=============================================================================== 0010e550 : #define MAXSYMLINK 5 int IMFS_Set_handlers( rtems_filesystem_location_info_t *loc ) { 10e550: 55 push %ebp 10e551: 89 e5 mov %esp,%ebp 10e553: 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; 10e556: 8b 50 10 mov 0x10(%eax),%edx 10e559: 8b 4a 34 mov 0x34(%edx),%ecx switch( node->type ) { 10e55c: 8b 10 mov (%eax),%edx 10e55e: 83 7a 4c 07 cmpl $0x7,0x4c(%edx) 10e562: 77 12 ja 10e576 <== NEVER TAKEN 10e564: 8b 52 4c mov 0x4c(%edx),%edx 10e567: ff 24 95 30 02 12 00 jmp *0x120230(,%edx,4) 10e56e: 66 90 xchg %ax,%ax case IMFS_DIRECTORY: loc->handlers = fs_info->directory_handlers; 10e570: 8b 51 0c mov 0xc(%ecx),%edx 10e573: 89 50 08 mov %edx,0x8(%eax) loc->handlers = fs_info->fifo_handlers; break; } return 0; } 10e576: 31 c0 xor %eax,%eax 10e578: c9 leave 10e579: c3 ret 10e57a: 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; 10e57c: 8b 51 08 mov 0x8(%ecx),%edx 10e57f: 89 50 08 mov %edx,0x8(%eax) loc->handlers = fs_info->fifo_handlers; break; } return 0; } 10e582: 31 c0 xor %eax,%eax 10e584: c9 leave 10e585: c3 ret 10e586: 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; 10e588: c7 40 08 e0 02 12 00 movl $0x1202e0,0x8(%eax) loc->handlers = fs_info->fifo_handlers; break; } return 0; } 10e58f: 31 c0 xor %eax,%eax 10e591: c9 leave 10e592: c3 ret 10e593: 90 nop break; case IMFS_MEMORY_FILE: loc->handlers = fs_info->memfile_handlers; break; case IMFS_FIFO: loc->handlers = fs_info->fifo_handlers; 10e594: 8b 51 10 mov 0x10(%ecx),%edx 10e597: 89 50 08 mov %edx,0x8(%eax) break; } return 0; } 10e59a: 31 c0 xor %eax,%eax 10e59c: c9 leave 10e59d: c3 ret 10e59e: 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; 10e5a0: c7 40 08 60 02 12 00 movl $0x120260,0x8(%eax) loc->handlers = fs_info->fifo_handlers; break; } return 0; } 10e5a7: 31 c0 xor %eax,%eax 10e5a9: c9 leave 10e5aa: c3 ret =============================================================================== 0010ee98 : void IMFS_check_node_remove( IMFS_jnode_t *jnode ) { 10ee98: 55 push %ebp 10ee99: 89 e5 mov %esp,%ebp 10ee9b: 53 push %ebx 10ee9c: 83 ec 10 sub $0x10,%esp 10ee9f: 8b 5d 08 mov 0x8(%ebp),%ebx if ( !rtems_libio_is_file_open( jnode ) && jnode->st_nlink < 1 ) { 10eea2: 53 push %ebx 10eea3: e8 2c 05 00 00 call 10f3d4 10eea8: 83 c4 10 add $0x10,%esp 10eeab: 85 c0 test %eax,%eax 10eead: 75 2d jne 10eedc 10eeaf: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) 10eeb4: 75 26 jne 10eedc if ( rtems_filesystem_current.node_access == jnode ) 10eeb6: a1 b0 41 12 00 mov 0x1241b0,%eax 10eebb: 39 58 04 cmp %ebx,0x4(%eax) 10eebe: 74 58 je 10ef18 <== NEVER TAKEN rtems_filesystem_current.node_access = NULL; switch ( jnode->type ) { 10eec0: 8b 43 4c mov 0x4c(%ebx),%eax 10eec3: 83 f8 04 cmp $0x4,%eax 10eec6: 74 34 je 10eefc 10eec8: 83 f8 05 cmp $0x5,%eax 10eecb: 74 17 je 10eee4 break; default: break; } free( jnode ); 10eecd: 89 5d 08 mov %ebx,0x8(%ebp) } } 10eed0: 8b 5d fc mov -0x4(%ebp),%ebx 10eed3: c9 leave break; default: break; } free( jnode ); 10eed4: e9 5b 87 ff ff jmp 107634 10eed9: 8d 76 00 lea 0x0(%esi),%esi } } 10eedc: 8b 5d fc mov -0x4(%ebp),%ebx 10eedf: c9 leave 10eee0: c3 ret 10eee1: 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 ); 10eee4: 83 ec 0c sub $0xc,%esp 10eee7: 53 push %ebx 10eee8: e8 7b 1e 00 00 call 110d68 break; 10eeed: 83 c4 10 add $0x10,%esp break; default: break; } free( jnode ); 10eef0: 89 5d 08 mov %ebx,0x8(%ebp) } } 10eef3: 8b 5d fc mov -0x4(%ebp),%ebx 10eef6: c9 leave break; default: break; } free( jnode ); 10eef7: e9 38 87 ff ff jmp 107634 switch ( jnode->type ) { case IMFS_MEMORY_FILE: IMFS_memfile_remove( jnode ); break; case IMFS_SYM_LINK: free( jnode->info.sym_link.name ); 10eefc: 83 ec 0c sub $0xc,%esp 10eeff: ff 73 50 pushl 0x50(%ebx) 10ef02: e8 2d 87 ff ff call 107634 break; 10ef07: 83 c4 10 add $0x10,%esp default: break; } free( jnode ); 10ef0a: 89 5d 08 mov %ebx,0x8(%ebp) } } 10ef0d: 8b 5d fc mov -0x4(%ebp),%ebx 10ef10: c9 leave break; default: break; } free( jnode ); 10ef11: e9 1e 87 ff ff jmp 107634 10ef16: 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; 10ef18: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) 10ef1f: eb 9f jmp 10eec0 =============================================================================== 0010e3e4 : IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) { 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 45 08 mov 0x8(%ebp),%eax 10e3f0: 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 ) 10e3f3: 85 c0 test %eax,%eax 10e3f5: 0f 84 ba 00 00 00 je 10e4b5 <== NEVER TAKEN return NULL; parent = parent_loc->node_access; 10e3fb: 8b 38 mov (%eax),%edi fs_info = parent_loc->mt_entry->fs_info; 10e3fd: 8b 40 10 mov 0x10(%eax),%eax 10e400: 8b 70 34 mov 0x34(%eax),%esi /* * Reject creation of FIFOs if support is disabled. */ if ( type == IMFS_FIFO && 10e403: 83 fb 07 cmp $0x7,%ebx 10e406: 0f 84 9c 00 00 00 je 10e4a8 return NULL; /* * Allocate filesystem node and fill in basic information */ node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask ); 10e40c: 50 push %eax 10e40d: a1 b0 41 12 00 mov 0x1241b0,%eax 10e412: 8b 40 2c mov 0x2c(%eax),%eax 10e415: f7 d0 not %eax 10e417: 23 45 14 and 0x14(%ebp),%eax 10e41a: 50 push %eax 10e41b: ff 75 10 pushl 0x10(%ebp) 10e41e: 53 push %ebx 10e41f: e8 54 ff ff ff call 10e378 if ( !node ) 10e424: 83 c4 10 add $0x10,%esp 10e427: 85 c0 test %eax,%eax 10e429: 74 73 je 10e49e return NULL; /* * Set the type specific information */ if ( type == IMFS_DIRECTORY ) { 10e42b: 83 fb 01 cmp $0x1,%ebx 10e42e: 74 38 je 10e468 rtems_chain_initialize_empty(&node->info.directory.Entries); } else if ( type == IMFS_HARD_LINK ) { 10e430: 83 fb 03 cmp $0x3,%ebx 10e433: 0f 84 97 00 00 00 je 10e4d0 node->info.hard_link.link_node = info->hard_link.link_node; } else if ( type == IMFS_SYM_LINK ) { 10e439: 83 fb 04 cmp $0x4,%ebx 10e43c: 0f 84 8e 00 00 00 je 10e4d0 node->info.sym_link.name = info->sym_link.name; } else if ( type == IMFS_DEVICE ) { 10e442: 83 fb 02 cmp $0x2,%ebx 10e445: 74 79 je 10e4c0 node->info.device.major = info->device.major; node->info.device.minor = info->device.minor; } else if ( type == IMFS_LINEAR_FILE ) { 10e447: 83 fb 06 cmp $0x6,%ebx 10e44a: 0f 84 8c 00 00 00 je 10e4dc node->info.linearfile.size = 0; node->info.linearfile.direct = 0; } else if ( type == IMFS_MEMORY_FILE ) { 10e450: 83 fb 05 cmp $0x5,%ebx 10e453: 0f 84 9b 00 00 00 je 10e4f4 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 ) { 10e459: 83 fb 07 cmp $0x7,%ebx 10e45c: 75 1d jne 10e47b <== NEVER TAKEN node->info.fifo.pipe = NULL; 10e45e: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10e465: eb 14 jmp 10e47b 10e467: 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 ); 10e468: 8d 50 54 lea 0x54(%eax),%edx 10e46b: 89 50 50 mov %edx,0x50(%eax) head->next = tail; head->previous = NULL; 10e46e: 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 ); 10e475: 8d 50 50 lea 0x50(%eax),%edx 10e478: 89 50 58 mov %edx,0x58(%eax) } /* * This node MUST have a parent, so put it in that directory list. */ node->Parent = parent; 10e47b: 89 78 08 mov %edi,0x8(%eax) node->st_ino = ++fs_info->ino_count; 10e47e: 8b 56 04 mov 0x4(%esi),%edx 10e481: 42 inc %edx 10e482: 89 56 04 mov %edx,0x4(%esi) 10e485: 89 50 38 mov %edx,0x38(%eax) 10e488: 83 ec 08 sub $0x8,%esp 10e48b: 50 push %eax rtems_chain_append( &parent->info.directory.Entries, &node->Node ); 10e48c: 83 c7 50 add $0x50,%edi 10e48f: 57 push %edi 10e490: 89 45 e4 mov %eax,-0x1c(%ebp) 10e493: e8 ec cf ff ff call 10b484 <_Chain_Append> return node; 10e498: 83 c4 10 add $0x10,%esp 10e49b: 8b 45 e4 mov -0x1c(%ebp),%eax } 10e49e: 8d 65 f4 lea -0xc(%ebp),%esp 10e4a1: 5b pop %ebx 10e4a2: 5e pop %esi 10e4a3: 5f pop %edi 10e4a4: c9 leave 10e4a5: c3 ret 10e4a6: 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 && 10e4a8: 81 7e 10 c0 01 12 00 cmpl $0x1201c0,0x10(%esi) 10e4af: 0f 85 57 ff ff ff jne 10e40c fs_info->fifo_handlers == &rtems_filesystem_handlers_default ) return NULL; 10e4b5: 31 c0 xor %eax,%eax node->st_ino = ++fs_info->ino_count; rtems_chain_append( &parent->info.directory.Entries, &node->Node ); return node; } 10e4b7: 8d 65 f4 lea -0xc(%ebp),%esp 10e4ba: 5b pop %ebx 10e4bb: 5e pop %esi 10e4bc: 5f pop %edi 10e4bd: c9 leave 10e4be: c3 ret 10e4bf: 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; 10e4c0: 8b 4d 18 mov 0x18(%ebp),%ecx 10e4c3: 8b 11 mov (%ecx),%edx 10e4c5: 89 50 50 mov %edx,0x50(%eax) node->info.device.minor = info->device.minor; 10e4c8: 8b 51 04 mov 0x4(%ecx),%edx 10e4cb: 89 50 54 mov %edx,0x54(%eax) 10e4ce: eb ab jmp 10e47b 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; 10e4d0: 8b 4d 18 mov 0x18(%ebp),%ecx 10e4d3: 8b 11 mov (%ecx),%edx 10e4d5: 89 50 50 mov %edx,0x50(%eax) 10e4d8: eb a1 jmp 10e47b 10e4da: 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; 10e4dc: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10e4e3: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.linearfile.direct = 0; 10e4ea: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) 10e4f1: eb 88 jmp 10e47b 10e4f3: 90 nop } else if ( type == IMFS_MEMORY_FILE ) { node->info.file.size = 0; 10e4f4: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10e4fb: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.file.indirect = 0; 10e502: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) node->info.file.doubly_indirect = 0; 10e509: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) node->info.file.triply_indirect = 0; 10e510: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) 10e517: e9 5f ff ff ff jmp 10e47b =============================================================================== 00109a58 : */ void IMFS_dump_directory( IMFS_jnode_t *the_directory, int level ) { 109a58: 55 push %ebp 109a59: 89 e5 mov %esp,%ebp 109a5b: 57 push %edi 109a5c: 56 push %esi 109a5d: 53 push %ebx 109a5e: 83 ec 1c sub $0x1c,%esp 109a61: 8b 45 08 mov 0x8(%ebp),%eax 109a64: 8b 75 0c mov 0xc(%ebp),%esi * */ int IMFS_memfile_maximum_size( void ) { return IMFS_MEMFILE_MAXIMUM_SIZE; } 109a67: 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)); 109a6a: 83 c0 54 add $0x54,%eax 109a6d: 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 ); 109a70: 39 c7 cmp %eax,%edi 109a72: 74 47 je 109abb 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 ); 109a74: 8d 46 01 lea 0x1(%esi),%eax 109a77: 89 45 e0 mov %eax,-0x20(%ebp) 109a7a: 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++ ) 109a7c: 85 f6 test %esi,%esi 109a7e: 78 22 js 109aa2 <== NEVER TAKEN 109a80: 31 db xor %ebx,%ebx 109a82: 66 90 xchg %ax,%ax fprintf(stdout, "...." ); 109a84: a1 00 ab 12 00 mov 0x12ab00,%eax 109a89: ff 70 08 pushl 0x8(%eax) 109a8c: 6a 04 push $0x4 109a8e: 6a 01 push $0x1 109a90: 68 12 5b 12 00 push $0x125b12 109a95: e8 be d5 00 00 call 117058 !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++ ) 109a9a: 43 inc %ebx 109a9b: 83 c4 10 add $0x10,%esp 109a9e: 39 de cmp %ebx,%esi 109aa0: 7d e2 jge 109a84 fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); 109aa2: 83 ec 0c sub $0xc,%esp 109aa5: 57 push %edi 109aa6: e8 75 fe ff ff call 109920 if ( the_jnode->type == IMFS_DIRECTORY ) 109aab: 83 c4 10 add $0x10,%esp 109aae: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 109ab2: 74 10 je 109ac4 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 ) { 109ab4: 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 ); 109ab6: 3b 7d e4 cmp -0x1c(%ebp),%edi 109ab9: 75 c1 jne 109a7c fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); if ( the_jnode->type == IMFS_DIRECTORY ) IMFS_dump_directory( the_jnode, level + 1 ); } } 109abb: 8d 65 f4 lea -0xc(%ebp),%esp 109abe: 5b pop %ebx 109abf: 5e pop %esi 109ac0: 5f pop %edi 109ac1: c9 leave 109ac2: c3 ret 109ac3: 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 ); 109ac4: 83 ec 08 sub $0x8,%esp 109ac7: ff 75 e0 pushl -0x20(%ebp) 109aca: 57 push %edi 109acb: e8 88 ff ff ff call 109a58 109ad0: 83 c4 10 add $0x10,%esp 109ad3: eb df jmp 109ab4 =============================================================================== 0010e62c : const char *pathname, /* IN */ size_t pathnamelen, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10e62c: 55 push %ebp 10e62d: 89 e5 mov %esp,%ebp 10e62f: 57 push %edi 10e630: 56 push %esi 10e631: 53 push %ebx 10e632: 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 ) ) { 10e635: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp) 10e63c: 0f 85 ee 01 00 00 jne 10e830 <== NEVER TAKEN /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10e642: 8b 45 14 mov 0x14(%ebp),%eax 10e645: 8b 38 mov (%eax),%edi size_t pathnamelen, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { int i = 0; 10e647: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp) 10e64e: 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 ); 10e651: 8d 55 e4 lea -0x1c(%ebp),%edx 10e654: 52 push %edx 10e655: 56 push %esi 10e656: ff 75 0c pushl 0xc(%ebp) 10e659: 8b 45 08 mov 0x8(%ebp),%eax 10e65c: 03 45 a4 add -0x5c(%ebp),%eax 10e65f: 50 push %eax 10e660: e8 17 07 00 00 call 10ed7c 10e665: 89 c3 mov %eax,%ebx pathnamelen -= len; 10e667: 8b 55 e4 mov -0x1c(%ebp),%edx i += len; if ( !pathloc->node_access ) 10e66a: 8b 4d 14 mov 0x14(%ebp),%ecx 10e66d: 8b 01 mov (%ecx),%eax 10e66f: 83 c4 10 add $0x10,%esp 10e672: 85 c0 test %eax,%eax 10e674: 0f 84 e6 00 00 00 je 10e760 <== NEVER TAKEN */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], pathnamelen, token, &len ); pathnamelen -= len; 10e67a: 29 55 0c sub %edx,0xc(%ebp) i += len; 10e67d: 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 ) 10e680: 85 db test %ebx,%ebx 10e682: 75 44 jne 10e6c8 * 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 ) { 10e684: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 10e688: 0f 84 26 01 00 00 je 10e7b4 flags, pathloc ); } else { result = IMFS_Set_handlers( pathloc ); } } else { result = IMFS_Set_handlers( pathloc ); 10e68e: 83 ec 0c sub $0xc,%esp 10e691: ff 75 14 pushl 0x14(%ebp) 10e694: e8 b7 fe ff ff call 10e550 10e699: 89 c3 mov %eax,%ebx 10e69b: 5a pop %edx 10e69c: 59 pop %ecx /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) 10e69d: ff 75 10 pushl 0x10(%ebp) 10e6a0: ff 75 14 pushl 0x14(%ebp) 10e6a3: e8 04 ff ff ff call 10e5ac 10e6a8: 83 c4 10 add $0x10,%esp 10e6ab: 85 c0 test %eax,%eax 10e6ad: 0f 85 d1 00 00 00 jne 10e784 rtems_set_errno_and_return_minus_one( EACCES ); 10e6b3: e8 24 37 00 00 call 111ddc <__errno> 10e6b8: c7 00 0d 00 00 00 movl $0xd,(%eax) 10e6be: bb ff ff ff ff mov $0xffffffff,%ebx 10e6c3: e9 bc 00 00 00 jmp 10e784 /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) 10e6c8: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10e6cc: 0f 84 be 00 00 00 je 10e790 if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); node = pathloc->node_access; 10e6d2: 89 c7 mov %eax,%edi switch( type ) { 10e6d4: 83 fb 03 cmp $0x3,%ebx 10e6d7: 74 1b je 10e6f4 10e6d9: 83 fb 04 cmp $0x4,%ebx 10e6dc: 0f 84 92 00 00 00 je 10e774 10e6e2: 83 fb 02 cmp $0x2,%ebx 10e6e5: 74 51 je 10e738 /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 10e6e7: 83 fb 04 cmp $0x4,%ebx 10e6ea: 0f 85 61 ff ff ff jne 10e651 <== ALWAYS TAKEN 10e6f0: eb 92 jmp 10e684 <== NOT EXECUTED 10e6f2: 66 90 xchg %ax,%ax <== NOT EXECUTED case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { 10e6f4: 8b 40 4c mov 0x4c(%eax),%eax 10e6f7: 83 f8 03 cmp $0x3,%eax 10e6fa: 0f 84 08 01 00 00 je 10e808 * It would be a design error if we evaluated the link and * was broken. */ IMFS_assert( node ); } else if ( node->type == IMFS_SYM_LINK ) { 10e700: 83 f8 04 cmp $0x4,%eax 10e703: 0f 84 51 01 00 00 je 10e85a } /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10e709: 48 dec %eax 10e70a: 0f 85 35 01 00 00 jne 10e845 /* * 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 ) { 10e710: 8b 47 5c mov 0x5c(%edi),%eax 10e713: 85 c0 test %eax,%eax 10e715: 0f 85 a4 00 00 00 jne 10e7bf } /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10e71b: 83 ec 08 sub $0x8,%esp 10e71e: 56 push %esi 10e71f: 57 push %edi 10e720: e8 eb 05 00 00 call 10ed10 10e725: 89 c7 mov %eax,%edi if ( !node ) 10e727: 83 c4 10 add $0x10,%esp 10e72a: 85 c0 test %eax,%eax 10e72c: 74 32 je 10e760 /* * Set the node access to the point we have found. */ pathloc->node_access = node; 10e72e: 8b 45 14 mov 0x14(%ebp),%eax 10e731: 89 38 mov %edi,(%eax) 10e733: e9 19 ff ff ff jmp 10e651 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10e738: 8b 15 b0 41 12 00 mov 0x1241b0,%edx 10e73e: 39 42 18 cmp %eax,0x18(%edx) 10e741: 0f 84 0a ff ff ff je 10e651 /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access) { 10e747: 8b 4d 14 mov 0x14(%ebp),%ecx 10e74a: 8b 51 10 mov 0x10(%ecx),%edx /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == 10e74d: 39 42 1c cmp %eax,0x1c(%edx) 10e750: 0f 84 d2 00 00 00 je 10e828 pathnamelen+len, flags,pathloc); } } else { if ( !node->Parent ) 10e756: 8b 78 08 mov 0x8(%eax),%edi 10e759: 85 ff test %edi,%edi 10e75b: 75 d1 jne 10e72e 10e75d: 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 ); 10e760: e8 77 36 00 00 call 111ddc <__errno> 10e765: c7 00 02 00 00 00 movl $0x2,(%eax) 10e76b: bb ff ff ff ff mov $0xffffffff,%ebx 10e770: eb 12 jmp 10e784 10e772: 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 ); 10e774: e8 63 36 00 00 call 111ddc <__errno> 10e779: c7 00 5b 00 00 00 movl $0x5b,(%eax) 10e77f: bb ff ff ff ff mov $0xffffffff,%ebx if ( !IMFS_evaluate_permission( pathloc, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10e784: 89 d8 mov %ebx,%eax 10e786: 8d 65 f4 lea -0xc(%ebp),%esp 10e789: 5b pop %ebx 10e78a: 5e pop %esi 10e78b: 5f pop %edi 10e78c: c9 leave 10e78d: c3 ret 10e78e: 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 ) ) 10e790: 83 ec 08 sub $0x8,%esp 10e793: 6a 01 push $0x1 10e795: ff 75 14 pushl 0x14(%ebp) 10e798: e8 0f fe ff ff call 10e5ac 10e79d: 83 c4 10 add $0x10,%esp 10e7a0: 85 c0 test %eax,%eax 10e7a2: 0f 84 0b ff ff ff je 10e6b3 10e7a8: 8b 55 14 mov 0x14(%ebp),%edx 10e7ab: 8b 02 mov (%edx),%eax 10e7ad: e9 20 ff ff ff jmp 10e6d2 10e7b2: 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 ) { 10e7b4: 8b 40 5c mov 0x5c(%eax),%eax 10e7b7: 85 c0 test %eax,%eax 10e7b9: 0f 84 cf fe ff ff je 10e68e newloc = node->info.directory.mt_fs->mt_fs_root; 10e7bf: 8d 7d d0 lea -0x30(%ebp),%edi 10e7c2: 8d 70 1c lea 0x1c(%eax),%esi 10e7c5: b9 05 00 00 00 mov $0x5,%ecx 10e7ca: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10e7cc: 8d 75 d0 lea -0x30(%ebp),%esi 10e7cf: b1 05 mov $0x5,%cl 10e7d1: 8b 7d 14 mov 0x14(%ebp),%edi 10e7d4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalpath_h)( &pathname[i-len], 10e7d6: 8b 55 e4 mov -0x1c(%ebp),%edx 10e7d9: 8b 4d 14 mov 0x14(%ebp),%ecx 10e7dc: 8b 41 0c mov 0xc(%ecx),%eax 10e7df: 51 push %ecx 10e7e0: ff 75 10 pushl 0x10(%ebp) 10e7e3: 8b 4d 0c mov 0xc(%ebp),%ecx 10e7e6: 01 d1 add %edx,%ecx 10e7e8: 51 push %ecx 10e7e9: 8b 4d a4 mov -0x5c(%ebp),%ecx 10e7ec: 29 d1 sub %edx,%ecx 10e7ee: 8b 55 08 mov 0x8(%ebp),%edx 10e7f1: 01 ca add %ecx,%edx 10e7f3: 52 push %edx 10e7f4: ff 10 call *(%eax) 10e7f6: 89 c3 mov %eax,%ebx 10e7f8: 83 c4 10 add $0x10,%esp if ( !IMFS_evaluate_permission( pathloc, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10e7fb: 89 d8 mov %ebx,%eax 10e7fd: 8d 65 f4 lea -0xc(%ebp),%esp 10e800: 5b pop %ebx 10e801: 5e pop %esi 10e802: 5f pop %edi 10e803: c9 leave 10e804: c3 ret 10e805: 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 ); 10e808: 83 ec 08 sub $0x8,%esp 10e80b: 6a 00 push $0x0 10e80d: ff 75 14 pushl 0x14(%ebp) 10e810: e8 d3 fd ff ff call 10e5e8 node = pathloc->node_access; 10e815: 8b 55 14 mov 0x14(%ebp),%edx 10e818: 8b 3a mov (%edx),%edi 10e81a: 8b 47 4c mov 0x4c(%edi),%eax 10e81d: 83 c4 10 add $0x10,%esp 10e820: e9 e4 fe ff ff jmp 10e709 10e825: 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; 10e828: 8d 7d d0 lea -0x30(%ebp),%edi 10e82b: 8d 72 08 lea 0x8(%edx),%esi 10e82e: eb 95 jmp 10e7c5 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 ); 10e830: e8 a7 35 00 00 call 111ddc <__errno> <== NOT EXECUTED 10e835: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 10e83b: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10e840: e9 3f ff ff ff jmp 10e784 <== NOT EXECUTED /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 10e845: e8 92 35 00 00 call 111ddc <__errno> 10e84a: c7 00 14 00 00 00 movl $0x14,(%eax) 10e850: bb ff ff ff ff mov $0xffffffff,%ebx 10e855: e9 2a ff ff ff jmp 10e784 * was broken. */ IMFS_assert( node ); } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_sym_link( pathloc, 0 ); 10e85a: 83 ec 08 sub $0x8,%esp 10e85d: 6a 00 push $0x0 10e85f: ff 75 14 pushl 0x14(%ebp) 10e862: e8 1d 00 00 00 call 10e884 10e867: 89 c3 mov %eax,%ebx /* * In contrast to a hard link, it is possible to have a broken * symbolic link. */ node = pathloc->node_access; 10e869: 8b 4d 14 mov 0x14(%ebp),%ecx 10e86c: 8b 39 mov (%ecx),%edi if ( result == -1 ) 10e86e: 83 c4 10 add $0x10,%esp 10e871: 83 f8 ff cmp $0xffffffff,%eax 10e874: 0f 84 0a ff ff ff je 10e784 <== NEVER TAKEN /* * In contrast to a hard link, it is possible to have a broken * symbolic link. */ node = pathloc->node_access; 10e87a: 8b 47 4c mov 0x4c(%edi),%eax 10e87d: e9 87 fe ff ff jmp 10e709 =============================================================================== 0010e9ac : int IMFS_evaluate_for_make( const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) { 10e9ac: 55 push %ebp 10e9ad: 89 e5 mov %esp,%ebp 10e9af: 57 push %edi 10e9b0: 56 push %esi 10e9b1: 53 push %ebx 10e9b2: 83 ec 5c sub $0x5c,%esp /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10e9b5: 8b 45 0c mov 0xc(%ebp),%eax 10e9b8: 8b 18 mov (%eax),%ebx /* * Get the path length. */ pathlen = strlen( path ); 10e9ba: 31 c0 xor %eax,%eax 10e9bc: b9 ff ff ff ff mov $0xffffffff,%ecx 10e9c1: 8b 7d 08 mov 0x8(%ebp),%edi 10e9c4: f2 ae repnz scas %es:(%edi),%al 10e9c6: f7 d1 not %ecx 10e9c8: 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; 10e9cb: 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 ); 10e9d2: 8d 55 e4 lea -0x1c(%ebp),%edx 10e9d5: 52 push %edx 10e9d6: 8d 4d af lea -0x51(%ebp),%ecx 10e9d9: 51 push %ecx 10e9da: 56 push %esi 10e9db: 8b 45 08 mov 0x8(%ebp),%eax 10e9de: 03 45 a4 add -0x5c(%ebp),%eax 10e9e1: 50 push %eax 10e9e2: e8 95 03 00 00 call 10ed7c 10e9e7: 89 c7 mov %eax,%edi pathlen -= len; 10e9e9: 8b 55 e4 mov -0x1c(%ebp),%edx 10e9ec: 29 d6 sub %edx,%esi i += len; if ( !pathloc->node_access ) 10e9ee: 8b 4d 0c mov 0xc(%ebp),%ecx 10e9f1: 8b 01 mov (%ecx),%eax 10e9f3: 83 c4 10 add $0x10,%esp 10e9f6: 85 c0 test %eax,%eax 10e9f8: 0f 84 55 01 00 00 je 10eb53 <== NEVER TAKEN /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10e9fe: 85 ff test %edi,%edi 10ea00: 75 1a jne 10ea1c pathloc->node_access = node; break; case IMFS_NO_MORE_PATH: rtems_set_errno_and_return_minus_one( EEXIST ); 10ea02: e8 d5 33 00 00 call 111ddc <__errno> 10ea07: c7 00 11 00 00 00 movl $0x11,(%eax) 10ea0d: 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; } 10ea12: 89 d8 mov %ebx,%eax 10ea14: 8d 65 f4 lea -0xc(%ebp),%esp 10ea17: 5b pop %ebx 10ea18: 5e pop %esi 10ea19: 5f pop %edi 10ea1a: c9 leave 10ea1b: c3 ret /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) 10ea1c: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10ea20: 0f 84 c6 00 00 00 je 10eaec while( !done ) { type = IMFS_get_token( &path[i], pathlen, token, &len ); pathlen -= len; i += len; 10ea26: 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; 10ea29: 89 c3 mov %eax,%ebx switch( type ) { 10ea2b: 83 ff 02 cmp $0x2,%edi 10ea2e: 0f 84 88 00 00 00 je 10eabc 10ea34: 76 26 jbe 10ea5c 10ea36: 83 ff 03 cmp $0x3,%edi 10ea39: 74 2d je 10ea68 10ea3b: 83 ff 04 cmp $0x4,%edi 10ea3e: 75 92 jne 10e9d2 <== 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 ); 10ea40: e8 97 33 00 00 call 111ddc <__errno> 10ea45: c7 00 5b 00 00 00 movl $0x5b,(%eax) 10ea4b: 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; } 10ea50: 89 d8 mov %ebx,%eax 10ea52: 8d 65 f4 lea -0xc(%ebp),%esp 10ea55: 5b pop %ebx 10ea56: 5e pop %esi 10ea57: 5f pop %edi 10ea58: c9 leave 10ea59: c3 ret 10ea5a: 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 ) { 10ea5c: 85 ff test %edi,%edi 10ea5e: 74 a2 je 10ea02 <== NEVER TAKEN 10ea60: e9 6d ff ff ff jmp 10e9d2 10ea65: 8d 76 00 lea 0x0(%esi),%esi pathloc->node_access = node; break; case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { 10ea68: 8b 40 4c mov 0x4c(%eax),%eax 10ea6b: 83 f8 03 cmp $0x3,%eax 10ea6e: 0f 84 b4 01 00 00 je 10ec28 result = IMFS_evaluate_link( pathloc, 0 ); if ( result == -1 ) return -1; } else if ( node->type == IMFS_SYM_LINK ) { 10ea74: 83 f8 04 cmp $0x4,%eax 10ea77: 0f 84 ca 01 00 00 je 10ec47 if ( result == -1 ) return -1; } node = pathloc->node_access; if ( !node ) 10ea7d: 85 db test %ebx,%ebx 10ea7f: 0f 84 67 01 00 00 je 10ebec <== NEVER TAKEN /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10ea85: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10ea89: 0f 85 5d 01 00 00 jne 10ebec /* * 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 ) { 10ea8f: 8b 43 5c mov 0x5c(%ebx),%eax 10ea92: 85 c0 test %eax,%eax 10ea94: 0f 85 67 01 00 00 jne 10ec01 /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10ea9a: 83 ec 08 sub $0x8,%esp 10ea9d: 8d 45 af lea -0x51(%ebp),%eax 10eaa0: 50 push %eax 10eaa1: 53 push %ebx 10eaa2: e8 69 02 00 00 call 10ed10 10eaa7: 89 c3 mov %eax,%ebx /* * If there is no node we have found the name of the node we * wish to create. */ if ( ! node ) 10eaa9: 83 c4 10 add $0x10,%esp 10eaac: 85 c0 test %eax,%eax 10eaae: 74 64 je 10eb14 done = true; else pathloc->node_access = node; 10eab0: 8b 55 0c mov 0xc(%ebp),%edx 10eab3: 89 02 mov %eax,(%edx) 10eab5: e9 18 ff ff ff jmp 10e9d2 10eaba: 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 ) 10eabc: 8b 15 b0 41 12 00 mov 0x1241b0,%edx 10eac2: 3b 42 18 cmp 0x18(%edx),%eax 10eac5: 0f 84 07 ff ff ff je 10e9d2 /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){ 10eacb: 8b 4d 0c mov 0xc(%ebp),%ecx 10eace: 8b 51 10 mov 0x10(%ecx),%edx 10ead1: 3b 42 1c cmp 0x1c(%edx),%eax 10ead4: 0f 84 8e 00 00 00 je 10eb68 *pathloc = newloc; return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); } } else { if ( !node->Parent ) 10eada: 8b 58 08 mov 0x8(%eax),%ebx 10eadd: 85 db test %ebx,%ebx 10eadf: 74 72 je 10eb53 rtems_set_errno_and_return_minus_one( ENOENT ); node = node->Parent; } pathloc->node_access = node; 10eae1: 8b 4d 0c mov 0xc(%ebp),%ecx 10eae4: 89 19 mov %ebx,(%ecx) break; 10eae6: e9 e7 fe ff ff jmp 10e9d2 10eaeb: 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 ) ) 10eaec: 83 ec 08 sub $0x8,%esp 10eaef: 6a 01 push $0x1 10eaf1: ff 75 0c pushl 0xc(%ebp) 10eaf4: 89 55 a0 mov %edx,-0x60(%ebp) 10eaf7: e8 b0 fa ff ff call 10e5ac 10eafc: 83 c4 10 add $0x10,%esp 10eaff: 85 c0 test %eax,%eax 10eb01: 8b 55 a0 mov -0x60(%ebp),%edx 10eb04: 0f 84 cd 00 00 00 je 10ebd7 10eb0a: 8b 4d 0c mov 0xc(%ebp),%ecx 10eb0d: 8b 01 mov (%ecx),%eax 10eb0f: e9 12 ff ff ff jmp 10ea26 case IMFS_CURRENT_DIR: break; } } *name = &path[ i - len ]; 10eb14: 8b 45 a4 mov -0x5c(%ebp),%eax 10eb17: 2b 45 e4 sub -0x1c(%ebp),%eax 10eb1a: 03 45 08 add 0x8(%ebp),%eax 10eb1d: 8b 4d 10 mov 0x10(%ebp),%ecx 10eb20: 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++) { 10eb22: 8b 4d 08 mov 0x8(%ebp),%ecx 10eb25: 8b 55 a4 mov -0x5c(%ebp),%edx 10eb28: 8a 04 11 mov (%ecx,%edx,1),%al 10eb2b: 84 c0 test %al,%al 10eb2d: 74 75 je 10eba4 10eb2f: 89 d3 mov %edx,%ebx 10eb31: 89 ce mov %ecx,%esi 10eb33: eb 0b jmp 10eb40 10eb35: 8d 76 00 lea 0x0(%esi),%esi 10eb38: 43 inc %ebx 10eb39: 8a 04 1e mov (%esi,%ebx,1),%al 10eb3c: 84 c0 test %al,%al 10eb3e: 74 64 je 10eba4 if ( !IMFS_is_separator( path[ i ] ) ) 10eb40: 83 ec 0c sub $0xc,%esp 10eb43: 0f be c0 movsbl %al,%eax 10eb46: 50 push %eax 10eb47: e8 74 99 ff ff call 1084c0 10eb4c: 83 c4 10 add $0x10,%esp 10eb4f: 85 c0 test %eax,%eax 10eb51: 75 e5 jne 10eb38 rtems_set_errno_and_return_minus_one( ENOENT ); 10eb53: e8 84 32 00 00 call 111ddc <__errno> 10eb58: c7 00 02 00 00 00 movl $0x2,(%eax) 10eb5e: bb ff ff ff ff mov $0xffffffff,%ebx 10eb63: e9 aa fe ff ff jmp 10ea12 if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; } else { newloc = pathloc->mt_entry->mt_point_node; 10eb68: 8d 7d d0 lea -0x30(%ebp),%edi 10eb6b: 8d 72 08 lea 0x8(%edx),%esi 10eb6e: b9 05 00 00 00 mov $0x5,%ecx 10eb73: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10eb75: 8d 75 d0 lea -0x30(%ebp),%esi 10eb78: b1 05 mov $0x5,%cl 10eb7a: 8b 7d 0c mov 0xc(%ebp),%edi 10eb7d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10eb7f: 53 push %ebx 10eb80: 8b 55 0c mov 0xc(%ebp),%edx 10eb83: 8b 42 0c mov 0xc(%edx),%eax 10eb86: ff 75 10 pushl 0x10(%ebp) 10eb89: 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 ); 10eb8a: 8b 55 a4 mov -0x5c(%ebp),%edx 10eb8d: 2b 55 e4 sub -0x1c(%ebp),%edx 10eb90: 03 55 08 add 0x8(%ebp),%edx 10eb93: 52 push %edx 10eb94: ff 50 04 call *0x4(%eax) 10eb97: 89 c3 mov %eax,%ebx 10eb99: 83 c4 10 add $0x10,%esp 10eb9c: e9 71 fe ff ff jmp 10ea12 10eba1: 8d 76 00 lea 0x0(%esi),%esi /* * Verify we can execute and write to this directory. */ result = IMFS_Set_handlers( pathloc ); 10eba4: 83 ec 0c sub $0xc,%esp 10eba7: ff 75 0c pushl 0xc(%ebp) 10ebaa: e8 a1 f9 ff ff call 10e550 10ebaf: 89 c3 mov %eax,%ebx /* * The returned node must be a directory */ node = pathloc->node_access; if ( node->type != IMFS_DIRECTORY ) 10ebb1: 8b 55 0c mov 0xc(%ebp),%edx 10ebb4: 8b 02 mov (%edx),%eax 10ebb6: 83 c4 10 add $0x10,%esp 10ebb9: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 10ebbd: 75 2d jne 10ebec <== NEVER TAKEN /* * We must have Write and execute permission on the returned node. */ if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) 10ebbf: 83 ec 08 sub $0x8,%esp 10ebc2: 6a 03 push $0x3 10ebc4: ff 75 0c pushl 0xc(%ebp) 10ebc7: e8 e0 f9 ff ff call 10e5ac 10ebcc: 83 c4 10 add $0x10,%esp 10ebcf: 85 c0 test %eax,%eax 10ebd1: 0f 85 3b fe ff ff jne 10ea12 rtems_set_errno_and_return_minus_one( EACCES ); 10ebd7: e8 00 32 00 00 call 111ddc <__errno> 10ebdc: c7 00 0d 00 00 00 movl $0xd,(%eax) 10ebe2: bb ff ff ff ff mov $0xffffffff,%ebx 10ebe7: e9 26 fe ff ff jmp 10ea12 /* * The returned node must be a directory */ node = pathloc->node_access; if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 10ebec: e8 eb 31 00 00 call 111ddc <__errno> 10ebf1: c7 00 14 00 00 00 movl $0x14,(%eax) 10ebf7: bb ff ff ff ff mov $0xffffffff,%ebx 10ebfc: e9 11 fe ff ff jmp 10ea12 * 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; 10ec01: 8d 7d d0 lea -0x30(%ebp),%edi 10ec04: 8d 70 1c lea 0x1c(%eax),%esi 10ec07: b9 05 00 00 00 mov $0x5,%ecx 10ec0c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10ec0e: 8d 75 d0 lea -0x30(%ebp),%esi 10ec11: b1 05 mov $0x5,%cl 10ec13: 8b 7d 0c mov 0xc(%ebp),%edi 10ec16: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10ec18: 51 push %ecx 10ec19: 8b 4d 0c mov 0xc(%ebp),%ecx 10ec1c: 8b 41 0c mov 0xc(%ecx),%eax 10ec1f: ff 75 10 pushl 0x10(%ebp) 10ec22: 51 push %ecx 10ec23: e9 62 ff ff ff jmp 10eb8a case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { result = IMFS_evaluate_link( pathloc, 0 ); 10ec28: 83 ec 08 sub $0x8,%esp 10ec2b: 6a 00 push $0x0 10ec2d: ff 75 0c pushl 0xc(%ebp) 10ec30: e8 cb fc ff ff call 10e900 if ( result == -1 ) 10ec35: 83 c4 10 add $0x10,%esp 10ec38: 83 f8 ff cmp $0xffffffff,%eax 10ec3b: 74 29 je 10ec66 <== NEVER TAKEN 10ec3d: 8b 45 0c mov 0xc(%ebp),%eax 10ec40: 8b 18 mov (%eax),%ebx 10ec42: e9 36 fe ff ff jmp 10ea7d return -1; } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_link( pathloc, 0 ); 10ec47: 83 ec 08 sub $0x8,%esp 10ec4a: 6a 00 push $0x0 10ec4c: ff 75 0c pushl 0xc(%ebp) 10ec4f: e8 ac fc ff ff call 10e900 if ( result == -1 ) 10ec54: 83 c4 10 add $0x10,%esp 10ec57: 83 f8 ff cmp $0xffffffff,%eax 10ec5a: 74 0a je 10ec66 <== NEVER TAKEN 10ec5c: 8b 55 0c mov 0xc(%ebp),%edx 10ec5f: 8b 1a mov (%edx),%ebx 10ec61: e9 17 fe ff ff jmp 10ea7d 10ec66: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10ec68: e9 a5 fd ff ff jmp 10ea12 <== NOT EXECUTED =============================================================================== 0010e900 : */ int IMFS_evaluate_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10e900: 55 push %ebp 10e901: 89 e5 mov %esp,%ebp 10e903: 57 push %edi 10e904: 56 push %esi 10e905: 53 push %ebx 10e906: 83 ec 0c sub $0xc,%esp 10e909: 8b 75 08 mov 0x8(%ebp),%esi 10e90c: 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 ); 10e90f: 8b 15 b0 41 12 00 mov 0x1241b0,%edx 10e915: eb 0e jmp 10e925 10e917: 90 nop */ if ( jnode->type == IMFS_HARD_LINK ) result = IMFS_evaluate_hard_link( node, flags ); else if (jnode->type == IMFS_SYM_LINK ) 10e918: 83 f8 04 cmp $0x4,%eax 10e91b: 74 53 je 10e970 result = IMFS_evaluate_sym_link( node, flags ); } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || 10e91d: 83 e8 03 sub $0x3,%eax 10e920: 83 f8 01 cmp $0x1,%eax 10e923: 77 3a ja 10e95f <== ALWAYS TAKEN { IMFS_jnode_t *jnode; int result = 0; do { jnode = node->node_access; 10e925: 8b 1e mov (%esi),%ebx /* * Increment and check the link counter. */ rtems_filesystem_link_counts ++; 10e927: 8b 42 30 mov 0x30(%edx),%eax 10e92a: 40 inc %eax 10e92b: 66 89 42 30 mov %ax,0x30(%edx) if ( rtems_filesystem_link_counts > MAXSYMLINK ) { 10e92f: 66 83 f8 05 cmp $0x5,%ax 10e933: 77 57 ja 10e98c /* * Follow the Link node. */ if ( jnode->type == IMFS_HARD_LINK ) 10e935: 8b 43 4c mov 0x4c(%ebx),%eax 10e938: 83 f8 03 cmp $0x3,%eax 10e93b: 75 db jne 10e918 result = IMFS_evaluate_hard_link( node, flags ); 10e93d: 83 ec 08 sub $0x8,%esp 10e940: 57 push %edi 10e941: 56 push %esi 10e942: e8 a1 fc ff ff call 10e5e8 10e947: 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 ) ) ); 10e94a: 85 c0 test %eax,%eax 10e94c: 75 33 jne 10e981 10e94e: 8b 43 4c mov 0x4c(%ebx),%eax 10e951: 8b 15 b0 41 12 00 mov 0x1241b0,%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 ) || 10e957: 83 e8 03 sub $0x3,%eax 10e95a: 83 f8 01 cmp $0x1,%eax 10e95d: 76 c6 jbe 10e925 <== ALWAYS TAKEN 10e95f: 31 c0 xor %eax,%eax /* * Clear link counter. */ rtems_filesystem_link_counts = 0; 10e961: 66 c7 42 30 00 00 movw $0x0,0x30(%edx) return result; } 10e967: 8d 65 f4 lea -0xc(%ebp),%esp 10e96a: 5b pop %ebx 10e96b: 5e pop %esi 10e96c: 5f pop %edi 10e96d: c9 leave 10e96e: c3 ret 10e96f: 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 ); 10e970: 83 ec 08 sub $0x8,%esp 10e973: 57 push %edi 10e974: 56 push %esi 10e975: e8 0a ff ff ff call 10e884 10e97a: 83 c4 10 add $0x10,%esp } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || ( jnode->type == IMFS_HARD_LINK ) ) ); 10e97d: 85 c0 test %eax,%eax 10e97f: 74 cd je 10e94e 10e981: 8b 15 b0 41 12 00 mov 0x1241b0,%edx 10e987: eb d8 jmp 10e961 10e989: 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; 10e98c: 66 c7 42 30 00 00 movw $0x0,0x30(%edx) rtems_set_errno_and_return_minus_one( ELOOP ); 10e992: e8 45 34 00 00 call 111ddc <__errno> 10e997: c7 00 5c 00 00 00 movl $0x5c,(%eax) 10e99d: b8 ff ff ff ff mov $0xffffffff,%eax */ rtems_filesystem_link_counts = 0; return result; } 10e9a2: 8d 65 f4 lea -0xc(%ebp),%esp 10e9a5: 5b pop %ebx 10e9a6: 5e pop %esi 10e9a7: 5f pop %edi 10e9a8: c9 leave 10e9a9: c3 ret =============================================================================== 0010e5ac : */ int IMFS_evaluate_permission( rtems_filesystem_location_info_t *node, int flags ) { 10e5ac: 55 push %ebp 10e5ad: 89 e5 mov %esp,%ebp 10e5af: 83 ec 08 sub $0x8,%esp 10e5b2: 8b 45 0c mov 0xc(%ebp),%eax uid_t st_uid; gid_t st_gid; IMFS_jnode_t *jnode; int flags_to_test; if ( !rtems_libio_is_valid_perms( flags ) ) 10e5b5: a9 f8 ff ff ff test $0xfffffff8,%eax 10e5ba: 75 18 jne 10e5d4 <== NEVER TAKEN */ flags_to_test = flags; if ( st_uid == jnode->st_uid ) flags_to_test <<= 6; 10e5bc: c1 e0 06 shl $0x6,%eax /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10e5bf: 8b 55 08 mov 0x8(%ebp),%edx 10e5c2: 8b 12 mov (%edx),%edx 10e5c4: 8b 52 30 mov 0x30(%edx),%edx 10e5c7: 21 c2 and %eax,%edx 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 ); 10e5c9: 39 d0 cmp %edx,%eax 10e5cb: 0f 94 c0 sete %al 10e5ce: 0f b6 c0 movzbl %al,%eax */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) return 1; return 0; } 10e5d1: c9 leave 10e5d2: c3 ret 10e5d3: 90 nop 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 ); 10e5d4: e8 03 38 00 00 call 111ddc <__errno> <== NOT EXECUTED 10e5d9: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10e5df: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) return 1; return 0; } 10e5e4: c9 leave <== NOT EXECUTED 10e5e5: c3 ret <== NOT EXECUTED =============================================================================== 0010e884 : int IMFS_evaluate_sym_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10e884: 55 push %ebp 10e885: 89 e5 mov %esp,%ebp 10e887: 57 push %edi 10e888: 56 push %esi 10e889: 53 push %ebx 10e88a: 83 ec 20 sub $0x20,%esp 10e88d: 8b 5d 08 mov 0x8(%ebp),%ebx 10e890: 8b 75 0c mov 0xc(%ebp),%esi IMFS_jnode_t *jnode = node->node_access; 10e893: 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; 10e895: 8b 47 08 mov 0x8(%edi),%eax 10e898: 89 03 mov %eax,(%ebx) rtems_filesystem_get_sym_start_loc( 10e89a: 53 push %ebx 10e89b: 8d 45 e4 lea -0x1c(%ebp),%eax 10e89e: 50 push %eax 10e89f: ff 77 50 pushl 0x50(%edi) 10e8a2: e8 2d 0e 00 00 call 10f6d4 ); /* * Use eval path to evaluate the path of the symbolic link. */ result = IMFS_eval_path( 10e8a7: 8b 57 50 mov 0x50(%edi),%edx 10e8aa: 03 55 e4 add -0x1c(%ebp),%edx 10e8ad: 31 c0 xor %eax,%eax 10e8af: b9 ff ff ff ff mov $0xffffffff,%ecx 10e8b4: 89 d7 mov %edx,%edi 10e8b6: f2 ae repnz scas %es:(%edi),%al 10e8b8: f7 d1 not %ecx 10e8ba: 49 dec %ecx 10e8bb: 53 push %ebx 10e8bc: 56 push %esi 10e8bd: 51 push %ecx 10e8be: 52 push %edx 10e8bf: e8 68 fd ff ff call 10e62c 10e8c4: 89 c7 mov %eax,%edi strlen( &jnode->info.sym_link.name[i] ), flags, node ); IMFS_Set_handlers( node ); 10e8c6: 83 c4 14 add $0x14,%esp 10e8c9: 53 push %ebx 10e8ca: e8 81 fc ff ff call 10e550 /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) 10e8cf: 58 pop %eax 10e8d0: 5a pop %edx 10e8d1: 56 push %esi 10e8d2: 53 push %ebx 10e8d3: e8 d4 fc ff ff call 10e5ac 10e8d8: 83 c4 10 add $0x10,%esp 10e8db: 85 c0 test %eax,%eax 10e8dd: 74 0d je 10e8ec rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10e8df: 89 f8 mov %edi,%eax 10e8e1: 8d 65 f4 lea -0xc(%ebp),%esp 10e8e4: 5b pop %ebx 10e8e5: 5e pop %esi 10e8e6: 5f pop %edi 10e8e7: c9 leave 10e8e8: c3 ret 10e8e9: 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 ); 10e8ec: e8 eb 34 00 00 call 111ddc <__errno> 10e8f1: c7 00 0d 00 00 00 movl $0xd,(%eax) 10e8f7: bf ff ff ff ff mov $0xffffffff,%edi 10e8fc: eb e1 jmp 10e8df =============================================================================== 00107f14 : int IMFS_fifo_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 107f14: 55 push %ebp 107f15: 89 e5 mov %esp,%ebp 107f17: 53 push %ebx 107f18: 83 ec 04 sub $0x4,%esp 107f1b: 8b 45 08 mov 0x8(%ebp),%eax 107f1e: 8b 55 0c mov 0xc(%ebp),%edx 107f21: 8b 4d 10 mov 0x10(%ebp),%ecx int err; if (command == FIONBIO) { 107f24: 81 fa 7e 66 04 80 cmp $0x8004667e,%edx 107f2a: 74 1c je 107f48 iop->flags &= ~LIBIO_FLAGS_NO_DELAY; return 0; } } else err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop); 107f2c: 50 push %eax 107f2d: 51 push %ecx 107f2e: 52 push %edx 107f2f: 8b 40 18 mov 0x18(%eax),%eax 107f32: ff 70 50 pushl 0x50(%eax) 107f35: e8 56 96 00 00 call 111590 IMFS_FIFO_RETURN(err); 107f3a: 83 c4 10 add $0x10,%esp 107f3d: 85 c0 test %eax,%eax 107f3f: 78 3e js 107f7f } 107f41: 8b 5d fc mov -0x4(%ebp),%ebx 107f44: c9 leave 107f45: c3 ret 107f46: 66 90 xchg %ax,%ax ) { int err; if (command == FIONBIO) { if (buffer == NULL) 107f48: 85 c9 test %ecx,%ecx 107f4a: 74 20 je 107f6c err = -EFAULT; else { if (*(int *)buffer) 107f4c: 8b 11 mov (%ecx),%edx 107f4e: 85 d2 test %edx,%edx 107f50: 74 0e je 107f60 iop->flags |= LIBIO_FLAGS_NO_DELAY; 107f52: 83 48 14 01 orl $0x1,0x14(%eax) else iop->flags &= ~LIBIO_FLAGS_NO_DELAY; return 0; 107f56: 31 c0 xor %eax,%eax } else err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop); IMFS_FIFO_RETURN(err); } 107f58: 8b 5d fc mov -0x4(%ebp),%ebx 107f5b: c9 leave 107f5c: c3 ret 107f5d: 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; 107f60: 83 60 14 fe andl $0xfffffffe,0x14(%eax) return 0; 107f64: 31 c0 xor %eax,%eax } else err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop); IMFS_FIFO_RETURN(err); } 107f66: 8b 5d fc mov -0x4(%ebp),%ebx 107f69: c9 leave 107f6a: c3 ret 107f6b: 90 nop ) { int err; if (command == FIONBIO) { if (buffer == NULL) 107f6c: bb 0e 00 00 00 mov $0xe,%ebx } } else err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop); IMFS_FIFO_RETURN(err); 107f71: e8 2e ba 00 00 call 1139a4 <__errno> 107f76: 89 18 mov %ebx,(%eax) 107f78: b8 ff ff ff ff mov $0xffffffff,%eax 107f7d: eb c2 jmp 107f41 107f7f: 89 c3 mov %eax,%ebx 107f81: f7 db neg %ebx 107f83: eb ec jmp 107f71 =============================================================================== 00107ed0 : rtems_off64_t IMFS_fifo_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) { 107ed0: 55 push %ebp 107ed1: 89 e5 mov %esp,%ebp 107ed3: 53 push %ebx 107ed4: 83 ec 10 sub $0x10,%esp 107ed7: 8b 45 08 mov 0x8(%ebp),%eax off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop); 107eda: 50 push %eax 107edb: ff 75 14 pushl 0x14(%ebp) 107ede: ff 75 10 pushl 0x10(%ebp) 107ee1: ff 75 0c pushl 0xc(%ebp) 107ee4: 8b 40 18 mov 0x18(%eax),%eax 107ee7: ff 70 50 pushl 0x50(%eax) 107eea: e8 01 97 00 00 call 1115f0 107eef: 89 c3 mov %eax,%ebx 107ef1: 99 cltd IMFS_FIFO_RETURN(err); 107ef2: 83 c4 20 add $0x20,%esp 107ef5: 85 d2 test %edx,%edx 107ef7: 78 05 js 107efe <== ALWAYS TAKEN } 107ef9: 8b 5d fc mov -0x4(%ebp),%ebx 107efc: c9 leave 107efd: c3 ret rtems_off64_t offset, int whence ) { off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop); IMFS_FIFO_RETURN(err); 107efe: e8 a1 ba 00 00 call 1139a4 <__errno> 107f03: f7 db neg %ebx 107f05: 89 18 mov %ebx,(%eax) 107f07: b8 ff ff ff ff mov $0xffffffff,%eax 107f0c: ba ff ff ff ff mov $0xffffffff,%edx 107f11: eb e6 jmp 107ef9 =============================================================================== 00107f88 : ssize_t IMFS_fifo_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 107f88: 55 push %ebp 107f89: 89 e5 mov %esp,%ebp 107f8b: 56 push %esi 107f8c: 53 push %ebx 107f8d: 83 ec 10 sub $0x10,%esp 107f90: 8b 45 08 mov 0x8(%ebp),%eax IMFS_jnode_t *jnode = iop->pathinfo.node_access; 107f93: 8b 58 18 mov 0x18(%eax),%ebx int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop); 107f96: 50 push %eax 107f97: ff 75 10 pushl 0x10(%ebp) 107f9a: ff 75 0c pushl 0xc(%ebp) 107f9d: ff 73 50 pushl 0x50(%ebx) 107fa0: e8 07 94 00 00 call 1113ac 107fa5: 89 c6 mov %eax,%esi if (err > 0) { 107fa7: 83 c4 10 add $0x10,%esp 107faa: 83 f8 00 cmp $0x0,%eax 107fad: 7e 25 jle 107fd4 IMFS_mtime_ctime_update(jnode); 107faf: 83 ec 08 sub $0x8,%esp 107fb2: 6a 00 push $0x0 107fb4: 8d 45 f0 lea -0x10(%ebp),%eax 107fb7: 50 push %eax 107fb8: e8 1f 0f 00 00 call 108edc 107fbd: 8b 45 f0 mov -0x10(%ebp),%eax 107fc0: 89 43 44 mov %eax,0x44(%ebx) 107fc3: 89 43 48 mov %eax,0x48(%ebx) 107fc6: 83 c4 10 add $0x10,%esp 107fc9: 89 f0 mov %esi,%eax } IMFS_FIFO_RETURN(err); } 107fcb: 8d 65 f8 lea -0x8(%ebp),%esp 107fce: 5b pop %ebx 107fcf: 5e pop %esi 107fd0: c9 leave 107fd1: c3 ret 107fd2: 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); 107fd4: 75 09 jne 107fdf <== ALWAYS TAKEN 107fd6: 31 c0 xor %eax,%eax } 107fd8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 107fdb: 5b pop %ebx <== NOT EXECUTED 107fdc: 5e pop %esi <== NOT EXECUTED 107fdd: c9 leave <== NOT EXECUTED 107fde: 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); 107fdf: e8 c0 b9 00 00 call 1139a4 <__errno> 107fe4: f7 de neg %esi 107fe6: 89 30 mov %esi,(%eax) 107fe8: b8 ff ff ff ff mov $0xffffffff,%eax 107fed: eb dc jmp 107fcb =============================================================================== 0010ed10 : IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) { 10ed10: 55 push %ebp 10ed11: 89 e5 mov %esp,%ebp 10ed13: 57 push %edi 10ed14: 56 push %esi 10ed15: 53 push %ebx 10ed16: 83 ec 0c sub $0xc,%esp 10ed19: 8b 45 08 mov 0x8(%ebp),%eax 10ed1c: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Check for "." and ".." */ if ( !strcmp( name, dotname ) ) 10ed1f: bf 50 02 12 00 mov $0x120250,%edi 10ed24: b9 02 00 00 00 mov $0x2,%ecx 10ed29: 89 de mov %ebx,%esi 10ed2b: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10ed2d: 74 13 je 10ed42 <== NEVER TAKEN return directory; if ( !strcmp( name, dotdotname ) ) 10ed2f: bf 52 02 12 00 mov $0x120252,%edi 10ed34: b9 03 00 00 00 mov $0x3,%ecx 10ed39: 89 de mov %ebx,%esi 10ed3b: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10ed3d: 75 0d jne 10ed4c <== ALWAYS TAKEN return directory->Parent; 10ed3f: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10ed42: 8d 65 f4 lea -0xc(%ebp),%esp 10ed45: 5b pop %ebx 10ed46: 5e pop %esi 10ed47: 5f pop %edi 10ed48: c9 leave 10ed49: c3 ret 10ed4a: 66 90 xchg %ax,%ax 10ed4c: 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)); 10ed4f: 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 ); 10ed52: 39 fe cmp %edi,%esi 10ed54: 75 08 jne 10ed5e 10ed56: eb 20 jmp 10ed78 !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { 10ed58: 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 ); 10ed5a: 39 fe cmp %edi,%esi 10ed5c: 74 1a je 10ed78 !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 ) ) 10ed5e: 8d 46 0c lea 0xc(%esi),%eax 10ed61: 83 ec 08 sub $0x8,%esp 10ed64: 50 push %eax 10ed65: 53 push %ebx 10ed66: e8 e1 3c 00 00 call 112a4c 10ed6b: 83 c4 10 add $0x10,%esp 10ed6e: 85 c0 test %eax,%eax 10ed70: 75 e6 jne 10ed58 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; 10ed72: 89 f0 mov %esi,%eax 10ed74: eb cc jmp 10ed42 10ed76: 66 90 xchg %ax,%ax if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; 10ed78: 31 c0 xor %eax,%eax 10ed7a: eb c6 jmp 10ed42 =============================================================================== 0010ec70 : ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next)) int IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 10ec70: 55 push %ebp 10ec71: 89 e5 mov %esp,%ebp 10ec73: 57 push %edi 10ec74: 56 push %esi 10ec75: 53 push %ebx 10ec76: 83 ec 3c sub $0x3c,%esp 10ec79: 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; 10ec7c: 8b 58 1c mov 0x1c(%eax),%ebx loc = temp_mt_entry->mt_fs_root; 10ec7f: 8d 55 d4 lea -0x2c(%ebp),%edx 10ec82: 89 55 c4 mov %edx,-0x3c(%ebp) 10ec85: 8d 70 1c lea 0x1c(%eax),%esi 10ec88: b9 05 00 00 00 mov $0x5,%ecx 10ec8d: 89 d7 mov %edx,%edi 10ec8f: 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; 10ec91: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) do { next = jnode->Parent; 10ec98: 8b 73 08 mov 0x8(%ebx),%esi loc.node_access = (void *)jnode; 10ec9b: 89 5d d4 mov %ebx,-0x2c(%ebp) IMFS_Set_handlers( &loc ); 10ec9e: 83 ec 0c sub $0xc,%esp 10eca1: 8d 45 d4 lea -0x2c(%ebp),%eax 10eca4: 50 push %eax 10eca5: e8 a6 f8 ff ff call 10e550 if ( jnode->type != IMFS_DIRECTORY ) { 10ecaa: 83 c4 10 add $0x10,%esp 10ecad: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10ecb1: 75 31 jne 10ece4 RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10ecb3: 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 ) ) { 10ecb6: 39 43 50 cmp %eax,0x50(%ebx) 10ecb9: 74 42 je 10ecfd result = IMFS_unlink( NULL, &loc ); if (result != 0) return -1; jnode = next; } if ( jnode != NULL ) { 10ecbb: 85 db test %ebx,%ebx 10ecbd: 74 19 je 10ecd8 if ( jnode->type == IMFS_DIRECTORY ) { 10ecbf: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10ecc3: 75 d3 jne 10ec98 <== NEVER TAKEN } } } while (jnode != NULL); return 0; } 10ecc5: 8b 43 50 mov 0x50(%ebx),%eax 10ecc8: 8d 53 54 lea 0x54(%ebx),%edx return -1; jnode = next; } if ( jnode != NULL ) { if ( jnode->type == IMFS_DIRECTORY ) { if ( jnode_has_children( jnode ) ) 10eccb: 39 d0 cmp %edx,%eax 10eccd: 74 c9 je 10ec98 jnode = jnode_get_first_child( jnode ); 10eccf: 89 c3 mov %eax,%ebx } } } while (jnode != NULL); 10ecd1: 85 c0 test %eax,%eax 10ecd3: 75 c3 jne 10ec98 <== ALWAYS TAKEN 10ecd5: 8d 76 00 lea 0x0(%esi),%esi return 0; 10ecd8: 31 c0 xor %eax,%eax } 10ecda: 8d 65 f4 lea -0xc(%ebp),%esp 10ecdd: 5b pop %ebx 10ecde: 5e pop %esi 10ecdf: 5f pop %edi 10ece0: c9 leave 10ece1: c3 ret 10ece2: 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 ); 10ece4: 83 ec 08 sub $0x8,%esp 10ece7: 8d 55 d4 lea -0x2c(%ebp),%edx 10ecea: 52 push %edx if (result != 0) return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { result = IMFS_unlink( NULL, &loc ); 10eceb: 6a 00 push $0x0 10eced: e8 8a 84 ff ff call 10717c if (result != 0) 10ecf2: 83 c4 10 add $0x10,%esp 10ecf5: 85 c0 test %eax,%eax 10ecf7: 75 0d jne 10ed06 <== NEVER TAKEN return -1; jnode = next; 10ecf9: 89 f3 mov %esi,%ebx 10ecfb: eb be jmp 10ecbb result = IMFS_unlink( NULL, &loc ); if (result != 0) return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { result = IMFS_unlink( NULL, &loc ); 10ecfd: 83 ec 08 sub $0x8,%esp 10ed00: 8d 45 d4 lea -0x2c(%ebp),%eax 10ed03: 50 push %eax 10ed04: eb e5 jmp 10eceb if (result != 0) return -1; 10ed06: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ed0b: eb cd jmp 10ecda <== NOT EXECUTED =============================================================================== 0010ed7c : const char *path, int pathlen, char *token, int *token_len ) { 10ed7c: 55 push %ebp 10ed7d: 89 e5 mov %esp,%ebp 10ed7f: 57 push %edi 10ed80: 56 push %esi 10ed81: 53 push %ebx 10ed82: 83 ec 1c sub $0x1c,%esp 10ed85: 8b 7d 08 mov 0x8(%ebp),%edi 10ed88: 8b 5d 10 mov 0x10(%ebp),%ebx register char c; /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; 10ed8b: 8a 17 mov (%edi),%dl int pathlen, char *token, int *token_len ) { register int i = 0; 10ed8d: 31 f6 xor %esi,%esi 10ed8f: 89 7d e4 mov %edi,-0x1c(%ebp) 10ed92: 89 df mov %ebx,%edi 10ed94: 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) ) { 10ed96: eb 07 jmp 10ed9f return IMFS_INVALID_TOKEN; if ( !IMFS_is_valid_name_char(c) ) type = IMFS_INVALID_TOKEN; c = path [++i]; 10ed98: 46 inc %esi 10ed99: 8b 45 e4 mov -0x1c(%ebp),%eax 10ed9c: 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) ) { 10ed9f: 83 ec 0c sub $0xc,%esp 10eda2: 0f be c3 movsbl %bl,%eax 10eda5: 50 push %eax 10eda6: e8 15 97 ff ff call 1084c0 10edab: 83 c4 10 add $0x10,%esp 10edae: 85 c0 test %eax,%eax 10edb0: 75 1a jne 10edcc 10edb2: 3b 75 0c cmp 0xc(%ebp),%esi 10edb5: 7d 15 jge 10edcc token[i] = c; 10edb7: 88 1c 37 mov %bl,(%edi,%esi,1) if ( i == IMFS_NAME_MAX ) 10edba: 83 fe 20 cmp $0x20,%esi 10edbd: 75 d9 jne 10ed98 return IMFS_INVALID_TOKEN; 10edbf: b8 04 00 00 00 mov $0x4,%eax else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; } return type; } 10edc4: 8d 65 f4 lea -0xc(%ebp),%esp 10edc7: 5b pop %ebx 10edc8: 5e pop %esi 10edc9: 5f pop %edi 10edca: c9 leave 10edcb: c3 ret 10edcc: 88 da mov %bl,%dl 10edce: 89 fb mov %edi,%ebx /* * Copy a seperator into token. */ if ( i == 0 ) { 10edd0: 85 f6 test %esi,%esi 10edd2: 75 25 jne 10edf9 token[i] = c; 10edd4: 88 17 mov %dl,(%edi) if ( (token[i] != '\0') && pathlen ) { 10edd6: 84 d2 test %dl,%dl 10edd8: 74 16 je 10edf0 10edda: 8b 45 0c mov 0xc(%ebp),%eax 10eddd: 85 c0 test %eax,%eax 10eddf: 74 0f je 10edf0 i++; type = IMFS_CURRENT_DIR; 10ede1: b8 01 00 00 00 mov $0x1,%eax if ( i == 0 ) { token[i] = c; if ( (token[i] != '\0') && pathlen ) { i++; 10ede6: be 01 00 00 00 mov $0x1,%esi 10edeb: eb 05 jmp 10edf2 10eded: 8d 76 00 lea 0x0(%esi),%esi type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; 10edf0: 31 c0 xor %eax,%eax /* * Set token_len to the number of characters copied. */ *token_len = i; 10edf2: 8b 55 14 mov 0x14(%ebp),%edx 10edf5: 89 32 mov %esi,(%edx) 10edf7: eb cb jmp 10edc4 i++; type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; } } else if (token[ i-1 ] != '\0') { 10edf9: 80 7c 37 ff 00 cmpb $0x0,-0x1(%edi,%esi,1) 10edfe: 74 04 je 10ee04 <== NEVER TAKEN token[i] = '\0'; 10ee00: c6 04 37 00 movb $0x0,(%edi,%esi,1) /* * Set token_len to the number of characters copied. */ *token_len = i; 10ee04: 8b 45 14 mov 0x14(%ebp),%eax 10ee07: 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 ) 10ee09: bf 55 02 12 00 mov $0x120255,%edi 10ee0e: b9 03 00 00 00 mov $0x3,%ecx 10ee13: 89 de mov %ebx,%esi 10ee15: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10ee17: 75 0f jne 10ee28 type = IMFS_UP_DIR; 10ee19: b8 02 00 00 00 mov $0x2,%eax else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; } return type; } 10ee1e: 8d 65 f4 lea -0xc(%ebp),%esp 10ee21: 5b pop %ebx 10ee22: 5e pop %esi 10ee23: 5f pop %edi 10ee24: c9 leave 10ee25: c3 ret 10ee26: 66 90 xchg %ax,%ax */ if ( type == IMFS_NAME ) { if ( strcmp( token, "..") == 0 ) type = IMFS_UP_DIR; else if ( strcmp( token, "." ) == 0 ) 10ee28: bf 56 02 12 00 mov $0x120256,%edi 10ee2d: b9 02 00 00 00 mov $0x2,%ecx 10ee32: 89 de mov %ebx,%esi 10ee34: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10ee36: 0f 97 c0 seta %al 10ee39: 0f 92 c2 setb %dl 10ee3c: 28 d0 sub %dl,%al 10ee3e: 0f be c0 movsbl %al,%eax 10ee41: 83 f8 01 cmp $0x1,%eax 10ee44: 19 c0 sbb %eax,%eax 10ee46: 83 e0 fe and $0xfffffffe,%eax 10ee49: 83 c0 03 add $0x3,%eax type = IMFS_CURRENT_DIR; } return type; } 10ee4c: 8d 65 f4 lea -0xc(%ebp),%esp 10ee4f: 5b pop %ebx 10ee50: 5e pop %esi 10ee51: 5f pop %edi 10ee52: c9 leave 10ee53: c3 ret =============================================================================== 00106dc4 : 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 ) { 106dc4: 55 push %ebp 106dc5: 89 e5 mov %esp,%ebp 106dc7: 57 push %edi 106dc8: 56 push %esi 106dc9: 53 push %ebx 106dca: 83 ec 1c sub $0x1c,%esp 106dcd: 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, 106dd0: 8b 0d f0 21 12 00 mov 0x1221f0,%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) { 106dd6: 83 f9 10 cmp $0x10,%ecx 106dd9: 74 1f je 106dfa is_valid = true; break; } if(bit_mask > requested_bytes_per_block) 106ddb: 83 f9 0f cmp $0xf,%ecx 106dde: 7e 15 jle 106df5 106de0: ba 05 00 00 00 mov $0x5,%edx 106de5: 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) { 106dea: 39 c1 cmp %eax,%ecx 106dec: 74 0c je 106dfa is_valid = true; break; } if(bit_mask > requested_bytes_per_block) 106dee: 7c 05 jl 106df5 <== 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) { 106df0: d1 e0 shl %eax 106df2: 4a dec %edx 106df3: 75 f5 jne 106dea <== ALWAYS TAKEN if(bit_mask > requested_bytes_per_block) break; } *dest_bytes_per_block = ((is_valid) ? requested_bytes_per_block : default_bytes_per_block); 106df5: b9 80 00 00 00 mov $0x80,%ecx break; } if(bit_mask > requested_bytes_per_block) break; } *dest_bytes_per_block = ((is_valid) 106dfa: 89 0d 20 60 12 00 mov %ecx,0x126020 /* * 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(); 106e00: e8 17 77 00 00 call 10e51c 106e05: 89 c2 mov %eax,%edx 106e07: 89 43 1c mov %eax,0x1c(%ebx) temp_mt_entry->mt_fs_root.handlers = directory_handlers; 106e0a: 8b 45 14 mov 0x14(%ebp),%eax 106e0d: 89 43 24 mov %eax,0x24(%ebx) temp_mt_entry->mt_fs_root.ops = op_table; 106e10: 8b 45 0c mov 0xc(%ebp),%eax 106e13: 89 43 28 mov %eax,0x28(%ebx) temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS; 106e16: 8d 7b 38 lea 0x38(%ebx),%edi 106e19: be 00 02 12 00 mov $0x120200,%esi 106e1e: b9 0c 00 00 00 mov $0xc,%ecx 106e23: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Create custom file system data. */ fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) ); 106e25: 83 ec 08 sub $0x8,%esp 106e28: 6a 14 push $0x14 106e2a: 6a 01 push $0x1 106e2c: 89 55 e4 mov %edx,-0x1c(%ebp) 106e2f: e8 70 06 00 00 call 1074a4 if ( !fs_info ) { 106e34: 83 c4 10 add $0x10,%esp 106e37: 85 c0 test %eax,%eax 106e39: 8b 55 e4 mov -0x1c(%ebp),%edx 106e3c: 74 3c je 106e7a free(temp_mt_entry->mt_fs_root.node_access); rtems_set_errno_and_return_minus_one(ENOMEM); } temp_mt_entry->fs_info = fs_info; 106e3e: 89 43 34 mov %eax,0x34(%ebx) /* * Set st_ino for the root to 1. */ fs_info->instance = imfs_instance++; 106e41: 8b 0d 24 60 12 00 mov 0x126024,%ecx 106e47: 89 08 mov %ecx,(%eax) 106e49: 41 inc %ecx 106e4a: 89 0d 24 60 12 00 mov %ecx,0x126024 fs_info->ino_count = 1; 106e50: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) fs_info->memfile_handlers = memfile_handlers; 106e57: 8b 4d 10 mov 0x10(%ebp),%ecx 106e5a: 89 48 08 mov %ecx,0x8(%eax) fs_info->directory_handlers = directory_handlers; 106e5d: 8b 4d 14 mov 0x14(%ebp),%ecx 106e60: 89 48 0c mov %ecx,0xc(%eax) fs_info->fifo_handlers = fifo_handlers; 106e63: 8b 4d 18 mov 0x18(%ebp),%ecx 106e66: 89 48 10 mov %ecx,0x10(%eax) jnode = temp_mt_entry->mt_fs_root.node_access; jnode->st_ino = fs_info->ino_count; 106e69: c7 42 38 01 00 00 00 movl $0x1,0x38(%edx) return 0; 106e70: 31 c0 xor %eax,%eax } 106e72: 8d 65 f4 lea -0xc(%ebp),%esp 106e75: 5b pop %ebx 106e76: 5e pop %esi 106e77: 5f pop %edi 106e78: c9 leave 106e79: 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); 106e7a: 83 ec 0c sub $0xc,%esp 106e7d: 52 push %edx 106e7e: e8 b1 07 00 00 call 107634 rtems_set_errno_and_return_minus_one(ENOMEM); 106e83: e8 54 af 00 00 call 111ddc <__errno> 106e88: c7 00 0c 00 00 00 movl $0xc,(%eax) 106e8e: 83 c4 10 add $0x10,%esp 106e91: 83 c8 ff or $0xffffffff,%eax 106e94: eb dc jmp 106e72 =============================================================================== 00106e98 : int IMFS_link( rtems_filesystem_location_info_t *to_loc, /* IN */ rtems_filesystem_location_info_t *parent_loc, /* IN */ const char *token /* IN */ ) { 106e98: 55 push %ebp 106e99: 89 e5 mov %esp,%ebp 106e9b: 57 push %edi 106e9c: 53 push %ebx 106e9d: 83 ec 50 sub $0x50,%esp 106ea0: 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; 106ea3: 8b 45 08 mov 0x8(%ebp),%eax 106ea6: 8b 00 mov (%eax),%eax 106ea8: 89 45 d8 mov %eax,-0x28(%ebp) if ( info.hard_link.link_node->st_nlink >= LINK_MAX ) 106eab: 66 83 78 34 07 cmpw $0x7,0x34(%eax) 106eb0: 77 66 ja 106f18 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 ); 106eb2: 31 c0 xor %eax,%eax 106eb4: b9 ff ff ff ff mov $0xffffffff,%ecx 106eb9: 89 d7 mov %edx,%edi 106ebb: f2 ae repnz scas %es:(%edi),%al 106ebd: f7 d1 not %ecx 106ebf: 49 dec %ecx 106ec0: 8d 45 f4 lea -0xc(%ebp),%eax 106ec3: 50 push %eax 106ec4: 8d 5d b7 lea -0x49(%ebp),%ebx 106ec7: 53 push %ebx 106ec8: 51 push %ecx 106ec9: 52 push %edx 106eca: e8 ad 7e 00 00 call 10ed7c new_node = IMFS_create_node( parent_loc, IMFS_HARD_LINK, new_name, ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info 106ecf: 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( 106ed2: 89 04 24 mov %eax,(%esp) 106ed5: 68 ff a1 00 00 push $0xa1ff 106eda: 53 push %ebx 106edb: 6a 03 push $0x3 106edd: ff 75 0c pushl 0xc(%ebp) 106ee0: e8 ff 74 00 00 call 10e3e4 new_name, ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if ( !new_node ) 106ee5: 83 c4 20 add $0x20,%esp 106ee8: 85 c0 test %eax,%eax 106eea: 74 3e je 106f2a 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++; 106eec: 8b 45 d8 mov -0x28(%ebp),%eax 106eef: 66 ff 40 34 incw 0x34(%eax) IMFS_update_ctime( info.hard_link.link_node ); 106ef3: 83 ec 08 sub $0x8,%esp 106ef6: 6a 00 push $0x0 106ef8: 8d 45 ec lea -0x14(%ebp),%eax 106efb: 50 push %eax 106efc: e8 af 07 00 00 call 1076b0 106f01: 8b 55 ec mov -0x14(%ebp),%edx 106f04: 8b 45 d8 mov -0x28(%ebp),%eax 106f07: 89 50 48 mov %edx,0x48(%eax) return 0; 106f0a: 83 c4 10 add $0x10,%esp 106f0d: 31 c0 xor %eax,%eax } 106f0f: 8d 65 f8 lea -0x8(%ebp),%esp 106f12: 5b pop %ebx 106f13: 5f pop %edi 106f14: c9 leave 106f15: c3 ret 106f16: 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 ); 106f18: e8 bf ae 00 00 call 111ddc <__errno> 106f1d: c7 00 1f 00 00 00 movl $0x1f,(%eax) 106f23: b8 ff ff ff ff mov $0xffffffff,%eax 106f28: eb e5 jmp 106f0f ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if ( !new_node ) rtems_set_errno_and_return_minus_one( ENOMEM ); 106f2a: e8 ad ae 00 00 call 111ddc <__errno> 106f2f: c7 00 0c 00 00 00 movl $0xc,(%eax) 106f35: b8 ff ff ff ff mov $0xffffffff,%eax 106f3a: eb d3 jmp 106f0f =============================================================================== 00110cb0 : */ MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) { 110cb0: 55 push %ebp 110cb1: 89 e5 mov %esp,%ebp 110cb3: 53 push %ebx 110cb4: 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 ); 110cb7: 6a 01 push $0x1 110cb9: ff 75 0c pushl 0xc(%ebp) 110cbc: ff 75 08 pushl 0x8(%ebp) 110cbf: e8 28 fc ff ff call 1108ec 110cc4: 89 c3 mov %eax,%ebx if ( *block_entry_ptr ) 110cc6: 83 c4 10 add $0x10,%esp 110cc9: 8b 00 mov (%eax),%eax 110ccb: 85 c0 test %eax,%eax 110ccd: 74 09 je 110cd8 return 0; 110ccf: 31 c0 xor %eax,%eax if ( !memory ) return 1; *block_entry_ptr = memory; return 0; } 110cd1: 8b 5d fc mov -0x4(%ebp),%ebx 110cd4: c9 leave 110cd5: c3 ret 110cd6: 66 90 xchg %ax,%ax return 0; /* * There is no memory for this block number so allocate it. */ memory = memfile_alloc_block(); 110cd8: e8 eb fb ff ff call 1108c8 if ( !memory ) 110cdd: 85 c0 test %eax,%eax 110cdf: 74 07 je 110ce8 return 1; *block_entry_ptr = memory; 110ce1: 89 03 mov %eax,(%ebx) return 0; 110ce3: 31 c0 xor %eax,%eax 110ce5: eb ea jmp 110cd1 110ce7: 90 nop /* * There is no memory for this block number so allocate it. */ memory = memfile_alloc_block(); if ( !memory ) return 1; 110ce8: b8 01 00 00 00 mov $0x1,%eax 110ced: eb e2 jmp 110cd1 =============================================================================== 00110ef0 : */ MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) { 110ef0: 55 push %ebp 110ef1: 89 e5 mov %esp,%ebp 110ef3: 57 push %edi 110ef4: 56 push %esi 110ef5: 53 push %ebx 110ef6: 83 ec 2c sub $0x2c,%esp 110ef9: 8b 5d 08 mov 0x8(%ebp),%ebx 110efc: 8b 45 0c mov 0xc(%ebp),%eax 110eff: 8b 55 10 mov 0x10(%ebp),%edx 110f02: 89 45 d8 mov %eax,-0x28(%ebp) 110f05: 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 ) 110f08: a1 20 60 12 00 mov 0x126020,%eax 110f0d: 89 c1 mov %eax,%ecx 110f0f: c1 e9 02 shr $0x2,%ecx 110f12: 8d 51 01 lea 0x1(%ecx),%edx 110f15: 0f af d1 imul %ecx,%edx 110f18: 42 inc %edx 110f19: 0f af d1 imul %ecx,%edx 110f1c: 4a dec %edx 110f1d: 0f af d0 imul %eax,%edx 110f20: 31 c9 xor %ecx,%ecx 110f22: 3b 4d dc cmp -0x24(%ebp),%ecx 110f25: 7f 1a jg 110f41 <== NEVER TAKEN 110f27: 7d 13 jge 110f3c <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 110f29: e8 ae 0e 00 00 call 111ddc <__errno> 110f2e: c7 00 16 00 00 00 movl $0x16,(%eax) 110f34: b8 ff ff ff ff mov $0xffffffff,%eax 110f39: eb 19 jmp 110f54 110f3b: 90 nop IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE ); /* * Verify new file size is supported */ if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE ) 110f3c: 3b 55 d8 cmp -0x28(%ebp),%edx 110f3f: 76 e8 jbe 110f29 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 ) 110f41: 8b 53 50 mov 0x50(%ebx),%edx 110f44: 8b 4b 54 mov 0x54(%ebx),%ecx 110f47: 89 55 e0 mov %edx,-0x20(%ebp) 110f4a: 89 4d e4 mov %ecx,-0x1c(%ebp) 110f4d: 39 4d dc cmp %ecx,-0x24(%ebp) 110f50: 7d 0a jge 110f5c <== ALWAYS TAKEN return 0; 110f52: 31 c0 xor %eax,%eax /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; return 0; } 110f54: 8d 65 f4 lea -0xc(%ebp),%esp 110f57: 5b pop %ebx 110f58: 5e pop %esi 110f59: 5f pop %edi 110f5a: c9 leave 110f5b: 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 ) 110f5c: 7f 05 jg 110f63 <== NEVER TAKEN 110f5e: 39 55 d8 cmp %edx,-0x28(%ebp) 110f61: 76 ef jbe 110f52 return 0; /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; 110f63: 89 45 d0 mov %eax,-0x30(%ebp) 110f66: 89 c1 mov %eax,%ecx 110f68: c1 f9 1f sar $0x1f,%ecx 110f6b: 89 4d d4 mov %ecx,-0x2c(%ebp) 110f6e: ff 75 d4 pushl -0x2c(%ebp) 110f71: ff 75 d0 pushl -0x30(%ebp) 110f74: ff 75 dc pushl -0x24(%ebp) 110f77: ff 75 d8 pushl -0x28(%ebp) 110f7a: e8 61 c6 00 00 call 11d5e0 <__divdi3> 110f7f: 83 c4 10 add $0x10,%esp 110f82: 89 c6 mov %eax,%esi old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; 110f84: ff 75 d4 pushl -0x2c(%ebp) 110f87: ff 75 d0 pushl -0x30(%ebp) 110f8a: ff 75 e4 pushl -0x1c(%ebp) 110f8d: ff 75 e0 pushl -0x20(%ebp) 110f90: e8 4b c6 00 00 call 11d5e0 <__divdi3> 110f95: 83 c4 10 add $0x10,%esp 110f98: 89 45 e0 mov %eax,-0x20(%ebp) /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 110f9b: 39 c6 cmp %eax,%esi 110f9d: 72 51 jb 110ff0 <== NEVER TAKEN 110f9f: 89 c7 mov %eax,%edi 110fa1: eb 06 jmp 110fa9 110fa3: 90 nop 110fa4: 47 inc %edi 110fa5: 39 fe cmp %edi,%esi 110fa7: 72 47 jb 110ff0 if ( IMFS_memfile_addblock( the_jnode, block ) ) { 110fa9: 83 ec 08 sub $0x8,%esp 110fac: 57 push %edi 110fad: 53 push %ebx 110fae: e8 fd fc ff ff call 110cb0 110fb3: 83 c4 10 add $0x10,%esp 110fb6: 85 c0 test %eax,%eax 110fb8: 74 ea je 110fa4 for ( ; block>=old_blocks ; block-- ) { 110fba: 39 7d e0 cmp %edi,-0x20(%ebp) 110fbd: 77 17 ja 110fd6 <== NEVER TAKEN 110fbf: 8b 75 e0 mov -0x20(%ebp),%esi 110fc2: 66 90 xchg %ax,%ax IMFS_memfile_remove_block( the_jnode, block ); 110fc4: 83 ec 08 sub $0x8,%esp 110fc7: 57 push %edi 110fc8: 53 push %ebx 110fc9: e8 f6 fe ff ff call 110ec4 /* * 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-- ) { 110fce: 4f dec %edi 110fcf: 83 c4 10 add $0x10,%esp 110fd2: 39 fe cmp %edi,%esi 110fd4: 76 ee jbe 110fc4 IMFS_memfile_remove_block( the_jnode, block ); } rtems_set_errno_and_return_minus_one( ENOSPC ); 110fd6: e8 01 0e 00 00 call 111ddc <__errno> 110fdb: c7 00 1c 00 00 00 movl $0x1c,(%eax) 110fe1: b8 ff ff ff ff mov $0xffffffff,%eax /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; return 0; } 110fe6: 8d 65 f4 lea -0xc(%ebp),%esp 110fe9: 5b pop %ebx 110fea: 5e pop %esi 110feb: 5f pop %edi 110fec: c9 leave 110fed: c3 ret 110fee: 66 90 xchg %ax,%ax } /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; 110ff0: 8b 45 d8 mov -0x28(%ebp),%eax 110ff3: 8b 55 dc mov -0x24(%ebp),%edx 110ff6: 89 43 50 mov %eax,0x50(%ebx) 110ff9: 89 53 54 mov %edx,0x54(%ebx) return 0; 110ffc: 31 c0 xor %eax,%eax } 110ffe: 8d 65 f4 lea -0xc(%ebp),%esp 111001: 5b pop %ebx 111002: 5e pop %esi 111003: 5f pop %edi 111004: c9 leave 111005: c3 ret =============================================================================== 001108ec : #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) { 1108ec: 55 push %ebp 1108ed: 89 e5 mov %esp,%ebp 1108ef: 57 push %edi 1108f0: 56 push %esi 1108f1: 53 push %ebx 1108f2: 83 ec 1c sub $0x1c,%esp 1108f5: 8b 5d 08 mov 0x8(%ebp),%ebx 1108f8: 8b 75 0c mov 0xc(%ebp),%esi 1108fb: 8b 7d 10 mov 0x10(%ebp),%edi my_block = block; /* * Is the block number in the simple indirect portion? */ if ( my_block <= LAST_INDIRECT ) { 1108fe: 8b 0d 20 60 12 00 mov 0x126020,%ecx 110904: c1 e9 02 shr $0x2,%ecx 110907: 8d 41 ff lea -0x1(%ecx),%eax 11090a: 39 c6 cmp %eax,%esi 11090c: 77 1a ja 110928 p = info->indirect; 11090e: 8b 43 58 mov 0x58(%ebx),%eax if ( malloc_it ) { 110911: 85 ff test %edi,%edi 110913: 74 53 je 110968 if ( !p ) { 110915: 85 c0 test %eax,%eax 110917: 0f 84 b6 00 00 00 je 1109d3 } if ( !p ) return 0; return &info->indirect[ my_block ]; 11091d: 8d 04 b0 lea (%eax,%esi,4),%eax /* * This means the requested block number is out of range. */ return 0; } 110920: 83 c4 1c add $0x1c,%esp 110923: 5b pop %ebx 110924: 5e pop %esi 110925: 5f pop %edi 110926: c9 leave 110927: c3 ret /* * Is the block number in the doubly indirect portion? */ if ( my_block <= LAST_DOUBLY_INDIRECT ) { 110928: 8d 41 01 lea 0x1(%ecx),%eax 11092b: 0f af c1 imul %ecx,%eax 11092e: 8d 50 ff lea -0x1(%eax),%edx 110931: 39 d6 cmp %edx,%esi 110933: 77 3b ja 110970 my_block -= FIRST_DOUBLY_INDIRECT; 110935: 29 ce sub %ecx,%esi singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 110937: 89 f0 mov %esi,%eax 110939: 31 d2 xor %edx,%edx 11093b: f7 f1 div %ecx 11093d: 89 c6 mov %eax,%esi doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; p = info->doubly_indirect; 11093f: 8b 43 5c mov 0x5c(%ebx),%eax if ( malloc_it ) { 110942: 85 ff test %edi,%edi 110944: 74 7e je 1109c4 if ( !p ) { 110946: 85 c0 test %eax,%eax 110948: 0f 84 96 00 00 00 je 1109e4 if ( !p ) return 0; info->doubly_indirect = p; } p1 = (block_p *)p[ doubly ]; 11094e: 8d 1c b0 lea (%eax,%esi,4),%ebx 110951: 8b 03 mov (%ebx),%eax if ( !p1 ) { 110953: 85 c0 test %eax,%eax 110955: 0f 84 a4 00 00 00 je 1109ff p = (block_p *)p[ doubly ]; if ( !p ) return 0; return (block_p *)&p[ singly ]; 11095b: 8d 04 90 lea (%eax,%edx,4),%eax /* * This means the requested block number is out of range. */ return 0; } 11095e: 83 c4 1c add $0x1c,%esp 110961: 5b pop %ebx 110962: 5e pop %esi 110963: 5f pop %edi 110964: c9 leave 110965: c3 ret 110966: 66 90 xchg %ax,%ax info->indirect = p; } return &info->indirect[ my_block ]; } if ( !p ) 110968: 85 c0 test %eax,%eax 11096a: 75 b1 jne 11091d <== ALWAYS TAKEN if ( !p ) return 0; p1 = (block_p *) p[ triply ]; if ( !p1 ) return 0; 11096c: 31 c0 xor %eax,%eax 11096e: eb ee jmp 11095e <== NOT EXECUTED } /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 110970: 8d 50 01 lea 0x1(%eax),%edx 110973: 0f af d1 imul %ecx,%edx 110976: 4a dec %edx 110977: 39 d6 cmp %edx,%esi 110979: 77 f1 ja 11096c <== NEVER TAKEN my_block -= FIRST_TRIPLY_INDIRECT; 11097b: 29 c6 sub %eax,%esi 11097d: 89 f0 mov %esi,%eax singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 11097f: 31 d2 xor %edx,%edx 110981: f7 f1 div %ecx 110983: 89 55 e4 mov %edx,-0x1c(%ebp) doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; 110986: 31 d2 xor %edx,%edx 110988: f7 f1 div %ecx 11098a: 89 c6 mov %eax,%esi doubly %= IMFS_MEMFILE_BLOCK_SLOTS; p = info->triply_indirect; 11098c: 8b 4b 60 mov 0x60(%ebx),%ecx if ( malloc_it ) { 11098f: 85 ff test %edi,%edi 110991: 0f 84 82 00 00 00 je 110a19 if ( !p ) { 110997: 85 c9 test %ecx,%ecx 110999: 0f 84 9b 00 00 00 je 110a3a if ( !p ) return 0; info->triply_indirect = p; } p1 = (block_p *) p[ triply ]; 11099f: 8d 1c b1 lea (%ecx,%esi,4),%ebx 1109a2: 8b 0b mov (%ebx),%ecx if ( !p1 ) { 1109a4: 85 c9 test %ecx,%ecx 1109a6: 0f 84 c5 00 00 00 je 110a71 if ( !p1 ) return 0; p[ triply ] = (block_p) p1; } p2 = (block_p *)p1[ doubly ]; 1109ac: 8d 1c 91 lea (%ecx,%edx,4),%ebx 1109af: 8b 13 mov (%ebx),%edx if ( !p2 ) { 1109b1: 85 d2 test %edx,%edx 1109b3: 0f 84 a0 00 00 00 je 110a59 p2 = (block_p *)p1[ doubly ]; if ( !p2 ) return 0; return (block_p *)&p2[ singly ]; 1109b9: 8b 4d e4 mov -0x1c(%ebp),%ecx 1109bc: 8d 04 8a lea (%edx,%ecx,4),%eax 1109bf: eb 9d jmp 11095e 1109c1: 8d 76 00 lea 0x0(%esi),%esi } return (block_p *)&p1[ singly ]; } if ( !p ) 1109c4: 85 c0 test %eax,%eax 1109c6: 74 a4 je 11096c <== NEVER TAKEN return 0; p = (block_p *)p[ doubly ]; 1109c8: 8b 04 b0 mov (%eax,%esi,4),%eax if ( !p ) 1109cb: 85 c0 test %eax,%eax 1109cd: 75 8c jne 11095b <== ALWAYS TAKEN if ( !p ) return 0; p1 = (block_p *) p[ triply ]; if ( !p1 ) return 0; 1109cf: 31 c0 xor %eax,%eax 1109d1: eb 8b jmp 11095e <== NOT EXECUTED p = info->indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 1109d3: e8 f0 fe ff ff call 1108c8 if ( !p ) 1109d8: 85 c0 test %eax,%eax 1109da: 74 90 je 11096c <== NEVER TAKEN return 0; info->indirect = p; 1109dc: 89 43 58 mov %eax,0x58(%ebx) 1109df: e9 39 ff ff ff jmp 11091d p = info->doubly_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 1109e4: 89 55 e0 mov %edx,-0x20(%ebp) 1109e7: e8 dc fe ff ff call 1108c8 if ( !p ) 1109ec: 85 c0 test %eax,%eax 1109ee: 8b 55 e0 mov -0x20(%ebp),%edx 1109f1: 0f 84 75 ff ff ff je 11096c <== NEVER TAKEN return 0; info->doubly_indirect = p; 1109f7: 89 43 5c mov %eax,0x5c(%ebx) 1109fa: e9 4f ff ff ff jmp 11094e } p1 = (block_p *)p[ doubly ]; if ( !p1 ) { p1 = memfile_alloc_block(); 1109ff: 89 55 e0 mov %edx,-0x20(%ebp) 110a02: e8 c1 fe ff ff call 1108c8 if ( !p1 ) 110a07: 85 c0 test %eax,%eax 110a09: 8b 55 e0 mov -0x20(%ebp),%edx 110a0c: 0f 84 5a ff ff ff je 11096c <== NEVER TAKEN return 0; p[ doubly ] = (block_p) p1; 110a12: 89 03 mov %eax,(%ebx) 110a14: e9 42 ff ff ff jmp 11095b p1[ doubly ] = (block_p) p2; } return (block_p *)&p2[ singly ]; } if ( !p ) 110a19: 85 c9 test %ecx,%ecx 110a1b: 0f 84 4b ff ff ff je 11096c <== NEVER TAKEN return 0; p1 = (block_p *) p[ triply ]; 110a21: 8b 04 81 mov (%ecx,%eax,4),%eax if ( !p1 ) 110a24: 85 c0 test %eax,%eax 110a26: 0f 84 40 ff ff ff je 11096c <== NEVER TAKEN return 0; p2 = (block_p *)p1[ doubly ]; 110a2c: 8b 14 90 mov (%eax,%edx,4),%edx if ( !p2 ) return 0; 110a2f: 31 c0 xor %eax,%eax p1 = (block_p *) p[ triply ]; if ( !p1 ) return 0; p2 = (block_p *)p1[ doubly ]; if ( !p2 ) 110a31: 85 d2 test %edx,%edx 110a33: 75 84 jne 1109b9 <== ALWAYS TAKEN 110a35: e9 24 ff ff ff jmp 11095e <== NOT EXECUTED p = info->triply_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 110a3a: 89 55 e0 mov %edx,-0x20(%ebp) 110a3d: e8 86 fe ff ff call 1108c8 110a42: 89 c1 mov %eax,%ecx if ( !p ) return 0; 110a44: 31 c0 xor %eax,%eax p = info->triply_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); if ( !p ) 110a46: 85 c9 test %ecx,%ecx 110a48: 8b 55 e0 mov -0x20(%ebp),%edx 110a4b: 0f 84 0d ff ff ff je 11095e <== NEVER TAKEN return 0; info->triply_indirect = p; 110a51: 89 4b 60 mov %ecx,0x60(%ebx) 110a54: e9 46 ff ff ff jmp 11099f p[ triply ] = (block_p) p1; } p2 = (block_p *)p1[ doubly ]; if ( !p2 ) { p2 = memfile_alloc_block(); 110a59: e8 6a fe ff ff call 1108c8 110a5e: 89 c2 mov %eax,%edx if ( !p2 ) return 0; 110a60: 31 c0 xor %eax,%eax } p2 = (block_p *)p1[ doubly ]; if ( !p2 ) { p2 = memfile_alloc_block(); if ( !p2 ) 110a62: 85 d2 test %edx,%edx 110a64: 0f 84 f4 fe ff ff je 11095e <== NEVER TAKEN return 0; p1[ doubly ] = (block_p) p2; 110a6a: 89 13 mov %edx,(%ebx) 110a6c: e9 48 ff ff ff jmp 1109b9 info->triply_indirect = p; } p1 = (block_p *) p[ triply ]; if ( !p1 ) { p1 = memfile_alloc_block(); 110a71: 89 55 e0 mov %edx,-0x20(%ebp) 110a74: e8 4f fe ff ff call 1108c8 110a79: 89 c1 mov %eax,%ecx if ( !p1 ) return 0; 110a7b: 31 c0 xor %eax,%eax } p1 = (block_p *) p[ triply ]; if ( !p1 ) { p1 = memfile_alloc_block(); if ( !p1 ) 110a7d: 85 c9 test %ecx,%ecx 110a7f: 8b 55 e0 mov -0x20(%ebp),%edx 110a82: 0f 84 d6 fe ff ff je 11095e <== NEVER TAKEN return 0; p[ triply ] = (block_p) p1; 110a88: 89 0b mov %ecx,(%ebx) 110a8a: e9 1d ff ff ff jmp 1109ac =============================================================================== 00110a90 : IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) { 110a90: 55 push %ebp 110a91: 89 e5 mov %esp,%ebp 110a93: 57 push %edi 110a94: 56 push %esi 110a95: 53 push %ebx 110a96: 83 ec 3c sub $0x3c,%esp 110a99: 8b 75 0c mov 0xc(%ebp),%esi 110a9c: 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) { 110a9f: 8b 45 08 mov 0x8(%ebp),%eax 110aa2: 83 78 4c 06 cmpl $0x6,0x4c(%eax) 110aa6: 0f 84 60 01 00 00 je 110c0c /* * 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; 110aac: 89 f0 mov %esi,%eax if ( last_byte > the_jnode->info.file.size ) 110aae: 8b 55 08 mov 0x8(%ebp),%edx 110ab1: 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; 110ab4: 8b 5d 18 mov 0x18(%ebp),%ebx 110ab7: 01 f3 add %esi,%ebx 110ab9: 89 5d d0 mov %ebx,-0x30(%ebp) if ( last_byte > the_jnode->info.file.size ) 110abc: 31 d2 xor %edx,%edx 110abe: 8b 5d 08 mov 0x8(%ebp),%ebx 110ac1: 3b 53 54 cmp 0x54(%ebx),%edx 110ac4: 0f 8d d2 00 00 00 jge 110b9c <== ALWAYS TAKEN /* * Linear files (as created from a tar file are easier to handle * than block files). */ my_length = length; 110aca: 8b 45 18 mov 0x18(%ebp),%eax 110acd: 89 45 cc mov %eax,-0x34(%ebp) */ /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 110ad0: 8b 15 20 60 12 00 mov 0x126020,%edx 110ad6: 89 55 d0 mov %edx,-0x30(%ebp) 110ad9: 89 d0 mov %edx,%eax 110adb: 99 cltd 110adc: 89 d3 mov %edx,%ebx 110ade: 52 push %edx 110adf: 50 push %eax 110ae0: 57 push %edi 110ae1: 56 push %esi 110ae2: 89 45 c0 mov %eax,-0x40(%ebp) 110ae5: e8 42 cc 00 00 call 11d72c <__moddi3> 110aea: 83 c4 10 add $0x10,%esp 110aed: 89 45 c8 mov %eax,-0x38(%ebp) block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 110af0: 8b 4d c0 mov -0x40(%ebp),%ecx 110af3: 53 push %ebx 110af4: 51 push %ecx 110af5: 57 push %edi 110af6: 56 push %esi 110af7: e8 e4 ca 00 00 call 11d5e0 <__divdi3> 110afc: 83 c4 10 add $0x10,%esp 110aff: 89 c3 mov %eax,%ebx if ( start_offset ) { 110b01: 8b 7d c8 mov -0x38(%ebp),%edi 110b04: 85 ff test %edi,%edi 110b06: 0f 84 a0 00 00 00 je 110bac 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 ); 110b0c: 56 push %esi 110b0d: 6a 00 push $0x0 110b0f: 50 push %eax 110b10: ff 75 08 pushl 0x8(%ebp) 110b13: e8 d4 fd ff ff call 1108ec if ( !block_ptr ) 110b18: 83 c4 10 add $0x10,%esp 110b1b: 85 c0 test %eax,%eax 110b1d: 0f 84 65 01 00 00 je 110c88 <== 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; 110b23: 8b 4d d0 mov -0x30(%ebp),%ecx 110b26: 2b 4d c8 sub -0x38(%ebp),%ecx 110b29: 8b 55 cc mov -0x34(%ebp),%edx 110b2c: 39 ca cmp %ecx,%edx 110b2e: 0f 87 3c 01 00 00 ja 110c70 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 ); 110b34: 8b 75 c8 mov -0x38(%ebp),%esi 110b37: 03 30 add (%eax),%esi dest += to_copy; 110b39: 8b 7d 14 mov 0x14(%ebp),%edi 110b3c: 89 d1 mov %edx,%ecx 110b3e: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 110b40: 89 7d c8 mov %edi,-0x38(%ebp) block++; 110b43: 43 inc %ebx my_length -= to_copy; 110b44: 29 55 cc sub %edx,-0x34(%ebp) 110b47: a1 20 60 12 00 mov 0x126020,%eax 110b4c: 89 45 d0 mov %eax,-0x30(%ebp) copied += to_copy; 110b4f: 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 ) { 110b52: 8b 4d d0 mov -0x30(%ebp),%ecx 110b55: 39 4d cc cmp %ecx,-0x34(%ebp) 110b58: 73 24 jae 110b7e 110b5a: eb 60 jmp 110bbc block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); 110b5c: 8b 30 mov (%eax),%esi 110b5e: 8b 7d c8 mov -0x38(%ebp),%edi 110b61: 8b 4d d0 mov -0x30(%ebp),%ecx 110b64: f3 a4 rep movsb %ds:(%esi),%es:(%edi) dest += to_copy; 110b66: 89 7d c8 mov %edi,-0x38(%ebp) block++; 110b69: 43 inc %ebx my_length -= to_copy; 110b6a: 8b 7d d0 mov -0x30(%ebp),%edi 110b6d: 29 7d cc sub %edi,-0x34(%ebp) copied += to_copy; 110b70: 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 ) { 110b73: 8b 45 cc mov -0x34(%ebp),%eax 110b76: 39 05 20 60 12 00 cmp %eax,0x126020 110b7c: 77 3e ja 110bbc block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 110b7e: 51 push %ecx 110b7f: 6a 00 push $0x0 110b81: 53 push %ebx 110b82: ff 75 08 pushl 0x8(%ebp) 110b85: e8 62 fd ff ff call 1108ec if ( !block_ptr ) 110b8a: 83 c4 10 add $0x10,%esp 110b8d: 85 c0 test %eax,%eax 110b8f: 75 cb jne 110b5c <== 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; 110b91: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED } IMFS_update_atime( the_jnode ); return copied; } 110b94: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 110b97: 5b pop %ebx <== NOT EXECUTED 110b98: 5e pop %esi <== NOT EXECUTED 110b99: 5f pop %edi <== NOT EXECUTED 110b9a: c9 leave <== NOT EXECUTED 110b9b: 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 ) 110b9c: 0f 8e be 00 00 00 jle 110c60 <== ALWAYS TAKEN my_length = the_jnode->info.file.size - start; 110ba2: 29 c1 sub %eax,%ecx 110ba4: 89 4d cc mov %ecx,-0x34(%ebp) 110ba7: e9 24 ff ff ff jmp 110ad0 unsigned int last_byte; unsigned int copied; unsigned int start_offset; unsigned char *dest; dest = destination; 110bac: 8b 55 14 mov 0x14(%ebp),%edx 110baf: 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; 110bb2: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) 110bb9: eb 97 jmp 110b52 110bbb: 90 nop /* * Phase 3: possibly the first part of one block */ IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { 110bbc: 8b 55 cc mov -0x34(%ebp),%edx 110bbf: 85 d2 test %edx,%edx 110bc1: 74 23 je 110be6 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 110bc3: 50 push %eax 110bc4: 6a 00 push $0x0 110bc6: 53 push %ebx 110bc7: ff 75 08 pushl 0x8(%ebp) 110bca: e8 1d fd ff ff call 1108ec if ( !block_ptr ) 110bcf: 83 c4 10 add $0x10,%esp 110bd2: 85 c0 test %eax,%eax 110bd4: 74 bb je 110b91 <== NEVER TAKEN return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); 110bd6: 8b 30 mov (%eax),%esi 110bd8: 8b 7d c8 mov -0x38(%ebp),%edi 110bdb: 8b 4d cc mov -0x34(%ebp),%ecx 110bde: f3 a4 rep movsb %ds:(%esi),%es:(%edi) copied += my_length; 110be0: 8b 55 cc mov -0x34(%ebp),%edx 110be3: 01 55 c4 add %edx,-0x3c(%ebp) } IMFS_update_atime( the_jnode ); 110be6: 83 ec 08 sub $0x8,%esp 110be9: 6a 00 push $0x0 110beb: 8d 45 e0 lea -0x20(%ebp),%eax 110bee: 50 push %eax 110bef: e8 bc 6a ff ff call 1076b0 110bf4: 8b 45 e0 mov -0x20(%ebp),%eax 110bf7: 8b 4d 08 mov 0x8(%ebp),%ecx 110bfa: 89 41 40 mov %eax,0x40(%ecx) return copied; 110bfd: 8b 45 c4 mov -0x3c(%ebp),%eax 110c00: 83 c4 10 add $0x10,%esp } 110c03: 8d 65 f4 lea -0xc(%ebp),%esp 110c06: 5b pop %ebx 110c07: 5e pop %esi 110c08: 5f pop %edi 110c09: c9 leave 110c0a: c3 ret 110c0b: 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; 110c0c: 8b 50 58 mov 0x58(%eax),%edx 110c0f: 89 55 cc mov %edx,-0x34(%ebp) if (my_length > (the_jnode->info.linearfile.size - start)) 110c12: 89 c1 mov %eax,%ecx 110c14: 8b 40 50 mov 0x50(%eax),%eax 110c17: 8b 51 54 mov 0x54(%ecx),%edx 110c1a: 89 c1 mov %eax,%ecx 110c1c: 89 d3 mov %edx,%ebx 110c1e: 29 f1 sub %esi,%ecx 110c20: 19 fb sbb %edi,%ebx 110c22: 89 4d d0 mov %ecx,-0x30(%ebp) 110c25: 89 5d d4 mov %ebx,-0x2c(%ebp) 110c28: 31 c9 xor %ecx,%ecx 110c2a: 39 d9 cmp %ebx,%ecx 110c2c: 7d 4a jge 110c78 <== ALWAYS TAKEN /* * Linear files (as created from a tar file are easier to handle * than block files). */ my_length = length; 110c2e: 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); 110c31: 03 75 cc add -0x34(%ebp),%esi 110c34: 8b 7d 14 mov 0x14(%ebp),%edi 110c37: 89 d9 mov %ebx,%ecx 110c39: f3 a4 rep movsb %ds:(%esi),%es:(%edi) IMFS_update_atime( the_jnode ); 110c3b: 83 ec 08 sub $0x8,%esp 110c3e: 6a 00 push $0x0 110c40: 8d 45 e0 lea -0x20(%ebp),%eax 110c43: 50 push %eax 110c44: e8 67 6a ff ff call 1076b0 110c49: 8b 45 e0 mov -0x20(%ebp),%eax 110c4c: 8b 7d 08 mov 0x8(%ebp),%edi 110c4f: 89 47 40 mov %eax,0x40(%edi) return my_length; 110c52: 89 d8 mov %ebx,%eax 110c54: 83 c4 10 add $0x10,%esp } IMFS_update_atime( the_jnode ); return copied; } 110c57: 8d 65 f4 lea -0xc(%ebp),%esp 110c5a: 5b pop %ebx 110c5b: 5e pop %esi 110c5c: 5f pop %edi 110c5d: c9 leave 110c5e: c3 ret 110c5f: 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 ) 110c60: 39 4d d0 cmp %ecx,-0x30(%ebp) 110c63: 0f 86 61 fe ff ff jbe 110aca 110c69: e9 34 ff ff ff jmp 110ba2 110c6e: 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; 110c70: 89 ca mov %ecx,%edx 110c72: e9 bd fe ff ff jmp 110b34 110c77: 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)) 110c78: 7f 08 jg 110c82 <== NEVER TAKEN 110c7a: 8b 5d d0 mov -0x30(%ebp),%ebx 110c7d: 39 5d 18 cmp %ebx,0x18(%ebp) 110c80: 76 ac jbe 110c2e <== NEVER TAKEN my_length = the_jnode->info.linearfile.size - start; 110c82: 89 c3 mov %eax,%ebx 110c84: 29 f3 sub %esi,%ebx 110c86: eb a9 jmp 110c31 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; 110c88: 31 c0 xor %eax,%eax 110c8a: e9 05 ff ff ff jmp 110b94 <== NOT EXECUTED =============================================================================== 00110d68 : * is better to stick to simple, easy to understand algorithms. */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) { 110d68: 55 push %ebp 110d69: 89 e5 mov %esp,%ebp 110d6b: 57 push %edi 110d6c: 56 push %esi 110d6d: 53 push %ebx 110d6e: 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; 110d71: 8b 3d 20 60 12 00 mov 0x126020,%edi 110d77: c1 ef 02 shr $0x2,%edi * + doubly indirect * + triply indirect */ info = &the_jnode->info.file; if ( info->indirect ) { 110d7a: 8b 45 08 mov 0x8(%ebp),%eax 110d7d: 8b 50 58 mov 0x58(%eax),%edx 110d80: 85 d2 test %edx,%edx 110d82: 74 10 je 110d94 memfile_free_blocks_in_table( &info->indirect, to_free ); 110d84: 83 ec 08 sub $0x8,%esp 110d87: 57 push %edi 110d88: 83 c0 58 add $0x58,%eax 110d8b: 50 push %eax 110d8c: e8 7b ff ff ff call 110d0c 110d91: 83 c4 10 add $0x10,%esp } if ( info->doubly_indirect ) { 110d94: 8b 4d 08 mov 0x8(%ebp),%ecx 110d97: 8b 51 5c mov 0x5c(%ecx),%edx 110d9a: 85 d2 test %edx,%edx 110d9c: 74 55 je 110df3 for ( i=0 ; i<== NEVER TAKEN 110daa: 31 c9 xor %ecx,%ecx 110dac: 31 db xor %ebx,%ebx 110dae: 8b 75 08 mov 0x8(%ebp),%esi 110db1: eb 04 jmp 110db7 110db3: 90 nop 110db4: 8b 56 5c mov 0x5c(%esi),%edx if ( info->doubly_indirect[i] ) { 110db7: c1 e1 02 shl $0x2,%ecx 110dba: 83 3c 0a 00 cmpl $0x0,(%edx,%ecx,1) 110dbe: 74 14 je 110dd4 <== NEVER TAKEN memfile_free_blocks_in_table( 110dc0: 83 ec 08 sub $0x8,%esp 110dc3: 57 push %edi 110dc4: 01 ca add %ecx,%edx 110dc6: 52 push %edx 110dc7: e8 40 ff ff ff call 110d0c 110dcc: 83 c4 10 add $0x10,%esp 110dcf: a1 20 60 12 00 mov 0x126020,%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 ); 110de0: 83 ec 08 sub $0x8,%esp 110de3: 57 push %edi 110de4: 8b 45 08 mov 0x8(%ebp),%eax 110de7: 83 c0 5c add $0x5c,%eax 110dea: 50 push %eax 110deb: e8 1c ff ff ff call 110d0c 110df0: 83 c4 10 add $0x10,%esp } if ( info->triply_indirect ) { 110df3: 8b 45 08 mov 0x8(%ebp),%eax 110df6: 8b 50 60 mov 0x60(%eax),%edx 110df9: 85 d2 test %edx,%edx 110dfb: 0f 84 b6 00 00 00 je 110eb7 for ( i=0 ; i<== NEVER TAKEN p = (block_p *) info->triply_indirect[i]; 110e11: 8b 32 mov (%edx),%esi if ( !p ) /* ensure we have a valid pointer */ 110e13: 85 f6 test %esi,%esi 110e15: 0f 84 89 00 00 00 je 110ea4 <== NEVER TAKEN } if ( info->triply_indirect ) { for ( i=0 ; itriply_indirect[i]; 110e1b: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) if ( !p ) /* ensure we have a valid pointer */ 110e22: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 110e29: 8d 76 00 lea 0x0(%esi),%esi break; for ( j=0 ; j<== NEVER TAKEN 110e33: 31 d2 xor %edx,%edx 110e35: 31 db xor %ebx,%ebx 110e37: 90 nop if ( p[j] ) { 110e38: c1 e2 02 shl $0x2,%edx 110e3b: 8b 0c 16 mov (%esi,%edx,1),%ecx 110e3e: 85 c9 test %ecx,%ecx 110e40: 74 15 je 110e57 <== NEVER TAKEN memfile_free_blocks_in_table( (block_p **)&p[j], to_free); 110e42: 83 ec 08 sub $0x8,%esp 110e45: 57 push %edi 110e46: 8d 14 16 lea (%esi,%edx,1),%edx 110e49: 52 push %edx 110e4a: e8 bd fe ff ff call 110d0c 110e4f: 83 c4 10 add $0x10,%esp 110e52: a1 20 60 12 00 mov 0x126020,%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( 110e63: 83 ec 08 sub $0x8,%esp 110e66: 57 push %edi 110e67: 8b 45 e0 mov -0x20(%ebp),%eax 110e6a: 8b 4d 08 mov 0x8(%ebp),%ecx 110e6d: 03 41 60 add 0x60(%ecx),%eax 110e70: 50 push %eax 110e71: e8 96 fe ff ff call 110d0c 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 */ 110e8b: 8b 55 e4 mov -0x1c(%ebp),%edx 110e8e: c1 e2 02 shl $0x2,%edx 110e91: 89 55 e0 mov %edx,-0x20(%ebp) } if ( info->triply_indirect ) { for ( i=0 ; itriply_indirect[i]; 110e94: 8b 4d 08 mov 0x8(%ebp),%ecx 110e97: 8b 51 60 mov 0x60(%ecx),%edx 110e9a: 8b 4d e0 mov -0x20(%ebp),%ecx 110e9d: 8b 34 0a mov (%edx,%ecx,1),%esi if ( !p ) /* ensure we have a valid pointer */ 110ea0: 85 f6 test %esi,%esi 110ea2: 75 88 jne 110e2c <== ALWAYS TAKEN } } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( 110ea4: 83 ec 08 sub $0x8,%esp 110ea7: 57 push %edi (block_p **)&info->triply_indirect, to_free ); 110ea8: 8b 45 08 mov 0x8(%ebp),%eax 110eab: 83 c0 60 add $0x60,%eax } } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( 110eae: 50 push %eax 110eaf: e8 58 fe ff ff call 110d0c 110eb4: 83 c4 10 add $0x10,%esp (block_p **)&info->triply_indirect, to_free ); } return 0; } 110eb7: 31 c0 xor %eax,%eax 110eb9: 8d 65 f4 lea -0xc(%ebp),%esp 110ebc: 5b pop %ebx 110ebd: 5e pop %esi 110ebe: 5f pop %edi 110ebf: c9 leave 110ec0: c3 ret =============================================================================== 00111008 : IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 111008: 55 push %ebp 111009: 89 e5 mov %esp,%ebp 11100b: 57 push %edi 11100c: 56 push %esi 11100d: 53 push %ebx 11100e: 83 ec 3c sub $0x3c,%esp 111011: 8b 5d 0c mov 0xc(%ebp),%ebx 111014: 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; 111017: 8b 4d 18 mov 0x18(%ebp),%ecx 11101a: 01 d9 add %ebx,%ecx if ( last_byte > the_jnode->info.file.size ) { 11101c: 89 c8 mov %ecx,%eax 11101e: 31 d2 xor %edx,%edx 111020: 8b 7d 08 mov 0x8(%ebp),%edi 111023: 3b 57 54 cmp 0x54(%edi),%edx 111026: 7c 1c jl 111044 <== NEVER TAKEN 111028: 0f 8e f2 00 00 00 jle 111120 <== ALWAYS TAKEN status = IMFS_memfile_extend( the_jnode, last_byte ); 11102e: 51 push %ecx 11102f: 52 push %edx 111030: 50 push %eax 111031: ff 75 08 pushl 0x8(%ebp) 111034: e8 b7 fe ff ff call 110ef0 if ( status ) 111039: 83 c4 10 add $0x10,%esp 11103c: 85 c0 test %eax,%eax 11103e: 0f 85 52 01 00 00 jne 111196 */ /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 111044: a1 20 60 12 00 mov 0x126020,%eax 111049: 89 45 d4 mov %eax,-0x2c(%ebp) 11104c: 99 cltd 11104d: 89 45 c8 mov %eax,-0x38(%ebp) 111050: 89 55 cc mov %edx,-0x34(%ebp) 111053: 52 push %edx 111054: 50 push %eax 111055: 56 push %esi 111056: 53 push %ebx 111057: e8 d0 c6 00 00 call 11d72c <__moddi3> 11105c: 83 c4 10 add $0x10,%esp 11105f: 89 c7 mov %eax,%edi block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 111061: ff 75 cc pushl -0x34(%ebp) 111064: ff 75 c8 pushl -0x38(%ebp) 111067: 56 push %esi 111068: 53 push %ebx 111069: e8 72 c5 00 00 call 11d5e0 <__divdi3> 11106e: 83 c4 10 add $0x10,%esp 111071: 89 c3 mov %eax,%ebx if ( start_offset ) { 111073: 85 ff test %edi,%edi 111075: 75 5d jne 1110d4 unsigned int last_byte; unsigned int start_offset; int copied; const unsigned char *src; src = source; 111077: 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 ) { 11107a: 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; 11107d: 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 ) { 111084: 3b 55 d4 cmp -0x2c(%ebp),%edx 111087: 73 26 jae 1110af 111089: e9 a2 00 00 00 jmp 111130 11108e: 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 ); 111090: 8b 00 mov (%eax),%eax src += to_copy; 111092: 89 c7 mov %eax,%edi 111094: 8b 4d d4 mov -0x2c(%ebp),%ecx 111097: f3 a4 rep movsb %ds:(%esi),%es:(%edi) block++; 111099: 43 inc %ebx my_length -= to_copy; 11109a: 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( 11109d: 8b 45 d4 mov -0x2c(%ebp),%eax 1110a0: 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 ) { 1110a3: 39 15 20 60 12 00 cmp %edx,0x126020 1110a9: 0f 87 81 00 00 00 ja 111130 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 1110af: 57 push %edi 1110b0: 6a 00 push $0x0 1110b2: 53 push %ebx 1110b3: ff 75 08 pushl 0x8(%ebp) 1110b6: 89 55 c4 mov %edx,-0x3c(%ebp) 1110b9: e8 2e f8 ff ff call 1108ec if ( !block_ptr ) 1110be: 83 c4 10 add $0x10,%esp 1110c1: 85 c0 test %eax,%eax 1110c3: 8b 55 c4 mov -0x3c(%ebp),%edx 1110c6: 75 c8 jne 111090 <== 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 ) 1110c8: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED } IMFS_mtime_ctime_update( the_jnode ); return copied; } 1110cb: 8d 65 f4 lea -0xc(%ebp),%esp 1110ce: 5b pop %ebx 1110cf: 5e pop %esi 1110d0: 5f pop %edi 1110d1: c9 leave 1110d2: c3 ret 1110d3: 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 ); 1110d4: 50 push %eax 1110d5: 6a 00 push $0x0 1110d7: 53 push %ebx 1110d8: ff 75 08 pushl 0x8(%ebp) 1110db: e8 0c f8 ff ff call 1108ec if ( !block_ptr ) 1110e0: 83 c4 10 add $0x10,%esp 1110e3: 85 c0 test %eax,%eax 1110e5: 0f 84 a1 00 00 00 je 11118c <== 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; 1110eb: 8b 55 d4 mov -0x2c(%ebp),%edx 1110ee: 29 fa sub %edi,%edx 1110f0: 89 55 c8 mov %edx,-0x38(%ebp) 1110f3: 8b 55 18 mov 0x18(%ebp),%edx 1110f6: 39 55 c8 cmp %edx,-0x38(%ebp) 1110f9: 0f 87 85 00 00 00 ja 111184 block, to_copy, src ); #endif memcpy( &(*block_ptr)[ start_offset ], src, to_copy ); 1110ff: 03 38 add (%eax),%edi src += to_copy; 111101: 8b 75 14 mov 0x14(%ebp),%esi 111104: 8b 4d c8 mov -0x38(%ebp),%ecx 111107: f3 a4 rep movsb %ds:(%esi),%es:(%edi) block++; 111109: 43 inc %ebx my_length -= to_copy; 11110a: 8b 55 18 mov 0x18(%ebp),%edx 11110d: 2b 55 c8 sub -0x38(%ebp),%edx copied += to_copy; 111110: 8b 3d 20 60 12 00 mov 0x126020,%edi 111116: 89 7d d4 mov %edi,-0x2c(%ebp) 111119: e9 66 ff ff ff jmp 111084 11111e: 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 ) { 111120: 3b 4f 50 cmp 0x50(%edi),%ecx 111123: 0f 86 1b ff ff ff jbe 111044 <== NEVER TAKEN 111129: e9 00 ff ff ff jmp 11102e 11112e: 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 ) { 111130: 85 d2 test %edx,%edx 111132: 74 28 je 11115c block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 111134: 51 push %ecx 111135: 6a 00 push $0x0 111137: 53 push %ebx 111138: ff 75 08 pushl 0x8(%ebp) 11113b: 89 55 c4 mov %edx,-0x3c(%ebp) 11113e: e8 a9 f7 ff ff call 1108ec if ( !block_ptr ) 111143: 83 c4 10 add $0x10,%esp 111146: 85 c0 test %eax,%eax 111148: 8b 55 c4 mov -0x3c(%ebp),%edx 11114b: 0f 84 77 ff ff ff je 1110c8 <== 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 ); 111151: 8b 00 mov (%eax),%eax 111153: 89 c7 mov %eax,%edi 111155: 89 d1 mov %edx,%ecx 111157: f3 a4 rep movsb %ds:(%esi),%es:(%edi) my_length = 0; copied += to_copy; 111159: 01 55 c8 add %edx,-0x38(%ebp) } IMFS_mtime_ctime_update( the_jnode ); 11115c: 83 ec 08 sub $0x8,%esp 11115f: 6a 00 push $0x0 111161: 8d 45 e0 lea -0x20(%ebp),%eax 111164: 50 push %eax 111165: e8 46 65 ff ff call 1076b0 11116a: 8b 45 e0 mov -0x20(%ebp),%eax 11116d: 8b 55 08 mov 0x8(%ebp),%edx 111170: 89 42 44 mov %eax,0x44(%edx) 111173: 89 42 48 mov %eax,0x48(%edx) return copied; 111176: 83 c4 10 add $0x10,%esp 111179: 8b 45 c8 mov -0x38(%ebp),%eax } 11117c: 8d 65 f4 lea -0xc(%ebp),%esp 11117f: 5b pop %ebx 111180: 5e pop %esi 111181: 5f pop %edi 111182: c9 leave 111183: 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; 111184: 89 55 c8 mov %edx,-0x38(%ebp) 111187: e9 73 ff ff ff jmp 1110ff 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; 11118c: 31 c0 xor %eax,%eax } IMFS_mtime_ctime_update( the_jnode ); return copied; } 11118e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111191: 5b pop %ebx <== NOT EXECUTED 111192: 5e pop %esi <== NOT EXECUTED 111193: 5f pop %edi <== NOT EXECUTED 111194: c9 leave <== NOT EXECUTED 111195: 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 ); 111196: e8 41 0c 00 00 call 111ddc <__errno> 11119b: c7 00 1c 00 00 00 movl $0x1c,(%eax) 1111a1: 83 c8 ff or $0xffffffff,%eax 1111a4: e9 22 ff ff ff jmp 1110cb =============================================================================== 00106f3c : const char *token, /* IN */ mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 106f3c: 55 push %ebp 106f3d: 89 e5 mov %esp,%ebp 106f3f: 57 push %edi 106f40: 56 push %esi 106f41: 53 push %ebx 106f42: 83 ec 5c sub $0x5c,%esp 106f45: 8b 55 08 mov 0x8(%ebp),%edx 106f48: 8b 5d 0c mov 0xc(%ebp),%ebx 106f4b: 8b 75 10 mov 0x10(%ebp),%esi 106f4e: 8b 45 14 mov 0x14(%ebp),%eax 106f51: 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 ); 106f54: 31 c0 xor %eax,%eax 106f56: b9 ff ff ff ff mov $0xffffffff,%ecx 106f5b: 89 d7 mov %edx,%edi 106f5d: f2 ae repnz scas %es:(%edi),%al 106f5f: f7 d1 not %ecx 106f61: 49 dec %ecx 106f62: 8d 45 e4 lea -0x1c(%ebp),%eax 106f65: 50 push %eax 106f66: 8d 7d af lea -0x51(%ebp),%edi 106f69: 57 push %edi 106f6a: 51 push %ecx 106f6b: 52 push %edx 106f6c: e8 0b 7e 00 00 call 10ed7c /* * Figure out what type of IMFS node this is. */ if ( S_ISDIR(mode) ) 106f71: 89 d8 mov %ebx,%eax 106f73: 25 00 f0 00 00 and $0xf000,%eax 106f78: 83 c4 10 add $0x10,%esp 106f7b: 3d 00 40 00 00 cmp $0x4000,%eax 106f80: 74 56 je 106fd8 type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) 106f82: 3d 00 80 00 00 cmp $0x8000,%eax 106f87: 74 57 je 106fe0 type = IMFS_MEMORY_FILE; else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { 106f89: 3d 00 60 00 00 cmp $0x6000,%eax 106f8e: 74 14 je 106fa4 106f90: 3d 00 20 00 00 cmp $0x2000,%eax 106f95: 74 0d je 106fa4 type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor ); } else if (S_ISFIFO(mode)) 106f97: 3d 00 10 00 00 cmp $0x1000,%eax 106f9c: 74 4a je 106fe8 <== ALWAYS TAKEN mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { IMFS_token_types type = 0; 106f9e: 31 d2 xor %edx,%edx <== NOT EXECUTED 106fa0: eb 10 jmp 106fb2 <== NOT EXECUTED 106fa2: 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 ); 106fa4: 89 75 d0 mov %esi,-0x30(%ebp) dev_t device ) { union __rtems_dev_t temp; temp.device = device; 106fa7: 8b 45 a4 mov -0x5c(%ebp),%eax 106faa: 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; 106fad: 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 ); 106fb2: 83 ec 0c sub $0xc,%esp 106fb5: 8d 45 d0 lea -0x30(%ebp),%eax 106fb8: 50 push %eax 106fb9: 53 push %ebx 106fba: 57 push %edi 106fbb: 52 push %edx 106fbc: ff 75 18 pushl 0x18(%ebp) 106fbf: e8 20 74 00 00 call 10e3e4 if ( !new_node ) 106fc4: 83 c4 20 add $0x20,%esp 106fc7: 85 c0 test %eax,%eax 106fc9: 74 24 je 106fef rtems_set_errno_and_return_minus_one( ENOMEM ); return 0; 106fcb: 31 c0 xor %eax,%eax } 106fcd: 8d 65 f4 lea -0xc(%ebp),%esp 106fd0: 5b pop %ebx 106fd1: 5e pop %esi 106fd2: 5f pop %edi 106fd3: c9 leave 106fd4: c3 ret 106fd5: 8d 76 00 lea 0x0(%esi),%esi /* * Figure out what type of IMFS node this is. */ if ( S_ISDIR(mode) ) type = IMFS_DIRECTORY; 106fd8: ba 01 00 00 00 mov $0x1,%edx 106fdd: eb d3 jmp 106fb2 106fdf: 90 nop else if ( S_ISREG(mode) ) type = IMFS_MEMORY_FILE; 106fe0: ba 05 00 00 00 mov $0x5,%edx 106fe5: eb cb jmp 106fb2 106fe7: 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; 106fe8: ba 07 00 00 00 mov $0x7,%edx 106fed: eb c3 jmp 106fb2 * 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 ); 106fef: e8 e8 ad 00 00 call 111ddc <__errno> 106ff4: c7 00 0c 00 00 00 movl $0xc,(%eax) 106ffa: b8 ff ff ff ff mov $0xffffffff,%eax 106fff: eb cc jmp 106fcd =============================================================================== 00107004 : #include int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 107004: 55 push %ebp 107005: 89 e5 mov %esp,%ebp 107007: 83 ec 08 sub $0x8,%esp 10700a: 8b 55 08 mov 0x8(%ebp),%edx IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 10700d: 8b 42 08 mov 0x8(%edx),%eax /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 107010: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 107014: 75 0a jne 107020 <== 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; 107016: 89 50 5c mov %edx,0x5c(%eax) return 0; 107019: 31 c0 xor %eax,%eax } 10701b: c9 leave 10701c: c3 ret 10701d: 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 ); 107020: e8 b7 ad 00 00 call 111ddc <__errno> <== NOT EXECUTED 107025: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 10702b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED * the mounted file system. */ node->info.directory.mt_fs = mt_entry; return 0; } 107030: c9 leave <== NOT EXECUTED 107031: c3 ret <== NOT EXECUTED =============================================================================== 00109920 : * This routine prints the contents of the specified jnode. */ void IMFS_print_jnode( IMFS_jnode_t *the_jnode ) { 109920: 55 push %ebp 109921: 89 e5 mov %esp,%ebp 109923: 53 push %ebx 109924: 83 ec 0c sub $0xc,%esp 109927: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_assert( the_jnode ); fprintf(stdout, "%s", the_jnode->name ); 10992a: a1 00 ab 12 00 mov 0x12ab00,%eax 10992f: ff 70 08 pushl 0x8(%eax) 109932: 8d 43 0c lea 0xc(%ebx),%eax 109935: 50 push %eax 109936: e8 f9 ca 00 00 call 116434 switch( the_jnode->type ) { 10993b: 8b 43 4c mov 0x4c(%ebx),%eax 10993e: 83 c4 10 add $0x10,%esp 109941: 83 f8 07 cmp $0x7,%eax 109944: 76 1e jbe 109964 <== ALWAYS TAKEN case IMFS_FIFO: fprintf(stdout, " FIFO not printed\n" ); return; default: fprintf(stdout, " bad type %d\n", the_jnode->type ); 109946: 52 push %edx <== NOT EXECUTED 109947: 50 push %eax <== NOT EXECUTED 109948: 68 04 5b 12 00 push $0x125b04 <== NOT EXECUTED 10994d: a1 00 ab 12 00 mov 0x12ab00,%eax <== NOT EXECUTED 109952: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 109955: e8 ce c9 00 00 call 116328 <== NOT EXECUTED return; 10995a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } puts(""); } 10995d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109960: c9 leave <== NOT EXECUTED 109961: c3 ret <== NOT EXECUTED 109962: 66 90 xchg %ax,%ax <== NOT EXECUTED ) { IMFS_assert( the_jnode ); fprintf(stdout, "%s", the_jnode->name ); switch( the_jnode->type ) { 109964: ff 24 85 1c 5b 12 00 jmp *0x125b1c(,%eax,4) 10996b: 90 nop case IMFS_HARD_LINK: fprintf(stdout, " links not printed\n" ); return; case IMFS_SYM_LINK: fprintf(stdout, " links not printed\n" ); 10996c: a1 00 ab 12 00 mov 0x12ab00,%eax 109971: ff 70 08 pushl 0x8(%eax) 109974: 6a 13 push $0x13 109976: 6a 01 push $0x1 109978: 68 dd 5a 12 00 push $0x125add 10997d: e8 d6 d6 00 00 call 117058 return; 109982: 83 c4 10 add $0x10,%esp default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); } 109985: 8b 5d fc mov -0x4(%ebp),%ebx 109988: c9 leave 109989: c3 ret 10998a: 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" ); 10998c: a1 00 ab 12 00 mov 0x12ab00,%eax 109991: ff 70 08 pushl 0x8(%eax) 109994: 6a 12 push $0x12 109996: 6a 01 push $0x1 109998: 68 f1 5a 12 00 push $0x125af1 10999d: e8 b6 d6 00 00 call 117058 return; 1099a2: 83 c4 10 add $0x10,%esp default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); } 1099a5: 8b 5d fc mov -0x4(%ebp),%ebx 1099a8: c9 leave 1099a9: c3 ret 1099aa: 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 ")", 1099ac: 51 push %ecx 1099ad: ff 73 50 pushl 0x50(%ebx) 1099b0: 68 d1 5a 12 00 push $0x125ad1 1099b5: a1 00 ab 12 00 mov 0x12ab00,%eax 1099ba: ff 70 08 pushl 0x8(%eax) 1099bd: e8 66 c9 00 00 call 116328 (uint32_t)the_jnode->info.file.size ); #endif break; 1099c2: 83 c4 10 add $0x10,%esp default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 1099c5: c7 45 08 09 5e 12 00 movl $0x125e09,0x8(%ebp) } 1099cc: 8b 5d fc mov -0x4(%ebp),%ebx 1099cf: c9 leave default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 1099d0: e9 83 e2 00 00 jmp 117c58 1099d5: 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)", 1099d8: ff 73 58 pushl 0x58(%ebx) 1099db: ff 73 50 pushl 0x50(%ebx) 1099de: 68 c2 5a 12 00 push $0x125ac2 1099e3: a1 00 ab 12 00 mov 0x12ab00,%eax 1099e8: ff 70 08 pushl 0x8(%eax) 1099eb: e8 38 c9 00 00 call 116328 (uint32_t)the_jnode->info.linearfile.size, the_jnode->info.linearfile.direct ); break; 1099f0: 83 c4 10 add $0x10,%esp default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 1099f3: c7 45 08 09 5e 12 00 movl $0x125e09,0x8(%ebp) } 1099fa: 8b 5d fc mov -0x4(%ebp),%ebx 1099fd: c9 leave default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 1099fe: e9 55 e2 00 00 jmp 117c58 109a03: 90 nop IMFS_assert( the_jnode ); fprintf(stdout, "%s", the_jnode->name ); switch( the_jnode->type ) { case IMFS_DIRECTORY: fprintf(stdout, "/" ); 109a04: 83 ec 08 sub $0x8,%esp 109a07: a1 00 ab 12 00 mov 0x12ab00,%eax 109a0c: ff 70 08 pushl 0x8(%eax) 109a0f: 6a 2f push $0x2f 109a11: e8 72 c9 00 00 call 116388 break; 109a16: 83 c4 10 add $0x10,%esp default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 109a19: c7 45 08 09 5e 12 00 movl $0x125e09,0x8(%ebp) } 109a20: 8b 5d fc mov -0x4(%ebp),%ebx 109a23: c9 leave default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 109a24: e9 2f e2 00 00 jmp 117c58 109a29: 8d 76 00 lea 0x0(%esi),%esi case IMFS_DIRECTORY: fprintf(stdout, "/" ); break; case IMFS_DEVICE: fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")", 109a2c: ff 73 54 pushl 0x54(%ebx) 109a2f: ff 73 50 pushl 0x50(%ebx) 109a32: 68 af 5a 12 00 push $0x125aaf 109a37: a1 00 ab 12 00 mov 0x12ab00,%eax 109a3c: ff 70 08 pushl 0x8(%eax) 109a3f: e8 e4 c8 00 00 call 116328 the_jnode->info.device.major, the_jnode->info.device.minor ); break; 109a44: 83 c4 10 add $0x10,%esp default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 109a47: c7 45 08 09 5e 12 00 movl $0x125e09,0x8(%ebp) } 109a4e: 8b 5d fc mov -0x4(%ebp),%ebx 109a51: c9 leave default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 109a52: e9 01 e2 00 00 jmp 117c58 =============================================================================== 00107044 : ssize_t IMFS_readlink( rtems_filesystem_location_info_t *loc, char *buf, /* OUT */ size_t bufsize ) { 107044: 55 push %ebp 107045: 89 e5 mov %esp,%ebp 107047: 57 push %edi 107048: 56 push %esi 107049: 53 push %ebx 10704a: 8b 7d 0c mov 0xc(%ebp),%edi 10704d: 8b 5d 10 mov 0x10(%ebp),%ebx IMFS_jnode_t *node; ssize_t i; node = loc->node_access; 107050: 8b 45 08 mov 0x8(%ebp),%eax 107053: 8b 30 mov (%eax),%esi IMFS_assert( node->type == IMFS_SYM_LINK ); for( i=0; ((iinfo.sym_link.name[i] != '\0')); i++ ) 107055: 85 db test %ebx,%ebx 107057: 74 28 je 107081 <== NEVER TAKEN 107059: 8b 46 50 mov 0x50(%esi),%eax 10705c: 8a 10 mov (%eax),%dl 10705e: 84 d2 test %dl,%dl 107060: 74 1f je 107081 <== NEVER TAKEN 107062: 31 c9 xor %ecx,%ecx 107064: 31 c0 xor %eax,%eax 107066: eb 0a jmp 107072 107068: 8b 56 50 mov 0x50(%esi),%edx 10706b: 8a 14 02 mov (%edx,%eax,1),%dl 10706e: 84 d2 test %dl,%dl 107070: 74 0a je 10707c buf[i] = node->info.sym_link.name[i]; 107072: 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++ ) 107075: 40 inc %eax 107076: 89 c1 mov %eax,%ecx 107078: 39 d8 cmp %ebx,%eax 10707a: 72 ec jb 107068 buf[i] = node->info.sym_link.name[i]; return i; } 10707c: 5b pop %ebx 10707d: 5e pop %esi 10707e: 5f pop %edi 10707f: c9 leave 107080: c3 ret node = loc->node_access; IMFS_assert( node->type == IMFS_SYM_LINK ); for( i=0; ((iinfo.sym_link.name[i] != '\0')); i++ ) 107081: 31 c0 xor %eax,%eax 107083: eb f7 jmp 10707c <== NOT EXECUTED =============================================================================== 00107088 : 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 */ ) { 107088: 55 push %ebp 107089: 89 e5 mov %esp,%ebp 10708b: 53 push %ebx 10708c: 83 ec 18 sub $0x18,%esp IMFS_jnode_t *the_jnode; IMFS_jnode_t *new_parent; the_jnode = old_loc->node_access; 10708f: 8b 45 0c mov 0xc(%ebp),%eax 107092: 8b 18 mov (%eax),%ebx strncpy( the_jnode->name, new_name, IMFS_NAME_MAX ); 107094: 6a 20 push $0x20 107096: ff 75 14 pushl 0x14(%ebp) 107099: 8d 43 0c lea 0xc(%ebx),%eax 10709c: 50 push %eax 10709d: e8 2a bb 00 00 call 112bcc if ( the_jnode->Parent != NULL ) 1070a2: 83 c4 10 add $0x10,%esp 1070a5: 8b 4b 08 mov 0x8(%ebx),%ecx 1070a8: 85 c9 test %ecx,%ecx 1070aa: 74 0c je 1070b8 <== NEVER TAKEN */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 1070ac: 83 ec 0c sub $0xc,%esp 1070af: 53 push %ebx 1070b0: e8 f3 43 00 00 call 10b4a8 <_Chain_Extract> 1070b5: 83 c4 10 add $0x10,%esp rtems_chain_extract( (rtems_chain_node *) the_jnode ); new_parent = new_parent_loc->node_access; 1070b8: 8b 45 10 mov 0x10(%ebp),%eax 1070bb: 8b 00 mov (%eax),%eax the_jnode->Parent = new_parent; 1070bd: 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 ); 1070c0: 83 ec 08 sub $0x8,%esp 1070c3: 53 push %ebx rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node ); 1070c4: 83 c0 50 add $0x50,%eax 1070c7: 50 push %eax 1070c8: e8 b7 43 00 00 call 10b484 <_Chain_Append> /* * Update the time. */ IMFS_update_ctime( the_jnode ); 1070cd: 58 pop %eax 1070ce: 5a pop %edx 1070cf: 6a 00 push $0x0 1070d1: 8d 45 f0 lea -0x10(%ebp),%eax 1070d4: 50 push %eax 1070d5: e8 d6 05 00 00 call 1076b0 1070da: 8b 45 f0 mov -0x10(%ebp),%eax 1070dd: 89 43 48 mov %eax,0x48(%ebx) return 0; } 1070e0: 31 c0 xor %eax,%eax 1070e2: 8b 5d fc mov -0x4(%ebp),%ebx 1070e5: c9 leave 1070e6: c3 ret =============================================================================== 0010ef48 : int IMFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 10ef48: 55 push %ebp 10ef49: 89 e5 mov %esp,%ebp 10ef4b: 56 push %esi 10ef4c: 53 push %ebx 10ef4d: 8b 4d 08 mov 0x8(%ebp),%ecx 10ef50: 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; 10ef53: 8b 11 mov (%ecx),%edx switch ( the_jnode->type ) { 10ef55: 83 7a 4c 07 cmpl $0x7,0x4c(%edx) 10ef59: 76 15 jbe 10ef70 <== ALWAYS TAKEN case IMFS_FIFO: buf->st_size = 0; break; default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 10ef5b: e8 7c 2e 00 00 call 111ddc <__errno> 10ef60: c7 00 86 00 00 00 movl $0x86,(%eax) 10ef66: 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; } 10ef6b: 5b pop %ebx 10ef6c: 5e pop %esi 10ef6d: c9 leave 10ef6e: c3 ret 10ef6f: 90 nop IMFS_device_t *io; the_jnode = loc->node_access; switch ( the_jnode->type ) { 10ef70: 8b 5a 4c mov 0x4c(%edx),%ebx 10ef73: ff 24 9d 58 03 12 00 jmp *0x120358(,%ebx,4) 10ef7a: 66 90 xchg %ax,%ax case IMFS_SYM_LINK: buf->st_size = 0; break; case IMFS_FIFO: buf->st_size = 0; 10ef7c: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) 10ef83: 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; 10ef8a: 8b 49 10 mov 0x10(%ecx),%ecx buf->st_dev = rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance ); 10ef8d: 8b 49 34 mov 0x34(%ecx),%ecx 10ef90: 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 = 10ef92: c7 00 fe ff 00 00 movl $0xfffe,(%eax) 10ef98: 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; 10ef9b: 8b 4a 30 mov 0x30(%edx),%ecx 10ef9e: 89 48 0c mov %ecx,0xc(%eax) buf->st_nlink = the_jnode->st_nlink; 10efa1: 8b 4a 34 mov 0x34(%edx),%ecx 10efa4: 66 89 48 10 mov %cx,0x10(%eax) buf->st_ino = the_jnode->st_ino; 10efa8: 8b 4a 38 mov 0x38(%edx),%ecx 10efab: 89 48 08 mov %ecx,0x8(%eax) buf->st_uid = the_jnode->st_uid; 10efae: 8b 4a 3c mov 0x3c(%edx),%ecx 10efb1: 66 89 48 12 mov %cx,0x12(%eax) buf->st_gid = the_jnode->st_gid; 10efb5: 66 8b 4a 3e mov 0x3e(%edx),%cx 10efb9: 66 89 48 14 mov %cx,0x14(%eax) buf->st_atime = the_jnode->stat_atime; 10efbd: 8b 4a 40 mov 0x40(%edx),%ecx 10efc0: 89 48 28 mov %ecx,0x28(%eax) buf->st_mtime = the_jnode->stat_mtime; 10efc3: 8b 4a 44 mov 0x44(%edx),%ecx 10efc6: 89 48 30 mov %ecx,0x30(%eax) buf->st_ctime = the_jnode->stat_ctime; 10efc9: 8b 52 48 mov 0x48(%edx),%edx 10efcc: 89 50 38 mov %edx,0x38(%eax) return 0; 10efcf: 31 c0 xor %eax,%eax } 10efd1: 5b pop %ebx 10efd2: 5e pop %esi 10efd3: c9 leave 10efd4: c3 ret 10efd5: 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 ); 10efd8: 8b 5a 54 mov 0x54(%edx),%ebx rtems_device_minor_number _minor ) { union __rtems_dev_t temp; temp.__overlay.major = _major; 10efdb: 8b 72 50 mov 0x50(%edx),%esi 10efde: 89 70 18 mov %esi,0x18(%eax) 10efe1: 89 58 1c mov %ebx,0x1c(%eax) break; 10efe4: eb a4 jmp 10ef8a 10efe6: 66 90 xchg %ax,%ax case IMFS_LINEAR_FILE: case IMFS_MEMORY_FILE: buf->st_size = the_jnode->info.file.size; 10efe8: 8b 5a 50 mov 0x50(%edx),%ebx 10efeb: 8b 72 54 mov 0x54(%edx),%esi 10efee: 89 58 20 mov %ebx,0x20(%eax) 10eff1: 89 70 24 mov %esi,0x24(%eax) break; 10eff4: eb 94 jmp 10ef8a =============================================================================== 0010717c : int IMFS_unlink( rtems_filesystem_location_info_t *parentloc, /* IN */ rtems_filesystem_location_info_t *loc /* IN */ ) { 10717c: 55 push %ebp 10717d: 89 e5 mov %esp,%ebp 10717f: 57 push %edi 107180: 56 push %esi 107181: 53 push %ebx 107182: 83 ec 3c sub $0x3c,%esp 107185: 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; 107188: 8b 13 mov (%ebx),%edx /* * If this is the last last pointer to the node * free the node. */ if ( node->type == IMFS_HARD_LINK ) { 10718a: 83 7a 4c 03 cmpl $0x3,0x4c(%edx) 10718e: 74 18 je 1071a8 /* * Now actually free the node we were asked to free. */ result = (*loc->handlers->rmnod_h)( parentloc, loc ); 107190: 83 ec 08 sub $0x8,%esp 107193: 8b 43 08 mov 0x8(%ebx),%eax 107196: 53 push %ebx 107197: ff 75 08 pushl 0x8(%ebp) 10719a: ff 50 34 call *0x34(%eax) return result; 10719d: 83 c4 10 add $0x10,%esp } 1071a0: 8d 65 f4 lea -0xc(%ebp),%esp 1071a3: 5b pop %ebx 1071a4: 5e pop %esi 1071a5: 5f pop %edi 1071a6: c9 leave 1071a7: c3 ret * free the node. */ if ( node->type == IMFS_HARD_LINK ) { if ( !node->info.hard_link.link_node ) 1071a8: 8b 42 50 mov 0x50(%edx),%eax 1071ab: 85 c0 test %eax,%eax 1071ad: 74 79 je 107228 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); the_link = *loc; 1071af: 8d 7d cc lea -0x34(%ebp),%edi 1071b2: b9 05 00 00 00 mov $0x5,%ecx 1071b7: 89 de mov %ebx,%esi 1071b9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_link.node_access = node->info.hard_link.link_node; 1071bb: 89 45 cc mov %eax,-0x34(%ebp) IMFS_Set_handlers( &the_link ); 1071be: 83 ec 0c sub $0xc,%esp 1071c1: 8d 75 cc lea -0x34(%ebp),%esi 1071c4: 56 push %esi 1071c5: 89 55 c4 mov %edx,-0x3c(%ebp) 1071c8: e8 83 73 00 00 call 10e550 /* * 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) 1071cd: 8b 55 c4 mov -0x3c(%ebp),%edx 1071d0: 8b 42 50 mov 0x50(%edx),%eax 1071d3: 8b 48 34 mov 0x34(%eax),%ecx 1071d6: 83 c4 10 add $0x10,%esp 1071d9: 66 83 f9 01 cmp $0x1,%cx 1071dd: 74 27 je 107206 if ( result != 0 ) return -1; } else { node->info.hard_link.link_node->st_nlink --; 1071df: 49 dec %ecx 1071e0: 66 89 48 34 mov %cx,0x34(%eax) IMFS_update_ctime( node->info.hard_link.link_node ); 1071e4: 83 ec 08 sub $0x8,%esp 1071e7: 6a 00 push $0x0 1071e9: 8d 45 e0 lea -0x20(%ebp),%eax 1071ec: 50 push %eax 1071ed: 89 55 c4 mov %edx,-0x3c(%ebp) 1071f0: e8 bb 04 00 00 call 1076b0 1071f5: 8b 55 c4 mov -0x3c(%ebp),%edx 1071f8: 8b 42 50 mov 0x50(%edx),%eax 1071fb: 8b 55 e0 mov -0x20(%ebp),%edx 1071fe: 89 50 48 mov %edx,0x48(%eax) 107201: 83 c4 10 add $0x10,%esp 107204: eb 8a jmp 107190 * 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 ); 107206: 83 ec 08 sub $0x8,%esp 107209: 56 push %esi 10720a: ff 75 08 pushl 0x8(%ebp) 10720d: 8b 45 d4 mov -0x2c(%ebp),%eax 107210: ff 50 34 call *0x34(%eax) if ( result != 0 ) 107213: 83 c4 10 add $0x10,%esp 107216: 85 c0 test %eax,%eax 107218: 0f 84 72 ff ff ff je 107190 return -1; 10721e: b8 ff ff ff ff mov $0xffffffff,%eax 107223: e9 78 ff ff ff jmp 1071a0 */ if ( node->type == IMFS_HARD_LINK ) { if ( !node->info.hard_link.link_node ) rtems_set_errno_and_return_minus_one( EINVAL ); 107228: e8 af ab 00 00 call 111ddc <__errno> <== NOT EXECUTED 10722d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 107233: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 107238: e9 63 ff ff ff jmp 1071a0 <== NOT EXECUTED =============================================================================== 00107240 : #include int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 107240: 55 push %ebp 107241: 89 e5 mov %esp,%ebp 107243: 83 ec 08 sub $0x8,%esp IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 107246: 8b 45 08 mov 0x8(%ebp),%eax 107249: 8b 40 08 mov 0x8(%eax),%eax /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 10724c: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 107250: 75 12 jne 107264 <== NEVER TAKEN /* * Did the node indicate that there was a directory mounted here? */ if ( node->info.directory.mt_fs == NULL ) 107252: 8b 50 5c mov 0x5c(%eax),%edx 107255: 85 d2 test %edx,%edx 107257: 74 1d je 107276 <== 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; 107259: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) return 0; 107260: 31 c0 xor %eax,%eax } 107262: c9 leave 107263: 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 ); 107264: e8 73 ab 00 00 call 111ddc <__errno> <== NOT EXECUTED 107269: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 10726f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED */ node->info.directory.mt_fs = NULL; return 0; } 107274: c9 leave <== NOT EXECUTED 107275: 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 */ 107276: e8 61 ab 00 00 call 111ddc <__errno> <== NOT EXECUTED 10727b: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 107281: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED */ node->info.directory.mt_fs = NULL; return 0; } 107286: c9 leave <== NOT EXECUTED 107287: c3 ret <== NOT EXECUTED =============================================================================== 0010785c : void RTEMS_Malloc_Initialize( void *heap_begin, uintptr_t heap_size, size_t sbrk_amount ) { 10785c: 55 push %ebp 10785d: 89 e5 mov %esp,%ebp 10785f: 57 push %edi 107860: 56 push %esi 107861: 53 push %ebx 107862: 83 ec 0c sub $0xc,%esp 107865: 8b 5d 08 mov 0x8(%ebp),%ebx 107868: 8b 75 0c mov 0xc(%ebp),%esi 10786b: 8b 7d 10 mov 0x10(%ebp),%edi /* * If configured, initialize the statistics support */ if ( rtems_malloc_statistics_helpers != NULL ) { 10786e: a1 a8 47 12 00 mov 0x1247a8,%eax 107873: 85 c0 test %eax,%eax 107875: 74 02 je 107879 (*rtems_malloc_statistics_helpers->initialize)(); 107877: ff 10 call *(%eax) } /* * Initialize the garbage collection list to start with nothing on it. */ malloc_deferred_frees_initialize(); 107879: e8 76 ff ff ff call 1077f4 /* * Initialize the optional sbrk support for extending the heap */ if ( rtems_malloc_sbrk_helpers != NULL ) { 10787e: a1 ac 47 12 00 mov 0x1247ac,%eax 107883: 85 c0 test %eax,%eax 107885: 74 0e je 107895 heap_begin = (*rtems_malloc_sbrk_helpers->initialize)( 107887: 83 ec 08 sub $0x8,%esp 10788a: 57 push %edi 10788b: 53 push %ebx 10788c: ff 10 call *(%eax) 10788e: 89 c3 mov %eax,%ebx 107890: 83 c4 10 add $0x10,%esp heap_begin, sbrk_amount ); heap_size = (uintptr_t) sbrk_amount; 107893: 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 ( 107895: 80 3d a4 47 12 00 00 cmpb $0x0,0x1247a4 10789c: 75 1f jne 1078bd !rtems_unified_work_area && rtems_configuration_get_do_zero_of_workspace() 10789e: 80 3d 28 23 12 00 00 cmpb $0x0,0x122328 1078a5: 75 41 jne 1078e8 void *area_begin, uintptr_t area_size, uintptr_t page_size ) { return _Heap_Initialize( heap, area_begin, area_size, page_size ); 1078a7: 6a 04 push $0x4 1078a9: 56 push %esi 1078aa: 53 push %ebx 1078ab: ff 35 30 22 12 00 pushl 0x122230 1078b1: e8 aa 41 00 00 call 10ba60 <_Heap_Initialize> RTEMS_Malloc_Heap, heap_begin, heap_size, CPU_HEAP_ALIGNMENT ); if ( status == 0 ) { 1078b6: 83 c4 10 add $0x10,%esp 1078b9: 85 c0 test %eax,%eax 1078bb: 74 3e je 1078fb rtems_fatal_error_occurred( RTEMS_NO_MEMORY ); } } MSBUMP( space_available, _Protected_heap_Get_size(RTEMS_Malloc_Heap) ); 1078bd: 8b 1d a0 63 12 00 mov 0x1263a0,%ebx 1078c3: 83 ec 0c sub $0xc,%esp 1078c6: ff 35 30 22 12 00 pushl 0x122230 1078cc: e8 d3 4b 00 00 call 10c4a4 <_Protected_heap_Get_size> 1078d1: 8d 1c 18 lea (%eax,%ebx,1),%ebx 1078d4: 89 1d a0 63 12 00 mov %ebx,0x1263a0 1078da: 83 c4 10 add $0x10,%esp } 1078dd: 8d 65 f4 lea -0xc(%ebp),%esp 1078e0: 5b pop %ebx 1078e1: 5e pop %esi 1078e2: 5f pop %edi 1078e3: c9 leave 1078e4: c3 ret 1078e5: 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 ); 1078e8: 31 c0 xor %eax,%eax 1078ea: 89 df mov %ebx,%edi 1078ec: 89 f1 mov %esi,%ecx 1078ee: 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 ) { 1078f0: 80 3d a4 47 12 00 00 cmpb $0x0,0x1247a4 1078f7: 74 ae je 1078a7 <== ALWAYS TAKEN 1078f9: eb c2 jmp 1078bd <== NOT EXECUTED heap_begin, heap_size, CPU_HEAP_ALIGNMENT ); if ( status == 0 ) { rtems_fatal_error_occurred( RTEMS_NO_MEMORY ); 1078fb: 83 ec 0c sub $0xc,%esp 1078fe: 6a 1a push $0x1a 107900: e8 e3 38 00 00 call 10b1e8 =============================================================================== 00106d90 : static rtems_printk_plugin_t print_handler; void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) { 106d90: 55 push %ebp <== NOT EXECUTED 106d91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106d93: 57 push %edi <== NOT EXECUTED 106d94: 56 push %esi <== NOT EXECUTED 106d95: 53 push %ebx <== NOT EXECUTED 106d96: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 106d99: 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) { 106d9c: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED 106d9f: 0f 84 37 01 00 00 je 106edc <== NOT EXECUTED the_thread = 0; current = 0; } else #endif { stack = &the_thread->Start.Initial_stack; 106da5: 8d b3 b4 00 00 00 lea 0xb4(%ebx),%esi <== NOT EXECUTED current = (void *)_CPU_Context_Get_SP( &the_thread->Registers ); 106dab: 8b 83 c8 00 00 00 mov 0xc8(%ebx),%eax <== NOT EXECUTED 106db1: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 106db4: 8b 8b b8 00 00 00 mov 0xb8(%ebx),%ecx <== NOT EXECUTED } low = Stack_check_usable_stack_start(stack); 106dba: 8d 51 10 lea 0x10(%ecx),%edx <== NOT EXECUTED 106dbd: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED size = Stack_check_usable_stack_size(stack); 106dc0: 8b 3e mov (%esi),%edi <== NOT EXECUTED 106dc2: 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; 106dc5: 8d 41 20 lea 0x20(%ecx),%eax <== NOT EXECUTED for (ebase = base + length; base < ebase; base++) 106dc8: 89 fa mov %edi,%edx <== NOT EXECUTED 106dca: 83 e2 fc and $0xfffffffc,%edx <== NOT EXECUTED 106dcd: 8d 14 10 lea (%eax,%edx,1),%edx <== NOT EXECUTED 106dd0: 39 d0 cmp %edx,%eax <== NOT EXECUTED 106dd2: 73 23 jae 106df7 <== NOT EXECUTED if (*base != U32_PATTERN) 106dd4: 81 79 20 a5 a5 a5 a5 cmpl $0xa5a5a5a5,0x20(%ecx) <== NOT EXECUTED 106ddb: 74 13 je 106df0 <== NOT EXECUTED 106ddd: e9 a2 00 00 00 jmp 106e84 <== NOT EXECUTED 106de2: 66 90 xchg %ax,%ax <== NOT EXECUTED 106de4: 81 38 a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%eax) <== NOT EXECUTED 106dea: 0f 85 94 00 00 00 jne 106e84 <== 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++) 106df0: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 106df3: 39 c2 cmp %eax,%edx <== NOT EXECUTED 106df5: 77 ed ja 106de4 <== 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; 106df7: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if ( the_thread ) 106dfe: 85 db test %ebx,%ebx <== NOT EXECUTED 106e00: 0f 84 98 00 00 00 je 106e9e <== NOT EXECUTED #endif { (*print_handler)( 106e06: a1 cc 65 12 00 mov 0x1265cc,%eax <== NOT EXECUTED 106e0b: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED 106e0e: 50 push %eax <== NOT EXECUTED 106e0f: 8d 45 e3 lea -0x1d(%ebp),%eax <== NOT EXECUTED 106e12: 50 push %eax <== NOT EXECUTED 106e13: 6a 05 push $0x5 <== NOT EXECUTED 106e15: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 106e18: e8 47 3f 00 00 call 10ad64 <== NOT EXECUTED 106e1d: 50 push %eax <== NOT EXECUTED 106e1e: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 106e21: 68 d7 00 12 00 push $0x1200d7 <== NOT EXECUTED 106e26: ff 35 c8 65 12 00 pushl 0x1265c8 <== NOT EXECUTED 106e2c: ff 55 cc call *-0x34(%ebp) <== NOT EXECUTED 106e2f: 83 c4 20 add $0x20,%esp <== NOT EXECUTED (*print_handler)( print_context, " %010p - %010p %010p %8" PRId32 " ", stack->area, stack->area + stack->size - 1, 106e32: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); } #endif (*print_handler)( 106e35: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 106e38: 57 push %edi <== NOT EXECUTED 106e39: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED print_context, " %010p - %010p %010p %8" PRId32 " ", stack->area, stack->area + stack->size - 1, 106e3c: 8b 16 mov (%esi),%edx <== NOT EXECUTED else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); } #endif (*print_handler)( 106e3e: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED 106e42: 52 push %edx <== NOT EXECUTED 106e43: 50 push %eax <== NOT EXECUTED 106e44: 68 f2 00 12 00 push $0x1200f2 <== NOT EXECUTED 106e49: ff 35 c8 65 12 00 pushl 0x1265c8 <== NOT EXECUTED 106e4f: ff 15 cc 65 12 00 call *0x1265cc <== NOT EXECUTED stack->area + stack->size - 1, current, size ); if (Stack_check_Initialized == 0) { 106e55: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 106e58: 8b 15 d0 65 12 00 mov 0x1265d0,%edx <== NOT EXECUTED 106e5e: 85 d2 test %edx,%edx <== NOT EXECUTED 106e60: 74 5a je 106ebc <== NOT EXECUTED (*print_handler)( print_context, "Unavailable\n" ); } else { (*print_handler)( print_context, "%8" PRId32 "\n", used ); 106e62: 50 push %eax <== NOT EXECUTED 106e63: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 106e66: 68 1d 01 12 00 push $0x12011d <== NOT EXECUTED 106e6b: ff 35 c8 65 12 00 pushl 0x1265c8 <== NOT EXECUTED 106e71: ff 15 cc 65 12 00 call *0x1265cc <== NOT EXECUTED 106e77: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 106e7a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106e7d: 5b pop %ebx <== NOT EXECUTED 106e7e: 5e pop %esi <== NOT EXECUTED 106e7f: 5f pop %edi <== NOT EXECUTED 106e80: c9 leave <== NOT EXECUTED 106e81: c3 ret <== NOT EXECUTED 106e82: 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 ) 106e84: 85 c0 test %eax,%eax <== NOT EXECUTED 106e86: 0f 84 6b ff ff ff je 106df7 <== NOT EXECUTED used = Stack_check_Calculate_used( low, size, high_water_mark ); 106e8c: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 106e8f: 01 fa add %edi,%edx <== NOT EXECUTED 106e91: 29 c2 sub %eax,%edx <== NOT EXECUTED 106e93: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED else used = 0; #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if ( the_thread ) 106e96: 85 db test %ebx,%ebx <== NOT EXECUTED 106e98: 0f 85 68 ff ff ff jne 106e06 <== 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 ); 106e9e: 51 push %ecx <== NOT EXECUTED 106e9f: 6a ff push $0xffffffff <== NOT EXECUTED 106ea1: 68 e4 00 12 00 push $0x1200e4 <== NOT EXECUTED 106ea6: ff 35 c8 65 12 00 pushl 0x1265c8 <== NOT EXECUTED 106eac: ff 15 cc 65 12 00 call *0x1265cc <== NOT EXECUTED 106eb2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106eb5: e9 78 ff ff ff jmp 106e32 <== NOT EXECUTED 106eba: 66 90 xchg %ax,%ax <== NOT EXECUTED current, size ); if (Stack_check_Initialized == 0) { (*print_handler)( print_context, "Unavailable\n" ); 106ebc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 106ebf: 68 10 01 12 00 push $0x120110 <== NOT EXECUTED 106ec4: ff 35 c8 65 12 00 pushl 0x1265c8 <== NOT EXECUTED 106eca: ff 15 cc 65 12 00 call *0x1265cc <== NOT EXECUTED 106ed0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { (*print_handler)( print_context, "%8" PRId32 "\n", used ); } } 106ed3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106ed6: 5b pop %ebx <== NOT EXECUTED 106ed7: 5e pop %esi <== NOT EXECUTED 106ed8: 5f pop %edi <== NOT EXECUTED 106ed9: c9 leave <== NOT EXECUTED 106eda: c3 ret <== NOT EXECUTED 106edb: 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) 106edc: 8b 0d 34 69 12 00 mov 0x126934,%ecx <== NOT EXECUTED 106ee2: 85 c9 test %ecx,%ecx <== NOT EXECUTED 106ee4: 74 94 je 106e7a <== NOT EXECUTED return; stack = &Stack_check_Interrupt_stack; 106ee6: be 30 69 12 00 mov $0x126930,%esi <== NOT EXECUTED the_thread = 0; current = 0; 106eeb: 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; 106ef2: 31 db xor %ebx,%ebx <== NOT EXECUTED 106ef4: e9 c1 fe ff ff jmp 106dba <== NOT EXECUTED =============================================================================== 00106efc : /* * Stack_check_Initialize */ void Stack_check_Initialize( void ) { 106efc: 55 push %ebp 106efd: 89 e5 mov %esp,%ebp 106eff: 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 ) 106f00: 8b 15 d0 65 12 00 mov 0x1265d0,%edx 106f06: 85 d2 test %edx,%edx 106f08: 75 5a jne 106f64 /* * Dope the pattern and fill areas */ p = Stack_check_Pattern.pattern; for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) { p[i] = pattern[ i%4 ]; 106f0a: c7 05 20 69 12 00 0d movl $0xfeedf00d,0x126920 106f11: f0 ed fe 106f14: c7 05 24 69 12 00 06 movl $0xbad0d06,0x126924 106f1b: 0d ad 0b 106f1e: c7 05 28 69 12 00 0d movl $0xdeadf00d,0x126928 106f25: f0 ad de 106f28: c7 05 2c 69 12 00 06 movl $0x600d0d06,0x12692c 106f2f: 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) { 106f32: 8b 15 2c 6d 12 00 mov 0x126d2c,%edx 106f38: 85 d2 test %edx,%edx 106f3a: 74 1e je 106f5a <== NEVER TAKEN 106f3c: 8b 0d 30 6d 12 00 mov 0x126d30,%ecx 106f42: 85 c9 test %ecx,%ecx 106f44: 74 14 je 106f5a <== NEVER TAKEN Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low; 106f46: 89 15 34 69 12 00 mov %edx,0x126934 Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high - 106f4c: 29 d1 sub %edx,%ecx 106f4e: 89 0d 30 69 12 00 mov %ecx,0x126930 (char *) _CPU_Interrupt_stack_low; Stack_check_Dope_stack(&Stack_check_Interrupt_stack); 106f54: b0 a5 mov $0xa5,%al 106f56: 89 d7 mov %edx,%edi 106f58: f3 aa rep stos %al,%es:(%edi) } #endif Stack_check_Initialized = 1; 106f5a: c7 05 d0 65 12 00 01 movl $0x1,0x1265d0 106f61: 00 00 00 } 106f64: 5f pop %edi 106f65: c9 leave 106f66: c3 ret =============================================================================== 00106fb8 : Thread_Control *running, bool pattern_ok ) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE; void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok) { 106fb8: 55 push %ebp <== NOT EXECUTED 106fb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106fbb: 56 push %esi <== NOT EXECUTED 106fbc: 53 push %ebx <== NOT EXECUTED 106fbd: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 106fc0: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 106fc3: 8a 55 0c mov 0xc(%ebp),%dl <== NOT EXECUTED Stack_Control *stack = &running->Start.Initial_stack; void *pattern_area = Stack_check_Get_pattern(stack); 106fc6: 8b b3 b8 00 00 00 mov 0xb8(%ebx),%esi <== NOT EXECUTED char name[32]; printk("BLOWN STACK!!!\n"); 106fcc: 68 23 01 12 00 push $0x120123 <== NOT EXECUTED 106fd1: 88 55 d4 mov %dl,-0x2c(%ebp) <== NOT EXECUTED 106fd4: e8 8b 18 00 00 call 108864 <== NOT EXECUTED printk("task control block: 0x%08" PRIxPTR "\n", running); 106fd9: 5a pop %edx <== NOT EXECUTED 106fda: 59 pop %ecx <== NOT EXECUTED 106fdb: 53 push %ebx <== NOT EXECUTED 106fdc: 68 33 01 12 00 push $0x120133 <== NOT EXECUTED 106fe1: e8 7e 18 00 00 call 108864 <== NOT EXECUTED printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id); 106fe6: 59 pop %ecx <== NOT EXECUTED 106fe7: 58 pop %eax <== NOT EXECUTED 106fe8: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 106feb: 68 50 01 12 00 push $0x120150 <== NOT EXECUTED 106ff0: e8 6f 18 00 00 call 108864 <== NOT EXECUTED printk( 106ff5: 58 pop %eax <== NOT EXECUTED 106ff6: 5a pop %edx <== NOT EXECUTED 106ff7: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 106ffa: 68 62 01 12 00 push $0x120162 <== NOT EXECUTED 106fff: e8 60 18 00 00 call 108864 <== NOT EXECUTED "task name: 0x%08" PRIx32 "\n", running->Object.name.name_u32 ); printk( 107004: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 107007: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED 10700a: 50 push %eax <== NOT EXECUTED 10700b: 6a 20 push $0x20 <== NOT EXECUTED 10700d: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 107010: e8 4f 3d 00 00 call 10ad64 <== NOT EXECUTED 107015: 5a pop %edx <== NOT EXECUTED 107016: 59 pop %ecx <== NOT EXECUTED 107017: 50 push %eax <== NOT EXECUTED 107018: 68 76 01 12 00 push $0x120176 <== NOT EXECUTED 10701d: e8 42 18 00 00 call 108864 <== 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) 107022: 8b 8b b8 00 00 00 mov 0xb8(%ebx),%ecx <== NOT EXECUTED 107028: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax <== NOT EXECUTED ); printk( "task name string: %s\n", rtems_object_get_name(running->Object.id, sizeof(name), name) ); printk( 10702e: 8d 1c 01 lea (%ecx,%eax,1),%ebx <== NOT EXECUTED 107031: 53 push %ebx <== NOT EXECUTED 107032: 51 push %ecx <== NOT EXECUTED 107033: 50 push %eax <== NOT EXECUTED 107034: 68 a4 01 12 00 push $0x1201a4 <== NOT EXECUTED 107039: e8 26 18 00 00 call 108864 <== 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) { 10703e: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 107041: 8a 55 d4 mov -0x2c(%ebp),%dl <== NOT EXECUTED 107044: 84 d2 test %dl,%dl <== NOT EXECUTED 107046: 74 10 je 107058 <== NOT EXECUTED rtems_configuration_get_user_multiprocessing_table()->node ); } #endif rtems_fatal_error_occurred(0x81); 107048: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10704b: 68 81 00 00 00 push $0x81 <== NOT EXECUTED 107050: e8 8f 45 00 00 call 10b5e4 <== NOT EXECUTED 107055: 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); 107058: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED (unsigned long) stack->size, stack->area, ((char *) stack->area + stack->size) ); if (!pattern_ok) { printk( 10705b: 83 c6 18 add $0x18,%esi <== NOT EXECUTED 10705e: 56 push %esi <== NOT EXECUTED 10705f: 50 push %eax <== NOT EXECUTED 107060: 6a 10 push $0x10 <== NOT EXECUTED 107062: 68 d8 01 12 00 push $0x1201d8 <== NOT EXECUTED 107067: e8 f8 17 00 00 call 108864 <== NOT EXECUTED 10706c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10706f: eb d7 jmp 107048 <== NOT EXECUTED =============================================================================== 0010b348 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 10b348: 55 push %ebp 10b349: 89 e5 mov %esp,%ebp 10b34b: 53 push %ebx 10b34c: 83 ec 04 sub $0x4,%esp the_extension = (API_extensions_Control *) the_node; (*the_extension->postswitch_hook)( _Thread_Executing ); } } 10b34f: 8b 1d 18 67 12 00 mov 0x126718,%ebx void _API_extensions_Run_postdriver( void ) { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 10b355: 81 fb 1c 67 12 00 cmp $0x12671c,%ebx 10b35b: 74 10 je 10b36d <_API_extensions_Run_postdriver+0x25><== NEVER TAKEN 10b35d: 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)(); 10b360: 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 ) { 10b363: 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 ); 10b365: 81 fb 1c 67 12 00 cmp $0x12671c,%ebx 10b36b: 75 f3 jne 10b360 <_API_extensions_Run_postdriver+0x18><== NEVER TAKEN #if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API) if ( the_extension->postdriver_hook ) #endif (*the_extension->postdriver_hook)(); } } 10b36d: 58 pop %eax 10b36e: 5b pop %ebx 10b36f: c9 leave 10b370: c3 ret =============================================================================== 0010b374 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 10b374: 55 push %ebp 10b375: 89 e5 mov %esp,%ebp 10b377: 53 push %ebx 10b378: 83 ec 04 sub $0x4,%esp the_extension = (API_extensions_Control *) the_node; (*the_extension->postswitch_hook)( _Thread_Executing ); } } 10b37b: 8b 1d 18 67 12 00 mov 0x126718,%ebx void _API_extensions_Run_postswitch( void ) { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _Chain_First( &_API_extensions_List ); 10b381: 81 fb 1c 67 12 00 cmp $0x12671c,%ebx 10b387: 74 1c je 10b3a5 <_API_extensions_Run_postswitch+0x31><== NEVER TAKEN 10b389: 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 ); 10b38c: 83 ec 0c sub $0xc,%esp 10b38f: ff 35 78 67 12 00 pushl 0x126778 10b395: 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 ) { 10b398: 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 ); 10b39a: 83 c4 10 add $0x10,%esp 10b39d: 81 fb 1c 67 12 00 cmp $0x12671c,%ebx 10b3a3: 75 e7 jne 10b38c <_API_extensions_Run_postswitch+0x18><== NEVER TAKEN the_extension = (API_extensions_Control *) the_node; (*the_extension->postswitch_hook)( _Thread_Executing ); } } 10b3a5: 8b 5d fc mov -0x4(%ebp),%ebx 10b3a8: c9 leave 10b3a9: c3 ret =============================================================================== 0010ff0c <_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 ) { 10ff0c: 55 push %ebp 10ff0d: 89 e5 mov %esp,%ebp 10ff0f: 57 push %edi 10ff10: 56 push %esi 10ff11: 53 push %ebx 10ff12: 83 ec 0c sub $0xc,%esp 10ff15: 8b 5d 08 mov 0x8(%ebp),%ebx 10ff18: 8b 75 10 mov 0x10(%ebp),%esi 10ff1b: 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; 10ff1e: 89 73 44 mov %esi,0x44(%ebx) the_message_queue->number_of_pending_messages = 0; 10ff21: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) the_message_queue->maximum_message_size = maximum_message_size; 10ff28: 89 43 4c mov %eax,0x4c(%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)) { 10ff2b: a8 03 test $0x3,%al 10ff2d: 74 15 je 10ff44 <_CORE_message_queue_Initialize+0x38> allocated_message_size += sizeof(uint32_t); 10ff2f: 8d 50 04 lea 0x4(%eax),%edx allocated_message_size &= ~(sizeof(uint32_t) - 1); 10ff32: 83 e2 fc and $0xfffffffc,%edx } if (allocated_message_size < maximum_message_size) 10ff35: 39 d0 cmp %edx,%eax 10ff37: 76 0d jbe 10ff46 <_CORE_message_queue_Initialize+0x3a><== 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; 10ff39: 31 c0 xor %eax,%eax STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; } 10ff3b: 8d 65 f4 lea -0xc(%ebp),%esp 10ff3e: 5b pop %ebx 10ff3f: 5e pop %esi 10ff40: 5f pop %edi 10ff41: c9 leave 10ff42: c3 ret 10ff43: 90 nop /* * 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)) { 10ff44: 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)); 10ff46: 8d 7a 10 lea 0x10(%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 * 10ff49: 89 f8 mov %edi,%eax 10ff4b: 0f af c6 imul %esi,%eax (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 10ff4e: 39 d0 cmp %edx,%eax 10ff50: 72 e7 jb 10ff39 <_CORE_message_queue_Initialize+0x2d><== NEVER TAKEN /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) _Workspace_Allocate( message_buffering_required ); 10ff52: 83 ec 0c sub $0xc,%esp 10ff55: 50 push %eax 10ff56: e8 15 dd ff ff call 10dc70 <_Workspace_Allocate> return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 10ff5b: 89 43 5c mov %eax,0x5c(%ebx) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 10ff5e: 83 c4 10 add $0x10,%esp 10ff61: 85 c0 test %eax,%eax 10ff63: 74 d4 je 10ff39 <_CORE_message_queue_Initialize+0x2d> /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 10ff65: 57 push %edi 10ff66: 56 push %esi 10ff67: 50 push %eax 10ff68: 8d 43 60 lea 0x60(%ebx),%eax 10ff6b: 50 push %eax 10ff6c: e8 bb fe ff ff call 10fe2c <_Chain_Initialize> Chain_Node *tail = _Chain_Tail( the_chain ); 10ff71: 8d 43 54 lea 0x54(%ebx),%eax 10ff74: 89 43 50 mov %eax,0x50(%ebx) head->next = tail; head->previous = NULL; 10ff77: 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 ); 10ff7e: 8d 43 50 lea 0x50(%ebx),%eax 10ff81: 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( 10ff84: 6a 06 push $0x6 10ff86: 68 80 00 00 00 push $0x80 10ff8b: 8b 45 0c mov 0xc(%ebp),%eax 10ff8e: 83 38 01 cmpl $0x1,(%eax) 10ff91: 0f 94 c0 sete %al 10ff94: 0f b6 c0 movzbl %al,%eax 10ff97: 50 push %eax 10ff98: 53 push %ebx 10ff99: e8 3e d4 ff ff call 10d3dc <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 10ff9e: 83 c4 20 add $0x20,%esp 10ffa1: b0 01 mov $0x1,%al } 10ffa3: 8d 65 f4 lea -0xc(%ebp),%esp 10ffa6: 5b pop %ebx 10ffa7: 5e pop %esi 10ffa8: 5f pop %edi 10ffa9: c9 leave 10ffaa: c3 ret =============================================================================== 00111c20 <_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 ) { 111c20: 55 push %ebp 111c21: 89 e5 mov %esp,%ebp 111c23: 56 push %esi 111c24: 53 push %ebx 111c25: 8b 45 08 mov 0x8(%ebp),%eax 111c28: 8b 55 0c mov 0xc(%ebp),%edx #endif _CORE_message_queue_Set_message_priority( the_message, submit_type ); #if !defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY) _ISR_Disable( level ); 111c2b: 9c pushf 111c2c: fa cli 111c2d: 5b pop %ebx SET_NOTIFY(); the_message_queue->number_of_pending_messages++; 111c2e: ff 40 48 incl 0x48(%eax) if ( submit_type == CORE_MESSAGE_QUEUE_SEND_REQUEST ) 111c31: 81 7d 10 ff ff ff 7f cmpl $0x7fffffff,0x10(%ebp) 111c38: 74 1a je 111c54 <_CORE_message_queue_Insert_message+0x34> RTEMS_INLINE_ROUTINE void _Chain_Prepend_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert_unprotected(_Chain_Head(the_chain), the_node); 111c3a: 8d 48 50 lea 0x50(%eax),%ecx 111c3d: 89 4a 04 mov %ecx,0x4(%edx) ) { Chain_Node *before_node; the_node->previous = after_node; before_node = after_node->next; 111c40: 8b 48 50 mov 0x50(%eax),%ecx after_node->next = the_node; 111c43: 89 50 50 mov %edx,0x50(%eax) the_node->next = before_node; 111c46: 89 0a mov %ecx,(%edx) before_node->previous = the_node; 111c48: 89 51 04 mov %edx,0x4(%ecx) _CORE_message_queue_Append_unprotected(the_message_queue, the_message); else _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 111c4b: 53 push %ebx 111c4c: 9d popf * 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 } 111c4d: 5b pop %ebx 111c4e: 5e pop %esi 111c4f: c9 leave 111c50: c3 ret 111c51: 8d 76 00 lea 0x0(%esi),%esi Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 111c54: 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 ); 111c57: 8d 70 54 lea 0x54(%eax),%esi 111c5a: 89 32 mov %esi,(%edx) Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 111c5c: 89 50 58 mov %edx,0x58(%eax) old_last->next = the_node; 111c5f: 89 11 mov %edx,(%ecx) the_node->previous = old_last; 111c61: 89 4a 04 mov %ecx,0x4(%edx) 111c64: eb e5 jmp 111c4b <_CORE_message_queue_Insert_message+0x2b> =============================================================================== 00110084 <_CORE_message_queue_Submit>: #endif CORE_message_queue_Submit_types submit_type, bool wait, Watchdog_Interval timeout ) { 110084: 55 push %ebp 110085: 89 e5 mov %esp,%ebp 110087: 57 push %edi 110088: 56 push %esi 110089: 53 push %ebx 11008a: 83 ec 0c sub $0xc,%esp 11008d: 8b 5d 08 mov 0x8(%ebp),%ebx 110090: 8b 75 0c mov 0xc(%ebp),%esi CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 110093: 8b 45 10 mov 0x10(%ebp),%eax 110096: 39 43 4c cmp %eax,0x4c(%ebx) 110099: 72 51 jb 1100ec <_CORE_message_queue_Submit+0x68> } /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { 11009b: 8b 43 48 mov 0x48(%ebx),%eax 11009e: 85 c0 test %eax,%eax 1100a0: 74 5a je 1100fc <_CORE_message_queue_Submit+0x78> /* * 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 < 1100a2: 39 43 44 cmp %eax,0x44(%ebx) 1100a5: 77 0d ja 1100b4 <_CORE_message_queue_Submit+0x30> ); return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } #if !defined(RTEMS_SCORE_COREMSG_ENABLE_BLOCKING_SEND) return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY; 1100a7: 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 } 1100ac: 8d 65 f4 lea -0xc(%ebp),%esp 1100af: 5b pop %ebx 1100b0: 5e pop %esi 1100b1: 5f pop %edi 1100b2: c9 leave 1100b3: 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 ); 1100b4: 83 ec 0c sub $0xc,%esp 1100b7: 8d 43 60 lea 0x60(%ebx),%eax 1100ba: 50 push %eax 1100bb: e8 00 b4 ff ff call 10b4c0 <_Chain_Get> 1100c0: 89 c2 mov %eax,%edx return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED; #endif _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, 1100c2: 8d 40 0c lea 0xc(%eax),%eax const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 1100c5: 89 c7 mov %eax,%edi 1100c7: 8b 4d 10 mov 0x10(%ebp),%ecx 1100ca: f3 a4 rep movsb %ds:(%esi),%es:(%edi) size ); the_message->Contents.size = size; 1100cc: 8b 4d 10 mov 0x10(%ebp),%ecx 1100cf: 89 4a 08 mov %ecx,0x8(%edx) _CORE_message_queue_Set_message_priority( the_message, submit_type ); _CORE_message_queue_Insert_message( 1100d2: 83 c4 0c add $0xc,%esp 1100d5: ff 75 1c pushl 0x1c(%ebp) 1100d8: 52 push %edx 1100d9: 53 push %ebx 1100da: e8 41 1b 00 00 call 111c20 <_CORE_message_queue_Insert_message> the_message_queue, the_message, submit_type ); return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 1100df: 83 c4 10 add $0x10,%esp 1100e2: 31 c0 xor %eax,%eax _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; #endif } 1100e4: 8d 65 f4 lea -0xc(%ebp),%esp 1100e7: 5b pop %ebx 1100e8: 5e pop %esi 1100e9: 5f pop %edi 1100ea: c9 leave 1100eb: c3 ret { 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; 1100ec: 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 } 1100f1: 8d 65 f4 lea -0xc(%ebp),%esp 1100f4: 5b pop %ebx 1100f5: 5e pop %esi 1100f6: 5f pop %edi 1100f7: c9 leave 1100f8: c3 ret 1100f9: 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 ); 1100fc: 83 ec 0c sub $0xc,%esp 1100ff: 53 push %ebx 110100: e8 47 cf ff ff call 10d04c <_Thread_queue_Dequeue> 110105: 89 c2 mov %eax,%edx if ( the_thread ) { 110107: 83 c4 10 add $0x10,%esp 11010a: 85 c0 test %eax,%eax 11010c: 74 1e je 11012c <_CORE_message_queue_Submit+0xa8> 11010e: 8b 40 2c mov 0x2c(%eax),%eax 110111: 89 c7 mov %eax,%edi 110113: 8b 4d 10 mov 0x10(%ebp),%ecx 110116: 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; 110118: 8b 42 28 mov 0x28(%edx),%eax 11011b: 8b 4d 10 mov 0x10(%ebp),%ecx 11011e: 89 08 mov %ecx,(%eax) the_thread->Wait.count = (uint32_t) submit_type; 110120: 8b 45 1c mov 0x1c(%ebp),%eax 110123: 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; 110126: 31 c0 xor %eax,%eax 110128: eb 82 jmp 1100ac <_CORE_message_queue_Submit+0x28> 11012a: 66 90 xchg %ax,%ax /* * 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 ) { 11012c: 8b 43 48 mov 0x48(%ebx),%eax 11012f: e9 6e ff ff ff jmp 1100a2 <_CORE_message_queue_Submit+0x1e> =============================================================================== 0010b4f0 <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 10b4f0: 55 push %ebp 10b4f1: 89 e5 mov %esp,%ebp 10b4f3: 57 push %edi 10b4f4: 56 push %esi 10b4f5: 53 push %ebx 10b4f6: 83 ec 0c sub $0xc,%esp 10b4f9: 8b 45 08 mov 0x8(%ebp),%eax 10b4fc: 8b 5d 0c mov 0xc(%ebp),%ebx 10b4ff: 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; 10b502: 8d 78 40 lea 0x40(%eax),%edi 10b505: b9 04 00 00 00 mov $0x4,%ecx 10b50a: 89 de mov %ebx,%esi 10b50c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_mutex->lock = initial_lock; 10b50e: 89 50 50 mov %edx,0x50(%eax) the_mutex->blocked_count = 0; 10b511: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) if ( initial_lock == CORE_MUTEX_LOCKED ) { 10b518: 85 d2 test %edx,%edx 10b51a: 75 30 jne 10b54c <_CORE_mutex_Initialize+0x5c> the_mutex->nest_count = 1; 10b51c: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax) the_mutex->holder = _Thread_Executing; 10b523: 8b 15 78 67 12 00 mov 0x126778,%edx 10b529: 89 50 5c mov %edx,0x5c(%eax) the_mutex->holder_id = _Thread_Executing->Object.id; 10b52c: 8b 4a 08 mov 0x8(%edx),%ecx 10b52f: 89 48 60 mov %ecx,0x60(%eax) STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10b532: 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 ) || 10b535: 83 f9 02 cmp $0x2,%ecx 10b538: 74 05 je 10b53f <_CORE_mutex_Initialize+0x4f> 10b53a: 83 f9 03 cmp $0x3,%ecx 10b53d: 75 22 jne 10b561 <_CORE_mutex_Initialize+0x71> _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 10b53f: 8b 48 4c mov 0x4c(%eax),%ecx 10b542: 39 4a 14 cmp %ecx,0x14(%edx) 10b545: 72 41 jb 10b588 <_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++; 10b547: ff 42 1c incl 0x1c(%edx) 10b54a: eb 15 jmp 10b561 <_CORE_mutex_Initialize+0x71> } } else { the_mutex->nest_count = 0; 10b54c: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) the_mutex->holder = NULL; 10b553: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) the_mutex->holder_id = 0; 10b55a: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) } _Thread_queue_Initialize( 10b561: 6a 04 push $0x4 10b563: 68 00 04 00 00 push $0x400 10b568: 31 d2 xor %edx,%edx 10b56a: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10b56e: 0f 95 c2 setne %dl 10b571: 52 push %edx 10b572: 50 push %eax 10b573: e8 64 1e 00 00 call 10d3dc <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY, STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; 10b578: 83 c4 10 add $0x10,%esp 10b57b: 31 c0 xor %eax,%eax } 10b57d: 8d 65 f4 lea -0xc(%ebp),%esp 10b580: 5b pop %ebx 10b581: 5e pop %esi 10b582: 5f pop %edi 10b583: c9 leave 10b584: c3 ret 10b585: 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; 10b588: b8 05 00 00 00 mov $0x5,%eax STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10b58d: 8d 65 f4 lea -0xc(%ebp),%esp 10b590: 5b pop %ebx 10b591: 5e pop %esi 10b592: 5f pop %edi 10b593: c9 leave 10b594: c3 ret =============================================================================== 0010b5e8 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 10b5e8: 55 push %ebp 10b5e9: 89 e5 mov %esp,%ebp 10b5eb: 53 push %ebx 10b5ec: 83 ec 14 sub $0x14,%esp 10b5ef: 8b 5d 08 mov 0x8(%ebp),%ebx 10b5f2: 8a 55 10 mov 0x10(%ebp),%dl _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10b5f5: a1 ec 64 12 00 mov 0x1264ec,%eax 10b5fa: 85 c0 test %eax,%eax 10b5fc: 74 04 je 10b602 <_CORE_mutex_Seize+0x1a> 10b5fe: 84 d2 test %dl,%dl 10b600: 75 36 jne 10b638 <_CORE_mutex_Seize+0x50><== ALWAYS TAKEN 10b602: 83 ec 08 sub $0x8,%esp 10b605: 8d 45 18 lea 0x18(%ebp),%eax 10b608: 50 push %eax 10b609: 53 push %ebx 10b60a: 88 55 f4 mov %dl,-0xc(%ebp) 10b60d: e8 22 4b 00 00 call 110134 <_CORE_mutex_Seize_interrupt_trylock> 10b612: 83 c4 10 add $0x10,%esp 10b615: 85 c0 test %eax,%eax 10b617: 8a 55 f4 mov -0xc(%ebp),%dl 10b61a: 74 14 je 10b630 <_CORE_mutex_Seize+0x48> 10b61c: 84 d2 test %dl,%dl 10b61e: 75 30 jne 10b650 <_CORE_mutex_Seize+0x68> 10b620: ff 75 18 pushl 0x18(%ebp) 10b623: 9d popf 10b624: a1 78 67 12 00 mov 0x126778,%eax 10b629: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) } 10b630: 8b 5d fc mov -0x4(%ebp),%ebx 10b633: c9 leave 10b634: c3 ret 10b635: 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 ); 10b638: 83 3d 80 66 12 00 01 cmpl $0x1,0x126680 10b63f: 76 c1 jbe 10b602 <_CORE_mutex_Seize+0x1a> 10b641: 53 push %ebx 10b642: 6a 12 push $0x12 10b644: 6a 00 push $0x0 10b646: 6a 00 push $0x0 10b648: e8 1b 06 00 00 call 10bc68 <_Internal_error_Occurred> 10b64d: 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; 10b650: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) 10b657: a1 78 67 12 00 mov 0x126778,%eax 10b65c: 89 58 44 mov %ebx,0x44(%eax) 10b65f: 8b 55 0c mov 0xc(%ebp),%edx 10b662: 89 50 20 mov %edx,0x20(%eax) 10b665: a1 ec 64 12 00 mov 0x1264ec,%eax 10b66a: 40 inc %eax 10b66b: a3 ec 64 12 00 mov %eax,0x1264ec 10b670: ff 75 18 pushl 0x18(%ebp) 10b673: 9d popf 10b674: 83 ec 08 sub $0x8,%esp 10b677: ff 75 14 pushl 0x14(%ebp) 10b67a: 53 push %ebx 10b67b: e8 18 ff ff ff call 10b598 <_CORE_mutex_Seize_interrupt_blocking> 10b680: 83 c4 10 add $0x10,%esp } 10b683: 8b 5d fc mov -0x4(%ebp),%ebx 10b686: c9 leave 10b687: c3 ret =============================================================================== 00110134 <_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 ) { 110134: 55 push %ebp 110135: 89 e5 mov %esp,%ebp 110137: 56 push %esi 110138: 53 push %ebx 110139: 8b 45 08 mov 0x8(%ebp),%eax 11013c: 8b 4d 0c mov 0xc(%ebp),%ecx { Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing; 11013f: 8b 15 78 67 12 00 mov 0x126778,%edx executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 110145: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 11014c: 8b 58 50 mov 0x50(%eax),%ebx 11014f: 85 db test %ebx,%ebx 110151: 74 31 je 110184 <_CORE_mutex_Seize_interrupt_trylock+0x50> the_mutex->lock = CORE_MUTEX_LOCKED; 110153: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) the_mutex->holder = executing; 11015a: 89 50 5c mov %edx,0x5c(%eax) the_mutex->holder_id = executing->Object.id; 11015d: 8b 5a 08 mov 0x8(%edx),%ebx 110160: 89 58 60 mov %ebx,0x60(%eax) the_mutex->nest_count = 1; 110163: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax) return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); } 11016a: 8b 58 48 mov 0x48(%eax),%ebx if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 11016d: 83 fb 02 cmp $0x2,%ebx 110170: 74 26 je 110198 <_CORE_mutex_Seize_interrupt_trylock+0x64> 110172: 83 fb 03 cmp $0x3,%ebx 110175: 74 3d je 1101b4 <_CORE_mutex_Seize_interrupt_trylock+0x80> executing->resource_count++; } if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { _ISR_Enable( *level_p ); 110177: ff 31 pushl (%ecx) 110179: 9d popf return 0; 11017a: 31 c0 xor %eax,%eax 11017c: 8d 65 f8 lea -0x8(%ebp),%esp 11017f: 5b pop %ebx 110180: 5e pop %esi 110181: c9 leave 110182: c3 ret 110183: 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 ) ) { 110184: 3b 50 5c cmp 0x5c(%eax),%edx 110187: 74 17 je 1101a0 <_CORE_mutex_Seize_interrupt_trylock+0x6c> /* * The mutex is not available and the caller must deal with the possibility * of blocking. */ return 1; 110189: b8 01 00 00 00 mov $0x1,%eax 11018e: 8d 65 f8 lea -0x8(%ebp),%esp 110191: 5b pop %ebx 110192: 5e pop %esi 110193: c9 leave 110194: c3 ret 110195: 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++; 110198: ff 42 1c incl 0x1c(%edx) 11019b: eb da jmp 110177 <_CORE_mutex_Seize_interrupt_trylock+0x43> 11019d: 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 ) { 1101a0: 8b 50 40 mov 0x40(%eax),%edx 1101a3: 85 d2 test %edx,%edx 1101a5: 75 e2 jne 110189 <_CORE_mutex_Seize_interrupt_trylock+0x55> case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 1101a7: ff 40 54 incl 0x54(%eax) _ISR_Enable( *level_p ); 1101aa: ff 31 pushl (%ecx) 1101ac: 9d popf return 0; 1101ad: 31 c0 xor %eax,%eax 1101af: eb dd jmp 11018e <_CORE_mutex_Seize_interrupt_trylock+0x5a> 1101b1: 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++; 1101b4: 8b 5a 1c mov 0x1c(%edx),%ebx 1101b7: 8d 73 01 lea 0x1(%ebx),%esi 1101ba: 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 ) { 1101bd: 8b 72 14 mov 0x14(%edx),%esi 1101c0: 39 70 4c cmp %esi,0x4c(%eax) 1101c3: 74 57 je 11021c <_CORE_mutex_Seize_interrupt_trylock+0xe8> _ISR_Enable( *level_p ); return 0; } if ( current > ceiling ) { 1101c5: 72 25 jb 1101ec <_CORE_mutex_Seize_interrupt_trylock+0xb8> ); _Thread_Enable_dispatch(); return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 1101c7: c7 42 34 05 00 00 00 movl $0x5,0x34(%edx) the_mutex->lock = CORE_MUTEX_UNLOCKED; 1101ce: c7 40 50 01 00 00 00 movl $0x1,0x50(%eax) the_mutex->nest_count = 0; /* undo locking above */ 1101d5: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) executing->resource_count--; /* undo locking above */ 1101dc: 89 5a 1c mov %ebx,0x1c(%edx) _ISR_Enable( *level_p ); 1101df: ff 31 pushl (%ecx) 1101e1: 9d popf return 0; 1101e2: 31 c0 xor %eax,%eax 1101e4: 8d 65 f8 lea -0x8(%ebp),%esp 1101e7: 5b pop %ebx 1101e8: 5e pop %esi 1101e9: c9 leave 1101ea: c3 ret 1101eb: 90 nop rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 1101ec: 8b 15 ec 64 12 00 mov 0x1264ec,%edx 1101f2: 42 inc %edx 1101f3: 89 15 ec 64 12 00 mov %edx,0x1264ec return 0; } if ( current > ceiling ) { _Thread_Disable_dispatch(); _ISR_Enable( *level_p ); 1101f9: ff 31 pushl (%ecx) 1101fb: 9d popf _Thread_Change_priority( 1101fc: 51 push %ecx 1101fd: 6a 00 push $0x0 1101ff: ff 70 4c pushl 0x4c(%eax) 110202: ff 70 5c pushl 0x5c(%eax) 110205: e8 ba c6 ff ff call 10c8c4 <_Thread_Change_priority> the_mutex->holder, the_mutex->Attributes.priority_ceiling, false ); _Thread_Enable_dispatch(); 11020a: e8 ed ca ff ff call 10ccfc <_Thread_Enable_dispatch> 11020f: 83 c4 10 add $0x10,%esp return 0; 110212: 31 c0 xor %eax,%eax 110214: e9 75 ff ff ff jmp 11018e <_CORE_mutex_Seize_interrupt_trylock+0x5a> 110219: 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 ); 11021c: ff 31 pushl (%ecx) 11021e: 9d popf return 0; 11021f: 31 c0 xor %eax,%eax 110221: e9 68 ff ff ff jmp 11018e <_CORE_mutex_Seize_interrupt_trylock+0x5a> =============================================================================== 0010b688 <_CORE_mutex_Surrender>: #else Objects_Id id __attribute__((unused)), CORE_mutex_API_mp_support_callout api_mutex_mp_support __attribute__((unused)) #endif ) { 10b688: 55 push %ebp 10b689: 89 e5 mov %esp,%ebp 10b68b: 53 push %ebx 10b68c: 83 ec 04 sub $0x4,%esp 10b68f: 8b 5d 08 mov 0x8(%ebp),%ebx Thread_Control *the_thread; Thread_Control *holder; holder = the_mutex->holder; 10b692: 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 ) { 10b695: 80 7b 44 00 cmpb $0x0,0x44(%ebx) 10b699: 74 15 je 10b6b0 <_CORE_mutex_Surrender+0x28> if ( !_Thread_Is_executing( holder ) ) 10b69b: 3b 05 78 67 12 00 cmp 0x126778,%eax 10b6a1: 74 0d je 10b6b0 <_CORE_mutex_Surrender+0x28> return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; 10b6a3: b8 02 00 00 00 mov $0x2,%eax } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 10b6a8: 8b 5d fc mov -0x4(%ebp),%ebx 10b6ab: c9 leave 10b6ac: c3 ret 10b6ad: 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 ) 10b6b0: 8b 53 54 mov 0x54(%ebx),%edx 10b6b3: 85 d2 test %edx,%edx 10b6b5: 74 51 je 10b708 <_CORE_mutex_Surrender+0x80> return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 10b6b7: 4a dec %edx 10b6b8: 89 53 54 mov %edx,0x54(%ebx) if ( the_mutex->nest_count != 0 ) { 10b6bb: 85 d2 test %edx,%edx 10b6bd: 75 49 jne 10b708 <_CORE_mutex_Surrender+0x80> } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 10b6bf: 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 ) || 10b6c2: 83 fa 02 cmp $0x2,%edx 10b6c5: 74 69 je 10b730 <_CORE_mutex_Surrender+0xa8> 10b6c7: 83 fa 03 cmp $0x3,%edx 10b6ca: 74 64 je 10b730 <_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; 10b6cc: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) the_mutex->holder_id = 0; 10b6d3: 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 ) ) ) { 10b6da: 83 ec 0c sub $0xc,%esp 10b6dd: 53 push %ebx 10b6de: e8 69 19 00 00 call 10d04c <_Thread_queue_Dequeue> 10b6e3: 83 c4 10 add $0x10,%esp 10b6e6: 85 c0 test %eax,%eax 10b6e8: 74 7a je 10b764 <_CORE_mutex_Surrender+0xdc> } else #endif { the_mutex->holder = the_thread; 10b6ea: 89 43 5c mov %eax,0x5c(%ebx) the_mutex->holder_id = the_thread->Object.id; 10b6ed: 8b 50 08 mov 0x8(%eax),%edx 10b6f0: 89 53 60 mov %edx,0x60(%ebx) the_mutex->nest_count = 1; 10b6f3: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx) switch ( the_mutex->Attributes.discipline ) { 10b6fa: 8b 53 48 mov 0x48(%ebx),%edx 10b6fd: 83 fa 02 cmp $0x2,%edx 10b700: 74 56 je 10b758 <_CORE_mutex_Surrender+0xd0> 10b702: 83 fa 03 cmp $0x3,%edx 10b705: 74 09 je 10b710 <_CORE_mutex_Surrender+0x88> 10b707: 90 nop } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; 10b708: 31 c0 xor %eax,%eax } 10b70a: 8b 5d fc mov -0x4(%ebp),%ebx 10b70d: c9 leave 10b70e: c3 ret 10b70f: 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++; 10b710: ff 40 1c incl 0x1c(%eax) if (the_mutex->Attributes.priority_ceiling < 10b713: 8b 53 4c mov 0x4c(%ebx),%edx 10b716: 3b 50 14 cmp 0x14(%eax),%edx 10b719: 73 ed jae 10b708 <_CORE_mutex_Surrender+0x80> the_thread->current_priority){ _Thread_Change_priority( 10b71b: 51 push %ecx 10b71c: 6a 00 push $0x0 10b71e: 52 push %edx 10b71f: 50 push %eax 10b720: e8 9f 11 00 00 call 10c8c4 <_Thread_Change_priority> 10b725: 83 c4 10 add $0x10,%esp } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; 10b728: 31 c0 xor %eax,%eax 10b72a: e9 79 ff ff ff jmp 10b6a8 <_CORE_mutex_Surrender+0x20> 10b72f: 90 nop _CORE_mutex_Pop_priority( the_mutex, holder ); if ( pop_status != CORE_MUTEX_STATUS_SUCCESSFUL ) return pop_status; holder->resource_count--; 10b730: 8b 50 1c mov 0x1c(%eax),%edx 10b733: 4a dec %edx 10b734: 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 && 10b737: 85 d2 test %edx,%edx 10b739: 75 91 jne 10b6cc <_CORE_mutex_Surrender+0x44> holder->real_priority != holder->current_priority ) { 10b73b: 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 && 10b73e: 3b 50 14 cmp 0x14(%eax),%edx 10b741: 74 89 je 10b6cc <_CORE_mutex_Surrender+0x44> holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, true ); 10b743: 51 push %ecx 10b744: 6a 01 push $0x1 10b746: 52 push %edx 10b747: 50 push %eax 10b748: e8 77 11 00 00 call 10c8c4 <_Thread_Change_priority> 10b74d: 83 c4 10 add $0x10,%esp 10b750: e9 77 ff ff ff jmp 10b6cc <_CORE_mutex_Surrender+0x44> 10b755: 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++; 10b758: ff 40 1c incl 0x1c(%eax) } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; 10b75b: 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; 10b75d: e9 46 ff ff ff jmp 10b6a8 <_CORE_mutex_Surrender+0x20> 10b762: 66 90 xchg %ax,%ax } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 10b764: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx) return CORE_MUTEX_STATUS_SUCCESSFUL; 10b76b: 31 c0 xor %eax,%eax 10b76d: e9 36 ff ff ff jmp 10b6a8 <_CORE_mutex_Surrender+0x20> =============================================================================== 0010b7c0 <_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 ) { 10b7c0: 55 push %ebp 10b7c1: 89 e5 mov %esp,%ebp 10b7c3: 53 push %ebx 10b7c4: 83 ec 10 sub $0x10,%esp 10b7c7: 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)) ) { 10b7ca: 53 push %ebx 10b7cb: e8 7c 18 00 00 call 10d04c <_Thread_queue_Dequeue> 10b7d0: 83 c4 10 add $0x10,%esp 10b7d3: 85 c0 test %eax,%eax 10b7d5: 74 09 je 10b7e0 <_CORE_semaphore_Surrender+0x20> { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10b7d7: 31 c0 xor %eax,%eax status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); } return status; } 10b7d9: 8b 5d fc mov -0x4(%ebp),%ebx 10b7dc: c9 leave 10b7dd: c3 ret 10b7de: 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 ); 10b7e0: 9c pushf 10b7e1: fa cli 10b7e2: 5a pop %edx if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10b7e3: 8b 43 48 mov 0x48(%ebx),%eax 10b7e6: 3b 43 40 cmp 0x40(%ebx),%eax 10b7e9: 72 0d jb 10b7f8 <_CORE_semaphore_Surrender+0x38><== ALWAYS TAKEN the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; 10b7eb: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED _ISR_Enable( level ); 10b7f0: 52 push %edx 10b7f1: 9d popf } return status; } 10b7f2: 8b 5d fc mov -0x4(%ebp),%ebx 10b7f5: c9 leave 10b7f6: c3 ret 10b7f7: 90 nop #endif } else { _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) the_semaphore->count += 1; 10b7f8: 40 inc %eax 10b7f9: 89 43 48 mov %eax,0x48(%ebx) { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10b7fc: 31 c0 xor %eax,%eax 10b7fe: eb f0 jmp 10b7f0 <_CORE_semaphore_Surrender+0x30> =============================================================================== 0010bc28 <_Chain_Get_with_empty_check>: bool _Chain_Get_with_empty_check( Chain_Control *chain, Chain_Node **node ) { 10bc28: 55 push %ebp 10bc29: 89 e5 mov %esp,%ebp 10bc2b: 57 push %edi 10bc2c: 56 push %esi 10bc2d: 53 push %ebx 10bc2e: 8b 45 08 mov 0x8(%ebp),%eax 10bc31: 8b 7d 0c mov 0xc(%ebp),%edi ISR_Level level; bool is_empty_now; _ISR_Disable( level ); 10bc34: 9c pushf 10bc35: fa cli 10bc36: 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 ); 10bc37: 8d 58 04 lea 0x4(%eax),%ebx Chain_Node *old_first = head->next; 10bc3a: 8b 10 mov (%eax),%edx if ( old_first != tail ) { 10bc3c: 39 d3 cmp %edx,%ebx 10bc3e: 74 18 je 10bc58 <_Chain_Get_with_empty_check+0x30> Chain_Node *new_first = old_first->next; 10bc40: 8b 0a mov (%edx),%ecx head->next = new_first; 10bc42: 89 08 mov %ecx,(%eax) new_first->previous = head; 10bc44: 89 41 04 mov %eax,0x4(%ecx) *the_node = old_first; 10bc47: 89 17 mov %edx,(%edi) is_empty_now = new_first == tail; 10bc49: 39 cb cmp %ecx,%ebx 10bc4b: 0f 94 c0 sete %al is_empty_now = _Chain_Get_with_empty_check_unprotected( chain, node ); _ISR_Enable( level ); 10bc4e: 56 push %esi 10bc4f: 9d popf return is_empty_now; } 10bc50: 5b pop %ebx 10bc51: 5e pop %esi 10bc52: 5f pop %edi 10bc53: c9 leave 10bc54: c3 ret 10bc55: 8d 76 00 lea 0x0(%esi),%esi } else *the_node = NULL; 10bc58: 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; 10bc5e: b0 01 mov $0x1,%al 10bc60: eb ec jmp 10bc4e <_Chain_Get_with_empty_check+0x26> =============================================================================== 0010fe2c <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10fe2c: 55 push %ebp 10fe2d: 89 e5 mov %esp,%ebp 10fe2f: 57 push %edi 10fe30: 56 push %esi 10fe31: 53 push %ebx 10fe32: 83 ec 08 sub $0x8,%esp 10fe35: 8b 7d 08 mov 0x8(%ebp),%edi 10fe38: 8b 4d 10 mov 0x10(%ebp),%ecx 10fe3b: 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 ); 10fe3e: 8d 47 04 lea 0x4(%edi),%eax 10fe41: 89 45 f0 mov %eax,-0x10(%ebp) Chain_Node *current = head; Chain_Node *next = starting_address; head->previous = NULL; 10fe44: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) while ( count-- ) { 10fe4b: 85 c9 test %ecx,%ecx 10fe4d: 74 35 je 10fe84 <_Chain_Initialize+0x58><== NEVER TAKEN 10fe4f: 49 dec %ecx 10fe50: 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; 10fe53: 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; 10fe56: 89 fa mov %edi,%edx 10fe58: eb 07 jmp 10fe61 <_Chain_Initialize+0x35> 10fe5a: 66 90 xchg %ax,%ax Chain_Node *next = starting_address; head->previous = NULL; while ( count-- ) { 10fe5c: 89 c2 mov %eax,%edx current->next = next; next->previous = current; current = next; next = (Chain_Node *) 10fe5e: 89 d8 mov %ebx,%eax 10fe60: 49 dec %ecx Chain_Node *next = starting_address; head->previous = NULL; while ( count-- ) { current->next = next; 10fe61: 89 02 mov %eax,(%edx) next->previous = current; 10fe63: 89 50 04 mov %edx,0x4(%eax) * node_size - size of node in bytes * * Output parameters: NONE */ void _Chain_Initialize( 10fe66: 8d 1c 30 lea (%eax,%esi,1),%ebx Chain_Node *current = head; Chain_Node *next = starting_address; head->previous = NULL; while ( count-- ) { 10fe69: 85 c9 test %ecx,%ecx 10fe6b: 75 ef jne 10fe5c <_Chain_Initialize+0x30> * node_size - size of node in bytes * * Output parameters: NONE */ void _Chain_Initialize( 10fe6d: 0f af 75 ec imul -0x14(%ebp),%esi 10fe71: 03 75 0c add 0xc(%ebp),%esi current = next; next = (Chain_Node *) _Addresses_Add_offset( (void *) next, node_size ); } current->next = tail; 10fe74: 8b 45 f0 mov -0x10(%ebp),%eax 10fe77: 89 06 mov %eax,(%esi) tail->previous = current; 10fe79: 89 77 08 mov %esi,0x8(%edi) } 10fe7c: 83 c4 08 add $0x8,%esp 10fe7f: 5b pop %ebx 10fe80: 5e pop %esi 10fe81: 5f pop %edi 10fe82: c9 leave 10fe83: 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; 10fe84: 89 fe mov %edi,%esi <== NOT EXECUTED 10fe86: eb ec jmp 10fe74 <_Chain_Initialize+0x48><== NOT EXECUTED =============================================================================== 0010a618 <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 10a618: 55 push %ebp 10a619: 89 e5 mov %esp,%ebp 10a61b: 57 push %edi 10a61c: 56 push %esi 10a61d: 53 push %ebx 10a61e: 83 ec 2c sub $0x2c,%esp 10a621: 8b 45 08 mov 0x8(%ebp),%eax 10a624: 8b 4d 0c mov 0xc(%ebp),%ecx 10a627: 8b 55 10 mov 0x10(%ebp),%edx 10a62a: 89 55 dc mov %edx,-0x24(%ebp) 10a62d: 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; 10a630: 8b 1d 78 67 12 00 mov 0x126778,%ebx executing->Wait.return_code = RTEMS_SUCCESSFUL; 10a636: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10a63d: 8b b3 e4 00 00 00 mov 0xe4(%ebx),%esi _ISR_Disable( level ); 10a643: 9c pushf 10a644: fa cli 10a645: 8f 45 e0 popl -0x20(%ebp) pending_events = api->pending_events; 10a648: 8b 16 mov (%esi),%edx 10a64a: 89 55 d4 mov %edx,-0x2c(%ebp) seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 10a64d: 21 c2 and %eax,%edx 10a64f: 89 55 e4 mov %edx,-0x1c(%ebp) 10a652: 74 0d je 10a661 <_Event_Seize+0x49> 10a654: 39 d0 cmp %edx,%eax 10a656: 0f 84 84 00 00 00 je 10a6e0 <_Event_Seize+0xc8> (seized_events == event_in || _Options_Is_any( option_set )) ) { 10a65c: f6 c1 02 test $0x2,%cl 10a65f: 75 7f jne 10a6e0 <_Event_Seize+0xc8> _ISR_Enable( level ); *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { 10a661: f6 c1 01 test $0x1,%cl 10a664: 75 62 jne 10a6c8 <_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; 10a666: 89 4b 30 mov %ecx,0x30(%ebx) executing->Wait.count = (uint32_t) event_in; 10a669: 89 43 24 mov %eax,0x24(%ebx) executing->Wait.return_argument = event_out; 10a66c: 89 7b 28 mov %edi,0x28(%ebx) _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10a66f: c7 05 e0 67 12 00 01 movl $0x1,0x1267e0 10a676: 00 00 00 _ISR_Enable( level ); 10a679: ff 75 e0 pushl -0x20(%ebp) 10a67c: 9d popf if ( ticks ) { 10a67d: 8b 45 dc mov -0x24(%ebp),%eax 10a680: 85 c0 test %eax,%eax 10a682: 0f 85 80 00 00 00 jne 10a708 <_Event_Seize+0xf0> NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 10a688: 83 ec 08 sub $0x8,%esp 10a68b: 68 00 01 00 00 push $0x100 10a690: 53 push %ebx 10a691: e8 5a 2e 00 00 call 10d4f0 <_Thread_Set_state> _ISR_Disable( level ); 10a696: 9c pushf 10a697: fa cli 10a698: 5a pop %edx sync_state = _Event_Sync_state; 10a699: a1 e0 67 12 00 mov 0x1267e0,%eax _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10a69e: c7 05 e0 67 12 00 00 movl $0x0,0x1267e0 10a6a5: 00 00 00 if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { 10a6a8: 83 c4 10 add $0x10,%esp 10a6ab: 83 f8 01 cmp $0x1,%eax 10a6ae: 74 4c je 10a6fc <_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 ); 10a6b0: 89 55 10 mov %edx,0x10(%ebp) 10a6b3: 89 5d 0c mov %ebx,0xc(%ebp) 10a6b6: 89 45 08 mov %eax,0x8(%ebp) } 10a6b9: 8d 65 f4 lea -0xc(%ebp),%esp 10a6bc: 5b pop %ebx 10a6bd: 5e pop %esi 10a6be: 5f pop %edi 10a6bf: 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 ); 10a6c0: e9 b3 21 00 00 jmp 10c878 <_Thread_blocking_operation_Cancel> 10a6c5: 8d 76 00 lea 0x0(%esi),%esi *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { _ISR_Enable( level ); 10a6c8: ff 75 e0 pushl -0x20(%ebp) 10a6cb: 9d popf executing->Wait.return_code = RTEMS_UNSATISFIED; 10a6cc: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx) *event_out = seized_events; 10a6d3: 8b 55 e4 mov -0x1c(%ebp),%edx 10a6d6: 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 ); } 10a6d8: 8d 65 f4 lea -0xc(%ebp),%esp 10a6db: 5b pop %ebx 10a6dc: 5e pop %esi 10a6dd: 5f pop %edi 10a6de: c9 leave 10a6df: 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) ); 10a6e0: 8b 45 e4 mov -0x1c(%ebp),%eax 10a6e3: f7 d0 not %eax 10a6e5: 23 45 d4 and -0x2c(%ebp),%eax 10a6e8: 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 ); 10a6ea: ff 75 e0 pushl -0x20(%ebp) 10a6ed: 9d popf *event_out = seized_events; 10a6ee: 8b 45 e4 mov -0x1c(%ebp),%eax 10a6f1: 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 ); } 10a6f3: 8d 65 f4 lea -0xc(%ebp),%esp 10a6f6: 5b pop %ebx 10a6f7: 5e pop %esi 10a6f8: 5f pop %edi 10a6f9: c9 leave 10a6fa: c3 ret 10a6fb: 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 ); 10a6fc: 52 push %edx 10a6fd: 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 ); } 10a6fe: 8d 65 f4 lea -0xc(%ebp),%esp 10a701: 5b pop %ebx 10a702: 5e pop %esi 10a703: 5f pop %edi 10a704: c9 leave 10a705: c3 ret 10a706: 66 90 xchg %ax,%ax _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; _ISR_Enable( level ); if ( ticks ) { _Watchdog_Initialize( 10a708: 8b 43 08 mov 0x8(%ebx),%eax Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10a70b: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) the_watchdog->routine = routine; 10a712: c7 43 64 bc a8 10 00 movl $0x10a8bc,0x64(%ebx) the_watchdog->id = id; 10a719: 89 43 68 mov %eax,0x68(%ebx) the_watchdog->user_data = user_data; 10a71c: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10a723: 8b 45 dc mov -0x24(%ebp),%eax 10a726: 89 43 54 mov %eax,0x54(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10a729: 83 ec 08 sub $0x8,%esp &executing->Timer, _Event_Timeout, executing->Object.id, NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); 10a72c: 8d 43 48 lea 0x48(%ebx),%eax 10a72f: 50 push %eax 10a730: 68 c0 65 12 00 push $0x1265c0 10a735: e8 ce 32 00 00 call 10da08 <_Watchdog_Insert> 10a73a: 83 c4 10 add $0x10,%esp 10a73d: e9 46 ff ff ff jmp 10a688 <_Event_Seize+0x70> =============================================================================== 0010a798 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 10a798: 55 push %ebp 10a799: 89 e5 mov %esp,%ebp 10a79b: 57 push %edi 10a79c: 56 push %esi 10a79d: 53 push %ebx 10a79e: 83 ec 2c sub $0x2c,%esp 10a7a1: 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 ]; 10a7a4: 8b 8b e4 00 00 00 mov 0xe4(%ebx),%ecx option_set = (rtems_option) the_thread->Wait.option; 10a7aa: 8b 7b 30 mov 0x30(%ebx),%edi _ISR_Disable( level ); 10a7ad: 9c pushf 10a7ae: fa cli 10a7af: 8f 45 d4 popl -0x2c(%ebp) pending_events = api->pending_events; 10a7b2: 8b 11 mov (%ecx),%edx event_condition = (rtems_event_set) the_thread->Wait.count; 10a7b4: 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 ) ) { 10a7b7: 89 c6 mov %eax,%esi 10a7b9: 21 d6 and %edx,%esi 10a7bb: 89 75 e4 mov %esi,-0x1c(%ebp) 10a7be: 74 74 je 10a834 <_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() && 10a7c0: 8b 35 74 67 12 00 mov 0x126774,%esi 10a7c6: 85 f6 test %esi,%esi 10a7c8: 74 0c je 10a7d6 <_Event_Surrender+0x3e> 10a7ca: 3b 1d 78 67 12 00 cmp 0x126778,%ebx 10a7d0: 0f 84 96 00 00 00 je 10a86c <_Event_Surrender+0xd4> } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 10a7d6: f6 43 11 01 testb $0x1,0x11(%ebx) 10a7da: 74 4c je 10a828 <_Event_Surrender+0x90> if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 10a7dc: 3b 45 e4 cmp -0x1c(%ebp),%eax 10a7df: 74 05 je 10a7e6 <_Event_Surrender+0x4e> 10a7e1: 83 e7 02 and $0x2,%edi 10a7e4: 74 42 je 10a828 <_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) ); 10a7e6: 8b 45 e4 mov -0x1c(%ebp),%eax 10a7e9: f7 d0 not %eax 10a7eb: 21 d0 and %edx,%eax 10a7ed: 89 01 mov %eax,(%ecx) api->pending_events = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 10a7ef: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 10a7f6: 8b 43 28 mov 0x28(%ebx),%eax 10a7f9: 8b 75 e4 mov -0x1c(%ebp),%esi 10a7fc: 89 30 mov %esi,(%eax) _ISR_Flash( level ); 10a7fe: ff 75 d4 pushl -0x2c(%ebp) 10a801: 9d popf 10a802: fa cli if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10a803: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 10a807: 74 37 je 10a840 <_Event_Surrender+0xa8> _ISR_Enable( level ); 10a809: ff 75 d4 pushl -0x2c(%ebp) 10a80c: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10a80d: 83 ec 08 sub $0x8,%esp 10a810: 68 f8 ff 03 10 push $0x1003fff8 10a815: 53 push %ebx 10a816: e8 7d 21 00 00 call 10c998 <_Thread_Clear_state> 10a81b: 83 c4 10 add $0x10,%esp } return; } } _ISR_Enable( level ); } 10a81e: 8d 65 f4 lea -0xc(%ebp),%esp 10a821: 5b pop %ebx 10a822: 5e pop %esi 10a823: 5f pop %edi 10a824: c9 leave 10a825: c3 ret 10a826: 66 90 xchg %ax,%ax _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 10a828: ff 75 d4 pushl -0x2c(%ebp) 10a82b: 9d popf } 10a82c: 8d 65 f4 lea -0xc(%ebp),%esp 10a82f: 5b pop %ebx 10a830: 5e pop %esi 10a831: 5f pop %edi 10a832: c9 leave 10a833: c3 ret /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { _ISR_Enable( level ); 10a834: ff 75 d4 pushl -0x2c(%ebp) 10a837: 9d popf } return; } } _ISR_Enable( level ); } 10a838: 8d 65 f4 lea -0xc(%ebp),%esp 10a83b: 5b pop %ebx 10a83c: 5e pop %esi 10a83d: 5f pop %edi 10a83e: c9 leave 10a83f: c3 ret RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 10a840: 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 ); 10a847: ff 75 d4 pushl -0x2c(%ebp) 10a84a: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 10a84b: 83 ec 0c sub $0xc,%esp 10a84e: 8d 43 48 lea 0x48(%ebx),%eax 10a851: 50 push %eax 10a852: e8 f1 32 00 00 call 10db48 <_Watchdog_Remove> 10a857: 58 pop %eax 10a858: 5a pop %edx 10a859: 68 f8 ff 03 10 push $0x1003fff8 10a85e: 53 push %ebx 10a85f: e8 34 21 00 00 call 10c998 <_Thread_Clear_state> 10a864: 83 c4 10 add $0x10,%esp 10a867: eb c3 jmp 10a82c <_Event_Surrender+0x94> 10a869: 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) || 10a86c: 8b 35 e0 67 12 00 mov 0x1267e0,%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 ) && 10a872: 83 fe 02 cmp $0x2,%esi 10a875: 74 0d je 10a884 <_Event_Surrender+0xec> <== NEVER TAKEN ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { 10a877: 8b 35 e0 67 12 00 mov 0x1267e0,%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) || 10a87d: 4e dec %esi 10a87e: 0f 85 52 ff ff ff jne 10a7d6 <_Event_Surrender+0x3e> (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 10a884: 3b 45 e4 cmp -0x1c(%ebp),%eax 10a887: 74 05 je 10a88e <_Event_Surrender+0xf6> 10a889: 83 e7 02 and $0x2,%edi 10a88c: 74 22 je 10a8b0 <_Event_Surrender+0x118><== NEVER TAKEN 10a88e: 8b 45 e4 mov -0x1c(%ebp),%eax 10a891: f7 d0 not %eax 10a893: 21 d0 and %edx,%eax 10a895: 89 01 mov %eax,(%ecx) api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 10a897: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 10a89e: 8b 43 28 mov 0x28(%ebx),%eax 10a8a1: 8b 55 e4 mov -0x1c(%ebp),%edx 10a8a4: 89 10 mov %edx,(%eax) _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 10a8a6: c7 05 e0 67 12 00 03 movl $0x3,0x1267e0 10a8ad: 00 00 00 } _ISR_Enable( level ); 10a8b0: ff 75 d4 pushl -0x2c(%ebp) 10a8b3: 9d popf return; 10a8b4: e9 73 ff ff ff jmp 10a82c <_Event_Surrender+0x94> =============================================================================== 0010a8bc <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 10a8bc: 55 push %ebp 10a8bd: 89 e5 mov %esp,%ebp 10a8bf: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 10a8c2: 8d 45 f4 lea -0xc(%ebp),%eax 10a8c5: 50 push %eax 10a8c6: ff 75 08 pushl 0x8(%ebp) 10a8c9: e8 52 24 00 00 call 10cd20 <_Thread_Get> switch ( location ) { 10a8ce: 83 c4 10 add $0x10,%esp 10a8d1: 8b 55 f4 mov -0xc(%ebp),%edx 10a8d4: 85 d2 test %edx,%edx 10a8d6: 75 37 jne 10a90f <_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 ); 10a8d8: 9c pushf 10a8d9: fa cli 10a8da: 5a pop %edx _ISR_Enable( level ); return; } #endif the_thread->Wait.count = 0; 10a8db: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) if ( _Thread_Is_executing( the_thread ) ) { 10a8e2: 3b 05 78 67 12 00 cmp 0x126778,%eax 10a8e8: 74 2a je 10a914 <_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; 10a8ea: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax) _ISR_Enable( level ); 10a8f1: 52 push %edx 10a8f2: 9d popf 10a8f3: 83 ec 08 sub $0x8,%esp 10a8f6: 68 f8 ff 03 10 push $0x1003fff8 10a8fb: 50 push %eax 10a8fc: e8 97 20 00 00 call 10c998 <_Thread_Clear_state> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10a901: a1 ec 64 12 00 mov 0x1264ec,%eax 10a906: 48 dec %eax 10a907: a3 ec 64 12 00 mov %eax,0x1264ec _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; 10a90c: 83 c4 10 add $0x10,%esp case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10a90f: c9 leave 10a910: c3 ret 10a911: 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 ) 10a914: 8b 0d e0 67 12 00 mov 0x1267e0,%ecx 10a91a: 49 dec %ecx 10a91b: 75 cd jne 10a8ea <_Event_Timeout+0x2e> _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10a91d: c7 05 e0 67 12 00 02 movl $0x2,0x1267e0 10a924: 00 00 00 10a927: eb c1 jmp 10a8ea <_Event_Timeout+0x2e> =============================================================================== 0011027c <_Heap_Allocate_aligned_with_boundary>: Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) { 11027c: 55 push %ebp 11027d: 89 e5 mov %esp,%ebp 11027f: 57 push %edi 110280: 56 push %esi 110281: 53 push %ebx 110282: 83 ec 2c sub $0x2c,%esp 110285: 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 110288: 8d 47 04 lea 0x4(%edi),%eax 11028b: 89 45 dc mov %eax,-0x24(%ebp) - HEAP_ALLOC_BONUS; uintptr_t const page_size = heap->page_size; 11028e: 8b 55 08 mov 0x8(%ebp),%edx 110291: 8b 52 10 mov 0x10(%edx),%edx 110294: 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 ) { 110297: 39 c7 cmp %eax,%edi 110299: 0f 87 69 01 00 00 ja 110408 <_Heap_Allocate_aligned_with_boundary+0x18c> /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { 11029f: 8b 5d 14 mov 0x14(%ebp),%ebx 1102a2: 85 db test %ebx,%ebx 1102a4: 0f 85 56 01 00 00 jne 110400 <_Heap_Allocate_aligned_with_boundary+0x184> if ( stats->max_search < search_count ) { stats->max_search = search_count; } return (void *) alloc_begin; } 1102aa: 8b 45 08 mov 0x8(%ebp),%eax 1102ad: 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 ) { 1102b0: 39 c8 cmp %ecx,%eax 1102b2: 0f 84 50 01 00 00 je 110408 <_Heap_Allocate_aligned_with_boundary+0x18c> 1102b8: 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 1102bf: 8b 55 cc mov -0x34(%ebp),%edx 1102c2: 83 c2 07 add $0x7,%edx 1102c5: 89 55 c8 mov %edx,-0x38(%ebp) + HEAP_BLOCK_HEADER_SIZE + page_size - 1; uintptr_t alloc_end = block_end + HEAP_ALLOC_BONUS; 1102c8: c7 45 d0 04 00 00 00 movl $0x4,-0x30(%ebp) 1102cf: 29 7d d0 sub %edi,-0x30(%ebp) 1102d2: eb 1e jmp 1102f2 <_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; 1102d4: 8d 59 08 lea 0x8(%ecx),%ebx } /* Statistics */ ++search_count; if ( alloc_begin != 0 ) { 1102d7: 85 db test %ebx,%ebx 1102d9: 0f 85 f1 00 00 00 jne 1103d0 <_Heap_Allocate_aligned_with_boundary+0x154><== ALWAYS TAKEN break; } block = block->next; 1102df: 8b 49 08 mov 0x8(%ecx),%ecx 1102e2: 8b 45 e4 mov -0x1c(%ebp),%eax 1102e5: 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 ) { 1102e6: 39 4d 08 cmp %ecx,0x8(%ebp) 1102e9: 0f 84 25 01 00 00 je 110414 <_Heap_Allocate_aligned_with_boundary+0x198> 1102ef: 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 ) { 1102f2: 8b 59 04 mov 0x4(%ecx),%ebx 1102f5: 39 5d dc cmp %ebx,-0x24(%ebp) 1102f8: 73 e5 jae 1102df <_Heap_Allocate_aligned_with_boundary+0x63> if ( alignment == 0 ) { 1102fa: 8b 55 10 mov 0x10(%ebp),%edx 1102fd: 85 d2 test %edx,%edx 1102ff: 74 d3 je 1102d4 <_Heap_Allocate_aligned_with_boundary+0x58> if ( stats->max_search < search_count ) { stats->max_search = search_count; } return (void *) alloc_begin; } 110301: 8b 45 08 mov 0x8(%ebp),%eax 110304: 8b 40 14 mov 0x14(%eax),%eax 110307: 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; 11030a: 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; 11030d: 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; 110310: 8d 51 08 lea 0x8(%ecx),%edx 110313: 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; 110316: 8b 75 c8 mov -0x38(%ebp),%esi 110319: 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 11031b: 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; 11031d: 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); 110320: 89 d8 mov %ebx,%eax 110322: 31 d2 xor %edx,%edx 110324: f7 75 10 divl 0x10(%ebp) 110327: 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 ) { 110329: 39 de cmp %ebx,%esi 11032b: 73 0b jae 110338 <_Heap_Allocate_aligned_with_boundary+0xbc> 11032d: 89 f0 mov %esi,%eax 11032f: 31 d2 xor %edx,%edx 110331: f7 75 10 divl 0x10(%ebp) 110334: 89 f3 mov %esi,%ebx 110336: 29 d3 sub %edx,%ebx } alloc_end = alloc_begin + alloc_size; /* Ensure boundary constaint */ if ( boundary != 0 ) { 110338: 8b 45 14 mov 0x14(%ebp),%eax 11033b: 85 c0 test %eax,%eax 11033d: 74 5b je 11039a <_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; 11033f: 8d 34 3b lea (%ebx,%edi,1),%esi 110342: 89 f0 mov %esi,%eax 110344: 31 d2 xor %edx,%edx 110346: f7 75 14 divl 0x14(%ebp) 110349: 89 f0 mov %esi,%eax 11034b: 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 ) { 11034d: 39 c3 cmp %eax,%ebx 11034f: 73 49 jae 11039a <_Heap_Allocate_aligned_with_boundary+0x11e> 110351: 39 c6 cmp %eax,%esi 110353: 76 45 jbe 11039a <_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; 110355: 8b 55 d4 mov -0x2c(%ebp),%edx 110358: 01 fa add %edi,%edx 11035a: 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 ) { 11035d: 39 c2 cmp %eax,%edx 11035f: 0f 87 7a ff ff ff ja 1102df <_Heap_Allocate_aligned_with_boundary+0x63> 110365: 89 ce mov %ecx,%esi 110367: eb 10 jmp 110379 <_Heap_Allocate_aligned_with_boundary+0xfd> 110369: 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 ) { 11036c: 39 c1 cmp %eax,%ecx 11036e: 76 28 jbe 110398 <_Heap_Allocate_aligned_with_boundary+0x11c> if ( boundary_line < boundary_floor ) { 110370: 39 45 e0 cmp %eax,-0x20(%ebp) 110373: 0f 87 9f 00 00 00 ja 110418 <_Heap_Allocate_aligned_with_boundary+0x19c><== NEVER TAKEN return 0; } alloc_begin = boundary_line - alloc_size; 110379: 89 c3 mov %eax,%ebx 11037b: 29 fb sub %edi,%ebx 11037d: 89 d8 mov %ebx,%eax 11037f: 31 d2 xor %edx,%edx 110381: f7 75 10 divl 0x10(%ebp) 110384: 29 d3 sub %edx,%ebx alloc_begin = _Heap_Align_down( alloc_begin, alignment ); alloc_end = alloc_begin + alloc_size; 110386: 8d 0c 3b lea (%ebx,%edi,1),%ecx 110389: 89 c8 mov %ecx,%eax 11038b: 31 d2 xor %edx,%edx 11038d: f7 75 14 divl 0x14(%ebp) 110390: 89 c8 mov %ecx,%eax 110392: 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 ) { 110394: 39 c3 cmp %eax,%ebx 110396: 72 d4 jb 11036c <_Heap_Allocate_aligned_with_boundary+0xf0> 110398: 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 ) { 11039a: 39 5d d4 cmp %ebx,-0x2c(%ebp) 11039d: 0f 87 3c ff ff ff ja 1102df <_Heap_Allocate_aligned_with_boundary+0x63> 1103a3: be f8 ff ff ff mov $0xfffffff8,%esi 1103a8: 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); 1103aa: 01 de add %ebx,%esi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 1103ac: 89 d8 mov %ebx,%eax 1103ae: 31 d2 xor %edx,%edx 1103b0: 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; 1103b3: 29 d6 sub %edx,%esi if ( free_size >= min_block_size || free_size == 0 ) { 1103b5: 39 75 d8 cmp %esi,-0x28(%ebp) 1103b8: 0f 86 19 ff ff ff jbe 1102d7 <_Heap_Allocate_aligned_with_boundary+0x5b> 1103be: 85 f6 test %esi,%esi 1103c0: 0f 85 19 ff ff ff jne 1102df <_Heap_Allocate_aligned_with_boundary+0x63> } /* Statistics */ ++search_count; if ( alloc_begin != 0 ) { 1103c6: 85 db test %ebx,%ebx 1103c8: 0f 84 11 ff ff ff je 1102df <_Heap_Allocate_aligned_with_boundary+0x63><== NEVER TAKEN 1103ce: 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; 1103d0: 8b 45 08 mov 0x8(%ebp),%eax 1103d3: ff 40 48 incl 0x48(%eax) stats->searches += search_count; 1103d6: 8b 55 e4 mov -0x1c(%ebp),%edx 1103d9: 01 50 4c add %edx,0x4c(%eax) block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size ); 1103dc: 57 push %edi 1103dd: 53 push %ebx 1103de: 51 push %ecx 1103df: 50 push %eax 1103e0: e8 8f b7 ff ff call 10bb74 <_Heap_Block_allocate> 1103e5: 89 d8 mov %ebx,%eax 1103e7: 83 c4 10 add $0x10,%esp boundary ); } /* Statistics */ if ( stats->max_search < search_count ) { 1103ea: 8b 55 e4 mov -0x1c(%ebp),%edx 1103ed: 8b 4d 08 mov 0x8(%ebp),%ecx 1103f0: 39 51 44 cmp %edx,0x44(%ecx) 1103f3: 73 15 jae 11040a <_Heap_Allocate_aligned_with_boundary+0x18e> stats->max_search = search_count; 1103f5: 89 51 44 mov %edx,0x44(%ecx) } return (void *) alloc_begin; } 1103f8: 8d 65 f4 lea -0xc(%ebp),%esp 1103fb: 5b pop %ebx 1103fc: 5e pop %esi 1103fd: 5f pop %edi 1103fe: c9 leave 1103ff: c3 ret /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { if ( boundary < alloc_size ) { 110400: 3b 7d 14 cmp 0x14(%ebp),%edi 110403: 76 1a jbe 11041f <_Heap_Allocate_aligned_with_boundary+0x1a3> 110405: 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 ) { 110408: 31 c0 xor %eax,%eax if ( stats->max_search < search_count ) { stats->max_search = search_count; } return (void *) alloc_begin; } 11040a: 8d 65 f4 lea -0xc(%ebp),%esp 11040d: 5b pop %ebx 11040e: 5e pop %esi 11040f: 5f pop %edi 110410: c9 leave 110411: c3 ret 110412: 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 ) { 110414: 31 c0 xor %eax,%eax 110416: eb d2 jmp 1103ea <_Heap_Allocate_aligned_with_boundary+0x16e> 110418: 89 f1 mov %esi,%ecx <== NOT EXECUTED 11041a: e9 c0 fe ff ff jmp 1102df <_Heap_Allocate_aligned_with_boundary+0x63><== NOT EXECUTED if ( boundary != 0 ) { if ( boundary < alloc_size ) { return NULL; } if ( alignment == 0 ) { 11041f: 8b 4d 10 mov 0x10(%ebp),%ecx 110422: 85 c9 test %ecx,%ecx 110424: 0f 85 80 fe ff ff jne 1102aa <_Heap_Allocate_aligned_with_boundary+0x2e> alignment = page_size; 11042a: 89 55 10 mov %edx,0x10(%ebp) 11042d: e9 78 fe ff ff jmp 1102aa <_Heap_Allocate_aligned_with_boundary+0x2e> =============================================================================== 00110790 <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 110790: 55 push %ebp 110791: 89 e5 mov %esp,%ebp 110793: 57 push %edi 110794: 56 push %esi 110795: 53 push %ebx 110796: 83 ec 4c sub $0x4c,%esp 110799: 8b 5d 08 mov 0x8(%ebp),%ebx 11079c: 8b 4d 10 mov 0x10(%ebp),%ecx Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 11079f: 8b 43 20 mov 0x20(%ebx),%eax 1107a2: 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; 1107a5: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) Heap_Block *extend_last_block = NULL; 1107ac: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) uintptr_t const page_size = heap->page_size; 1107b3: 8b 53 10 mov 0x10(%ebx),%edx 1107b6: 89 55 d4 mov %edx,-0x2c(%ebp) uintptr_t const min_block_size = heap->min_block_size; 1107b9: 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; 1107bc: 8b 73 30 mov 0x30(%ebx),%esi 1107bf: 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 ) { 1107c2: 8b 55 0c mov 0xc(%ebp),%edx 1107c5: 01 ca add %ecx,%edx 1107c7: 89 55 cc mov %edx,-0x34(%ebp) 1107ca: 73 0c jae 1107d8 <_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; 1107cc: 31 c0 xor %eax,%eax if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 1107ce: 8d 65 f4 lea -0xc(%ebp),%esp 1107d1: 5b pop %ebx 1107d2: 5e pop %esi 1107d3: 5f pop %edi 1107d4: c9 leave 1107d5: c3 ret 1107d6: 66 90 xchg %ax,%ax if ( extend_area_end < extend_area_begin ) { return false; } extend_area_ok = _Heap_Get_first_and_last_block( 1107d8: 83 ec 08 sub $0x8,%esp 1107db: 8d 55 e0 lea -0x20(%ebp),%edx 1107de: 52 push %edx 1107df: 8d 55 e4 lea -0x1c(%ebp),%edx 1107e2: 52 push %edx 1107e3: 50 push %eax 1107e4: ff 75 d4 pushl -0x2c(%ebp) 1107e7: 51 push %ecx 1107e8: ff 75 0c pushl 0xc(%ebp) 1107eb: e8 90 b5 ff ff call 10bd80 <_Heap_Get_first_and_last_block> page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 1107f0: 83 c4 20 add $0x20,%esp 1107f3: 84 c0 test %al,%al 1107f5: 74 d5 je 1107cc <_Heap_Extend+0x3c> 1107f7: 8b 7d d0 mov -0x30(%ebp),%edi 1107fa: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp) 110801: c7 45 b8 00 00 00 00 movl $0x0,-0x48(%ebp) 110808: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) 11080f: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) 110816: 8b 75 cc mov -0x34(%ebp),%esi 110819: 89 5d b4 mov %ebx,-0x4c(%ebp) 11081c: eb 30 jmp 11084e <_Heap_Extend+0xbe> 11081e: 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 ) { 110820: 39 ce cmp %ecx,%esi 110822: 73 03 jae 110827 <_Heap_Extend+0x97> 110824: 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); 110827: 8d 59 f8 lea -0x8(%ecx),%ebx 11082a: 89 c8 mov %ecx,%eax 11082c: 31 d2 xor %edx,%edx 11082e: 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); 110831: 29 d3 sub %edx,%ebx link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 110833: 3b 4d 0c cmp 0xc(%ebp),%ecx 110836: 74 3c je 110874 <_Heap_Extend+0xe4> <== NEVER TAKEN start_block->prev_size = extend_area_end; merge_above_block = end_block; } else if ( sub_area_end < extend_area_begin ) { 110838: 39 4d 0c cmp %ecx,0xc(%ebp) 11083b: 76 03 jbe 110840 <_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 ) 11083d: 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; 110840: 8b 7b 04 mov 0x4(%ebx),%edi 110843: 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); 110846: 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 ); 110849: 39 7d d0 cmp %edi,-0x30(%ebp) 11084c: 74 39 je 110887 <_Heap_Extend+0xf7> return false; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 11084e: 3b 7d d0 cmp -0x30(%ebp),%edi 110851: 0f 84 39 01 00 00 je 110990 <_Heap_Extend+0x200> 110857: 89 f8 mov %edi,%eax uintptr_t const sub_area_end = start_block->prev_size; 110859: 8b 0f mov (%edi),%ecx Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 11085b: 39 4d 0c cmp %ecx,0xc(%ebp) 11085e: 73 08 jae 110868 <_Heap_Extend+0xd8> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin 110860: 39 f0 cmp %esi,%eax 110862: 0f 82 64 ff ff ff jb 1107cc <_Heap_Extend+0x3c> ) { return false; } if ( extend_area_end == sub_area_begin ) { 110868: 39 f0 cmp %esi,%eax 11086a: 75 b4 jne 110820 <_Heap_Extend+0x90> 11086c: 89 7d c4 mov %edi,-0x3c(%ebp) 11086f: eb b6 jmp 110827 <_Heap_Extend+0x97> 110871: 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; 110874: 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 ) 110876: 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; 110879: 8b 7b 04 mov 0x4(%ebx),%edi 11087c: 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); 11087f: 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 ); 110882: 39 7d d0 cmp %edi,-0x30(%ebp) 110885: 75 c7 jne 11084e <_Heap_Extend+0xbe> <== NEVER TAKEN 110887: 8b 5d b4 mov -0x4c(%ebp),%ebx if ( extend_area_begin < heap->area_begin ) { 11088a: 8b 75 0c mov 0xc(%ebp),%esi 11088d: 3b 73 18 cmp 0x18(%ebx),%esi 110890: 0f 82 06 01 00 00 jb 11099c <_Heap_Extend+0x20c> heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { 110896: 8b 45 cc mov -0x34(%ebp),%eax 110899: 3b 43 1c cmp 0x1c(%ebx),%eax 11089c: 76 03 jbe 1108a1 <_Heap_Extend+0x111> heap->area_end = extend_area_end; 11089e: 89 43 1c mov %eax,0x1c(%ebx) } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 1108a1: 8b 55 e0 mov -0x20(%ebp),%edx 1108a4: 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 = 1108a7: 89 d1 mov %edx,%ecx 1108a9: 29 c1 sub %eax,%ecx (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; extend_first_block->prev_size = extend_area_end; 1108ab: 8b 75 cc mov -0x34(%ebp),%esi 1108ae: 89 30 mov %esi,(%eax) extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 1108b0: 89 ce mov %ecx,%esi 1108b2: 83 ce 01 or $0x1,%esi 1108b5: 89 70 04 mov %esi,0x4(%eax) _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 1108b8: 89 0a mov %ecx,(%edx) extend_last_block->size_and_flag = 0; 1108ba: 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 ) { 1108c1: 39 43 20 cmp %eax,0x20(%ebx) 1108c4: 0f 86 da 00 00 00 jbe 1109a4 <_Heap_Extend+0x214> heap->first_block = extend_first_block; 1108ca: 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 ) { 1108cd: 8b 75 c4 mov -0x3c(%ebp),%esi 1108d0: 85 f6 test %esi,%esi 1108d2: 0f 84 10 01 00 00 je 1109e8 <_Heap_Extend+0x258> Heap_Control *heap, uintptr_t extend_area_begin, Heap_Block *first_block ) { uintptr_t const page_size = heap->page_size; 1108d8: 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 ); 1108db: 8b 4d 0c mov 0xc(%ebp),%ecx 1108de: 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; 1108e1: 89 c8 mov %ecx,%eax 1108e3: 31 d2 xor %edx,%edx 1108e5: f7 f6 div %esi if ( remainder != 0 ) { 1108e7: 85 d2 test %edx,%edx 1108e9: 0f 84 c9 00 00 00 je 1109b8 <_Heap_Extend+0x228> return value - remainder + alignment; 1108ef: 8d 04 31 lea (%ecx,%esi,1),%eax 1108f2: 29 d0 sub %edx,%eax uintptr_t const new_first_block_begin = 1108f4: 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; 1108f7: 8b 75 c4 mov -0x3c(%ebp),%esi 1108fa: 8b 0e mov (%esi),%ecx 1108fc: 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 = 1108ff: 89 f0 mov %esi,%eax 110901: 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; 110903: 83 c8 01 or $0x1,%eax 110906: 89 42 04 mov %eax,0x4(%edx) _Heap_Free_block( heap, new_first_block ); 110909: 89 d8 mov %ebx,%eax 11090b: e8 64 fe ff ff call 110774 <_Heap_Free_block> link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 110910: 8b 45 c8 mov -0x38(%ebp),%eax 110913: 85 c0 test %eax,%eax 110915: 0f 84 a5 00 00 00 je 1109c0 <_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, 11091b: 8b 4d cc mov -0x34(%ebp),%ecx 11091e: 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( 110921: 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); 110924: 89 c8 mov %ecx,%eax 110926: 31 d2 xor %edx,%edx 110928: f7 73 10 divl 0x10(%ebx) 11092b: 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) 11092d: 8b 55 c8 mov -0x38(%ebp),%edx 110930: 8b 42 04 mov 0x4(%edx),%eax 110933: 29 c8 sub %ecx,%eax | HEAP_PREV_BLOCK_USED; 110935: 83 c8 01 or $0x1,%eax 110938: 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; 11093c: 8b 42 04 mov 0x4(%edx),%eax 11093f: 83 e0 01 and $0x1,%eax block->size_and_flag = size | flag; 110942: 09 c8 or %ecx,%eax 110944: 89 42 04 mov %eax,0x4(%edx) _Heap_Block_set_size( last_block, last_block_new_size ); _Heap_Free_block( heap, last_block ); 110947: 89 d8 mov %ebx,%eax 110949: e8 26 fe ff ff call 110774 <_Heap_Free_block> extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 11094e: 8b 75 c4 mov -0x3c(%ebp),%esi 110951: 85 f6 test %esi,%esi 110953: 0f 84 ab 00 00 00 je 110a04 <_Heap_Extend+0x274> if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 110959: 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( 11095c: 8b 43 20 mov 0x20(%ebx),%eax 11095f: 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; 110961: 8b 4a 04 mov 0x4(%edx),%ecx 110964: 83 e1 01 and $0x1,%ecx block->size_and_flag = size | flag; 110967: 09 c8 or %ecx,%eax 110969: 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; 11096c: 8b 43 30 mov 0x30(%ebx),%eax 11096f: 2b 45 c0 sub -0x40(%ebp),%eax /* Statistics */ stats->size += extended_size; 110972: 01 43 2c add %eax,0x2c(%ebx) if ( extended_size_ptr != NULL ) 110975: 8b 55 14 mov 0x14(%ebp),%edx 110978: 85 d2 test %edx,%edx 11097a: 0f 84 a0 00 00 00 je 110a20 <_Heap_Extend+0x290> <== NEVER TAKEN *extended_size_ptr = extended_size; 110980: 8b 55 14 mov 0x14(%ebp),%edx 110983: 89 02 mov %eax,(%edx) return true; 110985: b0 01 mov $0x1,%al } 110987: 8d 65 f4 lea -0xc(%ebp),%esp 11098a: 5b pop %ebx 11098b: 5e pop %esi 11098c: 5f pop %edi 11098d: c9 leave 11098e: c3 ret 11098f: 90 nop return false; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 110990: 8b 55 b4 mov -0x4c(%ebp),%edx 110993: 8b 42 18 mov 0x18(%edx),%eax 110996: e9 be fe ff ff jmp 110859 <_Heap_Extend+0xc9> 11099b: 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; 11099c: 89 73 18 mov %esi,0x18(%ebx) 11099f: e9 fd fe ff ff jmp 1108a1 <_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 ) { 1109a4: 39 53 24 cmp %edx,0x24(%ebx) 1109a7: 0f 83 20 ff ff ff jae 1108cd <_Heap_Extend+0x13d> heap->last_block = extend_last_block; 1109ad: 89 53 24 mov %edx,0x24(%ebx) 1109b0: e9 18 ff ff ff jmp 1108cd <_Heap_Extend+0x13d> 1109b5: 8d 76 00 lea 0x0(%esi),%esi uintptr_t remainder = value % alignment; if ( remainder != 0 ) { return value - remainder + alignment; } else { return value; 1109b8: 89 c8 mov %ecx,%eax 1109ba: e9 35 ff ff ff jmp 1108f4 <_Heap_Extend+0x164> 1109bf: 90 nop ); } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { 1109c0: 8b 7d bc mov -0x44(%ebp),%edi 1109c3: 85 ff test %edi,%edi 1109c5: 74 87 je 11094e <_Heap_Extend+0x1be> _Heap_Link_above( 1109c7: 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 ); 1109ca: 8b 45 e4 mov -0x1c(%ebp),%eax 1109cd: 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; 1109d0: 8b 75 bc mov -0x44(%ebp),%esi 1109d3: 8b 56 04 mov 0x4(%esi),%edx 1109d6: 83 e2 01 and $0x1,%edx block->size_and_flag = size | flag; 1109d9: 09 d0 or %edx,%eax 1109db: 89 46 04 mov %eax,0x4(%esi) last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 1109de: 83 49 04 01 orl $0x1,0x4(%ecx) 1109e2: e9 67 ff ff ff jmp 11094e <_Heap_Extend+0x1be> 1109e7: 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 ) { 1109e8: 8b 4d b8 mov -0x48(%ebp),%ecx 1109eb: 85 c9 test %ecx,%ecx 1109ed: 0f 84 1d ff ff ff je 110910 <_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; 1109f3: 8b 45 b8 mov -0x48(%ebp),%eax 1109f6: 29 d0 sub %edx,%eax 1109f8: 83 c8 01 or $0x1,%eax 1109fb: 89 42 04 mov %eax,0x4(%edx) 1109fe: e9 0d ff ff ff jmp 110910 <_Heap_Extend+0x180> 110a03: 90 nop extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 110a04: 8b 4d c8 mov -0x38(%ebp),%ecx 110a07: 85 c9 test %ecx,%ecx 110a09: 0f 85 4a ff ff ff jne 110959 <_Heap_Extend+0x1c9> _Heap_Free_block( heap, extend_first_block ); 110a0f: 8b 55 e4 mov -0x1c(%ebp),%edx 110a12: 89 d8 mov %ebx,%eax 110a14: e8 5b fd ff ff call 110774 <_Heap_Free_block> 110a19: e9 3b ff ff ff jmp 110959 <_Heap_Extend+0x1c9> 110a1e: 66 90 xchg %ax,%ax stats->size += extended_size; if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; 110a20: b0 01 mov $0x1,%al <== NOT EXECUTED 110a22: e9 a7 fd ff ff jmp 1107ce <_Heap_Extend+0x3e> <== NOT EXECUTED =============================================================================== 00110434 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 110434: 55 push %ebp 110435: 89 e5 mov %esp,%ebp 110437: 57 push %edi 110438: 56 push %esi 110439: 53 push %ebx 11043a: 83 ec 10 sub $0x10,%esp 11043d: 8b 4d 08 mov 0x8(%ebp),%ecx 110440: 8b 45 0c mov 0xc(%ebp),%eax /* * If NULL return true so a free on NULL is considered a valid release. This * is a special case that could be handled by the in heap check how-ever that * would result in false being returned which is wrong. */ if ( alloc_begin_ptr == NULL ) { 110443: 85 c0 test %eax,%eax 110445: 0f 84 e9 00 00 00 je 110534 <_Heap_Free+0x100> 11044b: 8d 58 f8 lea -0x8(%eax),%ebx 11044e: 31 d2 xor %edx,%edx 110450: f7 71 10 divl 0x10(%ecx) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 110453: 29 d3 sub %edx,%ebx 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 110455: 8b 41 20 mov 0x20(%ecx),%eax && (uintptr_t) block <= (uintptr_t) heap->last_block; 110458: 39 c3 cmp %eax,%ebx 11045a: 72 1c jb 110478 <_Heap_Free+0x44> 11045c: 8b 71 24 mov 0x24(%ecx),%esi 11045f: 39 f3 cmp %esi,%ebx 110461: 77 15 ja 110478 <_Heap_Free+0x44> --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 110463: 8b 53 04 mov 0x4(%ebx),%edx 110466: 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; 110469: 83 e2 fe and $0xfffffffe,%edx 11046c: 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); 11046f: 8d 14 13 lea (%ebx,%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; 110472: 39 d0 cmp %edx,%eax 110474: 76 0e jbe 110484 <_Heap_Free+0x50> <== ALWAYS TAKEN 110476: 66 90 xchg %ax,%ax /* 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 ); 110478: 31 c0 xor %eax,%eax --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 11047a: 83 c4 10 add $0x10,%esp 11047d: 5b pop %ebx 11047e: 5e pop %esi 11047f: 5f pop %edi 110480: c9 leave 110481: c3 ret 110482: 66 90 xchg %ax,%ax 110484: 39 d6 cmp %edx,%esi 110486: 72 f0 jb 110478 <_Heap_Free+0x44> <== NEVER TAKEN 110488: 8b 7a 04 mov 0x4(%edx),%edi return false; } _Heap_Protection_block_check( heap, next_block ); if ( !_Heap_Is_prev_used( next_block ) ) { 11048b: f7 c7 01 00 00 00 test $0x1,%edi 110491: 74 e5 je 110478 <_Heap_Free+0x44> <== 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; 110493: 83 e7 fe and $0xfffffffe,%edi 110496: 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 )); 110499: 39 d6 cmp %edx,%esi 11049b: 0f 84 d3 00 00 00 je 110574 <_Heap_Free+0x140> return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) 1104a1: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1) 1104a6: 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 ) ) { 1104aa: f6 45 f0 01 testb $0x1,-0x10(%ebp) 1104ae: 75 44 jne 1104f4 <_Heap_Free+0xc0> uintptr_t const prev_size = block->prev_size; 1104b0: 8b 3b mov (%ebx),%edi 1104b2: 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); 1104b5: 29 fb sub %edi,%ebx 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; 1104b7: 39 d8 cmp %ebx,%eax 1104b9: 77 bd ja 110478 <_Heap_Free+0x44> <== NEVER TAKEN 1104bb: 39 de cmp %ebx,%esi 1104bd: 72 b9 jb 110478 <_Heap_Free+0x44> <== 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) ) { 1104bf: f6 43 04 01 testb $0x1,0x4(%ebx) 1104c3: 74 b3 je 110478 <_Heap_Free+0x44> <== NEVER TAKEN _HAssert( false ); return( false ); } if ( next_is_free ) { /* coalesce both */ 1104c5: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) 1104c9: 0f 84 b1 00 00 00 je 110580 <_Heap_Free+0x14c> uintptr_t const size = block_size + prev_size + next_block_size; 1104cf: 8b 7d e4 mov -0x1c(%ebp),%edi 1104d2: 03 7d ec add -0x14(%ebp),%edi 1104d5: 03 7d f0 add -0x10(%ebp),%edi --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 1104d8: 8b 42 08 mov 0x8(%edx),%eax 1104db: 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; 1104de: 89 42 08 mov %eax,0x8(%edx) next->prev = prev; 1104e1: 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; 1104e4: ff 49 38 decl 0x38(%ecx) prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 1104e7: 89 f8 mov %edi,%eax 1104e9: 83 c8 01 or $0x1,%eax 1104ec: 89 43 04 mov %eax,0x4(%ebx) next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; 1104ef: 89 3c 3b mov %edi,(%ebx,%edi,1) 1104f2: eb 29 jmp 11051d <_Heap_Free+0xe9> 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 */ 1104f4: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) 1104f8: 74 46 je 110540 <_Heap_Free+0x10c> uintptr_t const size = block_size + next_block_size; 1104fa: 8b 7d e4 mov -0x1c(%ebp),%edi 1104fd: 03 7d ec add -0x14(%ebp),%edi --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 110500: 8b 42 08 mov 0x8(%edx),%eax 110503: 8b 52 0c mov 0xc(%edx),%edx ) { Heap_Block *next = old_block->next; Heap_Block *prev = old_block->prev; new_block->next = next; 110506: 89 43 08 mov %eax,0x8(%ebx) new_block->prev = prev; 110509: 89 53 0c mov %edx,0xc(%ebx) next->prev = new_block; 11050c: 89 58 0c mov %ebx,0xc(%eax) prev->next = new_block; 11050f: 89 5a 08 mov %ebx,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; 110512: 89 f8 mov %edi,%eax 110514: 83 c8 01 or $0x1,%eax 110517: 89 43 04 mov %eax,0x4(%ebx) next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 11051a: 89 3c 3b mov %edi,(%ebx,%edi,1) stats->max_free_blocks = stats->free_blocks; } } /* Statistics */ --stats->used_blocks; 11051d: ff 49 40 decl 0x40(%ecx) ++stats->frees; 110520: ff 41 50 incl 0x50(%ecx) stats->free_size += block_size; 110523: 8b 55 ec mov -0x14(%ebp),%edx 110526: 01 51 30 add %edx,0x30(%ecx) return( true ); 110529: b0 01 mov $0x1,%al } 11052b: 83 c4 10 add $0x10,%esp 11052e: 5b pop %ebx 11052f: 5e pop %esi 110530: 5f pop %edi 110531: c9 leave 110532: c3 ret 110533: 90 nop * If NULL return true so a free on NULL is considered a valid release. This * is a special case that could be handled by the in heap check how-ever that * would result in false being returned which is wrong. */ if ( alloc_begin_ptr == NULL ) { return true; 110534: b0 01 mov $0x1,%al --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 110536: 83 c4 10 add $0x10,%esp 110539: 5b pop %ebx 11053a: 5e pop %esi 11053b: 5f pop %edi 11053c: c9 leave 11053d: c3 ret 11053e: 66 90 xchg %ax,%ax RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after( Heap_Block *block_before, Heap_Block *new_block ) { Heap_Block *next = block_before->next; 110540: 8b 41 08 mov 0x8(%ecx),%eax new_block->next = next; 110543: 89 43 08 mov %eax,0x8(%ebx) new_block->prev = block_before; 110546: 89 4b 0c mov %ecx,0xc(%ebx) block_before->next = new_block; 110549: 89 59 08 mov %ebx,0x8(%ecx) next->prev = new_block; 11054c: 89 58 0c mov %ebx,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; 11054f: 8b 45 ec mov -0x14(%ebp),%eax 110552: 83 c8 01 or $0x1,%eax 110555: 89 43 04 mov %eax,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 110558: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = block_size; 11055c: 8b 45 ec mov -0x14(%ebp),%eax 11055f: 89 02 mov %eax,(%edx) /* Statistics */ ++stats->free_blocks; 110561: 8b 41 38 mov 0x38(%ecx),%eax 110564: 40 inc %eax 110565: 89 41 38 mov %eax,0x38(%ecx) if ( stats->max_free_blocks < stats->free_blocks ) { 110568: 3b 41 3c cmp 0x3c(%ecx),%eax 11056b: 76 b0 jbe 11051d <_Heap_Free+0xe9> stats->max_free_blocks = stats->free_blocks; 11056d: 89 41 3c mov %eax,0x3c(%ecx) 110570: eb ab jmp 11051d <_Heap_Free+0xe9> 110572: 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 )); 110574: c6 45 eb 00 movb $0x0,-0x15(%ebp) 110578: e9 2d ff ff ff jmp 1104aa <_Heap_Free+0x76> 11057d: 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; 110580: 8b 45 ec mov -0x14(%ebp),%eax 110583: 03 45 f0 add -0x10(%ebp),%eax prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 110586: 89 c6 mov %eax,%esi 110588: 83 ce 01 or $0x1,%esi 11058b: 89 73 04 mov %esi,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 11058e: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = size; 110592: 89 02 mov %eax,(%edx) 110594: eb 87 jmp 11051d <_Heap_Free+0xe9> =============================================================================== 0010ba04 <_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 ) { 10ba04: 55 push %ebp 10ba05: 89 e5 mov %esp,%ebp 10ba07: 57 push %edi 10ba08: 56 push %esi 10ba09: 53 push %ebx 10ba0a: 8b 4d 08 mov 0x8(%ebp),%ecx 10ba0d: 8b 7d 0c mov 0xc(%ebp),%edi uintptr_t const heap_area_end = heap_area_begin + heap_area_size; 10ba10: 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 ); 10ba13: 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; 10ba16: 89 d8 mov %ebx,%eax 10ba18: 31 d2 xor %edx,%edx 10ba1a: f7 75 10 divl 0x10(%ebp) if ( remainder != 0 ) { 10ba1d: 85 d2 test %edx,%edx 10ba1f: 74 05 je 10ba26 <_Heap_Get_first_and_last_block+0x22> return value - remainder + alignment; 10ba21: 03 5d 10 add 0x10(%ebp),%ebx 10ba24: 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 ( 10ba26: 39 f1 cmp %esi,%ecx 10ba28: 77 2e ja 10ba58 <_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); 10ba2a: 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 = 10ba2d: 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 10ba2f: 39 df cmp %ebx,%edi 10ba31: 76 25 jbe 10ba58 <_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 ); 10ba33: 29 df sub %ebx,%edi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10ba35: 89 f8 mov %edi,%eax 10ba37: 31 d2 xor %edx,%edx 10ba39: f7 75 10 divl 0x10(%ebp) 10ba3c: 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 10ba3e: 39 7d 14 cmp %edi,0x14(%ebp) 10ba41: 77 15 ja 10ba58 <_Heap_Get_first_and_last_block+0x54> ) { /* Invalid area or area too small */ return false; } *first_block_ptr = first_block; 10ba43: 8b 45 18 mov 0x18(%ebp),%eax 10ba46: 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); 10ba48: 01 f7 add %esi,%edi 10ba4a: 8b 45 1c mov 0x1c(%ebp),%eax 10ba4d: 89 38 mov %edi,(%eax) *last_block_ptr = last_block; return true; 10ba4f: b0 01 mov $0x1,%al } 10ba51: 5b pop %ebx 10ba52: 5e pop %esi 10ba53: 5f pop %edi 10ba54: c9 leave 10ba55: c3 ret 10ba56: 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; 10ba58: 31 c0 xor %eax,%eax *first_block_ptr = first_block; *last_block_ptr = last_block; return true; } 10ba5a: 5b pop %ebx 10ba5b: 5e pop %esi 10ba5c: 5f pop %edi 10ba5d: c9 leave 10ba5e: c3 ret =============================================================================== 001141b8 <_Heap_Get_free_information>: void _Heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 1141b8: 55 push %ebp 1141b9: 89 e5 mov %esp,%ebp 1141bb: 57 push %edi 1141bc: 56 push %esi 1141bd: 53 push %ebx 1141be: 8b 7d 0c mov 0xc(%ebp),%edi Heap_Block *the_block; Heap_Block *const tail = _Heap_Free_list_tail(the_heap); info->number = 0; 1141c1: c7 07 00 00 00 00 movl $0x0,(%edi) info->largest = 0; 1141c7: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) info->total = 0; 1141ce: 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; } } 1141d5: 8b 45 08 mov 0x8(%ebp),%eax 1141d8: 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); 1141db: 39 d0 cmp %edx,%eax 1141dd: 74 31 je 114210 <_Heap_Get_free_information+0x58> 1141df: b9 01 00 00 00 mov $0x1,%ecx 1141e4: 31 f6 xor %esi,%esi 1141e6: 31 db xor %ebx,%ebx 1141e8: eb 07 jmp 1141f1 <_Heap_Get_free_information+0x39> 1141ea: 66 90 xchg %ax,%ax 1141ec: 8b 77 04 mov 0x4(%edi),%esi 1141ef: 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; 1141f1: 8b 42 04 mov 0x4(%edx),%eax 1141f4: 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; 1141f7: 01 c3 add %eax,%ebx if ( info->largest < the_size ) 1141f9: 39 f0 cmp %esi,%eax 1141fb: 76 03 jbe 114200 <_Heap_Get_free_information+0x48> info->largest = the_size; 1141fd: 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) 114200: 8b 52 08 mov 0x8(%edx),%edx 114203: 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); 114206: 39 55 08 cmp %edx,0x8(%ebp) 114209: 75 e1 jne 1141ec <_Heap_Get_free_information+0x34> 11420b: 89 0f mov %ecx,(%edi) 11420d: 89 5f 08 mov %ebx,0x8(%edi) info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 114210: 5b pop %ebx 114211: 5e pop %esi 114212: 5f pop %edi 114213: c9 leave 114214: c3 ret =============================================================================== 00110f50 <_Heap_Get_information>: void _Heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 110f50: 55 push %ebp 110f51: 89 e5 mov %esp,%ebp 110f53: 57 push %edi 110f54: 56 push %esi 110f55: 53 push %ebx 110f56: 83 ec 04 sub $0x4,%esp 110f59: 8b 45 08 mov 0x8(%ebp),%eax 110f5c: 8b 5d 0c mov 0xc(%ebp),%ebx Heap_Block *the_block = the_heap->first_block; 110f5f: 8b 50 20 mov 0x20(%eax),%edx Heap_Block *const end = the_heap->last_block; 110f62: 8b 40 24 mov 0x24(%eax),%eax 110f65: 89 45 f0 mov %eax,-0x10(%ebp) memset(the_info, 0, sizeof(*the_info)); 110f68: b9 18 00 00 00 mov $0x18,%ecx 110f6d: 31 c0 xor %eax,%eax 110f6f: 89 df mov %ebx,%edi 110f71: f3 aa rep stos %al,%es:(%edi) while ( the_block != end ) { 110f73: 3b 55 f0 cmp -0x10(%ebp),%edx 110f76: 74 38 je 110fb0 <_Heap_Get_information+0x60><== NEVER TAKEN 110f78: 8b 7a 04 mov 0x4(%edx),%edi 110f7b: eb 18 jmp 110f95 <_Heap_Get_information+0x45> 110f7d: 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; 110f80: 8d 43 0c lea 0xc(%ebx),%eax else info = &the_info->Free; info->number++; 110f83: ff 00 incl (%eax) info->total += the_size; 110f85: 01 48 08 add %ecx,0x8(%eax) if ( info->largest < the_size ) 110f88: 39 48 04 cmp %ecx,0x4(%eax) 110f8b: 73 03 jae 110f90 <_Heap_Get_information+0x40> info->largest = the_size; 110f8d: 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 ) { 110f90: 39 75 f0 cmp %esi,-0x10(%ebp) 110f93: 74 1b je 110fb0 <_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; 110f95: 89 f9 mov %edi,%ecx 110f97: 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); 110f9a: 8d 34 0a lea (%edx,%ecx,1),%esi 110f9d: 89 f2 mov %esi,%edx if ( info->largest < the_size ) info->largest = the_size; the_block = next_block; } } 110f9f: 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) ) 110fa2: f7 c7 01 00 00 00 test $0x1,%edi 110fa8: 75 d6 jne 110f80 <_Heap_Get_information+0x30> info = &the_info->Used; else info = &the_info->Free; 110faa: 89 d8 mov %ebx,%eax 110fac: eb d5 jmp 110f83 <_Heap_Get_information+0x33> 110fae: 66 90 xchg %ax,%ax if ( info->largest < the_size ) info->largest = the_size; the_block = next_block; } } 110fb0: 58 pop %eax 110fb1: 5b pop %ebx 110fb2: 5e pop %esi 110fb3: 5f pop %edi 110fb4: c9 leave 110fb5: c3 ret =============================================================================== 0011e098 <_Heap_Resize_block>: void *alloc_begin_ptr, uintptr_t new_alloc_size, uintptr_t *old_size, uintptr_t *new_size ) { 11e098: 55 push %ebp 11e099: 89 e5 mov %esp,%ebp 11e09b: 57 push %edi 11e09c: 56 push %esi 11e09d: 53 push %ebx 11e09e: 83 ec 2c sub $0x2c,%esp 11e0a1: 8b 5d 08 mov 0x8(%ebp),%ebx 11e0a4: 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); 11e0a7: 8d 4e f8 lea -0x8(%esi),%ecx 11e0aa: 89 f0 mov %esi,%eax 11e0ac: 31 d2 xor %edx,%edx 11e0ae: 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); 11e0b1: 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; 11e0b3: 8b 45 14 mov 0x14(%ebp),%eax 11e0b6: c7 00 00 00 00 00 movl $0x0,(%eax) *new_size = 0; 11e0bc: 8b 55 18 mov 0x18(%ebp),%edx 11e0bf: 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; 11e0c5: 39 4b 20 cmp %ecx,0x20(%ebx) 11e0c8: 77 05 ja 11e0cf <_Heap_Resize_block+0x37> 11e0ca: 39 4b 24 cmp %ecx,0x24(%ebx) 11e0cd: 73 0d jae 11e0dc <_Heap_Resize_block+0x44> new_alloc_size, old_size, new_size ); } return HEAP_RESIZE_FATAL_ERROR; 11e0cf: b8 02 00 00 00 mov $0x2,%eax } 11e0d4: 8d 65 f4 lea -0xc(%ebp),%esp 11e0d7: 5b pop %ebx 11e0d8: 5e pop %esi 11e0d9: 5f pop %edi 11e0da: c9 leave 11e0db: 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; 11e0dc: 8b 41 04 mov 0x4(%ecx),%eax 11e0df: 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; 11e0e2: 8d 3c 01 lea (%ecx,%eax,1),%edi 11e0e5: 89 7d d4 mov %edi,-0x2c(%ebp) uintptr_t alloc_size = block_end - alloc_begin + HEAP_ALLOC_BONUS; 11e0e8: 89 fa mov %edi,%edx 11e0ea: 29 f2 sub %esi,%edx 11e0ec: 83 c2 04 add $0x4,%edx 11e0ef: 89 55 e0 mov %edx,-0x20(%ebp) 11e0f2: 8b 57 04 mov 0x4(%edi),%edx 11e0f5: 83 e2 fe and $0xfffffffe,%edx 11e0f8: 89 55 d0 mov %edx,-0x30(%ebp) RTEMS_INLINE_ROUTINE bool _Heap_Is_free( const Heap_Block *block ) { return !_Heap_Is_used( block ); 11e0fb: f6 44 17 04 01 testb $0x1,0x4(%edi,%edx,1) 11e100: 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; 11e104: 8b 55 e0 mov -0x20(%ebp),%edx 11e107: 8b 7d 14 mov 0x14(%ebp),%edi 11e10a: 89 17 mov %edx,(%edi) if ( next_block_is_free ) { 11e10c: 80 7d df 00 cmpb $0x0,-0x21(%ebp) 11e110: 75 6e jne 11e180 <_Heap_Resize_block+0xe8> block_size += next_block_size; alloc_size += next_block_size; } if ( new_alloc_size > alloc_size ) { 11e112: 8b 55 e0 mov -0x20(%ebp),%edx 11e115: 39 55 10 cmp %edx,0x10(%ebp) 11e118: 77 79 ja 11e193 <_Heap_Resize_block+0xfb> return HEAP_RESIZE_UNSATISFIED; } if ( next_block_is_free ) { 11e11a: 80 7d df 00 cmpb $0x0,-0x21(%ebp) 11e11e: 74 31 je 11e151 <_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; 11e120: 8b 79 04 mov 0x4(%ecx),%edi 11e123: 83 e7 01 and $0x1,%edi block->size_and_flag = size | flag; 11e126: 09 c7 or %eax,%edi 11e128: 89 79 04 mov %edi,0x4(%ecx) old_size, new_size ); } return HEAP_RESIZE_FATAL_ERROR; } 11e12b: 8b 7d d4 mov -0x2c(%ebp),%edi 11e12e: 8b 7f 08 mov 0x8(%edi),%edi 11e131: 89 7d e4 mov %edi,-0x1c(%ebp) 11e134: 8b 55 d4 mov -0x2c(%ebp),%edx 11e137: 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; 11e13a: 8b 55 e4 mov -0x1c(%ebp),%edx 11e13d: 89 57 08 mov %edx,0x8(%edi) next->prev = prev; 11e140: 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; 11e143: 83 4c 01 04 01 orl $0x1,0x4(%ecx,%eax,1) /* Statistics */ --stats->free_blocks; 11e148: ff 4b 38 decl 0x38(%ebx) stats->free_size -= next_block_size; 11e14b: 8b 7d d0 mov -0x30(%ebp),%edi 11e14e: 29 7b 30 sub %edi,0x30(%ebx) } block = _Heap_Block_allocate( heap, block, alloc_begin, new_alloc_size ); 11e151: ff 75 10 pushl 0x10(%ebp) 11e154: 56 push %esi 11e155: 51 push %ecx 11e156: 53 push %ebx 11e157: e8 18 da fe ff call 10bb74 <_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; 11e15c: 8b 50 04 mov 0x4(%eax),%edx 11e15f: 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; 11e162: 29 f0 sub %esi,%eax 11e164: 8d 44 10 04 lea 0x4(%eax,%edx,1),%eax 11e168: 8b 55 18 mov 0x18(%ebp),%edx 11e16b: 89 02 mov %eax,(%edx) /* Statistics */ ++stats->resizes; 11e16d: ff 43 54 incl 0x54(%ebx) 11e170: 83 c4 10 add $0x10,%esp return HEAP_RESIZE_SUCCESSFUL; 11e173: 31 c0 xor %eax,%eax old_size, new_size ); } return HEAP_RESIZE_FATAL_ERROR; } 11e175: 8d 65 f4 lea -0xc(%ebp),%esp 11e178: 5b pop %ebx 11e179: 5e pop %esi 11e17a: 5f pop %edi 11e17b: c9 leave 11e17c: c3 ret 11e17d: 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; 11e180: 03 45 d0 add -0x30(%ebp),%eax alloc_size += next_block_size; 11e183: 8b 7d d0 mov -0x30(%ebp),%edi 11e186: 01 fa add %edi,%edx 11e188: 89 55 e0 mov %edx,-0x20(%ebp) } if ( new_alloc_size > alloc_size ) { 11e18b: 8b 55 e0 mov -0x20(%ebp),%edx 11e18e: 39 55 10 cmp %edx,0x10(%ebp) 11e191: 76 87 jbe 11e11a <_Heap_Resize_block+0x82> return HEAP_RESIZE_UNSATISFIED; 11e193: b8 01 00 00 00 mov $0x1,%eax old_size, new_size ); } return HEAP_RESIZE_FATAL_ERROR; } 11e198: 8d 65 f4 lea -0xc(%ebp),%esp 11e19b: 5b pop %ebx 11e19c: 5e pop %esi 11e19d: 5f pop %edi 11e19e: c9 leave 11e19f: c3 ret =============================================================================== 0011e1a0 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) { 11e1a0: 55 push %ebp 11e1a1: 89 e5 mov %esp,%ebp 11e1a3: 56 push %esi 11e1a4: 53 push %ebx 11e1a5: 8b 5d 08 mov 0x8(%ebp),%ebx 11e1a8: 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); 11e1ab: 8d 4e f8 lea -0x8(%esi),%ecx 11e1ae: 89 f0 mov %esi,%eax 11e1b0: 31 d2 xor %edx,%edx 11e1b2: 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); 11e1b5: 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 11e1b7: 8b 43 20 mov 0x20(%ebx),%eax && (uintptr_t) block <= (uintptr_t) heap->last_block; 11e1ba: 39 c1 cmp %eax,%ecx 11e1bc: 72 07 jb 11e1c5 <_Heap_Size_of_alloc_area+0x25> 11e1be: 8b 53 24 mov 0x24(%ebx),%edx 11e1c1: 39 d1 cmp %edx,%ecx 11e1c3: 76 07 jbe 11e1cc <_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; 11e1c5: 31 c0 xor %eax,%eax } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; return true; } 11e1c7: 5b pop %ebx 11e1c8: 5e pop %esi 11e1c9: c9 leave 11e1ca: c3 ret 11e1cb: 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; 11e1cc: 8b 59 04 mov 0x4(%ecx),%ebx 11e1cf: 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); 11e1d2: 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; 11e1d4: 39 c8 cmp %ecx,%eax 11e1d6: 77 ed ja 11e1c5 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN 11e1d8: 39 ca cmp %ecx,%edx 11e1da: 72 e9 jb 11e1c5 <_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 ) 11e1dc: f6 41 04 01 testb $0x1,0x4(%ecx) 11e1e0: 74 e3 je 11e1c5 <_Heap_Size_of_alloc_area+0x25><== NEVER TAKEN ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 11e1e2: 29 f1 sub %esi,%ecx 11e1e4: 8d 51 04 lea 0x4(%ecx),%edx 11e1e7: 8b 45 10 mov 0x10(%ebp),%eax 11e1ea: 89 10 mov %edx,(%eax) return true; 11e1ec: b0 01 mov $0x1,%al } 11e1ee: 5b pop %ebx 11e1ef: 5e pop %esi 11e1f0: c9 leave 11e1f1: c3 ret =============================================================================== 0010c6dc <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 10c6dc: 55 push %ebp 10c6dd: 89 e5 mov %esp,%ebp 10c6df: 57 push %edi 10c6e0: 56 push %esi 10c6e1: 53 push %ebx 10c6e2: 83 ec 4c sub $0x4c,%esp 10c6e5: 8b 5d 08 mov 0x8(%ebp),%ebx uintptr_t const page_size = heap->page_size; 10c6e8: 8b 43 10 mov 0x10(%ebx),%eax 10c6eb: 89 45 e0 mov %eax,-0x20(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10c6ee: 8b 53 14 mov 0x14(%ebx),%edx 10c6f1: 89 55 d0 mov %edx,-0x30(%ebp) Heap_Block *const first_block = heap->first_block; 10c6f4: 8b 43 20 mov 0x20(%ebx),%eax 10c6f7: 89 45 dc mov %eax,-0x24(%ebp) Heap_Block *const last_block = heap->last_block; 10c6fa: 8b 53 24 mov 0x24(%ebx),%edx 10c6fd: 89 55 cc mov %edx,-0x34(%ebp) Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 10c700: 80 7d 10 00 cmpb $0x0,0x10(%ebp) 10c704: 74 1a je 10c720 <_Heap_Walk+0x44> 10c706: c7 45 d8 94 c6 10 00 movl $0x10c694,-0x28(%ebp) if ( !_System_state_Is_up( _System_state_Get() ) ) { 10c70d: 83 3d 40 8b 12 00 03 cmpl $0x3,0x128b40 10c714: 74 1a je 10c730 <_Heap_Walk+0x54> <== ALWAYS TAKEN } block = next_block; } while ( block != first_block ); return true; 10c716: b0 01 mov $0x1,%al } 10c718: 8d 65 f4 lea -0xc(%ebp),%esp 10c71b: 5b pop %ebx 10c71c: 5e pop %esi 10c71d: 5f pop %edi 10c71e: c9 leave 10c71f: 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; 10c720: c7 45 d8 8c c6 10 00 movl $0x10c68c,-0x28(%ebp) if ( !_System_state_Is_up( _System_state_Get() ) ) { 10c727: 83 3d 40 8b 12 00 03 cmpl $0x3,0x128b40 10c72e: 75 e6 jne 10c716 <_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)( 10c730: 52 push %edx 10c731: ff 73 0c pushl 0xc(%ebx) 10c734: ff 73 08 pushl 0x8(%ebx) 10c737: ff 75 cc pushl -0x34(%ebp) 10c73a: ff 75 dc pushl -0x24(%ebp) 10c73d: ff 73 1c pushl 0x1c(%ebx) 10c740: ff 73 18 pushl 0x18(%ebx) 10c743: ff 75 d0 pushl -0x30(%ebp) 10c746: ff 75 e0 pushl -0x20(%ebp) 10c749: 68 c4 0f 12 00 push $0x120fc4 10c74e: 6a 00 push $0x0 10c750: ff 75 0c pushl 0xc(%ebp) 10c753: 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 ) { 10c756: 83 c4 30 add $0x30,%esp 10c759: 8b 45 e0 mov -0x20(%ebp),%eax 10c75c: 85 c0 test %eax,%eax 10c75e: 74 70 je 10c7d0 <_Heap_Walk+0xf4> (*printer)( source, true, "page size is zero\n" ); return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 10c760: f6 45 e0 03 testb $0x3,-0x20(%ebp) 10c764: 75 72 jne 10c7d8 <_Heap_Walk+0xfc> RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10c766: 8b 45 d0 mov -0x30(%ebp),%eax 10c769: 31 d2 xor %edx,%edx 10c76b: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 10c76e: 85 d2 test %edx,%edx 10c770: 75 72 jne 10c7e4 <_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; 10c772: 8b 45 dc mov -0x24(%ebp),%eax 10c775: 83 c0 08 add $0x8,%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10c778: 31 d2 xor %edx,%edx 10c77a: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( 10c77d: 85 d2 test %edx,%edx 10c77f: 75 6f jne 10c7f0 <_Heap_Walk+0x114> block = next_block; } while ( block != first_block ); return true; } 10c781: 8b 45 dc mov -0x24(%ebp),%eax 10c784: 8b 40 04 mov 0x4(%eax),%eax 10c787: 89 45 e4 mov %eax,-0x1c(%ebp) ); return false; } if ( !_Heap_Is_prev_used( first_block ) ) { 10c78a: a8 01 test $0x1,%al 10c78c: 0f 84 ce 02 00 00 je 10ca60 <_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; 10c792: 8b 55 cc mov -0x34(%ebp),%edx 10c795: 8b 42 04 mov 0x4(%edx),%eax 10c798: 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); 10c79b: 01 d0 add %edx,%eax ); return false; } if ( _Heap_Is_free( last_block ) ) { 10c79d: f6 40 04 01 testb $0x1,0x4(%eax) 10c7a1: 74 25 je 10c7c8 <_Heap_Walk+0xec> ); return false; } if ( 10c7a3: 39 45 dc cmp %eax,-0x24(%ebp) 10c7a6: 74 54 je 10c7fc <_Heap_Walk+0x120> _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block ) { (*printer)( 10c7a8: 51 push %ecx 10c7a9: 68 e0 10 12 00 push $0x1210e0 10c7ae: 66 90 xchg %ax,%ax return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10c7b0: 6a 01 push $0x1 10c7b2: ff 75 0c pushl 0xc(%ebp) 10c7b5: ff 55 d8 call *-0x28(%ebp) 10c7b8: 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; 10c7bb: 31 c0 xor %eax,%eax block = next_block; } while ( block != first_block ); return true; } 10c7bd: 8d 65 f4 lea -0xc(%ebp),%esp 10c7c0: 5b pop %ebx 10c7c1: 5e pop %esi 10c7c2: 5f pop %edi 10c7c3: c9 leave 10c7c4: c3 ret 10c7c5: 8d 76 00 lea 0x0(%esi),%esi return false; } if ( _Heap_Is_free( last_block ) ) { (*printer)( 10c7c8: 53 push %ebx 10c7c9: 68 7a 0f 12 00 push $0x120f7a 10c7ce: eb e0 jmp 10c7b0 <_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" ); 10c7d0: 57 push %edi 10c7d1: 68 49 0f 12 00 push $0x120f49 10c7d6: eb d8 jmp 10c7b0 <_Heap_Walk+0xd4> return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { (*printer)( 10c7d8: ff 75 e0 pushl -0x20(%ebp) 10c7db: 68 5c 0f 12 00 push $0x120f5c 10c7e0: eb ce jmp 10c7b0 <_Heap_Walk+0xd4> 10c7e2: 66 90 xchg %ax,%ax return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { (*printer)( 10c7e4: ff 75 d0 pushl -0x30(%ebp) 10c7e7: 68 58 10 12 00 push $0x121058 10c7ec: eb c2 jmp 10c7b0 <_Heap_Walk+0xd4> 10c7ee: 66 90 xchg %ax,%ax } if ( !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size ) ) { (*printer)( 10c7f0: ff 75 dc pushl -0x24(%ebp) 10c7f3: 68 7c 10 12 00 push $0x12107c 10c7f8: eb b6 jmp 10c7b0 <_Heap_Walk+0xd4> 10c7fa: 66 90 xchg %ax,%ax int source, Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; 10c7fc: 8b 43 10 mov 0x10(%ebx),%eax 10c7ff: 89 45 c8 mov %eax,-0x38(%ebp) block = next_block; } while ( block != first_block ); return true; } 10c802: 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 ) { 10c805: 39 f3 cmp %esi,%ebx 10c807: 74 65 je 10c86e <_Heap_Walk+0x192> block = next_block; } while ( block != first_block ); return true; } 10c809: 8b 43 20 mov 0x20(%ebx),%eax 10c80c: 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; 10c80f: 39 f0 cmp %esi,%eax 10c811: 0f 87 55 02 00 00 ja 10ca6c <_Heap_Walk+0x390> <== NEVER TAKEN 10c817: 8b 7b 24 mov 0x24(%ebx),%edi 10c81a: 39 f7 cmp %esi,%edi 10c81c: 0f 82 4a 02 00 00 jb 10ca6c <_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; 10c822: 8d 46 08 lea 0x8(%esi),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10c825: 31 d2 xor %edx,%edx 10c827: f7 75 c8 divl -0x38(%ebp) ); return false; } if ( 10c82a: 85 d2 test %edx,%edx 10c82c: 0f 85 71 02 00 00 jne 10caa3 <_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; 10c832: 8b 46 04 mov 0x4(%esi),%eax 10c835: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10c838: f6 44 06 04 01 testb $0x1,0x4(%esi,%eax,1) 10c83d: 0f 85 6d 02 00 00 jne 10cab0 <_Heap_Walk+0x3d4> <== NEVER TAKEN 10c843: 89 da mov %ebx,%edx 10c845: 8d 76 00 lea 0x0(%esi),%esi ); return false; } if ( free_block->prev != prev_block ) { 10c848: 8b 46 0c mov 0xc(%esi),%eax 10c84b: 39 d0 cmp %edx,%eax 10c84d: 0f 85 6a 02 00 00 jne 10cabd <_Heap_Walk+0x3e1> return false; } prev_block = free_block; free_block = free_block->next; 10c853: 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 ) { 10c856: 39 cb cmp %ecx,%ebx 10c858: 74 1a je 10c874 <_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; 10c85a: 39 4d d4 cmp %ecx,-0x2c(%ebp) 10c85d: 0f 86 7d 01 00 00 jbe 10c9e0 <_Heap_Walk+0x304> if ( !_Heap_Is_block_in_heap( heap, free_block ) ) { (*printer)( 10c863: 51 push %ecx 10c864: 68 10 11 12 00 push $0x121110 10c869: e9 42 ff ff ff jmp 10c7b0 <_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 ) { 10c86e: 8b 53 20 mov 0x20(%ebx),%edx 10c871: 89 55 d4 mov %edx,-0x2c(%ebp) ); return false; } if ( _Heap_Is_used( free_block ) ) { 10c874: 8b 7d dc mov -0x24(%ebp),%edi 10c877: 8b 45 d4 mov -0x2c(%ebp),%eax 10c87a: 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; 10c87c: 8b 4d e4 mov -0x1c(%ebp),%ecx 10c87f: 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); 10c882: 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; 10c885: 39 f0 cmp %esi,%eax 10c887: 76 23 jbe 10c8ac <_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)( 10c889: 83 ec 0c sub $0xc,%esp 10c88c: 56 push %esi 10c88d: 57 push %edi 10c88e: 68 94 11 12 00 push $0x121194 10c893: 90 nop 10c894: 6a 01 push $0x1 10c896: ff 75 0c pushl 0xc(%ebp) 10c899: ff 55 d8 call *-0x28(%ebp) "block 0x%08x: next block 0x%08x not in heap\n", block, next_block ); return false; 10c89c: 83 c4 20 add $0x20,%esp 10c89f: 31 c0 xor %eax,%eax block = next_block; } while ( block != first_block ); return true; } 10c8a1: 8d 65 f4 lea -0xc(%ebp),%esp 10c8a4: 5b pop %ebx 10c8a5: 5e pop %esi 10c8a6: 5f pop %edi 10c8a7: c9 leave 10c8a8: c3 ret 10c8a9: 8d 76 00 lea 0x0(%esi),%esi 10c8ac: 39 73 24 cmp %esi,0x24(%ebx) 10c8af: 72 d8 jb 10c889 <_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; 10c8b1: 3b 7d cc cmp -0x34(%ebp),%edi 10c8b4: 0f 95 45 d4 setne -0x2c(%ebp) RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10c8b8: 89 c8 mov %ecx,%eax 10c8ba: 31 d2 xor %edx,%edx 10c8bc: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 10c8bf: 85 d2 test %edx,%edx 10c8c1: 74 0a je 10c8cd <_Heap_Walk+0x1f1> 10c8c3: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp) 10c8c7: 0f 85 a6 01 00 00 jne 10ca73 <_Heap_Walk+0x397> ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 10c8cd: 39 4d d0 cmp %ecx,-0x30(%ebp) 10c8d0: 76 0a jbe 10c8dc <_Heap_Walk+0x200> 10c8d2: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp) 10c8d6: 0f 85 a6 01 00 00 jne 10ca82 <_Heap_Walk+0x3a6> <== ALWAYS TAKEN ); return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { 10c8dc: 39 f7 cmp %esi,%edi 10c8de: 72 0a jb 10c8ea <_Heap_Walk+0x20e> 10c8e0: 80 7d d4 00 cmpb $0x0,-0x2c(%ebp) 10c8e4: 0f 85 aa 01 00 00 jne 10ca94 <_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; 10c8ea: 8b 55 e4 mov -0x1c(%ebp),%edx 10c8ed: 83 e2 01 and $0x1,%edx ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 10c8f0: f6 46 04 01 testb $0x1,0x4(%esi) 10c8f4: 74 4e je 10c944 <_Heap_Walk+0x268> if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; } } else if (prev_used) { 10c8f6: 85 d2 test %edx,%edx 10c8f8: 74 2e je 10c928 <_Heap_Walk+0x24c> (*printer)( 10c8fa: 83 ec 0c sub $0xc,%esp 10c8fd: 51 push %ecx 10c8fe: 57 push %edi 10c8ff: 68 ab 0f 12 00 push $0x120fab 10c904: 6a 00 push $0x0 10c906: ff 75 0c pushl 0xc(%ebp) 10c909: ff 55 d8 call *-0x28(%ebp) 10c90c: 83 c4 20 add $0x20,%esp block->prev_size ); } block = next_block; } while ( block != first_block ); 10c90f: 39 75 dc cmp %esi,-0x24(%ebp) 10c912: 0f 84 fe fd ff ff je 10c716 <_Heap_Walk+0x3a> 10c918: 8b 56 04 mov 0x4(%esi),%edx 10c91b: 89 55 e4 mov %edx,-0x1c(%ebp) 10c91e: 8b 43 20 mov 0x20(%ebx),%eax 10c921: 89 f7 mov %esi,%edi 10c923: e9 54 ff ff ff jmp 10c87c <_Heap_Walk+0x1a0> "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 10c928: 83 ec 08 sub $0x8,%esp 10c92b: ff 37 pushl (%edi) 10c92d: 51 push %ecx 10c92e: 57 push %edi 10c92f: 68 f8 12 12 00 push $0x1212f8 10c934: 6a 00 push $0x0 10c936: ff 75 0c pushl 0xc(%ebp) 10c939: ff 55 d8 call *-0x28(%ebp) 10c93c: 83 c4 20 add $0x20,%esp 10c93f: eb ce jmp 10c90f <_Heap_Walk+0x233> 10c941: 8d 76 00 lea 0x0(%esi),%esi block = next_block; } while ( block != first_block ); return true; } 10c944: 8b 43 08 mov 0x8(%ebx),%eax 10c947: 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 ? 10c94a: 8b 47 08 mov 0x8(%edi),%eax 10c94d: 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)( 10c950: 39 43 0c cmp %eax,0xc(%ebx) 10c953: 0f 84 cb 00 00 00 je 10ca24 <_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)" : "") 10c959: 39 c3 cmp %eax,%ebx 10c95b: 0f 84 db 00 00 00 je 10ca3c <_Heap_Walk+0x360> 10c961: c7 45 c8 49 0e 12 00 movl $0x120e49,-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 ? 10c968: 8b 47 0c mov 0xc(%edi),%eax 10c96b: 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)( 10c96e: 39 45 b4 cmp %eax,-0x4c(%ebp) 10c971: 0f 84 b9 00 00 00 je 10ca30 <_Heap_Walk+0x354> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10c977: 39 c3 cmp %eax,%ebx 10c979: 0f 84 c9 00 00 00 je 10ca48 <_Heap_Walk+0x36c> 10c97f: b8 49 0e 12 00 mov $0x120e49,%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)( 10c984: 83 ec 0c sub $0xc,%esp 10c987: ff 75 c8 pushl -0x38(%ebp) 10c98a: ff 75 e4 pushl -0x1c(%ebp) 10c98d: 50 push %eax 10c98e: ff 75 d4 pushl -0x2c(%ebp) 10c991: 51 push %ecx 10c992: 57 push %edi 10c993: 68 54 12 12 00 push $0x121254 10c998: 6a 00 push $0x0 10c99a: ff 75 0c pushl 0xc(%ebp) 10c99d: 89 55 c4 mov %edx,-0x3c(%ebp) 10c9a0: 89 4d c0 mov %ecx,-0x40(%ebp) 10c9a3: 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 ) { 10c9a6: 8b 06 mov (%esi),%eax 10c9a8: 83 c4 30 add $0x30,%esp 10c9ab: 8b 4d c0 mov -0x40(%ebp),%ecx 10c9ae: 39 c1 cmp %eax,%ecx 10c9b0: 8b 55 c4 mov -0x3c(%ebp),%edx 10c9b3: 75 5f jne 10ca14 <_Heap_Walk+0x338> ); return false; } if ( !prev_used ) { 10c9b5: 85 d2 test %edx,%edx 10c9b7: 0f 84 97 00 00 00 je 10ca54 <_Heap_Walk+0x378> block = next_block; } while ( block != first_block ); return true; } 10c9bd: 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 ) { 10c9c0: 39 c3 cmp %eax,%ebx 10c9c2: 74 0f je 10c9d3 <_Heap_Walk+0x2f7> <== NEVER TAKEN if ( free_block == block ) { 10c9c4: 39 c7 cmp %eax,%edi 10c9c6: 0f 84 43 ff ff ff je 10c90f <_Heap_Walk+0x233> return true; } free_block = free_block->next; 10c9cc: 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 ) { 10c9cf: 39 c3 cmp %eax,%ebx 10c9d1: 75 f1 jne 10c9c4 <_Heap_Walk+0x2e8> return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10c9d3: 57 push %edi 10c9d4: 68 20 13 12 00 push $0x121320 10c9d9: e9 d2 fd ff ff jmp 10c7b0 <_Heap_Walk+0xd4> 10c9de: 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; 10c9e0: 39 f9 cmp %edi,%ecx 10c9e2: 0f 87 7b fe ff ff ja 10c863 <_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; 10c9e8: 8d 41 08 lea 0x8(%ecx),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10c9eb: 31 d2 xor %edx,%edx 10c9ed: f7 75 c8 divl -0x38(%ebp) ); return false; } if ( 10c9f0: 85 d2 test %edx,%edx 10c9f2: 0f 85 ad 00 00 00 jne 10caa5 <_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; 10c9f8: 8b 41 04 mov 0x4(%ecx),%eax 10c9fb: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10c9fe: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1) 10ca03: 0f 85 a9 00 00 00 jne 10cab2 <_Heap_Walk+0x3d6> 10ca09: 89 f2 mov %esi,%edx 10ca0b: 89 ce mov %ecx,%esi 10ca0d: e9 36 fe ff ff jmp 10c848 <_Heap_Walk+0x16c> 10ca12: 66 90 xchg %ax,%ax " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") ); if ( block_size != next_block->prev_size ) { (*printer)( 10ca14: 52 push %edx 10ca15: 56 push %esi 10ca16: 50 push %eax 10ca17: 51 push %ecx 10ca18: 57 push %edi 10ca19: 68 8c 12 12 00 push $0x12128c 10ca1e: e9 71 fe ff ff jmp 10c894 <_Heap_Walk+0x1b8> 10ca23: 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)( 10ca24: c7 45 c8 16 0f 12 00 movl $0x120f16,-0x38(%ebp) 10ca2b: e9 38 ff ff ff jmp 10c968 <_Heap_Walk+0x28c> 10ca30: b8 2f 0f 12 00 mov $0x120f2f,%eax 10ca35: e9 4a ff ff ff jmp 10c984 <_Heap_Walk+0x2a8> 10ca3a: 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)" : "") 10ca3c: c7 45 c8 25 0f 12 00 movl $0x120f25,-0x38(%ebp) 10ca43: e9 20 ff ff ff jmp 10c968 <_Heap_Walk+0x28c> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10ca48: b8 3f 0f 12 00 mov $0x120f3f,%eax 10ca4d: e9 32 ff ff ff jmp 10c984 <_Heap_Walk+0x2a8> 10ca52: 66 90 xchg %ax,%ax return false; } if ( !prev_used ) { (*printer)( 10ca54: 57 push %edi 10ca55: 68 c8 12 12 00 push $0x1212c8 10ca5a: e9 51 fd ff ff jmp 10c7b0 <_Heap_Walk+0xd4> 10ca5f: 90 nop return false; } if ( !_Heap_Is_prev_used( first_block ) ) { (*printer)( 10ca60: 56 push %esi 10ca61: 68 b0 10 12 00 push $0x1210b0 10ca66: e9 45 fd ff ff jmp 10c7b0 <_Heap_Walk+0xd4> 10ca6b: 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; 10ca6c: 89 f1 mov %esi,%ecx <== NOT EXECUTED 10ca6e: e9 f0 fd ff ff jmp 10c863 <_Heap_Walk+0x187> <== NOT EXECUTED return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { (*printer)( 10ca73: 83 ec 0c sub $0xc,%esp 10ca76: 51 push %ecx 10ca77: 57 push %edi 10ca78: 68 c4 11 12 00 push $0x1211c4 10ca7d: e9 12 fe ff ff jmp 10c894 <_Heap_Walk+0x1b8> return false; } if ( block_size < min_block_size && is_not_last_block ) { (*printer)( 10ca82: 83 ec 08 sub $0x8,%esp 10ca85: ff 75 d0 pushl -0x30(%ebp) 10ca88: 51 push %ecx 10ca89: 57 push %edi 10ca8a: 68 f4 11 12 00 push $0x1211f4 10ca8f: e9 00 fe ff ff jmp 10c894 <_Heap_Walk+0x1b8> return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { (*printer)( 10ca94: 83 ec 0c sub $0xc,%esp 10ca97: 56 push %esi 10ca98: 57 push %edi 10ca99: 68 20 12 12 00 push $0x121220 10ca9e: e9 f1 fd ff ff jmp 10c894 <_Heap_Walk+0x1b8> ); return false; } if ( 10caa3: 89 f1 mov %esi,%ecx <== NOT EXECUTED !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size ) ) { (*printer)( 10caa5: 51 push %ecx 10caa6: 68 30 11 12 00 push $0x121130 10caab: e9 00 fd ff ff jmp 10c7b0 <_Heap_Walk+0xd4> ); return false; } if ( _Heap_Is_used( free_block ) ) { 10cab0: 89 f1 mov %esi,%ecx <== NOT EXECUTED (*printer)( 10cab2: 51 push %ecx 10cab3: 68 8f 0f 12 00 push $0x120f8f 10cab8: e9 f3 fc ff ff jmp 10c7b0 <_Heap_Walk+0xd4> return false; } if ( free_block->prev != prev_block ) { (*printer)( 10cabd: 83 ec 0c sub $0xc,%esp 10cac0: 50 push %eax 10cac1: 56 push %esi 10cac2: 68 60 11 12 00 push $0x121160 10cac7: e9 c8 fd ff ff jmp 10c894 <_Heap_Walk+0x1b8> =============================================================================== 0010b294 <_IO_Initialize_all_drivers>: * * Output Parameters: NONE */ void _IO_Initialize_all_drivers( void ) { 10b294: 55 push %ebp 10b295: 89 e5 mov %esp,%ebp 10b297: 53 push %ebx 10b298: 83 ec 04 sub $0x4,%esp rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10b29b: 8b 0d 40 68 12 00 mov 0x126840,%ecx 10b2a1: 85 c9 test %ecx,%ecx 10b2a3: 74 1a je 10b2bf <_IO_Initialize_all_drivers+0x2b><== NEVER TAKEN 10b2a5: 31 db xor %ebx,%ebx 10b2a7: 90 nop (void) rtems_io_initialize( major, 0, NULL ); 10b2a8: 52 push %edx 10b2a9: 6a 00 push $0x0 10b2ab: 6a 00 push $0x0 10b2ad: 53 push %ebx 10b2ae: e8 39 4b 00 00 call 10fdec void _IO_Initialize_all_drivers( void ) { rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10b2b3: 43 inc %ebx 10b2b4: 83 c4 10 add $0x10,%esp 10b2b7: 39 1d 40 68 12 00 cmp %ebx,0x126840 10b2bd: 77 e9 ja 10b2a8 <_IO_Initialize_all_drivers+0x14> (void) rtems_io_initialize( major, 0, NULL ); } 10b2bf: 8b 5d fc mov -0x4(%ebp),%ebx 10b2c2: c9 leave 10b2c3: c3 ret =============================================================================== 0010b1fc <_IO_Manager_initialization>: * workspace. * */ void _IO_Manager_initialization(void) { 10b1fc: 55 push %ebp 10b1fd: 89 e5 mov %esp,%ebp 10b1ff: 57 push %edi 10b200: 56 push %esi 10b201: 53 push %ebx 10b202: 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; 10b205: 8b 1d 34 23 12 00 mov 0x122334,%ebx drivers_in_table = Configuration.number_of_device_drivers; 10b20b: a1 30 23 12 00 mov 0x122330,%eax 10b210: 89 45 e4 mov %eax,-0x1c(%ebp) number_of_drivers = Configuration.maximum_drivers; 10b213: 8b 35 2c 23 12 00 mov 0x12232c,%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 ) 10b219: 39 f0 cmp %esi,%eax 10b21b: 73 5f jae 10b27c <_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( 10b21d: 8d 0c 76 lea (%esi,%esi,2),%ecx 10b220: c1 e1 03 shl $0x3,%ecx 10b223: 83 ec 0c sub $0xc,%esp 10b226: 51 push %ecx 10b227: 89 4d dc mov %ecx,-0x24(%ebp) 10b22a: e8 75 2a 00 00 call 10dca4 <_Workspace_Allocate_or_fatal_error> 10b22f: 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 *) 10b231: a3 44 68 12 00 mov %eax,0x126844 _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 10b236: 89 35 40 68 12 00 mov %esi,0x126840 memset( 10b23c: 31 c0 xor %eax,%eax 10b23e: 8b 4d dc mov -0x24(%ebp),%ecx 10b241: 89 d7 mov %edx,%edi 10b243: 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++ ) 10b245: 83 c4 10 add $0x10,%esp 10b248: 8b 45 e4 mov -0x1c(%ebp),%eax 10b24b: 85 c0 test %eax,%eax 10b24d: 74 25 je 10b274 <_IO_Manager_initialization+0x78><== NEVER TAKEN 10b24f: a1 44 68 12 00 mov 0x126844,%eax 10b254: 89 45 e0 mov %eax,-0x20(%ebp) 10b257: 31 c0 xor %eax,%eax 10b259: 31 d2 xor %edx,%edx 10b25b: 90 nop _IO_Driver_address_table[index] = driver_table[index]; 10b25c: 8b 7d e0 mov -0x20(%ebp),%edi 10b25f: 01 c7 add %eax,%edi 10b261: 8d 34 03 lea (%ebx,%eax,1),%esi 10b264: b9 06 00 00 00 mov $0x6,%ecx 10b269: 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++ ) 10b26b: 42 inc %edx 10b26c: 83 c0 18 add $0x18,%eax 10b26f: 39 55 e4 cmp %edx,-0x1c(%ebp) 10b272: 77 e8 ja 10b25c <_IO_Manager_initialization+0x60> _IO_Driver_address_table[index] = driver_table[index]; } 10b274: 8d 65 f4 lea -0xc(%ebp),%esp 10b277: 5b pop %ebx 10b278: 5e pop %esi 10b279: 5f pop %edi 10b27a: c9 leave 10b27b: 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; 10b27c: 89 1d 44 68 12 00 mov %ebx,0x126844 _IO_Number_of_drivers = number_of_drivers; 10b282: 8b 45 e4 mov -0x1c(%ebp),%eax 10b285: a3 40 68 12 00 mov %eax,0x126840 sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) _IO_Driver_address_table[index] = driver_table[index]; } 10b28a: 8d 65 f4 lea -0xc(%ebp),%esp 10b28d: 5b pop %ebx 10b28e: 5e pop %esi 10b28f: 5f pop %edi 10b290: c9 leave 10b291: c3 ret =============================================================================== 0010bc68 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10bc68: 55 push %ebp 10bc69: 89 e5 mov %esp,%ebp 10bc6b: 53 push %ebx 10bc6c: 83 ec 08 sub $0x8,%esp 10bc6f: 8b 45 08 mov 0x8(%ebp),%eax 10bc72: 8b 55 0c mov 0xc(%ebp),%edx 10bc75: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10bc78: a3 94 65 12 00 mov %eax,0x126594 _Internal_errors_What_happened.is_internal = is_internal; 10bc7d: 88 15 98 65 12 00 mov %dl,0x126598 _Internal_errors_What_happened.the_error = the_error; 10bc83: 89 1d 9c 65 12 00 mov %ebx,0x12659c _User_extensions_Fatal( the_source, is_internal, the_error ); 10bc89: 53 push %ebx 10bc8a: 0f b6 d2 movzbl %dl,%edx 10bc8d: 52 push %edx 10bc8e: 50 push %eax 10bc8f: e8 10 1c 00 00 call 10d8a4 <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 10bc94: c7 05 80 66 12 00 05 movl $0x5,0x126680 <== NOT EXECUTED 10bc9b: 00 00 00 _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10bc9e: fa cli <== NOT EXECUTED 10bc9f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bca1: f4 hlt <== NOT EXECUTED 10bca2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bca5: eb fe jmp 10bca5 <_Internal_error_Occurred+0x3d><== NOT EXECUTED =============================================================================== 00110598 <_Objects_API_maximum_class>: #include unsigned int _Objects_API_maximum_class( uint32_t api ) { 110598: 55 push %ebp 110599: 89 e5 mov %esp,%ebp 11059b: 8b 45 08 mov 0x8(%ebp),%eax 11059e: 48 dec %eax 11059f: 83 f8 02 cmp $0x2,%eax 1105a2: 77 0c ja 1105b0 <_Objects_API_maximum_class+0x18> 1105a4: 8b 04 85 30 04 12 00 mov 0x120430(,%eax,4),%eax case OBJECTS_NO_API: default: break; } return 0; } 1105ab: c9 leave 1105ac: c3 ret 1105ad: 8d 76 00 lea 0x0(%esi),%esi #include unsigned int _Objects_API_maximum_class( uint32_t api ) { 1105b0: 31 c0 xor %eax,%eax case OBJECTS_NO_API: default: break; } return 0; } 1105b2: c9 leave 1105b3: c3 ret =============================================================================== 0010bcf8 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10bcf8: 55 push %ebp 10bcf9: 89 e5 mov %esp,%ebp 10bcfb: 56 push %esi 10bcfc: 53 push %ebx 10bcfd: 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 ) 10bd00: 8b 43 18 mov 0x18(%ebx),%eax 10bd03: 85 c0 test %eax,%eax 10bd05: 75 0d jne 10bd14 <_Objects_Allocate+0x1c><== ALWAYS TAKEN return NULL; 10bd07: 31 c9 xor %ecx,%ecx <== NOT EXECUTED ); } #endif return the_object; } 10bd09: 89 c8 mov %ecx,%eax 10bd0b: 8d 65 f8 lea -0x8(%ebp),%esp 10bd0e: 5b pop %ebx 10bd0f: 5e pop %esi 10bd10: c9 leave 10bd11: c3 ret 10bd12: 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 ); 10bd14: 8d 73 20 lea 0x20(%ebx),%esi 10bd17: 83 ec 0c sub $0xc,%esp 10bd1a: 56 push %esi 10bd1b: e8 a0 f7 ff ff call 10b4c0 <_Chain_Get> 10bd20: 89 c1 mov %eax,%ecx if ( information->auto_extend ) { 10bd22: 83 c4 10 add $0x10,%esp 10bd25: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10bd29: 74 de je 10bd09 <_Objects_Allocate+0x11> /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10bd2b: 85 c0 test %eax,%eax 10bd2d: 74 29 je 10bd58 <_Objects_Allocate+0x60> } if ( the_object ) { uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 10bd2f: 0f b7 41 08 movzwl 0x8(%ecx),%eax 10bd33: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10bd37: 29 d0 sub %edx,%eax _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; 10bd39: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10bd3d: 31 d2 xor %edx,%edx 10bd3f: f7 f6 div %esi information->inactive_per_block[ block ]--; 10bd41: c1 e0 02 shl $0x2,%eax 10bd44: 03 43 30 add 0x30(%ebx),%eax 10bd47: ff 08 decl (%eax) information->inactive--; 10bd49: 66 ff 4b 2c decw 0x2c(%ebx) ); } #endif return the_object; } 10bd4d: 89 c8 mov %ecx,%eax 10bd4f: 8d 65 f8 lea -0x8(%ebp),%esp 10bd52: 5b pop %ebx 10bd53: 5e pop %esi 10bd54: c9 leave 10bd55: c3 ret 10bd56: 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 ); 10bd58: 83 ec 0c sub $0xc,%esp 10bd5b: 53 push %ebx 10bd5c: e8 3b 00 00 00 call 10bd9c <_Objects_Extend_information> the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10bd61: 89 34 24 mov %esi,(%esp) 10bd64: e8 57 f7 ff ff call 10b4c0 <_Chain_Get> 10bd69: 89 c1 mov %eax,%ecx } if ( the_object ) { 10bd6b: 83 c4 10 add $0x10,%esp 10bd6e: 85 c0 test %eax,%eax 10bd70: 74 97 je 10bd09 <_Objects_Allocate+0x11> 10bd72: eb bb jmp 10bd2f <_Objects_Allocate+0x37> =============================================================================== 0010bd9c <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 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 4c sub $0x4c,%esp 10bda5: 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 ); 10bda8: 0f b7 43 08 movzwl 0x8(%ebx),%eax 10bdac: 89 45 cc mov %eax,-0x34(%ebp) index_base = minimum_index; block = 0; /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) 10bdaf: 8b 4b 34 mov 0x34(%ebx),%ecx 10bdb2: 85 c9 test %ecx,%ecx 10bdb4: 0f 84 62 02 00 00 je 10c01c <_Objects_Extend_information+0x280> block_count = 0; else { block_count = information->maximum / information->allocation_size; 10bdba: 8b 73 10 mov 0x10(%ebx),%esi 10bdbd: 66 89 75 d0 mov %si,-0x30(%ebp) 10bdc1: 8b 7b 14 mov 0x14(%ebx),%edi 10bdc4: 89 f0 mov %esi,%eax 10bdc6: 31 d2 xor %edx,%edx 10bdc8: 66 f7 f7 div %di 10bdcb: 0f b7 f0 movzwl %ax,%esi for ( ; block < block_count; block++ ) { 10bdce: 85 f6 test %esi,%esi 10bdd0: 0f 84 5f 02 00 00 je 10c035 <_Objects_Extend_information+0x299><== NEVER TAKEN if ( information->object_blocks[ block ] == NULL ) { 10bdd6: 8b 01 mov (%ecx),%eax 10bdd8: 85 c0 test %eax,%eax 10bdda: 0f 84 67 02 00 00 je 10c047 <_Objects_Extend_information+0x2ab><== NEVER TAKEN 10bde0: 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 ); 10bde3: 8b 55 cc mov -0x34(%ebp),%edx 10bde6: 89 55 d4 mov %edx,-0x2c(%ebp) index_base = minimum_index; block = 0; 10bde9: 31 d2 xor %edx,%edx 10bdeb: 8b 45 d4 mov -0x2c(%ebp),%eax 10bdee: eb 0a jmp 10bdfa <_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 ) { 10bdf0: 83 3c 91 00 cmpl $0x0,(%ecx,%edx,4) 10bdf4: 0f 84 c2 01 00 00 je 10bfbc <_Objects_Extend_information+0x220> do_extend = false; break; } else index_base += information->allocation_size; 10bdfa: 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++ ) { 10bdfc: 42 inc %edx 10bdfd: 39 d6 cmp %edx,%esi 10bdff: 77 ef ja 10bdf0 <_Objects_Extend_information+0x54> 10be01: 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; 10be04: b1 01 mov $0x1,%cl } else index_base += information->allocation_size; } } maximum = (uint32_t) information->maximum + information->allocation_size; 10be06: 0f b7 45 d0 movzwl -0x30(%ebp),%eax 10be0a: 01 f8 add %edi,%eax 10be0c: 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 ) { 10be0f: 3d ff ff 00 00 cmp $0xffff,%eax 10be14: 0f 87 9a 01 00 00 ja 10bfb4 <_Objects_Extend_information+0x218> /* * 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; 10be1a: 0f af 7b 18 imul 0x18(%ebx),%edi if ( information->auto_extend ) { 10be1e: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10be22: 0f 84 a0 01 00 00 je 10bfc8 <_Objects_Extend_information+0x22c> new_object_block = _Workspace_Allocate( block_size ); 10be28: 83 ec 0c sub $0xc,%esp 10be2b: 57 push %edi 10be2c: 89 55 b8 mov %edx,-0x48(%ebp) 10be2f: 88 4d b4 mov %cl,-0x4c(%ebp) 10be32: e8 39 1e 00 00 call 10dc70 <_Workspace_Allocate> 10be37: 89 45 c8 mov %eax,-0x38(%ebp) if ( !new_object_block ) 10be3a: 83 c4 10 add $0x10,%esp 10be3d: 85 c0 test %eax,%eax 10be3f: 8b 55 b8 mov -0x48(%ebp),%edx 10be42: 8a 4d b4 mov -0x4c(%ebp),%cl 10be45: 0f 84 69 01 00 00 je 10bfb4 <_Objects_Extend_information+0x218> } /* * Do we need to grow the tables? */ if ( do_extend ) { 10be4b: 84 c9 test %cl,%cl 10be4d: 0f 84 e6 00 00 00 je 10bf39 <_Objects_Extend_information+0x19d> */ /* * Up the block count and maximum */ block_count++; 10be53: 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 ); 10be56: 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 *)) + 10be59: 8d 04 7f lea (%edi,%edi,2),%eax ((maximum + minimum_index) * sizeof(Objects_Control *)); 10be5c: 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 *)) + 10be5f: 03 45 cc add -0x34(%ebp),%eax block_count++; /* * Allocate the tables and break it up. */ block_size = block_count * 10be62: 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 ); 10be65: 50 push %eax 10be66: 89 55 b8 mov %edx,-0x48(%ebp) 10be69: e8 02 1e 00 00 call 10dc70 <_Workspace_Allocate> 10be6e: 89 45 c4 mov %eax,-0x3c(%ebp) if ( !object_blocks ) { 10be71: 83 c4 10 add $0x10,%esp 10be74: 85 c0 test %eax,%eax 10be76: 8b 55 b8 mov -0x48(%ebp),%edx 10be79: 0f 84 da 01 00 00 je 10c059 <_Objects_Extend_information+0x2bd> 10be7f: 8b 45 c4 mov -0x3c(%ebp),%eax 10be82: 8d 04 b8 lea (%eax,%edi,4),%eax 10be85: 89 45 bc mov %eax,-0x44(%ebp) 10be88: 8b 4d c4 mov -0x3c(%ebp),%ecx 10be8b: 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 ) { 10be8e: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10be92: 39 4d cc cmp %ecx,-0x34(%ebp) 10be95: 0f 82 4d 01 00 00 jb 10bfe8 <_Objects_Extend_information+0x24c> } else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10be9b: 8b 4d cc mov -0x34(%ebp),%ecx 10be9e: 85 c9 test %ecx,%ecx 10bea0: 74 12 je 10beb4 <_Objects_Extend_information+0x118><== NEVER TAKEN 10bea2: 31 c9 xor %ecx,%ecx 10bea4: 8b 7d cc mov -0x34(%ebp),%edi 10bea7: 90 nop local_table[ index ] = NULL; 10bea8: 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++ ) { 10beaf: 41 inc %ecx 10beb0: 39 cf cmp %ecx,%edi 10beb2: 77 f4 ja 10bea8 <_Objects_Extend_information+0x10c><== NEVER TAKEN 10beb4: c1 e6 02 shl $0x2,%esi 10beb7: 89 75 c0 mov %esi,-0x40(%ebp) } /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 10beba: 8b 4d c4 mov -0x3c(%ebp),%ecx 10bebd: 8b 75 c0 mov -0x40(%ebp),%esi 10bec0: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1) inactive_per_block[block_count] = 0; 10bec7: 8b 4d bc mov -0x44(%ebp),%ecx 10beca: c7 04 31 00 00 00 00 movl $0x0,(%ecx,%esi,1) for ( index=index_base ; index < ( information->allocation_size + index_base ); 10bed1: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10bed5: 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 ; 10bed8: 39 75 d4 cmp %esi,-0x2c(%ebp) 10bedb: 73 0f jae 10beec <_Objects_Extend_information+0x150><== NEVER TAKEN 10bedd: 8b 4d d4 mov -0x2c(%ebp),%ecx index < ( information->allocation_size + index_base ); index++ ) { local_table[ index ] = NULL; 10bee0: 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++ ) { 10bee7: 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 ; 10bee8: 39 f1 cmp %esi,%ecx 10beea: 72 f4 jb 10bee0 <_Objects_Extend_information+0x144> index < ( information->allocation_size + index_base ); index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 10beec: 9c pushf 10beed: fa cli 10beee: 5f pop %edi old_tables = information->object_blocks; 10beef: 8b 73 34 mov 0x34(%ebx),%esi information->object_blocks = object_blocks; 10bef2: 8b 4d c4 mov -0x3c(%ebp),%ecx 10bef5: 89 4b 34 mov %ecx,0x34(%ebx) information->inactive_per_block = inactive_per_block; 10bef8: 8b 4d bc mov -0x44(%ebp),%ecx 10befb: 89 4b 30 mov %ecx,0x30(%ebx) information->local_table = local_table; 10befe: 89 43 1c mov %eax,0x1c(%ebx) information->maximum = (Objects_Maximum) maximum; 10bf01: 8b 45 d0 mov -0x30(%ebp),%eax 10bf04: 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) | 10bf08: 8b 0b mov (%ebx),%ecx 10bf0a: c1 e1 18 shl $0x18,%ecx 10bf0d: 81 c9 00 00 01 00 or $0x10000,%ecx information->maximum_id = _Objects_Build_id( 10bf13: 0f b7 43 04 movzwl 0x4(%ebx),%eax (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 10bf17: c1 e0 1b shl $0x1b,%eax 10bf1a: 09 c1 or %eax,%ecx 10bf1c: 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) | 10bf20: 09 c1 or %eax,%ecx 10bf22: 89 4b 0c mov %ecx,0xc(%ebx) information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 10bf25: 57 push %edi 10bf26: 9d popf _Workspace_Free( old_tables ); 10bf27: 83 ec 0c sub $0xc,%esp 10bf2a: 56 push %esi 10bf2b: 89 55 b8 mov %edx,-0x48(%ebp) 10bf2e: e8 59 1d 00 00 call 10dc8c <_Workspace_Free> 10bf33: 83 c4 10 add $0x10,%esp 10bf36: 8b 55 b8 mov -0x48(%ebp),%edx } /* * Assign the new object block to the object block table. */ information->object_blocks[ block ] = new_object_block; 10bf39: c1 e2 02 shl $0x2,%edx 10bf3c: 89 55 d0 mov %edx,-0x30(%ebp) 10bf3f: 8b 43 34 mov 0x34(%ebx),%eax 10bf42: 8b 4d c8 mov -0x38(%ebp),%ecx 10bf45: 89 0c 10 mov %ecx,(%eax,%edx,1) /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 10bf48: ff 73 18 pushl 0x18(%ebx) 10bf4b: 0f b7 43 14 movzwl 0x14(%ebx),%eax 10bf4f: 50 push %eax 10bf50: 51 push %ecx 10bf51: 8d 7d dc lea -0x24(%ebp),%edi 10bf54: 57 push %edi 10bf55: e8 d2 3e 00 00 call 10fe2c <_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 ) { 10bf5a: 83 c4 10 add $0x10,%esp 10bf5d: 8b 75 d4 mov -0x2c(%ebp),%esi information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10bf60: 8d 43 20 lea 0x20(%ebx),%eax 10bf63: 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 ) { 10bf66: eb 29 jmp 10bf91 <_Objects_Extend_information+0x1f5> 10bf68: 8b 13 mov (%ebx),%edx 10bf6a: c1 e2 18 shl $0x18,%edx 10bf6d: 81 ca 00 00 01 00 or $0x10000,%edx the_object->id = _Objects_Build_id( 10bf73: 0f b7 4b 04 movzwl 0x4(%ebx),%ecx (( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) | 10bf77: c1 e1 1b shl $0x1b,%ecx 10bf7a: 09 ca or %ecx,%edx uint32_t the_class, uint32_t node, uint32_t index ) { return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) | 10bf7c: 09 f2 or %esi,%edx 10bf7e: 89 50 08 mov %edx,0x8(%eax) information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10bf81: 83 ec 08 sub $0x8,%esp 10bf84: 50 push %eax 10bf85: ff 75 d4 pushl -0x2c(%ebp) 10bf88: e8 f7 f4 ff ff call 10b484 <_Chain_Append> index++; 10bf8d: 46 inc %esi 10bf8e: 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 ) { 10bf91: 83 ec 0c sub $0xc,%esp 10bf94: 57 push %edi 10bf95: e8 26 f5 ff ff call 10b4c0 <_Chain_Get> 10bf9a: 83 c4 10 add $0x10,%esp 10bf9d: 85 c0 test %eax,%eax 10bf9f: 75 c7 jne 10bf68 <_Objects_Extend_information+0x1cc> _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 10bfa1: 8b 43 14 mov 0x14(%ebx),%eax 10bfa4: 8b 53 30 mov 0x30(%ebx),%edx 10bfa7: 0f b7 c8 movzwl %ax,%ecx 10bfaa: 8b 75 d0 mov -0x30(%ebp),%esi 10bfad: 89 0c 32 mov %ecx,(%edx,%esi,1) information->inactive = (Objects_Maximum)(information->inactive + information->allocation_size); 10bfb0: 66 01 43 2c add %ax,0x2c(%ebx) } 10bfb4: 8d 65 f4 lea -0xc(%ebp),%esp 10bfb7: 5b pop %ebx 10bfb8: 5e pop %esi 10bfb9: 5f pop %edi 10bfba: c9 leave 10bfbb: c3 ret 10bfbc: 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; 10bfbf: 31 c9 xor %ecx,%ecx 10bfc1: e9 40 fe ff ff jmp 10be06 <_Objects_Extend_information+0x6a> 10bfc6: 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 ); 10bfc8: 83 ec 0c sub $0xc,%esp 10bfcb: 57 push %edi 10bfcc: 89 55 b8 mov %edx,-0x48(%ebp) 10bfcf: 88 4d b4 mov %cl,-0x4c(%ebp) 10bfd2: e8 cd 1c 00 00 call 10dca4 <_Workspace_Allocate_or_fatal_error> 10bfd7: 89 45 c8 mov %eax,-0x38(%ebp) 10bfda: 83 c4 10 add $0x10,%esp 10bfdd: 8a 4d b4 mov -0x4c(%ebp),%cl 10bfe0: 8b 55 b8 mov -0x48(%ebp),%edx 10bfe3: e9 63 fe ff ff jmp 10be4b <_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, 10bfe8: c1 e6 02 shl $0x2,%esi 10bfeb: 89 75 c0 mov %esi,-0x40(%ebp) 10bfee: 8b 73 34 mov 0x34(%ebx),%esi 10bff1: 8b 7d c4 mov -0x3c(%ebp),%edi 10bff4: 8b 4d c0 mov -0x40(%ebp),%ecx 10bff7: f3 a4 rep movsb %ds:(%esi),%es:(%edi) information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 10bff9: 8b 73 30 mov 0x30(%ebx),%esi 10bffc: 8b 7d bc mov -0x44(%ebp),%edi 10bfff: 8b 4d c0 mov -0x40(%ebp),%ecx 10c002: 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 *) ); 10c004: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10c008: 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, 10c00b: c1 e1 02 shl $0x2,%ecx 10c00e: 8b 73 1c mov 0x1c(%ebx),%esi 10c011: 89 c7 mov %eax,%edi 10c013: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10c015: e9 a0 fe ff ff jmp 10beba <_Objects_Extend_information+0x11e> 10c01a: 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 ) 10c01c: 8b 53 10 mov 0x10(%ebx),%edx 10c01f: 66 89 55 d0 mov %dx,-0x30(%ebp) 10c023: 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 ); 10c027: 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; 10c02a: b1 01 mov $0x1,%cl minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 10c02c: 31 d2 xor %edx,%edx /* if ( information->maximum < minimum_index ) */ if ( information->object_blocks == NULL ) block_count = 0; 10c02e: 31 f6 xor %esi,%esi 10c030: e9 d1 fd ff ff jmp 10be06 <_Objects_Extend_information+0x6a> else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10c035: 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 ); 10c038: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10c03b: 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; 10c03e: b1 01 mov $0x1,%cl <== NOT EXECUTED minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; 10c040: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c042: e9 bf fd ff ff jmp 10be06 <_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 ) { 10c047: 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 ); 10c04a: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED 10c04d: 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; 10c050: 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; 10c052: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c054: e9 ad fd ff ff jmp 10be06 <_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 ); 10c059: 83 ec 0c sub $0xc,%esp 10c05c: ff 75 c8 pushl -0x38(%ebp) 10c05f: e8 28 1c 00 00 call 10dc8c <_Workspace_Free> return; 10c064: 83 c4 10 add $0x10,%esp 10c067: e9 48 ff ff ff jmp 10bfb4 <_Objects_Extend_information+0x218> =============================================================================== 0010c0fc <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 10c0fc: 55 push %ebp 10c0fd: 89 e5 mov %esp,%ebp 10c0ff: 56 push %esi 10c100: 53 push %ebx 10c101: 8b 75 08 mov 0x8(%ebp),%esi 10c104: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 10c107: 66 85 db test %bx,%bx 10c10a: 75 0c jne 10c118 <_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; 10c10c: 31 c0 xor %eax,%eax if ( info->maximum == 0 ) return NULL; #endif return info; } 10c10e: 8d 65 f8 lea -0x8(%ebp),%esp 10c111: 5b pop %ebx 10c112: 5e pop %esi 10c113: c9 leave 10c114: c3 ret 10c115: 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 ); 10c118: 83 ec 0c sub $0xc,%esp 10c11b: 56 push %esi 10c11c: e8 77 44 00 00 call 110598 <_Objects_API_maximum_class> if ( the_class_api_maximum == 0 ) 10c121: 83 c4 10 add $0x10,%esp 10c124: 85 c0 test %eax,%eax 10c126: 74 e4 je 10c10c <_Objects_Get_information+0x10> return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 10c128: 0f b7 db movzwl %bx,%ebx 10c12b: 39 d8 cmp %ebx,%eax 10c12d: 72 dd jb 10c10c <_Objects_Get_information+0x10> return NULL; if ( !_Objects_Information_table[ the_api ] ) 10c12f: 8b 14 b5 c4 64 12 00 mov 0x1264c4(,%esi,4),%edx return NULL; 10c136: 31 c0 xor %eax,%eax return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) return NULL; if ( !_Objects_Information_table[ the_api ] ) 10c138: 85 d2 test %edx,%edx 10c13a: 74 d2 je 10c10e <_Objects_Get_information+0x12><== NEVER TAKEN return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10c13c: 8b 04 9a mov (%edx,%ebx,4),%eax if ( !info ) 10c13f: 85 c0 test %eax,%eax 10c141: 74 cb je 10c10e <_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; 10c143: 31 d2 xor %edx,%edx 10c145: 66 83 78 10 00 cmpw $0x0,0x10(%eax) 10c14a: 0f 95 c2 setne %dl 10c14d: f7 da neg %edx 10c14f: 21 d0 and %edx,%eax 10c151: eb bb jmp 10c10e <_Objects_Get_information+0x12> =============================================================================== 0010c154 <_Objects_Get_isr_disable>: Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 10c154: 55 push %ebp 10c155: 89 e5 mov %esp,%ebp 10c157: 56 push %esi 10c158: 53 push %ebx 10c159: 8b 55 08 mov 0x8(%ebp),%edx 10c15c: 8b 5d 10 mov 0x10(%ebp),%ebx Objects_Control *the_object; uint32_t index; ISR_Level level; index = id - information->minimum_id + 1; 10c15f: b8 01 00 00 00 mov $0x1,%eax 10c164: 2b 42 08 sub 0x8(%edx),%eax 10c167: 03 45 0c add 0xc(%ebp),%eax _ISR_Disable( level ); 10c16a: 9c pushf 10c16b: fa cli 10c16c: 5e pop %esi if ( information->maximum >= index ) { 10c16d: 0f b7 4a 10 movzwl 0x10(%edx),%ecx 10c171: 39 c8 cmp %ecx,%eax 10c173: 77 1b ja 10c190 <_Objects_Get_isr_disable+0x3c> if ( (the_object = information->local_table[ index ]) != NULL ) { 10c175: 8b 52 1c mov 0x1c(%edx),%edx 10c178: 8b 04 82 mov (%edx,%eax,4),%eax 10c17b: 85 c0 test %eax,%eax 10c17d: 74 21 je 10c1a0 <_Objects_Get_isr_disable+0x4c><== NEVER TAKEN *location = OBJECTS_LOCAL; 10c17f: c7 03 00 00 00 00 movl $0x0,(%ebx) *level_p = level; 10c185: 8b 55 14 mov 0x14(%ebp),%edx 10c188: 89 32 mov %esi,(%edx) _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10c18a: 5b pop %ebx 10c18b: 5e pop %esi 10c18c: c9 leave 10c18d: c3 ret 10c18e: 66 90 xchg %ax,%ax } _ISR_Enable( level ); *location = OBJECTS_ERROR; return NULL; } _ISR_Enable( level ); 10c190: 56 push %esi 10c191: 9d popf *location = OBJECTS_ERROR; 10c192: 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; 10c198: 31 c0 xor %eax,%eax #endif } 10c19a: 5b pop %ebx 10c19b: 5e pop %esi 10c19c: c9 leave 10c19d: c3 ret 10c19e: 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 ); 10c1a0: 56 push %esi 10c1a1: 9d popf *location = OBJECTS_ERROR; 10c1a2: c7 03 01 00 00 00 movl $0x1,(%ebx) return NULL; 10c1a8: eb e0 jmp 10c18a <_Objects_Get_isr_disable+0x36> =============================================================================== 0010d874 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 10d874: 55 push %ebp 10d875: 89 e5 mov %esp,%ebp 10d877: 57 push %edi 10d878: 56 push %esi 10d879: 53 push %ebx 10d87a: 83 ec 3c sub $0x3c,%esp 10d87d: 8b 7d 08 mov 0x8(%ebp),%edi 10d880: 8b 75 0c mov 0xc(%ebp),%esi 10d883: 8b 5d 10 mov 0x10(%ebp),%ebx char lname[5]; Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) 10d886: 85 f6 test %esi,%esi 10d888: 75 0e jne 10d898 <_Objects_Get_name_as_string+0x24> #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* not supported */ #endif case OBJECTS_ERROR: return NULL; 10d88a: 31 db xor %ebx,%ebx _Thread_Enable_dispatch(); return name; } return NULL; /* unreachable path */ } 10d88c: 89 d8 mov %ebx,%eax 10d88e: 8d 65 f4 lea -0xc(%ebp),%esp 10d891: 5b pop %ebx 10d892: 5e pop %esi 10d893: 5f pop %edi 10d894: c9 leave 10d895: c3 ret 10d896: 66 90 xchg %ax,%ax Objects_Id tmpId; if ( length == 0 ) return NULL; if ( name == NULL ) 10d898: 85 db test %ebx,%ebx 10d89a: 74 f0 je 10d88c <_Objects_Get_name_as_string+0x18> return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10d89c: 85 ff test %edi,%edi 10d89e: 75 08 jne 10d8a8 <_Objects_Get_name_as_string+0x34> 10d8a0: a1 98 9b 12 00 mov 0x129b98,%eax 10d8a5: 8b 78 08 mov 0x8(%eax),%edi information = _Objects_Get_information_id( tmpId ); 10d8a8: 83 ec 0c sub $0xc,%esp 10d8ab: 57 push %edi 10d8ac: e8 f3 fe ff ff call 10d7a4 <_Objects_Get_information_id> if ( !information ) 10d8b1: 83 c4 10 add $0x10,%esp 10d8b4: 85 c0 test %eax,%eax 10d8b6: 74 d2 je 10d88a <_Objects_Get_name_as_string+0x16> return NULL; the_object = _Objects_Get( information, tmpId, &location ); 10d8b8: 51 push %ecx 10d8b9: 8d 55 e4 lea -0x1c(%ebp),%edx 10d8bc: 52 push %edx 10d8bd: 57 push %edi 10d8be: 50 push %eax 10d8bf: e8 80 00 00 00 call 10d944 <_Objects_Get> switch ( location ) { 10d8c4: 83 c4 10 add $0x10,%esp 10d8c7: 8b 55 e4 mov -0x1c(%ebp),%edx 10d8ca: 85 d2 test %edx,%edx 10d8cc: 75 bc jne 10d88a <_Objects_Get_name_as_string+0x16> if ( information->is_string ) { s = the_object->name.name_p; } else #endif { uint32_t u32_name = (uint32_t) the_object->name.name_u32; 10d8ce: 8b 40 0c mov 0xc(%eax),%eax lname[ 0 ] = (u32_name >> 24) & 0xff; 10d8d1: 89 c2 mov %eax,%edx 10d8d3: c1 ea 18 shr $0x18,%edx 10d8d6: 88 55 c7 mov %dl,-0x39(%ebp) 10d8d9: 88 55 df mov %dl,-0x21(%ebp) lname[ 1 ] = (u32_name >> 16) & 0xff; 10d8dc: 89 c7 mov %eax,%edi 10d8de: c1 ef 10 shr $0x10,%edi 10d8e1: 89 f9 mov %edi,%ecx 10d8e3: 88 4d e0 mov %cl,-0x20(%ebp) lname[ 2 ] = (u32_name >> 8) & 0xff; 10d8e6: 89 c7 mov %eax,%edi 10d8e8: c1 ef 08 shr $0x8,%edi 10d8eb: 89 f9 mov %edi,%ecx 10d8ed: 88 4d e1 mov %cl,-0x1f(%ebp) lname[ 3 ] = (u32_name >> 0) & 0xff; 10d8f0: 88 45 e2 mov %al,-0x1e(%ebp) lname[ 4 ] = '\0'; 10d8f3: c6 45 e3 00 movb $0x0,-0x1d(%ebp) s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 10d8f7: 4e dec %esi 10d8f8: 89 75 d4 mov %esi,-0x2c(%ebp) 10d8fb: 74 41 je 10d93e <_Objects_Get_name_as_string+0xca><== NEVER TAKEN 10d8fd: 84 d2 test %dl,%dl 10d8ff: 74 3d je 10d93e <_Objects_Get_name_as_string+0xca> 10d901: 89 d9 mov %ebx,%ecx 10d903: 31 c0 xor %eax,%eax 10d905: eb 09 jmp 10d910 <_Objects_Get_name_as_string+0x9c> 10d907: 90 nop 10d908: 8a 54 05 df mov -0x21(%ebp,%eax,1),%dl 10d90c: 84 d2 test %dl,%dl 10d90e: 74 21 je 10d931 <_Objects_Get_name_as_string+0xbd> *d = (isprint((unsigned char)*s)) ? *s : '*'; 10d910: 0f b6 f2 movzbl %dl,%esi 10d913: 8b 3d 28 72 12 00 mov 0x127228,%edi 10d919: 0f be 74 37 01 movsbl 0x1(%edi,%esi,1),%esi 10d91e: 81 e6 97 00 00 00 and $0x97,%esi 10d924: 75 02 jne 10d928 <_Objects_Get_name_as_string+0xb4> 10d926: b2 2a mov $0x2a,%dl 10d928: 88 11 mov %dl,(%ecx) s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 10d92a: 40 inc %eax 10d92b: 41 inc %ecx 10d92c: 3b 45 d4 cmp -0x2c(%ebp),%eax 10d92f: 72 d7 jb 10d908 <_Objects_Get_name_as_string+0x94> *d = (isprint((unsigned char)*s)) ? *s : '*'; } } *d = '\0'; 10d931: c6 01 00 movb $0x0,(%ecx) _Thread_Enable_dispatch(); 10d934: e8 e3 0a 00 00 call 10e41c <_Thread_Enable_dispatch> return name; 10d939: e9 4e ff ff ff jmp 10d88c <_Objects_Get_name_as_string+0x18> s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 10d93e: 89 d9 mov %ebx,%ecx 10d940: eb ef jmp 10d931 <_Objects_Get_name_as_string+0xbd> =============================================================================== 0010c2f4 <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 10c2f4: 55 push %ebp 10c2f5: 89 e5 mov %esp,%ebp 10c2f7: 57 push %edi 10c2f8: 56 push %esi 10c2f9: 53 push %ebx 10c2fa: 83 ec 0c sub $0xc,%esp 10c2fd: 8b 5d 08 mov 0x8(%ebp),%ebx 10c300: 8b 75 0c mov 0xc(%ebp),%esi 10c303: 8b 7d 10 mov 0x10(%ebp),%edi Objects_Control *object; Objects_Id next_id; if ( !information ) 10c306: 85 db test %ebx,%ebx 10c308: 75 0a jne 10c314 <_Objects_Get_next+0x20> if ( !location_p ) return NULL; if ( !next_id_p ) return NULL; 10c30a: 31 c0 xor %eax,%eax return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 10c30c: 8d 65 f4 lea -0xc(%ebp),%esp 10c30f: 5b pop %ebx 10c310: 5e pop %esi 10c311: 5f pop %edi 10c312: c9 leave 10c313: c3 ret Objects_Id next_id; if ( !information ) return NULL; if ( !location_p ) 10c314: 85 ff test %edi,%edi 10c316: 74 f2 je 10c30a <_Objects_Get_next+0x16> return NULL; if ( !next_id_p ) 10c318: 8b 45 14 mov 0x14(%ebp),%eax 10c31b: 85 c0 test %eax,%eax 10c31d: 74 eb je 10c30a <_Objects_Get_next+0x16> return NULL; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) 10c31f: 66 85 f6 test %si,%si 10c322: 75 04 jne 10c328 <_Objects_Get_next+0x34> next_id = information->minimum_id; 10c324: 8b 73 08 mov 0x8(%ebx),%esi 10c327: 90 nop else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 10c328: 66 39 73 10 cmp %si,0x10(%ebx) 10c32c: 72 22 jb 10c350 <_Objects_Get_next+0x5c> *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 10c32e: 51 push %ecx 10c32f: 57 push %edi 10c330: 56 push %esi 10c331: 53 push %ebx 10c332: e8 2d 00 00 00 call 10c364 <_Objects_Get> next_id++; 10c337: 46 inc %esi } while (*location_p != OBJECTS_LOCAL); 10c338: 83 c4 10 add $0x10,%esp 10c33b: 8b 17 mov (%edi),%edx 10c33d: 85 d2 test %edx,%edx 10c33f: 75 e7 jne 10c328 <_Objects_Get_next+0x34> *next_id_p = next_id; 10c341: 8b 55 14 mov 0x14(%ebp),%edx 10c344: 89 32 mov %esi,(%edx) return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 10c346: 8d 65 f4 lea -0xc(%ebp),%esp 10c349: 5b pop %ebx 10c34a: 5e pop %esi 10c34b: 5f pop %edi 10c34c: c9 leave 10c34d: c3 ret 10c34e: 66 90 xchg %ax,%ax do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) { *location_p = OBJECTS_ERROR; 10c350: c7 07 01 00 00 00 movl $0x1,(%edi) *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 10c356: 8b 45 14 mov 0x14(%ebp),%eax 10c359: c7 00 ff ff ff ff movl $0xffffffff,(%eax) return 0; 10c35f: 31 c0 xor %eax,%eax 10c361: eb a9 jmp 10c30c <_Objects_Get_next+0x18> =============================================================================== 0011a788 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 11a788: 55 push %ebp 11a789: 89 e5 mov %esp,%ebp 11a78b: 53 push %ebx 11a78c: 8b 55 08 mov 0x8(%ebp),%edx 11a78f: 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; 11a792: b8 01 00 00 00 mov $0x1,%eax 11a797: 2b 42 08 sub 0x8(%edx),%eax 11a79a: 03 45 0c add 0xc(%ebp),%eax if ( information->maximum >= index ) { 11a79d: 0f b7 4a 10 movzwl 0x10(%edx),%ecx 11a7a1: 39 c8 cmp %ecx,%eax 11a7a3: 77 13 ja 11a7b8 <_Objects_Get_no_protection+0x30> if ( (the_object = information->local_table[ index ]) != NULL ) { 11a7a5: 8b 52 1c mov 0x1c(%edx),%edx 11a7a8: 8b 04 82 mov (%edx,%eax,4),%eax 11a7ab: 85 c0 test %eax,%eax 11a7ad: 74 09 je 11a7b8 <_Objects_Get_no_protection+0x30><== NEVER TAKEN *location = OBJECTS_LOCAL; 11a7af: 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; } 11a7b5: 5b pop %ebx 11a7b6: c9 leave 11a7b7: 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; 11a7b8: c7 03 01 00 00 00 movl $0x1,(%ebx) return NULL; 11a7be: 31 c0 xor %eax,%eax } 11a7c0: 5b pop %ebx 11a7c1: c9 leave 11a7c2: c3 ret =============================================================================== 0010d458 <_Objects_Id_to_name>: */ Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10d458: 55 push %ebp 10d459: 89 e5 mov %esp,%ebp 10d45b: 83 ec 18 sub $0x18,%esp 10d45e: 8b 55 08 mov 0x8(%ebp),%edx /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10d461: 85 d2 test %edx,%edx 10d463: 75 08 jne 10d46d <_Objects_Id_to_name+0x15> 10d465: a1 58 87 12 00 mov 0x128758,%eax 10d46a: 8b 50 08 mov 0x8(%eax),%edx 10d46d: 89 d0 mov %edx,%eax 10d46f: c1 e8 18 shr $0x18,%eax 10d472: 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 ) 10d475: 8d 48 ff lea -0x1(%eax),%ecx 10d478: 83 f9 02 cmp $0x2,%ecx 10d47b: 77 3b ja 10d4b8 <_Objects_Id_to_name+0x60> the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) 10d47d: 8b 04 85 a4 84 12 00 mov 0x1284a4(,%eax,4),%eax 10d484: 85 c0 test %eax,%eax 10d486: 74 30 je 10d4b8 <_Objects_Id_to_name+0x60> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10d488: 89 d1 mov %edx,%ecx 10d48a: c1 e9 1b shr $0x1b,%ecx return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 10d48d: 8b 04 88 mov (%eax,%ecx,4),%eax if ( !information ) 10d490: 85 c0 test %eax,%eax 10d492: 74 24 je 10d4b8 <_Objects_Id_to_name+0x60><== NEVER TAKEN #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 ); 10d494: 51 push %ecx 10d495: 8d 4d f4 lea -0xc(%ebp),%ecx 10d498: 51 push %ecx 10d499: 52 push %edx 10d49a: 50 push %eax 10d49b: e8 50 ff ff ff call 10d3f0 <_Objects_Get> if ( !the_object ) 10d4a0: 83 c4 10 add $0x10,%esp 10d4a3: 85 c0 test %eax,%eax 10d4a5: 74 11 je 10d4b8 <_Objects_Id_to_name+0x60> return OBJECTS_INVALID_ID; *name = the_object->name; 10d4a7: 8b 50 0c mov 0xc(%eax),%edx 10d4aa: 8b 45 0c mov 0xc(%ebp),%eax 10d4ad: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10d4af: e8 f4 0a 00 00 call 10dfa8 <_Thread_Enable_dispatch> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10d4b4: 31 c0 xor %eax,%eax } 10d4b6: c9 leave 10d4b7: c3 ret 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; 10d4b8: 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; } 10d4bd: c9 leave 10d4be: c3 ret =============================================================================== 0010c2f4 <_Objects_Name_to_id_u32>: Objects_Information *information, uint32_t name, uint32_t node, Objects_Id *id ) { 10c2f4: 55 push %ebp 10c2f5: 89 e5 mov %esp,%ebp 10c2f7: 57 push %edi 10c2f8: 56 push %esi 10c2f9: 53 push %ebx 10c2fa: 8b 45 08 mov 0x8(%ebp),%eax 10c2fd: 8b 4d 0c mov 0xc(%ebp),%ecx 10c300: 8b 55 10 mov 0x10(%ebp),%edx 10c303: 8b 7d 14 mov 0x14(%ebp),%edi Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == false */ if ( !id ) 10c306: 85 ff test %edi,%edi 10c308: 74 56 je 10c360 <_Objects_Name_to_id_u32+0x6c> return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 10c30a: 85 c9 test %ecx,%ecx 10c30c: 74 08 je 10c316 <_Objects_Name_to_id_u32+0x22> return OBJECTS_INVALID_NAME; search_local_node = false; if ( information->maximum != 0 && 10c30e: 8b 70 10 mov 0x10(%eax),%esi 10c311: 66 85 f6 test %si,%si 10c314: 75 0a jne 10c320 <_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; 10c316: b8 01 00 00 00 mov $0x1,%eax #endif } 10c31b: 5b pop %ebx 10c31c: 5e pop %esi 10c31d: 5f pop %edi 10c31e: c9 leave 10c31f: c3 ret if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = false; if ( information->maximum != 0 && 10c320: 85 d2 test %edx,%edx 10c322: 75 20 jne 10c344 <_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++ ) { 10c324: 0f b7 f6 movzwl %si,%esi 10c327: 8b 58 1c mov 0x1c(%eax),%ebx 10c32a: b8 01 00 00 00 mov $0x1,%eax 10c32f: 90 nop the_object = information->local_table[ index ]; 10c330: 8b 14 83 mov (%ebx,%eax,4),%edx if ( !the_object ) 10c333: 85 d2 test %edx,%edx 10c335: 74 05 je 10c33c <_Objects_Name_to_id_u32+0x48> continue; if ( name == the_object->name.name_u32 ) { 10c337: 39 4a 0c cmp %ecx,0xc(%edx) 10c33a: 74 18 je 10c354 <_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++ ) { 10c33c: 40 inc %eax 10c33d: 39 c6 cmp %eax,%esi 10c33f: 73 ef jae 10c330 <_Objects_Name_to_id_u32+0x3c> 10c341: eb d3 jmp 10c316 <_Objects_Name_to_id_u32+0x22> 10c343: 90 nop return OBJECTS_INVALID_NAME; search_local_node = false; if ( information->maximum != 0 && (node == OBJECTS_SEARCH_ALL_NODES || 10c344: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx 10c34a: 74 d8 je 10c324 <_Objects_Name_to_id_u32+0x30> node == OBJECTS_SEARCH_LOCAL_NODE || 10c34c: 4a dec %edx 10c34d: 75 c7 jne 10c316 <_Objects_Name_to_id_u32+0x22> 10c34f: eb d3 jmp 10c324 <_Objects_Name_to_id_u32+0x30> 10c351: 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; 10c354: 8b 42 08 mov 0x8(%edx),%eax 10c357: 89 07 mov %eax,(%edi) return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10c359: 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 } 10c35b: 5b pop %ebx 10c35c: 5e pop %esi 10c35d: 5f pop %edi 10c35e: c9 leave 10c35f: c3 ret #endif /* ASSERT: information->is_string == false */ if ( !id ) return OBJECTS_INVALID_ADDRESS; 10c360: 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 } 10c365: 5b pop %ebx 10c366: 5e pop %esi 10c367: 5f pop %edi 10c368: c9 leave 10c369: c3 ret =============================================================================== 0010e294 <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 10e294: 55 push %ebp 10e295: 89 e5 mov %esp,%ebp 10e297: 53 push %ebx 10e298: 83 ec 0c sub $0xc,%esp 10e29b: 8b 5d 10 mov 0x10(%ebp),%ebx size_t length; const char *s; s = name; length = strnlen( name, information->name_length ); 10e29e: 8b 45 08 mov 0x8(%ebp),%eax 10e2a1: 0f b7 40 38 movzwl 0x38(%eax),%eax 10e2a5: 50 push %eax 10e2a6: 53 push %ebx 10e2a7: e8 3c 6d 00 00 call 114fe8 d[length] = '\0'; the_object->name.name_p = d; } else #endif { the_object->name.name_u32 = _Objects_Build_name( 10e2ac: 0f be 0b movsbl (%ebx),%ecx 10e2af: c1 e1 18 shl $0x18,%ecx 10e2b2: 83 c4 10 add $0x10,%esp 10e2b5: 83 f8 01 cmp $0x1,%eax 10e2b8: 76 32 jbe 10e2ec <_Objects_Set_name+0x58> 10e2ba: 0f be 53 01 movsbl 0x1(%ebx),%edx 10e2be: c1 e2 10 shl $0x10,%edx 10e2c1: 09 ca or %ecx,%edx 10e2c3: 83 f8 02 cmp $0x2,%eax 10e2c6: 74 2c je 10e2f4 <_Objects_Set_name+0x60> 10e2c8: 0f be 4b 02 movsbl 0x2(%ebx),%ecx 10e2cc: c1 e1 08 shl $0x8,%ecx 10e2cf: 09 d1 or %edx,%ecx 10e2d1: 83 f8 03 cmp $0x3,%eax 10e2d4: 74 37 je 10e30d <_Objects_Set_name+0x79> 10e2d6: 0f be 43 03 movsbl 0x3(%ebx),%eax 10e2da: 09 c1 or %eax,%ecx 10e2dc: 8b 55 0c mov 0xc(%ebp),%edx 10e2df: 89 4a 0c mov %ecx,0xc(%edx) ); } return true; } 10e2e2: b0 01 mov $0x1,%al 10e2e4: 8b 5d fc mov -0x4(%ebp),%ebx 10e2e7: c9 leave 10e2e8: c3 ret 10e2e9: 8d 76 00 lea 0x0(%esi),%esi d[length] = '\0'; the_object->name.name_p = d; } else #endif { the_object->name.name_u32 = _Objects_Build_name( 10e2ec: 89 ca mov %ecx,%edx 10e2ee: 81 ca 00 00 20 00 or $0x200000,%edx 10e2f4: 89 d1 mov %edx,%ecx 10e2f6: 80 cd 20 or $0x20,%ch 10e2f9: b8 20 00 00 00 mov $0x20,%eax 10e2fe: 09 c1 or %eax,%ecx 10e300: 8b 55 0c mov 0xc(%ebp),%edx 10e303: 89 4a 0c mov %ecx,0xc(%edx) ); } return true; } 10e306: b0 01 mov $0x1,%al 10e308: 8b 5d fc mov -0x4(%ebp),%ebx 10e30b: c9 leave 10e30c: c3 ret d[length] = '\0'; the_object->name.name_p = d; } else #endif { the_object->name.name_u32 = _Objects_Build_name( 10e30d: b8 20 00 00 00 mov $0x20,%eax 10e312: eb c6 jmp 10e2da <_Objects_Set_name+0x46> =============================================================================== 0010c36c <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 10c36c: 55 push %ebp 10c36d: 89 e5 mov %esp,%ebp 10c36f: 57 push %edi 10c370: 56 push %esi 10c371: 53 push %ebx 10c372: 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 ); 10c375: 8b 45 08 mov 0x8(%ebp),%eax 10c378: 0f b7 58 08 movzwl 0x8(%eax),%ebx block_count = (information->maximum - index_base) / 10c37c: 0f b7 48 14 movzwl 0x14(%eax),%ecx 10c380: 0f b7 40 10 movzwl 0x10(%eax),%eax 10c384: 29 d8 sub %ebx,%eax 10c386: 31 d2 xor %edx,%edx 10c388: f7 f1 div %ecx information->allocation_size; for ( block = 0; block < block_count; block++ ) { 10c38a: 85 c0 test %eax,%eax 10c38c: 74 21 je 10c3af <_Objects_Shrink_information+0x43><== NEVER TAKEN if ( information->inactive_per_block[ block ] == 10c38e: 8b 55 08 mov 0x8(%ebp),%edx 10c391: 8b 72 30 mov 0x30(%edx),%esi 10c394: 3b 0e cmp (%esi),%ecx 10c396: 74 1f je 10c3b7 <_Objects_Shrink_information+0x4b><== NEVER TAKEN 10c398: 31 d2 xor %edx,%edx 10c39a: eb 0e jmp 10c3aa <_Objects_Shrink_information+0x3e> information->inactive -= information->allocation_size; return; } index_base += information->allocation_size; 10c39c: 01 cb add %ecx,%ebx 10c39e: 8d 3c 95 00 00 00 00 lea 0x0(,%edx,4),%edi index_base = _Objects_Get_index( information->minimum_id ); block_count = (information->maximum - index_base) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { if ( information->inactive_per_block[ block ] == 10c3a5: 3b 0c 96 cmp (%esi,%edx,4),%ecx 10c3a8: 74 12 je 10c3bc <_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++ ) { 10c3aa: 42 inc %edx 10c3ab: 39 d0 cmp %edx,%eax 10c3ad: 77 ed ja 10c39c <_Objects_Shrink_information+0x30> return; } index_base += information->allocation_size; } } 10c3af: 8d 65 f4 lea -0xc(%ebp),%esp 10c3b2: 5b pop %ebx 10c3b3: 5e pop %esi 10c3b4: 5f pop %edi 10c3b5: c9 leave 10c3b6: 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 ] == 10c3b7: 31 ff xor %edi,%edi <== NOT EXECUTED 10c3b9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED information->allocation_size ) { /* * Assume the Inactive chain is never empty at this point */ the_object = (Objects_Control *) _Chain_First( &information->Inactive ); 10c3bc: 8b 55 08 mov 0x8(%ebp),%edx 10c3bf: 8b 42 20 mov 0x20(%edx),%eax 10c3c2: 89 7d e4 mov %edi,-0x1c(%ebp) 10c3c5: eb 07 jmp 10c3ce <_Objects_Shrink_information+0x62> 10c3c7: 90 nop if ((index >= index_base) && (index < (index_base + information->allocation_size))) { _Chain_Extract( &extract_me->Node ); } } while ( the_object ); 10c3c8: 85 f6 test %esi,%esi 10c3ca: 74 2c je 10c3f8 <_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; 10c3cc: 89 f0 mov %esi,%eax * Assume the Inactive chain is never empty at this point */ the_object = (Objects_Control *) _Chain_First( &information->Inactive ); do { index = _Objects_Get_index( the_object->id ); 10c3ce: 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; 10c3d2: 8b 30 mov (%eax),%esi if ((index >= index_base) && 10c3d4: 39 da cmp %ebx,%edx 10c3d6: 72 f0 jb 10c3c8 <_Objects_Shrink_information+0x5c> (index < (index_base + information->allocation_size))) { 10c3d8: 8b 7d 08 mov 0x8(%ebp),%edi 10c3db: 0f b7 4f 14 movzwl 0x14(%edi),%ecx 10c3df: 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) && 10c3e2: 39 ca cmp %ecx,%edx 10c3e4: 73 e2 jae 10c3c8 <_Objects_Shrink_information+0x5c> (index < (index_base + information->allocation_size))) { _Chain_Extract( &extract_me->Node ); 10c3e6: 83 ec 0c sub $0xc,%esp 10c3e9: 50 push %eax 10c3ea: e8 b9 f0 ff ff call 10b4a8 <_Chain_Extract> 10c3ef: 83 c4 10 add $0x10,%esp } } while ( the_object ); 10c3f2: 85 f6 test %esi,%esi 10c3f4: 75 d6 jne 10c3cc <_Objects_Shrink_information+0x60> 10c3f6: 66 90 xchg %ax,%ax 10c3f8: 8b 7d e4 mov -0x1c(%ebp),%edi /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); 10c3fb: 83 ec 0c sub $0xc,%esp 10c3fe: 8b 55 08 mov 0x8(%ebp),%edx 10c401: 8b 42 34 mov 0x34(%edx),%eax 10c404: ff 34 38 pushl (%eax,%edi,1) 10c407: e8 80 18 00 00 call 10dc8c <_Workspace_Free> information->object_blocks[ block ] = NULL; 10c40c: 8b 55 08 mov 0x8(%ebp),%edx 10c40f: 8b 42 34 mov 0x34(%edx),%eax 10c412: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1) information->inactive_per_block[ block ] = 0; 10c419: 8b 42 30 mov 0x30(%edx),%eax 10c41c: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1) information->inactive -= information->allocation_size; 10c423: 8b 42 14 mov 0x14(%edx),%eax 10c426: 66 29 42 2c sub %ax,0x2c(%edx) return; 10c42a: 83 c4 10 add $0x10,%esp } index_base += information->allocation_size; } } 10c42d: 8d 65 f4 lea -0xc(%ebp),%esp 10c430: 5b pop %ebx 10c431: 5e pop %esi 10c432: 5f pop %edi 10c433: c9 leave 10c434: c3 ret =============================================================================== 0010cb1c <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 10cb1c: 55 push %ebp 10cb1d: 89 e5 mov %esp,%ebp 10cb1f: 56 push %esi 10cb20: 53 push %ebx 10cb21: 8b 5d 08 mov 0x8(%ebp),%ebx 10cb24: 8b 75 0c mov 0xc(%ebp),%esi if ( !the_heap ) 10cb27: 85 db test %ebx,%ebx 10cb29: 74 35 je 10cb60 <_Protected_heap_Get_information+0x44> return false; if ( !the_info ) 10cb2b: 85 f6 test %esi,%esi 10cb2d: 74 31 je 10cb60 <_Protected_heap_Get_information+0x44> return false; _RTEMS_Lock_allocator(); 10cb2f: 83 ec 0c sub $0xc,%esp 10cb32: ff 35 c0 65 12 00 pushl 0x1265c0 10cb38: e8 bf ef ff ff call 10bafc <_API_Mutex_Lock> _Heap_Get_information( the_heap, the_info ); 10cb3d: 5a pop %edx 10cb3e: 59 pop %ecx 10cb3f: 56 push %esi 10cb40: 53 push %ebx 10cb41: e8 0a 44 00 00 call 110f50 <_Heap_Get_information> _RTEMS_Unlock_allocator(); 10cb46: 58 pop %eax 10cb47: ff 35 c0 65 12 00 pushl 0x1265c0 10cb4d: e8 f2 ef ff ff call 10bb44 <_API_Mutex_Unlock> return true; 10cb52: 83 c4 10 add $0x10,%esp 10cb55: b0 01 mov $0x1,%al } 10cb57: 8d 65 f8 lea -0x8(%ebp),%esp 10cb5a: 5b pop %ebx 10cb5b: 5e pop %esi 10cb5c: c9 leave 10cb5d: c3 ret 10cb5e: 66 90 xchg %ax,%ax { if ( !the_heap ) return false; if ( !the_info ) return false; 10cb60: 31 c0 xor %eax,%eax _RTEMS_Lock_allocator(); _Heap_Get_information( the_heap, the_info ); _RTEMS_Unlock_allocator(); return true; } 10cb62: 8d 65 f8 lea -0x8(%ebp),%esp 10cb65: 5b pop %ebx 10cb66: 5e pop %esi 10cb67: c9 leave 10cb68: c3 ret =============================================================================== 0010ffc4 <_Protected_heap_Walk>: bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 10ffc4: 55 push %ebp 10ffc5: 89 e5 mov %esp,%ebp 10ffc7: 56 push %esi 10ffc8: 53 push %ebx 10ffc9: 83 ec 10 sub $0x10,%esp 10ffcc: 8b 5d 08 mov 0x8(%ebp),%ebx 10ffcf: 8b 75 0c mov 0xc(%ebp),%esi 10ffd2: 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 ) { 10ffd5: 8b 15 cc d5 12 00 mov 0x12d5cc,%edx 10ffdb: 85 d2 test %edx,%edx 10ffdd: 74 19 je 10fff8 <_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 ); 10ffdf: 0f b6 c0 movzbl %al,%eax 10ffe2: 89 45 10 mov %eax,0x10(%ebp) 10ffe5: 89 75 0c mov %esi,0xc(%ebp) 10ffe8: 89 5d 08 mov %ebx,0x8(%ebp) } return status; } 10ffeb: 8d 65 f8 lea -0x8(%ebp),%esp 10ffee: 5b pop %ebx 10ffef: 5e pop %esi 10fff0: 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 ); 10fff1: e9 5a f2 ff ff jmp 10f250 <_Heap_Walk> 10fff6: 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(); 10fff8: 83 ec 0c sub $0xc,%esp 10fffb: ff 35 80 d6 12 00 pushl 0x12d680 110001: 88 45 f4 mov %al,-0xc(%ebp) 110004: e8 0b e5 ff ff call 10e514 <_API_Mutex_Lock> status = _Heap_Walk( the_heap, source, do_dump ); 110009: 83 c4 0c add $0xc,%esp 11000c: 8a 45 f4 mov -0xc(%ebp),%al 11000f: 0f b6 c0 movzbl %al,%eax 110012: 50 push %eax 110013: 56 push %esi 110014: 53 push %ebx 110015: e8 36 f2 ff ff call 10f250 <_Heap_Walk> _RTEMS_Unlock_allocator(); 11001a: 5a pop %edx 11001b: ff 35 80 d6 12 00 pushl 0x12d680 110021: 88 45 f4 mov %al,-0xc(%ebp) 110024: e8 33 e5 ff ff call 10e55c <_API_Mutex_Unlock> 110029: 83 c4 10 add $0x10,%esp } else { status = _Heap_Walk( the_heap, source, do_dump ); } return status; } 11002c: 8a 45 f4 mov -0xc(%ebp),%al 11002f: 8d 65 f8 lea -0x8(%ebp),%esp 110032: 5b pop %ebx 110033: 5e pop %esi 110034: c9 leave 110035: c3 ret =============================================================================== 0010fc3c <_RTEMS_tasks_Create_extension>: bool _RTEMS_tasks_Create_extension( Thread_Control *executing, Thread_Control *created ) { 10fc3c: 55 push %ebp 10fc3d: 89 e5 mov %esp,%ebp 10fc3f: 53 push %ebx 10fc40: 83 ec 10 sub $0x10,%esp 10fc43: 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 ); 10fc46: 80 3d c4 22 12 00 01 cmpb $0x1,0x1222c4 10fc4d: 19 c0 sbb %eax,%eax 10fc4f: 83 e0 c0 and $0xffffffc0,%eax 10fc52: 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 ); 10fc55: 50 push %eax 10fc56: e8 15 e0 ff ff call 10dc70 <_Workspace_Allocate> if ( !api ) 10fc5b: 83 c4 10 add $0x10,%esp 10fc5e: 85 c0 test %eax,%eax 10fc60: 74 6a je 10fccc <_RTEMS_tasks_Create_extension+0x90> return false; created->API_Extensions[ THREAD_API_RTEMS ] = api; 10fc62: 89 83 e4 00 00 00 mov %eax,0xe4(%ebx) api->pending_events = EVENT_SETS_NONE_PENDING; 10fc68: c7 00 00 00 00 00 movl $0x0,(%eax) api->event_condition = 0; 10fc6e: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) */ RTEMS_INLINE_ROUTINE void _ASR_Initialize ( ASR_Information *information ) { information->is_enabled = false; 10fc75: c6 40 08 00 movb $0x0,0x8(%eax) information->handler = NULL; 10fc79: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) information->mode_set = RTEMS_DEFAULT_MODES; 10fc80: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) information->signals_posted = 0; 10fc87: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax) information->signals_pending = 0; 10fc8e: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) information->nest_level = 0; 10fc95: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) _ASR_Initialize( &api->Signal ); created->task_variables = NULL; 10fc9c: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx) 10fca3: 00 00 00 if ( rtems_configuration_get_notepads_enabled() ) { 10fca6: 80 3d c4 22 12 00 00 cmpb $0x0,0x1222c4 10fcad: 74 13 je 10fcc2 <_RTEMS_tasks_Create_extension+0x86> 10fcaf: 31 d2 xor %edx,%edx 10fcb1: 8d 76 00 lea 0x0(%esi),%esi for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; 10fcb4: c7 44 90 20 00 00 00 movl $0x0,0x20(%eax,%edx,4) 10fcbb: 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++) 10fcbc: 42 inc %edx 10fcbd: 83 fa 10 cmp $0x10,%edx 10fcc0: 75 f2 jne 10fcb4 <_RTEMS_tasks_Create_extension+0x78> api->Notepads[i] = 0; } return true; 10fcc2: b0 01 mov $0x1,%al } 10fcc4: 8b 5d fc mov -0x4(%ebp),%ebx 10fcc7: c9 leave 10fcc8: c3 ret 10fcc9: 8d 76 00 lea 0x0(%esi),%esi to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); if ( !api ) return false; 10fccc: 31 c0 xor %eax,%eax for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; } return true; } 10fcce: 8b 5d fc mov -0x4(%ebp),%ebx 10fcd1: c9 leave 10fcd2: c3 ret =============================================================================== 0010fbe4 <_RTEMS_tasks_Delete_extension>: void _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 10fbe4: 55 push %ebp 10fbe5: 89 e5 mov %esp,%ebp 10fbe7: 56 push %esi 10fbe8: 53 push %ebx 10fbe9: 8b 75 0c mov 0xc(%ebp),%esi /* * Free per task variable memory */ tvp = deleted->task_variables; 10fbec: 8b 86 f0 00 00 00 mov 0xf0(%esi),%eax deleted->task_variables = NULL; 10fbf2: c7 86 f0 00 00 00 00 movl $0x0,0xf0(%esi) 10fbf9: 00 00 00 while (tvp) { 10fbfc: 85 c0 test %eax,%eax 10fbfe: 75 06 jne 10fc06 <_RTEMS_tasks_Delete_extension+0x22> 10fc00: eb 17 jmp 10fc19 <_RTEMS_tasks_Delete_extension+0x35> 10fc02: 66 90 xchg %ax,%ax next = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); tvp = next; 10fc04: 89 d8 mov %ebx,%eax */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { next = (rtems_task_variable_t *)tvp->next; 10fc06: 8b 18 mov (%eax),%ebx _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); 10fc08: 83 ec 08 sub $0x8,%esp 10fc0b: 50 push %eax 10fc0c: 56 push %esi 10fc0d: e8 56 01 00 00 call 10fd68 <_RTEMS_Tasks_Invoke_task_variable_dtor> * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 10fc12: 83 c4 10 add $0x10,%esp 10fc15: 85 db test %ebx,%ebx 10fc17: 75 eb jne 10fc04 <_RTEMS_tasks_Delete_extension+0x20> /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); 10fc19: 83 ec 0c sub $0xc,%esp 10fc1c: ff b6 e4 00 00 00 pushl 0xe4(%esi) 10fc22: e8 65 e0 ff ff call 10dc8c <_Workspace_Free> deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 10fc27: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) 10fc2e: 00 00 00 10fc31: 83 c4 10 add $0x10,%esp } 10fc34: 8d 65 f8 lea -0x8(%ebp),%esp 10fc37: 5b pop %ebx 10fc38: 5e pop %esi 10fc39: c9 leave 10fc3a: c3 ret =============================================================================== 0010fb68 <_RTEMS_tasks_Initialize_user_tasks>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks( void ) { 10fb68: 55 push %ebp 10fb69: 89 e5 mov %esp,%ebp 10fb6b: 83 ec 08 sub $0x8,%esp if ( _RTEMS_tasks_Initialize_user_tasks_p ) 10fb6e: a1 40 23 12 00 mov 0x122340,%eax 10fb73: 85 c0 test %eax,%eax 10fb75: 74 05 je 10fb7c <_RTEMS_tasks_Initialize_user_tasks+0x14> (*_RTEMS_tasks_Initialize_user_tasks_p)(); } 10fb77: c9 leave */ void _RTEMS_tasks_Initialize_user_tasks( void ) { if ( _RTEMS_tasks_Initialize_user_tasks_p ) (*_RTEMS_tasks_Initialize_user_tasks_p)(); 10fb78: ff e0 jmp *%eax 10fb7a: 66 90 xchg %ax,%ax } 10fb7c: c9 leave 10fb7d: c3 ret =============================================================================== 0010af78 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 10af78: 55 push %ebp 10af79: 89 e5 mov %esp,%ebp 10af7b: 57 push %edi 10af7c: 56 push %esi 10af7d: 53 push %ebx 10af7e: 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; 10af81: 8b 1d ec 22 12 00 mov 0x1222ec,%ebx maximum = Configuration_RTEMS_API.number_of_initialization_tasks; 10af87: 8b 3d e8 22 12 00 mov 0x1222e8,%edi /* * Verify that we have a set of user tasks to iterate */ if ( !user_tasks ) 10af8d: 85 db test %ebx,%ebx 10af8f: 74 46 je 10afd7 <_RTEMS_tasks_Initialize_user_tasks_body+0x5f> return; /* * Now iterate over the initialization tasks and create/start them. */ for ( index=0 ; index < maximum ; index++ ) { 10af91: 85 ff test %edi,%edi 10af93: 74 42 je 10afd7 <_RTEMS_tasks_Initialize_user_tasks_body+0x5f><== NEVER TAKEN 10af95: 31 f6 xor %esi,%esi 10af97: 90 nop return_value = rtems_task_create( 10af98: 83 ec 08 sub $0x8,%esp 10af9b: 8d 45 e4 lea -0x1c(%ebp),%eax 10af9e: 50 push %eax 10af9f: ff 73 0c pushl 0xc(%ebx) 10afa2: ff 73 14 pushl 0x14(%ebx) 10afa5: ff 73 04 pushl 0x4(%ebx) 10afa8: ff 73 08 pushl 0x8(%ebx) 10afab: ff 33 pushl (%ebx) 10afad: e8 92 fd ff ff call 10ad44 user_tasks[ index ].stack_size, user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 10afb2: 83 c4 20 add $0x20,%esp 10afb5: 85 c0 test %eax,%eax 10afb7: 75 26 jne 10afdf <_RTEMS_tasks_Initialize_user_tasks_body+0x67> _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, true, return_value ); return_value = rtems_task_start( 10afb9: 51 push %ecx 10afba: ff 73 18 pushl 0x18(%ebx) 10afbd: ff 73 10 pushl 0x10(%ebx) 10afc0: ff 75 e4 pushl -0x1c(%ebp) 10afc3: e8 24 00 00 00 call 10afec id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 10afc8: 83 c4 10 add $0x10,%esp 10afcb: 85 c0 test %eax,%eax 10afcd: 75 10 jne 10afdf <_RTEMS_tasks_Initialize_user_tasks_body+0x67> return; /* * Now iterate over the initialization tasks and create/start them. */ for ( index=0 ; index < maximum ; index++ ) { 10afcf: 46 inc %esi 10afd0: 83 c3 1c add $0x1c,%ebx 10afd3: 39 f7 cmp %esi,%edi 10afd5: 77 c1 ja 10af98 <_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 ); } } 10afd7: 8d 65 f4 lea -0xc(%ebp),%esp 10afda: 5b pop %ebx 10afdb: 5e pop %esi 10afdc: 5f pop %edi 10afdd: c9 leave 10afde: 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 ); 10afdf: 52 push %edx 10afe0: 50 push %eax 10afe1: 6a 01 push $0x1 10afe3: 6a 01 push $0x1 10afe5: e8 7e 0c 00 00 call 10bc68 <_Internal_error_Occurred> =============================================================================== 0010fb80 <_RTEMS_tasks_Post_switch_extension>: */ void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) { 10fb80: 55 push %ebp 10fb81: 89 e5 mov %esp,%ebp 10fb83: 57 push %edi 10fb84: 56 push %esi 10fb85: 53 push %ebx 10fb86: 83 ec 1c sub $0x1c,%esp RTEMS_API_Control *api; ASR_Information *asr; rtems_signal_set signal_set; Modes_Control prev_mode; api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10fb89: 8b 45 08 mov 0x8(%ebp),%eax 10fb8c: 8b 98 e4 00 00 00 mov 0xe4(%eax),%ebx if ( !api ) 10fb92: 85 db test %ebx,%ebx 10fb94: 74 45 je 10fbdb <_RTEMS_tasks_Post_switch_extension+0x5b><== NEVER TAKEN * Signal Processing */ asr = &api->Signal; _ISR_Disable( level ); 10fb96: 9c pushf 10fb97: fa cli 10fb98: 58 pop %eax signal_set = asr->signals_posted; 10fb99: 8b 73 14 mov 0x14(%ebx),%esi asr->signals_posted = 0; 10fb9c: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) _ISR_Enable( level ); 10fba3: 50 push %eax 10fba4: 9d popf if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 10fba5: 85 f6 test %esi,%esi 10fba7: 74 32 je 10fbdb <_RTEMS_tasks_Post_switch_extension+0x5b> return; asr->nest_level += 1; 10fba9: ff 43 1c incl 0x1c(%ebx) rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10fbac: 50 push %eax 10fbad: 8d 7d e4 lea -0x1c(%ebp),%edi 10fbb0: 57 push %edi 10fbb1: 68 ff ff 00 00 push $0xffff 10fbb6: ff 73 10 pushl 0x10(%ebx) 10fbb9: e8 be 1d 00 00 call 11197c (*asr->handler)( signal_set ); 10fbbe: 89 34 24 mov %esi,(%esp) 10fbc1: ff 53 0c call *0xc(%ebx) asr->nest_level -= 1; 10fbc4: ff 4b 1c decl 0x1c(%ebx) rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10fbc7: 83 c4 0c add $0xc,%esp 10fbca: 57 push %edi 10fbcb: 68 ff ff 00 00 push $0xffff 10fbd0: ff 75 e4 pushl -0x1c(%ebp) 10fbd3: e8 a4 1d 00 00 call 11197c 10fbd8: 83 c4 10 add $0x10,%esp } 10fbdb: 8d 65 f4 lea -0xc(%ebp),%esp 10fbde: 5b pop %ebx 10fbdf: 5e pop %esi 10fbe0: 5f pop %edi 10fbe1: c9 leave 10fbe2: c3 ret =============================================================================== 0010fb20 <_RTEMS_tasks_Switch_extension>: void _RTEMS_tasks_Switch_extension( Thread_Control *executing, Thread_Control *heir ) { 10fb20: 55 push %ebp 10fb21: 89 e5 mov %esp,%ebp /* * Per Task Variables */ tvp = executing->task_variables; 10fb23: 8b 45 08 mov 0x8(%ebp),%eax 10fb26: 8b 80 f0 00 00 00 mov 0xf0(%eax),%eax while (tvp) { 10fb2c: 85 c0 test %eax,%eax 10fb2e: 74 13 je 10fb43 <_RTEMS_tasks_Switch_extension+0x23> tvp->tval = *tvp->ptr; 10fb30: 8b 50 04 mov 0x4(%eax),%edx 10fb33: 8b 0a mov (%edx),%ecx 10fb35: 89 48 0c mov %ecx,0xc(%eax) *tvp->ptr = tvp->gval; 10fb38: 8b 48 08 mov 0x8(%eax),%ecx 10fb3b: 89 0a mov %ecx,(%edx) tvp = (rtems_task_variable_t *)tvp->next; 10fb3d: 8b 00 mov (%eax),%eax /* * Per Task Variables */ tvp = executing->task_variables; while (tvp) { 10fb3f: 85 c0 test %eax,%eax 10fb41: 75 ed jne 10fb30 <_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; 10fb43: 8b 45 0c mov 0xc(%ebp),%eax 10fb46: 8b 80 f0 00 00 00 mov 0xf0(%eax),%eax while (tvp) { 10fb4c: 85 c0 test %eax,%eax 10fb4e: 74 13 je 10fb63 <_RTEMS_tasks_Switch_extension+0x43> tvp->gval = *tvp->ptr; 10fb50: 8b 50 04 mov 0x4(%eax),%edx 10fb53: 8b 0a mov (%edx),%ecx 10fb55: 89 48 08 mov %ecx,0x8(%eax) *tvp->ptr = tvp->tval; 10fb58: 8b 48 0c mov 0xc(%eax),%ecx 10fb5b: 89 0a mov %ecx,(%edx) tvp = (rtems_task_variable_t *)tvp->next; 10fb5d: 8b 00 mov (%eax),%eax *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { 10fb5f: 85 c0 test %eax,%eax 10fb61: 75 ed jne 10fb50 <_RTEMS_tasks_Switch_extension+0x30><== NEVER TAKEN tvp->gval = *tvp->ptr; *tvp->ptr = tvp->tval; tvp = (rtems_task_variable_t *)tvp->next; } } 10fb63: c9 leave 10fb64: c3 ret =============================================================================== 0010b9d8 <_Rate_monotonic_Initiate_statistics>: } void _Rate_monotonic_Initiate_statistics( Rate_monotonic_Control *the_period ) { 10b9d8: 55 push %ebp 10b9d9: 89 e5 mov %esp,%ebp 10b9db: 57 push %edi 10b9dc: 56 push %esi 10b9dd: 53 push %ebx 10b9de: 83 ec 28 sub $0x28,%esp 10b9e1: 8b 5d 08 mov 0x8(%ebp),%ebx Thread_Control *owning_thread = the_period->owner; 10b9e4: 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 ); 10b9e7: 8d 7d e0 lea -0x20(%ebp),%edi 10b9ea: 57 push %edi 10b9eb: e8 14 17 00 00 call 10d104 <_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; 10b9f0: 8b 45 e0 mov -0x20(%ebp),%eax 10b9f3: 8b 55 e4 mov -0x1c(%ebp),%edx 10b9f6: 89 43 4c mov %eax,0x4c(%ebx) 10b9f9: 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; 10b9fc: 8b 86 84 00 00 00 mov 0x84(%esi),%eax 10ba02: 8b 96 88 00 00 00 mov 0x88(%esi),%edx 10ba08: 89 43 44 mov %eax,0x44(%ebx) 10ba0b: 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) { 10ba0e: 83 c4 10 add $0x10,%esp 10ba11: 39 35 18 88 12 00 cmp %esi,0x128818 10ba17: 74 0b je 10ba24 <_Rate_monotonic_Initiate_statistics+0x4c> ); _Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran ); } #endif } 10ba19: 8d 65 f4 lea -0xc(%ebp),%esp 10ba1c: 5b pop %ebx 10ba1d: 5e pop %esi 10ba1e: 5f pop %edi 10ba1f: c9 leave 10ba20: c3 ret 10ba21: 8d 76 00 lea 0x0(%esi),%esi /* * Adjust the CPU time used to account for the time since last * context switch. */ _Timespec_Subtract( 10ba24: 50 push %eax &_Thread_Time_of_last_context_switch, &uptime, &ran 10ba25: 8d 75 d8 lea -0x28(%ebp),%esi /* * Adjust the CPU time used to account for the time since last * context switch. */ _Timespec_Subtract( 10ba28: 56 push %esi 10ba29: 57 push %edi 10ba2a: 68 4c 86 12 00 push $0x12864c 10ba2f: e8 88 37 00 00 call 10f1bc <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timespec_Add_to( &the_period->cpu_usage_period_initiated, &ran ); 10ba34: 59 pop %ecx 10ba35: 5f pop %edi 10ba36: 56 push %esi 10ba37: 83 c3 44 add $0x44,%ebx 10ba3a: 53 push %ebx 10ba3b: e8 80 36 00 00 call 10f0c0 <_Timespec_Add_to> 10ba40: 83 c4 10 add $0x10,%esp } #endif } 10ba43: 8d 65 f4 lea -0xc(%ebp),%esp 10ba46: 5b pop %ebx 10ba47: 5e pop %esi 10ba48: 5f pop %edi 10ba49: c9 leave 10ba4a: c3 ret =============================================================================== 0010bf94 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 10bf94: 55 push %ebp 10bf95: 89 e5 mov %esp,%ebp 10bf97: 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 ); 10bf9a: 8d 45 f4 lea -0xc(%ebp),%eax 10bf9d: 50 push %eax 10bf9e: ff 75 08 pushl 0x8(%ebp) 10bfa1: 68 a0 84 12 00 push $0x1284a0 10bfa6: e8 d5 1b 00 00 call 10db80 <_Objects_Get> switch ( location ) { 10bfab: 83 c4 10 add $0x10,%esp 10bfae: 8b 55 f4 mov -0xc(%ebp),%edx 10bfb1: 85 d2 test %edx,%edx 10bfb3: 75 29 jne 10bfde <_Rate_monotonic_Timeout+0x4a><== NEVER TAKEN case OBJECTS_LOCAL: the_thread = the_period->owner; 10bfb5: 8b 50 40 mov 0x40(%eax),%edx if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10bfb8: f6 42 11 40 testb $0x40,0x11(%edx) 10bfbc: 74 08 je 10bfc6 <_Rate_monotonic_Timeout+0x32> 10bfbe: 8b 48 08 mov 0x8(%eax),%ecx 10bfc1: 39 4a 20 cmp %ecx,0x20(%edx) 10bfc4: 74 4e je 10c014 <_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 ) { 10bfc6: 83 78 38 01 cmpl $0x1,0x38(%eax) 10bfca: 74 14 je 10bfe0 <_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; 10bfcc: 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; 10bfd3: a1 8c 85 12 00 mov 0x12858c,%eax 10bfd8: 48 dec %eax 10bfd9: a3 8c 85 12 00 mov %eax,0x12858c case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10bfde: c9 leave 10bfdf: 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; 10bfe0: c7 40 38 03 00 00 00 movl $0x3,0x38(%eax) _Rate_monotonic_Initiate_statistics( the_period ); 10bfe7: 83 ec 0c sub $0xc,%esp 10bfea: 50 push %eax 10bfeb: 89 45 e4 mov %eax,-0x1c(%ebp) 10bfee: e8 e5 f9 ff ff call 10b9d8 <_Rate_monotonic_Initiate_statistics> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10bff3: 8b 45 e4 mov -0x1c(%ebp),%eax 10bff6: 8b 50 3c mov 0x3c(%eax),%edx 10bff9: 89 50 1c mov %edx,0x1c(%eax) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10bffc: 5a pop %edx 10bffd: 59 pop %ecx _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 10bffe: 83 c0 10 add $0x10,%eax 10c001: 50 push %eax 10c002: 68 60 86 12 00 push $0x128660 10c007: e8 90 34 00 00 call 10f49c <_Watchdog_Insert> 10c00c: 83 c4 10 add $0x10,%esp 10c00f: eb c2 jmp 10bfd3 <_Rate_monotonic_Timeout+0x3f> 10c011: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10c014: 83 ec 08 sub $0x8,%esp 10c017: 68 f8 ff 03 10 push $0x1003fff8 10c01c: 52 push %edx 10c01d: 89 45 e4 mov %eax,-0x1c(%ebp) 10c020: e8 47 23 00 00 call 10e36c <_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 ); 10c025: 8b 45 e4 mov -0x1c(%ebp),%eax 10c028: 89 04 24 mov %eax,(%esp) 10c02b: eb c1 jmp 10bfee <_Rate_monotonic_Timeout+0x5a> =============================================================================== 0010ba4c <_Rate_monotonic_Update_statistics>: void _Rate_monotonic_Update_statistics( Rate_monotonic_Control *the_period ) { 10ba4c: 55 push %ebp 10ba4d: 89 e5 mov %esp,%ebp 10ba4f: 57 push %edi 10ba50: 56 push %esi 10ba51: 53 push %ebx 10ba52: 83 ec 1c sub $0x1c,%esp 10ba55: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Update the counts. */ stats = &the_period->Statistics; stats->count++; 10ba58: ff 43 54 incl 0x54(%ebx) if ( the_period->state == RATE_MONOTONIC_EXPIRED ) 10ba5b: 83 7b 38 04 cmpl $0x4,0x38(%ebx) 10ba5f: 0f 84 bf 00 00 00 je 10bb24 <_Rate_monotonic_Update_statistics+0xd8> stats->missed_count++; /* * Grab status for time statistics. */ valid_status = 10ba65: 51 push %ecx _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); 10ba66: 8d 7d e0 lea -0x20(%ebp),%edi stats->missed_count++; /* * Grab status for time statistics. */ valid_status = 10ba69: 57 push %edi _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); 10ba6a: 8d 75 d8 lea -0x28(%ebp),%esi stats->missed_count++; /* * Grab status for time statistics. */ valid_status = 10ba6d: 56 push %esi 10ba6e: 53 push %ebx 10ba6f: e8 cc fe ff ff call 10b940 <_Rate_monotonic_Get_status> _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); if (!valid_status) 10ba74: 83 c4 10 add $0x10,%esp 10ba77: 84 c0 test %al,%al 10ba79: 75 09 jne 10ba84 <_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 } 10ba7b: 8d 65 f4 lea -0xc(%ebp),%esp 10ba7e: 5b pop %ebx 10ba7f: 5e pop %esi 10ba80: 5f pop %edi 10ba81: c9 leave 10ba82: c3 ret 10ba83: 90 nop /* * Update CPU time */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Add_to( &stats->total_cpu_time, &executed ); 10ba84: 83 ec 08 sub $0x8,%esp 10ba87: 57 push %edi 10ba88: 8d 43 6c lea 0x6c(%ebx),%eax 10ba8b: 50 push %eax 10ba8c: e8 2f 36 00 00 call 10f0c0 <_Timespec_Add_to> if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) ) 10ba91: 58 pop %eax 10ba92: 5a pop %edx 10ba93: 8d 43 5c lea 0x5c(%ebx),%eax 10ba96: 50 push %eax 10ba97: 57 push %edi 10ba98: e8 fb 36 00 00 call 10f198 <_Timespec_Less_than> 10ba9d: 83 c4 10 add $0x10,%esp 10baa0: 84 c0 test %al,%al 10baa2: 74 0c je 10bab0 <_Rate_monotonic_Update_statistics+0x64> stats->min_cpu_time = executed; 10baa4: 8b 45 e0 mov -0x20(%ebp),%eax 10baa7: 8b 55 e4 mov -0x1c(%ebp),%edx 10baaa: 89 43 5c mov %eax,0x5c(%ebx) 10baad: 89 53 60 mov %edx,0x60(%ebx) if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) ) 10bab0: 83 ec 08 sub $0x8,%esp 10bab3: 8d 43 64 lea 0x64(%ebx),%eax 10bab6: 50 push %eax 10bab7: 57 push %edi 10bab8: e8 b7 36 00 00 call 10f174 <_Timespec_Greater_than> 10babd: 83 c4 10 add $0x10,%esp 10bac0: 84 c0 test %al,%al 10bac2: 74 0c je 10bad0 <_Rate_monotonic_Update_statistics+0x84> stats->max_cpu_time = executed; 10bac4: 8b 45 e0 mov -0x20(%ebp),%eax 10bac7: 8b 55 e4 mov -0x1c(%ebp),%edx 10baca: 89 43 64 mov %eax,0x64(%ebx) 10bacd: 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 ); 10bad0: 83 ec 08 sub $0x8,%esp 10bad3: 56 push %esi 10bad4: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10bada: 50 push %eax 10badb: e8 e0 35 00 00 call 10f0c0 <_Timespec_Add_to> if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) ) 10bae0: 5a pop %edx 10bae1: 59 pop %ecx 10bae2: 8d 43 74 lea 0x74(%ebx),%eax 10bae5: 50 push %eax 10bae6: 56 push %esi 10bae7: e8 ac 36 00 00 call 10f198 <_Timespec_Less_than> 10baec: 83 c4 10 add $0x10,%esp 10baef: 84 c0 test %al,%al 10baf1: 75 39 jne 10bb2c <_Rate_monotonic_Update_statistics+0xe0> stats->min_wall_time = since_last_period; if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) ) 10baf3: 83 ec 08 sub $0x8,%esp 10baf6: 8d 43 7c lea 0x7c(%ebx),%eax 10baf9: 50 push %eax 10bafa: 56 push %esi 10bafb: e8 74 36 00 00 call 10f174 <_Timespec_Greater_than> 10bb00: 83 c4 10 add $0x10,%esp 10bb03: 84 c0 test %al,%al 10bb05: 0f 84 70 ff ff ff je 10ba7b <_Rate_monotonic_Update_statistics+0x2f> stats->max_wall_time = since_last_period; 10bb0b: 8b 45 d8 mov -0x28(%ebp),%eax 10bb0e: 8b 55 dc mov -0x24(%ebp),%edx 10bb11: 89 43 7c mov %eax,0x7c(%ebx) 10bb14: 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 } 10bb1a: 8d 65 f4 lea -0xc(%ebp),%esp 10bb1d: 5b pop %ebx 10bb1e: 5e pop %esi 10bb1f: 5f pop %edi 10bb20: c9 leave 10bb21: c3 ret 10bb22: 66 90 xchg %ax,%ax */ stats = &the_period->Statistics; stats->count++; if ( the_period->state == RATE_MONOTONIC_EXPIRED ) stats->missed_count++; 10bb24: ff 43 58 incl 0x58(%ebx) 10bb27: e9 39 ff ff ff jmp 10ba65 <_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; 10bb2c: 8b 45 d8 mov -0x28(%ebp),%eax 10bb2f: 8b 55 dc mov -0x24(%ebp),%edx 10bb32: 89 43 74 mov %eax,0x74(%ebx) 10bb35: 89 53 78 mov %edx,0x78(%ebx) 10bb38: eb b9 jmp 10baf3 <_Rate_monotonic_Update_statistics+0xa7> =============================================================================== 0010c4d8 <_Scheduler_priority_Block>: #include void _Scheduler_priority_Block( Thread_Control *the_thread ) { 10c4d8: 55 push %ebp 10c4d9: 89 e5 mov %esp,%ebp 10c4db: 53 push %ebx 10c4dc: 8b 45 08 mov 0x8(%ebp),%eax ) { Scheduler_priority_Per_thread *sched_info; Chain_Control *ready; sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info; 10c4df: 8b 88 8c 00 00 00 mov 0x8c(%eax),%ecx ready = sched_info->ready_chain; 10c4e5: 8b 11 mov (%ecx),%edx if ( _Chain_Has_only_one_node( ready ) ) { 10c4e7: 8b 5a 08 mov 0x8(%edx),%ebx 10c4ea: 39 1a cmp %ebx,(%edx) 10c4ec: 74 6e je 10c55c <_Scheduler_priority_Block+0x84> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 10c4ee: 8b 08 mov (%eax),%ecx previous = the_node->previous; 10c4f0: 8b 50 04 mov 0x4(%eax),%edx next->previous = previous; 10c4f3: 89 51 04 mov %edx,0x4(%ecx) previous->next = next; 10c4f6: 89 0a mov %ecx,(%edx) _Scheduler_priority_Ready_queue_extract( the_thread ); /* TODO: flash critical section? */ if ( _Thread_Is_heir( the_thread ) ) 10c4f8: 3b 05 7c 67 12 00 cmp 0x12677c,%eax 10c4fe: 74 18 je 10c518 <_Scheduler_priority_Block+0x40> _Scheduler_priority_Schedule_body(); if ( _Thread_Is_executing( the_thread ) ) 10c500: 3b 05 78 67 12 00 cmp 0x126778,%eax 10c506: 74 04 je 10c50c <_Scheduler_priority_Block+0x34> _Thread_Dispatch_necessary = true; } 10c508: 5b pop %ebx 10c509: c9 leave 10c50a: c3 ret 10c50b: 90 nop if ( _Thread_Is_heir( the_thread ) ) _Scheduler_priority_Schedule_body(); if ( _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; 10c50c: c6 05 84 67 12 00 01 movb $0x1,0x126784 } 10c513: 5b pop %ebx 10c514: c9 leave 10c515: c3 ret 10c516: 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 ); 10c518: 66 8b 1d a0 67 12 00 mov 0x1267a0,%bx 10c51f: 31 d2 xor %edx,%edx 10c521: 89 d1 mov %edx,%ecx 10c523: 66 0f bc cb bsf %bx,%cx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10c527: 0f b7 c9 movzwl %cx,%ecx 10c52a: 66 8b 9c 09 c0 67 12 mov 0x1267c0(%ecx,%ecx,1),%bx 10c531: 00 10c532: 66 0f bc d3 bsf %bx,%dx return (_Priority_Bits_index( major ) << 4) + 10c536: c1 e1 04 shl $0x4,%ecx 10c539: 0f b7 d2 movzwl %dx,%edx 10c53c: 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 ] ) ) 10c53f: 8d 14 52 lea (%edx,%edx,2),%edx 10c542: c1 e2 02 shl $0x2,%edx 10c545: 03 15 00 22 12 00 add 0x122200,%edx 10c54b: 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 ); 10c54d: 83 c2 04 add $0x4,%edx 10c550: 39 d1 cmp %edx,%ecx 10c552: 74 44 je 10c598 <_Scheduler_priority_Block+0xc0><== NEVER TAKEN * * @param[in] the_thread - pointer to thread */ RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10c554: 89 0d 7c 67 12 00 mov %ecx,0x12677c 10c55a: eb a4 jmp 10c500 <_Scheduler_priority_Block+0x28> RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 10c55c: 8d 5a 04 lea 0x4(%edx),%ebx 10c55f: 89 1a mov %ebx,(%edx) head->next = tail; head->previous = NULL; 10c561: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) tail->previous = head; 10c568: 89 52 08 mov %edx,0x8(%edx) RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor &= the_priority_map->block_minor; 10c56b: 8b 59 04 mov 0x4(%ecx),%ebx 10c56e: 66 8b 13 mov (%ebx),%dx 10c571: 66 23 51 0e and 0xe(%ecx),%dx 10c575: 66 89 13 mov %dx,(%ebx) if ( *the_priority_map->minor == 0 ) 10c578: 66 85 d2 test %dx,%dx 10c57b: 0f 85 77 ff ff ff jne 10c4f8 <_Scheduler_priority_Block+0x20> _Priority_Major_bit_map &= the_priority_map->block_major; 10c581: 66 8b 15 a0 67 12 00 mov 0x1267a0,%dx 10c588: 23 51 0c and 0xc(%ecx),%edx 10c58b: 66 89 15 a0 67 12 00 mov %dx,0x1267a0 10c592: e9 61 ff ff ff jmp 10c4f8 <_Scheduler_priority_Block+0x20> 10c597: 90 nop Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 10c598: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10c59a: eb b8 jmp 10c554 <_Scheduler_priority_Block+0x7c><== NOT EXECUTED =============================================================================== 0010c6ec <_Scheduler_priority_Schedule>: #include #include #include void _Scheduler_priority_Schedule(void) { 10c6ec: 55 push %ebp 10c6ed: 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 ); 10c6ef: 66 8b 0d a0 67 12 00 mov 0x1267a0,%cx 10c6f6: 31 c0 xor %eax,%eax 10c6f8: 89 c2 mov %eax,%edx 10c6fa: 66 0f bc d1 bsf %cx,%dx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10c6fe: 0f b7 d2 movzwl %dx,%edx 10c701: 66 8b 8c 12 c0 67 12 mov 0x1267c0(%edx,%edx,1),%cx 10c708: 00 10c709: 66 0f bc c1 bsf %cx,%ax return (_Priority_Bits_index( major ) << 4) + 10c70d: c1 e2 04 shl $0x4,%edx 10c710: 0f b7 c0 movzwl %ax,%eax 10c713: 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 ] ) ) 10c716: 8d 04 40 lea (%eax,%eax,2),%eax 10c719: c1 e0 02 shl $0x2,%eax 10c71c: 03 05 00 22 12 00 add 0x122200,%eax _Scheduler_priority_Schedule_body(); } 10c722: 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 ); 10c724: 83 c0 04 add $0x4,%eax 10c727: 39 c2 cmp %eax,%edx 10c729: 74 09 je 10c734 <_Scheduler_priority_Schedule+0x48><== NEVER TAKEN * * @param[in] the_thread - pointer to thread */ RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10c72b: 89 15 7c 67 12 00 mov %edx,0x12677c 10c731: c9 leave 10c732: c3 ret 10c733: 90 nop Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 10c734: 31 d2 xor %edx,%edx <== NOT EXECUTED * * @param[in] the_thread - pointer to thread */ RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10c736: 89 15 7c 67 12 00 mov %edx,0x12677c <== NOT EXECUTED 10c73c: c9 leave <== NOT EXECUTED 10c73d: c3 ret <== NOT EXECUTED =============================================================================== 0010c810 <_Scheduler_priority_Yield>: * ready chain * select heir */ void _Scheduler_priority_Yield(void) { 10c810: 55 push %ebp 10c811: 89 e5 mov %esp,%ebp 10c813: 56 push %esi 10c814: 53 push %ebx Scheduler_priority_Per_thread *sched_info; ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10c815: a1 78 67 12 00 mov 0x126778,%eax sched_info = (Scheduler_priority_Per_thread *) executing->scheduler_info; ready = sched_info->ready_chain; 10c81a: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx 10c820: 8b 12 mov (%edx),%edx _ISR_Disable( level ); 10c822: 9c pushf 10c823: fa cli 10c824: 59 pop %ecx if ( !_Chain_Has_only_one_node( ready ) ) { 10c825: 8b 5a 08 mov 0x8(%edx),%ebx 10c828: 39 1a cmp %ebx,(%edx) 10c82a: 74 40 je 10c86c <_Scheduler_priority_Yield+0x5c> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 10c82c: 8b 30 mov (%eax),%esi previous = the_node->previous; 10c82e: 8b 58 04 mov 0x4(%eax),%ebx next->previous = previous; 10c831: 89 5e 04 mov %ebx,0x4(%esi) previous->next = next; 10c834: 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; 10c836: 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 ); 10c839: 8d 72 04 lea 0x4(%edx),%esi 10c83c: 89 30 mov %esi,(%eax) Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 10c83e: 89 42 08 mov %eax,0x8(%edx) old_last->next = the_node; 10c841: 89 03 mov %eax,(%ebx) the_node->previous = old_last; 10c843: 89 58 04 mov %ebx,0x4(%eax) _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 10c846: 51 push %ecx 10c847: 9d popf 10c848: fa cli if ( _Thread_Is_heir( executing ) ) 10c849: 3b 05 7c 67 12 00 cmp 0x12677c,%eax 10c84f: 74 0f je 10c860 <_Scheduler_priority_Yield+0x50><== ALWAYS TAKEN _Thread_Heir = (Thread_Control *) _Chain_First( ready ); _Thread_Dispatch_necessary = true; } else if ( !_Thread_Is_heir( executing ) ) _Thread_Dispatch_necessary = true; 10c851: c6 05 84 67 12 00 01 movb $0x1,0x126784 _ISR_Enable( level ); 10c858: 51 push %ecx 10c859: 9d popf } 10c85a: 5b pop %ebx 10c85b: 5e pop %esi 10c85c: c9 leave 10c85d: c3 ret 10c85e: 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 ); 10c860: 8b 02 mov (%edx),%eax 10c862: a3 7c 67 12 00 mov %eax,0x12677c 10c867: eb e8 jmp 10c851 <_Scheduler_priority_Yield+0x41> 10c869: 8d 76 00 lea 0x0(%esi),%esi _Thread_Dispatch_necessary = true; } else if ( !_Thread_Is_heir( executing ) ) 10c86c: 3b 05 7c 67 12 00 cmp 0x12677c,%eax 10c872: 75 dd jne 10c851 <_Scheduler_priority_Yield+0x41><== NEVER TAKEN 10c874: eb e2 jmp 10c858 <_Scheduler_priority_Yield+0x48> =============================================================================== 0010caa4 <_Scheduler_simple_Ready_queue_Enqueue>: #include void _Scheduler_simple_Ready_queue_Enqueue( Thread_Control *the_thread ) { 10caa4: 55 push %ebp 10caa5: 89 e5 mov %esp,%ebp 10caa7: 56 push %esi 10caa8: 53 push %ebx 10caa9: 8b 75 08 mov 0x8(%ebp),%esi Chain_Control *ready; Chain_Node *the_node; Thread_Control *current; ready = (Chain_Control *)_Scheduler.information; 10caac: 8b 15 60 21 12 00 mov 0x122160,%edx } } /* enqueue */ _Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node ); } 10cab2: 8b 02 mov (%edx),%eax RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Tail(the_chain)); 10cab4: 8d 4a 04 lea 0x4(%edx),%ecx ready = (Chain_Control *)_Scheduler.information; the_node = _Chain_First( ready ); current = (Thread_Control *)ready; for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) { 10cab7: 39 c8 cmp %ecx,%eax 10cab9: 74 1a je 10cad5 <_Scheduler_simple_Ready_queue_Enqueue+0x31> current = (Thread_Control *) the_node; 10cabb: 89 c2 mov %eax,%edx /* break when AT END OR PAST our priority */ if ( the_thread->current_priority < current->current_priority ) { 10cabd: 8b 5e 14 mov 0x14(%esi),%ebx 10cac0: 3b 58 14 cmp 0x14(%eax),%ebx 10cac3: 73 0a jae 10cacf <_Scheduler_simple_Ready_queue_Enqueue+0x2b> 10cac5: eb 21 jmp 10cae8 <_Scheduler_simple_Ready_queue_Enqueue+0x44> 10cac7: 90 nop ready = (Chain_Control *)_Scheduler.information; the_node = _Chain_First( ready ); current = (Thread_Control *)ready; for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) { current = (Thread_Control *) the_node; 10cac8: 89 c2 mov %eax,%edx /* break when AT END OR PAST our priority */ if ( the_thread->current_priority < current->current_priority ) { 10caca: 39 58 14 cmp %ebx,0x14(%eax) 10cacd: 77 19 ja 10cae8 <_Scheduler_simple_Ready_queue_Enqueue+0x44> ready = (Chain_Control *)_Scheduler.information; the_node = _Chain_First( ready ); current = (Thread_Control *)ready; for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) { 10cacf: 8b 00 mov (%eax),%eax 10cad1: 39 c8 cmp %ecx,%eax 10cad3: 75 f3 jne 10cac8 <_Scheduler_simple_Ready_queue_Enqueue+0x24> Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10cad5: 89 56 04 mov %edx,0x4(%esi) before_node = after_node->next; 10cad8: 8b 02 mov (%edx),%eax after_node->next = the_node; 10cada: 89 32 mov %esi,(%edx) the_node->next = before_node; 10cadc: 89 06 mov %eax,(%esi) before_node->previous = the_node; 10cade: 89 70 04 mov %esi,0x4(%eax) } } /* enqueue */ _Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node ); } 10cae1: 5b pop %ebx 10cae2: 5e pop %esi 10cae3: c9 leave 10cae4: c3 ret 10cae5: 8d 76 00 lea 0x0(%esi),%esi for ( ; !_Chain_Is_tail( ready, the_node ) ; the_node = the_node->next ) { current = (Thread_Control *) the_node; /* break when AT END OR PAST our priority */ if ( the_thread->current_priority < current->current_priority ) { current = (Thread_Control *)current->Object.Node.previous; 10cae8: 8b 50 04 mov 0x4(%eax),%edx Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10caeb: 89 56 04 mov %edx,0x4(%esi) before_node = after_node->next; 10caee: 8b 02 mov (%edx),%eax after_node->next = the_node; 10caf0: 89 32 mov %esi,(%edx) the_node->next = before_node; 10caf2: 89 06 mov %eax,(%esi) before_node->previous = the_node; 10caf4: 89 70 04 mov %esi,0x4(%eax) } } /* enqueue */ _Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node ); } 10caf7: 5b pop %ebx 10caf8: 5e pop %esi 10caf9: c9 leave 10cafa: c3 ret =============================================================================== 0010ca74 <_Scheduler_simple_Ready_queue_Enqueue_first>: #include void _Scheduler_simple_Ready_queue_Enqueue_first( Thread_Control *the_thread ) { 10ca74: 55 push %ebp 10ca75: 89 e5 mov %esp,%ebp 10ca77: 8b 4d 08 mov 0x8(%ebp),%ecx } } /* enqueue */ _Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node ); } 10ca7a: a1 60 21 12 00 mov 0x122160,%eax 10ca7f: 8b 00 mov (%eax),%eax */ for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) { current = (Thread_Control *) the_node; /* break when AT HEAD OF (or PAST) our priority */ if ( the_thread->current_priority <= current->current_priority ) { 10ca81: 8b 51 14 mov 0x14(%ecx),%edx 10ca84: 3b 50 14 cmp 0x14(%eax),%edx 10ca87: 76 0a jbe 10ca93 <_Scheduler_simple_Ready_queue_Enqueue_first+0x1f> 10ca89: 8d 76 00 lea 0x0(%esi),%esi * Do NOT need to check for end of chain because there is always * at least one task on the ready chain -- the IDLE task. It can * never block, should never attempt to obtain a semaphore or mutex, * and thus will always be there. */ for ( the_node = _Chain_First(ready) ; ; the_node = the_node->next ) { 10ca8c: 8b 00 mov (%eax),%eax current = (Thread_Control *) the_node; /* break when AT HEAD OF (or PAST) our priority */ if ( the_thread->current_priority <= current->current_priority ) { 10ca8e: 39 50 14 cmp %edx,0x14(%eax) 10ca91: 72 f9 jb 10ca8c <_Scheduler_simple_Ready_queue_Enqueue_first+0x18><== NEVER TAKEN current = (Thread_Control *)current->Object.Node.previous; 10ca93: 8b 40 04 mov 0x4(%eax),%eax Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10ca96: 89 41 04 mov %eax,0x4(%ecx) before_node = after_node->next; 10ca99: 8b 10 mov (%eax),%edx after_node->next = the_node; 10ca9b: 89 08 mov %ecx,(%eax) the_node->next = before_node; 10ca9d: 89 11 mov %edx,(%ecx) before_node->previous = the_node; 10ca9f: 89 4a 04 mov %ecx,0x4(%edx) } } /* enqueue */ _Chain_Insert_unprotected( (Chain_Node *)current, &the_thread->Object.Node ); } 10caa2: c9 leave 10caa3: c3 ret =============================================================================== 0010ce7c <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 10ce7c: 55 push %ebp 10ce7d: 89 e5 mov %esp,%ebp 10ce7f: 53 push %ebx 10ce80: 83 ec 04 sub $0x4,%esp 10ce83: 8b 5d 08 mov 0x8(%ebp),%ebx 10ce86: a1 cc 98 12 00 mov 0x1298cc,%eax 10ce8b: 40 inc %eax 10ce8c: a3 cc 98 12 00 mov %eax,0x1298cc long seconds; _Thread_Disable_dispatch(); _TOD_Deactivate(); seconds = _TOD_Seconds_since_epoch(); 10ce91: a1 68 99 12 00 mov 0x129968,%eax if ( time->tv_sec < seconds ) 10ce96: 8b 13 mov (%ebx),%edx 10ce98: 39 d0 cmp %edx,%eax 10ce9a: 7f 34 jg 10ced0 <_TOD_Set+0x54> Watchdog_Adjust_directions direction, Watchdog_Interval units ) { _Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units ); 10ce9c: 51 push %ecx _Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec ); else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - seconds ); 10ce9d: 29 c2 sub %eax,%edx 10ce9f: 52 push %edx 10cea0: 6a 00 push $0x0 10cea2: 68 94 99 12 00 push $0x129994 10cea7: e8 7c 23 00 00 call 10f228 <_Watchdog_Adjust> 10ceac: 83 c4 10 add $0x10,%esp /* POSIX format TOD (timespec) */ _Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec ); 10ceaf: 8b 03 mov (%ebx),%eax 10ceb1: a3 68 99 12 00 mov %eax,0x129968 10ceb6: 8b 43 04 mov 0x4(%ebx),%eax 10ceb9: a3 6c 99 12 00 mov %eax,0x12996c _TOD_Is_set = true; 10cebe: c6 05 dc 98 12 00 01 movb $0x1,0x1298dc _TOD_Activate(); _Thread_Enable_dispatch(); } 10cec5: 8b 5d fc mov -0x4(%ebp),%ebx 10cec8: c9 leave _Timestamp_Set( &_TOD_Now, time->tv_sec, time->tv_nsec ); _TOD_Is_set = true; _TOD_Activate(); _Thread_Enable_dispatch(); 10cec9: e9 4e 15 00 00 jmp 10e41c <_Thread_Enable_dispatch> 10cece: 66 90 xchg %ax,%ax 10ced0: 51 push %ecx _TOD_Deactivate(); seconds = _TOD_Seconds_since_epoch(); if ( time->tv_sec < seconds ) _Watchdog_Adjust_seconds( WATCHDOG_BACKWARD, seconds - time->tv_sec ); 10ced1: 29 d0 sub %edx,%eax 10ced3: 50 push %eax 10ced4: 6a 01 push $0x1 10ced6: 68 94 99 12 00 push $0x129994 10cedb: e8 48 23 00 00 call 10f228 <_Watchdog_Adjust> 10cee0: 83 c4 10 add $0x10,%esp 10cee3: eb ca jmp 10ceaf <_TOD_Set+0x33> =============================================================================== 0010b888 <_TOD_Tickle_ticks>: * * Output parameters: NONE */ void _TOD_Tickle_ticks( void ) { 10b888: 55 push %ebp 10b889: 89 e5 mov %esp,%ebp 10b88b: 53 push %ebx 10b88c: 83 ec 1c sub $0x1c,%esp Timestamp_Control tick; uint32_t seconds; /* Convert the tick quantum to a timestamp */ _Timestamp_Set( &tick, 0, rtems_configuration_get_nanoseconds_per_tick() ); 10b88f: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) 10b896: a1 0c 23 12 00 mov 0x12230c,%eax 10b89b: 8d 04 80 lea (%eax,%eax,4),%eax 10b89e: 8d 04 80 lea (%eax,%eax,4),%eax 10b8a1: 8d 04 80 lea (%eax,%eax,4),%eax 10b8a4: c1 e0 03 shl $0x3,%eax 10b8a7: 89 45 f4 mov %eax,-0xc(%ebp) /* Update the counter of ticks since boot */ _Watchdog_Ticks_since_boot += 1; 10b8aa: a1 24 66 12 00 mov 0x126624,%eax 10b8af: 40 inc %eax 10b8b0: a3 24 66 12 00 mov %eax,0x126624 /* Update the timespec format uptime */ _Timestamp_Add_to( &_TOD_Uptime, &tick ); 10b8b5: 8d 5d f0 lea -0x10(%ebp),%ebx 10b8b8: 53 push %ebx 10b8b9: 68 78 65 12 00 push $0x126578 10b8be: e8 29 1e 00 00 call 10d6ec <_Timespec_Add_to> /* we do not care how much the uptime changed */ /* Update the timespec format TOD */ seconds = _Timestamp_Add_to_at_tick( &_TOD_Now, &tick ); 10b8c3: 58 pop %eax 10b8c4: 5a pop %edx 10b8c5: 53 push %ebx 10b8c6: 68 88 65 12 00 push $0x126588 10b8cb: e8 1c 1e 00 00 call 10d6ec <_Timespec_Add_to> 10b8d0: 89 c3 mov %eax,%ebx while ( seconds ) { 10b8d2: 83 c4 10 add $0x10,%esp 10b8d5: 85 c0 test %eax,%eax 10b8d7: 74 16 je 10b8ef <_TOD_Tickle_ticks+0x67> 10b8d9: 8d 76 00 lea 0x0(%esi),%esi */ RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void ) { _Watchdog_Tickle( &_Watchdog_Seconds_chain ); 10b8dc: 83 ec 0c sub $0xc,%esp 10b8df: 68 b4 65 12 00 push $0x1265b4 10b8e4: e8 cb 22 00 00 call 10dbb4 <_Watchdog_Tickle> 10b8e9: 83 c4 10 add $0x10,%esp 10b8ec: 4b dec %ebx 10b8ed: 75 ed jne 10b8dc <_TOD_Tickle_ticks+0x54><== NEVER TAKEN _Watchdog_Tickle_seconds(); seconds--; } } 10b8ef: 8b 5d fc mov -0x4(%ebp),%ebx 10b8f2: c9 leave 10b8f3: c3 ret =============================================================================== 0010b7bc <_TOD_To_seconds>: */ uint32_t _TOD_To_seconds( const rtems_time_of_day *the_tod ) { 10b7bc: 55 push %ebp 10b7bd: 89 e5 mov %esp,%ebp 10b7bf: 56 push %esi 10b7c0: 53 push %ebx 10b7c1: 8b 55 08 mov 0x8(%ebp),%edx uint32_t time; uint32_t year_mod_4; time = the_tod->day - 1; 10b7c4: 8b 72 08 mov 0x8(%edx),%esi 10b7c7: 4e dec %esi year_mod_4 = the_tod->year & 3; 10b7c8: 8b 02 mov (%edx),%eax if ( year_mod_4 == 0 ) 10b7ca: 89 c3 mov %eax,%ebx 10b7cc: 83 e3 03 and $0x3,%ebx 10b7cf: 74 67 je 10b838 <_TOD_To_seconds+0x7c> time += _TOD_Days_to_date[ 1 ][ the_tod->month ]; else time += _TOD_Days_to_date[ 0 ][ the_tod->month ]; 10b7d1: 8b 4a 04 mov 0x4(%edx),%ecx 10b7d4: 0f b7 8c 09 c0 27 12 movzwl 0x1227c0(%ecx,%ecx,1),%ecx 10b7db: 00 10b7dc: 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 ]; 10b7df: 0f b7 8c 1b f4 27 12 movzwl 0x1227f4(%ebx,%ebx,1),%ecx 10b7e6: 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 ) * 10b7e7: 2d c4 07 00 00 sub $0x7c4,%eax 10b7ec: c1 e8 02 shr $0x2,%eax 10b7ef: 8d 1c c0 lea (%eax,%eax,8),%ebx 10b7f2: 8d 1c d8 lea (%eax,%ebx,8),%ebx 10b7f5: 8d 1c 9b lea (%ebx,%ebx,4),%ebx 10b7f8: 8d 04 98 lea (%eax,%ebx,4),%eax 10b7fb: 01 c1 add %eax,%ecx ( (TOD_DAYS_PER_YEAR * 4) + 1); time += _TOD_Days_since_last_leap_year[ year_mod_4 ]; 10b7fd: 01 f1 add %esi,%ecx time *= TOD_SECONDS_PER_DAY; 10b7ff: 8d 04 89 lea (%ecx,%ecx,4),%eax 10b802: 8d 04 81 lea (%ecx,%eax,4),%eax 10b805: 8d 04 c1 lea (%ecx,%eax,8),%eax 10b808: c1 e0 02 shl $0x2,%eax 10b80b: 29 c8 sub %ecx,%eax 10b80d: c1 e0 07 shl $0x7,%eax time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute) 10b810: 8b 5a 14 mov 0x14(%edx),%ebx 10b813: 8b 4a 0c mov 0xc(%edx),%ecx 10b816: 8d 0c 49 lea (%ecx,%ecx,2),%ecx 10b819: 8d 0c 89 lea (%ecx,%ecx,4),%ecx 10b81c: c1 e1 02 shl $0x2,%ecx 10b81f: 03 4a 10 add 0x10(%edx),%ecx * TOD_SECONDS_PER_MINUTE; 10b822: 8d 14 49 lea (%ecx,%ecx,2),%edx 10b825: 8d 14 92 lea (%edx,%edx,4),%edx time += the_tod->second; 10b828: 8d 94 93 00 e5 da 21 lea 0x21dae500(%ebx,%edx,4),%edx time += TOD_SECONDS_1970_THROUGH_1988; 10b82f: 8d 04 02 lea (%edx,%eax,1),%eax return( time ); } 10b832: 5b pop %ebx 10b833: 5e pop %esi 10b834: c9 leave 10b835: c3 ret 10b836: 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 ]; 10b838: 8b 4a 04 mov 0x4(%edx),%ecx 10b83b: 0f b7 8c 09 da 27 12 movzwl 0x1227da(%ecx,%ecx,1),%ecx 10b842: 00 10b843: 8d 34 31 lea (%ecx,%esi,1),%esi 10b846: eb 97 jmp 10b7df <_TOD_To_seconds+0x23> =============================================================================== 0010b848 <_TOD_Validate>: */ bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 10b848: 55 push %ebp 10b849: 89 e5 mov %esp,%ebp 10b84b: 53 push %ebx 10b84c: 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(); 10b84f: 8b 1d 6c 52 12 00 mov 0x12526c,%ebx if ((!the_tod) || 10b855: 85 c9 test %ecx,%ecx 10b857: 74 53 je 10b8ac <_TOD_Validate+0x64> <== NEVER TAKEN ) { uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 10b859: b8 40 42 0f 00 mov $0xf4240,%eax 10b85e: 31 d2 xor %edx,%edx 10b860: f7 f3 div %ebx rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 10b862: 3b 41 18 cmp 0x18(%ecx),%eax 10b865: 76 45 jbe 10b8ac <_TOD_Validate+0x64> (the_tod->ticks >= ticks_per_second) || 10b867: 83 79 14 3b cmpl $0x3b,0x14(%ecx) 10b86b: 77 3f ja 10b8ac <_TOD_Validate+0x64> (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 10b86d: 83 79 10 3b cmpl $0x3b,0x10(%ecx) 10b871: 77 39 ja 10b8ac <_TOD_Validate+0x64> (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 10b873: 83 79 0c 17 cmpl $0x17,0xc(%ecx) 10b877: 77 33 ja 10b8ac <_TOD_Validate+0x64> (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 10b879: 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) || 10b87c: 85 c0 test %eax,%eax 10b87e: 74 2c je 10b8ac <_TOD_Validate+0x64> <== NEVER TAKEN (the_tod->month == 0) || 10b880: 83 f8 0c cmp $0xc,%eax 10b883: 77 27 ja 10b8ac <_TOD_Validate+0x64> (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 10b885: 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) || 10b887: 81 fa c3 07 00 00 cmp $0x7c3,%edx 10b88d: 76 1d jbe 10b8ac <_TOD_Validate+0x64> (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) 10b88f: 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) || 10b892: 85 c9 test %ecx,%ecx 10b894: 74 16 je 10b8ac <_TOD_Validate+0x64> <== NEVER TAKEN (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 10b896: 83 e2 03 and $0x3,%edx 10b899: 75 16 jne 10b8b1 <_TOD_Validate+0x69> days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 10b89b: 8b 04 85 34 28 12 00 mov 0x122834(,%eax,4),%eax * false - if the the_tod is invalid * * NOTE: This routine only works for leap-years through 2099. */ bool _TOD_Validate( 10b8a2: 39 c8 cmp %ecx,%eax 10b8a4: 0f 93 c0 setae %al 10b8a7: eb 05 jmp 10b8ae <_TOD_Validate+0x66> 10b8a9: 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; 10b8ac: 31 c0 xor %eax,%eax if ( the_tod->day > days_in_month ) return false; return true; } 10b8ae: 5b pop %ebx 10b8af: c9 leave 10b8b0: 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 ]; 10b8b1: 8b 04 85 00 28 12 00 mov 0x122800(,%eax,4),%eax 10b8b8: eb e8 jmp 10b8a2 <_TOD_Validate+0x5a> =============================================================================== 0010c8c4 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10c8c4: 55 push %ebp 10c8c5: 89 e5 mov %esp,%ebp 10c8c7: 57 push %edi 10c8c8: 56 push %esi 10c8c9: 53 push %ebx 10c8ca: 83 ec 28 sub $0x28,%esp 10c8cd: 8b 5d 08 mov 0x8(%ebp),%ebx 10c8d0: 8b 75 0c mov 0xc(%ebp),%esi 10c8d3: 8a 45 10 mov 0x10(%ebp),%al 10c8d6: 88 45 e7 mov %al,-0x19(%ebp) States_Control state, original_state; /* * Save original state */ original_state = the_thread->current_state; 10c8d9: 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 ); 10c8dc: 53 push %ebx 10c8dd: e8 4a 0c 00 00 call 10d52c <_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 ) 10c8e2: 83 c4 10 add $0x10,%esp 10c8e5: 39 73 14 cmp %esi,0x14(%ebx) 10c8e8: 74 0d je 10c8f7 <_Thread_Change_priority+0x33> _Thread_Set_priority( the_thread, new_priority ); 10c8ea: 83 ec 08 sub $0x8,%esp 10c8ed: 56 push %esi 10c8ee: 53 push %ebx 10c8ef: e8 e4 0b 00 00 call 10d4d8 <_Thread_Set_priority> 10c8f4: 83 c4 10 add $0x10,%esp _ISR_Disable( level ); 10c8f7: 9c pushf 10c8f8: fa cli 10c8f9: 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; 10c8fa: 8b 43 10 mov 0x10(%ebx),%eax if ( state != STATES_TRANSIENT ) { 10c8fd: 83 f8 04 cmp $0x4,%eax 10c900: 74 22 je 10c924 <_Thread_Change_priority+0x60> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10c902: 83 e7 04 and $0x4,%edi 10c905: 74 11 je 10c918 <_Thread_Change_priority+0x54><== ALWAYS TAKEN the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); 10c907: 56 push %esi 10c908: 9d popf if ( _States_Is_waiting_on_thread_queue( state ) ) { 10c909: a9 e0 be 03 00 test $0x3bee0,%eax 10c90e: 75 60 jne 10c970 <_Thread_Change_priority+0xac> if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; _ISR_Enable( level ); } 10c910: 8d 65 f4 lea -0xc(%ebp),%esp 10c913: 5b pop %ebx 10c914: 5e pop %esi 10c915: 5f pop %edi 10c916: c9 leave 10c917: c3 ret RTEMS_INLINE_ROUTINE States_Control _States_Clear ( States_Control states_to_clear, States_Control current_state ) { return (current_state & ~states_to_clear); 10c918: 89 c2 mov %eax,%edx 10c91a: 83 e2 fb and $0xfffffffb,%edx 10c91d: 89 53 10 mov %edx,0x10(%ebx) 10c920: eb e5 jmp 10c907 <_Thread_Change_priority+0x43> 10c922: 66 90 xchg %ax,%ax } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10c924: 83 e7 04 and $0x4,%edi 10c927: 75 1a jne 10c943 <_Thread_Change_priority+0x7f><== NEVER TAKEN * Interrupts are STILL disabled. * We now know the thread will be in the READY state when we remove * the TRANSIENT state. So we have to place it on the appropriate * Ready Queue with interrupts off. */ the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10c929: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) if ( prepend_it ) 10c930: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10c934: 74 52 je 10c988 <_Thread_Change_priority+0xc4> */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue_first( the_thread ); 10c936: 83 ec 0c sub $0xc,%esp 10c939: 53 push %ebx 10c93a: ff 15 28 22 12 00 call *0x122228 10c940: 83 c4 10 add $0x10,%esp _Scheduler_Enqueue_first( the_thread ); else _Scheduler_Enqueue( the_thread ); } _ISR_Flash( level ); 10c943: 56 push %esi 10c944: 9d popf 10c945: fa cli * This kernel routine implements the scheduling decision logic for * the scheduler. It does NOT dispatch. */ RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( void ) { _Scheduler.Operations.schedule(); 10c946: ff 15 08 22 12 00 call *0x122208 * is also the heir thread, and false otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void ) { return ( _Thread_Executing == _Thread_Heir ); 10c94c: a1 78 67 12 00 mov 0x126778,%eax * We altered the set of thread priorities. So let's figure out * who is the heir and if we need to switch to them. */ _Scheduler_Schedule(); if ( !_Thread_Is_executing_also_the_heir() && 10c951: 3b 05 7c 67 12 00 cmp 0x12677c,%eax 10c957: 74 0d je 10c966 <_Thread_Change_priority+0xa2> 10c959: 80 78 74 00 cmpb $0x0,0x74(%eax) 10c95d: 74 07 je 10c966 <_Thread_Change_priority+0xa2> _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; 10c95f: c6 05 84 67 12 00 01 movb $0x1,0x126784 _ISR_Enable( level ); 10c966: 56 push %esi 10c967: 9d popf } 10c968: 8d 65 f4 lea -0xc(%ebp),%esp 10c96b: 5b pop %ebx 10c96c: 5e pop %esi 10c96d: 5f pop %edi 10c96e: c9 leave 10c96f: c3 ret /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); if ( _States_Is_waiting_on_thread_queue( state ) ) { _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10c970: 89 5d 0c mov %ebx,0xc(%ebp) 10c973: 8b 43 44 mov 0x44(%ebx),%eax 10c976: 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 ); } 10c979: 8d 65 f4 lea -0xc(%ebp),%esp 10c97c: 5b pop %ebx 10c97d: 5e pop %esi 10c97e: 5f pop %edi 10c97f: 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 ); 10c980: e9 bb 0a 00 00 jmp 10d440 <_Thread_queue_Requeue> 10c985: 8d 76 00 lea 0x0(%esi),%esi */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue( the_thread ); 10c988: 83 ec 0c sub $0xc,%esp 10c98b: 53 push %ebx 10c98c: ff 15 24 22 12 00 call *0x122224 10c992: 83 c4 10 add $0x10,%esp 10c995: eb ac jmp 10c943 <_Thread_Change_priority+0x7f> =============================================================================== 0010c998 <_Thread_Clear_state>: */ void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 10c998: 55 push %ebp 10c999: 89 e5 mov %esp,%ebp 10c99b: 53 push %ebx 10c99c: 83 ec 04 sub $0x4,%esp 10c99f: 8b 55 08 mov 0x8(%ebp),%edx 10c9a2: 8b 45 0c mov 0xc(%ebp),%eax ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10c9a5: 9c pushf 10c9a6: fa cli 10c9a7: 5b pop %ebx current_state = the_thread->current_state; 10c9a8: 8b 4a 10 mov 0x10(%edx),%ecx if ( current_state & state ) { 10c9ab: 85 c8 test %ecx,%eax 10c9ad: 74 0b je 10c9ba <_Thread_Clear_state+0x22> 10c9af: f7 d0 not %eax 10c9b1: 21 c8 and %ecx,%eax current_state = the_thread->current_state = _States_Clear( state, current_state ); 10c9b3: 89 42 10 mov %eax,0x10(%edx) if ( _States_Is_ready( current_state ) ) { 10c9b6: 85 c0 test %eax,%eax 10c9b8: 74 0a je 10c9c4 <_Thread_Clear_state+0x2c> _Scheduler_Unblock( the_thread ); } } _ISR_Enable( level ); 10c9ba: 53 push %ebx 10c9bb: 9d popf } 10c9bc: 8b 5d fc mov -0x4(%ebp),%ebx 10c9bf: c9 leave 10c9c0: c3 ret 10c9c1: 8d 76 00 lea 0x0(%esi),%esi */ RTEMS_INLINE_ROUTINE void _Scheduler_Unblock( Thread_Control *the_thread ) { _Scheduler.Operations.unblock( the_thread ); 10c9c4: 83 ec 0c sub $0xc,%esp 10c9c7: 52 push %edx 10c9c8: ff 15 14 22 12 00 call *0x122214 10c9ce: 83 c4 10 add $0x10,%esp 10c9d1: eb e7 jmp 10c9ba <_Thread_Clear_state+0x22> =============================================================================== 0010cb48 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 10cb48: 55 push %ebp 10cb49: 89 e5 mov %esp,%ebp 10cb4b: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10cb4e: 8d 45 f4 lea -0xc(%ebp),%eax 10cb51: 50 push %eax 10cb52: ff 75 08 pushl 0x8(%ebp) 10cb55: e8 c6 01 00 00 call 10cd20 <_Thread_Get> switch ( location ) { 10cb5a: 83 c4 10 add $0x10,%esp 10cb5d: 8b 55 f4 mov -0xc(%ebp),%edx 10cb60: 85 d2 test %edx,%edx 10cb62: 75 1c jne 10cb80 <_Thread_Delay_ended+0x38><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_Clear_state( 10cb64: 83 ec 08 sub $0x8,%esp 10cb67: 68 18 00 00 10 push $0x10000018 10cb6c: 50 push %eax 10cb6d: e8 26 fe ff ff call 10c998 <_Thread_Clear_state> 10cb72: a1 ec 64 12 00 mov 0x1264ec,%eax 10cb77: 48 dec %eax 10cb78: a3 ec 64 12 00 mov %eax,0x1264ec 10cb7d: 83 c4 10 add $0x10,%esp | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Thread_Unnest_dispatch(); break; } } 10cb80: c9 leave 10cb81: c3 ret =============================================================================== 0010cb84 <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10cb84: 55 push %ebp 10cb85: 89 e5 mov %esp,%ebp 10cb87: 57 push %edi 10cb88: 56 push %esi 10cb89: 53 push %ebx 10cb8a: 83 ec 1c sub $0x1c,%esp Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10cb8d: 8b 1d 78 67 12 00 mov 0x126778,%ebx _ISR_Disable( level ); 10cb93: 9c pushf 10cb94: fa cli 10cb95: 58 pop %eax while ( _Thread_Dispatch_necessary == true ) { 10cb96: 8a 15 84 67 12 00 mov 0x126784,%dl 10cb9c: 84 d2 test %dl,%dl 10cb9e: 0f 84 3c 01 00 00 je 10cce0 <_Thread_Dispatch+0x15c> heir = _Thread_Heir; 10cba4: 8b 35 7c 67 12 00 mov 0x12677c,%esi _Thread_Dispatch_disable_level = 1; 10cbaa: c7 05 ec 64 12 00 01 movl $0x1,0x1264ec 10cbb1: 00 00 00 _Thread_Dispatch_necessary = false; 10cbb4: c6 05 84 67 12 00 00 movb $0x0,0x126784 _Thread_Executing = heir; 10cbbb: 89 35 78 67 12 00 mov %esi,0x126778 /* * 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 ) 10cbc1: 39 f3 cmp %esi,%ebx 10cbc3: 0f 84 17 01 00 00 je 10cce0 <_Thread_Dispatch+0x15c> 10cbc9: 8d 7d d8 lea -0x28(%ebp),%edi 10cbcc: e9 f5 00 00 00 jmp 10ccc6 <_Thread_Dispatch+0x142> 10cbd1: 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 ); 10cbd4: 50 push %eax 10cbd5: 9d popf #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); 10cbd6: 83 ec 0c sub $0xc,%esp 10cbd9: 8d 45 e0 lea -0x20(%ebp),%eax 10cbdc: 50 push %eax 10cbdd: e8 46 36 00 00 call 110228 <_TOD_Get_uptime> _Timestamp_Subtract( 10cbe2: 83 c4 0c add $0xc,%esp 10cbe5: 57 push %edi 10cbe6: 8d 45 e0 lea -0x20(%ebp),%eax 10cbe9: 50 push %eax 10cbea: 68 ac 65 12 00 push $0x1265ac 10cbef: e8 34 0b 00 00 call 10d728 <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timestamp_Add_to( &executing->cpu_time_used, &ran ); 10cbf4: 58 pop %eax 10cbf5: 5a pop %edx 10cbf6: 57 push %edi 10cbf7: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10cbfd: 50 push %eax 10cbfe: e8 e9 0a 00 00 call 10d6ec <_Timespec_Add_to> _Thread_Time_of_last_context_switch = uptime; 10cc03: 8b 45 e0 mov -0x20(%ebp),%eax 10cc06: 8b 55 e4 mov -0x1c(%ebp),%edx 10cc09: a3 ac 65 12 00 mov %eax,0x1265ac 10cc0e: 89 15 b0 65 12 00 mov %edx,0x1265b0 #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10cc14: a1 84 65 12 00 mov 0x126584,%eax 10cc19: 83 c4 10 add $0x10,%esp 10cc1c: 85 c0 test %eax,%eax 10cc1e: 74 10 je 10cc30 <_Thread_Dispatch+0xac> <== NEVER TAKEN executing->libc_reent = *_Thread_libc_reent; 10cc20: 8b 10 mov (%eax),%edx 10cc22: 89 93 e0 00 00 00 mov %edx,0xe0(%ebx) *_Thread_libc_reent = heir->libc_reent; 10cc28: 8b 96 e0 00 00 00 mov 0xe0(%esi),%edx 10cc2e: 89 10 mov %edx,(%eax) } _User_extensions_Thread_switch( executing, heir ); 10cc30: 83 ec 08 sub $0x8,%esp 10cc33: 56 push %esi 10cc34: 53 push %ebx 10cc35: e8 8e 0d 00 00 call 10d9c8 <_User_extensions_Thread_switch> if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10cc3a: 5a pop %edx 10cc3b: 59 pop %ecx 10cc3c: 81 c6 c4 00 00 00 add $0xc4,%esi 10cc42: 56 push %esi 10cc43: 8d 83 c4 00 00 00 lea 0xc4(%ebx),%eax 10cc49: 50 push %eax 10cc4a: e8 81 10 00 00 call 10dcd0 <_CPU_Context_switch> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10cc4f: 83 c4 10 add $0x10,%esp 10cc52: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax 10cc58: 85 c0 test %eax,%eax 10cc5a: 74 36 je 10cc92 <_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 ); 10cc5c: a1 80 65 12 00 mov 0x126580,%eax 10cc61: 39 c3 cmp %eax,%ebx 10cc63: 74 2d je 10cc92 <_Thread_Dispatch+0x10e> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10cc65: 85 c0 test %eax,%eax 10cc67: 74 11 je 10cc7a <_Thread_Dispatch+0xf6> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10cc69: 83 ec 0c sub $0xc,%esp 10cc6c: 05 dc 00 00 00 add $0xdc,%eax 10cc71: 50 push %eax 10cc72: e8 8d 10 00 00 call 10dd04 <_CPU_Context_save_fp> 10cc77: 83 c4 10 add $0x10,%esp _Context_Restore_fp( &executing->fp_context ); 10cc7a: 83 ec 0c sub $0xc,%esp 10cc7d: 8d 83 dc 00 00 00 lea 0xdc(%ebx),%eax 10cc83: 50 push %eax 10cc84: e8 85 10 00 00 call 10dd0e <_CPU_Context_restore_fp> _Thread_Allocated_fp = executing; 10cc89: 89 1d 80 65 12 00 mov %ebx,0x126580 10cc8f: 83 c4 10 add $0x10,%esp if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10cc92: 8b 1d 78 67 12 00 mov 0x126778,%ebx _ISR_Disable( level ); 10cc98: 9c pushf 10cc99: fa cli 10cc9a: 58 pop %eax Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10cc9b: 8a 15 84 67 12 00 mov 0x126784,%dl 10cca1: 84 d2 test %dl,%dl 10cca3: 74 3b je 10cce0 <_Thread_Dispatch+0x15c> heir = _Thread_Heir; 10cca5: 8b 35 7c 67 12 00 mov 0x12677c,%esi _Thread_Dispatch_disable_level = 1; 10ccab: c7 05 ec 64 12 00 01 movl $0x1,0x1264ec 10ccb2: 00 00 00 _Thread_Dispatch_necessary = false; 10ccb5: c6 05 84 67 12 00 00 movb $0x0,0x126784 _Thread_Executing = heir; 10ccbc: 89 35 78 67 12 00 mov %esi,0x126778 /* * 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 ) 10ccc2: 39 de cmp %ebx,%esi 10ccc4: 74 1a je 10cce0 <_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 ) 10ccc6: 83 7e 7c 01 cmpl $0x1,0x7c(%esi) 10ccca: 0f 85 04 ff ff ff jne 10cbd4 <_Thread_Dispatch+0x50> heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10ccd0: 8b 15 c0 64 12 00 mov 0x1264c0,%edx 10ccd6: 89 56 78 mov %edx,0x78(%esi) 10ccd9: e9 f6 fe ff ff jmp 10cbd4 <_Thread_Dispatch+0x50> 10ccde: 66 90 xchg %ax,%ax _ISR_Disable( level ); } post_switch: _Thread_Dispatch_disable_level = 0; 10cce0: c7 05 ec 64 12 00 00 movl $0x0,0x1264ec 10cce7: 00 00 00 _ISR_Enable( level ); 10ccea: 50 push %eax 10cceb: 9d popf _API_extensions_Run_postswitch(); 10ccec: e8 83 e6 ff ff call 10b374 <_API_extensions_Run_postswitch> } 10ccf1: 8d 65 f4 lea -0xc(%ebp),%esp 10ccf4: 5b pop %ebx 10ccf5: 5e pop %esi 10ccf6: 5f pop %edi 10ccf7: c9 leave 10ccf8: c3 ret =============================================================================== 0010cd20 <_Thread_Get>: */ Thread_Control *_Thread_Get ( Objects_Id id, Objects_Locations *location ) { 10cd20: 55 push %ebp 10cd21: 89 e5 mov %esp,%ebp 10cd23: 53 push %ebx 10cd24: 83 ec 04 sub $0x4,%esp 10cd27: 8b 45 08 mov 0x8(%ebp),%eax 10cd2a: 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 ) ) { 10cd2d: 85 c0 test %eax,%eax 10cd2f: 74 4b je 10cd7c <_Thread_Get+0x5c> */ RTEMS_INLINE_ROUTINE Objects_APIs _Objects_Get_API( Objects_Id id ) { return (Objects_APIs) ((id >> OBJECTS_API_START_BIT) & OBJECTS_API_VALID_BITS); 10cd31: 89 c2 mov %eax,%edx 10cd33: c1 ea 18 shr $0x18,%edx 10cd36: 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 ) 10cd39: 8d 5a ff lea -0x1(%edx),%ebx 10cd3c: 83 fb 02 cmp $0x2,%ebx 10cd3f: 77 2b ja 10cd6c <_Thread_Get+0x4c> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10cd41: 89 c3 mov %eax,%ebx 10cd43: 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 :) */ 10cd46: 4b dec %ebx 10cd47: 75 23 jne 10cd6c <_Thread_Get+0x4c> *location = OBJECTS_ERROR; goto done; } api_information = _Objects_Information_table[ the_api ]; 10cd49: 8b 14 95 c4 64 12 00 mov 0x1264c4(,%edx,4),%edx * There is no way for this to happen if POSIX is enabled. But there * is actually a test case in sp43 for this which trips it whether or * not POSIX is enabled. So in the interest of safety, this is left * on in all configurations. */ if ( !api_information ) { 10cd50: 85 d2 test %edx,%edx 10cd52: 74 18 je 10cd6c <_Thread_Get+0x4c> *location = OBJECTS_ERROR; goto done; } information = api_information[ the_class ]; 10cd54: 8b 52 04 mov 0x4(%edx),%edx if ( !information ) { 10cd57: 85 d2 test %edx,%edx 10cd59: 74 11 je 10cd6c <_Thread_Get+0x4c> *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 10cd5b: 53 push %ebx 10cd5c: 51 push %ecx 10cd5d: 50 push %eax 10cd5e: 52 push %edx 10cd5f: e8 48 f4 ff ff call 10c1ac <_Objects_Get> 10cd64: 83 c4 10 add $0x10,%esp done: return tp; } 10cd67: 8b 5d fc mov -0x4(%ebp),%ebx 10cd6a: c9 leave 10cd6b: c3 ret goto done; } information = api_information[ the_class ]; if ( !information ) { *location = OBJECTS_ERROR; 10cd6c: 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; 10cd72: 31 c0 xor %eax,%eax tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10cd74: 8b 5d fc mov -0x4(%ebp),%ebx 10cd77: c9 leave 10cd78: c3 ret 10cd79: 8d 76 00 lea 0x0(%esi),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10cd7c: a1 ec 64 12 00 mov 0x1264ec,%eax 10cd81: 40 inc %eax 10cd82: a3 ec 64 12 00 mov %eax,0x1264ec 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; 10cd87: c7 01 00 00 00 00 movl $0x0,(%ecx) tp = _Thread_Executing; 10cd8d: a1 78 67 12 00 mov 0x126778,%eax tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10cd92: 8b 5d fc mov -0x4(%ebp),%ebx 10cd95: c9 leave 10cd96: c3 ret =============================================================================== 00111c68 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 111c68: 55 push %ebp 111c69: 89 e5 mov %esp,%ebp 111c6b: 53 push %ebx 111c6c: 83 ec 14 sub $0x14,%esp #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing; 111c6f: 8b 1d 78 67 12 00 mov 0x126778,%ebx /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 111c75: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax _ISR_Set_level(level); 111c7b: 85 c0 test %eax,%eax 111c7d: 74 79 je 111cf8 <_Thread_Handler+0x90> 111c7f: fa cli #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) doneCons = doneConstructors; 111c80: a0 54 61 12 00 mov 0x126154,%al 111c85: 88 45 f7 mov %al,-0x9(%ebp) doneConstructors = 1; 111c88: c6 05 54 61 12 00 01 movb $0x1,0x126154 #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 111c8f: 8b 93 dc 00 00 00 mov 0xdc(%ebx),%edx 111c95: 85 d2 test %edx,%edx 111c97: 74 24 je 111cbd <_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 ); 111c99: a1 80 65 12 00 mov 0x126580,%eax 111c9e: 39 c3 cmp %eax,%ebx 111ca0: 74 1b je 111cbd <_Thread_Handler+0x55> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 111ca2: 85 c0 test %eax,%eax 111ca4: 74 11 je 111cb7 <_Thread_Handler+0x4f> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 111ca6: 83 ec 0c sub $0xc,%esp 111ca9: 05 dc 00 00 00 add $0xdc,%eax 111cae: 50 push %eax 111caf: e8 50 c0 ff ff call 10dd04 <_CPU_Context_save_fp> 111cb4: 83 c4 10 add $0x10,%esp _Thread_Allocated_fp = executing; 111cb7: 89 1d 80 65 12 00 mov %ebx,0x126580 /* * 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 ); 111cbd: 83 ec 0c sub $0xc,%esp 111cc0: 53 push %ebx 111cc1: e8 66 bb ff ff call 10d82c <_User_extensions_Thread_begin> /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 111cc6: e8 31 b0 ff ff call 10ccfc <_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) */ { 111ccb: 83 c4 10 add $0x10,%esp 111cce: 80 7d f7 00 cmpb $0x0,-0x9(%ebp) 111cd2: 74 28 je 111cfc <_Thread_Handler+0x94> INIT_NAME (); } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 111cd4: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 111cda: 85 c0 test %eax,%eax 111cdc: 74 2d je 111d0b <_Thread_Handler+0xa3> <== 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 ); 111cde: 83 ec 0c sub $0xc,%esp 111ce1: 53 push %ebx 111ce2: e8 81 bb ff ff call 10d868 <_User_extensions_Thread_exitted> _Internal_error_Occurred( 111ce7: 83 c4 0c add $0xc,%esp 111cea: 6a 05 push $0x5 111cec: 6a 01 push $0x1 111cee: 6a 00 push $0x0 111cf0: e8 73 9f ff ff call 10bc68 <_Internal_error_Occurred> 111cf5: 8d 76 00 lea 0x0(%esi),%esi * 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); 111cf8: fb sti 111cf9: eb 85 jmp 111c80 <_Thread_Handler+0x18> 111cfb: 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 (); 111cfc: e8 ef c6 00 00 call 11e3f0 <__start_set_sysctl_set> } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 111d01: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 111d07: 85 c0 test %eax,%eax 111d09: 75 d3 jne 111cde <_Thread_Handler+0x76> <== NEVER TAKEN executing->Wait.return_argument = (*(Thread_Entry_numeric) executing->Start.entry_point)( 111d0b: 83 ec 0c sub $0xc,%esp 111d0e: ff b3 9c 00 00 00 pushl 0x9c(%ebx) 111d14: ff 93 90 00 00 00 call *0x90(%ebx) INIT_NAME (); } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { executing->Wait.return_argument = 111d1a: 89 43 28 mov %eax,0x28(%ebx) 111d1d: 83 c4 10 add $0x10,%esp 111d20: eb bc jmp 111cde <_Thread_Handler+0x76> =============================================================================== 0010cd98 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10cd98: 55 push %ebp 10cd99: 89 e5 mov %esp,%ebp 10cd9b: 57 push %edi 10cd9c: 56 push %esi 10cd9d: 53 push %ebx 10cd9e: 83 ec 24 sub $0x24,%esp 10cda1: 8b 5d 0c mov 0xc(%ebp),%ebx 10cda4: 8b 75 14 mov 0x14(%ebp),%esi 10cda7: 0f b6 7d 18 movzbl 0x18(%ebp),%edi 10cdab: 8a 45 20 mov 0x20(%ebp),%al 10cdae: 88 45 e4 mov %al,-0x1c(%ebp) /* * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; 10cdb1: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10cdb8: 00 00 00 10cdbb: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx) 10cdc2: 00 00 00 extensions_area = NULL; the_thread->libc_reent = NULL; 10cdc5: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx) 10cdcc: 00 00 00 /* * Allocate and Initialize the stack for this thread. */ #if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API) actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10cdcf: 56 push %esi 10cdd0: 53 push %ebx 10cdd1: e8 86 07 00 00 call 10d55c <_Thread_Stack_Allocate> if ( !actual_stack_size || actual_stack_size < stack_size ) 10cdd6: 83 c4 10 add $0x10,%esp 10cdd9: 85 c0 test %eax,%eax 10cddb: 0f 84 5b 01 00 00 je 10cf3c <_Thread_Initialize+0x1a4> 10cde1: 39 c6 cmp %eax,%esi 10cde3: 0f 87 53 01 00 00 ja 10cf3c <_Thread_Initialize+0x1a4><== NEVER TAKEN Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 10cde9: 8b 93 c0 00 00 00 mov 0xc0(%ebx),%edx 10cdef: 89 93 b8 00 00 00 mov %edx,0xb8(%ebx) the_stack->size = size; 10cdf5: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 10cdfb: 89 f8 mov %edi,%eax 10cdfd: 84 c0 test %al,%al 10cdff: 0f 85 47 01 00 00 jne 10cf4c <_Thread_Initialize+0x1b4> 10ce05: 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; 10ce07: 31 ff xor %edi,%edi 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; 10ce09: 89 83 dc 00 00 00 mov %eax,0xdc(%ebx) the_thread->Start.fp_context = fp_area; 10ce0f: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10ce15: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) the_watchdog->routine = routine; 10ce1c: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) the_watchdog->id = id; 10ce23: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) the_watchdog->user_data = user_data; 10ce2a: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10ce31: a1 90 65 12 00 mov 0x126590,%eax 10ce36: 85 c0 test %eax,%eax 10ce38: 0f 85 36 01 00 00 jne 10cf74 <_Thread_Initialize+0x1dc> (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) goto failed; } the_thread->extensions = (void **) extensions_area; 10ce3e: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx) 10ce45: 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; 10ce48: 31 f6 xor %esi,%esi /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10ce4a: 8a 45 e4 mov -0x1c(%ebp),%al 10ce4d: 88 83 a0 00 00 00 mov %al,0xa0(%ebx) the_thread->Start.budget_algorithm = budget_algorithm; 10ce53: 8b 45 24 mov 0x24(%ebp),%eax 10ce56: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) the_thread->Start.budget_callout = budget_callout; 10ce5c: 8b 45 28 mov 0x28(%ebp),%eax 10ce5f: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; #endif } the_thread->Start.isr_level = isr_level; 10ce65: 8b 45 2c mov 0x2c(%ebp),%eax 10ce68: 89 83 ac 00 00 00 mov %eax,0xac(%ebx) the_thread->current_state = STATES_DORMANT; 10ce6e: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) the_thread->Wait.queue = NULL; 10ce75: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) the_thread->resource_count = 0; 10ce7c: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->real_priority = priority; 10ce83: 8b 45 1c mov 0x1c(%ebp),%eax 10ce86: 89 43 18 mov %eax,0x18(%ebx) the_thread->Start.initial_priority = priority; 10ce89: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx) */ RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate( Thread_Control *the_thread ) { return _Scheduler.Operations.allocate( the_thread ); 10ce8f: 83 ec 0c sub $0xc,%esp 10ce92: 53 push %ebx 10ce93: ff 15 18 22 12 00 call *0x122218 10ce99: 89 45 e4 mov %eax,-0x1c(%ebp) sched =_Scheduler_Allocate( the_thread ); if ( !sched ) 10ce9c: 83 c4 10 add $0x10,%esp 10ce9f: 85 c0 test %eax,%eax 10cea1: 74 42 je 10cee5 <_Thread_Initialize+0x14d> goto failed; _Thread_Set_priority( the_thread, priority ); 10cea3: 83 ec 08 sub $0x8,%esp 10cea6: ff 75 1c pushl 0x1c(%ebp) 10cea9: 53 push %ebx 10ceaa: e8 29 06 00 00 call 10d4d8 <_Thread_Set_priority> /* * Initialize the CPU usage statistics */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Set_to_zero( &the_thread->cpu_time_used ); 10ceaf: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) 10ceb6: 00 00 00 10ceb9: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) 10cec0: 00 00 00 _Workspace_Free( sched ); _Thread_Stack_Free( the_thread ); return false; } 10cec3: 8b 45 08 mov 0x8(%ebp),%eax 10cec6: 8b 40 1c mov 0x1c(%eax),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10cec9: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10cecd: 89 1c 90 mov %ebx,(%eax,%edx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10ced0: 8b 45 30 mov 0x30(%ebp),%eax 10ced3: 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 ); 10ced6: 89 1c 24 mov %ebx,(%esp) 10ced9: e8 16 0a 00 00 call 10d8f4 <_User_extensions_Thread_create> if ( extension_status ) 10cede: 83 c4 10 add $0x10,%esp 10cee1: 84 c0 test %al,%al 10cee3: 75 63 jne 10cf48 <_Thread_Initialize+0x1b0> return true; failed: _Workspace_Free( the_thread->libc_reent ); 10cee5: 83 ec 0c sub $0xc,%esp 10cee8: ff b3 e0 00 00 00 pushl 0xe0(%ebx) 10ceee: e8 99 0d 00 00 call 10dc8c <_Workspace_Free> for ( i=0 ; i <= THREAD_API_LAST ; i++ ) _Workspace_Free( the_thread->API_Extensions[i] ); 10cef3: 59 pop %ecx 10cef4: ff b3 e4 00 00 00 pushl 0xe4(%ebx) 10cefa: e8 8d 0d 00 00 call 10dc8c <_Workspace_Free> 10ceff: 5a pop %edx 10cf00: ff b3 e8 00 00 00 pushl 0xe8(%ebx) 10cf06: e8 81 0d 00 00 call 10dc8c <_Workspace_Free> _Workspace_Free( extensions_area ); 10cf0b: 89 34 24 mov %esi,(%esp) 10cf0e: e8 79 0d 00 00 call 10dc8c <_Workspace_Free> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Workspace_Free( fp_area ); 10cf13: 89 3c 24 mov %edi,(%esp) 10cf16: e8 71 0d 00 00 call 10dc8c <_Workspace_Free> #endif _Workspace_Free( sched ); 10cf1b: 58 pop %eax 10cf1c: ff 75 e4 pushl -0x1c(%ebp) 10cf1f: e8 68 0d 00 00 call 10dc8c <_Workspace_Free> _Thread_Stack_Free( the_thread ); 10cf24: 89 1c 24 mov %ebx,(%esp) 10cf27: e8 94 06 00 00 call 10d5c0 <_Thread_Stack_Free> return false; 10cf2c: 83 c4 10 add $0x10,%esp 10cf2f: 31 c0 xor %eax,%eax } 10cf31: 8d 65 f4 lea -0xc(%ebp),%esp 10cf34: 5b pop %ebx 10cf35: 5e pop %esi 10cf36: 5f pop %edi 10cf37: c9 leave 10cf38: c3 ret 10cf39: 8d 76 00 lea 0x0(%esi),%esi * Allocate and Initialize the stack for this thread. */ #if !defined(RTEMS_SCORE_THREAD_ENABLE_USER_PROVIDED_STACK_VIA_API) actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); if ( !actual_stack_size || actual_stack_size < stack_size ) return false; /* stack allocation failed */ 10cf3c: 31 c0 xor %eax,%eax _Workspace_Free( sched ); _Thread_Stack_Free( the_thread ); return false; } 10cf3e: 8d 65 f4 lea -0xc(%ebp),%esp 10cf41: 5b pop %ebx 10cf42: 5e pop %esi 10cf43: 5f pop %edi 10cf44: c9 leave 10cf45: c3 ret 10cf46: 66 90 xchg %ax,%ax * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread ); if ( extension_status ) return true; 10cf48: b0 01 mov $0x1,%al 10cf4a: eb f2 jmp 10cf3e <_Thread_Initialize+0x1a6> /* * 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 ); 10cf4c: 83 ec 0c sub $0xc,%esp 10cf4f: 6a 6c push $0x6c 10cf51: e8 1a 0d 00 00 call 10dc70 <_Workspace_Allocate> 10cf56: 89 c7 mov %eax,%edi if ( !fp_area ) 10cf58: 83 c4 10 add $0x10,%esp 10cf5b: 85 c0 test %eax,%eax 10cf5d: 0f 85 a6 fe ff ff jne 10ce09 <_Thread_Initialize+0x71> * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10cf63: 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; 10cf65: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 10cf6c: e9 74 ff ff ff jmp 10cee5 <_Thread_Initialize+0x14d> 10cf71: 8d 76 00 lea 0x0(%esi),%esi /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { extensions_area = _Workspace_Allocate( 10cf74: 83 ec 0c sub $0xc,%esp 10cf77: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10cf7e: 50 push %eax 10cf7f: e8 ec 0c 00 00 call 10dc70 <_Workspace_Allocate> 10cf84: 89 c6 mov %eax,%esi (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) 10cf86: 83 c4 10 add $0x10,%esp 10cf89: 85 c0 test %eax,%eax 10cf8b: 74 26 je 10cfb3 <_Thread_Initialize+0x21b> goto failed; } the_thread->extensions = (void **) extensions_area; 10cf8d: 89 83 ec 00 00 00 mov %eax,0xec(%ebx) 10cf93: 8b 0d 90 65 12 00 mov 0x126590,%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++ ) 10cf99: 31 d2 xor %edx,%edx (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) goto failed; } the_thread->extensions = (void **) extensions_area; 10cf9b: 31 c0 xor %eax,%eax 10cf9d: 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; 10cfa0: 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++ ) 10cfa7: 40 inc %eax 10cfa8: 89 c2 mov %eax,%edx 10cfaa: 39 c1 cmp %eax,%ecx 10cfac: 73 f2 jae 10cfa0 <_Thread_Initialize+0x208> 10cfae: e9 97 fe ff ff jmp 10ce4a <_Thread_Initialize+0xb2> 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; 10cfb3: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 10cfba: e9 26 ff ff ff jmp 10cee5 <_Thread_Initialize+0x14d> =============================================================================== 0011146c <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 11146c: 55 push %ebp 11146d: 89 e5 mov %esp,%ebp 11146f: 53 push %ebx 111470: 83 ec 10 sub $0x10,%esp 111473: 8b 5d 08 mov 0x8(%ebp),%ebx the_thread->resource_count = 0; 111476: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->is_preemptible = the_thread->Start.is_preemptible; 11147d: 8a 83 a0 00 00 00 mov 0xa0(%ebx),%al 111483: 88 43 74 mov %al,0x74(%ebx) the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 111486: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax 11148c: 89 43 7c mov %eax,0x7c(%ebx) the_thread->budget_callout = the_thread->Start.budget_callout; 11148f: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax 111495: 89 83 80 00 00 00 mov %eax,0x80(%ebx) the_thread->Start.pointer_argument = pointer_argument; 11149b: 8b 45 0c mov 0xc(%ebp),%eax 11149e: 89 83 98 00 00 00 mov %eax,0x98(%ebx) the_thread->Start.numeric_argument = numeric_argument; 1114a4: 8b 45 10 mov 0x10(%ebp),%eax 1114a7: 89 83 9c 00 00 00 mov %eax,0x9c(%ebx) if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 1114ad: 53 push %ebx 1114ae: e8 95 c9 ff ff call 10de48 <_Thread_queue_Extract_with_proxy> 1114b3: 83 c4 10 add $0x10,%esp 1114b6: 84 c0 test %al,%al 1114b8: 75 06 jne 1114c0 <_Thread_Reset+0x54> if ( _Watchdog_Is_active( &the_thread->Timer ) ) 1114ba: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 1114be: 74 28 je 1114e8 <_Thread_Reset+0x7c> (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 1114c0: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax 1114c6: 39 43 14 cmp %eax,0x14(%ebx) 1114c9: 74 15 je 1114e0 <_Thread_Reset+0x74> the_thread->real_priority = the_thread->Start.initial_priority; 1114cb: 89 43 18 mov %eax,0x18(%ebx) _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 1114ce: 89 45 0c mov %eax,0xc(%ebp) 1114d1: 89 5d 08 mov %ebx,0x8(%ebp) } } 1114d4: 8b 5d fc mov -0x4(%ebp),%ebx 1114d7: 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 ); 1114d8: e9 47 cb ff ff jmp 10e024 <_Thread_Set_priority> 1114dd: 8d 76 00 lea 0x0(%esi),%esi } } 1114e0: 8b 5d fc mov -0x4(%ebp),%ebx 1114e3: c9 leave 1114e4: c3 ret 1114e5: 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 ); 1114e8: 83 ec 0c sub $0xc,%esp 1114eb: 8d 43 48 lea 0x48(%ebx),%eax 1114ee: 50 push %eax 1114ef: e8 e0 d1 ff ff call 10e6d4 <_Watchdog_Remove> 1114f4: 83 c4 10 add $0x10,%esp 1114f7: eb c7 jmp 1114c0 <_Thread_Reset+0x54> =============================================================================== 0010d55c <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 10d55c: 55 push %ebp 10d55d: 89 e5 mov %esp,%ebp 10d55f: 53 push %ebx 10d560: 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; 10d563: a1 f0 22 12 00 mov 0x1222f0,%eax 10d568: 8b 5d 0c mov 0xc(%ebp),%ebx 10d56b: 39 c3 cmp %eax,%ebx 10d56d: 73 02 jae 10d571 <_Thread_Stack_Allocate+0x15> 10d56f: 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 ) { 10d571: a1 20 23 12 00 mov 0x122320,%eax 10d576: 85 c0 test %eax,%eax 10d578: 74 32 je 10d5ac <_Thread_Stack_Allocate+0x50> stack_addr = (*Configuration.stack_allocate_hook)( the_stack_size ); 10d57a: 83 ec 0c sub $0xc,%esp 10d57d: 53 push %ebx 10d57e: ff d0 call *%eax 10d580: 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 ) 10d583: 85 c0 test %eax,%eax 10d585: 74 11 je 10d598 <_Thread_Stack_Allocate+0x3c> the_stack_size = 0; the_thread->Start.stack = stack_addr; 10d587: 8b 55 08 mov 0x8(%ebp),%edx 10d58a: 89 82 c0 00 00 00 mov %eax,0xc0(%edx) return the_stack_size; } 10d590: 89 d8 mov %ebx,%eax 10d592: 8b 5d fc mov -0x4(%ebp),%ebx 10d595: c9 leave 10d596: c3 ret 10d597: 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; 10d598: 31 db xor %ebx,%ebx the_thread->Start.stack = stack_addr; 10d59a: 8b 55 08 mov 0x8(%ebp),%edx 10d59d: 89 82 c0 00 00 00 mov %eax,0xc0(%edx) return the_stack_size; } 10d5a3: 89 d8 mov %ebx,%eax 10d5a5: 8b 5d fc mov -0x4(%ebp),%ebx 10d5a8: c9 leave 10d5a9: c3 ret 10d5aa: 66 90 xchg %ax,%ax RTEMS_INLINE_ROUTINE uint32_t _Stack_Adjust_size ( size_t size ) { return size + CPU_STACK_ALIGNMENT; 10d5ac: 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 ); 10d5af: 83 ec 0c sub $0xc,%esp 10d5b2: 53 push %ebx 10d5b3: e8 b8 06 00 00 call 10dc70 <_Workspace_Allocate> 10d5b8: 83 c4 10 add $0x10,%esp 10d5bb: eb c6 jmp 10d583 <_Thread_Stack_Allocate+0x27> =============================================================================== 0010d5c0 <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 10d5c0: 55 push %ebp 10d5c1: 89 e5 mov %esp,%ebp 10d5c3: 83 ec 08 sub $0x8,%esp 10d5c6: 8b 55 08 mov 0x8(%ebp),%edx * 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 ) 10d5c9: a1 24 23 12 00 mov 0x122324,%eax 10d5ce: 85 c0 test %eax,%eax 10d5d0: 74 0e je 10d5e0 <_Thread_Stack_Free+0x20> (*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area ); 10d5d2: 8b 92 b8 00 00 00 mov 0xb8(%edx),%edx 10d5d8: 89 55 08 mov %edx,0x8(%ebp) else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10d5db: 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 ); 10d5dc: ff e0 jmp *%eax 10d5de: 66 90 xchg %ax,%ax else _Workspace_Free( the_thread->Start.Initial_stack.area ); 10d5e0: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax 10d5e6: 89 45 08 mov %eax,0x8(%ebp) } 10d5e9: 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 ); 10d5ea: e9 9d 06 00 00 jmp 10dc8c <_Workspace_Free> =============================================================================== 0010d098 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 10d098: 55 push %ebp 10d099: 89 e5 mov %esp,%ebp 10d09b: 57 push %edi 10d09c: 56 push %esi 10d09d: 53 push %ebx 10d09e: 83 ec 2c sub $0x2c,%esp 10d0a1: 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 ); 10d0a4: 9c pushf 10d0a5: fa cli 10d0a6: 58 pop %eax 10d0a7: 89 f9 mov %edi,%ecx for( index=0 ; 10d0a9: 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 ); } 10d0ab: 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 ); 10d0ad: 8d 34 52 lea (%edx,%edx,2),%esi 10d0b0: 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 ] ) ) { 10d0b4: 39 f3 cmp %esi,%ebx 10d0b6: 75 18 jne 10d0d0 <_Thread_queue_Dequeue_priority+0x38> Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 10d0b8: 42 inc %edx 10d0b9: 83 c1 0c add $0xc,%ecx Chain_Node *last_node; Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; 10d0bc: 83 fa 04 cmp $0x4,%edx 10d0bf: 75 ea jne 10d0ab <_Thread_queue_Dequeue_priority+0x13> } /* * We did not find a thread to unblock. */ _ISR_Enable( level ); 10d0c1: 50 push %eax 10d0c2: 9d popf return NULL; 10d0c3: 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 ); } 10d0c5: 89 f0 mov %esi,%eax 10d0c7: 8d 65 f4 lea -0xc(%ebp),%esp 10d0ca: 5b pop %ebx 10d0cb: 5e pop %esi 10d0cc: 5f pop %edi 10d0cd: c9 leave 10d0ce: c3 ret 10d0cf: 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( 10d0d0: 89 de mov %ebx,%esi */ _ISR_Enable( level ); return NULL; dequeue: the_thread->Wait.queue = NULL; 10d0d2: 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 ); } 10d0d9: 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; 10d0dc: 8b 0b mov (%ebx),%ecx previous_node = the_thread->Object.Node.previous; 10d0de: 8b 7b 04 mov 0x4(%ebx),%edi 10d0e1: 89 7d d4 mov %edi,-0x2c(%ebp) 10d0e4: 8d 7b 3c lea 0x3c(%ebx),%edi if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10d0e7: 39 fa cmp %edi,%edx 10d0e9: 74 7f je 10d16a <_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 ); } 10d0eb: 8b 7b 40 mov 0x40(%ebx),%edi 10d0ee: 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; 10d0f1: 8b 3a mov (%edx),%edi 10d0f3: 89 7d e0 mov %edi,-0x20(%ebp) previous_node->next = new_first_node; 10d0f6: 8b 7d d4 mov -0x2c(%ebp),%edi 10d0f9: 89 17 mov %edx,(%edi) next_node->previous = new_first_node; 10d0fb: 89 51 04 mov %edx,0x4(%ecx) new_first_node->next = next_node; 10d0fe: 89 0a mov %ecx,(%edx) new_first_node->previous = previous_node; 10d100: 89 7a 04 mov %edi,0x4(%edx) if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10d103: 8b 4b 40 mov 0x40(%ebx),%ecx 10d106: 39 4b 38 cmp %ecx,0x38(%ebx) 10d109: 74 17 je 10d122 <_Thread_queue_Dequeue_priority+0x8a> /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); 10d10b: 8d 4a 38 lea 0x38(%edx),%ecx 10d10e: 8b 7d e0 mov -0x20(%ebp),%edi 10d111: 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; 10d114: 89 7a 38 mov %edi,0x38(%edx) tail->previous = last_node; 10d117: 8b 4d e4 mov -0x1c(%ebp),%ecx 10d11a: 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 ); 10d11d: 83 c2 3c add $0x3c,%edx 10d120: 89 11 mov %edx,(%ecx) } else { previous_node->next = next_node; next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10d122: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 10d126: 74 18 je 10d140 <_Thread_queue_Dequeue_priority+0xa8> _ISR_Enable( level ); 10d128: 50 push %eax 10d129: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10d12a: 83 ec 08 sub $0x8,%esp 10d12d: 68 f8 ff 03 10 push $0x1003fff8 10d132: 53 push %ebx 10d133: e8 60 f8 ff ff call 10c998 <_Thread_Clear_state> 10d138: 83 c4 10 add $0x10,%esp 10d13b: eb 88 jmp 10d0c5 <_Thread_queue_Dequeue_priority+0x2d> 10d13d: 8d 76 00 lea 0x0(%esi),%esi RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 10d140: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10d147: 50 push %eax 10d148: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 10d149: 83 ec 0c sub $0xc,%esp 10d14c: 8d 43 48 lea 0x48(%ebx),%eax 10d14f: 50 push %eax 10d150: e8 f3 09 00 00 call 10db48 <_Watchdog_Remove> 10d155: 58 pop %eax 10d156: 5a pop %edx 10d157: 68 f8 ff 03 10 push $0x1003fff8 10d15c: 53 push %ebx 10d15d: e8 36 f8 ff ff call 10c998 <_Thread_Clear_state> 10d162: 83 c4 10 add $0x10,%esp 10d165: e9 5b ff ff ff jmp 10d0c5 <_Thread_queue_Dequeue_priority+0x2d> head->next = new_second_node; tail->previous = last_node; last_node->next = tail; } } else { previous_node->next = next_node; 10d16a: 8b 7d d4 mov -0x2c(%ebp),%edi 10d16d: 89 0f mov %ecx,(%edi) next_node->previous = previous_node; 10d16f: 89 79 04 mov %edi,0x4(%ecx) 10d172: eb ae jmp 10d122 <_Thread_queue_Dequeue_priority+0x8a> =============================================================================== 001106fc <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 1106fc: 55 push %ebp 1106fd: 89 e5 mov %esp,%ebp 1106ff: 83 ec 08 sub $0x8,%esp 110702: 8b 45 08 mov 0x8(%ebp),%eax 110705: 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 ) 110708: 83 78 34 01 cmpl $0x1,0x34(%eax) 11070c: 74 0e je 11071c <_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 ); 11070e: 89 55 0c mov %edx,0xc(%ebp) 110711: 89 45 08 mov %eax,0x8(%ebp) } 110714: 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 ); 110715: e9 0a 16 00 00 jmp 111d24 <_Thread_queue_Extract_fifo> 11071a: 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 ); 11071c: 51 push %ecx 11071d: 6a 00 push $0x0 11071f: 52 push %edx 110720: 50 push %eax 110721: e8 06 00 00 00 call 11072c <_Thread_queue_Extract_priority_helper> 110726: 83 c4 10 add $0x10,%esp else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); } 110729: c9 leave 11072a: c3 ret =============================================================================== 00111d24 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue __attribute__((unused)), Thread_Control *the_thread ) { 111d24: 55 push %ebp 111d25: 89 e5 mov %esp,%ebp 111d27: 53 push %ebx 111d28: 83 ec 04 sub $0x4,%esp 111d2b: 8b 5d 0c mov 0xc(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 111d2e: 9c pushf 111d2f: fa cli 111d30: 58 pop %eax if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 111d31: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) 111d38: 74 2e je 111d68 <_Thread_queue_Extract_fifo+0x44> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 111d3a: 8b 0b mov (%ebx),%ecx previous = the_node->previous; 111d3c: 8b 53 04 mov 0x4(%ebx),%edx next->previous = previous; 111d3f: 89 51 04 mov %edx,0x4(%ecx) previous->next = next; 111d42: 89 0a mov %ecx,(%edx) return; } _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; 111d44: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 111d4b: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 111d4f: 74 1f je 111d70 <_Thread_queue_Extract_fifo+0x4c> _ISR_Enable( level ); 111d51: 50 push %eax 111d52: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 111d53: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 111d5a: 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 } 111d5d: 8b 5d fc mov -0x4(%ebp),%ebx 111d60: c9 leave 111d61: e9 32 ac ff ff jmp 10c998 <_Thread_Clear_state> 111d66: 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 ); 111d68: 50 push %eax 111d69: 9d popf #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 111d6a: 8b 5d fc mov -0x4(%ebp),%ebx 111d6d: c9 leave 111d6e: c3 ret 111d6f: 90 nop 111d70: 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 ); 111d77: 50 push %eax 111d78: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 111d79: 83 ec 0c sub $0xc,%esp 111d7c: 8d 43 48 lea 0x48(%ebx),%eax 111d7f: 50 push %eax 111d80: e8 c3 bd ff ff call 10db48 <_Watchdog_Remove> 111d85: 83 c4 10 add $0x10,%esp 111d88: eb c9 jmp 111d53 <_Thread_queue_Extract_fifo+0x2f> =============================================================================== 0011072c <_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 ) { 11072c: 55 push %ebp 11072d: 89 e5 mov %esp,%ebp 11072f: 57 push %edi 110730: 56 push %esi 110731: 53 push %ebx 110732: 83 ec 1c sub $0x1c,%esp 110735: 8b 5d 0c mov 0xc(%ebp),%ebx 110738: 8a 45 10 mov 0x10(%ebp),%al 11073b: 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 ); 11073e: 9c pushf 11073f: fa cli 110740: 8f 45 e4 popl -0x1c(%ebp) if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 110743: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) 11074a: 74 6c je 1107b8 <_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; 11074c: 8b 13 mov (%ebx),%edx previous_node = the_node->previous; 11074e: 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 } 110751: 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 ); 110754: 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 ) ) { 110757: 39 f0 cmp %esi,%eax 110759: 74 69 je 1107c4 <_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 } 11075b: 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; 11075e: 8b 30 mov (%eax),%esi previous_node->next = new_first_node; 110760: 89 01 mov %eax,(%ecx) next_node->previous = new_first_node; 110762: 89 42 04 mov %eax,0x4(%edx) new_first_node->next = next_node; 110765: 89 10 mov %edx,(%eax) new_first_node->previous = previous_node; 110767: 89 48 04 mov %ecx,0x4(%eax) if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 11076a: 8b 53 40 mov 0x40(%ebx),%edx 11076d: 39 53 38 cmp %edx,0x38(%ebx) 110770: 74 11 je 110783 <_Thread_queue_Extract_priority_helper+0x57> /* > two threads on 2-n */ head = _Chain_Head( &new_first_thread->Wait.Block2n ); 110772: 8d 50 38 lea 0x38(%eax),%edx 110775: 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; 110778: 89 70 38 mov %esi,0x38(%eax) tail->previous = last_node; 11077b: 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 ); 11077e: 83 c0 3c add $0x3c,%eax 110781: 89 07 mov %eax,(%edi) /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 110783: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 110787: 75 23 jne 1107ac <_Thread_queue_Extract_priority_helper+0x80> _ISR_Enable( level ); return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 110789: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 11078d: 74 3d je 1107cc <_Thread_queue_Extract_priority_helper+0xa0> _ISR_Enable( level ); 11078f: ff 75 e4 pushl -0x1c(%ebp) 110792: 9d popf 110793: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 11079a: 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 } 11079d: 8d 65 f4 lea -0xc(%ebp),%esp 1107a0: 5b pop %ebx 1107a1: 5e pop %esi 1107a2: 5f pop %edi 1107a3: c9 leave 1107a4: e9 ef c1 ff ff jmp 10c998 <_Thread_Clear_state> 1107a9: 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 ); 1107ac: ff 75 e4 pushl -0x1c(%ebp) 1107af: 9d popf #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 1107b0: 8d 65 f4 lea -0xc(%ebp),%esp 1107b3: 5b pop %ebx 1107b4: 5e pop %esi 1107b5: 5f pop %edi 1107b6: c9 leave 1107b7: 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 ); 1107b8: ff 75 e4 pushl -0x1c(%ebp) 1107bb: 9d popf #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 1107bc: 8d 65 f4 lea -0xc(%ebp),%esp 1107bf: 5b pop %ebx 1107c0: 5e pop %esi 1107c1: 5f pop %edi 1107c2: c9 leave 1107c3: c3 ret head->next = new_second_node; tail->previous = last_node; last_node->next = tail; } } else { previous_node->next = next_node; 1107c4: 89 11 mov %edx,(%ecx) next_node->previous = previous_node; 1107c6: 89 4a 04 mov %ecx,0x4(%edx) 1107c9: eb b8 jmp 110783 <_Thread_queue_Extract_priority_helper+0x57> 1107cb: 90 nop 1107cc: 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 ); 1107d3: ff 75 e4 pushl -0x1c(%ebp) 1107d6: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 1107d7: 83 ec 0c sub $0xc,%esp 1107da: 8d 43 48 lea 0x48(%ebx),%eax 1107dd: 50 push %eax 1107de: e8 65 d3 ff ff call 10db48 <_Watchdog_Remove> 1107e3: 83 c4 10 add $0x10,%esp 1107e6: eb ab jmp 110793 <_Thread_queue_Extract_priority_helper+0x67> =============================================================================== 0010d384 <_Thread_queue_Extract_with_proxy>: */ bool _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 10d384: 55 push %ebp 10d385: 89 e5 mov %esp,%ebp 10d387: 83 ec 08 sub $0x8,%esp 10d38a: 8b 45 08 mov 0x8(%ebp),%eax States_Control state; state = the_thread->current_state; if ( _States_Is_waiting_on_thread_queue( state ) ) { 10d38d: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax) 10d394: 75 06 jne 10d39c <_Thread_queue_Extract_with_proxy+0x18> #endif _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); return true; } return false; 10d396: 31 c0 xor %eax,%eax } 10d398: c9 leave 10d399: c3 ret 10d39a: 66 90 xchg %ax,%ax if ( proxy_extract_callout ) (*proxy_extract_callout)( the_thread ); } #endif _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10d39c: 83 ec 08 sub $0x8,%esp 10d39f: 50 push %eax 10d3a0: ff 70 44 pushl 0x44(%eax) 10d3a3: e8 54 33 00 00 call 1106fc <_Thread_queue_Extract> return true; 10d3a8: 83 c4 10 add $0x10,%esp 10d3ab: b0 01 mov $0x1,%al } return false; } 10d3ad: c9 leave 10d3ae: c3 ret =============================================================================== 0011e7ac <_Thread_queue_First>: */ Thread_Control *_Thread_queue_First( Thread_queue_Control *the_thread_queue ) { 11e7ac: 55 push %ebp 11e7ad: 89 e5 mov %esp,%ebp 11e7af: 83 ec 08 sub $0x8,%esp 11e7b2: 8b 45 08 mov 0x8(%ebp),%eax Thread_Control * (*first_p)(Thread_queue_Control *); if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 11e7b5: 83 78 34 01 cmpl $0x1,0x34(%eax) 11e7b9: 74 0d je 11e7c8 <_Thread_queue_First+0x1c> first_p = _Thread_queue_First_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; 11e7bb: ba 3c fb 11 00 mov $0x11fb3c,%edx return (*first_p)( the_thread_queue ); 11e7c0: 89 45 08 mov %eax,0x8(%ebp) } 11e7c3: 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 ); 11e7c4: ff e2 jmp *%edx 11e7c6: 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; 11e7c8: ba d4 e7 11 00 mov $0x11e7d4,%edx else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; return (*first_p)( the_thread_queue ); 11e7cd: 89 45 08 mov %eax,0x8(%ebp) } 11e7d0: 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 ); 11e7d1: ff e2 jmp *%edx =============================================================================== 0011fb3c <_Thread_queue_First_fifo>: */ Thread_Control *_Thread_queue_First_fifo( Thread_queue_Control *the_thread_queue ) { 11fb3c: 55 push %ebp 11fb3d: 89 e5 mov %esp,%ebp 11fb3f: 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; } 11fb42: 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 ); 11fb44: 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 ) ) 11fb47: 39 d0 cmp %edx,%eax 11fb49: 74 05 je 11fb50 <_Thread_queue_First_fifo+0x14> return (Thread_Control *) _Chain_First( &the_thread_queue->Queues.Fifo ); return NULL; } 11fb4b: c9 leave 11fb4c: c3 ret 11fb4d: 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; 11fb50: 31 c0 xor %eax,%eax } 11fb52: c9 leave 11fb53: c3 ret =============================================================================== 0010d3b0 <_Thread_queue_Flush>: #else Thread_queue_Flush_callout remote_extract_callout __attribute__((unused)), #endif uint32_t status ) { 10d3b0: 55 push %ebp 10d3b1: 89 e5 mov %esp,%ebp 10d3b3: 56 push %esi 10d3b4: 53 push %ebx 10d3b5: 8b 5d 08 mov 0x8(%ebp),%ebx 10d3b8: 8b 75 10 mov 0x10(%ebp),%esi Thread_Control *the_thread; while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) { 10d3bb: eb 06 jmp 10d3c3 <_Thread_queue_Flush+0x13> 10d3bd: 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; 10d3c0: 89 70 34 mov %esi,0x34(%eax) uint32_t status ) { Thread_Control *the_thread; while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) { 10d3c3: 83 ec 0c sub $0xc,%esp 10d3c6: 53 push %ebx 10d3c7: e8 80 fc ff ff call 10d04c <_Thread_queue_Dequeue> 10d3cc: 83 c4 10 add $0x10,%esp 10d3cf: 85 c0 test %eax,%eax 10d3d1: 75 ed jne 10d3c0 <_Thread_queue_Flush+0x10> ( *remote_extract_callout )( the_thread ); else #endif the_thread->Wait.return_code = status; } } 10d3d3: 8d 65 f8 lea -0x8(%ebp),%esp 10d3d6: 5b pop %ebx 10d3d7: 5e pop %esi 10d3d8: c9 leave 10d3d9: c3 ret =============================================================================== 0010d3dc <_Thread_queue_Initialize>: Thread_queue_Control *the_thread_queue, Thread_queue_Disciplines the_discipline, States_Control state, uint32_t timeout_status ) { 10d3dc: 55 push %ebp 10d3dd: 89 e5 mov %esp,%ebp 10d3df: 56 push %esi 10d3e0: 53 push %ebx 10d3e1: 8b 45 08 mov 0x8(%ebp),%eax 10d3e4: 8b 55 0c mov 0xc(%ebp),%edx the_thread_queue->state = state; 10d3e7: 8b 4d 10 mov 0x10(%ebp),%ecx 10d3ea: 89 48 38 mov %ecx,0x38(%eax) the_thread_queue->discipline = the_discipline; 10d3ed: 89 50 34 mov %edx,0x34(%eax) the_thread_queue->timeout_status = timeout_status; 10d3f0: 8b 4d 14 mov 0x14(%ebp),%ecx 10d3f3: 89 48 3c mov %ecx,0x3c(%eax) the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10d3f6: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10d3fd: 83 fa 01 cmp $0x1,%edx 10d400: 74 16 je 10d418 <_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 ); 10d402: 8d 50 04 lea 0x4(%eax),%edx 10d405: 89 10 mov %edx,(%eax) head->next = tail; head->previous = NULL; 10d407: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) tail->previous = head; 10d40e: 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 ); } } 10d411: 5b pop %ebx 10d412: 5e pop %esi 10d413: c9 leave 10d414: c3 ret 10d415: 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 ) { 10d418: 89 c1 mov %eax,%ecx 10d41a: 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 ); 10d41c: 8d 1c 52 lea (%edx,%edx,2),%ebx 10d41f: 8d 1c 98 lea (%eax,%ebx,4),%ebx 10d422: 8d 73 04 lea 0x4(%ebx),%esi 10d425: 89 31 mov %esi,(%ecx) head->next = tail; head->previous = NULL; 10d427: 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 ); 10d42e: 89 59 08 mov %ebx,0x8(%ecx) uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++) 10d431: 42 inc %edx 10d432: 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 ; 10d435: 83 fa 04 cmp $0x4,%edx 10d438: 75 e2 jne 10d41c <_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 ); } } 10d43a: 5b pop %ebx 10d43b: 5e pop %esi 10d43c: c9 leave 10d43d: c3 ret =============================================================================== 0010d440 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 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 1c sub $0x1c,%esp 10d449: 8b 75 08 mov 0x8(%ebp),%esi 10d44c: 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 ) 10d44f: 85 f6 test %esi,%esi 10d451: 74 06 je 10d459 <_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 ) { 10d453: 83 7e 34 01 cmpl $0x1,0x34(%esi) 10d457: 74 0b je 10d464 <_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 ); } } 10d459: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d45c: 5b pop %ebx <== NOT EXECUTED 10d45d: 5e pop %esi <== NOT EXECUTED 10d45e: 5f pop %edi <== NOT EXECUTED 10d45f: c9 leave <== NOT EXECUTED 10d460: c3 ret <== NOT EXECUTED 10d461: 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 ); 10d464: 9c pushf 10d465: fa cli 10d466: 5b pop %ebx if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10d467: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi) 10d46e: 75 0c jne 10d47c <_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 ); 10d470: 53 push %ebx 10d471: 9d popf } } 10d472: 8d 65 f4 lea -0xc(%ebp),%esp 10d475: 5b pop %ebx 10d476: 5e pop %esi 10d477: 5f pop %edi 10d478: c9 leave 10d479: c3 ret 10d47a: 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; 10d47c: 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 ); 10d483: 50 push %eax 10d484: 6a 01 push $0x1 10d486: 57 push %edi 10d487: 56 push %esi 10d488: e8 9f 32 00 00 call 11072c <_Thread_queue_Extract_priority_helper> (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10d48d: 83 c4 0c add $0xc,%esp 10d490: 8d 45 e4 lea -0x1c(%ebp),%eax 10d493: 50 push %eax 10d494: 57 push %edi 10d495: 56 push %esi 10d496: e8 71 fd ff ff call 10d20c <_Thread_queue_Enqueue_priority> 10d49b: 83 c4 10 add $0x10,%esp 10d49e: eb d0 jmp 10d470 <_Thread_queue_Requeue+0x30> =============================================================================== 0010d4a0 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) { 10d4a0: 55 push %ebp 10d4a1: 89 e5 mov %esp,%ebp 10d4a3: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10d4a6: 8d 45 f4 lea -0xc(%ebp),%eax 10d4a9: 50 push %eax 10d4aa: ff 75 08 pushl 0x8(%ebp) 10d4ad: e8 6e f8 ff ff call 10cd20 <_Thread_Get> switch ( location ) { 10d4b2: 83 c4 10 add $0x10,%esp 10d4b5: 8b 55 f4 mov -0xc(%ebp),%edx 10d4b8: 85 d2 test %edx,%edx 10d4ba: 75 17 jne 10d4d3 <_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 ); 10d4bc: 83 ec 0c sub $0xc,%esp 10d4bf: 50 push %eax 10d4c0: e8 23 33 00 00 call 1107e8 <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10d4c5: a1 ec 64 12 00 mov 0x1264ec,%eax 10d4ca: 48 dec %eax 10d4cb: a3 ec 64 12 00 mov %eax,0x1264ec 10d4d0: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10d4d3: c9 leave 10d4d4: c3 ret =============================================================================== 001183e0 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 1183e0: 55 push %ebp 1183e1: 89 e5 mov %esp,%ebp 1183e3: 57 push %edi 1183e4: 56 push %esi 1183e5: 53 push %ebx 1183e6: 83 ec 4c sub $0x4c,%esp 1183e9: 8b 5d 08 mov 0x8(%ebp),%ebx ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 1183ec: 8d 45 e0 lea -0x20(%ebp),%eax 1183ef: 89 45 b4 mov %eax,-0x4c(%ebp) 1183f2: 89 45 dc mov %eax,-0x24(%ebp) head->previous = NULL; 1183f5: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) tail->previous = head; 1183fc: 8d 4d dc lea -0x24(%ebp),%ecx 1183ff: 89 4d e4 mov %ecx,-0x1c(%ebp) ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 118402: 8d 7d d0 lea -0x30(%ebp),%edi 118405: 8d 45 d4 lea -0x2c(%ebp),%eax 118408: 89 45 b0 mov %eax,-0x50(%ebp) 11840b: 89 45 d0 mov %eax,-0x30(%ebp) head->previous = NULL; 11840e: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) tail->previous = head; 118415: 89 7d d8 mov %edi,-0x28(%ebp) 118418: 8d 73 30 lea 0x30(%ebx),%esi 11841b: 8d 4b 68 lea 0x68(%ebx),%ecx 11841e: 89 4d c4 mov %ecx,-0x3c(%ebp) 118421: 8d 43 08 lea 0x8(%ebx),%eax 118424: 89 45 c0 mov %eax,-0x40(%ebp) 118427: 8d 53 40 lea 0x40(%ebx),%edx 11842a: 89 55 bc mov %edx,-0x44(%ebp) 11842d: 8d 76 00 lea 0x0(%esi),%esi { /* * 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; 118430: 8d 4d dc lea -0x24(%ebp),%ecx 118433: 89 4b 78 mov %ecx,0x78(%ebx) 118436: 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; 118438: a1 24 0a 14 00 mov 0x140a24,%eax /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 11843d: 8b 53 3c mov 0x3c(%ebx),%edx watchdogs->last_snapshot = snapshot; 118440: 89 43 3c mov %eax,0x3c(%ebx) _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 118443: 51 push %ecx 118444: 57 push %edi Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 118445: 29 d0 sub %edx,%eax watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 118447: 50 push %eax 118448: 56 push %esi 118449: e8 5a 3d 00 00 call 11c1a8 <_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(); 11844e: a1 88 09 14 00 mov 0x140988,%eax Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 118453: 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 ) { 118456: 83 c4 10 add $0x10,%esp 118459: 39 d0 cmp %edx,%eax 11845b: 77 63 ja 1184c0 <_Timer_server_Body+0xe0> * TOD has been set forward. */ delta = snapshot - last_snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); } else if ( snapshot < last_snapshot ) { 11845d: 72 7d jb 1184dc <_Timer_server_Body+0xfc> */ delta = last_snapshot - snapshot; _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); } watchdogs->last_snapshot = snapshot; 11845f: 89 43 74 mov %eax,0x74(%ebx) 118462: 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 ); 118464: 8b 43 78 mov 0x78(%ebx),%eax 118467: 83 ec 0c sub $0xc,%esp 11846a: 50 push %eax 11846b: e8 ac 09 00 00 call 118e1c <_Chain_Get> if ( timer == NULL ) { 118470: 83 c4 10 add $0x10,%esp 118473: 85 c0 test %eax,%eax 118475: 74 35 je 1184ac <_Timer_server_Body+0xcc><== ALWAYS TAKEN static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 118477: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 11847a: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 11847d: 74 19 je 118498 <_Timer_server_Body+0xb8><== NOT EXECUTED _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 11847f: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 118482: 75 e0 jne 118464 <_Timer_server_Body+0x84><== NOT EXECUTED _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 118484: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 118487: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 11848a: 50 push %eax <== NOT EXECUTED 11848b: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED 11848e: e8 a1 3d 00 00 call 11c234 <_Watchdog_Insert> <== NOT EXECUTED 118493: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 118496: eb cc jmp 118464 <_Timer_server_Body+0x84><== 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 ); 118498: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11849b: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 11849e: 50 push %eax <== NOT EXECUTED 11849f: 56 push %esi <== NOT EXECUTED 1184a0: e8 8f 3d 00 00 call 11c234 <_Watchdog_Insert> <== NOT EXECUTED 1184a5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1184a8: eb ba jmp 118464 <_Timer_server_Body+0x84><== NOT EXECUTED 1184aa: 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 ); 1184ac: 9c pushf 1184ad: fa cli 1184ae: 58 pop %eax if ( _Chain_Is_empty( insert_chain ) ) { 1184af: 8b 55 b4 mov -0x4c(%ebp),%edx 1184b2: 39 55 dc cmp %edx,-0x24(%ebp) 1184b5: 74 41 je 1184f8 <_Timer_server_Body+0x118><== ALWAYS TAKEN ts->insert_chain = NULL; _ISR_Enable( level ); break; } else { _ISR_Enable( level ); 1184b7: 50 push %eax <== NOT EXECUTED 1184b8: 9d popf <== NOT EXECUTED 1184b9: e9 7a ff ff ff jmp 118438 <_Timer_server_Body+0x58><== NOT EXECUTED 1184be: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * 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 ); 1184c0: 51 push %ecx 1184c1: 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; 1184c2: 89 c1 mov %eax,%ecx 1184c4: 29 d1 sub %edx,%ecx _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1184c6: 51 push %ecx 1184c7: ff 75 c4 pushl -0x3c(%ebp) 1184ca: 89 45 b8 mov %eax,-0x48(%ebp) 1184cd: e8 d6 3c 00 00 call 11c1a8 <_Watchdog_Adjust_to_chain> 1184d2: 83 c4 10 add $0x10,%esp 1184d5: 8b 45 b8 mov -0x48(%ebp),%eax 1184d8: eb 85 jmp 11845f <_Timer_server_Body+0x7f> 1184da: 66 90 xchg %ax,%ax /* * 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 ); 1184dc: 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; 1184dd: 29 c2 sub %eax,%edx _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 1184df: 52 push %edx 1184e0: 6a 01 push $0x1 1184e2: ff 75 c4 pushl -0x3c(%ebp) 1184e5: 89 45 b8 mov %eax,-0x48(%ebp) 1184e8: e8 43 3c 00 00 call 11c130 <_Watchdog_Adjust> 1184ed: 83 c4 10 add $0x10,%esp 1184f0: 8b 45 b8 mov -0x48(%ebp),%eax 1184f3: e9 67 ff ff ff jmp 11845f <_Timer_server_Body+0x7f> */ _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); if ( _Chain_Is_empty( insert_chain ) ) { ts->insert_chain = NULL; 1184f8: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx) _ISR_Enable( level ); 1184ff: 50 push %eax 118500: 9d popf _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 ) ) { 118501: 8b 4d b0 mov -0x50(%ebp),%ecx 118504: 39 4d d0 cmp %ecx,-0x30(%ebp) 118507: 75 23 jne 11852c <_Timer_server_Body+0x14c> 118509: eb 33 jmp 11853e <_Timer_server_Body+0x15e> 11850b: 90 nop Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 11850c: 8b 10 mov (%eax),%edx head->next = new_first; 11850e: 89 55 d0 mov %edx,-0x30(%ebp) new_first->previous = head; 118511: 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; 118514: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) _ISR_Enable( level ); 11851b: 51 push %ecx 11851c: 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 ); 11851d: 83 ec 08 sub $0x8,%esp 118520: ff 70 24 pushl 0x24(%eax) 118523: ff 70 20 pushl 0x20(%eax) 118526: ff 50 1c call *0x1c(%eax) } 118529: 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 ); 11852c: 9c pushf 11852d: fa cli 11852e: 59 pop %ecx initialized = false; } #endif return status; } 11852f: 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)) 118532: 3b 45 b0 cmp -0x50(%ebp),%eax 118535: 75 d5 jne 11850c <_Timer_server_Body+0x12c> watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; _ISR_Enable( level ); } else { _ISR_Enable( level ); 118537: 51 push %ecx 118538: 9d popf 118539: e9 f2 fe ff ff jmp 118430 <_Timer_server_Body+0x50> * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); } } else { ts->active = false; 11853e: c6 43 7c 00 movb $0x0,0x7c(%ebx) 118542: a1 ec 08 14 00 mov 0x1408ec,%eax 118547: 40 inc %eax 118548: a3 ec 08 14 00 mov %eax,0x1408ec /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( ts->thread, STATES_DELAYING ); 11854d: 83 ec 08 sub $0x8,%esp 118550: 6a 08 push $0x8 118552: ff 33 pushl (%ebx) 118554: e8 37 36 00 00 call 11bb90 <_Thread_Set_state> _Timer_server_Reset_interval_system_watchdog( ts ); 118559: 89 d8 mov %ebx,%eax 11855b: e8 e0 fd ff ff call 118340 <_Timer_server_Reset_interval_system_watchdog> _Timer_server_Reset_tod_system_watchdog( ts ); 118560: 89 d8 mov %ebx,%eax 118562: e8 29 fe ff ff call 118390 <_Timer_server_Reset_tod_system_watchdog> _Thread_Enable_dispatch(); 118567: e8 a8 2d 00 00 call 11b314 <_Thread_Enable_dispatch> ts->active = true; 11856c: 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 ); 118570: 5a pop %edx 118571: ff 75 c0 pushl -0x40(%ebp) 118574: e8 fb 3d 00 00 call 11c374 <_Watchdog_Remove> static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 118579: 58 pop %eax 11857a: ff 75 bc pushl -0x44(%ebp) 11857d: e8 f2 3d 00 00 call 11c374 <_Watchdog_Remove> 118582: 83 c4 10 add $0x10,%esp 118585: e9 a6 fe ff ff jmp 118430 <_Timer_server_Body+0x50> =============================================================================== 0011858c <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 11858c: 55 push %ebp 11858d: 89 e5 mov %esp,%ebp 11858f: 57 push %edi 118590: 56 push %esi 118591: 53 push %ebx 118592: 83 ec 2c sub $0x2c,%esp 118595: 8b 5d 08 mov 0x8(%ebp),%ebx 118598: 8b 45 0c mov 0xc(%ebp),%eax if ( ts->insert_chain == NULL ) { 11859b: 8b 53 78 mov 0x78(%ebx),%edx 11859e: 85 d2 test %edx,%edx 1185a0: 74 16 je 1185b8 <_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 ); 1185a2: 8b 53 78 mov 0x78(%ebx),%edx <== NOT EXECUTED 1185a5: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1185a8: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } } 1185ab: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1185ae: 5b pop %ebx <== NOT EXECUTED 1185af: 5e pop %esi <== NOT EXECUTED 1185b0: 5f pop %edi <== NOT EXECUTED 1185b1: 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 ); 1185b2: e9 29 08 00 00 jmp 118de0 <_Chain_Append> <== NOT EXECUTED 1185b7: 90 nop <== NOT EXECUTED 1185b8: 8b 15 ec 08 14 00 mov 0x1408ec,%edx 1185be: 42 inc %edx 1185bf: 89 15 ec 08 14 00 mov %edx,0x1408ec * being inserted. This could result in an integer overflow. */ _Thread_Disable_dispatch(); if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 1185c5: 8b 50 38 mov 0x38(%eax),%edx 1185c8: 83 fa 01 cmp $0x1,%edx 1185cb: 74 7b je 118648 <_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 ) { 1185cd: 83 fa 03 cmp $0x3,%edx 1185d0: 74 0e je 1185e0 <_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 ); } } 1185d2: 8d 65 f4 lea -0xc(%ebp),%esp 1185d5: 5b pop %ebx 1185d6: 5e pop %esi 1185d7: 5f pop %edi 1185d8: c9 leave if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 1185d9: e9 36 2d 00 00 jmp 11b314 <_Thread_Enable_dispatch> 1185de: 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 ); 1185e0: 9c pushf 1185e1: fa cli 1185e2: 8f 45 e4 popl -0x1c(%ebp) snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 1185e5: 8b 0d 88 09 14 00 mov 0x140988,%ecx last_snapshot = ts->TOD_watchdogs.last_snapshot; 1185eb: 8b 53 74 mov 0x74(%ebx),%edx 1185ee: 89 55 d4 mov %edx,-0x2c(%ebp) initialized = false; } #endif return status; } 1185f1: 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 ); 1185f4: 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 ) ) { 1185f7: 39 fa cmp %edi,%edx 1185f9: 74 21 je 11861c <_Timer_server_Schedule_operation_method+0x90> first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 1185fb: 8b 7a 10 mov 0x10(%edx),%edi if ( snapshot > last_snapshot ) { 1185fe: 3b 4d d4 cmp -0x2c(%ebp),%ecx 118601: 0f 86 a1 00 00 00 jbe 1186a8 <_Timer_server_Schedule_operation_method+0x11c> /* * We advanced in time. */ delta = snapshot - last_snapshot; 118607: 89 ce mov %ecx,%esi 118609: 2b 75 d4 sub -0x2c(%ebp),%esi 11860c: 89 75 d4 mov %esi,-0x2c(%ebp) if (delta_interval > delta) { 11860f: 39 f7 cmp %esi,%edi 118611: 0f 86 9b 00 00 00 jbe 1186b2 <_Timer_server_Schedule_operation_method+0x126><== NEVER TAKEN delta_interval -= delta; 118617: 29 f7 sub %esi,%edi * Someone put us in the past. */ delta = last_snapshot - snapshot; delta_interval += delta; } first_watchdog->delta_interval = delta_interval; 118619: 89 7a 10 mov %edi,0x10(%edx) } ts->TOD_watchdogs.last_snapshot = snapshot; 11861c: 89 4b 74 mov %ecx,0x74(%ebx) _ISR_Enable( level ); 11861f: ff 75 e4 pushl -0x1c(%ebp) 118622: 9d popf _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 118623: 83 ec 08 sub $0x8,%esp 118626: 83 c0 10 add $0x10,%eax 118629: 50 push %eax 11862a: 8d 43 68 lea 0x68(%ebx),%eax 11862d: 50 push %eax 11862e: e8 01 3c 00 00 call 11c234 <_Watchdog_Insert> if ( !ts->active ) { 118633: 8a 43 7c mov 0x7c(%ebx),%al 118636: 83 c4 10 add $0x10,%esp 118639: 84 c0 test %al,%al 11863b: 75 95 jne 1185d2 <_Timer_server_Schedule_operation_method+0x46> _Timer_server_Reset_tod_system_watchdog( ts ); 11863d: 89 d8 mov %ebx,%eax 11863f: e8 4c fd ff ff call 118390 <_Timer_server_Reset_tod_system_watchdog> 118644: eb 8c jmp 1185d2 <_Timer_server_Schedule_operation_method+0x46> 118646: 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 ); 118648: 9c pushf 118649: fa cli 11864a: 8f 45 e4 popl -0x1c(%ebp) snapshot = _Watchdog_Ticks_since_boot; 11864d: 8b 0d 24 0a 14 00 mov 0x140a24,%ecx last_snapshot = ts->Interval_watchdogs.last_snapshot; 118653: 8b 7b 3c mov 0x3c(%ebx),%edi initialized = false; } #endif return status; } 118656: 8b 53 30 mov 0x30(%ebx),%edx 118659: 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 ) ) { 11865c: 39 f2 cmp %esi,%edx 11865e: 74 10 je 118670 <_Timer_server_Schedule_operation_method+0xe4> first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain ); /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; 118660: 89 ce mov %ecx,%esi 118662: 29 fe sub %edi,%esi delta_interval = first_watchdog->delta_interval; 118664: 8b 7a 10 mov 0x10(%edx),%edi if (delta_interval > delta) { 118667: 39 fe cmp %edi,%esi 118669: 73 39 jae 1186a4 <_Timer_server_Schedule_operation_method+0x118> delta_interval -= delta; 11866b: 29 f7 sub %esi,%edi } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 11866d: 89 7a 10 mov %edi,0x10(%edx) } ts->Interval_watchdogs.last_snapshot = snapshot; 118670: 89 4b 3c mov %ecx,0x3c(%ebx) _ISR_Enable( level ); 118673: ff 75 e4 pushl -0x1c(%ebp) 118676: 9d popf _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 118677: 83 ec 08 sub $0x8,%esp 11867a: 83 c0 10 add $0x10,%eax 11867d: 50 push %eax 11867e: 8d 43 30 lea 0x30(%ebx),%eax 118681: 50 push %eax 118682: e8 ad 3b 00 00 call 11c234 <_Watchdog_Insert> if ( !ts->active ) { 118687: 8a 43 7c mov 0x7c(%ebx),%al 11868a: 83 c4 10 add $0x10,%esp 11868d: 84 c0 test %al,%al 11868f: 0f 85 3d ff ff ff jne 1185d2 <_Timer_server_Schedule_operation_method+0x46> _Timer_server_Reset_interval_system_watchdog( ts ); 118695: 89 d8 mov %ebx,%eax 118697: e8 a4 fc ff ff call 118340 <_Timer_server_Reset_interval_system_watchdog> 11869c: e9 31 ff ff ff jmp 1185d2 <_Timer_server_Schedule_operation_method+0x46> 1186a1: 8d 76 00 lea 0x0(%esi),%esi delta_interval = first_watchdog->delta_interval; if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 1186a4: 31 ff xor %edi,%edi 1186a6: eb c5 jmp 11866d <_Timer_server_Schedule_operation_method+0xe1> } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 1186a8: 03 7d d4 add -0x2c(%ebp),%edi delta_interval += delta; 1186ab: 29 cf sub %ecx,%edi 1186ad: e9 67 ff ff ff jmp 118619 <_Timer_server_Schedule_operation_method+0x8d> */ delta = snapshot - last_snapshot; if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 1186b2: 31 ff xor %edi,%edi <== NOT EXECUTED 1186b4: e9 60 ff ff ff jmp 118619 <_Timer_server_Schedule_operation_method+0x8d><== NOT EXECUTED =============================================================================== 0010ee48 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 10ee48: 55 push %ebp 10ee49: 89 e5 mov %esp,%ebp 10ee4b: 57 push %edi 10ee4c: 56 push %esi 10ee4d: 53 push %ebx 10ee4e: 83 ec 2c sub $0x2c,%esp 10ee51: 8b 45 08 mov 0x8(%ebp),%eax 10ee54: 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; 10ee57: 8b 38 mov (%eax),%edi left += lhs->tv_nsec; 10ee59: 8b 70 04 mov 0x4(%eax),%esi right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10ee5c: bb 00 ca 9a 3b mov $0x3b9aca00,%ebx 10ee61: 8b 01 mov (%ecx),%eax 10ee63: f7 eb imul %ebx 10ee65: 89 45 e0 mov %eax,-0x20(%ebp) 10ee68: 89 55 e4 mov %edx,-0x1c(%ebp) right += rhs->tv_nsec; 10ee6b: 8b 41 04 mov 0x4(%ecx),%eax 10ee6e: 99 cltd 10ee6f: 01 45 e0 add %eax,-0x20(%ebp) 10ee72: 11 55 e4 adc %edx,-0x1c(%ebp) if ( right == 0 ) { 10ee75: 8b 55 e4 mov -0x1c(%ebp),%edx 10ee78: 0b 55 e0 or -0x20(%ebp),%edx 10ee7b: 74 73 je 10eef0 <_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; 10ee7d: 89 f8 mov %edi,%eax 10ee7f: f7 eb imul %ebx 10ee81: 89 45 d0 mov %eax,-0x30(%ebp) 10ee84: 89 55 d4 mov %edx,-0x2c(%ebp) left += lhs->tv_nsec; 10ee87: 89 f7 mov %esi,%edi 10ee89: c1 ff 1f sar $0x1f,%edi 10ee8c: 01 75 d0 add %esi,-0x30(%ebp) 10ee8f: 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; 10ee92: 69 4d d4 a0 86 01 00 imul $0x186a0,-0x2c(%ebp),%ecx 10ee99: bb a0 86 01 00 mov $0x186a0,%ebx 10ee9e: 8b 45 d0 mov -0x30(%ebp),%eax 10eea1: f7 e3 mul %ebx 10eea3: 8d 34 11 lea (%ecx,%edx,1),%esi 10eea6: ff 75 e4 pushl -0x1c(%ebp) 10eea9: ff 75 e0 pushl -0x20(%ebp) 10eeac: 56 push %esi 10eead: 50 push %eax 10eeae: e8 e9 0a 01 00 call 11f99c <__udivdi3> 10eeb3: 83 c4 10 add $0x10,%esp 10eeb6: 89 c3 mov %eax,%ebx 10eeb8: 89 d6 mov %edx,%esi *ival_percentage = answer / 1000; 10eeba: 6a 00 push $0x0 10eebc: 68 e8 03 00 00 push $0x3e8 10eec1: 52 push %edx 10eec2: 50 push %eax 10eec3: e8 d4 0a 01 00 call 11f99c <__udivdi3> 10eec8: 83 c4 10 add $0x10,%esp 10eecb: 8b 55 10 mov 0x10(%ebp),%edx 10eece: 89 02 mov %eax,(%edx) *fval_percentage = answer % 1000; 10eed0: 6a 00 push $0x0 10eed2: 68 e8 03 00 00 push $0x3e8 10eed7: 56 push %esi 10eed8: 53 push %ebx 10eed9: e8 ce 0b 01 00 call 11faac <__umoddi3> 10eede: 83 c4 10 add $0x10,%esp 10eee1: 8b 55 14 mov 0x14(%ebp),%edx 10eee4: 89 02 mov %eax,(%edx) } 10eee6: 8d 65 f4 lea -0xc(%ebp),%esp 10eee9: 5b pop %ebx 10eeea: 5e pop %esi 10eeeb: 5f pop %edi 10eeec: c9 leave 10eeed: c3 ret 10eeee: 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; 10eef0: 8b 45 10 mov 0x10(%ebp),%eax 10eef3: c7 00 00 00 00 00 movl $0x0,(%eax) *fval_percentage = 0; 10eef9: 8b 55 14 mov 0x14(%ebp),%edx 10eefc: c7 02 00 00 00 00 movl $0x0,(%edx) answer = (left * 100000) / right; *ival_percentage = answer / 1000; *fval_percentage = answer % 1000; } 10ef02: 8d 65 f4 lea -0xc(%ebp),%esp 10ef05: 5b pop %ebx 10ef06: 5e pop %esi 10ef07: 5f pop %edi 10ef08: c9 leave 10ef09: c3 ret =============================================================================== 0011f1d0 <_Timespec_Is_valid>: #include bool _Timespec_Is_valid( const struct timespec *time ) { 11f1d0: 55 push %ebp 11f1d1: 89 e5 mov %esp,%ebp 11f1d3: 8b 45 08 mov 0x8(%ebp),%eax if ( !time ) 11f1d6: 85 c0 test %eax,%eax 11f1d8: 74 1a je 11f1f4 <_Timespec_Is_valid+0x24> return false; if ( time->tv_sec < 0 ) 11f1da: 8b 10 mov (%eax),%edx 11f1dc: 85 d2 test %edx,%edx 11f1de: 78 14 js 11f1f4 <_Timespec_Is_valid+0x24> return false; if ( time->tv_nsec < 0 ) 11f1e0: 8b 40 04 mov 0x4(%eax),%eax 11f1e3: 85 c0 test %eax,%eax 11f1e5: 78 0d js 11f1f4 <_Timespec_Is_valid+0x24> #include #include #include bool _Timespec_Is_valid( 11f1e7: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax 11f1ec: 0f 96 c0 setbe %al if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return false; return true; } 11f1ef: c9 leave 11f1f0: c3 ret 11f1f1: 8d 76 00 lea 0x0(%esi),%esi if ( time->tv_sec < 0 ) return false; if ( time->tv_nsec < 0 ) return false; 11f1f4: 31 c0 xor %eax,%eax if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return false; return true; } 11f1f6: c9 leave 11f1f7: c3 ret =============================================================================== 0011f1f8 <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 11f1f8: 55 push %ebp 11f1f9: 89 e5 mov %esp,%ebp 11f1fb: 56 push %esi 11f1fc: 53 push %ebx 11f1fd: 8b 5d 08 mov 0x8(%ebp),%ebx uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 11f200: 8b 33 mov (%ebx),%esi 11f202: 85 f6 test %esi,%esi 11f204: 75 07 jne 11f20d <_Timespec_To_ticks+0x15> 11f206: 8b 43 04 mov 0x4(%ebx),%eax 11f209: 85 c0 test %eax,%eax 11f20b: 74 37 je 11f244 <_Timespec_To_ticks+0x4c> return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 11f20d: e8 ba 01 00 00 call 11f3cc 11f212: 89 c1 mov %eax,%ecx 11f214: 0f af ce imul %esi,%ecx ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick(); 11f217: a1 8c 32 12 00 mov 0x12328c,%eax 11f21c: 8d 04 80 lea (%eax,%eax,4),%eax 11f21f: 8d 04 80 lea (%eax,%eax,4),%eax 11f222: 8d 34 80 lea (%eax,%eax,4),%esi 11f225: c1 e6 03 shl $0x3,%esi 11f228: 8b 43 04 mov 0x4(%ebx),%eax 11f22b: 31 d2 xor %edx,%edx 11f22d: f7 f6 div %esi if (ticks) 11f22f: 01 c8 add %ecx,%eax 11f231: 74 05 je 11f238 <_Timespec_To_ticks+0x40> return ticks; return 1; } 11f233: 5b pop %ebx 11f234: 5e pop %esi 11f235: c9 leave 11f236: c3 ret 11f237: 90 nop ticks += time->tv_nsec / rtems_configuration_get_nanoseconds_per_tick(); if (ticks) return ticks; return 1; 11f238: b8 01 00 00 00 mov $0x1,%eax } 11f23d: 5b pop %ebx 11f23e: 5e pop %esi 11f23f: c9 leave 11f240: c3 ret 11f241: 8d 76 00 lea 0x0(%esi),%esi ) { uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) return 0; 11f244: 31 c0 xor %eax,%eax if (ticks) return ticks; return 1; } 11f246: 5b pop %ebx 11f247: 5e pop %esi 11f248: c9 leave 11f249: c3 ret =============================================================================== 0010d8a4 <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10d8a4: 55 push %ebp 10d8a5: 89 e5 mov %esp,%ebp 10d8a7: 57 push %edi 10d8a8: 56 push %esi 10d8a9: 53 push %ebx 10d8aa: 83 ec 1c sub $0x1c,%esp 10d8ad: 8b 75 08 mov 0x8(%ebp),%esi 10d8b0: 8b 7d 10 mov 0x10(%ebp),%edi 10d8b3: 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 ); } } 10d8b6: 8b 1d 14 67 12 00 mov 0x126714,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10d8bc: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx 10d8c2: 74 25 je 10d8e9 <_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 ); 10d8c4: 0f b6 c0 movzbl %al,%eax 10d8c7: 89 45 e4 mov %eax,-0x1c(%ebp) 10d8ca: 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 ) 10d8cc: 8b 43 30 mov 0x30(%ebx),%eax 10d8cf: 85 c0 test %eax,%eax 10d8d1: 74 0b je 10d8de <_User_extensions_Fatal+0x3a> (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10d8d3: 52 push %edx 10d8d4: 57 push %edi 10d8d5: ff 75 e4 pushl -0x1c(%ebp) 10d8d8: 56 push %esi 10d8d9: ff d0 call *%eax 10d8db: 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 ) { 10d8de: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10d8e1: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx 10d8e7: 75 e3 jne 10d8cc <_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 ); } } 10d8e9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d8ec: 5b pop %ebx <== NOT EXECUTED 10d8ed: 5e pop %esi <== NOT EXECUTED 10d8ee: 5f pop %edi <== NOT EXECUTED 10d8ef: c9 leave <== NOT EXECUTED 10d8f0: c3 ret <== NOT EXECUTED =============================================================================== 0010d768 <_User_extensions_Handler_initialization>: #include #include #include void _User_extensions_Handler_initialization(void) { 10d768: 55 push %ebp 10d769: 89 e5 mov %esp,%ebp 10d76b: 57 push %edi 10d76c: 56 push %esi 10d76d: 53 push %ebx 10d76e: 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; 10d771: a1 38 23 12 00 mov 0x122338,%eax 10d776: 89 45 dc mov %eax,-0x24(%ebp) initial_extensions = Configuration.User_extension_table; 10d779: 8b 35 3c 23 12 00 mov 0x12233c,%esi Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10d77f: c7 05 0c 67 12 00 10 movl $0x126710,0x12670c 10d786: 67 12 00 head->previous = NULL; 10d789: c7 05 10 67 12 00 00 movl $0x0,0x126710 10d790: 00 00 00 tail->previous = head; 10d793: c7 05 14 67 12 00 0c movl $0x12670c,0x126714 10d79a: 67 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10d79d: c7 05 f0 64 12 00 f4 movl $0x1264f4,0x1264f0 10d7a4: 64 12 00 head->previous = NULL; 10d7a7: c7 05 f4 64 12 00 00 movl $0x0,0x1264f4 10d7ae: 00 00 00 tail->previous = head; 10d7b1: c7 05 f8 64 12 00 f0 movl $0x1264f0,0x1264f8 10d7b8: 64 12 00 _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10d7bb: 85 f6 test %esi,%esi 10d7bd: 74 64 je 10d823 <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN extension = (User_extensions_Control *) _Workspace_Allocate_or_fatal_error( 10d7bf: 89 c2 mov %eax,%edx 10d7c1: 8d 04 40 lea (%eax,%eax,2),%eax 10d7c4: 8d 0c 82 lea (%edx,%eax,4),%ecx 10d7c7: c1 e1 02 shl $0x2,%ecx 10d7ca: 83 ec 0c sub $0xc,%esp 10d7cd: 51 push %ecx 10d7ce: 89 4d d8 mov %ecx,-0x28(%ebp) 10d7d1: e8 ce 04 00 00 call 10dca4 <_Workspace_Allocate_or_fatal_error> 10d7d6: 89 c3 mov %eax,%ebx number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10d7d8: 31 c0 xor %eax,%eax 10d7da: 8b 4d d8 mov -0x28(%ebp),%ecx 10d7dd: 89 df mov %ebx,%edi 10d7df: f3 aa rep stos %al,%es:(%edi) extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10d7e1: 83 c4 10 add $0x10,%esp 10d7e4: 8b 45 dc mov -0x24(%ebp),%eax 10d7e7: 85 c0 test %eax,%eax 10d7e9: 74 38 je 10d823 <_User_extensions_Handler_initialization+0xbb><== NEVER TAKEN 10d7eb: 89 75 e4 mov %esi,-0x1c(%ebp) 10d7ee: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) 10d7f5: 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; 10d7f8: 8d 7b 14 lea 0x14(%ebx),%edi 10d7fb: 8b 75 e4 mov -0x1c(%ebp),%esi 10d7fe: b9 08 00 00 00 mov $0x8,%ecx 10d803: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _User_extensions_Add_set( extension ); 10d805: 83 ec 0c sub $0xc,%esp 10d808: 53 push %ebx 10d809: e8 46 30 00 00 call 110854 <_User_extensions_Add_set> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; 10d80e: 83 c3 34 add $0x34,%ebx extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10d811: ff 45 e0 incl -0x20(%ebp) 10d814: 83 45 e4 20 addl $0x20,-0x1c(%ebp) 10d818: 83 c4 10 add $0x10,%esp 10d81b: 8b 45 e0 mov -0x20(%ebp),%eax 10d81e: 39 45 dc cmp %eax,-0x24(%ebp) 10d821: 77 d5 ja 10d7f8 <_User_extensions_Handler_initialization+0x90> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; } } } 10d823: 8d 65 f4 lea -0xc(%ebp),%esp 10d826: 5b pop %ebx 10d827: 5e pop %esi 10d828: 5f pop %edi 10d829: c9 leave 10d82a: c3 ret =============================================================================== 0010ebf8 <_User_extensions_Remove_set>: #include void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 10ebf8: 55 push %ebp 10ebf9: 89 e5 mov %esp,%ebp 10ebfb: 53 push %ebx 10ebfc: 83 ec 10 sub $0x10,%esp 10ebff: 8b 5d 08 mov 0x8(%ebp),%ebx _Chain_Extract( &the_extension->Node ); 10ec02: 53 push %ebx 10ec03: e8 3c dc ff ff call 10c844 <_Chain_Extract> /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 10ec08: 83 c4 10 add $0x10,%esp 10ec0b: 8b 43 24 mov 0x24(%ebx),%eax 10ec0e: 85 c0 test %eax,%eax 10ec10: 74 12 je 10ec24 <_User_extensions_Remove_set+0x2c> _Chain_Extract( &the_extension->Switch.Node ); 10ec12: 83 c3 08 add $0x8,%ebx 10ec15: 89 5d 08 mov %ebx,0x8(%ebp) } 10ec18: 8b 5d fc mov -0x4(%ebp),%ebx 10ec1b: c9 leave /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) _Chain_Extract( &the_extension->Switch.Node ); 10ec1c: e9 23 dc ff ff jmp 10c844 <_Chain_Extract> 10ec21: 8d 76 00 lea 0x0(%esi),%esi } 10ec24: 8b 5d fc mov -0x4(%ebp),%ebx 10ec27: c9 leave 10ec28: c3 ret =============================================================================== 0010d82c <_User_extensions_Thread_begin>: #include void _User_extensions_Thread_begin ( Thread_Control *executing ) { 10d82c: 55 push %ebp 10d82d: 89 e5 mov %esp,%ebp 10d82f: 56 push %esi 10d830: 53 push %ebx 10d831: 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 ); } } 10d834: 8b 1d 0c 67 12 00 mov 0x12670c,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10d83a: 81 fb 10 67 12 00 cmp $0x126710,%ebx 10d840: 74 1c je 10d85e <_User_extensions_Thread_begin+0x32><== NEVER TAKEN 10d842: 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 ) 10d844: 8b 43 28 mov 0x28(%ebx),%eax 10d847: 85 c0 test %eax,%eax 10d849: 74 09 je 10d854 <_User_extensions_Thread_begin+0x28> (*the_extension->Callouts.thread_begin)( executing ); 10d84b: 83 ec 0c sub $0xc,%esp 10d84e: 56 push %esi 10d84f: ff d0 call *%eax 10d851: 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 ) { 10d854: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10d856: 81 fb 10 67 12 00 cmp $0x126710,%ebx 10d85c: 75 e6 jne 10d844 <_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 ); } } 10d85e: 8d 65 f8 lea -0x8(%ebp),%esp 10d861: 5b pop %ebx 10d862: 5e pop %esi 10d863: c9 leave 10d864: c3 ret =============================================================================== 0010d8f4 <_User_extensions_Thread_create>: #include bool _User_extensions_Thread_create ( Thread_Control *the_thread ) { 10d8f4: 55 push %ebp 10d8f5: 89 e5 mov %esp,%ebp 10d8f7: 56 push %esi 10d8f8: 53 push %ebx 10d8f9: 8b 75 08 mov 0x8(%ebp),%esi return false; } } return true; } 10d8fc: 8b 1d 0c 67 12 00 mov 0x12670c,%ebx { Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _Chain_First( &_User_extensions_List ); 10d902: 81 fb 10 67 12 00 cmp $0x126710,%ebx 10d908: 74 26 je 10d930 <_User_extensions_Thread_create+0x3c><== NEVER TAKEN 10d90a: 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 ) { 10d90c: 8b 43 14 mov 0x14(%ebx),%eax 10d90f: 85 c0 test %eax,%eax 10d911: 74 13 je 10d926 <_User_extensions_Thread_create+0x32> status = (*the_extension->Callouts.thread_create)( 10d913: 83 ec 08 sub $0x8,%esp 10d916: 56 push %esi 10d917: ff 35 78 67 12 00 pushl 0x126778 10d91d: ff d0 call *%eax _Thread_Executing, the_thread ); if ( !status ) 10d91f: 83 c4 10 add $0x10,%esp 10d922: 84 c0 test %al,%al 10d924: 74 16 je 10d93c <_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 ) { 10d926: 8b 1b mov (%ebx),%ebx { Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _Chain_First( &_User_extensions_List ); 10d928: 81 fb 10 67 12 00 cmp $0x126710,%ebx 10d92e: 75 dc jne 10d90c <_User_extensions_Thread_create+0x18> if ( !status ) return false; } } return true; 10d930: b0 01 mov $0x1,%al } 10d932: 8d 65 f8 lea -0x8(%ebp),%esp 10d935: 5b pop %ebx 10d936: 5e pop %esi 10d937: c9 leave 10d938: c3 ret 10d939: 8d 76 00 lea 0x0(%esi),%esi status = (*the_extension->Callouts.thread_create)( _Thread_Executing, the_thread ); if ( !status ) return false; 10d93c: 31 c0 xor %eax,%eax } } return true; } 10d93e: 8d 65 f8 lea -0x8(%ebp),%esp 10d941: 5b pop %ebx 10d942: 5e pop %esi 10d943: c9 leave 10d944: c3 ret =============================================================================== 0010d948 <_User_extensions_Thread_delete>: #include void _User_extensions_Thread_delete ( Thread_Control *the_thread ) { 10d948: 55 push %ebp 10d949: 89 e5 mov %esp,%ebp 10d94b: 56 push %esi 10d94c: 53 push %ebx 10d94d: 8b 75 08 mov 0x8(%ebp),%esi (*the_extension->Callouts.thread_delete)( _Thread_Executing, the_thread ); } } 10d950: 8b 1d 14 67 12 00 mov 0x126714,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10d956: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx 10d95c: 74 23 je 10d981 <_User_extensions_Thread_delete+0x39><== NEVER TAKEN 10d95e: 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 ) 10d960: 8b 43 20 mov 0x20(%ebx),%eax 10d963: 85 c0 test %eax,%eax 10d965: 74 0f je 10d976 <_User_extensions_Thread_delete+0x2e> (*the_extension->Callouts.thread_delete)( 10d967: 83 ec 08 sub $0x8,%esp 10d96a: 56 push %esi 10d96b: ff 35 78 67 12 00 pushl 0x126778 10d971: ff d0 call *%eax 10d973: 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 ) { 10d976: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10d979: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx 10d97f: 75 df jne 10d960 <_User_extensions_Thread_delete+0x18> (*the_extension->Callouts.thread_delete)( _Thread_Executing, the_thread ); } } 10d981: 8d 65 f8 lea -0x8(%ebp),%esp 10d984: 5b pop %ebx 10d985: 5e pop %esi 10d986: c9 leave 10d987: c3 ret =============================================================================== 0010d868 <_User_extensions_Thread_exitted>: void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 10d868: 55 push %ebp 10d869: 89 e5 mov %esp,%ebp 10d86b: 56 push %esi 10d86c: 53 push %ebx 10d86d: 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 ); } } 10d870: 8b 1d 14 67 12 00 mov 0x126714,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10d876: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx 10d87c: 74 1d je 10d89b <_User_extensions_Thread_exitted+0x33><== NEVER TAKEN 10d87e: 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 ) 10d880: 8b 43 2c mov 0x2c(%ebx),%eax 10d883: 85 c0 test %eax,%eax 10d885: 74 09 je 10d890 <_User_extensions_Thread_exitted+0x28> (*the_extension->Callouts.thread_exitted)( executing ); 10d887: 83 ec 0c sub $0xc,%esp 10d88a: 56 push %esi 10d88b: ff d0 call *%eax 10d88d: 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 ) { 10d890: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10d893: 81 fb 0c 67 12 00 cmp $0x12670c,%ebx 10d899: 75 e5 jne 10d880 <_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 ); } } 10d89b: 8d 65 f8 lea -0x8(%ebp),%esp 10d89e: 5b pop %ebx 10d89f: 5e pop %esi 10d8a0: c9 leave 10d8a1: c3 ret =============================================================================== 0010e4d4 <_User_extensions_Thread_restart>: #include void _User_extensions_Thread_restart ( Thread_Control *the_thread ) { 10e4d4: 55 push %ebp 10e4d5: 89 e5 mov %esp,%ebp 10e4d7: 56 push %esi 10e4d8: 53 push %ebx 10e4d9: 8b 75 08 mov 0x8(%ebp),%esi (*the_extension->Callouts.thread_restart)( _Thread_Executing, the_thread ); } } 10e4dc: 8b 1d ec 76 12 00 mov 0x1276ec,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e4e2: 81 fb f0 76 12 00 cmp $0x1276f0,%ebx 10e4e8: 74 22 je 10e50c <_User_extensions_Thread_restart+0x38><== NEVER TAKEN 10e4ea: 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 ) 10e4ec: 8b 43 1c mov 0x1c(%ebx),%eax 10e4ef: 85 c0 test %eax,%eax 10e4f1: 74 0f je 10e502 <_User_extensions_Thread_restart+0x2e> (*the_extension->Callouts.thread_restart)( 10e4f3: 83 ec 08 sub $0x8,%esp 10e4f6: 56 push %esi 10e4f7: ff 35 58 77 12 00 pushl 0x127758 10e4fd: ff d0 call *%eax 10e4ff: 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 ) { 10e502: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10e504: 81 fb f0 76 12 00 cmp $0x1276f0,%ebx 10e50a: 75 e0 jne 10e4ec <_User_extensions_Thread_restart+0x18> (*the_extension->Callouts.thread_restart)( _Thread_Executing, the_thread ); } } 10e50c: 8d 65 f8 lea -0x8(%ebp),%esp 10e50f: 5b pop %ebx 10e510: 5e pop %esi 10e511: c9 leave 10e512: c3 ret =============================================================================== 0010d988 <_User_extensions_Thread_start>: #include void _User_extensions_Thread_start ( Thread_Control *the_thread ) { 10d988: 55 push %ebp 10d989: 89 e5 mov %esp,%ebp 10d98b: 56 push %esi 10d98c: 53 push %ebx 10d98d: 8b 75 08 mov 0x8(%ebp),%esi (*the_extension->Callouts.thread_start)( _Thread_Executing, the_thread ); } } 10d990: 8b 1d 0c 67 12 00 mov 0x12670c,%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10d996: 81 fb 10 67 12 00 cmp $0x126710,%ebx 10d99c: 74 22 je 10d9c0 <_User_extensions_Thread_start+0x38><== NEVER TAKEN 10d99e: 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 ) 10d9a0: 8b 43 18 mov 0x18(%ebx),%eax 10d9a3: 85 c0 test %eax,%eax 10d9a5: 74 0f je 10d9b6 <_User_extensions_Thread_start+0x2e> (*the_extension->Callouts.thread_start)( 10d9a7: 83 ec 08 sub $0x8,%esp 10d9aa: 56 push %esi 10d9ab: ff 35 78 67 12 00 pushl 0x126778 10d9b1: ff d0 call *%eax 10d9b3: 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 ) { 10d9b6: 8b 1b mov (%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_First( &_User_extensions_List ); 10d9b8: 81 fb 10 67 12 00 cmp $0x126710,%ebx 10d9be: 75 e0 jne 10d9a0 <_User_extensions_Thread_start+0x18> (*the_extension->Callouts.thread_start)( _Thread_Executing, the_thread ); } } 10d9c0: 8d 65 f8 lea -0x8(%ebp),%esp 10d9c3: 5b pop %ebx 10d9c4: 5e pop %esi 10d9c5: c9 leave 10d9c6: c3 ret =============================================================================== 0010d9c8 <_User_extensions_Thread_switch>: void _User_extensions_Thread_switch ( Thread_Control *executing, Thread_Control *heir ) { 10d9c8: 55 push %ebp 10d9c9: 89 e5 mov %esp,%ebp 10d9cb: 57 push %edi 10d9cc: 56 push %esi 10d9cd: 53 push %ebx 10d9ce: 83 ec 0c sub $0xc,%esp 10d9d1: 8b 7d 08 mov 0x8(%ebp),%edi 10d9d4: 8b 75 0c mov 0xc(%ebp),%esi the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); } } 10d9d7: 8b 1d f0 64 12 00 mov 0x1264f0,%ebx ) { Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _Chain_First( &_User_extensions_Switches_list ); 10d9dd: 81 fb f4 64 12 00 cmp $0x1264f4,%ebx 10d9e3: 74 18 je 10d9fd <_User_extensions_Thread_switch+0x35><== NEVER TAKEN 10d9e5: 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 ); 10d9e8: 83 ec 08 sub $0x8,%esp 10d9eb: 56 push %esi 10d9ec: 57 push %edi 10d9ed: 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 ) { 10d9f0: 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 ); 10d9f2: 83 c4 10 add $0x10,%esp 10d9f5: 81 fb f4 64 12 00 cmp $0x1264f4,%ebx 10d9fb: 75 eb jne 10d9e8 <_User_extensions_Thread_switch+0x20> the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); } } 10d9fd: 8d 65 f4 lea -0xc(%ebp),%esp 10da00: 5b pop %ebx 10da01: 5e pop %esi 10da02: 5f pop %edi 10da03: c9 leave 10da04: c3 ret =============================================================================== 0010f228 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10f228: 55 push %ebp 10f229: 89 e5 mov %esp,%ebp 10f22b: 57 push %edi 10f22c: 56 push %esi 10f22d: 53 push %ebx 10f22e: 83 ec 1c sub $0x1c,%esp 10f231: 8b 75 08 mov 0x8(%ebp),%esi 10f234: 8b 4d 0c mov 0xc(%ebp),%ecx 10f237: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 10f23a: 9c pushf 10f23b: fa cli 10f23c: 58 pop %eax } } _ISR_Enable( level ); } 10f23d: 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 ); 10f23f: 8d 7e 04 lea 0x4(%esi),%edi 10f242: 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 ) ) { 10f245: 39 fa cmp %edi,%edx 10f247: 74 3d je 10f286 <_Watchdog_Adjust+0x5e> switch ( direction ) { 10f249: 85 c9 test %ecx,%ecx 10f24b: 75 43 jne 10f290 <_Watchdog_Adjust+0x68> case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10f24d: 85 db test %ebx,%ebx 10f24f: 74 35 je 10f286 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN if ( units < _Watchdog_First( header )->delta_interval ) { 10f251: 8b 7a 10 mov 0x10(%edx),%edi 10f254: 39 fb cmp %edi,%ebx 10f256: 73 0f jae 10f267 <_Watchdog_Adjust+0x3f> <== ALWAYS TAKEN 10f258: eb 3e jmp 10f298 <_Watchdog_Adjust+0x70> <== NOT EXECUTED 10f25a: 66 90 xchg %ax,%ax <== NOT EXECUTED switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10f25c: 29 fb sub %edi,%ebx 10f25e: 74 26 je 10f286 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN if ( units < _Watchdog_First( header )->delta_interval ) { 10f260: 8b 7a 10 mov 0x10(%edx),%edi 10f263: 39 df cmp %ebx,%edi 10f265: 77 31 ja 10f298 <_Watchdog_Adjust+0x70> _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 10f267: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx) _ISR_Enable( level ); 10f26e: 50 push %eax 10f26f: 9d popf _Watchdog_Tickle( header ); 10f270: 83 ec 0c sub $0xc,%esp 10f273: 56 push %esi 10f274: e8 d3 01 00 00 call 10f44c <_Watchdog_Tickle> _ISR_Disable( level ); 10f279: 9c pushf 10f27a: fa cli 10f27b: 58 pop %eax } } _ISR_Enable( level ); } 10f27c: 8b 16 mov (%esi),%edx _Watchdog_Tickle( header ); _ISR_Disable( level ); if ( _Chain_Is_empty( header ) ) 10f27e: 83 c4 10 add $0x10,%esp 10f281: 39 55 e4 cmp %edx,-0x1c(%ebp) 10f284: 75 d6 jne 10f25c <_Watchdog_Adjust+0x34> } break; } } _ISR_Enable( level ); 10f286: 50 push %eax 10f287: 9d popf } 10f288: 8d 65 f4 lea -0xc(%ebp),%esp 10f28b: 5b pop %ebx 10f28c: 5e pop %esi 10f28d: 5f pop %edi 10f28e: c9 leave 10f28f: c3 ret * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { switch ( direction ) { 10f290: 49 dec %ecx 10f291: 75 f3 jne 10f286 <_Watchdog_Adjust+0x5e> <== NEVER TAKEN case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10f293: 01 5a 10 add %ebx,0x10(%edx) break; 10f296: eb ee jmp 10f286 <_Watchdog_Adjust+0x5e> case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; 10f298: 29 df sub %ebx,%edi 10f29a: 89 7a 10 mov %edi,0x10(%edx) break; 10f29d: eb e7 jmp 10f286 <_Watchdog_Adjust+0x5e> =============================================================================== 0010da08 <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 10da08: 55 push %ebp 10da09: 89 e5 mov %esp,%ebp 10da0b: 57 push %edi 10da0c: 56 push %esi 10da0d: 53 push %ebx 10da0e: 83 ec 04 sub $0x4,%esp 10da11: 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; 10da14: 8b 3d 74 67 12 00 mov 0x126774,%edi _ISR_Disable( level ); 10da1a: 9c pushf 10da1b: fa cli 10da1c: 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 ) { 10da1f: 8b 43 08 mov 0x8(%ebx),%eax 10da22: 85 c0 test %eax,%eax 10da24: 0f 85 9e 00 00 00 jne 10dac8 <_Watchdog_Insert+0xc0> _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 10da2a: c7 43 08 01 00 00 00 movl $0x1,0x8(%ebx) _Watchdog_Sync_count++; 10da31: a1 20 66 12 00 mov 0x126620,%eax 10da36: 40 inc %eax 10da37: a3 20 66 12 00 mov %eax,0x126620 restart: delta_interval = the_watchdog->initial; 10da3c: 8b 43 0c mov 0xc(%ebx),%eax RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First( Chain_Control *header ) { return ( (Watchdog_Control *) _Chain_First( header ) ); 10da3f: 8b 4d 08 mov 0x8(%ebp),%ecx 10da42: 8b 11 mov (%ecx),%edx for ( after = _Watchdog_First( header ) ; ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10da44: 85 c0 test %eax,%eax 10da46: 74 5d je 10daa5 <_Watchdog_Insert+0x9d> 10da48: 8b 32 mov (%edx),%esi 10da4a: 85 f6 test %esi,%esi 10da4c: 74 57 je 10daa5 <_Watchdog_Insert+0x9d> break; if ( delta_interval < after->delta_interval ) { 10da4e: 8b 4a 10 mov 0x10(%edx),%ecx 10da51: 39 c8 cmp %ecx,%eax 10da53: 73 22 jae 10da77 <_Watchdog_Insert+0x6f> 10da55: eb 49 jmp 10daa0 <_Watchdog_Insert+0x98> 10da57: 90 nop if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 10da58: 8b 35 a4 65 12 00 mov 0x1265a4,%esi 10da5e: 39 f7 cmp %esi,%edi 10da60: 72 72 jb 10dad4 <_Watchdog_Insert+0xcc> if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; break; } delta_interval -= after->delta_interval; 10da62: 29 c8 sub %ecx,%eax exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; _Watchdog_Sync_count--; _ISR_Enable( level ); } 10da64: 8b 12 mov (%edx),%edx for ( after = _Watchdog_First( header ) ; ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10da66: 85 c0 test %eax,%eax 10da68: 74 3b je 10daa5 <_Watchdog_Insert+0x9d> 10da6a: 8b 0a mov (%edx),%ecx 10da6c: 85 c9 test %ecx,%ecx 10da6e: 74 35 je 10daa5 <_Watchdog_Insert+0x9d> break; if ( delta_interval < after->delta_interval ) { 10da70: 8b 4a 10 mov 0x10(%edx),%ecx 10da73: 39 c1 cmp %eax,%ecx 10da75: 77 29 ja 10daa0 <_Watchdog_Insert+0x98> break; } delta_interval -= after->delta_interval; _ISR_Flash( level ); 10da77: ff 75 f0 pushl -0x10(%ebp) 10da7a: 9d popf 10da7b: fa cli if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 10da7c: 83 7b 08 01 cmpl $0x1,0x8(%ebx) 10da80: 74 d6 je 10da58 <_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; 10da82: 89 3d a4 65 12 00 mov %edi,0x1265a4 _Watchdog_Sync_count--; 10da88: a1 20 66 12 00 mov 0x126620,%eax 10da8d: 48 dec %eax 10da8e: a3 20 66 12 00 mov %eax,0x126620 _ISR_Enable( level ); 10da93: ff 75 f0 pushl -0x10(%ebp) 10da96: 9d popf } 10da97: 58 pop %eax 10da98: 5b pop %ebx 10da99: 5e pop %esi 10da9a: 5f pop %edi 10da9b: c9 leave 10da9c: c3 ret 10da9d: 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; 10daa0: 29 c1 sub %eax,%ecx 10daa2: 89 4a 10 mov %ecx,0x10(%edx) RTEMS_INLINE_ROUTINE void _Watchdog_Activate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_ACTIVE; 10daa5: c7 43 08 02 00 00 00 movl $0x2,0x8(%ebx) } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 10daac: 89 43 10 mov %eax,0x10(%ebx) _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 10daaf: 8b 42 04 mov 0x4(%edx),%eax Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10dab2: 89 43 04 mov %eax,0x4(%ebx) before_node = after_node->next; 10dab5: 8b 10 mov (%eax),%edx after_node->next = the_node; 10dab7: 89 18 mov %ebx,(%eax) the_node->next = before_node; 10dab9: 89 13 mov %edx,(%ebx) before_node->previous = the_node; 10dabb: 89 5a 04 mov %ebx,0x4(%edx) the_watchdog->start_time = _Watchdog_Ticks_since_boot; 10dabe: a1 24 66 12 00 mov 0x126624,%eax 10dac3: 89 43 14 mov %eax,0x14(%ebx) 10dac6: eb ba jmp 10da82 <_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 ); 10dac8: ff 75 f0 pushl -0x10(%ebp) 10dacb: 9d popf exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; _Watchdog_Sync_count--; _ISR_Enable( level ); } 10dacc: 58 pop %eax 10dacd: 5b pop %ebx 10dace: 5e pop %esi 10dacf: 5f pop %edi 10dad0: c9 leave 10dad1: c3 ret 10dad2: 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; 10dad4: 89 3d a4 65 12 00 mov %edi,0x1265a4 goto restart; 10dada: e9 5d ff ff ff jmp 10da3c <_Watchdog_Insert+0x34> =============================================================================== 0010db48 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10db48: 55 push %ebp 10db49: 89 e5 mov %esp,%ebp 10db4b: 56 push %esi 10db4c: 53 push %ebx 10db4d: 8b 55 08 mov 0x8(%ebp),%edx ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10db50: 9c pushf 10db51: fa cli 10db52: 59 pop %ecx previous_state = the_watchdog->state; 10db53: 8b 42 08 mov 0x8(%edx),%eax switch ( previous_state ) { 10db56: 83 f8 01 cmp $0x1,%eax 10db59: 74 4d je 10dba8 <_Watchdog_Remove+0x60> 10db5b: 73 0f jae 10db6c <_Watchdog_Remove+0x24> _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10db5d: 8b 1d 24 66 12 00 mov 0x126624,%ebx 10db63: 89 5a 18 mov %ebx,0x18(%edx) _ISR_Enable( level ); 10db66: 51 push %ecx 10db67: 9d popf return( previous_state ); } 10db68: 5b pop %ebx 10db69: 5e pop %esi 10db6a: c9 leave 10db6b: c3 ret Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); previous_state = the_watchdog->state; switch ( previous_state ) { 10db6c: 83 f8 03 cmp $0x3,%eax 10db6f: 77 ec ja 10db5d <_Watchdog_Remove+0x15> <== NEVER TAKEN break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10db71: 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 ); } 10db78: 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) ) 10db7a: 8b 33 mov (%ebx),%esi 10db7c: 85 f6 test %esi,%esi 10db7e: 74 06 je 10db86 <_Watchdog_Remove+0x3e> next_watchdog->delta_interval += the_watchdog->delta_interval; 10db80: 8b 72 10 mov 0x10(%edx),%esi 10db83: 01 73 10 add %esi,0x10(%ebx) if ( _Watchdog_Sync_count ) 10db86: 8b 35 20 66 12 00 mov 0x126620,%esi 10db8c: 85 f6 test %esi,%esi 10db8e: 74 0c je 10db9c <_Watchdog_Remove+0x54> _Watchdog_Sync_level = _ISR_Nest_level; 10db90: 8b 35 74 67 12 00 mov 0x126774,%esi 10db96: 89 35 a4 65 12 00 mov %esi,0x1265a4 { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 10db9c: 8b 72 04 mov 0x4(%edx),%esi next->previous = previous; 10db9f: 89 73 04 mov %esi,0x4(%ebx) previous->next = next; 10dba2: 89 1e mov %ebx,(%esi) 10dba4: eb b7 jmp 10db5d <_Watchdog_Remove+0x15> 10dba6: 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; 10dba8: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) break; 10dbaf: eb ac jmp 10db5d <_Watchdog_Remove+0x15> =============================================================================== 0010ee6c <_Watchdog_Report>: void _Watchdog_Report( const char *name, Watchdog_Control *watch ) { 10ee6c: 55 push %ebp 10ee6d: 89 e5 mov %esp,%ebp 10ee6f: 57 push %edi 10ee70: 56 push %esi 10ee71: 53 push %ebx 10ee72: 83 ec 2c sub $0x2c,%esp 10ee75: 8b 55 08 mov 0x8(%ebp),%edx 10ee78: 8b 45 0c mov 0xc(%ebp),%eax printk( 10ee7b: 8b 78 24 mov 0x24(%eax),%edi 10ee7e: 8b 70 20 mov 0x20(%eax),%esi 10ee81: 8b 58 1c mov 0x1c(%eax),%ebx 10ee84: 8b 48 0c mov 0xc(%eax),%ecx 10ee87: 89 4d d4 mov %ecx,-0x2c(%ebp) 10ee8a: 8b 48 10 mov 0x10(%eax),%ecx 10ee8d: 89 4d e4 mov %ecx,-0x1c(%ebp) 10ee90: 85 d2 test %edx,%edx 10ee92: 74 2c je 10eec0 <_Watchdog_Report+0x54> 10ee94: b9 e3 19 12 00 mov $0x1219e3,%ecx 10ee99: 83 ec 0c sub $0xc,%esp 10ee9c: 57 push %edi 10ee9d: 56 push %esi 10ee9e: 53 push %ebx 10ee9f: 50 push %eax 10eea0: ff 75 d4 pushl -0x2c(%ebp) 10eea3: ff 75 e4 pushl -0x1c(%ebp) 10eea6: 51 push %ecx 10eea7: 52 push %edx 10eea8: 68 36 24 12 00 push $0x122436 10eead: e8 7e a1 ff ff call 109030 10eeb2: 83 c4 30 add $0x30,%esp watch, watch->routine, watch->id, watch->user_data ); } 10eeb5: 8d 65 f4 lea -0xc(%ebp),%esp 10eeb8: 5b pop %ebx 10eeb9: 5e pop %esi 10eeba: 5f pop %edi 10eebb: c9 leave 10eebc: c3 ret 10eebd: 8d 76 00 lea 0x0(%esi),%esi void _Watchdog_Report( const char *name, Watchdog_Control *watch ) { printk( 10eec0: b9 a9 22 12 00 mov $0x1222a9,%ecx 10eec5: 89 ca mov %ecx,%edx 10eec7: eb d0 jmp 10ee99 <_Watchdog_Report+0x2d> =============================================================================== 0010edfc <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) { 10edfc: 55 push %ebp 10edfd: 89 e5 mov %esp,%ebp 10edff: 57 push %edi 10ee00: 56 push %esi 10ee01: 53 push %ebx 10ee02: 83 ec 20 sub $0x20,%esp 10ee05: 8b 7d 08 mov 0x8(%ebp),%edi 10ee08: 8b 75 0c mov 0xc(%ebp),%esi ISR_Level level; Chain_Node *node; _ISR_Disable( level ); 10ee0b: 9c pushf 10ee0c: fa cli 10ee0d: 8f 45 e4 popl -0x1c(%ebp) printk( "Watchdog Chain: %s %p\n", name, header ); 10ee10: 56 push %esi 10ee11: 57 push %edi 10ee12: 68 00 24 12 00 push $0x122400 10ee17: e8 14 a2 ff ff call 109030 printk( "== end of %s \n", name ); } else { printk( "Chain is empty\n" ); } _ISR_Enable( level ); } 10ee1c: 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 ); 10ee1e: 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 ) ) { 10ee21: 83 c4 10 add $0x10,%esp 10ee24: 39 f3 cmp %esi,%ebx 10ee26: 74 31 je 10ee59 <_Watchdog_Report_chain+0x5d> node != _Chain_Tail(header) ; node = node->next ) { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); 10ee28: 83 ec 08 sub $0x8,%esp 10ee2b: 53 push %ebx 10ee2c: 6a 00 push $0x0 10ee2e: e8 39 00 00 00 call 10ee6c <_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 ) 10ee33: 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 ) ; 10ee35: 83 c4 10 add $0x10,%esp 10ee38: 39 f3 cmp %esi,%ebx 10ee3a: 75 ec jne 10ee28 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); 10ee3c: 83 ec 08 sub $0x8,%esp 10ee3f: 57 push %edi 10ee40: 68 17 24 12 00 push $0x122417 10ee45: e8 e6 a1 ff ff call 109030 10ee4a: 83 c4 10 add $0x10,%esp } else { printk( "Chain is empty\n" ); } _ISR_Enable( level ); 10ee4d: ff 75 e4 pushl -0x1c(%ebp) 10ee50: 9d popf } 10ee51: 8d 65 f4 lea -0xc(%ebp),%esp 10ee54: 5b pop %ebx 10ee55: 5e pop %esi 10ee56: 5f pop %edi 10ee57: c9 leave 10ee58: c3 ret _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); } else { printk( "Chain is empty\n" ); 10ee59: 83 ec 0c sub $0xc,%esp 10ee5c: 68 26 24 12 00 push $0x122426 10ee61: e8 ca a1 ff ff call 109030 10ee66: 83 c4 10 add $0x10,%esp 10ee69: eb e2 jmp 10ee4d <_Watchdog_Report_chain+0x51> =============================================================================== 0010dbb4 <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10dbb4: 55 push %ebp 10dbb5: 89 e5 mov %esp,%ebp 10dbb7: 57 push %edi 10dbb8: 56 push %esi 10dbb9: 53 push %ebx 10dbba: 83 ec 1c sub $0x1c,%esp 10dbbd: 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 ); 10dbc0: 9c pushf 10dbc1: fa cli 10dbc2: 5e pop %esi } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); } 10dbc3: 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 ); 10dbc5: 8d 47 04 lea 0x4(%edi),%eax 10dbc8: 89 45 e4 mov %eax,-0x1c(%ebp) * volatile data - till, 2003/7 */ _ISR_Disable( level ); if ( _Chain_Is_empty( header ) ) 10dbcb: 39 c3 cmp %eax,%ebx 10dbcd: 74 11 je 10dbe0 <_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) { 10dbcf: 8b 43 10 mov 0x10(%ebx),%eax 10dbd2: 85 c0 test %eax,%eax 10dbd4: 74 34 je 10dc0a <_Watchdog_Tickle+0x56> the_watchdog->delta_interval--; 10dbd6: 48 dec %eax 10dbd7: 89 43 10 mov %eax,0x10(%ebx) if ( the_watchdog->delta_interval != 0 ) 10dbda: 85 c0 test %eax,%eax 10dbdc: 74 2c je 10dc0a <_Watchdog_Tickle+0x56> 10dbde: 66 90 xchg %ax,%ax the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); 10dbe0: 56 push %esi 10dbe1: 9d popf } 10dbe2: 8d 65 f4 lea -0xc(%ebp),%esp 10dbe5: 5b pop %ebx 10dbe6: 5e pop %esi 10dbe7: 5f pop %edi 10dbe8: c9 leave 10dbe9: c3 ret _ISR_Enable( level ); switch( watchdog_state ) { case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10dbea: 83 ec 08 sub $0x8,%esp 10dbed: ff 73 24 pushl 0x24(%ebx) 10dbf0: ff 73 20 pushl 0x20(%ebx) 10dbf3: ff 53 1c call *0x1c(%ebx) the_watchdog->id, the_watchdog->user_data ); break; 10dbf6: 83 c4 10 add $0x10,%esp case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10dbf9: 9c pushf 10dbfa: fa cli 10dbfb: 5e pop %esi } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); } 10dbfc: 8b 1f mov (%edi),%ebx _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10dbfe: 3b 5d e4 cmp -0x1c(%ebp),%ebx 10dc01: 74 dd je 10dbe0 <_Watchdog_Tickle+0x2c> } _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && 10dc03: 8b 43 10 mov 0x10(%ebx),%eax 10dc06: 85 c0 test %eax,%eax 10dc08: 75 d6 jne 10dbe0 <_Watchdog_Tickle+0x2c> if ( the_watchdog->delta_interval != 0 ) goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10dc0a: 83 ec 0c sub $0xc,%esp 10dc0d: 53 push %ebx 10dc0e: e8 35 ff ff ff call 10db48 <_Watchdog_Remove> _ISR_Enable( level ); 10dc13: 56 push %esi 10dc14: 9d popf switch( watchdog_state ) { 10dc15: 83 c4 10 add $0x10,%esp 10dc18: 83 f8 02 cmp $0x2,%eax 10dc1b: 75 dc jne 10dbf9 <_Watchdog_Tickle+0x45> <== NEVER TAKEN 10dc1d: eb cb jmp 10dbea <_Watchdog_Tickle+0x36> =============================================================================== 0010dc20 <_Workspace_Handler_initialization>: /* * _Workspace_Handler_initialization */ void _Workspace_Handler_initialization(void) { 10dc20: 55 push %ebp 10dc21: 89 e5 mov %esp,%ebp 10dc23: 57 push %edi 10dc24: 53 push %ebx uintptr_t memory_available = 0; void *starting_address = Configuration.work_space_start; 10dc25: 8b 1d 00 23 12 00 mov 0x122300,%ebx uintptr_t size = Configuration.work_space_size; 10dc2b: 8b 15 04 23 12 00 mov 0x122304,%edx if ( Configuration.do_zero_of_workspace ) 10dc31: 80 3d 28 23 12 00 00 cmpb $0x0,0x122328 10dc38: 75 1e jne 10dc58 <_Workspace_Handler_initialization+0x38> memset( starting_address, 0, size ); memory_available = _Heap_Initialize( 10dc3a: 6a 04 push $0x4 10dc3c: 52 push %edx 10dc3d: 53 push %ebx 10dc3e: 68 20 65 12 00 push $0x126520 10dc43: e8 18 de ff ff call 10ba60 <_Heap_Initialize> starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 10dc48: 83 c4 10 add $0x10,%esp 10dc4b: 85 c0 test %eax,%eax 10dc4d: 74 13 je 10dc62 <_Workspace_Handler_initialization+0x42> _Internal_error_Occurred( INTERNAL_ERROR_CORE, true, INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } 10dc4f: 8d 65 f8 lea -0x8(%ebp),%esp 10dc52: 5b pop %ebx 10dc53: 5f pop %edi 10dc54: c9 leave 10dc55: c3 ret 10dc56: 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 ); 10dc58: 31 c0 xor %eax,%eax 10dc5a: 89 df mov %ebx,%edi 10dc5c: 89 d1 mov %edx,%ecx 10dc5e: f3 aa rep stos %al,%es:(%edi) 10dc60: eb d8 jmp 10dc3a <_Workspace_Handler_initialization+0x1a> size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) _Internal_error_Occurred( 10dc62: 50 push %eax 10dc63: 6a 02 push $0x2 10dc65: 6a 01 push $0x1 10dc67: 6a 00 push $0x0 10dc69: e8 fa df ff ff call 10bc68 <_Internal_error_Occurred> =============================================================================== 001231e8 <__kill>: #endif int __kill( pid_t pid, int sig ) { 1231e8: 55 push %ebp <== NOT EXECUTED 1231e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 1231eb: 31 c0 xor %eax,%eax <== NOT EXECUTED 1231ed: c9 leave <== NOT EXECUTED 1231ee: c3 ret <== NOT EXECUTED =============================================================================== 00107724 <_gettimeofday>: int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { 107724: 55 push %ebp <== NOT EXECUTED 107725: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107727: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED return gettimeofday( tp, tzp ); } 10772a: c9 leave <== NOT EXECUTED int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp ); 10772b: e9 80 ff ff ff jmp 1076b0 <== NOT EXECUTED =============================================================================== 0010ba44 <_rename_r>: int _rename_r( struct _reent *ptr __attribute__((unused)), const char *old, const char *new ) { 10ba44: 55 push %ebp 10ba45: 89 e5 mov %esp,%ebp 10ba47: 57 push %edi 10ba48: 56 push %esi 10ba49: 53 push %ebx 10ba4a: 83 ec 78 sub $0x78,%esp 10ba4d: 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 ); 10ba50: 53 push %ebx 10ba51: e8 2a ea ff ff call 10a480 if ( old_parent_pathlen == 0 ) 10ba56: 83 c4 10 add $0x10,%esp 10ba59: 85 c0 test %eax,%eax 10ba5b: 0f 85 57 01 00 00 jne 10bbb8 <_rename_r+0x174> rtems_filesystem_get_start_loc( old, &i, &old_parent_loc ); 10ba61: 52 push %edx 10ba62: 8d 45 b8 lea -0x48(%ebp),%eax 10ba65: 89 45 94 mov %eax,-0x6c(%ebp) 10ba68: 50 push %eax 10ba69: 8d 45 e4 lea -0x1c(%ebp),%eax 10ba6c: 50 push %eax 10ba6d: 53 push %ebx 10ba6e: e8 e1 03 00 00 call 10be54 10ba73: 83 c4 10 add $0x10,%esp 10ba76: 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; 10ba78: 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; 10ba7c: 8d 7d cc lea -0x34(%ebp),%edi 10ba7f: b9 05 00 00 00 mov $0x5,%ecx 10ba84: 8b 75 94 mov -0x6c(%ebp),%esi 10ba87: f3 a5 rep movsl %ds:(%esi),%es:(%edi) name = old + old_parent_pathlen; 10ba89: 01 d3 add %edx,%ebx 10ba8b: 89 5d e0 mov %ebx,-0x20(%ebp) name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 10ba8e: be ff ff ff ff mov $0xffffffff,%esi 10ba93: 89 f1 mov %esi,%ecx 10ba95: 89 df mov %ebx,%edi 10ba97: 31 c0 xor %eax,%eax 10ba99: f2 ae repnz scas %es:(%edi),%al 10ba9b: f7 d1 not %ecx 10ba9d: 49 dec %ecx 10ba9e: 83 ec 08 sub $0x8,%esp 10baa1: 51 push %ecx 10baa2: 53 push %ebx 10baa3: e8 1c ea ff ff call 10a4c4 10baa8: 01 c3 add %eax,%ebx 10baaa: 89 5d e0 mov %ebx,-0x20(%ebp) result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 10baad: 89 f1 mov %esi,%ecx 10baaf: 89 df mov %ebx,%edi 10bab1: 31 c0 xor %eax,%eax 10bab3: f2 ae repnz scas %es:(%edi),%al 10bab5: f7 d1 not %ecx 10bab7: 49 dec %ecx 10bab8: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10babf: 8d 75 cc lea -0x34(%ebp),%esi 10bac2: 56 push %esi 10bac3: 6a 00 push $0x0 10bac5: 51 push %ecx 10bac6: 53 push %ebx 10bac7: e8 08 e9 ff ff call 10a3d4 0, &old_loc, false ); if ( result != 0 ) { 10bacc: 83 c4 20 add $0x20,%esp 10bacf: 85 c0 test %eax,%eax 10bad1: 0f 85 c9 00 00 00 jne 10bba0 <_rename_r+0x15c> /* * Get the parent of the new node we are renaming to. */ rtems_filesystem_get_start_loc( new, &i, &new_parent_loc ); 10bad7: 50 push %eax 10bad8: 8d 5d a4 lea -0x5c(%ebp),%ebx 10badb: 53 push %ebx 10badc: 8d 45 e4 lea -0x1c(%ebp),%eax 10badf: 50 push %eax 10bae0: ff 75 10 pushl 0x10(%ebp) 10bae3: e8 6c 03 00 00 call 10be54 result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name ); 10bae8: 83 c4 0c add $0xc,%esp 10baeb: 8d 45 e0 lea -0x20(%ebp),%eax 10baee: 50 push %eax 10baef: 53 push %ebx 10baf0: 8b 45 10 mov 0x10(%ebp),%eax 10baf3: 03 45 e4 add -0x1c(%ebp),%eax 10baf6: 50 push %eax 10baf7: 8b 45 b0 mov -0x50(%ebp),%eax 10bafa: ff 50 04 call *0x4(%eax) if ( result != 0 ) { 10bafd: 83 c4 10 add $0x10,%esp 10bb00: 85 c0 test %eax,%eax 10bb02: 0f 85 e0 00 00 00 jne 10bbe8 <_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 ) { 10bb08: 8b 45 b4 mov -0x4c(%ebp),%eax 10bb0b: 39 45 c8 cmp %eax,-0x38(%ebp) 10bb0e: 75 48 jne 10bb58 <_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 ); 10bb10: ff 75 e0 pushl -0x20(%ebp) 10bb13: 53 push %ebx 10bb14: 56 push %esi 10bb15: ff 75 94 pushl -0x6c(%ebp) 10bb18: 8b 45 b0 mov -0x50(%ebp),%eax 10bb1b: ff 50 40 call *0x40(%eax) 10bb1e: 89 c7 mov %eax,%edi rtems_filesystem_freenode( &new_parent_loc ); 10bb20: 89 1c 24 mov %ebx,(%esp) 10bb23: e8 c8 eb ff ff call 10a6f0 if ( free_old_parentloc ) 10bb28: 83 c4 10 add $0x10,%esp 10bb2b: 80 7d 93 00 cmpb $0x0,-0x6d(%ebp) 10bb2f: 75 17 jne 10bb48 <_rename_r+0x104> rtems_filesystem_freenode( &old_parent_loc ); rtems_filesystem_freenode( &old_loc ); 10bb31: 83 ec 0c sub $0xc,%esp 10bb34: 56 push %esi 10bb35: e8 b6 eb ff ff call 10a6f0 return result; 10bb3a: 83 c4 10 add $0x10,%esp } 10bb3d: 89 f8 mov %edi,%eax 10bb3f: 8d 65 f4 lea -0xc(%ebp),%esp 10bb42: 5b pop %ebx 10bb43: 5e pop %esi 10bb44: 5f pop %edi 10bb45: c9 leave 10bb46: c3 ret 10bb47: 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 ); 10bb48: 83 ec 0c sub $0xc,%esp 10bb4b: ff 75 94 pushl -0x6c(%ebp) 10bb4e: e8 9d eb ff ff call 10a6f0 10bb53: 83 c4 10 add $0x10,%esp 10bb56: eb d9 jmp 10bb31 <_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 ); 10bb58: 83 ec 0c sub $0xc,%esp 10bb5b: 53 push %ebx 10bb5c: e8 8f eb ff ff call 10a6f0 if ( free_old_parentloc ) 10bb61: 83 c4 10 add $0x10,%esp 10bb64: 80 7d 93 00 cmpb $0x0,-0x6d(%ebp) 10bb68: 74 0e je 10bb78 <_rename_r+0x134> rtems_filesystem_freenode( &old_parent_loc ); 10bb6a: 83 ec 0c sub $0xc,%esp 10bb6d: ff 75 94 pushl -0x6c(%ebp) 10bb70: e8 7b eb ff ff call 10a6f0 10bb75: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &old_loc ); 10bb78: 83 ec 0c sub $0xc,%esp 10bb7b: 56 push %esi 10bb7c: e8 6f eb ff ff call 10a6f0 rtems_set_errno_and_return_minus_one( EXDEV ); 10bb81: e8 d2 9d 00 00 call 115958 <__errno> 10bb86: c7 00 12 00 00 00 movl $0x12,(%eax) 10bb8c: 83 c4 10 add $0x10,%esp 10bb8f: 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; } 10bb94: 89 f8 mov %edi,%eax 10bb96: 8d 65 f4 lea -0xc(%ebp),%esp 10bb99: 5b pop %ebx 10bb9a: 5e pop %esi 10bb9b: 5f pop %edi 10bb9c: c9 leave 10bb9d: c3 ret 10bb9e: 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 ) 10bba0: 80 7d 93 00 cmpb $0x0,-0x6d(%ebp) 10bba4: 75 78 jne 10bc1e <_rename_r+0x1da> <== ALWAYS TAKEN rtems_filesystem_freenode( &old_parent_loc ); return -1; 10bba6: 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; } 10bbab: 89 f8 mov %edi,%eax <== NOT EXECUTED 10bbad: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bbb0: 5b pop %ebx <== NOT EXECUTED 10bbb1: 5e pop %esi <== NOT EXECUTED 10bbb2: 5f pop %edi <== NOT EXECUTED 10bbb3: c9 leave <== NOT EXECUTED 10bbb4: c3 ret <== NOT EXECUTED 10bbb5: 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, 10bbb8: 89 c2 mov %eax,%edx 10bbba: 83 ec 0c sub $0xc,%esp 10bbbd: 6a 00 push $0x0 10bbbf: 8d 45 b8 lea -0x48(%ebp),%eax 10bbc2: 89 45 94 mov %eax,-0x6c(%ebp) 10bbc5: 50 push %eax 10bbc6: 6a 02 push $0x2 10bbc8: 52 push %edx 10bbc9: 53 push %ebx 10bbca: 89 55 8c mov %edx,-0x74(%ebp) 10bbcd: e8 6a e8 ff ff call 10a43c RTEMS_LIBIO_PERMS_WRITE, &old_parent_loc, false ); if ( result != 0 ) 10bbd2: 83 c4 20 add $0x20,%esp 10bbd5: 85 c0 test %eax,%eax 10bbd7: 8b 55 8c mov -0x74(%ebp),%edx 10bbda: 75 ca jne 10bba6 <_rename_r+0x162> <== NEVER TAKEN return -1; free_old_parentloc = true; 10bbdc: c6 45 93 01 movb $0x1,-0x6d(%ebp) 10bbe0: e9 97 fe ff ff jmp 10ba7c <_rename_r+0x38> 10bbe5: 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 ); 10bbe8: 83 ec 0c sub $0xc,%esp 10bbeb: 53 push %ebx 10bbec: e8 ff ea ff ff call 10a6f0 if ( free_old_parentloc ) 10bbf1: 83 c4 10 add $0x10,%esp 10bbf4: 80 7d 93 00 cmpb $0x0,-0x6d(%ebp) 10bbf8: 74 0e je 10bc08 <_rename_r+0x1c4> <== NEVER TAKEN rtems_filesystem_freenode( &old_parent_loc ); 10bbfa: 83 ec 0c sub $0xc,%esp 10bbfd: ff 75 94 pushl -0x6c(%ebp) 10bc00: e8 eb ea ff ff call 10a6f0 10bc05: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &old_loc ); 10bc08: 83 ec 0c sub $0xc,%esp 10bc0b: 56 push %esi 10bc0c: e8 df ea ff ff call 10a6f0 return -1; 10bc11: 83 c4 10 add $0x10,%esp 10bc14: bf ff ff ff ff mov $0xffffffff,%edi 10bc19: e9 1f ff ff ff jmp 10bb3d <_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 ); 10bc1e: 83 ec 0c sub $0xc,%esp 10bc21: ff 75 94 pushl -0x6c(%ebp) 10bc24: e8 c7 ea ff ff call 10a6f0 10bc29: 83 c4 10 add $0x10,%esp return -1; 10bc2c: bf ff ff ff ff mov $0xffffffff,%edi 10bc31: e9 07 ff ff ff jmp 10bb3d <_rename_r+0xf9> =============================================================================== 0010a314 <_times>: #endif clock_t _times( struct tms *ptms ) { 10a314: 55 push %ebp 10a315: 89 e5 mov %esp,%ebp 10a317: 56 push %esi 10a318: 53 push %ebx 10a319: 83 ec 10 sub $0x10,%esp 10a31c: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_interval ticks; if ( !ptms ) 10a31f: 85 db test %ebx,%ebx 10a321: 74 75 je 10a398 <_times+0x84> /* * This call does not depend on TOD being initialized and can't fail. */ ticks = rtems_clock_get_ticks_since_boot(); 10a323: e8 84 04 00 00 call 10a7ac 10a328: 89 c6 mov %eax,%esi { Timestamp_Control per_tick; uint32_t ticks; uint32_t fractional_ticks; _Timestamp_Set( 10a32a: 8b 0d ac 25 12 00 mov 0x1225ac,%ecx 10a330: ba 83 de 1b 43 mov $0x431bde83,%edx 10a335: 89 c8 mov %ecx,%eax 10a337: f7 e2 mul %edx 10a339: c1 ea 12 shr $0x12,%edx 10a33c: 89 55 e8 mov %edx,-0x18(%ebp) 10a33f: 8d 04 89 lea (%ecx,%ecx,4),%eax 10a342: 8d 04 80 lea (%eax,%eax,4),%eax 10a345: 8d 04 80 lea (%eax,%eax,4),%eax 10a348: c1 e0 03 shl $0x3,%eax 10a34b: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx 10a350: 31 d2 xor %edx,%edx 10a352: f7 f1 div %ecx 10a354: 89 55 ec mov %edx,-0x14(%ebp) TOD_MICROSECONDS_PER_SECOND, (rtems_configuration_get_nanoseconds_per_tick() % TOD_NANOSECONDS_PER_SECOND) ); _Timestamp_Divide( 10a357: 8d 45 f0 lea -0x10(%ebp),%eax 10a35a: 50 push %eax 10a35b: 8d 45 f4 lea -0xc(%ebp),%eax 10a35e: 50 push %eax 10a35f: 8d 45 e8 lea -0x18(%ebp),%eax 10a362: 50 push %eax 10a363: a1 18 6a 12 00 mov 0x126a18,%eax 10a368: 05 84 00 00 00 add $0x84,%eax 10a36d: 50 push %eax 10a36e: e8 51 35 00 00 call 10d8c4 <_Timespec_Divide> &_Thread_Executing->cpu_time_used, &per_tick, &ticks, &fractional_ticks ); ptms->tms_utime = ticks; 10a373: 8b 45 f4 mov -0xc(%ebp),%eax 10a376: 89 03 mov %eax,(%ebx) } #else ptms->tms_utime = _Thread_Executing->cpu_time_used; #endif ptms->tms_stime = ticks; 10a378: 89 73 04 mov %esi,0x4(%ebx) ptms->tms_cutime = 0; 10a37b: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) ptms->tms_cstime = 0; 10a382: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) return ticks; 10a389: 83 c4 10 add $0x10,%esp 10a38c: 89 f0 mov %esi,%eax } 10a38e: 8d 65 f8 lea -0x8(%ebp),%esp 10a391: 5b pop %ebx 10a392: 5e pop %esi 10a393: c9 leave 10a394: c3 ret 10a395: 8d 76 00 lea 0x0(%esi),%esi ) { rtems_interval ticks; if ( !ptms ) rtems_set_errno_and_return_minus_one( EFAULT ); 10a398: e8 9f 7c 00 00 call 11203c <__errno> 10a39d: c7 00 0e 00 00 00 movl $0xe,(%eax) 10a3a3: b8 ff ff ff ff mov $0xffffffff,%eax ptms->tms_stime = ticks; ptms->tms_cutime = 0; ptms->tms_cstime = 0; return ticks; } 10a3a8: 8d 65 f8 lea -0x8(%ebp),%esp 10a3ab: 5b pop %ebx 10a3ac: 5e pop %esi 10a3ad: c9 leave 10a3ae: c3 ret =============================================================================== 001090ac : int access( const char *path, int amode ) { 1090ac: 55 push %ebp 1090ad: 89 e5 mov %esp,%ebp 1090af: 53 push %ebx 1090b0: 83 ec 5c sub $0x5c,%esp 1090b3: 8b 5d 0c mov 0xc(%ebp),%ebx struct stat statbuf; if ( stat(path, &statbuf) ) 1090b6: 8d 45 b0 lea -0x50(%ebp),%eax 1090b9: 50 push %eax 1090ba: ff 75 08 pushl 0x8(%ebp) 1090bd: e8 6a 17 00 00 call 10a82c 1090c2: 83 c4 10 add $0x10,%esp 1090c5: 85 c0 test %eax,%eax 1090c7: 75 1f jne 1090e8 return -1; if ( amode & R_OK ) { 1090c9: f6 c3 04 test $0x4,%bl 1090cc: 75 26 jne 1090f4 if (!( statbuf.st_mode & S_IREAD )) return -1; } if ( amode & W_OK ) { 1090ce: f6 c3 02 test $0x2,%bl 1090d1: 75 0d jne 1090e0 if ( !( statbuf.st_mode & S_IWRITE ) ) return -1; } if ( amode & X_OK ) { 1090d3: 83 e3 01 and $0x1,%ebx 1090d6: 75 24 jne 1090fc if ( !( statbuf.st_mode & S_IEXEC ) ) return -1; } return 0; 1090d8: 31 c0 xor %eax,%eax } 1090da: 8b 5d fc mov -0x4(%ebp),%ebx 1090dd: c9 leave 1090de: c3 ret 1090df: 90 nop if (!( statbuf.st_mode & S_IREAD )) return -1; } if ( amode & W_OK ) { if ( !( statbuf.st_mode & S_IWRITE ) ) 1090e0: f6 45 bc 80 testb $0x80,-0x44(%ebp) 1090e4: 75 ed jne 1090d3 1090e6: 66 90 xchg %ax,%ax return -1; 1090e8: b8 ff ff ff ff mov $0xffffffff,%eax if ( !( statbuf.st_mode & S_IEXEC ) ) return -1; } return 0; } 1090ed: 8b 5d fc mov -0x4(%ebp),%ebx 1090f0: c9 leave 1090f1: c3 ret 1090f2: 66 90 xchg %ax,%ax if ( stat(path, &statbuf) ) return -1; if ( amode & R_OK ) { if (!( statbuf.st_mode & S_IREAD )) 1090f4: f6 45 bd 01 testb $0x1,-0x43(%ebp) 1090f8: 75 d4 jne 1090ce 1090fa: eb ec jmp 1090e8 if ( !( statbuf.st_mode & S_IWRITE ) ) return -1; } if ( amode & X_OK ) { if ( !( statbuf.st_mode & S_IEXEC ) ) 1090fc: 8b 45 bc mov -0x44(%ebp),%eax 1090ff: 83 e0 40 and $0x40,%eax return -1; } return 0; 109102: 83 f8 01 cmp $0x1,%eax 109105: 19 c0 sbb %eax,%eax 109107: eb d1 jmp 1090da =============================================================================== 00108870 : int cfsetospeed( struct termios *tp, speed_t speed ) { 108870: 55 push %ebp 108871: 89 e5 mov %esp,%ebp 108873: 83 ec 08 sub $0x8,%esp 108876: 8b 4d 08 mov 0x8(%ebp),%ecx 108879: 8b 55 0c mov 0xc(%ebp),%edx if ( speed & ~CBAUD ) 10887c: f7 c2 f0 ef ff ff test $0xffffeff0,%edx 108882: 75 14 jne 108898 rtems_set_errno_and_return_minus_one( EINVAL ); tp->c_cflag = (tp->c_cflag & ~CBAUD) | speed; 108884: 8b 41 08 mov 0x8(%ecx),%eax 108887: 25 f0 ef ff ff and $0xffffeff0,%eax 10888c: 09 d0 or %edx,%eax 10888e: 89 41 08 mov %eax,0x8(%ecx) return 0; 108891: 31 c0 xor %eax,%eax } 108893: c9 leave 108894: c3 ret 108895: 8d 76 00 lea 0x0(%esi),%esi struct termios *tp, speed_t speed ) { if ( speed & ~CBAUD ) rtems_set_errno_and_return_minus_one( EINVAL ); 108898: e8 f3 af 00 00 call 113890 <__errno> 10889d: c7 00 16 00 00 00 movl $0x16,(%eax) 1088a3: b8 ff ff ff ff mov $0xffffffff,%eax tp->c_cflag = (tp->c_cflag & ~CBAUD) | speed; return 0; } 1088a8: c9 leave 1088a9: c3 ret =============================================================================== 0010fa90 : #include int chdir( const char *pathname ) { 10fa90: 55 push %ebp 10fa91: 89 e5 mov %esp,%ebp 10fa93: 57 push %edi 10fa94: 56 push %esi 10fa95: 83 ec 20 sub $0x20,%esp 10fa98: 8b 55 08 mov 0x8(%ebp),%edx rtems_filesystem_location_info_t loc; int result; if ( !pathname ) 10fa9b: 85 d2 test %edx,%edx 10fa9d: 74 75 je 10fb14 rtems_set_errno_and_return_minus_one( EFAULT ); /* * Get the node where we wish to go. */ result = rtems_filesystem_evaluate_path( 10fa9f: 31 c0 xor %eax,%eax 10faa1: b9 ff ff ff ff mov $0xffffffff,%ecx 10faa6: 89 d7 mov %edx,%edi 10faa8: f2 ae repnz scas %es:(%edi),%al 10faaa: f7 d1 not %ecx 10faac: 49 dec %ecx 10faad: 83 ec 0c sub $0xc,%esp 10fab0: 6a 01 push $0x1 10fab2: 8d 75 e4 lea -0x1c(%ebp),%esi 10fab5: 56 push %esi 10fab6: 6a 01 push $0x1 10fab8: 51 push %ecx 10fab9: 52 push %edx 10faba: e8 c9 7e ff ff call 107988 pathname, strlen( pathname ), RTEMS_LIBIO_PERMS_SEARCH, &loc, true ); if ( result != 0 ) 10fabf: 83 c4 20 add $0x20,%esp 10fac2: 85 c0 test %eax,%eax 10fac4: 74 0e je 10fad4 return -1; 10fac6: b8 ff ff ff ff mov $0xffffffff,%eax rtems_filesystem_freenode( &rtems_filesystem_current ); rtems_filesystem_current = loc; return 0; } 10facb: 8d 65 f8 lea -0x8(%ebp),%esp 10face: 5e pop %esi 10facf: 5f pop %edi 10fad0: c9 leave 10fad1: c3 ret 10fad2: 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 ) { 10fad4: 83 ec 0c sub $0xc,%esp 10fad7: 56 push %esi 10fad8: 8b 45 f0 mov -0x10(%ebp),%eax 10fadb: ff 50 10 call *0x10(%eax) 10fade: 83 c4 10 add $0x10,%esp 10fae1: 48 dec %eax 10fae2: 75 48 jne 10fb2c rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTDIR ); } rtems_filesystem_freenode( &rtems_filesystem_current ); 10fae4: 83 ec 0c sub $0xc,%esp 10fae7: a1 10 41 12 00 mov 0x124110,%eax 10faec: 83 c0 04 add $0x4,%eax 10faef: 50 push %eax 10faf0: e8 6b 7f ff ff call 107a60 rtems_filesystem_current = loc; 10faf5: 8b 3d 10 41 12 00 mov 0x124110,%edi 10fafb: 83 c7 04 add $0x4,%edi 10fafe: b9 05 00 00 00 mov $0x5,%ecx 10fb03: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return 0; 10fb05: 83 c4 10 add $0x10,%esp 10fb08: 31 c0 xor %eax,%eax } 10fb0a: 8d 65 f8 lea -0x8(%ebp),%esp 10fb0d: 5e pop %esi 10fb0e: 5f pop %edi 10fb0f: c9 leave 10fb10: c3 ret 10fb11: 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 ); 10fb14: e8 ef 2a 00 00 call 112608 <__errno> 10fb19: c7 00 0e 00 00 00 movl $0xe,(%eax) 10fb1f: b8 ff ff ff ff mov $0xffffffff,%eax rtems_filesystem_freenode( &rtems_filesystem_current ); rtems_filesystem_current = loc; return 0; } 10fb24: 8d 65 f8 lea -0x8(%ebp),%esp 10fb27: 5e pop %esi 10fb28: 5f pop %edi 10fb29: c9 leave 10fb2a: c3 ret 10fb2b: 90 nop /* * Verify you can change directory into this node. */ if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { rtems_filesystem_freenode( &loc ); 10fb2c: 83 ec 0c sub $0xc,%esp 10fb2f: 56 push %esi 10fb30: e8 2b 7f ff ff call 107a60 rtems_set_errno_and_return_minus_one( ENOTDIR ); 10fb35: e8 ce 2a 00 00 call 112608 <__errno> 10fb3a: c7 00 14 00 00 00 movl $0x14,(%eax) 10fb40: 83 c4 10 add $0x10,%esp 10fb43: b8 ff ff ff ff mov $0xffffffff,%eax 10fb48: eb 81 jmp 10facb =============================================================================== 001077f0 : #include int chroot( const char *pathname ) { 1077f0: 55 push %ebp 1077f1: 89 e5 mov %esp,%ebp 1077f3: 57 push %edi 1077f4: 56 push %esi 1077f5: 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) { 1077f8: 81 3d 10 41 12 00 40 cmpl $0x126340,0x124110 1077ff: 63 12 00 107802: 74 60 je 107864 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); 107804: 83 ec 0c sub $0xc,%esp 107807: ff 75 08 pushl 0x8(%ebp) 10780a: e8 81 82 00 00 call 10fa90 if (result) { 10780f: 83 c4 10 add $0x10,%esp 107812: 85 c0 test %eax,%eax 107814: 75 72 jne 107888 rtems_set_errno_and_return_minus_one( errno ); } /* clone the new root location */ if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) { 107816: 83 ec 0c sub $0xc,%esp 107819: 6a 00 push $0x0 10781b: 8d 75 e4 lea -0x1c(%ebp),%esi 10781e: 56 push %esi 10781f: 6a 00 push $0x0 107821: 6a 01 push $0x1 107823: 68 b6 0b 12 00 push $0x120bb6 107828: e8 5b 01 00 00 call 107988 10782d: 83 c4 20 add $0x20,%esp 107830: 85 c0 test %eax,%eax 107832: 75 54 jne 107888 <== 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); 107834: 83 ec 0c sub $0xc,%esp 107837: a1 10 41 12 00 mov 0x124110,%eax 10783c: 83 c0 18 add $0x18,%eax 10783f: 50 push %eax 107840: e8 1b 02 00 00 call 107a60 rtems_filesystem_root = loc; 107845: 8b 3d 10 41 12 00 mov 0x124110,%edi 10784b: 83 c7 18 add $0x18,%edi 10784e: b9 05 00 00 00 mov $0x5,%ecx 107853: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return 0; 107855: 83 c4 10 add $0x10,%esp 107858: 31 c0 xor %eax,%eax } 10785a: 8d 65 f8 lea -0x8(%ebp),%esp 10785d: 5e pop %esi 10785e: 5f pop %edi 10785f: c9 leave 107860: c3 ret 107861: 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*/ 107864: e8 cf 12 00 00 call 108b38 if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 107869: 81 3d 10 41 12 00 40 cmpl $0x126340,0x124110 107870: 63 12 00 107873: 75 8f jne 107804 rtems_set_errno_and_return_minus_one( ENOTSUP ); 107875: e8 8e ad 00 00 call 112608 <__errno> 10787a: c7 00 86 00 00 00 movl $0x86,(%eax) 107880: 83 c8 ff or $0xffffffff,%eax 107883: eb d5 jmp 10785a 107885: 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 ); 107888: e8 7b ad 00 00 call 112608 <__errno> 10788d: 89 c6 mov %eax,%esi 10788f: e8 74 ad 00 00 call 112608 <__errno> 107894: 8b 00 mov (%eax),%eax 107896: 89 06 mov %eax,(%esi) 107898: b8 ff ff ff ff mov $0xffffffff,%eax 10789d: eb bb jmp 10785a =============================================================================== 0010f074 : #include int close( int fd ) { 10f074: 55 push %ebp 10f075: 89 e5 mov %esp,%ebp 10f077: 53 push %ebx 10f078: 83 ec 14 sub $0x14,%esp 10f07b: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_t *iop; rtems_status_code rc; rtems_libio_check_fd(fd); 10f07e: 3b 05 ec 21 12 00 cmp 0x1221ec,%eax 10f084: 73 46 jae 10f0cc iop = rtems_libio_iop(fd); 10f086: c1 e0 03 shl $0x3,%eax 10f089: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx 10f090: 29 c3 sub %eax,%ebx 10f092: 03 1d 80 63 12 00 add 0x126380,%ebx rtems_libio_check_is_open(iop); 10f098: f6 43 15 01 testb $0x1,0x15(%ebx) 10f09c: 74 2e je 10f0cc rc = RTEMS_SUCCESSFUL; rc = (*iop->pathinfo.handlers->close_h)( iop ); 10f09e: 83 ec 0c sub $0xc,%esp 10f0a1: 8b 43 20 mov 0x20(%ebx),%eax 10f0a4: 53 push %ebx 10f0a5: ff 50 04 call *0x4(%eax) rtems_filesystem_freenode( &iop->pathinfo ); 10f0a8: 8d 53 18 lea 0x18(%ebx),%edx 10f0ab: 89 14 24 mov %edx,(%esp) 10f0ae: 89 45 f4 mov %eax,-0xc(%ebp) 10f0b1: e8 6a 85 ff ff call 107620 rtems_libio_free( iop ); 10f0b6: 89 1c 24 mov %ebx,(%esp) 10f0b9: e8 5a 02 00 00 call 10f318 return rc; 10f0be: 83 c4 10 add $0x10,%esp 10f0c1: 8b 45 f4 mov -0xc(%ebp),%eax } 10f0c4: 8b 5d fc mov -0x4(%ebp),%ebx 10f0c7: c9 leave 10f0c8: c3 ret 10f0c9: 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); 10f0cc: e8 0b 2d 00 00 call 111ddc <__errno> 10f0d1: c7 00 09 00 00 00 movl $0x9,(%eax) 10f0d7: b8 ff ff ff ff mov $0xffffffff,%eax 10f0dc: eb e6 jmp 10f0c4 =============================================================================== 0010778c : static char *ctermid_name = "/dev/console"; char *ctermid( char *s ) { 10778c: 55 push %ebp 10778d: 89 e5 mov %esp,%ebp 10778f: 57 push %edi 107790: 56 push %esi 107791: 8b 45 08 mov 0x8(%ebp),%eax if ( !s ) 107794: 85 c0 test %eax,%eax 107796: 74 14 je 1077ac /* * 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 ); 107798: be 43 ca 11 00 mov $0x11ca43,%esi 10779d: b9 0d 00 00 00 mov $0xd,%ecx 1077a2: 89 c7 mov %eax,%edi 1077a4: f3 a4 rep movsb %ds:(%esi),%es:(%edi) return s; } 1077a6: 5e pop %esi 1077a7: 5f pop %edi 1077a8: c9 leave 1077a9: c3 ret 1077aa: 66 90 xchg %ax,%ax char *ctermid( char *s ) { if ( !s ) return ctermid_name; 1077ac: b8 43 ca 11 00 mov $0x11ca43,%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; } 1077b1: 5e pop %esi 1077b2: 5f pop %edi 1077b3: c9 leave 1077b4: c3 ret =============================================================================== 00106fec : #include #include "devfs.h" int devFS_Show(void) { 106fec: 55 push %ebp 106fed: 89 e5 mov %esp,%ebp 106fef: 56 push %esi 106ff0: 53 push %ebx int i; rtems_filesystem_location_info_t *temp_loc; rtems_device_name_t *device_name_table; temp_loc = &rtems_filesystem_root; 106ff1: a1 d0 11 12 00 mov 0x1211d0,%eax device_name_table = (rtems_device_name_t *)temp_loc->node_access; 106ff6: 8b 70 18 mov 0x18(%eax),%esi if (!device_name_table) 106ff9: 85 f6 test %esi,%esi 106ffb: 74 43 je 107040 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EFAULT ); for (i = 0; i < rtems_device_table_size; i++){ 106ffd: a1 50 f1 11 00 mov 0x11f150,%eax 107002: 85 c0 test %eax,%eax 107004: 74 31 je 107037 107006: 31 c0 xor %eax,%eax 107008: 31 db xor %ebx,%ebx 10700a: 66 90 xchg %ax,%ax if (device_name_table[i].device_name){ 10700c: 8d 04 80 lea (%eax,%eax,4),%eax 10700f: 8d 04 86 lea (%esi,%eax,4),%eax 107012: 8b 10 mov (%eax),%edx 107014: 85 d2 test %edx,%edx 107016: 74 14 je 10702c printk("/%s %d %d\n", device_name_table[i].device_name, 107018: ff 70 0c pushl 0xc(%eax) 10701b: ff 70 08 pushl 0x8(%eax) 10701e: 52 push %edx 10701f: 68 13 db 11 00 push $0x11db13 107024: e8 6b 12 00 00 call 108294 107029: 83 c4 10 add $0x10,%esp temp_loc = &rtems_filesystem_root; device_name_table = (rtems_device_name_t *)temp_loc->node_access; if (!device_name_table) rtems_set_errno_and_return_minus_one( EFAULT ); for (i = 0; i < rtems_device_table_size; i++){ 10702c: 43 inc %ebx 10702d: 89 d8 mov %ebx,%eax 10702f: 3b 1d 50 f1 11 00 cmp 0x11f150,%ebx 107035: 72 d5 jb 10700c if (device_name_table[i].device_name){ printk("/%s %d %d\n", device_name_table[i].device_name, device_name_table[i].major, device_name_table[i].minor); } } return 0; 107037: 31 c0 xor %eax,%eax } 107039: 8d 65 f8 lea -0x8(%ebp),%esp 10703c: 5b pop %ebx 10703d: 5e pop %esi 10703e: c9 leave 10703f: c3 ret rtems_device_name_t *device_name_table; temp_loc = &rtems_filesystem_root; device_name_table = (rtems_device_name_t *)temp_loc->node_access; if (!device_name_table) rtems_set_errno_and_return_minus_one( EFAULT ); 107040: e8 97 8f 00 00 call 10ffdc <__errno> 107045: c7 00 0e 00 00 00 movl $0xe,(%eax) 10704b: 83 c8 ff or $0xffffffff,%eax 10704e: eb e9 jmp 107039 =============================================================================== 0010ef84 : const char *pathname, size_t pathnamelen, int flags, rtems_filesystem_location_info_t *pathloc ) { 10ef84: 55 push %ebp 10ef85: 89 e5 mov %esp,%ebp 10ef87: 57 push %edi 10ef88: 56 push %esi 10ef89: 53 push %ebx 10ef8a: 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 ) ) 10ef8d: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp) 10ef94: 0f 85 96 00 00 00 jne 10f030 <== 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; 10ef9a: 8b 45 14 mov 0x14(%ebp),%eax 10ef9d: 8b 00 mov (%eax),%eax 10ef9f: 89 45 e4 mov %eax,-0x1c(%ebp) if (!device_name_table) 10efa2: 85 c0 test %eax,%eax 10efa4: 0f 84 98 00 00 00 je 10f042 rtems_set_errno_and_return_minus_one( EFAULT ); for (i = 0; i < rtems_device_table_size; i++) { 10efaa: 8b 15 50 01 12 00 mov 0x120150,%edx 10efb0: 89 55 e0 mov %edx,-0x20(%ebp) 10efb3: 85 d2 test %edx,%edx 10efb5: 74 38 je 10efef <== NEVER TAKEN 10efb7: 31 c0 xor %eax,%eax 10efb9: 31 db xor %ebx,%ebx if (!device_name_table[i].device_name) 10efbb: 8d 04 80 lea (%eax,%eax,4),%eax 10efbe: 8b 55 e4 mov -0x1c(%ebp),%edx 10efc1: 8d 3c 82 lea (%edx,%eax,4),%edi 10efc4: 8b 37 mov (%edi),%esi 10efc6: 85 f6 test %esi,%esi 10efc8: 74 1d je 10efe7 continue; if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0) 10efca: 50 push %eax 10efcb: ff 75 0c pushl 0xc(%ebp) 10efce: 56 push %esi 10efcf: ff 75 08 pushl 0x8(%ebp) 10efd2: e8 9d 29 00 00 call 111974 10efd7: 83 c4 10 add $0x10,%esp 10efda: 85 c0 test %eax,%eax 10efdc: 75 09 jne 10efe7 continue; if (device_name_table[i].device_name[pathnamelen] != '\0') 10efde: 8b 45 0c mov 0xc(%ebp),%eax 10efe1: 80 3c 06 00 cmpb $0x0,(%esi,%eax,1) 10efe5: 74 21 je 10f008 <== 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++) { 10efe7: 43 inc %ebx 10efe8: 89 d8 mov %ebx,%eax 10efea: 39 5d e0 cmp %ebx,-0x20(%ebp) 10efed: 77 cc ja 10efbb pathloc->mt_entry = rtems_filesystem_root.mt_entry; return 0; } /* no such file or directory */ rtems_set_errno_and_return_minus_one( ENOENT ); 10efef: e8 c8 1c 00 00 call 110cbc <__errno> 10eff4: c7 00 02 00 00 00 movl $0x2,(%eax) 10effa: b8 ff ff ff ff mov $0xffffffff,%eax } 10efff: 8d 65 f4 lea -0xc(%ebp),%esp 10f002: 5b pop %ebx 10f003: 5e pop %esi 10f004: 5f pop %edi 10f005: c9 leave 10f006: c3 ret 10f007: 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]; 10f008: 8b 55 14 mov 0x14(%ebp),%edx 10f00b: 89 3a mov %edi,(%edx) pathloc->handlers = &devFS_file_handlers; 10f00d: c7 42 08 60 20 12 00 movl $0x122060,0x8(%edx) pathloc->ops = &devFS_ops; 10f014: c7 42 0c 00 20 12 00 movl $0x122000,0xc(%edx) pathloc->mt_entry = rtems_filesystem_root.mt_entry; 10f01b: a1 d0 21 12 00 mov 0x1221d0,%eax 10f020: 8b 40 28 mov 0x28(%eax),%eax 10f023: 89 42 10 mov %eax,0x10(%edx) return 0; 10f026: 31 c0 xor %eax,%eax } /* no such file or directory */ rtems_set_errno_and_return_minus_one( ENOENT ); } 10f028: 8d 65 f4 lea -0xc(%ebp),%esp 10f02b: 5b pop %ebx 10f02c: 5e pop %esi 10f02d: 5f pop %edi 10f02e: c9 leave 10f02f: 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 ); 10f030: e8 87 1c 00 00 call 110cbc <__errno> <== NOT EXECUTED 10f035: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10f03b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10f040: eb e6 jmp 10f028 <== 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 ); 10f042: e8 75 1c 00 00 call 110cbc <__errno> 10f047: c7 00 0e 00 00 00 movl $0xe,(%eax) 10f04d: 83 c8 ff or $0xffffffff,%eax 10f050: eb d6 jmp 10f028 =============================================================================== 00107d3c : int devFS_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 107d3c: 55 push %ebp 107d3d: 89 e5 mov %esp,%ebp 107d3f: 83 ec 1c sub $0x1c,%esp 107d42: 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; 107d45: 8b 42 18 mov 0x18(%edx),%eax args.iop = iop; 107d48: 89 55 e8 mov %edx,-0x18(%ebp) args.command = command; 107d4b: 8b 55 0c mov 0xc(%ebp),%edx 107d4e: 89 55 ec mov %edx,-0x14(%ebp) args.buffer = buffer; 107d51: 8b 55 10 mov 0x10(%ebp),%edx 107d54: 89 55 f0 mov %edx,-0x10(%ebp) status = rtems_io_control( np->major, np->minor, (void *) &args 107d57: 8d 55 e8 lea -0x18(%ebp),%edx args.iop = iop; args.command = command; args.buffer = buffer; status = rtems_io_control( 107d5a: 52 push %edx 107d5b: ff 70 0c pushl 0xc(%eax) 107d5e: ff 70 08 pushl 0x8(%eax) 107d61: e8 8a 3f 00 00 call 10bcf0 np->major, np->minor, (void *) &args ); if ( status ) 107d66: 83 c4 10 add $0x10,%esp 107d69: 85 c0 test %eax,%eax 107d6b: 75 07 jne 107d74 return rtems_deviceio_errno(status); return args.ioctl_return; 107d6d: 8b 45 f4 mov -0xc(%ebp),%eax } 107d70: c9 leave 107d71: c3 ret 107d72: 66 90 xchg %ax,%ax np->minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 107d74: 83 ec 0c sub $0xc,%esp 107d77: 50 push %eax 107d78: e8 e7 72 00 00 call 10f064 107d7d: 83 c4 10 add $0x10,%esp return args.ioctl_return; } 107d80: c9 leave 107d81: c3 ret =============================================================================== 00107be4 : const char *path, mode_t mode, dev_t dev, rtems_filesystem_location_info_t *pathloc ) { 107be4: 55 push %ebp 107be5: 89 e5 mov %esp,%ebp 107be7: 57 push %edi 107be8: 56 push %esi 107be9: 53 push %ebx 107bea: 83 ec 1c sub $0x1c,%esp 107bed: 8b 7d 08 mov 0x8(%ebp),%edi 107bf0: 8b 4d 10 mov 0x10(%ebp),%ecx 107bf3: 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') && 107bf6: 80 3f 64 cmpb $0x64,(%edi) 107bf9: 0f 84 dd 00 00 00 je 107cdc (path[2] == 'v') && (path[3] == '\0')) return 0; /* must be a character device or a block device */ if (!S_ISBLK(mode) && !S_ISCHR(mode)) 107bff: 8b 45 0c mov 0xc(%ebp),%eax 107c02: 25 00 f0 00 00 and $0xf000,%eax 107c07: 3d 00 60 00 00 cmp $0x6000,%eax 107c0c: 74 0b je 107c19 107c0e: 3d 00 20 00 00 cmp $0x2000,%eax 107c13: 0f 85 e5 00 00 00 jne 107cfe ) { union __rtems_dev_t temp; temp.device = device; return temp.__overlay.major; 107c19: 89 4d dc mov %ecx,-0x24(%ebp) dev_t device ) { union __rtems_dev_t temp; temp.device = device; 107c1c: 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; 107c1f: 8b 45 18 mov 0x18(%ebp),%eax 107c22: 8b 30 mov (%eax),%esi if (!device_name_table) 107c24: 85 f6 test %esi,%esi 107c26: 0f 84 f4 00 00 00 je 107d20 rtems_set_errno_and_return_minus_one( EFAULT ); for (slot = -1, i = 0; i < rtems_device_table_size; i++){ 107c2c: 8b 15 50 01 12 00 mov 0x120150,%edx 107c32: 85 d2 test %edx,%edx 107c34: 0f 84 d6 00 00 00 je 107d10 107c3a: 31 c0 xor %eax,%eax 107c3c: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp) 107c43: 31 db xor %ebx,%ebx 107c45: 89 7d e4 mov %edi,-0x1c(%ebp) 107c48: 89 d7 mov %edx,%edi 107c4a: eb 1a jmp 107c66 if (device_name_table[i].device_name == NULL) slot = i; else if (strcmp(path, device_name_table[i].device_name) == 0) 107c4c: 83 ec 08 sub $0x8,%esp 107c4f: 50 push %eax 107c50: ff 75 e4 pushl -0x1c(%ebp) 107c53: e8 c4 9c 00 00 call 11191c 107c58: 83 c4 10 add $0x10,%esp 107c5b: 85 c0 test %eax,%eax 107c5d: 74 65 je 107cc4 /* 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++){ 107c5f: 43 inc %ebx 107c60: 89 d8 mov %ebx,%eax 107c62: 39 fb cmp %edi,%ebx 107c64: 73 16 jae 107c7c if (device_name_table[i].device_name == NULL) 107c66: 8d 04 80 lea (%eax,%eax,4),%eax 107c69: 8b 04 86 mov (%esi,%eax,4),%eax 107c6c: 85 c0 test %eax,%eax 107c6e: 75 dc jne 107c4c 107c70: 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++){ 107c73: 43 inc %ebx 107c74: 89 d8 mov %ebx,%eax 107c76: 39 fb cmp %edi,%ebx 107c78: 72 ec jb 107c66 107c7a: 66 90 xchg %ax,%ax 107c7c: 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) 107c7f: 83 7d e0 ff cmpl $0xffffffff,-0x20(%ebp) 107c83: 0f 84 87 00 00 00 je 107d10 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( ENOMEM ); _ISR_Disable(level); 107c89: 9c pushf 107c8a: fa cli 107c8b: 5b pop %ebx device_name_table[slot].device_name = (char *)path; 107c8c: 8b 55 e0 mov -0x20(%ebp),%edx 107c8f: 8d 04 92 lea (%edx,%edx,4),%eax 107c92: 8d 14 86 lea (%esi,%eax,4),%edx 107c95: 89 3a mov %edi,(%edx) device_name_table[slot].device_name_length = strlen(path); 107c97: 31 c0 xor %eax,%eax 107c99: b9 ff ff ff ff mov $0xffffffff,%ecx 107c9e: f2 ae repnz scas %es:(%edi),%al 107ca0: f7 d1 not %ecx 107ca2: 49 dec %ecx 107ca3: 89 4a 04 mov %ecx,0x4(%edx) device_name_table[slot].major = major; 107ca6: 8b 45 dc mov -0x24(%ebp),%eax 107ca9: 89 42 08 mov %eax,0x8(%edx) device_name_table[slot].minor = minor; 107cac: 8b 45 d8 mov -0x28(%ebp),%eax 107caf: 89 42 0c mov %eax,0xc(%edx) device_name_table[slot].mode = mode; 107cb2: 8b 45 0c mov 0xc(%ebp),%eax 107cb5: 89 42 10 mov %eax,0x10(%edx) _ISR_Enable(level); 107cb8: 53 push %ebx 107cb9: 9d popf return 0; 107cba: 31 c0 xor %eax,%eax } 107cbc: 8d 65 f4 lea -0xc(%ebp),%esp 107cbf: 5b pop %ebx 107cc0: 5e pop %esi 107cc1: 5f pop %edi 107cc2: c9 leave 107cc3: 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 ); 107cc4: e8 f3 8f 00 00 call 110cbc <__errno> 107cc9: c7 00 11 00 00 00 movl $0x11,(%eax) 107ccf: 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; } 107cd4: 8d 65 f4 lea -0xc(%ebp),%esp 107cd7: 5b pop %ebx 107cd8: 5e pop %esi 107cd9: 5f pop %edi 107cda: c9 leave 107cdb: 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') && 107cdc: 80 7f 01 65 cmpb $0x65,0x1(%edi) 107ce0: 0f 85 19 ff ff ff jne 107bff <== NEVER TAKEN 107ce6: 80 7f 02 76 cmpb $0x76,0x2(%edi) 107cea: 0f 85 0f ff ff ff jne 107bff <== NEVER TAKEN (path[2] == 'v') && (path[3] == '\0')) 107cf0: 80 7f 03 00 cmpb $0x0,0x3(%edi) 107cf4: 0f 85 05 ff ff ff jne 107bff return 0; 107cfa: 31 c0 xor %eax,%eax 107cfc: eb be jmp 107cbc /* must be a character device or a block device */ if (!S_ISBLK(mode) && !S_ISCHR(mode)) rtems_set_errno_and_return_minus_one( EINVAL ); 107cfe: e8 b9 8f 00 00 call 110cbc <__errno> 107d03: c7 00 16 00 00 00 movl $0x16,(%eax) 107d09: b8 ff ff ff ff mov $0xffffffff,%eax 107d0e: eb ac jmp 107cbc 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 ); 107d10: e8 a7 8f 00 00 call 110cbc <__errno> 107d15: c7 00 0c 00 00 00 movl $0xc,(%eax) 107d1b: 83 c8 ff or $0xffffffff,%eax 107d1e: eb 9c jmp 107cbc 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 ); 107d20: e8 97 8f 00 00 call 110cbc <__errno> 107d25: c7 00 0e 00 00 00 movl $0xe,(%eax) 107d2b: 83 c8 ff or $0xffffffff,%eax 107d2e: eb 8c jmp 107cbc =============================================================================== 00111558 : int device_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 111558: 55 push %ebp 111559: 89 e5 mov %esp,%ebp 11155b: 83 ec 1c sub $0x1c,%esp 11155e: 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; 111561: 89 45 e8 mov %eax,-0x18(%ebp) args.command = command; 111564: 8b 55 0c mov 0xc(%ebp),%edx 111567: 89 55 ec mov %edx,-0x14(%ebp) args.buffer = buffer; 11156a: 8b 55 10 mov 0x10(%ebp),%edx 11156d: 89 55 f0 mov %edx,-0x10(%ebp) the_jnode = iop->pathinfo.node_access; 111570: 8b 40 18 mov 0x18(%eax),%eax status = rtems_io_control( the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args 111573: 8d 55 e8 lea -0x18(%ebp),%edx args.command = command; args.buffer = buffer; the_jnode = iop->pathinfo.node_access; status = rtems_io_control( 111576: 52 push %edx 111577: ff 70 54 pushl 0x54(%eax) 11157a: ff 70 50 pushl 0x50(%eax) 11157d: e8 9e 05 00 00 call 111b20 the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 111582: 83 c4 10 add $0x10,%esp 111585: 85 c0 test %eax,%eax 111587: 75 07 jne 111590 return rtems_deviceio_errno(status); return args.ioctl_return; 111589: 8b 45 f4 mov -0xc(%ebp),%eax } 11158c: c9 leave 11158d: c3 ret 11158e: 66 90 xchg %ax,%ax the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 111590: 83 ec 0c sub $0xc,%esp 111593: 50 push %eax 111594: e8 f3 07 00 00 call 111d8c 111599: 83 c4 10 add $0x10,%esp return args.ioctl_return; } 11159c: c9 leave 11159d: c3 ret =============================================================================== 0010854c : /* * Drain output queue */ static void drainOutput (struct rtems_termios_tty *tty) { 10854c: 55 push %ebp 10854d: 89 e5 mov %esp,%ebp 10854f: 53 push %ebx 108550: 83 ec 04 sub $0x4,%esp 108553: 89 c3 mov %eax,%ebx rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { 108555: 8b 90 b4 00 00 00 mov 0xb4(%eax),%edx 10855b: 85 d2 test %edx,%edx 10855d: 74 4d je 1085ac rtems_interrupt_disable (level); 10855f: 9c pushf 108560: fa cli 108561: 58 pop %eax while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) { 108562: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx 108568: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 10856e: 39 d1 cmp %edx,%ecx 108570: 74 38 je 1085aa 108572: 66 90 xchg %ax,%ax tty->rawOutBufState = rob_wait; 108574: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) 10857b: 00 00 00 rtems_interrupt_enable (level); 10857e: 50 push %eax 10857f: 9d popf sc = rtems_semaphore_obtain( 108580: 50 push %eax 108581: 6a 00 push $0x0 108583: 6a 00 push $0x0 108585: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 10858b: e8 18 26 00 00 call 10aba8 tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 108590: 83 c4 10 add $0x10,%esp 108593: 85 c0 test %eax,%eax 108595: 75 1a jne 1085b1 <== NEVER TAKEN rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); 108597: 9c pushf 108598: fa cli 108599: 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) { 10859a: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx 1085a0: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 1085a6: 39 d1 cmp %edx,%ecx 1085a8: 75 ca jne 108574 <== 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); 1085aa: 50 push %eax 1085ab: 9d popf } } 1085ac: 8b 5d fc mov -0x4(%ebp),%ebx 1085af: c9 leave 1085b0: 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); 1085b1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1085b4: 50 push %eax <== NOT EXECUTED 1085b5: e8 2e 2c 00 00 call 10b1e8 <== NOT EXECUTED =============================================================================== 001092e4 : /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { 1092e4: 55 push %ebp 1092e5: 89 e5 mov %esp,%ebp 1092e7: 53 push %ebx 1092e8: 83 ec 24 sub $0x24,%esp if ((tty->termios.c_lflag & ECHOCTL) && 1092eb: f6 42 3d 02 testb $0x2,0x3d(%edx) 1092ef: 74 1b je 10930c <== NEVER TAKEN iscntrl(c) && (c != '\t') && (c != '\n')) { 1092f1: 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) && 1092f4: 8b 1d 54 42 12 00 mov 0x124254,%ebx 1092fa: f6 44 0b 01 20 testb $0x20,0x1(%ebx,%ecx,1) 1092ff: 74 0b je 10930c iscntrl(c) && (c != '\t') && (c != '\n')) { 109301: 3c 09 cmp $0x9,%al 109303: 74 07 je 10930c 109305: 3c 0a cmp $0xa,%al 109307: 75 13 jne 10931c 109309: 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); 10930c: 0f b6 c0 movzbl %al,%eax 10930f: e8 94 fe ff ff call 1091a8 } } 109314: 8b 5d fc mov -0x4(%ebp),%ebx 109317: c9 leave 109318: c3 ret 109319: 8d 76 00 lea 0x0(%esi),%esi { if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) { char echobuf[2]; echobuf[0] = '^'; 10931c: c6 45 f6 5e movb $0x5e,-0xa(%ebp) echobuf[1] = c ^ 0x40; 109320: 83 f0 40 xor $0x40,%eax 109323: 88 45 f7 mov %al,-0x9(%ebp) rtems_termios_puts (echobuf, 2, tty); 109326: 53 push %ebx 109327: 52 push %edx 109328: 6a 02 push $0x2 10932a: 8d 45 f6 lea -0xa(%ebp),%eax 10932d: 50 push %eax 10932e: 89 55 e4 mov %edx,-0x1c(%ebp) 109331: e8 3e fd ff ff call 109074 tty->column += 2; 109336: 8b 55 e4 mov -0x1c(%ebp),%edx 109339: 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')) { 10933d: 83 c4 10 add $0x10,%esp rtems_termios_puts (echobuf, 2, tty); tty->column += 2; } else { oproc (c, tty); } } 109340: 8b 5d fc mov -0x4(%ebp),%ebx 109343: c9 leave 109344: c3 ret =============================================================================== 001084e4 : void endgrent(void) { 1084e4: 55 push %ebp 1084e5: 89 e5 mov %esp,%ebp 1084e7: 83 ec 08 sub $0x8,%esp if (group_fp != NULL) 1084ea: a1 a0 6f 12 00 mov 0x126fa0,%eax 1084ef: 85 c0 test %eax,%eax 1084f1: 74 0c je 1084ff <== NEVER TAKEN fclose(group_fp); 1084f3: 83 ec 0c sub $0xc,%esp 1084f6: 50 push %eax 1084f7: e8 48 a8 00 00 call 112d44 1084fc: 83 c4 10 add $0x10,%esp } 1084ff: c9 leave 108500: c3 ret =============================================================================== 0010838c : void endpwent(void) { 10838c: 55 push %ebp 10838d: 89 e5 mov %esp,%ebp 10838f: 83 ec 08 sub $0x8,%esp if (passwd_fp != NULL) 108392: a1 88 70 12 00 mov 0x127088,%eax 108397: 85 c0 test %eax,%eax 108399: 74 0c je 1083a7 <== NEVER TAKEN fclose(passwd_fp); 10839b: 83 ec 0c sub $0xc,%esp 10839e: 50 push %eax 10839f: e8 a0 a9 00 00 call 112d44 1083a4: 83 c4 10 add $0x10,%esp } 1083a7: c9 leave 1083a8: c3 ret =============================================================================== 00109348 : * 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) { 109348: 55 push %ebp 109349: 89 e5 mov %esp,%ebp 10934b: 57 push %edi 10934c: 56 push %esi 10934d: 53 push %ebx 10934e: 83 ec 1c sub $0x1c,%esp 109351: 89 c3 mov %eax,%ebx 109353: 89 d7 mov %edx,%edi if (tty->ccount == 0) 109355: 8b 48 20 mov 0x20(%eax),%ecx 109358: 85 c9 test %ecx,%ecx 10935a: 0f 84 84 00 00 00 je 1093e4 return; if (lineFlag) { 109360: 85 d2 test %edx,%edx 109362: 0f 85 84 00 00 00 jne 1093ec echo ('\n', tty); return; } } while (tty->ccount) { 109368: 8b 50 3c mov 0x3c(%eax),%edx 10936b: 89 7d e4 mov %edi,-0x1c(%ebp) 10936e: eb 1d jmp 10938d rtems_termios_puts ("\b", 1, tty); tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { 109370: 80 e6 02 and $0x2,%dh <== NOT EXECUTED 109373: 0f 85 37 01 00 00 jne 1094b0 <== NOT EXECUTED 109379: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (tty->column) tty->column--; } } } if (!lineFlag) 10937c: 8b 75 e4 mov -0x1c(%ebp),%esi 10937f: 85 f6 test %esi,%esi 109381: 74 61 je 1093e4 <== NEVER TAKEN echo ('\n', tty); return; } } while (tty->ccount) { 109383: 8b 4b 20 mov 0x20(%ebx),%ecx 109386: 85 c9 test %ecx,%ecx 109388: 74 5a je 1093e4 } 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); 10938a: 8b 53 3c mov 0x3c(%ebx),%edx return; } } while (tty->ccount) { unsigned char c = tty->cbuf[--tty->ccount]; 10938d: 8b 7b 1c mov 0x1c(%ebx),%edi 109390: 49 dec %ecx 109391: 89 4b 20 mov %ecx,0x20(%ebx) 109394: 8a 04 0f mov (%edi,%ecx,1),%al if (tty->termios.c_lflag & ECHO) { 109397: f6 c2 08 test $0x8,%dl 10939a: 74 e0 je 10937c <== NEVER TAKEN if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { 10939c: 8b 75 e4 mov -0x1c(%ebp),%esi 10939f: 85 f6 test %esi,%esi 1093a1: 75 09 jne 1093ac 1093a3: f6 c2 10 test $0x10,%dl 1093a6: 0f 84 f0 00 00 00 je 10949c <== NEVER TAKEN echo (tty->termios.c_cc[VERASE], tty); } else if (c == '\t') { 1093ac: 3c 09 cmp $0x9,%al 1093ae: 74 58 je 109408 rtems_termios_puts ("\b", 1, tty); tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { 1093b0: 0f b6 c0 movzbl %al,%eax 1093b3: 8d 70 01 lea 0x1(%eax),%esi 1093b6: a1 54 42 12 00 mov 0x124254,%eax 1093bb: f6 04 30 20 testb $0x20,(%eax,%esi,1) 1093bf: 75 af jne 109370 <== 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); 1093c1: 57 push %edi 1093c2: 53 push %ebx 1093c3: 6a 03 push $0x3 1093c5: 68 66 fe 11 00 push $0x11fe66 1093ca: e8 a5 fc ff ff call 109074 if (tty->column) 1093cf: 8b 43 28 mov 0x28(%ebx),%eax 1093d2: 83 c4 10 add $0x10,%esp 1093d5: 85 c0 test %eax,%eax 1093d7: 74 a3 je 10937c <== NEVER TAKEN tty->column--; 1093d9: 48 dec %eax 1093da: 89 43 28 mov %eax,0x28(%ebx) } } } if (!lineFlag) 1093dd: 8b 75 e4 mov -0x1c(%ebp),%esi 1093e0: 85 f6 test %esi,%esi 1093e2: 75 9f jne 109383 break; } } 1093e4: 8d 65 f4 lea -0xc(%ebp),%esp 1093e7: 5b pop %ebx 1093e8: 5e pop %esi 1093e9: 5f pop %edi 1093ea: c9 leave 1093eb: c3 ret erase (struct rtems_termios_tty *tty, int lineFlag) { if (tty->ccount == 0) return; if (lineFlag) { if (!(tty->termios.c_lflag & ECHO)) { 1093ec: 8b 50 3c mov 0x3c(%eax),%edx 1093ef: f6 c2 08 test $0x8,%dl 1093f2: 0f 84 94 00 00 00 je 10948c <== NEVER TAKEN tty->ccount = 0; return; } if (!(tty->termios.c_lflag & ECHOE)) { 1093f8: f6 c2 10 test $0x10,%dl 1093fb: 0f 84 eb 00 00 00 je 1094ec <== NEVER TAKEN 109401: 89 7d e4 mov %edi,-0x1c(%ebp) 109404: eb 87 jmp 10938d 109406: 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; 109408: 8b 73 2c mov 0x2c(%ebx),%esi int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 10940b: 85 c9 test %ecx,%ecx 10940d: 74 46 je 109455 c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; } else if (iscntrl (c)) { 10940f: a1 54 42 12 00 mov 0x124254,%eax 109414: 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; 109417: 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) 109419: 81 e2 00 02 00 00 and $0x200,%edx 10941f: 89 55 e0 mov %edx,-0x20(%ebp) 109422: 89 5d d8 mov %ebx,-0x28(%ebp) 109425: 8b 5d dc mov -0x24(%ebp),%ebx 109428: eb 10 jmp 10943a 10942a: 66 90 xchg %ax,%ax 10942c: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 10942f: 85 d2 test %edx,%edx <== NOT EXECUTED 109431: 74 03 je 109436 <== NOT EXECUTED col += 2; 109433: 83 c6 02 add $0x2,%esi <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 109436: 39 c1 cmp %eax,%ecx 109438: 74 18 je 109452 <== NEVER TAKEN c = tty->cbuf[i++]; 10943a: 8a 14 07 mov (%edi,%eax,1),%dl 10943d: 40 inc %eax if (c == '\t') { 10943e: 80 fa 09 cmp $0x9,%dl 109441: 74 41 je 109484 <== NEVER TAKEN col = (col | 7) + 1; } else if (iscntrl (c)) { 109443: 0f b6 d2 movzbl %dl,%edx 109446: f6 44 13 01 20 testb $0x20,0x1(%ebx,%edx,1) 10944b: 75 df jne 10942c <== NEVER TAKEN if (tty->termios.c_lflag & ECHOCTL) col += 2; } else { col++; 10944d: 46 inc %esi int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 10944e: 39 c1 cmp %eax,%ecx 109450: 75 e8 jne 10943a 109452: 8b 5d d8 mov -0x28(%ebp),%ebx } /* * Back up over the tab */ while (tty->column > col) { 109455: 3b 73 28 cmp 0x28(%ebx),%esi 109458: 0f 8d 1e ff ff ff jge 10937c <== NEVER TAKEN 10945e: 66 90 xchg %ax,%ax rtems_termios_puts ("\b", 1, tty); 109460: 52 push %edx 109461: 53 push %ebx 109462: 6a 01 push $0x1 109464: 68 68 fe 11 00 push $0x11fe68 109469: e8 06 fc ff ff call 109074 tty->column--; 10946e: 8b 43 28 mov 0x28(%ebx),%eax 109471: 48 dec %eax 109472: 89 43 28 mov %eax,0x28(%ebx) } /* * Back up over the tab */ while (tty->column > col) { 109475: 83 c4 10 add $0x10,%esp 109478: 39 f0 cmp %esi,%eax 10947a: 7f e4 jg 109460 10947c: e9 fb fe ff ff jmp 10937c 109481: 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; 109484: 83 ce 07 or $0x7,%esi 109487: 46 inc %esi 109488: eb ac jmp 109436 10948a: 66 90 xchg %ax,%ax { if (tty->ccount == 0) return; if (lineFlag) { if (!(tty->termios.c_lflag & ECHO)) { tty->ccount = 0; 10948c: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) <== NOT EXECUTED } } if (!lineFlag) break; } } 109493: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109496: 5b pop %ebx <== NOT EXECUTED 109497: 5e pop %esi <== NOT EXECUTED 109498: 5f pop %edi <== NOT EXECUTED 109499: c9 leave <== NOT EXECUTED 10949a: c3 ret <== NOT EXECUTED 10949b: 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); 10949c: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED 1094a0: 89 da mov %ebx,%edx <== NOT EXECUTED } } if (!lineFlag) break; } } 1094a2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1094a5: 5b pop %ebx <== NOT EXECUTED 1094a6: 5e pop %esi <== NOT EXECUTED 1094a7: 5f pop %edi <== NOT EXECUTED 1094a8: 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); 1094a9: e9 36 fe ff ff jmp 1092e4 <== NOT EXECUTED 1094ae: 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); 1094b0: 50 push %eax <== NOT EXECUTED 1094b1: 53 push %ebx <== NOT EXECUTED 1094b2: 6a 03 push $0x3 <== NOT EXECUTED 1094b4: 68 66 fe 11 00 push $0x11fe66 <== NOT EXECUTED 1094b9: e8 b6 fb ff ff call 109074 <== NOT EXECUTED if (tty->column) 1094be: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 1094c1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1094c4: 85 c0 test %eax,%eax <== NOT EXECUTED 1094c6: 74 04 je 1094cc <== NOT EXECUTED tty->column--; 1094c8: 48 dec %eax <== NOT EXECUTED 1094c9: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED } if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) { 1094cc: a1 54 42 12 00 mov 0x124254,%eax <== NOT EXECUTED 1094d1: f6 04 30 20 testb $0x20,(%eax,%esi,1) <== NOT EXECUTED 1094d5: 0f 84 e6 fe ff ff je 1093c1 <== NOT EXECUTED 1094db: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED 1094df: 0f 85 dc fe ff ff jne 1093c1 <== NOT EXECUTED 1094e5: e9 92 fe ff ff jmp 10937c <== NOT EXECUTED 1094ea: 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; 1094ec: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) <== NOT EXECUTED echo (tty->termios.c_cc[VKILL], tty); 1094f3: 0f b6 40 44 movzbl 0x44(%eax),%eax <== NOT EXECUTED 1094f7: 89 da mov %ebx,%edx <== NOT EXECUTED 1094f9: e8 e6 fd ff ff call 1092e4 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) 1094fe: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED 109502: 0f 84 dc fe ff ff je 1093e4 <== NOT EXECUTED echo ('\n', tty); 109508: 89 da mov %ebx,%edx <== NOT EXECUTED 10950a: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10950f: eb 91 jmp 1094a2 <== NOT EXECUTED =============================================================================== 001080b0 : #include int fchdir( int fd ) { 1080b0: 55 push %ebp 1080b1: 89 e5 mov %esp,%ebp 1080b3: 57 push %edi 1080b4: 56 push %esi 1080b5: 53 push %ebx 1080b6: 83 ec 4c sub $0x4c,%esp 1080b9: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_t *iop; rtems_filesystem_location_info_t loc, saved; rtems_libio_check_fd( fd ); 1080bc: 3b 05 ac 35 12 00 cmp 0x1235ac,%eax 1080c2: 0f 83 d0 00 00 00 jae 108198 iop = rtems_libio_iop( fd ); 1080c8: c1 e0 03 shl $0x3,%eax 1080cb: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx 1080d2: 29 c3 sub %eax,%ebx 1080d4: 03 1d 40 77 12 00 add 0x127740,%ebx rtems_libio_check_is_open(iop); 1080da: 8b 43 14 mov 0x14(%ebx),%eax 1080dd: f6 c4 01 test $0x1,%ah 1080e0: 0f 84 b2 00 00 00 je 108198 /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 1080e6: a8 02 test $0x2,%al 1080e8: 0f 84 be 00 00 00 je 1081ac /* * Verify you can change directory into this node. */ if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) != 1080ee: 83 ec 0c sub $0xc,%esp 1080f1: 8b 43 24 mov 0x24(%ebx),%eax 1080f4: 83 c3 18 add $0x18,%ebx 1080f7: 53 push %ebx 1080f8: ff 50 10 call *0x10(%eax) 1080fb: 83 c4 10 add $0x10,%esp 1080fe: 48 dec %eax 1080ff: 75 67 jne 108168 * but note the race condition. Threads who * share their rtems_filesystem_current better * be synchronized! */ saved = rtems_filesystem_current; 108101: a1 70 55 12 00 mov 0x125570,%eax 108106: 8d 55 c0 lea -0x40(%ebp),%edx 108109: 89 55 b4 mov %edx,-0x4c(%ebp) 10810c: 8d 70 04 lea 0x4(%eax),%esi 10810f: b9 05 00 00 00 mov $0x5,%ecx 108114: 89 d7 mov %edx,%edi 108116: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_filesystem_current = iop->pathinfo; 108118: 8d 78 04 lea 0x4(%eax),%edi 10811b: b1 05 mov $0x5,%cl 10811d: 89 de mov %ebx,%esi 10811f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* clone the current node */ if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) { 108121: 83 ec 0c sub $0xc,%esp 108124: 6a 00 push $0x0 108126: 8d 75 d4 lea -0x2c(%ebp),%esi 108129: 56 push %esi 10812a: 6a 00 push $0x0 10812c: 6a 01 push $0x1 10812e: 68 b6 16 12 00 push $0x1216b6 108133: e8 a0 fe ff ff call 107fd8 108138: 83 c4 20 add $0x20,%esp 10813b: 85 c0 test %eax,%eax 10813d: 75 3d jne 10817c /* cloning failed; restore original and bail out */ rtems_filesystem_current = saved; return -1; } /* release the old one */ rtems_filesystem_freenode( &saved ); 10813f: 83 ec 0c sub $0xc,%esp 108142: 8d 45 c0 lea -0x40(%ebp),%eax 108145: 50 push %eax 108146: e8 61 01 00 00 call 1082ac rtems_filesystem_current = loc; 10814b: 8b 3d 70 55 12 00 mov 0x125570,%edi 108151: 83 c7 04 add $0x4,%edi 108154: b9 05 00 00 00 mov $0x5,%ecx 108159: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return 0; 10815b: 83 c4 10 add $0x10,%esp 10815e: 31 c0 xor %eax,%eax } 108160: 8d 65 f4 lea -0xc(%ebp),%esp 108163: 5b pop %ebx 108164: 5e pop %esi 108165: 5f pop %edi 108166: c9 leave 108167: 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 ); 108168: e8 af aa 00 00 call 112c1c <__errno> 10816d: c7 00 14 00 00 00 movl $0x14,(%eax) 108173: b8 ff ff ff ff mov $0xffffffff,%eax 108178: eb e6 jmp 108160 10817a: 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; 10817c: 8b 3d 70 55 12 00 mov 0x125570,%edi 108182: 83 c7 04 add $0x4,%edi 108185: b9 05 00 00 00 mov $0x5,%ecx 10818a: 8b 75 b4 mov -0x4c(%ebp),%esi 10818d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return -1; 10818f: b8 ff ff ff ff mov $0xffffffff,%eax 108194: eb ca jmp 108160 108196: 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); 108198: e8 7f aa 00 00 call 112c1c <__errno> 10819d: c7 00 09 00 00 00 movl $0x9,(%eax) 1081a3: b8 ff ff ff ff mov $0xffffffff,%eax 1081a8: eb b6 jmp 108160 1081aa: 66 90 xchg %ax,%ax /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 1081ac: e8 6b aa 00 00 call 112c1c <__errno> 1081b1: c7 00 16 00 00 00 movl $0x16,(%eax) 1081b7: b8 ff ff ff ff mov $0xffffffff,%eax 1081bc: eb a2 jmp 108160 =============================================================================== 001081c0 : int fchmod( int fd, mode_t mode ) { 1081c0: 55 push %ebp 1081c1: 89 e5 mov %esp,%ebp 1081c3: 83 ec 08 sub $0x8,%esp 1081c6: 8b 45 08 mov 0x8(%ebp),%eax 1081c9: 8b 4d 0c mov 0xc(%ebp),%ecx rtems_libio_t *iop; rtems_libio_check_fd( fd ); 1081cc: 3b 05 ac 35 12 00 cmp 0x1235ac,%eax 1081d2: 73 38 jae 10820c iop = rtems_libio_iop( fd ); 1081d4: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx 1081db: 8d 04 d5 00 00 00 00 lea 0x0(,%edx,8),%eax 1081e2: 29 d0 sub %edx,%eax 1081e4: 03 05 40 77 12 00 add 0x127740,%eax rtems_libio_check_is_open(iop); 1081ea: 8b 50 14 mov 0x14(%eax),%edx 1081ed: f6 c6 01 test $0x1,%dh 1081f0: 74 1a je 10820c /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 1081f2: 83 e2 04 and $0x4,%edx 1081f5: 74 29 je 108220 return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode ); 1081f7: 8b 50 20 mov 0x20(%eax),%edx 1081fa: 89 4d 0c mov %ecx,0xc(%ebp) 1081fd: 83 c0 18 add $0x18,%eax 108200: 89 45 08 mov %eax,0x8(%ebp) 108203: 8b 42 1c mov 0x1c(%edx),%eax } 108206: c9 leave * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode ); 108207: ff e0 jmp *%eax 108209: 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); 10820c: e8 0b aa 00 00 call 112c1c <__errno> 108211: 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 ); } 108217: b8 ff ff ff ff mov $0xffffffff,%eax 10821c: c9 leave 10821d: c3 ret 10821e: 66 90 xchg %ax,%ax /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 108220: e8 f7 a9 00 00 call 112c1c <__errno> 108225: c7 00 16 00 00 00 movl $0x16,(%eax) 10822b: eb ea jmp 108217 =============================================================================== 00108060 : int fcntl( int fd, int cmd, ... ) { 108060: 55 push %ebp 108061: 89 e5 mov %esp,%ebp 108063: 57 push %edi 108064: 56 push %esi 108065: 53 push %ebx 108066: 83 ec 1c sub $0x1c,%esp 108069: 8b 5d 08 mov 0x8(%ebp),%ebx 10806c: 8b 55 0c mov 0xc(%ebp),%edx int ret; va_list ap; va_start( ap, cmd ); 10806f: 8d 7d 10 lea 0x10(%ebp),%edi int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 108072: 8b 0d 4c 31 12 00 mov 0x12314c,%ecx 108078: 39 cb cmp %ecx,%ebx 10807a: 0f 83 5c 01 00 00 jae 1081dc iop = rtems_libio_iop( fd ); 108080: a1 e0 72 12 00 mov 0x1272e0,%eax 108085: 8d 34 dd 00 00 00 00 lea 0x0(,%ebx,8),%esi 10808c: 8d 1c f5 00 00 00 00 lea 0x0(,%esi,8),%ebx 108093: 29 f3 sub %esi,%ebx 108095: 8d 1c 18 lea (%eax,%ebx,1),%ebx rtems_libio_check_is_open(iop); 108098: 8b 73 14 mov 0x14(%ebx),%esi 10809b: f7 c6 00 01 00 00 test $0x100,%esi 1080a1: 0f 84 35 01 00 00 je 1081dc /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 1080a7: 83 fa 09 cmp $0x9,%edx 1080aa: 76 10 jbe 1080bc errno = ENOTSUP; ret = -1; break; default: errno = EINVAL; 1080ac: e8 1b ae 00 00 call 112ecc <__errno> 1080b1: c7 00 16 00 00 00 movl $0x16,(%eax) 1080b7: eb 16 jmp 1080cf 1080b9: 8d 76 00 lea 0x0(%esi),%esi /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 1080bc: ff 24 95 d0 18 12 00 jmp *0x1218d0(,%edx,4) 1080c3: 90 nop errno = ENOTSUP; ret = -1; break; case F_GETOWN: /* for sockets. */ errno = ENOTSUP; 1080c4: e8 03 ae 00 00 call 112ecc <__errno> 1080c9: 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; 1080cf: 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; } 1080d4: 89 f0 mov %esi,%eax 1080d6: 8d 65 f4 lea -0xc(%ebp),%esp 1080d9: 5b pop %ebx 1080da: 5e pop %esi 1080db: 5f pop %edi 1080dc: c9 leave 1080dd: c3 ret 1080de: 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 ) ); 1080e0: 83 ec 0c sub $0xc,%esp 1080e3: ff 37 pushl (%edi) 1080e5: 89 55 e0 mov %edx,-0x20(%ebp) 1080e8: e8 33 05 00 00 call 108620 /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = (iop->flags & ~mask) | (flags & mask); 1080ed: 25 01 02 00 00 and $0x201,%eax 1080f2: 8b 4b 14 mov 0x14(%ebx),%ecx 1080f5: 81 e1 fe fd ff ff and $0xfffffdfe,%ecx 1080fb: 09 c8 or %ecx,%eax 1080fd: 89 43 14 mov %eax,0x14(%ebx) 108100: 83 c4 10 add $0x10,%esp rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0; 108103: 31 f6 xor %esi,%esi 108105: 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 ); 108108: 83 ec 08 sub $0x8,%esp 10810b: 8b 43 20 mov 0x20(%ebx),%eax 10810e: 53 push %ebx 10810f: 52 push %edx 108110: ff 50 30 call *0x30(%eax) 108113: 89 c3 mov %eax,%ebx if (err) { 108115: 83 c4 10 add $0x10,%esp 108118: 85 c0 test %eax,%eax 10811a: 74 b8 je 1080d4 <== ALWAYS TAKEN errno = err; 10811c: e8 ab ad 00 00 call 112ecc <__errno> <== NOT EXECUTED 108121: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 108123: eb aa jmp 1080cf <== NOT EXECUTED 108125: 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 ); 108128: 83 ec 0c sub $0xc,%esp 10812b: 56 push %esi 10812c: 89 55 e0 mov %edx,-0x20(%ebp) 10812f: e8 24 05 00 00 call 108658 108134: 89 c6 mov %eax,%esi 108136: 83 c4 10 add $0x10,%esp 108139: 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) { 10813c: 85 f6 test %esi,%esi 10813e: 79 c8 jns 108108 <== ALWAYS TAKEN 108140: eb 92 jmp 1080d4 <== NOT EXECUTED 108142: 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 ) ) 108144: 8b 07 mov (%edi),%eax 108146: 85 c0 test %eax,%eax 108148: 74 6a je 1081b4 iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; 10814a: 81 ce 00 08 00 00 or $0x800,%esi 108150: 89 73 14 mov %esi,0x14(%ebx) rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0; 108153: 31 f6 xor %esi,%esi 108155: eb b1 jmp 108108 108157: 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); 108158: 31 c0 xor %eax,%eax 10815a: f7 c6 00 08 00 00 test $0x800,%esi 108160: 0f 95 c0 setne %al 108163: 89 c6 mov %eax,%esi 108165: eb a1 jmp 108108 108167: 90 nop * This switch should contain all the cases from POSIX. */ switch ( cmd ) { case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); 108168: 8b 3f mov (%edi),%edi if ( fd2 ) 10816a: 85 ff test %edi,%edi 10816c: 0f 84 82 00 00 00 je 1081f4 diop = rtems_libio_iop( fd2 ); 108172: 39 f9 cmp %edi,%ecx 108174: 77 4e ja 1081c4 <== ALWAYS TAKEN 108176: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) <== NOT EXECUTED 10817d: 31 ff xor %edi,%edi <== NOT EXECUTED ret = -1; break; } } diop->flags = iop->flags; 10817f: 89 77 14 mov %esi,0x14(%edi) diop->pathinfo = iop->pathinfo; 108182: 83 c7 18 add $0x18,%edi 108185: 8d 73 18 lea 0x18(%ebx),%esi 108188: b9 05 00 00 00 mov $0x5,%ecx 10818d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ret = (int) (diop - rtems_libio_iops); 10818f: 8b 4d e4 mov -0x1c(%ebp),%ecx 108192: 29 c1 sub %eax,%ecx 108194: 89 c8 mov %ecx,%eax 108196: c1 f8 03 sar $0x3,%eax 108199: 8d 0c c0 lea (%eax,%eax,8),%ecx 10819c: 8d 0c c8 lea (%eax,%ecx,8),%ecx 10819f: 8d 0c c8 lea (%eax,%ecx,8),%ecx 1081a2: 8d 0c c8 lea (%eax,%ecx,8),%ecx 1081a5: 89 ce mov %ecx,%esi 1081a7: c1 e6 0f shl $0xf,%esi 1081aa: 01 f1 add %esi,%ecx 1081ac: 8d 34 c8 lea (%eax,%ecx,8),%esi 1081af: f7 de neg %esi 1081b1: eb 89 jmp 10813c 1081b3: 90 nop */ if ( va_arg( ap, int ) ) iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; 1081b4: 81 e6 ff f7 ff ff and $0xfffff7ff,%esi 1081ba: 89 73 14 mov %esi,0x14(%ebx) rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0; 1081bd: 31 f6 xor %esi,%esi 1081bf: e9 44 ff ff ff jmp 108108 switch ( cmd ) { case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); if ( fd2 ) diop = rtems_libio_iop( fd2 ); 1081c4: 8d 0c fd 00 00 00 00 lea 0x0(,%edi,8),%ecx 1081cb: 8d 3c cd 00 00 00 00 lea 0x0(,%ecx,8),%edi 1081d2: 29 cf sub %ecx,%edi 1081d4: 8d 3c 38 lea (%eax,%edi,1),%edi 1081d7: 89 7d e4 mov %edi,-0x1c(%ebp) 1081da: eb a3 jmp 10817f int mask; int ret = 0; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 1081dc: e8 eb ac 00 00 call 112ecc <__errno> 1081e1: c7 00 09 00 00 00 movl $0x9,(%eax) 1081e7: be ff ff ff ff mov $0xffffffff,%esi 1081ec: e9 e3 fe ff ff jmp 1080d4 1081f1: 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(); 1081f4: 89 55 e0 mov %edx,-0x20(%ebp) 1081f7: e8 a0 04 00 00 call 10869c 1081fc: 89 c7 mov %eax,%edi if ( diop == 0 ) { 1081fe: 85 c0 test %eax,%eax 108200: 8b 55 e0 mov -0x20(%ebp),%edx 108203: 0f 84 c6 fe ff ff je 1080cf <== NEVER TAKEN 108209: 8b 73 14 mov 0x14(%ebx),%esi 10820c: 89 45 e4 mov %eax,-0x1c(%ebp) 10820f: a1 e0 72 12 00 mov 0x1272e0,%eax 108214: e9 66 ff ff ff jmp 10817f =============================================================================== 0010823c : #include int fdatasync( int fd ) { 10823c: 55 push %ebp 10823d: 89 e5 mov %esp,%ebp 10823f: 83 ec 08 sub $0x8,%esp 108242: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_t *iop; rtems_libio_check_fd( fd ); 108245: 3b 05 4c 31 12 00 cmp 0x12314c,%eax 10824b: 73 2f jae 10827c iop = rtems_libio_iop( fd ); 10824d: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx 108254: 8d 04 d5 00 00 00 00 lea 0x0(,%edx,8),%eax 10825b: 29 d0 sub %edx,%eax 10825d: 03 05 e0 72 12 00 add 0x1272e0,%eax rtems_libio_check_is_open(iop); 108263: 8b 50 14 mov 0x14(%eax),%edx 108266: f6 c6 01 test $0x1,%dh 108269: 74 11 je 10827c rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 10826b: 83 e2 04 and $0x4,%edx 10826e: 74 20 je 108290 /* * Now process the fdatasync(). */ return (*iop->pathinfo.handlers->fdatasync_h)( iop ); 108270: 8b 50 20 mov 0x20(%eax),%edx 108273: 89 45 08 mov %eax,0x8(%ebp) 108276: 8b 42 2c mov 0x2c(%edx),%eax } 108279: c9 leave /* * Now process the fdatasync(). */ return (*iop->pathinfo.handlers->fdatasync_h)( iop ); 10827a: ff e0 jmp *%eax { rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 10827c: e8 4b ac 00 00 call 112ecc <__errno> 108281: c7 00 09 00 00 00 movl $0x9,(%eax) /* * Now process the fdatasync(). */ return (*iop->pathinfo.handlers->fdatasync_h)( iop ); } 108287: b8 ff ff ff ff mov $0xffffffff,%eax 10828c: c9 leave 10828d: c3 ret 10828e: 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 ); 108290: e8 37 ac 00 00 call 112ecc <__errno> 108295: c7 00 16 00 00 00 movl $0x16,(%eax) 10829b: eb ea jmp 108287 =============================================================================== 00110dbc : */ int fifo_open( pipe_control_t **pipep, rtems_libio_t *iop ) { 110dbc: 55 push %ebp 110dbd: 89 e5 mov %esp,%ebp 110dbf: 57 push %edi 110dc0: 56 push %esi 110dc1: 53 push %ebx 110dc2: 83 ec 2c sub $0x2c,%esp 110dc5: 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) { 110dc8: a1 54 85 12 00 mov 0x128554,%eax 110dcd: 85 c0 test %eax,%eax 110dcf: 0f 84 8b 00 00 00 je 110e60 rtems_libio_unlock(); } if (sc == RTEMS_SUCCESSFUL) { sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 110dd5: 51 push %ecx 110dd6: 6a 00 push $0x0 110dd8: 6a 00 push $0x0 110dda: 50 push %eax 110ddb: e8 dc ba ff ff call 10c8bc } if (sc == RTEMS_SUCCESSFUL) { 110de0: 83 c4 10 add $0x10,%esp 110de3: 85 c0 test %eax,%eax 110de5: 0f 85 0c 03 00 00 jne 1110f7 <== NEVER TAKEN err = pipe_lock(); if (err) return err; pipe = *pipep; 110deb: 8b 1e mov (%esi),%ebx if (pipe == NULL) { 110ded: 85 db test %ebx,%ebx 110def: 0f 84 df 01 00 00 je 110fd4 err = pipe_alloc(&pipe); if (err) goto out; } if (! PIPE_LOCK(pipe)) 110df5: 52 push %edx 110df6: 6a 00 push $0x0 110df8: 6a 00 push $0x0 110dfa: ff 73 28 pushl 0x28(%ebx) 110dfd: e8 ba ba ff ff call 10c8bc 110e02: 83 c4 10 add $0x10,%esp 110e05: 83 f8 01 cmp $0x1,%eax 110e08: 19 ff sbb %edi,%edi 110e0a: f7 d7 not %edi 110e0c: 83 e7 fc and $0xfffffffc,%edi err = -EINTR; if (*pipep == NULL) { 110e0f: 8b 06 mov (%esi),%eax 110e11: 85 c0 test %eax,%eax 110e13: 0f 84 97 02 00 00 je 1110b0 else *pipep = pipe; } out: pipe_unlock(); 110e19: e8 aa fe ff ff call 110cc8 pipe_control_t *pipe; unsigned int prevCounter; int err; err = pipe_new(pipep); if (err) 110e1e: 85 ff test %edi,%edi 110e20: 75 32 jne 110e54 <== NEVER TAKEN return err; pipe = *pipep; 110e22: 8b 1e mov (%esi),%ebx switch (LIBIO_ACCMODE(iop)) { 110e24: 8b 55 0c mov 0xc(%ebp),%edx 110e27: 8b 42 14 mov 0x14(%edx),%eax 110e2a: 83 e0 06 and $0x6,%eax 110e2d: 83 f8 04 cmp $0x4,%eax 110e30: 74 6a je 110e9c 110e32: 83 f8 06 cmp $0x6,%eax 110e35: 0f 84 59 01 00 00 je 110f94 110e3b: 83 f8 02 cmp $0x2,%eax 110e3e: 0f 84 dc 00 00 00 je 110f20 <== ALWAYS TAKEN if (pipe->Writers ++ == 0) PIPE_WAKEUPREADERS(pipe); break; } PIPE_UNLOCK(pipe); 110e44: 83 ec 0c sub $0xc,%esp 110e47: ff 73 28 pushl 0x28(%ebx) 110e4a: e8 69 bb ff ff call 10c9b8 return 0; 110e4f: 83 c4 10 add $0x10,%esp 110e52: 31 ff xor %edi,%edi out_error: pipe_release(pipep, iop); return err; } 110e54: 89 f8 mov %edi,%eax 110e56: 8d 65 f4 lea -0xc(%ebp),%esp 110e59: 5b pop %ebx 110e5a: 5e pop %esi 110e5b: 5f pop %edi 110e5c: c9 leave 110e5d: c3 ret 110e5e: 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 ); 110e60: 57 push %edi 110e61: 6a 00 push $0x0 110e63: 6a 00 push $0x0 110e65: ff 35 88 87 12 00 pushl 0x128788 110e6b: e8 4c ba ff ff call 10c8bc rtems_status_code sc = RTEMS_SUCCESSFUL; if (pipe_semaphore == RTEMS_ID_NONE) { rtems_libio_lock(); if (pipe_semaphore == RTEMS_ID_NONE) { 110e70: 83 c4 10 add $0x10,%esp 110e73: 8b 1d 54 85 12 00 mov 0x128554,%ebx 110e79: 85 db test %ebx,%ebx 110e7b: 0f 84 43 02 00 00 je 1110c4 <== ALWAYS TAKEN } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 110e81: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110e84: ff 35 88 87 12 00 pushl 0x128788 <== NOT EXECUTED 110e8a: e8 29 bb ff ff call 10c9b8 <== NOT EXECUTED 110e8f: a1 54 85 12 00 mov 0x128554,%eax <== NOT EXECUTED 110e94: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110e97: e9 39 ff ff ff jmp 110dd5 <== NOT EXECUTED } while (prevCounter == pipe->writerCounter); } break; case LIBIO_FLAGS_WRITE: pipe->writerCounter ++; 110e9c: ff 43 24 incl 0x24(%ebx) if (pipe->Writers ++ == 0) 110e9f: 8b 43 14 mov 0x14(%ebx),%eax 110ea2: 8d 50 01 lea 0x1(%eax),%edx 110ea5: 89 53 14 mov %edx,0x14(%ebx) 110ea8: 85 c0 test %eax,%eax 110eaa: 0f 84 84 02 00 00 je 111134 <== ALWAYS TAKEN PIPE_WAKEUPREADERS(pipe); if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) { 110eb0: 8b 4b 10 mov 0x10(%ebx),%ecx 110eb3: 85 c9 test %ecx,%ecx 110eb5: 75 8d jne 110e44 110eb7: 8b 55 0c mov 0xc(%ebp),%edx 110eba: f6 42 14 01 testb $0x1,0x14(%edx) 110ebe: 0f 85 c4 02 00 00 jne 111188 err = -ENXIO; goto out_error; } if (pipe->Readers == 0) { prevCounter = pipe->readerCounter; 110ec4: 8b 7b 20 mov 0x20(%ebx),%edi 110ec7: eb 20 jmp 110ee9 110ec9: 8d 76 00 lea 0x0(%esi),%esi err = -EINTR; do { PIPE_UNLOCK(pipe); if (! PIPE_WRITEWAIT(pipe)) goto out_error; if (! PIPE_LOCK(pipe)) 110ecc: 51 push %ecx 110ecd: 6a 00 push $0x0 110ecf: 6a 00 push $0x0 110ed1: ff 73 28 pushl 0x28(%ebx) 110ed4: e8 e3 b9 ff ff call 10c8bc 110ed9: 83 c4 10 add $0x10,%esp 110edc: 85 c0 test %eax,%eax 110ede: 75 27 jne 110f07 <== NEVER TAKEN goto out_error; } while (prevCounter == pipe->readerCounter); 110ee0: 39 7b 20 cmp %edi,0x20(%ebx) 110ee3: 0f 85 5b ff ff ff jne 110e44 <== ALWAYS TAKEN if (pipe->Readers == 0) { prevCounter = pipe->readerCounter; err = -EINTR; do { PIPE_UNLOCK(pipe); 110ee9: 83 ec 0c sub $0xc,%esp 110eec: ff 73 28 pushl 0x28(%ebx) 110eef: e8 c4 ba ff ff call 10c9b8 if (! PIPE_WRITEWAIT(pipe)) 110ef4: 58 pop %eax 110ef5: 5a pop %edx 110ef6: 6a 00 push $0x0 110ef8: ff 73 30 pushl 0x30(%ebx) 110efb: e8 04 13 00 00 call 112204 110f00: 83 c4 10 add $0x10,%esp 110f03: 85 c0 test %eax,%eax 110f05: 74 c5 je 110ecc <== ALWAYS TAKEN goto out_error; } if (pipe->Readers == 0) { prevCounter = pipe->readerCounter; err = -EINTR; 110f07: bf fc ff ff ff mov $0xfffffffc,%edi <== NOT EXECUTED PIPE_UNLOCK(pipe); return 0; out_error: pipe_release(pipep, iop); 110f0c: 83 ec 08 sub $0x8,%esp 110f0f: ff 75 0c pushl 0xc(%ebp) 110f12: 56 push %esi 110f13: e8 c8 fd ff ff call 110ce0 return err; 110f18: 83 c4 10 add $0x10,%esp 110f1b: e9 34 ff ff ff jmp 110e54 return err; pipe = *pipep; switch (LIBIO_ACCMODE(iop)) { case LIBIO_FLAGS_READ: pipe->readerCounter ++; 110f20: ff 43 20 incl 0x20(%ebx) if (pipe->Readers ++ == 0) 110f23: 8b 43 10 mov 0x10(%ebx),%eax 110f26: 8d 50 01 lea 0x1(%eax),%edx 110f29: 89 53 10 mov %edx,0x10(%ebx) 110f2c: 85 c0 test %eax,%eax 110f2e: 0f 84 d0 01 00 00 je 111104 <== ALWAYS TAKEN PIPE_WAKEUPWRITERS(pipe); if (pipe->Writers == 0) { 110f34: 8b 7b 14 mov 0x14(%ebx),%edi 110f37: 85 ff test %edi,%edi 110f39: 0f 85 05 ff ff ff jne 110e44 /* Not an error */ if (LIBIO_NODELAY(iop)) 110f3f: 8b 45 0c mov 0xc(%ebp),%eax 110f42: f6 40 14 01 testb $0x1,0x14(%eax) 110f46: 0f 85 f8 fe ff ff jne 110e44 break; prevCounter = pipe->writerCounter; 110f4c: 8b 7b 24 mov 0x24(%ebx),%edi 110f4f: eb 20 jmp 110f71 110f51: 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)) 110f54: 50 push %eax 110f55: 6a 00 push $0x0 110f57: 6a 00 push $0x0 110f59: ff 73 28 pushl 0x28(%ebx) 110f5c: e8 5b b9 ff ff call 10c8bc 110f61: 83 c4 10 add $0x10,%esp 110f64: 85 c0 test %eax,%eax 110f66: 75 9f jne 110f07 <== NEVER TAKEN goto out_error; } while (prevCounter == pipe->writerCounter); 110f68: 39 7b 24 cmp %edi,0x24(%ebx) 110f6b: 0f 85 d3 fe ff ff jne 110e44 <== ALWAYS TAKEN prevCounter = pipe->writerCounter; err = -EINTR; /* Wait until a writer opens the pipe */ do { PIPE_UNLOCK(pipe); 110f71: 83 ec 0c sub $0xc,%esp 110f74: ff 73 28 pushl 0x28(%ebx) 110f77: e8 3c ba ff ff call 10c9b8 if (! PIPE_READWAIT(pipe)) 110f7c: 5a pop %edx 110f7d: 59 pop %ecx 110f7e: 6a 00 push $0x0 110f80: ff 73 2c pushl 0x2c(%ebx) 110f83: e8 7c 12 00 00 call 112204 110f88: 83 c4 10 add $0x10,%esp 110f8b: 85 c0 test %eax,%eax 110f8d: 74 c5 je 110f54 <== ALWAYS TAKEN 110f8f: e9 73 ff ff ff jmp 110f07 <== NOT EXECUTED } while (prevCounter == pipe->readerCounter); } break; case LIBIO_FLAGS_READ_WRITE: pipe->readerCounter ++; 110f94: ff 43 20 incl 0x20(%ebx) if (pipe->Readers ++ == 0) 110f97: 8b 43 10 mov 0x10(%ebx),%eax 110f9a: 8d 50 01 lea 0x1(%eax),%edx 110f9d: 89 53 10 mov %edx,0x10(%ebx) 110fa0: 85 c0 test %eax,%eax 110fa2: 0f 84 74 01 00 00 je 11111c <== ALWAYS TAKEN PIPE_WAKEUPWRITERS(pipe); pipe->writerCounter ++; 110fa8: ff 43 24 incl 0x24(%ebx) if (pipe->Writers ++ == 0) 110fab: 8b 43 14 mov 0x14(%ebx),%eax 110fae: 8d 50 01 lea 0x1(%eax),%edx 110fb1: 89 53 14 mov %edx,0x14(%ebx) 110fb4: 85 c0 test %eax,%eax 110fb6: 0f 85 88 fe ff ff jne 110e44 <== NEVER TAKEN PIPE_WAKEUPREADERS(pipe); 110fbc: 83 ec 08 sub $0x8,%esp 110fbf: 8d 45 e4 lea -0x1c(%ebp),%eax 110fc2: 50 push %eax 110fc3: ff 73 2c pushl 0x2c(%ebx) 110fc6: e8 d5 11 00 00 call 1121a0 110fcb: 83 c4 10 add $0x10,%esp 110fce: e9 71 fe ff ff jmp 110e44 110fd3: 90 nop { static char c = 'a'; pipe_control_t *pipe; int err = -ENOMEM; pipe = malloc(sizeof(pipe_control_t)); 110fd4: 83 ec 0c sub $0xc,%esp 110fd7: 6a 34 push $0x34 110fd9: e8 52 85 ff ff call 109530 110fde: 89 c3 mov %eax,%ebx 110fe0: 89 45 d4 mov %eax,-0x2c(%ebp) if (pipe == NULL) 110fe3: 83 c4 10 add $0x10,%esp 110fe6: 85 c0 test %eax,%eax 110fe8: 0f 84 f2 01 00 00 je 1111e0 return err; memset(pipe, 0, sizeof(pipe_control_t)); 110fee: b9 34 00 00 00 mov $0x34,%ecx 110ff3: 31 c0 xor %eax,%eax 110ff5: 89 df mov %ebx,%edi 110ff7: f3 aa rep stos %al,%es:(%edi) pipe->Size = PIPE_BUF; 110ff9: c7 43 04 00 02 00 00 movl $0x200,0x4(%ebx) pipe->Buffer = malloc(pipe->Size); 111000: 83 ec 0c sub $0xc,%esp 111003: 68 00 02 00 00 push $0x200 111008: e8 23 85 ff ff call 109530 11100d: 89 03 mov %eax,(%ebx) if (! pipe->Buffer) 11100f: 83 c4 10 add $0x10,%esp 111012: 85 c0 test %eax,%eax 111014: 0f 84 b8 01 00 00 je 1111d2 <== NEVER TAKEN goto err_buf; err = -ENOMEM; if (rtems_barrier_create( 11101a: 8d 43 2c lea 0x2c(%ebx),%eax 11101d: 50 push %eax 11101e: 6a 00 push $0x0 111020: 6a 00 push $0x0 rtems_build_name ('P', 'I', 'r', c), 111022: 0f be 05 9c 65 12 00 movsbl 0x12659c,%eax if (! pipe->Buffer) goto err_buf; err = -ENOMEM; if (rtems_barrier_create( 111029: 0d 00 72 49 50 or $0x50497200,%eax 11102e: 50 push %eax 11102f: e8 f0 0f 00 00 call 112024 111034: 83 c4 10 add $0x10,%esp 111037: 85 c0 test %eax,%eax 111039: 0f 85 83 01 00 00 jne 1111c2 rtems_build_name ('P', 'I', 'r', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->readBarrier) != RTEMS_SUCCESSFUL) goto err_rbar; if (rtems_barrier_create( 11103f: 8d 43 30 lea 0x30(%ebx),%eax 111042: 50 push %eax 111043: 6a 00 push $0x0 111045: 6a 00 push $0x0 rtems_build_name ('P', 'I', 'w', c), 111047: 0f be 05 9c 65 12 00 movsbl 0x12659c,%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( 11104e: 0d 00 77 49 50 or $0x50497700,%eax 111053: 50 push %eax 111054: e8 cb 0f 00 00 call 112024 111059: 83 c4 10 add $0x10,%esp 11105c: 85 c0 test %eax,%eax 11105e: 0f 85 4d 01 00 00 jne 1111b1 rtems_build_name ('P', 'I', 'w', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->writeBarrier) != RTEMS_SUCCESSFUL) goto err_wbar; if (rtems_semaphore_create( 111064: 83 ec 0c sub $0xc,%esp 111067: 8d 43 28 lea 0x28(%ebx),%eax 11106a: 50 push %eax 11106b: 6a 00 push $0x0 11106d: 6a 10 push $0x10 11106f: 6a 01 push $0x1 rtems_build_name ('P', 'I', 's', c), 1, 111071: 0f be 05 9c 65 12 00 movsbl 0x12659c,%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( 111078: 0d 00 73 49 50 or $0x50497300,%eax 11107d: 50 push %eax 11107e: e8 bd b5 ff ff call 10c640 111083: 83 c4 20 add $0x20,%esp 111086: 85 c0 test %eax,%eax 111088: 0f 85 12 01 00 00 jne 1111a0 #ifdef RTEMS_POSIX_API pipe_interruptible(pipe); #endif *pipep = pipe; if (c ++ == 'z') 11108e: a0 9c 65 12 00 mov 0x12659c,%al 111093: 8d 50 01 lea 0x1(%eax),%edx 111096: 88 15 9c 65 12 00 mov %dl,0x12659c 11109c: 3c 7a cmp $0x7a,%al 11109e: 0f 85 51 fd ff ff jne 110df5 c = 'a'; 1110a4: c6 05 9c 65 12 00 61 movb $0x61,0x12659c 1110ab: e9 45 fd ff ff jmp 110df5 if (! PIPE_LOCK(pipe)) err = -EINTR; if (*pipep == NULL) { if (err) 1110b0: 85 ff test %edi,%edi 1110b2: 0f 85 94 00 00 00 jne 11114c <== NEVER TAKEN pipe_free(pipe); else *pipep = pipe; 1110b8: 89 1e mov %ebx,(%esi) } out: pipe_unlock(); 1110ba: e8 09 fc ff ff call 110cc8 1110bf: e9 5e fd ff ff jmp 110e22 if (pipe_semaphore == RTEMS_ID_NONE) { rtems_libio_lock(); if (pipe_semaphore == RTEMS_ID_NONE) { sc = rtems_semaphore_create( 1110c4: 83 ec 0c sub $0xc,%esp 1110c7: 68 54 85 12 00 push $0x128554 1110cc: 6a 00 push $0x0 1110ce: 6a 54 push $0x54 1110d0: 6a 01 push $0x1 1110d2: 68 45 50 49 50 push $0x50495045 1110d7: e8 64 b5 ff ff call 10c640 1110dc: 89 c3 mov %eax,%ebx 1110de: 83 c4 14 add $0x14,%esp 1110e1: ff 35 88 87 12 00 pushl 0x128788 1110e7: e8 cc b8 ff ff call 10c9b8 } rtems_libio_unlock(); } if (sc == RTEMS_SUCCESSFUL) { 1110ec: 83 c4 10 add $0x10,%esp 1110ef: 85 db test %ebx,%ebx 1110f1: 0f 84 f0 00 00 00 je 1111e7 ) { pipe_control_t *pipe; int err = 0; err = pipe_lock(); 1110f7: bf f4 ff ff ff mov $0xfffffff4,%edi 1110fc: e9 53 fd ff ff jmp 110e54 111101: 8d 76 00 lea 0x0(%esi),%esi switch (LIBIO_ACCMODE(iop)) { case LIBIO_FLAGS_READ: pipe->readerCounter ++; if (pipe->Readers ++ == 0) PIPE_WAKEUPWRITERS(pipe); 111104: 83 ec 08 sub $0x8,%esp 111107: 8d 45 e4 lea -0x1c(%ebp),%eax 11110a: 50 push %eax 11110b: ff 73 30 pushl 0x30(%ebx) 11110e: e8 8d 10 00 00 call 1121a0 111113: 83 c4 10 add $0x10,%esp 111116: e9 19 fe ff ff jmp 110f34 11111b: 90 nop break; case LIBIO_FLAGS_READ_WRITE: pipe->readerCounter ++; if (pipe->Readers ++ == 0) PIPE_WAKEUPWRITERS(pipe); 11111c: 83 ec 08 sub $0x8,%esp 11111f: 8d 45 e4 lea -0x1c(%ebp),%eax 111122: 50 push %eax 111123: ff 73 30 pushl 0x30(%ebx) 111126: e8 75 10 00 00 call 1121a0 11112b: 83 c4 10 add $0x10,%esp 11112e: e9 75 fe ff ff jmp 110fa8 111133: 90 nop case LIBIO_FLAGS_WRITE: pipe->writerCounter ++; if (pipe->Writers ++ == 0) PIPE_WAKEUPREADERS(pipe); 111134: 83 ec 08 sub $0x8,%esp 111137: 8d 45 e4 lea -0x1c(%ebp),%eax 11113a: 50 push %eax 11113b: ff 73 2c pushl 0x2c(%ebx) 11113e: e8 5d 10 00 00 call 1121a0 111143: 83 c4 10 add $0x10,%esp 111146: e9 65 fd ff ff jmp 110eb0 11114b: 90 nop /* Called with pipe_semaphore held. */ static inline void pipe_free( pipe_control_t *pipe ) { rtems_barrier_delete(pipe->readBarrier); 11114c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11114f: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 111152: e8 b9 0f 00 00 call 112110 <== NOT EXECUTED rtems_barrier_delete(pipe->writeBarrier); 111157: 59 pop %ecx <== NOT EXECUTED 111158: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 11115b: e8 b0 0f 00 00 call 112110 <== NOT EXECUTED rtems_semaphore_delete(pipe->Semaphore); 111160: 5a pop %edx <== NOT EXECUTED 111161: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 111164: e8 af b6 ff ff call 10c818 <== NOT EXECUTED free(pipe->Buffer); 111169: 58 pop %eax <== NOT EXECUTED 11116a: ff 33 pushl (%ebx) <== NOT EXECUTED 11116c: e8 ef 7c ff ff call 108e60 <== NOT EXECUTED free(pipe); 111171: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 111174: e8 e7 7c ff ff call 108e60 <== NOT EXECUTED 111179: 83 c4 10 add $0x10,%esp <== NOT EXECUTED else *pipep = pipe; } out: pipe_unlock(); 11117c: e8 47 fb ff ff call 110cc8 111181: e9 ce fc ff ff jmp 110e54 111186: 66 90 xchg %ax,%ax if (pipe->Writers ++ == 0) PIPE_WAKEUPREADERS(pipe); if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) { PIPE_UNLOCK(pipe); 111188: 83 ec 0c sub $0xc,%esp 11118b: ff 73 28 pushl 0x28(%ebx) 11118e: e8 25 b8 ff ff call 10c9b8 err = -ENXIO; goto out_error; 111193: 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; 111196: bf fa ff ff ff mov $0xfffffffa,%edi goto out_error; 11119b: e9 6c fd ff ff jmp 110f0c if (c ++ == 'z') c = 'a'; return 0; err_sem: rtems_barrier_delete(pipe->writeBarrier); 1111a0: 83 ec 0c sub $0xc,%esp 1111a3: 8b 45 d4 mov -0x2c(%ebp),%eax 1111a6: ff 70 30 pushl 0x30(%eax) 1111a9: e8 62 0f 00 00 call 112110 1111ae: 83 c4 10 add $0x10,%esp err_wbar: rtems_barrier_delete(pipe->readBarrier); 1111b1: 83 ec 0c sub $0xc,%esp 1111b4: 8b 55 d4 mov -0x2c(%ebp),%edx 1111b7: ff 72 2c pushl 0x2c(%edx) 1111ba: e8 51 0f 00 00 call 112110 1111bf: 83 c4 10 add $0x10,%esp err_rbar: free(pipe->Buffer); 1111c2: 83 ec 0c sub $0xc,%esp 1111c5: 8b 45 d4 mov -0x2c(%ebp),%eax 1111c8: ff 30 pushl (%eax) 1111ca: e8 91 7c ff ff call 108e60 1111cf: 83 c4 10 add $0x10,%esp err_buf: free(pipe); 1111d2: 83 ec 0c sub $0xc,%esp 1111d5: ff 75 d4 pushl -0x2c(%ebp) 1111d8: e8 83 7c ff ff call 108e60 1111dd: 83 c4 10 add $0x10,%esp ) { pipe_control_t *pipe; int err = 0; err = pipe_lock(); 1111e0: bf f4 ff ff ff mov $0xfffffff4,%edi 1111e5: eb 95 jmp 11117c } rtems_libio_unlock(); } if (sc == RTEMS_SUCCESSFUL) { 1111e7: a1 54 85 12 00 mov 0x128554,%eax 1111ec: e9 e4 fb ff ff jmp 110dd5 =============================================================================== 0010f438 : const char *type; rtems_filesystem_fsmount_me_t mount_h; } find_arg; static bool find_handler(const rtems_filesystem_table_t *entry, void *arg) { 10f438: 55 push %ebp 10f439: 89 e5 mov %esp,%ebp 10f43b: 56 push %esi 10f43c: 53 push %ebx 10f43d: 8b 75 08 mov 0x8(%ebp),%esi 10f440: 8b 5d 0c mov 0xc(%ebp),%ebx find_arg *fa = arg; if ( strcmp( entry->type, fa->type ) != 0 ) { 10f443: 83 ec 08 sub $0x8,%esp 10f446: ff 33 pushl (%ebx) 10f448: ff 36 pushl (%esi) 10f44a: e8 fd 35 00 00 call 112a4c 10f44f: 83 c4 10 add $0x10,%esp 10f452: 85 c0 test %eax,%eax 10f454: 75 12 jne 10f468 return false; } else { fa->mount_h = entry->mount_h; 10f456: 8b 46 04 mov 0x4(%esi),%eax 10f459: 89 43 04 mov %eax,0x4(%ebx) return true; 10f45c: b0 01 mov $0x1,%al } } 10f45e: 8d 65 f8 lea -0x8(%ebp),%esp 10f461: 5b pop %ebx 10f462: 5e pop %esi 10f463: c9 leave 10f464: c3 ret 10f465: 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; 10f468: 31 c0 xor %eax,%eax } else { fa->mount_h = entry->mount_h; return true; } } 10f46a: 8d 65 f8 lea -0x8(%ebp),%esp 10f46d: 5b pop %ebx 10f46e: 5e pop %esi 10f46f: c9 leave 10f470: c3 ret =============================================================================== 001082a0 : long fpathconf( int fd, int name ) { 1082a0: 55 push %ebp 1082a1: 89 e5 mov %esp,%ebp 1082a3: 83 ec 08 sub $0x8,%esp 1082a6: 8b 45 08 mov 0x8(%ebp),%eax 1082a9: 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); 1082ac: 3b 05 4c 31 12 00 cmp 0x12314c,%eax 1082b2: 0f 83 ac 00 00 00 jae 108364 iop = rtems_libio_iop(fd); 1082b8: 8d 0c c5 00 00 00 00 lea 0x0(,%eax,8),%ecx 1082bf: 8d 04 cd 00 00 00 00 lea 0x0(,%ecx,8),%eax 1082c6: 29 c8 sub %ecx,%eax 1082c8: 03 05 e0 72 12 00 add 0x1272e0,%eax rtems_libio_check_is_open(iop); 1082ce: 8b 48 14 mov 0x14(%eax),%ecx 1082d1: f6 c5 01 test $0x1,%ch 1082d4: 0f 84 8a 00 00 00 je 108364 <== NEVER TAKEN rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ); 1082da: 83 e1 02 and $0x2,%ecx 1082dd: 74 08 je 1082e7 /* * Now process the information request. */ the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options; 1082df: 8b 40 28 mov 0x28(%eax),%eax switch ( name ) { 1082e2: 83 fa 0b cmp $0xb,%edx 1082e5: 76 15 jbe 1082fc break; case _PC_SYNC_IO: return_value = the_limits->posix_sync_io; break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 1082e7: e8 e0 ab 00 00 call 112ecc <__errno> 1082ec: c7 00 16 00 00 00 movl $0x16,(%eax) 1082f2: b8 ff ff ff ff mov $0xffffffff,%eax break; } return return_value; } 1082f7: c9 leave 1082f8: c3 ret 1082f9: 8d 76 00 lea 0x0(%esi),%esi * Now process the information request. */ the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options; switch ( name ) { 1082fc: ff 24 95 f8 18 12 00 jmp *0x1218f8(,%edx,4) 108303: 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; 108304: 8b 40 5c mov 0x5c(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108307: c9 leave 108308: c3 ret 108309: 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; 10830c: 8b 40 50 mov 0x50(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 10830f: c9 leave 108310: c3 ret 108311: 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; 108314: 8b 40 64 mov 0x64(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108317: c9 leave 108318: c3 ret 108319: 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; 10831c: 8b 40 58 mov 0x58(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 10831f: c9 leave 108320: c3 ret 108321: 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; 108324: 8b 40 54 mov 0x54(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108327: c9 leave 108328: c3 ret 108329: 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; 10832c: 8b 40 4c mov 0x4c(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 10832f: c9 leave 108330: c3 ret 108331: 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; 108334: 8b 40 48 mov 0x48(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108337: c9 leave 108338: c3 ret 108339: 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; 10833c: 8b 40 44 mov 0x44(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 10833f: c9 leave 108340: c3 ret 108341: 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; 108344: 8b 40 40 mov 0x40(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108347: c9 leave 108348: c3 ret 108349: 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; 10834c: 8b 40 3c mov 0x3c(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 10834f: c9 leave 108350: c3 ret 108351: 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; 108354: 8b 40 38 mov 0x38(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108357: c9 leave 108358: c3 ret 108359: 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; 10835c: 8b 40 60 mov 0x60(%eax),%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 10835f: c9 leave 108360: c3 ret 108361: 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); 108364: e8 63 ab 00 00 call 112ecc <__errno> 108369: c7 00 09 00 00 00 movl $0x9,(%eax) 10836f: b8 ff ff ff ff mov $0xffffffff,%eax rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108374: c9 leave 108375: c3 ret =============================================================================== 00107634 : #include void free( void *ptr ) { 107634: 55 push %ebp 107635: 89 e5 mov %esp,%ebp 107637: 53 push %ebx 107638: 83 ec 04 sub $0x4,%esp 10763b: 8b 5d 08 mov 0x8(%ebp),%ebx MSBUMP(free_calls, 1); 10763e: ff 05 ac 63 12 00 incl 0x1263ac if ( !ptr ) 107644: 85 db test %ebx,%ebx 107646: 74 4b je 107693 return; /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 107648: 83 3d 80 66 12 00 03 cmpl $0x3,0x126680 10764f: 74 47 je 107698 <== ALWAYS TAKEN } /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 107651: a1 a8 47 12 00 mov 0x1247a8,%eax 107656: 85 c0 test %eax,%eax 107658: 74 0a je 107664 (*rtems_malloc_statistics_helpers->at_free)(ptr); 10765a: 83 ec 0c sub $0xc,%esp 10765d: 53 push %ebx 10765e: ff 50 08 call *0x8(%eax) 107661: 83 c4 10 add $0x10,%esp if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) { 107664: 83 ec 08 sub $0x8,%esp 107667: 53 push %ebx 107668: ff 35 30 22 12 00 pushl 0x122230 10766e: e8 fd 4d 00 00 call 10c470 <_Protected_heap_Free> 107673: 83 c4 10 add $0x10,%esp 107676: 84 c0 test %al,%al 107678: 75 19 jne 107693 printk( "Program heap: free of bad pointer %p -- range %p - %p \n", ptr, RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end 10767a: a1 30 22 12 00 mov 0x122230,%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", 10767f: ff 70 1c pushl 0x1c(%eax) 107682: ff 70 18 pushl 0x18(%eax) 107685: 53 push %ebx 107686: 68 70 fd 11 00 push $0x11fd70 10768b: e8 b4 0d 00 00 call 108444 107690: 83 c4 10 add $0x10,%esp RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end ); } } 107693: 8b 5d fc mov -0x4(%ebp),%ebx 107696: c9 leave 107697: 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() ) { 107698: e8 3b 01 00 00 call 1077d8 return; /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 10769d: 84 c0 test %al,%al 10769f: 75 b0 jne 107651 !malloc_is_system_state_OK() ) { malloc_deferred_free(ptr); 1076a1: 89 5d 08 mov %ebx,0x8(%ebp) RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end ); } } 1076a4: 8b 5d fc mov -0x4(%ebp),%ebx 1076a7: 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); 1076a8: e9 97 01 00 00 jmp 107844 =============================================================================== 00108af8 : * NOTE: this must be called with * thread dispatching disabled! */ static void free_user_env(void *venv) { 108af8: 55 push %ebp 108af9: 89 e5 mov %esp,%ebp 108afb: 53 push %ebx 108afc: 83 ec 04 sub $0x4,%esp 108aff: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_user_env_t *env = (rtems_user_env_t*) venv ; if (env != &rtems_global_user_env 108b02: 81 fb 40 63 12 00 cmp $0x126340,%ebx 108b08: 74 26 je 108b30 <== NEVER TAKEN #ifdef HAVE_USERENV_REFCNT && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); 108b0a: 83 ec 0c sub $0xc,%esp 108b0d: 8d 43 04 lea 0x4(%ebx),%eax 108b10: 50 push %eax 108b11: e8 4a ef ff ff call 107a60 rtems_filesystem_freenode( &env->root_directory); 108b16: 8d 43 18 lea 0x18(%ebx),%eax 108b19: 89 04 24 mov %eax,(%esp) 108b1c: e8 3f ef ff ff call 107a60 free(env); 108b21: 83 c4 10 add $0x10,%esp 108b24: 89 5d 08 mov %ebx,0x8(%ebp) } } 108b27: 8b 5d fc mov -0x4(%ebp),%ebx 108b2a: c9 leave && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); rtems_filesystem_freenode( &env->root_directory); free(env); 108b2b: e9 44 ef ff ff jmp 107a74 } } 108b30: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 108b33: c9 leave <== NOT EXECUTED 108b34: c3 ret <== NOT EXECUTED =============================================================================== 0011db2c : int fstat( int fd, struct stat *sbuf ) { 11db2c: 55 push %ebp 11db2d: 89 e5 mov %esp,%ebp 11db2f: 57 push %edi 11db30: 53 push %ebx 11db31: 8b 45 08 mov 0x8(%ebp),%eax 11db34: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_libio_t *iop; /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) 11db37: 85 db test %ebx,%ebx 11db39: 74 55 je 11db90 rtems_set_errno_and_return_minus_one( EFAULT ); /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); 11db3b: 3b 05 ec 21 12 00 cmp 0x1221ec,%eax 11db41: 73 39 jae 11db7c 11db43: c1 e0 03 shl $0x3,%eax 11db46: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx 11db4d: 29 c2 sub %eax,%edx 11db4f: 03 15 80 63 12 00 add 0x126380,%edx rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); 11db55: f6 42 15 01 testb $0x1,0x15(%edx) 11db59: 74 21 je 11db7c <== NEVER TAKEN /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); 11db5b: b9 48 00 00 00 mov $0x48,%ecx 11db60: 31 c0 xor %eax,%eax 11db62: 89 df mov %ebx,%edi 11db64: f3 aa rep stos %al,%es:(%edi) return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf ); 11db66: 8b 42 20 mov 0x20(%edx),%eax 11db69: 89 5d 0c mov %ebx,0xc(%ebp) 11db6c: 83 c2 18 add $0x18,%edx 11db6f: 89 55 08 mov %edx,0x8(%ebp) 11db72: 8b 40 18 mov 0x18(%eax),%eax } 11db75: 5b pop %ebx 11db76: 5f pop %edi 11db77: 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 ); 11db78: ff e0 jmp *%eax 11db7a: 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); 11db7c: e8 5b 42 ff ff call 111ddc <__errno> 11db81: 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 ); } 11db87: b8 ff ff ff ff mov $0xffffffff,%eax 11db8c: 5b pop %ebx 11db8d: 5f pop %edi 11db8e: c9 leave 11db8f: c3 ret /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) rtems_set_errno_and_return_minus_one( EFAULT ); 11db90: e8 47 42 ff ff call 111ddc <__errno> 11db95: c7 00 0e 00 00 00 movl $0xe,(%eax) 11db9b: eb ea jmp 11db87 =============================================================================== 00108494 : #include int fsync( int fd ) { 108494: 55 push %ebp 108495: 89 e5 mov %esp,%ebp 108497: 83 ec 08 sub $0x8,%esp 10849a: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_t *iop; rtems_libio_check_fd( fd ); 10849d: 3b 05 4c 31 12 00 cmp 0x12314c,%eax 1084a3: 73 2f jae 1084d4 iop = rtems_libio_iop( fd ); 1084a5: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx 1084ac: 8d 04 d5 00 00 00 00 lea 0x0(,%edx,8),%eax 1084b3: 29 d0 sub %edx,%eax 1084b5: 03 05 e0 72 12 00 add 0x1272e0,%eax rtems_libio_check_is_open(iop); 1084bb: 8b 50 14 mov 0x14(%eax),%edx 1084be: f6 c6 01 test $0x1,%dh 1084c1: 74 11 je 1084d4 rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 1084c3: 83 e2 04 and $0x4,%edx 1084c6: 74 20 je 1084e8 /* * Now process the fsync(). */ return (*iop->pathinfo.handlers->fsync_h)( iop ); 1084c8: 8b 50 20 mov 0x20(%eax),%edx 1084cb: 89 45 08 mov %eax,0x8(%ebp) 1084ce: 8b 42 28 mov 0x28(%edx),%eax } 1084d1: c9 leave /* * Now process the fsync(). */ return (*iop->pathinfo.handlers->fsync_h)( iop ); 1084d2: ff e0 jmp *%eax { rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 1084d4: e8 f3 a9 00 00 call 112ecc <__errno> 1084d9: c7 00 09 00 00 00 movl $0x9,(%eax) /* * Now process the fsync(). */ return (*iop->pathinfo.handlers->fsync_h)( iop ); } 1084df: b8 ff ff ff ff mov $0xffffffff,%eax 1084e4: c9 leave 1084e5: c3 ret 1084e6: 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 ); 1084e8: e8 df a9 00 00 call 112ecc <__errno> 1084ed: c7 00 16 00 00 00 movl $0x16,(%eax) 1084f3: eb ea jmp 1084df =============================================================================== 0010f0f4 : int ftruncate( int fd, off_t length ) { 10f0f4: 55 push %ebp 10f0f5: 89 e5 mov %esp,%ebp 10f0f7: 57 push %edi 10f0f8: 56 push %esi 10f0f9: 53 push %ebx 10f0fa: 83 ec 3c sub $0x3c,%esp 10f0fd: 8b 45 08 mov 0x8(%ebp),%eax 10f100: 8b 55 0c mov 0xc(%ebp),%edx 10f103: 8b 4d 10 mov 0x10(%ebp),%ecx 10f106: 89 55 c0 mov %edx,-0x40(%ebp) 10f109: 89 4d c4 mov %ecx,-0x3c(%ebp) rtems_libio_t *iop; rtems_filesystem_location_info_t loc; rtems_libio_check_fd( fd ); 10f10c: 3b 05 ec 21 12 00 cmp 0x1221ec,%eax 10f112: 73 58 jae 10f16c iop = rtems_libio_iop( fd ); 10f114: c1 e0 03 shl $0x3,%eax 10f117: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx 10f11e: 29 c3 sub %eax,%ebx 10f120: 03 1d 80 63 12 00 add 0x126380,%ebx rtems_libio_check_is_open(iop); 10f126: f6 43 15 01 testb $0x1,0x15(%ebx) 10f12a: 74 40 je 10f16c /* * Make sure we are not working on a directory */ loc = iop->pathinfo; 10f12c: 8d 7d d4 lea -0x2c(%ebp),%edi 10f12f: 8d 73 18 lea 0x18(%ebx),%esi 10f132: b9 05 00 00 00 mov $0x5,%ecx 10f137: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) 10f139: 83 ec 0c sub $0xc,%esp 10f13c: 8d 45 d4 lea -0x2c(%ebp),%eax 10f13f: 50 push %eax 10f140: 8b 45 e0 mov -0x20(%ebp),%eax 10f143: ff 50 10 call *0x10(%eax) 10f146: 83 c4 10 add $0x10,%esp 10f149: 48 dec %eax 10f14a: 74 46 je 10f192 rtems_set_errno_and_return_minus_one( EISDIR ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 10f14c: f6 43 14 04 testb $0x4,0x14(%ebx) 10f150: 74 2e je 10f180 return (*iop->pathinfo.handlers->ftruncate_h)( iop, length ); 10f152: 50 push %eax 10f153: 8b 43 20 mov 0x20(%ebx),%eax 10f156: ff 75 c4 pushl -0x3c(%ebp) 10f159: ff 75 c0 pushl -0x40(%ebp) 10f15c: 53 push %ebx 10f15d: ff 50 20 call *0x20(%eax) 10f160: 83 c4 10 add $0x10,%esp } 10f163: 8d 65 f4 lea -0xc(%ebp),%esp 10f166: 5b pop %ebx 10f167: 5e pop %esi 10f168: 5f pop %edi 10f169: c9 leave 10f16a: c3 ret 10f16b: 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); 10f16c: e8 6b 2c 00 00 call 111ddc <__errno> 10f171: c7 00 09 00 00 00 movl $0x9,(%eax) 10f177: b8 ff ff ff ff mov $0xffffffff,%eax 10f17c: eb e5 jmp 10f163 10f17e: 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 ); 10f180: e8 57 2c 00 00 call 111ddc <__errno> 10f185: c7 00 16 00 00 00 movl $0x16,(%eax) 10f18b: b8 ff ff ff ff mov $0xffffffff,%eax 10f190: eb d1 jmp 10f163 * 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 ); 10f192: e8 45 2c 00 00 call 111ddc <__errno> 10f197: c7 00 15 00 00 00 movl $0x15,(%eax) 10f19d: b8 ff ff ff ff mov $0xffffffff,%eax 10f1a2: eb bf jmp 10f163 =============================================================================== 00107880 : #include #include int getchark(void) { 107880: 55 push %ebp 107881: 89 e5 mov %esp,%ebp 107883: 83 ec 08 sub $0x8,%esp if ( BSP_poll_char ) 107886: a1 8c 26 12 00 mov 0x12268c,%eax 10788b: 85 c0 test %eax,%eax 10788d: 74 05 je 107894 return (*BSP_poll_char)(); return -1; } 10788f: c9 leave #include int getchark(void) { if ( BSP_poll_char ) return (*BSP_poll_char)(); 107890: ff e0 jmp *%eax 107892: 66 90 xchg %ax,%ax return -1; } 107894: b8 ff ff ff ff mov $0xffffffff,%eax 107899: c9 leave 10789a: c3 ret =============================================================================== 0011f4a0 : int getdents( int dd_fd, char *dd_buf, int dd_len ) { 11f4a0: 55 push %ebp 11f4a1: 89 e5 mov %esp,%ebp 11f4a3: 57 push %edi 11f4a4: 56 push %esi 11f4a5: 53 push %ebx 11f4a6: 83 ec 2c sub $0x2c,%esp 11f4a9: 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 ); 11f4ac: 3b 05 4c 41 12 00 cmp 0x12414c,%eax 11f4b2: 73 4c jae 11f500 <== NEVER TAKEN 11f4b4: c1 e0 03 shl $0x3,%eax 11f4b7: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx 11f4be: 29 c3 sub %eax,%ebx 11f4c0: 03 1d 00 84 12 00 add 0x128400,%ebx /* * Make sure we are working on a directory */ loc = iop->pathinfo; 11f4c6: 8d 7d d4 lea -0x2c(%ebp),%edi 11f4c9: 8d 73 18 lea 0x18(%ebx),%esi 11f4cc: b9 05 00 00 00 mov $0x5,%ecx 11f4d1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) 11f4d3: 83 ec 0c sub $0xc,%esp 11f4d6: 8d 45 d4 lea -0x2c(%ebp),%eax 11f4d9: 50 push %eax 11f4da: 8b 45 e0 mov -0x20(%ebp),%eax 11f4dd: ff 50 10 call *0x10(%eax) 11f4e0: 83 c4 10 add $0x10,%esp 11f4e3: 48 dec %eax 11f4e4: 75 1e jne 11f504 /* * 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 ); 11f4e6: 50 push %eax 11f4e7: 8b 43 20 mov 0x20(%ebx),%eax 11f4ea: ff 75 10 pushl 0x10(%ebp) 11f4ed: ff 75 0c pushl 0xc(%ebp) 11f4f0: 53 push %ebx 11f4f1: ff 50 08 call *0x8(%eax) 11f4f4: 83 c4 10 add $0x10,%esp } 11f4f7: 8d 65 f4 lea -0xc(%ebp),%esp 11f4fa: 5b pop %ebx 11f4fb: 5e pop %esi 11f4fc: 5f pop %edi 11f4fd: c9 leave 11f4fe: c3 ret 11f4ff: 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 ); 11f500: 31 db xor %ebx,%ebx 11f502: eb c2 jmp 11f4c6 <== 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 ); 11f504: e8 a3 38 ff ff call 112dac <__errno> 11f509: c7 00 14 00 00 00 movl $0x14,(%eax) 11f50f: b8 ff ff ff ff mov $0xffffffff,%eax 11f514: eb e1 jmp 11f4f7 =============================================================================== 001080b4 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 1080b4: 55 push %ebp 1080b5: 89 e5 mov %esp,%ebp 1080b7: 57 push %edi 1080b8: 56 push %esi 1080b9: 53 push %ebx 1080ba: 83 ec 1c sub $0x1c,%esp 1080bd: 89 c3 mov %eax,%ebx 1080bf: 89 55 e4 mov %edx,-0x1c(%ebp) 1080c2: 89 ce mov %ecx,%esi FILE *fp; int match; init_etc_passwd_group(); 1080c4: e8 eb fe ff ff call 107fb4 if ((fp = fopen("/etc/group", "r")) == NULL) 1080c9: 83 ec 08 sub $0x8,%esp 1080cc: 68 d2 02 12 00 push $0x1202d2 1080d1: 68 99 16 12 00 push $0x121699 1080d6: e8 6d b3 00 00 call 113448 1080db: 89 c7 mov %eax,%edi 1080dd: 83 c4 10 add $0x10,%esp 1080e0: 85 c0 test %eax,%eax 1080e2: 75 22 jne 108106 1080e4: e9 8b 00 00 00 jmp 108174 1080e9: 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); 1080ec: 83 ec 08 sub $0x8,%esp 1080ef: 53 push %ebx 1080f0: ff 36 pushl (%esi) 1080f2: e8 c5 c1 00 00 call 1142bc 1080f7: 83 c4 10 add $0x10,%esp 1080fa: 85 c0 test %eax,%eax 1080fc: 0f 94 c0 sete %al 1080ff: 0f b6 c0 movzbl %al,%eax } else { match = (grp->gr_gid == gid); } if (match) { 108102: 85 c0 test %eax,%eax 108104: 75 2e jne 108134 if ((fp = fopen("/etc/group", "r")) == NULL) rtems_set_errno_and_return_minus_one( EINVAL ); for(;;) { if (!scangr(fp, grp, buffer, bufsize)) 108106: 83 ec 0c sub $0xc,%esp 108109: ff 75 0c pushl 0xc(%ebp) 10810c: 8b 4d 08 mov 0x8(%ebp),%ecx 10810f: 89 f2 mov %esi,%edx 108111: 89 f8 mov %edi,%eax 108113: e8 88 fc ff ff call 107da0 108118: 83 c4 10 add $0x10,%esp 10811b: 85 c0 test %eax,%eax 10811d: 74 31 je 108150 goto error_einval; if (name) { 10811f: 85 db test %ebx,%ebx 108121: 75 c9 jne 1080ec match = (strcmp(grp->gr_name, name) == 0); } else { match = (grp->gr_gid == gid); 108123: 0f b7 46 08 movzwl 0x8(%esi),%eax 108127: 3b 45 e4 cmp -0x1c(%ebp),%eax 10812a: 0f 94 c0 sete %al 10812d: 0f b6 c0 movzbl %al,%eax } if (match) { 108130: 85 c0 test %eax,%eax 108132: 74 d2 je 108106 fclose(fp); 108134: 83 ec 0c sub $0xc,%esp 108137: 57 push %edi 108138: e8 07 ac 00 00 call 112d44 *result = grp; 10813d: 8b 45 10 mov 0x10(%ebp),%eax 108140: 89 30 mov %esi,(%eax) return 0; 108142: 83 c4 10 add $0x10,%esp 108145: 31 c0 xor %eax,%eax } } error_einval: fclose(fp); rtems_set_errno_and_return_minus_one( EINVAL ); } 108147: 8d 65 f4 lea -0xc(%ebp),%esp 10814a: 5b pop %ebx 10814b: 5e pop %esi 10814c: 5f pop %edi 10814d: c9 leave 10814e: c3 ret 10814f: 90 nop *result = grp; return 0; } } error_einval: fclose(fp); 108150: 83 ec 0c sub $0xc,%esp 108153: 57 push %edi 108154: e8 eb ab 00 00 call 112d44 rtems_set_errno_and_return_minus_one( EINVAL ); 108159: e8 8e aa 00 00 call 112bec <__errno> 10815e: c7 00 16 00 00 00 movl $0x16,(%eax) 108164: 83 c4 10 add $0x10,%esp 108167: b8 ff ff ff ff mov $0xffffffff,%eax } 10816c: 8d 65 f4 lea -0xc(%ebp),%esp 10816f: 5b pop %ebx 108170: 5e pop %esi 108171: 5f pop %edi 108172: c9 leave 108173: c3 ret int match; init_etc_passwd_group(); if ((fp = fopen("/etc/group", "r")) == NULL) rtems_set_errno_and_return_minus_one( EINVAL ); 108174: e8 73 aa 00 00 call 112bec <__errno> 108179: c7 00 16 00 00 00 movl $0x16,(%eax) 10817f: 83 c8 ff or $0xffffffff,%eax 108182: eb c3 jmp 108147 =============================================================================== 001083d8 : } struct group *getgrnam( const char *name ) { 1083d8: 55 push %ebp 1083d9: 89 e5 mov %esp,%ebp 1083db: 83 ec 24 sub $0x24,%esp struct group *p; if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p)) 1083de: 8d 45 f4 lea -0xc(%ebp),%eax 1083e1: 50 push %eax 1083e2: 68 c8 00 00 00 push $0xc8 1083e7: 68 c0 6f 12 00 push $0x126fc0 1083ec: 68 a4 6f 12 00 push $0x126fa4 1083f1: ff 75 08 pushl 0x8(%ebp) 1083f4: e8 b3 ff ff ff call 1083ac 1083f9: 83 c4 20 add $0x20,%esp 1083fc: 85 c0 test %eax,%eax 1083fe: 75 08 jne 108408 return NULL; return p; 108400: 8b 45 f4 mov -0xc(%ebp),%eax } 108403: c9 leave 108404: c3 ret 108405: 8d 76 00 lea 0x0(%esi),%esi ) { struct group *p; if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p)) return NULL; 108408: 31 c0 xor %eax,%eax return p; } 10840a: c9 leave 10840b: c3 ret =============================================================================== 00107b78 : */ int getlogin_r( char *name, size_t namesize ) { 107b78: 55 push %ebp 107b79: 89 e5 mov %esp,%ebp 107b7b: 53 push %ebx 107b7c: 83 ec 04 sub $0x4,%esp 107b7f: 8b 5d 08 mov 0x8(%ebp),%ebx struct passwd *pw; char *pname; if ( !name ) 107b82: 85 db test %ebx,%ebx 107b84: 74 42 je 107bc8 return EFAULT; if ( namesize < LOGIN_NAME_MAX ) 107b86: 83 7d 0c 08 cmpl $0x8,0xc(%ebp) 107b8a: 77 0c ja 107b98 return ERANGE; 107b8c: b8 22 00 00 00 mov $0x22,%eax if ( pw ) pname = pw->pw_name; strncpy( name, pname, LOGIN_NAME_MAX ); return 0; } 107b91: 8b 5d fc mov -0x4(%ebp),%ebx 107b94: c9 leave 107b95: c3 ret 107b96: 66 90 xchg %ax,%ax return ERANGE; /* Set the pointer to a default name */ pname = ""; pw = getpwuid(getuid()); 107b98: e8 e7 09 00 00 call 108584 107b9d: 83 ec 0c sub $0xc,%esp 107ba0: 0f b7 c0 movzwl %ax,%eax 107ba3: 50 push %eax 107ba4: e8 37 07 00 00 call 1082e0 if ( pw ) 107ba9: 83 c4 10 add $0x10,%esp 107bac: 85 c0 test %eax,%eax 107bae: 74 20 je 107bd0 pname = pw->pw_name; 107bb0: 8b 00 mov (%eax),%eax strncpy( name, pname, LOGIN_NAME_MAX ); 107bb2: 52 push %edx 107bb3: 6a 09 push $0x9 107bb5: 50 push %eax 107bb6: 53 push %ebx 107bb7: e8 80 c8 00 00 call 11443c return 0; 107bbc: 83 c4 10 add $0x10,%esp 107bbf: 31 c0 xor %eax,%eax } 107bc1: 8b 5d fc mov -0x4(%ebp),%ebx 107bc4: c9 leave 107bc5: c3 ret 107bc6: 66 90 xchg %ax,%ax { struct passwd *pw; char *pname; if ( !name ) return EFAULT; 107bc8: b8 0e 00 00 00 mov $0xe,%eax 107bcd: eb c2 jmp 107b91 107bcf: 90 nop if ( namesize < LOGIN_NAME_MAX ) return ERANGE; /* Set the pointer to a default name */ pname = ""; 107bd0: b8 e9 17 12 00 mov $0x1217e9,%eax 107bd5: eb db jmp 107bb2 =============================================================================== 00108184 : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 108184: 55 push %ebp 108185: 89 e5 mov %esp,%ebp 108187: 57 push %edi 108188: 56 push %esi 108189: 53 push %ebx 10818a: 83 ec 1c sub $0x1c,%esp 10818d: 89 c3 mov %eax,%ebx 10818f: 89 55 e4 mov %edx,-0x1c(%ebp) 108192: 89 ce mov %ecx,%esi FILE *fp; int match; init_etc_passwd_group(); 108194: e8 1b fe ff ff call 107fb4 if ((fp = fopen("/etc/passwd", "r")) == NULL) 108199: 83 ec 08 sub $0x8,%esp 10819c: 68 d2 02 12 00 push $0x1202d2 1081a1: 68 8d 16 12 00 push $0x12168d 1081a6: e8 9d b2 00 00 call 113448 1081ab: 89 c7 mov %eax,%edi 1081ad: 83 c4 10 add $0x10,%esp 1081b0: 85 c0 test %eax,%eax 1081b2: 75 22 jne 1081d6 1081b4: e9 8b 00 00 00 jmp 108244 1081b9: 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); 1081bc: 83 ec 08 sub $0x8,%esp 1081bf: 53 push %ebx 1081c0: ff 36 pushl (%esi) 1081c2: e8 f5 c0 00 00 call 1142bc 1081c7: 83 c4 10 add $0x10,%esp 1081ca: 85 c0 test %eax,%eax 1081cc: 0f 94 c0 sete %al 1081cf: 0f b6 c0 movzbl %al,%eax } else { match = (pwd->pw_uid == uid); } if (match) { 1081d2: 85 c0 test %eax,%eax 1081d4: 75 2e jne 108204 if ((fp = fopen("/etc/passwd", "r")) == NULL) rtems_set_errno_and_return_minus_one( EINVAL ); for(;;) { if (!scanpw(fp, pwd, buffer, bufsize)) 1081d6: 83 ec 0c sub $0xc,%esp 1081d9: ff 75 0c pushl 0xc(%ebp) 1081dc: 8b 4d 08 mov 0x8(%ebp),%ecx 1081df: 89 f2 mov %esi,%edx 1081e1: 89 f8 mov %edi,%eax 1081e3: e8 d0 fc ff ff call 107eb8 1081e8: 83 c4 10 add $0x10,%esp 1081eb: 85 c0 test %eax,%eax 1081ed: 74 31 je 108220 goto error_einval; if (name) { 1081ef: 85 db test %ebx,%ebx 1081f1: 75 c9 jne 1081bc match = (strcmp(pwd->pw_name, name) == 0); } else { match = (pwd->pw_uid == uid); 1081f3: 0f b7 46 08 movzwl 0x8(%esi),%eax 1081f7: 3b 45 e4 cmp -0x1c(%ebp),%eax 1081fa: 0f 94 c0 sete %al 1081fd: 0f b6 c0 movzbl %al,%eax } if (match) { 108200: 85 c0 test %eax,%eax 108202: 74 d2 je 1081d6 fclose(fp); 108204: 83 ec 0c sub $0xc,%esp 108207: 57 push %edi 108208: e8 37 ab 00 00 call 112d44 *result = pwd; 10820d: 8b 45 10 mov 0x10(%ebp),%eax 108210: 89 30 mov %esi,(%eax) return 0; 108212: 83 c4 10 add $0x10,%esp 108215: 31 c0 xor %eax,%eax } } error_einval: fclose(fp); rtems_set_errno_and_return_minus_one( EINVAL ); } 108217: 8d 65 f4 lea -0xc(%ebp),%esp 10821a: 5b pop %ebx 10821b: 5e pop %esi 10821c: 5f pop %edi 10821d: c9 leave 10821e: c3 ret 10821f: 90 nop *result = pwd; return 0; } } error_einval: fclose(fp); 108220: 83 ec 0c sub $0xc,%esp 108223: 57 push %edi 108224: e8 1b ab 00 00 call 112d44 rtems_set_errno_and_return_minus_one( EINVAL ); 108229: e8 be a9 00 00 call 112bec <__errno> 10822e: c7 00 16 00 00 00 movl $0x16,(%eax) 108234: 83 c4 10 add $0x10,%esp 108237: b8 ff ff ff ff mov $0xffffffff,%eax } 10823c: 8d 65 f4 lea -0xc(%ebp),%esp 10823f: 5b pop %ebx 108240: 5e pop %esi 108241: 5f pop %edi 108242: c9 leave 108243: c3 ret int match; init_etc_passwd_group(); if ((fp = fopen("/etc/passwd", "r")) == NULL) rtems_set_errno_and_return_minus_one( EINVAL ); 108244: e8 a3 a9 00 00 call 112bec <__errno> 108249: c7 00 16 00 00 00 movl $0x16,(%eax) 10824f: 83 c8 ff or $0xffffffff,%eax 108252: eb c3 jmp 108217 =============================================================================== 00108280 : } struct passwd *getpwnam( const char *name ) { 108280: 55 push %ebp 108281: 89 e5 mov %esp,%ebp 108283: 83 ec 24 sub $0x24,%esp struct passwd *p; if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p)) 108286: 8d 45 f4 lea -0xc(%ebp),%eax 108289: 50 push %eax 10828a: 68 c8 00 00 00 push $0xc8 10828f: 68 c0 70 12 00 push $0x1270c0 108294: 68 8c 70 12 00 push $0x12708c 108299: ff 75 08 pushl 0x8(%ebp) 10829c: e8 b3 ff ff ff call 108254 1082a1: 83 c4 20 add $0x20,%esp 1082a4: 85 c0 test %eax,%eax 1082a6: 75 08 jne 1082b0 return NULL; return p; 1082a8: 8b 45 f4 mov -0xc(%ebp),%eax } 1082ab: c9 leave 1082ac: c3 ret 1082ad: 8d 76 00 lea 0x0(%esi),%esi ) { struct passwd *p; if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p)) return NULL; 1082b0: 31 c0 xor %eax,%eax return p; } 1082b2: c9 leave 1082b3: c3 ret =============================================================================== 001076b0 : */ int gettimeofday( struct timeval *tp, void * __tz __attribute__((unused)) ) { 1076b0: 55 push %ebp 1076b1: 89 e5 mov %esp,%ebp 1076b3: 56 push %esi 1076b4: 53 push %ebx 1076b5: 83 ec 10 sub $0x10,%esp 1076b8: 8b 5d 08 mov 0x8(%ebp),%ebx /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) 1076bb: 85 db test %ebx,%ebx 1076bd: 74 39 je 1076f8 <== NEVER TAKEN { ISR_Level level; struct timespec now; suseconds_t useconds; _ISR_Disable(level); 1076bf: 9c pushf 1076c0: fa cli 1076c1: 5e pop %esi _TOD_Get( &now ); 1076c2: 83 ec 0c sub $0xc,%esp 1076c5: 8d 45 f0 lea -0x10(%ebp),%eax 1076c8: 50 push %eax 1076c9: e8 32 41 00 00 call 10b800 <_TOD_Get> _ISR_Enable(level); 1076ce: 56 push %esi 1076cf: 9d popf useconds = (suseconds_t)now.tv_nsec; 1076d0: 8b 4d f4 mov -0xc(%ebp),%ecx useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND; time->tv_sec = now.tv_sec; 1076d3: 8b 45 f0 mov -0x10(%ebp),%eax 1076d6: 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; 1076d8: b8 d3 4d 62 10 mov $0x10624dd3,%eax 1076dd: f7 e9 imul %ecx 1076df: 89 d0 mov %edx,%eax 1076e1: c1 f8 06 sar $0x6,%eax 1076e4: c1 f9 1f sar $0x1f,%ecx 1076e7: 29 c8 sub %ecx,%eax 1076e9: 89 43 04 mov %eax,0x4(%ebx) * Timezone information ignored by the OS proper. Per email * with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X * do it. This puts us in good company. */ return 0; 1076ec: 83 c4 10 add $0x10,%esp 1076ef: 31 c0 xor %eax,%eax } 1076f1: 8d 65 f8 lea -0x8(%ebp),%esp 1076f4: 5b pop %ebx 1076f5: 5e pop %esi 1076f6: c9 leave 1076f7: c3 ret void * __tz __attribute__((unused)) ) { /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) rtems_set_errno_and_return_minus_one( EFAULT ); 1076f8: e8 df a6 00 00 call 111ddc <__errno> <== NOT EXECUTED 1076fd: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 107703: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 107708: eb e7 jmp 1076f1 <== NOT EXECUTED =============================================================================== 001115b4 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 1115b4: 55 push %ebp 1115b5: 89 e5 mov %esp,%ebp 1115b7: 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 ) 1115ba: 8b 50 18 mov 0x18(%eax),%edx 1115bd: 83 7a 4c 01 cmpl $0x1,0x4c(%edx) 1115c1: 74 09 je 1115cc <== ALWAYS TAKEN return -1; /* It wasn't a directory --> return error */ 1115c3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED iop->offset = 0; return 0; } 1115c8: c9 leave <== NOT EXECUTED 1115c9: c3 ret <== NOT EXECUTED 1115ca: 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; 1115cc: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) 1115d3: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) return 0; 1115da: 31 c0 xor %eax,%eax } 1115dc: c9 leave 1115dd: c3 ret =============================================================================== 001115e0 : ssize_t imfs_dir_read( rtems_libio_t *iop, void *buffer, size_t count ) { 1115e0: 55 push %ebp 1115e1: 89 e5 mov %esp,%ebp 1115e3: 57 push %edi 1115e4: 56 push %esi 1115e5: 53 push %ebx 1115e6: 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; 1115ec: 8b 55 08 mov 0x8(%ebp),%edx 1115ef: 8b 42 18 mov 0x18(%edx),%eax IMFS_create_orphan( the_jnode ); IMFS_check_node_remove( the_jnode ); return 0; } 1115f2: 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 ); 1115f5: 83 c0 54 add $0x54,%eax 1115f8: 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 ) ) 1115fe: 39 c3 cmp %eax,%ebx 111600: 0f 84 2a 01 00 00 je 111730 /* Move to the first of the desired directory entries */ the_node = rtems_chain_first( the_chain ); bytes_transferred = 0; first_entry = iop->offset; 111606: 8b 42 0c mov 0xc(%edx),%eax 111609: 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); 11160f: ba f1 f0 f0 f0 mov $0xf0f0f0f1,%edx 111614: 8b 45 10 mov 0x10(%ebp),%eax 111617: f7 e2 mul %edx 111619: c1 ea 08 shr $0x8,%edx 11161c: 89 d0 mov %edx,%eax 11161e: c1 e0 04 shl $0x4,%eax 111621: c1 e2 08 shl $0x8,%edx 111624: 8d 14 10 lea (%eax,%edx,1),%edx 111627: 03 95 d4 fe ff ff add -0x12c(%ebp),%edx 11162d: 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 ( 111633: 85 d2 test %edx,%edx 111635: 0f 8e f5 00 00 00 jle 111730 <== NEVER TAKEN 11163b: 31 d2 xor %edx,%edx 11163d: c7 85 c8 fe ff ff 00 movl $0x0,-0x138(%ebp) 111644: 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 ); 111647: 8d 85 d8 fe ff ff lea -0x128(%ebp),%eax 11164d: 89 85 b4 fe ff ff mov %eax,-0x14c(%ebp) 111653: eb 23 jmp 111678 111655: 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; 111658: 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( 11165a: 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 ( 111660: 39 95 d0 fe ff ff cmp %edx,-0x130(%ebp) 111666: 0f 8e b4 00 00 00 jle 111720 <== 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 ) ){ 11166c: 3b 9d cc fe ff ff cmp -0x134(%ebp),%ebx 111672: 0f 84 a8 00 00 00 je 111720 /* entry in the read */ return bytes_transferred; /* Indicate that there are no more */ /* entries to return */ } if( current_entry >= first_entry ) { 111678: 39 95 d4 fe ff ff cmp %edx,-0x12c(%ebp) 11167e: 7f d8 jg 111658 /* Move the entry to the return buffer */ tmp_dirent.d_off = current_entry; 111680: 89 95 dc fe ff ff mov %edx,-0x124(%ebp) 111686: 89 d0 mov %edx,%eax 111688: c1 f8 1f sar $0x1f,%eax 11168b: 89 85 e0 fe ff ff mov %eax,-0x120(%ebp) tmp_dirent.d_reclen = sizeof( struct dirent ); 111691: 66 c7 85 e4 fe ff ff movw $0x110,-0x11c(%ebp) 111698: 10 01 the_jnode = (IMFS_jnode_t *) the_node; tmp_dirent.d_ino = the_jnode->st_ino; 11169a: 8b 43 38 mov 0x38(%ebx),%eax 11169d: 89 85 d8 fe ff ff mov %eax,-0x128(%ebp) tmp_dirent.d_namlen = strlen( the_jnode->name ); 1116a3: 8d 73 0c lea 0xc(%ebx),%esi 1116a6: 31 c0 xor %eax,%eax 1116a8: b9 ff ff ff ff mov $0xffffffff,%ecx 1116ad: 89 f7 mov %esi,%edi 1116af: f2 ae repnz scas %es:(%edi),%al 1116b1: f7 d1 not %ecx 1116b3: 49 dec %ecx 1116b4: 66 89 8d e6 fe ff ff mov %cx,-0x11a(%ebp) strcpy( tmp_dirent.d_name, the_jnode->name ); 1116bb: 83 ec 08 sub $0x8,%esp 1116be: 56 push %esi 1116bf: 8d 85 e8 fe ff ff lea -0x118(%ebp),%eax 1116c5: 50 push %eax 1116c6: 89 95 c4 fe ff ff mov %edx,-0x13c(%ebp) 1116cc: e8 d3 13 00 00 call 112aa4 memcpy( 1116d1: 8b 45 0c mov 0xc(%ebp),%eax 1116d4: 03 85 c8 fe ff ff add -0x138(%ebp),%eax 1116da: b9 44 00 00 00 mov $0x44,%ecx 1116df: 89 c7 mov %eax,%edi 1116e1: 8b b5 b4 fe ff ff mov -0x14c(%ebp),%esi 1116e7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) buffer + bytes_transferred, (void *)&tmp_dirent, sizeof( struct dirent ) ); iop->offset = iop->offset + sizeof(struct dirent); 1116e9: 8b 45 08 mov 0x8(%ebp),%eax 1116ec: 81 40 0c 10 01 00 00 addl $0x110,0xc(%eax) 1116f3: 83 50 10 00 adcl $0x0,0x10(%eax) bytes_transferred = bytes_transferred + sizeof( struct dirent ); 1116f7: 81 85 c8 fe ff ff 10 addl $0x110,-0x138(%ebp) 1116fe: 01 00 00 111701: 83 c4 10 add $0x10,%esp 111704: 8b 95 c4 fe ff ff mov -0x13c(%ebp),%edx } the_node = the_node->next; 11170a: 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( 11170c: 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 ( 111712: 39 95 d0 fe ff ff cmp %edx,-0x130(%ebp) 111718: 0f 8f 4e ff ff ff jg 11166c <== NEVER TAKEN 11171e: 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 ) ){ 111720: 8b 85 c8 fe ff ff mov -0x138(%ebp),%eax the_node = the_node->next; } /* Success */ return bytes_transferred; } 111726: 8d 65 f4 lea -0xc(%ebp),%esp 111729: 5b pop %ebx 11172a: 5e pop %esi 11172b: 5f pop %edi 11172c: c9 leave 11172d: c3 ret 11172e: 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; 111730: 31 c0 xor %eax,%eax the_node = the_node->next; } /* Success */ return bytes_transferred; } 111732: 8d 65 f4 lea -0xc(%ebp),%esp 111735: 5b pop %ebx 111736: 5e pop %esi 111737: 5f pop %edi 111738: c9 leave 111739: c3 ret =============================================================================== 0011186c : int imfs_dir_rmnod( rtems_filesystem_location_info_t *parent_pathloc, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN */ ) { 11186c: 55 push %ebp 11186d: 89 e5 mov %esp,%ebp 11186f: 53 push %ebx 111870: 83 ec 04 sub $0x4,%esp 111873: 8b 45 0c mov 0xc(%ebp),%eax IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 111876: 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 ); 111878: 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 ) ) 11187b: 39 53 50 cmp %edx,0x50(%ebx) 11187e: 75 44 jne 1118c4 /* * You cannot remove the file system root node. */ if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access ) 111880: 8b 40 10 mov 0x10(%eax),%eax 111883: 3b 58 1c cmp 0x1c(%eax),%ebx 111886: 74 24 je 1118ac /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) 111888: 8b 4b 5c mov 0x5c(%ebx),%ecx 11188b: 85 c9 test %ecx,%ecx 11188d: 75 1d jne 1118ac <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EBUSY ); IMFS_create_orphan( the_jnode ); 11188f: 83 ec 0c sub $0xc,%esp 111892: 53 push %ebx 111893: e8 bc d5 ff ff call 10ee54 IMFS_check_node_remove( the_jnode ); 111898: 89 1c 24 mov %ebx,(%esp) 11189b: e8 f8 d5 ff ff call 10ee98 return 0; 1118a0: 83 c4 10 add $0x10,%esp 1118a3: 31 c0 xor %eax,%eax } 1118a5: 8b 5d fc mov -0x4(%ebp),%ebx 1118a8: c9 leave 1118a9: c3 ret 1118aa: 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 ); 1118ac: e8 2b 05 00 00 call 111ddc <__errno> 1118b1: c7 00 10 00 00 00 movl $0x10,(%eax) 1118b7: b8 ff ff ff ff mov $0xffffffff,%eax IMFS_create_orphan( the_jnode ); IMFS_check_node_remove( the_jnode ); return 0; } 1118bc: 8b 5d fc mov -0x4(%ebp),%ebx 1118bf: c9 leave 1118c0: c3 ret 1118c1: 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 ); 1118c4: e8 13 05 00 00 call 111ddc <__errno> 1118c9: c7 00 5a 00 00 00 movl $0x5a,(%eax) 1118cf: b8 ff ff ff ff mov $0xffffffff,%eax 1118d4: eb cf jmp 1118a5 =============================================================================== 00107fb4 : /* * Initialize useable but dummy databases */ void init_etc_passwd_group(void) { 107fb4: 55 push %ebp 107fb5: 89 e5 mov %esp,%ebp 107fb7: 53 push %ebx 107fb8: 83 ec 04 sub $0x4,%esp FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) 107fbb: 80 3d 88 71 12 00 00 cmpb $0x0,0x127188 107fc2: 74 08 je 107fcc fprintf( fp, "root:x:0:root\n" "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); } } 107fc4: 8b 5d fc mov -0x4(%ebp),%ebx 107fc7: c9 leave 107fc8: c3 ret 107fc9: 8d 76 00 lea 0x0(%esi),%esi FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) return; etc_passwd_initted = 1; 107fcc: c6 05 88 71 12 00 01 movb $0x1,0x127188 mkdir("/etc", 0777); 107fd3: 83 ec 08 sub $0x8,%esp 107fd6: 68 ff 01 00 00 push $0x1ff 107fdb: 68 88 16 12 00 push $0x121688 107fe0: e8 37 08 00 00 call 10881c /* * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { 107fe5: 59 pop %ecx 107fe6: 5b pop %ebx 107fe7: 68 d2 02 12 00 push $0x1202d2 107fec: 68 8d 16 12 00 push $0x12168d 107ff1: e8 52 b4 00 00 call 113448 107ff6: 83 c4 10 add $0x10,%esp 107ff9: 85 c0 test %eax,%eax 107ffb: 74 77 je 108074 fclose(fp); 107ffd: 83 ec 0c sub $0xc,%esp 108000: 50 push %eax 108001: e8 3e ad 00 00 call 112d44 108006: 83 c4 10 add $0x10,%esp } /* * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { 108009: 83 ec 08 sub $0x8,%esp 10800c: 68 d2 02 12 00 push $0x1202d2 108011: 68 99 16 12 00 push $0x121699 108016: e8 2d b4 00 00 call 113448 10801b: 83 c4 10 add $0x10,%esp 10801e: 85 c0 test %eax,%eax 108020: 74 12 je 108034 fclose(fp); 108022: 83 ec 0c sub $0xc,%esp 108025: 50 push %eax 108026: e8 19 ad 00 00 call 112d44 10802b: 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); } } 10802e: 8b 5d fc mov -0x4(%ebp),%ebx 108031: c9 leave 108032: c3 ret 108033: 90 nop * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { fclose(fp); } else if ((fp = fopen("/etc/group", "w")) != NULL) { 108034: 83 ec 08 sub $0x8,%esp 108037: 68 b4 01 12 00 push $0x1201b4 10803c: 68 99 16 12 00 push $0x121699 108041: e8 02 b4 00 00 call 113448 108046: 89 c3 mov %eax,%ebx 108048: 83 c4 10 add $0x10,%esp 10804b: 85 c0 test %eax,%eax 10804d: 0f 84 71 ff ff ff je 107fc4 <== NEVER TAKEN fprintf( fp, "root:x:0:root\n" 108053: 50 push %eax 108054: 6a 2a push $0x2a 108056: 6a 01 push $0x1 108058: 68 0c 17 12 00 push $0x12170c 10805d: e8 ba bb 00 00 call 113c1c "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); 108062: 89 1c 24 mov %ebx,(%esp) 108065: e8 da ac 00 00 call 112d44 10806a: 83 c4 10 add $0x10,%esp 10806d: e9 52 ff ff ff jmp 107fc4 108072: 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) { 108074: 83 ec 08 sub $0x8,%esp 108077: 68 b4 01 12 00 push $0x1201b4 10807c: 68 8d 16 12 00 push $0x12168d 108081: e8 c2 b3 00 00 call 113448 108086: 89 c3 mov %eax,%ebx 108088: 83 c4 10 add $0x10,%esp 10808b: 85 c0 test %eax,%eax 10808d: 0f 84 76 ff ff ff je 108009 <== NEVER TAKEN fprintf(fp, "root:*:0:0:root::/:/bin/sh\n" 108093: 50 push %eax 108094: 6a 66 push $0x66 108096: 6a 01 push $0x1 108098: 68 a4 16 12 00 push $0x1216a4 10809d: e8 7a bb 00 00 call 113c1c "rtems:*:1:1:RTEMS Application::/:/bin/sh\n" "tty:!:2:2:tty owner::/:/bin/false\n" ); fclose(fp); 1080a2: 89 1c 24 mov %ebx,(%esp) 1080a5: e8 9a ac 00 00 call 112d44 1080aa: 83 c4 10 add $0x10,%esp 1080ad: e9 57 ff ff ff jmp 108009 =============================================================================== 00109514 : /* * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) { 109514: 55 push %ebp 109515: 89 e5 mov %esp,%ebp 109517: 56 push %esi 109518: 53 push %ebx 109519: 89 d6 mov %edx,%esi 10951b: 88 c3 mov %al,%bl if (tty->termios.c_iflag & ISTRIP) 10951d: 8b 42 30 mov 0x30(%edx),%eax 109520: a8 20 test $0x20,%al 109522: 74 03 je 109527 <== ALWAYS TAKEN c &= 0x7f; 109524: 83 e3 7f and $0x7f,%ebx <== NOT EXECUTED if (tty->termios.c_iflag & IUCLC) 109527: f6 c4 02 test $0x2,%ah 10952a: 74 18 je 109544 c = tolower (c); 10952c: 0f b6 db movzbl %bl,%ebx 10952f: 8b 15 54 42 12 00 mov 0x124254,%edx 109535: 0f be 54 1a 01 movsbl 0x1(%edx,%ebx,1),%edx 10953a: 83 e2 03 and $0x3,%edx 10953d: 4a dec %edx 10953e: 0f 84 9c 00 00 00 je 1095e0 if (c == '\r') { 109544: 80 fb 0d cmp $0xd,%bl 109547: 74 33 je 10957c 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)) { 109549: 80 fb 0a cmp $0xa,%bl 10954c: 0f 84 86 00 00 00 je 1095d8 c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 109552: 84 db test %bl,%bl 109554: 75 3a jne 109590 <== ALWAYS TAKEN } /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { 109556: 8b 46 20 mov 0x20(%esi),%eax 109559: 8b 15 a0 41 12 00 mov 0x1241a0,%edx 10955f: 4a dec %edx 109560: 39 d0 cmp %edx,%eax 109562: 7d 1c jge 109580 <== NEVER TAKEN if (tty->termios.c_lflag & ECHO) 109564: f6 46 3c 08 testb $0x8,0x3c(%esi) 109568: 75 7e jne 1095e8 <== ALWAYS TAKEN echo (c, tty); tty->cbuf[tty->ccount++] = c; 10956a: 8b 56 1c mov 0x1c(%esi),%edx 10956d: 88 1c 02 mov %bl,(%edx,%eax,1) 109570: 40 inc %eax 109571: 89 46 20 mov %eax,0x20(%esi) } return 0; 109574: 31 c0 xor %eax,%eax } 109576: 5b pop %ebx 109577: 5e pop %esi 109578: c9 leave 109579: c3 ret 10957a: 66 90 xchg %ax,%ax if (tty->termios.c_iflag & IUCLC) c = tolower (c); if (c == '\r') { if (tty->termios.c_iflag & IGNCR) 10957c: a8 80 test $0x80,%al 10957e: 74 08 je 109588 <== ALWAYS TAKEN if (tty->ccount < (CBUFSIZE-1)) { if (tty->termios.c_lflag & ECHO) echo (c, tty); tty->cbuf[tty->ccount++] = c; } return 0; 109580: 31 c0 xor %eax,%eax } 109582: 5b pop %ebx <== NOT EXECUTED 109583: 5e pop %esi <== NOT EXECUTED 109584: c9 leave <== NOT EXECUTED 109585: c3 ret <== NOT EXECUTED 109586: 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) 109588: f6 c4 01 test $0x1,%ah 10958b: 74 03 je 109590 <== NEVER TAKEN c = '\n'; 10958d: b3 0a mov $0xa,%bl 10958f: 90 nop } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 109590: 8b 46 3c mov 0x3c(%esi),%eax 109593: a8 02 test $0x2,%al 109595: 74 bf je 109556 if (c == tty->termios.c_cc[VERASE]) { 109597: 38 5e 43 cmp %bl,0x43(%esi) 10959a: 0f 84 b0 00 00 00 je 109650 erase (tty, 0); return 0; } else if (c == tty->termios.c_cc[VKILL]) { 1095a0: 38 5e 44 cmp %bl,0x44(%esi) 1095a3: 74 63 je 109608 erase (tty, 1); return 0; } else if (c == tty->termios.c_cc[VEOF]) { 1095a5: 38 5e 45 cmp %bl,0x45(%esi) 1095a8: 0f 84 96 00 00 00 je 109644 <== NEVER TAKEN return 1; } else if (c == '\n') { 1095ae: 80 fb 0a cmp $0xa,%bl 1095b1: 74 69 je 10961c 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]) || 1095b3: 38 5e 4c cmp %bl,0x4c(%esi) 1095b6: 74 05 je 1095bd <== NEVER TAKEN 1095b8: 38 5e 51 cmp %bl,0x51(%esi) 1095bb: 75 99 jne 109556 <== ALWAYS TAKEN (c == tty->termios.c_cc[VEOL2])) { if (tty->termios.c_lflag & ECHO) 1095bd: a8 08 test $0x8,%al <== NOT EXECUTED 1095bf: 75 3b jne 1095fc <== NOT EXECUTED echo (c, tty); tty->cbuf[tty->ccount++] = c; 1095c1: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED 1095c4: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED 1095c7: 88 1c 02 mov %bl,(%edx,%eax,1) <== NOT EXECUTED 1095ca: 40 inc %eax <== NOT EXECUTED 1095cb: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED return 1; 1095ce: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 1095d3: eb a1 jmp 109576 <== NOT EXECUTED 1095d5: 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)) { 1095d8: a8 40 test $0x40,%al 1095da: 74 b4 je 109590 <== ALWAYS TAKEN c = '\r'; 1095dc: b3 0d mov $0xd,%bl <== NOT EXECUTED 1095de: eb b0 jmp 109590 <== NOT EXECUTED { if (tty->termios.c_iflag & ISTRIP) c &= 0x7f; if (tty->termios.c_iflag & IUCLC) c = tolower (c); 1095e0: 83 c3 20 add $0x20,%ebx 1095e3: e9 5c ff ff ff jmp 109544 /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { if (tty->termios.c_lflag & ECHO) echo (c, tty); 1095e8: 0f b6 c3 movzbl %bl,%eax 1095eb: 89 f2 mov %esi,%edx 1095ed: e8 f2 fc ff ff call 1092e4 1095f2: 8b 46 20 mov 0x20(%esi),%eax 1095f5: e9 70 ff ff ff jmp 10956a 1095fa: 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); 1095fc: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 1095ff: 89 f2 mov %esi,%edx <== NOT EXECUTED 109601: e8 de fc ff ff call 1092e4 <== NOT EXECUTED 109606: eb b9 jmp 1095c1 <== 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); 109608: ba 01 00 00 00 mov $0x1,%edx 10960d: 89 f0 mov %esi,%eax 10960f: e8 34 fd ff ff call 109348 return 0; 109614: 31 c0 xor %eax,%eax 109616: e9 5b ff ff ff jmp 109576 10961b: 90 nop } else if (c == tty->termios.c_cc[VEOF]) { return 1; } else if (c == '\n') { if (tty->termios.c_lflag & (ECHO | ECHONL)) 10961c: a8 48 test $0x48,%al 10961e: 74 0c je 10962c <== NEVER TAKEN echo (c, tty); 109620: 89 f2 mov %esi,%edx 109622: b8 0a 00 00 00 mov $0xa,%eax 109627: e8 b8 fc ff ff call 1092e4 tty->cbuf[tty->ccount++] = c; 10962c: 8b 46 20 mov 0x20(%esi),%eax 10962f: 8b 56 1c mov 0x1c(%esi),%edx 109632: c6 04 02 0a movb $0xa,(%edx,%eax,1) 109636: 40 inc %eax 109637: 89 46 20 mov %eax,0x20(%esi) return 1; 10963a: b8 01 00 00 00 mov $0x1,%eax 10963f: e9 32 ff ff ff jmp 109576 else if (c == tty->termios.c_cc[VKILL]) { erase (tty, 1); return 0; } else if (c == tty->termios.c_cc[VEOF]) { return 1; 109644: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 109649: e9 28 ff ff ff jmp 109576 <== NOT EXECUTED 10964e: 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); 109650: 31 d2 xor %edx,%edx 109652: 89 f0 mov %esi,%eax 109654: e8 ef fc ff ff call 109348 return 0; 109659: 31 c0 xor %eax,%eax 10965b: e9 16 ff ff ff jmp 109576 =============================================================================== 001231d8 : * These are directly supported (and completely correct) in the posix api. */ #if !defined(RTEMS_POSIX_API) int kill( pid_t pid, int sig ) { 1231d8: 55 push %ebp <== NOT EXECUTED 1231d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 1231db: 31 c0 xor %eax,%eax <== NOT EXECUTED 1231dd: c9 leave <== NOT EXECUTED 1231de: c3 ret <== NOT EXECUTED =============================================================================== 0011dcf4 : extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) { 11dcf4: 55 push %ebp 11dcf5: 89 e5 mov %esp,%ebp 11dcf7: 53 push %ebx 11dcf8: 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())) 11dcfb: 83 3d 80 66 12 00 03 cmpl $0x3,0x126680 11dd02: 74 08 je 11dd0c <== ALWAYS TAKEN */ fclose (stdin); fclose (stdout); fclose (stderr); } 11dd04: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11dd07: c9 leave <== NOT EXECUTED 11dd08: c3 ret <== NOT EXECUTED 11dd09: 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) { 11dd0c: a1 60 42 12 00 mov 0x124260,%eax 11dd11: 8b 1d 60 07 12 00 mov 0x120760,%ebx 11dd17: 39 d8 cmp %ebx,%eax 11dd19: 74 14 je 11dd2f _wrapup_reent(_global_impure_ptr); 11dd1b: 83 ec 0c sub $0xc,%esp 11dd1e: 53 push %ebx 11dd1f: e8 f8 05 00 00 call 11e31c <_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; 11dd24: 89 1d 60 42 12 00 mov %ebx,0x124260 11dd2a: 83 c4 10 add $0x10,%esp 11dd2d: 89 d8 mov %ebx,%eax * * Should this be changed to do *all* file streams? * _fwalk (_REENT, fclose); */ fclose (stdin); 11dd2f: 83 ec 0c sub $0xc,%esp 11dd32: ff 70 04 pushl 0x4(%eax) 11dd35: e8 fa 41 ff ff call 111f34 fclose (stdout); 11dd3a: 5a pop %edx 11dd3b: a1 60 42 12 00 mov 0x124260,%eax 11dd40: ff 70 08 pushl 0x8(%eax) 11dd43: e8 ec 41 ff ff call 111f34 fclose (stderr); 11dd48: 58 pop %eax 11dd49: a1 60 42 12 00 mov 0x124260,%eax 11dd4e: ff 70 0c pushl 0xc(%eax) 11dd51: e8 de 41 ff ff call 111f34 11dd56: 83 c4 10 add $0x10,%esp } 11dd59: 8b 5d fc mov -0x4(%ebp),%ebx 11dd5c: c9 leave 11dd5d: c3 ret =============================================================================== 0010aae8 : int link( const char *existing, const char *new ) { 10aae8: 55 push %ebp 10aae9: 89 e5 mov %esp,%ebp 10aaeb: 57 push %edi 10aaec: 56 push %esi 10aaed: 53 push %ebx 10aaee: 83 ec 58 sub $0x58,%esp 10aaf1: 8b 55 08 mov 0x8(%ebp),%edx 10aaf4: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Get the node we are linking to. */ result = rtems_filesystem_evaluate_path( existing, strlen( existing ), 10aaf7: 31 c0 xor %eax,%eax 10aaf9: b9 ff ff ff ff mov $0xffffffff,%ecx 10aafe: 89 d7 mov %edx,%edi 10ab00: f2 ae repnz scas %es:(%edi),%al 10ab02: f7 d1 not %ecx 10ab04: 49 dec %ecx 10ab05: 6a 01 push $0x1 10ab07: 8d 75 cc lea -0x34(%ebp),%esi 10ab0a: 56 push %esi 10ab0b: 6a 00 push $0x0 10ab0d: 51 push %ecx 10ab0e: 52 push %edx 10ab0f: e8 28 f9 ff ff call 10a43c 0, &existing_loc, true ); if ( result != 0 ) 10ab14: 83 c4 20 add $0x20,%esp 10ab17: 85 c0 test %eax,%eax 10ab19: 74 0d je 10ab28 return -1; 10ab1b: b8 ff ff ff ff mov $0xffffffff,%eax rtems_filesystem_freenode( &existing_loc ); rtems_filesystem_freenode( &parent_loc ); return result; } 10ab20: 8d 65 f4 lea -0xc(%ebp),%esp 10ab23: 5b pop %ebx 10ab24: 5e pop %esi 10ab25: 5f pop %edi 10ab26: c9 leave 10ab27: c3 ret /* * Get the parent of the node we are creating. */ rtems_filesystem_get_start_loc( new, &i, &parent_loc ); 10ab28: 52 push %edx 10ab29: 8d 7d b8 lea -0x48(%ebp),%edi 10ab2c: 57 push %edi 10ab2d: 8d 45 e4 lea -0x1c(%ebp),%eax 10ab30: 50 push %eax 10ab31: 53 push %ebx 10ab32: e8 1d 13 00 00 call 10be54 result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start ); 10ab37: 83 c4 0c add $0xc,%esp 10ab3a: 8d 45 e0 lea -0x20(%ebp),%eax 10ab3d: 50 push %eax 10ab3e: 57 push %edi 10ab3f: 03 5d e4 add -0x1c(%ebp),%ebx 10ab42: 53 push %ebx 10ab43: 8b 45 c4 mov -0x3c(%ebp),%eax 10ab46: ff 50 04 call *0x4(%eax) if ( result != 0 ) { 10ab49: 83 c4 10 add $0x10,%esp 10ab4c: 85 c0 test %eax,%eax 10ab4e: 75 61 jne 10abb1 /* * Check to see if the caller is trying to link across file system * boundaries. */ if ( parent_loc.mt_entry != existing_loc.mt_entry ) { 10ab50: 8b 45 dc mov -0x24(%ebp),%eax 10ab53: 39 45 c8 cmp %eax,-0x38(%ebp) 10ab56: 75 30 jne 10ab88 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 ); 10ab58: 50 push %eax 10ab59: ff 75 e0 pushl -0x20(%ebp) 10ab5c: 57 push %edi 10ab5d: 56 push %esi 10ab5e: 8b 45 c4 mov -0x3c(%ebp),%eax 10ab61: ff 50 08 call *0x8(%eax) rtems_filesystem_freenode( &existing_loc ); 10ab64: 89 34 24 mov %esi,(%esp) 10ab67: 89 45 b4 mov %eax,-0x4c(%ebp) 10ab6a: e8 81 fb ff ff call 10a6f0 rtems_filesystem_freenode( &parent_loc ); 10ab6f: 89 3c 24 mov %edi,(%esp) 10ab72: e8 79 fb ff ff call 10a6f0 return result; 10ab77: 83 c4 10 add $0x10,%esp 10ab7a: 8b 45 b4 mov -0x4c(%ebp),%eax } 10ab7d: 8d 65 f4 lea -0xc(%ebp),%esp 10ab80: 5b pop %ebx 10ab81: 5e pop %esi 10ab82: 5f pop %edi 10ab83: c9 leave 10ab84: c3 ret 10ab85: 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 ); 10ab88: 83 ec 0c sub $0xc,%esp 10ab8b: 56 push %esi 10ab8c: e8 5f fb ff ff call 10a6f0 rtems_filesystem_freenode( &parent_loc ); 10ab91: 89 3c 24 mov %edi,(%esp) 10ab94: e8 57 fb ff ff call 10a6f0 rtems_set_errno_and_return_minus_one( EXDEV ); 10ab99: e8 ba ad 00 00 call 115958 <__errno> 10ab9e: c7 00 12 00 00 00 movl $0x12,(%eax) 10aba4: 83 c4 10 add $0x10,%esp 10aba7: b8 ff ff ff ff mov $0xffffffff,%eax 10abac: e9 6f ff ff ff jmp 10ab20 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 ); 10abb1: 83 ec 0c sub $0xc,%esp 10abb4: 56 push %esi 10abb5: e8 36 fb ff ff call 10a6f0 return -1; 10abba: 83 c4 10 add $0x10,%esp 10abbd: b8 ff ff ff ff mov $0xffffffff,%eax 10abc2: e9 59 ff ff ff jmp 10ab20 =============================================================================== 0011dbcc : off_t lseek( int fd, off_t offset, int whence ) { 11dbcc: 55 push %ebp 11dbcd: 89 e5 mov %esp,%ebp 11dbcf: 57 push %edi 11dbd0: 56 push %esi 11dbd1: 53 push %ebx 11dbd2: 83 ec 1c sub $0x1c,%esp 11dbd5: 8b 5d 08 mov 0x8(%ebp),%ebx 11dbd8: 8b 55 0c mov 0xc(%ebp),%edx 11dbdb: 8b 4d 10 mov 0x10(%ebp),%ecx 11dbde: 8b 45 14 mov 0x14(%ebp),%eax rtems_libio_t *iop; off_t old_offset; off_t status; rtems_libio_check_fd( fd ); 11dbe1: 3b 1d ec 21 12 00 cmp 0x1221ec,%ebx 11dbe7: 0f 83 b3 00 00 00 jae 11dca0 iop = rtems_libio_iop( fd ); 11dbed: 8d 34 dd 00 00 00 00 lea 0x0(,%ebx,8),%esi 11dbf4: 8d 1c f5 00 00 00 00 lea 0x0(,%esi,8),%ebx 11dbfb: 29 f3 sub %esi,%ebx 11dbfd: 03 1d 80 63 12 00 add 0x126380,%ebx rtems_libio_check_is_open(iop); 11dc03: f6 43 15 01 testb $0x1,0x15(%ebx) 11dc07: 0f 84 93 00 00 00 je 11dca0 /* * Now process the lseek(). */ old_offset = iop->offset; 11dc0d: 8b 73 0c mov 0xc(%ebx),%esi 11dc10: 8b 7b 10 mov 0x10(%ebx),%edi 11dc13: 89 75 e0 mov %esi,-0x20(%ebp) 11dc16: 89 7d e4 mov %edi,-0x1c(%ebp) switch ( whence ) { 11dc19: 83 f8 01 cmp $0x1,%eax 11dc1c: 74 6e je 11dc8c 11dc1e: 83 f8 02 cmp $0x2,%eax 11dc21: 74 35 je 11dc58 11dc23: 85 c0 test %eax,%eax 11dc25: 75 45 jne 11dc6c case SEEK_SET: iop->offset = offset; 11dc27: 89 53 0c mov %edx,0xc(%ebx) 11dc2a: 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 ); 11dc2d: 8b 73 20 mov 0x20(%ebx),%esi 11dc30: 50 push %eax 11dc31: 51 push %ecx 11dc32: 52 push %edx 11dc33: 53 push %ebx 11dc34: ff 56 14 call *0x14(%esi) if ( status == (off_t) -1 ) 11dc37: 83 c4 10 add $0x10,%esp 11dc3a: 89 c1 mov %eax,%ecx 11dc3c: 21 d1 and %edx,%ecx 11dc3e: 41 inc %ecx 11dc3f: 75 0c jne 11dc4d iop->offset = old_offset; 11dc41: 8b 75 e0 mov -0x20(%ebp),%esi 11dc44: 8b 7d e4 mov -0x1c(%ebp),%edi 11dc47: 89 73 0c mov %esi,0xc(%ebx) 11dc4a: 89 7b 10 mov %edi,0x10(%ebx) /* * So if the operation failed, we have to restore iop->offset. */ return status; } 11dc4d: 8d 65 f4 lea -0xc(%ebp),%esp 11dc50: 5b pop %ebx 11dc51: 5e pop %esi 11dc52: 5f pop %edi 11dc53: c9 leave 11dc54: c3 ret 11dc55: 8d 76 00 lea 0x0(%esi),%esi case SEEK_CUR: iop->offset += offset; break; case SEEK_END: iop->offset = iop->size + offset; 11dc58: 89 d6 mov %edx,%esi 11dc5a: 89 cf mov %ecx,%edi 11dc5c: 03 73 04 add 0x4(%ebx),%esi 11dc5f: 13 7b 08 adc 0x8(%ebx),%edi 11dc62: 89 73 0c mov %esi,0xc(%ebx) 11dc65: 89 7b 10 mov %edi,0x10(%ebx) break; 11dc68: eb c3 jmp 11dc2d 11dc6a: 66 90 xchg %ax,%ax default: rtems_set_errno_and_return_minus_one( EINVAL ); 11dc6c: e8 6b 41 ff ff call 111ddc <__errno> 11dc71: c7 00 16 00 00 00 movl $0x16,(%eax) 11dc77: b8 ff ff ff ff mov $0xffffffff,%eax 11dc7c: ba ff ff ff ff mov $0xffffffff,%edx /* * So if the operation failed, we have to restore iop->offset. */ return status; } 11dc81: 8d 65 f4 lea -0xc(%ebp),%esp 11dc84: 5b pop %ebx 11dc85: 5e pop %esi 11dc86: 5f pop %edi 11dc87: c9 leave 11dc88: c3 ret 11dc89: 8d 76 00 lea 0x0(%esi),%esi case SEEK_SET: iop->offset = offset; break; case SEEK_CUR: iop->offset += offset; 11dc8c: 8b 75 e0 mov -0x20(%ebp),%esi 11dc8f: 8b 7d e4 mov -0x1c(%ebp),%edi 11dc92: 01 d6 add %edx,%esi 11dc94: 11 cf adc %ecx,%edi 11dc96: 89 73 0c mov %esi,0xc(%ebx) 11dc99: 89 7b 10 mov %edi,0x10(%ebx) break; 11dc9c: eb 8f jmp 11dc2d 11dc9e: 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); 11dca0: e8 37 41 ff ff call 111ddc <__errno> 11dca5: c7 00 09 00 00 00 movl $0x9,(%eax) 11dcab: b8 ff ff ff ff mov $0xffffffff,%eax 11dcb0: ba ff ff ff ff mov $0xffffffff,%edx 11dcb5: eb 96 jmp 11dc4d =============================================================================== 0010933c : int _STAT_NAME( const char *path, struct stat *buf ) { 10933c: 55 push %ebp 10933d: 89 e5 mov %esp,%ebp 10933f: 57 push %edi 109340: 56 push %esi 109341: 53 push %ebx 109342: 83 ec 3c sub $0x3c,%esp 109345: 8b 55 08 mov 0x8(%ebp),%edx 109348: 8b 75 0c mov 0xc(%ebp),%esi /* * Check to see if we were passed a valid pointer. */ if ( !buf ) 10934b: 85 f6 test %esi,%esi 10934d: 74 65 je 1093b4 rtems_set_errno_and_return_minus_one( EFAULT ); status = rtems_filesystem_evaluate_path( path, strlen( path ), 10934f: b9 ff ff ff ff mov $0xffffffff,%ecx 109354: 89 d7 mov %edx,%edi 109356: 31 c0 xor %eax,%eax 109358: f2 ae repnz scas %es:(%edi),%al 10935a: f7 d1 not %ecx 10935c: 49 dec %ecx 10935d: 83 ec 0c sub $0xc,%esp 109360: 6a 00 push $0x0 109362: 8d 5d d4 lea -0x2c(%ebp),%ebx 109365: 53 push %ebx 109366: 6a 00 push $0x0 109368: 51 push %ecx 109369: 52 push %edx 10936a: e8 05 fa ff ff call 108d74 0, &loc, _STAT_FOLLOW_LINKS ); if ( status != 0 ) 10936f: 83 c4 20 add $0x20,%esp 109372: 85 c0 test %eax,%eax 109374: 74 0e je 109384 return -1; 109376: b8 ff ff ff ff mov $0xffffffff,%eax status = (*loc.handlers->fstat_h)( &loc, buf ); rtems_filesystem_freenode( &loc ); return status; } 10937b: 8d 65 f4 lea -0xc(%ebp),%esp 10937e: 5b pop %ebx 10937f: 5e pop %esi 109380: 5f pop %edi 109381: c9 leave 109382: c3 ret 109383: 90 nop /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( buf, 0, sizeof(struct stat) ); 109384: b9 48 00 00 00 mov $0x48,%ecx 109389: 89 f7 mov %esi,%edi 10938b: f3 aa rep stos %al,%es:(%edi) status = (*loc.handlers->fstat_h)( &loc, buf ); 10938d: 83 ec 08 sub $0x8,%esp 109390: 56 push %esi 109391: 53 push %ebx 109392: 8b 45 dc mov -0x24(%ebp),%eax 109395: ff 50 18 call *0x18(%eax) rtems_filesystem_freenode( &loc ); 109398: 89 1c 24 mov %ebx,(%esp) 10939b: 89 45 c4 mov %eax,-0x3c(%ebp) 10939e: e8 a9 fa ff ff call 108e4c return status; 1093a3: 83 c4 10 add $0x10,%esp 1093a6: 8b 45 c4 mov -0x3c(%ebp),%eax } 1093a9: 8d 65 f4 lea -0xc(%ebp),%esp 1093ac: 5b pop %ebx 1093ad: 5e pop %esi 1093ae: 5f pop %edi 1093af: c9 leave 1093b0: c3 ret 1093b1: 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 ); 1093b4: e8 eb a5 00 00 call 1139a4 <__errno> 1093b9: c7 00 0e 00 00 00 movl $0xe,(%eax) 1093bf: b8 ff ff ff ff mov $0xffffffff,%eax status = (*loc.handlers->fstat_h)( &loc, buf ); rtems_filesystem_freenode( &loc ); return status; } 1093c4: 8d 65 f4 lea -0xc(%ebp),%esp 1093c7: 5b pop %ebx 1093c8: 5e pop %esi 1093c9: 5f pop %edi 1093ca: c9 leave 1093cb: c3 ret =============================================================================== 00107908 : #include "malloc_p.h" void *malloc( size_t size ) { 107908: 55 push %ebp 107909: 89 e5 mov %esp,%ebp 10790b: 56 push %esi 10790c: 53 push %ebx 10790d: 8b 75 08 mov 0x8(%ebp),%esi void *return_this; MSBUMP(malloc_calls, 1); 107910: ff 05 a4 63 12 00 incl 0x1263a4 /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 107916: e8 fd fe ff ff call 107818 /* * Validate the parameters */ if ( !size ) 10791b: 85 f6 test %esi,%esi 10791d: 74 5d je 10797c return (void *) 0; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 10791f: 83 3d 80 66 12 00 03 cmpl $0x3,0x126680 107926: 74 48 je 107970 RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate( Heap_Control *heap, uintptr_t size ) { return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 ); 107928: 6a 00 push $0x0 10792a: 6a 00 push $0x0 10792c: 56 push %esi 10792d: ff 35 30 22 12 00 pushl 0x122230 107933: e8 00 4b 00 00 call 10c438 <_Protected_heap_Allocate_aligned_with_boundary> 107938: 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 ) { 10793a: 83 c4 10 add $0x10,%esp 10793d: 85 c0 test %eax,%eax 10793f: 74 47 je 107988 } /* * If the user wants us to dirty the allocated memory, then do it. */ if ( rtems_malloc_dirty_helper ) 107941: a1 b0 47 12 00 mov 0x1247b0,%eax 107946: 85 c0 test %eax,%eax 107948: 74 0a je 107954 (*rtems_malloc_dirty_helper)( return_this, size ); 10794a: 83 ec 08 sub $0x8,%esp 10794d: 56 push %esi 10794e: 53 push %ebx 10794f: ff d0 call *%eax 107951: 83 c4 10 add $0x10,%esp /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 107954: a1 a8 47 12 00 mov 0x1247a8,%eax 107959: 85 c0 test %eax,%eax 10795b: 74 0a je 107967 (*rtems_malloc_statistics_helpers->at_malloc)(return_this); 10795d: 83 ec 0c sub $0xc,%esp 107960: 53 push %ebx 107961: ff 50 04 call *0x4(%eax) 107964: 83 c4 10 add $0x10,%esp return return_this; } 107967: 89 d8 mov %ebx,%eax 107969: 8d 65 f8 lea -0x8(%ebp),%esp 10796c: 5b pop %ebx 10796d: 5e pop %esi 10796e: c9 leave 10796f: 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() ) 107970: e8 63 fe ff ff call 1077d8 return (void *) 0; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 107975: 84 c0 test %al,%al 107977: 75 af jne 107928 <== ALWAYS TAKEN 107979: 8d 76 00 lea 0x0(%esi),%esi !malloc_is_system_state_OK() ) return NULL; 10797c: 31 db xor %ebx,%ebx */ if ( rtems_malloc_statistics_helpers ) (*rtems_malloc_statistics_helpers->at_malloc)(return_this); return return_this; } 10797e: 89 d8 mov %ebx,%eax 107980: 8d 65 f8 lea -0x8(%ebp),%esp 107983: 5b pop %ebx 107984: 5e pop %esi 107985: c9 leave 107986: c3 ret 107987: 90 nop */ return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); if ( !return_this ) { if (rtems_malloc_sbrk_helpers) 107988: a1 ac 47 12 00 mov 0x1247ac,%eax 10798d: 85 c0 test %eax,%eax 10798f: 74 12 je 1079a3 return_this = (*rtems_malloc_sbrk_helpers->extend)( size ); 107991: 83 ec 0c sub $0xc,%esp 107994: 56 push %esi 107995: ff 50 04 call *0x4(%eax) if ( !return_this ) { 107998: 83 c4 10 add $0x10,%esp 10799b: 85 c0 test %eax,%eax 10799d: 74 04 je 1079a3 10799f: 89 c3 mov %eax,%ebx 1079a1: eb 9e jmp 107941 errno = ENOMEM; 1079a3: e8 34 a4 00 00 call 111ddc <__errno> 1079a8: c7 00 0c 00 00 00 movl $0xc,(%eax) return (void *) 0; 1079ae: eb b7 jmp 107967 =============================================================================== 0010787c : #include "malloc_p.h" int malloc_get_statistics( rtems_malloc_statistics_t *stats ) { 10787c: 55 push %ebp 10787d: 89 e5 mov %esp,%ebp 10787f: 57 push %edi 107880: 56 push %esi 107881: 53 push %ebx 107882: 83 ec 0c sub $0xc,%esp 107885: 8b 5d 08 mov 0x8(%ebp),%ebx if ( !stats ) 107888: 85 db test %ebx,%ebx 10788a: 74 38 je 1078c4 return -1; _RTEMS_Lock_allocator(); 10788c: 83 ec 0c sub $0xc,%esp 10788f: ff 35 00 55 12 00 pushl 0x125500 107895: e8 a2 3b 00 00 call 10b43c <_API_Mutex_Lock> *stats = rtems_malloc_statistics; 10789a: be 00 53 12 00 mov $0x125300,%esi 10789f: b9 0b 00 00 00 mov $0xb,%ecx 1078a4: 89 df mov %ebx,%edi 1078a6: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _RTEMS_Unlock_allocator(); 1078a8: 58 pop %eax 1078a9: ff 35 00 55 12 00 pushl 0x125500 1078af: e8 d0 3b 00 00 call 10b484 <_API_Mutex_Unlock> return 0; 1078b4: 83 c4 10 add $0x10,%esp 1078b7: 31 c0 xor %eax,%eax } 1078b9: 8d 65 f4 lea -0xc(%ebp),%esp 1078bc: 5b pop %ebx 1078bd: 5e pop %esi 1078be: 5f pop %edi 1078bf: c9 leave 1078c0: c3 ret 1078c1: 8d 76 00 lea 0x0(%esi),%esi int malloc_get_statistics( rtems_malloc_statistics_t *stats ) { if ( !stats ) return -1; 1078c4: b8 ff ff ff ff mov $0xffffffff,%eax _RTEMS_Lock_allocator(); *stats = rtems_malloc_statistics; _RTEMS_Unlock_allocator(); return 0; } 1078c9: 8d 65 f4 lea -0xc(%ebp),%esp 1078cc: 5b pop %ebx 1078cd: 5e pop %esi 1078ce: 5f pop %edi 1078cf: c9 leave 1078d0: c3 ret =============================================================================== 00107c9c : } void *malloc_sbrk_extend_and_allocate( size_t size ) { 107c9c: 55 push %ebp 107c9d: 89 e5 mov %esp,%ebp 107c9f: 56 push %esi 107ca0: 53 push %ebx 107ca1: 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; 107ca4: 8b 0d 8c 64 12 00 mov 0x12648c,%ecx if ( sbrk_amount == 0 ) 107caa: 85 c9 test %ecx,%ecx 107cac: 75 0a jne 107cb8 <== 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; 107cae: 31 c0 xor %eax,%eax MSBUMP(space_available, the_size); return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); return return_this; } 107cb0: 8d 65 f8 lea -0x8(%ebp),%esp 107cb3: 5b pop %ebx 107cb4: 5e pop %esi 107cb5: c9 leave 107cb6: c3 ret 107cb7: 90 nop sbrk_amount = RTEMS_Malloc_Sbrk_amount; if ( sbrk_amount == 0 ) return (void *) 0; the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount); 107cb8: 8d 04 0e lea (%esi,%ecx,1),%eax 107cbb: 31 d2 xor %edx,%edx 107cbd: f7 f1 div %ecx 107cbf: 89 c3 mov %eax,%ebx 107cc1: 0f af d9 imul %ecx,%ebx starting_address = (void *) sbrk(the_size); 107cc4: 83 ec 0c sub $0xc,%esp 107cc7: 53 push %ebx 107cc8: e8 8f 87 ff ff call 10045c if ( starting_address == (void*) -1 ) 107ccd: 83 c4 10 add $0x10,%esp 107cd0: 83 f8 ff cmp $0xffffffff,%eax 107cd3: 74 d9 je 107cae return (void *) 0; if ( !_Protected_heap_Extend( 107cd5: 52 push %edx 107cd6: 53 push %ebx 107cd7: 50 push %eax 107cd8: ff 35 90 21 12 00 pushl 0x122190 107cde: e8 91 4a 00 00 call 10c774 <_Protected_heap_Extend> 107ce3: 83 c4 10 add $0x10,%esp 107ce6: 84 c0 test %al,%al 107ce8: 74 1b je 107d05 sbrk(-the_size); errno = ENOMEM; return (void *) 0; } MSBUMP(space_available, the_size); 107cea: 01 1d 60 64 12 00 add %ebx,0x126460 107cf0: 6a 00 push $0x0 107cf2: 6a 00 push $0x0 107cf4: 56 push %esi 107cf5: ff 35 90 21 12 00 pushl 0x122190 107cfb: e8 3c 4a 00 00 call 10c73c <_Protected_heap_Allocate_aligned_with_boundary> return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); return return_this; 107d00: 83 c4 10 add $0x10,%esp 107d03: eb ab jmp 107cb0 if ( starting_address == (void*) -1 ) return (void *) 0; if ( !_Protected_heap_Extend( RTEMS_Malloc_Heap, starting_address, the_size) ) { sbrk(-the_size); 107d05: 83 ec 0c sub $0xc,%esp 107d08: f7 db neg %ebx 107d0a: 53 push %ebx 107d0b: e8 4c 87 ff ff call 10045c errno = ENOMEM; 107d10: e8 bb a6 00 00 call 1123d0 <__errno> 107d15: c7 00 0c 00 00 00 movl $0xc,(%eax) return (void *) 0; 107d1b: 83 c4 10 add $0x10,%esp 107d1e: 31 c0 xor %eax,%eax 107d20: eb 8e jmp 107cb0 =============================================================================== 00110d0c : */ void memfile_free_blocks_in_table( block_p **block_table, int entries ) { 110d0c: 55 push %ebp 110d0d: 89 e5 mov %esp,%ebp 110d0f: 57 push %edi 110d10: 56 push %esi 110d11: 53 push %ebx 110d12: 83 ec 0c sub $0xc,%esp 110d15: 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; 110d18: 8b 45 08 mov 0x8(%ebp),%eax 110d1b: 8b 30 mov (%eax),%esi for ( i=0 ; i<== NEVER TAKEN 110d21: 31 db xor %ebx,%ebx 110d23: 90 nop if ( b[i] ) { 110d24: 8b 04 9e mov (%esi,%ebx,4),%eax 110d27: 85 c0 test %eax,%eax 110d29: 74 13 je 110d3e memfile_free_block( b[i] ); 110d2b: 83 ec 0c sub $0xc,%esp 110d2e: 50 push %eax 110d2f: e8 bc ff ff ff call 110cf0 b[i] = 0; 110d34: c7 04 9e 00 00 00 00 movl $0x0,(%esi,%ebx,4) 110d3b: 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 110d43: 8b 45 08 mov 0x8(%ebp),%eax 110d46: 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 ); 110d48: 83 ec 0c sub $0xc,%esp 110d4b: 56 push %esi 110d4c: e8 9f ff ff ff call 110cf0 *block_table = 0; 110d51: 8b 45 08 mov 0x8(%ebp),%eax 110d54: c7 00 00 00 00 00 movl $0x0,(%eax) 110d5a: 83 c4 10 add $0x10,%esp } 110d5d: 8d 65 f4 lea -0xc(%ebp),%esp 110d60: 5b pop %ebx 110d61: 5e pop %esi 110d62: 5f pop %edi 110d63: c9 leave 110d64: c3 ret =============================================================================== 00111288 : */ int memfile_ftruncate( rtems_libio_t *iop, rtems_off64_t length ) { 111288: 55 push %ebp 111289: 89 e5 mov %esp,%ebp 11128b: 53 push %ebx 11128c: 83 ec 14 sub $0x14,%esp 11128f: 8b 4d 08 mov 0x8(%ebp),%ecx 111292: 8b 45 0c mov 0xc(%ebp),%eax 111295: 8b 55 10 mov 0x10(%ebp),%edx IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 111298: 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 ) 11129b: 39 53 54 cmp %edx,0x54(%ebx) 11129e: 7f 19 jg 1112b9 <== NEVER TAKEN 1112a0: 7d 12 jge 1112b4 <== ALWAYS TAKEN return IMFS_memfile_extend( the_jnode, length ); 1112a2: 51 push %ecx 1112a3: 52 push %edx 1112a4: 50 push %eax 1112a5: 53 push %ebx 1112a6: e8 45 fc ff ff call 110ef0 1112ab: 83 c4 10 add $0x10,%esp iop->size = the_jnode->info.file.size; IMFS_update_atime( the_jnode ); return 0; } 1112ae: 8b 5d fc mov -0x4(%ebp),%ebx 1112b1: c9 leave 1112b2: c3 ret 1112b3: 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 ) 1112b4: 39 43 50 cmp %eax,0x50(%ebx) 1112b7: 72 e9 jb 1112a2 /* * 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; 1112b9: 89 43 50 mov %eax,0x50(%ebx) 1112bc: 89 53 54 mov %edx,0x54(%ebx) iop->size = the_jnode->info.file.size; 1112bf: 89 41 04 mov %eax,0x4(%ecx) 1112c2: 89 51 08 mov %edx,0x8(%ecx) IMFS_update_atime( the_jnode ); 1112c5: 83 ec 08 sub $0x8,%esp 1112c8: 6a 00 push $0x0 1112ca: 8d 45 f0 lea -0x10(%ebp),%eax 1112cd: 50 push %eax 1112ce: e8 dd 63 ff ff call 1076b0 1112d3: 8b 45 f0 mov -0x10(%ebp),%eax 1112d6: 89 43 40 mov %eax,0x40(%ebx) return 0; 1112d9: 83 c4 10 add $0x10,%esp 1112dc: 31 c0 xor %eax,%eax } 1112de: 8b 5d fc mov -0x4(%ebp),%ebx 1112e1: c9 leave 1112e2: c3 ret =============================================================================== 001112e4 : rtems_off64_t memfile_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) { 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 0c sub $0xc,%esp 1112ed: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 1112f0: 8b 73 18 mov 0x18(%ebx),%esi if (the_jnode->type == IMFS_LINEAR_FILE) { 1112f3: 83 7e 4c 06 cmpl $0x6,0x4c(%esi) 1112f7: 74 2f je 111328 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 )) 1112f9: 57 push %edi 1112fa: ff 73 10 pushl 0x10(%ebx) 1112fd: ff 73 0c pushl 0xc(%ebx) 111300: 56 push %esi 111301: e8 ea fb ff ff call 110ef0 111306: 83 c4 10 add $0x10,%esp 111309: 85 c0 test %eax,%eax 11130b: 75 45 jne 111352 rtems_set_errno_and_return_minus_one( ENOSPC ); iop->size = the_jnode->info.file.size; 11130d: 8b 46 50 mov 0x50(%esi),%eax 111310: 8b 56 54 mov 0x54(%esi),%edx 111313: 89 43 04 mov %eax,0x4(%ebx) 111316: 89 53 08 mov %edx,0x8(%ebx) 111319: 8b 43 0c mov 0xc(%ebx),%eax 11131c: 8b 53 10 mov 0x10(%ebx),%edx } return iop->offset; } 11131f: 8d 65 f4 lea -0xc(%ebp),%esp 111322: 5b pop %ebx 111323: 5e pop %esi 111324: 5f pop %edi 111325: c9 leave 111326: c3 ret 111327: 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) 111328: 8b 43 0c mov 0xc(%ebx),%eax 11132b: 8b 53 10 mov 0x10(%ebx),%edx 11132e: 8b 7e 50 mov 0x50(%esi),%edi 111331: 8b 4e 54 mov 0x54(%esi),%ecx 111334: 39 ca cmp %ecx,%edx 111336: 7c e7 jl 11131f <== NEVER TAKEN 111338: 7e 12 jle 11134c <== ALWAYS TAKEN iop->offset = the_jnode->info.linearfile.size; 11133a: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED 11133d: 89 4b 10 mov %ecx,0x10(%ebx) <== NOT EXECUTED 111340: 89 f8 mov %edi,%eax <== NOT EXECUTED 111342: 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; } 111344: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111347: 5b pop %ebx <== NOT EXECUTED 111348: 5e pop %esi <== NOT EXECUTED 111349: 5f pop %edi <== NOT EXECUTED 11134a: c9 leave <== NOT EXECUTED 11134b: 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) 11134c: 39 f8 cmp %edi,%eax 11134e: 76 cf jbe 11131f <== ALWAYS TAKEN 111350: eb e8 jmp 11133a <== 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 ); 111352: e8 85 0a 00 00 call 111ddc <__errno> 111357: c7 00 1c 00 00 00 movl $0x1c,(%eax) 11135d: b8 ff ff ff ff mov $0xffffffff,%eax 111362: ba ff ff ff ff mov $0xffffffff,%edx 111367: eb b6 jmp 11131f =============================================================================== 001111e0 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 1111e0: 55 push %ebp 1111e1: 89 e5 mov %esp,%ebp 1111e3: 56 push %esi 1111e4: 53 push %ebx 1111e5: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 1111e8: 8b 73 18 mov 0x18(%ebx),%esi /* * Perform 'copy on write' for linear files */ if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND)) 1111eb: 8b 43 14 mov 0x14(%ebx),%eax 1111ee: a9 04 02 00 00 test $0x204,%eax 1111f3: 74 06 je 1111fb && (the_jnode->type == IMFS_LINEAR_FILE)) { 1111f5: 83 7e 4c 06 cmpl $0x6,0x4c(%esi) 1111f9: 74 2d je 111228 <== 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)) 1111fb: 8b 56 50 mov 0x50(%esi),%edx 1111fe: 8b 4e 54 mov 0x54(%esi),%ecx return -1; } if (iop->flags & LIBIO_FLAGS_APPEND) 111201: f6 c4 02 test $0x2,%ah 111204: 75 12 jne 111218 iop->offset = the_jnode->info.file.size; iop->size = the_jnode->info.file.size; 111206: 89 53 04 mov %edx,0x4(%ebx) 111209: 89 4b 08 mov %ecx,0x8(%ebx) return 0; 11120c: 31 c0 xor %eax,%eax } 11120e: 8d 65 f8 lea -0x8(%ebp),%esp 111211: 5b pop %ebx 111212: 5e pop %esi 111213: c9 leave 111214: c3 ret 111215: 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; 111218: 89 53 0c mov %edx,0xc(%ebx) 11121b: 89 4b 10 mov %ecx,0x10(%ebx) 11121e: 8b 56 50 mov 0x50(%esi),%edx 111221: 8b 4e 54 mov 0x54(%esi),%ecx 111224: eb e0 jmp 111206 111226: 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; 111228: 8b 46 50 mov 0x50(%esi),%eax <== NOT EXECUTED const unsigned char *buffer = the_jnode->info.linearfile.direct; 11122b: 8b 56 58 mov 0x58(%esi),%edx <== NOT EXECUTED the_jnode->type = IMFS_MEMORY_FILE; 11122e: c7 46 4c 05 00 00 00 movl $0x5,0x4c(%esi) <== NOT EXECUTED the_jnode->info.file.size = 0; 111235: c7 46 50 00 00 00 00 movl $0x0,0x50(%esi) <== NOT EXECUTED 11123c: c7 46 54 00 00 00 00 movl $0x0,0x54(%esi) <== NOT EXECUTED the_jnode->info.file.indirect = 0; 111243: c7 46 58 00 00 00 00 movl $0x0,0x58(%esi) <== NOT EXECUTED the_jnode->info.file.doubly_indirect = 0; 11124a: c7 46 5c 00 00 00 00 movl $0x0,0x5c(%esi) <== NOT EXECUTED the_jnode->info.file.triply_indirect = 0; 111251: c7 46 60 00 00 00 00 movl $0x0,0x60(%esi) <== NOT EXECUTED if ((count != 0) 111258: 85 c0 test %eax,%eax <== NOT EXECUTED 11125a: 75 09 jne 111265 <== NOT EXECUTED 11125c: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 11125f: 31 d2 xor %edx,%edx <== NOT EXECUTED 111261: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 111263: eb 9c jmp 111201 <== NOT EXECUTED && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) 111265: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111268: 50 push %eax <== NOT EXECUTED 111269: 52 push %edx <== NOT EXECUTED 11126a: 6a 00 push $0x0 <== NOT EXECUTED 11126c: 6a 00 push $0x0 <== NOT EXECUTED 11126e: 56 push %esi <== NOT EXECUTED 11126f: e8 94 fd ff ff call 111008 <== NOT EXECUTED 111274: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 111277: 40 inc %eax <== NOT EXECUTED 111278: 74 08 je 111282 <== NOT EXECUTED 11127a: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 11127d: e9 79 ff ff ff jmp 1111fb <== NOT EXECUTED return -1; 111282: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 111285: eb 87 jmp 11120e <== NOT EXECUTED =============================================================================== 001079cc : int mknod( const char *pathname, mode_t mode, dev_t dev ) { 1079cc: 55 push %ebp 1079cd: 89 e5 mov %esp,%ebp 1079cf: 57 push %edi 1079d0: 56 push %esi 1079d1: 53 push %ebx 1079d2: 83 ec 3c sub $0x3c,%esp 1079d5: 8b 7d 08 mov 0x8(%ebp),%edi 1079d8: 8b 5d 0c mov 0xc(%ebp),%ebx 1079db: 8b 55 10 mov 0x10(%ebp),%edx 1079de: 8b 4d 14 mov 0x14(%ebp),%ecx int result; /* * The file type is field within the mode. Check we have a sane mode set. */ switch (mode & S_IFMT) 1079e1: 89 d8 mov %ebx,%eax 1079e3: 25 00 f0 00 00 and $0xf000,%eax 1079e8: 3d 00 40 00 00 cmp $0x4000,%eax 1079ed: 74 39 je 107a28 1079ef: 76 27 jbe 107a18 1079f1: 3d 00 60 00 00 cmp $0x6000,%eax 1079f6: 74 30 je 107a28 1079f8: 3d 00 80 00 00 cmp $0x8000,%eax 1079fd: 74 29 je 107a28 <== ALWAYS TAKEN case S_IFBLK: case S_IFREG: case S_IFIFO: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 1079ff: e8 d8 a3 00 00 call 111ddc <__errno> 107a04: c7 00 16 00 00 00 movl $0x16,(%eax) 107a0a: 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; } 107a0f: 8d 65 f4 lea -0xc(%ebp),%esp 107a12: 5b pop %ebx 107a13: 5e pop %esi 107a14: 5f pop %edi 107a15: c9 leave 107a16: c3 ret 107a17: 90 nop int result; /* * The file type is field within the mode. Check we have a sane mode set. */ switch (mode & S_IFMT) 107a18: 3d 00 10 00 00 cmp $0x1000,%eax 107a1d: 74 09 je 107a28 107a1f: 3d 00 20 00 00 cmp $0x2000,%eax 107a24: 75 d9 jne 1079ff 107a26: 66 90 xchg %ax,%ax break; default: rtems_set_errno_and_return_minus_one( EINVAL ); } rtems_filesystem_get_start_loc( pathname, &i, &temp_loc ); 107a28: 50 push %eax 107a29: 8d 75 cc lea -0x34(%ebp),%esi 107a2c: 56 push %esi 107a2d: 8d 45 e4 lea -0x1c(%ebp),%eax 107a30: 50 push %eax 107a31: 57 push %edi 107a32: 89 55 c4 mov %edx,-0x3c(%ebp) 107a35: 89 4d c0 mov %ecx,-0x40(%ebp) 107a38: e8 1f 0a 00 00 call 10845c result = (*temp_loc.ops->evalformake_h)( 107a3d: 83 c4 0c add $0xc,%esp 107a40: 8d 45 e0 lea -0x20(%ebp),%eax 107a43: 50 push %eax 107a44: 56 push %esi 107a45: 03 7d e4 add -0x1c(%ebp),%edi 107a48: 57 push %edi 107a49: 8b 45 d8 mov -0x28(%ebp),%eax 107a4c: ff 50 04 call *0x4(%eax) &pathname[i], &temp_loc, &name_start ); if ( result != 0 ) 107a4f: 83 c4 10 add $0x10,%esp 107a52: 85 c0 test %eax,%eax 107a54: 8b 55 c4 mov -0x3c(%ebp),%edx 107a57: 8b 4d c0 mov -0x40(%ebp),%ecx 107a5a: 74 10 je 107a6c return -1; 107a5c: 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; } 107a61: 8d 65 f4 lea -0xc(%ebp),%esp 107a64: 5b pop %ebx 107a65: 5e pop %esi 107a66: 5f pop %edi 107a67: c9 leave 107a68: c3 ret 107a69: 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 ); 107a6c: 83 ec 0c sub $0xc,%esp 107a6f: 56 push %esi 107a70: 51 push %ecx 107a71: 52 push %edx 107a72: 53 push %ebx 107a73: ff 75 e0 pushl -0x20(%ebp) 107a76: 8b 45 d8 mov -0x28(%ebp),%eax 107a79: ff 50 14 call *0x14(%eax) rtems_filesystem_freenode( &temp_loc ); 107a7c: 83 c4 14 add $0x14,%esp 107a7f: 56 push %esi 107a80: 89 45 c4 mov %eax,-0x3c(%ebp) 107a83: e8 98 fb ff ff call 107620 return result; 107a88: 83 c4 10 add $0x10,%esp 107a8b: 8b 45 c4 mov -0x3c(%ebp),%eax } 107a8e: 8d 65 f4 lea -0xc(%ebp),%esp 107a91: 5b pop %ebx 107a92: 5e pop %esi 107a93: 5f pop %edi 107a94: c9 leave 107a95: c3 ret =============================================================================== 00107b1c : const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { 107b1c: 55 push %ebp 107b1d: 89 e5 mov %esp,%ebp 107b1f: 57 push %edi 107b20: 56 push %esi 107b21: 53 push %ebx 107b22: 83 ec 4c sub $0x4c,%esp 107b25: 8b 75 10 mov 0x10(%ebp),%esi /* * Are the file system options valid? */ if ( options != RTEMS_FILESYSTEM_READ_ONLY && 107b28: 83 7d 14 01 cmpl $0x1,0x14(%ebp) 107b2c: 0f 87 36 02 00 00 ja 107d68 rtems_set_errno_and_return_minus_one( EINVAL ); /* * Get mount handler */ mount_h = rtems_filesystem_get_mount_handler( filesystemtype ); 107b32: 83 ec 0c sub $0xc,%esp 107b35: 56 push %esi 107b36: e8 dd 79 00 00 call 10f518 107b3b: 89 45 b8 mov %eax,-0x48(%ebp) if ( !mount_h ) 107b3e: 83 c4 10 add $0x10,%esp 107b41: 85 c0 test %eax,%eax 107b43: 0f 84 1f 02 00 00 je 107d68 { 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; 107b49: 8b 45 0c mov 0xc(%ebp),%eax 107b4c: 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 : "/"; 107b4e: 0f 95 45 b7 setne -0x49(%ebp) 107b52: 0f 84 e8 01 00 00 je 107d40 * 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( 107b58: 31 c0 xor %eax,%eax 107b5a: b9 ff ff ff ff mov $0xffffffff,%ecx 107b5f: 8b 7d 0c mov 0xc(%ebp),%edi 107b62: f2 ae repnz scas %es:(%edi),%al 107b64: f7 d1 not %ecx 107b66: 8d 41 ff lea -0x1(%ecx),%eax 107b69: 89 45 ac mov %eax,-0x54(%ebp) 107b6c: 89 4d bc mov %ecx,-0x44(%ebp) 107b6f: 8b 55 0c mov 0xc(%ebp),%edx 107b72: 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; 107b75: ba ff ff ff ff mov $0xffffffff,%edx 107b7a: 31 c0 xor %eax,%eax 107b7c: 89 d1 mov %edx,%ecx 107b7e: 89 f7 mov %esi,%edi 107b80: f2 ae repnz scas %es:(%edi),%al 107b82: f7 d1 not %ecx 107b84: 89 4d c4 mov %ecx,-0x3c(%ebp) size_t source_size = source_or_null != NULL ? strlen( source_or_null ) + 1 : 0; 107b87: 8b 7d 08 mov 0x8(%ebp),%edi 107b8a: 85 ff test %edi,%edi 107b8c: 0f 84 ca 01 00 00 je 107d5c 107b92: 89 d1 mov %edx,%ecx 107b94: 8b 7d 08 mov 0x8(%ebp),%edi 107b97: f2 ae repnz scas %es:(%edi),%al 107b99: f7 d1 not %ecx 107b9b: 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 ); 107b9e: 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; 107ba1: 8b 55 bc mov -0x44(%ebp),%edx 107ba4: 8b 7d c4 mov -0x3c(%ebp),%edi 107ba7: 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 ) 107bab: 03 45 c0 add -0x40(%ebp),%eax + filesystemtype_size + source_size + target_size; rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size ); 107bae: 50 push %eax 107baf: 6a 01 push $0x1 107bb1: e8 ee f8 ff ff call 1074a4 107bb6: 89 c3 mov %eax,%ebx if ( mt_entry != NULL ) { 107bb8: 83 c4 10 add $0x10,%esp 107bbb: 85 c0 test %eax,%eax 107bbd: 0f 84 65 01 00 00 je 107d28 <== NEVER TAKEN char *str = (char *) mt_entry + sizeof( *mt_entry ); 107bc3: 8d 40 74 lea 0x74(%eax),%eax memcpy( str, filesystemtype, filesystemtype_size ); 107bc6: 89 c7 mov %eax,%edi 107bc8: 8b 4d c4 mov -0x3c(%ebp),%ecx 107bcb: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 107bcd: 89 fa mov %edi,%edx mt_entry->type = str; 107bcf: 89 43 6c mov %eax,0x6c(%ebx) str += filesystemtype_size; memcpy( str, source_or_null, source_size ); 107bd2: 8b 75 08 mov 0x8(%ebp),%esi 107bd5: 8b 4d c0 mov -0x40(%ebp),%ecx 107bd8: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 107bda: 89 f8 mov %edi,%eax mt_entry->dev = str; 107bdc: 89 53 70 mov %edx,0x70(%ebx) str += source_size; memcpy( str, target, target_size ); 107bdf: 8b 75 b0 mov -0x50(%ebp),%esi 107be2: 8b 4d bc mov -0x44(%ebp),%ecx 107be5: f3 a4 rep movsb %ds:(%esi),%es:(%edi) mt_entry->target = str; 107be7: 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; 107bea: 89 5b 2c mov %ebx,0x2c(%ebx) mt_entry->options = options; 107bed: 8b 45 14 mov 0x14(%ebp),%eax 107bf0: 89 43 30 mov %eax,0x30(%ebx) mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf; 107bf3: 8d 7b 38 lea 0x38(%ebx),%edi 107bf6: be c0 fd 11 00 mov $0x11fdc0,%esi 107bfb: b1 0c mov $0xc,%cl 107bfd: 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 ) { 107bff: 80 7d b7 00 cmpb $0x0,-0x49(%ebp) 107c03: 0f 85 83 00 00 00 jne 107c8c } } else { /* * Do we already have a base file system ? */ if ( !rtems_chain_is_empty( &mount_chain ) ) { 107c09: 81 3d 84 40 12 00 88 cmpl $0x124088,0x124084 107c10: 40 12 00 107c13: 0f 85 67 01 00 00 jne 107d80 <== 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; 107c19: 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 ) ) { 107c1b: 83 ec 08 sub $0x8,%esp 107c1e: ff 75 18 pushl 0x18(%ebp) 107c21: 53 push %ebx 107c22: ff 55 b8 call *-0x48(%ebp) 107c25: 83 c4 10 add $0x10,%esp 107c28: 85 c0 test %eax,%eax 107c2a: 0f 85 74 01 00 00 jne 107da4 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 ); 107c30: 56 push %esi 107c31: 6a 00 push $0x0 107c33: 6a 00 push $0x0 107c35: ff 35 88 63 12 00 pushl 0x126388 107c3b: e8 68 2f 00 00 call 10aba8 107c40: 5a pop %edx 107c41: 59 pop %ecx 107c42: 53 push %ebx 107c43: 68 84 40 12 00 push $0x124084 107c48: e8 37 38 00 00 call 10b484 <_Chain_Append> } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 107c4d: 58 pop %eax 107c4e: ff 35 88 63 12 00 pushl 0x126388 107c54: e8 4b 30 00 00 call 10aca4 */ rtems_libio_lock(); rtems_chain_append( &mount_chain, &mt_entry->Node ); rtems_libio_unlock(); if ( !has_target ) 107c59: 83 c4 10 add $0x10,%esp 107c5c: 80 7d b7 00 cmpb $0x0,-0x49(%ebp) 107c60: 74 0a je 107c6c rtems_filesystem_root = mt_entry->mt_fs_root; return 0; 107c62: 31 c0 xor %eax,%eax if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; } 107c64: 8d 65 f4 lea -0xc(%ebp),%esp 107c67: 5b pop %ebx 107c68: 5e pop %esi 107c69: 5f pop %edi 107c6a: c9 leave 107c6b: 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; 107c6c: 8b 3d b0 41 12 00 mov 0x1241b0,%edi 107c72: 83 c7 18 add $0x18,%edi 107c75: 8d 73 1c lea 0x1c(%ebx),%esi 107c78: b9 05 00 00 00 mov $0x5,%ecx 107c7d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return 0; 107c7f: 31 c0 xor %eax,%eax if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; } 107c81: 8d 65 f4 lea -0xc(%ebp),%esp 107c84: 5b pop %ebx 107c85: 5e pop %esi 107c86: 5f pop %edi 107c87: c9 leave 107c88: c3 ret 107c89: 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( 107c8c: 83 ec 0c sub $0xc,%esp 107c8f: 6a 01 push $0x1 107c91: 8d 75 d4 lea -0x2c(%ebp),%esi 107c94: 56 push %esi 107c95: 6a 07 push $0x7 107c97: ff 75 ac pushl -0x54(%ebp) 107c9a: ff 75 0c pushl 0xc(%ebp) 107c9d: e8 a6 f8 ff ff call 107548 107ca2: 83 c4 20 add $0x20,%esp 107ca5: 40 inc %eax 107ca6: 0f 84 df 00 00 00 je 107d8b <== NEVER TAKEN /* * Test to see if it is a directory */ if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 107cac: 83 ec 0c sub $0xc,%esp 107caf: 56 push %esi 107cb0: 8b 45 e0 mov -0x20(%ebp),%eax 107cb3: ff 50 10 call *0x10(%eax) 107cb6: 83 c4 10 add $0x10,%esp 107cb9: 48 dec %eax 107cba: 0f 85 0c 01 00 00 jne 107dcc /* * You can only mount one file system onto a single mount point. */ if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) { 107cc0: 83 ec 08 sub $0x8,%esp 107cc3: ff 75 d4 pushl -0x2c(%ebp) 107cc6: 68 98 7a 10 00 push $0x107a98 107ccb: e8 dc fd ff ff call 107aac 107cd0: 83 c4 10 add $0x10,%esp 107cd3: 84 c0 test %al,%al 107cd5: 0f 85 01 01 00 00 jne 107ddc * 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; 107cdb: 8b 45 d4 mov -0x2c(%ebp),%eax 107cde: 89 43 08 mov %eax,0x8(%ebx) mt_entry->mt_point_node.handlers = loc.handlers; 107ce1: 8b 45 dc mov -0x24(%ebp),%eax 107ce4: 89 43 10 mov %eax,0x10(%ebx) mt_entry->mt_point_node.ops = loc.ops; 107ce7: 8b 45 e0 mov -0x20(%ebp),%eax 107cea: 89 43 14 mov %eax,0x14(%ebx) mt_entry->mt_point_node.mt_entry = loc.mt_entry; 107ced: 8b 55 e4 mov -0x1c(%ebp),%edx 107cf0: 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 ) ) { 107cf3: 83 ec 0c sub $0xc,%esp 107cf6: 53 push %ebx 107cf7: ff 50 20 call *0x20(%eax) 107cfa: 83 c4 10 add $0x10,%esp 107cfd: 85 c0 test %eax,%eax 107cff: 0f 84 16 ff ff ff je 107c1b <== ALWAYS TAKEN return 0; cleanup_and_bail: free( mt_entry ); 107d05: 83 ec 0c sub $0xc,%esp 107d08: 53 push %ebx 107d09: e8 26 f9 ff ff call 107634 107d0e: 83 c4 10 add $0x10,%esp if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); 107d11: 83 ec 0c sub $0xc,%esp 107d14: 56 push %esi 107d15: e8 06 f9 ff ff call 107620 107d1a: 83 c4 10 add $0x10,%esp return -1; 107d1d: b8 ff ff ff ff mov $0xffffffff,%eax 107d22: e9 3d ff ff ff jmp 107c64 107d27: 90 nop target, filesystemtype, &target_length ); if ( !mt_entry ) rtems_set_errno_and_return_minus_one( ENOMEM ); 107d28: e8 af a0 00 00 call 111ddc <__errno> <== NOT EXECUTED 107d2d: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 107d33: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; } 107d38: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107d3b: 5b pop %ebx <== NOT EXECUTED 107d3c: 5e pop %esi <== NOT EXECUTED 107d3d: 5f pop %edi <== NOT EXECUTED 107d3e: c9 leave <== NOT EXECUTED 107d3f: 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 : "/"; 107d40: c7 45 bc 02 00 00 00 movl $0x2,-0x44(%ebp) 107d47: c7 45 ac 01 00 00 00 movl $0x1,-0x54(%ebp) 107d4e: c7 45 b0 67 fd 11 00 movl $0x11fd67,-0x50(%ebp) 107d55: e9 1b fe ff ff jmp 107b75 107d5a: 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; 107d5c: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp) 107d63: e9 36 fe ff ff jmp 107b9e /* * Get mount handler */ mount_h = rtems_filesystem_get_mount_handler( filesystemtype ); if ( !mount_h ) rtems_set_errno_and_return_minus_one( EINVAL ); 107d68: e8 6f a0 00 00 call 111ddc <__errno> 107d6d: c7 00 16 00 00 00 movl $0x16,(%eax) 107d73: b8 ff ff ff ff mov $0xffffffff,%eax if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; } 107d78: 8d 65 f4 lea -0xc(%ebp),%esp 107d7b: 5b pop %ebx 107d7c: 5e pop %esi 107d7d: 5f pop %edi 107d7e: c9 leave 107d7f: c3 ret } else { /* * Do we already have a base file system ? */ if ( !rtems_chain_is_empty( &mount_chain ) ) { errno = EINVAL; 107d80: e8 57 a0 00 00 call 111ddc <__errno> <== NOT EXECUTED 107d85: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED return 0; cleanup_and_bail: free( mt_entry ); 107d8b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107d8e: 53 push %ebx <== NOT EXECUTED 107d8f: e8 a0 f8 ff ff call 107634 <== NOT EXECUTED 107d94: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; 107d97: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 107d9c: e9 c3 fe ff ff jmp 107c64 <== NOT EXECUTED 107da1: 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 ); 107da4: 83 ec 0c sub $0xc,%esp 107da7: 53 push %ebx 107da8: 8b 45 e0 mov -0x20(%ebp),%eax 107dab: ff 50 28 call *0x28(%eax) return 0; cleanup_and_bail: free( mt_entry ); 107dae: 89 1c 24 mov %ebx,(%esp) 107db1: e8 7e f8 ff ff call 107634 if ( loc_to_free ) 107db6: 83 c4 10 add $0x10,%esp 107db9: 85 f6 test %esi,%esi 107dbb: 0f 85 50 ff ff ff jne 107d11 <== ALWAYS TAKEN rtems_filesystem_freenode( loc_to_free ); return -1; 107dc1: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 107dc6: e9 99 fe ff ff jmp 107c64 <== NOT EXECUTED 107dcb: 90 nop <== NOT EXECUTED /* * Test to see if it is a directory */ if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { errno = ENOTDIR; 107dcc: e8 0b a0 00 00 call 111ddc <__errno> 107dd1: c7 00 14 00 00 00 movl $0x14,(%eax) goto cleanup_and_bail; 107dd7: e9 29 ff ff ff jmp 107d05 /* * 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; 107ddc: e8 fb 9f 00 00 call 111ddc <__errno> 107de1: c7 00 10 00 00 00 movl $0x10,(%eax) goto cleanup_and_bail; 107de7: e9 19 ff ff ff jmp 107d05 =============================================================================== 00108120 : const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { 108120: 55 push %ebp 108121: 89 e5 mov %esp,%ebp 108123: 57 push %edi 108124: 56 push %esi 108125: 53 push %ebx 108126: 83 ec 1c sub $0x1c,%esp 108129: 8b 45 08 mov 0x8(%ebp),%eax 10812c: 89 45 e4 mov %eax,-0x1c(%ebp) 10812f: 8b 5d 0c mov 0xc(%ebp),%ebx 108132: 8b 75 10 mov 0x10(%ebp),%esi 108135: 8b 7d 14 mov 0x14(%ebp),%edi 108138: 8b 45 18 mov 0x18(%ebp),%eax 10813b: 89 45 e0 mov %eax,-0x20(%ebp) int rv = -1; if (target != NULL) { 10813e: 85 db test %ebx,%ebx 108140: 74 3f je 108181 rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO); 108142: 83 ec 08 sub $0x8,%esp 108145: 68 ff 01 00 00 push $0x1ff 10814a: 53 push %ebx 10814b: e8 08 0a 00 00 call 108b58 if (rv == 0) { 108150: 83 c4 10 add $0x10,%esp 108153: 85 c0 test %eax,%eax 108155: 74 09 je 108160 <== ALWAYS TAKEN } else { errno = EINVAL; } return rv; } 108157: 8d 65 f4 lea -0xc(%ebp),%esp 10815a: 5b pop %ebx 10815b: 5e pop %esi 10815c: 5f pop %edi 10815d: c9 leave 10815e: c3 ret 10815f: 90 nop int rv = -1; if (target != NULL) { rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO); if (rv == 0) { rv = mount( 108160: 8b 45 e0 mov -0x20(%ebp),%eax 108163: 89 45 18 mov %eax,0x18(%ebp) 108166: 89 7d 14 mov %edi,0x14(%ebp) 108169: 89 75 10 mov %esi,0x10(%ebp) 10816c: 89 5d 0c mov %ebx,0xc(%ebp) 10816f: 8b 45 e4 mov -0x1c(%ebp),%eax 108172: 89 45 08 mov %eax,0x8(%ebp) } else { errno = EINVAL; } return rv; } 108175: 8d 65 f4 lea -0xc(%ebp),%esp 108178: 5b pop %ebx 108179: 5e pop %esi 10817a: 5f pop %edi 10817b: c9 leave int rv = -1; if (target != NULL) { rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO); if (rv == 0) { rv = mount( 10817c: e9 97 00 00 00 jmp 108218 options, data ); } } else { errno = EINVAL; 108181: e8 ca a2 00 00 call 112450 <__errno> 108186: c7 00 16 00 00 00 movl $0x16,(%eax) const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { int rv = -1; 10818c: b8 ff ff ff ff mov $0xffffffff,%eax 108191: eb c4 jmp 108157 =============================================================================== 00107e50 : */ bool newlib_create_hook( rtems_tcb *current_task __attribute__((unused)), rtems_tcb *creating_task ) { 107e50: 55 push %ebp 107e51: 89 e5 mov %esp,%ebp 107e53: 57 push %edi 107e54: 56 push %esi 107e55: 53 push %ebx 107e56: 83 ec 0c sub $0xc,%esp struct _reent *ptr; if (_Thread_libc_reent == 0) 107e59: a1 84 65 12 00 mov 0x126584,%eax 107e5e: 85 c0 test %eax,%eax 107e60: 0f 84 52 02 00 00 je 1080b8 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)); 107e66: 83 ec 0c sub $0xc,%esp 107e69: 68 24 04 00 00 push $0x424 107e6e: e8 fd 5d 00 00 call 10dc70 <_Workspace_Allocate> 107e73: 89 c2 mov %eax,%edx #endif if (ptr) { 107e75: 83 c4 10 add $0x10,%esp 107e78: 85 c0 test %eax,%eax 107e7a: 0f 84 2c 02 00 00 je 1080ac _REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */ 107e80: c7 00 00 00 00 00 movl $0x0,(%eax) 107e86: 8d 98 ec 02 00 00 lea 0x2ec(%eax),%ebx 107e8c: 89 58 04 mov %ebx,0x4(%eax) 107e8f: 8d 80 54 03 00 00 lea 0x354(%eax),%eax 107e95: 89 42 08 mov %eax,0x8(%edx) 107e98: 8d 82 bc 03 00 00 lea 0x3bc(%edx),%eax 107e9e: 89 42 0c mov %eax,0xc(%edx) 107ea1: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) 107ea8: 8d 72 14 lea 0x14(%edx),%esi 107eab: 31 c0 xor %eax,%eax 107ead: b9 19 00 00 00 mov $0x19,%ecx 107eb2: 89 f7 mov %esi,%edi 107eb4: f3 aa rep stos %al,%es:(%edi) 107eb6: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) 107ebd: c7 42 34 ea fa 11 00 movl $0x11faea,0x34(%edx) 107ec4: c7 42 38 00 00 00 00 movl $0x0,0x38(%edx) 107ecb: c7 42 3c 00 00 00 00 movl $0x0,0x3c(%edx) 107ed2: c7 42 40 00 00 00 00 movl $0x0,0x40(%edx) 107ed9: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx) 107ee0: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) 107ee7: c7 42 4c 00 00 00 00 movl $0x0,0x4c(%edx) 107eee: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx) 107ef5: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) 107efc: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx) 107f03: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx) 107f0a: c6 42 60 00 movb $0x0,0x60(%edx) 107f0e: 8d 72 7c lea 0x7c(%edx),%esi 107f11: b1 24 mov $0x24,%cl 107f13: 89 f7 mov %esi,%edi 107f15: f3 aa rep stos %al,%es:(%edi) 107f17: c7 82 a0 00 00 00 00 movl $0x0,0xa0(%edx) 107f1e: 00 00 00 107f21: c7 82 a4 00 00 00 01 movl $0x1,0xa4(%edx) 107f28: 00 00 00 107f2b: c7 82 a8 00 00 00 00 movl $0x0,0xa8(%edx) 107f32: 00 00 00 107f35: 66 c7 82 ac 00 00 00 movw $0x330e,0xac(%edx) 107f3c: 0e 33 107f3e: 66 c7 82 ae 00 00 00 movw $0xabcd,0xae(%edx) 107f45: cd ab 107f47: 66 c7 82 b0 00 00 00 movw $0x1234,0xb0(%edx) 107f4e: 34 12 107f50: 66 c7 82 b2 00 00 00 movw $0xe66d,0xb2(%edx) 107f57: 6d e6 107f59: 66 c7 82 b4 00 00 00 movw $0xdeec,0xb4(%edx) 107f60: ec de 107f62: 66 c7 82 b6 00 00 00 movw $0x5,0xb6(%edx) 107f69: 05 00 107f6b: 66 c7 82 b8 00 00 00 movw $0xb,0xb8(%edx) 107f72: 0b 00 107f74: c7 82 bc 00 00 00 00 movl $0x0,0xbc(%edx) 107f7b: 00 00 00 107f7e: c7 82 c0 00 00 00 00 movl $0x0,0xc0(%edx) 107f85: 00 00 00 107f88: c7 82 c4 00 00 00 00 movl $0x0,0xc4(%edx) 107f8f: 00 00 00 107f92: c7 82 c8 00 00 00 00 movl $0x0,0xc8(%edx) 107f99: 00 00 00 107f9c: c7 82 cc 00 00 00 00 movl $0x0,0xcc(%edx) 107fa3: 00 00 00 107fa6: c7 82 d0 00 00 00 00 movl $0x0,0xd0(%edx) 107fad: 00 00 00 107fb0: c7 82 f8 00 00 00 00 movl $0x0,0xf8(%edx) 107fb7: 00 00 00 107fba: c7 82 fc 00 00 00 00 movl $0x0,0xfc(%edx) 107fc1: 00 00 00 107fc4: c7 82 00 01 00 00 00 movl $0x0,0x100(%edx) 107fcb: 00 00 00 107fce: c7 82 04 01 00 00 00 movl $0x0,0x104(%edx) 107fd5: 00 00 00 107fd8: c7 82 08 01 00 00 00 movl $0x0,0x108(%edx) 107fdf: 00 00 00 107fe2: c7 82 0c 01 00 00 00 movl $0x0,0x10c(%edx) 107fe9: 00 00 00 107fec: c7 82 10 01 00 00 00 movl $0x0,0x110(%edx) 107ff3: 00 00 00 107ff6: c7 82 14 01 00 00 00 movl $0x0,0x114(%edx) 107ffd: 00 00 00 108000: c7 82 18 01 00 00 00 movl $0x0,0x118(%edx) 108007: 00 00 00 10800a: c7 82 1c 01 00 00 00 movl $0x0,0x11c(%edx) 108011: 00 00 00 108014: c6 82 d4 00 00 00 00 movb $0x0,0xd4(%edx) 10801b: c6 82 dc 00 00 00 00 movb $0x0,0xdc(%edx) 108022: c7 82 f4 00 00 00 00 movl $0x0,0xf4(%edx) 108029: 00 00 00 10802c: c7 82 48 01 00 00 00 movl $0x0,0x148(%edx) 108033: 00 00 00 108036: c7 82 4c 01 00 00 00 movl $0x0,0x14c(%edx) 10803d: 00 00 00 108040: c7 82 50 01 00 00 00 movl $0x0,0x150(%edx) 108047: 00 00 00 10804a: c7 82 54 01 00 00 00 movl $0x0,0x154(%edx) 108051: 00 00 00 108054: c7 82 d4 02 00 00 00 movl $0x0,0x2d4(%edx) 10805b: 00 00 00 10805e: c7 82 d4 01 00 00 00 movl $0x0,0x1d4(%edx) 108065: 00 00 00 108068: c7 82 dc 02 00 00 00 movl $0x0,0x2dc(%edx) 10806f: 00 00 00 108072: c7 82 e0 02 00 00 00 movl $0x0,0x2e0(%edx) 108079: 00 00 00 10807c: c7 82 e4 02 00 00 00 movl $0x0,0x2e4(%edx) 108083: 00 00 00 108086: c7 82 e8 02 00 00 00 movl $0x0,0x2e8(%edx) 10808d: 00 00 00 108090: 66 b9 38 01 mov $0x138,%cx 108094: 89 df mov %ebx,%edi 108096: f3 aa rep stos %al,%es:(%edi) creating_task->libc_reent = ptr; 108098: 8b 45 0c mov 0xc(%ebp),%eax 10809b: 89 90 e0 00 00 00 mov %edx,0xe0(%eax) return TRUE; 1080a1: b0 01 mov $0x1,%al } return FALSE; } 1080a3: 8d 65 f4 lea -0xc(%ebp),%esp 1080a6: 5b pop %ebx 1080a7: 5e pop %esi 1080a8: 5f pop %edi 1080a9: c9 leave 1080aa: c3 ret 1080ab: 90 nop _REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */ creating_task->libc_reent = ptr; return TRUE; } return FALSE; 1080ac: 31 c0 xor %eax,%eax } 1080ae: 8d 65 f4 lea -0xc(%ebp),%esp 1080b1: 5b pop %ebx 1080b2: 5e pop %esi 1080b3: 5f pop %edi 1080b4: c9 leave 1080b5: c3 ret 1080b6: 66 90 xchg %ax,%ax { struct _reent *ptr; if (_Thread_libc_reent == 0) { _REENT = _global_impure_ptr; 1080b8: a1 60 07 12 00 mov 0x120760,%eax 1080bd: a3 60 42 12 00 mov %eax,0x124260 RTEMS_INLINE_ROUTINE void _Thread_Set_libc_reent ( struct _reent **libc_reent ) { _Thread_libc_reent = libc_reent; 1080c2: c7 05 84 65 12 00 60 movl $0x124260,0x126584 1080c9: 42 12 00 1080cc: e9 95 fd ff ff jmp 107e66 =============================================================================== 001080d4 : void newlib_delete_hook( rtems_tcb *current_task, rtems_tcb *deleted_task ) { 1080d4: 55 push %ebp 1080d5: 89 e5 mov %esp,%ebp 1080d7: 57 push %edi 1080d8: 56 push %esi 1080d9: 53 push %ebx 1080da: 83 ec 0c sub $0xc,%esp 1080dd: 8b 7d 08 mov 0x8(%ebp),%edi 1080e0: 8b 5d 0c mov 0xc(%ebp),%ebx /* * The reentrancy structure was allocated by newlib using malloc() */ if (current_task == deleted_task) { 1080e3: 39 df cmp %ebx,%edi 1080e5: 74 55 je 10813c ptr = _REENT; } else { ptr = deleted_task->libc_reent; 1080e7: 8b b3 e0 00 00 00 mov 0xe0(%ebx),%esi } if (ptr && ptr != _global_impure_ptr) { 1080ed: 85 f6 test %esi,%esi 1080ef: 74 21 je 108112 <== NEVER TAKEN 1080f1: 3b 35 60 07 12 00 cmp 0x120760,%esi 1080f7: 74 19 je 108112 _reclaim_reent(ptr); */ /* * Just in case there are some buffers lying around. */ _fwalk(ptr, newlib_free_buffers); 1080f9: 83 ec 08 sub $0x8,%esp 1080fc: 68 f4 7d 10 00 push $0x107df4 108101: 56 push %esi 108102: e8 bd a4 00 00 call 1125c4 <_fwalk> #if REENT_MALLOCED free(ptr); #else _Workspace_Free(ptr); 108107: 89 34 24 mov %esi,(%esp) 10810a: e8 7d 5b 00 00 call 10dc8c <_Workspace_Free> 10810f: 83 c4 10 add $0x10,%esp #endif } deleted_task->libc_reent = NULL; 108112: c7 83 e0 00 00 00 00 movl $0x0,0xe0(%ebx) 108119: 00 00 00 /* * Require the switch back to another task to install its own */ if ( current_task == deleted_task ) { 10811c: 39 df cmp %ebx,%edi 10811e: 74 08 je 108128 _REENT = 0; } } 108120: 8d 65 f4 lea -0xc(%ebp),%esp 108123: 5b pop %ebx 108124: 5e pop %esi 108125: 5f pop %edi 108126: c9 leave 108127: c3 ret /* * Require the switch back to another task to install its own */ if ( current_task == deleted_task ) { _REENT = 0; 108128: c7 05 60 42 12 00 00 movl $0x0,0x124260 10812f: 00 00 00 } } 108132: 8d 65 f4 lea -0xc(%ebp),%esp 108135: 5b pop %ebx 108136: 5e pop %esi 108137: 5f pop %edi 108138: c9 leave 108139: c3 ret 10813a: 66 90 xchg %ax,%ax /* * The reentrancy structure was allocated by newlib using malloc() */ if (current_task == deleted_task) { ptr = _REENT; 10813c: 8b 35 60 42 12 00 mov 0x124260,%esi 108142: eb a9 jmp 1080ed =============================================================================== 00107df4 : */ int newlib_free_buffers( FILE *fp ) { 107df4: 55 push %ebp 107df5: 89 e5 mov %esp,%ebp 107df7: 53 push %ebx 107df8: 83 ec 10 sub $0x10,%esp 107dfb: 8b 5d 08 mov 0x8(%ebp),%ebx switch ( fileno(fp) ) { 107dfe: 53 push %ebx 107dff: e8 ac a3 00 00 call 1121b0 107e04: 83 c4 10 add $0x10,%esp 107e07: 83 f8 02 cmp $0x2,%eax 107e0a: 76 14 jbe 107e20 <== ALWAYS TAKEN fp->_flags &= ~__SMBF; fp->_bf._base = fp->_p = (unsigned char *) NULL; } break; default: fclose(fp); 107e0c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107e0f: 53 push %ebx <== NOT EXECUTED 107e10: e8 1f a1 00 00 call 111f34 <== NOT EXECUTED 107e15: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 107e18: 31 c0 xor %eax,%eax 107e1a: 8b 5d fc mov -0x4(%ebp),%ebx 107e1d: c9 leave 107e1e: c3 ret 107e1f: 90 nop { switch ( fileno(fp) ) { case 0: case 1: case 2: if (fp->_flags & __SMBF) { 107e20: f6 43 0c 80 testb $0x80,0xc(%ebx) 107e24: 74 f2 je 107e18 <== ALWAYS TAKEN free( fp->_bf._base ); 107e26: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107e29: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 107e2c: e8 03 f8 ff ff call 107634 <== NOT EXECUTED fp->_flags &= ~__SMBF; 107e31: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) <== NOT EXECUTED fp->_bf._base = fp->_p = (unsigned char *) NULL; 107e37: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED 107e3d: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED 107e44: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; default: fclose(fp); } return 0; } 107e47: 31 c0 xor %eax,%eax <== NOT EXECUTED 107e49: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 107e4c: c9 leave <== NOT EXECUTED 107e4d: c3 ret <== NOT EXECUTED =============================================================================== 00107264 : rtems_device_driver null_initialize( rtems_device_major_number major, rtems_device_minor_number minor __attribute__((unused)), void *pargp __attribute__((unused)) ) { 107264: 55 push %ebp 107265: 89 e5 mov %esp,%ebp 107267: 53 push %ebx 107268: 83 ec 04 sub $0x4,%esp 10726b: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_device_driver status; if ( !initialized ) { 10726e: 80 3d 80 40 12 00 00 cmpb $0x0,0x124080 107275: 74 09 je 107280 NULL_major = major; } return RTEMS_SUCCESSFUL; } 107277: 31 c0 xor %eax,%eax 107279: 8b 5d fc mov -0x4(%ebp),%ebx 10727c: c9 leave 10727d: c3 ret 10727e: 66 90 xchg %ax,%ax ) { rtems_device_driver status; if ( !initialized ) { initialized = 1; 107280: c6 05 80 40 12 00 01 movb $0x1,0x124080 status = rtems_io_register_name( 107287: 50 push %eax 107288: 6a 00 push $0x0 10728a: 53 push %ebx 10728b: 68 37 c5 11 00 push $0x11c537 107290: e8 7b 01 00 00 call 107410 "/dev/null", major, (rtems_device_minor_number) 0 ); if (status != RTEMS_SUCCESSFUL) 107295: 83 c4 10 add $0x10,%esp 107298: 85 c0 test %eax,%eax 10729a: 75 0d jne 1072a9 rtems_fatal_error_occurred(status); NULL_major = major; 10729c: 89 1d c0 43 12 00 mov %ebx,0x1243c0 } return RTEMS_SUCCESSFUL; } 1072a2: 31 c0 xor %eax,%eax 1072a4: 8b 5d fc mov -0x4(%ebp),%ebx 1072a7: c9 leave 1072a8: c3 ret major, (rtems_device_minor_number) 0 ); if (status != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred(status); 1072a9: 83 ec 0c sub $0xc,%esp 1072ac: 50 push %eax 1072ad: e8 22 41 00 00 call 10b3d4 =============================================================================== 001081a4 : int open( const char *pathname, int flags, ... ) { 1081a4: 55 push %ebp 1081a5: 89 e5 mov %esp,%ebp 1081a7: 57 push %edi 1081a8: 56 push %esi 1081a9: 53 push %ebx 1081aa: 83 ec 4c sub $0x4c,%esp /* * Set the Evaluation flags */ eval_flags = 0; status = flags + 1; 1081ad: 8b 45 0c mov 0xc(%ebp),%eax 1081b0: 40 inc %eax if ( ( status & _FREAD ) == _FREAD ) 1081b1: 89 c3 mov %eax,%ebx 1081b3: 83 e3 01 and $0x1,%ebx eval_flags |= RTEMS_LIBIO_PERMS_READ; 1081b6: f7 db neg %ebx 1081b8: 83 e3 04 and $0x4,%ebx if ( ( status & _FWRITE ) == _FWRITE ) 1081bb: a8 02 test $0x2,%al 1081bd: 74 03 je 1081c2 eval_flags |= RTEMS_LIBIO_PERMS_WRITE; 1081bf: 83 cb 02 or $0x2,%ebx va_start(ap, flags); mode = va_arg( ap, int ); 1081c2: 8b 45 10 mov 0x10(%ebp),%eax 1081c5: 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(); 1081c8: e8 a7 70 00 00 call 10f274 1081cd: 89 c2 mov %eax,%edx if ( iop == 0 ) { 1081cf: 85 c0 test %eax,%eax 1081d1: 0f 84 c5 00 00 00 je 10829c } /* * See if the file exists. */ status = rtems_filesystem_evaluate_path( 1081d7: 31 f6 xor %esi,%esi 1081d9: b9 ff ff ff ff mov $0xffffffff,%ecx 1081de: 8b 7d 08 mov 0x8(%ebp),%edi 1081e1: 89 f0 mov %esi,%eax 1081e3: f2 ae repnz scas %es:(%edi),%al 1081e5: f7 d1 not %ecx 1081e7: 49 dec %ecx 1081e8: 83 ec 0c sub $0xc,%esp 1081eb: 6a 01 push $0x1 1081ed: 8d 45 d4 lea -0x2c(%ebp),%eax 1081f0: 89 45 b4 mov %eax,-0x4c(%ebp) 1081f3: 50 push %eax 1081f4: 53 push %ebx 1081f5: 51 push %ecx 1081f6: ff 75 08 pushl 0x8(%ebp) 1081f9: 89 55 c0 mov %edx,-0x40(%ebp) 1081fc: e8 47 f3 ff ff call 107548 108201: 89 c3 mov %eax,%ebx pathname, strlen( pathname ), eval_flags, &loc, true ); if ( status == -1 ) { 108203: 83 c4 20 add $0x20,%esp 108206: 83 f8 ff cmp $0xffffffff,%eax 108209: 8b 55 c0 mov -0x40(%ebp),%edx 10820c: 0f 84 de 00 00 00 je 1082f0 if ( status != 0 ) { /* The file did not exist */ rc = EACCES; goto done; } } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) { 108212: 8b 45 0c mov 0xc(%ebp),%eax 108215: 25 00 0a 00 00 and $0xa00,%eax 10821a: 3d 00 0a 00 00 cmp $0xa00,%eax 10821f: 0f 84 8b 00 00 00 je 1082b0 /* * Fill in the file control block based on the loc structure * returned by successful path evaluation. */ iop->flags |= rtems_libio_fcntl_flags( flags ); 108225: 8b 5a 14 mov 0x14(%edx),%ebx 108228: 83 ec 0c sub $0xc,%esp 10822b: ff 75 0c pushl 0xc(%ebp) 10822e: 89 55 c0 mov %edx,-0x40(%ebp) 108231: e8 c2 6f 00 00 call 10f1f8 108236: 09 d8 or %ebx,%eax 108238: 8b 55 c0 mov -0x40(%ebp),%edx 10823b: 89 42 14 mov %eax,0x14(%edx) iop->pathinfo = loc; 10823e: 8d 7a 18 lea 0x18(%edx),%edi 108241: b9 05 00 00 00 mov $0x5,%ecx 108246: 8b 75 b4 mov -0x4c(%ebp),%esi 108249: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode ); 10824b: 8b 42 20 mov 0x20(%edx),%eax 10824e: ff 75 c4 pushl -0x3c(%ebp) 108251: ff 75 0c pushl 0xc(%ebp) 108254: ff 75 08 pushl 0x8(%ebp) 108257: 52 push %edx 108258: ff 10 call *(%eax) if ( rc ) { 10825a: 83 c4 20 add $0x20,%esp 10825d: 85 c0 test %eax,%eax 10825f: 8b 55 c0 mov -0x40(%ebp),%edx 108262: 75 78 jne 1082dc } /* * Optionally truncate the file. */ if ( (flags & O_TRUNC) == O_TRUNC ) { 108264: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 10826b: 0f 85 9f 00 00 00 jne 108310 if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); rtems_set_errno_and_return_minus_one( rc ); } return iop - rtems_libio_iops; 108271: 2b 15 80 63 12 00 sub 0x126380,%edx 108277: c1 fa 03 sar $0x3,%edx 10827a: 8d 04 d2 lea (%edx,%edx,8),%eax 10827d: 8d 04 c2 lea (%edx,%eax,8),%eax 108280: 8d 04 c2 lea (%edx,%eax,8),%eax 108283: 8d 04 c2 lea (%edx,%eax,8),%eax 108286: 89 c1 mov %eax,%ecx 108288: c1 e1 0f shl $0xf,%ecx 10828b: 01 c8 add %ecx,%eax 10828d: 8d 04 c2 lea (%edx,%eax,8),%eax 108290: f7 d8 neg %eax } 108292: 8d 65 f4 lea -0xc(%ebp),%esp 108295: 5b pop %ebx 108296: 5e pop %esi 108297: 5f pop %edi 108298: c9 leave 108299: c3 ret 10829a: 66 90 xchg %ax,%ax */ /* allocate a file control block */ iop = rtems_libio_allocate(); if ( iop == 0 ) { rc = ENFILE; 10829c: 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 ); 1082a1: e8 36 9b 00 00 call 111ddc <__errno> 1082a6: 89 18 mov %ebx,(%eax) 1082a8: b8 ff ff ff ff mov $0xffffffff,%eax 1082ad: eb e3 jmp 108292 1082af: 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; 1082b0: 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; 1082b3: bb 11 00 00 00 mov $0x11,%ebx */ done: va_end(ap); if ( rc ) { if ( iop ) 1082b8: 85 d2 test %edx,%edx 1082ba: 74 0c je 1082c8 rtems_libio_free( iop ); 1082bc: 83 ec 0c sub $0xc,%esp 1082bf: 52 push %edx 1082c0: e8 53 70 00 00 call 10f318 1082c5: 83 c4 10 add $0x10,%esp if ( loc_to_free ) 1082c8: 85 f6 test %esi,%esi 1082ca: 74 d5 je 1082a1 rtems_filesystem_freenode( loc_to_free ); 1082cc: 83 ec 0c sub $0xc,%esp 1082cf: 56 push %esi 1082d0: e8 4b f3 ff ff call 107620 1082d5: 83 c4 10 add $0x10,%esp 1082d8: eb c7 jmp 1082a1 1082da: 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; 1082dc: e8 fb 9a 00 00 call 111ddc <__errno> 1082e1: 8b 18 mov (%eax),%ebx rc = EEXIST; loc_to_free = &loc; goto done; } loc_to_free = &loc; 1082e3: 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; 1082e6: 8b 55 c0 mov -0x40(%ebp),%edx * Single exit and clean up path. */ done: va_end(ap); if ( rc ) { 1082e9: 85 db test %ebx,%ebx 1082eb: 74 84 je 108271 <== NEVER TAKEN 1082ed: eb c9 jmp 1082b8 1082ef: 90 nop */ status = rtems_filesystem_evaluate_path( pathname, strlen( pathname ), eval_flags, &loc, true ); if ( status == -1 ) { if ( errno != ENOENT ) { 1082f0: e8 e7 9a 00 00 call 111ddc <__errno> 1082f5: 83 38 02 cmpl $0x2,(%eax) 1082f8: 8b 55 c0 mov -0x40(%ebp),%edx 1082fb: 0f 84 9b 00 00 00 je 10839c } /* Create the node for the new regular file */ rc = mknod( pathname, S_IFREG | mode, 0LL ); if ( rc ) { rc = errno; 108301: e8 d6 9a 00 00 call 111ddc <__errno> 108306: 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; 108308: 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; 10830a: 8b 55 c0 mov -0x40(%ebp),%edx 10830d: eb da jmp 1082e9 10830f: 90 nop /* * Optionally truncate the file. */ if ( (flags & O_TRUNC) == O_TRUNC ) { rc = ftruncate( iop - rtems_libio_iops, 0 ); 108310: 51 push %ecx 108311: 6a 00 push $0x0 108313: 6a 00 push $0x0 108315: 89 d0 mov %edx,%eax 108317: 2b 05 80 63 12 00 sub 0x126380,%eax 10831d: c1 f8 03 sar $0x3,%eax 108320: 8d 0c c0 lea (%eax,%eax,8),%ecx 108323: 8d 0c c8 lea (%eax,%ecx,8),%ecx 108326: 8d 0c c8 lea (%eax,%ecx,8),%ecx 108329: 8d 0c c8 lea (%eax,%ecx,8),%ecx 10832c: 89 cb mov %ecx,%ebx 10832e: c1 e3 0f shl $0xf,%ebx 108331: 01 d9 add %ebx,%ecx 108333: 8d 04 c8 lea (%eax,%ecx,8),%eax 108336: f7 d8 neg %eax 108338: 50 push %eax 108339: 89 55 c0 mov %edx,-0x40(%ebp) 10833c: e8 b3 6d 00 00 call 10f0f4 108341: 89 c3 mov %eax,%ebx if ( rc ) { 108343: 83 c4 10 add $0x10,%esp 108346: 85 c0 test %eax,%eax 108348: 8b 55 c0 mov -0x40(%ebp),%edx 10834b: 0f 84 20 ff ff ff je 108271 if(errno) rc = errno; 108351: e8 86 9a 00 00 call 111ddc <__errno> 108356: 8b 00 mov (%eax),%eax 108358: 85 c0 test %eax,%eax 10835a: 8b 55 c0 mov -0x40(%ebp),%edx 10835d: 0f 85 b2 00 00 00 jne 108415 <== ALWAYS TAKEN close( iop - rtems_libio_iops ); 108363: 83 ec 0c sub $0xc,%esp 108366: 2b 15 80 63 12 00 sub 0x126380,%edx 10836c: c1 fa 03 sar $0x3,%edx 10836f: 8d 04 d2 lea (%edx,%edx,8),%eax 108372: 8d 04 c2 lea (%edx,%eax,8),%eax 108375: 8d 04 c2 lea (%edx,%eax,8),%eax 108378: 8d 04 c2 lea (%edx,%eax,8),%eax 10837b: 89 c1 mov %eax,%ecx 10837d: c1 e1 0f shl $0xf,%ecx 108380: 01 c8 add %ecx,%eax 108382: 8d 04 c2 lea (%edx,%eax,8),%eax 108385: f7 d8 neg %eax 108387: 50 push %eax 108388: e8 e7 6c 00 00 call 10f074 10838d: 83 c4 10 add $0x10,%esp /* those are released by close(): */ iop = 0; loc_to_free = NULL; 108390: 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; 108392: 31 d2 xor %edx,%edx 108394: e9 50 ff ff ff jmp 1082e9 108399: 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) ) { 10839c: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 1083a3: 75 0f jne 1083b4 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; 1083a5: 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; 1083a7: bb 02 00 00 00 mov $0x2,%ebx 1083ac: e9 07 ff ff ff jmp 1082b8 1083b1: 8d 76 00 lea 0x0(%esi),%esi goto done; } /* Create the node for the new regular file */ rc = mknod( pathname, S_IFREG | mode, 0LL ); 1083b4: 6a 00 push $0x0 1083b6: 6a 00 push $0x0 1083b8: 8b 45 c4 mov -0x3c(%ebp),%eax 1083bb: 80 cc 80 or $0x80,%ah 1083be: 50 push %eax 1083bf: ff 75 08 pushl 0x8(%ebp) 1083c2: 89 55 c0 mov %edx,-0x40(%ebp) 1083c5: e8 02 f6 ff ff call 1079cc if ( rc ) { 1083ca: 83 c4 10 add $0x10,%esp 1083cd: 85 c0 test %eax,%eax 1083cf: 8b 55 c0 mov -0x40(%ebp),%edx 1083d2: 0f 85 29 ff ff ff jne 108301 <== 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( 1083d8: 89 d9 mov %ebx,%ecx 1083da: 8b 7d 08 mov 0x8(%ebp),%edi 1083dd: 89 f0 mov %esi,%eax 1083df: f2 ae repnz scas %es:(%edi),%al 1083e1: f7 d1 not %ecx 1083e3: 49 dec %ecx 1083e4: 83 ec 0c sub $0xc,%esp 1083e7: 6a 01 push $0x1 1083e9: 8d 45 d4 lea -0x2c(%ebp),%eax 1083ec: 50 push %eax 1083ed: 6a 00 push $0x0 1083ef: 51 push %ecx 1083f0: ff 75 08 pushl 0x8(%ebp) 1083f3: 89 55 c0 mov %edx,-0x40(%ebp) 1083f6: e8 4d f1 ff ff call 107548 pathname, strlen( pathname ), 0x0, &loc, true ); if ( status != 0 ) { /* The file did not exist */ 1083fb: 83 c4 20 add $0x20,%esp 1083fe: 85 c0 test %eax,%eax 108400: 8b 55 c0 mov -0x40(%ebp),%edx 108403: 0f 84 1c fe ff ff je 108225 <== 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; 108409: 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; 10840b: bb 0d 00 00 00 mov $0xd,%ebx <== NOT EXECUTED 108410: e9 a3 fe ff ff jmp 1082b8 <== 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; 108415: e8 c2 99 00 00 call 111ddc <__errno> 10841a: 8b 18 mov (%eax),%ebx 10841c: 8b 55 c0 mov -0x40(%ebp),%edx 10841f: e9 3f ff ff ff jmp 108363 =============================================================================== 001091a8 : /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) { 1091a8: 55 push %ebp 1091a9: 89 e5 mov %esp,%ebp 1091ab: 56 push %esi 1091ac: 53 push %ebx 1091ad: 83 ec 10 sub $0x10,%esp 1091b0: 88 45 f4 mov %al,-0xc(%ebp) int i; if (tty->termios.c_oflag & OPOST) { 1091b3: 8b 4a 34 mov 0x34(%edx),%ecx 1091b6: f6 c1 01 test $0x1,%cl 1091b9: 74 31 je 1091ec <== NEVER TAKEN switch (c) { 1091bb: 3c 09 cmp $0x9,%al 1091bd: 0f 84 b1 00 00 00 je 109274 1091c3: 76 3f jbe 109204 <== NEVER TAKEN 1091c5: 3c 0a cmp $0xa,%al 1091c7: 74 4f je 109218 1091c9: 3c 0d cmp $0xd,%al 1091cb: 74 7f je 10924c <== NEVER TAKEN if (tty->column > 0) tty->column--; break; default: if (tty->termios.c_oflag & OLCUC) 1091cd: 83 e1 02 and $0x2,%ecx 1091d0: 0f 85 c6 00 00 00 jne 10929c <== NEVER TAKEN 1091d6: 8b 0d 54 42 12 00 mov 0x124254,%ecx c = toupper(c); if (!iscntrl(c)) 1091dc: 0f b6 c0 movzbl %al,%eax 1091df: f6 44 01 01 20 testb $0x20,0x1(%ecx,%eax,1) 1091e4: 75 06 jne 1091ec <== NEVER TAKEN tty->column++; 1091e6: ff 42 28 incl 0x28(%edx) 1091e9: 8d 76 00 lea 0x0(%esi),%esi break; } } rtems_termios_puts (&c, 1, tty); 1091ec: 53 push %ebx 1091ed: 52 push %edx 1091ee: 6a 01 push $0x1 1091f0: 8d 45 f4 lea -0xc(%ebp),%eax 1091f3: 50 push %eax 1091f4: e8 7b fe ff ff call 109074 1091f9: 83 c4 10 add $0x10,%esp } 1091fc: 8d 65 f8 lea -0x8(%ebp),%esp 1091ff: 5b pop %ebx 109200: 5e pop %esi 109201: c9 leave 109202: c3 ret 109203: 90 nop oproc (unsigned char c, struct rtems_termios_tty *tty) { int i; if (tty->termios.c_oflag & OPOST) { switch (c) { 109204: 3c 08 cmp $0x8,%al <== NOT EXECUTED 109206: 75 c5 jne 1091cd <== NOT EXECUTED } tty->column += i; break; case '\b': if (tty->column > 0) 109208: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 10920b: 85 c0 test %eax,%eax <== NOT EXECUTED 10920d: 7e dd jle 1091ec <== NOT EXECUTED tty->column--; 10920f: 48 dec %eax <== NOT EXECUTED 109210: 89 42 28 mov %eax,0x28(%edx) <== NOT EXECUTED 109213: eb d7 jmp 1091ec <== NOT EXECUTED 109215: 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) 109218: f6 c1 20 test $0x20,%cl 10921b: 74 07 je 109224 <== ALWAYS TAKEN tty->column = 0; 10921d: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) <== NOT EXECUTED if (tty->termios.c_oflag & ONLCR) { 109224: 83 e1 04 and $0x4,%ecx 109227: 74 c3 je 1091ec <== NEVER TAKEN rtems_termios_puts ("\r", 1, tty); 109229: 51 push %ecx 10922a: 52 push %edx 10922b: 6a 01 push $0x1 10922d: 68 64 fe 11 00 push $0x11fe64 109232: 89 55 f0 mov %edx,-0x10(%ebp) 109235: e8 3a fe ff ff call 109074 tty->column = 0; 10923a: 8b 55 f0 mov -0x10(%ebp),%edx 10923d: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) 109244: 83 c4 10 add $0x10,%esp 109247: eb a3 jmp 1091ec 109249: 8d 76 00 lea 0x0(%esi),%esi } break; case '\r': if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0)) 10924c: f6 c1 10 test $0x10,%cl <== NOT EXECUTED 10924f: 74 07 je 109258 <== NOT EXECUTED 109251: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 109254: 85 c0 test %eax,%eax <== NOT EXECUTED 109256: 74 a4 je 1091fc <== NOT EXECUTED return; if (tty->termios.c_oflag & OCRNL) { 109258: f6 c1 08 test $0x8,%cl <== NOT EXECUTED 10925b: 74 09 je 109266 <== NOT EXECUTED c = '\n'; 10925d: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED if (tty->termios.c_oflag & ONLRET) 109261: 83 e1 20 and $0x20,%ecx <== NOT EXECUTED 109264: 74 86 je 1091ec <== NOT EXECUTED tty->column = 0; break; } tty->column = 0; 109266: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) <== NOT EXECUTED break; 10926d: e9 7a ff ff ff jmp 1091ec <== NOT EXECUTED 109272: 66 90 xchg %ax,%ax <== NOT EXECUTED case '\t': i = 8 - (tty->column & 7); 109274: 8b 5a 28 mov 0x28(%edx),%ebx 109277: 89 de mov %ebx,%esi 109279: 83 e6 07 and $0x7,%esi 10927c: b8 08 00 00 00 mov $0x8,%eax 109281: 29 f0 sub %esi,%eax if ((tty->termios.c_oflag & TABDLY) == XTABS) { 109283: 81 e1 00 18 00 00 and $0x1800,%ecx 109289: 81 f9 00 18 00 00 cmp $0x1800,%ecx 10928f: 74 37 je 1092c8 <== ALWAYS TAKEN tty->column += i; rtems_termios_puts ( " ", i, tty); return; } tty->column += i; 109291: 01 d8 add %ebx,%eax <== NOT EXECUTED 109293: 89 42 28 mov %eax,0x28(%edx) <== NOT EXECUTED break; 109296: e9 51 ff ff ff jmp 1091ec <== NOT EXECUTED 10929b: 90 nop <== NOT EXECUTED tty->column--; break; default: if (tty->termios.c_oflag & OLCUC) c = toupper(c); 10929c: 8b 0d 54 42 12 00 mov 0x124254,%ecx <== NOT EXECUTED 1092a2: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 1092a5: 0f be 5c 01 01 movsbl 0x1(%ecx,%eax,1),%ebx <== NOT EXECUTED 1092aa: 83 e3 03 and $0x3,%ebx <== NOT EXECUTED 1092ad: 83 fb 02 cmp $0x2,%ebx <== NOT EXECUTED 1092b0: 74 0e je 1092c0 <== NOT EXECUTED 1092b2: 89 c3 mov %eax,%ebx <== NOT EXECUTED 1092b4: 88 d8 mov %bl,%al <== NOT EXECUTED 1092b6: 88 5d f4 mov %bl,-0xc(%ebp) <== NOT EXECUTED 1092b9: e9 1e ff ff ff jmp 1091dc <== NOT EXECUTED 1092be: 66 90 xchg %ax,%ax <== NOT EXECUTED 1092c0: 8d 58 e0 lea -0x20(%eax),%ebx <== NOT EXECUTED 1092c3: eb ef jmp 1092b4 <== NOT EXECUTED 1092c5: 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; 1092c8: 8d 1c 18 lea (%eax,%ebx,1),%ebx 1092cb: 89 5a 28 mov %ebx,0x28(%edx) rtems_termios_puts ( " ", i, tty); 1092ce: 56 push %esi 1092cf: 52 push %edx 1092d0: 50 push %eax 1092d1: 68 fc f9 11 00 push $0x11f9fc 1092d6: e8 99 fd ff ff call 109074 return; 1092db: 83 c4 10 add $0x10,%esp 1092de: e9 19 ff ff ff jmp 1091fc =============================================================================== 001095e0 : long pathconf( const char *path, int name ) { 1095e0: 55 push %ebp 1095e1: 89 e5 mov %esp,%ebp 1095e3: 56 push %esi 1095e4: 53 push %ebx int status; int fd; fd = open( path, O_RDONLY ); 1095e5: 83 ec 08 sub $0x8,%esp 1095e8: 6a 00 push $0x0 1095ea: ff 75 08 pushl 0x8(%ebp) 1095ed: e8 4e fd ff ff call 109340 1095f2: 89 c3 mov %eax,%ebx if ( fd == -1 ) 1095f4: 83 c4 10 add $0x10,%esp 1095f7: 83 f8 ff cmp $0xffffffff,%eax 1095fa: 74 24 je 109620 return -1; status = fpathconf( fd, name ); 1095fc: 83 ec 08 sub $0x8,%esp 1095ff: ff 75 0c pushl 0xc(%ebp) 109602: 50 push %eax 109603: e8 98 ec ff ff call 1082a0 109608: 89 c6 mov %eax,%esi (void) close( fd ); 10960a: 89 1c 24 mov %ebx,(%esp) 10960d: e8 2e e8 ff ff call 107e40 return status; 109612: 83 c4 10 add $0x10,%esp 109615: 89 f0 mov %esi,%eax } 109617: 8d 65 f8 lea -0x8(%ebp),%esp 10961a: 5b pop %ebx 10961b: 5e pop %esi 10961c: c9 leave 10961d: c3 ret 10961e: 66 90 xchg %ax,%ax int status; int fd; fd = open( path, O_RDONLY ); if ( fd == -1 ) return -1; 109620: b8 ff ff ff ff mov $0xffffffff,%eax status = fpathconf( fd, name ); (void) close( fd ); return status; } 109625: 8d 65 f8 lea -0x8(%ebp),%esp 109628: 5b pop %ebx 109629: 5e pop %esi 10962a: c9 leave 10962b: c3 ret =============================================================================== 00110118 : * Called by pipe() to create an anonymous pipe. */ int pipe_create( int filsdes[2] ) { 110118: 55 push %ebp 110119: 89 e5 mov %esp,%ebp 11011b: 57 push %edi 11011c: 56 push %esi 11011d: 53 push %ebx 11011e: 83 ec 24 sub $0x24,%esp rtems_libio_t *iop; int err = 0; if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0) 110121: 68 ff 01 00 00 push $0x1ff 110126: 68 0c 1a 12 00 push $0x121a0c 11012b: e8 ec 16 00 00 call 11181c 110130: 83 c4 10 add $0x10,%esp 110133: 85 c0 test %eax,%eax 110135: 74 0d je 110144 <== ALWAYS TAKEN return -1; 110137: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED unlink(fifopath); } if(err != 0) rtems_set_errno_and_return_minus_one(err); return 0; } 11013c: 8d 65 f4 lea -0xc(%ebp),%esp 11013f: 5b pop %ebx 110140: 5e pop %esi 110141: 5f pop %edi 110142: c9 leave 110143: 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); 110144: 8d 5d d9 lea -0x27(%ebp),%ebx 110147: be 11 1a 12 00 mov $0x121a11,%esi 11014c: b9 0a 00 00 00 mov $0xa,%ecx 110151: 89 df mov %ebx,%edi 110153: f3 a4 rep movsb %ds:(%esi),%es:(%edi) sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); 110155: 0f b7 05 d4 70 12 00 movzwl 0x1270d4,%eax 11015c: 8d 50 01 lea 0x1(%eax),%edx 11015f: 66 89 15 d4 70 12 00 mov %dx,0x1270d4 110166: 51 push %ecx 110167: 50 push %eax 110168: 68 1c 1a 12 00 push $0x121a1c 11016d: 8d 45 e3 lea -0x1d(%ebp),%eax 110170: 50 push %eax 110171: e8 f6 3b 00 00 call 113d6c /* Try creating FIFO file until find an available file name */ while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) { 110176: 58 pop %eax 110177: 5a pop %edx 110178: 68 80 01 00 00 push $0x180 11017d: 53 push %ebx 11017e: e8 e1 13 00 00 call 111564 110183: 83 c4 10 add $0x10,%esp 110186: 85 c0 test %eax,%eax 110188: 0f 85 a6 00 00 00 jne 110234 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); 11018e: 83 ec 08 sub $0x8,%esp 110191: 68 00 40 00 00 push $0x4000 110196: 53 push %ebx 110197: e8 4c 92 ff ff call 1093e8 11019c: 8b 55 08 mov 0x8(%ebp),%edx 11019f: 89 02 mov %eax,(%edx) if (filsdes[0] < 0) { 1101a1: 83 c4 10 add $0x10,%esp 1101a4: 85 c0 test %eax,%eax 1101a6: 78 58 js 110200 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]); 1101a8: 3b 05 4c 31 12 00 cmp 0x12314c,%eax 1101ae: 72 3c jb 1101ec <== ALWAYS TAKEN 1101b0: 31 d2 xor %edx,%edx <== NOT EXECUTED iop->flags &= ~LIBIO_FLAGS_NO_DELAY; 1101b2: 83 62 14 fe andl $0xfffffffe,0x14(%edx) filsdes[1] = open(fifopath, O_WRONLY); 1101b6: 83 ec 08 sub $0x8,%esp 1101b9: 6a 01 push $0x1 1101bb: 53 push %ebx 1101bc: e8 27 92 ff ff call 1093e8 1101c1: 8b 55 08 mov 0x8(%ebp),%edx 1101c4: 89 42 04 mov %eax,0x4(%edx) if (filsdes[1] < 0) { 1101c7: 83 c4 10 add $0x10,%esp 1101ca: 85 c0 test %eax,%eax 1101cc: 78 4a js 110218 int pipe_create( int filsdes[2] ) { rtems_libio_t *iop; int err = 0; 1101ce: 31 f6 xor %esi,%esi if (filsdes[1] < 0) { err = errno; close(filsdes[0]); } unlink(fifopath); 1101d0: 83 ec 0c sub $0xc,%esp 1101d3: 53 push %ebx 1101d4: e8 5b b2 ff ff call 10b434 1101d9: 83 c4 10 add $0x10,%esp } if(err != 0) 1101dc: 85 f6 test %esi,%esi 1101de: 75 63 jne 110243 rtems_set_errno_and_return_minus_one(err); return 0; 1101e0: 31 c0 xor %eax,%eax } 1101e2: 8d 65 f4 lea -0xc(%ebp),%esp 1101e5: 5b pop %ebx 1101e6: 5e pop %esi 1101e7: 5f pop %edi 1101e8: c9 leave 1101e9: c3 ret 1101ea: 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]); 1101ec: c1 e0 03 shl $0x3,%eax 1101ef: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx 1101f6: 29 c2 sub %eax,%edx 1101f8: 03 15 00 73 12 00 add 0x127300,%edx 1101fe: eb b2 jmp 1101b2 } /* Non-blocking open to avoid waiting for writers */ filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK); if (filsdes[0] < 0) { err = errno; 110200: e8 cf 31 00 00 call 1133d4 <__errno> 110205: 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); 110207: 83 ec 0c sub $0xc,%esp 11020a: 53 push %ebx 11020b: e8 24 b2 ff ff call 10b434 110210: 83 c4 10 add $0x10,%esp 110213: eb c7 jmp 1101dc 110215: 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; 110218: e8 b7 31 00 00 call 1133d4 <__errno> 11021d: 8b 30 mov (%eax),%esi close(filsdes[0]); 11021f: 83 ec 0c sub $0xc,%esp 110222: 8b 45 08 mov 0x8(%ebp),%eax 110225: ff 30 pushl (%eax) 110227: e8 1c 82 ff ff call 108448 11022c: 83 c4 10 add $0x10,%esp 11022f: eb 9f jmp 1101d0 110231: 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){ 110234: e8 9b 31 00 00 call 1133d4 <__errno> return -1; 110239: b8 ff ff ff ff mov $0xffffffff,%eax 11023e: e9 f9 fe ff ff jmp 11013c close(filsdes[0]); } unlink(fifopath); } if(err != 0) rtems_set_errno_and_return_minus_one(err); 110243: e8 8c 31 00 00 call 1133d4 <__errno> 110248: 89 30 mov %esi,(%eax) 11024a: b8 ff ff ff ff mov $0xffffffff,%eax 11024f: e9 e8 fe ff ff jmp 11013c =============================================================================== 00111590 : pipe_control_t *pipe, uint32_t cmd, void *buffer, rtems_libio_t *iop ) { 111590: 55 push %ebp 111591: 89 e5 mov %esp,%ebp 111593: 56 push %esi 111594: 53 push %ebx 111595: 8b 75 08 mov 0x8(%ebp),%esi 111598: 8b 5d 10 mov 0x10(%ebp),%ebx if (cmd == FIONREAD) { 11159b: 81 7d 0c 7f 66 04 40 cmpl $0x4004667f,0xc(%ebp) 1115a2: 74 0c je 1115b0 *(unsigned int *)buffer = pipe->Length; PIPE_UNLOCK(pipe); return 0; } return -EINVAL; 1115a4: b8 ea ff ff ff mov $0xffffffea,%eax } 1115a9: 8d 65 f8 lea -0x8(%ebp),%esp 1115ac: 5b pop %ebx 1115ad: 5e pop %esi 1115ae: c9 leave 1115af: c3 ret void *buffer, rtems_libio_t *iop ) { if (cmd == FIONREAD) { if (buffer == NULL) 1115b0: 85 db test %ebx,%ebx 1115b2: 75 07 jne 1115bb return -EFAULT; 1115b4: b8 f2 ff ff ff mov $0xfffffff2,%eax 1115b9: eb ee jmp 1115a9 if (! PIPE_LOCK(pipe)) 1115bb: 50 push %eax 1115bc: 6a 00 push $0x0 1115be: 6a 00 push $0x0 1115c0: ff 76 28 pushl 0x28(%esi) 1115c3: e8 f4 b2 ff ff call 10c8bc 1115c8: 83 c4 10 add $0x10,%esp 1115cb: 85 c0 test %eax,%eax 1115cd: 74 07 je 1115d6 <== ALWAYS TAKEN return -EINTR; 1115cf: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED 1115d4: eb d3 jmp 1115a9 <== NOT EXECUTED /* Return length of pipe */ *(unsigned int *)buffer = pipe->Length; 1115d6: 8b 46 0c mov 0xc(%esi),%eax 1115d9: 89 03 mov %eax,(%ebx) PIPE_UNLOCK(pipe); 1115db: 83 ec 0c sub $0xc,%esp 1115de: ff 76 28 pushl 0x28(%esi) 1115e1: e8 d2 b3 ff ff call 10c9b8 return 0; 1115e6: 83 c4 10 add $0x10,%esp 1115e9: 31 c0 xor %eax,%eax 1115eb: eb bc jmp 1115a9 =============================================================================== 001111f4 : pipe_control_t *pipe, void *buffer, size_t count, rtems_libio_t *iop ) { 1111f4: 55 push %ebp 1111f5: 89 e5 mov %esp,%ebp 1111f7: 57 push %edi 1111f8: 56 push %esi 1111f9: 53 push %ebx 1111fa: 83 ec 30 sub $0x30,%esp 1111fd: 8b 5d 08 mov 0x8(%ebp),%ebx int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) 111200: 6a 00 push $0x0 111202: 6a 00 push $0x0 111204: ff 73 28 pushl 0x28(%ebx) 111207: e8 b0 b6 ff ff call 10c8bc 11120c: 83 c4 10 add $0x10,%esp 11120f: 85 c0 test %eax,%eax 111211: 0f 85 ad 00 00 00 jne 1112c4 <== NEVER TAKEN return -EINTR; while (read < count) { 111217: 8b 45 10 mov 0x10(%ebp),%eax 11121a: 85 c0 test %eax,%eax 11121c: 0f 84 7a 01 00 00 je 11139c <== NEVER TAKEN 111222: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) 111229: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) while (PIPE_EMPTY(pipe)) { 111230: 8b 53 0c mov 0xc(%ebx),%edx 111233: 85 d2 test %edx,%edx 111235: 0f 85 99 00 00 00 jne 1112d4 /* Not an error */ if (pipe->Writers == 0) 11123b: 8b 7b 14 mov 0x14(%ebx),%edi 11123e: 85 ff test %edi,%edi 111240: 0f 84 fe 00 00 00 je 111344 goto out_locked; if (LIBIO_NODELAY(iop)) { 111246: 8b 45 14 mov 0x14(%ebp),%eax 111249: f6 40 14 01 testb $0x1,0x14(%eax) 11124d: 0f 85 f9 00 00 00 jne 11134c ret = -EAGAIN; goto out_locked; } /* Wait until pipe is no more empty or no writer exists */ pipe->waitingReaders ++; 111253: ff 43 18 incl 0x18(%ebx) PIPE_UNLOCK(pipe); 111256: 83 ec 0c sub $0xc,%esp 111259: ff 73 28 pushl 0x28(%ebx) 11125c: e8 57 b7 ff ff call 10c9b8 if (! PIPE_READWAIT(pipe)) 111261: 59 pop %ecx 111262: 5e pop %esi 111263: 6a 00 push $0x0 111265: ff 73 2c pushl 0x2c(%ebx) 111268: e8 97 0f 00 00 call 112204 11126d: 83 c4 0c add $0xc,%esp 111270: 83 f8 01 cmp $0x1,%eax 111273: 19 f6 sbb %esi,%esi 111275: f7 d6 not %esi 111277: 83 e6 fc and $0xfffffffc,%esi ret = -EINTR; if (! PIPE_LOCK(pipe)) { 11127a: 6a 00 push $0x0 11127c: 6a 00 push $0x0 11127e: ff 73 28 pushl 0x28(%ebx) 111281: e8 36 b6 ff ff call 10c8bc 111286: 83 c4 10 add $0x10,%esp 111289: 85 c0 test %eax,%eax 11128b: 0f 85 c7 00 00 00 jne 111358 <== NEVER TAKEN /* WARN waitingReaders not restored! */ ret = -EINTR; goto out_nolock; } pipe->waitingReaders --; 111291: ff 4b 18 decl 0x18(%ebx) if (ret != 0) 111294: 85 f6 test %esi,%esi 111296: 74 98 je 111230 <== ALWAYS TAKEN PIPE_WAKEUPWRITERS(pipe); read += chunk; } out_locked: PIPE_UNLOCK(pipe); 111298: 83 ec 0c sub $0xc,%esp 11129b: ff 73 28 pushl 0x28(%ebx) 11129e: e8 15 b7 ff ff call 10c9b8 1112a3: 83 c4 10 add $0x10,%esp out_nolock: if (read > 0) 1112a6: 8b 45 d4 mov -0x2c(%ebp),%eax 1112a9: 85 c0 test %eax,%eax 1112ab: 7e 0b jle 1112b8 1112ad: 8b 45 d4 mov -0x2c(%ebp),%eax return read; return ret; } 1112b0: 8d 65 f4 lea -0xc(%ebp),%esp 1112b3: 5b pop %ebx 1112b4: 5e pop %esi 1112b5: 5f pop %edi 1112b6: c9 leave 1112b7: c3 ret PIPE_UNLOCK(pipe); out_nolock: if (read > 0) return read; return ret; 1112b8: 89 f0 mov %esi,%eax } 1112ba: 8d 65 f4 lea -0xc(%ebp),%esp 1112bd: 5b pop %ebx 1112be: 5e pop %esi 1112bf: 5f pop %edi 1112c0: c9 leave 1112c1: c3 ret 1112c2: 66 90 xchg %ax,%ax ) { int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) return -EINTR; 1112c4: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED out_nolock: if (read > 0) return read; return ret; } 1112c9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1112cc: 5b pop %ebx <== NOT EXECUTED 1112cd: 5e pop %esi <== NOT EXECUTED 1112ce: 5f pop %edi <== NOT EXECUTED 1112cf: c9 leave <== NOT EXECUTED 1112d0: c3 ret <== NOT EXECUTED 1112d1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (ret != 0) goto out_locked; } /* Read chunk bytes */ chunk = MIN(count - read, pipe->Length); 1112d4: 8b 45 10 mov 0x10(%ebp),%eax 1112d7: 2b 45 d0 sub -0x30(%ebp),%eax 1112da: 89 55 cc mov %edx,-0x34(%ebp) 1112dd: 39 c2 cmp %eax,%edx 1112df: 76 03 jbe 1112e4 1112e1: 89 45 cc mov %eax,-0x34(%ebp) chunk1 = pipe->Size - pipe->Start; 1112e4: 8b 73 08 mov 0x8(%ebx),%esi 1112e7: 8b 43 04 mov 0x4(%ebx),%eax 1112ea: 29 f0 sub %esi,%eax if (chunk > chunk1) { 1112ec: 39 45 cc cmp %eax,-0x34(%ebp) 1112ef: 7f 71 jg 111362 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); 1112f1: 8b 45 0c mov 0xc(%ebp),%eax 1112f4: 03 45 d0 add -0x30(%ebp),%eax 1112f7: 03 33 add (%ebx),%esi 1112f9: 89 c7 mov %eax,%edi 1112fb: 8b 4d cc mov -0x34(%ebp),%ecx 1112fe: f3 a4 rep movsb %ds:(%esi),%es:(%edi) pipe->Start += chunk; 111300: 8b 45 cc mov -0x34(%ebp),%eax 111303: 03 43 08 add 0x8(%ebx),%eax pipe->Start %= pipe->Size; 111306: 31 d2 xor %edx,%edx 111308: f7 73 04 divl 0x4(%ebx) 11130b: 89 53 08 mov %edx,0x8(%ebx) pipe->Length -= chunk; 11130e: 8b 43 0c mov 0xc(%ebx),%eax 111311: 2b 45 cc sub -0x34(%ebp),%eax 111314: 89 43 0c mov %eax,0xc(%ebx) /* For buffering optimization */ if (PIPE_EMPTY(pipe)) 111317: 85 c0 test %eax,%eax 111319: 75 07 jne 111322 pipe->Start = 0; 11131b: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) if (pipe->waitingWriters > 0) 111322: 8b 53 1c mov 0x1c(%ebx),%edx 111325: 85 d2 test %edx,%edx 111327: 75 5f jne 111388 PIPE_WAKEUPWRITERS(pipe); read += chunk; 111329: 8b 45 cc mov -0x34(%ebp),%eax 11132c: 01 45 d4 add %eax,-0x2c(%ebp) int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) return -EINTR; while (read < count) { 11132f: 8b 45 d4 mov -0x2c(%ebp),%eax 111332: 89 45 d0 mov %eax,-0x30(%ebp) 111335: 8b 45 10 mov 0x10(%ebp),%eax 111338: 39 45 d4 cmp %eax,-0x2c(%ebp) 11133b: 0f 82 ef fe ff ff jb 111230 <== NEVER TAKEN 111341: 8d 76 00 lea 0x0(%esi),%esi while (PIPE_EMPTY(pipe)) { /* Not an error */ if (pipe->Writers == 0) 111344: 31 f6 xor %esi,%esi 111346: e9 4d ff ff ff jmp 111298 11134b: 90 nop goto out_locked; if (LIBIO_NODELAY(iop)) { ret = -EAGAIN; 11134c: be f5 ff ff ff mov $0xfffffff5,%esi 111351: e9 42 ff ff ff jmp 111298 111356: 66 90 xchg %ax,%ax PIPE_UNLOCK(pipe); if (! PIPE_READWAIT(pipe)) ret = -EINTR; if (! PIPE_LOCK(pipe)) { /* WARN waitingReaders not restored! */ ret = -EINTR; 111358: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED 11135d: e9 44 ff ff ff jmp 1112a6 <== 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); 111362: 8b 55 0c mov 0xc(%ebp),%edx 111365: 03 55 d0 add -0x30(%ebp),%edx 111368: 03 33 add (%ebx),%esi 11136a: 89 d7 mov %edx,%edi 11136c: 89 c1 mov %eax,%ecx 11136e: f3 a4 rep movsb %ds:(%esi),%es:(%edi) memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1); 111370: 8b 55 d0 mov -0x30(%ebp),%edx 111373: 01 c2 add %eax,%edx 111375: 03 55 0c add 0xc(%ebp),%edx 111378: 8b 4d cc mov -0x34(%ebp),%ecx 11137b: 29 c1 sub %eax,%ecx 11137d: 8b 33 mov (%ebx),%esi 11137f: 89 d7 mov %edx,%edi 111381: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 111383: e9 78 ff ff ff jmp 111300 /* For buffering optimization */ if (PIPE_EMPTY(pipe)) pipe->Start = 0; if (pipe->waitingWriters > 0) PIPE_WAKEUPWRITERS(pipe); 111388: 83 ec 08 sub $0x8,%esp 11138b: 8d 45 e4 lea -0x1c(%ebp),%eax 11138e: 50 push %eax 11138f: ff 73 30 pushl 0x30(%ebx) 111392: e8 09 0e 00 00 call 1121a0 111397: 83 c4 10 add $0x10,%esp 11139a: eb 8d jmp 111329 int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) return -EINTR; while (read < count) { 11139c: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED 1113a3: 31 f6 xor %esi,%esi <== NOT EXECUTED 1113a5: e9 ee fe ff ff jmp 111298 <== NOT EXECUTED =============================================================================== 00110ce0 : */ void pipe_release( pipe_control_t **pipep, rtems_libio_t *iop ) { 110ce0: 55 push %ebp 110ce1: 89 e5 mov %esp,%ebp 110ce3: 57 push %edi 110ce4: 56 push %esi 110ce5: 53 push %ebx 110ce6: 83 ec 1c sub $0x1c,%esp 110ce9: 8b 7d 08 mov 0x8(%ebp),%edi pipe_control_t *pipe = *pipep; 110cec: 8b 1f mov (%edi),%ebx /* WARN pipe not released! */ if (!PIPE_LOCK(pipe)) rtems_fatal_error_occurred(0xdeadbeef); #endif mode = LIBIO_ACCMODE(iop); 110cee: 8b 45 0c mov 0xc(%ebp),%eax 110cf1: 8b 40 14 mov 0x14(%eax),%eax 110cf4: 89 c6 mov %eax,%esi 110cf6: 83 e6 06 and $0x6,%esi if (mode & LIBIO_FLAGS_READ) 110cf9: a8 02 test $0x2,%al 110cfb: 74 03 je 110d00 pipe->Readers --; 110cfd: ff 4b 10 decl 0x10(%ebx) if (mode & LIBIO_FLAGS_WRITE) 110d00: f7 c6 04 00 00 00 test $0x4,%esi 110d06: 74 03 je 110d0b pipe->Writers --; 110d08: ff 4b 14 decl 0x14(%ebx) PIPE_UNLOCK(pipe); 110d0b: 83 ec 0c sub $0xc,%esp 110d0e: ff 73 28 pushl 0x28(%ebx) 110d11: e8 a2 bc ff ff call 10c9b8 if (pipe->Readers == 0 && pipe->Writers == 0) { 110d16: 83 c4 10 add $0x10,%esp 110d19: 8b 53 10 mov 0x10(%ebx),%edx 110d1c: 85 d2 test %edx,%edx 110d1e: 74 2c je 110d4c *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) 110d20: 8b 43 14 mov 0x14(%ebx),%eax 110d23: 85 c0 test %eax,%eax 110d25: 75 17 jne 110d3e <== NEVER TAKEN 110d27: 83 fe 02 cmp $0x2,%esi 110d2a: 74 12 je 110d3e <== NEVER TAKEN PIPE_WAKEUPREADERS(pipe); 110d2c: 83 ec 08 sub $0x8,%esp 110d2f: 8d 45 e4 lea -0x1c(%ebp),%eax 110d32: 50 push %eax 110d33: ff 73 2c pushl 0x2c(%ebx) 110d36: e8 65 14 00 00 call 1121a0 110d3b: 83 c4 10 add $0x10,%esp pipe_unlock(); 110d3e: e8 85 ff ff ff call 110cc8 iop->flags &= ~LIBIO_FLAGS_OPEN; if(iop->pathinfo.ops->unlink_h(&iop->pathinfo)) return; #endif } 110d43: 8d 65 f4 lea -0xc(%ebp),%esp 110d46: 5b pop %ebx 110d47: 5e pop %esi 110d48: 5f pop %edi 110d49: c9 leave 110d4a: c3 ret 110d4b: 90 nop if (mode & LIBIO_FLAGS_WRITE) pipe->Writers --; PIPE_UNLOCK(pipe); if (pipe->Readers == 0 && pipe->Writers == 0) { 110d4c: 8b 43 14 mov 0x14(%ebx),%eax 110d4f: 85 c0 test %eax,%eax 110d51: 74 25 je 110d78 delfile = TRUE; #endif pipe_free(pipe); *pipep = NULL; } else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE) 110d53: 83 fe 04 cmp $0x4,%esi 110d56: 74 e6 je 110d3e <== NEVER TAKEN /* Notify waiting Writers that all their partners left */ PIPE_WAKEUPWRITERS(pipe); 110d58: 83 ec 08 sub $0x8,%esp 110d5b: 8d 45 e4 lea -0x1c(%ebp),%eax 110d5e: 50 push %eax 110d5f: ff 73 30 pushl 0x30(%ebx) 110d62: e8 39 14 00 00 call 1121a0 110d67: 83 c4 10 add $0x10,%esp else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ) PIPE_WAKEUPREADERS(pipe); pipe_unlock(); 110d6a: e8 59 ff ff ff call 110cc8 iop->flags &= ~LIBIO_FLAGS_OPEN; if(iop->pathinfo.ops->unlink_h(&iop->pathinfo)) return; #endif } 110d6f: 8d 65 f4 lea -0xc(%ebp),%esp 110d72: 5b pop %ebx 110d73: 5e pop %esi 110d74: 5f pop %edi 110d75: c9 leave 110d76: c3 ret 110d77: 90 nop /* Called with pipe_semaphore held. */ static inline void pipe_free( pipe_control_t *pipe ) { rtems_barrier_delete(pipe->readBarrier); 110d78: 83 ec 0c sub $0xc,%esp 110d7b: ff 73 2c pushl 0x2c(%ebx) 110d7e: e8 8d 13 00 00 call 112110 rtems_barrier_delete(pipe->writeBarrier); 110d83: 5e pop %esi 110d84: ff 73 30 pushl 0x30(%ebx) 110d87: e8 84 13 00 00 call 112110 rtems_semaphore_delete(pipe->Semaphore); 110d8c: 59 pop %ecx 110d8d: ff 73 28 pushl 0x28(%ebx) 110d90: e8 83 ba ff ff call 10c818 free(pipe->Buffer); 110d95: 5a pop %edx 110d96: ff 33 pushl (%ebx) 110d98: e8 c3 80 ff ff call 108e60 free(pipe); 110d9d: 89 1c 24 mov %ebx,(%esp) 110da0: e8 bb 80 ff ff call 108e60 /* To delete an anonymous pipe file when all users closed it */ if (pipe->Anonymous) delfile = TRUE; #endif pipe_free(pipe); *pipep = NULL; 110da5: c7 07 00 00 00 00 movl $0x0,(%edi) 110dab: 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(); 110dae: e8 15 ff ff ff call 110cc8 iop->flags &= ~LIBIO_FLAGS_OPEN; if(iop->pathinfo.ops->unlink_h(&iop->pathinfo)) return; #endif } 110db3: 8d 65 f4 lea -0xc(%ebp),%esp 110db6: 5b pop %ebx 110db7: 5e pop %esi 110db8: 5f pop %edi 110db9: c9 leave 110dba: c3 ret =============================================================================== 001113ac : pipe_control_t *pipe, const void *buffer, size_t count, rtems_libio_t *iop ) { 1113ac: 55 push %ebp 1113ad: 89 e5 mov %esp,%ebp 1113af: 57 push %edi 1113b0: 56 push %esi 1113b1: 53 push %ebx 1113b2: 83 ec 2c sub $0x2c,%esp 1113b5: 8b 5d 10 mov 0x10(%ebp),%ebx int chunk, chunk1, written = 0, ret = 0; /* Write nothing */ if (count == 0) 1113b8: 85 db test %ebx,%ebx 1113ba: 75 0c jne 1113c8 <== ALWAYS TAKEN return 0; 1113bc: 31 c0 xor %eax,%eax #endif if (written > 0) return written; return ret; } 1113be: 8d 65 f4 lea -0xc(%ebp),%esp 1113c1: 5b pop %ebx 1113c2: 5e pop %esi 1113c3: 5f pop %edi 1113c4: c9 leave 1113c5: c3 ret 1113c6: 66 90 xchg %ax,%ax /* Write nothing */ if (count == 0) return 0; if (! PIPE_LOCK(pipe)) 1113c8: 56 push %esi 1113c9: 6a 00 push $0x0 1113cb: 6a 00 push $0x0 1113cd: 8b 45 08 mov 0x8(%ebp),%eax 1113d0: ff 70 28 pushl 0x28(%eax) 1113d3: e8 e4 b4 ff ff call 10c8bc 1113d8: 83 c4 10 add $0x10,%esp 1113db: 85 c0 test %eax,%eax 1113dd: 0f 85 45 01 00 00 jne 111528 <== NEVER TAKEN return -EINTR; if (pipe->Readers == 0) { 1113e3: 8b 45 08 mov 0x8(%ebp),%eax 1113e6: 8b 48 10 mov 0x10(%eax),%ecx 1113e9: 85 c9 test %ecx,%ecx 1113eb: 0f 84 52 01 00 00 je 111543 ret = -EPIPE; goto out_locked; } /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; 1113f1: 8b 48 04 mov 0x4(%eax),%ecx 1113f4: 39 cb cmp %ecx,%ebx 1113f6: 0f 87 3d 01 00 00 ja 111539 <== NEVER TAKEN 1113fc: 89 de mov %ebx,%esi 1113fe: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) 111405: 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); 11140c: 89 5d c8 mov %ebx,-0x38(%ebp) 11140f: 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) { 111412: 8b 43 0c mov 0xc(%ebx),%eax 111415: 89 ca mov %ecx,%edx 111417: 29 c2 sub %eax,%edx 111419: 39 f2 cmp %esi,%edx 11141b: 73 6f jae 11148c if (LIBIO_NODELAY(iop)) { 11141d: 8b 45 14 mov 0x14(%ebp),%eax 111420: f6 40 14 01 testb $0x1,0x14(%eax) 111424: 0f 85 2e 01 00 00 jne 111558 ret = -EAGAIN; goto out_locked; } /* Wait until there is chunk bytes space or no reader exists */ pipe->waitingWriters ++; 11142a: ff 43 1c incl 0x1c(%ebx) PIPE_UNLOCK(pipe); 11142d: 83 ec 0c sub $0xc,%esp 111430: ff 73 28 pushl 0x28(%ebx) 111433: e8 80 b5 ff ff call 10c9b8 if (! PIPE_WRITEWAIT(pipe)) 111438: 58 pop %eax 111439: 5a pop %edx 11143a: 6a 00 push $0x0 11143c: ff 73 30 pushl 0x30(%ebx) 11143f: e8 c0 0d 00 00 call 112204 111444: 83 c4 0c add $0xc,%esp 111447: 83 f8 01 cmp $0x1,%eax 11144a: 19 ff sbb %edi,%edi 11144c: f7 d7 not %edi 11144e: 83 e7 fc and $0xfffffffc,%edi ret = -EINTR; if (! PIPE_LOCK(pipe)) { 111451: 6a 00 push $0x0 111453: 6a 00 push $0x0 111455: ff 73 28 pushl 0x28(%ebx) 111458: e8 5f b4 ff ff call 10c8bc 11145d: 83 c4 10 add $0x10,%esp 111460: 85 c0 test %eax,%eax 111462: 0f 85 e9 00 00 00 jne 111551 <== NEVER TAKEN /* WARN waitingWriters not restored! */ ret = -EINTR; goto out_nolock; } pipe->waitingWriters --; 111468: ff 4b 1c decl 0x1c(%ebx) if (ret != 0) 11146b: 85 ff test %edi,%edi 11146d: 0f 85 95 00 00 00 jne 111508 <== NEVER TAKEN goto out_locked; if (pipe->Readers == 0) { 111473: 8b 7b 10 mov 0x10(%ebx),%edi 111476: 85 ff test %edi,%edi 111478: 0f 84 85 00 00 00 je 111503 <== NEVER TAKEN 11147e: 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) { 111481: 8b 43 0c mov 0xc(%ebx),%eax 111484: 89 ca mov %ecx,%edx 111486: 29 c2 sub %eax,%edx 111488: 39 f2 cmp %esi,%edx 11148a: 72 91 jb 11141d <== NEVER TAKEN ret = -EPIPE; goto out_locked; } } chunk = MIN(count - written, PIPE_SPACE(pipe)); 11148c: 8b 75 c8 mov -0x38(%ebp),%esi 11148f: 2b 75 d0 sub -0x30(%ebp),%esi 111492: 89 55 cc mov %edx,-0x34(%ebp) 111495: 39 f2 cmp %esi,%edx 111497: 76 03 jbe 11149c 111499: 89 75 cc mov %esi,-0x34(%ebp) chunk1 = pipe->Size - PIPE_WSTART(pipe); 11149c: 03 43 08 add 0x8(%ebx),%eax 11149f: 31 d2 xor %edx,%edx 1114a1: f7 f1 div %ecx 1114a3: 89 c8 mov %ecx,%eax 1114a5: 29 d0 sub %edx,%eax if (chunk > chunk1) { 1114a7: 39 45 cc cmp %eax,-0x34(%ebp) 1114aa: 0f 8e af 00 00 00 jle 11155f memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1); 1114b0: 03 13 add (%ebx),%edx 1114b2: 8b 75 0c mov 0xc(%ebp),%esi 1114b5: 03 75 d0 add -0x30(%ebp),%esi 1114b8: 89 d7 mov %edx,%edi 1114ba: 89 c1 mov %eax,%ecx 1114bc: f3 a4 rep movsb %ds:(%esi),%es:(%edi) memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1); 1114be: 8b 13 mov (%ebx),%edx 1114c0: 8b 4d cc mov -0x34(%ebp),%ecx 1114c3: 29 c1 sub %eax,%ecx 1114c5: 03 45 d0 add -0x30(%ebp),%eax 1114c8: 8b 75 0c mov 0xc(%ebp),%esi 1114cb: 01 c6 add %eax,%esi 1114cd: 89 d7 mov %edx,%edi 1114cf: f3 a4 rep movsb %ds:(%esi),%es:(%edi) } else memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk); pipe->Length += chunk; 1114d1: 8b 45 cc mov -0x34(%ebp),%eax 1114d4: 01 43 0c add %eax,0xc(%ebx) if (pipe->waitingReaders > 0) 1114d7: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 1114db: 0f 85 92 00 00 00 jne 111573 PIPE_WAKEUPREADERS(pipe); written += chunk; 1114e1: 8b 45 cc mov -0x34(%ebp),%eax 1114e4: 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) { 1114e7: 8b 45 d4 mov -0x2c(%ebp),%eax 1114ea: 89 45 d0 mov %eax,-0x30(%ebp) 1114ed: 39 45 c8 cmp %eax,-0x38(%ebp) 1114f0: 0f 86 93 00 00 00 jbe 111589 <== ALWAYS TAKEN 1114f6: 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; 1114f9: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 1114fe: e9 0f ff ff ff jmp 111412 <== NOT EXECUTED pipe->waitingWriters --; if (ret != 0) goto out_locked; if (pipe->Readers == 0) { ret = -EPIPE; 111503: 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); 111508: 83 ec 0c sub $0xc,%esp 11150b: 8b 45 08 mov 0x8(%ebp),%eax 11150e: ff 70 28 pushl 0x28(%eax) 111511: e8 a2 b4 ff ff call 10c9b8 111516: 83 c4 10 add $0x10,%esp /* Signal SIGPIPE */ if (ret == -EPIPE) kill(getpid(), SIGPIPE); #endif if (written > 0) 111519: 8b 55 d4 mov -0x2c(%ebp),%edx 11151c: 85 d2 test %edx,%edx 11151e: 7e 12 jle 111532 111520: 8b 45 d4 mov -0x2c(%ebp),%eax 111523: e9 96 fe ff ff jmp 1113be /* Write nothing */ if (count == 0) return 0; if (! PIPE_LOCK(pipe)) return -EINTR; 111528: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED 11152d: e9 8c fe ff ff jmp 1113be <== NOT EXECUTED kill(getpid(), SIGPIPE); #endif if (written > 0) return written; return ret; 111532: 89 f8 mov %edi,%eax 111534: e9 85 fe ff ff jmp 1113be ret = -EPIPE; goto out_locked; } /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; 111539: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 11153e: e9 bb fe ff ff jmp 1113fe <== NOT EXECUTED if (! PIPE_LOCK(pipe)) return -EINTR; if (pipe->Readers == 0) { ret = -EPIPE; 111543: 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; 111548: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) 11154f: eb b7 jmp 111508 PIPE_UNLOCK(pipe); if (! PIPE_WRITEWAIT(pipe)) ret = -EINTR; if (! PIPE_LOCK(pipe)) { /* WARN waitingWriters not restored! */ ret = -EINTR; 111551: bf fc ff ff ff mov $0xfffffffc,%edi <== NOT EXECUTED 111556: eb c1 jmp 111519 <== NOT EXECUTED chunk = count <= pipe->Size ? count : 1; while (written < count) { while (PIPE_SPACE(pipe) < chunk) { if (LIBIO_NODELAY(iop)) { ret = -EAGAIN; 111558: bf f5 ff ff ff mov $0xfffffff5,%edi 11155d: eb a9 jmp 111508 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); 11155f: 03 13 add (%ebx),%edx 111561: 8b 75 0c mov 0xc(%ebp),%esi 111564: 03 75 d0 add -0x30(%ebp),%esi 111567: 89 d7 mov %edx,%edi 111569: 8b 4d cc mov -0x34(%ebp),%ecx 11156c: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 11156e: e9 5e ff ff ff jmp 1114d1 pipe->Length += chunk; if (pipe->waitingReaders > 0) PIPE_WAKEUPREADERS(pipe); 111573: 51 push %ecx 111574: 51 push %ecx 111575: 8d 45 e4 lea -0x1c(%ebp),%eax 111578: 50 push %eax 111579: ff 73 2c pushl 0x2c(%ebx) 11157c: e8 1f 0c 00 00 call 1121a0 111581: 83 c4 10 add $0x10,%esp 111584: e9 58 ff ff ff jmp 1114e1 } /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; while (written < count) { 111589: 31 ff xor %edi,%edi 11158b: e9 78 ff ff ff jmp 111508 =============================================================================== 0010b0d8 : int posix_memalign( void **pointer, size_t alignment, size_t size ) { 10b0d8: 55 push %ebp 10b0d9: 89 e5 mov %esp,%ebp 10b0db: 53 push %ebx 10b0dc: 83 ec 04 sub $0x4,%esp 10b0df: 8b 45 0c mov 0xc(%ebp),%eax /* * Update call statistics */ MSBUMP(memalign_calls, 1); 10b0e2: ff 05 88 d4 12 00 incl 0x12d488 if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *))) 10b0e8: 8d 50 ff lea -0x1(%eax),%edx 10b0eb: 85 c2 test %eax,%edx 10b0ed: 75 05 jne 10b0f4 <== NEVER TAKEN 10b0ef: 83 f8 03 cmp $0x3,%eax 10b0f2: 77 0c ja 10b100 /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); } 10b0f4: b8 16 00 00 00 mov $0x16,%eax 10b0f9: 5a pop %edx 10b0fa: 5b pop %ebx 10b0fb: c9 leave 10b0fc: c3 ret 10b0fd: 8d 76 00 lea 0x0(%esi),%esi 10b100: 59 pop %ecx 10b101: 5b pop %ebx 10b102: c9 leave /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); 10b103: e9 78 01 00 00 jmp 10b280 =============================================================================== 0011dd7c : ssize_t read( int fd, void *buffer, size_t count ) { 11dd7c: 55 push %ebp 11dd7d: 89 e5 mov %esp,%ebp 11dd7f: 53 push %ebx 11dd80: 83 ec 04 sub $0x4,%esp 11dd83: 8b 4d 08 mov 0x8(%ebp),%ecx 11dd86: 8b 45 0c mov 0xc(%ebp),%eax 11dd89: 8b 55 10 mov 0x10(%ebp),%edx ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11dd8c: 3b 0d ec 21 12 00 cmp 0x1221ec,%ecx 11dd92: 73 50 jae 11dde4 <== NEVER TAKEN iop = rtems_libio_iop( fd ); 11dd94: c1 e1 03 shl $0x3,%ecx 11dd97: 8d 1c cd 00 00 00 00 lea 0x0(,%ecx,8),%ebx 11dd9e: 29 cb sub %ecx,%ebx 11dda0: 03 1d 80 63 12 00 add 0x126380,%ebx rtems_libio_check_is_open( iop ); 11dda6: 8b 4b 14 mov 0x14(%ebx),%ecx 11dda9: f6 c5 01 test $0x1,%ch 11ddac: 74 36 je 11dde4 rtems_libio_check_buffer( buffer ); 11ddae: 85 c0 test %eax,%eax 11ddb0: 74 46 je 11ddf8 <== NEVER TAKEN rtems_libio_check_count( count ); 11ddb2: 85 d2 test %edx,%edx 11ddb4: 74 26 je 11dddc rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 11ddb6: 83 e1 02 and $0x2,%ecx 11ddb9: 74 3d je 11ddf8 /* * Now process the read(). */ rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count ); 11ddbb: 51 push %ecx 11ddbc: 8b 4b 20 mov 0x20(%ebx),%ecx 11ddbf: 52 push %edx 11ddc0: 50 push %eax 11ddc1: 53 push %ebx 11ddc2: ff 51 08 call *0x8(%ecx) if ( rc > 0 ) 11ddc5: 83 c4 10 add $0x10,%esp 11ddc8: 85 c0 test %eax,%eax 11ddca: 7e 0b jle 11ddd7 iop->offset += rc; 11ddcc: 89 c1 mov %eax,%ecx 11ddce: c1 f9 1f sar $0x1f,%ecx 11ddd1: 01 43 0c add %eax,0xc(%ebx) 11ddd4: 11 4b 10 adc %ecx,0x10(%ebx) return rc; } 11ddd7: 8b 5d fc mov -0x4(%ebp),%ebx 11ddda: c9 leave 11dddb: 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 ); 11dddc: 31 c0 xor %eax,%eax if ( rc > 0 ) iop->offset += rc; return rc; } 11ddde: 8b 5d fc mov -0x4(%ebp),%ebx 11dde1: c9 leave 11dde2: c3 ret 11dde3: 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 ); 11dde4: e8 f3 3f ff ff call 111ddc <__errno> 11dde9: c7 00 09 00 00 00 movl $0x9,(%eax) 11ddef: b8 ff ff ff ff mov $0xffffffff,%eax 11ddf4: eb e1 jmp 11ddd7 11ddf6: 66 90 xchg %ax,%ax rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 11ddf8: e8 df 3f ff ff call 111ddc <__errno> 11ddfd: c7 00 16 00 00 00 movl $0x16,(%eax) 11de03: b8 ff ff ff ff mov $0xffffffff,%eax 11de08: eb cd jmp 11ddd7 =============================================================================== 0010a600 : ssize_t readlink( const char *pathname, char *buf, size_t bufsize ) { 10a600: 55 push %ebp 10a601: 89 e5 mov %esp,%ebp 10a603: 57 push %edi 10a604: 56 push %esi 10a605: 53 push %ebx 10a606: 83 ec 3c sub $0x3c,%esp 10a609: 8b 55 08 mov 0x8(%ebp),%edx 10a60c: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_filesystem_location_info_t loc; int result; if (!buf) 10a60f: 85 db test %ebx,%ebx 10a611: 74 6d je 10a680 rtems_set_errno_and_return_minus_one( EFAULT ); result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ), 10a613: 31 c0 xor %eax,%eax 10a615: b9 ff ff ff ff mov $0xffffffff,%ecx 10a61a: 89 d7 mov %edx,%edi 10a61c: f2 ae repnz scas %es:(%edi),%al 10a61e: f7 d1 not %ecx 10a620: 49 dec %ecx 10a621: 83 ec 0c sub $0xc,%esp 10a624: 6a 00 push $0x0 10a626: 8d 75 d4 lea -0x2c(%ebp),%esi 10a629: 56 push %esi 10a62a: 6a 00 push $0x0 10a62c: 51 push %ecx 10a62d: 52 push %edx 10a62e: e8 51 ee ff ff call 109484 0, &loc, false ); if ( result != 0 ) 10a633: 83 c4 20 add $0x20,%esp 10a636: 85 c0 test %eax,%eax 10a638: 74 0e je 10a648 <== ALWAYS TAKEN return -1; 10a63a: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); rtems_filesystem_freenode( &loc ); return result; } 10a63f: 8d 65 f4 lea -0xc(%ebp),%esp 10a642: 5b pop %ebx 10a643: 5e pop %esi 10a644: 5f pop %edi 10a645: c9 leave 10a646: c3 ret 10a647: 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 ){ 10a648: 83 ec 0c sub $0xc,%esp 10a64b: 56 push %esi 10a64c: 8b 45 e0 mov -0x20(%ebp),%eax 10a64f: ff 50 10 call *0x10(%eax) 10a652: 83 c4 10 add $0x10,%esp 10a655: 83 f8 04 cmp $0x4,%eax 10a658: 75 3e jne 10a698 rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( EINVAL ); } result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); 10a65a: 50 push %eax 10a65b: ff 75 10 pushl 0x10(%ebp) 10a65e: 53 push %ebx 10a65f: 56 push %esi 10a660: 8b 45 e0 mov -0x20(%ebp),%eax 10a663: ff 50 3c call *0x3c(%eax) rtems_filesystem_freenode( &loc ); 10a666: 89 34 24 mov %esi,(%esp) 10a669: 89 45 c4 mov %eax,-0x3c(%ebp) 10a66c: e8 eb ee ff ff call 10955c return result; 10a671: 83 c4 10 add $0x10,%esp 10a674: 8b 45 c4 mov -0x3c(%ebp),%eax } 10a677: 8d 65 f4 lea -0xc(%ebp),%esp 10a67a: 5b pop %ebx 10a67b: 5e pop %esi 10a67c: 5f pop %edi 10a67d: c9 leave 10a67e: c3 ret 10a67f: 90 nop { rtems_filesystem_location_info_t loc; int result; if (!buf) rtems_set_errno_and_return_minus_one( EFAULT ); 10a680: e8 23 a2 00 00 call 1148a8 <__errno> 10a685: c7 00 0e 00 00 00 movl $0xe,(%eax) 10a68b: b8 ff ff ff ff mov $0xffffffff,%eax result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); rtems_filesystem_freenode( &loc ); return result; } 10a690: 8d 65 f4 lea -0xc(%ebp),%esp 10a693: 5b pop %ebx 10a694: 5e pop %esi 10a695: 5f pop %edi 10a696: c9 leave 10a697: 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 ); 10a698: 83 ec 0c sub $0xc,%esp 10a69b: 56 push %esi 10a69c: e8 bb ee ff ff call 10955c rtems_set_errno_and_return_minus_one( EINVAL ); 10a6a1: e8 02 a2 00 00 call 1148a8 <__errno> 10a6a6: c7 00 16 00 00 00 movl $0x16,(%eax) 10a6ac: 83 c4 10 add $0x10,%esp 10a6af: b8 ff ff ff ff mov $0xffffffff,%eax 10a6b4: eb 89 jmp 10a63f =============================================================================== 001092c4 : ssize_t readv( int fd, const struct iovec *iov, int iovcnt ) { 1092c4: 55 push %ebp 1092c5: 89 e5 mov %esp,%ebp 1092c7: 57 push %edi 1092c8: 56 push %esi 1092c9: 53 push %ebx 1092ca: 83 ec 1c sub $0x1c,%esp 1092cd: 8b 45 08 mov 0x8(%ebp),%eax 1092d0: 8b 5d 0c mov 0xc(%ebp),%ebx int v; int bytes; rtems_libio_t *iop; bool all_zeros; rtems_libio_check_fd( fd ); 1092d3: 3b 05 4c 37 12 00 cmp 0x12374c,%eax 1092d9: 0f 83 ef 00 00 00 jae 1093ce iop = rtems_libio_iop( fd ); 1092df: c1 e0 03 shl $0x3,%eax 1092e2: 8d 34 c5 00 00 00 00 lea 0x0(,%eax,8),%esi 1092e9: 29 c6 sub %eax,%esi 1092eb: 03 35 e0 78 12 00 add 0x1278e0,%esi rtems_libio_check_is_open( iop ); 1092f1: 8b 46 14 mov 0x14(%esi),%eax 1092f4: f6 c4 01 test $0x1,%ah 1092f7: 0f 84 d1 00 00 00 je 1093ce rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 1092fd: a8 02 test $0x2,%al 1092ff: 0f 84 97 00 00 00 je 10939c <== NEVER TAKEN /* * Argument validation on IO vector */ if ( !iov ) 109305: 85 db test %ebx,%ebx 109307: 0f 84 8f 00 00 00 je 10939c rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt <= 0 ) 10930d: 8b 7d 10 mov 0x10(%ebp),%edi 109310: 85 ff test %edi,%edi 109312: 0f 8e 84 00 00 00 jle 10939c rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt > IOV_MAX ) 109318: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp) 10931f: 7f 7b jg 10939c <== NEVER TAKEN 109321: c6 45 e4 01 movb $0x1,-0x1c(%ebp) 109325: 31 c0 xor %eax,%eax 109327: 31 d2 xor %edx,%edx 109329: eb 03 jmp 10932e 10932b: 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; 10932c: 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 ) 10932e: 8b 0c c3 mov (%ebx,%eax,8),%ecx 109331: 85 c9 test %ecx,%ecx 109333: 74 67 je 10939c rtems_set_errno_and_return_minus_one( EINVAL ); /* check for wrap */ old = total; total += iov[v].iov_len; 109335: 8b 4c c3 04 mov 0x4(%ebx,%eax,8),%ecx 109339: 8d 3c 0a lea (%edx,%ecx,1),%edi if ( total < old ) 10933c: 39 fa cmp %edi,%edx 10933e: 7f 5c jg 10939c rtems_set_errno_and_return_minus_one( EINVAL ); if ( iov[v].iov_len ) 109340: 85 c9 test %ecx,%ecx 109342: 74 04 je 109348 all_zeros = false; 109344: 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++ ) { 109348: 40 inc %eax 109349: 39 45 10 cmp %eax,0x10(%ebp) 10934c: 7f de jg 10932c /* * 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 ) { 10934e: 80 7d e4 00 cmpb $0x0,-0x1c(%ebp) 109352: 75 68 jne 1093bc 109354: 31 ff xor %edi,%edi 109356: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 10935d: eb 1d jmp 10937c 10935f: 90 nop ); if ( bytes < 0 ) return -1; if ( bytes > 0 ) { 109360: 74 0e je 109370 <== NEVER TAKEN iop->offset += bytes; 109362: 89 c1 mov %eax,%ecx 109364: c1 f9 1f sar $0x1f,%ecx 109367: 01 46 0c add %eax,0xc(%esi) 10936a: 11 4e 10 adc %ecx,0x10(%esi) total += bytes; 10936d: 01 45 e4 add %eax,-0x1c(%ebp) } if (bytes != iov[ v ].iov_len) 109370: 3b 44 fb 04 cmp 0x4(%ebx,%edi,8),%eax 109374: 75 38 jne 1093ae <== NEVER TAKEN } /* * Now process the readv(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { 109376: 47 inc %edi 109377: 39 7d 10 cmp %edi,0x10(%ebp) 10937a: 7e 32 jle 1093ae bytes = (*iop->pathinfo.handlers->read_h)( 10937c: 50 push %eax 10937d: 8b 46 20 mov 0x20(%esi),%eax 109380: ff 74 fb 04 pushl 0x4(%ebx,%edi,8) 109384: ff 34 fb pushl (%ebx,%edi,8) 109387: 56 push %esi 109388: ff 50 08 call *0x8(%eax) iop, iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) 10938b: 83 c4 10 add $0x10,%esp 10938e: 83 f8 00 cmp $0x0,%eax 109391: 7d cd jge 109360 <== ALWAYS TAKEN return -1; 109393: c7 45 e4 ff ff ff ff movl $0xffffffff,-0x1c(%ebp) <== NOT EXECUTED 10939a: eb 12 jmp 1093ae <== NOT EXECUTED /* check for wrap */ old = total; total += iov[v].iov_len; if ( total < old ) rtems_set_errno_and_return_minus_one( EINVAL ); 10939c: e8 f7 96 00 00 call 112a98 <__errno> 1093a1: c7 00 16 00 00 00 movl $0x16,(%eax) 1093a7: c7 45 e4 ff ff ff ff movl $0xffffffff,-0x1c(%ebp) if (bytes != iov[ v ].iov_len) break; } return total; } 1093ae: 8b 45 e4 mov -0x1c(%ebp),%eax 1093b1: 8d 65 f4 lea -0xc(%ebp),%esp 1093b4: 5b pop %ebx 1093b5: 5e pop %esi 1093b6: 5f pop %edi 1093b7: c9 leave 1093b8: c3 ret 1093b9: 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; 1093bc: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) if (bytes != iov[ v ].iov_len) break; } return total; } 1093c3: 8b 45 e4 mov -0x1c(%ebp),%eax 1093c6: 8d 65 f4 lea -0xc(%ebp),%esp 1093c9: 5b pop %ebx 1093ca: 5e pop %esi 1093cb: 5f pop %edi 1093cc: c9 leave 1093cd: 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 ); 1093ce: e8 c5 96 00 00 call 112a98 <__errno> 1093d3: c7 00 09 00 00 00 movl $0x9,(%eax) 1093d9: c7 45 e4 ff ff ff ff movl $0xffffffff,-0x1c(%ebp) 1093e0: eb cc jmp 1093ae =============================================================================== 0011de98 : void *realloc( void *ptr, size_t size ) { 11de98: 55 push %ebp 11de99: 89 e5 mov %esp,%ebp 11de9b: 57 push %edi 11de9c: 56 push %esi 11de9d: 53 push %ebx 11de9e: 83 ec 2c sub $0x2c,%esp 11dea1: 8b 5d 08 mov 0x8(%ebp),%ebx 11dea4: 8b 75 0c mov 0xc(%ebp),%esi uintptr_t old_size; char *new_area; MSBUMP(realloc_calls, 1); 11dea7: ff 05 b0 63 12 00 incl 0x1263b0 /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 11dead: 83 3d 80 66 12 00 03 cmpl $0x3,0x126680 11deb4: 74 72 je 11df28 <== ALWAYS TAKEN } /* * Continue with realloc(). */ if ( !ptr ) 11deb6: 85 db test %ebx,%ebx 11deb8: 74 5e je 11df18 return malloc( size ); if ( !size ) { 11deba: 85 f6 test %esi,%esi 11debc: 74 3a je 11def8 <== NEVER TAKEN free( ptr ); return (void *) 0; } if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) { 11debe: 52 push %edx 11debf: 8d 45 e4 lea -0x1c(%ebp),%eax 11dec2: 50 push %eax 11dec3: 53 push %ebx 11dec4: ff 35 30 22 12 00 pushl 0x122230 11deca: e8 49 01 00 00 call 11e018 <_Protected_heap_Get_block_size> 11decf: 83 c4 10 add $0x10,%esp 11ded2: 84 c0 test %al,%al 11ded4: 74 32 je 11df08 } /* * Now resize it. */ if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) { 11ded6: 50 push %eax 11ded7: 56 push %esi 11ded8: 53 push %ebx 11ded9: ff 35 30 22 12 00 pushl 0x122230 11dedf: e8 6c 01 00 00 call 11e050 <_Protected_heap_Resize_block> 11dee4: 83 c4 10 add $0x10,%esp 11dee7: 84 c0 test %al,%al 11dee9: 74 5d je 11df48 memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; } 11deeb: 89 d8 mov %ebx,%eax 11deed: 8d 65 f4 lea -0xc(%ebp),%esp 11def0: 5b pop %ebx 11def1: 5e pop %esi 11def2: 5f pop %edi 11def3: c9 leave 11def4: c3 ret 11def5: 8d 76 00 lea 0x0(%esi),%esi */ if ( !ptr ) return malloc( size ); if ( !size ) { free( ptr ); 11def8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11defb: 53 push %ebx <== NOT EXECUTED 11defc: e8 33 97 fe ff call 107634 <== NOT EXECUTED return (void *) 0; 11df01: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11df04: 31 db xor %ebx,%ebx <== NOT EXECUTED 11df06: eb e3 jmp 11deeb <== NOT EXECUTED } if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) { errno = EINVAL; 11df08: e8 cf 3e ff ff call 111ddc <__errno> 11df0d: c7 00 16 00 00 00 movl $0x16,(%eax) return (void *) 0; 11df13: 31 db xor %ebx,%ebx 11df15: eb d4 jmp 11deeb 11df17: 90 nop /* * Continue with realloc(). */ if ( !ptr ) return malloc( size ); 11df18: 83 ec 0c sub $0xc,%esp 11df1b: 56 push %esi 11df1c: e8 e7 99 fe ff call 107908 11df21: 89 c3 mov %eax,%ebx 11df23: 83 c4 10 add $0x10,%esp 11df26: eb c3 jmp 11deeb /* * 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) 11df28: a1 ec 64 12 00 mov 0x1264ec,%eax 11df2d: 85 c0 test %eax,%eax 11df2f: 74 04 je 11df35 <== ALWAYS TAKEN new_area = malloc( size ); MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ if ( !new_area ) { return (void *) 0; 11df31: 31 db xor %ebx,%ebx 11df33: eb b6 jmp 11deeb if (_System_state_Is_up(_System_state_Get())) { if (_Thread_Dispatch_disable_level > 0) return (void *) 0; if (_ISR_Nest_level > 0) 11df35: 8b 0d 74 67 12 00 mov 0x126774,%ecx 11df3b: 85 c9 test %ecx,%ecx 11df3d: 0f 84 73 ff ff ff je 11deb6 <== ALWAYS TAKEN new_area = malloc( size ); MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ if ( !new_area ) { return (void *) 0; 11df43: 31 db xor %ebx,%ebx 11df45: eb a4 jmp 11deeb <== NOT EXECUTED 11df47: 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 ); 11df48: 83 ec 0c sub $0xc,%esp 11df4b: 56 push %esi 11df4c: e8 b7 99 fe ff call 107908 MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ 11df51: ff 0d a4 63 12 00 decl 0x1263a4 if ( !new_area ) { 11df57: 83 c4 10 add $0x10,%esp 11df5a: 85 c0 test %eax,%eax 11df5c: 74 d3 je 11df31 return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 11df5e: 8b 55 e4 mov -0x1c(%ebp),%edx 11df61: 89 f1 mov %esi,%ecx 11df63: 39 d6 cmp %edx,%esi 11df65: 76 02 jbe 11df69 <== NEVER TAKEN 11df67: 89 d1 mov %edx,%ecx 11df69: 89 c7 mov %eax,%edi 11df6b: 89 de mov %ebx,%esi 11df6d: f3 a4 rep movsb %ds:(%esi),%es:(%edi) free( ptr ); 11df6f: 83 ec 0c sub $0xc,%esp 11df72: 53 push %ebx 11df73: 89 45 d4 mov %eax,-0x2c(%ebp) 11df76: e8 b9 96 fe ff call 107634 return new_area; 11df7b: 83 c4 10 add $0x10,%esp 11df7e: 8b 45 d4 mov -0x2c(%ebp),%eax 11df81: 89 c3 mov %eax,%ebx 11df83: e9 63 ff ff ff jmp 11deeb =============================================================================== 001088a8 : #include int rmdir( const char *pathname ) { 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 58 sub $0x58,%esp 1088b1: 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 ); 1088b4: 53 push %ebx 1088b5: e8 1e f1 ff ff call 1079d8 if ( parentpathlen == 0 ) 1088ba: 83 c4 10 add $0x10,%esp 1088bd: 85 c0 test %eax,%eax 1088bf: 0f 85 0f 01 00 00 jne 1089d4 rtems_filesystem_get_start_loc( pathname, &i, &parentloc ); 1088c5: 50 push %eax 1088c6: 8d 45 d0 lea -0x30(%ebp),%eax 1088c9: 89 45 b4 mov %eax,-0x4c(%ebp) 1088cc: 50 push %eax 1088cd: 8d 45 e4 lea -0x1c(%ebp),%eax 1088d0: 50 push %eax 1088d1: 53 push %ebx 1088d2: e8 45 01 00 00 call 108a1c 1088d7: 83 c4 10 add $0x10,%esp 1088da: 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; 1088dc: c6 45 b3 00 movb $0x0,-0x4d(%ebp) /* * Start from the parent to find the node that should be under it. */ loc = parentloc; 1088e0: 8d 7d bc lea -0x44(%ebp),%edi 1088e3: b9 05 00 00 00 mov $0x5,%ecx 1088e8: 8b 75 b4 mov -0x4c(%ebp),%esi 1088eb: f3 a5 rep movsl %ds:(%esi),%es:(%edi) name = pathname + parentpathlen; 1088ed: 01 d3 add %edx,%ebx name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 1088ef: be ff ff ff ff mov $0xffffffff,%esi 1088f4: 89 f1 mov %esi,%ecx 1088f6: 89 df mov %ebx,%edi 1088f8: 31 c0 xor %eax,%eax 1088fa: f2 ae repnz scas %es:(%edi),%al 1088fc: f7 d1 not %ecx 1088fe: 49 dec %ecx 1088ff: 83 ec 08 sub $0x8,%esp 108902: 51 push %ecx 108903: 53 push %ebx 108904: e8 13 f1 ff ff call 107a1c 108909: 01 c3 add %eax,%ebx result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 10890b: 89 f1 mov %esi,%ecx 10890d: 89 df mov %ebx,%edi 10890f: 31 c0 xor %eax,%eax 108911: f2 ae repnz scas %es:(%edi),%al 108913: f7 d1 not %ecx 108915: 49 dec %ecx 108916: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10891d: 8d 75 bc lea -0x44(%ebp),%esi 108920: 56 push %esi 108921: 6a 00 push $0x0 108923: 51 push %ecx 108924: 53 push %ebx 108925: e8 02 f0 ff ff call 10792c 0, &loc, false ); if ( result != 0 ) { 10892a: 83 c4 20 add $0x20,%esp 10892d: 85 c0 test %eax,%eax 10892f: 75 5b jne 10898c } /* * Verify you can remove this node as a directory. */ if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 108931: 83 ec 0c sub $0xc,%esp 108934: 56 push %esi 108935: 8b 45 c8 mov -0x38(%ebp),%eax 108938: ff 50 10 call *0x10(%eax) 10893b: 83 c4 10 add $0x10,%esp 10893e: 48 dec %eax 10893f: 75 5f jne 1089a0 /* * Use the filesystems rmnod to remove the node. */ result = (*loc.handlers->rmnod_h)( &parentloc, &loc ); 108941: 83 ec 08 sub $0x8,%esp 108944: 56 push %esi 108945: ff 75 b4 pushl -0x4c(%ebp) 108948: 8b 45 c4 mov -0x3c(%ebp),%eax 10894b: ff 50 34 call *0x34(%eax) rtems_filesystem_freenode( &loc ); 10894e: 89 34 24 mov %esi,(%esp) 108951: 89 45 ac mov %eax,-0x54(%ebp) 108954: e8 13 f1 ff ff call 107a6c if ( free_parentloc ) 108959: 83 c4 10 add $0x10,%esp 10895c: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp) 108960: 8b 45 ac mov -0x54(%ebp),%eax 108963: 75 0b jne 108970 rtems_filesystem_freenode( &parentloc ); return result; } 108965: 8d 65 f4 lea -0xc(%ebp),%esp 108968: 5b pop %ebx 108969: 5e pop %esi 10896a: 5f pop %edi 10896b: c9 leave 10896c: c3 ret 10896d: 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 ); 108970: 83 ec 0c sub $0xc,%esp 108973: ff 75 b4 pushl -0x4c(%ebp) 108976: e8 f1 f0 ff ff call 107a6c 10897b: 83 c4 10 add $0x10,%esp 10897e: 8b 45 ac mov -0x54(%ebp),%eax return result; } 108981: 8d 65 f4 lea -0xc(%ebp),%esp 108984: 5b pop %ebx 108985: 5e pop %esi 108986: 5f pop %edi 108987: c9 leave 108988: c3 ret 108989: 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 ) 10898c: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp) 108990: 75 6f jne 108a01 rtems_filesystem_freenode( &parentloc ); return -1; 108992: b8 ff ff ff ff mov $0xffffffff,%eax rtems_filesystem_freenode( &loc ); if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); return result; } 108997: 8d 65 f4 lea -0xc(%ebp),%esp 10899a: 5b pop %ebx 10899b: 5e pop %esi 10899c: 5f pop %edi 10899d: c9 leave 10899e: c3 ret 10899f: 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 ); 1089a0: 83 ec 0c sub $0xc,%esp 1089a3: 56 push %esi 1089a4: e8 c3 f0 ff ff call 107a6c if ( free_parentloc ) 1089a9: 83 c4 10 add $0x10,%esp 1089ac: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp) 1089b0: 74 0e je 1089c0 <== NEVER TAKEN rtems_filesystem_freenode( &parentloc ); 1089b2: 83 ec 0c sub $0xc,%esp 1089b5: ff 75 b4 pushl -0x4c(%ebp) 1089b8: e8 af f0 ff ff call 107a6c 1089bd: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( ENOTDIR ); 1089c0: e8 3f 9c 00 00 call 112604 <__errno> 1089c5: c7 00 14 00 00 00 movl $0x14,(%eax) 1089cb: b8 ff ff ff ff mov $0xffffffff,%eax 1089d0: eb 93 jmp 108965 1089d2: 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, 1089d4: 89 c2 mov %eax,%edx 1089d6: 83 ec 0c sub $0xc,%esp 1089d9: 6a 00 push $0x0 1089db: 8d 45 d0 lea -0x30(%ebp),%eax 1089de: 89 45 b4 mov %eax,-0x4c(%ebp) 1089e1: 50 push %eax 1089e2: 6a 02 push $0x2 1089e4: 52 push %edx 1089e5: 53 push %ebx 1089e6: 89 55 ac mov %edx,-0x54(%ebp) 1089e9: e8 a6 ef ff ff call 107994 RTEMS_LIBIO_PERMS_WRITE, &parentloc, false ); if ( result != 0 ) 1089ee: 83 c4 20 add $0x20,%esp 1089f1: 85 c0 test %eax,%eax 1089f3: 8b 55 ac mov -0x54(%ebp),%edx 1089f6: 75 9a jne 108992 <== NEVER TAKEN return -1; free_parentloc = true; 1089f8: c6 45 b3 01 movb $0x1,-0x4d(%ebp) 1089fc: e9 df fe ff ff jmp 1088e0 result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 0, &loc, false ); if ( result != 0 ) { if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); 108a01: 83 ec 0c sub $0xc,%esp 108a04: ff 75 b4 pushl -0x4c(%ebp) 108a07: e8 60 f0 ff ff call 107a6c 108a0c: 83 c4 10 add $0x10,%esp return -1; 108a0f: b8 ff ff ff ff mov $0xffffffff,%eax 108a14: e9 4c ff ff ff jmp 108965 =============================================================================== 00107d6c : uint32_t rtems_assoc_local_by_name( const rtems_assoc_t *ap, const char *name ) { 107d6c: 55 push %ebp 107d6d: 89 e5 mov %esp,%ebp 107d6f: 83 ec 10 sub $0x10,%esp const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_name(ap, name); 107d72: ff 75 0c pushl 0xc(%ebp) 107d75: ff 75 08 pushl 0x8(%ebp) 107d78: e8 13 02 00 00 call 107f90 if (nap) 107d7d: 83 c4 10 add $0x10,%esp 107d80: 85 c0 test %eax,%eax 107d82: 74 08 je 107d8c return nap->local_value; 107d84: 8b 40 04 mov 0x4(%eax),%eax return 0; } 107d87: c9 leave 107d88: c3 ret 107d89: 8d 76 00 lea 0x0(%esi),%esi nap = rtems_assoc_ptr_by_name(ap, name); if (nap) return nap->local_value; return 0; 107d8c: 31 c0 xor %eax,%eax } 107d8e: c9 leave 107d8f: c3 ret =============================================================================== 0010eff8 : uint32_t rtems_assoc_local_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 10eff8: 55 push %ebp 10eff9: 89 e5 mov %esp,%ebp 10effb: 83 ec 10 sub $0x10,%esp const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_remote(ap, remote_value); 10effe: ff 75 0c pushl 0xc(%ebp) 10f001: ff 75 08 pushl 0x8(%ebp) 10f004: e8 13 00 00 00 call 10f01c if (nap) 10f009: 83 c4 10 add $0x10,%esp 10f00c: 85 c0 test %eax,%eax 10f00e: 74 08 je 10f018 return nap->local_value; 10f010: 8b 40 04 mov 0x4(%eax),%eax return 0; } 10f013: c9 leave 10f014: c3 ret 10f015: 8d 76 00 lea 0x0(%esi),%esi nap = rtems_assoc_ptr_by_remote(ap, remote_value); if (nap) return nap->local_value; return 0; 10f018: 31 c0 xor %eax,%eax } 10f01a: c9 leave 10f01b: c3 ret =============================================================================== 0011191c : uint32_t rtems_assoc_local_by_remote_bitfield( const rtems_assoc_t *ap, uint32_t remote_value ) { 11191c: 55 push %ebp 11191d: 89 e5 mov %esp,%ebp 11191f: 57 push %edi 111920: 56 push %esi 111921: 53 push %ebx 111922: 83 ec 1c sub $0x1c,%esp 111925: 8b 7d 0c mov 0xc(%ebp),%edi 111928: be 20 00 00 00 mov $0x20,%esi uint32_t b; uint32_t local_value = 0; 11192d: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) for (b = 1; b; b <<= 1) { 111934: bb 01 00 00 00 mov $0x1,%ebx 111939: eb 06 jmp 111941 11193b: 90 nop 11193c: d1 e3 shl %ebx 11193e: 4e dec %esi 11193f: 74 1b je 11195c if (b & remote_value) 111941: 85 fb test %edi,%ebx 111943: 74 f7 je 11193c local_value |= rtems_assoc_local_by_remote(ap, b); 111945: 83 ec 08 sub $0x8,%esp 111948: 53 push %ebx 111949: ff 75 08 pushl 0x8(%ebp) 11194c: e8 a7 d6 ff ff call 10eff8 111951: 09 45 e4 or %eax,-0x1c(%ebp) 111954: 83 c4 10 add $0x10,%esp ) { uint32_t b; uint32_t local_value = 0; for (b = 1; b; b <<= 1) { 111957: d1 e3 shl %ebx 111959: 4e dec %esi 11195a: 75 e5 jne 111941 <== ALWAYS TAKEN if (b & remote_value) local_value |= rtems_assoc_local_by_remote(ap, b); } return local_value; } 11195c: 8b 45 e4 mov -0x1c(%ebp),%eax 11195f: 8d 65 f4 lea -0xc(%ebp),%esp 111962: 5b pop %ebx 111963: 5e pop %esi 111964: 5f pop %edi 111965: c9 leave 111966: c3 ret =============================================================================== 001140bc : const char *rtems_assoc_name_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 1140bc: 55 push %ebp 1140bd: 89 e5 mov %esp,%ebp 1140bf: 53 push %ebx 1140c0: 83 ec 0c sub $0xc,%esp 1140c3: 8b 5d 0c mov 0xc(%ebp),%ebx const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 1140c6: 53 push %ebx 1140c7: ff 75 08 pushl 0x8(%ebp) 1140ca: e8 1d 00 00 00 call 1140ec if (nap) 1140cf: 83 c4 10 add $0x10,%esp 1140d2: 85 c0 test %eax,%eax 1140d4: 74 0a je 1140e0 return nap->name; 1140d6: 8b 00 mov (%eax),%eax return rtems_assoc_name_bad(local_value); } 1140d8: 8b 5d fc mov -0x4(%ebp),%ebx 1140db: c9 leave 1140dc: c3 ret 1140dd: 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); 1140e0: 89 5d 08 mov %ebx,0x8(%ebp) } 1140e3: 8b 5d fc mov -0x4(%ebp),%ebx 1140e6: c9 leave nap = rtems_assoc_ptr_by_local(ap, local_value); if (nap) return nap->name; return rtems_assoc_name_bad(local_value); 1140e7: e9 00 2b 00 00 jmp 116bec =============================================================================== 00107f08 : const char *rtems_assoc_name_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 107f08: 55 push %ebp 107f09: 89 e5 mov %esp,%ebp 107f0b: 53 push %ebx 107f0c: 83 ec 0c sub $0xc,%esp 107f0f: 8b 5d 0c mov 0xc(%ebp),%ebx const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_remote(ap, remote_value); 107f12: 53 push %ebx 107f13: ff 75 08 pushl 0x8(%ebp) 107f16: e8 ed 00 00 00 call 108008 if (nap) 107f1b: 83 c4 10 add $0x10,%esp 107f1e: 85 c0 test %eax,%eax 107f20: 74 0a je 107f2c return nap->name; 107f22: 8b 00 mov (%eax),%eax return rtems_assoc_name_bad(remote_value); } 107f24: 8b 5d fc mov -0x4(%ebp),%ebx 107f27: c9 leave 107f28: c3 ret 107f29: 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); 107f2c: 89 5d 08 mov %ebx,0x8(%ebp) } 107f2f: 8b 5d fc mov -0x4(%ebp),%ebx 107f32: c9 leave nap = rtems_assoc_ptr_by_remote(ap, remote_value); if (nap) return nap->name; return rtems_assoc_name_bad(remote_value); 107f33: e9 40 7d 00 00 jmp 10fc78 =============================================================================== 001140ec : const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 1140ec: 55 push %ebp 1140ed: 89 e5 mov %esp,%ebp 1140ef: 57 push %edi 1140f0: 56 push %esi 1140f1: 53 push %ebx 1140f2: 8b 45 08 mov 0x8(%ebp),%eax 1140f5: 8b 55 0c mov 0xc(%ebp),%edx const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 1140f8: 8b 30 mov (%eax),%esi 1140fa: 85 f6 test %esi,%esi 1140fc: 74 3e je 11413c 1140fe: bf d8 61 12 00 mov $0x1261d8,%edi 114103: b9 0a 00 00 00 mov $0xa,%ecx 114108: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 11410a: 74 18 je 114124 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; 11410c: 31 c9 xor %ecx,%ecx 11410e: eb 09 jmp 114119 if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 114110: 83 c0 0c add $0xc,%eax 114113: 8b 18 mov (%eax),%ebx 114115: 85 db test %ebx,%ebx 114117: 74 1b je 114134 if (ap->local_value == local_value) 114119: 39 50 04 cmp %edx,0x4(%eax) 11411c: 75 f2 jne 114110 return ap; return default_ap; } 11411e: 5b pop %ebx 11411f: 5e pop %esi 114120: 5f pop %edi 114121: c9 leave 114122: c3 ret 114123: 90 nop ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 114124: 8d 58 0c lea 0xc(%eax),%ebx for ( ; ap->name; ap++) 114127: 8b 70 0c mov 0xc(%eax),%esi 11412a: 85 f6 test %esi,%esi 11412c: 74 f0 je 11411e <== NEVER TAKEN 11412e: 89 c1 mov %eax,%ecx 114130: 89 d8 mov %ebx,%eax 114132: eb e5 jmp 114119 114134: 89 c8 mov %ecx,%eax if (ap->local_value == local_value) return ap; return default_ap; } 114136: 5b pop %ebx 114137: 5e pop %esi 114138: 5f pop %edi 114139: c9 leave 11413a: c3 ret 11413b: 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; 11413c: 31 c0 xor %eax,%eax for ( ; ap->name; ap++) if (ap->local_value == local_value) return ap; return default_ap; } 11413e: 5b pop %ebx 11413f: 5e pop %esi 114140: 5f pop %edi 114141: c9 leave 114142: c3 ret =============================================================================== 00107f90 : const rtems_assoc_t *rtems_assoc_ptr_by_name( const rtems_assoc_t *ap, const char *name ) { 107f90: 55 push %ebp 107f91: 89 e5 mov %esp,%ebp 107f93: 57 push %edi 107f94: 56 push %esi 107f95: 53 push %ebx 107f96: 83 ec 0c sub $0xc,%esp 107f99: 8b 5d 08 mov 0x8(%ebp),%ebx const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 107f9c: 8b 03 mov (%ebx),%eax 107f9e: 85 c0 test %eax,%eax 107fa0: 74 5a je 107ffc 107fa2: bf 7d f6 11 00 mov $0x11f67d,%edi 107fa7: b9 0a 00 00 00 mov $0xa,%ecx 107fac: 89 c6 mov %eax,%esi 107fae: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 107fb0: 74 2e je 107fe0 const rtems_assoc_t *rtems_assoc_ptr_by_name( const rtems_assoc_t *ap, const char *name ) { const rtems_assoc_t *default_ap = 0; 107fb2: 31 f6 xor %esi,%esi 107fb4: eb 0b jmp 107fc1 107fb6: 66 90 xchg %ax,%ax if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 107fb8: 83 c3 0c add $0xc,%ebx 107fbb: 8b 03 mov (%ebx),%eax 107fbd: 85 c0 test %eax,%eax 107fbf: 74 2f je 107ff0 if (strcmp(ap->name, name) == 0) 107fc1: 83 ec 08 sub $0x8,%esp 107fc4: ff 75 0c pushl 0xc(%ebp) 107fc7: 50 push %eax 107fc8: e8 ff b5 00 00 call 1135cc 107fcd: 83 c4 10 add $0x10,%esp 107fd0: 85 c0 test %eax,%eax 107fd2: 75 e4 jne 107fb8 return ap; return default_ap; } 107fd4: 89 d8 mov %ebx,%eax 107fd6: 8d 65 f4 lea -0xc(%ebp),%esp 107fd9: 5b pop %ebx 107fda: 5e pop %esi 107fdb: 5f pop %edi 107fdc: c9 leave 107fdd: c3 ret 107fde: 66 90 xchg %ax,%ax ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 107fe0: 8d 53 0c lea 0xc(%ebx),%edx for ( ; ap->name; ap++) 107fe3: 8b 43 0c mov 0xc(%ebx),%eax 107fe6: 85 c0 test %eax,%eax 107fe8: 74 ea je 107fd4 <== NEVER TAKEN 107fea: 89 de mov %ebx,%esi 107fec: 89 d3 mov %edx,%ebx 107fee: eb d1 jmp 107fc1 107ff0: 89 f3 mov %esi,%ebx if (strcmp(ap->name, name) == 0) return ap; return default_ap; } 107ff2: 89 d8 mov %ebx,%eax 107ff4: 8d 65 f4 lea -0xc(%ebp),%esp 107ff7: 5b pop %ebx 107ff8: 5e pop %esi 107ff9: 5f pop %edi 107ffa: c9 leave 107ffb: 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; 107ffc: 31 db xor %ebx,%ebx for ( ; ap->name; ap++) if (strcmp(ap->name, name) == 0) return ap; return default_ap; } 107ffe: 89 d8 mov %ebx,%eax 108000: 8d 65 f4 lea -0xc(%ebp),%esp 108003: 5b pop %ebx 108004: 5e pop %esi 108005: 5f pop %edi 108006: c9 leave 108007: c3 ret =============================================================================== 0010f01c : const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 10f01c: 55 push %ebp 10f01d: 89 e5 mov %esp,%ebp 10f01f: 57 push %edi 10f020: 56 push %esi 10f021: 53 push %ebx 10f022: 8b 45 08 mov 0x8(%ebp),%eax 10f025: 8b 55 0c mov 0xc(%ebp),%edx const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 10f028: 8b 30 mov (%eax),%esi 10f02a: 85 f6 test %esi,%esi 10f02c: 74 3e je 10f06c 10f02e: bf 78 03 12 00 mov $0x120378,%edi 10f033: b9 0a 00 00 00 mov $0xa,%ecx 10f038: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10f03a: 74 18 je 10f054 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; 10f03c: 31 c9 xor %ecx,%ecx 10f03e: eb 09 jmp 10f049 if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 10f040: 83 c0 0c add $0xc,%eax 10f043: 8b 18 mov (%eax),%ebx 10f045: 85 db test %ebx,%ebx 10f047: 74 1b je 10f064 if (ap->remote_value == remote_value) 10f049: 39 50 08 cmp %edx,0x8(%eax) 10f04c: 75 f2 jne 10f040 return ap; return default_ap; } 10f04e: 5b pop %ebx 10f04f: 5e pop %esi 10f050: 5f pop %edi 10f051: c9 leave 10f052: c3 ret 10f053: 90 nop ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 10f054: 8d 58 0c lea 0xc(%eax),%ebx for ( ; ap->name; ap++) 10f057: 8b 70 0c mov 0xc(%eax),%esi 10f05a: 85 f6 test %esi,%esi 10f05c: 74 f0 je 10f04e <== NEVER TAKEN 10f05e: 89 c1 mov %eax,%ecx 10f060: 89 d8 mov %ebx,%eax 10f062: eb e5 jmp 10f049 10f064: 89 c8 mov %ecx,%eax if (ap->remote_value == remote_value) return ap; return default_ap; } 10f066: 5b pop %ebx 10f067: 5e pop %esi 10f068: 5f pop %edi 10f069: c9 leave 10f06a: c3 ret 10f06b: 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; 10f06c: 31 c0 xor %eax,%eax for ( ; ap->name; ap++) if (ap->remote_value == remote_value) return ap; return default_ap; } 10f06e: 5b pop %ebx 10f06f: 5e pop %esi 10f070: 5f pop %edi 10f071: c9 leave 10f072: c3 ret =============================================================================== 001080ac : uint32_t rtems_assoc_remote_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 1080ac: 55 push %ebp 1080ad: 89 e5 mov %esp,%ebp 1080af: 83 ec 10 sub $0x10,%esp const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 1080b2: ff 75 0c pushl 0xc(%ebp) 1080b5: ff 75 08 pushl 0x8(%ebp) 1080b8: e8 7b fe ff ff call 107f38 if (nap) 1080bd: 83 c4 10 add $0x10,%esp 1080c0: 85 c0 test %eax,%eax 1080c2: 74 08 je 1080cc return nap->remote_value; 1080c4: 8b 40 08 mov 0x8(%eax),%eax return 0; } 1080c7: c9 leave 1080c8: c3 ret 1080c9: 8d 76 00 lea 0x0(%esi),%esi nap = rtems_assoc_ptr_by_local(ap, local_value); if (nap) return nap->remote_value; return 0; 1080cc: 31 c0 xor %eax,%eax } 1080ce: c9 leave 1080cf: c3 ret =============================================================================== 00108060 : uint32_t rtems_assoc_remote_by_local_bitfield( const rtems_assoc_t *ap, uint32_t local_value ) { 108060: 55 push %ebp 108061: 89 e5 mov %esp,%ebp 108063: 57 push %edi 108064: 56 push %esi 108065: 53 push %ebx 108066: 83 ec 1c sub $0x1c,%esp 108069: 8b 7d 0c mov 0xc(%ebp),%edi 10806c: be 20 00 00 00 mov $0x20,%esi uint32_t b; uint32_t remote_value = 0; 108071: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) for (b = 1; b; b <<= 1) 108078: bb 01 00 00 00 mov $0x1,%ebx 10807d: eb 06 jmp 108085 10807f: 90 nop 108080: d1 e3 shl %ebx 108082: 4e dec %esi 108083: 74 1b je 1080a0 if (b & local_value) 108085: 85 fb test %edi,%ebx 108087: 74 f7 je 108080 remote_value |= rtems_assoc_remote_by_local(ap, b); 108089: 83 ec 08 sub $0x8,%esp 10808c: 53 push %ebx 10808d: ff 75 08 pushl 0x8(%ebp) 108090: e8 17 00 00 00 call 1080ac 108095: 09 45 e4 or %eax,-0x1c(%ebp) 108098: 83 c4 10 add $0x10,%esp ) { uint32_t b; uint32_t remote_value = 0; for (b = 1; b; b <<= 1) 10809b: d1 e3 shl %ebx 10809d: 4e dec %esi 10809e: 75 e5 jne 108085 <== ALWAYS TAKEN if (b & local_value) remote_value |= rtems_assoc_remote_by_local(ap, b); return remote_value; } 1080a0: 8b 45 e4 mov -0x1c(%ebp),%eax 1080a3: 8d 65 f4 lea -0xc(%ebp),%esp 1080a6: 5b pop %ebx 1080a7: 5e pop %esi 1080a8: 5f pop %edi 1080a9: c9 leave 1080aa: c3 ret =============================================================================== 001080d0 : uint32_t rtems_assoc_remote_by_name( const rtems_assoc_t *ap, const char *name ) { 1080d0: 55 push %ebp 1080d1: 89 e5 mov %esp,%ebp 1080d3: 83 ec 10 sub $0x10,%esp const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_name(ap, name); 1080d6: ff 75 0c pushl 0xc(%ebp) 1080d9: ff 75 08 pushl 0x8(%ebp) 1080dc: e8 af fe ff ff call 107f90 if (nap) 1080e1: 83 c4 10 add $0x10,%esp 1080e4: 85 c0 test %eax,%eax 1080e6: 74 08 je 1080f0 return nap->remote_value; 1080e8: 8b 40 08 mov 0x8(%eax),%eax return 0; } 1080eb: c9 leave 1080ec: c3 ret 1080ed: 8d 76 00 lea 0x0(%esi),%esi nap = rtems_assoc_ptr_by_name(ap, name); if (nap) return nap->remote_value; return 0; 1080f0: 31 c0 xor %eax,%eax } 1080f2: c9 leave 1080f3: c3 ret =============================================================================== 00112024 : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 112024: 55 push %ebp 112025: 89 e5 mov %esp,%ebp 112027: 57 push %edi 112028: 56 push %esi 112029: 53 push %ebx 11202a: 83 ec 2c sub $0x2c,%esp 11202d: 8b 5d 08 mov 0x8(%ebp),%ebx 112030: 8b 7d 0c mov 0xc(%ebp),%edi 112033: 8b 45 10 mov 0x10(%ebp),%eax 112036: 8b 75 14 mov 0x14(%ebp),%esi Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 112039: 85 db test %ebx,%ebx 11203b: 0f 84 87 00 00 00 je 1120c8 return RTEMS_INVALID_NAME; if ( !id ) 112041: 85 f6 test %esi,%esi 112043: 0f 84 bf 00 00 00 je 112108 return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 112049: f7 c7 10 00 00 00 test $0x10,%edi 11204f: 0f 84 83 00 00 00 je 1120d8 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 112055: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) if ( maximum_waiters == 0 ) 11205c: 85 c0 test %eax,%eax 11205e: 0f 84 80 00 00 00 je 1120e4 return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; the_attributes.maximum_count = maximum_waiters; 112064: 89 45 e4 mov %eax,-0x1c(%ebp) 112067: a1 ec 88 12 00 mov 0x1288ec,%eax 11206c: 40 inc %eax 11206d: a3 ec 88 12 00 mov %eax,0x1288ec * 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 ); 112072: 83 ec 0c sub $0xc,%esp 112075: 68 e0 8b 12 00 push $0x128be0 11207a: e8 45 b9 ff ff call 10d9c4 <_Objects_Allocate> _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 11207f: 83 c4 10 add $0x10,%esp 112082: 85 c0 test %eax,%eax 112084: 74 6e je 1120f4 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 112086: 89 78 10 mov %edi,0x10(%eax) _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 112089: 83 ec 08 sub $0x8,%esp 11208c: 8d 55 e0 lea -0x20(%ebp),%edx 11208f: 52 push %edx 112090: 8d 50 14 lea 0x14(%eax),%edx 112093: 52 push %edx 112094: 89 45 d4 mov %eax,-0x2c(%ebp) 112097: e8 44 0a 00 00 call 112ae0 <_CORE_barrier_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 11209c: 8b 45 d4 mov -0x2c(%ebp),%eax 11209f: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 1120a2: 0f b7 fa movzwl %dx,%edi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 1120a5: 8b 0d fc 8b 12 00 mov 0x128bfc,%ecx 1120ab: 89 04 b9 mov %eax,(%ecx,%edi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 1120ae: 89 58 0c mov %ebx,0xc(%eax) &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 1120b1: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 1120b3: e8 c8 c8 ff ff call 10e980 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1120b8: 83 c4 10 add $0x10,%esp 1120bb: 31 c0 xor %eax,%eax } 1120bd: 8d 65 f4 lea -0xc(%ebp),%esp 1120c0: 5b pop %ebx 1120c1: 5e pop %esi 1120c2: 5f pop %edi 1120c3: c9 leave 1120c4: c3 ret 1120c5: 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; 1120c8: b8 03 00 00 00 mov $0x3,%eax *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1120cd: 8d 65 f4 lea -0xc(%ebp),%esp 1120d0: 5b pop %ebx 1120d1: 5e pop %esi 1120d2: 5f pop %edi 1120d3: c9 leave 1120d4: c3 ret 1120d5: 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; 1120d8: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) 1120df: eb 83 jmp 112064 1120e1: 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; 1120e4: b8 0a 00 00 00 mov $0xa,%eax *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1120e9: 8d 65 f4 lea -0xc(%ebp),%esp 1120ec: 5b pop %ebx 1120ed: 5e pop %esi 1120ee: 5f pop %edi 1120ef: c9 leave 1120f0: c3 ret 1120f1: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { _Thread_Enable_dispatch(); 1120f4: e8 87 c8 ff ff call 10e980 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 1120f9: b8 05 00 00 00 mov $0x5,%eax *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1120fe: 8d 65 f4 lea -0xc(%ebp),%esp 112101: 5b pop %ebx 112102: 5e pop %esi 112103: 5f pop %edi 112104: c9 leave 112105: c3 ret 112106: 66 90 xchg %ax,%ax if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 112108: b8 09 00 00 00 mov $0x9,%eax 11210d: eb ae jmp 1120bd =============================================================================== 001072cc : const char *rtems_bsp_cmdline_get_param( const char *name, char *value, size_t length ) { 1072cc: 55 push %ebp 1072cd: 89 e5 mov %esp,%ebp 1072cf: 57 push %edi 1072d0: 56 push %esi 1072d1: 53 push %ebx 1072d2: 83 ec 1c sub $0x1c,%esp 1072d5: 8b 45 08 mov 0x8(%ebp),%eax 1072d8: 8b 5d 0c mov 0xc(%ebp),%ebx 1072db: 8b 75 10 mov 0x10(%ebp),%esi const char *p; if ( !name ) 1072de: 85 c0 test %eax,%eax 1072e0: 75 0a jne 1072ec value[0] = '\0'; p = rtems_bsp_cmdline_get_param_raw( name ); if ( !p ) return NULL; 1072e2: 31 c0 xor %eax,%eax copy_string( p, value, length ); return value; } 1072e4: 8d 65 f4 lea -0xc(%ebp),%esp 1072e7: 5b pop %ebx 1072e8: 5e pop %esi 1072e9: 5f pop %edi 1072ea: c9 leave 1072eb: c3 ret const char *p; if ( !name ) return NULL; if ( !value ) 1072ec: 85 db test %ebx,%ebx 1072ee: 74 f2 je 1072e2 return NULL; if ( !length ) 1072f0: 85 f6 test %esi,%esi 1072f2: 74 ee je 1072e2 return NULL; value[0] = '\0'; 1072f4: c6 03 00 movb $0x0,(%ebx) p = rtems_bsp_cmdline_get_param_raw( name ); 1072f7: 83 ec 0c sub $0xc,%esp 1072fa: 50 push %eax 1072fb: e8 4c 00 00 00 call 10734c if ( !p ) 107300: 83 c4 10 add $0x10,%esp 107303: 85 c0 test %eax,%eax 107305: 74 db je 1072e2 int i; int quotes; const char *p = start; quotes=0; for (i=0 ; *p && i<== NEVER TAKEN 10730d: 4e dec %esi 10730e: 89 75 e4 mov %esi,-0x1c(%ebp) 107311: 74 34 je 107347 <== NEVER TAKEN 107313: 31 f6 xor %esi,%esi 107315: 31 d2 xor %edx,%edx 107317: 31 ff xor %edi,%edi 107319: eb 24 jmp 10733f 10731b: 90 nop if ( *p == '\"' ) { quotes++; } else if ( ((quotes % 2) == 0) && *p == ' ' ) 10731c: f7 c7 01 00 00 00 test $0x1,%edi 107322: 75 05 jne 107329 107324: 80 f9 20 cmp $0x20,%cl 107327: 74 1e je 107347 break; value[i++] = *p++; 107329: 88 0c 33 mov %cl,(%ebx,%esi,1) 10732c: 42 inc %edx value[i] = '\0'; 10732d: c6 04 13 00 movb $0x0,(%ebx,%edx,1) int i; int quotes; const char *p = start; quotes=0; for (i=0 ; *p && i 107338: 3b 55 e4 cmp -0x1c(%ebp),%edx 10733b: 73 0a jae 107347 10733d: 89 d6 mov %edx,%esi if ( *p == '\"' ) { 10733f: 80 f9 22 cmp $0x22,%cl 107342: 75 d8 jne 10731c quotes++; 107344: 47 inc %edi 107345: eb e2 jmp 107329 int i; int quotes; const char *p = start; quotes=0; for (i=0 ; *p && i =============================================================================== 0010734c : extern const char *bsp_boot_cmdline; const char *rtems_bsp_cmdline_get_param_raw( const char *name ) { 10734c: 55 push %ebp 10734d: 89 e5 mov %esp,%ebp 10734f: 83 ec 08 sub $0x8,%esp 107352: 8b 45 08 mov 0x8(%ebp),%eax const char *p; if ( !name ) 107355: 85 c0 test %eax,%eax 107357: 75 07 jne 107360 return NULL; if ( !bsp_boot_cmdline ) return NULL; 107359: 31 c0 xor %eax,%eax p = strstr(bsp_boot_cmdline, name); /* printf( "raw: %p (%s)\n", p, p ); */ return p; } 10735b: c9 leave 10735c: c3 ret 10735d: 8d 76 00 lea 0x0(%esi),%esi const char *p; if ( !name ) return NULL; if ( !bsp_boot_cmdline ) 107360: 8b 15 38 61 12 00 mov 0x126138,%edx 107366: 85 d2 test %edx,%edx 107368: 74 ef je 107359 return NULL; p = strstr(bsp_boot_cmdline, name); 10736a: 83 ec 08 sub $0x8,%esp 10736d: 50 push %eax 10736e: 52 push %edx 10736f: e8 28 c3 00 00 call 11369c 107374: 83 c4 10 add $0x10,%esp /* printf( "raw: %p (%s)\n", p, p ); */ return p; } 107377: c9 leave 107378: c3 ret =============================================================================== 0010b708 : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10b708: 55 push %ebp 10b709: 89 e5 mov %esp,%ebp 10b70b: 56 push %esi 10b70c: 53 push %ebx 10b70d: 8b 5d 10 mov 0x10(%ebp),%ebx 10b710: 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 ); 10b713: 83 ec 08 sub $0x8,%esp 10b716: ff 75 0c pushl 0xc(%ebp) 10b719: ff 75 08 pushl 0x8(%ebp) 10b71c: e8 9f 04 00 00 call 10bbc0 <_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 ) { 10b721: 83 c4 10 add $0x10,%esp 10b724: 84 c0 test %al,%al 10b726: 75 0c jne 10b734 sc = rtems_event_send( task, events ); } return sc; } 10b728: 31 c0 xor %eax,%eax 10b72a: 8d 65 f8 lea -0x8(%ebp),%esp 10b72d: 5b pop %ebx 10b72e: 5e pop %esi 10b72f: c9 leave 10b730: c3 ret 10b731: 8d 76 00 lea 0x0(%esi),%esi { 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 ); 10b734: 89 75 0c mov %esi,0xc(%ebp) 10b737: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10b73a: 8d 65 f8 lea -0x8(%ebp),%esp 10b73d: 5b pop %ebx 10b73e: 5e pop %esi 10b73f: 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 ); 10b740: e9 5f f6 ff ff jmp 10ada4 =============================================================================== 0010b748 : rtems_chain_control *chain, rtems_id task, rtems_event_set events, rtems_chain_node **node ) { 10b748: 55 push %ebp 10b749: 89 e5 mov %esp,%ebp 10b74b: 56 push %esi 10b74c: 53 push %ebx 10b74d: 8b 5d 0c mov 0xc(%ebp),%ebx 10b750: 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 ); 10b753: 83 ec 08 sub $0x8,%esp 10b756: ff 75 14 pushl 0x14(%ebp) 10b759: ff 75 08 pushl 0x8(%ebp) 10b75c: e8 c7 04 00 00 call 10bc28 <_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 ) { 10b761: 83 c4 10 add $0x10,%esp 10b764: 84 c0 test %al,%al 10b766: 75 0c jne 10b774 sc = rtems_event_send( task, events ); } return sc; } 10b768: 31 c0 xor %eax,%eax 10b76a: 8d 65 f8 lea -0x8(%ebp),%esp 10b76d: 5b pop %ebx 10b76e: 5e pop %esi 10b76f: c9 leave 10b770: c3 ret 10b771: 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 ); 10b774: 89 75 0c mov %esi,0xc(%ebp) 10b777: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10b77a: 8d 65 f8 lea -0x8(%ebp),%esp 10b77d: 5b pop %ebx 10b77e: 5e pop %esi 10b77f: 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 ); 10b780: e9 1f f6 ff ff jmp 10ada4 =============================================================================== 0010b788 : rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) { 10b788: 55 push %ebp 10b789: 89 e5 mov %esp,%ebp 10b78b: 57 push %edi 10b78c: 56 push %esi 10b78d: 53 push %ebx 10b78e: 83 ec 1c sub $0x1c,%esp 10b791: 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( 10b794: 8d 7d e4 lea -0x1c(%ebp),%edi 10b797: 90 nop */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 10b798: 83 ec 0c sub $0xc,%esp 10b79b: 56 push %esi 10b79c: e8 c3 04 00 00 call 10bc64 <_Chain_Get> 10b7a1: 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 10b7a3: 83 c4 10 add $0x10,%esp 10b7a6: 85 c0 test %eax,%eax 10b7a8: 75 22 jne 10b7cc ) { rtems_event_set out; sc = rtems_event_receive( 10b7aa: 57 push %edi 10b7ab: ff 75 10 pushl 0x10(%ebp) 10b7ae: 6a 00 push $0x0 10b7b0: ff 75 0c pushl 0xc(%ebp) 10b7b3: e8 64 f4 ff ff call 10ac1c ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( 10b7b8: 83 c4 10 add $0x10,%esp 10b7bb: 85 c0 test %eax,%eax 10b7bd: 74 d9 je 10b798 <== NEVER TAKEN timeout, &out ); } *node_ptr = node; 10b7bf: 8b 55 14 mov 0x14(%ebp),%edx 10b7c2: 89 1a mov %ebx,(%edx) return sc; } 10b7c4: 8d 65 f4 lea -0xc(%ebp),%esp 10b7c7: 5b pop %ebx 10b7c8: 5e pop %esi 10b7c9: 5f pop %edi 10b7ca: c9 leave 10b7cb: c3 ret rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 10b7cc: 31 c0 xor %eax,%eax timeout, &out ); } *node_ptr = node; 10b7ce: 8b 55 14 mov 0x14(%ebp),%edx 10b7d1: 89 1a mov %ebx,(%edx) return sc; } 10b7d3: 8d 65 f4 lea -0xc(%ebp),%esp 10b7d6: 5b pop %ebx 10b7d7: 5e pop %esi 10b7d8: 5f pop %edi 10b7d9: c9 leave 10b7da: c3 ret =============================================================================== 0010b7dc : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10b7dc: 55 push %ebp 10b7dd: 89 e5 mov %esp,%ebp 10b7df: 56 push %esi 10b7e0: 53 push %ebx 10b7e1: 8b 5d 10 mov 0x10(%ebp),%ebx 10b7e4: 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 ); 10b7e7: 83 ec 08 sub $0x8,%esp 10b7ea: ff 75 0c pushl 0xc(%ebp) 10b7ed: ff 75 08 pushl 0x8(%ebp) 10b7f0: e8 b3 04 00 00 call 10bca8 <_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) { 10b7f5: 83 c4 10 add $0x10,%esp 10b7f8: 84 c0 test %al,%al 10b7fa: 75 0c jne 10b808 sc = rtems_event_send( task, events ); } return sc; } 10b7fc: 31 c0 xor %eax,%eax 10b7fe: 8d 65 f8 lea -0x8(%ebp),%esp 10b801: 5b pop %ebx 10b802: 5e pop %esi 10b803: c9 leave 10b804: c3 ret 10b805: 8d 76 00 lea 0x0(%esi),%esi { 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 ); 10b808: 89 75 0c mov %esi,0xc(%ebp) 10b80b: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10b80e: 8d 65 f8 lea -0x8(%ebp),%esp 10b811: 5b pop %ebx 10b812: 5e pop %esi 10b813: 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 ); 10b814: e9 8b f5 ff ff jmp 10ada4 =============================================================================== 00115088 : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 115088: 55 push %ebp 115089: 89 e5 mov %esp,%ebp 11508b: 53 push %ebx 11508c: 83 ec 04 sub $0x4,%esp 11508f: 8b 45 08 mov 0x8(%ebp),%eax 115092: 8b 5d 0c mov 0xc(%ebp),%ebx if ( !time_buffer ) 115095: 85 db test %ebx,%ebx 115097: 74 3b je 1150d4 return RTEMS_INVALID_ADDRESS; if ( option == RTEMS_CLOCK_GET_TOD ) 115099: 85 c0 test %eax,%eax 11509b: 74 2b je 1150c8 return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); if ( option == RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH ) 11509d: 83 f8 01 cmp $0x1,%eax 1150a0: 74 3e je 1150e0 return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) { 1150a2: 83 f8 02 cmp $0x2,%eax 1150a5: 74 45 je 1150ec *interval = rtems_clock_get_ticks_since_boot(); return RTEMS_SUCCESSFUL; } if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) { 1150a7: 83 f8 03 cmp $0x3,%eax 1150aa: 74 4c je 1150f8 *interval = rtems_clock_get_ticks_per_second(); return RTEMS_SUCCESSFUL; } if ( option == RTEMS_CLOCK_GET_TIME_VALUE ) 1150ac: 83 f8 04 cmp $0x4,%eax 1150af: 74 0b je 1150bc return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); return RTEMS_INVALID_NUMBER; 1150b1: b8 0a 00 00 00 mov $0xa,%eax } 1150b6: 5a pop %edx 1150b7: 5b pop %ebx 1150b8: c9 leave 1150b9: c3 ret 1150ba: 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 ); 1150bc: 89 5d 08 mov %ebx,0x8(%ebp) return RTEMS_INVALID_NUMBER; } 1150bf: 59 pop %ecx 1150c0: 5b pop %ebx 1150c1: 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 ); 1150c2: e9 41 01 00 00 jmp 115208 1150c7: 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 ); 1150c8: 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; } 1150cb: 58 pop %eax 1150cc: 5b pop %ebx 1150cd: 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 ); 1150ce: e9 81 00 00 00 jmp 115154 1150d3: 90 nop rtems_clock_get_options option, void *time_buffer ) { if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; 1150d4: 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; } 1150d9: 5a pop %edx 1150da: 5b pop %ebx 1150db: c9 leave 1150dc: c3 ret 1150dd: 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); 1150e0: 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; } 1150e3: 5b pop %ebx 1150e4: 5b pop %ebx 1150e5: 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); 1150e6: e9 19 00 00 00 jmp 115104 1150eb: 90 nop if ( option == RTEMS_CLOCK_GET_TICKS_SINCE_BOOT ) { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_since_boot(); 1150ec: e8 57 00 00 00 call 115148 1150f1: 89 03 mov %eax,(%ebx) return RTEMS_SUCCESSFUL; 1150f3: 31 c0 xor %eax,%eax 1150f5: eb bf jmp 1150b6 1150f7: 90 nop } if ( option == RTEMS_CLOCK_GET_TICKS_PER_SECOND ) { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_per_second(); 1150f8: e8 37 00 00 00 call 115134 1150fd: 89 03 mov %eax,(%ebx) return RTEMS_SUCCESSFUL; 1150ff: 31 c0 xor %eax,%eax 115101: eb b3 jmp 1150b6 =============================================================================== 00115208 : #include rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { 115208: 55 push %ebp 115209: 89 e5 mov %esp,%ebp 11520b: 56 push %esi 11520c: 53 push %ebx 11520d: 83 ec 10 sub $0x10,%esp 115210: 8b 5d 08 mov 0x8(%ebp),%ebx if ( !time ) 115213: 85 db test %ebx,%ebx 115215: 74 51 je 115268 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 115217: 80 3d fc 08 14 00 00 cmpb $0x0,0x1408fc 11521e: 75 0c jne 11522c return RTEMS_NOT_DEFINED; 115220: b8 0b 00 00 00 mov $0xb,%eax _TOD_Get_timeval( time ); return RTEMS_SUCCESSFUL; } 115225: 8d 65 f8 lea -0x8(%ebp),%esp 115228: 5b pop %ebx 115229: 5e pop %esi 11522a: c9 leave 11522b: c3 ret { ISR_Level level; struct timespec now; suseconds_t useconds; _ISR_Disable(level); 11522c: 9c pushf 11522d: fa cli 11522e: 5e pop %esi _TOD_Get( &now ); 11522f: 83 ec 0c sub $0xc,%esp 115232: 8d 45 f0 lea -0x10(%ebp),%eax 115235: 50 push %eax 115236: e8 c9 42 00 00 call 119504 <_TOD_Get> _ISR_Enable(level); 11523b: 56 push %esi 11523c: 9d popf useconds = (suseconds_t)now.tv_nsec; 11523d: 8b 4d f4 mov -0xc(%ebp),%ecx useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND; time->tv_sec = now.tv_sec; 115240: 8b 45 f0 mov -0x10(%ebp),%eax 115243: 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; 115245: b8 d3 4d 62 10 mov $0x10624dd3,%eax 11524a: f7 e9 imul %ecx 11524c: 89 d0 mov %edx,%eax 11524e: c1 f8 06 sar $0x6,%eax 115251: c1 f9 1f sar $0x1f,%ecx 115254: 29 c8 sub %ecx,%eax 115256: 89 43 04 mov %eax,0x4(%ebx) if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); return RTEMS_SUCCESSFUL; 115259: 83 c4 10 add $0x10,%esp 11525c: 31 c0 xor %eax,%eax } 11525e: 8d 65 f8 lea -0x8(%ebp),%esp 115261: 5b pop %ebx 115262: 5e pop %esi 115263: c9 leave 115264: c3 ret 115265: 8d 76 00 lea 0x0(%esi),%esi rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { if ( !time ) return RTEMS_INVALID_ADDRESS; 115268: b8 09 00 00 00 mov $0x9,%eax 11526d: eb b6 jmp 115225 =============================================================================== 0010a77c : * error code - if unsuccessful */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { 10a77c: 55 push %ebp 10a77d: 89 e5 mov %esp,%ebp 10a77f: 83 ec 08 sub $0x8,%esp 10a782: 8b 45 08 mov 0x8(%ebp),%eax if ( !uptime ) 10a785: 85 c0 test %eax,%eax 10a787: 74 13 je 10a79c return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime_as_timespec( uptime ); 10a789: 83 ec 0c sub $0xc,%esp 10a78c: 50 push %eax 10a78d: e8 42 14 00 00 call 10bbd4 <_TOD_Get_uptime_as_timespec> return RTEMS_SUCCESSFUL; 10a792: 83 c4 10 add $0x10,%esp 10a795: 31 c0 xor %eax,%eax } 10a797: c9 leave 10a798: c3 ret 10a799: 8d 76 00 lea 0x0(%esi),%esi rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { if ( !uptime ) return RTEMS_INVALID_ADDRESS; 10a79c: b8 09 00 00 00 mov $0x9,%eax _TOD_Get_uptime_as_timespec( uptime ); return RTEMS_SUCCESSFUL; } 10a7a1: c9 leave 10a7a2: c3 ret =============================================================================== 0010b6f8 : */ rtems_status_code rtems_clock_set( rtems_time_of_day *time_buffer ) { 10b6f8: 55 push %ebp 10b6f9: 89 e5 mov %esp,%ebp 10b6fb: 53 push %ebx 10b6fc: 83 ec 14 sub $0x14,%esp 10b6ff: 8b 5d 08 mov 0x8(%ebp),%ebx struct timespec newtime; if ( !time_buffer ) 10b702: 85 db test %ebx,%ebx 10b704: 74 66 je 10b76c return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { 10b706: 83 ec 0c sub $0xc,%esp 10b709: 53 push %ebx 10b70a: e8 39 01 00 00 call 10b848 <_TOD_Validate> 10b70f: 83 c4 10 add $0x10,%esp 10b712: 84 c0 test %al,%al 10b714: 75 0a jne 10b720 _Thread_Disable_dispatch(); _TOD_Set( &newtime ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; 10b716: b8 14 00 00 00 mov $0x14,%eax } 10b71b: 8b 5d fc mov -0x4(%ebp),%ebx 10b71e: c9 leave 10b71f: c3 ret if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { newtime.tv_sec = _TOD_To_seconds( time_buffer ); 10b720: 83 ec 0c sub $0xc,%esp 10b723: 53 push %ebx 10b724: e8 93 00 00 00 call 10b7bc <_TOD_To_seconds> 10b729: 89 45 f0 mov %eax,-0x10(%ebp) newtime.tv_nsec = time_buffer->ticks * 10b72c: 8b 43 18 mov 0x18(%ebx),%eax 10b72f: 0f af 05 6c 52 12 00 imul 0x12526c,%eax 10b736: 8d 04 80 lea (%eax,%eax,4),%eax 10b739: 8d 04 80 lea (%eax,%eax,4),%eax 10b73c: 8d 04 80 lea (%eax,%eax,4),%eax 10b73f: c1 e0 03 shl $0x3,%eax 10b742: 89 45 f4 mov %eax,-0xc(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b745: a1 cc 98 12 00 mov 0x1298cc,%eax 10b74a: 40 inc %eax 10b74b: a3 cc 98 12 00 mov %eax,0x1298cc rtems_configuration_get_nanoseconds_per_tick(); _Thread_Disable_dispatch(); _TOD_Set( &newtime ); 10b750: 8d 45 f0 lea -0x10(%ebp),%eax 10b753: 89 04 24 mov %eax,(%esp) 10b756: e8 21 17 00 00 call 10ce7c <_TOD_Set> _Thread_Enable_dispatch(); 10b75b: e8 bc 2c 00 00 call 10e41c <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b760: 83 c4 10 add $0x10,%esp 10b763: 31 c0 xor %eax,%eax } return RTEMS_INVALID_CLOCK; } 10b765: 8b 5d fc mov -0x4(%ebp),%ebx 10b768: c9 leave 10b769: c3 ret 10b76a: 66 90 xchg %ax,%ax ) { struct timespec newtime; if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; 10b76c: b8 09 00 00 00 mov $0x9,%eax _TOD_Set( &newtime ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 10b771: 8b 5d fc mov -0x4(%ebp),%ebx 10b774: c9 leave 10b775: c3 ret =============================================================================== 0010a578 : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 10a578: 55 push %ebp 10a579: 89 e5 mov %esp,%ebp 10a57b: 83 ec 08 sub $0x8,%esp _TOD_Tickle_ticks(); 10a57e: e8 05 13 00 00 call 10b888 <_TOD_Tickle_ticks> */ RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void ) { _Watchdog_Tickle( &_Watchdog_Ticks_chain ); 10a583: 83 ec 0c sub $0xc,%esp 10a586: 68 c0 65 12 00 push $0x1265c0 10a58b: e8 24 36 00 00 call 10dbb4 <_Watchdog_Tickle> _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 10a590: e8 17 31 00 00 call 10d6ac <_Thread_Tickle_timeslice> * otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void ) { return ( _Thread_Dispatch_necessary ); 10a595: a0 84 67 12 00 mov 0x126784,%al if ( _Thread_Is_context_switch_necessary() && 10a59a: 83 c4 10 add $0x10,%esp 10a59d: 84 c0 test %al,%al 10a59f: 74 09 je 10a5aa * otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); 10a5a1: a1 ec 64 12 00 mov 0x1264ec,%eax 10a5a6: 85 c0 test %eax,%eax 10a5a8: 74 06 je 10a5b0 _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); return RTEMS_SUCCESSFUL; } 10a5aa: 31 c0 xor %eax,%eax 10a5ac: c9 leave 10a5ad: c3 ret 10a5ae: 66 90 xchg %ax,%ax _Thread_Tickle_timeslice(); if ( _Thread_Is_context_switch_necessary() && _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 10a5b0: e8 cf 25 00 00 call 10cb84 <_Thread_Dispatch> return RTEMS_SUCCESSFUL; } 10a5b5: 31 c0 xor %eax,%eax 10a5b7: c9 leave 10a5b8: c3 ret =============================================================================== 00107980 : void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) { 107980: 55 push %ebp 107981: 89 e5 mov %esp,%ebp 107983: 57 push %edi 107984: 56 push %esi 107985: 53 push %ebx 107986: 83 ec 6c sub $0x6c,%esp Timestamp_Control uptime, total, ran, uptime_at_last_reset; #else uint32_t total_units = 0; #endif if ( !print ) 107989: 8b 55 0c mov 0xc(%ebp),%edx 10798c: 85 d2 test %edx,%edx 10798e: 0f 84 a0 01 00 00 je 107b34 <== 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__ _Timestamp_Set_to_zero( &total ); 107994: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) 10799b: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) uptime_at_last_reset = CPU_usage_Uptime_at_last_reset; 1079a2: a1 00 9c 12 00 mov 0x129c00,%eax 1079a7: 8b 15 04 9c 12 00 mov 0x129c04,%edx 1079ad: 89 45 c0 mov %eax,-0x40(%ebp) 1079b0: 89 55 c4 mov %edx,-0x3c(%ebp) } } } #endif (*print)( 1079b3: 83 ec 08 sub $0x8,%esp 1079b6: 68 30 1f 12 00 push $0x121f30 1079bb: ff 75 08 pushl 0x8(%ebp) 1079be: ff 55 0c call *0xc(%ebp) 1079c1: 83 c4 10 add $0x10,%esp " ID | NAME | TICKS | PERCENT\n" #endif "------------+----------------------------------------+---------------+---------\n" ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 1079c4: c7 45 90 01 00 00 00 movl $0x1,-0x70(%ebp) #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG) if ( !_Objects_Information_table[ api_index ] ) 1079cb: 8b 55 90 mov -0x70(%ebp),%edx 1079ce: 8b 04 95 a4 98 12 00 mov 0x1298a4(,%edx,4),%eax 1079d5: 85 c0 test %eax,%eax 1079d7: 0f 84 2b 01 00 00 je 107b08 continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 1079dd: 8b 70 04 mov 0x4(%eax),%esi if ( information ) { 1079e0: 85 f6 test %esi,%esi 1079e2: 0f 84 20 01 00 00 je 107b08 <== NEVER TAKEN for ( i=1 ; i <= information->maximum ; i++ ) { 1079e8: 66 83 7e 10 00 cmpw $0x0,0x10(%esi) 1079ed: 0f 84 15 01 00 00 je 107b08 <== NEVER TAKEN 1079f3: bb 01 00 00 00 mov $0x1,%ebx 1079f8: eb 6f jmp 107a69 1079fa: 66 90 xchg %ax,%ax Timestamp_Control last = _Thread_Time_of_last_context_switch; _TOD_Get_uptime( &uptime ); _Timestamp_Subtract( &last, &uptime, &used ); _Timestamp_Add_to( &ran, &used ); } else { _TOD_Get_uptime( &uptime ); 1079fc: 83 ec 0c sub $0xc,%esp 1079ff: 8d 7d d8 lea -0x28(%ebp),%edi 107a02: 57 push %edi 107a03: e8 ec 53 00 00 call 10cdf4 <_TOD_Get_uptime> 107a08: 83 c4 10 add $0x10,%esp 107a0b: 8d 55 c8 lea -0x38(%ebp),%edx 107a0e: 89 55 94 mov %edx,-0x6c(%ebp) } _Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total ); 107a11: 50 push %eax 107a12: 8d 45 d0 lea -0x30(%ebp),%eax 107a15: 50 push %eax 107a16: 57 push %edi 107a17: 8d 55 c0 lea -0x40(%ebp),%edx 107a1a: 52 push %edx 107a1b: e8 ec 74 00 00 call 10ef0c <_Timespec_Subtract> _Timestamp_Divide( &ran, &total, &ival, &fval ); 107a20: 8d 45 e0 lea -0x20(%ebp),%eax 107a23: 50 push %eax 107a24: 8d 55 e4 lea -0x1c(%ebp),%edx 107a27: 52 push %edx 107a28: 8d 45 d0 lea -0x30(%ebp),%eax 107a2b: 50 push %eax 107a2c: ff 75 94 pushl -0x6c(%ebp) 107a2f: e8 14 74 00 00 call 10ee48 <_Timespec_Divide> /* * Print the information */ (*print)( context, 107a34: 83 c4 18 add $0x18,%esp 107a37: ff 75 e0 pushl -0x20(%ebp) 107a3a: ff 75 e4 pushl -0x1c(%ebp) 107a3d: ba d3 4d 62 10 mov $0x10624dd3,%edx 107a42: 8b 45 cc mov -0x34(%ebp),%eax 107a45: f7 e2 mul %edx 107a47: c1 ea 06 shr $0x6,%edx 107a4a: 52 push %edx 107a4b: ff 75 c8 pushl -0x38(%ebp) 107a4e: 68 a3 21 12 00 push $0x1221a3 107a53: ff 75 08 pushl 0x8(%ebp) 107a56: ff 55 0c call *0xc(%ebp) 107a59: 83 c4 20 add $0x20,%esp continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 107a5c: 43 inc %ebx 107a5d: 0f b7 46 10 movzwl 0x10(%esi),%eax 107a61: 39 d8 cmp %ebx,%eax 107a63: 0f 82 9f 00 00 00 jb 107b08 the_thread = (Thread_Control *)information->local_table[ i ]; 107a69: 8b 46 1c mov 0x1c(%esi),%eax 107a6c: 8b 3c 98 mov (%eax,%ebx,4),%edi if ( !the_thread ) 107a6f: 85 ff test %edi,%edi 107a71: 74 e9 je 107a5c <== NEVER TAKEN continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 107a73: 50 push %eax 107a74: 8d 45 a3 lea -0x5d(%ebp),%eax 107a77: 50 push %eax 107a78: 6a 0d push $0xd 107a7a: ff 77 08 pushl 0x8(%edi) 107a7d: e8 aa 41 00 00 call 10bc2c (*print)( 107a82: 8d 55 a3 lea -0x5d(%ebp),%edx 107a85: 52 push %edx 107a86: ff 77 08 pushl 0x8(%edi) 107a89: 68 90 21 12 00 push $0x122190 107a8e: ff 75 08 pushl 0x8(%ebp) 107a91: 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; 107a94: 8b 87 84 00 00 00 mov 0x84(%edi),%eax 107a9a: 8b 97 88 00 00 00 mov 0x88(%edi),%edx 107aa0: 89 45 c8 mov %eax,-0x38(%ebp) 107aa3: 89 55 cc mov %edx,-0x34(%ebp) if ( _Thread_Executing->Object.id == the_thread->Object.id ) { 107aa6: 83 c4 20 add $0x20,%esp 107aa9: a1 98 9b 12 00 mov 0x129b98,%eax 107aae: 8b 57 08 mov 0x8(%edi),%edx 107ab1: 39 50 08 cmp %edx,0x8(%eax) 107ab4: 0f 85 42 ff ff ff jne 1079fc Timestamp_Control used; Timestamp_Control last = _Thread_Time_of_last_context_switch; 107aba: a1 8c 99 12 00 mov 0x12998c,%eax 107abf: 8b 15 90 99 12 00 mov 0x129990,%edx 107ac5: 89 45 b0 mov %eax,-0x50(%ebp) 107ac8: 89 55 b4 mov %edx,-0x4c(%ebp) _TOD_Get_uptime( &uptime ); 107acb: 83 ec 0c sub $0xc,%esp 107ace: 8d 7d d8 lea -0x28(%ebp),%edi 107ad1: 57 push %edi 107ad2: e8 1d 53 00 00 call 10cdf4 <_TOD_Get_uptime> _Timestamp_Subtract( &last, &uptime, &used ); 107ad7: 83 c4 0c add $0xc,%esp 107ada: 8d 45 b8 lea -0x48(%ebp),%eax 107add: 50 push %eax 107ade: 57 push %edi 107adf: 8d 55 b0 lea -0x50(%ebp),%edx 107ae2: 52 push %edx 107ae3: 89 45 8c mov %eax,-0x74(%ebp) 107ae6: e8 21 74 00 00 call 10ef0c <_Timespec_Subtract> _Timestamp_Add_to( &ran, &used ); 107aeb: 5a pop %edx 107aec: 59 pop %ecx 107aed: 8b 45 8c mov -0x74(%ebp),%eax 107af0: 50 push %eax 107af1: 8d 45 c8 lea -0x38(%ebp),%eax 107af4: 89 45 94 mov %eax,-0x6c(%ebp) 107af7: 50 push %eax 107af8: e8 0f 73 00 00 call 10ee0c <_Timespec_Add_to> 107afd: 83 c4 10 add $0x10,%esp 107b00: e9 0c ff ff ff jmp 107a11 107b05: 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++ ) { 107b08: ff 45 90 incl -0x70(%ebp) 107b0b: 83 7d 90 04 cmpl $0x4,-0x70(%ebp) 107b0f: 0f 85 b6 fe ff ff jne 1079cb } } } #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( 107b15: ba d3 4d 62 10 mov $0x10624dd3,%edx 107b1a: 8b 45 d4 mov -0x2c(%ebp),%eax 107b1d: f7 e2 mul %edx 107b1f: c1 ea 06 shr $0x6,%edx 107b22: 52 push %edx 107b23: ff 75 d0 pushl -0x30(%ebp) 107b26: 68 a4 20 12 00 push $0x1220a4 107b2b: ff 75 08 pushl 0x8(%ebp) 107b2e: ff 55 0c call *0xc(%ebp) 107b31: 83 c4 10 add $0x10,%esp "-------------------------------------------------------------------------------\n", _Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset, total_units ); #endif } 107b34: 8d 65 f4 lea -0xc(%ebp),%esp 107b37: 5b pop %ebx 107b38: 5e pop %esi 107b39: 5f pop %edi 107b3a: c9 leave 107b3b: c3 ret =============================================================================== 00111d8c : [RTEMS_IO_ERROR] = EIO, [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_deviceio_errno(rtems_status_code sc) { 111d8c: 55 push %ebp 111d8d: 89 e5 mov %esp,%ebp 111d8f: 53 push %ebx 111d90: 83 ec 04 sub $0x4,%esp 111d93: 8b 45 08 mov 0x8(%ebp),%eax if (sc == RTEMS_SUCCESSFUL) { 111d96: 85 c0 test %eax,%eax 111d98: 75 06 jne 111da0 return 0; 111d9a: 31 c0 xor %eax,%eax errno = eno; return -1; } } 111d9c: 5a pop %edx 111d9d: 5b pop %ebx 111d9e: c9 leave 111d9f: c3 ret if (sc == RTEMS_SUCCESSFUL) { return 0; } else { int eno = EINVAL; if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) { 111da0: 83 f8 1c cmp $0x1c,%eax 111da3: 77 17 ja 111dbc <== NEVER TAKEN eno = status_code_to_errno [sc]; 111da5: 8b 1c 85 40 04 12 00 mov 0x120440(,%eax,4),%ebx } errno = eno; 111dac: e8 2b 00 00 00 call 111ddc <__errno> 111db1: 89 18 mov %ebx,(%eax) return -1; 111db3: b8 ff ff ff ff mov $0xffffffff,%eax 111db8: eb e2 jmp 111d9c 111dba: 66 90 xchg %ax,%ax int rtems_deviceio_errno(rtems_status_code sc) { if (sc == RTEMS_SUCCESSFUL) { return 0; } else { int eno = EINVAL; 111dbc: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED 111dc1: eb e9 jmp 111dac <== NOT EXECUTED =============================================================================== 0010a744 : rtems_status_code rtems_event_send( rtems_id id, rtems_event_set event_in ) { 10a744: 55 push %ebp 10a745: 89 e5 mov %esp,%ebp 10a747: 53 push %ebx 10a748: 83 ec 1c sub $0x1c,%esp register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; the_thread = _Thread_Get( id, &location ); 10a74b: 8d 45 f4 lea -0xc(%ebp),%eax 10a74e: 50 push %eax 10a74f: ff 75 08 pushl 0x8(%ebp) 10a752: e8 c9 25 00 00 call 10cd20 <_Thread_Get> switch ( location ) { 10a757: 83 c4 10 add $0x10,%esp 10a75a: 8b 55 f4 mov -0xc(%ebp),%edx 10a75d: 85 d2 test %edx,%edx 10a75f: 75 2b jne 10a78c case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 10a761: 8b 90 e4 00 00 00 mov 0xe4(%eax),%edx rtems_event_set *the_event_set ) { ISR_Level level; _ISR_Disable( level ); 10a767: 9c pushf 10a768: fa cli 10a769: 59 pop %ecx *the_event_set |= the_new_events; 10a76a: 8b 5d 0c mov 0xc(%ebp),%ebx 10a76d: 09 1a or %ebx,(%edx) _ISR_Enable( level ); 10a76f: 51 push %ecx 10a770: 9d popf _Event_sets_Post( event_in, &api->pending_events ); _Event_Surrender( the_thread ); 10a771: 83 ec 0c sub $0xc,%esp 10a774: 50 push %eax 10a775: e8 1e 00 00 00 call 10a798 <_Event_Surrender> _Thread_Enable_dispatch(); 10a77a: e8 7d 25 00 00 call 10ccfc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10a77f: 83 c4 10 add $0x10,%esp 10a782: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a784: 8b 5d fc mov -0x4(%ebp),%ebx 10a787: c9 leave 10a788: c3 ret 10a789: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10a78c: b8 04 00 00 00 mov $0x4,%eax } 10a791: 8b 5d fc mov -0x4(%ebp),%ebx 10a794: c9 leave 10a795: c3 ret =============================================================================== 0010c6bc : rtems_status_code rtems_extension_create( rtems_name name, const rtems_extensions_table *extension_table, rtems_id *id ) { 10c6bc: 55 push %ebp 10c6bd: 89 e5 mov %esp,%ebp 10c6bf: 57 push %edi 10c6c0: 56 push %esi 10c6c1: 53 push %ebx 10c6c2: 83 ec 1c sub $0x1c,%esp 10c6c5: 8b 75 0c mov 0xc(%ebp),%esi 10c6c8: 8b 5d 10 mov 0x10(%ebp),%ebx Extension_Control *the_extension; if ( !id ) 10c6cb: 85 db test %ebx,%ebx 10c6cd: 0f 84 85 00 00 00 je 10c758 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10c6d3: 8b 45 08 mov 0x8(%ebp),%eax 10c6d6: 85 c0 test %eax,%eax 10c6d8: 75 0e jne 10c6e8 return RTEMS_INVALID_NAME; 10c6da: b8 03 00 00 00 mov $0x3,%eax ); *id = the_extension->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10c6df: 8d 65 f4 lea -0xc(%ebp),%esp 10c6e2: 5b pop %ebx 10c6e3: 5e pop %esi 10c6e4: 5f pop %edi 10c6e5: c9 leave 10c6e6: c3 ret 10c6e7: 90 nop rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10c6e8: a1 cc 98 12 00 mov 0x1298cc,%eax 10c6ed: 40 inc %eax 10c6ee: a3 cc 98 12 00 mov %eax,0x1298cc #ifndef __EXTENSION_MANAGER_inl #define __EXTENSION_MANAGER_inl RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Allocate( void ) { return (Extension_Control *) _Objects_Allocate( &_Extension_Information ); 10c6f3: 83 ec 0c sub $0xc,%esp 10c6f6: 68 20 9b 12 00 push $0x129b20 10c6fb: e8 c0 0c 00 00 call 10d3c0 <_Objects_Allocate> _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 10c700: 83 c4 10 add $0x10,%esp 10c703: 85 c0 test %eax,%eax 10c705: 74 45 je 10c74c RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table( User_extensions_Control *extension, const User_extensions_Table *extension_table ) { extension->Callouts = *extension_table; 10c707: 8d 78 24 lea 0x24(%eax),%edi 10c70a: b9 08 00 00 00 mov $0x8,%ecx 10c70f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _User_extensions_Add_set( extension ); 10c711: 83 ec 0c sub $0xc,%esp _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } _User_extensions_Add_set_with_table( &the_extension->Extension, extension_table ); 10c714: 8d 50 10 lea 0x10(%eax),%edx 10c717: 52 push %edx 10c718: 89 45 e4 mov %eax,-0x1c(%ebp) 10c71b: e8 2c 28 00 00 call 10ef4c <_User_extensions_Add_set> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10c720: 8b 45 e4 mov -0x1c(%ebp),%eax 10c723: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10c726: 0f b7 f2 movzwl %dx,%esi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c729: 8b 0d 3c 9b 12 00 mov 0x129b3c,%ecx 10c72f: 89 04 b1 mov %eax,(%ecx,%esi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10c732: 8b 4d 08 mov 0x8(%ebp),%ecx 10c735: 89 48 0c mov %ecx,0xc(%eax) &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 10c738: 89 13 mov %edx,(%ebx) _Thread_Enable_dispatch(); 10c73a: e8 dd 1c 00 00 call 10e41c <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c73f: 83 c4 10 add $0x10,%esp 10c742: 31 c0 xor %eax,%eax } 10c744: 8d 65 f4 lea -0xc(%ebp),%esp 10c747: 5b pop %ebx 10c748: 5e pop %esi 10c749: 5f pop %edi 10c74a: c9 leave 10c74b: c3 ret _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { _Thread_Enable_dispatch(); 10c74c: e8 cb 1c 00 00 call 10e41c <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 10c751: b8 05 00 00 00 mov $0x5,%eax 10c756: eb 87 jmp 10c6df ) { Extension_Control *the_extension; if ( !id ) return RTEMS_INVALID_ADDRESS; 10c758: b8 09 00 00 00 mov $0x9,%eax 10c75d: eb 80 jmp 10c6df =============================================================================== 0010c4f4 : #include rtems_status_code rtems_extension_delete( rtems_id id ) { 10c4f4: 55 push %ebp 10c4f5: 89 e5 mov %esp,%ebp 10c4f7: 53 push %ebx 10c4f8: 83 ec 18 sub $0x18,%esp Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); 10c4fb: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Extension_Control *) _Objects_Get( &_Extension_Information, id, location ); 10c4fe: 50 push %eax 10c4ff: ff 75 08 pushl 0x8(%ebp) 10c502: 68 20 8b 12 00 push $0x128b20 10c507: e8 a8 10 00 00 call 10d5b4 <_Objects_Get> 10c50c: 89 c3 mov %eax,%ebx switch ( location ) { 10c50e: 83 c4 10 add $0x10,%esp 10c511: 8b 55 f4 mov -0xc(%ebp),%edx 10c514: 85 d2 test %edx,%edx 10c516: 75 38 jne 10c550 case OBJECTS_LOCAL: _User_extensions_Remove_set( &the_extension->Extension ); 10c518: 83 ec 0c sub $0xc,%esp 10c51b: 8d 40 10 lea 0x10(%eax),%eax 10c51e: 50 push %eax 10c51f: e8 d4 26 00 00 call 10ebf8 <_User_extensions_Remove_set> _Objects_Close( &_Extension_Information, &the_extension->Object ); 10c524: 59 pop %ecx 10c525: 58 pop %eax 10c526: 53 push %ebx 10c527: 68 20 8b 12 00 push $0x128b20 10c52c: e8 4b 0c 00 00 call 10d17c <_Objects_Close> RTEMS_INLINE_ROUTINE void _Extension_Free ( Extension_Control *the_extension ) { _Objects_Free( &_Extension_Information, &the_extension->Object ); 10c531: 58 pop %eax 10c532: 5a pop %edx 10c533: 53 push %ebx 10c534: 68 20 8b 12 00 push $0x128b20 10c539: e8 36 0f 00 00 call 10d474 <_Objects_Free> _Extension_Free( the_extension ); _Thread_Enable_dispatch(); 10c53e: e8 49 1b 00 00 call 10e08c <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c543: 83 c4 10 add $0x10,%esp 10c546: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c548: 8b 5d fc mov -0x4(%ebp),%ebx 10c54b: c9 leave 10c54c: c3 ret 10c54d: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10c550: b8 04 00 00 00 mov $0x4,%eax } 10c555: 8b 5d fc mov -0x4(%ebp),%ebx 10c558: c9 leave 10c559: c3 ret =============================================================================== 0010758c : int rtems_filesystem_dirname( const char *pathname ) { 10758c: 55 push %ebp 10758d: 89 e5 mov %esp,%ebp 10758f: 57 push %edi 107590: 56 push %esi 107591: 53 push %ebx 107592: 83 ec 0c sub $0xc,%esp 107595: 8b 5d 08 mov 0x8(%ebp),%ebx int len = strlen( pathname ); 107598: 31 c0 xor %eax,%eax 10759a: b9 ff ff ff ff mov $0xffffffff,%ecx 10759f: 89 df mov %ebx,%edi 1075a1: f2 ae repnz scas %es:(%edi),%al 1075a3: f7 d1 not %ecx while ( len ) { 1075a5: 89 ce mov %ecx,%esi 1075a7: 4e dec %esi 1075a8: 75 06 jne 1075b0 <== ALWAYS TAKEN 1075aa: eb 19 jmp 1075c5 <== NOT EXECUTED 1075ac: 85 f6 test %esi,%esi 1075ae: 74 15 je 1075c5 len--; 1075b0: 4e dec %esi if ( rtems_filesystem_is_separator( pathname[len] ) ) 1075b1: 83 ec 0c sub $0xc,%esp 1075b4: 0f be 04 33 movsbl (%ebx,%esi,1),%eax 1075b8: 50 push %eax 1075b9: e8 02 0f 00 00 call 1084c0 1075be: 83 c4 10 add $0x10,%esp 1075c1: 85 c0 test %eax,%eax 1075c3: 74 e7 je 1075ac break; } return len; } 1075c5: 89 f0 mov %esi,%eax 1075c7: 8d 65 f4 lea -0xc(%ebp),%esp 1075ca: 5b pop %ebx 1075cb: 5e pop %esi 1075cc: 5f pop %edi 1075cd: c9 leave 1075ce: c3 ret =============================================================================== 0010f518 : rtems_filesystem_fsmount_me_t rtems_filesystem_get_mount_handler( const char *type ) { 10f518: 55 push %ebp 10f519: 89 e5 mov %esp,%ebp 10f51b: 83 ec 18 sub $0x18,%esp 10f51e: 8b 45 08 mov 0x8(%ebp),%eax find_arg fa = { 10f521: 89 45 f0 mov %eax,-0x10(%ebp) 10f524: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) .type = type, .mount_h = NULL }; if ( type != NULL ) { 10f52b: 85 c0 test %eax,%eax 10f52d: 74 19 je 10f548 <== NEVER TAKEN rtems_filesystem_iterate( find_handler, &fa ); 10f52f: 83 ec 08 sub $0x8,%esp 10f532: 8d 45 f0 lea -0x10(%ebp),%eax 10f535: 50 push %eax 10f536: 68 38 f4 10 00 push $0x10f438 10f53b: e8 34 ff ff ff call 10f474 10f540: 8b 45 f4 mov -0xc(%ebp),%eax 10f543: 83 c4 10 add $0x10,%esp } return fa.mount_h; } 10f546: c9 leave 10f547: c3 ret find_arg fa = { .type = type, .mount_h = NULL }; if ( type != NULL ) { 10f548: 31 c0 xor %eax,%eax rtems_filesystem_iterate( find_handler, &fa ); } return fa.mount_h; } 10f54a: c9 leave <== NOT EXECUTED 10f54b: c3 ret <== NOT EXECUTED =============================================================================== 0010f6d4 : #include "rtems/libio_.h" void rtems_filesystem_get_sym_start_loc(const char *path, int *index, rtems_filesystem_location_info_t *loc) { 10f6d4: 55 push %ebp 10f6d5: 89 e5 mov %esp,%ebp 10f6d7: 57 push %edi 10f6d8: 56 push %esi 10f6d9: 53 push %ebx 10f6da: 83 ec 18 sub $0x18,%esp 10f6dd: 8b 5d 0c mov 0xc(%ebp),%ebx if (rtems_filesystem_is_separator(path[0])) { 10f6e0: 8b 45 08 mov 0x8(%ebp),%eax 10f6e3: 0f be 00 movsbl (%eax),%eax 10f6e6: 50 push %eax 10f6e7: e8 d4 8d ff ff call 1084c0 10f6ec: 83 c4 10 add $0x10,%esp 10f6ef: 85 c0 test %eax,%eax 10f6f1: 75 11 jne 10f704 *loc = rtems_filesystem_root; *index = 1; } else { *index = 0; 10f6f3: c7 03 00 00 00 00 movl $0x0,(%ebx) } } 10f6f9: 8d 65 f4 lea -0xc(%ebp),%esp 10f6fc: 5b pop %ebx 10f6fd: 5e pop %esi 10f6fe: 5f pop %edi 10f6ff: c9 leave 10f700: c3 ret 10f701: 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; 10f704: 8b 35 b0 41 12 00 mov 0x1241b0,%esi 10f70a: 83 c6 18 add $0x18,%esi 10f70d: b9 05 00 00 00 mov $0x5,%ecx 10f712: 8b 7d 10 mov 0x10(%ebp),%edi 10f715: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *index = 1; 10f717: c7 03 01 00 00 00 movl $0x1,(%ebx) } else { *index = 0; } } 10f71d: 8d 65 f4 lea -0xc(%ebp),%esp 10f720: 5b pop %ebx 10f721: 5e pop %esi 10f722: 5f pop %edi 10f723: c9 leave 10f724: c3 ret =============================================================================== 001073bc : * configuration is a single instantiation of the IMFS or miniIMFS with * a single "/dev" directory in it. */ void rtems_filesystem_initialize( void ) { 1073bc: 55 push %ebp 1073bd: 89 e5 mov %esp,%ebp 1073bf: 57 push %edi 1073c0: 56 push %esi 1073c1: 53 push %ebx 1073c2: 83 ec 2c sub $0x2c,%esp /* * Set the default umask to "022". */ rtems_filesystem_umask = 022; 1073c5: a1 b0 41 12 00 mov 0x1241b0,%eax 1073ca: c7 40 2c 12 00 00 00 movl $0x12,0x2c(%eax) /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) 1073d1: a1 a0 e4 11 00 mov 0x11e4a0,%eax 1073d6: 85 c0 test %eax,%eax 1073d8: 0f 84 9f 00 00 00 je 10747d <== NEVER TAKEN rtems_fatal_error_occurred( 0xABCD0001 ); mt = &rtems_filesystem_mount_table[0]; 1073de: a1 f4 21 12 00 mov 0x1221f4,%eax status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL ); 1073e3: 83 ec 0c sub $0xc,%esp 1073e6: 6a 00 push $0x0 1073e8: ff 70 04 pushl 0x4(%eax) 1073eb: ff 30 pushl (%eax) 1073ed: ff 70 0c pushl 0xc(%eax) 1073f0: ff 70 08 pushl 0x8(%eax) 1073f3: e8 24 07 00 00 call 107b1c if ( status == -1 ) 1073f8: 83 c4 20 add $0x20,%esp 1073fb: 40 inc %eax 1073fc: 0f 84 95 00 00 00 je 107497 <== NEVER TAKEN rtems_fatal_error_occurred( 0xABCD0002 ); rtems_filesystem_link_counts = 0; 107402: a1 b0 41 12 00 mov 0x1241b0,%eax 107407: 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); 10740d: 83 ec 0c sub $0xc,%esp 107410: 6a 00 push $0x0 107412: 8d 5d d4 lea -0x2c(%ebp),%ebx 107415: 53 push %ebx 107416: 6a 00 push $0x0 107418: 6a 01 push $0x1 10741a: 68 67 fd 11 00 push $0x11fd67 10741f: e8 24 01 00 00 call 107548 rtems_filesystem_root = loc; 107424: 8b 3d b0 41 12 00 mov 0x1241b0,%edi 10742a: 83 c7 18 add $0x18,%edi 10742d: b9 05 00 00 00 mov $0x5,%ecx 107432: 89 de mov %ebx,%esi 107434: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0); 107436: 83 c4 14 add $0x14,%esp 107439: 6a 00 push $0x0 10743b: 53 push %ebx 10743c: 6a 00 push $0x0 10743e: 6a 01 push $0x1 107440: 68 67 fd 11 00 push $0x11fd67 107445: e8 fe 00 00 00 call 107548 rtems_filesystem_current = loc; 10744a: 8b 3d b0 41 12 00 mov 0x1241b0,%edi 107450: 83 c7 04 add $0x4,%edi 107453: b9 05 00 00 00 mov $0x5,%ecx 107458: 89 de mov %ebx,%esi 10745a: 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); 10745c: 83 c4 18 add $0x18,%esp 10745f: 68 ff 01 00 00 push $0x1ff 107464: 68 69 fd 11 00 push $0x11fd69 107469: e8 42 05 00 00 call 1079b0 if ( status != 0 ) 10746e: 83 c4 10 add $0x10,%esp 107471: 85 c0 test %eax,%eax 107473: 75 15 jne 10748a <== 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. */ } 107475: 8d 65 f4 lea -0xc(%ebp),%esp 107478: 5b pop %ebx 107479: 5e pop %esi 10747a: 5f pop %edi 10747b: c9 leave 10747c: c3 ret /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) rtems_fatal_error_occurred( 0xABCD0001 ); 10747d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107480: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED 107485: e8 5e 3d 00 00 call 10b1e8 <== NOT EXECUTED * created that way by the IMFS. */ status = mkdir( "/dev", 0777); if ( status != 0 ) rtems_fatal_error_occurred( 0xABCD0003 ); 10748a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10748d: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED 107492: e8 51 3d 00 00 call 10b1e8 <== 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 ); 107497: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10749a: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED 10749f: e8 44 3d 00 00 call 10b1e8 <== NOT EXECUTED =============================================================================== 0010f474 : bool rtems_filesystem_iterate( rtems_per_filesystem_routine routine, void *routine_arg ) { 10f474: 55 push %ebp 10f475: 89 e5 mov %esp,%ebp 10f477: 57 push %edi 10f478: 56 push %esi 10f479: 53 push %ebx 10f47a: 83 ec 1c sub $0x1c,%esp 10f47d: 8b 75 08 mov 0x8(%ebp),%esi 10f480: 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 ) { 10f483: 8b 1d 80 e4 11 00 mov 0x11e480,%ebx 10f489: 85 db test %ebx,%ebx 10f48b: 74 24 je 10f4b1 <== NEVER TAKEN 10f48d: bb 80 e4 11 00 mov $0x11e480,%ebx 10f492: eb 04 jmp 10f498 10f494: 84 c0 test %al,%al 10f496: 75 70 jne 10f508 stop = (*routine)( table_entry, routine_arg ); 10f498: 83 ec 08 sub $0x8,%esp 10f49b: 57 push %edi 10f49c: 53 push %ebx 10f49d: ff d6 call *%esi 10f49f: 88 c2 mov %al,%dl ++table_entry; 10f4a1: 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 ) { 10f4a4: 83 c4 10 add $0x10,%esp 10f4a7: 8b 0b mov (%ebx),%ecx 10f4a9: 85 c9 test %ecx,%ecx 10f4ab: 75 e7 jne 10f494 stop = (*routine)( table_entry, routine_arg ); ++table_entry; } if ( !stop ) { 10f4ad: 84 c0 test %al,%al 10f4af: 75 57 jne 10f508 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 ); 10f4b1: 50 push %eax 10f4b2: 6a 00 push $0x0 10f4b4: 6a 00 push $0x0 10f4b6: ff 35 88 63 12 00 pushl 0x126388 10f4bc: e8 e7 b6 ff ff call 10aba8 } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 10f4c1: 8b 1d bc 41 12 00 mov 0x1241bc,%ebx ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( 10f4c7: 83 c4 10 add $0x10,%esp 10f4ca: 81 fb c0 41 12 00 cmp $0x1241c0,%ebx 10f4d0: 75 06 jne 10f4d8 10f4d2: eb 3e jmp 10f512 node = rtems_chain_first( &filesystem_chain ); !rtems_chain_is_tail( &filesystem_chain, node ) && !stop; 10f4d4: 84 c0 test %al,%al 10f4d6: 75 19 jne 10f4f1 <== NEVER TAKEN node = rtems_chain_next( node ) ) { const filesystem_node *fsn = (filesystem_node *) node; stop = (*routine)( &fsn->entry, routine_arg ); 10f4d8: 83 ec 08 sub $0x8,%esp 10f4db: 57 push %edi 10f4dc: 8d 43 08 lea 0x8(%ebx),%eax 10f4df: 50 push %eax 10f4e0: ff d6 call *%esi 10f4e2: 88 c2 mov %al,%dl } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 10f4e4: 8b 1b mov (%ebx),%ebx ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( 10f4e6: 83 c4 10 add $0x10,%esp 10f4e9: 81 fb c0 41 12 00 cmp $0x1241c0,%ebx 10f4ef: 75 e3 jne 10f4d4 } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10f4f1: 83 ec 0c sub $0xc,%esp 10f4f4: ff 35 88 63 12 00 pushl 0x126388 10f4fa: 88 55 e4 mov %dl,-0x1c(%ebp) 10f4fd: e8 a2 b7 ff ff call 10aca4 10f502: 83 c4 10 add $0x10,%esp 10f505: 8a 55 e4 mov -0x1c(%ebp),%dl } rtems_libio_unlock(); } return stop; } 10f508: 88 d0 mov %dl,%al 10f50a: 8d 65 f4 lea -0xc(%ebp),%esp 10f50d: 5b pop %ebx 10f50e: 5e pop %esi 10f50f: 5f pop %edi 10f510: c9 leave 10f511: c3 ret ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( 10f512: 31 d2 xor %edx,%edx 10f514: eb db jmp 10f4f1 =============================================================================== 00107aac : bool rtems_filesystem_mount_iterate( rtems_per_filesystem_mount_routine routine, void *routine_arg ) { 107aac: 55 push %ebp 107aad: 89 e5 mov %esp,%ebp 107aaf: 57 push %edi 107ab0: 56 push %esi 107ab1: 53 push %ebx 107ab2: 83 ec 20 sub $0x20,%esp 107ab5: 8b 75 08 mov 0x8(%ebp),%esi 107ab8: 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 ); 107abb: 6a 00 push $0x0 107abd: 6a 00 push $0x0 107abf: ff 35 88 63 12 00 pushl 0x126388 107ac5: e8 de 30 00 00 call 10aba8 stop = (*routine)( mt_entry, routine_arg ); } rtems_libio_unlock(); return stop; } 107aca: 8b 1d 84 40 12 00 mov 0x124084,%ebx { rtems_chain_node *node = NULL; bool stop = false; rtems_libio_lock(); for ( 107ad0: 83 c4 10 add $0x10,%esp 107ad3: 81 fb 88 40 12 00 cmp $0x124088,%ebx 107ad9: 75 09 jne 107ae4 <== ALWAYS TAKEN 107adb: eb 3b jmp 107b18 <== NOT EXECUTED 107add: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED node = rtems_chain_first( &mount_chain ); !rtems_chain_is_tail( &mount_chain, node ) && !stop; 107ae0: 84 c0 test %al,%al 107ae2: 75 16 jne 107afa <== 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 ); 107ae4: 83 ec 08 sub $0x8,%esp 107ae7: 57 push %edi 107ae8: 53 push %ebx 107ae9: ff d6 call *%esi 107aeb: 88 c2 mov %al,%dl } rtems_libio_unlock(); return stop; } 107aed: 8b 1b mov (%ebx),%ebx { rtems_chain_node *node = NULL; bool stop = false; rtems_libio_lock(); for ( 107aef: 83 c4 10 add $0x10,%esp 107af2: 81 fb 88 40 12 00 cmp $0x124088,%ebx 107af8: 75 e6 jne 107ae0 } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 107afa: 83 ec 0c sub $0xc,%esp 107afd: ff 35 88 63 12 00 pushl 0x126388 107b03: 88 55 e4 mov %dl,-0x1c(%ebp) 107b06: e8 99 31 00 00 call 10aca4 stop = (*routine)( mt_entry, routine_arg ); } rtems_libio_unlock(); return stop; } 107b0b: 8a 55 e4 mov -0x1c(%ebp),%dl 107b0e: 88 d0 mov %dl,%al 107b10: 8d 65 f4 lea -0xc(%ebp),%esp 107b13: 5b pop %ebx 107b14: 5e pop %esi 107b15: 5f pop %edi 107b16: c9 leave 107b17: c3 ret rtems_per_filesystem_mount_routine routine, void *routine_arg ) { rtems_chain_node *node = NULL; bool stop = false; 107b18: 31 d2 xor %edx,%edx <== NOT EXECUTED 107b1a: eb de jmp 107afa <== NOT EXECUTED =============================================================================== 001075d0 : int rtems_filesystem_prefix_separators( const char *pathname, int pathnamelen ) { 1075d0: 55 push %ebp 1075d1: 89 e5 mov %esp,%ebp 1075d3: 57 push %edi 1075d4: 56 push %esi 1075d5: 53 push %ebx 1075d6: 83 ec 0c sub $0xc,%esp 1075d9: 8b 75 08 mov 0x8(%ebp),%esi 1075dc: 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 ) ) 1075df: 8a 06 mov (%esi),%al 1075e1: 84 c0 test %al,%al 1075e3: 74 34 je 107619 <== NEVER TAKEN 1075e5: 85 ff test %edi,%edi 1075e7: 74 30 je 107619 <== NEVER TAKEN 1075e9: 31 db xor %ebx,%ebx 1075eb: eb 0f jmp 1075fc 1075ed: 8d 76 00 lea 0x0(%esi),%esi { pathname++; pathnamelen--; stripped++; 1075f0: 43 inc %ebx { /* * Eat any separators at start of the path. */ int stripped = 0; while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) ) 1075f1: 8a 04 1e mov (%esi,%ebx,1),%al 1075f4: 84 c0 test %al,%al 1075f6: 74 17 je 10760f <== NEVER TAKEN 1075f8: 39 df cmp %ebx,%edi 1075fa: 74 13 je 10760f <== NEVER TAKEN 1075fc: 83 ec 0c sub $0xc,%esp 1075ff: 0f be c0 movsbl %al,%eax 107602: 50 push %eax 107603: e8 b8 0e 00 00 call 1084c0 107608: 83 c4 10 add $0x10,%esp 10760b: 85 c0 test %eax,%eax 10760d: 75 e1 jne 1075f0 pathname++; pathnamelen--; stripped++; } return stripped; } 10760f: 89 d8 mov %ebx,%eax 107611: 8d 65 f4 lea -0xc(%ebp),%esp 107614: 5b pop %ebx 107615: 5e pop %esi 107616: 5f pop %edi 107617: c9 leave 107618: c3 ret ) { /* * Eat any separators at start of the path. */ int stripped = 0; 107619: 31 db xor %ebx,%ebx 10761b: eb f2 jmp 10760f <== NOT EXECUTED =============================================================================== 0010f54c : int rtems_filesystem_register( const char *type, rtems_filesystem_fsmount_me_t mount_h ) { 10f54c: 55 push %ebp 10f54d: 89 e5 mov %esp,%ebp 10f54f: 57 push %edi 10f550: 56 push %esi 10f551: 53 push %ebx 10f552: 83 ec 28 sub $0x28,%esp size_t type_size = strlen(type) + 1; 10f555: 31 c0 xor %eax,%eax 10f557: b9 ff ff ff ff mov $0xffffffff,%ecx 10f55c: 8b 7d 08 mov 0x8(%ebp),%edi 10f55f: f2 ae repnz scas %es:(%edi),%al 10f561: f7 d1 not %ecx size_t fsn_size = sizeof( filesystem_node ) + type_size; 10f563: 8d 41 10 lea 0x10(%ecx),%eax filesystem_node *fsn = malloc( fsn_size ); 10f566: 50 push %eax 10f567: 89 4d e4 mov %ecx,-0x1c(%ebp) 10f56a: e8 99 83 ff ff call 107908 10f56f: 89 c3 mov %eax,%ebx char *type_storage = (char *) fsn + sizeof( *fsn ); if ( fsn == NULL ) 10f571: 83 c4 10 add $0x10,%esp 10f574: 85 c0 test %eax,%eax 10f576: 8b 4d e4 mov -0x1c(%ebp),%ecx 10f579: 0f 84 8e 00 00 00 je 10f60d <== NEVER TAKEN ) { 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 ); 10f57f: 8d 40 10 lea 0x10(%eax),%eax if ( fsn == NULL ) rtems_set_errno_and_return_minus_one( ENOMEM ); memcpy(type_storage, type, type_size); 10f582: 89 c7 mov %eax,%edi 10f584: 8b 75 08 mov 0x8(%ebp),%esi 10f587: f3 a4 rep movsb %ds:(%esi),%es:(%edi) fsn->entry.type = type_storage; 10f589: 89 43 08 mov %eax,0x8(%ebx) fsn->entry.mount_h = mount_h; 10f58c: 8b 45 0c mov 0xc(%ebp),%eax 10f58f: 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 ); 10f592: 50 push %eax 10f593: 6a 00 push $0x0 10f595: 6a 00 push $0x0 10f597: ff 35 88 63 12 00 pushl 0x126388 10f59d: e8 06 b6 ff ff call 10aba8 rtems_libio_lock(); if ( rtems_filesystem_get_mount_handler( type ) == NULL ) { 10f5a2: 5f pop %edi 10f5a3: ff 75 08 pushl 0x8(%ebp) 10f5a6: e8 6d ff ff ff call 10f518 10f5ab: 83 c4 10 add $0x10,%esp 10f5ae: 85 c0 test %eax,%eax 10f5b0: 75 2a jne 10f5dc <== NEVER TAKEN 10f5b2: 83 ec 08 sub $0x8,%esp 10f5b5: 53 push %ebx 10f5b6: 68 bc 41 12 00 push $0x1241bc 10f5bb: e8 c4 be ff ff call 10b484 <_Chain_Append> } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10f5c0: 5e pop %esi 10f5c1: ff 35 88 63 12 00 pushl 0x126388 10f5c7: e8 d8 b6 ff ff call 10aca4 10f5cc: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EINVAL ); } rtems_libio_unlock(); return 0; 10f5cf: 31 c0 xor %eax,%eax } 10f5d1: 8d 65 f4 lea -0xc(%ebp),%esp 10f5d4: 5b pop %ebx 10f5d5: 5e pop %esi 10f5d6: 5f pop %edi 10f5d7: c9 leave 10f5d8: c3 ret 10f5d9: 8d 76 00 lea 0x0(%esi),%esi 10f5dc: 83 ec 0c sub $0xc,%esp 10f5df: ff 35 88 63 12 00 pushl 0x126388 10f5e5: e8 ba b6 ff ff call 10aca4 rtems_libio_lock(); if ( rtems_filesystem_get_mount_handler( type ) == NULL ) { rtems_chain_append( &filesystem_chain, &fsn->node ); } else { rtems_libio_unlock(); free( fsn ); 10f5ea: 89 1c 24 mov %ebx,(%esp) 10f5ed: e8 42 80 ff ff call 107634 rtems_set_errno_and_return_minus_one( EINVAL ); 10f5f2: e8 e5 27 00 00 call 111ddc <__errno> 10f5f7: c7 00 16 00 00 00 movl $0x16,(%eax) 10f5fd: 83 c4 10 add $0x10,%esp 10f600: b8 ff ff ff ff mov $0xffffffff,%eax } rtems_libio_unlock(); return 0; } 10f605: 8d 65 f4 lea -0xc(%ebp),%esp 10f608: 5b pop %ebx 10f609: 5e pop %esi 10f60a: 5f pop %edi 10f60b: c9 leave 10f60c: 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 ); 10f60d: e8 ca 27 00 00 call 111ddc <__errno> 10f612: c7 00 0c 00 00 00 movl $0xc,(%eax) 10f618: b8 ff ff ff ff mov $0xffffffff,%eax 10f61d: eb b2 jmp 10f5d1 =============================================================================== 0010f620 : int rtems_filesystem_unregister( const char *type ) { 10f620: 55 push %ebp 10f621: 89 e5 mov %esp,%ebp 10f623: 56 push %esi 10f624: 53 push %ebx 10f625: 8b 75 08 mov 0x8(%ebp),%esi rtems_chain_node *node = NULL; if ( type == NULL ) { 10f628: 85 f6 test %esi,%esi 10f62a: 0f 84 94 00 00 00 je 10f6c4 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 ); 10f630: 51 push %ecx 10f631: 6a 00 push $0x0 10f633: 6a 00 push $0x0 10f635: ff 35 88 63 12 00 pushl 0x126388 10f63b: e8 68 b5 ff ff call 10aba8 } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 10f640: 8b 1d bc 41 12 00 mov 0x1241bc,%ebx if ( type == NULL ) { rtems_set_errno_and_return_minus_one( EINVAL ); } rtems_libio_lock(); for ( 10f646: 83 c4 10 add $0x10,%esp 10f649: 81 fb c0 41 12 00 cmp $0x1241c0,%ebx 10f64f: 75 0d jne 10f65e 10f651: eb 49 jmp 10f69c 10f653: 90 nop } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 10f654: 8b 1b mov (%ebx),%ebx if ( type == NULL ) { rtems_set_errno_and_return_minus_one( EINVAL ); } rtems_libio_lock(); for ( 10f656: 81 fb c0 41 12 00 cmp $0x1241c0,%ebx 10f65c: 74 3e je 10f69c <== 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 ) { 10f65e: 83 ec 08 sub $0x8,%esp 10f661: 56 push %esi 10f662: ff 73 08 pushl 0x8(%ebx) 10f665: e8 e2 33 00 00 call 112a4c 10f66a: 83 c4 10 add $0x10,%esp 10f66d: 85 c0 test %eax,%eax 10f66f: 75 e3 jne 10f654 */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10f671: 83 ec 0c sub $0xc,%esp 10f674: 53 push %ebx 10f675: e8 2e be ff ff call 10b4a8 <_Chain_Extract> rtems_chain_extract( node ); free( fsn ); 10f67a: 89 1c 24 mov %ebx,(%esp) 10f67d: e8 b2 7f ff ff call 107634 } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10f682: 5a pop %edx 10f683: ff 35 88 63 12 00 pushl 0x126388 10f689: e8 16 b6 ff ff call 10aca4 10f68e: 83 c4 10 add $0x10,%esp rtems_libio_unlock(); return 0; 10f691: 31 c0 xor %eax,%eax } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 10f693: 8d 65 f8 lea -0x8(%ebp),%esp 10f696: 5b pop %ebx 10f697: 5e pop %esi 10f698: c9 leave 10f699: c3 ret 10f69a: 66 90 xchg %ax,%ax 10f69c: 83 ec 0c sub $0xc,%esp 10f69f: ff 35 88 63 12 00 pushl 0x126388 10f6a5: e8 fa b5 ff ff call 10aca4 return 0; } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); 10f6aa: e8 2d 27 00 00 call 111ddc <__errno> 10f6af: c7 00 02 00 00 00 movl $0x2,(%eax) 10f6b5: 83 c4 10 add $0x10,%esp 10f6b8: b8 ff ff ff ff mov $0xffffffff,%eax } 10f6bd: 8d 65 f8 lea -0x8(%ebp),%esp 10f6c0: 5b pop %ebx 10f6c1: 5e pop %esi 10f6c2: c9 leave 10f6c3: c3 ret ) { rtems_chain_node *node = NULL; if ( type == NULL ) { rtems_set_errno_and_return_minus_one( EINVAL ); 10f6c4: e8 13 27 00 00 call 111ddc <__errno> 10f6c9: c7 00 16 00 00 00 movl $0x16,(%eax) 10f6cf: 83 c8 ff or $0xffffffff,%eax 10f6d2: eb e9 jmp 10f6bd =============================================================================== 00107efc : int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *)) { 107efc: 55 push %ebp 107efd: 89 e5 mov %esp,%ebp 107eff: 56 push %esi 107f00: 53 push %ebx 107f01: 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 ) ); 107f04: 83 ec 0c sub $0xc,%esp 107f07: 6a 08 push $0x8 107f09: e8 c6 03 00 00 call 1082d4 107f0e: 89 c3 mov %eax,%ebx *key = new_key; 107f10: 8b 45 08 mov 0x8(%ebp),%eax 107f13: 89 18 mov %ebx,(%eax) new_key->val = NULL; 107f15: c7 03 00 00 00 00 movl $0x0,(%ebx) new_key->dtor = dtor; 107f1b: 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 ); 107f1e: 83 c4 0c add $0xc,%esp 107f21: 56 push %esi 107f22: 53 push %ebx 107f23: 6a 00 push $0x0 107f25: e8 1e 3c 00 00 call 10bb48 if ( status == RTEMS_SUCCESSFUL ) 107f2a: 83 c4 10 add $0x10,%esp 107f2d: 85 c0 test %eax,%eax 107f2f: 75 0b jne 107f3c <== NEVER TAKEN return 0; 107f31: 31 c0 xor %eax,%eax free( new_key ); return -1; } 107f33: 8d 65 f8 lea -0x8(%ebp),%esp 107f36: 5b pop %ebx 107f37: 5e pop %esi 107f38: c9 leave 107f39: c3 ret 107f3a: 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 ); 107f3c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107f3f: 53 push %ebx <== NOT EXECUTED 107f40: e8 3f fe ff ff call 107d84 <== NOT EXECUTED return -1; 107f45: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107f48: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 107f4d: eb e4 jmp 107f33 <== NOT EXECUTED =============================================================================== 00107f60 : int rtems_gxx_key_delete (__gthread_key_t key) { 107f60: 55 push %ebp 107f61: 89 e5 mov %esp,%ebp 107f63: 53 push %ebx 107f64: 83 ec 0c sub $0xc,%esp 107f67: 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 ); 107f6a: 53 push %ebx 107f6b: 6a 00 push $0x0 107f6d: e8 9a 3c 00 00 call 10bc0c if ( status == RTEMS_SUCCESSFUL ) { 107f72: 83 c4 10 add $0x10,%esp 107f75: 85 c0 test %eax,%eax 107f77: 75 11 jne 107f8a <== NEVER TAKEN /* Hmm - hopefully all tasks using this key have gone away... */ if ( key ) free( *(void **)key ); 107f79: 85 db test %ebx,%ebx 107f7b: 74 0d je 107f8a <== NEVER TAKEN 107f7d: 83 ec 0c sub $0xc,%esp 107f80: ff 33 pushl (%ebx) 107f82: e8 fd fd ff ff call 107d84 107f87: 83 c4 10 add $0x10,%esp return 0; } key = NULL; return 0; } 107f8a: 31 c0 xor %eax,%eax 107f8c: 8b 5d fc mov -0x4(%ebp),%ebx 107f8f: c9 leave 107f90: c3 ret =============================================================================== 00107e80 : /* 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)) { 107e80: 55 push %ebp 107e81: 89 e5 mov %esp,%ebp 107e83: 56 push %esi 107e84: 53 push %ebx 107e85: 83 ec 10 sub $0x10,%esp 107e88: 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 ) { 107e8b: 8b 03 mov (%ebx),%eax 107e8d: 85 c0 test %eax,%eax 107e8f: 74 0b je 107e9c rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); if ( o == 0 ) (*func)(); } return 0; } 107e91: 31 c0 xor %eax,%eax 107e93: 8d 65 f8 lea -0x8(%ebp),%esp 107e96: 5b pop %ebx 107e97: 5e pop %esi 107e98: c9 leave 107e99: c3 ret 107e9a: 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); 107e9c: 51 push %ecx 107e9d: 8d 75 f4 lea -0xc(%ebp),%esi 107ea0: 56 push %esi 107ea1: 68 00 01 00 00 push $0x100 107ea6: 68 00 01 00 00 push $0x100 107eab: e8 c0 3a 00 00 call 10b970 if ( (o = *(volatile __gthread_once_t *)once) == 0 ) { 107eb0: 8b 03 mov (%ebx),%eax 107eb2: 83 c4 10 add $0x10,%esp 107eb5: 85 c0 test %eax,%eax 107eb7: 75 27 jne 107ee0 <== NEVER TAKEN *(volatile __gthread_once_t *)once = 1; 107eb9: c7 03 01 00 00 00 movl $0x1,(%ebx) } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 107ebf: 52 push %edx 107ec0: 56 push %esi 107ec1: 68 00 01 00 00 push $0x100 107ec6: ff 75 f4 pushl -0xc(%ebp) 107ec9: e8 a2 3a 00 00 call 10b970 if ( o == 0 ) (*func)(); 107ece: ff 55 0c call *0xc(%ebp) 107ed1: 83 c4 10 add $0x10,%esp } return 0; } 107ed4: 31 c0 xor %eax,%eax 107ed6: 8d 65 f8 lea -0x8(%ebp),%esp 107ed9: 5b pop %ebx 107eda: 5e pop %esi 107edb: c9 leave 107edc: c3 ret 107edd: 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); 107ee0: 50 push %eax <== NOT EXECUTED 107ee1: 56 push %esi <== NOT EXECUTED 107ee2: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 107ee7: ff 75 f4 pushl -0xc(%ebp) <== NOT EXECUTED 107eea: e8 81 3a 00 00 call 10b970 <== NOT EXECUTED 107eef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( o == 0 ) (*func)(); } return 0; } 107ef2: 31 c0 xor %eax,%eax <== NOT EXECUTED 107ef4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 107ef7: 5b pop %ebx <== NOT EXECUTED 107ef8: 5e pop %esi <== NOT EXECUTED 107ef9: c9 leave <== NOT EXECUTED 107efa: c3 ret <== NOT EXECUTED =============================================================================== 00107ff0 : #endif return p; } int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr) { 107ff0: 55 push %ebp 107ff1: 89 e5 mov %esp,%ebp 107ff3: 53 push %ebx 107ff4: 83 ec 08 sub $0x8,%esp 107ff7: 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 ); 107ffa: ff 73 04 pushl 0x4(%ebx) 107ffd: 53 push %ebx 107ffe: 6a 00 push $0x0 108000: e8 43 3b 00 00 call 10bb48 if ( status == RTEMS_SUCCESSFUL ) { 108005: 83 c4 10 add $0x10,%esp 108008: 85 c0 test %eax,%eax 10800a: 75 0c jne 108018 <== NEVER TAKEN /* now let's set the proper value */ key->val = (void *)ptr; 10800c: 8b 45 0c mov 0xc(%ebp),%eax 10800f: 89 03 mov %eax,(%ebx) return 0; 108011: 31 c0 xor %eax,%eax } return -1; } 108013: 8b 5d fc mov -0x4(%ebp),%ebx 108016: c9 leave 108017: c3 ret if ( status == RTEMS_SUCCESSFUL ) { /* now let's set the proper value */ key->val = (void *)ptr; return 0; } return -1; 108018: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 10801d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 108020: c9 leave <== NOT EXECUTED 108021: c3 ret <== NOT EXECUTED =============================================================================== 0010b240 : void *rtems_heap_allocate_aligned_with_boundary( size_t size, uintptr_t alignment, uintptr_t boundary ) { 10b240: 55 push %ebp 10b241: 89 e5 mov %esp,%ebp 10b243: 83 ec 08 sub $0x8,%esp if ( 10b246: 83 3d 60 d7 12 00 03 cmpl $0x3,0x12d760 10b24d: 74 21 je 10b270 <== ALWAYS TAKEN && !malloc_is_system_state_OK() ) { return NULL; } malloc_deferred_frees_process(); 10b24f: e8 b8 ef ff ff call 10a20c /* FIXME: Statistics, boundary checks */ return _Protected_heap_Allocate_aligned_with_boundary( 10b254: ff 75 10 pushl 0x10(%ebp) 10b257: ff 75 0c pushl 0xc(%ebp) 10b25a: ff 75 08 pushl 0x8(%ebp) 10b25d: ff 35 f0 89 12 00 pushl 0x1289f0 10b263: e8 a8 4b 00 00 call 10fe10 <_Protected_heap_Allocate_aligned_with_boundary> 10b268: 83 c4 10 add $0x10,%esp RTEMS_Malloc_Heap, size, alignment, boundary ); } 10b26b: c9 leave 10b26c: c3 ret 10b26d: 8d 76 00 lea 0x0(%esi),%esi uintptr_t boundary ) { if ( _System_state_Is_up( _System_state_Get() ) && !malloc_is_system_state_OK() 10b270: e8 57 ef ff ff call 10a1cc 10b275: 84 c0 test %al,%al 10b277: 75 d6 jne 10b24f ) { return NULL; 10b279: 31 c0 xor %eax,%eax RTEMS_Malloc_Heap, size, alignment, boundary ); } 10b27b: c9 leave 10b27c: c3 ret =============================================================================== 00111ae0 : rtems_status_code rtems_io_close( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 111ae0: 55 push %ebp 111ae1: 89 e5 mov %esp,%ebp 111ae3: 53 push %ebx 111ae4: 83 ec 04 sub $0x4,%esp 111ae7: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 111aea: 39 05 40 68 12 00 cmp %eax,0x126840 111af0: 76 1a jbe 111b0c return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; 111af2: 8d 14 40 lea (%eax,%eax,2),%edx 111af5: c1 e2 03 shl $0x3,%edx 111af8: 03 15 44 68 12 00 add 0x126844,%edx 111afe: 8b 52 08 mov 0x8(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 111b01: 85 d2 test %edx,%edx 111b03: 74 13 je 111b18 } 111b05: 59 pop %ecx 111b06: 5b pop %ebx 111b07: 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; 111b08: ff e2 jmp *%edx 111b0a: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 111b0c: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].close_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 111b11: 5a pop %edx 111b12: 5b pop %ebx 111b13: c9 leave 111b14: c3 ret 111b15: 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; 111b18: 31 c0 xor %eax,%eax } 111b1a: 5a pop %edx 111b1b: 5b pop %ebx 111b1c: c9 leave 111b1d: c3 ret =============================================================================== 00111b20 : rtems_status_code rtems_io_control( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 111b20: 55 push %ebp 111b21: 89 e5 mov %esp,%ebp 111b23: 53 push %ebx 111b24: 83 ec 04 sub $0x4,%esp 111b27: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 111b2a: 39 05 40 68 12 00 cmp %eax,0x126840 111b30: 76 1a jbe 111b4c return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; 111b32: 8d 14 40 lea (%eax,%eax,2),%edx 111b35: c1 e2 03 shl $0x3,%edx 111b38: 03 15 44 68 12 00 add 0x126844,%edx 111b3e: 8b 52 14 mov 0x14(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 111b41: 85 d2 test %edx,%edx 111b43: 74 13 je 111b58 } 111b45: 59 pop %ecx 111b46: 5b pop %ebx 111b47: 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; 111b48: ff e2 jmp *%edx 111b4a: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 111b4c: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].control_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 111b51: 5a pop %edx 111b52: 5b pop %ebx 111b53: c9 leave 111b54: c3 ret 111b55: 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; 111b58: 31 c0 xor %eax,%eax } 111b5a: 5a pop %edx 111b5b: 5b pop %ebx 111b5c: c9 leave 111b5d: c3 ret =============================================================================== 0010fdec : rtems_status_code rtems_io_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10fdec: 55 push %ebp 10fded: 89 e5 mov %esp,%ebp 10fdef: 53 push %ebx 10fdf0: 83 ec 04 sub $0x4,%esp 10fdf3: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10fdf6: 39 05 40 68 12 00 cmp %eax,0x126840 10fdfc: 76 1a jbe 10fe18 return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; 10fdfe: 8d 14 40 lea (%eax,%eax,2),%edx 10fe01: c1 e2 03 shl $0x3,%edx 10fe04: 03 15 44 68 12 00 add 0x126844,%edx 10fe0a: 8b 12 mov (%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10fe0c: 85 d2 test %edx,%edx 10fe0e: 74 14 je 10fe24 } 10fe10: 59 pop %ecx 10fe11: 5b pop %ebx 10fe12: 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; 10fe13: ff e2 jmp *%edx 10fe15: 8d 76 00 lea 0x0(%esi),%esi ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 10fe18: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].initialization_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 10fe1d: 5a pop %edx 10fe1e: 5b pop %ebx 10fe1f: c9 leave 10fe20: c3 ret 10fe21: 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; 10fe24: 31 c0 xor %eax,%eax } 10fe26: 5a pop %edx 10fe27: 5b pop %ebx 10fe28: c9 leave 10fe29: c3 ret =============================================================================== 001072e0 : rtems_status_code rtems_io_lookup_name( const char *name, rtems_driver_name_t *device_info ) { 1072e0: 55 push %ebp 1072e1: 89 e5 mov %esp,%ebp 1072e3: 57 push %edi 1072e4: 56 push %esi 1072e5: 53 push %ebx 1072e6: 83 ec 48 sub $0x48,%esp 1072e9: 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( 1072ec: b9 ff ff ff ff mov $0xffffffff,%ecx 1072f1: 89 f7 mov %esi,%edi 1072f3: 31 c0 xor %eax,%eax 1072f5: f2 ae repnz scas %es:(%edi),%al 1072f7: f7 d1 not %ecx 1072f9: 49 dec %ecx 1072fa: 6a 01 push $0x1 1072fc: 8d 5d d4 lea -0x2c(%ebp),%ebx 1072ff: 53 push %ebx 107300: 6a 00 push $0x0 107302: 51 push %ecx 107303: 56 push %esi 107304: e8 3f 02 00 00 call 107548 107309: 89 c7 mov %eax,%edi name, strlen( name ), 0x00, &loc, true ); the_jnode = loc.node_access; 10730b: 8b 55 d4 mov -0x2c(%ebp),%edx 10730e: 89 55 c4 mov %edx,-0x3c(%ebp) node_type = (*loc.ops->node_type_h)( &loc ); 107311: 83 c4 14 add $0x14,%esp 107314: 53 push %ebx 107315: 8b 45 e0 mov -0x20(%ebp),%eax 107318: ff 50 10 call *0x10(%eax) if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) { 10731b: 83 c4 10 add $0x10,%esp 10731e: 85 ff test %edi,%edi 107320: 75 05 jne 107327 <== NEVER TAKEN 107322: 83 f8 02 cmp $0x2,%eax 107325: 74 19 je 107340 rtems_filesystem_freenode( &loc ); 107327: 83 ec 0c sub $0xc,%esp 10732a: 53 push %ebx 10732b: e8 f0 02 00 00 call 107620 return RTEMS_UNSATISFIED; 107330: 83 c4 10 add $0x10,%esp 107333: b8 0d 00 00 00 mov $0xd,%eax device_info->minor = the_jnode->info.device.minor; rtems_filesystem_freenode( &loc ); return RTEMS_SUCCESSFUL; } 107338: 8d 65 f4 lea -0xc(%ebp),%esp 10733b: 5b pop %ebx 10733c: 5e pop %esi 10733d: 5f pop %edi 10733e: c9 leave 10733f: c3 ret if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) { rtems_filesystem_freenode( &loc ); return RTEMS_UNSATISFIED; } device_info->device_name = (char *) name; 107340: 8b 7d 0c mov 0xc(%ebp),%edi 107343: 89 37 mov %esi,(%edi) device_info->device_name_length = strlen( name ); 107345: b9 ff ff ff ff mov $0xffffffff,%ecx 10734a: 89 f7 mov %esi,%edi 10734c: 31 c0 xor %eax,%eax 10734e: f2 ae repnz scas %es:(%edi),%al 107350: f7 d1 not %ecx 107352: 49 dec %ecx 107353: 8b 45 0c mov 0xc(%ebp),%eax 107356: 89 48 04 mov %ecx,0x4(%eax) device_info->major = the_jnode->info.device.major; 107359: 8b 55 c4 mov -0x3c(%ebp),%edx 10735c: 8b 42 50 mov 0x50(%edx),%eax 10735f: 8b 7d 0c mov 0xc(%ebp),%edi 107362: 89 47 08 mov %eax,0x8(%edi) device_info->minor = the_jnode->info.device.minor; 107365: 8b 42 54 mov 0x54(%edx),%eax 107368: 89 47 0c mov %eax,0xc(%edi) rtems_filesystem_freenode( &loc ); 10736b: 83 ec 0c sub $0xc,%esp 10736e: 53 push %ebx 10736f: e8 ac 02 00 00 call 107620 return RTEMS_SUCCESSFUL; 107374: 83 c4 10 add $0x10,%esp 107377: 31 c0 xor %eax,%eax 107379: eb bd jmp 107338 =============================================================================== 00111b60 : rtems_status_code rtems_io_open( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 111b60: 55 push %ebp 111b61: 89 e5 mov %esp,%ebp 111b63: 53 push %ebx 111b64: 83 ec 04 sub $0x4,%esp 111b67: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 111b6a: 39 05 40 68 12 00 cmp %eax,0x126840 111b70: 76 1a jbe 111b8c return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; 111b72: 8d 14 40 lea (%eax,%eax,2),%edx 111b75: c1 e2 03 shl $0x3,%edx 111b78: 03 15 44 68 12 00 add 0x126844,%edx 111b7e: 8b 52 04 mov 0x4(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 111b81: 85 d2 test %edx,%edx 111b83: 74 13 je 111b98 } 111b85: 59 pop %ecx 111b86: 5b pop %ebx 111b87: 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; 111b88: ff e2 jmp *%edx 111b8a: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 111b8c: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].open_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 111b91: 5a pop %edx 111b92: 5b pop %ebx 111b93: c9 leave 111b94: c3 ret 111b95: 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; 111b98: 31 c0 xor %eax,%eax } 111b9a: 5a pop %edx 111b9b: 5b pop %ebx 111b9c: c9 leave 111b9d: c3 ret =============================================================================== 00111ba0 : rtems_status_code rtems_io_read( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 111ba0: 55 push %ebp 111ba1: 89 e5 mov %esp,%ebp 111ba3: 53 push %ebx 111ba4: 83 ec 04 sub $0x4,%esp 111ba7: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 111baa: 39 05 40 68 12 00 cmp %eax,0x126840 111bb0: 76 1a jbe 111bcc return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; 111bb2: 8d 14 40 lea (%eax,%eax,2),%edx 111bb5: c1 e2 03 shl $0x3,%edx 111bb8: 03 15 44 68 12 00 add 0x126844,%edx 111bbe: 8b 52 0c mov 0xc(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 111bc1: 85 d2 test %edx,%edx 111bc3: 74 13 je 111bd8 } 111bc5: 59 pop %ecx 111bc6: 5b pop %ebx 111bc7: 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; 111bc8: ff e2 jmp *%edx 111bca: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 111bcc: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].read_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 111bd1: 5a pop %edx 111bd2: 5b pop %ebx 111bd3: c9 leave 111bd4: c3 ret 111bd5: 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; 111bd8: 31 c0 xor %eax,%eax } 111bda: 5a pop %edx 111bdb: 5b pop %ebx 111bdc: c9 leave 111bdd: c3 ret =============================================================================== 0010c3b4 : 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 ) { 10c3b4: 55 push %ebp 10c3b5: 89 e5 mov %esp,%ebp 10c3b7: 57 push %edi 10c3b8: 56 push %esi 10c3b9: 53 push %ebx 10c3ba: 83 ec 0c sub $0xc,%esp 10c3bd: 8b 5d 08 mov 0x8(%ebp),%ebx 10c3c0: 8b 75 0c mov 0xc(%ebp),%esi 10c3c3: 8b 55 10 mov 0x10(%ebp),%edx rtems_device_major_number major_limit = _IO_Number_of_drivers; 10c3c6: a1 40 98 12 00 mov 0x129840,%eax if ( rtems_interrupt_is_in_progress() ) 10c3cb: 8b 0d 74 97 12 00 mov 0x129774,%ecx 10c3d1: 85 c9 test %ecx,%ecx 10c3d3: 0f 85 ab 00 00 00 jne 10c484 return RTEMS_CALLED_FROM_ISR; if ( registered_major == NULL ) 10c3d9: 85 d2 test %edx,%edx 10c3db: 0f 84 e7 00 00 00 je 10c4c8 return RTEMS_INVALID_ADDRESS; /* Set it to an invalid value */ *registered_major = major_limit; 10c3e1: 89 02 mov %eax,(%edx) if ( driver_table == NULL ) 10c3e3: 85 f6 test %esi,%esi 10c3e5: 0f 84 dd 00 00 00 je 10c4c8 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10c3eb: 8b 3e mov (%esi),%edi 10c3ed: 85 ff test %edi,%edi 10c3ef: 0f 84 c7 00 00 00 je 10c4bc return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; if ( major >= major_limit ) 10c3f5: 39 d8 cmp %ebx,%eax 10c3f7: 76 7b jbe 10c474 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10c3f9: a1 ec 94 12 00 mov 0x1294ec,%eax 10c3fe: 40 inc %eax 10c3ff: a3 ec 94 12 00 mov %eax,0x1294ec return RTEMS_INVALID_NUMBER; _Thread_Disable_dispatch(); if ( major == 0 ) { 10c404: 85 db test %ebx,%ebx 10c406: 0f 85 88 00 00 00 jne 10c494 static rtems_status_code rtems_io_obtain_major_number( rtems_device_major_number *major ) { rtems_device_major_number n = _IO_Number_of_drivers; 10c40c: 8b 0d 40 98 12 00 mov 0x129840,%ecx rtems_device_major_number m = 0; /* major is error checked by caller */ for ( m = 0; m < n; ++m ) { 10c412: 85 c9 test %ecx,%ecx 10c414: 0f 84 bb 00 00 00 je 10c4d5 <== NEVER TAKEN 10c41a: 8b 3d 44 98 12 00 mov 0x129844,%edi 10c420: 89 f8 mov %edi,%eax 10c422: eb 08 jmp 10c42c 10c424: 43 inc %ebx 10c425: 83 c0 18 add $0x18,%eax 10c428: 39 d9 cmp %ebx,%ecx 10c42a: 76 0b jbe 10c437 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10c42c: 83 38 00 cmpl $0x0,(%eax) 10c42f: 75 f3 jne 10c424 10c431: 83 78 04 00 cmpl $0x0,0x4(%eax) 10c435: 75 ed jne 10c424 if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 10c437: 89 1a mov %ebx,(%edx) if ( m != n ) 10c439: 39 d9 cmp %ebx,%ecx 10c43b: 0f 84 9b 00 00 00 je 10c4dc 10c441: 8d 04 5b lea (%ebx,%ebx,2),%eax 10c444: c1 e0 03 shl $0x3,%eax } *registered_major = major; } _IO_Driver_address_table [major] = *driver_table; 10c447: 01 c7 add %eax,%edi 10c449: b9 06 00 00 00 mov $0x6,%ecx 10c44e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Thread_Enable_dispatch(); 10c450: e8 4b 1b 00 00 call 10dfa0 <_Thread_Enable_dispatch> return rtems_io_initialize( major, 0, NULL ); 10c455: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) 10c45c: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) 10c463: 89 5d 08 mov %ebx,0x8(%ebp) } 10c466: 83 c4 0c add $0xc,%esp 10c469: 5b pop %ebx 10c46a: 5e pop %esi 10c46b: 5f pop %edi 10c46c: c9 leave _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); 10c46d: e9 b6 76 00 00 jmp 113b28 10c472: 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; 10c474: 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 ); } 10c479: 83 c4 0c add $0xc,%esp 10c47c: 5b pop %ebx 10c47d: 5e pop %esi 10c47e: 5f pop %edi 10c47f: c9 leave 10c480: c3 ret 10c481: 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; 10c484: 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 ); } 10c489: 83 c4 0c add $0xc,%esp 10c48c: 5b pop %ebx 10c48d: 5e pop %esi 10c48e: 5f pop %edi 10c48f: c9 leave 10c490: c3 ret 10c491: 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; 10c494: 8d 04 5b lea (%ebx,%ebx,2),%eax 10c497: c1 e0 03 shl $0x3,%eax 10c49a: 8b 0d 44 98 12 00 mov 0x129844,%ecx 10c4a0: 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; 10c4a2: 8b 39 mov (%ecx),%edi 10c4a4: 85 ff test %edi,%edi 10c4a6: 74 40 je 10c4e8 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(); 10c4a8: e8 f3 1a 00 00 call 10dfa0 <_Thread_Enable_dispatch> return RTEMS_RESOURCE_IN_USE; 10c4ad: 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 ); } 10c4b2: 83 c4 0c add $0xc,%esp 10c4b5: 5b pop %ebx 10c4b6: 5e pop %esi 10c4b7: 5f pop %edi 10c4b8: c9 leave 10c4b9: c3 ret 10c4ba: 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; 10c4bc: 8b 4e 04 mov 0x4(%esi),%ecx 10c4bf: 85 c9 test %ecx,%ecx 10c4c1: 0f 85 2e ff ff ff jne 10c3f5 10c4c7: 90 nop if ( driver_table == NULL ) return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; 10c4c8: 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 ); } 10c4cd: 83 c4 0c add $0xc,%esp 10c4d0: 5b pop %ebx 10c4d1: 5e pop %esi 10c4d2: 5f pop %edi 10c4d3: c9 leave 10c4d4: c3 ret if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 10c4d5: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED 10c4db: 90 nop <== NOT EXECUTED if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); 10c4dc: e8 bf 1a 00 00 call 10dfa0 <_Thread_Enable_dispatch> *major = m; if ( m != n ) return RTEMS_SUCCESSFUL; return RTEMS_TOO_MANY; 10c4e1: 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; 10c4e6: eb 91 jmp 10c479 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10c4e8: 8b 49 04 mov 0x4(%ecx),%ecx 10c4eb: 85 c9 test %ecx,%ecx 10c4ed: 75 b9 jne 10c4a8 if ( !rtems_io_is_empty_table( table ) ) { _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } *registered_major = major; 10c4ef: 89 1a mov %ebx,(%edx) 10c4f1: 8b 3d 44 98 12 00 mov 0x129844,%edi 10c4f7: e9 4b ff ff ff jmp 10c447 =============================================================================== 0010c4fc : */ rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { 10c4fc: 55 push %ebp 10c4fd: 89 e5 mov %esp,%ebp 10c4ff: 57 push %edi 10c500: 83 ec 04 sub $0x4,%esp 10c503: 8b 45 08 mov 0x8(%ebp),%eax if ( rtems_interrupt_is_in_progress() ) 10c506: 8b 0d 74 97 12 00 mov 0x129774,%ecx 10c50c: 85 c9 test %ecx,%ecx 10c50e: 75 44 jne 10c554 return RTEMS_CALLED_FROM_ISR; if ( major < _IO_Number_of_drivers ) { 10c510: 39 05 40 98 12 00 cmp %eax,0x129840 10c516: 77 0c ja 10c524 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; 10c518: b8 0d 00 00 00 mov $0xd,%eax } 10c51d: 5a pop %edx 10c51e: 5f pop %edi 10c51f: c9 leave 10c520: c3 ret 10c521: 8d 76 00 lea 0x0(%esi),%esi 10c524: 8b 15 ec 94 12 00 mov 0x1294ec,%edx 10c52a: 42 inc %edx 10c52b: 89 15 ec 94 12 00 mov %edx,0x1294ec return RTEMS_CALLED_FROM_ISR; if ( major < _IO_Number_of_drivers ) { _Thread_Disable_dispatch(); memset( &_IO_Driver_address_table[major], 10c531: 8d 14 40 lea (%eax,%eax,2),%edx 10c534: 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( 10c537: 03 15 44 98 12 00 add 0x129844,%edx 10c53d: b9 18 00 00 00 mov $0x18,%ecx 10c542: 31 c0 xor %eax,%eax 10c544: 89 d7 mov %edx,%edi 10c546: f3 aa rep stos %al,%es:(%edi) &_IO_Driver_address_table[major], 0, sizeof( rtems_driver_address_table ) ); _Thread_Enable_dispatch(); 10c548: e8 53 1a 00 00 call 10dfa0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c54d: 31 c0 xor %eax,%eax } return RTEMS_UNSATISFIED; } 10c54f: 5a pop %edx 10c550: 5f pop %edi 10c551: c9 leave 10c552: c3 ret 10c553: 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; 10c554: b8 12 00 00 00 mov $0x12,%eax return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10c559: 5a pop %edx 10c55a: 5f pop %edi 10c55b: c9 leave 10c55c: c3 ret =============================================================================== 00111be0 : rtems_status_code rtems_io_write( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 111be0: 55 push %ebp 111be1: 89 e5 mov %esp,%ebp 111be3: 53 push %ebx 111be4: 83 ec 04 sub $0x4,%esp 111be7: 8b 45 08 mov 0x8(%ebp),%eax rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 111bea: 39 05 40 68 12 00 cmp %eax,0x126840 111bf0: 76 1a jbe 111c0c return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; 111bf2: 8d 14 40 lea (%eax,%eax,2),%edx 111bf5: c1 e2 03 shl $0x3,%edx 111bf8: 03 15 44 68 12 00 add 0x126844,%edx 111bfe: 8b 52 10 mov 0x10(%edx),%edx return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 111c01: 85 d2 test %edx,%edx 111c03: 74 13 je 111c18 } 111c05: 59 pop %ecx 111c06: 5b pop %ebx 111c07: 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; 111c08: ff e2 jmp *%edx 111c0a: 66 90 xchg %ax,%ax ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; 111c0c: b8 0a 00 00 00 mov $0xa,%eax callout = _IO_Driver_address_table[major].write_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 111c11: 5a pop %edx 111c12: 5b pop %ebx 111c13: c9 leave 111c14: c3 ret 111c15: 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; 111c18: 31 c0 xor %eax,%eax } 111c1a: 5a pop %edx 111c1b: 5b pop %ebx 111c1c: c9 leave 111c1d: c3 ret =============================================================================== 0010d358 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10d358: 55 push %ebp 10d359: 89 e5 mov %esp,%ebp 10d35b: 57 push %edi 10d35c: 56 push %esi 10d35d: 53 push %ebx 10d35e: 83 ec 1c sub $0x1c,%esp 10d361: 8b 7d 08 mov 0x8(%ebp),%edi uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10d364: 85 ff test %edi,%edi 10d366: 74 4d je 10d3b5 <== NEVER TAKEN 10d368: c7 45 e4 01 00 00 00 movl $0x1,-0x1c(%ebp) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG) if ( !_Objects_Information_table[ api_index ] ) 10d36f: 8b 55 e4 mov -0x1c(%ebp),%edx 10d372: 8b 04 95 a4 98 12 00 mov 0x1298a4(,%edx,4),%eax 10d379: 85 c0 test %eax,%eax 10d37b: 74 2f je 10d3ac continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 10d37d: 8b 70 04 mov 0x4(%eax),%esi if ( !information ) 10d380: 85 f6 test %esi,%esi 10d382: 74 28 je 10d3ac continue; for ( i=1 ; i <= information->maximum ; i++ ) { 10d384: 66 83 7e 10 00 cmpw $0x0,0x10(%esi) 10d389: 74 21 je 10d3ac <== NEVER TAKEN 10d38b: bb 01 00 00 00 mov $0x1,%ebx the_thread = (Thread_Control *)information->local_table[ i ]; 10d390: 8b 46 1c mov 0x1c(%esi),%eax 10d393: 8b 04 98 mov (%eax,%ebx,4),%eax if ( !the_thread ) 10d396: 85 c0 test %eax,%eax 10d398: 74 09 je 10d3a3 <== NEVER TAKEN continue; (*routine)(the_thread); 10d39a: 83 ec 0c sub $0xc,%esp 10d39d: 50 push %eax 10d39e: ff d7 call *%edi 10d3a0: 83 c4 10 add $0x10,%esp information = _Objects_Information_table[ api_index ][ 1 ]; if ( !information ) continue; for ( i=1 ; i <= information->maximum ; i++ ) { 10d3a3: 43 inc %ebx 10d3a4: 0f b7 46 10 movzwl 0x10(%esi),%eax 10d3a8: 39 d8 cmp %ebx,%eax 10d3aa: 73 e4 jae 10d390 Objects_Information *information; if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10d3ac: ff 45 e4 incl -0x1c(%ebp) 10d3af: 83 7d e4 04 cmpl $0x4,-0x1c(%ebp) 10d3b3: 75 ba jne 10d36f (*routine)(the_thread); } } } 10d3b5: 8d 65 f4 lea -0xc(%ebp),%esp 10d3b8: 5b pop %ebx 10d3b9: 5e pop %esi 10d3ba: 5f pop %edi 10d3bb: c9 leave 10d3bc: c3 ret =============================================================================== 0010f318 : */ void rtems_libio_free( rtems_libio_t *iop ) { 10f318: 55 push %ebp 10f319: 89 e5 mov %esp,%ebp 10f31b: 53 push %ebx 10f31c: 83 ec 08 sub $0x8,%esp 10f31f: 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 ); 10f322: 6a 00 push $0x0 10f324: 6a 00 push $0x0 10f326: ff 35 88 63 12 00 pushl 0x126388 10f32c: e8 77 b8 ff ff call 10aba8 rtems_libio_lock(); if (iop->sem) 10f331: 8b 43 2c mov 0x2c(%ebx),%eax 10f334: 83 c4 10 add $0x10,%esp 10f337: 85 c0 test %eax,%eax 10f339: 74 0c je 10f347 <== NEVER TAKEN rtems_semaphore_delete(iop->sem); 10f33b: 83 ec 0c sub $0xc,%esp 10f33e: 50 push %eax 10f33f: e8 c0 b7 ff ff call 10ab04 10f344: 83 c4 10 add $0x10,%esp iop->flags &= ~LIBIO_FLAGS_OPEN; 10f347: 81 63 14 ff fe ff ff andl $0xfffffeff,0x14(%ebx) iop->data1 = rtems_libio_iop_freelist; 10f34e: a1 84 63 12 00 mov 0x126384,%eax 10f353: 89 43 34 mov %eax,0x34(%ebx) rtems_libio_iop_freelist = iop; 10f356: 89 1d 84 63 12 00 mov %ebx,0x126384 } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10f35c: a1 88 63 12 00 mov 0x126388,%eax 10f361: 89 45 08 mov %eax,0x8(%ebp) rtems_libio_unlock(); } 10f364: 8b 5d fc mov -0x4(%ebp),%ebx 10f367: c9 leave 10f368: e9 37 b9 ff ff jmp 10aca4 =============================================================================== 00107730 : * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) { 107730: 55 push %ebp 107731: 89 e5 mov %esp,%ebp 107733: 53 push %ebx 107734: 83 ec 04 sub $0x4,%esp rtems_status_code rc; uint32_t i; rtems_libio_t *iop; if (rtems_libio_number_iops > 0) 107737: 8b 1d ec 21 12 00 mov 0x1221ec,%ebx 10773d: 85 db test %ebx,%ebx 10773f: 74 50 je 107791 <== NEVER TAKEN { rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, 107741: 83 ec 08 sub $0x8,%esp 107744: 6a 38 push $0x38 107746: 53 push %ebx 107747: e8 58 fd ff ff call 1074a4 10774c: 89 c2 mov %eax,%edx 10774e: a3 80 63 12 00 mov %eax,0x126380 sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) 107753: 83 c4 10 add $0x10,%esp 107756: 85 c0 test %eax,%eax 107758: 74 74 je 1077ce rtems_fatal_error_occurred(RTEMS_NO_MEMORY); iop = rtems_libio_iop_freelist = rtems_libio_iops; 10775a: a3 84 63 12 00 mov %eax,0x126384 for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++) 10775f: 83 fb 01 cmp $0x1,%ebx 107762: 76 26 jbe 10778a <== NEVER TAKEN * rtems_libio_init * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) 107764: 8d 50 38 lea 0x38(%eax),%edx 107767: 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; 10776c: 89 52 fc mov %edx,-0x4(%edx) 10776f: 41 inc %ecx 107770: 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++) 107773: 39 d9 cmp %ebx,%ecx 107775: 75 f5 jne 10776c * rtems_libio_init * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) 107777: 8d 0c cd f8 ff ff ff lea -0x8(,%ecx,8),%ecx 10777e: 8d 14 cd 00 00 00 00 lea 0x0(,%ecx,8),%edx 107785: 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++) 107787: 8d 14 10 lea (%eax,%edx,1),%edx iop->data1 = iop + 1; iop->data1 = NULL; 10778a: 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( 107791: 83 ec 0c sub $0xc,%esp 107794: 68 88 63 12 00 push $0x126388 107799: 6a 00 push $0x0 10779b: 6a 54 push $0x54 10779d: 6a 01 push $0x1 10779f: 68 4f 49 42 4c push $0x4c42494f 1077a4: e8 83 31 00 00 call 10a92c 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_libio_semaphore ); if ( rc != RTEMS_SUCCESSFUL ) 1077a9: 83 c4 20 add $0x20,%esp 1077ac: 85 c0 test %eax,%eax 1077ae: 75 15 jne 1077c5 <== NEVER TAKEN /* * Initialize the base file system infrastructure. */ if (rtems_fs_init_helper) 1077b0: a1 e8 21 12 00 mov 0x1221e8,%eax 1077b5: 85 c0 test %eax,%eax 1077b7: 74 07 je 1077c0 <== NEVER TAKEN (* rtems_fs_init_helper)(); } 1077b9: 8b 5d fc mov -0x4(%ebp),%ebx 1077bc: c9 leave /* * Initialize the base file system infrastructure. */ if (rtems_fs_init_helper) (* rtems_fs_init_helper)(); 1077bd: ff e0 jmp *%eax 1077bf: 90 nop } 1077c0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1077c3: c9 leave <== NOT EXECUTED 1077c4: 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 ); 1077c5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1077c8: 50 push %eax <== NOT EXECUTED 1077c9: e8 1a 3a 00 00 call 10b1e8 <== 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); 1077ce: 83 ec 0c sub $0xc,%esp 1077d1: 6a 1a push $0x1a 1077d3: e8 10 3a 00 00 call 10b1e8 =============================================================================== 0010f3d4 : */ int rtems_libio_is_file_open( void *node_access ) { 10f3d4: 55 push %ebp 10f3d5: 89 e5 mov %esp,%ebp 10f3d7: 53 push %ebx 10f3d8: 83 ec 08 sub $0x8,%esp 10f3db: 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 ); 10f3de: 6a 00 push $0x0 10f3e0: 6a 00 push $0x0 10f3e2: ff 35 88 63 12 00 pushl 0x126388 10f3e8: e8 bb b7 ff ff call 10aba8 /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10f3ed: a1 80 63 12 00 mov 0x126380,%eax 10f3f2: 8b 0d ec 21 12 00 mov 0x1221ec,%ecx 10f3f8: 83 c4 10 add $0x10,%esp 10f3fb: 85 c9 test %ecx,%ecx 10f3fd: 74 18 je 10f417 <== NEVER TAKEN 10f3ff: 31 d2 xor %edx,%edx 10f401: eb 04 jmp 10f407 10f403: 90 nop 10f404: 83 c0 38 add $0x38,%eax if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) { 10f407: f6 40 15 01 testb $0x1,0x15(%eax) 10f40b: 74 05 je 10f412 /* * Check if this node is under the file system that we * are trying to dismount. */ if ( iop->pathinfo.node_access == node_access ) { 10f40d: 39 58 18 cmp %ebx,0x18(%eax) 10f410: 74 1e je 10f430 /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10f412: 42 inc %edx 10f413: 39 ca cmp %ecx,%edx 10f415: 72 ed jb 10f404 int rtems_libio_is_file_open( void *node_access ) { rtems_libio_t *iop; int result=0; 10f417: 31 db xor %ebx,%ebx } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10f419: 83 ec 0c sub $0xc,%esp 10f41c: ff 35 88 63 12 00 pushl 0x126388 10f422: e8 7d b8 ff ff call 10aca4 } rtems_libio_unlock(); return result; } 10f427: 89 d8 mov %ebx,%eax 10f429: 8b 5d fc mov -0x4(%ebp),%ebx 10f42c: c9 leave 10f42d: c3 ret 10f42e: 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; 10f430: bb 01 00 00 00 mov $0x1,%ebx 10f435: eb e2 jmp 10f419 =============================================================================== 0010f370 : */ int rtems_libio_is_open_files_in_fs( rtems_filesystem_mount_table_entry_t * fs_mt_entry ) { 10f370: 55 push %ebp 10f371: 89 e5 mov %esp,%ebp 10f373: 53 push %ebx 10f374: 83 ec 08 sub $0x8,%esp 10f377: 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 ); 10f37a: 6a 00 push $0x0 10f37c: 6a 00 push $0x0 10f37e: ff 35 88 63 12 00 pushl 0x126388 10f384: e8 1f b8 ff ff call 10aba8 /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10f389: a1 80 63 12 00 mov 0x126380,%eax 10f38e: 8b 0d ec 21 12 00 mov 0x1221ec,%ecx 10f394: 83 c4 10 add $0x10,%esp 10f397: 85 c9 test %ecx,%ecx 10f399: 74 18 je 10f3b3 <== NEVER TAKEN 10f39b: 31 d2 xor %edx,%edx 10f39d: eb 04 jmp 10f3a3 10f39f: 90 nop 10f3a0: 83 c0 38 add $0x38,%eax if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) { 10f3a3: f6 40 15 01 testb $0x1,0x15(%eax) 10f3a7: 74 05 je 10f3ae /* * Check if this node is under the file system that we * are trying to dismount. */ if ( iop->pathinfo.mt_entry == fs_mt_entry ) { 10f3a9: 39 58 28 cmp %ebx,0x28(%eax) 10f3ac: 74 1e je 10f3cc /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10f3ae: 42 inc %edx 10f3af: 39 ca cmp %ecx,%edx 10f3b1: 72 ed jb 10f3a0 int rtems_libio_is_open_files_in_fs( rtems_filesystem_mount_table_entry_t * fs_mt_entry ) { rtems_libio_t *iop; int result = 0; 10f3b3: 31 db xor %ebx,%ebx } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10f3b5: 83 ec 0c sub $0xc,%esp 10f3b8: ff 35 88 63 12 00 pushl 0x126388 10f3be: e8 e1 b8 ff ff call 10aca4 } rtems_libio_unlock(); return result; } 10f3c3: 89 d8 mov %ebx,%eax 10f3c5: 8b 5d fc mov -0x4(%ebp),%ebx 10f3c8: c9 leave 10f3c9: c3 ret 10f3ca: 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; 10f3cc: bb 01 00 00 00 mov $0x1,%ebx 10f3d1: eb e2 jmp 10f3b5 =============================================================================== 00108b38 : rtems_status_code rtems_libio_set_private_env(void) { 108b38: 55 push %ebp 108b39: 89 e5 mov %esp,%ebp 108b3b: 57 push %edi 108b3c: 56 push %esi 108b3d: 53 push %ebx 108b3e: 83 ec 5c sub $0x5c,%esp rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_id task_id = rtems_task_self(); 108b41: e8 5e 2d 00 00 call 10b8a4 108b46: 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); 108b49: 83 ec 0c sub $0xc,%esp 108b4c: 6a 00 push $0x0 108b4e: 8d 5d d4 lea -0x2c(%ebp),%ebx 108b51: 53 push %ebx 108b52: 6a 00 push $0x0 108b54: 6a 01 push $0x1 108b56: 68 27 06 12 00 push $0x120627 108b5b: e8 28 ee ff ff call 107988 if (rv != 0) 108b60: 83 c4 20 add $0x20,%esp 108b63: 85 c0 test %eax,%eax 108b65: 74 0d je 108b74 <== ALWAYS TAKEN error_1: rtems_filesystem_freenode(&root_loc); error_0: return RTEMS_NO_MEMORY; 108b67: b8 1a 00 00 00 mov $0x1a,%eax <== NOT EXECUTED } 108b6c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108b6f: 5b pop %ebx <== NOT EXECUTED 108b70: 5e pop %esi <== NOT EXECUTED 108b71: 5f pop %edi <== NOT EXECUTED 108b72: c9 leave <== NOT EXECUTED 108b73: 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); 108b74: 83 ec 0c sub $0xc,%esp 108b77: 6a 00 push $0x0 108b79: 8d 45 c0 lea -0x40(%ebp),%eax 108b7c: 89 45 a4 mov %eax,-0x5c(%ebp) 108b7f: 50 push %eax 108b80: 6a 00 push $0x0 108b82: 6a 01 push $0x1 108b84: 68 27 06 12 00 push $0x120627 108b89: e8 fa ed ff ff call 107988 if (rv != 0) 108b8e: 83 c4 20 add $0x20,%esp 108b91: 85 c0 test %eax,%eax 108b93: 0f 85 9a 00 00 00 jne 108c33 <== 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 108b99: 8b 15 10 41 12 00 mov 0x124110,%edx /* * Bharath: I'm not sure if the check can be reduced to * if( rtems_current_user_env->task_id != task_id ) { */ if ( 108b9f: 81 fa 40 63 12 00 cmp $0x126340,%edx 108ba5: 74 07 je 108bae rtems_current_user_env == &rtems_global_user_env || rtems_current_user_env->task_id != task_id 108ba7: 8b 45 b4 mov -0x4c(%ebp),%eax 108baa: 39 02 cmp %eax,(%edx) 108bac: 74 3a je 108be8 ) { new_env = malloc(sizeof(rtems_user_env_t)); 108bae: 83 ec 0c sub $0xc,%esp 108bb1: 6a 48 push $0x48 108bb3: e8 ec f3 ff ff call 107fa4 108bb8: 89 c2 mov %eax,%edx 108bba: 89 c6 mov %eax,%esi if (new_env == NULL) 108bbc: 83 c4 10 add $0x10,%esp 108bbf: 85 c0 test %eax,%eax 108bc1: 74 61 je 108c24 #ifdef HAVE_USERENV_REFCNT new_env->refcnt = 1; #endif sc = rtems_task_variable_add( 108bc3: 50 push %eax 108bc4: 68 f8 8a 10 00 push $0x108af8 108bc9: 68 10 41 12 00 push $0x124110 108bce: 6a 00 push $0x0 108bd0: 89 55 b0 mov %edx,-0x50(%ebp) 108bd3: e8 50 2d 00 00 call 10b928 RTEMS_SELF, (void*)&rtems_current_user_env, (void(*)(void *))free_user_env ); if (sc != RTEMS_SUCCESSFUL) 108bd8: 83 c4 10 add $0x10,%esp 108bdb: 85 c0 test %eax,%eax 108bdd: 8b 55 b0 mov -0x50(%ebp),%edx 108be0: 75 36 jne 108c18 goto error_3; rtems_current_user_env = new_env; 108be2: 89 15 10 41 12 00 mov %edx,0x124110 } /* Inherit the global values */ *rtems_current_user_env = rtems_global_user_env; 108be8: be 40 63 12 00 mov $0x126340,%esi 108bed: b9 12 00 00 00 mov $0x12,%ecx 108bf2: 89 d7 mov %edx,%edi 108bf4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_current_user_env->task_id = task_id; 108bf6: 8b 75 b4 mov -0x4c(%ebp),%esi 108bf9: 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; 108bfb: 8d 7a 18 lea 0x18(%edx),%edi 108bfe: b1 05 mov $0x5,%cl 108c00: 89 de mov %ebx,%esi 108c02: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_filesystem_current = current_loc; 108c04: 8d 7a 04 lea 0x4(%edx),%edi 108c07: b1 05 mov $0x5,%cl 108c09: 8b 75 a4 mov -0x5c(%ebp),%esi 108c0c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return RTEMS_SUCCESSFUL; 108c0e: 31 c0 xor %eax,%eax error_1: rtems_filesystem_freenode(&root_loc); error_0: return RTEMS_NO_MEMORY; } 108c10: 8d 65 f4 lea -0xc(%ebp),%esp 108c13: 5b pop %ebx 108c14: 5e pop %esi 108c15: 5f pop %edi 108c16: c9 leave 108c17: c3 ret rtems_filesystem_current = current_loc; return RTEMS_SUCCESSFUL; error_3: free(new_env); 108c18: 83 ec 0c sub $0xc,%esp 108c1b: 56 push %esi 108c1c: e8 53 ee ff ff call 107a74 108c21: 83 c4 10 add $0x10,%esp error_2: rtems_filesystem_freenode(¤t_loc); 108c24: 83 ec 0c sub $0xc,%esp 108c27: 8d 45 c0 lea -0x40(%ebp),%eax 108c2a: 50 push %eax 108c2b: e8 30 ee ff ff call 107a60 108c30: 83 c4 10 add $0x10,%esp error_1: rtems_filesystem_freenode(&root_loc); 108c33: 83 ec 0c sub $0xc,%esp 108c36: 53 push %ebx 108c37: e8 24 ee ff ff call 107a60 108c3c: 83 c4 10 add $0x10,%esp error_0: return RTEMS_NO_MEMORY; 108c3f: b8 1a 00 00 00 mov $0x1a,%eax } 108c44: 8d 65 f4 lea -0xc(%ebp),%esp 108c47: 5b pop %ebx 108c48: 5e pop %esi 108c49: 5f pop %edi 108c4a: c9 leave 108c4b: c3 ret =============================================================================== 00108c4c : * 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) { 108c4c: 55 push %ebp 108c4d: 89 e5 mov %esp,%ebp 108c4f: 56 push %esi 108c50: 53 push %ebx 108c51: 83 ec 20 sub $0x20,%esp 108c54: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_id current_task_id; /* * get current task id */ current_task_id = rtems_task_self(); 108c57: e8 48 2c 00 00 call 10b8a4 108c5c: 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 ) 108c5e: 39 c3 cmp %eax,%ebx 108c60: 74 32 je 108c94 <== NEVER TAKEN return RTEMS_SUCCESSFUL; /* * Try to get the requested user environment */ sc = rtems_task_variable_get( 108c62: 52 push %edx task_id, (void*)&rtems_current_user_env, (void*)&shared_user_env ); 108c63: 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( 108c66: 50 push %eax 108c67: 68 10 41 12 00 push $0x124110 108c6c: 53 push %ebx 108c6d: e8 7a 2d 00 00 call 10b9ec (void*)&shared_user_env ); /* * If it was not successful, return the error code */ if (sc != RTEMS_SUCCESSFUL) 108c72: 83 c4 10 add $0x10,%esp 108c75: 85 c0 test %eax,%eax 108c77: 75 13 jne 108c8c * 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) { 108c79: 8b 15 10 41 12 00 mov 0x124110,%edx 108c7f: 39 32 cmp %esi,(%edx) 108c81: 74 1d je 108ca0 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; 108c83: 8b 55 f4 mov -0xc(%ebp),%edx 108c86: 89 15 10 41 12 00 mov %edx,0x124110 #ifdef HAVE_USERENV_REFCNT rtems_current_user_env->refcnt++; #endif return RTEMS_SUCCESSFUL; } 108c8c: 8d 65 f8 lea -0x8(%ebp),%esp 108c8f: 5b pop %ebx 108c90: 5e pop %esi 108c91: c9 leave 108c92: c3 ret 108c93: 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; 108c94: 31 c0 xor %eax,%eax #ifdef HAVE_USERENV_REFCNT rtems_current_user_env->refcnt++; #endif return RTEMS_SUCCESSFUL; } 108c96: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108c99: 5b pop %ebx <== NOT EXECUTED 108c9a: 5e pop %esi <== NOT EXECUTED 108c9b: c9 leave <== NOT EXECUTED 108c9c: c3 ret <== NOT EXECUTED 108c9d: 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 ); 108ca0: 83 ec 0c sub $0xc,%esp 108ca3: 52 push %edx 108ca4: 89 45 e4 mov %eax,-0x1c(%ebp) 108ca7: e8 4c fe ff ff call 108af8 108cac: 83 c4 10 add $0x10,%esp 108caf: 8b 45 e4 mov -0x1c(%ebp),%eax 108cb2: eb cf jmp 108c83 =============================================================================== 0010f230 : */ uint32_t rtems_libio_to_fcntl_flags( uint32_t flags ) { 10f230: 55 push %ebp 10f231: 89 e5 mov %esp,%ebp 10f233: 8b 55 08 mov 0x8(%ebp),%edx uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10f236: 89 d0 mov %edx,%eax 10f238: 83 e0 06 and $0x6,%eax 10f23b: 83 f8 06 cmp $0x6,%eax 10f23e: 74 2c je 10f26c <== NEVER TAKEN fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { 10f240: f6 c2 02 test $0x2,%dl 10f243: 75 23 jne 10f268 <== ALWAYS TAKEN ) { uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { fcntl_flags |= O_RDWR; 10f245: 31 c0 xor %eax,%eax 10f247: f6 c2 04 test $0x4,%dl <== NOT EXECUTED 10f24a: 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 ) { 10f24d: f6 c2 01 test $0x1,%dl 10f250: 74 03 je 10f255 fcntl_flags |= O_NONBLOCK; 10f252: 80 cc 40 or $0x40,%ah } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 10f255: f6 c6 02 test $0x2,%dh 10f258: 74 03 je 10f25d fcntl_flags |= O_APPEND; 10f25a: 83 c8 08 or $0x8,%eax } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 10f25d: 80 e6 04 and $0x4,%dh 10f260: 74 03 je 10f265 fcntl_flags |= O_CREAT; 10f262: 80 cc 02 or $0x2,%ah } return fcntl_flags; } 10f265: c9 leave 10f266: c3 ret 10f267: 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; 10f268: 31 c0 xor %eax,%eax 10f26a: eb e1 jmp 10f24d ) { uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { fcntl_flags |= O_RDWR; 10f26c: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10f271: eb da jmp 10f24d <== NOT EXECUTED =============================================================================== 0010a4f0 : * size and thus we skip updating the statistics. */ static void rtems_malloc_statistics_at_free( void *pointer ) { 10a4f0: 55 push %ebp 10a4f1: 89 e5 mov %esp,%ebp 10a4f3: 83 ec 1c sub $0x1c,%esp uintptr_t size; if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) { 10a4f6: 8d 45 f4 lea -0xc(%ebp),%eax 10a4f9: 50 push %eax 10a4fa: ff 75 08 pushl 0x8(%ebp) 10a4fd: ff 35 f0 89 12 00 pushl 0x1289f0 10a503: e8 b0 59 00 00 call 10feb8 <_Protected_heap_Get_block_size> 10a508: 83 c4 10 add $0x10,%esp 10a50b: 84 c0 test %al,%al 10a50d: 74 11 je 10a520 <== NEVER TAKEN MSBUMP(lifetime_freed, size); 10a50f: 8b 45 f4 mov -0xc(%ebp),%eax 10a512: 31 d2 xor %edx,%edx 10a514: 01 05 a4 d4 12 00 add %eax,0x12d4a4 10a51a: 11 15 a8 d4 12 00 adc %edx,0x12d4a8 } } 10a520: c9 leave 10a521: c3 ret =============================================================================== 0010a524 : } static void rtems_malloc_statistics_at_malloc( void *pointer ) { 10a524: 55 push %ebp 10a525: 89 e5 mov %esp,%ebp 10a527: 83 ec 18 sub $0x18,%esp 10a52a: 8b 45 08 mov 0x8(%ebp),%eax uintptr_t actual_size = 0; 10a52d: 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 ) 10a534: 85 c0 test %eax,%eax 10a536: 74 43 je 10a57b <== NEVER TAKEN return; _Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size); 10a538: 52 push %edx 10a539: 8d 55 f4 lea -0xc(%ebp),%edx 10a53c: 52 push %edx 10a53d: 50 push %eax 10a53e: ff 35 f0 89 12 00 pushl 0x1289f0 10a544: e8 6f 59 00 00 call 10feb8 <_Protected_heap_Get_block_size> MSBUMP(lifetime_allocated, actual_size); 10a549: 8b 45 f4 mov -0xc(%ebp),%eax 10a54c: 31 d2 xor %edx,%edx 10a54e: 03 05 9c d4 12 00 add 0x12d49c,%eax 10a554: 13 15 a0 d4 12 00 adc 0x12d4a0,%edx 10a55a: a3 9c d4 12 00 mov %eax,0x12d49c 10a55f: 89 15 a0 d4 12 00 mov %edx,0x12d4a0 current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed); 10a565: 2b 05 a4 d4 12 00 sub 0x12d4a4,%eax if (current_depth > s->max_depth) 10a56b: 83 c4 10 add $0x10,%esp 10a56e: 3b 05 98 d4 12 00 cmp 0x12d498,%eax 10a574: 76 05 jbe 10a57b s->max_depth = current_depth; 10a576: a3 98 d4 12 00 mov %eax,0x12d498 } 10a57b: c9 leave 10a57c: c3 ret =============================================================================== 001131c4 : int rtems_memalign( void **pointer, size_t alignment, size_t size ) { 1131c4: 55 push %ebp 1131c5: 89 e5 mov %esp,%ebp 1131c7: 53 push %ebx 1131c8: 83 ec 14 sub $0x14,%esp 1131cb: 8b 5d 08 mov 0x8(%ebp),%ebx void *return_this; /* * Parameter error checks */ if ( !pointer ) 1131ce: 85 db test %ebx,%ebx 1131d0: 74 5b je 11322d return EINVAL; *pointer = NULL; 1131d2: 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()) && 1131d8: 83 3d 80 96 12 00 03 cmpl $0x3,0x129680 1131df: 74 43 je 113224 <== ALWAYS TAKEN return EINVAL; /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 1131e1: e8 fa 54 ff ff call 1086e0 Heap_Control *heap, uintptr_t size, uintptr_t alignment ) { return 1131e6: 6a 00 push $0x0 1131e8: ff 75 0c pushl 0xc(%ebp) 1131eb: ff 75 10 pushl 0x10(%ebp) 1131ee: ff 35 90 51 12 00 pushl 0x125190 1131f4: e8 63 a4 ff ff call 10d65c <_Protected_heap_Allocate_aligned_with_boundary> return_this = _Protected_heap_Allocate_aligned( RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 1131f9: 83 c4 10 add $0x10,%esp 1131fc: 85 c0 test %eax,%eax 1131fe: 74 38 je 113238 return ENOMEM; /* * If configured, update the more involved statistics */ if ( rtems_malloc_statistics_helpers ) 113200: 8b 15 28 77 12 00 mov 0x127728,%edx 113206: 85 d2 test %edx,%edx 113208: 74 10 je 11321a (*rtems_malloc_statistics_helpers->at_malloc)(pointer); 11320a: 83 ec 0c sub $0xc,%esp 11320d: 53 push %ebx 11320e: 89 45 f4 mov %eax,-0xc(%ebp) 113211: ff 52 04 call *0x4(%edx) 113214: 83 c4 10 add $0x10,%esp 113217: 8b 45 f4 mov -0xc(%ebp),%eax *pointer = return_this; 11321a: 89 03 mov %eax,(%ebx) return 0; 11321c: 31 c0 xor %eax,%eax } 11321e: 8b 5d fc mov -0x4(%ebp),%ebx 113221: c9 leave 113222: c3 ret 113223: 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() ) 113224: e8 77 54 ff ff call 1086a0 *pointer = NULL; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 113229: 84 c0 test %al,%al 11322b: 75 b4 jne 1131e1 <== ALWAYS TAKEN !malloc_is_system_state_OK() ) return EINVAL; 11322d: 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; } 113232: 8b 5d fc mov -0x4(%ebp),%ebx 113235: c9 leave 113236: c3 ret 113237: 90 nop RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) return ENOMEM; 113238: b8 0c 00 00 00 mov $0xc,%eax 11323d: eb df jmp 11321e =============================================================================== 001159e4 : rtems_id id, const void *buffer, size_t size, uint32_t *count ) { 1159e4: 55 push %ebp 1159e5: 89 e5 mov %esp,%ebp 1159e7: 57 push %edi 1159e8: 56 push %esi 1159e9: 53 push %ebx 1159ea: 83 ec 1c sub $0x1c,%esp 1159ed: 8b 7d 08 mov 0x8(%ebp),%edi 1159f0: 8b 5d 0c mov 0xc(%ebp),%ebx 1159f3: 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 ) 1159f6: 85 db test %ebx,%ebx 1159f8: 74 62 je 115a5c return RTEMS_INVALID_ADDRESS; if ( !count ) 1159fa: 85 f6 test %esi,%esi 1159fc: 74 5e je 115a5c Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) _Objects_Get( &_Message_queue_Information, id, location ); 1159fe: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 1159ff: 8d 45 e4 lea -0x1c(%ebp),%eax 115a02: 50 push %eax 115a03: 57 push %edi 115a04: 68 00 0c 14 00 push $0x140c00 115a09: e8 b6 4d 00 00 call 11a7c4 <_Objects_Get> switch ( location ) { 115a0e: 83 c4 10 add $0x10,%esp 115a11: 8b 55 e4 mov -0x1c(%ebp),%edx 115a14: 85 d2 test %edx,%edx 115a16: 74 10 je 115a28 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115a18: b8 04 00 00 00 mov $0x4,%eax } 115a1d: 8d 65 f4 lea -0xc(%ebp),%esp 115a20: 5b pop %ebx 115a21: 5e pop %esi 115a22: 5f pop %edi 115a23: c9 leave 115a24: c3 ret 115a25: 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( 115a28: 83 ec 08 sub $0x8,%esp 115a2b: 56 push %esi 115a2c: 6a 00 push $0x0 115a2e: 57 push %edi 115a2f: ff 75 10 pushl 0x10(%ebp) 115a32: 53 push %ebx 115a33: 83 c0 14 add $0x14,%eax 115a36: 50 push %eax 115a37: e8 60 34 00 00 call 118e9c <_CORE_message_queue_Broadcast> 115a3c: 89 c3 mov %eax,%ebx NULL, #endif count ); _Thread_Enable_dispatch(); 115a3e: 83 c4 20 add $0x20,%esp 115a41: e8 ce 58 00 00 call 11b314 <_Thread_Enable_dispatch> return 115a46: 83 ec 0c sub $0xc,%esp 115a49: 53 push %ebx 115a4a: e8 69 03 00 00 call 115db8 <_Message_queue_Translate_core_message_queue_return_code> 115a4f: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115a52: 8d 65 f4 lea -0xc(%ebp),%esp 115a55: 5b pop %ebx 115a56: 5e pop %esi 115a57: 5f pop %edi 115a58: c9 leave 115a59: c3 ret 115a5a: 66 90 xchg %ax,%ax if ( !buffer ) return RTEMS_INVALID_ADDRESS; if ( !count ) return RTEMS_INVALID_ADDRESS; 115a5c: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115a61: 8d 65 f4 lea -0xc(%ebp),%esp 115a64: 5b pop %ebx 115a65: 5e pop %esi 115a66: 5f pop %edi 115a67: c9 leave 115a68: c3 ret =============================================================================== 0010f7b0 : uint32_t count, size_t max_message_size, rtems_attribute attribute_set, rtems_id *id ) { 10f7b0: 55 push %ebp 10f7b1: 89 e5 mov %esp,%ebp 10f7b3: 57 push %edi 10f7b4: 56 push %esi 10f7b5: 53 push %ebx 10f7b6: 83 ec 2c sub $0x2c,%esp 10f7b9: 8b 5d 08 mov 0x8(%ebp),%ebx 10f7bc: 8b 75 0c mov 0xc(%ebp),%esi 10f7bf: 8b 4d 10 mov 0x10(%ebp),%ecx 10f7c2: 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 ) ) 10f7c5: 85 db test %ebx,%ebx 10f7c7: 74 2f je 10f7f8 return RTEMS_INVALID_NAME; if ( !id ) 10f7c9: 85 ff test %edi,%edi 10f7cb: 0f 84 a3 00 00 00 je 10f874 if ( (is_global = _Attributes_Is_global( attribute_set ) ) && !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) 10f7d1: 85 f6 test %esi,%esi 10f7d3: 74 13 je 10f7e8 return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 10f7d5: 85 c9 test %ecx,%ecx 10f7d7: 75 2f jne 10f808 return RTEMS_INVALID_SIZE; 10f7d9: b8 08 00 00 00 mov $0x8,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10f7de: 8d 65 f4 lea -0xc(%ebp),%esp 10f7e1: 5b pop %ebx 10f7e2: 5e pop %esi 10f7e3: 5f pop %edi 10f7e4: c9 leave 10f7e5: c3 ret 10f7e6: 66 90 xchg %ax,%ax !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) return RTEMS_INVALID_NUMBER; 10f7e8: b8 0a 00 00 00 mov $0xa,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10f7ed: 8d 65 f4 lea -0xc(%ebp),%esp 10f7f0: 5b pop %ebx 10f7f1: 5e pop %esi 10f7f2: 5f pop %edi 10f7f3: c9 leave 10f7f4: c3 ret 10f7f5: 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; 10f7f8: b8 03 00 00 00 mov $0x3,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10f7fd: 8d 65 f4 lea -0xc(%ebp),%esp 10f800: 5b pop %ebx 10f801: 5e pop %esi 10f802: 5f pop %edi 10f803: c9 leave 10f804: c3 ret 10f805: 8d 76 00 lea 0x0(%esi),%esi 10f808: a1 ec 64 12 00 mov 0x1264ec,%eax 10f80d: 40 inc %eax 10f80e: a3 ec 64 12 00 mov %eax,0x1264ec #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); 10f813: 89 4d d4 mov %ecx,-0x2c(%ebp) 10f816: e8 4d 21 00 00 call 111968 <_Message_queue_Allocate> 10f81b: 89 c2 mov %eax,%edx if ( !the_message_queue ) { 10f81d: 85 c0 test %eax,%eax 10f81f: 8b 4d d4 mov -0x2c(%ebp),%ecx 10f822: 74 7c je 10f8a0 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_message_queue->attribute_set = attribute_set; 10f824: 8b 45 14 mov 0x14(%ebp),%eax 10f827: 89 42 10 mov %eax,0x10(%edx) if (_Attributes_Is_priority( attribute_set ) ) the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 10f82a: a8 04 test $0x4,%al 10f82c: 0f 95 c0 setne %al 10f82f: 0f b6 c0 movzbl %al,%eax 10f832: 89 45 e4 mov %eax,-0x1c(%ebp) else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( ! _CORE_message_queue_Initialize( 10f835: 51 push %ecx 10f836: 56 push %esi 10f837: 8d 45 e4 lea -0x1c(%ebp),%eax 10f83a: 50 push %eax 10f83b: 8d 42 14 lea 0x14(%edx),%eax 10f83e: 50 push %eax 10f83f: 89 55 d4 mov %edx,-0x2c(%ebp) 10f842: e8 c5 06 00 00 call 10ff0c <_CORE_message_queue_Initialize> 10f847: 83 c4 10 add $0x10,%esp 10f84a: 84 c0 test %al,%al 10f84c: 8b 55 d4 mov -0x2c(%ebp),%edx 10f84f: 75 2f jne 10f880 */ RTEMS_INLINE_ROUTINE void _Message_queue_Free ( Message_queue_Control *the_message_queue ) { _Objects_Free( &_Message_queue_Information, &the_message_queue->Object ); 10f851: 83 ec 08 sub $0x8,%esp 10f854: 52 push %edx 10f855: 68 e0 68 12 00 push $0x1268e0 10f85a: e8 0d c8 ff ff call 10c06c <_Objects_Free> _Objects_MP_Close( &_Message_queue_Information, the_message_queue->Object.id); #endif _Message_queue_Free( the_message_queue ); _Thread_Enable_dispatch(); 10f85f: e8 98 d4 ff ff call 10ccfc <_Thread_Enable_dispatch> return RTEMS_UNSATISFIED; 10f864: 83 c4 10 add $0x10,%esp 10f867: b8 0d 00 00 00 mov $0xd,%eax 10f86c: e9 6d ff ff ff jmp 10f7de 10f871: 8d 76 00 lea 0x0(%esi),%esi if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 10f874: b8 09 00 00 00 mov $0x9,%eax 10f879: e9 60 ff ff ff jmp 10f7de 10f87e: 66 90 xchg %ax,%ax Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10f880: 8b 42 08 mov 0x8(%edx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10f883: 0f b7 f0 movzwl %ax,%esi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10f886: 8b 0d fc 68 12 00 mov 0x1268fc,%ecx 10f88c: 89 14 b1 mov %edx,(%ecx,%esi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10f88f: 89 5a 0c mov %ebx,0xc(%edx) &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 10f892: 89 07 mov %eax,(%edi) name, 0 ); #endif _Thread_Enable_dispatch(); 10f894: e8 63 d4 ff ff call 10ccfc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10f899: 31 c0 xor %eax,%eax 10f89b: e9 3e ff ff ff jmp 10f7de _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); if ( !the_message_queue ) { _Thread_Enable_dispatch(); 10f8a0: e8 57 d4 ff ff call 10ccfc <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 10f8a5: b8 05 00 00 00 mov $0x5,%eax 10f8aa: e9 2f ff ff ff jmp 10f7de =============================================================================== 0010f8b0 : */ rtems_status_code rtems_message_queue_delete( rtems_id id ) { 10f8b0: 55 push %ebp 10f8b1: 89 e5 mov %esp,%ebp 10f8b3: 53 push %ebx 10f8b4: 83 ec 18 sub $0x18,%esp register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); 10f8b7: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) _Objects_Get( &_Message_queue_Information, id, location ); 10f8ba: 50 push %eax 10f8bb: ff 75 08 pushl 0x8(%ebp) 10f8be: 68 e0 68 12 00 push $0x1268e0 10f8c3: e8 e4 c8 ff ff call 10c1ac <_Objects_Get> 10f8c8: 89 c3 mov %eax,%ebx switch ( location ) { 10f8ca: 83 c4 10 add $0x10,%esp 10f8cd: 8b 4d f4 mov -0xc(%ebp),%ecx 10f8d0: 85 c9 test %ecx,%ecx 10f8d2: 75 3c jne 10f910 case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, 10f8d4: 83 ec 08 sub $0x8,%esp 10f8d7: 50 push %eax 10f8d8: 68 e0 68 12 00 push $0x1268e0 10f8dd: e8 92 c4 ff ff call 10bd74 <_Objects_Close> &the_message_queue->Object ); _CORE_message_queue_Close( 10f8e2: 83 c4 0c add $0xc,%esp 10f8e5: 6a 05 push $0x5 10f8e7: 6a 00 push $0x0 10f8e9: 8d 43 14 lea 0x14(%ebx),%eax 10f8ec: 50 push %eax 10f8ed: e8 96 05 00 00 call 10fe88 <_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 ); 10f8f2: 58 pop %eax 10f8f3: 5a pop %edx 10f8f4: 53 push %ebx 10f8f5: 68 e0 68 12 00 push $0x1268e0 10f8fa: e8 6d c7 ff ff call 10c06c <_Objects_Free> 0, /* Not used */ 0 ); } #endif _Thread_Enable_dispatch(); 10f8ff: e8 f8 d3 ff ff call 10ccfc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10f904: 83 c4 10 add $0x10,%esp 10f907: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f909: 8b 5d fc mov -0x4(%ebp),%ebx 10f90c: c9 leave 10f90d: c3 ret 10f90e: 66 90 xchg %ax,%ax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10f910: b8 04 00 00 00 mov $0x4,%eax } 10f915: 8b 5d fc mov -0x4(%ebp),%ebx 10f918: c9 leave 10f919: c3 ret =============================================================================== 00115bd8 : rtems_status_code rtems_message_queue_flush( rtems_id id, uint32_t *count ) { 115bd8: 55 push %ebp 115bd9: 89 e5 mov %esp,%ebp 115bdb: 53 push %ebx 115bdc: 83 ec 14 sub $0x14,%esp 115bdf: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 115be2: 85 db test %ebx,%ebx 115be4: 74 46 je 115c2c Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) _Objects_Get( &_Message_queue_Information, id, location ); 115be6: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 115be7: 8d 45 f4 lea -0xc(%ebp),%eax 115bea: 50 push %eax 115beb: ff 75 08 pushl 0x8(%ebp) 115bee: 68 00 0c 14 00 push $0x140c00 115bf3: e8 cc 4b 00 00 call 11a7c4 <_Objects_Get> switch ( location ) { 115bf8: 83 c4 10 add $0x10,%esp 115bfb: 8b 55 f4 mov -0xc(%ebp),%edx 115bfe: 85 d2 test %edx,%edx 115c00: 74 0a je 115c0c case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115c02: b8 04 00 00 00 mov $0x4,%eax } 115c07: 8b 5d fc mov -0x4(%ebp),%ebx 115c0a: c9 leave 115c0b: 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 ); 115c0c: 83 ec 0c sub $0xc,%esp 115c0f: 83 c0 14 add $0x14,%eax 115c12: 50 push %eax 115c13: e8 44 33 00 00 call 118f5c <_CORE_message_queue_Flush> 115c18: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 115c1a: e8 f5 56 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115c1f: 83 c4 10 add $0x10,%esp 115c22: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115c24: 8b 5d fc mov -0x4(%ebp),%ebx 115c27: c9 leave 115c28: c3 ret 115c29: 8d 76 00 lea 0x0(%esi),%esi { register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) return RTEMS_INVALID_ADDRESS; 115c2c: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115c31: 8b 5d fc mov -0x4(%ebp),%ebx 115c34: c9 leave 115c35: c3 ret =============================================================================== 00115c38 : rtems_status_code rtems_message_queue_get_number_pending( rtems_id id, uint32_t *count ) { 115c38: 55 push %ebp 115c39: 89 e5 mov %esp,%ebp 115c3b: 53 push %ebx 115c3c: 83 ec 14 sub $0x14,%esp 115c3f: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 115c42: 85 db test %ebx,%ebx 115c44: 74 3a je 115c80 115c46: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 115c47: 8d 45 f4 lea -0xc(%ebp),%eax 115c4a: 50 push %eax 115c4b: ff 75 08 pushl 0x8(%ebp) 115c4e: 68 00 0c 14 00 push $0x140c00 115c53: e8 6c 4b 00 00 call 11a7c4 <_Objects_Get> switch ( location ) { 115c58: 83 c4 10 add $0x10,%esp 115c5b: 8b 55 f4 mov -0xc(%ebp),%edx 115c5e: 85 d2 test %edx,%edx 115c60: 74 0a je 115c6c case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115c62: b8 04 00 00 00 mov $0x4,%eax } 115c67: 8b 5d fc mov -0x4(%ebp),%ebx 115c6a: c9 leave 115c6b: 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; 115c6c: 8b 40 5c mov 0x5c(%eax),%eax 115c6f: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 115c71: e8 9e 56 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115c76: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115c78: 8b 5d fc mov -0x4(%ebp),%ebx 115c7b: c9 leave 115c7c: c3 ret 115c7d: 8d 76 00 lea 0x0(%esi),%esi { register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) return RTEMS_INVALID_ADDRESS; 115c80: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115c85: 8b 5d fc mov -0x4(%ebp),%ebx 115c88: c9 leave 115c89: c3 ret =============================================================================== 0010f91c : void *buffer, size_t *size, rtems_option option_set, rtems_interval timeout ) { 10f91c: 55 push %ebp 10f91d: 89 e5 mov %esp,%ebp 10f91f: 56 push %esi 10f920: 53 push %ebx 10f921: 83 ec 10 sub $0x10,%esp 10f924: 8b 5d 0c mov 0xc(%ebp),%ebx 10f927: 8b 75 10 mov 0x10(%ebp),%esi register Message_queue_Control *the_message_queue; Objects_Locations location; bool wait; if ( !buffer ) 10f92a: 85 db test %ebx,%ebx 10f92c: 74 6e je 10f99c return RTEMS_INVALID_ADDRESS; if ( !size ) 10f92e: 85 f6 test %esi,%esi 10f930: 74 6a je 10f99c Objects_Id id, Objects_Locations *location ) { return (Message_queue_Control *) _Objects_Get( &_Message_queue_Information, id, location ); 10f932: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 10f933: 8d 45 f4 lea -0xc(%ebp),%eax 10f936: 50 push %eax 10f937: ff 75 08 pushl 0x8(%ebp) 10f93a: 68 e0 68 12 00 push $0x1268e0 10f93f: e8 68 c8 ff ff call 10c1ac <_Objects_Get> switch ( location ) { 10f944: 83 c4 10 add $0x10,%esp 10f947: 8b 55 f4 mov -0xc(%ebp),%edx 10f94a: 85 d2 test %edx,%edx 10f94c: 75 42 jne 10f990 if ( _Options_Is_no_wait( option_set ) ) wait = false; else wait = true; _CORE_message_queue_Seize( 10f94e: 83 ec 08 sub $0x8,%esp 10f951: ff 75 18 pushl 0x18(%ebp) 10f954: 8b 55 14 mov 0x14(%ebp),%edx 10f957: 83 e2 01 and $0x1,%edx 10f95a: 83 f2 01 xor $0x1,%edx 10f95d: 52 push %edx 10f95e: 56 push %esi 10f95f: 53 push %ebx 10f960: ff 70 08 pushl 0x8(%eax) 10f963: 83 c0 14 add $0x14,%eax 10f966: 50 push %eax 10f967: e8 40 06 00 00 call 10ffac <_CORE_message_queue_Seize> buffer, size, wait, timeout ); _Thread_Enable_dispatch(); 10f96c: 83 c4 20 add $0x20,%esp 10f96f: e8 88 d3 ff ff call 10ccfc <_Thread_Enable_dispatch> return _Message_queue_Translate_core_message_queue_return_code( 10f974: 83 ec 0c sub $0xc,%esp _Thread_Executing->Wait.return_code 10f977: a1 78 67 12 00 mov 0x126778,%eax size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 10f97c: ff 70 34 pushl 0x34(%eax) 10f97f: e8 a0 00 00 00 call 10fa24 <_Message_queue_Translate_core_message_queue_return_code> 10f984: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f987: 8d 65 f8 lea -0x8(%ebp),%esp 10f98a: 5b pop %ebx 10f98b: 5e pop %esi 10f98c: c9 leave 10f98d: c3 ret 10f98e: 66 90 xchg %ax,%ax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10f990: b8 04 00 00 00 mov $0x4,%eax } 10f995: 8d 65 f8 lea -0x8(%ebp),%esp 10f998: 5b pop %ebx 10f999: 5e pop %esi 10f99a: c9 leave 10f99b: c3 ret if ( !buffer ) return RTEMS_INVALID_ADDRESS; if ( !size ) return RTEMS_INVALID_ADDRESS; 10f99c: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f9a1: 8d 65 f8 lea -0x8(%ebp),%esp 10f9a4: 5b pop %ebx 10f9a5: 5e pop %esi 10f9a6: c9 leave 10f9a7: c3 ret =============================================================================== 0010f9a8 : rtems_status_code rtems_message_queue_send( rtems_id id, const void *buffer, size_t size ) { 10f9a8: 55 push %ebp 10f9a9: 89 e5 mov %esp,%ebp 10f9ab: 56 push %esi 10f9ac: 53 push %ebx 10f9ad: 83 ec 10 sub $0x10,%esp 10f9b0: 8b 75 08 mov 0x8(%ebp),%esi 10f9b3: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 10f9b6: 85 db test %ebx,%ebx 10f9b8: 74 5e je 10fa18 10f9ba: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 10f9bb: 8d 45 f4 lea -0xc(%ebp),%eax 10f9be: 50 push %eax 10f9bf: 56 push %esi 10f9c0: 68 e0 68 12 00 push $0x1268e0 10f9c5: e8 e2 c7 ff ff call 10c1ac <_Objects_Get> switch ( location ) { 10f9ca: 83 c4 10 add $0x10,%esp 10f9cd: 8b 55 f4 mov -0xc(%ebp),%edx 10f9d0: 85 d2 test %edx,%edx 10f9d2: 74 0c je 10f9e0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10f9d4: b8 04 00 00 00 mov $0x4,%eax } 10f9d9: 8d 65 f8 lea -0x8(%ebp),%esp 10f9dc: 5b pop %ebx 10f9dd: 5e pop %esi 10f9de: c9 leave 10f9df: c3 ret CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, bool wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 10f9e0: 6a 00 push $0x0 10f9e2: 6a 00 push $0x0 10f9e4: 68 ff ff ff 7f push $0x7fffffff 10f9e9: 6a 00 push $0x0 10f9eb: 56 push %esi 10f9ec: ff 75 10 pushl 0x10(%ebp) 10f9ef: 53 push %ebx the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: status = _CORE_message_queue_Send( 10f9f0: 83 c0 14 add $0x14,%eax 10f9f3: 50 push %eax 10f9f4: e8 8b 06 00 00 call 110084 <_CORE_message_queue_Submit> 10f9f9: 89 c3 mov %eax,%ebx MESSAGE_QUEUE_MP_HANDLER, false, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 10f9fb: 83 c4 20 add $0x20,%esp 10f9fe: e8 f9 d2 ff ff call 10ccfc <_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); 10fa03: 83 ec 0c sub $0xc,%esp 10fa06: 53 push %ebx 10fa07: e8 18 00 00 00 call 10fa24 <_Message_queue_Translate_core_message_queue_return_code> 10fa0c: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10fa0f: 8d 65 f8 lea -0x8(%ebp),%esp 10fa12: 5b pop %ebx 10fa13: 5e pop %esi 10fa14: c9 leave 10fa15: c3 ret 10fa16: 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; 10fa18: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10fa1d: 8d 65 f8 lea -0x8(%ebp),%esp 10fa20: 5b pop %ebx 10fa21: 5e pop %esi 10fa22: c9 leave 10fa23: c3 ret =============================================================================== 00115dc8 : rtems_status_code rtems_message_queue_urgent( rtems_id id, const void *buffer, size_t size ) { 115dc8: 55 push %ebp 115dc9: 89 e5 mov %esp,%ebp 115dcb: 56 push %esi 115dcc: 53 push %ebx 115dcd: 83 ec 10 sub $0x10,%esp 115dd0: 8b 75 08 mov 0x8(%ebp),%esi 115dd3: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 115dd6: 85 db test %ebx,%ebx 115dd8: 74 5e je 115e38 115dda: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); 115ddb: 8d 45 f4 lea -0xc(%ebp),%eax 115dde: 50 push %eax 115ddf: 56 push %esi 115de0: 68 00 0c 14 00 push $0x140c00 115de5: e8 da 49 00 00 call 11a7c4 <_Objects_Get> switch ( location ) { 115dea: 83 c4 10 add $0x10,%esp 115ded: 8b 55 f4 mov -0xc(%ebp),%edx 115df0: 85 d2 test %edx,%edx 115df2: 74 0c je 115e00 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115df4: b8 04 00 00 00 mov $0x4,%eax } 115df9: 8d 65 f8 lea -0x8(%ebp),%esp 115dfc: 5b pop %ebx 115dfd: 5e pop %esi 115dfe: c9 leave 115dff: c3 ret CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, bool wait, Watchdog_Interval timeout ) { return _CORE_message_queue_Submit( 115e00: 6a 00 push $0x0 115e02: 6a 00 push $0x0 115e04: 68 00 00 00 80 push $0x80000000 115e09: 6a 00 push $0x0 115e0b: 56 push %esi 115e0c: ff 75 10 pushl 0x10(%ebp) 115e0f: 53 push %ebx the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: status = _CORE_message_queue_Urgent( 115e10: 83 c0 14 add $0x14,%eax 115e13: 50 push %eax 115e14: e8 1f 33 00 00 call 119138 <_CORE_message_queue_Submit> 115e19: 89 c3 mov %eax,%ebx id, MESSAGE_QUEUE_MP_HANDLER, false, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 115e1b: 83 c4 20 add $0x20,%esp 115e1e: e8 f1 54 00 00 call 11b314 <_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); 115e23: 83 ec 0c sub $0xc,%esp 115e26: 53 push %ebx 115e27: e8 8c ff ff ff call 115db8 <_Message_queue_Translate_core_message_queue_return_code> 115e2c: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115e2f: 8d 65 f8 lea -0x8(%ebp),%esp 115e32: 5b pop %ebx 115e33: 5e pop %esi 115e34: c9 leave 115e35: c3 ret 115e36: 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; 115e38: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115e3d: 8d 65 f8 lea -0x8(%ebp),%esp 115e40: 5b pop %ebx 115e41: 5e pop %esi 115e42: c9 leave 115e43: c3 ret =============================================================================== 0011181c : return (retval); } int rtems_mkdir(const char *path, mode_t mode) { 11181c: 55 push %ebp 11181d: 89 e5 mov %esp,%ebp 11181f: 57 push %edi 111820: 56 push %esi 111821: 53 push %ebx 111822: 83 ec 78 sub $0x78,%esp int success = 0; char *dup_path = strdup(path); 111825: ff 75 08 pushl 0x8(%ebp) 111828: e8 27 28 00 00 call 114054 11182d: 89 c7 mov %eax,%edi if (dup_path != NULL) { 11182f: 83 c4 10 add $0x10,%esp 111832: 85 c0 test %eax,%eax 111834: 0f 84 0a 01 00 00 je 111944 <== NEVER TAKEN char *p; p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ 11183a: 8a 10 mov (%eax),%dl 11183c: 80 fa 2f cmp $0x2f,%dl 11183f: 0f 84 0f 01 00 00 je 111954 111845: 89 c3 mov %eax,%ebx 111847: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) 11184e: b8 01 00 00 00 mov $0x1,%eax ++p; for (first = 1, last = 0; !last ; ++p) { if (p[0] == '\0') 111853: 84 d2 test %dl,%dl 111855: 74 11 je 111868 <== NEVER TAKEN 111857: 90 nop last = 1; else if (p[0] != '/') 111858: 80 fa 2f cmp $0x2f,%dl 11185b: 0f 84 83 00 00 00 je 1118e4 p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; for (first = 1, last = 0; !last ; ++p) { 111861: 43 inc %ebx 111862: 8a 13 mov (%ebx),%dl if (p[0] == '\0') 111864: 84 d2 test %dl,%dl 111866: 75 f0 jne 111858 last = 1; else if (p[0] != '/') continue; *p = '\0'; 111868: c6 03 00 movb $0x0,(%ebx) 11186b: be 01 00 00 00 mov $0x1,%esi if (!last && p[1] == '\0') last = 1; if (first) { 111870: 85 c0 test %eax,%eax 111872: 75 54 jne 1118c8 oumask = umask(0); numask = oumask & ~(S_IWUSR | S_IXUSR); (void)umask(numask); first = 0; } if (last) 111874: 85 f6 test %esi,%esi 111876: 75 3c jne 1118b4 (void)umask(oumask); if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { 111878: b8 ff 01 00 00 mov $0x1ff,%eax 11187d: 83 ec 08 sub $0x8,%esp 111880: 50 push %eax 111881: 57 push %edi 111882: e8 6d 73 ff ff call 108bf4 111887: 83 c4 10 add $0x10,%esp 11188a: 85 c0 test %eax,%eax 11188c: 78 6a js 1118f8 } else { retval = 0; break; } } if (!last) 11188e: 85 f6 test %esi,%esi 111890: 75 0a jne 11189c *p = '/'; 111892: c6 03 2f movb $0x2f,(%ebx) 111895: 31 c0 xor %eax,%eax 111897: eb c8 jmp 111861 111899: 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); 11189c: 83 ec 0c sub $0xc,%esp 11189f: 57 push %edi 1118a0: e8 77 6d ff ff call 10861c 1118a5: 83 c4 10 add $0x10,%esp } return success != 0 ? 0 : -1; 1118a8: 31 c0 xor %eax,%eax } 1118aa: 8d 65 f4 lea -0xc(%ebp),%esp 1118ad: 5b pop %ebx 1118ae: 5e pop %esi 1118af: 5f pop %edi 1118b0: c9 leave 1118b1: c3 ret 1118b2: 66 90 xchg %ax,%ax numask = oumask & ~(S_IWUSR | S_IXUSR); (void)umask(numask); first = 0; } if (last) (void)umask(oumask); 1118b4: 83 ec 0c sub $0xc,%esp 1118b7: ff 75 94 pushl -0x6c(%ebp) 1118ba: e8 81 01 00 00 call 111a40 1118bf: 83 c4 10 add $0x10,%esp if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { 1118c2: 8b 45 0c mov 0xc(%ebp),%eax 1118c5: eb b6 jmp 11187d 1118c7: 90 nop * mkdir [-m mode] dir * * We change the user's umask and then restore it, * instead of doing chmod's. */ oumask = umask(0); 1118c8: 83 ec 0c sub $0xc,%esp 1118cb: 6a 00 push $0x0 1118cd: e8 6e 01 00 00 call 111a40 1118d2: 89 45 94 mov %eax,-0x6c(%ebp) numask = oumask & ~(S_IWUSR | S_IXUSR); 1118d5: 24 3f and $0x3f,%al (void)umask(numask); 1118d7: 89 04 24 mov %eax,(%esp) 1118da: e8 61 01 00 00 call 111a40 1118df: 83 c4 10 add $0x10,%esp 1118e2: eb 90 jmp 111874 for (first = 1, last = 0; !last ; ++p) { if (p[0] == '\0') last = 1; else if (p[0] != '/') continue; *p = '\0'; 1118e4: c6 03 00 movb $0x0,(%ebx) if (!last && p[1] == '\0') 1118e7: 31 d2 xor %edx,%edx 1118e9: 80 7b 01 00 cmpb $0x0,0x1(%ebx) 1118ed: 0f 94 c2 sete %dl 1118f0: 89 d6 mov %edx,%esi 1118f2: e9 79 ff ff ff jmp 111870 1118f7: 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) { 1118f8: e8 d7 1a 00 00 call 1133d4 <__errno> 1118fd: 83 38 11 cmpl $0x11,(%eax) 111900: 74 0a je 11190c 111902: e8 cd 1a 00 00 call 1133d4 <__errno> 111907: 83 38 15 cmpl $0x15,(%eax) 11190a: 75 53 jne 11195f <== ALWAYS TAKEN if (stat(path, &sb) < 0) { 11190c: 83 ec 08 sub $0x8,%esp 11190f: 8d 45 a0 lea -0x60(%ebp),%eax 111912: 50 push %eax 111913: 57 push %edi 111914: e8 7f 00 00 00 call 111998 111919: 83 c4 10 add $0x10,%esp 11191c: 85 c0 test %eax,%eax 11191e: 78 3f js 11195f <== NEVER TAKEN retval = 0; break; } else if (!S_ISDIR(sb.st_mode)) { 111920: 8b 45 ac mov -0x54(%ebp),%eax 111923: 25 00 f0 00 00 and $0xf000,%eax 111928: 3d 00 40 00 00 cmp $0x4000,%eax 11192d: 0f 84 5b ff ff ff je 11188e if (last) 111933: 85 f6 test %esi,%esi 111935: 74 53 je 11198a errno = EEXIST; 111937: e8 98 1a 00 00 call 1133d4 <__errno> 11193c: c7 00 11 00 00 00 movl $0x11,(%eax) 111942: eb 2d jmp 111971 if (dup_path != NULL) { success = build(dup_path, mode); free(dup_path); } return success != 0 ? 0 : -1; 111944: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 111949: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11194c: 5b pop %ebx <== NOT EXECUTED 11194d: 5e pop %esi <== NOT EXECUTED 11194e: 5f pop %edi <== NOT EXECUTED 11194f: c9 leave <== NOT EXECUTED 111950: c3 ret <== NOT EXECUTED 111951: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; 111954: 8d 58 01 lea 0x1(%eax),%ebx 111957: 8a 50 01 mov 0x1(%eax),%dl 11195a: e9 e8 fe ff ff jmp 111847 } } if (!last) *p = '/'; } if (!first && !last) 11195f: 85 f6 test %esi,%esi 111961: 75 0e jne 111971 <== ALWAYS TAKEN (void)umask(oumask); 111963: 83 ec 0c sub $0xc,%esp 111966: ff 75 94 pushl -0x6c(%ebp) 111969: e8 d2 00 00 00 call 111a40 11196e: 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); 111971: 83 ec 0c sub $0xc,%esp 111974: 57 push %edi 111975: e8 a2 6c ff ff call 10861c 11197a: 83 c4 10 add $0x10,%esp } return success != 0 ? 0 : -1; 11197d: b8 ff ff ff ff mov $0xffffffff,%eax } 111982: 8d 65 f4 lea -0xc(%ebp),%esp 111985: 5b pop %ebx 111986: 5e pop %esi 111987: 5f pop %edi 111988: c9 leave 111989: c3 ret break; } else if (!S_ISDIR(sb.st_mode)) { if (last) errno = EEXIST; else errno = ENOTDIR; 11198a: e8 45 1a 00 00 call 1133d4 <__errno> 11198f: c7 00 14 00 00 00 movl $0x14,(%eax) 111995: eb cc jmp 111963 =============================================================================== 0010c4cc : const char *rtems_object_get_api_class_name( int the_api, int the_class ) { 10c4cc: 55 push %ebp 10c4cd: 89 e5 mov %esp,%ebp 10c4cf: 83 ec 08 sub $0x8,%esp 10c4d2: 8b 45 08 mov 0x8(%ebp),%eax const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) 10c4d5: 83 f8 01 cmp $0x1,%eax 10c4d8: 74 2a je 10c504 api_assoc = rtems_object_api_internal_assoc; else if ( the_api == OBJECTS_CLASSIC_API ) 10c4da: 83 f8 02 cmp $0x2,%eax 10c4dd: 74 09 je 10c4e8 #ifdef RTEMS_POSIX_API else if ( the_api == OBJECTS_POSIX_API ) api_assoc = rtems_object_api_posix_assoc; #endif else return "BAD API"; 10c4df: b8 db 33 12 00 mov $0x1233db,%eax class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class ); if ( class_assoc ) return class_assoc->name; return "BAD CLASS"; } 10c4e4: c9 leave 10c4e5: c3 ret 10c4e6: 66 90 xchg %ax,%ax const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) api_assoc = rtems_object_api_internal_assoc; else if ( the_api == OBJECTS_CLASSIC_API ) api_assoc = rtems_object_api_classic_assoc; 10c4e8: b8 40 71 12 00 mov $0x127140,%eax else if ( the_api == OBJECTS_POSIX_API ) api_assoc = rtems_object_api_posix_assoc; #endif else return "BAD API"; class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class ); 10c4ed: 83 ec 08 sub $0x8,%esp 10c4f0: ff 75 0c pushl 0xc(%ebp) 10c4f3: 50 push %eax 10c4f4: e8 03 4b 00 00 call 110ffc if ( class_assoc ) 10c4f9: 83 c4 10 add $0x10,%esp 10c4fc: 85 c0 test %eax,%eax 10c4fe: 74 0c je 10c50c return class_assoc->name; 10c500: 8b 00 mov (%eax),%eax return "BAD CLASS"; } 10c502: c9 leave 10c503: c3 ret { const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) api_assoc = rtems_object_api_internal_assoc; 10c504: b8 20 71 12 00 mov $0x127120,%eax 10c509: eb e2 jmp 10c4ed 10c50b: 90 nop else return "BAD API"; class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class ); if ( class_assoc ) return class_assoc->name; return "BAD CLASS"; 10c50c: b8 e3 33 12 00 mov $0x1233e3,%eax } 10c511: c9 leave 10c512: c3 ret =============================================================================== 0010c514 : }; const char *rtems_object_get_api_name( int api ) { 10c514: 55 push %ebp 10c515: 89 e5 mov %esp,%ebp 10c517: 83 ec 10 sub $0x10,%esp const rtems_assoc_t *api_assoc; api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api ); 10c51a: ff 75 08 pushl 0x8(%ebp) 10c51d: 68 c0 71 12 00 push $0x1271c0 10c522: e8 d5 4a 00 00 call 110ffc if ( api_assoc ) 10c527: 83 c4 10 add $0x10,%esp 10c52a: 85 c0 test %eax,%eax 10c52c: 74 06 je 10c534 return api_assoc->name; 10c52e: 8b 00 mov (%eax),%eax return "BAD CLASS"; } 10c530: c9 leave 10c531: c3 ret 10c532: 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"; 10c534: b8 e3 33 12 00 mov $0x1233e3,%eax } 10c539: c9 leave 10c53a: c3 ret =============================================================================== 0010c57c : rtems_status_code rtems_object_get_class_information( int the_api, int the_class, rtems_object_api_class_information *info ) { 10c57c: 55 push %ebp 10c57d: 89 e5 mov %esp,%ebp 10c57f: 57 push %edi 10c580: 56 push %esi 10c581: 53 push %ebx 10c582: 83 ec 0c sub $0xc,%esp 10c585: 8b 5d 10 mov 0x10(%ebp),%ebx int i; /* * Validate parameters and look up information structure. */ if ( !info ) 10c588: 85 db test %ebx,%ebx 10c58a: 74 60 je 10c5ec return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); 10c58c: 83 ec 08 sub $0x8,%esp 10c58f: 0f b7 45 0c movzwl 0xc(%ebp),%eax 10c593: 50 push %eax 10c594: ff 75 08 pushl 0x8(%ebp) 10c597: e8 c8 19 00 00 call 10df64 <_Objects_Get_information> if ( !obj_info ) 10c59c: 83 c4 10 add $0x10,%esp 10c59f: 85 c0 test %eax,%eax 10c5a1: 74 59 je 10c5fc return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 10c5a3: 8b 50 08 mov 0x8(%eax),%edx 10c5a6: 89 13 mov %edx,(%ebx) info->maximum_id = obj_info->maximum_id; 10c5a8: 8b 50 0c mov 0xc(%eax),%edx 10c5ab: 89 53 04 mov %edx,0x4(%ebx) info->auto_extend = obj_info->auto_extend; 10c5ae: 8a 50 12 mov 0x12(%eax),%dl 10c5b1: 88 53 0c mov %dl,0xc(%ebx) info->maximum = obj_info->maximum; 10c5b4: 0f b7 70 10 movzwl 0x10(%eax),%esi 10c5b8: 89 73 08 mov %esi,0x8(%ebx) for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10c5bb: 85 f6 test %esi,%esi 10c5bd: 74 44 je 10c603 <== NEVER TAKEN 10c5bf: 8b 78 1c mov 0x1c(%eax),%edi 10c5c2: b9 01 00 00 00 mov $0x1,%ecx 10c5c7: b8 01 00 00 00 mov $0x1,%eax 10c5cc: 31 d2 xor %edx,%edx 10c5ce: 66 90 xchg %ax,%ax if ( !obj_info->local_table[i] ) unallocated++; 10c5d0: 83 3c 8f 01 cmpl $0x1,(%edi,%ecx,4) 10c5d4: 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++ ) 10c5d7: 40 inc %eax 10c5d8: 89 c1 mov %eax,%ecx 10c5da: 39 c6 cmp %eax,%esi 10c5dc: 73 f2 jae 10c5d0 if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; 10c5de: 89 53 10 mov %edx,0x10(%ebx) return RTEMS_SUCCESSFUL; 10c5e1: 31 c0 xor %eax,%eax } 10c5e3: 8d 65 f4 lea -0xc(%ebp),%esp 10c5e6: 5b pop %ebx 10c5e7: 5e pop %esi 10c5e8: 5f pop %edi 10c5e9: c9 leave 10c5ea: c3 ret 10c5eb: 90 nop /* * Validate parameters and look up information structure. */ if ( !info ) return RTEMS_INVALID_ADDRESS; 10c5ec: b8 09 00 00 00 mov $0x9,%eax unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; } 10c5f1: 8d 65 f4 lea -0xc(%ebp),%esp 10c5f4: 5b pop %ebx 10c5f5: 5e pop %esi 10c5f6: 5f pop %edi 10c5f7: c9 leave 10c5f8: c3 ret 10c5f9: 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; 10c5fc: b8 0a 00 00 00 mov $0xa,%eax 10c601: eb e0 jmp 10c5e3 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++ ) 10c603: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c605: eb d7 jmp 10c5de <== NOT EXECUTED =============================================================================== 0010ba18 : rtems_status_code rtems_object_get_classic_name( rtems_id id, rtems_name *name ) { 10ba18: 55 push %ebp 10ba19: 89 e5 mov %esp,%ebp 10ba1b: 53 push %ebx 10ba1c: 83 ec 14 sub $0x14,%esp 10ba1f: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Name_or_id_lookup_errors status; Objects_Name name_u; if ( !name ) 10ba22: 85 db test %ebx,%ebx 10ba24: 74 26 je 10ba4c return RTEMS_INVALID_ADDRESS; status = _Objects_Id_to_name( id, &name_u ); 10ba26: 83 ec 08 sub $0x8,%esp 10ba29: 8d 45 f4 lea -0xc(%ebp),%eax 10ba2c: 50 push %eax 10ba2d: ff 75 08 pushl 0x8(%ebp) 10ba30: e8 23 1a 00 00 call 10d458 <_Objects_Id_to_name> *name = name_u.name_u32; 10ba35: 8b 55 f4 mov -0xc(%ebp),%edx 10ba38: 89 13 mov %edx,(%ebx) return _Status_Object_name_errors_to_status[ status ]; 10ba3a: 8b 04 85 ec 1d 12 00 mov 0x121dec(,%eax,4),%eax 10ba41: 83 c4 10 add $0x10,%esp } 10ba44: 8b 5d fc mov -0x4(%ebp),%ebx 10ba47: c9 leave 10ba48: c3 ret 10ba49: 8d 76 00 lea 0x0(%esi),%esi { Objects_Name_or_id_lookup_errors status; Objects_Name name_u; if ( !name ) return RTEMS_INVALID_ADDRESS; 10ba4c: 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 ]; } 10ba51: 8b 5d fc mov -0x4(%ebp),%ebx 10ba54: c9 leave 10ba55: c3 ret =============================================================================== 0010c660 : */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) { 10c660: 55 push %ebp 10c661: 89 e5 mov %esp,%ebp 10c663: 57 push %edi 10c664: 56 push %esi 10c665: 53 push %ebx 10c666: 83 ec 1c sub $0x1c,%esp 10c669: 8b 75 08 mov 0x8(%ebp),%esi 10c66c: 8b 7d 0c mov 0xc(%ebp),%edi Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 10c66f: 85 ff test %edi,%edi 10c671: 74 61 je 10c6d4 return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10c673: 85 f6 test %esi,%esi 10c675: 74 35 je 10c6ac information = _Objects_Get_information_id( tmpId ); 10c677: 83 ec 0c sub $0xc,%esp 10c67a: 56 push %esi 10c67b: e8 c4 18 00 00 call 10df44 <_Objects_Get_information_id> 10c680: 89 c3 mov %eax,%ebx if ( !information ) 10c682: 83 c4 10 add $0x10,%esp 10c685: 85 c0 test %eax,%eax 10c687: 74 16 je 10c69f return RTEMS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &location ); 10c689: 50 push %eax 10c68a: 8d 45 e4 lea -0x1c(%ebp),%eax 10c68d: 50 push %eax 10c68e: 56 push %esi 10c68f: 53 push %ebx 10c690: e8 4f 1a 00 00 call 10e0e4 <_Objects_Get> switch ( location ) { 10c695: 83 c4 10 add $0x10,%esp 10c698: 8b 4d e4 mov -0x1c(%ebp),%ecx 10c69b: 85 c9 test %ecx,%ecx 10c69d: 74 19 je 10c6b8 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10c69f: b8 04 00 00 00 mov $0x4,%eax } 10c6a4: 8d 65 f4 lea -0xc(%ebp),%esp 10c6a7: 5b pop %ebx 10c6a8: 5e pop %esi 10c6a9: 5f pop %edi 10c6aa: c9 leave 10c6ab: c3 ret Objects_Id tmpId; if ( !name ) return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10c6ac: a1 f8 97 12 00 mov 0x1297f8,%eax 10c6b1: 8b 70 08 mov 0x8(%eax),%esi 10c6b4: eb c1 jmp 10c677 10c6b6: 66 90 xchg %ax,%ax the_object = _Objects_Get( information, tmpId, &location ); switch ( location ) { case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); 10c6b8: 52 push %edx 10c6b9: 57 push %edi 10c6ba: 50 push %eax 10c6bb: 53 push %ebx 10c6bc: e8 d3 1b 00 00 call 10e294 <_Objects_Set_name> _Thread_Enable_dispatch(); 10c6c1: e8 de 25 00 00 call 10eca4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10c6c6: 83 c4 10 add $0x10,%esp 10c6c9: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c6cb: 8d 65 f4 lea -0xc(%ebp),%esp 10c6ce: 5b pop %ebx 10c6cf: 5e pop %esi 10c6d0: 5f pop %edi 10c6d1: c9 leave 10c6d2: c3 ret 10c6d3: 90 nop Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) return RTEMS_INVALID_ADDRESS; 10c6d4: b8 09 00 00 00 mov $0x9,%eax 10c6d9: eb c9 jmp 10c6a4 =============================================================================== 00115e44 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 115e44: 55 push %ebp 115e45: 89 e5 mov %esp,%ebp 115e47: 57 push %edi 115e48: 56 push %esi 115e49: 53 push %ebx 115e4a: 83 ec 1c sub $0x1c,%esp 115e4d: 8b 5d 08 mov 0x8(%ebp),%ebx 115e50: 8b 75 0c mov 0xc(%ebp),%esi 115e53: 8b 55 10 mov 0x10(%ebp),%edx 115e56: 8b 7d 14 mov 0x14(%ebp),%edi register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 115e59: 85 db test %ebx,%ebx 115e5b: 74 47 je 115ea4 return RTEMS_INVALID_NAME; if ( !starting_address ) 115e5d: 85 f6 test %esi,%esi 115e5f: 74 23 je 115e84 return RTEMS_INVALID_ADDRESS; if ( !id ) 115e61: 8b 45 1c mov 0x1c(%ebp),%eax 115e64: 85 c0 test %eax,%eax 115e66: 74 1c je 115e84 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 115e68: 85 d2 test %edx,%edx 115e6a: 74 28 je 115e94 115e6c: 85 ff test %edi,%edi 115e6e: 74 24 je 115e94 115e70: 39 fa cmp %edi,%edx 115e72: 72 20 jb 115e94 115e74: f7 c7 03 00 00 00 test $0x3,%edi 115e7a: 75 18 jne 115e94 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 115e7c: f7 c6 03 00 00 00 test $0x3,%esi 115e82: 74 30 je 115eb4 return RTEMS_INVALID_ADDRESS; 115e84: b8 09 00 00 00 mov $0x9,%eax ); #endif _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 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; 115e94: b8 08 00 00 00 mov $0x8,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 115e99: 8d 65 f4 lea -0xc(%ebp),%esp 115e9c: 5b pop %ebx 115e9d: 5e pop %esi 115e9e: 5f pop %edi 115e9f: c9 leave 115ea0: c3 ret 115ea1: 8d 76 00 lea 0x0(%esi),%esi ) { register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 115ea4: b8 03 00 00 00 mov $0x3,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 115ea9: 8d 65 f4 lea -0xc(%ebp),%esp 115eac: 5b pop %ebx 115ead: 5e pop %esi 115eae: 5f pop %edi 115eaf: c9 leave 115eb0: c3 ret 115eb1: 8d 76 00 lea 0x0(%esi),%esi 115eb4: a1 ec 08 14 00 mov 0x1408ec,%eax 115eb9: 40 inc %eax 115eba: a3 ec 08 14 00 mov %eax,0x1408ec * 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 ); 115ebf: 83 ec 0c sub $0xc,%esp 115ec2: 68 80 07 14 00 push $0x140780 115ec7: 89 55 e0 mov %edx,-0x20(%ebp) 115eca: e8 05 44 00 00 call 11a2d4 <_Objects_Allocate> 115ecf: 89 45 e4 mov %eax,-0x1c(%ebp) _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 115ed2: 83 c4 10 add $0x10,%esp 115ed5: 85 c0 test %eax,%eax 115ed7: 8b 55 e0 mov -0x20(%ebp),%edx 115eda: 74 58 je 115f34 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 115edc: 8b 45 e4 mov -0x1c(%ebp),%eax 115edf: 89 70 10 mov %esi,0x10(%eax) the_partition->length = length; 115ee2: 89 50 14 mov %edx,0x14(%eax) the_partition->buffer_size = buffer_size; 115ee5: 89 78 18 mov %edi,0x18(%eax) the_partition->attribute_set = attribute_set; 115ee8: 8b 4d 18 mov 0x18(%ebp),%ecx 115eeb: 89 48 1c mov %ecx,0x1c(%eax) the_partition->number_of_used_blocks = 0; 115eee: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) _Chain_Initialize( &the_partition->Memory, starting_address, 115ef5: 57 push %edi 115ef6: 89 d0 mov %edx,%eax 115ef8: 31 d2 xor %edx,%edx 115efa: f7 f7 div %edi 115efc: 50 push %eax 115efd: 56 push %esi 115efe: 8b 45 e4 mov -0x1c(%ebp),%eax 115f01: 83 c0 24 add $0x24,%eax 115f04: 50 push %eax 115f05: e8 36 2f 00 00 call 118e40 <_Chain_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 115f0a: 8b 7d e4 mov -0x1c(%ebp),%edi 115f0d: 8b 47 08 mov 0x8(%edi),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 115f10: 0f b7 f0 movzwl %ax,%esi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 115f13: 8b 15 9c 07 14 00 mov 0x14079c,%edx 115f19: 89 3c b2 mov %edi,(%edx,%esi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 115f1c: 89 5f 0c mov %ebx,0xc(%edi) &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 115f1f: 8b 55 1c mov 0x1c(%ebp),%edx 115f22: 89 02 mov %eax,(%edx) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 115f24: e8 eb 53 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115f29: 83 c4 10 add $0x10,%esp 115f2c: 31 c0 xor %eax,%eax 115f2e: e9 66 ff ff ff jmp 115e99 115f33: 90 nop _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { _Thread_Enable_dispatch(); 115f34: e8 db 53 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 115f39: b8 05 00 00 00 mov $0x5,%eax 115f3e: e9 56 ff ff ff jmp 115e99 =============================================================================== 00115fb0 : rtems_status_code rtems_partition_get_buffer( rtems_id id, void **buffer ) { 115fb0: 55 push %ebp 115fb1: 89 e5 mov %esp,%ebp 115fb3: 56 push %esi 115fb4: 53 push %ebx 115fb5: 83 ec 20 sub $0x20,%esp 115fb8: 8b 5d 0c mov 0xc(%ebp),%ebx register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 115fbb: 85 db test %ebx,%ebx 115fbd: 74 59 je 116018 <== NEVER TAKEN Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) _Objects_Get( &_Partition_Information, id, location ); 115fbf: 52 push %edx return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); 115fc0: 8d 45 f4 lea -0xc(%ebp),%eax 115fc3: 50 push %eax 115fc4: ff 75 08 pushl 0x8(%ebp) 115fc7: 68 80 07 14 00 push $0x140780 115fcc: e8 f3 47 00 00 call 11a7c4 <_Objects_Get> 115fd1: 89 c6 mov %eax,%esi switch ( location ) { 115fd3: 83 c4 10 add $0x10,%esp 115fd6: 8b 45 f4 mov -0xc(%ebp),%eax 115fd9: 85 c0 test %eax,%eax 115fdb: 75 2f jne 11600c <== NEVER TAKEN */ RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer ( Partition_Control *the_partition ) { return _Chain_Get( &the_partition->Memory ); 115fdd: 83 ec 0c sub $0xc,%esp 115fe0: 8d 46 24 lea 0x24(%esi),%eax 115fe3: 50 push %eax 115fe4: e8 33 2e 00 00 call 118e1c <_Chain_Get> case OBJECTS_LOCAL: the_buffer = _Partition_Allocate_buffer( the_partition ); if ( the_buffer ) { 115fe9: 83 c4 10 add $0x10,%esp 115fec: 85 c0 test %eax,%eax 115fee: 74 34 je 116024 the_partition->number_of_used_blocks += 1; 115ff0: ff 46 20 incl 0x20(%esi) _Thread_Enable_dispatch(); 115ff3: 89 45 e4 mov %eax,-0x1c(%ebp) 115ff6: e8 19 53 00 00 call 11b314 <_Thread_Enable_dispatch> *buffer = the_buffer; 115ffb: 8b 45 e4 mov -0x1c(%ebp),%eax 115ffe: 89 03 mov %eax,(%ebx) return RTEMS_SUCCESSFUL; 116000: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116002: 8d 65 f8 lea -0x8(%ebp),%esp 116005: 5b pop %ebx 116006: 5e pop %esi 116007: c9 leave 116008: c3 ret 116009: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 11600c: b8 04 00 00 00 mov $0x4,%eax } 116011: 8d 65 f8 lea -0x8(%ebp),%esp 116014: 5b pop %ebx 116015: 5e pop %esi 116016: c9 leave 116017: c3 ret register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) return RTEMS_INVALID_ADDRESS; 116018: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11601d: 8d 65 f8 lea -0x8(%ebp),%esp 116020: 5b pop %ebx 116021: 5e pop %esi 116022: c9 leave 116023: c3 ret the_partition->number_of_used_blocks += 1; _Thread_Enable_dispatch(); *buffer = the_buffer; return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 116024: e8 eb 52 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_UNSATISFIED; 116029: b8 0d 00 00 00 mov $0xd,%eax 11602e: eb e1 jmp 116011 =============================================================================== 00116054 : rtems_status_code rtems_partition_return_buffer( rtems_id id, void *buffer ) { 116054: 55 push %ebp 116055: 89 e5 mov %esp,%ebp 116057: 56 push %esi 116058: 53 push %ebx 116059: 83 ec 14 sub $0x14,%esp 11605c: 8b 75 0c mov 0xc(%ebp),%esi register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); 11605f: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Partition_Control *) _Objects_Get( &_Partition_Information, id, location ); 116062: 50 push %eax 116063: ff 75 08 pushl 0x8(%ebp) 116066: 68 80 07 14 00 push $0x140780 11606b: e8 54 47 00 00 call 11a7c4 <_Objects_Get> 116070: 89 c3 mov %eax,%ebx switch ( location ) { 116072: 83 c4 10 add $0x10,%esp 116075: 8b 45 f4 mov -0xc(%ebp),%eax 116078: 85 c0 test %eax,%eax 11607a: 74 0c je 116088 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 11607c: b8 04 00 00 00 mov $0x4,%eax } 116081: 8d 65 f8 lea -0x8(%ebp),%esp 116084: 5b pop %ebx 116085: 5e pop %esi 116086: c9 leave 116087: c3 ret ) { void *starting; void *ending; starting = the_partition->starting_address; 116088: 8b 43 10 mov 0x10(%ebx),%eax ending = _Addresses_Add_offset( starting, the_partition->length ); 11608b: 8b 53 14 mov 0x14(%ebx),%edx const void *address, const void *base, const void *limit ) { return (address >= base && address <= limit); 11608e: 39 c6 cmp %eax,%esi 116090: 72 3a jb 1160cc RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( const void *base, uintptr_t offset ) { return (void *)((uintptr_t)base + offset); 116092: 8d 14 10 lea (%eax,%edx,1),%edx const void *address, const void *base, const void *limit ) { return (address >= base && address <= limit); 116095: 39 d6 cmp %edx,%esi 116097: 77 33 ja 1160cc <== NEVER TAKEN RTEMS_INLINE_ROUTINE int32_t _Addresses_Subtract ( const void *left, const void *right ) { return (int32_t) ((const char *) left - (const char *) right); 116099: 89 f2 mov %esi,%edx 11609b: 29 c2 sub %eax,%edx 11609d: 89 d0 mov %edx,%eax offset = (uint32_t) _Addresses_Subtract( the_buffer, the_partition->starting_address ); return ((offset % the_partition->buffer_size) == 0); 11609f: 31 d2 xor %edx,%edx 1160a1: 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 ) && 1160a4: 85 d2 test %edx,%edx 1160a6: 75 24 jne 1160cc RTEMS_INLINE_ROUTINE void _Partition_Free_buffer ( Partition_Control *the_partition, Chain_Node *the_buffer ) { _Chain_Append( &the_partition->Memory, the_buffer ); 1160a8: 83 ec 08 sub $0x8,%esp 1160ab: 56 push %esi 1160ac: 8d 43 24 lea 0x24(%ebx),%eax 1160af: 50 push %eax 1160b0: e8 2b 2d 00 00 call 118de0 <_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; 1160b5: ff 4b 20 decl 0x20(%ebx) _Thread_Enable_dispatch(); 1160b8: e8 57 52 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1160bd: 83 c4 10 add $0x10,%esp 1160c0: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1160c2: 8d 65 f8 lea -0x8(%ebp),%esp 1160c5: 5b pop %ebx 1160c6: 5e pop %esi 1160c7: c9 leave 1160c8: c3 ret 1160c9: 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(); 1160cc: e8 43 52 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_INVALID_ADDRESS; 1160d1: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1160d6: 8d 65 f8 lea -0x8(%ebp),%esp 1160d9: 5b pop %ebx 1160da: 5e pop %esi 1160db: c9 leave 1160dc: c3 ret =============================================================================== 00115478 : void *internal_start, void *external_start, uint32_t length, rtems_id *id ) { 115478: 55 push %ebp 115479: 89 e5 mov %esp,%ebp 11547b: 57 push %edi 11547c: 56 push %esi 11547d: 53 push %ebx 11547e: 83 ec 1c sub $0x1c,%esp 115481: 8b 5d 08 mov 0x8(%ebp),%ebx 115484: 8b 55 0c mov 0xc(%ebp),%edx 115487: 8b 7d 10 mov 0x10(%ebp),%edi 11548a: 8b 75 18 mov 0x18(%ebp),%esi register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name ) ) 11548d: 85 db test %ebx,%ebx 11548f: 74 1b je 1154ac return RTEMS_INVALID_NAME; if ( !id ) 115491: 85 f6 test %esi,%esi 115493: 74 08 je 11549d * id - port id * RTEMS_SUCCESSFUL - if successful * error code - if unsuccessful */ rtems_status_code rtems_port_create( 115495: 89 f8 mov %edi,%eax 115497: 09 d0 or %edx,%eax return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( internal_start ) || 115499: a8 03 test $0x3,%al 11549b: 74 1f je 1154bc !_Addresses_Is_aligned( external_start ) ) return RTEMS_INVALID_ADDRESS; 11549d: b8 09 00 00 00 mov $0x9,%eax ); *id = the_port->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1154a2: 8d 65 f4 lea -0xc(%ebp),%esp 1154a5: 5b pop %ebx 1154a6: 5e pop %esi 1154a7: 5f pop %edi 1154a8: c9 leave 1154a9: c3 ret 1154aa: 66 90 xchg %ax,%ax ) { register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 1154ac: b8 03 00 00 00 mov $0x3,%eax ); *id = the_port->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1154b1: 8d 65 f4 lea -0xc(%ebp),%esp 1154b4: 5b pop %ebx 1154b5: 5e pop %esi 1154b6: 5f pop %edi 1154b7: c9 leave 1154b8: c3 ret 1154b9: 8d 76 00 lea 0x0(%esi),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 1154bc: a1 ec 08 14 00 mov 0x1408ec,%eax 1154c1: 40 inc %eax 1154c2: a3 ec 08 14 00 mov %eax,0x1408ec */ RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Allocate ( void ) { return (Dual_ported_memory_Control *) _Objects_Allocate( &_Dual_ported_memory_Information ); 1154c7: 83 ec 0c sub $0xc,%esp 1154ca: 68 40 07 14 00 push $0x140740 1154cf: 89 55 e4 mov %edx,-0x1c(%ebp) 1154d2: e8 fd 4d 00 00 call 11a2d4 <_Objects_Allocate> _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { 1154d7: 83 c4 10 add $0x10,%esp 1154da: 85 c0 test %eax,%eax 1154dc: 8b 55 e4 mov -0x1c(%ebp),%edx 1154df: 74 33 je 115514 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; 1154e1: 89 50 10 mov %edx,0x10(%eax) the_port->external_base = external_start; 1154e4: 89 78 14 mov %edi,0x14(%eax) the_port->length = length - 1; 1154e7: 8b 55 14 mov 0x14(%ebp),%edx 1154ea: 4a dec %edx 1154eb: 89 50 18 mov %edx,0x18(%eax) Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 1154ee: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 1154f1: 0f b7 fa movzwl %dx,%edi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 1154f4: 8b 0d 5c 07 14 00 mov 0x14075c,%ecx 1154fa: 89 04 b9 mov %eax,(%ecx,%edi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 1154fd: 89 58 0c mov %ebx,0xc(%eax) &_Dual_ported_memory_Information, &the_port->Object, (Objects_Name) name ); *id = the_port->Object.id; 115500: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 115502: e8 0d 5e 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115507: 31 c0 xor %eax,%eax } 115509: 8d 65 f4 lea -0xc(%ebp),%esp 11550c: 5b pop %ebx 11550d: 5e pop %esi 11550e: 5f pop %edi 11550f: c9 leave 115510: c3 ret 115511: 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(); 115514: e8 fb 5d 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 115519: b8 05 00 00 00 mov $0x5,%eax 11551e: eb 82 jmp 1154a2 =============================================================================== 00115520 : */ rtems_status_code rtems_port_delete( rtems_id id ) { 115520: 55 push %ebp 115521: 89 e5 mov %esp,%ebp 115523: 83 ec 2c sub $0x2c,%esp register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); 115526: 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 ); 115529: 50 push %eax 11552a: ff 75 08 pushl 0x8(%ebp) 11552d: 68 40 07 14 00 push $0x140740 115532: e8 8d 52 00 00 call 11a7c4 <_Objects_Get> switch ( location ) { 115537: 83 c4 10 add $0x10,%esp 11553a: 8b 4d f4 mov -0xc(%ebp),%ecx 11553d: 85 c9 test %ecx,%ecx 11553f: 75 2f jne 115570 case OBJECTS_LOCAL: _Objects_Close( &_Dual_ported_memory_Information, &the_port->Object ); 115541: 83 ec 08 sub $0x8,%esp 115544: 50 push %eax 115545: 68 40 07 14 00 push $0x140740 11554a: 89 45 e4 mov %eax,-0x1c(%ebp) 11554d: e8 fe 4d 00 00 call 11a350 <_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 ); 115552: 58 pop %eax 115553: 5a pop %edx 115554: 8b 45 e4 mov -0x1c(%ebp),%eax 115557: 50 push %eax 115558: 68 40 07 14 00 push $0x140740 11555d: e8 e6 50 00 00 call 11a648 <_Objects_Free> _Dual_ported_memory_Free( the_port ); _Thread_Enable_dispatch(); 115562: e8 ad 5d 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115567: 83 c4 10 add $0x10,%esp 11556a: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11556c: c9 leave 11556d: c3 ret 11556e: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115570: b8 04 00 00 00 mov $0x4,%eax } 115575: c9 leave 115576: c3 ret =============================================================================== 00115578 : rtems_status_code rtems_port_external_to_internal( rtems_id id, void *external, void **internal ) { 115578: 55 push %ebp 115579: 89 e5 mov %esp,%ebp 11557b: 56 push %esi 11557c: 53 push %ebx 11557d: 83 ec 10 sub $0x10,%esp 115580: 8b 75 0c mov 0xc(%ebp),%esi 115583: 8b 5d 10 mov 0x10(%ebp),%ebx register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !internal ) 115586: 85 db test %ebx,%ebx 115588: 74 4e je 1155d8 Objects_Id id, Objects_Locations *location ) { return (Dual_ported_memory_Control *) _Objects_Get( &_Dual_ported_memory_Information, id, location ); 11558a: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); 11558b: 8d 45 f4 lea -0xc(%ebp),%eax 11558e: 50 push %eax 11558f: ff 75 08 pushl 0x8(%ebp) 115592: 68 40 07 14 00 push $0x140740 115597: e8 28 52 00 00 call 11a7c4 <_Objects_Get> switch ( location ) { 11559c: 83 c4 10 add $0x10,%esp 11559f: 8b 55 f4 mov -0xc(%ebp),%edx 1155a2: 85 d2 test %edx,%edx 1155a4: 74 0e je 1155b4 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1155a6: b8 04 00 00 00 mov $0x4,%eax } 1155ab: 8d 65 f8 lea -0x8(%ebp),%esp 1155ae: 5b pop %ebx 1155af: 5e pop %esi 1155b0: c9 leave 1155b1: c3 ret 1155b2: 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); 1155b4: 89 f2 mov %esi,%edx 1155b6: 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 ) 1155b9: 3b 50 18 cmp 0x18(%eax),%edx 1155bc: 77 16 ja 1155d4 RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( const void *base, uintptr_t offset ) { return (void *)((uintptr_t)base + offset); 1155be: 03 50 10 add 0x10(%eax),%edx 1155c1: 89 13 mov %edx,(%ebx) *internal = external; else *internal = _Addresses_Add_offset( the_port->internal_base, ending ); _Thread_Enable_dispatch(); 1155c3: e8 4c 5d 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1155c8: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1155ca: 8d 65 f8 lea -0x8(%ebp),%esp 1155cd: 5b pop %ebx 1155ce: 5e pop %esi 1155cf: c9 leave 1155d0: c3 ret 1155d1: 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; 1155d4: 89 33 mov %esi,(%ebx) 1155d6: eb eb jmp 1155c3 register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !internal ) return RTEMS_INVALID_ADDRESS; 1155d8: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1155dd: 8d 65 f8 lea -0x8(%ebp),%esp 1155e0: 5b pop %ebx 1155e1: 5e pop %esi 1155e2: c9 leave 1155e3: c3 ret =============================================================================== 00115608 : rtems_status_code rtems_port_internal_to_external( rtems_id id, void *internal, void **external ) { 115608: 55 push %ebp 115609: 89 e5 mov %esp,%ebp 11560b: 56 push %esi 11560c: 53 push %ebx 11560d: 83 ec 10 sub $0x10,%esp 115610: 8b 75 0c mov 0xc(%ebp),%esi 115613: 8b 5d 10 mov 0x10(%ebp),%ebx register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !external ) 115616: 85 db test %ebx,%ebx 115618: 74 4e je 115668 11561a: 51 push %ecx return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); 11561b: 8d 45 f4 lea -0xc(%ebp),%eax 11561e: 50 push %eax 11561f: ff 75 08 pushl 0x8(%ebp) 115622: 68 40 07 14 00 push $0x140740 115627: e8 98 51 00 00 call 11a7c4 <_Objects_Get> switch ( location ) { 11562c: 83 c4 10 add $0x10,%esp 11562f: 8b 55 f4 mov -0xc(%ebp),%edx 115632: 85 d2 test %edx,%edx 115634: 74 0e je 115644 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115636: b8 04 00 00 00 mov $0x4,%eax } 11563b: 8d 65 f8 lea -0x8(%ebp),%esp 11563e: 5b pop %ebx 11563f: 5e pop %esi 115640: c9 leave 115641: c3 ret 115642: 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); 115644: 89 f2 mov %esi,%edx 115646: 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 ) 115649: 3b 50 18 cmp 0x18(%eax),%edx 11564c: 77 16 ja 115664 RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( const void *base, uintptr_t offset ) { return (void *)((uintptr_t)base + offset); 11564e: 03 50 14 add 0x14(%eax),%edx 115651: 89 13 mov %edx,(%ebx) *external = internal; else *external = _Addresses_Add_offset( the_port->external_base, ending ); _Thread_Enable_dispatch(); 115653: e8 bc 5c 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115658: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11565a: 8d 65 f8 lea -0x8(%ebp),%esp 11565d: 5b pop %ebx 11565e: 5e pop %esi 11565f: c9 leave 115660: c3 ret 115661: 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; 115664: 89 33 mov %esi,(%ebx) 115666: eb eb jmp 115653 register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !external ) return RTEMS_INVALID_ADDRESS; 115668: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11566d: 8d 65 f8 lea -0x8(%ebp),%esp 115670: 5b pop %ebx 115671: 5e pop %esi 115672: c9 leave 115673: c3 ret =============================================================================== 00106da0 : void rtems_print_buffer( const unsigned char *buffer, int length ) { 106da0: 55 push %ebp 106da1: 89 e5 mov %esp,%ebp 106da3: 57 push %edi 106da4: 56 push %esi 106da5: 53 push %ebx 106da6: 81 ec 9c 00 00 00 sub $0x9c,%esp 106dac: 8b 75 0c mov 0xc(%ebp),%esi int i, mod, max; if ( !length ) return; 106daf: 85 f6 test %esi,%esi 106db1: 0f 84 00 01 00 00 je 106eb7 mod = length % 16; 106db7: 89 f0 mov %esi,%eax 106db9: 25 0f 00 00 80 and $0x8000000f,%eax 106dbe: 89 85 60 ff ff ff mov %eax,-0xa0(%ebp) 106dc4: 0f 88 21 02 00 00 js 106feb 106dca: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax 106dd0: 89 85 58 ff ff ff mov %eax,-0xa8(%ebp) max = length - mod; 106dd6: 29 c6 sub %eax,%esi 106dd8: 89 b5 5c ff ff ff mov %esi,-0xa4(%ebp) for ( i=0 ; i 106de6: c7 85 64 ff ff ff 00 movl $0x0,-0x9c(%ebp) 106ded: 00 00 00 106df0: 8d 9d 70 ff ff ff lea -0x90(%ebp),%ebx 106df6: 66 90 xchg %ax,%ax static inline void Dump_Line( const unsigned char *buffer, int length ); void rtems_print_buffer( 106df8: 8b 75 08 mov 0x8(%ebp),%esi 106dfb: 03 b5 64 ff ff ff add -0x9c(%ebp),%esi { int i; char line_buffer[120]; line_buffer[0] = '\0'; 106e01: 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, "|" ); 106e26: 31 c0 xor %eax,%eax 106e28: b9 ff ff ff ff mov $0xffffffff,%ecx 106e2d: 89 df mov %ebx,%edi 106e2f: f2 ae repnz scas %es:(%edi),%al 106e31: f7 d1 not %ecx 106e33: 66 c7 44 0b ff 7c 00 movw $0x7c,-0x1(%ebx,%ecx,1) for( i=0 ; i 106e53: b8 2e 00 00 00 mov $0x2e,%eax 106e58: 50 push %eax 106e59: 53 push %ebx 106e5a: 68 bb fd 11 00 push $0x11fdbb 106e5f: 53 push %ebx 106e60: e8 df ba 00 00 call 112944 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" ); 106e6e: 31 c0 xor %eax,%eax 106e70: b9 ff ff ff ff mov $0xffffffff,%ecx 106e75: 89 df mov %ebx,%edi 106e77: f2 ae repnz scas %es:(%edi),%al 106e79: f7 d1 not %ecx 106e7b: 8d 44 0b ff lea -0x1(%ebx,%ecx,1),%eax 106e7f: 66 c7 00 7c 0a movw $0xa7c,(%eax) 106e84: c6 40 02 00 movb $0x0,0x2(%eax) printk( line_buffer ); 106e88: 83 ec 0c sub $0xc,%esp 106e8b: 53 push %ebx 106e8c: e8 3f 18 00 00 call 1086d0 mod = length % 16; max = length - mod; for ( i=0 ; i Dump_Line( &buffer[ i ], 16 ); if ( mod ) 106ead: 8b 8d 60 ff ff ff mov -0xa0(%ebp),%ecx 106eb3: 85 c9 test %ecx,%ecx 106eb5: 75 08 jne 106ebf Dump_Line( &buffer[ max ], mod ); } 106eb7: 8d 65 f4 lea -0xc(%ebp),%esp 106eba: 5b pop %ebx 106ebb: 5e pop %esi 106ebc: 5f pop %edi 106ebd: c9 leave 106ebe: c3 ret for ( i=0 ; i<== NEVER TAKEN 106edd: 31 ff xor %edi,%edi 106edf: 8d 9d 70 ff ff ff lea -0x90(%ebp),%ebx 106ee5: 8d 76 00 lea 0x0(%esi),%esi sprintf( line_buffer, "%s%02x ", line_buffer, buffer[ i ] ); 106ee8: 0f b6 04 3e movzbl (%esi,%edi,1),%eax 106eec: 50 push %eax 106eed: 53 push %ebx 106eee: 68 b3 fd 11 00 push $0x11fdb3 106ef3: 53 push %ebx 106ef4: e8 4b ba 00 00 call 112944 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++ ) 106f05: 83 bd 60 ff ff ff 0f cmpl $0xf,-0xa0(%ebp) 106f0c: 0f 8f 02 01 00 00 jg 107014 <== NEVER TAKEN 106f12: 8b 95 60 ff ff ff mov -0xa0(%ebp),%edx strcat( line_buffer, " " ); 106f18: 31 c0 xor %eax,%eax 106f1a: 66 90 xchg %ax,%ax 106f1c: b9 ff ff ff ff mov $0xffffffff,%ecx 106f21: 89 df mov %ebx,%edi 106f23: f2 ae repnz scas %es:(%edi),%al 106f25: f7 d1 not %ecx 106f27: c7 44 0b ff 20 20 20 movl $0x202020,-0x1(%ebx,%ecx,1) 106f2e: 00 line_buffer[0] = '\0'; for( i=0 ; i strcat( line_buffer, " " ); strcat( line_buffer, "|" ); 106f35: 31 c0 xor %eax,%eax 106f37: b9 ff ff ff ff mov $0xffffffff,%ecx 106f3c: 89 df mov %ebx,%edi 106f3e: f2 ae repnz scas %es:(%edi),%al 106f40: f7 d1 not %ecx 106f42: 66 c7 44 0b ff 7c 00 movw $0x7c,-0x1(%ebx,%ecx,1) for( i=0 ; i 106f57: 31 ff xor %edi,%edi 106f59: 8d 76 00 lea 0x0(%esi),%esi sprintf( line_buffer, "%s%c", line_buffer, isprint( buffer[ i ] ) ? buffer[ i ] : '.' ); 106f5c: 0f b6 04 3e movzbl (%esi,%edi,1),%eax 106f60: 8b 15 54 43 12 00 mov 0x124354,%edx 106f66: 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 106f73: b8 2e 00 00 00 mov $0x2e,%eax 106f78: 50 push %eax 106f79: 53 push %ebx 106f7a: 68 bb fd 11 00 push $0x11fdbb 106f7f: 53 push %ebx 106f80: e8 bf b9 00 00 call 112944 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++ ) 106f91: 83 bd 60 ff ff ff 0f cmpl $0xf,-0xa0(%ebp) 106f98: 7f 23 jg 106fbd <== NEVER TAKEN strcat( line_buffer, " " ); 106f9a: ba ff ff ff ff mov $0xffffffff,%edx 106f9f: 31 c0 xor %eax,%eax 106fa1: 8b b5 58 ff ff ff mov -0xa8(%ebp),%esi 106fa7: 90 nop 106fa8: 89 d1 mov %edx,%ecx 106faa: 89 df mov %ebx,%edi 106fac: f2 ae repnz scas %es:(%edi),%al 106fae: f7 d1 not %ecx 106fb0: 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" ); 106fbd: 31 c0 xor %eax,%eax 106fbf: b9 ff ff ff ff mov $0xffffffff,%ecx 106fc4: 89 df mov %ebx,%edi 106fc6: f2 ae repnz scas %es:(%edi),%al 106fc8: f7 d1 not %ecx 106fca: 8d 44 0b ff lea -0x1(%ebx,%ecx,1),%eax 106fce: 66 c7 00 7c 0a movw $0xa7c,(%eax) 106fd3: c6 40 02 00 movb $0x0,0x2(%eax) printk( line_buffer ); 106fd7: 83 ec 0c sub $0xc,%esp 106fda: 53 push %ebx 106fdb: e8 f0 16 00 00 call 1086d0 106fe0: 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, "|" ); 107014: 31 c0 xor %eax,%eax 107016: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 107019: 89 df mov %ebx,%edi <== NOT EXECUTED 10701b: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 10701d: f7 d1 not %ecx <== NOT EXECUTED 10701f: 66 c7 44 0b ff 7c 00 movw $0x7c,-0x1(%ebx,%ecx,1) <== NOT EXECUTED 107026: e9 2c ff ff ff jmp 106f57 <== NOT EXECUTED =============================================================================== 001160e0 : */ rtems_status_code rtems_rate_monotonic_cancel( rtems_id id ) { 1160e0: 55 push %ebp 1160e1: 89 e5 mov %esp,%ebp 1160e3: 53 push %ebx 1160e4: 83 ec 18 sub $0x18,%esp Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); 1160e7: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) _Objects_Get( &_Rate_monotonic_Information, id, location ); 1160ea: 50 push %eax 1160eb: ff 75 08 pushl 0x8(%ebp) 1160ee: 68 c0 07 14 00 push $0x1407c0 1160f3: e8 cc 46 00 00 call 11a7c4 <_Objects_Get> 1160f8: 89 c3 mov %eax,%ebx switch ( location ) { 1160fa: 83 c4 10 add $0x10,%esp 1160fd: 8b 45 f4 mov -0xc(%ebp),%eax 116100: 85 c0 test %eax,%eax 116102: 74 0c je 116110 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 116104: b8 04 00 00 00 mov $0x4,%eax } 116109: 8b 5d fc mov -0x4(%ebp),%ebx 11610c: c9 leave 11610d: c3 ret 11610e: 66 90 xchg %ax,%ax the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 116110: a1 78 0b 14 00 mov 0x140b78,%eax 116115: 39 43 40 cmp %eax,0x40(%ebx) 116118: 74 12 je 11612c _Thread_Enable_dispatch(); 11611a: e8 f5 51 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_NOT_OWNER_OF_RESOURCE; 11611f: b8 17 00 00 00 mov $0x17,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116124: 8b 5d fc mov -0x4(%ebp),%ebx 116127: c9 leave 116128: c3 ret 116129: 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 ); 11612c: 83 ec 0c sub $0xc,%esp 11612f: 8d 43 10 lea 0x10(%ebx),%eax 116132: 50 push %eax 116133: e8 3c 62 00 00 call 11c374 <_Watchdog_Remove> the_period->state = RATE_MONOTONIC_INACTIVE; 116138: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) _Thread_Enable_dispatch(); 11613f: e8 d0 51 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 116144: 83 c4 10 add $0x10,%esp 116147: 31 c0 xor %eax,%eax 116149: eb be jmp 116109 =============================================================================== 0010b828 : rtems_status_code rtems_rate_monotonic_create( rtems_name name, rtems_id *id ) { 10b828: 55 push %ebp 10b829: 89 e5 mov %esp,%ebp 10b82b: 57 push %edi 10b82c: 56 push %esi 10b82d: 53 push %ebx 10b82e: 83 ec 1c sub $0x1c,%esp 10b831: 8b 5d 08 mov 0x8(%ebp),%ebx 10b834: 8b 75 0c mov 0xc(%ebp),%esi Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 10b837: 85 db test %ebx,%ebx 10b839: 0f 84 a9 00 00 00 je 10b8e8 return RTEMS_INVALID_NAME; if ( !id ) 10b83f: 85 f6 test %esi,%esi 10b841: 0f 84 c5 00 00 00 je 10b90c rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b847: a1 8c 85 12 00 mov 0x12858c,%eax 10b84c: 40 inc %eax 10b84d: a3 8c 85 12 00 mov %eax,0x12858c * 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 ); 10b852: 83 ec 0c sub $0xc,%esp 10b855: 68 a0 84 12 00 push $0x1284a0 10b85a: e8 9d 1d 00 00 call 10d5fc <_Objects_Allocate> 10b85f: 89 c2 mov %eax,%edx _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { 10b861: 83 c4 10 add $0x10,%esp 10b864: 85 c0 test %eax,%eax 10b866: 0f 84 8c 00 00 00 je 10b8f8 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 10b86c: a1 18 88 12 00 mov 0x128818,%eax 10b871: 89 42 40 mov %eax,0x40(%edx) the_period->state = RATE_MONOTONIC_INACTIVE; 10b874: 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; 10b87b: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) the_watchdog->routine = routine; 10b882: c7 42 2c 00 00 00 00 movl $0x0,0x2c(%edx) the_watchdog->id = id; 10b889: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) the_watchdog->user_data = user_data; 10b890: 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 ); 10b897: 8d 42 54 lea 0x54(%edx),%eax 10b89a: 89 45 e4 mov %eax,-0x1c(%ebp) 10b89d: b9 38 00 00 00 mov $0x38,%ecx 10b8a2: 31 c0 xor %eax,%eax 10b8a4: 8b 7d e4 mov -0x1c(%ebp),%edi 10b8a7: f3 aa rep stos %al,%es:(%edi) 10b8a9: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx) 10b8b0: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx) 10b8b7: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx) 10b8be: 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 ), 10b8c5: 8b 42 08 mov 0x8(%edx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10b8c8: 0f b7 f8 movzwl %ax,%edi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10b8cb: 8b 0d bc 84 12 00 mov 0x1284bc,%ecx 10b8d1: 89 14 b9 mov %edx,(%ecx,%edi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10b8d4: 89 5a 0c mov %ebx,0xc(%edx) &_Rate_monotonic_Information, &the_period->Object, (Objects_Name) name ); *id = the_period->Object.id; 10b8d7: 89 06 mov %eax,(%esi) _Thread_Enable_dispatch(); 10b8d9: e8 f2 2d 00 00 call 10e6d0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b8de: 31 c0 xor %eax,%eax } 10b8e0: 8d 65 f4 lea -0xc(%ebp),%esp 10b8e3: 5b pop %ebx 10b8e4: 5e pop %esi 10b8e5: 5f pop %edi 10b8e6: c9 leave 10b8e7: c3 ret ) { Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 10b8e8: b8 03 00 00 00 mov $0x3,%eax ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b8ed: 8d 65 f4 lea -0xc(%ebp),%esp 10b8f0: 5b pop %ebx 10b8f1: 5e pop %esi 10b8f2: 5f pop %edi 10b8f3: c9 leave 10b8f4: c3 ret 10b8f5: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { _Thread_Enable_dispatch(); 10b8f8: e8 d3 2d 00 00 call 10e6d0 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 10b8fd: b8 05 00 00 00 mov $0x5,%eax ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b902: 8d 65 f4 lea -0xc(%ebp),%esp 10b905: 5b pop %ebx 10b906: 5e pop %esi 10b907: 5f pop %edi 10b908: c9 leave 10b909: c3 ret 10b90a: 66 90 xchg %ax,%ax if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 10b90c: b8 09 00 00 00 mov $0x9,%eax ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b911: 8d 65 f4 lea -0xc(%ebp),%esp 10b914: 5b pop %ebx 10b915: 5e pop %esi 10b916: 5f pop %edi 10b917: c9 leave 10b918: c3 ret =============================================================================== 00111648 : rtems_status_code rtems_rate_monotonic_get_status( rtems_id id, rtems_rate_monotonic_period_status *status ) { 111648: 55 push %ebp 111649: 89 e5 mov %esp,%ebp 11164b: 53 push %ebx 11164c: 83 ec 24 sub $0x24,%esp 11164f: 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 ) 111652: 85 db test %ebx,%ebx 111654: 0f 84 92 00 00 00 je 1116ec 11165a: 50 push %eax return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); 11165b: 8d 45 f4 lea -0xc(%ebp),%eax 11165e: 50 push %eax 11165f: ff 75 08 pushl 0x8(%ebp) 111662: 68 a0 84 12 00 push $0x1284a0 111667: e8 14 c5 ff ff call 10db80 <_Objects_Get> switch ( location ) { 11166c: 83 c4 10 add $0x10,%esp 11166f: 8b 4d f4 mov -0xc(%ebp),%ecx 111672: 85 c9 test %ecx,%ecx 111674: 74 0a je 111680 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 111676: b8 04 00 00 00 mov $0x4,%eax } 11167b: 8b 5d fc mov -0x4(%ebp),%ebx 11167e: c9 leave 11167f: c3 ret the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: status->owner = the_period->owner->Object.id; 111680: 8b 50 40 mov 0x40(%eax),%edx 111683: 8b 52 08 mov 0x8(%edx),%edx 111686: 89 13 mov %edx,(%ebx) status->state = the_period->state; 111688: 8b 50 38 mov 0x38(%eax),%edx 11168b: 89 53 04 mov %edx,0x4(%ebx) /* * If the period is inactive, there is no information. */ if ( status->state == RATE_MONOTONIC_INACTIVE ) { 11168e: 85 d2 test %edx,%edx 111690: 75 2a jne 1116bc #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timespec_Set_to_zero( &status->since_last_period ); 111692: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 111699: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) _Timespec_Set_to_zero( &status->executed_since_last_period ); 1116a0: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) 1116a7: 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(); 1116ae: e8 1d d0 ff ff call 10e6d0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1116b3: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1116b5: 8b 5d fc mov -0x4(%ebp),%ebx 1116b8: c9 leave 1116b9: c3 ret 1116ba: 66 90 xchg %ax,%ax } else { /* * Grab the current status. */ valid_status = 1116bc: 52 push %edx _Rate_monotonic_Get_status( 1116bd: 8d 55 ec lea -0x14(%ebp),%edx } else { /* * Grab the current status. */ valid_status = 1116c0: 52 push %edx _Rate_monotonic_Get_status( 1116c1: 8d 55 e4 lea -0x1c(%ebp),%edx } else { /* * Grab the current status. */ valid_status = 1116c4: 52 push %edx 1116c5: 50 push %eax 1116c6: e8 75 a2 ff ff call 10b940 <_Rate_monotonic_Get_status> _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); if (!valid_status) { 1116cb: 83 c4 10 add $0x10,%esp 1116ce: 84 c0 test %al,%al 1116d0: 74 26 je 1116f8 _Thread_Enable_dispatch(); return RTEMS_NOT_DEFINED; } #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_To_timespec( 1116d2: 8b 45 e4 mov -0x1c(%ebp),%eax 1116d5: 8b 55 e8 mov -0x18(%ebp),%edx 1116d8: 89 43 08 mov %eax,0x8(%ebx) 1116db: 89 53 0c mov %edx,0xc(%ebx) &since_last_period, &status->since_last_period ); _Timestamp_To_timespec( 1116de: 8b 45 ec mov -0x14(%ebp),%eax 1116e1: 8b 55 f0 mov -0x10(%ebp),%edx 1116e4: 89 43 10 mov %eax,0x10(%ebx) 1116e7: 89 53 14 mov %edx,0x14(%ebx) 1116ea: eb c2 jmp 1116ae Rate_monotonic_Period_time_t since_last_period; Rate_monotonic_Control *the_period; bool valid_status; if ( !status ) return RTEMS_INVALID_ADDRESS; 1116ec: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1116f1: 8b 5d fc mov -0x4(%ebp),%ebx 1116f4: c9 leave 1116f5: c3 ret 1116f6: 66 90 xchg %ax,%ax valid_status = _Rate_monotonic_Get_status( the_period, &since_last_period, &executed ); if (!valid_status) { _Thread_Enable_dispatch(); 1116f8: e8 d3 cf ff ff call 10e6d0 <_Thread_Enable_dispatch> return RTEMS_NOT_DEFINED; 1116fd: b8 0b 00 00 00 mov $0xb,%eax 111702: e9 74 ff ff ff jmp 11167b =============================================================================== 0010bb3c : rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) { 10bb3c: 55 push %ebp 10bb3d: 89 e5 mov %esp,%ebp 10bb3f: 57 push %edi 10bb40: 56 push %esi 10bb41: 53 push %ebx 10bb42: 83 ec 30 sub $0x30,%esp 10bb45: 8b 5d 08 mov 0x8(%ebp),%ebx 10bb48: 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 ); 10bb4b: 8d 45 e4 lea -0x1c(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) _Objects_Get( &_Rate_monotonic_Information, id, location ); 10bb4e: 50 push %eax 10bb4f: 53 push %ebx 10bb50: 68 a0 84 12 00 push $0x1284a0 10bb55: e8 26 20 00 00 call 10db80 <_Objects_Get> switch ( location ) { 10bb5a: 83 c4 10 add $0x10,%esp 10bb5d: 8b 55 e4 mov -0x1c(%ebp),%edx 10bb60: 85 d2 test %edx,%edx 10bb62: 74 10 je 10bb74 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10bb64: b8 04 00 00 00 mov $0x4,%eax } 10bb69: 8d 65 f4 lea -0xc(%ebp),%esp 10bb6c: 5b pop %ebx 10bb6d: 5e pop %esi 10bb6e: 5f pop %edi 10bb6f: c9 leave 10bb70: c3 ret 10bb71: 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 ) ) { 10bb74: 8b 15 18 88 12 00 mov 0x128818,%edx 10bb7a: 39 50 40 cmp %edx,0x40(%eax) 10bb7d: 74 15 je 10bb94 _Thread_Enable_dispatch(); 10bb7f: e8 4c 2b 00 00 call 10e6d0 <_Thread_Enable_dispatch> return RTEMS_NOT_OWNER_OF_RESOURCE; 10bb84: b8 17 00 00 00 mov $0x17,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bb89: 8d 65 f4 lea -0xc(%ebp),%esp 10bb8c: 5b pop %ebx 10bb8d: 5e pop %esi 10bb8e: 5f pop %edi 10bb8f: c9 leave 10bb90: c3 ret 10bb91: 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 ) { 10bb94: 85 f6 test %esi,%esi 10bb96: 75 1c jne 10bbb4 switch ( the_period->state ) { 10bb98: 8b 40 38 mov 0x38(%eax),%eax 10bb9b: 83 f8 04 cmp $0x4,%eax 10bb9e: 77 6c ja 10bc0c <== NEVER TAKEN 10bba0: 8b 04 85 7c 22 12 00 mov 0x12227c(,%eax,4),%eax case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 10bba7: 89 45 d4 mov %eax,-0x2c(%ebp) 10bbaa: e8 21 2b 00 00 call 10e6d0 <_Thread_Enable_dispatch> return( return_value ); 10bbaf: 8b 45 d4 mov -0x2c(%ebp),%eax 10bbb2: eb b5 jmp 10bb69 } _ISR_Disable( level ); 10bbb4: 9c pushf 10bbb5: fa cli 10bbb6: 5f pop %edi if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 10bbb7: 8b 50 38 mov 0x38(%eax),%edx 10bbba: 85 d2 test %edx,%edx 10bbbc: 74 52 je 10bc10 _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { 10bbbe: 83 fa 02 cmp $0x2,%edx 10bbc1: 0f 84 9e 00 00 00 je 10bc65 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_EXPIRED ) { 10bbc7: 83 fa 04 cmp $0x4,%edx 10bbca: 75 98 jne 10bb64 <== NEVER TAKEN /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 10bbcc: 83 ec 0c sub $0xc,%esp 10bbcf: 50 push %eax 10bbd0: 89 45 d4 mov %eax,-0x2c(%ebp) 10bbd3: e8 74 fe ff ff call 10ba4c <_Rate_monotonic_Update_statistics> _ISR_Enable( level ); 10bbd8: 57 push %edi 10bbd9: 9d popf the_period->state = RATE_MONOTONIC_ACTIVE; 10bbda: 8b 45 d4 mov -0x2c(%ebp),%eax 10bbdd: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax) the_period->next_length = length; 10bbe4: 89 70 3c mov %esi,0x3c(%eax) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10bbe7: 89 70 1c mov %esi,0x1c(%eax) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10bbea: 5b pop %ebx 10bbeb: 5e pop %esi _Watchdog_Insert_ticks( &the_period->Timer, length ); 10bbec: 83 c0 10 add $0x10,%eax 10bbef: 50 push %eax 10bbf0: 68 60 86 12 00 push $0x128660 10bbf5: e8 a2 38 00 00 call 10f49c <_Watchdog_Insert> _Thread_Enable_dispatch(); 10bbfa: e8 d1 2a 00 00 call 10e6d0 <_Thread_Enable_dispatch> return RTEMS_TIMEOUT; 10bbff: 83 c4 10 add $0x10,%esp 10bc02: b8 06 00 00 00 mov $0x6,%eax 10bc07: e9 5d ff ff ff jmp 10bb69 _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { switch ( the_period->state ) { 10bc0c: 31 c0 xor %eax,%eax 10bc0e: eb 97 jmp 10bba7 <== NOT EXECUTED return( return_value ); } _ISR_Disable( level ); if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { _ISR_Enable( level ); 10bc10: 57 push %edi 10bc11: 9d popf /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 10bc12: 83 ec 0c sub $0xc,%esp 10bc15: 50 push %eax 10bc16: 89 45 d4 mov %eax,-0x2c(%ebp) 10bc19: e8 ba fd ff ff call 10b9d8 <_Rate_monotonic_Initiate_statistics> the_period->state = RATE_MONOTONIC_ACTIVE; 10bc1e: 8b 45 d4 mov -0x2c(%ebp),%eax 10bc21: 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; 10bc28: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_watchdog->routine = routine; 10bc2f: c7 40 2c 94 bf 10 00 movl $0x10bf94,0x2c(%eax) the_watchdog->id = id; 10bc36: 89 58 30 mov %ebx,0x30(%eax) the_watchdog->user_data = user_data; 10bc39: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 10bc40: 89 70 3c mov %esi,0x3c(%eax) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10bc43: 89 70 1c mov %esi,0x1c(%eax) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10bc46: 5e pop %esi 10bc47: 5f pop %edi _Watchdog_Insert_ticks( &the_period->Timer, length ); 10bc48: 83 c0 10 add $0x10,%eax 10bc4b: 50 push %eax 10bc4c: 68 60 86 12 00 push $0x128660 10bc51: e8 46 38 00 00 call 10f49c <_Watchdog_Insert> _Thread_Enable_dispatch(); 10bc56: e8 75 2a 00 00 call 10e6d0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10bc5b: 83 c4 10 add $0x10,%esp 10bc5e: 31 c0 xor %eax,%eax 10bc60: e9 04 ff ff ff jmp 10bb69 if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 10bc65: 83 ec 0c sub $0xc,%esp 10bc68: 50 push %eax 10bc69: 89 45 d4 mov %eax,-0x2c(%ebp) 10bc6c: e8 db fd ff ff call 10ba4c <_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; 10bc71: 8b 45 d4 mov -0x2c(%ebp),%eax 10bc74: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax) the_period->next_length = length; 10bc7b: 89 70 3c mov %esi,0x3c(%eax) _ISR_Enable( level ); 10bc7e: 57 push %edi 10bc7f: 9d popf _Thread_Executing->Wait.id = the_period->Object.id; 10bc80: 8b 15 18 88 12 00 mov 0x128818,%edx 10bc86: 8b 48 08 mov 0x8(%eax),%ecx 10bc89: 89 4a 20 mov %ecx,0x20(%edx) _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10bc8c: 59 pop %ecx 10bc8d: 5b pop %ebx 10bc8e: 68 00 40 00 00 push $0x4000 10bc93: 52 push %edx 10bc94: 89 45 d4 mov %eax,-0x2c(%ebp) 10bc97: e8 28 32 00 00 call 10eec4 <_Thread_Set_state> /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 10bc9c: 9c pushf 10bc9d: fa cli 10bc9e: 59 pop %ecx local_state = the_period->state; 10bc9f: 8b 45 d4 mov -0x2c(%ebp),%eax 10bca2: 8b 50 38 mov 0x38(%eax),%edx the_period->state = RATE_MONOTONIC_ACTIVE; 10bca5: c7 40 38 02 00 00 00 movl $0x2,0x38(%eax) _ISR_Enable( level ); 10bcac: 51 push %ecx 10bcad: 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 ) 10bcae: 83 c4 10 add $0x10,%esp 10bcb1: 83 fa 03 cmp $0x3,%edx 10bcb4: 74 0c je 10bcc2 _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); _Thread_Enable_dispatch(); 10bcb6: e8 15 2a 00 00 call 10e6d0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10bcbb: 31 c0 xor %eax,%eax 10bcbd: e9 a7 fe ff ff jmp 10bb69 /* * 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 ); 10bcc2: 57 push %edi 10bcc3: 57 push %edi 10bcc4: 68 00 40 00 00 push $0x4000 10bcc9: ff 35 18 88 12 00 pushl 0x128818 10bccf: e8 98 26 00 00 call 10e36c <_Thread_Clear_state> 10bcd4: 83 c4 10 add $0x10,%esp 10bcd7: eb dd jmp 10bcb6 =============================================================================== 0010bcdc : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 10bcdc: 55 push %ebp 10bcdd: 89 e5 mov %esp,%ebp 10bcdf: 57 push %edi 10bce0: 56 push %esi 10bce1: 53 push %ebx 10bce2: 81 ec 8c 00 00 00 sub $0x8c,%esp 10bce8: 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 ) 10bceb: 8b 7d 0c mov 0xc(%ebp),%edi 10bcee: 85 ff test %edi,%edi 10bcf0: 0f 84 be 00 00 00 je 10bdb4 <== NEVER TAKEN return; (*print)( context, "Period information by period\n" ); 10bcf6: 83 ec 08 sub $0x8,%esp 10bcf9: 68 90 22 12 00 push $0x122290 10bcfe: 56 push %esi 10bcff: ff 55 0c call *0xc(%ebp) #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( context, "--- CPU times are in seconds ---\n" ); 10bd02: 59 pop %ecx 10bd03: 5b pop %ebx 10bd04: 68 c8 22 12 00 push $0x1222c8 10bd09: 56 push %esi 10bd0a: ff 55 0c call *0xc(%ebp) (*print)( context, "--- Wall times are in seconds ---\n" ); 10bd0d: 58 pop %eax 10bd0e: 5a pop %edx 10bd0f: 68 ec 22 12 00 push $0x1222ec 10bd14: 56 push %esi 10bd15: ff 55 0c call *0xc(%ebp) Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 10bd18: 5b pop %ebx 10bd19: 5f pop %edi 10bd1a: 68 10 23 12 00 push $0x122310 10bd1f: 56 push %esi 10bd20: ff 55 0c call *0xc(%ebp) #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ " " #endif " WALL TIME\n" ); (*print)( context, " " 10bd23: 5a pop %edx 10bd24: 59 pop %ecx 10bd25: 68 5c 23 12 00 push $0x12235c 10bd2a: 56 push %esi 10bd2b: 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 ; 10bd2e: 8b 1d a8 84 12 00 mov 0x1284a8,%ebx 10bd34: 83 c4 10 add $0x10,%esp 10bd37: 3b 1d ac 84 12 00 cmp 0x1284ac,%ebx 10bd3d: 77 75 ja 10bdb4 <== NEVER TAKEN 10bd3f: 8d 7d 88 lea -0x78(%ebp),%edi 10bd42: eb 09 jmp 10bd4d id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 10bd44: 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 ; 10bd45: 39 1d ac 84 12 00 cmp %ebx,0x1284ac 10bd4b: 72 67 jb 10bdb4 id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 10bd4d: 83 ec 08 sub $0x8,%esp 10bd50: 57 push %edi 10bd51: 53 push %ebx 10bd52: e8 45 58 00 00 call 11159c if ( status != RTEMS_SUCCESSFUL ) 10bd57: 83 c4 10 add $0x10,%esp 10bd5a: 85 c0 test %eax,%eax 10bd5c: 75 e6 jne 10bd44 #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 ); 10bd5e: 83 ec 08 sub $0x8,%esp 10bd61: 8d 45 c0 lea -0x40(%ebp),%eax 10bd64: 50 push %eax 10bd65: 53 push %ebx 10bd66: e8 dd 58 00 00 call 111648 #endif rtems_object_get_name( the_status.owner, sizeof(name), name ); 10bd6b: 83 c4 0c add $0xc,%esp 10bd6e: 8d 55 e3 lea -0x1d(%ebp),%edx 10bd71: 52 push %edx 10bd72: 6a 05 push $0x5 10bd74: ff 75 c0 pushl -0x40(%ebp) 10bd77: e8 b4 02 00 00 call 10c030 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 10bd7c: 59 pop %ecx 10bd7d: 58 pop %eax 10bd7e: ff 75 8c pushl -0x74(%ebp) 10bd81: ff 75 88 pushl -0x78(%ebp) 10bd84: 8d 45 e3 lea -0x1d(%ebp),%eax 10bd87: 50 push %eax 10bd88: 53 push %ebx 10bd89: 68 ae 22 12 00 push $0x1222ae 10bd8e: 56 push %esi 10bd8f: ff 55 0c call *0xc(%ebp) ); /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 10bd92: 8b 45 88 mov -0x78(%ebp),%eax 10bd95: 83 c4 20 add $0x20,%esp 10bd98: 85 c0 test %eax,%eax 10bd9a: 75 20 jne 10bdbc (*print)( context, "\n" ); 10bd9c: 83 ec 08 sub $0x8,%esp 10bd9f: 68 b1 04 12 00 push $0x1204b1 10bda4: 56 push %esi 10bda5: ff 55 0c call *0xc(%ebp) continue; 10bda8: 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++ ) { 10bdab: 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 ; 10bdac: 39 1d ac 84 12 00 cmp %ebx,0x1284ac 10bdb2: 73 99 jae 10bd4d <== ALWAYS TAKEN the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 10bdb4: 8d 65 f4 lea -0xc(%ebp),%esp 10bdb7: 5b pop %ebx 10bdb8: 5e pop %esi 10bdb9: 5f pop %edi 10bdba: c9 leave 10bdbb: 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 ); 10bdbc: 52 push %edx 10bdbd: 8d 55 d8 lea -0x28(%ebp),%edx 10bdc0: 52 push %edx 10bdc1: 50 push %eax 10bdc2: 8d 45 a0 lea -0x60(%ebp),%eax 10bdc5: 50 push %eax 10bdc6: e8 31 33 00 00 call 10f0fc <_Timespec_Divide_by_integer> (*print)( context, 10bdcb: b9 d3 4d 62 10 mov $0x10624dd3,%ecx 10bdd0: 8b 45 dc mov -0x24(%ebp),%eax 10bdd3: f7 e9 imul %ecx 10bdd5: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10bddb: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10bde1: c1 f8 06 sar $0x6,%eax 10bde4: 8b 55 dc mov -0x24(%ebp),%edx 10bde7: c1 fa 1f sar $0x1f,%edx 10bdea: 29 d0 sub %edx,%eax 10bdec: 50 push %eax 10bded: ff 75 d8 pushl -0x28(%ebp) 10bdf0: 8b 45 9c mov -0x64(%ebp),%eax 10bdf3: f7 e9 imul %ecx 10bdf5: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10bdfb: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10be01: c1 f8 06 sar $0x6,%eax 10be04: 8b 55 9c mov -0x64(%ebp),%edx 10be07: c1 fa 1f sar $0x1f,%edx 10be0a: 29 d0 sub %edx,%eax 10be0c: 50 push %eax 10be0d: ff 75 98 pushl -0x68(%ebp) 10be10: 8b 45 94 mov -0x6c(%ebp),%eax 10be13: f7 e9 imul %ecx 10be15: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) 10be1b: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10be21: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10be27: c1 f8 06 sar $0x6,%eax 10be2a: 8b 55 94 mov -0x6c(%ebp),%edx 10be2d: c1 fa 1f sar $0x1f,%edx 10be30: 29 d0 sub %edx,%eax 10be32: 50 push %eax 10be33: ff 75 90 pushl -0x70(%ebp) 10be36: 68 a8 23 12 00 push $0x1223a8 10be3b: 56 push %esi 10be3c: 89 4d 84 mov %ecx,-0x7c(%ebp) 10be3f: 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); 10be42: 83 c4 2c add $0x2c,%esp 10be45: 8d 55 d8 lea -0x28(%ebp),%edx 10be48: 52 push %edx 10be49: ff 75 88 pushl -0x78(%ebp) 10be4c: 8d 45 b8 lea -0x48(%ebp),%eax 10be4f: 50 push %eax 10be50: e8 a7 32 00 00 call 10f0fc <_Timespec_Divide_by_integer> (*print)( context, 10be55: 8b 4d 84 mov -0x7c(%ebp),%ecx 10be58: 8b 45 dc mov -0x24(%ebp),%eax 10be5b: f7 e9 imul %ecx 10be5d: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10be63: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10be69: c1 f8 06 sar $0x6,%eax 10be6c: 8b 55 dc mov -0x24(%ebp),%edx 10be6f: c1 fa 1f sar $0x1f,%edx 10be72: 29 d0 sub %edx,%eax 10be74: 50 push %eax 10be75: ff 75 d8 pushl -0x28(%ebp) 10be78: 8b 45 b4 mov -0x4c(%ebp),%eax 10be7b: f7 e9 imul %ecx 10be7d: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10be83: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10be89: c1 f8 06 sar $0x6,%eax 10be8c: 8b 55 b4 mov -0x4c(%ebp),%edx 10be8f: c1 fa 1f sar $0x1f,%edx 10be92: 29 d0 sub %edx,%eax 10be94: 50 push %eax 10be95: ff 75 b0 pushl -0x50(%ebp) 10be98: 8b 45 ac mov -0x54(%ebp),%eax 10be9b: f7 e9 imul %ecx 10be9d: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) 10bea3: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10bea9: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10beaf: c1 f8 06 sar $0x6,%eax 10beb2: 8b 55 ac mov -0x54(%ebp),%edx 10beb5: c1 fa 1f sar $0x1f,%edx 10beb8: 29 d0 sub %edx,%eax 10beba: 50 push %eax 10bebb: ff 75 a8 pushl -0x58(%ebp) 10bebe: 68 c8 23 12 00 push $0x1223c8 10bec3: 56 push %esi 10bec4: ff 55 0c call *0xc(%ebp) 10bec7: 83 c4 30 add $0x30,%esp 10beca: e9 75 fe ff ff jmp 10bd44 =============================================================================== 0010bee8 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 10bee8: 55 push %ebp 10bee9: 89 e5 mov %esp,%ebp 10beeb: 53 push %ebx 10beec: 83 ec 04 sub $0x4,%esp 10beef: a1 8c 85 12 00 mov 0x12858c,%eax 10bef4: 40 inc %eax 10bef5: a3 8c 85 12 00 mov %eax,0x12858c /* * 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 ; 10befa: 8b 1d a8 84 12 00 mov 0x1284a8,%ebx 10bf00: 3b 1d ac 84 12 00 cmp 0x1284ac,%ebx 10bf06: 77 15 ja 10bf1d <== NEVER TAKEN id <= _Rate_monotonic_Information.maximum_id ; id++ ) { (void) rtems_rate_monotonic_reset_statistics( id ); 10bf08: 83 ec 0c sub $0xc,%esp 10bf0b: 53 push %ebx 10bf0c: e8 17 00 00 00 call 10bf28 * 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++ ) { 10bf11: 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 ; 10bf12: 83 c4 10 add $0x10,%esp 10bf15: 39 1d ac 84 12 00 cmp %ebx,0x1284ac 10bf1b: 73 eb jae 10bf08 /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); } 10bf1d: 8b 5d fc mov -0x4(%ebp),%ebx 10bf20: c9 leave } /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); 10bf21: e9 aa 27 00 00 jmp 10e6d0 <_Thread_Enable_dispatch> =============================================================================== 0010bf28 : */ rtems_status_code rtems_rate_monotonic_reset_statistics( rtems_id id ) { 10bf28: 55 push %ebp 10bf29: 89 e5 mov %esp,%ebp 10bf2b: 57 push %edi 10bf2c: 53 push %ebx 10bf2d: 83 ec 14 sub $0x14,%esp Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); 10bf30: 8d 45 f4 lea -0xc(%ebp),%eax 10bf33: 50 push %eax 10bf34: ff 75 08 pushl 0x8(%ebp) 10bf37: 68 a0 84 12 00 push $0x1284a0 10bf3c: e8 3f 1c 00 00 call 10db80 <_Objects_Get> 10bf41: 89 c2 mov %eax,%edx switch ( location ) { 10bf43: 83 c4 10 add $0x10,%esp 10bf46: 8b 45 f4 mov -0xc(%ebp),%eax 10bf49: 85 c0 test %eax,%eax 10bf4b: 75 3b jne 10bf88 case OBJECTS_LOCAL: _Rate_monotonic_Reset_statistics( the_period ); 10bf4d: 8d 5a 54 lea 0x54(%edx),%ebx 10bf50: b9 38 00 00 00 mov $0x38,%ecx 10bf55: 31 c0 xor %eax,%eax 10bf57: 89 df mov %ebx,%edi 10bf59: f3 aa rep stos %al,%es:(%edi) 10bf5b: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx) 10bf62: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx) 10bf69: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx) 10bf70: c7 42 78 ff ff ff 7f movl $0x7fffffff,0x78(%edx) _Thread_Enable_dispatch(); 10bf77: e8 54 27 00 00 call 10e6d0 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10bf7c: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bf7e: 8d 65 f8 lea -0x8(%ebp),%esp 10bf81: 5b pop %ebx 10bf82: 5f pop %edi 10bf83: c9 leave 10bf84: c3 ret 10bf85: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10bf88: b8 04 00 00 00 mov $0x4,%eax } 10bf8d: 8d 65 f8 lea -0x8(%ebp),%esp 10bf90: 5b pop %ebx 10bf91: 5f pop %edi 10bf92: c9 leave 10bf93: c3 ret =============================================================================== 00116874 : uintptr_t length, uintptr_t page_size, rtems_attribute attribute_set, rtems_id *id ) { 116874: 55 push %ebp 116875: 89 e5 mov %esp,%ebp 116877: 57 push %edi 116878: 56 push %esi 116879: 53 push %ebx 11687a: 83 ec 1c sub $0x1c,%esp 11687d: 8b 7d 08 mov 0x8(%ebp),%edi 116880: 8b 75 0c mov 0xc(%ebp),%esi rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 116883: 85 ff test %edi,%edi 116885: 0f 84 c1 00 00 00 je 11694c return RTEMS_INVALID_NAME; if ( !starting_address ) 11688b: 85 f6 test %esi,%esi 11688d: 0f 84 e1 00 00 00 je 116974 return RTEMS_INVALID_ADDRESS; if ( !id ) 116893: 8b 45 1c mov 0x1c(%ebp),%eax 116896: 85 c0 test %eax,%eax 116898: 0f 84 d6 00 00 00 je 116974 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 11689e: 83 ec 0c sub $0xc,%esp 1168a1: ff 35 a0 09 14 00 pushl 0x1409a0 1168a7: e8 bc 24 00 00 call 118d68 <_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 ); 1168ac: c7 04 24 00 08 14 00 movl $0x140800,(%esp) 1168b3: e8 1c 3a 00 00 call 11a2d4 <_Objects_Allocate> 1168b8: 89 c3 mov %eax,%ebx the_region = _Region_Allocate(); if ( !the_region ) 1168ba: 83 c4 10 add $0x10,%esp 1168bd: 85 c0 test %eax,%eax 1168bf: 0f 84 bf 00 00 00 je 116984 return_status = RTEMS_TOO_MANY; else { the_region->maximum_segment_size = _Heap_Initialize( 1168c5: ff 75 14 pushl 0x14(%ebp) 1168c8: ff 75 10 pushl 0x10(%ebp) 1168cb: 56 push %esi 1168cc: 8d 40 68 lea 0x68(%eax),%eax 1168cf: 50 push %eax 1168d0: e8 0b 36 00 00 call 119ee0 <_Heap_Initialize> 1168d5: 89 43 5c mov %eax,0x5c(%ebx) &the_region->Memory, starting_address, length, page_size ); if ( !the_region->maximum_segment_size ) { 1168d8: 83 c4 10 add $0x10,%esp 1168db: 85 c0 test %eax,%eax 1168dd: 74 7d je 11695c return_status = RTEMS_INVALID_SIZE; } else { the_region->starting_address = starting_address; 1168df: 89 73 50 mov %esi,0x50(%ebx) the_region->length = length; 1168e2: 8b 45 10 mov 0x10(%ebp),%eax 1168e5: 89 43 54 mov %eax,0x54(%ebx) the_region->page_size = page_size; 1168e8: 8b 55 14 mov 0x14(%ebp),%edx 1168eb: 89 53 58 mov %edx,0x58(%ebx) the_region->attribute_set = attribute_set; 1168ee: 8b 45 18 mov 0x18(%ebp),%eax 1168f1: 89 43 60 mov %eax,0x60(%ebx) the_region->number_of_used_blocks = 0; 1168f4: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) _Thread_queue_Initialize( 1168fb: 6a 06 push $0x6 1168fd: 6a 40 push $0x40 1168ff: a8 04 test $0x4,%al 116901: 0f 95 c0 setne %al 116904: 0f b6 c0 movzbl %al,%eax 116907: 50 push %eax 116908: 8d 43 10 lea 0x10(%ebx),%eax 11690b: 50 push %eax 11690c: e8 e3 50 00 00 call 11b9f4 <_Thread_queue_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 116911: 8b 43 08 mov 0x8(%ebx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 116914: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 116917: 8b 15 1c 08 14 00 mov 0x14081c,%edx 11691d: 89 1c 8a mov %ebx,(%edx,%ecx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 116920: 89 7b 0c mov %edi,0xc(%ebx) &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 116923: 8b 55 1c mov 0x1c(%ebp),%edx 116926: 89 02 mov %eax,(%edx) 116928: 83 c4 10 add $0x10,%esp return_status = RTEMS_SUCCESSFUL; 11692b: 31 c0 xor %eax,%eax } } _RTEMS_Unlock_allocator(); 11692d: 83 ec 0c sub $0xc,%esp 116930: ff 35 a0 09 14 00 pushl 0x1409a0 116936: 89 45 e4 mov %eax,-0x1c(%ebp) 116939: e8 72 24 00 00 call 118db0 <_API_Mutex_Unlock> return return_status; 11693e: 83 c4 10 add $0x10,%esp 116941: 8b 45 e4 mov -0x1c(%ebp),%eax } 116944: 8d 65 f4 lea -0xc(%ebp),%esp 116947: 5b pop %ebx 116948: 5e pop %esi 116949: 5f pop %edi 11694a: c9 leave 11694b: c3 ret { rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 11694c: b8 03 00 00 00 mov $0x3,%eax } } _RTEMS_Unlock_allocator(); return return_status; } 116951: 8d 65 f4 lea -0xc(%ebp),%esp 116954: 5b pop %ebx 116955: 5e pop %esi 116956: 5f pop %edi 116957: c9 leave 116958: c3 ret 116959: 8d 76 00 lea 0x0(%esi),%esi */ RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 11695c: 83 ec 08 sub $0x8,%esp 11695f: 53 push %ebx 116960: 68 00 08 14 00 push $0x140800 116965: e8 de 3c 00 00 call 11a648 <_Objects_Free> 11696a: 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; 11696d: b8 08 00 00 00 mov $0x8,%eax 116972: eb b9 jmp 11692d if ( !starting_address ) return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; 116974: b8 09 00 00 00 mov $0x9,%eax } } _RTEMS_Unlock_allocator(); return return_status; } 116979: 8d 65 f4 lea -0xc(%ebp),%esp 11697c: 5b pop %ebx 11697d: 5e pop %esi 11697e: 5f pop %edi 11697f: c9 leave 116980: c3 ret 116981: 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; 116984: b8 05 00 00 00 mov $0x5,%eax 116989: eb a2 jmp 11692d =============================================================================== 0011698c : */ rtems_status_code rtems_region_delete( rtems_id id ) { 11698c: 55 push %ebp 11698d: 89 e5 mov %esp,%ebp 11698f: 53 push %ebx 116990: 83 ec 30 sub $0x30,%esp Objects_Locations location; rtems_status_code return_status; Region_Control *the_region; _RTEMS_Lock_allocator(); 116993: ff 35 a0 09 14 00 pushl 0x1409a0 116999: e8 ca 23 00 00 call 118d68 <_API_Mutex_Lock> Objects_Id id, Objects_Locations *location ) { return (Region_Control *) _Objects_Get_no_protection( &_Region_Information, id, location ); 11699e: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 1169a1: 8d 45 f4 lea -0xc(%ebp),%eax 1169a4: 50 push %eax 1169a5: ff 75 08 pushl 0x8(%ebp) 1169a8: 68 00 08 14 00 push $0x140800 1169ad: e8 d6 3d 00 00 call 11a788 <_Objects_Get_no_protection> switch ( location ) { 1169b2: 83 c4 10 add $0x10,%esp 1169b5: 8b 5d f4 mov -0xc(%ebp),%ebx 1169b8: 85 db test %ebx,%ebx 1169ba: 74 1c je 1169d8 break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 1169bc: bb 04 00 00 00 mov $0x4,%ebx break; } _RTEMS_Unlock_allocator(); 1169c1: 83 ec 0c sub $0xc,%esp 1169c4: ff 35 a0 09 14 00 pushl 0x1409a0 1169ca: e8 e1 23 00 00 call 118db0 <_API_Mutex_Unlock> return return_status; } 1169cf: 89 d8 mov %ebx,%eax 1169d1: 8b 5d fc mov -0x4(%ebp),%ebx 1169d4: c9 leave 1169d5: c3 ret 1169d6: 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 ) 1169d8: 8b 48 64 mov 0x64(%eax),%ecx 1169db: 85 c9 test %ecx,%ecx 1169dd: 74 09 je 1169e8 return_status = RTEMS_RESOURCE_IN_USE; 1169df: bb 0c 00 00 00 mov $0xc,%ebx 1169e4: eb db jmp 1169c1 1169e6: 66 90 xchg %ax,%ax else { _Objects_Close( &_Region_Information, &the_region->Object ); 1169e8: 83 ec 08 sub $0x8,%esp 1169eb: 50 push %eax 1169ec: 68 00 08 14 00 push $0x140800 1169f1: 89 45 e4 mov %eax,-0x1c(%ebp) 1169f4: e8 57 39 00 00 call 11a350 <_Objects_Close> */ RTEMS_INLINE_ROUTINE void _Region_Free ( Region_Control *the_region ) { _Objects_Free( &_Region_Information, &the_region->Object ); 1169f9: 58 pop %eax 1169fa: 5a pop %edx 1169fb: 8b 45 e4 mov -0x1c(%ebp),%eax 1169fe: 50 push %eax 1169ff: 68 00 08 14 00 push $0x140800 116a04: e8 3f 3c 00 00 call 11a648 <_Objects_Free> 116a09: 83 c4 10 add $0x10,%esp _Region_Free( the_region ); return_status = RTEMS_SUCCESSFUL; 116a0c: 31 db xor %ebx,%ebx 116a0e: eb b1 jmp 1169c1 =============================================================================== 00116a10 : rtems_status_code rtems_region_extend( rtems_id id, void *starting_address, uintptr_t length ) { 116a10: 55 push %ebp 116a11: 89 e5 mov %esp,%ebp 116a13: 56 push %esi 116a14: 53 push %ebx 116a15: 83 ec 10 sub $0x10,%esp 116a18: 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 ) 116a1b: 85 db test %ebx,%ebx 116a1d: 74 75 je 116a94 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 116a1f: 83 ec 0c sub $0xc,%esp 116a22: ff 35 a0 09 14 00 pushl 0x1409a0 116a28: e8 3b 23 00 00 call 118d68 <_API_Mutex_Lock> Objects_Id id, Objects_Locations *location ) { return (Region_Control *) _Objects_Get_no_protection( &_Region_Information, id, location ); 116a2d: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 116a30: 8d 45 f0 lea -0x10(%ebp),%eax 116a33: 50 push %eax 116a34: ff 75 08 pushl 0x8(%ebp) 116a37: 68 00 08 14 00 push $0x140800 116a3c: e8 47 3d 00 00 call 11a788 <_Objects_Get_no_protection> 116a41: 89 c6 mov %eax,%esi switch ( location ) { 116a43: 83 c4 10 add $0x10,%esp 116a46: 8b 45 f0 mov -0x10(%ebp),%eax 116a49: 85 c0 test %eax,%eax 116a4b: 74 1f je 116a6c break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 116a4d: bb 04 00 00 00 mov $0x4,%ebx break; } _RTEMS_Unlock_allocator(); 116a52: 83 ec 0c sub $0xc,%esp 116a55: ff 35 a0 09 14 00 pushl 0x1409a0 116a5b: e8 50 23 00 00 call 118db0 <_API_Mutex_Unlock> return return_status; 116a60: 83 c4 10 add $0x10,%esp } 116a63: 89 d8 mov %ebx,%eax 116a65: 8d 65 f8 lea -0x8(%ebp),%esp 116a68: 5b pop %ebx 116a69: 5e pop %esi 116a6a: c9 leave 116a6b: c3 ret the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: extend_ok = _Heap_Extend( 116a6c: 8d 45 f4 lea -0xc(%ebp),%eax 116a6f: 50 push %eax 116a70: ff 75 10 pushl 0x10(%ebp) 116a73: 53 push %ebx 116a74: 8d 46 68 lea 0x68(%esi),%eax 116a77: 50 push %eax 116a78: e8 43 2e 00 00 call 1198c0 <_Heap_Extend> starting_address, length, &amount_extended ); if ( extend_ok ) { 116a7d: 83 c4 10 add $0x10,%esp 116a80: 84 c0 test %al,%al 116a82: 74 20 je 116aa4 the_region->length += amount_extended; 116a84: 8b 45 f4 mov -0xc(%ebp),%eax 116a87: 01 46 54 add %eax,0x54(%esi) the_region->maximum_segment_size += amount_extended; 116a8a: 01 46 5c add %eax,0x5c(%esi) return_status = RTEMS_SUCCESSFUL; 116a8d: 31 db xor %ebx,%ebx 116a8f: eb c1 jmp 116a52 116a91: 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; 116a94: bb 09 00 00 00 mov $0x9,%ebx break; } _RTEMS_Unlock_allocator(); return return_status; } 116a99: 89 d8 mov %ebx,%eax 116a9b: 8d 65 f8 lea -0x8(%ebp),%esp 116a9e: 5b pop %ebx 116a9f: 5e pop %esi 116aa0: c9 leave 116aa1: c3 ret 116aa2: 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; 116aa4: bb 09 00 00 00 mov $0x9,%ebx 116aa9: eb a7 jmp 116a52 =============================================================================== 00116aac : rtems_status_code rtems_region_get_free_information( rtems_id id, Heap_Information_block *the_info ) { 116aac: 55 push %ebp 116aad: 89 e5 mov %esp,%ebp 116aaf: 53 push %ebx 116ab0: 83 ec 14 sub $0x14,%esp 116ab3: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; rtems_status_code return_status; register Region_Control *the_region; if ( !the_info ) 116ab6: 85 db test %ebx,%ebx 116ab8: 74 76 je 116b30 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 116aba: 83 ec 0c sub $0xc,%esp 116abd: ff 35 a0 09 14 00 pushl 0x1409a0 116ac3: e8 a0 22 00 00 call 118d68 <_API_Mutex_Lock> 116ac8: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 116acb: 8d 45 f4 lea -0xc(%ebp),%eax 116ace: 50 push %eax 116acf: ff 75 08 pushl 0x8(%ebp) 116ad2: 68 00 08 14 00 push $0x140800 116ad7: e8 ac 3c 00 00 call 11a788 <_Objects_Get_no_protection> switch ( location ) { 116adc: 83 c4 10 add $0x10,%esp 116adf: 8b 55 f4 mov -0xc(%ebp),%edx 116ae2: 85 d2 test %edx,%edx 116ae4: 74 1e je 116b04 break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 116ae6: bb 04 00 00 00 mov $0x4,%ebx break; } _RTEMS_Unlock_allocator(); 116aeb: 83 ec 0c sub $0xc,%esp 116aee: ff 35 a0 09 14 00 pushl 0x1409a0 116af4: e8 b7 22 00 00 call 118db0 <_API_Mutex_Unlock> return return_status; 116af9: 83 c4 10 add $0x10,%esp } 116afc: 89 d8 mov %ebx,%eax 116afe: 8b 5d fc mov -0x4(%ebp),%ebx 116b01: c9 leave 116b02: c3 ret 116b03: 90 nop the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: the_info->Used.number = 0; 116b04: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) the_info->Used.total = 0; 116b0b: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) the_info->Used.largest = 0; 116b12: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) _Heap_Get_free_information( &the_region->Memory, &the_info->Free ); 116b19: 83 ec 08 sub $0x8,%esp 116b1c: 53 push %ebx 116b1d: 83 c0 68 add $0x68,%eax 116b20: 50 push %eax 116b21: e8 96 31 00 00 call 119cbc <_Heap_Get_free_information> return_status = RTEMS_SUCCESSFUL; break; 116b26: 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; 116b29: 31 db xor %ebx,%ebx break; 116b2b: eb be jmp 116aeb 116b2d: 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; 116b30: bb 09 00 00 00 mov $0x9,%ebx break; } _RTEMS_Unlock_allocator(); return return_status; } 116b35: 89 d8 mov %ebx,%eax 116b37: 8b 5d fc mov -0x4(%ebp),%ebx 116b3a: c9 leave 116b3b: c3 ret =============================================================================== 00116bb4 : uintptr_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 116bb4: 55 push %ebp 116bb5: 89 e5 mov %esp,%ebp 116bb7: 57 push %edi 116bb8: 56 push %esi 116bb9: 53 push %ebx 116bba: 83 ec 2c sub $0x2c,%esp 116bbd: 8b 75 0c mov 0xc(%ebp),%esi 116bc0: 8b 5d 18 mov 0x18(%ebp),%ebx Objects_Locations location; rtems_status_code return_status; Region_Control *the_region; void *the_segment; if ( !segment ) 116bc3: 85 db test %ebx,%ebx 116bc5: 0f 84 a1 00 00 00 je 116c6c return RTEMS_INVALID_ADDRESS; *segment = NULL; 116bcb: c7 03 00 00 00 00 movl $0x0,(%ebx) if ( size == 0 ) 116bd1: 85 f6 test %esi,%esi 116bd3: 75 0f jne 116be4 return RTEMS_INVALID_SIZE; 116bd5: b8 08 00 00 00 mov $0x8,%eax break; } _RTEMS_Unlock_allocator(); return return_status; } 116bda: 8d 65 f4 lea -0xc(%ebp),%esp 116bdd: 5b pop %ebx 116bde: 5e pop %esi 116bdf: 5f pop %edi 116be0: c9 leave 116be1: c3 ret 116be2: 66 90 xchg %ax,%ax *segment = NULL; if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 116be4: 83 ec 0c sub $0xc,%esp 116be7: ff 35 a0 09 14 00 pushl 0x1409a0 116bed: e8 76 21 00 00 call 118d68 <_API_Mutex_Lock> executing = _Thread_Executing; 116bf2: a1 78 0b 14 00 mov 0x140b78,%eax 116bf7: 89 45 d4 mov %eax,-0x2c(%ebp) 116bfa: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 116bfd: 8d 45 e4 lea -0x1c(%ebp),%eax 116c00: 50 push %eax 116c01: ff 75 08 pushl 0x8(%ebp) 116c04: 68 00 08 14 00 push $0x140800 116c09: e8 7a 3b 00 00 call 11a788 <_Objects_Get_no_protection> 116c0e: 89 c7 mov %eax,%edi switch ( location ) { 116c10: 83 c4 10 add $0x10,%esp 116c13: 8b 45 e4 mov -0x1c(%ebp),%eax 116c16: 85 c0 test %eax,%eax 116c18: 75 2a jne 116c44 case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) 116c1a: 3b 77 5c cmp 0x5c(%edi),%esi 116c1d: 76 2d jbe 116c4c return_status = RTEMS_INVALID_SIZE; 116c1f: b8 08 00 00 00 mov $0x8,%eax default: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 116c24: 83 ec 0c sub $0xc,%esp 116c27: ff 35 a0 09 14 00 pushl 0x1409a0 116c2d: 89 45 d0 mov %eax,-0x30(%ebp) 116c30: e8 7b 21 00 00 call 118db0 <_API_Mutex_Unlock> return return_status; 116c35: 83 c4 10 add $0x10,%esp 116c38: 8b 45 d0 mov -0x30(%ebp),%eax } 116c3b: 8d 65 f4 lea -0xc(%ebp),%esp 116c3e: 5b pop %ebx 116c3f: 5e pop %esi 116c40: 5f pop %edi 116c41: c9 leave 116c42: c3 ret 116c43: 90 nop break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 116c44: b8 04 00 00 00 mov $0x4,%eax 116c49: eb d9 jmp 116c24 116c4b: 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 ); 116c4c: 6a 00 push $0x0 116c4e: 6a 00 push $0x0 116c50: 56 push %esi RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment ( Region_Control *the_region, uintptr_t size ) { return _Heap_Allocate( &the_region->Memory, size ); 116c51: 8d 47 68 lea 0x68(%edi),%eax 116c54: 50 push %eax 116c55: e8 92 2a 00 00 call 1196ec <_Heap_Allocate_aligned_with_boundary> the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 116c5a: 83 c4 10 add $0x10,%esp 116c5d: 85 c0 test %eax,%eax 116c5f: 74 17 je 116c78 the_region->number_of_used_blocks += 1; 116c61: ff 47 64 incl 0x64(%edi) *segment = the_segment; 116c64: 89 03 mov %eax,(%ebx) return_status = RTEMS_SUCCESSFUL; 116c66: 31 c0 xor %eax,%eax 116c68: eb ba jmp 116c24 116c6a: 66 90 xchg %ax,%ax rtems_status_code return_status; Region_Control *the_region; void *the_segment; if ( !segment ) return RTEMS_INVALID_ADDRESS; 116c6c: b8 09 00 00 00 mov $0x9,%eax 116c71: e9 64 ff ff ff jmp 116bda 116c76: 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 ) ) { 116c78: f6 45 10 01 testb $0x1,0x10(%ebp) 116c7c: 74 07 je 116c85 return_status = RTEMS_UNSATISFIED; 116c7e: b8 0d 00 00 00 mov $0xd,%eax 116c83: eb 9f jmp 116c24 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 116c85: a1 ec 08 14 00 mov 0x1408ec,%eax 116c8a: 40 inc %eax 116c8b: a3 ec 08 14 00 mov %eax,0x1408ec * 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(); 116c90: 83 ec 0c sub $0xc,%esp 116c93: ff 35 a0 09 14 00 pushl 0x1409a0 116c99: e8 12 21 00 00 call 118db0 <_API_Mutex_Unlock> executing->Wait.queue = &the_region->Wait_queue; 116c9e: 8d 47 10 lea 0x10(%edi),%eax 116ca1: 8b 55 d4 mov -0x2c(%ebp),%edx 116ca4: 89 42 44 mov %eax,0x44(%edx) executing->Wait.id = id; 116ca7: 8b 4d 08 mov 0x8(%ebp),%ecx 116caa: 89 4a 20 mov %ecx,0x20(%edx) executing->Wait.count = size; 116cad: 89 72 24 mov %esi,0x24(%edx) executing->Wait.return_argument = segment; 116cb0: 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; 116cb3: 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 ); 116cba: 83 c4 0c add $0xc,%esp 116cbd: 68 b8 ba 11 00 push $0x11bab8 116cc2: ff 75 14 pushl 0x14(%ebp) 116cc5: 50 push %eax 116cc6: e8 c1 4a 00 00 call 11b78c <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 116ccb: e8 44 46 00 00 call 11b314 <_Thread_Enable_dispatch> return (rtems_status_code) executing->Wait.return_code; 116cd0: 8b 55 d4 mov -0x2c(%ebp),%edx 116cd3: 8b 42 34 mov 0x34(%edx),%eax 116cd6: 83 c4 10 add $0x10,%esp 116cd9: e9 fc fe ff ff jmp 116bda =============================================================================== 00116d94 : rtems_id id, void *segment, uintptr_t size, uintptr_t *old_size ) { 116d94: 55 push %ebp 116d95: 89 e5 mov %esp,%ebp 116d97: 56 push %esi 116d98: 53 push %ebx 116d99: 83 ec 20 sub $0x20,%esp 116d9c: 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 ) 116d9f: 85 db test %ebx,%ebx 116da1: 0f 84 89 00 00 00 je 116e30 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 116da7: 83 ec 0c sub $0xc,%esp 116daa: ff 35 a0 09 14 00 pushl 0x1409a0 116db0: e8 b3 1f 00 00 call 118d68 <_API_Mutex_Lock> 116db5: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 116db8: 8d 45 f0 lea -0x10(%ebp),%eax 116dbb: 50 push %eax 116dbc: ff 75 08 pushl 0x8(%ebp) 116dbf: 68 00 08 14 00 push $0x140800 116dc4: e8 bf 39 00 00 call 11a788 <_Objects_Get_no_protection> 116dc9: 89 c6 mov %eax,%esi switch ( location ) { 116dcb: 83 c4 10 add $0x10,%esp 116dce: 8b 45 f0 mov -0x10(%ebp),%eax 116dd1: 85 c0 test %eax,%eax 116dd3: 74 1f je 116df4 default: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 116dd5: 83 ec 0c sub $0xc,%esp 116dd8: ff 35 a0 09 14 00 pushl 0x1409a0 116dde: e8 cd 1f 00 00 call 118db0 <_API_Mutex_Unlock> return return_status; 116de3: 83 c4 10 add $0x10,%esp 116de6: b8 04 00 00 00 mov $0x4,%eax } 116deb: 8d 65 f8 lea -0x8(%ebp),%esp 116dee: 5b pop %ebx 116def: 5e pop %esi 116df0: c9 leave 116df1: c3 ret 116df2: 66 90 xchg %ax,%ax case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 7 ); status = _Heap_Resize_block( 116df4: 83 ec 0c sub $0xc,%esp 116df7: 8d 45 f4 lea -0xc(%ebp),%eax 116dfa: 50 push %eax 116dfb: 8d 45 ec lea -0x14(%ebp),%eax 116dfe: 50 push %eax 116dff: ff 75 10 pushl 0x10(%ebp) 116e02: ff 75 0c pushl 0xc(%ebp) 116e05: 8d 46 68 lea 0x68(%esi),%eax 116e08: 50 push %eax 116e09: e8 da 32 00 00 call 11a0e8 <_Heap_Resize_block> segment, (uint32_t) size, &osize, &avail_size ); *old_size = (uint32_t) osize; 116e0e: 8b 55 ec mov -0x14(%ebp),%edx 116e11: 89 13 mov %edx,(%ebx) _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL ) 116e13: 83 c4 20 add $0x20,%esp 116e16: 85 c0 test %eax,%eax 116e18: 75 22 jne 116e3c _Region_Process_queue( the_region ); /* unlocks allocator */ 116e1a: 83 ec 0c sub $0xc,%esp 116e1d: 56 push %esi 116e1e: e8 d1 72 00 00 call 11e0f4 <_Region_Process_queue> 116e23: 83 c4 10 add $0x10,%esp else _RTEMS_Unlock_allocator(); if (status == HEAP_RESIZE_SUCCESSFUL) return RTEMS_SUCCESSFUL; 116e26: 31 c0 xor %eax,%eax break; } _RTEMS_Unlock_allocator(); return return_status; } 116e28: 8d 65 f8 lea -0x8(%ebp),%esp 116e2b: 5b pop %ebx 116e2c: 5e pop %esi 116e2d: c9 leave 116e2e: c3 ret 116e2f: 90 nop rtems_status_code return_status; Heap_Resize_status status; register Region_Control *the_region; if ( !old_size ) return RTEMS_INVALID_ADDRESS; 116e30: b8 09 00 00 00 mov $0x9,%eax break; } _RTEMS_Unlock_allocator(); return return_status; } 116e35: 8d 65 f8 lea -0x8(%ebp),%esp 116e38: 5b pop %ebx 116e39: 5e pop %esi 116e3a: c9 leave 116e3b: c3 ret _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL ) _Region_Process_queue( the_region ); /* unlocks allocator */ else _RTEMS_Unlock_allocator(); 116e3c: 83 ec 0c sub $0xc,%esp 116e3f: ff 35 a0 09 14 00 pushl 0x1409a0 116e45: 89 45 e4 mov %eax,-0x1c(%ebp) 116e48: e8 63 1f 00 00 call 118db0 <_API_Mutex_Unlock> if (status == HEAP_RESIZE_SUCCESSFUL) return RTEMS_SUCCESSFUL; if (status == HEAP_RESIZE_UNSATISFIED) 116e4d: 83 c4 10 add $0x10,%esp return RTEMS_UNSATISFIED; 116e50: 8b 45 e4 mov -0x1c(%ebp),%eax 116e53: 48 dec %eax 116e54: 0f 94 c0 sete %al 116e57: 0f b6 c0 movzbl %al,%eax 116e5a: 8d 04 85 09 00 00 00 lea 0x9(,%eax,4),%eax break; } _RTEMS_Unlock_allocator(); return return_status; } 116e61: 8d 65 f8 lea -0x8(%ebp),%esp 116e64: 5b pop %ebx 116e65: 5e pop %esi 116e66: c9 leave 116e67: c3 ret =============================================================================== 00116e68 : rtems_status_code rtems_region_return_segment( rtems_id id, void *segment ) { 116e68: 55 push %ebp 116e69: 89 e5 mov %esp,%ebp 116e6b: 53 push %ebx 116e6c: 83 ec 20 sub $0x20,%esp uint32_t size; #endif int status; register Region_Control *the_region; _RTEMS_Lock_allocator(); 116e6f: ff 35 a0 09 14 00 pushl 0x1409a0 116e75: e8 ee 1e 00 00 call 118d68 <_API_Mutex_Lock> 116e7a: 83 c4 0c add $0xc,%esp the_region = _Region_Get( id, &location ); 116e7d: 8d 45 f4 lea -0xc(%ebp),%eax 116e80: 50 push %eax 116e81: ff 75 08 pushl 0x8(%ebp) 116e84: 68 00 08 14 00 push $0x140800 116e89: e8 fa 38 00 00 call 11a788 <_Objects_Get_no_protection> 116e8e: 89 c3 mov %eax,%ebx switch ( location ) { 116e90: 83 c4 10 add $0x10,%esp 116e93: 8b 45 f4 mov -0xc(%ebp),%eax 116e96: 85 c0 test %eax,%eax 116e98: 75 1e jne 116eb8 RTEMS_INLINE_ROUTINE bool _Region_Free_segment ( Region_Control *the_region, void *the_segment ) { return _Heap_Free( &the_region->Memory, the_segment ); 116e9a: 83 ec 08 sub $0x8,%esp 116e9d: ff 75 0c pushl 0xc(%ebp) 116ea0: 8d 43 68 lea 0x68(%ebx),%eax 116ea3: 50 push %eax 116ea4: e8 af 2c 00 00 call 119b58 <_Heap_Free> #endif status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) 116ea9: 83 c4 10 add $0x10,%esp 116eac: 84 c0 test %al,%al 116eae: 75 28 jne 116ed8 return_status = RTEMS_INVALID_ADDRESS; 116eb0: bb 09 00 00 00 mov $0x9,%ebx 116eb5: eb 06 jmp 116ebd 116eb7: 90 nop break; #endif case OBJECTS_ERROR: default: return_status = RTEMS_INVALID_ID; 116eb8: bb 04 00 00 00 mov $0x4,%ebx break; } _RTEMS_Unlock_allocator(); 116ebd: 83 ec 0c sub $0xc,%esp 116ec0: ff 35 a0 09 14 00 pushl 0x1409a0 116ec6: e8 e5 1e 00 00 call 118db0 <_API_Mutex_Unlock> return return_status; 116ecb: 83 c4 10 add $0x10,%esp } 116ece: 89 d8 mov %ebx,%eax 116ed0: 8b 5d fc mov -0x4(%ebp),%ebx 116ed3: c9 leave 116ed4: c3 ret 116ed5: 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; 116ed8: ff 4b 64 decl 0x64(%ebx) _Region_Process_queue(the_region); /* unlocks allocator */ 116edb: 83 ec 0c sub $0xc,%esp 116ede: 53 push %ebx 116edf: e8 10 72 00 00 call 11e0f4 <_Region_Process_queue> return RTEMS_SUCCESSFUL; 116ee4: 83 c4 10 add $0x10,%esp 116ee7: 31 db xor %ebx,%ebx break; } _RTEMS_Unlock_allocator(); return return_status; } 116ee9: 89 d8 mov %ebx,%eax 116eeb: 8b 5d fc mov -0x4(%ebp),%ebx 116eee: c9 leave 116eef: c3 ret =============================================================================== 0010a92c : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 10a92c: 55 push %ebp 10a92d: 89 e5 mov %esp,%ebp 10a92f: 57 push %edi 10a930: 56 push %esi 10a931: 53 push %ebx 10a932: 83 ec 3c sub $0x3c,%esp 10a935: 8b 75 08 mov 0x8(%ebp),%esi 10a938: 8b 5d 10 mov 0x10(%ebp),%ebx 10a93b: 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 ) ) 10a93e: 85 f6 test %esi,%esi 10a940: 74 4a je 10a98c return RTEMS_INVALID_NAME; if ( !id ) 10a942: 85 ff test %edi,%edi 10a944: 0f 84 f6 00 00 00 je 10aa40 <== NEVER TAKEN return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 10a94a: 89 da mov %ebx,%edx 10a94c: 81 e2 c0 00 00 00 and $0xc0,%edx 10a952: 74 48 je 10a99c */ RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore( rtems_attribute attribute_set ) { return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE); 10a954: 89 d8 mov %ebx,%eax 10a956: 83 e0 30 and $0x30,%eax _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) && 10a959: 83 f8 10 cmp $0x10,%eax 10a95c: 74 0e je 10a96c } if ( _Attributes_Is_inherit_priority( attribute_set ) && _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; 10a95e: b8 0b 00 00 00 mov $0xb,%eax 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10a963: 8d 65 f4 lea -0xc(%ebp),%esp 10a966: 5b pop %ebx 10a967: 5e pop %esi 10a968: 5f pop %edi 10a969: c9 leave 10a96a: c3 ret 10a96b: 90 nop #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! (_Attributes_Is_binary_semaphore( attribute_set ) && 10a96c: f6 c3 04 test $0x4,%bl 10a96f: 74 ed je 10a95e _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 10a971: 81 fa c0 00 00 00 cmp $0xc0,%edx 10a977: 74 e5 je 10a95e 10a979: 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 ) ) 10a97e: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 10a982: 76 1f jbe 10a9a3 return RTEMS_INVALID_NUMBER; 10a984: b8 0a 00 00 00 mov $0xa,%eax 10a989: eb d8 jmp 10a963 10a98b: 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; 10a98c: b8 03 00 00 00 mov $0x3,%eax 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10a991: 8d 65 f4 lea -0xc(%ebp),%esp 10a994: 5b pop %ebx 10a995: 5e pop %esi 10a996: 5f pop %edi 10a997: c9 leave 10a998: c3 ret 10a999: 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 ) ) 10a99c: 89 d9 mov %ebx,%ecx 10a99e: 83 e1 30 and $0x30,%ecx 10a9a1: 75 db jne 10a97e rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a9a3: a1 ec 64 12 00 mov 0x1264ec,%eax 10a9a8: 40 inc %eax 10a9a9: a3 ec 64 12 00 mov %eax,0x1264ec * 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 ); 10a9ae: 83 ec 0c sub $0xc,%esp 10a9b1: 68 40 64 12 00 push $0x126440 10a9b6: 89 4d c4 mov %ecx,-0x3c(%ebp) 10a9b9: e8 3a 13 00 00 call 10bcf8 <_Objects_Allocate> 10a9be: 89 c2 mov %eax,%edx _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 10a9c0: 83 c4 10 add $0x10,%esp 10a9c3: 85 c0 test %eax,%eax 10a9c5: 8b 4d c4 mov -0x3c(%ebp),%ecx 10a9c8: 0f 84 ba 00 00 00 je 10aa88 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_semaphore->attribute_set = attribute_set; 10a9ce: 89 58 10 mov %ebx,0x10(%eax) /* * Initialize it as a counting semaphore. */ if ( _Attributes_Is_counting_semaphore( attribute_set ) ) { 10a9d1: 85 c9 test %ecx,%ecx 10a9d3: 74 77 je 10aa4c /* * 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; 10a9d5: 31 c0 xor %eax,%eax 10a9d7: f6 c3 04 test $0x4,%bl 10a9da: 0f 95 c0 setne %al 10a9dd: 89 45 d8 mov %eax,-0x28(%ebp) else the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 10a9e0: 83 f9 10 cmp $0x10,%ecx 10a9e3: 0f 84 ae 00 00 00 je 10aa97 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; 10a9e9: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp) the_mutex_attr.only_owner_release = false; 10a9f0: c6 45 d4 00 movb $0x0,-0x2c(%ebp) } mutex_status = _CORE_mutex_Initialize( 10a9f4: 50 push %eax 10a9f5: 31 c0 xor %eax,%eax 10a9f7: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 10a9fb: 0f 94 c0 sete %al 10a9fe: 50 push %eax 10a9ff: 8d 45 d0 lea -0x30(%ebp),%eax 10aa02: 50 push %eax 10aa03: 8d 42 14 lea 0x14(%edx),%eax 10aa06: 50 push %eax 10aa07: 89 55 c4 mov %edx,-0x3c(%ebp) 10aa0a: e8 e1 0a 00 00 call 10b4f0 <_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 ) { 10aa0f: 83 c4 10 add $0x10,%esp 10aa12: 83 f8 05 cmp $0x5,%eax 10aa15: 8b 55 c4 mov -0x3c(%ebp),%edx 10aa18: 0f 84 a9 00 00 00 je 10aac7 Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10aa1e: 8b 42 08 mov 0x8(%edx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10aa21: 0f b7 d8 movzwl %ax,%ebx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10aa24: 8b 0d 5c 64 12 00 mov 0x12645c,%ecx 10aa2a: 89 14 99 mov %edx,(%ecx,%ebx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10aa2d: 89 72 0c mov %esi,0xc(%edx) &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 10aa30: 89 07 mov %eax,(%edi) the_semaphore->Object.id, name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 10aa32: e8 c5 22 00 00 call 10ccfc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10aa37: 31 c0 xor %eax,%eax 10aa39: e9 25 ff ff ff jmp 10a963 10aa3e: 66 90 xchg %ax,%ax if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 10aa40: b8 09 00 00 00 mov $0x9,%eax 10aa45: e9 19 ff ff ff jmp 10a963 10aa4a: 66 90 xchg %ax,%ax */ if ( _Attributes_Is_counting_semaphore( attribute_set ) ) { /* * This effectively disables limit checking. */ the_semaphore_attr.maximum_count = 0xFFFFFFFF; 10aa4c: 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; 10aa53: 31 c0 xor %eax,%eax 10aa55: f6 c3 04 test $0x4,%bl 10aa58: 0f 95 c0 setne %al 10aa5b: 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; 10aa5e: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) the_mutex_attr.priority_ceiling = PRIORITY_MINIMUM; 10aa65: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) _CORE_semaphore_Initialize( 10aa6c: 51 push %ecx 10aa6d: ff 75 0c pushl 0xc(%ebp) 10aa70: 8d 45 e0 lea -0x20(%ebp),%eax 10aa73: 50 push %eax 10aa74: 8d 42 14 lea 0x14(%edx),%eax 10aa77: 50 push %eax 10aa78: 89 55 c4 mov %edx,-0x3c(%ebp) 10aa7b: e8 00 0d 00 00 call 10b780 <_CORE_semaphore_Initialize> 10aa80: 83 c4 10 add $0x10,%esp 10aa83: 8b 55 c4 mov -0x3c(%ebp),%edx 10aa86: eb 96 jmp 10aa1e _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { _Thread_Enable_dispatch(); 10aa88: e8 6f 22 00 00 call 10ccfc <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 10aa8d: b8 05 00 00 00 mov $0x5,%eax 10aa92: e9 cc fe ff ff jmp 10a963 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; 10aa97: 8b 45 14 mov 0x14(%ebp),%eax 10aa9a: 89 45 dc mov %eax,-0x24(%ebp) the_mutex_attr.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 10aa9d: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) the_mutex_attr.only_owner_release = false; 10aaa4: c6 45 d4 00 movb $0x0,-0x2c(%ebp) if ( the_mutex_attr.discipline == CORE_MUTEX_DISCIPLINES_PRIORITY ) { 10aaa8: 83 7d d8 01 cmpl $0x1,-0x28(%ebp) 10aaac: 0f 85 42 ff ff ff jne 10a9f4 if ( _Attributes_Is_inherit_priority( attribute_set ) ) { 10aab2: f6 c3 40 test $0x40,%bl 10aab5: 74 30 je 10aae7 the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 10aab7: c7 45 d8 02 00 00 00 movl $0x2,-0x28(%ebp) the_mutex_attr.only_owner_release = true; 10aabe: c6 45 d4 01 movb $0x1,-0x2c(%ebp) 10aac2: e9 2d ff ff ff jmp 10a9f4 */ RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 10aac7: 83 ec 08 sub $0x8,%esp 10aaca: 52 push %edx 10aacb: 68 40 64 12 00 push $0x126440 10aad0: e8 97 15 00 00 call 10c06c <_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(); 10aad5: e8 22 22 00 00 call 10ccfc <_Thread_Enable_dispatch> return RTEMS_INVALID_PRIORITY; 10aada: 83 c4 10 add $0x10,%esp 10aadd: b8 13 00 00 00 mov $0x13,%eax 10aae2: e9 7c fe ff ff jmp 10a963 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 ) ) { 10aae7: 81 e3 80 00 00 00 and $0x80,%ebx 10aaed: 0f 84 01 ff ff ff je 10a9f4 the_mutex_attr.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 10aaf3: c7 45 d8 03 00 00 00 movl $0x3,-0x28(%ebp) the_mutex_attr.only_owner_release = true; 10aafa: c6 45 d4 01 movb $0x1,-0x2c(%ebp) 10aafe: e9 f1 fe ff ff jmp 10a9f4 =============================================================================== 0010ab04 : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 10ab04: 55 push %ebp 10ab05: 89 e5 mov %esp,%ebp 10ab07: 53 push %ebx 10ab08: 83 ec 18 sub $0x18,%esp register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); 10ab0b: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) _Objects_Get( &_Semaphore_Information, id, location ); 10ab0e: 50 push %eax 10ab0f: ff 75 08 pushl 0x8(%ebp) 10ab12: 68 40 64 12 00 push $0x126440 10ab17: e8 90 16 00 00 call 10c1ac <_Objects_Get> 10ab1c: 89 c3 mov %eax,%ebx switch ( location ) { 10ab1e: 83 c4 10 add $0x10,%esp 10ab21: 8b 4d f4 mov -0xc(%ebp),%ecx 10ab24: 85 c9 test %ecx,%ecx 10ab26: 74 0c je 10ab34 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10ab28: b8 04 00 00 00 mov $0x4,%eax } 10ab2d: 8b 5d fc mov -0x4(%ebp),%ebx 10ab30: c9 leave 10ab31: c3 ret 10ab32: 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); 10ab34: 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) ) { 10ab37: 83 e0 30 and $0x30,%eax 10ab3a: 74 58 je 10ab94 if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 10ab3c: 8b 53 64 mov 0x64(%ebx),%edx 10ab3f: 85 d2 test %edx,%edx 10ab41: 75 15 jne 10ab58 10ab43: 83 f8 20 cmp $0x20,%eax 10ab46: 74 10 je 10ab58 !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); 10ab48: e8 af 21 00 00 call 10ccfc <_Thread_Enable_dispatch> return RTEMS_RESOURCE_IN_USE; 10ab4d: b8 0c 00 00 00 mov $0xc,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ab52: 8b 5d fc mov -0x4(%ebp),%ebx 10ab55: c9 leave 10ab56: c3 ret 10ab57: 90 nop !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } _CORE_mutex_Flush( 10ab58: 50 push %eax 10ab59: 6a 03 push $0x3 10ab5b: 6a 00 push $0x0 10ab5d: 8d 43 14 lea 0x14(%ebx),%eax 10ab60: 50 push %eax 10ab61: e8 7e 09 00 00 call 10b4e4 <_CORE_mutex_Flush> 10ab66: 83 c4 10 add $0x10,%esp SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_SEMAPHORE_WAS_DELETED ); } _Objects_Close( &_Semaphore_Information, &the_semaphore->Object ); 10ab69: 83 ec 08 sub $0x8,%esp 10ab6c: 53 push %ebx 10ab6d: 68 40 64 12 00 push $0x126440 10ab72: e8 fd 11 00 00 call 10bd74 <_Objects_Close> */ RTEMS_INLINE_ROUTINE void _Semaphore_Free ( Semaphore_Control *the_semaphore ) { _Objects_Free( &_Semaphore_Information, &the_semaphore->Object ); 10ab77: 58 pop %eax 10ab78: 5a pop %edx 10ab79: 53 push %ebx 10ab7a: 68 40 64 12 00 push $0x126440 10ab7f: e8 e8 14 00 00 call 10c06c <_Objects_Free> 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 10ab84: e8 73 21 00 00 call 10ccfc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10ab89: 83 c4 10 add $0x10,%esp 10ab8c: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ab8e: 8b 5d fc mov -0x4(%ebp),%ebx 10ab91: c9 leave 10ab92: c3 ret 10ab93: 90 nop &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 10ab94: 51 push %ecx 10ab95: 6a 02 push $0x2 10ab97: 6a 00 push $0x0 10ab99: 8d 43 14 lea 0x14(%ebx),%eax 10ab9c: 50 push %eax 10ab9d: e8 d2 0b 00 00 call 10b774 <_CORE_semaphore_Flush> 10aba2: 83 c4 10 add $0x10,%esp 10aba5: eb c2 jmp 10ab69 =============================================================================== 0010aba8 : rtems_status_code rtems_semaphore_obtain( rtems_id id, rtems_option option_set, rtems_interval timeout ) { 10aba8: 55 push %ebp 10aba9: 89 e5 mov %esp,%ebp 10abab: 57 push %edi 10abac: 56 push %esi 10abad: 53 push %ebx 10abae: 83 ec 1c sub $0x1c,%esp 10abb1: 8b 5d 08 mov 0x8(%ebp),%ebx 10abb4: 8b 75 0c mov 0xc(%ebp),%esi 10abb7: 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 ); 10abba: 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 ); 10abbd: 50 push %eax 10abbe: 8d 45 e4 lea -0x1c(%ebp),%eax 10abc1: 50 push %eax 10abc2: 53 push %ebx 10abc3: 68 40 64 12 00 push $0x126440 10abc8: e8 87 15 00 00 call 10c154 <_Objects_Get_isr_disable> switch ( location ) { 10abcd: 83 c4 10 add $0x10,%esp 10abd0: 8b 4d e4 mov -0x1c(%ebp),%ecx 10abd3: 85 c9 test %ecx,%ecx 10abd5: 74 0d je 10abe4 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10abd7: b8 04 00 00 00 mov $0x4,%eax } 10abdc: 8d 65 f4 lea -0xc(%ebp),%esp 10abdf: 5b pop %ebx 10abe0: 5e pop %esi 10abe1: 5f pop %edi 10abe2: c9 leave 10abe3: 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) ) { 10abe4: f6 40 10 30 testb $0x30,0x10(%eax) 10abe8: 74 36 je 10ac20 _CORE_mutex_Seize( 10abea: 83 ec 0c sub $0xc,%esp 10abed: ff 75 e0 pushl -0x20(%ebp) 10abf0: 57 push %edi */ RTEMS_INLINE_ROUTINE bool _Options_Is_no_wait ( rtems_option option_set ) { return (option_set & RTEMS_NO_WAIT) ? true : false; 10abf1: 83 e6 01 and $0x1,%esi 10abf4: 83 f6 01 xor $0x1,%esi 10abf7: 56 push %esi 10abf8: 53 push %ebx 10abf9: 83 c0 14 add $0x14,%eax 10abfc: 50 push %eax 10abfd: e8 e6 09 00 00 call 10b5e8 <_CORE_mutex_Seize> id, ((_Options_Is_no_wait( option_set )) ? false : true), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 10ac02: 83 c4 14 add $0x14,%esp _Thread_Executing->Wait.return_code ); 10ac05: a1 78 67 12 00 mov 0x126778,%eax id, ((_Options_Is_no_wait( option_set )) ? false : true), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 10ac0a: ff 70 34 pushl 0x34(%eax) 10ac0d: e8 12 01 00 00 call 10ad24 <_Semaphore_Translate_core_mutex_return_code> 10ac12: 83 c4 10 add $0x10,%esp break; } return RTEMS_INVALID_ID; } 10ac15: 8d 65 f4 lea -0xc(%ebp),%esp 10ac18: 5b pop %ebx 10ac19: 5e pop %esi 10ac1a: 5f pop %edi 10ac1b: c9 leave 10ac1c: c3 ret 10ac1d: 8d 76 00 lea 0x0(%esi),%esi { Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing; 10ac20: 8b 15 78 67 12 00 mov 0x126778,%edx executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10ac26: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) if ( the_semaphore->count != 0 ) { 10ac2d: 8b 48 5c mov 0x5c(%eax),%ecx 10ac30: 85 c9 test %ecx,%ecx 10ac32: 75 2c jne 10ac60 the_semaphore->count -= 1; _ISR_Enable( *level_p ); return; } if ( !wait ) { 10ac34: 83 e6 01 and $0x1,%esi 10ac37: 74 33 je 10ac6c _ISR_Enable( *level_p ); 10ac39: ff 75 e0 pushl -0x20(%ebp) 10ac3c: 9d popf executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 10ac3d: 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( 10ac44: 83 ec 0c sub $0xc,%esp _Thread_Executing->Wait.return_code ); 10ac47: a1 78 67 12 00 mov 0x126778,%eax id, ((_Options_Is_no_wait( option_set )) ? false : true), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 10ac4c: ff 70 34 pushl 0x34(%eax) 10ac4f: e8 e0 00 00 00 call 10ad34 <_Semaphore_Translate_core_semaphore_return_code> 10ac54: 83 c4 10 add $0x10,%esp break; } return RTEMS_INVALID_ID; } 10ac57: 8d 65 f4 lea -0xc(%ebp),%esp 10ac5a: 5b pop %ebx 10ac5b: 5e pop %esi 10ac5c: 5f pop %edi 10ac5d: c9 leave 10ac5e: c3 ret 10ac5f: 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; 10ac60: 49 dec %ecx 10ac61: 89 48 5c mov %ecx,0x5c(%eax) _ISR_Enable( *level_p ); 10ac64: ff 75 e0 pushl -0x20(%ebp) 10ac67: 9d popf 10ac68: eb da jmp 10ac44 10ac6a: 66 90 xchg %ax,%ax 10ac6c: 8b 0d ec 64 12 00 mov 0x1264ec,%ecx 10ac72: 41 inc %ecx 10ac73: 89 0d ec 64 12 00 mov %ecx,0x1264ec 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; 10ac79: 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; 10ac80: 83 c0 14 add $0x14,%eax 10ac83: 89 42 44 mov %eax,0x44(%edx) executing->Wait.id = id; 10ac86: 89 5a 20 mov %ebx,0x20(%edx) _ISR_Enable( *level_p ); 10ac89: ff 75 e0 pushl -0x20(%ebp) 10ac8c: 9d popf _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 10ac8d: 52 push %edx 10ac8e: 68 a0 d4 10 00 push $0x10d4a0 10ac93: 57 push %edi 10ac94: 50 push %eax 10ac95: e8 da 24 00 00 call 10d174 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10ac9a: e8 5d 20 00 00 call 10ccfc <_Thread_Enable_dispatch> 10ac9f: 83 c4 10 add $0x10,%esp 10aca2: eb a0 jmp 10ac44 =============================================================================== 0010aca4 : #endif rtems_status_code rtems_semaphore_release( rtems_id id ) { 10aca4: 55 push %ebp 10aca5: 89 e5 mov %esp,%ebp 10aca7: 53 push %ebx 10aca8: 83 ec 18 sub $0x18,%esp 10acab: 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 ); 10acae: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Semaphore_Control *) _Objects_Get( &_Semaphore_Information, id, location ); 10acb1: 50 push %eax 10acb2: 53 push %ebx 10acb3: 68 40 64 12 00 push $0x126440 10acb8: e8 ef 14 00 00 call 10c1ac <_Objects_Get> switch ( location ) { 10acbd: 83 c4 10 add $0x10,%esp 10acc0: 8b 55 f4 mov -0xc(%ebp),%edx 10acc3: 85 d2 test %edx,%edx 10acc5: 74 0d je 10acd4 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10acc7: b8 04 00 00 00 mov $0x4,%eax } 10accc: 8b 5d fc mov -0x4(%ebp),%ebx 10accf: c9 leave 10acd0: c3 ret 10acd1: 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) ) { 10acd4: f6 40 10 30 testb $0x30,0x10(%eax) 10acd8: 75 26 jne 10ad00 MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); } else { semaphore_status = _CORE_semaphore_Surrender( 10acda: 52 push %edx 10acdb: 6a 00 push $0x0 10acdd: 53 push %ebx 10acde: 83 c0 14 add $0x14,%eax 10ace1: 50 push %eax 10ace2: e8 d9 0a 00 00 call 10b7c0 <_CORE_semaphore_Surrender> 10ace7: 89 c3 mov %eax,%ebx &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 10ace9: e8 0e 20 00 00 call 10ccfc <_Thread_Enable_dispatch> return 10acee: 89 1c 24 mov %ebx,(%esp) 10acf1: e8 3e 00 00 00 call 10ad34 <_Semaphore_Translate_core_semaphore_return_code> 10acf6: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10acf9: 8b 5d fc mov -0x4(%ebp),%ebx 10acfc: c9 leave 10acfd: c3 ret 10acfe: 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( 10ad00: 51 push %ecx 10ad01: 6a 00 push $0x0 10ad03: 53 push %ebx 10ad04: 83 c0 14 add $0x14,%eax 10ad07: 50 push %eax 10ad08: e8 7b 09 00 00 call 10b688 <_CORE_mutex_Surrender> 10ad0d: 89 c3 mov %eax,%ebx &the_semaphore->Core_control.mutex, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 10ad0f: e8 e8 1f 00 00 call 10ccfc <_Thread_Enable_dispatch> return _Semaphore_Translate_core_mutex_return_code( mutex_status ); 10ad14: 89 1c 24 mov %ebx,(%esp) 10ad17: e8 08 00 00 00 call 10ad24 <_Semaphore_Translate_core_mutex_return_code> 10ad1c: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ad1f: 8b 5d fc mov -0x4(%ebp),%ebx 10ad22: c9 leave 10ad23: c3 ret =============================================================================== 00117388 : rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) { 117388: 55 push %ebp 117389: 89 e5 mov %esp,%ebp 11738b: 53 push %ebx 11738c: 83 ec 14 sub $0x14,%esp 11738f: 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 ) 117392: 85 db test %ebx,%ebx 117394: 75 0a jne 1173a0 return RTEMS_INVALID_NUMBER; 117396: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11739b: 8b 5d fc mov -0x4(%ebp),%ebx 11739e: c9 leave 11739f: c3 ret ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 1173a0: 83 ec 08 sub $0x8,%esp 1173a3: 8d 45 f4 lea -0xc(%ebp),%eax 1173a6: 50 push %eax 1173a7: ff 75 08 pushl 0x8(%ebp) 1173aa: e8 89 3f 00 00 call 11b338 <_Thread_Get> switch ( location ) { 1173af: 83 c4 10 add $0x10,%esp 1173b2: 8b 55 f4 mov -0xc(%ebp),%edx 1173b5: 85 d2 test %edx,%edx 1173b7: 74 0b je 1173c4 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1173b9: b8 04 00 00 00 mov $0x4,%eax } 1173be: 8b 5d fc mov -0x4(%ebp),%ebx 1173c1: c9 leave 1173c2: c3 ret 1173c3: 90 nop the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 1173c4: 8b 90 e4 00 00 00 mov 0xe4(%eax),%edx asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 1173ca: 8b 4a 0c mov 0xc(%edx),%ecx 1173cd: 85 c9 test %ecx,%ecx 1173cf: 74 3f je 117410 if ( asr->is_enabled ) { 1173d1: 80 7a 08 00 cmpb $0x0,0x8(%edx) 1173d5: 74 25 je 1173fc rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 1173d7: 9c pushf 1173d8: fa cli 1173d9: 59 pop %ecx *signal_set |= signals; 1173da: 09 5a 14 or %ebx,0x14(%edx) _ISR_Enable( _level ); 1173dd: 51 push %ecx 1173de: 9d popf _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 1173df: 8b 15 74 0b 14 00 mov 0x140b74,%edx 1173e5: 85 d2 test %edx,%edx 1173e7: 74 1b je 117404 1173e9: 3b 05 78 0b 14 00 cmp 0x140b78,%eax 1173ef: 75 13 jne 117404 <== NEVER TAKEN _Thread_Dispatch_necessary = true; 1173f1: c6 05 84 0b 14 00 01 movb $0x1,0x140b84 1173f8: eb 0a jmp 117404 1173fa: 66 90 xchg %ax,%ax rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 1173fc: 9c pushf 1173fd: fa cli 1173fe: 58 pop %eax *signal_set |= signals; 1173ff: 09 5a 18 or %ebx,0x18(%edx) _ISR_Enable( _level ); 117402: 50 push %eax 117403: 9d popf } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 117404: e8 0b 3f 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 117409: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11740b: 8b 5d fc mov -0x4(%ebp),%ebx 11740e: c9 leave 11740f: c3 ret _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 117410: e8 ff 3e 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_NOT_DEFINED; 117415: b8 0b 00 00 00 mov $0xb,%eax 11741a: e9 7c ff ff ff jmp 11739b =============================================================================== 00106f90 : * rtems_stack_checker_Begin_extension */ void rtems_stack_checker_begin_extension( Thread_Control *the_thread ) { 106f90: 55 push %ebp 106f91: 89 e5 mov %esp,%ebp 106f93: 57 push %edi 106f94: 56 push %esi 106f95: 8b 45 08 mov 0x8(%ebp),%eax Stack_check_Control *the_pattern; if ( the_thread->Object.id == 0 ) /* skip system tasks */ 106f98: 8b 48 08 mov 0x8(%eax),%ecx 106f9b: 85 c9 test %ecx,%ecx 106f9d: 74 15 je 106fb4 <== NEVER TAKEN return; the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack); *the_pattern = Stack_check_Pattern; 106f9f: 8b b8 b8 00 00 00 mov 0xb8(%eax),%edi 106fa5: 83 c7 08 add $0x8,%edi 106fa8: be 20 69 12 00 mov $0x126920,%esi 106fad: b9 04 00 00 00 mov $0x4,%ecx 106fb2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } 106fb4: 5e pop %esi 106fb5: 5f pop %edi 106fb6: c9 leave 106fb7: c3 ret =============================================================================== 00106f68 : */ bool rtems_stack_checker_create_extension( Thread_Control *running __attribute__((unused)), Thread_Control *the_thread ) { 106f68: 55 push %ebp 106f69: 89 e5 mov %esp,%ebp 106f6b: 57 push %edi 106f6c: 8b 7d 0c mov 0xc(%ebp),%edi Stack_check_Initialize(); 106f6f: e8 88 ff ff ff call 106efc if (the_thread) 106f74: 85 ff test %edi,%edi 106f76: 74 12 je 106f8a <== NEVER TAKEN Stack_check_Dope_stack(&the_thread->Start.Initial_stack); 106f78: 8b 8f b4 00 00 00 mov 0xb4(%edi),%ecx 106f7e: 8b 97 b8 00 00 00 mov 0xb8(%edi),%edx 106f84: b0 a5 mov $0xa5,%al 106f86: 89 d7 mov %edx,%edi 106f88: f3 aa rep stos %al,%es:(%edi) return true; } 106f8a: b0 01 mov $0x1,%al 106f8c: 5f pop %edi 106f8d: c9 leave 106f8e: c3 ret =============================================================================== 001070cc : /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) { 1070cc: 55 push %ebp 1070cd: 89 e5 mov %esp,%ebp 1070cf: 57 push %edi 1070d0: 56 push %esi Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 1070d1: a1 38 6d 12 00 mov 0x126d38,%eax ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 1070d6: 8b b0 b8 00 00 00 mov 0xb8(%eax),%esi 1070dc: 39 f5 cmp %esi,%ebp 1070de: 72 3c jb 10711c <== NEVER TAKEN return false; } if ( sp > (the_stack->area + the_stack->size) ) { 1070e0: 8b 80 b4 00 00 00 mov 0xb4(%eax),%eax 1070e6: 8d 04 06 lea (%esi,%eax,1),%eax } /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) 1070e9: 39 c5 cmp %eax,%ebp 1070eb: 0f 96 c0 setbe %al /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 1070ee: 8b 15 d0 65 12 00 mov 0x1265d0,%edx 1070f4: 85 d2 test %edx,%edx 1070f6: 74 30 je 107128 <== NEVER TAKEN pattern_ok = (!memcmp( 1070f8: 83 c6 08 add $0x8,%esi 1070fb: bf 20 69 12 00 mov $0x126920,%edi 107100: b9 10 00 00 00 mov $0x10,%ecx 107105: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 107107: 0f 94 c2 sete %dl /* * Let's report as much as we can. */ if ( !sp_ok || !pattern_ok ) { 10710a: 84 c0 test %al,%al 10710c: 74 1e je 10712c <== NEVER TAKEN 10710e: 84 d2 test %dl,%dl 107110: 74 1a je 10712c <== NEVER TAKEN /* * The Stack Pointer and the Pattern Area are OK so return false. */ return false; } 107112: 31 c0 xor %eax,%eax 107114: 8d 65 f8 lea -0x8(%ebp),%esp 107117: 5e pop %esi 107118: 5f pop %edi 107119: c9 leave 10711a: c3 ret 10711b: 90 nop { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { return false; 10711c: 31 c0 xor %eax,%eax /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 10711e: 8b 15 d0 65 12 00 mov 0x1265d0,%edx <== NOT EXECUTED 107124: 85 d2 test %edx,%edx <== NOT EXECUTED 107126: 75 d0 jne 1070f8 <== 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; 107128: b2 01 mov $0x1,%dl <== NOT EXECUTED 10712a: eb de jmp 10710a <== NOT EXECUTED /* * Let's report as much as we can. */ if ( !sp_ok || !pattern_ok ) { Stack_check_report_blown_task( _Thread_Executing, pattern_ok ); 10712c: 57 push %edi <== NOT EXECUTED 10712d: 57 push %edi <== NOT EXECUTED 10712e: 0f b6 d2 movzbl %dl,%edx <== NOT EXECUTED 107131: 52 push %edx <== NOT EXECUTED 107132: ff 35 38 6d 12 00 pushl 0x126d38 <== NOT EXECUTED 107138: e8 7b fe ff ff call 106fb8 <== NOT EXECUTED =============================================================================== 001071a8 : void rtems_stack_checker_report_usage( void ) { 1071a8: 55 push %ebp <== NOT EXECUTED 1071a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1071ab: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin ); 1071ae: 68 7c 88 10 00 push $0x10887c <== NOT EXECUTED 1071b3: 6a 00 push $0x0 <== NOT EXECUTED 1071b5: e8 86 ff ff ff call 107140 <== NOT EXECUTED 1071ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1071bd: c9 leave <== NOT EXECUTED 1071be: c3 ret <== NOT EXECUTED =============================================================================== 00107140 : void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) { 107140: 55 push %ebp <== NOT EXECUTED 107141: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107143: 56 push %esi <== NOT EXECUTED 107144: 53 push %ebx <== NOT EXECUTED 107145: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 107148: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED if ( !print ) 10714b: 85 db test %ebx,%ebx <== NOT EXECUTED 10714d: 74 50 je 10719f <== NOT EXECUTED return; print_context = context; 10714f: 89 35 c8 65 12 00 mov %esi,0x1265c8 <== NOT EXECUTED print_handler = print; 107155: 89 1d cc 65 12 00 mov %ebx,0x1265cc <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 10715b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10715e: 68 8c 01 12 00 push $0x12018c <== NOT EXECUTED 107163: 56 push %esi <== NOT EXECUTED 107164: ff d3 call *%ebx <== NOT EXECUTED (*print)( context, 107166: 59 pop %ecx <== NOT EXECUTED 107167: 58 pop %eax <== NOT EXECUTED 107168: 68 10 02 12 00 push $0x120210 <== NOT EXECUTED 10716d: 56 push %esi <== NOT EXECUTED 10716e: 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 ); 107170: c7 04 24 90 6d 10 00 movl $0x106d90,(%esp) <== NOT EXECUTED 107177: e8 78 4f 00 00 call 10c0f4 <== NOT EXECUTED #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) /* dump interrupt stack info if any */ Stack_check_Dump_threads_usage((Thread_Control *) -1); 10717c: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED 107183: e8 08 fc ff ff call 106d90 <== NOT EXECUTED #endif print_context = NULL; 107188: c7 05 c8 65 12 00 00 movl $0x0,0x1265c8 <== NOT EXECUTED 10718f: 00 00 00 print_handler = NULL; 107192: c7 05 cc 65 12 00 00 movl $0x0,0x1265cc <== NOT EXECUTED 107199: 00 00 00 10719c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10719f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1071a2: 5b pop %ebx <== NOT EXECUTED 1071a3: 5e pop %esi <== NOT EXECUTED 1071a4: c9 leave <== NOT EXECUTED 1071a5: c3 ret <== NOT EXECUTED =============================================================================== 00107074 : */ void rtems_stack_checker_switch_extension( Thread_Control *running __attribute__((unused)), Thread_Control *heir __attribute__((unused)) ) { 107074: 55 push %ebp 107075: 89 e5 mov %esp,%ebp 107077: 57 push %edi 107078: 56 push %esi 107079: 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); 10707c: 8b 90 b8 00 00 00 mov 0xb8(%eax),%edx 107082: 8d 72 08 lea 0x8(%edx),%esi ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 107085: 39 d5 cmp %edx,%ebp 107087: 72 0a jb 107093 <== NEVER TAKEN return false; } if ( sp > (the_stack->area + the_stack->size) ) { 107089: 03 90 b4 00 00 00 add 0xb4(%eax),%edx 10708f: 39 d5 cmp %edx,%ebp 107091: 76 1d jbe 1070b0 <== 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, 107093: bf 20 69 12 00 mov $0x126920,%edi <== NOT EXECUTED 107098: b9 10 00 00 00 mov $0x10,%ecx <== NOT EXECUTED 10709d: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 10709f: 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 ); 1070a2: 56 push %esi <== NOT EXECUTED 1070a3: 56 push %esi <== NOT EXECUTED 1070a4: 0f b6 d2 movzbl %dl,%edx <== NOT EXECUTED 1070a7: 52 push %edx <== NOT EXECUTED 1070a8: 50 push %eax <== NOT EXECUTED 1070a9: e8 0a ff ff ff call 106fb8 <== NOT EXECUTED 1070ae: 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, 1070b0: bf 20 69 12 00 mov $0x126920,%edi 1070b5: b9 10 00 00 00 mov $0x10,%ecx (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { 1070ba: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 1070bc: 75 07 jne 1070c5 <== NEVER TAKEN Stack_check_report_blown_task( running, pattern_ok ); } } 1070be: 8d 65 f8 lea -0x8(%ebp),%esp 1070c1: 5e pop %esi 1070c2: 5f pop %edi 1070c3: c9 leave 1070c4: 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 ) { 1070c5: 31 d2 xor %edx,%edx <== NOT EXECUTED 1070c7: eb d9 jmp 1070a2 <== NOT EXECUTED =============================================================================== 0010fdd0 : rtems_status_code rtems_string_to_double ( const char *s, double *n, char **endptr ) { 10fdd0: 55 push %ebp 10fdd1: 89 e5 mov %esp,%ebp 10fdd3: 57 push %edi 10fdd4: 56 push %esi 10fdd5: 53 push %ebx 10fdd6: 83 ec 2c sub $0x2c,%esp 10fdd9: 8b 75 08 mov 0x8(%ebp),%esi 10fddc: 8b 5d 0c mov 0xc(%ebp),%ebx 10fddf: 8b 7d 10 mov 0x10(%ebp),%edi double result; char *end; if ( !n ) 10fde2: 85 db test %ebx,%ebx 10fde4: 0f 84 b2 00 00 00 je 10fe9c return RTEMS_INVALID_ADDRESS; errno = 0; 10fdea: e8 4d 28 00 00 call 11263c <__errno> 10fdef: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10fdf5: c7 03 00 00 00 00 movl $0x0,(%ebx) 10fdfb: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) result = strtod( s, &end ); 10fe02: 83 ec 08 sub $0x8,%esp 10fe05: 8d 45 e4 lea -0x1c(%ebp),%eax 10fe08: 50 push %eax 10fe09: 56 push %esi 10fe0a: e8 39 52 00 00 call 115048 if ( endptr ) 10fe0f: 83 c4 10 add $0x10,%esp 10fe12: 85 ff test %edi,%edi 10fe14: 0f 84 92 00 00 00 je 10feac *endptr = end; 10fe1a: 8b 45 e4 mov -0x1c(%ebp),%eax 10fe1d: 89 07 mov %eax,(%edi) if ( end == s ) 10fe1f: 39 c6 cmp %eax,%esi 10fe21: 74 69 je 10fe8c return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10fe23: dd 5d c8 fstpl -0x38(%ebp) 10fe26: e8 11 28 00 00 call 11263c <__errno> 10fe2b: 83 38 22 cmpl $0x22,(%eax) 10fe2e: dd 45 c8 fldl -0x38(%ebp) 10fe31: 74 0d je 10fe40 (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL ))) return RTEMS_INVALID_NUMBER; *n = result; 10fe33: dd 1b fstpl (%ebx) return RTEMS_SUCCESSFUL; 10fe35: 31 c0 xor %eax,%eax } 10fe37: 8d 65 f4 lea -0xc(%ebp),%esp 10fe3a: 5b pop %ebx 10fe3b: 5e pop %esi 10fe3c: 5f pop %edi 10fe3d: c9 leave 10fe3e: c3 ret 10fe3f: 90 nop *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10fe40: d9 ee fldz 10fe42: d9 c9 fxch %st(1) 10fe44: dd e1 fucom %st(1) 10fe46: df e0 fnstsw %ax 10fe48: dd d9 fstp %st(1) 10fe4a: 80 e4 45 and $0x45,%ah 10fe4d: 80 fc 40 cmp $0x40,%ah 10fe50: 74 26 je 10fe78 <== NEVER TAKEN (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL ))) 10fe52: dd 05 90 47 12 00 fldl 0x124790 10fe58: d9 c9 fxch %st(1) 10fe5a: dd e1 fucom %st(1) 10fe5c: df e0 fnstsw %ax 10fe5e: dd d9 fstp %st(1) 10fe60: f6 c4 45 test $0x45,%ah 10fe63: 74 17 je 10fe7c <== ALWAYS TAKEN 10fe65: dd 05 98 47 12 00 fldl 0x124798 <== NOT EXECUTED 10fe6b: dd e9 fucomp %st(1) <== NOT EXECUTED 10fe6d: df e0 fnstsw %ax <== NOT EXECUTED 10fe6f: f6 c4 45 test $0x45,%ah <== NOT EXECUTED 10fe72: 75 bf jne 10fe33 <== NOT EXECUTED 10fe74: dd d8 fstp %st(0) <== NOT EXECUTED 10fe76: eb 06 jmp 10fe7e <== NOT EXECUTED 10fe78: dd d8 fstp %st(0) <== NOT EXECUTED 10fe7a: eb 02 jmp 10fe7e <== NOT EXECUTED 10fe7c: dd d8 fstp %st(0) return RTEMS_INVALID_NUMBER; 10fe7e: b8 0a 00 00 00 mov $0xa,%eax *n = result; return RTEMS_SUCCESSFUL; } 10fe83: 8d 65 f4 lea -0xc(%ebp),%esp 10fe86: 5b pop %ebx 10fe87: 5e pop %esi 10fe88: 5f pop %edi 10fe89: c9 leave 10fe8a: c3 ret 10fe8b: 90 nop 10fe8c: dd d8 fstp %st(0) if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 10fe8e: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 10fe93: 8d 65 f4 lea -0xc(%ebp),%esp 10fe96: 5b pop %ebx 10fe97: 5e pop %esi 10fe98: 5f pop %edi 10fe99: c9 leave 10fe9a: c3 ret 10fe9b: 90 nop { double result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10fe9c: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 10fea1: 8d 65 f4 lea -0xc(%ebp),%esp 10fea4: 5b pop %ebx 10fea5: 5e pop %esi 10fea6: 5f pop %edi 10fea7: c9 leave 10fea8: c3 ret 10fea9: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtod( s, &end ); if ( endptr ) 10feac: 8b 45 e4 mov -0x1c(%ebp),%eax 10feaf: e9 6b ff ff ff jmp 10fe1f =============================================================================== 0010feb4 : rtems_status_code rtems_string_to_float ( const char *s, float *n, char **endptr ) { 10feb4: 55 push %ebp 10feb5: 89 e5 mov %esp,%ebp 10feb7: 57 push %edi 10feb8: 56 push %esi 10feb9: 53 push %ebx 10feba: 83 ec 2c sub $0x2c,%esp 10febd: 8b 75 08 mov 0x8(%ebp),%esi 10fec0: 8b 5d 0c mov 0xc(%ebp),%ebx 10fec3: 8b 7d 10 mov 0x10(%ebp),%edi float result; char *end; if ( !n ) 10fec6: 85 db test %ebx,%ebx 10fec8: 0f 84 aa 00 00 00 je 10ff78 return RTEMS_INVALID_ADDRESS; errno = 0; 10fece: e8 69 27 00 00 call 11263c <__errno> 10fed3: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10fed9: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtof( s, &end ); 10fedf: 83 ec 08 sub $0x8,%esp 10fee2: 8d 45 e4 lea -0x1c(%ebp),%eax 10fee5: 50 push %eax 10fee6: 56 push %esi 10fee7: e8 78 51 00 00 call 115064 if ( endptr ) 10feec: 83 c4 10 add $0x10,%esp 10feef: 85 ff test %edi,%edi 10fef1: 0f 84 91 00 00 00 je 10ff88 *endptr = end; 10fef7: 8b 45 e4 mov -0x1c(%ebp),%eax 10fefa: 89 07 mov %eax,(%edi) if ( end == s ) 10fefc: 39 c6 cmp %eax,%esi 10fefe: 74 68 je 10ff68 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10ff00: d9 5d c8 fstps -0x38(%ebp) 10ff03: e8 34 27 00 00 call 11263c <__errno> 10ff08: 83 38 22 cmpl $0x22,(%eax) 10ff0b: d9 45 c8 flds -0x38(%ebp) 10ff0e: 74 0c je 10ff1c (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF ))) return RTEMS_INVALID_NUMBER; *n = result; 10ff10: d9 1b fstps (%ebx) return RTEMS_SUCCESSFUL; 10ff12: 31 c0 xor %eax,%eax } 10ff14: 8d 65 f4 lea -0xc(%ebp),%esp 10ff17: 5b pop %ebx 10ff18: 5e pop %esi 10ff19: 5f pop %edi 10ff1a: c9 leave 10ff1b: c3 ret *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10ff1c: d9 ee fldz 10ff1e: d9 c9 fxch %st(1) 10ff20: dd e1 fucom %st(1) 10ff22: df e0 fnstsw %ax 10ff24: dd d9 fstp %st(1) 10ff26: 80 e4 45 and $0x45,%ah 10ff29: 80 fc 40 cmp $0x40,%ah 10ff2c: 74 26 je 10ff54 <== NEVER TAKEN (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF ))) 10ff2e: d9 05 a0 47 12 00 flds 0x1247a0 10ff34: d9 c9 fxch %st(1) 10ff36: dd e1 fucom %st(1) 10ff38: df e0 fnstsw %ax 10ff3a: dd d9 fstp %st(1) 10ff3c: f6 c4 45 test $0x45,%ah 10ff3f: 74 17 je 10ff58 <== ALWAYS TAKEN 10ff41: d9 05 a4 47 12 00 flds 0x1247a4 <== NOT EXECUTED 10ff47: dd e9 fucomp %st(1) <== NOT EXECUTED 10ff49: df e0 fnstsw %ax <== NOT EXECUTED 10ff4b: f6 c4 45 test $0x45,%ah <== NOT EXECUTED 10ff4e: 75 c0 jne 10ff10 <== NOT EXECUTED 10ff50: dd d8 fstp %st(0) <== NOT EXECUTED 10ff52: eb 06 jmp 10ff5a <== NOT EXECUTED 10ff54: dd d8 fstp %st(0) <== NOT EXECUTED 10ff56: eb 02 jmp 10ff5a <== NOT EXECUTED 10ff58: dd d8 fstp %st(0) return RTEMS_INVALID_NUMBER; 10ff5a: b8 0a 00 00 00 mov $0xa,%eax *n = result; return RTEMS_SUCCESSFUL; } 10ff5f: 8d 65 f4 lea -0xc(%ebp),%esp 10ff62: 5b pop %ebx 10ff63: 5e pop %esi 10ff64: 5f pop %edi 10ff65: c9 leave 10ff66: c3 ret 10ff67: 90 nop 10ff68: dd d8 fstp %st(0) if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 10ff6a: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 10ff6f: 8d 65 f4 lea -0xc(%ebp),%esp 10ff72: 5b pop %ebx 10ff73: 5e pop %esi 10ff74: 5f pop %edi 10ff75: c9 leave 10ff76: c3 ret 10ff77: 90 nop { float result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10ff78: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 10ff7d: 8d 65 f4 lea -0xc(%ebp),%esp 10ff80: 5b pop %ebx 10ff81: 5e pop %esi 10ff82: 5f pop %edi 10ff83: c9 leave 10ff84: c3 ret 10ff85: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtof( s, &end ); if ( endptr ) 10ff88: 8b 45 e4 mov -0x1c(%ebp),%eax 10ff8b: e9 6c ff ff ff jmp 10fefc =============================================================================== 0010ff90 : const char *s, int *n, char **endptr, int base ) { 10ff90: 55 push %ebp 10ff91: 89 e5 mov %esp,%ebp 10ff93: 57 push %edi 10ff94: 56 push %esi 10ff95: 53 push %ebx 10ff96: 83 ec 2c sub $0x2c,%esp 10ff99: 8b 75 08 mov 0x8(%ebp),%esi 10ff9c: 8b 5d 0c mov 0xc(%ebp),%ebx 10ff9f: 8b 7d 10 mov 0x10(%ebp),%edi long result; char *end; if ( !n ) 10ffa2: 85 db test %ebx,%ebx 10ffa4: 0f 84 82 00 00 00 je 11002c <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; errno = 0; 10ffaa: e8 8d 26 00 00 call 11263c <__errno> 10ffaf: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10ffb5: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtol( s, &end, base ); 10ffbb: 50 push %eax 10ffbc: ff 75 14 pushl 0x14(%ebp) 10ffbf: 8d 45 e4 lea -0x1c(%ebp),%eax 10ffc2: 50 push %eax 10ffc3: 56 push %esi 10ffc4: e8 5b 52 00 00 call 115224 10ffc9: 89 c2 mov %eax,%edx if ( endptr ) 10ffcb: 83 c4 10 add $0x10,%esp 10ffce: 85 ff test %edi,%edi 10ffd0: 74 6a je 11003c <== NEVER TAKEN *endptr = end; 10ffd2: 8b 45 e4 mov -0x1c(%ebp),%eax 10ffd5: 89 07 mov %eax,(%edi) if ( end == s ) 10ffd7: 39 c6 cmp %eax,%esi 10ffd9: 74 41 je 11001c <== NEVER TAKEN return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10ffdb: 89 55 d4 mov %edx,-0x2c(%ebp) 10ffde: e8 59 26 00 00 call 11263c <__errno> 10ffe3: 83 38 22 cmpl $0x22,(%eax) 10ffe6: 8b 55 d4 mov -0x2c(%ebp),%edx 10ffe9: 74 0d je 10fff8 errno = ERANGE; return RTEMS_INVALID_NUMBER; } #endif *n = result; 10ffeb: 89 13 mov %edx,(%ebx) return RTEMS_SUCCESSFUL; 10ffed: 31 c0 xor %eax,%eax } 10ffef: 8d 65 f4 lea -0xc(%ebp),%esp 10fff2: 5b pop %ebx 10fff3: 5e pop %esi 10fff4: 5f pop %edi 10fff5: c9 leave 10fff6: c3 ret 10fff7: 90 nop *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10fff8: 85 d2 test %edx,%edx 10fffa: 74 10 je 11000c <== NEVER TAKEN (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) 10fffc: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx 110002: 74 08 je 11000c <== ALWAYS TAKEN 110004: 81 fa 00 00 00 80 cmp $0x80000000,%edx <== NOT EXECUTED 11000a: 75 df jne 10ffeb <== NOT EXECUTED return RTEMS_INVALID_NUMBER; 11000c: b8 0a 00 00 00 mov $0xa,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 110011: 8d 65 f4 lea -0xc(%ebp),%esp 110014: 5b pop %ebx 110015: 5e pop %esi 110016: 5f pop %edi 110017: c9 leave 110018: c3 ret 110019: 8d 76 00 lea 0x0(%esi),%esi if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 11001c: b8 0b 00 00 00 mov $0xb,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 110021: 8d 65 f4 lea -0xc(%ebp),%esp 110024: 5b pop %ebx 110025: 5e pop %esi 110026: 5f pop %edi 110027: c9 leave 110028: c3 ret 110029: 8d 76 00 lea 0x0(%esi),%esi { long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 11002c: b8 09 00 00 00 mov $0x9,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 110031: 8d 65 f4 lea -0xc(%ebp),%esp 110034: 5b pop %ebx 110035: 5e pop %esi 110036: 5f pop %edi 110037: c9 leave 110038: c3 ret 110039: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtol( s, &end, base ); if ( endptr ) 11003c: 8b 45 e4 mov -0x1c(%ebp),%eax 11003f: eb 96 jmp 10ffd7 =============================================================================== 00110110 : const char *s, long *n, char **endptr, int base ) { 110110: 55 push %ebp 110111: 89 e5 mov %esp,%ebp 110113: 57 push %edi 110114: 56 push %esi 110115: 53 push %ebx 110116: 83 ec 2c sub $0x2c,%esp 110119: 8b 75 08 mov 0x8(%ebp),%esi 11011c: 8b 5d 0c mov 0xc(%ebp),%ebx 11011f: 8b 7d 10 mov 0x10(%ebp),%edi long result; char *end; if ( !n ) 110122: 85 db test %ebx,%ebx 110124: 0f 84 82 00 00 00 je 1101ac return RTEMS_INVALID_ADDRESS; errno = 0; 11012a: e8 0d 25 00 00 call 11263c <__errno> 11012f: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110135: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtol( s, &end, base ); 11013b: 50 push %eax 11013c: ff 75 14 pushl 0x14(%ebp) 11013f: 8d 45 e4 lea -0x1c(%ebp),%eax 110142: 50 push %eax 110143: 56 push %esi 110144: e8 db 50 00 00 call 115224 110149: 89 c2 mov %eax,%edx if ( endptr ) 11014b: 83 c4 10 add $0x10,%esp 11014e: 85 ff test %edi,%edi 110150: 74 6a je 1101bc *endptr = end; 110152: 8b 45 e4 mov -0x1c(%ebp),%eax 110155: 89 07 mov %eax,(%edi) if ( end == s ) 110157: 39 c6 cmp %eax,%esi 110159: 74 41 je 11019c return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 11015b: 89 55 d4 mov %edx,-0x2c(%ebp) 11015e: e8 d9 24 00 00 call 11263c <__errno> 110163: 83 38 22 cmpl $0x22,(%eax) 110166: 8b 55 d4 mov -0x2c(%ebp),%edx 110169: 74 0d je 110178 (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) return RTEMS_INVALID_NUMBER; *n = result; 11016b: 89 13 mov %edx,(%ebx) return RTEMS_SUCCESSFUL; 11016d: 31 c0 xor %eax,%eax } 11016f: 8d 65 f4 lea -0xc(%ebp),%esp 110172: 5b pop %ebx 110173: 5e pop %esi 110174: 5f pop %edi 110175: c9 leave 110176: c3 ret 110177: 90 nop *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110178: 85 d2 test %edx,%edx 11017a: 74 10 je 11018c <== NEVER TAKEN (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) 11017c: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx 110182: 74 08 je 11018c 110184: 81 fa 00 00 00 80 cmp $0x80000000,%edx 11018a: 75 df jne 11016b <== NEVER TAKEN return RTEMS_INVALID_NUMBER; 11018c: b8 0a 00 00 00 mov $0xa,%eax *n = result; return RTEMS_SUCCESSFUL; } 110191: 8d 65 f4 lea -0xc(%ebp),%esp 110194: 5b pop %ebx 110195: 5e pop %esi 110196: 5f pop %edi 110197: c9 leave 110198: c3 ret 110199: 8d 76 00 lea 0x0(%esi),%esi if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 11019c: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 1101a1: 8d 65 f4 lea -0xc(%ebp),%esp 1101a4: 5b pop %ebx 1101a5: 5e pop %esi 1101a6: 5f pop %edi 1101a7: c9 leave 1101a8: c3 ret 1101a9: 8d 76 00 lea 0x0(%esi),%esi { long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 1101ac: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 1101b1: 8d 65 f4 lea -0xc(%ebp),%esp 1101b4: 5b pop %ebx 1101b5: 5e pop %esi 1101b6: 5f pop %edi 1101b7: c9 leave 1101b8: c3 ret 1101b9: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtol( s, &end, base ); if ( endptr ) 1101bc: 8b 45 e4 mov -0x1c(%ebp),%eax 1101bf: eb 96 jmp 110157 =============================================================================== 00110044 : const char *s, long long *n, char **endptr, int base ) { 110044: 55 push %ebp 110045: 89 e5 mov %esp,%ebp 110047: 57 push %edi 110048: 56 push %esi 110049: 53 push %ebx 11004a: 83 ec 2c sub $0x2c,%esp 11004d: 8b 5d 0c mov 0xc(%ebp),%ebx 110050: 8b 7d 10 mov 0x10(%ebp),%edi long long result; char *end; if ( !n ) 110053: 85 db test %ebx,%ebx 110055: 0f 84 9d 00 00 00 je 1100f8 return RTEMS_INVALID_ADDRESS; errno = 0; 11005b: e8 dc 25 00 00 call 11263c <__errno> 110060: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110066: c7 03 00 00 00 00 movl $0x0,(%ebx) 11006c: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) result = strtoll( s, &end, base ); 110073: 50 push %eax 110074: ff 75 14 pushl 0x14(%ebp) 110077: 8d 45 e4 lea -0x1c(%ebp),%eax 11007a: 50 push %eax 11007b: ff 75 08 pushl 0x8(%ebp) 11007e: e8 bd 51 00 00 call 115240 110083: 89 c6 mov %eax,%esi if ( endptr ) 110085: 83 c4 10 add $0x10,%esp 110088: 85 ff test %edi,%edi 11008a: 74 7c je 110108 *endptr = end; 11008c: 8b 45 e4 mov -0x1c(%ebp),%eax 11008f: 89 07 mov %eax,(%edi) if ( end == s ) 110091: 39 45 08 cmp %eax,0x8(%ebp) 110094: 74 52 je 1100e8 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110096: 89 55 d4 mov %edx,-0x2c(%ebp) 110099: e8 9e 25 00 00 call 11263c <__errno> 11009e: 83 38 22 cmpl $0x22,(%eax) 1100a1: 8b 55 d4 mov -0x2c(%ebp),%edx 1100a4: 74 12 je 1100b8 (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN ))) return RTEMS_INVALID_NUMBER; *n = result; 1100a6: 89 33 mov %esi,(%ebx) 1100a8: 89 53 04 mov %edx,0x4(%ebx) return RTEMS_SUCCESSFUL; 1100ab: 31 c0 xor %eax,%eax } 1100ad: 8d 65 f4 lea -0xc(%ebp),%esp 1100b0: 5b pop %ebx 1100b1: 5e pop %esi 1100b2: 5f pop %edi 1100b3: c9 leave 1100b4: c3 ret 1100b5: 8d 76 00 lea 0x0(%esi),%esi *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 1100b8: 89 d0 mov %edx,%eax 1100ba: 09 f0 or %esi,%eax 1100bc: 74 1a je 1100d8 <== NEVER TAKEN (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN ))) 1100be: 89 d1 mov %edx,%ecx 1100c0: 81 f1 ff ff ff 7f xor $0x7fffffff,%ecx 1100c6: 89 f0 mov %esi,%eax 1100c8: f7 d0 not %eax 1100ca: 09 c1 or %eax,%ecx 1100cc: 74 0a je 1100d8 1100ce: 8d 82 00 00 00 80 lea -0x80000000(%edx),%eax 1100d4: 09 f0 or %esi,%eax 1100d6: 75 ce jne 1100a6 <== NEVER TAKEN return RTEMS_INVALID_NUMBER; 1100d8: b8 0a 00 00 00 mov $0xa,%eax *n = result; return RTEMS_SUCCESSFUL; } 1100dd: 8d 65 f4 lea -0xc(%ebp),%esp 1100e0: 5b pop %ebx 1100e1: 5e pop %esi 1100e2: 5f pop %edi 1100e3: c9 leave 1100e4: c3 ret 1100e5: 8d 76 00 lea 0x0(%esi),%esi if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 1100e8: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 1100ed: 8d 65 f4 lea -0xc(%ebp),%esp 1100f0: 5b pop %ebx 1100f1: 5e pop %esi 1100f2: 5f pop %edi 1100f3: c9 leave 1100f4: c3 ret 1100f5: 8d 76 00 lea 0x0(%esi),%esi { long long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 1100f8: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 1100fd: 8d 65 f4 lea -0xc(%ebp),%esp 110100: 5b pop %ebx 110101: 5e pop %esi 110102: 5f pop %edi 110103: c9 leave 110104: c3 ret 110105: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtoll( s, &end, base ); if ( endptr ) 110108: 8b 45 e4 mov -0x1c(%ebp),%eax 11010b: eb 84 jmp 110091 =============================================================================== 001101dc : const char *s, unsigned char *n, char **endptr, int base ) { 1101dc: 55 push %ebp 1101dd: 89 e5 mov %esp,%ebp 1101df: 57 push %edi 1101e0: 56 push %esi 1101e1: 53 push %ebx 1101e2: 83 ec 2c sub $0x2c,%esp 1101e5: 8b 75 08 mov 0x8(%ebp),%esi 1101e8: 8b 5d 0c mov 0xc(%ebp),%ebx 1101eb: 8b 7d 10 mov 0x10(%ebp),%edi unsigned long result; char *end; if ( !n ) 1101ee: 85 db test %ebx,%ebx 1101f0: 0f 84 92 00 00 00 je 110288 return RTEMS_INVALID_ADDRESS; errno = 0; 1101f6: e8 41 24 00 00 call 11263c <__errno> 1101fb: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110201: c6 03 00 movb $0x0,(%ebx) result = strtoul( s, &end, base ); 110204: 50 push %eax 110205: ff 75 14 pushl 0x14(%ebp) 110208: 8d 45 e4 lea -0x1c(%ebp),%eax 11020b: 50 push %eax 11020c: 56 push %esi 11020d: e8 ce 54 00 00 call 1156e0 110212: 89 c2 mov %eax,%edx if ( endptr ) 110214: 83 c4 10 add $0x10,%esp 110217: 85 ff test %edi,%edi 110219: 74 7d je 110298 *endptr = end; 11021b: 8b 45 e4 mov -0x1c(%ebp),%eax 11021e: 89 07 mov %eax,(%edi) if ( end == s ) 110220: 39 c6 cmp %eax,%esi 110222: 74 54 je 110278 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110224: 89 55 d4 mov %edx,-0x2c(%ebp) 110227: e8 10 24 00 00 call 11263c <__errno> 11022c: 83 38 22 cmpl $0x22,(%eax) 11022f: 8b 55 d4 mov -0x2c(%ebp),%edx 110232: 74 14 je 110248 <== NEVER TAKEN (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; #if (UCHAR_MAX < ULONG_MAX) if ( result > UCHAR_MAX ) { 110234: 81 fa ff 00 00 00 cmp $0xff,%edx 11023a: 77 24 ja 110260 <== NEVER TAKEN errno = ERANGE; return RTEMS_INVALID_NUMBER; } #endif *n = result; 11023c: 88 13 mov %dl,(%ebx) return RTEMS_SUCCESSFUL; 11023e: 31 c0 xor %eax,%eax } 110240: 8d 65 f4 lea -0xc(%ebp),%esp 110243: 5b pop %ebx 110244: 5e pop %esi 110245: 5f pop %edi 110246: c9 leave 110247: c3 ret if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == ULONG_MAX ))) 110248: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 11024b: 83 f8 fd cmp $0xfffffffd,%eax <== NOT EXECUTED 11024e: 76 e4 jbe 110234 <== NOT EXECUTED (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; 110250: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED #endif *n = result; return RTEMS_SUCCESSFUL; } 110255: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 110258: 5b pop %ebx <== NOT EXECUTED 110259: 5e pop %esi <== NOT EXECUTED 11025a: 5f pop %edi <== NOT EXECUTED 11025b: c9 leave <== NOT EXECUTED 11025c: c3 ret <== NOT EXECUTED 11025d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; #if (UCHAR_MAX < ULONG_MAX) if ( result > UCHAR_MAX ) { errno = ERANGE; 110260: e8 d7 23 00 00 call 11263c <__errno> <== NOT EXECUTED 110265: c7 00 22 00 00 00 movl $0x22,(%eax) <== NOT EXECUTED return RTEMS_INVALID_NUMBER; 11026b: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED #endif *n = result; return RTEMS_SUCCESSFUL; } 110270: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 110273: 5b pop %ebx <== NOT EXECUTED 110274: 5e pop %esi <== NOT EXECUTED 110275: 5f pop %edi <== NOT EXECUTED 110276: c9 leave <== NOT EXECUTED 110277: c3 ret <== NOT EXECUTED if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 110278: b8 0b 00 00 00 mov $0xb,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 11027d: 8d 65 f4 lea -0xc(%ebp),%esp 110280: 5b pop %ebx 110281: 5e pop %esi 110282: 5f pop %edi 110283: c9 leave 110284: c3 ret 110285: 8d 76 00 lea 0x0(%esi),%esi { unsigned long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 110288: b8 09 00 00 00 mov $0x9,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 11028d: 8d 65 f4 lea -0xc(%ebp),%esp 110290: 5b pop %ebx 110291: 5e pop %esi 110292: 5f pop %edi 110293: c9 leave 110294: c3 ret 110295: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtoul( s, &end, base ); if ( endptr ) 110298: 8b 45 e4 mov -0x1c(%ebp),%eax 11029b: eb 83 jmp 110220 =============================================================================== 001102a0 : const char *s, unsigned int *n, char **endptr, int base ) { 1102a0: 55 push %ebp 1102a1: 89 e5 mov %esp,%ebp 1102a3: 57 push %edi 1102a4: 56 push %esi 1102a5: 53 push %ebx 1102a6: 83 ec 2c sub $0x2c,%esp 1102a9: 8b 75 08 mov 0x8(%ebp),%esi 1102ac: 8b 5d 0c mov 0xc(%ebp),%ebx 1102af: 8b 7d 10 mov 0x10(%ebp),%edi unsigned long result; char *end; if ( !n ) 1102b2: 85 db test %ebx,%ebx 1102b4: 74 76 je 11032c return RTEMS_INVALID_ADDRESS; errno = 0; 1102b6: e8 81 23 00 00 call 11263c <__errno> 1102bb: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 1102c1: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtoul( s, &end, base ); 1102c7: 50 push %eax 1102c8: ff 75 14 pushl 0x14(%ebp) 1102cb: 8d 45 e4 lea -0x1c(%ebp),%eax 1102ce: 50 push %eax 1102cf: 56 push %esi 1102d0: e8 0b 54 00 00 call 1156e0 1102d5: 89 c2 mov %eax,%edx if ( endptr ) 1102d7: 83 c4 10 add $0x10,%esp 1102da: 85 ff test %edi,%edi 1102dc: 74 5e je 11033c *endptr = end; 1102de: 8b 45 e4 mov -0x1c(%ebp),%eax 1102e1: 89 07 mov %eax,(%edi) if ( end == s ) 1102e3: 39 c6 cmp %eax,%esi 1102e5: 74 35 je 11031c return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 1102e7: 89 55 d4 mov %edx,-0x2c(%ebp) 1102ea: e8 4d 23 00 00 call 11263c <__errno> 1102ef: 83 38 22 cmpl $0x22,(%eax) 1102f2: 8b 55 d4 mov -0x2c(%ebp),%edx 1102f5: 74 0d je 110304 errno = ERANGE; return RTEMS_INVALID_NUMBER; } #endif *n = result; 1102f7: 89 13 mov %edx,(%ebx) return RTEMS_SUCCESSFUL; 1102f9: 31 c0 xor %eax,%eax } 1102fb: 8d 65 f4 lea -0xc(%ebp),%esp 1102fe: 5b pop %ebx 1102ff: 5e pop %esi 110300: 5f pop %edi 110301: c9 leave 110302: c3 ret 110303: 90 nop if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == ULONG_MAX ))) 110304: 8d 42 ff lea -0x1(%edx),%eax *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110307: 83 f8 fd cmp $0xfffffffd,%eax 11030a: 76 eb jbe 1102f7 <== NEVER TAKEN (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; 11030c: b8 0a 00 00 00 mov $0xa,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 110311: 8d 65 f4 lea -0xc(%ebp),%esp 110314: 5b pop %ebx 110315: 5e pop %esi 110316: 5f pop %edi 110317: c9 leave 110318: c3 ret 110319: 8d 76 00 lea 0x0(%esi),%esi if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 11031c: b8 0b 00 00 00 mov $0xb,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 110321: 8d 65 f4 lea -0xc(%ebp),%esp 110324: 5b pop %ebx 110325: 5e pop %esi 110326: 5f pop %edi 110327: c9 leave 110328: c3 ret 110329: 8d 76 00 lea 0x0(%esi),%esi { unsigned long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 11032c: b8 09 00 00 00 mov $0x9,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 110331: 8d 65 f4 lea -0xc(%ebp),%esp 110334: 5b pop %ebx 110335: 5e pop %esi 110336: 5f pop %edi 110337: c9 leave 110338: c3 ret 110339: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtoul( s, &end, base ); if ( endptr ) 11033c: 8b 45 e4 mov -0x1c(%ebp),%eax 11033f: eb a2 jmp 1102e3 =============================================================================== 0011040c : const char *s, unsigned long *n, char **endptr, int base ) { 11040c: 55 push %ebp 11040d: 89 e5 mov %esp,%ebp 11040f: 57 push %edi 110410: 56 push %esi 110411: 53 push %ebx 110412: 83 ec 2c sub $0x2c,%esp 110415: 8b 75 08 mov 0x8(%ebp),%esi 110418: 8b 5d 0c mov 0xc(%ebp),%ebx 11041b: 8b 7d 10 mov 0x10(%ebp),%edi unsigned long result; char *end; if ( !n ) 11041e: 85 db test %ebx,%ebx 110420: 74 76 je 110498 return RTEMS_INVALID_ADDRESS; errno = 0; 110422: e8 15 22 00 00 call 11263c <__errno> 110427: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 11042d: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtoul( s, &end, base ); 110433: 50 push %eax 110434: ff 75 14 pushl 0x14(%ebp) 110437: 8d 45 e4 lea -0x1c(%ebp),%eax 11043a: 50 push %eax 11043b: 56 push %esi 11043c: e8 9f 52 00 00 call 1156e0 110441: 89 c2 mov %eax,%edx if ( endptr ) 110443: 83 c4 10 add $0x10,%esp 110446: 85 ff test %edi,%edi 110448: 74 5e je 1104a8 *endptr = end; 11044a: 8b 45 e4 mov -0x1c(%ebp),%eax 11044d: 89 07 mov %eax,(%edi) if ( end == s ) 11044f: 39 c6 cmp %eax,%esi 110451: 74 35 je 110488 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110453: 89 55 d4 mov %edx,-0x2c(%ebp) 110456: e8 e1 21 00 00 call 11263c <__errno> 11045b: 83 38 22 cmpl $0x22,(%eax) 11045e: 8b 55 d4 mov -0x2c(%ebp),%edx 110461: 74 0d je 110470 (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; *n = result; 110463: 89 13 mov %edx,(%ebx) return RTEMS_SUCCESSFUL; 110465: 31 c0 xor %eax,%eax } 110467: 8d 65 f4 lea -0xc(%ebp),%esp 11046a: 5b pop %ebx 11046b: 5e pop %esi 11046c: 5f pop %edi 11046d: c9 leave 11046e: c3 ret 11046f: 90 nop if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == ULONG_MAX ))) 110470: 8d 42 ff lea -0x1(%edx),%eax *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110473: 83 f8 fd cmp $0xfffffffd,%eax 110476: 76 eb jbe 110463 <== NEVER TAKEN (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; 110478: b8 0a 00 00 00 mov $0xa,%eax *n = result; return RTEMS_SUCCESSFUL; } 11047d: 8d 65 f4 lea -0xc(%ebp),%esp 110480: 5b pop %ebx 110481: 5e pop %esi 110482: 5f pop %edi 110483: c9 leave 110484: c3 ret 110485: 8d 76 00 lea 0x0(%esi),%esi if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 110488: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 11048d: 8d 65 f4 lea -0xc(%ebp),%esp 110490: 5b pop %ebx 110491: 5e pop %esi 110492: 5f pop %edi 110493: c9 leave 110494: c3 ret 110495: 8d 76 00 lea 0x0(%esi),%esi { unsigned long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 110498: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 11049d: 8d 65 f4 lea -0xc(%ebp),%esp 1104a0: 5b pop %ebx 1104a1: 5e pop %esi 1104a2: 5f pop %edi 1104a3: c9 leave 1104a4: c3 ret 1104a5: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtoul( s, &end, base ); if ( endptr ) 1104a8: 8b 45 e4 mov -0x1c(%ebp),%eax 1104ab: eb a2 jmp 11044f =============================================================================== 00110344 : const char *s, unsigned long long *n, char **endptr, int base ) { 110344: 55 push %ebp 110345: 89 e5 mov %esp,%ebp 110347: 57 push %edi 110348: 56 push %esi 110349: 53 push %ebx 11034a: 83 ec 2c sub $0x2c,%esp 11034d: 8b 7d 08 mov 0x8(%ebp),%edi 110350: 8b 5d 0c mov 0xc(%ebp),%ebx 110353: 8b 75 10 mov 0x10(%ebp),%esi unsigned long long result; char *end; if ( !n ) 110356: 85 db test %ebx,%ebx 110358: 0f 84 96 00 00 00 je 1103f4 return RTEMS_INVALID_ADDRESS; errno = 0; 11035e: e8 d9 22 00 00 call 11263c <__errno> 110363: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 110369: c7 03 00 00 00 00 movl $0x0,(%ebx) 11036f: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) result = strtoull( s, &end, base ); 110376: 50 push %eax 110377: ff 75 14 pushl 0x14(%ebp) 11037a: 8d 45 e4 lea -0x1c(%ebp),%eax 11037d: 50 push %eax 11037e: 57 push %edi 11037f: e8 78 53 00 00 call 1156fc 110384: 89 d1 mov %edx,%ecx 110386: 89 c2 mov %eax,%edx if ( endptr ) 110388: 83 c4 10 add $0x10,%esp 11038b: 85 f6 test %esi,%esi 11038d: 74 75 je 110404 *endptr = end; 11038f: 8b 45 e4 mov -0x1c(%ebp),%eax 110392: 89 06 mov %eax,(%esi) if ( end == s ) 110394: 39 c7 cmp %eax,%edi 110396: 74 4c je 1103e4 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 110398: 89 55 d4 mov %edx,-0x2c(%ebp) 11039b: 89 4d d0 mov %ecx,-0x30(%ebp) 11039e: e8 99 22 00 00 call 11263c <__errno> 1103a3: 83 38 22 cmpl $0x22,(%eax) 1103a6: 8b 55 d4 mov -0x2c(%ebp),%edx 1103a9: 8b 4d d0 mov -0x30(%ebp),%ecx 1103ac: 74 12 je 1103c0 (( result == 0 ) || ( result == ULONG_LONG_MAX ))) return RTEMS_INVALID_NUMBER; *n = result; 1103ae: 89 13 mov %edx,(%ebx) 1103b0: 89 4b 04 mov %ecx,0x4(%ebx) return RTEMS_SUCCESSFUL; 1103b3: 31 c0 xor %eax,%eax } 1103b5: 8d 65 f4 lea -0xc(%ebp),%esp 1103b8: 5b pop %ebx 1103b9: 5e pop %esi 1103ba: 5f pop %edi 1103bb: c9 leave 1103bc: c3 ret 1103bd: 8d 76 00 lea 0x0(%esi),%esi if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == ULONG_LONG_MAX ))) 1103c0: 89 d6 mov %edx,%esi 1103c2: 89 cf mov %ecx,%edi 1103c4: 83 c6 ff add $0xffffffff,%esi 1103c7: 83 d7 ff adc $0xffffffff,%edi *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 1103ca: 83 ff ff cmp $0xffffffff,%edi 1103cd: 72 df jb 1103ae <== NEVER TAKEN 1103cf: 83 fe fd cmp $0xfffffffd,%esi 1103d2: 76 da jbe 1103ae <== NEVER TAKEN (( result == 0 ) || ( result == ULONG_LONG_MAX ))) return RTEMS_INVALID_NUMBER; 1103d4: b8 0a 00 00 00 mov $0xa,%eax *n = result; return RTEMS_SUCCESSFUL; } 1103d9: 8d 65 f4 lea -0xc(%ebp),%esp 1103dc: 5b pop %ebx 1103dd: 5e pop %esi 1103de: 5f pop %edi 1103df: c9 leave 1103e0: c3 ret 1103e1: 8d 76 00 lea 0x0(%esi),%esi if ( endptr ) *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; 1103e4: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 1103e9: 8d 65 f4 lea -0xc(%ebp),%esp 1103ec: 5b pop %ebx 1103ed: 5e pop %esi 1103ee: 5f pop %edi 1103ef: c9 leave 1103f0: c3 ret 1103f1: 8d 76 00 lea 0x0(%esi),%esi { unsigned long long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 1103f4: b8 09 00 00 00 mov $0x9,%eax return RTEMS_INVALID_NUMBER; *n = result; return RTEMS_SUCCESSFUL; } 1103f9: 8d 65 f4 lea -0xc(%ebp),%esp 1103fc: 5b pop %ebx 1103fd: 5e pop %esi 1103fe: 5f pop %edi 1103ff: c9 leave 110400: c3 ret 110401: 8d 76 00 lea 0x0(%esi),%esi errno = 0; *n = 0; result = strtoull( s, &end, base ); if ( endptr ) 110404: 8b 45 e4 mov -0x1c(%ebp),%eax 110407: eb 8b jmp 110394 =============================================================================== 00107394 : int rtems_tarfs_load( char *mountpoint, uint8_t *tar_image, size_t tar_size ) { 107394: 55 push %ebp 107395: 89 e5 mov %esp,%ebp 107397: 57 push %edi 107398: 56 push %esi 107399: 53 push %ebx 10739a: 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( 1073a0: 31 c0 xor %eax,%eax 1073a2: b9 ff ff ff ff mov $0xffffffff,%ecx 1073a7: 8b 7d 08 mov 0x8(%ebp),%edi 1073aa: f2 ae repnz scas %es:(%edi),%al 1073ac: f7 d1 not %ecx 1073ae: 49 dec %ecx 1073af: 6a 00 push $0x0 1073b1: 8d 45 d0 lea -0x30(%ebp),%eax 1073b4: 89 85 2c fe ff ff mov %eax,-0x1d4(%ebp) 1073ba: 50 push %eax 1073bb: 6a 00 push $0x0 1073bd: 51 push %ecx 1073be: ff 75 08 pushl 0x8(%ebp) 1073c1: e8 9a 0a 00 00 call 107e60 1073c6: 89 85 44 fe ff ff mov %eax,-0x1bc(%ebp) strlen(mountpoint), 0, &root_loc, 0 ); if (status != 0) 1073cc: 83 c4 20 add $0x20,%esp 1073cf: 85 c0 test %eax,%eax 1073d1: 0f 85 61 01 00 00 jne 107538 return -1; if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops) 1073d7: 8b 45 dc mov -0x24(%ebp),%eax 1073da: 3d 20 52 12 00 cmp $0x125220,%eax 1073df: 0f 85 47 01 00 00 jne 10752c 1073e5: 31 db xor %ebx,%ebx * should not have this path. */ else if (linkflag == REGTYPE) { const char *name; loc = root_loc; 1073e7: 8d 45 bc lea -0x44(%ebp),%eax 1073ea: 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); 1073f0: 8d 95 58 fe ff ff lea -0x1a8(%ebp),%edx 1073f6: 89 95 34 fe ff ff mov %edx,-0x1cc(%ebp) 1073fc: eb 15 jmp 107413 1073fe: 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) { 107400: 80 bd 53 fe ff ff 30 cmpb $0x30,-0x1ad(%ebp) 107407: 0f 84 43 01 00 00 je 107550 0 ); if (status != 0) return -1; if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops) 10740d: 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) 107413: 8d 83 00 02 00 00 lea 0x200(%ebx),%eax 107419: 89 85 54 fe ff ff mov %eax,-0x1ac(%ebp) 10741f: 8b 55 10 mov 0x10(%ebp),%edx 107422: 39 d0 cmp %edx,%eax 107424: 0f 87 18 01 00 00 ja 107542 <== NEVER TAKEN break; /* * Read a header. */ hdr_ptr = (char *) &tar_image[offset]; 10742a: 03 5d 0c add 0xc(%ebp),%ebx offset += 512; if (strncmp(&hdr_ptr[257], "ustar", 5)) 10742d: 8d b3 01 01 00 00 lea 0x101(%ebx),%esi 107433: bf 68 52 12 00 mov $0x125268,%edi 107438: b9 05 00 00 00 mov $0x5,%ecx 10743d: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10743f: 0f 85 fd 00 00 00 jne 107542 break; strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE); 107445: 57 push %edi 107446: 6a 63 push $0x63 107448: 53 push %ebx 107449: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax 10744f: 50 push %eax 107450: e8 f7 ed 00 00 call 11624c filename[MAX_NAME_FIELD_SIZE] = '\0'; 107455: c6 45 bb 00 movb $0x0,-0x45(%ebp) linkflag = hdr_ptr[156]; 107459: 8a 93 9c 00 00 00 mov 0x9c(%ebx),%dl 10745f: 88 95 53 fe ff ff mov %dl,-0x1ad(%ebp) file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8); 107465: 59 pop %ecx 107466: 5e pop %esi 107467: 6a 08 push $0x8 107469: 8d 43 64 lea 0x64(%ebx),%eax 10746c: 50 push %eax 10746d: e8 3a 7b 00 00 call 10efac <_rtems_octal2ulong> 107472: 89 85 48 fe ff ff mov %eax,-0x1b8(%ebp) file_size = _rtems_octal2ulong(&hdr_ptr[124], 12); 107478: 58 pop %eax 107479: 5a pop %edx 10747a: 6a 0c push $0xc 10747c: 8d 43 7c lea 0x7c(%ebx),%eax 10747f: 50 push %eax 107480: e8 27 7b 00 00 call 10efac <_rtems_octal2ulong> 107485: 89 85 4c fe ff ff mov %eax,-0x1b4(%ebp) hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8); 10748b: 5e pop %esi 10748c: 5f pop %edi 10748d: 6a 08 push $0x8 10748f: 8d 83 94 00 00 00 lea 0x94(%ebx),%eax 107495: 50 push %eax 107496: e8 11 7b 00 00 call 10efac <_rtems_octal2ulong> 10749b: 89 c6 mov %eax,%esi if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum) 10749d: 89 1c 24 mov %ebx,(%esp) 1074a0: e8 db 7f 00 00 call 10f480 <_rtems_tar_header_checksum> 1074a5: 83 c4 10 add $0x10,%esp 1074a8: 39 f0 cmp %esi,%eax 1074aa: 0f 85 92 00 00 00 jne 107542 <== 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) { 1074b0: 80 bd 53 fe ff ff 35 cmpb $0x35,-0x1ad(%ebp) 1074b7: 0f 85 43 ff ff ff jne 107400 strcpy(full_filename, mountpoint); 1074bd: 83 ec 08 sub $0x8,%esp 1074c0: ff 75 08 pushl 0x8(%ebp) 1074c3: 8d 85 58 fe ff ff lea -0x1a8(%ebp),%eax 1074c9: 50 push %eax 1074ca: e8 15 ea 00 00 call 115ee4 if (full_filename[strlen(full_filename)-1] != '/') 1074cf: 31 c0 xor %eax,%eax 1074d1: b9 ff ff ff ff mov $0xffffffff,%ecx 1074d6: 8b bd 34 fe ff ff mov -0x1cc(%ebp),%edi 1074dc: f2 ae repnz scas %es:(%edi),%al 1074de: f7 d1 not %ecx 1074e0: 49 dec %ecx 1074e1: 83 c4 10 add $0x10,%esp 1074e4: 80 bc 0d 57 fe ff ff cmpb $0x2f,-0x1a9(%ebp,%ecx,1) 1074eb: 2f 1074ec: 74 0a je 1074f8 <== ALWAYS TAKEN strcat(full_filename, "/"); 1074ee: 66 c7 84 0d 58 fe ff movw $0x2f,-0x1a8(%ebp,%ecx,1) <== NOT EXECUTED 1074f5: ff 2f 00 strcat(full_filename, filename); 1074f8: 83 ec 08 sub $0x8,%esp 1074fb: 8d 95 58 ff ff ff lea -0xa8(%ebp),%edx 107501: 52 push %edx 107502: 8d 85 58 fe ff ff lea -0x1a8(%ebp),%eax 107508: 50 push %eax 107509: e8 22 e8 00 00 call 115d30 mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO); 10750e: 5a pop %edx 10750f: 59 pop %ecx 107510: 68 ff 01 00 00 push $0x1ff 107515: 8d 95 58 fe ff ff lea -0x1a8(%ebp),%edx 10751b: 52 push %edx 10751c: e8 fb 10 00 00 call 10861c 107521: 83 c4 10 add $0x10,%esp 107524: e9 e4 fe ff ff jmp 10740d 107529: 8d 76 00 lea 0x0(%esi),%esi 0 ); if (status != 0) return -1; if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops) 10752c: 3d a0 5c 12 00 cmp $0x125ca0,%eax 107531: 0f 84 ae fe ff ff je 1073e5 <== NEVER TAKEN 107537: 90 nop return -1; 107538: c7 85 44 fe ff ff ff movl $0xffffffff,-0x1bc(%ebp) 10753f: ff ff ff nblocks = (((file_size) + 511) & ~511) / 512; offset += 512 * nblocks; } } return status; } 107542: 8b 85 44 fe ff ff mov -0x1bc(%ebp),%eax 107548: 8d 65 f4 lea -0xc(%ebp),%esp 10754b: 5b pop %ebx 10754c: 5e pop %esi 10754d: 5f pop %edi 10754e: c9 leave 10754f: c3 ret * should not have this path. */ else if (linkflag == REGTYPE) { const char *name; loc = root_loc; 107550: 8b bd 30 fe ff ff mov -0x1d0(%ebp),%edi 107556: 8b b5 2c fe ff ff mov -0x1d4(%ebp),%esi 10755c: b9 05 00 00 00 mov $0x5,%ecx 107561: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) { 107563: 50 push %eax 107564: 8d 45 e4 lea -0x1c(%ebp),%eax 107567: 50 push %eax 107568: 8d 55 bc lea -0x44(%ebp),%edx 10756b: 52 push %edx 10756c: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax 107572: 50 push %eax 107573: e8 84 86 00 00 call 10fbfc 107578: 83 c4 10 add $0x10,%esp 10757b: 85 c0 test %eax,%eax 10757d: 74 1d je 10759c <== ALWAYS TAKEN ); node->info.linearfile.size = file_size; node->info.linearfile.direct = &tar_image[offset]; } nblocks = (((file_size) + 511) & ~511) / 512; 10757f: 8b 85 4c fe ff ff mov -0x1b4(%ebp),%eax 107585: 05 ff 01 00 00 add $0x1ff,%eax offset += 512 * nblocks; 10758a: 25 00 fe ff ff and $0xfffffe00,%eax 10758f: 01 85 54 fe ff ff add %eax,-0x1ac(%ebp) 107595: e9 73 fe ff ff jmp 10740d 10759a: 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( 10759c: 83 ec 0c sub $0xc,%esp 10759f: 6a 00 push $0x0 &loc, IMFS_LINEAR_FILE, (char *)name, (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG, 1075a1: 8b 85 48 fe ff ff mov -0x1b8(%ebp),%eax 1075a7: 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( 1075ac: 80 cc 80 or $0x80,%ah 1075af: 50 push %eax 1075b0: ff 75 e4 pushl -0x1c(%ebp) 1075b3: 6a 06 push $0x6 1075b5: 8d 55 bc lea -0x44(%ebp),%edx 1075b8: 52 push %edx 1075b9: e8 76 80 00 00 call 10f634 &loc, IMFS_LINEAR_FILE, (char *)name, (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG, NULL ); node->info.linearfile.size = file_size; 1075be: 8b 95 4c fe ff ff mov -0x1b4(%ebp),%edx 1075c4: 89 50 50 mov %edx,0x50(%eax) 1075c7: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.linearfile.direct = &tar_image[offset]; 1075ce: 8b 55 0c mov 0xc(%ebp),%edx 1075d1: 03 95 54 fe ff ff add -0x1ac(%ebp),%edx 1075d7: 89 50 58 mov %edx,0x58(%eax) 1075da: 83 c4 20 add $0x20,%esp 1075dd: eb a0 jmp 10757f =============================================================================== 0010ad44 : size_t stack_size, rtems_mode initial_modes, rtems_attribute attribute_set, rtems_id *id ) { 10ad44: 55 push %ebp 10ad45: 89 e5 mov %esp,%ebp 10ad47: 57 push %edi 10ad48: 56 push %esi 10ad49: 53 push %ebx 10ad4a: 83 ec 1c sub $0x1c,%esp 10ad4d: 8b 5d 08 mov 0x8(%ebp),%ebx 10ad50: 8b 7d 0c mov 0xc(%ebp),%edi 10ad53: 8b 75 1c mov 0x1c(%ebp),%esi Priority_Control core_priority; RTEMS_API_Control *api; ASR_Information *asr; if ( !id ) 10ad56: 85 f6 test %esi,%esi 10ad58: 0f 84 3e 01 00 00 je 10ae9c return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10ad5e: 85 db test %ebx,%ebx 10ad60: 0f 84 d2 00 00 00 je 10ae38 /* * Validate the RTEMS API priority and convert it to the core priority range. */ if ( !_Attributes_Is_system_task( the_attribute_set ) ) { 10ad66: f7 45 18 00 80 00 00 testl $0x8000,0x18(%ebp) 10ad6d: 75 17 jne 10ad86 */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 10ad6f: 85 ff test %edi,%edi 10ad71: 0f 84 b1 00 00 00 je 10ae28 ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) ); 10ad77: 0f b6 05 f4 22 12 00 movzbl 0x1222f4,%eax */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 10ad7e: 39 c7 cmp %eax,%edi 10ad80: 0f 87 a2 00 00 00 ja 10ae28 */ /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 10ad86: 83 ec 0c sub $0xc,%esp 10ad89: ff 35 a0 65 12 00 pushl 0x1265a0 10ad8f: e8 78 06 00 00 call 10b40c <_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 ); 10ad94: c7 04 24 80 64 12 00 movl $0x126480,(%esp) 10ad9b: e8 58 0f 00 00 call 10bcf8 <_Objects_Allocate> 10ada0: 89 c2 mov %eax,%edx * the event of an error. */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { 10ada2: 83 c4 10 add $0x10,%esp 10ada5: 85 c0 test %eax,%eax 10ada7: 0f 84 cf 00 00 00 je 10ae7c /* * Initialize the core thread for this task. */ status = _Thread_Initialize( 10adad: 50 push %eax 10adae: 53 push %ebx */ RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level ( Modes_Control mode_set ) { return ( mode_set & RTEMS_INTERRUPT_MASK ); 10adaf: 8b 45 14 mov 0x14(%ebp),%eax 10adb2: 83 e0 01 and $0x1,%eax 10adb5: 50 push %eax 10adb6: 6a 00 push $0x0 10adb8: 31 c0 xor %eax,%eax 10adba: f7 45 14 00 02 00 00 testl $0x200,0x14(%ebp) 10adc1: 0f 95 c0 setne %al 10adc4: 50 push %eax 10adc5: 31 c0 xor %eax,%eax 10adc7: f7 45 14 00 01 00 00 testl $0x100,0x14(%ebp) 10adce: 0f 94 c0 sete %al 10add1: 50 push %eax 10add2: 57 push %edi */ RTEMS_INLINE_ROUTINE bool _Attributes_Is_floating_point( rtems_attribute attribute_set ) { return ( attribute_set & RTEMS_FLOATING_POINT ) ? true : false; 10add3: 8b 45 18 mov 0x18(%ebp),%eax 10add6: 83 e0 01 and $0x1,%eax 10add9: 50 push %eax 10adda: ff 75 10 pushl 0x10(%ebp) 10addd: 6a 00 push $0x0 10addf: 52 push %edx 10ade0: 68 80 64 12 00 push $0x126480 10ade5: 89 55 e4 mov %edx,-0x1c(%ebp) 10ade8: e8 ab 1f 00 00 call 10cd98 <_Thread_Initialize> NULL, /* no budget algorithm callout */ _Modes_Get_interrupt_level(initial_modes), (Objects_Name) name ); if ( !status ) { 10aded: 83 c4 30 add $0x30,%esp 10adf0: 84 c0 test %al,%al 10adf2: 8b 55 e4 mov -0x1c(%ebp),%edx 10adf5: 74 51 je 10ae48 _RTEMS_Unlock_allocator(); return RTEMS_UNSATISFIED; } api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; 10adf7: 8b 82 e4 00 00 00 mov 0xe4(%edx),%eax * id - thread id * RTEMS_SUCCESSFUL - if successful * error code - if unsuccessful */ rtems_status_code rtems_task_create( 10adfd: 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; 10ae04: 0f 94 40 08 sete 0x8(%eax) *id = the_thread->Object.id; 10ae08: 8b 42 08 mov 0x8(%edx),%eax 10ae0b: 89 06 mov %eax,(%esi) ); } #endif _RTEMS_Unlock_allocator(); 10ae0d: 83 ec 0c sub $0xc,%esp 10ae10: ff 35 a0 65 12 00 pushl 0x1265a0 10ae16: e8 39 06 00 00 call 10b454 <_API_Mutex_Unlock> return RTEMS_SUCCESSFUL; 10ae1b: 83 c4 10 add $0x10,%esp 10ae1e: 31 c0 xor %eax,%eax } 10ae20: 8d 65 f4 lea -0xc(%ebp),%esp 10ae23: 5b pop %ebx 10ae24: 5e pop %esi 10ae25: 5f pop %edi 10ae26: c9 leave 10ae27: 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; 10ae28: b8 13 00 00 00 mov $0x13,%eax } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10ae2d: 8d 65 f4 lea -0xc(%ebp),%esp 10ae30: 5b pop %ebx 10ae31: 5e pop %esi 10ae32: 5f pop %edi 10ae33: c9 leave 10ae34: c3 ret 10ae35: 8d 76 00 lea 0x0(%esi),%esi if ( !id ) return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 10ae38: b8 03 00 00 00 mov $0x3,%eax } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10ae3d: 8d 65 f4 lea -0xc(%ebp),%esp 10ae40: 5b pop %ebx 10ae41: 5e pop %esi 10ae42: 5f pop %edi 10ae43: c9 leave 10ae44: c3 ret 10ae45: 8d 76 00 lea 0x0(%esi),%esi */ RTEMS_INLINE_ROUTINE void _RTEMS_tasks_Free ( Thread_Control *the_task ) { _Objects_Free( 10ae48: 83 ec 0c sub $0xc,%esp 10ae4b: ff 72 08 pushl 0x8(%edx) 10ae4e: e8 89 12 00 00 call 10c0dc <_Objects_Get_information_id> 10ae53: 5a pop %edx 10ae54: 59 pop %ecx 10ae55: 8b 55 e4 mov -0x1c(%ebp),%edx 10ae58: 52 push %edx 10ae59: 50 push %eax 10ae5a: e8 0d 12 00 00 call 10c06c <_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(); 10ae5f: 58 pop %eax 10ae60: ff 35 a0 65 12 00 pushl 0x1265a0 10ae66: e8 e9 05 00 00 call 10b454 <_API_Mutex_Unlock> return RTEMS_UNSATISFIED; 10ae6b: 83 c4 10 add $0x10,%esp 10ae6e: b8 0d 00 00 00 mov $0xd,%eax } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10ae73: 8d 65 f4 lea -0xc(%ebp),%esp 10ae76: 5b pop %ebx 10ae77: 5e pop %esi 10ae78: 5f pop %edi 10ae79: c9 leave 10ae7a: c3 ret 10ae7b: 90 nop */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { _RTEMS_Unlock_allocator(); 10ae7c: 83 ec 0c sub $0xc,%esp 10ae7f: ff 35 a0 65 12 00 pushl 0x1265a0 10ae85: e8 ca 05 00 00 call 10b454 <_API_Mutex_Unlock> return RTEMS_TOO_MANY; 10ae8a: 83 c4 10 add $0x10,%esp 10ae8d: b8 05 00 00 00 mov $0x5,%eax } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10ae92: 8d 65 f4 lea -0xc(%ebp),%esp 10ae95: 5b pop %ebx 10ae96: 5e pop %esi 10ae97: 5f pop %edi 10ae98: c9 leave 10ae99: c3 ret 10ae9a: 66 90 xchg %ax,%ax RTEMS_API_Control *api; ASR_Information *asr; if ( !id ) return RTEMS_INVALID_ADDRESS; 10ae9c: b8 09 00 00 00 mov $0x9,%eax 10aea1: eb 8a jmp 10ae2d =============================================================================== 0010aea4 : */ rtems_status_code rtems_task_delete( rtems_id id ) { 10aea4: 55 push %ebp 10aea5: 89 e5 mov %esp,%ebp 10aea7: 53 push %ebx 10aea8: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; _RTEMS_Lock_allocator(); 10aeab: ff 35 a0 65 12 00 pushl 0x1265a0 10aeb1: e8 56 05 00 00 call 10b40c <_API_Mutex_Lock> the_thread = _Thread_Get( id, &location ); 10aeb6: 5a pop %edx 10aeb7: 59 pop %ecx 10aeb8: 8d 45 f4 lea -0xc(%ebp),%eax 10aebb: 50 push %eax 10aebc: ff 75 08 pushl 0x8(%ebp) 10aebf: e8 5c 1e 00 00 call 10cd20 <_Thread_Get> 10aec4: 89 c3 mov %eax,%ebx switch ( location ) { 10aec6: 83 c4 10 add $0x10,%esp 10aec9: 8b 45 f4 mov -0xc(%ebp),%eax 10aecc: 85 c0 test %eax,%eax 10aece: 75 44 jne 10af14 case OBJECTS_LOCAL: the_information = _Objects_Get_information_id( the_thread->Object.id ); 10aed0: 83 ec 0c sub $0xc,%esp 10aed3: ff 73 08 pushl 0x8(%ebx) 10aed6: e8 01 12 00 00 call 10c0dc <_Objects_Get_information_id> 0 /* Not used */ ); } #endif _Thread_Close( the_information, the_thread ); 10aedb: 5a pop %edx 10aedc: 59 pop %ecx 10aedd: 53 push %ebx 10aede: 50 push %eax 10aedf: e8 f0 1a 00 00 call 10c9d4 <_Thread_Close> 10aee4: 58 pop %eax 10aee5: ff 73 08 pushl 0x8(%ebx) 10aee8: e8 ef 11 00 00 call 10c0dc <_Objects_Get_information_id> 10aeed: 5a pop %edx 10aeee: 59 pop %ecx 10aeef: 53 push %ebx 10aef0: 50 push %eax 10aef1: e8 76 11 00 00 call 10c06c <_Objects_Free> _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 10aef6: 58 pop %eax 10aef7: ff 35 a0 65 12 00 pushl 0x1265a0 10aefd: e8 52 05 00 00 call 10b454 <_API_Mutex_Unlock> _Thread_Enable_dispatch(); 10af02: e8 f5 1d 00 00 call 10ccfc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10af07: 83 c4 10 add $0x10,%esp 10af0a: 31 c0 xor %eax,%eax break; } _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; } 10af0c: 8b 5d fc mov -0x4(%ebp),%ebx 10af0f: c9 leave 10af10: c3 ret 10af11: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_ERROR: break; } _RTEMS_Unlock_allocator(); 10af14: 83 ec 0c sub $0xc,%esp 10af17: ff 35 a0 65 12 00 pushl 0x1265a0 10af1d: e8 32 05 00 00 call 10b454 <_API_Mutex_Unlock> return RTEMS_INVALID_ID; 10af22: 83 c4 10 add $0x10,%esp 10af25: b8 04 00 00 00 mov $0x4,%eax } 10af2a: 8b 5d fc mov -0x4(%ebp),%ebx 10af2d: c9 leave 10af2e: c3 ret =============================================================================== 0010ca6c : rtems_status_code rtems_task_get_note( rtems_id id, uint32_t notepad, uint32_t *note ) { 10ca6c: 55 push %ebp 10ca6d: 89 e5 mov %esp,%ebp 10ca6f: 56 push %esi 10ca70: 53 push %ebx 10ca71: 83 ec 10 sub $0x10,%esp 10ca74: 8b 45 08 mov 0x8(%ebp),%eax 10ca77: 8b 75 0c mov 0xc(%ebp),%esi 10ca7a: 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() ) 10ca7d: 80 3d 24 52 12 00 00 cmpb $0x0,0x125224 10ca84: 74 6e je 10caf4 return RTEMS_NOT_CONFIGURED; if ( !note ) 10ca86: 85 db test %ebx,%ebx 10ca88: 74 7e je 10cb08 /* * 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 ) 10ca8a: 83 fe 0f cmp $0xf,%esi 10ca8d: 77 3d ja 10cacc /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10ca8f: 85 c0 test %eax,%eax 10ca91: 74 45 je 10cad8 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 10ca93: 8b 15 18 9a 12 00 mov 0x129a18,%edx /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10ca99: 3b 42 08 cmp 0x8(%edx),%eax 10ca9c: 74 40 je 10cade api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10ca9e: 83 ec 08 sub $0x8,%esp 10caa1: 8d 55 f4 lea -0xc(%ebp),%edx 10caa4: 52 push %edx 10caa5: 50 push %eax 10caa6: e8 4d 21 00 00 call 10ebf8 <_Thread_Get> switch ( location ) { 10caab: 83 c4 10 add $0x10,%esp 10caae: 8b 55 f4 mov -0xc(%ebp),%edx 10cab1: 85 d2 test %edx,%edx 10cab3: 75 4b jne 10cb00 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10cab5: 8b 80 e4 00 00 00 mov 0xe4(%eax),%eax 10cabb: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10cabf: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10cac1: e8 0e 21 00 00 call 10ebd4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10cac6: 31 c0 xor %eax,%eax 10cac8: eb 07 jmp 10cad1 10caca: 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; 10cacc: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10cad1: 8d 65 f8 lea -0x8(%ebp),%esp 10cad4: 5b pop %ebx 10cad5: 5e pop %esi 10cad6: c9 leave 10cad7: c3 ret /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10cad8: 8b 15 18 9a 12 00 mov 0x129a18,%edx _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10cade: 8b 82 e4 00 00 00 mov 0xe4(%edx),%eax 10cae4: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10cae8: 89 03 mov %eax,(%ebx) return RTEMS_SUCCESSFUL; 10caea: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10caec: 8d 65 f8 lea -0x8(%ebp),%esp 10caef: 5b pop %ebx 10caf0: 5e pop %esi 10caf1: c9 leave 10caf2: c3 ret 10caf3: 90 nop register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) return RTEMS_NOT_CONFIGURED; 10caf4: b8 16 00 00 00 mov $0x16,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10caf9: 8d 65 f8 lea -0x8(%ebp),%esp 10cafc: 5b pop %ebx 10cafd: 5e pop %esi 10cafe: c9 leave 10caff: c3 ret case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10cb00: b8 04 00 00 00 mov $0x4,%eax 10cb05: eb ca jmp 10cad1 10cb07: 90 nop if ( !rtems_configuration_get_notepads_enabled() ) return RTEMS_NOT_CONFIGURED; if ( !note ) return RTEMS_INVALID_ADDRESS; 10cb08: b8 09 00 00 00 mov $0x9,%eax 10cb0d: eb c2 jmp 10cad1 =============================================================================== 0011776c : */ rtems_status_code rtems_task_is_suspended( rtems_id id ) { 11776c: 55 push %ebp 11776d: 89 e5 mov %esp,%ebp 11776f: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 117772: 8d 45 f4 lea -0xc(%ebp),%eax 117775: 50 push %eax 117776: ff 75 08 pushl 0x8(%ebp) 117779: e8 ba 3b 00 00 call 11b338 <_Thread_Get> switch ( location ) { 11777e: 83 c4 10 add $0x10,%esp 117781: 8b 55 f4 mov -0xc(%ebp),%edx 117784: 85 d2 test %edx,%edx 117786: 74 08 je 117790 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 117788: b8 04 00 00 00 mov $0x4,%eax } 11778d: c9 leave 11778e: c3 ret 11778f: 90 nop the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 117790: f6 40 10 02 testb $0x2,0x10(%eax) 117794: 74 0e je 1177a4 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 117796: e8 79 3b 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_ALREADY_SUSPENDED; 11779b: b8 0f 00 00 00 mov $0xf,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1177a0: c9 leave 1177a1: c3 ret 1177a2: 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(); 1177a4: e8 6b 3b 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1177a9: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1177ab: c9 leave 1177ac: c3 ret =============================================================================== 0011197c : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 11197c: 55 push %ebp 11197d: 89 e5 mov %esp,%ebp 11197f: 57 push %edi 111980: 56 push %esi 111981: 53 push %ebx 111982: 83 ec 1c sub $0x1c,%esp 111985: 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 ) 111988: 85 c9 test %ecx,%ecx 11198a: 0f 84 40 01 00 00 je 111ad0 return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 111990: 8b 1d 78 67 12 00 mov 0x126778,%ebx api = executing->API_Extensions[ THREAD_API_RTEMS ]; 111996: 8b bb e4 00 00 00 mov 0xe4(%ebx),%edi asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 11199c: 80 7b 74 01 cmpb $0x1,0x74(%ebx) 1119a0: 19 f6 sbb %esi,%esi 1119a2: 81 e6 00 01 00 00 and $0x100,%esi if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 1119a8: 8b 53 7c mov 0x7c(%ebx),%edx 1119ab: 85 d2 test %edx,%edx 1119ad: 0f 85 f1 00 00 00 jne 111aa4 old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 1119b3: 80 7f 08 01 cmpb $0x1,0x8(%edi) 1119b7: 19 d2 sbb %edx,%edx 1119b9: 81 e2 00 04 00 00 and $0x400,%edx old_mode |= _ISR_Get_level(); 1119bf: 89 55 e4 mov %edx,-0x1c(%ebp) 1119c2: 89 4d e0 mov %ecx,-0x20(%ebp) 1119c5: e8 a2 c6 ff ff call 10e06c <_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; 1119ca: 8b 55 e4 mov -0x1c(%ebp),%edx 1119cd: 09 d0 or %edx,%eax old_mode |= _ISR_Get_level(); 1119cf: 09 f0 or %esi,%eax 1119d1: 8b 4d e0 mov -0x20(%ebp),%ecx 1119d4: 89 01 mov %eax,(%ecx) *previous_mode_set = old_mode; /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 1119d6: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) 1119dd: 74 0b je 1119ea executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; 1119df: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp) 1119e6: 0f 94 43 74 sete 0x74(%ebx) if ( mask & RTEMS_TIMESLICE_MASK ) { 1119ea: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 1119f1: 74 1c je 111a0f if ( _Modes_Is_timeslice(mode_set) ) { 1119f3: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp) 1119fa: 0f 84 b8 00 00 00 je 111ab8 executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 111a00: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx) executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 111a07: a1 c0 64 12 00 mov 0x1264c0,%eax 111a0c: 89 43 78 mov %eax,0x78(%ebx) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 111a0f: f6 45 0c 01 testb $0x1,0xc(%ebp) 111a13: 74 0b je 111a20 */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( Modes_Control mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 111a15: f6 45 08 01 testb $0x1,0x8(%ebp) 111a19: 0f 84 91 00 00 00 je 111ab0 111a1f: fa cli * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; if ( mask & RTEMS_ASR_MASK ) { 111a20: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 111a27: 74 3f je 111a68 * Output: * *previous_mode_set - previous mode set * always return RTEMS_SUCCESSFUL; */ rtems_status_code rtems_task_mode( 111a29: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp) 111a30: 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 ) { 111a33: 38 47 08 cmp %al,0x8(%edi) 111a36: 74 30 je 111a68 asr->is_enabled = is_asr_enabled; 111a38: 88 47 08 mov %al,0x8(%edi) ) { rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); 111a3b: 9c pushf 111a3c: fa cli 111a3d: 58 pop %eax _signals = information->signals_pending; 111a3e: 8b 57 18 mov 0x18(%edi),%edx information->signals_pending = information->signals_posted; 111a41: 8b 4f 14 mov 0x14(%edi),%ecx 111a44: 89 4f 18 mov %ecx,0x18(%edi) information->signals_posted = _signals; 111a47: 89 57 14 mov %edx,0x14(%edi) _ISR_Enable( _level ); 111a4a: 50 push %eax 111a4b: 9d popf /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 111a4c: 8b 47 14 mov 0x14(%edi),%eax 111a4f: 85 c0 test %eax,%eax 111a51: 0f 95 c0 setne %al needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 111a54: 83 3d 80 66 12 00 03 cmpl $0x3,0x126680 111a5b: 74 16 je 111a73 <== ALWAYS TAKEN if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; 111a5d: 31 c0 xor %eax,%eax } 111a5f: 83 c4 1c add $0x1c,%esp 111a62: 5b pop %ebx 111a63: 5e pop %esi 111a64: 5f pop %edi 111a65: c9 leave 111a66: c3 ret 111a67: 90 nop /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 111a68: 31 c0 xor %eax,%eax needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 111a6a: 83 3d 80 66 12 00 03 cmpl $0x3,0x126680 111a71: 75 ea jne 111a5d bool are_signals_pending ) { Thread_Control *executing; executing = _Thread_Executing; 111a73: 8b 15 78 67 12 00 mov 0x126778,%edx if ( are_signals_pending || 111a79: 84 c0 test %al,%al 111a7b: 75 0e jne 111a8b 111a7d: 3b 15 7c 67 12 00 cmp 0x12677c,%edx 111a83: 74 d8 je 111a5d (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) { 111a85: 80 7a 74 00 cmpb $0x0,0x74(%edx) 111a89: 74 d2 je 111a5d <== NEVER TAKEN _Thread_Dispatch_necessary = true; 111a8b: c6 05 84 67 12 00 01 movb $0x1,0x126784 if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); 111a92: e8 ed b0 ff ff call 10cb84 <_Thread_Dispatch> } return RTEMS_SUCCESSFUL; 111a97: 31 c0 xor %eax,%eax } 111a99: 83 c4 1c add $0x1c,%esp 111a9c: 5b pop %ebx 111a9d: 5e pop %esi 111a9e: 5f pop %edi 111a9f: c9 leave 111aa0: c3 ret 111aa1: 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; 111aa4: 81 ce 00 02 00 00 or $0x200,%esi 111aaa: e9 04 ff ff ff jmp 1119b3 111aaf: 90 nop 111ab0: fb sti 111ab1: e9 6a ff ff ff jmp 111a20 111ab6: 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; 111ab8: c7 43 7c 00 00 00 00 movl $0x0,0x7c(%ebx) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 111abf: f6 45 0c 01 testb $0x1,0xc(%ebp) 111ac3: 0f 84 57 ff ff ff je 111a20 111ac9: e9 47 ff ff ff jmp 111a15 111ace: 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; 111ad0: b8 09 00 00 00 mov $0x9,%eax if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; } 111ad5: 83 c4 1c add $0x1c,%esp 111ad8: 5b pop %ebx 111ad9: 5e pop %esi 111ada: 5f pop %edi 111adb: c9 leave 111adc: c3 ret =============================================================================== 0010e1c4 : */ rtems_status_code rtems_task_resume( rtems_id id ) { 10e1c4: 55 push %ebp 10e1c5: 89 e5 mov %esp,%ebp 10e1c7: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10e1ca: 8d 45 f4 lea -0xc(%ebp),%eax 10e1cd: 50 push %eax 10e1ce: ff 75 08 pushl 0x8(%ebp) 10e1d1: e8 fa 1d 00 00 call 10ffd0 <_Thread_Get> switch ( location ) { 10e1d6: 83 c4 10 add $0x10,%esp 10e1d9: 8b 55 f4 mov -0xc(%ebp),%edx 10e1dc: 85 d2 test %edx,%edx 10e1de: 74 08 je 10e1e8 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10e1e0: b8 04 00 00 00 mov $0x4,%eax } 10e1e5: c9 leave 10e1e6: c3 ret 10e1e7: 90 nop the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { 10e1e8: f6 40 10 02 testb $0x2,0x10(%eax) 10e1ec: 75 0e jne 10e1fc _Thread_Resume( the_thread ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10e1ee: e8 b9 1d 00 00 call 10ffac <_Thread_Enable_dispatch> return RTEMS_INCORRECT_STATE; 10e1f3: b8 0e 00 00 00 mov $0xe,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10e1f8: c9 leave 10e1f9: c3 ret 10e1fa: 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 ); 10e1fc: 83 ec 08 sub $0x8,%esp 10e1ff: 6a 02 push $0x2 10e201: 50 push %eax 10e202: e8 41 1a 00 00 call 10fc48 <_Thread_Clear_state> _Thread_Enable_dispatch(); 10e207: e8 a0 1d 00 00 call 10ffac <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10e20c: 83 c4 10 add $0x10,%esp 10e20f: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10e211: c9 leave 10e212: c3 ret =============================================================================== 0010cbe4 : rtems_status_code rtems_task_set_note( rtems_id id, uint32_t notepad, uint32_t note ) { 10cbe4: 55 push %ebp 10cbe5: 89 e5 mov %esp,%ebp 10cbe7: 56 push %esi 10cbe8: 53 push %ebx 10cbe9: 83 ec 10 sub $0x10,%esp 10cbec: 8b 45 08 mov 0x8(%ebp),%eax 10cbef: 8b 5d 0c mov 0xc(%ebp),%ebx 10cbf2: 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() ) 10cbf5: 80 3d 24 52 12 00 00 cmpb $0x0,0x125224 10cbfc: 74 66 je 10cc64 /* * 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 ) 10cbfe: 83 fb 0f cmp $0xf,%ebx 10cc01: 77 39 ja 10cc3c /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10cc03: 85 c0 test %eax,%eax 10cc05: 74 41 je 10cc48 _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 10cc07: 8b 15 18 9a 12 00 mov 0x129a18,%edx /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10cc0d: 3b 42 08 cmp 0x8(%edx),%eax 10cc10: 74 3c je 10cc4e api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10cc12: 83 ec 08 sub $0x8,%esp 10cc15: 8d 55 f4 lea -0xc(%ebp),%edx 10cc18: 52 push %edx 10cc19: 50 push %eax 10cc1a: e8 d9 1f 00 00 call 10ebf8 <_Thread_Get> switch ( location ) { 10cc1f: 83 c4 10 add $0x10,%esp 10cc22: 8b 55 f4 mov -0xc(%ebp),%edx 10cc25: 85 d2 test %edx,%edx 10cc27: 75 47 jne 10cc70 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10cc29: 8b 80 e4 00 00 00 mov 0xe4(%eax),%eax 10cc2f: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4) _Thread_Enable_dispatch(); 10cc33: e8 9c 1f 00 00 call 10ebd4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10cc38: 31 c0 xor %eax,%eax 10cc3a: eb 05 jmp 10cc41 * 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; 10cc3c: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10cc41: 8d 65 f8 lea -0x8(%ebp),%esp 10cc44: 5b pop %ebx 10cc45: 5e pop %esi 10cc46: c9 leave 10cc47: c3 ret /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10cc48: 8b 15 18 9a 12 00 mov 0x129a18,%edx _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10cc4e: 8b 82 e4 00 00 00 mov 0xe4(%edx),%eax 10cc54: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4) return RTEMS_SUCCESSFUL; 10cc58: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10cc5a: 8d 65 f8 lea -0x8(%ebp),%esp 10cc5d: 5b pop %ebx 10cc5e: 5e pop %esi 10cc5f: c9 leave 10cc60: c3 ret 10cc61: 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; 10cc64: b8 16 00 00 00 mov $0x16,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10cc69: 8d 65 f8 lea -0x8(%ebp),%esp 10cc6c: 5b pop %ebx 10cc6d: 5e pop %esi 10cc6e: c9 leave 10cc6f: c3 ret case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10cc70: b8 04 00 00 00 mov $0x4,%eax } 10cc75: 8d 65 f8 lea -0x8(%ebp),%esp 10cc78: 5b pop %ebx 10cc79: 5e pop %esi 10cc7a: c9 leave 10cc7b: c3 ret =============================================================================== 0010ee88 : rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10ee88: 55 push %ebp 10ee89: 89 e5 mov %esp,%ebp 10ee8b: 56 push %esi 10ee8c: 53 push %ebx 10ee8d: 83 ec 10 sub $0x10,%esp 10ee90: 8b 5d 0c mov 0xc(%ebp),%ebx 10ee93: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10ee96: 85 db test %ebx,%ebx 10ee98: 74 0b je 10eea5 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 ) ); 10ee9a: 0f b6 05 54 52 12 00 movzbl 0x125254,%eax */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 10eea1: 39 c3 cmp %eax,%ebx 10eea3: 77 5f ja 10ef04 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10eea5: 85 f6 test %esi,%esi 10eea7: 74 67 je 10ef10 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10eea9: 83 ec 08 sub $0x8,%esp 10eeac: 8d 45 f4 lea -0xc(%ebp),%eax 10eeaf: 50 push %eax 10eeb0: ff 75 08 pushl 0x8(%ebp) 10eeb3: e8 58 1f 00 00 call 110e10 <_Thread_Get> switch ( location ) { 10eeb8: 83 c4 10 add $0x10,%esp 10eebb: 8b 55 f4 mov -0xc(%ebp),%edx 10eebe: 85 d2 test %edx,%edx 10eec0: 75 36 jne 10eef8 case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10eec2: 8b 50 14 mov 0x14(%eax),%edx 10eec5: 89 16 mov %edx,(%esi) if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10eec7: 85 db test %ebx,%ebx 10eec9: 74 1c je 10eee7 the_thread->real_priority = new_priority; 10eecb: 89 58 18 mov %ebx,0x18(%eax) if ( the_thread->resource_count == 0 || 10eece: 8b 48 1c mov 0x1c(%eax),%ecx 10eed1: 85 c9 test %ecx,%ecx 10eed3: 74 05 je 10eeda 10eed5: 3b 58 14 cmp 0x14(%eax),%ebx 10eed8: 73 0d jae 10eee7 <== ALWAYS TAKEN the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, false ); 10eeda: 52 push %edx 10eedb: 6a 00 push $0x0 10eedd: 53 push %ebx 10eede: 50 push %eax 10eedf: e8 d0 1a 00 00 call 1109b4 <_Thread_Change_priority> 10eee4: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10eee7: e8 00 1f 00 00 call 110dec <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10eeec: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10eeee: 8d 65 f8 lea -0x8(%ebp),%esp 10eef1: 5b pop %ebx 10eef2: 5e pop %esi 10eef3: c9 leave 10eef4: c3 ret 10eef5: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10eef8: b8 04 00 00 00 mov $0x4,%eax } 10eefd: 8d 65 f8 lea -0x8(%ebp),%esp 10ef00: 5b pop %ebx 10ef01: 5e pop %esi 10ef02: c9 leave 10ef03: 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; 10ef04: b8 13 00 00 00 mov $0x13,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ef09: 8d 65 f8 lea -0x8(%ebp),%esp 10ef0c: 5b pop %ebx 10ef0d: 5e pop %esi 10ef0e: c9 leave 10ef0f: 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; 10ef10: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ef15: 8d 65 f8 lea -0x8(%ebp),%esp 10ef18: 5b pop %ebx 10ef19: 5e pop %esi 10ef1a: c9 leave 10ef1b: c3 ret =============================================================================== 0010afec : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 10afec: 55 push %ebp 10afed: 89 e5 mov %esp,%ebp 10afef: 53 push %ebx 10aff0: 83 ec 14 sub $0x14,%esp 10aff3: 8b 5d 0c mov 0xc(%ebp),%ebx register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 10aff6: 85 db test %ebx,%ebx 10aff8: 74 4e je 10b048 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10affa: 83 ec 08 sub $0x8,%esp 10affd: 8d 45 f4 lea -0xc(%ebp),%eax 10b000: 50 push %eax 10b001: ff 75 08 pushl 0x8(%ebp) 10b004: e8 17 1d 00 00 call 10cd20 <_Thread_Get> switch ( location ) { 10b009: 83 c4 10 add $0x10,%esp 10b00c: 8b 55 f4 mov -0xc(%ebp),%edx 10b00f: 85 d2 test %edx,%edx 10b011: 75 29 jne 10b03c case OBJECTS_LOCAL: if ( _Thread_Start( 10b013: 83 ec 0c sub $0xc,%esp 10b016: ff 75 10 pushl 0x10(%ebp) 10b019: 6a 00 push $0x0 10b01b: 53 push %ebx 10b01c: 6a 00 push $0x0 10b01e: 50 push %eax 10b01f: e8 28 26 00 00 call 10d64c <_Thread_Start> 10b024: 83 c4 20 add $0x20,%esp 10b027: 84 c0 test %al,%al 10b029: 75 29 jne 10b054 the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10b02b: e8 cc 1c 00 00 call 10ccfc <_Thread_Enable_dispatch> return RTEMS_INCORRECT_STATE; 10b030: b8 0e 00 00 00 mov $0xe,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b035: 8b 5d fc mov -0x4(%ebp),%ebx 10b038: c9 leave 10b039: c3 ret 10b03a: 66 90 xchg %ax,%ax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b03c: b8 04 00 00 00 mov $0x4,%eax } 10b041: 8b 5d fc mov -0x4(%ebp),%ebx 10b044: c9 leave 10b045: c3 ret 10b046: 66 90 xchg %ax,%ax { register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) return RTEMS_INVALID_ADDRESS; 10b048: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b04d: 8b 5d fc mov -0x4(%ebp),%ebx 10b050: c9 leave 10b051: c3 ret 10b052: 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(); 10b054: e8 a3 1c 00 00 call 10ccfc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b059: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b05b: 8b 5d fc mov -0x4(%ebp),%ebx 10b05e: c9 leave 10b05f: c3 ret =============================================================================== 0010fd18 : */ rtems_status_code rtems_task_suspend( rtems_id id ) { 10fd18: 55 push %ebp 10fd19: 89 e5 mov %esp,%ebp 10fd1b: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10fd1e: 8d 45 f4 lea -0xc(%ebp),%eax 10fd21: 50 push %eax 10fd22: ff 75 08 pushl 0x8(%ebp) 10fd25: e8 f6 cf ff ff call 10cd20 <_Thread_Get> switch ( location ) { 10fd2a: 83 c4 10 add $0x10,%esp 10fd2d: 8b 55 f4 mov -0xc(%ebp),%edx 10fd30: 85 d2 test %edx,%edx 10fd32: 74 08 je 10fd3c case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10fd34: b8 04 00 00 00 mov $0x4,%eax } 10fd39: c9 leave 10fd3a: c3 ret 10fd3b: 90 nop the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 10fd3c: f6 40 10 02 testb $0x2,0x10(%eax) 10fd40: 74 0e je 10fd50 _Thread_Suspend( the_thread ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10fd42: e8 b5 cf ff ff call 10ccfc <_Thread_Enable_dispatch> return RTEMS_ALREADY_SUSPENDED; 10fd47: b8 0f 00 00 00 mov $0xf,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10fd4c: c9 leave 10fd4d: c3 ret 10fd4e: 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 ); 10fd50: 83 ec 08 sub $0x8,%esp 10fd53: 6a 02 push $0x2 10fd55: 50 push %eax 10fd56: e8 95 d7 ff ff call 10d4f0 <_Thread_Set_state> _Thread_Enable_dispatch(); 10fd5b: e8 9c cf ff ff call 10ccfc <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10fd60: 83 c4 10 add $0x10,%esp 10fd63: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10fd65: c9 leave 10fd66: c3 ret =============================================================================== 0010bb48 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 10bb48: 55 push %ebp 10bb49: 89 e5 mov %esp,%ebp 10bb4b: 57 push %edi 10bb4c: 56 push %esi 10bb4d: 53 push %ebx 10bb4e: 83 ec 1c sub $0x1c,%esp 10bb51: 8b 5d 0c mov 0xc(%ebp),%ebx 10bb54: 8b 7d 10 mov 0x10(%ebp),%edi Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 10bb57: 85 db test %ebx,%ebx 10bb59: 0f 84 9d 00 00 00 je 10bbfc return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 10bb5f: 83 ec 08 sub $0x8,%esp 10bb62: 8d 45 e4 lea -0x1c(%ebp),%eax 10bb65: 50 push %eax 10bb66: ff 75 08 pushl 0x8(%ebp) 10bb69: e8 4a 1e 00 00 call 10d9b8 <_Thread_Get> 10bb6e: 89 c6 mov %eax,%esi switch (location) { 10bb70: 83 c4 10 add $0x10,%esp 10bb73: 8b 45 e4 mov -0x1c(%ebp),%eax 10bb76: 85 c0 test %eax,%eax 10bb78: 74 0e je 10bb88 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10bb7a: b8 04 00 00 00 mov $0x4,%eax } 10bb7f: 8d 65 f4 lea -0xc(%ebp),%esp 10bb82: 5b pop %ebx 10bb83: 5e pop %esi 10bb84: 5f pop %edi 10bb85: c9 leave 10bb86: c3 ret 10bb87: 90 nop case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 10bb88: 8b 86 f0 00 00 00 mov 0xf0(%esi),%eax while (tvp) { 10bb8e: 85 c0 test %eax,%eax 10bb90: 75 44 jne 10bbd6 10bb92: 66 90 xchg %ax,%ax /* * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); 10bb94: 83 ec 0c sub $0xc,%esp 10bb97: 6a 14 push $0x14 10bb99: e8 6a 2d 00 00 call 10e908 <_Workspace_Allocate> if (new == NULL) { 10bb9e: 83 c4 10 add $0x10,%esp 10bba1: 85 c0 test %eax,%eax 10bba3: 74 4b je 10bbf0 _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 10bba5: 8b 13 mov (%ebx),%edx 10bba7: 89 50 08 mov %edx,0x8(%eax) new->ptr = ptr; 10bbaa: 89 58 04 mov %ebx,0x4(%eax) new->dtor = dtor; 10bbad: 89 78 10 mov %edi,0x10(%eax) new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 10bbb0: 8b 96 f0 00 00 00 mov 0xf0(%esi),%edx 10bbb6: 89 10 mov %edx,(%eax) the_thread->task_variables = new; 10bbb8: 89 86 f0 00 00 00 mov %eax,0xf0(%esi) _Thread_Enable_dispatch(); 10bbbe: e8 d1 1d 00 00 call 10d994 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10bbc3: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bbc5: 8d 65 f4 lea -0xc(%ebp),%esp 10bbc8: 5b pop %ebx 10bbc9: 5e pop %esi 10bbca: 5f pop %edi 10bbcb: c9 leave 10bbcc: c3 ret 10bbcd: 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; 10bbd0: 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) { 10bbd2: 85 c0 test %eax,%eax 10bbd4: 74 be je 10bb94 if (tvp->ptr == ptr) { 10bbd6: 39 58 04 cmp %ebx,0x4(%eax) 10bbd9: 75 f5 jne 10bbd0 tvp->dtor = dtor; 10bbdb: 89 78 10 mov %edi,0x10(%eax) _Thread_Enable_dispatch(); 10bbde: e8 b1 1d 00 00 call 10d994 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10bbe3: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bbe5: 8d 65 f4 lea -0xc(%ebp),%esp 10bbe8: 5b pop %ebx 10bbe9: 5e pop %esi 10bbea: 5f pop %edi 10bbeb: c9 leave 10bbec: c3 ret 10bbed: 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(); 10bbf0: e8 9f 1d 00 00 call 10d994 <_Thread_Enable_dispatch> return RTEMS_NO_MEMORY; 10bbf5: b8 1a 00 00 00 mov $0x1a,%eax 10bbfa: eb 83 jmp 10bb7f Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) return RTEMS_INVALID_ADDRESS; 10bbfc: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bc01: 8d 65 f4 lea -0xc(%ebp),%esp 10bc04: 5b pop %ebx 10bc05: 5e pop %esi 10bc06: 5f pop %edi 10bc07: c9 leave 10bc08: c3 ret =============================================================================== 0010bc0c : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 10bc0c: 55 push %ebp 10bc0d: 89 e5 mov %esp,%ebp 10bc0f: 53 push %ebx 10bc10: 83 ec 14 sub $0x14,%esp 10bc13: 8b 5d 0c mov 0xc(%ebp),%ebx Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 10bc16: 85 db test %ebx,%ebx 10bc18: 74 76 je 10bc90 return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); 10bc1a: 83 ec 08 sub $0x8,%esp 10bc1d: 8d 45 f4 lea -0xc(%ebp),%eax 10bc20: 50 push %eax 10bc21: ff 75 08 pushl 0x8(%ebp) 10bc24: e8 8f 1d 00 00 call 10d9b8 <_Thread_Get> switch (location) { 10bc29: 83 c4 10 add $0x10,%esp 10bc2c: 8b 55 f4 mov -0xc(%ebp),%edx 10bc2f: 85 d2 test %edx,%edx 10bc31: 74 0d je 10bc40 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10bc33: b8 04 00 00 00 mov $0x4,%eax } 10bc38: 8b 5d fc mov -0x4(%ebp),%ebx 10bc3b: c9 leave 10bc3c: c3 ret 10bc3d: 8d 76 00 lea 0x0(%esi),%esi the_thread = _Thread_Get (tid, &location); switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; 10bc40: 8b 88 f0 00 00 00 mov 0xf0(%eax),%ecx while (tvp) { 10bc46: 85 c9 test %ecx,%ecx 10bc48: 74 17 je 10bc61 if (tvp->ptr == ptr) { 10bc4a: 39 59 04 cmp %ebx,0x4(%ecx) 10bc4d: 75 0c jne 10bc5b 10bc4f: eb 49 jmp 10bc9a 10bc51: 8d 76 00 lea 0x0(%esi),%esi 10bc54: 39 5a 04 cmp %ebx,0x4(%edx) 10bc57: 74 17 je 10bc70 10bc59: 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; 10bc5b: 8b 11 mov (%ecx),%edx the_thread = _Thread_Get (tid, &location); switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 10bc5d: 85 d2 test %edx,%edx 10bc5f: 75 f3 jne 10bc54 <== ALWAYS TAKEN return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 10bc61: e8 2e 1d 00 00 call 10d994 <_Thread_Enable_dispatch> return RTEMS_INVALID_ADDRESS; 10bc66: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bc6b: 8b 5d fc mov -0x4(%ebp),%ebx 10bc6e: c9 leave 10bc6f: c3 ret case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; 10bc70: 8b 1a mov (%edx),%ebx 10bc72: 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 ); 10bc74: 83 ec 08 sub $0x8,%esp 10bc77: 52 push %edx 10bc78: 50 push %eax 10bc79: e8 b2 00 00 00 call 10bd30 <_RTEMS_Tasks_Invoke_task_variable_dtor> _Thread_Enable_dispatch(); 10bc7e: e8 11 1d 00 00 call 10d994 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10bc83: 83 c4 10 add $0x10,%esp 10bc86: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bc88: 8b 5d fc mov -0x4(%ebp),%ebx 10bc8b: c9 leave 10bc8c: c3 ret 10bc8d: 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; 10bc90: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bc95: 8b 5d fc mov -0x4(%ebp),%ebx 10bc98: c9 leave 10bc99: 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; 10bc9a: 8b 11 mov (%ecx),%edx 10bc9c: 89 90 f0 00 00 00 mov %edx,0xf0(%eax) 10bca2: 89 ca mov %ecx,%edx 10bca4: eb ce jmp 10bc74 =============================================================================== 0010bca8 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 10bca8: 55 push %ebp 10bca9: 89 e5 mov %esp,%ebp 10bcab: 56 push %esi 10bcac: 53 push %ebx 10bcad: 83 ec 10 sub $0x10,%esp 10bcb0: 8b 5d 0c mov 0xc(%ebp),%ebx 10bcb3: 8b 75 10 mov 0x10(%ebp),%esi Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 10bcb6: 85 db test %ebx,%ebx 10bcb8: 74 56 je 10bd10 return RTEMS_INVALID_ADDRESS; if ( !result ) 10bcba: 85 f6 test %esi,%esi 10bcbc: 74 52 je 10bd10 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 10bcbe: 83 ec 08 sub $0x8,%esp 10bcc1: 8d 45 f4 lea -0xc(%ebp),%eax 10bcc4: 50 push %eax 10bcc5: ff 75 08 pushl 0x8(%ebp) 10bcc8: e8 eb 1c 00 00 call 10d9b8 <_Thread_Get> switch (location) { 10bccd: 83 c4 10 add $0x10,%esp 10bcd0: 8b 55 f4 mov -0xc(%ebp),%edx 10bcd3: 85 d2 test %edx,%edx 10bcd5: 75 2d jne 10bd04 case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 10bcd7: 8b 80 f0 00 00 00 mov 0xf0(%eax),%eax while (tvp) { 10bcdd: 85 c0 test %eax,%eax 10bcdf: 75 09 jne 10bcea 10bce1: eb 39 jmp 10bd1c 10bce3: 90 nop */ *result = tvp->tval; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 10bce4: 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) { 10bce6: 85 c0 test %eax,%eax 10bce8: 74 32 je 10bd1c <== NEVER TAKEN if (tvp->ptr == ptr) { 10bcea: 39 58 04 cmp %ebx,0x4(%eax) 10bced: 75 f5 jne 10bce4 /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 10bcef: 8b 40 0c mov 0xc(%eax),%eax 10bcf2: 89 06 mov %eax,(%esi) _Thread_Enable_dispatch(); 10bcf4: e8 9b 1c 00 00 call 10d994 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10bcf9: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bcfb: 8d 65 f8 lea -0x8(%ebp),%esp 10bcfe: 5b pop %ebx 10bcff: 5e pop %esi 10bd00: c9 leave 10bd01: c3 ret 10bd02: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10bd04: b8 04 00 00 00 mov $0x4,%eax } 10bd09: 8d 65 f8 lea -0x8(%ebp),%esp 10bd0c: 5b pop %ebx 10bd0d: 5e pop %esi 10bd0e: c9 leave 10bd0f: c3 ret if ( !ptr ) return RTEMS_INVALID_ADDRESS; if ( !result ) return RTEMS_INVALID_ADDRESS; 10bd10: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bd15: 8d 65 f8 lea -0x8(%ebp),%esp 10bd18: 5b pop %ebx 10bd19: 5e pop %esi 10bd1a: c9 leave 10bd1b: c3 ret _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 10bd1c: e8 73 1c 00 00 call 10d994 <_Thread_Enable_dispatch> return RTEMS_INVALID_ADDRESS; 10bd21: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bd26: 8d 65 f8 lea -0x8(%ebp),%esp 10bd29: 5b pop %ebx 10bd2a: 5e pop %esi 10bd2b: c9 leave 10bd2c: c3 ret =============================================================================== 0010bea8 : */ rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer ) { 10bea8: 55 push %ebp 10bea9: 89 e5 mov %esp,%ebp 10beab: 53 push %ebx 10beac: 83 ec 14 sub $0x14,%esp 10beaf: 8b 5d 08 mov 0x8(%ebp),%ebx Watchdog_Interval seconds; if ( !_TOD_Is_set ) 10beb2: 80 3d fc 84 12 00 00 cmpb $0x0,0x1284fc 10beb9: 0f 84 a9 00 00 00 je 10bf68 return RTEMS_NOT_DEFINED; if ( !time_buffer ) 10bebf: 85 db test %ebx,%ebx 10bec1: 0f 84 ad 00 00 00 je 10bf74 return RTEMS_INVALID_ADDRESS; time_buffer->ticks = 0; 10bec7: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) if ( !_TOD_Validate( time_buffer ) ) 10bece: 83 ec 0c sub $0xc,%esp 10bed1: 53 push %ebx 10bed2: e8 81 f4 ff ff call 10b358 <_TOD_Validate> 10bed7: 83 c4 10 add $0x10,%esp 10beda: 84 c0 test %al,%al 10bedc: 75 0a jne 10bee8 return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; 10bede: b8 14 00 00 00 mov $0x14,%eax &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10bee3: 8b 5d fc mov -0x4(%ebp),%ebx 10bee6: c9 leave 10bee7: c3 ret time_buffer->ticks = 0; if ( !_TOD_Validate( time_buffer ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); 10bee8: 83 ec 0c sub $0xc,%esp 10beeb: 53 push %ebx 10beec: e8 db f3 ff ff call 10b2cc <_TOD_To_seconds> if ( seconds <= _TOD_Seconds_since_epoch() ) 10bef1: 83 c4 10 add $0x10,%esp 10bef4: 3b 05 88 85 12 00 cmp 0x128588,%eax 10befa: 76 e2 jbe 10bede 10befc: 8b 15 ec 84 12 00 mov 0x1284ec,%edx 10bf02: 42 inc %edx 10bf03: 89 15 ec 84 12 00 mov %edx,0x1284ec return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME ); 10bf09: 83 ec 08 sub $0x8,%esp 10bf0c: 6a 10 push $0x10 10bf0e: ff 35 78 87 12 00 pushl 0x128778 10bf14: 89 45 f4 mov %eax,-0xc(%ebp) 10bf17: e8 9c 24 00 00 call 10e3b8 <_Thread_Set_state> _Watchdog_Initialize( &_Thread_Executing->Timer, _Thread_Delay_ended, _Thread_Executing->Object.id, 10bf1c: 8b 15 78 87 12 00 mov 0x128778,%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( 10bf22: 8b 4a 08 mov 0x8(%edx),%ecx Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10bf25: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx) the_watchdog->routine = routine; 10bf2c: c7 42 64 10 da 10 00 movl $0x10da10,0x64(%edx) the_watchdog->id = id; 10bf33: 89 4a 68 mov %ecx,0x68(%edx) the_watchdog->user_data = user_data; 10bf36: 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( 10bf3d: 8b 45 f4 mov -0xc(%ebp),%eax 10bf40: 2b 05 88 85 12 00 sub 0x128588,%eax 10bf46: 89 42 54 mov %eax,0x54(%edx) ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 10bf49: 58 pop %eax 10bf4a: 59 pop %ecx 10bf4b: 83 c2 48 add $0x48,%edx 10bf4e: 52 push %edx 10bf4f: 68 b4 85 12 00 push $0x1285b4 10bf54: e8 ef 29 00 00 call 10e948 <_Watchdog_Insert> &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); 10bf59: e8 66 1c 00 00 call 10dbc4 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10bf5e: 83 c4 10 add $0x10,%esp 10bf61: 31 c0 xor %eax,%eax 10bf63: e9 7b ff ff ff jmp 10bee3 ) { Watchdog_Interval seconds; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; 10bf68: b8 0b 00 00 00 mov $0xb,%eax &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10bf6d: 8b 5d fc mov -0x4(%ebp),%ebx 10bf70: c9 leave 10bf71: c3 ret 10bf72: 66 90 xchg %ax,%ax if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; 10bf74: b8 09 00 00 00 mov $0x9,%eax &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10bf79: 8b 5d fc mov -0x4(%ebp),%ebx 10bf7c: c9 leave 10bf7d: c3 ret =============================================================================== 00109e74 : #include int rtems_termios_baud_to_index( rtems_termios_baud_t termios_baud ) { 109e74: 55 push %ebp 109e75: 89 e5 mov %esp,%ebp 109e77: 8b 45 08 mov 0x8(%ebp),%eax int baud_index; switch (termios_baud) { 109e7a: 83 f8 09 cmp $0x9,%eax 109e7d: 0f 84 f1 00 00 00 je 109f74 109e83: 7e 37 jle 109ebc 109e85: 83 f8 0e cmp $0xe,%eax 109e88: 0f 84 f6 00 00 00 je 109f84 109e8e: 7e 5c jle 109eec 109e90: 3d 02 10 00 00 cmp $0x1002,%eax 109e95: 0f 84 01 01 00 00 je 109f9c 109e9b: 0f 8e 97 00 00 00 jle 109f38 109ea1: 3d 03 10 00 00 cmp $0x1003,%eax 109ea6: 0f 84 e0 00 00 00 je 109f8c 109eac: 3d 04 10 00 00 cmp $0x1004,%eax 109eb1: 75 51 jne 109f04 <== 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; 109eb3: b8 13 00 00 00 mov $0x13,%eax default: baud_index = -1; break; } return baud_index; } 109eb8: c9 leave 109eb9: c3 ret 109eba: 66 90 xchg %ax,%ax rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 109ebc: 83 f8 04 cmp $0x4,%eax 109ebf: 0f 84 b7 00 00 00 je 109f7c 109ec5: 7f 45 jg 109f0c 109ec7: 83 f8 01 cmp $0x1,%eax 109eca: 0f 84 8c 00 00 00 je 109f5c 109ed0: 0f 8e de 00 00 00 jle 109fb4 109ed6: 83 f8 02 cmp $0x2,%eax 109ed9: 0f 84 c5 00 00 00 je 109fa4 109edf: 83 f8 03 cmp $0x3,%eax 109ee2: 75 20 jne 109f04 <== 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; 109ee4: b8 03 00 00 00 mov $0x3,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109ee9: c9 leave 109eea: c3 ret 109eeb: 90 nop rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 109eec: 83 f8 0b cmp $0xb,%eax 109eef: 0f 84 9f 00 00 00 je 109f94 109ef5: 7c 39 jl 109f30 109ef7: 83 f8 0c cmp $0xc,%eax 109efa: 74 50 je 109f4c 109efc: 83 f8 0d cmp $0xd,%eax 109eff: 74 62 je 109f63 <== ALWAYS TAKEN 109f01: 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; 109f04: b8 ff ff ff ff mov $0xffffffff,%eax } return baud_index; } 109f09: c9 leave 109f0a: c3 ret 109f0b: 90 nop rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 109f0c: 83 f8 06 cmp $0x6,%eax 109f0f: 74 43 je 109f54 109f11: 7c 15 jl 109f28 109f13: 83 f8 07 cmp $0x7,%eax 109f16: 0f 84 90 00 00 00 je 109fac 109f1c: 83 f8 08 cmp $0x8,%eax 109f1f: 75 e3 jne 109f04 <== 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; 109f21: b8 08 00 00 00 mov $0x8,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109f26: c9 leave 109f27: 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; 109f28: b8 05 00 00 00 mov $0x5,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109f2d: c9 leave 109f2e: c3 ret 109f2f: 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; 109f30: b8 0a 00 00 00 mov $0xa,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109f35: c9 leave 109f36: c3 ret 109f37: 90 nop rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 109f38: 83 f8 0f cmp $0xf,%eax 109f3b: 74 2f je 109f6c 109f3d: 3d 01 10 00 00 cmp $0x1001,%eax 109f42: 75 c0 jne 109f04 <== 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; 109f44: b8 10 00 00 00 mov $0x10,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109f49: c9 leave 109f4a: c3 ret 109f4b: 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; 109f4c: b8 0c 00 00 00 mov $0xc,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109f51: c9 leave 109f52: c3 ret 109f53: 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; 109f54: b8 06 00 00 00 mov $0x6,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109f59: c9 leave 109f5a: c3 ret 109f5b: 90 nop { int baud_index; switch (termios_baud) { case B0: baud_index = 0; break; case B50: baud_index = 1; break; 109f5c: b8 01 00 00 00 mov $0x1,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109f61: c9 leave 109f62: 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; 109f63: b8 0d 00 00 00 mov $0xd,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109f68: c9 leave 109f69: c3 ret 109f6a: 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; 109f6c: b8 0f 00 00 00 mov $0xf,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109f71: c9 leave 109f72: c3 ret 109f73: 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; 109f74: b8 09 00 00 00 mov $0x9,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109f79: c9 leave 109f7a: c3 ret 109f7b: 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; 109f7c: b8 04 00 00 00 mov $0x4,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109f81: c9 leave 109f82: c3 ret 109f83: 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; 109f84: b8 0e 00 00 00 mov $0xe,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109f89: c9 leave 109f8a: c3 ret 109f8b: 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; 109f8c: b8 12 00 00 00 mov $0x12,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109f91: c9 leave 109f92: c3 ret 109f93: 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; 109f94: b8 0b 00 00 00 mov $0xb,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109f99: c9 leave 109f9a: c3 ret 109f9b: 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; 109f9c: b8 11 00 00 00 mov $0x11,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109fa1: c9 leave 109fa2: c3 ret 109fa3: 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; 109fa4: b8 02 00 00 00 mov $0x2,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109fa9: c9 leave 109faa: c3 ret 109fab: 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; 109fac: b8 07 00 00 00 mov $0x7,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109fb1: c9 leave 109fb2: c3 ret 109fb3: 90 nop rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 109fb4: 85 c0 test %eax,%eax 109fb6: 0f 85 48 ff ff ff jne 109f04 case B0: baud_index = 0; break; 109fbc: 31 c0 xor %eax,%eax case B460800: baud_index = 19; break; default: baud_index = -1; break; } return baud_index; } 109fbe: c9 leave 109fbf: c3 ret =============================================================================== 001084e0 : extern rtems_assoc_t termios_assoc_table[]; int32_t rtems_termios_baud_to_number( int termios_baud ) { 1084e0: 55 push %ebp 1084e1: 89 e5 mov %esp,%ebp 1084e3: 53 push %ebx 1084e4: 83 ec 0c sub $0xc,%esp 1084e7: 8b 5d 08 mov 0x8(%ebp),%ebx int baud; baud = rtems_assoc_local_by_remote( termios_assoc_table, termios_baud ); 1084ea: 53 push %ebx 1084eb: 68 a0 40 12 00 push $0x1240a0 1084f0: e8 03 6b 00 00 call 10eff8 if ( baud == 0 && termios_baud != 0 ) 1084f5: 83 c4 10 add $0x10,%esp 1084f8: 85 c0 test %eax,%eax 1084fa: 74 08 je 108504 return -1; return baud; } 1084fc: 8b 5d fc mov -0x4(%ebp),%ebx 1084ff: c9 leave 108500: c3 ret 108501: 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 ) 108504: 83 fb 01 cmp $0x1,%ebx 108507: 19 c0 sbb %eax,%eax 108509: f7 d0 not %eax 10850b: eb ef jmp 1084fc =============================================================================== 00108a64 : } } rtems_status_code rtems_termios_close (void *arg) { 108a64: 55 push %ebp 108a65: 89 e5 mov %esp,%ebp 108a67: 56 push %esi 108a68: 53 push %ebx 108a69: 8b 75 08 mov 0x8(%ebp),%esi rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 108a6c: 8b 06 mov (%esi),%eax 108a6e: 8b 58 34 mov 0x34(%eax),%ebx rtems_status_code sc; sc = rtems_semaphore_obtain( 108a71: 52 push %edx 108a72: 6a 00 push $0x0 108a74: 6a 00 push $0x0 108a76: ff 35 cc 63 12 00 pushl 0x1263cc 108a7c: e8 27 21 00 00 call 10aba8 rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 108a81: 83 c4 10 add $0x10,%esp 108a84: 85 c0 test %eax,%eax 108a86: 0f 85 9a 01 00 00 jne 108c26 <== NEVER TAKEN rtems_fatal_error_occurred (sc); if (--tty->refcount == 0) { 108a8c: 8b 43 08 mov 0x8(%ebx),%eax 108a8f: 48 dec %eax 108a90: 89 43 08 mov %eax,0x8(%ebx) 108a93: 85 c0 test %eax,%eax 108a95: 0f 85 bf 00 00 00 jne 108b5a if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 108a9b: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 108aa1: c1 e0 05 shl $0x5,%eax 108aa4: 8b 80 44 60 12 00 mov 0x126044(%eax),%eax 108aaa: 85 c0 test %eax,%eax 108aac: 0f 84 0a 01 00 00 je 108bbc /* * call discipline-specific close */ sc = rtems_termios_linesw[tty->t_line].l_close(tty); 108ab2: 83 ec 0c sub $0xc,%esp 108ab5: 53 push %ebx 108ab6: ff d0 call *%eax 108ab8: 83 c4 10 add $0x10,%esp } drainOutput (tty); rtems_semaphore_release (tty->osem); } if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 108abb: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 108ac2: 0f 84 2c 01 00 00 je 108bf4 <== 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) 108ac8: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax 108ace: 85 c0 test %eax,%eax 108ad0: 74 0d je 108adf (*tty->device.lastClose)(tty->major, tty->minor, arg); 108ad2: 51 push %ecx 108ad3: 56 push %esi 108ad4: ff 73 10 pushl 0x10(%ebx) 108ad7: ff 73 0c pushl 0xc(%ebx) 108ada: ff d0 call *%eax 108adc: 83 c4 10 add $0x10,%esp if (tty->forw == NULL) { 108adf: 8b 03 mov (%ebx),%eax 108ae1: 85 c0 test %eax,%eax 108ae3: 0f 84 b7 00 00 00 je 108ba0 rtems_termios_ttyTail = tty->back; if ( rtems_termios_ttyTail != NULL ) { rtems_termios_ttyTail->forw = NULL; } } else { tty->forw->back = tty->back; 108ae9: 8b 53 04 mov 0x4(%ebx),%edx 108aec: 89 50 04 mov %edx,0x4(%eax) 108aef: 8b 53 04 mov 0x4(%ebx),%edx } if (tty->back == NULL) { 108af2: 85 d2 test %edx,%edx 108af4: 0f 84 8a 00 00 00 je 108b84 <== ALWAYS TAKEN rtems_termios_ttyHead = tty->forw; if ( rtems_termios_ttyHead != NULL ) { rtems_termios_ttyHead->back = NULL; } } else { tty->back->forw = tty->forw; 108afa: 89 02 mov %eax,(%edx) } rtems_semaphore_delete (tty->isem); 108afc: 83 ec 0c sub $0xc,%esp 108aff: ff 73 14 pushl 0x14(%ebx) 108b02: e8 fd 1f 00 00 call 10ab04 rtems_semaphore_delete (tty->osem); 108b07: 5a pop %edx 108b08: ff 73 18 pushl 0x18(%ebx) 108b0b: e8 f4 1f 00 00 call 10ab04 rtems_semaphore_delete (tty->rawOutBuf.Semaphore); 108b10: 58 pop %eax 108b11: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 108b17: e8 e8 1f 00 00 call 10ab04 if ((tty->device.pollRead == NULL) || 108b1c: 83 c4 10 add $0x10,%esp 108b1f: 8b b3 a0 00 00 00 mov 0xa0(%ebx),%esi 108b25: 85 f6 test %esi,%esi 108b27: 74 4b je 108b74 108b29: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 108b30: 74 42 je 108b74 (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)) rtems_semaphore_delete (tty->rawInBuf.Semaphore); free (tty->rawInBuf.theBuf); 108b32: 83 ec 0c sub $0xc,%esp 108b35: ff 73 58 pushl 0x58(%ebx) 108b38: e8 f7 ea ff ff call 107634 free (tty->rawOutBuf.theBuf); 108b3d: 59 pop %ecx 108b3e: ff 73 7c pushl 0x7c(%ebx) 108b41: e8 ee ea ff ff call 107634 free (tty->cbuf); 108b46: 5a pop %edx 108b47: ff 73 1c pushl 0x1c(%ebx) 108b4a: e8 e5 ea ff ff call 107634 free (tty); 108b4f: 89 1c 24 mov %ebx,(%esp) 108b52: e8 dd ea ff ff call 107634 108b57: 83 c4 10 add $0x10,%esp } rtems_semaphore_release (rtems_termios_ttyMutex); 108b5a: 83 ec 0c sub $0xc,%esp 108b5d: ff 35 cc 63 12 00 pushl 0x1263cc 108b63: e8 3c 21 00 00 call 10aca4 return RTEMS_SUCCESSFUL; } 108b68: 31 c0 xor %eax,%eax 108b6a: 8d 65 f8 lea -0x8(%ebp),%esp 108b6d: 5b pop %ebx 108b6e: 5e pop %esi 108b6f: c9 leave 108b70: c3 ret 108b71: 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); 108b74: 83 ec 0c sub $0xc,%esp 108b77: ff 73 68 pushl 0x68(%ebx) 108b7a: e8 85 1f 00 00 call 10ab04 108b7f: 83 c4 10 add $0x10,%esp 108b82: eb ae jmp 108b32 } else { tty->forw->back = tty->back; } if (tty->back == NULL) { rtems_termios_ttyHead = tty->forw; 108b84: a3 d4 63 12 00 mov %eax,0x1263d4 if ( rtems_termios_ttyHead != NULL ) { 108b89: 85 c0 test %eax,%eax 108b8b: 0f 84 6b ff ff ff je 108afc rtems_termios_ttyHead->back = NULL; 108b91: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) 108b98: e9 5f ff ff ff jmp 108afc 108b9d: 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; 108ba0: 8b 53 04 mov 0x4(%ebx),%edx 108ba3: 89 15 d0 63 12 00 mov %edx,0x1263d0 if ( rtems_termios_ttyTail != NULL ) { 108ba9: 85 d2 test %edx,%edx 108bab: 74 d7 je 108b84 rtems_termios_ttyTail->forw = NULL; 108bad: c7 02 00 00 00 00 movl $0x0,(%edx) 108bb3: 8b 03 mov (%ebx),%eax 108bb5: e9 40 ff ff ff jmp 108afa 108bba: 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); 108bbc: 50 push %eax 108bbd: 6a 00 push $0x0 108bbf: 6a 00 push $0x0 108bc1: ff 73 18 pushl 0x18(%ebx) 108bc4: e8 df 1f 00 00 call 10aba8 if (sc != RTEMS_SUCCESSFUL) { 108bc9: 83 c4 10 add $0x10,%esp 108bcc: 85 c0 test %eax,%eax 108bce: 75 56 jne 108c26 <== NEVER TAKEN rtems_fatal_error_occurred (sc); } drainOutput (tty); 108bd0: 89 d8 mov %ebx,%eax 108bd2: e8 75 f9 ff ff call 10854c rtems_semaphore_release (tty->osem); 108bd7: 83 ec 0c sub $0xc,%esp 108bda: ff 73 18 pushl 0x18(%ebx) 108bdd: e8 c2 20 00 00 call 10aca4 108be2: 83 c4 10 add $0x10,%esp } if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 108be5: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 108bec: 0f 85 d6 fe ff ff jne 108ac8 108bf2: 66 90 xchg %ax,%ax /* * send "terminate" to I/O tasks */ sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT ); 108bf4: 83 ec 08 sub $0x8,%esp 108bf7: 6a 01 push $0x1 108bf9: ff b3 c4 00 00 00 pushl 0xc4(%ebx) 108bff: e8 40 1b 00 00 call 10a744 if (sc != RTEMS_SUCCESSFUL) 108c04: 83 c4 10 add $0x10,%esp 108c07: 85 c0 test %eax,%eax 108c09: 75 1b jne 108c26 <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT ); 108c0b: 83 ec 08 sub $0x8,%esp 108c0e: 6a 01 push $0x1 108c10: ff b3 c8 00 00 00 pushl 0xc8(%ebx) 108c16: e8 29 1b 00 00 call 10a744 if (sc != RTEMS_SUCCESSFUL) 108c1b: 83 c4 10 add $0x10,%esp 108c1e: 85 c0 test %eax,%eax 108c20: 0f 84 a2 fe ff ff je 108ac8 <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 108c26: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108c29: 50 push %eax <== NOT EXECUTED 108c2a: e8 b9 25 00 00 call 10b1e8 <== NOT EXECUTED =============================================================================== 0010a10c : * for each transmitted character. * It returns number of characters left to transmit */ int rtems_termios_dequeue_characters (void *ttyp, int len) { 10a10c: 55 push %ebp 10a10d: 89 e5 mov %esp,%ebp 10a10f: 83 ec 08 sub $0x8,%esp 10a112: 8b 45 08 mov 0x8(%ebp),%eax rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len; 10a115: 8b 55 0c mov 0xc(%ebp),%edx 10a118: 01 90 90 00 00 00 add %edx,0x90(%eax) if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 10a11e: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax) 10a125: 74 2d je 10a154 if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); return 0; /* nothing to output in IRQ... */ } if (tty->t_line == PPPDISC ) { 10a127: 83 b8 cc 00 00 00 05 cmpl $0x5,0xcc(%eax) 10a12e: 74 0c je 10a13c rtems_termios_linesw[tty->t_line].l_start(tty); } return 0; /* nothing to output in IRQ... */ } return rtems_termios_refill_transmitter(tty); 10a130: 89 45 08 mov %eax,0x8(%ebp) } 10a133: c9 leave rtems_termios_linesw[tty->t_line].l_start(tty); } return 0; /* nothing to output in IRQ... */ } return rtems_termios_refill_transmitter(tty); 10a134: e9 27 fd ff ff jmp 109e60 10a139: 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) { 10a13c: 8b 15 f4 60 12 00 mov 0x1260f4,%edx 10a142: 85 d2 test %edx,%edx 10a144: 74 09 je 10a14f <== NEVER TAKEN rtems_termios_linesw[tty->t_line].l_start(tty); 10a146: 83 ec 0c sub $0xc,%esp 10a149: 50 push %eax 10a14a: ff d2 call *%edx 10a14c: 83 c4 10 add $0x10,%esp } return 0; /* nothing to output in IRQ... */ } return rtems_termios_refill_transmitter(tty); } 10a14f: 31 c0 xor %eax,%eax 10a151: c9 leave 10a152: c3 ret 10a153: 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); 10a154: 83 ec 08 sub $0x8,%esp 10a157: 6a 02 push $0x2 10a159: ff b0 c8 00 00 00 pushl 0xc8(%eax) 10a15f: e8 e0 05 00 00 call 10a744 if (sc != RTEMS_SUCCESSFUL) 10a164: 83 c4 10 add $0x10,%esp 10a167: 85 c0 test %eax,%eax 10a169: 74 e4 je 10a14f <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 10a16b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a16e: 50 push %eax <== NOT EXECUTED 10a16f: e8 74 10 00 00 call 10b1e8 <== NOT EXECUTED =============================================================================== 00109ae8 : * 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) { 109ae8: 55 push %ebp 109ae9: 89 e5 mov %esp,%ebp 109aeb: 57 push %edi 109aec: 56 push %esi 109aed: 53 push %ebx 109aee: 83 ec 3c sub $0x3c,%esp 109af1: 8b 5d 08 mov 0x8(%ebp),%ebx 109af4: 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) { 109af7: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 109afd: c1 e0 05 shl $0x5,%eax 109b00: 8b 80 50 60 12 00 mov 0x126050(%eax),%eax 109b06: 85 c0 test %eax,%eax 109b08: 0f 84 8a 00 00 00 je 109b98 while (len--) { 109b0e: 8b 4d 10 mov 0x10(%ebp),%ecx 109b11: 85 c9 test %ecx,%ecx 109b13: 74 2a je 109b3f <== NEVER TAKEN 109b15: 31 ff xor %edi,%edi 109b17: eb 12 jmp 109b2b 109b19: 8d 76 00 lea 0x0(%esi),%esi 109b1c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 109b22: c1 e0 05 shl $0x5,%eax 109b25: 8b 80 50 60 12 00 mov 0x126050(%eax),%eax c = *buf++; rtems_termios_linesw[tty->t_line].l_rint(c,tty); 109b2b: 83 ec 08 sub $0x8,%esp 109b2e: 53 push %ebx 109b2f: 0f be 14 3e movsbl (%esi,%edi,1),%edx 109b33: 52 push %edx 109b34: ff d0 call *%eax 109b36: 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--) { 109b37: 83 c4 10 add $0x10,%esp 109b3a: 3b 7d 10 cmp 0x10(%ebp),%edi 109b3d: 75 dd jne 109b1c } /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 109b3f: 8b 93 e4 00 00 00 mov 0xe4(%ebx),%edx 109b45: 85 d2 test %edx,%edx 109b47: 75 3b jne 109b84 <== NEVER TAKEN 109b49: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax 109b4f: 85 c0 test %eax,%eax 109b51: 74 31 je 109b84 <== NEVER TAKEN (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 109b53: 83 ec 08 sub $0x8,%esp 109b56: ff b3 e0 00 00 00 pushl 0xe0(%ebx) 109b5c: 8d 53 30 lea 0x30(%ebx),%edx 109b5f: 52 push %edx 109b60: ff d0 call *%eax tty->tty_rcvwakeup = 1; 109b62: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) 109b69: 00 00 00 109b6c: 83 c4 10 add $0x10,%esp } return 0; 109b6f: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped; } 109b76: 8b 45 e0 mov -0x20(%ebp),%eax 109b79: 8d 65 f4 lea -0xc(%ebp),%esp 109b7c: 5b pop %ebx 109b7d: 5e pop %esi 109b7e: 5f pop %edi 109b7f: c9 leave 109b80: c3 ret 109b81: 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; 109b84: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped; } 109b8b: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 109b8e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109b91: 5b pop %ebx <== NOT EXECUTED 109b92: 5e pop %esi <== NOT EXECUTED 109b93: 5f pop %edi <== NOT EXECUTED 109b94: c9 leave <== NOT EXECUTED 109b95: c3 ret <== NOT EXECUTED 109b96: 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) { 109b98: 8b 7d 10 mov 0x10(%ebp),%edi 109b9b: c6 45 db 00 movb $0x0,-0x25(%ebp) 109b9f: 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); 109ba6: 8d 43 30 lea 0x30(%ebx),%eax 109ba9: 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, 109bac: 8d 53 4a lea 0x4a(%ebx),%edx 109baf: 89 55 cc mov %edx,-0x34(%ebp) tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 109bb2: 85 ff test %edi,%edi 109bb4: 0f 84 0b 01 00 00 je 109cc5 <== NEVER TAKEN 109bba: 66 90 xchg %ax,%ax c = *buf++; 109bbc: 8a 06 mov (%esi),%al 109bbe: 88 45 e7 mov %al,-0x19(%ebp) 109bc1: 46 inc %esi /* FIXME: implement IXANY: any character restarts output */ /* if incoming XON/XOFF controls outgoing stream: */ if (tty->flow_ctrl & FL_MDXON) { 109bc2: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109bc8: f6 c4 02 test $0x2,%ah 109bcb: 74 1c je 109be9 /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { 109bcd: 0f be 45 e7 movsbl -0x19(%ebp),%eax 109bd1: 0f b6 53 4a movzbl 0x4a(%ebx),%edx 109bd5: 39 d0 cmp %edx,%eax 109bd7: 0f 84 07 01 00 00 je 109ce4 /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; } flow_rcv = true; } else if (c == tty->termios.c_cc[VSTART]) { 109bdd: 0f b6 53 49 movzbl 0x49(%ebx),%edx 109be1: 39 d0 cmp %edx,%eax 109be3: 0f 84 4f 01 00 00 je 109d38 <== NEVER TAKEN /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; flow_rcv = true; } } if (flow_rcv) { 109be9: 80 7d db 00 cmpb $0x0,-0x25(%ebp) 109bed: 0f 85 0c 01 00 00 jne 109cff <== NEVER TAKEN } /* reenable interrupts */ rtems_interrupt_enable(level); } } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; 109bf3: 8b 43 60 mov 0x60(%ebx),%eax 109bf6: 8b 53 64 mov 0x64(%ebx),%edx 109bf9: 89 55 dc mov %edx,-0x24(%ebp) 109bfc: 40 inc %eax 109bfd: 31 d2 xor %edx,%edx 109bff: f7 75 dc divl -0x24(%ebp) 109c02: 89 d1 mov %edx,%ecx /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); 109c04: 9c pushf 109c05: fa cli 109c06: 8f 45 d4 popl -0x2c(%ebp) if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 109c09: 8b 43 5c mov 0x5c(%ebx),%eax 109c0c: 89 45 c4 mov %eax,-0x3c(%ebp) 109c0f: 8b 43 64 mov 0x64(%ebx),%eax % tty->rawInBuf.Size) > tty->highwater) && 109c12: 8b 53 64 mov 0x64(%ebx),%edx 109c15: 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) 109c18: 2b 45 c4 sub -0x3c(%ebp),%eax 109c1b: 01 c8 add %ecx,%eax % tty->rawInBuf.Size) > tty->highwater) && 109c1d: 31 d2 xor %edx,%edx 109c1f: 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) 109c22: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx 109c28: 76 46 jbe 109c70 <== ALWAYS TAKEN % tty->rawInBuf.Size) > tty->highwater) && !(tty->flow_ctrl & FL_IREQXOF)) { 109c2a: 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) && 109c30: a8 01 test $0x1,%al <== NOT EXECUTED 109c32: 75 3c jne 109c70 <== NOT EXECUTED !(tty->flow_ctrl & FL_IREQXOF)) { /* incoming data stream should be stopped */ tty->flow_ctrl |= FL_IREQXOF; 109c34: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109c3a: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 109c3d: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF)) 109c43: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109c49: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED 109c4e: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED 109c53: 0f 84 22 01 00 00 je 109d7b <== 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) ) { 109c59: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109c5f: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED 109c64: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED 109c69: 0f 84 50 01 00 00 je 109dbf <== NOT EXECUTED 109c6f: 90 nop <== NOT EXECUTED } } } /* reenable interrupts */ rtems_interrupt_enable(level); 109c70: ff 75 d4 pushl -0x2c(%ebp) 109c73: 9d popf if (newTail == tty->rawInBuf.Head) { 109c74: 8b 43 5c mov 0x5c(%ebx),%eax 109c77: 39 c8 cmp %ecx,%eax 109c79: 0f 84 b1 00 00 00 je 109d30 <== NEVER TAKEN dropped++; } else { tty->rawInBuf.theBuf[newTail] = c; 109c7f: 8b 43 58 mov 0x58(%ebx),%eax 109c82: 8a 55 e7 mov -0x19(%ebp),%dl 109c85: 88 14 08 mov %dl,(%eax,%ecx,1) tty->rawInBuf.Tail = newTail; 109c88: 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 )) { 109c8b: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax 109c91: 85 c0 test %eax,%eax 109c93: 75 27 jne 109cbc <== NEVER TAKEN 109c95: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax 109c9b: 85 c0 test %eax,%eax 109c9d: 74 1d je 109cbc <== ALWAYS TAKEN (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 109c9f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109ca2: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED 109ca8: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED 109cab: ff d0 call *%eax <== NOT EXECUTED tty->tty_rcvwakeup = 1; 109cad: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED 109cb4: 00 00 00 109cb7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109cba: 66 90 xchg %ax,%ax <== NOT EXECUTED 109cbc: 4f dec %edi tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 109cbd: 85 ff test %edi,%edi 109cbf: 0f 85 f7 fe ff ff jne 109bbc <== NEVER TAKEN } } } } tty->rawInBufDropped += dropped; 109cc5: 8b 45 e0 mov -0x20(%ebp),%eax 109cc8: 01 43 78 add %eax,0x78(%ebx) rtems_semaphore_release (tty->rawInBuf.Semaphore); 109ccb: 83 ec 0c sub $0xc,%esp 109cce: ff 73 68 pushl 0x68(%ebx) 109cd1: e8 ce 0f 00 00 call 10aca4 return dropped; 109cd6: 83 c4 10 add $0x10,%esp } 109cd9: 8b 45 e0 mov -0x20(%ebp),%eax 109cdc: 8d 65 f4 lea -0xc(%ebp),%esp 109cdf: 5b pop %ebx 109ce0: 5e pop %esi 109ce1: 5f pop %edi 109ce2: c9 leave 109ce3: 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]) { 109ce4: 0f b6 53 49 movzbl 0x49(%ebx),%edx 109ce8: 39 d0 cmp %edx,%eax 109cea: 74 7e je 109d6a <== NEVER TAKEN tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; } else { /* VSTOP received (other code than VSTART) */ /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; 109cec: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109cf2: 83 c8 10 or $0x10,%eax 109cf5: 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--) { 109cfb: 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) { 109cff: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109d05: 83 e0 30 and $0x30,%eax 109d08: 83 f8 20 cmp $0x20,%eax 109d0b: 75 af jne 109cbc <== ALWAYS TAKEN /* disable interrupts */ rtems_interrupt_disable(level); 109d0d: 9c pushf <== NOT EXECUTED 109d0e: fa cli <== NOT EXECUTED 109d0f: 5a pop %edx <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 109d10: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109d16: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 109d19: 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) { 109d1f: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax <== NOT EXECUTED 109d25: 85 c0 test %eax,%eax <== NOT EXECUTED 109d27: 75 20 jne 109d49 <== 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); 109d29: 52 push %edx <== NOT EXECUTED 109d2a: 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; 109d2b: 4f dec %edi <== NOT EXECUTED 109d2c: eb 8f jmp 109cbd <== NOT EXECUTED 109d2e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* reenable interrupts */ rtems_interrupt_enable(level); if (newTail == tty->rawInBuf.Head) { dropped++; 109d30: 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; 109d33: 4f dec %edi <== NOT EXECUTED 109d34: eb 87 jmp 109cbd <== NOT EXECUTED 109d36: 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; 109d38: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109d3e: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED 109d41: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED 109d47: eb b2 jmp 109cfb <== 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); 109d49: 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)( 109d4f: 51 push %ecx <== NOT EXECUTED 109d50: 6a 01 push $0x1 <== NOT EXECUTED 109d52: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 109d55: 50 push %eax <== NOT EXECUTED 109d56: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109d59: 89 55 c8 mov %edx,-0x38(%ebp) <== NOT EXECUTED 109d5c: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 109d62: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109d65: 8b 55 c8 mov -0x38(%ebp),%edx <== NOT EXECUTED 109d68: eb bf jmp 109d29 <== 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; 109d6a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109d70: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED 109d73: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED 109d79: eb 80 jmp 109cfb <== 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) || 109d7b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109d81: a8 20 test $0x20,%al <== NOT EXECUTED 109d83: 75 0e jne 109d93 <== NOT EXECUTED 109d85: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax <== NOT EXECUTED 109d8b: 85 c0 test %eax,%eax <== NOT EXECUTED 109d8d: 0f 85 dd fe ff ff jne 109c70 <== 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; 109d93: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109d99: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 109d9c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED (*tty->device.write)(tty->minor, 109da2: 52 push %edx <== NOT EXECUTED 109da3: 6a 01 push $0x1 <== NOT EXECUTED 109da5: ff 75 cc pushl -0x34(%ebp) <== NOT EXECUTED 109da8: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109dab: 89 4d c8 mov %ecx,-0x38(%ebp) <== NOT EXECUTED 109dae: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 109db4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109db7: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 109dba: e9 b1 fe ff ff jmp 109c70 <== 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; 109dbf: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109dc5: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 109dc8: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* deactivate RTS line */ if (tty->device.stopRemoteTx != NULL) { 109dce: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED 109dd4: 85 c0 test %eax,%eax <== NOT EXECUTED 109dd6: 0f 84 94 fe ff ff je 109c70 <== NOT EXECUTED tty->device.stopRemoteTx(tty->minor); 109ddc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109ddf: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109de2: 89 4d c8 mov %ecx,-0x38(%ebp) <== NOT EXECUTED 109de5: ff d0 call *%eax <== NOT EXECUTED 109de7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109dea: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 109ded: e9 7e fe ff ff jmp 109c70 <== NOT EXECUTED =============================================================================== 00108510 : struct rtems_termios_tty *rtems_termios_ttyTail; rtems_id rtems_termios_ttyMutex; void rtems_termios_initialize (void) { 108510: 55 push %ebp 108511: 89 e5 mov %esp,%ebp 108513: 83 ec 08 sub $0x8,%esp rtems_status_code sc; /* * Create the mutex semaphore for the tty list */ if (!rtems_termios_ttyMutex) { 108516: a1 cc 63 12 00 mov 0x1263cc,%eax 10851b: 85 c0 test %eax,%eax 10851d: 74 05 je 108524 RTEMS_NO_PRIORITY, &rtems_termios_ttyMutex); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } } 10851f: c9 leave 108520: c3 ret 108521: 8d 76 00 lea 0x0(%esi),%esi /* * Create the mutex semaphore for the tty list */ if (!rtems_termios_ttyMutex) { sc = rtems_semaphore_create ( 108524: 83 ec 0c sub $0xc,%esp 108527: 68 cc 63 12 00 push $0x1263cc 10852c: 6a 00 push $0x0 10852e: 6a 54 push $0x54 108530: 6a 01 push $0x1 108532: 68 69 6d 52 54 push $0x54526d69 108537: e8 f0 23 00 00 call 10a92c 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) 10853c: 83 c4 20 add $0x20,%esp 10853f: 85 c0 test %eax,%eax 108541: 74 dc je 10851f rtems_fatal_error_occurred (sc); 108543: 83 ec 0c sub $0xc,%esp 108546: 50 push %eax 108547: e8 9c 2c 00 00 call 10b1e8 =============================================================================== 00108c50 : } } rtems_status_code rtems_termios_ioctl (void *arg) { 108c50: 55 push %ebp 108c51: 89 e5 mov %esp,%ebp 108c53: 57 push %edi 108c54: 56 push %esi 108c55: 53 push %ebx 108c56: 83 ec 20 sub $0x20,%esp 108c59: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 108c5c: 8b 03 mov (%ebx),%eax 108c5e: 8b 40 34 mov 0x34(%eax),%eax 108c61: 89 45 e4 mov %eax,-0x1c(%ebp) struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer; 108c64: 8b 73 08 mov 0x8(%ebx),%esi rtems_status_code sc; args->ioctl_return = 0; 108c67: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 108c6e: 6a 00 push $0x0 108c70: 6a 00 push $0x0 108c72: ff 70 18 pushl 0x18(%eax) 108c75: e8 2e 1f 00 00 call 10aba8 108c7a: 89 45 e0 mov %eax,-0x20(%ebp) if (sc != RTEMS_SUCCESSFUL) { 108c7d: 83 c4 10 add $0x10,%esp 108c80: 85 c0 test %eax,%eax 108c82: 75 24 jne 108ca8 <== NEVER TAKEN args->ioctl_return = sc; return sc; } switch (args->command) { 108c84: 8b 43 04 mov 0x4(%ebx),%eax 108c87: 83 f8 04 cmp $0x4,%eax 108c8a: 74 70 je 108cfc 108c8c: 77 2a ja 108cb8 108c8e: 83 f8 02 cmp $0x2,%eax 108c91: 0f 84 9d 00 00 00 je 108d34 108c97: 0f 86 3f 02 00 00 jbe 108edc if (tty->device.setAttributes) (*tty->device.setAttributes)(tty->minor, &tty->termios); break; case RTEMS_IO_TCDRAIN: drainOutput (tty); 108c9d: 8b 45 e4 mov -0x1c(%ebp),%eax 108ca0: e8 a7 f8 ff ff call 10854c break; 108ca5: eb 69 jmp 108d10 108ca7: 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; 108ca8: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED } rtems_semaphore_release (tty->osem); args->ioctl_return = sc; return sc; } 108cab: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 108cae: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108cb1: 5b pop %ebx <== NOT EXECUTED 108cb2: 5e pop %esi <== NOT EXECUTED 108cb3: 5f pop %edi <== NOT EXECUTED 108cb4: c9 leave <== NOT EXECUTED 108cb5: c3 ret <== NOT EXECUTED 108cb6: 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) { 108cb8: 3d 7f 66 04 40 cmp $0x4004667f,%eax 108cbd: 0f 84 f1 01 00 00 je 108eb4 <== NEVER TAKEN 108cc3: 0f 87 33 02 00 00 ja 108efc 108cc9: 83 f8 05 cmp $0x5,%eax 108ccc: 0f 84 ae 02 00 00 je 108f80 default: if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) { 108cd2: 8b 55 e4 mov -0x1c(%ebp),%edx 108cd5: 8b 82 cc 00 00 00 mov 0xcc(%edx),%eax 108cdb: c1 e0 05 shl $0x5,%eax 108cde: 8b 80 58 60 12 00 mov 0x126058(%eax),%eax 108ce4: 85 c0 test %eax,%eax 108ce6: 0f 84 b8 02 00 00 je 108fa4 <== NEVER TAKEN sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args); 108cec: 83 ec 08 sub $0x8,%esp 108cef: 53 push %ebx 108cf0: 52 push %edx 108cf1: ff d0 call *%eax 108cf3: 89 45 e0 mov %eax,-0x20(%ebp) 108cf6: 83 c4 10 add $0x10,%esp 108cf9: eb 15 jmp 108d10 108cfb: 90 nop case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; break; case RTEMS_IO_RCVWAKEUP: tty->tty_rcv = *wakeup; 108cfc: 8b 06 mov (%esi),%eax 108cfe: 8b 56 04 mov 0x4(%esi),%edx 108d01: 8b 4d e4 mov -0x1c(%ebp),%ecx 108d04: 89 81 dc 00 00 00 mov %eax,0xdc(%ecx) 108d0a: 89 91 e0 00 00 00 mov %edx,0xe0(%ecx) *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; } break; } rtems_semaphore_release (tty->osem); 108d10: 83 ec 0c sub $0xc,%esp 108d13: 8b 45 e4 mov -0x1c(%ebp),%eax 108d16: ff 70 18 pushl 0x18(%eax) 108d19: e8 86 1f 00 00 call 10aca4 args->ioctl_return = sc; 108d1e: 8b 55 e0 mov -0x20(%ebp),%edx 108d21: 89 53 0c mov %edx,0xc(%ebx) return sc; 108d24: 83 c4 10 add $0x10,%esp } 108d27: 8b 45 e0 mov -0x20(%ebp),%eax 108d2a: 8d 65 f4 lea -0xc(%ebp),%esp 108d2d: 5b pop %ebx 108d2e: 5e pop %esi 108d2f: 5f pop %edi 108d30: c9 leave 108d31: c3 ret 108d32: 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; 108d34: 8b 73 08 mov 0x8(%ebx),%esi 108d37: 8b 4d e4 mov -0x1c(%ebp),%ecx 108d3a: 83 c1 30 add $0x30,%ecx 108d3d: 89 4d dc mov %ecx,-0x24(%ebp) 108d40: b9 09 00 00 00 mov $0x9,%ecx 108d45: 8b 7d dc mov -0x24(%ebp),%edi 108d48: 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) && 108d4a: 8b 55 e4 mov -0x1c(%ebp),%edx 108d4d: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax 108d53: f6 c4 02 test $0x2,%ah 108d56: 74 44 je 108d9c 108d58: f6 42 31 04 testb $0x4,0x31(%edx) 108d5c: 75 3e jne 108d9c !(tty->termios.c_iflag & IXON)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF); 108d5e: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax 108d64: 25 ef fd ff ff and $0xfffffdef,%eax 108d69: 89 82 b8 00 00 00 mov %eax,0xb8(%edx) /* has output been stopped due to received XOFF? */ if (tty->flow_ctrl & FL_OSTOP) { 108d6f: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax 108d75: a8 20 test $0x20,%al 108d77: 74 23 je 108d9c <== ALWAYS TAKEN /* disable interrupts */ rtems_interrupt_disable(level); 108d79: 9c pushf <== NOT EXECUTED 108d7a: fa cli <== NOT EXECUTED 108d7b: 5e pop %esi <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 108d7c: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax <== NOT EXECUTED 108d82: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 108d85: 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) { 108d8b: 8b ba 94 00 00 00 mov 0x94(%edx),%edi <== NOT EXECUTED 108d91: 85 ff test %edi,%edi <== NOT EXECUTED 108d93: 0f 85 bb 02 00 00 jne 109054 <== 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); 108d99: 56 push %esi <== NOT EXECUTED 108d9a: 9d popf <== NOT EXECUTED 108d9b: 90 nop <== NOT EXECUTED } } /* check for incoming XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) { 108d9c: 8b 4d e4 mov -0x1c(%ebp),%ecx 108d9f: 8b 81 b8 00 00 00 mov 0xb8(%ecx),%eax 108da5: f6 c4 04 test $0x4,%ah 108da8: 74 24 je 108dce 108daa: f6 41 31 10 testb $0x10,0x31(%ecx) 108dae: 75 1e jne 108dce /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXOF); 108db0: 8b 81 b8 00 00 00 mov 0xb8(%ecx),%eax 108db6: 80 e4 fb and $0xfb,%ah 108db9: 89 81 b8 00 00 00 mov %eax,0xb8(%ecx) /* FIXME: what happens, if we had sent XOFF but not yet XON? */ tty->flow_ctrl &= ~(FL_ISNTXOF); 108dbf: 8b 81 b8 00 00 00 mov 0xb8(%ecx),%eax 108dc5: 83 e0 fd and $0xfffffffd,%eax 108dc8: 89 81 b8 00 00 00 mov %eax,0xb8(%ecx) } /* check for incoming RTS/CTS flow control switched off */ if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) { 108dce: 8b 55 e4 mov -0x1c(%ebp),%edx 108dd1: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax 108dd7: f6 c4 01 test $0x1,%ah 108dda: 0f 84 bc 01 00 00 je 108f9c <== ALWAYS TAKEN 108de0: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 108de3: 8b 41 38 mov 0x38(%ecx),%eax <== NOT EXECUTED 108de6: 85 c0 test %eax,%eax <== NOT EXECUTED 108de8: 0f 88 12 02 00 00 js 109000 <== NOT EXECUTED /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDRTS); 108dee: 8b 91 b8 00 00 00 mov 0xb8(%ecx),%edx <== NOT EXECUTED 108df4: 80 e6 fe and $0xfe,%dh <== NOT EXECUTED 108df7: 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)) { 108dfd: 8b 91 b8 00 00 00 mov 0xb8(%ecx),%edx <== NOT EXECUTED 108e03: 83 e2 04 and $0x4,%edx <== NOT EXECUTED 108e06: 74 1b je 108e23 <== NOT EXECUTED 108e08: 8b 91 b0 00 00 00 mov 0xb0(%ecx),%edx <== NOT EXECUTED 108e0e: 85 d2 test %edx,%edx <== NOT EXECUTED 108e10: 74 11 je 108e23 <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 108e12: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108e15: ff 71 10 pushl 0x10(%ecx) <== NOT EXECUTED 108e18: ff d2 call *%edx <== NOT EXECUTED 108e1a: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 108e1d: 8b 42 38 mov 0x38(%edx),%eax <== NOT EXECUTED 108e20: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } tty->flow_ctrl &= ~(FL_IRTSOFF); 108e23: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 108e26: 8b 91 b8 00 00 00 mov 0xb8(%ecx),%edx <== NOT EXECUTED 108e2c: 83 e2 fb and $0xfffffffb,%edx <== NOT EXECUTED 108e2f: 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) { 108e35: 85 c0 test %eax,%eax 108e37: 0f 88 c3 01 00 00 js 109000 <== NEVER TAKEN tty->flow_ctrl |= FL_MDRTS; } /* check for incoming XON/XOF flow control switched on */ if (tty->termios.c_iflag & IXOFF) { 108e3d: 8b 4d e4 mov -0x1c(%ebp),%ecx 108e40: 8b 41 30 mov 0x30(%ecx),%eax 108e43: f6 c4 10 test $0x10,%ah 108e46: 74 0f je 108e57 tty->flow_ctrl |= FL_MDXOF; 108e48: 8b 91 b8 00 00 00 mov 0xb8(%ecx),%edx 108e4e: 80 ce 04 or $0x4,%dh 108e51: 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) { 108e57: f6 c4 04 test $0x4,%ah 108e5a: 74 12 je 108e6e tty->flow_ctrl |= FL_MDXON; 108e5c: 8b 55 e4 mov -0x1c(%ebp),%edx 108e5f: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax 108e65: 80 cc 02 or $0x2,%ah 108e68: 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) { 108e6e: 8b 4d e4 mov -0x1c(%ebp),%ecx 108e71: f6 41 3c 02 testb $0x2,0x3c(%ecx) 108e75: 0f 84 41 01 00 00 je 108fbc tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 108e7b: c7 41 6c 00 00 00 00 movl $0x0,0x6c(%ecx) tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; 108e82: c7 41 70 00 00 00 00 movl $0x0,0x70(%ecx) tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; 108e89: c7 41 74 00 00 00 00 movl $0x0,0x74(%ecx) } else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; } } } if (tty->device.setAttributes) 108e90: 8b 55 e4 mov -0x1c(%ebp),%edx 108e93: 8b 82 a8 00 00 00 mov 0xa8(%edx),%eax 108e99: 85 c0 test %eax,%eax 108e9b: 0f 84 6f fe ff ff je 108d10 <== NEVER TAKEN (*tty->device.setAttributes)(tty->minor, &tty->termios); 108ea1: 83 ec 08 sub $0x8,%esp 108ea4: ff 75 dc pushl -0x24(%ebp) 108ea7: ff 72 10 pushl 0x10(%edx) 108eaa: ff d0 call *%eax 108eac: 83 c4 10 add $0x10,%esp 108eaf: e9 5c fe ff ff jmp 108d10 case TIOCGETD: *(int*)(args->buffer)=tty->t_line; break; #endif case FIONREAD: { int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head; 108eb4: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 108eb7: 8b 42 60 mov 0x60(%edx),%eax <== NOT EXECUTED 108eba: 89 d1 mov %edx,%ecx <== NOT EXECUTED 108ebc: 8b 52 5c mov 0x5c(%edx),%edx <== NOT EXECUTED if ( rawnc < 0 ) 108ebf: 29 d0 sub %edx,%eax <== NOT EXECUTED 108ec1: 0f 88 e9 00 00 00 js 108fb0 <== NOT EXECUTED rawnc += tty->rawInBuf.Size; /* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; 108ec7: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 108eca: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 108ecd: 03 41 20 add 0x20(%ecx),%eax <== NOT EXECUTED 108ed0: 2b 41 24 sub 0x24(%ecx),%eax <== NOT EXECUTED 108ed3: 89 02 mov %eax,(%edx) <== NOT EXECUTED } break; 108ed5: e9 36 fe ff ff jmp 108d10 <== NOT EXECUTED 108eda: 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) { 108edc: 48 dec %eax 108edd: 0f 85 ef fd ff ff jne 108cd2 <== NEVER TAKEN sc = RTEMS_INVALID_NUMBER; } break; case RTEMS_IO_GET_ATTRIBUTES: *(struct termios *)args->buffer = tty->termios; 108ee3: 8b 43 08 mov 0x8(%ebx),%eax 108ee6: 8b 75 e4 mov -0x1c(%ebp),%esi 108ee9: 83 c6 30 add $0x30,%esi 108eec: b9 09 00 00 00 mov $0x9,%ecx 108ef1: 89 c7 mov %eax,%edi 108ef3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) break; 108ef5: e9 16 fe ff ff jmp 108d10 108efa: 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) { 108efc: 3d 1a 74 04 40 cmp $0x4004741a,%eax 108f01: 74 69 je 108f6c 108f03: 3d 1b 74 04 80 cmp $0x8004741b,%eax 108f08: 0f 85 c4 fd ff ff jne 108cd2 <== NEVER TAKEN #if 1 /* FIXME */ case TIOCSETD: /* * close old line discipline */ if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 108f0e: 8b 55 e4 mov -0x1c(%ebp),%edx 108f11: 8b 82 cc 00 00 00 mov 0xcc(%edx),%eax 108f17: c1 e0 05 shl $0x5,%eax 108f1a: 8b 80 44 60 12 00 mov 0x126044(%eax),%eax 108f20: 85 c0 test %eax,%eax 108f22: 74 0c je 108f30 sc = rtems_termios_linesw[tty->t_line].l_close(tty); 108f24: 83 ec 0c sub $0xc,%esp 108f27: 52 push %edx 108f28: ff d0 call *%eax 108f2a: 89 45 e0 mov %eax,-0x20(%ebp) 108f2d: 83 c4 10 add $0x10,%esp } tty->t_line=*(int*)(args->buffer); 108f30: 8b 43 08 mov 0x8(%ebx),%eax 108f33: 8b 00 mov (%eax),%eax 108f35: 8b 4d e4 mov -0x1c(%ebp),%ecx 108f38: 89 81 cc 00 00 00 mov %eax,0xcc(%ecx) tty->t_sc = NULL; /* ensure that no more valid data */ 108f3e: c7 81 d0 00 00 00 00 movl $0x0,0xd0(%ecx) 108f45: 00 00 00 /* * open new line discipline */ if (rtems_termios_linesw[tty->t_line].l_open != NULL) { 108f48: c1 e0 05 shl $0x5,%eax 108f4b: 8b 80 40 60 12 00 mov 0x126040(%eax),%eax 108f51: 85 c0 test %eax,%eax 108f53: 0f 84 b7 fd ff ff je 108d10 sc = rtems_termios_linesw[tty->t_line].l_open(tty); 108f59: 83 ec 0c sub $0xc,%esp 108f5c: 51 push %ecx 108f5d: ff d0 call *%eax 108f5f: 89 45 e0 mov %eax,-0x20(%ebp) 108f62: 83 c4 10 add $0x10,%esp 108f65: e9 a6 fd ff ff jmp 108d10 108f6a: 66 90 xchg %ax,%ax } break; case TIOCGETD: *(int*)(args->buffer)=tty->t_line; 108f6c: 8b 43 08 mov 0x8(%ebx),%eax 108f6f: 8b 4d e4 mov -0x1c(%ebp),%ecx 108f72: 8b 91 cc 00 00 00 mov 0xcc(%ecx),%edx 108f78: 89 10 mov %edx,(%eax) break; 108f7a: e9 91 fd ff ff jmp 108d10 108f7f: 90 nop case RTEMS_IO_TCDRAIN: drainOutput (tty); break; case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; 108f80: 8b 06 mov (%esi),%eax 108f82: 8b 56 04 mov 0x4(%esi),%edx 108f85: 8b 4d e4 mov -0x1c(%ebp),%ecx 108f88: 89 81 d4 00 00 00 mov %eax,0xd4(%ecx) 108f8e: 89 91 d8 00 00 00 mov %edx,0xd8(%ecx) break; 108f94: e9 77 fd ff ff jmp 108d10 108f99: 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)) { 108f9c: 8b 42 38 mov 0x38(%edx),%eax 108f9f: e9 91 fe ff ff jmp 108e35 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; 108fa4: c7 45 e0 0a 00 00 00 movl $0xa,-0x20(%ebp) <== NOT EXECUTED 108fab: e9 60 fd ff ff jmp 108d10 <== NOT EXECUTED break; #endif case FIONREAD: { int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head; if ( rawnc < 0 ) rawnc += tty->rawInBuf.Size; 108fb0: 8b 51 64 mov 0x64(%ecx),%edx <== NOT EXECUTED 108fb3: 01 d0 add %edx,%eax <== NOT EXECUTED 108fb5: e9 0d ff ff ff jmp 108ec7 <== NOT EXECUTED 108fba: 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] * 108fbc: 8b 45 e4 mov -0x1c(%ebp),%eax 108fbf: 0f b6 70 46 movzbl 0x46(%eax),%esi rtems_clock_get_ticks_per_second() / 10; 108fc3: e8 74 15 00 00 call 10a53c 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] * 108fc8: 0f af c6 imul %esi,%eax rtems_clock_get_ticks_per_second() / 10; 108fcb: ba cd cc cc cc mov $0xcccccccd,%edx 108fd0: f7 e2 mul %edx 108fd2: 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] * 108fd5: 8b 4d e4 mov -0x1c(%ebp),%ecx 108fd8: 89 51 54 mov %edx,0x54(%ecx) rtems_clock_get_ticks_per_second() / 10; if (tty->termios.c_cc[VTIME]) { 108fdb: 80 79 46 00 cmpb $0x0,0x46(%ecx) 108fdf: 74 36 je 109017 tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 108fe1: c7 41 6c 00 00 00 00 movl $0x0,0x6c(%ecx) tty->rawInBufSemaphoreTimeout = tty->vtimeTicks; 108fe8: 89 51 70 mov %edx,0x70(%ecx) if (tty->termios.c_cc[VMIN]) 108feb: 80 79 47 00 cmpb $0x0,0x47(%ecx) 108fef: 74 49 je 10903a tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; 108ff1: c7 41 74 00 00 00 00 movl $0x0,0x74(%ecx) 108ff8: e9 93 fe ff ff jmp 108e90 108ffd: 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; 109000: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 109003: 8b 82 b8 00 00 00 mov 0xb8(%edx),%eax <== NOT EXECUTED 109009: 80 cc 01 or $0x1,%ah <== NOT EXECUTED 10900c: 89 82 b8 00 00 00 mov %eax,0xb8(%edx) <== NOT EXECUTED 109012: e9 26 fe ff ff jmp 108e3d <== 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]) { 109017: 8b 55 e4 mov -0x1c(%ebp),%edx 10901a: 80 7a 47 00 cmpb $0x0,0x47(%edx) 10901e: 74 25 je 109045 <== ALWAYS TAKEN tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 109020: c7 42 6c 00 00 00 00 movl $0x0,0x6c(%edx) <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; 109027: c7 42 70 00 00 00 00 movl $0x0,0x70(%edx) <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; 10902e: c7 42 74 00 00 00 00 movl $0x0,0x74(%edx) <== NOT EXECUTED 109035: e9 56 fe ff ff jmp 108e90 <== 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; 10903a: 8b 45 e4 mov -0x1c(%ebp),%eax 10903d: 89 50 74 mov %edx,0x74(%eax) 109040: e9 4b fe ff ff jmp 108e90 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; 109045: 8b 4d e4 mov -0x1c(%ebp),%ecx 109048: c7 41 6c 01 00 00 00 movl $0x1,0x6c(%ecx) 10904f: e9 3c fe ff ff jmp 108e90 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); 109054: 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)( 10905a: 51 push %ecx <== NOT EXECUTED 10905b: 6a 01 push $0x1 <== NOT EXECUTED 10905d: 03 42 7c add 0x7c(%edx),%eax <== NOT EXECUTED 109060: 50 push %eax <== NOT EXECUTED 109061: ff 72 10 pushl 0x10(%edx) <== NOT EXECUTED 109064: ff 92 a4 00 00 00 call *0xa4(%edx) <== NOT EXECUTED 10906a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10906d: e9 27 fd ff ff jmp 108d99 <== NOT EXECUTED =============================================================================== 0010a02c : extern rtems_assoc_t termios_assoc_table[]; int rtems_termios_number_to_baud( int32_t baud ) { 10a02c: 55 push %ebp 10a02d: 89 e5 mov %esp,%ebp 10a02f: 53 push %ebx 10a030: 83 ec 0c sub $0xc,%esp 10a033: 8b 5d 08 mov 0x8(%ebp),%ebx int termios_baud; termios_baud = rtems_assoc_remote_by_local( termios_assoc_table, baud ); 10a036: 53 push %ebx 10a037: 68 00 74 12 00 push $0x127400 10a03c: e8 47 6d 00 00 call 110d88 if ( termios_baud == 0 && baud != 0 ) 10a041: 83 c4 10 add $0x10,%esp 10a044: 85 c0 test %eax,%eax 10a046: 74 08 je 10a050 return -1; return termios_baud; } 10a048: 8b 5d fc mov -0x4(%ebp),%ebx 10a04b: c9 leave 10a04c: c3 ret 10a04d: 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 ) 10a050: 85 db test %ebx,%ebx 10a052: 74 f4 je 10a048 return -1; 10a054: b8 ff ff ff ff mov $0xffffffff,%eax 10a059: eb ed jmp 10a048 =============================================================================== 001085bc : rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) { 1085bc: 55 push %ebp 1085bd: 89 e5 mov %esp,%ebp 1085bf: 57 push %edi 1085c0: 56 push %esi 1085c1: 53 push %ebx 1085c2: 83 ec 40 sub $0x40,%esp 1085c5: 8b 55 08 mov 0x8(%ebp),%edx struct rtems_termios_tty *tty; /* * See if the device has already been opened */ sc = rtems_semaphore_obtain( 1085c8: 6a 00 push $0x0 1085ca: 6a 00 push $0x0 1085cc: ff 35 cc 63 12 00 pushl 0x1263cc 1085d2: 89 55 dc mov %edx,-0x24(%ebp) 1085d5: e8 ce 25 00 00 call 10aba8 1085da: 89 45 e4 mov %eax,-0x1c(%ebp) rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 1085dd: 83 c4 10 add $0x10,%esp 1085e0: 85 c0 test %eax,%eax 1085e2: 8b 55 dc mov -0x24(%ebp),%edx 1085e5: 75 6d jne 108654 <== NEVER TAKEN return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 1085e7: 8b 35 d4 63 12 00 mov 0x1263d4,%esi 1085ed: 85 f6 test %esi,%esi 1085ef: 0f 84 a7 00 00 00 je 10869c 1085f5: 89 f3 mov %esi,%ebx 1085f7: 8b 45 0c mov 0xc(%ebp),%eax 1085fa: eb 0a jmp 108606 1085fc: 8b 1b mov (%ebx),%ebx 1085fe: 85 db test %ebx,%ebx 108600: 0f 84 96 00 00 00 je 10869c <== ALWAYS TAKEN if ((tty->major == major) && (tty->minor == minor)) 108606: 39 53 0c cmp %edx,0xc(%ebx) 108609: 75 f1 jne 1085fc 10860b: 39 43 10 cmp %eax,0x10(%ebx) 10860e: 75 ec jne 1085fc <== NEVER TAKEN */ if (c++ == 'z') c = 'a'; } args->iop->data1 = tty; 108610: 8b 75 10 mov 0x10(%ebp),%esi 108613: 8b 06 mov (%esi),%eax 108615: 89 58 34 mov %ebx,0x34(%eax) if (!tty->refcount++) { 108618: 8b 43 08 mov 0x8(%ebx),%eax 10861b: 8d 48 01 lea 0x1(%eax),%ecx 10861e: 89 4b 08 mov %ecx,0x8(%ebx) 108621: 85 c0 test %eax,%eax 108623: 75 1e jne 108643 if (tty->device.firstOpen) 108625: 8b 83 98 00 00 00 mov 0x98(%ebx),%eax 10862b: 85 c0 test %eax,%eax 10862d: 74 0b je 10863a (*tty->device.firstOpen)(major, minor, arg); 10862f: 57 push %edi 108630: 56 push %esi 108631: ff 75 0c pushl 0xc(%ebp) 108634: 52 push %edx 108635: ff d0 call *%eax 108637: 83 c4 10 add $0x10,%esp /* * start I/O tasks, if needed */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 10863a: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 108641: 74 1c je 10865f tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } } rtems_semaphore_release (rtems_termios_ttyMutex); 108643: 83 ec 0c sub $0xc,%esp 108646: ff 35 cc 63 12 00 pushl 0x1263cc 10864c: e8 53 26 00 00 call 10aca4 return RTEMS_SUCCESSFUL; 108651: 83 c4 10 add $0x10,%esp } 108654: 8b 45 e4 mov -0x1c(%ebp),%eax 108657: 8d 65 f4 lea -0xc(%ebp),%esp 10865a: 5b pop %ebx 10865b: 5e pop %esi 10865c: 5f pop %edi 10865d: c9 leave 10865e: c3 ret /* * start I/O tasks, if needed */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { sc = rtems_task_start( 10865f: 56 push %esi 108660: 53 push %ebx 108661: 68 f4 9d 10 00 push $0x109df4 108666: ff b3 c4 00 00 00 pushl 0xc4(%ebx) 10866c: e8 7b 29 00 00 call 10afec tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 108671: 83 c4 10 add $0x10,%esp 108674: 85 c0 test %eax,%eax 108676: 0f 85 3f 03 00 00 jne 1089bb <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_task_start( 10867c: 51 push %ecx 10867d: 53 push %ebx 10867e: 68 a4 a0 10 00 push $0x10a0a4 108683: ff b3 c8 00 00 00 pushl 0xc8(%ebx) 108689: e8 5e 29 00 00 call 10afec tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 10868e: 83 c4 10 add $0x10,%esp 108691: 85 c0 test %eax,%eax 108693: 74 ae je 108643 <== ALWAYS TAKEN 108695: e9 21 03 00 00 jmp 1089bb <== NOT EXECUTED 10869a: 66 90 xchg %ax,%ax <== NOT EXECUTED static char c = 'a'; /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); 10869c: 83 ec 08 sub $0x8,%esp 10869f: 68 e8 00 00 00 push $0xe8 1086a4: 6a 01 push $0x1 1086a6: 89 55 dc mov %edx,-0x24(%ebp) 1086a9: e8 f6 ed ff ff call 1074a4 1086ae: 89 45 e0 mov %eax,-0x20(%ebp) 1086b1: 89 c3 mov %eax,%ebx if (tty == NULL) { 1086b3: 83 c4 10 add $0x10,%esp 1086b6: 85 c0 test %eax,%eax 1086b8: 8b 55 dc mov -0x24(%ebp),%edx 1086bb: 0f 84 75 02 00 00 je 108936 return RTEMS_NO_MEMORY; } /* * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; 1086c1: a1 a4 41 12 00 mov 0x1241a4,%eax 1086c6: 8b 4d e0 mov -0x20(%ebp),%ecx 1086c9: 89 41 64 mov %eax,0x64(%ecx) tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size); 1086cc: 8b 41 64 mov 0x64(%ecx),%eax 1086cf: 83 ec 0c sub $0xc,%esp 1086d2: 50 push %eax 1086d3: 89 55 dc mov %edx,-0x24(%ebp) 1086d6: e8 2d f2 ff ff call 107908 1086db: 89 45 c4 mov %eax,-0x3c(%ebp) 1086de: 8b 7d e0 mov -0x20(%ebp),%edi 1086e1: 89 47 58 mov %eax,0x58(%edi) if (tty->rawInBuf.theBuf == NULL) { 1086e4: 83 c4 10 add $0x10,%esp 1086e7: 85 c0 test %eax,%eax 1086e9: 8b 55 dc mov -0x24(%ebp),%edx 1086ec: 0f 84 61 02 00 00 je 108953 return RTEMS_NO_MEMORY; } /* * allocate raw output buffer */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; 1086f2: a1 a8 41 12 00 mov 0x1241a8,%eax 1086f7: 8b 4d e0 mov -0x20(%ebp),%ecx 1086fa: 89 81 88 00 00 00 mov %eax,0x88(%ecx) tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size); 108700: 8b 81 88 00 00 00 mov 0x88(%ecx),%eax 108706: 83 ec 0c sub $0xc,%esp 108709: 50 push %eax 10870a: 89 55 dc mov %edx,-0x24(%ebp) 10870d: e8 f6 f1 ff ff call 107908 108712: 89 c7 mov %eax,%edi 108714: 8b 45 e0 mov -0x20(%ebp),%eax 108717: 89 78 7c mov %edi,0x7c(%eax) if (tty->rawOutBuf.theBuf == NULL) { 10871a: 83 c4 10 add $0x10,%esp 10871d: 85 ff test %edi,%edi 10871f: 8b 55 dc mov -0x24(%ebp),%edx 108722: 0f 84 4f 02 00 00 je 108977 <== NEVER TAKEN return RTEMS_NO_MEMORY; } /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); 108728: 83 ec 0c sub $0xc,%esp 10872b: ff 35 a0 41 12 00 pushl 0x1241a0 108731: 89 55 dc mov %edx,-0x24(%ebp) 108734: e8 cf f1 ff ff call 107908 108739: 8b 4d e0 mov -0x20(%ebp),%ecx 10873c: 89 41 1c mov %eax,0x1c(%ecx) if (tty->cbuf == NULL) { 10873f: 83 c4 10 add $0x10,%esp 108742: 85 c0 test %eax,%eax 108744: 8b 55 dc mov -0x24(%ebp),%edx 108747: 0f 84 77 02 00 00 je 1089c4 return RTEMS_NO_MEMORY; } /* * Initialize wakeup callbacks */ tty->tty_snd.sw_pfn = NULL; 10874d: 8b 7d e0 mov -0x20(%ebp),%edi 108750: c7 87 d4 00 00 00 00 movl $0x0,0xd4(%edi) 108757: 00 00 00 tty->tty_snd.sw_arg = NULL; 10875a: c7 87 d8 00 00 00 00 movl $0x0,0xd8(%edi) 108761: 00 00 00 tty->tty_rcv.sw_pfn = NULL; 108764: c7 87 dc 00 00 00 00 movl $0x0,0xdc(%edi) 10876b: 00 00 00 tty->tty_rcv.sw_arg = NULL; 10876e: c7 87 e0 00 00 00 00 movl $0x0,0xe0(%edi) 108775: 00 00 00 tty->tty_rcvwakeup = 0; 108778: c7 87 e4 00 00 00 00 movl $0x0,0xe4(%edi) 10877f: 00 00 00 /* * link tty */ tty->forw = rtems_termios_ttyHead; 108782: 89 37 mov %esi,(%edi) tty->back = NULL; 108784: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) if (rtems_termios_ttyHead != NULL) 10878b: 85 f6 test %esi,%esi 10878d: 74 03 je 108792 rtems_termios_ttyHead->back = tty; 10878f: 89 7e 04 mov %edi,0x4(%esi) rtems_termios_ttyHead = tty; 108792: 8b 45 e0 mov -0x20(%ebp),%eax 108795: a3 d4 63 12 00 mov %eax,0x1263d4 if (rtems_termios_ttyTail == NULL) 10879a: 8b 0d d0 63 12 00 mov 0x1263d0,%ecx 1087a0: 85 c9 test %ecx,%ecx 1087a2: 0f 84 af 02 00 00 je 108a57 rtems_termios_ttyTail = tty; tty->minor = minor; 1087a8: 8b 75 0c mov 0xc(%ebp),%esi 1087ab: 8b 4d e0 mov -0x20(%ebp),%ecx 1087ae: 89 71 10 mov %esi,0x10(%ecx) tty->major = major; 1087b1: 89 51 0c mov %edx,0xc(%ecx) /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 1087b4: 83 ec 0c sub $0xc,%esp 1087b7: 89 c8 mov %ecx,%eax 1087b9: 83 c0 14 add $0x14,%eax 1087bc: 50 push %eax 1087bd: 6a 00 push $0x0 1087bf: 6a 54 push $0x54 1087c1: 6a 01 push $0x1 rtems_build_name ('T', 'R', 'i', c), 1087c3: 0f be 05 ac 41 12 00 movsbl 0x1241ac,%eax tty->major = major; /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 1087ca: 0d 00 69 52 54 or $0x54526900,%eax 1087cf: 50 push %eax 1087d0: 89 55 dc mov %edx,-0x24(%ebp) 1087d3: e8 54 21 00 00 call 10a92c 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) 1087d8: 83 c4 20 add $0x20,%esp 1087db: 85 c0 test %eax,%eax 1087dd: 8b 55 dc mov -0x24(%ebp),%edx 1087e0: 0f 85 d5 01 00 00 jne 1089bb rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 1087e6: 83 ec 0c sub $0xc,%esp 1087e9: 8b 45 e0 mov -0x20(%ebp),%eax 1087ec: 83 c0 18 add $0x18,%eax 1087ef: 50 push %eax 1087f0: 6a 00 push $0x0 1087f2: 6a 54 push $0x54 1087f4: 6a 01 push $0x1 rtems_build_name ('T', 'R', 'o', c), 1087f6: 0f be 05 ac 41 12 00 movsbl 0x1241ac,%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 ( 1087fd: 0d 00 6f 52 54 or $0x54526f00,%eax 108802: 50 push %eax 108803: 89 55 dc mov %edx,-0x24(%ebp) 108806: e8 21 21 00 00 call 10a92c 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) 10880b: 83 c4 20 add $0x20,%esp 10880e: 85 c0 test %eax,%eax 108810: 8b 55 dc mov -0x24(%ebp),%edx 108813: 0f 85 a2 01 00 00 jne 1089bb rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 108819: 83 ec 0c sub $0xc,%esp 10881c: 8b 45 e0 mov -0x20(%ebp),%eax 10881f: 05 8c 00 00 00 add $0x8c,%eax 108824: 50 push %eax 108825: 6a 00 push $0x0 108827: 6a 20 push $0x20 108829: 6a 00 push $0x0 rtems_build_name ('T', 'R', 'x', c), 10882b: 0f be 05 ac 41 12 00 movsbl 0x1241ac,%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 ( 108832: 0d 00 78 52 54 or $0x54527800,%eax 108837: 50 push %eax 108838: 89 55 dc mov %edx,-0x24(%ebp) 10883b: e8 ec 20 00 00 call 10a92c rtems_build_name ('T', 'R', 'x', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO, RTEMS_NO_PRIORITY, &tty->rawOutBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 108840: 83 c4 20 add $0x20,%esp 108843: 85 c0 test %eax,%eax 108845: 8b 55 dc mov -0x24(%ebp),%edx 108848: 0f 85 6d 01 00 00 jne 1089bb rtems_fatal_error_occurred (sc); tty->rawOutBufState = rob_idle; 10884e: 8b 7d e0 mov -0x20(%ebp),%edi 108851: c7 87 94 00 00 00 00 movl $0x0,0x94(%edi) 108858: 00 00 00 /* * Set callbacks */ tty->device = *callbacks; 10885b: 81 c7 98 00 00 00 add $0x98,%edi 108861: b9 08 00 00 00 mov $0x8,%ecx 108866: 8b 75 14 mov 0x14(%ebp),%esi 108869: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 10886b: 8b 7d e0 mov -0x20(%ebp),%edi 10886e: 83 bf b4 00 00 00 02 cmpl $0x2,0xb4(%edi) 108875: 0f 84 64 01 00 00 je 1089df &tty->rxTaskId); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || 10887b: 8b 45 e0 mov -0x20(%ebp),%eax 10887e: 8b 88 a0 00 00 00 mov 0xa0(%eax),%ecx 108884: 85 c9 test %ecx,%ecx 108886: 0f 84 fc 00 00 00 je 108988 10888c: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax) 108893: 0f 84 ef 00 00 00 je 108988 } /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; 108899: 8b 4d e0 mov -0x20(%ebp),%ecx 10889c: c7 41 30 02 25 00 00 movl $0x2502,0x30(%ecx) tty->termios.c_oflag = OPOST | ONLCR | XTABS; 1088a3: c7 41 34 05 18 00 00 movl $0x1805,0x34(%ecx) tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; 1088aa: c7 41 38 bd 08 00 00 movl $0x8bd,0x38(%ecx) tty->termios.c_lflag = 1088b1: c7 41 3c 3b 82 00 00 movl $0x823b,0x3c(%ecx) ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL; tty->termios.c_cc[VINTR] = '\003'; 1088b8: c6 41 41 03 movb $0x3,0x41(%ecx) tty->termios.c_cc[VQUIT] = '\034'; 1088bc: c6 41 42 1c movb $0x1c,0x42(%ecx) tty->termios.c_cc[VERASE] = '\177'; 1088c0: c6 41 43 7f movb $0x7f,0x43(%ecx) tty->termios.c_cc[VKILL] = '\025'; 1088c4: c6 41 44 15 movb $0x15,0x44(%ecx) tty->termios.c_cc[VEOF] = '\004'; 1088c8: c6 41 45 04 movb $0x4,0x45(%ecx) tty->termios.c_cc[VEOL] = '\000'; 1088cc: c6 41 4c 00 movb $0x0,0x4c(%ecx) tty->termios.c_cc[VEOL2] = '\000'; 1088d0: c6 41 51 00 movb $0x0,0x51(%ecx) tty->termios.c_cc[VSTART] = '\021'; 1088d4: c6 41 49 11 movb $0x11,0x49(%ecx) tty->termios.c_cc[VSTOP] = '\023'; 1088d8: c6 41 4a 13 movb $0x13,0x4a(%ecx) tty->termios.c_cc[VSUSP] = '\032'; 1088dc: c6 41 4b 1a movb $0x1a,0x4b(%ecx) tty->termios.c_cc[VREPRINT] = '\022'; 1088e0: c6 41 4d 12 movb $0x12,0x4d(%ecx) tty->termios.c_cc[VDISCARD] = '\017'; 1088e4: c6 41 4e 0f movb $0xf,0x4e(%ecx) tty->termios.c_cc[VWERASE] = '\027'; 1088e8: c6 41 4f 17 movb $0x17,0x4f(%ecx) tty->termios.c_cc[VLNEXT] = '\026'; 1088ec: c6 41 50 16 movb $0x16,0x50(%ecx) /* start with no flow control, clear flow control flags */ tty->flow_ctrl = 0; 1088f0: c7 81 b8 00 00 00 00 movl $0x0,0xb8(%ecx) 1088f7: 00 00 00 /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2; 1088fa: 8b 41 64 mov 0x64(%ecx),%eax 1088fd: d1 e8 shr %eax 1088ff: 89 81 bc 00 00 00 mov %eax,0xbc(%ecx) tty->highwater = tty->rawInBuf.Size * 3/4; 108905: 8b 41 64 mov 0x64(%ecx),%eax 108908: 8d 04 40 lea (%eax,%eax,2),%eax 10890b: c1 e8 02 shr $0x2,%eax 10890e: 89 81 c0 00 00 00 mov %eax,0xc0(%ecx) /* * Bump name characer */ if (c++ == 'z') 108914: a0 ac 41 12 00 mov 0x1241ac,%al 108919: 8d 48 01 lea 0x1(%eax),%ecx 10891c: 88 0d ac 41 12 00 mov %cl,0x1241ac 108922: 3c 7a cmp $0x7a,%al 108924: 0f 85 e6 fc ff ff jne 108610 c = 'a'; 10892a: c6 05 ac 41 12 00 61 movb $0x61,0x1241ac 108931: e9 da fc ff ff jmp 108610 /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); if (tty == NULL) { rtems_semaphore_release (rtems_termios_ttyMutex); 108936: 83 ec 0c sub $0xc,%esp 108939: ff 35 cc 63 12 00 pushl 0x1263cc 10893f: e8 60 23 00 00 call 10aca4 return RTEMS_NO_MEMORY; 108944: 83 c4 10 add $0x10,%esp 108947: c7 45 e4 1a 00 00 00 movl $0x1a,-0x1c(%ebp) 10894e: e9 01 fd ff ff jmp 108654 * 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); 108953: 83 ec 0c sub $0xc,%esp 108956: 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); 108957: e8 d8 ec ff ff call 107634 rtems_semaphore_release (rtems_termios_ttyMutex); 10895c: 5f pop %edi 10895d: ff 35 cc 63 12 00 pushl 0x1263cc 108963: e8 3c 23 00 00 call 10aca4 return RTEMS_NO_MEMORY; 108968: 83 c4 10 add $0x10,%esp 10896b: c7 45 e4 1a 00 00 00 movl $0x1a,-0x1c(%ebp) 108972: e9 dd fc ff ff jmp 108654 * 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)); 108977: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10897a: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED 10897d: e8 b2 ec ff ff call 107634 <== NOT EXECUTED free(tty); 108982: 58 pop %eax <== NOT EXECUTED 108983: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 108986: eb cf jmp 108957 <== NOT EXECUTED rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 108988: 83 ec 0c sub $0xc,%esp 10898b: 8b 45 e0 mov -0x20(%ebp),%eax 10898e: 83 c0 68 add $0x68,%eax 108991: 50 push %eax 108992: 6a 00 push $0x0 108994: 6a 24 push $0x24 108996: 6a 00 push $0x0 rtems_build_name ('T', 'R', 'r', c), 108998: 0f be 05 ac 41 12 00 movsbl 0x1241ac,%eax rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 10899f: 0d 00 72 52 54 or $0x54527200,%eax 1089a4: 50 push %eax 1089a5: 89 55 dc mov %edx,-0x24(%ebp) 1089a8: e8 7f 1f 00 00 call 10a92c rtems_build_name ('T', 'R', 'r', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->rawInBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 1089ad: 83 c4 20 add $0x20,%esp 1089b0: 85 c0 test %eax,%eax 1089b2: 8b 55 dc mov -0x24(%ebp),%edx 1089b5: 0f 84 de fe ff ff je 108899 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); 1089bb: 83 ec 0c sub $0xc,%esp 1089be: 50 push %eax 1089bf: e8 24 28 00 00 call 10b1e8 /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); if (tty->cbuf == NULL) { free((void *)(tty->rawOutBuf.theBuf)); 1089c4: 83 ec 0c sub $0xc,%esp 1089c7: 57 push %edi 1089c8: e8 67 ec ff ff call 107634 free((void *)(tty->rawInBuf.theBuf)); 1089cd: 5e pop %esi 1089ce: ff 75 c4 pushl -0x3c(%ebp) 1089d1: e8 5e ec ff ff call 107634 free(tty); 1089d6: 5b pop %ebx 1089d7: ff 75 e0 pushl -0x20(%ebp) 1089da: e9 78 ff ff ff jmp 108957 /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { sc = rtems_task_create ( 1089df: 50 push %eax 1089e0: 50 push %eax 1089e1: 89 f8 mov %edi,%eax 1089e3: 05 c8 00 00 00 add $0xc8,%eax 1089e8: 50 push %eax 1089e9: 6a 00 push $0x0 1089eb: 68 00 05 00 00 push $0x500 1089f0: 68 00 04 00 00 push $0x400 1089f5: 6a 0a push $0xa rtems_build_name ('T', 'x', 'T', c), 1089f7: 0f be 05 ac 41 12 00 movsbl 0x1241ac,%eax /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { sc = rtems_task_create ( 1089fe: 0d 00 54 78 54 or $0x54785400,%eax 108a03: 50 push %eax 108a04: 89 55 dc mov %edx,-0x24(%ebp) 108a07: e8 38 23 00 00 call 10ad44 TERMIOS_TXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->txTaskId); if (sc != RTEMS_SUCCESSFUL) 108a0c: 83 c4 20 add $0x20,%esp 108a0f: 85 c0 test %eax,%eax 108a11: 8b 55 dc mov -0x24(%ebp),%edx 108a14: 75 a5 jne 1089bb <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_task_create ( 108a16: 56 push %esi 108a17: 56 push %esi 108a18: 8b 45 e0 mov -0x20(%ebp),%eax 108a1b: 05 c4 00 00 00 add $0xc4,%eax 108a20: 50 push %eax 108a21: 6a 00 push $0x0 108a23: 68 00 05 00 00 push $0x500 108a28: 68 00 04 00 00 push $0x400 108a2d: 6a 09 push $0x9 rtems_build_name ('R', 'x', 'T', c), 108a2f: 0f be 05 ac 41 12 00 movsbl 0x1241ac,%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 ( 108a36: 0d 00 54 78 52 or $0x52785400,%eax 108a3b: 50 push %eax 108a3c: 89 55 dc mov %edx,-0x24(%ebp) 108a3f: e8 00 23 00 00 call 10ad44 TERMIOS_RXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->rxTaskId); if (sc != RTEMS_SUCCESSFUL) 108a44: 83 c4 20 add $0x20,%esp 108a47: 85 c0 test %eax,%eax 108a49: 8b 55 dc mov -0x24(%ebp),%edx 108a4c: 0f 84 29 fe ff ff je 10887b <== ALWAYS TAKEN 108a52: e9 64 ff ff ff jmp 1089bb <== 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; 108a57: a3 d0 63 12 00 mov %eax,0x1263d0 108a5c: e9 47 fd ff ff jmp 1087a8 =============================================================================== 00109074 : * Send characters to device-specific code */ void rtems_termios_puts ( const void *_buf, int len, struct rtems_termios_tty *tty) { 109074: 55 push %ebp 109075: 89 e5 mov %esp,%ebp 109077: 57 push %edi 109078: 56 push %esi 109079: 53 push %ebx 10907a: 83 ec 1c sub $0x1c,%esp 10907d: 8b 45 08 mov 0x8(%ebp),%eax 109080: 8b 55 0c mov 0xc(%ebp),%edx 109083: 89 55 e4 mov %edx,-0x1c(%ebp) 109086: 8b 5d 10 mov 0x10(%ebp),%ebx const unsigned char *buf = _buf; 109089: 89 c6 mov %eax,%esi unsigned int newHead; rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { 10908b: 8b 8b b4 00 00 00 mov 0xb4(%ebx),%ecx 109091: 85 c9 test %ecx,%ecx 109093: 0f 84 eb 00 00 00 je 109184 (*tty->device.write)(tty->minor, (void *)buf, len); return; } newHead = tty->rawOutBuf.Head; 109099: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 10909f: 89 45 e0 mov %eax,-0x20(%ebp) while (len) { 1090a2: 8b 55 e4 mov -0x1c(%ebp),%edx 1090a5: 85 d2 test %edx,%edx 1090a7: 0f 84 cf 00 00 00 je 10917c <== NEVER TAKEN 1090ad: 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; 1090b0: 8b 45 e0 mov -0x20(%ebp),%eax 1090b3: 40 inc %eax 1090b4: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx 1090ba: 31 d2 xor %edx,%edx 1090bc: f7 f1 div %ecx 1090be: 89 55 dc mov %edx,-0x24(%ebp) 1090c1: 89 55 e0 mov %edx,-0x20(%ebp) rtems_interrupt_disable (level); 1090c4: 9c pushf 1090c5: fa cli 1090c6: 5f pop %edi while (newHead == tty->rawOutBuf.Tail) { 1090c7: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx 1090cd: 3b 55 e0 cmp -0x20(%ebp),%edx 1090d0: 75 3e jne 109110 1090d2: 89 f8 mov %edi,%eax 1090d4: 89 f7 mov %esi,%edi 1090d6: 89 d6 mov %edx,%esi tty->rawOutBufState = rob_wait; 1090d8: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) 1090df: 00 00 00 rtems_interrupt_enable (level); 1090e2: 50 push %eax 1090e3: 9d popf sc = rtems_semaphore_obtain( 1090e4: 50 push %eax 1090e5: 6a 00 push $0x0 1090e7: 6a 00 push $0x0 1090e9: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 1090ef: e8 b4 1a 00 00 call 10aba8 tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 1090f4: 83 c4 10 add $0x10,%esp 1090f7: 85 c0 test %eax,%eax 1090f9: 0f 85 a0 00 00 00 jne 10919f <== NEVER TAKEN rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); 1090ff: 9c pushf 109100: fa cli 109101: 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) { 109102: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx 109108: 39 f2 cmp %esi,%edx 10910a: 74 cc je 1090d8 <== NEVER TAKEN 10910c: 89 fe mov %edi,%esi 10910e: 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++; 109110: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 109116: 8b 4b 7c mov 0x7c(%ebx),%ecx 109119: 8a 16 mov (%esi),%dl 10911b: 88 14 01 mov %dl,(%ecx,%eax,1) tty->rawOutBuf.Head = newHead; 10911e: 8b 45 dc mov -0x24(%ebp),%eax 109121: 89 83 80 00 00 00 mov %eax,0x80(%ebx) if (tty->rawOutBufState == rob_idle) { 109127: 8b 8b 94 00 00 00 mov 0x94(%ebx),%ecx 10912d: 85 c9 test %ecx,%ecx 10912f: 75 23 jne 109154 /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { 109131: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109137: a8 10 test $0x10,%al 109139: 74 26 je 109161 <== 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; 10913b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109141: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 109144: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } tty->rawOutBufState = rob_busy; 10914a: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) 109151: 00 00 00 } rtems_interrupt_enable (level); 109154: 57 push %edi 109155: 9d popf if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, (void *)buf, len); return; } newHead = tty->rawOutBuf.Head; while (len) { 109156: ff 4d e4 decl -0x1c(%ebp) 109159: 74 21 je 10917c 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++; 10915b: 46 inc %esi 10915c: e9 4f ff ff ff jmp 1090b0 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); 109161: 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, 109167: 52 push %edx 109168: 6a 01 push $0x1 10916a: 03 43 7c add 0x7c(%ebx),%eax 10916d: 50 push %eax 10916e: ff 73 10 pushl 0x10(%ebx) 109171: ff 93 a4 00 00 00 call *0xa4(%ebx) 109177: 83 c4 10 add $0x10,%esp 10917a: eb ce jmp 10914a tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 10917c: 8d 65 f4 lea -0xc(%ebp),%esp 10917f: 5b pop %ebx 109180: 5e pop %esi 109181: 5f pop %edi 109182: c9 leave 109183: 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); 109184: 89 55 10 mov %edx,0x10(%ebp) 109187: 89 45 0c mov %eax,0xc(%ebp) 10918a: 8b 43 10 mov 0x10(%ebx),%eax 10918d: 89 45 08 mov %eax,0x8(%ebp) 109190: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 109196: 8d 65 f4 lea -0xc(%ebp),%esp 109199: 5b pop %ebx 10919a: 5e pop %esi 10919b: 5f pop %edi 10919c: 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); 10919d: 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); 10919f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1091a2: 50 push %eax <== NOT EXECUTED 1091a3: e8 40 20 00 00 call 10b1e8 <== NOT EXECUTED =============================================================================== 00109780 : return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) { 109780: 55 push %ebp 109781: 89 e5 mov %esp,%ebp 109783: 57 push %edi 109784: 56 push %esi 109785: 53 push %ebx 109786: 83 ec 30 sub $0x30,%esp rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 109789: 8b 55 08 mov 0x8(%ebp),%edx 10978c: 8b 02 mov (%edx),%eax 10978e: 8b 58 34 mov 0x34(%eax),%ebx uint32_t count = args->count; 109791: 8b 4a 10 mov 0x10(%edx),%ecx 109794: 89 4d dc mov %ecx,-0x24(%ebp) char *buffer = args->buffer; 109797: 8b 42 0c mov 0xc(%edx),%eax 10979a: 89 45 d8 mov %eax,-0x28(%ebp) rtems_status_code sc; sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 10979d: 6a 00 push $0x0 10979f: 6a 00 push $0x0 1097a1: ff 73 14 pushl 0x14(%ebx) 1097a4: e8 ff 13 00 00 call 10aba8 1097a9: 89 45 e0 mov %eax,-0x20(%ebp) if (sc != RTEMS_SUCCESSFUL) 1097ac: 83 c4 10 add $0x10,%esp 1097af: 85 c0 test %eax,%eax 1097b1: 75 35 jne 1097e8 <== NEVER TAKEN return sc; if (rtems_termios_linesw[tty->t_line].l_read != NULL) { 1097b3: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 1097b9: c1 e0 05 shl $0x5,%eax 1097bc: 8b 80 48 60 12 00 mov 0x126048(%eax),%eax 1097c2: 85 c0 test %eax,%eax 1097c4: 74 2e je 1097f4 sc = rtems_termios_linesw[tty->t_line].l_read(tty,args); 1097c6: 83 ec 08 sub $0x8,%esp 1097c9: ff 75 08 pushl 0x8(%ebp) 1097cc: 53 push %ebx 1097cd: ff d0 call *%eax 1097cf: 89 45 e0 mov %eax,-0x20(%ebp) tty->tty_rcvwakeup = 0; 1097d2: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 1097d9: 00 00 00 rtems_semaphore_release (tty->isem); 1097dc: 59 pop %ecx 1097dd: ff 73 14 pushl 0x14(%ebx) 1097e0: e8 bf 14 00 00 call 10aca4 return sc; 1097e5: 83 c4 10 add $0x10,%esp } args->bytes_moved = args->count - count; tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); return sc; } 1097e8: 8b 45 e0 mov -0x20(%ebp),%eax 1097eb: 8d 65 f4 lea -0xc(%ebp),%esp 1097ee: 5b pop %ebx 1097ef: 5e pop %esi 1097f0: 5f pop %edi 1097f1: c9 leave 1097f2: c3 ret 1097f3: 90 nop tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); return sc; } if (tty->cindex == tty->ccount) { 1097f4: 8b 53 20 mov 0x20(%ebx),%edx 1097f7: 39 53 24 cmp %edx,0x24(%ebx) 1097fa: 74 5f je 10985b <== ALWAYS TAKEN sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 1097fc: 8b 45 dc mov -0x24(%ebp),%eax 1097ff: 85 c0 test %eax,%eax 109801: 74 29 je 10982c <== NEVER TAKEN 109803: 8b 43 24 mov 0x24(%ebx),%eax 109806: 3b 43 20 cmp 0x20(%ebx),%eax 109809: 7d 21 jge 10982c <== NEVER TAKEN 10980b: 8b 55 d8 mov -0x28(%ebp),%edx 10980e: 8b 7d dc mov -0x24(%ebp),%edi 109811: eb 06 jmp 109819 109813: 90 nop 109814: 39 43 20 cmp %eax,0x20(%ebx) 109817: 7e 10 jle 109829 *buffer++ = tty->cbuf[tty->cindex++]; 109819: 8b 73 1c mov 0x1c(%ebx),%esi 10981c: 8a 0c 06 mov (%esi,%eax,1),%cl 10981f: 88 0a mov %cl,(%edx) 109821: 42 inc %edx 109822: 40 inc %eax 109823: 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)) { 109826: 4f dec %edi 109827: 75 eb jne 109814 109829: 89 7d dc mov %edi,-0x24(%ebp) *buffer++ = tty->cbuf[tty->cindex++]; count--; } args->bytes_moved = args->count - count; 10982c: 8b 55 08 mov 0x8(%ebp),%edx 10982f: 8b 42 10 mov 0x10(%edx),%eax 109832: 2b 45 dc sub -0x24(%ebp),%eax 109835: 89 42 18 mov %eax,0x18(%edx) tty->tty_rcvwakeup = 0; 109838: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10983f: 00 00 00 rtems_semaphore_release (tty->isem); 109842: 83 ec 0c sub $0xc,%esp 109845: ff 73 14 pushl 0x14(%ebx) 109848: e8 57 14 00 00 call 10aca4 return sc; 10984d: 83 c4 10 add $0x10,%esp } 109850: 8b 45 e0 mov -0x20(%ebp),%eax 109853: 8d 65 f4 lea -0xc(%ebp),%esp 109856: 5b pop %ebx 109857: 5e pop %esi 109858: 5f pop %edi 109859: c9 leave 10985a: c3 ret rtems_semaphore_release (tty->isem); return sc; } if (tty->cindex == tty->ccount) { tty->cindex = tty->ccount = 0; 10985b: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) 109862: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) tty->read_start_column = tty->column; 109869: 8b 43 28 mov 0x28(%ebx),%eax 10986c: 89 43 2c mov %eax,0x2c(%ebx) if (tty->device.pollRead != NULL && 10986f: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax 109875: 85 c0 test %eax,%eax 109877: 74 0e je 109887 109879: 8b 93 b4 00 00 00 mov 0xb4(%ebx),%edx 10987f: 85 d2 test %edx,%edx 109881: 0f 84 82 01 00 00 je 109a09 * Fill the input buffer from the raw input queue */ static rtems_status_code fillBufferQueue (struct rtems_termios_tty *tty) { rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout; 109887: 8b 73 74 mov 0x74(%ebx),%esi rtems_status_code sc; int wait = (int)1; 10988a: 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)( 109891: 8d 4b 49 lea 0x49(%ebx),%ecx 109894: 89 4d d4 mov %ecx,-0x2c(%ebp) 109897: 90 nop while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 109898: 8b 53 5c mov 0x5c(%ebx),%edx 10989b: 8b 43 60 mov 0x60(%ebx),%eax 10989e: 39 c2 cmp %eax,%edx 1098a0: 0f 84 06 01 00 00 je 1099ac (tty->ccount < (CBUFSIZE-1))) { 1098a6: a1 a0 41 12 00 mov 0x1241a0,%eax 1098ab: 48 dec %eax while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 1098ac: 3b 43 20 cmp 0x20(%ebx),%eax 1098af: 7f 3c jg 1098ed <== ALWAYS TAKEN 1098b1: e9 f6 00 00 00 jmp 1099ac <== NOT EXECUTED 1098b6: 66 90 xchg %ax,%ax <== NOT EXECUTED } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { if (siproc (c, tty)) 1098b8: 0f b6 c1 movzbl %cl,%eax 1098bb: 89 da mov %ebx,%edx 1098bd: e8 9e fd ff ff call 109660 1098c2: 85 c0 test %eax,%eax 1098c4: 74 07 je 1098cd wait = 0; } else { siproc (c, tty); if (tty->ccount >= tty->termios.c_cc[VMIN]) wait = 0; 1098c6: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) } timeout = tty->rawInBufSemaphoreTimeout; 1098cd: 8b 73 70 mov 0x70(%ebx),%esi while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 1098d0: 8b 53 5c mov 0x5c(%ebx),%edx 1098d3: 8b 43 60 mov 0x60(%ebx),%eax 1098d6: 39 c2 cmp %eax,%edx 1098d8: 0f 84 ce 00 00 00 je 1099ac (tty->ccount < (CBUFSIZE-1))) { 1098de: a1 a0 41 12 00 mov 0x1241a0,%eax 1098e3: 48 dec %eax while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 1098e4: 39 43 20 cmp %eax,0x20(%ebx) 1098e7: 0f 8d bf 00 00 00 jge 1099ac <== NEVER TAKEN (tty->ccount < (CBUFSIZE-1))) { unsigned char c; unsigned int newHead; newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size; 1098ed: 8b 43 5c mov 0x5c(%ebx),%eax 1098f0: 8b 4b 64 mov 0x64(%ebx),%ecx 1098f3: 40 inc %eax 1098f4: 31 d2 xor %edx,%edx 1098f6: f7 f1 div %ecx c = tty->rawInBuf.theBuf[newHead]; 1098f8: 8b 43 58 mov 0x58(%ebx),%eax 1098fb: 8a 0c 10 mov (%eax,%edx,1),%cl tty->rawInBuf.Head = newHead; 1098fe: 89 53 5c mov %edx,0x5c(%ebx) if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) 109901: 8b 43 60 mov 0x60(%ebx),%eax 109904: 8b 7b 64 mov 0x64(%ebx),%edi % tty->rawInBuf.Size) 109907: 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) 10990a: 8d 04 07 lea (%edi,%eax,1),%eax 10990d: 29 d0 sub %edx,%eax % tty->rawInBuf.Size) 10990f: 31 d2 xor %edx,%edx 109911: 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) 109913: 3b 93 bc 00 00 00 cmp 0xbc(%ebx),%edx 109919: 73 5d jae 109978 <== NEVER TAKEN % tty->rawInBuf.Size) < tty->lowwater) { tty->flow_ctrl &= ~FL_IREQXOF; 10991b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109921: 83 e0 fe and $0xfffffffe,%eax 109924: 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)) 10992a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109930: 25 02 02 00 00 and $0x202,%eax 109935: 3d 02 02 00 00 cmp $0x202,%eax 10993a: 0f 84 94 00 00 00 je 1099d4 <== 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) { 109940: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109946: f6 c4 01 test $0x1,%ah 109949: 74 2d je 109978 <== ALWAYS TAKEN tty->flow_ctrl &= ~FL_IRTSOFF; 10994b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109951: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 109954: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* activate RTS line */ if (tty->device.startRemoteTx != NULL) { 10995a: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 109960: 85 c0 test %eax,%eax <== NOT EXECUTED 109962: 74 14 je 109978 <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 109964: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109967: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10996a: 88 4d d0 mov %cl,-0x30(%ebp) <== NOT EXECUTED 10996d: ff d0 call *%eax <== NOT EXECUTED 10996f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109972: 8a 4d d0 mov -0x30(%ebp),%cl <== NOT EXECUTED 109975: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { 109978: f6 43 3c 02 testb $0x2,0x3c(%ebx) 10997c: 0f 85 36 ff ff ff jne 1098b8 <== ALWAYS TAKEN if (siproc (c, tty)) wait = 0; } else { siproc (c, tty); 109982: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 109985: 89 da mov %ebx,%edx <== NOT EXECUTED 109987: e8 d4 fc ff ff call 109660 <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 10998c: 0f b6 43 47 movzbl 0x47(%ebx),%eax <== NOT EXECUTED 109990: 39 43 20 cmp %eax,0x20(%ebx) <== NOT EXECUTED 109993: 0f 8d 2d ff ff ff jge 1098c6 <== NOT EXECUTED wait = 0; } timeout = tty->rawInBufSemaphoreTimeout; 109999: 8b 73 70 mov 0x70(%ebx),%esi <== NOT EXECUTED while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 10999c: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED 10999f: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED 1099a2: 39 c2 cmp %eax,%edx <== NOT EXECUTED 1099a4: 0f 85 34 ff ff ff jne 1098de <== NOT EXECUTED 1099aa: 66 90 xchg %ax,%ax <== NOT EXECUTED } /* * Wait for characters */ if ( wait ) { 1099ac: 8b 4d e4 mov -0x1c(%ebp),%ecx 1099af: 85 c9 test %ecx,%ecx 1099b1: 0f 84 45 fe ff ff je 1097fc sc = rtems_semaphore_obtain( 1099b7: 52 push %edx 1099b8: 56 push %esi 1099b9: ff 73 6c pushl 0x6c(%ebx) 1099bc: ff 73 68 pushl 0x68(%ebx) 1099bf: e8 e4 11 00 00 call 10aba8 tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout); if (sc != RTEMS_SUCCESSFUL) 1099c4: 83 c4 10 add $0x10,%esp 1099c7: 85 c0 test %eax,%eax 1099c9: 0f 84 c9 fe ff ff je 109898 <== ALWAYS TAKEN 1099cf: e9 28 fe ff ff jmp 1097fc <== 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) 1099d4: 8b bb 94 00 00 00 mov 0x94(%ebx),%edi <== NOT EXECUTED 1099da: 85 ff test %edi,%edi <== NOT EXECUTED 1099dc: 74 0e je 1099ec <== NOT EXECUTED || (tty->flow_ctrl & FL_OSTOP))) { 1099de: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1099e4: a8 20 test $0x20,%al <== NOT EXECUTED 1099e6: 0f 84 54 ff ff ff je 109940 <== NOT EXECUTED /* XON should be sent now... */ (*tty->device.write)( 1099ec: 56 push %esi <== NOT EXECUTED 1099ed: 6a 01 push $0x1 <== NOT EXECUTED 1099ef: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 1099f2: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1099f5: 88 4d d0 mov %cl,-0x30(%ebp) <== NOT EXECUTED 1099f8: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 1099fe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109a01: 8a 4d d0 mov -0x30(%ebp),%cl <== NOT EXECUTED 109a04: e9 6f ff ff ff jmp 109978 <== NOT EXECUTED static rtems_status_code fillBufferPoll (struct rtems_termios_tty *tty) { int n; if (tty->termios.c_lflag & ICANON) { 109a09: f6 43 3c 02 testb $0x2,0x3c(%ebx) 109a0d: 75 1d jne 109a2c 109a0f: eb 39 jmp 109a4a 109a11: 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)) 109a14: 0f b6 c0 movzbl %al,%eax 109a17: 89 da mov %ebx,%edx 109a19: e8 42 fc ff ff call 109660 109a1e: 85 c0 test %eax,%eax 109a20: 0f 85 d6 fd ff ff jne 1097fc static rtems_status_code fillBufferPoll (struct rtems_termios_tty *tty) { int n; if (tty->termios.c_lflag & ICANON) { 109a26: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax for (;;) { n = (*tty->device.pollRead)(tty->minor); 109a2c: 83 ec 0c sub $0xc,%esp 109a2f: ff 73 10 pushl 0x10(%ebx) 109a32: ff d0 call *%eax if (n < 0) { 109a34: 83 c4 10 add $0x10,%esp 109a37: 85 c0 test %eax,%eax 109a39: 79 d9 jns 109a14 rtems_task_wake_after (1); 109a3b: 83 ec 0c sub $0xc,%esp 109a3e: 6a 01 push $0x1 109a40: e8 1b 16 00 00 call 10b060 109a45: 83 c4 10 add $0x10,%esp 109a48: eb dc jmp 109a26 } } } else { rtems_interval then, now; then = rtems_clock_get_ticks_since_boot(); 109a4a: e8 01 0b 00 00 call 10a550 109a4f: 89 c6 mov %eax,%esi 109a51: 8d 76 00 lea 0x0(%esi),%esi for (;;) { n = (*tty->device.pollRead)(tty->minor); 109a54: 83 ec 0c sub $0xc,%esp 109a57: ff 73 10 pushl 0x10(%ebx) 109a5a: ff 93 a0 00 00 00 call *0xa0(%ebx) if (n < 0) { 109a60: 83 c4 10 add $0x10,%esp 109a63: 85 c0 test %eax,%eax 109a65: 78 25 js 109a8c break; } } rtems_task_wake_after (1); } else { siproc (n, tty); 109a67: 0f b6 c0 movzbl %al,%eax 109a6a: 89 da mov %ebx,%edx 109a6c: e8 ef fb ff ff call 109660 if (tty->ccount >= tty->termios.c_cc[VMIN]) 109a71: 8a 43 47 mov 0x47(%ebx),%al 109a74: 0f b6 d0 movzbl %al,%edx 109a77: 39 53 20 cmp %edx,0x20(%ebx) 109a7a: 0f 8d 7c fd ff ff jge 1097fc <== NEVER TAKEN break; if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 109a80: 84 c0 test %al,%al 109a82: 74 d0 je 109a54 <== NEVER TAKEN 109a84: 80 7b 46 00 cmpb $0x0,0x46(%ebx) 109a88: 74 ca je 109a54 <== NEVER TAKEN 109a8a: eb be jmp 109a4a then = rtems_clock_get_ticks_since_boot(); for (;;) { n = (*tty->device.pollRead)(tty->minor); if (n < 0) { if (tty->termios.c_cc[VMIN]) { 109a8c: 80 7b 47 00 cmpb $0x0,0x47(%ebx) 109a90: 74 1d je 109aaf <== NEVER TAKEN if (tty->termios.c_cc[VTIME] && tty->ccount) { 109a92: 80 7b 46 00 cmpb $0x0,0x46(%ebx) 109a96: 74 08 je 109aa0 <== NEVER TAKEN 109a98: 8b 43 20 mov 0x20(%ebx),%eax 109a9b: 85 c0 test %eax,%eax 109a9d: 75 1a jne 109ab9 109a9f: 90 nop now = rtems_clock_get_ticks_since_boot(); if ((now - then) > tty->vtimeTicks) { break; } } rtems_task_wake_after (1); 109aa0: 83 ec 0c sub $0xc,%esp 109aa3: 6a 01 push $0x1 109aa5: e8 b6 15 00 00 call 10b060 109aaa: 83 c4 10 add $0x10,%esp 109aad: eb a5 jmp 109a54 if ((now - then) > tty->vtimeTicks) { break; } } } else { if (!tty->termios.c_cc[VTIME]) 109aaf: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED 109ab3: 0f 84 43 fd ff ff je 1097fc <== NOT EXECUTED break; now = rtems_clock_get_ticks_since_boot(); 109ab9: e8 92 0a 00 00 call 10a550 if ((now - then) > tty->vtimeTicks) { 109abe: 29 f0 sub %esi,%eax 109ac0: 3b 43 54 cmp 0x54(%ebx),%eax 109ac3: 76 db jbe 109aa0 109ac5: e9 32 fd ff ff jmp 1097fc =============================================================================== 00109e60 : * 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) { 109e60: 55 push %ebp 109e61: 89 e5 mov %esp,%ebp 109e63: 57 push %edi 109e64: 56 push %esi 109e65: 53 push %ebx 109e66: 83 ec 0c sub $0xc,%esp 109e69: 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)) 109e6c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109e72: 25 03 04 00 00 and $0x403,%eax 109e77: 3d 01 04 00 00 cmp $0x401,%eax 109e7c: 0f 84 62 01 00 00 je 109fe4 <== NEVER TAKEN tty->flow_ctrl |= FL_ISNTXOF; rtems_interrupt_enable(level); nToSend = 1; } else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) { 109e82: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109e88: 83 e0 03 and $0x3,%eax 109e8b: 83 f8 02 cmp $0x2,%eax 109e8e: 0f 84 8c 01 00 00 je 10a020 <== NEVER TAKEN tty->flow_ctrl &= ~FL_ISNTXOF; rtems_interrupt_enable(level); nToSend = 1; } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { 109e94: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 109e9a: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 109ea0: 39 c2 cmp %eax,%edx 109ea2: 0f 84 a4 00 00 00 je 109f4c rtems_semaphore_release (tty->rawOutBuf.Semaphore); } return 0; } rtems_interrupt_disable(level); 109ea8: 9c pushf 109ea9: fa cli 109eaa: 58 pop %eax len = tty->t_dqlen; 109eab: 8b b3 90 00 00 00 mov 0x90(%ebx),%esi tty->t_dqlen = 0; 109eb1: c7 83 90 00 00 00 00 movl $0x0,0x90(%ebx) 109eb8: 00 00 00 rtems_interrupt_enable(level); 109ebb: 50 push %eax 109ebc: 9d popf newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size; 109ebd: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 109ec3: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx 109ec9: 8d 04 06 lea (%esi,%eax,1),%eax 109ecc: 31 d2 xor %edx,%edx 109ece: f7 f1 div %ecx 109ed0: 89 d6 mov %edx,%esi tty->rawOutBuf.Tail = newTail; 109ed2: 89 93 84 00 00 00 mov %edx,0x84(%ebx) if (tty->rawOutBufState == rob_wait) { 109ed8: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) 109edf: 0f 84 e7 00 00 00 je 109fcc * wake up any pending writer task */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); } if (newTail == tty->rawOutBuf.Head) { 109ee5: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 109eeb: 39 f0 cmp %esi,%eax 109eed: 74 79 je 109f68 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)) 109eef: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109ef5: 25 10 02 00 00 and $0x210,%eax 109efa: 3d 10 02 00 00 cmp $0x210,%eax 109eff: 0f 84 57 01 00 00 je 10a05c <== NEVER TAKEN nToSend = 0; } else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) 109f05: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 109f0b: 39 c6 cmp %eax,%esi 109f0d: 0f 87 91 00 00 00 ja 109fa4 nToSend = tty->rawOutBuf.Size - newTail; else nToSend = tty->rawOutBuf.Head - newTail; 109f13: 8b bb 80 00 00 00 mov 0x80(%ebx),%edi 109f19: 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)) { 109f1b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109f21: f6 c4 06 test $0x6,%ah 109f24: 0f 85 91 00 00 00 jne 109fbb 109f2a: 89 f8 mov %edi,%eax nToSend = 1; } tty->rawOutBufState = rob_busy; /*apm*/ 109f2c: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) 109f33: 00 00 00 (*tty->device.write)( 109f36: 52 push %edx 109f37: 50 push %eax 109f38: 8b 43 7c mov 0x7c(%ebx),%eax 109f3b: 01 f0 add %esi,%eax 109f3d: 50 push %eax 109f3e: ff 73 10 pushl 0x10(%ebx) 109f41: ff 93 a4 00 00 00 call *0xa4(%ebx) 109f47: 83 c4 10 add $0x10,%esp 109f4a: eb 48 jmp 109f94 } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { /* * buffer was empty */ if (tty->rawOutBufState == rob_wait) { 109f4c: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) 109f53: 0f 84 2b 01 00 00 je 10a084 <== NEVER TAKEN /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); } return 0; 109f59: 31 ff xor %edi,%edi tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 109f5b: 89 f8 mov %edi,%eax 109f5d: 8d 65 f4 lea -0xc(%ebp),%esp 109f60: 5b pop %ebx 109f61: 5e pop %esi 109f62: 5f pop %edi 109f63: c9 leave 109f64: c3 ret 109f65: 8d 76 00 lea 0x0(%esi),%esi if (newTail == tty->rawOutBuf.Head) { /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; 109f68: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx) 109f6f: 00 00 00 nToSend = 0; /* * check to see if snd wakeup callback was set */ if ( tty->tty_snd.sw_pfn != NULL) { 109f72: 8b 83 d4 00 00 00 mov 0xd4(%ebx),%eax 109f78: 85 c0 test %eax,%eax 109f7a: 0f 84 1c 01 00 00 je 10a09c <== ALWAYS TAKEN (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg); 109f80: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109f83: ff b3 d8 00 00 00 pushl 0xd8(%ebx) <== NOT EXECUTED 109f89: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED 109f8c: 52 push %edx <== NOT EXECUTED 109f8d: ff d0 call *%eax <== NOT EXECUTED 109f8f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (newTail == tty->rawOutBuf.Head) { /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; nToSend = 0; 109f92: 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*/ 109f94: 89 b3 84 00 00 00 mov %esi,0x84(%ebx) } return nToSend; } 109f9a: 89 f8 mov %edi,%eax 109f9c: 8d 65 f4 lea -0xc(%ebp),%esp 109f9f: 5b pop %ebx 109fa0: 5e pop %esi 109fa1: 5f pop %edi 109fa2: c9 leave 109fa3: c3 ret } else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) nToSend = tty->rawOutBuf.Size - newTail; 109fa4: 8b bb 88 00 00 00 mov 0x88(%ebx),%edi 109faa: 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)) { 109fac: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109fb2: f6 c4 06 test $0x6,%ah 109fb5: 0f 84 6f ff ff ff je 109f2a <== ALWAYS TAKEN 109fbb: b8 01 00 00 00 mov $0x1,%eax nToSend = 1; 109fc0: bf 01 00 00 00 mov $0x1,%edi 109fc5: e9 62 ff ff ff jmp 109f2c 109fca: 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); 109fcc: 83 ec 0c sub $0xc,%esp 109fcf: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 109fd5: e8 ca 0c 00 00 call 10aca4 109fda: 83 c4 10 add $0x10,%esp 109fdd: e9 03 ff ff ff jmp 109ee5 109fe2: 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); 109fe4: 56 push %esi <== NOT EXECUTED 109fe5: 6a 01 push $0x1 <== NOT EXECUTED 109fe7: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED 109fea: 50 push %eax <== NOT EXECUTED 109feb: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109fee: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED rtems_interrupt_disable(level); 109ff4: 9c pushf <== NOT EXECUTED 109ff5: fa cli <== NOT EXECUTED 109ff6: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 109ff7: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; 109ffd: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10a003: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 10a006: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED rtems_interrupt_enable(level); 10a00c: 52 push %edx <== NOT EXECUTED 10a00d: 9d popf <== NOT EXECUTED 10a00e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED nToSend = 1; 10a011: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 10a016: 89 f8 mov %edi,%eax <== NOT EXECUTED 10a018: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a01b: 5b pop %ebx <== NOT EXECUTED 10a01c: 5e pop %esi <== NOT EXECUTED 10a01d: 5f pop %edi <== NOT EXECUTED 10a01e: c9 leave <== NOT EXECUTED 10a01f: 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); 10a020: 51 push %ecx <== NOT EXECUTED 10a021: 6a 01 push $0x1 <== NOT EXECUTED 10a023: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED 10a026: 50 push %eax <== NOT EXECUTED 10a027: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10a02a: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED rtems_interrupt_disable(level); 10a030: 9c pushf <== NOT EXECUTED 10a031: fa cli <== NOT EXECUTED 10a032: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 10a033: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl &= ~FL_ISNTXOF; 10a039: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10a03f: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 10a042: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED rtems_interrupt_enable(level); 10a048: 52 push %edx <== NOT EXECUTED 10a049: 9d popf <== NOT EXECUTED 10a04a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED nToSend = 1; 10a04d: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 10a052: 89 f8 mov %edi,%eax <== NOT EXECUTED 10a054: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a057: 5b pop %ebx <== NOT EXECUTED 10a058: 5e pop %esi <== NOT EXECUTED 10a059: 5f pop %edi <== NOT EXECUTED 10a05a: c9 leave <== NOT EXECUTED 10a05b: 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); 10a05c: 9c pushf <== NOT EXECUTED 10a05d: fa cli <== NOT EXECUTED 10a05e: 5a pop %edx <== NOT EXECUTED tty->flow_ctrl |= FL_OSTOP; 10a05f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10a065: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 10a068: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ 10a06e: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED 10a075: 00 00 00 rtems_interrupt_enable(level); 10a078: 52 push %edx <== NOT EXECUTED 10a079: 9d popf <== NOT EXECUTED nToSend = 0; 10a07a: 31 ff xor %edi,%edi <== NOT EXECUTED 10a07c: e9 13 ff ff ff jmp 109f94 <== NOT EXECUTED 10a081: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ if (tty->rawOutBufState == rob_wait) { /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 10a084: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a087: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED 10a08d: e8 12 0c 00 00 call 10aca4 <== NOT EXECUTED 10a092: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; 10a095: 31 ff xor %edi,%edi <== NOT EXECUTED 10a097: e9 bf fe ff ff jmp 109f5b <== NOT EXECUTED if (newTail == tty->rawOutBuf.Head) { /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; nToSend = 0; 10a09c: 31 ff xor %edi,%edi 10a09e: e9 f1 fe ff ff jmp 109f94 =============================================================================== 00109df4 : /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) { 109df4: 55 push %ebp 109df5: 89 e5 mov %esp,%ebp 109df7: 57 push %edi 109df8: 56 push %esi 109df9: 53 push %ebx 109dfa: 83 ec 1c sub $0x1c,%esp 109dfd: 8b 5d 08 mov 0x8(%ebp),%ebx 109e00: 8d 75 e0 lea -0x20(%ebp),%esi 109e03: 8d 7d e7 lea -0x19(%ebp),%edi 109e06: eb 14 jmp 109e1c } /* * do something */ c = tty->device.pollRead(tty->minor); 109e08: 83 ec 0c sub $0xc,%esp 109e0b: ff 73 10 pushl 0x10(%ebx) 109e0e: ff 93 a0 00 00 00 call *0xa0(%ebx) if (c != EOF) { 109e14: 83 c4 10 add $0x10,%esp 109e17: 83 f8 ff cmp $0xffffffff,%eax 109e1a: 75 30 jne 109e4c while (1) { /* * wait for rtems event */ rtems_event_receive( 109e1c: 56 push %esi 109e1d: 6a 00 push $0x0 109e1f: 6a 02 push $0x2 109e21: 6a 03 push $0x3 109e23: e8 94 07 00 00 call 10a5bc (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) { 109e28: 83 c4 10 add $0x10,%esp 109e2b: f6 45 e0 01 testb $0x1,-0x20(%ebp) 109e2f: 74 d7 je 109e08 <== ALWAYS TAKEN tty->rxTaskId = 0; 109e31: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED 109e38: 00 00 00 rtems_task_delete(RTEMS_SELF); 109e3b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109e3e: 6a 00 push $0x0 <== NOT EXECUTED 109e40: e8 5f 10 00 00 call 10aea4 <== NOT EXECUTED 109e45: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109e48: eb be jmp 109e08 <== NOT EXECUTED 109e4a: 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; 109e4c: 88 45 e7 mov %al,-0x19(%ebp) rtems_termios_enqueue_raw_characters ( tty,&c_buf,1); 109e4f: 50 push %eax 109e50: 6a 01 push $0x1 109e52: 57 push %edi 109e53: 53 push %ebx 109e54: e8 8f fc ff ff call 109ae8 109e59: 83 c4 10 add $0x10,%esp 109e5c: eb be jmp 109e1c =============================================================================== 0010a0a4 : /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) { 10a0a4: 55 push %ebp 10a0a5: 89 e5 mov %esp,%ebp 10a0a7: 56 push %esi 10a0a8: 53 push %ebx 10a0a9: 83 ec 10 sub $0x10,%esp 10a0ac: 8b 5d 08 mov 0x8(%ebp),%ebx 10a0af: 8d 75 f4 lea -0xc(%ebp),%esi 10a0b2: eb 28 jmp 10a0dc } /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 10a0b4: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 10a0ba: c1 e0 05 shl $0x5,%eax 10a0bd: 8b 80 54 60 12 00 mov 0x126054(%eax),%eax 10a0c3: 85 c0 test %eax,%eax 10a0c5: 74 09 je 10a0d0 <== ALWAYS TAKEN rtems_termios_linesw[tty->t_line].l_start(tty); 10a0c7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a0ca: 53 push %ebx <== NOT EXECUTED 10a0cb: ff d0 call *%eax <== NOT EXECUTED 10a0cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * try to push further characters to device */ rtems_termios_refill_transmitter(tty); 10a0d0: 83 ec 0c sub $0xc,%esp 10a0d3: 53 push %ebx 10a0d4: e8 87 fd ff ff call 109e60 } 10a0d9: 83 c4 10 add $0x10,%esp while (1) { /* * wait for rtems event */ rtems_event_receive( 10a0dc: 56 push %esi 10a0dd: 6a 00 push $0x0 10a0df: 6a 02 push $0x2 10a0e1: 6a 03 push $0x3 10a0e3: e8 d4 04 00 00 call 10a5bc (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) { 10a0e8: 83 c4 10 add $0x10,%esp 10a0eb: f6 45 f4 01 testb $0x1,-0xc(%ebp) 10a0ef: 74 c3 je 10a0b4 <== ALWAYS TAKEN tty->txTaskId = 0; 10a0f1: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED 10a0f8: 00 00 00 rtems_task_delete(RTEMS_SELF); 10a0fb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a0fe: 6a 00 push $0x0 <== NOT EXECUTED 10a100: e8 9f 0d 00 00 call 10aea4 <== NOT EXECUTED 10a105: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a108: eb aa jmp 10a0b4 <== NOT EXECUTED =============================================================================== 001096b4 : rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) { 1096b4: 55 push %ebp 1096b5: 89 e5 mov %esp,%ebp 1096b7: 57 push %edi 1096b8: 56 push %esi 1096b9: 53 push %ebx 1096ba: 83 ec 20 sub $0x20,%esp 1096bd: 8b 7d 08 mov 0x8(%ebp),%edi rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 1096c0: 8b 07 mov (%edi),%eax 1096c2: 8b 70 34 mov 0x34(%eax),%esi rtems_status_code sc; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 1096c5: 6a 00 push $0x0 1096c7: 6a 00 push $0x0 1096c9: ff 76 18 pushl 0x18(%esi) 1096cc: e8 d7 14 00 00 call 10aba8 1096d1: 89 45 e4 mov %eax,-0x1c(%ebp) if (sc != RTEMS_SUCCESSFUL) 1096d4: 83 c4 10 add $0x10,%esp 1096d7: 85 c0 test %eax,%eax 1096d9: 75 29 jne 109704 <== NEVER TAKEN return sc; if (rtems_termios_linesw[tty->t_line].l_write != NULL) { 1096db: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax 1096e1: c1 e0 05 shl $0x5,%eax 1096e4: 8b 80 4c 60 12 00 mov 0x12604c(%eax),%eax 1096ea: 85 c0 test %eax,%eax 1096ec: 74 22 je 109710 sc = rtems_termios_linesw[tty->t_line].l_write(tty,args); 1096ee: 83 ec 08 sub $0x8,%esp 1096f1: 57 push %edi 1096f2: 56 push %esi 1096f3: ff d0 call *%eax 1096f5: 89 45 e4 mov %eax,-0x1c(%ebp) rtems_semaphore_release (tty->osem); 1096f8: 5f pop %edi 1096f9: ff 76 18 pushl 0x18(%esi) 1096fc: e8 a3 15 00 00 call 10aca4 return sc; 109701: 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; } 109704: 8b 45 e4 mov -0x1c(%ebp),%eax 109707: 8d 65 f4 lea -0xc(%ebp),%esp 10970a: 5b pop %ebx 10970b: 5e pop %esi 10970c: 5f pop %edi 10970d: c9 leave 10970e: c3 ret 10970f: 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) { 109710: f6 46 34 01 testb $0x1,0x34(%esi) 109714: 74 4e je 109764 <== NEVER TAKEN uint32_t count = args->count; 109716: 8b 47 10 mov 0x10(%edi),%eax 109719: 89 45 e0 mov %eax,-0x20(%ebp) char *buffer = args->buffer; 10971c: 8b 47 0c mov 0xc(%edi),%eax while (count--) 10971f: 8b 5d e0 mov -0x20(%ebp),%ebx 109722: 85 db test %ebx,%ebx 109724: 74 56 je 10977c <== NEVER TAKEN 109726: 31 db xor %ebx,%ebx 109728: 89 7d dc mov %edi,-0x24(%ebp) 10972b: 89 c7 mov %eax,%edi 10972d: 8d 76 00 lea 0x0(%esi),%esi oproc (*buffer++, tty); 109730: 0f b6 04 1f movzbl (%edi,%ebx,1),%eax 109734: 89 f2 mov %esi,%edx 109736: e8 6d fa ff ff call 1091a8 10973b: 43 inc %ebx return sc; } if (tty->termios.c_oflag & OPOST) { uint32_t count = args->count; char *buffer = args->buffer; while (count--) 10973c: 39 5d e0 cmp %ebx,-0x20(%ebp) 10973f: 75 ef jne 109730 109741: 8b 7d dc mov -0x24(%ebp),%edi 109744: 8b 47 10 mov 0x10(%edi),%eax oproc (*buffer++, tty); args->bytes_moved = args->count; 109747: 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); 10974a: 83 ec 0c sub $0xc,%esp 10974d: ff 76 18 pushl 0x18(%esi) 109750: e8 4f 15 00 00 call 10aca4 return sc; 109755: 83 c4 10 add $0x10,%esp } 109758: 8b 45 e4 mov -0x1c(%ebp),%eax 10975b: 8d 65 f4 lea -0xc(%ebp),%esp 10975e: 5b pop %ebx 10975f: 5e pop %esi 109760: 5f pop %edi 109761: c9 leave 109762: c3 ret 109763: 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); 109764: 51 push %ecx <== NOT EXECUTED 109765: 56 push %esi <== NOT EXECUTED 109766: ff 77 10 pushl 0x10(%edi) <== NOT EXECUTED 109769: ff 77 0c pushl 0xc(%edi) <== NOT EXECUTED 10976c: e8 03 f9 ff ff call 109074 <== NOT EXECUTED args->bytes_moved = args->count; 109771: 8b 47 10 mov 0x10(%edi),%eax <== NOT EXECUTED 109774: 89 47 18 mov %eax,0x18(%edi) <== NOT EXECUTED 109777: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10977a: eb ce jmp 10974a <== NOT EXECUTED return sc; } if (tty->termios.c_oflag & OPOST) { uint32_t count = args->count; char *buffer = args->buffer; while (count--) 10977c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10977e: eb c7 jmp 109747 <== NOT EXECUTED =============================================================================== 00117cfc : */ rtems_status_code rtems_timer_cancel( rtems_id id ) { 117cfc: 55 push %ebp 117cfd: 89 e5 mov %esp,%ebp 117cff: 83 ec 1c sub $0x1c,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 117d02: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 117d05: 50 push %eax 117d06: ff 75 08 pushl 0x8(%ebp) 117d09: 68 40 0c 14 00 push $0x140c40 117d0e: e8 b1 2a 00 00 call 11a7c4 <_Objects_Get> switch ( location ) { 117d13: 83 c4 10 add $0x10,%esp 117d16: 8b 55 f4 mov -0xc(%ebp),%edx 117d19: 85 d2 test %edx,%edx 117d1b: 74 07 je 117d24 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 117d1d: b8 04 00 00 00 mov $0x4,%eax } 117d22: c9 leave 117d23: c3 ret the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 117d24: 83 78 38 04 cmpl $0x4,0x38(%eax) 117d28: 74 0f je 117d39 <== NEVER TAKEN (void) _Watchdog_Remove( &the_timer->Ticker ); 117d2a: 83 ec 0c sub $0xc,%esp 117d2d: 83 c0 10 add $0x10,%eax 117d30: 50 push %eax 117d31: e8 3e 46 00 00 call 11c374 <_Watchdog_Remove> 117d36: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 117d39: e8 d6 35 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 117d3e: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 117d40: c9 leave 117d41: c3 ret =============================================================================== 0010b4d8 : rtems_status_code rtems_timer_create( rtems_name name, rtems_id *id ) { 10b4d8: 55 push %ebp 10b4d9: 89 e5 mov %esp,%ebp 10b4db: 57 push %edi 10b4dc: 56 push %esi 10b4dd: 53 push %ebx 10b4de: 83 ec 0c sub $0xc,%esp 10b4e1: 8b 5d 08 mov 0x8(%ebp),%ebx 10b4e4: 8b 75 0c mov 0xc(%ebp),%esi Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 10b4e7: 85 db test %ebx,%ebx 10b4e9: 74 6d je 10b558 return RTEMS_INVALID_NAME; if ( !id ) 10b4eb: 85 f6 test %esi,%esi 10b4ed: 0f 84 89 00 00 00 je 10b57c 10b4f3: a1 2c 7a 12 00 mov 0x127a2c,%eax 10b4f8: 40 inc %eax 10b4f9: a3 2c 7a 12 00 mov %eax,0x127a2c * 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 ); 10b4fe: 83 ec 0c sub $0xc,%esp 10b501: 68 40 7d 12 00 push $0x127d40 10b506: e8 ad 0d 00 00 call 10c2b8 <_Objects_Allocate> _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { 10b50b: 83 c4 10 add $0x10,%esp 10b50e: 85 c0 test %eax,%eax 10b510: 74 56 je 10b568 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_timer->the_class = TIMER_DORMANT; 10b512: 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; 10b519: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_watchdog->routine = routine; 10b520: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) the_watchdog->id = id; 10b527: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) the_watchdog->user_data = user_data; 10b52e: 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 ), 10b535: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10b538: 0f b7 fa movzwl %dx,%edi #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10b53b: 8b 0d 5c 7d 12 00 mov 0x127d5c,%ecx 10b541: 89 04 b9 mov %eax,(%ecx,%edi,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10b544: 89 58 0c mov %ebx,0xc(%eax) &_Timer_Information, &the_timer->Object, (Objects_Name) name ); *id = the_timer->Object.id; 10b547: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 10b549: e8 f6 1c 00 00 call 10d244 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b54e: 31 c0 xor %eax,%eax } 10b550: 8d 65 f4 lea -0xc(%ebp),%esp 10b553: 5b pop %ebx 10b554: 5e pop %esi 10b555: 5f pop %edi 10b556: c9 leave 10b557: c3 ret ) { Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 10b558: b8 03 00 00 00 mov $0x3,%eax ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b55d: 8d 65 f4 lea -0xc(%ebp),%esp 10b560: 5b pop %ebx 10b561: 5e pop %esi 10b562: 5f pop %edi 10b563: c9 leave 10b564: c3 ret 10b565: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { _Thread_Enable_dispatch(); 10b568: e8 d7 1c 00 00 call 10d244 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 10b56d: b8 05 00 00 00 mov $0x5,%eax ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b572: 8d 65 f4 lea -0xc(%ebp),%esp 10b575: 5b pop %ebx 10b576: 5e pop %esi 10b577: 5f pop %edi 10b578: c9 leave 10b579: c3 ret 10b57a: 66 90 xchg %ax,%ax if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) return RTEMS_INVALID_ADDRESS; 10b57c: b8 09 00 00 00 mov $0x9,%eax ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b581: 8d 65 f4 lea -0xc(%ebp),%esp 10b584: 5b pop %ebx 10b585: 5e pop %esi 10b586: 5f pop %edi 10b587: c9 leave 10b588: c3 ret =============================================================================== 00117df8 : */ rtems_status_code rtems_timer_delete( rtems_id id ) { 117df8: 55 push %ebp 117df9: 89 e5 mov %esp,%ebp 117dfb: 53 push %ebx 117dfc: 83 ec 18 sub $0x18,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 117dff: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 117e02: 50 push %eax 117e03: ff 75 08 pushl 0x8(%ebp) 117e06: 68 40 0c 14 00 push $0x140c40 117e0b: e8 b4 29 00 00 call 11a7c4 <_Objects_Get> 117e10: 89 c3 mov %eax,%ebx switch ( location ) { 117e12: 83 c4 10 add $0x10,%esp 117e15: 8b 4d f4 mov -0xc(%ebp),%ecx 117e18: 85 c9 test %ecx,%ecx 117e1a: 75 38 jne 117e54 case OBJECTS_LOCAL: _Objects_Close( &_Timer_Information, &the_timer->Object ); 117e1c: 83 ec 08 sub $0x8,%esp 117e1f: 50 push %eax 117e20: 68 40 0c 14 00 push $0x140c40 117e25: e8 26 25 00 00 call 11a350 <_Objects_Close> (void) _Watchdog_Remove( &the_timer->Ticker ); 117e2a: 8d 43 10 lea 0x10(%ebx),%eax 117e2d: 89 04 24 mov %eax,(%esp) 117e30: e8 3f 45 00 00 call 11c374 <_Watchdog_Remove> */ RTEMS_INLINE_ROUTINE void _Timer_Free ( Timer_Control *the_timer ) { _Objects_Free( &_Timer_Information, &the_timer->Object ); 117e35: 58 pop %eax 117e36: 5a pop %edx 117e37: 53 push %ebx 117e38: 68 40 0c 14 00 push $0x140c40 117e3d: e8 06 28 00 00 call 11a648 <_Objects_Free> _Timer_Free( the_timer ); _Thread_Enable_dispatch(); 117e42: e8 cd 34 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 117e47: 83 c4 10 add $0x10,%esp 117e4a: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 117e4c: 8b 5d fc mov -0x4(%ebp),%ebx 117e4f: c9 leave 117e50: c3 ret 117e51: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 117e54: b8 04 00 00 00 mov $0x4,%eax } 117e59: 8b 5d fc mov -0x4(%ebp),%ebx 117e5c: c9 leave 117e5d: c3 ret =============================================================================== 0010b58c : rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 10b58c: 55 push %ebp 10b58d: 89 e5 mov %esp,%ebp 10b58f: 57 push %edi 10b590: 56 push %esi 10b591: 53 push %ebx 10b592: 83 ec 2c sub $0x2c,%esp 10b595: 8b 5d 0c mov 0xc(%ebp),%ebx 10b598: 8b 75 10 mov 0x10(%ebp),%esi Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 10b59b: 85 db test %ebx,%ebx 10b59d: 0f 84 99 00 00 00 je 10b63c return RTEMS_INVALID_NUMBER; if ( !routine ) 10b5a3: 85 f6 test %esi,%esi 10b5a5: 0f 84 b1 00 00 00 je 10b65c Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 10b5ab: 57 push %edi return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); 10b5ac: 8d 45 e4 lea -0x1c(%ebp),%eax 10b5af: 50 push %eax 10b5b0: ff 75 08 pushl 0x8(%ebp) 10b5b3: 68 40 7d 12 00 push $0x127d40 10b5b8: e8 af 11 00 00 call 10c76c <_Objects_Get> 10b5bd: 89 c7 mov %eax,%edi switch ( location ) { 10b5bf: 83 c4 10 add $0x10,%esp 10b5c2: 8b 4d e4 mov -0x1c(%ebp),%ecx 10b5c5: 85 c9 test %ecx,%ecx 10b5c7: 74 0f je 10b5d8 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b5c9: b8 04 00 00 00 mov $0x4,%eax } 10b5ce: 8d 65 f4 lea -0xc(%ebp),%esp 10b5d1: 5b pop %ebx 10b5d2: 5e pop %esi 10b5d3: 5f pop %edi 10b5d4: c9 leave 10b5d5: c3 ret 10b5d6: 66 90 xchg %ax,%ax the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 10b5d8: 8d 50 10 lea 0x10(%eax),%edx 10b5db: 83 ec 0c sub $0xc,%esp 10b5de: 52 push %edx 10b5df: 89 55 d4 mov %edx,-0x2c(%ebp) 10b5e2: e8 a9 2a 00 00 call 10e090 <_Watchdog_Remove> _ISR_Disable( level ); 10b5e7: 9c pushf 10b5e8: fa cli 10b5e9: 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 ) { 10b5ea: 83 c4 10 add $0x10,%esp 10b5ed: 8b 57 18 mov 0x18(%edi),%edx 10b5f0: 85 d2 test %edx,%edx 10b5f2: 8b 55 d4 mov -0x2c(%ebp),%edx 10b5f5: 75 55 jne 10b64c /* * 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; 10b5f7: 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; 10b5fe: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) the_watchdog->routine = routine; 10b605: 89 77 2c mov %esi,0x2c(%edi) the_watchdog->id = id; 10b608: 8b 4d 08 mov 0x8(%ebp),%ecx 10b60b: 89 4f 30 mov %ecx,0x30(%edi) the_watchdog->user_data = user_data; 10b60e: 8b 4d 14 mov 0x14(%ebp),%ecx 10b611: 89 4f 34 mov %ecx,0x34(%edi) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 10b614: 50 push %eax 10b615: 9d popf Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b616: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b619: 83 ec 08 sub $0x8,%esp 10b61c: 52 push %edx 10b61d: 68 00 7b 12 00 push $0x127b00 10b622: e8 29 29 00 00 call 10df50 <_Watchdog_Insert> _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 10b627: e8 18 1c 00 00 call 10d244 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b62c: 83 c4 10 add $0x10,%esp 10b62f: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b631: 8d 65 f4 lea -0xc(%ebp),%esp 10b634: 5b pop %ebx 10b635: 5e pop %esi 10b636: 5f pop %edi 10b637: c9 leave 10b638: c3 ret 10b639: 8d 76 00 lea 0x0(%esi),%esi Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; 10b63c: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b641: 8d 65 f4 lea -0xc(%ebp),%esp 10b644: 5b pop %ebx 10b645: 5e pop %esi 10b646: 5f pop %edi 10b647: c9 leave 10b648: c3 ret 10b649: 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 ); 10b64c: 50 push %eax 10b64d: 9d popf _Thread_Enable_dispatch(); 10b64e: e8 f1 1b 00 00 call 10d244 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b653: 31 c0 xor %eax,%eax 10b655: e9 74 ff ff ff jmp 10b5ce 10b65a: 66 90 xchg %ax,%ax if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; if ( !routine ) return RTEMS_INVALID_ADDRESS; 10b65c: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b661: 8d 65 f4 lea -0xc(%ebp),%esp 10b664: 5b pop %ebx 10b665: 5e pop %esi 10b666: 5f pop %edi 10b667: c9 leave 10b668: c3 ret =============================================================================== 00117f40 : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 117f40: 55 push %ebp 117f41: 89 e5 mov %esp,%ebp 117f43: 57 push %edi 117f44: 56 push %esi 117f45: 53 push %ebx 117f46: 83 ec 2c sub $0x2c,%esp 117f49: 8b 75 08 mov 0x8(%ebp),%esi 117f4c: 8b 7d 0c mov 0xc(%ebp),%edi 117f4f: 8b 5d 10 mov 0x10(%ebp),%ebx Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD_Is_set ) 117f52: 80 3d fc 08 14 00 00 cmpb $0x0,0x1408fc 117f59: 75 0d jne 117f68 return RTEMS_NOT_DEFINED; 117f5b: b8 0b 00 00 00 mov $0xb,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 117f60: 8d 65 f4 lea -0xc(%ebp),%esp 117f63: 5b pop %ebx 117f64: 5e pop %esi 117f65: 5f pop %edi 117f66: c9 leave 117f67: c3 ret rtems_interval seconds; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) 117f68: 83 ec 0c sub $0xc,%esp 117f6b: 57 push %edi 117f6c: e8 93 d4 ff ff call 115404 <_TOD_Validate> 117f71: 83 c4 10 add $0x10,%esp 117f74: 84 c0 test %al,%al 117f76: 74 1e je 117f96 return RTEMS_INVALID_CLOCK; if ( !routine ) 117f78: 85 db test %ebx,%ebx 117f7a: 0f 84 a4 00 00 00 je 118024 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; seconds = _TOD_To_seconds( wall_time ); 117f80: 83 ec 0c sub $0xc,%esp 117f83: 57 push %edi 117f84: e8 ef d3 ff ff call 115378 <_TOD_To_seconds> 117f89: 89 c7 mov %eax,%edi if ( seconds <= _TOD_Seconds_since_epoch() ) 117f8b: 83 c4 10 add $0x10,%esp 117f8e: 3b 05 88 09 14 00 cmp 0x140988,%eax 117f94: 77 0e ja 117fa4 return RTEMS_INVALID_CLOCK; 117f96: b8 14 00 00 00 mov $0x14,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 117f9b: 8d 65 f4 lea -0xc(%ebp),%esp 117f9e: 5b pop %ebx 117f9f: 5e pop %esi 117fa0: 5f pop %edi 117fa1: c9 leave 117fa2: c3 ret 117fa3: 90 nop 117fa4: 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 ); 117fa5: 8d 45 e4 lea -0x1c(%ebp),%eax 117fa8: 50 push %eax 117fa9: 56 push %esi 117faa: 68 40 0c 14 00 push $0x140c40 117faf: e8 10 28 00 00 call 11a7c4 <_Objects_Get> switch ( location ) { 117fb4: 83 c4 10 add $0x10,%esp 117fb7: 8b 4d e4 mov -0x1c(%ebp),%ecx 117fba: 85 c9 test %ecx,%ecx 117fbc: 75 5a jne 118018 <== NEVER TAKEN case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 117fbe: 8d 48 10 lea 0x10(%eax),%ecx 117fc1: 83 ec 0c sub $0xc,%esp 117fc4: 51 push %ecx 117fc5: 89 45 d0 mov %eax,-0x30(%ebp) 117fc8: 89 4d d4 mov %ecx,-0x2c(%ebp) 117fcb: e8 a4 43 00 00 call 11c374 <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY; 117fd0: 8b 55 d0 mov -0x30(%ebp),%edx 117fd3: 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; 117fda: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) the_watchdog->routine = routine; 117fe1: 89 5a 2c mov %ebx,0x2c(%edx) the_watchdog->id = id; 117fe4: 89 72 30 mov %esi,0x30(%edx) the_watchdog->user_data = user_data; 117fe7: 8b 45 14 mov 0x14(%ebp),%eax 117fea: 89 42 34 mov %eax,0x34(%edx) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _Watchdog_Insert_seconds( 117fed: 2b 3d 88 09 14 00 sub 0x140988,%edi 117ff3: 89 7a 1c mov %edi,0x1c(%edx) ) { the_watchdog->initial = units; _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog ); 117ff6: 58 pop %eax 117ff7: 5a pop %edx 117ff8: 8b 4d d4 mov -0x2c(%ebp),%ecx 117ffb: 51 push %ecx 117ffc: 68 b4 09 14 00 push $0x1409b4 118001: e8 2e 42 00 00 call 11c234 <_Watchdog_Insert> &the_timer->Ticker, seconds - _TOD_Seconds_since_epoch() ); _Thread_Enable_dispatch(); 118006: e8 09 33 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 11800b: 83 c4 10 add $0x10,%esp 11800e: 31 c0 xor %eax,%eax 118010: e9 4b ff ff ff jmp 117f60 118015: 8d 76 00 lea 0x0(%esi),%esi #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 118018: b8 04 00 00 00 mov $0x4,%eax 11801d: e9 3e ff ff ff jmp 117f60 118022: 66 90 xchg %ax,%ax if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; if ( !routine ) return RTEMS_INVALID_ADDRESS; 118024: b8 09 00 00 00 mov $0x9,%eax 118029: e9 32 ff ff ff jmp 117f60 =============================================================================== 001186bc : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 1186bc: 55 push %ebp 1186bd: 89 e5 mov %esp,%ebp 1186bf: 56 push %esi 1186c0: 53 push %ebx 1186c1: 83 ec 10 sub $0x10,%esp 1186c4: 8b 45 08 mov 0x8(%ebp),%eax 1186c7: 85 c0 test %eax,%eax 1186c9: 74 41 je 11870c ( the_priority <= RTEMS_MAXIMUM_PRIORITY ) ); 1186cb: 0f b6 15 d4 82 13 00 movzbl 0x1382d4,%edx */ RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid ( rtems_task_priority the_priority ) { return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) && 1186d2: 39 d0 cmp %edx,%eax 1186d4: 76 42 jbe 118718 * 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 ) 1186d6: 40 inc %eax 1186d7: 75 33 jne 11870c return RTEMS_INVALID_PRIORITY; _priority = 0; 1186d9: 31 f6 xor %esi,%esi 1186db: 8b 15 ec 08 14 00 mov 0x1408ec,%edx 1186e1: 42 inc %edx 1186e2: 89 15 ec 08 14 00 mov %edx,0x1408ec /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 1186e8: 8a 1d 20 c2 13 00 mov 0x13c220,%bl initialized = true; 1186ee: c6 05 20 c2 13 00 01 movb $0x1,0x13c220 _Thread_Enable_dispatch(); 1186f5: e8 1a 2c 00 00 call 11b314 <_Thread_Enable_dispatch> if ( tmpInitialized ) 1186fa: 84 db test %bl,%bl 1186fc: 74 1e je 11871c return RTEMS_INCORRECT_STATE; 1186fe: b8 0e 00 00 00 mov $0xe,%eax initialized = false; } #endif return status; } 118703: 8d 65 f8 lea -0x8(%ebp),%esp 118706: 5b pop %ebx 118707: 5e pop %esi 118708: c9 leave 118709: c3 ret 11870a: 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; 11870c: b8 13 00 00 00 mov $0x13,%eax initialized = false; } #endif return status; } 118711: 8d 65 f8 lea -0x8(%ebp),%esp 118714: 5b pop %ebx 118715: 5e pop %esi 118716: c9 leave 118717: c3 ret 118718: 89 c6 mov %eax,%esi 11871a: eb bf jmp 1186db * 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( 11871c: 83 ec 08 sub $0x8,%esp 11871f: 8d 45 f4 lea -0xc(%ebp),%eax 118722: 50 push %eax 118723: 8b 45 10 mov 0x10(%ebp),%eax 118726: 80 cc 80 or $0x80,%ah 118729: 50 push %eax 11872a: 68 00 01 00 00 push $0x100 11872f: ff 75 0c pushl 0xc(%ebp) 118732: 56 push %esi 118733: 68 45 4d 49 54 push $0x54494d45 118738: e8 e3 ec ff ff call 117420 /* 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) { 11873d: 83 c4 20 add $0x20,%esp 118740: 85 c0 test %eax,%eax 118742: 74 10 je 118754 initialized = false; 118744: c6 05 20 c2 13 00 00 movb $0x0,0x13c220 initialized = false; } #endif return status; } 11874b: 8d 65 f8 lea -0x8(%ebp),%esp 11874e: 5b pop %ebx 11874f: 5e pop %esi 118750: c9 leave 118751: c3 ret 118752: 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) 118754: 8b 45 f4 mov -0xc(%ebp),%eax */ #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return NULL; #endif return information->local_table[ index ]; 118757: 0f b7 c8 movzwl %ax,%ecx 11875a: 8b 15 9c 08 14 00 mov 0x14089c,%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( 118760: 8b 14 8a mov (%edx,%ecx,4),%edx 118763: 89 15 a0 c1 13 00 mov %edx,0x13c1a0 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 118769: c7 05 d0 c1 13 00 d4 movl $0x13c1d4,0x13c1d0 118770: c1 13 00 head->previous = NULL; 118773: c7 05 d4 c1 13 00 00 movl $0x0,0x13c1d4 11877a: 00 00 00 tail->previous = head; 11877d: c7 05 d8 c1 13 00 d0 movl $0x13c1d0,0x13c1d8 118784: c1 13 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 118787: c7 05 08 c2 13 00 0c movl $0x13c20c,0x13c208 11878e: c2 13 00 head->previous = NULL; 118791: c7 05 0c c2 13 00 00 movl $0x0,0x13c20c 118798: 00 00 00 tail->previous = head; 11879b: c7 05 10 c2 13 00 08 movl $0x13c208,0x13c210 1187a2: c2 13 00 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 1187a5: c7 05 b0 c1 13 00 00 movl $0x0,0x13c1b0 1187ac: 00 00 00 the_watchdog->routine = routine; 1187af: c7 05 c4 c1 13 00 60 movl $0x11b160,0x13c1c4 1187b6: b1 11 00 the_watchdog->id = id; 1187b9: a3 c8 c1 13 00 mov %eax,0x13c1c8 the_watchdog->user_data = user_data; 1187be: c7 05 cc c1 13 00 00 movl $0x0,0x13c1cc 1187c5: 00 00 00 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 1187c8: c7 05 e8 c1 13 00 00 movl $0x0,0x13c1e8 1187cf: 00 00 00 the_watchdog->routine = routine; 1187d2: c7 05 fc c1 13 00 60 movl $0x11b160,0x13c1fc 1187d9: b1 11 00 the_watchdog->id = id; 1187dc: a3 00 c2 13 00 mov %eax,0x13c200 the_watchdog->user_data = user_data; 1187e1: c7 05 04 c2 13 00 00 movl $0x0,0x13c204 1187e8: 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; 1187eb: c7 05 a4 c1 13 00 8c movl $0x11858c,0x13c1a4 1187f2: 85 11 00 ts->Interval_watchdogs.last_snapshot = _Watchdog_Ticks_since_boot; 1187f5: 8b 15 24 0a 14 00 mov 0x140a24,%edx 1187fb: 89 15 dc c1 13 00 mov %edx,0x13c1dc ts->TOD_watchdogs.last_snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 118801: 8b 15 88 09 14 00 mov 0x140988,%edx 118807: 89 15 14 c2 13 00 mov %edx,0x13c214 ts->insert_chain = NULL; 11880d: c7 05 18 c2 13 00 00 movl $0x0,0x13c218 118814: 00 00 00 ts->active = false; 118817: c6 05 1c c2 13 00 00 movb $0x0,0x13c21c /* * The default timer server is now available. */ _Timer_server = ts; 11881e: c7 05 80 0c 14 00 a0 movl $0x13c1a0,0x140c80 118825: c1 13 00 /* * Start the timer server */ status = rtems_task_start( 118828: 53 push %ebx 118829: 68 a0 c1 13 00 push $0x13c1a0 11882e: 68 e0 83 11 00 push $0x1183e0 118833: 50 push %eax 118834: e8 a7 f2 ff ff call 117ae0 if (status) { initialized = false; } #endif return status; 118839: 83 c4 10 add $0x10,%esp 11883c: e9 d0 fe ff ff jmp 118711 =============================================================================== 001180b8 : */ rtems_status_code rtems_timer_reset( rtems_id id ) { 1180b8: 55 push %ebp 1180b9: 89 e5 mov %esp,%ebp 1180bb: 56 push %esi 1180bc: 53 push %ebx 1180bd: 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 ); 1180c0: 8d 45 f4 lea -0xc(%ebp),%eax 1180c3: 50 push %eax 1180c4: ff 75 08 pushl 0x8(%ebp) 1180c7: 68 40 0c 14 00 push $0x140c40 1180cc: e8 f3 26 00 00 call 11a7c4 <_Objects_Get> 1180d1: 89 c3 mov %eax,%ebx switch ( location ) { 1180d3: 83 c4 10 add $0x10,%esp 1180d6: 8b 45 f4 mov -0xc(%ebp),%eax 1180d9: 85 c0 test %eax,%eax 1180db: 74 0f je 1180ec #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1180dd: b8 04 00 00 00 mov $0x4,%eax } 1180e2: 8d 65 f8 lea -0x8(%ebp),%esp 1180e5: 5b pop %ebx 1180e6: 5e pop %esi 1180e7: c9 leave 1180e8: c3 ret 1180e9: 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 ) { 1180ec: 8b 43 38 mov 0x38(%ebx),%eax 1180ef: 85 c0 test %eax,%eax 1180f1: 74 1d je 118110 _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); } else if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { 1180f3: 48 dec %eax 1180f4: 74 3a je 118130 /* * 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; 1180f6: b8 0b 00 00 00 mov $0xb,%eax } _Thread_Enable_dispatch(); 1180fb: 89 45 e4 mov %eax,-0x1c(%ebp) 1180fe: e8 11 32 00 00 call 11b314 <_Thread_Enable_dispatch> return status; 118103: 8b 45 e4 mov -0x1c(%ebp),%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 118106: 8d 65 f8 lea -0x8(%ebp),%esp 118109: 5b pop %ebx 11810a: 5e pop %esi 11810b: c9 leave 11810c: c3 ret 11810d: 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 ); 118110: 83 c3 10 add $0x10,%ebx 118113: 83 ec 0c sub $0xc,%esp 118116: 53 push %ebx 118117: e8 58 42 00 00 call 11c374 <_Watchdog_Remove> _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 11811c: 59 pop %ecx 11811d: 5e pop %esi 11811e: 53 push %ebx 11811f: 68 c0 09 14 00 push $0x1409c0 118124: e8 0b 41 00 00 call 11c234 <_Watchdog_Insert> 118129: 83 c4 10 add $0x10,%esp rtems_id id ) { Timer_Control *the_timer; Objects_Locations location; rtems_status_code status = RTEMS_SUCCESSFUL; 11812c: 31 c0 xor %eax,%eax 11812e: eb cb jmp 1180fb 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; 118130: 8b 35 80 0c 14 00 mov 0x140c80,%esi if ( !timer_server ) { _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } #endif _Watchdog_Remove( &the_timer->Ticker ); 118136: 83 ec 0c sub $0xc,%esp 118139: 8d 43 10 lea 0x10(%ebx),%eax 11813c: 50 push %eax 11813d: e8 32 42 00 00 call 11c374 <_Watchdog_Remove> (*timer_server->schedule_operation)( timer_server, the_timer ); 118142: 58 pop %eax 118143: 5a pop %edx 118144: 53 push %ebx 118145: 56 push %esi 118146: ff 56 04 call *0x4(%esi) 118149: 83 c4 10 add $0x10,%esp rtems_id id ) { Timer_Control *the_timer; Objects_Locations location; rtems_status_code status = RTEMS_SUCCESSFUL; 11814c: 31 c0 xor %eax,%eax 11814e: eb ab jmp 1180fb =============================================================================== 00118150 : rtems_id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 118150: 55 push %ebp 118151: 89 e5 mov %esp,%ebp 118153: 57 push %edi 118154: 56 push %esi 118155: 53 push %ebx 118156: 83 ec 2c sub $0x2c,%esp 118159: 8b 7d 0c mov 0xc(%ebp),%edi 11815c: 8b 75 10 mov 0x10(%ebp),%esi Timer_Control *the_timer; Objects_Locations location; ISR_Level level; Timer_server_Control *timer_server = _Timer_server; 11815f: 8b 1d 80 0c 14 00 mov 0x140c80,%ebx if ( !timer_server ) 118165: 85 db test %ebx,%ebx 118167: 0f 84 9f 00 00 00 je 11820c return RTEMS_INCORRECT_STATE; if ( !routine ) 11816d: 85 f6 test %esi,%esi 11816f: 0f 84 a3 00 00 00 je 118218 return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 118175: 85 ff test %edi,%edi 118177: 75 0f jne 118188 return RTEMS_INVALID_NUMBER; 118179: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11817e: 8d 65 f4 lea -0xc(%ebp),%esp 118181: 5b pop %ebx 118182: 5e pop %esi 118183: 5f pop %edi 118184: c9 leave 118185: c3 ret 118186: 66 90 xchg %ax,%ax 118188: 52 push %edx return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); 118189: 8d 45 e4 lea -0x1c(%ebp),%eax 11818c: 50 push %eax 11818d: ff 75 08 pushl 0x8(%ebp) 118190: 68 40 0c 14 00 push $0x140c40 118195: e8 2a 26 00 00 call 11a7c4 <_Objects_Get> 11819a: 89 c2 mov %eax,%edx switch ( location ) { 11819c: 83 c4 10 add $0x10,%esp 11819f: 8b 45 e4 mov -0x1c(%ebp),%eax 1181a2: 85 c0 test %eax,%eax 1181a4: 75 56 jne 1181fc case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 1181a6: 83 ec 0c sub $0xc,%esp 1181a9: 8d 42 10 lea 0x10(%edx),%eax 1181ac: 50 push %eax 1181ad: 89 55 d4 mov %edx,-0x2c(%ebp) 1181b0: e8 bf 41 00 00 call 11c374 <_Watchdog_Remove> _ISR_Disable( level ); 1181b5: 9c pushf 1181b6: fa cli 1181b7: 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 ) { 1181b8: 83 c4 10 add $0x10,%esp 1181bb: 8b 55 d4 mov -0x2c(%ebp),%edx 1181be: 8b 4a 18 mov 0x18(%edx),%ecx 1181c1: 85 c9 test %ecx,%ecx 1181c3: 75 5f jne 118224 /* * 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; 1181c5: 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; 1181cc: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) the_watchdog->routine = routine; 1181d3: 89 72 2c mov %esi,0x2c(%edx) the_watchdog->id = id; 1181d6: 8b 4d 08 mov 0x8(%ebp),%ecx 1181d9: 89 4a 30 mov %ecx,0x30(%edx) the_watchdog->user_data = user_data; 1181dc: 8b 4d 14 mov 0x14(%ebp),%ecx 1181df: 89 4a 34 mov %ecx,0x34(%edx) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = ticks; 1181e2: 89 7a 1c mov %edi,0x1c(%edx) _ISR_Enable( level ); 1181e5: 50 push %eax 1181e6: 9d popf (*timer_server->schedule_operation)( timer_server, the_timer ); 1181e7: 83 ec 08 sub $0x8,%esp 1181ea: 52 push %edx 1181eb: 53 push %ebx 1181ec: ff 53 04 call *0x4(%ebx) _Thread_Enable_dispatch(); 1181ef: e8 20 31 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1181f4: 83 c4 10 add $0x10,%esp 1181f7: 31 c0 xor %eax,%eax 1181f9: eb 83 jmp 11817e 1181fb: 90 nop #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1181fc: b8 04 00 00 00 mov $0x4,%eax } 118201: 8d 65 f4 lea -0xc(%ebp),%esp 118204: 5b pop %ebx 118205: 5e pop %esi 118206: 5f pop %edi 118207: c9 leave 118208: c3 ret 118209: 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; 11820c: b8 0e 00 00 00 mov $0xe,%eax 118211: e9 68 ff ff ff jmp 11817e 118216: 66 90 xchg %ax,%ax if ( !routine ) return RTEMS_INVALID_ADDRESS; 118218: b8 09 00 00 00 mov $0x9,%eax 11821d: e9 5c ff ff ff jmp 11817e 118222: 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 ); 118224: 50 push %eax 118225: 9d popf _Thread_Enable_dispatch(); 118226: e8 e9 30 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 11822b: 31 c0 xor %eax,%eax 11822d: e9 4c ff ff ff jmp 11817e =============================================================================== 00118234 : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 118234: 55 push %ebp 118235: 89 e5 mov %esp,%ebp 118237: 57 push %edi 118238: 56 push %esi 118239: 53 push %ebx 11823a: 83 ec 2c sub $0x2c,%esp 11823d: 8b 7d 0c mov 0xc(%ebp),%edi 118240: 8b 75 10 mov 0x10(%ebp),%esi Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 118243: 8b 1d 80 0c 14 00 mov 0x140c80,%ebx if ( !timer_server ) 118249: 85 db test %ebx,%ebx 11824b: 0f 84 d7 00 00 00 je 118328 return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 118251: 80 3d fc 08 14 00 00 cmpb $0x0,0x1408fc 118258: 0f 84 aa 00 00 00 je 118308 <== NEVER TAKEN return RTEMS_NOT_DEFINED; if ( !routine ) 11825e: 85 f6 test %esi,%esi 118260: 0f 84 b2 00 00 00 je 118318 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 118266: 83 ec 0c sub $0xc,%esp 118269: 57 push %edi 11826a: e8 95 d1 ff ff call 115404 <_TOD_Validate> 11826f: 83 c4 10 add $0x10,%esp 118272: 84 c0 test %al,%al 118274: 75 0e jne 118284 return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch() ) return RTEMS_INVALID_CLOCK; 118276: b8 14 00 00 00 mov $0x14,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11827b: 8d 65 f4 lea -0xc(%ebp),%esp 11827e: 5b pop %ebx 11827f: 5e pop %esi 118280: 5f pop %edi 118281: c9 leave 118282: c3 ret 118283: 90 nop return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 118284: 83 ec 0c sub $0xc,%esp 118287: 57 push %edi 118288: e8 eb d0 ff ff call 115378 <_TOD_To_seconds> 11828d: 89 c7 mov %eax,%edi if ( seconds <= _TOD_Seconds_since_epoch() ) 11828f: 83 c4 10 add $0x10,%esp 118292: 3b 05 88 09 14 00 cmp 0x140988,%eax 118298: 76 dc jbe 118276 11829a: 52 push %edx return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); 11829b: 8d 45 e4 lea -0x1c(%ebp),%eax 11829e: 50 push %eax 11829f: ff 75 08 pushl 0x8(%ebp) 1182a2: 68 40 0c 14 00 push $0x140c40 1182a7: e8 18 25 00 00 call 11a7c4 <_Objects_Get> 1182ac: 89 c2 mov %eax,%edx switch ( location ) { 1182ae: 83 c4 10 add $0x10,%esp 1182b1: 8b 45 e4 mov -0x1c(%ebp),%eax 1182b4: 85 c0 test %eax,%eax 1182b6: 75 7c jne 118334 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 1182b8: 83 ec 0c sub $0xc,%esp 1182bb: 8d 42 10 lea 0x10(%edx),%eax 1182be: 50 push %eax 1182bf: 89 55 d4 mov %edx,-0x2c(%ebp) 1182c2: e8 ad 40 00 00 call 11c374 <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 1182c7: 8b 55 d4 mov -0x2c(%ebp),%edx 1182ca: 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; 1182d1: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) the_watchdog->routine = routine; 1182d8: 89 72 2c mov %esi,0x2c(%edx) the_watchdog->id = id; 1182db: 8b 45 08 mov 0x8(%ebp),%eax 1182de: 89 42 30 mov %eax,0x30(%edx) the_watchdog->user_data = user_data; 1182e1: 8b 45 14 mov 0x14(%ebp),%eax 1182e4: 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(); 1182e7: 2b 3d 88 09 14 00 sub 0x140988,%edi 1182ed: 89 7a 1c mov %edi,0x1c(%edx) (*timer_server->schedule_operation)( timer_server, the_timer ); 1182f0: 58 pop %eax 1182f1: 59 pop %ecx 1182f2: 52 push %edx 1182f3: 53 push %ebx 1182f4: ff 53 04 call *0x4(%ebx) _Thread_Enable_dispatch(); 1182f7: e8 18 30 00 00 call 11b314 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1182fc: 83 c4 10 add $0x10,%esp 1182ff: 31 c0 xor %eax,%eax 118301: e9 75 ff ff ff jmp 11827b 118306: 66 90 xchg %ax,%ax if ( !timer_server ) return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; 118308: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11830d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 118310: 5b pop %ebx <== NOT EXECUTED 118311: 5e pop %esi <== NOT EXECUTED 118312: 5f pop %edi <== NOT EXECUTED 118313: c9 leave <== NOT EXECUTED 118314: c3 ret <== NOT EXECUTED 118315: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; 118318: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11831d: 8d 65 f4 lea -0xc(%ebp),%esp 118320: 5b pop %ebx 118321: 5e pop %esi 118322: 5f pop %edi 118323: c9 leave 118324: c3 ret 118325: 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; 118328: b8 0e 00 00 00 mov $0xe,%eax 11832d: e9 49 ff ff ff jmp 11827b 118332: 66 90 xchg %ax,%ax #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 118334: b8 04 00 00 00 mov $0x4,%eax 118339: e9 3d ff ff ff jmp 11827b =============================================================================== 0010bc70 : static int rtems_verror( rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) { 10bc70: 55 push %ebp 10bc71: 89 e5 mov %esp,%ebp 10bc73: 57 push %edi 10bc74: 56 push %esi 10bc75: 53 push %ebx 10bc76: 83 ec 1c sub $0x1c,%esp 10bc79: 89 c3 mov %eax,%ebx 10bc7b: 89 d6 mov %edx,%esi 10bc7d: 89 cf mov %ecx,%edi int local_errno = 0; int chars_written = 0; rtems_status_code status; if (error_flag & RTEMS_ERROR_PANIC) { 10bc7f: a9 00 00 00 20 test $0x20000000,%eax 10bc84: 74 2b je 10bcb1 if (rtems_panic_in_progress++) 10bc86: 8b 15 80 c4 12 00 mov 0x12c480,%edx 10bc8c: 8d 42 01 lea 0x1(%edx),%eax 10bc8f: a3 80 c4 12 00 mov %eax,0x12c480 10bc94: 85 d2 test %edx,%edx 10bc96: 74 10 je 10bca8 <== ALWAYS TAKEN rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10bc98: a1 ec c5 12 00 mov 0x12c5ec,%eax <== NOT EXECUTED 10bc9d: 40 inc %eax <== NOT EXECUTED 10bc9e: a3 ec c5 12 00 mov %eax,0x12c5ec <== NOT EXECUTED RTEMS_COMPILER_MEMORY_BARRIER(); 10bca3: a1 80 c4 12 00 mov 0x12c480,%eax <== NOT EXECUTED _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) 10bca8: 83 f8 02 cmp $0x2,%eax 10bcab: 0f 8f af 00 00 00 jg 10bd60 <== NEVER TAKEN return 0; } (void) fflush(stdout); /* in case stdout/stderr same */ 10bcb1: 83 ec 0c sub $0xc,%esp 10bcb4: a1 60 a2 12 00 mov 0x12a260,%eax 10bcb9: ff 70 08 pushl 0x8(%eax) 10bcbc: e8 fb b5 00 00 call 1172bc status = error_flag & ~RTEMS_ERROR_MASK; 10bcc1: 89 d8 mov %ebx,%eax 10bcc3: 25 ff ff ff 8f and $0x8fffffff,%eax 10bcc8: 89 45 e4 mov %eax,-0x1c(%ebp) if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 10bccb: 83 c4 10 add $0x10,%esp 10bcce: 81 e3 00 00 00 40 and $0x40000000,%ebx 10bcd4: 0f 85 be 00 00 00 jne 10bd98 rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) { int local_errno = 0; 10bcda: 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); 10bcdc: 50 push %eax 10bcdd: 57 push %edi 10bcde: 56 push %esi 10bcdf: a1 60 a2 12 00 mov 0x12a260,%eax 10bce4: ff 70 0c pushl 0xc(%eax) 10bce7: e8 88 1a 01 00 call 11d774 10bcec: 89 c6 mov %eax,%esi if (status) 10bcee: 83 c4 10 add $0x10,%esp 10bcf1: 8b 4d e4 mov -0x1c(%ebp),%ecx 10bcf4: 85 c9 test %ecx,%ecx 10bcf6: 75 74 jne 10bd6c chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); if (local_errno) { 10bcf8: 83 fb 00 cmp $0x0,%ebx 10bcfb: 74 30 je 10bd2d if ((local_errno > 0) && *strerror(local_errno)) 10bcfd: 7e 15 jle 10bd14 10bcff: 83 ec 0c sub $0xc,%esp 10bd02: 53 push %ebx 10bd03: e8 f4 c1 00 00 call 117efc 10bd08: 83 c4 10 add $0x10,%esp 10bd0b: 80 38 00 cmpb $0x0,(%eax) 10bd0e: 0f 85 90 00 00 00 jne 10bda4 <== ALWAYS TAKEN chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); else chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno); 10bd14: 52 push %edx 10bd15: 53 push %ebx 10bd16: 68 89 57 12 00 push $0x125789 10bd1b: a1 60 a2 12 00 mov 0x12a260,%eax 10bd20: ff 70 0c pushl 0xc(%eax) 10bd23: e8 88 b9 00 00 call 1176b0 10bd28: 01 c6 add %eax,%esi 10bd2a: 83 c4 10 add $0x10,%esp } chars_written += fprintf(stderr, "\n"); 10bd2d: 83 ec 08 sub $0x8,%esp 10bd30: 68 cd 52 12 00 push $0x1252cd 10bd35: a1 60 a2 12 00 mov 0x12a260,%eax 10bd3a: ff 70 0c pushl 0xc(%eax) 10bd3d: e8 6e b9 00 00 call 1176b0 10bd42: 8d 34 30 lea (%eax,%esi,1),%esi (void) fflush(stderr); 10bd45: 58 pop %eax 10bd46: a1 60 a2 12 00 mov 0x12a260,%eax 10bd4b: ff 70 0c pushl 0xc(%eax) 10bd4e: e8 69 b5 00 00 call 1172bc return chars_written; 10bd53: 83 c4 10 add $0x10,%esp } 10bd56: 89 f0 mov %esi,%eax 10bd58: 8d 65 f4 lea -0xc(%ebp),%esp 10bd5b: 5b pop %ebx 10bd5c: 5e pop %esi 10bd5d: 5f pop %edi 10bd5e: c9 leave 10bd5f: 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; 10bd60: 31 f6 xor %esi,%esi chars_written += fprintf(stderr, "\n"); (void) fflush(stderr); return chars_written; } 10bd62: 89 f0 mov %esi,%eax <== NOT EXECUTED 10bd64: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bd67: 5b pop %ebx <== NOT EXECUTED 10bd68: 5e pop %esi <== NOT EXECUTED 10bd69: 5f pop %edi <== NOT EXECUTED 10bd6a: c9 leave <== NOT EXECUTED 10bd6b: c3 ret <== NOT EXECUTED chars_written += vfprintf(stderr, printf_format, arglist); if (status) chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); 10bd6c: 83 ec 0c sub $0xc,%esp 10bd6f: ff 75 e4 pushl -0x1c(%ebp) 10bd72: e8 e1 fe ff ff call 10bc58 10bd77: 83 c4 0c add $0xc,%esp 10bd7a: 50 push %eax 10bd7b: 68 6e 57 12 00 push $0x12576e 10bd80: a1 60 a2 12 00 mov 0x12a260,%eax 10bd85: ff 70 0c pushl 0xc(%eax) 10bd88: e8 23 b9 00 00 call 1176b0 #endif chars_written += vfprintf(stderr, printf_format, arglist); if (status) chars_written += 10bd8d: 01 c6 add %eax,%esi 10bd8f: 83 c4 10 add $0x10,%esp 10bd92: e9 61 ff ff ff jmp 10bcf8 10bd97: 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; 10bd98: e8 87 b1 00 00 call 116f24 <__errno> 10bd9d: 8b 18 mov (%eax),%ebx 10bd9f: e9 38 ff ff ff jmp 10bcdc 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)); 10bda4: 83 ec 0c sub $0xc,%esp 10bda7: 53 push %ebx 10bda8: e8 4f c1 00 00 call 117efc 10bdad: 83 c4 0c add $0xc,%esp 10bdb0: 50 push %eax 10bdb1: 68 7c 57 12 00 push $0x12577c 10bdb6: e9 60 ff ff ff jmp 10bd1b =============================================================================== 00107c34 : /* * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) { 107c34: 55 push %ebp 107c35: 89 e5 mov %esp,%ebp 107c37: 57 push %edi 107c38: 56 push %esi 107c39: 53 push %ebx 107c3a: 83 ec 1c sub $0x1c,%esp 107c3d: 89 c6 mov %eax,%esi 107c3f: 89 55 e0 mov %edx,-0x20(%ebp) int c; unsigned int i = 0; unsigned int limit = INT_MAX; int sign = 0; 107c42: 31 ff xor %edi,%edi static int scanInt(FILE *fp, int *val) { int c; unsigned int i = 0; unsigned int limit = INT_MAX; 107c44: c7 45 e4 ff ff ff 7f movl $0x7fffffff,-0x1c(%ebp) */ static int scanInt(FILE *fp, int *val) { int c; unsigned int i = 0; 107c4b: 31 db xor %ebx,%ebx unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 107c4d: 8b 46 04 mov 0x4(%esi),%eax 107c50: 48 dec %eax 107c51: 89 46 04 mov %eax,0x4(%esi) 107c54: 85 c0 test %eax,%eax 107c56: 78 52 js 107caa <== NEVER TAKEN 107c58: 8b 06 mov (%esi),%eax 107c5a: 0f b6 08 movzbl (%eax),%ecx 107c5d: 40 inc %eax 107c5e: 89 06 mov %eax,(%esi) if (c == ':') 107c60: 83 f9 3a cmp $0x3a,%ecx 107c63: 74 5f je 107cc4 break; if (sign == 0) { 107c65: 85 ff test %edi,%edi 107c67: 75 0e jne 107c77 if (c == '-') { 107c69: 83 f9 2d cmp $0x2d,%ecx 107c6c: 0f 84 8a 00 00 00 je 107cfc sign = -1; limit++; continue; } sign = 1; 107c72: bf 01 00 00 00 mov $0x1,%edi } if (!isdigit(c)) 107c77: a1 b4 51 12 00 mov 0x1251b4,%eax 107c7c: f6 44 08 01 04 testb $0x4,0x1(%eax,%ecx,1) 107c81: 74 6d je 107cf0 return 0; d = c - '0'; if ((i > (limit / 10)) 107c83: b8 cd cc cc cc mov $0xcccccccd,%eax 107c88: f7 65 e4 mull -0x1c(%ebp) 107c8b: c1 ea 03 shr $0x3,%edx 107c8e: 39 d3 cmp %edx,%ebx 107c90: 77 5e ja 107cf0 } sign = 1; } if (!isdigit(c)) return 0; d = c - '0'; 107c92: 83 e9 30 sub $0x30,%ecx if ((i > (limit / 10)) || ((i == (limit / 10)) && (d > (limit % 10)))) 107c95: 39 d3 cmp %edx,%ebx 107c97: 74 47 je 107ce0 return 0; i = i * 10 + d; 107c99: 8d 04 9b lea (%ebx,%ebx,4),%eax 107c9c: 8d 1c 41 lea (%ecx,%eax,2),%ebx unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 107c9f: 8b 46 04 mov 0x4(%esi),%eax 107ca2: 48 dec %eax 107ca3: 89 46 04 mov %eax,0x4(%esi) 107ca6: 85 c0 test %eax,%eax 107ca8: 79 ae jns 107c58 <== ALWAYS TAKEN 107caa: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107cad: 56 push %esi <== NOT EXECUTED 107cae: ff 35 c0 51 12 00 pushl 0x1251c0 <== NOT EXECUTED 107cb4: e8 0f c3 00 00 call 113fc8 <__srget_r> <== NOT EXECUTED 107cb9: 89 c1 mov %eax,%ecx <== NOT EXECUTED 107cbb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (c == ':') 107cbe: 83 f9 3a cmp $0x3a,%ecx <== NOT EXECUTED 107cc1: 75 a2 jne 107c65 <== NOT EXECUTED 107cc3: 90 nop <== NOT EXECUTED if ((i > (limit / 10)) || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; i = i * 10 + d; } if (sign == 0) 107cc4: 85 ff test %edi,%edi 107cc6: 74 28 je 107cf0 <== NEVER TAKEN return 0; *val = i * sign; 107cc8: 0f af df imul %edi,%ebx 107ccb: 8b 45 e0 mov -0x20(%ebp),%eax 107cce: 89 18 mov %ebx,(%eax) return 1; 107cd0: b8 01 00 00 00 mov $0x1,%eax } 107cd5: 8d 65 f4 lea -0xc(%ebp),%esp 107cd8: 5b pop %ebx 107cd9: 5e pop %esi 107cda: 5f pop %edi 107cdb: c9 leave 107cdc: c3 ret 107cdd: 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)))) 107ce0: 8d 04 9b lea (%ebx,%ebx,4),%eax 107ce3: d1 e0 shl %eax 107ce5: 8b 55 e4 mov -0x1c(%ebp),%edx 107ce8: 29 c2 sub %eax,%edx 107cea: 39 d1 cmp %edx,%ecx 107cec: 76 ab jbe 107c99 <== NEVER TAKEN 107cee: 66 90 xchg %ax,%ax return 0; i = i * 10 + d; } if (sign == 0) return 0; 107cf0: 31 c0 xor %eax,%eax *val = i * sign; return 1; } 107cf2: 8d 65 f4 lea -0xc(%ebp),%esp 107cf5: 5b pop %ebx 107cf6: 5e pop %esi 107cf7: 5f pop %edi 107cf8: c9 leave 107cf9: c3 ret 107cfa: 66 90 xchg %ax,%ax if (c == ':') break; if (sign == 0) { if (c == '-') { sign = -1; limit++; 107cfc: ff 45 e4 incl -0x1c(%ebp) c = getc(fp); if (c == ':') break; if (sign == 0) { if (c == '-') { sign = -1; 107cff: bf ff ff ff ff mov $0xffffffff,%edi limit++; continue; 107d04: e9 44 ff ff ff jmp 107c4d =============================================================================== 00107d0c : /* * Extract a string value from the database */ static int scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag) { 107d0c: 55 push %ebp 107d0d: 89 e5 mov %esp,%ebp 107d0f: 57 push %edi 107d10: 56 push %esi 107d11: 53 push %ebx 107d12: 83 ec 0c sub $0xc,%esp 107d15: 89 c3 mov %eax,%ebx 107d17: 89 ce mov %ecx,%esi 107d19: 8b 7d 08 mov 0x8(%ebp),%edi int c; *name = *bufp; 107d1c: 8b 01 mov (%ecx),%eax 107d1e: 89 02 mov %eax,(%edx) 107d20: eb 26 jmp 107d48 107d22: 66 90 xchg %ax,%ax for (;;) { c = getc(fp); 107d24: 8b 13 mov (%ebx),%edx 107d26: 0f b6 02 movzbl (%edx),%eax 107d29: 42 inc %edx 107d2a: 89 13 mov %edx,(%ebx) if (c == ':') { 107d2c: 83 f8 3a cmp $0x3a,%eax 107d2f: 74 3b je 107d6c if (nlFlag) return 0; break; } if (c == '\n') { 107d31: 83 f8 0a cmp $0xa,%eax 107d34: 74 56 je 107d8c if (!nlFlag) return 0; break; } if (c == EOF) 107d36: 83 f8 ff cmp $0xffffffff,%eax 107d39: 74 59 je 107d94 return 0; if (*nleft < 2) 107d3b: 83 3f 01 cmpl $0x1,(%edi) 107d3e: 76 54 jbe 107d94 return 0; **bufp = c; 107d40: 8b 16 mov (%esi),%edx 107d42: 88 02 mov %al,(%edx) ++(*bufp); 107d44: ff 06 incl (%esi) --(*nleft); 107d46: ff 0f decl (%edi) { int c; *name = *bufp; for (;;) { c = getc(fp); 107d48: 8b 43 04 mov 0x4(%ebx),%eax 107d4b: 48 dec %eax 107d4c: 89 43 04 mov %eax,0x4(%ebx) 107d4f: 85 c0 test %eax,%eax 107d51: 79 d1 jns 107d24 107d53: 83 ec 08 sub $0x8,%esp 107d56: 53 push %ebx 107d57: ff 35 c0 51 12 00 pushl 0x1251c0 107d5d: e8 66 c2 00 00 call 113fc8 <__srget_r> 107d62: 83 c4 10 add $0x10,%esp if (c == ':') { 107d65: 83 f8 3a cmp $0x3a,%eax 107d68: 75 c7 jne 107d31 <== ALWAYS TAKEN 107d6a: 66 90 xchg %ax,%ax if (nlFlag) 107d6c: 8b 55 0c mov 0xc(%ebp),%edx 107d6f: 85 d2 test %edx,%edx 107d71: 75 21 jne 107d94 return 0; **bufp = c; ++(*bufp); --(*nleft); } **bufp = '\0'; 107d73: 8b 06 mov (%esi),%eax 107d75: c6 00 00 movb $0x0,(%eax) ++(*bufp); 107d78: ff 06 incl (%esi) --(*nleft); 107d7a: ff 0f decl (%edi) return 1; 107d7c: b8 01 00 00 00 mov $0x1,%eax } 107d81: 8d 65 f4 lea -0xc(%ebp),%esp 107d84: 5b pop %ebx 107d85: 5e pop %esi 107d86: 5f pop %edi 107d87: c9 leave 107d88: c3 ret 107d89: 8d 76 00 lea 0x0(%esi),%esi if (nlFlag) return 0; break; } if (c == '\n') { if (!nlFlag) 107d8c: 8b 45 0c mov 0xc(%ebp),%eax 107d8f: 85 c0 test %eax,%eax 107d91: 75 e0 jne 107d73 107d93: 90 nop break; } if (c == EOF) return 0; if (*nleft < 2) return 0; 107d94: 31 c0 xor %eax,%eax } **bufp = '\0'; ++(*bufp); --(*nleft); return 1; } 107d96: 8d 65 f4 lea -0xc(%ebp),%esp 107d99: 5b pop %ebx 107d9a: 5e pop %esi 107d9b: 5f pop %edi 107d9c: c9 leave 107d9d: c3 ret =============================================================================== 00107da0 : FILE *fp, struct group *grp, char *buffer, size_t bufsize ) { 107da0: 55 push %ebp 107da1: 89 e5 mov %esp,%ebp 107da3: 57 push %edi 107da4: 56 push %esi 107da5: 53 push %ebx 107da6: 83 ec 34 sub $0x34,%esp 107da9: 89 c6 mov %eax,%esi 107dab: 89 d3 mov %edx,%ebx 107dad: 89 4d d4 mov %ecx,-0x2c(%ebp) int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 107db0: 8d 7d d4 lea -0x2c(%ebp),%edi 107db3: 6a 00 push $0x0 107db5: 8d 45 08 lea 0x8(%ebp),%eax 107db8: 50 push %eax 107db9: 89 f9 mov %edi,%ecx 107dbb: 89 f0 mov %esi,%eax 107dbd: e8 4a ff ff ff call 107d0c 107dc2: 83 c4 10 add $0x10,%esp 107dc5: 85 c0 test %eax,%eax 107dc7: 75 0b jne 107dd4 /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) return 0; 107dc9: 31 c0 xor %eax,%eax grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; return 1; } 107dcb: 8d 65 f4 lea -0xc(%ebp),%esp 107dce: 5b pop %ebx 107dcf: 5e pop %esi 107dd0: 5f pop %edi 107dd1: c9 leave 107dd2: c3 ret 107dd3: 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) 107dd4: 83 ec 08 sub $0x8,%esp 107dd7: 8d 53 04 lea 0x4(%ebx),%edx 107dda: 6a 00 push $0x0 107ddc: 8d 45 08 lea 0x8(%ebp),%eax 107ddf: 50 push %eax 107de0: 89 f9 mov %edi,%ecx 107de2: 89 f0 mov %esi,%eax 107de4: e8 23 ff ff ff call 107d0c 107de9: 83 c4 10 add $0x10,%esp 107dec: 85 c0 test %eax,%eax 107dee: 74 d9 je 107dc9 <== NEVER TAKEN || !scanInt(fp, &grgid) 107df0: 8d 55 e4 lea -0x1c(%ebp),%edx 107df3: 89 f0 mov %esi,%eax 107df5: e8 3a fe ff ff call 107c34 107dfa: 85 c0 test %eax,%eax 107dfc: 74 cb je 107dc9 <== NEVER TAKEN || !scanString(fp, &grmem, &buffer, &bufsize, 1)) 107dfe: 83 ec 08 sub $0x8,%esp 107e01: 8d 55 e0 lea -0x20(%ebp),%edx 107e04: 6a 01 push $0x1 107e06: 8d 45 08 lea 0x8(%ebp),%eax 107e09: 50 push %eax 107e0a: 89 f9 mov %edi,%ecx 107e0c: 89 f0 mov %esi,%eax 107e0e: e8 f9 fe ff ff call 107d0c 107e13: 83 c4 10 add $0x10,%esp 107e16: 85 c0 test %eax,%eax 107e18: 74 af je 107dc9 <== NEVER TAKEN return 0; grp->gr_gid = grgid; 107e1a: 8b 45 e4 mov -0x1c(%ebp),%eax 107e1d: 66 89 43 08 mov %ax,0x8(%ebx) /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 107e21: 8b 7d e0 mov -0x20(%ebp),%edi 107e24: 8a 07 mov (%edi),%al 107e26: 84 c0 test %al,%al 107e28: 74 7d je 107ea7 <== NEVER TAKEN 107e2a: 89 fa mov %edi,%edx 107e2c: b9 01 00 00 00 mov $0x1,%ecx 107e31: eb 08 jmp 107e3b 107e33: 90 nop 107e34: 42 inc %edx 107e35: 8a 02 mov (%edx),%al 107e37: 84 c0 test %al,%al 107e39: 74 09 je 107e44 if(*cp == ',') 107e3b: 3c 2c cmp $0x2c,%al 107e3d: 75 f5 jne 107e34 memcount++; 107e3f: 41 inc %ecx 107e40: eb f2 jmp 107e34 107e42: 66 90 xchg %ax,%ax grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 107e44: 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)) 107e4b: 39 45 08 cmp %eax,0x8(%ebp) 107e4e: 0f 82 75 ff ff ff jb 107dc9 <== NEVER TAKEN return 0; grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15); 107e54: 8b 75 d4 mov -0x2c(%ebp),%esi 107e57: 83 c6 0f add $0xf,%esi 107e5a: 83 e6 f0 and $0xfffffff0,%esi 107e5d: 89 73 0c mov %esi,0xc(%ebx) /* * Fill in pointer array */ grp->gr_mem[0] = grmem; 107e60: 89 3e mov %edi,(%esi) for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 107e62: 8b 45 e0 mov -0x20(%ebp),%eax 107e65: 8a 10 mov (%eax),%dl 107e67: 84 d2 test %dl,%dl 107e69: 74 43 je 107eae <== NEVER TAKEN } /* * Extract a single group record from the database */ static int scangr( 107e6b: 40 inc %eax /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 107e6c: b9 01 00 00 00 mov $0x1,%ecx 107e71: eb 08 jmp 107e7b 107e73: 90 nop 107e74: 8a 10 mov (%eax),%dl 107e76: 40 inc %eax 107e77: 84 d2 test %dl,%dl 107e79: 74 15 je 107e90 if(*cp == ',') { 107e7b: 80 fa 2c cmp $0x2c,%dl 107e7e: 75 f4 jne 107e74 *cp = '\0'; 107e80: c6 40 ff 00 movb $0x0,-0x1(%eax) grp->gr_mem[memcount++] = cp + 1; 107e84: 8b 53 0c mov 0xc(%ebx),%edx 107e87: 89 04 8a mov %eax,(%edx,%ecx,4) 107e8a: 41 inc %ecx 107e8b: eb e7 jmp 107e74 107e8d: 8d 76 00 lea 0x0(%esi),%esi /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 107e90: 8b 73 0c mov 0xc(%ebx),%esi 107e93: c1 e1 02 shl $0x2,%ecx if(*cp == ',') { *cp = '\0'; grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; 107e96: c7 04 0e 00 00 00 00 movl $0x0,(%esi,%ecx,1) return 1; 107e9d: b8 01 00 00 00 mov $0x1,%eax 107ea2: e9 24 ff ff ff jmp 107dcb grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 107ea7: b8 17 00 00 00 mov $0x17,%eax <== NOT EXECUTED 107eac: eb 9d jmp 107e4b <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 107eae: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 107eb3: eb e1 jmp 107e96 <== NOT EXECUTED =============================================================================== 00107eb8 : FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) { 107eb8: 55 push %ebp 107eb9: 89 e5 mov %esp,%ebp 107ebb: 57 push %edi 107ebc: 56 push %esi 107ebd: 53 push %ebx 107ebe: 83 ec 34 sub $0x34,%esp 107ec1: 89 c6 mov %eax,%esi 107ec3: 89 d3 mov %edx,%ebx 107ec5: 89 4d d4 mov %ecx,-0x2c(%ebp) int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 107ec8: 8d 7d d4 lea -0x2c(%ebp),%edi 107ecb: 6a 00 push $0x0 107ecd: 8d 45 08 lea 0x8(%ebp),%eax 107ed0: 50 push %eax 107ed1: 89 f9 mov %edi,%ecx 107ed3: 89 f0 mov %esi,%eax 107ed5: e8 32 fe ff ff call 107d0c 107eda: 83 c4 10 add $0x10,%esp 107edd: 85 c0 test %eax,%eax 107edf: 75 0b jne 107eec || !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; 107ee1: 31 c0 xor %eax,%eax pwd->pw_uid = pwuid; pwd->pw_gid = pwgid; return 1; } 107ee3: 8d 65 f4 lea -0xc(%ebp),%esp 107ee6: 5b pop %ebx 107ee7: 5e pop %esi 107ee8: 5f pop %edi 107ee9: c9 leave 107eea: c3 ret 107eeb: 90 nop ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) 107eec: 83 ec 08 sub $0x8,%esp 107eef: 8d 53 04 lea 0x4(%ebx),%edx 107ef2: 6a 00 push $0x0 107ef4: 8d 45 08 lea 0x8(%ebp),%eax 107ef7: 50 push %eax 107ef8: 89 f9 mov %edi,%ecx 107efa: 89 f0 mov %esi,%eax 107efc: e8 0b fe ff ff call 107d0c 107f01: 83 c4 10 add $0x10,%esp 107f04: 85 c0 test %eax,%eax 107f06: 74 d9 je 107ee1 <== NEVER TAKEN || !scanInt(fp, &pwuid) 107f08: 8d 55 e4 lea -0x1c(%ebp),%edx 107f0b: 89 f0 mov %esi,%eax 107f0d: e8 22 fd ff ff call 107c34 107f12: 85 c0 test %eax,%eax 107f14: 74 cb je 107ee1 || !scanInt(fp, &pwgid) 107f16: 8d 55 e0 lea -0x20(%ebp),%edx 107f19: 89 f0 mov %esi,%eax 107f1b: e8 14 fd ff ff call 107c34 107f20: 85 c0 test %eax,%eax 107f22: 74 bd je 107ee1 || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) 107f24: 83 ec 08 sub $0x8,%esp 107f27: 8d 53 0c lea 0xc(%ebx),%edx 107f2a: 6a 00 push $0x0 107f2c: 8d 45 08 lea 0x8(%ebp),%eax 107f2f: 50 push %eax 107f30: 89 f9 mov %edi,%ecx 107f32: 89 f0 mov %esi,%eax 107f34: e8 d3 fd ff ff call 107d0c 107f39: 83 c4 10 add $0x10,%esp 107f3c: 85 c0 test %eax,%eax 107f3e: 74 a1 je 107ee1 <== NEVER TAKEN || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0) 107f40: 83 ec 08 sub $0x8,%esp 107f43: 8d 53 10 lea 0x10(%ebx),%edx 107f46: 6a 00 push $0x0 107f48: 8d 45 08 lea 0x8(%ebp),%eax 107f4b: 50 push %eax 107f4c: 89 f9 mov %edi,%ecx 107f4e: 89 f0 mov %esi,%eax 107f50: e8 b7 fd ff ff call 107d0c 107f55: 83 c4 10 add $0x10,%esp 107f58: 85 c0 test %eax,%eax 107f5a: 74 85 je 107ee1 <== NEVER TAKEN || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0) 107f5c: 83 ec 08 sub $0x8,%esp 107f5f: 8d 53 14 lea 0x14(%ebx),%edx 107f62: 6a 00 push $0x0 107f64: 8d 45 08 lea 0x8(%ebp),%eax 107f67: 50 push %eax 107f68: 89 f9 mov %edi,%ecx 107f6a: 89 f0 mov %esi,%eax 107f6c: e8 9b fd ff ff call 107d0c 107f71: 83 c4 10 add $0x10,%esp 107f74: 85 c0 test %eax,%eax 107f76: 0f 84 65 ff ff ff je 107ee1 <== NEVER TAKEN || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1)) 107f7c: 83 ec 08 sub $0x8,%esp 107f7f: 8d 53 18 lea 0x18(%ebx),%edx 107f82: 6a 01 push $0x1 107f84: 8d 45 08 lea 0x8(%ebp),%eax 107f87: 50 push %eax 107f88: 89 f9 mov %edi,%ecx 107f8a: 89 f0 mov %esi,%eax 107f8c: e8 7b fd ff ff call 107d0c 107f91: 83 c4 10 add $0x10,%esp 107f94: 85 c0 test %eax,%eax 107f96: 0f 84 45 ff ff ff je 107ee1 return 0; pwd->pw_uid = pwuid; 107f9c: 8b 45 e4 mov -0x1c(%ebp),%eax 107f9f: 66 89 43 08 mov %ax,0x8(%ebx) pwd->pw_gid = pwgid; 107fa3: 8b 45 e0 mov -0x20(%ebp),%eax 107fa6: 66 89 43 0a mov %ax,0xa(%ebx) return 1; 107faa: b8 01 00 00 00 mov $0x1,%eax 107faf: e9 2f ff ff ff jmp 107ee3 =============================================================================== 00109660 : /* * Process input character, with semaphore. */ static int siproc (unsigned char c, struct rtems_termios_tty *tty) { 109660: 55 push %ebp 109661: 89 e5 mov %esp,%ebp 109663: 56 push %esi 109664: 53 push %ebx 109665: 89 d3 mov %edx,%ebx 109667: 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)) { 109669: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx) 109670: 75 12 jne 109684 <== 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); 109672: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 109675: 89 da mov %ebx,%edx <== NOT EXECUTED } return i; } 109677: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10967a: 5b pop %ebx <== NOT EXECUTED 10967b: 5e pop %esi <== NOT EXECUTED 10967c: 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); 10967d: e9 92 fe ff ff jmp 109514 <== NOT EXECUTED 109682: 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); 109684: 52 push %edx 109685: 6a 00 push $0x0 109687: 6a 00 push $0x0 109689: ff 73 18 pushl 0x18(%ebx) 10968c: e8 17 15 00 00 call 10aba8 i = iproc (c, tty); 109691: 89 f2 mov %esi,%edx 109693: 0f b6 c2 movzbl %dl,%eax 109696: 89 da mov %ebx,%edx 109698: e8 77 fe ff ff call 109514 10969d: 89 c6 mov %eax,%esi rtems_semaphore_release (tty->osem); 10969f: 58 pop %eax 1096a0: ff 73 18 pushl 0x18(%ebx) 1096a3: e8 fc 15 00 00 call 10aca4 1096a8: 83 c4 10 add $0x10,%esp } else { i = iproc (c, tty); } return i; } 1096ab: 89 f0 mov %esi,%eax 1096ad: 8d 65 f8 lea -0x8(%ebp),%esp 1096b0: 5b pop %ebx 1096b1: 5e pop %esi 1096b2: c9 leave 1096b3: c3 ret =============================================================================== 00108464 : int _STAT_NAME( const char *path, struct stat *buf ) { 108464: 55 push %ebp 108465: 89 e5 mov %esp,%ebp 108467: 57 push %edi 108468: 56 push %esi 108469: 53 push %ebx 10846a: 83 ec 3c sub $0x3c,%esp 10846d: 8b 55 08 mov 0x8(%ebp),%edx 108470: 8b 75 0c mov 0xc(%ebp),%esi /* * Check to see if we were passed a valid pointer. */ if ( !buf ) 108473: 85 f6 test %esi,%esi 108475: 74 65 je 1084dc rtems_set_errno_and_return_minus_one( EFAULT ); status = rtems_filesystem_evaluate_path( path, strlen( path ), 108477: b9 ff ff ff ff mov $0xffffffff,%ecx 10847c: 89 d7 mov %edx,%edi 10847e: 31 c0 xor %eax,%eax 108480: f2 ae repnz scas %es:(%edi),%al 108482: f7 d1 not %ecx 108484: 49 dec %ecx 108485: 83 ec 0c sub $0xc,%esp 108488: 6a 01 push $0x1 10848a: 8d 5d d4 lea -0x2c(%ebp),%ebx 10848d: 53 push %ebx 10848e: 6a 00 push $0x0 108490: 51 push %ecx 108491: 52 push %edx 108492: e8 1d f1 ff ff call 1075b4 0, &loc, _STAT_FOLLOW_LINKS ); if ( status != 0 ) 108497: 83 c4 20 add $0x20,%esp 10849a: 85 c0 test %eax,%eax 10849c: 74 0e je 1084ac return -1; 10849e: b8 ff ff ff ff mov $0xffffffff,%eax status = (*loc.handlers->fstat_h)( &loc, buf ); rtems_filesystem_freenode( &loc ); return status; } 1084a3: 8d 65 f4 lea -0xc(%ebp),%esp 1084a6: 5b pop %ebx 1084a7: 5e pop %esi 1084a8: 5f pop %edi 1084a9: c9 leave 1084aa: c3 ret 1084ab: 90 nop /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( buf, 0, sizeof(struct stat) ); 1084ac: b9 48 00 00 00 mov $0x48,%ecx 1084b1: 89 f7 mov %esi,%edi 1084b3: f3 aa rep stos %al,%es:(%edi) status = (*loc.handlers->fstat_h)( &loc, buf ); 1084b5: 83 ec 08 sub $0x8,%esp 1084b8: 56 push %esi 1084b9: 53 push %ebx 1084ba: 8b 45 dc mov -0x24(%ebp),%eax 1084bd: ff 50 18 call *0x18(%eax) rtems_filesystem_freenode( &loc ); 1084c0: 89 1c 24 mov %ebx,(%esp) 1084c3: 89 45 c4 mov %eax,-0x3c(%ebp) 1084c6: e8 c1 f1 ff ff call 10768c return status; 1084cb: 83 c4 10 add $0x10,%esp 1084ce: 8b 45 c4 mov -0x3c(%ebp),%eax } 1084d1: 8d 65 f4 lea -0xc(%ebp),%esp 1084d4: 5b pop %ebx 1084d5: 5e pop %esi 1084d6: 5f pop %edi 1084d7: c9 leave 1084d8: c3 ret 1084d9: 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 ); 1084dc: e8 5b 7d 00 00 call 11023c <__errno> 1084e1: c7 00 0e 00 00 00 movl $0xe,(%eax) 1084e7: b8 ff ff ff ff mov $0xffffffff,%eax status = (*loc.handlers->fstat_h)( &loc, buf ); rtems_filesystem_freenode( &loc ); return status; } 1084ec: 8d 65 f4 lea -0xc(%ebp),%esp 1084ef: 5b pop %ebx 1084f0: 5e pop %esi 1084f1: 5f pop %edi 1084f2: c9 leave 1084f3: c3 ret =============================================================================== 0010a8d4 : #include int statvfs (const char *path, struct statvfs *sb) { 10a8d4: 55 push %ebp 10a8d5: 89 e5 mov %esp,%ebp 10a8d7: 57 push %edi 10a8d8: 56 push %esi 10a8d9: 53 push %ebx 10a8da: 83 ec 48 sub $0x48,%esp 10a8dd: 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 ) ) 10a8e0: 31 f6 xor %esi,%esi 10a8e2: b9 ff ff ff ff mov $0xffffffff,%ecx 10a8e7: 89 d7 mov %edx,%edi 10a8e9: 89 f0 mov %esi,%eax 10a8eb: f2 ae repnz scas %es:(%edi),%al 10a8ed: f7 d1 not %ecx 10a8ef: 49 dec %ecx 10a8f0: 6a 01 push $0x1 10a8f2: 8d 5d d4 lea -0x2c(%ebp),%ebx 10a8f5: 53 push %ebx 10a8f6: 6a 00 push $0x0 10a8f8: 51 push %ecx 10a8f9: 52 push %edx 10a8fa: e8 85 eb ff ff call 109484 10a8ff: 83 c4 20 add $0x20,%esp 10a902: 85 c0 test %eax,%eax 10a904: 74 0e je 10a914 <== ALWAYS TAKEN return -1; 10a906: 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; } 10a90b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a90e: 5b pop %ebx <== NOT EXECUTED 10a90f: 5e pop %esi <== NOT EXECUTED 10a910: 5f pop %edi <== NOT EXECUTED 10a911: c9 leave <== NOT EXECUTED 10a912: c3 ret <== NOT EXECUTED 10a913: 90 nop <== NOT EXECUTED */ if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) ) return -1; mt_entry = loc.mt_entry; 10a914: 8b 55 e4 mov -0x1c(%ebp),%edx fs_mount_root = &mt_entry->mt_fs_root; memset (sb, 0, sizeof (struct statvfs)); 10a917: b9 38 00 00 00 mov $0x38,%ecx 10a91c: 8b 7d 0c mov 0xc(%ebp),%edi 10a91f: 89 f0 mov %esi,%eax 10a921: f3 aa rep stos %al,%es:(%edi) result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb ); 10a923: 83 ec 08 sub $0x8,%esp 10a926: 8b 42 28 mov 0x28(%edx),%eax 10a929: 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; 10a92c: 83 c2 1c add $0x1c,%edx memset (sb, 0, sizeof (struct statvfs)); result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb ); 10a92f: 52 push %edx 10a930: ff 50 44 call *0x44(%eax) rtems_filesystem_freenode( &loc ); 10a933: 89 1c 24 mov %ebx,(%esp) 10a936: 89 45 c4 mov %eax,-0x3c(%ebp) 10a939: e8 1e ec ff ff call 10955c return result; 10a93e: 83 c4 10 add $0x10,%esp 10a941: 8b 45 c4 mov -0x3c(%ebp),%eax } 10a944: 8d 65 f4 lea -0xc(%ebp),%esp 10a947: 5b pop %ebx 10a948: 5e pop %esi 10a949: 5f pop %edi 10a94a: c9 leave 10a94b: c3 ret =============================================================================== 0010a18c : int symlink( const char *actualpath, const char *sympath ) { 10a18c: 55 push %ebp 10a18d: 89 e5 mov %esp,%ebp 10a18f: 56 push %esi 10a190: 53 push %ebx 10a191: 83 ec 34 sub $0x34,%esp 10a194: 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 ); 10a197: 8d 5d dc lea -0x24(%ebp),%ebx 10a19a: 53 push %ebx 10a19b: 8d 45 f4 lea -0xc(%ebp),%eax 10a19e: 50 push %eax 10a19f: 56 push %esi 10a1a0: e8 0f ff ff ff call 10a0b4 result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start ); 10a1a5: 83 c4 0c add $0xc,%esp 10a1a8: 8d 45 f0 lea -0x10(%ebp),%eax 10a1ab: 50 push %eax 10a1ac: 53 push %ebx 10a1ad: 03 75 f4 add -0xc(%ebp),%esi 10a1b0: 56 push %esi 10a1b1: 8b 45 e8 mov -0x18(%ebp),%eax 10a1b4: ff 50 04 call *0x4(%eax) if ( result != 0 ) 10a1b7: 83 c4 10 add $0x10,%esp 10a1ba: 85 c0 test %eax,%eax 10a1bc: 74 0e je 10a1cc return -1; 10a1be: b8 ff ff ff ff mov $0xffffffff,%eax result = (*loc.ops->symlink_h)( &loc, actualpath, name_start); rtems_filesystem_freenode( &loc ); return result; } 10a1c3: 8d 65 f8 lea -0x8(%ebp),%esp 10a1c6: 5b pop %ebx 10a1c7: 5e pop %esi 10a1c8: c9 leave 10a1c9: c3 ret 10a1ca: 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); 10a1cc: 50 push %eax 10a1cd: ff 75 f0 pushl -0x10(%ebp) 10a1d0: ff 75 08 pushl 0x8(%ebp) 10a1d3: 53 push %ebx 10a1d4: 8b 45 e8 mov -0x18(%ebp),%eax 10a1d7: ff 50 38 call *0x38(%eax) rtems_filesystem_freenode( &loc ); 10a1da: 89 1c 24 mov %ebx,(%esp) 10a1dd: 89 45 d4 mov %eax,-0x2c(%ebp) 10a1e0: e8 67 ec ff ff call 108e4c return result; 10a1e5: 83 c4 10 add $0x10,%esp 10a1e8: 8b 45 d4 mov -0x2c(%ebp),%eax } 10a1eb: 8d 65 f8 lea -0x8(%ebp),%esp 10a1ee: 5b pop %ebx 10a1ef: 5e pop %esi 10a1f0: c9 leave 10a1f1: c3 ret =============================================================================== 00109770 : fdatasync(fn); } /* iterate over all FILE *'s for this thread */ static void sync_per_thread(Thread_Control *t) { 109770: 55 push %ebp 109771: 89 e5 mov %esp,%ebp 109773: 53 push %ebx 109774: 83 ec 04 sub $0x4,%esp 109777: 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; 10977a: 8b 90 e0 00 00 00 mov 0xe0(%eax),%edx if ( this_reent ) { 109780: 85 d2 test %edx,%edx 109782: 74 33 je 1097b7 <== NEVER TAKEN current_reent = _Thread_Executing->libc_reent; 109784: 8b 0d d8 76 12 00 mov 0x1276d8,%ecx 10978a: 8b 99 e0 00 00 00 mov 0xe0(%ecx),%ebx _Thread_Executing->libc_reent = this_reent; 109790: 89 91 e0 00 00 00 mov %edx,0xe0(%ecx) _fwalk (t->libc_reent, sync_wrapper); 109796: 83 ec 08 sub $0x8,%esp 109799: 68 bc 97 10 00 push $0x1097bc 10979e: ff b0 e0 00 00 00 pushl 0xe0(%eax) 1097a4: e8 4b a6 00 00 call 113df4 <_fwalk> _Thread_Executing->libc_reent = current_reent; 1097a9: a1 d8 76 12 00 mov 0x1276d8,%eax 1097ae: 89 98 e0 00 00 00 mov %ebx,0xe0(%eax) 1097b4: 83 c4 10 add $0x10,%esp } } 1097b7: 8b 5d fc mov -0x4(%ebp),%ebx 1097ba: c9 leave 1097bb: c3 ret =============================================================================== 00110394 : int tcsetattr( int fd, int opt, struct termios *tp ) { 110394: 55 push %ebp 110395: 89 e5 mov %esp,%ebp 110397: 56 push %esi 110398: 53 push %ebx 110399: 8b 5d 08 mov 0x8(%ebp),%ebx 11039c: 8b 45 0c mov 0xc(%ebp),%eax 11039f: 8b 75 10 mov 0x10(%ebp),%esi switch (opt) { 1103a2: 85 c0 test %eax,%eax 1103a4: 74 2c je 1103d2 1103a6: 48 dec %eax 1103a7: 74 17 je 1103c0 default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 1103a9: e8 6a 2b 00 00 call 112f18 <__errno> 1103ae: c7 00 86 00 00 00 movl $0x86,(%eax) * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); } } 1103b4: b8 ff ff ff ff mov $0xffffffff,%eax 1103b9: 8d 65 f8 lea -0x8(%ebp),%esp 1103bc: 5b pop %ebx 1103bd: 5e pop %esi 1103be: c9 leave 1103bf: c3 ret switch (opt) { default: rtems_set_errno_and_return_minus_one( ENOTSUP ); case TCSADRAIN: if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0) 1103c0: 50 push %eax 1103c1: 6a 00 push $0x0 1103c3: 6a 03 push $0x3 1103c5: 53 push %ebx 1103c6: e8 55 fc ff ff call 110020 1103cb: 83 c4 10 add $0x10,%esp 1103ce: 85 c0 test %eax,%eax 1103d0: 78 e2 js 1103b4 <== NEVER TAKEN return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 1103d2: 89 75 10 mov %esi,0x10(%ebp) 1103d5: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp) 1103dc: 89 5d 08 mov %ebx,0x8(%ebp) } } 1103df: 8d 65 f8 lea -0x8(%ebp),%esp 1103e2: 5b pop %ebx 1103e3: 5e pop %esi 1103e4: c9 leave return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 1103e5: e9 36 fc ff ff jmp 110020 =============================================================================== 0010b12c : #include int unlink( const char *path ) { 10b12c: 55 push %ebp 10b12d: 89 e5 mov %esp,%ebp 10b12f: 57 push %edi 10b130: 56 push %esi 10b131: 53 push %ebx 10b132: 83 ec 58 sub $0x58,%esp 10b135: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Get the node to be unlinked. Find the parent path first. */ parentpathlen = rtems_filesystem_dirname ( path ); 10b138: 53 push %ebx 10b139: e8 16 d3 ff ff call 108454 if ( parentpathlen == 0 ) 10b13e: 83 c4 10 add $0x10,%esp 10b141: 85 c0 test %eax,%eax 10b143: 0f 85 d3 00 00 00 jne 10b21c rtems_filesystem_get_start_loc( path, &i, &parentloc ); 10b149: 50 push %eax 10b14a: 8d 45 d0 lea -0x30(%ebp),%eax 10b14d: 89 45 b4 mov %eax,-0x4c(%ebp) 10b150: 50 push %eax 10b151: 8d 45 e4 lea -0x1c(%ebp),%eax 10b154: 50 push %eax 10b155: 53 push %ebx 10b156: e8 b9 e2 ff ff call 109414 10b15b: 83 c4 10 add $0x10,%esp 10b15e: 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; 10b160: c6 45 b3 00 movb $0x0,-0x4d(%ebp) /* * Start from the parent to find the node that should be under it. */ loc = parentloc; 10b164: 8d 7d bc lea -0x44(%ebp),%edi 10b167: b9 05 00 00 00 mov $0x5,%ecx 10b16c: 8b 75 b4 mov -0x4c(%ebp),%esi 10b16f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) name = path + parentpathlen; 10b171: 01 d3 add %edx,%ebx name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 10b173: be ff ff ff ff mov $0xffffffff,%esi 10b178: 89 f1 mov %esi,%ecx 10b17a: 89 df mov %ebx,%edi 10b17c: 31 c0 xor %eax,%eax 10b17e: f2 ae repnz scas %es:(%edi),%al 10b180: f7 d1 not %ecx 10b182: 49 dec %ecx 10b183: 83 ec 08 sub $0x8,%esp 10b186: 51 push %ecx 10b187: 53 push %ebx 10b188: e8 0b d3 ff ff call 108498 10b18d: 01 c3 add %eax,%ebx result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 10b18f: 89 f1 mov %esi,%ecx 10b191: 89 df mov %ebx,%edi 10b193: 31 c0 xor %eax,%eax 10b195: f2 ae repnz scas %es:(%edi),%al 10b197: f7 d1 not %ecx 10b199: 49 dec %ecx 10b19a: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10b1a1: 8d 75 bc lea -0x44(%ebp),%esi 10b1a4: 56 push %esi 10b1a5: 6a 00 push $0x0 10b1a7: 51 push %ecx 10b1a8: 53 push %ebx 10b1a9: e8 fa d1 ff ff call 1083a8 0, &loc, false ); if ( result != 0 ) { 10b1ae: 83 c4 20 add $0x20,%esp 10b1b1: 85 c0 test %eax,%eax 10b1b3: 75 53 jne 10b208 if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); return -1; } if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) { 10b1b5: 83 ec 0c sub $0xc,%esp 10b1b8: 56 push %esi 10b1b9: 8b 45 c8 mov -0x38(%ebp),%eax 10b1bc: ff 50 10 call *0x10(%eax) 10b1bf: 83 c4 10 add $0x10,%esp 10b1c2: 48 dec %eax 10b1c3: 0f 84 83 00 00 00 je 10b24c if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); rtems_set_errno_and_return_minus_one( EISDIR ); } result = (*loc.ops->unlink_h)( &parentloc, &loc ); 10b1c9: 83 ec 08 sub $0x8,%esp 10b1cc: 56 push %esi 10b1cd: ff 75 b4 pushl -0x4c(%ebp) 10b1d0: 8b 45 c8 mov -0x38(%ebp),%eax 10b1d3: ff 50 0c call *0xc(%eax) rtems_filesystem_freenode( &loc ); 10b1d6: 89 34 24 mov %esi,(%esp) 10b1d9: 89 45 ac mov %eax,-0x54(%ebp) 10b1dc: e8 07 d3 ff ff call 1084e8 if ( free_parentloc ) 10b1e1: 83 c4 10 add $0x10,%esp 10b1e4: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp) 10b1e8: 8b 45 ac mov -0x54(%ebp),%eax 10b1eb: 74 11 je 10b1fe rtems_filesystem_freenode( &parentloc ); 10b1ed: 83 ec 0c sub $0xc,%esp 10b1f0: ff 75 b4 pushl -0x4c(%ebp) 10b1f3: e8 f0 d2 ff ff call 1084e8 10b1f8: 83 c4 10 add $0x10,%esp 10b1fb: 8b 45 ac mov -0x54(%ebp),%eax return result; } 10b1fe: 8d 65 f4 lea -0xc(%ebp),%esp 10b201: 5b pop %ebx 10b202: 5e pop %esi 10b203: 5f pop %edi 10b204: c9 leave 10b205: c3 ret 10b206: 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 ) 10b208: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp) 10b20c: 75 70 jne 10b27e <== ALWAYS TAKEN rtems_filesystem_freenode( &parentloc ); return -1; 10b20e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED rtems_filesystem_freenode( &loc ); if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); return result; } 10b213: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b216: 5b pop %ebx <== NOT EXECUTED 10b217: 5e pop %esi <== NOT EXECUTED 10b218: 5f pop %edi <== NOT EXECUTED 10b219: c9 leave <== NOT EXECUTED 10b21a: c3 ret <== NOT EXECUTED 10b21b: 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, 10b21c: 89 c2 mov %eax,%edx 10b21e: 83 ec 0c sub $0xc,%esp 10b221: 6a 00 push $0x0 10b223: 8d 45 d0 lea -0x30(%ebp),%eax 10b226: 89 45 b4 mov %eax,-0x4c(%ebp) 10b229: 50 push %eax 10b22a: 6a 02 push $0x2 10b22c: 52 push %edx 10b22d: 53 push %ebx 10b22e: 89 55 ac mov %edx,-0x54(%ebp) 10b231: e8 da d1 ff ff call 108410 RTEMS_LIBIO_PERMS_WRITE, &parentloc, false ); if ( result != 0 ) 10b236: 83 c4 20 add $0x20,%esp 10b239: 85 c0 test %eax,%eax 10b23b: 8b 55 ac mov -0x54(%ebp),%edx 10b23e: 75 ce jne 10b20e <== NEVER TAKEN return -1; free_parentloc = true; 10b240: c6 45 b3 01 movb $0x1,-0x4d(%ebp) 10b244: e9 1b ff ff ff jmp 10b164 10b249: 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 ); 10b24c: 83 ec 0c sub $0xc,%esp 10b24f: 56 push %esi 10b250: e8 93 d2 ff ff call 1084e8 if ( free_parentloc ) 10b255: 83 c4 10 add $0x10,%esp 10b258: 80 7d b3 00 cmpb $0x0,-0x4d(%ebp) 10b25c: 74 0e je 10b26c rtems_filesystem_freenode( &parentloc ); 10b25e: 83 ec 0c sub $0xc,%esp 10b261: ff 75 b4 pushl -0x4c(%ebp) 10b264: e8 7f d2 ff ff call 1084e8 10b269: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EISDIR ); 10b26c: e8 bf a8 00 00 call 115b30 <__errno> 10b271: c7 00 15 00 00 00 movl $0x15,(%eax) 10b277: b8 ff ff ff ff mov $0xffffffff,%eax 10b27c: eb 80 jmp 10b1fe result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 0, &loc, false ); if ( result != 0 ) { if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); 10b27e: 83 ec 0c sub $0xc,%esp 10b281: ff 75 b4 pushl -0x4c(%ebp) 10b284: e8 5f d2 ff ff call 1084e8 10b289: 83 c4 10 add $0x10,%esp return -1; 10b28c: b8 ff ff ff ff mov $0xffffffff,%eax 10b291: e9 68 ff ff ff jmp 10b1fe =============================================================================== 0010b2fc : */ int unmount( const char *path ) { 10b2fc: 55 push %ebp 10b2fd: 89 e5 mov %esp,%ebp 10b2ff: 57 push %edi 10b300: 56 push %esi 10b301: 53 push %ebx 10b302: 83 ec 38 sub $0x38,%esp 10b305: 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 ) ) 10b308: 31 c0 xor %eax,%eax 10b30a: b9 ff ff ff ff mov $0xffffffff,%ecx 10b30f: 89 d7 mov %edx,%edi 10b311: f2 ae repnz scas %es:(%edi),%al 10b313: f7 d1 not %ecx 10b315: 49 dec %ecx 10b316: 6a 01 push $0x1 10b318: 8d 75 d4 lea -0x2c(%ebp),%esi 10b31b: 56 push %esi 10b31c: 6a 00 push $0x0 10b31e: 51 push %ecx 10b31f: 52 push %edx 10b320: e8 4f cf ff ff call 108274 10b325: 83 c4 20 add $0x20,%esp 10b328: 85 c0 test %eax,%eax 10b32a: 75 68 jne 10b394 return -1; mt_entry = loc.mt_entry; 10b32c: 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 ){ 10b32f: 8b 45 d4 mov -0x2c(%ebp),%eax 10b332: 39 43 1c cmp %eax,0x1c(%ebx) 10b335: 0f 85 c5 00 00 00 jne 10b400 /* * Free the loc node and just use the nodes from the mt_entry . */ rtems_filesystem_freenode( &loc ); 10b33b: 83 ec 0c sub $0xc,%esp 10b33e: 56 push %esi 10b33f: e8 08 d0 ff ff call 10834c * 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 ) 10b344: 83 c4 10 add $0x10,%esp 10b347: a1 b0 61 12 00 mov 0x1261b0,%eax 10b34c: 39 58 14 cmp %ebx,0x14(%eax) 10b34f: 0f 84 cf 00 00 00 je 10b424 /* * Verify there are no file systems below the path specified */ if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point, 10b355: 83 ec 08 sub $0x8,%esp 10b358: ff 73 2c pushl 0x2c(%ebx) 10b35b: 68 e8 b2 10 00 push $0x10b2e8 10b360: e8 ab d7 ff ff call 108b10 10b365: 83 c4 10 add $0x10,%esp 10b368: 84 c0 test %al,%al 10b36a: 0f 85 b4 00 00 00 jne 10b424 * 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 ) 10b370: 83 ec 0c sub $0xc,%esp 10b373: 53 push %ebx 10b374: e8 03 d3 ff ff call 10867c 10b379: 83 c4 10 add $0x10,%esp 10b37c: 48 dec %eax 10b37d: 0f 84 a1 00 00 00 je 10b424 * 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 ) 10b383: 83 ec 0c sub $0xc,%esp 10b386: 8b 43 14 mov 0x14(%ebx),%eax 10b389: 53 push %ebx 10b38a: ff 50 28 call *0x28(%eax) 10b38d: 83 c4 10 add $0x10,%esp 10b390: 85 c0 test %eax,%eax 10b392: 74 10 je 10b3a4 <== 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; 10b394: b8 ff ff ff ff mov $0xffffffff,%eax rtems_filesystem_freenode( fs_mount_loc ); free( mt_entry ); return 0; } 10b399: 8d 65 f4 lea -0xc(%ebp),%esp 10b39c: 5b pop %ebx 10b39d: 5e pop %esi 10b39e: 5f pop %edi 10b39f: c9 leave 10b3a0: c3 ret 10b3a1: 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){ 10b3a4: 83 ec 0c sub $0xc,%esp 10b3a7: 8b 43 28 mov 0x28(%ebx),%eax 10b3aa: 53 push %ebx 10b3ab: ff 50 2c call *0x2c(%eax) 10b3ae: 83 c4 10 add $0x10,%esp 10b3b1: 85 c0 test %eax,%eax 10b3b3: 0f 85 83 00 00 00 jne 10b43c <== 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 ); 10b3b9: 52 push %edx 10b3ba: 6a 00 push $0x0 10b3bc: 6a 00 push $0x0 10b3be: ff 35 08 84 12 00 pushl 0x128408 10b3c4: e8 c7 0a 00 00 call 10be90 */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10b3c9: 89 1c 24 mov %ebx,(%esp) 10b3cc: e8 77 13 00 00 call 10c748 <_Chain_Extract> } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10b3d1: 58 pop %eax 10b3d2: ff 35 08 84 12 00 pushl 0x128408 10b3d8: e8 af 0b 00 00 call 10bf8c 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; 10b3dd: 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 ); 10b3e0: 89 04 24 mov %eax,(%esp) 10b3e3: e8 64 cf ff ff call 10834c free( mt_entry ); 10b3e8: 89 1c 24 mov %ebx,(%esp) 10b3eb: e8 70 cf ff ff call 108360 return 0; 10b3f0: 83 c4 10 add $0x10,%esp 10b3f3: 31 c0 xor %eax,%eax } 10b3f5: 8d 65 f4 lea -0xc(%ebp),%esp 10b3f8: 5b pop %ebx 10b3f9: 5e pop %esi 10b3fa: 5f pop %edi 10b3fb: c9 leave 10b3fc: c3 ret 10b3fd: 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 ); 10b400: 83 ec 0c sub $0xc,%esp 10b403: 56 push %esi 10b404: e8 43 cf ff ff call 10834c rtems_set_errno_and_return_minus_one( EACCES ); 10b409: e8 9e 79 00 00 call 112dac <__errno> 10b40e: c7 00 0d 00 00 00 movl $0xd,(%eax) 10b414: 83 c4 10 add $0x10,%esp 10b417: b8 ff ff ff ff mov $0xffffffff,%eax rtems_filesystem_freenode( fs_mount_loc ); free( mt_entry ); return 0; } 10b41c: 8d 65 f4 lea -0xc(%ebp),%esp 10b41f: 5b pop %ebx 10b420: 5e pop %esi 10b421: 5f pop %edi 10b422: c9 leave 10b423: 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 ); 10b424: e8 83 79 00 00 call 112dac <__errno> 10b429: c7 00 10 00 00 00 movl $0x10,(%eax) 10b42f: b8 ff ff ff ff mov $0xffffffff,%eax rtems_filesystem_freenode( fs_mount_loc ); free( mt_entry ); return 0; } 10b434: 8d 65 f4 lea -0xc(%ebp),%esp 10b437: 5b pop %ebx 10b438: 5e pop %esi 10b439: 5f pop %edi 10b43a: c9 leave 10b43b: 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 ) 10b43c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b43f: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10b442: 53 push %ebx <== NOT EXECUTED 10b443: ff 50 20 call *0x20(%eax) <== NOT EXECUTED 10b446: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b449: 85 c0 test %eax,%eax <== NOT EXECUTED 10b44b: 0f 84 43 ff ff ff je 10b394 <== NOT EXECUTED rtems_fatal_error_occurred( 0 ); 10b451: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b454: 6a 00 push $0x0 <== NOT EXECUTED 10b456: e8 2d 10 00 00 call 10c488 <== NOT EXECUTED =============================================================================== 0010b4b4 : int utime( const char *path, const struct utimbuf *times ) { 10b4b4: 55 push %ebp 10b4b5: 89 e5 mov %esp,%ebp 10b4b7: 57 push %edi 10b4b8: 56 push %esi 10b4b9: 53 push %ebx 10b4ba: 83 ec 48 sub $0x48,%esp 10b4bd: 8b 55 08 mov 0x8(%ebp),%edx 10b4c0: 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 ) ) 10b4c3: 31 c0 xor %eax,%eax 10b4c5: b9 ff ff ff ff mov $0xffffffff,%ecx 10b4ca: 89 d7 mov %edx,%edi 10b4cc: f2 ae repnz scas %es:(%edi),%al 10b4ce: f7 d1 not %ecx 10b4d0: 49 dec %ecx 10b4d1: 6a 01 push $0x1 10b4d3: 8d 75 d4 lea -0x2c(%ebp),%esi 10b4d6: 56 push %esi 10b4d7: 6a 00 push $0x0 10b4d9: 51 push %ecx 10b4da: 52 push %edx 10b4db: e8 a8 ca ff ff call 107f88 10b4e0: 83 c4 20 add $0x20,%esp 10b4e3: 85 c0 test %eax,%eax 10b4e5: 75 2d jne 10b514 return -1; if ( times == NULL ) { 10b4e7: 85 db test %ebx,%ebx 10b4e9: 74 39 je 10b524 10b4eb: 8b 53 04 mov 0x4(%ebx),%edx 10b4ee: 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 ); 10b4f0: 51 push %ecx 10b4f1: 52 push %edx 10b4f2: 50 push %eax 10b4f3: 56 push %esi 10b4f4: 8b 45 e0 mov -0x20(%ebp),%eax 10b4f7: ff 50 30 call *0x30(%eax) rtems_filesystem_freenode( &temp_loc ); 10b4fa: 89 34 24 mov %esi,(%esp) 10b4fd: 89 45 c4 mov %eax,-0x3c(%ebp) 10b500: e8 73 ce ff ff call 108378 return result; 10b505: 83 c4 10 add $0x10,%esp 10b508: 8b 45 c4 mov -0x3c(%ebp),%eax } 10b50b: 8d 65 f4 lea -0xc(%ebp),%esp 10b50e: 5b pop %ebx 10b50f: 5e pop %esi 10b510: 5f pop %edi 10b511: c9 leave 10b512: c3 ret 10b513: 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; 10b514: 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; } 10b519: 8d 65 f4 lea -0xc(%ebp),%esp 10b51c: 5b pop %ebx 10b51d: 5e pop %esi 10b51e: 5f pop %edi 10b51f: c9 leave 10b520: c3 ret 10b521: 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 ); 10b524: 83 ec 0c sub $0xc,%esp 10b527: 6a 00 push $0x0 10b529: e8 1a c2 00 00 call 117748