=============================================================================== 0010d738 : #define MAXSYMLINK 5 int IMFS_Set_handlers( rtems_filesystem_location_info_t *loc ) { 10d738: 55 push %ebp 10d739: 89 e5 mov %esp,%ebp 10d73b: 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; 10d73e: 8b 50 10 mov 0x10(%eax),%edx 10d741: 8b 52 34 mov 0x34(%edx),%edx switch( node->type ) { 10d744: 8b 08 mov (%eax),%ecx 10d746: 8b 49 4c mov 0x4c(%ecx),%ecx 10d749: 49 dec %ecx 10d74a: 83 f9 06 cmp $0x6,%ecx 10d74d: 77 29 ja 10d778 <== NEVER TAKEN 10d74f: ff 24 8d d8 f3 11 00 jmp *0x11f3d8(,%ecx,4) case IMFS_DIRECTORY: loc->handlers = fs_info->directory_handlers; 10d756: 8b 52 0c mov 0xc(%edx),%edx 10d759: eb 1a jmp 10d775 break; case IMFS_DEVICE: loc->handlers = &IMFS_device_handlers; 10d75b: c7 40 08 fc f3 11 00 movl $0x11f3fc,0x8(%eax) break; 10d762: eb 14 jmp 10d778 case IMFS_SYM_LINK: case IMFS_HARD_LINK: loc->handlers = &IMFS_link_handlers; 10d764: c7 40 08 6c f4 11 00 movl $0x11f46c,0x8(%eax) break; 10d76b: eb 0b jmp 10d778 case IMFS_LINEAR_FILE: loc->handlers = fs_info->memfile_handlers; break; case IMFS_MEMORY_FILE: loc->handlers = fs_info->memfile_handlers; 10d76d: 8b 52 08 mov 0x8(%edx),%edx 10d770: eb 03 jmp 10d775 break; case IMFS_FIFO: loc->handlers = fs_info->fifo_handlers; 10d772: 8b 52 10 mov 0x10(%edx),%edx 10d775: 89 50 08 mov %edx,0x8(%eax) break; } return 0; } 10d778: 31 c0 xor %eax,%eax 10d77a: c9 leave 10d77b: c3 ret =============================================================================== 0010d5eb : IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) { 10d5eb: 55 push %ebp 10d5ec: 89 e5 mov %esp,%ebp 10d5ee: 57 push %edi 10d5ef: 56 push %esi 10d5f0: 53 push %ebx 10d5f1: 83 ec 1c sub $0x1c,%esp 10d5f4: 8b 4d 08 mov 0x8(%ebp),%ecx 10d5f7: 8b 5d 0c mov 0xc(%ebp),%ebx 10d5fa: 8b 75 18 mov 0x18(%ebp),%esi /* * MUST have a parent node to call this routine. */ if ( parent_loc == NULL ) return NULL; 10d5fd: 31 c0 xor %eax,%eax IMFS_fs_info_t *fs_info; /* * MUST have a parent node to call this routine. */ if ( parent_loc == NULL ) 10d5ff: 85 c9 test %ecx,%ecx 10d601: 0f 84 f4 00 00 00 je 10d6fb <== NEVER TAKEN return NULL; parent = parent_loc->node_access; 10d607: 8b 11 mov (%ecx),%edx fs_info = parent_loc->mt_entry->fs_info; 10d609: 8b 49 10 mov 0x10(%ecx),%ecx 10d60c: 8b 79 34 mov 0x34(%ecx),%edi /* * Reject creation of FIFOs if support is disabled. */ if ( type == IMFS_FIFO && 10d60f: 83 fb 07 cmp $0x7,%ebx 10d612: 75 0d jne 10d621 10d614: 81 7f 10 70 f3 11 00 cmpl $0x11f370,0x10(%edi) 10d61b: 0f 84 da 00 00 00 je 10d6fb return NULL; /* * Allocate filesystem node and fill in basic information */ node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask ); 10d621: 50 push %eax 10d622: a1 80 30 12 00 mov 0x123080,%eax 10d627: 8b 40 2c mov 0x2c(%eax),%eax 10d62a: f7 d0 not %eax 10d62c: 23 45 14 and 0x14(%ebp),%eax 10d62f: 50 push %eax 10d630: ff 75 10 pushl 0x10(%ebp) 10d633: 53 push %ebx 10d634: 89 55 e4 mov %edx,-0x1c(%ebp) 10d637: e8 40 ff ff ff call 10d57c if ( !node ) 10d63c: 83 c4 10 add $0x10,%esp 10d63f: 85 c0 test %eax,%eax 10d641: 8b 55 e4 mov -0x1c(%ebp),%edx 10d644: 0f 84 b1 00 00 00 je 10d6fb return NULL; /* * Set the type specific information */ if ( type == IMFS_DIRECTORY ) { 10d64a: 83 fb 01 cmp $0x1,%ebx 10d64d: 75 15 jne 10d664 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 ); 10d64f: 8d 48 54 lea 0x54(%eax),%ecx 10d652: 89 48 50 mov %ecx,0x50(%eax) head->next = tail; head->previous = NULL; 10d655: 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 ); 10d65c: 8d 48 50 lea 0x50(%eax),%ecx 10d65f: 89 48 58 mov %ecx,0x58(%eax) 10d662: eb 75 jmp 10d6d9 rtems_chain_initialize_empty(&node->info.directory.Entries); } else if ( type == IMFS_HARD_LINK ) { 10d664: 83 fb 03 cmp $0x3,%ebx 10d667: 74 05 je 10d66e node->info.hard_link.link_node = info->hard_link.link_node; } else if ( type == IMFS_SYM_LINK ) { 10d669: 83 fb 04 cmp $0x4,%ebx 10d66c: 75 07 jne 10d675 node->info.sym_link.name = info->sym_link.name; 10d66e: 8b 0e mov (%esi),%ecx 10d670: 89 48 50 mov %ecx,0x50(%eax) 10d673: eb 64 jmp 10d6d9 } else if ( type == IMFS_DEVICE ) { 10d675: 83 fb 02 cmp $0x2,%ebx 10d678: 75 0d jne 10d687 node->info.device.major = info->device.major; 10d67a: 8b 0e mov (%esi),%ecx 10d67c: 89 48 50 mov %ecx,0x50(%eax) node->info.device.minor = info->device.minor; 10d67f: 8b 4e 04 mov 0x4(%esi),%ecx 10d682: 89 48 54 mov %ecx,0x54(%eax) 10d685: eb 52 jmp 10d6d9 } else if ( type == IMFS_LINEAR_FILE ) { 10d687: 83 fb 06 cmp $0x6,%ebx 10d68a: 75 17 jne 10d6a3 node->info.linearfile.size = 0; 10d68c: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10d693: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.linearfile.direct = 0; 10d69a: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) 10d6a1: eb 36 jmp 10d6d9 } else if ( type == IMFS_MEMORY_FILE ) { 10d6a3: 83 fb 05 cmp $0x5,%ebx 10d6a6: 75 25 jne 10d6cd node->info.file.size = 0; 10d6a8: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10d6af: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.file.indirect = 0; 10d6b6: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) node->info.file.doubly_indirect = 0; 10d6bd: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) node->info.file.triply_indirect = 0; 10d6c4: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) 10d6cb: eb 0c jmp 10d6d9 } else if ( type == IMFS_FIFO ) { 10d6cd: 83 fb 07 cmp $0x7,%ebx 10d6d0: 75 07 jne 10d6d9 <== NEVER TAKEN node->info.fifo.pipe = NULL; 10d6d2: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) } /* * This node MUST have a parent, so put it in that directory list. */ node->Parent = parent; 10d6d9: 89 50 08 mov %edx,0x8(%eax) node->st_ino = ++fs_info->ino_count; 10d6dc: 8b 4f 04 mov 0x4(%edi),%ecx 10d6df: 41 inc %ecx 10d6e0: 89 4f 04 mov %ecx,0x4(%edi) 10d6e3: 89 48 38 mov %ecx,0x38(%eax) 10d6e6: 53 push %ebx 10d6e7: 53 push %ebx 10d6e8: 50 push %eax rtems_chain_append( &parent->info.directory.Entries, &node->Node ); 10d6e9: 83 c2 50 add $0x50,%edx 10d6ec: 52 push %edx 10d6ed: 89 45 e4 mov %eax,-0x1c(%ebp) 10d6f0: e8 3f d3 ff ff call 10aa34 <_Chain_Append> return node; 10d6f5: 83 c4 10 add $0x10,%esp 10d6f8: 8b 45 e4 mov -0x1c(%ebp),%eax } 10d6fb: 8d 65 f4 lea -0xc(%ebp),%esp 10d6fe: 5b pop %ebx 10d6ff: 5e pop %esi 10d700: 5f pop %edi 10d701: c9 leave 10d702: c3 ret =============================================================================== 0010d819 : const char *pathname, /* IN */ size_t pathnamelen, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10d819: 55 push %ebp 10d81a: 89 e5 mov %esp,%ebp 10d81c: 57 push %edi 10d81d: 56 push %esi 10d81e: 53 push %ebx 10d81f: 83 ec 5c sub $0x5c,%esp 10d822: 8b 5d 14 mov 0x14(%ebp),%ebx 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 ) ) { 10d825: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp) 10d82c: 74 0d je 10d83b <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EIO ); 10d82e: e8 05 39 00 00 call 111138 <__errno> <== NOT EXECUTED 10d833: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 10d839: eb 42 jmp 10d87d <== NOT EXECUTED /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10d83b: 8b 3b mov (%ebx),%edi rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { int i = 0; int len; IMFS_token_types type = IMFS_CURRENT_DIR; 10d83d: be 01 00 00 00 mov $0x1,%esi size_t pathnamelen, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { int i = 0; 10d842: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp) /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 10d849: e9 29 01 00 00 jmp 10d977 type = IMFS_get_token( &pathname[i], pathnamelen, token, &len ); 10d84e: 8d 45 e4 lea -0x1c(%ebp),%eax 10d851: 50 push %eax 10d852: 8d 4d af lea -0x51(%ebp),%ecx 10d855: 51 push %ecx 10d856: ff 75 0c pushl 0xc(%ebp) 10d859: 8b 45 08 mov 0x8(%ebp),%eax 10d85c: 03 45 a4 add -0x5c(%ebp),%eax 10d85f: 50 push %eax 10d860: e8 b3 05 00 00 call 10de18 10d865: 89 c6 mov %eax,%esi pathnamelen -= len; 10d867: 8b 55 e4 mov -0x1c(%ebp),%edx i += len; if ( !pathloc->node_access ) 10d86a: 83 c4 10 add $0x10,%esp 10d86d: 83 3b 00 cmpl $0x0,(%ebx) 10d870: 75 13 jne 10d885 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOENT ); 10d872: e8 c1 38 00 00 call 111138 <__errno> 10d877: c7 00 02 00 00 00 movl $0x2,(%eax) 10d87d: 83 cf ff or $0xffffffff,%edi 10d880: e9 75 01 00 00 jmp 10d9fa /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10d885: 85 c0 test %eax,%eax 10d887: 74 21 je 10d8aa if ( node->type == IMFS_DIRECTORY ) 10d889: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10d88d: 75 1b jne 10d8aa if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10d88f: 57 push %edi 10d890: 57 push %edi 10d891: 6a 01 push $0x1 10d893: 53 push %ebx 10d894: 89 55 a0 mov %edx,-0x60(%ebp) 10d897: e8 e0 fe ff ff call 10d77c 10d89c: 83 c4 10 add $0x10,%esp 10d89f: 85 c0 test %eax,%eax 10d8a1: 8b 55 a0 mov -0x60(%ebp),%edx 10d8a4: 0f 84 3e 01 00 00 je 10d9e8 */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], pathnamelen, token, &len ); pathnamelen -= len; 10d8aa: 29 55 0c sub %edx,0xc(%ebp) i += len; 10d8ad: 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; 10d8b0: 8b 3b mov (%ebx),%edi switch( type ) { 10d8b2: 83 fe 03 cmp $0x3,%esi 10d8b5: 74 38 je 10d8ef 10d8b7: 83 fe 04 cmp $0x4,%esi 10d8ba: 0f 84 a7 00 00 00 je 10d967 10d8c0: 83 fe 02 cmp $0x2,%esi 10d8c3: 0f 85 ae 00 00 00 jne 10d977 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10d8c9: a1 80 30 12 00 mov 0x123080,%eax 10d8ce: 3b 78 18 cmp 0x18(%eax),%edi 10d8d1: 0f 84 a0 00 00 00 je 10d977 <== NEVER TAKEN /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access) { 10d8d7: 8b 43 10 mov 0x10(%ebx),%eax /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == 10d8da: 3b 78 1c cmp 0x1c(%eax),%edi 10d8dd: 75 0b jne 10d8ea */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; /* Throw out the .. in this case */ } else { newloc = pathloc->mt_entry->mt_point_node; 10d8df: 8d 7d d0 lea -0x30(%ebp),%edi 10d8e2: 8d 70 08 lea 0x8(%eax),%esi 10d8e5: e9 ad 00 00 00 jmp 10d997 pathnamelen+len, flags,pathloc); } } else { if ( !node->Parent ) 10d8ea: 8b 7f 08 mov 0x8(%edi),%edi 10d8ed: eb 6c jmp 10d95b case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { 10d8ef: 8b 47 4c mov 0x4c(%edi),%eax 10d8f2: 83 f8 03 cmp $0x3,%eax 10d8f5: 75 11 jne 10d908 IMFS_evaluate_hard_link( pathloc, 0 ); 10d8f7: 51 push %ecx 10d8f8: 51 push %ecx 10d8f9: 6a 00 push $0x0 10d8fb: 53 push %ebx 10d8fc: e8 d9 fe ff ff call 10d7da node = pathloc->node_access; 10d901: 8b 3b mov (%ebx),%edi 10d903: 83 c4 10 add $0x10,%esp 10d906: eb 1d jmp 10d925 * It would be a design error if we evaluated the link and * was broken. */ IMFS_assert( node ); } else if ( node->type == IMFS_SYM_LINK ) { 10d908: 83 f8 04 cmp $0x4,%eax 10d90b: 75 18 jne 10d925 result = IMFS_evaluate_sym_link( pathloc, 0 ); 10d90d: 52 push %edx 10d90e: 52 push %edx 10d90f: 6a 00 push $0x0 10d911: 53 push %ebx 10d912: e8 ed 00 00 00 call 10da04 /* * In contrast to a hard link, it is possible to have a broken * symbolic link. */ node = pathloc->node_access; 10d917: 8b 3b mov (%ebx),%edi if ( result == -1 ) 10d919: 83 c4 10 add $0x10,%esp 10d91c: 83 f8 ff cmp $0xffffffff,%eax 10d91f: 0f 84 d3 00 00 00 je 10d9f8 <== NEVER TAKEN } /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10d925: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10d929: 74 10 je 10d93b rtems_set_errno_and_return_minus_one( ENOTDIR ); 10d92b: e8 08 38 00 00 call 111138 <__errno> 10d930: c7 00 14 00 00 00 movl $0x14,(%eax) 10d936: e9 42 ff ff ff jmp 10d87d /* * 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 ) { 10d93b: 8b 47 5c mov 0x5c(%edi),%eax 10d93e: 85 c0 test %eax,%eax 10d940: 74 08 je 10d94a newloc = node->info.directory.mt_fs->mt_fs_root; 10d942: 8d 7d d0 lea -0x30(%ebp),%edi 10d945: 8d 70 1c lea 0x1c(%eax),%esi 10d948: eb 4d jmp 10d997 } /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10d94a: 50 push %eax 10d94b: 50 push %eax 10d94c: 8d 45 af lea -0x51(%ebp),%eax 10d94f: 50 push %eax 10d950: 57 push %edi 10d951: e8 56 04 00 00 call 10ddac 10d956: 89 c7 mov %eax,%edi if ( !node ) 10d958: 83 c4 10 add $0x10,%esp 10d95b: 85 ff test %edi,%edi 10d95d: 0f 84 0f ff ff ff je 10d872 /* * Set the node access to the point we have found. */ pathloc->node_access = node; 10d963: 89 3b mov %edi,(%ebx) 10d965: eb 10 jmp 10d977 case IMFS_NO_MORE_PATH: case IMFS_CURRENT_DIR: break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10d967: e8 cc 37 00 00 call 111138 <__errno> 10d96c: c7 00 5b 00 00 00 movl $0x5b,(%eax) 10d972: e9 06 ff ff ff jmp 10d87d /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 10d977: 83 fe 04 cmp $0x4,%esi 10d97a: 74 08 je 10d984 <== NEVER TAKEN 10d97c: 85 f6 test %esi,%esi 10d97e: 0f 85 ca fe ff ff jne 10d84e * 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 ) { 10d984: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10d988: 75 41 jne 10d9cb if ( node->info.directory.mt_fs != NULL ) { 10d98a: 8b 77 5c mov 0x5c(%edi),%esi 10d98d: 85 f6 test %esi,%esi 10d98f: 74 3a je 10d9cb newloc = node->info.directory.mt_fs->mt_fs_root; 10d991: 8d 7d d0 lea -0x30(%ebp),%edi 10d994: 83 c6 1c add $0x1c,%esi 10d997: b9 05 00 00 00 mov $0x5,%ecx 10d99c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10d99e: 8d 75 d0 lea -0x30(%ebp),%esi 10d9a1: b1 05 mov $0x5,%cl 10d9a3: 89 df mov %ebx,%edi 10d9a5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalpath_h)( &pathname[i-len], 10d9a7: 8b 45 e4 mov -0x1c(%ebp),%eax 10d9aa: 8b 53 0c mov 0xc(%ebx),%edx 10d9ad: 53 push %ebx 10d9ae: ff 75 10 pushl 0x10(%ebp) 10d9b1: 8b 4d 0c mov 0xc(%ebp),%ecx 10d9b4: 01 c1 add %eax,%ecx 10d9b6: 51 push %ecx 10d9b7: 8b 4d a4 mov -0x5c(%ebp),%ecx 10d9ba: 29 c1 sub %eax,%ecx 10d9bc: 8b 45 08 mov 0x8(%ebp),%eax 10d9bf: 01 c8 add %ecx,%eax 10d9c1: 50 push %eax 10d9c2: ff 12 call *(%edx) 10d9c4: 89 c7 mov %eax,%edi 10d9c6: 83 c4 10 add $0x10,%esp 10d9c9: eb 2f jmp 10d9fa flags, pathloc ); } else { result = IMFS_Set_handlers( pathloc ); } } else { result = IMFS_Set_handlers( pathloc ); 10d9cb: 83 ec 0c sub $0xc,%esp 10d9ce: 53 push %ebx 10d9cf: e8 64 fd ff ff call 10d738 10d9d4: 89 c7 mov %eax,%edi 10d9d6: 5a pop %edx 10d9d7: 59 pop %ecx /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) 10d9d8: ff 75 10 pushl 0x10(%ebp) 10d9db: 53 push %ebx 10d9dc: e8 9b fd ff ff call 10d77c 10d9e1: 83 c4 10 add $0x10,%esp 10d9e4: 85 c0 test %eax,%eax 10d9e6: 75 12 jne 10d9fa rtems_set_errno_and_return_minus_one( EACCES ); 10d9e8: e8 4b 37 00 00 call 111138 <__errno> 10d9ed: c7 00 0d 00 00 00 movl $0xd,(%eax) 10d9f3: e9 85 fe ff ff jmp 10d87d 10d9f8: 89 c7 mov %eax,%edi <== NOT EXECUTED return result; } 10d9fa: 89 f8 mov %edi,%eax 10d9fc: 8d 65 f4 lea -0xc(%ebp),%esp 10d9ff: 5b pop %ebx 10da00: 5e pop %esi 10da01: 5f pop %edi 10da02: c9 leave 10da03: c3 ret =============================================================================== 0010daf8 : int IMFS_evaluate_for_make( const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) { 10daf8: 55 push %ebp 10daf9: 89 e5 mov %esp,%ebp 10dafb: 57 push %edi 10dafc: 56 push %esi 10dafd: 53 push %ebx 10dafe: 83 ec 5c sub $0x5c,%esp 10db01: 8b 55 0c mov 0xc(%ebp),%edx /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10db04: 8b 1a mov (%edx),%ebx /* * Get the path length. */ pathlen = strlen( path ); 10db06: 31 c0 xor %eax,%eax 10db08: 83 c9 ff or $0xffffffff,%ecx 10db0b: 8b 7d 08 mov 0x8(%ebp),%edi 10db0e: f2 ae repnz scas %es:(%edi),%al 10db10: f7 d1 not %ecx 10db12: 49 dec %ecx 10db13: 89 4d a0 mov %ecx,-0x60(%ebp) const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) { int i = 0; 10db16: 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 ); 10db1d: 8d 7d af lea -0x51(%ebp),%edi 10db20: 89 d6 mov %edx,%esi 10db22: 8d 45 e4 lea -0x1c(%ebp),%eax 10db25: 50 push %eax 10db26: 57 push %edi 10db27: ff 75 a0 pushl -0x60(%ebp) 10db2a: 8b 45 08 mov 0x8(%ebp),%eax 10db2d: 03 45 a4 add -0x5c(%ebp),%eax 10db30: 50 push %eax 10db31: e8 e2 02 00 00 call 10de18 10db36: 89 c2 mov %eax,%edx pathlen -= len; 10db38: 8b 4d e4 mov -0x1c(%ebp),%ecx 10db3b: 29 4d a0 sub %ecx,-0x60(%ebp) i += len; if ( !pathloc->node_access ) 10db3e: 83 c4 10 add $0x10,%esp 10db41: 83 3e 00 cmpl $0x0,(%esi) 10db44: 0f 84 79 01 00 00 je 10dcc3 <== NEVER TAKEN /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10db4a: 85 c0 test %eax,%eax 10db4c: 74 36 je 10db84 if ( node->type == IMFS_DIRECTORY ) 10db4e: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10db52: 75 30 jne 10db84 if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10db54: 53 push %ebx 10db55: 53 push %ebx 10db56: 6a 01 push $0x1 10db58: 56 push %esi 10db59: 89 45 9c mov %eax,-0x64(%ebp) 10db5c: 89 4d 98 mov %ecx,-0x68(%ebp) 10db5f: e8 18 fc ff ff call 10d77c 10db64: 83 c4 10 add $0x10,%esp 10db67: 85 c0 test %eax,%eax 10db69: 8b 55 9c mov -0x64(%ebp),%edx 10db6c: 8b 4d 98 mov -0x68(%ebp),%ecx 10db6f: 75 13 jne 10db84 rtems_set_errno_and_return_minus_one( EACCES ); 10db71: e8 c2 35 00 00 call 111138 <__errno> 10db76: c7 00 0d 00 00 00 movl $0xd,(%eax) 10db7c: 83 cb ff or $0xffffffff,%ebx 10db7f: e9 99 01 00 00 jmp 10dd1d while( !done ) { type = IMFS_get_token( &path[i], pathlen, token, &len ); pathlen -= len; i += len; 10db84: 01 4d a4 add %ecx,-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; 10db87: 8b 1e mov (%esi),%ebx switch( type ) { 10db89: 83 fa 02 cmp $0x2,%edx 10db8c: 74 1f je 10dbad 10db8e: 77 0a ja 10db9a 10db90: 85 d2 test %edx,%edx 10db92: 0f 84 d9 00 00 00 je 10dc71 10db98: eb 88 jmp 10db22 10db9a: 83 fa 03 cmp $0x3,%edx 10db9d: 74 40 je 10dbdf 10db9f: 83 fa 04 cmp $0x4,%edx 10dba2: 0f 85 7a ff ff ff jne 10db22 <== NEVER TAKEN 10dba8: e9 d4 00 00 00 jmp 10dc81 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10dbad: a1 80 30 12 00 mov 0x123080,%eax 10dbb2: 3b 58 18 cmp 0x18(%eax),%ebx 10dbb5: 0f 84 67 ff ff ff je 10db22 /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){ 10dbbb: 8b 46 10 mov 0x10(%esi),%eax 10dbbe: 3b 58 1c cmp 0x1c(%eax),%ebx 10dbc1: 75 0c jne 10dbcf 10dbc3: 89 f2 mov %esi,%edx 10dbc5: 89 c6 mov %eax,%esi if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; } else { newloc = pathloc->mt_entry->mt_point_node; 10dbc7: 8d 7d d0 lea -0x30(%ebp),%edi 10dbca: 83 c6 08 add $0x8,%esi 10dbcd: eb 5a jmp 10dc29 *pathloc = newloc; return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); } } else { if ( !node->Parent ) 10dbcf: 8b 5b 08 mov 0x8(%ebx),%ebx 10dbd2: 85 db test %ebx,%ebx 10dbd4: 0f 85 90 00 00 00 jne 10dc6a 10dbda: e9 e4 00 00 00 jmp 10dcc3 pathloc->node_access = node; break; case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { 10dbdf: 8b 43 4c mov 0x4c(%ebx),%eax 10dbe2: 83 f8 03 cmp $0x3,%eax 10dbe5: 74 05 je 10dbec result = IMFS_evaluate_link( pathloc, 0 ); if ( result == -1 ) return -1; } else if ( node->type == IMFS_SYM_LINK ) { 10dbe7: 83 f8 04 cmp $0x4,%eax 10dbea: 75 16 jne 10dc02 result = IMFS_evaluate_link( pathloc, 0 ); 10dbec: 50 push %eax 10dbed: 50 push %eax 10dbee: 6a 00 push $0x0 10dbf0: 56 push %esi 10dbf1: e8 7f fe ff ff call 10da75 if ( result == -1 ) 10dbf6: 83 c4 10 add $0x10,%esp 10dbf9: 83 f8 ff cmp $0xffffffff,%eax 10dbfc: 0f 84 19 01 00 00 je 10dd1b <== NEVER TAKEN return -1; } node = pathloc->node_access; 10dc02: 8b 06 mov (%esi),%eax if ( !node ) 10dc04: 85 c0 test %eax,%eax 10dc06: 0f 84 e9 00 00 00 je 10dcf5 <== NEVER TAKEN /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10dc0c: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 10dc10: 0f 85 df 00 00 00 jne 10dcf5 /* * 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 ) { 10dc16: 8b 50 5c mov 0x5c(%eax),%edx 10dc19: 85 d2 test %edx,%edx 10dc1b: 74 3b je 10dc58 10dc1d: 89 f0 mov %esi,%eax 10dc1f: 89 d6 mov %edx,%esi 10dc21: 89 c2 mov %eax,%edx newloc = node->info.directory.mt_fs->mt_fs_root; 10dc23: 8d 7d d0 lea -0x30(%ebp),%edi 10dc26: 83 c6 1c add $0x1c,%esi 10dc29: b9 05 00 00 00 mov $0x5,%ecx 10dc2e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10dc30: 8d 75 d0 lea -0x30(%ebp),%esi 10dc33: b1 05 mov $0x5,%cl 10dc35: 89 d7 mov %edx,%edi 10dc37: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10dc39: 56 push %esi 10dc3a: 8b 42 0c mov 0xc(%edx),%eax 10dc3d: ff 75 10 pushl 0x10(%ebp) 10dc40: 52 push %edx 10dc41: 8b 55 a4 mov -0x5c(%ebp),%edx 10dc44: 2b 55 e4 sub -0x1c(%ebp),%edx 10dc47: 03 55 08 add 0x8(%ebp),%edx 10dc4a: 52 push %edx 10dc4b: ff 50 04 call *0x4(%eax) 10dc4e: 89 c3 mov %eax,%ebx 10dc50: 83 c4 10 add $0x10,%esp 10dc53: e9 c5 00 00 00 jmp 10dd1d /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10dc58: 53 push %ebx 10dc59: 53 push %ebx 10dc5a: 57 push %edi 10dc5b: 50 push %eax 10dc5c: e8 4b 01 00 00 call 10ddac 10dc61: 89 c3 mov %eax,%ebx /* * If there is no node we have found the name of the node we * wish to create. */ if ( ! node ) 10dc63: 83 c4 10 add $0x10,%esp 10dc66: 85 c0 test %eax,%eax 10dc68: 74 27 je 10dc91 done = true; else pathloc->node_access = node; 10dc6a: 89 1e mov %ebx,(%esi) 10dc6c: e9 b1 fe ff ff jmp 10db22 break; case IMFS_NO_MORE_PATH: rtems_set_errno_and_return_minus_one( EEXIST ); 10dc71: e8 c2 34 00 00 call 111138 <__errno> 10dc76: c7 00 11 00 00 00 movl $0x11,(%eax) 10dc7c: e9 fb fe ff ff jmp 10db7c break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10dc81: e8 b2 34 00 00 call 111138 <__errno> 10dc86: c7 00 5b 00 00 00 movl $0x5b,(%eax) 10dc8c: e9 eb fe ff ff jmp 10db7c 10dc91: 89 f2 mov %esi,%edx case IMFS_CURRENT_DIR: break; } } *name = &path[ i - len ]; 10dc93: 8b 45 a4 mov -0x5c(%ebp),%eax 10dc96: 2b 45 e4 sub -0x1c(%ebp),%eax 10dc99: 03 45 08 add 0x8(%ebp),%eax 10dc9c: 8b 4d 10 mov 0x10(%ebp),%ecx 10dc9f: 89 01 mov %eax,(%ecx) * pathloc is returned with a pointer to the parent of the new node. * name is returned with a pointer to the first character in the * new node name. The parent node is verified to be a directory. */ int IMFS_evaluate_for_make( 10dca1: 8b 5d 08 mov 0x8(%ebp),%ebx 10dca4: 03 5d a4 add -0x5c(%ebp),%ebx /* * 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++) { 10dca7: eb 2a jmp 10dcd3 if ( !IMFS_is_separator( path[ i ] ) ) 10dca9: 83 ec 0c sub $0xc,%esp 10dcac: 0f be c0 movsbl %al,%eax 10dcaf: 50 push %eax 10dcb0: 89 55 9c mov %edx,-0x64(%ebp) 10dcb3: e8 9c a3 ff ff call 108054 10dcb8: 43 inc %ebx 10dcb9: 83 c4 10 add $0x10,%esp 10dcbc: 85 c0 test %eax,%eax 10dcbe: 8b 55 9c mov -0x64(%ebp),%edx 10dcc1: 75 10 jne 10dcd3 rtems_set_errno_and_return_minus_one( ENOENT ); 10dcc3: e8 70 34 00 00 call 111138 <__errno> 10dcc8: c7 00 02 00 00 00 movl $0x2,(%eax) 10dcce: e9 a9 fe ff ff jmp 10db7c /* * 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++) { 10dcd3: 8a 03 mov (%ebx),%al 10dcd5: 84 c0 test %al,%al 10dcd7: 75 d0 jne 10dca9 /* * Verify we can execute and write to this directory. */ result = IMFS_Set_handlers( pathloc ); 10dcd9: 83 ec 0c sub $0xc,%esp 10dcdc: 52 push %edx 10dcdd: 89 55 9c mov %edx,-0x64(%ebp) 10dce0: e8 53 fa ff ff call 10d738 10dce5: 89 c3 mov %eax,%ebx /* * The returned node must be a directory */ node = pathloc->node_access; if ( node->type != IMFS_DIRECTORY ) 10dce7: 8b 55 9c mov -0x64(%ebp),%edx 10dcea: 8b 02 mov (%edx),%eax 10dcec: 83 c4 10 add $0x10,%esp 10dcef: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 10dcf3: 74 10 je 10dd05 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTDIR ); 10dcf5: e8 3e 34 00 00 call 111138 <__errno> 10dcfa: c7 00 14 00 00 00 movl $0x14,(%eax) 10dd00: e9 77 fe ff ff jmp 10db7c /* * We must have Write and execute permission on the returned node. */ if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) 10dd05: 51 push %ecx 10dd06: 51 push %ecx 10dd07: 6a 03 push $0x3 10dd09: 52 push %edx 10dd0a: e8 6d fa ff ff call 10d77c 10dd0f: 83 c4 10 add $0x10,%esp 10dd12: 85 c0 test %eax,%eax 10dd14: 75 07 jne 10dd1d 10dd16: e9 56 fe ff ff jmp 10db71 10dd1b: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10dd1d: 89 d8 mov %ebx,%eax 10dd1f: 8d 65 f4 lea -0xc(%ebp),%esp 10dd22: 5b pop %ebx 10dd23: 5e pop %esi 10dd24: 5f pop %edi 10dd25: c9 leave 10dd26: c3 ret =============================================================================== 0010d77c : */ int IMFS_evaluate_permission( rtems_filesystem_location_info_t *node, int flags ) { 10d77c: 55 push %ebp 10d77d: 89 e5 mov %esp,%ebp 10d77f: 57 push %edi 10d780: 56 push %esi 10d781: 53 push %ebx 10d782: 83 ec 0c sub $0xc,%esp 10d785: 8b 75 0c mov 0xc(%ebp),%esi uid_t st_uid; gid_t st_gid; IMFS_jnode_t *jnode; int flags_to_test; if ( !rtems_libio_is_valid_perms( flags ) ) 10d788: f7 c6 f8 ff ff ff test $0xfffffff8,%esi 10d78e: 74 10 je 10d7a0 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EPERM ); 10d790: e8 a3 39 00 00 call 111138 <__errno> <== NOT EXECUTED 10d795: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10d79b: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10d79e: eb 32 jmp 10d7d2 <== NOT EXECUTED jnode = node->node_access; 10d7a0: 8b 45 08 mov 0x8(%ebp),%eax 10d7a3: 8b 18 mov (%eax),%ebx #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 10d7a5: e8 2e 0a 00 00 call 10e1d8 10d7aa: 89 c7 mov %eax,%edi st_gid = getegid(); 10d7ac: e8 17 0a 00 00 call 10e1c8 * Check if I am owner or a group member or someone else. */ flags_to_test = flags; if ( st_uid == jnode->st_uid ) 10d7b1: 66 3b 7b 3c cmp 0x3c(%ebx),%di 10d7b5: 75 05 jne 10d7bc flags_to_test <<= 6; 10d7b7: c1 e6 06 shl $0x6,%esi 10d7ba: eb 09 jmp 10d7c5 else if ( st_gid == jnode->st_gid ) 10d7bc: 66 3b 43 3e cmp 0x3e(%ebx),%ax 10d7c0: 75 03 jne 10d7c5 <== NEVER TAKEN flags_to_test <<= 3; 10d7c2: c1 e6 03 shl $0x3,%esi /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10d7c5: 8b 43 30 mov 0x30(%ebx),%eax 10d7c8: 21 f0 and %esi,%eax gid_t st_gid; IMFS_jnode_t *jnode; int flags_to_test; if ( !rtems_libio_is_valid_perms( flags ) ) rtems_set_errno_and_return_minus_one( EPERM ); 10d7ca: 39 f0 cmp %esi,%eax 10d7cc: 0f 94 c0 sete %al 10d7cf: 0f b6 c0 movzbl %al,%eax */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) return 1; return 0; } 10d7d2: 83 c4 0c add $0xc,%esp 10d7d5: 5b pop %ebx 10d7d6: 5e pop %esi 10d7d7: 5f pop %edi 10d7d8: c9 leave 10d7d9: c3 ret =============================================================================== 00107b98 : rtems_off64_t IMFS_fifo_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) { 107b98: 55 push %ebp 107b99: 89 e5 mov %esp,%ebp 107b9b: 53 push %ebx 107b9c: 83 ec 10 sub $0x10,%esp 107b9f: 8b 45 08 mov 0x8(%ebp),%eax off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop); 107ba2: 50 push %eax 107ba3: ff 75 14 pushl 0x14(%ebp) 107ba6: ff 75 10 pushl 0x10(%ebp) 107ba9: ff 75 0c pushl 0xc(%ebp) 107bac: 8b 40 18 mov 0x18(%eax),%eax 107baf: ff 70 50 pushl 0x50(%eax) 107bb2: e8 fa 86 00 00 call 1102b1 107bb7: 89 c3 mov %eax,%ebx IMFS_FIFO_RETURN(err); 107bb9: 83 c4 20 add $0x20,%esp 107bbc: 99 cltd 107bbd: 85 d2 test %edx,%edx 107bbf: 79 0e jns 107bcf <== NEVER TAKEN 107bc1: e8 8e b3 00 00 call 112f54 <__errno> 107bc6: f7 db neg %ebx 107bc8: 89 18 mov %ebx,(%eax) 107bca: 83 c8 ff or $0xffffffff,%eax 107bcd: 89 c2 mov %eax,%edx } 107bcf: 8b 5d fc mov -0x4(%ebp),%ebx 107bd2: c9 leave 107bd3: c3 ret =============================================================================== 00107c34 : ssize_t IMFS_fifo_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 107c34: 55 push %ebp 107c35: 89 e5 mov %esp,%ebp 107c37: 56 push %esi 107c38: 53 push %ebx 107c39: 83 ec 10 sub $0x10,%esp 107c3c: 8b 45 08 mov 0x8(%ebp),%eax IMFS_jnode_t *jnode = iop->pathinfo.node_access; 107c3f: 8b 70 18 mov 0x18(%eax),%esi int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop); 107c42: 50 push %eax 107c43: ff 75 10 pushl 0x10(%ebp) 107c46: ff 75 0c pushl 0xc(%ebp) 107c49: ff 76 50 pushl 0x50(%esi) 107c4c: e8 5c 84 00 00 call 1100ad 107c51: 89 c3 mov %eax,%ebx if (err > 0) { 107c53: 83 c4 10 add $0x10,%esp 107c56: 83 f8 00 cmp $0x0,%eax 107c59: 7e 1d jle 107c78 IMFS_mtime_ctime_update(jnode); 107c5b: 50 push %eax 107c5c: 50 push %eax 107c5d: 6a 00 push $0x0 107c5f: 8d 45 f0 lea -0x10(%ebp),%eax 107c62: 50 push %eax 107c63: e8 ec 0d 00 00 call 108a54 107c68: 8b 45 f0 mov -0x10(%ebp),%eax 107c6b: 89 46 44 mov %eax,0x44(%esi) 107c6e: 89 46 48 mov %eax,0x48(%esi) 107c71: 83 c4 10 add $0x10,%esp 107c74: 89 d8 mov %ebx,%eax 107c76: eb 13 jmp 107c8b } IMFS_FIFO_RETURN(err); 107c78: b8 00 00 00 00 mov $0x0,%eax 107c7d: 74 0c je 107c8b <== NEVER TAKEN 107c7f: e8 d0 b2 00 00 call 112f54 <__errno> 107c84: f7 db neg %ebx 107c86: 89 18 mov %ebx,(%eax) 107c88: 83 c8 ff or $0xffffffff,%eax } 107c8b: 8d 65 f8 lea -0x8(%ebp),%esp 107c8e: 5b pop %ebx 107c8f: 5e pop %esi 107c90: c9 leave 107c91: c3 ret =============================================================================== 0010ddac : IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) { 10ddac: 55 push %ebp 10ddad: 89 e5 mov %esp,%ebp 10ddaf: 57 push %edi 10ddb0: 56 push %esi 10ddb1: 53 push %ebx 10ddb2: 83 ec 14 sub $0x14,%esp 10ddb5: 8b 5d 08 mov 0x8(%ebp),%ebx 10ddb8: 8b 7d 0c mov 0xc(%ebp),%edi /* * Check for "." and ".." */ if ( !strcmp( name, dotname ) ) 10ddbb: 68 f4 f3 11 00 push $0x11f3f4 10ddc0: 57 push %edi 10ddc1: e8 36 40 00 00 call 111dfc 10ddc6: 83 c4 10 add $0x10,%esp 10ddc9: 85 c0 test %eax,%eax 10ddcb: 74 40 je 10de0d <== NEVER TAKEN return directory; if ( !strcmp( name, dotdotname ) ) 10ddcd: 51 push %ecx 10ddce: 51 push %ecx 10ddcf: 68 f6 f3 11 00 push $0x11f3f6 10ddd4: 57 push %edi 10ddd5: e8 22 40 00 00 call 111dfc 10ddda: 83 c4 10 add $0x10,%esp 10dddd: 85 c0 test %eax,%eax 10dddf: 75 05 jne 10dde6 <== ALWAYS TAKEN return directory->Parent; 10dde1: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10dde4: eb 27 jmp 10de0d <== NOT EXECUTED if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10dde6: 8b 73 50 mov 0x50(%ebx),%esi RTEMS_INLINE_ROUTINE bool _Chain_Is_tail( Chain_Control *the_chain, const Chain_Node *the_node ) { return (the_node == _Chain_Tail(the_chain)); 10dde9: 83 c3 54 add $0x54,%ebx if ( !strcmp( name, dotdotname ) ) return directory->Parent; the_chain = &directory->info.directory.Entries; for ( the_node = rtems_chain_first( the_chain ); 10ddec: eb 15 jmp 10de03 !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 ) ) 10ddee: 8d 46 0c lea 0xc(%esi),%eax 10ddf1: 52 push %edx 10ddf2: 52 push %edx 10ddf3: 50 push %eax 10ddf4: 57 push %edi 10ddf5: e8 02 40 00 00 call 111dfc 10ddfa: 83 c4 10 add $0x10,%esp 10ddfd: 85 c0 test %eax,%eax 10ddff: 74 0a je 10de0b the_chain = &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 ) { 10de01: 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 ); 10de03: 39 de cmp %ebx,%esi 10de05: 75 e7 jne 10ddee if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; 10de07: 31 db xor %ebx,%ebx 10de09: eb 02 jmp 10de0d 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; 10de0b: 89 f3 mov %esi,%ebx if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10de0d: 89 d8 mov %ebx,%eax 10de0f: 8d 65 f4 lea -0xc(%ebp),%esp 10de12: 5b pop %ebx 10de13: 5e pop %esi 10de14: 5f pop %edi 10de15: c9 leave 10de16: c3 ret =============================================================================== 0010dd28 : ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next)) int IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 10dd28: 55 push %ebp 10dd29: 89 e5 mov %esp,%ebp 10dd2b: 57 push %edi 10dd2c: 56 push %esi 10dd2d: 53 push %ebx 10dd2e: 83 ec 2c sub $0x2c,%esp 10dd31: 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; 10dd34: 8b 58 1c mov 0x1c(%eax),%ebx loc = temp_mt_entry->mt_fs_root; 10dd37: 8d 7d d4 lea -0x2c(%ebp),%edi 10dd3a: 8d 70 1c lea 0x1c(%eax),%esi 10dd3d: b9 05 00 00 00 mov $0x5,%ecx 10dd42: 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; 10dd44: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) do { next = jnode->Parent; loc.node_access = (void *)jnode; IMFS_Set_handlers( &loc ); 10dd4b: 8d 75 d4 lea -0x2c(%ebp),%esi */ temp_mt_entry->mt_fs_root.node_access = NULL; do { next = jnode->Parent; 10dd4e: 8b 7b 08 mov 0x8(%ebx),%edi loc.node_access = (void *)jnode; 10dd51: 89 5d d4 mov %ebx,-0x2c(%ebp) IMFS_Set_handlers( &loc ); 10dd54: 83 ec 0c sub $0xc,%esp 10dd57: 56 push %esi 10dd58: e8 db f9 ff ff call 10d738 if ( jnode->type != IMFS_DIRECTORY ) { 10dd5d: 83 c4 10 add $0x10,%esp 10dd60: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10dd64: 75 08 jne 10dd6e RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10dd66: 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 ) ) { 10dd69: 39 43 50 cmp %eax,0x50(%ebx) 10dd6c: 75 13 jne 10dd81 result = IMFS_unlink( NULL, &loc ); 10dd6e: 50 push %eax 10dd6f: 50 push %eax 10dd70: 56 push %esi 10dd71: 6a 00 push $0x0 10dd73: e8 9c 91 ff ff call 106f14 if (result != 0) 10dd78: 83 c4 10 add $0x10,%esp 10dd7b: 85 c0 test %eax,%eax 10dd7d: 75 1e jne 10dd9d <== NEVER TAKEN return -1; jnode = next; 10dd7f: 89 fb mov %edi,%ebx } if ( jnode != NULL ) { 10dd81: 85 db test %ebx,%ebx 10dd83: 74 1d je 10dda2 if ( jnode->type == IMFS_DIRECTORY ) { 10dd85: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10dd89: 75 c3 jne 10dd4e <== NEVER TAKEN } } } while (jnode != NULL); return 0; } 10dd8b: 8b 43 50 mov 0x50(%ebx),%eax 10dd8e: 8d 53 54 lea 0x54(%ebx),%edx return -1; jnode = next; } if ( jnode != NULL ) { if ( jnode->type == IMFS_DIRECTORY ) { if ( jnode_has_children( jnode ) ) 10dd91: 39 d0 cmp %edx,%eax 10dd93: 74 b9 je 10dd4e jnode = jnode_get_first_child( jnode ); 10dd95: 89 c3 mov %eax,%ebx } } } while (jnode != NULL); 10dd97: 85 c0 test %eax,%eax 10dd99: 75 b3 jne 10dd4e <== ALWAYS TAKEN 10dd9b: eb 05 jmp 10dda2 <== NOT EXECUTED return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { result = IMFS_unlink( NULL, &loc ); if (result != 0) return -1; 10dd9d: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10dda0: eb 02 jmp 10dda4 <== NOT EXECUTED jnode = jnode_get_first_child( jnode ); } } } while (jnode != NULL); return 0; 10dda2: 31 c0 xor %eax,%eax } 10dda4: 8d 65 f4 lea -0xc(%ebp),%esp 10dda7: 5b pop %ebx 10dda8: 5e pop %esi 10dda9: 5f pop %edi 10ddaa: c9 leave 10ddab: c3 ret =============================================================================== 0010de18 : const char *path, int pathlen, char *token, int *token_len ) { 10de18: 55 push %ebp 10de19: 89 e5 mov %esp,%ebp 10de1b: 57 push %edi 10de1c: 56 push %esi 10de1d: 53 push %ebx 10de1e: 83 ec 1c sub $0x1c,%esp 10de21: 8b 7d 08 mov 0x8(%ebp),%edi 10de24: 8b 75 10 mov 0x10(%ebp),%esi register char c; /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; 10de27: 8a 17 mov (%edi),%dl int pathlen, char *token, int *token_len ) { register int i = 0; 10de29: 31 db xor %ebx,%ebx /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) { 10de2b: eb 10 jmp 10de3d token[i] = c; 10de2d: 88 14 1e mov %dl,(%esi,%ebx,1) if ( i == IMFS_NAME_MAX ) 10de30: 83 fb 20 cmp $0x20,%ebx 10de33: 0f 84 86 00 00 00 je 10debf return IMFS_INVALID_TOKEN; if ( !IMFS_is_valid_name_char(c) ) type = IMFS_INVALID_TOKEN; c = path [++i]; 10de39: 43 inc %ebx 10de3a: 8a 14 1f mov (%edi,%ebx,1),%dl /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) { 10de3d: 83 ec 0c sub $0xc,%esp 10de40: 0f be c2 movsbl %dl,%eax 10de43: 50 push %eax 10de44: 88 55 e4 mov %dl,-0x1c(%ebp) 10de47: e8 08 a2 ff ff call 108054 10de4c: 83 c4 10 add $0x10,%esp 10de4f: 85 c0 test %eax,%eax 10de51: 8a 55 e4 mov -0x1c(%ebp),%dl 10de54: 75 05 jne 10de5b 10de56: 3b 5d 0c cmp 0xc(%ebp),%ebx 10de59: 7c d2 jl 10de2d /* * Copy a seperator into token. */ if ( i == 0 ) { 10de5b: 85 db test %ebx,%ebx 10de5d: 75 10 jne 10de6f token[i] = c; 10de5f: 88 16 mov %dl,(%esi) if ( (token[i] != '\0') && pathlen ) { 10de61: 84 d2 test %dl,%dl 10de63: 74 06 je 10de6b 10de65: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10de69: 75 16 jne 10de81 i++; type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; 10de6b: 31 ff xor %edi,%edi 10de6d: eb 1c jmp 10de8b char *token, int *token_len ) { register int i = 0; IMFS_token_types type = IMFS_NAME; 10de6f: bf 03 00 00 00 mov $0x3,%edi i++; type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; } } else if (token[ i-1 ] != '\0') { 10de74: 80 7c 1e ff 00 cmpb $0x0,-0x1(%esi,%ebx,1) 10de79: 74 10 je 10de8b <== NEVER TAKEN token[i] = '\0'; 10de7b: c6 04 1e 00 movb $0x0,(%esi,%ebx,1) 10de7f: eb 0a jmp 10de8b if ( i == 0 ) { token[i] = c; if ( (token[i] != '\0') && pathlen ) { i++; type = IMFS_CURRENT_DIR; 10de81: bf 01 00 00 00 mov $0x1,%edi if ( i == 0 ) { token[i] = c; if ( (token[i] != '\0') && pathlen ) { i++; 10de86: bb 01 00 00 00 mov $0x1,%ebx /* * Set token_len to the number of characters copied. */ *token_len = i; 10de8b: 8b 45 14 mov 0x14(%ebp),%eax 10de8e: 89 18 mov %ebx,(%eax) /* * If we copied something that was not a seperator see if * it was a special name. */ if ( type == IMFS_NAME ) { 10de90: 83 ff 03 cmp $0x3,%edi 10de93: 75 3d jne 10ded2 if ( strcmp( token, "..") == 0 ) 10de95: 52 push %edx 10de96: 52 push %edx 10de97: 68 f9 f3 11 00 push $0x11f3f9 10de9c: 56 push %esi 10de9d: e8 5a 3f 00 00 call 111dfc 10dea2: 83 c4 10 add $0x10,%esp 10dea5: 85 c0 test %eax,%eax 10dea7: 74 1d je 10dec6 type = IMFS_UP_DIR; else if ( strcmp( token, "." ) == 0 ) 10dea9: 50 push %eax 10deaa: 50 push %eax 10deab: 68 fa f3 11 00 push $0x11f3fa 10deb0: 56 push %esi 10deb1: e8 46 3f 00 00 call 111dfc 10deb6: 83 c4 10 add $0x10,%esp 10deb9: 85 c0 test %eax,%eax 10debb: 74 10 je 10decd 10debd: eb 13 jmp 10ded2 while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) { token[i] = c; if ( i == IMFS_NAME_MAX ) return IMFS_INVALID_TOKEN; 10debf: bf 04 00 00 00 mov $0x4,%edi 10dec4: eb 0c jmp 10ded2 * it was a special name. */ if ( type == IMFS_NAME ) { if ( strcmp( token, "..") == 0 ) type = IMFS_UP_DIR; 10dec6: bf 02 00 00 00 mov $0x2,%edi 10decb: eb 05 jmp 10ded2 else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; 10decd: bf 01 00 00 00 mov $0x1,%edi } return type; } 10ded2: 89 f8 mov %edi,%eax 10ded4: 8d 65 f4 lea -0xc(%ebp),%esp 10ded7: 5b pop %ebx 10ded8: 5e pop %esi 10ded9: 5f pop %edi 10deda: c9 leave 10dedb: c3 ret =============================================================================== 00106bac : 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 ) { 106bac: 55 push %ebp 106bad: 89 e5 mov %esp,%ebp 106baf: 57 push %edi 106bb0: 56 push %esi 106bb1: 53 push %ebx 106bb2: 83 ec 1c sub $0x1c,%esp 106bb5: 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, 106bb8: a1 48 11 12 00 mov 0x121148,%eax 106bbd: b9 06 00 00 00 mov $0x6,%ecx int bit_mask; /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) { 106bc2: ba 10 00 00 00 mov $0x10,%edx if (bit_mask == requested_bytes_per_block) { 106bc7: 39 c2 cmp %eax,%edx 106bc9: 74 0c je 106bd7 is_valid = true; break; } if(bit_mask > requested_bytes_per_block) 106bcb: 7f 05 jg 106bd2 int bit_mask; /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) { 106bcd: d1 e2 shl %edx 106bcf: 49 dec %ecx 106bd0: 75 f5 jne 106bc7 <== ALWAYS TAKEN if(bit_mask > requested_bytes_per_block) break; } *dest_bytes_per_block = ((is_valid) ? requested_bytes_per_block : default_bytes_per_block); 106bd2: b8 80 00 00 00 mov $0x80,%eax break; } if(bit_mask > requested_bytes_per_block) break; } *dest_bytes_per_block = ((is_valid) 106bd7: a3 ec 4e 12 00 mov %eax,0x124eec /* * 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(); 106bdc: e8 22 6b 00 00 call 10d703 106be1: 89 c2 mov %eax,%edx 106be3: 89 43 1c mov %eax,0x1c(%ebx) temp_mt_entry->mt_fs_root.handlers = directory_handlers; 106be6: 8b 45 14 mov 0x14(%ebp),%eax 106be9: 89 43 24 mov %eax,0x24(%ebx) temp_mt_entry->mt_fs_root.ops = op_table; 106bec: 8b 45 0c mov 0xc(%ebp),%eax 106bef: 89 43 28 mov %eax,0x28(%ebx) temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS; 106bf2: 8d 7b 38 lea 0x38(%ebx),%edi 106bf5: be a8 f3 11 00 mov $0x11f3a8,%esi 106bfa: b9 0c 00 00 00 mov $0xc,%ecx 106bff: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Create custom file system data. */ fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) ); 106c01: 50 push %eax 106c02: 50 push %eax 106c03: 6a 14 push $0x14 106c05: 6a 01 push $0x1 106c07: 89 55 e4 mov %edx,-0x1c(%ebp) 106c0a: e8 fd 05 00 00 call 10720c if ( !fs_info ) { 106c0f: 83 c4 10 add $0x10,%esp 106c12: 85 c0 test %eax,%eax 106c14: 8b 55 e4 mov -0x1c(%ebp),%edx 106c17: 75 1c jne 106c35 free(temp_mt_entry->mt_fs_root.node_access); 106c19: 83 ec 0c sub $0xc,%esp 106c1c: 52 push %edx 106c1d: e8 56 07 00 00 call 107378 rtems_set_errno_and_return_minus_one(ENOMEM); 106c22: e8 11 a5 00 00 call 111138 <__errno> 106c27: c7 00 0c 00 00 00 movl $0xc,(%eax) 106c2d: 83 c4 10 add $0x10,%esp 106c30: 83 c8 ff or $0xffffffff,%eax 106c33: eb 34 jmp 106c69 } temp_mt_entry->fs_info = fs_info; 106c35: 89 43 34 mov %eax,0x34(%ebx) /* * Set st_ino for the root to 1. */ fs_info->instance = imfs_instance++; 106c38: 8b 0d f0 4e 12 00 mov 0x124ef0,%ecx 106c3e: 89 08 mov %ecx,(%eax) 106c40: 41 inc %ecx 106c41: 89 0d f0 4e 12 00 mov %ecx,0x124ef0 fs_info->ino_count = 1; 106c47: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) fs_info->memfile_handlers = memfile_handlers; 106c4e: 8b 4d 10 mov 0x10(%ebp),%ecx 106c51: 89 48 08 mov %ecx,0x8(%eax) fs_info->directory_handlers = directory_handlers; 106c54: 8b 4d 14 mov 0x14(%ebp),%ecx 106c57: 89 48 0c mov %ecx,0xc(%eax) fs_info->fifo_handlers = fifo_handlers; 106c5a: 8b 4d 18 mov 0x18(%ebp),%ecx 106c5d: 89 48 10 mov %ecx,0x10(%eax) jnode = temp_mt_entry->mt_fs_root.node_access; jnode->st_ino = fs_info->ino_count; 106c60: c7 42 38 01 00 00 00 movl $0x1,0x38(%edx) return 0; 106c67: 31 c0 xor %eax,%eax } 106c69: 8d 65 f4 lea -0xc(%ebp),%esp 106c6c: 5b pop %ebx 106c6d: 5e pop %esi 106c6e: 5f pop %edi 106c6f: c9 leave 106c70: c3 ret =============================================================================== 00110102 : */ MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) { 110102: 55 push %ebp 110103: 89 e5 mov %esp,%ebp 110105: 57 push %edi 110106: 56 push %esi 110107: 53 push %ebx 110108: 83 ec 2c sub $0x2c,%esp 11010b: 8b 7d 08 mov 0x8(%ebp),%edi 11010e: 8b 5d 0c mov 0xc(%ebp),%ebx 110111: 8b 75 10 mov 0x10(%ebp),%esi IMFS_assert( the_jnode->type == IMFS_MEMORY_FILE ); /* * Verify new file size is supported */ if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE ) 110114: a1 ec 4e 12 00 mov 0x124eec,%eax 110119: 89 c1 mov %eax,%ecx 11011b: c1 e9 02 shr $0x2,%ecx 11011e: 8d 51 01 lea 0x1(%ecx),%edx 110121: 0f af d1 imul %ecx,%edx 110124: 42 inc %edx 110125: 0f af d1 imul %ecx,%edx 110128: 4a dec %edx 110129: 0f af d0 imul %eax,%edx 11012c: 83 fe 00 cmp $0x0,%esi 11012f: 7c 16 jl 110147 <== NEVER TAKEN 110131: 7f 04 jg 110137 <== NEVER TAKEN 110133: 39 d3 cmp %edx,%ebx 110135: 72 10 jb 110147 rtems_set_errno_and_return_minus_one( EINVAL ); 110137: e8 fc 0f 00 00 call 111138 <__errno> 11013c: c7 00 16 00 00 00 movl $0x16,(%eax) 110142: e9 92 00 00 00 jmp 1101d9 /* * Verify new file size is actually larger than current size */ if ( new_length <= the_jnode->info.file.size ) 110147: 8b 57 50 mov 0x50(%edi),%edx 11014a: 8b 4f 54 mov 0x54(%edi),%ecx 11014d: 89 55 e0 mov %edx,-0x20(%ebp) 110150: 89 4d e4 mov %ecx,-0x1c(%ebp) 110153: 39 ce cmp %ecx,%esi 110155: 0f 8c 8f 00 00 00 jl 1101ea <== NEVER TAKEN 11015b: 7f 08 jg 110165 <== NEVER TAKEN 11015d: 39 d3 cmp %edx,%ebx 11015f: 0f 86 85 00 00 00 jbe 1101ea return 0; /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; 110165: 89 45 d8 mov %eax,-0x28(%ebp) 110168: 89 c1 mov %eax,%ecx 11016a: c1 f9 1f sar $0x1f,%ecx 11016d: 89 4d dc mov %ecx,-0x24(%ebp) 110170: ff 75 dc pushl -0x24(%ebp) 110173: ff 75 d8 pushl -0x28(%ebp) 110176: 56 push %esi 110177: 53 push %ebx 110178: e8 43 c8 00 00 call 11c9c0 <__divdi3> 11017d: 83 c4 10 add $0x10,%esp 110180: 89 45 d4 mov %eax,-0x2c(%ebp) old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; 110183: ff 75 dc pushl -0x24(%ebp) 110186: ff 75 d8 pushl -0x28(%ebp) 110189: ff 75 e4 pushl -0x1c(%ebp) 11018c: ff 75 e0 pushl -0x20(%ebp) 11018f: e8 2c c8 00 00 call 11c9c0 <__divdi3> 110194: 83 c4 10 add $0x10,%esp 110197: 89 45 e0 mov %eax,-0x20(%ebp) /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 11019a: 89 c2 mov %eax,%edx 11019c: eb 41 jmp 1101df if ( IMFS_memfile_addblock( the_jnode, block ) ) { 11019e: 51 push %ecx 11019f: 51 push %ecx 1101a0: 52 push %edx 1101a1: 57 push %edi 1101a2: 89 55 d0 mov %edx,-0x30(%ebp) 1101a5: e8 99 fd ff ff call 10ff43 1101aa: 83 c4 10 add $0x10,%esp 1101ad: 85 c0 test %eax,%eax 1101af: 8b 55 d0 mov -0x30(%ebp),%edx 1101b2: 74 2a je 1101de 1101b4: eb 13 jmp 1101c9 for ( ; block>=old_blocks ; block-- ) { IMFS_memfile_remove_block( the_jnode, block ); 1101b6: 50 push %eax 1101b7: 50 push %eax 1101b8: 52 push %edx 1101b9: 57 push %edi 1101ba: 89 55 d0 mov %edx,-0x30(%ebp) 1101bd: e8 16 ff ff ff call 1100d8 /* * 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-- ) { 1101c2: 8b 55 d0 mov -0x30(%ebp),%edx 1101c5: 4a dec %edx 1101c6: 83 c4 10 add $0x10,%esp 1101c9: 3b 55 e0 cmp -0x20(%ebp),%edx 1101cc: 73 e8 jae 1101b6 IMFS_memfile_remove_block( the_jnode, block ); } rtems_set_errno_and_return_minus_one( ENOSPC ); 1101ce: e8 65 0f 00 00 call 111138 <__errno> 1101d3: c7 00 1c 00 00 00 movl $0x1c,(%eax) 1101d9: 83 c8 ff or $0xffffffff,%eax 1101dc: eb 0e jmp 1101ec old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 1101de: 42 inc %edx 1101df: 3b 55 d4 cmp -0x2c(%ebp),%edx 1101e2: 76 ba jbe 11019e } /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; 1101e4: 89 5f 50 mov %ebx,0x50(%edi) 1101e7: 89 77 54 mov %esi,0x54(%edi) /* * Verify new file size is actually larger than current size */ if ( new_length <= the_jnode->info.file.size ) return 0; 1101ea: 31 c0 xor %eax,%eax /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; return 0; } 1101ec: 8d 65 f4 lea -0xc(%ebp),%esp 1101ef: 5b pop %ebx 1101f0: 5e pop %esi 1101f1: 5f pop %edi 1101f2: c9 leave 1101f3: c3 ret =============================================================================== 0010fc48 : #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) { 10fc48: 55 push %ebp 10fc49: 89 e5 mov %esp,%ebp 10fc4b: 57 push %edi 10fc4c: 56 push %esi 10fc4d: 53 push %ebx 10fc4e: 83 ec 1c sub $0x1c,%esp 10fc51: 8b 75 08 mov 0x8(%ebp),%esi 10fc54: 8b 7d 0c mov 0xc(%ebp),%edi my_block = block; /* * Is the block number in the simple indirect portion? */ if ( my_block <= LAST_INDIRECT ) { 10fc57: 8b 0d ec 4e 12 00 mov 0x124eec,%ecx 10fc5d: c1 e9 02 shr $0x2,%ecx 10fc60: 8d 41 ff lea -0x1(%ecx),%eax 10fc63: 39 c7 cmp %eax,%edi 10fc65: 77 40 ja 10fca7 p = info->indirect; 10fc67: 8b 46 58 mov 0x58(%esi),%eax if ( malloc_it ) { 10fc6a: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10fc6e: 74 25 je 10fc95 if ( !p ) { 10fc70: 85 c0 test %eax,%eax 10fc72: 75 12 jne 10fc86 p = memfile_alloc_block(); 10fc74: e8 ad ff ff ff call 10fc26 if ( !p ) return 0; 10fc79: 31 db xor %ebx,%ebx if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); if ( !p ) 10fc7b: 85 c0 test %eax,%eax 10fc7d: 0f 84 f7 00 00 00 je 10fd7a <== NEVER TAKEN return 0; info->indirect = p; 10fc83: 89 46 58 mov %eax,0x58(%esi) } return &info->indirect[ my_block ]; 10fc86: 8d 1c bd 00 00 00 00 lea 0x0(,%edi,4),%ebx 10fc8d: 03 5e 58 add 0x58(%esi),%ebx 10fc90: e9 e5 00 00 00 jmp 10fd7a } if ( !p ) return 0; 10fc95: 31 db xor %ebx,%ebx info->indirect = p; } return &info->indirect[ my_block ]; } if ( !p ) 10fc97: 85 c0 test %eax,%eax 10fc99: 0f 84 db 00 00 00 je 10fd7a <== NEVER TAKEN return 0; return &info->indirect[ my_block ]; 10fc9f: 8d 1c b8 lea (%eax,%edi,4),%ebx 10fca2: e9 d3 00 00 00 jmp 10fd7a /* * Is the block number in the doubly indirect portion? */ if ( my_block <= LAST_DOUBLY_INDIRECT ) { 10fca7: 8d 41 01 lea 0x1(%ecx),%eax 10fcaa: 0f af c1 imul %ecx,%eax 10fcad: 8d 50 ff lea -0x1(%eax),%edx 10fcb0: 39 d7 cmp %edx,%edi 10fcb2: 77 40 ja 10fcf4 my_block -= FIRST_DOUBLY_INDIRECT; 10fcb4: 29 cf sub %ecx,%edi singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 10fcb6: 89 f8 mov %edi,%eax 10fcb8: 31 d2 xor %edx,%edx 10fcba: f7 f1 div %ecx 10fcbc: 89 55 e4 mov %edx,-0x1c(%ebp) 10fcbf: 89 c7 mov %eax,%edi doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; p = info->doubly_indirect; 10fcc1: 8b 46 5c mov 0x5c(%esi),%eax if ( malloc_it ) { 10fcc4: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10fcc8: 74 1b je 10fce5 if ( !p ) { 10fcca: 85 c0 test %eax,%eax 10fccc: 75 12 jne 10fce0 p = memfile_alloc_block(); 10fcce: e8 53 ff ff ff call 10fc26 if ( !p ) return 0; 10fcd3: 31 db xor %ebx,%ebx p = info->doubly_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); if ( !p ) 10fcd5: 85 c0 test %eax,%eax 10fcd7: 0f 84 9d 00 00 00 je 10fd7a <== NEVER TAKEN return 0; info->doubly_indirect = p; 10fcdd: 89 46 5c mov %eax,0x5c(%esi) } p1 = (block_p *)p[ doubly ]; 10fce0: 8d 34 b8 lea (%eax,%edi,4),%esi 10fce3: eb 65 jmp 10fd4a return (block_p *)&p1[ singly ]; } if ( !p ) return 0; 10fce5: 31 db xor %ebx,%ebx } return (block_p *)&p1[ singly ]; } if ( !p ) 10fce7: 85 c0 test %eax,%eax 10fce9: 0f 84 8b 00 00 00 je 10fd7a <== NEVER TAKEN return 0; p = (block_p *)p[ doubly ]; 10fcef: 8b 04 b8 mov (%eax,%edi,4),%eax 10fcf2: eb 7c jmp 10fd70 } /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 10fcf4: 8d 50 01 lea 0x1(%eax),%edx 10fcf7: 0f af d1 imul %ecx,%edx 10fcfa: 4a dec %edx } /* * This means the requested block number is out of range. */ return 0; 10fcfb: 31 db xor %ebx,%ebx } /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 10fcfd: 39 d7 cmp %edx,%edi 10fcff: 77 79 ja 10fd7a <== NEVER TAKEN my_block -= FIRST_TRIPLY_INDIRECT; 10fd01: 29 c7 sub %eax,%edi 10fd03: 89 f8 mov %edi,%eax singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 10fd05: 31 d2 xor %edx,%edx 10fd07: f7 f1 div %ecx 10fd09: 89 55 e4 mov %edx,-0x1c(%ebp) doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; 10fd0c: 31 d2 xor %edx,%edx 10fd0e: f7 f1 div %ecx 10fd10: 89 55 e0 mov %edx,-0x20(%ebp) 10fd13: 89 c7 mov %eax,%edi doubly %= IMFS_MEMFILE_BLOCK_SLOTS; p = info->triply_indirect; 10fd15: 8b 46 60 mov 0x60(%esi),%eax if ( malloc_it ) { 10fd18: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10fd1c: 74 41 je 10fd5f if ( !p ) { 10fd1e: 85 c0 test %eax,%eax 10fd20: 75 0c jne 10fd2e p = memfile_alloc_block(); 10fd22: e8 ff fe ff ff call 10fc26 if ( !p ) 10fd27: 85 c0 test %eax,%eax 10fd29: 74 4f je 10fd7a <== NEVER TAKEN return 0; info->triply_indirect = p; 10fd2b: 89 46 60 mov %eax,0x60(%esi) } p1 = (block_p *) p[ triply ]; 10fd2e: 8d 34 b8 lea (%eax,%edi,4),%esi 10fd31: 8b 06 mov (%esi),%eax if ( !p1 ) { 10fd33: 85 c0 test %eax,%eax 10fd35: 75 0d jne 10fd44 p1 = memfile_alloc_block(); 10fd37: e8 ea fe ff ff call 10fc26 if ( !p1 ) return 0; 10fd3c: 31 db xor %ebx,%ebx } p1 = (block_p *) p[ triply ]; if ( !p1 ) { p1 = memfile_alloc_block(); if ( !p1 ) 10fd3e: 85 c0 test %eax,%eax 10fd40: 74 38 je 10fd7a <== NEVER TAKEN return 0; p[ triply ] = (block_p) p1; 10fd42: 89 06 mov %eax,(%esi) } p2 = (block_p *)p1[ doubly ]; 10fd44: 8b 55 e0 mov -0x20(%ebp),%edx 10fd47: 8d 34 90 lea (%eax,%edx,4),%esi 10fd4a: 8b 06 mov (%esi),%eax if ( !p2 ) { 10fd4c: 85 c0 test %eax,%eax 10fd4e: 75 24 jne 10fd74 p2 = memfile_alloc_block(); 10fd50: e8 d1 fe ff ff call 10fc26 if ( !p2 ) return 0; 10fd55: 31 db xor %ebx,%ebx } p2 = (block_p *)p1[ doubly ]; if ( !p2 ) { p2 = memfile_alloc_block(); if ( !p2 ) 10fd57: 85 c0 test %eax,%eax 10fd59: 74 1f je 10fd7a <== NEVER TAKEN return 0; p1[ doubly ] = (block_p) p2; 10fd5b: 89 06 mov %eax,(%esi) 10fd5d: eb 15 jmp 10fd74 } return (block_p *)&p2[ singly ]; } if ( !p ) 10fd5f: 85 c0 test %eax,%eax 10fd61: 74 17 je 10fd7a <== NEVER TAKEN return 0; p1 = (block_p *) p[ triply ]; 10fd63: 8b 04 b8 mov (%eax,%edi,4),%eax if ( !p1 ) 10fd66: 85 c0 test %eax,%eax 10fd68: 74 10 je 10fd7a <== NEVER TAKEN return 0; p2 = (block_p *)p1[ doubly ]; 10fd6a: 8b 55 e0 mov -0x20(%ebp),%edx 10fd6d: 8b 04 90 mov (%eax,%edx,4),%eax if ( !p2 ) 10fd70: 85 c0 test %eax,%eax 10fd72: 74 06 je 10fd7a <== NEVER TAKEN return 0; return (block_p *)&p2[ singly ]; 10fd74: 8b 55 e4 mov -0x1c(%ebp),%edx 10fd77: 8d 1c 90 lea (%eax,%edx,4),%ebx /* * This means the requested block number is out of range. */ return 0; } 10fd7a: 89 d8 mov %ebx,%eax 10fd7c: 83 c4 1c add $0x1c,%esp 10fd7f: 5b pop %ebx 10fd80: 5e pop %esi 10fd81: 5f pop %edi 10fd82: c9 leave 10fd83: c3 ret =============================================================================== 0010fd84 : IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) { 10fd84: 55 push %ebp 10fd85: 89 e5 mov %esp,%ebp 10fd87: 57 push %edi 10fd88: 56 push %esi 10fd89: 53 push %ebx 10fd8a: 83 ec 4c sub $0x4c,%esp 10fd8d: 8b 75 0c mov 0xc(%ebp),%esi 10fd90: 8b 7d 10 mov 0x10(%ebp),%edi 10fd93: 8b 5d 18 mov 0x18(%ebp),%ebx * 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) { 10fd96: 8b 45 08 mov 0x8(%ebp),%eax 10fd99: 83 78 4c 06 cmpl $0x6,0x4c(%eax) 10fd9d: 75 3f jne 10fdde unsigned char *file_ptr; file_ptr = (unsigned char *)the_jnode->info.linearfile.direct; 10fd9f: 8b 48 58 mov 0x58(%eax),%ecx if (my_length > (the_jnode->info.linearfile.size - start)) 10fda2: 89 c2 mov %eax,%edx 10fda4: 8b 40 50 mov 0x50(%eax),%eax 10fda7: 8b 52 54 mov 0x54(%edx),%edx 10fdaa: 89 45 b0 mov %eax,-0x50(%ebp) 10fdad: 89 55 b4 mov %edx,-0x4c(%ebp) 10fdb0: 29 f0 sub %esi,%eax 10fdb2: 19 fa sbb %edi,%edx 10fdb4: 89 45 d0 mov %eax,-0x30(%ebp) 10fdb7: 89 55 d4 mov %edx,-0x2c(%ebp) 10fdba: 31 c0 xor %eax,%eax 10fdbc: 39 d0 cmp %edx,%eax 10fdbe: 7c 0e jl 10fdce <== NEVER TAKEN 10fdc0: 7f 05 jg 10fdc7 <== NEVER TAKEN 10fdc2: 3b 5d d0 cmp -0x30(%ebp),%ebx 10fdc5: 76 07 jbe 10fdce <== NEVER TAKEN my_length = the_jnode->info.linearfile.size - start; 10fdc7: 8b 55 b0 mov -0x50(%ebp),%edx 10fdca: 29 f2 sub %esi,%edx 10fdcc: eb 02 jmp 10fdd0 /* * Linear files (as created from a tar file are easier to handle * than block files). */ my_length = length; 10fdce: 89 da mov %ebx,%edx <== 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); 10fdd0: 01 ce add %ecx,%esi 10fdd2: 8b 7d 14 mov 0x14(%ebp),%edi 10fdd5: 89 d1 mov %edx,%ecx 10fdd7: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10fdd9: e9 1d 01 00 00 jmp 10fefb /* * 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; 10fdde: 89 f0 mov %esi,%eax if ( last_byte > the_jnode->info.file.size ) 10fde0: 8b 55 08 mov 0x8(%ebp),%edx 10fde3: 8b 52 50 mov 0x50(%edx),%edx 10fde6: 89 55 cc mov %edx,-0x34(%ebp) /* * 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; 10fde9: 8d 0c 33 lea (%ebx,%esi,1),%ecx 10fdec: 89 4d d0 mov %ecx,-0x30(%ebp) if ( last_byte > the_jnode->info.file.size ) 10fdef: 31 c9 xor %ecx,%ecx 10fdf1: 8b 55 08 mov 0x8(%ebp),%edx 10fdf4: 3b 4a 54 cmp 0x54(%edx),%ecx 10fdf7: 7c 14 jl 10fe0d <== NEVER TAKEN 10fdf9: 7f 08 jg 10fe03 <== NEVER TAKEN 10fdfb: 8b 4d cc mov -0x34(%ebp),%ecx 10fdfe: 39 4d d0 cmp %ecx,-0x30(%ebp) 10fe01: 76 0a jbe 10fe0d my_length = the_jnode->info.file.size - start; 10fe03: 8b 55 cc mov -0x34(%ebp),%edx 10fe06: 29 c2 sub %eax,%edx 10fe08: 89 55 d0 mov %edx,-0x30(%ebp) 10fe0b: eb 03 jmp 10fe10 /* * Linear files (as created from a tar file are easier to handle * than block files). */ my_length = length; 10fe0d: 89 5d d0 mov %ebx,-0x30(%ebp) */ /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 10fe10: 8b 0d ec 4e 12 00 mov 0x124eec,%ecx 10fe16: 89 4d c4 mov %ecx,-0x3c(%ebp) 10fe19: 89 c8 mov %ecx,%eax 10fe1b: 99 cltd 10fe1c: 89 d3 mov %edx,%ebx 10fe1e: 52 push %edx 10fe1f: 51 push %ecx 10fe20: 57 push %edi 10fe21: 56 push %esi 10fe22: 89 4d c0 mov %ecx,-0x40(%ebp) 10fe25: e8 e2 cc 00 00 call 11cb0c <__moddi3> 10fe2a: 83 c4 10 add $0x10,%esp 10fe2d: 89 45 cc mov %eax,-0x34(%ebp) block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 10fe30: 8b 4d c0 mov -0x40(%ebp),%ecx 10fe33: 53 push %ebx 10fe34: 51 push %ecx 10fe35: 57 push %edi 10fe36: 56 push %esi 10fe37: e8 84 cb 00 00 call 11c9c0 <__divdi3> 10fe3c: 83 c4 10 add $0x10,%esp 10fe3f: 89 c3 mov %eax,%ebx if ( start_offset ) { 10fe41: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 10fe45: 74 3d je 10fe84 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 ); 10fe47: 57 push %edi 10fe48: 6a 00 push $0x0 10fe4a: 50 push %eax 10fe4b: ff 75 08 pushl 0x8(%ebp) 10fe4e: e8 f5 fd ff ff call 10fc48 if ( !block_ptr ) 10fe53: 83 c4 10 add $0x10,%esp return copied; 10fe56: 31 d2 xor %edx,%edx 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 ); if ( !block_ptr ) 10fe58: 85 c0 test %eax,%eax 10fe5a: 0f 84 ba 00 00 00 je 10ff1a <== 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; 10fe60: 8b 4d c4 mov -0x3c(%ebp),%ecx 10fe63: 2b 4d cc sub -0x34(%ebp),%ecx 10fe66: 8b 55 d0 mov -0x30(%ebp),%edx 10fe69: 39 ca cmp %ecx,%edx 10fe6b: 76 02 jbe 10fe6f 10fe6d: 89 ca mov %ecx,%edx 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 ); 10fe6f: 8b 75 cc mov -0x34(%ebp),%esi 10fe72: 03 30 add (%eax),%esi dest += to_copy; 10fe74: 8b 7d 14 mov 0x14(%ebp),%edi 10fe77: 89 d1 mov %edx,%ecx 10fe79: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10fe7b: 89 7d cc mov %edi,-0x34(%ebp) block++; 10fe7e: 43 inc %ebx my_length -= to_copy; 10fe7f: 29 55 d0 sub %edx,-0x30(%ebp) 10fe82: eb 08 jmp 10fe8c unsigned int last_byte; unsigned int copied; unsigned int start_offset; unsigned char *dest; dest = destination; 10fe84: 8b 45 14 mov 0x14(%ebp),%eax 10fe87: 89 45 cc mov %eax,-0x34(%ebp) */ last_byte = start + length; if ( last_byte > the_jnode->info.file.size ) my_length = the_jnode->info.file.size - start; copied = 0; 10fe8a: 31 d2 xor %edx,%edx } /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 10fe8c: 8b 0d ec 4e 12 00 mov 0x124eec,%ecx 10fe92: 89 4d c8 mov %ecx,-0x38(%ebp) while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 10fe95: eb 2f jmp 10fec6 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 10fe97: 56 push %esi 10fe98: 6a 00 push $0x0 10fe9a: 53 push %ebx 10fe9b: ff 75 08 pushl 0x8(%ebp) 10fe9e: 89 55 c0 mov %edx,-0x40(%ebp) 10fea1: e8 a2 fd ff ff call 10fc48 if ( !block_ptr ) 10fea6: 83 c4 10 add $0x10,%esp 10fea9: 85 c0 test %eax,%eax 10feab: 8b 55 c0 mov -0x40(%ebp),%edx 10feae: 74 6a je 10ff1a <== NEVER TAKEN return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); 10feb0: 8b 30 mov (%eax),%esi 10feb2: 8b 7d cc mov -0x34(%ebp),%edi 10feb5: 8b 4d c8 mov -0x38(%ebp),%ecx 10feb8: f3 a4 rep movsb %ds:(%esi),%es:(%edi) dest += to_copy; 10feba: 89 7d cc mov %edi,-0x34(%ebp) block++; 10febd: 43 inc %ebx my_length -= to_copy; 10febe: 8b 7d c8 mov -0x38(%ebp),%edi 10fec1: 29 7d d0 sub %edi,-0x30(%ebp) copied += to_copy; 10fec4: 01 fa add %edi,%edx /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 10fec6: 8b 45 d0 mov -0x30(%ebp),%eax 10fec9: 3b 05 ec 4e 12 00 cmp 0x124eec,%eax 10fecf: 73 c6 jae 10fe97 /* * Phase 3: possibly the first part of one block */ IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { 10fed1: 85 c0 test %eax,%eax 10fed3: 74 26 je 10fefb block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 10fed5: 51 push %ecx 10fed6: 6a 00 push $0x0 10fed8: 53 push %ebx 10fed9: ff 75 08 pushl 0x8(%ebp) 10fedc: 89 55 c0 mov %edx,-0x40(%ebp) 10fedf: e8 64 fd ff ff call 10fc48 if ( !block_ptr ) 10fee4: 83 c4 10 add $0x10,%esp 10fee7: 85 c0 test %eax,%eax 10fee9: 8b 55 c0 mov -0x40(%ebp),%edx 10feec: 74 2c je 10ff1a <== NEVER TAKEN return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); 10feee: 8b 30 mov (%eax),%esi 10fef0: 8b 7d cc mov -0x34(%ebp),%edi 10fef3: 8b 4d d0 mov -0x30(%ebp),%ecx 10fef6: f3 a4 rep movsb %ds:(%esi),%es:(%edi) copied += my_length; 10fef8: 03 55 d0 add -0x30(%ebp),%edx } IMFS_update_atime( the_jnode ); 10fefb: 50 push %eax 10fefc: 50 push %eax 10fefd: 6a 00 push $0x0 10feff: 8d 45 e0 lea -0x20(%ebp),%eax 10ff02: 50 push %eax 10ff03: 89 55 c0 mov %edx,-0x40(%ebp) 10ff06: e8 e5 74 ff ff call 1073f0 10ff0b: 8b 45 e0 mov -0x20(%ebp),%eax 10ff0e: 8b 4d 08 mov 0x8(%ebp),%ecx 10ff11: 89 41 40 mov %eax,0x40(%ecx) return copied; 10ff14: 8b 55 c0 mov -0x40(%ebp),%edx 10ff17: 83 c4 10 add $0x10,%esp } 10ff1a: 89 d0 mov %edx,%eax 10ff1c: 8d 65 f4 lea -0xc(%ebp),%esp 10ff1f: 5b pop %ebx 10ff20: 5e pop %esi 10ff21: 5f pop %edi 10ff22: c9 leave 10ff23: c3 ret =============================================================================== 0010ffe2 : * is better to stick to simple, easy to understand algorithms. */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) { 10ffe2: 55 push %ebp 10ffe3: 89 e5 mov %esp,%ebp 10ffe5: 57 push %edi 10ffe6: 56 push %esi 10ffe7: 53 push %ebx 10ffe8: 83 ec 1c sub $0x1c,%esp 10ffeb: 8b 5d 08 mov 0x8(%ebp),%ebx /* * 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; 10ffee: 8b 35 ec 4e 12 00 mov 0x124eec,%esi 10fff4: c1 ee 02 shr $0x2,%esi * + doubly indirect * + triply indirect */ info = &the_jnode->info.file; if ( info->indirect ) { 10fff7: 83 7b 58 00 cmpl $0x0,0x58(%ebx) 10fffb: 74 0f je 11000c memfile_free_blocks_in_table( &info->indirect, to_free ); 10fffd: 57 push %edi 10fffe: 57 push %edi 10ffff: 56 push %esi 110000: 8d 43 58 lea 0x58(%ebx),%eax 110003: 50 push %eax 110004: e8 8c ff ff ff call 10ff95 110009: 83 c4 10 add $0x10,%esp } if ( info->doubly_indirect ) { 11000c: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx) 110010: 74 3e je 110050 110012: 31 ff xor %edi,%edi 110014: eb 1f jmp 110035 for ( i=0 ; idoubly_indirect[i] ) { 110016: 8b 43 5c mov 0x5c(%ebx),%eax 110019: 8d 14 bd 00 00 00 00 lea 0x0(,%edi,4),%edx 110020: 83 3c b8 00 cmpl $0x0,(%eax,%edi,4) 110024: 74 0e je 110034 <== NEVER TAKEN memfile_free_blocks_in_table( 110026: 51 push %ecx 110027: 51 push %ecx 110028: 56 push %esi 110029: 01 d0 add %edx,%eax 11002b: 50 push %eax 11002c: e8 64 ff ff ff call 10ff95 110031: 83 c4 10 add $0x10,%esp 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 ); 110041: 57 push %edi 110042: 57 push %edi 110043: 56 push %esi 110044: 8d 43 5c lea 0x5c(%ebx),%eax 110047: 50 push %eax 110048: e8 48 ff ff ff call 10ff95 11004d: 83 c4 10 add $0x10,%esp } if ( info->triply_indirect ) { 110050: 83 7b 60 00 cmpl $0x0,0x60(%ebx) 110054: 74 78 je 1100ce 110056: 31 ff xor %edi,%edi 110058: eb 59 jmp 1100b3 11005a: 8d 04 bd 00 00 00 00 lea 0x0(,%edi,4),%eax 110061: 89 45 e4 mov %eax,-0x1c(%ebp) for ( i=0 ; itriply_indirect[i]; 110064: 8b 43 60 mov 0x60(%ebx),%eax 110067: 8b 04 b8 mov (%eax,%edi,4),%eax if ( !p ) /* ensure we have a valid pointer */ 11006a: 85 c0 test %eax,%eax 11006c: 74 51 je 1100bf <== NEVER TAKEN 11006e: 31 d2 xor %edx,%edx 110070: eb 21 jmp 110093 break; for ( j=0 ; j<== NEVER TAKEN memfile_free_blocks_in_table( (block_p **)&p[j], to_free); 110077: 51 push %ecx 110078: 51 push %ecx 110079: 56 push %esi 11007a: 50 push %eax 11007b: 89 45 dc mov %eax,-0x24(%ebp) 11007e: 89 55 e0 mov %edx,-0x20(%ebp) 110081: e8 0f ff ff ff call 10ff95 110086: 83 c4 10 add $0x10,%esp 110089: 8b 55 e0 mov -0x20(%ebp),%edx 11008c: 8b 45 dc mov -0x24(%ebp),%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( 1100a0: 52 push %edx 1100a1: 52 push %edx 1100a2: 56 push %esi 1100a3: 8b 45 e4 mov -0x1c(%ebp),%eax 1100a6: 03 43 60 add 0x60(%ebx),%eax 1100a9: 50 push %eax 1100aa: e8 e6 fe ff ff call 10ff95 memfile_free_blocks_in_table( &info->doubly_indirect, to_free ); } if ( info->triply_indirect ) { for ( i=0 ; i } } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( 1100bf: 50 push %eax 1100c0: 50 push %eax 1100c1: 56 push %esi (block_p **)&info->triply_indirect, to_free ); 1100c2: 83 c3 60 add $0x60,%ebx } } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( 1100c5: 53 push %ebx 1100c6: e8 ca fe ff ff call 10ff95 1100cb: 83 c4 10 add $0x10,%esp (block_p **)&info->triply_indirect, to_free ); } return 0; } 1100ce: 31 c0 xor %eax,%eax 1100d0: 8d 65 f4 lea -0xc(%ebp),%esp 1100d3: 5b pop %ebx 1100d4: 5e pop %esi 1100d5: 5f pop %edi 1100d6: c9 leave 1100d7: c3 ret =============================================================================== 001101f4 : IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 1101f4: 55 push %ebp 1101f5: 89 e5 mov %esp,%ebp 1101f7: 57 push %edi 1101f8: 56 push %esi 1101f9: 53 push %ebx 1101fa: 83 ec 2c sub $0x2c,%esp 1101fd: 8b 75 0c mov 0xc(%ebp),%esi 110200: 8b 7d 10 mov 0x10(%ebp),%edi /* * 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; 110203: 8b 4d 18 mov 0x18(%ebp),%ecx 110206: 01 f1 add %esi,%ecx if ( last_byte > the_jnode->info.file.size ) { 110208: 89 c8 mov %ecx,%eax 11020a: 31 d2 xor %edx,%edx 11020c: 8b 5d 08 mov 0x8(%ebp),%ebx 11020f: 3b 53 54 cmp 0x54(%ebx),%edx 110212: 7c 2c jl 110240 <== NEVER TAKEN 110214: 7f 05 jg 11021b <== NEVER TAKEN 110216: 3b 4b 50 cmp 0x50(%ebx),%ecx 110219: 76 25 jbe 110240 <== NEVER TAKEN status = IMFS_memfile_extend( the_jnode, last_byte ); 11021b: 51 push %ecx 11021c: 52 push %edx 11021d: 50 push %eax 11021e: ff 75 08 pushl 0x8(%ebp) 110221: e8 dc fe ff ff call 110102 if ( status ) 110226: 83 c4 10 add $0x10,%esp 110229: 85 c0 test %eax,%eax 11022b: 74 13 je 110240 rtems_set_errno_and_return_minus_one( ENOSPC ); 11022d: e8 06 0f 00 00 call 111138 <__errno> 110232: c7 00 1c 00 00 00 movl $0x1c,(%eax) 110238: 83 c9 ff or $0xffffffff,%ecx 11023b: e9 0f 01 00 00 jmp 11034f */ /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 110240: a1 ec 4e 12 00 mov 0x124eec,%eax 110245: 89 45 cc mov %eax,-0x34(%ebp) 110248: 99 cltd 110249: 89 d3 mov %edx,%ebx 11024b: 52 push %edx 11024c: 50 push %eax 11024d: 57 push %edi 11024e: 56 push %esi 11024f: 89 45 c8 mov %eax,-0x38(%ebp) 110252: e8 b5 c8 00 00 call 11cb0c <__moddi3> 110257: 83 c4 10 add $0x10,%esp 11025a: 89 45 d0 mov %eax,-0x30(%ebp) block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 11025d: 8b 4d c8 mov -0x38(%ebp),%ecx 110260: 53 push %ebx 110261: 51 push %ecx 110262: 57 push %edi 110263: 56 push %esi 110264: e8 57 c7 00 00 call 11c9c0 <__divdi3> 110269: 83 c4 10 add $0x10,%esp 11026c: 89 c3 mov %eax,%ebx if ( start_offset ) { 11026e: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 110272: 74 40 je 1102b4 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 ); 110274: 52 push %edx 110275: 6a 00 push $0x0 110277: 53 push %ebx 110278: ff 75 08 pushl 0x8(%ebp) 11027b: e8 c8 f9 ff ff call 10fc48 if ( !block_ptr ) 110280: 83 c4 10 add $0x10,%esp return copied; 110283: 31 c9 xor %ecx,%ecx 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 ); if ( !block_ptr ) 110285: 85 c0 test %eax,%eax 110287: 0f 84 c2 00 00 00 je 11034f <== 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; 11028d: 8b 55 cc mov -0x34(%ebp),%edx 110290: 2b 55 d0 sub -0x30(%ebp),%edx 110293: 3b 55 18 cmp 0x18(%ebp),%edx 110296: 76 03 jbe 11029b 110298: 8b 55 18 mov 0x18(%ebp),%edx block, to_copy, src ); #endif memcpy( &(*block_ptr)[ start_offset ], src, to_copy ); 11029b: 8b 00 mov (%eax),%eax 11029d: 03 45 d0 add -0x30(%ebp),%eax src += to_copy; 1102a0: 89 c7 mov %eax,%edi 1102a2: 8b 75 14 mov 0x14(%ebp),%esi 1102a5: 89 d1 mov %edx,%ecx 1102a7: f3 a4 rep movsb %ds:(%esi),%es:(%edi) block++; 1102a9: 43 inc %ebx my_length -= to_copy; 1102aa: 8b 4d 18 mov 0x18(%ebp),%ecx 1102ad: 29 d1 sub %edx,%ecx 1102af: 89 4d d4 mov %ecx,-0x2c(%ebp) 1102b2: eb 0b jmp 1102bf unsigned int last_byte; unsigned int start_offset; int copied; const unsigned char *src; src = source; 1102b4: 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 ) { 1102b7: 8b 45 18 mov 0x18(%ebp),%eax 1102ba: 89 45 d4 mov %eax,-0x2c(%ebp) status = IMFS_memfile_extend( the_jnode, last_byte ); if ( status ) rtems_set_errno_and_return_minus_one( ENOSPC ); } copied = 0; 1102bd: 31 d2 xor %edx,%edx /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 1102bf: 8b 0d ec 4e 12 00 mov 0x124eec,%ecx 1102c5: 89 4d d0 mov %ecx,-0x30(%ebp) while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 1102c8: eb 2b jmp 1102f5 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 1102ca: 50 push %eax 1102cb: 6a 00 push $0x0 1102cd: 53 push %ebx 1102ce: ff 75 08 pushl 0x8(%ebp) 1102d1: 89 55 c8 mov %edx,-0x38(%ebp) 1102d4: e8 6f f9 ff ff call 10fc48 if ( !block_ptr ) 1102d9: 83 c4 10 add $0x10,%esp 1102dc: 85 c0 test %eax,%eax 1102de: 8b 55 c8 mov -0x38(%ebp),%edx 1102e1: 74 6a je 11034d <== 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, to_copy ); 1102e3: 8b 00 mov (%eax),%eax src += to_copy; 1102e5: 89 c7 mov %eax,%edi 1102e7: 8b 4d d0 mov -0x30(%ebp),%ecx 1102ea: f3 a4 rep movsb %ds:(%esi),%es:(%edi) block++; 1102ec: 43 inc %ebx my_length -= to_copy; 1102ed: 8b 45 d0 mov -0x30(%ebp),%eax 1102f0: 29 45 d4 sub %eax,-0x2c(%ebp) * 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( 1102f3: 01 c2 add %eax,%edx /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 1102f5: 8b 4d d4 mov -0x2c(%ebp),%ecx 1102f8: 3b 0d ec 4e 12 00 cmp 0x124eec,%ecx 1102fe: 73 ca jae 1102ca * 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 ) { 110300: 85 c9 test %ecx,%ecx 110302: 74 27 je 11032b block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 110304: 57 push %edi 110305: 6a 00 push $0x0 110307: 53 push %ebx 110308: ff 75 08 pushl 0x8(%ebp) 11030b: 89 55 c8 mov %edx,-0x38(%ebp) 11030e: e8 35 f9 ff ff call 10fc48 if ( !block_ptr ) 110313: 83 c4 10 add $0x10,%esp 110316: 8b 55 c8 mov -0x38(%ebp),%edx 110319: 89 d1 mov %edx,%ecx 11031b: 85 c0 test %eax,%eax 11031d: 74 30 je 11034f <== 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 ); 11031f: 8b 00 mov (%eax),%eax 110321: 89 c7 mov %eax,%edi 110323: 8b 4d d4 mov -0x2c(%ebp),%ecx 110326: f3 a4 rep movsb %ds:(%esi),%es:(%edi) my_length = 0; copied += to_copy; 110328: 03 55 d4 add -0x2c(%ebp),%edx } IMFS_mtime_ctime_update( the_jnode ); 11032b: 53 push %ebx 11032c: 53 push %ebx 11032d: 6a 00 push $0x0 11032f: 8d 45 e0 lea -0x20(%ebp),%eax 110332: 50 push %eax 110333: 89 55 c8 mov %edx,-0x38(%ebp) 110336: e8 b5 70 ff ff call 1073f0 11033b: 8b 45 e0 mov -0x20(%ebp),%eax 11033e: 8b 5d 08 mov 0x8(%ebp),%ebx 110341: 89 43 44 mov %eax,0x44(%ebx) 110344: 89 43 48 mov %eax,0x48(%ebx) return copied; 110347: 83 c4 10 add $0x10,%esp 11034a: 8b 55 c8 mov -0x38(%ebp),%edx */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); if ( !block_ptr ) 11034d: 89 d1 mov %edx,%ecx } IMFS_mtime_ctime_update( the_jnode ); return copied; } 11034f: 89 c8 mov %ecx,%eax 110351: 8d 65 f4 lea -0xc(%ebp),%esp 110354: 5b pop %ebx 110355: 5e pop %esi 110356: 5f pop %edi 110357: c9 leave 110358: c3 ret =============================================================================== 00106dc0 : #include int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 106dc0: 55 push %ebp 106dc1: 89 e5 mov %esp,%ebp 106dc3: 83 ec 08 sub $0x8,%esp 106dc6: 8b 55 08 mov 0x8(%ebp),%edx IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 106dc9: 8b 42 08 mov 0x8(%edx),%eax /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 106dcc: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 106dd0: 74 10 je 106de2 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTDIR ); 106dd2: e8 61 a3 00 00 call 111138 <__errno> <== NOT EXECUTED 106dd7: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 106ddd: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 106de0: eb 05 jmp 106de7 <== NOT EXECUTED /* * Set mt_fs pointer to point to the mount table entry for * the mounted file system. */ node->info.directory.mt_fs = mt_entry; 106de2: 89 50 5c mov %edx,0x5c(%eax) return 0; 106de5: 31 c0 xor %eax,%eax } 106de7: c9 leave 106de8: c3 ret =============================================================================== 00109558 : * This routine prints the contents of the specified jnode. */ void IMFS_print_jnode( IMFS_jnode_t *the_jnode ) { 109558: 55 push %ebp 109559: 89 e5 mov %esp,%ebp 10955b: 53 push %ebx 10955c: 83 ec 0c sub $0xc,%esp 10955f: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_assert( the_jnode ); fprintf(stdout, "%s", the_jnode->name ); 109562: a1 20 99 12 00 mov 0x129920,%eax 109567: ff 70 08 pushl 0x8(%eax) 10956a: 8d 43 0c lea 0xc(%ebx),%eax 10956d: 50 push %eax 10956e: e8 39 be 00 00 call 1153ac switch( the_jnode->type ) { 109573: 8b 43 4c mov 0x4c(%ebx),%eax 109576: 83 c4 10 add $0x10,%esp 109579: 8d 50 ff lea -0x1(%eax),%edx 10957c: 83 fa 06 cmp $0x6,%edx 10957f: 77 75 ja 1095f6 <== NEVER TAKEN 109581: a1 20 99 12 00 mov 0x129920,%eax 109586: ff 24 95 3c 49 12 00 jmp *0x12493c(,%edx,4) case IMFS_DIRECTORY: fprintf(stdout, "/" ); 10958d: 51 push %ecx 10958e: 51 push %ecx 10958f: ff 70 08 pushl 0x8(%eax) 109592: 6a 2f push $0x2f 109594: e8 67 bd 00 00 call 115300 109599: eb 2b jmp 1095c6 break; case IMFS_DEVICE: fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")", 10959b: ff 73 54 pushl 0x54(%ebx) 10959e: ff 73 50 pushl 0x50(%ebx) 1095a1: 68 61 48 12 00 push $0x124861 1095a6: eb 16 jmp 1095be the_jnode->info.device.major, the_jnode->info.device.minor ); break; case IMFS_LINEAR_FILE: fprintf(stdout, " (file %" PRId32 " %p)", 1095a8: ff 73 58 pushl 0x58(%ebx) 1095ab: ff 73 50 pushl 0x50(%ebx) 1095ae: 68 74 48 12 00 push $0x124874 1095b3: eb 09 jmp 1095be the_jnode->info.file.indirect, the_jnode->info.file.doubly_indirect, the_jnode->info.file.triply_indirect ); #else fprintf(stdout, " (file %" PRId32 ")", 1095b5: 52 push %edx 1095b6: ff 73 50 pushl 0x50(%ebx) 1095b9: 68 83 48 12 00 push $0x124883 1095be: ff 70 08 pushl 0x8(%eax) 1095c1: e8 da bc 00 00 call 1152a0 (uint32_t)the_jnode->info.file.size ); #endif break; 1095c6: 83 c4 10 add $0x10,%esp default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 1095c9: c7 45 08 6d 4b 12 00 movl $0x124b6d,0x8(%ebp) } 1095d0: 8b 5d fc mov -0x4(%ebp),%ebx 1095d3: c9 leave default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 1095d4: e9 8f d5 00 00 jmp 116b68 case IMFS_HARD_LINK: fprintf(stdout, " links not printed\n" ); return; case IMFS_SYM_LINK: fprintf(stdout, " links not printed\n" ); 1095d9: 53 push %ebx 1095da: 53 push %ebx 1095db: ff 70 08 pushl 0x8(%eax) 1095de: 68 8f 48 12 00 push $0x12488f 1095e3: eb 0a jmp 1095ef return; case IMFS_FIFO: fprintf(stdout, " FIFO not printed\n" ); 1095e5: 51 push %ecx 1095e6: 51 push %ecx 1095e7: ff 70 08 pushl 0x8(%eax) 1095ea: 68 a3 48 12 00 push $0x1248a3 1095ef: e8 b8 bd 00 00 call 1153ac 1095f4: eb 14 jmp 10960a return; default: fprintf(stdout, " bad type %d\n", the_jnode->type ); 1095f6: 52 push %edx <== NOT EXECUTED 1095f7: 50 push %eax <== NOT EXECUTED 1095f8: 68 b6 48 12 00 push $0x1248b6 <== NOT EXECUTED 1095fd: a1 20 99 12 00 mov 0x129920,%eax <== NOT EXECUTED 109602: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 109605: e8 96 bc 00 00 call 1152a0 <== NOT EXECUTED return; 10960a: 83 c4 10 add $0x10,%esp } puts(""); } 10960d: 8b 5d fc mov -0x4(%ebp),%ebx 109610: c9 leave 109611: c3 ret =============================================================================== 00106e28 : 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 */ ) { 106e28: 55 push %ebp 106e29: 89 e5 mov %esp,%ebp 106e2b: 53 push %ebx 106e2c: 83 ec 18 sub $0x18,%esp IMFS_jnode_t *the_jnode; IMFS_jnode_t *new_parent; the_jnode = old_loc->node_access; 106e2f: 8b 45 0c mov 0xc(%ebp),%eax 106e32: 8b 18 mov (%eax),%ebx strncpy( the_jnode->name, new_name, IMFS_NAME_MAX ); 106e34: 6a 20 push $0x20 106e36: ff 75 14 pushl 0x14(%ebp) 106e39: 8d 43 0c lea 0xc(%ebx),%eax 106e3c: 50 push %eax 106e3d: e8 ca b1 00 00 call 11200c if ( the_jnode->Parent != NULL ) 106e42: 83 c4 10 add $0x10,%esp 106e45: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 106e49: 74 0c je 106e57 <== NEVER TAKEN */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 106e4b: 83 ec 0c sub $0xc,%esp 106e4e: 53 push %ebx 106e4f: e8 04 3c 00 00 call 10aa58 <_Chain_Extract> 106e54: 83 c4 10 add $0x10,%esp rtems_chain_extract( (rtems_chain_node *) the_jnode ); new_parent = new_parent_loc->node_access; 106e57: 8b 45 10 mov 0x10(%ebp),%eax 106e5a: 8b 00 mov (%eax),%eax the_jnode->Parent = new_parent; 106e5c: 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 ); 106e5f: 51 push %ecx 106e60: 51 push %ecx 106e61: 53 push %ebx rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node ); 106e62: 83 c0 50 add $0x50,%eax 106e65: 50 push %eax 106e66: e8 c9 3b 00 00 call 10aa34 <_Chain_Append> /* * Update the time. */ IMFS_update_ctime( the_jnode ); 106e6b: 58 pop %eax 106e6c: 5a pop %edx 106e6d: 6a 00 push $0x0 106e6f: 8d 45 f0 lea -0x10(%ebp),%eax 106e72: 50 push %eax 106e73: e8 78 05 00 00 call 1073f0 106e78: 8b 45 f0 mov -0x10(%ebp),%eax 106e7b: 89 43 48 mov %eax,0x48(%ebx) return 0; } 106e7e: 31 c0 xor %eax,%eax 106e80: 8b 5d fc mov -0x4(%ebp),%ebx 106e83: c9 leave 106e84: c3 ret =============================================================================== 0010dfa8 : int IMFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 10dfa8: 55 push %ebp 10dfa9: 89 e5 mov %esp,%ebp 10dfab: 56 push %esi 10dfac: 53 push %ebx 10dfad: 8b 4d 08 mov 0x8(%ebp),%ecx 10dfb0: 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; 10dfb3: 8b 11 mov (%ecx),%edx switch ( the_jnode->type ) { 10dfb5: 8b 5a 4c mov 0x4c(%edx),%ebx 10dfb8: 83 eb 02 sub $0x2,%ebx 10dfbb: 83 fb 05 cmp $0x5,%ebx 10dfbe: 77 33 ja 10dff3 <== NEVER TAKEN 10dfc0: ff 24 9d dc f4 11 00 jmp *0x11f4dc(,%ebx,4) case IMFS_DEVICE: io = &the_jnode->info.device; buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor ); 10dfc7: 8b 5a 54 mov 0x54(%edx),%ebx rtems_device_minor_number _minor ) { union __rtems_dev_t temp; temp.__overlay.major = _major; 10dfca: 8b 72 50 mov 0x50(%edx),%esi 10dfcd: 89 70 18 mov %esi,0x18(%eax) 10dfd0: 89 58 1c mov %ebx,0x1c(%eax) break; 10dfd3: eb 2e jmp 10e003 case IMFS_LINEAR_FILE: case IMFS_MEMORY_FILE: buf->st_size = the_jnode->info.file.size; 10dfd5: 8b 5a 50 mov 0x50(%edx),%ebx 10dfd8: 8b 72 54 mov 0x54(%edx),%esi 10dfdb: 89 58 20 mov %ebx,0x20(%eax) 10dfde: 89 70 24 mov %esi,0x24(%eax) break; 10dfe1: eb 20 jmp 10e003 case IMFS_SYM_LINK: buf->st_size = 0; break; case IMFS_FIFO: buf->st_size = 0; 10dfe3: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) 10dfea: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) break; 10dff1: eb 10 jmp 10e003 default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 10dff3: e8 40 31 00 00 call 111138 <__errno> 10dff8: c7 00 86 00 00 00 movl $0x86,(%eax) 10dffe: 83 c8 ff or $0xffffffff,%eax 10e001: eb 47 jmp 10e04a /* * The device number of the IMFS is the major number and the minor is the * instance. */ fs_info = loc->mt_entry->fs_info; 10e003: 8b 49 10 mov 0x10(%ecx),%ecx buf->st_dev = rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance ); 10e006: 8b 49 34 mov 0x34(%ecx),%ecx 10e009: 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 = 10e00b: c7 00 fe ff 00 00 movl $0xfffe,(%eax) 10e011: 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; 10e014: 8b 4a 30 mov 0x30(%edx),%ecx 10e017: 89 48 0c mov %ecx,0xc(%eax) buf->st_nlink = the_jnode->st_nlink; 10e01a: 8b 4a 34 mov 0x34(%edx),%ecx 10e01d: 66 89 48 10 mov %cx,0x10(%eax) buf->st_ino = the_jnode->st_ino; 10e021: 8b 4a 38 mov 0x38(%edx),%ecx 10e024: 89 48 08 mov %ecx,0x8(%eax) buf->st_uid = the_jnode->st_uid; 10e027: 8b 4a 3c mov 0x3c(%edx),%ecx 10e02a: 66 89 48 12 mov %cx,0x12(%eax) buf->st_gid = the_jnode->st_gid; 10e02e: 66 8b 4a 3e mov 0x3e(%edx),%cx 10e032: 66 89 48 14 mov %cx,0x14(%eax) buf->st_atime = the_jnode->stat_atime; 10e036: 8b 4a 40 mov 0x40(%edx),%ecx 10e039: 89 48 28 mov %ecx,0x28(%eax) buf->st_mtime = the_jnode->stat_mtime; 10e03c: 8b 4a 44 mov 0x44(%edx),%ecx 10e03f: 89 48 30 mov %ecx,0x30(%eax) buf->st_ctime = the_jnode->stat_ctime; 10e042: 8b 52 48 mov 0x48(%edx),%edx 10e045: 89 50 38 mov %edx,0x38(%eax) return 0; 10e048: 31 c0 xor %eax,%eax } 10e04a: 5b pop %ebx 10e04b: 5e pop %esi 10e04c: c9 leave 10e04d: c3 ret =============================================================================== 00106f14 : int IMFS_unlink( rtems_filesystem_location_info_t *parentloc, /* IN */ rtems_filesystem_location_info_t *loc /* IN */ ) { 106f14: 55 push %ebp 106f15: 89 e5 mov %esp,%ebp 106f17: 57 push %edi 106f18: 56 push %esi 106f19: 53 push %ebx 106f1a: 83 ec 2c sub $0x2c,%esp IMFS_jnode_t *node; rtems_filesystem_location_info_t the_link; int result = 0; node = loc->node_access; 106f1d: 8b 45 0c mov 0xc(%ebp),%eax 106f20: 8b 18 mov (%eax),%ebx /* * If this is the last last pointer to the node * free the node. */ if ( node->type == IMFS_HARD_LINK ) { 106f22: 83 7b 4c 03 cmpl $0x3,0x4c(%ebx) 106f26: 75 7a jne 106fa2 if ( !node->info.hard_link.link_node ) 106f28: 8b 43 50 mov 0x50(%ebx),%eax 106f2b: 85 c0 test %eax,%eax 106f2d: 75 10 jne 106f3f <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 106f2f: e8 04 a2 00 00 call 111138 <__errno> <== NOT EXECUTED 106f34: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 106f3a: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 106f3d: eb 75 jmp 106fb4 <== NOT EXECUTED the_link = *loc; 106f3f: 8d 7d cc lea -0x34(%ebp),%edi 106f42: b9 05 00 00 00 mov $0x5,%ecx 106f47: 8b 75 0c mov 0xc(%ebp),%esi 106f4a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_link.node_access = node->info.hard_link.link_node; 106f4c: 89 45 cc mov %eax,-0x34(%ebp) IMFS_Set_handlers( &the_link ); 106f4f: 83 ec 0c sub $0xc,%esp 106f52: 8d 75 cc lea -0x34(%ebp),%esi 106f55: 56 push %esi 106f56: e8 dd 67 00 00 call 10d738 /* * 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) 106f5b: 8b 43 50 mov 0x50(%ebx),%eax 106f5e: 8b 50 34 mov 0x34(%eax),%edx 106f61: 83 c4 10 add $0x10,%esp 106f64: 66 83 fa 01 cmp $0x1,%dx 106f68: 75 1a jne 106f84 { result = (*the_link.handlers->rmnod_h)( parentloc, &the_link ); 106f6a: 51 push %ecx 106f6b: 51 push %ecx 106f6c: 56 push %esi 106f6d: ff 75 08 pushl 0x8(%ebp) 106f70: 8b 45 d4 mov -0x2c(%ebp),%eax 106f73: ff 50 34 call *0x34(%eax) 106f76: 89 c2 mov %eax,%edx if ( result != 0 ) 106f78: 83 c4 10 add $0x10,%esp return -1; 106f7b: 83 c8 ff or $0xffffffff,%eax */ if ( node->info.hard_link.link_node->st_nlink == 1) { result = (*the_link.handlers->rmnod_h)( parentloc, &the_link ); if ( result != 0 ) 106f7e: 85 d2 test %edx,%edx 106f80: 74 20 je 106fa2 106f82: eb 30 jmp 106fb4 return -1; } else { node->info.hard_link.link_node->st_nlink --; 106f84: 4a dec %edx 106f85: 66 89 50 34 mov %dx,0x34(%eax) IMFS_update_ctime( node->info.hard_link.link_node ); 106f89: 52 push %edx 106f8a: 52 push %edx 106f8b: 6a 00 push $0x0 106f8d: 8d 45 e0 lea -0x20(%ebp),%eax 106f90: 50 push %eax 106f91: e8 5a 04 00 00 call 1073f0 106f96: 8b 43 50 mov 0x50(%ebx),%eax 106f99: 8b 55 e0 mov -0x20(%ebp),%edx 106f9c: 89 50 48 mov %edx,0x48(%eax) 106f9f: 83 c4 10 add $0x10,%esp /* * Now actually free the node we were asked to free. */ result = (*loc->handlers->rmnod_h)( parentloc, loc ); 106fa2: 50 push %eax 106fa3: 50 push %eax 106fa4: 8b 55 0c mov 0xc(%ebp),%edx 106fa7: 8b 42 08 mov 0x8(%edx),%eax 106faa: 52 push %edx 106fab: ff 75 08 pushl 0x8(%ebp) 106fae: ff 50 34 call *0x34(%eax) return result; 106fb1: 83 c4 10 add $0x10,%esp } 106fb4: 8d 65 f4 lea -0xc(%ebp),%esp 106fb7: 5b pop %ebx 106fb8: 5e pop %esi 106fb9: 5f pop %edi 106fba: c9 leave 106fbb: c3 ret =============================================================================== 00106fbc : #include int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 106fbc: 55 push %ebp 106fbd: 89 e5 mov %esp,%ebp 106fbf: 83 ec 08 sub $0x8,%esp IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 106fc2: 8b 45 08 mov 0x8(%ebp),%eax 106fc5: 8b 40 08 mov 0x8(%eax),%eax /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 106fc8: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 106fcc: 74 0d je 106fdb <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTDIR ); 106fce: e8 65 a1 00 00 call 111138 <__errno> <== NOT EXECUTED 106fd3: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 106fd9: eb 11 jmp 106fec <== NOT EXECUTED /* * Did the node indicate that there was a directory mounted here? */ if ( node->info.directory.mt_fs == NULL ) 106fdb: 83 78 5c 00 cmpl $0x0,0x5c(%eax) 106fdf: 75 10 jne 106ff1 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */ 106fe1: e8 52 a1 00 00 call 111138 <__errno> <== NOT EXECUTED 106fe6: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 106fec: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 106fef: eb 09 jmp 106ffa <== NOT EXECUTED /* * 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; 106ff1: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) return 0; 106ff8: 31 c0 xor %eax,%eax } 106ffa: c9 leave 106ffb: c3 ret =============================================================================== 00107148 : static rtems_printk_plugin_t print_handler; void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) { 107148: 55 push %ebp <== NOT EXECUTED 107149: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10714b: 57 push %edi <== NOT EXECUTED 10714c: 56 push %esi <== NOT EXECUTED 10714d: 53 push %ebx <== NOT EXECUTED 10714e: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 107151: 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) { 107154: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED 107157: 75 1d jne 107176 <== NOT EXECUTED if (!Stack_check_Interrupt_stack.area) 107159: 83 3d 3c 72 12 00 00 cmpl $0x0,0x12723c <== NOT EXECUTED 107160: 0f 84 f5 00 00 00 je 10725b <== NOT EXECUTED return; stack = &Stack_check_Interrupt_stack; 107166: ba 38 72 12 00 mov $0x127238,%edx <== NOT EXECUTED the_thread = 0; current = 0; 10716b: 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; 107172: 31 db xor %ebx,%ebx <== NOT EXECUTED 107174: eb 0f jmp 107185 <== NOT EXECUTED current = 0; } else #endif { stack = &the_thread->Start.Initial_stack; 107176: 8d 93 b8 00 00 00 lea 0xb8(%ebx),%edx <== NOT EXECUTED current = (void *)_CPU_Context_Get_SP( &the_thread->Registers ); 10717c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 107182: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED } low = Stack_check_usable_stack_start(stack); 107185: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 107188: 8d 48 10 lea 0x10(%eax),%ecx <== NOT EXECUTED size = Stack_check_usable_stack_size(stack); 10718b: 8b 32 mov (%edx),%esi <== NOT EXECUTED 10718d: 83 ee 10 sub $0x10,%esi <== NOT EXECUTED 107190: 89 75 d4 mov %esi,-0x2c(%ebp) <== NOT EXECUTED /* * start at lower memory and find first word that does not * match pattern */ base += PATTERN_SIZE_WORDS; 107193: 83 c0 20 add $0x20,%eax <== NOT EXECUTED for (ebase = base + length; base < ebase; base++) 107196: 83 e6 fc and $0xfffffffc,%esi <== NOT EXECUTED 107199: 8d 34 30 lea (%eax,%esi,1),%esi <== NOT EXECUTED 10719c: eb 0b jmp 1071a9 <== NOT EXECUTED if (*base != U32_PATTERN) 10719e: 81 38 a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%eax) <== NOT EXECUTED 1071a4: 75 0b jne 1071b1 <== 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++) 1071a6: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 1071a9: 39 f0 cmp %esi,%eax <== NOT EXECUTED 1071ab: 72 f1 jb 10719e <== 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; 1071ad: 31 ff xor %edi,%edi <== NOT EXECUTED 1071af: eb 0e jmp 1071bf <== NOT EXECUTED 1071b1: 31 ff xor %edi,%edi <== 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 ) 1071b3: 85 c0 test %eax,%eax <== NOT EXECUTED 1071b5: 74 08 je 1071bf <== NOT EXECUTED used = Stack_check_Calculate_used( low, size, high_water_mark ); 1071b7: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED 1071ba: 8d 3c 39 lea (%ecx,%edi,1),%edi <== NOT EXECUTED 1071bd: 29 c7 sub %eax,%edi <== NOT EXECUTED else used = 0; #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if ( the_thread ) 1071bf: 85 db test %ebx,%ebx <== NOT EXECUTED 1071c1: 8b 35 14 6f 12 00 mov 0x126f14,%esi <== NOT EXECUTED 1071c7: 74 28 je 1071f1 <== NOT EXECUTED #endif { (*print_handler)( 1071c9: 50 push %eax <== NOT EXECUTED 1071ca: 8d 45 e3 lea -0x1d(%ebp),%eax <== NOT EXECUTED 1071cd: 50 push %eax <== NOT EXECUTED 1071ce: 6a 05 push $0x5 <== NOT EXECUTED 1071d0: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 1071d3: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED 1071d6: e8 cd 53 00 00 call 10c5a8 <== NOT EXECUTED 1071db: 50 push %eax <== NOT EXECUTED 1071dc: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 1071df: 68 57 16 12 00 push $0x121657 <== NOT EXECUTED 1071e4: ff 35 10 6f 12 00 pushl 0x126f10 <== NOT EXECUTED 1071ea: ff d6 call *%esi <== NOT EXECUTED 1071ec: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1071ef: eb 16 jmp 107207 <== 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 ); 1071f1: 53 push %ebx <== NOT EXECUTED 1071f2: 6a ff push $0xffffffff <== NOT EXECUTED 1071f4: 68 64 16 12 00 push $0x121664 <== NOT EXECUTED 1071f9: ff 35 10 6f 12 00 pushl 0x126f10 <== NOT EXECUTED 1071ff: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED 107202: ff d6 call *%esi <== NOT EXECUTED 107204: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107207: 8b 55 cc mov -0x34(%ebp),%edx <== NOT EXECUTED (*print_handler)( print_context, " %010p - %010p %010p %8" PRId32 " ", stack->area, stack->area + stack->size - 1, 10720a: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); } #endif (*print_handler)( 10720d: 51 push %ecx <== NOT EXECUTED 10720e: 51 push %ecx <== NOT EXECUTED 10720f: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 107212: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED print_context, " %010p - %010p %010p %8" PRId32 " ", stack->area, stack->area + stack->size - 1, 107215: 8b 12 mov (%edx),%edx <== NOT EXECUTED else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); } #endif (*print_handler)( 107217: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED 10721b: 52 push %edx <== NOT EXECUTED 10721c: 50 push %eax <== NOT EXECUTED 10721d: 68 72 16 12 00 push $0x121672 <== NOT EXECUTED 107222: ff 35 10 6f 12 00 pushl 0x126f10 <== NOT EXECUTED 107228: ff 15 14 6f 12 00 call *0x126f14 <== NOT EXECUTED stack->area + stack->size - 1, current, size ); if (Stack_check_Initialized == 0) { 10722e: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 107231: 83 3d 18 6f 12 00 00 cmpl $0x0,0x126f18 <== NOT EXECUTED 107238: 8b 35 14 6f 12 00 mov 0x126f14,%esi <== NOT EXECUTED 10723e: 75 09 jne 107249 <== NOT EXECUTED (*print_handler)( print_context, "Unavailable\n" ); 107240: 52 push %edx <== NOT EXECUTED 107241: 52 push %edx <== NOT EXECUTED 107242: 68 90 16 12 00 push $0x121690 <== NOT EXECUTED 107247: eb 07 jmp 107250 <== NOT EXECUTED } else { (*print_handler)( print_context, "%8" PRId32 "\n", used ); 107249: 50 push %eax <== NOT EXECUTED 10724a: 57 push %edi <== NOT EXECUTED 10724b: 68 9d 16 12 00 push $0x12169d <== NOT EXECUTED 107250: ff 35 10 6f 12 00 pushl 0x126f10 <== NOT EXECUTED 107256: ff d6 call *%esi <== NOT EXECUTED 107258: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 10725b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10725e: 5b pop %ebx <== NOT EXECUTED 10725f: 5e pop %esi <== NOT EXECUTED 107260: 5f pop %edi <== NOT EXECUTED 107261: c9 leave <== NOT EXECUTED 107262: c3 ret <== NOT EXECUTED =============================================================================== 00107263 : /* * Stack_check_Initialize */ void Stack_check_Initialize( void ) { 107263: 55 push %ebp 107264: 89 e5 mov %esp,%ebp 107266: 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 ) 107267: 83 3d 18 6f 12 00 00 cmpl $0x0,0x126f18 10726e: 75 5a jne 1072ca /* * Dope the pattern and fill areas */ p = Stack_check_Pattern.pattern; for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) { p[i] = pattern[ i%4 ]; 107270: c7 05 28 72 12 00 0d movl $0xfeedf00d,0x127228 107277: f0 ed fe 10727a: c7 05 2c 72 12 00 06 movl $0xbad0d06,0x12722c 107281: 0d ad 0b 107284: c7 05 30 72 12 00 0d movl $0xdeadf00d,0x127230 10728b: f0 ad de 10728e: c7 05 34 72 12 00 06 movl $0x600d0d06,0x127234 107295: 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) { 107298: 8b 15 10 79 12 00 mov 0x127910,%edx 10729e: 85 d2 test %edx,%edx 1072a0: 74 1e je 1072c0 <== NEVER TAKEN 1072a2: 8b 0d 14 79 12 00 mov 0x127914,%ecx 1072a8: 85 c9 test %ecx,%ecx 1072aa: 74 14 je 1072c0 <== NEVER TAKEN Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low; 1072ac: 89 15 3c 72 12 00 mov %edx,0x12723c Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high - 1072b2: 29 d1 sub %edx,%ecx 1072b4: 89 0d 38 72 12 00 mov %ecx,0x127238 (char *) _CPU_Interrupt_stack_low; Stack_check_Dope_stack(&Stack_check_Interrupt_stack); 1072ba: b0 a5 mov $0xa5,%al 1072bc: 89 d7 mov %edx,%edi 1072be: f3 aa rep stos %al,%es:(%edi) } #endif Stack_check_Initialized = 1; 1072c0: c7 05 18 6f 12 00 01 movl $0x1,0x126f18 1072c7: 00 00 00 } 1072ca: 5f pop %edi 1072cb: c9 leave 1072cc: c3 ret =============================================================================== 0010731b : Thread_Control *running, bool pattern_ok ) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE; void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok) { 10731b: 55 push %ebp <== NOT EXECUTED 10731c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10731e: 56 push %esi <== NOT EXECUTED 10731f: 53 push %ebx <== NOT EXECUTED 107320: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 107323: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 107326: 8a 55 0c mov 0xc(%ebp),%dl <== NOT EXECUTED Stack_Control *stack = &running->Start.Initial_stack; void *pattern_area = Stack_check_Get_pattern(stack); 107329: 8b b3 bc 00 00 00 mov 0xbc(%ebx),%esi <== NOT EXECUTED char name[32]; printk("BLOWN STACK!!!\n"); 10732f: 68 a3 16 12 00 push $0x1216a3 <== NOT EXECUTED 107334: 88 55 d4 mov %dl,-0x2c(%ebp) <== NOT EXECUTED 107337: e8 2c 19 00 00 call 108c68 <== NOT EXECUTED printk("task control block: 0x%08" PRIxPTR "\n", running); 10733c: 5a pop %edx <== NOT EXECUTED 10733d: 59 pop %ecx <== NOT EXECUTED 10733e: 53 push %ebx <== NOT EXECUTED 10733f: 68 b3 16 12 00 push $0x1216b3 <== NOT EXECUTED 107344: e8 1f 19 00 00 call 108c68 <== NOT EXECUTED printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id); 107349: 59 pop %ecx <== NOT EXECUTED 10734a: 58 pop %eax <== NOT EXECUTED 10734b: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10734e: 68 d0 16 12 00 push $0x1216d0 <== NOT EXECUTED 107353: e8 10 19 00 00 call 108c68 <== NOT EXECUTED printk( 107358: 58 pop %eax <== NOT EXECUTED 107359: 5a pop %edx <== NOT EXECUTED 10735a: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10735d: 68 e2 16 12 00 push $0x1216e2 <== NOT EXECUTED 107362: e8 01 19 00 00 call 108c68 <== NOT EXECUTED "task name: 0x%08" PRIx32 "\n", running->Object.name.name_u32 ); printk( 107367: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10736a: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED 10736d: 50 push %eax <== NOT EXECUTED 10736e: 6a 20 push $0x20 <== NOT EXECUTED 107370: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 107373: e8 30 52 00 00 call 10c5a8 <== NOT EXECUTED 107378: 5a pop %edx <== NOT EXECUTED 107379: 59 pop %ecx <== NOT EXECUTED 10737a: 50 push %eax <== NOT EXECUTED 10737b: 68 f6 16 12 00 push $0x1216f6 <== NOT EXECUTED 107380: e8 e3 18 00 00 call 108c68 <== 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) 107385: 8b 8b bc 00 00 00 mov 0xbc(%ebx),%ecx <== NOT EXECUTED 10738b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED ); printk( "task name string: %s\n", rtems_object_get_name(running->Object.id, sizeof(name), name) ); printk( 107391: 8d 1c 01 lea (%ecx,%eax,1),%ebx <== NOT EXECUTED 107394: 53 push %ebx <== NOT EXECUTED 107395: 51 push %ecx <== NOT EXECUTED 107396: 50 push %eax <== NOT EXECUTED 107397: 68 0c 17 12 00 push $0x12170c <== NOT EXECUTED 10739c: e8 c7 18 00 00 call 108c68 <== 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) { 1073a1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1073a4: 8a 55 d4 mov -0x2c(%ebp),%dl <== NOT EXECUTED 1073a7: 84 d2 test %dl,%dl <== NOT EXECUTED 1073a9: 75 17 jne 1073c2 <== 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); 1073ab: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED (unsigned long) stack->size, stack->area, ((char *) stack->area + stack->size) ); if (!pattern_ok) { printk( 1073ae: 83 c6 18 add $0x18,%esi <== NOT EXECUTED 1073b1: 56 push %esi <== NOT EXECUTED 1073b2: 50 push %eax <== NOT EXECUTED 1073b3: 6a 10 push $0x10 <== NOT EXECUTED 1073b5: 68 3d 17 12 00 push $0x12173d <== NOT EXECUTED 1073ba: e8 a9 18 00 00 call 108c68 <== NOT EXECUTED 1073bf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_configuration_get_user_multiprocessing_table()->node ); } #endif rtems_fatal_error_occurred(0x81); 1073c2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1073c5: 68 81 00 00 00 push $0x81 <== NOT EXECUTED 1073ca: e8 21 59 00 00 call 10ccf0 <== NOT EXECUTED =============================================================================== 0010ce60 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 10ce60: 55 push %ebp 10ce61: 89 e5 mov %esp,%ebp 10ce63: 53 push %ebx 10ce64: 83 ec 04 sub $0x4,%esp 10ce67: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; Thread_Control *executing = _Thread_Executing; 10ce6a: 8b 15 78 88 12 00 mov 0x128878,%edx * Otherwise, we have to block. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 10ce70: 9c pushf 10ce71: fa cli 10ce72: 58 pop %eax if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 10ce73: 8b 4b 44 mov 0x44(%ebx),%ecx 10ce76: 85 c9 test %ecx,%ecx 10ce78: 75 0b jne 10ce85 <_CORE_RWLock_Release+0x25> _ISR_Enable( level ); 10ce7a: 50 push %eax 10ce7b: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10ce7c: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) return CORE_RWLOCK_SUCCESSFUL; 10ce83: eb 72 jmp 10cef7 <_CORE_RWLock_Release+0x97> } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { 10ce85: 49 dec %ecx 10ce86: 75 0f jne 10ce97 <_CORE_RWLock_Release+0x37> the_rwlock->number_of_readers -= 1; 10ce88: 8b 4b 48 mov 0x48(%ebx),%ecx 10ce8b: 49 dec %ecx 10ce8c: 89 4b 48 mov %ecx,0x48(%ebx) if ( the_rwlock->number_of_readers != 0 ) { 10ce8f: 85 c9 test %ecx,%ecx 10ce91: 74 04 je 10ce97 <_CORE_RWLock_Release+0x37> /* must be unlocked again */ _ISR_Enable( level ); 10ce93: 50 push %eax 10ce94: 9d popf return CORE_RWLOCK_SUCCESSFUL; 10ce95: eb 60 jmp 10cef7 <_CORE_RWLock_Release+0x97> } } /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */ executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10ce97: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) /* * Implicitly transition to "unlocked" and find another thread interested * in obtaining this rwlock. */ the_rwlock->current_state = CORE_RWLOCK_UNLOCKED; 10ce9e: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) _ISR_Enable( level ); 10cea5: 50 push %eax 10cea6: 9d popf next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 10cea7: 83 ec 0c sub $0xc,%esp 10ceaa: 53 push %ebx 10ceab: e8 f0 17 00 00 call 10e6a0 <_Thread_queue_Dequeue> if ( next ) { 10ceb0: 83 c4 10 add $0x10,%esp 10ceb3: 85 c0 test %eax,%eax 10ceb5: 74 40 je 10cef7 <_CORE_RWLock_Release+0x97> if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 10ceb7: 83 78 30 01 cmpl $0x1,0x30(%eax) 10cebb: 75 09 jne 10cec6 <_CORE_RWLock_Release+0x66> the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10cebd: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx) return CORE_RWLOCK_SUCCESSFUL; 10cec4: eb 31 jmp 10cef7 <_CORE_RWLock_Release+0x97> } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 10cec6: ff 43 48 incl 0x48(%ebx) the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10cec9: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); 10ced0: 83 ec 0c sub $0xc,%esp 10ced3: 53 push %ebx 10ced4: e8 bf 1b 00 00 call 10ea98 <_Thread_queue_First> if ( !next || 10ced9: 83 c4 10 add $0x10,%esp 10cedc: 85 c0 test %eax,%eax 10cede: 74 17 je 10cef7 <_CORE_RWLock_Release+0x97> 10cee0: 83 78 30 01 cmpl $0x1,0x30(%eax) 10cee4: 74 11 je 10cef7 <_CORE_RWLock_Release+0x97><== NEVER TAKEN next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) return CORE_RWLOCK_SUCCESSFUL; the_rwlock->number_of_readers += 1; 10cee6: ff 43 48 incl 0x48(%ebx) _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 10cee9: 52 push %edx 10ceea: 52 push %edx 10ceeb: 50 push %eax 10ceec: 53 push %ebx 10ceed: e8 96 1a 00 00 call 10e988 <_Thread_queue_Extract> } 10cef2: 83 c4 10 add $0x10,%esp 10cef5: eb d9 jmp 10ced0 <_CORE_RWLock_Release+0x70> } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10cef7: 31 c0 xor %eax,%eax 10cef9: 8b 5d fc mov -0x4(%ebp),%ebx 10cefc: c9 leave 10cefd: c3 ret =============================================================================== 0010cf00 <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 10cf00: 55 push %ebp 10cf01: 89 e5 mov %esp,%ebp 10cf03: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10cf06: 8d 45 f4 lea -0xc(%ebp),%eax 10cf09: 50 push %eax 10cf0a: ff 75 08 pushl 0x8(%ebp) 10cf0d: e8 72 14 00 00 call 10e384 <_Thread_Get> switch ( location ) { 10cf12: 83 c4 10 add $0x10,%esp 10cf15: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10cf19: 75 17 jne 10cf32 <_CORE_RWLock_Timeout+0x32><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10cf1b: 83 ec 0c sub $0xc,%esp 10cf1e: 50 push %eax 10cf1f: e8 40 1c 00 00 call 10eb64 <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10cf24: a1 50 83 12 00 mov 0x128350,%eax 10cf29: 48 dec %eax 10cf2a: a3 50 83 12 00 mov %eax,0x128350 10cf2f: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10cf32: c9 leave 10cf33: c3 ret =============================================================================== 00112274 <_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 ) { 112274: 55 push %ebp 112275: 89 e5 mov %esp,%ebp 112277: 57 push %edi 112278: 56 push %esi 112279: 53 push %ebx 11227a: 83 ec 1c sub $0x1c,%esp 11227d: 8b 5d 08 mov 0x8(%ebp),%ebx 112280: 8b 7d 10 mov 0x10(%ebp),%edi 112283: 8b 55 14 mov 0x14(%ebp),%edx size_t message_buffering_required; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; 112286: 89 7b 44 mov %edi,0x44(%ebx) the_message_queue->number_of_pending_messages = 0; 112289: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) the_message_queue->maximum_message_size = maximum_message_size; 112290: 89 53 4c mov %edx,0x4c(%ebx) CORE_message_queue_Control *the_message_queue, CORE_message_queue_Notify_Handler the_handler, void *the_argument ) { the_message_queue->notify_handler = the_handler; 112293: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) the_message_queue->notify_argument = the_argument; 11229a: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) /* * Round size up to multiple of a pointer for chain init and * check for overflow on adding overhead to each message. */ allocated_message_size = maximum_message_size; if (allocated_message_size & (sizeof(uint32_t) - 1)) { 1122a1: 89 d0 mov %edx,%eax 1122a3: f6 c2 03 test $0x3,%dl 1122a6: 74 0c je 1122b4 <_CORE_message_queue_Initialize+0x40> allocated_message_size += sizeof(uint32_t); 1122a8: 83 c0 04 add $0x4,%eax allocated_message_size &= ~(sizeof(uint32_t) - 1); 1122ab: 83 e0 fc and $0xfffffffc,%eax } if (allocated_message_size < maximum_message_size) return false; 1122ae: 31 f6 xor %esi,%esi if (allocated_message_size & (sizeof(uint32_t) - 1)) { allocated_message_size += sizeof(uint32_t); allocated_message_size &= ~(sizeof(uint32_t) - 1); } if (allocated_message_size < maximum_message_size) 1122b0: 39 d0 cmp %edx,%eax 1122b2: 72 68 jb 11231c <_CORE_message_queue_Initialize+0xa8><== NEVER TAKEN /* * 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)); 1122b4: 8d 50 14 lea 0x14(%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 * 1122b7: 89 d1 mov %edx,%ecx 1122b9: 0f af cf imul %edi,%ecx (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) return false; 1122bc: 31 f6 xor %esi,%esi * check for overflow on the multiplication. */ message_buffering_required = (size_t) maximum_pending_messages * (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 1122be: 39 c1 cmp %eax,%ecx 1122c0: 72 5a jb 11231c <_CORE_message_queue_Initialize+0xa8><== NEVER TAKEN /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) _Workspace_Allocate( message_buffering_required ); 1122c2: 83 ec 0c sub $0xc,%esp 1122c5: 51 push %ecx 1122c6: 89 55 e4 mov %edx,-0x1c(%ebp) 1122c9: e8 b4 27 00 00 call 114a82 <_Workspace_Allocate> return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 1122ce: 89 43 5c mov %eax,0x5c(%ebx) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 1122d1: 83 c4 10 add $0x10,%esp 1122d4: 85 c0 test %eax,%eax 1122d6: 8b 55 e4 mov -0x1c(%ebp),%edx 1122d9: 74 41 je 11231c <_CORE_message_queue_Initialize+0xa8> /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 1122db: 52 push %edx 1122dc: 57 push %edi 1122dd: 50 push %eax 1122de: 8d 43 68 lea 0x68(%ebx),%eax 1122e1: 50 push %eax 1122e2: e8 f5 4a 00 00 call 116ddc <_Chain_Initialize> RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); 1122e7: 8d 43 54 lea 0x54(%ebx),%eax 1122ea: 89 43 50 mov %eax,0x50(%ebx) head->next = tail; head->previous = NULL; 1122ed: 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 ); 1122f4: 8d 43 50 lea 0x50(%ebx),%eax 1122f7: 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( 1122fa: 6a 06 push $0x6 1122fc: 68 80 00 00 00 push $0x80 112301: 8b 45 0c mov 0xc(%ebp),%eax 112304: 83 38 01 cmpl $0x1,(%eax) 112307: 0f 94 c0 sete %al 11230a: 0f b6 c0 movzbl %al,%eax 11230d: 50 push %eax 11230e: 53 push %ebx 11230f: e8 94 1f 00 00 call 1142a8 <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 112314: 83 c4 20 add $0x20,%esp 112317: be 01 00 00 00 mov $0x1,%esi } 11231c: 89 f0 mov %esi,%eax 11231e: 8d 65 f4 lea -0xc(%ebp),%esp 112321: 5b pop %ebx 112322: 5e pop %esi 112323: 5f pop %edi 112324: c9 leave 112325: c3 ret =============================================================================== 00112328 <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 112328: 55 push %ebp 112329: 89 e5 mov %esp,%ebp 11232b: 57 push %edi 11232c: 56 push %esi 11232d: 53 push %ebx 11232e: 83 ec 2c sub $0x2c,%esp 112331: 8b 55 08 mov 0x8(%ebp),%edx 112334: 8b 45 0c mov 0xc(%ebp),%eax 112337: 89 45 dc mov %eax,-0x24(%ebp) 11233a: 8b 5d 10 mov 0x10(%ebp),%ebx 11233d: 89 5d e0 mov %ebx,-0x20(%ebp) 112340: 8b 4d 14 mov 0x14(%ebp),%ecx 112343: 8b 75 1c mov 0x1c(%ebp),%esi 112346: 89 75 d4 mov %esi,-0x2c(%ebp) 112349: 8a 45 18 mov 0x18(%ebp),%al 11234c: 88 45 db mov %al,-0x25(%ebp) ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *executing; executing = _Thread_Executing; 11234f: a1 f0 d9 12 00 mov 0x12d9f0,%eax executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 112354: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) _ISR_Disable( level ); 11235b: 9c pushf 11235c: fa cli 11235d: 8f 45 e4 popl -0x1c(%ebp) executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 112360: 8b 5a 50 mov 0x50(%edx),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 112363: 8d 72 54 lea 0x54(%edx),%esi */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 112366: 39 f3 cmp %esi,%ebx 112368: 0f 84 8a 00 00 00 je 1123f8 <_CORE_message_queue_Seize+0xd0> Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 11236e: 8b 33 mov (%ebx),%esi head->next = new_first; 112370: 89 72 50 mov %esi,0x50(%edx) */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_first_unprotected( Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); 112373: 8d 7a 50 lea 0x50(%edx),%edi 112376: 89 7e 04 mov %edi,0x4(%esi) executing = _Thread_Executing; executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; _ISR_Disable( level ); the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); if ( the_message != NULL ) { 112379: 85 db test %ebx,%ebx 11237b: 74 7b je 1123f8 <_CORE_message_queue_Seize+0xd0><== NEVER TAKEN the_message_queue->number_of_pending_messages -= 1; 11237d: ff 4a 48 decl 0x48(%edx) _ISR_Enable( level ); 112380: ff 75 e4 pushl -0x1c(%ebp) 112383: 9d popf *size_p = the_message->Contents.size; 112384: 8b 43 0c mov 0xc(%ebx),%eax 112387: 89 01 mov %eax,(%ecx) _Thread_Executing->Wait.count = 112389: 8b 73 08 mov 0x8(%ebx),%esi 11238c: a1 f0 d9 12 00 mov 0x12d9f0,%eax 112391: 89 70 24 mov %esi,0x24(%eax) _CORE_message_queue_Get_message_priority( the_message ); _CORE_message_queue_Copy_buffer( the_message->Contents.buffer, 112394: 8d 73 10 lea 0x10(%ebx),%esi 112397: 89 75 e4 mov %esi,-0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 11239a: 8b 09 mov (%ecx),%ecx 11239c: 8b 7d e0 mov -0x20(%ebp),%edi 11239f: f3 a4 rep movsb %ds:(%esi),%es:(%edi) * is not, then we can go ahead and free the buffer. * * NOTE: If we note that the queue was not full before this receive, * then we can avoid this dequeue. */ the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 1123a1: 83 ec 0c sub $0xc,%esp 1123a4: 52 push %edx 1123a5: 89 55 d0 mov %edx,-0x30(%ebp) 1123a8: e8 c3 1b 00 00 call 113f70 <_Thread_queue_Dequeue> if ( !the_thread ) { 1123ad: 83 c4 10 add $0x10,%esp 1123b0: 85 c0 test %eax,%eax 1123b2: 8b 55 d0 mov -0x30(%ebp),%edx 1123b5: 75 15 jne 1123cc <_CORE_message_queue_Seize+0xa4> RTEMS_INLINE_ROUTINE void _CORE_message_queue_Free_message_buffer ( CORE_message_queue_Control *the_message_queue, CORE_message_queue_Buffer_control *the_message ) { _Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node ); 1123b7: 89 5d 0c mov %ebx,0xc(%ebp) 1123ba: 83 c2 68 add $0x68,%edx 1123bd: 89 55 08 mov %edx,0x8(%ebp) executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 1123c0: 8d 65 f4 lea -0xc(%ebp),%esp 1123c3: 5b pop %ebx 1123c4: 5e pop %esi 1123c5: 5f pop %edi 1123c6: c9 leave 1123c7: e9 28 fe ff ff jmp 1121f4 <_Chain_Append> CORE_message_queue_Buffer_control *the_message, int priority ) { #if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY) the_message->priority = priority; 1123cc: 8b 48 24 mov 0x24(%eax),%ecx 1123cf: 89 4b 08 mov %ecx,0x8(%ebx) */ _CORE_message_queue_Set_message_priority( the_message, the_thread->Wait.count ); the_message->Contents.size = (size_t) the_thread->Wait.option; 1123d2: 8b 48 30 mov 0x30(%eax),%ecx 1123d5: 89 4b 0c mov %ecx,0xc(%ebx) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 1123d8: 8b 70 2c mov 0x2c(%eax),%esi 1123db: 8b 7d e4 mov -0x1c(%ebp),%edi 1123de: f3 a4 rep movsb %ds:(%esi),%es:(%edi) the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 1123e0: 8b 43 08 mov 0x8(%ebx),%eax 1123e3: 89 45 10 mov %eax,0x10(%ebp) 1123e6: 89 5d 0c mov %ebx,0xc(%ebp) 1123e9: 89 55 08 mov %edx,0x8(%ebp) executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 1123ec: 8d 65 f4 lea -0xc(%ebp),%esp 1123ef: 5b pop %ebx 1123f0: 5e pop %esi 1123f1: 5f pop %edi 1123f2: c9 leave the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 1123f3: e9 1c 4a 00 00 jmp 116e14 <_CORE_message_queue_Insert_message> return; } #endif } if ( !wait ) { 1123f8: 80 7d db 00 cmpb $0x0,-0x25(%ebp) 1123fc: 75 13 jne 112411 <_CORE_message_queue_Seize+0xe9> _ISR_Enable( level ); 1123fe: ff 75 e4 pushl -0x1c(%ebp) 112401: 9d popf executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 112402: c7 40 34 04 00 00 00 movl $0x4,0x34(%eax) executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 112409: 8d 65 f4 lea -0xc(%ebp),%esp 11240c: 5b pop %ebx 11240d: 5e pop %esi 11240e: 5f pop %edi 11240f: c9 leave 112410: c3 ret 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; 112411: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx) executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; return; } _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; 112418: 89 50 44 mov %edx,0x44(%eax) executing->Wait.id = id; 11241b: 8b 5d dc mov -0x24(%ebp),%ebx 11241e: 89 58 20 mov %ebx,0x20(%eax) executing->Wait.return_argument_second.mutable_object = buffer; 112421: 8b 75 e0 mov -0x20(%ebp),%esi 112424: 89 70 2c mov %esi,0x2c(%eax) executing->Wait.return_argument = size_p; 112427: 89 48 28 mov %ecx,0x28(%eax) /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 11242a: ff 75 e4 pushl -0x1c(%ebp) 11242d: 9d popf _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 11242e: c7 45 10 58 43 11 00 movl $0x114358,0x10(%ebp) 112435: 8b 45 d4 mov -0x2c(%ebp),%eax 112438: 89 45 0c mov %eax,0xc(%ebp) 11243b: 89 55 08 mov %edx,0x8(%ebp) } 11243e: 8d 65 f4 lea -0xc(%ebp),%esp 112441: 5b pop %ebx 112442: 5e pop %esi 112443: 5f pop %edi 112444: c9 leave executing->Wait.return_argument_second.mutable_object = buffer; executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 112445: e9 32 1c 00 00 jmp 11407c <_Thread_queue_Enqueue_with_handler> =============================================================================== 0010ab98 <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 10ab98: 55 push %ebp 10ab99: 89 e5 mov %esp,%ebp 10ab9b: 57 push %edi 10ab9c: 56 push %esi 10ab9d: 53 push %ebx 10ab9e: 83 ec 0c sub $0xc,%esp 10aba1: 8b 55 08 mov 0x8(%ebp),%edx 10aba4: 8b 5d 0c mov 0xc(%ebp),%ebx 10aba7: 8b 45 10 mov 0x10(%ebp),%eax /* 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; 10abaa: 8d 7a 40 lea 0x40(%edx),%edi 10abad: b9 04 00 00 00 mov $0x4,%ecx 10abb2: 89 de mov %ebx,%esi 10abb4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_mutex->lock = initial_lock; 10abb6: 89 42 50 mov %eax,0x50(%edx) the_mutex->blocked_count = 0; 10abb9: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx) if ( initial_lock == CORE_MUTEX_LOCKED ) { 10abc0: 85 c0 test %eax,%eax 10abc2: 75 35 jne 10abf9 <_CORE_mutex_Initialize+0x61> the_mutex->nest_count = 1; 10abc4: c7 42 54 01 00 00 00 movl $0x1,0x54(%edx) the_mutex->holder = _Thread_Executing; 10abcb: 8b 0d 68 58 12 00 mov 0x125868,%ecx 10abd1: 89 4a 5c mov %ecx,0x5c(%edx) the_mutex->holder_id = _Thread_Executing->Object.id; 10abd4: 8b 41 08 mov 0x8(%ecx),%eax 10abd7: 89 42 60 mov %eax,0x60(%edx) STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10abda: 8b 42 48 mov 0x48(%edx),%eax 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 ) || 10abdd: 83 f8 02 cmp $0x2,%eax 10abe0: 74 05 je 10abe7 <_CORE_mutex_Initialize+0x4f> 10abe2: 83 f8 03 cmp $0x3,%eax 10abe5: 75 27 jne 10ac0e <_CORE_mutex_Initialize+0x76> _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < the_mutex->Attributes.priority_ceiling ) return CORE_MUTEX_STATUS_CEILING_VIOLATED; 10abe7: b8 06 00 00 00 mov $0x6,%eax the_mutex->holder = _Thread_Executing; the_mutex->holder_id = _Thread_Executing->Object.id; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 10abec: 8b 72 4c mov 0x4c(%edx),%esi 10abef: 39 71 14 cmp %esi,0x14(%ecx) 10abf2: 72 36 jb 10ac2a <_CORE_mutex_Initialize+0x92><== NEVER TAKEN _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++; 10abf4: ff 41 1c incl 0x1c(%ecx) 10abf7: eb 15 jmp 10ac0e <_CORE_mutex_Initialize+0x76> } } else { the_mutex->nest_count = 0; 10abf9: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) the_mutex->holder = NULL; 10ac00: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx) the_mutex->holder_id = 0; 10ac07: c7 42 60 00 00 00 00 movl $0x0,0x60(%edx) } _Thread_queue_Initialize( 10ac0e: 6a 05 push $0x5 10ac10: 68 00 04 00 00 push $0x400 10ac15: 31 c0 xor %eax,%eax 10ac17: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10ac1b: 0f 95 c0 setne %al 10ac1e: 50 push %eax 10ac1f: 52 push %edx 10ac20: e8 4b 1c 00 00 call 10c870 <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_FIFO : THREAD_QUEUE_DISCIPLINE_PRIORITY, STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; 10ac25: 83 c4 10 add $0x10,%esp 10ac28: 31 c0 xor %eax,%eax } 10ac2a: 8d 65 f4 lea -0xc(%ebp),%esp 10ac2d: 5b pop %ebx 10ac2e: 5e pop %esi 10ac2f: 5f pop %edi 10ac30: c9 leave 10ac31: c3 ret =============================================================================== 0010ac81 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 10ac81: 55 push %ebp 10ac82: 89 e5 mov %esp,%ebp 10ac84: 53 push %ebx 10ac85: 83 ec 14 sub $0x14,%esp 10ac88: 8b 5d 08 mov 0x8(%ebp),%ebx 10ac8b: 8a 55 10 mov 0x10(%ebp),%dl _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10ac8e: a1 40 53 12 00 mov 0x125340,%eax 10ac93: 85 c0 test %eax,%eax 10ac95: 74 19 je 10acb0 <_CORE_mutex_Seize+0x2f> 10ac97: 84 d2 test %dl,%dl 10ac99: 74 15 je 10acb0 <_CORE_mutex_Seize+0x2f><== NEVER TAKEN 10ac9b: 83 3d 9c 54 12 00 01 cmpl $0x1,0x12549c 10aca2: 76 0c jbe 10acb0 <_CORE_mutex_Seize+0x2f> 10aca4: 53 push %ebx 10aca5: 6a 12 push $0x12 10aca7: 6a 00 push $0x0 10aca9: 6a 00 push $0x0 10acab: e8 dc 05 00 00 call 10b28c <_Internal_error_Occurred> 10acb0: 51 push %ecx 10acb1: 51 push %ecx 10acb2: 8d 45 18 lea 0x18(%ebp),%eax 10acb5: 50 push %eax 10acb6: 53 push %ebx 10acb7: 88 55 f4 mov %dl,-0xc(%ebp) 10acba: e8 d5 47 00 00 call 10f494 <_CORE_mutex_Seize_interrupt_trylock> 10acbf: 83 c4 10 add $0x10,%esp 10acc2: 85 c0 test %eax,%eax 10acc4: 8a 55 f4 mov -0xc(%ebp),%dl 10acc7: 74 48 je 10ad11 <_CORE_mutex_Seize+0x90> 10acc9: 84 d2 test %dl,%dl 10accb: 75 12 jne 10acdf <_CORE_mutex_Seize+0x5e> 10accd: ff 75 18 pushl 0x18(%ebp) 10acd0: 9d popf 10acd1: a1 68 58 12 00 mov 0x125868,%eax 10acd6: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) 10acdd: eb 32 jmp 10ad11 <_CORE_mutex_Seize+0x90> 10acdf: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) 10ace6: a1 68 58 12 00 mov 0x125868,%eax 10aceb: 89 58 44 mov %ebx,0x44(%eax) 10acee: 8b 55 0c mov 0xc(%ebp),%edx 10acf1: 89 50 20 mov %edx,0x20(%eax) 10acf4: a1 40 53 12 00 mov 0x125340,%eax 10acf9: 40 inc %eax 10acfa: a3 40 53 12 00 mov %eax,0x125340 10acff: ff 75 18 pushl 0x18(%ebp) 10ad02: 9d popf 10ad03: 50 push %eax 10ad04: 50 push %eax 10ad05: ff 75 14 pushl 0x14(%ebp) 10ad08: 53 push %ebx 10ad09: e8 26 ff ff ff call 10ac34 <_CORE_mutex_Seize_interrupt_blocking> 10ad0e: 83 c4 10 add $0x10,%esp } 10ad11: 8b 5d fc mov -0x4(%ebp),%ebx 10ad14: c9 leave 10ad15: c3 ret =============================================================================== 0010ae3c <_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 ) { 10ae3c: 55 push %ebp 10ae3d: 89 e5 mov %esp,%ebp 10ae3f: 53 push %ebx 10ae40: 83 ec 10 sub $0x10,%esp 10ae43: 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)) ) { 10ae46: 53 push %ebx 10ae47: e8 ec 16 00 00 call 10c538 <_Thread_queue_Dequeue> 10ae4c: 89 c2 mov %eax,%edx 10ae4e: 83 c4 10 add $0x10,%esp { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10ae51: 31 c0 xor %eax,%eax if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 10ae53: 85 d2 test %edx,%edx 10ae55: 75 15 jne 10ae6c <_CORE_semaphore_Surrender+0x30> if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); 10ae57: 9c pushf 10ae58: fa cli 10ae59: 59 pop %ecx if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10ae5a: 8b 53 48 mov 0x48(%ebx),%edx the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; 10ae5d: b0 04 mov $0x4,%al (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10ae5f: 3b 53 40 cmp 0x40(%ebx),%edx 10ae62: 73 06 jae 10ae6a <_CORE_semaphore_Surrender+0x2e><== NEVER TAKEN the_semaphore->count += 1; 10ae64: 42 inc %edx 10ae65: 89 53 48 mov %edx,0x48(%ebx) { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10ae68: 30 c0 xor %al,%al _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); 10ae6a: 51 push %ecx 10ae6b: 9d popf } return status; } 10ae6c: 8b 5d fc mov -0x4(%ebp),%ebx 10ae6f: c9 leave 10ae70: c3 ret =============================================================================== 00109da0 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 109da0: 55 push %ebp 109da1: 89 e5 mov %esp,%ebp 109da3: 57 push %edi 109da4: 56 push %esi 109da5: 53 push %ebx 109da6: 83 ec 2c sub $0x2c,%esp 109da9: 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 ]; 109dac: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi option_set = (rtems_option) the_thread->Wait.option; 109db2: 8b 43 30 mov 0x30(%ebx),%eax 109db5: 89 45 e0 mov %eax,-0x20(%ebp) _ISR_Disable( level ); 109db8: 9c pushf 109db9: fa cli 109dba: 58 pop %eax pending_events = api->pending_events; 109dbb: 8b 17 mov (%edi),%edx 109dbd: 89 55 d4 mov %edx,-0x2c(%ebp) event_condition = (rtems_event_set) the_thread->Wait.count; 109dc0: 8b 73 24 mov 0x24(%ebx),%esi seized_events = _Event_sets_Get( pending_events, event_condition ); /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { 109dc3: 21 f2 and %esi,%edx 109dc5: 75 07 jne 109dce <_Event_Surrender+0x2e> _ISR_Enable( level ); 109dc7: 50 push %eax 109dc8: 9d popf return; 109dc9: e9 af 00 00 00 jmp 109e7d <_Event_Surrender+0xdd> /* * 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() && 109dce: 83 3d 64 58 12 00 00 cmpl $0x0,0x125864 109dd5: 74 49 je 109e20 <_Event_Surrender+0x80> 109dd7: 3b 1d 68 58 12 00 cmp 0x125868,%ebx 109ddd: 75 41 jne 109e20 <_Event_Surrender+0x80> _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 109ddf: 8b 0d 3c 5c 12 00 mov 0x125c3c,%ecx /* * 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 ) && 109de5: 83 f9 02 cmp $0x2,%ecx 109de8: 74 09 je 109df3 <_Event_Surrender+0x53> <== NEVER TAKEN ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { 109dea: 8b 0d 3c 5c 12 00 mov 0x125c3c,%ecx * 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) || 109df0: 49 dec %ecx 109df1: 75 2d jne 109e20 <_Event_Surrender+0x80> (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 109df3: 39 f2 cmp %esi,%edx 109df5: 74 06 je 109dfd <_Event_Surrender+0x5d> 109df7: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109dfb: 74 1f je 109e1c <_Event_Surrender+0x7c> <== 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) ); 109dfd: 89 d6 mov %edx,%esi 109dff: f7 d6 not %esi 109e01: 23 75 d4 and -0x2c(%ebp),%esi 109e04: 89 37 mov %esi,(%edi) api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 109e06: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109e0d: 8b 4b 28 mov 0x28(%ebx),%ecx 109e10: 89 11 mov %edx,(%ecx) _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 109e12: c7 05 3c 5c 12 00 03 movl $0x3,0x125c3c 109e19: 00 00 00 } _ISR_Enable( level ); 109e1c: 50 push %eax 109e1d: 9d popf return; 109e1e: eb 5d jmp 109e7d <_Event_Surrender+0xdd> } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 109e20: f6 43 11 01 testb $0x1,0x11(%ebx) 109e24: 74 55 je 109e7b <_Event_Surrender+0xdb> if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 109e26: 39 f2 cmp %esi,%edx 109e28: 74 06 je 109e30 <_Event_Surrender+0x90> 109e2a: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109e2e: 74 4b je 109e7b <_Event_Surrender+0xdb> <== NEVER TAKEN 109e30: 89 d6 mov %edx,%esi 109e32: f7 d6 not %esi 109e34: 23 75 d4 and -0x2c(%ebp),%esi 109e37: 89 37 mov %esi,(%edi) api->pending_events = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 109e39: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109e40: 8b 4b 28 mov 0x28(%ebx),%ecx 109e43: 89 11 mov %edx,(%ecx) _ISR_Flash( level ); 109e45: 50 push %eax 109e46: 9d popf 109e47: fa cli if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 109e48: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 109e4c: 74 06 je 109e54 <_Event_Surrender+0xb4> _ISR_Enable( level ); 109e4e: 50 push %eax 109e4f: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 109e50: 51 push %ecx 109e51: 51 push %ecx 109e52: eb 17 jmp 109e6b <_Event_Surrender+0xcb> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 109e54: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 109e5b: 50 push %eax 109e5c: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 109e5d: 83 ec 0c sub $0xc,%esp 109e60: 8d 43 48 lea 0x48(%ebx),%eax 109e63: 50 push %eax 109e64: e8 c7 30 00 00 call 10cf30 <_Watchdog_Remove> 109e69: 58 pop %eax 109e6a: 5a pop %edx 109e6b: 68 f8 ff 03 10 push $0x1003fff8 109e70: 53 push %ebx 109e71: e8 6e 20 00 00 call 10bee4 <_Thread_Clear_state> 109e76: 83 c4 10 add $0x10,%esp 109e79: eb 02 jmp 109e7d <_Event_Surrender+0xdd> _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 109e7b: 50 push %eax 109e7c: 9d popf } 109e7d: 8d 65 f4 lea -0xc(%ebp),%esp 109e80: 5b pop %ebx 109e81: 5e pop %esi 109e82: 5f pop %edi 109e83: c9 leave 109e84: c3 ret =============================================================================== 00109e88 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 109e88: 55 push %ebp 109e89: 89 e5 mov %esp,%ebp 109e8b: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 109e8e: 8d 45 f4 lea -0xc(%ebp),%eax 109e91: 50 push %eax 109e92: ff 75 08 pushl 0x8(%ebp) 109e95: e8 82 23 00 00 call 10c21c <_Thread_Get> switch ( location ) { 109e9a: 83 c4 10 add $0x10,%esp 109e9d: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 109ea1: 75 49 jne 109eec <_Event_Timeout+0x64> <== 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 ); 109ea3: 9c pushf 109ea4: fa cli 109ea5: 5a pop %edx _ISR_Enable( level ); return; } #endif the_thread->Wait.count = 0; 109ea6: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) if ( _Thread_Is_executing( the_thread ) ) { 109ead: 3b 05 68 58 12 00 cmp 0x125868,%eax 109eb3: 75 13 jne 109ec8 <_Event_Timeout+0x40> if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 109eb5: 8b 0d 3c 5c 12 00 mov 0x125c3c,%ecx 109ebb: 49 dec %ecx 109ebc: 75 0a jne 109ec8 <_Event_Timeout+0x40> _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 109ebe: c7 05 3c 5c 12 00 02 movl $0x2,0x125c3c 109ec5: 00 00 00 } the_thread->Wait.return_code = RTEMS_TIMEOUT; 109ec8: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax) _ISR_Enable( level ); 109ecf: 52 push %edx 109ed0: 9d popf 109ed1: 52 push %edx 109ed2: 52 push %edx 109ed3: 68 f8 ff 03 10 push $0x1003fff8 109ed8: 50 push %eax 109ed9: e8 06 20 00 00 call 10bee4 <_Thread_Clear_state> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 109ede: a1 40 53 12 00 mov 0x125340,%eax 109ee3: 48 dec %eax 109ee4: a3 40 53 12 00 mov %eax,0x125340 _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; 109ee9: 83 c4 10 add $0x10,%esp case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 109eec: c9 leave 109eed: c3 ret =============================================================================== 0010faeb <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 10faeb: 55 push %ebp 10faec: 89 e5 mov %esp,%ebp 10faee: 57 push %edi 10faef: 56 push %esi 10faf0: 53 push %ebx 10faf1: 83 ec 4c sub $0x4c,%esp 10faf4: 8b 5d 08 mov 0x8(%ebp),%ebx 10faf7: 8b 4d 10 mov 0x10(%ebp),%ecx Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 10fafa: 8b 43 20 mov 0x20(%ebx),%eax 10fafd: 89 45 c0 mov %eax,-0x40(%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; 10fb00: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) Heap_Block *extend_last_block = NULL; 10fb07: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) uintptr_t const page_size = heap->page_size; 10fb0e: 8b 53 10 mov 0x10(%ebx),%edx 10fb11: 89 55 c4 mov %edx,-0x3c(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10fb14: 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; 10fb17: 8b 7b 30 mov 0x30(%ebx),%edi 10fb1a: 89 7d bc mov %edi,-0x44(%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 ) { return false; 10fb1d: 31 f6 xor %esi,%esi uintptr_t const free_size = stats->free_size; uintptr_t extend_first_block_size = 0; uintptr_t extended_size = 0; bool extend_area_ok = false; if ( extend_area_end < extend_area_begin ) { 10fb1f: 8b 7d 0c mov 0xc(%ebp),%edi 10fb22: 01 cf add %ecx,%edi 10fb24: 0f 82 d4 01 00 00 jb 10fcfe <_Heap_Extend+0x213> return false; } extend_area_ok = _Heap_Get_first_and_last_block( 10fb2a: 52 push %edx 10fb2b: 52 push %edx 10fb2c: 8d 55 e0 lea -0x20(%ebp),%edx 10fb2f: 52 push %edx 10fb30: 8d 55 e4 lea -0x1c(%ebp),%edx 10fb33: 52 push %edx 10fb34: 50 push %eax 10fb35: ff 75 c4 pushl -0x3c(%ebp) 10fb38: 51 push %ecx 10fb39: ff 75 0c pushl 0xc(%ebp) 10fb3c: e8 6e b8 ff ff call 10b3af <_Heap_Get_first_and_last_block> page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 10fb41: 83 c4 20 add $0x20,%esp 10fb44: 84 c0 test %al,%al 10fb46: 0f 84 b2 01 00 00 je 10fcfe <_Heap_Extend+0x213> 10fb4c: 8b 4d c0 mov -0x40(%ebp),%ecx 10fb4f: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) 10fb56: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) 10fb5d: 31 f6 xor %esi,%esi 10fb5f: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) return false; } do { uintptr_t const sub_area_begin = (start_block != first_block) ? (uintptr_t) start_block : heap->area_begin; 10fb66: 8b 43 18 mov 0x18(%ebx),%eax 10fb69: 89 5d b8 mov %ebx,-0x48(%ebp) 10fb6c: eb 02 jmp 10fb70 <_Heap_Extend+0x85> 10fb6e: 89 c8 mov %ecx,%eax uintptr_t const sub_area_end = start_block->prev_size; 10fb70: 8b 19 mov (%ecx),%ebx Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 10fb72: 39 c7 cmp %eax,%edi 10fb74: 76 09 jbe 10fb7f <_Heap_Extend+0x94> 10fb76: 39 5d 0c cmp %ebx,0xc(%ebp) 10fb79: 0f 82 7d 01 00 00 jb 10fcfc <_Heap_Extend+0x211> <== NEVER TAKEN sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10fb7f: 39 c7 cmp %eax,%edi 10fb81: 74 06 je 10fb89 <_Heap_Extend+0x9e> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10fb83: 39 df cmp %ebx,%edi 10fb85: 72 07 jb 10fb8e <_Heap_Extend+0xa3> 10fb87: eb 08 jmp 10fb91 <_Heap_Extend+0xa6> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10fb89: 89 4d d0 mov %ecx,-0x30(%ebp) 10fb8c: eb 03 jmp 10fb91 <_Heap_Extend+0xa6> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10fb8e: 89 4d c8 mov %ecx,-0x38(%ebp) RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10fb91: 8d 43 f8 lea -0x8(%ebx),%eax 10fb94: 89 45 d4 mov %eax,-0x2c(%ebp) 10fb97: 89 d8 mov %ebx,%eax 10fb99: 31 d2 xor %edx,%edx 10fb9b: f7 75 c4 divl -0x3c(%ebp) uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 10fb9e: 29 55 d4 sub %edx,-0x2c(%ebp) link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 10fba1: 3b 5d 0c cmp 0xc(%ebp),%ebx 10fba4: 75 07 jne 10fbad <_Heap_Extend+0xc2> start_block->prev_size = extend_area_end; 10fba6: 89 39 mov %edi,(%ecx) 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 ) 10fba8: 8b 75 d4 mov -0x2c(%ebp),%esi 10fbab: eb 08 jmp 10fbb5 <_Heap_Extend+0xca> merge_above_block = end_block; } else if ( sub_area_end < extend_area_begin ) { 10fbad: 73 06 jae 10fbb5 <_Heap_Extend+0xca> 10fbaf: 8b 55 d4 mov -0x2c(%ebp),%edx 10fbb2: 89 55 cc mov %edx,-0x34(%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; 10fbb5: 8b 45 d4 mov -0x2c(%ebp),%eax 10fbb8: 8b 48 04 mov 0x4(%eax),%ecx 10fbbb: 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); 10fbbe: 01 c1 add %eax,%ecx link_above_block = end_block; } start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) ); } while ( start_block != first_block ); 10fbc0: 3b 4d c0 cmp -0x40(%ebp),%ecx 10fbc3: 75 a9 jne 10fb6e <_Heap_Extend+0x83> 10fbc5: 8b 5d b8 mov -0x48(%ebp),%ebx if ( extend_area_begin < heap->area_begin ) { 10fbc8: 8b 55 0c mov 0xc(%ebp),%edx 10fbcb: 3b 53 18 cmp 0x18(%ebx),%edx 10fbce: 73 05 jae 10fbd5 <_Heap_Extend+0xea> heap->area_begin = extend_area_begin; 10fbd0: 89 53 18 mov %edx,0x18(%ebx) 10fbd3: eb 08 jmp 10fbdd <_Heap_Extend+0xf2> } else if ( heap->area_end < extend_area_end ) { 10fbd5: 39 7b 1c cmp %edi,0x1c(%ebx) 10fbd8: 73 03 jae 10fbdd <_Heap_Extend+0xf2> heap->area_end = extend_area_end; 10fbda: 89 7b 1c mov %edi,0x1c(%ebx) } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 10fbdd: 8b 45 e0 mov -0x20(%ebp),%eax 10fbe0: 8b 55 e4 mov -0x1c(%ebp),%edx heap->area_begin = extend_area_begin; } else if ( heap->area_end < extend_area_end ) { heap->area_end = extend_area_end; } extend_first_block_size = 10fbe3: 89 c1 mov %eax,%ecx 10fbe5: 29 d1 sub %edx,%ecx 10fbe7: 89 4d d4 mov %ecx,-0x2c(%ebp) (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; extend_first_block->prev_size = extend_area_end; 10fbea: 89 3a mov %edi,(%edx) extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 10fbec: 83 c9 01 or $0x1,%ecx 10fbef: 89 4a 04 mov %ecx,0x4(%edx) _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 10fbf2: 8b 4d d4 mov -0x2c(%ebp),%ecx 10fbf5: 89 08 mov %ecx,(%eax) extend_last_block->size_and_flag = 0; 10fbf7: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) _Heap_Protection_block_initialize( heap, extend_last_block ); if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { 10fbfe: 39 53 20 cmp %edx,0x20(%ebx) 10fc01: 76 05 jbe 10fc08 <_Heap_Extend+0x11d> heap->first_block = extend_first_block; 10fc03: 89 53 20 mov %edx,0x20(%ebx) 10fc06: eb 08 jmp 10fc10 <_Heap_Extend+0x125> } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 10fc08: 39 43 24 cmp %eax,0x24(%ebx) 10fc0b: 73 03 jae 10fc10 <_Heap_Extend+0x125> heap->last_block = extend_last_block; 10fc0d: 89 43 24 mov %eax,0x24(%ebx) } if ( merge_below_block != NULL ) { 10fc10: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 10fc14: 74 3b je 10fc51 <_Heap_Extend+0x166> Heap_Control *heap, uintptr_t extend_area_begin, Heap_Block *first_block ) { uintptr_t const page_size = heap->page_size; 10fc16: 8b 43 10 mov 0x10(%ebx),%eax 10fc19: 89 45 d4 mov %eax,-0x2c(%ebp) uintptr_t const new_first_block_alloc_begin = _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 10fc1c: 8b 4d 0c mov 0xc(%ebp),%ecx 10fc1f: 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; 10fc22: 89 c8 mov %ecx,%eax 10fc24: 31 d2 xor %edx,%edx 10fc26: f7 75 d4 divl -0x2c(%ebp) if ( remainder != 0 ) { 10fc29: 85 d2 test %edx,%edx 10fc2b: 74 05 je 10fc32 <_Heap_Extend+0x147> return value - remainder + alignment; 10fc2d: 03 4d d4 add -0x2c(%ebp),%ecx 10fc30: 29 d1 sub %edx,%ecx uintptr_t const new_first_block_begin = 10fc32: 8d 51 f8 lea -0x8(%ecx),%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; 10fc35: 8b 45 d0 mov -0x30(%ebp),%eax 10fc38: 8b 00 mov (%eax),%eax 10fc3a: 89 41 f8 mov %eax,-0x8(%ecx) 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 = 10fc3d: 8b 45 d0 mov -0x30(%ebp),%eax 10fc40: 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; 10fc42: 83 c8 01 or $0x1,%eax 10fc45: 89 42 04 mov %eax,0x4(%edx) _Heap_Free_block( heap, new_first_block ); 10fc48: 89 d8 mov %ebx,%eax 10fc4a: e8 81 fe ff ff call 10fad0 <_Heap_Free_block> 10fc4f: eb 14 jmp 10fc65 <_Heap_Extend+0x17a> 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 ) { 10fc51: 83 7d c8 00 cmpl $0x0,-0x38(%ebp) 10fc55: 74 0e je 10fc65 <_Heap_Extend+0x17a> _Heap_Link_below( 10fc57: 8b 55 e0 mov -0x20(%ebp),%edx { 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; 10fc5a: 8b 45 c8 mov -0x38(%ebp),%eax 10fc5d: 29 d0 sub %edx,%eax 10fc5f: 83 c8 01 or $0x1,%eax 10fc62: 89 42 04 mov %eax,0x4(%edx) link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 10fc65: 85 f6 test %esi,%esi 10fc67: 74 30 je 10fc99 <_Heap_Extend+0x1ae> ) { 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, 10fc69: 83 ef 08 sub $0x8,%edi 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( 10fc6c: 29 f7 sub %esi,%edi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10fc6e: 89 f8 mov %edi,%eax 10fc70: 31 d2 xor %edx,%edx 10fc72: f7 73 10 divl 0x10(%ebx) 10fc75: 29 d7 sub %edx,%edi ); 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) 10fc77: 8b 46 04 mov 0x4(%esi),%eax 10fc7a: 29 f8 sub %edi,%eax | HEAP_PREV_BLOCK_USED; 10fc7c: 83 c8 01 or $0x1,%eax 10fc7f: 89 44 37 04 mov %eax,0x4(%edi,%esi,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; 10fc83: 8b 46 04 mov 0x4(%esi),%eax 10fc86: 83 e0 01 and $0x1,%eax block->size_and_flag = size | flag; 10fc89: 09 f8 or %edi,%eax 10fc8b: 89 46 04 mov %eax,0x4(%esi) _Heap_Block_set_size( last_block, last_block_new_size ); _Heap_Free_block( heap, last_block ); 10fc8e: 89 f2 mov %esi,%edx 10fc90: 89 d8 mov %ebx,%eax 10fc92: e8 39 fe ff ff call 10fad0 <_Heap_Free_block> 10fc97: eb 21 jmp 10fcba <_Heap_Extend+0x1cf> ); } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { 10fc99: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 10fc9d: 74 1b je 10fcba <_Heap_Extend+0x1cf> _Heap_Link_above( 10fc9f: 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 ); 10fca2: 8b 45 e4 mov -0x1c(%ebp),%eax 10fca5: 2b 45 cc sub -0x34(%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; 10fca8: 8b 7d cc mov -0x34(%ebp),%edi 10fcab: 8b 57 04 mov 0x4(%edi),%edx 10fcae: 83 e2 01 and $0x1,%edx block->size_and_flag = size | flag; 10fcb1: 09 d0 or %edx,%eax 10fcb3: 89 47 04 mov %eax,0x4(%edi) last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 10fcb6: 83 49 04 01 orl $0x1,0x4(%ecx) extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 10fcba: 85 f6 test %esi,%esi 10fcbc: 75 10 jne 10fcce <_Heap_Extend+0x1e3> 10fcbe: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 10fcc2: 75 0a jne 10fcce <_Heap_Extend+0x1e3> _Heap_Free_block( heap, extend_first_block ); 10fcc4: 8b 55 e4 mov -0x1c(%ebp),%edx 10fcc7: 89 d8 mov %ebx,%eax 10fcc9: e8 02 fe ff ff call 10fad0 <_Heap_Free_block> */ RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap ) { _Heap_Block_set_size( heap->last_block, (uintptr_t) heap->first_block - (uintptr_t) heap->last_block 10fcce: 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( 10fcd1: 8b 43 20 mov 0x20(%ebx),%eax 10fcd4: 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; 10fcd6: 8b 4a 04 mov 0x4(%edx),%ecx 10fcd9: 83 e1 01 and $0x1,%ecx block->size_and_flag = size | flag; 10fcdc: 09 c8 or %ecx,%eax 10fcde: 89 42 04 mov %eax,0x4(%edx) } _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; 10fce1: 8b 43 30 mov 0x30(%ebx),%eax 10fce4: 2b 45 bc sub -0x44(%ebp),%eax /* Statistics */ stats->size += extended_size; 10fce7: 01 43 2c add %eax,0x2c(%ebx) if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; 10fcea: be 01 00 00 00 mov $0x1,%esi extended_size = stats->free_size - free_size; /* Statistics */ stats->size += extended_size; if ( extended_size_ptr != NULL ) 10fcef: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10fcf3: 74 09 je 10fcfe <_Heap_Extend+0x213> <== NEVER TAKEN *extended_size_ptr = extended_size; 10fcf5: 8b 55 14 mov 0x14(%ebp),%edx 10fcf8: 89 02 mov %eax,(%edx) 10fcfa: eb 02 jmp 10fcfe <_Heap_Extend+0x213> _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; 10fcfc: 31 f6 xor %esi,%esi if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 10fcfe: 89 f0 mov %esi,%eax 10fd00: 8d 65 f4 lea -0xc(%ebp),%esp 10fd03: 5b pop %ebx 10fd04: 5e pop %esi 10fd05: 5f pop %edi 10fd06: c9 leave 10fd07: c3 ret =============================================================================== 0010f730 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 10f730: 55 push %ebp 10f731: 89 e5 mov %esp,%ebp 10f733: 57 push %edi 10f734: 56 push %esi 10f735: 53 push %ebx 10f736: 83 ec 14 sub $0x14,%esp 10f739: 8b 4d 08 mov 0x8(%ebp),%ecx 10f73c: 8b 55 0c mov 0xc(%ebp),%edx * 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; 10f73f: b0 01 mov $0x1,%al /* * 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 ) { 10f741: 85 d2 test %edx,%edx 10f743: 0f 84 4b 01 00 00 je 10f894 <_Heap_Free+0x164> 10f749: 8d 5a f8 lea -0x8(%edx),%ebx 10f74c: 89 d0 mov %edx,%eax 10f74e: 31 d2 xor %edx,%edx 10f750: 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); 10f753: 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 10f755: 8b 41 20 mov 0x20(%ecx),%eax 10f758: 89 45 ec mov %eax,-0x14(%ebp) && (uintptr_t) block <= (uintptr_t) heap->last_block; 10f75b: 31 d2 xor %edx,%edx 10f75d: 39 c3 cmp %eax,%ebx 10f75f: 72 08 jb 10f769 <_Heap_Free+0x39> 10f761: 31 d2 xor %edx,%edx 10f763: 39 59 24 cmp %ebx,0x24(%ecx) 10f766: 0f 93 c2 setae %dl alloc_begin = (uintptr_t) alloc_begin_ptr; block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size ); if ( !_Heap_Is_block_in_heap( heap, block ) ) { return false; 10f769: 31 c0 xor %eax,%eax } alloc_begin = (uintptr_t) alloc_begin_ptr; block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size ); if ( !_Heap_Is_block_in_heap( heap, block ) ) { 10f76b: 85 d2 test %edx,%edx 10f76d: 0f 84 21 01 00 00 je 10f894 <_Heap_Free+0x164> --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10f773: 8b 43 04 mov 0x4(%ebx),%eax 10f776: 89 45 f0 mov %eax,-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; 10f779: 89 c6 mov %eax,%esi 10f77b: 83 e6 fe and $0xfffffffe,%esi RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10f77e: 8d 14 33 lea (%ebx,%esi,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; 10f781: 31 ff xor %edi,%edi 10f783: 3b 55 ec cmp -0x14(%ebp),%edx 10f786: 72 0a jb 10f792 <_Heap_Free+0x62> <== NEVER TAKEN 10f788: 31 c0 xor %eax,%eax 10f78a: 39 51 24 cmp %edx,0x24(%ecx) 10f78d: 0f 93 c0 setae %al 10f790: 89 c7 mov %eax,%edi block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { return false; 10f792: 31 c0 xor %eax,%eax _Heap_Protection_block_check( heap, block ); block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { 10f794: 85 ff test %edi,%edi 10f796: 0f 84 f8 00 00 00 je 10f894 <_Heap_Free+0x164> <== NEVER TAKEN --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10f79c: 8b 7a 04 mov 0x4(%edx),%edi return false; } _Heap_Protection_block_check( heap, next_block ); if ( !_Heap_Is_prev_used( next_block ) ) { 10f79f: f7 c7 01 00 00 00 test $0x1,%edi 10f7a5: 0f 84 e9 00 00 00 je 10f894 <_Heap_Free+0x164> <== 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; 10f7ab: 83 e7 fe and $0xfffffffe,%edi 10f7ae: 89 7d e8 mov %edi,-0x18(%ebp) if ( !_Heap_Protection_determine_block_free( heap, block ) ) { return true; } next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block 10f7b1: 8b 41 24 mov 0x24(%ecx),%eax 10f7b4: 89 45 e4 mov %eax,-0x1c(%ebp) && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); 10f7b7: 31 c0 xor %eax,%eax 10f7b9: 3b 55 e4 cmp -0x1c(%ebp),%edx 10f7bc: 74 0a je 10f7c8 <_Heap_Free+0x98> 10f7be: 31 c0 xor %eax,%eax 10f7c0: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1) 10f7c5: 0f 94 c0 sete %al if ( !_Heap_Protection_determine_block_free( heap, block ) ) { return true; } next_block_size = _Heap_Block_size( next_block ); next_is_free = next_block != heap->last_block 10f7c8: 88 45 e3 mov %al,-0x1d(%ebp) && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); if ( !_Heap_Is_prev_used( block ) ) { 10f7cb: f6 45 f0 01 testb $0x1,-0x10(%ebp) 10f7cf: 75 62 jne 10f833 <_Heap_Free+0x103> uintptr_t const prev_size = block->prev_size; 10f7d1: 8b 03 mov (%ebx),%eax 10f7d3: 89 45 f0 mov %eax,-0x10(%ebp) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10f7d6: 29 c3 sub %eax,%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; 10f7d8: 31 ff xor %edi,%edi 10f7da: 3b 5d ec cmp -0x14(%ebp),%ebx 10f7dd: 72 0a jb 10f7e9 <_Heap_Free+0xb9> <== NEVER TAKEN 10f7df: 31 c0 xor %eax,%eax 10f7e1: 39 5d e4 cmp %ebx,-0x1c(%ebp) 10f7e4: 0f 93 c0 setae %al 10f7e7: 89 c7 mov %eax,%edi Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size ); if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) { _HAssert( false ); return( false ); 10f7e9: 31 c0 xor %eax,%eax if ( !_Heap_Is_prev_used( block ) ) { uintptr_t const prev_size = block->prev_size; Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size ); if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) { 10f7eb: 85 ff test %edi,%edi 10f7ed: 0f 84 a1 00 00 00 je 10f894 <_Heap_Free+0x164> <== 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) ) { 10f7f3: f6 43 04 01 testb $0x1,0x4(%ebx) 10f7f7: 0f 84 97 00 00 00 je 10f894 <_Heap_Free+0x164> <== NEVER TAKEN _HAssert( false ); return( false ); } if ( next_is_free ) { /* coalesce both */ 10f7fd: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 10f801: 74 1a je 10f81d <_Heap_Free+0xed> uintptr_t const size = block_size + prev_size + next_block_size; 10f803: 8b 45 e8 mov -0x18(%ebp),%eax 10f806: 8d 04 06 lea (%esi,%eax,1),%eax 10f809: 03 45 f0 add -0x10(%ebp),%eax return _Heap_Free_list_tail(heap)->prev; } RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block ) { Heap_Block *next = block->next; 10f80c: 8b 7a 08 mov 0x8(%edx),%edi Heap_Block *prev = block->prev; 10f80f: 8b 52 0c mov 0xc(%edx),%edx prev->next = next; 10f812: 89 7a 08 mov %edi,0x8(%edx) next->prev = prev; 10f815: 89 57 0c mov %edx,0xc(%edi) _Heap_Free_list_remove( next_block ); stats->free_blocks -= 1; 10f818: ff 49 38 decl 0x38(%ecx) 10f81b: eb 33 jmp 10f850 <_Heap_Free+0x120> 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; 10f81d: 8b 45 f0 mov -0x10(%ebp),%eax 10f820: 8d 04 06 lea (%esi,%eax,1),%eax prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 10f823: 89 c7 mov %eax,%edi 10f825: 83 cf 01 or $0x1,%edi 10f828: 89 7b 04 mov %edi,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10f82b: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = size; 10f82f: 89 02 mov %eax,(%edx) 10f831: eb 56 jmp 10f889 <_Heap_Free+0x159> } } else if ( next_is_free ) { /* coalesce next */ 10f833: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 10f837: 74 24 je 10f85d <_Heap_Free+0x12d> uintptr_t const size = block_size + next_block_size; 10f839: 8b 45 e8 mov -0x18(%ebp),%eax 10f83c: 01 f0 add %esi,%eax RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace( Heap_Block *old_block, Heap_Block *new_block ) { Heap_Block *next = old_block->next; 10f83e: 8b 7a 08 mov 0x8(%edx),%edi Heap_Block *prev = old_block->prev; 10f841: 8b 52 0c mov 0xc(%edx),%edx new_block->next = next; 10f844: 89 7b 08 mov %edi,0x8(%ebx) new_block->prev = prev; 10f847: 89 53 0c mov %edx,0xc(%ebx) next->prev = new_block; 10f84a: 89 5f 0c mov %ebx,0xc(%edi) prev->next = new_block; 10f84d: 89 5a 08 mov %ebx,0x8(%edx) _Heap_Free_list_replace( next_block, block ); block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 10f850: 89 c2 mov %eax,%edx 10f852: 83 ca 01 or $0x1,%edx 10f855: 89 53 04 mov %edx,0x4(%ebx) next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 10f858: 89 04 03 mov %eax,(%ebx,%eax,1) 10f85b: eb 2c jmp 10f889 <_Heap_Free+0x159> RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after( Heap_Block *block_before, Heap_Block *new_block ) { Heap_Block *next = block_before->next; 10f85d: 8b 41 08 mov 0x8(%ecx),%eax new_block->next = next; 10f860: 89 43 08 mov %eax,0x8(%ebx) new_block->prev = block_before; 10f863: 89 4b 0c mov %ecx,0xc(%ebx) block_before->next = new_block; 10f866: 89 59 08 mov %ebx,0x8(%ecx) next->prev = new_block; 10f869: 89 58 0c mov %ebx,0xc(%eax) } 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; 10f86c: 89 f0 mov %esi,%eax 10f86e: 83 c8 01 or $0x1,%eax 10f871: 89 43 04 mov %eax,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10f874: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = block_size; 10f878: 89 32 mov %esi,(%edx) /* Statistics */ ++stats->free_blocks; 10f87a: 8b 41 38 mov 0x38(%ecx),%eax 10f87d: 40 inc %eax 10f87e: 89 41 38 mov %eax,0x38(%ecx) if ( stats->max_free_blocks < stats->free_blocks ) { 10f881: 39 41 3c cmp %eax,0x3c(%ecx) 10f884: 73 03 jae 10f889 <_Heap_Free+0x159> stats->max_free_blocks = stats->free_blocks; 10f886: 89 41 3c mov %eax,0x3c(%ecx) } } /* Statistics */ --stats->used_blocks; 10f889: ff 49 40 decl 0x40(%ecx) ++stats->frees; 10f88c: ff 41 50 incl 0x50(%ecx) stats->free_size += block_size; 10f88f: 01 71 30 add %esi,0x30(%ecx) return( true ); 10f892: b0 01 mov $0x1,%al } 10f894: 83 c4 14 add $0x14,%esp 10f897: 5b pop %ebx 10f898: 5e pop %esi 10f899: 5f pop %edi 10f89a: c9 leave 10f89b: c3 ret =============================================================================== 0011d4e0 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) { 11d4e0: 55 push %ebp 11d4e1: 89 e5 mov %esp,%ebp 11d4e3: 57 push %edi 11d4e4: 56 push %esi 11d4e5: 53 push %ebx 11d4e6: 8b 5d 08 mov 0x8(%ebp),%ebx 11d4e9: 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); 11d4ec: 8d 4e f8 lea -0x8(%esi),%ecx 11d4ef: 89 f0 mov %esi,%eax 11d4f1: 31 d2 xor %edx,%edx 11d4f3: 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); 11d4f6: 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 11d4f8: 8b 53 20 mov 0x20(%ebx),%edx && (uintptr_t) block <= (uintptr_t) heap->last_block; 11d4fb: 31 ff xor %edi,%edi 11d4fd: 39 d1 cmp %edx,%ecx 11d4ff: 72 0a jb 11d50b <_Heap_Size_of_alloc_area+0x2b> 11d501: 31 c0 xor %eax,%eax 11d503: 39 4b 24 cmp %ecx,0x24(%ebx) 11d506: 0f 93 c0 setae %al 11d509: 89 c7 mov %eax,%edi Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size ); Heap_Block *next_block = NULL; uintptr_t block_size = 0; if ( !_Heap_Is_block_in_heap( heap, block ) ) { return false; 11d50b: 31 c0 xor %eax,%eax uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr; Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size ); Heap_Block *next_block = NULL; uintptr_t block_size = 0; if ( !_Heap_Is_block_in_heap( heap, block ) ) { 11d50d: 85 ff test %edi,%edi 11d50f: 74 30 je 11d541 <_Heap_Size_of_alloc_area+0x61> - 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; 11d511: 8b 41 04 mov 0x4(%ecx),%eax 11d514: 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); 11d517: 01 c1 add %eax,%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; 11d519: 31 ff xor %edi,%edi 11d51b: 39 d1 cmp %edx,%ecx 11d51d: 72 0a jb 11d529 <_Heap_Size_of_alloc_area+0x49><== NEVER TAKEN 11d51f: 31 c0 xor %eax,%eax 11d521: 39 4b 24 cmp %ecx,0x24(%ebx) 11d524: 0f 93 c0 setae %al 11d527: 89 c7 mov %eax,%edi if ( !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) ) { return false; 11d529: 31 c0 xor %eax,%eax } block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( 11d52b: 85 ff test %edi,%edi 11d52d: 74 12 je 11d541 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) 11d52f: f6 41 04 01 testb $0x1,0x4(%ecx) 11d533: 74 0c je 11d541 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 11d535: 29 f1 sub %esi,%ecx 11d537: 8d 51 04 lea 0x4(%ecx),%edx 11d53a: 8b 45 10 mov 0x10(%ebp),%eax 11d53d: 89 10 mov %edx,(%eax) return true; 11d53f: b0 01 mov $0x1,%al } 11d541: 5b pop %ebx 11d542: 5e pop %esi 11d543: 5f pop %edi 11d544: c9 leave 11d545: c3 ret =============================================================================== 0010bca6 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 10bca6: 55 push %ebp 10bca7: 89 e5 mov %esp,%ebp 10bca9: 57 push %edi 10bcaa: 56 push %esi 10bcab: 53 push %ebx 10bcac: 83 ec 4c sub $0x4c,%esp 10bcaf: 8b 75 08 mov 0x8(%ebp),%esi 10bcb2: 8b 5d 0c mov 0xc(%ebp),%ebx uintptr_t const page_size = heap->page_size; 10bcb5: 8b 46 10 mov 0x10(%esi),%eax 10bcb8: 89 45 d8 mov %eax,-0x28(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10bcbb: 8b 4e 14 mov 0x14(%esi),%ecx 10bcbe: 89 4d d4 mov %ecx,-0x2c(%ebp) Heap_Block *const first_block = heap->first_block; 10bcc1: 8b 46 20 mov 0x20(%esi),%eax 10bcc4: 89 45 d0 mov %eax,-0x30(%ebp) Heap_Block *const last_block = heap->last_block; 10bcc7: 8b 4e 24 mov 0x24(%esi),%ecx 10bcca: 89 4d c8 mov %ecx,-0x38(%ebp) Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 10bccd: c7 45 e4 68 bc 10 00 movl $0x10bc68,-0x1c(%ebp) 10bcd4: 80 7d 10 00 cmpb $0x0,0x10(%ebp) 10bcd8: 74 07 je 10bce1 <_Heap_Walk+0x3b> 10bcda: c7 45 e4 6d bc 10 00 movl $0x10bc6d,-0x1c(%ebp) if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; 10bce1: b0 01 mov $0x1,%al 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; if ( !_System_state_Is_up( _System_state_Get() ) ) { 10bce3: 83 3d 24 75 12 00 03 cmpl $0x3,0x127524 10bcea: 0f 85 e8 02 00 00 jne 10bfd8 <_Heap_Walk+0x332> 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)( 10bcf0: 52 push %edx 10bcf1: ff 76 0c pushl 0xc(%esi) 10bcf4: ff 76 08 pushl 0x8(%esi) 10bcf7: ff 75 c8 pushl -0x38(%ebp) 10bcfa: ff 75 d0 pushl -0x30(%ebp) 10bcfd: ff 76 1c pushl 0x1c(%esi) 10bd00: ff 76 18 pushl 0x18(%esi) 10bd03: ff 75 d4 pushl -0x2c(%ebp) 10bd06: ff 75 d8 pushl -0x28(%ebp) 10bd09: 68 dd 00 12 00 push $0x1200dd 10bd0e: 6a 00 push $0x0 10bd10: 53 push %ebx 10bd11: ff 55 e4 call *-0x1c(%ebp) heap->area_begin, heap->area_end, first_block, last_block, first_free_block, last_free_block ); if ( page_size == 0 ) { 10bd14: 83 c4 30 add $0x30,%esp 10bd17: 83 7d d8 00 cmpl $0x0,-0x28(%ebp) 10bd1b: 75 0b jne 10bd28 <_Heap_Walk+0x82> (*printer)( source, true, "page size is zero\n" ); 10bd1d: 50 push %eax 10bd1e: 68 6e 01 12 00 push $0x12016e 10bd23: e9 6b 02 00 00 jmp 10bf93 <_Heap_Walk+0x2ed> return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 10bd28: f6 45 d8 03 testb $0x3,-0x28(%ebp) 10bd2c: 74 0d je 10bd3b <_Heap_Walk+0x95> (*printer)( 10bd2e: ff 75 d8 pushl -0x28(%ebp) 10bd31: 68 81 01 12 00 push $0x120181 10bd36: e9 58 02 00 00 jmp 10bf93 <_Heap_Walk+0x2ed> RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bd3b: 8b 45 d4 mov -0x2c(%ebp),%eax 10bd3e: 31 d2 xor %edx,%edx 10bd40: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 10bd43: 85 d2 test %edx,%edx 10bd45: 74 0d je 10bd54 <_Heap_Walk+0xae> (*printer)( 10bd47: ff 75 d4 pushl -0x2c(%ebp) 10bd4a: 68 9f 01 12 00 push $0x12019f 10bd4f: e9 3f 02 00 00 jmp 10bf93 <_Heap_Walk+0x2ed> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10bd54: 8b 45 d0 mov -0x30(%ebp),%eax 10bd57: 83 c0 08 add $0x8,%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bd5a: 31 d2 xor %edx,%edx 10bd5c: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( 10bd5f: 85 d2 test %edx,%edx 10bd61: 74 0d je 10bd70 <_Heap_Walk+0xca> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size ) ) { (*printer)( 10bd63: ff 75 d0 pushl -0x30(%ebp) 10bd66: 68 c3 01 12 00 push $0x1201c3 10bd6b: e9 23 02 00 00 jmp 10bf93 <_Heap_Walk+0x2ed> ); return false; } if ( !_Heap_Is_prev_used( first_block ) ) { 10bd70: 8b 45 d0 mov -0x30(%ebp),%eax 10bd73: f6 40 04 01 testb $0x1,0x4(%eax) 10bd77: 75 0b jne 10bd84 <_Heap_Walk+0xde> (*printer)( 10bd79: 57 push %edi 10bd7a: 68 f4 01 12 00 push $0x1201f4 10bd7f: e9 0f 02 00 00 jmp 10bf93 <_Heap_Walk+0x2ed> - 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; 10bd84: 8b 4d c8 mov -0x38(%ebp),%ecx 10bd87: 8b 79 04 mov 0x4(%ecx),%edi 10bd8a: 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); 10bd8d: 01 cf add %ecx,%edi ); return false; } if ( _Heap_Is_free( last_block ) ) { 10bd8f: f6 47 04 01 testb $0x1,0x4(%edi) 10bd93: 75 0b jne 10bda0 <_Heap_Walk+0xfa> (*printer)( 10bd95: 56 push %esi 10bd96: 68 22 02 12 00 push $0x120222 10bd9b: e9 f3 01 00 00 jmp 10bf93 <_Heap_Walk+0x2ed> ); return false; } if ( 10bda0: 3b 7d d0 cmp -0x30(%ebp),%edi 10bda3: 74 0b je 10bdb0 <_Heap_Walk+0x10a> _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block ) { (*printer)( 10bda5: 51 push %ecx 10bda6: 68 37 02 12 00 push $0x120237 10bdab: e9 e3 01 00 00 jmp 10bf93 <_Heap_Walk+0x2ed> int source, Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; 10bdb0: 8b 46 10 mov 0x10(%esi),%eax 10bdb3: 89 45 e0 mov %eax,-0x20(%ebp) block = next_block; } while ( block != first_block ); return true; } 10bdb6: 8b 4e 08 mov 0x8(%esi),%ecx Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); 10bdb9: 89 75 dc mov %esi,-0x24(%ebp) 10bdbc: eb 75 jmp 10be33 <_Heap_Walk+0x18d> 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; 10bdbe: 31 c0 xor %eax,%eax 10bdc0: 39 4e 20 cmp %ecx,0x20(%esi) 10bdc3: 77 08 ja 10bdcd <_Heap_Walk+0x127> 10bdc5: 31 c0 xor %eax,%eax 10bdc7: 39 4e 24 cmp %ecx,0x24(%esi) 10bdca: 0f 93 c0 setae %al 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 ) { if ( !_Heap_Is_block_in_heap( heap, free_block ) ) { 10bdcd: 85 c0 test %eax,%eax 10bdcf: 75 0b jne 10bddc <_Heap_Walk+0x136> (*printer)( 10bdd1: 51 push %ecx 10bdd2: 68 66 02 12 00 push $0x120266 10bdd7: e9 b7 01 00 00 jmp 10bf93 <_Heap_Walk+0x2ed> RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 10bddc: 8d 41 08 lea 0x8(%ecx),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bddf: 31 d2 xor %edx,%edx 10bde1: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( 10bde4: 85 d2 test %edx,%edx 10bde6: 74 0b je 10bdf3 <_Heap_Walk+0x14d> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size ) ) { (*printer)( 10bde8: 51 push %ecx 10bde9: 68 86 02 12 00 push $0x120286 10bdee: e9 a0 01 00 00 jmp 10bf93 <_Heap_Walk+0x2ed> - 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; 10bdf3: 8b 41 04 mov 0x4(%ecx),%eax 10bdf6: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10bdf9: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1) 10bdfe: 74 0b je 10be0b <_Heap_Walk+0x165> (*printer)( 10be00: 51 push %ecx 10be01: 68 b6 02 12 00 push $0x1202b6 10be06: e9 88 01 00 00 jmp 10bf93 <_Heap_Walk+0x2ed> ); return false; } if ( free_block->prev != prev_block ) { 10be0b: 8b 41 0c mov 0xc(%ecx),%eax 10be0e: 3b 45 dc cmp -0x24(%ebp),%eax 10be11: 74 1a je 10be2d <_Heap_Walk+0x187> (*printer)( 10be13: 83 ec 0c sub $0xc,%esp 10be16: 50 push %eax 10be17: 51 push %ecx 10be18: 68 d2 02 12 00 push $0x1202d2 10be1d: 6a 01 push $0x1 10be1f: 53 push %ebx 10be20: ff 55 e4 call *-0x1c(%ebp) 10be23: 83 c4 20 add $0x20,%esp if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; } if ( !_Heap_Walk_check_control( source, printer, heap ) ) { return false; 10be26: 31 c0 xor %eax,%eax 10be28: e9 ab 01 00 00 jmp 10bfd8 <_Heap_Walk+0x332> return false; } prev_block = free_block; free_block = free_block->next; 10be2d: 89 4d dc mov %ecx,-0x24(%ebp) 10be30: 8b 49 08 mov 0x8(%ecx),%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 ) { 10be33: 39 f1 cmp %esi,%ecx 10be35: 75 87 jne 10bdbe <_Heap_Walk+0x118> 10be37: 89 5d dc mov %ebx,-0x24(%ebp) 10be3a: eb 02 jmp 10be3e <_Heap_Walk+0x198> block->prev_size ); } block = next_block; } while ( block != first_block ); 10be3c: 89 df mov %ebx,%edi return true; } 10be3e: 8b 4f 04 mov 0x4(%edi),%ecx 10be41: 89 4d cc mov %ecx,-0x34(%ebp) 10be44: 83 e1 fe and $0xfffffffe,%ecx 10be47: 89 4d e0 mov %ecx,-0x20(%ebp) RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at( const Heap_Block *block, uintptr_t offset ) { return (Heap_Block *) ((uintptr_t) block + offset); 10be4a: 8d 1c 0f lea (%edi,%ecx,1),%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; 10be4d: 31 c0 xor %eax,%eax 10be4f: 39 5e 20 cmp %ebx,0x20(%esi) 10be52: 77 08 ja 10be5c <_Heap_Walk+0x1b6> <== NEVER TAKEN 10be54: 31 c0 xor %eax,%eax 10be56: 39 5e 24 cmp %ebx,0x24(%esi) 10be59: 0f 93 c0 setae %al 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; if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { 10be5c: 85 c0 test %eax,%eax 10be5e: 75 11 jne 10be71 <_Heap_Walk+0x1cb> 10be60: 89 d9 mov %ebx,%ecx 10be62: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10be65: 83 ec 0c sub $0xc,%esp 10be68: 51 push %ecx 10be69: 57 push %edi 10be6a: 68 04 03 12 00 push $0x120304 10be6f: eb ac jmp 10be1d <_Heap_Walk+0x177> 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; 10be71: 3b 7d c8 cmp -0x38(%ebp),%edi 10be74: 0f 95 c1 setne %cl RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10be77: 8b 45 e0 mov -0x20(%ebp),%eax 10be7a: 31 d2 xor %edx,%edx 10be7c: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 10be7f: 85 d2 test %edx,%edx 10be81: 74 15 je 10be98 <_Heap_Walk+0x1f2> 10be83: 84 c9 test %cl,%cl 10be85: 74 11 je 10be98 <_Heap_Walk+0x1f2> 10be87: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10be8a: 83 ec 0c sub $0xc,%esp 10be8d: ff 75 e0 pushl -0x20(%ebp) 10be90: 57 push %edi 10be91: 68 31 03 12 00 push $0x120331 10be96: eb 85 jmp 10be1d <_Heap_Walk+0x177> ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 10be98: 8b 45 d4 mov -0x2c(%ebp),%eax 10be9b: 39 45 e0 cmp %eax,-0x20(%ebp) 10be9e: 73 18 jae 10beb8 <_Heap_Walk+0x212> 10bea0: 84 c9 test %cl,%cl 10bea2: 74 14 je 10beb8 <_Heap_Walk+0x212> <== NEVER TAKEN 10bea4: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bea7: 52 push %edx 10bea8: 52 push %edx 10bea9: 50 push %eax 10beaa: ff 75 e0 pushl -0x20(%ebp) 10bead: 57 push %edi 10beae: 68 5f 03 12 00 push $0x12035f 10beb3: e9 65 ff ff ff jmp 10be1d <_Heap_Walk+0x177> ); return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { 10beb8: 39 fb cmp %edi,%ebx 10beba: 77 18 ja 10bed4 <_Heap_Walk+0x22e> 10bebc: 84 c9 test %cl,%cl 10bebe: 74 14 je 10bed4 <_Heap_Walk+0x22e> 10bec0: 89 d9 mov %ebx,%ecx 10bec2: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bec5: 83 ec 0c sub $0xc,%esp 10bec8: 51 push %ecx 10bec9: 57 push %edi 10beca: 68 8a 03 12 00 push $0x12038a 10becf: e9 49 ff ff ff jmp 10be1d <_Heap_Walk+0x177> 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; 10bed4: 8b 4d cc mov -0x34(%ebp),%ecx 10bed7: 83 e1 01 and $0x1,%ecx 10beda: 89 4d c4 mov %ecx,-0x3c(%ebp) ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 10bedd: f6 43 04 01 testb $0x1,0x4(%ebx) 10bee1: 0f 85 ba 00 00 00 jne 10bfa1 <_Heap_Walk+0x2fb> block = next_block; } while ( block != first_block ); return true; } 10bee7: 8b 46 08 mov 0x8(%esi),%eax 10beea: 89 45 c0 mov %eax,-0x40(%ebp) block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? 10beed: 8b 4f 08 mov 0x8(%edi),%ecx 10bef0: 89 4d b4 mov %ecx,-0x4c(%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)( 10bef3: ba aa 00 12 00 mov $0x1200aa,%edx 10bef8: 3b 4e 0c cmp 0xc(%esi),%ecx 10befb: 74 0e je 10bf0b <_Heap_Walk+0x265> " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), block->next, block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") 10befd: ba f1 ff 11 00 mov $0x11fff1,%edx 10bf02: 39 f1 cmp %esi,%ecx 10bf04: 75 05 jne 10bf0b <_Heap_Walk+0x265> 10bf06: ba b9 00 12 00 mov $0x1200b9,%edx 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 ? 10bf0b: 8b 47 0c mov 0xc(%edi),%eax 10bf0e: 89 45 cc mov %eax,-0x34(%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)( 10bf11: b8 c3 00 12 00 mov $0x1200c3,%eax 10bf16: 8b 4d c0 mov -0x40(%ebp),%ecx 10bf19: 39 4d cc cmp %ecx,-0x34(%ebp) 10bf1c: 74 0f je 10bf2d <_Heap_Walk+0x287> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10bf1e: b8 f1 ff 11 00 mov $0x11fff1,%eax 10bf23: 39 75 cc cmp %esi,-0x34(%ebp) 10bf26: 75 05 jne 10bf2d <_Heap_Walk+0x287> 10bf28: b8 d3 00 12 00 mov $0x1200d3,%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)( 10bf2d: 83 ec 0c sub $0xc,%esp 10bf30: 52 push %edx 10bf31: ff 75 b4 pushl -0x4c(%ebp) 10bf34: 50 push %eax 10bf35: ff 75 cc pushl -0x34(%ebp) 10bf38: ff 75 e0 pushl -0x20(%ebp) 10bf3b: 57 push %edi 10bf3c: 68 be 03 12 00 push $0x1203be 10bf41: 6a 00 push $0x0 10bf43: ff 75 dc pushl -0x24(%ebp) 10bf46: ff 55 e4 call *-0x1c(%ebp) block->next == last_free_block ? " (= last free)" : (block->next == free_list_tail ? " (= tail)" : "") ); if ( block_size != next_block->prev_size ) { 10bf49: 8b 03 mov (%ebx),%eax 10bf4b: 83 c4 30 add $0x30,%esp 10bf4e: 39 45 e0 cmp %eax,-0x20(%ebp) 10bf51: 74 16 je 10bf69 <_Heap_Walk+0x2c3> 10bf53: 89 d9 mov %ebx,%ecx 10bf55: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bf58: 56 push %esi 10bf59: 51 push %ecx 10bf5a: 50 push %eax 10bf5b: ff 75 e0 pushl -0x20(%ebp) 10bf5e: 57 push %edi 10bf5f: 68 f3 03 12 00 push $0x1203f3 10bf64: e9 b4 fe ff ff jmp 10be1d <_Heap_Walk+0x177> ); return false; } if ( !prev_used ) { 10bf69: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 10bf6d: 75 0b jne 10bf7a <_Heap_Walk+0x2d4> 10bf6f: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bf72: 57 push %edi 10bf73: 68 2c 04 12 00 push $0x12042c 10bf78: eb 19 jmp 10bf93 <_Heap_Walk+0x2ed> block = next_block; } while ( block != first_block ); return true; } 10bf7a: 8b 46 08 mov 0x8(%esi),%eax 10bf7d: eb 07 jmp 10bf86 <_Heap_Walk+0x2e0> { 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 ) { if ( free_block == block ) { 10bf7f: 39 f8 cmp %edi,%eax 10bf81: 74 4a je 10bfcd <_Heap_Walk+0x327> return true; } free_block = free_block->next; 10bf83: 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 ) { 10bf86: 39 f0 cmp %esi,%eax 10bf88: 75 f5 jne 10bf7f <_Heap_Walk+0x2d9> 10bf8a: 8b 5d dc mov -0x24(%ebp),%ebx return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10bf8d: 57 push %edi 10bf8e: 68 97 04 12 00 push $0x120497 10bf93: 6a 01 push $0x1 10bf95: 53 push %ebx 10bf96: ff 55 e4 call *-0x1c(%ebp) 10bf99: 83 c4 10 add $0x10,%esp 10bf9c: e9 85 fe ff ff jmp 10be26 <_Heap_Walk+0x180> if ( !_Heap_Is_prev_used( next_block ) ) { if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) { return false; } } else if (prev_used) { 10bfa1: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 10bfa5: 74 0e je 10bfb5 <_Heap_Walk+0x30f> (*printer)( 10bfa7: 83 ec 0c sub $0xc,%esp 10bfaa: ff 75 e0 pushl -0x20(%ebp) 10bfad: 57 push %edi 10bfae: 68 5b 04 12 00 push $0x12045b 10bfb3: eb 0d jmp 10bfc2 <_Heap_Walk+0x31c> "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 10bfb5: 51 push %ecx 10bfb6: 51 push %ecx 10bfb7: ff 37 pushl (%edi) 10bfb9: ff 75 e0 pushl -0x20(%ebp) 10bfbc: 57 push %edi 10bfbd: 68 72 04 12 00 push $0x120472 10bfc2: 6a 00 push $0x0 10bfc4: ff 75 dc pushl -0x24(%ebp) 10bfc7: ff 55 e4 call *-0x1c(%ebp) 10bfca: 83 c4 20 add $0x20,%esp block->prev_size ); } block = next_block; } while ( block != first_block ); 10bfcd: 3b 5d d0 cmp -0x30(%ebp),%ebx 10bfd0: 0f 85 66 fe ff ff jne 10be3c <_Heap_Walk+0x196> return true; 10bfd6: b0 01 mov $0x1,%al } 10bfd8: 8d 65 f4 lea -0xc(%ebp),%esp 10bfdb: 5b pop %ebx 10bfdc: 5e pop %esi 10bfdd: 5f pop %edi 10bfde: c9 leave 10bfdf: c3 ret =============================================================================== 0010b28c <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10b28c: 55 push %ebp 10b28d: 89 e5 mov %esp,%ebp 10b28f: 53 push %ebx 10b290: 83 ec 08 sub $0x8,%esp 10b293: 8b 45 08 mov 0x8(%ebp),%eax 10b296: 8b 55 0c mov 0xc(%ebp),%edx 10b299: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10b29c: a3 d8 53 12 00 mov %eax,0x1253d8 _Internal_errors_What_happened.is_internal = is_internal; 10b2a1: 88 15 dc 53 12 00 mov %dl,0x1253dc _Internal_errors_What_happened.the_error = the_error; 10b2a7: 89 1d e0 53 12 00 mov %ebx,0x1253e0 _User_extensions_Fatal( the_source, is_internal, the_error ); 10b2ad: 53 push %ebx 10b2ae: 0f b6 d2 movzbl %dl,%edx 10b2b1: 52 push %edx 10b2b2: 50 push %eax 10b2b3: e8 37 1a 00 00 call 10ccef <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 10b2b8: c7 05 9c 54 12 00 05 movl $0x5,0x12549c <== NOT EXECUTED 10b2bf: 00 00 00 _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10b2c2: fa cli <== NOT EXECUTED 10b2c3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b2c5: f4 hlt <== NOT EXECUTED 10b2c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b2c9: eb fe jmp 10b2c9 <_Internal_error_Occurred+0x3d><== NOT EXECUTED =============================================================================== 0010b31c <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10b31c: 55 push %ebp 10b31d: 89 e5 mov %esp,%ebp 10b31f: 56 push %esi 10b320: 53 push %ebx 10b321: 8b 5d 08 mov 0x8(%ebp),%ebx * 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 ) return NULL; 10b324: 31 c9 xor %ecx,%ecx * 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 ) 10b326: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 10b32a: 74 53 je 10b37f <_Objects_Allocate+0x63><== NEVER TAKEN /* * 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 ); 10b32c: 8d 73 20 lea 0x20(%ebx),%esi 10b32f: 83 ec 0c sub $0xc,%esp 10b332: 56 push %esi 10b333: e8 38 f7 ff ff call 10aa70 <_Chain_Get> 10b338: 89 c1 mov %eax,%ecx if ( information->auto_extend ) { 10b33a: 83 c4 10 add $0x10,%esp 10b33d: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10b341: 74 3c je 10b37f <_Objects_Allocate+0x63> /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10b343: 85 c0 test %eax,%eax 10b345: 75 1a jne 10b361 <_Objects_Allocate+0x45> _Objects_Extend_information( information ); 10b347: 83 ec 0c sub $0xc,%esp 10b34a: 53 push %ebx 10b34b: e8 60 00 00 00 call 10b3b0 <_Objects_Extend_information> the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10b350: 89 34 24 mov %esi,(%esp) 10b353: e8 18 f7 ff ff call 10aa70 <_Chain_Get> 10b358: 89 c1 mov %eax,%ecx } if ( the_object ) { 10b35a: 83 c4 10 add $0x10,%esp 10b35d: 85 c0 test %eax,%eax 10b35f: 74 1e je 10b37f <_Objects_Allocate+0x63> uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 10b361: 0f b7 41 08 movzwl 0x8(%ecx),%eax 10b365: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10b369: 29 d0 sub %edx,%eax _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; 10b36b: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10b36f: 31 d2 xor %edx,%edx 10b371: f7 f6 div %esi information->inactive_per_block[ block ]--; 10b373: c1 e0 02 shl $0x2,%eax 10b376: 03 43 30 add 0x30(%ebx),%eax 10b379: ff 08 decl (%eax) information->inactive--; 10b37b: 66 ff 4b 2c decw 0x2c(%ebx) ); } #endif return the_object; } 10b37f: 89 c8 mov %ecx,%eax 10b381: 8d 65 f8 lea -0x8(%ebp),%esp 10b384: 5b pop %ebx 10b385: 5e pop %esi 10b386: c9 leave 10b387: c3 ret =============================================================================== 0010b6a0 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 10b6a0: 55 push %ebp 10b6a1: 89 e5 mov %esp,%ebp 10b6a3: 57 push %edi 10b6a4: 56 push %esi 10b6a5: 53 push %ebx 10b6a6: 83 ec 0c sub $0xc,%esp 10b6a9: 8b 75 08 mov 0x8(%ebp),%esi 10b6ac: 8b 7d 0c mov 0xc(%ebp),%edi Objects_Information *info; int the_class_api_maximum; if ( !the_class ) return NULL; 10b6af: 31 db xor %ebx,%ebx ) { Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 10b6b1: 66 85 ff test %di,%di 10b6b4: 74 37 je 10b6ed <_Objects_Get_information+0x4d> /* * 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 ); 10b6b6: 83 ec 0c sub $0xc,%esp 10b6b9: 56 push %esi 10b6ba: e8 dd 41 00 00 call 10f89c <_Objects_API_maximum_class> if ( the_class_api_maximum == 0 ) 10b6bf: 83 c4 10 add $0x10,%esp 10b6c2: 85 c0 test %eax,%eax 10b6c4: 74 27 je 10b6ed <_Objects_Get_information+0x4d> return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 10b6c6: 0f b7 ff movzwl %di,%edi 10b6c9: 39 c7 cmp %eax,%edi 10b6cb: 77 20 ja 10b6ed <_Objects_Get_information+0x4d> return NULL; if ( !_Objects_Information_table[ the_api ] ) 10b6cd: 8b 04 b5 18 53 12 00 mov 0x125318(,%esi,4),%eax 10b6d4: 85 c0 test %eax,%eax 10b6d6: 74 15 je 10b6ed <_Objects_Get_information+0x4d><== NEVER TAKEN return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10b6d8: 8b 1c b8 mov (%eax,%edi,4),%ebx if ( !info ) 10b6db: 85 db test %ebx,%ebx 10b6dd: 74 0e je 10b6ed <_Objects_Get_information+0x4d><== 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; 10b6df: 31 c0 xor %eax,%eax 10b6e1: 66 83 7b 10 00 cmpw $0x0,0x10(%ebx) 10b6e6: 0f 95 c0 setne %al 10b6e9: f7 d8 neg %eax 10b6eb: 21 c3 and %eax,%ebx #endif return info; } 10b6ed: 89 d8 mov %ebx,%eax 10b6ef: 8d 65 f4 lea -0xc(%ebp),%esp 10b6f2: 5b pop %ebx 10b6f3: 5e pop %esi 10b6f4: 5f pop %edi 10b6f5: c9 leave 10b6f6: c3 ret =============================================================================== 00118bb0 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 118bb0: 55 push %ebp 118bb1: 89 e5 mov %esp,%ebp 118bb3: 53 push %ebx 118bb4: 8b 55 08 mov 0x8(%ebp),%edx 118bb7: 8b 4d 10 mov 0x10(%ebp),%ecx /* * 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; 118bba: b8 01 00 00 00 mov $0x1,%eax 118bbf: 2b 42 08 sub 0x8(%edx),%eax 118bc2: 03 45 0c add 0xc(%ebp),%eax if ( information->maximum >= index ) { 118bc5: 0f b7 5a 10 movzwl 0x10(%edx),%ebx 118bc9: 39 c3 cmp %eax,%ebx 118bcb: 72 12 jb 118bdf <_Objects_Get_no_protection+0x2f> if ( (the_object = information->local_table[ index ]) != NULL ) { 118bcd: 8b 52 1c mov 0x1c(%edx),%edx 118bd0: 8b 04 82 mov (%edx,%eax,4),%eax 118bd3: 85 c0 test %eax,%eax 118bd5: 74 08 je 118bdf <_Objects_Get_no_protection+0x2f><== NEVER TAKEN *location = OBJECTS_LOCAL; 118bd7: c7 01 00 00 00 00 movl $0x0,(%ecx) return the_object; 118bdd: eb 08 jmp 118be7 <_Objects_Get_no_protection+0x37> /* * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; 118bdf: c7 01 01 00 00 00 movl $0x1,(%ecx) return NULL; 118be5: 31 c0 xor %eax,%eax } 118be7: 5b pop %ebx 118be8: c9 leave 118be9: c3 ret =============================================================================== 0010c8bc <_Objects_Id_to_name>: */ Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10c8bc: 55 push %ebp 10c8bd: 89 e5 mov %esp,%ebp 10c8bf: 53 push %ebx 10c8c0: 83 ec 14 sub $0x14,%esp /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10c8c3: 8b 45 08 mov 0x8(%ebp),%eax 10c8c6: 85 c0 test %eax,%eax 10c8c8: 75 08 jne 10c8d2 <_Objects_Id_to_name+0x16> 10c8ca: a1 d4 78 12 00 mov 0x1278d4,%eax 10c8cf: 8b 40 08 mov 0x8(%eax),%eax 10c8d2: 89 c2 mov %eax,%edx 10c8d4: c1 ea 18 shr $0x18,%edx 10c8d7: 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 ) 10c8da: 8d 4a ff lea -0x1(%edx),%ecx the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; 10c8dd: bb 03 00 00 00 mov $0x3,%ebx 10c8e2: 83 f9 02 cmp $0x2,%ecx 10c8e5: 77 36 ja 10c91d <_Objects_Id_to_name+0x61> 10c8e7: eb 3b jmp 10c924 <_Objects_Id_to_name+0x68> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10c8e9: 89 c1 mov %eax,%ecx 10c8eb: c1 e9 1b shr $0x1b,%ecx if ( !_Objects_Information_table[ the_api ] ) return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 10c8ee: 8b 14 8a mov (%edx,%ecx,4),%edx if ( !information ) 10c8f1: 85 d2 test %edx,%edx 10c8f3: 74 28 je 10c91d <_Objects_Id_to_name+0x61><== NEVER TAKEN return OBJECTS_INVALID_ID; #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) 10c8f5: 80 7a 38 00 cmpb $0x0,0x38(%edx) 10c8f9: 75 22 jne 10c91d <_Objects_Id_to_name+0x61><== NEVER TAKEN return OBJECTS_INVALID_ID; #endif the_object = _Objects_Get( information, tmpId, &ignored_location ); 10c8fb: 51 push %ecx 10c8fc: 8d 4d f4 lea -0xc(%ebp),%ecx 10c8ff: 51 push %ecx 10c900: 50 push %eax 10c901: 52 push %edx 10c902: e8 5d ff ff ff call 10c864 <_Objects_Get> if ( !the_object ) 10c907: 83 c4 10 add $0x10,%esp 10c90a: 85 c0 test %eax,%eax 10c90c: 74 0f je 10c91d <_Objects_Id_to_name+0x61> return OBJECTS_INVALID_ID; *name = the_object->name; 10c90e: 8b 50 0c mov 0xc(%eax),%edx 10c911: 8b 45 0c mov 0xc(%ebp),%eax 10c914: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10c916: e8 73 0a 00 00 call 10d38e <_Thread_Enable_dispatch> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10c91b: 31 db xor %ebx,%ebx } 10c91d: 89 d8 mov %ebx,%eax 10c91f: 8b 5d fc mov -0x4(%ebp),%ebx 10c922: c9 leave 10c923: 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 ] ) 10c924: 8b 14 95 84 73 12 00 mov 0x127384(,%edx,4),%edx 10c92b: 85 d2 test %edx,%edx 10c92d: 75 ba jne 10c8e9 <_Objects_Id_to_name+0x2d> 10c92f: eb ec jmp 10c91d <_Objects_Id_to_name+0x61> =============================================================================== 0010e310 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 10e310: 55 push %ebp 10e311: 89 e5 mov %esp,%ebp 10e313: 57 push %edi 10e314: 56 push %esi 10e315: 53 push %ebx 10e316: 83 ec 30 sub $0x30,%esp 10e319: 8b 75 08 mov 0x8(%ebp),%esi 10e31c: 8b 5d 14 mov 0x14(%ebp),%ebx 10e31f: 8a 55 18 mov 0x18(%ebp),%dl POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; size_t length_out; bool do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); 10e322: 8d 45 e4 lea -0x1c(%ebp),%eax RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *_POSIX_Message_queue_Get_fd ( mqd_t id, Objects_Locations *location ) { return (POSIX_Message_queue_Control_fd *) _Objects_Get( 10e325: 50 push %eax 10e326: 56 push %esi 10e327: 68 30 e3 12 00 push $0x12e330 10e32c: 88 55 d4 mov %dl,-0x2c(%ebp) 10e32f: e8 f0 2a 00 00 call 110e24 <_Objects_Get> switch ( location ) { 10e334: 83 c4 10 add $0x10,%esp 10e337: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10e33b: 8a 55 d4 mov -0x2c(%ebp),%dl 10e33e: 0f 85 aa 00 00 00 jne 10e3ee <_POSIX_Message_queue_Receive_support+0xde> case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 10e344: 8b 78 14 mov 0x14(%eax),%edi 10e347: 89 f9 mov %edi,%ecx 10e349: 83 e1 03 and $0x3,%ecx 10e34c: 49 dec %ecx 10e34d: 75 0a jne 10e359 <_POSIX_Message_queue_Receive_support+0x49> _Thread_Enable_dispatch(); 10e34f: e8 f6 35 00 00 call 11194a <_Thread_Enable_dispatch> 10e354: e9 95 00 00 00 jmp 10e3ee <_POSIX_Message_queue_Receive_support+0xde> rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10e359: 8b 40 10 mov 0x10(%eax),%eax if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 10e35c: 8b 48 68 mov 0x68(%eax),%ecx 10e35f: 39 4d 10 cmp %ecx,0x10(%ebp) 10e362: 73 15 jae 10e379 <_POSIX_Message_queue_Receive_support+0x69> _Thread_Enable_dispatch(); 10e364: e8 e1 35 00 00 call 11194a <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EMSGSIZE ); 10e369: e8 ee 8a 00 00 call 116e5c <__errno> 10e36e: c7 00 7a 00 00 00 movl $0x7a,(%eax) 10e374: e9 80 00 00 00 jmp 10e3f9 <_POSIX_Message_queue_Receive_support+0xe9> /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 10e379: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp) /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10e380: 31 c9 xor %ecx,%ecx 10e382: 84 d2 test %dl,%dl 10e384: 74 09 je 10e38f <_POSIX_Message_queue_Receive_support+0x7f><== NEVER TAKEN do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true; 10e386: 81 e7 00 40 00 00 and $0x4000,%edi 10e38c: 0f 94 c1 sete %cl do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 10e38f: 52 push %edx 10e390: 52 push %edx 10e391: ff 75 1c pushl 0x1c(%ebp) 10e394: 0f b6 c9 movzbl %cl,%ecx 10e397: 51 push %ecx 10e398: 8d 55 e0 lea -0x20(%ebp),%edx 10e39b: 52 push %edx 10e39c: ff 75 0c pushl 0xc(%ebp) 10e39f: 56 push %esi 10e3a0: 83 c0 1c add $0x1c,%eax 10e3a3: 50 push %eax 10e3a4: e8 7f 1c 00 00 call 110028 <_CORE_message_queue_Seize> &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 10e3a9: 83 c4 20 add $0x20,%esp 10e3ac: e8 99 35 00 00 call 11194a <_Thread_Enable_dispatch> *msg_prio = _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); 10e3b1: a1 a8 e3 12 00 mov 0x12e3a8,%eax RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core( CORE_message_queue_Submit_types priority ) { /* absolute value without a library dependency */ return ((priority >= 0) ? priority : -priority); 10e3b6: 8b 50 24 mov 0x24(%eax),%edx 10e3b9: c1 fa 1f sar $0x1f,%edx 10e3bc: 8b 48 24 mov 0x24(%eax),%ecx 10e3bf: 31 d1 xor %edx,%ecx 10e3c1: 89 0b mov %ecx,(%ebx) 10e3c3: 29 13 sub %edx,(%ebx) if ( !_Thread_Executing->Wait.return_code ) 10e3c5: 83 78 34 00 cmpl $0x0,0x34(%eax) 10e3c9: 75 05 jne 10e3d0 <_POSIX_Message_queue_Receive_support+0xc0> return length_out; 10e3cb: 8b 45 e0 mov -0x20(%ebp),%eax 10e3ce: eb 2c jmp 10e3fc <_POSIX_Message_queue_Receive_support+0xec> rtems_set_errno_and_return_minus_one( 10e3d0: e8 87 8a 00 00 call 116e5c <__errno> 10e3d5: 89 c3 mov %eax,%ebx 10e3d7: 83 ec 0c sub $0xc,%esp 10e3da: a1 a8 e3 12 00 mov 0x12e3a8,%eax 10e3df: ff 70 34 pushl 0x34(%eax) 10e3e2: e8 ed 01 00 00 call 10e5d4 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10e3e7: 89 03 mov %eax,(%ebx) 10e3e9: 83 c4 10 add $0x10,%esp 10e3ec: eb 0b jmp 10e3f9 <_POSIX_Message_queue_Receive_support+0xe9> #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10e3ee: e8 69 8a 00 00 call 116e5c <__errno> 10e3f3: c7 00 09 00 00 00 movl $0x9,(%eax) 10e3f9: 83 c8 ff or $0xffffffff,%eax } 10e3fc: 8d 65 f4 lea -0xc(%ebp),%esp 10e3ff: 5b pop %ebx 10e400: 5e pop %esi 10e401: 5f pop %edi 10e402: c9 leave 10e403: c3 ret =============================================================================== 0010bccb <_POSIX_Mutex_Get_interrupt_disable>: POSIX_Mutex_Control *_POSIX_Mutex_Get_interrupt_disable ( pthread_mutex_t *mutex, Objects_Locations *location, ISR_Level *level ) { 10bccb: 55 push %ebp 10bccc: 89 e5 mov %esp,%ebp 10bcce: 56 push %esi 10bccf: 53 push %ebx 10bcd0: 8b 5d 08 mov 0x8(%ebp),%ebx 10bcd3: 8b 75 0c mov 0xc(%ebp),%esi ___POSIX_Mutex_Get_support_error_check( mutex, location ); 10bcd6: 85 db test %ebx,%ebx 10bcd8: 74 16 je 10bcf0 <_POSIX_Mutex_Get_interrupt_disable+0x25> ___POSIX_Mutex_Get_support_auto_initialization( mutex, location ); 10bcda: 83 3b ff cmpl $0xffffffff,(%ebx) 10bcdd: 75 1b jne 10bcfa <_POSIX_Mutex_Get_interrupt_disable+0x2f> 10bcdf: 51 push %ecx 10bce0: 51 push %ecx 10bce1: 6a 00 push $0x0 10bce3: 53 push %ebx 10bce4: e8 73 00 00 00 call 10bd5c 10bce9: 83 c4 10 add $0x10,%esp 10bcec: 85 c0 test %eax,%eax 10bcee: 74 0a je 10bcfa <_POSIX_Mutex_Get_interrupt_disable+0x2f><== NEVER TAKEN 10bcf0: c7 06 01 00 00 00 movl $0x1,(%esi) 10bcf6: 31 c0 xor %eax,%eax 10bcf8: eb 13 jmp 10bd0d <_POSIX_Mutex_Get_interrupt_disable+0x42> return (POSIX_Mutex_Control *) _Objects_Get_isr_disable( 10bcfa: ff 75 10 pushl 0x10(%ebp) 10bcfd: 56 push %esi 10bcfe: ff 33 pushl (%ebx) 10bd00: 68 54 a7 12 00 push $0x12a754 10bd05: e8 06 27 00 00 call 10e410 <_Objects_Get_isr_disable> 10bd0a: 83 c4 10 add $0x10,%esp &_POSIX_Mutex_Information, (Objects_Id) *mutex, location, level ); } 10bd0d: 8d 65 f8 lea -0x8(%ebp),%esp 10bd10: 5b pop %ebx 10bd11: 5e pop %esi 10bd12: c9 leave 10bd13: c3 ret =============================================================================== 0010e9dc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>: #include void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( Thread_Control *the_thread ) { 10e9dc: 55 push %ebp 10e9dd: 89 e5 mov %esp,%ebp 10e9df: 83 ec 08 sub $0x8,%esp 10e9e2: 8b 55 08 mov 0x8(%ebp),%edx POSIX_API_Control *thread_support; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10e9e5: 8b 82 ec 00 00 00 mov 0xec(%edx),%eax if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10e9eb: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax) 10e9f2: 75 2c jne 10ea20 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NEVER TAKEN 10e9f4: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax) 10e9fb: 75 23 jne 10ea20 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44> thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && 10e9fd: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax) 10ea04: 74 1a je 10ea20 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10ea06: a1 50 63 12 00 mov 0x126350,%eax 10ea0b: 48 dec %eax 10ea0c: a3 50 63 12 00 mov %eax,0x126350 thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 10ea11: 50 push %eax 10ea12: 50 push %eax 10ea13: 6a ff push $0xffffffff 10ea15: 52 push %edx 10ea16: e8 51 08 00 00 call 10f26c <_POSIX_Thread_Exit> 10ea1b: 83 c4 10 add $0x10,%esp } else _Thread_Enable_dispatch(); } 10ea1e: c9 leave 10ea1f: c3 ret 10ea20: c9 leave thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); } else _Thread_Enable_dispatch(); 10ea21: e9 78 db ff ff jmp 10c59e <_Thread_Enable_dispatch> =============================================================================== 0010fc74 <_POSIX_Thread_Translate_sched_param>: int policy, struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) { 10fc74: 55 push %ebp 10fc75: 89 e5 mov %esp,%ebp 10fc77: 57 push %edi 10fc78: 56 push %esi 10fc79: 53 push %ebx 10fc7a: 83 ec 28 sub $0x28,%esp 10fc7d: 8b 55 08 mov 0x8(%ebp),%edx 10fc80: 8b 5d 0c mov 0xc(%ebp),%ebx 10fc83: 8b 7d 10 mov 0x10(%ebp),%edi if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 10fc86: ff 33 pushl (%ebx) 10fc88: 89 55 e0 mov %edx,-0x20(%ebp) 10fc8b: e8 c4 ff ff ff call 10fc54 <_POSIX_Priority_Is_valid> 10fc90: 83 c4 10 add $0x10,%esp return EINVAL; 10fc93: be 16 00 00 00 mov $0x16,%esi struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) { if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 10fc98: 84 c0 test %al,%al 10fc9a: 8b 55 e0 mov -0x20(%ebp),%edx 10fc9d: 0f 84 a4 00 00 00 je 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3><== NEVER TAKEN return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 10fca3: c7 07 00 00 00 00 movl $0x0,(%edi) *budget_callout = NULL; 10fca9: 8b 45 14 mov 0x14(%ebp),%eax 10fcac: c7 00 00 00 00 00 movl $0x0,(%eax) if ( policy == SCHED_OTHER ) { 10fcb2: 85 d2 test %edx,%edx 10fcb4: 75 0b jne 10fcc1 <_POSIX_Thread_Translate_sched_param+0x4d> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 10fcb6: c7 07 01 00 00 00 movl $0x1,(%edi) 10fcbc: e9 83 00 00 00 jmp 10fd44 <_POSIX_Thread_Translate_sched_param+0xd0> return 0; } if ( policy == SCHED_FIFO ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; 10fcc1: 31 f6 xor %esi,%esi if ( policy == SCHED_OTHER ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; return 0; } if ( policy == SCHED_FIFO ) { 10fcc3: 83 fa 01 cmp $0x1,%edx 10fcc6: 74 7f je 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; } if ( policy == SCHED_RR ) { 10fcc8: 83 fa 02 cmp $0x2,%edx 10fccb: 75 08 jne 10fcd5 <_POSIX_Thread_Translate_sched_param+0x61> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; 10fccd: c7 07 02 00 00 00 movl $0x2,(%edi) return 0; 10fcd3: eb 72 jmp 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; *budget_callout = _POSIX_Threads_Sporadic_budget_callout; return 0; } return EINVAL; 10fcd5: be 16 00 00 00 mov $0x16,%esi if ( policy == SCHED_RR ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; return 0; } if ( policy == SCHED_SPORADIC ) { 10fcda: 83 fa 04 cmp $0x4,%edx 10fcdd: 75 68 jne 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3> if ( (param->sched_ss_repl_period.tv_sec == 0) && 10fcdf: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10fce3: 75 06 jne 10fceb <_POSIX_Thread_Translate_sched_param+0x77> 10fce5: 83 7b 0c 00 cmpl $0x0,0xc(%ebx) 10fce9: 74 5c je 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3> (param->sched_ss_repl_period.tv_nsec == 0) ) return EINVAL; if ( (param->sched_ss_init_budget.tv_sec == 0) && 10fceb: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10fcef: 75 0b jne 10fcfc <_POSIX_Thread_Translate_sched_param+0x88> (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; 10fcf1: be 16 00 00 00 mov $0x16,%esi if ( policy == SCHED_SPORADIC ) { if ( (param->sched_ss_repl_period.tv_sec == 0) && (param->sched_ss_repl_period.tv_nsec == 0) ) return EINVAL; if ( (param->sched_ss_init_budget.tv_sec == 0) && 10fcf6: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10fcfa: 74 4b je 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3> (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) < 10fcfc: 83 ec 0c sub $0xc,%esp 10fcff: 8d 43 08 lea 0x8(%ebx),%eax 10fd02: 50 push %eax 10fd03: e8 00 de ff ff call 10db08 <_Timespec_To_ticks> 10fd08: 89 45 e4 mov %eax,-0x1c(%ebp) _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) 10fd0b: 8d 43 10 lea 0x10(%ebx),%eax 10fd0e: 89 04 24 mov %eax,(%esp) 10fd11: e8 f2 dd ff ff call 10db08 <_Timespec_To_ticks> if ( (param->sched_ss_init_budget.tv_sec == 0) && (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) < 10fd16: 83 c4 10 add $0x10,%esp _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) return EINVAL; 10fd19: be 16 00 00 00 mov $0x16,%esi if ( (param->sched_ss_init_budget.tv_sec == 0) && (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) < 10fd1e: 39 45 e4 cmp %eax,-0x1c(%ebp) 10fd21: 72 24 jb 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3> _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) ) 10fd23: 83 ec 0c sub $0xc,%esp 10fd26: ff 73 04 pushl 0x4(%ebx) 10fd29: e8 26 ff ff ff call 10fc54 <_POSIX_Priority_Is_valid> 10fd2e: 83 c4 10 add $0x10,%esp 10fd31: 84 c0 test %al,%al 10fd33: 74 12 je 10fd47 <_POSIX_Thread_Translate_sched_param+0xd3> return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; 10fd35: c7 07 03 00 00 00 movl $0x3,(%edi) *budget_callout = _POSIX_Threads_Sporadic_budget_callout; 10fd3b: 8b 45 14 mov 0x14(%ebp),%eax 10fd3e: c7 00 41 a8 10 00 movl $0x10a841,(%eax) return 0; 10fd44: 66 31 f6 xor %si,%si } return EINVAL; } 10fd47: 89 f0 mov %esi,%eax 10fd49: 8d 65 f4 lea -0xc(%ebp),%esp 10fd4c: 5b pop %ebx 10fd4d: 5e pop %esi 10fd4e: 5f pop %edi 10fd4f: c9 leave 10fd50: c3 ret =============================================================================== 0010a544 <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body(void) { 10a544: 55 push %ebp 10a545: 89 e5 mov %esp,%ebp 10a547: 57 push %edi 10a548: 56 push %esi 10a549: 53 push %ebx 10a54a: 83 ec 6c sub $0x6c,%esp uint32_t maximum; posix_initialization_threads_table *user_threads; pthread_t thread_id; pthread_attr_t attr; user_threads = Configuration_POSIX_API.User_initialization_threads_table; 10a54d: 8b 3d 40 22 12 00 mov 0x122240,%edi maximum = Configuration_POSIX_API.number_of_initialization_threads; 10a553: 8b 15 3c 22 12 00 mov 0x12223c,%edx if ( !user_threads || maximum == 0 ) 10a559: 85 d2 test %edx,%edx 10a55b: 74 54 je 10a5b1 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN 10a55d: 85 ff test %edi,%edi 10a55f: 74 50 je 10a5b1 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN 10a561: 31 db xor %ebx,%ebx for ( index=0 ; index < maximum ; index++ ) { /* * There is no way for these calls to fail in this situation. */ (void) pthread_attr_init( &attr ); 10a563: 8d 75 a4 lea -0x5c(%ebp),%esi 10a566: 83 ec 0c sub $0xc,%esp 10a569: 56 push %esi 10a56a: 89 55 94 mov %edx,-0x6c(%ebp) 10a56d: e8 e2 57 00 00 call 10fd54 (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 10a572: 5a pop %edx 10a573: 59 pop %ecx 10a574: 6a 02 push $0x2 10a576: 56 push %esi 10a577: e8 00 58 00 00 call 10fd7c (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size); 10a57c: 59 pop %ecx 10a57d: 58 pop %eax 10a57e: ff 74 df 04 pushl 0x4(%edi,%ebx,8) 10a582: 56 push %esi 10a583: e8 20 58 00 00 call 10fda8 status = pthread_create( 10a588: 6a 00 push $0x0 10a58a: ff 34 df pushl (%edi,%ebx,8) 10a58d: 56 push %esi 10a58e: 8d 45 e4 lea -0x1c(%ebp),%eax 10a591: 50 push %eax 10a592: e8 e5 fc ff ff call 10a27c &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) 10a597: 83 c4 20 add $0x20,%esp 10a59a: 85 c0 test %eax,%eax 10a59c: 8b 55 94 mov -0x6c(%ebp),%edx 10a59f: 74 0b je 10a5ac <_POSIX_Threads_Initialize_user_threads_body+0x68> _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); 10a5a1: 52 push %edx 10a5a2: 50 push %eax 10a5a3: 6a 01 push $0x1 10a5a5: 6a 02 push $0x2 10a5a7: e8 e8 1b 00 00 call 10c194 <_Internal_error_Occurred> * * Setting the attributes explicitly is critical, since we don't want * to inherit the idle tasks attributes. */ for ( index=0 ; index < maximum ; index++ ) { 10a5ac: 43 inc %ebx 10a5ad: 39 d3 cmp %edx,%ebx 10a5af: 72 b5 jb 10a566 <_POSIX_Threads_Initialize_user_threads_body+0x22><== NEVER TAKEN NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); } } 10a5b1: 8d 65 f4 lea -0xc(%ebp),%esp 10a5b4: 5b pop %ebx 10a5b5: 5e pop %esi 10a5b6: 5f pop %edi 10a5b7: c9 leave 10a5b8: c3 ret =============================================================================== 0010edcf <_POSIX_Threads_Sporadic_budget_TSR>: */ void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id __attribute__((unused)), void *argument ) { 10edcf: 55 push %ebp 10edd0: 89 e5 mov %esp,%ebp 10edd2: 56 push %esi 10edd3: 53 push %ebx 10edd4: 8b 5d 0c mov 0xc(%ebp),%ebx Thread_Control *the_thread; POSIX_API_Control *api; the_thread = argument; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10edd7: 8b b3 ec 00 00 00 mov 0xec(%ebx),%esi /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget ); 10eddd: 83 ec 0c sub $0xc,%esp 10ede0: 8d 86 98 00 00 00 lea 0x98(%esi),%eax 10ede6: 50 push %eax 10ede7: e8 88 0d 00 00 call 10fb74 <_Timespec_To_ticks> the_thread->cpu_time_budget = ticks; 10edec: 89 43 78 mov %eax,0x78(%ebx) RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 10edef: 0f b6 05 24 12 12 00 movzbl 0x121224,%eax 10edf6: 2b 86 88 00 00 00 sub 0x88(%esi),%eax new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority ); the_thread->real_priority = new_priority; 10edfc: 89 43 18 mov %eax,0x18(%ebx) */ #if 0 printk( "TSR %d %d %d\n", the_thread->resource_count, the_thread->current_priority, new_priority ); #endif if ( the_thread->resource_count == 0 ) { 10edff: 83 c4 10 add $0x10,%esp 10ee02: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx) 10ee06: 75 12 jne 10ee1a <_POSIX_Threads_Sporadic_budget_TSR+0x4b><== NEVER TAKEN /* * If this would make them less important, then do not change it. */ if ( the_thread->current_priority > new_priority ) { 10ee08: 39 43 14 cmp %eax,0x14(%ebx) 10ee0b: 76 0d jbe 10ee1a <_POSIX_Threads_Sporadic_budget_TSR+0x4b> _Thread_Change_priority( the_thread, new_priority, true ); 10ee0d: 52 push %edx 10ee0e: 6a 01 push $0x1 10ee10: 50 push %eax 10ee11: 53 push %ebx 10ee12: e8 0d d0 ff ff call 10be24 <_Thread_Change_priority> 10ee17: 83 c4 10 add $0x10,%esp #endif } } /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ); 10ee1a: 83 ec 0c sub $0xc,%esp 10ee1d: 8d 86 90 00 00 00 lea 0x90(%esi),%eax 10ee23: 50 push %eax 10ee24: e8 4b 0d 00 00 call 10fb74 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10ee29: 89 86 b4 00 00 00 mov %eax,0xb4(%esi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10ee2f: 83 c4 10 add $0x10,%esp _Watchdog_Insert_ticks( &api->Sporadic_timer, ticks ); 10ee32: 81 c6 a8 00 00 00 add $0xa8,%esi 10ee38: 89 75 0c mov %esi,0xc(%ebp) 10ee3b: c7 45 08 04 54 12 00 movl $0x125404,0x8(%ebp) } 10ee42: 8d 65 f8 lea -0x8(%ebp),%esp 10ee45: 5b pop %ebx 10ee46: 5e pop %esi 10ee47: c9 leave 10ee48: e9 c3 df ff ff jmp 10ce10 <_Watchdog_Insert> =============================================================================== 0010ee4d <_POSIX_Threads_Sporadic_budget_callout>: * _POSIX_Threads_Sporadic_budget_callout */ void _POSIX_Threads_Sporadic_budget_callout( Thread_Control *the_thread ) { 10ee4d: 55 push %ebp 10ee4e: 89 e5 mov %esp,%ebp 10ee50: 83 ec 08 sub $0x8,%esp 10ee53: 8b 45 08 mov 0x8(%ebp),%eax POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10ee56: 8b 88 ec 00 00 00 mov 0xec(%eax),%ecx /* * This will prevent the thread from consuming its entire "budget" * while at low priority. */ the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */ 10ee5c: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax) 10ee63: 0f b6 15 24 12 12 00 movzbl 0x121224,%edx 10ee6a: 2b 91 8c 00 00 00 sub 0x8c(%ecx),%edx new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority); the_thread->real_priority = new_priority; 10ee70: 89 50 18 mov %edx,0x18(%eax) */ #if 0 printk( "callout %d %d %d\n", the_thread->resource_count, the_thread->current_priority, new_priority ); #endif if ( the_thread->resource_count == 0 ) { 10ee73: 83 78 1c 00 cmpl $0x0,0x1c(%eax) 10ee77: 75 12 jne 10ee8b <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN /* * Make sure we are actually lowering it. If they have lowered it * to logically lower than sched_ss_low_priority, then we do not want to * change it. */ if ( the_thread->current_priority < new_priority ) { 10ee79: 39 50 14 cmp %edx,0x14(%eax) 10ee7c: 73 0d jae 10ee8b <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN _Thread_Change_priority( the_thread, new_priority, true ); 10ee7e: 51 push %ecx 10ee7f: 6a 01 push $0x1 10ee81: 52 push %edx 10ee82: 50 push %eax 10ee83: e8 9c cf ff ff call 10be24 <_Thread_Change_priority> 10ee88: 83 c4 10 add $0x10,%esp #if 0 printk( "lower priority\n" ); #endif } } } 10ee8b: c9 leave 10ee8c: c3 ret =============================================================================== 0010a304 <_POSIX_Timer_TSR>: * This is the operation that is run when a timer expires */ void _POSIX_Timer_TSR( Objects_Id timer __attribute__((unused)), void *data) { 10a304: 55 push %ebp 10a305: 89 e5 mov %esp,%ebp 10a307: 53 push %ebx 10a308: 83 ec 04 sub $0x4,%esp 10a30b: 8b 5d 0c mov 0xc(%ebp),%ebx bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 10a30e: ff 43 68 incl 0x68(%ebx) /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10a311: 83 7b 54 00 cmpl $0x0,0x54(%ebx) 10a315: 75 06 jne 10a31d <_POSIX_Timer_TSR+0x19> 10a317: 83 7b 58 00 cmpl $0x0,0x58(%ebx) 10a31b: 74 34 je 10a351 <_POSIX_Timer_TSR+0x4d> <== NEVER TAKEN ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { activated = _POSIX_Timer_Insert_helper( 10a31d: 83 ec 0c sub $0xc,%esp 10a320: 53 push %ebx 10a321: 68 04 a3 10 00 push $0x10a304 10a326: ff 73 08 pushl 0x8(%ebx) 10a329: ff 73 64 pushl 0x64(%ebx) 10a32c: 8d 43 10 lea 0x10(%ebx),%eax 10a32f: 50 push %eax 10a330: e8 e7 56 00 00 call 10fa1c <_POSIX_Timer_Insert_helper> ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 10a335: 83 c4 20 add $0x20,%esp 10a338: 84 c0 test %al,%al 10a33a: 74 30 je 10a36c <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 10a33c: 83 ec 0c sub $0xc,%esp 10a33f: 8d 43 6c lea 0x6c(%ebx),%eax 10a342: 50 push %eax 10a343: e8 5c 14 00 00 call 10b7a4 <_TOD_Get> /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a348: c6 43 3c 03 movb $0x3,0x3c(%ebx) 10a34c: 83 c4 10 add $0x10,%esp 10a34f: eb 04 jmp 10a355 <_POSIX_Timer_TSR+0x51> } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a351: c6 43 3c 04 movb $0x4,0x3c(%ebx) <== NOT EXECUTED /* * The sending of the signal to the process running the handling function * specified for that signal is simulated */ if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) { 10a355: 50 push %eax 10a356: 50 push %eax 10a357: ff 73 44 pushl 0x44(%ebx) 10a35a: ff 73 38 pushl 0x38(%ebx) 10a35d: e8 92 52 00 00 call 10f5f4 } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 10a362: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) 10a369: 83 c4 10 add $0x10,%esp } 10a36c: 8b 5d fc mov -0x4(%ebp),%ebx 10a36f: c9 leave 10a370: c3 ret =============================================================================== 00110b54 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) { 110b54: 55 push %ebp 110b55: 89 e5 mov %esp,%ebp 110b57: 57 push %edi 110b58: 56 push %esi 110b59: 53 push %ebx 110b5a: 83 ec 68 sub $0x68,%esp 110b5d: 8b 5d 0c mov 0xc(%ebp),%ebx siginfo_t siginfo_struct; sigset_t saved_signals_blocked; Thread_Wait_information stored_thread_wait_information; if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct, 110b60: 6a 01 push $0x1 110b62: 0f b6 45 10 movzbl 0x10(%ebp),%eax 110b66: 50 push %eax 110b67: 8d 45 dc lea -0x24(%ebp),%eax 110b6a: 50 push %eax 110b6b: 53 push %ebx 110b6c: ff 75 08 pushl 0x8(%ebp) 110b6f: e8 8c 00 00 00 call 110c00 <_POSIX_signals_Clear_signals> 110b74: 83 c4 20 add $0x20,%esp is_global, true ) ) return false; 110b77: 31 c9 xor %ecx,%ecx { siginfo_t siginfo_struct; sigset_t saved_signals_blocked; Thread_Wait_information stored_thread_wait_information; if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct, 110b79: 84 c0 test %al,%al 110b7b: 74 78 je 110bf5 <_POSIX_signals_Check_signal+0xa1> #endif /* * Just to prevent sending a signal which is currently being ignored. */ if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN ) 110b7d: 6b d3 0c imul $0xc,%ebx,%edx 110b80: 8b 82 a4 58 12 00 mov 0x1258a4(%edx),%eax 110b86: 83 f8 01 cmp $0x1,%eax 110b89: 74 6a je 110bf5 <_POSIX_signals_Check_signal+0xa1><== NEVER TAKEN return false; /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 110b8b: 8b 4d 08 mov 0x8(%ebp),%ecx 110b8e: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx 110b94: 89 4d a4 mov %ecx,-0x5c(%ebp) api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 110b97: 0b 8a a0 58 12 00 or 0x1258a0(%edx),%ecx 110b9d: 8b 75 08 mov 0x8(%ebp),%esi 110ba0: 89 8e d0 00 00 00 mov %ecx,0xd0(%esi) /* * We have to save the blocking information of the current wait queue * because the signal handler may subsequently go on and put the thread * on a wait queue, for its own purposes. */ memcpy( &stored_thread_wait_information, &_Thread_Executing->Wait, 110ba6: 8d 7d b4 lea -0x4c(%ebp),%edi 110ba9: 8b 35 68 58 12 00 mov 0x125868,%esi 110baf: 83 c6 20 add $0x20,%esi 110bb2: b9 0a 00 00 00 mov $0xa,%ecx 110bb7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) sizeof( Thread_Wait_information )); /* * Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 110bb9: 83 ba 9c 58 12 00 02 cmpl $0x2,0x12589c(%edx) 110bc0: 75 09 jne 110bcb <_POSIX_signals_Check_signal+0x77> case SA_SIGINFO: (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 110bc2: 52 push %edx 110bc3: 6a 00 push $0x0 110bc5: 8d 55 dc lea -0x24(%ebp),%edx 110bc8: 52 push %edx 110bc9: eb 03 jmp 110bce <_POSIX_signals_Check_signal+0x7a> &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; default: (*_POSIX_signals_Vectors[ signo ].sa_handler)( signo ); 110bcb: 83 ec 0c sub $0xc,%esp 110bce: 53 push %ebx 110bcf: ff d0 call *%eax break; 110bd1: 83 c4 10 add $0x10,%esp } /* * Restore the blocking information */ memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information, 110bd4: 8b 3d 68 58 12 00 mov 0x125868,%edi 110bda: 83 c7 20 add $0x20,%edi 110bdd: 8d 75 b4 lea -0x4c(%ebp),%esi 110be0: b9 0a 00 00 00 mov $0xa,%ecx 110be5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) sizeof( Thread_Wait_information )); /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 110be7: 8b 75 a4 mov -0x5c(%ebp),%esi 110bea: 8b 4d 08 mov 0x8(%ebp),%ecx 110bed: 89 b1 d0 00 00 00 mov %esi,0xd0(%ecx) return true; 110bf3: b1 01 mov $0x1,%cl } 110bf5: 88 c8 mov %cl,%al 110bf7: 8d 65 f4 lea -0xc(%ebp),%esp 110bfa: 5b pop %ebx 110bfb: 5e pop %esi 110bfc: 5f pop %edi 110bfd: c9 leave 110bfe: c3 ret =============================================================================== 001110e8 <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( int signo ) { 1110e8: 55 push %ebp 1110e9: 89 e5 mov %esp,%ebp 1110eb: 53 push %ebx 1110ec: 8b 4d 08 mov 0x8(%ebp),%ecx clear_signal = true; mask = signo_to_mask( signo ); ISR_Level level; _ISR_Disable( level ); 1110ef: 9c pushf 1110f0: fa cli 1110f1: 5a pop %edx if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 1110f2: 6b c1 0c imul $0xc,%ecx,%eax 1110f5: 83 b8 9c 58 12 00 02 cmpl $0x2,0x12589c(%eax) 1110fc: 75 0e jne 11110c <_POSIX_signals_Clear_process_signals+0x24> RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 1110fe: 8d 98 98 5a 12 00 lea 0x125a98(%eax),%ebx if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 111104: 39 98 94 5a 12 00 cmp %ebx,0x125a94(%eax) 11110a: 75 0e jne 11111a <_POSIX_signals_Clear_process_signals+0x32><== NEVER TAKEN 11110c: 49 dec %ecx 11110d: b8 fe ff ff ff mov $0xfffffffe,%eax clear_signal = false; } if ( clear_signal ) { _POSIX_signals_Pending &= ~mask; 111112: d3 c0 rol %cl,%eax 111114: 21 05 90 5a 12 00 and %eax,0x125a90 } _ISR_Enable( level ); 11111a: 52 push %edx 11111b: 9d popf } 11111c: 5b pop %ebx 11111d: c9 leave 11111e: c3 ret =============================================================================== 0010aba8 <_POSIX_signals_Get_lowest>: #include int _POSIX_signals_Get_lowest( sigset_t set ) { 10aba8: 55 push %ebp 10aba9: 89 e5 mov %esp,%ebp 10abab: 56 push %esi 10abac: 53 push %ebx 10abad: 8b 55 08 mov 0x8(%ebp),%edx int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10abb0: b8 1b 00 00 00 mov $0x1b,%eax 10abb5: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include int _POSIX_signals_Get_lowest( 10abba: 8d 48 ff lea -0x1(%eax),%ecx 10abbd: 89 de mov %ebx,%esi 10abbf: d3 e6 shl %cl,%esi ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) { 10abc1: 85 d6 test %edx,%esi 10abc3: 75 1e jne 10abe3 <_POSIX_signals_Get_lowest+0x3b><== NEVER TAKEN sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10abc5: 40 inc %eax 10abc6: 83 f8 20 cmp $0x20,%eax 10abc9: 75 ef jne 10abba <_POSIX_signals_Get_lowest+0x12> 10abcb: b0 01 mov $0x1,%al 10abcd: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include int _POSIX_signals_Get_lowest( 10abd2: 8d 48 ff lea -0x1(%eax),%ecx 10abd5: 89 de mov %ebx,%esi 10abd7: d3 e6 shl %cl,%esi #if (SIGHUP != 1) #error "Assumption that SIGHUP==1 violated!!" #endif for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( set & signo_to_mask( signo ) ) { 10abd9: 85 d6 test %edx,%esi 10abdb: 75 06 jne 10abe3 <_POSIX_signals_Get_lowest+0x3b> */ #if (SIGHUP != 1) #error "Assumption that SIGHUP==1 violated!!" #endif for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10abdd: 40 inc %eax 10abde: 83 f8 1b cmp $0x1b,%eax 10abe1: 75 ef jne 10abd2 <_POSIX_signals_Get_lowest+0x2a><== ALWAYS TAKEN * a return 0. This routine will NOT be called unless a signal * is pending in the set passed in. */ found_it: return signo; } 10abe3: 5b pop %ebx 10abe4: 5e pop %esi 10abe5: c9 leave 10abe6: c3 ret =============================================================================== 001221a0 <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 1221a0: 55 push %ebp 1221a1: 89 e5 mov %esp,%ebp 1221a3: 57 push %edi 1221a4: 56 push %esi 1221a5: 53 push %ebx 1221a6: 83 ec 0c sub $0xc,%esp 1221a9: 8b 5d 08 mov 0x8(%ebp),%ebx 1221ac: 8b 75 0c mov 0xc(%ebp),%esi POSIX_API_Control *api; sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 1221af: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax 1221b5: 8d 4e ff lea -0x1(%esi),%ecx 1221b8: ba 01 00 00 00 mov $0x1,%edx 1221bd: d3 e2 shl %cl,%edx /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 1221bf: 8b 4b 10 mov 0x10(%ebx),%ecx 1221c2: 89 cf mov %ecx,%edi 1221c4: 81 e7 00 80 00 10 and $0x10008000,%edi 1221ca: 81 ff 00 80 00 10 cmp $0x10008000,%edi 1221d0: 75 58 jne 12222a <_POSIX_signals_Unblock_thread+0x8a> if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 1221d2: 85 53 30 test %edx,0x30(%ebx) 1221d5: 75 12 jne 1221e9 <_POSIX_signals_Unblock_thread+0x49> 1221d7: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 1221dd: f7 d0 not %eax /* * This should only be reached via pthread_kill(). */ return false; 1221df: 31 ff xor %edi,%edi * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 1221e1: 85 c2 test %eax,%edx 1221e3: 0f 84 b0 00 00 00 je 122299 <_POSIX_signals_Unblock_thread+0xf9> the_thread->Wait.return_code = EINTR; 1221e9: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) the_info = (siginfo_t *) the_thread->Wait.return_argument; 1221f0: 8b 43 28 mov 0x28(%ebx),%eax if ( !info ) { 1221f3: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 1221f7: 75 12 jne 12220b <_POSIX_signals_Unblock_thread+0x6b> the_info->si_signo = signo; 1221f9: 89 30 mov %esi,(%eax) the_info->si_code = SI_USER; 1221fb: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) the_info->si_value.sival_int = 0; 122202: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) 122209: eb 0c jmp 122217 <_POSIX_signals_Unblock_thread+0x77> } else { *the_info = *info; 12220b: b9 03 00 00 00 mov $0x3,%ecx 122210: 89 c7 mov %eax,%edi 122212: 8b 75 10 mov 0x10(%ebp),%esi 122215: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } _Thread_queue_Extract_with_proxy( the_thread ); 122217: 83 ec 0c sub $0xc,%esp 12221a: 53 push %ebx 12221b: e8 c0 ed fe ff call 110fe0 <_Thread_queue_Extract_with_proxy> return true; 122220: 83 c4 10 add $0x10,%esp 122223: bf 01 00 00 00 mov $0x1,%edi 122228: eb 6f jmp 122299 <_POSIX_signals_Unblock_thread+0xf9> } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 12222a: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 122230: f7 d0 not %eax } else if ( the_thread->current_state == STATES_READY ) { if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; } } return false; 122232: 31 ff xor %edi,%edi } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 122234: 85 c2 test %eax,%edx 122236: 74 61 je 122299 <_POSIX_signals_Unblock_thread+0xf9> * it is not blocked, THEN * we need to dispatch at the end of this ISR. * + Any other combination, do nothing. */ if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) { 122238: f7 c1 00 00 00 10 test $0x10000000,%ecx 12223e: 74 3d je 12227d <_POSIX_signals_Unblock_thread+0xdd> the_thread->Wait.return_code = EINTR; 122240: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) /* * In pthread_cond_wait, a thread will be blocking on a thread * queue, but is also interruptible by a POSIX signal. */ if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) 122247: f7 c1 e0 be 03 00 test $0x3bee0,%ecx 12224d: 74 0b je 12225a <_POSIX_signals_Unblock_thread+0xba> _Thread_queue_Extract_with_proxy( the_thread ); 12224f: 83 ec 0c sub $0xc,%esp 122252: 53 push %ebx 122253: e8 88 ed fe ff call 110fe0 <_Thread_queue_Extract_with_proxy> 122258: eb 1e jmp 122278 <_POSIX_signals_Unblock_thread+0xd8> else if ( _States_Is_delaying(the_thread->current_state) ) { 12225a: 80 e1 08 and $0x8,%cl 12225d: 74 3a je 122299 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN (void) _Watchdog_Remove( &the_thread->Timer ); 12225f: 83 ec 0c sub $0xc,%esp 122262: 8d 43 48 lea 0x48(%ebx),%eax 122265: 50 push %eax 122266: e8 85 f4 fe ff call 1116f0 <_Watchdog_Remove> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 12226b: 58 pop %eax 12226c: 5a pop %edx 12226d: 68 f8 ff 03 10 push $0x1003fff8 122272: 53 push %ebx 122273: e8 2c e4 fe ff call 1106a4 <_Thread_Clear_state> 122278: 83 c4 10 add $0x10,%esp 12227b: eb 1c jmp 122299 <_POSIX_signals_Unblock_thread+0xf9> _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { 12227d: 85 c9 test %ecx,%ecx 12227f: 75 18 jne 122299 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 122281: 83 3d d8 b9 12 00 00 cmpl $0x0,0x12b9d8 122288: 74 0f je 122299 <_POSIX_signals_Unblock_thread+0xf9> 12228a: 3b 1d dc b9 12 00 cmp 0x12b9dc,%ebx 122290: 75 07 jne 122299 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN _Thread_Dispatch_necessary = true; 122292: c6 05 e8 b9 12 00 01 movb $0x1,0x12b9e8 } } return false; } 122299: 89 f8 mov %edi,%eax 12229b: 8d 65 f4 lea -0xc(%ebp),%esp 12229e: 5b pop %ebx 12229f: 5e pop %esi 1222a0: 5f pop %edi 1222a1: c9 leave 1222a2: c3 ret =============================================================================== 0010efb0 <_Protected_heap_Walk>: bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 10efb0: 55 push %ebp 10efb1: 89 e5 mov %esp,%ebp 10efb3: 57 push %edi 10efb4: 56 push %esi 10efb5: 53 push %ebx 10efb6: 83 ec 1c sub $0x1c,%esp 10efb9: 8b 5d 08 mov 0x8(%ebp),%ebx 10efbc: 8b 75 0c mov 0xc(%ebp),%esi 10efbf: 8b 7d 10 mov 0x10(%ebp),%edi * 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 ) { 10efc2: a1 6c bc 12 00 mov 0x12bc6c,%eax 10efc7: 85 c0 test %eax,%eax 10efc9: 75 3c jne 10f007 <_Protected_heap_Walk+0x57><== NEVER TAKEN _RTEMS_Lock_allocator(); 10efcb: 83 ec 0c sub $0xc,%esp 10efce: ff 35 10 bd 12 00 pushl 0x12bd10 10efd4: e8 93 e6 ff ff call 10d66c <_API_Mutex_Lock> status = _Heap_Walk( the_heap, source, do_dump ); 10efd9: 83 c4 0c add $0xc,%esp 10efdc: 81 e7 ff 00 00 00 and $0xff,%edi 10efe2: 57 push %edi 10efe3: 56 push %esi 10efe4: 53 push %ebx 10efe5: e8 a4 f3 ff ff call 10e38e <_Heap_Walk> _RTEMS_Unlock_allocator(); 10efea: 5a pop %edx 10efeb: ff 35 10 bd 12 00 pushl 0x12bd10 10eff1: 88 45 e4 mov %al,-0x1c(%ebp) 10eff4: e8 bb e6 ff ff call 10d6b4 <_API_Mutex_Unlock> 10eff9: 83 c4 10 add $0x10,%esp } else { status = _Heap_Walk( the_heap, source, do_dump ); } return status; } 10effc: 8a 45 e4 mov -0x1c(%ebp),%al 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 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 ); 10f007: 81 e7 ff 00 00 00 and $0xff,%edi 10f00d: 89 7d 10 mov %edi,0x10(%ebp) 10f010: 89 75 0c mov %esi,0xc(%ebp) 10f013: 89 5d 08 mov %ebx,0x8(%ebp) } return status; } 10f016: 8d 65 f4 lea -0xc(%ebp),%esp 10f019: 5b pop %ebx 10f01a: 5e pop %esi 10f01b: 5f pop %edi 10f01c: 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 ); 10f01d: e9 6c f3 ff ff jmp 10e38e <_Heap_Walk> =============================================================================== 0010b3fc <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 10b3fc: 55 push %ebp 10b3fd: 89 e5 mov %esp,%ebp 10b3ff: 53 push %ebx 10b400: 83 ec 18 sub $0x18,%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 ); 10b403: 8d 45 f4 lea -0xc(%ebp),%eax 10b406: 50 push %eax 10b407: ff 75 08 pushl 0x8(%ebp) 10b40a: 68 74 83 12 00 push $0x128374 10b40f: e8 c8 1a 00 00 call 10cedc <_Objects_Get> 10b414: 89 c3 mov %eax,%ebx switch ( location ) { 10b416: 83 c4 10 add $0x10,%esp 10b419: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10b41d: 75 64 jne 10b483 <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN case OBJECTS_LOCAL: the_thread = the_period->owner; 10b41f: 8b 40 40 mov 0x40(%eax),%eax if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10b422: f6 40 11 40 testb $0x40,0x11(%eax) 10b426: 74 18 je 10b440 <_Rate_monotonic_Timeout+0x44> 10b428: 8b 53 08 mov 0x8(%ebx),%edx 10b42b: 39 50 20 cmp %edx,0x20(%eax) 10b42e: 75 10 jne 10b440 <_Rate_monotonic_Timeout+0x44> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10b430: 52 push %edx 10b431: 52 push %edx 10b432: 68 f8 ff 03 10 push $0x1003fff8 10b437: 50 push %eax 10b438: e8 3b 22 00 00 call 10d678 <_Thread_Clear_state> the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 10b43d: 59 pop %ecx 10b43e: eb 10 jmp 10b450 <_Rate_monotonic_Timeout+0x54> _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 10b440: 83 7b 38 01 cmpl $0x1,0x38(%ebx) 10b444: 75 2b jne 10b471 <_Rate_monotonic_Timeout+0x75> the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 10b446: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) _Rate_monotonic_Initiate_statistics( the_period ); 10b44d: 83 ec 0c sub $0xc,%esp 10b450: 53 push %ebx 10b451: e8 ec fa ff ff call 10af42 <_Rate_monotonic_Initiate_statistics> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b456: 8b 43 3c mov 0x3c(%ebx),%eax 10b459: 89 43 1c mov %eax,0x1c(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b45c: 58 pop %eax 10b45d: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 10b45e: 83 c3 10 add $0x10,%ebx 10b461: 53 push %ebx 10b462: 68 28 85 12 00 push $0x128528 10b467: e8 34 32 00 00 call 10e6a0 <_Watchdog_Insert> 10b46c: 83 c4 10 add $0x10,%esp 10b46f: eb 07 jmp 10b478 <_Rate_monotonic_Timeout+0x7c> } else the_period->state = RATE_MONOTONIC_EXPIRED; 10b471: c7 43 38 04 00 00 00 movl $0x4,0x38(%ebx) */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10b478: a1 64 84 12 00 mov 0x128464,%eax 10b47d: 48 dec %eax 10b47e: a3 64 84 12 00 mov %eax,0x128464 case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10b483: 8b 5d fc mov -0x4(%ebp),%ebx 10b486: c9 leave 10b487: c3 ret =============================================================================== 0010ba6c <_Scheduler_priority_Block>: #include void _Scheduler_priority_Block( Thread_Control *the_thread ) { 10ba6c: 55 push %ebp 10ba6d: 89 e5 mov %esp,%ebp 10ba6f: 56 push %esi 10ba70: 53 push %ebx 10ba71: 8b 55 08 mov 0x8(%ebp),%edx ) { Scheduler_priority_Per_thread *sched_info; Chain_Control *ready; sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info; 10ba74: 8b 8a 8c 00 00 00 mov 0x8c(%edx),%ecx ready = sched_info->ready_chain; 10ba7a: 8b 01 mov (%ecx),%eax if ( _Chain_Has_only_one_node( ready ) ) { 10ba7c: 8b 58 08 mov 0x8(%eax),%ebx 10ba7f: 39 18 cmp %ebx,(%eax) 10ba81: 75 32 jne 10bab5 <_Scheduler_priority_Block+0x49> Chain_Node *tail = _Chain_Tail( the_chain ); 10ba83: 8d 58 04 lea 0x4(%eax),%ebx 10ba86: 89 18 mov %ebx,(%eax) head->next = tail; head->previous = NULL; 10ba88: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) tail->previous = head; 10ba8f: 89 40 08 mov %eax,0x8(%eax) RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor &= the_priority_map->block_minor; 10ba92: 8b 59 04 mov 0x4(%ecx),%ebx 10ba95: 66 8b 03 mov (%ebx),%ax 10ba98: 66 23 41 0e and 0xe(%ecx),%ax 10ba9c: 66 89 03 mov %ax,(%ebx) if ( *the_priority_map->minor == 0 ) 10ba9f: 66 85 c0 test %ax,%ax 10baa2: 75 1b jne 10babf <_Scheduler_priority_Block+0x53> _Priority_Major_bit_map &= the_priority_map->block_major; 10baa4: 66 a1 78 58 12 00 mov 0x125878,%ax 10baaa: 23 41 0c and 0xc(%ecx),%eax 10baad: 66 a3 78 58 12 00 mov %ax,0x125878 10bab3: eb 0a jmp 10babf <_Scheduler_priority_Block+0x53> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 10bab5: 8b 0a mov (%edx),%ecx previous = the_node->previous; 10bab7: 8b 42 04 mov 0x4(%edx),%eax next->previous = previous; 10baba: 89 41 04 mov %eax,0x4(%ecx) previous->next = next; 10babd: 89 08 mov %ecx,(%eax) _Scheduler_priority_Ready_queue_extract( the_thread ); /* TODO: flash critical section? */ if ( _Thread_Is_heir( the_thread ) ) 10babf: 3b 15 6c 58 12 00 cmp 0x12586c,%edx 10bac5: 75 43 jne 10bb0a <_Scheduler_priority_Block+0x9e> 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 ); 10bac7: 66 8b 35 78 58 12 00 mov 0x125878,%si 10bace: 31 c9 xor %ecx,%ecx 10bad0: 89 cb mov %ecx,%ebx 10bad2: 66 0f bc de bsf %si,%bx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10bad6: 0f b7 db movzwl %bx,%ebx 10bad9: 66 8b b4 1b 7c 58 12 mov 0x12587c(%ebx,%ebx,1),%si 10bae0: 00 10bae1: 66 0f bc ce bsf %si,%cx return (_Priority_Bits_index( major ) << 4) + 10bae5: c1 e3 04 shl $0x4,%ebx 10bae8: 0f b7 c9 movzwl %cx,%ecx 10baeb: 8d 04 0b lea (%ebx,%ecx,1),%eax Chain_Control *the_ready_queue ) { Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) 10baee: 6b c0 0c imul $0xc,%eax,%eax 10baf1: 03 05 50 11 12 00 add 0x121150,%eax _Scheduler_priority_Schedule_body(); if ( _Thread_Is_executing( the_thread ) ) _Thread_Dispatch_necessary = true; } 10baf7: 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 ); 10baf9: 83 c0 04 add $0x4,%eax return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 10bafc: 31 c9 xor %ecx,%ecx Chain_Control *the_ready_queue ) { Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) 10bafe: 39 c3 cmp %eax,%ebx 10bb00: 74 02 je 10bb04 <_Scheduler_priority_Block+0x98><== NEVER TAKEN return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); 10bb02: 89 d9 mov %ebx,%ecx * * @param[in] the_thread - pointer to thread */ RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10bb04: 89 0d 6c 58 12 00 mov %ecx,0x12586c /* TODO: flash critical section? */ if ( _Thread_Is_heir( the_thread ) ) _Scheduler_priority_Schedule_body(); if ( _Thread_Is_executing( the_thread ) ) 10bb0a: 3b 15 68 58 12 00 cmp 0x125868,%edx 10bb10: 75 07 jne 10bb19 <_Scheduler_priority_Block+0xad> _Thread_Dispatch_necessary = true; 10bb12: c6 05 74 58 12 00 01 movb $0x1,0x125874 } 10bb19: 5b pop %ebx 10bb1a: 5e pop %esi 10bb1b: c9 leave 10bb1c: c3 ret =============================================================================== 0010bc6c <_Scheduler_priority_Schedule>: #include #include #include void _Scheduler_priority_Schedule(void) { 10bc6c: 55 push %ebp 10bc6d: 89 e5 mov %esp,%ebp 10bc6f: 53 push %ebx 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 ); 10bc70: 66 8b 1d 78 58 12 00 mov 0x125878,%bx 10bc77: 31 d2 xor %edx,%edx 10bc79: 89 d1 mov %edx,%ecx 10bc7b: 66 0f bc cb bsf %bx,%cx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10bc7f: 0f b7 c9 movzwl %cx,%ecx 10bc82: 66 8b 9c 09 7c 58 12 mov 0x12587c(%ecx,%ecx,1),%bx 10bc89: 00 10bc8a: 66 0f bc d3 bsf %bx,%dx return (_Priority_Bits_index( major ) << 4) + 10bc8e: c1 e1 04 shl $0x4,%ecx 10bc91: 0f b7 d2 movzwl %dx,%edx 10bc94: 8d 04 11 lea (%ecx,%edx,1),%eax Chain_Control *the_ready_queue ) { Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) 10bc97: 6b c0 0c imul $0xc,%eax,%eax 10bc9a: 03 05 50 11 12 00 add 0x121150,%eax _Scheduler_priority_Schedule_body(); } 10bca0: 8b 08 mov (%eax),%ecx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10bca2: 83 c0 04 add $0x4,%eax return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 10bca5: 31 d2 xor %edx,%edx Chain_Control *the_ready_queue ) { Priority_Control index = _Priority_bit_map_Get_highest(); if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) ) 10bca7: 39 c1 cmp %eax,%ecx 10bca9: 74 02 je 10bcad <_Scheduler_priority_Schedule+0x41><== NEVER TAKEN return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); 10bcab: 89 ca mov %ecx,%edx * * @param[in] the_thread - pointer to thread */ RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body(void) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10bcad: 89 15 6c 58 12 00 mov %edx,0x12586c 10bcb3: 5b pop %ebx 10bcb4: c9 leave 10bcb5: c3 ret =============================================================================== 0010ad28 <_TOD_Validate>: */ bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 10ad28: 55 push %ebp 10ad29: 89 e5 mov %esp,%ebp 10ad2b: 56 push %esi 10ad2c: 53 push %ebx 10ad2d: 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(); 10ad30: 8b 35 94 4b 12 00 mov 0x124b94,%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; 10ad36: 31 db xor %ebx,%ebx uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 10ad38: 85 c9 test %ecx,%ecx 10ad3a: 74 57 je 10ad93 <_TOD_Validate+0x6b> <== NEVER TAKEN ) { uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 10ad3c: b8 40 42 0f 00 mov $0xf4240,%eax 10ad41: 31 d2 xor %edx,%edx 10ad43: f7 f6 div %esi rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 10ad45: 39 41 18 cmp %eax,0x18(%ecx) 10ad48: 73 49 jae 10ad93 <_TOD_Validate+0x6b> (the_tod->ticks >= ticks_per_second) || 10ad4a: 83 79 14 3b cmpl $0x3b,0x14(%ecx) 10ad4e: 77 43 ja 10ad93 <_TOD_Validate+0x6b> (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 10ad50: 83 79 10 3b cmpl $0x3b,0x10(%ecx) 10ad54: 77 3d ja 10ad93 <_TOD_Validate+0x6b> (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 10ad56: 83 79 0c 17 cmpl $0x17,0xc(%ecx) 10ad5a: 77 37 ja 10ad93 <_TOD_Validate+0x6b> (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 10ad5c: 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) || 10ad5f: 85 c0 test %eax,%eax 10ad61: 74 30 je 10ad93 <_TOD_Validate+0x6b> <== NEVER TAKEN (the_tod->month == 0) || 10ad63: 83 f8 0c cmp $0xc,%eax 10ad66: 77 2b ja 10ad93 <_TOD_Validate+0x6b> (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 10ad68: 8b 31 mov (%ecx),%esi (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) || 10ad6a: 81 fe c3 07 00 00 cmp $0x7c3,%esi 10ad70: 76 21 jbe 10ad93 <_TOD_Validate+0x6b> (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) 10ad72: 8b 51 08 mov 0x8(%ecx),%edx (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) || 10ad75: 85 d2 test %edx,%edx 10ad77: 74 1a je 10ad93 <_TOD_Validate+0x6b> <== NEVER TAKEN (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 10ad79: 83 e6 03 and $0x3,%esi 10ad7c: 75 09 jne 10ad87 <_TOD_Validate+0x5f> days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 10ad7e: 8b 04 85 90 1d 12 00 mov 0x121d90(,%eax,4),%eax 10ad85: eb 07 jmp 10ad8e <_TOD_Validate+0x66> else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 10ad87: 8b 04 85 5c 1d 12 00 mov 0x121d5c(,%eax,4),%eax * false - if the the_tod is invalid * * NOTE: This routine only works for leap-years through 2099. */ bool _TOD_Validate( 10ad8e: 39 c2 cmp %eax,%edx 10ad90: 0f 96 c3 setbe %bl if ( the_tod->day > days_in_month ) return false; return true; } 10ad93: 88 d8 mov %bl,%al 10ad95: 5b pop %ebx 10ad96: 5e pop %esi 10ad97: c9 leave 10ad98: c3 ret =============================================================================== 0010be24 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10be24: 55 push %ebp 10be25: 89 e5 mov %esp,%ebp 10be27: 57 push %edi 10be28: 56 push %esi 10be29: 53 push %ebx 10be2a: 83 ec 28 sub $0x28,%esp 10be2d: 8b 5d 08 mov 0x8(%ebp),%ebx 10be30: 8b 75 0c mov 0xc(%ebp),%esi 10be33: 8a 45 10 mov 0x10(%ebp),%al 10be36: 88 45 e7 mov %al,-0x19(%ebp) States_Control state, original_state; /* * Save original state */ original_state = the_thread->current_state; 10be39: 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 ); 10be3c: 53 push %ebx 10be3d: e8 62 0b 00 00 call 10c9a4 <_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 ) 10be42: 83 c4 10 add $0x10,%esp 10be45: 39 73 14 cmp %esi,0x14(%ebx) 10be48: 74 0c je 10be56 <_Thread_Change_priority+0x32> _Thread_Set_priority( the_thread, new_priority ); 10be4a: 50 push %eax 10be4b: 50 push %eax 10be4c: 56 push %esi 10be4d: 53 push %ebx 10be4e: e8 01 0b 00 00 call 10c954 <_Thread_Set_priority> 10be53: 83 c4 10 add $0x10,%esp _ISR_Disable( level ); 10be56: 9c pushf 10be57: fa cli 10be58: 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; 10be59: 8b 43 10 mov 0x10(%ebx),%eax if ( state != STATES_TRANSIENT ) { 10be5c: 83 f8 04 cmp $0x4,%eax 10be5f: 74 2b je 10be8c <_Thread_Change_priority+0x68> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10be61: 83 e7 04 and $0x4,%edi 10be64: 75 08 jne 10be6e <_Thread_Change_priority+0x4a><== NEVER TAKEN RTEMS_INLINE_ROUTINE States_Control _States_Clear ( States_Control states_to_clear, States_Control current_state ) { return (current_state & ~states_to_clear); 10be66: 89 c2 mov %eax,%edx 10be68: 83 e2 fb and $0xfffffffb,%edx 10be6b: 89 53 10 mov %edx,0x10(%ebx) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); 10be6e: 56 push %esi 10be6f: 9d popf if ( _States_Is_waiting_on_thread_queue( state ) ) { 10be70: a9 e0 be 03 00 test $0x3bee0,%eax 10be75: 74 65 je 10bedc <_Thread_Change_priority+0xb8> _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10be77: 89 5d 0c mov %ebx,0xc(%ebp) 10be7a: 8b 43 44 mov 0x44(%ebx),%eax 10be7d: 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 ); } 10be80: 8d 65 f4 lea -0xc(%ebp),%esp 10be83: 5b pop %ebx 10be84: 5e pop %esi 10be85: 5f pop %edi 10be86: 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 ); 10be87: e9 40 0a 00 00 jmp 10c8cc <_Thread_queue_Requeue> } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10be8c: 83 e7 04 and $0x4,%edi 10be8f: 75 26 jne 10beb7 <_Thread_Change_priority+0x93><== 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 ); 10be91: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) if ( prepend_it ) 10be98: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10be9c: 74 0c je 10beaa <_Thread_Change_priority+0x86> */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue_first( the_thread ); 10be9e: 83 ec 0c sub $0xc,%esp 10bea1: 53 push %ebx 10bea2: ff 15 78 11 12 00 call *0x121178 10bea8: eb 0a jmp 10beb4 <_Thread_Change_priority+0x90> */ RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue( Thread_Control *the_thread ) { _Scheduler.Operations.enqueue( the_thread ); 10beaa: 83 ec 0c sub $0xc,%esp 10bead: 53 push %ebx 10beae: ff 15 74 11 12 00 call *0x121174 10beb4: 83 c4 10 add $0x10,%esp _Scheduler_Enqueue_first( the_thread ); else _Scheduler_Enqueue( the_thread ); } _ISR_Flash( level ); 10beb7: 56 push %esi 10beb8: 9d popf 10beb9: 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(); 10beba: ff 15 58 11 12 00 call *0x121158 * is also the heir thread, and false otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void ) { return ( _Thread_Executing == _Thread_Heir ); 10bec0: a1 68 58 12 00 mov 0x125868,%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() && 10bec5: 3b 05 6c 58 12 00 cmp 0x12586c,%eax 10becb: 74 0d je 10beda <_Thread_Change_priority+0xb6> 10becd: 80 78 74 00 cmpb $0x0,0x74(%eax) 10bed1: 74 07 je 10beda <_Thread_Change_priority+0xb6> _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; 10bed3: c6 05 74 58 12 00 01 movb $0x1,0x125874 _ISR_Enable( level ); 10beda: 56 push %esi 10bedb: 9d popf } 10bedc: 8d 65 f4 lea -0xc(%ebp),%esp 10bedf: 5b pop %ebx 10bee0: 5e pop %esi 10bee1: 5f pop %edi 10bee2: c9 leave 10bee3: c3 ret =============================================================================== 0010c088 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 10c088: 55 push %ebp 10c089: 89 e5 mov %esp,%ebp 10c08b: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10c08e: 8d 45 f4 lea -0xc(%ebp),%eax 10c091: 50 push %eax 10c092: ff 75 08 pushl 0x8(%ebp) 10c095: e8 82 01 00 00 call 10c21c <_Thread_Get> switch ( location ) { 10c09a: 83 c4 10 add $0x10,%esp 10c09d: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10c0a1: 75 1b jne 10c0be <_Thread_Delay_ended+0x36><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_Clear_state( 10c0a3: 52 push %edx 10c0a4: 52 push %edx 10c0a5: 68 18 00 00 10 push $0x10000018 10c0aa: 50 push %eax 10c0ab: e8 34 fe ff ff call 10bee4 <_Thread_Clear_state> 10c0b0: a1 40 53 12 00 mov 0x125340,%eax 10c0b5: 48 dec %eax 10c0b6: a3 40 53 12 00 mov %eax,0x125340 10c0bb: 83 c4 10 add $0x10,%esp | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Thread_Unnest_dispatch(); break; } } 10c0be: c9 leave 10c0bf: c3 ret =============================================================================== 0010c0c0 <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10c0c0: 55 push %ebp 10c0c1: 89 e5 mov %esp,%ebp 10c0c3: 57 push %edi 10c0c4: 56 push %esi 10c0c5: 53 push %ebx 10c0c6: 83 ec 1c sub $0x1c,%esp Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10c0c9: 8b 1d 68 58 12 00 mov 0x125868,%ebx _ISR_Disable( level ); 10c0cf: 9c pushf 10c0d0: fa cli 10c0d1: 58 pop %eax #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); _Timestamp_Subtract( 10c0d2: 8d 7d d8 lea -0x28(%ebp),%edi Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10c0d5: e9 f9 00 00 00 jmp 10c1d3 <_Thread_Dispatch+0x113> heir = _Thread_Heir; 10c0da: 8b 35 6c 58 12 00 mov 0x12586c,%esi _Thread_Dispatch_disable_level = 1; 10c0e0: c7 05 40 53 12 00 01 movl $0x1,0x125340 10c0e7: 00 00 00 _Thread_Dispatch_necessary = false; 10c0ea: c6 05 74 58 12 00 00 movb $0x0,0x125874 _Thread_Executing = heir; 10c0f1: 89 35 68 58 12 00 mov %esi,0x125868 /* * 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 ) 10c0f7: 39 de cmp %ebx,%esi 10c0f9: 0f 84 e2 00 00 00 je 10c1e1 <_Thread_Dispatch+0x121> */ #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 ) 10c0ff: 83 7e 7c 01 cmpl $0x1,0x7c(%esi) 10c103: 75 09 jne 10c10e <_Thread_Dispatch+0x4e> heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c105: 8b 15 10 53 12 00 mov 0x125310,%edx 10c10b: 89 56 78 mov %edx,0x78(%esi) _ISR_Enable( level ); 10c10e: 50 push %eax 10c10f: 9d popf #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); 10c110: 83 ec 0c sub $0xc,%esp 10c113: 8d 45 e0 lea -0x20(%ebp),%eax 10c116: 50 push %eax 10c117: e8 5c 34 00 00 call 10f578 <_TOD_Get_uptime> _Timestamp_Subtract( 10c11c: 83 c4 0c add $0xc,%esp 10c11f: 57 push %edi 10c120: 8d 45 e0 lea -0x20(%ebp),%eax 10c123: 50 push %eax 10c124: 68 f0 53 12 00 push $0x1253f0 10c129: e8 76 0a 00 00 call 10cba4 <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timestamp_Add_to( &executing->cpu_time_used, &ran ); 10c12e: 58 pop %eax 10c12f: 5a pop %edx 10c130: 57 push %edi 10c131: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10c137: 50 push %eax 10c138: e8 37 0a 00 00 call 10cb74 <_Timespec_Add_to> _Thread_Time_of_last_context_switch = uptime; 10c13d: 8b 45 e0 mov -0x20(%ebp),%eax 10c140: 8b 55 e4 mov -0x1c(%ebp),%edx 10c143: a3 f0 53 12 00 mov %eax,0x1253f0 10c148: 89 15 f4 53 12 00 mov %edx,0x1253f4 #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10c14e: a1 c8 53 12 00 mov 0x1253c8,%eax 10c153: 83 c4 10 add $0x10,%esp 10c156: 85 c0 test %eax,%eax 10c158: 74 10 je 10c16a <_Thread_Dispatch+0xaa> <== NEVER TAKEN executing->libc_reent = *_Thread_libc_reent; 10c15a: 8b 10 mov (%eax),%edx 10c15c: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx) *_Thread_libc_reent = heir->libc_reent; 10c162: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx 10c168: 89 10 mov %edx,(%eax) } _User_extensions_Thread_switch( executing, heir ); 10c16a: 51 push %ecx 10c16b: 51 push %ecx 10c16c: 56 push %esi 10c16d: 53 push %ebx 10c16e: e8 69 0c 00 00 call 10cddc <_User_extensions_Thread_switch> if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10c173: 58 pop %eax 10c174: 5a pop %edx 10c175: 81 c6 c8 00 00 00 add $0xc8,%esi 10c17b: 56 push %esi 10c17c: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax 10c182: 50 push %eax 10c183: e8 28 0f 00 00 call 10d0b0 <_CPU_Context_switch> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10c188: 83 c4 10 add $0x10,%esp 10c18b: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx) 10c192: 74 36 je 10c1ca <_Thread_Dispatch+0x10a> #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 ); 10c194: a1 c4 53 12 00 mov 0x1253c4,%eax 10c199: 39 c3 cmp %eax,%ebx 10c19b: 74 2d je 10c1ca <_Thread_Dispatch+0x10a> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10c19d: 85 c0 test %eax,%eax 10c19f: 74 11 je 10c1b2 <_Thread_Dispatch+0xf2> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10c1a1: 83 ec 0c sub $0xc,%esp 10c1a4: 05 e0 00 00 00 add $0xe0,%eax 10c1a9: 50 push %eax 10c1aa: e8 35 0f 00 00 call 10d0e4 <_CPU_Context_save_fp> 10c1af: 83 c4 10 add $0x10,%esp _Context_Restore_fp( &executing->fp_context ); 10c1b2: 83 ec 0c sub $0xc,%esp 10c1b5: 8d 83 e0 00 00 00 lea 0xe0(%ebx),%eax 10c1bb: 50 push %eax 10c1bc: e8 2d 0f 00 00 call 10d0ee <_CPU_Context_restore_fp> _Thread_Allocated_fp = executing; 10c1c1: 89 1d c4 53 12 00 mov %ebx,0x1253c4 10c1c7: 83 c4 10 add $0x10,%esp if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10c1ca: 8b 1d 68 58 12 00 mov 0x125868,%ebx _ISR_Disable( level ); 10c1d0: 9c pushf 10c1d1: fa cli 10c1d2: 58 pop %eax Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10c1d3: 8a 15 74 58 12 00 mov 0x125874,%dl 10c1d9: 84 d2 test %dl,%dl 10c1db: 0f 85 f9 fe ff ff jne 10c0da <_Thread_Dispatch+0x1a> _ISR_Disable( level ); } post_switch: _Thread_Dispatch_disable_level = 0; 10c1e1: c7 05 40 53 12 00 00 movl $0x0,0x125340 10c1e8: 00 00 00 _ISR_Enable( level ); 10c1eb: 50 push %eax 10c1ec: 9d popf _API_extensions_Run_postswitch(); 10c1ed: e8 3d e7 ff ff call 10a92f <_API_extensions_Run_postswitch> } 10c1f2: 8d 65 f4 lea -0xc(%ebp),%esp 10c1f5: 5b pop %ebx 10c1f6: 5e pop %esi 10c1f7: 5f pop %edi 10c1f8: c9 leave 10c1f9: c3 ret =============================================================================== 00110f9c <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 110f9c: 55 push %ebp 110f9d: 89 e5 mov %esp,%ebp 110f9f: 53 push %ebx 110fa0: 83 ec 14 sub $0x14,%esp #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing; 110fa3: 8b 1d 68 58 12 00 mov 0x125868,%ebx /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 110fa9: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax _ISR_Set_level(level); 110faf: 85 c0 test %eax,%eax 110fb1: 74 03 je 110fb6 <_Thread_Handler+0x1a> 110fb3: fa cli 110fb4: eb 01 jmp 110fb7 <_Thread_Handler+0x1b> 110fb6: fb sti #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) doneCons = doneConstructors; 110fb7: a0 00 50 12 00 mov 0x125000,%al 110fbc: 88 45 f7 mov %al,-0x9(%ebp) doneConstructors = 1; 110fbf: c6 05 00 50 12 00 01 movb $0x1,0x125000 #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 110fc6: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx) 110fcd: 74 24 je 110ff3 <_Thread_Handler+0x57> #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 ); 110fcf: a1 c4 53 12 00 mov 0x1253c4,%eax 110fd4: 39 c3 cmp %eax,%ebx 110fd6: 74 1b je 110ff3 <_Thread_Handler+0x57> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 110fd8: 85 c0 test %eax,%eax 110fda: 74 11 je 110fed <_Thread_Handler+0x51> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 110fdc: 83 ec 0c sub $0xc,%esp 110fdf: 05 e0 00 00 00 add $0xe0,%eax 110fe4: 50 push %eax 110fe5: e8 fa c0 ff ff call 10d0e4 <_CPU_Context_save_fp> 110fea: 83 c4 10 add $0x10,%esp _Thread_Allocated_fp = executing; 110fed: 89 1d c4 53 12 00 mov %ebx,0x1253c4 /* * 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 ); 110ff3: 83 ec 0c sub $0xc,%esp 110ff6: 53 push %ebx 110ff7: e8 90 bc ff ff call 10cc8c <_User_extensions_Thread_begin> /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 110ffc: e8 f9 b1 ff ff call 10c1fa <_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) */ { 111001: 83 c4 10 add $0x10,%esp 111004: 80 7d f7 00 cmpb $0x0,-0x9(%ebp) 111008: 75 05 jne 11100f <_Thread_Handler+0x73> INIT_NAME (); 11100a: e8 31 c7 00 00 call 11d740 <__start_set_sysctl_set> } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 11100f: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 111015: 85 c0 test %eax,%eax 111017: 75 0b jne 111024 <_Thread_Handler+0x88> executing->Wait.return_argument = (*(Thread_Entry_numeric) executing->Start.entry_point)( 111019: 83 ec 0c sub $0xc,%esp 11101c: ff b3 9c 00 00 00 pushl 0x9c(%ebx) 111022: eb 0c jmp 111030 <_Thread_Handler+0x94> executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { 111024: 48 dec %eax 111025: 75 15 jne 11103c <_Thread_Handler+0xa0> <== NEVER TAKEN executing->Wait.return_argument = (*(Thread_Entry_pointer) executing->Start.entry_point)( 111027: 83 ec 0c sub $0xc,%esp 11102a: ff b3 98 00 00 00 pushl 0x98(%ebx) 111030: ff 93 90 00 00 00 call *0x90(%ebx) executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { executing->Wait.return_argument = 111036: 89 43 28 mov %eax,0x28(%ebx) 111039: 83 c4 10 add $0x10,%esp * 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 ); 11103c: 83 ec 0c sub $0xc,%esp 11103f: 53 push %ebx 111040: e8 78 bc ff ff call 10ccbd <_User_extensions_Thread_exitted> _Internal_error_Occurred( 111045: 83 c4 0c add $0xc,%esp 111048: 6a 05 push $0x5 11104a: 6a 01 push $0x1 11104c: 6a 00 push $0x0 11104e: e8 39 a2 ff ff call 10b28c <_Internal_error_Occurred> =============================================================================== 0010c290 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10c290: 55 push %ebp 10c291: 89 e5 mov %esp,%ebp 10c293: 57 push %edi 10c294: 56 push %esi 10c295: 53 push %ebx 10c296: 83 ec 1c sub $0x1c,%esp 10c299: 8b 5d 0c mov 0xc(%ebp),%ebx 10c29c: 8b 4d 10 mov 0x10(%ebp),%ecx 10c29f: 8b 75 14 mov 0x14(%ebp),%esi 10c2a2: 8a 55 18 mov 0x18(%ebp),%dl 10c2a5: 8a 45 20 mov 0x20(%ebp),%al 10c2a8: 88 45 e7 mov %al,-0x19(%ebp) /* * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; 10c2ab: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx) 10c2b2: 00 00 00 10c2b5: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx) 10c2bc: 00 00 00 extensions_area = NULL; the_thread->libc_reent = NULL; 10c2bf: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10c2c6: 00 00 00 if ( !actual_stack_size || actual_stack_size < stack_size ) return false; /* stack allocation failed */ stack = the_thread->Start.stack; #else if ( !stack_area ) { 10c2c9: 85 c9 test %ecx,%ecx 10c2cb: 75 31 jne 10c2fe <_Thread_Initialize+0x6e> actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10c2cd: 57 push %edi 10c2ce: 57 push %edi 10c2cf: 56 push %esi 10c2d0: 53 push %ebx 10c2d1: 88 55 e0 mov %dl,-0x20(%ebp) 10c2d4: e8 fb 06 00 00 call 10c9d4 <_Thread_Stack_Allocate> if ( !actual_stack_size || actual_stack_size < stack_size ) 10c2d9: 83 c4 10 add $0x10,%esp 10c2dc: 39 f0 cmp %esi,%eax 10c2de: 8a 55 e0 mov -0x20(%ebp),%dl 10c2e1: 0f 82 bf 01 00 00 jb 10c4a6 <_Thread_Initialize+0x216> 10c2e7: 85 c0 test %eax,%eax 10c2e9: 0f 84 b7 01 00 00 je 10c4a6 <_Thread_Initialize+0x216><== NEVER TAKEN return false; /* stack allocation failed */ stack = the_thread->Start.stack; 10c2ef: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx the_thread->Start.core_allocated_stack = true; 10c2f5: c6 83 b4 00 00 00 01 movb $0x1,0xb4(%ebx) 10c2fc: eb 09 jmp 10c307 <_Thread_Initialize+0x77> } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = false; 10c2fe: c6 83 b4 00 00 00 00 movb $0x0,0xb4(%ebx) 10c305: 89 f0 mov %esi,%eax Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 10c307: 89 8b bc 00 00 00 mov %ecx,0xbc(%ebx) the_stack->size = size; 10c30d: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) extensions_area = NULL; the_thread->libc_reent = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) fp_area = NULL; 10c313: 31 ff xor %edi,%edi /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 10c315: 84 d2 test %dl,%dl 10c317: 74 17 je 10c330 <_Thread_Initialize+0xa0> fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10c319: 83 ec 0c sub $0xc,%esp 10c31c: 6a 6c push $0x6c 10c31e: e8 27 0d 00 00 call 10d04a <_Workspace_Allocate> 10c323: 89 c7 mov %eax,%edi if ( !fp_area ) 10c325: 83 c4 10 add $0x10,%esp 10c328: 85 c0 test %eax,%eax 10c32a: 0f 84 23 01 00 00 je 10c453 <_Thread_Initialize+0x1c3> goto failed; fp_area = _Context_Fp_start( fp_area, 0 ); } the_thread->fp_context = fp_area; 10c330: 89 bb e0 00 00 00 mov %edi,0xe0(%ebx) the_thread->Start.fp_context = fp_area; 10c336: 89 bb c0 00 00 00 mov %edi,0xc0(%ebx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10c33c: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) the_watchdog->routine = routine; 10c343: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) the_watchdog->id = id; 10c34a: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) the_watchdog->user_data = user_data; 10c351: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c358: a1 d4 53 12 00 mov 0x1253d4,%eax * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10c35d: 31 f6 xor %esi,%esi #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c35f: 85 c0 test %eax,%eax 10c361: 74 1d je 10c380 <_Thread_Initialize+0xf0> extensions_area = _Workspace_Allocate( 10c363: 83 ec 0c sub $0xc,%esp 10c366: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10c36d: 50 push %eax 10c36e: e8 d7 0c 00 00 call 10d04a <_Workspace_Allocate> 10c373: 89 c6 mov %eax,%esi (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) 10c375: 83 c4 10 add $0x10,%esp 10c378: 85 c0 test %eax,%eax 10c37a: 0f 84 d5 00 00 00 je 10c455 <_Thread_Initialize+0x1c5> goto failed; } the_thread->extensions = (void **) extensions_area; 10c380: 89 b3 f0 00 00 00 mov %esi,0xf0(%ebx) * if they are linked to the thread. An extension user may * create the extension long after tasks have been created * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { 10c386: 85 f6 test %esi,%esi 10c388: 74 16 je 10c3a0 <_Thread_Initialize+0x110> for ( i = 0; i <= _Thread_Maximum_extensions ; i++ ) 10c38a: 8b 15 d4 53 12 00 mov 0x1253d4,%edx 10c390: 31 c0 xor %eax,%eax 10c392: eb 08 jmp 10c39c <_Thread_Initialize+0x10c> the_thread->extensions[i] = NULL; 10c394: c7 04 86 00 00 00 00 movl $0x0,(%esi,%eax,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++ ) 10c39b: 40 inc %eax 10c39c: 39 d0 cmp %edx,%eax 10c39e: 76 f4 jbe 10c394 <_Thread_Initialize+0x104> /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10c3a0: 8a 45 e7 mov -0x19(%ebp),%al 10c3a3: 88 83 a0 00 00 00 mov %al,0xa0(%ebx) the_thread->Start.budget_algorithm = budget_algorithm; 10c3a9: 8b 45 24 mov 0x24(%ebp),%eax 10c3ac: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) the_thread->Start.budget_callout = budget_callout; 10c3b2: 8b 45 28 mov 0x28(%ebp),%eax 10c3b5: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) switch ( budget_algorithm ) { 10c3bb: 83 7d 24 02 cmpl $0x2,0x24(%ebp) 10c3bf: 75 08 jne 10c3c9 <_Thread_Initialize+0x139> case THREAD_CPU_BUDGET_ALGORITHM_NONE: case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: break; #if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE) case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c3c1: a1 10 53 12 00 mov 0x125310,%eax 10c3c6: 89 43 78 mov %eax,0x78(%ebx) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; #endif } the_thread->Start.isr_level = isr_level; 10c3c9: 8b 45 2c mov 0x2c(%ebp),%eax 10c3cc: 89 83 ac 00 00 00 mov %eax,0xac(%ebx) the_thread->current_state = STATES_DORMANT; 10c3d2: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) the_thread->Wait.queue = NULL; 10c3d9: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) the_thread->resource_count = 0; 10c3e0: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->real_priority = priority; 10c3e7: 8b 45 1c mov 0x1c(%ebp),%eax 10c3ea: 89 43 18 mov %eax,0x18(%ebx) the_thread->Start.initial_priority = priority; 10c3ed: 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 ); 10c3f3: 83 ec 0c sub $0xc,%esp 10c3f6: 53 push %ebx 10c3f7: ff 15 68 11 12 00 call *0x121168 10c3fd: 89 c2 mov %eax,%edx sched =_Scheduler_Allocate( the_thread ); if ( !sched ) 10c3ff: 83 c4 10 add $0x10,%esp 10c402: 85 c0 test %eax,%eax 10c404: 74 51 je 10c457 <_Thread_Initialize+0x1c7> goto failed; _Thread_Set_priority( the_thread, priority ); 10c406: 51 push %ecx 10c407: 51 push %ecx 10c408: ff 75 1c pushl 0x1c(%ebp) 10c40b: 53 push %ebx 10c40c: 89 45 e0 mov %eax,-0x20(%ebp) 10c40f: e8 40 05 00 00 call 10c954 <_Thread_Set_priority> /* * Initialize the CPU usage statistics */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Set_to_zero( &the_thread->cpu_time_used ); 10c414: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) 10c41b: 00 00 00 10c41e: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) 10c425: 00 00 00 _Workspace_Free( sched ); _Thread_Stack_Free( the_thread ); return false; } 10c428: 8b 45 08 mov 0x8(%ebp),%eax 10c42b: 8b 40 1c mov 0x1c(%eax),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10c42e: 0f b7 4b 08 movzwl 0x8(%ebx),%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c432: 89 1c 88 mov %ebx,(%eax,%ecx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10c435: 8b 45 30 mov 0x30(%ebp),%eax 10c438: 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 ); 10c43b: 89 1c 24 mov %ebx,(%esp) 10c43e: e8 e9 08 00 00 call 10cd2c <_User_extensions_Thread_create> 10c443: 88 c1 mov %al,%cl if ( extension_status ) 10c445: 83 c4 10 add $0x10,%esp return true; 10c448: b0 01 mov $0x1,%al * 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 ); if ( extension_status ) 10c44a: 84 c9 test %cl,%cl 10c44c: 8b 55 e0 mov -0x20(%ebp),%edx 10c44f: 74 06 je 10c457 <_Thread_Initialize+0x1c7> 10c451: eb 55 jmp 10c4a8 <_Thread_Initialize+0x218> * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10c453: 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; 10c455: 31 d2 xor %edx,%edx extension_status = _User_extensions_Thread_create( the_thread ); if ( extension_status ) return true; failed: _Workspace_Free( the_thread->libc_reent ); 10c457: 83 ec 0c sub $0xc,%esp 10c45a: ff b3 e4 00 00 00 pushl 0xe4(%ebx) 10c460: 89 55 e0 mov %edx,-0x20(%ebp) 10c463: e8 fb 0b 00 00 call 10d063 <_Workspace_Free> for ( i=0 ; i <= THREAD_API_LAST ; i++ ) _Workspace_Free( the_thread->API_Extensions[i] ); 10c468: 5a pop %edx 10c469: ff b3 e8 00 00 00 pushl 0xe8(%ebx) 10c46f: e8 ef 0b 00 00 call 10d063 <_Workspace_Free> 10c474: 58 pop %eax 10c475: ff b3 ec 00 00 00 pushl 0xec(%ebx) 10c47b: e8 e3 0b 00 00 call 10d063 <_Workspace_Free> _Workspace_Free( extensions_area ); 10c480: 89 34 24 mov %esi,(%esp) 10c483: e8 db 0b 00 00 call 10d063 <_Workspace_Free> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Workspace_Free( fp_area ); 10c488: 89 3c 24 mov %edi,(%esp) 10c48b: e8 d3 0b 00 00 call 10d063 <_Workspace_Free> #endif _Workspace_Free( sched ); 10c490: 8b 55 e0 mov -0x20(%ebp),%edx 10c493: 89 14 24 mov %edx,(%esp) 10c496: e8 c8 0b 00 00 call 10d063 <_Workspace_Free> _Thread_Stack_Free( the_thread ); 10c49b: 89 1c 24 mov %ebx,(%esp) 10c49e: e8 81 05 00 00 call 10ca24 <_Thread_Stack_Free> return false; 10c4a3: 83 c4 10 add $0x10,%esp stack = the_thread->Start.stack; #else if ( !stack_area ) { actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); if ( !actual_stack_size || actual_stack_size < stack_size ) return false; /* stack allocation failed */ 10c4a6: 31 c0 xor %eax,%eax _Workspace_Free( sched ); _Thread_Stack_Free( the_thread ); return false; } 10c4a8: 8d 65 f4 lea -0xc(%ebp),%esp 10c4ab: 5b pop %ebx 10c4ac: 5e pop %esi 10c4ad: 5f pop %edi 10c4ae: c9 leave 10c4af: c3 ret =============================================================================== 0010f6dc <_Thread_Resume>: */ void _Thread_Resume( Thread_Control *the_thread, bool force ) { 10f6dc: 55 push %ebp 10f6dd: 89 e5 mov %esp,%ebp 10f6df: 53 push %ebx 10f6e0: 83 ec 04 sub $0x4,%esp 10f6e3: 8b 45 08 mov 0x8(%ebp),%eax ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10f6e6: 9c pushf 10f6e7: fa cli 10f6e8: 5b pop %ebx current_state = the_thread->current_state; 10f6e9: 8b 50 10 mov 0x10(%eax),%edx if ( current_state & STATES_SUSPENDED ) { 10f6ec: f6 c2 02 test $0x2,%dl 10f6ef: 74 17 je 10f708 <_Thread_Resume+0x2c> <== NEVER TAKEN 10f6f1: 83 e2 fd and $0xfffffffd,%edx current_state = the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); 10f6f4: 89 50 10 mov %edx,0x10(%eax) if ( _States_Is_ready( current_state ) ) { 10f6f7: 85 d2 test %edx,%edx 10f6f9: 75 0d jne 10f708 <_Thread_Resume+0x2c> */ RTEMS_INLINE_ROUTINE void _Scheduler_Unblock( Thread_Control *the_thread ) { _Scheduler.Operations.unblock( the_thread ); 10f6fb: 83 ec 0c sub $0xc,%esp 10f6fe: 50 push %eax 10f6ff: ff 15 64 41 12 00 call *0x124164 10f705: 83 c4 10 add $0x10,%esp _Scheduler_Unblock( the_thread ); } } _ISR_Enable( level ); 10f708: 53 push %ebx 10f709: 9d popf } 10f70a: 8b 5d fc mov -0x4(%ebp),%ebx 10f70d: c9 leave 10f70e: c3 ret =============================================================================== 0010cb0c <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10cb0c: 55 push %ebp 10cb0d: 89 e5 mov %esp,%ebp 10cb0f: 53 push %ebx 10cb10: 83 ec 04 sub $0x4,%esp Thread_Control *executing; executing = _Thread_Executing; 10cb13: 8b 1d 68 58 12 00 mov 0x125868,%ebx /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10cb19: 80 7b 74 00 cmpb $0x0,0x74(%ebx) 10cb1d: 74 4d je 10cb6c <_Thread_Tickle_timeslice+0x60> return; if ( !_States_Is_ready( executing->current_state ) ) 10cb1f: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10cb23: 75 47 jne 10cb6c <_Thread_Tickle_timeslice+0x60> /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10cb25: 8b 43 7c mov 0x7c(%ebx),%eax 10cb28: 83 f8 01 cmp $0x1,%eax 10cb2b: 72 3f jb 10cb6c <_Thread_Tickle_timeslice+0x60> 10cb2d: 83 f8 02 cmp $0x2,%eax 10cb30: 76 07 jbe 10cb39 <_Thread_Tickle_timeslice+0x2d> 10cb32: 83 f8 03 cmp $0x3,%eax 10cb35: 75 35 jne 10cb6c <_Thread_Tickle_timeslice+0x60><== NEVER TAKEN 10cb37: eb 1b jmp 10cb54 <_Thread_Tickle_timeslice+0x48> case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: #if defined(RTEMS_SCORE_THREAD_ENABLE_EXHAUST_TIMESLICE) case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: #endif if ( (int)(--executing->cpu_time_budget) <= 0 ) { 10cb39: 8b 43 78 mov 0x78(%ebx),%eax 10cb3c: 48 dec %eax 10cb3d: 89 43 78 mov %eax,0x78(%ebx) 10cb40: 85 c0 test %eax,%eax 10cb42: 7f 28 jg 10cb6c <_Thread_Tickle_timeslice+0x60> * always operates on the scheduler that 'owns' the currently executing * thread. */ RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void ) { _Scheduler.Operations.yield(); 10cb44: ff 15 5c 11 12 00 call *0x12115c * executing thread's timeslice is reset. Otherwise, the * currently executing thread is placed at the rear of the * FIFO for this priority and a new heir is selected. */ _Scheduler_Yield( ); executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10cb4a: a1 10 53 12 00 mov 0x125310,%eax 10cb4f: 89 43 78 mov %eax,0x78(%ebx) 10cb52: eb 18 jmp 10cb6c <_Thread_Tickle_timeslice+0x60> } break; #if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 10cb54: 8b 43 78 mov 0x78(%ebx),%eax 10cb57: 48 dec %eax 10cb58: 89 43 78 mov %eax,0x78(%ebx) 10cb5b: 85 c0 test %eax,%eax 10cb5d: 75 0d jne 10cb6c <_Thread_Tickle_timeslice+0x60> (*executing->budget_callout)( executing ); 10cb5f: 83 ec 0c sub $0xc,%esp 10cb62: 53 push %ebx 10cb63: ff 93 80 00 00 00 call *0x80(%ebx) 10cb69: 83 c4 10 add $0x10,%esp break; #endif } } 10cb6c: 8b 5d fc mov -0x4(%ebp),%ebx 10cb6f: c9 leave 10cb70: c3 ret =============================================================================== 0010c8cc <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10c8cc: 55 push %ebp 10c8cd: 89 e5 mov %esp,%ebp 10c8cf: 57 push %edi 10c8d0: 56 push %esi 10c8d1: 53 push %ebx 10c8d2: 83 ec 1c sub $0x1c,%esp 10c8d5: 8b 75 08 mov 0x8(%ebp),%esi 10c8d8: 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 ) 10c8db: 85 f6 test %esi,%esi 10c8dd: 74 36 je 10c915 <_Thread_queue_Requeue+0x49><== 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 ) { 10c8df: 83 7e 34 01 cmpl $0x1,0x34(%esi) 10c8e3: 75 30 jne 10c915 <_Thread_queue_Requeue+0x49><== NEVER TAKEN Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10c8e5: 9c pushf 10c8e6: fa cli 10c8e7: 5b pop %ebx if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10c8e8: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi) 10c8ef: 74 22 je 10c913 <_Thread_queue_Requeue+0x47><== NEVER TAKEN 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; 10c8f1: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, true ); 10c8f8: 50 push %eax 10c8f9: 6a 01 push $0x1 10c8fb: 57 push %edi 10c8fc: 56 push %esi 10c8fd: e8 12 31 00 00 call 10fa14 <_Thread_queue_Extract_priority_helper> (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10c902: 83 c4 0c add $0xc,%esp 10c905: 8d 45 e4 lea -0x1c(%ebp),%eax 10c908: 50 push %eax 10c909: 57 push %edi 10c90a: 56 push %esi 10c90b: e8 c0 fd ff ff call 10c6d0 <_Thread_queue_Enqueue_priority> 10c910: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10c913: 53 push %ebx 10c914: 9d popf } } 10c915: 8d 65 f4 lea -0xc(%ebp),%esp 10c918: 5b pop %ebx 10c919: 5e pop %esi 10c91a: 5f pop %edi 10c91b: c9 leave 10c91c: c3 ret =============================================================================== 0010c920 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) { 10c920: 55 push %ebp 10c921: 89 e5 mov %esp,%ebp 10c923: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10c926: 8d 45 f4 lea -0xc(%ebp),%eax 10c929: 50 push %eax 10c92a: ff 75 08 pushl 0x8(%ebp) 10c92d: e8 ea f8 ff ff call 10c21c <_Thread_Get> switch ( location ) { 10c932: 83 c4 10 add $0x10,%esp 10c935: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10c939: 75 17 jne 10c952 <_Thread_queue_Timeout+0x32><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10c93b: 83 ec 0c sub $0xc,%esp 10c93e: 50 push %eax 10c93f: e8 88 31 00 00 call 10facc <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10c944: a1 40 53 12 00 mov 0x125340,%eax 10c949: 48 dec %eax 10c94a: a3 40 53 12 00 mov %eax,0x125340 10c94f: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10c952: c9 leave 10c953: c3 ret =============================================================================== 00116a64 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 116a64: 55 push %ebp 116a65: 89 e5 mov %esp,%ebp 116a67: 57 push %edi 116a68: 56 push %esi 116a69: 53 push %ebx 116a6a: 83 ec 4c sub $0x4c,%esp 116a6d: 8b 5d 08 mov 0x8(%ebp),%ebx ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 116a70: 8d 55 dc lea -0x24(%ebp),%edx 116a73: 8d 45 e0 lea -0x20(%ebp),%eax 116a76: 89 45 dc mov %eax,-0x24(%ebp) head->previous = NULL; 116a79: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) tail->previous = head; 116a80: 89 55 e4 mov %edx,-0x1c(%ebp) ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 116a83: 8d 7d d0 lea -0x30(%ebp),%edi 116a86: 8d 4d d4 lea -0x2c(%ebp),%ecx 116a89: 89 4d d0 mov %ecx,-0x30(%ebp) head->previous = NULL; 116a8c: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) tail->previous = head; 116a93: 89 7d d8 mov %edi,-0x28(%ebp) */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 116a96: 8d 53 30 lea 0x30(%ebx),%edx 116a99: 89 55 c0 mov %edx,-0x40(%ebp) /* * 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 ); 116a9c: 8d 73 68 lea 0x68(%ebx),%esi */ RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail( const Chain_Control *the_chain ) { return &the_chain->Tail.Node; 116a9f: 89 45 b4 mov %eax,-0x4c(%ebp) Chain_Control *tmp; /* * Afterwards all timer inserts are directed to this chain and the interval * and TOD chains will be no more modified by other parties. */ ts->insert_chain = insert_chain; 116aa2: 8d 4d dc lea -0x24(%ebp),%ecx 116aa5: 89 4b 78 mov %ecx,0x78(%ebx) static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 116aa8: a1 e8 f1 13 00 mov 0x13f1e8,%eax /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 116aad: 8b 53 3c mov 0x3c(%ebx),%edx watchdogs->last_snapshot = snapshot; 116ab0: 89 43 3c mov %eax,0x3c(%ebx) _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 116ab3: 51 push %ecx 116ab4: 57 push %edi Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 116ab5: 29 d0 sub %edx,%eax watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 116ab7: 50 push %eax 116ab8: ff 75 c0 pushl -0x40(%ebp) 116abb: e8 d4 39 00 00 call 11a494 <_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(); 116ac0: a1 60 f1 13 00 mov 0x13f160,%eax 116ac5: 89 45 c4 mov %eax,-0x3c(%ebp) Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 116ac8: 8b 43 74 mov 0x74(%ebx),%eax /* * 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 ) { 116acb: 83 c4 10 add $0x10,%esp 116ace: 39 45 c4 cmp %eax,-0x3c(%ebp) 116ad1: 76 10 jbe 116ae3 <_Timer_server_Body+0x7f> /* * 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 ); 116ad3: 52 push %edx 116ad4: 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; 116ad5: 8b 55 c4 mov -0x3c(%ebp),%edx 116ad8: 29 c2 sub %eax,%edx _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 116ada: 52 push %edx 116adb: 56 push %esi 116adc: e8 b3 39 00 00 call 11a494 <_Watchdog_Adjust_to_chain> 116ae1: eb 0f jmp 116af2 <_Timer_server_Body+0x8e> } else if ( snapshot < last_snapshot ) { 116ae3: 73 10 jae 116af5 <_Timer_server_Body+0x91> /* * 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 ); 116ae5: 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; 116ae6: 2b 45 c4 sub -0x3c(%ebp),%eax _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 116ae9: 50 push %eax 116aea: 6a 01 push $0x1 116aec: 56 push %esi 116aed: e8 36 39 00 00 call 11a428 <_Watchdog_Adjust> 116af2: 83 c4 10 add $0x10,%esp } watchdogs->last_snapshot = snapshot; 116af5: 8b 4d c4 mov -0x3c(%ebp),%ecx 116af8: 89 4b 74 mov %ecx,0x74(%ebx) } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 116afb: 8b 43 78 mov 0x78(%ebx),%eax 116afe: 83 ec 0c sub $0xc,%esp 116b01: 50 push %eax 116b02: e8 fd 08 00 00 call 117404 <_Chain_Get> if ( timer == NULL ) { 116b07: 83 c4 10 add $0x10,%esp 116b0a: 85 c0 test %eax,%eax 116b0c: 74 29 je 116b37 <_Timer_server_Body+0xd3><== ALWAYS TAKEN static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 116b0e: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 116b11: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 116b14: 75 0b jne 116b21 <_Timer_server_Body+0xbd><== NOT EXECUTED _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116b16: 52 push %edx <== NOT EXECUTED 116b17: 52 push %edx <== NOT EXECUTED 116b18: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 116b1b: 50 push %eax <== NOT EXECUTED 116b1c: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED 116b1f: eb 0c jmp 116b2d <_Timer_server_Body+0xc9><== NOT EXECUTED } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116b21: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 116b24: 75 d5 jne 116afb <_Timer_server_Body+0x97><== NOT EXECUTED _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116b26: 51 push %ecx <== NOT EXECUTED 116b27: 51 push %ecx <== NOT EXECUTED 116b28: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 116b2b: 50 push %eax <== NOT EXECUTED 116b2c: 56 push %esi <== NOT EXECUTED 116b2d: e8 ea 39 00 00 call 11a51c <_Watchdog_Insert> <== NOT EXECUTED 116b32: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116b35: eb c4 jmp 116afb <_Timer_server_Body+0x97><== 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 ); 116b37: 9c pushf 116b38: fa cli 116b39: 5a pop %edx tmp = ts->insert_chain; 116b3a: 8b 43 78 mov 0x78(%ebx),%eax if ( _Chain_Is_empty( insert_chain ) ) { 116b3d: b0 01 mov $0x1,%al 116b3f: 8b 4d b4 mov -0x4c(%ebp),%ecx 116b42: 39 4d dc cmp %ecx,-0x24(%ebp) 116b45: 75 09 jne 116b50 <_Timer_server_Body+0xec><== NEVER TAKEN ts->insert_chain = NULL; 116b47: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx) do_loop = false; 116b4e: 31 c0 xor %eax,%eax } _ISR_Enable( level ); 116b50: 52 push %edx 116b51: 9d popf * Afterwards all timer inserts are directed to this chain and the interval * and TOD chains will be no more modified by other parties. */ ts->insert_chain = insert_chain; while ( do_loop ) { 116b52: 84 c0 test %al,%al 116b54: 0f 85 4e ff ff ff jne 116aa8 <_Timer_server_Body+0x44><== NEVER TAKEN 116b5a: 8d 45 d4 lea -0x2c(%ebp),%eax _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 ) ) { 116b5d: 39 45 d0 cmp %eax,-0x30(%ebp) 116b60: 74 3a je 116b9c <_Timer_server_Body+0x138> 116b62: 89 45 b0 mov %eax,-0x50(%ebp) /* * It is essential that interrupts are disable here since an interrupt * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); 116b65: 9c pushf 116b66: fa cli 116b67: 59 pop %ecx initialized = false; } #endif return status; } 116b68: 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)) 116b6b: 3b 45 b0 cmp -0x50(%ebp),%eax 116b6e: 74 25 je 116b95 <_Timer_server_Body+0x131> Chain_Control *the_chain ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *old_first = head->next; Chain_Node *new_first = old_first->next; 116b70: 8b 10 mov (%eax),%edx head->next = new_first; 116b72: 89 55 d0 mov %edx,-0x30(%ebp) new_first->previous = head; 116b75: 89 7a 04 mov %edi,0x4(%edx) * It is essential that interrupts are disable here since an interrupt * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { 116b78: 85 c0 test %eax,%eax 116b7a: 74 19 je 116b95 <_Timer_server_Body+0x131><== NEVER TAKEN watchdog->state = WATCHDOG_INACTIVE; 116b7c: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) _ISR_Enable( level ); 116b83: 51 push %ecx 116b84: 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 ); 116b85: 52 push %edx 116b86: 52 push %edx 116b87: ff 70 24 pushl 0x24(%eax) 116b8a: ff 70 20 pushl 0x20(%eax) 116b8d: ff 50 1c call *0x1c(%eax) } 116b90: 83 c4 10 add $0x10,%esp 116b93: eb d0 jmp 116b65 <_Timer_server_Body+0x101> watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; _ISR_Enable( level ); } else { _ISR_Enable( level ); 116b95: 51 push %ecx 116b96: 9d popf 116b97: e9 06 ff ff ff jmp 116aa2 <_Timer_server_Body+0x3e> * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); } } else { ts->active = false; 116b9c: c6 43 7c 00 movb $0x0,0x7c(%ebx) /* * Block until there is something to do. */ _Thread_Disable_dispatch(); 116ba0: e8 23 fe ff ff call 1169c8 <_Thread_Disable_dispatch> _Thread_Set_state( ts->thread, STATES_DELAYING ); 116ba5: 51 push %ecx 116ba6: 51 push %ecx 116ba7: 6a 08 push $0x8 116ba9: ff 33 pushl (%ebx) 116bab: e8 18 33 00 00 call 119ec8 <_Thread_Set_state> _Timer_server_Reset_interval_system_watchdog( ts ); 116bb0: 89 d8 mov %ebx,%eax 116bb2: e8 21 fe ff ff call 1169d8 <_Timer_server_Reset_interval_system_watchdog> _Timer_server_Reset_tod_system_watchdog( ts ); 116bb7: 89 d8 mov %ebx,%eax 116bb9: e8 60 fe ff ff call 116a1e <_Timer_server_Reset_tod_system_watchdog> _Thread_Enable_dispatch(); 116bbe: e8 db 2a 00 00 call 11969e <_Thread_Enable_dispatch> ts->active = true; 116bc3: 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 ); 116bc7: 8d 43 08 lea 0x8(%ebx),%eax 116bca: 89 04 24 mov %eax,(%esp) 116bcd: e8 6a 3a 00 00 call 11a63c <_Watchdog_Remove> static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 116bd2: 8d 43 40 lea 0x40(%ebx),%eax 116bd5: 89 04 24 mov %eax,(%esp) 116bd8: e8 5f 3a 00 00 call 11a63c <_Watchdog_Remove> 116bdd: 83 c4 10 add $0x10,%esp 116be0: e9 bd fe ff ff jmp 116aa2 <_Timer_server_Body+0x3e> =============================================================================== 00116be5 <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 116be5: 55 push %ebp 116be6: 89 e5 mov %esp,%ebp 116be8: 57 push %edi 116be9: 56 push %esi 116bea: 53 push %ebx 116beb: 83 ec 2c sub $0x2c,%esp 116bee: 8b 5d 08 mov 0x8(%ebp),%ebx 116bf1: 8b 75 0c mov 0xc(%ebp),%esi if ( ts->insert_chain == NULL ) { 116bf4: 8b 43 78 mov 0x78(%ebx),%eax 116bf7: 85 c0 test %eax,%eax 116bf9: 0f 85 de 00 00 00 jne 116cdd <_Timer_server_Schedule_operation_method+0xf8><== NEVER TAKEN * is the reference point for the delta chain. Thus if we do not update the * reference point we have to add DT to the initial delta of the watchdog * being inserted. This could result in an integer overflow. */ _Thread_Disable_dispatch(); 116bff: e8 c4 fd ff ff call 1169c8 <_Thread_Disable_dispatch> if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 116c04: 8b 46 38 mov 0x38(%esi),%eax 116c07: 83 f8 01 cmp $0x1,%eax 116c0a: 75 5a jne 116c66 <_Timer_server_Schedule_operation_method+0x81> /* * We have to advance the last known ticks value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 116c0c: 9c pushf 116c0d: fa cli 116c0e: 8f 45 e0 popl -0x20(%ebp) snapshot = _Watchdog_Ticks_since_boot; 116c11: 8b 15 e8 f1 13 00 mov 0x13f1e8,%edx last_snapshot = ts->Interval_watchdogs.last_snapshot; 116c17: 8b 4b 3c mov 0x3c(%ebx),%ecx initialized = false; } #endif return status; } 116c1a: 8b 43 30 mov 0x30(%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 ); 116c1d: 8d 7b 34 lea 0x34(%ebx),%edi * 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 ) ) { 116c20: 39 f8 cmp %edi,%eax 116c22: 74 19 je 116c3d <_Timer_server_Schedule_operation_method+0x58> first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain ); /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; 116c24: 89 d7 mov %edx,%edi 116c26: 29 cf sub %ecx,%edi 116c28: 89 7d e4 mov %edi,-0x1c(%ebp) delta_interval = first_watchdog->delta_interval; 116c2b: 8b 78 10 mov 0x10(%eax),%edi if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 116c2e: 31 c9 xor %ecx,%ecx * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; delta_interval = first_watchdog->delta_interval; if (delta_interval > delta) { 116c30: 3b 7d e4 cmp -0x1c(%ebp),%edi 116c33: 76 05 jbe 116c3a <_Timer_server_Schedule_operation_method+0x55> delta_interval -= delta; 116c35: 89 f9 mov %edi,%ecx 116c37: 2b 4d e4 sub -0x1c(%ebp),%ecx } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 116c3a: 89 48 10 mov %ecx,0x10(%eax) } ts->Interval_watchdogs.last_snapshot = snapshot; 116c3d: 89 53 3c mov %edx,0x3c(%ebx) _ISR_Enable( level ); 116c40: ff 75 e0 pushl -0x20(%ebp) 116c43: 9d popf _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116c44: 50 push %eax 116c45: 50 push %eax 116c46: 83 c6 10 add $0x10,%esi 116c49: 56 push %esi 116c4a: 8d 43 30 lea 0x30(%ebx),%eax 116c4d: 50 push %eax 116c4e: e8 c9 38 00 00 call 11a51c <_Watchdog_Insert> if ( !ts->active ) { 116c53: 8a 43 7c mov 0x7c(%ebx),%al 116c56: 83 c4 10 add $0x10,%esp 116c59: 84 c0 test %al,%al 116c5b: 75 74 jne 116cd1 <_Timer_server_Schedule_operation_method+0xec> _Timer_server_Reset_interval_system_watchdog( ts ); 116c5d: 89 d8 mov %ebx,%eax 116c5f: e8 74 fd ff ff call 1169d8 <_Timer_server_Reset_interval_system_watchdog> 116c64: eb 6b jmp 116cd1 <_Timer_server_Schedule_operation_method+0xec> } } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116c66: 83 f8 03 cmp $0x3,%eax 116c69: 75 66 jne 116cd1 <_Timer_server_Schedule_operation_method+0xec> /* * We have to advance the last known seconds value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 116c6b: 9c pushf 116c6c: fa cli 116c6d: 8f 45 e0 popl -0x20(%ebp) snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 116c70: 8b 15 60 f1 13 00 mov 0x13f160,%edx last_snapshot = ts->TOD_watchdogs.last_snapshot; 116c76: 8b 43 74 mov 0x74(%ebx),%eax initialized = false; } #endif return status; } 116c79: 8b 4b 68 mov 0x68(%ebx),%ecx 116c7c: 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 ) ) { 116c7f: 39 f9 cmp %edi,%ecx 116c81: 74 27 je 116caa <_Timer_server_Schedule_operation_method+0xc5> first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 116c83: 8b 79 10 mov 0x10(%ecx),%edi 116c86: 89 7d d4 mov %edi,-0x2c(%ebp) if ( snapshot > last_snapshot ) { 116c89: 39 c2 cmp %eax,%edx 116c8b: 76 15 jbe 116ca2 <_Timer_server_Schedule_operation_method+0xbd> /* * We advanced in time. */ delta = snapshot - last_snapshot; 116c8d: 89 d7 mov %edx,%edi 116c8f: 29 c7 sub %eax,%edi 116c91: 89 7d e4 mov %edi,-0x1c(%ebp) if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 116c94: 31 c0 xor %eax,%eax if ( snapshot > last_snapshot ) { /* * We advanced in time. */ delta = snapshot - last_snapshot; if (delta_interval > delta) { 116c96: 39 7d d4 cmp %edi,-0x2c(%ebp) 116c99: 76 0c jbe 116ca7 <_Timer_server_Schedule_operation_method+0xc2><== NEVER TAKEN delta_interval -= delta; 116c9b: 8b 45 d4 mov -0x2c(%ebp),%eax 116c9e: 29 f8 sub %edi,%eax 116ca0: eb 05 jmp 116ca7 <_Timer_server_Schedule_operation_method+0xc2> } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 116ca2: 03 45 d4 add -0x2c(%ebp),%eax delta_interval += delta; 116ca5: 29 d0 sub %edx,%eax } first_watchdog->delta_interval = delta_interval; 116ca7: 89 41 10 mov %eax,0x10(%ecx) } ts->TOD_watchdogs.last_snapshot = snapshot; 116caa: 89 53 74 mov %edx,0x74(%ebx) _ISR_Enable( level ); 116cad: ff 75 e0 pushl -0x20(%ebp) 116cb0: 9d popf _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116cb1: 57 push %edi 116cb2: 57 push %edi 116cb3: 83 c6 10 add $0x10,%esi 116cb6: 56 push %esi 116cb7: 8d 43 68 lea 0x68(%ebx),%eax 116cba: 50 push %eax 116cbb: e8 5c 38 00 00 call 11a51c <_Watchdog_Insert> if ( !ts->active ) { 116cc0: 8a 43 7c mov 0x7c(%ebx),%al 116cc3: 83 c4 10 add $0x10,%esp 116cc6: 84 c0 test %al,%al 116cc8: 75 07 jne 116cd1 <_Timer_server_Schedule_operation_method+0xec> _Timer_server_Reset_tod_system_watchdog( ts ); 116cca: 89 d8 mov %ebx,%eax 116ccc: e8 4d fd ff ff call 116a1e <_Timer_server_Reset_tod_system_watchdog> * 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 ); } } 116cd1: 8d 65 f4 lea -0xc(%ebp),%esp 116cd4: 5b pop %ebx 116cd5: 5e pop %esi 116cd6: 5f pop %edi 116cd7: c9 leave if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 116cd8: e9 c1 29 00 00 jmp 11969e <_Thread_Enable_dispatch> * 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 ); 116cdd: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 116ce0: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 116ce3: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } } 116ce6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116ce9: 5b pop %ebx <== NOT EXECUTED 116cea: 5e pop %esi <== NOT EXECUTED 116ceb: 5f pop %edi <== NOT EXECUTED 116cec: 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 ); 116ced: e9 d6 06 00 00 jmp 1173c8 <_Chain_Append> <== NOT EXECUTED =============================================================================== 0010ccef <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10ccef: 55 push %ebp 10ccf0: 89 e5 mov %esp,%ebp 10ccf2: 57 push %edi 10ccf3: 56 push %esi 10ccf4: 53 push %ebx 10ccf5: 83 ec 0c sub $0xc,%esp 10ccf8: 8b 7d 10 mov 0x10(%ebp),%edi the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 10ccfb: 8b 1d 14 55 12 00 mov 0x125514,%ebx 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 ); 10cd01: 0f b6 75 0c movzbl 0xc(%ebp),%esi ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10cd05: eb 15 jmp 10cd1c <_User_extensions_Fatal+0x2d> !_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 ) 10cd07: 8b 43 30 mov 0x30(%ebx),%eax 10cd0a: 85 c0 test %eax,%eax 10cd0c: 74 0b je 10cd19 <_User_extensions_Fatal+0x2a> (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10cd0e: 52 push %edx 10cd0f: 57 push %edi 10cd10: 56 push %esi 10cd11: ff 75 08 pushl 0x8(%ebp) 10cd14: ff d0 call *%eax 10cd16: 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 ) { 10cd19: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10cd1c: 81 fb 0c 55 12 00 cmp $0x12550c,%ebx 10cd22: 75 e3 jne 10cd07 <_User_extensions_Fatal+0x18><== 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 ); } } 10cd24: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cd27: 5b pop %ebx <== NOT EXECUTED 10cd28: 5e pop %esi <== NOT EXECUTED 10cd29: 5f pop %edi <== NOT EXECUTED 10cd2a: c9 leave <== NOT EXECUTED 10cd2b: c3 ret <== NOT EXECUTED =============================================================================== 0010cbd8 <_User_extensions_Handler_initialization>: #include #include #include void _User_extensions_Handler_initialization(void) { 10cbd8: 55 push %ebp 10cbd9: 89 e5 mov %esp,%ebp 10cbdb: 57 push %edi 10cbdc: 56 push %esi 10cbdd: 53 push %ebx 10cbde: 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; 10cbe1: a1 60 12 12 00 mov 0x121260,%eax 10cbe6: 89 45 e4 mov %eax,-0x1c(%ebp) initial_extensions = Configuration.User_extension_table; 10cbe9: 8b 35 64 12 12 00 mov 0x121264,%esi ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10cbef: c7 05 0c 55 12 00 10 movl $0x125510,0x12550c 10cbf6: 55 12 00 head->previous = NULL; 10cbf9: c7 05 10 55 12 00 00 movl $0x0,0x125510 10cc00: 00 00 00 tail->previous = head; 10cc03: c7 05 14 55 12 00 0c movl $0x12550c,0x125514 10cc0a: 55 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10cc0d: c7 05 44 53 12 00 48 movl $0x125348,0x125344 10cc14: 53 12 00 head->previous = NULL; 10cc17: c7 05 48 53 12 00 00 movl $0x0,0x125348 10cc1e: 00 00 00 tail->previous = head; 10cc21: c7 05 4c 53 12 00 44 movl $0x125344,0x12534c 10cc28: 53 12 00 _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10cc2b: 85 f6 test %esi,%esi 10cc2d: 74 53 je 10cc82 <_User_extensions_Handler_initialization+0xaa><== NEVER TAKEN extension = (User_extensions_Control *) _Workspace_Allocate_or_fatal_error( 10cc2f: 6b c8 34 imul $0x34,%eax,%ecx 10cc32: 83 ec 0c sub $0xc,%esp 10cc35: 51 push %ecx 10cc36: 89 4d e0 mov %ecx,-0x20(%ebp) 10cc39: e8 3d 04 00 00 call 10d07b <_Workspace_Allocate_or_fatal_error> 10cc3e: 89 c3 mov %eax,%ebx number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10cc40: 31 c0 xor %eax,%eax 10cc42: 8b 4d e0 mov -0x20(%ebp),%ecx 10cc45: 89 df mov %ebx,%edi 10cc47: f3 aa rep stos %al,%es:(%edi) 10cc49: 89 f0 mov %esi,%eax extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10cc4b: 83 c4 10 add $0x10,%esp 10cc4e: 31 d2 xor %edx,%edx 10cc50: eb 2b jmp 10cc7d <_User_extensions_Handler_initialization+0xa5> RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table( User_extensions_Control *extension, const User_extensions_Table *extension_table ) { extension->Callouts = *extension_table; 10cc52: 8d 7b 14 lea 0x14(%ebx),%edi 10cc55: 89 c6 mov %eax,%esi 10cc57: b9 08 00 00 00 mov $0x8,%ecx 10cc5c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _User_extensions_Add_set( extension ); 10cc5e: 83 ec 0c sub $0xc,%esp 10cc61: 53 push %ebx 10cc62: 89 45 dc mov %eax,-0x24(%ebp) 10cc65: 89 55 e0 mov %edx,-0x20(%ebp) 10cc68: e8 47 2f 00 00 call 10fbb4 <_User_extensions_Add_set> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; 10cc6d: 83 c3 34 add $0x34,%ebx extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10cc70: 8b 55 e0 mov -0x20(%ebp),%edx 10cc73: 42 inc %edx 10cc74: 8b 45 dc mov -0x24(%ebp),%eax 10cc77: 83 c0 20 add $0x20,%eax 10cc7a: 83 c4 10 add $0x10,%esp 10cc7d: 3b 55 e4 cmp -0x1c(%ebp),%edx 10cc80: 72 d0 jb 10cc52 <_User_extensions_Handler_initialization+0x7a> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; } } } 10cc82: 8d 65 f4 lea -0xc(%ebp),%esp 10cc85: 5b pop %ebx 10cc86: 5e pop %esi 10cc87: 5f pop %edi 10cc88: c9 leave 10cc89: c3 ret =============================================================================== 0010e54c <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10e54c: 55 push %ebp 10e54d: 89 e5 mov %esp,%ebp 10e54f: 57 push %edi 10e550: 56 push %esi 10e551: 53 push %ebx 10e552: 83 ec 1c sub $0x1c,%esp 10e555: 8b 75 08 mov 0x8(%ebp),%esi 10e558: 8b 7d 0c mov 0xc(%ebp),%edi 10e55b: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 10e55e: 9c pushf 10e55f: fa cli 10e560: 58 pop %eax } } _ISR_Enable( level ); } 10e561: 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 ); 10e563: 8d 4e 04 lea 0x4(%esi),%ecx * hence the compiler must not assume *header to remain * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { 10e566: 39 ca cmp %ecx,%edx 10e568: 74 44 je 10e5ae <_Watchdog_Adjust+0x62> switch ( direction ) { 10e56a: 85 ff test %edi,%edi 10e56c: 74 3c je 10e5aa <_Watchdog_Adjust+0x5e> 10e56e: 4f dec %edi 10e56f: 75 3d jne 10e5ae <_Watchdog_Adjust+0x62> <== NEVER TAKEN case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10e571: 01 5a 10 add %ebx,0x10(%edx) break; 10e574: eb 38 jmp 10e5ae <_Watchdog_Adjust+0x62> RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First( Chain_Control *header ) { return ( (Watchdog_Control *) _Chain_First( header ) ); 10e576: 8b 16 mov (%esi),%edx case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 10e578: 8b 7a 10 mov 0x10(%edx),%edi 10e57b: 39 fb cmp %edi,%ebx 10e57d: 73 07 jae 10e586 <_Watchdog_Adjust+0x3a> _Watchdog_First( header )->delta_interval -= units; 10e57f: 29 df sub %ebx,%edi 10e581: 89 7a 10 mov %edi,0x10(%edx) break; 10e584: eb 28 jmp 10e5ae <_Watchdog_Adjust+0x62> } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 10e586: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx) _ISR_Enable( level ); 10e58d: 50 push %eax 10e58e: 9d popf _Watchdog_Tickle( header ); 10e58f: 83 ec 0c sub $0xc,%esp 10e592: 56 push %esi 10e593: 89 4d e4 mov %ecx,-0x1c(%ebp) 10e596: e8 a5 01 00 00 call 10e740 <_Watchdog_Tickle> _ISR_Disable( level ); 10e59b: 9c pushf 10e59c: fa cli 10e59d: 58 pop %eax if ( _Chain_Is_empty( header ) ) 10e59e: 83 c4 10 add $0x10,%esp 10e5a1: 8b 4d e4 mov -0x1c(%ebp),%ecx 10e5a4: 39 0e cmp %ecx,(%esi) 10e5a6: 74 06 je 10e5ae <_Watchdog_Adjust+0x62> while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; 10e5a8: 29 fb sub %edi,%ebx switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10e5aa: 85 db test %ebx,%ebx 10e5ac: 75 c8 jne 10e576 <_Watchdog_Adjust+0x2a> <== ALWAYS TAKEN } break; } } _ISR_Enable( level ); 10e5ae: 50 push %eax 10e5af: 9d popf } 10e5b0: 8d 65 f4 lea -0xc(%ebp),%esp 10e5b3: 5b pop %ebx 10e5b4: 5e pop %esi 10e5b5: 5f pop %edi 10e5b6: c9 leave 10e5b7: c3 ret =============================================================================== 0010cf30 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10cf30: 55 push %ebp 10cf31: 89 e5 mov %esp,%ebp 10cf33: 56 push %esi 10cf34: 53 push %ebx 10cf35: 8b 55 08 mov 0x8(%ebp),%edx ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10cf38: 9c pushf 10cf39: fa cli 10cf3a: 5e pop %esi previous_state = the_watchdog->state; 10cf3b: 8b 42 08 mov 0x8(%edx),%eax switch ( previous_state ) { 10cf3e: 83 f8 01 cmp $0x1,%eax 10cf41: 74 09 je 10cf4c <_Watchdog_Remove+0x1c> 10cf43: 72 42 jb 10cf87 <_Watchdog_Remove+0x57> 10cf45: 83 f8 03 cmp $0x3,%eax 10cf48: 77 3d ja 10cf87 <_Watchdog_Remove+0x57> <== NEVER TAKEN 10cf4a: eb 09 jmp 10cf55 <_Watchdog_Remove+0x25> /* * 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; 10cf4c: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) break; 10cf53: eb 32 jmp 10cf87 <_Watchdog_Remove+0x57> case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10cf55: 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 ); } 10cf5c: 8b 0a mov (%edx),%ecx case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 10cf5e: 83 39 00 cmpl $0x0,(%ecx) 10cf61: 74 06 je 10cf69 <_Watchdog_Remove+0x39> next_watchdog->delta_interval += the_watchdog->delta_interval; 10cf63: 8b 5a 10 mov 0x10(%edx),%ebx 10cf66: 01 59 10 add %ebx,0x10(%ecx) if ( _Watchdog_Sync_count ) 10cf69: 8b 1d 50 54 12 00 mov 0x125450,%ebx 10cf6f: 85 db test %ebx,%ebx 10cf71: 74 0c je 10cf7f <_Watchdog_Remove+0x4f> _Watchdog_Sync_level = _ISR_Nest_level; 10cf73: 8b 1d 64 58 12 00 mov 0x125864,%ebx 10cf79: 89 1d e8 53 12 00 mov %ebx,0x1253e8 { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 10cf7f: 8b 5a 04 mov 0x4(%edx),%ebx next->previous = previous; 10cf82: 89 59 04 mov %ebx,0x4(%ecx) previous->next = next; 10cf85: 89 0b mov %ecx,(%ebx) _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10cf87: 8b 0d 54 54 12 00 mov 0x125454,%ecx 10cf8d: 89 4a 18 mov %ecx,0x18(%edx) _ISR_Enable( level ); 10cf90: 56 push %esi 10cf91: 9d popf return( previous_state ); } 10cf92: 5b pop %ebx 10cf93: 5e pop %esi 10cf94: c9 leave 10cf95: c3 ret =============================================================================== 0010e0bc <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) { 10e0bc: 55 push %ebp 10e0bd: 89 e5 mov %esp,%ebp 10e0bf: 57 push %edi 10e0c0: 56 push %esi 10e0c1: 53 push %ebx 10e0c2: 83 ec 20 sub $0x20,%esp 10e0c5: 8b 7d 08 mov 0x8(%ebp),%edi 10e0c8: 8b 75 0c mov 0xc(%ebp),%esi ISR_Level level; Chain_Node *node; _ISR_Disable( level ); 10e0cb: 9c pushf 10e0cc: fa cli 10e0cd: 8f 45 e4 popl -0x1c(%ebp) printk( "Watchdog Chain: %s %p\n", name, header ); 10e0d0: 56 push %esi 10e0d1: 57 push %edi 10e0d2: 68 9c 18 12 00 push $0x12189c 10e0d7: e8 50 aa ff ff call 108b2c printk( "== end of %s \n", name ); } else { printk( "Chain is empty\n" ); } _ISR_Enable( level ); } 10e0dc: 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 ); 10e0de: 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 ) ) { 10e0e1: 83 c4 10 add $0x10,%esp 10e0e4: 39 f3 cmp %esi,%ebx 10e0e6: 74 1d je 10e105 <_Watchdog_Report_chain+0x49> node != _Chain_Tail(header) ; node = node->next ) { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); 10e0e8: 52 push %edx 10e0e9: 52 push %edx 10e0ea: 53 push %ebx 10e0eb: 6a 00 push $0x0 10e0ed: e8 32 00 00 00 call 10e124 <_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 ) 10e0f2: 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 ) ; 10e0f4: 83 c4 10 add $0x10,%esp 10e0f7: 39 f3 cmp %esi,%ebx 10e0f9: 75 ed jne 10e0e8 <_Watchdog_Report_chain+0x2c><== NEVER TAKEN { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); 10e0fb: 50 push %eax 10e0fc: 50 push %eax 10e0fd: 57 push %edi 10e0fe: 68 b3 18 12 00 push $0x1218b3 10e103: eb 08 jmp 10e10d <_Watchdog_Report_chain+0x51> } else { printk( "Chain is empty\n" ); 10e105: 83 ec 0c sub $0xc,%esp 10e108: 68 c2 18 12 00 push $0x1218c2 10e10d: e8 1a aa ff ff call 108b2c 10e112: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10e115: ff 75 e4 pushl -0x1c(%ebp) 10e118: 9d popf } 10e119: 8d 65 f4 lea -0xc(%ebp),%esp 10e11c: 5b pop %ebx 10e11d: 5e pop %esi 10e11e: 5f pop %edi 10e11f: c9 leave 10e120: c3 ret =============================================================================== 0010b21c <_rename_r>: int _rename_r( struct _reent *ptr __attribute__((unused)), const char *old, const char *new ) { 10b21c: 55 push %ebp 10b21d: 89 e5 mov %esp,%ebp 10b21f: 57 push %edi 10b220: 56 push %esi 10b221: 53 push %ebx 10b222: 83 ec 78 sub $0x78,%esp /* * Get the parent node of the old path to be renamed. Find the parent path. */ old_parent_pathlen = rtems_filesystem_dirname ( old ); 10b225: ff 75 0c pushl 0xc(%ebp) 10b228: e8 3a ed ff ff call 109f67 10b22d: 89 45 94 mov %eax,-0x6c(%ebp) if ( old_parent_pathlen == 0 ) 10b230: 83 c4 10 add $0x10,%esp 10b233: 85 c0 test %eax,%eax 10b235: 8d 45 b8 lea -0x48(%ebp),%eax 10b238: 75 15 jne 10b24f <_rename_r+0x33> rtems_filesystem_get_start_loc( old, &i, &old_parent_loc ); 10b23a: 51 push %ecx 10b23b: 50 push %eax 10b23c: 8d 45 e4 lea -0x1c(%ebp),%eax 10b23f: 50 push %eax 10b240: ff 75 0c pushl 0xc(%ebp) 10b243: e8 48 03 00 00 call 10b590 10b248: 83 c4 10 add $0x10,%esp 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; 10b24b: 31 db xor %ebx,%ebx 10b24d: eb 23 jmp 10b272 <_rename_r+0x56> 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, 10b24f: 83 ec 0c sub $0xc,%esp 10b252: 6a 00 push $0x0 10b254: 50 push %eax 10b255: 6a 02 push $0x2 10b257: ff 75 94 pushl -0x6c(%ebp) 10b25a: ff 75 0c pushl 0xc(%ebp) 10b25d: e8 c4 ec ff ff call 109f26 RTEMS_LIBIO_PERMS_WRITE, &old_parent_loc, false ); if ( result != 0 ) 10b262: 83 c4 20 add $0x20,%esp return -1; 10b265: 83 cf ff or $0xffffffff,%edi else { result = rtems_filesystem_evaluate_path( old, old_parent_pathlen, RTEMS_LIBIO_PERMS_WRITE, &old_parent_loc, false ); if ( result != 0 ) 10b268: 85 c0 test %eax,%eax 10b26a: 0f 85 50 01 00 00 jne 10b3c0 <_rename_r+0x1a4> <== NEVER TAKEN return -1; free_old_parentloc = true; 10b270: b3 01 mov $0x1,%bl /* * Start from the parent to find the node that should be under it. */ old_loc = old_parent_loc; 10b272: 8d 7d cc lea -0x34(%ebp),%edi 10b275: 8d 75 b8 lea -0x48(%ebp),%esi 10b278: b9 05 00 00 00 mov $0x5,%ecx 10b27d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) name = old + old_parent_pathlen; 10b27f: 8b 75 0c mov 0xc(%ebp),%esi 10b282: 03 75 94 add -0x6c(%ebp),%esi 10b285: 89 75 e0 mov %esi,-0x20(%ebp) name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 10b288: 83 c9 ff or $0xffffffff,%ecx 10b28b: 89 f7 mov %esi,%edi 10b28d: 31 c0 xor %eax,%eax 10b28f: f2 ae repnz scas %es:(%edi),%al 10b291: f7 d1 not %ecx 10b293: 49 dec %ecx 10b294: 52 push %edx 10b295: 52 push %edx 10b296: 51 push %ecx 10b297: 56 push %esi 10b298: e8 09 ed ff ff call 109fa6 10b29d: 01 c6 add %eax,%esi 10b29f: 89 75 e0 mov %esi,-0x20(%ebp) result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 10b2a2: 83 c9 ff or $0xffffffff,%ecx 10b2a5: 89 f7 mov %esi,%edi 10b2a7: 31 c0 xor %eax,%eax 10b2a9: f2 ae repnz scas %es:(%edi),%al 10b2ab: f7 d1 not %ecx 10b2ad: 49 dec %ecx 10b2ae: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10b2b5: 8d 7d cc lea -0x34(%ebp),%edi 10b2b8: 57 push %edi 10b2b9: 6a 00 push $0x0 10b2bb: 51 push %ecx 10b2bc: 56 push %esi 10b2bd: e8 06 ec ff ff call 109ec8 0, &old_loc, false ); if ( result != 0 ) { 10b2c2: 83 c4 20 add $0x20,%esp 10b2c5: 85 c0 test %eax,%eax 10b2c7: 74 16 je 10b2df <_rename_r+0xc3> if ( free_old_parentloc ) rtems_filesystem_freenode( &old_parent_loc ); return -1; 10b2c9: 83 cf ff or $0xffffffff,%edi 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 ) 10b2cc: 84 db test %bl,%bl 10b2ce: 0f 84 ec 00 00 00 je 10b3c0 <_rename_r+0x1a4> <== NEVER TAKEN rtems_filesystem_freenode( &old_parent_loc ); 10b2d4: 83 ec 0c sub $0xc,%esp 10b2d7: 8d 45 b8 lea -0x48(%ebp),%eax 10b2da: e9 d8 00 00 00 jmp 10b3b7 <_rename_r+0x19b> /* * Get the parent of the new node we are renaming to. */ rtems_filesystem_get_start_loc( new, &i, &new_parent_loc ); 10b2df: 50 push %eax 10b2e0: 8d 75 a4 lea -0x5c(%ebp),%esi 10b2e3: 56 push %esi 10b2e4: 8d 45 e4 lea -0x1c(%ebp),%eax 10b2e7: 50 push %eax 10b2e8: ff 75 10 pushl 0x10(%ebp) 10b2eb: e8 a0 02 00 00 call 10b590 result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name ); 10b2f0: 83 c4 0c add $0xc,%esp 10b2f3: 8d 45 e0 lea -0x20(%ebp),%eax 10b2f6: 50 push %eax 10b2f7: 56 push %esi 10b2f8: 8b 45 10 mov 0x10(%ebp),%eax 10b2fb: 03 45 e4 add -0x1c(%ebp),%eax 10b2fe: 50 push %eax 10b2ff: 8b 45 b0 mov -0x50(%ebp),%eax 10b302: ff 50 04 call *0x4(%eax) if ( result != 0 ) { 10b305: 83 c4 10 add $0x10,%esp 10b308: 85 c0 test %eax,%eax 10b30a: 74 2d je 10b339 <_rename_r+0x11d> rtems_filesystem_freenode( &new_parent_loc ); 10b30c: 83 ec 0c sub $0xc,%esp 10b30f: 56 push %esi 10b310: e8 1f ee ff ff call 10a134 if ( free_old_parentloc ) 10b315: 83 c4 10 add $0x10,%esp 10b318: 84 db test %bl,%bl 10b31a: 74 0f je 10b32b <_rename_r+0x10f> <== NEVER TAKEN rtems_filesystem_freenode( &old_parent_loc ); 10b31c: 83 ec 0c sub $0xc,%esp 10b31f: 8d 45 b8 lea -0x48(%ebp),%eax 10b322: 50 push %eax 10b323: e8 0c ee ff ff call 10a134 10b328: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &old_loc ); 10b32b: 83 ec 0c sub $0xc,%esp 10b32e: 8d 45 cc lea -0x34(%ebp),%eax 10b331: 50 push %eax 10b332: e8 fd ed ff ff call 10a134 10b337: eb 3e jmp 10b377 <_rename_r+0x15b> /* * 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 ) { 10b339: 8b 45 b4 mov -0x4c(%ebp),%eax 10b33c: 39 45 c8 cmp %eax,-0x38(%ebp) 10b33f: 74 3e je 10b37f <_rename_r+0x163> rtems_filesystem_freenode( &new_parent_loc ); 10b341: 83 ec 0c sub $0xc,%esp 10b344: 56 push %esi 10b345: e8 ea ed ff ff call 10a134 if ( free_old_parentloc ) 10b34a: 83 c4 10 add $0x10,%esp 10b34d: 84 db test %bl,%bl 10b34f: 74 0f je 10b360 <_rename_r+0x144> rtems_filesystem_freenode( &old_parent_loc ); 10b351: 83 ec 0c sub $0xc,%esp 10b354: 8d 45 b8 lea -0x48(%ebp),%eax 10b357: 50 push %eax 10b358: e8 d7 ed ff ff call 10a134 10b35d: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &old_loc ); 10b360: 83 ec 0c sub $0xc,%esp 10b363: 8d 45 cc lea -0x34(%ebp),%eax 10b366: 50 push %eax 10b367: e8 c8 ed ff ff call 10a134 rtems_set_errno_and_return_minus_one( EXDEV ); 10b36c: e8 5f 95 00 00 call 1148d0 <__errno> 10b371: c7 00 12 00 00 00 movl $0x12,(%eax) 10b377: 83 c4 10 add $0x10,%esp 10b37a: 83 cf ff or $0xffffffff,%edi 10b37d: eb 41 jmp 10b3c0 <_rename_r+0x1a4> } result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name ); 10b37f: ff 75 e0 pushl -0x20(%ebp) 10b382: 56 push %esi 10b383: 57 push %edi 10b384: 8d 55 b8 lea -0x48(%ebp),%edx 10b387: 52 push %edx 10b388: 8b 45 b0 mov -0x50(%ebp),%eax 10b38b: 89 55 90 mov %edx,-0x70(%ebp) 10b38e: ff 50 40 call *0x40(%eax) 10b391: 89 c7 mov %eax,%edi rtems_filesystem_freenode( &new_parent_loc ); 10b393: 89 34 24 mov %esi,(%esp) 10b396: e8 99 ed ff ff call 10a134 if ( free_old_parentloc ) 10b39b: 83 c4 10 add $0x10,%esp 10b39e: 84 db test %bl,%bl 10b3a0: 8b 55 90 mov -0x70(%ebp),%edx 10b3a3: 74 0c je 10b3b1 <_rename_r+0x195> rtems_filesystem_freenode( &old_parent_loc ); 10b3a5: 83 ec 0c sub $0xc,%esp 10b3a8: 52 push %edx 10b3a9: e8 86 ed ff ff call 10a134 10b3ae: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &old_loc ); 10b3b1: 83 ec 0c sub $0xc,%esp 10b3b4: 8d 45 cc lea -0x34(%ebp),%eax 10b3b7: 50 push %eax 10b3b8: e8 77 ed ff ff call 10a134 return result; 10b3bd: 83 c4 10 add $0x10,%esp } 10b3c0: 89 f8 mov %edi,%eax 10b3c2: 8d 65 f4 lea -0xc(%ebp),%esp 10b3c5: 5b pop %ebx 10b3c6: 5e pop %esi 10b3c7: 5f pop %edi 10b3c8: c9 leave 10b3c9: c3 ret =============================================================================== 0010a818 : * operation(s) cannot be canceled */ int aio_cancel(int fildes, struct aiocb *aiocbp) { 10a818: 55 push %ebp 10a819: 89 e5 mov %esp,%ebp 10a81b: 57 push %edi 10a81c: 56 push %esi 10a81d: 53 push %ebx 10a81e: 83 ec 18 sub $0x18,%esp 10a821: 8b 75 08 mov 0x8(%ebp),%esi 10a824: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request_chain *r_chain; int result; pthread_mutex_lock (&aio_request_queue.mutex); 10a827: 68 d8 72 12 00 push $0x1272d8 10a82c: e8 2f 10 00 00 call 10b860 if (fcntl (fildes, F_GETFD) < 0) { 10a831: 5f pop %edi 10a832: 58 pop %eax 10a833: 6a 01 push $0x1 10a835: 56 push %esi 10a836: e8 f1 60 00 00 call 11092c 10a83b: 83 c4 10 add $0x10,%esp 10a83e: 85 c0 test %eax,%eax 10a840: 79 1d jns 10a85f pthread_mutex_unlock(&aio_request_queue.mutex); 10a842: 83 ec 0c sub $0xc,%esp 10a845: 68 d8 72 12 00 push $0x1272d8 10a84a: e8 91 10 00 00 call 10b8e0 rtems_set_errno_and_return_minus_one (EBADF); 10a84f: e8 94 8e 00 00 call 1136e8 <__errno> 10a854: c7 00 09 00 00 00 movl $0x9,(%eax) 10a85a: e9 e3 00 00 00 jmp 10a942 } /* if aiocbp is NULL remove all request for given file descriptor */ if (aiocbp == NULL) { 10a85f: 85 db test %ebx,%ebx 10a861: 0f 85 bd 00 00 00 jne 10a924 AIO_printf ("Cancel all requests\n"); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); 10a867: 51 push %ecx 10a868: 6a 00 push $0x0 10a86a: 56 push %esi 10a86b: 68 20 73 12 00 push $0x127320 10a870: e8 27 03 00 00 call 10ab9c 10a875: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 10a877: 83 c4 10 add $0x10,%esp 10a87a: 85 c0 test %eax,%eax 10a87c: 75 6c jne 10a8ea AIO_printf ("Request chain not on [WQ]\n"); if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10a87e: 81 3d 2c 73 12 00 30 cmpl $0x127330,0x12732c 10a885: 73 12 00 10a888: 0f 84 07 01 00 00 je 10a995 <== NEVER TAKEN r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 10a88e: 52 push %edx 10a88f: 6a 00 push $0x0 10a891: 56 push %esi 10a892: 68 2c 73 12 00 push $0x12732c 10a897: e8 00 03 00 00 call 10ab9c 10a89c: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 10a89e: 83 c4 10 add $0x10,%esp 10a8a1: 85 c0 test %eax,%eax 10a8a3: 75 17 jne 10a8bc pthread_mutex_unlock(&aio_request_queue.mutex); 10a8a5: 83 ec 0c sub $0xc,%esp 10a8a8: 68 d8 72 12 00 push $0x1272d8 10a8ad: e8 2e 10 00 00 call 10b8e0 return AIO_ALLDONE; 10a8b2: 83 c4 10 add $0x10,%esp 10a8b5: b3 02 mov $0x2,%bl 10a8b7: e9 21 01 00 00 jmp 10a9dd */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10a8bc: 83 ec 0c sub $0xc,%esp 10a8bf: 50 push %eax 10a8c0: e8 fb 26 00 00 call 10cfc0 <_Chain_Extract> } AIO_printf ("Request chain on [IQ]\n"); rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10a8c5: 89 1c 24 mov %ebx,(%esp) 10a8c8: e8 12 06 00 00 call 10aedf pthread_mutex_destroy (&r_chain->mutex); 10a8cd: 8d 73 1c lea 0x1c(%ebx),%esi 10a8d0: 89 34 24 mov %esi,(%esp) 10a8d3: e8 68 0d 00 00 call 10b640 pthread_cond_destroy (&r_chain->mutex); 10a8d8: 89 34 24 mov %esi,(%esp) 10a8db: e8 6c 0a 00 00 call 10b34c free (r_chain); 10a8e0: 89 1c 24 mov %ebx,(%esp) 10a8e3: e8 88 d4 ff ff call 107d70 10a8e8: eb 24 jmp 10a90e return AIO_ALLDONE; } AIO_printf ("Request chain on [WQ]\n"); pthread_mutex_lock (&r_chain->mutex); 10a8ea: 8d 70 1c lea 0x1c(%eax),%esi 10a8ed: 83 ec 0c sub $0xc,%esp 10a8f0: 56 push %esi 10a8f1: e8 6a 0f 00 00 call 10b860 10a8f6: 89 1c 24 mov %ebx,(%esp) 10a8f9: e8 c2 26 00 00 call 10cfc0 <_Chain_Extract> rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10a8fe: 89 1c 24 mov %ebx,(%esp) 10a901: e8 d9 05 00 00 call 10aedf pthread_mutex_unlock (&r_chain->mutex); 10a906: 89 34 24 mov %esi,(%esp) 10a909: e8 d2 0f 00 00 call 10b8e0 pthread_mutex_unlock (&aio_request_queue.mutex); 10a90e: c7 04 24 d8 72 12 00 movl $0x1272d8,(%esp) 10a915: e8 c6 0f 00 00 call 10b8e0 return AIO_CANCELED; 10a91a: 83 c4 10 add $0x10,%esp 10a91d: 31 db xor %ebx,%ebx 10a91f: e9 b9 00 00 00 jmp 10a9dd } else { AIO_printf ("Cancel request\n"); if (aiocbp->aio_fildes != fildes) { 10a924: 8b 3b mov (%ebx),%edi 10a926: 39 f7 cmp %esi,%edi 10a928: 74 23 je 10a94d pthread_mutex_unlock (&aio_request_queue.mutex); 10a92a: 83 ec 0c sub $0xc,%esp 10a92d: 68 d8 72 12 00 push $0x1272d8 10a932: e8 a9 0f 00 00 call 10b8e0 rtems_set_errno_and_return_minus_one (EINVAL); 10a937: e8 ac 8d 00 00 call 1136e8 <__errno> 10a93c: c7 00 16 00 00 00 movl $0x16,(%eax) 10a942: 83 c4 10 add $0x10,%esp 10a945: 83 cb ff or $0xffffffff,%ebx 10a948: e9 90 00 00 00 jmp 10a9dd } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); 10a94d: 50 push %eax 10a94e: 6a 00 push $0x0 10a950: 57 push %edi 10a951: 68 20 73 12 00 push $0x127320 10a956: e8 41 02 00 00 call 10ab9c 10a95b: 89 c6 mov %eax,%esi if (r_chain == NULL) { 10a95d: 83 c4 10 add $0x10,%esp 10a960: 85 c0 test %eax,%eax 10a962: 75 48 jne 10a9ac if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10a964: 81 3d 2c 73 12 00 30 cmpl $0x127330,0x12732c 10a96b: 73 12 00 10a96e: 74 25 je 10a995 <== NEVER TAKEN r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 10a970: 56 push %esi 10a971: 6a 00 push $0x0 10a973: 57 push %edi 10a974: 68 2c 73 12 00 push $0x12732c 10a979: e8 1e 02 00 00 call 10ab9c if (r_chain == NULL) { 10a97e: 83 c4 10 add $0x10,%esp 10a981: 85 c0 test %eax,%eax 10a983: 74 a5 je 10a92a rtems_set_errno_and_return_minus_one (EINVAL); } AIO_printf ("Request on [IQ]\n"); result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 10a985: 51 push %ecx 10a986: 51 push %ecx 10a987: 53 push %ebx 10a988: 83 c0 08 add $0x8,%eax 10a98b: 50 push %eax 10a98c: e8 97 05 00 00 call 10af28 10a991: 89 c3 mov %eax,%ebx 10a993: eb 39 jmp 10a9ce pthread_mutex_unlock (&aio_request_queue.mutex); return result; } else { pthread_mutex_unlock (&aio_request_queue.mutex); 10a995: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a998: 68 d8 72 12 00 push $0x1272d8 <== NOT EXECUTED 10a99d: e8 3e 0f 00 00 call 10b8e0 <== NOT EXECUTED return AIO_ALLDONE; 10a9a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a9a5: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED 10a9aa: eb 31 jmp 10a9dd <== NOT EXECUTED } } AIO_printf ("Request on [WQ]\n"); pthread_mutex_lock (&r_chain->mutex); 10a9ac: 8d 78 1c lea 0x1c(%eax),%edi 10a9af: 83 ec 0c sub $0xc,%esp 10a9b2: 57 push %edi 10a9b3: e8 a8 0e 00 00 call 10b860 result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 10a9b8: 58 pop %eax 10a9b9: 5a pop %edx 10a9ba: 53 push %ebx 10a9bb: 83 c6 08 add $0x8,%esi 10a9be: 56 push %esi 10a9bf: e8 64 05 00 00 call 10af28 10a9c4: 89 c3 mov %eax,%ebx pthread_mutex_unlock (&r_chain->mutex); 10a9c6: 89 3c 24 mov %edi,(%esp) 10a9c9: e8 12 0f 00 00 call 10b8e0 pthread_mutex_unlock (&aio_request_queue.mutex); 10a9ce: c7 04 24 d8 72 12 00 movl $0x1272d8,(%esp) 10a9d5: e8 06 0f 00 00 call 10b8e0 return result; 10a9da: 83 c4 10 add $0x10,%esp } return AIO_ALLDONE; } 10a9dd: 89 d8 mov %ebx,%eax 10a9df: 8d 65 f4 lea -0xc(%ebp),%esp 10a9e2: 5b pop %ebx 10a9e3: 5e pop %esi 10a9e4: 5f pop %edi 10a9e5: c9 leave 10a9e6: c3 ret =============================================================================== 0010a9f4 : int aio_fsync( int op, struct aiocb *aiocbp ) { 10a9f4: 55 push %ebp 10a9f5: 89 e5 mov %esp,%ebp 10a9f7: 53 push %ebx 10a9f8: 83 ec 04 sub $0x4,%esp 10a9fb: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request *req; int mode; if (op != O_SYNC) 10a9fe: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp) 10aa05: 74 1b je 10aa22 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10aa07: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10aa0e: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10aa15: e8 ce 8c 00 00 call 1136e8 <__errno> 10aa1a: c7 00 16 00 00 00 movl $0x16,(%eax) 10aa20: eb 74 jmp 10aa96 mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10aa22: 50 push %eax 10aa23: 50 push %eax 10aa24: 6a 03 push $0x3 10aa26: ff 33 pushl (%ebx) 10aa28: e8 ff 5e 00 00 call 11092c if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10aa2d: 83 e0 03 and $0x3,%eax 10aa30: 48 dec %eax 10aa31: 83 c4 10 add $0x10,%esp 10aa34: 83 f8 01 cmp $0x1,%eax 10aa37: 76 1b jbe 10aa54 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10aa39: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10aa40: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10aa47: e8 9c 8c 00 00 call 1136e8 <__errno> 10aa4c: c7 00 09 00 00 00 movl $0x9,(%eax) 10aa52: eb 42 jmp 10aa96 req = malloc (sizeof (rtems_aio_request)); 10aa54: 83 ec 0c sub $0xc,%esp 10aa57: 6a 18 push $0x18 10aa59: e8 96 d7 ff ff call 1081f4 if (req == NULL) 10aa5e: 83 c4 10 add $0x10,%esp 10aa61: 85 c0 test %eax,%eax 10aa63: 75 1b jne 10aa80 <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10aa65: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10aa6c: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10aa73: e8 70 8c 00 00 call 1136e8 <__errno> <== NOT EXECUTED 10aa78: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10aa7e: eb 16 jmp 10aa96 <== NOT EXECUTED req->aiocbp = aiocbp; 10aa80: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_SYNC; 10aa83: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx) return rtems_aio_enqueue (req); 10aa8a: 89 45 08 mov %eax,0x8(%ebp) } 10aa8d: 8b 5d fc mov -0x4(%ebp),%ebx 10aa90: c9 leave rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_SYNC; return rtems_aio_enqueue (req); 10aa91: e9 ef 04 00 00 jmp 10af85 } 10aa96: 83 c8 ff or $0xffffffff,%eax 10aa99: 8b 5d fc mov -0x4(%ebp),%ebx 10aa9c: c9 leave 10aa9d: c3 ret =============================================================================== 0010b188 : * 0 - otherwise */ int aio_read (struct aiocb *aiocbp) { 10b188: 55 push %ebp 10b189: 89 e5 mov %esp,%ebp 10b18b: 53 push %ebx 10b18c: 83 ec 0c sub $0xc,%esp 10b18f: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10b192: 6a 03 push $0x3 10b194: ff 33 pushl (%ebx) 10b196: e8 91 57 00 00 call 11092c if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10b19b: 83 e0 03 and $0x3,%eax 10b19e: 83 c4 10 add $0x10,%esp 10b1a1: 83 f8 02 cmp $0x2,%eax 10b1a4: 74 1f je 10b1c5 10b1a6: 85 c0 test %eax,%eax 10b1a8: 74 1b je 10b1c5 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10b1aa: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10b1b1: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b1b8: e8 2b 85 00 00 call 1136e8 <__errno> 10b1bd: c7 00 09 00 00 00 movl $0x9,(%eax) 10b1c3: eb 69 jmp 10b22e if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10b1c5: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10b1c9: 75 06 jne 10b1d1 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10b1cb: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10b1cf: 79 1b jns 10b1ec rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10b1d1: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10b1d8: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b1df: e8 04 85 00 00 call 1136e8 <__errno> 10b1e4: c7 00 16 00 00 00 movl $0x16,(%eax) 10b1ea: eb 42 jmp 10b22e req = malloc (sizeof (rtems_aio_request)); 10b1ec: 83 ec 0c sub $0xc,%esp 10b1ef: 6a 18 push $0x18 10b1f1: e8 fe cf ff ff call 1081f4 if (req == NULL) 10b1f6: 83 c4 10 add $0x10,%esp 10b1f9: 85 c0 test %eax,%eax 10b1fb: 75 1b jne 10b218 <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10b1fd: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10b204: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10b20b: e8 d8 84 00 00 call 1136e8 <__errno> <== NOT EXECUTED 10b210: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10b216: eb 16 jmp 10b22e <== NOT EXECUTED req->aiocbp = aiocbp; 10b218: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_READ; 10b21b: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx) return rtems_aio_enqueue (req); 10b222: 89 45 08 mov %eax,0x8(%ebp) } 10b225: 8b 5d fc mov -0x4(%ebp),%ebx 10b228: c9 leave rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_READ; return rtems_aio_enqueue (req); 10b229: e9 57 fd ff ff jmp 10af85 } 10b22e: 83 c8 ff or $0xffffffff,%eax 10b231: 8b 5d fc mov -0x4(%ebp),%ebx 10b234: c9 leave 10b235: c3 ret =============================================================================== 0010b244 : * 0 - otherwise */ int aio_write (struct aiocb *aiocbp) { 10b244: 55 push %ebp 10b245: 89 e5 mov %esp,%ebp 10b247: 53 push %ebx 10b248: 83 ec 0c sub $0xc,%esp 10b24b: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10b24e: 6a 03 push $0x3 10b250: ff 33 pushl (%ebx) 10b252: e8 d5 56 00 00 call 11092c if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10b257: 83 e0 03 and $0x3,%eax 10b25a: 48 dec %eax 10b25b: 83 c4 10 add $0x10,%esp 10b25e: 83 f8 01 cmp $0x1,%eax 10b261: 76 1b jbe 10b27e rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10b263: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10b26a: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b271: e8 72 84 00 00 call 1136e8 <__errno> 10b276: c7 00 09 00 00 00 movl $0x9,(%eax) 10b27c: eb 69 jmp 10b2e7 if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10b27e: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10b282: 75 06 jne 10b28a rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10b284: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10b288: 79 1b jns 10b2a5 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10b28a: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10b291: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b298: e8 4b 84 00 00 call 1136e8 <__errno> 10b29d: c7 00 16 00 00 00 movl $0x16,(%eax) 10b2a3: eb 42 jmp 10b2e7 req = malloc (sizeof (rtems_aio_request)); 10b2a5: 83 ec 0c sub $0xc,%esp 10b2a8: 6a 18 push $0x18 10b2aa: e8 45 cf ff ff call 1081f4 if (req == NULL) 10b2af: 83 c4 10 add $0x10,%esp 10b2b2: 85 c0 test %eax,%eax 10b2b4: 75 1b jne 10b2d1 <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10b2b6: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10b2bd: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10b2c4: e8 1f 84 00 00 call 1136e8 <__errno> <== NOT EXECUTED 10b2c9: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10b2cf: eb 16 jmp 10b2e7 <== NOT EXECUTED req->aiocbp = aiocbp; 10b2d1: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_WRITE; 10b2d4: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx) return rtems_aio_enqueue (req); 10b2db: 89 45 08 mov %eax,0x8(%ebp) } 10b2de: 8b 5d fc mov -0x4(%ebp),%ebx 10b2e1: c9 leave rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_WRITE; return rtems_aio_enqueue (req); 10b2e2: e9 9e fc ff ff jmp 10af85 } 10b2e7: 83 c8 ff or $0xffffffff,%eax 10b2ea: 8b 5d fc mov -0x4(%ebp),%ebx 10b2ed: c9 leave 10b2ee: c3 ret =============================================================================== 00107548 : #include int chroot( const char *pathname ) { 107548: 55 push %ebp 107549: 89 e5 mov %esp,%ebp 10754b: 57 push %edi 10754c: 56 push %esi 10754d: 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) { 107550: 81 3d 6c 30 12 00 48 cmpl $0x125248,0x12306c 107557: 52 12 00 10755a: 75 1e jne 10757a rtems_libio_set_private_env(); /* try to set a new private env*/ 10755c: e8 f0 10 00 00 call 108651 if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 107561: 81 3d 6c 30 12 00 48 cmpl $0x125248,0x12306c 107568: 52 12 00 10756b: 75 0d jne 10757a rtems_set_errno_and_return_minus_one( ENOTSUP ); 10756d: e8 8e a3 00 00 call 111900 <__errno> 107572: c7 00 86 00 00 00 movl $0x86,(%eax) 107578: eb 22 jmp 10759c } result = chdir(pathname); 10757a: 83 ec 0c sub $0xc,%esp 10757d: ff 75 08 pushl 0x8(%ebp) 107580: e8 b7 74 00 00 call 10ea3c if (result) { 107585: 83 c4 10 add $0x10,%esp 107588: 85 c0 test %eax,%eax 10758a: 74 15 je 1075a1 rtems_set_errno_and_return_minus_one( errno ); 10758c: e8 6f a3 00 00 call 111900 <__errno> 107591: 89 c6 mov %eax,%esi 107593: e8 68 a3 00 00 call 111900 <__errno> 107598: 8b 00 mov (%eax),%eax 10759a: 89 06 mov %eax,(%esi) 10759c: 83 c8 ff or $0xffffffff,%eax 10759f: eb 44 jmp 1075e5 } /* clone the new root location */ if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) { 1075a1: 83 ec 0c sub $0xc,%esp 1075a4: 6a 00 push $0x0 1075a6: 8d 75 e4 lea -0x1c(%ebp),%esi 1075a9: 56 push %esi 1075aa: 6a 00 push $0x0 1075ac: 6a 01 push $0x1 1075ae: 68 ea fc 11 00 push $0x11fcea 1075b3: e8 02 01 00 00 call 1076ba 1075b8: 83 c4 20 add $0x20,%esp 1075bb: 85 c0 test %eax,%eax 1075bd: 75 cd jne 10758c <== 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); 1075bf: 83 ec 0c sub $0xc,%esp 1075c2: a1 6c 30 12 00 mov 0x12306c,%eax 1075c7: 83 c0 18 add $0x18,%eax 1075ca: 50 push %eax 1075cb: e8 a8 01 00 00 call 107778 rtems_filesystem_root = loc; 1075d0: 8b 3d 6c 30 12 00 mov 0x12306c,%edi 1075d6: 83 c7 18 add $0x18,%edi 1075d9: b9 05 00 00 00 mov $0x5,%ecx 1075de: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return 0; 1075e0: 83 c4 10 add $0x10,%esp 1075e3: 31 c0 xor %eax,%eax } 1075e5: 8d 65 f8 lea -0x8(%ebp),%esp 1075e8: 5e pop %esi 1075e9: 5f pop %edi 1075ea: c9 leave 1075eb: c3 ret =============================================================================== 00109fec : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 109fec: 55 push %ebp 109fed: 89 e5 mov %esp,%ebp 109fef: 83 ec 08 sub $0x8,%esp 109ff2: 8b 45 08 mov 0x8(%ebp),%eax 109ff5: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 109ff8: 85 d2 test %edx,%edx 109ffa: 74 3c je 10a038 rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 109ffc: 83 f8 01 cmp $0x1,%eax 109fff: 75 0b jne 10a00c _TOD_Get(tp); 10a001: 83 ec 0c sub $0xc,%esp 10a004: 52 push %edx 10a005: e8 a6 1b 00 00 call 10bbb0 <_TOD_Get> 10a00a: eb 13 jmp 10a01f return 0; } #ifdef CLOCK_MONOTONIC if ( clock_id == CLOCK_MONOTONIC ) { 10a00c: 83 f8 04 cmp $0x4,%eax 10a00f: 74 05 je 10a016 <== NEVER TAKEN return 0; } #endif #ifdef _POSIX_CPUTIME if ( clock_id == CLOCK_PROCESS_CPUTIME ) { 10a011: 83 f8 02 cmp $0x2,%eax 10a014: 75 10 jne 10a026 _TOD_Get_uptime_as_timespec( tp ); 10a016: 83 ec 0c sub $0xc,%esp 10a019: 52 push %edx 10a01a: e8 e5 1b 00 00 call 10bc04 <_TOD_Get_uptime_as_timespec> return 0; 10a01f: 83 c4 10 add $0x10,%esp 10a022: 31 c0 xor %eax,%eax 10a024: eb 20 jmp 10a046 } #endif #ifdef _POSIX_THREAD_CPUTIME if ( clock_id == CLOCK_THREAD_CPUTIME ) 10a026: 83 f8 03 cmp $0x3,%eax 10a029: 75 0d jne 10a038 rtems_set_errno_and_return_minus_one( ENOSYS ); 10a02b: e8 9c 7f 00 00 call 111fcc <__errno> 10a030: c7 00 58 00 00 00 movl $0x58,(%eax) 10a036: eb 0b jmp 10a043 #endif rtems_set_errno_and_return_minus_one( EINVAL ); 10a038: e8 8f 7f 00 00 call 111fcc <__errno> 10a03d: c7 00 16 00 00 00 movl $0x16,(%eax) 10a043: 83 c8 ff or $0xffffffff,%eax return 0; } 10a046: c9 leave 10a047: c3 ret =============================================================================== 0010a048 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 10a048: 55 push %ebp 10a049: 89 e5 mov %esp,%ebp 10a04b: 83 ec 08 sub $0x8,%esp 10a04e: 8b 45 08 mov 0x8(%ebp),%eax 10a051: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 10a054: 85 d2 test %edx,%edx 10a056: 74 44 je 10a09c <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 10a058: 83 f8 01 cmp $0x1,%eax 10a05b: 75 28 jne 10a085 if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 10a05d: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx) 10a063: 76 37 jbe 10a09c rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a065: a1 a0 73 12 00 mov 0x1273a0,%eax 10a06a: 40 inc %eax 10a06b: a3 a0 73 12 00 mov %eax,0x1273a0 rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); 10a070: 83 ec 0c sub $0xc,%esp 10a073: 52 push %edx 10a074: e8 e3 1b 00 00 call 10bc5c <_TOD_Set> _Thread_Enable_dispatch(); 10a079: e8 38 2f 00 00 call 10cfb6 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; 10a07e: 83 c4 10 add $0x10,%esp 10a081: 31 c0 xor %eax,%eax 10a083: eb 25 jmp 10a0aa _Thread_Disable_dispatch(); _TOD_Set( tp ); _Thread_Enable_dispatch(); } #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 10a085: 83 f8 02 cmp $0x2,%eax 10a088: 74 05 je 10a08f rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 10a08a: 83 f8 03 cmp $0x3,%eax 10a08d: 75 0d jne 10a09c rtems_set_errno_and_return_minus_one( ENOSYS ); 10a08f: e8 38 7f 00 00 call 111fcc <__errno> 10a094: c7 00 58 00 00 00 movl $0x58,(%eax) 10a09a: eb 0b jmp 10a0a7 #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 10a09c: e8 2b 7f 00 00 call 111fcc <__errno> 10a0a1: c7 00 16 00 00 00 movl $0x16,(%eax) 10a0a7: 83 c8 ff or $0xffffffff,%eax return 0; } 10a0aa: c9 leave 10a0ab: c3 ret =============================================================================== 0010d4d0 : const char *pathname, size_t pathnamelen, int flags, rtems_filesystem_location_info_t *pathloc ) { 10d4d0: 55 push %ebp 10d4d1: 89 e5 mov %esp,%ebp 10d4d3: 57 push %edi 10d4d4: 56 push %esi 10d4d5: 53 push %ebx 10d4d6: 83 ec 1c sub $0x1c,%esp 10d4d9: 8b 4d 0c mov 0xc(%ebp),%ecx 10d4dc: 8b 5d 14 mov 0x14(%ebp),%ebx int i; rtems_device_name_t *device_name_table; /* see if 'flags' is valid */ if ( !rtems_libio_is_valid_perms( flags ) ) 10d4df: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp) 10d4e6: 74 0d je 10d4f5 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EPERM ); 10d4e8: e8 53 22 00 00 call 10f740 <__errno> <== NOT EXECUTED 10d4ed: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10d4f3: eb 77 jmp 10d56c <== NOT EXECUTED /* get the device name table */ device_name_table = (rtems_device_name_t *)pathloc->node_access; 10d4f5: 8b 33 mov (%ebx),%esi if (!device_name_table) 10d4f7: 85 f6 test %esi,%esi 10d4f9: 74 04 je 10d4ff 10d4fb: 31 ff xor %edi,%edi 10d4fd: eb 5a jmp 10d559 rtems_set_errno_and_return_minus_one( EFAULT ); 10d4ff: e8 3c 22 00 00 call 10f740 <__errno> 10d504: c7 00 0e 00 00 00 movl $0xe,(%eax) 10d50a: eb 60 jmp 10d56c for (i = 0; i < rtems_device_table_size; i++) { if (!device_name_table[i].device_name) 10d50c: 8b 16 mov (%esi),%edx 10d50e: 85 d2 test %edx,%edx 10d510: 74 43 je 10d555 continue; if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0) 10d512: 50 push %eax 10d513: 51 push %ecx 10d514: 52 push %edx 10d515: ff 75 08 pushl 0x8(%ebp) 10d518: 89 55 e4 mov %edx,-0x1c(%ebp) 10d51b: 89 4d e0 mov %ecx,-0x20(%ebp) 10d51e: e8 f1 2e 00 00 call 110414 10d523: 83 c4 10 add $0x10,%esp 10d526: 85 c0 test %eax,%eax 10d528: 8b 55 e4 mov -0x1c(%ebp),%edx 10d52b: 8b 4d e0 mov -0x20(%ebp),%ecx 10d52e: 75 25 jne 10d555 continue; if (device_name_table[i].device_name[pathnamelen] != '\0') 10d530: 80 3c 0a 00 cmpb $0x0,(%edx,%ecx,1) 10d534: 75 1f jne 10d555 <== NEVER TAKEN continue; /* find the device, set proper values */ pathloc->node_access = (void *)&device_name_table[i]; 10d536: 89 33 mov %esi,(%ebx) pathloc->handlers = &devFS_file_handlers; 10d538: c7 43 08 ac 0f 12 00 movl $0x120fac,0x8(%ebx) pathloc->ops = &devFS_ops; 10d53f: c7 43 0c 64 0f 12 00 movl $0x120f64,0xc(%ebx) pathloc->mt_entry = rtems_filesystem_root.mt_entry; 10d546: a1 00 11 12 00 mov 0x121100,%eax 10d54b: 8b 40 28 mov 0x28(%eax),%eax 10d54e: 89 43 10 mov %eax,0x10(%ebx) return 0; 10d551: 31 c0 xor %eax,%eax 10d553: eb 1a jmp 10d56f /* 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++) { 10d555: 47 inc %edi 10d556: 83 c6 14 add $0x14,%esi 10d559: 3b 3d 48 f1 11 00 cmp 0x11f148,%edi 10d55f: 72 ab jb 10d50c pathloc->mt_entry = rtems_filesystem_root.mt_entry; return 0; } /* no such file or directory */ rtems_set_errno_and_return_minus_one( ENOENT ); 10d561: e8 da 21 00 00 call 10f740 <__errno> 10d566: c7 00 02 00 00 00 movl $0x2,(%eax) 10d56c: 83 c8 ff or $0xffffffff,%eax } 10d56f: 8d 65 f4 lea -0xc(%ebp),%esp 10d572: 5b pop %ebx 10d573: 5e pop %esi 10d574: 5f pop %edi 10d575: c9 leave 10d576: c3 ret =============================================================================== 00106c70 : const char *path, mode_t mode, dev_t dev, rtems_filesystem_location_info_t *pathloc ) { 106c70: 55 push %ebp 106c71: 89 e5 mov %esp,%ebp 106c73: 57 push %edi 106c74: 56 push %esi 106c75: 53 push %ebx 106c76: 83 ec 1c sub $0x1c,%esp 106c79: 8b 7d 08 mov 0x8(%ebp),%edi 106c7c: 8b 4d 10 mov 0x10(%ebp),%ecx 106c7f: 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') && 106c82: 80 3f 64 cmpb $0x64,(%edi) 106c85: 75 18 jne 106c9f 106c87: 80 7f 01 65 cmpb $0x65,0x1(%edi) 106c8b: 75 12 jne 106c9f <== NEVER TAKEN 106c8d: 80 7f 02 76 cmpb $0x76,0x2(%edi) 106c91: 75 0c jne 106c9f <== NEVER TAKEN (path[2] == 'v') && (path[3] == '\0')) return 0; 106c93: 31 c0 xor %eax,%eax * actually passed in is 'dev', not '/dev'. Just return 0 to * indicate we are OK. */ if ((path[0] == 'd') && (path[1] == 'e') && (path[2] == 'v') && (path[3] == '\0')) 106c95: 80 7f 03 00 cmpb $0x0,0x3(%edi) 106c99: 0f 84 c9 00 00 00 je 106d68 return 0; /* must be a character device or a block device */ if (!S_ISBLK(mode) && !S_ISCHR(mode)) 106c9f: 8b 45 0c mov 0xc(%ebp),%eax 106ca2: 25 00 f0 00 00 and $0xf000,%eax 106ca7: 3d 00 20 00 00 cmp $0x2000,%eax 106cac: 74 14 je 106cc2 106cae: 3d 00 60 00 00 cmp $0x6000,%eax 106cb3: 74 0d je 106cc2 rtems_set_errno_and_return_minus_one( EINVAL ); 106cb5: e8 86 8a 00 00 call 10f740 <__errno> 106cba: c7 00 16 00 00 00 movl $0x16,(%eax) 106cc0: eb 23 jmp 106ce5 ) { union __rtems_dev_t temp; temp.device = device; return temp.__overlay.major; 106cc2: 89 4d e4 mov %ecx,-0x1c(%ebp) dev_t device ) { union __rtems_dev_t temp; temp.device = device; 106cc5: 89 55 e0 mov %edx,-0x20(%ebp) 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; 106cc8: 8b 45 18 mov 0x18(%ebp),%eax 106ccb: 8b 08 mov (%eax),%ecx if (!device_name_table) 106ccd: 85 c9 test %ecx,%ecx 106ccf: 74 09 je 106cda 106cd1: 89 ca mov %ecx,%edx 106cd3: 83 ce ff or $0xffffffff,%esi 106cd6: 31 db xor %ebx,%ebx 106cd8: eb 46 jmp 106d20 rtems_set_errno_and_return_minus_one( EFAULT ); 106cda: e8 61 8a 00 00 call 10f740 <__errno> 106cdf: c7 00 0e 00 00 00 movl $0xe,(%eax) 106ce5: 83 c8 ff or $0xffffffff,%eax 106ce8: eb 7e jmp 106d68 for (slot = -1, i = 0; i < rtems_device_table_size; i++){ if (device_name_table[i].device_name == NULL) 106cea: 8b 02 mov (%edx),%eax 106cec: 85 c0 test %eax,%eax 106cee: 74 2a je 106d1a slot = i; else if (strcmp(path, device_name_table[i].device_name) == 0) 106cf0: 83 ec 08 sub $0x8,%esp 106cf3: 50 push %eax 106cf4: 57 push %edi 106cf5: 89 55 d8 mov %edx,-0x28(%ebp) 106cf8: 89 4d dc mov %ecx,-0x24(%ebp) 106cfb: e8 6c 96 00 00 call 11036c 106d00: 83 c4 10 add $0x10,%esp 106d03: 85 c0 test %eax,%eax 106d05: 8b 55 d8 mov -0x28(%ebp),%edx 106d08: 8b 4d dc mov -0x24(%ebp),%ecx 106d0b: 75 0f jne 106d1c rtems_set_errno_and_return_minus_one( EEXIST ); 106d0d: e8 2e 8a 00 00 call 10f740 <__errno> 106d12: c7 00 11 00 00 00 movl $0x11,(%eax) 106d18: eb cb jmp 106ce5 if (!device_name_table) rtems_set_errno_and_return_minus_one( EFAULT ); for (slot = -1, i = 0; i < rtems_device_table_size; i++){ if (device_name_table[i].device_name == NULL) slot = i; 106d1a: 89 de mov %ebx,%esi /* 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++){ 106d1c: 43 inc %ebx 106d1d: 83 c2 14 add $0x14,%edx 106d20: 3b 1d 48 f1 11 00 cmp 0x11f148,%ebx 106d26: 72 c2 jb 106cea else if (strcmp(path, device_name_table[i].device_name) == 0) rtems_set_errno_and_return_minus_one( EEXIST ); } if (slot == -1) 106d28: 83 fe ff cmp $0xffffffff,%esi 106d2b: 75 0d jne 106d3a rtems_set_errno_and_return_minus_one( ENOMEM ); 106d2d: e8 0e 8a 00 00 call 10f740 <__errno> 106d32: c7 00 0c 00 00 00 movl $0xc,(%eax) 106d38: eb ab jmp 106ce5 _ISR_Disable(level); 106d3a: 9c pushf 106d3b: fa cli 106d3c: 5b pop %ebx device_name_table[slot].device_name = (char *)path; 106d3d: 6b d6 14 imul $0x14,%esi,%edx 106d40: 8d 14 11 lea (%ecx,%edx,1),%edx 106d43: 89 3a mov %edi,(%edx) device_name_table[slot].device_name_length = strlen(path); 106d45: 31 c0 xor %eax,%eax 106d47: 83 c9 ff or $0xffffffff,%ecx 106d4a: f2 ae repnz scas %es:(%edi),%al 106d4c: f7 d1 not %ecx 106d4e: 49 dec %ecx 106d4f: 89 4a 04 mov %ecx,0x4(%edx) device_name_table[slot].major = major; 106d52: 8b 45 e4 mov -0x1c(%ebp),%eax 106d55: 89 42 08 mov %eax,0x8(%edx) device_name_table[slot].minor = minor; 106d58: 8b 45 e0 mov -0x20(%ebp),%eax 106d5b: 89 42 0c mov %eax,0xc(%edx) device_name_table[slot].mode = mode; 106d5e: 8b 45 0c mov 0xc(%ebp),%eax 106d61: 89 42 10 mov %eax,0x10(%edx) _ISR_Enable(level); 106d64: 53 push %ebx 106d65: 9d popf return 0; 106d66: 31 c0 xor %eax,%eax } 106d68: 8d 65 f4 lea -0xc(%ebp),%esp 106d6b: 5b pop %ebx 106d6c: 5e pop %esi 106d6d: 5f pop %edi 106d6e: c9 leave 106d6f: c3 ret =============================================================================== 001080d8 : /* * Drain output queue */ static void drainOutput (struct rtems_termios_tty *tty) { 1080d8: 55 push %ebp 1080d9: 89 e5 mov %esp,%ebp 1080db: 53 push %ebx 1080dc: 83 ec 04 sub $0x4,%esp 1080df: 89 c3 mov %eax,%ebx rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { 1080e1: 83 b8 b4 00 00 00 00 cmpl $0x0,0xb4(%eax) 1080e8: 74 46 je 108130 rtems_interrupt_disable (level); 1080ea: 9c pushf 1080eb: fa cli 1080ec: 58 pop %eax while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) { 1080ed: eb 2f jmp 10811e tty->rawOutBufState = rob_wait; 1080ef: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) 1080f6: 00 00 00 rtems_interrupt_enable (level); 1080f9: 50 push %eax 1080fa: 9d popf sc = rtems_semaphore_obtain( 1080fb: 50 push %eax 1080fc: 6a 00 push $0x0 1080fe: 6a 00 push $0x0 108100: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 108106: e8 b1 20 00 00 call 10a1bc tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 10810b: 83 c4 10 add $0x10,%esp 10810e: 85 c0 test %eax,%eax 108110: 74 09 je 10811b <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 108112: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108115: 50 push %eax <== NOT EXECUTED 108116: e8 6d 26 00 00 call 10a788 <== NOT EXECUTED rtems_interrupt_disable (level); 10811b: 9c pushf 10811c: fa cli 10811d: 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) { 10811e: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx 108124: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 10812a: 39 d1 cmp %edx,%ecx 10812c: 75 c1 jne 1080ef 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); 10812e: 50 push %eax 10812f: 9d popf } } 108130: 8b 5d fc mov -0x4(%ebp),%ebx 108133: c9 leave 108134: c3 ret =============================================================================== 00108c8f : /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { 108c8f: 55 push %ebp 108c90: 89 e5 mov %esp,%ebp 108c92: 53 push %ebx 108c93: 83 ec 24 sub $0x24,%esp if ((tty->termios.c_lflag & ECHOCTL) && 108c96: f6 42 3d 02 testb $0x2,0x3d(%edx) 108c9a: 74 3e je 108cda <== NEVER TAKEN iscntrl(c) && (c != '\t') && (c != '\n')) { 108c9c: 0f b6 c8 movzbl %al,%ecx 108c9f: 8b 1d 3c 31 12 00 mov 0x12313c,%ebx 108ca5: f6 44 0b 01 20 testb $0x20,0x1(%ebx,%ecx,1) 108caa: 74 2e je 108cda 108cac: 3c 09 cmp $0x9,%al 108cae: 74 2a je 108cda 108cb0: 3c 0a cmp $0xa,%al 108cb2: 74 26 je 108cda char echobuf[2]; echobuf[0] = '^'; 108cb4: c6 45 f6 5e movb $0x5e,-0xa(%ebp) echobuf[1] = c ^ 0x40; 108cb8: 83 f0 40 xor $0x40,%eax 108cbb: 88 45 f7 mov %al,-0x9(%ebp) rtems_termios_puts (echobuf, 2, tty); 108cbe: 50 push %eax 108cbf: 52 push %edx 108cc0: 6a 02 push $0x2 108cc2: 8d 45 f6 lea -0xa(%ebp),%eax 108cc5: 50 push %eax 108cc6: 89 55 e4 mov %edx,-0x1c(%ebp) 108cc9: e8 84 fd ff ff call 108a52 tty->column += 2; 108cce: 8b 55 e4 mov -0x1c(%ebp),%edx 108cd1: 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')) { 108cd5: 83 c4 10 add $0x10,%esp 108cd8: eb 08 jmp 108ce2 echobuf[0] = '^'; echobuf[1] = c ^ 0x40; rtems_termios_puts (echobuf, 2, tty); tty->column += 2; } else { oproc (c, tty); 108cda: 0f b6 c0 movzbl %al,%eax 108cdd: e8 90 fe ff ff call 108b72 } } 108ce2: 8b 5d fc mov -0x4(%ebp),%ebx 108ce5: c9 leave 108ce6: c3 ret =============================================================================== 0010814e : void endgrent(void) { 10814e: 55 push %ebp 10814f: 89 e5 mov %esp,%ebp 108151: 83 ec 08 sub $0x8,%esp if (group_fp != NULL) 108154: a1 b8 6b 12 00 mov 0x126bb8,%eax 108159: 85 c0 test %eax,%eax 10815b: 74 0c je 108169 <== NEVER TAKEN fclose(group_fp); 10815d: 83 ec 0c sub $0xc,%esp 108160: 50 push %eax 108161: e8 aa 9e 00 00 call 112010 108166: 83 c4 10 add $0x10,%esp } 108169: c9 leave 10816a: c3 ret =============================================================================== 00108001 : void endpwent(void) { 108001: 55 push %ebp 108002: 89 e5 mov %esp,%ebp 108004: 83 ec 08 sub $0x8,%esp if (passwd_fp != NULL) 108007: a1 94 6c 12 00 mov 0x126c94,%eax 10800c: 85 c0 test %eax,%eax 10800e: 74 0c je 10801c <== NEVER TAKEN fclose(passwd_fp); 108010: 83 ec 0c sub $0xc,%esp 108013: 50 push %eax 108014: e8 f7 9f 00 00 call 112010 108019: 83 c4 10 add $0x10,%esp } 10801c: c9 leave 10801d: c3 ret =============================================================================== 00108ce7 : * 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) { 108ce7: 55 push %ebp 108ce8: 89 e5 mov %esp,%ebp 108cea: 57 push %edi 108ceb: 56 push %esi 108cec: 53 push %ebx 108ced: 83 ec 2c sub $0x2c,%esp 108cf0: 89 c3 mov %eax,%ebx 108cf2: 89 55 e4 mov %edx,-0x1c(%ebp) if (tty->ccount == 0) 108cf5: 83 78 20 00 cmpl $0x0,0x20(%eax) 108cf9: 0f 84 59 01 00 00 je 108e58 return; if (lineFlag) { 108cff: 85 d2 test %edx,%edx 108d01: 0f 84 46 01 00 00 je 108e4d if (!(tty->termios.c_lflag & ECHO)) { 108d07: 8b 40 3c mov 0x3c(%eax),%eax 108d0a: a8 08 test $0x8,%al 108d0c: 75 0c jne 108d1a <== ALWAYS TAKEN tty->ccount = 0; 108d0e: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED return; 108d15: e9 3e 01 00 00 jmp 108e58 <== NOT EXECUTED } if (!(tty->termios.c_lflag & ECHOE)) { 108d1a: a8 10 test $0x10,%al 108d1c: 0f 85 2b 01 00 00 jne 108e4d <== ALWAYS TAKEN tty->ccount = 0; 108d22: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED echo (tty->termios.c_cc[VKILL], tty); 108d29: 0f b6 43 44 movzbl 0x44(%ebx),%eax <== NOT EXECUTED 108d2d: 89 da mov %ebx,%edx <== NOT EXECUTED 108d2f: e8 5b ff ff ff call 108c8f <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) 108d34: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED 108d38: 0f 84 1a 01 00 00 je 108e58 <== NOT EXECUTED echo ('\n', tty); 108d3e: 89 da mov %ebx,%edx <== NOT EXECUTED 108d40: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 108d45: eb 2a jmp 108d71 <== NOT EXECUTED return; } } while (tty->ccount) { unsigned char c = tty->cbuf[--tty->ccount]; 108d47: 8b 7b 1c mov 0x1c(%ebx),%edi 108d4a: 8d 50 ff lea -0x1(%eax),%edx 108d4d: 89 53 20 mov %edx,0x20(%ebx) 108d50: 8a 4c 07 ff mov -0x1(%edi,%eax,1),%cl if (tty->termios.c_lflag & ECHO) { 108d54: 8b 53 3c mov 0x3c(%ebx),%edx 108d57: f6 c2 08 test $0x8,%dl 108d5a: 0f 84 e7 00 00 00 je 108e47 <== NEVER TAKEN if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { 108d60: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 108d64: 75 17 jne 108d7d 108d66: f6 c2 10 test $0x10,%dl 108d69: 75 12 jne 108d7d <== ALWAYS TAKEN echo (tty->termios.c_cc[VERASE], tty); 108d6b: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED 108d6f: 89 da mov %ebx,%edx <== NOT EXECUTED } } if (!lineFlag) break; } } 108d71: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108d74: 5b pop %ebx <== NOT EXECUTED 108d75: 5e pop %esi <== NOT EXECUTED 108d76: 5f pop %edi <== NOT EXECUTED 108d77: 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); 108d78: e9 12 ff ff ff jmp 108c8f <== NOT EXECUTED } else if (c == '\t') { 108d7d: 80 f9 09 cmp $0x9,%cl 108d80: 8b 35 3c 31 12 00 mov 0x12313c,%esi 108d86: 89 75 e0 mov %esi,-0x20(%ebp) 108d89: 75 60 jne 108deb int col = tty->read_start_column; 108d8b: 8b 73 2c mov 0x2c(%ebx),%esi int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 108d8e: b9 01 00 00 00 mov $0x1,%ecx c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; } else if (iscntrl (c)) { if (tty->termios.c_lflag & ECHOCTL) 108d93: 81 e2 00 02 00 00 and $0x200,%edx 108d99: 89 55 dc mov %edx,-0x24(%ebp) 108d9c: 89 45 d4 mov %eax,-0x2c(%ebp) int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 108d9f: eb 28 jmp 108dc9 c = tty->cbuf[i++]; 108da1: 8a 54 0f ff mov -0x1(%edi,%ecx,1),%dl if (c == '\t') { 108da5: 80 fa 09 cmp $0x9,%dl 108da8: 75 05 jne 108daf col = (col | 7) + 1; 108daa: 83 ce 07 or $0x7,%esi 108dad: eb 18 jmp 108dc7 } else if (iscntrl (c)) { 108daf: 0f b6 d2 movzbl %dl,%edx 108db2: 8b 45 e0 mov -0x20(%ebp),%eax 108db5: f6 44 10 01 20 testb $0x20,0x1(%eax,%edx,1) 108dba: 74 0b je 108dc7 <== ALWAYS TAKEN if (tty->termios.c_lflag & ECHOCTL) 108dbc: 83 7d dc 00 cmpl $0x0,-0x24(%ebp) <== NOT EXECUTED 108dc0: 74 06 je 108dc8 <== NOT EXECUTED col += 2; 108dc2: 83 c6 02 add $0x2,%esi <== NOT EXECUTED 108dc5: eb 01 jmp 108dc8 <== NOT EXECUTED } else { col++; 108dc7: 46 inc %esi 108dc8: 41 inc %ecx int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 108dc9: 3b 4d d4 cmp -0x2c(%ebp),%ecx 108dcc: 75 d3 jne 108da1 108dce: eb 14 jmp 108de4 /* * Back up over the tab */ while (tty->column > col) { rtems_termios_puts ("\b", 1, tty); 108dd0: 57 push %edi 108dd1: 53 push %ebx 108dd2: 6a 01 push $0x1 108dd4: 68 68 f0 11 00 push $0x11f068 108dd9: e8 74 fc ff ff call 108a52 tty->column--; 108dde: ff 4b 28 decl 0x28(%ebx) 108de1: 83 c4 10 add $0x10,%esp } /* * Back up over the tab */ while (tty->column > col) { 108de4: 39 73 28 cmp %esi,0x28(%ebx) 108de7: 7f e7 jg 108dd0 108de9: eb 5c jmp 108e47 rtems_termios_puts ("\b", 1, tty); tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { 108deb: 0f b6 f1 movzbl %cl,%esi 108dee: 8b 45 e0 mov -0x20(%ebp),%eax 108df1: f6 44 30 01 20 testb $0x20,0x1(%eax,%esi,1) 108df6: 74 21 je 108e19 <== ALWAYS TAKEN 108df8: 80 e6 02 and $0x2,%dh <== NOT EXECUTED 108dfb: 74 1c je 108e19 <== NOT EXECUTED rtems_termios_puts ("\b \b", 3, tty); 108dfd: 51 push %ecx <== NOT EXECUTED 108dfe: 53 push %ebx <== NOT EXECUTED 108dff: 6a 03 push $0x3 <== NOT EXECUTED 108e01: 68 66 f0 11 00 push $0x11f066 <== NOT EXECUTED 108e06: e8 47 fc ff ff call 108a52 <== NOT EXECUTED if (tty->column) 108e0b: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 108e0e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108e11: 85 c0 test %eax,%eax <== NOT EXECUTED 108e13: 74 04 je 108e19 <== NOT EXECUTED tty->column--; 108e15: 48 dec %eax <== NOT EXECUTED 108e16: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED } if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) { 108e19: a1 3c 31 12 00 mov 0x12313c,%eax 108e1e: f6 44 30 01 20 testb $0x20,0x1(%eax,%esi,1) 108e23: 74 06 je 108e2b <== ALWAYS TAKEN 108e25: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED 108e29: 74 1c je 108e47 <== NOT EXECUTED rtems_termios_puts ("\b \b", 3, tty); 108e2b: 52 push %edx 108e2c: 53 push %ebx 108e2d: 6a 03 push $0x3 108e2f: 68 66 f0 11 00 push $0x11f066 108e34: e8 19 fc ff ff call 108a52 if (tty->column) 108e39: 8b 43 28 mov 0x28(%ebx),%eax 108e3c: 83 c4 10 add $0x10,%esp 108e3f: 85 c0 test %eax,%eax 108e41: 74 04 je 108e47 <== NEVER TAKEN tty->column--; 108e43: 48 dec %eax 108e44: 89 43 28 mov %eax,0x28(%ebx) } } } if (!lineFlag) 108e47: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 108e4b: 74 0b je 108e58 echo ('\n', tty); return; } } while (tty->ccount) { 108e4d: 8b 43 20 mov 0x20(%ebx),%eax 108e50: 85 c0 test %eax,%eax 108e52: 0f 85 ef fe ff ff jne 108d47 } } if (!lineFlag) break; } } 108e58: 8d 65 f4 lea -0xc(%ebp),%esp 108e5b: 5b pop %ebx 108e5c: 5e pop %esi 108e5d: 5f pop %edi 108e5e: c9 leave 108e5f: c3 ret =============================================================================== 00107c08 : int fcntl( int fd, int cmd, ... ) { 107c08: 55 push %ebp 107c09: 89 e5 mov %esp,%ebp 107c0b: 57 push %edi 107c0c: 56 push %esi 107c0d: 53 push %ebx 107c0e: 83 ec 0c sub $0xc,%esp 107c11: 8b 5d 08 mov 0x8(%ebp),%ebx int ret; va_list ap; va_start( ap, cmd ); 107c14: 8d 75 10 lea 0x10(%ebp),%esi int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 107c17: 8b 0d 44 21 12 00 mov 0x122144,%ecx 107c1d: 39 cb cmp %ecx,%ebx 107c1f: 73 14 jae 107c35 iop = rtems_libio_iop( fd ); 107c21: 8b 15 f8 61 12 00 mov 0x1261f8,%edx 107c27: 6b db 38 imul $0x38,%ebx,%ebx 107c2a: 8d 1c 1a lea (%edx,%ebx,1),%ebx rtems_libio_check_is_open(iop); 107c2d: 8b 43 14 mov 0x14(%ebx),%eax 107c30: f6 c4 01 test $0x1,%ah 107c33: 75 10 jne 107c45 107c35: e8 56 a3 00 00 call 111f90 <__errno> 107c3a: c7 00 09 00 00 00 movl $0x9,(%eax) 107c40: e9 e6 00 00 00 jmp 107d2b /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 107c45: 83 7d 0c 09 cmpl $0x9,0xc(%ebp) 107c49: 0f 87 af 00 00 00 ja 107cfe 107c4f: 8b 7d 0c mov 0xc(%ebp),%edi 107c52: ff 24 bd b4 08 12 00 jmp *0x1208b4(,%edi,4) case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); 107c59: 8b 36 mov (%esi),%esi if ( fd2 ) 107c5b: 85 f6 test %esi,%esi 107c5d: 74 0e je 107c6d diop = rtems_libio_iop( fd2 ); 107c5f: 31 c0 xor %eax,%eax 107c61: 39 ce cmp %ecx,%esi 107c63: 73 15 jae 107c7a <== NEVER TAKEN 107c65: 6b c6 38 imul $0x38,%esi,%eax 107c68: 8d 04 02 lea (%edx,%eax,1),%eax 107c6b: eb 0d jmp 107c7a else { /* allocate a file control block */ diop = rtems_libio_allocate(); 107c6d: e8 d1 04 00 00 call 108143 if ( diop == 0 ) { 107c72: 85 c0 test %eax,%eax 107c74: 0f 84 b1 00 00 00 je 107d2b <== NEVER TAKEN ret = -1; break; } } diop->flags = iop->flags; 107c7a: 8b 53 14 mov 0x14(%ebx),%edx 107c7d: 89 50 14 mov %edx,0x14(%eax) diop->pathinfo = iop->pathinfo; 107c80: 8d 78 18 lea 0x18(%eax),%edi 107c83: 8d 73 18 lea 0x18(%ebx),%esi 107c86: b9 05 00 00 00 mov $0x5,%ecx 107c8b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ret = (int) (diop - rtems_libio_iops); 107c8d: 2b 05 f8 61 12 00 sub 0x1261f8,%eax 107c93: c1 f8 03 sar $0x3,%eax 107c96: 69 f0 b7 6d db b6 imul $0xb6db6db7,%eax,%esi 107c9c: eb 6d jmp 107d0b break; case F_GETFD: /* get f_flags */ ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0); 107c9e: f6 c4 08 test $0x8,%ah 107ca1: 0f 95 c0 setne %al 107ca4: 0f b6 c0 movzbl %al,%eax 107ca7: 89 c6 mov %eax,%esi 107ca9: eb 64 jmp 107d0f * 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 ) ) 107cab: 83 3e 00 cmpl $0x0,(%esi) 107cae: 74 05 je 107cb5 iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; 107cb0: 80 cc 08 or $0x8,%ah 107cb3: eb 03 jmp 107cb8 else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; 107cb5: 80 e4 f7 and $0xf7,%ah 107cb8: 89 43 14 mov %eax,0x14(%ebx) 107cbb: eb 30 jmp 107ced break; case F_GETFL: /* more flags (cloexec) */ ret = rtems_libio_to_fcntl_flags( iop->flags ); 107cbd: 83 ec 0c sub $0xc,%esp 107cc0: 50 push %eax 107cc1: e8 3f 04 00 00 call 108105 107cc6: 89 c6 mov %eax,%esi 107cc8: 83 c4 10 add $0x10,%esp 107ccb: eb 3e jmp 107d0b break; case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); 107ccd: 83 ec 0c sub $0xc,%esp 107cd0: ff 36 pushl (%esi) 107cd2: e8 f9 03 00 00 call 1080d0 /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = (iop->flags & ~mask) | (flags & mask); 107cd7: 25 01 02 00 00 and $0x201,%eax 107cdc: 8b 53 14 mov 0x14(%ebx),%edx 107cdf: 81 e2 fe fd ff ff and $0xfffffdfe,%edx 107ce5: 09 d0 or %edx,%eax 107ce7: 89 43 14 mov %eax,0x14(%ebx) 107cea: 83 c4 10 add $0x10,%esp rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0; 107ced: 31 f6 xor %esi,%esi 107cef: eb 1e jmp 107d0f errno = ENOTSUP; ret = -1; break; case F_GETOWN: /* for sockets. */ errno = ENOTSUP; 107cf1: e8 9a a2 00 00 call 111f90 <__errno> 107cf6: c7 00 86 00 00 00 movl $0x86,(%eax) 107cfc: eb 2d jmp 107d2b ret = -1; break; default: errno = EINVAL; 107cfe: e8 8d a2 00 00 call 111f90 <__errno> 107d03: c7 00 16 00 00 00 movl $0x16,(%eax) 107d09: eb 20 jmp 107d2b /* * If we got this far successfully, then we give the optional * filesystem specific handler a chance to process this. */ if (ret >= 0) { 107d0b: 85 f6 test %esi,%esi 107d0d: 78 1f js 107d2e <== NEVER TAKEN int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop ); 107d0f: 50 push %eax 107d10: 50 push %eax 107d11: 8b 43 20 mov 0x20(%ebx),%eax 107d14: 53 push %ebx 107d15: ff 75 0c pushl 0xc(%ebp) 107d18: ff 50 30 call *0x30(%eax) 107d1b: 89 c3 mov %eax,%ebx if (err) { 107d1d: 83 c4 10 add $0x10,%esp 107d20: 85 c0 test %eax,%eax 107d22: 74 0a je 107d2e <== ALWAYS TAKEN errno = err; 107d24: e8 67 a2 00 00 call 111f90 <__errno> <== NOT EXECUTED 107d29: 89 18 mov %ebx,(%eax) <== NOT EXECUTED ret = -1; 107d2b: 83 ce ff or $0xffffffff,%esi va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; } 107d2e: 89 f0 mov %esi,%eax 107d30: 8d 65 f4 lea -0xc(%ebp),%esp 107d33: 5b pop %ebx 107d34: 5e pop %esi 107d35: 5f pop %edi 107d36: c9 leave 107d37: c3 ret =============================================================================== 0010fb83 : */ int fifo_open( pipe_control_t **pipep, rtems_libio_t *iop ) { 10fb83: 55 push %ebp 10fb84: 89 e5 mov %esp,%ebp 10fb86: 57 push %edi 10fb87: 56 push %esi 10fb88: 53 push %ebx 10fb89: 83 ec 2c sub $0x2c,%esp static rtems_status_code pipe_lock(void) { rtems_status_code sc = RTEMS_SUCCESSFUL; if (pipe_semaphore == RTEMS_ID_NONE) { 10fb8c: 83 3d 20 70 12 00 00 cmpl $0x0,0x127020 10fb93: 75 50 jne 10fbe5 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 ); 10fb95: 53 push %ebx 10fb96: 6a 00 push $0x0 10fb98: 6a 00 push $0x0 10fb9a: ff 35 20 72 12 00 pushl 0x127220 10fba0: e8 bb c0 ff ff call 10bc60 rtems_libio_lock(); if (pipe_semaphore == RTEMS_ID_NONE) { 10fba5: 83 c4 10 add $0x10,%esp free(pipe); } static rtems_status_code pipe_lock(void) { rtems_status_code sc = RTEMS_SUCCESSFUL; 10fba8: 31 db xor %ebx,%ebx if (pipe_semaphore == RTEMS_ID_NONE) { rtems_libio_lock(); if (pipe_semaphore == RTEMS_ID_NONE) { 10fbaa: 83 3d 20 70 12 00 00 cmpl $0x0,0x127020 10fbb1: 75 1d jne 10fbd0 <== NEVER TAKEN sc = rtems_semaphore_create( 10fbb3: 83 ec 0c sub $0xc,%esp 10fbb6: 68 20 70 12 00 push $0x127020 10fbbb: 6a 00 push $0x0 10fbbd: 6a 54 push $0x54 10fbbf: 6a 01 push $0x1 10fbc1: 68 45 50 49 50 push $0x50495045 10fbc6: e8 6d be ff ff call 10ba38 10fbcb: 89 c3 mov %eax,%ebx 10fbcd: 83 c4 20 add $0x20,%esp } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10fbd0: 83 ec 0c sub $0xc,%esp 10fbd3: ff 35 20 72 12 00 pushl 0x127220 10fbd9: e8 6e c1 ff ff call 10bd4c } rtems_libio_unlock(); } if (sc == RTEMS_SUCCESSFUL) { 10fbde: 83 c4 10 add $0x10,%esp 10fbe1: 85 db test %ebx,%ebx 10fbe3: 75 19 jne 10fbfe sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 10fbe5: 51 push %ecx 10fbe6: 6a 00 push $0x0 10fbe8: 6a 00 push $0x0 10fbea: ff 35 20 70 12 00 pushl 0x127020 10fbf0: e8 6b c0 ff ff call 10bc60 } if (sc == RTEMS_SUCCESSFUL) { 10fbf5: 83 c4 10 add $0x10,%esp return 0; 10fbf8: 31 f6 xor %esi,%esi if (sc == RTEMS_SUCCESSFUL) { sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); } if (sc == RTEMS_SUCCESSFUL) { 10fbfa: 85 c0 test %eax,%eax 10fbfc: 74 05 je 10fc03 <== ALWAYS TAKEN return 0; } else { return -ENOMEM; 10fbfe: be f4 ff ff ff mov $0xfffffff4,%esi { pipe_control_t *pipe; int err = 0; err = pipe_lock(); if (err) 10fc03: 85 f6 test %esi,%esi 10fc05: 0f 85 37 03 00 00 jne 10ff42 return err; pipe = *pipep; 10fc0b: 8b 45 08 mov 0x8(%ebp),%eax 10fc0e: 8b 18 mov (%eax),%ebx if (pipe == NULL) { 10fc10: 85 db test %ebx,%ebx 10fc12: 0f 85 56 01 00 00 jne 10fd6e { static char c = 'a'; pipe_control_t *pipe; int err = -ENOMEM; pipe = malloc(sizeof(pipe_control_t)); 10fc18: 83 ec 0c sub $0xc,%esp 10fc1b: 6a 34 push $0x34 10fc1d: e8 be 93 ff ff call 108fe0 10fc22: 89 c3 mov %eax,%ebx 10fc24: 89 45 d4 mov %eax,-0x2c(%ebp) if (pipe == NULL) 10fc27: 83 c4 10 add $0x10,%esp 10fc2a: 85 c0 test %eax,%eax 10fc2c: 0f 84 35 01 00 00 je 10fd67 return err; memset(pipe, 0, sizeof(pipe_control_t)); 10fc32: b9 0d 00 00 00 mov $0xd,%ecx 10fc37: 89 c7 mov %eax,%edi 10fc39: 89 f0 mov %esi,%eax 10fc3b: f3 ab rep stos %eax,%es:(%edi) pipe->Size = PIPE_BUF; 10fc3d: c7 43 04 00 02 00 00 movl $0x200,0x4(%ebx) pipe->Buffer = malloc(pipe->Size); 10fc44: 83 ec 0c sub $0xc,%esp 10fc47: 68 00 02 00 00 push $0x200 10fc4c: e8 8f 93 ff ff call 108fe0 10fc51: 89 03 mov %eax,(%ebx) if (! pipe->Buffer) 10fc53: 83 c4 10 add $0x10,%esp 10fc56: 85 c0 test %eax,%eax 10fc58: 0f 84 fb 00 00 00 je 10fd59 <== NEVER TAKEN goto err_buf; err = -ENOMEM; if (rtems_barrier_create( 10fc5e: 8d 43 2c lea 0x2c(%ebx),%eax 10fc61: 50 push %eax 10fc62: 6a 00 push $0x0 10fc64: 6a 00 push $0x0 rtems_build_name ('P', 'I', 'r', c), 10fc66: 0f be 05 a8 50 12 00 movsbl 0x1250a8,%eax if (! pipe->Buffer) goto err_buf; err = -ENOMEM; if (rtems_barrier_create( 10fc6d: 0d 00 72 49 50 or $0x50497200,%eax 10fc72: 50 push %eax 10fc73: e8 40 18 00 00 call 1114b8 10fc78: 83 c4 10 add $0x10,%esp 10fc7b: 85 c0 test %eax,%eax 10fc7d: 0f 85 c6 00 00 00 jne 10fd49 rtems_build_name ('P', 'I', 'r', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->readBarrier) != RTEMS_SUCCESSFUL) goto err_rbar; if (rtems_barrier_create( 10fc83: 8d 43 30 lea 0x30(%ebx),%eax 10fc86: 50 push %eax 10fc87: 6a 00 push $0x0 10fc89: 6a 00 push $0x0 rtems_build_name ('P', 'I', 'w', c), 10fc8b: 0f be 05 a8 50 12 00 movsbl 0x1250a8,%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( 10fc92: 0d 00 77 49 50 or $0x50497700,%eax 10fc97: 50 push %eax 10fc98: e8 1b 18 00 00 call 1114b8 10fc9d: 83 c4 10 add $0x10,%esp 10fca0: 85 c0 test %eax,%eax 10fca2: 0f 85 90 00 00 00 jne 10fd38 rtems_build_name ('P', 'I', 'w', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->writeBarrier) != RTEMS_SUCCESSFUL) goto err_wbar; if (rtems_semaphore_create( 10fca8: 83 ec 0c sub $0xc,%esp 10fcab: 8d 43 28 lea 0x28(%ebx),%eax 10fcae: 50 push %eax 10fcaf: 6a 00 push $0x0 10fcb1: 6a 10 push $0x10 10fcb3: 6a 01 push $0x1 rtems_build_name ('P', 'I', 's', c), 1, 10fcb5: 0f be 05 a8 50 12 00 movsbl 0x1250a8,%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( 10fcbc: 0d 00 73 49 50 or $0x50497300,%eax 10fcc1: 50 push %eax 10fcc2: e8 71 bd ff ff call 10ba38 10fcc7: 83 c4 20 add $0x20,%esp 10fcca: 85 c0 test %eax,%eax 10fccc: 75 59 jne 10fd27 Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) _Objects_Get( &_Barrier_Information, id, location ); 10fcce: 52 push %edx /* Set barriers to be interruptible by signals. */ static void pipe_interruptible(pipe_control_t *pipe) { Objects_Locations location; _Barrier_Get(pipe->readBarrier, &location)->Barrier.Wait_queue.state 10fccf: 8d 7d e0 lea -0x20(%ebp),%edi 10fcd2: 57 push %edi 10fcd3: ff 73 2c pushl 0x2c(%ebx) 10fcd6: 68 5c 7c 12 00 push $0x127c5c 10fcdb: e8 c8 d4 ff ff call 10d1a8 <_Objects_Get> |= STATES_INTERRUPTIBLE_BY_SIGNAL; 10fce0: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax) _Thread_Enable_dispatch(); 10fce7: e8 9e df ff ff call 10dc8a <_Thread_Enable_dispatch> 10fcec: 83 c4 0c add $0xc,%esp 10fcef: 57 push %edi 10fcf0: ff 73 30 pushl 0x30(%ebx) 10fcf3: 68 5c 7c 12 00 push $0x127c5c 10fcf8: e8 ab d4 ff ff call 10d1a8 <_Objects_Get> _Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state |= STATES_INTERRUPTIBLE_BY_SIGNAL; 10fcfd: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax) _Thread_Enable_dispatch(); 10fd04: e8 81 df ff ff call 10dc8a <_Thread_Enable_dispatch> #ifdef RTEMS_POSIX_API pipe_interruptible(pipe); #endif *pipep = pipe; if (c ++ == 'z') 10fd09: a0 a8 50 12 00 mov 0x1250a8,%al 10fd0e: 8d 50 01 lea 0x1(%eax),%edx 10fd11: 88 15 a8 50 12 00 mov %dl,0x1250a8 10fd17: 83 c4 10 add $0x10,%esp 10fd1a: 3c 7a cmp $0x7a,%al 10fd1c: 75 50 jne 10fd6e c = 'a'; 10fd1e: c6 05 a8 50 12 00 61 movb $0x61,0x1250a8 10fd25: eb 47 jmp 10fd6e return 0; err_sem: rtems_barrier_delete(pipe->writeBarrier); 10fd27: 83 ec 0c sub $0xc,%esp 10fd2a: 8b 55 d4 mov -0x2c(%ebp),%edx 10fd2d: ff 72 30 pushl 0x30(%edx) 10fd30: e8 3b 18 00 00 call 111570 10fd35: 83 c4 10 add $0x10,%esp err_wbar: rtems_barrier_delete(pipe->readBarrier); 10fd38: 83 ec 0c sub $0xc,%esp 10fd3b: 8b 45 d4 mov -0x2c(%ebp),%eax 10fd3e: ff 70 2c pushl 0x2c(%eax) 10fd41: e8 2a 18 00 00 call 111570 10fd46: 83 c4 10 add $0x10,%esp err_rbar: free(pipe->Buffer); 10fd49: 83 ec 0c sub $0xc,%esp 10fd4c: 8b 55 d4 mov -0x2c(%ebp),%edx 10fd4f: ff 32 pushl (%edx) 10fd51: e8 66 8c ff ff call 1089bc 10fd56: 83 c4 10 add $0x10,%esp err_buf: free(pipe); 10fd59: 83 ec 0c sub $0xc,%esp 10fd5c: ff 75 d4 pushl -0x2c(%ebp) 10fd5f: e8 58 8c ff ff call 1089bc 10fd64: 83 c4 10 add $0x10,%esp if (err) goto out; } if (! PIPE_LOCK(pipe)) err = -EINTR; 10fd67: be f4 ff ff ff mov $0xfffffff4,%esi 10fd6c: eb 33 jmp 10fda1 err = pipe_alloc(&pipe); if (err) goto out; } if (! PIPE_LOCK(pipe)) 10fd6e: 50 push %eax 10fd6f: 6a 00 push $0x0 10fd71: 6a 00 push $0x0 10fd73: ff 73 28 pushl 0x28(%ebx) 10fd76: e8 e5 be ff ff call 10bc60 10fd7b: 83 c4 10 add $0x10,%esp 10fd7e: 85 c0 test %eax,%eax 10fd80: 74 05 je 10fd87 <== ALWAYS TAKEN err = -EINTR; 10fd82: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED if (*pipep == NULL) { 10fd87: 8b 45 08 mov 0x8(%ebp),%eax 10fd8a: 83 38 00 cmpl $0x0,(%eax) 10fd8d: 75 12 jne 10fda1 if (err) 10fd8f: 85 f6 test %esi,%esi 10fd91: 74 09 je 10fd9c <== ALWAYS TAKEN pipe_free(pipe); 10fd93: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10fd95: e8 1c fd ff ff call 10fab6 <== NOT EXECUTED 10fd9a: eb 05 jmp 10fda1 <== NOT EXECUTED else *pipep = pipe; 10fd9c: 8b 55 08 mov 0x8(%ebp),%edx 10fd9f: 89 1a mov %ebx,(%edx) } out: pipe_unlock(); 10fda1: e8 fa fc ff ff call 10faa0 pipe_control_t *pipe; unsigned int prevCounter; int err; err = pipe_new(pipep); if (err) 10fda6: 85 f6 test %esi,%esi 10fda8: 0f 85 94 01 00 00 jne 10ff42 return err; pipe = *pipep; 10fdae: 8b 45 08 mov 0x8(%ebp),%eax 10fdb1: 8b 18 mov (%eax),%ebx switch (LIBIO_ACCMODE(iop)) { 10fdb3: 8b 55 0c mov 0xc(%ebp),%edx 10fdb6: 8b 42 14 mov 0x14(%edx),%eax 10fdb9: 83 e0 06 and $0x6,%eax 10fdbc: 83 f8 04 cmp $0x4,%eax 10fdbf: 0f 84 91 00 00 00 je 10fe56 10fdc5: 83 f8 06 cmp $0x6,%eax 10fdc8: 0f 84 10 01 00 00 je 10fede 10fdce: 83 f8 02 cmp $0x2,%eax 10fdd1: 0f 85 49 01 00 00 jne 10ff20 <== NEVER TAKEN case LIBIO_FLAGS_READ: pipe->readerCounter ++; 10fdd7: ff 43 20 incl 0x20(%ebx) if (pipe->Readers ++ == 0) 10fdda: 8b 43 10 mov 0x10(%ebx),%eax 10fddd: 8d 50 01 lea 0x1(%eax),%edx 10fde0: 89 53 10 mov %edx,0x10(%ebx) 10fde3: 85 c0 test %eax,%eax 10fde5: 75 11 jne 10fdf8 <== NEVER TAKEN PIPE_WAKEUPWRITERS(pipe); 10fde7: 57 push %edi 10fde8: 57 push %edi 10fde9: 8d 45 e4 lea -0x1c(%ebp),%eax 10fdec: 50 push %eax 10fded: ff 73 30 pushl 0x30(%ebx) 10fdf0: e8 03 18 00 00 call 1115f8 10fdf5: 83 c4 10 add $0x10,%esp if (pipe->Writers == 0) { 10fdf8: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10fdfc: 0f 85 1e 01 00 00 jne 10ff20 /* Not an error */ if (LIBIO_NODELAY(iop)) 10fe02: 8b 45 0c mov 0xc(%ebp),%eax 10fe05: f6 40 14 01 testb $0x1,0x14(%eax) 10fe09: 0f 85 11 01 00 00 jne 10ff20 break; prevCounter = pipe->writerCounter; 10fe0f: 8b 7b 24 mov 0x24(%ebx),%edi err = -EINTR; /* Wait until a writer opens the pipe */ do { PIPE_UNLOCK(pipe); 10fe12: 83 ec 0c sub $0xc,%esp 10fe15: ff 73 28 pushl 0x28(%ebx) 10fe18: e8 2f bf ff ff call 10bd4c if (! PIPE_READWAIT(pipe)) 10fe1d: 5a pop %edx 10fe1e: 59 pop %ecx 10fe1f: 6a 00 push $0x0 10fe21: ff 73 2c pushl 0x2c(%ebx) 10fe24: e8 27 18 00 00 call 111650 10fe29: 83 c4 10 add $0x10,%esp 10fe2c: 85 c0 test %eax,%eax 10fe2e: 0f 85 f9 00 00 00 jne 10ff2d <== NEVER TAKEN goto out_error; if (! PIPE_LOCK(pipe)) 10fe34: 50 push %eax 10fe35: 6a 00 push $0x0 10fe37: 6a 00 push $0x0 10fe39: ff 73 28 pushl 0x28(%ebx) 10fe3c: e8 1f be ff ff call 10bc60 10fe41: 83 c4 10 add $0x10,%esp 10fe44: 85 c0 test %eax,%eax 10fe46: 0f 85 e1 00 00 00 jne 10ff2d <== NEVER TAKEN goto out_error; } while (prevCounter == pipe->writerCounter); 10fe4c: 3b 7b 24 cmp 0x24(%ebx),%edi 10fe4f: 74 c1 je 10fe12 <== NEVER TAKEN 10fe51: e9 ca 00 00 00 jmp 10ff20 } break; case LIBIO_FLAGS_WRITE: pipe->writerCounter ++; 10fe56: ff 43 24 incl 0x24(%ebx) if (pipe->Writers ++ == 0) 10fe59: 8b 43 14 mov 0x14(%ebx),%eax 10fe5c: 8d 50 01 lea 0x1(%eax),%edx 10fe5f: 89 53 14 mov %edx,0x14(%ebx) 10fe62: 85 c0 test %eax,%eax 10fe64: 75 11 jne 10fe77 <== NEVER TAKEN PIPE_WAKEUPREADERS(pipe); 10fe66: 57 push %edi 10fe67: 57 push %edi 10fe68: 8d 45 e4 lea -0x1c(%ebp),%eax 10fe6b: 50 push %eax 10fe6c: ff 73 2c pushl 0x2c(%ebx) 10fe6f: e8 84 17 00 00 call 1115f8 10fe74: 83 c4 10 add $0x10,%esp if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) { 10fe77: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10fe7b: 0f 85 9f 00 00 00 jne 10ff20 10fe81: 8b 55 0c mov 0xc(%ebp),%edx 10fe84: f6 42 14 01 testb $0x1,0x14(%edx) 10fe88: 74 18 je 10fea2 PIPE_UNLOCK(pipe); 10fe8a: 83 ec 0c sub $0xc,%esp 10fe8d: ff 73 28 pushl 0x28(%ebx) 10fe90: e8 b7 be ff ff call 10bd4c err = -ENXIO; goto out_error; 10fe95: 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; 10fe98: be fa ff ff ff mov $0xfffffffa,%esi goto out_error; 10fe9d: e9 90 00 00 00 jmp 10ff32 } if (pipe->Readers == 0) { prevCounter = pipe->readerCounter; 10fea2: 8b 7b 20 mov 0x20(%ebx),%edi err = -EINTR; do { PIPE_UNLOCK(pipe); 10fea5: 83 ec 0c sub $0xc,%esp 10fea8: ff 73 28 pushl 0x28(%ebx) 10feab: e8 9c be ff ff call 10bd4c if (! PIPE_WRITEWAIT(pipe)) 10feb0: 5a pop %edx 10feb1: 59 pop %ecx 10feb2: 6a 00 push $0x0 10feb4: ff 73 30 pushl 0x30(%ebx) 10feb7: e8 94 17 00 00 call 111650 10febc: 83 c4 10 add $0x10,%esp 10febf: 85 c0 test %eax,%eax 10fec1: 75 6a jne 10ff2d <== NEVER TAKEN goto out_error; if (! PIPE_LOCK(pipe)) 10fec3: 50 push %eax 10fec4: 6a 00 push $0x0 10fec6: 6a 00 push $0x0 10fec8: ff 73 28 pushl 0x28(%ebx) 10fecb: e8 90 bd ff ff call 10bc60 10fed0: 83 c4 10 add $0x10,%esp 10fed3: 85 c0 test %eax,%eax 10fed5: 75 56 jne 10ff2d <== NEVER TAKEN goto out_error; } while (prevCounter == pipe->readerCounter); 10fed7: 3b 7b 20 cmp 0x20(%ebx),%edi 10feda: 74 c9 je 10fea5 <== NEVER TAKEN 10fedc: eb 42 jmp 10ff20 } break; case LIBIO_FLAGS_READ_WRITE: pipe->readerCounter ++; 10fede: ff 43 20 incl 0x20(%ebx) if (pipe->Readers ++ == 0) 10fee1: 8b 43 10 mov 0x10(%ebx),%eax 10fee4: 8d 50 01 lea 0x1(%eax),%edx 10fee7: 89 53 10 mov %edx,0x10(%ebx) 10feea: 85 c0 test %eax,%eax 10feec: 75 11 jne 10feff <== NEVER TAKEN PIPE_WAKEUPWRITERS(pipe); 10feee: 51 push %ecx 10feef: 51 push %ecx 10fef0: 8d 45 e4 lea -0x1c(%ebp),%eax 10fef3: 50 push %eax 10fef4: ff 73 30 pushl 0x30(%ebx) 10fef7: e8 fc 16 00 00 call 1115f8 10fefc: 83 c4 10 add $0x10,%esp pipe->writerCounter ++; 10feff: ff 43 24 incl 0x24(%ebx) if (pipe->Writers ++ == 0) 10ff02: 8b 43 14 mov 0x14(%ebx),%eax 10ff05: 8d 50 01 lea 0x1(%eax),%edx 10ff08: 89 53 14 mov %edx,0x14(%ebx) 10ff0b: 85 c0 test %eax,%eax 10ff0d: 75 11 jne 10ff20 <== NEVER TAKEN PIPE_WAKEUPREADERS(pipe); 10ff0f: 52 push %edx 10ff10: 52 push %edx 10ff11: 8d 45 e4 lea -0x1c(%ebp),%eax 10ff14: 50 push %eax 10ff15: ff 73 2c pushl 0x2c(%ebx) 10ff18: e8 db 16 00 00 call 1115f8 10ff1d: 83 c4 10 add $0x10,%esp break; } PIPE_UNLOCK(pipe); 10ff20: 83 ec 0c sub $0xc,%esp 10ff23: ff 73 28 pushl 0x28(%ebx) 10ff26: e8 21 be ff ff call 10bd4c 10ff2b: eb 12 jmp 10ff3f goto out_error; } if (pipe->Readers == 0) { prevCounter = pipe->readerCounter; err = -EINTR; 10ff2d: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED PIPE_UNLOCK(pipe); return 0; out_error: pipe_release(pipep, iop); 10ff32: 50 push %eax 10ff33: 50 push %eax 10ff34: ff 75 0c pushl 0xc(%ebp) 10ff37: ff 75 08 pushl 0x8(%ebp) 10ff3a: e8 b2 fb ff ff call 10faf1 return err; 10ff3f: 83 c4 10 add $0x10,%esp } 10ff42: 89 f0 mov %esi,%eax 10ff44: 8d 65 f4 lea -0xc(%ebp),%esp 10ff47: 5b pop %ebx 10ff48: 5e pop %esi 10ff49: 5f pop %edi 10ff4a: c9 leave 10ff4b: c3 ret =============================================================================== 00107dac : long fpathconf( int fd, int name ) { 107dac: 55 push %ebp 107dad: 89 e5 mov %esp,%ebp 107daf: 83 ec 08 sub $0x8,%esp 107db2: 8b 45 08 mov 0x8(%ebp),%eax 107db5: 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); 107db8: 3b 05 44 21 12 00 cmp 0x122144,%eax 107dbe: 73 11 jae 107dd1 iop = rtems_libio_iop(fd); 107dc0: 6b c0 38 imul $0x38,%eax,%eax 107dc3: 03 05 f8 61 12 00 add 0x1261f8,%eax rtems_libio_check_is_open(iop); 107dc9: 8b 48 14 mov 0x14(%eax),%ecx 107dcc: f6 c5 01 test $0x1,%ch 107dcf: 75 0d jne 107dde <== ALWAYS TAKEN 107dd1: e8 ba a1 00 00 call 111f90 <__errno> 107dd6: c7 00 09 00 00 00 movl $0x9,(%eax) 107ddc: eb 5b jmp 107e39 rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ); 107dde: 80 e1 02 and $0x2,%cl 107de1: 74 4b je 107e2e /* * Now process the information request. */ the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options; 107de3: 8b 40 28 mov 0x28(%eax),%eax switch ( name ) { 107de6: 83 fa 0b cmp $0xb,%edx 107de9: 77 43 ja 107e2e 107deb: ff 24 95 dc 08 12 00 jmp *0x1208dc(,%edx,4) case _PC_LINK_MAX: return_value = the_limits->link_max; 107df2: 8b 40 38 mov 0x38(%eax),%eax break; 107df5: eb 45 jmp 107e3c case _PC_MAX_CANON: return_value = the_limits->max_canon; 107df7: 8b 40 3c mov 0x3c(%eax),%eax break; 107dfa: eb 40 jmp 107e3c case _PC_MAX_INPUT: return_value = the_limits->max_input; 107dfc: 8b 40 40 mov 0x40(%eax),%eax break; 107dff: eb 3b jmp 107e3c case _PC_NAME_MAX: return_value = the_limits->name_max; 107e01: 8b 40 44 mov 0x44(%eax),%eax break; 107e04: eb 36 jmp 107e3c case _PC_PATH_MAX: return_value = the_limits->path_max; 107e06: 8b 40 48 mov 0x48(%eax),%eax break; 107e09: eb 31 jmp 107e3c case _PC_PIPE_BUF: return_value = the_limits->pipe_buf; 107e0b: 8b 40 4c mov 0x4c(%eax),%eax break; 107e0e: eb 2c jmp 107e3c case _PC_CHOWN_RESTRICTED: return_value = the_limits->posix_chown_restrictions; 107e10: 8b 40 54 mov 0x54(%eax),%eax break; 107e13: eb 27 jmp 107e3c case _PC_NO_TRUNC: return_value = the_limits->posix_no_trunc; 107e15: 8b 40 58 mov 0x58(%eax),%eax break; 107e18: eb 22 jmp 107e3c case _PC_VDISABLE: return_value = the_limits->posix_vdisable; 107e1a: 8b 40 64 mov 0x64(%eax),%eax break; 107e1d: eb 1d jmp 107e3c case _PC_ASYNC_IO: return_value = the_limits->posix_async_io; 107e1f: 8b 40 50 mov 0x50(%eax),%eax break; 107e22: eb 18 jmp 107e3c case _PC_PRIO_IO: return_value = the_limits->posix_prio_io; 107e24: 8b 40 5c mov 0x5c(%eax),%eax break; 107e27: eb 13 jmp 107e3c case _PC_SYNC_IO: return_value = the_limits->posix_sync_io; 107e29: 8b 40 60 mov 0x60(%eax),%eax break; 107e2c: eb 0e jmp 107e3c default: rtems_set_errno_and_return_minus_one( EINVAL ); 107e2e: e8 5d a1 00 00 call 111f90 <__errno> 107e33: c7 00 16 00 00 00 movl $0x16,(%eax) 107e39: 83 c8 ff or $0xffffffff,%eax break; } return return_value; } 107e3c: c9 leave 107e3d: c3 ret =============================================================================== 00107378 : #include void free( void *ptr ) { 107378: 55 push %ebp 107379: 89 e5 mov %esp,%ebp 10737b: 53 push %ebx 10737c: 83 ec 04 sub $0x4,%esp 10737f: 8b 5d 08 mov 0x8(%ebp),%ebx MSBUMP(free_calls, 1); 107382: ff 05 1c 52 12 00 incl 0x12521c if ( !ptr ) 107388: 85 db test %ebx,%ebx 10738a: 74 5f je 1073eb return; /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 10738c: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c 107393: 75 15 jne 1073aa <== NEVER TAKEN !malloc_is_system_state_OK() ) { 107395: e8 56 01 00 00 call 1074f0 return; /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 10739a: 84 c0 test %al,%al 10739c: 75 0c jne 1073aa !malloc_is_system_state_OK() ) { malloc_deferred_free(ptr); 10739e: 89 5d 08 mov %ebx,0x8(%ebp) RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end ); } } 1073a1: 8b 5d fc mov -0x4(%ebp),%ebx 1073a4: 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); 1073a5: e9 ae 01 00 00 jmp 107558 } /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 1073aa: a1 70 36 12 00 mov 0x123670,%eax 1073af: 85 c0 test %eax,%eax 1073b1: 74 0a je 1073bd (*rtems_malloc_statistics_helpers->at_free)(ptr); 1073b3: 83 ec 0c sub $0xc,%esp 1073b6: 53 push %ebx 1073b7: ff 50 08 call *0x8(%eax) 1073ba: 83 c4 10 add $0x10,%esp if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) { 1073bd: 50 push %eax 1073be: 50 push %eax 1073bf: 53 push %ebx 1073c0: ff 35 80 11 12 00 pushl 0x121180 1073c6: e8 39 46 00 00 call 10ba04 <_Protected_heap_Free> 1073cb: 83 c4 10 add $0x10,%esp 1073ce: 84 c0 test %al,%al 1073d0: 75 19 jne 1073eb printk( "Program heap: free of bad pointer %p -- range %p - %p \n", ptr, RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end 1073d2: a1 80 11 12 00 mov 0x121180,%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", 1073d7: ff 70 1c pushl 0x1c(%eax) 1073da: ff 70 18 pushl 0x18(%eax) 1073dd: 53 push %ebx 1073de: 68 87 ef 11 00 push $0x11ef87 1073e3: e8 fc 0b 00 00 call 107fe4 1073e8: 83 c4 10 add $0x10,%esp RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end ); } } 1073eb: 8b 5d fc mov -0x4(%ebp),%ebx 1073ee: c9 leave 1073ef: c3 ret =============================================================================== 00108614 : * NOTE: this must be called with * thread dispatching disabled! */ static void free_user_env(void *venv) { 108614: 55 push %ebp 108615: 89 e5 mov %esp,%ebp 108617: 53 push %ebx 108618: 83 ec 04 sub $0x4,%esp 10861b: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_user_env_t *env = (rtems_user_env_t*) venv ; if (env != &rtems_global_user_env 10861e: 81 fb 48 52 12 00 cmp $0x125248,%ebx 108624: 74 26 je 10864c <== NEVER TAKEN #ifdef HAVE_USERENV_REFCNT && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); 108626: 83 ec 0c sub $0xc,%esp 108629: 8d 43 04 lea 0x4(%ebx),%eax 10862c: 50 push %eax 10862d: e8 46 f1 ff ff call 107778 rtems_filesystem_freenode( &env->root_directory); 108632: 8d 43 18 lea 0x18(%ebx),%eax 108635: 89 04 24 mov %eax,(%esp) 108638: e8 3b f1 ff ff call 107778 free(env); 10863d: 83 c4 10 add $0x10,%esp 108640: 89 5d 08 mov %ebx,0x8(%ebp) } } 108643: 8b 5d fc mov -0x4(%ebp),%ebx 108646: c9 leave && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); rtems_filesystem_freenode( &env->root_directory); free(env); 108647: e9 40 f1 ff ff jmp 10778c } } 10864c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10864f: c9 leave <== NOT EXECUTED 108650: c3 ret <== NOT EXECUTED =============================================================================== 0011e7a8 : int getdents( int dd_fd, char *dd_buf, int dd_len ) { 11e7a8: 55 push %ebp 11e7a9: 89 e5 mov %esp,%ebp 11e7ab: 57 push %edi 11e7ac: 56 push %esi 11e7ad: 53 push %ebx 11e7ae: 83 ec 2c sub $0x2c,%esp 11e7b1: 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 ); 11e7b4: 31 db xor %ebx,%ebx 11e7b6: 3b 05 44 31 12 00 cmp 0x123144,%eax 11e7bc: 73 09 jae 11e7c7 <== NEVER TAKEN 11e7be: 6b d8 38 imul $0x38,%eax,%ebx 11e7c1: 03 1d 40 73 12 00 add 0x127340,%ebx /* * Make sure we are working on a directory */ loc = iop->pathinfo; 11e7c7: 8d 7d d4 lea -0x2c(%ebp),%edi 11e7ca: 8d 73 18 lea 0x18(%ebx),%esi 11e7cd: b9 05 00 00 00 mov $0x5,%ecx 11e7d2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) 11e7d4: 83 ec 0c sub $0xc,%esp 11e7d7: 8d 45 d4 lea -0x2c(%ebp),%eax 11e7da: 50 push %eax 11e7db: 8b 45 e0 mov -0x20(%ebp),%eax 11e7de: ff 50 10 call *0x10(%eax) 11e7e1: 83 c4 10 add $0x10,%esp 11e7e4: 48 dec %eax 11e7e5: 74 10 je 11e7f7 rtems_set_errno_and_return_minus_one( ENOTDIR ); 11e7e7: e8 d4 38 ff ff call 1120c0 <__errno> 11e7ec: c7 00 14 00 00 00 movl $0x14,(%eax) 11e7f2: 83 c8 ff or $0xffffffff,%eax 11e7f5: eb 11 jmp 11e808 /* * 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 ); 11e7f7: 50 push %eax 11e7f8: 8b 43 20 mov 0x20(%ebx),%eax 11e7fb: ff 75 10 pushl 0x10(%ebp) 11e7fe: ff 75 0c pushl 0xc(%ebp) 11e801: 53 push %ebx 11e802: ff 50 08 call *0x8(%eax) 11e805: 83 c4 10 add $0x10,%esp } 11e808: 8d 65 f4 lea -0xc(%ebp),%esp 11e80b: 5b pop %ebx 11e80c: 5e pop %esi 11e80d: 5f pop %edi 11e80e: c9 leave 11e80f: c3 ret =============================================================================== 00107f88 : struct passwd *getpwent(void) { 107f88: 55 push %ebp 107f89: 89 e5 mov %esp,%ebp 107f8b: 83 ec 08 sub $0x8,%esp if (passwd_fp == NULL) 107f8e: a1 94 6c 12 00 mov 0x126c94,%eax return NULL; 107f93: 31 d2 xor %edx,%edx return p; } struct passwd *getpwent(void) { if (passwd_fp == NULL) 107f95: 85 c0 test %eax,%eax 107f97: 74 29 je 107fc2 <== NEVER TAKEN return NULL; if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf)) 107f99: 83 ec 0c sub $0xc,%esp 107f9c: 68 c8 00 00 00 push $0xc8 107fa1: b9 b4 6c 12 00 mov $0x126cb4,%ecx 107fa6: ba 98 6c 12 00 mov $0x126c98,%edx 107fab: e8 e9 fb ff ff call 107b99 107fb0: 83 c4 10 add $0x10,%esp return NULL; 107fb3: 31 d2 xor %edx,%edx 107fb5: 85 c0 test %eax,%eax 107fb7: 0f 95 c2 setne %dl 107fba: f7 da neg %edx 107fbc: 81 e2 98 6c 12 00 and $0x126c98,%edx return &pwent; } 107fc2: 89 d0 mov %edx,%eax 107fc4: c9 leave 107fc5: c3 ret =============================================================================== 00110710 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 110710: 55 push %ebp 110711: 89 e5 mov %esp,%ebp 110713: 8b 55 08 mov 0x8(%ebp),%edx 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 ) 110716: 8b 4a 18 mov 0x18(%edx),%ecx return -1; /* It wasn't a directory --> return error */ 110719: 83 c8 ff or $0xffffffff,%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 ) 11071c: 83 79 4c 01 cmpl $0x1,0x4c(%ecx) 110720: 75 10 jne 110732 <== NEVER TAKEN return -1; /* It wasn't a directory --> return error */ iop->offset = 0; 110722: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) 110729: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) return 0; 110730: 31 c0 xor %eax,%eax } 110732: c9 leave 110733: c3 ret =============================================================================== 00110979 : int imfs_dir_rmnod( rtems_filesystem_location_info_t *parent_pathloc, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN */ ) { 110979: 55 push %ebp 11097a: 89 e5 mov %esp,%ebp 11097c: 53 push %ebx 11097d: 83 ec 04 sub $0x4,%esp 110980: 8b 45 0c mov 0xc(%ebp),%eax IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 110983: 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 ); 110985: 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 ) ) 110988: 39 53 50 cmp %edx,0x50(%ebx) 11098b: 74 0d je 11099a rtems_set_errno_and_return_minus_one( ENOTEMPTY ); 11098d: e8 a6 07 00 00 call 111138 <__errno> 110992: c7 00 5a 00 00 00 movl $0x5a,(%eax) 110998: eb 13 jmp 1109ad /* * You cannot remove the file system root node. */ if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access ) 11099a: 8b 40 10 mov 0x10(%eax),%eax 11099d: 39 58 1c cmp %ebx,0x1c(%eax) 1109a0: 75 10 jne 1109b2 rtems_set_errno_and_return_minus_one( EBUSY ); 1109a2: e8 91 07 00 00 call 111138 <__errno> 1109a7: c7 00 10 00 00 00 movl $0x10,(%eax) 1109ad: 83 c8 ff or $0xffffffff,%eax 1109b0: eb 1c jmp 1109ce /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) 1109b2: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx) 1109b6: 75 ea jne 1109a2 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EBUSY ); IMFS_create_orphan( the_jnode ); 1109b8: 83 ec 0c sub $0xc,%esp 1109bb: 53 push %ebx 1109bc: e8 1b d5 ff ff call 10dedc IMFS_check_node_remove( the_jnode ); 1109c1: 89 1c 24 mov %ebx,(%esp) 1109c4: e8 55 d5 ff ff call 10df1e return 0; 1109c9: 83 c4 10 add $0x10,%esp 1109cc: 31 c0 xor %eax,%eax } 1109ce: 8b 5d fc mov -0x4(%ebp),%ebx 1109d1: c9 leave 1109d2: c3 ret =============================================================================== 00107c9c : /* * Initialize useable but dummy databases */ void init_etc_passwd_group(void) { 107c9c: 55 push %ebp 107c9d: 89 e5 mov %esp,%ebp 107c9f: 53 push %ebx 107ca0: 83 ec 04 sub $0x4,%esp FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) 107ca3: 80 3d 7c 6d 12 00 00 cmpb $0x0,0x126d7c 107caa: 0f 85 b8 00 00 00 jne 107d68 return; etc_passwd_initted = 1; 107cb0: c6 05 7c 6d 12 00 01 movb $0x1,0x126d7c mkdir("/etc", 0777); 107cb7: 50 push %eax 107cb8: 50 push %eax 107cb9: 68 ff 01 00 00 push $0x1ff 107cbe: 68 13 08 12 00 push $0x120813 107cc3: e8 7c 07 00 00 call 108444 /* * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { 107cc8: 59 pop %ecx 107cc9: 5b pop %ebx 107cca: 68 12 f5 11 00 push $0x11f512 107ccf: 68 18 08 12 00 push $0x120818 107cd4: e8 3b aa 00 00 call 112714 107cd9: 83 c4 10 add $0x10,%esp 107cdc: 85 c0 test %eax,%eax 107cde: 74 06 je 107ce6 fclose(fp); 107ce0: 83 ec 0c sub $0xc,%esp 107ce3: 50 push %eax 107ce4: eb 2a jmp 107d10 } else if ((fp = fopen("/etc/passwd", "w")) != NULL) { 107ce6: 52 push %edx 107ce7: 52 push %edx 107ce8: 68 2c f4 11 00 push $0x11f42c 107ced: 68 18 08 12 00 push $0x120818 107cf2: e8 1d aa 00 00 call 112714 107cf7: 89 c3 mov %eax,%ebx 107cf9: 83 c4 10 add $0x10,%esp 107cfc: 85 c0 test %eax,%eax 107cfe: 74 18 je 107d18 <== NEVER TAKEN fprintf(fp, "root:*:0:0:root::/:/bin/sh\n" 107d00: 50 push %eax 107d01: 50 push %eax 107d02: 53 push %ebx 107d03: 68 24 08 12 00 push $0x120824 107d08: e8 d3 aa 00 00 call 1127e0 "rtems:*:1:1:RTEMS Application::/:/bin/sh\n" "tty:!:2:2:tty owner::/:/bin/false\n" ); fclose(fp); 107d0d: 89 1c 24 mov %ebx,(%esp) 107d10: e8 fb a2 00 00 call 112010 107d15: 83 c4 10 add $0x10,%esp } /* * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { 107d18: 51 push %ecx 107d19: 51 push %ecx 107d1a: 68 12 f5 11 00 push $0x11f512 107d1f: 68 8b 08 12 00 push $0x12088b 107d24: e8 eb a9 00 00 call 112714 107d29: 83 c4 10 add $0x10,%esp 107d2c: 85 c0 test %eax,%eax 107d2e: 74 06 je 107d36 fclose(fp); 107d30: 83 ec 0c sub $0xc,%esp 107d33: 50 push %eax 107d34: eb 2a jmp 107d60 } else if ((fp = fopen("/etc/group", "w")) != NULL) { 107d36: 52 push %edx 107d37: 52 push %edx 107d38: 68 2c f4 11 00 push $0x11f42c 107d3d: 68 8b 08 12 00 push $0x12088b 107d42: e8 cd a9 00 00 call 112714 107d47: 89 c3 mov %eax,%ebx 107d49: 83 c4 10 add $0x10,%esp 107d4c: 85 c0 test %eax,%eax 107d4e: 74 18 je 107d68 <== NEVER TAKEN fprintf( fp, "root:x:0:root\n" 107d50: 50 push %eax 107d51: 50 push %eax 107d52: 53 push %ebx 107d53: 68 96 08 12 00 push $0x120896 107d58: e8 83 aa 00 00 call 1127e0 "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); 107d5d: 89 1c 24 mov %ebx,(%esp) 107d60: e8 ab a2 00 00 call 112010 107d65: 83 c4 10 add $0x10,%esp } } 107d68: 8b 5d fc mov -0x4(%ebp),%ebx 107d6b: c9 leave 107d6c: c3 ret =============================================================================== 00108e60 : /* * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) { 108e60: 55 push %ebp 108e61: 89 e5 mov %esp,%ebp 108e63: 53 push %ebx 108e64: 83 ec 14 sub $0x14,%esp 108e67: 89 d3 mov %edx,%ebx 108e69: 88 c1 mov %al,%cl if (tty->termios.c_iflag & ISTRIP) 108e6b: 8b 52 30 mov 0x30(%edx),%edx 108e6e: f6 c2 20 test $0x20,%dl 108e71: 74 03 je 108e76 <== ALWAYS TAKEN c &= 0x7f; 108e73: 83 e1 7f and $0x7f,%ecx <== NOT EXECUTED if (tty->termios.c_iflag & IUCLC) 108e76: f6 c6 02 test $0x2,%dh 108e79: 74 16 je 108e91 c = tolower (c); 108e7b: 0f b6 c9 movzbl %cl,%ecx 108e7e: a1 3c 31 12 00 mov 0x12313c,%eax 108e83: 0f be 44 08 01 movsbl 0x1(%eax,%ecx,1),%eax 108e88: 83 e0 03 and $0x3,%eax 108e8b: 48 dec %eax 108e8c: 75 03 jne 108e91 108e8e: 83 c1 20 add $0x20,%ecx if (c == '\r') { 108e91: 80 f9 0d cmp $0xd,%cl 108e94: 75 14 jne 108eaa if (tty->termios.c_iflag & IGNCR) return 0; 108e96: 31 c0 xor %eax,%eax if (tty->termios.c_iflag & IUCLC) c = tolower (c); if (c == '\r') { if (tty->termios.c_iflag & IGNCR) 108e98: f6 c2 80 test $0x80,%dl 108e9b: 0f 85 d9 00 00 00 jne 108f7a <== NEVER TAKEN return 0; if (tty->termios.c_iflag & ICRNL) 108ea1: 80 e6 01 and $0x1,%dh 108ea4: 74 1a je 108ec0 <== NEVER TAKEN c = '\n'; 108ea6: b1 0a mov $0xa,%cl 108ea8: eb 16 jmp 108ec0 } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { 108eaa: 80 f9 0a cmp $0xa,%cl 108ead: 75 09 jne 108eb8 108eaf: 80 e2 40 and $0x40,%dl 108eb2: 74 0c je 108ec0 <== ALWAYS TAKEN c = '\r'; 108eb4: b1 0d mov $0xd,%cl <== NOT EXECUTED 108eb6: eb 08 jmp 108ec0 <== NOT EXECUTED } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 108eb8: 84 c9 test %cl,%cl 108eba: 0f 84 87 00 00 00 je 108f47 <== NEVER TAKEN 108ec0: 8b 53 3c mov 0x3c(%ebx),%edx 108ec3: f6 c2 02 test $0x2,%dl 108ec6: 74 7f je 108f47 if (c == tty->termios.c_cc[VERASE]) { 108ec8: 3a 4b 43 cmp 0x43(%ebx),%cl 108ecb: 75 04 jne 108ed1 erase (tty, 0); 108ecd: 31 d2 xor %edx,%edx 108ecf: eb 0a jmp 108edb return 0; } else if (c == tty->termios.c_cc[VKILL]) { 108ed1: 3a 4b 44 cmp 0x44(%ebx),%cl 108ed4: 75 11 jne 108ee7 erase (tty, 1); 108ed6: ba 01 00 00 00 mov $0x1,%edx 108edb: 89 d8 mov %ebx,%eax 108edd: e8 05 fe ff ff call 108ce7 108ee2: e9 91 00 00 00 jmp 108f78 return 0; } else if (c == tty->termios.c_cc[VEOF]) { return 1; 108ee7: b8 01 00 00 00 mov $0x1,%eax } else if (c == tty->termios.c_cc[VKILL]) { erase (tty, 1); return 0; } else if (c == tty->termios.c_cc[VEOF]) { 108eec: 3a 4b 45 cmp 0x45(%ebx),%cl 108eef: 0f 84 85 00 00 00 je 108f7a <== NEVER TAKEN return 1; } else if (c == '\n') { 108ef5: 80 f9 0a cmp $0xa,%cl 108ef8: 75 1a jne 108f14 if (tty->termios.c_lflag & (ECHO | ECHONL)) 108efa: 80 e2 48 and $0x48,%dl 108efd: 74 09 je 108f08 <== NEVER TAKEN echo (c, tty); 108eff: 89 da mov %ebx,%edx 108f01: b0 0a mov $0xa,%al 108f03: e8 87 fd ff ff call 108c8f tty->cbuf[tty->ccount++] = c; 108f08: 8b 43 20 mov 0x20(%ebx),%eax 108f0b: 8b 53 1c mov 0x1c(%ebx),%edx 108f0e: c6 04 02 0a movb $0xa,(%edx,%eax,1) 108f12: eb 28 jmp 108f3c return 1; } else if ((c == tty->termios.c_cc[VEOL]) || 108f14: 3a 4b 4c cmp 0x4c(%ebx),%cl 108f17: 74 05 je 108f1e <== NEVER TAKEN 108f19: 3a 4b 51 cmp 0x51(%ebx),%cl 108f1c: 75 29 jne 108f47 <== ALWAYS TAKEN (c == tty->termios.c_cc[VEOL2])) { if (tty->termios.c_lflag & ECHO) 108f1e: 80 e2 08 and $0x8,%dl <== NOT EXECUTED 108f21: 74 10 je 108f33 <== NOT EXECUTED echo (c, tty); 108f23: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 108f26: 89 da mov %ebx,%edx <== NOT EXECUTED 108f28: 88 4d f4 mov %cl,-0xc(%ebp) <== NOT EXECUTED 108f2b: e8 5f fd ff ff call 108c8f <== NOT EXECUTED 108f30: 8a 4d f4 mov -0xc(%ebp),%cl <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 108f33: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 108f36: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED 108f39: 88 0c 02 mov %cl,(%edx,%eax,1) <== NOT EXECUTED 108f3c: 40 inc %eax 108f3d: 89 43 20 mov %eax,0x20(%ebx) return 1; 108f40: b8 01 00 00 00 mov $0x1,%eax 108f45: eb 33 jmp 108f7a } /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { 108f47: 8b 15 70 30 12 00 mov 0x123070,%edx 108f4d: 4a dec %edx if (tty->termios.c_lflag & ECHO) echo (c, tty); tty->cbuf[tty->ccount++] = c; } return 0; 108f4e: 31 c0 xor %eax,%eax } /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { 108f50: 39 53 20 cmp %edx,0x20(%ebx) 108f53: 7d 25 jge 108f7a <== NEVER TAKEN if (tty->termios.c_lflag & ECHO) 108f55: f6 43 3c 08 testb $0x8,0x3c(%ebx) 108f59: 74 10 je 108f6b <== NEVER TAKEN echo (c, tty); 108f5b: 0f b6 c1 movzbl %cl,%eax 108f5e: 89 da mov %ebx,%edx 108f60: 88 4d f4 mov %cl,-0xc(%ebp) 108f63: e8 27 fd ff ff call 108c8f 108f68: 8a 4d f4 mov -0xc(%ebp),%cl tty->cbuf[tty->ccount++] = c; 108f6b: 8b 43 20 mov 0x20(%ebx),%eax 108f6e: 8b 53 1c mov 0x1c(%ebx),%edx 108f71: 88 0c 02 mov %cl,(%edx,%eax,1) 108f74: 40 inc %eax 108f75: 89 43 20 mov %eax,0x20(%ebx) } return 0; 108f78: 31 c0 xor %eax,%eax } 108f7a: 83 c4 14 add $0x14,%esp 108f7d: 5b pop %ebx 108f7e: c9 leave 108f7f: c3 ret =============================================================================== 00121f58 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 121f58: 55 push %ebp 121f59: 89 e5 mov %esp,%ebp 121f5b: 57 push %edi 121f5c: 56 push %esi 121f5d: 53 push %ebx 121f5e: 83 ec 4c sub $0x4c,%esp 121f61: 8b 5d 0c mov 0xc(%ebp),%ebx 121f64: 8b 7d 10 mov 0x10(%ebp),%edi POSIX_signals_Siginfo_node *psiginfo; /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 121f67: e8 64 fd ff ff call 121cd0 121f6c: 39 45 08 cmp %eax,0x8(%ebp) 121f6f: 74 0d je 121f7e rtems_set_errno_and_return_minus_one( ESRCH ); 121f71: e8 5a 3a ff ff call 1159d0 <__errno> 121f76: c7 00 03 00 00 00 movl $0x3,(%eax) 121f7c: eb 0f jmp 121f8d /* * Validate the signal passed. */ if ( !sig ) 121f7e: 85 db test %ebx,%ebx 121f80: 75 13 jne 121f95 rtems_set_errno_and_return_minus_one( EINVAL ); 121f82: e8 49 3a ff ff call 1159d0 <__errno> 121f87: c7 00 16 00 00 00 movl $0x16,(%eax) 121f8d: 83 c8 ff or $0xffffffff,%eax 121f90: e9 ef 01 00 00 jmp 122184 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 121f95: 8d 4b ff lea -0x1(%ebx),%ecx if ( !is_valid_signo(sig) ) 121f98: 83 f9 1f cmp $0x1f,%ecx 121f9b: 77 e5 ja 121f82 rtems_set_errno_and_return_minus_one( EINVAL ); /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) 121f9d: 6b d3 0c imul $0xc,%ebx,%edx return 0; 121fa0: 31 c0 xor %eax,%eax rtems_set_errno_and_return_minus_one( EINVAL ); /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) 121fa2: 83 ba 18 ba 12 00 01 cmpl $0x1,0x12ba18(%edx) 121fa9: 0f 84 d5 01 00 00 je 122184 /* * P1003.1c/Draft 10, p. 33 says that certain signals should always * be directed to the executing thread such as those caused by hardware * faults. */ if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) ) 121faf: 83 fb 04 cmp $0x4,%ebx 121fb2: 74 0a je 121fbe 121fb4: 83 fb 08 cmp $0x8,%ebx 121fb7: 74 05 je 121fbe 121fb9: 83 fb 0b cmp $0xb,%ebx 121fbc: 75 16 jne 121fd4 return pthread_kill( pthread_self(), sig ); 121fbe: e8 85 03 00 00 call 122348 121fc3: 56 push %esi 121fc4: 56 push %esi 121fc5: 53 push %ebx 121fc6: 50 push %eax 121fc7: e8 d8 02 00 00 call 1222a4 121fcc: 83 c4 10 add $0x10,%esp 121fcf: e9 b0 01 00 00 jmp 122184 static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 121fd4: be 01 00 00 00 mov $0x1,%esi 121fd9: d3 e6 shl %cl,%esi /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 121fdb: 89 5d dc mov %ebx,-0x24(%ebp) siginfo->si_code = SI_USER; 121fde: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) if ( !value ) { 121fe5: 85 ff test %edi,%edi 121fe7: 75 09 jne 121ff2 siginfo->si_value.sival_int = 0; 121fe9: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 121ff0: eb 05 jmp 121ff7 } else { siginfo->si_value = *value; 121ff2: 8b 07 mov (%edi),%eax 121ff4: 89 45 e4 mov %eax,-0x1c(%ebp) 121ff7: a1 b4 b4 12 00 mov 0x12b4b4,%eax 121ffc: 40 inc %eax 121ffd: a3 b4 b4 12 00 mov %eax,0x12b4b4 /* * Is the currently executing thread interested? If so then it will * get it an execute it as soon as the dispatcher executes. */ the_thread = _Thread_Executing; 122002: a1 dc b9 12 00 mov 0x12b9dc,%eax api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 122007: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx 12200d: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx 122013: f7 d2 not %edx 122015: 85 d6 test %edx,%esi 122017: 0f 85 ed 00 00 00 jne 12210a } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); return 0; } 12201d: 8b 15 9c bb 12 00 mov 0x12bb9c,%edx /* XXX violation of visibility -- need to define thread queue support */ the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); 122023: eb 23 jmp 122048 !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; 122025: 89 d0 mov %edx,%eax api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 122027: 8b 8a ec 00 00 00 mov 0xec(%edx),%ecx #endif /* * Is this thread is actually blocked waiting for the signal? */ if (the_thread->Wait.option & mask) 12202d: 85 72 30 test %esi,0x30(%edx) 122030: 0f 85 d4 00 00 00 jne 12210a /* * Is this thread is blocked waiting for another signal but has * not blocked this one? */ if (~api->signals_blocked & mask) 122036: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx 12203c: f7 d1 not %ecx 12203e: 85 ce test %ecx,%esi 122040: 0f 85 c4 00 00 00 jne 12210a the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 122046: 8b 12 mov (%edx),%edx /* XXX violation of visibility -- need to define thread queue support */ the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = _Chain_First( the_chain ); 122048: 81 fa a0 bb 12 00 cmp $0x12bba0,%edx 12204e: 75 d5 jne 122025 * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 122050: 0f b6 0d 24 72 12 00 movzbl 0x127224,%ecx 122057: 41 inc %ecx * * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; 122058: 31 c0 xor %eax,%eax interested_priority = PRIORITY_MAXIMUM + 1; for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { 12205a: c7 45 cc 02 00 00 00 movl $0x2,-0x34(%ebp) /* * This can occur when no one is interested and an API is not configured. */ if ( !_Objects_Information_table[ the_api ] ) 122061: 8b 7d cc mov -0x34(%ebp),%edi 122064: 8b 14 bd 8c b4 12 00 mov 0x12b48c(,%edi,4),%edx 12206b: 85 d2 test %edx,%edx 12206d: 0f 84 86 00 00 00 je 1220f9 <== NEVER TAKEN continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 122073: 8b 52 04 mov 0x4(%edx),%edx */ if ( !the_info ) continue; #endif maximum = the_info->maximum; 122076: 0f b7 7a 10 movzwl 0x10(%edx),%edi 12207a: 89 7d c4 mov %edi,-0x3c(%ebp) object_table = the_info->local_table; 12207d: 8b 52 1c mov 0x1c(%edx),%edx 122080: 89 55 c0 mov %edx,-0x40(%ebp) for ( index = 1 ; index <= maximum ; index++ ) { 122083: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp) 12208a: 89 5d b4 mov %ebx,-0x4c(%ebp) 12208d: eb 5f jmp 1220ee the_thread = (Thread_Control *) object_table[ index ]; 12208f: 8b 5d d0 mov -0x30(%ebp),%ebx 122092: 8b 7d c0 mov -0x40(%ebp),%edi 122095: 8b 14 9f mov (%edi,%ebx,4),%edx if ( !the_thread ) 122098: 85 d2 test %edx,%edx 12209a: 74 4f je 1220eb /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 12209c: 8b 5a 14 mov 0x14(%edx),%ebx 12209f: 89 5d d4 mov %ebx,-0x2c(%ebp) 1220a2: 39 cb cmp %ecx,%ebx 1220a4: 77 45 ja 1220eb #if defined(RTEMS_DEBUG) if ( !api ) continue; #endif if ( !_POSIX_signals_Is_interested( api, mask ) ) 1220a6: 8b ba ec 00 00 00 mov 0xec(%edx),%edi 1220ac: 8b bf d0 00 00 00 mov 0xd0(%edi),%edi 1220b2: f7 d7 not %edi 1220b4: 85 fe test %edi,%esi 1220b6: 74 33 je 1220eb * * NOTE: We initialized interested_priority to PRIORITY_MAXIMUM + 1 * so we never have to worry about deferencing a NULL * interested thread. */ if ( the_thread->current_priority < interested_priority ) { 1220b8: 39 cb cmp %ecx,%ebx 1220ba: 72 2a jb 1220e6 * and blocking interruptibutable by signal. * * If the interested thread is ready, don't think about changing. */ if ( interested && !_States_Is_ready( interested->current_state ) ) { 1220bc: 85 c0 test %eax,%eax 1220be: 74 2b je 1220eb <== NEVER TAKEN 1220c0: 8b 78 10 mov 0x10(%eax),%edi 1220c3: 89 7d c8 mov %edi,-0x38(%ebp) 1220c6: 85 ff test %edi,%edi 1220c8: 74 21 je 1220eb <== NEVER TAKEN /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 1220ca: 8b 7a 10 mov 0x10(%edx),%edi 1220cd: 85 ff test %edi,%edi 1220cf: 74 15 je 1220e6 continue; } DEBUG_STEP("6"); /* prefer blocked/interruptible over blocked/not interruptible */ if ( !_States_Is_interruptible_by_signal(interested->current_state) ) { 1220d1: f7 45 c8 00 00 00 10 testl $0x10000000,-0x38(%ebp) 1220d8: 75 11 jne 1220eb DEBUG_STEP("7"); if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) { 1220da: 81 e7 00 00 00 10 and $0x10000000,%edi 1220e0: 74 09 je 1220eb 1220e2: 89 d9 mov %ebx,%ecx 1220e4: eb 03 jmp 1220e9 */ if ( interested && !_States_Is_ready( interested->current_state ) ) { /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 1220e6: 8b 4d d4 mov -0x2c(%ebp),%ecx 1220e9: 89 d0 mov %edx,%eax #endif maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 1220eb: ff 45 d0 incl -0x30(%ebp) 1220ee: 8b 55 c4 mov -0x3c(%ebp),%edx 1220f1: 39 55 d0 cmp %edx,-0x30(%ebp) 1220f4: 76 99 jbe 12208f 1220f6: 8b 5d b4 mov -0x4c(%ebp),%ebx * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { 1220f9: ff 45 cc incl -0x34(%ebp) 1220fc: 83 7d cc 04 cmpl $0x4,-0x34(%ebp) 122100: 0f 85 5b ff ff ff jne 122061 } } } } if ( interested ) { 122106: 85 c0 test %eax,%eax 122108: 74 13 je 12211d /* * Returns true if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { 12210a: 51 push %ecx mask = signo_to_mask( sig ); /* * Build up a siginfo structure */ siginfo = &siginfo_struct; 12210b: 8d 55 dc lea -0x24(%ebp),%edx /* * Returns true if the signal was synchronously given to a thread * blocked waiting for the signal. */ if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) { 12210e: 52 push %edx 12210f: 53 push %ebx 122110: 50 push %eax 122111: e8 8a 00 00 00 call 1221a0 <_POSIX_signals_Unblock_thread> 122116: 83 c4 10 add $0x10,%esp 122119: 84 c0 test %al,%al 12211b: 75 60 jne 12217d /* * We may have woken up a thread but we definitely need to post the * signal to the process wide information set. */ _POSIX_signals_Set_process_signals( mask ); 12211d: 83 ec 0c sub $0xc,%esp 122120: 56 push %esi 122121: e8 66 00 00 00 call 12218c <_POSIX_signals_Set_process_signals> if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 122126: 6b db 0c imul $0xc,%ebx,%ebx 122129: 83 c4 10 add $0x10,%esp 12212c: 83 bb 10 ba 12 00 02 cmpl $0x2,0x12ba10(%ebx) 122133: 75 48 jne 12217d psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get( &_POSIX_signals_Inactive_siginfo ); 122135: 83 ec 0c sub $0xc,%esp 122138: 68 90 bb 12 00 push $0x12bb90 12213d: e8 4e d0 fe ff call 10f190 <_Chain_Get> if ( !psiginfo ) { 122142: 83 c4 10 add $0x10,%esp 122145: 85 c0 test %eax,%eax 122147: 75 15 jne 12215e _Thread_Enable_dispatch(); 122149: e8 6c e8 fe ff call 1109ba <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 12214e: e8 7d 38 ff ff call 1159d0 <__errno> 122153: c7 00 0b 00 00 00 movl $0xb,(%eax) 122159: e9 2f fe ff ff jmp 121f8d } psiginfo->Info = *siginfo; 12215e: 8d 78 08 lea 0x8(%eax),%edi 122161: 8d 75 dc lea -0x24(%ebp),%esi 122164: b9 03 00 00 00 mov $0x3,%ecx 122169: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 12216b: 52 push %edx 12216c: 52 push %edx 12216d: 50 push %eax 12216e: 81 c3 08 bc 12 00 add $0x12bc08,%ebx 122174: 53 push %ebx 122175: e8 da cf fe ff call 10f154 <_Chain_Append> 12217a: 83 c4 10 add $0x10,%esp } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); 12217d: e8 38 e8 fe ff call 1109ba <_Thread_Enable_dispatch> return 0; 122182: 31 c0 xor %eax,%eax } 122184: 8d 65 f4 lea -0xc(%ebp),%esp 122187: 5b pop %ebx 122188: 5e pop %esi 122189: 5f pop %edi 12218a: c9 leave 12218b: c3 ret =============================================================================== 0011d094 : extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) { 11d094: 55 push %ebp 11d095: 89 e5 mov %esp,%ebp 11d097: 53 push %ebx 11d098: 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())) 11d09b: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c 11d0a2: 75 4f jne 11d0f3 <== NEVER TAKEN /* * This was already done if the user called exit() directly . _wrapup_reent(0); */ if (_REENT != _global_impure_ptr) { 11d0a4: 8b 1d 80 fa 11 00 mov 0x11fa80,%ebx 11d0aa: 39 1d 40 31 12 00 cmp %ebx,0x123140 11d0b0: 74 12 je 11d0c4 _wrapup_reent(_global_impure_ptr); 11d0b2: 83 ec 0c sub $0xc,%esp 11d0b5: 53 push %ebx 11d0b6: e8 b5 05 00 00 call 11d670 <_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; 11d0bb: 89 1d 40 31 12 00 mov %ebx,0x123140 11d0c1: 83 c4 10 add $0x10,%esp * * Should this be changed to do *all* file streams? * _fwalk (_REENT, fclose); */ fclose (stdin); 11d0c4: 83 ec 0c sub $0xc,%esp 11d0c7: a1 40 31 12 00 mov 0x123140,%eax 11d0cc: ff 70 04 pushl 0x4(%eax) 11d0cf: e8 bc 41 ff ff call 111290 fclose (stdout); 11d0d4: 5a pop %edx 11d0d5: a1 40 31 12 00 mov 0x123140,%eax 11d0da: ff 70 08 pushl 0x8(%eax) 11d0dd: e8 ae 41 ff ff call 111290 fclose (stderr); 11d0e2: 58 pop %eax 11d0e3: a1 40 31 12 00 mov 0x123140,%eax 11d0e8: ff 70 0c pushl 0xc(%eax) 11d0eb: e8 a0 41 ff ff call 111290 11d0f0: 83 c4 10 add $0x10,%esp } 11d0f3: 8b 5d fc mov -0x4(%ebp),%ebx 11d0f6: c9 leave 11d0f7: c3 ret =============================================================================== 0011cfa0 : off_t lseek( int fd, off_t offset, int whence ) { 11cfa0: 55 push %ebp 11cfa1: 89 e5 mov %esp,%ebp 11cfa3: 57 push %edi 11cfa4: 56 push %esi 11cfa5: 53 push %ebx 11cfa6: 83 ec 1c sub $0x1c,%esp 11cfa9: 8b 5d 08 mov 0x8(%ebp),%ebx 11cfac: 8b 45 0c mov 0xc(%ebp),%eax 11cfaf: 8b 55 10 mov 0x10(%ebp),%edx 11cfb2: 8b 4d 14 mov 0x14(%ebp),%ecx rtems_libio_t *iop; off_t old_offset; off_t status; rtems_libio_check_fd( fd ); 11cfb5: 3b 1d 44 11 12 00 cmp 0x121144,%ebx 11cfbb: 73 0f jae 11cfcc iop = rtems_libio_iop( fd ); 11cfbd: 6b db 38 imul $0x38,%ebx,%ebx 11cfc0: 03 1d f8 51 12 00 add 0x1251f8,%ebx rtems_libio_check_is_open(iop); 11cfc6: f6 43 15 01 testb $0x1,0x15(%ebx) 11cfca: 75 0d jne 11cfd9 11cfcc: e8 67 41 ff ff call 111138 <__errno> 11cfd1: c7 00 09 00 00 00 movl $0x9,(%eax) 11cfd7: eb 4b jmp 11d024 /* * Now process the lseek(). */ old_offset = iop->offset; 11cfd9: 8b 73 0c mov 0xc(%ebx),%esi 11cfdc: 8b 7b 10 mov 0x10(%ebx),%edi 11cfdf: 89 75 e0 mov %esi,-0x20(%ebp) 11cfe2: 89 7d e4 mov %edi,-0x1c(%ebp) switch ( whence ) { 11cfe5: 83 f9 01 cmp $0x1,%ecx 11cfe8: 74 11 je 11cffb 11cfea: 83 f9 02 cmp $0x2,%ecx 11cfed: 74 18 je 11d007 11cfef: 85 c9 test %ecx,%ecx 11cff1: 75 26 jne 11d019 case SEEK_SET: iop->offset = offset; 11cff3: 89 43 0c mov %eax,0xc(%ebx) 11cff6: 89 53 10 mov %edx,0x10(%ebx) break; 11cff9: eb 30 jmp 11d02b case SEEK_CUR: iop->offset += offset; 11cffb: 8b 75 e0 mov -0x20(%ebp),%esi 11cffe: 8b 7d e4 mov -0x1c(%ebp),%edi 11d001: 01 c6 add %eax,%esi 11d003: 11 d7 adc %edx,%edi 11d005: eb 0a jmp 11d011 break; case SEEK_END: iop->offset = iop->size + offset; 11d007: 89 c6 mov %eax,%esi 11d009: 89 d7 mov %edx,%edi 11d00b: 03 73 04 add 0x4(%ebx),%esi 11d00e: 13 7b 08 adc 0x8(%ebx),%edi 11d011: 89 73 0c mov %esi,0xc(%ebx) 11d014: 89 7b 10 mov %edi,0x10(%ebx) break; 11d017: eb 12 jmp 11d02b default: rtems_set_errno_and_return_minus_one( EINVAL ); 11d019: e8 1a 41 ff ff call 111138 <__errno> 11d01e: c7 00 16 00 00 00 movl $0x16,(%eax) 11d024: 83 c8 ff or $0xffffffff,%eax 11d027: 89 c2 mov %eax,%edx 11d029: eb 23 jmp 11d04e /* * At this time, handlers assume iop->offset has the desired * new offset. */ status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence ); 11d02b: 8b 73 20 mov 0x20(%ebx),%esi 11d02e: 51 push %ecx 11d02f: 52 push %edx 11d030: 50 push %eax 11d031: 53 push %ebx 11d032: ff 56 14 call *0x14(%esi) if ( status == (off_t) -1 ) 11d035: 83 c4 10 add $0x10,%esp 11d038: 83 fa ff cmp $0xffffffff,%edx 11d03b: 75 11 jne 11d04e 11d03d: 83 f8 ff cmp $0xffffffff,%eax 11d040: 75 0c jne 11d04e <== NEVER TAKEN iop->offset = old_offset; 11d042: 8b 75 e0 mov -0x20(%ebp),%esi 11d045: 8b 7d e4 mov -0x1c(%ebp),%edi 11d048: 89 73 0c mov %esi,0xc(%ebx) 11d04b: 89 7b 10 mov %edi,0x10(%ebx) /* * So if the operation failed, we have to restore iop->offset. */ return status; } 11d04e: 8d 65 f4 lea -0xc(%ebp),%esp 11d051: 5b pop %ebx 11d052: 5e pop %esi 11d053: 5f pop %edi 11d054: c9 leave 11d055: c3 ret =============================================================================== 00107614 : #include "malloc_p.h" void *malloc( size_t size ) { 107614: 55 push %ebp 107615: 89 e5 mov %esp,%ebp 107617: 56 push %esi 107618: 53 push %ebx 107619: 8b 75 08 mov 0x8(%ebp),%esi void *return_this; MSBUMP(malloc_calls, 1); 10761c: ff 05 14 52 12 00 incl 0x125214 /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 107622: e8 07 ff ff ff call 10752e /* * Validate the parameters */ if ( !size ) return (void *) 0; 107627: 31 db xor %ebx,%ebx malloc_deferred_frees_process(); /* * Validate the parameters */ if ( !size ) 107629: 85 f6 test %esi,%esi 10762b: 74 78 je 1076a5 return (void *) 0; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 10762d: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c 107634: 75 09 jne 10763f !malloc_is_system_state_OK() ) 107636: e8 b5 fe ff ff call 1074f0 return (void *) 0; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 10763b: 84 c0 test %al,%al 10763d: 74 66 je 1076a5 <== NEVER TAKEN RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate( Heap_Control *heap, uintptr_t size ) { return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 ); 10763f: 6a 00 push $0x0 107641: 6a 00 push $0x0 107643: 56 push %esi 107644: ff 35 80 11 12 00 pushl 0x121180 10764a: e8 7d 43 00 00 call 10b9cc <_Protected_heap_Allocate_aligned_with_boundary> * If this fails then return a NULL pointer. */ return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); if ( !return_this ) { 10764f: 83 c4 10 add $0x10,%esp 107652: 89 c3 mov %eax,%ebx 107654: 85 c0 test %eax,%eax 107656: 75 28 jne 107680 if (rtems_malloc_sbrk_helpers) 107658: a1 74 36 12 00 mov 0x123674,%eax 10765d: 85 c0 test %eax,%eax 10765f: 74 10 je 107671 return_this = (*rtems_malloc_sbrk_helpers->extend)( size ); 107661: 83 ec 0c sub $0xc,%esp 107664: 56 push %esi 107665: ff 50 04 call *0x4(%eax) 107668: 89 c3 mov %eax,%ebx if ( !return_this ) { 10766a: 83 c4 10 add $0x10,%esp 10766d: 85 c0 test %eax,%eax 10766f: 75 0f jne 107680 errno = ENOMEM; 107671: e8 c2 9a 00 00 call 111138 <__errno> 107676: c7 00 0c 00 00 00 movl $0xc,(%eax) return (void *) 0; 10767c: 31 db xor %ebx,%ebx 10767e: eb 25 jmp 1076a5 } /* * If the user wants us to dirty the allocated memory, then do it. */ if ( rtems_malloc_dirty_helper ) 107680: a1 78 36 12 00 mov 0x123678,%eax 107685: 85 c0 test %eax,%eax 107687: 74 09 je 107692 (*rtems_malloc_dirty_helper)( return_this, size ); 107689: 52 push %edx 10768a: 52 push %edx 10768b: 56 push %esi 10768c: 53 push %ebx 10768d: ff d0 call *%eax 10768f: 83 c4 10 add $0x10,%esp /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 107692: a1 70 36 12 00 mov 0x123670,%eax 107697: 85 c0 test %eax,%eax 107699: 74 0a je 1076a5 (*rtems_malloc_statistics_helpers->at_malloc)(return_this); 10769b: 83 ec 0c sub $0xc,%esp 10769e: 53 push %ebx 10769f: ff 50 04 call *0x4(%eax) 1076a2: 83 c4 10 add $0x10,%esp return return_this; } 1076a5: 89 d8 mov %ebx,%eax 1076a7: 8d 65 f8 lea -0x8(%ebp),%esp 1076aa: 5b pop %ebx 1076ab: 5e pop %esi 1076ac: c9 leave 1076ad: c3 ret =============================================================================== 0010797c : } void *malloc_sbrk_extend_and_allocate( size_t size ) { 10797c: 55 push %ebp 10797d: 89 e5 mov %esp,%ebp 10797f: 57 push %edi 107980: 56 push %esi 107981: 53 push %ebx 107982: 83 ec 0c sub $0xc,%esp 107985: 8b 7d 08 mov 0x8(%ebp),%edi * 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; 107988: 8b 0d 94 53 12 00 mov 0x125394,%ecx if ( sbrk_amount == 0 ) return (void *) 0; 10798e: 31 f6 xor %esi,%esi * in "page" amounts. */ sbrk_amount = RTEMS_Malloc_Sbrk_amount; if ( sbrk_amount == 0 ) 107990: 85 c9 test %ecx,%ecx 107992: 74 67 je 1079fb <== NEVER TAKEN return (void *) 0; the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount); 107994: 8d 1c 0f lea (%edi,%ecx,1),%ebx 107997: 89 d8 mov %ebx,%eax 107999: 31 d2 xor %edx,%edx 10799b: f7 f1 div %ecx 10799d: 89 c3 mov %eax,%ebx 10799f: 0f af d9 imul %ecx,%ebx starting_address = (void *) sbrk(the_size); 1079a2: 83 ec 0c sub $0xc,%esp 1079a5: 53 push %ebx 1079a6: e8 a8 8a ff ff call 100453 if ( starting_address == (void*) -1 ) 1079ab: 83 c4 10 add $0x10,%esp 1079ae: 83 f8 ff cmp $0xffffffff,%eax 1079b1: 74 48 je 1079fb return (void *) 0; if ( !_Protected_heap_Extend( 1079b3: 52 push %edx 1079b4: 53 push %ebx 1079b5: 50 push %eax 1079b6: ff 35 80 11 12 00 pushl 0x121180 1079bc: e8 a3 43 00 00 call 10bd64 <_Protected_heap_Extend> 1079c1: 83 c4 10 add $0x10,%esp 1079c4: 84 c0 test %al,%al 1079c6: 75 18 jne 1079e0 RTEMS_Malloc_Heap, starting_address, the_size) ) { sbrk(-the_size); 1079c8: 83 ec 0c sub $0xc,%esp 1079cb: f7 db neg %ebx 1079cd: 53 push %ebx 1079ce: e8 80 8a ff ff call 100453 errno = ENOMEM; 1079d3: e8 38 9d 00 00 call 111710 <__errno> 1079d8: c7 00 0c 00 00 00 movl $0xc,(%eax) 1079de: eb 18 jmp 1079f8 return (void *) 0; } MSBUMP(space_available, the_size); 1079e0: 01 1d 68 53 12 00 add %ebx,0x125368 1079e6: 6a 00 push $0x0 1079e8: 6a 00 push $0x0 1079ea: 57 push %edi 1079eb: ff 35 80 11 12 00 pushl 0x121180 1079f1: e8 36 43 00 00 call 10bd2c <_Protected_heap_Allocate_aligned_with_boundary> 1079f6: 89 c6 mov %eax,%esi return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); return return_this; 1079f8: 83 c4 10 add $0x10,%esp } 1079fb: 89 f0 mov %esi,%eax 1079fd: 8d 65 f4 lea -0xc(%ebp),%esp 107a00: 5b pop %ebx 107a01: 5e pop %esi 107a02: 5f pop %edi 107a03: c9 leave 107a04: c3 ret =============================================================================== 0011041b : */ int memfile_ftruncate( rtems_libio_t *iop, rtems_off64_t length ) { 11041b: 55 push %ebp 11041c: 89 e5 mov %esp,%ebp 11041e: 53 push %ebx 11041f: 83 ec 14 sub $0x14,%esp 110422: 8b 4d 08 mov 0x8(%ebp),%ecx 110425: 8b 45 0c mov 0xc(%ebp),%eax 110428: 8b 55 10 mov 0x10(%ebp),%edx IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 11042b: 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 ) 11042e: 3b 53 54 cmp 0x54(%ebx),%edx 110431: 7c 15 jl 110448 <== NEVER TAKEN 110433: 7f 05 jg 11043a <== NEVER TAKEN 110435: 3b 43 50 cmp 0x50(%ebx),%eax 110438: 76 0e jbe 110448 return IMFS_memfile_extend( the_jnode, length ); 11043a: 51 push %ecx 11043b: 52 push %edx 11043c: 50 push %eax 11043d: 53 push %ebx 11043e: e8 bf fc ff ff call 110102 110443: 83 c4 10 add $0x10,%esp 110446: eb 24 jmp 11046c /* * 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; 110448: 89 43 50 mov %eax,0x50(%ebx) 11044b: 89 53 54 mov %edx,0x54(%ebx) iop->size = the_jnode->info.file.size; 11044e: 89 41 04 mov %eax,0x4(%ecx) 110451: 89 51 08 mov %edx,0x8(%ecx) IMFS_update_atime( the_jnode ); 110454: 50 push %eax 110455: 50 push %eax 110456: 6a 00 push $0x0 110458: 8d 45 f0 lea -0x10(%ebp),%eax 11045b: 50 push %eax 11045c: e8 8f 6f ff ff call 1073f0 110461: 8b 45 f0 mov -0x10(%ebp),%eax 110464: 89 43 40 mov %eax,0x40(%ebx) return 0; 110467: 83 c4 10 add $0x10,%esp 11046a: 31 c0 xor %eax,%eax } 11046c: 8b 5d fc mov -0x4(%ebp),%ebx 11046f: c9 leave 110470: c3 ret =============================================================================== 00110471 : rtems_off64_t memfile_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) { 110471: 55 push %ebp 110472: 89 e5 mov %esp,%ebp 110474: 56 push %esi 110475: 53 push %ebx 110476: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 110479: 8b 73 18 mov 0x18(%ebx),%esi if (the_jnode->type == IMFS_LINEAR_FILE) { 11047c: 83 7e 4c 06 cmpl $0x6,0x4c(%esi) 110480: 75 1a jne 11049c if (iop->offset > the_jnode->info.linearfile.size) 110482: 8b 56 50 mov 0x50(%esi),%edx 110485: 8b 46 54 mov 0x54(%esi),%eax 110488: 39 43 10 cmp %eax,0x10(%ebx) 11048b: 7c 41 jl 1104ce <== NEVER TAKEN 11048d: 7f 05 jg 110494 <== NEVER TAKEN 11048f: 39 53 0c cmp %edx,0xc(%ebx) 110492: 76 3a jbe 1104ce <== ALWAYS TAKEN iop->offset = the_jnode->info.linearfile.size; 110494: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED 110497: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED 11049a: eb 32 jmp 1104ce <== NOT EXECUTED } else { /* Must be a block file (IMFS_MEMORY_FILE). */ if (IMFS_memfile_extend( the_jnode, iop->offset )) 11049c: 50 push %eax 11049d: ff 73 10 pushl 0x10(%ebx) 1104a0: ff 73 0c pushl 0xc(%ebx) 1104a3: 56 push %esi 1104a4: e8 59 fc ff ff call 110102 1104a9: 83 c4 10 add $0x10,%esp 1104ac: 85 c0 test %eax,%eax 1104ae: 74 12 je 1104c2 rtems_set_errno_and_return_minus_one( ENOSPC ); 1104b0: e8 83 0c 00 00 call 111138 <__errno> 1104b5: c7 00 1c 00 00 00 movl $0x1c,(%eax) 1104bb: 83 c8 ff or $0xffffffff,%eax 1104be: 89 c2 mov %eax,%edx 1104c0: eb 12 jmp 1104d4 iop->size = the_jnode->info.file.size; 1104c2: 8b 46 50 mov 0x50(%esi),%eax 1104c5: 8b 56 54 mov 0x54(%esi),%edx 1104c8: 89 43 04 mov %eax,0x4(%ebx) 1104cb: 89 53 08 mov %edx,0x8(%ebx) } return iop->offset; 1104ce: 8b 43 0c mov 0xc(%ebx),%eax 1104d1: 8b 53 10 mov 0x10(%ebx),%edx } 1104d4: 8d 65 f8 lea -0x8(%ebp),%esp 1104d7: 5b pop %ebx 1104d8: 5e pop %esi 1104d9: c9 leave 1104da: c3 ret =============================================================================== 0011038c : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 11038c: 55 push %ebp 11038d: 89 e5 mov %esp,%ebp 11038f: 56 push %esi 110390: 53 push %ebx 110391: 8b 75 08 mov 0x8(%ebp),%esi IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 110394: 8b 5e 18 mov 0x18(%esi),%ebx /* * Perform 'copy on write' for linear files */ if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND)) 110397: f7 46 14 04 02 00 00 testl $0x204,0x14(%esi) 11039e: 74 54 je 1103f4 && (the_jnode->type == IMFS_LINEAR_FILE)) { 1103a0: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) 1103a4: 75 4e jne 1103f4 <== ALWAYS TAKEN uint32_t count = the_jnode->info.linearfile.size; 1103a6: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED const unsigned char *buffer = the_jnode->info.linearfile.direct; 1103a9: 8b 53 58 mov 0x58(%ebx),%edx <== NOT EXECUTED the_jnode->type = IMFS_MEMORY_FILE; 1103ac: c7 43 4c 05 00 00 00 movl $0x5,0x4c(%ebx) <== NOT EXECUTED the_jnode->info.file.size = 0; 1103b3: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED 1103ba: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED the_jnode->info.file.indirect = 0; 1103c1: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED the_jnode->info.file.doubly_indirect = 0; 1103c8: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED the_jnode->info.file.triply_indirect = 0; 1103cf: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED if ((count != 0) 1103d6: 85 c0 test %eax,%eax <== NOT EXECUTED 1103d8: 74 1a je 1103f4 <== NOT EXECUTED && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) 1103da: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1103dd: 50 push %eax <== NOT EXECUTED 1103de: 52 push %edx <== NOT EXECUTED 1103df: 6a 00 push $0x0 <== NOT EXECUTED 1103e1: 6a 00 push $0x0 <== NOT EXECUTED 1103e3: 53 push %ebx <== NOT EXECUTED 1103e4: e8 0b fe ff ff call 1101f4 <== NOT EXECUTED 1103e9: 89 c2 mov %eax,%edx <== NOT EXECUTED 1103eb: 83 c4 20 add $0x20,%esp <== NOT EXECUTED return -1; 1103ee: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 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)) 1103f1: 42 inc %edx <== NOT EXECUTED 1103f2: 74 20 je 110414 <== NOT EXECUTED return -1; } if (iop->flags & LIBIO_FLAGS_APPEND) 1103f4: f6 46 15 02 testb $0x2,0x15(%esi) 1103f8: 74 0c je 110406 iop->offset = the_jnode->info.file.size; 1103fa: 8b 43 50 mov 0x50(%ebx),%eax 1103fd: 8b 53 54 mov 0x54(%ebx),%edx 110400: 89 46 0c mov %eax,0xc(%esi) 110403: 89 56 10 mov %edx,0x10(%esi) iop->size = the_jnode->info.file.size; 110406: 8b 43 50 mov 0x50(%ebx),%eax 110409: 8b 53 54 mov 0x54(%ebx),%edx 11040c: 89 46 04 mov %eax,0x4(%esi) 11040f: 89 56 08 mov %edx,0x8(%esi) return 0; 110412: 31 c0 xor %eax,%eax } 110414: 8d 65 f8 lea -0x8(%ebp),%esp 110417: 5b pop %ebx 110418: 5e pop %esi 110419: c9 leave 11041a: c3 ret =============================================================================== 00107809 : const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { 107809: 55 push %ebp 10780a: 89 e5 mov %esp,%ebp 10780c: 57 push %edi 10780d: 56 push %esi 10780e: 53 push %ebx 10780f: 83 ec 4c sub $0x4c,%esp 107812: 8b 75 10 mov 0x10(%ebp),%esi /* * Are the file system options valid? */ if ( options != RTEMS_FILESYSTEM_READ_ONLY && 107815: 83 7d 14 01 cmpl $0x1,0x14(%ebp) 107819: 77 13 ja 10782e rtems_set_errno_and_return_minus_one( EINVAL ); /* * Get mount handler */ mount_h = rtems_filesystem_get_mount_handler( filesystemtype ); 10781b: 83 ec 0c sub $0xc,%esp 10781e: 56 push %esi 10781f: e8 83 6c 00 00 call 10e4a7 107824: 89 45 b0 mov %eax,-0x50(%ebp) if ( !mount_h ) 107827: 83 c4 10 add $0x10,%esp 10782a: 85 c0 test %eax,%eax 10782c: 75 10 jne 10783e rtems_set_errno_and_return_minus_one( EINVAL ); 10782e: e8 05 99 00 00 call 111138 <__errno> 107833: c7 00 16 00 00 00 movl $0x16,(%eax) 107839: e9 ca 00 00 00 jmp 107908 { 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; 10783e: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 107842: 0f 95 45 b7 setne -0x49(%ebp) const char *target_or_null, const char *filesystemtype, size_t *target_length_ptr ) { const char *target = target_or_null != NULL ? target_or_null : "/"; 107846: 8b 45 0c mov 0xc(%ebp),%eax 107849: 89 45 b8 mov %eax,-0x48(%ebp) 10784c: 80 7d b7 00 cmpb $0x0,-0x49(%ebp) 107850: 75 07 jne 107859 107852: c7 45 b8 80 ef 11 00 movl $0x11ef80,-0x48(%ebp) size_t filesystemtype_size = strlen( filesystemtype ) + 1; 107859: 83 ca ff or $0xffffffff,%edx 10785c: 31 c0 xor %eax,%eax 10785e: 89 d1 mov %edx,%ecx 107860: 89 f7 mov %esi,%edi 107862: f2 ae repnz scas %es:(%edi),%al 107864: f7 d1 not %ecx 107866: 89 4d bc mov %ecx,-0x44(%ebp) size_t source_size = source_or_null != NULL ? strlen( source_or_null ) + 1 : 0; 107869: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) 107870: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 107874: 74 0c je 107882 107876: 89 d1 mov %edx,%ecx 107878: 8b 7d 08 mov 0x8(%ebp),%edi 10787b: f2 ae repnz scas %es:(%edi),%al 10787d: f7 d1 not %ecx 10787f: 89 4d c4 mov %ecx,-0x3c(%ebp) size_t target_size = strlen( target ) + 1; 107882: 31 c0 xor %eax,%eax 107884: 83 c9 ff or $0xffffffff,%ecx 107887: 8b 7d b8 mov -0x48(%ebp),%edi 10788a: f2 ae repnz scas %es:(%edi),%al 10788c: f7 d1 not %ecx 10788e: 89 4d c0 mov %ecx,-0x40(%ebp) 107891: 49 dec %ecx 107892: 89 4d ac mov %ecx,-0x54(%ebp) 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 ); 107895: 50 push %eax 107896: 50 push %eax 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; 107897: 8b 55 c4 mov -0x3c(%ebp),%edx 10789a: 8b 7d bc mov -0x44(%ebp),%edi 10789d: 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 ) 1078a1: 03 45 c0 add -0x40(%ebp),%eax + filesystemtype_size + source_size + target_size; rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size ); 1078a4: 50 push %eax 1078a5: 6a 01 push $0x1 1078a7: e8 60 f9 ff ff call 10720c 1078ac: 89 c3 mov %eax,%ebx if ( mt_entry != NULL ) { 1078ae: 83 c4 10 add $0x10,%esp 1078b1: 85 c0 test %eax,%eax 1078b3: 74 48 je 1078fd <== NEVER TAKEN char *str = (char *) mt_entry + sizeof( *mt_entry ); 1078b5: 8d 40 74 lea 0x74(%eax),%eax memcpy( str, filesystemtype, filesystemtype_size ); 1078b8: 89 c7 mov %eax,%edi 1078ba: 8b 4d bc mov -0x44(%ebp),%ecx 1078bd: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 1078bf: 89 fa mov %edi,%edx mt_entry->type = str; 1078c1: 89 43 6c mov %eax,0x6c(%ebx) str += filesystemtype_size; memcpy( str, source_or_null, source_size ); 1078c4: 8b 75 08 mov 0x8(%ebp),%esi 1078c7: 8b 4d c4 mov -0x3c(%ebp),%ecx 1078ca: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 1078cc: 89 f8 mov %edi,%eax mt_entry->dev = str; 1078ce: 89 53 70 mov %edx,0x70(%ebx) str += source_size; memcpy( str, target, target_size ); 1078d1: 8b 75 b8 mov -0x48(%ebp),%esi 1078d4: 8b 4d c0 mov -0x40(%ebp),%ecx 1078d7: f3 a4 rep movsb %ds:(%esi),%es:(%edi) mt_entry->target = str; 1078d9: 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; 1078dc: 89 5b 2c mov %ebx,0x2c(%ebx) mt_entry->options = options; 1078df: 8b 45 14 mov 0x14(%ebp),%eax 1078e2: 89 43 30 mov %eax,0x30(%ebx) mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf; 1078e5: 8d 7b 38 lea 0x38(%ebx),%edi 1078e8: be c0 ef 11 00 mov $0x11efc0,%esi 1078ed: b1 0c mov $0xc,%cl 1078ef: 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 ) { 1078f1: 80 7d b7 00 cmpb $0x0,-0x49(%ebp) 1078f5: 0f 84 a3 00 00 00 je 10799e 1078fb: eb 13 jmp 107910 target, filesystemtype, &target_length ); if ( !mt_entry ) rtems_set_errno_and_return_minus_one( ENOMEM ); 1078fd: e8 36 98 00 00 call 111138 <__errno> <== NOT EXECUTED 107902: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 107908: 83 c8 ff or $0xffffffff,%eax 10790b: e9 26 01 00 00 jmp 107a36 * The mount_point should be a directory with read/write/execute * permissions in the existing tree. */ if ( has_target ) { if ( rtems_filesystem_evaluate_path( 107910: 83 ec 0c sub $0xc,%esp 107913: 6a 01 push $0x1 107915: 8d 75 d4 lea -0x2c(%ebp),%esi 107918: 56 push %esi 107919: 6a 07 push $0x7 10791b: ff 75 ac pushl -0x54(%ebp) 10791e: ff 75 0c pushl 0xc(%ebp) 107921: e8 80 f9 ff ff call 1072a6 107926: 83 c4 20 add $0x20,%esp 107929: 40 inc %eax 10792a: 0f 84 df 00 00 00 je 107a0f <== NEVER TAKEN /* * Test to see if it is a directory */ if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 107930: 83 ec 0c sub $0xc,%esp 107933: 56 push %esi 107934: 8b 45 e0 mov -0x20(%ebp),%eax 107937: ff 50 10 call *0x10(%eax) 10793a: 83 c4 10 add $0x10,%esp 10793d: 48 dec %eax 10793e: 74 10 je 107950 errno = ENOTDIR; 107940: e8 f3 97 00 00 call 111138 <__errno> 107945: c7 00 14 00 00 00 movl $0x14,(%eax) goto cleanup_and_bail; 10794b: e9 c1 00 00 00 jmp 107a11 /* * You can only mount one file system onto a single mount point. */ if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) { 107950: 57 push %edi 107951: 57 push %edi 107952: ff 75 d4 pushl -0x2c(%ebp) 107955: 68 80 77 10 00 push $0x107780 10795a: e8 62 fe ff ff call 1077c1 10795f: 83 c4 10 add $0x10,%esp 107962: 84 c0 test %al,%al 107964: 74 10 je 107976 errno = EBUSY; 107966: e8 cd 97 00 00 call 111138 <__errno> 10796b: c7 00 10 00 00 00 movl $0x10,(%eax) goto cleanup_and_bail; 107971: e9 9b 00 00 00 jmp 107a11 * 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; 107976: 8b 45 d4 mov -0x2c(%ebp),%eax 107979: 89 43 08 mov %eax,0x8(%ebx) mt_entry->mt_point_node.handlers = loc.handlers; 10797c: 8b 45 dc mov -0x24(%ebp),%eax 10797f: 89 43 10 mov %eax,0x10(%ebx) mt_entry->mt_point_node.ops = loc.ops; 107982: 8b 45 e0 mov -0x20(%ebp),%eax 107985: 89 43 14 mov %eax,0x14(%ebx) mt_entry->mt_point_node.mt_entry = loc.mt_entry; 107988: 8b 55 e4 mov -0x1c(%ebp),%edx 10798b: 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 ) ) { 10798e: 83 ec 0c sub $0xc,%esp 107991: 53 push %ebx 107992: ff 50 20 call *0x20(%eax) 107995: 83 c4 10 add $0x10,%esp 107998: 85 c0 test %eax,%eax 10799a: 74 1d je 1079b9 <== ALWAYS TAKEN 10799c: eb 73 jmp 107a11 <== NOT EXECUTED ) { 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; 10799e: 31 f6 xor %esi,%esi } } else { /* * Do we already have a base file system ? */ if ( !rtems_chain_is_empty( &mount_chain ) ) { 1079a0: 81 3d 64 2f 12 00 68 cmpl $0x122f68,0x122f64 1079a7: 2f 12 00 1079aa: 74 0d je 1079b9 <== ALWAYS TAKEN errno = EINVAL; 1079ac: e8 87 97 00 00 call 111138 <__errno> <== NOT EXECUTED 1079b1: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED goto cleanup_and_bail; 1079b7: eb 58 jmp 107a11 <== NOT EXECUTED * 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 ) ) { 1079b9: 51 push %ecx 1079ba: 51 push %ecx 1079bb: ff 75 18 pushl 0x18(%ebp) 1079be: 53 push %ebx 1079bf: ff 55 b0 call *-0x50(%ebp) 1079c2: 83 c4 10 add $0x10,%esp 1079c5: 85 c0 test %eax,%eax 1079c7: 74 0f je 1079d8 /* * Try to undo the mount operation */ loc.ops->unmount_h( mt_entry ); 1079c9: 83 ec 0c sub $0xc,%esp 1079cc: 53 push %ebx 1079cd: 8b 45 e0 mov -0x20(%ebp),%eax 1079d0: ff 50 28 call *0x28(%eax) goto cleanup_and_bail; 1079d3: 83 c4 10 add $0x10,%esp 1079d6: eb 39 jmp 107a11 } /* * Add the mount table entry to the mount table chain */ rtems_libio_lock(); 1079d8: e8 b4 fd ff ff call 107791 1079dd: 52 push %edx 1079de: 52 push %edx 1079df: 53 push %ebx 1079e0: 68 64 2f 12 00 push $0x122f64 1079e5: e8 4a 30 00 00 call 10aa34 <_Chain_Append> rtems_chain_append( &mount_chain, &mt_entry->Node ); rtems_libio_unlock(); 1079ea: e8 bc fd ff ff call 1077ab if ( !has_target ) 1079ef: 83 c4 10 add $0x10,%esp rtems_filesystem_root = mt_entry->mt_fs_root; return 0; 1079f2: 31 c0 xor %eax,%eax */ rtems_libio_lock(); rtems_chain_append( &mount_chain, &mt_entry->Node ); rtems_libio_unlock(); if ( !has_target ) 1079f4: 80 7d b7 00 cmpb $0x0,-0x49(%ebp) 1079f8: 75 3c jne 107a36 rtems_filesystem_root = mt_entry->mt_fs_root; 1079fa: 8b 3d 80 30 12 00 mov 0x123080,%edi 107a00: 83 c7 18 add $0x18,%edi 107a03: 8d 73 1c lea 0x1c(%ebx),%esi 107a06: b9 05 00 00 00 mov $0x5,%ecx 107a0b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 107a0d: eb 27 jmp 107a36 ) { 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; 107a0f: 31 f6 xor %esi,%esi return 0; cleanup_and_bail: free( mt_entry ); 107a11: 83 ec 0c sub $0xc,%esp 107a14: 53 push %ebx 107a15: e8 5e f9 ff ff call 107378 if ( loc_to_free ) 107a1a: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( loc_to_free ); return -1; 107a1d: 83 c8 ff or $0xffffffff,%eax cleanup_and_bail: free( mt_entry ); if ( loc_to_free ) 107a20: 85 f6 test %esi,%esi 107a22: 74 12 je 107a36 <== NEVER TAKEN rtems_filesystem_freenode( loc_to_free ); 107a24: 83 ec 0c sub $0xc,%esp 107a27: 56 push %esi 107a28: 89 45 a8 mov %eax,-0x58(%ebp) 107a2b: e8 34 f9 ff ff call 107364 107a30: 83 c4 10 add $0x10,%esp 107a33: 8b 45 a8 mov -0x58(%ebp),%eax return -1; } 107a36: 8d 65 f4 lea -0xc(%ebp),%esp 107a39: 5b pop %ebx 107a3a: 5e pop %esi 107a3b: 5f pop %edi 107a3c: c9 leave 107a3d: c3 ret =============================================================================== 00107d90 : const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { 107d90: 55 push %ebp 107d91: 89 e5 mov %esp,%ebp 107d93: 57 push %edi 107d94: 56 push %esi 107d95: 53 push %ebx 107d96: 83 ec 1c sub $0x1c,%esp 107d99: 8b 4d 08 mov 0x8(%ebp),%ecx 107d9c: 8b 5d 0c mov 0xc(%ebp),%ebx 107d9f: 8b 75 10 mov 0x10(%ebp),%esi 107da2: 8b 7d 14 mov 0x14(%ebp),%edi 107da5: 8b 55 18 mov 0x18(%ebp),%edx int rv = -1; if (target != NULL) { 107da8: 85 db test %ebx,%ebx 107daa: 74 3b je 107de7 rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO); 107dac: 50 push %eax 107dad: 50 push %eax 107dae: 68 ff 01 00 00 push $0x1ff 107db3: 53 push %ebx 107db4: 89 55 e0 mov %edx,-0x20(%ebp) 107db7: 89 4d e4 mov %ecx,-0x1c(%ebp) 107dba: e8 bd 08 00 00 call 10867c if (rv == 0) { 107dbf: 83 c4 10 add $0x10,%esp 107dc2: 85 c0 test %eax,%eax 107dc4: 8b 55 e0 mov -0x20(%ebp),%edx 107dc7: 8b 4d e4 mov -0x1c(%ebp),%ecx 107dca: 75 29 jne 107df5 <== NEVER TAKEN rv = mount( 107dcc: 89 55 18 mov %edx,0x18(%ebp) 107dcf: 89 7d 14 mov %edi,0x14(%ebp) 107dd2: 89 75 10 mov %esi,0x10(%ebp) 107dd5: 89 5d 0c mov %ebx,0xc(%ebp) 107dd8: 89 4d 08 mov %ecx,0x8(%ebp) } else { errno = EINVAL; } return rv; } 107ddb: 8d 65 f4 lea -0xc(%ebp),%esp 107dde: 5b pop %ebx 107ddf: 5e pop %esi 107de0: 5f pop %edi 107de1: c9 leave int rv = -1; if (target != NULL) { rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO); if (rv == 0) { rv = mount( 107de2: e9 a2 00 00 00 jmp 107e89 options, data ); } } else { errno = EINVAL; 107de7: e8 c8 99 00 00 call 1117b4 <__errno> 107dec: c7 00 16 00 00 00 movl $0x16,(%eax) const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { int rv = -1; 107df2: 83 c8 ff or $0xffffffff,%eax } else { errno = EINVAL; } return rv; } 107df5: 8d 65 f4 lea -0xc(%ebp),%esp 107df8: 5b pop %ebx 107df9: 5e pop %esi 107dfa: 5f pop %edi 107dfb: c9 leave 107dfc: c3 ret =============================================================================== 00107a99 : */ bool newlib_create_hook( rtems_tcb *current_task __attribute__((unused)), rtems_tcb *creating_task ) { 107a99: 55 push %ebp 107a9a: 89 e5 mov %esp,%ebp 107a9c: 57 push %edi 107a9d: 56 push %esi 107a9e: 53 push %ebx 107a9f: 83 ec 1c sub $0x1c,%esp struct _reent *ptr; if (_Thread_libc_reent == 0) 107aa2: 83 3d c8 53 12 00 00 cmpl $0x0,0x1253c8 107aa9: 75 14 jne 107abf { _REENT = _global_impure_ptr; 107aab: a1 80 fa 11 00 mov 0x11fa80,%eax 107ab0: a3 40 31 12 00 mov %eax,0x123140 RTEMS_INLINE_ROUTINE void _Thread_Set_libc_reent ( struct _reent **libc_reent ) { _Thread_libc_reent = libc_reent; 107ab5: c7 05 c8 53 12 00 40 movl $0x123140,0x1253c8 107abc: 31 12 00 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)); 107abf: 83 ec 0c sub $0xc,%esp 107ac2: 68 24 04 00 00 push $0x424 107ac7: e8 7e 55 00 00 call 10d04a <_Workspace_Allocate> 107acc: 89 c2 mov %eax,%edx #endif if (ptr) { 107ace: 83 c4 10 add $0x10,%esp _REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */ creating_task->libc_reent = ptr; return TRUE; } return FALSE; 107ad1: 31 c0 xor %eax,%eax * hooks run with thread dispatching disabled. */ ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent)); #endif if (ptr) { 107ad3: 85 d2 test %edx,%edx 107ad5: 0f 84 28 02 00 00 je 107d03 <== NEVER TAKEN _REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */ 107adb: c7 02 00 00 00 00 movl $0x0,(%edx) 107ae1: 8d b2 ec 02 00 00 lea 0x2ec(%edx),%esi 107ae7: 89 72 04 mov %esi,0x4(%edx) 107aea: 8d 8a 54 03 00 00 lea 0x354(%edx),%ecx 107af0: 89 4a 08 mov %ecx,0x8(%edx) 107af3: 8d 8a bc 03 00 00 lea 0x3bc(%edx),%ecx 107af9: 89 4a 0c mov %ecx,0xc(%edx) 107afc: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) 107b03: 8d 4a 14 lea 0x14(%edx),%ecx 107b06: bb 19 00 00 00 mov $0x19,%ebx 107b0b: 89 cf mov %ecx,%edi 107b0d: 89 d9 mov %ebx,%ecx 107b0f: f3 aa rep stos %al,%es:(%edi) 107b11: 89 cb mov %ecx,%ebx 107b13: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) 107b1a: c7 42 34 12 ed 11 00 movl $0x11ed12,0x34(%edx) 107b21: c7 42 38 00 00 00 00 movl $0x0,0x38(%edx) 107b28: c7 42 3c 00 00 00 00 movl $0x0,0x3c(%edx) 107b2f: c7 42 40 00 00 00 00 movl $0x0,0x40(%edx) 107b36: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx) 107b3d: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) 107b44: c7 42 4c 00 00 00 00 movl $0x0,0x4c(%edx) 107b4b: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx) 107b52: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) 107b59: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx) 107b60: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx) 107b67: c6 42 60 00 movb $0x0,0x60(%edx) 107b6b: 8d 42 7c lea 0x7c(%edx),%eax 107b6e: 89 45 e4 mov %eax,-0x1c(%ebp) 107b71: b1 09 mov $0x9,%cl 107b73: 89 c7 mov %eax,%edi 107b75: 89 d8 mov %ebx,%eax 107b77: f3 ab rep stos %eax,%es:(%edi) 107b79: c7 82 a0 00 00 00 00 movl $0x0,0xa0(%edx) 107b80: 00 00 00 107b83: c7 82 a4 00 00 00 01 movl $0x1,0xa4(%edx) 107b8a: 00 00 00 107b8d: c7 82 a8 00 00 00 00 movl $0x0,0xa8(%edx) 107b94: 00 00 00 107b97: 66 c7 82 ac 00 00 00 movw $0x330e,0xac(%edx) 107b9e: 0e 33 107ba0: 66 c7 82 ae 00 00 00 movw $0xabcd,0xae(%edx) 107ba7: cd ab 107ba9: 66 c7 82 b0 00 00 00 movw $0x1234,0xb0(%edx) 107bb0: 34 12 107bb2: 66 c7 82 b2 00 00 00 movw $0xe66d,0xb2(%edx) 107bb9: 6d e6 107bbb: 66 c7 82 b4 00 00 00 movw $0xdeec,0xb4(%edx) 107bc2: ec de 107bc4: 66 c7 82 b6 00 00 00 movw $0x5,0xb6(%edx) 107bcb: 05 00 107bcd: 66 c7 82 b8 00 00 00 movw $0xb,0xb8(%edx) 107bd4: 0b 00 107bd6: c7 82 bc 00 00 00 00 movl $0x0,0xbc(%edx) 107bdd: 00 00 00 107be0: c7 82 c0 00 00 00 00 movl $0x0,0xc0(%edx) 107be7: 00 00 00 107bea: c7 82 c4 00 00 00 00 movl $0x0,0xc4(%edx) 107bf1: 00 00 00 107bf4: c7 82 c8 00 00 00 00 movl $0x0,0xc8(%edx) 107bfb: 00 00 00 107bfe: c7 82 cc 00 00 00 00 movl $0x0,0xcc(%edx) 107c05: 00 00 00 107c08: c7 82 d0 00 00 00 00 movl $0x0,0xd0(%edx) 107c0f: 00 00 00 107c12: c7 82 f8 00 00 00 00 movl $0x0,0xf8(%edx) 107c19: 00 00 00 107c1c: c7 82 fc 00 00 00 00 movl $0x0,0xfc(%edx) 107c23: 00 00 00 107c26: c7 82 00 01 00 00 00 movl $0x0,0x100(%edx) 107c2d: 00 00 00 107c30: c7 82 04 01 00 00 00 movl $0x0,0x104(%edx) 107c37: 00 00 00 107c3a: c7 82 08 01 00 00 00 movl $0x0,0x108(%edx) 107c41: 00 00 00 107c44: c7 82 0c 01 00 00 00 movl $0x0,0x10c(%edx) 107c4b: 00 00 00 107c4e: c7 82 10 01 00 00 00 movl $0x0,0x110(%edx) 107c55: 00 00 00 107c58: c7 82 14 01 00 00 00 movl $0x0,0x114(%edx) 107c5f: 00 00 00 107c62: c7 82 18 01 00 00 00 movl $0x0,0x118(%edx) 107c69: 00 00 00 107c6c: c7 82 1c 01 00 00 00 movl $0x0,0x11c(%edx) 107c73: 00 00 00 107c76: c6 82 d4 00 00 00 00 movb $0x0,0xd4(%edx) 107c7d: c6 82 dc 00 00 00 00 movb $0x0,0xdc(%edx) 107c84: c7 82 f4 00 00 00 00 movl $0x0,0xf4(%edx) 107c8b: 00 00 00 107c8e: c7 82 48 01 00 00 00 movl $0x0,0x148(%edx) 107c95: 00 00 00 107c98: c7 82 4c 01 00 00 00 movl $0x0,0x14c(%edx) 107c9f: 00 00 00 107ca2: c7 82 50 01 00 00 00 movl $0x0,0x150(%edx) 107ca9: 00 00 00 107cac: c7 82 54 01 00 00 00 movl $0x0,0x154(%edx) 107cb3: 00 00 00 107cb6: c7 82 d4 02 00 00 00 movl $0x0,0x2d4(%edx) 107cbd: 00 00 00 107cc0: c7 82 d4 01 00 00 00 movl $0x0,0x1d4(%edx) 107cc7: 00 00 00 107cca: c7 82 dc 02 00 00 00 movl $0x0,0x2dc(%edx) 107cd1: 00 00 00 107cd4: c7 82 e0 02 00 00 00 movl $0x0,0x2e0(%edx) 107cdb: 00 00 00 107cde: c7 82 e4 02 00 00 00 movl $0x0,0x2e4(%edx) 107ce5: 00 00 00 107ce8: c7 82 e8 02 00 00 00 movl $0x0,0x2e8(%edx) 107cef: 00 00 00 107cf2: b1 4e mov $0x4e,%cl 107cf4: 89 f7 mov %esi,%edi 107cf6: f3 ab rep stos %eax,%es:(%edi) creating_task->libc_reent = ptr; 107cf8: 8b 45 0c mov 0xc(%ebp),%eax 107cfb: 89 90 e4 00 00 00 mov %edx,0xe4(%eax) return TRUE; 107d01: b0 01 mov $0x1,%al } return FALSE; } 107d03: 8d 65 f4 lea -0xc(%ebp),%esp 107d06: 5b pop %ebx 107d07: 5e pop %esi 107d08: 5f pop %edi 107d09: c9 leave 107d0a: c3 ret =============================================================================== 00107d0b : void newlib_delete_hook( rtems_tcb *current_task, rtems_tcb *deleted_task ) { 107d0b: 55 push %ebp 107d0c: 89 e5 mov %esp,%ebp 107d0e: 57 push %edi 107d0f: 56 push %esi 107d10: 53 push %ebx 107d11: 83 ec 0c sub $0xc,%esp 107d14: 8b 7d 08 mov 0x8(%ebp),%edi 107d17: 8b 75 0c mov 0xc(%ebp),%esi /* * The reentrancy structure was allocated by newlib using malloc() */ if (current_task == deleted_task) { 107d1a: 39 f7 cmp %esi,%edi 107d1c: 75 08 jne 107d26 ptr = _REENT; 107d1e: 8b 1d 40 31 12 00 mov 0x123140,%ebx 107d24: eb 06 jmp 107d2c } else { ptr = deleted_task->libc_reent; 107d26: 8b 9e e4 00 00 00 mov 0xe4(%esi),%ebx } if (ptr && ptr != _global_impure_ptr) { 107d2c: 85 db test %ebx,%ebx 107d2e: 74 20 je 107d50 <== NEVER TAKEN 107d30: 3b 1d 80 fa 11 00 cmp 0x11fa80,%ebx 107d36: 74 18 je 107d50 _reclaim_reent(ptr); */ /* * Just in case there are some buffers lying around. */ _fwalk(ptr, newlib_free_buffers); 107d38: 50 push %eax 107d39: 50 push %eax 107d3a: 68 48 7a 10 00 push $0x107a48 107d3f: 53 push %ebx 107d40: e8 db 9b 00 00 call 111920 <_fwalk> #if REENT_MALLOCED free(ptr); #else _Workspace_Free(ptr); 107d45: 89 1c 24 mov %ebx,(%esp) 107d48: e8 16 53 00 00 call 10d063 <_Workspace_Free> 107d4d: 83 c4 10 add $0x10,%esp #endif } deleted_task->libc_reent = NULL; 107d50: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) 107d57: 00 00 00 /* * Require the switch back to another task to install its own */ if ( current_task == deleted_task ) { 107d5a: 39 f7 cmp %esi,%edi 107d5c: 75 0a jne 107d68 _REENT = 0; 107d5e: c7 05 40 31 12 00 00 movl $0x0,0x123140 107d65: 00 00 00 } } 107d68: 8d 65 f4 lea -0xc(%ebp),%esp 107d6b: 5b pop %ebx 107d6c: 5e pop %esi 107d6d: 5f pop %edi 107d6e: c9 leave 107d6f: c3 ret =============================================================================== 00107a48 : */ int newlib_free_buffers( FILE *fp ) { 107a48: 55 push %ebp 107a49: 89 e5 mov %esp,%ebp 107a4b: 53 push %ebx 107a4c: 83 ec 10 sub $0x10,%esp 107a4f: 8b 5d 08 mov 0x8(%ebp),%ebx switch ( fileno(fp) ) { 107a52: 53 push %ebx 107a53: e8 b4 9a 00 00 call 11150c 107a58: 83 c4 10 add $0x10,%esp 107a5b: 83 f8 02 cmp $0x2,%eax 107a5e: 77 26 ja 107a86 <== NEVER TAKEN case 0: case 1: case 2: if (fp->_flags & __SMBF) { 107a60: f6 43 0c 80 testb $0x80,0xc(%ebx) 107a64: 74 2c je 107a92 <== ALWAYS TAKEN free( fp->_bf._base ); 107a66: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107a69: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 107a6c: e8 07 f9 ff ff call 107378 <== NOT EXECUTED fp->_flags &= ~__SMBF; 107a71: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) <== NOT EXECUTED fp->_bf._base = fp->_p = (unsigned char *) NULL; 107a77: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED 107a7d: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED 107a84: eb 09 jmp 107a8f <== NOT EXECUTED } break; default: fclose(fp); 107a86: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107a89: 53 push %ebx <== NOT EXECUTED 107a8a: e8 01 98 00 00 call 111290 <== NOT EXECUTED 107a8f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 107a92: 31 c0 xor %eax,%eax 107a94: 8b 5d fc mov -0x4(%ebp),%ebx 107a97: c9 leave 107a98: c3 ret =============================================================================== 00107dd0 : int open( const char *pathname, int flags, ... ) { 107dd0: 55 push %ebp 107dd1: 89 e5 mov %esp,%ebp 107dd3: 57 push %edi 107dd4: 56 push %esi 107dd5: 53 push %ebx 107dd6: 83 ec 3c sub $0x3c,%esp /* * Set the Evaluation flags */ eval_flags = 0; status = flags + 1; 107dd9: 8b 45 0c mov 0xc(%ebp),%eax 107ddc: 40 inc %eax if ( ( status & _FREAD ) == _FREAD ) 107ddd: 89 c6 mov %eax,%esi 107ddf: 83 e6 01 and $0x1,%esi eval_flags |= RTEMS_LIBIO_PERMS_READ; 107de2: f7 de neg %esi 107de4: 83 e6 04 and $0x4,%esi if ( ( status & _FWRITE ) == _FWRITE ) 107de7: a8 02 test $0x2,%al 107de9: 74 03 je 107dee eval_flags |= RTEMS_LIBIO_PERMS_WRITE; 107deb: 83 ce 02 or $0x2,%esi va_start(ap, flags); mode = va_arg( ap, int ); 107dee: 8b 45 10 mov 0x10(%ebp),%eax 107df1: 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(); 107df4: e8 92 64 00 00 call 10e28b 107df9: 89 c3 mov %eax,%ebx if ( iop == 0 ) { 107dfb: 85 c0 test %eax,%eax 107dfd: 0f 84 56 01 00 00 je 107f59 } /* * See if the file exists. */ status = rtems_filesystem_evaluate_path( 107e03: 83 c9 ff or $0xffffffff,%ecx 107e06: 8b 7d 08 mov 0x8(%ebp),%edi 107e09: 31 c0 xor %eax,%eax 107e0b: f2 ae repnz scas %es:(%edi),%al 107e0d: f7 d1 not %ecx 107e0f: 49 dec %ecx 107e10: 83 ec 0c sub $0xc,%esp 107e13: 6a 01 push $0x1 107e15: 8d 45 d4 lea -0x2c(%ebp),%eax 107e18: 50 push %eax 107e19: 56 push %esi 107e1a: 51 push %ecx 107e1b: ff 75 08 pushl 0x8(%ebp) 107e1e: e8 83 f4 ff ff call 1072a6 107e23: 89 c6 mov %eax,%esi pathname, strlen( pathname ), eval_flags, &loc, true ); if ( status == -1 ) { 107e25: 83 c4 20 add $0x20,%esp 107e28: 83 f8 ff cmp $0xffffffff,%eax 107e2b: 75 6c jne 107e99 if ( errno != ENOENT ) { 107e2d: e8 06 93 00 00 call 111138 <__errno> 107e32: 83 38 02 cmpl $0x2,(%eax) 107e35: 75 27 jne 107e5e rc = errno; goto done; } /* If the file does not exist and we are not trying to create it--> error */ if ( !(flags & O_CREAT) ) { 107e37: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 107e3e: 0f 84 1c 01 00 00 je 107f60 rc = ENOENT; goto done; } /* Create the node for the new regular file */ rc = mknod( pathname, S_IFREG | mode, 0LL ); 107e44: 6a 00 push $0x0 107e46: 6a 00 push $0x0 107e48: 8b 45 c4 mov -0x3c(%ebp),%eax 107e4b: 80 cc 80 or $0x80,%ah 107e4e: 50 push %eax 107e4f: ff 75 08 pushl 0x8(%ebp) 107e52: e8 75 f8 ff ff call 1076cc if ( rc ) { 107e57: 83 c4 10 add $0x10,%esp 107e5a: 85 c0 test %eax,%eax 107e5c: 74 0e je 107e6c <== ALWAYS TAKEN rc = errno; 107e5e: e8 d5 92 00 00 call 111138 <__errno> 107e63: 8b 30 mov (%eax),%esi 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; 107e65: 31 ff xor %edi,%edi /* Create the node for the new regular file */ rc = mknod( pathname, S_IFREG | mode, 0LL ); if ( rc ) { rc = errno; goto done; 107e67: e9 10 01 00 00 jmp 107f7c /* * 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( 107e6c: 89 f1 mov %esi,%ecx 107e6e: 8b 7d 08 mov 0x8(%ebp),%edi 107e71: 31 c0 xor %eax,%eax 107e73: f2 ae repnz scas %es:(%edi),%al 107e75: f7 d1 not %ecx 107e77: 49 dec %ecx 107e78: 83 ec 0c sub $0xc,%esp 107e7b: 6a 01 push $0x1 107e7d: 8d 45 d4 lea -0x2c(%ebp),%eax 107e80: 50 push %eax 107e81: 6a 00 push $0x0 107e83: 51 push %ecx 107e84: ff 75 08 pushl 0x8(%ebp) 107e87: e8 1a f4 ff ff call 1072a6 pathname, strlen( pathname ), 0x0, &loc, true ); if ( status != 0 ) { /* The file did not exist */ 107e8c: 83 c4 20 add $0x20,%esp 107e8f: 85 c0 test %eax,%eax 107e91: 0f 85 d2 00 00 00 jne 107f69 <== NEVER TAKEN 107e97: eb 13 jmp 107eac rc = EACCES; goto done; } } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) { 107e99: 8b 45 0c mov 0xc(%ebp),%eax 107e9c: 25 00 0a 00 00 and $0xa00,%eax 107ea1: 3d 00 0a 00 00 cmp $0xa00,%eax 107ea6: 0f 84 c6 00 00 00 je 107f72 /* * Fill in the file control block based on the loc structure * returned by successful path evaluation. */ iop->flags |= rtems_libio_fcntl_flags( flags ); 107eac: 8b 73 14 mov 0x14(%ebx),%esi 107eaf: 83 ec 0c sub $0xc,%esp 107eb2: ff 75 0c pushl 0xc(%ebp) 107eb5: e8 5e 63 00 00 call 10e218 107eba: 09 f0 or %esi,%eax 107ebc: 89 43 14 mov %eax,0x14(%ebx) iop->pathinfo = loc; 107ebf: 8d 7b 18 lea 0x18(%ebx),%edi 107ec2: 8d 75 d4 lea -0x2c(%ebp),%esi 107ec5: b9 05 00 00 00 mov $0x5,%ecx 107eca: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode ); 107ecc: 8b 43 20 mov 0x20(%ebx),%eax 107ecf: ff 75 c4 pushl -0x3c(%ebp) 107ed2: ff 75 0c pushl 0xc(%ebp) 107ed5: ff 75 08 pushl 0x8(%ebp) 107ed8: 53 push %ebx 107ed9: ff 10 call *(%eax) if ( rc ) { 107edb: 83 c4 20 add $0x20,%esp 107ede: 85 c0 test %eax,%eax 107ee0: 74 0f je 107ef1 rc = errno; 107ee2: e8 51 92 00 00 call 111138 <__errno> 107ee7: 8b 30 mov (%eax),%esi rc = EEXIST; loc_to_free = &loc; goto done; } loc_to_free = &loc; 107ee9: 8d 7d d4 lea -0x2c(%ebp),%edi iop->pathinfo = loc; rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode ); if ( rc ) { rc = errno; goto done; 107eec: e9 8b 00 00 00 jmp 107f7c } /* * Optionally truncate the file. */ if ( (flags & O_TRUNC) == O_TRUNC ) { 107ef1: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 107ef8: 0f 84 ae 00 00 00 je 107fac rc = ftruncate( iop - rtems_libio_iops, 0 ); 107efe: 50 push %eax 107eff: 6a 00 push $0x0 107f01: 6a 00 push $0x0 107f03: 89 d8 mov %ebx,%eax 107f05: 2b 05 f8 51 12 00 sub 0x1251f8,%eax 107f0b: c1 f8 03 sar $0x3,%eax 107f0e: 69 c0 b7 6d db b6 imul $0xb6db6db7,%eax,%eax 107f14: 50 push %eax 107f15: e8 16 62 00 00 call 10e130 107f1a: 89 c6 mov %eax,%esi if ( rc ) { 107f1c: 83 c4 10 add $0x10,%esp 107f1f: 85 c0 test %eax,%eax 107f21: 0f 84 85 00 00 00 je 107fac if(errno) rc = errno; 107f27: e8 0c 92 00 00 call 111138 <__errno> 107f2c: 83 38 00 cmpl $0x0,(%eax) 107f2f: 74 07 je 107f38 <== NEVER TAKEN 107f31: e8 02 92 00 00 call 111138 <__errno> 107f36: 8b 30 mov (%eax),%esi close( iop - rtems_libio_iops ); 107f38: 83 ec 0c sub $0xc,%esp 107f3b: 2b 1d f8 51 12 00 sub 0x1251f8,%ebx 107f41: c1 fb 03 sar $0x3,%ebx 107f44: 69 db b7 6d db b6 imul $0xb6db6db7,%ebx,%ebx 107f4a: 53 push %ebx 107f4b: e8 70 61 00 00 call 10e0c0 107f50: 83 c4 10 add $0x10,%esp /* those are released by close(): */ iop = 0; loc_to_free = NULL; 107f53: 31 ff xor %edi,%edi 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; 107f55: 31 db xor %ebx,%ebx 107f57: eb 23 jmp 107f7c */ /* allocate a file control block */ iop = rtems_libio_allocate(); if ( iop == 0 ) { rc = ENFILE; 107f59: be 17 00 00 00 mov $0x17,%esi 107f5e: eb 40 jmp 107fa0 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; 107f60: 31 ff xor %edi,%edi goto done; } /* If the file does not exist and we are not trying to create it--> error */ if ( !(flags & O_CREAT) ) { rc = ENOENT; 107f62: be 02 00 00 00 mov $0x2,%esi 107f67: eb 17 jmp 107f80 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; 107f69: 31 ff xor %edi,%edi <== NOT EXECUTED * 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; 107f6b: be 0d 00 00 00 mov $0xd,%esi <== NOT EXECUTED 107f70: eb 0e jmp 107f80 <== NOT EXECUTED } } 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; 107f72: 8d 7d d4 lea -0x2c(%ebp),%edi 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; 107f75: be 11 00 00 00 mov $0x11,%esi 107f7a: eb 04 jmp 107f80 * Single exit and clean up path. */ done: va_end(ap); if ( rc ) { 107f7c: 85 f6 test %esi,%esi 107f7e: 74 2c je 107fac <== NEVER TAKEN if ( iop ) 107f80: 85 db test %ebx,%ebx 107f82: 74 0c je 107f90 rtems_libio_free( iop ); 107f84: 83 ec 0c sub $0xc,%esp 107f87: 53 push %ebx 107f88: e8 77 63 00 00 call 10e304 107f8d: 83 c4 10 add $0x10,%esp if ( loc_to_free ) 107f90: 85 ff test %edi,%edi 107f92: 74 0c je 107fa0 rtems_filesystem_freenode( loc_to_free ); 107f94: 83 ec 0c sub $0xc,%esp 107f97: 57 push %edi 107f98: e8 c7 f3 ff ff call 107364 107f9d: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( rc ); 107fa0: e8 93 91 00 00 call 111138 <__errno> 107fa5: 89 30 mov %esi,(%eax) 107fa7: 83 c8 ff or $0xffffffff,%eax 107faa: eb 0f jmp 107fbb } return iop - rtems_libio_iops; 107fac: 2b 1d f8 51 12 00 sub 0x1251f8,%ebx 107fb2: c1 fb 03 sar $0x3,%ebx 107fb5: 69 c3 b7 6d db b6 imul $0xb6db6db7,%ebx,%eax } 107fbb: 8d 65 f4 lea -0xc(%ebp),%esp 107fbe: 5b pop %ebx 107fbf: 5e pop %esi 107fc0: 5f pop %edi 107fc1: c9 leave 107fc2: c3 ret =============================================================================== 00108b72 : /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) { 108b72: 55 push %ebp 108b73: 89 e5 mov %esp,%ebp 108b75: 56 push %esi 108b76: 53 push %ebx 108b77: 83 ec 10 sub $0x10,%esp 108b7a: 89 d3 mov %edx,%ebx 108b7c: 88 45 f4 mov %al,-0xc(%ebp) int i; if (tty->termios.c_oflag & OPOST) { 108b7f: 8b 52 34 mov 0x34(%edx),%edx 108b82: f6 c2 01 test $0x1,%dl 108b85: 0f 84 ed 00 00 00 je 108c78 <== NEVER TAKEN switch (c) { 108b8b: 3c 09 cmp $0x9,%al 108b8d: 74 75 je 108c04 108b8f: 77 0d ja 108b9e <== ALWAYS TAKEN 108b91: 3c 08 cmp $0x8,%al <== NOT EXECUTED 108b93: 0f 85 aa 00 00 00 jne 108c43 <== NOT EXECUTED 108b99: e9 98 00 00 00 jmp 108c36 <== NOT EXECUTED 108b9e: 3c 0a cmp $0xa,%al 108ba0: 74 0a je 108bac 108ba2: 3c 0d cmp $0xd,%al 108ba4: 0f 85 99 00 00 00 jne 108c43 <== ALWAYS TAKEN 108baa: eb 32 jmp 108bde <== NOT EXECUTED case '\n': if (tty->termios.c_oflag & ONLRET) 108bac: f6 c2 20 test $0x20,%dl 108baf: 74 07 je 108bb8 <== ALWAYS TAKEN tty->column = 0; 108bb1: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED if (tty->termios.c_oflag & ONLCR) { 108bb8: 80 e2 04 and $0x4,%dl 108bbb: 0f 84 b7 00 00 00 je 108c78 <== NEVER TAKEN rtems_termios_puts ("\r", 1, tty); 108bc1: 56 push %esi 108bc2: 53 push %ebx 108bc3: 6a 01 push $0x1 108bc5: 68 64 f0 11 00 push $0x11f064 108bca: e8 83 fe ff ff call 108a52 tty->column = 0; 108bcf: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) 108bd6: 83 c4 10 add $0x10,%esp 108bd9: e9 9a 00 00 00 jmp 108c78 } break; case '\r': if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0)) 108bde: f6 c2 10 test $0x10,%dl <== NOT EXECUTED 108be1: 74 0a je 108bed <== NOT EXECUTED 108be3: 83 7b 28 00 cmpl $0x0,0x28(%ebx) <== NOT EXECUTED 108be7: 0f 84 9b 00 00 00 je 108c88 <== NOT EXECUTED return; if (tty->termios.c_oflag & OCRNL) { 108bed: f6 c2 08 test $0x8,%dl <== NOT EXECUTED 108bf0: 74 09 je 108bfb <== NOT EXECUTED c = '\n'; 108bf2: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED if (tty->termios.c_oflag & ONLRET) 108bf6: 80 e2 20 and $0x20,%dl <== NOT EXECUTED 108bf9: 74 7d je 108c78 <== NOT EXECUTED tty->column = 0; break; } tty->column = 0; 108bfb: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED break; 108c02: eb 74 jmp 108c78 <== NOT EXECUTED case '\t': i = 8 - (tty->column & 7); 108c04: 8b 4b 28 mov 0x28(%ebx),%ecx 108c07: 89 ce mov %ecx,%esi 108c09: 83 e6 07 and $0x7,%esi 108c0c: b8 08 00 00 00 mov $0x8,%eax 108c11: 29 f0 sub %esi,%eax if ((tty->termios.c_oflag & TABDLY) == XTABS) { 108c13: 81 e2 00 18 00 00 and $0x1800,%edx 108c19: 81 fa 00 18 00 00 cmp $0x1800,%edx 108c1f: 8d 14 08 lea (%eax,%ecx,1),%edx 108c22: 75 0d jne 108c31 <== NEVER TAKEN tty->column += i; 108c24: 89 53 28 mov %edx,0x28(%ebx) rtems_termios_puts ( " ", i, tty); 108c27: 51 push %ecx 108c28: 53 push %ebx 108c29: 50 push %eax 108c2a: 68 24 ec 11 00 push $0x11ec24 108c2f: eb 4f jmp 108c80 return; } tty->column += i; 108c31: 89 53 28 mov %edx,0x28(%ebx) <== NOT EXECUTED break; 108c34: eb 42 jmp 108c78 <== NOT EXECUTED case '\b': if (tty->column > 0) 108c36: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 108c39: 85 c0 test %eax,%eax <== NOT EXECUTED 108c3b: 7e 3b jle 108c78 <== NOT EXECUTED tty->column--; 108c3d: 48 dec %eax <== NOT EXECUTED 108c3e: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 108c41: eb 35 jmp 108c78 <== NOT EXECUTED break; default: if (tty->termios.c_oflag & OLCUC) 108c43: 80 e2 02 and $0x2,%dl 108c46: 74 1c je 108c64 <== ALWAYS TAKEN c = toupper(c); 108c48: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 108c4b: 8b 15 3c 31 12 00 mov 0x12313c,%edx <== NOT EXECUTED 108c51: 0f be 54 02 01 movsbl 0x1(%edx,%eax,1),%edx <== NOT EXECUTED 108c56: 83 e2 03 and $0x3,%edx <== NOT EXECUTED 108c59: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 108c5c: 75 03 jne 108c61 <== NOT EXECUTED 108c5e: 83 e8 20 sub $0x20,%eax <== NOT EXECUTED 108c61: 88 45 f4 mov %al,-0xc(%ebp) <== NOT EXECUTED if (!iscntrl(c)) 108c64: 0f b6 45 f4 movzbl -0xc(%ebp),%eax 108c68: 8b 15 3c 31 12 00 mov 0x12313c,%edx 108c6e: f6 44 02 01 20 testb $0x20,0x1(%edx,%eax,1) 108c73: 75 03 jne 108c78 <== NEVER TAKEN tty->column++; 108c75: ff 43 28 incl 0x28(%ebx) break; } } rtems_termios_puts (&c, 1, tty); 108c78: 52 push %edx 108c79: 53 push %ebx 108c7a: 6a 01 push $0x1 108c7c: 8d 45 f4 lea -0xc(%ebp),%eax 108c7f: 50 push %eax 108c80: e8 cd fd ff ff call 108a52 108c85: 83 c4 10 add $0x10,%esp } 108c88: 8d 65 f8 lea -0x8(%ebp),%esp 108c8b: 5b pop %ebx 108c8c: 5e pop %esi 108c8d: c9 leave 108c8e: c3 ret =============================================================================== 0010ef5c : * Called by pipe() to create an anonymous pipe. */ int pipe_create( int filsdes[2] ) { 10ef5c: 55 push %ebp 10ef5d: 89 e5 mov %esp,%ebp 10ef5f: 57 push %edi 10ef60: 56 push %esi 10ef61: 53 push %ebx 10ef62: 83 ec 34 sub $0x34,%esp rtems_libio_t *iop; int err = 0; if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0) 10ef65: 68 ff 01 00 00 push $0x1ff 10ef6a: 68 fc 0d 12 00 push $0x120dfc 10ef6f: e8 58 14 00 00 call 1103cc 10ef74: 83 c4 10 add $0x10,%esp return -1; 10ef77: c7 45 d4 ff ff ff ff movl $0xffffffff,-0x2c(%ebp) ) { rtems_libio_t *iop; int err = 0; if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0) 10ef7e: 85 c0 test %eax,%eax 10ef80: 0f 85 e8 00 00 00 jne 10f06e <== NEVER TAKEN return -1; /* /tmp/.fifoXXXX */ char fifopath[15]; memcpy(fifopath, "/tmp/.fifo", 10); 10ef86: 8d 5d d9 lea -0x27(%ebp),%ebx 10ef89: be 01 0e 12 00 mov $0x120e01,%esi 10ef8e: b9 0a 00 00 00 mov $0xa,%ecx 10ef93: 89 df mov %ebx,%edi 10ef95: f3 a4 rep movsb %ds:(%esi),%es:(%edi) sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); 10ef97: 0f b7 05 20 60 12 00 movzwl 0x126020,%eax 10ef9e: 8d 50 01 lea 0x1(%eax),%edx 10efa1: 66 89 15 20 60 12 00 mov %dx,0x126020 10efa8: 57 push %edi 10efa9: 50 push %eax 10efaa: 68 0c 0e 12 00 push $0x120e0c 10efaf: 8d 45 e3 lea -0x1d(%ebp),%eax 10efb2: 50 push %eax 10efb3: e8 c0 43 00 00 call 113378 /* Try creating FIFO file until find an available file name */ while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) { 10efb8: 59 pop %ecx 10efb9: 5e pop %esi 10efba: 68 80 01 00 00 push $0x180 10efbf: 53 push %ebx 10efc0: e8 c7 11 00 00 call 11018c 10efc5: 83 c4 10 add $0x10,%esp 10efc8: 85 c0 test %eax,%eax 10efca: 74 0a je 10efd6 if (errno != EEXIST){ 10efcc: e8 bb 39 00 00 call 11298c <__errno> 10efd1: e9 98 00 00 00 jmp 10f06e 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); 10efd6: 52 push %edx 10efd7: 52 push %edx 10efd8: 68 00 40 00 00 push $0x4000 10efdd: 53 push %ebx 10efde: e8 4d 9e ff ff call 108e30 10efe3: 8b 55 08 mov 0x8(%ebp),%edx 10efe6: 89 02 mov %eax,(%edx) if (filsdes[0] < 0) { 10efe8: 83 c4 10 add $0x10,%esp 10efeb: 85 c0 test %eax,%eax 10efed: 79 0d jns 10effc err = errno; 10efef: e8 98 39 00 00 call 11298c <__errno> 10eff4: 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); 10eff6: 83 ec 0c sub $0xc,%esp 10eff9: 53 push %ebx 10effa: eb 51 jmp 10f04d } else { /* Reset open file to blocking mode */ iop = rtems_libio_iop(filsdes[0]); 10effc: 31 d2 xor %edx,%edx 10effe: 3b 05 44 21 12 00 cmp 0x122144,%eax 10f004: 73 09 jae 10f00f <== NEVER TAKEN 10f006: 6b d0 38 imul $0x38,%eax,%edx 10f009: 03 15 20 62 12 00 add 0x126220,%edx iop->flags &= ~LIBIO_FLAGS_NO_DELAY; 10f00f: 83 62 14 fe andl $0xfffffffe,0x14(%edx) filsdes[1] = open(fifopath, O_WRONLY); 10f013: 50 push %eax 10f014: 50 push %eax 10f015: 6a 01 push $0x1 10f017: 8d 45 d9 lea -0x27(%ebp),%eax 10f01a: 50 push %eax 10f01b: e8 10 9e ff ff call 108e30 10f020: 8b 55 08 mov 0x8(%ebp),%edx 10f023: 89 42 04 mov %eax,0x4(%edx) if (filsdes[1] < 0) { 10f026: 83 c4 10 add $0x10,%esp int pipe_create( int filsdes[2] ) { rtems_libio_t *iop; int err = 0; 10f029: 31 f6 xor %esi,%esi iop = rtems_libio_iop(filsdes[0]); iop->flags &= ~LIBIO_FLAGS_NO_DELAY; filsdes[1] = open(fifopath, O_WRONLY); if (filsdes[1] < 0) { 10f02b: 85 c0 test %eax,%eax 10f02d: 79 17 jns 10f046 err = errno; 10f02f: e8 58 39 00 00 call 11298c <__errno> 10f034: 8b 30 mov (%eax),%esi close(filsdes[0]); 10f036: 83 ec 0c sub $0xc,%esp 10f039: 8b 45 08 mov 0x8(%ebp),%eax 10f03c: ff 30 pushl (%eax) 10f03e: e8 d1 8f ff ff call 108014 10f043: 83 c4 10 add $0x10,%esp } unlink(fifopath); 10f046: 83 ec 0c sub $0xc,%esp 10f049: 8d 45 d9 lea -0x27(%ebp),%eax 10f04c: 50 push %eax 10f04d: e8 7a b9 ff ff call 10a9cc 10f052: 83 c4 10 add $0x10,%esp } if(err != 0) rtems_set_errno_and_return_minus_one(err); return 0; 10f055: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) err = errno; close(filsdes[0]); } unlink(fifopath); } if(err != 0) 10f05c: 85 f6 test %esi,%esi 10f05e: 74 0e je 10f06e rtems_set_errno_and_return_minus_one(err); 10f060: e8 27 39 00 00 call 11298c <__errno> 10f065: 89 30 mov %esi,(%eax) 10f067: c7 45 d4 ff ff ff ff movl $0xffffffff,-0x2c(%ebp) return 0; } 10f06e: 8b 45 d4 mov -0x2c(%ebp),%eax 10f071: 8d 65 f4 lea -0xc(%ebp),%esp 10f074: 5b pop %ebx 10f075: 5e pop %esi 10f076: 5f pop %edi 10f077: c9 leave 10f078: c3 ret =============================================================================== 0011025b : pipe_control_t *pipe, uint32_t cmd, void *buffer, rtems_libio_t *iop ) { 11025b: 55 push %ebp 11025c: 89 e5 mov %esp,%ebp 11025e: 56 push %esi 11025f: 53 push %ebx 110260: 8b 5d 08 mov 0x8(%ebp),%ebx 110263: 8b 75 10 mov 0x10(%ebp),%esi *(unsigned int *)buffer = pipe->Length; PIPE_UNLOCK(pipe); return 0; } return -EINVAL; 110266: b8 ea ff ff ff mov $0xffffffea,%eax uint32_t cmd, void *buffer, rtems_libio_t *iop ) { if (cmd == FIONREAD) { 11026b: 81 7d 0c 7f 66 04 40 cmpl $0x4004667f,0xc(%ebp) 110272: 75 36 jne 1102aa if (buffer == NULL) return -EFAULT; 110274: b0 f2 mov $0xf2,%al void *buffer, rtems_libio_t *iop ) { if (cmd == FIONREAD) { if (buffer == NULL) 110276: 85 f6 test %esi,%esi 110278: 74 30 je 1102aa return -EFAULT; if (! PIPE_LOCK(pipe)) 11027a: 51 push %ecx 11027b: 6a 00 push $0x0 11027d: 6a 00 push $0x0 11027f: ff 73 28 pushl 0x28(%ebx) 110282: e8 d9 b9 ff ff call 10bc60 110287: 89 c2 mov %eax,%edx 110289: 83 c4 10 add $0x10,%esp return -EINTR; 11028c: b8 fc ff ff ff mov $0xfffffffc,%eax { if (cmd == FIONREAD) { if (buffer == NULL) return -EFAULT; if (! PIPE_LOCK(pipe)) 110291: 85 d2 test %edx,%edx 110293: 75 15 jne 1102aa <== NEVER TAKEN return -EINTR; /* Return length of pipe */ *(unsigned int *)buffer = pipe->Length; 110295: 8b 43 0c mov 0xc(%ebx),%eax 110298: 89 06 mov %eax,(%esi) PIPE_UNLOCK(pipe); 11029a: 83 ec 0c sub $0xc,%esp 11029d: ff 73 28 pushl 0x28(%ebx) 1102a0: e8 a7 ba ff ff call 10bd4c return 0; 1102a5: 83 c4 10 add $0x10,%esp 1102a8: 31 c0 xor %eax,%eax } return -EINVAL; } 1102aa: 8d 65 f8 lea -0x8(%ebp),%esp 1102ad: 5b pop %ebx 1102ae: 5e pop %esi 1102af: c9 leave 1102b0: c3 ret =============================================================================== 0010ff4c : pipe_control_t *pipe, void *buffer, size_t count, rtems_libio_t *iop ) { 10ff4c: 55 push %ebp 10ff4d: 89 e5 mov %esp,%ebp 10ff4f: 57 push %edi 10ff50: 56 push %esi 10ff51: 53 push %ebx 10ff52: 83 ec 30 sub $0x30,%esp 10ff55: 8b 5d 08 mov 0x8(%ebp),%ebx int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) 10ff58: 6a 00 push $0x0 10ff5a: 6a 00 push $0x0 10ff5c: ff 73 28 pushl 0x28(%ebx) 10ff5f: e8 fc bc ff ff call 10bc60 10ff64: 83 c4 10 add $0x10,%esp return -EINTR; 10ff67: be fc ff ff ff mov $0xfffffffc,%esi rtems_libio_t *iop ) { int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) 10ff6c: 85 c0 test %eax,%eax 10ff6e: 0f 85 2f 01 00 00 jne 1100a3 <== NEVER TAKEN 10ff74: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) 10ff7b: e9 f0 00 00 00 jmp 110070 return -EINTR; while (read < count) { while (PIPE_EMPTY(pipe)) { /* Not an error */ if (pipe->Writers == 0) 10ff80: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10ff84: 0f 84 f2 00 00 00 je 11007c goto out_locked; if (LIBIO_NODELAY(iop)) { 10ff8a: 8b 45 14 mov 0x14(%ebp),%eax 10ff8d: f6 40 14 01 testb $0x1,0x14(%eax) 10ff91: 0f 85 e9 00 00 00 jne 110080 ret = -EAGAIN; goto out_locked; } /* Wait until pipe is no more empty or no writer exists */ pipe->waitingReaders ++; 10ff97: ff 43 18 incl 0x18(%ebx) PIPE_UNLOCK(pipe); 10ff9a: 83 ec 0c sub $0xc,%esp 10ff9d: ff 73 28 pushl 0x28(%ebx) 10ffa0: e8 a7 bd ff ff call 10bd4c if (! PIPE_READWAIT(pipe)) 10ffa5: 5f pop %edi 10ffa6: 58 pop %eax 10ffa7: 6a 00 push $0x0 10ffa9: ff 73 2c pushl 0x2c(%ebx) 10ffac: e8 9f 16 00 00 call 111650 10ffb1: 83 c4 0c add $0xc,%esp 10ffb4: 83 f8 01 cmp $0x1,%eax 10ffb7: 19 f6 sbb %esi,%esi 10ffb9: f7 d6 not %esi 10ffbb: 83 e6 fc and $0xfffffffc,%esi ret = -EINTR; if (! PIPE_LOCK(pipe)) { 10ffbe: 6a 00 push $0x0 10ffc0: 6a 00 push $0x0 10ffc2: ff 73 28 pushl 0x28(%ebx) 10ffc5: e8 96 bc ff ff call 10bc60 10ffca: 83 c4 10 add $0x10,%esp 10ffcd: 85 c0 test %eax,%eax 10ffcf: 0f 85 c0 00 00 00 jne 110095 <== NEVER TAKEN /* WARN waitingReaders not restored! */ ret = -EINTR; goto out_nolock; } pipe->waitingReaders --; 10ffd5: ff 4b 18 decl 0x18(%ebx) if (ret != 0) 10ffd8: 85 f6 test %esi,%esi 10ffda: 0f 85 a5 00 00 00 jne 110085 <== NEVER TAKEN if (! PIPE_LOCK(pipe)) return -EINTR; while (read < count) { while (PIPE_EMPTY(pipe)) { 10ffe0: 8b 53 0c mov 0xc(%ebx),%edx 10ffe3: 85 d2 test %edx,%edx 10ffe5: 74 99 je 10ff80 if (ret != 0) goto out_locked; } /* Read chunk bytes */ chunk = MIN(count - read, pipe->Length); 10ffe7: 8b 45 10 mov 0x10(%ebp),%eax 10ffea: 2b 45 d0 sub -0x30(%ebp),%eax 10ffed: 89 55 d4 mov %edx,-0x2c(%ebp) 10fff0: 39 c2 cmp %eax,%edx 10fff2: 76 03 jbe 10fff7 10fff4: 89 45 d4 mov %eax,-0x2c(%ebp) chunk1 = pipe->Size - pipe->Start; 10fff7: 8b 73 08 mov 0x8(%ebx),%esi 10fffa: 8b 43 04 mov 0x4(%ebx),%eax 10fffd: 29 f0 sub %esi,%eax if (chunk > chunk1) { 10ffff: 39 45 d4 cmp %eax,-0x2c(%ebp) 110002: 8b 7d 0c mov 0xc(%ebp),%edi 110005: 8b 4d d0 mov -0x30(%ebp),%ecx 110008: 8d 14 0f lea (%edi,%ecx,1),%edx 11000b: 7e 1b jle 110028 memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1); 11000d: 03 33 add (%ebx),%esi 11000f: 89 d7 mov %edx,%edi 110011: 89 c1 mov %eax,%ecx 110013: f3 a4 rep movsb %ds:(%esi),%es:(%edi) memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1); 110015: 8b 55 d0 mov -0x30(%ebp),%edx 110018: 01 c2 add %eax,%edx 11001a: 03 55 0c add 0xc(%ebp),%edx 11001d: 8b 4d d4 mov -0x2c(%ebp),%ecx 110020: 29 c1 sub %eax,%ecx 110022: 8b 33 mov (%ebx),%esi 110024: 89 d7 mov %edx,%edi 110026: eb 07 jmp 11002f } else memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk); 110028: 03 33 add (%ebx),%esi 11002a: 89 d7 mov %edx,%edi 11002c: 8b 4d d4 mov -0x2c(%ebp),%ecx 11002f: f3 a4 rep movsb %ds:(%esi),%es:(%edi) pipe->Start += chunk; 110031: 8b 45 d4 mov -0x2c(%ebp),%eax 110034: 03 43 08 add 0x8(%ebx),%eax pipe->Start %= pipe->Size; 110037: 31 d2 xor %edx,%edx 110039: f7 73 04 divl 0x4(%ebx) 11003c: 89 53 08 mov %edx,0x8(%ebx) pipe->Length -= chunk; 11003f: 8b 43 0c mov 0xc(%ebx),%eax 110042: 2b 45 d4 sub -0x2c(%ebp),%eax 110045: 89 43 0c mov %eax,0xc(%ebx) /* For buffering optimization */ if (PIPE_EMPTY(pipe)) 110048: 85 c0 test %eax,%eax 11004a: 75 07 jne 110053 pipe->Start = 0; 11004c: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) if (pipe->waitingWriters > 0) 110053: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx) 110057: 74 11 je 11006a PIPE_WAKEUPWRITERS(pipe); 110059: 56 push %esi 11005a: 56 push %esi 11005b: 8d 45 e4 lea -0x1c(%ebp),%eax 11005e: 50 push %eax 11005f: ff 73 30 pushl 0x30(%ebx) 110062: e8 91 15 00 00 call 1115f8 110067: 83 c4 10 add $0x10,%esp read += chunk; 11006a: 8b 4d d4 mov -0x2c(%ebp),%ecx 11006d: 01 4d d0 add %ecx,-0x30(%ebp) int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) return -EINTR; while (read < count) { 110070: 8b 7d 10 mov 0x10(%ebp),%edi 110073: 39 7d d0 cmp %edi,-0x30(%ebp) 110076: 0f 82 64 ff ff ff jb 10ffe0 while (PIPE_EMPTY(pipe)) { /* Not an error */ if (pipe->Writers == 0) 11007c: 31 f6 xor %esi,%esi 11007e: eb 05 jmp 110085 goto out_locked; if (LIBIO_NODELAY(iop)) { ret = -EAGAIN; 110080: be f5 ff ff ff mov $0xfffffff5,%esi PIPE_WAKEUPWRITERS(pipe); read += chunk; } out_locked: PIPE_UNLOCK(pipe); 110085: 83 ec 0c sub $0xc,%esp 110088: ff 73 28 pushl 0x28(%ebx) 11008b: e8 bc bc ff ff call 10bd4c 110090: 83 c4 10 add $0x10,%esp 110093: eb 05 jmp 11009a PIPE_UNLOCK(pipe); if (! PIPE_READWAIT(pipe)) ret = -EINTR; if (! PIPE_LOCK(pipe)) { /* WARN waitingReaders not restored! */ ret = -EINTR; 110095: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED out_locked: PIPE_UNLOCK(pipe); out_nolock: if (read > 0) 11009a: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 11009e: 7e 03 jle 1100a3 1100a0: 8b 75 d0 mov -0x30(%ebp),%esi return read; return ret; } 1100a3: 89 f0 mov %esi,%eax 1100a5: 8d 65 f4 lea -0xc(%ebp),%esp 1100a8: 5b pop %ebx 1100a9: 5e pop %esi 1100aa: 5f pop %edi 1100ab: c9 leave 1100ac: c3 ret =============================================================================== 0010faf1 : */ void pipe_release( pipe_control_t **pipep, rtems_libio_t *iop ) { 10faf1: 55 push %ebp 10faf2: 89 e5 mov %esp,%ebp 10faf4: 57 push %edi 10faf5: 56 push %esi 10faf6: 53 push %ebx 10faf7: 83 ec 1c sub $0x1c,%esp 10fafa: 8b 7d 08 mov 0x8(%ebp),%edi pipe_control_t *pipe = *pipep; 10fafd: 8b 1f mov (%edi),%ebx /* WARN pipe not released! */ if (!PIPE_LOCK(pipe)) rtems_fatal_error_occurred(0xdeadbeef); #endif mode = LIBIO_ACCMODE(iop); 10faff: 8b 45 0c mov 0xc(%ebp),%eax 10fb02: 8b 40 14 mov 0x14(%eax),%eax 10fb05: 89 c6 mov %eax,%esi 10fb07: 83 e6 06 and $0x6,%esi if (mode & LIBIO_FLAGS_READ) 10fb0a: a8 02 test $0x2,%al 10fb0c: 74 03 je 10fb11 pipe->Readers --; 10fb0e: ff 4b 10 decl 0x10(%ebx) if (mode & LIBIO_FLAGS_WRITE) 10fb11: f7 c6 04 00 00 00 test $0x4,%esi 10fb17: 74 03 je 10fb1c pipe->Writers --; 10fb19: ff 4b 14 decl 0x14(%ebx) PIPE_UNLOCK(pipe); 10fb1c: 83 ec 0c sub $0xc,%esp 10fb1f: ff 73 28 pushl 0x28(%ebx) 10fb22: e8 25 c2 ff ff call 10bd4c if (pipe->Readers == 0 && pipe->Writers == 0) { 10fb27: 8b 43 10 mov 0x10(%ebx),%eax 10fb2a: 83 c4 10 add $0x10,%esp 10fb2d: 85 c0 test %eax,%eax 10fb2f: 75 15 jne 10fb46 10fb31: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10fb35: 75 0f jne 10fb46 #if 0 /* To delete an anonymous pipe file when all users closed it */ if (pipe->Anonymous) delfile = TRUE; #endif pipe_free(pipe); 10fb37: 89 d8 mov %ebx,%eax 10fb39: e8 78 ff ff ff call 10fab6 *pipep = NULL; 10fb3e: c7 07 00 00 00 00 movl $0x0,(%edi) 10fb44: eb 30 jmp 10fb76 } else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE) 10fb46: 83 fe 04 cmp $0x4,%esi 10fb49: 74 0f je 10fb5a 10fb4b: 85 c0 test %eax,%eax 10fb4d: 75 0b jne 10fb5a <== NEVER TAKEN /* Notify waiting Writers that all their partners left */ PIPE_WAKEUPWRITERS(pipe); 10fb4f: 57 push %edi 10fb50: 57 push %edi 10fb51: 8d 45 e4 lea -0x1c(%ebp),%eax 10fb54: 50 push %eax 10fb55: ff 73 30 pushl 0x30(%ebx) 10fb58: eb 14 jmp 10fb6e else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ) 10fb5a: 83 fe 02 cmp $0x2,%esi 10fb5d: 74 17 je 10fb76 <== NEVER TAKEN 10fb5f: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10fb63: 75 11 jne 10fb76 <== NEVER TAKEN PIPE_WAKEUPREADERS(pipe); 10fb65: 56 push %esi 10fb66: 56 push %esi 10fb67: 8d 45 e4 lea -0x1c(%ebp),%eax 10fb6a: 50 push %eax 10fb6b: ff 73 2c pushl 0x2c(%ebx) 10fb6e: e8 85 1a 00 00 call 1115f8 10fb73: 83 c4 10 add $0x10,%esp pipe_unlock(); 10fb76: e8 25 ff ff ff call 10faa0 iop->flags &= ~LIBIO_FLAGS_OPEN; if(iop->pathinfo.ops->unlink_h(&iop->pathinfo)) return; #endif } 10fb7b: 8d 65 f4 lea -0xc(%ebp),%esp 10fb7e: 5b pop %ebx 10fb7f: 5e pop %esi 10fb80: 5f pop %edi 10fb81: c9 leave 10fb82: c3 ret =============================================================================== 001100ad : pipe_control_t *pipe, const void *buffer, size_t count, rtems_libio_t *iop ) { 1100ad: 55 push %ebp 1100ae: 89 e5 mov %esp,%ebp 1100b0: 57 push %edi 1100b1: 56 push %esi 1100b2: 53 push %ebx 1100b3: 83 ec 2c sub $0x2c,%esp 1100b6: 8b 5d 08 mov 0x8(%ebp),%ebx int chunk, chunk1, written = 0, ret = 0; /* Write nothing */ if (count == 0) return 0; 1100b9: 31 f6 xor %esi,%esi ) { int chunk, chunk1, written = 0, ret = 0; /* Write nothing */ if (count == 0) 1100bb: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 1100bf: 0f 84 8c 01 00 00 je 110251 <== NEVER TAKEN return 0; if (! PIPE_LOCK(pipe)) 1100c5: 52 push %edx 1100c6: 6a 00 push $0x0 1100c8: 6a 00 push $0x0 1100ca: ff 73 28 pushl 0x28(%ebx) 1100cd: e8 8e bb ff ff call 10bc60 1100d2: 83 c4 10 add $0x10,%esp return -EINTR; 1100d5: be fc ff ff ff mov $0xfffffffc,%esi /* Write nothing */ if (count == 0) return 0; if (! PIPE_LOCK(pipe)) 1100da: 85 c0 test %eax,%eax 1100dc: 0f 85 6f 01 00 00 jne 110251 <== NEVER TAKEN return -EINTR; if (pipe->Readers == 0) { 1100e2: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 1100e6: 0f 84 16 01 00 00 je 110202 ret = -EPIPE; goto out_locked; } /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; 1100ec: bf 01 00 00 00 mov $0x1,%edi 1100f1: 8b 45 10 mov 0x10(%ebp),%eax 1100f4: 3b 43 04 cmp 0x4(%ebx),%eax 1100f7: 77 02 ja 1100fb <== NEVER TAKEN 1100f9: 89 c7 mov %eax,%edi /* Wait until there is chunk bytes space or no reader exists */ pipe->waitingWriters ++; PIPE_UNLOCK(pipe); if (! PIPE_WRITEWAIT(pipe)) ret = -EINTR; 1100fb: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) 110102: e9 eb 00 00 00 jmp 1101f2 /* 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) { if (LIBIO_NODELAY(iop)) { 110107: 8b 4d 14 mov 0x14(%ebp),%ecx 11010a: f6 41 14 01 testb $0x1,0x14(%ecx) 11010e: 0f 85 fc 00 00 00 jne 110210 ret = -EAGAIN; goto out_locked; } /* Wait until there is chunk bytes space or no reader exists */ pipe->waitingWriters ++; 110114: ff 43 1c incl 0x1c(%ebx) PIPE_UNLOCK(pipe); 110117: 83 ec 0c sub $0xc,%esp 11011a: ff 73 28 pushl 0x28(%ebx) 11011d: e8 2a bc ff ff call 10bd4c if (! PIPE_WRITEWAIT(pipe)) 110122: 5e pop %esi 110123: 58 pop %eax 110124: 6a 00 push $0x0 110126: ff 73 30 pushl 0x30(%ebx) 110129: e8 22 15 00 00 call 111650 11012e: 83 c4 0c add $0xc,%esp 110131: 83 f8 01 cmp $0x1,%eax 110134: 19 f6 sbb %esi,%esi 110136: f7 d6 not %esi 110138: 83 e6 fc and $0xfffffffc,%esi ret = -EINTR; if (! PIPE_LOCK(pipe)) { 11013b: 6a 00 push $0x0 11013d: 6a 00 push $0x0 11013f: ff 73 28 pushl 0x28(%ebx) 110142: e8 19 bb ff ff call 10bc60 110147: 83 c4 10 add $0x10,%esp 11014a: 85 c0 test %eax,%eax 11014c: 0f 85 f1 00 00 00 jne 110243 <== NEVER TAKEN /* WARN waitingWriters not restored! */ ret = -EINTR; goto out_nolock; } pipe->waitingWriters --; 110152: ff 4b 1c decl 0x1c(%ebx) if (ret != 0) 110155: 85 f6 test %esi,%esi 110157: 0f 85 bf 00 00 00 jne 11021c <== NEVER TAKEN goto out_locked; if (pipe->Readers == 0) { 11015d: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 110161: 0f 84 b0 00 00 00 je 110217 <== NEVER TAKEN /* 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) { 110167: 8b 73 04 mov 0x4(%ebx),%esi 11016a: 8b 43 0c mov 0xc(%ebx),%eax 11016d: 89 f1 mov %esi,%ecx 11016f: 29 c1 sub %eax,%ecx 110171: 39 f9 cmp %edi,%ecx 110173: 72 92 jb 110107 ret = -EPIPE; goto out_locked; } } chunk = MIN(count - written, PIPE_SPACE(pipe)); 110175: 8b 55 10 mov 0x10(%ebp),%edx 110178: 2b 55 d4 sub -0x2c(%ebp),%edx 11017b: 89 4d d0 mov %ecx,-0x30(%ebp) 11017e: 39 d1 cmp %edx,%ecx 110180: 76 03 jbe 110185 110182: 89 55 d0 mov %edx,-0x30(%ebp) chunk1 = pipe->Size - PIPE_WSTART(pipe); 110185: 03 43 08 add 0x8(%ebx),%eax 110188: 31 d2 xor %edx,%edx 11018a: f7 f6 div %esi 11018c: 29 d6 sub %edx,%esi 11018e: 89 75 cc mov %esi,-0x34(%ebp) if (chunk > chunk1) { 110191: 39 75 d0 cmp %esi,-0x30(%ebp) 110194: 8b 4d 0c mov 0xc(%ebp),%ecx 110197: 8b 45 d4 mov -0x2c(%ebp),%eax 11019a: 8d 34 01 lea (%ecx,%eax,1),%esi 11019d: 7e 20 jle 1101bf memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1); 11019f: 8b 03 mov (%ebx),%eax 1101a1: 01 d0 add %edx,%eax 1101a3: 89 c7 mov %eax,%edi 1101a5: 8b 4d cc mov -0x34(%ebp),%ecx 1101a8: f3 a4 rep movsb %ds:(%esi),%es:(%edi) memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1); 1101aa: 8b 03 mov (%ebx),%eax 1101ac: 8b 4d d0 mov -0x30(%ebp),%ecx 1101af: 2b 4d cc sub -0x34(%ebp),%ecx 1101b2: 8b 75 cc mov -0x34(%ebp),%esi 1101b5: 03 75 d4 add -0x2c(%ebp),%esi 1101b8: 03 75 0c add 0xc(%ebp),%esi 1101bb: 89 c7 mov %eax,%edi 1101bd: eb 09 jmp 1101c8 } else memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk); 1101bf: 8b 03 mov (%ebx),%eax 1101c1: 01 d0 add %edx,%eax 1101c3: 89 c7 mov %eax,%edi 1101c5: 8b 4d d0 mov -0x30(%ebp),%ecx 1101c8: f3 a4 rep movsb %ds:(%esi),%es:(%edi) pipe->Length += chunk; 1101ca: 8b 45 d0 mov -0x30(%ebp),%eax 1101cd: 01 43 0c add %eax,0xc(%ebx) if (pipe->waitingReaders > 0) 1101d0: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 1101d4: 74 11 je 1101e7 PIPE_WAKEUPREADERS(pipe); 1101d6: 51 push %ecx 1101d7: 51 push %ecx 1101d8: 8d 4d e4 lea -0x1c(%ebp),%ecx 1101db: 51 push %ecx 1101dc: ff 73 2c pushl 0x2c(%ebx) 1101df: e8 14 14 00 00 call 1115f8 1101e4: 83 c4 10 add $0x10,%esp written += chunk; 1101e7: 8b 45 d0 mov -0x30(%ebp),%eax 1101ea: 01 45 d4 add %eax,-0x2c(%ebp) /* Write of more than PIPE_BUF bytes can be interleaved */ chunk = 1; 1101ed: bf 01 00 00 00 mov $0x1,%edi } /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; while (written < count) { 1101f2: 8b 4d 10 mov 0x10(%ebp),%ecx 1101f5: 39 4d d4 cmp %ecx,-0x2c(%ebp) 1101f8: 0f 82 69 ff ff ff jb 110167 1101fe: 31 f6 xor %esi,%esi 110200: eb 1a jmp 11021c if (! PIPE_LOCK(pipe)) return -EINTR; if (pipe->Readers == 0) { ret = -EPIPE; 110202: be e0 ff ff ff mov $0xffffffe0,%esi const void *buffer, size_t count, rtems_libio_t *iop ) { int chunk, chunk1, written = 0, ret = 0; 110207: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) 11020e: eb 0c jmp 11021c chunk = count <= pipe->Size ? count : 1; while (written < count) { while (PIPE_SPACE(pipe) < chunk) { if (LIBIO_NODELAY(iop)) { ret = -EAGAIN; 110210: be f5 ff ff ff mov $0xfffffff5,%esi 110215: eb 05 jmp 11021c pipe->waitingWriters --; if (ret != 0) goto out_locked; if (pipe->Readers == 0) { ret = -EPIPE; 110217: be e0 ff ff ff mov $0xffffffe0,%esi <== NOT EXECUTED /* Write of more than PIPE_BUF bytes can be interleaved */ chunk = 1; } out_locked: PIPE_UNLOCK(pipe); 11021c: 83 ec 0c sub $0xc,%esp 11021f: ff 73 28 pushl 0x28(%ebx) 110222: e8 25 bb ff ff call 10bd4c 110227: 83 c4 10 add $0x10,%esp out_nolock: #ifdef RTEMS_POSIX_API /* Signal SIGPIPE */ if (ret == -EPIPE) 11022a: 83 fe e0 cmp $0xffffffe0,%esi 11022d: 75 19 jne 110248 kill(getpid(), SIGPIPE); 11022f: e8 24 07 00 00 call 110958 110234: 52 push %edx 110235: 52 push %edx 110236: 6a 0d push $0xd 110238: 50 push %eax 110239: e8 a2 09 00 00 call 110be0 11023e: 83 c4 10 add $0x10,%esp 110241: eb 05 jmp 110248 PIPE_UNLOCK(pipe); if (! PIPE_WRITEWAIT(pipe)) ret = -EINTR; if (! PIPE_LOCK(pipe)) { /* WARN waitingWriters not restored! */ ret = -EINTR; 110243: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED /* Signal SIGPIPE */ if (ret == -EPIPE) kill(getpid(), SIGPIPE); #endif if (written > 0) 110248: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 11024c: 7e 03 jle 110251 11024e: 8b 75 d4 mov -0x2c(%ebp),%esi return written; return ret; } 110251: 89 f0 mov %esi,%eax 110253: 8d 65 f4 lea -0xc(%ebp),%esp 110256: 5b pop %ebx 110257: 5e pop %esi 110258: 5f pop %edi 110259: c9 leave 11025a: c3 ret =============================================================================== 0010a888 : int posix_memalign( void **pointer, size_t alignment, size_t size ) { 10a888: 55 push %ebp 10a889: 89 e5 mov %esp,%ebp 10a88b: 53 push %ebx 10a88c: 83 ec 04 sub $0x4,%esp 10a88f: 8b 45 0c mov 0xc(%ebp),%eax /* * Update call statistics */ MSBUMP(memalign_calls, 1); 10a892: ff 05 44 bb 12 00 incl 0x12bb44 if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *))) 10a898: 8d 58 ff lea -0x1(%eax),%ebx 10a89b: 85 c3 test %eax,%ebx 10a89d: 75 0d jne 10a8ac <== NEVER TAKEN 10a89f: 83 f8 03 cmp $0x3,%eax 10a8a2: 76 08 jbe 10a8ac /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); } 10a8a4: 59 pop %ecx 10a8a5: 5b pop %ebx 10a8a6: c9 leave /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); 10a8a7: e9 74 01 00 00 jmp 10aa20 } 10a8ac: b8 16 00 00 00 mov $0x16,%eax 10a8b1: 5a pop %edx 10a8b2: 5b pop %ebx 10a8b3: c9 leave 10a8b4: c3 ret =============================================================================== 0010efd8 : int pthread_attr_getdetachstate( const pthread_attr_t *attr, int *detachstate ) { 10efd8: 55 push %ebp 10efd9: 89 e5 mov %esp,%ebp 10efdb: 8b 55 08 mov 0x8(%ebp),%edx 10efde: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized || !detachstate ) return EINVAL; 10efe1: b8 16 00 00 00 mov $0x16,%eax int pthread_attr_getdetachstate( const pthread_attr_t *attr, int *detachstate ) { if ( !attr || !attr->is_initialized || !detachstate ) 10efe6: 85 d2 test %edx,%edx 10efe8: 74 17 je 10f001 <== NEVER TAKEN 10efea: 85 c9 test %ecx,%ecx 10efec: 74 0e je 10effc 10efee: 83 3a 00 cmpl $0x0,(%edx) 10eff1: 74 09 je 10effc return EINVAL; *detachstate = attr->detachstate; 10eff3: 8b 42 3c mov 0x3c(%edx),%eax 10eff6: 89 01 mov %eax,(%ecx) return 0; 10eff8: 31 c0 xor %eax,%eax 10effa: eb 05 jmp 10f001 const pthread_attr_t *attr, int *detachstate ) { if ( !attr || !attr->is_initialized || !detachstate ) return EINVAL; 10effc: b8 16 00 00 00 mov $0x16,%eax *detachstate = attr->detachstate; return 0; } 10f001: c9 leave 10f002: c3 ret =============================================================================== 0010f24c : int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { 10f24c: 55 push %ebp 10f24d: 89 e5 mov %esp,%ebp 10f24f: 8b 55 08 mov 0x8(%ebp),%edx 10f252: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 10f255: b8 16 00 00 00 mov $0x16,%eax int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { if ( !attr || !attr->is_initialized ) 10f25a: 85 d2 test %edx,%edx 10f25c: 74 1e je 10f27c 10f25e: 83 3a 00 cmpl $0x0,(%edx) 10f261: 74 19 je 10f27c return EINVAL; switch ( policy ) { 10f263: 83 f9 04 cmp $0x4,%ecx 10f266: 77 0f ja 10f277 10f268: b0 01 mov $0x1,%al 10f26a: d3 e0 shl %cl,%eax 10f26c: a8 17 test $0x17,%al 10f26e: 74 07 je 10f277 <== NEVER TAKEN case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: case SCHED_SPORADIC: attr->schedpolicy = policy; 10f270: 89 4a 14 mov %ecx,0x14(%edx) return 0; 10f273: 31 c0 xor %eax,%eax 10f275: eb 05 jmp 10f27c default: return ENOTSUP; 10f277: b8 86 00 00 00 mov $0x86,%eax } } 10f27c: c9 leave 10f27d: c3 ret =============================================================================== 0010a56c : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 10a56c: 55 push %ebp 10a56d: 89 e5 mov %esp,%ebp 10a56f: 57 push %edi 10a570: 56 push %esi 10a571: 53 push %ebx 10a572: 83 ec 1c sub $0x1c,%esp 10a575: 8b 5d 08 mov 0x8(%ebp),%ebx 10a578: 8b 75 10 mov 0x10(%ebp),%esi /* * Error check parameters */ if ( !barrier ) return EINVAL; 10a57b: b8 16 00 00 00 mov $0x16,%eax const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 10a580: 85 db test %ebx,%ebx 10a582: 0f 84 96 00 00 00 je 10a61e return EINVAL; if ( count == 0 ) 10a588: 85 f6 test %esi,%esi 10a58a: 0f 84 8e 00 00 00 je 10a61e return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10a590: 8b 7d 0c mov 0xc(%ebp),%edi 10a593: 85 ff test %edi,%edi 10a595: 75 0f jne 10a5a6 the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 10a597: 83 ec 0c sub $0xc,%esp 10a59a: 8d 7d d8 lea -0x28(%ebp),%edi 10a59d: 57 push %edi 10a59e: e8 19 ff ff ff call 10a4bc 10a5a3: 83 c4 10 add $0x10,%esp /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) return EINVAL; 10a5a6: b8 16 00 00 00 mov $0x16,%eax } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 10a5ab: 83 3f 00 cmpl $0x0,(%edi) 10a5ae: 74 6e je 10a61e return EINVAL; switch ( the_attr->process_shared ) { 10a5b0: 83 7f 04 00 cmpl $0x0,0x4(%edi) 10a5b4: 75 68 jne 10a61e <== NEVER TAKEN } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 10a5b6: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) the_attributes.maximum_count = count; 10a5bd: 89 75 e4 mov %esi,-0x1c(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a5c0: a1 50 63 12 00 mov 0x126350,%eax 10a5c5: 40 inc %eax 10a5c6: a3 50 63 12 00 mov %eax,0x126350 * the inactive chain of free barrier control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Allocate( void ) { return (POSIX_Barrier_Control *) _Objects_Allocate( &_POSIX_Barrier_Information ); 10a5cb: 83 ec 0c sub $0xc,%esp 10a5ce: 68 f4 66 12 00 push $0x1266f4 10a5d3: e8 0c 1e 00 00 call 10c3e4 <_Objects_Allocate> 10a5d8: 89 c6 mov %eax,%esi */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 10a5da: 83 c4 10 add $0x10,%esp 10a5dd: 85 c0 test %eax,%eax 10a5df: 75 0c jne 10a5ed _Thread_Enable_dispatch(); 10a5e1: e8 dc 2c 00 00 call 10d2c2 <_Thread_Enable_dispatch> return EAGAIN; 10a5e6: b8 0b 00 00 00 mov $0xb,%eax 10a5eb: eb 31 jmp 10a61e } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 10a5ed: 50 push %eax 10a5ee: 50 push %eax 10a5ef: 8d 45 e0 lea -0x20(%ebp),%eax 10a5f2: 50 push %eax 10a5f3: 8d 46 10 lea 0x10(%esi),%eax 10a5f6: 50 push %eax 10a5f7: e8 a8 14 00 00 call 10baa4 <_CORE_barrier_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10a5fc: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10a5ff: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10a602: 8b 15 10 67 12 00 mov 0x126710,%edx 10a608: 89 34 8a mov %esi,(%edx,%ecx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10a60b: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) ); /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; 10a612: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10a614: e8 a9 2c 00 00 call 10d2c2 <_Thread_Enable_dispatch> return 0; 10a619: 83 c4 10 add $0x10,%esp 10a61c: 31 c0 xor %eax,%eax } 10a61e: 8d 65 f4 lea -0xc(%ebp),%esp 10a621: 5b pop %ebx 10a622: 5e pop %esi 10a623: 5f pop %edi 10a624: c9 leave 10a625: c3 ret =============================================================================== 00109f20 : void pthread_cleanup_push( void (*routine)( void * ), void *arg ) { 109f20: 55 push %ebp 109f21: 89 e5 mov %esp,%ebp 109f23: 56 push %esi 109f24: 53 push %ebx 109f25: 8b 5d 08 mov 0x8(%ebp),%ebx 109f28: 8b 75 0c mov 0xc(%ebp),%esi /* * The POSIX standard does not address what to do when the routine * is NULL. It also does not address what happens when we cannot * allocate memory or anything else bad happens. */ if ( !routine ) 109f2b: 85 db test %ebx,%ebx 109f2d: 74 4b je 109f7a rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 109f2f: a1 48 63 12 00 mov 0x126348,%eax 109f34: 40 inc %eax 109f35: a3 48 63 12 00 mov %eax,0x126348 return; _Thread_Disable_dispatch(); handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); 109f3a: 83 ec 0c sub $0xc,%esp 109f3d: 6a 10 push $0x10 109f3f: e8 3e 3c 00 00 call 10db82 <_Workspace_Allocate> if ( handler ) { 109f44: 83 c4 10 add $0x10,%esp 109f47: 85 c0 test %eax,%eax 109f49: 74 24 je 109f6f <== NEVER TAKEN thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 109f4b: 8b 15 70 68 12 00 mov 0x126870,%edx handler_stack = &thread_support->Cancellation_Handlers; 109f51: 8b 92 ec 00 00 00 mov 0xec(%edx),%edx 109f57: 81 c2 e4 00 00 00 add $0xe4,%edx handler->routine = routine; 109f5d: 89 58 08 mov %ebx,0x8(%eax) handler->arg = arg; 109f60: 89 70 0c mov %esi,0xc(%eax) _Chain_Append( handler_stack, &handler->Node ); 109f63: 51 push %ecx 109f64: 51 push %ecx 109f65: 50 push %eax 109f66: 52 push %edx 109f67: e8 84 15 00 00 call 10b4f0 <_Chain_Append> 109f6c: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); } 109f6f: 8d 65 f8 lea -0x8(%ebp),%esp 109f72: 5b pop %ebx 109f73: 5e pop %esi 109f74: c9 leave handler->routine = routine; handler->arg = arg; _Chain_Append( handler_stack, &handler->Node ); } _Thread_Enable_dispatch(); 109f75: e9 3c 2d 00 00 jmp 10ccb6 <_Thread_Enable_dispatch> } 109f7a: 8d 65 f8 lea -0x8(%ebp),%esp 109f7d: 5b pop %ebx 109f7e: 5e pop %esi 109f7f: c9 leave 109f80: c3 ret =============================================================================== 0010ac94 : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 10ac94: 55 push %ebp 10ac95: 89 e5 mov %esp,%ebp 10ac97: 56 push %esi 10ac98: 53 push %ebx POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 10ac99: 8b 5d 0c mov 0xc(%ebp),%ebx 10ac9c: 85 db test %ebx,%ebx 10ac9e: 75 05 jne 10aca5 else the_attr = &_POSIX_Condition_variables_Default_attributes; 10aca0: bb b4 15 12 00 mov $0x1215b4,%ebx /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) return EINVAL; 10aca5: b8 16 00 00 00 mov $0x16,%eax else the_attr = &_POSIX_Condition_variables_Default_attributes; /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 10acaa: 83 7b 04 01 cmpl $0x1,0x4(%ebx) 10acae: 74 76 je 10ad26 <== NEVER TAKEN return EINVAL; if ( !the_attr->is_initialized ) 10acb0: 83 3b 00 cmpl $0x0,(%ebx) 10acb3: 74 71 je 10ad26 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10acb5: a1 60 73 12 00 mov 0x127360,%eax 10acba: 40 inc %eax 10acbb: a3 60 73 12 00 mov %eax,0x127360 RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control *_POSIX_Condition_variables_Allocate( void ) { return (POSIX_Condition_variables_Control *) _Objects_Allocate( &_POSIX_Condition_variables_Information ); 10acc0: 83 ec 0c sub $0xc,%esp 10acc3: 68 9c 77 12 00 push $0x12779c 10acc8: e8 f7 22 00 00 call 10cfc4 <_Objects_Allocate> 10accd: 89 c6 mov %eax,%esi _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 10accf: 83 c4 10 add $0x10,%esp 10acd2: 85 c0 test %eax,%eax 10acd4: 75 0c jne 10ace2 _Thread_Enable_dispatch(); 10acd6: e8 c7 31 00 00 call 10dea2 <_Thread_Enable_dispatch> return ENOMEM; 10acdb: b8 0c 00 00 00 mov $0xc,%eax 10ace0: eb 44 jmp 10ad26 } the_cond->process_shared = the_attr->process_shared; 10ace2: 8b 43 04 mov 0x4(%ebx),%eax 10ace5: 89 46 10 mov %eax,0x10(%esi) the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 10ace8: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) _Thread_queue_Initialize( 10acef: 6a 74 push $0x74 10acf1: 68 00 08 00 10 push $0x10000800 10acf6: 6a 00 push $0x0 10acf8: 8d 46 18 lea 0x18(%esi),%eax 10acfb: 50 push %eax 10acfc: e8 5f 38 00 00 call 10e560 <_Thread_queue_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10ad01: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10ad04: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10ad07: 8b 15 b8 77 12 00 mov 0x1277b8,%edx 10ad0d: 89 34 8a mov %esi,(%edx,%ecx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10ad10: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 10ad17: 8b 55 08 mov 0x8(%ebp),%edx 10ad1a: 89 02 mov %eax,(%edx) _Thread_Enable_dispatch(); 10ad1c: e8 81 31 00 00 call 10dea2 <_Thread_Enable_dispatch> return 0; 10ad21: 83 c4 10 add $0x10,%esp 10ad24: 31 c0 xor %eax,%eax } 10ad26: 8d 65 f8 lea -0x8(%ebp),%esp 10ad29: 5b pop %ebx 10ad2a: 5e pop %esi 10ad2b: c9 leave 10ad2c: c3 ret =============================================================================== 0010ab48 : */ int pthread_condattr_destroy( pthread_condattr_t *attr ) { 10ab48: 55 push %ebp 10ab49: 89 e5 mov %esp,%ebp 10ab4b: 8b 55 08 mov 0x8(%ebp),%edx if ( !attr || attr->is_initialized == false ) return EINVAL; 10ab4e: b8 16 00 00 00 mov $0x16,%eax int pthread_condattr_destroy( pthread_condattr_t *attr ) { if ( !attr || attr->is_initialized == false ) 10ab53: 85 d2 test %edx,%edx 10ab55: 74 0d je 10ab64 10ab57: 83 3a 00 cmpl $0x0,(%edx) 10ab5a: 74 08 je 10ab64 <== NEVER TAKEN return EINVAL; attr->is_initialized = false; 10ab5c: c7 02 00 00 00 00 movl $0x0,(%edx) return 0; 10ab62: 30 c0 xor %al,%al } 10ab64: c9 leave 10ab65: c3 ret =============================================================================== 0010a27c : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 10a27c: 55 push %ebp 10a27d: 89 e5 mov %esp,%ebp 10a27f: 57 push %edi 10a280: 56 push %esi 10a281: 53 push %ebx 10a282: 83 ec 5c sub $0x5c,%esp struct sched_param schedparam; Objects_Name name; int rc; if ( !start_routine ) return EFAULT; 10a285: c7 45 b4 0e 00 00 00 movl $0xe,-0x4c(%ebp) int schedpolicy = SCHED_RR; struct sched_param schedparam; Objects_Name name; int rc; if ( !start_routine ) 10a28c: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a290: 0f 84 0f 02 00 00 je 10a4a5 return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 10a296: 8b 5d 0c mov 0xc(%ebp),%ebx 10a299: 85 db test %ebx,%ebx 10a29b: 75 05 jne 10a2a2 10a29d: bb 40 02 12 00 mov $0x120240,%ebx if ( !the_attr->is_initialized ) return EINVAL; 10a2a2: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp) if ( !start_routine ) return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; if ( !the_attr->is_initialized ) 10a2a9: 83 3b 00 cmpl $0x0,(%ebx) 10a2ac: 0f 84 f3 01 00 00 je 10a4a5 * stack space if it is allowed to allocate it itself. * * NOTE: If the user provides the stack we will let it drop below * twice the minimum. */ if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) ) 10a2b2: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a2b6: 74 0e je 10a2c6 10a2b8: a1 44 22 12 00 mov 0x122244,%eax 10a2bd: 39 43 08 cmp %eax,0x8(%ebx) 10a2c0: 0f 82 df 01 00 00 jb 10a4a5 * If inheritsched is set to PTHREAD_INHERIT_SCHED, then this thread * inherits scheduling attributes from the creating thread. If it is * PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the * attributes structure. */ switch ( the_attr->inheritsched ) { 10a2c6: 8b 43 10 mov 0x10(%ebx),%eax 10a2c9: 83 f8 01 cmp $0x1,%eax 10a2cc: 74 0b je 10a2d9 10a2ce: 83 f8 02 cmp $0x2,%eax 10a2d1: 0f 85 c7 01 00 00 jne 10a49e 10a2d7: eb 1f jmp 10a2f8 case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a2d9: a1 78 68 12 00 mov 0x126878,%eax 10a2de: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi schedpolicy = api->schedpolicy; 10a2e4: 8b 86 84 00 00 00 mov 0x84(%esi),%eax 10a2ea: 89 45 ac mov %eax,-0x54(%ebp) schedparam = api->schedparam; 10a2ed: 8d 7d c4 lea -0x3c(%ebp),%edi 10a2f0: 81 c6 88 00 00 00 add $0x88,%esi 10a2f6: eb 0c jmp 10a304 break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 10a2f8: 8b 43 14 mov 0x14(%ebx),%eax 10a2fb: 89 45 ac mov %eax,-0x54(%ebp) schedparam = the_attr->schedparam; 10a2fe: 8d 7d c4 lea -0x3c(%ebp),%edi 10a301: 8d 73 18 lea 0x18(%ebx),%esi 10a304: b9 07 00 00 00 mov $0x7,%ecx 10a309: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) return ENOTSUP; 10a30b: c7 45 b4 86 00 00 00 movl $0x86,-0x4c(%ebp) /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 10a312: 83 7b 0c 00 cmpl $0x0,0xc(%ebx) 10a316: 0f 85 89 01 00 00 jne 10a4a5 return ENOTSUP; /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 10a31c: 83 ec 0c sub $0xc,%esp 10a31f: ff 75 c4 pushl -0x3c(%ebp) 10a322: e8 2d 59 00 00 call 10fc54 <_POSIX_Priority_Is_valid> 10a327: 83 c4 10 add $0x10,%esp return EINVAL; 10a32a: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp) return ENOTSUP; /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 10a331: 84 c0 test %al,%al 10a333: 0f 84 6c 01 00 00 je 10a4a5 <== NEVER TAKEN return EINVAL; core_priority = _POSIX_Priority_To_core( schedparam.sched_priority ); 10a339: 8b 45 c4 mov -0x3c(%ebp),%eax 10a33c: 89 45 a8 mov %eax,-0x58(%ebp) RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core( int priority ) { return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1); 10a33f: 0f b6 3d 48 22 12 00 movzbl 0x122248,%edi /* * Set the core scheduling policy information. */ rc = _POSIX_Thread_Translate_sched_param( 10a346: 8d 45 e0 lea -0x20(%ebp),%eax 10a349: 50 push %eax 10a34a: 8d 45 e4 lea -0x1c(%ebp),%eax 10a34d: 50 push %eax 10a34e: 8d 45 c4 lea -0x3c(%ebp),%eax 10a351: 50 push %eax 10a352: ff 75 ac pushl -0x54(%ebp) 10a355: e8 1a 59 00 00 call 10fc74 <_POSIX_Thread_Translate_sched_param> 10a35a: 89 45 b4 mov %eax,-0x4c(%ebp) schedpolicy, &schedparam, &budget_algorithm, &budget_callout ); if ( rc ) 10a35d: 83 c4 10 add $0x10,%esp 10a360: 85 c0 test %eax,%eax 10a362: 0f 85 3d 01 00 00 jne 10a4a5 #endif /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 10a368: 83 ec 0c sub $0xc,%esp 10a36b: ff 35 f4 63 12 00 pushl 0x1263f4 10a371: e8 4e 15 00 00 call 10b8c4 <_API_Mutex_Lock> * _POSIX_Threads_Allocate */ RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information ); 10a376: c7 04 24 74 65 12 00 movl $0x126574,(%esp) 10a37d: e8 a2 1e 00 00 call 10c224 <_Objects_Allocate> 10a382: 89 45 b0 mov %eax,-0x50(%ebp) * Allocate the thread control block. * * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { 10a385: 83 c4 10 add $0x10,%esp 10a388: 85 c0 test %eax,%eax 10a38a: 75 05 jne 10a391 _RTEMS_Unlock_allocator(); 10a38c: 83 ec 0c sub $0xc,%esp 10a38f: eb 53 jmp 10a3e4 /* * Initialize the core thread for this task. */ name.name_p = NULL; /* posix threads don't have a name by default */ status = _Thread_Initialize( 10a391: 8b 4d e0 mov -0x20(%ebp),%ecx 10a394: 8b 75 e4 mov -0x1c(%ebp),%esi 10a397: 8b 53 08 mov 0x8(%ebx),%edx 10a39a: a1 44 22 12 00 mov 0x122244,%eax 10a39f: d1 e0 shl %eax 10a3a1: 39 d0 cmp %edx,%eax 10a3a3: 73 02 jae 10a3a7 10a3a5: 89 d0 mov %edx,%eax 10a3a7: 52 push %edx 10a3a8: 6a 00 push $0x0 10a3aa: 6a 00 push $0x0 10a3ac: 51 push %ecx 10a3ad: 56 push %esi 10a3ae: 6a 01 push $0x1 10a3b0: 81 e7 ff 00 00 00 and $0xff,%edi 10a3b6: 2b 7d a8 sub -0x58(%ebp),%edi 10a3b9: 57 push %edi 10a3ba: 6a 01 push $0x1 10a3bc: 50 push %eax 10a3bd: ff 73 04 pushl 0x4(%ebx) 10a3c0: ff 75 b0 pushl -0x50(%ebp) 10a3c3: 68 74 65 12 00 push $0x126574 10a3c8: e8 cb 2d 00 00 call 10d198 <_Thread_Initialize> budget_callout, 0, /* isr level */ name /* posix threads don't have a name */ ); if ( !status ) { 10a3cd: 83 c4 30 add $0x30,%esp 10a3d0: 84 c0 test %al,%al 10a3d2: 75 2a jne 10a3fe RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 10a3d4: 56 push %esi 10a3d5: 56 push %esi 10a3d6: ff 75 b0 pushl -0x50(%ebp) 10a3d9: 68 74 65 12 00 push $0x126574 10a3de: e8 35 21 00 00 call 10c518 <_Objects_Free> _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 10a3e3: 5b pop %ebx 10a3e4: ff 35 f4 63 12 00 pushl 0x1263f4 10a3ea: e8 1d 15 00 00 call 10b90c <_API_Mutex_Unlock> return EAGAIN; 10a3ef: 83 c4 10 add $0x10,%esp 10a3f2: c7 45 b4 0b 00 00 00 movl $0xb,-0x4c(%ebp) 10a3f9: e9 a7 00 00 00 jmp 10a4a5 } /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10a3fe: 8b 45 b0 mov -0x50(%ebp),%eax 10a401: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx api->Attributes = *the_attr; 10a407: b9 10 00 00 00 mov $0x10,%ecx 10a40c: 89 d7 mov %edx,%edi 10a40e: 89 de mov %ebx,%esi 10a410: f3 a5 rep movsl %ds:(%esi),%es:(%edi) api->detachstate = the_attr->detachstate; 10a412: 8b 43 3c mov 0x3c(%ebx),%eax 10a415: 89 42 40 mov %eax,0x40(%edx) api->schedpolicy = schedpolicy; 10a418: 8b 45 ac mov -0x54(%ebp),%eax 10a41b: 89 82 84 00 00 00 mov %eax,0x84(%edx) api->schedparam = schedparam; 10a421: 8d ba 88 00 00 00 lea 0x88(%edx),%edi 10a427: 8d 75 c4 lea -0x3c(%ebp),%esi 10a42a: b1 07 mov $0x7,%cl 10a42c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 10a42e: 83 ec 0c sub $0xc,%esp 10a431: 6a 00 push $0x0 10a433: ff 75 14 pushl 0x14(%ebp) 10a436: ff 75 10 pushl 0x10(%ebp) 10a439: 6a 01 push $0x1 10a43b: ff 75 b0 pushl -0x50(%ebp) 10a43e: 89 55 a4 mov %edx,-0x5c(%ebp) 10a441: e8 72 35 00 00 call 10d9b8 <_Thread_Start> _RTEMS_Unlock_allocator(); return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { 10a446: 83 c4 20 add $0x20,%esp 10a449: 83 7d ac 04 cmpl $0x4,-0x54(%ebp) 10a44d: 8b 55 a4 mov -0x5c(%ebp),%edx 10a450: 75 2e jne 10a480 _Watchdog_Insert_ticks( 10a452: 83 ec 0c sub $0xc,%esp &api->Sporadic_timer, _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ) 10a455: 8d 82 90 00 00 00 lea 0x90(%edx),%eax return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 10a45b: 50 push %eax 10a45c: e8 a7 36 00 00 call 10db08 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10a461: 8b 55 a4 mov -0x5c(%ebp),%edx 10a464: 89 82 b4 00 00 00 mov %eax,0xb4(%edx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10a46a: 58 pop %eax 10a46b: 59 pop %ecx 10a46c: 81 c2 a8 00 00 00 add $0xa8,%edx 10a472: 52 push %edx 10a473: 68 14 64 12 00 push $0x126414 10a478: e8 3f 39 00 00 call 10ddbc <_Watchdog_Insert> 10a47d: 83 c4 10 add $0x10,%esp } /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 10a480: 8b 45 b0 mov -0x50(%ebp),%eax 10a483: 8b 50 08 mov 0x8(%eax),%edx 10a486: 8b 45 08 mov 0x8(%ebp),%eax 10a489: 89 10 mov %edx,(%eax) _RTEMS_Unlock_allocator(); 10a48b: 83 ec 0c sub $0xc,%esp 10a48e: ff 35 f4 63 12 00 pushl 0x1263f4 10a494: e8 73 14 00 00 call 10b90c <_API_Mutex_Unlock> return 0; 10a499: 83 c4 10 add $0x10,%esp 10a49c: eb 07 jmp 10a4a5 schedpolicy = the_attr->schedpolicy; schedparam = the_attr->schedparam; break; default: return EINVAL; 10a49e: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp) */ *thread = the_thread->Object.id; _RTEMS_Unlock_allocator(); return 0; } 10a4a5: 8b 45 b4 mov -0x4c(%ebp),%eax 10a4a8: 8d 65 f4 lea -0xc(%ebp),%esp 10a4ab: 5b pop %ebx 10a4ac: 5e pop %esi 10a4ad: 5f pop %edi 10a4ae: c9 leave 10a4af: c3 ret =============================================================================== 00110d4c : } void pthread_exit( void *value_ptr ) { 110d4c: 55 push %ebp 110d4d: 89 e5 mov %esp,%ebp 110d4f: 83 ec 10 sub $0x10,%esp _POSIX_Thread_Exit( _Thread_Executing, value_ptr ); 110d52: ff 75 08 pushl 0x8(%ebp) 110d55: ff 35 68 58 12 00 pushl 0x125868 110d5b: e8 88 ff ff ff call 110ce8 <_POSIX_Thread_Exit> 110d60: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 110d63: c9 leave <== NOT EXECUTED 110d64: c3 ret <== NOT EXECUTED =============================================================================== 001222a4 : int pthread_kill( pthread_t thread, int sig ) { 1222a4: 55 push %ebp 1222a5: 89 e5 mov %esp,%ebp 1222a7: 57 push %edi 1222a8: 56 push %esi 1222a9: 53 push %ebx 1222aa: 83 ec 1c sub $0x1c,%esp 1222ad: 8b 5d 0c mov 0xc(%ebp),%ebx POSIX_API_Control *api; Thread_Control *the_thread; Objects_Locations location; if ( !sig ) 1222b0: 85 db test %ebx,%ebx 1222b2: 74 08 je 1222bc static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 1222b4: 8d 7b ff lea -0x1(%ebx),%edi rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 1222b7: 83 ff 1f cmp $0x1f,%edi 1222ba: 76 0d jbe 1222c9 rtems_set_errno_and_return_minus_one( EINVAL ); 1222bc: e8 0f 37 ff ff call 1159d0 <__errno> 1222c1: c7 00 16 00 00 00 movl $0x16,(%eax) 1222c7: eb 73 jmp 12233c the_thread = _Thread_Get( thread, &location ); 1222c9: 52 push %edx 1222ca: 52 push %edx 1222cb: 8d 45 e4 lea -0x1c(%ebp),%eax 1222ce: 50 push %eax 1222cf: ff 75 08 pushl 0x8(%ebp) 1222d2: e8 05 e7 fe ff call 1109dc <_Thread_Get> 1222d7: 89 c6 mov %eax,%esi switch ( location ) { 1222d9: 83 c4 10 add $0x10,%esp 1222dc: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 1222e0: 75 4f jne 122331 <== NEVER TAKEN case OBJECTS_LOCAL: /* * If sig == 0 then just validate arguments */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 1222e2: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx if ( sig ) { if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 1222e8: 6b c3 0c imul $0xc,%ebx,%eax 1222eb: 83 b8 18 ba 12 00 01 cmpl $0x1,0x12ba18(%eax) 1222f2: 74 34 je 122328 static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 1222f4: b8 01 00 00 00 mov $0x1,%eax 1222f9: 89 f9 mov %edi,%ecx 1222fb: d3 e0 shl %cl,%eax return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 1222fd: 09 82 d4 00 00 00 or %eax,0xd4(%edx) (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 122303: 50 push %eax 122304: 6a 00 push $0x0 122306: 53 push %ebx 122307: 56 push %esi 122308: e8 93 fe ff ff call 1221a0 <_POSIX_signals_Unblock_thread> if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 12230d: 83 c4 10 add $0x10,%esp 122310: 83 3d d8 b9 12 00 00 cmpl $0x0,0x12b9d8 122317: 74 0f je 122328 122319: 3b 35 dc b9 12 00 cmp 0x12b9dc,%esi 12231f: 75 07 jne 122328 _Thread_Dispatch_necessary = true; 122321: c6 05 e8 b9 12 00 01 movb $0x1,0x12b9e8 } _Thread_Enable_dispatch(); 122328: e8 8d e6 fe ff call 1109ba <_Thread_Enable_dispatch> return 0; 12232d: 31 c0 xor %eax,%eax 12232f: eb 0e jmp 12233f #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( ESRCH ); 122331: e8 9a 36 ff ff call 1159d0 <__errno> <== NOT EXECUTED 122336: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED 12233c: 83 c8 ff or $0xffffffff,%eax } 12233f: 8d 65 f4 lea -0xc(%ebp),%esp 122342: 5b pop %ebx 122343: 5e pop %esi 122344: 5f pop %edi 122345: c9 leave 122346: c3 ret =============================================================================== 0010bf78 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 10bf78: 55 push %ebp 10bf79: 89 e5 mov %esp,%ebp 10bf7b: 53 push %ebx 10bf7c: 83 ec 2c sub $0x2c,%esp * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10bf7f: 8d 45 f4 lea -0xc(%ebp),%eax 10bf82: 50 push %eax 10bf83: ff 75 0c pushl 0xc(%ebp) 10bf86: e8 b9 00 00 00 call 10c044 <_POSIX_Absolute_timeout_to_ticks> 10bf8b: 89 c3 mov %eax,%ebx int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *__mutex)); int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *__mutex)); #if defined(_POSIX_TIMEOUTS) int _EXFUN(pthread_mutex_timedlock, 10bf8d: 83 c4 0c add $0xc,%esp 10bf90: 83 f8 03 cmp $0x3,%eax 10bf93: 0f 94 c2 sete %dl if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks ); 10bf96: ff 75 f4 pushl -0xc(%ebp) 10bf99: 0f b6 c2 movzbl %dl,%eax 10bf9c: 50 push %eax 10bf9d: ff 75 08 pushl 0x8(%ebp) 10bfa0: 88 55 e4 mov %dl,-0x1c(%ebp) 10bfa3: e8 e8 fe ff ff call 10be90 <_POSIX_Mutex_Lock_support> * This service only gives us the option to block. We used a polling * attempt to lock if the abstime was not in the future. If we did * not obtain the mutex, then not look at the status immediately, * make sure the right reason is returned. */ if ( !do_wait && (lock_status == EBUSY) ) { 10bfa8: 83 c4 10 add $0x10,%esp 10bfab: 8a 55 e4 mov -0x1c(%ebp),%dl 10bfae: 84 d2 test %dl,%dl 10bfb0: 75 1d jne 10bfcf 10bfb2: 83 f8 10 cmp $0x10,%eax 10bfb5: 75 18 jne 10bfcf <== NEVER TAKEN if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10bfb7: 85 db test %ebx,%ebx 10bfb9: 74 08 je 10bfc3 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10bfbb: 4b dec %ebx 10bfbc: 83 fb 01 cmp $0x1,%ebx 10bfbf: 77 0e ja 10bfcf <== NEVER TAKEN 10bfc1: eb 07 jmp 10bfca * not obtain the mutex, then not look at the status immediately, * make sure the right reason is returned. */ if ( !do_wait && (lock_status == EBUSY) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; 10bfc3: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10bfc8: eb 05 jmp 10bfcf <== NOT EXECUTED if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10bfca: b8 74 00 00 00 mov $0x74,%eax } return lock_status; } 10bfcf: 8b 5d fc mov -0x4(%ebp),%ebx 10bfd2: c9 leave 10bfd3: c3 ret =============================================================================== 0010bbf0 : int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { 10bbf0: 55 push %ebp 10bbf1: 89 e5 mov %esp,%ebp 10bbf3: 8b 55 08 mov 0x8(%ebp),%edx 10bbf6: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 10bbf9: b8 16 00 00 00 mov $0x16,%eax int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { if ( !attr || !attr->is_initialized ) 10bbfe: 85 d2 test %edx,%edx 10bc00: 74 0f je 10bc11 10bc02: 83 3a 00 cmpl $0x0,(%edx) 10bc05: 74 0a je 10bc11 return EINVAL; switch ( pshared ) { 10bc07: 83 f9 01 cmp $0x1,%ecx 10bc0a: 77 05 ja 10bc11 <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10bc0c: 89 4a 04 mov %ecx,0x4(%edx) return 0; 10bc0f: 30 c0 xor %al,%al default: return EINVAL; } } 10bc11: c9 leave 10bc12: c3 ret =============================================================================== 00109e18 : #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { 109e18: 55 push %ebp 109e19: 89 e5 mov %esp,%ebp 109e1b: 8b 55 08 mov 0x8(%ebp),%edx 109e1e: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 109e21: b8 16 00 00 00 mov $0x16,%eax int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { if ( !attr || !attr->is_initialized ) 109e26: 85 d2 test %edx,%edx 109e28: 74 0f je 109e39 109e2a: 83 3a 00 cmpl $0x0,(%edx) 109e2d: 74 0a je 109e39 <== NEVER TAKEN return EINVAL; switch ( type ) { 109e2f: 83 f9 03 cmp $0x3,%ecx 109e32: 77 05 ja 109e39 case PTHREAD_MUTEX_NORMAL: case PTHREAD_MUTEX_RECURSIVE: case PTHREAD_MUTEX_ERRORCHECK: case PTHREAD_MUTEX_DEFAULT: attr->type = type; 109e34: 89 4a 10 mov %ecx,0x10(%edx) return 0; 109e37: 30 c0 xor %al,%al default: return EINVAL; } } 109e39: c9 leave 109e3a: c3 ret =============================================================================== 0010a8c8 : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 10a8c8: 55 push %ebp 10a8c9: 89 e5 mov %esp,%ebp 10a8cb: 56 push %esi 10a8cc: 53 push %ebx 10a8cd: 83 ec 10 sub $0x10,%esp 10a8d0: 8b 5d 08 mov 0x8(%ebp),%ebx 10a8d3: 8b 75 0c mov 0xc(%ebp),%esi if ( !once_control || !init_routine ) 10a8d6: 85 f6 test %esi,%esi 10a8d8: 74 51 je 10a92b 10a8da: 85 db test %ebx,%ebx 10a8dc: 74 4d je 10a92b once_control->init_executed = true; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; 10a8de: 31 c0 xor %eax,%eax ) { if ( !once_control || !init_routine ) return EINVAL; if ( !once_control->init_executed ) { 10a8e0: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a8e4: 75 4a jne 10a930 rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 10a8e6: 52 push %edx 10a8e7: 8d 45 f4 lea -0xc(%ebp),%eax 10a8ea: 50 push %eax 10a8eb: 68 00 01 00 00 push $0x100 10a8f0: 68 00 01 00 00 push $0x100 10a8f5: e8 9e 0a 00 00 call 10b398 if ( !once_control->init_executed ) { 10a8fa: 83 c4 10 add $0x10,%esp 10a8fd: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a901: 75 0f jne 10a912 <== NEVER TAKEN once_control->is_initialized = true; 10a903: c7 03 01 00 00 00 movl $0x1,(%ebx) once_control->init_executed = true; 10a909: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) (*init_routine)(); 10a910: ff d6 call *%esi } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10a912: 50 push %eax 10a913: 8d 45 f4 lea -0xc(%ebp),%eax 10a916: 50 push %eax 10a917: 68 00 01 00 00 push $0x100 10a91c: ff 75 f4 pushl -0xc(%ebp) 10a91f: e8 74 0a 00 00 call 10b398 10a924: 83 c4 10 add $0x10,%esp } return 0; 10a927: 31 c0 xor %eax,%eax 10a929: eb 05 jmp 10a930 pthread_once_t *once_control, void (*init_routine)(void) ) { if ( !once_control || !init_routine ) return EINVAL; 10a92b: b8 16 00 00 00 mov $0x16,%eax (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; } 10a930: 8d 65 f8 lea -0x8(%ebp),%esp 10a933: 5b pop %ebx 10a934: 5e pop %esi 10a935: c9 leave 10a936: c3 ret =============================================================================== 0010b0f4 : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 10b0f4: 55 push %ebp 10b0f5: 89 e5 mov %esp,%ebp 10b0f7: 56 push %esi 10b0f8: 53 push %ebx 10b0f9: 83 ec 10 sub $0x10,%esp 10b0fc: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Error check parameters */ if ( !rwlock ) return EINVAL; 10b0ff: b8 16 00 00 00 mov $0x16,%eax const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 10b104: 85 db test %ebx,%ebx 10b106: 0f 84 8b 00 00 00 je 10b197 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10b10c: 8b 75 0c mov 0xc(%ebp),%esi 10b10f: 85 f6 test %esi,%esi 10b111: 75 0f jne 10b122 the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 10b113: 83 ec 0c sub $0xc,%esp 10b116: 8d 75 ec lea -0x14(%ebp),%esi 10b119: 56 push %esi 10b11a: e8 5d 09 00 00 call 10ba7c 10b11f: 83 c4 10 add $0x10,%esp /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) return EINVAL; 10b122: b8 16 00 00 00 mov $0x16,%eax } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 10b127: 83 3e 00 cmpl $0x0,(%esi) 10b12a: 74 6b je 10b197 <== NEVER TAKEN return EINVAL; switch ( the_attr->process_shared ) { 10b12c: 83 7e 04 00 cmpl $0x0,0x4(%esi) 10b130: 75 65 jne 10b197 <== NEVER TAKEN */ RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes( CORE_RWLock_Attributes *the_attributes ) { the_attributes->XXX = 0; 10b132: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b139: a1 50 83 12 00 mov 0x128350,%eax 10b13e: 40 inc %eax 10b13f: a3 50 83 12 00 mov %eax,0x128350 * the inactive chain of free RWLock control blocks. */ RTEMS_INLINE_ROUTINE POSIX_RWLock_Control *_POSIX_RWLock_Allocate( void ) { return (POSIX_RWLock_Control *) _Objects_Allocate( &_POSIX_RWLock_Information ); 10b144: 83 ec 0c sub $0xc,%esp 10b147: 68 34 85 12 00 push $0x128534 10b14c: e8 33 23 00 00 call 10d484 <_Objects_Allocate> 10b151: 89 c6 mov %eax,%esi */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 10b153: 83 c4 10 add $0x10,%esp 10b156: 85 c0 test %eax,%eax 10b158: 75 0c jne 10b166 _Thread_Enable_dispatch(); 10b15a: e8 03 32 00 00 call 10e362 <_Thread_Enable_dispatch> return EAGAIN; 10b15f: b8 0b 00 00 00 mov $0xb,%eax 10b164: eb 31 jmp 10b197 } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 10b166: 50 push %eax 10b167: 50 push %eax 10b168: 8d 45 f4 lea -0xc(%ebp),%eax 10b16b: 50 push %eax 10b16c: 8d 46 10 lea 0x10(%esi),%eax 10b16f: 50 push %eax 10b170: e8 7b 1b 00 00 call 10ccf0 <_CORE_RWLock_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10b175: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10b178: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10b17b: 8b 15 50 85 12 00 mov 0x128550,%edx 10b181: 89 34 8a mov %esi,(%edx,%ecx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10b184: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 10b18b: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10b18d: e8 d0 31 00 00 call 10e362 <_Thread_Enable_dispatch> return 0; 10b192: 83 c4 10 add $0x10,%esp 10b195: 31 c0 xor %eax,%eax } 10b197: 8d 65 f8 lea -0x8(%ebp),%esp 10b19a: 5b pop %ebx 10b19b: 5e pop %esi 10b19c: c9 leave 10b19d: c3 ret =============================================================================== 0010b208 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10b208: 55 push %ebp 10b209: 89 e5 mov %esp,%ebp 10b20b: 57 push %edi 10b20c: 56 push %esi 10b20d: 53 push %ebx 10b20e: 83 ec 2c sub $0x2c,%esp 10b211: 8b 7d 08 mov 0x8(%ebp),%edi Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) return EINVAL; 10b214: bb 16 00 00 00 mov $0x16,%ebx Objects_Locations location; Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 10b219: 85 ff test %edi,%edi 10b21b: 0f 84 87 00 00 00 je 10b2a8 * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10b221: 50 push %eax 10b222: 50 push %eax 10b223: 8d 45 e0 lea -0x20(%ebp),%eax 10b226: 50 push %eax 10b227: ff 75 0c pushl 0xc(%ebp) 10b22a: e8 65 59 00 00 call 110b94 <_POSIX_Absolute_timeout_to_ticks> 10b22f: 89 c6 mov %eax,%esi 10b231: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10b234: 8d 45 e4 lea -0x1c(%ebp),%eax 10b237: 50 push %eax 10b238: ff 37 pushl (%edi) 10b23a: 68 34 85 12 00 push $0x128534 10b23f: e8 6c 26 00 00 call 10d8b0 <_Objects_Get> switch ( location ) { 10b244: 83 c4 10 add $0x10,%esp 10b247: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b24b: 75 5b jne 10b2a8 int _EXFUN(pthread_rwlock_init, (pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr)); int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_timedrdlock, 10b24d: 83 fe 03 cmp $0x3,%esi 10b250: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 10b253: 83 ec 0c sub $0xc,%esp 10b256: 6a 00 push $0x0 10b258: ff 75 e0 pushl -0x20(%ebp) 10b25b: 0f b6 ca movzbl %dl,%ecx 10b25e: 51 push %ecx 10b25f: ff 37 pushl (%edi) 10b261: 83 c0 10 add $0x10,%eax 10b264: 50 push %eax 10b265: 88 55 d4 mov %dl,-0x2c(%ebp) 10b268: e8 b7 1a 00 00 call 10cd24 <_CORE_RWLock_Obtain_for_reading> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10b26d: 83 c4 20 add $0x20,%esp 10b270: e8 ed 30 00 00 call 10e362 <_Thread_Enable_dispatch> if ( !do_wait ) { 10b275: 8a 55 d4 mov -0x2c(%ebp),%dl 10b278: 84 d2 test %dl,%dl 10b27a: 75 17 jne 10b293 if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { 10b27c: a1 78 88 12 00 mov 0x128878,%eax 10b281: 83 78 34 02 cmpl $0x2,0x34(%eax) 10b285: 75 0c jne 10b293 if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10b287: 85 f6 test %esi,%esi 10b289: 74 1d je 10b2a8 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b28b: 4e dec %esi status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10b28c: b3 74 mov $0x74,%bl _Thread_Enable_dispatch(); if ( !do_wait ) { if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b28e: 83 fe 01 cmp $0x1,%esi 10b291: 76 15 jbe 10b2a8 <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b293: 83 ec 0c sub $0xc,%esp (CORE_RWLock_Status) _Thread_Executing->Wait.return_code 10b296: a1 78 88 12 00 mov 0x128878,%eax status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b29b: ff 70 34 pushl 0x34(%eax) 10b29e: e8 bd 00 00 00 call 10b360 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10b2a3: 89 c3 mov %eax,%ebx 10b2a5: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10b2a8: 89 d8 mov %ebx,%eax 10b2aa: 8d 65 f4 lea -0xc(%ebp),%esp 10b2ad: 5b pop %ebx 10b2ae: 5e pop %esi 10b2af: 5f pop %edi 10b2b0: c9 leave 10b2b1: c3 ret =============================================================================== 0010b2b4 : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10b2b4: 55 push %ebp 10b2b5: 89 e5 mov %esp,%ebp 10b2b7: 57 push %edi 10b2b8: 56 push %esi 10b2b9: 53 push %ebx 10b2ba: 83 ec 2c sub $0x2c,%esp 10b2bd: 8b 7d 08 mov 0x8(%ebp),%edi Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) return EINVAL; 10b2c0: bb 16 00 00 00 mov $0x16,%ebx Objects_Locations location; Watchdog_Interval ticks; bool do_wait = true; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 10b2c5: 85 ff test %edi,%edi 10b2c7: 0f 84 87 00 00 00 je 10b354 * * If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID, * POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW, * then we should not wait. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10b2cd: 50 push %eax 10b2ce: 50 push %eax 10b2cf: 8d 45 e0 lea -0x20(%ebp),%eax 10b2d2: 50 push %eax 10b2d3: ff 75 0c pushl 0xc(%ebp) 10b2d6: e8 b9 58 00 00 call 110b94 <_POSIX_Absolute_timeout_to_ticks> 10b2db: 89 c6 mov %eax,%esi 10b2dd: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10b2e0: 8d 45 e4 lea -0x1c(%ebp),%eax 10b2e3: 50 push %eax 10b2e4: ff 37 pushl (%edi) 10b2e6: 68 34 85 12 00 push $0x128534 10b2eb: e8 c0 25 00 00 call 10d8b0 <_Objects_Get> switch ( location ) { 10b2f0: 83 c4 10 add $0x10,%esp 10b2f3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b2f7: 75 5b jne 10b354 (pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime)); int _EXFUN(pthread_rwlock_unlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock)); int _EXFUN(pthread_rwlock_timedwrlock, 10b2f9: 83 fe 03 cmp $0x3,%esi 10b2fc: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 10b2ff: 83 ec 0c sub $0xc,%esp 10b302: 6a 00 push $0x0 10b304: ff 75 e0 pushl -0x20(%ebp) 10b307: 0f b6 ca movzbl %dl,%ecx 10b30a: 51 push %ecx 10b30b: ff 37 pushl (%edi) 10b30d: 83 c0 10 add $0x10,%eax 10b310: 50 push %eax 10b311: 88 55 d4 mov %dl,-0x2c(%ebp) 10b314: e8 c3 1a 00 00 call 10cddc <_CORE_RWLock_Obtain_for_writing> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10b319: 83 c4 20 add $0x20,%esp 10b31c: e8 41 30 00 00 call 10e362 <_Thread_Enable_dispatch> if ( !do_wait && 10b321: 8a 55 d4 mov -0x2c(%ebp),%dl 10b324: 84 d2 test %dl,%dl 10b326: 75 17 jne 10b33f (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { 10b328: a1 78 88 12 00 mov 0x128878,%eax ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 10b32d: 83 78 34 02 cmpl $0x2,0x34(%eax) 10b331: 75 0c jne 10b33f (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10b333: 85 f6 test %esi,%esi 10b335: 74 1d je 10b354 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b337: 4e dec %esi status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10b338: b3 74 mov $0x74,%bl _Thread_Enable_dispatch(); if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b33a: 83 fe 01 cmp $0x1,%esi 10b33d: 76 15 jbe 10b354 <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b33f: 83 ec 0c sub $0xc,%esp (CORE_RWLock_Status) _Thread_Executing->Wait.return_code 10b342: a1 78 88 12 00 mov 0x128878,%eax if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b347: ff 70 34 pushl 0x34(%eax) 10b34a: e8 11 00 00 00 call 10b360 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10b34f: 89 c3 mov %eax,%ebx 10b351: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10b354: 89 d8 mov %ebx,%eax 10b356: 8d 65 f4 lea -0xc(%ebp),%esp 10b359: 5b pop %ebx 10b35a: 5e pop %esi 10b35b: 5f pop %edi 10b35c: c9 leave 10b35d: c3 ret =============================================================================== 0010ba9c : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { 10ba9c: 55 push %ebp 10ba9d: 89 e5 mov %esp,%ebp 10ba9f: 8b 55 08 mov 0x8(%ebp),%edx 10baa2: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr ) return EINVAL; 10baa5: b8 16 00 00 00 mov $0x16,%eax int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { if ( !attr ) 10baaa: 85 d2 test %edx,%edx 10baac: 74 0f je 10babd return EINVAL; if ( !attr->is_initialized ) 10baae: 83 3a 00 cmpl $0x0,(%edx) 10bab1: 74 0a je 10babd return EINVAL; switch ( pshared ) { 10bab3: 83 f9 01 cmp $0x1,%ecx 10bab6: 77 05 ja 10babd <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10bab8: 89 4a 04 mov %ecx,0x4(%edx) return 0; 10babb: 30 c0 xor %al,%al default: return EINVAL; } } 10babd: c9 leave 10babe: c3 ret =============================================================================== 0010c798 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 10c798: 55 push %ebp 10c799: 89 e5 mov %esp,%ebp 10c79b: 57 push %edi 10c79c: 56 push %esi 10c79d: 53 push %ebx 10c79e: 83 ec 2c sub $0x2c,%esp 10c7a1: 8b 75 10 mov 0x10(%ebp),%esi /* * Check all the parameters */ if ( !param ) return EINVAL; 10c7a4: c7 45 d4 16 00 00 00 movl $0x16,-0x2c(%ebp) int rc; /* * Check all the parameters */ if ( !param ) 10c7ab: 85 f6 test %esi,%esi 10c7ad: 0f 84 fc 00 00 00 je 10c8af return EINVAL; rc = _POSIX_Thread_Translate_sched_param( 10c7b3: 8d 45 e0 lea -0x20(%ebp),%eax 10c7b6: 50 push %eax 10c7b7: 8d 45 e4 lea -0x1c(%ebp),%eax 10c7ba: 50 push %eax 10c7bb: 56 push %esi 10c7bc: ff 75 0c pushl 0xc(%ebp) 10c7bf: e8 20 53 00 00 call 111ae4 <_POSIX_Thread_Translate_sched_param> 10c7c4: 89 45 d4 mov %eax,-0x2c(%ebp) policy, param, &budget_algorithm, &budget_callout ); if ( rc ) 10c7c7: 83 c4 10 add $0x10,%esp 10c7ca: 85 c0 test %eax,%eax 10c7cc: 0f 85 dd 00 00 00 jne 10c8af return rc; /* * Actually change the scheduling policy and parameters */ the_thread = _Thread_Get( thread, &location ); 10c7d2: 53 push %ebx 10c7d3: 53 push %ebx 10c7d4: 8d 45 dc lea -0x24(%ebp),%eax 10c7d7: 50 push %eax 10c7d8: ff 75 08 pushl 0x8(%ebp) 10c7db: e8 54 27 00 00 call 10ef34 <_Thread_Get> 10c7e0: 89 c2 mov %eax,%edx switch ( location ) { 10c7e2: 83 c4 10 add $0x10,%esp 10c7e5: 83 7d dc 00 cmpl $0x0,-0x24(%ebp) 10c7e9: 0f 85 b9 00 00 00 jne 10c8a8 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10c7ef: 8b 98 ec 00 00 00 mov 0xec(%eax),%ebx if ( api->schedpolicy == SCHED_SPORADIC ) 10c7f5: 83 bb 84 00 00 00 04 cmpl $0x4,0x84(%ebx) 10c7fc: 75 18 jne 10c816 (void) _Watchdog_Remove( &api->Sporadic_timer ); 10c7fe: 83 ec 0c sub $0xc,%esp 10c801: 8d 83 a8 00 00 00 lea 0xa8(%ebx),%eax 10c807: 50 push %eax 10c808: 89 55 d0 mov %edx,-0x30(%ebp) 10c80b: e8 68 35 00 00 call 10fd78 <_Watchdog_Remove> 10c810: 83 c4 10 add $0x10,%esp 10c813: 8b 55 d0 mov -0x30(%ebp),%edx api->schedpolicy = policy; 10c816: 8b 45 0c mov 0xc(%ebp),%eax 10c819: 89 83 84 00 00 00 mov %eax,0x84(%ebx) api->schedparam = *param; 10c81f: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi 10c825: b9 07 00 00 00 mov $0x7,%ecx 10c82a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_thread->budget_algorithm = budget_algorithm; 10c82c: 8b 45 e4 mov -0x1c(%ebp),%eax 10c82f: 89 42 7c mov %eax,0x7c(%edx) the_thread->budget_callout = budget_callout; 10c832: 8b 45 e0 mov -0x20(%ebp),%eax 10c835: 89 82 80 00 00 00 mov %eax,0x80(%edx) switch ( api->schedpolicy ) { 10c83b: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10c83f: 78 60 js 10c8a1 <== NEVER TAKEN 10c841: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) 10c845: 7e 08 jle 10c84f 10c847: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) 10c84b: 75 54 jne 10c8a1 <== NEVER TAKEN 10c84d: eb 24 jmp 10c873 case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c84f: a1 c0 a3 12 00 mov 0x12a3c0,%eax 10c854: 89 42 78 mov %eax,0x78(%edx) 10c857: 0f b6 05 88 62 12 00 movzbl 0x126288,%eax 10c85e: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax the_thread->real_priority = 10c864: 89 42 18 mov %eax,0x18(%edx) _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 10c867: 51 push %ecx 10c868: 6a 01 push $0x1 10c86a: 50 push %eax 10c86b: 52 push %edx 10c86c: e8 cb 22 00 00 call 10eb3c <_Thread_Change_priority> 10c871: eb 2b jmp 10c89e true ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 10c873: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 10c879: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) _Watchdog_Remove( &api->Sporadic_timer ); 10c87f: 83 ec 0c sub $0xc,%esp 10c882: 81 c3 a8 00 00 00 add $0xa8,%ebx 10c888: 53 push %ebx 10c889: 89 55 d0 mov %edx,-0x30(%ebp) 10c88c: e8 e7 34 00 00 call 10fd78 <_Watchdog_Remove> _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 10c891: 58 pop %eax 10c892: 5a pop %edx 10c893: 8b 55 d0 mov -0x30(%ebp),%edx 10c896: 52 push %edx 10c897: 6a 00 push $0x0 10c899: e8 e5 fd ff ff call 10c683 <_POSIX_Threads_Sporadic_budget_TSR> break; 10c89e: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10c8a1: e8 6c 26 00 00 call 10ef12 <_Thread_Enable_dispatch> return 0; 10c8a6: eb 07 jmp 10c8af #endif case OBJECTS_ERROR: break; } return ESRCH; 10c8a8: c7 45 d4 03 00 00 00 movl $0x3,-0x2c(%ebp) } 10c8af: 8b 45 d4 mov -0x2c(%ebp),%eax 10c8b2: 8d 65 f4 lea -0xc(%ebp),%esp 10c8b5: 5b pop %ebx 10c8b6: 5e pop %esi 10c8b7: 5f pop %edi 10c8b8: c9 leave 10c8b9: c3 ret =============================================================================== 0010a690 : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 10a690: 55 push %ebp 10a691: 89 e5 mov %esp,%ebp 10a693: 53 push %ebx 10a694: 83 ec 04 sub $0x4,%esp * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 10a697: 83 3d 6c 68 12 00 00 cmpl $0x0,0x12686c 10a69e: 75 48 jne 10a6e8 <== NEVER TAKEN return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a6a0: a1 70 68 12 00 mov 0x126870,%eax 10a6a5: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 10a6ab: 8b 15 48 63 12 00 mov 0x126348,%edx 10a6b1: 42 inc %edx 10a6b2: 89 15 48 63 12 00 mov %edx,0x126348 */ void pthread_testcancel( void ) { POSIX_API_Control *thread_support; bool cancel = false; 10a6b8: 31 db xor %ebx,%ebx return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10a6ba: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax) 10a6c1: 75 0a jne 10a6cd <== NEVER TAKEN /* Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ int _EXFUN(pthread_setcancelstate, (int __state, int *__oldstate)); int _EXFUN(pthread_setcanceltype, (int __type, int *__oldtype)); void _EXFUN(pthread_testcancel, (void)); 10a6c3: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax) 10a6ca: 0f 95 c3 setne %bl thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a6cd: e8 e4 25 00 00 call 10ccb6 <_Thread_Enable_dispatch> if ( cancel ) 10a6d2: 84 db test %bl,%bl 10a6d4: 74 12 je 10a6e8 _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10a6d6: 50 push %eax 10a6d7: 50 push %eax 10a6d8: 6a ff push $0xffffffff 10a6da: ff 35 70 68 12 00 pushl 0x126870 10a6e0: e8 bf 52 00 00 call 10f9a4 <_POSIX_Thread_Exit> 10a6e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10a6e8: 8b 5d fc mov -0x4(%ebp),%ebx 10a6eb: c9 leave 10a6ec: c3 ret =============================================================================== 0011d114 : ssize_t read( int fd, void *buffer, size_t count ) { 11d114: 55 push %ebp 11d115: 89 e5 mov %esp,%ebp 11d117: 56 push %esi 11d118: 53 push %ebx 11d119: 8b 5d 08 mov 0x8(%ebp),%ebx 11d11c: 8b 55 0c mov 0xc(%ebp),%edx 11d11f: 8b 4d 10 mov 0x10(%ebp),%ecx ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11d122: 3b 1d 44 11 12 00 cmp 0x121144,%ebx 11d128: 73 14 jae 11d13e <== NEVER TAKEN iop = rtems_libio_iop( fd ); 11d12a: 6b db 38 imul $0x38,%ebx,%ebx 11d12d: 03 1d f8 51 12 00 add 0x1251f8,%ebx rtems_libio_check_is_open( iop ); 11d133: 8b 73 14 mov 0x14(%ebx),%esi 11d136: f7 c6 00 01 00 00 test $0x100,%esi 11d13c: 75 0d jne 11d14b 11d13e: e8 f5 3f ff ff call 111138 <__errno> 11d143: c7 00 09 00 00 00 movl $0x9,(%eax) 11d149: eb 1a jmp 11d165 rtems_libio_check_buffer( buffer ); 11d14b: 85 d2 test %edx,%edx 11d14d: 74 0b je 11d15a <== NEVER TAKEN rtems_libio_check_count( count ); 11d14f: 31 c0 xor %eax,%eax 11d151: 85 c9 test %ecx,%ecx 11d153: 74 31 je 11d186 rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 11d155: 83 e6 02 and $0x2,%esi 11d158: 75 10 jne 11d16a 11d15a: e8 d9 3f ff ff call 111138 <__errno> 11d15f: c7 00 16 00 00 00 movl $0x16,(%eax) 11d165: 83 c8 ff or $0xffffffff,%eax 11d168: eb 1c jmp 11d186 /* * Now process the read(). */ rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count ); 11d16a: 50 push %eax 11d16b: 8b 43 20 mov 0x20(%ebx),%eax 11d16e: 51 push %ecx 11d16f: 52 push %edx 11d170: 53 push %ebx 11d171: ff 50 08 call *0x8(%eax) if ( rc > 0 ) 11d174: 83 c4 10 add $0x10,%esp 11d177: 85 c0 test %eax,%eax 11d179: 7e 0b jle 11d186 iop->offset += rc; 11d17b: 89 c1 mov %eax,%ecx 11d17d: c1 f9 1f sar $0x1f,%ecx 11d180: 01 43 0c add %eax,0xc(%ebx) 11d183: 11 4b 10 adc %ecx,0x10(%ebx) return rc; } 11d186: 8d 65 f8 lea -0x8(%ebp),%esp 11d189: 5b pop %ebx 11d18a: 5e pop %esi 11d18b: c9 leave 11d18c: c3 ret =============================================================================== 00109ef8 : ssize_t readlink( const char *pathname, char *buf, size_t bufsize ) { 109ef8: 55 push %ebp 109ef9: 89 e5 mov %esp,%ebp 109efb: 57 push %edi 109efc: 56 push %esi 109efd: 53 push %ebx 109efe: 83 ec 2c sub $0x2c,%esp 109f01: 8b 55 08 mov 0x8(%ebp),%edx 109f04: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_filesystem_location_info_t loc; int result; if (!buf) 109f07: 85 db test %ebx,%ebx 109f09: 75 10 jne 109f1b rtems_set_errno_and_return_minus_one( EFAULT ); 109f0b: e8 34 99 00 00 call 113844 <__errno> 109f10: c7 00 0e 00 00 00 movl $0xe,(%eax) 109f16: 83 cf ff or $0xffffffff,%edi 109f19: eb 69 jmp 109f84 result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ), 109f1b: 31 c0 xor %eax,%eax 109f1d: 83 c9 ff or $0xffffffff,%ecx 109f20: 89 d7 mov %edx,%edi 109f22: f2 ae repnz scas %es:(%edi),%al 109f24: f7 d1 not %ecx 109f26: 49 dec %ecx 109f27: 83 ec 0c sub $0xc,%esp 109f2a: 6a 00 push $0x0 109f2c: 8d 75 d4 lea -0x2c(%ebp),%esi 109f2f: 56 push %esi 109f30: 6a 00 push $0x0 109f32: 51 push %ecx 109f33: 52 push %edx 109f34: e8 49 f0 ff ff call 108f82 0, &loc, false ); if ( result != 0 ) 109f39: 83 c4 20 add $0x20,%esp return -1; 109f3c: 83 cf ff or $0xffffffff,%edi if (!buf) rtems_set_errno_and_return_minus_one( EFAULT ); result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ), 0, &loc, false ); if ( result != 0 ) 109f3f: 85 c0 test %eax,%eax 109f41: 75 41 jne 109f84 <== NEVER TAKEN return -1; if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){ 109f43: 83 ec 0c sub $0xc,%esp 109f46: 56 push %esi 109f47: 8b 45 e0 mov -0x20(%ebp),%eax 109f4a: ff 50 10 call *0x10(%eax) 109f4d: 83 c4 10 add $0x10,%esp 109f50: 83 f8 04 cmp $0x4,%eax 109f53: 74 16 je 109f6b rtems_filesystem_freenode( &loc ); 109f55: 83 ec 0c sub $0xc,%esp 109f58: 56 push %esi 109f59: e8 e2 f0 ff ff call 109040 rtems_set_errno_and_return_minus_one( EINVAL ); 109f5e: e8 e1 98 00 00 call 113844 <__errno> 109f63: c7 00 16 00 00 00 movl $0x16,(%eax) 109f69: eb 16 jmp 109f81 } result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); 109f6b: 50 push %eax 109f6c: ff 75 10 pushl 0x10(%ebp) 109f6f: 53 push %ebx 109f70: 56 push %esi 109f71: 8b 45 e0 mov -0x20(%ebp),%eax 109f74: ff 50 3c call *0x3c(%eax) 109f77: 89 c7 mov %eax,%edi rtems_filesystem_freenode( &loc ); 109f79: 89 34 24 mov %esi,(%esp) 109f7c: e8 bf f0 ff ff call 109040 return result; 109f81: 83 c4 10 add $0x10,%esp } 109f84: 89 f8 mov %edi,%eax 109f86: 8d 65 f4 lea -0xc(%ebp),%esp 109f89: 5b pop %ebx 109f8a: 5e pop %esi 109f8b: 5f pop %edi 109f8c: c9 leave 109f8d: c3 ret =============================================================================== 00108ca8 : ssize_t readv( int fd, const struct iovec *iov, int iovcnt ) { 108ca8: 55 push %ebp 108ca9: 89 e5 mov %esp,%ebp 108cab: 57 push %edi 108cac: 56 push %esi 108cad: 53 push %ebx 108cae: 83 ec 2c sub $0x2c,%esp 108cb1: 8b 75 08 mov 0x8(%ebp),%esi 108cb4: 8b 7d 0c mov 0xc(%ebp),%edi int v; int bytes; rtems_libio_t *iop; bool all_zeros; rtems_libio_check_fd( fd ); 108cb7: 3b 35 44 21 12 00 cmp 0x122144,%esi 108cbd: 73 11 jae 108cd0 iop = rtems_libio_iop( fd ); 108cbf: 6b f6 38 imul $0x38,%esi,%esi 108cc2: 03 35 f8 61 12 00 add 0x1261f8,%esi rtems_libio_check_is_open( iop ); 108cc8: 8b 46 14 mov 0x14(%esi),%eax 108ccb: f6 c4 01 test $0x1,%ah 108cce: 75 10 jne 108ce0 108cd0: e8 33 90 00 00 call 111d08 <__errno> 108cd5: c7 00 09 00 00 00 movl $0x9,(%eax) 108cdb: e9 a4 00 00 00 jmp 108d84 rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 108ce0: a8 02 test $0x2,%al 108ce2: 74 35 je 108d19 <== NEVER TAKEN /* * Argument validation on IO vector */ if ( !iov ) 108ce4: 85 ff test %edi,%edi 108ce6: 74 31 je 108d19 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt <= 0 ) 108ce8: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 108cec: 7e 2b jle 108d19 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt > IOV_MAX ) 108cee: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp) 108cf5: 7f 22 jg 108d19 <== NEVER TAKEN 108cf7: b2 01 mov $0x1,%dl 108cf9: 31 c0 xor %eax,%eax 108cfb: 31 c9 xor %ecx,%ecx 108cfd: 89 75 d4 mov %esi,-0x2c(%ebp) 108d00: eb 03 jmp 108d05 if ( iov[v].iov_base == 0 ) rtems_set_errno_and_return_minus_one( EINVAL ); /* check for wrap */ old = total; total += iov[v].iov_len; 108d02: 8b 4d e4 mov -0x1c(%ebp),%ecx /* * 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 ) 108d05: 83 3c c7 00 cmpl $0x0,(%edi,%eax,8) 108d09: 74 0e je 108d19 rtems_set_errno_and_return_minus_one( EINVAL ); /* check for wrap */ old = total; total += iov[v].iov_len; 108d0b: 8b 5c c7 04 mov 0x4(%edi,%eax,8),%ebx 108d0f: 8d 34 19 lea (%ecx,%ebx,1),%esi 108d12: 89 75 e4 mov %esi,-0x1c(%ebp) if ( total < old ) 108d15: 39 ce cmp %ecx,%esi 108d17: 7d 0d jge 108d26 rtems_set_errno_and_return_minus_one( EINVAL ); 108d19: e8 ea 8f 00 00 call 111d08 <__errno> 108d1e: c7 00 16 00 00 00 movl $0x16,(%eax) 108d24: eb 5e jmp 108d84 if ( iov[v].iov_len ) all_zeros = false; 108d26: 85 db test %ebx,%ebx 108d28: 0f 94 c1 sete %cl 108d2b: f7 d9 neg %ecx 108d2d: 21 ca and %ecx,%edx * 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++ ) { 108d2f: 40 inc %eax 108d30: 3b 45 10 cmp 0x10(%ebp),%eax 108d33: 7c cd jl 108d02 108d35: 8b 75 d4 mov -0x2c(%ebp),%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; 108d38: 31 db xor %ebx,%ebx /* * 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 ) { 108d3a: 84 d2 test %dl,%dl 108d3c: 75 49 jne 108d87 108d3e: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) /* * Now process the readv(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { bytes = (*iop->pathinfo.handlers->read_h)( 108d45: 50 push %eax 108d46: 8b 46 20 mov 0x20(%esi),%eax 108d49: 8b 55 e4 mov -0x1c(%ebp),%edx 108d4c: ff 74 d7 04 pushl 0x4(%edi,%edx,8) 108d50: ff 34 d7 pushl (%edi,%edx,8) 108d53: 56 push %esi 108d54: ff 50 08 call *0x8(%eax) iop, iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) 108d57: 83 c4 10 add $0x10,%esp 108d5a: 83 f8 00 cmp $0x0,%eax 108d5d: 7c 25 jl 108d84 <== NEVER TAKEN return -1; if ( bytes > 0 ) { 108d5f: 74 0d je 108d6e <== NEVER TAKEN iop->offset += bytes; 108d61: 89 c1 mov %eax,%ecx 108d63: c1 f9 1f sar $0x1f,%ecx 108d66: 01 46 0c add %eax,0xc(%esi) 108d69: 11 4e 10 adc %ecx,0x10(%esi) total += bytes; 108d6c: 01 c3 add %eax,%ebx } if (bytes != iov[ v ].iov_len) 108d6e: 8b 55 e4 mov -0x1c(%ebp),%edx 108d71: 3b 44 d7 04 cmp 0x4(%edi,%edx,8),%eax 108d75: 75 10 jne 108d87 <== NEVER TAKEN } /* * Now process the readv(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { 108d77: 42 inc %edx 108d78: 89 55 e4 mov %edx,-0x1c(%ebp) 108d7b: 8b 45 10 mov 0x10(%ebp),%eax 108d7e: 39 c2 cmp %eax,%edx 108d80: 7c c3 jl 108d45 108d82: eb 03 jmp 108d87 iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) return -1; 108d84: 83 cb ff or $0xffffffff,%ebx if (bytes != iov[ v ].iov_len) break; } return total; } 108d87: 89 d8 mov %ebx,%eax 108d89: 8d 65 f4 lea -0xc(%ebp),%esp 108d8c: 5b pop %ebx 108d8d: 5e pop %esi 108d8e: 5f pop %edi 108d8f: c9 leave 108d90: c3 ret =============================================================================== 0011d218 : void *realloc( void *ptr, size_t size ) { 11d218: 55 push %ebp 11d219: 89 e5 mov %esp,%ebp 11d21b: 57 push %edi 11d21c: 56 push %esi 11d21d: 53 push %ebx 11d21e: 83 ec 2c sub $0x2c,%esp 11d221: 8b 5d 08 mov 0x8(%ebp),%ebx 11d224: 8b 75 0c mov 0xc(%ebp),%esi uintptr_t old_size; char *new_area; MSBUMP(realloc_calls, 1); 11d227: ff 05 20 52 12 00 incl 0x125220 /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 11d22d: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c 11d234: 75 1a jne 11d250 <== NEVER TAKEN if (_Thread_Dispatch_disable_level > 0) 11d236: a1 40 53 12 00 mov 0x125340,%eax 11d23b: 85 c0 test %eax,%eax 11d23d: 0f 85 ad 00 00 00 jne 11d2f0 <== NEVER TAKEN return (void *) 0; if (_ISR_Nest_level > 0) 11d243: 83 3d 64 58 12 00 00 cmpl $0x0,0x125864 11d24a: 0f 85 a0 00 00 00 jne 11d2f0 <== NEVER TAKEN } /* * Continue with realloc(). */ if ( !ptr ) 11d250: 85 db test %ebx,%ebx 11d252: 75 13 jne 11d267 return malloc( size ); 11d254: 83 ec 0c sub $0xc,%esp 11d257: 56 push %esi 11d258: e8 b7 a3 fe ff call 107614 11d25d: 89 c3 mov %eax,%ebx 11d25f: 83 c4 10 add $0x10,%esp 11d262: e9 8b 00 00 00 jmp 11d2f2 if ( !size ) { 11d267: 85 f6 test %esi,%esi 11d269: 75 0e jne 11d279 <== ALWAYS TAKEN free( ptr ); 11d26b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11d26e: 53 push %ebx <== NOT EXECUTED 11d26f: e8 04 a1 fe ff call 107378 <== NOT EXECUTED return (void *) 0; 11d274: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11d277: eb 77 jmp 11d2f0 <== NOT EXECUTED } if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) { 11d279: 52 push %edx 11d27a: 8d 45 e4 lea -0x1c(%ebp),%eax 11d27d: 50 push %eax 11d27e: 53 push %ebx 11d27f: ff 35 80 11 12 00 pushl 0x121180 11d285: e8 ee 00 00 00 call 11d378 <_Protected_heap_Get_block_size> 11d28a: 83 c4 10 add $0x10,%esp 11d28d: 84 c0 test %al,%al 11d28f: 75 0d jne 11d29e errno = EINVAL; 11d291: e8 a2 3e ff ff call 111138 <__errno> 11d296: c7 00 16 00 00 00 movl $0x16,(%eax) 11d29c: eb 52 jmp 11d2f0 } /* * Now resize it. */ if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) { 11d29e: 50 push %eax 11d29f: 56 push %esi 11d2a0: 53 push %ebx 11d2a1: ff 35 80 11 12 00 pushl 0x121180 11d2a7: e8 04 01 00 00 call 11d3b0 <_Protected_heap_Resize_block> 11d2ac: 83 c4 10 add $0x10,%esp 11d2af: 84 c0 test %al,%al 11d2b1: 75 3f jne 11d2f2 * 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 ); 11d2b3: 83 ec 0c sub $0xc,%esp 11d2b6: 56 push %esi 11d2b7: e8 58 a3 fe ff call 107614 MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ 11d2bc: ff 0d 14 52 12 00 decl 0x125214 if ( !new_area ) { 11d2c2: 83 c4 10 add $0x10,%esp 11d2c5: 85 c0 test %eax,%eax 11d2c7: 74 27 je 11d2f0 return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 11d2c9: 8b 55 e4 mov -0x1c(%ebp),%edx 11d2cc: 89 f1 mov %esi,%ecx 11d2ce: 39 d6 cmp %edx,%esi 11d2d0: 76 02 jbe 11d2d4 <== NEVER TAKEN 11d2d2: 89 d1 mov %edx,%ecx 11d2d4: 89 c7 mov %eax,%edi 11d2d6: 89 de mov %ebx,%esi 11d2d8: f3 a4 rep movsb %ds:(%esi),%es:(%edi) free( ptr ); 11d2da: 83 ec 0c sub $0xc,%esp 11d2dd: 53 push %ebx 11d2de: 89 45 d4 mov %eax,-0x2c(%ebp) 11d2e1: e8 92 a0 fe ff call 107378 return new_area; 11d2e6: 83 c4 10 add $0x10,%esp 11d2e9: 8b 45 d4 mov -0x2c(%ebp),%eax 11d2ec: 89 c3 mov %eax,%ebx 11d2ee: eb 02 jmp 11d2f2 new_area = malloc( size ); MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ if ( !new_area ) { return (void *) 0; 11d2f0: 31 db xor %ebx,%ebx memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; } 11d2f2: 89 d8 mov %ebx,%eax 11d2f4: 8d 65 f4 lea -0xc(%ebp),%esp 11d2f7: 5b pop %ebx 11d2f8: 5e pop %esi 11d2f9: 5f pop %edi 11d2fa: c9 leave 11d2fb: c3 ret =============================================================================== 001083e4 : #include int rmdir( const char *pathname ) { 1083e4: 55 push %ebp 1083e5: 89 e5 mov %esp,%ebp 1083e7: 57 push %edi 1083e8: 56 push %esi 1083e9: 53 push %ebx 1083ea: 83 ec 58 sub $0x58,%esp /* * Get the parent node of the node we wish to remove. Find the parent path. */ parentpathlen = rtems_filesystem_dirname ( pathname ); 1083ed: ff 75 08 pushl 0x8(%ebp) 1083f0: e8 da f2 ff ff call 1076cf 1083f5: 89 45 b4 mov %eax,-0x4c(%ebp) if ( parentpathlen == 0 ) 1083f8: 83 c4 10 add $0x10,%esp 1083fb: 85 c0 test %eax,%eax 1083fd: 8d 45 d0 lea -0x30(%ebp),%eax 108400: 75 15 jne 108417 rtems_filesystem_get_start_loc( pathname, &i, &parentloc ); 108402: 51 push %ecx 108403: 50 push %eax 108404: 8d 45 e4 lea -0x1c(%ebp),%eax 108407: 50 push %eax 108408: ff 75 08 pushl 0x8(%ebp) 10840b: e8 08 01 00 00 call 108518 108410: 83 c4 10 add $0x10,%esp const char *name; rtems_filesystem_location_info_t parentloc; rtems_filesystem_location_info_t loc; int i; int result; bool free_parentloc = false; 108413: 31 db xor %ebx,%ebx 108415: eb 25 jmp 10843c parentpathlen = rtems_filesystem_dirname ( pathname ); if ( parentpathlen == 0 ) rtems_filesystem_get_start_loc( pathname, &i, &parentloc ); else { result = rtems_filesystem_evaluate_path(pathname, parentpathlen, 108417: 83 ec 0c sub $0xc,%esp 10841a: 6a 00 push $0x0 10841c: 50 push %eax 10841d: 6a 02 push $0x2 10841f: ff 75 b4 pushl -0x4c(%ebp) 108422: ff 75 08 pushl 0x8(%ebp) 108425: e8 64 f2 ff ff call 10768e 10842a: 89 c2 mov %eax,%edx RTEMS_LIBIO_PERMS_WRITE, &parentloc, false ); if ( result != 0 ) 10842c: 83 c4 20 add $0x20,%esp return -1; 10842f: 83 c8 ff or $0xffffffff,%eax else { result = rtems_filesystem_evaluate_path(pathname, parentpathlen, RTEMS_LIBIO_PERMS_WRITE, &parentloc, false ); if ( result != 0 ) 108432: 85 d2 test %edx,%edx 108434: 0f 85 d6 00 00 00 jne 108510 <== NEVER TAKEN return -1; free_parentloc = true; 10843a: b3 01 mov $0x1,%bl /* * Start from the parent to find the node that should be under it. */ loc = parentloc; 10843c: 8d 7d bc lea -0x44(%ebp),%edi 10843f: 8d 75 d0 lea -0x30(%ebp),%esi 108442: b9 05 00 00 00 mov $0x5,%ecx 108447: f3 a5 rep movsl %ds:(%esi),%es:(%edi) name = pathname + parentpathlen; 108449: 8b 75 08 mov 0x8(%ebp),%esi 10844c: 03 75 b4 add -0x4c(%ebp),%esi name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 10844f: 83 c9 ff or $0xffffffff,%ecx 108452: 89 f7 mov %esi,%edi 108454: 31 c0 xor %eax,%eax 108456: f2 ae repnz scas %es:(%edi),%al 108458: f7 d1 not %ecx 10845a: 49 dec %ecx 10845b: 52 push %edx 10845c: 52 push %edx 10845d: 51 push %ecx 10845e: 56 push %esi 10845f: e8 aa f2 ff ff call 10770e 108464: 01 c6 add %eax,%esi result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 108466: 83 c9 ff or $0xffffffff,%ecx 108469: 89 f7 mov %esi,%edi 10846b: 31 c0 xor %eax,%eax 10846d: f2 ae repnz scas %es:(%edi),%al 10846f: f7 d1 not %ecx 108471: 49 dec %ecx 108472: c7 04 24 00 00 00 00 movl $0x0,(%esp) 108479: 8d 7d bc lea -0x44(%ebp),%edi 10847c: 57 push %edi 10847d: 6a 00 push $0x0 10847f: 51 push %ecx 108480: 56 push %esi 108481: e8 aa f1 ff ff call 107630 0, &loc, false ); if ( result != 0 ) { 108486: 83 c4 20 add $0x20,%esp 108489: 85 c0 test %eax,%eax 10848b: 74 13 je 1084a0 if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); return -1; 10848d: 83 c8 ff or $0xffffffff,%eax 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 ) 108490: 84 db test %bl,%bl 108492: 74 7c je 108510 rtems_filesystem_freenode( &parentloc ); 108494: 83 ec 0c sub $0xc,%esp 108497: 8d 55 d0 lea -0x30(%ebp),%edx 10849a: 52 push %edx 10849b: 89 45 b0 mov %eax,-0x50(%ebp) 10849e: eb 65 jmp 108505 } /* * Verify you can remove this node as a directory. */ if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 1084a0: 83 ec 0c sub $0xc,%esp 1084a3: 57 push %edi 1084a4: 8b 45 c8 mov -0x38(%ebp),%eax 1084a7: ff 50 10 call *0x10(%eax) 1084aa: 83 c4 10 add $0x10,%esp 1084ad: 48 dec %eax 1084ae: 74 2f je 1084df rtems_filesystem_freenode( &loc ); 1084b0: 83 ec 0c sub $0xc,%esp 1084b3: 57 push %edi 1084b4: e8 93 f2 ff ff call 10774c if ( free_parentloc ) 1084b9: 83 c4 10 add $0x10,%esp 1084bc: 84 db test %bl,%bl 1084be: 74 0f je 1084cf <== NEVER TAKEN rtems_filesystem_freenode( &parentloc ); 1084c0: 83 ec 0c sub $0xc,%esp 1084c3: 8d 45 d0 lea -0x30(%ebp),%eax 1084c6: 50 push %eax 1084c7: e8 80 f2 ff ff call 10774c 1084cc: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( ENOTDIR ); 1084cf: e8 04 94 00 00 call 1118d8 <__errno> 1084d4: c7 00 14 00 00 00 movl $0x14,(%eax) 1084da: 83 c8 ff or $0xffffffff,%eax 1084dd: eb 31 jmp 108510 /* * Use the filesystems rmnod to remove the node. */ result = (*loc.handlers->rmnod_h)( &parentloc, &loc ); 1084df: 50 push %eax 1084e0: 50 push %eax 1084e1: 57 push %edi 1084e2: 8d 75 d0 lea -0x30(%ebp),%esi 1084e5: 56 push %esi 1084e6: 8b 45 c4 mov -0x3c(%ebp),%eax 1084e9: ff 50 34 call *0x34(%eax) rtems_filesystem_freenode( &loc ); 1084ec: 89 3c 24 mov %edi,(%esp) 1084ef: 89 45 b0 mov %eax,-0x50(%ebp) 1084f2: e8 55 f2 ff ff call 10774c if ( free_parentloc ) 1084f7: 83 c4 10 add $0x10,%esp 1084fa: 84 db test %bl,%bl 1084fc: 8b 45 b0 mov -0x50(%ebp),%eax 1084ff: 74 0f je 108510 rtems_filesystem_freenode( &parentloc ); 108501: 83 ec 0c sub $0xc,%esp 108504: 56 push %esi 108505: e8 42 f2 ff ff call 10774c 10850a: 83 c4 10 add $0x10,%esp 10850d: 8b 45 b0 mov -0x50(%ebp),%eax return result; } 108510: 8d 65 f4 lea -0xc(%ebp),%esp 108513: 5b pop %ebx 108514: 5e pop %esi 108515: 5f pop %edi 108516: c9 leave 108517: c3 ret =============================================================================== 0010af85 : * errno - otherwise */ int rtems_aio_enqueue (rtems_aio_request *req) { 10af85: 55 push %ebp 10af86: 89 e5 mov %esp,%ebp 10af88: 57 push %edi 10af89: 56 push %esi 10af8a: 53 push %ebx 10af8b: 83 ec 58 sub $0x58,%esp 10af8e: 8b 5d 08 mov 0x8(%ebp),%ebx struct sched_param param; /* The queue should be initialized */ AIO_assert (aio_request_queue.initialized == AIO_QUEUE_INITIALIZED); result = pthread_mutex_lock (&aio_request_queue.mutex); 10af91: 68 d8 72 12 00 push $0x1272d8 10af96: e8 c5 08 00 00 call 10b860 10af9b: 89 45 b4 mov %eax,-0x4c(%ebp) if (result != 0) { 10af9e: 83 c4 10 add $0x10,%esp 10afa1: 85 c0 test %eax,%eax 10afa3: 74 0e je 10afb3 <== ALWAYS TAKEN free (req); 10afa5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10afa8: 53 push %ebx <== NOT EXECUTED 10afa9: e8 c2 cd ff ff call 107d70 <== NOT EXECUTED 10afae: e9 c6 01 00 00 jmp 10b179 <== NOT EXECUTED return result; } /* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined, we can use aio_reqprio to lower the priority of the request */ pthread_getschedparam (pthread_self(), &policy, ¶m); 10afb3: e8 a4 10 00 00 call 10c05c 10afb8: 57 push %edi 10afb9: 8d 55 c4 lea -0x3c(%ebp),%edx 10afbc: 52 push %edx 10afbd: 8d 55 e0 lea -0x20(%ebp),%edx 10afc0: 52 push %edx 10afc1: 50 push %eax 10afc2: e8 9d 0c 00 00 call 10bc64 req->caller_thread = pthread_self (); 10afc7: e8 90 10 00 00 call 10c05c 10afcc: 89 43 10 mov %eax,0x10(%ebx) req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 10afcf: 8b 43 14 mov 0x14(%ebx),%eax 10afd2: 8b 55 c4 mov -0x3c(%ebp),%edx 10afd5: 2b 50 14 sub 0x14(%eax),%edx 10afd8: 89 53 0c mov %edx,0xc(%ebx) req->policy = policy; 10afdb: 8b 55 e0 mov -0x20(%ebp),%edx 10afde: 89 53 08 mov %edx,0x8(%ebx) req->aiocbp->error_code = EINPROGRESS; 10afe1: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax) req->aiocbp->return_value = 0; 10afe8: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) if ((aio_request_queue.idle_threads == 0) && 10afef: 83 c4 10 add $0x10,%esp 10aff2: 83 3d 40 73 12 00 00 cmpl $0x0,0x127340 10aff9: 0f 85 b7 00 00 00 jne 10b0b6 <== NEVER TAKEN 10afff: 83 3d 3c 73 12 00 04 cmpl $0x4,0x12733c 10b006: 0f 8f aa 00 00 00 jg 10b0b6 aio_request_queue.active_threads < AIO_MAX_THREADS) /* we still have empty places on the active_threads chain */ { chain = &aio_request_queue.work_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10b00c: 56 push %esi 10b00d: 6a 01 push $0x1 10b00f: ff 30 pushl (%eax) 10b011: 68 20 73 12 00 push $0x127320 10b016: e8 81 fb ff ff call 10ab9c 10b01b: 89 c6 mov %eax,%esi if (r_chain->new_fd == 1) { 10b01d: 83 c4 10 add $0x10,%esp 10b020: 83 78 18 01 cmpl $0x1,0x18(%eax) 10b024: 8d 50 08 lea 0x8(%eax),%edx 10b027: 8d 78 1c lea 0x1c(%eax),%edi 10b02a: 8d 40 20 lea 0x20(%eax),%eax 10b02d: 89 45 b0 mov %eax,-0x50(%ebp) 10b030: 75 66 jne 10b098 RTEMS_INLINE_ROUTINE void _Chain_Prepend( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert(_Chain_Head(the_chain), the_node); 10b032: 51 push %ecx 10b033: 51 push %ecx 10b034: 53 push %ebx 10b035: 52 push %edx 10b036: e8 c1 1f 00 00 call 10cffc <_Chain_Insert> rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 10b03b: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) pthread_mutex_init (&r_chain->mutex, NULL); 10b042: 5b pop %ebx 10b043: 58 pop %eax 10b044: 6a 00 push $0x0 10b046: 57 push %edi 10b047: e8 f4 06 00 00 call 10b740 pthread_cond_init (&r_chain->cond, NULL); 10b04c: 5a pop %edx 10b04d: 59 pop %ecx 10b04e: 6a 00 push $0x0 10b050: ff 75 b0 pushl -0x50(%ebp) 10b053: e8 a8 03 00 00 call 10b400 AIO_printf ("New thread \n"); result = pthread_create (&thid, &aio_request_queue.attr, 10b058: 56 push %esi 10b059: 68 78 ac 10 00 push $0x10ac78 10b05e: 68 e0 72 12 00 push $0x1272e0 10b063: 8d 45 e4 lea -0x1c(%ebp),%eax 10b066: 50 push %eax 10b067: e8 c4 09 00 00 call 10ba30 10b06c: 89 c3 mov %eax,%ebx rtems_aio_handle, (void *) r_chain); if (result != 0) { 10b06e: 83 c4 20 add $0x20,%esp 10b071: 85 c0 test %eax,%eax 10b073: 74 18 je 10b08d <== ALWAYS TAKEN pthread_mutex_unlock (&aio_request_queue.mutex); 10b075: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b078: 68 d8 72 12 00 push $0x1272d8 <== NOT EXECUTED 10b07d: e8 5e 08 00 00 call 10b8e0 <== NOT EXECUTED return result; 10b082: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b085: 89 5d b4 mov %ebx,-0x4c(%ebp) <== NOT EXECUTED 10b088: e9 ef 00 00 00 jmp 10b17c <== NOT EXECUTED } ++aio_request_queue.active_threads; 10b08d: ff 05 3c 73 12 00 incl 0x12733c 10b093: e9 d4 00 00 00 jmp 10b16c } else { /* put request in the fd chain it belongs to */ pthread_mutex_lock (&r_chain->mutex); 10b098: 83 ec 0c sub $0xc,%esp 10b09b: 57 push %edi 10b09c: 89 55 ac mov %edx,-0x54(%ebp) 10b09f: e8 bc 07 00 00 call 10b860 rtems_aio_insert_prio (&r_chain->perfd, req); 10b0a4: 5e pop %esi 10b0a5: 58 pop %eax 10b0a6: 53 push %ebx 10b0a7: 8b 55 ac mov -0x54(%ebp),%edx 10b0aa: 52 push %edx 10b0ab: e8 ec fd ff ff call 10ae9c pthread_cond_signal (&r_chain->cond); 10b0b0: 5b pop %ebx 10b0b1: ff 75 b0 pushl -0x50(%ebp) 10b0b4: eb 36 jmp 10b0ec else { /* the maximum number of threads has been already created even though some of them might be idle. The request belongs to one of the active fd chain */ r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, 10b0b6: 51 push %ecx 10b0b7: 6a 00 push $0x0 10b0b9: ff 30 pushl (%eax) 10b0bb: 68 20 73 12 00 push $0x127320 10b0c0: e8 d7 fa ff ff call 10ab9c 10b0c5: 89 c6 mov %eax,%esi req->aiocbp->aio_fildes, 0); if (r_chain != NULL) 10b0c7: 83 c4 10 add $0x10,%esp 10b0ca: 85 c0 test %eax,%eax 10b0cc: 74 2d je 10b0fb { pthread_mutex_lock (&r_chain->mutex); 10b0ce: 8d 78 1c lea 0x1c(%eax),%edi 10b0d1: 83 ec 0c sub $0xc,%esp 10b0d4: 57 push %edi 10b0d5: e8 86 07 00 00 call 10b860 rtems_aio_insert_prio (&r_chain->perfd, req); 10b0da: 58 pop %eax 10b0db: 5a pop %edx 10b0dc: 53 push %ebx 10b0dd: 8d 46 08 lea 0x8(%esi),%eax 10b0e0: 50 push %eax 10b0e1: e8 b6 fd ff ff call 10ae9c pthread_cond_signal (&r_chain->cond); 10b0e6: 83 c6 20 add $0x20,%esi 10b0e9: 89 34 24 mov %esi,(%esp) 10b0ec: e8 ab 03 00 00 call 10b49c pthread_mutex_unlock (&r_chain->mutex); 10b0f1: 89 3c 24 mov %edi,(%esp) 10b0f4: e8 e7 07 00 00 call 10b8e0 10b0f9: eb 6e jmp 10b169 } else { /* or to the idle chain */ chain = &aio_request_queue.idle_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10b0fb: 56 push %esi 10b0fc: 6a 01 push $0x1 10b0fe: 8b 43 14 mov 0x14(%ebx),%eax 10b101: ff 30 pushl (%eax) 10b103: 68 2c 73 12 00 push $0x12732c 10b108: e8 8f fa ff ff call 10ab9c 10b10d: 89 c6 mov %eax,%esi if (r_chain->new_fd == 1) { 10b10f: 83 c4 10 add $0x10,%esp 10b112: 83 78 18 01 cmpl $0x1,0x18(%eax) 10b116: 8d 40 08 lea 0x8(%eax),%eax 10b119: 75 2c jne 10b147 10b11b: 51 push %ecx 10b11c: 51 push %ecx 10b11d: 53 push %ebx 10b11e: 50 push %eax 10b11f: e8 d8 1e 00 00 call 10cffc <_Chain_Insert> /* If this is a new fd chain we signal the idle threads that might be waiting for requests */ AIO_printf (" New chain on waiting queue \n "); rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 10b124: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) pthread_mutex_init (&r_chain->mutex, NULL); 10b12b: 58 pop %eax 10b12c: 5a pop %edx 10b12d: 6a 00 push $0x0 10b12f: 8d 46 1c lea 0x1c(%esi),%eax 10b132: 50 push %eax 10b133: e8 08 06 00 00 call 10b740 pthread_cond_init (&r_chain->cond, NULL); 10b138: 5b pop %ebx 10b139: 5f pop %edi 10b13a: 6a 00 push $0x0 10b13c: 83 c6 20 add $0x20,%esi 10b13f: 56 push %esi 10b140: e8 bb 02 00 00 call 10b400 10b145: eb 09 jmp 10b150 } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req); 10b147: 51 push %ecx 10b148: 51 push %ecx 10b149: 53 push %ebx 10b14a: 50 push %eax 10b14b: e8 4c fd ff ff call 10ae9c 10b150: 83 c4 10 add $0x10,%esp if (aio_request_queue.idle_threads > 0) 10b153: 83 3d 40 73 12 00 00 cmpl $0x0,0x127340 10b15a: 7e 10 jle 10b16c <== ALWAYS TAKEN pthread_cond_signal (&aio_request_queue.new_req); 10b15c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b15f: 68 dc 72 12 00 push $0x1272dc <== NOT EXECUTED 10b164: e8 33 03 00 00 call 10b49c <== NOT EXECUTED 10b169: 83 c4 10 add $0x10,%esp } } pthread_mutex_unlock (&aio_request_queue.mutex); 10b16c: 83 ec 0c sub $0xc,%esp 10b16f: 68 d8 72 12 00 push $0x1272d8 10b174: e8 67 07 00 00 call 10b8e0 return 0; 10b179: 83 c4 10 add $0x10,%esp } 10b17c: 8b 45 b4 mov -0x4c(%ebp),%eax 10b17f: 8d 65 f4 lea -0xc(%ebp),%esp 10b182: 5b pop %ebx 10b183: 5e pop %esi 10b184: 5f pop %edi 10b185: c9 leave 10b186: c3 ret =============================================================================== 0010ac78 : * NULL - if error */ static void * rtems_aio_handle (void *arg) { 10ac78: 55 push %ebp 10ac79: 89 e5 mov %esp,%ebp 10ac7b: 57 push %edi 10ac7c: 56 push %esi 10ac7d: 53 push %ebx 10ac7e: 83 ec 4c sub $0x4c,%esp rtems_aio_request_chain *r_chain = arg; 10ac81: 8b 5d 08 mov 0x8(%ebp),%ebx pthread_mutex_unlock (&r_chain->mutex); pthread_mutex_lock (&aio_request_queue.mutex); if (rtems_chain_is_empty (chain)) { clock_gettime (CLOCK_REALTIME, &timeout); 10ac84: 8d 7d dc lea -0x24(%ebp),%edi /* acquire the mutex of the current fd chain. we don't need to lock the queue mutex since we can add requests to idle fd chains or even active ones if the working request has been extracted from the chain */ result = pthread_mutex_lock (&r_chain->mutex); 10ac87: 8d 43 1c lea 0x1c(%ebx),%eax 10ac8a: 89 45 b4 mov %eax,-0x4c(%ebp) 10ac8d: 83 ec 0c sub $0xc,%esp 10ac90: 50 push %eax 10ac91: e8 ca 0b 00 00 call 10b860 if (result != 0) 10ac96: 83 c4 10 add $0x10,%esp 10ac99: 85 c0 test %eax,%eax 10ac9b: 0f 85 f1 01 00 00 jne 10ae92 <== NEVER TAKEN } } AIO_printf ("Thread finished\n"); return NULL; } 10aca1: 8b 73 08 mov 0x8(%ebx),%esi RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10aca4: 8d 43 0c lea 0xc(%ebx),%eax /* If the locked chain is not empty, take the first request extract it, unlock the chain and process the request, in this way the user can supply more requests to this fd chain */ if (!rtems_chain_is_empty (chain)) { 10aca7: 39 c6 cmp %eax,%esi 10aca9: 0f 84 cd 00 00 00 je 10ad7c node = rtems_chain_first (chain); req = (rtems_aio_request *) node; /* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING discussion in rtems_aio_enqueue () */ pthread_getschedparam (pthread_self(), &policy, ¶m); 10acaf: e8 a8 13 00 00 call 10c05c 10acb4: 52 push %edx 10acb5: 8d 55 c0 lea -0x40(%ebp),%edx 10acb8: 52 push %edx 10acb9: 8d 4d e4 lea -0x1c(%ebp),%ecx 10acbc: 51 push %ecx 10acbd: 50 push %eax 10acbe: e8 a1 0f 00 00 call 10bc64 param.sched_priority = req->priority; 10acc3: 8b 46 0c mov 0xc(%esi),%eax 10acc6: 89 45 c0 mov %eax,-0x40(%ebp) pthread_setschedparam (pthread_self(), req->policy, ¶m); 10acc9: 8b 56 08 mov 0x8(%esi),%edx 10accc: 89 55 b0 mov %edx,-0x50(%ebp) 10accf: e8 88 13 00 00 call 10c05c 10acd4: 83 c4 0c add $0xc,%esp 10acd7: 8d 4d c0 lea -0x40(%ebp),%ecx 10acda: 51 push %ecx 10acdb: 8b 55 b0 mov -0x50(%ebp),%edx 10acde: 52 push %edx 10acdf: 50 push %eax 10ace0: e8 87 13 00 00 call 10c06c */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10ace5: 89 34 24 mov %esi,(%esp) 10ace8: e8 d3 22 00 00 call 10cfc0 <_Chain_Extract> rtems_chain_extract (node); pthread_mutex_unlock (&r_chain->mutex); 10aced: 59 pop %ecx 10acee: ff 75 b4 pushl -0x4c(%ebp) 10acf1: e8 ea 0b 00 00 call 10b8e0 switch (req->aiocbp->aio_lio_opcode) { 10acf6: 8b 46 14 mov 0x14(%esi),%eax 10acf9: 83 c4 10 add $0x10,%esp 10acfc: 8b 50 2c mov 0x2c(%eax),%edx 10acff: 83 fa 02 cmp $0x2,%edx 10ad02: 74 20 je 10ad24 10ad04: 83 fa 03 cmp $0x3,%edx 10ad07: 74 36 je 10ad3f <== NEVER TAKEN 10ad09: 4a dec %edx 10ad0a: 75 45 jne 10ad51 <== NEVER TAKEN case LIO_READ: AIO_printf ("read\n"); result = pread (req->aiocbp->aio_fildes, 10ad0c: 83 ec 0c sub $0xc,%esp 10ad0f: ff 70 08 pushl 0x8(%eax) 10ad12: ff 70 04 pushl 0x4(%eax) 10ad15: ff 70 10 pushl 0x10(%eax) 10ad18: ff 70 0c pushl 0xc(%eax) 10ad1b: ff 30 pushl (%eax) 10ad1d: e8 fe 93 00 00 call 114120 10ad22: eb 16 jmp 10ad3a req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; case LIO_WRITE: AIO_printf ("write\n"); result = pwrite (req->aiocbp->aio_fildes, 10ad24: 83 ec 0c sub $0xc,%esp 10ad27: ff 70 08 pushl 0x8(%eax) 10ad2a: ff 70 04 pushl 0x4(%eax) 10ad2d: ff 70 10 pushl 0x10(%eax) 10ad30: ff 70 0c pushl 0xc(%eax) 10ad33: ff 30 pushl (%eax) 10ad35: e8 9a 94 00 00 call 1141d4 (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; 10ad3a: 83 c4 20 add $0x20,%esp 10ad3d: eb 0d jmp 10ad4c case LIO_SYNC: AIO_printf ("sync\n"); result = fsync (req->aiocbp->aio_fildes); 10ad3f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad42: ff 30 pushl (%eax) <== NOT EXECUTED 10ad44: e8 33 5d 00 00 call 110a7c <== NOT EXECUTED break; 10ad49: 83 c4 10 add $0x10,%esp <== NOT EXECUTED default: result = -1; } if (result == -1) { 10ad4c: 83 f8 ff cmp $0xffffffff,%eax 10ad4f: 75 19 jne 10ad6a <== ALWAYS TAKEN req->aiocbp->return_value = -1; 10ad51: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED 10ad54: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED req->aiocbp->error_code = errno; 10ad5b: e8 88 89 00 00 call 1136e8 <__errno> <== NOT EXECUTED 10ad60: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10ad62: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED 10ad65: e9 1d ff ff ff jmp 10ac87 <== NOT EXECUTED } else { req->aiocbp->return_value = result; 10ad6a: 8b 56 14 mov 0x14(%esi),%edx 10ad6d: 89 42 34 mov %eax,0x34(%edx) req->aiocbp->error_code = 0; 10ad70: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) 10ad77: e9 0b ff ff ff jmp 10ac87 struct timespec timeout; AIO_printf ("Chain is empty [WQ], wait for work\n"); pthread_mutex_unlock (&r_chain->mutex); 10ad7c: 83 ec 0c sub $0xc,%esp 10ad7f: ff 75 b4 pushl -0x4c(%ebp) 10ad82: e8 59 0b 00 00 call 10b8e0 pthread_mutex_lock (&aio_request_queue.mutex); 10ad87: c7 04 24 d8 72 12 00 movl $0x1272d8,(%esp) 10ad8e: e8 cd 0a 00 00 call 10b860 if (rtems_chain_is_empty (chain)) 10ad93: 83 c4 10 add $0x10,%esp 10ad96: 39 73 08 cmp %esi,0x8(%ebx) 10ad99: 0f 85 de 00 00 00 jne 10ae7d <== NEVER TAKEN { clock_gettime (CLOCK_REALTIME, &timeout); 10ad9f: 52 push %edx 10ada0: 52 push %edx 10ada1: 57 push %edi 10ada2: 6a 01 push $0x1 10ada4: e8 47 05 00 00 call 10b2f0 timeout.tv_sec += 3; 10ada9: 83 45 dc 03 addl $0x3,-0x24(%ebp) timeout.tv_nsec = 0; 10adad: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) result = pthread_cond_timedwait (&r_chain->cond, 10adb4: 8d 73 20 lea 0x20(%ebx),%esi 10adb7: 83 c4 0c add $0xc,%esp 10adba: 57 push %edi 10adbb: 68 d8 72 12 00 push $0x1272d8 10adc0: 56 push %esi 10adc1: e8 46 07 00 00 call 10b50c &aio_request_queue.mutex, &timeout); /* If no requests were added to the chain we delete the fd chain from the queue and start working with idle fd chains */ if (result == ETIMEDOUT) { 10adc6: 83 c4 10 add $0x10,%esp 10adc9: 83 f8 74 cmp $0x74,%eax 10adcc: 0f 85 ab 00 00 00 jne 10ae7d <== NEVER TAKEN 10add2: 83 ec 0c sub $0xc,%esp 10add5: 53 push %ebx 10add6: e8 e5 21 00 00 call 10cfc0 <_Chain_Extract> rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex); 10addb: 58 pop %eax 10addc: ff 75 b4 pushl -0x4c(%ebp) 10addf: e8 5c 08 00 00 call 10b640 pthread_cond_destroy (&r_chain->cond); 10ade4: 89 34 24 mov %esi,(%esp) 10ade7: e8 60 05 00 00 call 10b34c free (r_chain); 10adec: 89 1c 24 mov %ebx,(%esp) 10adef: e8 7c cf ff ff call 107d70 /* If the idle chain is empty sleep for 3 seconds and wait for a signal. The thread now becomes idle. */ if (rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10adf4: 83 c4 10 add $0x10,%esp 10adf7: 81 3d 2c 73 12 00 30 cmpl $0x127330,0x12732c 10adfe: 73 12 00 10ae01: 75 54 jne 10ae57 AIO_printf ("Chain is empty [IQ], wait for work\n"); ++aio_request_queue.idle_threads; 10ae03: ff 05 40 73 12 00 incl 0x127340 --aio_request_queue.active_threads; 10ae09: ff 0d 3c 73 12 00 decl 0x12733c clock_gettime (CLOCK_REALTIME, &timeout); 10ae0f: 53 push %ebx 10ae10: 53 push %ebx 10ae11: 57 push %edi 10ae12: 6a 01 push $0x1 10ae14: e8 d7 04 00 00 call 10b2f0 timeout.tv_sec += 3; 10ae19: 83 45 dc 03 addl $0x3,-0x24(%ebp) timeout.tv_nsec = 0; 10ae1d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) result = pthread_cond_timedwait (&aio_request_queue.new_req, 10ae24: 83 c4 0c add $0xc,%esp 10ae27: 57 push %edi 10ae28: 68 d8 72 12 00 push $0x1272d8 10ae2d: 68 dc 72 12 00 push $0x1272dc 10ae32: e8 d5 06 00 00 call 10b50c &aio_request_queue.mutex, &timeout); /* If no new fd chain was added in the idle requests then this thread is finished */ if (result == ETIMEDOUT) { 10ae37: 83 c4 10 add $0x10,%esp 10ae3a: 83 f8 74 cmp $0x74,%eax 10ae3d: 75 18 jne 10ae57 <== NEVER TAKEN AIO_printf ("Etimeout\n"); --aio_request_queue.idle_threads; 10ae3f: ff 0d 40 73 12 00 decl 0x127340 pthread_mutex_unlock (&aio_request_queue.mutex); 10ae45: 83 ec 0c sub $0xc,%esp 10ae48: 68 d8 72 12 00 push $0x1272d8 10ae4d: e8 8e 0a 00 00 call 10b8e0 return NULL; 10ae52: 83 c4 10 add $0x10,%esp 10ae55: eb 3b jmp 10ae92 } } /* Otherwise move this chain to the working chain and start the loop all over again */ AIO_printf ("Work on idle\n"); --aio_request_queue.idle_threads; 10ae57: ff 0d 40 73 12 00 decl 0x127340 ++aio_request_queue.active_threads; 10ae5d: ff 05 3c 73 12 00 incl 0x12733c } } AIO_printf ("Thread finished\n"); return NULL; } 10ae63: 8b 1d 2c 73 12 00 mov 0x12732c,%ebx 10ae69: 83 ec 0c sub $0xc,%esp 10ae6c: 53 push %ebx 10ae6d: e8 4e 21 00 00 call 10cfc0 <_Chain_Extract> node = rtems_chain_first (&aio_request_queue.idle_req); rtems_chain_extract (node); r_chain = (rtems_aio_request_chain *) node; rtems_aio_move_to_work (r_chain); 10ae72: 89 1c 24 mov %ebx,(%esp) 10ae75: e8 cd fd ff ff call 10ac47 10ae7a: 83 c4 10 add $0x10,%esp } } /* If there was a request added in the initial fd chain then release the mutex and process it */ pthread_mutex_unlock (&aio_request_queue.mutex); 10ae7d: 83 ec 0c sub $0xc,%esp 10ae80: 68 d8 72 12 00 push $0x1272d8 10ae85: e8 56 0a 00 00 call 10b8e0 10ae8a: 83 c4 10 add $0x10,%esp 10ae8d: e9 f5 fd ff ff jmp 10ac87 } } AIO_printf ("Thread finished\n"); return NULL; } 10ae92: 31 c0 xor %eax,%eax 10ae94: 8d 65 f4 lea -0xc(%ebp),%esp 10ae97: 5b pop %ebx 10ae98: 5e pop %esi 10ae99: 5f pop %edi 10ae9a: c9 leave 10ae9b: c3 ret =============================================================================== 0010aaa0 : * 0 - if initialization succeeded */ int rtems_aio_init (void) { 10aaa0: 55 push %ebp 10aaa1: 89 e5 mov %esp,%ebp 10aaa3: 53 push %ebx 10aaa4: 83 ec 10 sub $0x10,%esp int result = 0; result = pthread_attr_init (&aio_request_queue.attr); 10aaa7: 68 e0 72 12 00 push $0x1272e0 10aaac: e8 33 0f 00 00 call 10b9e4 10aab1: 89 c3 mov %eax,%ebx if (result != 0) 10aab3: 83 c4 10 add $0x10,%esp 10aab6: 85 c0 test %eax,%eax 10aab8: 0f 85 d7 00 00 00 jne 10ab95 <== NEVER TAKEN return result; result = 10aabe: 51 push %ecx 10aabf: 51 push %ecx 10aac0: 6a 00 push $0x0 10aac2: 68 e0 72 12 00 push $0x1272e0 10aac7: e8 40 0f 00 00 call 10ba0c pthread_attr_setdetachstate (&aio_request_queue.attr, PTHREAD_CREATE_DETACHED); if (result != 0) 10aacc: 83 c4 10 add $0x10,%esp 10aacf: 85 c0 test %eax,%eax 10aad1: 74 10 je 10aae3 <== ALWAYS TAKEN pthread_attr_destroy (&aio_request_queue.attr); 10aad3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aad6: 68 e0 72 12 00 push $0x1272e0 <== NOT EXECUTED 10aadb: e8 e4 0e 00 00 call 10b9c4 <== NOT EXECUTED 10aae0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED result = pthread_mutex_init (&aio_request_queue.mutex, NULL); 10aae3: 52 push %edx 10aae4: 52 push %edx 10aae5: 6a 00 push $0x0 10aae7: 68 d8 72 12 00 push $0x1272d8 10aaec: e8 4f 0c 00 00 call 10b740 if (result != 0) 10aaf1: 83 c4 10 add $0x10,%esp 10aaf4: 85 c0 test %eax,%eax 10aaf6: 74 10 je 10ab08 <== ALWAYS TAKEN pthread_attr_destroy (&aio_request_queue.attr); 10aaf8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aafb: 68 e0 72 12 00 push $0x1272e0 <== NOT EXECUTED 10ab00: e8 bf 0e 00 00 call 10b9c4 <== NOT EXECUTED 10ab05: 83 c4 10 add $0x10,%esp <== NOT EXECUTED result = pthread_cond_init (&aio_request_queue.new_req, NULL); 10ab08: 50 push %eax 10ab09: 50 push %eax 10ab0a: 6a 00 push $0x0 10ab0c: 68 dc 72 12 00 push $0x1272dc 10ab11: e8 ea 08 00 00 call 10b400 10ab16: 89 c3 mov %eax,%ebx if (result != 0) { 10ab18: 83 c4 10 add $0x10,%esp 10ab1b: 85 c0 test %eax,%eax 10ab1d: 74 1c je 10ab3b <== ALWAYS TAKEN pthread_mutex_destroy (&aio_request_queue.mutex); 10ab1f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab22: 68 d8 72 12 00 push $0x1272d8 <== NOT EXECUTED 10ab27: e8 14 0b 00 00 call 10b640 <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); 10ab2c: c7 04 24 e0 72 12 00 movl $0x1272e0,(%esp) <== NOT EXECUTED 10ab33: e8 8c 0e 00 00 call 10b9c4 <== NOT EXECUTED 10ab38: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10ab3b: c7 05 20 73 12 00 24 movl $0x127324,0x127320 10ab42: 73 12 00 head->previous = NULL; 10ab45: c7 05 24 73 12 00 00 movl $0x0,0x127324 10ab4c: 00 00 00 tail->previous = head; 10ab4f: c7 05 28 73 12 00 20 movl $0x127320,0x127328 10ab56: 73 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10ab59: c7 05 2c 73 12 00 30 movl $0x127330,0x12732c 10ab60: 73 12 00 head->previous = NULL; 10ab63: c7 05 30 73 12 00 00 movl $0x0,0x127330 10ab6a: 00 00 00 tail->previous = head; 10ab6d: c7 05 34 73 12 00 2c movl $0x12732c,0x127334 10ab74: 73 12 00 } rtems_chain_initialize_empty (&aio_request_queue.work_req); rtems_chain_initialize_empty (&aio_request_queue.idle_req); aio_request_queue.active_threads = 0; 10ab77: c7 05 3c 73 12 00 00 movl $0x0,0x12733c 10ab7e: 00 00 00 aio_request_queue.idle_threads = 0; 10ab81: c7 05 40 73 12 00 00 movl $0x0,0x127340 10ab88: 00 00 00 aio_request_queue.initialized = AIO_QUEUE_INITIALIZED; 10ab8b: c7 05 38 73 12 00 0b movl $0xb00b,0x127338 10ab92: b0 00 00 return result; } 10ab95: 89 d8 mov %ebx,%eax 10ab97: 8b 5d fc mov -0x4(%ebp),%ebx 10ab9a: c9 leave 10ab9b: c3 ret =============================================================================== 0010ae9c : * NONE */ void rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req) { 10ae9c: 55 push %ebp 10ae9d: 89 e5 mov %esp,%ebp 10ae9f: 56 push %esi 10aea0: 53 push %ebx 10aea1: 8b 4d 08 mov 0x8(%ebp),%ecx 10aea4: 8b 55 0c mov 0xc(%ebp),%edx } } AIO_printf ("Thread finished\n"); return NULL; } 10aea7: 8b 01 mov (%ecx),%eax 10aea9: 8d 59 04 lea 0x4(%ecx),%ebx rtems_chain_node *node; AIO_printf ("FD exists \n"); node = rtems_chain_first (chain); if (rtems_chain_is_empty (chain)) { 10aeac: 39 d8 cmp %ebx,%eax 10aeae: 74 27 je 10aed7 <== NEVER TAKEN AIO_printf ("First in chain \n"); rtems_chain_prepend (chain, &req->next_prio); } else { AIO_printf ("Add by priority \n"); int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; 10aeb0: 8b 48 14 mov 0x14(%eax),%ecx 10aeb3: 8b 49 14 mov 0x14(%ecx),%ecx while (req->aiocbp->aio_reqprio > prio && 10aeb6: 8b 72 14 mov 0x14(%edx),%esi 10aeb9: 8b 76 14 mov 0x14(%esi),%esi 10aebc: eb 08 jmp 10aec6 } } AIO_printf ("Thread finished\n"); return NULL; } 10aebe: 8b 00 mov (%eax),%eax <== NOT EXECUTED int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; while (req->aiocbp->aio_reqprio > prio && !rtems_chain_is_tail (chain, node)) { node = rtems_chain_next (node); prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; 10aec0: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED 10aec3: 8b 49 14 mov 0x14(%ecx),%ecx <== NOT EXECUTED rtems_chain_prepend (chain, &req->next_prio); } else { AIO_printf ("Add by priority \n"); int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio; while (req->aiocbp->aio_reqprio > prio && 10aec6: 39 ce cmp %ecx,%esi 10aec8: 7e 04 jle 10aece <== ALWAYS TAKEN 10aeca: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10aecc: 75 f0 jne 10aebe <== NOT EXECUTED RTEMS_INLINE_ROUTINE void rtems_chain_insert( rtems_chain_node *after_node, rtems_chain_node *the_node ) { _Chain_Insert( after_node, the_node ); 10aece: 89 55 0c mov %edx,0xc(%ebp) 10aed1: 8b 40 04 mov 0x4(%eax),%eax 10aed4: 89 45 08 mov %eax,0x8(%ebp) } rtems_chain_insert (node->previous, &req->next_prio); } } 10aed7: 5b pop %ebx 10aed8: 5e pop %esi 10aed9: c9 leave 10aeda: e9 1d 21 00 00 jmp 10cffc <_Chain_Insert> =============================================================================== 0010ac47 : * NONE */ void rtems_aio_move_to_work (rtems_aio_request_chain *r_chain) { 10ac47: 55 push %ebp 10ac48: 89 e5 mov %esp,%ebp 10ac4a: 83 ec 08 sub $0x8,%esp 10ac4d: 8b 55 08 mov 0x8(%ebp),%edx } } AIO_printf ("Thread finished\n"); return NULL; } 10ac50: a1 20 73 12 00 mov 0x127320,%eax rtems_chain_node *node; node = rtems_chain_first (&aio_request_queue.work_req); temp = (rtems_aio_request_chain *) node; while (temp->fildes < r_chain->fildes && 10ac55: 8b 4a 14 mov 0x14(%edx),%ecx 10ac58: eb 02 jmp 10ac5c } } AIO_printf ("Thread finished\n"); return NULL; } 10ac5a: 8b 00 mov (%eax),%eax rtems_chain_node *node; node = rtems_chain_first (&aio_request_queue.work_req); temp = (rtems_aio_request_chain *) node; while (temp->fildes < r_chain->fildes && 10ac5c: 39 48 14 cmp %ecx,0x14(%eax) 10ac5f: 7d 07 jge 10ac68 10ac61: 3d 24 73 12 00 cmp $0x127324,%eax 10ac66: 75 f2 jne 10ac5a <== ALWAYS TAKEN 10ac68: 51 push %ecx 10ac69: 51 push %ecx 10ac6a: 52 push %edx 10ac6b: ff 70 04 pushl 0x4(%eax) 10ac6e: e8 89 23 00 00 call 10cffc <_Chain_Insert> 10ac73: 83 c4 10 add $0x10,%esp node = rtems_chain_next (node); temp = (rtems_aio_request_chain *) node; } rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd); } 10ac76: c9 leave 10ac77: c3 ret =============================================================================== 0010af28 : * AIO_NOTCANCELED - if request was not canceled * AIO_CANCELED - if request was canceled */ int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp) { 10af28: 55 push %ebp 10af29: 89 e5 mov %esp,%ebp 10af2b: 53 push %ebx 10af2c: 83 ec 04 sub $0x4,%esp 10af2f: 8b 55 08 mov 0x8(%ebp),%edx 10af32: 8b 4d 0c mov 0xc(%ebp),%ecx } } AIO_printf ("Thread finished\n"); return NULL; } 10af35: 8b 1a mov (%edx),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10af37: 83 c2 04 add $0x4,%edx */ int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp) { if (rtems_chain_is_empty (chain)) return AIO_ALLDONE; 10af3a: b8 02 00 00 00 mov $0x2,%eax * AIO_CANCELED - if request was canceled */ int rtems_aio_remove_req (rtems_chain_control *chain, struct aiocb *aiocbp) { if (rtems_chain_is_empty (chain)) 10af3f: 39 d3 cmp %edx,%ebx 10af41: 75 08 jne 10af4b 10af43: eb 3b jmp 10af80 } } AIO_printf ("Thread finished\n"); return NULL; } 10af45: 8b 18 mov (%eax),%ebx <== NOT EXECUTED rtems_chain_node *node = rtems_chain_first (chain); rtems_aio_request *current; current = (rtems_aio_request *) node; while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { 10af47: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 10af49: 74 30 je 10af7b <== NOT EXECUTED node = rtems_chain_next (node); current = (rtems_aio_request *) node; 10af4b: 89 d8 mov %ebx,%eax rtems_chain_node *node = rtems_chain_first (chain); rtems_aio_request *current; current = (rtems_aio_request *) node; while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { 10af4d: 39 4b 14 cmp %ecx,0x14(%ebx) 10af50: 75 f3 jne 10af45 <== NEVER TAKEN 10af52: 83 ec 0c sub $0xc,%esp 10af55: 53 push %ebx 10af56: e8 65 20 00 00 call 10cfc0 <_Chain_Extract> if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; else { rtems_chain_extract (node); current->aiocbp->error_code = ECANCELED; 10af5b: 8b 43 14 mov 0x14(%ebx),%eax 10af5e: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) current->aiocbp->return_value = -1; 10af65: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) free (current); 10af6c: 89 1c 24 mov %ebx,(%esp) 10af6f: e8 fc cd ff ff call 107d70 } return AIO_CANCELED; 10af74: 83 c4 10 add $0x10,%esp 10af77: 31 c0 xor %eax,%eax 10af79: eb 05 jmp 10af80 node = rtems_chain_next (node); current = (rtems_aio_request *) node; } if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; 10af7b: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED current->aiocbp->return_value = -1; free (current); } return AIO_CANCELED; } 10af80: 8b 5d fc mov -0x4(%ebp),%ebx 10af83: c9 leave 10af84: c3 ret =============================================================================== 0010acc8 : rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) { 10acc8: 55 push %ebp 10acc9: 89 e5 mov %esp,%ebp 10accb: 57 push %edi 10accc: 56 push %esi 10accd: 53 push %ebx 10acce: 83 ec 1c sub $0x1c,%esp 10acd1: 8b 7d 0c mov 0xc(%ebp),%edi while ( sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL ) { rtems_event_set out; sc = rtems_event_receive( 10acd4: 8d 75 e4 lea -0x1c(%ebp),%esi 10acd7: eb 13 jmp 10acec 10acd9: 56 push %esi 10acda: ff 75 10 pushl 0x10(%ebp) 10acdd: 6a 00 push $0x0 10acdf: 57 push %edi 10ace0: e8 0f f5 ff ff call 10a1f4 ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( 10ace5: 83 c4 10 add $0x10,%esp 10ace8: 85 c0 test %eax,%eax 10acea: 75 16 jne 10ad02 <== ALWAYS TAKEN */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 10acec: 83 ec 0c sub $0xc,%esp 10acef: ff 75 08 pushl 0x8(%ebp) 10acf2: e8 a5 04 00 00 call 10b19c <_Chain_Get> 10acf7: 89 c3 mov %eax,%ebx sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 10acf9: 83 c4 10 add $0x10,%esp 10acfc: 85 c0 test %eax,%eax 10acfe: 74 d9 je 10acd9 10ad00: 31 c0 xor %eax,%eax timeout, &out ); } *node_ptr = node; 10ad02: 8b 55 14 mov 0x14(%ebp),%edx 10ad05: 89 1a mov %ebx,(%edx) return sc; } 10ad07: 8d 65 f4 lea -0xc(%ebp),%esp 10ad0a: 5b pop %ebx 10ad0b: 5e pop %esi 10ad0c: 5f pop %edi 10ad0d: c9 leave 10ad0e: c3 ret =============================================================================== 001076c8 : void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) { 1076c8: 55 push %ebp 1076c9: 89 e5 mov %esp,%ebp 1076cb: 57 push %edi 1076cc: 56 push %esi 1076cd: 53 push %ebx 1076ce: 83 ec 6c sub $0x6c,%esp Timestamp_Control uptime, total, ran, uptime_at_last_reset; #else uint32_t total_units = 0; #endif if ( !print ) 1076d1: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 1076d5: 0f 84 74 01 00 00 je 10784f <== 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__ uptime_at_last_reset = CPU_usage_Uptime_at_last_reset; 1076db: a1 60 96 12 00 mov 0x129660,%eax 1076e0: 8b 15 64 96 12 00 mov 0x129664,%edx 1076e6: 89 45 c0 mov %eax,-0x40(%ebp) 1076e9: 89 55 c4 mov %edx,-0x3c(%ebp) } } } #endif (*print)( 1076ec: 53 push %ebx 1076ed: 53 push %ebx 1076ee: 68 a1 14 12 00 push $0x1214a1 1076f3: ff 75 08 pushl 0x8(%ebp) 1076f6: ff 55 0c call *0xc(%ebp) 1076f9: 83 c4 10 add $0x10,%esp " ID | NAME | TICKS | PERCENT\n" #endif "------------+----------------------------------------+---------------+---------\n" ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 1076fc: bf 01 00 00 00 mov $0x1,%edi #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG) if ( !_Objects_Information_table[ api_index ] ) continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 107701: 8b 04 bd 9c 90 12 00 mov 0x12909c(,%edi,4),%eax 107708: 8b 70 04 mov 0x4(%eax),%esi if ( information ) { 10770b: 85 f6 test %esi,%esi 10770d: 0f 84 14 01 00 00 je 107827 <== NEVER TAKEN 107713: c7 45 94 01 00 00 00 movl $0x1,-0x6c(%ebp) 10771a: e9 fb 00 00 00 jmp 10781a for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 10771f: 8b 46 1c mov 0x1c(%esi),%eax 107722: 8b 4d 94 mov -0x6c(%ebp),%ecx 107725: 8b 14 88 mov (%eax,%ecx,4),%edx if ( !the_thread ) 107728: 85 d2 test %edx,%edx 10772a: 0f 84 e7 00 00 00 je 107817 <== NEVER TAKEN continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 107730: 51 push %ecx 107731: 8d 5d a3 lea -0x5d(%ebp),%ebx 107734: 53 push %ebx 107735: 6a 0d push $0xd 107737: ff 72 08 pushl 0x8(%edx) 10773a: 89 55 90 mov %edx,-0x70(%ebp) 10773d: e8 fa 39 00 00 call 10b13c (*print)( 107742: 53 push %ebx 107743: 8b 55 90 mov -0x70(%ebp),%edx 107746: ff 72 08 pushl 0x8(%edx) 107749: 68 13 16 12 00 push $0x121613 10774e: ff 75 08 pushl 0x8(%ebp) 107751: 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; 107754: 8b 55 90 mov -0x70(%ebp),%edx 107757: 8b 8a 84 00 00 00 mov 0x84(%edx),%ecx 10775d: 8b 9a 88 00 00 00 mov 0x88(%edx),%ebx 107763: 89 4d c8 mov %ecx,-0x38(%ebp) 107766: 89 5d cc mov %ebx,-0x34(%ebp) if ( _Thread_Executing->Object.id == the_thread->Object.id ) { 107769: 83 c4 20 add $0x20,%esp 10776c: a1 2c 96 12 00 mov 0x12962c,%eax 107771: 8b 5a 08 mov 0x8(%edx),%ebx 107774: 39 58 08 cmp %ebx,0x8(%eax) 107777: 75 45 jne 1077be Timestamp_Control used; Timestamp_Control last = _Thread_Time_of_last_context_switch; 107779: a1 74 91 12 00 mov 0x129174,%eax 10777e: 8b 15 78 91 12 00 mov 0x129178,%edx 107784: 89 45 b0 mov %eax,-0x50(%ebp) 107787: 89 55 b4 mov %edx,-0x4c(%ebp) _TOD_Get_uptime( &uptime ); 10778a: 83 ec 0c sub $0xc,%esp 10778d: 8d 45 d8 lea -0x28(%ebp),%eax 107790: 50 push %eax 107791: e8 1a 4b 00 00 call 10c2b0 <_TOD_Get_uptime> _Timestamp_Subtract( &last, &uptime, &used ); 107796: 83 c4 0c add $0xc,%esp 107799: 8d 45 b8 lea -0x48(%ebp),%eax 10779c: 50 push %eax 10779d: 8d 55 d8 lea -0x28(%ebp),%edx 1077a0: 52 push %edx 1077a1: 8d 55 b0 lea -0x50(%ebp),%edx 1077a4: 52 push %edx 1077a5: 89 45 90 mov %eax,-0x70(%ebp) 1077a8: e8 f7 6a 00 00 call 10e2a4 <_Timespec_Subtract> _Timestamp_Add_to( &ran, &used ); 1077ad: 58 pop %eax 1077ae: 5a pop %edx 1077af: 8b 45 90 mov -0x70(%ebp),%eax 1077b2: 50 push %eax 1077b3: 8d 45 c8 lea -0x38(%ebp),%eax 1077b6: 50 push %eax 1077b7: e8 fc 69 00 00 call 10e1b8 <_Timespec_Add_to> 1077bc: eb 0c jmp 1077ca } else { _TOD_Get_uptime( &uptime ); 1077be: 83 ec 0c sub $0xc,%esp 1077c1: 8d 4d d8 lea -0x28(%ebp),%ecx 1077c4: 51 push %ecx 1077c5: e8 e6 4a 00 00 call 10c2b0 <_TOD_Get_uptime> 1077ca: 83 c4 0c add $0xc,%esp } _Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total ); 1077cd: 8d 5d d0 lea -0x30(%ebp),%ebx 1077d0: 53 push %ebx 1077d1: 8d 45 d8 lea -0x28(%ebp),%eax 1077d4: 50 push %eax 1077d5: 8d 55 c0 lea -0x40(%ebp),%edx 1077d8: 52 push %edx 1077d9: e8 c6 6a 00 00 call 10e2a4 <_Timespec_Subtract> _Timestamp_Divide( &ran, &total, &ival, &fval ); 1077de: 8d 4d e0 lea -0x20(%ebp),%ecx 1077e1: 51 push %ecx 1077e2: 8d 45 e4 lea -0x1c(%ebp),%eax 1077e5: 50 push %eax 1077e6: 53 push %ebx 1077e7: 8d 45 c8 lea -0x38(%ebp),%eax 1077ea: 50 push %eax 1077eb: e8 f8 69 00 00 call 10e1e8 <_Timespec_Divide> /* * Print the information */ (*print)( context, 1077f0: 83 c4 18 add $0x18,%esp 1077f3: ff 75 e0 pushl -0x20(%ebp) 1077f6: ff 75 e4 pushl -0x1c(%ebp) 1077f9: 8b 45 cc mov -0x34(%ebp),%eax 1077fc: b9 e8 03 00 00 mov $0x3e8,%ecx 107801: 31 d2 xor %edx,%edx 107803: f7 f1 div %ecx 107805: 50 push %eax 107806: ff 75 c8 pushl -0x38(%ebp) 107809: 68 26 16 12 00 push $0x121626 10780e: ff 75 08 pushl 0x8(%ebp) 107811: ff 55 0c call *0xc(%ebp) 107814: 83 c4 20 add $0x20,%esp continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 107817: ff 45 94 incl -0x6c(%ebp) 10781a: 0f b7 46 10 movzwl 0x10(%esi),%eax 10781e: 39 45 94 cmp %eax,-0x6c(%ebp) 107821: 0f 86 f8 fe ff ff jbe 10771f " ID | NAME | TICKS | PERCENT\n" #endif "------------+----------------------------------------+---------------+---------\n" ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 107827: 47 inc %edi 107828: 83 ff 04 cmp $0x4,%edi 10782b: 0f 85 d0 fe ff ff jne 107701 } } } #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( 107831: 8b 45 d4 mov -0x2c(%ebp),%eax 107834: b9 e8 03 00 00 mov $0x3e8,%ecx 107839: 31 d2 xor %edx,%edx 10783b: f7 f1 div %ecx 10783d: 50 push %eax 10783e: ff 75 d0 pushl -0x30(%ebp) 107841: 68 3e 16 12 00 push $0x12163e 107846: ff 75 08 pushl 0x8(%ebp) 107849: ff 55 0c call *0xc(%ebp) 10784c: 83 c4 10 add $0x10,%esp "-------------------------------------------------------------------------------\n", _Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset, total_units ); #endif } 10784f: 8d 65 f4 lea -0xc(%ebp),%esp 107852: 5b pop %ebx 107853: 5e pop %esi 107854: 5f pop %edi 107855: c9 leave 107856: c3 ret =============================================================================== 001110b8 : [RTEMS_IO_ERROR] = EIO, [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_deviceio_errno(rtems_status_code sc) { 1110b8: 55 push %ebp 1110b9: 89 e5 mov %esp,%ebp 1110bb: 53 push %ebx 1110bc: 83 ec 04 sub $0x4,%esp 1110bf: 8b 55 08 mov 0x8(%ebp),%edx if (sc == RTEMS_SUCCESSFUL) { return 0; 1110c2: 31 c0 xor %eax,%eax [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_deviceio_errno(rtems_status_code sc) { if (sc == RTEMS_SUCCESSFUL) { 1110c4: 85 d2 test %edx,%edx 1110c6: 74 1b je 1110e3 return 0; } else { int eno = EINVAL; 1110c8: bb 16 00 00 00 mov $0x16,%ebx if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) { 1110cd: 83 fa 1c cmp $0x1c,%edx 1110d0: 77 07 ja 1110d9 <== NEVER TAKEN eno = status_code_to_errno [sc]; 1110d2: 8b 1c 95 54 f7 11 00 mov 0x11f754(,%edx,4),%ebx } errno = eno; 1110d9: e8 5a 00 00 00 call 111138 <__errno> 1110de: 89 18 mov %ebx,(%eax) return -1; 1110e0: 83 c8 ff or $0xffffffff,%eax } } 1110e3: 5a pop %edx 1110e4: 5b pop %ebx 1110e5: c9 leave 1110e6: c3 ret =============================================================================== 0010e4a7 : rtems_filesystem_fsmount_me_t rtems_filesystem_get_mount_handler( const char *type ) { 10e4a7: 55 push %ebp 10e4a8: 89 e5 mov %esp,%ebp 10e4aa: 83 ec 18 sub $0x18,%esp 10e4ad: 8b 45 08 mov 0x8(%ebp),%eax find_arg fa = { 10e4b0: 89 45 f0 mov %eax,-0x10(%ebp) 10e4b3: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) .type = type, .mount_h = NULL }; if ( type != NULL ) { 10e4ba: 85 c0 test %eax,%eax 10e4bc: 74 13 je 10e4d1 <== NEVER TAKEN rtems_filesystem_iterate( find_handler, &fa ); 10e4be: 50 push %eax 10e4bf: 50 push %eax 10e4c0: 8d 45 f0 lea -0x10(%ebp),%eax 10e4c3: 50 push %eax 10e4c4: 68 d0 e3 10 00 push $0x10e3d0 10e4c9: e8 62 ff ff ff call 10e430 10e4ce: 83 c4 10 add $0x10,%esp } return fa.mount_h; } 10e4d1: 8b 45 f4 mov -0xc(%ebp),%eax 10e4d4: c9 leave 10e4d5: c3 ret =============================================================================== 0010712c : * configuration is a single instantiation of the IMFS or miniIMFS with * a single "/dev" directory in it. */ void rtems_filesystem_initialize( void ) { 10712c: 55 push %ebp 10712d: 89 e5 mov %esp,%ebp 10712f: 57 push %edi 107130: 56 push %esi 107131: 53 push %ebx 107132: 83 ec 2c sub $0x2c,%esp /* * Set the default umask to "022". */ rtems_filesystem_umask = 022; 107135: a1 80 30 12 00 mov 0x123080,%eax 10713a: c7 40 2c 12 00 00 00 movl $0x12,0x2c(%eax) /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) 107141: 83 3d e0 d7 11 00 00 cmpl $0x0,0x11d7e0 107148: 75 0a jne 107154 <== ALWAYS TAKEN rtems_fatal_error_occurred( 0xABCD0001 ); 10714a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10714d: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED 107152: eb 28 jmp 10717c <== NOT EXECUTED mt = &rtems_filesystem_mount_table[0]; 107154: a1 4c 11 12 00 mov 0x12114c,%eax status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL ); 107159: 83 ec 0c sub $0xc,%esp 10715c: 6a 00 push $0x0 10715e: ff 70 04 pushl 0x4(%eax) 107161: ff 30 pushl (%eax) 107163: ff 70 0c pushl 0xc(%eax) 107166: ff 70 08 pushl 0x8(%eax) 107169: e8 9b 06 00 00 call 107809 if ( status == -1 ) 10716e: 83 c4 20 add $0x20,%esp 107171: 40 inc %eax 107172: 75 0d jne 107181 <== ALWAYS TAKEN rtems_fatal_error_occurred( 0xABCD0002 ); 107174: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107177: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED 10717c: e8 07 36 00 00 call 10a788 <== NOT EXECUTED rtems_filesystem_link_counts = 0; 107181: a1 80 30 12 00 mov 0x123080,%eax 107186: 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); 10718c: 83 ec 0c sub $0xc,%esp 10718f: 6a 00 push $0x0 107191: 8d 5d d4 lea -0x2c(%ebp),%ebx 107194: 53 push %ebx 107195: 6a 00 push $0x0 107197: 6a 01 push $0x1 107199: 68 80 ef 11 00 push $0x11ef80 10719e: e8 03 01 00 00 call 1072a6 rtems_filesystem_root = loc; 1071a3: 8b 3d 80 30 12 00 mov 0x123080,%edi 1071a9: 83 c7 18 add $0x18,%edi 1071ac: b9 05 00 00 00 mov $0x5,%ecx 1071b1: 89 de mov %ebx,%esi 1071b3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0); 1071b5: 83 c4 14 add $0x14,%esp 1071b8: 6a 00 push $0x0 1071ba: 53 push %ebx 1071bb: 6a 00 push $0x0 1071bd: 6a 01 push $0x1 1071bf: 68 80 ef 11 00 push $0x11ef80 1071c4: e8 dd 00 00 00 call 1072a6 rtems_filesystem_current = loc; 1071c9: 8b 3d 80 30 12 00 mov 0x123080,%edi 1071cf: 83 c7 04 add $0x4,%edi 1071d2: b9 05 00 00 00 mov $0x5,%ecx 1071d7: 89 de mov %ebx,%esi 1071d9: 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); 1071db: 83 c4 18 add $0x18,%esp 1071de: 68 ff 01 00 00 push $0x1ff 1071e3: 68 82 ef 11 00 push $0x11ef82 1071e8: e8 c3 04 00 00 call 1076b0 if ( status != 0 ) 1071ed: 83 c4 10 add $0x10,%esp 1071f0: 85 c0 test %eax,%eax 1071f2: 74 0d je 107201 <== ALWAYS TAKEN rtems_fatal_error_occurred( 0xABCD0003 ); 1071f4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1071f7: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED 1071fc: e9 7b ff ff ff jmp 10717c <== NOT EXECUTED * 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. */ } 107201: 8d 65 f4 lea -0xc(%ebp),%esp 107204: 5b pop %ebx 107205: 5e pop %esi 107206: 5f pop %edi 107207: c9 leave 107208: c3 ret =============================================================================== 0010e430 : bool rtems_filesystem_iterate( rtems_per_filesystem_routine routine, void *routine_arg ) { 10e430: 55 push %ebp 10e431: 89 e5 mov %esp,%ebp 10e433: 57 push %edi 10e434: 56 push %esi 10e435: 53 push %ebx 10e436: 83 ec 1c sub $0x1c,%esp 10e439: 8b 75 08 mov 0x8(%ebp),%esi 10e43c: 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; 10e43f: 31 c0 xor %eax,%eax bool rtems_filesystem_iterate( rtems_per_filesystem_routine routine, void *routine_arg ) { const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0]; 10e441: bb c0 d7 11 00 mov $0x11d7c0,%ebx rtems_chain_node *node = NULL; bool stop = false; while ( table_entry->type && !stop ) { 10e446: eb 0c jmp 10e454 stop = (*routine)( table_entry, routine_arg ); 10e448: 51 push %ecx 10e449: 51 push %ecx 10e44a: 57 push %edi 10e44b: 53 push %ebx 10e44c: ff d6 call *%esi ++table_entry; 10e44e: 83 c3 08 add $0x8,%ebx 10e451: 83 c4 10 add $0x10,%esp { const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0]; rtems_chain_node *node = NULL; bool stop = false; while ( table_entry->type && !stop ) { 10e454: 83 3b 00 cmpl $0x0,(%ebx) 10e457: 74 06 je 10e45f 10e459: 84 c0 test %al,%al 10e45b: 74 eb je 10e448 10e45d: eb 40 jmp 10e49f stop = (*routine)( table_entry, routine_arg ); ++table_entry; } if ( !stop ) { 10e45f: 84 c0 test %al,%al 10e461: 75 3c jne 10e49f rtems_libio_lock(); 10e463: 88 45 e4 mov %al,-0x1c(%ebp) 10e466: e8 95 ff ff ff call 10e400 } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 10e46b: 8b 1d a8 30 12 00 mov 0x1230a8,%ebx ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( 10e471: 8a 55 e4 mov -0x1c(%ebp),%dl 10e474: eb 10 jmp 10e486 !rtems_chain_is_tail( &filesystem_chain, node ) && !stop; node = rtems_chain_next( node ) ) { const filesystem_node *fsn = (filesystem_node *) node; stop = (*routine)( &fsn->entry, routine_arg ); 10e476: 52 push %edx 10e477: 52 push %edx 10e478: 57 push %edi 10e479: 8d 43 08 lea 0x8(%ebx),%eax 10e47c: 50 push %eax 10e47d: ff d6 call *%esi 10e47f: 88 c2 mov %al,%dl } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 10e481: 8b 1b mov (%ebx),%ebx if ( !stop ) { rtems_libio_lock(); for ( node = rtems_chain_first( &filesystem_chain ); !rtems_chain_is_tail( &filesystem_chain, node ) && !stop; node = rtems_chain_next( node ) 10e483: 83 c4 10 add $0x10,%esp ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( 10e486: 81 fb ac 30 12 00 cmp $0x1230ac,%ebx 10e48c: 74 04 je 10e492 node = rtems_chain_first( &filesystem_chain ); !rtems_chain_is_tail( &filesystem_chain, node ) && !stop; 10e48e: 84 d2 test %dl,%dl 10e490: 74 e4 je 10e476 <== ALWAYS TAKEN ) { const filesystem_node *fsn = (filesystem_node *) node; stop = (*routine)( &fsn->entry, routine_arg ); } rtems_libio_unlock(); 10e492: 88 55 e4 mov %dl,-0x1c(%ebp) 10e495: e8 80 ff ff ff call 10e41a 10e49a: 8a 55 e4 mov -0x1c(%ebp),%dl 10e49d: 88 d0 mov %dl,%al } return stop; } 10e49f: 8d 65 f4 lea -0xc(%ebp),%esp 10e4a2: 5b pop %ebx 10e4a3: 5e pop %esi 10e4a4: 5f pop %edi 10e4a5: c9 leave 10e4a6: c3 ret =============================================================================== 001077c1 : bool rtems_filesystem_mount_iterate( rtems_per_filesystem_mount_routine routine, void *routine_arg ) { 1077c1: 55 push %ebp 1077c2: 89 e5 mov %esp,%ebp 1077c4: 57 push %edi 1077c5: 56 push %esi 1077c6: 53 push %ebx 1077c7: 83 ec 1c sub $0x1c,%esp 1077ca: 8b 7d 08 mov 0x8(%ebp),%edi 1077cd: 8b 75 0c mov 0xc(%ebp),%esi rtems_chain_node *node = NULL; bool stop = false; rtems_libio_lock(); 1077d0: e8 bc ff ff ff call 107791 stop = (*routine)( mt_entry, routine_arg ); } rtems_libio_unlock(); return stop; } 1077d5: 8b 1d 64 2f 12 00 mov 0x122f64,%ebx rtems_per_filesystem_mount_routine routine, void *routine_arg ) { rtems_chain_node *node = NULL; bool stop = false; 1077db: 31 c0 xor %eax,%eax rtems_libio_lock(); for ( 1077dd: eb 0b jmp 1077ea 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 ); 1077df: 50 push %eax 1077e0: 50 push %eax 1077e1: 56 push %esi 1077e2: 53 push %ebx 1077e3: ff d7 call *%edi } rtems_libio_unlock(); return stop; } 1077e5: 8b 1b mov (%ebx),%ebx rtems_libio_lock(); for ( node = rtems_chain_first( &mount_chain ); !rtems_chain_is_tail( &mount_chain, node ) && !stop; node = rtems_chain_next( node ) 1077e7: 83 c4 10 add $0x10,%esp { rtems_chain_node *node = NULL; bool stop = false; rtems_libio_lock(); for ( 1077ea: 81 fb 68 2f 12 00 cmp $0x122f68,%ebx 1077f0: 74 04 je 1077f6 node = rtems_chain_first( &mount_chain ); !rtems_chain_is_tail( &mount_chain, node ) && !stop; 1077f2: 84 c0 test %al,%al 1077f4: 74 e9 je 1077df <== ALWAYS TAKEN const rtems_filesystem_mount_table_entry_t *mt_entry = (rtems_filesystem_mount_table_entry_t *) node; stop = (*routine)( mt_entry, routine_arg ); } rtems_libio_unlock(); 1077f6: 88 45 e4 mov %al,-0x1c(%ebp) 1077f9: e8 ad ff ff ff call 1077ab return stop; } 1077fe: 8a 45 e4 mov -0x1c(%ebp),%al 107801: 8d 65 f4 lea -0xc(%ebp),%esp 107804: 5b pop %ebx 107805: 5e pop %esi 107806: 5f pop %edi 107807: c9 leave 107808: c3 ret =============================================================================== 00107326 : int rtems_filesystem_prefix_separators( const char *pathname, int pathnamelen ) { 107326: 55 push %ebp 107327: 89 e5 mov %esp,%ebp 107329: 57 push %edi 10732a: 56 push %esi 10732b: 53 push %ebx 10732c: 83 ec 0c sub $0xc,%esp 10732f: 8b 7d 08 mov 0x8(%ebp),%edi 107332: 8b 75 0c mov 0xc(%ebp),%esi /* * Eat any separators at start of the path. */ int stripped = 0; 107335: 31 db xor %ebx,%ebx while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) ) 107337: eb 01 jmp 10733a { pathname++; pathnamelen--; stripped++; 107339: 43 inc %ebx { /* * Eat any separators at start of the path. */ int stripped = 0; while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) ) 10733a: 8a 04 1f mov (%edi,%ebx,1),%al 10733d: 39 de cmp %ebx,%esi 10733f: 74 17 je 107358 <== NEVER TAKEN 107341: 84 c0 test %al,%al 107343: 74 13 je 107358 <== NEVER TAKEN 107345: 83 ec 0c sub $0xc,%esp 107348: 0f be c0 movsbl %al,%eax 10734b: 50 push %eax 10734c: e8 03 0d 00 00 call 108054 107351: 83 c4 10 add $0x10,%esp 107354: 85 c0 test %eax,%eax 107356: 75 e1 jne 107339 pathname++; pathnamelen--; stripped++; } return stripped; } 107358: 89 d8 mov %ebx,%eax 10735a: 8d 65 f4 lea -0xc(%ebp),%esp 10735d: 5b pop %ebx 10735e: 5e pop %esi 10735f: 5f pop %edi 107360: c9 leave 107361: c3 ret =============================================================================== 00107bed : int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *)) { 107bed: 55 push %ebp 107bee: 89 e5 mov %esp,%ebp 107bf0: 56 push %esi 107bf1: 53 push %ebx 107bf2: 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 ) ); 107bf5: 83 ec 0c sub $0xc,%esp 107bf8: 6a 08 push $0x8 107bfa: e8 89 03 00 00 call 107f88 107bff: 89 c3 mov %eax,%ebx *key = new_key; 107c01: 8b 45 08 mov 0x8(%ebp),%eax 107c04: 89 18 mov %ebx,(%eax) new_key->val = NULL; 107c06: c7 03 00 00 00 00 movl $0x0,(%ebx) new_key->dtor = dtor; 107c0c: 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 ); 107c0f: 83 c4 0c add $0xc,%esp 107c12: 56 push %esi 107c13: 53 push %ebx 107c14: 6a 00 push $0x0 107c16: e8 41 34 00 00 call 10b05c 107c1b: 89 c2 mov %eax,%edx if ( status == RTEMS_SUCCESSFUL ) 107c1d: 83 c4 10 add $0x10,%esp return 0; 107c20: 31 c0 xor %eax,%eax ); #endif /* 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 ) 107c22: 85 d2 test %edx,%edx 107c24: 74 0f je 107c35 <== ALWAYS TAKEN return 0; free( new_key ); 107c26: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107c29: 53 push %ebx <== NOT EXECUTED 107c2a: e8 79 fe ff ff call 107aa8 <== NOT EXECUTED return -1; 107c2f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107c32: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 107c35: 8d 65 f8 lea -0x8(%ebp),%esp 107c38: 5b pop %ebx 107c39: 5e pop %esi 107c3a: c9 leave 107c3b: c3 ret =============================================================================== 00107c4c : int rtems_gxx_key_delete (__gthread_key_t key) { 107c4c: 55 push %ebp 107c4d: 89 e5 mov %esp,%ebp 107c4f: 53 push %ebx 107c50: 83 ec 0c sub $0xc,%esp 107c53: 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 ); 107c56: 53 push %ebx 107c57: 6a 00 push $0x0 107c59: e8 92 34 00 00 call 10b0f0 if ( status == RTEMS_SUCCESSFUL ) { 107c5e: 83 c4 10 add $0x10,%esp 107c61: 85 c0 test %eax,%eax 107c63: 75 11 jne 107c76 <== NEVER TAKEN /* Hmm - hopefully all tasks using this key have gone away... */ if ( key ) free( *(void **)key ); 107c65: 85 db test %ebx,%ebx 107c67: 74 0d je 107c76 <== NEVER TAKEN 107c69: 83 ec 0c sub $0xc,%esp 107c6c: ff 33 pushl (%ebx) 107c6e: e8 35 fe ff ff call 107aa8 107c73: 83 c4 10 add $0x10,%esp return 0; } key = NULL; return 0; } 107c76: 31 c0 xor %eax,%eax 107c78: 8b 5d fc mov -0x4(%ebp),%ebx 107c7b: c9 leave 107c7c: c3 ret =============================================================================== 00107b94 : /* 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)) { 107b94: 55 push %ebp 107b95: 89 e5 mov %esp,%ebp 107b97: 56 push %esi 107b98: 53 push %ebx 107b99: 83 ec 10 sub $0x10,%esp 107b9c: 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 ) { 107b9f: 8b 03 mov (%ebx),%eax 107ba1: 85 c0 test %eax,%eax 107ba3: 75 3f jne 107be4 rtems_mode saveMode; __gthread_once_t o; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 107ba5: 52 push %edx 107ba6: 8d 45 f4 lea -0xc(%ebp),%eax 107ba9: 50 push %eax 107baa: 68 00 01 00 00 push $0x100 107baf: 68 00 01 00 00 push $0x100 107bb4: e8 23 33 00 00 call 10aedc if ( (o = *(volatile __gthread_once_t *)once) == 0 ) { 107bb9: 8b 33 mov (%ebx),%esi 107bbb: 83 c4 10 add $0x10,%esp 107bbe: 85 f6 test %esi,%esi 107bc0: 75 06 jne 107bc8 <== NEVER TAKEN *(volatile __gthread_once_t *)once = 1; 107bc2: c7 03 01 00 00 00 movl $0x1,(%ebx) } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 107bc8: 50 push %eax 107bc9: 8d 45 f4 lea -0xc(%ebp),%eax 107bcc: 50 push %eax 107bcd: 68 00 01 00 00 push $0x100 107bd2: ff 75 f4 pushl -0xc(%ebp) 107bd5: e8 02 33 00 00 call 10aedc if ( o == 0 ) 107bda: 83 c4 10 add $0x10,%esp 107bdd: 85 f6 test %esi,%esi 107bdf: 75 03 jne 107be4 <== NEVER TAKEN (*func)(); 107be1: ff 55 0c call *0xc(%ebp) } return 0; } 107be4: 31 c0 xor %eax,%eax 107be6: 8d 65 f8 lea -0x8(%ebp),%esp 107be9: 5b pop %ebx 107bea: 5e pop %esi 107beb: c9 leave 107bec: c3 ret =============================================================================== 00107cd5 : int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr) { 107cd5: 55 push %ebp 107cd6: 89 e5 mov %esp,%ebp 107cd8: 53 push %ebx 107cd9: 83 ec 08 sub $0x8,%esp 107cdc: 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 ); 107cdf: ff 73 04 pushl 0x4(%ebx) 107ce2: 53 push %ebx 107ce3: 6a 00 push $0x0 107ce5: e8 72 33 00 00 call 10b05c 107cea: 89 c2 mov %eax,%edx if ( status == RTEMS_SUCCESSFUL ) { 107cec: 83 c4 10 add $0x10,%esp /* now let's set the proper value */ key->val = (void *)ptr; return 0; } return -1; 107cef: 83 c8 ff or $0xffffffff,%eax ); #endif /* register with RTEMS the buffer that will hold the key values */ status = rtems_task_variable_add( RTEMS_SELF, (void **)key, key->dtor ); if ( status == RTEMS_SUCCESSFUL ) { 107cf2: 85 d2 test %edx,%edx 107cf4: 75 07 jne 107cfd <== NEVER TAKEN /* now let's set the proper value */ key->val = (void *)ptr; 107cf6: 8b 45 0c mov 0xc(%ebp),%eax 107cf9: 89 03 mov %eax,(%ebx) return 0; 107cfb: 31 c0 xor %eax,%eax } return -1; } 107cfd: 8b 5d fc mov -0x4(%ebp),%ebx 107d00: c9 leave 107d01: c3 ret =============================================================================== 0010a9e4 : void *rtems_heap_allocate_aligned_with_boundary( size_t size, uintptr_t alignment, uintptr_t boundary ) { 10a9e4: 55 push %ebp 10a9e5: 89 e5 mov %esp,%ebp 10a9e7: 83 ec 08 sub $0x8,%esp if ( 10a9ea: 83 3d c8 bd 12 00 03 cmpl $0x3,0x12bdc8 10a9f1: 75 0d jne 10aa00 <== NEVER TAKEN _System_state_Is_up( _System_state_Get() ) && !malloc_is_system_state_OK() 10a9f3: e8 10 f1 ff ff call 109b08 10a9f8: 88 c2 mov %al,%dl ) { return NULL; 10a9fa: 31 c0 xor %eax,%eax uintptr_t boundary ) { if ( _System_state_Is_up( _System_state_Get() ) && !malloc_is_system_state_OK() 10a9fc: 84 d2 test %dl,%dl 10a9fe: 74 1c je 10aa1c ) { return NULL; } malloc_deferred_frees_process(); 10aa00: e8 41 f1 ff ff call 109b46 /* FIXME: Statistics, boundary checks */ return _Protected_heap_Allocate_aligned_with_boundary( 10aa05: ff 75 10 pushl 0x10(%ebp) 10aa08: ff 75 0c pushl 0xc(%ebp) 10aa0b: ff 75 08 pushl 0x8(%ebp) 10aa0e: ff 35 80 71 12 00 pushl 0x127180 10aa14: e8 ef 43 00 00 call 10ee08 <_Protected_heap_Allocate_aligned_with_boundary> 10aa19: 83 c4 10 add $0x10,%esp RTEMS_Malloc_Heap, size, alignment, boundary ); } 10aa1c: c9 leave 10aa1d: c3 ret =============================================================================== 00107052 : rtems_status_code rtems_io_lookup_name( const char *name, rtems_driver_name_t *device_info ) { 107052: 55 push %ebp 107053: 89 e5 mov %esp,%ebp 107055: 57 push %edi 107056: 56 push %esi 107057: 53 push %ebx 107058: 83 ec 48 sub $0x48,%esp 10705b: 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( 10705e: 31 c0 xor %eax,%eax 107060: 83 c9 ff or $0xffffffff,%ecx 107063: 89 f7 mov %esi,%edi 107065: f2 ae repnz scas %es:(%edi),%al 107067: f7 d1 not %ecx 107069: 49 dec %ecx 10706a: 6a 01 push $0x1 10706c: 8d 55 d4 lea -0x2c(%ebp),%edx 10706f: 52 push %edx 107070: 6a 00 push $0x0 107072: 51 push %ecx 107073: 56 push %esi 107074: 89 55 c4 mov %edx,-0x3c(%ebp) 107077: e8 2a 02 00 00 call 1072a6 10707c: 89 c7 mov %eax,%edi name, strlen( name ), 0x00, &loc, true ); the_jnode = loc.node_access; 10707e: 8b 5d d4 mov -0x2c(%ebp),%ebx node_type = (*loc.ops->node_type_h)( &loc ); 107081: 83 c4 14 add $0x14,%esp 107084: 8b 55 c4 mov -0x3c(%ebp),%edx 107087: 52 push %edx 107088: 8b 45 e0 mov -0x20(%ebp),%eax 10708b: ff 50 10 call *0x10(%eax) if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) { 10708e: 83 c4 10 add $0x10,%esp 107091: 83 f8 02 cmp $0x2,%eax 107094: 8b 55 c4 mov -0x3c(%ebp),%edx 107097: 75 07 jne 1070a0 107099: 85 ff test %edi,%edi 10709b: 0f 95 c0 setne %al 10709e: 74 16 je 1070b6 <== ALWAYS TAKEN rtems_filesystem_freenode( &loc ); 1070a0: 83 ec 0c sub $0xc,%esp 1070a3: 8d 45 d4 lea -0x2c(%ebp),%eax 1070a6: 50 push %eax 1070a7: e8 b8 02 00 00 call 107364 return RTEMS_UNSATISFIED; 1070ac: 83 c4 10 add $0x10,%esp 1070af: b8 0d 00 00 00 mov $0xd,%eax 1070b4: eb 32 jmp 1070e8 } device_info->device_name = (char *) name; 1070b6: 8b 4d 0c mov 0xc(%ebp),%ecx 1070b9: 89 31 mov %esi,(%ecx) device_info->device_name_length = strlen( name ); 1070bb: 83 c9 ff or $0xffffffff,%ecx 1070be: 89 f7 mov %esi,%edi 1070c0: f2 ae repnz scas %es:(%edi),%al 1070c2: f7 d1 not %ecx 1070c4: 49 dec %ecx 1070c5: 8b 45 0c mov 0xc(%ebp),%eax 1070c8: 89 48 04 mov %ecx,0x4(%eax) device_info->major = the_jnode->info.device.major; 1070cb: 8b 43 50 mov 0x50(%ebx),%eax 1070ce: 8b 4d 0c mov 0xc(%ebp),%ecx 1070d1: 89 41 08 mov %eax,0x8(%ecx) device_info->minor = the_jnode->info.device.minor; 1070d4: 8b 43 54 mov 0x54(%ebx),%eax 1070d7: 89 41 0c mov %eax,0xc(%ecx) rtems_filesystem_freenode( &loc ); 1070da: 83 ec 0c sub $0xc,%esp 1070dd: 52 push %edx 1070de: e8 81 02 00 00 call 107364 return RTEMS_SUCCESSFUL; 1070e3: 83 c4 10 add $0x10,%esp 1070e6: 31 c0 xor %eax,%eax } 1070e8: 8d 65 f4 lea -0xc(%ebp),%esp 1070eb: 5b pop %ebx 1070ec: 5e pop %esi 1070ed: 5f pop %edi 1070ee: c9 leave 1070ef: c3 ret =============================================================================== 0010c7b4 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10c7b4: 55 push %ebp 10c7b5: 89 e5 mov %esp,%ebp 10c7b7: 57 push %edi 10c7b8: 56 push %esi 10c7b9: 53 push %ebx 10c7ba: 83 ec 0c sub $0xc,%esp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10c7bd: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 10c7c1: 74 3d je 10c800 <== NEVER TAKEN 10c7c3: bb 01 00 00 00 mov $0x1,%ebx #if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG) if ( !_Objects_Information_table[ api_index ] ) continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 10c7c8: 8b 04 9d 9c 90 12 00 mov 0x12909c(,%ebx,4),%eax 10c7cf: 8b 78 04 mov 0x4(%eax),%edi if ( !information ) 10c7d2: be 01 00 00 00 mov $0x1,%esi 10c7d7: 85 ff test %edi,%edi 10c7d9: 75 17 jne 10c7f2 10c7db: eb 1d jmp 10c7fa continue; for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 10c7dd: 8b 47 1c mov 0x1c(%edi),%eax 10c7e0: 8b 04 b0 mov (%eax,%esi,4),%eax if ( !the_thread ) 10c7e3: 85 c0 test %eax,%eax 10c7e5: 74 0a je 10c7f1 <== NEVER TAKEN continue; (*routine)(the_thread); 10c7e7: 83 ec 0c sub $0xc,%esp 10c7ea: 50 push %eax 10c7eb: ff 55 08 call *0x8(%ebp) 10c7ee: 83 c4 10 add $0x10,%esp information = _Objects_Information_table[ api_index ][ 1 ]; if ( !information ) continue; for ( i=1 ; i <= information->maximum ; i++ ) { 10c7f1: 46 inc %esi 10c7f2: 0f b7 47 10 movzwl 0x10(%edi),%eax 10c7f6: 39 c6 cmp %eax,%esi 10c7f8: 76 e3 jbe 10c7dd Objects_Information *information; if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10c7fa: 43 inc %ebx 10c7fb: 83 fb 04 cmp $0x4,%ebx 10c7fe: 75 c8 jne 10c7c8 (*routine)(the_thread); } } } 10c800: 8d 65 f4 lea -0xc(%ebp),%esp 10c803: 5b pop %ebx 10c804: 5e pop %esi 10c805: 5f pop %edi 10c806: c9 leave 10c807: c3 ret =============================================================================== 0010e304 : */ void rtems_libio_free( rtems_libio_t *iop ) { 10e304: 55 push %ebp 10e305: 89 e5 mov %esp,%ebp 10e307: 53 push %ebx 10e308: 83 ec 04 sub $0x4,%esp 10e30b: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_libio_lock(); 10e30e: e8 d5 fe ff ff call 10e1e8 if (iop->sem) 10e313: 8b 43 2c mov 0x2c(%ebx),%eax 10e316: 85 c0 test %eax,%eax 10e318: 74 0c je 10e326 <== NEVER TAKEN rtems_semaphore_delete(iop->sem); 10e31a: 83 ec 0c sub $0xc,%esp 10e31d: 50 push %eax 10e31e: e8 09 be ff ff call 10a12c 10e323: 83 c4 10 add $0x10,%esp iop->flags &= ~LIBIO_FLAGS_OPEN; 10e326: 81 63 14 ff fe ff ff andl $0xfffffeff,0x14(%ebx) iop->data1 = rtems_libio_iop_freelist; 10e32d: a1 fc 51 12 00 mov 0x1251fc,%eax 10e332: 89 43 34 mov %eax,0x34(%ebx) rtems_libio_iop_freelist = iop; 10e335: 89 1d fc 51 12 00 mov %ebx,0x1251fc rtems_libio_unlock(); } 10e33b: 8b 5d fc mov -0x4(%ebp),%ebx 10e33e: c9 leave iop->flags &= ~LIBIO_FLAGS_OPEN; iop->data1 = rtems_libio_iop_freelist; rtems_libio_iop_freelist = iop; rtems_libio_unlock(); 10e33f: e9 be fe ff ff jmp 10e202 =============================================================================== 00107464 : * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) { 107464: 55 push %ebp 107465: 89 e5 mov %esp,%ebp 107467: 53 push %ebx 107468: 83 ec 04 sub $0x4,%esp rtems_status_code rc; uint32_t i; rtems_libio_t *iop; if (rtems_libio_number_iops > 0) 10746b: 8b 1d 44 11 12 00 mov 0x121144,%ebx 107471: 85 db test %ebx,%ebx 107473: 74 3e je 1074b3 <== NEVER TAKEN { rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, 107475: 50 push %eax 107476: 50 push %eax 107477: 6a 38 push $0x38 107479: 53 push %ebx 10747a: e8 8d fd ff ff call 10720c 10747f: a3 f8 51 12 00 mov %eax,0x1251f8 sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) 107484: 83 c4 10 add $0x10,%esp 107487: 85 c0 test %eax,%eax 107489: 75 07 jne 107492 rtems_fatal_error_occurred(RTEMS_NO_MEMORY); 10748b: 83 ec 0c sub $0xc,%esp 10748e: 6a 1a push $0x1a 107490: eb 44 jmp 1074d6 iop = rtems_libio_iop_freelist = rtems_libio_iops; 107492: a3 fc 51 12 00 mov %eax,0x1251fc 107497: 89 c2 mov %eax,%edx for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++) 107499: 31 c9 xor %ecx,%ecx 10749b: eb 03 jmp 1074a0 iop->data1 = iop + 1; 10749d: 89 52 fc mov %edx,-0x4(%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++) 1074a0: 41 inc %ecx 1074a1: 83 c2 38 add $0x38,%edx 1074a4: 39 d9 cmp %ebx,%ecx 1074a6: 72 f5 jb 10749d iop->data1 = iop + 1; iop->data1 = NULL; 1074a8: 6b db 38 imul $0x38,%ebx,%ebx 1074ab: c7 44 18 fc 00 00 00 movl $0x0,-0x4(%eax,%ebx,1) 1074b2: 00 /* * Create the binary semaphore used to provide mutual exclusion * on the IOP Table. */ rc = rtems_semaphore_create( 1074b3: 83 ec 0c sub $0xc,%esp 1074b6: 68 00 52 12 00 push $0x125200 1074bb: 6a 00 push $0x0 1074bd: 6a 54 push $0x54 1074bf: 6a 01 push $0x1 1074c1: 68 4f 49 42 4c push $0x4c42494f 1074c6: e8 c9 2a 00 00 call 109f94 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_libio_semaphore ); if ( rc != RTEMS_SUCCESSFUL ) 1074cb: 83 c4 20 add $0x20,%esp 1074ce: 85 c0 test %eax,%eax 1074d0: 74 09 je 1074db <== ALWAYS TAKEN rtems_fatal_error_occurred( rc ); 1074d2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1074d5: 50 push %eax <== NOT EXECUTED 1074d6: e8 ad 32 00 00 call 10a788 /* * Initialize the base file system infrastructure. */ if (rtems_fs_init_helper) 1074db: a1 40 11 12 00 mov 0x121140,%eax 1074e0: 85 c0 test %eax,%eax 1074e2: 74 06 je 1074ea <== NEVER TAKEN (* rtems_fs_init_helper)(); } 1074e4: 8b 5d fc mov -0x4(%ebp),%ebx 1074e7: c9 leave /* * Initialize the base file system infrastructure. */ if (rtems_fs_init_helper) (* rtems_fs_init_helper)(); 1074e8: ff e0 jmp *%eax } 1074ea: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1074ed: c9 leave <== NOT EXECUTED 1074ee: c3 ret <== NOT EXECUTED =============================================================================== 00108651 : rtems_status_code rtems_libio_set_private_env(void) { 108651: 55 push %ebp 108652: 89 e5 mov %esp,%ebp 108654: 57 push %edi 108655: 56 push %esi 108656: 53 push %ebx 108657: 83 ec 3c sub $0x3c,%esp rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_id task_id = rtems_task_self(); 10865a: e8 4d 27 00 00 call 10adac 10865f: 89 c3 mov %eax,%ebx 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); 108661: 83 ec 0c sub $0xc,%esp 108664: 6a 00 push $0x0 108666: 8d 45 d4 lea -0x2c(%ebp),%eax 108669: 50 push %eax 10866a: 6a 00 push $0x0 10866c: 6a 01 push $0x1 10866e: 68 e8 f7 11 00 push $0x11f7e8 108673: e8 42 f0 ff ff call 1076ba 108678: 89 c2 mov %eax,%edx if (rv != 0) 10867a: 83 c4 20 add $0x20,%esp error_1: rtems_filesystem_freenode(&root_loc); error_0: return RTEMS_NO_MEMORY; 10867d: b8 1a 00 00 00 mov $0x1a,%eax 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); if (rv != 0) 108682: 85 d2 test %edx,%edx 108684: 0f 85 c0 00 00 00 jne 10874a <== NEVER TAKEN goto error_0; rv = rtems_filesystem_evaluate_path("/", 1, 0, ¤t_loc, 0); 10868a: 83 ec 0c sub $0xc,%esp 10868d: 6a 00 push $0x0 10868f: 8d 45 c0 lea -0x40(%ebp),%eax 108692: 50 push %eax 108693: 6a 00 push $0x0 108695: 6a 01 push $0x1 108697: 68 e8 f7 11 00 push $0x11f7e8 10869c: e8 19 f0 ff ff call 1076ba if (rv != 0) 1086a1: 83 c4 20 add $0x20,%esp 1086a4: 85 c0 test %eax,%eax 1086a6: 0f 85 8a 00 00 00 jne 108736 <== 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 1086ac: a1 6c 30 12 00 mov 0x12306c,%eax /* * Bharath: I'm not sure if the check can be reduced to * if( rtems_current_user_env->task_id != task_id ) { */ if ( 1086b1: 3d 48 52 12 00 cmp $0x125248,%eax 1086b6: 74 04 je 1086bc rtems_current_user_env == &rtems_global_user_env || rtems_current_user_env->task_id != task_id 1086b8: 39 18 cmp %ebx,(%eax) 1086ba: 74 32 je 1086ee ) { new_env = malloc(sizeof(rtems_user_env_t)); 1086bc: 83 ec 0c sub $0xc,%esp 1086bf: 6a 48 push $0x48 1086c1: e8 66 f5 ff ff call 107c2c 1086c6: 89 c6 mov %eax,%esi if (new_env == NULL) 1086c8: 83 c4 10 add $0x10,%esp 1086cb: 85 c0 test %eax,%eax 1086cd: 74 58 je 108727 #ifdef HAVE_USERENV_REFCNT new_env->refcnt = 1; #endif sc = rtems_task_variable_add( 1086cf: 50 push %eax 1086d0: 68 14 86 10 00 push $0x108614 1086d5: 68 6c 30 12 00 push $0x12306c 1086da: 6a 00 push $0x0 1086dc: e8 3f 27 00 00 call 10ae20 RTEMS_SELF, (void*)&rtems_current_user_env, (void(*)(void *))free_user_env ); if (sc != RTEMS_SUCCESSFUL) 1086e1: 83 c4 10 add $0x10,%esp 1086e4: 85 c0 test %eax,%eax 1086e6: 75 33 jne 10871b goto error_3; rtems_current_user_env = new_env; 1086e8: 89 35 6c 30 12 00 mov %esi,0x12306c } /* Inherit the global values */ *rtems_current_user_env = rtems_global_user_env; 1086ee: a1 6c 30 12 00 mov 0x12306c,%eax 1086f3: be 48 52 12 00 mov $0x125248,%esi 1086f8: b9 12 00 00 00 mov $0x12,%ecx 1086fd: 89 c7 mov %eax,%edi 1086ff: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_current_user_env->task_id = task_id; 108701: 89 18 mov %ebx,(%eax) * 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; 108703: 8d 78 18 lea 0x18(%eax),%edi 108706: 8d 75 d4 lea -0x2c(%ebp),%esi 108709: b1 05 mov $0x5,%cl 10870b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_filesystem_current = current_loc; 10870d: 8d 78 04 lea 0x4(%eax),%edi 108710: 8d 75 c0 lea -0x40(%ebp),%esi 108713: b1 05 mov $0x5,%cl 108715: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return RTEMS_SUCCESSFUL; 108717: 31 c0 xor %eax,%eax 108719: eb 2f jmp 10874a error_3: free(new_env); 10871b: 83 ec 0c sub $0xc,%esp 10871e: 56 push %esi 10871f: e8 68 f0 ff ff call 10778c 108724: 83 c4 10 add $0x10,%esp error_2: rtems_filesystem_freenode(¤t_loc); 108727: 83 ec 0c sub $0xc,%esp 10872a: 8d 45 c0 lea -0x40(%ebp),%eax 10872d: 50 push %eax 10872e: e8 45 f0 ff ff call 107778 108733: 83 c4 10 add $0x10,%esp error_1: rtems_filesystem_freenode(&root_loc); 108736: 83 ec 0c sub $0xc,%esp 108739: 8d 45 d4 lea -0x2c(%ebp),%eax 10873c: 50 push %eax 10873d: e8 36 f0 ff ff call 107778 108742: 83 c4 10 add $0x10,%esp error_0: return RTEMS_NO_MEMORY; 108745: b8 1a 00 00 00 mov $0x1a,%eax } 10874a: 8d 65 f4 lea -0xc(%ebp),%esp 10874d: 5b pop %ebx 10874e: 5e pop %esi 10874f: 5f pop %edi 108750: c9 leave 108751: c3 ret =============================================================================== 00108752 : * 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) { 108752: 55 push %ebp 108753: 89 e5 mov %esp,%ebp 108755: 56 push %esi 108756: 53 push %ebx 108757: 83 ec 20 sub $0x20,%esp 10875a: 8b 75 08 mov 0x8(%ebp),%esi rtems_id current_task_id; /* * get current task id */ current_task_id = rtems_task_self(); 10875d: e8 4a 26 00 00 call 10adac 108762: 89 c3 mov %eax,%ebx * 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; 108764: 31 c0 xor %eax,%eax /* * 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 ) 108766: 39 de cmp %ebx,%esi 108768: 74 3c je 1087a6 <== NEVER TAKEN return RTEMS_SUCCESSFUL; /* * Try to get the requested user environment */ sc = rtems_task_variable_get( 10876a: 52 push %edx task_id, (void*)&rtems_current_user_env, (void*)&shared_user_env ); 10876b: 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( 10876e: 50 push %eax 10876f: 68 6c 30 12 00 push $0x12306c 108774: 56 push %esi 108775: e8 3a 27 00 00 call 10aeb4 (void*)&shared_user_env ); /* * If it was not successful, return the error code */ if (sc != RTEMS_SUCCESSFUL) 10877a: 83 c4 10 add $0x10,%esp 10877d: 85 c0 test %eax,%eax 10877f: 75 25 jne 1087a6 * 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) { 108781: 8b 15 6c 30 12 00 mov 0x12306c,%edx 108787: 39 1a cmp %ebx,(%edx) 108789: 75 12 jne 10879d rtems_user_env_t *tmp = rtems_current_user_env; free_user_env( tmp ); 10878b: 83 ec 0c sub $0xc,%esp 10878e: 52 push %edx 10878f: 89 45 e4 mov %eax,-0x1c(%ebp) 108792: e8 7d fe ff ff call 108614 108797: 83 c4 10 add $0x10,%esp 10879a: 8b 45 e4 mov -0x1c(%ebp),%eax } /* the current_user_env is the same pointer that remote env */ rtems_current_user_env = shared_user_env; 10879d: 8b 55 f4 mov -0xc(%ebp),%edx 1087a0: 89 15 6c 30 12 00 mov %edx,0x12306c #ifdef HAVE_USERENV_REFCNT rtems_current_user_env->refcnt++; #endif return RTEMS_SUCCESSFUL; } 1087a6: 8d 65 f8 lea -0x8(%ebp),%esp 1087a9: 5b pop %ebx 1087aa: 5e pop %esi 1087ab: c9 leave 1087ac: c3 ret =============================================================================== 0010e24d : */ uint32_t rtems_libio_to_fcntl_flags( uint32_t flags ) { 10e24d: 55 push %ebp 10e24e: 89 e5 mov %esp,%ebp 10e250: 8b 55 08 mov 0x8(%ebp),%edx uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10e253: 89 d1 mov %edx,%ecx 10e255: 83 e1 06 and $0x6,%ecx fcntl_flags |= O_RDWR; 10e258: b8 02 00 00 00 mov $0x2,%eax uint32_t flags ) { uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10e25d: 83 f9 06 cmp $0x6,%ecx 10e260: 74 0f je 10e271 fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { fcntl_flags |= O_RDONLY; 10e262: 30 c0 xor %al,%al { 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) { 10e264: f6 c2 02 test $0x2,%dl 10e267: 75 08 jne 10e271 <== ALWAYS TAKEN ) { uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { fcntl_flags |= O_RDWR; 10e269: 31 c0 xor %eax,%eax 10e26b: f6 c2 04 test $0x4,%dl <== NOT EXECUTED 10e26e: 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 ) { 10e271: f6 c2 01 test $0x1,%dl 10e274: 74 03 je 10e279 fcntl_flags |= O_NONBLOCK; 10e276: 80 cc 40 or $0x40,%ah } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 10e279: f6 c6 02 test $0x2,%dh 10e27c: 74 03 je 10e281 fcntl_flags |= O_APPEND; 10e27e: 83 c8 08 or $0x8,%eax } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 10e281: 80 e6 04 and $0x4,%dh 10e284: 74 03 je 10e289 fcntl_flags |= O_CREAT; 10e286: 80 cc 02 or $0x2,%ah } return fcntl_flags; } 10e289: c9 leave 10e28a: c3 ret =============================================================================== 00109e0c : * size and thus we skip updating the statistics. */ static void rtems_malloc_statistics_at_free( void *pointer ) { 109e0c: 55 push %ebp 109e0d: 89 e5 mov %esp,%ebp 109e0f: 83 ec 1c sub $0x1c,%esp uintptr_t size; if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) { 109e12: 8d 45 f4 lea -0xc(%ebp),%eax 109e15: 50 push %eax 109e16: ff 75 08 pushl 0x8(%ebp) 109e19: ff 35 80 71 12 00 pushl 0x127180 109e1f: e8 8c 50 00 00 call 10eeb0 <_Protected_heap_Get_block_size> 109e24: 83 c4 10 add $0x10,%esp 109e27: 84 c0 test %al,%al 109e29: 74 11 je 109e3c <== NEVER TAKEN MSBUMP(lifetime_freed, size); 109e2b: 8b 45 f4 mov -0xc(%ebp),%eax 109e2e: 31 d2 xor %edx,%edx 109e30: 01 05 60 bb 12 00 add %eax,0x12bb60 109e36: 11 15 64 bb 12 00 adc %edx,0x12bb64 } } 109e3c: c9 leave 109e3d: c3 ret =============================================================================== 00109e3e : } static void rtems_malloc_statistics_at_malloc( void *pointer ) { 109e3e: 55 push %ebp 109e3f: 89 e5 mov %esp,%ebp 109e41: 83 ec 18 sub $0x18,%esp 109e44: 8b 45 08 mov 0x8(%ebp),%eax uintptr_t actual_size = 0; 109e47: 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 ) 109e4e: 85 c0 test %eax,%eax 109e50: 74 43 je 109e95 <== NEVER TAKEN return; _Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size); 109e52: 52 push %edx 109e53: 8d 55 f4 lea -0xc(%ebp),%edx 109e56: 52 push %edx 109e57: 50 push %eax 109e58: ff 35 80 71 12 00 pushl 0x127180 109e5e: e8 4d 50 00 00 call 10eeb0 <_Protected_heap_Get_block_size> MSBUMP(lifetime_allocated, actual_size); 109e63: 8b 45 f4 mov -0xc(%ebp),%eax 109e66: 31 d2 xor %edx,%edx 109e68: 03 05 58 bb 12 00 add 0x12bb58,%eax 109e6e: 13 15 5c bb 12 00 adc 0x12bb5c,%edx 109e74: a3 58 bb 12 00 mov %eax,0x12bb58 109e79: 89 15 5c bb 12 00 mov %edx,0x12bb5c current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed); 109e7f: 2b 05 60 bb 12 00 sub 0x12bb60,%eax if (current_depth > s->max_depth) 109e85: 83 c4 10 add $0x10,%esp 109e88: 3b 05 54 bb 12 00 cmp 0x12bb54,%eax 109e8e: 76 05 jbe 109e95 s->max_depth = current_depth; 109e90: a3 54 bb 12 00 mov %eax,0x12bb54 } 109e95: c9 leave 109e96: c3 ret =============================================================================== 00111aac : int rtems_memalign( void **pointer, size_t alignment, size_t size ) { 111aac: 55 push %ebp 111aad: 89 e5 mov %esp,%ebp 111aaf: 57 push %edi 111ab0: 56 push %esi 111ab1: 53 push %ebx 111ab2: 83 ec 0c sub $0xc,%esp 111ab5: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Parameter error checks */ if ( !pointer ) return EINVAL; 111ab8: be 16 00 00 00 mov $0x16,%esi void *return_this; /* * Parameter error checks */ if ( !pointer ) 111abd: 85 db test %ebx,%ebx 111abf: 74 55 je 111b16 return EINVAL; *pointer = NULL; 111ac1: 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()) && 111ac7: 83 3d 54 85 12 00 03 cmpl $0x3,0x128554 111ace: 75 09 jne 111ad9 <== NEVER TAKEN !malloc_is_system_state_OK() ) 111ad0: e8 57 67 ff ff call 10822c *pointer = NULL; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 111ad5: 84 c0 test %al,%al 111ad7: 74 3d je 111b16 <== NEVER TAKEN return EINVAL; /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 111ad9: e8 8c 67 ff ff call 10826a Heap_Control *heap, uintptr_t size, uintptr_t alignment ) { return 111ade: 6a 00 push $0x0 111ae0: ff 75 0c pushl 0xc(%ebp) 111ae3: ff 75 10 pushl 0x10(%ebp) 111ae6: ff 35 80 41 12 00 pushl 0x124180 111aec: e8 77 af ff ff call 10ca68 <_Protected_heap_Allocate_aligned_with_boundary> 111af1: 89 c7 mov %eax,%edi return_this = _Protected_heap_Allocate_aligned( RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 111af3: 83 c4 10 add $0x10,%esp return ENOMEM; 111af6: be 0c 00 00 00 mov $0xc,%esi return_this = _Protected_heap_Allocate_aligned( RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 111afb: 85 c0 test %eax,%eax 111afd: 74 17 je 111b16 return ENOMEM; /* * If configured, update the more involved statistics */ if ( rtems_malloc_statistics_helpers ) 111aff: a1 90 66 12 00 mov 0x126690,%eax 111b04: 85 c0 test %eax,%eax 111b06: 74 0a je 111b12 (*rtems_malloc_statistics_helpers->at_malloc)(pointer); 111b08: 83 ec 0c sub $0xc,%esp 111b0b: 53 push %ebx 111b0c: ff 50 04 call *0x4(%eax) 111b0f: 83 c4 10 add $0x10,%esp *pointer = return_this; 111b12: 89 3b mov %edi,(%ebx) return 0; 111b14: 31 f6 xor %esi,%esi } 111b16: 89 f0 mov %esi,%eax 111b18: 8d 65 f4 lea -0xc(%ebp),%esp 111b1b: 5b pop %ebx 111b1c: 5e pop %esi 111b1d: 5f pop %edi 111b1e: c9 leave 111b1f: c3 ret =============================================================================== 001103cc : return (retval); } int rtems_mkdir(const char *path, mode_t mode) { 1103cc: 55 push %ebp 1103cd: 89 e5 mov %esp,%ebp 1103cf: 57 push %edi 1103d0: 56 push %esi 1103d1: 53 push %ebx 1103d2: 83 ec 78 sub $0x78,%esp int success = 0; char *dup_path = strdup(path); 1103d5: ff 75 08 pushl 0x8(%ebp) 1103d8: e8 87 32 00 00 call 113664 1103dd: 89 c3 mov %eax,%ebx if (dup_path != NULL) { 1103df: 83 c4 10 add $0x10,%esp success = build(dup_path, mode); free(dup_path); } return success != 0 ? 0 : -1; 1103e2: 83 c8 ff or $0xffffffff,%eax rtems_mkdir(const char *path, mode_t mode) { int success = 0; char *dup_path = strdup(path); if (dup_path != NULL) { 1103e5: 85 db test %ebx,%ebx 1103e7: 0f 84 1e 01 00 00 je 11050b <== NEVER TAKEN p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; 1103ed: 31 c0 xor %eax,%eax 1103ef: 80 3b 2f cmpb $0x2f,(%ebx) 1103f2: 0f 94 c0 sete %al 1103f5: 8d 3c 03 lea (%ebx,%eax,1),%edi char *p; p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ 1103f8: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) 1103ff: b8 01 00 00 00 mov $0x1,%eax ++p; for (first = 1, last = 0; !last ; ++p) { if (p[0] == '\0') 110404: 8a 0f mov (%edi),%cl last = 1; 110406: ba 01 00 00 00 mov $0x1,%edx oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; for (first = 1, last = 0; !last ; ++p) { if (p[0] == '\0') 11040b: 84 c9 test %cl,%cl 11040d: 74 0b je 11041a last = 1; else if (p[0] != '/') 11040f: 80 f9 2f cmp $0x2f,%cl 110412: 0f 85 c8 00 00 00 jne 1104e0 110418: 30 d2 xor %dl,%dl continue; *p = '\0'; 11041a: c6 07 00 movb $0x0,(%edi) if (!last && p[1] == '\0') 11041d: be 01 00 00 00 mov $0x1,%esi 110422: 85 d2 test %edx,%edx 110424: 75 0b jne 110431 110426: 31 d2 xor %edx,%edx 110428: 80 7f 01 00 cmpb $0x0,0x1(%edi) 11042c: 0f 94 c2 sete %dl 11042f: 89 d6 mov %edx,%esi last = 1; if (first) { 110431: 85 c0 test %eax,%eax 110433: 74 1a je 11044f * mkdir [-m mode] dir * * We change the user's umask and then restore it, * instead of doing chmod's. */ oumask = umask(0); 110435: 83 ec 0c sub $0xc,%esp 110438: 6a 00 push $0x0 11043a: e8 75 01 00 00 call 1105b4 11043f: 89 45 94 mov %eax,-0x6c(%ebp) numask = oumask & ~(S_IWUSR | S_IXUSR); 110442: 24 3f and $0x3f,%al (void)umask(numask); 110444: 89 04 24 mov %eax,(%esp) 110447: e8 68 01 00 00 call 1105b4 11044c: 83 c4 10 add $0x10,%esp first = 0; } if (last) (void)umask(oumask); if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { 11044f: b8 ff 01 00 00 mov $0x1ff,%eax oumask = umask(0); numask = oumask & ~(S_IWUSR | S_IXUSR); (void)umask(numask); first = 0; } if (last) 110454: 85 f6 test %esi,%esi 110456: 74 11 je 110469 (void)umask(oumask); 110458: 83 ec 0c sub $0xc,%esp 11045b: ff 75 94 pushl -0x6c(%ebp) 11045e: e8 51 01 00 00 call 1105b4 110463: 83 c4 10 add $0x10,%esp if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { 110466: 8b 45 0c mov 0xc(%ebp),%eax 110469: 52 push %edx 11046a: 52 push %edx 11046b: 50 push %eax 11046c: 53 push %ebx 11046d: e8 9e 82 ff ff call 108710 110472: 83 c4 10 add $0x10,%esp 110475: 85 c0 test %eax,%eax 110477: 79 5e jns 1104d7 if (errno == EEXIST || errno == EISDIR) { 110479: e8 0e 25 00 00 call 11298c <__errno> 11047e: 83 38 11 cmpl $0x11,(%eax) 110481: 74 0a je 11048d 110483: e8 04 25 00 00 call 11298c <__errno> 110488: 83 38 15 cmpl $0x15,(%eax) 11048b: 75 59 jne 1104e6 <== ALWAYS TAKEN if (stat(path, &sb) < 0) { 11048d: 50 push %eax 11048e: 50 push %eax 11048f: 8d 45 a0 lea -0x60(%ebp),%eax 110492: 50 push %eax 110493: 53 push %ebx 110494: e8 8b 00 00 00 call 110524 110499: 83 c4 10 add $0x10,%esp 11049c: 85 c0 test %eax,%eax 11049e: 78 46 js 1104e6 <== NEVER TAKEN retval = 0; break; } else if (!S_ISDIR(sb.st_mode)) { 1104a0: 8b 45 ac mov -0x54(%ebp),%eax 1104a3: 25 00 f0 00 00 and $0xf000,%eax 1104a8: 3d 00 40 00 00 cmp $0x4000,%eax 1104ad: 74 22 je 1104d1 if (last) 1104af: 85 f6 test %esi,%esi 1104b1: 74 0f je 1104c2 errno = EEXIST; 1104b3: e8 d4 24 00 00 call 11298c <__errno> 1104b8: c7 00 11 00 00 00 movl $0x11,(%eax) else errno = ENOTDIR; retval = 0; 1104be: 31 ff xor %edi,%edi 1104c0: eb 38 jmp 1104fa break; } else if (!S_ISDIR(sb.st_mode)) { if (last) errno = EEXIST; else errno = ENOTDIR; 1104c2: e8 c5 24 00 00 call 11298c <__errno> 1104c7: c7 00 14 00 00 00 movl $0x14,(%eax) retval = 0; 1104cd: 31 ff xor %edi,%edi 1104cf: eb 1b jmp 1104ec break; } if (last) 1104d1: 85 f6 test %esi,%esi 1104d3: 75 3e jne 110513 1104d5: eb 04 jmp 1104db } else { retval = 0; break; } } if (!last) 1104d7: 85 f6 test %esi,%esi 1104d9: 75 3f jne 11051a *p = '/'; 1104db: c6 07 2f movb $0x2f,(%edi) 1104de: 31 c0 xor %eax,%eax p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; for (first = 1, last = 0; !last ; ++p) { 1104e0: 47 inc %edi 1104e1: e9 1e ff ff ff jmp 110404 if (last) (void)umask(oumask); if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { if (errno == EEXIST || errno == EISDIR) { if (stat(path, &sb) < 0) { retval = 0; 1104e6: 31 ff xor %edi,%edi } } if (!last) *p = '/'; } if (!first && !last) 1104e8: 85 f6 test %esi,%esi 1104ea: 75 0e jne 1104fa <== ALWAYS TAKEN (void)umask(oumask); 1104ec: 83 ec 0c sub $0xc,%esp 1104ef: ff 75 94 pushl -0x6c(%ebp) 1104f2: e8 bd 00 00 00 call 1105b4 1104f7: 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); 1104fa: 83 ec 0c sub $0xc,%esp 1104fd: 53 push %ebx 1104fe: e8 b1 7c ff ff call 1081b4 } return success != 0 ? 0 : -1; 110503: 83 c4 10 add $0x10,%esp 110506: 83 ff 01 cmp $0x1,%edi 110509: 19 c0 sbb %eax,%eax } 11050b: 8d 65 f4 lea -0xc(%ebp),%esp 11050e: 5b pop %ebx 11050f: 5e pop %esi 110510: 5f pop %edi 110511: c9 leave 110512: c3 ret errno = ENOTDIR; retval = 0; break; } if (last) retval = 2; 110513: bf 02 00 00 00 mov $0x2,%edi 110518: eb e0 jmp 1104fa } else { retval = 0; break; } } if (!last) 11051a: bf 01 00 00 00 mov $0x1,%edi 11051f: eb d9 jmp 1104fa =============================================================================== 001148e0 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 1148e0: 55 push %ebp 1148e1: 89 e5 mov %esp,%ebp 1148e3: 57 push %edi 1148e4: 56 push %esi 1148e5: 53 push %ebx 1148e6: 83 ec 1c sub $0x1c,%esp 1148e9: 8b 75 0c mov 0xc(%ebp),%esi 1148ec: 8b 55 10 mov 0x10(%ebp),%edx 1148ef: 8b 7d 14 mov 0x14(%ebp),%edi register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 1148f2: b8 03 00 00 00 mov $0x3,%eax rtems_id *id ) { register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 1148f7: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 1148fb: 0f 84 ce 00 00 00 je 1149cf return RTEMS_INVALID_NAME; if ( !starting_address ) return RTEMS_INVALID_ADDRESS; 114901: b0 09 mov $0x9,%al register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !starting_address ) 114903: 85 f6 test %esi,%esi 114905: 0f 84 c4 00 00 00 je 1149cf return RTEMS_INVALID_ADDRESS; if ( !id ) 11490b: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp) 11490f: 0f 84 ba 00 00 00 je 1149cf <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 114915: 85 ff test %edi,%edi 114917: 0f 84 ad 00 00 00 je 1149ca 11491d: 85 d2 test %edx,%edx 11491f: 0f 84 a5 00 00 00 je 1149ca !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; 114925: b0 08 mov $0x8,%al return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 114927: 39 fa cmp %edi,%edx 114929: 0f 82 a0 00 00 00 jb 1149cf 11492f: f7 c7 03 00 00 00 test $0x3,%edi 114935: 0f 85 94 00 00 00 jne 1149cf !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) return RTEMS_INVALID_ADDRESS; 11493b: b0 09 mov $0x9,%al if ( length == 0 || buffer_size == 0 || length < buffer_size || !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 11493d: f7 c6 03 00 00 00 test $0x3,%esi 114943: 0f 85 86 00 00 00 jne 1149cf 114949: a1 d4 f0 13 00 mov 0x13f0d4,%eax 11494e: 40 inc %eax 11494f: a3 d4 f0 13 00 mov %eax,0x13f0d4 * 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 ); 114954: 83 ec 0c sub $0xc,%esp 114957: 68 64 ef 13 00 push $0x13ef64 11495c: 89 55 e4 mov %edx,-0x1c(%ebp) 11495f: e8 20 3e 00 00 call 118784 <_Objects_Allocate> 114964: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 114966: 83 c4 10 add $0x10,%esp 114969: 85 c0 test %eax,%eax 11496b: 8b 55 e4 mov -0x1c(%ebp),%edx 11496e: 75 0c jne 11497c _Thread_Enable_dispatch(); 114970: e8 29 4d 00 00 call 11969e <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 114975: b8 05 00 00 00 mov $0x5,%eax 11497a: eb 53 jmp 1149cf _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 11497c: 89 70 10 mov %esi,0x10(%eax) the_partition->length = length; 11497f: 89 50 14 mov %edx,0x14(%eax) the_partition->buffer_size = buffer_size; 114982: 89 78 18 mov %edi,0x18(%eax) the_partition->attribute_set = attribute_set; 114985: 8b 45 18 mov 0x18(%ebp),%eax 114988: 89 43 1c mov %eax,0x1c(%ebx) the_partition->number_of_used_blocks = 0; 11498b: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) _Chain_Initialize( &the_partition->Memory, starting_address, 114992: 57 push %edi 114993: 89 d0 mov %edx,%eax 114995: 31 d2 xor %edx,%edx 114997: f7 f7 div %edi 114999: 50 push %eax 11499a: 56 push %esi 11499b: 8d 43 24 lea 0x24(%ebx),%eax 11499e: 50 push %eax 11499f: e8 84 2a 00 00 call 117428 <_Chain_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 1149a4: 8b 43 08 mov 0x8(%ebx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 1149a7: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 1149aa: 8b 15 80 ef 13 00 mov 0x13ef80,%edx 1149b0: 89 1c 8a mov %ebx,(%edx,%ecx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 1149b3: 8b 55 08 mov 0x8(%ebp),%edx 1149b6: 89 53 0c mov %edx,0xc(%ebx) &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 1149b9: 8b 55 1c mov 0x1c(%ebp),%edx 1149bc: 89 02 mov %eax,(%edx) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 1149be: e8 db 4c 00 00 call 11969e <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1149c3: 83 c4 10 add $0x10,%esp 1149c6: 31 c0 xor %eax,%eax 1149c8: eb 05 jmp 1149cf 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; 1149ca: b8 08 00 00 00 mov $0x8,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1149cf: 8d 65 f4 lea -0xc(%ebp),%esp 1149d2: 5b pop %ebx 1149d3: 5e pop %esi 1149d4: 5f pop %edi 1149d5: c9 leave 1149d6: c3 ret =============================================================================== 0010b085 : rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) { 10b085: 55 push %ebp 10b086: 89 e5 mov %esp,%ebp 10b088: 57 push %edi 10b089: 56 push %esi 10b08a: 53 push %ebx 10b08b: 83 ec 30 sub $0x30,%esp 10b08e: 8b 75 08 mov 0x8(%ebp),%esi 10b091: 8b 5d 0c mov 0xc(%ebp),%ebx 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 ); 10b094: 8d 45 e4 lea -0x1c(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) _Objects_Get( &_Rate_monotonic_Information, id, location ); 10b097: 50 push %eax 10b098: 56 push %esi 10b099: 68 74 83 12 00 push $0x128374 10b09e: e8 39 1e 00 00 call 10cedc <_Objects_Get> 10b0a3: 89 c7 mov %eax,%edi switch ( location ) { 10b0a5: 83 c4 10 add $0x10,%esp 10b0a8: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b0ac: 0f 85 3b 01 00 00 jne 10b1ed case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 10b0b2: a1 8c 89 12 00 mov 0x12898c,%eax 10b0b7: 39 47 40 cmp %eax,0x40(%edi) 10b0ba: 74 0f je 10b0cb _Thread_Enable_dispatch(); 10b0bc: e8 cd 28 00 00 call 10d98e <_Thread_Enable_dispatch> return RTEMS_NOT_OWNER_OF_RESOURCE; 10b0c1: be 17 00 00 00 mov $0x17,%esi 10b0c6: e9 27 01 00 00 jmp 10b1f2 } if ( length == RTEMS_PERIOD_STATUS ) { 10b0cb: 85 db test %ebx,%ebx 10b0cd: 75 1b jne 10b0ea switch ( the_period->state ) { 10b0cf: 8b 47 38 mov 0x38(%edi),%eax 10b0d2: 31 f6 xor %esi,%esi 10b0d4: 83 f8 04 cmp $0x4,%eax 10b0d7: 77 07 ja 10b0e0 <== NEVER TAKEN 10b0d9: 8b 34 85 8c 16 12 00 mov 0x12168c(,%eax,4),%esi case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 10b0e0: e8 a9 28 00 00 call 10d98e <_Thread_Enable_dispatch> return( return_value ); 10b0e5: e9 08 01 00 00 jmp 10b1f2 } _ISR_Disable( level ); 10b0ea: 9c pushf 10b0eb: fa cli 10b0ec: 8f 45 d4 popl -0x2c(%ebp) if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 10b0ef: 8b 47 38 mov 0x38(%edi),%eax 10b0f2: 85 c0 test %eax,%eax 10b0f4: 75 4c jne 10b142 _ISR_Enable( level ); 10b0f6: ff 75 d4 pushl -0x2c(%ebp) 10b0f9: 9d popf /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 10b0fa: 83 ec 0c sub $0xc,%esp 10b0fd: 57 push %edi 10b0fe: e8 3f fe ff ff call 10af42 <_Rate_monotonic_Initiate_statistics> the_period->state = RATE_MONOTONIC_ACTIVE; 10b103: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10b10a: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) the_watchdog->routine = routine; 10b111: c7 47 2c fc b3 10 00 movl $0x10b3fc,0x2c(%edi) the_watchdog->id = id; 10b118: 89 77 30 mov %esi,0x30(%edi) the_watchdog->user_data = user_data; 10b11b: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 10b122: 89 5f 3c mov %ebx,0x3c(%edi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b125: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b128: 58 pop %eax 10b129: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, length ); 10b12a: 83 c7 10 add $0x10,%edi 10b12d: 57 push %edi 10b12e: 68 28 85 12 00 push $0x128528 10b133: e8 68 35 00 00 call 10e6a0 <_Watchdog_Insert> _Thread_Enable_dispatch(); 10b138: e8 51 28 00 00 call 10d98e <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b13d: 83 c4 10 add $0x10,%esp 10b140: eb 65 jmp 10b1a7 } if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { 10b142: 83 f8 02 cmp $0x2,%eax 10b145: 75 64 jne 10b1ab /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 10b147: 83 ec 0c sub $0xc,%esp 10b14a: 57 push %edi 10b14b: e8 5a fe ff ff call 10afaa <_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; 10b150: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi) the_period->next_length = length; 10b157: 89 5f 3c mov %ebx,0x3c(%edi) _ISR_Enable( level ); 10b15a: ff 75 d4 pushl -0x2c(%ebp) 10b15d: 9d popf _Thread_Executing->Wait.id = the_period->Object.id; 10b15e: a1 8c 89 12 00 mov 0x12898c,%eax 10b163: 8b 57 08 mov 0x8(%edi),%edx 10b166: 89 50 20 mov %edx,0x20(%eax) _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b169: 5b pop %ebx 10b16a: 5e pop %esi 10b16b: 68 00 40 00 00 push $0x4000 10b170: 50 push %eax 10b171: e8 8a 2f 00 00 call 10e100 <_Thread_Set_state> /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 10b176: 9c pushf 10b177: fa cli 10b178: 5a pop %edx local_state = the_period->state; 10b179: 8b 47 38 mov 0x38(%edi),%eax the_period->state = RATE_MONOTONIC_ACTIVE; 10b17c: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi) _ISR_Enable( level ); 10b183: 52 push %edx 10b184: 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 ) 10b185: 83 c4 10 add $0x10,%esp 10b188: 83 f8 03 cmp $0x3,%eax 10b18b: 75 15 jne 10b1a2 _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b18d: 51 push %ecx 10b18e: 51 push %ecx 10b18f: 68 00 40 00 00 push $0x4000 10b194: ff 35 8c 89 12 00 pushl 0x12898c 10b19a: e8 d9 24 00 00 call 10d678 <_Thread_Clear_state> 10b19f: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 10b1a2: e8 e7 27 00 00 call 10d98e <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b1a7: 31 f6 xor %esi,%esi 10b1a9: eb 47 jmp 10b1f2 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b1ab: be 04 00 00 00 mov $0x4,%esi _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_EXPIRED ) { 10b1b0: 83 f8 04 cmp $0x4,%eax 10b1b3: 75 3d jne 10b1f2 <== NEVER TAKEN /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 10b1b5: 83 ec 0c sub $0xc,%esp 10b1b8: 57 push %edi 10b1b9: e8 ec fd ff ff call 10afaa <_Rate_monotonic_Update_statistics> _ISR_Enable( level ); 10b1be: ff 75 d4 pushl -0x2c(%ebp) 10b1c1: 9d popf the_period->state = RATE_MONOTONIC_ACTIVE; 10b1c2: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi) the_period->next_length = length; 10b1c9: 89 5f 3c mov %ebx,0x3c(%edi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b1cc: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b1cf: 58 pop %eax 10b1d0: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, length ); 10b1d1: 83 c7 10 add $0x10,%edi 10b1d4: 57 push %edi 10b1d5: 68 28 85 12 00 push $0x128528 10b1da: e8 c1 34 00 00 call 10e6a0 <_Watchdog_Insert> _Thread_Enable_dispatch(); 10b1df: e8 aa 27 00 00 call 10d98e <_Thread_Enable_dispatch> return RTEMS_TIMEOUT; 10b1e4: 83 c4 10 add $0x10,%esp 10b1e7: 66 be 06 00 mov $0x6,%si 10b1eb: eb 05 jmp 10b1f2 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b1ed: be 04 00 00 00 mov $0x4,%esi } 10b1f2: 89 f0 mov %esi,%eax 10b1f4: 8d 65 f4 lea -0xc(%ebp),%esp 10b1f7: 5b pop %ebx 10b1f8: 5e pop %esi 10b1f9: 5f pop %edi 10b1fa: c9 leave 10b1fb: c3 ret =============================================================================== 0010b1fc : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 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 7c sub $0x7c,%esp 10b205: 8b 5d 08 mov 0x8(%ebp),%ebx 10b208: 8b 7d 0c mov 0xc(%ebp),%edi rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 10b20b: 85 ff test %edi,%edi 10b20d: 0f 84 2b 01 00 00 je 10b33e <== NEVER TAKEN return; (*print)( context, "Period information by period\n" ); 10b213: 52 push %edx 10b214: 52 push %edx 10b215: 68 a0 16 12 00 push $0x1216a0 10b21a: 53 push %ebx 10b21b: ff d7 call *%edi #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( context, "--- CPU times are in seconds ---\n" ); 10b21d: 5e pop %esi 10b21e: 58 pop %eax 10b21f: 68 be 16 12 00 push $0x1216be 10b224: 53 push %ebx 10b225: ff d7 call *%edi (*print)( context, "--- Wall times are in seconds ---\n" ); 10b227: 5a pop %edx 10b228: 59 pop %ecx 10b229: 68 e0 16 12 00 push $0x1216e0 10b22e: 53 push %ebx 10b22f: ff d7 call *%edi Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 10b231: 5e pop %esi 10b232: 58 pop %eax 10b233: 68 03 17 12 00 push $0x121703 10b238: 53 push %ebx 10b239: ff d7 call *%edi #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ " " #endif " WALL TIME\n" ); (*print)( context, " " 10b23b: 5a pop %edx 10b23c: 59 pop %ecx 10b23d: 68 4e 17 12 00 push $0x12174e 10b242: 53 push %ebx 10b243: ff d7 call *%edi /* * 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 ; 10b245: 8b 35 7c 83 12 00 mov 0x12837c,%esi 10b24b: 83 c4 10 add $0x10,%esp 10b24e: e9 df 00 00 00 jmp 10b332 id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 10b253: 50 push %eax 10b254: 50 push %eax 10b255: 8d 45 88 lea -0x78(%ebp),%eax 10b258: 50 push %eax 10b259: 56 push %esi 10b25a: e8 c1 56 00 00 call 110920 if ( status != RTEMS_SUCCESSFUL ) 10b25f: 83 c4 10 add $0x10,%esp 10b262: 85 c0 test %eax,%eax 10b264: 0f 85 c7 00 00 00 jne 10b331 #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 ); 10b26a: 51 push %ecx 10b26b: 51 push %ecx 10b26c: 8d 55 c0 lea -0x40(%ebp),%edx 10b26f: 52 push %edx 10b270: 56 push %esi 10b271: e8 4e 57 00 00 call 1109c4 #endif rtems_object_get_name( the_status.owner, sizeof(name), name ); 10b276: 83 c4 0c add $0xc,%esp 10b279: 8d 45 e3 lea -0x1d(%ebp),%eax 10b27c: 50 push %eax 10b27d: 6a 05 push $0x5 10b27f: ff 75 c0 pushl -0x40(%ebp) 10b282: e8 01 02 00 00 call 10b488 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 10b287: 58 pop %eax 10b288: 5a pop %edx 10b289: ff 75 8c pushl -0x74(%ebp) 10b28c: ff 75 88 pushl -0x78(%ebp) 10b28f: 8d 55 e3 lea -0x1d(%ebp),%edx 10b292: 52 push %edx 10b293: 56 push %esi 10b294: 68 9a 17 12 00 push $0x12179a 10b299: 53 push %ebx 10b29a: ff d7 call *%edi ); /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 10b29c: 8b 45 88 mov -0x78(%ebp),%eax 10b29f: 83 c4 20 add $0x20,%esp 10b2a2: 85 c0 test %eax,%eax 10b2a4: 75 0f jne 10b2b5 (*print)( context, "\n" ); 10b2a6: 51 push %ecx 10b2a7: 51 push %ecx 10b2a8: 68 04 1a 12 00 push $0x121a04 10b2ad: 53 push %ebx 10b2ae: ff d7 call *%edi continue; 10b2b0: 83 c4 10 add $0x10,%esp 10b2b3: eb 7c jmp 10b331 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 ); 10b2b5: 52 push %edx 10b2b6: 8d 55 d8 lea -0x28(%ebp),%edx 10b2b9: 52 push %edx 10b2ba: 50 push %eax 10b2bb: 8d 45 a0 lea -0x60(%ebp),%eax 10b2be: 50 push %eax 10b2bf: e8 b0 30 00 00 call 10e374 <_Timespec_Divide_by_integer> (*print)( context, 10b2c4: 8b 45 dc mov -0x24(%ebp),%eax 10b2c7: b9 e8 03 00 00 mov $0x3e8,%ecx 10b2cc: 99 cltd 10b2cd: f7 f9 idiv %ecx 10b2cf: 50 push %eax 10b2d0: ff 75 d8 pushl -0x28(%ebp) 10b2d3: 8b 45 9c mov -0x64(%ebp),%eax 10b2d6: 99 cltd 10b2d7: f7 f9 idiv %ecx 10b2d9: 50 push %eax 10b2da: ff 75 98 pushl -0x68(%ebp) 10b2dd: 8b 45 94 mov -0x6c(%ebp),%eax 10b2e0: 99 cltd 10b2e1: f7 f9 idiv %ecx 10b2e3: 50 push %eax 10b2e4: ff 75 90 pushl -0x70(%ebp) 10b2e7: 68 b1 17 12 00 push $0x1217b1 10b2ec: 53 push %ebx 10b2ed: 89 4d 84 mov %ecx,-0x7c(%ebp) 10b2f0: ff d7 call *%edi 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); 10b2f2: 83 c4 2c add $0x2c,%esp 10b2f5: 8d 55 d8 lea -0x28(%ebp),%edx 10b2f8: 52 push %edx 10b2f9: ff 75 88 pushl -0x78(%ebp) { #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ 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; 10b2fc: 8d 45 b8 lea -0x48(%ebp),%eax _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); 10b2ff: 50 push %eax 10b300: e8 6f 30 00 00 call 10e374 <_Timespec_Divide_by_integer> (*print)( context, 10b305: 8b 45 dc mov -0x24(%ebp),%eax 10b308: 8b 4d 84 mov -0x7c(%ebp),%ecx 10b30b: 99 cltd 10b30c: f7 f9 idiv %ecx 10b30e: 50 push %eax 10b30f: ff 75 d8 pushl -0x28(%ebp) 10b312: 8b 45 b4 mov -0x4c(%ebp),%eax 10b315: 99 cltd 10b316: f7 f9 idiv %ecx 10b318: 50 push %eax 10b319: ff 75 b0 pushl -0x50(%ebp) 10b31c: 8b 45 ac mov -0x54(%ebp),%eax 10b31f: 99 cltd 10b320: f7 f9 idiv %ecx 10b322: 50 push %eax 10b323: ff 75 a8 pushl -0x58(%ebp) 10b326: 68 d0 17 12 00 push $0x1217d0 10b32b: 53 push %ebx 10b32c: ff d7 call *%edi 10b32e: 83 c4 30 add $0x30,%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++ ) { 10b331: 46 inc %esi /* * 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 ; 10b332: 3b 35 80 83 12 00 cmp 0x128380,%esi 10b338: 0f 86 15 ff ff ff jbe 10b253 the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 10b33e: 8d 65 f4 lea -0xc(%ebp),%esp 10b341: 5b pop %ebx 10b342: 5e pop %esi 10b343: 5f pop %edi 10b344: c9 leave 10b345: c3 ret =============================================================================== 00115c40 : rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) { 115c40: 55 push %ebp 115c41: 89 e5 mov %esp,%ebp 115c43: 53 push %ebx 115c44: 83 ec 14 sub $0x14,%esp 115c47: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; 115c4a: b8 0a 00 00 00 mov $0xa,%eax register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 115c4f: 85 db test %ebx,%ebx 115c51: 74 6d je 115cc0 return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 115c53: 50 push %eax 115c54: 50 push %eax 115c55: 8d 45 f4 lea -0xc(%ebp),%eax 115c58: 50 push %eax 115c59: ff 75 08 pushl 0x8(%ebp) 115c5c: e8 5f 3a 00 00 call 1196c0 <_Thread_Get> switch ( location ) { 115c61: 83 c4 10 add $0x10,%esp 115c64: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 115c68: 75 51 jne 115cbb case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 115c6a: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 115c70: 83 7a 0c 00 cmpl $0x0,0xc(%edx) 115c74: 74 39 je 115caf if ( asr->is_enabled ) { 115c76: 80 7a 08 00 cmpb $0x0,0x8(%edx) 115c7a: 74 22 je 115c9e rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115c7c: 9c pushf 115c7d: fa cli 115c7e: 59 pop %ecx *signal_set |= signals; 115c7f: 09 5a 14 or %ebx,0x14(%edx) _ISR_Enable( _level ); 115c82: 51 push %ecx 115c83: 9d popf _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 115c84: 83 3d 00 f6 13 00 00 cmpl $0x0,0x13f600 115c8b: 74 19 je 115ca6 115c8d: 3b 05 04 f6 13 00 cmp 0x13f604,%eax 115c93: 75 11 jne 115ca6 <== NEVER TAKEN _Thread_Dispatch_necessary = true; 115c95: c6 05 10 f6 13 00 01 movb $0x1,0x13f610 115c9c: eb 08 jmp 115ca6 rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115c9e: 9c pushf 115c9f: fa cli 115ca0: 58 pop %eax *signal_set |= signals; 115ca1: 09 5a 18 or %ebx,0x18(%edx) _ISR_Enable( _level ); 115ca4: 50 push %eax 115ca5: 9d popf } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 115ca6: e8 f3 39 00 00 call 11969e <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115cab: 31 c0 xor %eax,%eax 115cad: eb 11 jmp 115cc0 } _Thread_Enable_dispatch(); 115caf: e8 ea 39 00 00 call 11969e <_Thread_Enable_dispatch> return RTEMS_NOT_DEFINED; 115cb4: b8 0b 00 00 00 mov $0xb,%eax 115cb9: eb 05 jmp 115cc0 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115cbb: b8 04 00 00 00 mov $0x4,%eax } 115cc0: 8b 5d fc mov -0x4(%ebp),%ebx 115cc3: c9 leave 115cc4: c3 ret =============================================================================== 001072f4 : * rtems_stack_checker_Begin_extension */ void rtems_stack_checker_begin_extension( Thread_Control *the_thread ) { 1072f4: 55 push %ebp 1072f5: 89 e5 mov %esp,%ebp 1072f7: 57 push %edi 1072f8: 56 push %esi 1072f9: 8b 45 08 mov 0x8(%ebp),%eax Stack_check_Control *the_pattern; if ( the_thread->Object.id == 0 ) /* skip system tasks */ 1072fc: 83 78 08 00 cmpl $0x0,0x8(%eax) 107300: 74 15 je 107317 <== NEVER TAKEN return; the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack); *the_pattern = Stack_check_Pattern; 107302: 8b b8 bc 00 00 00 mov 0xbc(%eax),%edi 107308: 83 c7 08 add $0x8,%edi 10730b: be 28 72 12 00 mov $0x127228,%esi 107310: b9 04 00 00 00 mov $0x4,%ecx 107315: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } 107317: 5e pop %esi 107318: 5f pop %edi 107319: c9 leave 10731a: c3 ret =============================================================================== 001072cd : */ bool rtems_stack_checker_create_extension( Thread_Control *running __attribute__((unused)), Thread_Control *the_thread ) { 1072cd: 55 push %ebp 1072ce: 89 e5 mov %esp,%ebp 1072d0: 57 push %edi 1072d1: 8b 7d 0c mov 0xc(%ebp),%edi Stack_check_Initialize(); 1072d4: e8 8a ff ff ff call 107263 if (the_thread) 1072d9: 85 ff test %edi,%edi 1072db: 74 12 je 1072ef <== NEVER TAKEN Stack_check_Dope_stack(&the_thread->Start.Initial_stack); 1072dd: 8b 8f b8 00 00 00 mov 0xb8(%edi),%ecx 1072e3: 8b 97 bc 00 00 00 mov 0xbc(%edi),%edx 1072e9: b0 a5 mov $0xa5,%al 1072eb: 89 d7 mov %edx,%edi 1072ed: f3 aa rep stos %al,%es:(%edi) return true; } 1072ef: b0 01 mov $0x1,%al 1072f1: 5f pop %edi 1072f2: c9 leave 1072f3: c3 ret =============================================================================== 00107428 : /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) { 107428: 55 push %ebp 107429: 89 e5 mov %esp,%ebp 10742b: 53 push %ebx 10742c: 83 ec 04 sub $0x4,%esp Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 10742f: a1 1c 79 12 00 mov 0x12791c,%eax ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 107434: 8b 90 bc 00 00 00 mov 0xbc(%eax),%edx return false; 10743a: 31 db xor %ebx,%ebx ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 10743c: 39 d5 cmp %edx,%ebp 10743e: 72 0e jb 10744e <== NEVER TAKEN return false; } if ( sp > (the_stack->area + the_stack->size) ) { 107440: 8b 80 b8 00 00 00 mov 0xb8(%eax),%eax 107446: 8d 04 02 lea (%edx,%eax,1),%eax } /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) 107449: 39 c5 cmp %eax,%ebp 10744b: 0f 96 c3 setbe %bl { Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; bool sp_ok; bool pattern_ok = true; 10744e: b0 01 mov $0x1,%al /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 107450: 83 3d 18 6f 12 00 00 cmpl $0x0,0x126f18 107457: 74 19 je 107472 <== NEVER TAKEN pattern_ok = (!memcmp( 107459: 83 c2 08 add $0x8,%edx 10745c: 51 push %ecx 10745d: 6a 10 push $0x10 10745f: 68 28 72 12 00 push $0x127228 107464: 52 push %edx 107465: e8 4a cb 00 00 call 113fb4 10746a: 83 c4 10 add $0x10,%esp 10746d: 85 c0 test %eax,%eax 10746f: 0f 94 c0 sete %al /* * Let's report as much as we can. */ if ( !sp_ok || !pattern_ok ) { 107472: 84 db test %bl,%bl 107474: 74 04 je 10747a <== NEVER TAKEN 107476: 84 c0 test %al,%al 107478: 75 11 jne 10748b <== ALWAYS TAKEN Stack_check_report_blown_task( _Thread_Executing, pattern_ok ); 10747a: 52 push %edx <== NOT EXECUTED 10747b: 52 push %edx <== NOT EXECUTED 10747c: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10747f: 50 push %eax <== NOT EXECUTED 107480: ff 35 1c 79 12 00 pushl 0x12791c <== NOT EXECUTED 107486: e8 90 fe ff ff call 10731b <== NOT EXECUTED /* * The Stack Pointer and the Pattern Area are OK so return false. */ return false; } 10748b: 31 c0 xor %eax,%eax 10748d: 8b 5d fc mov -0x4(%ebp),%ebx 107490: c9 leave 107491: c3 ret =============================================================================== 001074f7 : void rtems_stack_checker_report_usage( void ) { 1074f7: 55 push %ebp <== NOT EXECUTED 1074f8: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1074fa: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin ); 1074fd: 68 80 8c 10 00 push $0x108c80 <== NOT EXECUTED 107502: 6a 00 push $0x0 <== NOT EXECUTED 107504: e8 89 ff ff ff call 107492 <== NOT EXECUTED 107509: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10750c: c9 leave <== NOT EXECUTED 10750d: c3 ret <== NOT EXECUTED =============================================================================== 00107492 : void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) { 107492: 55 push %ebp <== NOT EXECUTED 107493: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107495: 56 push %esi <== NOT EXECUTED 107496: 53 push %ebx <== NOT EXECUTED 107497: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10749a: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED if ( !print ) 10749d: 85 db test %ebx,%ebx <== NOT EXECUTED 10749f: 74 4f je 1074f0 <== NOT EXECUTED return; print_context = context; 1074a1: 89 35 10 6f 12 00 mov %esi,0x126f10 <== NOT EXECUTED print_handler = print; 1074a7: 89 1d 14 6f 12 00 mov %ebx,0x126f14 <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 1074ad: 51 push %ecx <== NOT EXECUTED 1074ae: 51 push %ecx <== NOT EXECUTED 1074af: 68 73 17 12 00 push $0x121773 <== NOT EXECUTED 1074b4: 56 push %esi <== NOT EXECUTED 1074b5: ff d3 call *%ebx <== NOT EXECUTED (*print)( context, 1074b7: 58 pop %eax <== NOT EXECUTED 1074b8: 5a pop %edx <== NOT EXECUTED 1074b9: 68 8a 17 12 00 push $0x12178a <== NOT EXECUTED 1074be: 56 push %esi <== NOT EXECUTED 1074bf: 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 ); 1074c1: c7 04 24 48 71 10 00 movl $0x107148,(%esp) <== NOT EXECUTED 1074c8: e8 fb 63 00 00 call 10d8c8 <== NOT EXECUTED #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) /* dump interrupt stack info if any */ Stack_check_Dump_threads_usage((Thread_Control *) -1); 1074cd: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED 1074d4: e8 6f fc ff ff call 107148 <== NOT EXECUTED #endif print_context = NULL; 1074d9: c7 05 10 6f 12 00 00 movl $0x0,0x126f10 <== NOT EXECUTED 1074e0: 00 00 00 print_handler = NULL; 1074e3: c7 05 14 6f 12 00 00 movl $0x0,0x126f14 <== NOT EXECUTED 1074ea: 00 00 00 1074ed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1074f0: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1074f3: 5b pop %ebx <== NOT EXECUTED 1074f4: 5e pop %esi <== NOT EXECUTED 1074f5: c9 leave <== NOT EXECUTED 1074f6: c3 ret <== NOT EXECUTED =============================================================================== 001073cf : */ void rtems_stack_checker_switch_extension( Thread_Control *running __attribute__((unused)), Thread_Control *heir __attribute__((unused)) ) { 1073cf: 55 push %ebp 1073d0: 89 e5 mov %esp,%ebp 1073d2: 53 push %ebx 1073d3: 83 ec 14 sub $0x14,%esp 1073d6: 8b 5d 08 mov 0x8(%ebp),%ebx 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); 1073d9: 8b 83 bc 00 00 00 mov 0xbc(%ebx),%eax 1073df: 8d 48 08 lea 0x8(%eax),%ecx { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { return false; 1073e2: 31 d2 xor %edx,%edx ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 1073e4: 39 c5 cmp %eax,%ebp 1073e6: 72 0b jb 1073f3 <== NEVER TAKEN return false; } if ( sp > (the_stack->area + the_stack->size) ) { 1073e8: 03 83 b8 00 00 00 add 0xb8(%ebx),%eax } /* * rtems_stack_checker_switch_extension */ void rtems_stack_checker_switch_extension( 1073ee: 39 c5 cmp %eax,%ebp 1073f0: 0f 96 c2 setbe %dl /* * 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, 1073f3: 50 push %eax 1073f4: 6a 10 push $0x10 1073f6: 68 28 72 12 00 push $0x127228 1073fb: 51 push %ecx 1073fc: 88 55 f4 mov %dl,-0xc(%ebp) 1073ff: e8 b0 cb 00 00 call 113fb4 107404: 83 c4 10 add $0x10,%esp 107407: 85 c0 test %eax,%eax 107409: 0f 94 c0 sete %al (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { 10740c: 8a 55 f4 mov -0xc(%ebp),%dl 10740f: 84 d2 test %dl,%dl 107411: 74 04 je 107417 <== NEVER TAKEN 107413: 84 c0 test %al,%al 107415: 75 0c jne 107423 <== ALWAYS TAKEN Stack_check_report_blown_task( running, pattern_ok ); 107417: 52 push %edx <== NOT EXECUTED 107418: 52 push %edx <== NOT EXECUTED 107419: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10741c: 50 push %eax <== NOT EXECUTED 10741d: 53 push %ebx <== NOT EXECUTED 10741e: e8 f8 fe ff ff call 10731b <== NOT EXECUTED } } 107423: 8b 5d fc mov -0x4(%ebp),%ebx 107426: c9 leave 107427: c3 ret =============================================================================== 0010f070 : rtems_status_code rtems_string_to_double ( const char *s, double *n, char **endptr ) { 10f070: 55 push %ebp 10f071: 89 e5 mov %esp,%ebp 10f073: 57 push %edi 10f074: 56 push %esi 10f075: 53 push %ebx 10f076: 83 ec 2c sub $0x2c,%esp 10f079: 8b 75 08 mov 0x8(%ebp),%esi 10f07c: 8b 5d 0c mov 0xc(%ebp),%ebx 10f07f: 8b 7d 10 mov 0x10(%ebp),%edi double result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f082: ba 09 00 00 00 mov $0x9,%edx ) { double result; char *end; if ( !n ) 10f087: 85 db test %ebx,%ebx 10f089: 0f 84 95 00 00 00 je 10f124 return RTEMS_INVALID_ADDRESS; errno = 0; 10f08f: e8 54 2a 00 00 call 111ae8 <__errno> 10f094: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f09a: c7 03 00 00 00 00 movl $0x0,(%ebx) 10f0a0: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) result = strtod( s, &end ); 10f0a7: 50 push %eax 10f0a8: 50 push %eax 10f0a9: 8d 45 e4 lea -0x1c(%ebp),%eax 10f0ac: 50 push %eax 10f0ad: 56 push %esi 10f0ae: e8 e5 54 00 00 call 114598 if ( endptr ) 10f0b3: 83 c4 10 add $0x10,%esp 10f0b6: 85 ff test %edi,%edi 10f0b8: 74 05 je 10f0bf *endptr = end; 10f0ba: 8b 45 e4 mov -0x1c(%ebp),%eax 10f0bd: 89 07 mov %eax,(%edi) if ( end == s ) return RTEMS_NOT_DEFINED; 10f0bf: ba 0b 00 00 00 mov $0xb,%edx result = strtod( s, &end ); if ( endptr ) *endptr = end; if ( end == s ) 10f0c4: 39 75 e4 cmp %esi,-0x1c(%ebp) 10f0c7: 74 4d je 10f116 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f0c9: dd 5d c8 fstpl -0x38(%ebp) 10f0cc: e8 17 2a 00 00 call 111ae8 <__errno> 10f0d1: 83 38 22 cmpl $0x22,(%eax) 10f0d4: dd 45 c8 fldl -0x38(%ebp) 10f0d7: 75 37 jne 10f110 10f0d9: d9 ee fldz 10f0db: d9 c9 fxch %st(1) 10f0dd: dd e1 fucom %st(1) 10f0df: df e0 fnstsw %ax 10f0e1: dd d9 fstp %st(1) 10f0e3: 9e sahf 10f0e4: 7a 07 jp 10f0ed <== NEVER TAKEN (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL ))) return RTEMS_INVALID_NUMBER; 10f0e6: ba 0a 00 00 00 mov $0xa,%edx *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f0eb: 74 2d je 10f11a <== NEVER TAKEN (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL ))) return RTEMS_INVALID_NUMBER; 10f0ed: ba 0a 00 00 00 mov $0xa,%edx if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL ))) 10f0f2: dd 05 30 3e 12 00 fldl 0x123e30 10f0f8: d9 c9 fxch %st(1) 10f0fa: dd e1 fucom %st(1) 10f0fc: df e0 fnstsw %ax 10f0fe: dd d9 fstp %st(1) 10f100: 9e sahf 10f101: 77 1b ja 10f11e <== ALWAYS TAKEN 10f103: dd 05 38 3e 12 00 fldl 0x123e38 <== NOT EXECUTED 10f109: dd e9 fucomp %st(1) <== NOT EXECUTED 10f10b: df e0 fnstsw %ax <== NOT EXECUTED 10f10d: 9e sahf <== NOT EXECUTED 10f10e: 77 12 ja 10f122 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; *n = result; 10f110: dd 1b fstpl (%ebx) return RTEMS_SUCCESSFUL; 10f112: 31 d2 xor %edx,%edx 10f114: eb 0e jmp 10f124 10f116: dd d8 fstp %st(0) 10f118: eb 0a jmp 10f124 10f11a: dd d8 fstp %st(0) <== NOT EXECUTED 10f11c: eb 06 jmp 10f124 <== NOT EXECUTED 10f11e: dd d8 fstp %st(0) 10f120: eb 02 jmp 10f124 10f122: dd d8 fstp %st(0) <== NOT EXECUTED } 10f124: 89 d0 mov %edx,%eax 10f126: 8d 65 f4 lea -0xc(%ebp),%esp 10f129: 5b pop %ebx 10f12a: 5e pop %esi 10f12b: 5f pop %edi 10f12c: c9 leave 10f12d: c3 ret =============================================================================== 0010f130 : rtems_status_code rtems_string_to_float ( const char *s, float *n, char **endptr ) { 10f130: 55 push %ebp 10f131: 89 e5 mov %esp,%ebp 10f133: 57 push %edi 10f134: 56 push %esi 10f135: 53 push %ebx 10f136: 83 ec 2c sub $0x2c,%esp 10f139: 8b 75 08 mov 0x8(%ebp),%esi 10f13c: 8b 5d 0c mov 0xc(%ebp),%ebx 10f13f: 8b 7d 10 mov 0x10(%ebp),%edi float result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f142: ba 09 00 00 00 mov $0x9,%edx ) { float result; char *end; if ( !n ) 10f147: 85 db test %ebx,%ebx 10f149: 0f 84 8e 00 00 00 je 10f1dd return RTEMS_INVALID_ADDRESS; errno = 0; 10f14f: e8 94 29 00 00 call 111ae8 <__errno> 10f154: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f15a: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtof( s, &end ); 10f160: 50 push %eax 10f161: 50 push %eax 10f162: 8d 45 e4 lea -0x1c(%ebp),%eax 10f165: 50 push %eax 10f166: 56 push %esi 10f167: e8 48 54 00 00 call 1145b4 if ( endptr ) 10f16c: 83 c4 10 add $0x10,%esp 10f16f: 85 ff test %edi,%edi 10f171: 74 05 je 10f178 *endptr = end; 10f173: 8b 45 e4 mov -0x1c(%ebp),%eax 10f176: 89 07 mov %eax,(%edi) if ( end == s ) return RTEMS_NOT_DEFINED; 10f178: ba 0b 00 00 00 mov $0xb,%edx result = strtof( s, &end ); if ( endptr ) *endptr = end; if ( end == s ) 10f17d: 39 75 e4 cmp %esi,-0x1c(%ebp) 10f180: 74 4d je 10f1cf return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f182: d9 5d c8 fstps -0x38(%ebp) 10f185: e8 5e 29 00 00 call 111ae8 <__errno> 10f18a: 83 38 22 cmpl $0x22,(%eax) 10f18d: d9 45 c8 flds -0x38(%ebp) 10f190: 75 37 jne 10f1c9 10f192: d9 ee fldz 10f194: d9 c9 fxch %st(1) 10f196: dd e1 fucom %st(1) 10f198: df e0 fnstsw %ax 10f19a: dd d9 fstp %st(1) 10f19c: 9e sahf 10f19d: 7a 07 jp 10f1a6 <== NEVER TAKEN (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF ))) return RTEMS_INVALID_NUMBER; 10f19f: ba 0a 00 00 00 mov $0xa,%edx *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f1a4: 74 2d je 10f1d3 <== NEVER TAKEN (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF ))) return RTEMS_INVALID_NUMBER; 10f1a6: ba 0a 00 00 00 mov $0xa,%edx if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF ))) 10f1ab: d9 05 40 3e 12 00 flds 0x123e40 10f1b1: d9 c9 fxch %st(1) 10f1b3: dd e1 fucom %st(1) 10f1b5: df e0 fnstsw %ax 10f1b7: dd d9 fstp %st(1) 10f1b9: 9e sahf 10f1ba: 77 1b ja 10f1d7 <== ALWAYS TAKEN 10f1bc: d9 05 44 3e 12 00 flds 0x123e44 <== NOT EXECUTED 10f1c2: dd e9 fucomp %st(1) <== NOT EXECUTED 10f1c4: df e0 fnstsw %ax <== NOT EXECUTED 10f1c6: 9e sahf <== NOT EXECUTED 10f1c7: 77 12 ja 10f1db <== NOT EXECUTED return RTEMS_INVALID_NUMBER; *n = result; 10f1c9: d9 1b fstps (%ebx) return RTEMS_SUCCESSFUL; 10f1cb: 31 d2 xor %edx,%edx 10f1cd: eb 0e jmp 10f1dd 10f1cf: dd d8 fstp %st(0) 10f1d1: eb 0a jmp 10f1dd 10f1d3: dd d8 fstp %st(0) <== NOT EXECUTED 10f1d5: eb 06 jmp 10f1dd <== NOT EXECUTED 10f1d7: dd d8 fstp %st(0) 10f1d9: eb 02 jmp 10f1dd 10f1db: dd d8 fstp %st(0) <== NOT EXECUTED } 10f1dd: 89 d0 mov %edx,%eax 10f1df: 8d 65 f4 lea -0xc(%ebp),%esp 10f1e2: 5b pop %ebx 10f1e3: 5e pop %esi 10f1e4: 5f pop %edi 10f1e5: c9 leave 10f1e6: c3 ret =============================================================================== 0010f1e8 : const char *s, int *n, char **endptr, int base ) { 10f1e8: 55 push %ebp 10f1e9: 89 e5 mov %esp,%ebp 10f1eb: 57 push %edi 10f1ec: 56 push %esi 10f1ed: 53 push %ebx 10f1ee: 83 ec 2c sub $0x2c,%esp 10f1f1: 8b 7d 08 mov 0x8(%ebp),%edi 10f1f4: 8b 75 0c mov 0xc(%ebp),%esi 10f1f7: 8b 55 10 mov 0x10(%ebp),%edx long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f1fa: b8 09 00 00 00 mov $0x9,%eax ) { long result; char *end; if ( !n ) 10f1ff: 85 f6 test %esi,%esi 10f201: 74 6b je 10f26e return RTEMS_INVALID_ADDRESS; errno = 0; 10f203: 89 55 d4 mov %edx,-0x2c(%ebp) 10f206: e8 dd 28 00 00 call 111ae8 <__errno> 10f20b: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f211: c7 06 00 00 00 00 movl $0x0,(%esi) result = strtol( s, &end, base ); 10f217: 50 push %eax 10f218: ff 75 14 pushl 0x14(%ebp) 10f21b: 8d 45 e4 lea -0x1c(%ebp),%eax 10f21e: 50 push %eax 10f21f: 57 push %edi 10f220: e8 4f 55 00 00 call 114774 10f225: 89 c3 mov %eax,%ebx if ( endptr ) 10f227: 83 c4 10 add $0x10,%esp 10f22a: 8b 55 d4 mov -0x2c(%ebp),%edx 10f22d: 85 d2 test %edx,%edx 10f22f: 74 05 je 10f236 *endptr = end; 10f231: 8b 45 e4 mov -0x1c(%ebp),%eax 10f234: 89 02 mov %eax,(%edx) if ( end == s ) return RTEMS_NOT_DEFINED; 10f236: b8 0b 00 00 00 mov $0xb,%eax result = strtol( s, &end, base ); if ( endptr ) *endptr = end; if ( end == s ) 10f23b: 39 7d e4 cmp %edi,-0x1c(%ebp) 10f23e: 74 2e je 10f26e return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f240: e8 a3 28 00 00 call 111ae8 <__errno> 10f245: 83 38 22 cmpl $0x22,(%eax) 10f248: 75 19 jne 10f263 10f24a: 81 fb ff ff ff 7f cmp $0x7fffffff,%ebx 10f250: 74 17 je 10f269 <== ALWAYS TAKEN 10f252: 85 db test %ebx,%ebx <== NOT EXECUTED 10f254: 74 13 je 10f269 <== NOT EXECUTED (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) return RTEMS_INVALID_NUMBER; 10f256: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) 10f25b: 81 fb 00 00 00 80 cmp $0x80000000,%ebx <== NOT EXECUTED 10f261: 74 0b je 10f26e <== NOT EXECUTED errno = ERANGE; return RTEMS_INVALID_NUMBER; } #endif *n = result; 10f263: 89 1e mov %ebx,(%esi) return RTEMS_SUCCESSFUL; 10f265: 31 c0 xor %eax,%eax 10f267: eb 05 jmp 10f26e if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) return RTEMS_INVALID_NUMBER; 10f269: b8 0a 00 00 00 mov $0xa,%eax #endif *n = result; return RTEMS_SUCCESSFUL; } 10f26e: 8d 65 f4 lea -0xc(%ebp),%esp 10f271: 5b pop %ebx 10f272: 5e pop %esi 10f273: 5f pop %edi 10f274: c9 leave 10f275: c3 ret =============================================================================== 0010f324 : const char *s, long *n, char **endptr, int base ) { 10f324: 55 push %ebp 10f325: 89 e5 mov %esp,%ebp 10f327: 57 push %edi 10f328: 56 push %esi 10f329: 53 push %ebx 10f32a: 83 ec 2c sub $0x2c,%esp 10f32d: 8b 7d 08 mov 0x8(%ebp),%edi 10f330: 8b 75 0c mov 0xc(%ebp),%esi 10f333: 8b 55 10 mov 0x10(%ebp),%edx long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f336: b8 09 00 00 00 mov $0x9,%eax ) { long result; char *end; if ( !n ) 10f33b: 85 f6 test %esi,%esi 10f33d: 74 6b je 10f3aa return RTEMS_INVALID_ADDRESS; errno = 0; 10f33f: 89 55 d4 mov %edx,-0x2c(%ebp) 10f342: e8 a1 27 00 00 call 111ae8 <__errno> 10f347: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f34d: c7 06 00 00 00 00 movl $0x0,(%esi) result = strtol( s, &end, base ); 10f353: 50 push %eax 10f354: ff 75 14 pushl 0x14(%ebp) 10f357: 8d 45 e4 lea -0x1c(%ebp),%eax 10f35a: 50 push %eax 10f35b: 57 push %edi 10f35c: e8 13 54 00 00 call 114774 10f361: 89 c3 mov %eax,%ebx if ( endptr ) 10f363: 83 c4 10 add $0x10,%esp 10f366: 8b 55 d4 mov -0x2c(%ebp),%edx 10f369: 85 d2 test %edx,%edx 10f36b: 74 05 je 10f372 *endptr = end; 10f36d: 8b 45 e4 mov -0x1c(%ebp),%eax 10f370: 89 02 mov %eax,(%edx) if ( end == s ) return RTEMS_NOT_DEFINED; 10f372: b8 0b 00 00 00 mov $0xb,%eax result = strtol( s, &end, base ); if ( endptr ) *endptr = end; if ( end == s ) 10f377: 39 7d e4 cmp %edi,-0x1c(%ebp) 10f37a: 74 2e je 10f3aa return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f37c: e8 67 27 00 00 call 111ae8 <__errno> 10f381: 83 38 22 cmpl $0x22,(%eax) 10f384: 75 19 jne 10f39f 10f386: 81 fb ff ff ff 7f cmp $0x7fffffff,%ebx 10f38c: 74 17 je 10f3a5 10f38e: 85 db test %ebx,%ebx 10f390: 74 13 je 10f3a5 <== NEVER TAKEN (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) return RTEMS_INVALID_NUMBER; 10f392: b8 0a 00 00 00 mov $0xa,%eax if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) 10f397: 81 fb 00 00 00 80 cmp $0x80000000,%ebx 10f39d: 74 0b je 10f3aa <== ALWAYS TAKEN return RTEMS_INVALID_NUMBER; *n = result; 10f39f: 89 1e mov %ebx,(%esi) return RTEMS_SUCCESSFUL; 10f3a1: 31 c0 xor %eax,%eax 10f3a3: eb 05 jmp 10f3aa if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN ))) return RTEMS_INVALID_NUMBER; 10f3a5: b8 0a 00 00 00 mov $0xa,%eax *n = result; return RTEMS_SUCCESSFUL; } 10f3aa: 8d 65 f4 lea -0xc(%ebp),%esp 10f3ad: 5b pop %ebx 10f3ae: 5e pop %esi 10f3af: 5f pop %edi 10f3b0: c9 leave 10f3b1: c3 ret =============================================================================== 0010f278 : const char *s, long long *n, char **endptr, int base ) { 10f278: 55 push %ebp 10f279: 89 e5 mov %esp,%ebp 10f27b: 57 push %edi 10f27c: 56 push %esi 10f27d: 53 push %ebx 10f27e: 83 ec 2c sub $0x2c,%esp 10f281: 8b 5d 0c mov 0xc(%ebp),%ebx 10f284: 8b 7d 10 mov 0x10(%ebp),%edi long long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f287: b8 09 00 00 00 mov $0x9,%eax ) { long long result; char *end; if ( !n ) 10f28c: 85 db test %ebx,%ebx 10f28e: 0f 84 85 00 00 00 je 10f319 return RTEMS_INVALID_ADDRESS; errno = 0; 10f294: e8 4f 28 00 00 call 111ae8 <__errno> 10f299: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f29f: c7 03 00 00 00 00 movl $0x0,(%ebx) 10f2a5: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) result = strtoll( s, &end, base ); 10f2ac: 50 push %eax 10f2ad: ff 75 14 pushl 0x14(%ebp) 10f2b0: 8d 45 e4 lea -0x1c(%ebp),%eax 10f2b3: 50 push %eax 10f2b4: ff 75 08 pushl 0x8(%ebp) 10f2b7: e8 d4 54 00 00 call 114790 10f2bc: 89 c6 mov %eax,%esi if ( endptr ) 10f2be: 83 c4 10 add $0x10,%esp 10f2c1: 85 ff test %edi,%edi 10f2c3: 74 05 je 10f2ca *endptr = end; 10f2c5: 8b 45 e4 mov -0x1c(%ebp),%eax 10f2c8: 89 07 mov %eax,(%edi) if ( end == s ) return RTEMS_NOT_DEFINED; 10f2ca: b8 0b 00 00 00 mov $0xb,%eax result = strtoll( s, &end, base ); if ( endptr ) *endptr = end; if ( end == s ) 10f2cf: 8b 4d 08 mov 0x8(%ebp),%ecx 10f2d2: 39 4d e4 cmp %ecx,-0x1c(%ebp) 10f2d5: 74 42 je 10f319 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f2d7: 89 55 d4 mov %edx,-0x2c(%ebp) 10f2da: e8 09 28 00 00 call 111ae8 <__errno> 10f2df: 83 38 22 cmpl $0x22,(%eax) 10f2e2: 8b 55 d4 mov -0x2c(%ebp),%edx 10f2e5: 75 24 jne 10f30b (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN ))) 10f2e7: 89 f1 mov %esi,%ecx 10f2e9: f7 d1 not %ecx 10f2eb: 89 d0 mov %edx,%eax 10f2ed: 35 ff ff ff 7f xor $0x7fffffff,%eax *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f2f2: 09 c1 or %eax,%ecx 10f2f4: 74 1e je 10f314 10f2f6: 89 f0 mov %esi,%eax 10f2f8: 09 d0 or %edx,%eax 10f2fa: 74 18 je 10f314 <== NEVER TAKEN (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN ))) 10f2fc: 8d 8a 00 00 00 80 lea -0x80000000(%edx),%ecx return RTEMS_INVALID_NUMBER; 10f302: b8 0a 00 00 00 mov $0xa,%eax if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN ))) 10f307: 09 f1 or %esi,%ecx 10f309: 74 0e je 10f319 <== ALWAYS TAKEN return RTEMS_INVALID_NUMBER; *n = result; 10f30b: 89 33 mov %esi,(%ebx) 10f30d: 89 53 04 mov %edx,0x4(%ebx) return RTEMS_SUCCESSFUL; 10f310: 31 c0 xor %eax,%eax 10f312: eb 05 jmp 10f319 if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && (( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN ))) return RTEMS_INVALID_NUMBER; 10f314: b8 0a 00 00 00 mov $0xa,%eax *n = result; return RTEMS_SUCCESSFUL; } 10f319: 8d 65 f4 lea -0xc(%ebp),%esp 10f31c: 5b pop %ebx 10f31d: 5e pop %esi 10f31e: 5f pop %edi 10f31f: c9 leave 10f320: c3 ret =============================================================================== 0010f3cc : const char *s, unsigned char *n, char **endptr, int base ) { 10f3cc: 55 push %ebp 10f3cd: 89 e5 mov %esp,%ebp 10f3cf: 57 push %edi 10f3d0: 56 push %esi 10f3d1: 53 push %ebx 10f3d2: 83 ec 2c sub $0x2c,%esp 10f3d5: 8b 7d 08 mov 0x8(%ebp),%edi 10f3d8: 8b 5d 0c mov 0xc(%ebp),%ebx 10f3db: 8b 55 10 mov 0x10(%ebp),%edx unsigned long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f3de: b8 09 00 00 00 mov $0x9,%eax ) { unsigned long result; char *end; if ( !n ) 10f3e3: 85 db test %ebx,%ebx 10f3e5: 74 71 je 10f458 return RTEMS_INVALID_ADDRESS; errno = 0; 10f3e7: 89 55 d4 mov %edx,-0x2c(%ebp) 10f3ea: e8 f9 26 00 00 call 111ae8 <__errno> 10f3ef: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f3f5: c6 03 00 movb $0x0,(%ebx) result = strtoul( s, &end, base ); 10f3f8: 50 push %eax 10f3f9: ff 75 14 pushl 0x14(%ebp) 10f3fc: 8d 45 e4 lea -0x1c(%ebp),%eax 10f3ff: 50 push %eax 10f400: 57 push %edi 10f401: e8 2a 58 00 00 call 114c30 10f406: 89 c6 mov %eax,%esi if ( endptr ) 10f408: 83 c4 10 add $0x10,%esp 10f40b: 8b 55 d4 mov -0x2c(%ebp),%edx 10f40e: 85 d2 test %edx,%edx 10f410: 74 05 je 10f417 *endptr = end; 10f412: 8b 45 e4 mov -0x1c(%ebp),%eax 10f415: 89 02 mov %eax,(%edx) if ( end == s ) return RTEMS_NOT_DEFINED; 10f417: b8 0b 00 00 00 mov $0xb,%eax result = strtoul( s, &end, base ); if ( endptr ) *endptr = end; if ( end == s ) 10f41c: 39 7d e4 cmp %edi,-0x1c(%ebp) 10f41f: 74 37 je 10f458 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f421: e8 c2 26 00 00 call 111ae8 <__errno> 10f426: 83 38 22 cmpl $0x22,(%eax) 10f429: 75 0d jne 10f438 <== ALWAYS TAKEN (( result == 0 ) || ( result == ULONG_MAX ))) 10f42b: 8d 56 ff lea -0x1(%esi),%edx <== NOT EXECUTED return RTEMS_INVALID_NUMBER; 10f42e: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f433: 83 fa fd cmp $0xfffffffd,%edx <== NOT EXECUTED 10f436: 77 20 ja 10f458 <== NOT EXECUTED (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; #if (UCHAR_MAX < ULONG_MAX) if ( result > UCHAR_MAX ) { 10f438: 81 fe ff 00 00 00 cmp $0xff,%esi 10f43e: 76 12 jbe 10f452 <== ALWAYS TAKEN errno = ERANGE; 10f440: e8 a3 26 00 00 call 111ae8 <__errno> <== NOT EXECUTED 10f445: c7 00 22 00 00 00 movl $0x22,(%eax) <== NOT EXECUTED return RTEMS_INVALID_NUMBER; 10f44b: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10f450: eb 06 jmp 10f458 <== NOT EXECUTED } #endif *n = result; 10f452: 89 f0 mov %esi,%eax 10f454: 88 03 mov %al,(%ebx) return RTEMS_SUCCESSFUL; 10f456: 31 c0 xor %eax,%eax } 10f458: 8d 65 f4 lea -0xc(%ebp),%esp 10f45b: 5b pop %ebx 10f45c: 5e pop %esi 10f45d: 5f pop %edi 10f45e: c9 leave 10f45f: c3 ret =============================================================================== 0010f460 : const char *s, unsigned int *n, char **endptr, int base ) { 10f460: 55 push %ebp 10f461: 89 e5 mov %esp,%ebp 10f463: 57 push %edi 10f464: 56 push %esi 10f465: 53 push %ebx 10f466: 83 ec 2c sub $0x2c,%esp 10f469: 8b 7d 08 mov 0x8(%ebp),%edi 10f46c: 8b 5d 0c mov 0xc(%ebp),%ebx 10f46f: 8b 55 10 mov 0x10(%ebp),%edx unsigned long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f472: b8 09 00 00 00 mov $0x9,%eax ) { unsigned long result; char *end; if ( !n ) 10f477: 85 db test %ebx,%ebx 10f479: 74 58 je 10f4d3 return RTEMS_INVALID_ADDRESS; errno = 0; 10f47b: 89 55 d4 mov %edx,-0x2c(%ebp) 10f47e: e8 65 26 00 00 call 111ae8 <__errno> 10f483: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f489: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtoul( s, &end, base ); 10f48f: 50 push %eax 10f490: ff 75 14 pushl 0x14(%ebp) 10f493: 8d 45 e4 lea -0x1c(%ebp),%eax 10f496: 50 push %eax 10f497: 57 push %edi 10f498: e8 93 57 00 00 call 114c30 10f49d: 89 c6 mov %eax,%esi if ( endptr ) 10f49f: 83 c4 10 add $0x10,%esp 10f4a2: 8b 55 d4 mov -0x2c(%ebp),%edx 10f4a5: 85 d2 test %edx,%edx 10f4a7: 74 05 je 10f4ae *endptr = end; 10f4a9: 8b 45 e4 mov -0x1c(%ebp),%eax 10f4ac: 89 02 mov %eax,(%edx) if ( end == s ) return RTEMS_NOT_DEFINED; 10f4ae: b8 0b 00 00 00 mov $0xb,%eax result = strtoul( s, &end, base ); if ( endptr ) *endptr = end; if ( end == s ) 10f4b3: 39 7d e4 cmp %edi,-0x1c(%ebp) 10f4b6: 74 1b je 10f4d3 return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f4b8: e8 2b 26 00 00 call 111ae8 <__errno> 10f4bd: 83 38 22 cmpl $0x22,(%eax) 10f4c0: 75 0d jne 10f4cf (( result == 0 ) || ( result == ULONG_MAX ))) 10f4c2: 8d 56 ff lea -0x1(%esi),%edx return RTEMS_INVALID_NUMBER; 10f4c5: b8 0a 00 00 00 mov $0xa,%eax *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f4ca: 83 fa fd cmp $0xfffffffd,%edx 10f4cd: 77 04 ja 10f4d3 <== ALWAYS TAKEN errno = ERANGE; return RTEMS_INVALID_NUMBER; } #endif *n = result; 10f4cf: 89 33 mov %esi,(%ebx) return RTEMS_SUCCESSFUL; 10f4d1: 31 c0 xor %eax,%eax } 10f4d3: 8d 65 f4 lea -0xc(%ebp),%esp 10f4d6: 5b pop %ebx 10f4d7: 5e pop %esi 10f4d8: 5f pop %edi 10f4d9: c9 leave 10f4da: c3 ret =============================================================================== 0010f578 : const char *s, unsigned long *n, char **endptr, int base ) { 10f578: 55 push %ebp 10f579: 89 e5 mov %esp,%ebp 10f57b: 57 push %edi 10f57c: 56 push %esi 10f57d: 53 push %ebx 10f57e: 83 ec 2c sub $0x2c,%esp 10f581: 8b 7d 08 mov 0x8(%ebp),%edi 10f584: 8b 5d 0c mov 0xc(%ebp),%ebx 10f587: 8b 55 10 mov 0x10(%ebp),%edx unsigned long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f58a: b8 09 00 00 00 mov $0x9,%eax ) { unsigned long result; char *end; if ( !n ) 10f58f: 85 db test %ebx,%ebx 10f591: 74 58 je 10f5eb return RTEMS_INVALID_ADDRESS; errno = 0; 10f593: 89 55 d4 mov %edx,-0x2c(%ebp) 10f596: e8 4d 25 00 00 call 111ae8 <__errno> 10f59b: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f5a1: c7 03 00 00 00 00 movl $0x0,(%ebx) result = strtoul( s, &end, base ); 10f5a7: 50 push %eax 10f5a8: ff 75 14 pushl 0x14(%ebp) 10f5ab: 8d 45 e4 lea -0x1c(%ebp),%eax 10f5ae: 50 push %eax 10f5af: 57 push %edi 10f5b0: e8 7b 56 00 00 call 114c30 10f5b5: 89 c6 mov %eax,%esi if ( endptr ) 10f5b7: 83 c4 10 add $0x10,%esp 10f5ba: 8b 55 d4 mov -0x2c(%ebp),%edx 10f5bd: 85 d2 test %edx,%edx 10f5bf: 74 05 je 10f5c6 *endptr = end; 10f5c1: 8b 45 e4 mov -0x1c(%ebp),%eax 10f5c4: 89 02 mov %eax,(%edx) if ( end == s ) return RTEMS_NOT_DEFINED; 10f5c6: b8 0b 00 00 00 mov $0xb,%eax result = strtoul( s, &end, base ); if ( endptr ) *endptr = end; if ( end == s ) 10f5cb: 39 7d e4 cmp %edi,-0x1c(%ebp) 10f5ce: 74 1b je 10f5eb return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f5d0: e8 13 25 00 00 call 111ae8 <__errno> 10f5d5: 83 38 22 cmpl $0x22,(%eax) 10f5d8: 75 0d jne 10f5e7 (( result == 0 ) || ( result == ULONG_MAX ))) 10f5da: 8d 56 ff lea -0x1(%esi),%edx return RTEMS_INVALID_NUMBER; 10f5dd: b8 0a 00 00 00 mov $0xa,%eax *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f5e2: 83 fa fd cmp $0xfffffffd,%edx 10f5e5: 77 04 ja 10f5eb <== ALWAYS TAKEN (( result == 0 ) || ( result == ULONG_MAX ))) return RTEMS_INVALID_NUMBER; *n = result; 10f5e7: 89 33 mov %esi,(%ebx) return RTEMS_SUCCESSFUL; 10f5e9: 31 c0 xor %eax,%eax } 10f5eb: 8d 65 f4 lea -0xc(%ebp),%esp 10f5ee: 5b pop %ebx 10f5ef: 5e pop %esi 10f5f0: 5f pop %edi 10f5f1: c9 leave 10f5f2: c3 ret =============================================================================== 0010f4dc : const char *s, unsigned long long *n, char **endptr, int base ) { 10f4dc: 55 push %ebp 10f4dd: 89 e5 mov %esp,%ebp 10f4df: 57 push %edi 10f4e0: 56 push %esi 10f4e1: 53 push %ebx 10f4e2: 83 ec 2c sub $0x2c,%esp 10f4e5: 8b 7d 08 mov 0x8(%ebp),%edi 10f4e8: 8b 5d 0c mov 0xc(%ebp),%ebx 10f4eb: 8b 75 10 mov 0x10(%ebp),%esi unsigned long long result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f4ee: b8 09 00 00 00 mov $0x9,%eax ) { unsigned long long result; char *end; if ( !n ) 10f4f3: 85 db test %ebx,%ebx 10f4f5: 74 76 je 10f56d return RTEMS_INVALID_ADDRESS; errno = 0; 10f4f7: e8 ec 25 00 00 call 111ae8 <__errno> 10f4fc: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f502: c7 03 00 00 00 00 movl $0x0,(%ebx) 10f508: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) result = strtoull( s, &end, base ); 10f50f: 50 push %eax 10f510: ff 75 14 pushl 0x14(%ebp) 10f513: 8d 45 e4 lea -0x1c(%ebp),%eax 10f516: 50 push %eax 10f517: 57 push %edi 10f518: e8 2f 57 00 00 call 114c4c 10f51d: 89 d1 mov %edx,%ecx 10f51f: 89 c2 mov %eax,%edx if ( endptr ) 10f521: 83 c4 10 add $0x10,%esp 10f524: 85 f6 test %esi,%esi 10f526: 74 05 je 10f52d *endptr = end; 10f528: 8b 45 e4 mov -0x1c(%ebp),%eax 10f52b: 89 06 mov %eax,(%esi) if ( end == s ) return RTEMS_NOT_DEFINED; 10f52d: b8 0b 00 00 00 mov $0xb,%eax result = strtoull( s, &end, base ); if ( endptr ) *endptr = end; if ( end == s ) 10f532: 39 7d e4 cmp %edi,-0x1c(%ebp) 10f535: 74 36 je 10f56d return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f537: 89 55 d4 mov %edx,-0x2c(%ebp) 10f53a: 89 4d d0 mov %ecx,-0x30(%ebp) 10f53d: e8 a6 25 00 00 call 111ae8 <__errno> 10f542: 83 38 22 cmpl $0x22,(%eax) 10f545: 8b 55 d4 mov -0x2c(%ebp),%edx 10f548: 8b 4d d0 mov -0x30(%ebp),%ecx 10f54b: 75 19 jne 10f566 (( result == 0 ) || ( result == ULONG_LONG_MAX ))) 10f54d: 89 d6 mov %edx,%esi 10f54f: 89 cf mov %ecx,%edi 10f551: 83 c6 ff add $0xffffffff,%esi 10f554: 83 d7 ff adc $0xffffffff,%edi *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f557: 83 ff ff cmp $0xffffffff,%edi 10f55a: 72 0a jb 10f566 <== NEVER TAKEN (( result == 0 ) || ( result == ULONG_LONG_MAX ))) return RTEMS_INVALID_NUMBER; 10f55c: b8 0a 00 00 00 mov $0xa,%eax *endptr = end; if ( end == s ) return RTEMS_NOT_DEFINED; if ( ( errno == ERANGE ) && 10f561: 83 fe fd cmp $0xfffffffd,%esi 10f564: 77 07 ja 10f56d <== ALWAYS TAKEN (( result == 0 ) || ( result == ULONG_LONG_MAX ))) return RTEMS_INVALID_NUMBER; *n = result; 10f566: 89 13 mov %edx,(%ebx) 10f568: 89 4b 04 mov %ecx,0x4(%ebx) return RTEMS_SUCCESSFUL; 10f56b: 31 c0 xor %eax,%eax } 10f56d: 8d 65 f4 lea -0xc(%ebp),%esp 10f570: 5b pop %ebx 10f571: 5e pop %esi 10f572: 5f pop %edi 10f573: c9 leave 10f574: c3 ret =============================================================================== 001070ac : int rtems_tarfs_load( char *mountpoint, uint8_t *tar_image, size_t tar_size ) { 1070ac: 55 push %ebp 1070ad: 89 e5 mov %esp,%ebp 1070af: 57 push %edi 1070b0: 56 push %esi 1070b1: 53 push %ebx 1070b2: 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( 1070b8: 31 c0 xor %eax,%eax 1070ba: 83 c9 ff or $0xffffffff,%ecx 1070bd: 8b 7d 08 mov 0x8(%ebp),%edi 1070c0: f2 ae repnz scas %es:(%edi),%al 1070c2: f7 d1 not %ecx 1070c4: 49 dec %ecx 1070c5: 6a 00 push $0x0 1070c7: 8d 45 d0 lea -0x30(%ebp),%eax 1070ca: 50 push %eax 1070cb: 6a 00 push $0x0 1070cd: 51 push %ecx 1070ce: ff 75 08 pushl 0x8(%ebp) 1070d1: e8 d4 09 00 00 call 107aaa 1070d6: 89 85 54 fe ff ff mov %eax,-0x1ac(%ebp) strlen(mountpoint), 0, &root_loc, 0 ); if (status != 0) 1070dc: 83 c4 20 add $0x20,%esp 1070df: 85 c0 test %eax,%eax 1070e1: 0f 85 d9 01 00 00 jne 1072c0 return -1; if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops) 1070e7: 8b 45 dc mov -0x24(%ebp),%eax 1070ea: 31 f6 xor %esi,%esi 1070ec: 3d b0 45 12 00 cmp $0x1245b0,%eax 1070f1: 74 1b je 10710e 1070f3: 3d 98 4f 12 00 cmp $0x124f98,%eax 1070f8: 0f 85 c2 01 00 00 jne 1072c0 <== ALWAYS TAKEN 1070fe: 8b b5 54 fe ff ff mov -0x1ac(%ebp),%esi <== NOT EXECUTED 107104: eb 08 jmp 10710e <== NOT EXECUTED 107106: 8b b5 50 fe ff ff mov -0x1b0(%ebp),%esi 10710c: eb 18 jmp 107126 * should not have this path. */ else if (linkflag == REGTYPE) { const char *name; loc = root_loc; 10710e: 8d 45 bc lea -0x44(%ebp),%eax 107111: 89 85 34 fe ff ff mov %eax,-0x1cc(%ebp) 107117: 8d 55 d0 lea -0x30(%ebp),%edx 10711a: 89 95 30 fe ff ff mov %edx,-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); 107120: 8d 9d 58 fe ff ff lea -0x1a8(%ebp),%ebx /* * Create an IMFS node structure pointing to tar image memory. */ offset = 0; while (1) { if (offset + 512 > tar_size) 107126: 8d 86 00 02 00 00 lea 0x200(%esi),%eax 10712c: 89 85 50 fe ff ff mov %eax,-0x1b0(%ebp) 107132: 8b 55 10 mov 0x10(%ebp),%edx 107135: 39 d0 cmp %edx,%eax 107137: 0f 87 8d 01 00 00 ja 1072ca <== NEVER TAKEN break; /* * Read a header. */ hdr_ptr = (char *) &tar_image[offset]; 10713d: 03 75 0c add 0xc(%ebp),%esi offset += 512; if (strncmp(&hdr_ptr[257], "ustar", 5)) 107140: 8d 86 01 01 00 00 lea 0x101(%esi),%eax 107146: 52 push %edx 107147: 6a 05 push $0x5 107149: 68 f8 45 12 00 push $0x1245f8 10714e: 50 push %eax 10714f: e8 a8 e5 00 00 call 1156fc 107154: 83 c4 10 add $0x10,%esp 107157: 85 c0 test %eax,%eax 107159: 0f 85 6b 01 00 00 jne 1072ca break; strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE); 10715f: 50 push %eax 107160: 6a 63 push $0x63 107162: 56 push %esi 107163: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax 107169: 50 push %eax 10716a: e8 1d e6 00 00 call 11578c filename[MAX_NAME_FIELD_SIZE] = '\0'; 10716f: c6 45 bb 00 movb $0x0,-0x45(%ebp) linkflag = hdr_ptr[156]; 107173: 8a 96 9c 00 00 00 mov 0x9c(%esi),%dl file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8); 107179: 59 pop %ecx 10717a: 5f pop %edi 10717b: 6a 08 push $0x8 10717d: 8d 46 64 lea 0x64(%esi),%eax 107180: 50 push %eax 107181: 88 95 44 fe ff ff mov %dl,-0x1bc(%ebp) 107187: e8 b4 6e 00 00 call 10e040 <_rtems_octal2ulong> 10718c: 89 85 48 fe ff ff mov %eax,-0x1b8(%ebp) file_size = _rtems_octal2ulong(&hdr_ptr[124], 12); 107192: 5f pop %edi 107193: 58 pop %eax 107194: 6a 0c push $0xc 107196: 8d 46 7c lea 0x7c(%esi),%eax 107199: 50 push %eax 10719a: e8 a1 6e 00 00 call 10e040 <_rtems_octal2ulong> 10719f: 89 85 4c fe ff ff mov %eax,-0x1b4(%ebp) hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8); 1071a5: 5a pop %edx 1071a6: 59 pop %ecx 1071a7: 6a 08 push $0x8 1071a9: 8d 86 94 00 00 00 lea 0x94(%esi),%eax 1071af: 50 push %eax 1071b0: e8 8b 6e 00 00 call 10e040 <_rtems_octal2ulong> 1071b5: 89 c7 mov %eax,%edi if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum) 1071b7: 89 34 24 mov %esi,(%esp) 1071ba: e8 af 6e 00 00 call 10e06e <_rtems_tar_header_checksum> 1071bf: 83 c4 10 add $0x10,%esp 1071c2: 39 f8 cmp %edi,%eax 1071c4: 8a 95 44 fe ff ff mov -0x1bc(%ebp),%dl 1071ca: 0f 85 fa 00 00 00 jne 1072ca <== 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) { 1071d0: 80 fa 35 cmp $0x35,%dl 1071d3: 75 57 jne 10722c strcpy(full_filename, mountpoint); 1071d5: 50 push %eax 1071d6: 50 push %eax 1071d7: ff 75 08 pushl 0x8(%ebp) 1071da: 53 push %ebx 1071db: e8 b4 e1 00 00 call 115394 if (full_filename[strlen(full_filename)-1] != '/') 1071e0: 31 c0 xor %eax,%eax 1071e2: 83 c9 ff or $0xffffffff,%ecx 1071e5: 89 df mov %ebx,%edi 1071e7: f2 ae repnz scas %es:(%edi),%al 1071e9: f7 d1 not %ecx 1071eb: 83 c4 10 add $0x10,%esp 1071ee: 80 bc 0d 56 fe ff ff cmpb $0x2f,-0x1aa(%ebp,%ecx,1) 1071f5: 2f 1071f6: 74 10 je 107208 <== ALWAYS TAKEN strcat(full_filename, "/"); 1071f8: 57 push %edi <== NOT EXECUTED 1071f9: 57 push %edi <== NOT EXECUTED 1071fa: 68 59 04 12 00 push $0x120459 <== NOT EXECUTED 1071ff: 53 push %ebx <== NOT EXECUTED 107200: e8 db df 00 00 call 1151e0 <== NOT EXECUTED 107205: 83 c4 10 add $0x10,%esp <== NOT EXECUTED strcat(full_filename, filename); 107208: 56 push %esi 107209: 56 push %esi 10720a: 8d 95 58 ff ff ff lea -0xa8(%ebp),%edx 107210: 52 push %edx 107211: 53 push %ebx 107212: e8 c9 df 00 00 call 1151e0 mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO); 107217: 5a pop %edx 107218: 59 pop %ecx 107219: 68 ff 01 00 00 push $0x1ff 10721e: 53 push %ebx 10721f: e8 58 0f 00 00 call 10817c 107224: 83 c4 10 add $0x10,%esp 107227: e9 da fe ff ff jmp 107106 * 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) { 10722c: 80 fa 30 cmp $0x30,%dl 10722f: 0f 85 d1 fe ff ff jne 107106 const char *name; loc = root_loc; 107235: b9 05 00 00 00 mov $0x5,%ecx 10723a: 8b bd 34 fe ff ff mov -0x1cc(%ebp),%edi 107240: 8b b5 30 fe ff ff mov -0x1d0(%ebp),%esi 107246: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) { 107248: 50 push %eax 107249: 8d 45 e4 lea -0x1c(%ebp),%eax 10724c: 50 push %eax 10724d: 8d 55 bc lea -0x44(%ebp),%edx 107250: 52 push %edx 107251: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax 107257: 50 push %eax 107258: e8 0f 79 00 00 call 10eb6c 10725d: 83 c4 10 add $0x10,%esp 107260: 85 c0 test %eax,%eax 107262: 75 41 jne 1072a5 <== NEVER TAKEN node = IMFS_create_node( 107264: 83 ec 0c sub $0xc,%esp 107267: 6a 00 push $0x0 &loc, IMFS_LINEAR_FILE, (char *)name, (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG, 107269: 8b 85 48 fe ff ff mov -0x1b8(%ebp),%eax 10726f: 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( 107274: 80 cc 80 or $0x80,%ah 107277: 50 push %eax 107278: ff 75 e4 pushl -0x1c(%ebp) 10727b: 6a 06 push $0x6 10727d: 8d 55 bc lea -0x44(%ebp),%edx 107280: 52 push %edx 107281: e8 d9 73 00 00 call 10e65f &loc, IMFS_LINEAR_FILE, (char *)name, (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG, NULL ); node->info.linearfile.size = file_size; 107286: 8b 95 4c fe ff ff mov -0x1b4(%ebp),%edx 10728c: 89 50 50 mov %edx,0x50(%eax) 10728f: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.linearfile.direct = &tar_image[offset]; 107296: 8b 55 0c mov 0xc(%ebp),%edx 107299: 03 95 50 fe ff ff add -0x1b0(%ebp),%edx 10729f: 89 50 58 mov %edx,0x58(%eax) 1072a2: 83 c4 20 add $0x20,%esp } nblocks = (((file_size) + 511) & ~511) / 512; 1072a5: 8b 85 4c fe ff ff mov -0x1b4(%ebp),%eax 1072ab: 05 ff 01 00 00 add $0x1ff,%eax offset += 512 * nblocks; 1072b0: 25 00 fe ff ff and $0xfffffe00,%eax 1072b5: 01 85 50 fe ff ff add %eax,-0x1b0(%ebp) 1072bb: e9 46 fe ff ff jmp 107106 ); if (status != 0) return -1; if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops) return -1; 1072c0: c7 85 54 fe ff ff ff movl $0xffffffff,-0x1ac(%ebp) 1072c7: ff ff ff nblocks = (((file_size) + 511) & ~511) / 512; offset += 512 * nblocks; } } return status; } 1072ca: 8b 85 54 fe ff ff mov -0x1ac(%ebp),%eax 1072d0: 8d 65 f4 lea -0xc(%ebp),%esp 1072d3: 5b pop %ebx 1072d4: 5e pop %esi 1072d5: 5f pop %edi 1072d6: c9 leave 1072d7: c3 ret =============================================================================== 00110d68 : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 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 110d71: 8b 4d 10 mov 0x10(%ebp),%ecx bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) return RTEMS_INVALID_ADDRESS; 110d74: b8 09 00 00 00 mov $0x9,%eax ASR_Information *asr; bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) 110d79: 85 c9 test %ecx,%ecx 110d7b: 0f 84 fb 00 00 00 je 110e7c return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 110d81: 8b 35 68 58 12 00 mov 0x125868,%esi api = executing->API_Extensions[ THREAD_API_RTEMS ]; 110d87: 8b 9e e8 00 00 00 mov 0xe8(%esi),%ebx asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 110d8d: 80 7e 74 01 cmpb $0x1,0x74(%esi) 110d91: 19 ff sbb %edi,%edi 110d93: 81 e7 00 01 00 00 and $0x100,%edi if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 110d99: 83 7e 7c 00 cmpl $0x0,0x7c(%esi) 110d9d: 74 06 je 110da5 old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 110d9f: 81 cf 00 02 00 00 or $0x200,%edi old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 110da5: 80 7b 08 01 cmpb $0x1,0x8(%ebx) 110da9: 19 d2 sbb %edx,%edx 110dab: 81 e2 00 04 00 00 and $0x400,%edx old_mode |= _ISR_Get_level(); 110db1: 89 55 e4 mov %edx,-0x1c(%ebp) 110db4: 89 4d e0 mov %ecx,-0x20(%ebp) 110db7: e8 59 c6 ff ff call 10d415 <_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; 110dbc: 8b 55 e4 mov -0x1c(%ebp),%edx 110dbf: 09 d0 or %edx,%eax old_mode |= _ISR_Get_level(); 110dc1: 09 f8 or %edi,%eax 110dc3: 8b 4d e0 mov -0x20(%ebp),%ecx 110dc6: 89 01 mov %eax,(%ecx) *previous_mode_set = old_mode; /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 110dc8: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) 110dcf: 74 0b je 110ddc executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; 110dd1: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp) 110dd8: 0f 94 46 74 sete 0x74(%esi) if ( mask & RTEMS_TIMESLICE_MASK ) { 110ddc: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 110de3: 74 21 je 110e06 if ( _Modes_Is_timeslice(mode_set) ) { 110de5: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp) 110dec: 74 11 je 110dff executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 110dee: c7 46 7c 01 00 00 00 movl $0x1,0x7c(%esi) executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 110df5: a1 10 53 12 00 mov 0x125310,%eax 110dfa: 89 46 78 mov %eax,0x78(%esi) 110dfd: eb 07 jmp 110e06 } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 110dff: c7 46 7c 00 00 00 00 movl $0x0,0x7c(%esi) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 110e06: f6 45 0c 01 testb $0x1,0xc(%ebp) 110e0a: 74 0a je 110e16 */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( Modes_Control mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 110e0c: f6 45 08 01 testb $0x1,0x8(%ebp) 110e10: 74 03 je 110e15 110e12: fa cli 110e13: eb 01 jmp 110e16 110e15: fb sti /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 110e16: 31 c9 xor %ecx,%ecx if ( mask & RTEMS_ASR_MASK ) { 110e18: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 110e1f: 74 2a je 110e4b * Output: * *previous_mode_set - previous mode set * always return RTEMS_SUCCESSFUL; */ rtems_status_code rtems_task_mode( 110e21: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp) 110e28: 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 ) { 110e2b: 3a 43 08 cmp 0x8(%ebx),%al 110e2e: 74 1b je 110e4b asr->is_enabled = is_asr_enabled; 110e30: 88 43 08 mov %al,0x8(%ebx) ) { rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); 110e33: 9c pushf 110e34: fa cli 110e35: 58 pop %eax _signals = information->signals_pending; 110e36: 8b 53 18 mov 0x18(%ebx),%edx information->signals_pending = information->signals_posted; 110e39: 8b 4b 14 mov 0x14(%ebx),%ecx 110e3c: 89 4b 18 mov %ecx,0x18(%ebx) information->signals_posted = _signals; 110e3f: 89 53 14 mov %edx,0x14(%ebx) _ISR_Enable( _level ); 110e42: 50 push %eax 110e43: 9d popf /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 110e44: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 110e48: 0f 95 c1 setne %cl if ( _System_state_Is_up( _System_state_Get() ) ) { if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); } return RTEMS_SUCCESSFUL; 110e4b: 31 c0 xor %eax,%eax needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 110e4d: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c 110e54: 75 26 jne 110e7c bool are_signals_pending ) { Thread_Control *executing; executing = _Thread_Executing; 110e56: 8b 15 68 58 12 00 mov 0x125868,%edx if ( are_signals_pending || 110e5c: 84 c9 test %cl,%cl 110e5e: 75 0e jne 110e6e 110e60: 3b 15 6c 58 12 00 cmp 0x12586c,%edx 110e66: 74 14 je 110e7c (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) { 110e68: 80 7a 74 00 cmpb $0x0,0x74(%edx) 110e6c: 74 0e je 110e7c <== NEVER TAKEN _Thread_Dispatch_necessary = true; 110e6e: c6 05 74 58 12 00 01 movb $0x1,0x125874 if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); 110e75: e8 46 b2 ff ff call 10c0c0 <_Thread_Dispatch> } return RTEMS_SUCCESSFUL; 110e7a: 31 c0 xor %eax,%eax } 110e7c: 83 c4 1c add $0x1c,%esp 110e7f: 5b pop %ebx 110e80: 5e pop %esi 110e81: 5f pop %edi 110e82: c9 leave 110e83: c3 ret =============================================================================== 0010dd84 : rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10dd84: 55 push %ebp 10dd85: 89 e5 mov %esp,%ebp 10dd87: 56 push %esi 10dd88: 53 push %ebx 10dd89: 83 ec 10 sub $0x10,%esp 10dd8c: 8b 5d 0c mov 0xc(%ebp),%ebx 10dd8f: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10dd92: 85 db test %ebx,%ebx 10dd94: 74 10 je 10dda6 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 ) ); 10dd96: 0f b6 15 24 42 12 00 movzbl 0x124224,%edx !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; 10dd9d: b8 13 00 00 00 mov $0x13,%eax ) { register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10dda2: 39 d3 cmp %edx,%ebx 10dda4: 77 52 ja 10ddf8 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) return RTEMS_INVALID_ADDRESS; 10dda6: b8 09 00 00 00 mov $0x9,%eax if ( new_priority != RTEMS_CURRENT_PRIORITY && !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10ddab: 85 f6 test %esi,%esi 10ddad: 74 49 je 10ddf8 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10ddaf: 51 push %ecx 10ddb0: 51 push %ecx 10ddb1: 8d 45 f4 lea -0xc(%ebp),%eax 10ddb4: 50 push %eax 10ddb5: ff 75 08 pushl 0x8(%ebp) 10ddb8: e8 cb 1e 00 00 call 10fc88 <_Thread_Get> switch ( location ) { 10ddbd: 83 c4 10 add $0x10,%esp 10ddc0: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10ddc4: 75 2d jne 10ddf3 case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10ddc6: 8b 50 14 mov 0x14(%eax),%edx 10ddc9: 89 16 mov %edx,(%esi) if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10ddcb: 85 db test %ebx,%ebx 10ddcd: 74 1b je 10ddea the_thread->real_priority = new_priority; 10ddcf: 89 58 18 mov %ebx,0x18(%eax) if ( the_thread->resource_count == 0 || 10ddd2: 83 78 1c 00 cmpl $0x0,0x1c(%eax) 10ddd6: 74 05 je 10dddd 10ddd8: 39 58 14 cmp %ebx,0x14(%eax) 10dddb: 76 0d jbe 10ddea <== ALWAYS TAKEN the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, false ); 10dddd: 52 push %edx 10ddde: 6a 00 push $0x0 10dde0: 53 push %ebx 10dde1: 50 push %eax 10dde2: e8 a9 1a 00 00 call 10f890 <_Thread_Change_priority> 10dde7: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10ddea: e8 77 1e 00 00 call 10fc66 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10ddef: 31 c0 xor %eax,%eax 10ddf1: eb 05 jmp 10ddf8 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10ddf3: b8 04 00 00 00 mov $0x4,%eax } 10ddf8: 8d 65 f8 lea -0x8(%ebp),%esp 10ddfb: 5b pop %ebx 10ddfc: 5e pop %esi 10ddfd: c9 leave 10ddfe: c3 ret =============================================================================== 0010855b : } } rtems_status_code rtems_termios_close (void *arg) { 10855b: 55 push %ebp 10855c: 89 e5 mov %esp,%ebp 10855e: 56 push %esi 10855f: 53 push %ebx 108560: 8b 75 08 mov 0x8(%ebp),%esi rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 108563: 8b 06 mov (%esi),%eax 108565: 8b 58 34 mov 0x34(%eax),%ebx rtems_status_code sc; sc = rtems_semaphore_obtain( 108568: 51 push %ecx 108569: 6a 00 push $0x0 10856b: 6a 00 push $0x0 10856d: ff 35 3c 52 12 00 pushl 0x12523c 108573: e8 44 1c 00 00 call 10a1bc rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 108578: 83 c4 10 add $0x10,%esp 10857b: 85 c0 test %eax,%eax 10857d: 0f 85 88 00 00 00 jne 10860b <== NEVER TAKEN rtems_fatal_error_occurred (sc); if (--tty->refcount == 0) { 108583: 8b 43 08 mov 0x8(%ebx),%eax 108586: 48 dec %eax 108587: 89 43 08 mov %eax,0x8(%ebx) 10858a: 85 c0 test %eax,%eax 10858c: 0f 85 3e 01 00 00 jne 1086d0 if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 108592: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 108598: c1 e0 05 shl $0x5,%eax 10859b: 8b 80 f8 4e 12 00 mov 0x124ef8(%eax),%eax 1085a1: 85 c0 test %eax,%eax 1085a3: 74 08 je 1085ad /* * call discipline-specific close */ sc = rtems_termios_linesw[tty->t_line].l_close(tty); 1085a5: 83 ec 0c sub $0xc,%esp 1085a8: 53 push %ebx 1085a9: ff d0 call *%eax 1085ab: eb 26 jmp 1085d3 } else { /* * default: just flush output buffer */ sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 1085ad: 52 push %edx 1085ae: 6a 00 push $0x0 1085b0: 6a 00 push $0x0 1085b2: ff 73 18 pushl 0x18(%ebx) 1085b5: e8 02 1c 00 00 call 10a1bc if (sc != RTEMS_SUCCESSFUL) { 1085ba: 83 c4 10 add $0x10,%esp 1085bd: 85 c0 test %eax,%eax 1085bf: 75 4a jne 10860b <== NEVER TAKEN rtems_fatal_error_occurred (sc); } drainOutput (tty); 1085c1: 89 d8 mov %ebx,%eax 1085c3: e8 10 fb ff ff call 1080d8 rtems_semaphore_release (tty->osem); 1085c8: 83 ec 0c sub $0xc,%esp 1085cb: ff 73 18 pushl 0x18(%ebx) 1085ce: e8 d5 1c 00 00 call 10a2a8 1085d3: 83 c4 10 add $0x10,%esp } if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 1085d6: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 1085dd: 75 35 jne 108614 /* * send "terminate" to I/O tasks */ sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT ); 1085df: 50 push %eax 1085e0: 50 push %eax 1085e1: 6a 01 push $0x1 1085e3: ff b3 c4 00 00 00 pushl 0xc4(%ebx) 1085e9: e8 66 17 00 00 call 109d54 if (sc != RTEMS_SUCCESSFUL) 1085ee: 83 c4 10 add $0x10,%esp 1085f1: 85 c0 test %eax,%eax 1085f3: 75 16 jne 10860b <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT ); 1085f5: 51 push %ecx 1085f6: 51 push %ecx 1085f7: 6a 01 push $0x1 1085f9: ff b3 c8 00 00 00 pushl 0xc8(%ebx) 1085ff: e8 50 17 00 00 call 109d54 if (sc != RTEMS_SUCCESSFUL) 108604: 83 c4 10 add $0x10,%esp 108607: 85 c0 test %eax,%eax 108609: 74 09 je 108614 <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 10860b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10860e: 50 push %eax <== NOT EXECUTED 10860f: e8 74 21 00 00 call 10a788 <== NOT EXECUTED } if (tty->device.lastClose) 108614: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax 10861a: 85 c0 test %eax,%eax 10861c: 74 0d je 10862b (*tty->device.lastClose)(tty->major, tty->minor, arg); 10861e: 52 push %edx 10861f: 56 push %esi 108620: ff 73 10 pushl 0x10(%ebx) 108623: ff 73 0c pushl 0xc(%ebx) 108626: ff d0 call *%eax 108628: 83 c4 10 add $0x10,%esp if (tty->forw == NULL) { 10862b: 8b 13 mov (%ebx),%edx 10862d: 85 d2 test %edx,%edx 10862f: 8b 43 04 mov 0x4(%ebx),%eax 108632: 75 11 jne 108645 rtems_termios_ttyTail = tty->back; 108634: a3 40 52 12 00 mov %eax,0x125240 if ( rtems_termios_ttyTail != NULL ) { 108639: 85 c0 test %eax,%eax 10863b: 74 0b je 108648 rtems_termios_ttyTail->forw = NULL; 10863d: c7 00 00 00 00 00 movl $0x0,(%eax) 108643: eb 03 jmp 108648 } } else { tty->forw->back = tty->back; 108645: 89 42 04 mov %eax,0x4(%edx) } if (tty->back == NULL) { 108648: 8b 53 04 mov 0x4(%ebx),%edx 10864b: 85 d2 test %edx,%edx 10864d: 8b 03 mov (%ebx),%eax 10864f: 75 12 jne 108663 rtems_termios_ttyHead = tty->forw; 108651: a3 44 52 12 00 mov %eax,0x125244 if ( rtems_termios_ttyHead != NULL ) { 108656: 85 c0 test %eax,%eax 108658: 74 0b je 108665 rtems_termios_ttyHead->back = NULL; 10865a: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) 108661: eb 02 jmp 108665 } } else { tty->back->forw = tty->forw; 108663: 89 02 mov %eax,(%edx) } rtems_semaphore_delete (tty->isem); 108665: 83 ec 0c sub $0xc,%esp 108668: ff 73 14 pushl 0x14(%ebx) 10866b: e8 bc 1a 00 00 call 10a12c rtems_semaphore_delete (tty->osem); 108670: 59 pop %ecx 108671: ff 73 18 pushl 0x18(%ebx) 108674: e8 b3 1a 00 00 call 10a12c rtems_semaphore_delete (tty->rawOutBuf.Semaphore); 108679: 5a pop %edx 10867a: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 108680: e8 a7 1a 00 00 call 10a12c if ((tty->device.pollRead == NULL) || 108685: 83 c4 10 add $0x10,%esp 108688: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx) 10868f: 74 09 je 10869a 108691: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 108698: 75 0e jne 1086a8 (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)) rtems_semaphore_delete (tty->rawInBuf.Semaphore); 10869a: 83 ec 0c sub $0xc,%esp 10869d: ff 73 68 pushl 0x68(%ebx) 1086a0: e8 87 1a 00 00 call 10a12c 1086a5: 83 c4 10 add $0x10,%esp free (tty->rawInBuf.theBuf); 1086a8: 83 ec 0c sub $0xc,%esp 1086ab: ff 73 58 pushl 0x58(%ebx) 1086ae: e8 c5 ec ff ff call 107378 free (tty->rawOutBuf.theBuf); 1086b3: 58 pop %eax 1086b4: ff 73 7c pushl 0x7c(%ebx) 1086b7: e8 bc ec ff ff call 107378 free (tty->cbuf); 1086bc: 5e pop %esi 1086bd: ff 73 1c pushl 0x1c(%ebx) 1086c0: e8 b3 ec ff ff call 107378 free (tty); 1086c5: 89 1c 24 mov %ebx,(%esp) 1086c8: e8 ab ec ff ff call 107378 1086cd: 83 c4 10 add $0x10,%esp } rtems_semaphore_release (rtems_termios_ttyMutex); 1086d0: 83 ec 0c sub $0xc,%esp 1086d3: ff 35 3c 52 12 00 pushl 0x12523c 1086d9: e8 ca 1b 00 00 call 10a2a8 return RTEMS_SUCCESSFUL; } 1086de: 31 c0 xor %eax,%eax 1086e0: 8d 65 f8 lea -0x8(%ebp),%esp 1086e3: 5b pop %ebx 1086e4: 5e pop %esi 1086e5: c9 leave 1086e6: c3 ret =============================================================================== 00109894 : * for each transmitted character. * It returns number of characters left to transmit */ int rtems_termios_dequeue_characters (void *ttyp, int len) { 109894: 55 push %ebp 109895: 89 e5 mov %esp,%ebp 109897: 83 ec 08 sub $0x8,%esp 10989a: 8b 45 08 mov 0x8(%ebp),%eax rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len; 10989d: 8b 55 0c mov 0xc(%ebp),%edx 1098a0: 01 90 90 00 00 00 add %edx,0x90(%eax) if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 1098a6: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax) 1098ad: 75 1f jne 1098ce /* * send wake up to transmitter task */ sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT); 1098af: 52 push %edx 1098b0: 52 push %edx 1098b1: 6a 02 push $0x2 1098b3: ff b0 c8 00 00 00 pushl 0xc8(%eax) 1098b9: e8 96 04 00 00 call 109d54 if (sc != RTEMS_SUCCESSFUL) 1098be: 83 c4 10 add $0x10,%esp 1098c1: 85 c0 test %eax,%eax 1098c3: 74 30 je 1098f5 <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 1098c5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1098c8: 50 push %eax <== NOT EXECUTED 1098c9: e8 ba 0e 00 00 call 10a788 <== NOT EXECUTED return 0; /* nothing to output in IRQ... */ } if (tty->t_line == PPPDISC ) { 1098ce: 83 b8 cc 00 00 00 05 cmpl $0x5,0xcc(%eax) 1098d5: 75 15 jne 1098ec /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 1098d7: 8b 15 a8 4f 12 00 mov 0x124fa8,%edx 1098dd: 85 d2 test %edx,%edx 1098df: 74 14 je 1098f5 <== NEVER TAKEN rtems_termios_linesw[tty->t_line].l_start(tty); 1098e1: 83 ec 0c sub $0xc,%esp 1098e4: 50 push %eax 1098e5: ff d2 call *%edx 1098e7: 83 c4 10 add $0x10,%esp 1098ea: eb 09 jmp 1098f5 } return 0; /* nothing to output in IRQ... */ } return rtems_termios_refill_transmitter(tty); 1098ec: 89 45 08 mov %eax,0x8(%ebp) } 1098ef: c9 leave rtems_termios_linesw[tty->t_line].l_start(tty); } return 0; /* nothing to output in IRQ... */ } return rtems_termios_refill_transmitter(tty); 1098f0: e9 6d fd ff ff jmp 109662 } 1098f5: 31 c0 xor %eax,%eax 1098f7: c9 leave 1098f8: c3 ret =============================================================================== 00109373 : * 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) { 109373: 55 push %ebp 109374: 89 e5 mov %esp,%ebp 109376: 57 push %edi 109377: 56 push %esi 109378: 53 push %ebx 109379: 83 ec 2c sub $0x2c,%esp 10937c: 8b 5d 08 mov 0x8(%ebp),%ebx 10937f: 8b 7d 0c mov 0xc(%ebp),%edi 109382: 8b 4d 10 mov 0x10(%ebp),%ecx 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) { 109385: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 10938b: c1 e0 05 shl $0x5,%eax 10938e: 89 ca mov %ecx,%edx 109390: 83 b8 04 4f 12 00 00 cmpl $0x0,0x124f04(%eax) 109397: 75 3b jne 1093d4 109399: 89 4d e0 mov %ecx,-0x20(%ebp) 10939c: c6 45 df 00 movb $0x0,-0x21(%ebp) 1093a0: 31 f6 xor %esi,%esi /* * 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); 1093a2: 8d 43 30 lea 0x30(%ebx),%eax 1093a5: 89 45 d4 mov %eax,-0x2c(%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, 1093a8: 8d 53 4a lea 0x4a(%ebx),%edx 1093ab: 89 55 d0 mov %edx,-0x30(%ebp) 1093ae: e9 26 02 00 00 jmp 1095d9 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--) { c = *buf++; 1093b3: 0f be 0f movsbl (%edi),%ecx 1093b6: 47 inc %edi rtems_termios_linesw[tty->t_line].l_rint(c,tty); 1093b7: 56 push %esi 1093b8: 56 push %esi 1093b9: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 1093bf: c1 e0 05 shl $0x5,%eax 1093c2: 53 push %ebx 1093c3: 51 push %ecx 1093c4: 89 55 cc mov %edx,-0x34(%ebp) 1093c7: ff 90 04 4f 12 00 call *0x124f04(%eax) 1093cd: 8b 55 cc mov -0x34(%ebp),%edx 1093d0: 4a dec %edx 1093d1: 83 c4 10 add $0x10,%esp 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--) { 1093d4: 85 d2 test %edx,%edx 1093d6: 75 db jne 1093b3 */ 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; 1093d8: 31 f6 xor %esi,%esi } /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 1093da: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx) 1093e1: 0f 85 0d 02 00 00 jne 1095f4 <== NEVER TAKEN 1093e7: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); tty->tty_rcvwakeup = 1; } return 0; 1093ed: 89 d6 mov %edx,%esi } /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 1093ef: 85 c0 test %eax,%eax 1093f1: 0f 84 fd 01 00 00 je 1095f4 <== NEVER TAKEN (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 1093f7: 51 push %ecx 1093f8: 51 push %ecx 1093f9: ff b3 e0 00 00 00 pushl 0xe0(%ebx) 1093ff: 8d 53 30 lea 0x30(%ebx),%edx 109402: 52 push %edx 109403: ff d0 call *%eax tty->tty_rcvwakeup = 1; 109405: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) 10940c: 00 00 00 10940f: e9 dd 01 00 00 jmp 1095f1 } return 0; } while (len--) { c = *buf++; 109414: 8a 0f mov (%edi),%cl 109416: 88 4d de mov %cl,-0x22(%ebp) 109419: 47 inc %edi /* FIXME: implement IXANY: any character restarts output */ /* if incoming XON/XOFF controls outgoing stream: */ if (tty->flow_ctrl & FL_MDXON) { 10941a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109420: f6 c4 02 test $0x2,%ah 109423: 74 46 je 10946b /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { 109425: 0f be c1 movsbl %cl,%eax 109428: 0f b6 53 4a movzbl 0x4a(%ebx),%edx 10942c: 39 d0 cmp %edx,%eax 10942e: 75 28 jne 109458 if (c == tty->termios.c_cc[VSTART]) { 109430: 0f b6 53 49 movzbl 0x49(%ebx),%edx 109434: 39 d0 cmp %edx,%eax 109436: 75 0b jne 109443 <== ALWAYS TAKEN /* received VSTOP and VSTART==VSTOP? */ /* then toggle "stop output" status */ tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; 109438: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10943e: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED 109441: eb 09 jmp 10944c <== NOT EXECUTED } else { /* VSTOP received (other code than VSTART) */ /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; 109443: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109449: 83 c8 10 or $0x10,%eax 10944c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) * 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) { 109452: c6 45 df 01 movb $0x1,-0x21(%ebp) 109456: eb 19 jmp 109471 /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; } flow_rcv = true; } else if (c == tty->termios.c_cc[VSTART]) { 109458: 0f b6 53 49 movzbl 0x49(%ebx),%edx 10945c: 39 d0 cmp %edx,%eax 10945e: 75 0b jne 10946b <== ALWAYS TAKEN /* VSTART received */ /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; 109460: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109466: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED 109469: eb e1 jmp 10944c <== NOT EXECUTED flow_rcv = true; } } if (flow_rcv) { 10946b: 80 7d df 00 cmpb $0x0,-0x21(%ebp) 10946f: 74 51 je 1094c2 <== ALWAYS TAKEN /* restart output according to FL_ORCVXOF flag */ if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) { 109471: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109477: 83 e0 30 and $0x30,%eax 10947a: 83 f8 20 cmp $0x20,%eax 10947d: 0f 85 53 01 00 00 jne 1095d6 /* disable interrupts */ rtems_interrupt_disable(level); 109483: 9c pushf <== NOT EXECUTED 109484: fa cli <== NOT EXECUTED 109485: 8f 45 e4 popl -0x1c(%ebp) <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 109488: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10948e: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 109491: 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) { 109497: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 10949e: 74 19 je 1094b9 <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1); 1094a0: 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)( 1094a6: 52 push %edx <== NOT EXECUTED 1094a7: 6a 01 push $0x1 <== NOT EXECUTED 1094a9: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 1094ac: 50 push %eax <== NOT EXECUTED 1094ad: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1094b0: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 1094b6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1); } /* reenable interrupts */ rtems_interrupt_enable(level); 1094b9: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 1094bc: 9d popf <== NOT EXECUTED 1094bd: e9 14 01 00 00 jmp 1095d6 <== NOT EXECUTED } } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; 1094c2: 8b 43 60 mov 0x60(%ebx),%eax 1094c5: 8b 4b 64 mov 0x64(%ebx),%ecx 1094c8: 40 inc %eax 1094c9: 31 d2 xor %edx,%edx 1094cb: f7 f1 div %ecx 1094cd: 89 55 e4 mov %edx,-0x1c(%ebp) /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); 1094d0: 9c pushf 1094d1: fa cli 1094d2: 8f 45 d8 popl -0x28(%ebp) if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 1094d5: 8b 53 5c mov 0x5c(%ebx),%edx 1094d8: 8b 43 64 mov 0x64(%ebx),%eax % tty->rawInBuf.Size) > tty->highwater) && 1094db: 8b 4b 64 mov 0x64(%ebx),%ecx } } 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) 1094de: 29 d0 sub %edx,%eax 1094e0: 03 45 e4 add -0x1c(%ebp),%eax % tty->rawInBuf.Size) > tty->highwater) && 1094e3: 31 d2 xor %edx,%edx 1094e5: f7 f1 div %ecx } } 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) 1094e7: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx 1094ed: 0f 86 98 00 00 00 jbe 10958b <== ALWAYS TAKEN % tty->rawInBuf.Size) > tty->highwater) && !(tty->flow_ctrl & FL_IREQXOF)) { 1094f3: 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) && 1094f9: a8 01 test $0x1,%al <== NOT EXECUTED 1094fb: 0f 85 8a 00 00 00 jne 10958b <== NOT EXECUTED !(tty->flow_ctrl & FL_IREQXOF)) { /* incoming data stream should be stopped */ tty->flow_ctrl |= FL_IREQXOF; 109501: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109507: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10950a: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF)) 109510: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109516: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED 10951b: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED 109520: 75 33 jne 109555 <== NOT EXECUTED == (FL_MDXOF ) ) { if ((tty->flow_ctrl & FL_OSTOP) || 109522: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109528: a8 20 test $0x20,%al <== NOT EXECUTED 10952a: 75 09 jne 109535 <== NOT EXECUTED 10952c: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 109533: 75 56 jne 10958b <== 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; 109535: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10953b: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 10953e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED (*tty->device.write)(tty->minor, 109544: 51 push %ecx <== NOT EXECUTED 109545: 6a 01 push $0x1 <== NOT EXECUTED 109547: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED 10954a: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10954d: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 109553: eb 33 jmp 109588 <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTOP]), 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) { 109555: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10955b: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED 109560: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED 109565: 75 24 jne 10958b <== NOT EXECUTED tty->flow_ctrl |= FL_IRTSOFF; 109567: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10956d: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 109570: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* deactivate RTS line */ if (tty->device.stopRemoteTx != NULL) { 109576: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED 10957c: 85 c0 test %eax,%eax <== NOT EXECUTED 10957e: 74 0b je 10958b <== NOT EXECUTED tty->device.stopRemoteTx(tty->minor); 109580: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109583: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109586: ff d0 call *%eax <== NOT EXECUTED 109588: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } } /* reenable interrupts */ rtems_interrupt_enable(level); 10958b: ff 75 d8 pushl -0x28(%ebp) 10958e: 9d popf if (newTail == tty->rawInBuf.Head) { 10958f: 8b 43 5c mov 0x5c(%ebx),%eax 109592: 39 45 e4 cmp %eax,-0x1c(%ebp) 109595: 75 03 jne 10959a <== ALWAYS TAKEN dropped++; 109597: 46 inc %esi <== NOT EXECUTED 109598: eb 3c jmp 1095d6 <== NOT EXECUTED } else { tty->rawInBuf.theBuf[newTail] = c; 10959a: 8b 43 58 mov 0x58(%ebx),%eax 10959d: 8a 4d de mov -0x22(%ebp),%cl 1095a0: 8b 55 e4 mov -0x1c(%ebp),%edx 1095a3: 88 0c 10 mov %cl,(%eax,%edx,1) tty->rawInBuf.Tail = newTail; 1095a6: 89 53 60 mov %edx,0x60(%ebx) /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 1095a9: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx) 1095b0: 75 24 jne 1095d6 <== NEVER TAKEN 1095b2: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax 1095b8: 85 c0 test %eax,%eax 1095ba: 74 1a je 1095d6 <== ALWAYS TAKEN (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 1095bc: 52 push %edx <== NOT EXECUTED 1095bd: 52 push %edx <== NOT EXECUTED 1095be: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED 1095c4: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 1095c7: ff d0 call *%eax <== NOT EXECUTED tty->tty_rcvwakeup = 1; 1095c9: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED 1095d0: 00 00 00 1095d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1095d6: ff 4d e0 decl -0x20(%ebp) tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 1095d9: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) 1095dd: 0f 85 31 fe ff ff jne 109414 } } } } tty->rawInBufDropped += dropped; 1095e3: 01 73 78 add %esi,0x78(%ebx) rtems_semaphore_release (tty->rawInBuf.Semaphore); 1095e6: 83 ec 0c sub $0xc,%esp 1095e9: ff 73 68 pushl 0x68(%ebx) 1095ec: e8 b7 0c 00 00 call 10a2a8 return dropped; 1095f1: 83 c4 10 add $0x10,%esp } 1095f4: 89 f0 mov %esi,%eax 1095f6: 8d 65 f4 lea -0xc(%ebp),%esp 1095f9: 5b pop %ebx 1095fa: 5e pop %esi 1095fb: 5f pop %edi 1095fc: c9 leave 1095fd: c3 ret =============================================================================== 00108706 : } } rtems_status_code rtems_termios_ioctl (void *arg) { 108706: 55 push %ebp 108707: 89 e5 mov %esp,%ebp 108709: 57 push %edi 10870a: 56 push %esi 10870b: 53 push %ebx 10870c: 83 ec 20 sub $0x20,%esp rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 10870f: 8b 55 08 mov 0x8(%ebp),%edx 108712: 8b 02 mov (%edx),%eax 108714: 8b 58 34 mov 0x34(%eax),%ebx struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer; 108717: 8b 72 08 mov 0x8(%edx),%esi rtems_status_code sc; args->ioctl_return = 0; 10871a: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 108721: 6a 00 push $0x0 108723: 6a 00 push $0x0 108725: ff 73 18 pushl 0x18(%ebx) 108728: e8 8f 1a 00 00 call 10a1bc 10872d: 89 45 e4 mov %eax,-0x1c(%ebp) if (sc != RTEMS_SUCCESSFUL) { 108730: 83 c4 10 add $0x10,%esp 108733: 85 c0 test %eax,%eax 108735: 74 0b je 108742 <== ALWAYS TAKEN args->ioctl_return = sc; 108737: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10873a: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED return sc; 10873d: e9 05 03 00 00 jmp 108a47 <== NOT EXECUTED } switch (args->command) { 108742: 8b 55 08 mov 0x8(%ebp),%edx 108745: 8b 42 04 mov 0x4(%edx),%eax 108748: 83 f8 04 cmp $0x4,%eax 10874b: 0f 84 4d 02 00 00 je 10899e 108751: 77 10 ja 108763 108753: 83 f8 02 cmp $0x2,%eax 108756: 74 77 je 1087cf 108758: 0f 87 1e 02 00 00 ja 10897c 10875e: 48 dec %eax 10875f: 75 2f jne 108790 <== NEVER TAKEN 108761: eb 55 jmp 1087b8 108763: 3d 7f 66 04 40 cmp $0x4004667f,%eax 108768: 0f 84 a5 02 00 00 je 108a13 <== NEVER TAKEN 10876e: 77 0a ja 10877a 108770: 83 f8 05 cmp $0x5,%eax 108773: 75 1b jne 108790 108775: e9 0e 02 00 00 jmp 108988 10877a: 3d 1a 74 04 40 cmp $0x4004741a,%eax 10877f: 0f 84 7e 02 00 00 je 108a03 108785: 3d 1b 74 04 80 cmp $0x8004741b,%eax 10878a: 0f 84 21 02 00 00 je 1089b1 <== ALWAYS TAKEN default: if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) { 108790: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 108796: c1 e0 05 shl $0x5,%eax 108799: 8b 80 0c 4f 12 00 mov 0x124f0c(%eax),%eax sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args); } else { sc = RTEMS_INVALID_NUMBER; 10879f: c7 45 e4 0a 00 00 00 movl $0xa,-0x1c(%ebp) args->ioctl_return = sc; return sc; } switch (args->command) { default: if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) { 1087a6: 85 c0 test %eax,%eax 1087a8: 0f 84 82 02 00 00 je 108a30 <== NEVER TAKEN sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args); 1087ae: 52 push %edx 1087af: 52 push %edx 1087b0: ff 75 08 pushl 0x8(%ebp) 1087b3: e9 40 02 00 00 jmp 1089f8 sc = RTEMS_INVALID_NUMBER; } break; case RTEMS_IO_GET_ATTRIBUTES: *(struct termios *)args->buffer = tty->termios; 1087b8: 8b 4d 08 mov 0x8(%ebp),%ecx 1087bb: 8b 41 08 mov 0x8(%ecx),%eax 1087be: 8d 73 30 lea 0x30(%ebx),%esi 1087c1: b9 09 00 00 00 mov $0x9,%ecx 1087c6: 89 c7 mov %eax,%edi 1087c8: f3 a5 rep movsl %ds:(%esi),%es:(%edi) break; 1087ca: e9 61 02 00 00 jmp 108a30 case RTEMS_IO_SET_ATTRIBUTES: tty->termios = *(struct termios *)args->buffer; 1087cf: 8b 45 08 mov 0x8(%ebp),%eax 1087d2: 8b 70 08 mov 0x8(%eax),%esi 1087d5: 8d 7b 30 lea 0x30(%ebx),%edi 1087d8: b9 09 00 00 00 mov $0x9,%ecx 1087dd: 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) && 1087df: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1087e5: f6 c4 02 test $0x2,%ah 1087e8: 74 57 je 108841 1087ea: f6 43 31 04 testb $0x4,0x31(%ebx) 1087ee: 75 51 jne 108841 !(tty->termios.c_iflag & IXON)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF); 1087f0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1087f6: 25 ef fd ff ff and $0xfffffdef,%eax 1087fb: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) /* has output been stopped due to received XOFF? */ if (tty->flow_ctrl & FL_OSTOP) { 108801: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108807: a8 20 test $0x20,%al 108809: 74 36 je 108841 <== ALWAYS TAKEN /* disable interrupts */ rtems_interrupt_disable(level); 10880b: 9c pushf <== NOT EXECUTED 10880c: fa cli <== NOT EXECUTED 10880d: 5e pop %esi <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 10880e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108814: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 108817: 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) { 10881d: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 108824: 74 19 je 10883f <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 108826: 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)( 10882c: 57 push %edi <== NOT EXECUTED 10882d: 6a 01 push $0x1 <== NOT EXECUTED 10882f: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 108832: 50 push %eax <== NOT EXECUTED 108833: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108836: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 10883c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } /* reenable interrupts */ rtems_interrupt_enable(level); 10883f: 56 push %esi <== NOT EXECUTED 108840: 9d popf <== NOT EXECUTED } } /* check for incoming XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) { 108841: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108847: f6 c4 04 test $0x4,%ah 10884a: 74 24 je 108870 10884c: f6 43 31 10 testb $0x10,0x31(%ebx) 108850: 75 1e jne 108870 <== NEVER TAKEN /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXOF); 108852: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108858: 80 e4 fb and $0xfb,%ah 10885b: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) /* FIXME: what happens, if we had sent XOFF but not yet XON? */ tty->flow_ctrl &= ~(FL_ISNTXOF); 108861: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108867: 83 e0 fd and $0xfffffffd,%eax 10886a: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) } /* check for incoming RTS/CTS flow control switched off */ if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) { 108870: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108876: f6 c4 01 test $0x1,%ah 108879: 74 43 je 1088be <== ALWAYS TAKEN 10887b: 83 7b 38 00 cmpl $0x0,0x38(%ebx) <== NOT EXECUTED 10887f: 78 3d js 1088be <== NOT EXECUTED /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDRTS); 108881: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108887: 80 e4 fe and $0xfe,%ah <== NOT EXECUTED 10888a: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* restart remote Tx, if it was stopped */ if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) { 108890: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108896: a8 04 test $0x4,%al <== NOT EXECUTED 108898: 74 15 je 1088af <== NOT EXECUTED 10889a: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 1088a0: 85 c0 test %eax,%eax <== NOT EXECUTED 1088a2: 74 0b je 1088af <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 1088a4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1088a7: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1088aa: ff d0 call *%eax <== NOT EXECUTED 1088ac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } tty->flow_ctrl &= ~(FL_IRTSOFF); 1088af: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1088b5: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 1088b8: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== 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) { 1088be: 83 7b 38 00 cmpl $0x0,0x38(%ebx) 1088c2: 79 0f jns 1088d3 <== ALWAYS TAKEN tty->flow_ctrl |= FL_MDRTS; 1088c4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1088ca: 80 cc 01 or $0x1,%ah <== NOT EXECUTED 1088cd: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } /* check for incoming XON/XOF flow control switched on */ if (tty->termios.c_iflag & IXOFF) { 1088d3: 8b 53 30 mov 0x30(%ebx),%edx 1088d6: f6 c6 10 test $0x10,%dh 1088d9: 74 0f je 1088ea tty->flow_ctrl |= FL_MDXOF; 1088db: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1088e1: 80 cc 04 or $0x4,%ah 1088e4: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) } /* check for outgoing XON/XOF flow control switched on */ if (tty->termios.c_iflag & IXON) { 1088ea: 80 e6 04 and $0x4,%dh 1088ed: 74 0f je 1088fe tty->flow_ctrl |= FL_MDXON; 1088ef: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1088f5: 80 cc 02 or $0x2,%ah 1088f8: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) 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) { 1088fe: f6 43 3c 02 testb $0x2,0x3c(%ebx) 108902: 75 39 jne 10893d tty->rawInBufSemaphoreOptions = RTEMS_WAIT; tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { tty->vtimeTicks = tty->termios.c_cc[VTIME] * 108904: 0f b6 73 46 movzbl 0x46(%ebx),%esi rtems_clock_get_ticks_per_second() / 10; 108908: e8 6f 12 00 00 call 109b7c 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] * 10890d: 0f af c6 imul %esi,%eax rtems_clock_get_ticks_per_second() / 10; 108910: b9 0a 00 00 00 mov $0xa,%ecx 108915: 31 d2 xor %edx,%edx 108917: f7 f1 div %ecx 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] * 108919: 89 43 54 mov %eax,0x54(%ebx) rtems_clock_get_ticks_per_second() / 10; if (tty->termios.c_cc[VTIME]) { 10891c: 80 7b 46 00 cmpb $0x0,0x46(%ebx) 108920: 74 15 je 108937 tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 108922: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) tty->rawInBufSemaphoreTimeout = tty->vtimeTicks; 108929: 89 43 70 mov %eax,0x70(%ebx) if (tty->termios.c_cc[VMIN]) 10892c: 80 7b 47 00 cmpb $0x0,0x47(%ebx) 108930: 75 19 jne 10894b tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; 108932: 89 43 74 mov %eax,0x74(%ebx) 108935: eb 24 jmp 10895b } else { if (tty->termios.c_cc[VMIN]) { 108937: 80 7b 47 00 cmpb $0x0,0x47(%ebx) 10893b: 74 17 je 108954 <== ALWAYS TAKEN tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 10893d: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; 108944: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; 10894b: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx) 108952: eb 07 jmp 10895b } else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; 108954: c7 43 6c 01 00 00 00 movl $0x1,0x6c(%ebx) } } } if (tty->device.setAttributes) 10895b: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax 108961: 85 c0 test %eax,%eax 108963: 0f 84 c7 00 00 00 je 108a30 <== NEVER TAKEN (*tty->device.setAttributes)(tty->minor, &tty->termios); 108969: 56 push %esi 10896a: 56 push %esi 10896b: 8d 53 30 lea 0x30(%ebx),%edx 10896e: 52 push %edx 10896f: ff 73 10 pushl 0x10(%ebx) 108972: ff d0 call *%eax 108974: 83 c4 10 add $0x10,%esp 108977: e9 b4 00 00 00 jmp 108a30 break; case RTEMS_IO_TCDRAIN: drainOutput (tty); 10897c: 89 d8 mov %ebx,%eax 10897e: e8 55 f7 ff ff call 1080d8 break; 108983: e9 a8 00 00 00 jmp 108a30 case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; 108988: 8b 06 mov (%esi),%eax 10898a: 8b 56 04 mov 0x4(%esi),%edx 10898d: 89 83 d4 00 00 00 mov %eax,0xd4(%ebx) 108993: 89 93 d8 00 00 00 mov %edx,0xd8(%ebx) break; 108999: e9 92 00 00 00 jmp 108a30 case RTEMS_IO_RCVWAKEUP: tty->tty_rcv = *wakeup; 10899e: 8b 06 mov (%esi),%eax 1089a0: 8b 56 04 mov 0x4(%esi),%edx 1089a3: 89 83 dc 00 00 00 mov %eax,0xdc(%ebx) 1089a9: 89 93 e0 00 00 00 mov %edx,0xe0(%ebx) break; 1089af: eb 7f jmp 108a30 #if 1 /* FIXME */ case TIOCSETD: /* * close old line discipline */ if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 1089b1: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 1089b7: c1 e0 05 shl $0x5,%eax 1089ba: 8b 80 f8 4e 12 00 mov 0x124ef8(%eax),%eax 1089c0: 85 c0 test %eax,%eax 1089c2: 74 0c je 1089d0 sc = rtems_termios_linesw[tty->t_line].l_close(tty); 1089c4: 83 ec 0c sub $0xc,%esp 1089c7: 53 push %ebx 1089c8: ff d0 call *%eax 1089ca: 89 45 e4 mov %eax,-0x1c(%ebp) 1089cd: 83 c4 10 add $0x10,%esp } tty->t_line=*(int*)(args->buffer); 1089d0: 8b 55 08 mov 0x8(%ebp),%edx 1089d3: 8b 42 08 mov 0x8(%edx),%eax 1089d6: 8b 00 mov (%eax),%eax 1089d8: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx) tty->t_sc = NULL; /* ensure that no more valid data */ 1089de: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx) 1089e5: 00 00 00 /* * open new line discipline */ if (rtems_termios_linesw[tty->t_line].l_open != NULL) { 1089e8: c1 e0 05 shl $0x5,%eax 1089eb: 8b 80 f4 4e 12 00 mov 0x124ef4(%eax),%eax 1089f1: 85 c0 test %eax,%eax 1089f3: 74 3b je 108a30 <== NEVER TAKEN sc = rtems_termios_linesw[tty->t_line].l_open(tty); 1089f5: 83 ec 0c sub $0xc,%esp 1089f8: 53 push %ebx 1089f9: ff d0 call *%eax 1089fb: 89 45 e4 mov %eax,-0x1c(%ebp) 1089fe: e9 71 ff ff ff jmp 108974 } break; case TIOCGETD: *(int*)(args->buffer)=tty->t_line; 108a03: 8b 4d 08 mov 0x8(%ebp),%ecx 108a06: 8b 41 08 mov 0x8(%ecx),%eax 108a09: 8b 93 cc 00 00 00 mov 0xcc(%ebx),%edx 108a0f: 89 10 mov %edx,(%eax) break; 108a11: eb 1d jmp 108a30 #endif case FIONREAD: { int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head; 108a13: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED 108a16: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED if ( rawnc < 0 ) 108a19: 29 d0 sub %edx,%eax <== NOT EXECUTED 108a1b: 79 05 jns 108a22 <== NOT EXECUTED rawnc += tty->rawInBuf.Size; 108a1d: 8b 53 64 mov 0x64(%ebx),%edx <== NOT EXECUTED 108a20: 01 d0 add %edx,%eax <== NOT EXECUTED /* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; 108a22: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 108a25: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED 108a28: 03 43 20 add 0x20(%ebx),%eax <== NOT EXECUTED 108a2b: 2b 43 24 sub 0x24(%ebx),%eax <== NOT EXECUTED 108a2e: 89 02 mov %eax,(%edx) <== NOT EXECUTED } break; } rtems_semaphore_release (tty->osem); 108a30: 83 ec 0c sub $0xc,%esp 108a33: ff 73 18 pushl 0x18(%ebx) 108a36: e8 6d 18 00 00 call 10a2a8 args->ioctl_return = sc; 108a3b: 8b 55 e4 mov -0x1c(%ebp),%edx 108a3e: 8b 45 08 mov 0x8(%ebp),%eax 108a41: 89 50 0c mov %edx,0xc(%eax) return sc; 108a44: 83 c4 10 add $0x10,%esp } 108a47: 8b 45 e4 mov -0x1c(%ebp),%eax 108a4a: 8d 65 f4 lea -0xc(%ebp),%esp 108a4d: 5b pop %ebx 108a4e: 5e pop %esi 108a4f: 5f pop %edi 108a50: c9 leave 108a51: c3 ret =============================================================================== 00108135 : rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) { 108135: 55 push %ebp 108136: 89 e5 mov %esp,%ebp 108138: 57 push %edi 108139: 56 push %esi 10813a: 53 push %ebx 10813b: 83 ec 20 sub $0x20,%esp struct rtems_termios_tty *tty; /* * See if the device has already been opened */ sc = rtems_semaphore_obtain( 10813e: 6a 00 push $0x0 108140: 6a 00 push $0x0 108142: ff 35 3c 52 12 00 pushl 0x12523c 108148: e8 6f 20 00 00 call 10a1bc 10814d: 89 45 e4 mov %eax,-0x1c(%ebp) rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 108150: 83 c4 10 add $0x10,%esp 108153: 85 c0 test %eax,%eax 108155: 0f 85 d3 03 00 00 jne 10852e <== NEVER TAKEN return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 10815b: 8b 35 44 52 12 00 mov 0x125244,%esi 108161: 89 f2 mov %esi,%edx 108163: eb 16 jmp 10817b if ((tty->major == major) && (tty->minor == minor)) 108165: 8b 45 08 mov 0x8(%ebp),%eax 108168: 39 42 0c cmp %eax,0xc(%edx) 10816b: 75 0c jne 108179 10816d: 8b 4d 0c mov 0xc(%ebp),%ecx 108170: 39 4a 10 cmp %ecx,0x10(%edx) 108173: 0f 84 26 03 00 00 je 10849f <== ALWAYS TAKEN sc = rtems_semaphore_obtain( rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 108179: 8b 12 mov (%edx),%edx 10817b: 85 d2 test %edx,%edx 10817d: 75 e6 jne 108165 10817f: e9 b5 03 00 00 jmp 108539 /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); if (tty == NULL) { rtems_semaphore_release (rtems_termios_ttyMutex); 108184: 83 ec 0c sub $0xc,%esp 108187: eb 30 jmp 1081b9 return RTEMS_NO_MEMORY; } /* * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; 108189: a1 74 30 12 00 mov 0x123074,%eax 10818e: 89 42 64 mov %eax,0x64(%edx) tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size); 108191: 8b 42 64 mov 0x64(%edx),%eax 108194: 83 ec 0c sub $0xc,%esp 108197: 50 push %eax 108198: 89 55 e0 mov %edx,-0x20(%ebp) 10819b: e8 74 f4 ff ff call 107614 1081a0: 89 c7 mov %eax,%edi 1081a2: 8b 55 e0 mov -0x20(%ebp),%edx 1081a5: 89 42 58 mov %eax,0x58(%edx) if (tty->rawInBuf.theBuf == NULL) { 1081a8: 83 c4 10 add $0x10,%esp 1081ab: 85 c0 test %eax,%eax 1081ad: 75 24 jne 1081d3 free(tty); 1081af: 83 ec 0c sub $0xc,%esp 1081b2: 52 push %edx 1081b3: e8 c0 f1 ff ff call 107378 rtems_semaphore_release (rtems_termios_ttyMutex); 1081b8: 5b pop %ebx 1081b9: ff 35 3c 52 12 00 pushl 0x12523c 1081bf: e8 e4 20 00 00 call 10a2a8 return RTEMS_NO_MEMORY; 1081c4: 83 c4 10 add $0x10,%esp 1081c7: c7 45 e4 1a 00 00 00 movl $0x1a,-0x1c(%ebp) 1081ce: e9 5b 03 00 00 jmp 10852e } /* * allocate raw output buffer */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; 1081d3: a1 78 30 12 00 mov 0x123078,%eax 1081d8: 89 82 88 00 00 00 mov %eax,0x88(%edx) tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size); 1081de: 8b 82 88 00 00 00 mov 0x88(%edx),%eax 1081e4: 83 ec 0c sub $0xc,%esp 1081e7: 50 push %eax 1081e8: 89 55 e0 mov %edx,-0x20(%ebp) 1081eb: e8 24 f4 ff ff call 107614 1081f0: 8b 55 e0 mov -0x20(%ebp),%edx 1081f3: 89 42 7c mov %eax,0x7c(%edx) if (tty->rawOutBuf.theBuf == NULL) { 1081f6: 83 c4 10 add $0x10,%esp 1081f9: 85 c0 test %eax,%eax 1081fb: 75 05 jne 108202 <== ALWAYS TAKEN free((void *)(tty->rawInBuf.theBuf)); 1081fd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108200: eb 2e jmp 108230 <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); 108202: 83 ec 0c sub $0xc,%esp 108205: ff 35 70 30 12 00 pushl 0x123070 10820b: 89 55 e0 mov %edx,-0x20(%ebp) 10820e: 89 45 dc mov %eax,-0x24(%ebp) 108211: e8 fe f3 ff ff call 107614 108216: 8b 55 e0 mov -0x20(%ebp),%edx 108219: 89 42 1c mov %eax,0x1c(%edx) if (tty->cbuf == NULL) { 10821c: 83 c4 10 add $0x10,%esp 10821f: 85 c0 test %eax,%eax 108221: 8b 4d dc mov -0x24(%ebp),%ecx 108224: 75 19 jne 10823f free((void *)(tty->rawOutBuf.theBuf)); 108226: 83 ec 0c sub $0xc,%esp 108229: 51 push %ecx 10822a: e8 49 f1 ff ff call 107378 free((void *)(tty->rawInBuf.theBuf)); 10822f: 59 pop %ecx 108230: 57 push %edi 108231: e8 42 f1 ff ff call 107378 free(tty); 108236: 5a pop %edx 108237: 8b 55 e0 mov -0x20(%ebp),%edx 10823a: e9 73 ff ff ff jmp 1081b2 return RTEMS_NO_MEMORY; } /* * Initialize wakeup callbacks */ tty->tty_snd.sw_pfn = NULL; 10823f: c7 82 d4 00 00 00 00 movl $0x0,0xd4(%edx) 108246: 00 00 00 tty->tty_snd.sw_arg = NULL; 108249: c7 82 d8 00 00 00 00 movl $0x0,0xd8(%edx) 108250: 00 00 00 tty->tty_rcv.sw_pfn = NULL; 108253: c7 82 dc 00 00 00 00 movl $0x0,0xdc(%edx) 10825a: 00 00 00 tty->tty_rcv.sw_arg = NULL; 10825d: c7 82 e0 00 00 00 00 movl $0x0,0xe0(%edx) 108264: 00 00 00 tty->tty_rcvwakeup = 0; 108267: c7 82 e4 00 00 00 00 movl $0x0,0xe4(%edx) 10826e: 00 00 00 /* * link tty */ tty->forw = rtems_termios_ttyHead; 108271: 89 32 mov %esi,(%edx) tty->back = NULL; 108273: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) if (rtems_termios_ttyHead != NULL) 10827a: 85 f6 test %esi,%esi 10827c: 74 03 je 108281 rtems_termios_ttyHead->back = tty; 10827e: 89 56 04 mov %edx,0x4(%esi) rtems_termios_ttyHead = tty; 108281: 89 1d 44 52 12 00 mov %ebx,0x125244 if (rtems_termios_ttyTail == NULL) 108287: 83 3d 40 52 12 00 00 cmpl $0x0,0x125240 10828e: 75 06 jne 108296 rtems_termios_ttyTail = tty; 108290: 89 1d 40 52 12 00 mov %ebx,0x125240 tty->minor = minor; 108296: 8b 45 0c mov 0xc(%ebp),%eax 108299: 89 43 10 mov %eax,0x10(%ebx) tty->major = major; 10829c: 8b 4d 08 mov 0x8(%ebp),%ecx 10829f: 89 4b 0c mov %ecx,0xc(%ebx) /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 1082a2: 83 ec 0c sub $0xc,%esp 1082a5: 8d 43 14 lea 0x14(%ebx),%eax 1082a8: 50 push %eax 1082a9: 6a 00 push $0x0 1082ab: 6a 54 push $0x54 1082ad: 6a 01 push $0x1 rtems_build_name ('T', 'R', 'i', c), 1082af: 0f be 05 7c 30 12 00 movsbl 0x12307c,%eax tty->major = major; /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 1082b6: 0d 00 69 52 54 or $0x54526900,%eax 1082bb: 50 push %eax 1082bc: 89 55 e0 mov %edx,-0x20(%ebp) 1082bf: e8 d0 1c 00 00 call 109f94 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) 1082c4: 83 c4 20 add $0x20,%esp 1082c7: 85 c0 test %eax,%eax 1082c9: 8b 55 e0 mov -0x20(%ebp),%edx 1082cc: 0f 85 42 02 00 00 jne 108514 rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 1082d2: 83 ec 0c sub $0xc,%esp 1082d5: 8d 43 18 lea 0x18(%ebx),%eax 1082d8: 50 push %eax 1082d9: 6a 00 push $0x0 1082db: 6a 54 push $0x54 1082dd: 6a 01 push $0x1 rtems_build_name ('T', 'R', 'o', c), 1082df: 0f be 05 7c 30 12 00 movsbl 0x12307c,%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 ( 1082e6: 0d 00 6f 52 54 or $0x54526f00,%eax 1082eb: 50 push %eax 1082ec: 89 55 e0 mov %edx,-0x20(%ebp) 1082ef: e8 a0 1c 00 00 call 109f94 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) 1082f4: 83 c4 20 add $0x20,%esp 1082f7: 85 c0 test %eax,%eax 1082f9: 8b 55 e0 mov -0x20(%ebp),%edx 1082fc: 0f 85 12 02 00 00 jne 108514 rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 108302: 83 ec 0c sub $0xc,%esp 108305: 8d 83 8c 00 00 00 lea 0x8c(%ebx),%eax 10830b: 50 push %eax 10830c: 6a 00 push $0x0 10830e: 6a 20 push $0x20 108310: 6a 00 push $0x0 rtems_build_name ('T', 'R', 'x', c), 108312: 0f be 05 7c 30 12 00 movsbl 0x12307c,%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 ( 108319: 0d 00 78 52 54 or $0x54527800,%eax 10831e: 50 push %eax 10831f: 89 55 e0 mov %edx,-0x20(%ebp) 108322: e8 6d 1c 00 00 call 109f94 rtems_build_name ('T', 'R', 'x', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO, RTEMS_NO_PRIORITY, &tty->rawOutBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 108327: 83 c4 20 add $0x20,%esp 10832a: 85 c0 test %eax,%eax 10832c: 8b 55 e0 mov -0x20(%ebp),%edx 10832f: 0f 85 df 01 00 00 jne 108514 rtems_fatal_error_occurred (sc); tty->rawOutBufState = rob_idle; 108335: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx) 10833c: 00 00 00 /* * Set callbacks */ tty->device = *callbacks; 10833f: 8d bb 98 00 00 00 lea 0x98(%ebx),%edi 108345: b9 08 00 00 00 mov $0x8,%ecx 10834a: 8b 75 14 mov 0x14(%ebp),%esi 10834d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 10834f: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 108356: 75 74 jne 1083cc sc = rtems_task_create ( 108358: 50 push %eax 108359: 50 push %eax 10835a: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax 108360: 50 push %eax 108361: 6a 00 push $0x0 108363: 68 00 05 00 00 push $0x500 108368: 68 00 04 00 00 push $0x400 10836d: 6a 0a push $0xa rtems_build_name ('T', 'x', 'T', c), 10836f: 0f be 05 7c 30 12 00 movsbl 0x12307c,%eax /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { sc = rtems_task_create ( 108376: 0d 00 54 78 54 or $0x54785400,%eax 10837b: 50 push %eax 10837c: 89 55 e0 mov %edx,-0x20(%ebp) 10837f: e8 b4 1f 00 00 call 10a338 TERMIOS_TXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->txTaskId); if (sc != RTEMS_SUCCESSFUL) 108384: 83 c4 20 add $0x20,%esp 108387: 85 c0 test %eax,%eax 108389: 8b 55 e0 mov -0x20(%ebp),%edx 10838c: 0f 85 82 01 00 00 jne 108514 <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_task_create ( 108392: 57 push %edi 108393: 57 push %edi 108394: 8d 83 c4 00 00 00 lea 0xc4(%ebx),%eax 10839a: 50 push %eax 10839b: 6a 00 push $0x0 10839d: 68 00 05 00 00 push $0x500 1083a2: 68 00 04 00 00 push $0x400 1083a7: 6a 09 push $0x9 rtems_build_name ('R', 'x', 'T', c), 1083a9: 0f be 05 7c 30 12 00 movsbl 0x12307c,%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 ( 1083b0: 0d 00 54 78 52 or $0x52785400,%eax 1083b5: 50 push %eax 1083b6: 89 55 e0 mov %edx,-0x20(%ebp) 1083b9: e8 7a 1f 00 00 call 10a338 TERMIOS_RXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->rxTaskId); if (sc != RTEMS_SUCCESSFUL) 1083be: 83 c4 20 add $0x20,%esp 1083c1: 85 c0 test %eax,%eax 1083c3: 8b 55 e0 mov -0x20(%ebp),%edx 1083c6: 0f 85 48 01 00 00 jne 108514 <== NEVER TAKEN rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || 1083cc: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx) 1083d3: 74 09 je 1083de 1083d5: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 1083dc: 75 30 jne 10840e (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 1083de: 83 ec 0c sub $0xc,%esp 1083e1: 8d 43 68 lea 0x68(%ebx),%eax 1083e4: 50 push %eax 1083e5: 6a 00 push $0x0 1083e7: 6a 24 push $0x24 1083e9: 6a 00 push $0x0 rtems_build_name ('T', 'R', 'r', c), 1083eb: 0f be 05 7c 30 12 00 movsbl 0x12307c,%eax rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 1083f2: 0d 00 72 52 54 or $0x54527200,%eax 1083f7: 50 push %eax 1083f8: 89 55 e0 mov %edx,-0x20(%ebp) 1083fb: e8 94 1b 00 00 call 109f94 rtems_build_name ('T', 'R', 'r', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->rawInBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 108400: 83 c4 20 add $0x20,%esp 108403: 85 c0 test %eax,%eax 108405: 8b 55 e0 mov -0x20(%ebp),%edx 108408: 0f 85 06 01 00 00 jne 108514 } /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; 10840e: c7 43 30 02 25 00 00 movl $0x2502,0x30(%ebx) tty->termios.c_oflag = OPOST | ONLCR | XTABS; 108415: c7 43 34 05 18 00 00 movl $0x1805,0x34(%ebx) tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; 10841c: c7 43 38 bd 08 00 00 movl $0x8bd,0x38(%ebx) tty->termios.c_lflag = 108423: c7 43 3c 3b 82 00 00 movl $0x823b,0x3c(%ebx) ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL; tty->termios.c_cc[VINTR] = '\003'; 10842a: c6 43 41 03 movb $0x3,0x41(%ebx) tty->termios.c_cc[VQUIT] = '\034'; 10842e: c6 43 42 1c movb $0x1c,0x42(%ebx) tty->termios.c_cc[VERASE] = '\177'; 108432: c6 43 43 7f movb $0x7f,0x43(%ebx) tty->termios.c_cc[VKILL] = '\025'; 108436: c6 43 44 15 movb $0x15,0x44(%ebx) tty->termios.c_cc[VEOF] = '\004'; 10843a: c6 43 45 04 movb $0x4,0x45(%ebx) tty->termios.c_cc[VEOL] = '\000'; 10843e: c6 43 4c 00 movb $0x0,0x4c(%ebx) tty->termios.c_cc[VEOL2] = '\000'; 108442: c6 43 51 00 movb $0x0,0x51(%ebx) tty->termios.c_cc[VSTART] = '\021'; 108446: c6 43 49 11 movb $0x11,0x49(%ebx) tty->termios.c_cc[VSTOP] = '\023'; 10844a: c6 43 4a 13 movb $0x13,0x4a(%ebx) tty->termios.c_cc[VSUSP] = '\032'; 10844e: c6 43 4b 1a movb $0x1a,0x4b(%ebx) tty->termios.c_cc[VREPRINT] = '\022'; 108452: c6 43 4d 12 movb $0x12,0x4d(%ebx) tty->termios.c_cc[VDISCARD] = '\017'; 108456: c6 43 4e 0f movb $0xf,0x4e(%ebx) tty->termios.c_cc[VWERASE] = '\027'; 10845a: c6 43 4f 17 movb $0x17,0x4f(%ebx) tty->termios.c_cc[VLNEXT] = '\026'; 10845e: c6 43 50 16 movb $0x16,0x50(%ebx) /* start with no flow control, clear flow control flags */ tty->flow_ctrl = 0; 108462: c7 83 b8 00 00 00 00 movl $0x0,0xb8(%ebx) 108469: 00 00 00 /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2; 10846c: 8b 43 64 mov 0x64(%ebx),%eax 10846f: d1 e8 shr %eax 108471: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) tty->highwater = tty->rawInBuf.Size * 3/4; 108477: 8b 43 64 mov 0x64(%ebx),%eax 10847a: 8d 04 40 lea (%eax,%eax,2),%eax 10847d: c1 e8 02 shr $0x2,%eax 108480: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx) /* * Bump name characer */ if (c++ == 'z') 108486: a0 7c 30 12 00 mov 0x12307c,%al 10848b: 8d 48 01 lea 0x1(%eax),%ecx 10848e: 88 0d 7c 30 12 00 mov %cl,0x12307c 108494: 3c 7a cmp $0x7a,%al 108496: 75 07 jne 10849f c = 'a'; 108498: c6 05 7c 30 12 00 61 movb $0x61,0x12307c } args->iop->data1 = tty; 10849f: 8b 4d 10 mov 0x10(%ebp),%ecx 1084a2: 8b 01 mov (%ecx),%eax 1084a4: 89 50 34 mov %edx,0x34(%eax) if (!tty->refcount++) { 1084a7: 8b 42 08 mov 0x8(%edx),%eax 1084aa: 8d 48 01 lea 0x1(%eax),%ecx 1084ad: 89 4a 08 mov %ecx,0x8(%edx) 1084b0: 85 c0 test %eax,%eax 1084b2: 75 69 jne 10851d if (tty->device.firstOpen) 1084b4: 8b 82 98 00 00 00 mov 0x98(%edx),%eax 1084ba: 85 c0 test %eax,%eax 1084bc: 74 15 je 1084d3 (*tty->device.firstOpen)(major, minor, arg); 1084be: 56 push %esi 1084bf: ff 75 10 pushl 0x10(%ebp) 1084c2: ff 75 0c pushl 0xc(%ebp) 1084c5: ff 75 08 pushl 0x8(%ebp) 1084c8: 89 55 e0 mov %edx,-0x20(%ebp) 1084cb: ff d0 call *%eax 1084cd: 83 c4 10 add $0x10,%esp 1084d0: 8b 55 e0 mov -0x20(%ebp),%edx /* * start I/O tasks, if needed */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 1084d3: 83 ba b4 00 00 00 02 cmpl $0x2,0xb4(%edx) 1084da: 75 41 jne 10851d sc = rtems_task_start( 1084dc: 53 push %ebx 1084dd: 52 push %edx 1084de: 68 fe 95 10 00 push $0x1095fe 1084e3: ff b2 c4 00 00 00 pushl 0xc4(%edx) 1084e9: 89 55 e0 mov %edx,-0x20(%ebp) 1084ec: e8 bb 20 00 00 call 10a5ac tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 1084f1: 83 c4 10 add $0x10,%esp 1084f4: 85 c0 test %eax,%eax 1084f6: 8b 55 e0 mov -0x20(%ebp),%edx 1084f9: 75 19 jne 108514 <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_task_start( 1084fb: 51 push %ecx 1084fc: 52 push %edx 1084fd: 68 30 98 10 00 push $0x109830 108502: ff b2 c8 00 00 00 pushl 0xc8(%edx) 108508: e8 9f 20 00 00 call 10a5ac tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 10850d: 83 c4 10 add $0x10,%esp 108510: 85 c0 test %eax,%eax 108512: 74 09 je 10851d <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 108514: 83 ec 0c sub $0xc,%esp 108517: 50 push %eax 108518: e8 6b 22 00 00 call 10a788 } } rtems_semaphore_release (rtems_termios_ttyMutex); 10851d: 83 ec 0c sub $0xc,%esp 108520: ff 35 3c 52 12 00 pushl 0x12523c 108526: e8 7d 1d 00 00 call 10a2a8 return RTEMS_SUCCESSFUL; 10852b: 83 c4 10 add $0x10,%esp } 10852e: 8b 45 e4 mov -0x1c(%ebp),%eax 108531: 8d 65 f4 lea -0xc(%ebp),%esp 108534: 5b pop %ebx 108535: 5e pop %esi 108536: 5f pop %edi 108537: c9 leave 108538: c3 ret static char c = 'a'; /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); 108539: 52 push %edx 10853a: 52 push %edx 10853b: 68 e8 00 00 00 push $0xe8 108540: 6a 01 push $0x1 108542: e8 c5 ec ff ff call 10720c 108547: 89 c2 mov %eax,%edx 108549: 89 c3 mov %eax,%ebx if (tty == NULL) { 10854b: 83 c4 10 add $0x10,%esp 10854e: 85 c0 test %eax,%eax 108550: 0f 85 33 fc ff ff jne 108189 108556: e9 29 fc ff ff jmp 108184 =============================================================================== 00108a52 : * Send characters to device-specific code */ void rtems_termios_puts ( const void *_buf, int len, struct rtems_termios_tty *tty) { 108a52: 55 push %ebp 108a53: 89 e5 mov %esp,%ebp 108a55: 57 push %edi 108a56: 56 push %esi 108a57: 53 push %ebx 108a58: 83 ec 3c sub $0x3c,%esp 108a5b: 8b 45 08 mov 0x8(%ebp),%eax 108a5e: 8b 75 0c mov 0xc(%ebp),%esi 108a61: 8b 5d 10 mov 0x10(%ebp),%ebx const unsigned char *buf = _buf; 108a64: 89 c7 mov %eax,%edi unsigned int newHead; rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { 108a66: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx) 108a6d: 75 1b jne 108a8a (*tty->device.write)(tty->minor, (void *)buf, len); 108a6f: 89 75 10 mov %esi,0x10(%ebp) 108a72: 89 45 0c mov %eax,0xc(%ebp) 108a75: 8b 43 10 mov 0x10(%ebx),%eax 108a78: 89 45 08 mov %eax,0x8(%ebp) 108a7b: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 108a81: 8d 65 f4 lea -0xc(%ebp),%esp 108a84: 5b pop %ebx 108a85: 5e pop %esi 108a86: 5f pop %edi 108a87: 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); 108a88: ff e0 jmp *%eax return; } newHead = tty->rawOutBuf.Head; 108a8a: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 108a90: 89 45 e4 mov %eax,-0x1c(%ebp) while (len) { 108a93: e9 ca 00 00 00 jmp 108b62 * len -= ncopy * * To minimize latency, the memcpy should be done * with interrupts enabled. */ newHead = (newHead + 1) % tty->rawOutBuf.Size; 108a98: 8b 45 e4 mov -0x1c(%ebp),%eax 108a9b: 40 inc %eax 108a9c: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx 108aa2: 31 d2 xor %edx,%edx 108aa4: f7 f1 div %ecx 108aa6: 89 55 c4 mov %edx,-0x3c(%ebp) 108aa9: 89 55 e4 mov %edx,-0x1c(%ebp) rtems_interrupt_disable (level); 108aac: 9c pushf 108aad: fa cli 108aae: 8f 45 d4 popl -0x2c(%ebp) 108ab1: 8b 55 d4 mov -0x2c(%ebp),%edx 108ab4: 8b 4d c4 mov -0x3c(%ebp),%ecx while (newHead == tty->rawOutBuf.Tail) { 108ab7: eb 35 jmp 108aee tty->rawOutBufState = rob_wait; 108ab9: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) 108ac0: 00 00 00 rtems_interrupt_enable (level); 108ac3: 52 push %edx 108ac4: 9d popf sc = rtems_semaphore_obtain( 108ac5: 50 push %eax 108ac6: 6a 00 push $0x0 108ac8: 6a 00 push $0x0 108aca: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 108ad0: 89 4d e0 mov %ecx,-0x20(%ebp) 108ad3: e8 e4 16 00 00 call 10a1bc tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 108ad8: 83 c4 10 add $0x10,%esp 108adb: 85 c0 test %eax,%eax 108add: 8b 4d e0 mov -0x20(%ebp),%ecx 108ae0: 74 09 je 108aeb <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 108ae2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108ae5: 50 push %eax <== NOT EXECUTED 108ae6: e8 9d 1c 00 00 call 10a788 <== NOT EXECUTED rtems_interrupt_disable (level); 108aeb: 9c pushf 108aec: fa cli 108aed: 5a pop %edx * 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) { 108aee: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 108af4: 39 c1 cmp %eax,%ecx 108af6: 74 c1 je 108ab9 108af8: 89 55 d4 mov %edx,-0x2c(%ebp) 108afb: 89 4d c4 mov %ecx,-0x3c(%ebp) 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++; 108afe: 8b 8b 80 00 00 00 mov 0x80(%ebx),%ecx 108b04: 8a 07 mov (%edi),%al 108b06: 8b 53 7c mov 0x7c(%ebx),%edx 108b09: 88 04 0a mov %al,(%edx,%ecx,1) 108b0c: 47 inc %edi tty->rawOutBuf.Head = newHead; 108b0d: 8b 4d c4 mov -0x3c(%ebp),%ecx 108b10: 89 8b 80 00 00 00 mov %ecx,0x80(%ebx) if (tty->rawOutBufState == rob_idle) { 108b16: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) 108b1d: 75 3e jne 108b5d /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { 108b1f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108b25: a8 10 test $0x10,%al 108b27: 75 1b jne 108b44 <== NEVER TAKEN (*tty->device.write)(tty->minor, (char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 108b29: 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, 108b2f: 51 push %ecx 108b30: 6a 01 push $0x1 108b32: 03 43 7c add 0x7c(%ebx),%eax 108b35: 50 push %eax 108b36: ff 73 10 pushl 0x10(%ebx) 108b39: ff 93 a4 00 00 00 call *0xa4(%ebx) 108b3f: 83 c4 10 add $0x10,%esp 108b42: eb 0f jmp 108b53 (char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } else { /* remember that output has been stopped due to flow ctrl*/ tty->flow_ctrl |= FL_OSTOP; 108b44: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108b4a: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 108b4d: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } tty->rawOutBufState = rob_busy; 108b53: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) 108b5a: 00 00 00 } rtems_interrupt_enable (level); 108b5d: ff 75 d4 pushl -0x2c(%ebp) 108b60: 9d popf len--; 108b61: 4e dec %esi if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, (void *)buf, len); return; } newHead = tty->rawOutBuf.Head; while (len) { 108b62: 85 f6 test %esi,%esi 108b64: 0f 85 2e ff ff ff jne 108a98 tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 108b6a: 8d 65 f4 lea -0xc(%ebp),%esp 108b6d: 5b pop %ebx 108b6e: 5e pop %esi 108b6f: 5f pop %edi 108b70: c9 leave 108b71: c3 ret =============================================================================== 00109079 : return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) { 109079: 55 push %ebp 10907a: 89 e5 mov %esp,%ebp 10907c: 57 push %edi 10907d: 56 push %esi 10907e: 53 push %ebx 10907f: 83 ec 40 sub $0x40,%esp 109082: 8b 75 08 mov 0x8(%ebp),%esi rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 109085: 8b 06 mov (%esi),%eax 109087: 8b 58 34 mov 0x34(%eax),%ebx uint32_t count = args->count; 10908a: 8b 46 10 mov 0x10(%esi),%eax 10908d: 89 45 e4 mov %eax,-0x1c(%ebp) char *buffer = args->buffer; 109090: 8b 46 0c mov 0xc(%esi),%eax 109093: 89 45 e0 mov %eax,-0x20(%ebp) rtems_status_code sc; sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 109096: 6a 00 push $0x0 109098: 6a 00 push $0x0 10909a: ff 73 14 pushl 0x14(%ebx) 10909d: e8 1a 11 00 00 call 10a1bc 1090a2: 89 45 dc mov %eax,-0x24(%ebp) if (sc != RTEMS_SUCCESSFUL) 1090a5: 83 c4 10 add $0x10,%esp 1090a8: 85 c0 test %eax,%eax 1090aa: 0f 85 9d 02 00 00 jne 10934d <== NEVER TAKEN return sc; if (rtems_termios_linesw[tty->t_line].l_read != NULL) { 1090b0: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 1090b6: c1 e0 05 shl $0x5,%eax 1090b9: 8b 80 fc 4e 12 00 mov 0x124efc(%eax),%eax 1090bf: 85 c0 test %eax,%eax 1090c1: 74 19 je 1090dc sc = rtems_termios_linesw[tty->t_line].l_read(tty,args); 1090c3: 57 push %edi 1090c4: 57 push %edi 1090c5: 56 push %esi 1090c6: 53 push %ebx 1090c7: ff d0 call *%eax 1090c9: 89 45 dc mov %eax,-0x24(%ebp) tty->tty_rcvwakeup = 0; 1090cc: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 1090d3: 00 00 00 rtems_semaphore_release (tty->isem); 1090d6: 59 pop %ecx 1090d7: e9 66 02 00 00 jmp 109342 return sc; } if (tty->cindex == tty->ccount) { 1090dc: 8b 43 20 mov 0x20(%ebx),%eax 1090df: 39 43 24 cmp %eax,0x24(%ebx) 1090e2: 0f 85 2d 02 00 00 jne 109315 <== NEVER TAKEN tty->cindex = tty->ccount = 0; 1090e8: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) 1090ef: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) tty->read_start_column = tty->column; 1090f6: 8b 43 28 mov 0x28(%ebx),%eax 1090f9: 89 43 2c mov %eax,0x2c(%ebx) if (tty->device.pollRead != NULL && 1090fc: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx) 109103: 0f 84 c4 00 00 00 je 1091cd 109109: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx) 109110: 0f 85 b7 00 00 00 jne 1091cd static rtems_status_code fillBufferPoll (struct rtems_termios_tty *tty) { int n; if (tty->termios.c_lflag & ICANON) { 109116: f6 43 3c 02 testb $0x2,0x3c(%ebx) 10911a: 74 35 je 109151 for (;;) { n = (*tty->device.pollRead)(tty->minor); 10911c: 83 ec 0c sub $0xc,%esp 10911f: ff 73 10 pushl 0x10(%ebx) 109122: ff 93 a0 00 00 00 call *0xa0(%ebx) if (n < 0) { 109128: 83 c4 10 add $0x10,%esp 10912b: 85 c0 test %eax,%eax 10912d: 79 0f jns 10913e rtems_task_wake_after (1); 10912f: 83 ec 0c sub $0xc,%esp 109132: 6a 01 push $0x1 109134: e8 d7 14 00 00 call 10a610 109139: 83 c4 10 add $0x10,%esp 10913c: eb de jmp 10911c } else { if (siproc (n, tty)) 10913e: 0f b6 c0 movzbl %al,%eax 109141: 89 da mov %ebx,%edx 109143: e8 38 fe ff ff call 108f80 109148: 85 c0 test %eax,%eax 10914a: 74 d0 je 10911c 10914c: e9 c4 01 00 00 jmp 109315 } } } else { rtems_interval then, now; then = rtems_clock_get_ticks_since_boot(); 109151: e8 3a 0a 00 00 call 109b90 109156: 89 c7 mov %eax,%edi for (;;) { n = (*tty->device.pollRead)(tty->minor); 109158: 83 ec 0c sub $0xc,%esp 10915b: ff 73 10 pushl 0x10(%ebx) 10915e: ff 93 a0 00 00 00 call *0xa0(%ebx) if (n < 0) { 109164: 83 c4 10 add $0x10,%esp 109167: 85 c0 test %eax,%eax 109169: 79 3d jns 1091a8 if (tty->termios.c_cc[VMIN]) { 10916b: 80 7b 47 00 cmpb $0x0,0x47(%ebx) 10916f: 74 0e je 10917f <== NEVER TAKEN if (tty->termios.c_cc[VTIME] && tty->ccount) { 109171: 80 7b 46 00 cmpb $0x0,0x46(%ebx) 109175: 74 22 je 109199 <== NEVER TAKEN 109177: 83 7b 20 00 cmpl $0x0,0x20(%ebx) 10917b: 74 1c je 109199 10917d: eb 0a jmp 109189 if ((now - then) > tty->vtimeTicks) { break; } } } else { if (!tty->termios.c_cc[VTIME]) 10917f: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED 109183: 0f 84 8c 01 00 00 je 109315 <== NOT EXECUTED break; now = rtems_clock_get_ticks_since_boot(); 109189: e8 02 0a 00 00 call 109b90 if ((now - then) > tty->vtimeTicks) { 10918e: 29 f8 sub %edi,%eax 109190: 3b 43 54 cmp 0x54(%ebx),%eax 109193: 0f 87 7c 01 00 00 ja 109315 break; } } rtems_task_wake_after (1); 109199: 83 ec 0c sub $0xc,%esp 10919c: 6a 01 push $0x1 10919e: e8 6d 14 00 00 call 10a610 1091a3: 83 c4 10 add $0x10,%esp 1091a6: eb b0 jmp 109158 } else { siproc (n, tty); 1091a8: 0f b6 c0 movzbl %al,%eax 1091ab: 89 da mov %ebx,%edx 1091ad: e8 ce fd ff ff call 108f80 if (tty->ccount >= tty->termios.c_cc[VMIN]) 1091b2: 8a 43 47 mov 0x47(%ebx),%al 1091b5: 0f b6 d0 movzbl %al,%edx 1091b8: 39 53 20 cmp %edx,0x20(%ebx) 1091bb: 0f 8d 54 01 00 00 jge 109315 <== NEVER TAKEN break; if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 1091c1: 84 c0 test %al,%al 1091c3: 74 93 je 109158 <== NEVER TAKEN 1091c5: 80 7b 46 00 cmpb $0x0,0x46(%ebx) 1091c9: 74 8d je 109158 <== NEVER TAKEN 1091cb: eb 84 jmp 109151 * Fill the input buffer from the raw input queue */ static rtems_status_code fillBufferQueue (struct rtems_termios_tty *tty) { rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout; 1091cd: 8b 53 74 mov 0x74(%ebx),%edx rtems_status_code sc; int wait = (int)1; 1091d0: bf 01 00 00 00 mov $0x1,%edi 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)( 1091d5: 8d 43 49 lea 0x49(%ebx),%eax 1091d8: 89 45 d0 mov %eax,-0x30(%ebp) 1091db: e9 e6 00 00 00 jmp 1092c6 while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && (tty->ccount < (CBUFSIZE-1))) { unsigned char c; unsigned int newHead; newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size; 1091e0: 8b 43 5c mov 0x5c(%ebx),%eax 1091e3: 8b 4b 64 mov 0x64(%ebx),%ecx 1091e6: 40 inc %eax 1091e7: 31 d2 xor %edx,%edx 1091e9: f7 f1 div %ecx c = tty->rawInBuf.theBuf[newHead]; 1091eb: 8b 43 58 mov 0x58(%ebx),%eax 1091ee: 8a 04 10 mov (%eax,%edx,1),%al 1091f1: 88 45 db mov %al,-0x25(%ebp) tty->rawInBuf.Head = newHead; 1091f4: 89 53 5c mov %edx,0x5c(%ebx) if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) 1091f7: 8b 43 60 mov 0x60(%ebx),%eax 1091fa: 89 45 c4 mov %eax,-0x3c(%ebp) 1091fd: 8b 4b 64 mov 0x64(%ebx),%ecx % tty->rawInBuf.Size) 109200: 8b 43 64 mov 0x64(%ebx),%eax 109203: 89 45 d4 mov %eax,-0x2c(%ebp) 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) 109206: 8b 45 c4 mov -0x3c(%ebp),%eax 109209: 8d 04 01 lea (%ecx,%eax,1),%eax 10920c: 29 d0 sub %edx,%eax % tty->rawInBuf.Size) 10920e: 31 d2 xor %edx,%edx 109210: f7 75 d4 divl -0x2c(%ebp) 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) 109213: 3b 93 bc 00 00 00 cmp 0xbc(%ebx),%edx 109219: 73 74 jae 10928f <== NEVER TAKEN % tty->rawInBuf.Size) < tty->lowwater) { tty->flow_ctrl &= ~FL_IREQXOF; 10921b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109221: 83 e0 fe and $0xfffffffe,%eax 109224: 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)) 10922a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109230: 25 02 02 00 00 and $0x202,%eax 109235: 3d 02 02 00 00 cmp $0x202,%eax 10923a: 75 24 jne 109260 <== ALWAYS TAKEN == (FL_MDXON | FL_ISNTXOF)) && ((tty->rawOutBufState == rob_idle) 10923c: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 109243: 74 0a je 10924f <== NOT EXECUTED || (tty->flow_ctrl & FL_OSTOP))) { 109245: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10924b: a8 20 test $0x20,%al <== NOT EXECUTED 10924d: 74 11 je 109260 <== NOT EXECUTED /* XON should be sent now... */ (*tty->device.write)( 10924f: 52 push %edx <== NOT EXECUTED 109250: 6a 01 push $0x1 <== NOT EXECUTED 109252: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED 109255: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109258: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 10925e: eb 2c jmp 10928c <== NOT EXECUTED tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1); } else if (tty->flow_ctrl & FL_MDRTS) { 109260: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109266: f6 c4 01 test $0x1,%ah 109269: 74 24 je 10928f <== ALWAYS TAKEN tty->flow_ctrl &= ~FL_IRTSOFF; 10926b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109271: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 109274: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* activate RTS line */ if (tty->device.startRemoteTx != NULL) { 10927a: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 109280: 85 c0 test %eax,%eax <== NOT EXECUTED 109282: 74 0b je 10928f <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 109284: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109287: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10928a: ff d0 call *%eax <== NOT EXECUTED 10928c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { 10928f: f6 43 3c 02 testb $0x2,0x3c(%ebx) 109293: 74 12 je 1092a7 <== NEVER TAKEN if (siproc (c, tty)) 109295: 0f b6 45 db movzbl -0x25(%ebp),%eax 109299: 89 da mov %ebx,%edx 10929b: e8 e0 fc ff ff call 108f80 wait = 0; 1092a0: 85 c0 test %eax,%eax 1092a2: 0f 94 c0 sete %al 1092a5: eb 15 jmp 1092bc } else { siproc (c, tty); 1092a7: 0f b6 45 db movzbl -0x25(%ebp),%eax <== NOT EXECUTED 1092ab: 89 da mov %ebx,%edx <== NOT EXECUTED 1092ad: e8 ce fc ff ff call 108f80 <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 1092b2: 0f b6 43 47 movzbl 0x47(%ebx),%eax <== NOT EXECUTED wait = 0; 1092b6: 39 43 20 cmp %eax,0x20(%ebx) <== NOT EXECUTED 1092b9: 0f 9c c0 setl %al <== NOT EXECUTED 1092bc: 0f b6 c0 movzbl %al,%eax 1092bf: f7 d8 neg %eax 1092c1: 21 c7 and %eax,%edi } timeout = tty->rawInBufSemaphoreTimeout; 1092c3: 8b 53 70 mov 0x70(%ebx),%edx while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 1092c6: 8b 4b 5c mov 0x5c(%ebx),%ecx 1092c9: 8b 43 60 mov 0x60(%ebx),%eax 1092cc: 39 c1 cmp %eax,%ecx 1092ce: 74 0f je 1092df (tty->ccount < (CBUFSIZE-1))) { 1092d0: a1 70 30 12 00 mov 0x123070,%eax 1092d5: 48 dec %eax while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 1092d6: 39 43 20 cmp %eax,0x20(%ebx) 1092d9: 0f 8c 01 ff ff ff jl 1091e0 <== ALWAYS TAKEN } /* * Wait for characters */ if ( wait ) { 1092df: 85 ff test %edi,%edi 1092e1: 74 32 je 109315 sc = rtems_semaphore_obtain( 1092e3: 50 push %eax 1092e4: 52 push %edx 1092e5: ff 73 6c pushl 0x6c(%ebx) 1092e8: ff 73 68 pushl 0x68(%ebx) 1092eb: 89 55 cc mov %edx,-0x34(%ebp) 1092ee: e8 c9 0e 00 00 call 10a1bc tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout); if (sc != RTEMS_SUCCESSFUL) 1092f3: 83 c4 10 add $0x10,%esp 1092f6: 85 c0 test %eax,%eax 1092f8: 8b 55 cc mov -0x34(%ebp),%edx 1092fb: 74 c9 je 1092c6 <== ALWAYS TAKEN 1092fd: eb 16 jmp 109315 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { *buffer++ = tty->cbuf[tty->cindex++]; 1092ff: 8b 7b 1c mov 0x1c(%ebx),%edi 109302: 8b 45 e4 mov -0x1c(%ebp),%eax 109305: 8a 04 07 mov (%edi,%eax,1),%al 109308: 88 01 mov %al,(%ecx) 10930a: 41 inc %ecx 10930b: 8b 45 e4 mov -0x1c(%ebp),%eax 10930e: 40 inc %eax 10930f: 89 43 24 mov %eax,0x24(%ebx) count--; 109312: 4a dec %edx 109313: eb 06 jmp 10931b 109315: 8b 55 e4 mov -0x1c(%ebp),%edx 109318: 8b 4d e0 mov -0x20(%ebp),%ecx sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 10931b: 85 d2 test %edx,%edx 10931d: 74 0b je 10932a 10931f: 8b 43 24 mov 0x24(%ebx),%eax 109322: 89 45 e4 mov %eax,-0x1c(%ebp) 109325: 3b 43 20 cmp 0x20(%ebx),%eax 109328: 7c d5 jl 1092ff 10932a: 89 55 e4 mov %edx,-0x1c(%ebp) *buffer++ = tty->cbuf[tty->cindex++]; count--; } args->bytes_moved = args->count - count; 10932d: 8b 46 10 mov 0x10(%esi),%eax 109330: 29 d0 sub %edx,%eax 109332: 89 46 18 mov %eax,0x18(%esi) tty->tty_rcvwakeup = 0; 109335: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10933c: 00 00 00 rtems_semaphore_release (tty->isem); 10933f: 83 ec 0c sub $0xc,%esp 109342: ff 73 14 pushl 0x14(%ebx) 109345: e8 5e 0f 00 00 call 10a2a8 return sc; 10934a: 83 c4 10 add $0x10,%esp } 10934d: 8b 45 dc mov -0x24(%ebp),%eax 109350: 8d 65 f4 lea -0xc(%ebp),%esp 109353: 5b pop %ebx 109354: 5e pop %esi 109355: 5f pop %edi 109356: c9 leave 109357: c3 ret =============================================================================== 00109662 : * 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) { 109662: 55 push %ebp 109663: 89 e5 mov %esp,%ebp 109665: 57 push %edi 109666: 56 push %esi 109667: 53 push %ebx 109668: 83 ec 0c sub $0xc,%esp 10966b: 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)) 10966e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109674: 25 03 04 00 00 and $0x403,%eax 109679: 3d 01 04 00 00 cmp $0x401,%eax 10967e: 75 2c jne 1096ac <== ALWAYS TAKEN == (FL_MDXOF | FL_IREQXOF)) { /* XOFF should be sent now... */ (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1); 109680: 57 push %edi <== NOT EXECUTED 109681: 6a 01 push $0x1 <== NOT EXECUTED 109683: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED 109686: 50 push %eax <== NOT EXECUTED 109687: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10968a: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED rtems_interrupt_disable(level); 109690: 9c pushf <== NOT EXECUTED 109691: fa cli <== NOT EXECUTED 109692: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 109693: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; 109699: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10969f: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 1096a2: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED rtems_interrupt_enable(level); 1096a8: 52 push %edx <== NOT EXECUTED 1096a9: 9d popf <== NOT EXECUTED 1096aa: eb 38 jmp 1096e4 <== NOT EXECUTED nToSend = 1; } else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) { 1096ac: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1096b2: 83 e0 03 and $0x3,%eax 1096b5: 83 f8 02 cmp $0x2,%eax 1096b8: 75 37 jne 1096f1 <== ALWAYS TAKEN * 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); 1096ba: 56 push %esi <== NOT EXECUTED 1096bb: 6a 01 push $0x1 <== NOT EXECUTED 1096bd: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED 1096c0: 50 push %eax <== NOT EXECUTED 1096c1: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1096c4: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED rtems_interrupt_disable(level); 1096ca: 9c pushf <== NOT EXECUTED 1096cb: fa cli <== NOT EXECUTED 1096cc: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 1096cd: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl &= ~FL_ISNTXOF; 1096d3: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1096d9: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 1096dc: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED rtems_interrupt_enable(level); 1096e2: 52 push %edx <== NOT EXECUTED 1096e3: 9d popf <== NOT EXECUTED 1096e4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED nToSend = 1; 1096e7: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 1096ec: e9 35 01 00 00 jmp 109826 <== NOT EXECUTED } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { 1096f1: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 1096f7: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 1096fd: 39 c2 cmp %eax,%edx 1096ff: 75 25 jne 109726 /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); } return 0; 109701: 31 f6 xor %esi,%esi } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { /* * buffer was empty */ if (tty->rawOutBufState == rob_wait) { 109703: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) 10970a: 0f 85 16 01 00 00 jne 109826 <== ALWAYS TAKEN /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 109710: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109713: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED 109719: e8 8a 0b 00 00 call 10a2a8 <== NOT EXECUTED 10971e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109721: e9 00 01 00 00 jmp 109826 <== NOT EXECUTED } return 0; } rtems_interrupt_disable(level); 109726: 9c pushf 109727: fa cli 109728: 58 pop %eax len = tty->t_dqlen; 109729: 8b bb 90 00 00 00 mov 0x90(%ebx),%edi tty->t_dqlen = 0; 10972f: c7 83 90 00 00 00 00 movl $0x0,0x90(%ebx) 109736: 00 00 00 rtems_interrupt_enable(level); 109739: 50 push %eax 10973a: 9d popf newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size; 10973b: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 109741: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx 109747: 8d 04 07 lea (%edi,%eax,1),%eax 10974a: 31 d2 xor %edx,%edx 10974c: f7 f1 div %ecx 10974e: 89 d7 mov %edx,%edi tty->rawOutBuf.Tail = newTail; 109750: 89 93 84 00 00 00 mov %edx,0x84(%ebx) if (tty->rawOutBufState == rob_wait) { 109756: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) 10975d: 75 11 jne 109770 /* * wake up any pending writer task */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 10975f: 83 ec 0c sub $0xc,%esp 109762: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 109768: e8 3b 0b 00 00 call 10a2a8 10976d: 83 c4 10 add $0x10,%esp } if (newTail == tty->rawOutBuf.Head) { 109770: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 109776: 39 c7 cmp %eax,%edi 109778: 75 2a jne 1097a4 /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; 10977a: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx) 109781: 00 00 00 nToSend = 0; /* * check to see if snd wakeup callback was set */ if ( tty->tty_snd.sw_pfn != NULL) { 109784: 8b 83 d4 00 00 00 mov 0xd4(%ebx),%eax if (newTail == tty->rawOutBuf.Head) { /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; nToSend = 0; 10978a: 31 f6 xor %esi,%esi /* * check to see if snd wakeup callback was set */ if ( tty->tty_snd.sw_pfn != NULL) { 10978c: 85 c0 test %eax,%eax 10978e: 0f 84 8c 00 00 00 je 109820 <== ALWAYS TAKEN (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg); 109794: 51 push %ecx <== NOT EXECUTED 109795: 51 push %ecx <== NOT EXECUTED 109796: ff b3 d8 00 00 00 pushl 0xd8(%ebx) <== NOT EXECUTED 10979c: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED 10979f: 52 push %edx <== NOT EXECUTED 1097a0: ff d0 call *%eax <== NOT EXECUTED 1097a2: eb 79 jmp 10981d <== NOT EXECUTED } } /* check, whether output should stop due to received XOFF */ else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF)) 1097a4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1097aa: 25 10 02 00 00 and $0x210,%eax 1097af: 3d 10 02 00 00 cmp $0x210,%eax 1097b4: 75 22 jne 1097d8 <== ALWAYS TAKEN == (FL_MDXON | FL_ORCVXOF)) { /* Buffer not empty, but output stops due to XOFF */ /* set flag, that output has been stopped */ rtems_interrupt_disable(level); 1097b6: 9c pushf <== NOT EXECUTED 1097b7: fa cli <== NOT EXECUTED 1097b8: 5a pop %edx <== NOT EXECUTED tty->flow_ctrl |= FL_OSTOP; 1097b9: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1097bf: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 1097c2: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ 1097c8: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED 1097cf: 00 00 00 rtems_interrupt_enable(level); 1097d2: 52 push %edx <== NOT EXECUTED 1097d3: 9d popf <== NOT EXECUTED nToSend = 0; 1097d4: 31 f6 xor %esi,%esi <== NOT EXECUTED 1097d6: eb 48 jmp 109820 <== NOT EXECUTED } else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) 1097d8: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 1097de: 39 c7 cmp %eax,%edi 1097e0: 76 08 jbe 1097ea nToSend = tty->rawOutBuf.Size - newTail; 1097e2: 8b b3 88 00 00 00 mov 0x88(%ebx),%esi 1097e8: eb 06 jmp 1097f0 else nToSend = tty->rawOutBuf.Head - newTail; 1097ea: 8b b3 80 00 00 00 mov 0x80(%ebx),%esi 1097f0: 29 fe sub %edi,%esi /* 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)) { 1097f2: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1097f8: f6 c4 06 test $0x6,%ah 1097fb: 74 05 je 109802 nToSend = 1; 1097fd: be 01 00 00 00 mov $0x1,%esi } tty->rawOutBufState = rob_busy; /*apm*/ 109802: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) 109809: 00 00 00 (*tty->device.write)( 10980c: 52 push %edx 10980d: 56 push %esi 10980e: 8b 43 7c mov 0x7c(%ebx),%eax 109811: 01 f8 add %edi,%eax 109813: 50 push %eax 109814: ff 73 10 pushl 0x10(%ebx) 109817: ff 93 a4 00 00 00 call *0xa4(%ebx) 10981d: 83 c4 10 add $0x10,%esp tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ 109820: 89 bb 84 00 00 00 mov %edi,0x84(%ebx) } return nToSend; } 109826: 89 f0 mov %esi,%eax 109828: 8d 65 f4 lea -0xc(%ebp),%esp 10982b: 5b pop %ebx 10982c: 5e pop %esi 10982d: 5f pop %edi 10982e: c9 leave 10982f: c3 ret =============================================================================== 001095fe : /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) { 1095fe: 55 push %ebp 1095ff: 89 e5 mov %esp,%ebp 109601: 57 push %edi 109602: 56 push %esi 109603: 53 push %ebx 109604: 83 ec 1c sub $0x1c,%esp 109607: 8b 5d 08 mov 0x8(%ebp),%ebx while (1) { /* * wait for rtems event */ rtems_event_receive( 10960a: 8d 7d e0 lea -0x20(%ebp),%edi if (c != EOF) { /* * pollRead did call enqueue on its own */ c_buf = c; rtems_termios_enqueue_raw_characters ( tty,&c_buf,1); 10960d: 8d 75 e7 lea -0x19(%ebp),%esi while (1) { /* * wait for rtems event */ rtems_event_receive( 109610: 57 push %edi 109611: 6a 00 push $0x0 109613: 6a 02 push $0x2 109615: 6a 03 push $0x3 109617: e8 d8 05 00 00 call 109bf4 (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) { 10961c: 83 c4 10 add $0x10,%esp 10961f: f6 45 e0 01 testb $0x1,-0x20(%ebp) 109623: 74 17 je 10963c <== ALWAYS TAKEN tty->rxTaskId = 0; 109625: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED 10962c: 00 00 00 rtems_task_delete(RTEMS_SELF); 10962f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109632: 6a 00 push $0x0 <== NOT EXECUTED 109634: e8 37 0e 00 00 call 10a470 <== NOT EXECUTED 109639: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * do something */ c = tty->device.pollRead(tty->minor); 10963c: 83 ec 0c sub $0xc,%esp 10963f: ff 73 10 pushl 0x10(%ebx) 109642: ff 93 a0 00 00 00 call *0xa0(%ebx) if (c != EOF) { 109648: 83 c4 10 add $0x10,%esp 10964b: 83 f8 ff cmp $0xffffffff,%eax 10964e: 74 c0 je 109610 /* * pollRead did call enqueue on its own */ c_buf = c; 109650: 88 45 e7 mov %al,-0x19(%ebp) rtems_termios_enqueue_raw_characters ( tty,&c_buf,1); 109653: 50 push %eax 109654: 6a 01 push $0x1 109656: 56 push %esi 109657: 53 push %ebx 109658: e8 16 fd ff ff call 109373 10965d: 83 c4 10 add $0x10,%esp 109660: eb ae jmp 109610 =============================================================================== 00109830 : /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) { 109830: 55 push %ebp 109831: 89 e5 mov %esp,%ebp 109833: 56 push %esi 109834: 53 push %ebx 109835: 83 ec 10 sub $0x10,%esp 109838: 8b 5d 08 mov 0x8(%ebp),%ebx while (1) { /* * wait for rtems event */ rtems_event_receive( 10983b: 8d 75 f4 lea -0xc(%ebp),%esi 10983e: 56 push %esi 10983f: 6a 00 push $0x0 109841: 6a 02 push $0x2 109843: 6a 03 push $0x3 109845: e8 aa 03 00 00 call 109bf4 (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) { 10984a: 83 c4 10 add $0x10,%esp 10984d: f6 45 f4 01 testb $0x1,-0xc(%ebp) 109851: 74 17 je 10986a <== ALWAYS TAKEN tty->txTaskId = 0; 109853: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED 10985a: 00 00 00 rtems_task_delete(RTEMS_SELF); 10985d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109860: 6a 00 push $0x0 <== NOT EXECUTED 109862: e8 09 0c 00 00 call 10a470 <== NOT EXECUTED 109867: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 10986a: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 109870: c1 e0 05 shl $0x5,%eax 109873: 8b 80 08 4f 12 00 mov 0x124f08(%eax),%eax 109879: 85 c0 test %eax,%eax 10987b: 74 09 je 109886 <== ALWAYS TAKEN rtems_termios_linesw[tty->t_line].l_start(tty); 10987d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109880: 53 push %ebx <== NOT EXECUTED 109881: ff d0 call *%eax <== NOT EXECUTED 109883: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * try to push further characters to device */ rtems_termios_refill_transmitter(tty); 109886: 83 ec 0c sub $0xc,%esp 109889: 53 push %ebx 10988a: e8 d3 fd ff ff call 109662 } 10988f: 83 c4 10 add $0x10,%esp 109892: eb aa jmp 10983e =============================================================================== 00108fd2 : rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) { 108fd2: 55 push %ebp 108fd3: 89 e5 mov %esp,%ebp 108fd5: 57 push %edi 108fd6: 56 push %esi 108fd7: 53 push %ebx 108fd8: 83 ec 20 sub $0x20,%esp 108fdb: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 108fde: 8b 03 mov (%ebx),%eax 108fe0: 8b 70 34 mov 0x34(%eax),%esi rtems_status_code sc; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 108fe3: 6a 00 push $0x0 108fe5: 6a 00 push $0x0 108fe7: ff 76 18 pushl 0x18(%esi) 108fea: e8 cd 11 00 00 call 10a1bc 108fef: 89 c7 mov %eax,%edi if (sc != RTEMS_SUCCESSFUL) 108ff1: 83 c4 10 add $0x10,%esp 108ff4: 85 c0 test %eax,%eax 108ff6: 75 77 jne 10906f <== NEVER TAKEN return sc; if (rtems_termios_linesw[tty->t_line].l_write != NULL) { 108ff8: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax 108ffe: c1 e0 05 shl $0x5,%eax 109001: 8b 80 00 4f 12 00 mov 0x124f00(%eax),%eax 109007: 85 c0 test %eax,%eax 109009: 74 0b je 109016 sc = rtems_termios_linesw[tty->t_line].l_write(tty,args); 10900b: 57 push %edi 10900c: 57 push %edi 10900d: 53 push %ebx 10900e: 56 push %esi 10900f: ff d0 call *%eax 109011: 89 c7 mov %eax,%edi rtems_semaphore_release (tty->osem); 109013: 5b pop %ebx 109014: eb 4e jmp 109064 return sc; } if (tty->termios.c_oflag & OPOST) { 109016: f6 46 34 01 testb $0x1,0x34(%esi) 10901a: 74 2f je 10904b <== NEVER TAKEN uint32_t count = args->count; 10901c: 8b 4b 10 mov 0x10(%ebx),%ecx char *buffer = args->buffer; 10901f: 8b 43 0c mov 0xc(%ebx),%eax 109022: 89 45 e4 mov %eax,-0x1c(%ebp) while (count--) 109025: eb 18 jmp 10903f oproc (*buffer++, tty); 109027: 8b 55 e4 mov -0x1c(%ebp),%edx 10902a: 0f b6 02 movzbl (%edx),%eax 10902d: 42 inc %edx 10902e: 89 55 e4 mov %edx,-0x1c(%ebp) 109031: 89 f2 mov %esi,%edx 109033: 89 4d e0 mov %ecx,-0x20(%ebp) 109036: e8 37 fb ff ff call 108b72 10903b: 8b 4d e0 mov -0x20(%ebp),%ecx 10903e: 49 dec %ecx return sc; } if (tty->termios.c_oflag & OPOST) { uint32_t count = args->count; char *buffer = args->buffer; while (count--) 10903f: 85 c9 test %ecx,%ecx 109041: 75 e4 jne 109027 oproc (*buffer++, tty); args->bytes_moved = args->count; 109043: 8b 43 10 mov 0x10(%ebx),%eax 109046: 89 43 18 mov %eax,0x18(%ebx) 109049: eb 16 jmp 109061 } else { rtems_termios_puts (args->buffer, args->count, tty); 10904b: 51 push %ecx <== NOT EXECUTED 10904c: 56 push %esi <== NOT EXECUTED 10904d: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109050: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 109053: e8 fa f9 ff ff call 108a52 <== NOT EXECUTED args->bytes_moved = args->count; 109058: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10905b: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED 10905e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } rtems_semaphore_release (tty->osem); 109061: 83 ec 0c sub $0xc,%esp 109064: ff 76 18 pushl 0x18(%esi) 109067: e8 3c 12 00 00 call 10a2a8 return sc; 10906c: 83 c4 10 add $0x10,%esp } 10906f: 89 f8 mov %edi,%eax 109071: 8d 65 f4 lea -0xc(%ebp),%esp 109074: 5b pop %ebx 109075: 5e pop %esi 109076: 5f pop %edi 109077: c9 leave 109078: c3 ret =============================================================================== 0011648c : */ rtems_status_code rtems_timer_cancel( rtems_id id ) { 11648c: 55 push %ebp 11648d: 89 e5 mov %esp,%ebp 11648f: 83 ec 1c sub $0x1c,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 116492: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 116495: 50 push %eax 116496: ff 75 08 pushl 0x8(%ebp) 116499: 68 1c fa 13 00 push $0x13fa1c 11649e: e8 49 27 00 00 call 118bec <_Objects_Get> switch ( location ) { 1164a3: 83 c4 10 add $0x10,%esp 1164a6: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 1164aa: 75 1e jne 1164ca case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 1164ac: 83 78 38 04 cmpl $0x4,0x38(%eax) 1164b0: 74 0f je 1164c1 <== NEVER TAKEN (void) _Watchdog_Remove( &the_timer->Ticker ); 1164b2: 83 ec 0c sub $0xc,%esp 1164b5: 83 c0 10 add $0x10,%eax 1164b8: 50 push %eax 1164b9: e8 7e 41 00 00 call 11a63c <_Watchdog_Remove> 1164be: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 1164c1: e8 d8 31 00 00 call 11969e <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1164c6: 31 c0 xor %eax,%eax 1164c8: eb 05 jmp 1164cf #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1164ca: b8 04 00 00 00 mov $0x4,%eax } 1164cf: c9 leave 1164d0: c3 ret =============================================================================== 001168ec : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 1168ec: 55 push %ebp 1168ed: 89 e5 mov %esp,%ebp 1168ef: 57 push %edi 1168f0: 56 push %esi 1168f1: 53 push %ebx 1168f2: 83 ec 1c sub $0x1c,%esp 1168f5: 8b 7d 0c mov 0xc(%ebp),%edi Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 1168f8: 8b 35 5c fa 13 00 mov 0x13fa5c,%esi if ( !timer_server ) return RTEMS_INCORRECT_STATE; 1168fe: bb 0e 00 00 00 mov $0xe,%ebx Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) 116903: 85 f6 test %esi,%esi 116905: 0f 84 b1 00 00 00 je 1169bc return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; 11690b: b3 0b mov $0xb,%bl Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 11690d: 80 3d e8 f0 13 00 00 cmpb $0x0,0x13f0e8 116914: 0f 84 a2 00 00 00 je 1169bc <== NEVER TAKEN return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; 11691a: b3 09 mov $0x9,%bl return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) 11691c: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 116920: 0f 84 96 00 00 00 je 1169bc return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 116926: 83 ec 0c sub $0xc,%esp 116929: 57 push %edi 11692a: e8 b5 d6 ff ff call 113fe4 <_TOD_Validate> 11692f: 83 c4 10 add $0x10,%esp return RTEMS_INVALID_CLOCK; 116932: b3 14 mov $0x14,%bl return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 116934: 84 c0 test %al,%al 116936: 0f 84 80 00 00 00 je 1169bc return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 11693c: 83 ec 0c sub $0xc,%esp 11693f: 57 push %edi 116940: e8 37 d6 ff ff call 113f7c <_TOD_To_seconds> 116945: 89 c7 mov %eax,%edi if ( seconds <= _TOD_Seconds_since_epoch() ) 116947: 83 c4 10 add $0x10,%esp 11694a: 3b 05 60 f1 13 00 cmp 0x13f160,%eax 116950: 76 6a jbe 1169bc 116952: 51 push %ecx return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); 116953: 8d 45 e4 lea -0x1c(%ebp),%eax 116956: 50 push %eax 116957: ff 75 08 pushl 0x8(%ebp) 11695a: 68 1c fa 13 00 push $0x13fa1c 11695f: e8 88 22 00 00 call 118bec <_Objects_Get> 116964: 89 c3 mov %eax,%ebx switch ( location ) { 116966: 83 c4 10 add $0x10,%esp 116969: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 11696d: 75 48 jne 1169b7 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 11696f: 83 ec 0c sub $0xc,%esp 116972: 8d 40 10 lea 0x10(%eax),%eax 116975: 50 push %eax 116976: e8 c1 3c 00 00 call 11a63c <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 11697b: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 116982: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) the_watchdog->routine = routine; 116989: 8b 45 10 mov 0x10(%ebp),%eax 11698c: 89 43 2c mov %eax,0x2c(%ebx) the_watchdog->id = id; 11698f: 8b 45 08 mov 0x8(%ebp),%eax 116992: 89 43 30 mov %eax,0x30(%ebx) the_watchdog->user_data = user_data; 116995: 8b 45 14 mov 0x14(%ebp),%eax 116998: 89 43 34 mov %eax,0x34(%ebx) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch(); 11699b: 2b 3d 60 f1 13 00 sub 0x13f160,%edi 1169a1: 89 7b 1c mov %edi,0x1c(%ebx) (*timer_server->schedule_operation)( timer_server, the_timer ); 1169a4: 58 pop %eax 1169a5: 5a pop %edx 1169a6: 53 push %ebx 1169a7: 56 push %esi 1169a8: ff 56 04 call *0x4(%esi) _Thread_Enable_dispatch(); 1169ab: e8 ee 2c 00 00 call 11969e <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1169b0: 83 c4 10 add $0x10,%esp 1169b3: 31 db xor %ebx,%ebx 1169b5: eb 05 jmp 1169bc #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1169b7: bb 04 00 00 00 mov $0x4,%ebx } 1169bc: 89 d8 mov %ebx,%eax 1169be: 8d 65 f4 lea -0xc(%ebp),%esp 1169c1: 5b pop %ebx 1169c2: 5e pop %esi 1169c3: 5f pop %edi 1169c4: c9 leave 1169c5: c3 ret =============================================================================== 0010b17d : static int rtems_verror( rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) { 10b17d: 55 push %ebp 10b17e: 89 e5 mov %esp,%ebp 10b180: 57 push %edi 10b181: 56 push %esi 10b182: 53 push %ebx 10b183: 83 ec 1c sub $0x1c,%esp 10b186: 89 c3 mov %eax,%ebx 10b188: 89 55 e4 mov %edx,-0x1c(%ebp) 10b18b: 89 4d e0 mov %ecx,-0x20(%ebp) int local_errno = 0; int chars_written = 0; rtems_status_code status; if (error_flag & RTEMS_ERROR_PANIC) { 10b18e: a9 00 00 00 20 test $0x20000000,%eax 10b193: 74 2c je 10b1c1 if (rtems_panic_in_progress++) 10b195: a1 68 b3 12 00 mov 0x12b368,%eax 10b19a: 8d 50 01 lea 0x1(%eax),%edx 10b19d: 89 15 68 b3 12 00 mov %edx,0x12b368 10b1a3: 85 c0 test %eax,%eax 10b1a5: 74 0b je 10b1b2 <== ALWAYS TAKEN rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b1a7: a1 b4 b4 12 00 mov 0x12b4b4,%eax <== NOT EXECUTED 10b1ac: 40 inc %eax <== NOT EXECUTED 10b1ad: a3 b4 b4 12 00 mov %eax,0x12b4b4 <== NOT EXECUTED _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) return 0; 10b1b2: 31 f6 xor %esi,%esi if (error_flag & RTEMS_ERROR_PANIC) { if (rtems_panic_in_progress++) _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) 10b1b4: 83 3d 68 b3 12 00 02 cmpl $0x2,0x12b368 10b1bb: 0f 8f da 00 00 00 jg 10b29b <== NEVER TAKEN return 0; } (void) fflush(stdout); /* in case stdout/stderr same */ 10b1c1: 83 ec 0c sub $0xc,%esp 10b1c4: a1 c0 91 12 00 mov 0x1291c0,%eax 10b1c9: ff 70 08 pushl 0x8(%eax) 10b1cc: e8 97 ab 00 00 call 115d68 status = error_flag & ~RTEMS_ERROR_MASK; 10b1d1: 89 df mov %ebx,%edi 10b1d3: 81 e7 ff ff ff 8f and $0x8fffffff,%edi if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 10b1d9: 83 c4 10 add $0x10,%esp rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) { int local_errno = 0; 10b1dc: 31 f6 xor %esi,%esi } (void) fflush(stdout); /* in case stdout/stderr same */ status = error_flag & ~RTEMS_ERROR_MASK; if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 10b1de: 81 e3 00 00 00 40 and $0x40000000,%ebx 10b1e4: 74 07 je 10b1ed local_errno = errno; 10b1e6: e8 e5 a7 00 00 call 1159d0 <__errno> 10b1eb: 8b 30 mov (%eax),%esi #if defined(RTEMS_MULTIPROCESSING) if (_System_state_Is_multiprocessing) fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node); #endif chars_written += vfprintf(stderr, printf_format, arglist); 10b1ed: 53 push %ebx 10b1ee: ff 75 e0 pushl -0x20(%ebp) 10b1f1: ff 75 e4 pushl -0x1c(%ebp) 10b1f4: a1 c0 91 12 00 mov 0x1291c0,%eax 10b1f9: ff 70 0c pushl 0xc(%eax) 10b1fc: e8 03 11 01 00 call 11c304 10b201: 89 c3 mov %eax,%ebx if (status) 10b203: 83 c4 10 add $0x10,%esp 10b206: 85 ff test %edi,%edi 10b208: 74 24 je 10b22e chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); 10b20a: 83 ec 0c sub $0xc,%esp 10b20d: 57 push %edi 10b20e: e8 55 ff ff ff call 10b168 10b213: 83 c4 0c add $0xc,%esp 10b216: 50 push %eax 10b217: 68 93 44 12 00 push $0x124493 10b21c: a1 c0 91 12 00 mov 0x1291c0,%eax 10b221: ff 70 0c pushl 0xc(%eax) 10b224: e8 33 af 00 00 call 11615c #endif chars_written += vfprintf(stderr, printf_format, arglist); if (status) chars_written += 10b229: 01 c3 add %eax,%ebx 10b22b: 83 c4 10 add $0x10,%esp fprintf(stderr, " (status: %s)", rtems_status_text(status)); if (local_errno) { 10b22e: 83 fe 00 cmp $0x0,%esi 10b231: 74 40 je 10b273 if ((local_errno > 0) && *strerror(local_errno)) 10b233: 7e 25 jle 10b25a 10b235: 83 ec 0c sub $0xc,%esp 10b238: 56 push %esi 10b239: e8 be b7 00 00 call 1169fc 10b23e: 83 c4 10 add $0x10,%esp 10b241: 80 38 00 cmpb $0x0,(%eax) 10b244: 74 14 je 10b25a <== NEVER TAKEN chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); 10b246: 83 ec 0c sub $0xc,%esp 10b249: 56 push %esi 10b24a: e8 ad b7 00 00 call 1169fc 10b24f: 83 c4 0c add $0xc,%esp 10b252: 50 push %eax 10b253: 68 a1 44 12 00 push $0x1244a1 10b258: eb 07 jmp 10b261 else chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno); 10b25a: 51 push %ecx 10b25b: 56 push %esi 10b25c: 68 ae 44 12 00 push $0x1244ae 10b261: a1 c0 91 12 00 mov 0x1291c0,%eax 10b266: ff 70 0c pushl 0xc(%eax) 10b269: e8 ee ae 00 00 call 11615c 10b26e: 01 c3 add %eax,%ebx 10b270: 83 c4 10 add $0x10,%esp } chars_written += fprintf(stderr, "\n"); 10b273: 52 push %edx 10b274: 52 push %edx 10b275: 68 10 4c 12 00 push $0x124c10 10b27a: a1 c0 91 12 00 mov 0x1291c0,%eax 10b27f: ff 70 0c pushl 0xc(%eax) 10b282: e8 d5 ae 00 00 call 11615c 10b287: 8d 34 18 lea (%eax,%ebx,1),%esi (void) fflush(stderr); 10b28a: 58 pop %eax 10b28b: a1 c0 91 12 00 mov 0x1291c0,%eax 10b290: ff 70 0c pushl 0xc(%eax) 10b293: e8 d0 aa 00 00 call 115d68 return chars_written; 10b298: 83 c4 10 add $0x10,%esp } 10b29b: 89 f0 mov %esi,%eax 10b29d: 8d 65 f4 lea -0xc(%ebp),%esp 10b2a0: 5b pop %ebx 10b2a1: 5e pop %esi 10b2a2: 5f pop %edi 10b2a3: c9 leave 10b2a4: c3 ret =============================================================================== 00107960 : /* * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) { 107960: 55 push %ebp 107961: 89 e5 mov %esp,%ebp 107963: 57 push %edi 107964: 56 push %esi 107965: 53 push %ebx 107966: 83 ec 3c sub $0x3c,%esp 107969: 89 c3 mov %eax,%ebx 10796b: 89 55 e0 mov %edx,-0x20(%ebp) int c; unsigned int i = 0; unsigned int limit = INT_MAX; int sign = 0; 10796e: 31 f6 xor %esi,%esi static int scanInt(FILE *fp, int *val) { int c; unsigned int i = 0; unsigned int limit = INT_MAX; 107970: c7 45 e4 ff ff ff 7f movl $0x7fffffff,-0x1c(%ebp) */ static int scanInt(FILE *fp, int *val) { int c; unsigned int i = 0; 107977: 31 ff xor %edi,%edi sign = 1; } if (!isdigit(c)) return 0; d = c - '0'; if ((i > (limit / 10)) 107979: 89 7d c4 mov %edi,-0x3c(%ebp) unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 10797c: 8b 43 04 mov 0x4(%ebx),%eax 10797f: 48 dec %eax 107980: 89 43 04 mov %eax,0x4(%ebx) 107983: 85 c0 test %eax,%eax 107985: 79 15 jns 10799c <== ALWAYS TAKEN 107987: 50 push %eax <== NOT EXECUTED 107988: 50 push %eax <== NOT EXECUTED 107989: 53 push %ebx <== NOT EXECUTED 10798a: ff 35 00 4e 12 00 pushl 0x124e00 <== NOT EXECUTED 107990: e8 2f bf 00 00 call 1138c4 <__srget_r> <== NOT EXECUTED 107995: 89 c1 mov %eax,%ecx <== NOT EXECUTED 107997: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10799a: eb 08 jmp 1079a4 <== NOT EXECUTED 10799c: 8b 03 mov (%ebx),%eax 10799e: 0f b6 08 movzbl (%eax),%ecx 1079a1: 40 inc %eax 1079a2: 89 03 mov %eax,(%ebx) if (c == ':') 1079a4: 83 f9 3a cmp $0x3a,%ecx 1079a7: 74 4a je 1079f3 break; if (sign == 0) { 1079a9: 85 f6 test %esi,%esi 1079ab: 75 11 jne 1079be if (c == '-') { sign = -1; limit++; continue; } sign = 1; 1079ad: 66 be 01 00 mov $0x1,%si for (;;) { c = getc(fp); if (c == ':') break; if (sign == 0) { if (c == '-') { 1079b1: 83 f9 2d cmp $0x2d,%ecx 1079b4: 75 08 jne 1079be sign = -1; limit++; 1079b6: ff 45 e4 incl -0x1c(%ebp) c = getc(fp); if (c == ':') break; if (sign == 0) { if (c == '-') { sign = -1; 1079b9: 83 ce ff or $0xffffffff,%esi limit++; continue; 1079bc: eb be jmp 10797c } sign = 1; } if (!isdigit(c)) 1079be: a1 fc 4d 12 00 mov 0x124dfc,%eax 1079c3: f6 44 08 01 04 testb $0x4,0x1(%eax,%ecx,1) 1079c8: 74 41 je 107a0b return 0; d = c - '0'; if ((i > (limit / 10)) 1079ca: 8b 45 e4 mov -0x1c(%ebp),%eax 1079cd: bf 0a 00 00 00 mov $0xa,%edi 1079d2: 31 d2 xor %edx,%edx 1079d4: f7 f7 div %edi 1079d6: 89 55 d4 mov %edx,-0x2c(%ebp) 1079d9: 39 45 c4 cmp %eax,-0x3c(%ebp) 1079dc: 77 2d ja 107a0b } sign = 1; } if (!isdigit(c)) return 0; d = c - '0'; 1079de: 83 e9 30 sub $0x30,%ecx if ((i > (limit / 10)) || ((i == (limit / 10)) && (d > (limit % 10)))) 1079e1: 39 45 c4 cmp %eax,-0x3c(%ebp) 1079e4: 75 04 jne 1079ea 1079e6: 39 d1 cmp %edx,%ecx 1079e8: 77 21 ja 107a0b <== ALWAYS TAKEN return 0; i = i * 10 + d; 1079ea: 6b 7d c4 0a imul $0xa,-0x3c(%ebp),%edi 1079ee: 8d 3c 39 lea (%ecx,%edi,1),%edi 1079f1: eb 86 jmp 107979 1079f3: 8b 7d c4 mov -0x3c(%ebp),%edi } if (sign == 0) return 0; 1079f6: 31 c0 xor %eax,%eax if ((i > (limit / 10)) || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; i = i * 10 + d; } if (sign == 0) 1079f8: 85 f6 test %esi,%esi 1079fa: 74 11 je 107a0d <== NEVER TAKEN return 0; *val = i * sign; 1079fc: 0f af f7 imul %edi,%esi 1079ff: 8b 45 e0 mov -0x20(%ebp),%eax 107a02: 89 30 mov %esi,(%eax) return 1; 107a04: b8 01 00 00 00 mov $0x1,%eax 107a09: eb 02 jmp 107a0d if (!isdigit(c)) return 0; d = c - '0'; if ((i > (limit / 10)) || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; 107a0b: 31 c0 xor %eax,%eax } if (sign == 0) return 0; *val = i * sign; return 1; } 107a0d: 8d 65 f4 lea -0xc(%ebp),%esp 107a10: 5b pop %ebx 107a11: 5e pop %esi 107a12: 5f pop %edi 107a13: c9 leave 107a14: c3 ret =============================================================================== 00107aa0 : FILE *fp, struct group *grp, char *buffer, size_t bufsize ) { 107aa0: 55 push %ebp 107aa1: 89 e5 mov %esp,%ebp 107aa3: 57 push %edi 107aa4: 56 push %esi 107aa5: 53 push %ebx 107aa6: 83 ec 34 sub $0x34,%esp 107aa9: 89 c7 mov %eax,%edi 107aab: 89 d3 mov %edx,%ebx 107aad: 89 4d d4 mov %ecx,-0x2c(%ebp) int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 107ab0: 6a 00 push $0x0 107ab2: 8d 45 08 lea 0x8(%ebp),%eax 107ab5: 50 push %eax 107ab6: 8d 4d d4 lea -0x2c(%ebp),%ecx 107ab9: 89 f8 mov %edi,%eax 107abb: e8 55 ff ff ff call 107a15 107ac0: 83 c4 10 add $0x10,%esp || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &grgid) || !scanString(fp, &grmem, &buffer, &bufsize, 1)) return 0; 107ac3: 31 f6 xor %esi,%esi { int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 107ac5: 85 c0 test %eax,%eax 107ac7: 0f 84 c2 00 00 00 je 107b8f || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) 107acd: 50 push %eax 107ace: 50 push %eax 107acf: 8d 53 04 lea 0x4(%ebx),%edx 107ad2: 6a 00 push $0x0 107ad4: 8d 45 08 lea 0x8(%ebp),%eax 107ad7: 50 push %eax 107ad8: 8d 4d d4 lea -0x2c(%ebp),%ecx 107adb: 89 f8 mov %edi,%eax 107add: e8 33 ff ff ff call 107a15 107ae2: 83 c4 10 add $0x10,%esp 107ae5: 85 c0 test %eax,%eax 107ae7: 0f 84 a2 00 00 00 je 107b8f <== NEVER TAKEN || !scanInt(fp, &grgid) 107aed: 8d 55 e4 lea -0x1c(%ebp),%edx 107af0: 89 f8 mov %edi,%eax 107af2: e8 69 fe ff ff call 107960 107af7: 85 c0 test %eax,%eax 107af9: 0f 84 90 00 00 00 je 107b8f <== NEVER TAKEN || !scanString(fp, &grmem, &buffer, &bufsize, 1)) 107aff: 51 push %ecx 107b00: 51 push %ecx 107b01: 8d 55 e0 lea -0x20(%ebp),%edx 107b04: 6a 01 push $0x1 107b06: 8d 45 08 lea 0x8(%ebp),%eax 107b09: 50 push %eax 107b0a: 8d 4d d4 lea -0x2c(%ebp),%ecx 107b0d: 89 f8 mov %edi,%eax 107b0f: e8 01 ff ff ff call 107a15 107b14: 83 c4 10 add $0x10,%esp 107b17: 85 c0 test %eax,%eax 107b19: 74 74 je 107b8f <== NEVER TAKEN return 0; grp->gr_gid = grgid; 107b1b: 8b 45 e4 mov -0x1c(%ebp),%eax 107b1e: 66 89 43 08 mov %ax,0x8(%ebx) /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 107b22: 8b 4d e0 mov -0x20(%ebp),%ecx 107b25: 89 ca mov %ecx,%edx 107b27: b8 01 00 00 00 mov $0x1,%eax 107b2c: 89 c6 mov %eax,%esi 107b2e: eb 0b jmp 107b3b if(*cp == ',') memcount++; 107b30: 3c 2c cmp $0x2c,%al 107b32: 0f 94 c0 sete %al 107b35: 0f b6 c0 movzbl %al,%eax 107b38: 01 c6 add %eax,%esi grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 107b3a: 42 inc %edx 107b3b: 8a 02 mov (%edx),%al 107b3d: 84 c0 test %al,%al 107b3f: 75 ef jne 107b30 } /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) 107b41: 8d 04 b5 13 00 00 00 lea 0x13(,%esi,4),%eax return 0; 107b48: 31 f6 xor %esi,%esi } /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) 107b4a: 39 45 08 cmp %eax,0x8(%ebp) 107b4d: 72 40 jb 107b8f <== NEVER TAKEN return 0; grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15); 107b4f: 8b 45 d4 mov -0x2c(%ebp),%eax 107b52: 83 c0 0f add $0xf,%eax 107b55: 83 e0 f0 and $0xfffffff0,%eax 107b58: 89 43 0c mov %eax,0xc(%ebx) /* * Fill in pointer array */ grp->gr_mem[0] = grmem; 107b5b: 89 08 mov %ecx,(%eax) } /* * Extract a single group record from the database */ static int scangr( 107b5d: 8b 45 e0 mov -0x20(%ebp),%eax 107b60: 40 inc %eax /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 107b61: ba 01 00 00 00 mov $0x1,%edx 107b66: eb 11 jmp 107b79 if(*cp == ',') { 107b68: 80 f9 2c cmp $0x2c,%cl 107b6b: 75 0b jne 107b78 *cp = '\0'; 107b6d: c6 40 ff 00 movb $0x0,-0x1(%eax) grp->gr_mem[memcount++] = cp + 1; 107b71: 8b 4b 0c mov 0xc(%ebx),%ecx 107b74: 89 04 91 mov %eax,(%ecx,%edx,4) 107b77: 42 inc %edx 107b78: 40 inc %eax /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 107b79: 8a 48 ff mov -0x1(%eax),%cl 107b7c: 84 c9 test %cl,%cl 107b7e: 75 e8 jne 107b68 if(*cp == ',') { *cp = '\0'; grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; 107b80: 8b 43 0c mov 0xc(%ebx),%eax 107b83: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) return 1; 107b8a: be 01 00 00 00 mov $0x1,%esi } 107b8f: 89 f0 mov %esi,%eax 107b91: 8d 65 f4 lea -0xc(%ebp),%esp 107b94: 5b pop %ebx 107b95: 5e pop %esi 107b96: 5f pop %edi 107b97: c9 leave 107b98: c3 ret =============================================================================== 00107b99 : FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) { 107b99: 55 push %ebp 107b9a: 89 e5 mov %esp,%ebp 107b9c: 57 push %edi 107b9d: 56 push %esi 107b9e: 53 push %ebx 107b9f: 83 ec 34 sub $0x34,%esp 107ba2: 89 c6 mov %eax,%esi 107ba4: 89 d3 mov %edx,%ebx 107ba6: 89 4d d4 mov %ecx,-0x2c(%ebp) int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 107ba9: 8d 7d d4 lea -0x2c(%ebp),%edi 107bac: 6a 00 push $0x0 107bae: 8d 45 08 lea 0x8(%ebp),%eax 107bb1: 50 push %eax 107bb2: 89 f9 mov %edi,%ecx 107bb4: 89 f0 mov %esi,%eax 107bb6: e8 5a fe ff ff call 107a15 107bbb: 83 c4 10 add $0x10,%esp || !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; 107bbe: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 107bc5: 85 c0 test %eax,%eax 107bc7: 0f 84 c4 00 00 00 je 107c91 || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) 107bcd: 51 push %ecx 107bce: 51 push %ecx 107bcf: 8d 53 04 lea 0x4(%ebx),%edx 107bd2: 6a 00 push $0x0 107bd4: 8d 45 08 lea 0x8(%ebp),%eax 107bd7: 50 push %eax 107bd8: 89 f9 mov %edi,%ecx 107bda: 89 f0 mov %esi,%eax 107bdc: e8 34 fe ff ff call 107a15 107be1: 83 c4 10 add $0x10,%esp 107be4: 85 c0 test %eax,%eax 107be6: 0f 84 a5 00 00 00 je 107c91 <== NEVER TAKEN || !scanInt(fp, &pwuid) 107bec: 8d 55 e4 lea -0x1c(%ebp),%edx 107bef: 89 f0 mov %esi,%eax 107bf1: e8 6a fd ff ff call 107960 107bf6: 85 c0 test %eax,%eax 107bf8: 0f 84 93 00 00 00 je 107c91 || !scanInt(fp, &pwgid) 107bfe: 8d 55 e0 lea -0x20(%ebp),%edx 107c01: 89 f0 mov %esi,%eax 107c03: e8 58 fd ff ff call 107960 107c08: 85 c0 test %eax,%eax 107c0a: 0f 84 81 00 00 00 je 107c91 || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) 107c10: 52 push %edx 107c11: 52 push %edx 107c12: 8d 53 0c lea 0xc(%ebx),%edx 107c15: 6a 00 push $0x0 107c17: 8d 45 08 lea 0x8(%ebp),%eax 107c1a: 50 push %eax 107c1b: 89 f9 mov %edi,%ecx 107c1d: 89 f0 mov %esi,%eax 107c1f: e8 f1 fd ff ff call 107a15 107c24: 83 c4 10 add $0x10,%esp 107c27: 85 c0 test %eax,%eax 107c29: 74 66 je 107c91 <== NEVER TAKEN || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0) 107c2b: 50 push %eax 107c2c: 50 push %eax 107c2d: 8d 53 10 lea 0x10(%ebx),%edx 107c30: 6a 00 push $0x0 107c32: 8d 45 08 lea 0x8(%ebp),%eax 107c35: 50 push %eax 107c36: 89 f9 mov %edi,%ecx 107c38: 89 f0 mov %esi,%eax 107c3a: e8 d6 fd ff ff call 107a15 107c3f: 83 c4 10 add $0x10,%esp 107c42: 85 c0 test %eax,%eax 107c44: 74 4b je 107c91 <== NEVER TAKEN || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0) 107c46: 51 push %ecx 107c47: 51 push %ecx 107c48: 8d 53 14 lea 0x14(%ebx),%edx 107c4b: 6a 00 push $0x0 107c4d: 8d 45 08 lea 0x8(%ebp),%eax 107c50: 50 push %eax 107c51: 89 f9 mov %edi,%ecx 107c53: 89 f0 mov %esi,%eax 107c55: e8 bb fd ff ff call 107a15 107c5a: 83 c4 10 add $0x10,%esp 107c5d: 85 c0 test %eax,%eax 107c5f: 74 30 je 107c91 <== NEVER TAKEN || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1)) 107c61: 52 push %edx 107c62: 52 push %edx 107c63: 8d 53 18 lea 0x18(%ebx),%edx 107c66: 6a 01 push $0x1 107c68: 8d 45 08 lea 0x8(%ebp),%eax 107c6b: 50 push %eax 107c6c: 89 f9 mov %edi,%ecx 107c6e: 89 f0 mov %esi,%eax 107c70: e8 a0 fd ff ff call 107a15 107c75: 83 c4 10 add $0x10,%esp 107c78: 85 c0 test %eax,%eax 107c7a: 74 15 je 107c91 return 0; pwd->pw_uid = pwuid; 107c7c: 8b 45 e4 mov -0x1c(%ebp),%eax 107c7f: 66 89 43 08 mov %ax,0x8(%ebx) pwd->pw_gid = pwgid; 107c83: 8b 45 e0 mov -0x20(%ebp),%eax 107c86: 66 89 43 0a mov %ax,0xa(%ebx) return 1; 107c8a: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp) } 107c91: 8b 45 d0 mov -0x30(%ebp),%eax 107c94: 8d 65 f4 lea -0xc(%ebp),%esp 107c97: 5b pop %ebx 107c98: 5e pop %esi 107c99: 5f pop %edi 107c9a: c9 leave 107c9b: c3 ret =============================================================================== 0010a948 : #include int sched_get_priority_max( int policy ) { 10a948: 55 push %ebp 10a949: 89 e5 mov %esp,%ebp 10a94b: 83 ec 08 sub $0x8,%esp 10a94e: 8b 4d 08 mov 0x8(%ebp),%ecx switch ( policy ) { 10a951: 83 f9 04 cmp $0x4,%ecx 10a954: 77 0b ja 10a961 10a956: b8 01 00 00 00 mov $0x1,%eax 10a95b: d3 e0 shl %cl,%eax 10a95d: a8 17 test $0x17,%al 10a95f: 75 10 jne 10a971 <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a961: e8 e2 73 00 00 call 111d48 <__errno> 10a966: c7 00 16 00 00 00 movl $0x16,(%eax) 10a96c: 83 c8 ff or $0xffffffff,%eax 10a96f: eb 08 jmp 10a979 } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; 10a971: 0f b6 05 48 22 12 00 movzbl 0x122248,%eax 10a978: 48 dec %eax } 10a979: c9 leave 10a97a: c3 ret =============================================================================== 0010a97c : #include int sched_get_priority_min( int policy ) { 10a97c: 55 push %ebp 10a97d: 89 e5 mov %esp,%ebp 10a97f: 83 ec 08 sub $0x8,%esp 10a982: 8b 4d 08 mov 0x8(%ebp),%ecx switch ( policy ) { 10a985: 83 f9 04 cmp $0x4,%ecx 10a988: 77 11 ja 10a99b 10a98a: ba 01 00 00 00 mov $0x1,%edx 10a98f: d3 e2 shl %cl,%edx default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MINIMUM_PRIORITY; 10a991: b8 01 00 00 00 mov $0x1,%eax int sched_get_priority_min( int policy ) { switch ( policy ) { 10a996: 80 e2 17 and $0x17,%dl 10a999: 75 0e jne 10a9a9 <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a99b: e8 a8 73 00 00 call 111d48 <__errno> 10a9a0: c7 00 16 00 00 00 movl $0x16,(%eax) 10a9a6: 83 c8 ff or $0xffffffff,%eax } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 10a9a9: c9 leave 10a9aa: c3 ret =============================================================================== 0010a9ac : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 10a9ac: 55 push %ebp 10a9ad: 89 e5 mov %esp,%ebp 10a9af: 56 push %esi 10a9b0: 53 push %ebx 10a9b1: 8b 75 08 mov 0x8(%ebp),%esi 10a9b4: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10a9b7: 85 f6 test %esi,%esi 10a9b9: 74 16 je 10a9d1 <== NEVER TAKEN 10a9bb: e8 90 d0 ff ff call 107a50 10a9c0: 39 c6 cmp %eax,%esi 10a9c2: 74 0d je 10a9d1 rtems_set_errno_and_return_minus_one( ESRCH ); 10a9c4: e8 7f 73 00 00 call 111d48 <__errno> 10a9c9: c7 00 03 00 00 00 movl $0x3,(%eax) 10a9cf: eb 0f jmp 10a9e0 if ( !interval ) 10a9d1: 85 db test %ebx,%ebx 10a9d3: 75 10 jne 10a9e5 rtems_set_errno_and_return_minus_one( EINVAL ); 10a9d5: e8 6e 73 00 00 call 111d48 <__errno> 10a9da: c7 00 16 00 00 00 movl $0x16,(%eax) 10a9e0: 83 c8 ff or $0xffffffff,%eax 10a9e3: eb 13 jmp 10a9f8 _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 10a9e5: 50 push %eax 10a9e6: 50 push %eax 10a9e7: 53 push %ebx 10a9e8: ff 35 20 63 12 00 pushl 0x126320 10a9ee: e8 b9 30 00 00 call 10daac <_Timespec_From_ticks> return 0; 10a9f3: 83 c4 10 add $0x10,%esp 10a9f6: 31 c0 xor %eax,%eax } 10a9f8: 8d 65 f8 lea -0x8(%ebp),%esp 10a9fb: 5b pop %ebx 10a9fc: 5e pop %esi 10a9fd: c9 leave 10a9fe: c3 ret =============================================================================== 0010d088 : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 10d088: 55 push %ebp 10d089: 89 e5 mov %esp,%ebp 10d08b: 57 push %edi 10d08c: 56 push %esi 10d08d: 53 push %ebx 10d08e: 83 ec 2c sub $0x2c,%esp 10d091: 8b 75 08 mov 0x8(%ebp),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10d094: a1 a8 af 12 00 mov 0x12afa8,%eax 10d099: 40 inc %eax 10d09a: a3 a8 af 12 00 mov %eax,0x12afa8 va_list arg; mode_t mode; unsigned int value = 0; 10d09f: 31 ff xor %edi,%edi POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10d0a1: 8b 45 0c mov 0xc(%ebp),%eax 10d0a4: 25 00 02 00 00 and $0x200,%eax 10d0a9: 89 45 d4 mov %eax,-0x2c(%ebp) 10d0ac: 74 03 je 10d0b1 va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); 10d0ae: 8b 7d 14 mov 0x14(%ebp),%edi va_end(arg); } status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 10d0b1: 52 push %edx 10d0b2: 52 push %edx 10d0b3: 8d 45 e4 lea -0x1c(%ebp),%eax 10d0b6: 50 push %eax 10d0b7: 56 push %esi 10d0b8: e8 b3 59 00 00 call 112a70 <_POSIX_Semaphore_Name_to_id> 10d0bd: 89 c3 mov %eax,%ebx * and we can just return a pointer to the id. Otherwise we may * need to check to see if this is a "semaphore does not exist" * or some other miscellaneous error on the name. */ if ( status ) { 10d0bf: 83 c4 10 add $0x10,%esp 10d0c2: 85 c0 test %eax,%eax 10d0c4: 74 19 je 10d0df /* * Unless provided a valid name that did not already exist * and we are willing to create then it is an error. */ if ( !( status == ENOENT && (oflag & O_CREAT) ) ) { 10d0c6: 83 f8 02 cmp $0x2,%eax 10d0c9: 75 06 jne 10d0d1 <== NEVER TAKEN 10d0cb: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 10d0cf: 75 59 jne 10d12a _Thread_Enable_dispatch(); 10d0d1: e8 3c 28 00 00 call 10f912 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 10d0d6: e8 69 7f 00 00 call 115044 <__errno> 10d0db: 89 18 mov %ebx,(%eax) 10d0dd: eb 1f jmp 10d0fe /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10d0df: 8b 45 0c mov 0xc(%ebp),%eax 10d0e2: 25 00 0a 00 00 and $0xa00,%eax 10d0e7: 3d 00 0a 00 00 cmp $0xa00,%eax 10d0ec: 75 15 jne 10d103 _Thread_Enable_dispatch(); 10d0ee: e8 1f 28 00 00 call 10f912 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 10d0f3: e8 4c 7f 00 00 call 115044 <__errno> 10d0f8: c7 00 11 00 00 00 movl $0x11,(%eax) 10d0fe: 83 c8 ff or $0xffffffff,%eax 10d101: eb 4a jmp 10d14d 10d103: 50 push %eax } the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); 10d104: 8d 45 dc lea -0x24(%ebp),%eax 10d107: 50 push %eax 10d108: ff 75 e4 pushl -0x1c(%ebp) 10d10b: 68 4c b2 12 00 push $0x12b24c 10d110: e8 d7 1c 00 00 call 10edec <_Objects_Get> 10d115: 89 45 e0 mov %eax,-0x20(%ebp) the_semaphore->open_count += 1; 10d118: ff 40 18 incl 0x18(%eax) _Thread_Enable_dispatch(); 10d11b: e8 f2 27 00 00 call 10f912 <_Thread_Enable_dispatch> _Thread_Enable_dispatch(); 10d120: e8 ed 27 00 00 call 10f912 <_Thread_Enable_dispatch> goto return_id; 10d125: 83 c4 10 add $0x10,%esp 10d128: eb 1d jmp 10d147 /* * At this point, the semaphore does not exist and everything has been * checked. We should go ahead and create a semaphore. */ status =_POSIX_Semaphore_Create_support( 10d12a: 8d 45 e0 lea -0x20(%ebp),%eax 10d12d: 50 push %eax 10d12e: 57 push %edi 10d12f: 6a 00 push $0x0 10d131: 56 push %esi 10d132: e8 05 58 00 00 call 11293c <_POSIX_Semaphore_Create_support> 10d137: 89 c3 mov %eax,%ebx /* * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); 10d139: e8 d4 27 00 00 call 10f912 <_Thread_Enable_dispatch> if ( status == -1 ) 10d13e: 83 c4 10 add $0x10,%esp return SEM_FAILED; 10d141: 83 c8 ff or $0xffffffff,%eax * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); if ( status == -1 ) 10d144: 43 inc %ebx 10d145: 74 06 je 10d14d return_id: #if defined(RTEMS_USE_16_BIT_OBJECT) the_semaphore->Semaphore_id = the_semaphore->Object.id; id = &the_semaphore->Semaphore_id; #else id = (sem_t *)&the_semaphore->Object.id; 10d147: 8b 45 e0 mov -0x20(%ebp),%eax 10d14a: 83 c0 08 add $0x8,%eax #endif return id; } 10d14d: 8d 65 f4 lea -0xc(%ebp),%esp 10d150: 5b pop %ebx 10d151: 5e pop %esi 10d152: 5f pop %edi 10d153: c9 leave 10d154: c3 ret =============================================================================== 0010a820 : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 10a820: 55 push %ebp 10a821: 89 e5 mov %esp,%ebp 10a823: 57 push %edi 10a824: 56 push %esi 10a825: 53 push %ebx 10a826: 83 ec 1c sub $0x1c,%esp 10a829: 8b 5d 08 mov 0x8(%ebp),%ebx 10a82c: 8b 55 0c mov 0xc(%ebp),%edx 10a82f: 8b 45 10 mov 0x10(%ebp),%eax ISR_Level level; if ( oact ) 10a832: 85 c0 test %eax,%eax 10a834: 74 12 je 10a848 *oact = _POSIX_signals_Vectors[ sig ]; 10a836: 6b f3 0c imul $0xc,%ebx,%esi 10a839: 81 c6 fc 78 12 00 add $0x1278fc,%esi 10a83f: b9 03 00 00 00 mov $0x3,%ecx 10a844: 89 c7 mov %eax,%edi 10a846: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !sig ) 10a848: 85 db test %ebx,%ebx 10a84a: 74 0d je 10a859 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10a84c: 8d 43 ff lea -0x1(%ebx),%eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 10a84f: 83 f8 1f cmp $0x1f,%eax 10a852: 77 05 ja 10a859 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 10a854: 83 fb 09 cmp $0x9,%ebx 10a857: 75 10 jne 10a869 rtems_set_errno_and_return_minus_one( EINVAL ); 10a859: e8 6e 77 00 00 call 111fcc <__errno> 10a85e: c7 00 16 00 00 00 movl $0x16,(%eax) 10a864: 83 c8 ff or $0xffffffff,%eax 10a867: eb 57 jmp 10a8c0 * now (signals not posted when SIG_IGN). * + If we are now ignoring a signal that was previously pending, * we clear the pending signal indicator. */ return 0; 10a869: 31 c0 xor %eax,%eax /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 10a86b: 85 d2 test %edx,%edx 10a86d: 74 51 je 10a8c0 <== NEVER TAKEN /* * Unless the user is installing the default signal actions, then * we can just copy the provided sigaction structure into the vectors. */ _ISR_Disable( level ); 10a86f: 9c pushf 10a870: fa cli 10a871: 8f 45 e4 popl -0x1c(%ebp) if ( act->sa_handler == SIG_DFL ) { 10a874: 83 7a 08 00 cmpl $0x0,0x8(%edx) 10a878: 75 1a jne 10a894 _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 10a87a: 6b f3 0c imul $0xc,%ebx,%esi 10a87d: 8d 86 fc 78 12 00 lea 0x1278fc(%esi),%eax 10a883: 81 c6 70 12 12 00 add $0x121270,%esi 10a889: b9 03 00 00 00 mov $0x3,%ecx 10a88e: 89 c7 mov %eax,%edi 10a890: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10a892: eb 26 jmp 10a8ba } else { _POSIX_signals_Clear_process_signals( sig ); 10a894: 83 ec 0c sub $0xc,%esp 10a897: 53 push %ebx 10a898: 89 55 e0 mov %edx,-0x20(%ebp) 10a89b: e8 bc 4e 00 00 call 10f75c <_POSIX_signals_Clear_process_signals> _POSIX_signals_Vectors[ sig ] = *act; 10a8a0: 6b db 0c imul $0xc,%ebx,%ebx 10a8a3: 81 c3 fc 78 12 00 add $0x1278fc,%ebx 10a8a9: b9 03 00 00 00 mov $0x3,%ecx 10a8ae: 8b 55 e0 mov -0x20(%ebp),%edx 10a8b1: 89 df mov %ebx,%edi 10a8b3: 89 d6 mov %edx,%esi 10a8b5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10a8b7: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10a8ba: ff 75 e4 pushl -0x1c(%ebp) 10a8bd: 9d popf * now (signals not posted when SIG_IGN). * + If we are now ignoring a signal that was previously pending, * we clear the pending signal indicator. */ return 0; 10a8be: 31 c0 xor %eax,%eax } 10a8c0: 8d 65 f4 lea -0xc(%ebp),%esp 10a8c3: 5b pop %ebx 10a8c4: 5e pop %esi 10a8c5: 5f pop %edi 10a8c6: c9 leave 10a8c7: c3 ret =============================================================================== 0010abe7 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 10abe7: 55 push %ebp 10abe8: 89 e5 mov %esp,%ebp 10abea: 57 push %edi 10abeb: 56 push %esi 10abec: 53 push %ebx 10abed: 83 ec 3c sub $0x3c,%esp 10abf0: 8b 75 08 mov 0x8(%ebp),%esi 10abf3: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; /* * Error check parameters before disabling interrupts. */ if ( !set ) 10abf6: 85 f6 test %esi,%esi 10abf8: 74 24 je 10ac1e /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; if ( timeout ) { 10abfa: 85 db test %ebx,%ebx 10abfc: 74 30 je 10ac2e if ( !_Timespec_Is_valid( timeout ) ) 10abfe: 83 ec 0c sub $0xc,%esp 10ac01: 53 push %ebx 10ac02: e8 5d 31 00 00 call 10dd64 <_Timespec_Is_valid> 10ac07: 83 c4 10 add $0x10,%esp 10ac0a: 84 c0 test %al,%al 10ac0c: 74 10 je 10ac1e rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 10ac0e: 83 ec 0c sub $0xc,%esp 10ac11: 53 push %ebx 10ac12: e8 a5 31 00 00 call 10ddbc <_Timespec_To_ticks> if ( !interval ) 10ac17: 83 c4 10 add $0x10,%esp 10ac1a: 85 c0 test %eax,%eax 10ac1c: 75 12 jne 10ac30 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10ac1e: e8 51 79 00 00 call 112574 <__errno> 10ac23: c7 00 16 00 00 00 movl $0x16,(%eax) 10ac29: e9 39 01 00 00 jmp 10ad67 /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; 10ac2e: 31 c0 xor %eax,%eax /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 10ac30: 8b 7d 0c mov 0xc(%ebp),%edi 10ac33: 85 ff test %edi,%edi 10ac35: 75 03 jne 10ac3a 10ac37: 8d 7d dc lea -0x24(%ebp),%edi the_thread = _Thread_Executing; 10ac3a: 8b 15 c8 78 12 00 mov 0x1278c8,%edx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10ac40: 8b 8a ec 00 00 00 mov 0xec(%edx),%ecx 10ac46: 89 4d d4 mov %ecx,-0x2c(%ebp) * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 10ac49: 9c pushf 10ac4a: fa cli 10ac4b: 8f 45 d0 popl -0x30(%ebp) if ( *set & api->signals_pending ) { 10ac4e: 8b 1e mov (%esi),%ebx 10ac50: 89 5d c4 mov %ebx,-0x3c(%ebp) 10ac53: 8b 5d d4 mov -0x2c(%ebp),%ebx 10ac56: 8b 8b d4 00 00 00 mov 0xd4(%ebx),%ecx 10ac5c: 85 4d c4 test %ecx,-0x3c(%ebp) 10ac5f: 74 32 je 10ac93 /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending ); 10ac61: 83 ec 0c sub $0xc,%esp 10ac64: 51 push %ecx 10ac65: e8 3e ff ff ff call 10aba8 <_POSIX_signals_Get_lowest> 10ac6a: 89 07 mov %eax,(%edi) _POSIX_signals_Clear_signals( 10ac6c: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ac73: 6a 00 push $0x0 10ac75: 57 push %edi 10ac76: 50 push %eax 10ac77: 53 push %ebx 10ac78: e8 2b 51 00 00 call 10fda8 <_POSIX_signals_Clear_signals> the_info->si_signo, the_info, false, false ); _ISR_Enable( level ); 10ac7d: ff 75 d0 pushl -0x30(%ebp) 10ac80: 9d popf the_info->si_code = SI_USER; 10ac81: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10ac88: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return the_info->si_signo; 10ac8f: 8b 1f mov (%edi),%ebx 10ac91: eb 3d jmp 10acd0 } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 10ac93: 8b 0d f0 7a 12 00 mov 0x127af0,%ecx 10ac99: 85 4d c4 test %ecx,-0x3c(%ebp) 10ac9c: 74 3a je 10acd8 signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending ); 10ac9e: 83 ec 0c sub $0xc,%esp 10aca1: 51 push %ecx 10aca2: e8 01 ff ff ff call 10aba8 <_POSIX_signals_Get_lowest> 10aca7: 89 c3 mov %eax,%ebx _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 10aca9: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10acb0: 6a 01 push $0x1 10acb2: 57 push %edi 10acb3: 50 push %eax 10acb4: ff 75 d4 pushl -0x2c(%ebp) 10acb7: e8 ec 50 00 00 call 10fda8 <_POSIX_signals_Clear_signals> _ISR_Enable( level ); 10acbc: ff 75 d0 pushl -0x30(%ebp) 10acbf: 9d popf the_info->si_signo = signo; 10acc0: 89 1f mov %ebx,(%edi) the_info->si_code = SI_USER; 10acc2: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10acc9: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return signo; 10acd0: 83 c4 20 add $0x20,%esp 10acd3: e9 92 00 00 00 jmp 10ad6a } the_info->si_signo = -1; 10acd8: c7 07 ff ff ff ff movl $0xffffffff,(%edi) 10acde: 8b 0d a0 73 12 00 mov 0x1273a0,%ecx 10ace4: 41 inc %ecx 10ace5: 89 0d a0 73 12 00 mov %ecx,0x1273a0 _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 10aceb: c7 42 44 88 7a 12 00 movl $0x127a88,0x44(%edx) the_thread->Wait.return_code = EINTR; 10acf2: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx) the_thread->Wait.option = *set; 10acf9: 8b 0e mov (%esi),%ecx 10acfb: 89 4a 30 mov %ecx,0x30(%edx) the_thread->Wait.return_argument = the_info; 10acfe: 89 7a 28 mov %edi,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; 10ad01: c7 05 b8 7a 12 00 01 movl $0x1,0x127ab8 10ad08: 00 00 00 _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue ); _ISR_Enable( level ); 10ad0b: ff 75 d0 pushl -0x30(%ebp) 10ad0e: 9d popf _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 10ad0f: 52 push %edx 10ad10: 68 e0 da 10 00 push $0x10dae0 10ad15: 50 push %eax 10ad16: 68 88 7a 12 00 push $0x127a88 10ad1b: e8 e4 2a 00 00 call 10d804 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10ad20: e8 95 26 00 00 call 10d3ba <_Thread_Enable_dispatch> /* * When the thread is set free by a signal, it is need to eliminate * the signal. */ _POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false ); 10ad25: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ad2c: 6a 00 push $0x0 10ad2e: 57 push %edi 10ad2f: ff 37 pushl (%edi) 10ad31: ff 75 d4 pushl -0x2c(%ebp) 10ad34: e8 6f 50 00 00 call 10fda8 <_POSIX_signals_Clear_signals> /* Set errno only if return code is not EINTR or * if EINTR was caused by a signal being caught, which * was not in our set. */ if ( (_Thread_Executing->Wait.return_code != EINTR) 10ad39: 83 c4 20 add $0x20,%esp 10ad3c: a1 c8 78 12 00 mov 0x1278c8,%eax 10ad41: 83 78 34 04 cmpl $0x4,0x34(%eax) 10ad45: 75 10 jne 10ad57 || !(*set & signo_to_mask( the_info->si_signo )) ) { 10ad47: 8b 1f mov (%edi),%ebx 10ad49: 8d 4b ff lea -0x1(%ebx),%ecx 10ad4c: b8 01 00 00 00 mov $0x1,%eax 10ad51: d3 e0 shl %cl,%eax 10ad53: 85 06 test %eax,(%esi) 10ad55: 75 13 jne 10ad6a errno = _Thread_Executing->Wait.return_code; 10ad57: e8 18 78 00 00 call 112574 <__errno> 10ad5c: 8b 15 c8 78 12 00 mov 0x1278c8,%edx 10ad62: 8b 52 34 mov 0x34(%edx),%edx 10ad65: 89 10 mov %edx,(%eax) return -1; 10ad67: 83 cb ff or $0xffffffff,%ebx } return the_info->si_signo; } 10ad6a: 89 d8 mov %ebx,%eax 10ad6c: 8d 65 f4 lea -0xc(%ebp),%esp 10ad6f: 5b pop %ebx 10ad70: 5e pop %esi 10ad71: 5f pop %edi 10ad72: c9 leave 10ad73: c3 ret =============================================================================== 0010ca08 : int sigwait( const sigset_t *set, int *sig ) { 10ca08: 55 push %ebp 10ca09: 89 e5 mov %esp,%ebp 10ca0b: 53 push %ebx 10ca0c: 83 ec 08 sub $0x8,%esp 10ca0f: 8b 5d 0c mov 0xc(%ebp),%ebx int status; status = sigtimedwait( set, NULL, NULL ); 10ca12: 6a 00 push $0x0 10ca14: 6a 00 push $0x0 10ca16: ff 75 08 pushl 0x8(%ebp) 10ca19: e8 45 fe ff ff call 10c863 10ca1e: 89 c2 mov %eax,%edx if ( status != -1 ) { 10ca20: 83 c4 10 add $0x10,%esp 10ca23: 83 f8 ff cmp $0xffffffff,%eax 10ca26: 74 0a je 10ca32 if ( sig ) *sig = status; return 0; 10ca28: 31 c0 xor %eax,%eax int status; status = sigtimedwait( set, NULL, NULL ); if ( status != -1 ) { if ( sig ) 10ca2a: 85 db test %ebx,%ebx 10ca2c: 74 0b je 10ca39 <== NEVER TAKEN *sig = status; 10ca2e: 89 13 mov %edx,(%ebx) 10ca30: eb 07 jmp 10ca39 return 0; } return errno; 10ca32: e8 05 73 00 00 call 113d3c <__errno> 10ca37: 8b 00 mov (%eax),%eax } 10ca39: 8b 5d fc mov -0x4(%ebp),%ebx 10ca3c: c9 leave 10ca3d: c3 ret =============================================================================== 00108f80 : /* * Process input character, with semaphore. */ static int siproc (unsigned char c, struct rtems_termios_tty *tty) { 108f80: 55 push %ebp 108f81: 89 e5 mov %esp,%ebp 108f83: 56 push %esi 108f84: 53 push %ebx 108f85: 89 d3 mov %edx,%ebx 108f87: 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)) { 108f89: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx) 108f90: 74 30 je 108fc2 <== NEVER TAKEN rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 108f92: 52 push %edx 108f93: 6a 00 push $0x0 108f95: 6a 00 push $0x0 108f97: ff 73 18 pushl 0x18(%ebx) 108f9a: e8 1d 12 00 00 call 10a1bc i = iproc (c, tty); 108f9f: 89 f2 mov %esi,%edx 108fa1: 0f b6 c2 movzbl %dl,%eax 108fa4: 89 da mov %ebx,%edx 108fa6: e8 b5 fe ff ff call 108e60 108fab: 89 c6 mov %eax,%esi rtems_semaphore_release (tty->osem); 108fad: 58 pop %eax 108fae: ff 73 18 pushl 0x18(%ebx) 108fb1: e8 f2 12 00 00 call 10a2a8 108fb6: 83 c4 10 add $0x10,%esp } else { i = iproc (c, tty); } return i; } 108fb9: 89 f0 mov %esi,%eax 108fbb: 8d 65 f8 lea -0x8(%ebp),%esp 108fbe: 5b pop %ebx 108fbf: 5e pop %esi 108fc0: c9 leave 108fc1: c3 ret rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); i = iproc (c, tty); rtems_semaphore_release (tty->osem); } else { i = iproc (c, tty); 108fc2: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 108fc5: 89 da mov %ebx,%edx <== NOT EXECUTED } return i; } 108fc7: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108fca: 5b pop %ebx <== NOT EXECUTED 108fcb: 5e pop %esi <== NOT EXECUTED 108fcc: 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); 108fcd: e9 8e fe ff ff jmp 108e60 <== NOT EXECUTED =============================================================================== 0010a154 : #include int statvfs (const char *path, struct statvfs *sb) { 10a154: 55 push %ebp 10a155: 89 e5 mov %esp,%ebp 10a157: 57 push %edi 10a158: 56 push %esi 10a159: 53 push %ebx 10a15a: 83 ec 38 sub $0x38,%esp 10a15d: 8b 55 08 mov 0x8(%ebp),%edx 10a160: 8b 75 0c mov 0xc(%ebp),%esi * 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 ) ) 10a163: 31 c0 xor %eax,%eax 10a165: 83 c9 ff or $0xffffffff,%ecx 10a168: 89 d7 mov %edx,%edi 10a16a: f2 ae repnz scas %es:(%edi),%al 10a16c: f7 d1 not %ecx 10a16e: 49 dec %ecx 10a16f: 6a 01 push $0x1 10a171: 8d 5d d4 lea -0x2c(%ebp),%ebx 10a174: 53 push %ebx 10a175: 6a 00 push $0x0 10a177: 51 push %ecx 10a178: 52 push %edx 10a179: e8 04 ee ff ff call 108f82 10a17e: 83 c4 20 add $0x20,%esp return -1; 10a181: 83 cf ff or $0xffffffff,%edi * 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 ) ) 10a184: 85 c0 test %eax,%eax 10a186: 75 26 jne 10a1ae <== NEVER TAKEN return -1; mt_entry = loc.mt_entry; 10a188: 8b 55 e4 mov -0x1c(%ebp),%edx fs_mount_root = &mt_entry->mt_fs_root; memset (sb, 0, sizeof (struct statvfs)); 10a18b: b9 0e 00 00 00 mov $0xe,%ecx 10a190: 89 f7 mov %esi,%edi 10a192: f3 ab rep stos %eax,%es:(%edi) result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb ); 10a194: 50 push %eax 10a195: 50 push %eax 10a196: 8b 42 28 mov 0x28(%edx),%eax 10a199: 56 push %esi 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; 10a19a: 83 c2 1c add $0x1c,%edx memset (sb, 0, sizeof (struct statvfs)); result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb ); 10a19d: 52 push %edx 10a19e: ff 50 44 call *0x44(%eax) 10a1a1: 89 c7 mov %eax,%edi rtems_filesystem_freenode( &loc ); 10a1a3: 89 1c 24 mov %ebx,(%esp) 10a1a6: e8 95 ee ff ff call 109040 return result; 10a1ab: 83 c4 10 add $0x10,%esp } 10a1ae: 89 f8 mov %edi,%eax 10a1b0: 8d 65 f4 lea -0xc(%ebp),%esp 10a1b3: 5b pop %ebx 10a1b4: 5e pop %esi 10a1b5: 5f pop %edi 10a1b6: c9 leave 10a1b7: c3 ret =============================================================================== 00108fbc : fdatasync(fn); } /* iterate over all FILE *'s for this thread */ static void sync_per_thread(Thread_Control *t) { 108fbc: 55 push %ebp 108fbd: 89 e5 mov %esp,%ebp 108fbf: 53 push %ebx 108fc0: 83 ec 04 sub $0x4,%esp 108fc3: 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; 108fc6: 8b 88 e4 00 00 00 mov 0xe4(%eax),%ecx if ( this_reent ) { 108fcc: 85 c9 test %ecx,%ecx 108fce: 74 32 je 109002 <== NEVER TAKEN current_reent = _Thread_Executing->libc_reent; 108fd0: 8b 15 68 68 12 00 mov 0x126868,%edx 108fd6: 8b 9a e4 00 00 00 mov 0xe4(%edx),%ebx _Thread_Executing->libc_reent = this_reent; 108fdc: 89 8a e4 00 00 00 mov %ecx,0xe4(%edx) _fwalk (t->libc_reent, sync_wrapper); 108fe2: 52 push %edx 108fe3: 52 push %edx 108fe4: 68 07 90 10 00 push $0x109007 108fe9: ff b0 e4 00 00 00 pushl 0xe4(%eax) 108fef: e8 c4 9e 00 00 call 112eb8 <_fwalk> _Thread_Executing->libc_reent = current_reent; 108ff4: a1 68 68 12 00 mov 0x126868,%eax 108ff9: 89 98 e4 00 00 00 mov %ebx,0xe4(%eax) 108fff: 83 c4 10 add $0x10,%esp } } 109002: 8b 5d fc mov -0x4(%ebp),%ebx 109005: c9 leave 109006: c3 ret =============================================================================== 0010987c : int tcsetattr( int fd, int opt, struct termios *tp ) { 10987c: 55 push %ebp 10987d: 89 e5 mov %esp,%ebp 10987f: 56 push %esi 109880: 53 push %ebx 109881: 8b 5d 08 mov 0x8(%ebp),%ebx 109884: 8b 45 0c mov 0xc(%ebp),%eax 109887: 8b 75 10 mov 0x10(%ebp),%esi switch (opt) { 10988a: 85 c0 test %eax,%eax 10988c: 74 22 je 1098b0 10988e: 48 dec %eax 10988f: 74 0d je 10989e default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 109891: e8 66 92 00 00 call 112afc <__errno> 109896: c7 00 86 00 00 00 movl $0x86,(%eax) 10989c: eb 2a jmp 1098c8 case TCSADRAIN: if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0) 10989e: 50 push %eax 10989f: 6a 00 push $0x0 1098a1: 6a 03 push $0x3 1098a3: 53 push %ebx 1098a4: e8 7b 64 00 00 call 10fd24 1098a9: 83 c4 10 add $0x10,%esp 1098ac: 85 c0 test %eax,%eax 1098ae: 78 18 js 1098c8 <== NEVER TAKEN return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 1098b0: 89 75 10 mov %esi,0x10(%ebp) 1098b3: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp) 1098ba: 89 5d 08 mov %ebx,0x8(%ebp) } } 1098bd: 8d 65 f8 lea -0x8(%ebp),%esp 1098c0: 5b pop %ebx 1098c1: 5e pop %esi 1098c2: c9 leave return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 1098c3: e9 5c 64 00 00 jmp 10fd24 } } 1098c8: 83 c8 ff or $0xffffffff,%eax 1098cb: 8d 65 f8 lea -0x8(%ebp),%esp 1098ce: 5b pop %ebx 1098cf: 5e pop %esi 1098d0: c9 leave 1098d1: c3 ret =============================================================================== 0010a084 : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 10a084: 55 push %ebp 10a085: 89 e5 mov %esp,%ebp 10a087: 56 push %esi 10a088: 53 push %ebx 10a089: 8b 5d 0c mov 0xc(%ebp),%ebx 10a08c: 8b 75 10 mov 0x10(%ebp),%esi POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 10a08f: 83 7d 08 01 cmpl $0x1,0x8(%ebp) 10a093: 75 1d jne 10a0b2 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !timerid ) 10a095: 85 f6 test %esi,%esi 10a097: 74 19 je 10a0b2 /* * The data of the structure evp are checked in order to verify if they * are coherent. */ if (evp != NULL) { 10a099: 85 db test %ebx,%ebx 10a09b: 74 22 je 10a0bf /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 10a09d: 8b 03 mov (%ebx),%eax 10a09f: 48 dec %eax 10a0a0: 83 f8 01 cmp $0x1,%eax 10a0a3: 77 0d ja 10a0b2 <== NEVER TAKEN ( evp->sigev_notify != SIGEV_SIGNAL ) ) { /* The value of the field sigev_notify is not valid */ rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !evp->sigev_signo ) 10a0a5: 8b 43 04 mov 0x4(%ebx),%eax 10a0a8: 85 c0 test %eax,%eax 10a0aa: 74 06 je 10a0b2 <== NEVER TAKEN static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10a0ac: 48 dec %eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 10a0ad: 83 f8 1f cmp $0x1f,%eax 10a0b0: 76 0d jbe 10a0bf <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10a0b2: e8 9d 7c 00 00 call 111d54 <__errno> 10a0b7: c7 00 16 00 00 00 movl $0x16,(%eax) 10a0bd: eb 2f jmp 10a0ee rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a0bf: a1 b4 73 12 00 mov 0x1273b4,%eax 10a0c4: 40 inc %eax 10a0c5: a3 b4 73 12 00 mov %eax,0x1273b4 * the inactive chain of free timer control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void ) { return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information ); 10a0ca: 83 ec 0c sub $0xc,%esp 10a0cd: 68 98 76 12 00 push $0x127698 10a0d2: e8 75 1b 00 00 call 10bc4c <_Objects_Allocate> /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 10a0d7: 83 c4 10 add $0x10,%esp 10a0da: 85 c0 test %eax,%eax 10a0dc: 75 18 jne 10a0f6 _Thread_Enable_dispatch(); 10a0de: e8 47 2a 00 00 call 10cb2a <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 10a0e3: e8 6c 7c 00 00 call 111d54 <__errno> 10a0e8: c7 00 0b 00 00 00 movl $0xb,(%eax) 10a0ee: 83 c8 ff or $0xffffffff,%eax 10a0f1: e9 83 00 00 00 jmp 10a179 } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 10a0f6: c6 40 3c 02 movb $0x2,0x3c(%eax) ptimer->thread_id = _Thread_Executing->Object.id; 10a0fa: 8b 15 dc 78 12 00 mov 0x1278dc,%edx 10a100: 8b 52 08 mov 0x8(%edx),%edx 10a103: 89 50 38 mov %edx,0x38(%eax) if ( evp != NULL ) { 10a106: 85 db test %ebx,%ebx 10a108: 74 11 je 10a11b ptimer->inf.sigev_notify = evp->sigev_notify; 10a10a: 8b 13 mov (%ebx),%edx 10a10c: 89 50 40 mov %edx,0x40(%eax) ptimer->inf.sigev_signo = evp->sigev_signo; 10a10f: 8b 53 04 mov 0x4(%ebx),%edx 10a112: 89 50 44 mov %edx,0x44(%eax) ptimer->inf.sigev_value = evp->sigev_value; 10a115: 8b 53 08 mov 0x8(%ebx),%edx 10a118: 89 50 48 mov %edx,0x48(%eax) } ptimer->overrun = 0; 10a11b: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax) ptimer->timer_data.it_value.tv_sec = 0; 10a122: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) ptimer->timer_data.it_value.tv_nsec = 0; 10a129: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) ptimer->timer_data.it_interval.tv_sec = 0; 10a130: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) ptimer->timer_data.it_interval.tv_nsec = 0; 10a137: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10a13e: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_watchdog->routine = routine; 10a145: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) the_watchdog->id = id; 10a14c: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) the_watchdog->user_data = user_data; 10a153: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10a15a: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10a15d: 0f b7 da movzwl %dx,%ebx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10a160: 8b 0d b4 76 12 00 mov 0x1276b4,%ecx 10a166: 89 04 99 mov %eax,(%ecx,%ebx,4) _Objects_Get_index( the_object->id ), the_object ); /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 10a169: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) _Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL ); _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0); *timerid = ptimer->Object.id; 10a170: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 10a172: e8 b3 29 00 00 call 10cb2a <_Thread_Enable_dispatch> return 0; 10a177: 31 c0 xor %eax,%eax } 10a179: 8d 65 f8 lea -0x8(%ebp),%esp 10a17c: 5b pop %ebx 10a17d: 5e pop %esi 10a17e: c9 leave 10a17f: c3 ret =============================================================================== 0010a180 : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 10a180: 55 push %ebp 10a181: 89 e5 mov %esp,%ebp 10a183: 57 push %edi 10a184: 56 push %esi 10a185: 53 push %ebx 10a186: 83 ec 2c sub $0x2c,%esp 10a189: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; bool activated; uint32_t initial_period; struct itimerspec normalize; if ( !value ) 10a18c: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a190: 0f 84 58 01 00 00 je 10a2ee <== NEVER TAKEN /* * First, it verifies if the structure "value" is correct * if the number of nanoseconds is not correct return EINVAL */ if ( !_Timespec_Is_valid( &(value->it_value) ) ) { 10a196: 83 ec 0c sub $0xc,%esp 10a199: 8b 45 10 mov 0x10(%ebp),%eax 10a19c: 83 c0 08 add $0x8,%eax 10a19f: 50 push %eax 10a1a0: e8 53 33 00 00 call 10d4f8 <_Timespec_Is_valid> 10a1a5: 83 c4 10 add $0x10,%esp 10a1a8: 84 c0 test %al,%al 10a1aa: 0f 84 3e 01 00 00 je 10a2ee rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !_Timespec_Is_valid( &(value->it_interval) ) ) { 10a1b0: 83 ec 0c sub $0xc,%esp 10a1b3: ff 75 10 pushl 0x10(%ebp) 10a1b6: e8 3d 33 00 00 call 10d4f8 <_Timespec_Is_valid> 10a1bb: 83 c4 10 add $0x10,%esp 10a1be: 84 c0 test %al,%al 10a1c0: 0f 84 28 01 00 00 je 10a2ee <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); } if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 10a1c6: 85 db test %ebx,%ebx 10a1c8: 74 09 je 10a1d3 10a1ca: 83 fb 04 cmp $0x4,%ebx 10a1cd: 0f 85 1b 01 00 00 jne 10a2ee rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 10a1d3: 8d 7d cc lea -0x34(%ebp),%edi 10a1d6: b9 04 00 00 00 mov $0x4,%ecx 10a1db: 8b 75 10 mov 0x10(%ebp),%esi 10a1de: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { 10a1e0: 83 fb 04 cmp $0x4,%ebx 10a1e3: 75 2f jne 10a214 struct timespec now; _TOD_Get( &now ); 10a1e5: 83 ec 0c sub $0xc,%esp 10a1e8: 8d 5d dc lea -0x24(%ebp),%ebx 10a1eb: 53 push %ebx 10a1ec: e8 b3 15 00 00 call 10b7a4 <_TOD_Get> /* Check for seconds in the past */ if ( _Timespec_Greater_than( &now, &normalize.it_value ) ) 10a1f1: 59 pop %ecx 10a1f2: 5e pop %esi 10a1f3: 8d 75 d4 lea -0x2c(%ebp),%esi 10a1f6: 56 push %esi 10a1f7: 53 push %ebx 10a1f8: e8 d7 32 00 00 call 10d4d4 <_Timespec_Greater_than> 10a1fd: 83 c4 10 add $0x10,%esp 10a200: 84 c0 test %al,%al 10a202: 0f 85 e6 00 00 00 jne 10a2ee rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value ); 10a208: 52 push %edx 10a209: 56 push %esi 10a20a: 56 push %esi 10a20b: 53 push %ebx 10a20c: e8 0b 33 00 00 call 10d51c <_Timespec_Subtract> 10a211: 83 c4 10 add $0x10,%esp timer_t id, Objects_Locations *location ) { return (POSIX_Timer_Control *) _Objects_Get( &_POSIX_Timer_Information, (Objects_Id) id, location ); 10a214: 50 push %eax /* If the function reaches this point, then it will be necessary to do * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); 10a215: 8d 45 e4 lea -0x1c(%ebp),%eax 10a218: 50 push %eax 10a219: ff 75 08 pushl 0x8(%ebp) 10a21c: 68 98 76 12 00 push $0x127698 10a221: e8 52 1e 00 00 call 10c078 <_Objects_Get> 10a226: 89 c3 mov %eax,%ebx switch ( location ) { 10a228: 83 c4 10 add $0x10,%esp 10a22b: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10a22f: 0f 85 b9 00 00 00 jne 10a2ee case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) { 10a235: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 10a239: 75 3b jne 10a276 10a23b: 83 7d d8 00 cmpl $0x0,-0x28(%ebp) 10a23f: 75 35 jne 10a276 /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 10a241: 83 ec 0c sub $0xc,%esp 10a244: 8d 40 10 lea 0x10(%eax),%eax 10a247: 50 push %eax 10a248: e8 9b 36 00 00 call 10d8e8 <_Watchdog_Remove> /* The old data of the timer are returned */ if ( ovalue ) 10a24d: 83 c4 10 add $0x10,%esp 10a250: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10a254: 74 0d je 10a263 *ovalue = ptimer->timer_data; 10a256: 8d 73 54 lea 0x54(%ebx),%esi 10a259: b9 04 00 00 00 mov $0x4,%ecx 10a25e: 8b 7d 14 mov 0x14(%ebp),%edi 10a261: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* The new data are set */ ptimer->timer_data = normalize; 10a263: 8d 7b 54 lea 0x54(%ebx),%edi 10a266: 8d 75 cc lea -0x34(%ebp),%esi 10a269: b9 04 00 00 00 mov $0x4,%ecx 10a26e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a270: c6 43 3c 04 movb $0x4,0x3c(%ebx) 10a274: eb 35 jmp 10a2ab _Thread_Enable_dispatch(); return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); 10a276: 83 ec 0c sub $0xc,%esp 10a279: ff 75 10 pushl 0x10(%ebp) 10a27c: e8 cf 32 00 00 call 10d550 <_Timespec_To_ticks> 10a281: 89 43 64 mov %eax,0x64(%ebx) initial_period = _Timespec_To_ticks( &normalize.it_value ); 10a284: 8d 45 d4 lea -0x2c(%ebp),%eax 10a287: 89 04 24 mov %eax,(%esp) 10a28a: e8 c1 32 00 00 call 10d550 <_Timespec_To_ticks> activated = _POSIX_Timer_Insert_helper( 10a28f: 89 1c 24 mov %ebx,(%esp) 10a292: 68 04 a3 10 00 push $0x10a304 10a297: ff 73 08 pushl 0x8(%ebx) 10a29a: 50 push %eax 10a29b: 8d 43 10 lea 0x10(%ebx),%eax 10a29e: 50 push %eax 10a29f: e8 78 57 00 00 call 10fa1c <_POSIX_Timer_Insert_helper> initial_period, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 10a2a4: 83 c4 20 add $0x20,%esp 10a2a7: 84 c0 test %al,%al 10a2a9: 75 07 jne 10a2b2 _Thread_Enable_dispatch(); 10a2ab: e8 7a 28 00 00 call 10cb2a <_Thread_Enable_dispatch> 10a2b0: eb 38 jmp 10a2ea /* * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) 10a2b2: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10a2b6: 74 0d je 10a2c5 *ovalue = ptimer->timer_data; 10a2b8: 8d 73 54 lea 0x54(%ebx),%esi 10a2bb: b9 04 00 00 00 mov $0x4,%ecx 10a2c0: 8b 7d 14 mov 0x14(%ebp),%edi 10a2c3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ptimer->timer_data = normalize; 10a2c5: 8d 7b 54 lea 0x54(%ebx),%edi 10a2c8: 8d 75 cc lea -0x34(%ebp),%esi 10a2cb: b9 04 00 00 00 mov $0x4,%ecx 10a2d0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a2d2: c6 43 3c 03 movb $0x3,0x3c(%ebx) _TOD_Get( &ptimer->time ); 10a2d6: 83 ec 0c sub $0xc,%esp 10a2d9: 83 c3 6c add $0x6c,%ebx 10a2dc: 53 push %ebx 10a2dd: e8 c2 14 00 00 call 10b7a4 <_TOD_Get> _Thread_Enable_dispatch(); 10a2e2: e8 43 28 00 00 call 10cb2a <_Thread_Enable_dispatch> return 0; 10a2e7: 83 c4 10 add $0x10,%esp 10a2ea: 31 c0 xor %eax,%eax 10a2ec: eb 0e jmp 10a2fc #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10a2ee: e8 61 7a 00 00 call 111d54 <__errno> 10a2f3: c7 00 16 00 00 00 movl $0x16,(%eax) 10a2f9: 83 c8 ff or $0xffffffff,%eax } 10a2fc: 8d 65 f4 lea -0xc(%ebp),%esp 10a2ff: 5b pop %ebx 10a300: 5e pop %esi 10a301: 5f pop %edi 10a302: c9 leave 10a303: c3 ret =============================================================================== 00109fc0 : useconds_t ualarm( useconds_t useconds, useconds_t interval ) { 109fc0: 55 push %ebp 109fc1: 89 e5 mov %esp,%ebp 109fc3: 57 push %edi 109fc4: 56 push %esi 109fc5: 53 push %ebx 109fc6: 83 ec 1c sub $0x1c,%esp 109fc9: 8b 75 08 mov 0x8(%ebp),%esi /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 109fcc: 83 3d 00 7d 12 00 00 cmpl $0x0,0x127d00 109fd3: 75 2c jne 10a001 <== NEVER TAKEN Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 109fd5: c7 05 ec 7c 12 00 00 movl $0x0,0x127cec 109fdc: 00 00 00 the_watchdog->routine = routine; 109fdf: c7 05 00 7d 12 00 88 movl $0x109f88,0x127d00 109fe6: 9f 10 00 the_watchdog->id = id; 109fe9: c7 05 04 7d 12 00 00 movl $0x0,0x127d04 109ff0: 00 00 00 the_watchdog->user_data = user_data; 109ff3: c7 05 08 7d 12 00 00 movl $0x0,0x127d08 109ffa: 00 00 00 useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 109ffd: 31 db xor %ebx,%ebx 109fff: eb 4f jmp 10a050 if ( !the_timer->routine ) { _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { Watchdog_States state; state = _Watchdog_Remove( the_timer ); 10a001: 83 ec 0c sub $0xc,%esp 10a004: 68 e4 7c 12 00 push $0x127ce4 10a009: e8 c2 34 00 00 call 10d4d0 <_Watchdog_Remove> if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) { 10a00e: 83 e8 02 sub $0x2,%eax 10a011: 83 c4 10 add $0x10,%esp useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 10a014: 31 db xor %ebx,%ebx _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { Watchdog_States state; state = _Watchdog_Remove( the_timer ); if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) { 10a016: 83 f8 01 cmp $0x1,%eax 10a019: 77 35 ja 10a050 <== NEVER TAKEN * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 10a01b: a1 f8 7c 12 00 mov 0x127cf8,%eax 10a020: 03 05 f0 7c 12 00 add 0x127cf0,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 10a026: 57 push %edi 10a027: 57 push %edi 10a028: 8d 55 e0 lea -0x20(%ebp),%edx 10a02b: 52 push %edx * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 10a02c: 2b 05 fc 7c 12 00 sub 0x127cfc,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 10a032: 50 push %eax 10a033: e8 38 30 00 00 call 10d070 <_Timespec_From_ticks> remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 10a038: 69 4d e0 40 42 0f 00 imul $0xf4240,-0x20(%ebp),%ecx remaining += tp.tv_nsec / 1000; 10a03f: 8b 45 e4 mov -0x1c(%ebp),%eax 10a042: bf e8 03 00 00 mov $0x3e8,%edi 10a047: 99 cltd 10a048: f7 ff idiv %edi 10a04a: 8d 1c 08 lea (%eax,%ecx,1),%ebx 10a04d: 83 c4 10 add $0x10,%esp /* * If useconds is non-zero, then the caller wants to schedule * the alarm repeatedly at that interval. If the interval is * less than a single clock tick, then fudge it to a clock tick. */ if ( useconds ) { 10a050: 85 f6 test %esi,%esi 10a052: 74 44 je 10a098 Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 10a054: b9 40 42 0f 00 mov $0xf4240,%ecx 10a059: 89 f0 mov %esi,%eax 10a05b: 31 d2 xor %edx,%edx 10a05d: f7 f1 div %ecx 10a05f: 89 45 e0 mov %eax,-0x20(%ebp) tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 10a062: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx 10a068: 89 55 e4 mov %edx,-0x1c(%ebp) ticks = _Timespec_To_ticks( &tp ); 10a06b: 83 ec 0c sub $0xc,%esp 10a06e: 8d 75 e0 lea -0x20(%ebp),%esi 10a071: 56 push %esi 10a072: e8 55 30 00 00 call 10d0cc <_Timespec_To_ticks> if ( ticks == 0 ) ticks = 1; _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) ); 10a077: 89 34 24 mov %esi,(%esp) 10a07a: e8 4d 30 00 00 call 10d0cc <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10a07f: a3 f0 7c 12 00 mov %eax,0x127cf0 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10a084: 59 pop %ecx 10a085: 5e pop %esi 10a086: 68 e4 7c 12 00 push $0x127ce4 10a08b: 68 d4 74 12 00 push $0x1274d4 10a090: e8 1b 33 00 00 call 10d3b0 <_Watchdog_Insert> 10a095: 83 c4 10 add $0x10,%esp } return remaining; } 10a098: 89 d8 mov %ebx,%eax 10a09a: 8d 65 f4 lea -0xc(%ebp),%esp 10a09d: 5b pop %ebx 10a09e: 5e pop %esi 10a09f: 5f pop %edi 10a0a0: c9 leave 10a0a1: c3 ret =============================================================================== 0010a71c : #include int unlink( const char *path ) { 10a71c: 55 push %ebp 10a71d: 89 e5 mov %esp,%ebp 10a71f: 57 push %edi 10a720: 56 push %esi 10a721: 53 push %ebx 10a722: 83 ec 58 sub $0x58,%esp /* * Get the node to be unlinked. Find the parent path first. */ parentpathlen = rtems_filesystem_dirname ( path ); 10a725: ff 75 08 pushl 0x8(%ebp) 10a728: e8 f6 d8 ff ff call 108023 10a72d: 89 45 b4 mov %eax,-0x4c(%ebp) if ( parentpathlen == 0 ) 10a730: 83 c4 10 add $0x10,%esp 10a733: 85 c0 test %eax,%eax 10a735: 8d 45 d0 lea -0x30(%ebp),%eax 10a738: 75 15 jne 10a74f rtems_filesystem_get_start_loc( path, &i, &parentloc ); 10a73a: 51 push %ecx 10a73b: 50 push %eax 10a73c: 8d 45 e4 lea -0x1c(%ebp),%eax 10a73f: 50 push %eax 10a740: ff 75 08 pushl 0x8(%ebp) 10a743: e8 d4 e6 ff ff call 108e1c 10a748: 83 c4 10 add $0x10,%esp const char *name; rtems_filesystem_location_info_t parentloc; rtems_filesystem_location_info_t loc; int i; int result; bool free_parentloc = false; 10a74b: 31 db xor %ebx,%ebx 10a74d: eb 25 jmp 10a774 parentpathlen = rtems_filesystem_dirname ( path ); if ( parentpathlen == 0 ) rtems_filesystem_get_start_loc( path, &i, &parentloc ); else { result = rtems_filesystem_evaluate_path( path, parentpathlen, 10a74f: 83 ec 0c sub $0xc,%esp 10a752: 6a 00 push $0x0 10a754: 50 push %eax 10a755: 6a 02 push $0x2 10a757: ff 75 b4 pushl -0x4c(%ebp) 10a75a: ff 75 08 pushl 0x8(%ebp) 10a75d: e8 80 d8 ff ff call 107fe2 10a762: 89 c2 mov %eax,%edx RTEMS_LIBIO_PERMS_WRITE, &parentloc, false ); if ( result != 0 ) 10a764: 83 c4 20 add $0x20,%esp return -1; 10a767: 83 c8 ff or $0xffffffff,%eax else { result = rtems_filesystem_evaluate_path( path, parentpathlen, RTEMS_LIBIO_PERMS_WRITE, &parentloc, false ); if ( result != 0 ) 10a76a: 85 d2 test %edx,%edx 10a76c: 0f 85 d6 00 00 00 jne 10a848 <== NEVER TAKEN return -1; free_parentloc = true; 10a772: b3 01 mov $0x1,%bl /* * Start from the parent to find the node that should be under it. */ loc = parentloc; 10a774: 8d 7d bc lea -0x44(%ebp),%edi 10a777: 8d 75 d0 lea -0x30(%ebp),%esi 10a77a: b9 05 00 00 00 mov $0x5,%ecx 10a77f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) name = path + parentpathlen; 10a781: 8b 75 08 mov 0x8(%ebp),%esi 10a784: 03 75 b4 add -0x4c(%ebp),%esi name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 10a787: 83 c9 ff or $0xffffffff,%ecx 10a78a: 89 f7 mov %esi,%edi 10a78c: 31 c0 xor %eax,%eax 10a78e: f2 ae repnz scas %es:(%edi),%al 10a790: f7 d1 not %ecx 10a792: 49 dec %ecx 10a793: 52 push %edx 10a794: 52 push %edx 10a795: 51 push %ecx 10a796: 56 push %esi 10a797: e8 c6 d8 ff ff call 108062 10a79c: 01 c6 add %eax,%esi result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 10a79e: 83 c9 ff or $0xffffffff,%ecx 10a7a1: 89 f7 mov %esi,%edi 10a7a3: 31 c0 xor %eax,%eax 10a7a5: f2 ae repnz scas %es:(%edi),%al 10a7a7: f7 d1 not %ecx 10a7a9: 49 dec %ecx 10a7aa: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10a7b1: 8d 7d bc lea -0x44(%ebp),%edi 10a7b4: 57 push %edi 10a7b5: 6a 00 push $0x0 10a7b7: 51 push %ecx 10a7b8: 56 push %esi 10a7b9: e8 c6 d7 ff ff call 107f84 0, &loc, false ); if ( result != 0 ) { 10a7be: 83 c4 20 add $0x20,%esp 10a7c1: 85 c0 test %eax,%eax 10a7c3: 74 13 je 10a7d8 if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); return -1; 10a7c5: 83 c8 ff or $0xffffffff,%eax 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 ) 10a7c8: 84 db test %bl,%bl 10a7ca: 74 7c je 10a848 <== NEVER TAKEN rtems_filesystem_freenode( &parentloc ); 10a7cc: 83 ec 0c sub $0xc,%esp 10a7cf: 8d 55 d0 lea -0x30(%ebp),%edx 10a7d2: 52 push %edx 10a7d3: 89 45 b0 mov %eax,-0x50(%ebp) 10a7d6: eb 65 jmp 10a83d return -1; } if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) { 10a7d8: 83 ec 0c sub $0xc,%esp 10a7db: 57 push %edi 10a7dc: 8b 45 c8 mov -0x38(%ebp),%eax 10a7df: ff 50 10 call *0x10(%eax) 10a7e2: 83 c4 10 add $0x10,%esp 10a7e5: 48 dec %eax 10a7e6: 75 2f jne 10a817 rtems_filesystem_freenode( &loc ); 10a7e8: 83 ec 0c sub $0xc,%esp 10a7eb: 57 push %edi 10a7ec: e8 af d8 ff ff call 1080a0 if ( free_parentloc ) 10a7f1: 83 c4 10 add $0x10,%esp 10a7f4: 84 db test %bl,%bl 10a7f6: 74 0f je 10a807 rtems_filesystem_freenode( &parentloc ); 10a7f8: 83 ec 0c sub $0xc,%esp 10a7fb: 8d 45 d0 lea -0x30(%ebp),%eax 10a7fe: 50 push %eax 10a7ff: e8 9c d8 ff ff call 1080a0 10a804: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EISDIR ); 10a807: e8 2c a0 00 00 call 114838 <__errno> 10a80c: c7 00 15 00 00 00 movl $0x15,(%eax) 10a812: 83 c8 ff or $0xffffffff,%eax 10a815: eb 31 jmp 10a848 } result = (*loc.ops->unlink_h)( &parentloc, &loc ); 10a817: 50 push %eax 10a818: 50 push %eax 10a819: 57 push %edi 10a81a: 8d 75 d0 lea -0x30(%ebp),%esi 10a81d: 56 push %esi 10a81e: 8b 45 c8 mov -0x38(%ebp),%eax 10a821: ff 50 0c call *0xc(%eax) rtems_filesystem_freenode( &loc ); 10a824: 89 3c 24 mov %edi,(%esp) 10a827: 89 45 b0 mov %eax,-0x50(%ebp) 10a82a: e8 71 d8 ff ff call 1080a0 if ( free_parentloc ) 10a82f: 83 c4 10 add $0x10,%esp 10a832: 84 db test %bl,%bl 10a834: 8b 45 b0 mov -0x50(%ebp),%eax 10a837: 74 0f je 10a848 rtems_filesystem_freenode( &parentloc ); 10a839: 83 ec 0c sub $0xc,%esp 10a83c: 56 push %esi 10a83d: e8 5e d8 ff ff call 1080a0 10a842: 83 c4 10 add $0x10,%esp 10a845: 8b 45 b0 mov -0x50(%ebp),%eax return result; } 10a848: 8d 65 f4 lea -0xc(%ebp),%esp 10a84b: 5b pop %ebx 10a84c: 5e pop %esi 10a84d: 5f pop %edi 10a84e: c9 leave 10a84f: c3 ret =============================================================================== 0010a989 : */ int unmount( const char *path ) { 10a989: 55 push %ebp 10a98a: 89 e5 mov %esp,%ebp 10a98c: 57 push %edi 10a98d: 56 push %esi 10a98e: 53 push %ebx 10a98f: 83 ec 38 sub $0x38,%esp 10a992: 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 ) ) 10a995: 83 cb ff or $0xffffffff,%ebx 10a998: 31 c0 xor %eax,%eax 10a99a: 89 d9 mov %ebx,%ecx 10a99c: 89 d7 mov %edx,%edi 10a99e: f2 ae repnz scas %es:(%edi),%al 10a9a0: f7 d1 not %ecx 10a9a2: 49 dec %ecx 10a9a3: 6a 01 push $0x1 10a9a5: 8d 7d d4 lea -0x2c(%ebp),%edi 10a9a8: 57 push %edi 10a9a9: 6a 00 push $0x0 10a9ab: 51 push %ecx 10a9ac: 52 push %edx 10a9ad: e8 c4 d5 ff ff call 107f76 10a9b2: 83 c4 20 add $0x20,%esp 10a9b5: 85 c0 test %eax,%eax 10a9b7: 0f 85 f2 00 00 00 jne 10aaaf return -1; mt_entry = loc.mt_entry; 10a9bd: 8b 75 e4 mov -0x1c(%ebp),%esi /* * Verify this is the root node for the file system to be unmounted. */ if ( fs_root_loc->node_access != loc.node_access ){ 10a9c0: 8b 45 d4 mov -0x2c(%ebp),%eax 10a9c3: 39 46 1c cmp %eax,0x1c(%esi) 10a9c6: 74 1c je 10a9e4 rtems_filesystem_freenode( &loc ); 10a9c8: 83 ec 0c sub $0xc,%esp 10a9cb: 57 push %edi 10a9cc: e8 63 d6 ff ff call 108034 rtems_set_errno_and_return_minus_one( EACCES ); 10a9d1: e8 ea 76 00 00 call 1120c0 <__errno> 10a9d6: c7 00 0d 00 00 00 movl $0xd,(%eax) 10a9dc: 83 c4 10 add $0x10,%esp 10a9df: e9 cb 00 00 00 jmp 10aaaf /* * Free the loc node and just use the nodes from the mt_entry . */ rtems_filesystem_freenode( &loc ); 10a9e4: 83 ec 0c sub $0xc,%esp 10a9e7: 57 push %edi 10a9e8: e8 47 d6 ff ff call 108034 * 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 ) 10a9ed: 83 c4 10 add $0x10,%esp 10a9f0: a1 0c 51 12 00 mov 0x12510c,%eax 10a9f5: 39 70 14 cmp %esi,0x14(%eax) 10a9f8: 74 25 je 10aa1f /* * Verify there are no file systems below the path specified */ if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point, 10a9fa: 51 push %ecx 10a9fb: 51 push %ecx 10a9fc: ff 76 2c pushl 0x2c(%esi) 10a9ff: 68 78 a9 10 00 push $0x10a978 10aa04: e8 44 dd ff ff call 10874d 10aa09: 83 c4 10 add $0x10,%esp 10aa0c: 84 c0 test %al,%al 10aa0e: 75 0f jne 10aa1f * 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 ) 10aa10: 83 ec 0c sub $0xc,%esp 10aa13: 56 push %esi 10aa14: e8 03 d9 ff ff call 10831c 10aa19: 83 c4 10 add $0x10,%esp 10aa1c: 48 dec %eax 10aa1d: 75 10 jne 10aa2f rtems_set_errno_and_return_minus_one( EBUSY ); 10aa1f: e8 9c 76 00 00 call 1120c0 <__errno> 10aa24: c7 00 10 00 00 00 movl $0x10,(%eax) 10aa2a: e9 80 00 00 00 jmp 10aaaf * 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 ) 10aa2f: 83 ec 0c sub $0xc,%esp 10aa32: 8b 46 14 mov 0x14(%esi),%eax 10aa35: 56 push %esi 10aa36: ff 50 28 call *0x28(%eax) 10aa39: 83 c4 10 add $0x10,%esp return -1; 10aa3c: 83 ca ff or $0xffffffff,%edx * 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 ) 10aa3f: 85 c0 test %eax,%eax 10aa41: 75 6f jne 10aab2 <== NEVER TAKEN * 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){ 10aa43: 83 ec 0c sub $0xc,%esp 10aa46: 8b 46 28 mov 0x28(%esi),%eax 10aa49: 56 push %esi 10aa4a: ff 50 2c call *0x2c(%eax) 10aa4d: 83 c4 10 add $0x10,%esp 10aa50: 85 c0 test %eax,%eax 10aa52: 74 1d je 10aa71 <== ALWAYS TAKEN if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 ) 10aa54: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa57: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED 10aa5a: 56 push %esi <== NOT EXECUTED 10aa5b: ff 50 20 call *0x20(%eax) <== NOT EXECUTED 10aa5e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_fatal_error_occurred( 0 ); return -1; 10aa61: 89 da mov %ebx,%edx <== NOT EXECUTED * 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 ) 10aa63: 85 c0 test %eax,%eax <== NOT EXECUTED 10aa65: 74 4b je 10aab2 <== NOT EXECUTED rtems_fatal_error_occurred( 0 ); 10aa67: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa6a: 6a 00 push $0x0 <== NOT EXECUTED 10aa6c: e8 93 0e 00 00 call 10b904 <== NOT EXECUTED 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 ); 10aa71: 52 push %edx 10aa72: 6a 00 push $0x0 10aa74: 6a 00 push $0x0 10aa76: ff 35 48 73 12 00 pushl 0x127348 10aa7c: e8 fb 08 00 00 call 10b37c */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10aa81: 89 34 24 mov %esi,(%esp) 10aa84: e8 4b 11 00 00 call 10bbd4 <_Chain_Extract> } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10aa89: 58 pop %eax 10aa8a: ff 35 48 73 12 00 pushl 0x127348 10aa90: e8 d3 09 00 00 call 10b468 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; 10aa95: 8d 46 08 lea 0x8(%esi),%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 ); 10aa98: 89 04 24 mov %eax,(%esp) 10aa9b: e8 94 d5 ff ff call 108034 free( mt_entry ); 10aaa0: 89 34 24 mov %esi,(%esp) 10aaa3: e8 a0 d5 ff ff call 108048 return 0; 10aaa8: 83 c4 10 add $0x10,%esp 10aaab: 31 d2 xor %edx,%edx 10aaad: eb 03 jmp 10aab2 * 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 ) ) return -1; 10aaaf: 83 ca ff or $0xffffffff,%edx rtems_filesystem_freenode( fs_mount_loc ); free( mt_entry ); return 0; } 10aab2: 89 d0 mov %edx,%eax 10aab4: 8d 65 f4 lea -0xc(%ebp),%esp 10aab7: 5b pop %ebx 10aab8: 5e pop %esi 10aab9: 5f pop %edi 10aaba: c9 leave 10aabb: c3 ret =============================================================================== 0011d2fc : ssize_t write( int fd, const void *buffer, size_t count ) { 11d2fc: 55 push %ebp 11d2fd: 89 e5 mov %esp,%ebp 11d2ff: 56 push %esi 11d300: 53 push %ebx 11d301: 8b 5d 08 mov 0x8(%ebp),%ebx 11d304: 8b 55 0c mov 0xc(%ebp),%edx 11d307: 8b 4d 10 mov 0x10(%ebp),%ecx ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11d30a: 3b 1d 44 11 12 00 cmp 0x121144,%ebx 11d310: 73 14 jae 11d326 iop = rtems_libio_iop( fd ); 11d312: 6b db 38 imul $0x38,%ebx,%ebx 11d315: 03 1d f8 51 12 00 add 0x1251f8,%ebx rtems_libio_check_is_open( iop ); 11d31b: 8b 73 14 mov 0x14(%ebx),%esi 11d31e: f7 c6 00 01 00 00 test $0x100,%esi 11d324: 75 0d jne 11d333 11d326: e8 0d 3e ff ff call 111138 <__errno> 11d32b: c7 00 09 00 00 00 movl $0x9,(%eax) 11d331: eb 1a jmp 11d34d rtems_libio_check_buffer( buffer ); 11d333: 85 d2 test %edx,%edx 11d335: 74 0b je 11d342 <== NEVER TAKEN rtems_libio_check_count( count ); 11d337: 31 c0 xor %eax,%eax 11d339: 85 c9 test %ecx,%ecx 11d33b: 74 31 je 11d36e rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 11d33d: 83 e6 04 and $0x4,%esi 11d340: 75 10 jne 11d352 11d342: e8 f1 3d ff ff call 111138 <__errno> 11d347: c7 00 16 00 00 00 movl $0x16,(%eax) 11d34d: 83 c8 ff or $0xffffffff,%eax 11d350: eb 1c jmp 11d36e /* * Now process the write() request. */ rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count ); 11d352: 50 push %eax 11d353: 8b 43 20 mov 0x20(%ebx),%eax 11d356: 51 push %ecx 11d357: 52 push %edx 11d358: 53 push %ebx 11d359: ff 50 0c call *0xc(%eax) if ( rc > 0 ) 11d35c: 83 c4 10 add $0x10,%esp 11d35f: 85 c0 test %eax,%eax 11d361: 7e 0b jle 11d36e iop->offset += rc; 11d363: 89 c1 mov %eax,%ecx 11d365: c1 f9 1f sar $0x1f,%ecx 11d368: 01 43 0c add %eax,0xc(%ebx) 11d36b: 11 4b 10 adc %ecx,0x10(%ebx) return rc; } 11d36e: 8d 65 f8 lea -0x8(%ebp),%esp 11d371: 5b pop %ebx 11d372: 5e pop %esi 11d373: c9 leave 11d374: c3 ret =============================================================================== 0010a990 : ssize_t writev( int fd, const struct iovec *iov, int iovcnt ) { 10a990: 55 push %ebp 10a991: 89 e5 mov %esp,%ebp 10a993: 57 push %edi 10a994: 56 push %esi 10a995: 53 push %ebx 10a996: 83 ec 1c sub $0x1c,%esp 10a999: 8b 75 08 mov 0x8(%ebp),%esi 10a99c: 8b 7d 0c mov 0xc(%ebp),%edi int bytes; rtems_libio_t *iop; ssize_t old; bool all_zeros; rtems_libio_check_fd( fd ); 10a99f: 3b 35 44 21 12 00 cmp 0x122144,%esi 10a9a5: 73 11 jae 10a9b8 iop = rtems_libio_iop( fd ); 10a9a7: 6b f6 38 imul $0x38,%esi,%esi 10a9aa: 03 35 f8 61 12 00 add 0x1261f8,%esi rtems_libio_check_is_open( iop ); 10a9b0: 8b 46 14 mov 0x14(%esi),%eax 10a9b3: f6 c4 01 test $0x1,%ah 10a9b6: 75 10 jne 10a9c8 10a9b8: e8 4b 73 00 00 call 111d08 <__errno> 10a9bd: c7 00 09 00 00 00 movl $0x9,(%eax) 10a9c3: e9 ad 00 00 00 jmp 10aa75 rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 10a9c8: a8 04 test $0x4,%al 10a9ca: 74 42 je 10aa0e <== NEVER TAKEN /* * Argument validation on IO vector */ if ( !iov ) 10a9cc: 85 ff test %edi,%edi 10a9ce: 74 3e je 10aa0e rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt <= 0 ) 10a9d0: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a9d4: 7e 38 jle 10aa0e rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt > IOV_MAX ) 10a9d6: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp) 10a9dd: 7f 2f jg 10aa0e <== NEVER TAKEN 10a9df: b2 01 mov $0x1,%dl 10a9e1: 31 c0 xor %eax,%eax 10a9e3: 31 c9 xor %ecx,%ecx 10a9e5: eb 02 jmp 10a9e9 if ( iov[v].iov_len ) all_zeros = false; /* check for wrap */ old = total; total += iov[v].iov_len; 10a9e7: 89 d9 mov %ebx,%ecx /* * 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 ) 10a9e9: 83 3c c7 00 cmpl $0x0,(%edi,%eax,8) 10a9ed: 74 1f je 10aa0e rtems_set_errno_and_return_minus_one( EINVAL ); if ( iov[v].iov_len ) all_zeros = false; 10a9ef: 83 7c c7 04 00 cmpl $0x0,0x4(%edi,%eax,8) 10a9f4: 0f 94 c3 sete %bl 10a9f7: f7 db neg %ebx 10a9f9: 21 da and %ebx,%edx /* check for wrap */ old = total; total += iov[v].iov_len; 10a9fb: 8b 5c c7 04 mov 0x4(%edi,%eax,8),%ebx 10a9ff: 8d 1c 19 lea (%ecx,%ebx,1),%ebx if ( total < old || total > SSIZE_MAX ) 10aa02: 81 fb ff 7f 00 00 cmp $0x7fff,%ebx 10aa08: 7f 04 jg 10aa0e <== NEVER TAKEN 10aa0a: 39 cb cmp %ecx,%ebx 10aa0c: 7d 0d jge 10aa1b rtems_set_errno_and_return_minus_one( EINVAL ); 10aa0e: e8 f5 72 00 00 call 111d08 <__errno> 10aa13: c7 00 16 00 00 00 movl $0x16,(%eax) 10aa19: eb 5a jmp 10aa75 * this loop does that check as well and sets "all-zero" appropriately. * The variable "all_zero" is used as an early exit point before * entering the write loop. */ all_zeros = true; for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) { 10aa1b: 40 inc %eax 10aa1c: 3b 45 10 cmp 0x10(%ebp),%eax 10aa1f: 7c c6 jl 10a9e7 /* * A writev with all zeros is supposed to have no effect per OpenGroup. */ if ( all_zeros == true ) { return 0; 10aa21: 31 db xor %ebx,%ebx } /* * A writev with all zeros is supposed to have no effect per OpenGroup. */ if ( all_zeros == true ) { 10aa23: 84 d2 test %dl,%dl 10aa25: 75 51 jne 10aa78 10aa27: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) /* * Now process the writev(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { /* all zero lengths has no effect */ if ( iov[v].iov_len == 0 ) 10aa2e: 8b 55 e4 mov -0x1c(%ebp),%edx 10aa31: 8b 44 d7 04 mov 0x4(%edi,%edx,8),%eax 10aa35: 85 c0 test %eax,%eax 10aa37: 74 2f je 10aa68 <== NEVER TAKEN continue; bytes = (*iop->pathinfo.handlers->write_h)( 10aa39: 52 push %edx 10aa3a: 8b 56 20 mov 0x20(%esi),%edx 10aa3d: 50 push %eax 10aa3e: 8b 45 e4 mov -0x1c(%ebp),%eax 10aa41: ff 34 c7 pushl (%edi,%eax,8) 10aa44: 56 push %esi 10aa45: ff 52 0c call *0xc(%edx) iop, iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) 10aa48: 83 c4 10 add $0x10,%esp 10aa4b: 83 f8 00 cmp $0x0,%eax 10aa4e: 7c 25 jl 10aa75 <== NEVER TAKEN return -1; if ( bytes > 0 ) { 10aa50: 74 0d je 10aa5f <== NEVER TAKEN iop->offset += bytes; 10aa52: 89 c1 mov %eax,%ecx 10aa54: c1 f9 1f sar $0x1f,%ecx 10aa57: 01 46 0c add %eax,0xc(%esi) 10aa5a: 11 4e 10 adc %ecx,0x10(%esi) total += bytes; 10aa5d: 01 c3 add %eax,%ebx } if (bytes != iov[ v ].iov_len) 10aa5f: 8b 55 e4 mov -0x1c(%ebp),%edx 10aa62: 3b 44 d7 04 cmp 0x4(%edi,%edx,8),%eax 10aa66: 75 10 jne 10aa78 <== NEVER TAKEN } /* * Now process the writev(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { 10aa68: ff 45 e4 incl -0x1c(%ebp) 10aa6b: 8b 45 10 mov 0x10(%ebp),%eax 10aa6e: 39 45 e4 cmp %eax,-0x1c(%ebp) 10aa71: 7c bb jl 10aa2e 10aa73: eb 03 jmp 10aa78 iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) return -1; 10aa75: 83 cb ff or $0xffffffff,%ebx if (bytes != iov[ v ].iov_len) break; } return total; } 10aa78: 89 d8 mov %ebx,%eax 10aa7a: 8d 65 f4 lea -0xc(%ebp),%esp 10aa7d: 5b pop %ebx 10aa7e: 5e pop %esi 10aa7f: 5f pop %edi 10aa80: c9 leave 10aa81: c3 ret