=============================================================================== 0010d698 : #define MAXSYMLINK 5 int IMFS_Set_handlers( rtems_filesystem_location_info_t *loc ) { 10d698: 55 push %ebp 10d699: 89 e5 mov %esp,%ebp 10d69b: 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; 10d69e: 8b 50 10 mov 0x10(%eax),%edx 10d6a1: 8b 52 34 mov 0x34(%edx),%edx switch( node->type ) { 10d6a4: 8b 08 mov (%eax),%ecx 10d6a6: 8b 49 4c mov 0x4c(%ecx),%ecx 10d6a9: 49 dec %ecx 10d6aa: 83 f9 06 cmp $0x6,%ecx 10d6ad: 77 29 ja 10d6d8 <== NEVER TAKEN 10d6af: ff 24 8d c4 f3 11 00 jmp *0x11f3c4(,%ecx,4) case IMFS_DIRECTORY: loc->handlers = fs_info->directory_handlers; 10d6b6: 8b 52 0c mov 0xc(%edx),%edx 10d6b9: eb 1a jmp 10d6d5 break; case IMFS_DEVICE: loc->handlers = &IMFS_device_handlers; 10d6bb: c7 40 08 e8 f3 11 00 movl $0x11f3e8,0x8(%eax) break; 10d6c2: eb 14 jmp 10d6d8 case IMFS_SYM_LINK: case IMFS_HARD_LINK: loc->handlers = &IMFS_link_handlers; 10d6c4: c7 40 08 58 f4 11 00 movl $0x11f458,0x8(%eax) break; 10d6cb: eb 0b jmp 10d6d8 case IMFS_LINEAR_FILE: loc->handlers = fs_info->memfile_handlers; break; case IMFS_MEMORY_FILE: loc->handlers = fs_info->memfile_handlers; 10d6cd: 8b 52 08 mov 0x8(%edx),%edx 10d6d0: eb 03 jmp 10d6d5 break; case IMFS_FIFO: loc->handlers = fs_info->fifo_handlers; 10d6d2: 8b 52 10 mov 0x10(%edx),%edx 10d6d5: 89 50 08 mov %edx,0x8(%eax) break; } return 0; } 10d6d8: 31 c0 xor %eax,%eax 10d6da: c9 leave 10d6db: c3 ret =============================================================================== 0010d54b : IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) { 10d54b: 55 push %ebp 10d54c: 89 e5 mov %esp,%ebp 10d54e: 57 push %edi 10d54f: 56 push %esi 10d550: 53 push %ebx 10d551: 83 ec 1c sub $0x1c,%esp 10d554: 8b 4d 08 mov 0x8(%ebp),%ecx 10d557: 8b 5d 0c mov 0xc(%ebp),%ebx 10d55a: 8b 75 18 mov 0x18(%ebp),%esi /* * MUST have a parent node to call this routine. */ if ( parent_loc == NULL ) return NULL; 10d55d: 31 c0 xor %eax,%eax IMFS_fs_info_t *fs_info; /* * MUST have a parent node to call this routine. */ if ( parent_loc == NULL ) 10d55f: 85 c9 test %ecx,%ecx 10d561: 0f 84 f4 00 00 00 je 10d65b <== NEVER TAKEN return NULL; parent = parent_loc->node_access; 10d567: 8b 11 mov (%ecx),%edx fs_info = parent_loc->mt_entry->fs_info; 10d569: 8b 49 10 mov 0x10(%ecx),%ecx 10d56c: 8b 79 34 mov 0x34(%ecx),%edi /* * Reject creation of FIFOs if support is disabled. */ if ( type == IMFS_FIFO && 10d56f: 83 fb 07 cmp $0x7,%ebx 10d572: 75 0d jne 10d581 10d574: 81 7f 10 5c f3 11 00 cmpl $0x11f35c,0x10(%edi) 10d57b: 0f 84 da 00 00 00 je 10d65b return NULL; /* * Allocate filesystem node and fill in basic information */ node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask ); 10d581: 50 push %eax 10d582: a1 60 30 12 00 mov 0x123060,%eax 10d587: 8b 40 2c mov 0x2c(%eax),%eax 10d58a: f7 d0 not %eax 10d58c: 23 45 14 and 0x14(%ebp),%eax 10d58f: 50 push %eax 10d590: ff 75 10 pushl 0x10(%ebp) 10d593: 53 push %ebx 10d594: 89 55 e4 mov %edx,-0x1c(%ebp) 10d597: e8 40 ff ff ff call 10d4dc if ( !node ) 10d59c: 83 c4 10 add $0x10,%esp 10d59f: 85 c0 test %eax,%eax 10d5a1: 8b 55 e4 mov -0x1c(%ebp),%edx 10d5a4: 0f 84 b1 00 00 00 je 10d65b return NULL; /* * Set the type specific information */ if ( type == IMFS_DIRECTORY ) { 10d5aa: 83 fb 01 cmp $0x1,%ebx 10d5ad: 75 15 jne 10d5c4 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 ); 10d5af: 8d 48 54 lea 0x54(%eax),%ecx 10d5b2: 89 48 50 mov %ecx,0x50(%eax) head->next = tail; head->previous = NULL; 10d5b5: 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 ); 10d5bc: 8d 48 50 lea 0x50(%eax),%ecx 10d5bf: 89 48 58 mov %ecx,0x58(%eax) 10d5c2: eb 75 jmp 10d639 rtems_chain_initialize_empty(&node->info.directory.Entries); } else if ( type == IMFS_HARD_LINK ) { 10d5c4: 83 fb 03 cmp $0x3,%ebx 10d5c7: 74 05 je 10d5ce node->info.hard_link.link_node = info->hard_link.link_node; } else if ( type == IMFS_SYM_LINK ) { 10d5c9: 83 fb 04 cmp $0x4,%ebx 10d5cc: 75 07 jne 10d5d5 node->info.sym_link.name = info->sym_link.name; 10d5ce: 8b 0e mov (%esi),%ecx 10d5d0: 89 48 50 mov %ecx,0x50(%eax) 10d5d3: eb 64 jmp 10d639 } else if ( type == IMFS_DEVICE ) { 10d5d5: 83 fb 02 cmp $0x2,%ebx 10d5d8: 75 0d jne 10d5e7 node->info.device.major = info->device.major; 10d5da: 8b 0e mov (%esi),%ecx 10d5dc: 89 48 50 mov %ecx,0x50(%eax) node->info.device.minor = info->device.minor; 10d5df: 8b 4e 04 mov 0x4(%esi),%ecx 10d5e2: 89 48 54 mov %ecx,0x54(%eax) 10d5e5: eb 52 jmp 10d639 } else if ( type == IMFS_LINEAR_FILE ) { 10d5e7: 83 fb 06 cmp $0x6,%ebx 10d5ea: 75 17 jne 10d603 node->info.linearfile.size = 0; 10d5ec: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10d5f3: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.linearfile.direct = 0; 10d5fa: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) 10d601: eb 36 jmp 10d639 } else if ( type == IMFS_MEMORY_FILE ) { 10d603: 83 fb 05 cmp $0x5,%ebx 10d606: 75 25 jne 10d62d node->info.file.size = 0; 10d608: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10d60f: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.file.indirect = 0; 10d616: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) node->info.file.doubly_indirect = 0; 10d61d: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) node->info.file.triply_indirect = 0; 10d624: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) 10d62b: eb 0c jmp 10d639 } else if ( type == IMFS_FIFO ) { 10d62d: 83 fb 07 cmp $0x7,%ebx 10d630: 75 07 jne 10d639 <== NEVER TAKEN node->info.fifo.pipe = NULL; 10d632: 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; 10d639: 89 50 08 mov %edx,0x8(%eax) node->st_ino = ++fs_info->ino_count; 10d63c: 8b 4f 04 mov 0x4(%edi),%ecx 10d63f: 41 inc %ecx 10d640: 89 4f 04 mov %ecx,0x4(%edi) 10d643: 89 48 38 mov %ecx,0x38(%eax) 10d646: 53 push %ebx 10d647: 53 push %ebx 10d648: 50 push %eax rtems_chain_append( &parent->info.directory.Entries, &node->Node ); 10d649: 83 c2 50 add $0x50,%edx 10d64c: 52 push %edx 10d64d: 89 45 e4 mov %eax,-0x1c(%ebp) 10d650: e8 8b d3 ff ff call 10a9e0 <_Chain_Append> return node; 10d655: 83 c4 10 add $0x10,%esp 10d658: 8b 45 e4 mov -0x1c(%ebp),%eax } 10d65b: 8d 65 f4 lea -0xc(%ebp),%esp 10d65e: 5b pop %ebx 10d65f: 5e pop %esi 10d660: 5f pop %edi 10d661: c9 leave 10d662: c3 ret =============================================================================== 0010d779 : const char *pathname, /* IN */ size_t pathnamelen, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10d779: 55 push %ebp 10d77a: 89 e5 mov %esp,%ebp 10d77c: 57 push %edi 10d77d: 56 push %esi 10d77e: 53 push %ebx 10d77f: 83 ec 5c sub $0x5c,%esp 10d782: 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 ) ) { 10d785: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp) 10d78c: 74 0d je 10d79b <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EIO ); 10d78e: e8 b9 39 00 00 call 11114c <__errno> <== NOT EXECUTED 10d793: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 10d799: eb 42 jmp 10d7dd <== NOT EXECUTED /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10d79b: 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; 10d79d: 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; 10d7a2: 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) ) { 10d7a9: e9 29 01 00 00 jmp 10d8d7 type = IMFS_get_token( &pathname[i], pathnamelen, token, &len ); 10d7ae: 8d 45 e4 lea -0x1c(%ebp),%eax 10d7b1: 50 push %eax 10d7b2: 8d 4d af lea -0x51(%ebp),%ecx 10d7b5: 51 push %ecx 10d7b6: ff 75 0c pushl 0xc(%ebp) 10d7b9: 8b 45 08 mov 0x8(%ebp),%eax 10d7bc: 03 45 a4 add -0x5c(%ebp),%eax 10d7bf: 50 push %eax 10d7c0: e8 b3 05 00 00 call 10dd78 10d7c5: 89 c6 mov %eax,%esi pathnamelen -= len; 10d7c7: 8b 55 e4 mov -0x1c(%ebp),%edx i += len; if ( !pathloc->node_access ) 10d7ca: 83 c4 10 add $0x10,%esp 10d7cd: 83 3b 00 cmpl $0x0,(%ebx) 10d7d0: 75 13 jne 10d7e5 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOENT ); 10d7d2: e8 75 39 00 00 call 11114c <__errno> 10d7d7: c7 00 02 00 00 00 movl $0x2,(%eax) 10d7dd: 83 cf ff or $0xffffffff,%edi 10d7e0: e9 75 01 00 00 jmp 10d95a /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10d7e5: 85 c0 test %eax,%eax 10d7e7: 74 21 je 10d80a if ( node->type == IMFS_DIRECTORY ) 10d7e9: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10d7ed: 75 1b jne 10d80a if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10d7ef: 57 push %edi 10d7f0: 57 push %edi 10d7f1: 6a 01 push $0x1 10d7f3: 53 push %ebx 10d7f4: 89 55 a0 mov %edx,-0x60(%ebp) 10d7f7: e8 e0 fe ff ff call 10d6dc 10d7fc: 83 c4 10 add $0x10,%esp 10d7ff: 85 c0 test %eax,%eax 10d801: 8b 55 a0 mov -0x60(%ebp),%edx 10d804: 0f 84 3e 01 00 00 je 10d948 */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], pathnamelen, token, &len ); pathnamelen -= len; 10d80a: 29 55 0c sub %edx,0xc(%ebp) i += len; 10d80d: 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; 10d810: 8b 3b mov (%ebx),%edi switch( type ) { 10d812: 83 fe 03 cmp $0x3,%esi 10d815: 74 38 je 10d84f 10d817: 83 fe 04 cmp $0x4,%esi 10d81a: 0f 84 a7 00 00 00 je 10d8c7 10d820: 83 fe 02 cmp $0x2,%esi 10d823: 0f 85 ae 00 00 00 jne 10d8d7 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10d829: a1 60 30 12 00 mov 0x123060,%eax 10d82e: 3b 78 18 cmp 0x18(%eax),%edi 10d831: 0f 84 a0 00 00 00 je 10d8d7 /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access) { 10d837: 8b 43 10 mov 0x10(%ebx),%eax /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == 10d83a: 3b 78 1c cmp 0x1c(%eax),%edi 10d83d: 75 0b jne 10d84a */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; /* Throw out the .. in this case */ } else { newloc = pathloc->mt_entry->mt_point_node; 10d83f: 8d 7d d0 lea -0x30(%ebp),%edi 10d842: 8d 70 08 lea 0x8(%eax),%esi 10d845: e9 ad 00 00 00 jmp 10d8f7 pathnamelen+len, flags,pathloc); } } else { if ( !node->Parent ) 10d84a: 8b 7f 08 mov 0x8(%edi),%edi 10d84d: eb 6c jmp 10d8bb case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { 10d84f: 8b 47 4c mov 0x4c(%edi),%eax 10d852: 83 f8 03 cmp $0x3,%eax 10d855: 75 11 jne 10d868 IMFS_evaluate_hard_link( pathloc, 0 ); 10d857: 51 push %ecx 10d858: 51 push %ecx 10d859: 6a 00 push $0x0 10d85b: 53 push %ebx 10d85c: e8 d9 fe ff ff call 10d73a node = pathloc->node_access; 10d861: 8b 3b mov (%ebx),%edi 10d863: 83 c4 10 add $0x10,%esp 10d866: eb 1d jmp 10d885 * It would be a design error if we evaluated the link and * was broken. */ IMFS_assert( node ); } else if ( node->type == IMFS_SYM_LINK ) { 10d868: 83 f8 04 cmp $0x4,%eax 10d86b: 75 18 jne 10d885 result = IMFS_evaluate_sym_link( pathloc, 0 ); 10d86d: 52 push %edx 10d86e: 52 push %edx 10d86f: 6a 00 push $0x0 10d871: 53 push %ebx 10d872: e8 ed 00 00 00 call 10d964 /* * In contrast to a hard link, it is possible to have a broken * symbolic link. */ node = pathloc->node_access; 10d877: 8b 3b mov (%ebx),%edi if ( result == -1 ) 10d879: 83 c4 10 add $0x10,%esp 10d87c: 83 f8 ff cmp $0xffffffff,%eax 10d87f: 0f 84 d3 00 00 00 je 10d958 <== NEVER TAKEN } /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10d885: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10d889: 74 10 je 10d89b rtems_set_errno_and_return_minus_one( ENOTDIR ); 10d88b: e8 bc 38 00 00 call 11114c <__errno> 10d890: c7 00 14 00 00 00 movl $0x14,(%eax) 10d896: e9 42 ff ff ff jmp 10d7dd /* * 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 ) { 10d89b: 8b 47 5c mov 0x5c(%edi),%eax 10d89e: 85 c0 test %eax,%eax 10d8a0: 74 08 je 10d8aa newloc = node->info.directory.mt_fs->mt_fs_root; 10d8a2: 8d 7d d0 lea -0x30(%ebp),%edi 10d8a5: 8d 70 1c lea 0x1c(%eax),%esi 10d8a8: eb 4d jmp 10d8f7 } /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10d8aa: 50 push %eax 10d8ab: 50 push %eax 10d8ac: 8d 45 af lea -0x51(%ebp),%eax 10d8af: 50 push %eax 10d8b0: 57 push %edi 10d8b1: e8 56 04 00 00 call 10dd0c 10d8b6: 89 c7 mov %eax,%edi if ( !node ) 10d8b8: 83 c4 10 add $0x10,%esp 10d8bb: 85 ff test %edi,%edi 10d8bd: 0f 84 0f ff ff ff je 10d7d2 /* * Set the node access to the point we have found. */ pathloc->node_access = node; 10d8c3: 89 3b mov %edi,(%ebx) 10d8c5: eb 10 jmp 10d8d7 case IMFS_NO_MORE_PATH: case IMFS_CURRENT_DIR: break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10d8c7: e8 80 38 00 00 call 11114c <__errno> 10d8cc: c7 00 5b 00 00 00 movl $0x5b,(%eax) 10d8d2: e9 06 ff ff ff jmp 10d7dd /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 10d8d7: 83 fe 04 cmp $0x4,%esi 10d8da: 74 08 je 10d8e4 <== NEVER TAKEN 10d8dc: 85 f6 test %esi,%esi 10d8de: 0f 85 ca fe ff ff jne 10d7ae * 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 ) { 10d8e4: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10d8e8: 75 41 jne 10d92b if ( node->info.directory.mt_fs != NULL ) { 10d8ea: 8b 77 5c mov 0x5c(%edi),%esi 10d8ed: 85 f6 test %esi,%esi 10d8ef: 74 3a je 10d92b newloc = node->info.directory.mt_fs->mt_fs_root; 10d8f1: 8d 7d d0 lea -0x30(%ebp),%edi 10d8f4: 83 c6 1c add $0x1c,%esi 10d8f7: b9 05 00 00 00 mov $0x5,%ecx 10d8fc: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10d8fe: 8d 75 d0 lea -0x30(%ebp),%esi 10d901: b1 05 mov $0x5,%cl 10d903: 89 df mov %ebx,%edi 10d905: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalpath_h)( &pathname[i-len], 10d907: 8b 45 e4 mov -0x1c(%ebp),%eax 10d90a: 8b 53 0c mov 0xc(%ebx),%edx 10d90d: 53 push %ebx 10d90e: ff 75 10 pushl 0x10(%ebp) 10d911: 8b 4d 0c mov 0xc(%ebp),%ecx 10d914: 01 c1 add %eax,%ecx 10d916: 51 push %ecx 10d917: 8b 4d a4 mov -0x5c(%ebp),%ecx 10d91a: 29 c1 sub %eax,%ecx 10d91c: 8b 45 08 mov 0x8(%ebp),%eax 10d91f: 01 c8 add %ecx,%eax 10d921: 50 push %eax 10d922: ff 12 call *(%edx) 10d924: 89 c7 mov %eax,%edi 10d926: 83 c4 10 add $0x10,%esp 10d929: eb 2f jmp 10d95a flags, pathloc ); } else { result = IMFS_Set_handlers( pathloc ); } } else { result = IMFS_Set_handlers( pathloc ); 10d92b: 83 ec 0c sub $0xc,%esp 10d92e: 53 push %ebx 10d92f: e8 64 fd ff ff call 10d698 10d934: 89 c7 mov %eax,%edi 10d936: 5a pop %edx 10d937: 59 pop %ecx /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) 10d938: ff 75 10 pushl 0x10(%ebp) 10d93b: 53 push %ebx 10d93c: e8 9b fd ff ff call 10d6dc 10d941: 83 c4 10 add $0x10,%esp 10d944: 85 c0 test %eax,%eax 10d946: 75 12 jne 10d95a rtems_set_errno_and_return_minus_one( EACCES ); 10d948: e8 ff 37 00 00 call 11114c <__errno> 10d94d: c7 00 0d 00 00 00 movl $0xd,(%eax) 10d953: e9 85 fe ff ff jmp 10d7dd 10d958: 89 c7 mov %eax,%edi <== NOT EXECUTED return result; } 10d95a: 89 f8 mov %edi,%eax 10d95c: 8d 65 f4 lea -0xc(%ebp),%esp 10d95f: 5b pop %ebx 10d960: 5e pop %esi 10d961: 5f pop %edi 10d962: c9 leave 10d963: c3 ret =============================================================================== 0010da58 : int IMFS_evaluate_for_make( const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) { 10da58: 55 push %ebp 10da59: 89 e5 mov %esp,%ebp 10da5b: 57 push %edi 10da5c: 56 push %esi 10da5d: 53 push %ebx 10da5e: 83 ec 5c sub $0x5c,%esp 10da61: 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; 10da64: 8b 1a mov (%edx),%ebx /* * Get the path length. */ pathlen = strlen( path ); 10da66: 31 c0 xor %eax,%eax 10da68: 83 c9 ff or $0xffffffff,%ecx 10da6b: 8b 7d 08 mov 0x8(%ebp),%edi 10da6e: f2 ae repnz scas %es:(%edi),%al 10da70: f7 d1 not %ecx 10da72: 49 dec %ecx 10da73: 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; 10da76: 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 ); 10da7d: 8d 7d af lea -0x51(%ebp),%edi 10da80: 89 d6 mov %edx,%esi 10da82: 8d 45 e4 lea -0x1c(%ebp),%eax 10da85: 50 push %eax 10da86: 57 push %edi 10da87: ff 75 a0 pushl -0x60(%ebp) 10da8a: 8b 45 08 mov 0x8(%ebp),%eax 10da8d: 03 45 a4 add -0x5c(%ebp),%eax 10da90: 50 push %eax 10da91: e8 e2 02 00 00 call 10dd78 10da96: 89 c2 mov %eax,%edx pathlen -= len; 10da98: 8b 4d e4 mov -0x1c(%ebp),%ecx 10da9b: 29 4d a0 sub %ecx,-0x60(%ebp) i += len; if ( !pathloc->node_access ) 10da9e: 83 c4 10 add $0x10,%esp 10daa1: 83 3e 00 cmpl $0x0,(%esi) 10daa4: 0f 84 79 01 00 00 je 10dc23 <== NEVER TAKEN /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10daaa: 85 c0 test %eax,%eax 10daac: 74 36 je 10dae4 if ( node->type == IMFS_DIRECTORY ) 10daae: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10dab2: 75 30 jne 10dae4 if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10dab4: 53 push %ebx 10dab5: 53 push %ebx 10dab6: 6a 01 push $0x1 10dab8: 56 push %esi 10dab9: 89 45 9c mov %eax,-0x64(%ebp) 10dabc: 89 4d 98 mov %ecx,-0x68(%ebp) 10dabf: e8 18 fc ff ff call 10d6dc 10dac4: 83 c4 10 add $0x10,%esp 10dac7: 85 c0 test %eax,%eax 10dac9: 8b 55 9c mov -0x64(%ebp),%edx 10dacc: 8b 4d 98 mov -0x68(%ebp),%ecx 10dacf: 75 13 jne 10dae4 rtems_set_errno_and_return_minus_one( EACCES ); 10dad1: e8 76 36 00 00 call 11114c <__errno> 10dad6: c7 00 0d 00 00 00 movl $0xd,(%eax) 10dadc: 83 cb ff or $0xffffffff,%ebx 10dadf: e9 99 01 00 00 jmp 10dc7d while( !done ) { type = IMFS_get_token( &path[i], pathlen, token, &len ); pathlen -= len; i += len; 10dae4: 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; 10dae7: 8b 1e mov (%esi),%ebx switch( type ) { 10dae9: 83 fa 02 cmp $0x2,%edx 10daec: 74 1f je 10db0d 10daee: 77 0a ja 10dafa 10daf0: 85 d2 test %edx,%edx 10daf2: 0f 84 d9 00 00 00 je 10dbd1 10daf8: eb 88 jmp 10da82 10dafa: 83 fa 03 cmp $0x3,%edx 10dafd: 74 40 je 10db3f 10daff: 83 fa 04 cmp $0x4,%edx 10db02: 0f 85 7a ff ff ff jne 10da82 <== NEVER TAKEN 10db08: e9 d4 00 00 00 jmp 10dbe1 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10db0d: a1 60 30 12 00 mov 0x123060,%eax 10db12: 3b 58 18 cmp 0x18(%eax),%ebx 10db15: 0f 84 67 ff ff ff je 10da82 /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){ 10db1b: 8b 46 10 mov 0x10(%esi),%eax 10db1e: 3b 58 1c cmp 0x1c(%eax),%ebx 10db21: 75 0c jne 10db2f 10db23: 89 f2 mov %esi,%edx 10db25: 89 c6 mov %eax,%esi if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; } else { newloc = pathloc->mt_entry->mt_point_node; 10db27: 8d 7d d0 lea -0x30(%ebp),%edi 10db2a: 83 c6 08 add $0x8,%esi 10db2d: eb 5a jmp 10db89 *pathloc = newloc; return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); } } else { if ( !node->Parent ) 10db2f: 8b 5b 08 mov 0x8(%ebx),%ebx 10db32: 85 db test %ebx,%ebx 10db34: 0f 85 90 00 00 00 jne 10dbca 10db3a: e9 e4 00 00 00 jmp 10dc23 pathloc->node_access = node; break; case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { 10db3f: 8b 43 4c mov 0x4c(%ebx),%eax 10db42: 83 f8 03 cmp $0x3,%eax 10db45: 74 05 je 10db4c result = IMFS_evaluate_link( pathloc, 0 ); if ( result == -1 ) return -1; } else if ( node->type == IMFS_SYM_LINK ) { 10db47: 83 f8 04 cmp $0x4,%eax 10db4a: 75 16 jne 10db62 result = IMFS_evaluate_link( pathloc, 0 ); 10db4c: 50 push %eax 10db4d: 50 push %eax 10db4e: 6a 00 push $0x0 10db50: 56 push %esi 10db51: e8 7f fe ff ff call 10d9d5 if ( result == -1 ) 10db56: 83 c4 10 add $0x10,%esp 10db59: 83 f8 ff cmp $0xffffffff,%eax 10db5c: 0f 84 19 01 00 00 je 10dc7b <== NEVER TAKEN return -1; } node = pathloc->node_access; 10db62: 8b 06 mov (%esi),%eax if ( !node ) 10db64: 85 c0 test %eax,%eax 10db66: 0f 84 e9 00 00 00 je 10dc55 <== NEVER TAKEN /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10db6c: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 10db70: 0f 85 df 00 00 00 jne 10dc55 /* * 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 ) { 10db76: 8b 50 5c mov 0x5c(%eax),%edx 10db79: 85 d2 test %edx,%edx 10db7b: 74 3b je 10dbb8 10db7d: 89 f0 mov %esi,%eax 10db7f: 89 d6 mov %edx,%esi 10db81: 89 c2 mov %eax,%edx newloc = node->info.directory.mt_fs->mt_fs_root; 10db83: 8d 7d d0 lea -0x30(%ebp),%edi 10db86: 83 c6 1c add $0x1c,%esi 10db89: b9 05 00 00 00 mov $0x5,%ecx 10db8e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10db90: 8d 75 d0 lea -0x30(%ebp),%esi 10db93: b1 05 mov $0x5,%cl 10db95: 89 d7 mov %edx,%edi 10db97: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10db99: 56 push %esi 10db9a: 8b 42 0c mov 0xc(%edx),%eax 10db9d: ff 75 10 pushl 0x10(%ebp) 10dba0: 52 push %edx 10dba1: 8b 55 a4 mov -0x5c(%ebp),%edx 10dba4: 2b 55 e4 sub -0x1c(%ebp),%edx 10dba7: 03 55 08 add 0x8(%ebp),%edx 10dbaa: 52 push %edx 10dbab: ff 50 04 call *0x4(%eax) 10dbae: 89 c3 mov %eax,%ebx 10dbb0: 83 c4 10 add $0x10,%esp 10dbb3: e9 c5 00 00 00 jmp 10dc7d /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10dbb8: 53 push %ebx 10dbb9: 53 push %ebx 10dbba: 57 push %edi 10dbbb: 50 push %eax 10dbbc: e8 4b 01 00 00 call 10dd0c 10dbc1: 89 c3 mov %eax,%ebx /* * If there is no node we have found the name of the node we * wish to create. */ if ( ! node ) 10dbc3: 83 c4 10 add $0x10,%esp 10dbc6: 85 c0 test %eax,%eax 10dbc8: 74 27 je 10dbf1 done = true; else pathloc->node_access = node; 10dbca: 89 1e mov %ebx,(%esi) 10dbcc: e9 b1 fe ff ff jmp 10da82 break; case IMFS_NO_MORE_PATH: rtems_set_errno_and_return_minus_one( EEXIST ); 10dbd1: e8 76 35 00 00 call 11114c <__errno> 10dbd6: c7 00 11 00 00 00 movl $0x11,(%eax) 10dbdc: e9 fb fe ff ff jmp 10dadc break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10dbe1: e8 66 35 00 00 call 11114c <__errno> 10dbe6: c7 00 5b 00 00 00 movl $0x5b,(%eax) 10dbec: e9 eb fe ff ff jmp 10dadc 10dbf1: 89 f2 mov %esi,%edx case IMFS_CURRENT_DIR: break; } } *name = &path[ i - len ]; 10dbf3: 8b 45 a4 mov -0x5c(%ebp),%eax 10dbf6: 2b 45 e4 sub -0x1c(%ebp),%eax 10dbf9: 03 45 08 add 0x8(%ebp),%eax 10dbfc: 8b 4d 10 mov 0x10(%ebp),%ecx 10dbff: 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( 10dc01: 8b 5d 08 mov 0x8(%ebp),%ebx 10dc04: 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++) { 10dc07: eb 2a jmp 10dc33 if ( !IMFS_is_separator( path[ i ] ) ) 10dc09: 83 ec 0c sub $0xc,%esp 10dc0c: 0f be c0 movsbl %al,%eax 10dc0f: 50 push %eax 10dc10: 89 55 9c mov %edx,-0x64(%ebp) 10dc13: e8 e8 a3 ff ff call 108000 10dc18: 43 inc %ebx 10dc19: 83 c4 10 add $0x10,%esp 10dc1c: 85 c0 test %eax,%eax 10dc1e: 8b 55 9c mov -0x64(%ebp),%edx 10dc21: 75 10 jne 10dc33 rtems_set_errno_and_return_minus_one( ENOENT ); 10dc23: e8 24 35 00 00 call 11114c <__errno> 10dc28: c7 00 02 00 00 00 movl $0x2,(%eax) 10dc2e: e9 a9 fe ff ff jmp 10dadc /* * 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++) { 10dc33: 8a 03 mov (%ebx),%al 10dc35: 84 c0 test %al,%al 10dc37: 75 d0 jne 10dc09 /* * Verify we can execute and write to this directory. */ result = IMFS_Set_handlers( pathloc ); 10dc39: 83 ec 0c sub $0xc,%esp 10dc3c: 52 push %edx 10dc3d: 89 55 9c mov %edx,-0x64(%ebp) 10dc40: e8 53 fa ff ff call 10d698 10dc45: 89 c3 mov %eax,%ebx /* * The returned node must be a directory */ node = pathloc->node_access; if ( node->type != IMFS_DIRECTORY ) 10dc47: 8b 55 9c mov -0x64(%ebp),%edx 10dc4a: 8b 02 mov (%edx),%eax 10dc4c: 83 c4 10 add $0x10,%esp 10dc4f: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 10dc53: 74 10 je 10dc65 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTDIR ); 10dc55: e8 f2 34 00 00 call 11114c <__errno> 10dc5a: c7 00 14 00 00 00 movl $0x14,(%eax) 10dc60: e9 77 fe ff ff jmp 10dadc /* * We must have Write and execute permission on the returned node. */ if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) 10dc65: 51 push %ecx 10dc66: 51 push %ecx 10dc67: 6a 03 push $0x3 10dc69: 52 push %edx 10dc6a: e8 6d fa ff ff call 10d6dc 10dc6f: 83 c4 10 add $0x10,%esp 10dc72: 85 c0 test %eax,%eax 10dc74: 75 07 jne 10dc7d 10dc76: e9 56 fe ff ff jmp 10dad1 10dc7b: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10dc7d: 89 d8 mov %ebx,%eax 10dc7f: 8d 65 f4 lea -0xc(%ebp),%esp 10dc82: 5b pop %ebx 10dc83: 5e pop %esi 10dc84: 5f pop %edi 10dc85: c9 leave 10dc86: c3 ret =============================================================================== 0010d6dc : */ int IMFS_evaluate_permission( rtems_filesystem_location_info_t *node, int flags ) { 10d6dc: 55 push %ebp 10d6dd: 89 e5 mov %esp,%ebp 10d6df: 57 push %edi 10d6e0: 56 push %esi 10d6e1: 53 push %ebx 10d6e2: 83 ec 0c sub $0xc,%esp 10d6e5: 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 ) ) 10d6e8: f7 c6 f8 ff ff ff test $0xfffffff8,%esi 10d6ee: 74 10 je 10d700 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EPERM ); 10d6f0: e8 57 3a 00 00 call 11114c <__errno> <== NOT EXECUTED 10d6f5: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10d6fb: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10d6fe: eb 32 jmp 10d732 <== NOT EXECUTED jnode = node->node_access; 10d700: 8b 45 08 mov 0x8(%ebp),%eax 10d703: 8b 18 mov (%eax),%ebx #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 10d705: e8 2e 0a 00 00 call 10e138 10d70a: 89 c7 mov %eax,%edi st_gid = getegid(); 10d70c: e8 17 0a 00 00 call 10e128 * Check if I am owner or a group member or someone else. */ flags_to_test = flags; if ( st_uid == jnode->st_uid ) 10d711: 66 3b 7b 3c cmp 0x3c(%ebx),%di 10d715: 75 05 jne 10d71c flags_to_test <<= 6; 10d717: c1 e6 06 shl $0x6,%esi 10d71a: eb 09 jmp 10d725 else if ( st_gid == jnode->st_gid ) 10d71c: 66 3b 43 3e cmp 0x3e(%ebx),%ax 10d720: 75 03 jne 10d725 <== NEVER TAKEN flags_to_test <<= 3; 10d722: 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 ) 10d725: 8b 43 30 mov 0x30(%ebx),%eax 10d728: 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 ); 10d72a: 39 f0 cmp %esi,%eax 10d72c: 0f 94 c0 sete %al 10d72f: 0f b6 c0 movzbl %al,%eax */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) return 1; return 0; } 10d732: 83 c4 0c add $0xc,%esp 10d735: 5b pop %ebx 10d736: 5e pop %esi 10d737: 5f pop %edi 10d738: c9 leave 10d739: c3 ret =============================================================================== 00107b68 : rtems_off64_t IMFS_fifo_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) { 107b68: 55 push %ebp 107b69: 89 e5 mov %esp,%ebp 107b6b: 53 push %ebx 107b6c: 83 ec 10 sub $0x10,%esp 107b6f: 8b 45 08 mov 0x8(%ebp),%eax off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop); 107b72: 50 push %eax 107b73: ff 75 14 pushl 0x14(%ebp) 107b76: ff 75 10 pushl 0x10(%ebp) 107b79: ff 75 0c pushl 0xc(%ebp) 107b7c: 8b 40 18 mov 0x18(%eax),%eax 107b7f: ff 70 50 pushl 0x50(%eax) 107b82: e8 8a 86 00 00 call 110211 107b87: 89 c3 mov %eax,%ebx IMFS_FIFO_RETURN(err); 107b89: 83 c4 20 add $0x20,%esp 107b8c: 99 cltd 107b8d: 85 d2 test %edx,%edx 107b8f: 79 0e jns 107b9f <== NEVER TAKEN 107b91: e8 d6 b3 00 00 call 112f6c <__errno> 107b96: f7 db neg %ebx 107b98: 89 18 mov %ebx,(%eax) 107b9a: 83 c8 ff or $0xffffffff,%eax 107b9d: 89 c2 mov %eax,%edx } 107b9f: 8b 5d fc mov -0x4(%ebp),%ebx 107ba2: c9 leave 107ba3: c3 ret =============================================================================== 00107c04 : ssize_t IMFS_fifo_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 107c04: 55 push %ebp 107c05: 89 e5 mov %esp,%ebp 107c07: 56 push %esi 107c08: 53 push %ebx 107c09: 83 ec 10 sub $0x10,%esp 107c0c: 8b 45 08 mov 0x8(%ebp),%eax IMFS_jnode_t *jnode = iop->pathinfo.node_access; 107c0f: 8b 70 18 mov 0x18(%eax),%esi int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop); 107c12: 50 push %eax 107c13: ff 75 10 pushl 0x10(%ebp) 107c16: ff 75 0c pushl 0xc(%ebp) 107c19: ff 76 50 pushl 0x50(%esi) 107c1c: e8 ec 83 00 00 call 11000d 107c21: 89 c3 mov %eax,%ebx if (err > 0) { 107c23: 83 c4 10 add $0x10,%esp 107c26: 83 f8 00 cmp $0x0,%eax 107c29: 7e 1d jle 107c48 IMFS_mtime_ctime_update(jnode); 107c2b: 50 push %eax 107c2c: 50 push %eax 107c2d: 6a 00 push $0x0 107c2f: 8d 45 f0 lea -0x10(%ebp),%eax 107c32: 50 push %eax 107c33: e8 ec 0d 00 00 call 108a24 107c38: 8b 45 f0 mov -0x10(%ebp),%eax 107c3b: 89 46 44 mov %eax,0x44(%esi) 107c3e: 89 46 48 mov %eax,0x48(%esi) 107c41: 83 c4 10 add $0x10,%esp 107c44: 89 d8 mov %ebx,%eax 107c46: eb 13 jmp 107c5b } IMFS_FIFO_RETURN(err); 107c48: b8 00 00 00 00 mov $0x0,%eax 107c4d: 74 0c je 107c5b <== NEVER TAKEN 107c4f: e8 18 b3 00 00 call 112f6c <__errno> 107c54: f7 db neg %ebx 107c56: 89 18 mov %ebx,(%eax) 107c58: 83 c8 ff or $0xffffffff,%eax } 107c5b: 8d 65 f8 lea -0x8(%ebp),%esp 107c5e: 5b pop %ebx 107c5f: 5e pop %esi 107c60: c9 leave 107c61: c3 ret =============================================================================== 0010dd0c : IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) { 10dd0c: 55 push %ebp 10dd0d: 89 e5 mov %esp,%ebp 10dd0f: 57 push %edi 10dd10: 56 push %esi 10dd11: 53 push %ebx 10dd12: 83 ec 14 sub $0x14,%esp 10dd15: 8b 5d 08 mov 0x8(%ebp),%ebx 10dd18: 8b 7d 0c mov 0xc(%ebp),%edi /* * Check for "." and ".." */ if ( !strcmp( name, dotname ) ) 10dd1b: 68 e0 f3 11 00 push $0x11f3e0 10dd20: 57 push %edi 10dd21: e8 e6 40 00 00 call 111e0c 10dd26: 83 c4 10 add $0x10,%esp 10dd29: 85 c0 test %eax,%eax 10dd2b: 74 40 je 10dd6d <== NEVER TAKEN return directory; if ( !strcmp( name, dotdotname ) ) 10dd2d: 51 push %ecx 10dd2e: 51 push %ecx 10dd2f: 68 e2 f3 11 00 push $0x11f3e2 10dd34: 57 push %edi 10dd35: e8 d2 40 00 00 call 111e0c 10dd3a: 83 c4 10 add $0x10,%esp 10dd3d: 85 c0 test %eax,%eax 10dd3f: 75 05 jne 10dd46 <== ALWAYS TAKEN return directory->Parent; 10dd41: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10dd44: eb 27 jmp 10dd6d <== NOT EXECUTED if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10dd46: 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)); 10dd49: 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 ); 10dd4c: eb 15 jmp 10dd63 !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 ) ) 10dd4e: 8d 46 0c lea 0xc(%esi),%eax 10dd51: 52 push %edx 10dd52: 52 push %edx 10dd53: 50 push %eax 10dd54: 57 push %edi 10dd55: e8 b2 40 00 00 call 111e0c 10dd5a: 83 c4 10 add $0x10,%esp 10dd5d: 85 c0 test %eax,%eax 10dd5f: 74 0a je 10dd6b 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 ) { 10dd61: 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 ); 10dd63: 39 de cmp %ebx,%esi 10dd65: 75 e7 jne 10dd4e if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; 10dd67: 31 db xor %ebx,%ebx 10dd69: eb 02 jmp 10dd6d 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; 10dd6b: 89 f3 mov %esi,%ebx if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10dd6d: 89 d8 mov %ebx,%eax 10dd6f: 8d 65 f4 lea -0xc(%ebp),%esp 10dd72: 5b pop %ebx 10dd73: 5e pop %esi 10dd74: 5f pop %edi 10dd75: c9 leave 10dd76: c3 ret =============================================================================== 0010dc88 : ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next)) int IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 10dc88: 55 push %ebp 10dc89: 89 e5 mov %esp,%ebp 10dc8b: 57 push %edi 10dc8c: 56 push %esi 10dc8d: 53 push %ebx 10dc8e: 83 ec 2c sub $0x2c,%esp 10dc91: 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; 10dc94: 8b 58 1c mov 0x1c(%eax),%ebx loc = temp_mt_entry->mt_fs_root; 10dc97: 8d 7d d4 lea -0x2c(%ebp),%edi 10dc9a: 8d 70 1c lea 0x1c(%eax),%esi 10dc9d: b9 05 00 00 00 mov $0x5,%ecx 10dca2: 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; 10dca4: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) do { next = jnode->Parent; loc.node_access = (void *)jnode; IMFS_Set_handlers( &loc ); 10dcab: 8d 75 d4 lea -0x2c(%ebp),%esi */ temp_mt_entry->mt_fs_root.node_access = NULL; do { next = jnode->Parent; 10dcae: 8b 7b 08 mov 0x8(%ebx),%edi loc.node_access = (void *)jnode; 10dcb1: 89 5d d4 mov %ebx,-0x2c(%ebp) IMFS_Set_handlers( &loc ); 10dcb4: 83 ec 0c sub $0xc,%esp 10dcb7: 56 push %esi 10dcb8: e8 db f9 ff ff call 10d698 if ( jnode->type != IMFS_DIRECTORY ) { 10dcbd: 83 c4 10 add $0x10,%esp 10dcc0: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10dcc4: 75 08 jne 10dcce RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10dcc6: 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 ) ) { 10dcc9: 39 43 50 cmp %eax,0x50(%ebx) 10dccc: 75 13 jne 10dce1 result = IMFS_unlink( NULL, &loc ); 10dcce: 50 push %eax 10dccf: 50 push %eax 10dcd0: 56 push %esi 10dcd1: 6a 00 push $0x0 10dcd3: e8 0c 92 ff ff call 106ee4 if (result != 0) 10dcd8: 83 c4 10 add $0x10,%esp 10dcdb: 85 c0 test %eax,%eax 10dcdd: 75 1e jne 10dcfd <== NEVER TAKEN return -1; jnode = next; 10dcdf: 89 fb mov %edi,%ebx } if ( jnode != NULL ) { 10dce1: 85 db test %ebx,%ebx 10dce3: 74 1d je 10dd02 if ( jnode->type == IMFS_DIRECTORY ) { 10dce5: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10dce9: 75 c3 jne 10dcae <== NEVER TAKEN } } } while (jnode != NULL); return 0; } 10dceb: 8b 43 50 mov 0x50(%ebx),%eax 10dcee: 8d 53 54 lea 0x54(%ebx),%edx return -1; jnode = next; } if ( jnode != NULL ) { if ( jnode->type == IMFS_DIRECTORY ) { if ( jnode_has_children( jnode ) ) 10dcf1: 39 d0 cmp %edx,%eax 10dcf3: 74 b9 je 10dcae jnode = jnode_get_first_child( jnode ); 10dcf5: 89 c3 mov %eax,%ebx } } } while (jnode != NULL); 10dcf7: 85 c0 test %eax,%eax 10dcf9: 75 b3 jne 10dcae <== ALWAYS TAKEN 10dcfb: eb 05 jmp 10dd02 return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { result = IMFS_unlink( NULL, &loc ); if (result != 0) return -1; 10dcfd: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10dd00: eb 02 jmp 10dd04 <== NOT EXECUTED jnode = jnode_get_first_child( jnode ); } } } while (jnode != NULL); return 0; 10dd02: 31 c0 xor %eax,%eax } 10dd04: 8d 65 f4 lea -0xc(%ebp),%esp 10dd07: 5b pop %ebx 10dd08: 5e pop %esi 10dd09: 5f pop %edi 10dd0a: c9 leave 10dd0b: c3 ret =============================================================================== 0010dd78 : const char *path, int pathlen, char *token, int *token_len ) { 10dd78: 55 push %ebp 10dd79: 89 e5 mov %esp,%ebp 10dd7b: 57 push %edi 10dd7c: 56 push %esi 10dd7d: 53 push %ebx 10dd7e: 83 ec 1c sub $0x1c,%esp 10dd81: 8b 7d 08 mov 0x8(%ebp),%edi 10dd84: 8b 75 10 mov 0x10(%ebp),%esi register char c; /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; 10dd87: 8a 17 mov (%edi),%dl int pathlen, char *token, int *token_len ) { register int i = 0; 10dd89: 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) ) { 10dd8b: eb 10 jmp 10dd9d token[i] = c; 10dd8d: 88 14 1e mov %dl,(%esi,%ebx,1) if ( i == IMFS_NAME_MAX ) 10dd90: 83 fb 20 cmp $0x20,%ebx 10dd93: 0f 84 86 00 00 00 je 10de1f return IMFS_INVALID_TOKEN; if ( !IMFS_is_valid_name_char(c) ) type = IMFS_INVALID_TOKEN; c = path [++i]; 10dd99: 43 inc %ebx 10dd9a: 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) ) { 10dd9d: 83 ec 0c sub $0xc,%esp 10dda0: 0f be c2 movsbl %dl,%eax 10dda3: 50 push %eax 10dda4: 88 55 e4 mov %dl,-0x1c(%ebp) 10dda7: e8 54 a2 ff ff call 108000 10ddac: 83 c4 10 add $0x10,%esp 10ddaf: 85 c0 test %eax,%eax 10ddb1: 8a 55 e4 mov -0x1c(%ebp),%dl 10ddb4: 75 05 jne 10ddbb 10ddb6: 3b 5d 0c cmp 0xc(%ebp),%ebx 10ddb9: 7c d2 jl 10dd8d /* * Copy a seperator into token. */ if ( i == 0 ) { 10ddbb: 85 db test %ebx,%ebx 10ddbd: 75 10 jne 10ddcf token[i] = c; 10ddbf: 88 16 mov %dl,(%esi) if ( (token[i] != '\0') && pathlen ) { 10ddc1: 84 d2 test %dl,%dl 10ddc3: 74 06 je 10ddcb 10ddc5: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10ddc9: 75 16 jne 10dde1 i++; type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; 10ddcb: 31 ff xor %edi,%edi 10ddcd: eb 1c jmp 10ddeb char *token, int *token_len ) { register int i = 0; IMFS_token_types type = IMFS_NAME; 10ddcf: 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') { 10ddd4: 80 7c 1e ff 00 cmpb $0x0,-0x1(%esi,%ebx,1) 10ddd9: 74 10 je 10ddeb <== NEVER TAKEN token[i] = '\0'; 10dddb: c6 04 1e 00 movb $0x0,(%esi,%ebx,1) 10dddf: eb 0a jmp 10ddeb if ( i == 0 ) { token[i] = c; if ( (token[i] != '\0') && pathlen ) { i++; type = IMFS_CURRENT_DIR; 10dde1: bf 01 00 00 00 mov $0x1,%edi if ( i == 0 ) { token[i] = c; if ( (token[i] != '\0') && pathlen ) { i++; 10dde6: bb 01 00 00 00 mov $0x1,%ebx /* * Set token_len to the number of characters copied. */ *token_len = i; 10ddeb: 8b 45 14 mov 0x14(%ebp),%eax 10ddee: 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 ) { 10ddf0: 83 ff 03 cmp $0x3,%edi 10ddf3: 75 3d jne 10de32 if ( strcmp( token, "..") == 0 ) 10ddf5: 52 push %edx 10ddf6: 52 push %edx 10ddf7: 68 e5 f3 11 00 push $0x11f3e5 10ddfc: 56 push %esi 10ddfd: e8 0a 40 00 00 call 111e0c 10de02: 83 c4 10 add $0x10,%esp 10de05: 85 c0 test %eax,%eax 10de07: 74 1d je 10de26 type = IMFS_UP_DIR; else if ( strcmp( token, "." ) == 0 ) 10de09: 50 push %eax 10de0a: 50 push %eax 10de0b: 68 e6 f3 11 00 push $0x11f3e6 10de10: 56 push %esi 10de11: e8 f6 3f 00 00 call 111e0c 10de16: 83 c4 10 add $0x10,%esp 10de19: 85 c0 test %eax,%eax 10de1b: 74 10 je 10de2d 10de1d: eb 13 jmp 10de32 while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) { token[i] = c; if ( i == IMFS_NAME_MAX ) return IMFS_INVALID_TOKEN; 10de1f: bf 04 00 00 00 mov $0x4,%edi 10de24: eb 0c jmp 10de32 * it was a special name. */ if ( type == IMFS_NAME ) { if ( strcmp( token, "..") == 0 ) type = IMFS_UP_DIR; 10de26: bf 02 00 00 00 mov $0x2,%edi 10de2b: eb 05 jmp 10de32 else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; 10de2d: bf 01 00 00 00 mov $0x1,%edi } return type; } 10de32: 89 f8 mov %edi,%eax 10de34: 8d 65 f4 lea -0xc(%ebp),%esp 10de37: 5b pop %ebx 10de38: 5e pop %esi 10de39: 5f pop %edi 10de3a: c9 leave 10de3b: c3 ret =============================================================================== 00106b7c : 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 ) { 106b7c: 55 push %ebp 106b7d: 89 e5 mov %esp,%ebp 106b7f: 57 push %edi 106b80: 56 push %esi 106b81: 53 push %ebx 106b82: 83 ec 1c sub $0x1c,%esp 106b85: 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, 106b88: a1 48 11 12 00 mov 0x121148,%eax 106b8d: 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) { 106b92: ba 10 00 00 00 mov $0x10,%edx if (bit_mask == requested_bytes_per_block) { 106b97: 39 c2 cmp %eax,%edx 106b99: 74 0c je 106ba7 is_valid = true; break; } if(bit_mask > requested_bytes_per_block) 106b9b: 7f 05 jg 106ba2 int bit_mask; /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) { 106b9d: d1 e2 shl %edx 106b9f: 49 dec %ecx 106ba0: 75 f5 jne 106b97 <== ALWAYS TAKEN if(bit_mask > requested_bytes_per_block) break; } *dest_bytes_per_block = ((is_valid) ? requested_bytes_per_block : default_bytes_per_block); 106ba2: b8 80 00 00 00 mov $0x80,%eax break; } if(bit_mask > requested_bytes_per_block) break; } *dest_bytes_per_block = ((is_valid) 106ba7: a3 cc 4e 12 00 mov %eax,0x124ecc /* * 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(); 106bac: e8 b2 6a 00 00 call 10d663 106bb1: 89 c2 mov %eax,%edx 106bb3: 89 43 1c mov %eax,0x1c(%ebx) temp_mt_entry->mt_fs_root.handlers = directory_handlers; 106bb6: 8b 45 14 mov 0x14(%ebp),%eax 106bb9: 89 43 24 mov %eax,0x24(%ebx) temp_mt_entry->mt_fs_root.ops = op_table; 106bbc: 8b 45 0c mov 0xc(%ebp),%eax 106bbf: 89 43 28 mov %eax,0x28(%ebx) temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS; 106bc2: 8d 7b 38 lea 0x38(%ebx),%edi 106bc5: be 94 f3 11 00 mov $0x11f394,%esi 106bca: b9 0c 00 00 00 mov $0xc,%ecx 106bcf: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Create custom file system data. */ fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) ); 106bd1: 50 push %eax 106bd2: 50 push %eax 106bd3: 6a 14 push $0x14 106bd5: 6a 01 push $0x1 106bd7: 89 55 e4 mov %edx,-0x1c(%ebp) 106bda: e8 fd 05 00 00 call 1071dc if ( !fs_info ) { 106bdf: 83 c4 10 add $0x10,%esp 106be2: 85 c0 test %eax,%eax 106be4: 8b 55 e4 mov -0x1c(%ebp),%edx 106be7: 75 1c jne 106c05 free(temp_mt_entry->mt_fs_root.node_access); 106be9: 83 ec 0c sub $0xc,%esp 106bec: 52 push %edx 106bed: e8 56 07 00 00 call 107348 rtems_set_errno_and_return_minus_one(ENOMEM); 106bf2: e8 55 a5 00 00 call 11114c <__errno> 106bf7: c7 00 0c 00 00 00 movl $0xc,(%eax) 106bfd: 83 c4 10 add $0x10,%esp 106c00: 83 c8 ff or $0xffffffff,%eax 106c03: eb 34 jmp 106c39 } temp_mt_entry->fs_info = fs_info; 106c05: 89 43 34 mov %eax,0x34(%ebx) /* * Set st_ino for the root to 1. */ fs_info->instance = imfs_instance++; 106c08: 8b 0d d0 4e 12 00 mov 0x124ed0,%ecx 106c0e: 89 08 mov %ecx,(%eax) 106c10: 41 inc %ecx 106c11: 89 0d d0 4e 12 00 mov %ecx,0x124ed0 fs_info->ino_count = 1; 106c17: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) fs_info->memfile_handlers = memfile_handlers; 106c1e: 8b 4d 10 mov 0x10(%ebp),%ecx 106c21: 89 48 08 mov %ecx,0x8(%eax) fs_info->directory_handlers = directory_handlers; 106c24: 8b 4d 14 mov 0x14(%ebp),%ecx 106c27: 89 48 0c mov %ecx,0xc(%eax) fs_info->fifo_handlers = fifo_handlers; 106c2a: 8b 4d 18 mov 0x18(%ebp),%ecx 106c2d: 89 48 10 mov %ecx,0x10(%eax) jnode = temp_mt_entry->mt_fs_root.node_access; jnode->st_ino = fs_info->ino_count; 106c30: c7 42 38 01 00 00 00 movl $0x1,0x38(%edx) return 0; 106c37: 31 c0 xor %eax,%eax } 106c39: 8d 65 f4 lea -0xc(%ebp),%esp 106c3c: 5b pop %ebx 106c3d: 5e pop %esi 106c3e: 5f pop %edi 106c3f: c9 leave 106c40: c3 ret =============================================================================== 00110116 : */ MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) { 110116: 55 push %ebp 110117: 89 e5 mov %esp,%ebp 110119: 57 push %edi 11011a: 56 push %esi 11011b: 53 push %ebx 11011c: 83 ec 2c sub $0x2c,%esp 11011f: 8b 7d 08 mov 0x8(%ebp),%edi 110122: 8b 5d 0c mov 0xc(%ebp),%ebx 110125: 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 ) 110128: a1 cc 4e 12 00 mov 0x124ecc,%eax 11012d: 89 c1 mov %eax,%ecx 11012f: c1 e9 02 shr $0x2,%ecx 110132: 8d 51 01 lea 0x1(%ecx),%edx 110135: 0f af d1 imul %ecx,%edx 110138: 42 inc %edx 110139: 0f af d1 imul %ecx,%edx 11013c: 4a dec %edx 11013d: 0f af d0 imul %eax,%edx 110140: 83 fe 00 cmp $0x0,%esi 110143: 7c 16 jl 11015b <== NEVER TAKEN 110145: 7f 04 jg 11014b <== NEVER TAKEN 110147: 39 d3 cmp %edx,%ebx 110149: 72 10 jb 11015b rtems_set_errno_and_return_minus_one( EINVAL ); 11014b: e8 fc 0f 00 00 call 11114c <__errno> 110150: c7 00 16 00 00 00 movl $0x16,(%eax) 110156: e9 92 00 00 00 jmp 1101ed /* * Verify new file size is actually larger than current size */ if ( new_length <= the_jnode->info.file.size ) 11015b: 8b 57 50 mov 0x50(%edi),%edx 11015e: 8b 4f 54 mov 0x54(%edi),%ecx 110161: 89 55 e0 mov %edx,-0x20(%ebp) 110164: 89 4d e4 mov %ecx,-0x1c(%ebp) 110167: 39 ce cmp %ecx,%esi 110169: 0f 8c 8f 00 00 00 jl 1101fe <== NEVER TAKEN 11016f: 7f 08 jg 110179 <== NEVER TAKEN 110171: 39 d3 cmp %edx,%ebx 110173: 0f 86 85 00 00 00 jbe 1101fe return 0; /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; 110179: 89 45 d8 mov %eax,-0x28(%ebp) 11017c: 89 c1 mov %eax,%ecx 11017e: c1 f9 1f sar $0x1f,%ecx 110181: 89 4d dc mov %ecx,-0x24(%ebp) 110184: ff 75 dc pushl -0x24(%ebp) 110187: ff 75 d8 pushl -0x28(%ebp) 11018a: 56 push %esi 11018b: 53 push %ebx 11018c: e8 3f c8 00 00 call 11c9d0 <__divdi3> 110191: 83 c4 10 add $0x10,%esp 110194: 89 45 d4 mov %eax,-0x2c(%ebp) old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; 110197: ff 75 dc pushl -0x24(%ebp) 11019a: ff 75 d8 pushl -0x28(%ebp) 11019d: ff 75 e4 pushl -0x1c(%ebp) 1101a0: ff 75 e0 pushl -0x20(%ebp) 1101a3: e8 28 c8 00 00 call 11c9d0 <__divdi3> 1101a8: 83 c4 10 add $0x10,%esp 1101ab: 89 45 e0 mov %eax,-0x20(%ebp) /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 1101ae: 89 c2 mov %eax,%edx 1101b0: eb 41 jmp 1101f3 if ( IMFS_memfile_addblock( the_jnode, block ) ) { 1101b2: 51 push %ecx 1101b3: 51 push %ecx 1101b4: 52 push %edx 1101b5: 57 push %edi 1101b6: 89 55 d0 mov %edx,-0x30(%ebp) 1101b9: e8 99 fd ff ff call 10ff57 1101be: 83 c4 10 add $0x10,%esp 1101c1: 85 c0 test %eax,%eax 1101c3: 8b 55 d0 mov -0x30(%ebp),%edx 1101c6: 74 2a je 1101f2 1101c8: eb 13 jmp 1101dd for ( ; block>=old_blocks ; block-- ) { IMFS_memfile_remove_block( the_jnode, block ); 1101ca: 50 push %eax 1101cb: 50 push %eax 1101cc: 52 push %edx 1101cd: 57 push %edi 1101ce: 89 55 d0 mov %edx,-0x30(%ebp) 1101d1: e8 16 ff ff ff call 1100ec /* * 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-- ) { 1101d6: 8b 55 d0 mov -0x30(%ebp),%edx 1101d9: 4a dec %edx 1101da: 83 c4 10 add $0x10,%esp 1101dd: 3b 55 e0 cmp -0x20(%ebp),%edx 1101e0: 73 e8 jae 1101ca IMFS_memfile_remove_block( the_jnode, block ); } rtems_set_errno_and_return_minus_one( ENOSPC ); 1101e2: e8 65 0f 00 00 call 11114c <__errno> 1101e7: c7 00 1c 00 00 00 movl $0x1c,(%eax) 1101ed: 83 c8 ff or $0xffffffff,%eax 1101f0: eb 0e jmp 110200 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++ ) { 1101f2: 42 inc %edx 1101f3: 3b 55 d4 cmp -0x2c(%ebp),%edx 1101f6: 76 ba jbe 1101b2 } /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; 1101f8: 89 5f 50 mov %ebx,0x50(%edi) 1101fb: 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; 1101fe: 31 c0 xor %eax,%eax /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; return 0; } 110200: 8d 65 f4 lea -0xc(%ebp),%esp 110203: 5b pop %ebx 110204: 5e pop %esi 110205: 5f pop %edi 110206: c9 leave 110207: c3 ret =============================================================================== 0010fc5c : #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) { 10fc5c: 55 push %ebp 10fc5d: 89 e5 mov %esp,%ebp 10fc5f: 57 push %edi 10fc60: 56 push %esi 10fc61: 53 push %ebx 10fc62: 83 ec 1c sub $0x1c,%esp 10fc65: 8b 75 08 mov 0x8(%ebp),%esi 10fc68: 8b 7d 0c mov 0xc(%ebp),%edi my_block = block; /* * Is the block number in the simple indirect portion? */ if ( my_block <= LAST_INDIRECT ) { 10fc6b: 8b 0d cc 4e 12 00 mov 0x124ecc,%ecx 10fc71: c1 e9 02 shr $0x2,%ecx 10fc74: 8d 41 ff lea -0x1(%ecx),%eax 10fc77: 39 c7 cmp %eax,%edi 10fc79: 77 40 ja 10fcbb p = info->indirect; 10fc7b: 8b 46 58 mov 0x58(%esi),%eax if ( malloc_it ) { 10fc7e: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10fc82: 74 25 je 10fca9 if ( !p ) { 10fc84: 85 c0 test %eax,%eax 10fc86: 75 12 jne 10fc9a p = memfile_alloc_block(); 10fc88: e8 ad ff ff ff call 10fc3a if ( !p ) return 0; 10fc8d: 31 db xor %ebx,%ebx if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); if ( !p ) 10fc8f: 85 c0 test %eax,%eax 10fc91: 0f 84 f7 00 00 00 je 10fd8e <== NEVER TAKEN return 0; info->indirect = p; 10fc97: 89 46 58 mov %eax,0x58(%esi) } return &info->indirect[ my_block ]; 10fc9a: 8d 1c bd 00 00 00 00 lea 0x0(,%edi,4),%ebx 10fca1: 03 5e 58 add 0x58(%esi),%ebx 10fca4: e9 e5 00 00 00 jmp 10fd8e } if ( !p ) return 0; 10fca9: 31 db xor %ebx,%ebx info->indirect = p; } return &info->indirect[ my_block ]; } if ( !p ) 10fcab: 85 c0 test %eax,%eax 10fcad: 0f 84 db 00 00 00 je 10fd8e <== NEVER TAKEN return 0; return &info->indirect[ my_block ]; 10fcb3: 8d 1c b8 lea (%eax,%edi,4),%ebx 10fcb6: e9 d3 00 00 00 jmp 10fd8e /* * Is the block number in the doubly indirect portion? */ if ( my_block <= LAST_DOUBLY_INDIRECT ) { 10fcbb: 8d 41 01 lea 0x1(%ecx),%eax 10fcbe: 0f af c1 imul %ecx,%eax 10fcc1: 8d 50 ff lea -0x1(%eax),%edx 10fcc4: 39 d7 cmp %edx,%edi 10fcc6: 77 40 ja 10fd08 my_block -= FIRST_DOUBLY_INDIRECT; 10fcc8: 29 cf sub %ecx,%edi singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 10fcca: 89 f8 mov %edi,%eax 10fccc: 31 d2 xor %edx,%edx 10fcce: f7 f1 div %ecx 10fcd0: 89 55 e4 mov %edx,-0x1c(%ebp) 10fcd3: 89 c7 mov %eax,%edi doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; p = info->doubly_indirect; 10fcd5: 8b 46 5c mov 0x5c(%esi),%eax if ( malloc_it ) { 10fcd8: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10fcdc: 74 1b je 10fcf9 if ( !p ) { 10fcde: 85 c0 test %eax,%eax 10fce0: 75 12 jne 10fcf4 p = memfile_alloc_block(); 10fce2: e8 53 ff ff ff call 10fc3a if ( !p ) return 0; 10fce7: 31 db xor %ebx,%ebx p = info->doubly_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); if ( !p ) 10fce9: 85 c0 test %eax,%eax 10fceb: 0f 84 9d 00 00 00 je 10fd8e <== NEVER TAKEN return 0; info->doubly_indirect = p; 10fcf1: 89 46 5c mov %eax,0x5c(%esi) } p1 = (block_p *)p[ doubly ]; 10fcf4: 8d 34 b8 lea (%eax,%edi,4),%esi 10fcf7: eb 65 jmp 10fd5e return (block_p *)&p1[ singly ]; } if ( !p ) return 0; 10fcf9: 31 db xor %ebx,%ebx } return (block_p *)&p1[ singly ]; } if ( !p ) 10fcfb: 85 c0 test %eax,%eax 10fcfd: 0f 84 8b 00 00 00 je 10fd8e <== NEVER TAKEN return 0; p = (block_p *)p[ doubly ]; 10fd03: 8b 04 b8 mov (%eax,%edi,4),%eax 10fd06: eb 7c jmp 10fd84 } /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 10fd08: 8d 50 01 lea 0x1(%eax),%edx 10fd0b: 0f af d1 imul %ecx,%edx 10fd0e: 4a dec %edx } /* * This means the requested block number is out of range. */ return 0; 10fd0f: 31 db xor %ebx,%ebx } /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 10fd11: 39 d7 cmp %edx,%edi 10fd13: 77 79 ja 10fd8e <== NEVER TAKEN my_block -= FIRST_TRIPLY_INDIRECT; 10fd15: 29 c7 sub %eax,%edi 10fd17: 89 f8 mov %edi,%eax singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 10fd19: 31 d2 xor %edx,%edx 10fd1b: f7 f1 div %ecx 10fd1d: 89 55 e4 mov %edx,-0x1c(%ebp) doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; 10fd20: 31 d2 xor %edx,%edx 10fd22: f7 f1 div %ecx 10fd24: 89 55 e0 mov %edx,-0x20(%ebp) 10fd27: 89 c7 mov %eax,%edi doubly %= IMFS_MEMFILE_BLOCK_SLOTS; p = info->triply_indirect; 10fd29: 8b 46 60 mov 0x60(%esi),%eax if ( malloc_it ) { 10fd2c: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10fd30: 74 41 je 10fd73 if ( !p ) { 10fd32: 85 c0 test %eax,%eax 10fd34: 75 0c jne 10fd42 p = memfile_alloc_block(); 10fd36: e8 ff fe ff ff call 10fc3a if ( !p ) 10fd3b: 85 c0 test %eax,%eax 10fd3d: 74 4f je 10fd8e <== NEVER TAKEN return 0; info->triply_indirect = p; 10fd3f: 89 46 60 mov %eax,0x60(%esi) } p1 = (block_p *) p[ triply ]; 10fd42: 8d 34 b8 lea (%eax,%edi,4),%esi 10fd45: 8b 06 mov (%esi),%eax if ( !p1 ) { 10fd47: 85 c0 test %eax,%eax 10fd49: 75 0d jne 10fd58 p1 = memfile_alloc_block(); 10fd4b: e8 ea fe ff ff call 10fc3a if ( !p1 ) return 0; 10fd50: 31 db xor %ebx,%ebx } p1 = (block_p *) p[ triply ]; if ( !p1 ) { p1 = memfile_alloc_block(); if ( !p1 ) 10fd52: 85 c0 test %eax,%eax 10fd54: 74 38 je 10fd8e <== NEVER TAKEN return 0; p[ triply ] = (block_p) p1; 10fd56: 89 06 mov %eax,(%esi) } p2 = (block_p *)p1[ doubly ]; 10fd58: 8b 55 e0 mov -0x20(%ebp),%edx 10fd5b: 8d 34 90 lea (%eax,%edx,4),%esi 10fd5e: 8b 06 mov (%esi),%eax if ( !p2 ) { 10fd60: 85 c0 test %eax,%eax 10fd62: 75 24 jne 10fd88 p2 = memfile_alloc_block(); 10fd64: e8 d1 fe ff ff call 10fc3a if ( !p2 ) return 0; 10fd69: 31 db xor %ebx,%ebx } p2 = (block_p *)p1[ doubly ]; if ( !p2 ) { p2 = memfile_alloc_block(); if ( !p2 ) 10fd6b: 85 c0 test %eax,%eax 10fd6d: 74 1f je 10fd8e <== NEVER TAKEN return 0; p1[ doubly ] = (block_p) p2; 10fd6f: 89 06 mov %eax,(%esi) 10fd71: eb 15 jmp 10fd88 } return (block_p *)&p2[ singly ]; } if ( !p ) 10fd73: 85 c0 test %eax,%eax 10fd75: 74 17 je 10fd8e <== NEVER TAKEN return 0; p1 = (block_p *) p[ triply ]; 10fd77: 8b 04 b8 mov (%eax,%edi,4),%eax if ( !p1 ) 10fd7a: 85 c0 test %eax,%eax 10fd7c: 74 10 je 10fd8e <== NEVER TAKEN return 0; p2 = (block_p *)p1[ doubly ]; 10fd7e: 8b 55 e0 mov -0x20(%ebp),%edx 10fd81: 8b 04 90 mov (%eax,%edx,4),%eax if ( !p2 ) 10fd84: 85 c0 test %eax,%eax 10fd86: 74 06 je 10fd8e <== NEVER TAKEN return 0; return (block_p *)&p2[ singly ]; 10fd88: 8b 55 e4 mov -0x1c(%ebp),%edx 10fd8b: 8d 1c 90 lea (%eax,%edx,4),%ebx /* * This means the requested block number is out of range. */ return 0; } 10fd8e: 89 d8 mov %ebx,%eax 10fd90: 83 c4 1c add $0x1c,%esp 10fd93: 5b pop %ebx 10fd94: 5e pop %esi 10fd95: 5f pop %edi 10fd96: c9 leave 10fd97: c3 ret =============================================================================== 0010fd98 : IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) { 10fd98: 55 push %ebp 10fd99: 89 e5 mov %esp,%ebp 10fd9b: 57 push %edi 10fd9c: 56 push %esi 10fd9d: 53 push %ebx 10fd9e: 83 ec 4c sub $0x4c,%esp 10fda1: 8b 75 0c mov 0xc(%ebp),%esi 10fda4: 8b 7d 10 mov 0x10(%ebp),%edi 10fda7: 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) { 10fdaa: 8b 45 08 mov 0x8(%ebp),%eax 10fdad: 83 78 4c 06 cmpl $0x6,0x4c(%eax) 10fdb1: 75 3f jne 10fdf2 unsigned char *file_ptr; file_ptr = (unsigned char *)the_jnode->info.linearfile.direct; 10fdb3: 8b 48 58 mov 0x58(%eax),%ecx if (my_length > (the_jnode->info.linearfile.size - start)) 10fdb6: 89 c2 mov %eax,%edx 10fdb8: 8b 40 50 mov 0x50(%eax),%eax 10fdbb: 8b 52 54 mov 0x54(%edx),%edx 10fdbe: 89 45 b0 mov %eax,-0x50(%ebp) 10fdc1: 89 55 b4 mov %edx,-0x4c(%ebp) 10fdc4: 29 f0 sub %esi,%eax 10fdc6: 19 fa sbb %edi,%edx 10fdc8: 89 45 d0 mov %eax,-0x30(%ebp) 10fdcb: 89 55 d4 mov %edx,-0x2c(%ebp) 10fdce: 31 c0 xor %eax,%eax 10fdd0: 39 d0 cmp %edx,%eax 10fdd2: 7c 0e jl 10fde2 <== NEVER TAKEN 10fdd4: 7f 05 jg 10fddb <== NEVER TAKEN 10fdd6: 3b 5d d0 cmp -0x30(%ebp),%ebx 10fdd9: 76 07 jbe 10fde2 <== NEVER TAKEN my_length = the_jnode->info.linearfile.size - start; 10fddb: 8b 55 b0 mov -0x50(%ebp),%edx 10fdde: 29 f2 sub %esi,%edx 10fde0: eb 02 jmp 10fde4 /* * Linear files (as created from a tar file are easier to handle * than block files). */ my_length = length; 10fde2: 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); 10fde4: 01 ce add %ecx,%esi 10fde6: 8b 7d 14 mov 0x14(%ebp),%edi 10fde9: 89 d1 mov %edx,%ecx 10fdeb: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10fded: e9 1d 01 00 00 jmp 10ff0f /* * 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; 10fdf2: 89 f0 mov %esi,%eax if ( last_byte > the_jnode->info.file.size ) 10fdf4: 8b 55 08 mov 0x8(%ebp),%edx 10fdf7: 8b 52 50 mov 0x50(%edx),%edx 10fdfa: 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; 10fdfd: 8d 0c 33 lea (%ebx,%esi,1),%ecx 10fe00: 89 4d d0 mov %ecx,-0x30(%ebp) if ( last_byte > the_jnode->info.file.size ) 10fe03: 31 c9 xor %ecx,%ecx 10fe05: 8b 55 08 mov 0x8(%ebp),%edx 10fe08: 3b 4a 54 cmp 0x54(%edx),%ecx 10fe0b: 7c 14 jl 10fe21 <== NEVER TAKEN 10fe0d: 7f 08 jg 10fe17 <== NEVER TAKEN 10fe0f: 8b 4d cc mov -0x34(%ebp),%ecx 10fe12: 39 4d d0 cmp %ecx,-0x30(%ebp) 10fe15: 76 0a jbe 10fe21 my_length = the_jnode->info.file.size - start; 10fe17: 8b 55 cc mov -0x34(%ebp),%edx 10fe1a: 29 c2 sub %eax,%edx 10fe1c: 89 55 d0 mov %edx,-0x30(%ebp) 10fe1f: eb 03 jmp 10fe24 /* * Linear files (as created from a tar file are easier to handle * than block files). */ my_length = length; 10fe21: 89 5d d0 mov %ebx,-0x30(%ebp) */ /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 10fe24: 8b 0d cc 4e 12 00 mov 0x124ecc,%ecx 10fe2a: 89 4d c4 mov %ecx,-0x3c(%ebp) 10fe2d: 89 c8 mov %ecx,%eax 10fe2f: 99 cltd 10fe30: 89 d3 mov %edx,%ebx 10fe32: 52 push %edx 10fe33: 51 push %ecx 10fe34: 57 push %edi 10fe35: 56 push %esi 10fe36: 89 4d c0 mov %ecx,-0x40(%ebp) 10fe39: e8 de cc 00 00 call 11cb1c <__moddi3> 10fe3e: 83 c4 10 add $0x10,%esp 10fe41: 89 45 cc mov %eax,-0x34(%ebp) block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 10fe44: 8b 4d c0 mov -0x40(%ebp),%ecx 10fe47: 53 push %ebx 10fe48: 51 push %ecx 10fe49: 57 push %edi 10fe4a: 56 push %esi 10fe4b: e8 80 cb 00 00 call 11c9d0 <__divdi3> 10fe50: 83 c4 10 add $0x10,%esp 10fe53: 89 c3 mov %eax,%ebx if ( start_offset ) { 10fe55: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 10fe59: 74 3d je 10fe98 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 ); 10fe5b: 57 push %edi 10fe5c: 6a 00 push $0x0 10fe5e: 50 push %eax 10fe5f: ff 75 08 pushl 0x8(%ebp) 10fe62: e8 f5 fd ff ff call 10fc5c if ( !block_ptr ) 10fe67: 83 c4 10 add $0x10,%esp return copied; 10fe6a: 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 ) 10fe6c: 85 c0 test %eax,%eax 10fe6e: 0f 84 ba 00 00 00 je 10ff2e <== 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; 10fe74: 8b 4d c4 mov -0x3c(%ebp),%ecx 10fe77: 2b 4d cc sub -0x34(%ebp),%ecx 10fe7a: 8b 55 d0 mov -0x30(%ebp),%edx 10fe7d: 39 ca cmp %ecx,%edx 10fe7f: 76 02 jbe 10fe83 10fe81: 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 ); 10fe83: 8b 75 cc mov -0x34(%ebp),%esi 10fe86: 03 30 add (%eax),%esi dest += to_copy; 10fe88: 8b 7d 14 mov 0x14(%ebp),%edi 10fe8b: 89 d1 mov %edx,%ecx 10fe8d: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10fe8f: 89 7d cc mov %edi,-0x34(%ebp) block++; 10fe92: 43 inc %ebx my_length -= to_copy; 10fe93: 29 55 d0 sub %edx,-0x30(%ebp) 10fe96: eb 08 jmp 10fea0 unsigned int last_byte; unsigned int copied; unsigned int start_offset; unsigned char *dest; dest = destination; 10fe98: 8b 45 14 mov 0x14(%ebp),%eax 10fe9b: 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; 10fe9e: 31 d2 xor %edx,%edx } /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 10fea0: 8b 0d cc 4e 12 00 mov 0x124ecc,%ecx 10fea6: 89 4d c8 mov %ecx,-0x38(%ebp) while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 10fea9: eb 2f jmp 10feda block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 10feab: 56 push %esi 10feac: 6a 00 push $0x0 10feae: 53 push %ebx 10feaf: ff 75 08 pushl 0x8(%ebp) 10feb2: 89 55 c0 mov %edx,-0x40(%ebp) 10feb5: e8 a2 fd ff ff call 10fc5c if ( !block_ptr ) 10feba: 83 c4 10 add $0x10,%esp 10febd: 85 c0 test %eax,%eax 10febf: 8b 55 c0 mov -0x40(%ebp),%edx 10fec2: 74 6a je 10ff2e <== NEVER TAKEN return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); 10fec4: 8b 30 mov (%eax),%esi 10fec6: 8b 7d cc mov -0x34(%ebp),%edi 10fec9: 8b 4d c8 mov -0x38(%ebp),%ecx 10fecc: f3 a4 rep movsb %ds:(%esi),%es:(%edi) dest += to_copy; 10fece: 89 7d cc mov %edi,-0x34(%ebp) block++; 10fed1: 43 inc %ebx my_length -= to_copy; 10fed2: 8b 7d c8 mov -0x38(%ebp),%edi 10fed5: 29 7d d0 sub %edi,-0x30(%ebp) copied += to_copy; 10fed8: 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 ) { 10feda: 8b 45 d0 mov -0x30(%ebp),%eax 10fedd: 3b 05 cc 4e 12 00 cmp 0x124ecc,%eax 10fee3: 73 c6 jae 10feab /* * Phase 3: possibly the first part of one block */ IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { 10fee5: 85 c0 test %eax,%eax 10fee7: 74 26 je 10ff0f block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 10fee9: 51 push %ecx 10feea: 6a 00 push $0x0 10feec: 53 push %ebx 10feed: ff 75 08 pushl 0x8(%ebp) 10fef0: 89 55 c0 mov %edx,-0x40(%ebp) 10fef3: e8 64 fd ff ff call 10fc5c if ( !block_ptr ) 10fef8: 83 c4 10 add $0x10,%esp 10fefb: 85 c0 test %eax,%eax 10fefd: 8b 55 c0 mov -0x40(%ebp),%edx 10ff00: 74 2c je 10ff2e <== NEVER TAKEN return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); 10ff02: 8b 30 mov (%eax),%esi 10ff04: 8b 7d cc mov -0x34(%ebp),%edi 10ff07: 8b 4d d0 mov -0x30(%ebp),%ecx 10ff0a: f3 a4 rep movsb %ds:(%esi),%es:(%edi) copied += my_length; 10ff0c: 03 55 d0 add -0x30(%ebp),%edx } IMFS_update_atime( the_jnode ); 10ff0f: 50 push %eax 10ff10: 50 push %eax 10ff11: 6a 00 push $0x0 10ff13: 8d 45 e0 lea -0x20(%ebp),%eax 10ff16: 50 push %eax 10ff17: 89 55 c0 mov %edx,-0x40(%ebp) 10ff1a: e8 a1 74 ff ff call 1073c0 10ff1f: 8b 45 e0 mov -0x20(%ebp),%eax 10ff22: 8b 4d 08 mov 0x8(%ebp),%ecx 10ff25: 89 41 40 mov %eax,0x40(%ecx) return copied; 10ff28: 8b 55 c0 mov -0x40(%ebp),%edx 10ff2b: 83 c4 10 add $0x10,%esp } 10ff2e: 89 d0 mov %edx,%eax 10ff30: 8d 65 f4 lea -0xc(%ebp),%esp 10ff33: 5b pop %ebx 10ff34: 5e pop %esi 10ff35: 5f pop %edi 10ff36: c9 leave 10ff37: c3 ret =============================================================================== 0010fff6 : * is better to stick to simple, easy to understand algorithms. */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) { 10fff6: 55 push %ebp 10fff7: 89 e5 mov %esp,%ebp 10fff9: 57 push %edi 10fffa: 56 push %esi 10fffb: 53 push %ebx 10fffc: 83 ec 1c sub $0x1c,%esp 10ffff: 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; 110002: 8b 35 cc 4e 12 00 mov 0x124ecc,%esi 110008: c1 ee 02 shr $0x2,%esi * + doubly indirect * + triply indirect */ info = &the_jnode->info.file; if ( info->indirect ) { 11000b: 83 7b 58 00 cmpl $0x0,0x58(%ebx) 11000f: 74 0f je 110020 memfile_free_blocks_in_table( &info->indirect, to_free ); 110011: 57 push %edi 110012: 57 push %edi 110013: 56 push %esi 110014: 8d 43 58 lea 0x58(%ebx),%eax 110017: 50 push %eax 110018: e8 8c ff ff ff call 10ffa9 11001d: 83 c4 10 add $0x10,%esp } if ( info->doubly_indirect ) { 110020: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx) 110024: 74 3e je 110064 110026: 31 ff xor %edi,%edi 110028: eb 1f jmp 110049 for ( i=0 ; idoubly_indirect[i] ) { 11002a: 8b 43 5c mov 0x5c(%ebx),%eax 11002d: 8d 14 bd 00 00 00 00 lea 0x0(,%edi,4),%edx 110034: 83 3c b8 00 cmpl $0x0,(%eax,%edi,4) 110038: 74 0e je 110048 <== NEVER TAKEN memfile_free_blocks_in_table( 11003a: 51 push %ecx 11003b: 51 push %ecx 11003c: 56 push %esi 11003d: 01 d0 add %edx,%eax 11003f: 50 push %eax 110040: e8 64 ff ff ff call 10ffa9 110045: 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 ); 110055: 57 push %edi 110056: 57 push %edi 110057: 56 push %esi 110058: 8d 43 5c lea 0x5c(%ebx),%eax 11005b: 50 push %eax 11005c: e8 48 ff ff ff call 10ffa9 110061: 83 c4 10 add $0x10,%esp } if ( info->triply_indirect ) { 110064: 83 7b 60 00 cmpl $0x0,0x60(%ebx) 110068: 74 78 je 1100e2 11006a: 31 ff xor %edi,%edi 11006c: eb 59 jmp 1100c7 11006e: 8d 04 bd 00 00 00 00 lea 0x0(,%edi,4),%eax 110075: 89 45 e4 mov %eax,-0x1c(%ebp) for ( i=0 ; itriply_indirect[i]; 110078: 8b 43 60 mov 0x60(%ebx),%eax 11007b: 8b 04 b8 mov (%eax,%edi,4),%eax if ( !p ) /* ensure we have a valid pointer */ 11007e: 85 c0 test %eax,%eax 110080: 74 51 je 1100d3 <== NEVER TAKEN 110082: 31 d2 xor %edx,%edx 110084: eb 21 jmp 1100a7 break; for ( j=0 ; j<== NEVER TAKEN memfile_free_blocks_in_table( (block_p **)&p[j], to_free); 11008b: 51 push %ecx 11008c: 51 push %ecx 11008d: 56 push %esi 11008e: 50 push %eax 11008f: 89 45 dc mov %eax,-0x24(%ebp) 110092: 89 55 e0 mov %edx,-0x20(%ebp) 110095: e8 0f ff ff ff call 10ffa9 11009a: 83 c4 10 add $0x10,%esp 11009d: 8b 55 e0 mov -0x20(%ebp),%edx 1100a0: 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( 1100b4: 52 push %edx 1100b5: 52 push %edx 1100b6: 56 push %esi 1100b7: 8b 45 e4 mov -0x1c(%ebp),%eax 1100ba: 03 43 60 add 0x60(%ebx),%eax 1100bd: 50 push %eax 1100be: e8 e6 fe ff ff call 10ffa9 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( 1100d3: 50 push %eax 1100d4: 50 push %eax 1100d5: 56 push %esi (block_p **)&info->triply_indirect, to_free ); 1100d6: 83 c3 60 add $0x60,%ebx } } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( 1100d9: 53 push %ebx 1100da: e8 ca fe ff ff call 10ffa9 1100df: 83 c4 10 add $0x10,%esp (block_p **)&info->triply_indirect, to_free ); } return 0; } 1100e2: 31 c0 xor %eax,%eax 1100e4: 8d 65 f4 lea -0xc(%ebp),%esp 1100e7: 5b pop %ebx 1100e8: 5e pop %esi 1100e9: 5f pop %edi 1100ea: c9 leave 1100eb: c3 ret =============================================================================== 00110208 : IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 110208: 55 push %ebp 110209: 89 e5 mov %esp,%ebp 11020b: 57 push %edi 11020c: 56 push %esi 11020d: 53 push %ebx 11020e: 83 ec 2c sub $0x2c,%esp 110211: 8b 75 0c mov 0xc(%ebp),%esi 110214: 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; 110217: 8b 4d 18 mov 0x18(%ebp),%ecx 11021a: 01 f1 add %esi,%ecx if ( last_byte > the_jnode->info.file.size ) { 11021c: 89 c8 mov %ecx,%eax 11021e: 31 d2 xor %edx,%edx 110220: 8b 5d 08 mov 0x8(%ebp),%ebx 110223: 3b 53 54 cmp 0x54(%ebx),%edx 110226: 7c 2c jl 110254 <== NEVER TAKEN 110228: 7f 05 jg 11022f <== NEVER TAKEN 11022a: 3b 4b 50 cmp 0x50(%ebx),%ecx 11022d: 76 25 jbe 110254 <== NEVER TAKEN status = IMFS_memfile_extend( the_jnode, last_byte ); 11022f: 51 push %ecx 110230: 52 push %edx 110231: 50 push %eax 110232: ff 75 08 pushl 0x8(%ebp) 110235: e8 dc fe ff ff call 110116 if ( status ) 11023a: 83 c4 10 add $0x10,%esp 11023d: 85 c0 test %eax,%eax 11023f: 74 13 je 110254 rtems_set_errno_and_return_minus_one( ENOSPC ); 110241: e8 06 0f 00 00 call 11114c <__errno> 110246: c7 00 1c 00 00 00 movl $0x1c,(%eax) 11024c: 83 c9 ff or $0xffffffff,%ecx 11024f: e9 0f 01 00 00 jmp 110363 */ /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 110254: a1 cc 4e 12 00 mov 0x124ecc,%eax 110259: 89 45 cc mov %eax,-0x34(%ebp) 11025c: 99 cltd 11025d: 89 d3 mov %edx,%ebx 11025f: 52 push %edx 110260: 50 push %eax 110261: 57 push %edi 110262: 56 push %esi 110263: 89 45 c8 mov %eax,-0x38(%ebp) 110266: e8 b1 c8 00 00 call 11cb1c <__moddi3> 11026b: 83 c4 10 add $0x10,%esp 11026e: 89 45 d0 mov %eax,-0x30(%ebp) block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 110271: 8b 4d c8 mov -0x38(%ebp),%ecx 110274: 53 push %ebx 110275: 51 push %ecx 110276: 57 push %edi 110277: 56 push %esi 110278: e8 53 c7 00 00 call 11c9d0 <__divdi3> 11027d: 83 c4 10 add $0x10,%esp 110280: 89 c3 mov %eax,%ebx if ( start_offset ) { 110282: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 110286: 74 40 je 1102c8 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 ); 110288: 52 push %edx 110289: 6a 00 push $0x0 11028b: 53 push %ebx 11028c: ff 75 08 pushl 0x8(%ebp) 11028f: e8 c8 f9 ff ff call 10fc5c if ( !block_ptr ) 110294: 83 c4 10 add $0x10,%esp return copied; 110297: 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 ) 110299: 85 c0 test %eax,%eax 11029b: 0f 84 c2 00 00 00 je 110363 <== 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; 1102a1: 8b 55 cc mov -0x34(%ebp),%edx 1102a4: 2b 55 d0 sub -0x30(%ebp),%edx 1102a7: 3b 55 18 cmp 0x18(%ebp),%edx 1102aa: 76 03 jbe 1102af 1102ac: 8b 55 18 mov 0x18(%ebp),%edx block, to_copy, src ); #endif memcpy( &(*block_ptr)[ start_offset ], src, to_copy ); 1102af: 8b 00 mov (%eax),%eax 1102b1: 03 45 d0 add -0x30(%ebp),%eax src += to_copy; 1102b4: 89 c7 mov %eax,%edi 1102b6: 8b 75 14 mov 0x14(%ebp),%esi 1102b9: 89 d1 mov %edx,%ecx 1102bb: f3 a4 rep movsb %ds:(%esi),%es:(%edi) block++; 1102bd: 43 inc %ebx my_length -= to_copy; 1102be: 8b 4d 18 mov 0x18(%ebp),%ecx 1102c1: 29 d1 sub %edx,%ecx 1102c3: 89 4d d4 mov %ecx,-0x2c(%ebp) 1102c6: eb 0b jmp 1102d3 unsigned int last_byte; unsigned int start_offset; int copied; const unsigned char *src; src = source; 1102c8: 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 ) { 1102cb: 8b 45 18 mov 0x18(%ebp),%eax 1102ce: 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; 1102d1: 31 d2 xor %edx,%edx /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 1102d3: 8b 0d cc 4e 12 00 mov 0x124ecc,%ecx 1102d9: 89 4d d0 mov %ecx,-0x30(%ebp) while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 1102dc: eb 2b jmp 110309 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 1102de: 50 push %eax 1102df: 6a 00 push $0x0 1102e1: 53 push %ebx 1102e2: ff 75 08 pushl 0x8(%ebp) 1102e5: 89 55 c8 mov %edx,-0x38(%ebp) 1102e8: e8 6f f9 ff ff call 10fc5c if ( !block_ptr ) 1102ed: 83 c4 10 add $0x10,%esp 1102f0: 85 c0 test %eax,%eax 1102f2: 8b 55 c8 mov -0x38(%ebp),%edx 1102f5: 74 6a je 110361 <== 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 ); 1102f7: 8b 00 mov (%eax),%eax src += to_copy; 1102f9: 89 c7 mov %eax,%edi 1102fb: 8b 4d d0 mov -0x30(%ebp),%ecx 1102fe: f3 a4 rep movsb %ds:(%esi),%es:(%edi) block++; 110300: 43 inc %ebx my_length -= to_copy; 110301: 8b 45 d0 mov -0x30(%ebp),%eax 110304: 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( 110307: 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 ) { 110309: 8b 4d d4 mov -0x2c(%ebp),%ecx 11030c: 3b 0d cc 4e 12 00 cmp 0x124ecc,%ecx 110312: 73 ca jae 1102de * 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 ) { 110314: 85 c9 test %ecx,%ecx 110316: 74 27 je 11033f block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 110318: 57 push %edi 110319: 6a 00 push $0x0 11031b: 53 push %ebx 11031c: ff 75 08 pushl 0x8(%ebp) 11031f: 89 55 c8 mov %edx,-0x38(%ebp) 110322: e8 35 f9 ff ff call 10fc5c if ( !block_ptr ) 110327: 83 c4 10 add $0x10,%esp 11032a: 8b 55 c8 mov -0x38(%ebp),%edx 11032d: 89 d1 mov %edx,%ecx 11032f: 85 c0 test %eax,%eax 110331: 74 30 je 110363 <== 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 ); 110333: 8b 00 mov (%eax),%eax 110335: 89 c7 mov %eax,%edi 110337: 8b 4d d4 mov -0x2c(%ebp),%ecx 11033a: f3 a4 rep movsb %ds:(%esi),%es:(%edi) my_length = 0; copied += to_copy; 11033c: 03 55 d4 add -0x2c(%ebp),%edx } IMFS_mtime_ctime_update( the_jnode ); 11033f: 53 push %ebx 110340: 53 push %ebx 110341: 6a 00 push $0x0 110343: 8d 45 e0 lea -0x20(%ebp),%eax 110346: 50 push %eax 110347: 89 55 c8 mov %edx,-0x38(%ebp) 11034a: e8 71 70 ff ff call 1073c0 11034f: 8b 45 e0 mov -0x20(%ebp),%eax 110352: 8b 5d 08 mov 0x8(%ebp),%ebx 110355: 89 43 44 mov %eax,0x44(%ebx) 110358: 89 43 48 mov %eax,0x48(%ebx) return copied; 11035b: 83 c4 10 add $0x10,%esp 11035e: 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 ) 110361: 89 d1 mov %edx,%ecx } IMFS_mtime_ctime_update( the_jnode ); return copied; } 110363: 89 c8 mov %ecx,%eax 110365: 8d 65 f4 lea -0xc(%ebp),%esp 110368: 5b pop %ebx 110369: 5e pop %esi 11036a: 5f pop %edi 11036b: c9 leave 11036c: c3 ret =============================================================================== 00106d90 : #include int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 106d90: 55 push %ebp 106d91: 89 e5 mov %esp,%ebp 106d93: 83 ec 08 sub $0x8,%esp 106d96: 8b 55 08 mov 0x8(%ebp),%edx IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 106d99: 8b 42 08 mov 0x8(%edx),%eax /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 106d9c: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 106da0: 74 10 je 106db2 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTDIR ); 106da2: e8 a5 a3 00 00 call 11114c <__errno> <== NOT EXECUTED 106da7: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 106dad: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 106db0: eb 05 jmp 106db7 <== 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; 106db2: 89 50 5c mov %edx,0x5c(%eax) return 0; 106db5: 31 c0 xor %eax,%eax } 106db7: c9 leave 106db8: c3 ret =============================================================================== 00109528 : * This routine prints the contents of the specified jnode. */ void IMFS_print_jnode( IMFS_jnode_t *the_jnode ) { 109528: 55 push %ebp 109529: 89 e5 mov %esp,%ebp 10952b: 53 push %ebx 10952c: 83 ec 0c sub $0xc,%esp 10952f: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_assert( the_jnode ); fprintf(stdout, "%s", the_jnode->name ); 109532: a1 e0 98 12 00 mov 0x1298e0,%eax 109537: ff 70 08 pushl 0x8(%eax) 10953a: 8d 43 0c lea 0xc(%ebx),%eax 10953d: 50 push %eax 10953e: e8 7d be 00 00 call 1153c0 switch( the_jnode->type ) { 109543: 8b 43 4c mov 0x4c(%ebx),%eax 109546: 83 c4 10 add $0x10,%esp 109549: 8d 50 ff lea -0x1(%eax),%edx 10954c: 83 fa 06 cmp $0x6,%edx 10954f: 77 75 ja 1095c6 <== NEVER TAKEN 109551: a1 e0 98 12 00 mov 0x1298e0,%eax 109556: ff 24 95 18 49 12 00 jmp *0x124918(,%edx,4) case IMFS_DIRECTORY: fprintf(stdout, "/" ); 10955d: 51 push %ecx 10955e: 51 push %ecx 10955f: ff 70 08 pushl 0x8(%eax) 109562: 6a 2f push $0x2f 109564: e8 ab bd 00 00 call 115314 109569: eb 2b jmp 109596 break; case IMFS_DEVICE: fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")", 10956b: ff 73 54 pushl 0x54(%ebx) 10956e: ff 73 50 pushl 0x50(%ebx) 109571: 68 3d 48 12 00 push $0x12483d 109576: eb 16 jmp 10958e the_jnode->info.device.major, the_jnode->info.device.minor ); break; case IMFS_LINEAR_FILE: fprintf(stdout, " (file %" PRId32 " %p)", 109578: ff 73 58 pushl 0x58(%ebx) 10957b: ff 73 50 pushl 0x50(%ebx) 10957e: 68 50 48 12 00 push $0x124850 109583: eb 09 jmp 10958e the_jnode->info.file.indirect, the_jnode->info.file.doubly_indirect, the_jnode->info.file.triply_indirect ); #else fprintf(stdout, " (file %" PRId32 ")", 109585: 52 push %edx 109586: ff 73 50 pushl 0x50(%ebx) 109589: 68 5f 48 12 00 push $0x12485f 10958e: ff 70 08 pushl 0x8(%eax) 109591: e8 1e bd 00 00 call 1152b4 (uint32_t)the_jnode->info.file.size ); #endif break; 109596: 83 c4 10 add $0x10,%esp default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 109599: c7 45 08 49 4b 12 00 movl $0x124b49,0x8(%ebp) } 1095a0: 8b 5d fc mov -0x4(%ebp),%ebx 1095a3: c9 leave default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 1095a4: e9 df d5 00 00 jmp 116b88 case IMFS_HARD_LINK: fprintf(stdout, " links not printed\n" ); return; case IMFS_SYM_LINK: fprintf(stdout, " links not printed\n" ); 1095a9: 53 push %ebx 1095aa: 53 push %ebx 1095ab: ff 70 08 pushl 0x8(%eax) 1095ae: 68 6b 48 12 00 push $0x12486b 1095b3: eb 0a jmp 1095bf return; case IMFS_FIFO: fprintf(stdout, " FIFO not printed\n" ); 1095b5: 51 push %ecx 1095b6: 51 push %ecx 1095b7: ff 70 08 pushl 0x8(%eax) 1095ba: 68 7f 48 12 00 push $0x12487f 1095bf: e8 fc bd 00 00 call 1153c0 1095c4: eb 14 jmp 1095da return; default: fprintf(stdout, " bad type %d\n", the_jnode->type ); 1095c6: 52 push %edx <== NOT EXECUTED 1095c7: 50 push %eax <== NOT EXECUTED 1095c8: 68 92 48 12 00 push $0x124892 <== NOT EXECUTED 1095cd: a1 e0 98 12 00 mov 0x1298e0,%eax <== NOT EXECUTED 1095d2: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1095d5: e8 da bc 00 00 call 1152b4 <== NOT EXECUTED return; 1095da: 83 c4 10 add $0x10,%esp } puts(""); } 1095dd: 8b 5d fc mov -0x4(%ebp),%ebx 1095e0: c9 leave 1095e1: c3 ret =============================================================================== 00106df8 : 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 */ ) { 106df8: 55 push %ebp 106df9: 89 e5 mov %esp,%ebp 106dfb: 53 push %ebx 106dfc: 83 ec 18 sub $0x18,%esp IMFS_jnode_t *the_jnode; IMFS_jnode_t *new_parent; the_jnode = old_loc->node_access; 106dff: 8b 45 0c mov 0xc(%ebp),%eax 106e02: 8b 18 mov (%eax),%ebx strncpy( the_jnode->name, new_name, IMFS_NAME_MAX ); 106e04: 6a 20 push $0x20 106e06: ff 75 14 pushl 0x14(%ebp) 106e09: 8d 43 0c lea 0xc(%ebx),%eax 106e0c: 50 push %eax 106e0d: e8 0a b2 00 00 call 11201c if ( the_jnode->Parent != NULL ) 106e12: 83 c4 10 add $0x10,%esp 106e15: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 106e19: 74 0c je 106e27 <== NEVER TAKEN */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 106e1b: 83 ec 0c sub $0xc,%esp 106e1e: 53 push %ebx 106e1f: e8 e0 3b 00 00 call 10aa04 <_Chain_Extract> 106e24: 83 c4 10 add $0x10,%esp rtems_chain_extract( (rtems_chain_node *) the_jnode ); new_parent = new_parent_loc->node_access; 106e27: 8b 45 10 mov 0x10(%ebp),%eax 106e2a: 8b 00 mov (%eax),%eax the_jnode->Parent = new_parent; 106e2c: 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 ); 106e2f: 51 push %ecx 106e30: 51 push %ecx 106e31: 53 push %ebx rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node ); 106e32: 83 c0 50 add $0x50,%eax 106e35: 50 push %eax 106e36: e8 a5 3b 00 00 call 10a9e0 <_Chain_Append> /* * Update the time. */ IMFS_update_ctime( the_jnode ); 106e3b: 58 pop %eax 106e3c: 5a pop %edx 106e3d: 6a 00 push $0x0 106e3f: 8d 45 f0 lea -0x10(%ebp),%eax 106e42: 50 push %eax 106e43: e8 78 05 00 00 call 1073c0 106e48: 8b 45 f0 mov -0x10(%ebp),%eax 106e4b: 89 43 48 mov %eax,0x48(%ebx) return 0; } 106e4e: 31 c0 xor %eax,%eax 106e50: 8b 5d fc mov -0x4(%ebp),%ebx 106e53: c9 leave 106e54: c3 ret =============================================================================== 0010df08 : int IMFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 10df08: 55 push %ebp 10df09: 89 e5 mov %esp,%ebp 10df0b: 56 push %esi 10df0c: 53 push %ebx 10df0d: 8b 4d 08 mov 0x8(%ebp),%ecx 10df10: 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; 10df13: 8b 11 mov (%ecx),%edx switch ( the_jnode->type ) { 10df15: 8b 5a 4c mov 0x4c(%edx),%ebx 10df18: 83 eb 02 sub $0x2,%ebx 10df1b: 83 fb 05 cmp $0x5,%ebx 10df1e: 77 33 ja 10df53 <== NEVER TAKEN 10df20: ff 24 9d c8 f4 11 00 jmp *0x11f4c8(,%ebx,4) case IMFS_DEVICE: io = &the_jnode->info.device; buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor ); 10df27: 8b 5a 54 mov 0x54(%edx),%ebx rtems_device_minor_number _minor ) { union __rtems_dev_t temp; temp.__overlay.major = _major; 10df2a: 8b 72 50 mov 0x50(%edx),%esi 10df2d: 89 70 18 mov %esi,0x18(%eax) 10df30: 89 58 1c mov %ebx,0x1c(%eax) break; 10df33: eb 2e jmp 10df63 case IMFS_LINEAR_FILE: case IMFS_MEMORY_FILE: buf->st_size = the_jnode->info.file.size; 10df35: 8b 5a 50 mov 0x50(%edx),%ebx 10df38: 8b 72 54 mov 0x54(%edx),%esi 10df3b: 89 58 20 mov %ebx,0x20(%eax) 10df3e: 89 70 24 mov %esi,0x24(%eax) break; 10df41: eb 20 jmp 10df63 case IMFS_SYM_LINK: buf->st_size = 0; break; case IMFS_FIFO: buf->st_size = 0; 10df43: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) 10df4a: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) break; 10df51: eb 10 jmp 10df63 default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 10df53: e8 f4 31 00 00 call 11114c <__errno> 10df58: c7 00 86 00 00 00 movl $0x86,(%eax) 10df5e: 83 c8 ff or $0xffffffff,%eax 10df61: eb 47 jmp 10dfaa /* * The device number of the IMFS is the major number and the minor is the * instance. */ fs_info = loc->mt_entry->fs_info; 10df63: 8b 49 10 mov 0x10(%ecx),%ecx buf->st_dev = rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance ); 10df66: 8b 49 34 mov 0x34(%ecx),%ecx 10df69: 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 = 10df6b: c7 00 fe ff 00 00 movl $0xfffe,(%eax) 10df71: 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; 10df74: 8b 4a 30 mov 0x30(%edx),%ecx 10df77: 89 48 0c mov %ecx,0xc(%eax) buf->st_nlink = the_jnode->st_nlink; 10df7a: 8b 4a 34 mov 0x34(%edx),%ecx 10df7d: 66 89 48 10 mov %cx,0x10(%eax) buf->st_ino = the_jnode->st_ino; 10df81: 8b 4a 38 mov 0x38(%edx),%ecx 10df84: 89 48 08 mov %ecx,0x8(%eax) buf->st_uid = the_jnode->st_uid; 10df87: 8b 4a 3c mov 0x3c(%edx),%ecx 10df8a: 66 89 48 12 mov %cx,0x12(%eax) buf->st_gid = the_jnode->st_gid; 10df8e: 66 8b 4a 3e mov 0x3e(%edx),%cx 10df92: 66 89 48 14 mov %cx,0x14(%eax) buf->st_atime = the_jnode->stat_atime; 10df96: 8b 4a 40 mov 0x40(%edx),%ecx 10df99: 89 48 28 mov %ecx,0x28(%eax) buf->st_mtime = the_jnode->stat_mtime; 10df9c: 8b 4a 44 mov 0x44(%edx),%ecx 10df9f: 89 48 30 mov %ecx,0x30(%eax) buf->st_ctime = the_jnode->stat_ctime; 10dfa2: 8b 52 48 mov 0x48(%edx),%edx 10dfa5: 89 50 38 mov %edx,0x38(%eax) return 0; 10dfa8: 31 c0 xor %eax,%eax } 10dfaa: 5b pop %ebx 10dfab: 5e pop %esi 10dfac: c9 leave 10dfad: c3 ret =============================================================================== 00106ee4 : int IMFS_unlink( rtems_filesystem_location_info_t *parentloc, /* IN */ rtems_filesystem_location_info_t *loc /* IN */ ) { 106ee4: 55 push %ebp 106ee5: 89 e5 mov %esp,%ebp 106ee7: 57 push %edi 106ee8: 56 push %esi 106ee9: 53 push %ebx 106eea: 83 ec 2c sub $0x2c,%esp IMFS_jnode_t *node; rtems_filesystem_location_info_t the_link; int result = 0; node = loc->node_access; 106eed: 8b 45 0c mov 0xc(%ebp),%eax 106ef0: 8b 18 mov (%eax),%ebx /* * If this is the last last pointer to the node * free the node. */ if ( node->type == IMFS_HARD_LINK ) { 106ef2: 83 7b 4c 03 cmpl $0x3,0x4c(%ebx) 106ef6: 75 7a jne 106f72 if ( !node->info.hard_link.link_node ) 106ef8: 8b 43 50 mov 0x50(%ebx),%eax 106efb: 85 c0 test %eax,%eax 106efd: 75 10 jne 106f0f <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 106eff: e8 48 a2 00 00 call 11114c <__errno> <== NOT EXECUTED 106f04: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 106f0a: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 106f0d: eb 75 jmp 106f84 <== NOT EXECUTED the_link = *loc; 106f0f: 8d 7d cc lea -0x34(%ebp),%edi 106f12: b9 05 00 00 00 mov $0x5,%ecx 106f17: 8b 75 0c mov 0xc(%ebp),%esi 106f1a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_link.node_access = node->info.hard_link.link_node; 106f1c: 89 45 cc mov %eax,-0x34(%ebp) IMFS_Set_handlers( &the_link ); 106f1f: 83 ec 0c sub $0xc,%esp 106f22: 8d 75 cc lea -0x34(%ebp),%esi 106f25: 56 push %esi 106f26: e8 6d 67 00 00 call 10d698 /* * 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) 106f2b: 8b 43 50 mov 0x50(%ebx),%eax 106f2e: 8b 50 34 mov 0x34(%eax),%edx 106f31: 83 c4 10 add $0x10,%esp 106f34: 66 83 fa 01 cmp $0x1,%dx 106f38: 75 1a jne 106f54 { result = (*the_link.handlers->rmnod_h)( parentloc, &the_link ); 106f3a: 51 push %ecx 106f3b: 51 push %ecx 106f3c: 56 push %esi 106f3d: ff 75 08 pushl 0x8(%ebp) 106f40: 8b 45 d4 mov -0x2c(%ebp),%eax 106f43: ff 50 34 call *0x34(%eax) 106f46: 89 c2 mov %eax,%edx if ( result != 0 ) 106f48: 83 c4 10 add $0x10,%esp return -1; 106f4b: 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 ) 106f4e: 85 d2 test %edx,%edx 106f50: 74 20 je 106f72 106f52: eb 30 jmp 106f84 return -1; } else { node->info.hard_link.link_node->st_nlink --; 106f54: 4a dec %edx 106f55: 66 89 50 34 mov %dx,0x34(%eax) IMFS_update_ctime( node->info.hard_link.link_node ); 106f59: 52 push %edx 106f5a: 52 push %edx 106f5b: 6a 00 push $0x0 106f5d: 8d 45 e0 lea -0x20(%ebp),%eax 106f60: 50 push %eax 106f61: e8 5a 04 00 00 call 1073c0 106f66: 8b 43 50 mov 0x50(%ebx),%eax 106f69: 8b 55 e0 mov -0x20(%ebp),%edx 106f6c: 89 50 48 mov %edx,0x48(%eax) 106f6f: 83 c4 10 add $0x10,%esp /* * Now actually free the node we were asked to free. */ result = (*loc->handlers->rmnod_h)( parentloc, loc ); 106f72: 50 push %eax 106f73: 50 push %eax 106f74: 8b 55 0c mov 0xc(%ebp),%edx 106f77: 8b 42 08 mov 0x8(%edx),%eax 106f7a: 52 push %edx 106f7b: ff 75 08 pushl 0x8(%ebp) 106f7e: ff 50 34 call *0x34(%eax) return result; 106f81: 83 c4 10 add $0x10,%esp } 106f84: 8d 65 f4 lea -0xc(%ebp),%esp 106f87: 5b pop %ebx 106f88: 5e pop %esi 106f89: 5f pop %edi 106f8a: c9 leave 106f8b: c3 ret =============================================================================== 00106f8c : #include int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 106f8c: 55 push %ebp 106f8d: 89 e5 mov %esp,%ebp 106f8f: 83 ec 08 sub $0x8,%esp IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 106f92: 8b 45 08 mov 0x8(%ebp),%eax 106f95: 8b 40 08 mov 0x8(%eax),%eax /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 106f98: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 106f9c: 74 0d je 106fab <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTDIR ); 106f9e: e8 a9 a1 00 00 call 11114c <__errno> <== NOT EXECUTED 106fa3: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 106fa9: eb 11 jmp 106fbc <== NOT EXECUTED /* * Did the node indicate that there was a directory mounted here? */ if ( node->info.directory.mt_fs == NULL ) 106fab: 83 78 5c 00 cmpl $0x0,0x5c(%eax) 106faf: 75 10 jne 106fc1 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */ 106fb1: e8 96 a1 00 00 call 11114c <__errno> <== NOT EXECUTED 106fb6: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 106fbc: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 106fbf: eb 09 jmp 106fca <== 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; 106fc1: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) return 0; 106fc8: 31 c0 xor %eax,%eax } 106fca: c9 leave 106fcb: c3 ret =============================================================================== 00107108 : static rtems_printk_plugin_t print_handler; void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) { 107108: 55 push %ebp <== NOT EXECUTED 107109: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10710b: 57 push %edi <== NOT EXECUTED 10710c: 56 push %esi <== NOT EXECUTED 10710d: 53 push %ebx <== NOT EXECUTED 10710e: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 107111: 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) { 107114: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED 107117: 75 1d jne 107136 <== NOT EXECUTED if (!Stack_check_Interrupt_stack.area) 107119: 83 3d 1c 72 12 00 00 cmpl $0x0,0x12721c <== NOT EXECUTED 107120: 0f 84 f5 00 00 00 je 10721b <== NOT EXECUTED return; stack = &Stack_check_Interrupt_stack; 107126: ba 18 72 12 00 mov $0x127218,%edx <== NOT EXECUTED the_thread = 0; current = 0; 10712b: 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; 107132: 31 db xor %ebx,%ebx <== NOT EXECUTED 107134: eb 0f jmp 107145 <== NOT EXECUTED current = 0; } else #endif { stack = &the_thread->Start.Initial_stack; 107136: 8d 93 b8 00 00 00 lea 0xb8(%ebx),%edx <== NOT EXECUTED current = (void *)_CPU_Context_Get_SP( &the_thread->Registers ); 10713c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 107142: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED } low = Stack_check_usable_stack_start(stack); 107145: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 107148: 8d 48 10 lea 0x10(%eax),%ecx <== NOT EXECUTED size = Stack_check_usable_stack_size(stack); 10714b: 8b 32 mov (%edx),%esi <== NOT EXECUTED 10714d: 83 ee 10 sub $0x10,%esi <== NOT EXECUTED 107150: 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; 107153: 83 c0 20 add $0x20,%eax <== NOT EXECUTED for (ebase = base + length; base < ebase; base++) 107156: 83 e6 fc and $0xfffffffc,%esi <== NOT EXECUTED 107159: 8d 34 30 lea (%eax,%esi,1),%esi <== NOT EXECUTED 10715c: eb 0b jmp 107169 <== NOT EXECUTED if (*base != U32_PATTERN) 10715e: 81 38 a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%eax) <== NOT EXECUTED 107164: 75 0b jne 107171 <== 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++) 107166: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 107169: 39 f0 cmp %esi,%eax <== NOT EXECUTED 10716b: 72 f1 jb 10715e <== 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; 10716d: 31 ff xor %edi,%edi <== NOT EXECUTED 10716f: eb 0e jmp 10717f <== NOT EXECUTED 107171: 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 ) 107173: 85 c0 test %eax,%eax <== NOT EXECUTED 107175: 74 08 je 10717f <== NOT EXECUTED used = Stack_check_Calculate_used( low, size, high_water_mark ); 107177: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED 10717a: 8d 3c 39 lea (%ecx,%edi,1),%edi <== NOT EXECUTED 10717d: 29 c7 sub %eax,%edi <== NOT EXECUTED else used = 0; #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if ( the_thread ) 10717f: 85 db test %ebx,%ebx <== NOT EXECUTED 107181: 8b 35 f4 6e 12 00 mov 0x126ef4,%esi <== NOT EXECUTED 107187: 74 28 je 1071b1 <== NOT EXECUTED #endif { (*print_handler)( 107189: 50 push %eax <== NOT EXECUTED 10718a: 8d 45 e3 lea -0x1d(%ebp),%eax <== NOT EXECUTED 10718d: 50 push %eax <== NOT EXECUTED 10718e: 6a 05 push $0x5 <== NOT EXECUTED 107190: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 107193: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED 107196: e8 b1 53 00 00 call 10c54c <== NOT EXECUTED 10719b: 50 push %eax <== NOT EXECUTED 10719c: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10719f: 68 33 16 12 00 push $0x121633 <== NOT EXECUTED 1071a4: ff 35 f0 6e 12 00 pushl 0x126ef0 <== NOT EXECUTED 1071aa: ff d6 call *%esi <== NOT EXECUTED 1071ac: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1071af: eb 16 jmp 1071c7 <== 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 ); 1071b1: 53 push %ebx <== NOT EXECUTED 1071b2: 6a ff push $0xffffffff <== NOT EXECUTED 1071b4: 68 40 16 12 00 push $0x121640 <== NOT EXECUTED 1071b9: ff 35 f0 6e 12 00 pushl 0x126ef0 <== NOT EXECUTED 1071bf: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED 1071c2: ff d6 call *%esi <== NOT EXECUTED 1071c4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1071c7: 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, 1071ca: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); } #endif (*print_handler)( 1071cd: 51 push %ecx <== NOT EXECUTED 1071ce: 51 push %ecx <== NOT EXECUTED 1071cf: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 1071d2: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED print_context, " %010p - %010p %010p %8" PRId32 " ", stack->area, stack->area + stack->size - 1, 1071d5: 8b 12 mov (%edx),%edx <== NOT EXECUTED else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); } #endif (*print_handler)( 1071d7: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED 1071db: 52 push %edx <== NOT EXECUTED 1071dc: 50 push %eax <== NOT EXECUTED 1071dd: 68 4e 16 12 00 push $0x12164e <== NOT EXECUTED 1071e2: ff 35 f0 6e 12 00 pushl 0x126ef0 <== NOT EXECUTED 1071e8: ff 15 f4 6e 12 00 call *0x126ef4 <== NOT EXECUTED stack->area + stack->size - 1, current, size ); if (Stack_check_Initialized == 0) { 1071ee: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1071f1: 83 3d f8 6e 12 00 00 cmpl $0x0,0x126ef8 <== NOT EXECUTED 1071f8: 8b 35 f4 6e 12 00 mov 0x126ef4,%esi <== NOT EXECUTED 1071fe: 75 09 jne 107209 <== NOT EXECUTED (*print_handler)( print_context, "Unavailable\n" ); 107200: 52 push %edx <== NOT EXECUTED 107201: 52 push %edx <== NOT EXECUTED 107202: 68 6c 16 12 00 push $0x12166c <== NOT EXECUTED 107207: eb 07 jmp 107210 <== NOT EXECUTED } else { (*print_handler)( print_context, "%8" PRId32 "\n", used ); 107209: 50 push %eax <== NOT EXECUTED 10720a: 57 push %edi <== NOT EXECUTED 10720b: 68 79 16 12 00 push $0x121679 <== NOT EXECUTED 107210: ff 35 f0 6e 12 00 pushl 0x126ef0 <== NOT EXECUTED 107216: ff d6 call *%esi <== NOT EXECUTED 107218: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 10721b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10721e: 5b pop %ebx <== NOT EXECUTED 10721f: 5e pop %esi <== NOT EXECUTED 107220: 5f pop %edi <== NOT EXECUTED 107221: c9 leave <== NOT EXECUTED 107222: c3 ret <== NOT EXECUTED =============================================================================== 00107223 : /* * Stack_check_Initialize */ void Stack_check_Initialize( void ) { 107223: 55 push %ebp 107224: 89 e5 mov %esp,%ebp 107226: 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 ) 107227: 83 3d f8 6e 12 00 00 cmpl $0x0,0x126ef8 10722e: 75 5a jne 10728a /* * Dope the pattern and fill areas */ p = Stack_check_Pattern.pattern; for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) { p[i] = pattern[ i%4 ]; 107230: c7 05 08 72 12 00 0d movl $0xfeedf00d,0x127208 107237: f0 ed fe 10723a: c7 05 0c 72 12 00 06 movl $0xbad0d06,0x12720c 107241: 0d ad 0b 107244: c7 05 10 72 12 00 0d movl $0xdeadf00d,0x127210 10724b: f0 ad de 10724e: c7 05 14 72 12 00 06 movl $0x600d0d06,0x127214 107255: 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) { 107258: 8b 15 10 79 12 00 mov 0x127910,%edx 10725e: 85 d2 test %edx,%edx 107260: 74 1e je 107280 <== NEVER TAKEN 107262: 8b 0d 14 79 12 00 mov 0x127914,%ecx 107268: 85 c9 test %ecx,%ecx 10726a: 74 14 je 107280 <== NEVER TAKEN Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low; 10726c: 89 15 1c 72 12 00 mov %edx,0x12721c Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high - 107272: 29 d1 sub %edx,%ecx 107274: 89 0d 18 72 12 00 mov %ecx,0x127218 (char *) _CPU_Interrupt_stack_low; Stack_check_Dope_stack(&Stack_check_Interrupt_stack); 10727a: b0 a5 mov $0xa5,%al 10727c: 89 d7 mov %edx,%edi 10727e: f3 aa rep stos %al,%es:(%edi) } #endif Stack_check_Initialized = 1; 107280: c7 05 f8 6e 12 00 01 movl $0x1,0x126ef8 107287: 00 00 00 } 10728a: 5f pop %edi 10728b: c9 leave 10728c: c3 ret =============================================================================== 001072db : Thread_Control *running, bool pattern_ok ) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE; void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok) { 1072db: 55 push %ebp <== NOT EXECUTED 1072dc: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1072de: 56 push %esi <== NOT EXECUTED 1072df: 53 push %ebx <== NOT EXECUTED 1072e0: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 1072e3: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1072e6: 8a 55 0c mov 0xc(%ebp),%dl <== NOT EXECUTED Stack_Control *stack = &running->Start.Initial_stack; void *pattern_area = Stack_check_Get_pattern(stack); 1072e9: 8b b3 bc 00 00 00 mov 0xbc(%ebx),%esi <== NOT EXECUTED char name[32]; printk("BLOWN STACK!!!\n"); 1072ef: 68 7f 16 12 00 push $0x12167f <== NOT EXECUTED 1072f4: 88 55 d4 mov %dl,-0x2c(%ebp) <== NOT EXECUTED 1072f7: e8 08 19 00 00 call 108c04 <== NOT EXECUTED printk("task control block: 0x%08" PRIxPTR "\n", running); 1072fc: 5a pop %edx <== NOT EXECUTED 1072fd: 59 pop %ecx <== NOT EXECUTED 1072fe: 53 push %ebx <== NOT EXECUTED 1072ff: 68 8f 16 12 00 push $0x12168f <== NOT EXECUTED 107304: e8 fb 18 00 00 call 108c04 <== NOT EXECUTED printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id); 107309: 59 pop %ecx <== NOT EXECUTED 10730a: 58 pop %eax <== NOT EXECUTED 10730b: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10730e: 68 ac 16 12 00 push $0x1216ac <== NOT EXECUTED 107313: e8 ec 18 00 00 call 108c04 <== NOT EXECUTED printk( 107318: 58 pop %eax <== NOT EXECUTED 107319: 5a pop %edx <== NOT EXECUTED 10731a: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10731d: 68 be 16 12 00 push $0x1216be <== NOT EXECUTED 107322: e8 dd 18 00 00 call 108c04 <== NOT EXECUTED "task name: 0x%08" PRIx32 "\n", running->Object.name.name_u32 ); printk( 107327: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10732a: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED 10732d: 50 push %eax <== NOT EXECUTED 10732e: 6a 20 push $0x20 <== NOT EXECUTED 107330: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 107333: e8 14 52 00 00 call 10c54c <== NOT EXECUTED 107338: 5a pop %edx <== NOT EXECUTED 107339: 59 pop %ecx <== NOT EXECUTED 10733a: 50 push %eax <== NOT EXECUTED 10733b: 68 d2 16 12 00 push $0x1216d2 <== NOT EXECUTED 107340: e8 bf 18 00 00 call 108c04 <== 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) 107345: 8b 8b bc 00 00 00 mov 0xbc(%ebx),%ecx <== NOT EXECUTED 10734b: 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( 107351: 8d 1c 01 lea (%ecx,%eax,1),%ebx <== NOT EXECUTED 107354: 53 push %ebx <== NOT EXECUTED 107355: 51 push %ecx <== NOT EXECUTED 107356: 50 push %eax <== NOT EXECUTED 107357: 68 e8 16 12 00 push $0x1216e8 <== NOT EXECUTED 10735c: e8 a3 18 00 00 call 108c04 <== 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) { 107361: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 107364: 8a 55 d4 mov -0x2c(%ebp),%dl <== NOT EXECUTED 107367: 84 d2 test %dl,%dl <== NOT EXECUTED 107369: 75 17 jne 107382 <== 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); 10736b: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED (unsigned long) stack->size, stack->area, ((char *) stack->area + stack->size) ); if (!pattern_ok) { printk( 10736e: 83 c6 18 add $0x18,%esi <== NOT EXECUTED 107371: 56 push %esi <== NOT EXECUTED 107372: 50 push %eax <== NOT EXECUTED 107373: 6a 10 push $0x10 <== NOT EXECUTED 107375: 68 19 17 12 00 push $0x121719 <== NOT EXECUTED 10737a: e8 85 18 00 00 call 108c04 <== NOT EXECUTED 10737f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_configuration_get_user_multiprocessing_table()->node ); } #endif rtems_fatal_error_occurred(0x81); 107382: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107385: 68 81 00 00 00 push $0x81 <== NOT EXECUTED 10738a: e8 0d 59 00 00 call 10cc9c <== NOT EXECUTED =============================================================================== 0010ce0c <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 10ce0c: 55 push %ebp 10ce0d: 89 e5 mov %esp,%ebp 10ce0f: 53 push %ebx 10ce10: 83 ec 04 sub $0x4,%esp 10ce13: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; Thread_Control *executing = _Thread_Executing; 10ce16: 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 ); 10ce1c: 9c pushf 10ce1d: fa cli 10ce1e: 58 pop %eax if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 10ce1f: 8b 4b 44 mov 0x44(%ebx),%ecx 10ce22: 85 c9 test %ecx,%ecx 10ce24: 75 0b jne 10ce31 <_CORE_RWLock_Release+0x25> _ISR_Enable( level ); 10ce26: 50 push %eax 10ce27: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10ce28: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) return CORE_RWLOCK_SUCCESSFUL; 10ce2f: eb 72 jmp 10cea3 <_CORE_RWLock_Release+0x97> } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { 10ce31: 49 dec %ecx 10ce32: 75 0f jne 10ce43 <_CORE_RWLock_Release+0x37> the_rwlock->number_of_readers -= 1; 10ce34: 8b 4b 48 mov 0x48(%ebx),%ecx 10ce37: 49 dec %ecx 10ce38: 89 4b 48 mov %ecx,0x48(%ebx) if ( the_rwlock->number_of_readers != 0 ) { 10ce3b: 85 c9 test %ecx,%ecx 10ce3d: 74 04 je 10ce43 <_CORE_RWLock_Release+0x37> /* must be unlocked again */ _ISR_Enable( level ); 10ce3f: 50 push %eax 10ce40: 9d popf return CORE_RWLOCK_SUCCESSFUL; 10ce41: eb 60 jmp 10cea3 <_CORE_RWLock_Release+0x97> } } /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */ executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10ce43: 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; 10ce4a: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) _ISR_Enable( level ); 10ce51: 50 push %eax 10ce52: 9d popf next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 10ce53: 83 ec 0c sub $0xc,%esp 10ce56: 53 push %ebx 10ce57: e8 58 17 00 00 call 10e5b4 <_Thread_queue_Dequeue> if ( next ) { 10ce5c: 83 c4 10 add $0x10,%esp 10ce5f: 85 c0 test %eax,%eax 10ce61: 74 40 je 10cea3 <_CORE_RWLock_Release+0x97> if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 10ce63: 83 78 30 01 cmpl $0x1,0x30(%eax) 10ce67: 75 09 jne 10ce72 <_CORE_RWLock_Release+0x66> the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10ce69: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx) return CORE_RWLOCK_SUCCESSFUL; 10ce70: eb 31 jmp 10cea3 <_CORE_RWLock_Release+0x97> } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 10ce72: ff 43 48 incl 0x48(%ebx) the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10ce75: 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 ); 10ce7c: 83 ec 0c sub $0xc,%esp 10ce7f: 53 push %ebx 10ce80: e8 27 1b 00 00 call 10e9ac <_Thread_queue_First> if ( !next || 10ce85: 83 c4 10 add $0x10,%esp 10ce88: 85 c0 test %eax,%eax 10ce8a: 74 17 je 10cea3 <_CORE_RWLock_Release+0x97> 10ce8c: 83 78 30 01 cmpl $0x1,0x30(%eax) 10ce90: 74 11 je 10cea3 <_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; 10ce92: ff 43 48 incl 0x48(%ebx) _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 10ce95: 52 push %edx 10ce96: 52 push %edx 10ce97: 50 push %eax 10ce98: 53 push %ebx 10ce99: e8 fe 19 00 00 call 10e89c <_Thread_queue_Extract> } 10ce9e: 83 c4 10 add $0x10,%esp 10cea1: eb d9 jmp 10ce7c <_CORE_RWLock_Release+0x70> } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10cea3: 31 c0 xor %eax,%eax 10cea5: 8b 5d fc mov -0x4(%ebp),%ebx 10cea8: c9 leave 10cea9: c3 ret =============================================================================== 0010ceac <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 10ceac: 55 push %ebp 10cead: 89 e5 mov %esp,%ebp 10ceaf: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10ceb2: 8d 45 f4 lea -0xc(%ebp),%eax 10ceb5: 50 push %eax 10ceb6: ff 75 08 pushl 0x8(%ebp) 10ceb9: e8 a2 13 00 00 call 10e260 <_Thread_Get> switch ( location ) { 10cebe: 83 c4 10 add $0x10,%esp 10cec1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10cec5: 75 17 jne 10cede <_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 ); 10cec7: 83 ec 0c sub $0xc,%esp 10ceca: 50 push %eax 10cecb: e8 a8 1b 00 00 call 10ea78 <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10ced0: a1 30 83 12 00 mov 0x128330,%eax 10ced5: 48 dec %eax 10ced6: a3 30 83 12 00 mov %eax,0x128330 10cedb: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10cede: c9 leave 10cedf: c3 ret =============================================================================== 0011736c <_CORE_message_queue_Broadcast>: Objects_Id id __attribute__((unused)), CORE_message_queue_API_mp_support_callout api_message_queue_mp_support __attribute__((unused)), #endif uint32_t *count ) { 11736c: 55 push %ebp 11736d: 89 e5 mov %esp,%ebp 11736f: 57 push %edi 117370: 56 push %esi 117371: 53 push %ebx 117372: 83 ec 1c sub $0x1c,%esp 117375: 8b 5d 08 mov 0x8(%ebp),%ebx Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE; 117378: b8 01 00 00 00 mov $0x1,%eax { Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 11737d: 8b 55 10 mov 0x10(%ebp),%edx 117380: 3b 53 4c cmp 0x4c(%ebx),%edx 117383: 77 4e ja 1173d3 <_CORE_message_queue_Broadcast+0x67><== NEVER TAKEN * NOTE: This check is critical because threads can block on * send and receive and this ensures that we are broadcasting * the message to threads waiting to receive -- not to send. */ if ( the_message_queue->number_of_pending_messages != 0 ) { 117385: 83 7b 48 00 cmpl $0x0,0x48(%ebx) 117389: 75 09 jne 117394 <_CORE_message_queue_Broadcast+0x28> 11738b: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 117392: eb 23 jmp 1173b7 <_CORE_message_queue_Broadcast+0x4b> *count = 0; 117394: 8b 45 1c mov 0x1c(%ebp),%eax 117397: c7 00 00 00 00 00 movl $0x0,(%eax) 11739d: eb 32 jmp 1173d1 <_CORE_message_queue_Broadcast+0x65> */ number_broadcasted = 0; while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) { waitp = &the_thread->Wait; number_broadcasted += 1; 11739f: ff 45 e4 incl -0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 1173a2: 8b 42 2c mov 0x2c(%edx),%eax 1173a5: 89 c7 mov %eax,%edi 1173a7: 8b 75 0c mov 0xc(%ebp),%esi 1173aa: 8b 4d 10 mov 0x10(%ebp),%ecx 1173ad: f3 a4 rep movsb %ds:(%esi),%es:(%edi) buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 1173af: 8b 42 28 mov 0x28(%edx),%eax 1173b2: 8b 55 10 mov 0x10(%ebp),%edx 1173b5: 89 10 mov %edx,(%eax) /* * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread = 1173b7: 83 ec 0c sub $0xc,%esp 1173ba: 53 push %ebx 1173bb: e8 84 24 00 00 call 119844 <_Thread_queue_Dequeue> 1173c0: 89 c2 mov %eax,%edx 1173c2: 83 c4 10 add $0x10,%esp 1173c5: 85 c0 test %eax,%eax 1173c7: 75 d6 jne 11739f <_CORE_message_queue_Broadcast+0x33> if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif } *count = number_broadcasted; 1173c9: 8b 55 e4 mov -0x1c(%ebp),%edx 1173cc: 8b 45 1c mov 0x1c(%ebp),%eax 1173cf: 89 10 mov %edx,(%eax) return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 1173d1: 31 c0 xor %eax,%eax } 1173d3: 8d 65 f4 lea -0xc(%ebp),%esp 1173d6: 5b pop %ebx 1173d7: 5e pop %esi 1173d8: 5f pop %edi 1173d9: c9 leave 1173da: c3 ret =============================================================================== 00112220 <_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 ) { 112220: 55 push %ebp 112221: 89 e5 mov %esp,%ebp 112223: 57 push %edi 112224: 56 push %esi 112225: 53 push %ebx 112226: 83 ec 1c sub $0x1c,%esp 112229: 8b 5d 08 mov 0x8(%ebp),%ebx 11222c: 8b 7d 10 mov 0x10(%ebp),%edi 11222f: 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; 112232: 89 7b 44 mov %edi,0x44(%ebx) the_message_queue->number_of_pending_messages = 0; 112235: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) the_message_queue->maximum_message_size = maximum_message_size; 11223c: 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; 11223f: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) the_message_queue->notify_argument = the_argument; 112246: 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)) { 11224d: 89 d0 mov %edx,%eax 11224f: f6 c2 03 test $0x3,%dl 112252: 74 0c je 112260 <_CORE_message_queue_Initialize+0x40> allocated_message_size += sizeof(uint32_t); 112254: 83 c0 04 add $0x4,%eax allocated_message_size &= ~(sizeof(uint32_t) - 1); 112257: 83 e0 fc and $0xfffffffc,%eax } if (allocated_message_size < maximum_message_size) return false; 11225a: 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) 11225c: 39 d0 cmp %edx,%eax 11225e: 72 68 jb 1122c8 <_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)); 112260: 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 * 112263: 89 d1 mov %edx,%ecx 112265: 0f af cf imul %edi,%ecx (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) return false; 112268: 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) 11226a: 39 c1 cmp %eax,%ecx 11226c: 72 5a jb 1122c8 <_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 ); 11226e: 83 ec 0c sub $0xc,%esp 112271: 51 push %ecx 112272: 89 55 e4 mov %edx,-0x1c(%ebp) 112275: e8 74 27 00 00 call 1149ee <_Workspace_Allocate> return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 11227a: 89 43 5c mov %eax,0x5c(%ebx) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 11227d: 83 c4 10 add $0x10,%esp 112280: 85 c0 test %eax,%eax 112282: 8b 55 e4 mov -0x1c(%ebp),%edx 112285: 74 41 je 1122c8 <_CORE_message_queue_Initialize+0xa8> /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 112287: 52 push %edx 112288: 57 push %edi 112289: 50 push %eax 11228a: 8d 43 68 lea 0x68(%ebx),%eax 11228d: 50 push %eax 11228e: e8 b9 4a 00 00 call 116d4c <_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 ); 112293: 8d 43 54 lea 0x54(%ebx),%eax 112296: 89 43 50 mov %eax,0x50(%ebx) head->next = tail; head->previous = NULL; 112299: 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 ); 1122a0: 8d 43 50 lea 0x50(%ebx),%eax 1122a3: 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( 1122a6: 6a 06 push $0x6 1122a8: 68 80 00 00 00 push $0x80 1122ad: 8b 45 0c mov 0xc(%ebp),%eax 1122b0: 83 38 01 cmpl $0x1,(%eax) 1122b3: 0f 94 c0 sete %al 1122b6: 0f b6 c0 movzbl %al,%eax 1122b9: 50 push %eax 1122ba: 53 push %ebx 1122bb: e8 fc 1e 00 00 call 1141bc <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 1122c0: 83 c4 20 add $0x20,%esp 1122c3: be 01 00 00 00 mov $0x1,%esi } 1122c8: 89 f0 mov %esi,%eax 1122ca: 8d 65 f4 lea -0xc(%ebp),%esp 1122cd: 5b pop %ebx 1122ce: 5e pop %esi 1122cf: 5f pop %edi 1122d0: c9 leave 1122d1: c3 ret =============================================================================== 001122d4 <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 1122d4: 55 push %ebp 1122d5: 89 e5 mov %esp,%ebp 1122d7: 57 push %edi 1122d8: 56 push %esi 1122d9: 53 push %ebx 1122da: 83 ec 2c sub $0x2c,%esp 1122dd: 8b 55 08 mov 0x8(%ebp),%edx 1122e0: 8b 45 0c mov 0xc(%ebp),%eax 1122e3: 89 45 dc mov %eax,-0x24(%ebp) 1122e6: 8b 5d 10 mov 0x10(%ebp),%ebx 1122e9: 89 5d e0 mov %ebx,-0x20(%ebp) 1122ec: 8b 4d 14 mov 0x14(%ebp),%ecx 1122ef: 8b 75 1c mov 0x1c(%ebp),%esi 1122f2: 89 75 d4 mov %esi,-0x2c(%ebp) 1122f5: 8a 45 18 mov 0x18(%ebp),%al 1122f8: 88 45 db mov %al,-0x25(%ebp) ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *executing; executing = _Thread_Executing; 1122fb: a1 d0 d9 12 00 mov 0x12d9d0,%eax executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 112300: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) _ISR_Disable( level ); 112307: 9c pushf 112308: fa cli 112309: 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 ); } 11230c: 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 ); 11230f: 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)) 112312: 39 f3 cmp %esi,%ebx 112314: 0f 84 8a 00 00 00 je 1123a4 <_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; 11231a: 8b 33 mov (%ebx),%esi head->next = new_first; 11231c: 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 ); 11231f: 8d 7a 50 lea 0x50(%edx),%edi 112322: 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 ) { 112325: 85 db test %ebx,%ebx 112327: 74 7b je 1123a4 <_CORE_message_queue_Seize+0xd0><== NEVER TAKEN the_message_queue->number_of_pending_messages -= 1; 112329: ff 4a 48 decl 0x48(%edx) _ISR_Enable( level ); 11232c: ff 75 e4 pushl -0x1c(%ebp) 11232f: 9d popf *size_p = the_message->Contents.size; 112330: 8b 43 0c mov 0xc(%ebx),%eax 112333: 89 01 mov %eax,(%ecx) _Thread_Executing->Wait.count = 112335: 8b 73 08 mov 0x8(%ebx),%esi 112338: a1 d0 d9 12 00 mov 0x12d9d0,%eax 11233d: 89 70 24 mov %esi,0x24(%eax) _CORE_message_queue_Get_message_priority( the_message ); _CORE_message_queue_Copy_buffer( the_message->Contents.buffer, 112340: 8d 73 10 lea 0x10(%ebx),%esi 112343: 89 75 e4 mov %esi,-0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 112346: 8b 09 mov (%ecx),%ecx 112348: 8b 7d e0 mov -0x20(%ebp),%edi 11234b: 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 ); 11234d: 83 ec 0c sub $0xc,%esp 112350: 52 push %edx 112351: 89 55 d0 mov %edx,-0x30(%ebp) 112354: e8 2b 1b 00 00 call 113e84 <_Thread_queue_Dequeue> if ( !the_thread ) { 112359: 83 c4 10 add $0x10,%esp 11235c: 85 c0 test %eax,%eax 11235e: 8b 55 d0 mov -0x30(%ebp),%edx 112361: 75 15 jne 112378 <_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 ); 112363: 89 5d 0c mov %ebx,0xc(%ebp) 112366: 83 c2 68 add $0x68,%edx 112369: 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 ); } 11236c: 8d 65 f4 lea -0xc(%ebp),%esp 11236f: 5b pop %ebx 112370: 5e pop %esi 112371: 5f pop %edi 112372: c9 leave 112373: e9 28 fe ff ff jmp 1121a0 <_Chain_Append> CORE_message_queue_Buffer_control *the_message, int priority ) { #if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY) the_message->priority = priority; 112378: 8b 48 24 mov 0x24(%eax),%ecx 11237b: 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; 11237e: 8b 48 30 mov 0x30(%eax),%ecx 112381: 89 4b 0c mov %ecx,0xc(%ebx) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 112384: 8b 70 2c mov 0x2c(%eax),%esi 112387: 8b 7d e4 mov -0x1c(%ebp),%edi 11238a: 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( 11238c: 8b 43 08 mov 0x8(%ebx),%eax 11238f: 89 45 10 mov %eax,0x10(%ebp) 112392: 89 5d 0c mov %ebx,0xc(%ebp) 112395: 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 ); } 112398: 8d 65 f4 lea -0xc(%ebp),%esp 11239b: 5b pop %ebx 11239c: 5e pop %esi 11239d: 5f pop %edi 11239e: c9 leave the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 11239f: e9 e0 49 00 00 jmp 116d84 <_CORE_message_queue_Insert_message> return; } #endif } if ( !wait ) { 1123a4: 80 7d db 00 cmpb $0x0,-0x25(%ebp) 1123a8: 75 13 jne 1123bd <_CORE_message_queue_Seize+0xe9> _ISR_Enable( level ); 1123aa: ff 75 e4 pushl -0x1c(%ebp) 1123ad: 9d popf executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 1123ae: 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 ); } 1123b5: 8d 65 f4 lea -0xc(%ebp),%esp 1123b8: 5b pop %ebx 1123b9: 5e pop %esi 1123ba: 5f pop %edi 1123bb: c9 leave 1123bc: 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; 1123bd: 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; 1123c4: 89 50 44 mov %edx,0x44(%eax) executing->Wait.id = id; 1123c7: 8b 5d dc mov -0x24(%ebp),%ebx 1123ca: 89 58 20 mov %ebx,0x20(%eax) executing->Wait.return_argument_second.mutable_object = buffer; 1123cd: 8b 75 e0 mov -0x20(%ebp),%esi 1123d0: 89 70 2c mov %esi,0x2c(%eax) executing->Wait.return_argument = size_p; 1123d3: 89 48 28 mov %ecx,0x28(%eax) /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 1123d6: ff 75 e4 pushl -0x1c(%ebp) 1123d9: 9d popf _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 1123da: c7 45 10 6c 42 11 00 movl $0x11426c,0x10(%ebp) 1123e1: 8b 45 d4 mov -0x2c(%ebp),%eax 1123e4: 89 45 0c mov %eax,0xc(%ebp) 1123e7: 89 55 08 mov %edx,0x8(%ebp) } 1123ea: 8d 65 f4 lea -0xc(%ebp),%esp 1123ed: 5b pop %ebx 1123ee: 5e pop %esi 1123ef: 5f pop %edi 1123f0: 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 ); 1123f1: e9 9a 1b 00 00 jmp 113f90 <_Thread_queue_Enqueue_with_handler> =============================================================================== 0010ac2d <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 10ac2d: 55 push %ebp 10ac2e: 89 e5 mov %esp,%ebp 10ac30: 53 push %ebx 10ac31: 83 ec 14 sub $0x14,%esp 10ac34: 8b 5d 08 mov 0x8(%ebp),%ebx 10ac37: 8a 55 10 mov 0x10(%ebp),%dl _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10ac3a: a1 20 53 12 00 mov 0x125320,%eax 10ac3f: 85 c0 test %eax,%eax 10ac41: 74 19 je 10ac5c <_CORE_mutex_Seize+0x2f> 10ac43: 84 d2 test %dl,%dl 10ac45: 74 15 je 10ac5c <_CORE_mutex_Seize+0x2f><== NEVER TAKEN 10ac47: 83 3d 9c 54 12 00 01 cmpl $0x1,0x12549c 10ac4e: 76 0c jbe 10ac5c <_CORE_mutex_Seize+0x2f> 10ac50: 53 push %ebx 10ac51: 6a 12 push $0x12 10ac53: 6a 00 push $0x0 10ac55: 6a 00 push $0x0 10ac57: e8 dc 05 00 00 call 10b238 <_Internal_error_Occurred> 10ac5c: 51 push %ecx 10ac5d: 51 push %ecx 10ac5e: 8d 45 18 lea 0x18(%ebp),%eax 10ac61: 50 push %eax 10ac62: 53 push %ebx 10ac63: 88 55 f4 mov %dl,-0xc(%ebp) 10ac66: e8 89 47 00 00 call 10f3f4 <_CORE_mutex_Seize_interrupt_trylock> 10ac6b: 83 c4 10 add $0x10,%esp 10ac6e: 85 c0 test %eax,%eax 10ac70: 8a 55 f4 mov -0xc(%ebp),%dl 10ac73: 74 48 je 10acbd <_CORE_mutex_Seize+0x90> 10ac75: 84 d2 test %dl,%dl 10ac77: 75 12 jne 10ac8b <_CORE_mutex_Seize+0x5e> 10ac79: ff 75 18 pushl 0x18(%ebp) 10ac7c: 9d popf 10ac7d: a1 68 58 12 00 mov 0x125868,%eax 10ac82: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) 10ac89: eb 32 jmp 10acbd <_CORE_mutex_Seize+0x90> 10ac8b: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) 10ac92: a1 68 58 12 00 mov 0x125868,%eax 10ac97: 89 58 44 mov %ebx,0x44(%eax) 10ac9a: 8b 55 0c mov 0xc(%ebp),%edx 10ac9d: 89 50 20 mov %edx,0x20(%eax) 10aca0: a1 20 53 12 00 mov 0x125320,%eax 10aca5: 40 inc %eax 10aca6: a3 20 53 12 00 mov %eax,0x125320 10acab: ff 75 18 pushl 0x18(%ebp) 10acae: 9d popf 10acaf: 50 push %eax 10acb0: 50 push %eax 10acb1: ff 75 14 pushl 0x14(%ebp) 10acb4: 53 push %ebx 10acb5: e8 26 ff ff ff call 10abe0 <_CORE_mutex_Seize_interrupt_blocking> 10acba: 83 c4 10 add $0x10,%esp } 10acbd: 8b 5d fc mov -0x4(%ebp),%ebx 10acc0: c9 leave 10acc1: c3 ret =============================================================================== 0010ade8 <_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 ) { 10ade8: 55 push %ebp 10ade9: 89 e5 mov %esp,%ebp 10adeb: 53 push %ebx 10adec: 83 ec 10 sub $0x10,%esp 10adef: 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)) ) { 10adf2: 53 push %ebx 10adf3: e8 54 16 00 00 call 10c44c <_Thread_queue_Dequeue> 10adf8: 89 c2 mov %eax,%edx 10adfa: 83 c4 10 add $0x10,%esp { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10adfd: 31 c0 xor %eax,%eax if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 10adff: 85 d2 test %edx,%edx 10ae01: 75 15 jne 10ae18 <_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 ); 10ae03: 9c pushf 10ae04: fa cli 10ae05: 59 pop %ecx if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10ae06: 8b 53 48 mov 0x48(%ebx),%edx the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; 10ae09: 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 ) 10ae0b: 3b 53 40 cmp 0x40(%ebx),%edx 10ae0e: 73 06 jae 10ae16 <_CORE_semaphore_Surrender+0x2e><== NEVER TAKEN the_semaphore->count += 1; 10ae10: 42 inc %edx 10ae11: 89 53 48 mov %edx,0x48(%ebx) { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10ae14: 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 ); 10ae16: 51 push %ecx 10ae17: 9d popf } return status; } 10ae18: 8b 5d fc mov -0x4(%ebp),%ebx 10ae1b: c9 leave 10ae1c: c3 ret =============================================================================== 00109d4c <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 109d4c: 55 push %ebp 109d4d: 89 e5 mov %esp,%ebp 109d4f: 57 push %edi 109d50: 56 push %esi 109d51: 53 push %ebx 109d52: 83 ec 2c sub $0x2c,%esp 109d55: 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 ]; 109d58: 8b bb e8 00 00 00 mov 0xe8(%ebx),%edi option_set = (rtems_option) the_thread->Wait.option; 109d5e: 8b 43 30 mov 0x30(%ebx),%eax 109d61: 89 45 e0 mov %eax,-0x20(%ebp) _ISR_Disable( level ); 109d64: 9c pushf 109d65: fa cli 109d66: 58 pop %eax pending_events = api->pending_events; 109d67: 8b 17 mov (%edi),%edx 109d69: 89 55 d4 mov %edx,-0x2c(%ebp) event_condition = (rtems_event_set) the_thread->Wait.count; 109d6c: 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 ) ) { 109d6f: 21 f2 and %esi,%edx 109d71: 75 07 jne 109d7a <_Event_Surrender+0x2e> _ISR_Enable( level ); 109d73: 50 push %eax 109d74: 9d popf return; 109d75: e9 af 00 00 00 jmp 109e29 <_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() && 109d7a: 83 3d 64 58 12 00 00 cmpl $0x0,0x125864 109d81: 74 49 je 109dcc <_Event_Surrender+0x80> 109d83: 3b 1d 68 58 12 00 cmp 0x125868,%ebx 109d89: 75 41 jne 109dcc <_Event_Surrender+0x80> _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 109d8b: 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 ) && 109d91: 83 f9 02 cmp $0x2,%ecx 109d94: 74 09 je 109d9f <_Event_Surrender+0x53> <== NEVER TAKEN ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { 109d96: 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) || 109d9c: 49 dec %ecx 109d9d: 75 2d jne 109dcc <_Event_Surrender+0x80> (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 109d9f: 39 f2 cmp %esi,%edx 109da1: 74 06 je 109da9 <_Event_Surrender+0x5d> 109da3: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109da7: 74 1f je 109dc8 <_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) ); 109da9: 89 d6 mov %edx,%esi 109dab: f7 d6 not %esi 109dad: 23 75 d4 and -0x2c(%ebp),%esi 109db0: 89 37 mov %esi,(%edi) api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 109db2: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109db9: 8b 4b 28 mov 0x28(%ebx),%ecx 109dbc: 89 11 mov %edx,(%ecx) _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 109dbe: c7 05 3c 5c 12 00 03 movl $0x3,0x125c3c 109dc5: 00 00 00 } _ISR_Enable( level ); 109dc8: 50 push %eax 109dc9: 9d popf return; 109dca: eb 5d jmp 109e29 <_Event_Surrender+0xdd> } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 109dcc: f6 43 11 01 testb $0x1,0x11(%ebx) 109dd0: 74 55 je 109e27 <_Event_Surrender+0xdb> if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 109dd2: 39 f2 cmp %esi,%edx 109dd4: 74 06 je 109ddc <_Event_Surrender+0x90> 109dd6: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109dda: 74 4b je 109e27 <_Event_Surrender+0xdb> <== NEVER TAKEN 109ddc: 89 d6 mov %edx,%esi 109dde: f7 d6 not %esi 109de0: 23 75 d4 and -0x2c(%ebp),%esi 109de3: 89 37 mov %esi,(%edi) api->pending_events = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 109de5: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109dec: 8b 4b 28 mov 0x28(%ebx),%ecx 109def: 89 11 mov %edx,(%ecx) _ISR_Flash( level ); 109df1: 50 push %eax 109df2: 9d popf 109df3: fa cli if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 109df4: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 109df8: 74 06 je 109e00 <_Event_Surrender+0xb4> _ISR_Enable( level ); 109dfa: 50 push %eax 109dfb: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 109dfc: 51 push %ecx 109dfd: 51 push %ecx 109dfe: eb 17 jmp 109e17 <_Event_Surrender+0xcb> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 109e00: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 109e07: 50 push %eax 109e08: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 109e09: 83 ec 0c sub $0xc,%esp 109e0c: 8d 43 48 lea 0x48(%ebx),%eax 109e0f: 50 push %eax 109e10: e8 87 30 00 00 call 10ce9c <_Watchdog_Remove> 109e15: 58 pop %eax 109e16: 5a pop %edx 109e17: 68 f8 ff 03 10 push $0x1003fff8 109e1c: 53 push %ebx 109e1d: e8 82 1f 00 00 call 10bda4 <_Thread_Clear_state> 109e22: 83 c4 10 add $0x10,%esp 109e25: eb 02 jmp 109e29 <_Event_Surrender+0xdd> _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 109e27: 50 push %eax 109e28: 9d popf } 109e29: 8d 65 f4 lea -0xc(%ebp),%esp 109e2c: 5b pop %ebx 109e2d: 5e pop %esi 109e2e: 5f pop %edi 109e2f: c9 leave 109e30: c3 ret =============================================================================== 00109e34 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 109e34: 55 push %ebp 109e35: 89 e5 mov %esp,%ebp 109e37: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 109e3a: 8d 45 f4 lea -0xc(%ebp),%eax 109e3d: 50 push %eax 109e3e: ff 75 08 pushl 0x8(%ebp) 109e41: e8 b2 22 00 00 call 10c0f8 <_Thread_Get> switch ( location ) { 109e46: 83 c4 10 add $0x10,%esp 109e49: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 109e4d: 75 49 jne 109e98 <_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 ); 109e4f: 9c pushf 109e50: fa cli 109e51: 5a pop %edx _ISR_Enable( level ); return; } #endif the_thread->Wait.count = 0; 109e52: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) if ( _Thread_Is_executing( the_thread ) ) { 109e59: 3b 05 68 58 12 00 cmp 0x125868,%eax 109e5f: 75 13 jne 109e74 <_Event_Timeout+0x40> if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 109e61: 8b 0d 3c 5c 12 00 mov 0x125c3c,%ecx 109e67: 49 dec %ecx 109e68: 75 0a jne 109e74 <_Event_Timeout+0x40> _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 109e6a: c7 05 3c 5c 12 00 02 movl $0x2,0x125c3c 109e71: 00 00 00 } the_thread->Wait.return_code = RTEMS_TIMEOUT; 109e74: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax) _ISR_Enable( level ); 109e7b: 52 push %edx 109e7c: 9d popf 109e7d: 52 push %edx 109e7e: 52 push %edx 109e7f: 68 f8 ff 03 10 push $0x1003fff8 109e84: 50 push %eax 109e85: e8 1a 1f 00 00 call 10bda4 <_Thread_Clear_state> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 109e8a: a1 20 53 12 00 mov 0x125320,%eax 109e8f: 48 dec %eax 109e90: a3 20 53 12 00 mov %eax,0x125320 _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; 109e95: 83 c4 10 add $0x10,%esp case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 109e98: c9 leave 109e99: c3 ret =============================================================================== 0010fa4b <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 10fa4b: 55 push %ebp 10fa4c: 89 e5 mov %esp,%ebp 10fa4e: 57 push %edi 10fa4f: 56 push %esi 10fa50: 53 push %ebx 10fa51: 83 ec 4c sub $0x4c,%esp 10fa54: 8b 5d 08 mov 0x8(%ebp),%ebx 10fa57: 8b 4d 10 mov 0x10(%ebp),%ecx Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 10fa5a: 8b 43 20 mov 0x20(%ebx),%eax 10fa5d: 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; 10fa60: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) Heap_Block *extend_last_block = NULL; 10fa67: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) uintptr_t const page_size = heap->page_size; 10fa6e: 8b 53 10 mov 0x10(%ebx),%edx 10fa71: 89 55 c4 mov %edx,-0x3c(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10fa74: 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; 10fa77: 8b 7b 30 mov 0x30(%ebx),%edi 10fa7a: 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; 10fa7d: 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 ) { 10fa7f: 8b 7d 0c mov 0xc(%ebp),%edi 10fa82: 01 cf add %ecx,%edi 10fa84: 0f 82 d4 01 00 00 jb 10fc5e <_Heap_Extend+0x213> return false; } extend_area_ok = _Heap_Get_first_and_last_block( 10fa8a: 52 push %edx 10fa8b: 52 push %edx 10fa8c: 8d 55 e0 lea -0x20(%ebp),%edx 10fa8f: 52 push %edx 10fa90: 8d 55 e4 lea -0x1c(%ebp),%edx 10fa93: 52 push %edx 10fa94: 50 push %eax 10fa95: ff 75 c4 pushl -0x3c(%ebp) 10fa98: 51 push %ecx 10fa99: ff 75 0c pushl 0xc(%ebp) 10fa9c: e8 ba b8 ff ff call 10b35b <_Heap_Get_first_and_last_block> page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 10faa1: 83 c4 20 add $0x20,%esp 10faa4: 84 c0 test %al,%al 10faa6: 0f 84 b2 01 00 00 je 10fc5e <_Heap_Extend+0x213> 10faac: 8b 4d c0 mov -0x40(%ebp),%ecx 10faaf: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) 10fab6: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) 10fabd: 31 f6 xor %esi,%esi 10fabf: 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; 10fac6: 8b 43 18 mov 0x18(%ebx),%eax 10fac9: 89 5d b8 mov %ebx,-0x48(%ebp) 10facc: eb 02 jmp 10fad0 <_Heap_Extend+0x85> 10face: 89 c8 mov %ecx,%eax uintptr_t const sub_area_end = start_block->prev_size; 10fad0: 8b 19 mov (%ecx),%ebx Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 10fad2: 39 c7 cmp %eax,%edi 10fad4: 76 09 jbe 10fadf <_Heap_Extend+0x94> 10fad6: 39 5d 0c cmp %ebx,0xc(%ebp) 10fad9: 0f 82 7d 01 00 00 jb 10fc5c <_Heap_Extend+0x211> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10fadf: 39 c7 cmp %eax,%edi 10fae1: 74 06 je 10fae9 <_Heap_Extend+0x9e> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10fae3: 39 df cmp %ebx,%edi 10fae5: 72 07 jb 10faee <_Heap_Extend+0xa3> 10fae7: eb 08 jmp 10faf1 <_Heap_Extend+0xa6> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10fae9: 89 4d d0 mov %ecx,-0x30(%ebp) 10faec: eb 03 jmp 10faf1 <_Heap_Extend+0xa6> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10faee: 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); 10faf1: 8d 43 f8 lea -0x8(%ebx),%eax 10faf4: 89 45 d4 mov %eax,-0x2c(%ebp) 10faf7: 89 d8 mov %ebx,%eax 10faf9: 31 d2 xor %edx,%edx 10fafb: 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); 10fafe: 29 55 d4 sub %edx,-0x2c(%ebp) link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 10fb01: 3b 5d 0c cmp 0xc(%ebp),%ebx 10fb04: 75 07 jne 10fb0d <_Heap_Extend+0xc2> start_block->prev_size = extend_area_end; 10fb06: 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 ) 10fb08: 8b 75 d4 mov -0x2c(%ebp),%esi 10fb0b: eb 08 jmp 10fb15 <_Heap_Extend+0xca> merge_above_block = end_block; } else if ( sub_area_end < extend_area_begin ) { 10fb0d: 73 06 jae 10fb15 <_Heap_Extend+0xca> 10fb0f: 8b 55 d4 mov -0x2c(%ebp),%edx 10fb12: 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; 10fb15: 8b 45 d4 mov -0x2c(%ebp),%eax 10fb18: 8b 48 04 mov 0x4(%eax),%ecx 10fb1b: 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); 10fb1e: 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 ); 10fb20: 3b 4d c0 cmp -0x40(%ebp),%ecx 10fb23: 75 a9 jne 10face <_Heap_Extend+0x83> 10fb25: 8b 5d b8 mov -0x48(%ebp),%ebx if ( extend_area_begin < heap->area_begin ) { 10fb28: 8b 55 0c mov 0xc(%ebp),%edx 10fb2b: 3b 53 18 cmp 0x18(%ebx),%edx 10fb2e: 73 05 jae 10fb35 <_Heap_Extend+0xea> heap->area_begin = extend_area_begin; 10fb30: 89 53 18 mov %edx,0x18(%ebx) 10fb33: eb 08 jmp 10fb3d <_Heap_Extend+0xf2> } else if ( heap->area_end < extend_area_end ) { 10fb35: 39 7b 1c cmp %edi,0x1c(%ebx) 10fb38: 73 03 jae 10fb3d <_Heap_Extend+0xf2> heap->area_end = extend_area_end; 10fb3a: 89 7b 1c mov %edi,0x1c(%ebx) } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 10fb3d: 8b 45 e0 mov -0x20(%ebp),%eax 10fb40: 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 = 10fb43: 89 c1 mov %eax,%ecx 10fb45: 29 d1 sub %edx,%ecx 10fb47: 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; 10fb4a: 89 3a mov %edi,(%edx) extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 10fb4c: 83 c9 01 or $0x1,%ecx 10fb4f: 89 4a 04 mov %ecx,0x4(%edx) _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 10fb52: 8b 4d d4 mov -0x2c(%ebp),%ecx 10fb55: 89 08 mov %ecx,(%eax) extend_last_block->size_and_flag = 0; 10fb57: 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 ) { 10fb5e: 39 53 20 cmp %edx,0x20(%ebx) 10fb61: 76 05 jbe 10fb68 <_Heap_Extend+0x11d> heap->first_block = extend_first_block; 10fb63: 89 53 20 mov %edx,0x20(%ebx) 10fb66: eb 08 jmp 10fb70 <_Heap_Extend+0x125> } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 10fb68: 39 43 24 cmp %eax,0x24(%ebx) 10fb6b: 73 03 jae 10fb70 <_Heap_Extend+0x125> heap->last_block = extend_last_block; 10fb6d: 89 43 24 mov %eax,0x24(%ebx) } if ( merge_below_block != NULL ) { 10fb70: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 10fb74: 74 3b je 10fbb1 <_Heap_Extend+0x166> Heap_Control *heap, uintptr_t extend_area_begin, Heap_Block *first_block ) { uintptr_t const page_size = heap->page_size; 10fb76: 8b 43 10 mov 0x10(%ebx),%eax 10fb79: 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 ); 10fb7c: 8b 4d 0c mov 0xc(%ebp),%ecx 10fb7f: 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; 10fb82: 89 c8 mov %ecx,%eax 10fb84: 31 d2 xor %edx,%edx 10fb86: f7 75 d4 divl -0x2c(%ebp) if ( remainder != 0 ) { 10fb89: 85 d2 test %edx,%edx 10fb8b: 74 05 je 10fb92 <_Heap_Extend+0x147> <== ALWAYS TAKEN return value - remainder + alignment; 10fb8d: 03 4d d4 add -0x2c(%ebp),%ecx <== NOT EXECUTED 10fb90: 29 d1 sub %edx,%ecx <== NOT EXECUTED uintptr_t const new_first_block_begin = 10fb92: 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; 10fb95: 8b 45 d0 mov -0x30(%ebp),%eax 10fb98: 8b 00 mov (%eax),%eax 10fb9a: 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 = 10fb9d: 8b 45 d0 mov -0x30(%ebp),%eax 10fba0: 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; 10fba2: 83 c8 01 or $0x1,%eax 10fba5: 89 42 04 mov %eax,0x4(%edx) _Heap_Free_block( heap, new_first_block ); 10fba8: 89 d8 mov %ebx,%eax 10fbaa: e8 81 fe ff ff call 10fa30 <_Heap_Free_block> 10fbaf: eb 14 jmp 10fbc5 <_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 ) { 10fbb1: 83 7d c8 00 cmpl $0x0,-0x38(%ebp) 10fbb5: 74 0e je 10fbc5 <_Heap_Extend+0x17a> _Heap_Link_below( 10fbb7: 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; 10fbba: 8b 45 c8 mov -0x38(%ebp),%eax 10fbbd: 29 d0 sub %edx,%eax 10fbbf: 83 c8 01 or $0x1,%eax 10fbc2: 89 42 04 mov %eax,0x4(%edx) link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 10fbc5: 85 f6 test %esi,%esi 10fbc7: 74 30 je 10fbf9 <_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, 10fbc9: 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( 10fbcc: 29 f7 sub %esi,%edi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10fbce: 89 f8 mov %edi,%eax 10fbd0: 31 d2 xor %edx,%edx 10fbd2: f7 73 10 divl 0x10(%ebx) 10fbd5: 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) 10fbd7: 8b 46 04 mov 0x4(%esi),%eax 10fbda: 29 f8 sub %edi,%eax | HEAP_PREV_BLOCK_USED; 10fbdc: 83 c8 01 or $0x1,%eax 10fbdf: 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; 10fbe3: 8b 46 04 mov 0x4(%esi),%eax 10fbe6: 83 e0 01 and $0x1,%eax block->size_and_flag = size | flag; 10fbe9: 09 f8 or %edi,%eax 10fbeb: 89 46 04 mov %eax,0x4(%esi) _Heap_Block_set_size( last_block, last_block_new_size ); _Heap_Free_block( heap, last_block ); 10fbee: 89 f2 mov %esi,%edx 10fbf0: 89 d8 mov %ebx,%eax 10fbf2: e8 39 fe ff ff call 10fa30 <_Heap_Free_block> 10fbf7: eb 21 jmp 10fc1a <_Heap_Extend+0x1cf> ); } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { 10fbf9: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 10fbfd: 74 1b je 10fc1a <_Heap_Extend+0x1cf> _Heap_Link_above( 10fbff: 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 ); 10fc02: 8b 45 e4 mov -0x1c(%ebp),%eax 10fc05: 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; 10fc08: 8b 7d cc mov -0x34(%ebp),%edi 10fc0b: 8b 57 04 mov 0x4(%edi),%edx 10fc0e: 83 e2 01 and $0x1,%edx block->size_and_flag = size | flag; 10fc11: 09 d0 or %edx,%eax 10fc13: 89 47 04 mov %eax,0x4(%edi) last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 10fc16: 83 49 04 01 orl $0x1,0x4(%ecx) extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 10fc1a: 85 f6 test %esi,%esi 10fc1c: 75 10 jne 10fc2e <_Heap_Extend+0x1e3> 10fc1e: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 10fc22: 75 0a jne 10fc2e <_Heap_Extend+0x1e3> _Heap_Free_block( heap, extend_first_block ); 10fc24: 8b 55 e4 mov -0x1c(%ebp),%edx 10fc27: 89 d8 mov %ebx,%eax 10fc29: e8 02 fe ff ff call 10fa30 <_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 10fc2e: 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( 10fc31: 8b 43 20 mov 0x20(%ebx),%eax 10fc34: 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; 10fc36: 8b 4a 04 mov 0x4(%edx),%ecx 10fc39: 83 e1 01 and $0x1,%ecx block->size_and_flag = size | flag; 10fc3c: 09 c8 or %ecx,%eax 10fc3e: 89 42 04 mov %eax,0x4(%edx) } _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; 10fc41: 8b 43 30 mov 0x30(%ebx),%eax 10fc44: 2b 45 bc sub -0x44(%ebp),%eax /* Statistics */ stats->size += extended_size; 10fc47: 01 43 2c add %eax,0x2c(%ebx) if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; 10fc4a: 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 ) 10fc4f: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10fc53: 74 09 je 10fc5e <_Heap_Extend+0x213> <== NEVER TAKEN *extended_size_ptr = extended_size; 10fc55: 8b 55 14 mov 0x14(%ebp),%edx 10fc58: 89 02 mov %eax,(%edx) 10fc5a: eb 02 jmp 10fc5e <_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; 10fc5c: 31 f6 xor %esi,%esi if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 10fc5e: 89 f0 mov %esi,%eax 10fc60: 8d 65 f4 lea -0xc(%ebp),%esp 10fc63: 5b pop %ebx 10fc64: 5e pop %esi 10fc65: 5f pop %edi 10fc66: c9 leave 10fc67: c3 ret =============================================================================== 0010f690 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 10f690: 55 push %ebp 10f691: 89 e5 mov %esp,%ebp 10f693: 57 push %edi 10f694: 56 push %esi 10f695: 53 push %ebx 10f696: 83 ec 14 sub $0x14,%esp 10f699: 8b 4d 08 mov 0x8(%ebp),%ecx 10f69c: 8b 45 0c mov 0xc(%ebp),%eax 10f69f: 8d 58 f8 lea -0x8(%eax),%ebx 10f6a2: 31 d2 xor %edx,%edx 10f6a4: 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); 10f6a7: 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 10f6a9: 8b 41 20 mov 0x20(%ecx),%eax 10f6ac: 89 45 ec mov %eax,-0x14(%ebp) && (uintptr_t) block <= (uintptr_t) heap->last_block; 10f6af: 31 d2 xor %edx,%edx 10f6b1: 39 c3 cmp %eax,%ebx 10f6b3: 72 08 jb 10f6bd <_Heap_Free+0x2d> 10f6b5: 31 d2 xor %edx,%edx 10f6b7: 39 59 24 cmp %ebx,0x24(%ecx) 10f6ba: 0f 93 c2 setae %dl bool next_is_free = false; _Heap_Protection_block_check( heap, block ); if ( !_Heap_Is_block_in_heap( heap, block ) ) { return false; 10f6bd: 31 c0 xor %eax,%eax uintptr_t next_block_size = 0; bool next_is_free = false; _Heap_Protection_block_check( heap, block ); if ( !_Heap_Is_block_in_heap( heap, block ) ) { 10f6bf: 85 d2 test %edx,%edx 10f6c1: 0f 84 21 01 00 00 je 10f7e8 <_Heap_Free+0x158> --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10f6c7: 8b 43 04 mov 0x4(%ebx),%eax 10f6ca: 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; 10f6cd: 89 c6 mov %eax,%esi 10f6cf: 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); 10f6d2: 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; 10f6d5: 31 ff xor %edi,%edi 10f6d7: 3b 55 ec cmp -0x14(%ebp),%edx 10f6da: 72 0a jb 10f6e6 <_Heap_Free+0x56> <== NEVER TAKEN 10f6dc: 31 c0 xor %eax,%eax 10f6de: 39 51 24 cmp %edx,0x24(%ecx) 10f6e1: 0f 93 c0 setae %al 10f6e4: 89 c7 mov %eax,%edi _Heap_Protection_block_check( heap, next_block ); if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { _HAssert( false ); return false; 10f6e6: 31 c0 xor %eax,%eax block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); _Heap_Protection_block_check( heap, next_block ); if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { 10f6e8: 85 ff test %edi,%edi 10f6ea: 0f 84 f8 00 00 00 je 10f7e8 <_Heap_Free+0x158> <== NEVER TAKEN --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10f6f0: 8b 7a 04 mov 0x4(%edx),%edi if ( !_Heap_Is_block_in_heap( heap, next_block ) ) { _HAssert( false ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 10f6f3: f7 c7 01 00 00 00 test $0x1,%edi 10f6f9: 0f 84 e9 00 00 00 je 10f7e8 <_Heap_Free+0x158> <== 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; 10f6ff: 83 e7 fe and $0xfffffffe,%edi 10f702: 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 10f705: 8b 41 24 mov 0x24(%ecx),%eax 10f708: 89 45 e4 mov %eax,-0x1c(%ebp) && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); 10f70b: 31 c0 xor %eax,%eax 10f70d: 3b 55 e4 cmp -0x1c(%ebp),%edx 10f710: 74 0a je 10f71c <_Heap_Free+0x8c> 10f712: 31 c0 xor %eax,%eax 10f714: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1) 10f719: 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 10f71c: 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 ) ) { 10f71f: f6 45 f0 01 testb $0x1,-0x10(%ebp) 10f723: 75 62 jne 10f787 <_Heap_Free+0xf7> uintptr_t const prev_size = block->prev_size; 10f725: 8b 03 mov (%ebx),%eax 10f727: 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); 10f72a: 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; 10f72c: 31 ff xor %edi,%edi 10f72e: 3b 5d ec cmp -0x14(%ebp),%ebx 10f731: 72 0a jb 10f73d <_Heap_Free+0xad> <== NEVER TAKEN 10f733: 31 c0 xor %eax,%eax 10f735: 39 5d e4 cmp %ebx,-0x1c(%ebp) 10f738: 0f 93 c0 setae %al 10f73b: 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 ); 10f73d: 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 ) ) { 10f73f: 85 ff test %edi,%edi 10f741: 0f 84 a1 00 00 00 je 10f7e8 <_Heap_Free+0x158> <== 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) ) { 10f747: f6 43 04 01 testb $0x1,0x4(%ebx) 10f74b: 0f 84 97 00 00 00 je 10f7e8 <_Heap_Free+0x158> <== NEVER TAKEN _HAssert( false ); return( false ); } if ( next_is_free ) { /* coalesce both */ 10f751: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 10f755: 74 1a je 10f771 <_Heap_Free+0xe1> uintptr_t const size = block_size + prev_size + next_block_size; 10f757: 8b 45 e8 mov -0x18(%ebp),%eax 10f75a: 8d 04 06 lea (%esi,%eax,1),%eax 10f75d: 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; 10f760: 8b 7a 08 mov 0x8(%edx),%edi Heap_Block *prev = block->prev; 10f763: 8b 52 0c mov 0xc(%edx),%edx prev->next = next; 10f766: 89 7a 08 mov %edi,0x8(%edx) next->prev = prev; 10f769: 89 57 0c mov %edx,0xc(%edi) _Heap_Free_list_remove( next_block ); stats->free_blocks -= 1; 10f76c: ff 49 38 decl 0x38(%ecx) 10f76f: eb 33 jmp 10f7a4 <_Heap_Free+0x114> 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; 10f771: 8b 45 f0 mov -0x10(%ebp),%eax 10f774: 8d 04 06 lea (%esi,%eax,1),%eax prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 10f777: 89 c7 mov %eax,%edi 10f779: 83 cf 01 or $0x1,%edi 10f77c: 89 7b 04 mov %edi,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10f77f: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = size; 10f783: 89 02 mov %eax,(%edx) 10f785: eb 56 jmp 10f7dd <_Heap_Free+0x14d> } } else if ( next_is_free ) { /* coalesce next */ 10f787: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 10f78b: 74 24 je 10f7b1 <_Heap_Free+0x121> uintptr_t const size = block_size + next_block_size; 10f78d: 8b 45 e8 mov -0x18(%ebp),%eax 10f790: 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; 10f792: 8b 7a 08 mov 0x8(%edx),%edi Heap_Block *prev = old_block->prev; 10f795: 8b 52 0c mov 0xc(%edx),%edx new_block->next = next; 10f798: 89 7b 08 mov %edi,0x8(%ebx) new_block->prev = prev; 10f79b: 89 53 0c mov %edx,0xc(%ebx) next->prev = new_block; 10f79e: 89 5f 0c mov %ebx,0xc(%edi) prev->next = new_block; 10f7a1: 89 5a 08 mov %ebx,0x8(%edx) _Heap_Free_list_replace( next_block, block ); block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 10f7a4: 89 c2 mov %eax,%edx 10f7a6: 83 ca 01 or $0x1,%edx 10f7a9: 89 53 04 mov %edx,0x4(%ebx) next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 10f7ac: 89 04 03 mov %eax,(%ebx,%eax,1) 10f7af: eb 2c jmp 10f7dd <_Heap_Free+0x14d> RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after( Heap_Block *block_before, Heap_Block *new_block ) { Heap_Block *next = block_before->next; 10f7b1: 8b 41 08 mov 0x8(%ecx),%eax new_block->next = next; 10f7b4: 89 43 08 mov %eax,0x8(%ebx) new_block->prev = block_before; 10f7b7: 89 4b 0c mov %ecx,0xc(%ebx) block_before->next = new_block; 10f7ba: 89 59 08 mov %ebx,0x8(%ecx) next->prev = new_block; 10f7bd: 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; 10f7c0: 89 f0 mov %esi,%eax 10f7c2: 83 c8 01 or $0x1,%eax 10f7c5: 89 43 04 mov %eax,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10f7c8: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = block_size; 10f7cc: 89 32 mov %esi,(%edx) /* Statistics */ ++stats->free_blocks; 10f7ce: 8b 41 38 mov 0x38(%ecx),%eax 10f7d1: 40 inc %eax 10f7d2: 89 41 38 mov %eax,0x38(%ecx) if ( stats->max_free_blocks < stats->free_blocks ) { 10f7d5: 39 41 3c cmp %eax,0x3c(%ecx) 10f7d8: 73 03 jae 10f7dd <_Heap_Free+0x14d> stats->max_free_blocks = stats->free_blocks; 10f7da: 89 41 3c mov %eax,0x3c(%ecx) } } /* Statistics */ --stats->used_blocks; 10f7dd: ff 49 40 decl 0x40(%ecx) ++stats->frees; 10f7e0: ff 41 50 incl 0x50(%ecx) stats->free_size += block_size; 10f7e3: 01 71 30 add %esi,0x30(%ecx) return( true ); 10f7e6: b0 01 mov $0x1,%al } 10f7e8: 83 c4 14 add $0x14,%esp 10f7eb: 5b pop %ebx 10f7ec: 5e pop %esi 10f7ed: 5f pop %edi 10f7ee: c9 leave 10f7ef: c3 ret =============================================================================== 0011d4f0 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) { 11d4f0: 55 push %ebp 11d4f1: 89 e5 mov %esp,%ebp 11d4f3: 57 push %edi 11d4f4: 56 push %esi 11d4f5: 53 push %ebx 11d4f6: 8b 5d 08 mov 0x8(%ebp),%ebx 11d4f9: 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); 11d4fc: 8d 4e f8 lea -0x8(%esi),%ecx 11d4ff: 89 f0 mov %esi,%eax 11d501: 31 d2 xor %edx,%edx 11d503: 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); 11d506: 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 11d508: 8b 53 20 mov 0x20(%ebx),%edx && (uintptr_t) block <= (uintptr_t) heap->last_block; 11d50b: 31 ff xor %edi,%edi 11d50d: 39 d1 cmp %edx,%ecx 11d50f: 72 0a jb 11d51b <_Heap_Size_of_alloc_area+0x2b> 11d511: 31 c0 xor %eax,%eax 11d513: 39 4b 24 cmp %ecx,0x24(%ebx) 11d516: 0f 93 c0 setae %al 11d519: 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; 11d51b: 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 ) ) { 11d51d: 85 ff test %edi,%edi 11d51f: 74 30 je 11d551 <_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; 11d521: 8b 41 04 mov 0x4(%ecx),%eax 11d524: 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); 11d527: 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; 11d529: 31 ff xor %edi,%edi 11d52b: 39 d1 cmp %edx,%ecx 11d52d: 72 0a jb 11d539 <_Heap_Size_of_alloc_area+0x49><== NEVER TAKEN 11d52f: 31 c0 xor %eax,%eax 11d531: 39 4b 24 cmp %ecx,0x24(%ebx) 11d534: 0f 93 c0 setae %al 11d537: 89 c7 mov %eax,%edi if ( !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) ) { return false; 11d539: 31 c0 xor %eax,%eax } block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( 11d53b: 85 ff test %edi,%edi 11d53d: 74 12 je 11d551 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) 11d53f: f6 41 04 01 testb $0x1,0x4(%ecx) 11d543: 74 0c je 11d551 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 11d545: 29 f1 sub %esi,%ecx 11d547: 8d 51 04 lea 0x4(%ecx),%edx 11d54a: 8b 45 10 mov 0x10(%ebp),%eax 11d54d: 89 10 mov %edx,(%eax) return true; 11d54f: b0 01 mov $0x1,%al } 11d551: 5b pop %ebx 11d552: 5e pop %esi 11d553: 5f pop %edi 11d554: c9 leave 11d555: c3 ret =============================================================================== 0010bc16 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 10bc16: 55 push %ebp 10bc17: 89 e5 mov %esp,%ebp 10bc19: 57 push %edi 10bc1a: 56 push %esi 10bc1b: 53 push %ebx 10bc1c: 83 ec 4c sub $0x4c,%esp 10bc1f: 8b 75 08 mov 0x8(%ebp),%esi 10bc22: 8b 5d 0c mov 0xc(%ebp),%ebx uintptr_t const page_size = heap->page_size; 10bc25: 8b 46 10 mov 0x10(%esi),%eax 10bc28: 89 45 d8 mov %eax,-0x28(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10bc2b: 8b 4e 14 mov 0x14(%esi),%ecx 10bc2e: 89 4d d4 mov %ecx,-0x2c(%ebp) Heap_Block *const first_block = heap->first_block; 10bc31: 8b 46 20 mov 0x20(%esi),%eax 10bc34: 89 45 d0 mov %eax,-0x30(%ebp) Heap_Block *const last_block = heap->last_block; 10bc37: 8b 4e 24 mov 0x24(%esi),%ecx 10bc3a: 89 4d c8 mov %ecx,-0x38(%ebp) Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 10bc3d: c7 45 e4 d8 bb 10 00 movl $0x10bbd8,-0x1c(%ebp) 10bc44: 80 7d 10 00 cmpb $0x0,0x10(%ebp) 10bc48: 74 07 je 10bc51 <_Heap_Walk+0x3b> 10bc4a: c7 45 e4 dd bb 10 00 movl $0x10bbdd,-0x1c(%ebp) if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; 10bc51: 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() ) ) { 10bc53: 83 3d 24 75 12 00 03 cmpl $0x3,0x127524 10bc5a: 0f 85 e8 02 00 00 jne 10bf48 <_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)( 10bc60: 52 push %edx 10bc61: ff 76 0c pushl 0xc(%esi) 10bc64: ff 76 08 pushl 0x8(%esi) 10bc67: ff 75 c8 pushl -0x38(%ebp) 10bc6a: ff 75 d0 pushl -0x30(%ebp) 10bc6d: ff 76 1c pushl 0x1c(%esi) 10bc70: ff 76 18 pushl 0x18(%esi) 10bc73: ff 75 d4 pushl -0x2c(%ebp) 10bc76: ff 75 d8 pushl -0x28(%ebp) 10bc79: 68 71 00 12 00 push $0x120071 10bc7e: 6a 00 push $0x0 10bc80: 53 push %ebx 10bc81: 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 ) { 10bc84: 83 c4 30 add $0x30,%esp 10bc87: 83 7d d8 00 cmpl $0x0,-0x28(%ebp) 10bc8b: 75 0b jne 10bc98 <_Heap_Walk+0x82> (*printer)( source, true, "page size is zero\n" ); 10bc8d: 50 push %eax 10bc8e: 68 02 01 12 00 push $0x120102 10bc93: e9 6b 02 00 00 jmp 10bf03 <_Heap_Walk+0x2ed> return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 10bc98: f6 45 d8 03 testb $0x3,-0x28(%ebp) 10bc9c: 74 0d je 10bcab <_Heap_Walk+0x95> (*printer)( 10bc9e: ff 75 d8 pushl -0x28(%ebp) 10bca1: 68 15 01 12 00 push $0x120115 10bca6: e9 58 02 00 00 jmp 10bf03 <_Heap_Walk+0x2ed> RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bcab: 8b 45 d4 mov -0x2c(%ebp),%eax 10bcae: 31 d2 xor %edx,%edx 10bcb0: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 10bcb3: 85 d2 test %edx,%edx 10bcb5: 74 0d je 10bcc4 <_Heap_Walk+0xae> (*printer)( 10bcb7: ff 75 d4 pushl -0x2c(%ebp) 10bcba: 68 33 01 12 00 push $0x120133 10bcbf: e9 3f 02 00 00 jmp 10bf03 <_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; 10bcc4: 8b 45 d0 mov -0x30(%ebp),%eax 10bcc7: 83 c0 08 add $0x8,%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bcca: 31 d2 xor %edx,%edx 10bccc: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( 10bccf: 85 d2 test %edx,%edx 10bcd1: 74 0d je 10bce0 <_Heap_Walk+0xca> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size ) ) { (*printer)( 10bcd3: ff 75 d0 pushl -0x30(%ebp) 10bcd6: 68 57 01 12 00 push $0x120157 10bcdb: e9 23 02 00 00 jmp 10bf03 <_Heap_Walk+0x2ed> ); return false; } if ( !_Heap_Is_prev_used( first_block ) ) { 10bce0: 8b 45 d0 mov -0x30(%ebp),%eax 10bce3: f6 40 04 01 testb $0x1,0x4(%eax) 10bce7: 75 0b jne 10bcf4 <_Heap_Walk+0xde> (*printer)( 10bce9: 57 push %edi 10bcea: 68 88 01 12 00 push $0x120188 10bcef: e9 0f 02 00 00 jmp 10bf03 <_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; 10bcf4: 8b 4d c8 mov -0x38(%ebp),%ecx 10bcf7: 8b 79 04 mov 0x4(%ecx),%edi 10bcfa: 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); 10bcfd: 01 cf add %ecx,%edi ); return false; } if ( _Heap_Is_free( last_block ) ) { 10bcff: f6 47 04 01 testb $0x1,0x4(%edi) 10bd03: 75 0b jne 10bd10 <_Heap_Walk+0xfa> (*printer)( 10bd05: 56 push %esi 10bd06: 68 b6 01 12 00 push $0x1201b6 10bd0b: e9 f3 01 00 00 jmp 10bf03 <_Heap_Walk+0x2ed> ); return false; } if ( 10bd10: 3b 7d d0 cmp -0x30(%ebp),%edi 10bd13: 74 0b je 10bd20 <_Heap_Walk+0x10a> <== ALWAYS TAKEN _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block ) { (*printer)( 10bd15: 51 push %ecx <== NOT EXECUTED 10bd16: 68 cb 01 12 00 push $0x1201cb <== NOT EXECUTED 10bd1b: e9 e3 01 00 00 jmp 10bf03 <_Heap_Walk+0x2ed> <== NOT EXECUTED int source, Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; 10bd20: 8b 46 10 mov 0x10(%esi),%eax 10bd23: 89 45 e0 mov %eax,-0x20(%ebp) block = next_block; } while ( block != first_block ); return true; } 10bd26: 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 ); 10bd29: 89 75 dc mov %esi,-0x24(%ebp) 10bd2c: eb 75 jmp 10bda3 <_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; 10bd2e: 31 c0 xor %eax,%eax 10bd30: 39 4e 20 cmp %ecx,0x20(%esi) 10bd33: 77 08 ja 10bd3d <_Heap_Walk+0x127> 10bd35: 31 c0 xor %eax,%eax 10bd37: 39 4e 24 cmp %ecx,0x24(%esi) 10bd3a: 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 ) ) { 10bd3d: 85 c0 test %eax,%eax 10bd3f: 75 0b jne 10bd4c <_Heap_Walk+0x136> (*printer)( 10bd41: 51 push %ecx 10bd42: 68 fa 01 12 00 push $0x1201fa 10bd47: e9 b7 01 00 00 jmp 10bf03 <_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; 10bd4c: 8d 41 08 lea 0x8(%ecx),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bd4f: 31 d2 xor %edx,%edx 10bd51: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( 10bd54: 85 d2 test %edx,%edx 10bd56: 74 0b je 10bd63 <_Heap_Walk+0x14d> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size ) ) { (*printer)( 10bd58: 51 push %ecx 10bd59: 68 1a 02 12 00 push $0x12021a 10bd5e: e9 a0 01 00 00 jmp 10bf03 <_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; 10bd63: 8b 41 04 mov 0x4(%ecx),%eax 10bd66: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10bd69: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1) 10bd6e: 74 0b je 10bd7b <_Heap_Walk+0x165> (*printer)( 10bd70: 51 push %ecx 10bd71: 68 4a 02 12 00 push $0x12024a 10bd76: e9 88 01 00 00 jmp 10bf03 <_Heap_Walk+0x2ed> ); return false; } if ( free_block->prev != prev_block ) { 10bd7b: 8b 41 0c mov 0xc(%ecx),%eax 10bd7e: 3b 45 dc cmp -0x24(%ebp),%eax 10bd81: 74 1a je 10bd9d <_Heap_Walk+0x187> (*printer)( 10bd83: 83 ec 0c sub $0xc,%esp 10bd86: 50 push %eax 10bd87: 51 push %ecx 10bd88: 68 66 02 12 00 push $0x120266 10bd8d: 6a 01 push $0x1 10bd8f: 53 push %ebx 10bd90: ff 55 e4 call *-0x1c(%ebp) 10bd93: 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; 10bd96: 31 c0 xor %eax,%eax 10bd98: e9 ab 01 00 00 jmp 10bf48 <_Heap_Walk+0x332> return false; } prev_block = free_block; free_block = free_block->next; 10bd9d: 89 4d dc mov %ecx,-0x24(%ebp) 10bda0: 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 ) { 10bda3: 39 f1 cmp %esi,%ecx 10bda5: 75 87 jne 10bd2e <_Heap_Walk+0x118> 10bda7: 89 5d dc mov %ebx,-0x24(%ebp) 10bdaa: eb 02 jmp 10bdae <_Heap_Walk+0x198> block->prev_size ); } block = next_block; } while ( block != first_block ); 10bdac: 89 df mov %ebx,%edi return true; } 10bdae: 8b 4f 04 mov 0x4(%edi),%ecx 10bdb1: 89 4d cc mov %ecx,-0x34(%ebp) 10bdb4: 83 e1 fe and $0xfffffffe,%ecx 10bdb7: 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); 10bdba: 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; 10bdbd: 31 c0 xor %eax,%eax 10bdbf: 39 5e 20 cmp %ebx,0x20(%esi) 10bdc2: 77 08 ja 10bdcc <_Heap_Walk+0x1b6> <== NEVER TAKEN 10bdc4: 31 c0 xor %eax,%eax 10bdc6: 39 5e 24 cmp %ebx,0x24(%esi) 10bdc9: 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 ) ) { 10bdcc: 85 c0 test %eax,%eax 10bdce: 75 11 jne 10bde1 <_Heap_Walk+0x1cb> 10bdd0: 89 d9 mov %ebx,%ecx 10bdd2: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bdd5: 83 ec 0c sub $0xc,%esp 10bdd8: 51 push %ecx 10bdd9: 57 push %edi 10bdda: 68 98 02 12 00 push $0x120298 10bddf: eb ac jmp 10bd8d <_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; 10bde1: 3b 7d c8 cmp -0x38(%ebp),%edi 10bde4: 0f 95 c1 setne %cl RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bde7: 8b 45 e0 mov -0x20(%ebp),%eax 10bdea: 31 d2 xor %edx,%edx 10bdec: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 10bdef: 85 d2 test %edx,%edx 10bdf1: 74 15 je 10be08 <_Heap_Walk+0x1f2> 10bdf3: 84 c9 test %cl,%cl 10bdf5: 74 11 je 10be08 <_Heap_Walk+0x1f2> 10bdf7: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bdfa: 83 ec 0c sub $0xc,%esp 10bdfd: ff 75 e0 pushl -0x20(%ebp) 10be00: 57 push %edi 10be01: 68 c5 02 12 00 push $0x1202c5 10be06: eb 85 jmp 10bd8d <_Heap_Walk+0x177> ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 10be08: 8b 45 d4 mov -0x2c(%ebp),%eax 10be0b: 39 45 e0 cmp %eax,-0x20(%ebp) 10be0e: 73 18 jae 10be28 <_Heap_Walk+0x212> 10be10: 84 c9 test %cl,%cl 10be12: 74 14 je 10be28 <_Heap_Walk+0x212> <== NEVER TAKEN 10be14: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10be17: 52 push %edx 10be18: 52 push %edx 10be19: 50 push %eax 10be1a: ff 75 e0 pushl -0x20(%ebp) 10be1d: 57 push %edi 10be1e: 68 f3 02 12 00 push $0x1202f3 10be23: e9 65 ff ff ff jmp 10bd8d <_Heap_Walk+0x177> ); return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { 10be28: 39 fb cmp %edi,%ebx 10be2a: 77 18 ja 10be44 <_Heap_Walk+0x22e> 10be2c: 84 c9 test %cl,%cl 10be2e: 74 14 je 10be44 <_Heap_Walk+0x22e> 10be30: 89 d9 mov %ebx,%ecx 10be32: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10be35: 83 ec 0c sub $0xc,%esp 10be38: 51 push %ecx 10be39: 57 push %edi 10be3a: 68 1e 03 12 00 push $0x12031e 10be3f: e9 49 ff ff ff jmp 10bd8d <_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; 10be44: 8b 4d cc mov -0x34(%ebp),%ecx 10be47: 83 e1 01 and $0x1,%ecx 10be4a: 89 4d c4 mov %ecx,-0x3c(%ebp) ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 10be4d: f6 43 04 01 testb $0x1,0x4(%ebx) 10be51: 0f 85 ba 00 00 00 jne 10bf11 <_Heap_Walk+0x2fb> block = next_block; } while ( block != first_block ); return true; } 10be57: 8b 46 08 mov 0x8(%esi),%eax 10be5a: 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 ? 10be5d: 8b 4f 08 mov 0x8(%edi),%ecx 10be60: 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)( 10be63: ba 3e 00 12 00 mov $0x12003e,%edx 10be68: 3b 4e 0c cmp 0xc(%esi),%ecx 10be6b: 74 0e je 10be7b <_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)" : "") 10be6d: ba 75 ff 11 00 mov $0x11ff75,%edx 10be72: 39 f1 cmp %esi,%ecx 10be74: 75 05 jne 10be7b <_Heap_Walk+0x265> 10be76: ba 4d 00 12 00 mov $0x12004d,%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 ? 10be7b: 8b 47 0c mov 0xc(%edi),%eax 10be7e: 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)( 10be81: b8 57 00 12 00 mov $0x120057,%eax 10be86: 8b 4d c0 mov -0x40(%ebp),%ecx 10be89: 39 4d cc cmp %ecx,-0x34(%ebp) 10be8c: 74 0f je 10be9d <_Heap_Walk+0x287> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10be8e: b8 75 ff 11 00 mov $0x11ff75,%eax 10be93: 39 75 cc cmp %esi,-0x34(%ebp) 10be96: 75 05 jne 10be9d <_Heap_Walk+0x287> 10be98: b8 67 00 12 00 mov $0x120067,%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)( 10be9d: 83 ec 0c sub $0xc,%esp 10bea0: 52 push %edx 10bea1: ff 75 b4 pushl -0x4c(%ebp) 10bea4: 50 push %eax 10bea5: ff 75 cc pushl -0x34(%ebp) 10bea8: ff 75 e0 pushl -0x20(%ebp) 10beab: 57 push %edi 10beac: 68 52 03 12 00 push $0x120352 10beb1: 6a 00 push $0x0 10beb3: ff 75 dc pushl -0x24(%ebp) 10beb6: 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 ) { 10beb9: 8b 03 mov (%ebx),%eax 10bebb: 83 c4 30 add $0x30,%esp 10bebe: 39 45 e0 cmp %eax,-0x20(%ebp) 10bec1: 74 16 je 10bed9 <_Heap_Walk+0x2c3> 10bec3: 89 d9 mov %ebx,%ecx 10bec5: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bec8: 56 push %esi 10bec9: 51 push %ecx 10beca: 50 push %eax 10becb: ff 75 e0 pushl -0x20(%ebp) 10bece: 57 push %edi 10becf: 68 87 03 12 00 push $0x120387 10bed4: e9 b4 fe ff ff jmp 10bd8d <_Heap_Walk+0x177> ); return false; } if ( !prev_used ) { 10bed9: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 10bedd: 75 0b jne 10beea <_Heap_Walk+0x2d4> 10bedf: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bee2: 57 push %edi 10bee3: 68 c0 03 12 00 push $0x1203c0 10bee8: eb 19 jmp 10bf03 <_Heap_Walk+0x2ed> block = next_block; } while ( block != first_block ); return true; } 10beea: 8b 46 08 mov 0x8(%esi),%eax 10beed: eb 07 jmp 10bef6 <_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 ) { 10beef: 39 f8 cmp %edi,%eax 10bef1: 74 4a je 10bf3d <_Heap_Walk+0x327> return true; } free_block = free_block->next; 10bef3: 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 ) { 10bef6: 39 f0 cmp %esi,%eax 10bef8: 75 f5 jne 10beef <_Heap_Walk+0x2d9> 10befa: 8b 5d dc mov -0x24(%ebp),%ebx return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10befd: 57 push %edi 10befe: 68 2b 04 12 00 push $0x12042b 10bf03: 6a 01 push $0x1 10bf05: 53 push %ebx 10bf06: ff 55 e4 call *-0x1c(%ebp) 10bf09: 83 c4 10 add $0x10,%esp 10bf0c: e9 85 fe ff ff jmp 10bd96 <_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) { 10bf11: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 10bf15: 74 0e je 10bf25 <_Heap_Walk+0x30f> (*printer)( 10bf17: 83 ec 0c sub $0xc,%esp 10bf1a: ff 75 e0 pushl -0x20(%ebp) 10bf1d: 57 push %edi 10bf1e: 68 ef 03 12 00 push $0x1203ef 10bf23: eb 0d jmp 10bf32 <_Heap_Walk+0x31c> "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 10bf25: 51 push %ecx 10bf26: 51 push %ecx 10bf27: ff 37 pushl (%edi) 10bf29: ff 75 e0 pushl -0x20(%ebp) 10bf2c: 57 push %edi 10bf2d: 68 06 04 12 00 push $0x120406 10bf32: 6a 00 push $0x0 10bf34: ff 75 dc pushl -0x24(%ebp) 10bf37: ff 55 e4 call *-0x1c(%ebp) 10bf3a: 83 c4 20 add $0x20,%esp block->prev_size ); } block = next_block; } while ( block != first_block ); 10bf3d: 3b 5d d0 cmp -0x30(%ebp),%ebx 10bf40: 0f 85 66 fe ff ff jne 10bdac <_Heap_Walk+0x196> return true; 10bf46: b0 01 mov $0x1,%al } 10bf48: 8d 65 f4 lea -0xc(%ebp),%esp 10bf4b: 5b pop %ebx 10bf4c: 5e pop %esi 10bf4d: 5f pop %edi 10bf4e: c9 leave 10bf4f: c3 ret =============================================================================== 0010b238 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10b238: 55 push %ebp 10b239: 89 e5 mov %esp,%ebp 10b23b: 53 push %ebx 10b23c: 83 ec 08 sub $0x8,%esp 10b23f: 8b 45 08 mov 0x8(%ebp),%eax 10b242: 8b 55 0c mov 0xc(%ebp),%edx 10b245: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10b248: a3 d8 53 12 00 mov %eax,0x1253d8 _Internal_errors_What_happened.is_internal = is_internal; 10b24d: 88 15 dc 53 12 00 mov %dl,0x1253dc _Internal_errors_What_happened.the_error = the_error; 10b253: 89 1d e0 53 12 00 mov %ebx,0x1253e0 _User_extensions_Fatal( the_source, is_internal, the_error ); 10b259: 53 push %ebx 10b25a: 0f b6 d2 movzbl %dl,%edx 10b25d: 52 push %edx 10b25e: 50 push %eax 10b25f: e8 f7 19 00 00 call 10cc5b <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 10b264: c7 05 9c 54 12 00 05 movl $0x5,0x12549c <== NOT EXECUTED 10b26b: 00 00 00 _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10b26e: fa cli <== NOT EXECUTED 10b26f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b271: f4 hlt <== NOT EXECUTED 10b272: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b275: eb fe jmp 10b275 <_Internal_error_Occurred+0x3d><== NOT EXECUTED =============================================================================== 0010b2c8 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10b2c8: 55 push %ebp 10b2c9: 89 e5 mov %esp,%ebp 10b2cb: 56 push %esi 10b2cc: 53 push %ebx 10b2cd: 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; 10b2d0: 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 ) 10b2d2: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 10b2d6: 74 53 je 10b32b <_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 ); 10b2d8: 8d 73 20 lea 0x20(%ebx),%esi 10b2db: 83 ec 0c sub $0xc,%esp 10b2de: 56 push %esi 10b2df: e8 38 f7 ff ff call 10aa1c <_Chain_Get> 10b2e4: 89 c1 mov %eax,%ecx if ( information->auto_extend ) { 10b2e6: 83 c4 10 add $0x10,%esp 10b2e9: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10b2ed: 74 3c je 10b32b <_Objects_Allocate+0x63> /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10b2ef: 85 c0 test %eax,%eax 10b2f1: 75 1a jne 10b30d <_Objects_Allocate+0x45> _Objects_Extend_information( information ); 10b2f3: 83 ec 0c sub $0xc,%esp 10b2f6: 53 push %ebx 10b2f7: e8 60 00 00 00 call 10b35c <_Objects_Extend_information> the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10b2fc: 89 34 24 mov %esi,(%esp) 10b2ff: e8 18 f7 ff ff call 10aa1c <_Chain_Get> 10b304: 89 c1 mov %eax,%ecx } if ( the_object ) { 10b306: 83 c4 10 add $0x10,%esp 10b309: 85 c0 test %eax,%eax 10b30b: 74 1e je 10b32b <_Objects_Allocate+0x63> uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 10b30d: 0f b7 41 08 movzwl 0x8(%ecx),%eax 10b311: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10b315: 29 d0 sub %edx,%eax _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; 10b317: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10b31b: 31 d2 xor %edx,%edx 10b31d: f7 f6 div %esi information->inactive_per_block[ block ]--; 10b31f: c1 e0 02 shl $0x2,%eax 10b322: 03 43 30 add 0x30(%ebx),%eax 10b325: ff 08 decl (%eax) information->inactive--; 10b327: 66 ff 4b 2c decw 0x2c(%ebx) ); } #endif return the_object; } 10b32b: 89 c8 mov %ecx,%eax 10b32d: 8d 65 f8 lea -0x8(%ebp),%esp 10b330: 5b pop %ebx 10b331: 5e pop %esi 10b332: c9 leave 10b333: c3 ret =============================================================================== 0010b650 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 10b650: 55 push %ebp 10b651: 89 e5 mov %esp,%ebp 10b653: 57 push %edi 10b654: 56 push %esi 10b655: 53 push %ebx 10b656: 83 ec 0c sub $0xc,%esp 10b659: 8b 75 08 mov 0x8(%ebp),%esi 10b65c: 8b 7d 0c mov 0xc(%ebp),%edi Objects_Information *info; int the_class_api_maximum; if ( !the_class ) return NULL; 10b65f: 31 db xor %ebx,%ebx ) { Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 10b661: 66 85 ff test %di,%di 10b664: 74 37 je 10b69d <_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 ); 10b666: 83 ec 0c sub $0xc,%esp 10b669: 56 push %esi 10b66a: e8 81 41 00 00 call 10f7f0 <_Objects_API_maximum_class> if ( the_class_api_maximum == 0 ) 10b66f: 83 c4 10 add $0x10,%esp 10b672: 85 c0 test %eax,%eax 10b674: 74 27 je 10b69d <_Objects_Get_information+0x4d> return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 10b676: 0f b7 ff movzwl %di,%edi 10b679: 39 c7 cmp %eax,%edi 10b67b: 77 20 ja 10b69d <_Objects_Get_information+0x4d> return NULL; if ( !_Objects_Information_table[ the_api ] ) 10b67d: 8b 04 b5 f8 52 12 00 mov 0x1252f8(,%esi,4),%eax 10b684: 85 c0 test %eax,%eax 10b686: 74 15 je 10b69d <_Objects_Get_information+0x4d><== NEVER TAKEN return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10b688: 8b 1c b8 mov (%eax,%edi,4),%ebx if ( !info ) 10b68b: 85 db test %ebx,%ebx 10b68d: 74 0e je 10b69d <_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; 10b68f: 31 c0 xor %eax,%eax 10b691: 66 83 7b 10 00 cmpw $0x0,0x10(%ebx) 10b696: 0f 95 c0 setne %al 10b699: f7 d8 neg %eax 10b69b: 21 c3 and %eax,%ebx #endif return info; } 10b69d: 89 d8 mov %ebx,%eax 10b69f: 8d 65 f4 lea -0xc(%ebp),%esp 10b6a2: 5b pop %ebx 10b6a3: 5e pop %esi 10b6a4: 5f pop %edi 10b6a5: c9 leave 10b6a6: c3 ret =============================================================================== 00118ab4 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 118ab4: 55 push %ebp 118ab5: 89 e5 mov %esp,%ebp 118ab7: 53 push %ebx 118ab8: 8b 55 08 mov 0x8(%ebp),%edx 118abb: 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; 118abe: b8 01 00 00 00 mov $0x1,%eax 118ac3: 2b 42 08 sub 0x8(%edx),%eax 118ac6: 03 45 0c add 0xc(%ebp),%eax if ( information->maximum >= index ) { 118ac9: 0f b7 5a 10 movzwl 0x10(%edx),%ebx 118acd: 39 c3 cmp %eax,%ebx 118acf: 72 12 jb 118ae3 <_Objects_Get_no_protection+0x2f> if ( (the_object = information->local_table[ index ]) != NULL ) { 118ad1: 8b 52 1c mov 0x1c(%edx),%edx 118ad4: 8b 04 82 mov (%edx,%eax,4),%eax 118ad7: 85 c0 test %eax,%eax 118ad9: 74 08 je 118ae3 <_Objects_Get_no_protection+0x2f><== NEVER TAKEN *location = OBJECTS_LOCAL; 118adb: c7 01 00 00 00 00 movl $0x0,(%ecx) return the_object; 118ae1: eb 08 jmp 118aeb <_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; 118ae3: c7 01 01 00 00 00 movl $0x1,(%ecx) return NULL; 118ae9: 31 c0 xor %eax,%eax } 118aeb: 5b pop %ebx 118aec: c9 leave 118aed: c3 ret =============================================================================== 0010c86c <_Objects_Id_to_name>: */ Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10c86c: 55 push %ebp 10c86d: 89 e5 mov %esp,%ebp 10c86f: 53 push %ebx 10c870: 83 ec 14 sub $0x14,%esp /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10c873: 8b 45 08 mov 0x8(%ebp),%eax 10c876: 85 c0 test %eax,%eax 10c878: 75 08 jne 10c882 <_Objects_Id_to_name+0x16> 10c87a: a1 d4 78 12 00 mov 0x1278d4,%eax 10c87f: 8b 40 08 mov 0x8(%eax),%eax 10c882: 89 c2 mov %eax,%edx 10c884: c1 ea 18 shr $0x18,%edx 10c887: 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 ) 10c88a: 8d 4a ff lea -0x1(%edx),%ecx the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; 10c88d: bb 03 00 00 00 mov $0x3,%ebx 10c892: 83 f9 02 cmp $0x2,%ecx 10c895: 77 36 ja 10c8cd <_Objects_Id_to_name+0x61> 10c897: eb 3b jmp 10c8d4 <_Objects_Id_to_name+0x68> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10c899: 89 c1 mov %eax,%ecx 10c89b: 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 ]; 10c89e: 8b 14 8a mov (%edx,%ecx,4),%edx if ( !information ) 10c8a1: 85 d2 test %edx,%edx 10c8a3: 74 28 je 10c8cd <_Objects_Id_to_name+0x61><== NEVER TAKEN return OBJECTS_INVALID_ID; #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) 10c8a5: 80 7a 38 00 cmpb $0x0,0x38(%edx) 10c8a9: 75 22 jne 10c8cd <_Objects_Id_to_name+0x61><== NEVER TAKEN return OBJECTS_INVALID_ID; #endif the_object = _Objects_Get( information, tmpId, &ignored_location ); 10c8ab: 51 push %ecx 10c8ac: 8d 4d f4 lea -0xc(%ebp),%ecx 10c8af: 51 push %ecx 10c8b0: 50 push %eax 10c8b1: 52 push %edx 10c8b2: e8 5d ff ff ff call 10c814 <_Objects_Get> if ( !the_object ) 10c8b7: 83 c4 10 add $0x10,%esp 10c8ba: 85 c0 test %eax,%eax 10c8bc: 74 0f je 10c8cd <_Objects_Id_to_name+0x61> return OBJECTS_INVALID_ID; *name = the_object->name; 10c8be: 8b 50 0c mov 0xc(%eax),%edx 10c8c1: 8b 45 0c mov 0xc(%ebp),%eax 10c8c4: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10c8c6: e8 9f 09 00 00 call 10d26a <_Thread_Enable_dispatch> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10c8cb: 31 db xor %ebx,%ebx } 10c8cd: 89 d8 mov %ebx,%eax 10c8cf: 8b 5d fc mov -0x4(%ebp),%ebx 10c8d2: c9 leave 10c8d3: 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 ] ) 10c8d4: 8b 14 95 64 73 12 00 mov 0x127364(,%edx,4),%edx 10c8db: 85 d2 test %edx,%edx 10c8dd: 75 ba jne 10c899 <_Objects_Id_to_name+0x2d> 10c8df: eb ec jmp 10c8cd <_Objects_Id_to_name+0x61> =============================================================================== 0010e2bc <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 10e2bc: 55 push %ebp 10e2bd: 89 e5 mov %esp,%ebp 10e2bf: 57 push %edi 10e2c0: 56 push %esi 10e2c1: 53 push %ebx 10e2c2: 83 ec 30 sub $0x30,%esp 10e2c5: 8b 75 08 mov 0x8(%ebp),%esi 10e2c8: 8b 5d 14 mov 0x14(%ebp),%ebx 10e2cb: 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 ); 10e2ce: 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( 10e2d1: 50 push %eax 10e2d2: 56 push %esi 10e2d3: 68 f0 e2 12 00 push $0x12e2f0 10e2d8: 88 55 d4 mov %dl,-0x2c(%ebp) 10e2db: e8 f4 2a 00 00 call 110dd4 <_Objects_Get> switch ( location ) { 10e2e0: 83 c4 10 add $0x10,%esp 10e2e3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10e2e7: 8a 55 d4 mov -0x2c(%ebp),%dl 10e2ea: 0f 85 aa 00 00 00 jne 10e39a <_POSIX_Message_queue_Receive_support+0xde> case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 10e2f0: 8b 78 14 mov 0x14(%eax),%edi 10e2f3: 89 f9 mov %edi,%ecx 10e2f5: 83 e1 03 and $0x3,%ecx 10e2f8: 49 dec %ecx 10e2f9: 75 0a jne 10e305 <_POSIX_Message_queue_Receive_support+0x49> _Thread_Enable_dispatch(); 10e2fb: e8 26 35 00 00 call 111826 <_Thread_Enable_dispatch> 10e300: e9 95 00 00 00 jmp 10e39a <_POSIX_Message_queue_Receive_support+0xde> rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10e305: 8b 40 10 mov 0x10(%eax),%eax if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 10e308: 8b 48 68 mov 0x68(%eax),%ecx 10e30b: 39 4d 10 cmp %ecx,0x10(%ebp) 10e30e: 73 15 jae 10e325 <_POSIX_Message_queue_Receive_support+0x69> _Thread_Enable_dispatch(); 10e310: e8 11 35 00 00 call 111826 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EMSGSIZE ); 10e315: e8 6a 8b 00 00 call 116e84 <__errno> 10e31a: c7 00 7a 00 00 00 movl $0x7a,(%eax) 10e320: e9 80 00 00 00 jmp 10e3a5 <_POSIX_Message_queue_Receive_support+0xe9> /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 10e325: 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 ) 10e32c: 31 c9 xor %ecx,%ecx 10e32e: 84 d2 test %dl,%dl 10e330: 74 09 je 10e33b <_POSIX_Message_queue_Receive_support+0x7f><== NEVER TAKEN do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true; 10e332: 81 e7 00 40 00 00 and $0x4000,%edi 10e338: 0f 94 c1 sete %cl do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 10e33b: 52 push %edx 10e33c: 52 push %edx 10e33d: ff 75 1c pushl 0x1c(%ebp) 10e340: 0f b6 c9 movzbl %cl,%ecx 10e343: 51 push %ecx 10e344: 8d 55 e0 lea -0x20(%ebp),%edx 10e347: 52 push %edx 10e348: ff 75 0c pushl 0xc(%ebp) 10e34b: 56 push %esi 10e34c: 83 c0 1c add $0x1c,%eax 10e34f: 50 push %eax 10e350: e8 7f 1c 00 00 call 10ffd4 <_CORE_message_queue_Seize> &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 10e355: 83 c4 20 add $0x20,%esp 10e358: e8 c9 34 00 00 call 111826 <_Thread_Enable_dispatch> *msg_prio = _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); 10e35d: a1 68 e3 12 00 mov 0x12e368,%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); 10e362: 8b 50 24 mov 0x24(%eax),%edx 10e365: c1 fa 1f sar $0x1f,%edx 10e368: 8b 48 24 mov 0x24(%eax),%ecx 10e36b: 31 d1 xor %edx,%ecx 10e36d: 89 0b mov %ecx,(%ebx) 10e36f: 29 13 sub %edx,(%ebx) if ( !_Thread_Executing->Wait.return_code ) 10e371: 83 78 34 00 cmpl $0x0,0x34(%eax) 10e375: 75 05 jne 10e37c <_POSIX_Message_queue_Receive_support+0xc0> return length_out; 10e377: 8b 45 e0 mov -0x20(%ebp),%eax 10e37a: eb 2c jmp 10e3a8 <_POSIX_Message_queue_Receive_support+0xec> rtems_set_errno_and_return_minus_one( 10e37c: e8 03 8b 00 00 call 116e84 <__errno> 10e381: 89 c3 mov %eax,%ebx 10e383: 83 ec 0c sub $0xc,%esp 10e386: a1 68 e3 12 00 mov 0x12e368,%eax 10e38b: ff 70 34 pushl 0x34(%eax) 10e38e: e8 ed 01 00 00 call 10e580 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10e393: 89 03 mov %eax,(%ebx) 10e395: 83 c4 10 add $0x10,%esp 10e398: eb 0b jmp 10e3a5 <_POSIX_Message_queue_Receive_support+0xe9> #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10e39a: e8 e5 8a 00 00 call 116e84 <__errno> 10e39f: c7 00 09 00 00 00 movl $0x9,(%eax) 10e3a5: 83 c8 ff or $0xffffffff,%eax } 10e3a8: 8d 65 f4 lea -0xc(%ebp),%esp 10e3ab: 5b pop %ebx 10e3ac: 5e pop %esi 10e3ad: 5f pop %edi 10e3ae: c9 leave 10e3af: c3 ret =============================================================================== 0010e94c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>: #include void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( Thread_Control *the_thread ) { 10e94c: 55 push %ebp 10e94d: 89 e5 mov %esp,%ebp 10e94f: 83 ec 08 sub $0x8,%esp 10e952: 8b 55 08 mov 0x8(%ebp),%edx POSIX_API_Control *thread_support; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10e955: 8b 82 ec 00 00 00 mov 0xec(%edx),%eax if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10e95b: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax) 10e962: 75 2c jne 10e990 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NEVER TAKEN 10e964: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax) 10e96b: 75 23 jne 10e990 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44> thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && 10e96d: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax) 10e974: 74 1a je 10e990 <_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; 10e976: a1 10 63 12 00 mov 0x126310,%eax 10e97b: 48 dec %eax 10e97c: a3 10 63 12 00 mov %eax,0x126310 thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 10e981: 50 push %eax 10e982: 50 push %eax 10e983: 6a ff push $0xffffffff 10e985: 52 push %edx 10e986: e8 51 08 00 00 call 10f1dc <_POSIX_Thread_Exit> 10e98b: 83 c4 10 add $0x10,%esp } else _Thread_Enable_dispatch(); } 10e98e: c9 leave 10e98f: c3 ret 10e990: 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(); 10e991: e9 e8 da ff ff jmp 10c47e <_Thread_Enable_dispatch> =============================================================================== 0010fbe4 <_POSIX_Thread_Translate_sched_param>: int policy, struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) { 10fbe4: 55 push %ebp 10fbe5: 89 e5 mov %esp,%ebp 10fbe7: 57 push %edi 10fbe8: 56 push %esi 10fbe9: 53 push %ebx 10fbea: 83 ec 28 sub $0x28,%esp 10fbed: 8b 55 08 mov 0x8(%ebp),%edx 10fbf0: 8b 5d 0c mov 0xc(%ebp),%ebx 10fbf3: 8b 7d 10 mov 0x10(%ebp),%edi if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 10fbf6: ff 33 pushl (%ebx) 10fbf8: 89 55 e0 mov %edx,-0x20(%ebp) 10fbfb: e8 c4 ff ff ff call 10fbc4 <_POSIX_Priority_Is_valid> 10fc00: 83 c4 10 add $0x10,%esp return EINVAL; 10fc03: 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 ) ) 10fc08: 84 c0 test %al,%al 10fc0a: 8b 55 e0 mov -0x20(%ebp),%edx 10fc0d: 0f 84 a4 00 00 00 je 10fcb7 <_POSIX_Thread_Translate_sched_param+0xd3><== NEVER TAKEN return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 10fc13: c7 07 00 00 00 00 movl $0x0,(%edi) *budget_callout = NULL; 10fc19: 8b 45 14 mov 0x14(%ebp),%eax 10fc1c: c7 00 00 00 00 00 movl $0x0,(%eax) if ( policy == SCHED_OTHER ) { 10fc22: 85 d2 test %edx,%edx 10fc24: 75 0b jne 10fc31 <_POSIX_Thread_Translate_sched_param+0x4d> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 10fc26: c7 07 01 00 00 00 movl $0x1,(%edi) 10fc2c: e9 83 00 00 00 jmp 10fcb4 <_POSIX_Thread_Translate_sched_param+0xd0> return 0; } if ( policy == SCHED_FIFO ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; 10fc31: 31 f6 xor %esi,%esi if ( policy == SCHED_OTHER ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; return 0; } if ( policy == SCHED_FIFO ) { 10fc33: 83 fa 01 cmp $0x1,%edx 10fc36: 74 7f je 10fcb7 <_POSIX_Thread_Translate_sched_param+0xd3> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; } if ( policy == SCHED_RR ) { 10fc38: 83 fa 02 cmp $0x2,%edx 10fc3b: 75 08 jne 10fc45 <_POSIX_Thread_Translate_sched_param+0x61> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; 10fc3d: c7 07 02 00 00 00 movl $0x2,(%edi) return 0; 10fc43: eb 72 jmp 10fcb7 <_POSIX_Thread_Translate_sched_param+0xd3> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; *budget_callout = _POSIX_Threads_Sporadic_budget_callout; return 0; } return EINVAL; 10fc45: 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 ) { 10fc4a: 83 fa 04 cmp $0x4,%edx 10fc4d: 75 68 jne 10fcb7 <_POSIX_Thread_Translate_sched_param+0xd3> if ( (param->sched_ss_repl_period.tv_sec == 0) && 10fc4f: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10fc53: 75 06 jne 10fc5b <_POSIX_Thread_Translate_sched_param+0x77> 10fc55: 83 7b 0c 00 cmpl $0x0,0xc(%ebx) 10fc59: 74 5c je 10fcb7 <_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) && 10fc5b: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10fc5f: 75 0b jne 10fc6c <_POSIX_Thread_Translate_sched_param+0x88> (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; 10fc61: 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) && 10fc66: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10fc6a: 74 4b je 10fcb7 <_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 ) < 10fc6c: 83 ec 0c sub $0xc,%esp 10fc6f: 8d 43 08 lea 0x8(%ebx),%eax 10fc72: 50 push %eax 10fc73: e8 04 de ff ff call 10da7c <_Timespec_To_ticks> 10fc78: 89 45 e4 mov %eax,-0x1c(%ebp) _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) 10fc7b: 8d 43 10 lea 0x10(%ebx),%eax 10fc7e: 89 04 24 mov %eax,(%esp) 10fc81: e8 f6 dd ff ff call 10da7c <_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 ) < 10fc86: 83 c4 10 add $0x10,%esp _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) return EINVAL; 10fc89: 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 ) < 10fc8e: 39 45 e4 cmp %eax,-0x1c(%ebp) 10fc91: 72 24 jb 10fcb7 <_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 ) ) 10fc93: 83 ec 0c sub $0xc,%esp 10fc96: ff 73 04 pushl 0x4(%ebx) 10fc99: e8 26 ff ff ff call 10fbc4 <_POSIX_Priority_Is_valid> 10fc9e: 83 c4 10 add $0x10,%esp 10fca1: 84 c0 test %al,%al 10fca3: 74 12 je 10fcb7 <_POSIX_Thread_Translate_sched_param+0xd3> return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; 10fca5: c7 07 03 00 00 00 movl $0x3,(%edi) *budget_callout = _POSIX_Threads_Sporadic_budget_callout; 10fcab: 8b 45 14 mov 0x14(%ebp),%eax 10fcae: c7 00 ed a7 10 00 movl $0x10a7ed,(%eax) return 0; 10fcb4: 66 31 f6 xor %si,%si } return EINVAL; } 10fcb7: 89 f0 mov %esi,%eax 10fcb9: 8d 65 f4 lea -0xc(%ebp),%esp 10fcbc: 5b pop %ebx 10fcbd: 5e pop %esi 10fcbe: 5f pop %edi 10fcbf: c9 leave 10fcc0: c3 ret =============================================================================== 0010a4f0 <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body(void) { 10a4f0: 55 push %ebp 10a4f1: 89 e5 mov %esp,%ebp 10a4f3: 57 push %edi 10a4f4: 56 push %esi 10a4f5: 53 push %ebx 10a4f6: 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; 10a4f9: 8b 3d 10 22 12 00 mov 0x122210,%edi maximum = Configuration_POSIX_API.number_of_initialization_threads; 10a4ff: 8b 15 0c 22 12 00 mov 0x12220c,%edx if ( !user_threads || maximum == 0 ) 10a505: 85 d2 test %edx,%edx 10a507: 74 54 je 10a55d <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN 10a509: 85 ff test %edi,%edi 10a50b: 74 50 je 10a55d <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN 10a50d: 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 ); 10a50f: 8d 75 a4 lea -0x5c(%ebp),%esi 10a512: 83 ec 0c sub $0xc,%esp 10a515: 56 push %esi 10a516: 89 55 94 mov %edx,-0x6c(%ebp) 10a519: e8 a6 57 00 00 call 10fcc4 (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 10a51e: 5a pop %edx 10a51f: 59 pop %ecx 10a520: 6a 02 push $0x2 10a522: 56 push %esi 10a523: e8 c4 57 00 00 call 10fcec (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size); 10a528: 59 pop %ecx 10a529: 58 pop %eax 10a52a: ff 74 df 04 pushl 0x4(%edi,%ebx,8) 10a52e: 56 push %esi 10a52f: e8 e4 57 00 00 call 10fd18 status = pthread_create( 10a534: 6a 00 push $0x0 10a536: ff 34 df pushl (%edi,%ebx,8) 10a539: 56 push %esi 10a53a: 8d 45 e4 lea -0x1c(%ebp),%eax 10a53d: 50 push %eax 10a53e: e8 e5 fc ff ff call 10a228 &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) 10a543: 83 c4 20 add $0x20,%esp 10a546: 85 c0 test %eax,%eax 10a548: 8b 55 94 mov -0x6c(%ebp),%edx 10a54b: 74 0b je 10a558 <_POSIX_Threads_Initialize_user_threads_body+0x68> _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); 10a54d: 52 push %edx 10a54e: 50 push %eax 10a54f: 6a 01 push $0x1 10a551: 6a 02 push $0x2 10a553: e8 f0 1b 00 00 call 10c148 <_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++ ) { 10a558: 43 inc %ebx 10a559: 39 d3 cmp %edx,%ebx 10a55b: 72 b5 jb 10a512 <_POSIX_Threads_Initialize_user_threads_body+0x22><== NEVER TAKEN NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); } } 10a55d: 8d 65 f4 lea -0xc(%ebp),%esp 10a560: 5b pop %ebx 10a561: 5e pop %esi 10a562: 5f pop %edi 10a563: c9 leave 10a564: c3 ret =============================================================================== 0010ed2f <_POSIX_Threads_Sporadic_budget_TSR>: */ void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id __attribute__((unused)), void *argument ) { 10ed2f: 55 push %ebp 10ed30: 89 e5 mov %esp,%ebp 10ed32: 56 push %esi 10ed33: 53 push %ebx 10ed34: 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 ]; 10ed37: 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 ); 10ed3d: 83 ec 0c sub $0xc,%esp 10ed40: 8d 86 98 00 00 00 lea 0x98(%esi),%eax 10ed46: 50 push %eax 10ed47: e8 3c 0e 00 00 call 10fb88 <_Timespec_To_ticks> the_thread->cpu_time_budget = ticks; 10ed4c: 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); 10ed4f: 0f b6 05 f4 11 12 00 movzbl 0x1211f4,%eax 10ed56: 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; 10ed5c: 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 ) { 10ed5f: 83 c4 10 add $0x10,%esp 10ed62: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx) 10ed66: 75 12 jne 10ed7a <_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 ) { 10ed68: 39 43 14 cmp %eax,0x14(%ebx) 10ed6b: 76 0d jbe 10ed7a <_POSIX_Threads_Sporadic_budget_TSR+0x4b> _Thread_Change_priority( the_thread, new_priority, true ); 10ed6d: 52 push %edx 10ed6e: 6a 01 push $0x1 10ed70: 50 push %eax 10ed71: 53 push %ebx 10ed72: e8 19 cf ff ff call 10bc90 <_Thread_Change_priority> 10ed77: 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 ); 10ed7a: 83 ec 0c sub $0xc,%esp 10ed7d: 8d 86 90 00 00 00 lea 0x90(%esi),%eax 10ed83: 50 push %eax 10ed84: e8 ff 0d 00 00 call 10fb88 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10ed89: 89 86 b4 00 00 00 mov %eax,0xb4(%esi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10ed8f: 83 c4 10 add $0x10,%esp _Watchdog_Insert_ticks( &api->Sporadic_timer, ticks ); 10ed92: 81 c6 a8 00 00 00 add $0xa8,%esi 10ed98: 89 75 0c mov %esi,0xc(%ebp) 10ed9b: c7 45 08 04 54 12 00 movl $0x125404,0x8(%ebp) } 10eda2: 8d 65 f8 lea -0x8(%ebp),%esp 10eda5: 5b pop %ebx 10eda6: 5e pop %esi 10eda7: c9 leave 10eda8: e9 cf df ff ff jmp 10cd7c <_Watchdog_Insert> =============================================================================== 0010edad <_POSIX_Threads_Sporadic_budget_callout>: * _POSIX_Threads_Sporadic_budget_callout */ void _POSIX_Threads_Sporadic_budget_callout( Thread_Control *the_thread ) { 10edad: 55 push %ebp 10edae: 89 e5 mov %esp,%ebp 10edb0: 83 ec 08 sub $0x8,%esp 10edb3: 8b 45 08 mov 0x8(%ebp),%eax POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10edb6: 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 */ 10edbc: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax) 10edc3: 0f b6 15 f4 11 12 00 movzbl 0x1211f4,%edx 10edca: 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; 10edd0: 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 ) { 10edd3: 83 78 1c 00 cmpl $0x0,0x1c(%eax) 10edd7: 75 12 jne 10edeb <_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 ) { 10edd9: 39 50 14 cmp %edx,0x14(%eax) 10eddc: 73 0d jae 10edeb <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN _Thread_Change_priority( the_thread, new_priority, true ); 10edde: 51 push %ecx 10eddf: 6a 01 push $0x1 10ede1: 52 push %edx 10ede2: 50 push %eax 10ede3: e8 a8 ce ff ff call 10bc90 <_Thread_Change_priority> 10ede8: 83 c4 10 add $0x10,%esp #if 0 printk( "lower priority\n" ); #endif } } } 10edeb: c9 leave 10edec: c3 ret =============================================================================== 0010a2b0 <_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) { 10a2b0: 55 push %ebp 10a2b1: 89 e5 mov %esp,%ebp 10a2b3: 53 push %ebx 10a2b4: 83 ec 04 sub $0x4,%esp 10a2b7: 8b 5d 0c mov 0xc(%ebp),%ebx bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 10a2ba: ff 43 68 incl 0x68(%ebx) /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10a2bd: 83 7b 54 00 cmpl $0x0,0x54(%ebx) 10a2c1: 75 06 jne 10a2c9 <_POSIX_Timer_TSR+0x19> 10a2c3: 83 7b 58 00 cmpl $0x0,0x58(%ebx) 10a2c7: 74 34 je 10a2fd <_POSIX_Timer_TSR+0x4d> <== NEVER TAKEN ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { activated = _POSIX_Timer_Insert_helper( 10a2c9: 83 ec 0c sub $0xc,%esp 10a2cc: 53 push %ebx 10a2cd: 68 b0 a2 10 00 push $0x10a2b0 10a2d2: ff 73 08 pushl 0x8(%ebx) 10a2d5: ff 73 64 pushl 0x64(%ebx) 10a2d8: 8d 43 10 lea 0x10(%ebx),%eax 10a2db: 50 push %eax 10a2dc: e8 af 56 00 00 call 10f990 <_POSIX_Timer_Insert_helper> ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 10a2e1: 83 c4 20 add $0x20,%esp 10a2e4: 84 c0 test %al,%al 10a2e6: 74 30 je 10a318 <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 10a2e8: 83 ec 0c sub $0xc,%esp 10a2eb: 8d 43 6c lea 0x6c(%ebx),%eax 10a2ee: 50 push %eax 10a2ef: e8 5c 14 00 00 call 10b750 <_TOD_Get> /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a2f4: c6 43 3c 03 movb $0x3,0x3c(%ebx) 10a2f8: 83 c4 10 add $0x10,%esp 10a2fb: eb 04 jmp 10a301 <_POSIX_Timer_TSR+0x51> } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a2fd: 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 ) ) { 10a301: 50 push %eax 10a302: 50 push %eax 10a303: ff 73 44 pushl 0x44(%ebx) 10a306: ff 73 38 pushl 0x38(%ebx) 10a309: e8 56 52 00 00 call 10f564 } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 10a30e: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) 10a315: 83 c4 10 add $0x10,%esp } 10a318: 8b 5d fc mov -0x4(%ebp),%ebx 10a31b: c9 leave 10a31c: c3 ret =============================================================================== 00110b68 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) { 110b68: 55 push %ebp 110b69: 89 e5 mov %esp,%ebp 110b6b: 57 push %edi 110b6c: 56 push %esi 110b6d: 53 push %ebx 110b6e: 83 ec 68 sub $0x68,%esp 110b71: 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, 110b74: 6a 01 push $0x1 110b76: 0f b6 45 10 movzbl 0x10(%ebp),%eax 110b7a: 50 push %eax 110b7b: 8d 45 dc lea -0x24(%ebp),%eax 110b7e: 50 push %eax 110b7f: 53 push %ebx 110b80: ff 75 08 pushl 0x8(%ebp) 110b83: e8 8c 00 00 00 call 110c14 <_POSIX_signals_Clear_signals> 110b88: 83 c4 20 add $0x20,%esp is_global, true ) ) return false; 110b8b: 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, 110b8d: 84 c0 test %al,%al 110b8f: 74 78 je 110c09 <_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 ) 110b91: 6b d3 0c imul $0xc,%ebx,%edx 110b94: 8b 82 a4 58 12 00 mov 0x1258a4(%edx),%eax 110b9a: 83 f8 01 cmp $0x1,%eax 110b9d: 74 6a je 110c09 <_POSIX_signals_Check_signal+0xa1><== NEVER TAKEN return false; /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 110b9f: 8b 4d 08 mov 0x8(%ebp),%ecx 110ba2: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx 110ba8: 89 4d a4 mov %ecx,-0x5c(%ebp) api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 110bab: 0b 8a a0 58 12 00 or 0x1258a0(%edx),%ecx 110bb1: 8b 75 08 mov 0x8(%ebp),%esi 110bb4: 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, 110bba: 8d 7d b4 lea -0x4c(%ebp),%edi 110bbd: 8b 35 68 58 12 00 mov 0x125868,%esi 110bc3: 83 c6 20 add $0x20,%esi 110bc6: b9 0a 00 00 00 mov $0xa,%ecx 110bcb: 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 ) { 110bcd: 83 ba 9c 58 12 00 02 cmpl $0x2,0x12589c(%edx) 110bd4: 75 09 jne 110bdf <_POSIX_signals_Check_signal+0x77> case SA_SIGINFO: (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 110bd6: 52 push %edx 110bd7: 6a 00 push $0x0 110bd9: 8d 55 dc lea -0x24(%ebp),%edx 110bdc: 52 push %edx 110bdd: eb 03 jmp 110be2 <_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 ); 110bdf: 83 ec 0c sub $0xc,%esp 110be2: 53 push %ebx 110be3: ff d0 call *%eax break; 110be5: 83 c4 10 add $0x10,%esp } /* * Restore the blocking information */ memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information, 110be8: 8b 3d 68 58 12 00 mov 0x125868,%edi 110bee: 83 c7 20 add $0x20,%edi 110bf1: 8d 75 b4 lea -0x4c(%ebp),%esi 110bf4: b9 0a 00 00 00 mov $0xa,%ecx 110bf9: 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; 110bfb: 8b 75 a4 mov -0x5c(%ebp),%esi 110bfe: 8b 4d 08 mov 0x8(%ebp),%ecx 110c01: 89 b1 d0 00 00 00 mov %esi,0xd0(%ecx) return true; 110c07: b1 01 mov $0x1,%cl } 110c09: 88 c8 mov %cl,%al 110c0b: 8d 65 f4 lea -0xc(%ebp),%esp 110c0e: 5b pop %ebx 110c0f: 5e pop %esi 110c10: 5f pop %edi 110c11: c9 leave 110c12: c3 ret =============================================================================== 001110fc <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( int signo ) { 1110fc: 55 push %ebp 1110fd: 89 e5 mov %esp,%ebp 1110ff: 53 push %ebx 111100: 8b 4d 08 mov 0x8(%ebp),%ecx clear_signal = true; mask = signo_to_mask( signo ); ISR_Level level; _ISR_Disable( level ); 111103: 9c pushf 111104: fa cli 111105: 5a pop %edx if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 111106: 6b c1 0c imul $0xc,%ecx,%eax 111109: 83 b8 9c 58 12 00 02 cmpl $0x2,0x12589c(%eax) 111110: 75 0e jne 111120 <_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 ); 111112: 8d 98 98 5a 12 00 lea 0x125a98(%eax),%ebx if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 111118: 39 98 94 5a 12 00 cmp %ebx,0x125a94(%eax) 11111e: 75 0e jne 11112e <_POSIX_signals_Clear_process_signals+0x32><== NEVER TAKEN 111120: 49 dec %ecx 111121: b8 fe ff ff ff mov $0xfffffffe,%eax clear_signal = false; } if ( clear_signal ) { _POSIX_signals_Pending &= ~mask; 111126: d3 c0 rol %cl,%eax 111128: 21 05 90 5a 12 00 and %eax,0x125a90 } _ISR_Enable( level ); 11112e: 52 push %edx 11112f: 9d popf } 111130: 5b pop %ebx 111131: c9 leave 111132: c3 ret =============================================================================== 0010ab58 <_POSIX_signals_Get_lowest>: #include int _POSIX_signals_Get_lowest( sigset_t set ) { 10ab58: 55 push %ebp 10ab59: 89 e5 mov %esp,%ebp 10ab5b: 56 push %esi 10ab5c: 53 push %ebx 10ab5d: 8b 55 08 mov 0x8(%ebp),%edx int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10ab60: b8 1b 00 00 00 mov $0x1b,%eax 10ab65: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include int _POSIX_signals_Get_lowest( 10ab6a: 8d 48 ff lea -0x1(%eax),%ecx 10ab6d: 89 de mov %ebx,%esi 10ab6f: d3 e6 shl %cl,%esi ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) { 10ab71: 85 d6 test %edx,%esi 10ab73: 75 1e jne 10ab93 <_POSIX_signals_Get_lowest+0x3b><== NEVER TAKEN sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10ab75: 40 inc %eax 10ab76: 83 f8 20 cmp $0x20,%eax 10ab79: 75 ef jne 10ab6a <_POSIX_signals_Get_lowest+0x12> 10ab7b: b0 01 mov $0x1,%al 10ab7d: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include int _POSIX_signals_Get_lowest( 10ab82: 8d 48 ff lea -0x1(%eax),%ecx 10ab85: 89 de mov %ebx,%esi 10ab87: 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 ) ) { 10ab89: 85 d6 test %edx,%esi 10ab8b: 75 06 jne 10ab93 <_POSIX_signals_Get_lowest+0x3b> */ #if (SIGHUP != 1) #error "Assumption that SIGHUP==1 violated!!" #endif for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10ab8d: 40 inc %eax 10ab8e: 83 f8 1b cmp $0x1b,%eax 10ab91: 75 ef jne 10ab82 <_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; } 10ab93: 5b pop %ebx 10ab94: 5e pop %esi 10ab95: c9 leave 10ab96: c3 ret =============================================================================== 001221c0 <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 1221c0: 55 push %ebp 1221c1: 89 e5 mov %esp,%ebp 1221c3: 57 push %edi 1221c4: 56 push %esi 1221c5: 53 push %ebx 1221c6: 83 ec 0c sub $0xc,%esp 1221c9: 8b 5d 08 mov 0x8(%ebp),%ebx 1221cc: 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 ]; 1221cf: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax 1221d5: 8d 4e ff lea -0x1(%esi),%ecx 1221d8: ba 01 00 00 00 mov $0x1,%edx 1221dd: d3 e2 shl %cl,%edx /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 1221df: 8b 4b 10 mov 0x10(%ebx),%ecx 1221e2: 89 cf mov %ecx,%edi 1221e4: 81 e7 00 80 00 10 and $0x10008000,%edi 1221ea: 81 ff 00 80 00 10 cmp $0x10008000,%edi 1221f0: 75 58 jne 12224a <_POSIX_signals_Unblock_thread+0x8a> if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 1221f2: 85 53 30 test %edx,0x30(%ebx) 1221f5: 75 12 jne 122209 <_POSIX_signals_Unblock_thread+0x49> 1221f7: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 1221fd: f7 d0 not %eax /* * This should only be reached via pthread_kill(). */ return false; 1221ff: 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) ) { 122201: 85 c2 test %eax,%edx 122203: 0f 84 b0 00 00 00 je 1222b9 <_POSIX_signals_Unblock_thread+0xf9> the_thread->Wait.return_code = EINTR; 122209: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) the_info = (siginfo_t *) the_thread->Wait.return_argument; 122210: 8b 43 28 mov 0x28(%ebx),%eax if ( !info ) { 122213: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 122217: 75 12 jne 12222b <_POSIX_signals_Unblock_thread+0x6b> the_info->si_signo = signo; 122219: 89 30 mov %esi,(%eax) the_info->si_code = SI_USER; 12221b: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) the_info->si_value.sival_int = 0; 122222: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) 122229: eb 0c jmp 122237 <_POSIX_signals_Unblock_thread+0x77> } else { *the_info = *info; 12222b: b9 03 00 00 00 mov $0x3,%ecx 122230: 89 c7 mov %eax,%edi 122232: 8b 75 10 mov 0x10(%ebp),%esi 122235: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } _Thread_queue_Extract_with_proxy( the_thread ); 122237: 83 ec 0c sub $0xc,%esp 12223a: 53 push %ebx 12223b: e8 b4 ec fe ff call 110ef4 <_Thread_queue_Extract_with_proxy> return true; 122240: 83 c4 10 add $0x10,%esp 122243: bf 01 00 00 00 mov $0x1,%edi 122248: eb 6f jmp 1222b9 <_POSIX_signals_Unblock_thread+0xf9> } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 12224a: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 122250: 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; 122252: 31 ff xor %edi,%edi } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 122254: 85 c2 test %eax,%edx 122256: 74 61 je 1222b9 <_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 ) ) { 122258: f7 c1 00 00 00 10 test $0x10000000,%ecx 12225e: 74 3d je 12229d <_POSIX_signals_Unblock_thread+0xdd> the_thread->Wait.return_code = EINTR; 122260: 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) ) 122267: f7 c1 e0 be 03 00 test $0x3bee0,%ecx 12226d: 74 0b je 12227a <_POSIX_signals_Unblock_thread+0xba> _Thread_queue_Extract_with_proxy( the_thread ); 12226f: 83 ec 0c sub $0xc,%esp 122272: 53 push %ebx 122273: e8 7c ec fe ff call 110ef4 <_Thread_queue_Extract_with_proxy> 122278: eb 1e jmp 122298 <_POSIX_signals_Unblock_thread+0xd8> else if ( _States_Is_delaying(the_thread->current_state) ) { 12227a: 80 e1 08 and $0x8,%cl 12227d: 74 3a je 1222b9 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN (void) _Watchdog_Remove( &the_thread->Timer ); 12227f: 83 ec 0c sub $0xc,%esp 122282: 8d 43 48 lea 0x48(%ebx),%eax 122285: 50 push %eax 122286: e8 d1 f3 fe ff call 11165c <_Watchdog_Remove> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 12228b: 58 pop %eax 12228c: 5a pop %edx 12228d: 68 f8 ff 03 10 push $0x1003fff8 122292: 53 push %ebx 122293: e8 cc e2 fe ff call 110564 <_Thread_Clear_state> 122298: 83 c4 10 add $0x10,%esp 12229b: eb 1c jmp 1222b9 <_POSIX_signals_Unblock_thread+0xf9> _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { 12229d: 85 c9 test %ecx,%ecx 12229f: 75 18 jne 1222b9 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 1222a1: 83 3d d8 b9 12 00 00 cmpl $0x0,0x12b9d8 1222a8: 74 0f je 1222b9 <_POSIX_signals_Unblock_thread+0xf9> 1222aa: 3b 1d dc b9 12 00 cmp 0x12b9dc,%ebx 1222b0: 75 07 jne 1222b9 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN _Thread_Dispatch_necessary = true; 1222b2: c6 05 e8 b9 12 00 01 movb $0x1,0x12b9e8 } } return false; } 1222b9: 89 f8 mov %edi,%eax 1222bb: 8d 65 f4 lea -0xc(%ebp),%esp 1222be: 5b pop %ebx 1222bf: 5e pop %esi 1222c0: 5f pop %edi 1222c1: c9 leave 1222c2: c3 ret =============================================================================== 0010b3a8 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 10b3a8: 55 push %ebp 10b3a9: 89 e5 mov %esp,%ebp 10b3ab: 53 push %ebx 10b3ac: 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 ); 10b3af: 8d 45 f4 lea -0xc(%ebp),%eax 10b3b2: 50 push %eax 10b3b3: ff 75 08 pushl 0x8(%ebp) 10b3b6: 68 54 83 12 00 push $0x128354 10b3bb: e8 cc 1a 00 00 call 10ce8c <_Objects_Get> 10b3c0: 89 c3 mov %eax,%ebx switch ( location ) { 10b3c2: 83 c4 10 add $0x10,%esp 10b3c5: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10b3c9: 75 64 jne 10b42f <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN case OBJECTS_LOCAL: the_thread = the_period->owner; 10b3cb: 8b 40 40 mov 0x40(%eax),%eax if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10b3ce: f6 40 11 40 testb $0x40,0x11(%eax) 10b3d2: 74 18 je 10b3ec <_Rate_monotonic_Timeout+0x44> 10b3d4: 8b 53 08 mov 0x8(%ebx),%edx 10b3d7: 39 50 20 cmp %edx,0x20(%eax) 10b3da: 75 10 jne 10b3ec <_Rate_monotonic_Timeout+0x44> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10b3dc: 52 push %edx 10b3dd: 52 push %edx 10b3de: 68 f8 ff 03 10 push $0x1003fff8 10b3e3: 50 push %eax 10b3e4: e8 4f 21 00 00 call 10d538 <_Thread_Clear_state> the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 10b3e9: 59 pop %ecx 10b3ea: eb 10 jmp 10b3fc <_Rate_monotonic_Timeout+0x54> _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 10b3ec: 83 7b 38 01 cmpl $0x1,0x38(%ebx) 10b3f0: 75 2b jne 10b41d <_Rate_monotonic_Timeout+0x75> the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 10b3f2: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) _Rate_monotonic_Initiate_statistics( the_period ); 10b3f9: 83 ec 0c sub $0xc,%esp 10b3fc: 53 push %ebx 10b3fd: e8 ec fa ff ff call 10aeee <_Rate_monotonic_Initiate_statistics> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b402: 8b 43 3c mov 0x3c(%ebx),%eax 10b405: 89 43 1c mov %eax,0x1c(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b408: 58 pop %eax 10b409: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 10b40a: 83 c3 10 add $0x10,%ebx 10b40d: 53 push %ebx 10b40e: 68 28 85 12 00 push $0x128528 10b413: e8 f8 31 00 00 call 10e610 <_Watchdog_Insert> 10b418: 83 c4 10 add $0x10,%esp 10b41b: eb 07 jmp 10b424 <_Rate_monotonic_Timeout+0x7c> } else the_period->state = RATE_MONOTONIC_EXPIRED; 10b41d: 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; 10b424: a1 44 84 12 00 mov 0x128444,%eax 10b429: 48 dec %eax 10b42a: a3 44 84 12 00 mov %eax,0x128444 case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10b42f: 8b 5d fc mov -0x4(%ebp),%ebx 10b432: c9 leave 10b433: c3 ret =============================================================================== 0010f808 <_Scheduler_priority_Block>: void _Scheduler_priority_Block( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { 10f808: 55 push %ebp 10f809: 89 e5 mov %esp,%ebp 10f80b: 56 push %esi 10f80c: 53 push %ebx 10f80d: 8b 55 0c mov 0xc(%ebp),%edx RTEMS_INLINE_ROUTINE void _Scheduler_priority_Ready_queue_extract( Thread_Control *the_thread ) { Chain_Control *ready = the_thread->scheduler.priority->ready_chain; 10f810: 8b 82 8c 00 00 00 mov 0x8c(%edx),%eax 10f816: 8b 00 mov (%eax),%eax if ( _Chain_Has_only_one_node( ready ) ) { 10f818: 8b 48 08 mov 0x8(%eax),%ecx 10f81b: 39 08 cmp %ecx,(%eax) 10f81d: 75 38 jne 10f857 <_Scheduler_priority_Block+0x4f> 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 ); 10f81f: 8d 48 04 lea 0x4(%eax),%ecx 10f822: 89 08 mov %ecx,(%eax) head->next = tail; head->previous = NULL; 10f824: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) tail->previous = head; 10f82b: 89 40 08 mov %eax,0x8(%eax) _Chain_Initialize_empty( ready ); _Priority_bit_map_Remove( &the_thread->scheduler.priority->Priority_map ); 10f82e: 8b 8a 8c 00 00 00 mov 0x8c(%edx),%ecx RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor &= the_priority_map->block_minor; 10f834: 8b 59 04 mov 0x4(%ecx),%ebx 10f837: 66 8b 03 mov (%ebx),%ax 10f83a: 66 23 41 0e and 0xe(%ecx),%ax 10f83e: 66 89 03 mov %ax,(%ebx) if ( *the_priority_map->minor == 0 ) 10f841: 66 85 c0 test %ax,%ax 10f844: 75 1b jne 10f861 <_Scheduler_priority_Block+0x59> _Priority_Major_bit_map &= the_priority_map->block_major; 10f846: 66 a1 78 58 12 00 mov 0x125878,%ax 10f84c: 23 41 0c and 0xc(%ecx),%eax 10f84f: 66 a3 78 58 12 00 mov %ax,0x125878 10f855: eb 0a jmp 10f861 <_Scheduler_priority_Block+0x59> ) { Chain_Node *next; Chain_Node *previous; next = the_node->next; 10f857: 8b 0a mov (%edx),%ecx previous = the_node->previous; 10f859: 8b 42 04 mov 0x4(%edx),%eax next->previous = previous; 10f85c: 89 41 04 mov %eax,0x4(%ecx) previous->next = next; 10f85f: 89 08 mov %ecx,(%eax) { _Scheduler_priority_Ready_queue_extract(the_thread); /* TODO: flash critical section */ if ( _Thread_Is_heir( the_thread ) ) 10f861: 3b 15 6c 58 12 00 cmp 0x12586c,%edx 10f867: 75 42 jne 10f8ab <_Scheduler_priority_Block+0xa3> 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 ); 10f869: 66 8b 35 78 58 12 00 mov 0x125878,%si 10f870: 31 c9 xor %ecx,%ecx 10f872: 89 cb mov %ecx,%ebx 10f874: 66 0f bc de bsf %si,%bx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10f878: 0f b7 db movzwl %bx,%ebx 10f87b: 66 8b b4 1b 7c 58 12 mov 0x12587c(%ebx,%ebx,1),%si 10f882: 00 10f883: 66 0f bc ce bsf %si,%cx return (_Priority_Bits_index( major ) << 4) + 10f887: c1 e3 04 shl $0x4,%ebx 10f88a: 0f b7 c9 movzwl %cx,%ecx 10f88d: 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 ] ) ) 10f890: 6b c0 0c imul $0xc,%eax,%eax 10f893: 8b 4d 08 mov 0x8(%ebp),%ecx 10f896: 03 01 add (%ecx),%eax _Scheduler_priority_Block_body(the_scheduler, the_thread); } 10f898: 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 ); 10f89a: 83 c0 04 add $0x4,%eax return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 10f89d: 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 ] ) ) 10f89f: 39 c3 cmp %eax,%ebx 10f8a1: 74 02 je 10f8a5 <_Scheduler_priority_Block+0x9d><== NEVER TAKEN return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); 10f8a3: 89 d9 mov %ebx,%ecx RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body( Scheduler_Control *the_scheduler ) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10f8a5: 89 0d 6c 58 12 00 mov %ecx,0x12586c /* TODO: flash critical section */ if ( _Thread_Is_heir( the_thread ) ) _Scheduler_priority_Schedule_body(the_scheduler); if ( _Thread_Is_executing( the_thread ) ) 10f8ab: 3b 15 68 58 12 00 cmp 0x125868,%edx 10f8b1: 75 07 jne 10f8ba <_Scheduler_priority_Block+0xb2> _Thread_Dispatch_necessary = true; 10f8b3: c6 05 74 58 12 00 01 movb $0x1,0x125874 10f8ba: 5b pop %ebx 10f8bb: 5e pop %esi 10f8bc: c9 leave 10f8bd: c3 ret =============================================================================== 0010baa8 <_Scheduler_priority_Schedule>: */ void _Scheduler_priority_Schedule( Scheduler_Control *the_scheduler ) { 10baa8: 55 push %ebp 10baa9: 89 e5 mov %esp,%ebp 10baab: 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 ); 10baac: 66 8b 1d 78 58 12 00 mov 0x125878,%bx 10bab3: 31 d2 xor %edx,%edx 10bab5: 89 d1 mov %edx,%ecx 10bab7: 66 0f bc cb bsf %bx,%cx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10babb: 0f b7 c9 movzwl %cx,%ecx 10babe: 66 8b 9c 09 7c 58 12 mov 0x12587c(%ecx,%ecx,1),%bx 10bac5: 00 10bac6: 66 0f bc d3 bsf %bx,%dx return (_Priority_Bits_index( major ) << 4) + 10baca: c1 e1 04 shl $0x4,%ecx 10bacd: 0f b7 d2 movzwl %dx,%edx 10bad0: 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 ] ) ) 10bad3: 6b c0 0c imul $0xc,%eax,%eax 10bad6: 8b 55 08 mov 0x8(%ebp),%edx 10bad9: 03 02 add (%edx),%eax _Scheduler_priority_Schedule_body( the_scheduler ); } 10badb: 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 ); 10badd: 83 c0 04 add $0x4,%eax return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); return NULL; 10bae0: 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 ] ) ) 10bae2: 39 c1 cmp %eax,%ecx 10bae4: 74 02 je 10bae8 <_Scheduler_priority_Schedule+0x40><== NEVER TAKEN return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] ); 10bae6: 89 ca mov %ecx,%edx RTEMS_INLINE_ROUTINE void _Scheduler_priority_Schedule_body( Scheduler_Control *the_scheduler ) { _Thread_Heir = _Scheduler_priority_Ready_queue_first( 10bae8: 89 15 6c 58 12 00 mov %edx,0x12586c 10baee: 5b pop %ebx 10baef: c9 leave 10baf0: c3 ret =============================================================================== 0010acb8 <_TOD_Validate>: */ bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 10acb8: 55 push %ebp 10acb9: 89 e5 mov %esp,%ebp 10acbb: 56 push %esi 10acbc: 53 push %ebx 10acbd: 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(); 10acc0: 8b 35 04 42 12 00 mov 0x124204,%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; 10acc6: 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) || 10acc8: 85 c9 test %ecx,%ecx 10acca: 74 57 je 10ad23 <_TOD_Validate+0x6b> <== NEVER TAKEN ) { uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 10accc: b8 40 42 0f 00 mov $0xf4240,%eax 10acd1: 31 d2 xor %edx,%edx 10acd3: f7 f6 div %esi rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 10acd5: 39 41 18 cmp %eax,0x18(%ecx) 10acd8: 73 49 jae 10ad23 <_TOD_Validate+0x6b> (the_tod->ticks >= ticks_per_second) || 10acda: 83 79 14 3b cmpl $0x3b,0x14(%ecx) 10acde: 77 43 ja 10ad23 <_TOD_Validate+0x6b> (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 10ace0: 83 79 10 3b cmpl $0x3b,0x10(%ecx) 10ace4: 77 3d ja 10ad23 <_TOD_Validate+0x6b> (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 10ace6: 83 79 0c 17 cmpl $0x17,0xc(%ecx) 10acea: 77 37 ja 10ad23 <_TOD_Validate+0x6b> (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 10acec: 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) || 10acef: 85 c0 test %eax,%eax 10acf1: 74 30 je 10ad23 <_TOD_Validate+0x6b> <== NEVER TAKEN (the_tod->month == 0) || 10acf3: 83 f8 0c cmp $0xc,%eax 10acf6: 77 2b ja 10ad23 <_TOD_Validate+0x6b> (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 10acf8: 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) || 10acfa: 81 fe c3 07 00 00 cmp $0x7c3,%esi 10ad00: 76 21 jbe 10ad23 <_TOD_Validate+0x6b> (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) 10ad02: 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) || 10ad05: 85 d2 test %edx,%edx 10ad07: 74 1a je 10ad23 <_TOD_Validate+0x6b> <== NEVER TAKEN (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 10ad09: 83 e6 03 and $0x3,%esi 10ad0c: 75 09 jne 10ad17 <_TOD_Validate+0x5f> days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 10ad0e: 8b 04 85 4c 1d 12 00 mov 0x121d4c(,%eax,4),%eax 10ad15: eb 07 jmp 10ad1e <_TOD_Validate+0x66> else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 10ad17: 8b 04 85 18 1d 12 00 mov 0x121d18(,%eax,4),%eax * false - if the the_tod is invalid * * NOTE: This routine only works for leap-years through 2099. */ bool _TOD_Validate( 10ad1e: 39 c2 cmp %eax,%edx 10ad20: 0f 96 c3 setbe %bl if ( the_tod->day > days_in_month ) return false; return true; } 10ad23: 88 d8 mov %bl,%al 10ad25: 5b pop %ebx 10ad26: 5e pop %esi 10ad27: c9 leave 10ad28: c3 ret =============================================================================== 0010bc90 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10bc90: 55 push %ebp 10bc91: 89 e5 mov %esp,%ebp 10bc93: 57 push %edi 10bc94: 56 push %esi 10bc95: 53 push %ebx 10bc96: 83 ec 28 sub $0x28,%esp 10bc99: 8b 5d 08 mov 0x8(%ebp),%ebx 10bc9c: 8b 75 0c mov 0xc(%ebp),%esi 10bc9f: 8a 45 10 mov 0x10(%ebp),%al 10bca2: 88 45 e7 mov %al,-0x19(%ebp) */ /* * Save original state */ original_state = the_thread->current_state; 10bca5: 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 ); 10bca8: 53 push %ebx 10bca9: e8 1a 0c 00 00 call 10c8c8 <_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 ) 10bcae: 83 c4 10 add $0x10,%esp 10bcb1: 39 73 14 cmp %esi,0x14(%ebx) 10bcb4: 74 0c je 10bcc2 <_Thread_Change_priority+0x32> _Thread_Set_priority( the_thread, new_priority ); 10bcb6: 50 push %eax 10bcb7: 50 push %eax 10bcb8: 56 push %esi 10bcb9: 53 push %ebx 10bcba: e8 a9 0b 00 00 call 10c868 <_Thread_Set_priority> 10bcbf: 83 c4 10 add $0x10,%esp _ISR_Disable( level ); 10bcc2: 9c pushf 10bcc3: fa cli 10bcc4: 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; 10bcc5: 8b 43 10 mov 0x10(%ebx),%eax if ( state != STATES_TRANSIENT ) { 10bcc8: 83 f8 04 cmp $0x4,%eax 10bccb: 74 2f je 10bcfc <_Thread_Change_priority+0x6c> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10bccd: 83 e7 04 and $0x4,%edi 10bcd0: 75 08 jne 10bcda <_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); 10bcd2: 89 c2 mov %eax,%edx 10bcd4: 83 e2 fb and $0xfffffffb,%edx 10bcd7: 89 53 10 mov %edx,0x10(%ebx) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); 10bcda: 56 push %esi 10bcdb: 9d popf if ( _States_Is_waiting_on_thread_queue( state ) ) { 10bcdc: a9 e0 be 03 00 test $0x3bee0,%eax 10bce1: 0f 84 b5 00 00 00 je 10bd9c <_Thread_Change_priority+0x10c> _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10bce7: 89 5d 0c mov %ebx,0xc(%ebp) 10bcea: 8b 43 44 mov 0x44(%ebx),%eax 10bced: 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 ); } 10bcf0: 8d 65 f4 lea -0xc(%ebp),%esp 10bcf3: 5b pop %ebx 10bcf4: 5e pop %esi 10bcf5: 5f pop %edi 10bcf6: 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 ); 10bcf7: e9 e4 0a 00 00 jmp 10c7e0 <_Thread_queue_Requeue> } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10bcfc: 83 e7 04 and $0x4,%edi 10bcff: 75 6b jne 10bd6c <_Thread_Change_priority+0xdc><== NEVER TAKEN * Ready Queue with interrupts off. * * FIXME: hard-coded for priority scheduling. Might be ok since this * function is specific to priority scheduling? */ the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10bd01: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) if ( prepend_it ) 10bd08: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10bd0c: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax 10bd12: 74 2b je 10bd3f <_Thread_Change_priority+0xaf> RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10bd14: 8b 50 04 mov 0x4(%eax),%edx 10bd17: 66 8b 48 0a mov 0xa(%eax),%cx 10bd1b: 66 09 0a or %cx,(%edx) _Priority_Major_bit_map |= the_priority_map->ready_major; 10bd1e: 66 8b 15 78 58 12 00 mov 0x125878,%dx 10bd25: 0b 50 08 or 0x8(%eax),%edx 10bd28: 66 89 15 78 58 12 00 mov %dx,0x125878 Thread_Control *the_thread ) { _Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map ); _Chain_Prepend_unprotected( the_thread->scheduler.priority->ready_chain, 10bd2f: 8b 00 mov (%eax),%eax Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10bd31: 89 43 04 mov %eax,0x4(%ebx) before_node = after_node->next; 10bd34: 8b 10 mov (%eax),%edx after_node->next = the_node; 10bd36: 89 18 mov %ebx,(%eax) the_node->next = before_node; 10bd38: 89 13 mov %edx,(%ebx) before_node->previous = the_node; 10bd3a: 89 5a 04 mov %ebx,0x4(%edx) 10bd3d: eb 2d jmp 10bd6c <_Thread_Change_priority+0xdc> RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10bd3f: 8b 50 04 mov 0x4(%eax),%edx 10bd42: 66 8b 48 0a mov 0xa(%eax),%cx 10bd46: 66 09 0a or %cx,(%edx) _Priority_Major_bit_map |= the_priority_map->ready_major; 10bd49: 66 8b 15 78 58 12 00 mov 0x125878,%dx 10bd50: 0b 50 08 or 0x8(%eax),%edx 10bd53: 66 89 15 78 58 12 00 mov %dx,0x125878 Thread_Control *the_thread ) { _Priority_bit_map_Add( &the_thread->scheduler.priority->Priority_map ); _Chain_Append_unprotected( the_thread->scheduler.priority->ready_chain, 10bd5a: 8b 00 mov (%eax),%eax Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); Chain_Node *old_last = tail->previous; 10bd5c: 8b 50 08 mov 0x8(%eax),%edx RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected( Chain_Control *the_chain, Chain_Node *the_node ) { Chain_Node *tail = _Chain_Tail( the_chain ); 10bd5f: 8d 48 04 lea 0x4(%eax),%ecx 10bd62: 89 0b mov %ecx,(%ebx) Chain_Node *old_last = tail->previous; the_node->next = tail; tail->previous = the_node; 10bd64: 89 58 08 mov %ebx,0x8(%eax) old_last->next = the_node; 10bd67: 89 1a mov %ebx,(%edx) the_node->previous = old_last; 10bd69: 89 53 04 mov %edx,0x4(%ebx) _Scheduler_priority_Ready_queue_enqueue_first( the_thread ); else _Scheduler_priority_Ready_queue_enqueue( the_thread ); } _ISR_Flash( level ); 10bd6c: 56 push %esi 10bd6d: 9d popf 10bd6e: fa cli */ RTEMS_INLINE_ROUTINE void _Scheduler_Schedule( Scheduler_Control *the_scheduler ) { the_scheduler->Operations.schedule( the_scheduler ); 10bd6f: 83 ec 0c sub $0xc,%esp 10bd72: 68 a8 53 12 00 push $0x1253a8 10bd77: ff 15 ac 53 12 00 call *0x1253ac * is also the heir thread, and false otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void ) { return ( _Thread_Executing == _Thread_Heir ); 10bd7d: 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(&_Scheduler); if ( !_Thread_Is_executing_also_the_heir() && 10bd82: 83 c4 10 add $0x10,%esp 10bd85: 3b 05 6c 58 12 00 cmp 0x12586c,%eax 10bd8b: 74 0d je 10bd9a <_Thread_Change_priority+0x10a> 10bd8d: 80 78 74 00 cmpb $0x0,0x74(%eax) 10bd91: 74 07 je 10bd9a <_Thread_Change_priority+0x10a> _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; 10bd93: c6 05 74 58 12 00 01 movb $0x1,0x125874 _ISR_Enable( level ); 10bd9a: 56 push %esi 10bd9b: 9d popf } 10bd9c: 8d 65 f4 lea -0xc(%ebp),%esp 10bd9f: 5b pop %ebx 10bda0: 5e pop %esi 10bda1: 5f pop %edi 10bda2: c9 leave 10bda3: c3 ret =============================================================================== 0010bf64 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 10bf64: 55 push %ebp 10bf65: 89 e5 mov %esp,%ebp 10bf67: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10bf6a: 8d 45 f4 lea -0xc(%ebp),%eax 10bf6d: 50 push %eax 10bf6e: ff 75 08 pushl 0x8(%ebp) 10bf71: e8 82 01 00 00 call 10c0f8 <_Thread_Get> switch ( location ) { 10bf76: 83 c4 10 add $0x10,%esp 10bf79: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10bf7d: 75 1b jne 10bf9a <_Thread_Delay_ended+0x36><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_Clear_state( 10bf7f: 52 push %edx 10bf80: 52 push %edx 10bf81: 68 18 00 00 10 push $0x10000018 10bf86: 50 push %eax 10bf87: e8 18 fe ff ff call 10bda4 <_Thread_Clear_state> 10bf8c: a1 20 53 12 00 mov 0x125320,%eax 10bf91: 48 dec %eax 10bf92: a3 20 53 12 00 mov %eax,0x125320 10bf97: 83 c4 10 add $0x10,%esp | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Thread_Unnest_dispatch(); break; } } 10bf9a: c9 leave 10bf9b: c3 ret =============================================================================== 0010bf9c <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10bf9c: 55 push %ebp 10bf9d: 89 e5 mov %esp,%ebp 10bf9f: 57 push %edi 10bfa0: 56 push %esi 10bfa1: 53 push %ebx 10bfa2: 83 ec 1c sub $0x1c,%esp Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10bfa5: 8b 1d 68 58 12 00 mov 0x125868,%ebx _ISR_Disable( level ); 10bfab: 9c pushf 10bfac: fa cli 10bfad: 58 pop %eax #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); _Timestamp_Subtract( 10bfae: 8d 7d d8 lea -0x28(%ebp),%edi Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10bfb1: e9 f9 00 00 00 jmp 10c0af <_Thread_Dispatch+0x113> heir = _Thread_Heir; 10bfb6: 8b 35 6c 58 12 00 mov 0x12586c,%esi _Thread_Dispatch_disable_level = 1; 10bfbc: c7 05 20 53 12 00 01 movl $0x1,0x125320 10bfc3: 00 00 00 _Thread_Dispatch_necessary = false; 10bfc6: c6 05 74 58 12 00 00 movb $0x0,0x125874 _Thread_Executing = heir; 10bfcd: 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 ) 10bfd3: 39 de cmp %ebx,%esi 10bfd5: 0f 84 e2 00 00 00 je 10c0bd <_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 ) 10bfdb: 83 7e 7c 01 cmpl $0x1,0x7c(%esi) 10bfdf: 75 09 jne 10bfea <_Thread_Dispatch+0x4e> heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10bfe1: 8b 15 f0 52 12 00 mov 0x1252f0,%edx 10bfe7: 89 56 78 mov %edx,0x78(%esi) _ISR_Enable( level ); 10bfea: 50 push %eax 10bfeb: 9d popf #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); 10bfec: 83 ec 0c sub $0xc,%esp 10bfef: 8d 45 e0 lea -0x20(%ebp),%eax 10bff2: 50 push %eax 10bff3: e8 e0 34 00 00 call 10f4d8 <_TOD_Get_uptime> _Timestamp_Subtract( 10bff8: 83 c4 0c add $0xc,%esp 10bffb: 57 push %edi 10bffc: 8d 45 e0 lea -0x20(%ebp),%eax 10bfff: 50 push %eax 10c000: 68 f0 53 12 00 push $0x1253f0 10c005: e8 06 0b 00 00 call 10cb10 <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timestamp_Add_to( &executing->cpu_time_used, &ran ); 10c00a: 58 pop %eax 10c00b: 5a pop %edx 10c00c: 57 push %edi 10c00d: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10c013: 50 push %eax 10c014: e8 c7 0a 00 00 call 10cae0 <_Timespec_Add_to> _Thread_Time_of_last_context_switch = uptime; 10c019: 8b 45 e0 mov -0x20(%ebp),%eax 10c01c: 8b 55 e4 mov -0x1c(%ebp),%edx 10c01f: a3 f0 53 12 00 mov %eax,0x1253f0 10c024: 89 15 f4 53 12 00 mov %edx,0x1253f4 #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10c02a: a1 c8 53 12 00 mov 0x1253c8,%eax 10c02f: 83 c4 10 add $0x10,%esp 10c032: 85 c0 test %eax,%eax 10c034: 74 10 je 10c046 <_Thread_Dispatch+0xaa> <== NEVER TAKEN executing->libc_reent = *_Thread_libc_reent; 10c036: 8b 10 mov (%eax),%edx 10c038: 89 93 e4 00 00 00 mov %edx,0xe4(%ebx) *_Thread_libc_reent = heir->libc_reent; 10c03e: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx 10c044: 89 10 mov %edx,(%eax) } _User_extensions_Thread_switch( executing, heir ); 10c046: 51 push %ecx 10c047: 51 push %ecx 10c048: 56 push %esi 10c049: 53 push %ebx 10c04a: e8 f9 0c 00 00 call 10cd48 <_User_extensions_Thread_switch> if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10c04f: 58 pop %eax 10c050: 5a pop %edx 10c051: 81 c6 c8 00 00 00 add $0xc8,%esi 10c057: 56 push %esi 10c058: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax 10c05e: 50 push %eax 10c05f: e8 ac 0f 00 00 call 10d010 <_CPU_Context_switch> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10c064: 83 c4 10 add $0x10,%esp 10c067: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx) 10c06e: 74 36 je 10c0a6 <_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 ); 10c070: a1 a4 53 12 00 mov 0x1253a4,%eax 10c075: 39 c3 cmp %eax,%ebx 10c077: 74 2d je 10c0a6 <_Thread_Dispatch+0x10a> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10c079: 85 c0 test %eax,%eax 10c07b: 74 11 je 10c08e <_Thread_Dispatch+0xf2> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10c07d: 83 ec 0c sub $0xc,%esp 10c080: 05 e0 00 00 00 add $0xe0,%eax 10c085: 50 push %eax 10c086: e8 b9 0f 00 00 call 10d044 <_CPU_Context_save_fp> 10c08b: 83 c4 10 add $0x10,%esp _Context_Restore_fp( &executing->fp_context ); 10c08e: 83 ec 0c sub $0xc,%esp 10c091: 8d 83 e0 00 00 00 lea 0xe0(%ebx),%eax 10c097: 50 push %eax 10c098: e8 b1 0f 00 00 call 10d04e <_CPU_Context_restore_fp> _Thread_Allocated_fp = executing; 10c09d: 89 1d a4 53 12 00 mov %ebx,0x1253a4 10c0a3: 83 c4 10 add $0x10,%esp if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10c0a6: 8b 1d 68 58 12 00 mov 0x125868,%ebx _ISR_Disable( level ); 10c0ac: 9c pushf 10c0ad: fa cli 10c0ae: 58 pop %eax Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10c0af: 8a 15 74 58 12 00 mov 0x125874,%dl 10c0b5: 84 d2 test %dl,%dl 10c0b7: 0f 85 f9 fe ff ff jne 10bfb6 <_Thread_Dispatch+0x1a> _ISR_Disable( level ); } post_switch: _Thread_Dispatch_disable_level = 0; 10c0bd: c7 05 20 53 12 00 00 movl $0x0,0x125320 10c0c4: 00 00 00 _ISR_Enable( level ); 10c0c7: 50 push %eax 10c0c8: 9d popf _API_extensions_Run_postswitch(); 10c0c9: e8 15 e8 ff ff call 10a8e3 <_API_extensions_Run_postswitch> } 10c0ce: 8d 65 f4 lea -0xc(%ebp),%esp 10c0d1: 5b pop %ebx 10c0d2: 5e pop %esi 10c0d3: 5f pop %edi 10c0d4: c9 leave 10c0d5: c3 ret =============================================================================== 00110fb0 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 110fb0: 55 push %ebp 110fb1: 89 e5 mov %esp,%ebp 110fb3: 53 push %ebx 110fb4: 83 ec 14 sub $0x14,%esp #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing; 110fb7: 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; 110fbd: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax _ISR_Set_level(level); 110fc3: 85 c0 test %eax,%eax 110fc5: 74 03 je 110fca <_Thread_Handler+0x1a> 110fc7: fa cli 110fc8: eb 01 jmp 110fcb <_Thread_Handler+0x1b> 110fca: fb sti #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) doneCons = doneConstructors; 110fcb: a0 e0 4f 12 00 mov 0x124fe0,%al 110fd0: 88 45 f7 mov %al,-0x9(%ebp) doneConstructors = 1; 110fd3: c6 05 e0 4f 12 00 01 movb $0x1,0x124fe0 #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 110fda: 83 bb e0 00 00 00 00 cmpl $0x0,0xe0(%ebx) 110fe1: 74 24 je 111007 <_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 ); 110fe3: a1 a4 53 12 00 mov 0x1253a4,%eax 110fe8: 39 c3 cmp %eax,%ebx 110fea: 74 1b je 111007 <_Thread_Handler+0x57> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 110fec: 85 c0 test %eax,%eax 110fee: 74 11 je 111001 <_Thread_Handler+0x51> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 110ff0: 83 ec 0c sub $0xc,%esp 110ff3: 05 e0 00 00 00 add $0xe0,%eax 110ff8: 50 push %eax 110ff9: e8 46 c0 ff ff call 10d044 <_CPU_Context_save_fp> 110ffe: 83 c4 10 add $0x10,%esp _Thread_Allocated_fp = executing; 111001: 89 1d a4 53 12 00 mov %ebx,0x1253a4 /* * 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 ); 111007: 83 ec 0c sub $0xc,%esp 11100a: 53 push %ebx 11100b: e8 e8 bb ff ff call 10cbf8 <_User_extensions_Thread_begin> /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 111010: e8 c1 b0 ff ff call 10c0d6 <_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) */ { 111015: 83 c4 10 add $0x10,%esp 111018: 80 7d f7 00 cmpb $0x0,-0x9(%ebp) 11101c: 75 05 jne 111023 <_Thread_Handler+0x73> INIT_NAME (); 11101e: e8 2d c7 00 00 call 11d750 <__start_set_sysctl_set> } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 111023: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 111029: 85 c0 test %eax,%eax 11102b: 75 0b jne 111038 <_Thread_Handler+0x88> executing->Wait.return_argument = (*(Thread_Entry_numeric) executing->Start.entry_point)( 11102d: 83 ec 0c sub $0xc,%esp 111030: ff b3 9c 00 00 00 pushl 0x9c(%ebx) 111036: eb 0c jmp 111044 <_Thread_Handler+0x94> executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { 111038: 48 dec %eax 111039: 75 15 jne 111050 <_Thread_Handler+0xa0> <== NEVER TAKEN executing->Wait.return_argument = (*(Thread_Entry_pointer) executing->Start.entry_point)( 11103b: 83 ec 0c sub $0xc,%esp 11103e: ff b3 98 00 00 00 pushl 0x98(%ebx) 111044: 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 = 11104a: 89 43 28 mov %eax,0x28(%ebx) 11104d: 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 ); 111050: 83 ec 0c sub $0xc,%esp 111053: 53 push %ebx 111054: e8 d0 bb ff ff call 10cc29 <_User_extensions_Thread_exitted> _Internal_error_Occurred( 111059: 83 c4 0c add $0xc,%esp 11105c: 6a 05 push $0x5 11105e: 6a 01 push $0x1 111060: 6a 00 push $0x0 111062: e8 d1 a1 ff ff call 10b238 <_Internal_error_Occurred> =============================================================================== 0010c168 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10c168: 55 push %ebp 10c169: 89 e5 mov %esp,%ebp 10c16b: 57 push %edi 10c16c: 56 push %esi 10c16d: 53 push %ebx 10c16e: 83 ec 1c sub $0x1c,%esp 10c171: 8b 5d 0c mov 0xc(%ebp),%ebx 10c174: 8b 4d 10 mov 0x10(%ebp),%ecx 10c177: 8b 75 14 mov 0x14(%ebp),%esi 10c17a: 8a 55 18 mov 0x18(%ebp),%dl 10c17d: 8a 45 20 mov 0x20(%ebp),%al 10c180: 88 45 e3 mov %al,-0x1d(%ebp) /* * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; 10c183: c7 83 e8 00 00 00 00 movl $0x0,0xe8(%ebx) 10c18a: 00 00 00 10c18d: c7 83 ec 00 00 00 00 movl $0x0,0xec(%ebx) 10c194: 00 00 00 extensions_area = NULL; the_thread->libc_reent = NULL; 10c197: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10c19e: 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 ) { 10c1a1: 85 c9 test %ecx,%ecx 10c1a3: 75 31 jne 10c1d6 <_Thread_Initialize+0x6e> actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10c1a5: 51 push %ecx 10c1a6: 51 push %ecx 10c1a7: 56 push %esi 10c1a8: 53 push %ebx 10c1a9: 88 55 dc mov %dl,-0x24(%ebp) 10c1ac: e8 87 07 00 00 call 10c938 <_Thread_Stack_Allocate> if ( !actual_stack_size || actual_stack_size < stack_size ) 10c1b1: 83 c4 10 add $0x10,%esp 10c1b4: 39 f0 cmp %esi,%eax 10c1b6: 8a 55 dc mov -0x24(%ebp),%dl 10c1b9: 0f 82 f9 01 00 00 jb 10c3b8 <_Thread_Initialize+0x250> 10c1bf: 85 c0 test %eax,%eax 10c1c1: 0f 84 f1 01 00 00 je 10c3b8 <_Thread_Initialize+0x250><== NEVER TAKEN return false; /* stack allocation failed */ stack = the_thread->Start.stack; 10c1c7: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx the_thread->Start.core_allocated_stack = true; 10c1cd: c6 83 b4 00 00 00 01 movb $0x1,0xb4(%ebx) 10c1d4: eb 09 jmp 10c1df <_Thread_Initialize+0x77> } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = false; 10c1d6: c6 83 b4 00 00 00 00 movb $0x0,0xb4(%ebx) 10c1dd: 89 f0 mov %esi,%eax Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 10c1df: 89 8b bc 00 00 00 mov %ecx,0xbc(%ebx) the_stack->size = size; 10c1e5: 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; 10c1eb: 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 ) { 10c1ed: 84 d2 test %dl,%dl 10c1ef: 74 17 je 10c208 <_Thread_Initialize+0xa0> fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10c1f1: 83 ec 0c sub $0xc,%esp 10c1f4: 6a 6c push $0x6c 10c1f6: e8 bb 0d 00 00 call 10cfb6 <_Workspace_Allocate> 10c1fb: 89 c7 mov %eax,%edi if ( !fp_area ) 10c1fd: 83 c4 10 add $0x10,%esp 10c200: 85 c0 test %eax,%eax 10c202: 0f 84 25 01 00 00 je 10c32d <_Thread_Initialize+0x1c5> goto failed; fp_area = _Context_Fp_start( fp_area, 0 ); } the_thread->fp_context = fp_area; 10c208: 89 bb e0 00 00 00 mov %edi,0xe0(%ebx) the_thread->Start.fp_context = fp_area; 10c20e: 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; 10c214: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) the_watchdog->routine = routine; 10c21b: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) the_watchdog->id = id; 10c222: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) the_watchdog->user_data = user_data; 10c229: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c230: 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; 10c235: 31 f6 xor %esi,%esi #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c237: 85 c0 test %eax,%eax 10c239: 74 1d je 10c258 <_Thread_Initialize+0xf0> extensions_area = _Workspace_Allocate( 10c23b: 83 ec 0c sub $0xc,%esp 10c23e: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10c245: 50 push %eax 10c246: e8 6b 0d 00 00 call 10cfb6 <_Workspace_Allocate> 10c24b: 89 c6 mov %eax,%esi (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) 10c24d: 83 c4 10 add $0x10,%esp 10c250: 85 c0 test %eax,%eax 10c252: 0f 84 d7 00 00 00 je 10c32f <_Thread_Initialize+0x1c7> goto failed; } the_thread->extensions = (void **) extensions_area; 10c258: 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 ) { 10c25e: 85 f6 test %esi,%esi 10c260: 74 16 je 10c278 <_Thread_Initialize+0x110> for ( i = 0; i <= _Thread_Maximum_extensions ; i++ ) 10c262: 8b 15 d4 53 12 00 mov 0x1253d4,%edx 10c268: 31 c0 xor %eax,%eax 10c26a: eb 08 jmp 10c274 <_Thread_Initialize+0x10c> the_thread->extensions[i] = NULL; 10c26c: 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++ ) 10c273: 40 inc %eax 10c274: 39 d0 cmp %edx,%eax 10c276: 76 f4 jbe 10c26c <_Thread_Initialize+0x104> /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10c278: 8a 45 e3 mov -0x1d(%ebp),%al 10c27b: 88 83 a0 00 00 00 mov %al,0xa0(%ebx) the_thread->Start.budget_algorithm = budget_algorithm; 10c281: 8b 45 24 mov 0x24(%ebp),%eax 10c284: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) the_thread->Start.budget_callout = budget_callout; 10c28a: 8b 45 28 mov 0x28(%ebp),%eax 10c28d: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) switch ( budget_algorithm ) { 10c293: 83 7d 24 02 cmpl $0x2,0x24(%ebp) 10c297: 75 08 jne 10c2a1 <_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; 10c299: a1 f0 52 12 00 mov 0x1252f0,%eax 10c29e: 89 43 78 mov %eax,0x78(%ebx) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; #endif } the_thread->Start.isr_level = isr_level; 10c2a1: 8b 45 2c mov 0x2c(%ebp),%eax 10c2a4: 89 83 ac 00 00 00 mov %eax,0xac(%ebx) the_thread->current_state = STATES_DORMANT; 10c2aa: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) the_thread->Wait.queue = NULL; 10c2b1: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) the_thread->resource_count = 0; 10c2b8: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->real_priority = priority; 10c2bf: 8b 45 1c mov 0x1c(%ebp),%eax 10c2c2: 89 43 18 mov %eax,0x18(%ebx) the_thread->Start.initial_priority = priority; 10c2c5: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx) RTEMS_INLINE_ROUTINE void* _Scheduler_Thread_scheduler_allocate( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { return 10c2cb: 52 push %edx 10c2cc: 52 push %edx 10c2cd: 53 push %ebx 10c2ce: 68 a8 53 12 00 push $0x1253a8 10c2d3: ff 15 bc 53 12 00 call *0x1253bc 10c2d9: 89 45 e4 mov %eax,-0x1c(%ebp) sched =_Scheduler_Thread_scheduler_allocate( &_Scheduler, the_thread ); if ( !sched ) 10c2dc: 83 c4 10 add $0x10,%esp 10c2df: 85 c0 test %eax,%eax 10c2e1: 74 53 je 10c336 <_Thread_Initialize+0x1ce> goto failed; _Thread_Set_priority( the_thread, priority ); 10c2e3: 50 push %eax 10c2e4: 50 push %eax 10c2e5: ff 75 1c pushl 0x1c(%ebp) 10c2e8: 53 push %ebx 10c2e9: e8 7a 05 00 00 call 10c868 <_Thread_Set_priority> /* * Initialize the CPU usage statistics */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Set_to_zero( &the_thread->cpu_time_used ); 10c2ee: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) 10c2f5: 00 00 00 10c2f8: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) 10c2ff: 00 00 00 _Thread_Stack_Free( the_thread ); return false; } 10c302: 8b 45 08 mov 0x8(%ebp),%eax 10c305: 8b 40 1c mov 0x1c(%eax),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10c308: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c30c: 89 1c 90 mov %ebx,(%eax,%edx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10c30f: 8b 45 30 mov 0x30(%ebp),%eax 10c312: 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 ); 10c315: 89 1c 24 mov %ebx,(%esp) 10c318: e8 7b 09 00 00 call 10cc98 <_User_extensions_Thread_create> 10c31d: 88 c2 mov %al,%dl if ( extension_status ) 10c31f: 83 c4 10 add $0x10,%esp return true; 10c322: 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 ) 10c324: 84 d2 test %dl,%dl 10c326: 74 0e je 10c336 <_Thread_Initialize+0x1ce> 10c328: e9 8d 00 00 00 jmp 10c3ba <_Thread_Initialize+0x252> * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10c32d: 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; 10c32f: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) extension_status = _User_extensions_Thread_create( the_thread ); if ( extension_status ) return true; failed: if ( the_thread->libc_reent ) 10c336: 8b 83 e4 00 00 00 mov 0xe4(%ebx),%eax 10c33c: 85 c0 test %eax,%eax 10c33e: 74 0c je 10c34c <_Thread_Initialize+0x1e4> _Workspace_Free( the_thread->libc_reent ); 10c340: 83 ec 0c sub $0xc,%esp 10c343: 50 push %eax 10c344: e8 86 0c 00 00 call 10cfcf <_Workspace_Free> 10c349: 83 c4 10 add $0x10,%esp for ( i=0 ; i <= THREAD_API_LAST ; i++ ) if ( the_thread->API_Extensions[i] ) 10c34c: 8b 83 e8 00 00 00 mov 0xe8(%ebx),%eax 10c352: 85 c0 test %eax,%eax 10c354: 74 0c je 10c362 <_Thread_Initialize+0x1fa> _Workspace_Free( the_thread->API_Extensions[i] ); 10c356: 83 ec 0c sub $0xc,%esp 10c359: 50 push %eax 10c35a: e8 70 0c 00 00 call 10cfcf <_Workspace_Free> 10c35f: 83 c4 10 add $0x10,%esp failed: if ( the_thread->libc_reent ) _Workspace_Free( the_thread->libc_reent ); for ( i=0 ; i <= THREAD_API_LAST ; i++ ) if ( the_thread->API_Extensions[i] ) 10c362: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax 10c368: 85 c0 test %eax,%eax 10c36a: 74 0c je 10c378 <_Thread_Initialize+0x210> _Workspace_Free( the_thread->API_Extensions[i] ); 10c36c: 83 ec 0c sub $0xc,%esp 10c36f: 50 push %eax 10c370: e8 5a 0c 00 00 call 10cfcf <_Workspace_Free> 10c375: 83 c4 10 add $0x10,%esp if ( extensions_area ) 10c378: 85 f6 test %esi,%esi 10c37a: 74 0c je 10c388 <_Thread_Initialize+0x220> (void) _Workspace_Free( extensions_area ); 10c37c: 83 ec 0c sub $0xc,%esp 10c37f: 56 push %esi 10c380: e8 4a 0c 00 00 call 10cfcf <_Workspace_Free> 10c385: 83 c4 10 add $0x10,%esp #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 10c388: 85 ff test %edi,%edi 10c38a: 74 0c je 10c398 <_Thread_Initialize+0x230> (void) _Workspace_Free( fp_area ); 10c38c: 83 ec 0c sub $0xc,%esp 10c38f: 57 push %edi 10c390: e8 3a 0c 00 00 call 10cfcf <_Workspace_Free> 10c395: 83 c4 10 add $0x10,%esp #endif if ( sched ) 10c398: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10c39c: 74 0e je 10c3ac <_Thread_Initialize+0x244> (void) _Workspace_Free( sched ); 10c39e: 83 ec 0c sub $0xc,%esp 10c3a1: ff 75 e4 pushl -0x1c(%ebp) 10c3a4: e8 26 0c 00 00 call 10cfcf <_Workspace_Free> 10c3a9: 83 c4 10 add $0x10,%esp _Thread_Stack_Free( the_thread ); 10c3ac: 83 ec 0c sub $0xc,%esp 10c3af: 53 push %ebx 10c3b0: e8 d3 05 00 00 call 10c988 <_Thread_Stack_Free> return false; 10c3b5: 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 */ 10c3b8: 31 c0 xor %eax,%eax _Thread_Stack_Free( the_thread ); return false; } 10c3ba: 8d 65 f4 lea -0xc(%ebp),%esp 10c3bd: 5b pop %ebx 10c3be: 5e pop %esi 10c3bf: 5f pop %edi 10c3c0: c9 leave 10c3c1: c3 ret =============================================================================== 0010f5f0 <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) { 10f5f0: 55 push %ebp 10f5f1: 89 e5 mov %esp,%ebp 10f5f3: 53 push %ebx 10f5f4: 83 ec 04 sub $0x4,%esp 10f5f7: 8b 45 08 mov 0x8(%ebp),%eax ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10f5fa: 9c pushf 10f5fb: fa cli 10f5fc: 5b pop %ebx current_state = the_thread->current_state; 10f5fd: 8b 50 10 mov 0x10(%eax),%edx if ( current_state & STATES_SUSPENDED ) { 10f600: f6 c2 02 test $0x2,%dl 10f603: 74 1b je 10f620 <_Thread_Resume+0x30> <== NEVER TAKEN 10f605: 83 e2 fd and $0xfffffffd,%edx current_state = the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); 10f608: 89 50 10 mov %edx,0x10(%eax) if ( _States_Is_ready( current_state ) ) { 10f60b: 85 d2 test %edx,%edx 10f60d: 75 11 jne 10f620 <_Thread_Resume+0x30> RTEMS_INLINE_ROUTINE void _Scheduler_Unblock( Scheduler_Control *the_scheduler, Thread_Control *the_thread ) { the_scheduler->Operations.unblock( the_scheduler, the_thread ); 10f60f: 52 push %edx 10f610: 52 push %edx 10f611: 50 push %eax 10f612: 68 70 84 12 00 push $0x128470 10f617: ff 15 80 84 12 00 call *0x128480 10f61d: 83 c4 10 add $0x10,%esp _Scheduler_Unblock( &_Scheduler, the_thread ); } } _ISR_Enable( level ); 10f620: 53 push %ebx 10f621: 9d popf } 10f622: 8b 5d fc mov -0x4(%ebp),%ebx 10f625: c9 leave 10f626: c3 ret =============================================================================== 0010ca70 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10ca70: 55 push %ebp 10ca71: 89 e5 mov %esp,%ebp 10ca73: 53 push %ebx 10ca74: 83 ec 04 sub $0x4,%esp Thread_Control *executing; executing = _Thread_Executing; 10ca77: 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 ) 10ca7d: 80 7b 74 00 cmpb $0x0,0x74(%ebx) 10ca81: 74 55 je 10cad8 <_Thread_Tickle_timeslice+0x68> return; if ( !_States_Is_ready( executing->current_state ) ) 10ca83: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10ca87: 75 4f jne 10cad8 <_Thread_Tickle_timeslice+0x68> /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10ca89: 8b 43 7c mov 0x7c(%ebx),%eax 10ca8c: 83 f8 01 cmp $0x1,%eax 10ca8f: 72 47 jb 10cad8 <_Thread_Tickle_timeslice+0x68> 10ca91: 83 f8 02 cmp $0x2,%eax 10ca94: 76 07 jbe 10ca9d <_Thread_Tickle_timeslice+0x2d> 10ca96: 83 f8 03 cmp $0x3,%eax 10ca99: 75 3d jne 10cad8 <_Thread_Tickle_timeslice+0x68><== NEVER TAKEN 10ca9b: eb 23 jmp 10cac0 <_Thread_Tickle_timeslice+0x50> 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 ) { 10ca9d: 8b 43 78 mov 0x78(%ebx),%eax 10caa0: 48 dec %eax 10caa1: 89 43 78 mov %eax,0x78(%ebx) 10caa4: 85 c0 test %eax,%eax 10caa6: 7f 30 jg 10cad8 <_Thread_Tickle_timeslice+0x68> * always operates on the scheduler that 'owns' the currently executing * thread. */ RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void ) { _Scheduler.Operations.yield( &_Scheduler ); 10caa8: 83 ec 0c sub $0xc,%esp 10caab: 68 a8 53 12 00 push $0x1253a8 10cab0: ff 15 b0 53 12 00 call *0x1253b0 * 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; 10cab6: a1 f0 52 12 00 mov 0x1252f0,%eax 10cabb: 89 43 78 mov %eax,0x78(%ebx) 10cabe: eb 15 jmp 10cad5 <_Thread_Tickle_timeslice+0x65> } break; #if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 10cac0: 8b 43 78 mov 0x78(%ebx),%eax 10cac3: 48 dec %eax 10cac4: 89 43 78 mov %eax,0x78(%ebx) 10cac7: 85 c0 test %eax,%eax 10cac9: 75 0d jne 10cad8 <_Thread_Tickle_timeslice+0x68> (*executing->budget_callout)( executing ); 10cacb: 83 ec 0c sub $0xc,%esp 10cace: 53 push %ebx 10cacf: ff 93 80 00 00 00 call *0x80(%ebx) 10cad5: 83 c4 10 add $0x10,%esp break; #endif } } 10cad8: 8b 5d fc mov -0x4(%ebp),%ebx 10cadb: c9 leave 10cadc: c3 ret =============================================================================== 0010fad8 <_Thread_queue_Process_timeout>: #include void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { 10fad8: 55 push %ebp 10fad9: 89 e5 mov %esp,%ebp 10fadb: 83 ec 08 sub $0x8,%esp 10fade: 8b 55 08 mov 0x8(%ebp),%edx Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 10fae1: 8b 42 44 mov 0x44(%edx),%eax * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED && 10fae4: 8b 48 30 mov 0x30(%eax),%ecx 10fae7: 85 c9 test %ecx,%ecx 10fae9: 74 1c je 10fb07 <_Thread_queue_Process_timeout+0x2f> 10faeb: 3b 15 68 58 12 00 cmp 0x125868,%edx 10faf1: 75 14 jne 10fb07 <_Thread_queue_Process_timeout+0x2f><== NEVER TAKEN _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { 10faf3: 83 f9 03 cmp $0x3,%ecx 10faf6: 74 21 je 10fb19 <_Thread_queue_Process_timeout+0x41> the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10faf8: 8b 48 3c mov 0x3c(%eax),%ecx 10fafb: 89 4a 34 mov %ecx,0x34(%edx) the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10fafe: c7 40 30 02 00 00 00 movl $0x2,0x30(%eax) 10fb05: eb 12 jmp 10fb19 <_Thread_queue_Process_timeout+0x41> } } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10fb07: 8b 48 3c mov 0x3c(%eax),%ecx 10fb0a: 89 4a 34 mov %ecx,0x34(%edx) _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10fb0d: 51 push %ecx 10fb0e: 51 push %ecx 10fb0f: 52 push %edx 10fb10: 50 push %eax 10fb11: e8 da fe ff ff call 10f9f0 <_Thread_queue_Extract> 10fb16: 83 c4 10 add $0x10,%esp } } 10fb19: c9 leave 10fb1a: c3 ret =============================================================================== 0010c7e0 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10c7e0: 55 push %ebp 10c7e1: 89 e5 mov %esp,%ebp 10c7e3: 57 push %edi 10c7e4: 56 push %esi 10c7e5: 53 push %ebx 10c7e6: 83 ec 1c sub $0x1c,%esp 10c7e9: 8b 75 08 mov 0x8(%ebp),%esi 10c7ec: 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 ) 10c7ef: 85 f6 test %esi,%esi 10c7f1: 74 36 je 10c829 <_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 ) { 10c7f3: 83 7e 34 01 cmpl $0x1,0x34(%esi) 10c7f7: 75 30 jne 10c829 <_Thread_queue_Requeue+0x49><== NEVER TAKEN Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10c7f9: 9c pushf 10c7fa: fa cli 10c7fb: 5b pop %ebx if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10c7fc: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi) 10c803: 74 22 je 10c827 <_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; 10c805: 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 ); 10c80c: 50 push %eax 10c80d: 6a 01 push $0x1 10c80f: 57 push %edi 10c810: 56 push %esi 10c811: e8 0a 32 00 00 call 10fa20 <_Thread_queue_Extract_priority_helper> (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10c816: 83 c4 0c add $0xc,%esp 10c819: 8d 45 e4 lea -0x1c(%ebp),%eax 10c81c: 50 push %eax 10c81d: 57 push %edi 10c81e: 56 push %esi 10c81f: e8 c0 fd ff ff call 10c5e4 <_Thread_queue_Enqueue_priority> 10c824: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10c827: 53 push %ebx 10c828: 9d popf } } 10c829: 8d 65 f4 lea -0xc(%ebp),%esp 10c82c: 5b pop %ebx 10c82d: 5e pop %esi 10c82e: 5f pop %edi 10c82f: c9 leave 10c830: c3 ret =============================================================================== 0010c834 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) { 10c834: 55 push %ebp 10c835: 89 e5 mov %esp,%ebp 10c837: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10c83a: 8d 45 f4 lea -0xc(%ebp),%eax 10c83d: 50 push %eax 10c83e: ff 75 08 pushl 0x8(%ebp) 10c841: e8 b2 f8 ff ff call 10c0f8 <_Thread_Get> switch ( location ) { 10c846: 83 c4 10 add $0x10,%esp 10c849: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10c84d: 75 17 jne 10c866 <_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 ); 10c84f: 83 ec 0c sub $0xc,%esp 10c852: 50 push %eax 10c853: e8 80 32 00 00 call 10fad8 <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10c858: a1 20 53 12 00 mov 0x125320,%eax 10c85d: 48 dec %eax 10c85e: a3 20 53 12 00 mov %eax,0x125320 10c863: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10c866: c9 leave 10c867: c3 ret =============================================================================== 00116978 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 116978: 55 push %ebp 116979: 89 e5 mov %esp,%ebp 11697b: 57 push %edi 11697c: 56 push %esi 11697d: 53 push %ebx 11697e: 83 ec 4c sub $0x4c,%esp 116981: 8b 5d 08 mov 0x8(%ebp),%ebx ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 116984: 8d 55 dc lea -0x24(%ebp),%edx 116987: 8d 45 e0 lea -0x20(%ebp),%eax 11698a: 89 45 dc mov %eax,-0x24(%ebp) head->previous = NULL; 11698d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) tail->previous = head; 116994: 89 55 e4 mov %edx,-0x1c(%ebp) ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 116997: 8d 7d d0 lea -0x30(%ebp),%edi 11699a: 8d 4d d4 lea -0x2c(%ebp),%ecx 11699d: 89 4d d0 mov %ecx,-0x30(%ebp) head->previous = NULL; 1169a0: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) tail->previous = head; 1169a7: 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 ); 1169aa: 8d 53 30 lea 0x30(%ebx),%edx 1169ad: 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 ); 1169b0: 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; 1169b3: 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; 1169b6: 8d 4d dc lea -0x24(%ebp),%ecx 1169b9: 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; 1169bc: a1 c8 f0 13 00 mov 0x13f0c8,%eax /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 1169c1: 8b 53 3c mov 0x3c(%ebx),%edx watchdogs->last_snapshot = snapshot; 1169c4: 89 43 3c mov %eax,0x3c(%ebx) _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1169c7: 51 push %ecx 1169c8: 57 push %edi Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 1169c9: 29 d0 sub %edx,%eax watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1169cb: 50 push %eax 1169cc: ff 75 c0 pushl -0x40(%ebp) 1169cf: e8 88 39 00 00 call 11a35c <_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(); 1169d4: a1 40 f0 13 00 mov 0x13f040,%eax 1169d9: 89 45 c4 mov %eax,-0x3c(%ebp) Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 1169dc: 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 ) { 1169df: 83 c4 10 add $0x10,%esp 1169e2: 39 45 c4 cmp %eax,-0x3c(%ebp) 1169e5: 76 10 jbe 1169f7 <_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 ); 1169e7: 52 push %edx 1169e8: 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; 1169e9: 8b 55 c4 mov -0x3c(%ebp),%edx 1169ec: 29 c2 sub %eax,%edx _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1169ee: 52 push %edx 1169ef: 56 push %esi 1169f0: e8 67 39 00 00 call 11a35c <_Watchdog_Adjust_to_chain> 1169f5: eb 0f jmp 116a06 <_Timer_server_Body+0x8e> } else if ( snapshot < last_snapshot ) { 1169f7: 73 10 jae 116a09 <_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 ); 1169f9: 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; 1169fa: 2b 45 c4 sub -0x3c(%ebp),%eax _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 1169fd: 50 push %eax 1169fe: 6a 01 push $0x1 116a00: 56 push %esi 116a01: e8 ea 38 00 00 call 11a2f0 <_Watchdog_Adjust> 116a06: 83 c4 10 add $0x10,%esp } watchdogs->last_snapshot = snapshot; 116a09: 8b 4d c4 mov -0x3c(%ebp),%ecx 116a0c: 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 ); 116a0f: 8b 43 78 mov 0x78(%ebx),%eax 116a12: 83 ec 0c sub $0xc,%esp 116a15: 50 push %eax 116a16: e8 f5 08 00 00 call 117310 <_Chain_Get> if ( timer == NULL ) { 116a1b: 83 c4 10 add $0x10,%esp 116a1e: 85 c0 test %eax,%eax 116a20: 74 29 je 116a4b <_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 ) { 116a22: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 116a25: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 116a28: 75 0b jne 116a35 <_Timer_server_Body+0xbd><== NOT EXECUTED _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116a2a: 52 push %edx <== NOT EXECUTED 116a2b: 52 push %edx <== NOT EXECUTED 116a2c: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 116a2f: 50 push %eax <== NOT EXECUTED 116a30: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED 116a33: eb 0c jmp 116a41 <_Timer_server_Body+0xc9><== NOT EXECUTED } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116a35: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 116a38: 75 d5 jne 116a0f <_Timer_server_Body+0x97><== NOT EXECUTED _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116a3a: 51 push %ecx <== NOT EXECUTED 116a3b: 51 push %ecx <== NOT EXECUTED 116a3c: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 116a3f: 50 push %eax <== NOT EXECUTED 116a40: 56 push %esi <== NOT EXECUTED 116a41: e8 9e 39 00 00 call 11a3e4 <_Watchdog_Insert> <== NOT EXECUTED 116a46: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116a49: eb c4 jmp 116a0f <_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 ); 116a4b: 9c pushf 116a4c: fa cli 116a4d: 5a pop %edx tmp = ts->insert_chain; 116a4e: 8b 43 78 mov 0x78(%ebx),%eax if ( _Chain_Is_empty( insert_chain ) ) { 116a51: b0 01 mov $0x1,%al 116a53: 8b 4d b4 mov -0x4c(%ebp),%ecx 116a56: 39 4d dc cmp %ecx,-0x24(%ebp) 116a59: 75 09 jne 116a64 <_Timer_server_Body+0xec><== NEVER TAKEN ts->insert_chain = NULL; 116a5b: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx) do_loop = false; 116a62: 31 c0 xor %eax,%eax } _ISR_Enable( level ); 116a64: 52 push %edx 116a65: 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 ) { 116a66: 84 c0 test %al,%al 116a68: 0f 85 4e ff ff ff jne 1169bc <_Timer_server_Body+0x44><== NEVER TAKEN 116a6e: 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 ) ) { 116a71: 39 45 d0 cmp %eax,-0x30(%ebp) 116a74: 74 3a je 116ab0 <_Timer_server_Body+0x138> 116a76: 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 ); 116a79: 9c pushf 116a7a: fa cli 116a7b: 59 pop %ecx initialized = false; } #endif return status; } 116a7c: 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)) 116a7f: 3b 45 b0 cmp -0x50(%ebp),%eax 116a82: 74 25 je 116aa9 <_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; 116a84: 8b 10 mov (%eax),%edx head->next = new_first; 116a86: 89 55 d0 mov %edx,-0x30(%ebp) new_first->previous = head; 116a89: 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 ) { 116a8c: 85 c0 test %eax,%eax 116a8e: 74 19 je 116aa9 <_Timer_server_Body+0x131><== NEVER TAKEN watchdog->state = WATCHDOG_INACTIVE; 116a90: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) _ISR_Enable( level ); 116a97: 51 push %ecx 116a98: 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 ); 116a99: 52 push %edx 116a9a: 52 push %edx 116a9b: ff 70 24 pushl 0x24(%eax) 116a9e: ff 70 20 pushl 0x20(%eax) 116aa1: ff 50 1c call *0x1c(%eax) } 116aa4: 83 c4 10 add $0x10,%esp 116aa7: eb d0 jmp 116a79 <_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 ); 116aa9: 51 push %ecx 116aaa: 9d popf 116aab: e9 06 ff ff ff jmp 1169b6 <_Timer_server_Body+0x3e> * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); } } else { ts->active = false; 116ab0: c6 43 7c 00 movb $0x0,0x7c(%ebx) /* * Block until there is something to do. */ _Thread_Disable_dispatch(); 116ab4: e8 23 fe ff ff call 1168dc <_Thread_Disable_dispatch> _Thread_Set_state( ts->thread, STATES_DELAYING ); 116ab9: 51 push %ecx 116aba: 51 push %ecx 116abb: 6a 08 push $0x8 116abd: ff 33 pushl (%ebx) 116abf: e8 7c 32 00 00 call 119d40 <_Thread_Set_state> _Timer_server_Reset_interval_system_watchdog( ts ); 116ac4: 89 d8 mov %ebx,%eax 116ac6: e8 21 fe ff ff call 1168ec <_Timer_server_Reset_interval_system_watchdog> _Timer_server_Reset_tod_system_watchdog( ts ); 116acb: 89 d8 mov %ebx,%eax 116acd: e8 60 fe ff ff call 116932 <_Timer_server_Reset_tod_system_watchdog> _Thread_Enable_dispatch(); 116ad2: e8 f7 29 00 00 call 1194ce <_Thread_Enable_dispatch> ts->active = true; 116ad7: 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 ); 116adb: 8d 43 08 lea 0x8(%ebx),%eax 116ade: 89 04 24 mov %eax,(%esp) 116ae1: e8 1e 3a 00 00 call 11a504 <_Watchdog_Remove> static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 116ae6: 8d 43 40 lea 0x40(%ebx),%eax 116ae9: 89 04 24 mov %eax,(%esp) 116aec: e8 13 3a 00 00 call 11a504 <_Watchdog_Remove> 116af1: 83 c4 10 add $0x10,%esp 116af4: e9 bd fe ff ff jmp 1169b6 <_Timer_server_Body+0x3e> =============================================================================== 00116af9 <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 116af9: 55 push %ebp 116afa: 89 e5 mov %esp,%ebp 116afc: 57 push %edi 116afd: 56 push %esi 116afe: 53 push %ebx 116aff: 83 ec 2c sub $0x2c,%esp 116b02: 8b 5d 08 mov 0x8(%ebp),%ebx 116b05: 8b 75 0c mov 0xc(%ebp),%esi if ( ts->insert_chain == NULL ) { 116b08: 8b 43 78 mov 0x78(%ebx),%eax 116b0b: 85 c0 test %eax,%eax 116b0d: 0f 85 de 00 00 00 jne 116bf1 <_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(); 116b13: e8 c4 fd ff ff call 1168dc <_Thread_Disable_dispatch> if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 116b18: 8b 46 38 mov 0x38(%esi),%eax 116b1b: 83 f8 01 cmp $0x1,%eax 116b1e: 75 5a jne 116b7a <_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 ); 116b20: 9c pushf 116b21: fa cli 116b22: 8f 45 e0 popl -0x20(%ebp) snapshot = _Watchdog_Ticks_since_boot; 116b25: 8b 15 c8 f0 13 00 mov 0x13f0c8,%edx last_snapshot = ts->Interval_watchdogs.last_snapshot; 116b2b: 8b 4b 3c mov 0x3c(%ebx),%ecx initialized = false; } #endif return status; } 116b2e: 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 ); 116b31: 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 ) ) { 116b34: 39 f8 cmp %edi,%eax 116b36: 74 19 je 116b51 <_Timer_server_Schedule_operation_method+0x58> first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain ); /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; 116b38: 89 d7 mov %edx,%edi 116b3a: 29 cf sub %ecx,%edi 116b3c: 89 7d e4 mov %edi,-0x1c(%ebp) delta_interval = first_watchdog->delta_interval; 116b3f: 8b 78 10 mov 0x10(%eax),%edi if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 116b42: 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) { 116b44: 3b 7d e4 cmp -0x1c(%ebp),%edi 116b47: 76 05 jbe 116b4e <_Timer_server_Schedule_operation_method+0x55> delta_interval -= delta; 116b49: 89 f9 mov %edi,%ecx 116b4b: 2b 4d e4 sub -0x1c(%ebp),%ecx } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 116b4e: 89 48 10 mov %ecx,0x10(%eax) } ts->Interval_watchdogs.last_snapshot = snapshot; 116b51: 89 53 3c mov %edx,0x3c(%ebx) _ISR_Enable( level ); 116b54: ff 75 e0 pushl -0x20(%ebp) 116b57: 9d popf _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116b58: 50 push %eax 116b59: 50 push %eax 116b5a: 83 c6 10 add $0x10,%esi 116b5d: 56 push %esi 116b5e: 8d 43 30 lea 0x30(%ebx),%eax 116b61: 50 push %eax 116b62: e8 7d 38 00 00 call 11a3e4 <_Watchdog_Insert> if ( !ts->active ) { 116b67: 8a 43 7c mov 0x7c(%ebx),%al 116b6a: 83 c4 10 add $0x10,%esp 116b6d: 84 c0 test %al,%al 116b6f: 75 74 jne 116be5 <_Timer_server_Schedule_operation_method+0xec> _Timer_server_Reset_interval_system_watchdog( ts ); 116b71: 89 d8 mov %ebx,%eax 116b73: e8 74 fd ff ff call 1168ec <_Timer_server_Reset_interval_system_watchdog> 116b78: eb 6b jmp 116be5 <_Timer_server_Schedule_operation_method+0xec> } } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116b7a: 83 f8 03 cmp $0x3,%eax 116b7d: 75 66 jne 116be5 <_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 ); 116b7f: 9c pushf 116b80: fa cli 116b81: 8f 45 e0 popl -0x20(%ebp) snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 116b84: 8b 15 40 f0 13 00 mov 0x13f040,%edx last_snapshot = ts->TOD_watchdogs.last_snapshot; 116b8a: 8b 43 74 mov 0x74(%ebx),%eax initialized = false; } #endif return status; } 116b8d: 8b 4b 68 mov 0x68(%ebx),%ecx 116b90: 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 ) ) { 116b93: 39 f9 cmp %edi,%ecx 116b95: 74 27 je 116bbe <_Timer_server_Schedule_operation_method+0xc5> first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 116b97: 8b 79 10 mov 0x10(%ecx),%edi 116b9a: 89 7d d4 mov %edi,-0x2c(%ebp) if ( snapshot > last_snapshot ) { 116b9d: 39 c2 cmp %eax,%edx 116b9f: 76 15 jbe 116bb6 <_Timer_server_Schedule_operation_method+0xbd> /* * We advanced in time. */ delta = snapshot - last_snapshot; 116ba1: 89 d7 mov %edx,%edi 116ba3: 29 c7 sub %eax,%edi 116ba5: 89 7d e4 mov %edi,-0x1c(%ebp) if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 116ba8: 31 c0 xor %eax,%eax if ( snapshot > last_snapshot ) { /* * We advanced in time. */ delta = snapshot - last_snapshot; if (delta_interval > delta) { 116baa: 39 7d d4 cmp %edi,-0x2c(%ebp) 116bad: 76 0c jbe 116bbb <_Timer_server_Schedule_operation_method+0xc2><== NEVER TAKEN delta_interval -= delta; 116baf: 8b 45 d4 mov -0x2c(%ebp),%eax 116bb2: 29 f8 sub %edi,%eax 116bb4: eb 05 jmp 116bbb <_Timer_server_Schedule_operation_method+0xc2> } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 116bb6: 03 45 d4 add -0x2c(%ebp),%eax delta_interval += delta; 116bb9: 29 d0 sub %edx,%eax } first_watchdog->delta_interval = delta_interval; 116bbb: 89 41 10 mov %eax,0x10(%ecx) } ts->TOD_watchdogs.last_snapshot = snapshot; 116bbe: 89 53 74 mov %edx,0x74(%ebx) _ISR_Enable( level ); 116bc1: ff 75 e0 pushl -0x20(%ebp) 116bc4: 9d popf _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116bc5: 57 push %edi 116bc6: 57 push %edi 116bc7: 83 c6 10 add $0x10,%esi 116bca: 56 push %esi 116bcb: 8d 43 68 lea 0x68(%ebx),%eax 116bce: 50 push %eax 116bcf: e8 10 38 00 00 call 11a3e4 <_Watchdog_Insert> if ( !ts->active ) { 116bd4: 8a 43 7c mov 0x7c(%ebx),%al 116bd7: 83 c4 10 add $0x10,%esp 116bda: 84 c0 test %al,%al 116bdc: 75 07 jne 116be5 <_Timer_server_Schedule_operation_method+0xec> _Timer_server_Reset_tod_system_watchdog( ts ); 116bde: 89 d8 mov %ebx,%eax 116be0: e8 4d fd ff ff call 116932 <_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 ); } } 116be5: 8d 65 f4 lea -0xc(%ebp),%esp 116be8: 5b pop %ebx 116be9: 5e pop %esi 116bea: 5f pop %edi 116beb: c9 leave if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 116bec: e9 dd 28 00 00 jmp 1194ce <_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 ); 116bf1: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 116bf4: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 116bf7: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } } 116bfa: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116bfd: 5b pop %ebx <== NOT EXECUTED 116bfe: 5e pop %esi <== NOT EXECUTED 116bff: 5f pop %edi <== NOT EXECUTED 116c00: 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 ); 116c01: e9 ce 06 00 00 jmp 1172d4 <_Chain_Append> <== NOT EXECUTED =============================================================================== 0010cc5b <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10cc5b: 55 push %ebp 10cc5c: 89 e5 mov %esp,%ebp 10cc5e: 57 push %edi 10cc5f: 56 push %esi 10cc60: 53 push %ebx 10cc61: 83 ec 0c sub $0xc,%esp 10cc64: 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 ); } } 10cc67: 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 ); 10cc6d: 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 ); 10cc71: eb 15 jmp 10cc88 <_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 ) 10cc73: 8b 43 30 mov 0x30(%ebx),%eax 10cc76: 85 c0 test %eax,%eax 10cc78: 74 0b je 10cc85 <_User_extensions_Fatal+0x2a> (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10cc7a: 52 push %edx 10cc7b: 57 push %edi 10cc7c: 56 push %esi 10cc7d: ff 75 08 pushl 0x8(%ebp) 10cc80: ff d0 call *%eax 10cc82: 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 ) { 10cc85: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _Chain_Last( &_User_extensions_List ); 10cc88: 81 fb 0c 55 12 00 cmp $0x12550c,%ebx 10cc8e: 75 e3 jne 10cc73 <_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 ); } } 10cc90: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cc93: 5b pop %ebx <== NOT EXECUTED 10cc94: 5e pop %esi <== NOT EXECUTED 10cc95: 5f pop %edi <== NOT EXECUTED 10cc96: c9 leave <== NOT EXECUTED 10cc97: c3 ret <== NOT EXECUTED =============================================================================== 0010cb44 <_User_extensions_Handler_initialization>: #include #include #include void _User_extensions_Handler_initialization(void) { 10cb44: 55 push %ebp 10cb45: 89 e5 mov %esp,%ebp 10cb47: 57 push %edi 10cb48: 56 push %esi 10cb49: 53 push %ebx 10cb4a: 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; 10cb4d: a1 34 12 12 00 mov 0x121234,%eax 10cb52: 89 45 e4 mov %eax,-0x1c(%ebp) initial_extensions = Configuration.User_extension_table; 10cb55: 8b 35 38 12 12 00 mov 0x121238,%esi ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10cb5b: c7 05 0c 55 12 00 10 movl $0x125510,0x12550c 10cb62: 55 12 00 head->previous = NULL; 10cb65: c7 05 10 55 12 00 00 movl $0x0,0x125510 10cb6c: 00 00 00 tail->previous = head; 10cb6f: c7 05 14 55 12 00 0c movl $0x12550c,0x125514 10cb76: 55 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10cb79: c7 05 24 53 12 00 28 movl $0x125328,0x125324 10cb80: 53 12 00 head->previous = NULL; 10cb83: c7 05 28 53 12 00 00 movl $0x0,0x125328 10cb8a: 00 00 00 tail->previous = head; 10cb8d: c7 05 2c 53 12 00 24 movl $0x125324,0x12532c 10cb94: 53 12 00 _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10cb97: 85 f6 test %esi,%esi 10cb99: 74 53 je 10cbee <_User_extensions_Handler_initialization+0xaa><== NEVER TAKEN extension = (User_extensions_Control *) _Workspace_Allocate_or_fatal_error( 10cb9b: 6b c8 34 imul $0x34,%eax,%ecx 10cb9e: 83 ec 0c sub $0xc,%esp 10cba1: 51 push %ecx 10cba2: 89 4d e0 mov %ecx,-0x20(%ebp) 10cba5: e8 3a 04 00 00 call 10cfe4 <_Workspace_Allocate_or_fatal_error> 10cbaa: 89 c3 mov %eax,%ebx number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10cbac: 31 c0 xor %eax,%eax 10cbae: 8b 4d e0 mov -0x20(%ebp),%ecx 10cbb1: 89 df mov %ebx,%edi 10cbb3: f3 aa rep stos %al,%es:(%edi) 10cbb5: 89 f0 mov %esi,%eax extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10cbb7: 83 c4 10 add $0x10,%esp 10cbba: 31 d2 xor %edx,%edx 10cbbc: eb 2b jmp 10cbe9 <_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; 10cbbe: 8d 7b 14 lea 0x14(%ebx),%edi 10cbc1: 89 c6 mov %eax,%esi 10cbc3: b9 08 00 00 00 mov $0x8,%ecx 10cbc8: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _User_extensions_Add_set( extension ); 10cbca: 83 ec 0c sub $0xc,%esp 10cbcd: 53 push %ebx 10cbce: 89 45 dc mov %eax,-0x24(%ebp) 10cbd1: 89 55 e0 mov %edx,-0x20(%ebp) 10cbd4: e8 ef 2f 00 00 call 10fbc8 <_User_extensions_Add_set> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; 10cbd9: 83 c3 34 add $0x34,%ebx extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10cbdc: 8b 55 e0 mov -0x20(%ebp),%edx 10cbdf: 42 inc %edx 10cbe0: 8b 45 dc mov -0x24(%ebp),%eax 10cbe3: 83 c0 20 add $0x20,%eax 10cbe6: 83 c4 10 add $0x10,%esp 10cbe9: 3b 55 e4 cmp -0x1c(%ebp),%edx 10cbec: 72 d0 jb 10cbbe <_User_extensions_Handler_initialization+0x7a> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; } } } 10cbee: 8d 65 f4 lea -0xc(%ebp),%esp 10cbf1: 5b pop %ebx 10cbf2: 5e pop %esi 10cbf3: 5f pop %edi 10cbf4: c9 leave 10cbf5: c3 ret =============================================================================== 0010e4a4 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10e4a4: 55 push %ebp 10e4a5: 89 e5 mov %esp,%ebp 10e4a7: 57 push %edi 10e4a8: 56 push %esi 10e4a9: 53 push %ebx 10e4aa: 83 ec 1c sub $0x1c,%esp 10e4ad: 8b 75 08 mov 0x8(%ebp),%esi 10e4b0: 8b 7d 0c mov 0xc(%ebp),%edi 10e4b3: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 10e4b6: 9c pushf 10e4b7: fa cli 10e4b8: 58 pop %eax } } _ISR_Enable( level ); } 10e4b9: 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 ); 10e4bb: 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 ) ) { 10e4be: 39 ca cmp %ecx,%edx 10e4c0: 74 44 je 10e506 <_Watchdog_Adjust+0x62> switch ( direction ) { 10e4c2: 85 ff test %edi,%edi 10e4c4: 74 3c je 10e502 <_Watchdog_Adjust+0x5e> 10e4c6: 4f dec %edi 10e4c7: 75 3d jne 10e506 <_Watchdog_Adjust+0x62> <== NEVER TAKEN case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10e4c9: 01 5a 10 add %ebx,0x10(%edx) break; 10e4cc: eb 38 jmp 10e506 <_Watchdog_Adjust+0x62> RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First( Chain_Control *header ) { return ( (Watchdog_Control *) _Chain_First( header ) ); 10e4ce: 8b 16 mov (%esi),%edx case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 10e4d0: 8b 7a 10 mov 0x10(%edx),%edi 10e4d3: 39 fb cmp %edi,%ebx 10e4d5: 73 07 jae 10e4de <_Watchdog_Adjust+0x3a> _Watchdog_First( header )->delta_interval -= units; 10e4d7: 29 df sub %ebx,%edi 10e4d9: 89 7a 10 mov %edi,0x10(%edx) break; 10e4dc: eb 28 jmp 10e506 <_Watchdog_Adjust+0x62> } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 10e4de: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx) _ISR_Enable( level ); 10e4e5: 50 push %eax 10e4e6: 9d popf _Watchdog_Tickle( header ); 10e4e7: 83 ec 0c sub $0xc,%esp 10e4ea: 56 push %esi 10e4eb: 89 4d e4 mov %ecx,-0x1c(%ebp) 10e4ee: e8 a5 01 00 00 call 10e698 <_Watchdog_Tickle> _ISR_Disable( level ); 10e4f3: 9c pushf 10e4f4: fa cli 10e4f5: 58 pop %eax if ( _Chain_Is_empty( header ) ) 10e4f6: 83 c4 10 add $0x10,%esp 10e4f9: 8b 4d e4 mov -0x1c(%ebp),%ecx 10e4fc: 39 0e cmp %ecx,(%esi) 10e4fe: 74 06 je 10e506 <_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; 10e500: 29 fb sub %edi,%ebx switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10e502: 85 db test %ebx,%ebx 10e504: 75 c8 jne 10e4ce <_Watchdog_Adjust+0x2a> <== ALWAYS TAKEN } break; } } _ISR_Enable( level ); 10e506: 50 push %eax 10e507: 9d popf } 10e508: 8d 65 f4 lea -0xc(%ebp),%esp 10e50b: 5b pop %ebx 10e50c: 5e pop %esi 10e50d: 5f pop %edi 10e50e: c9 leave 10e50f: c3 ret =============================================================================== 0010ce9c <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10ce9c: 55 push %ebp 10ce9d: 89 e5 mov %esp,%ebp 10ce9f: 56 push %esi 10cea0: 53 push %ebx 10cea1: 8b 55 08 mov 0x8(%ebp),%edx ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10cea4: 9c pushf 10cea5: fa cli 10cea6: 5e pop %esi previous_state = the_watchdog->state; 10cea7: 8b 42 08 mov 0x8(%edx),%eax switch ( previous_state ) { 10ceaa: 83 f8 01 cmp $0x1,%eax 10cead: 74 09 je 10ceb8 <_Watchdog_Remove+0x1c> 10ceaf: 72 42 jb 10cef3 <_Watchdog_Remove+0x57> 10ceb1: 83 f8 03 cmp $0x3,%eax 10ceb4: 77 3d ja 10cef3 <_Watchdog_Remove+0x57> <== NEVER TAKEN 10ceb6: eb 09 jmp 10cec1 <_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; 10ceb8: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) break; 10cebf: eb 32 jmp 10cef3 <_Watchdog_Remove+0x57> case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10cec1: 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 ); } 10cec8: 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) ) 10ceca: 83 39 00 cmpl $0x0,(%ecx) 10cecd: 74 06 je 10ced5 <_Watchdog_Remove+0x39> next_watchdog->delta_interval += the_watchdog->delta_interval; 10cecf: 8b 5a 10 mov 0x10(%edx),%ebx 10ced2: 01 59 10 add %ebx,0x10(%ecx) if ( _Watchdog_Sync_count ) 10ced5: 8b 1d 50 54 12 00 mov 0x125450,%ebx 10cedb: 85 db test %ebx,%ebx 10cedd: 74 0c je 10ceeb <_Watchdog_Remove+0x4f> _Watchdog_Sync_level = _ISR_Nest_level; 10cedf: 8b 1d 64 58 12 00 mov 0x125864,%ebx 10cee5: 89 1d e8 53 12 00 mov %ebx,0x1253e8 { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 10ceeb: 8b 5a 04 mov 0x4(%edx),%ebx next->previous = previous; 10ceee: 89 59 04 mov %ebx,0x4(%ecx) previous->next = next; 10cef1: 89 0b mov %ecx,(%ebx) _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10cef3: 8b 0d 54 54 12 00 mov 0x125454,%ecx 10cef9: 89 4a 18 mov %ecx,0x18(%edx) _ISR_Enable( level ); 10cefc: 56 push %esi 10cefd: 9d popf return( previous_state ); } 10cefe: 5b pop %ebx 10ceff: 5e pop %esi 10cf00: c9 leave 10cf01: c3 ret =============================================================================== 0010e030 <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) { 10e030: 55 push %ebp 10e031: 89 e5 mov %esp,%ebp 10e033: 57 push %edi 10e034: 56 push %esi 10e035: 53 push %ebx 10e036: 83 ec 20 sub $0x20,%esp 10e039: 8b 7d 08 mov 0x8(%ebp),%edi 10e03c: 8b 75 0c mov 0xc(%ebp),%esi ISR_Level level; Chain_Node *node; _ISR_Disable( level ); 10e03f: 9c pushf 10e040: fa cli 10e041: 8f 45 e4 popl -0x1c(%ebp) printk( "Watchdog Chain: %s %p\n", name, header ); 10e044: 56 push %esi 10e045: 57 push %edi 10e046: 68 88 18 12 00 push $0x121888 10e04b: e8 88 aa ff ff call 108ad8 printk( "== end of %s \n", name ); } else { printk( "Chain is empty\n" ); } _ISR_Enable( level ); } 10e050: 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 ); 10e052: 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 ) ) { 10e055: 83 c4 10 add $0x10,%esp 10e058: 39 f3 cmp %esi,%ebx 10e05a: 74 1d je 10e079 <_Watchdog_Report_chain+0x49> node != _Chain_Tail(header) ; node = node->next ) { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); 10e05c: 52 push %edx 10e05d: 52 push %edx 10e05e: 53 push %ebx 10e05f: 6a 00 push $0x0 10e061: e8 32 00 00 00 call 10e098 <_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 ) 10e066: 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 ) ; 10e068: 83 c4 10 add $0x10,%esp 10e06b: 39 f3 cmp %esi,%ebx 10e06d: 75 ed jne 10e05c <_Watchdog_Report_chain+0x2c><== NEVER TAKEN { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); 10e06f: 50 push %eax 10e070: 50 push %eax 10e071: 57 push %edi 10e072: 68 9f 18 12 00 push $0x12189f 10e077: eb 08 jmp 10e081 <_Watchdog_Report_chain+0x51> } else { printk( "Chain is empty\n" ); 10e079: 83 ec 0c sub $0xc,%esp 10e07c: 68 ae 18 12 00 push $0x1218ae 10e081: e8 52 aa ff ff call 108ad8 10e086: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10e089: ff 75 e4 pushl -0x1c(%ebp) 10e08c: 9d popf } 10e08d: 8d 65 f4 lea -0xc(%ebp),%esp 10e090: 5b pop %ebx 10e091: 5e pop %esi 10e092: 5f pop %edi 10e093: c9 leave 10e094: c3 ret =============================================================================== 0010cf04 <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10cf04: 55 push %ebp 10cf05: 89 e5 mov %esp,%ebp 10cf07: 57 push %edi 10cf08: 56 push %esi 10cf09: 53 push %ebx 10cf0a: 83 ec 1c sub $0x1c,%esp 10cf0d: 8b 7d 08 mov 0x8(%ebp),%edi * See the comment in watchdoginsert.c and watchdogadjust.c * about why it's safe not to declare header a pointer to * volatile data - till, 2003/7 */ _ISR_Disable( level ); 10cf10: 9c pushf 10cf11: fa cli 10cf12: 5e pop %esi } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); } 10cf13: 8b 1f mov (%edi),%ebx RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( const Chain_Control *the_chain ) { return _Chain_Immutable_first( the_chain ) == _Chain_Immutable_tail( the_chain ); 10cf15: 8d 47 04 lea 0x4(%edi),%eax 10cf18: 89 45 e4 mov %eax,-0x1c(%ebp) * volatile data - till, 2003/7 */ _ISR_Disable( level ); if ( _Chain_Is_empty( header ) ) 10cf1b: 39 c3 cmp %eax,%ebx 10cf1d: 74 40 je 10cf5f <_Watchdog_Tickle+0x5b> * to be inserted has already had its delta_interval adjusted to 0, and * so is added to the head of the chain with a delta_interval of 0. * * Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc) */ if (the_watchdog->delta_interval != 0) { 10cf1f: 8b 43 10 mov 0x10(%ebx),%eax 10cf22: 85 c0 test %eax,%eax 10cf24: 74 08 je 10cf2e <_Watchdog_Tickle+0x2a> the_watchdog->delta_interval--; 10cf26: 48 dec %eax 10cf27: 89 43 10 mov %eax,0x10(%ebx) if ( the_watchdog->delta_interval != 0 ) 10cf2a: 85 c0 test %eax,%eax 10cf2c: 75 31 jne 10cf5f <_Watchdog_Tickle+0x5b> goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10cf2e: 83 ec 0c sub $0xc,%esp 10cf31: 53 push %ebx 10cf32: e8 65 ff ff ff call 10ce9c <_Watchdog_Remove> _ISR_Enable( level ); 10cf37: 56 push %esi 10cf38: 9d popf switch( watchdog_state ) { 10cf39: 83 c4 10 add $0x10,%esp 10cf3c: 83 f8 02 cmp $0x2,%eax 10cf3f: 75 0e jne 10cf4f <_Watchdog_Tickle+0x4b> <== NEVER TAKEN case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10cf41: 50 push %eax 10cf42: 50 push %eax 10cf43: ff 73 24 pushl 0x24(%ebx) 10cf46: ff 73 20 pushl 0x20(%ebx) 10cf49: ff 53 1c call *0x1c(%ebx) the_watchdog->id, the_watchdog->user_data ); break; 10cf4c: 83 c4 10 add $0x10,%esp case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10cf4f: 9c pushf 10cf50: fa cli 10cf51: 5e pop %esi } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); } 10cf52: 8b 1f mov (%edi),%ebx _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10cf54: 3b 5d e4 cmp -0x1c(%ebp),%ebx 10cf57: 74 06 je 10cf5f <_Watchdog_Tickle+0x5b> } _ISR_Disable( level ); the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && 10cf59: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10cf5d: eb cd jmp 10cf2c <_Watchdog_Tickle+0x28> (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); 10cf5f: 56 push %esi 10cf60: 9d popf } 10cf61: 8d 65 f4 lea -0xc(%ebp),%esp 10cf64: 5b pop %ebx 10cf65: 5e pop %esi 10cf66: 5f pop %edi 10cf67: c9 leave 10cf68: c3 ret =============================================================================== 0010b1c8 <_rename_r>: int _rename_r( struct _reent *ptr __attribute__((unused)), const char *old, const char *new ) { 10b1c8: 55 push %ebp 10b1c9: 89 e5 mov %esp,%ebp 10b1cb: 57 push %edi 10b1cc: 56 push %esi 10b1cd: 53 push %ebx 10b1ce: 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 ); 10b1d1: ff 75 0c pushl 0xc(%ebp) 10b1d4: e8 5e ed ff ff call 109f37 10b1d9: 89 45 94 mov %eax,-0x6c(%ebp) if ( old_parent_pathlen == 0 ) 10b1dc: 83 c4 10 add $0x10,%esp 10b1df: 85 c0 test %eax,%eax 10b1e1: 8d 45 b8 lea -0x48(%ebp),%eax 10b1e4: 75 15 jne 10b1fb <_rename_r+0x33> rtems_filesystem_get_start_loc( old, &i, &old_parent_loc ); 10b1e6: 51 push %ecx 10b1e7: 50 push %eax 10b1e8: 8d 45 e4 lea -0x1c(%ebp),%eax 10b1eb: 50 push %eax 10b1ec: ff 75 0c pushl 0xc(%ebp) 10b1ef: e8 48 03 00 00 call 10b53c 10b1f4: 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; 10b1f7: 31 db xor %ebx,%ebx 10b1f9: eb 23 jmp 10b21e <_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, 10b1fb: 83 ec 0c sub $0xc,%esp 10b1fe: 6a 00 push $0x0 10b200: 50 push %eax 10b201: 6a 02 push $0x2 10b203: ff 75 94 pushl -0x6c(%ebp) 10b206: ff 75 0c pushl 0xc(%ebp) 10b209: e8 e8 ec ff ff call 109ef6 RTEMS_LIBIO_PERMS_WRITE, &old_parent_loc, false ); if ( result != 0 ) 10b20e: 83 c4 20 add $0x20,%esp return -1; 10b211: 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 ) 10b214: 85 c0 test %eax,%eax 10b216: 0f 85 50 01 00 00 jne 10b36c <_rename_r+0x1a4> <== NEVER TAKEN return -1; free_old_parentloc = true; 10b21c: b3 01 mov $0x1,%bl /* * Start from the parent to find the node that should be under it. */ old_loc = old_parent_loc; 10b21e: 8d 7d cc lea -0x34(%ebp),%edi 10b221: 8d 75 b8 lea -0x48(%ebp),%esi 10b224: b9 05 00 00 00 mov $0x5,%ecx 10b229: f3 a5 rep movsl %ds:(%esi),%es:(%edi) name = old + old_parent_pathlen; 10b22b: 8b 75 0c mov 0xc(%ebp),%esi 10b22e: 03 75 94 add -0x6c(%ebp),%esi 10b231: 89 75 e0 mov %esi,-0x20(%ebp) name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 10b234: 83 c9 ff or $0xffffffff,%ecx 10b237: 89 f7 mov %esi,%edi 10b239: 31 c0 xor %eax,%eax 10b23b: f2 ae repnz scas %es:(%edi),%al 10b23d: f7 d1 not %ecx 10b23f: 49 dec %ecx 10b240: 52 push %edx 10b241: 52 push %edx 10b242: 51 push %ecx 10b243: 56 push %esi 10b244: e8 2d ed ff ff call 109f76 10b249: 01 c6 add %eax,%esi 10b24b: 89 75 e0 mov %esi,-0x20(%ebp) result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 10b24e: 83 c9 ff or $0xffffffff,%ecx 10b251: 89 f7 mov %esi,%edi 10b253: 31 c0 xor %eax,%eax 10b255: f2 ae repnz scas %es:(%edi),%al 10b257: f7 d1 not %ecx 10b259: 49 dec %ecx 10b25a: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10b261: 8d 7d cc lea -0x34(%ebp),%edi 10b264: 57 push %edi 10b265: 6a 00 push $0x0 10b267: 51 push %ecx 10b268: 56 push %esi 10b269: e8 2a ec ff ff call 109e98 0, &old_loc, false ); if ( result != 0 ) { 10b26e: 83 c4 20 add $0x20,%esp 10b271: 85 c0 test %eax,%eax 10b273: 74 16 je 10b28b <_rename_r+0xc3> if ( free_old_parentloc ) rtems_filesystem_freenode( &old_parent_loc ); return -1; 10b275: 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 ) 10b278: 84 db test %bl,%bl 10b27a: 0f 84 ec 00 00 00 je 10b36c <_rename_r+0x1a4> <== NEVER TAKEN rtems_filesystem_freenode( &old_parent_loc ); 10b280: 83 ec 0c sub $0xc,%esp 10b283: 8d 45 b8 lea -0x48(%ebp),%eax 10b286: e9 d8 00 00 00 jmp 10b363 <_rename_r+0x19b> /* * Get the parent of the new node we are renaming to. */ rtems_filesystem_get_start_loc( new, &i, &new_parent_loc ); 10b28b: 50 push %eax 10b28c: 8d 75 a4 lea -0x5c(%ebp),%esi 10b28f: 56 push %esi 10b290: 8d 45 e4 lea -0x1c(%ebp),%eax 10b293: 50 push %eax 10b294: ff 75 10 pushl 0x10(%ebp) 10b297: e8 a0 02 00 00 call 10b53c result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name ); 10b29c: 83 c4 0c add $0xc,%esp 10b29f: 8d 45 e0 lea -0x20(%ebp),%eax 10b2a2: 50 push %eax 10b2a3: 56 push %esi 10b2a4: 8b 45 10 mov 0x10(%ebp),%eax 10b2a7: 03 45 e4 add -0x1c(%ebp),%eax 10b2aa: 50 push %eax 10b2ab: 8b 45 b0 mov -0x50(%ebp),%eax 10b2ae: ff 50 04 call *0x4(%eax) if ( result != 0 ) { 10b2b1: 83 c4 10 add $0x10,%esp 10b2b4: 85 c0 test %eax,%eax 10b2b6: 74 2d je 10b2e5 <_rename_r+0x11d> rtems_filesystem_freenode( &new_parent_loc ); 10b2b8: 83 ec 0c sub $0xc,%esp 10b2bb: 56 push %esi 10b2bc: e8 43 ee ff ff call 10a104 if ( free_old_parentloc ) 10b2c1: 83 c4 10 add $0x10,%esp 10b2c4: 84 db test %bl,%bl 10b2c6: 74 0f je 10b2d7 <_rename_r+0x10f> <== NEVER TAKEN rtems_filesystem_freenode( &old_parent_loc ); 10b2c8: 83 ec 0c sub $0xc,%esp 10b2cb: 8d 45 b8 lea -0x48(%ebp),%eax 10b2ce: 50 push %eax 10b2cf: e8 30 ee ff ff call 10a104 10b2d4: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &old_loc ); 10b2d7: 83 ec 0c sub $0xc,%esp 10b2da: 8d 45 cc lea -0x34(%ebp),%eax 10b2dd: 50 push %eax 10b2de: e8 21 ee ff ff call 10a104 10b2e3: eb 3e jmp 10b323 <_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 ) { 10b2e5: 8b 45 b4 mov -0x4c(%ebp),%eax 10b2e8: 39 45 c8 cmp %eax,-0x38(%ebp) 10b2eb: 74 3e je 10b32b <_rename_r+0x163> rtems_filesystem_freenode( &new_parent_loc ); 10b2ed: 83 ec 0c sub $0xc,%esp 10b2f0: 56 push %esi 10b2f1: e8 0e ee ff ff call 10a104 if ( free_old_parentloc ) 10b2f6: 83 c4 10 add $0x10,%esp 10b2f9: 84 db test %bl,%bl 10b2fb: 74 0f je 10b30c <_rename_r+0x144> rtems_filesystem_freenode( &old_parent_loc ); 10b2fd: 83 ec 0c sub $0xc,%esp 10b300: 8d 45 b8 lea -0x48(%ebp),%eax 10b303: 50 push %eax 10b304: e8 fb ed ff ff call 10a104 10b309: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &old_loc ); 10b30c: 83 ec 0c sub $0xc,%esp 10b30f: 8d 45 cc lea -0x34(%ebp),%eax 10b312: 50 push %eax 10b313: e8 ec ed ff ff call 10a104 rtems_set_errno_and_return_minus_one( EXDEV ); 10b318: e8 c7 95 00 00 call 1148e4 <__errno> 10b31d: c7 00 12 00 00 00 movl $0x12,(%eax) 10b323: 83 c4 10 add $0x10,%esp 10b326: 83 cf ff or $0xffffffff,%edi 10b329: eb 41 jmp 10b36c <_rename_r+0x1a4> } result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name ); 10b32b: ff 75 e0 pushl -0x20(%ebp) 10b32e: 56 push %esi 10b32f: 57 push %edi 10b330: 8d 55 b8 lea -0x48(%ebp),%edx 10b333: 52 push %edx 10b334: 8b 45 b0 mov -0x50(%ebp),%eax 10b337: 89 55 90 mov %edx,-0x70(%ebp) 10b33a: ff 50 40 call *0x40(%eax) 10b33d: 89 c7 mov %eax,%edi rtems_filesystem_freenode( &new_parent_loc ); 10b33f: 89 34 24 mov %esi,(%esp) 10b342: e8 bd ed ff ff call 10a104 if ( free_old_parentloc ) 10b347: 83 c4 10 add $0x10,%esp 10b34a: 84 db test %bl,%bl 10b34c: 8b 55 90 mov -0x70(%ebp),%edx 10b34f: 74 0c je 10b35d <_rename_r+0x195> rtems_filesystem_freenode( &old_parent_loc ); 10b351: 83 ec 0c sub $0xc,%esp 10b354: 52 push %edx 10b355: e8 aa ed ff ff call 10a104 10b35a: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &old_loc ); 10b35d: 83 ec 0c sub $0xc,%esp 10b360: 8d 45 cc lea -0x34(%ebp),%eax 10b363: 50 push %eax 10b364: e8 9b ed ff ff call 10a104 return result; 10b369: 83 c4 10 add $0x10,%esp } 10b36c: 89 f8 mov %edi,%eax 10b36e: 8d 65 f4 lea -0xc(%ebp),%esp 10b371: 5b pop %ebx 10b372: 5e pop %esi 10b373: 5f pop %edi 10b374: c9 leave 10b375: c3 ret =============================================================================== 0010a7b4 : * operation(s) cannot be canceled */ int aio_cancel(int fildes, struct aiocb *aiocbp) { 10a7b4: 55 push %ebp 10a7b5: 89 e5 mov %esp,%ebp 10a7b7: 57 push %edi 10a7b8: 56 push %esi 10a7b9: 53 push %ebx 10a7ba: 83 ec 18 sub $0x18,%esp 10a7bd: 8b 75 08 mov 0x8(%ebp),%esi 10a7c0: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request_chain *r_chain; int result; pthread_mutex_lock (&aio_request_queue.mutex); 10a7c3: 68 b8 72 12 00 push $0x1272b8 10a7c8: e8 2f 10 00 00 call 10b7fc if (fcntl (fildes, F_GETFD) < 0) { 10a7cd: 5f pop %edi 10a7ce: 58 pop %eax 10a7cf: 6a 01 push $0x1 10a7d1: 56 push %esi 10a7d2: e8 b5 60 00 00 call 11088c 10a7d7: 83 c4 10 add $0x10,%esp 10a7da: 85 c0 test %eax,%eax 10a7dc: 79 1d jns 10a7fb pthread_mutex_unlock(&aio_request_queue.mutex); 10a7de: 83 ec 0c sub $0xc,%esp 10a7e1: 68 b8 72 12 00 push $0x1272b8 10a7e6: e8 91 10 00 00 call 10b87c rtems_set_errno_and_return_minus_one (EBADF); 10a7eb: e8 0c 8f 00 00 call 1136fc <__errno> 10a7f0: c7 00 09 00 00 00 movl $0x9,(%eax) 10a7f6: e9 e3 00 00 00 jmp 10a8de } /* if aiocbp is NULL remove all request for given file descriptor */ if (aiocbp == NULL) { 10a7fb: 85 db test %ebx,%ebx 10a7fd: 0f 85 bd 00 00 00 jne 10a8c0 AIO_printf ("Cancel all requests\n"); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); 10a803: 51 push %ecx 10a804: 6a 00 push $0x0 10a806: 56 push %esi 10a807: 68 00 73 12 00 push $0x127300 10a80c: e8 27 03 00 00 call 10ab38 10a811: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 10a813: 83 c4 10 add $0x10,%esp 10a816: 85 c0 test %eax,%eax 10a818: 75 6c jne 10a886 AIO_printf ("Request chain not on [WQ]\n"); if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10a81a: 81 3d 0c 73 12 00 10 cmpl $0x127310,0x12730c 10a821: 73 12 00 10a824: 0f 84 07 01 00 00 je 10a931 <== NEVER TAKEN r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 10a82a: 52 push %edx 10a82b: 6a 00 push $0x0 10a82d: 56 push %esi 10a82e: 68 0c 73 12 00 push $0x12730c 10a833: e8 00 03 00 00 call 10ab38 10a838: 89 c3 mov %eax,%ebx if (r_chain == NULL) { 10a83a: 83 c4 10 add $0x10,%esp 10a83d: 85 c0 test %eax,%eax 10a83f: 75 17 jne 10a858 pthread_mutex_unlock(&aio_request_queue.mutex); 10a841: 83 ec 0c sub $0xc,%esp 10a844: 68 b8 72 12 00 push $0x1272b8 10a849: e8 2e 10 00 00 call 10b87c return AIO_ALLDONE; 10a84e: 83 c4 10 add $0x10,%esp 10a851: b3 02 mov $0x2,%bl 10a853: e9 21 01 00 00 jmp 10a979 */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10a858: 83 ec 0c sub $0xc,%esp 10a85b: 50 push %eax 10a85c: e8 03 27 00 00 call 10cf64 <_Chain_Extract> } AIO_printf ("Request chain on [IQ]\n"); rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10a861: 89 1c 24 mov %ebx,(%esp) 10a864: e8 12 06 00 00 call 10ae7b pthread_mutex_destroy (&r_chain->mutex); 10a869: 8d 73 1c lea 0x1c(%ebx),%esi 10a86c: 89 34 24 mov %esi,(%esp) 10a86f: e8 68 0d 00 00 call 10b5dc pthread_cond_destroy (&r_chain->mutex); 10a874: 89 34 24 mov %esi,(%esp) 10a877: e8 6c 0a 00 00 call 10b2e8 free (r_chain); 10a87c: 89 1c 24 mov %ebx,(%esp) 10a87f: e8 ac d4 ff ff call 107d30 10a884: eb 24 jmp 10a8aa return AIO_ALLDONE; } AIO_printf ("Request chain on [WQ]\n"); pthread_mutex_lock (&r_chain->mutex); 10a886: 8d 70 1c lea 0x1c(%eax),%esi 10a889: 83 ec 0c sub $0xc,%esp 10a88c: 56 push %esi 10a88d: e8 6a 0f 00 00 call 10b7fc 10a892: 89 1c 24 mov %ebx,(%esp) 10a895: e8 ca 26 00 00 call 10cf64 <_Chain_Extract> rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10a89a: 89 1c 24 mov %ebx,(%esp) 10a89d: e8 d9 05 00 00 call 10ae7b pthread_mutex_unlock (&r_chain->mutex); 10a8a2: 89 34 24 mov %esi,(%esp) 10a8a5: e8 d2 0f 00 00 call 10b87c pthread_mutex_unlock (&aio_request_queue.mutex); 10a8aa: c7 04 24 b8 72 12 00 movl $0x1272b8,(%esp) 10a8b1: e8 c6 0f 00 00 call 10b87c return AIO_CANCELED; 10a8b6: 83 c4 10 add $0x10,%esp 10a8b9: 31 db xor %ebx,%ebx 10a8bb: e9 b9 00 00 00 jmp 10a979 } else { AIO_printf ("Cancel request\n"); if (aiocbp->aio_fildes != fildes) { 10a8c0: 8b 3b mov (%ebx),%edi 10a8c2: 39 f7 cmp %esi,%edi 10a8c4: 74 23 je 10a8e9 pthread_mutex_unlock (&aio_request_queue.mutex); 10a8c6: 83 ec 0c sub $0xc,%esp 10a8c9: 68 b8 72 12 00 push $0x1272b8 10a8ce: e8 a9 0f 00 00 call 10b87c rtems_set_errno_and_return_minus_one (EINVAL); 10a8d3: e8 24 8e 00 00 call 1136fc <__errno> 10a8d8: c7 00 16 00 00 00 movl $0x16,(%eax) 10a8de: 83 c4 10 add $0x10,%esp 10a8e1: 83 cb ff or $0xffffffff,%ebx 10a8e4: e9 90 00 00 00 jmp 10a979 } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0); 10a8e9: 50 push %eax 10a8ea: 6a 00 push $0x0 10a8ec: 57 push %edi 10a8ed: 68 00 73 12 00 push $0x127300 10a8f2: e8 41 02 00 00 call 10ab38 10a8f7: 89 c6 mov %eax,%esi if (r_chain == NULL) { 10a8f9: 83 c4 10 add $0x10,%esp 10a8fc: 85 c0 test %eax,%eax 10a8fe: 75 48 jne 10a948 if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10a900: 81 3d 0c 73 12 00 10 cmpl $0x127310,0x12730c 10a907: 73 12 00 10a90a: 74 25 je 10a931 <== NEVER TAKEN r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0); 10a90c: 56 push %esi 10a90d: 6a 00 push $0x0 10a90f: 57 push %edi 10a910: 68 0c 73 12 00 push $0x12730c 10a915: e8 1e 02 00 00 call 10ab38 if (r_chain == NULL) { 10a91a: 83 c4 10 add $0x10,%esp 10a91d: 85 c0 test %eax,%eax 10a91f: 74 a5 je 10a8c6 rtems_set_errno_and_return_minus_one (EINVAL); } AIO_printf ("Request on [IQ]\n"); result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 10a921: 51 push %ecx 10a922: 51 push %ecx 10a923: 53 push %ebx 10a924: 83 c0 08 add $0x8,%eax 10a927: 50 push %eax 10a928: e8 97 05 00 00 call 10aec4 10a92d: 89 c3 mov %eax,%ebx 10a92f: eb 39 jmp 10a96a pthread_mutex_unlock (&aio_request_queue.mutex); return result; } else { pthread_mutex_unlock (&aio_request_queue.mutex); 10a931: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a934: 68 b8 72 12 00 push $0x1272b8 <== NOT EXECUTED 10a939: e8 3e 0f 00 00 call 10b87c <== NOT EXECUTED return AIO_ALLDONE; 10a93e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a941: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED 10a946: eb 31 jmp 10a979 <== NOT EXECUTED } } AIO_printf ("Request on [WQ]\n"); pthread_mutex_lock (&r_chain->mutex); 10a948: 8d 78 1c lea 0x1c(%eax),%edi 10a94b: 83 ec 0c sub $0xc,%esp 10a94e: 57 push %edi 10a94f: e8 a8 0e 00 00 call 10b7fc result = rtems_aio_remove_req (&r_chain->perfd, aiocbp); 10a954: 58 pop %eax 10a955: 5a pop %edx 10a956: 53 push %ebx 10a957: 83 c6 08 add $0x8,%esi 10a95a: 56 push %esi 10a95b: e8 64 05 00 00 call 10aec4 10a960: 89 c3 mov %eax,%ebx pthread_mutex_unlock (&r_chain->mutex); 10a962: 89 3c 24 mov %edi,(%esp) 10a965: e8 12 0f 00 00 call 10b87c pthread_mutex_unlock (&aio_request_queue.mutex); 10a96a: c7 04 24 b8 72 12 00 movl $0x1272b8,(%esp) 10a971: e8 06 0f 00 00 call 10b87c return result; 10a976: 83 c4 10 add $0x10,%esp } return AIO_ALLDONE; } 10a979: 89 d8 mov %ebx,%eax 10a97b: 8d 65 f4 lea -0xc(%ebp),%esp 10a97e: 5b pop %ebx 10a97f: 5e pop %esi 10a980: 5f pop %edi 10a981: c9 leave 10a982: c3 ret =============================================================================== 0010a990 : int aio_fsync( int op, struct aiocb *aiocbp ) { 10a990: 55 push %ebp 10a991: 89 e5 mov %esp,%ebp 10a993: 53 push %ebx 10a994: 83 ec 04 sub $0x4,%esp 10a997: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request *req; int mode; if (op != O_SYNC) 10a99a: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp) 10a9a1: 74 1b je 10a9be rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10a9a3: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10a9aa: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a9b1: e8 46 8d 00 00 call 1136fc <__errno> 10a9b6: c7 00 16 00 00 00 movl $0x16,(%eax) 10a9bc: eb 74 jmp 10aa32 mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10a9be: 50 push %eax 10a9bf: 50 push %eax 10a9c0: 6a 03 push $0x3 10a9c2: ff 33 pushl (%ebx) 10a9c4: e8 c3 5e 00 00 call 11088c if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10a9c9: 83 e0 03 and $0x3,%eax 10a9cc: 48 dec %eax 10a9cd: 83 c4 10 add $0x10,%esp 10a9d0: 83 f8 01 cmp $0x1,%eax 10a9d3: 76 1b jbe 10a9f0 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10a9d5: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10a9dc: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a9e3: e8 14 8d 00 00 call 1136fc <__errno> 10a9e8: c7 00 09 00 00 00 movl $0x9,(%eax) 10a9ee: eb 42 jmp 10aa32 req = malloc (sizeof (rtems_aio_request)); 10a9f0: 83 ec 0c sub $0xc,%esp 10a9f3: 6a 18 push $0x18 10a9f5: e8 ba d7 ff ff call 1081b4 if (req == NULL) 10a9fa: 83 c4 10 add $0x10,%esp 10a9fd: 85 c0 test %eax,%eax 10a9ff: 75 1b jne 10aa1c <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10aa01: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10aa08: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10aa0f: e8 e8 8c 00 00 call 1136fc <__errno> <== NOT EXECUTED 10aa14: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10aa1a: eb 16 jmp 10aa32 <== NOT EXECUTED req->aiocbp = aiocbp; 10aa1c: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_SYNC; 10aa1f: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx) return rtems_aio_enqueue (req); 10aa26: 89 45 08 mov %eax,0x8(%ebp) } 10aa29: 8b 5d fc mov -0x4(%ebp),%ebx 10aa2c: 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); 10aa2d: e9 ef 04 00 00 jmp 10af21 } 10aa32: 83 c8 ff or $0xffffffff,%eax 10aa35: 8b 5d fc mov -0x4(%ebp),%ebx 10aa38: c9 leave 10aa39: c3 ret =============================================================================== 0010b124 : * 0 - otherwise */ int aio_read (struct aiocb *aiocbp) { 10b124: 55 push %ebp 10b125: 89 e5 mov %esp,%ebp 10b127: 53 push %ebx 10b128: 83 ec 0c sub $0xc,%esp 10b12b: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10b12e: 6a 03 push $0x3 10b130: ff 33 pushl (%ebx) 10b132: e8 55 57 00 00 call 11088c if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10b137: 83 e0 03 and $0x3,%eax 10b13a: 83 c4 10 add $0x10,%esp 10b13d: 83 f8 02 cmp $0x2,%eax 10b140: 74 1f je 10b161 10b142: 85 c0 test %eax,%eax 10b144: 74 1b je 10b161 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10b146: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10b14d: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b154: e8 a3 85 00 00 call 1136fc <__errno> 10b159: c7 00 09 00 00 00 movl $0x9,(%eax) 10b15f: eb 69 jmp 10b1ca if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10b161: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10b165: 75 06 jne 10b16d rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10b167: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10b16b: 79 1b jns 10b188 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10b16d: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10b174: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b17b: e8 7c 85 00 00 call 1136fc <__errno> 10b180: c7 00 16 00 00 00 movl $0x16,(%eax) 10b186: eb 42 jmp 10b1ca req = malloc (sizeof (rtems_aio_request)); 10b188: 83 ec 0c sub $0xc,%esp 10b18b: 6a 18 push $0x18 10b18d: e8 22 d0 ff ff call 1081b4 if (req == NULL) 10b192: 83 c4 10 add $0x10,%esp 10b195: 85 c0 test %eax,%eax 10b197: 75 1b jne 10b1b4 <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10b199: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10b1a0: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10b1a7: e8 50 85 00 00 call 1136fc <__errno> <== NOT EXECUTED 10b1ac: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10b1b2: eb 16 jmp 10b1ca <== NOT EXECUTED req->aiocbp = aiocbp; 10b1b4: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_READ; 10b1b7: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx) return rtems_aio_enqueue (req); 10b1be: 89 45 08 mov %eax,0x8(%ebp) } 10b1c1: 8b 5d fc mov -0x4(%ebp),%ebx 10b1c4: 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); 10b1c5: e9 57 fd ff ff jmp 10af21 } 10b1ca: 83 c8 ff or $0xffffffff,%eax 10b1cd: 8b 5d fc mov -0x4(%ebp),%ebx 10b1d0: c9 leave 10b1d1: c3 ret =============================================================================== 0010b1e0 : * 0 - otherwise */ int aio_write (struct aiocb *aiocbp) { 10b1e0: 55 push %ebp 10b1e1: 89 e5 mov %esp,%ebp 10b1e3: 53 push %ebx 10b1e4: 83 ec 0c sub $0xc,%esp 10b1e7: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10b1ea: 6a 03 push $0x3 10b1ec: ff 33 pushl (%ebx) 10b1ee: e8 99 56 00 00 call 11088c if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10b1f3: 83 e0 03 and $0x3,%eax 10b1f6: 48 dec %eax 10b1f7: 83 c4 10 add $0x10,%esp 10b1fa: 83 f8 01 cmp $0x1,%eax 10b1fd: 76 1b jbe 10b21a rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10b1ff: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10b206: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b20d: e8 ea 84 00 00 call 1136fc <__errno> 10b212: c7 00 09 00 00 00 movl $0x9,(%eax) 10b218: eb 69 jmp 10b283 if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10b21a: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10b21e: 75 06 jne 10b226 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10b220: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10b224: 79 1b jns 10b241 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10b226: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10b22d: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b234: e8 c3 84 00 00 call 1136fc <__errno> 10b239: c7 00 16 00 00 00 movl $0x16,(%eax) 10b23f: eb 42 jmp 10b283 req = malloc (sizeof (rtems_aio_request)); 10b241: 83 ec 0c sub $0xc,%esp 10b244: 6a 18 push $0x18 10b246: e8 69 cf ff ff call 1081b4 if (req == NULL) 10b24b: 83 c4 10 add $0x10,%esp 10b24e: 85 c0 test %eax,%eax 10b250: 75 1b jne 10b26d <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10b252: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10b259: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10b260: e8 97 84 00 00 call 1136fc <__errno> <== NOT EXECUTED 10b265: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10b26b: eb 16 jmp 10b283 <== NOT EXECUTED req->aiocbp = aiocbp; 10b26d: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_WRITE; 10b270: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx) return rtems_aio_enqueue (req); 10b277: 89 45 08 mov %eax,0x8(%ebp) } 10b27a: 8b 5d fc mov -0x4(%ebp),%ebx 10b27d: 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); 10b27e: e9 9e fc ff ff jmp 10af21 } 10b283: 83 c8 ff or $0xffffffff,%eax 10b286: 8b 5d fc mov -0x4(%ebp),%ebx 10b289: c9 leave 10b28a: c3 ret =============================================================================== 00107518 : #include int chroot( const char *pathname ) { 107518: 55 push %ebp 107519: 89 e5 mov %esp,%ebp 10751b: 57 push %edi 10751c: 56 push %esi 10751d: 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) { 107520: 81 3d 3c 30 12 00 08 cmpl $0x125208,0x12303c 107527: 52 12 00 10752a: 75 1e jne 10754a rtems_libio_set_private_env(); /* try to set a new private env*/ 10752c: e8 cc 10 00 00 call 1085fd if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 107531: 81 3d 3c 30 12 00 08 cmpl $0x125208,0x12303c 107538: 52 12 00 10753b: 75 0d jne 10754a rtems_set_errno_and_return_minus_one( ENOTSUP ); 10753d: e8 d2 a3 00 00 call 111914 <__errno> 107542: c7 00 86 00 00 00 movl $0x86,(%eax) 107548: eb 22 jmp 10756c } result = chdir(pathname); 10754a: 83 ec 0c sub $0xc,%esp 10754d: ff 75 08 pushl 0x8(%ebp) 107550: e8 47 74 00 00 call 10e99c if (result) { 107555: 83 c4 10 add $0x10,%esp 107558: 85 c0 test %eax,%eax 10755a: 74 15 je 107571 rtems_set_errno_and_return_minus_one( errno ); 10755c: e8 b3 a3 00 00 call 111914 <__errno> 107561: 89 c6 mov %eax,%esi 107563: e8 ac a3 00 00 call 111914 <__errno> 107568: 8b 00 mov (%eax),%eax 10756a: 89 06 mov %eax,(%esi) 10756c: 83 c8 ff or $0xffffffff,%eax 10756f: eb 44 jmp 1075b5 } /* clone the new root location */ if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) { 107571: 83 ec 0c sub $0xc,%esp 107574: 6a 00 push $0x0 107576: 8d 75 e4 lea -0x1c(%ebp),%esi 107579: 56 push %esi 10757a: 6a 00 push $0x0 10757c: 6a 01 push $0x1 10757e: 68 d6 fc 11 00 push $0x11fcd6 107583: e8 02 01 00 00 call 10768a 107588: 83 c4 20 add $0x20,%esp 10758b: 85 c0 test %eax,%eax 10758d: 75 cd jne 10755c <== 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); 10758f: 83 ec 0c sub $0xc,%esp 107592: a1 3c 30 12 00 mov 0x12303c,%eax 107597: 83 c0 18 add $0x18,%eax 10759a: 50 push %eax 10759b: e8 a8 01 00 00 call 107748 rtems_filesystem_root = loc; 1075a0: 8b 3d 3c 30 12 00 mov 0x12303c,%edi 1075a6: 83 c7 18 add $0x18,%edi 1075a9: b9 05 00 00 00 mov $0x5,%ecx 1075ae: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return 0; 1075b0: 83 c4 10 add $0x10,%esp 1075b3: 31 c0 xor %eax,%eax } 1075b5: 8d 65 f8 lea -0x8(%ebp),%esp 1075b8: 5e pop %esi 1075b9: 5f pop %edi 1075ba: c9 leave 1075bb: c3 ret =============================================================================== 00109f98 : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 109f98: 55 push %ebp 109f99: 89 e5 mov %esp,%ebp 109f9b: 83 ec 08 sub $0x8,%esp 109f9e: 8b 45 08 mov 0x8(%ebp),%eax 109fa1: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 109fa4: 85 d2 test %edx,%edx 109fa6: 74 3c je 109fe4 rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 109fa8: 83 f8 01 cmp $0x1,%eax 109fab: 75 0b jne 109fb8 _TOD_Get(tp); 109fad: 83 ec 0c sub $0xc,%esp 109fb0: 52 push %edx 109fb1: e8 b6 1b 00 00 call 10bb6c <_TOD_Get> 109fb6: eb 13 jmp 109fcb return 0; } #ifdef CLOCK_MONOTONIC if ( clock_id == CLOCK_MONOTONIC ) { 109fb8: 83 f8 04 cmp $0x4,%eax 109fbb: 74 05 je 109fc2 <== NEVER TAKEN return 0; } #endif #ifdef _POSIX_CPUTIME if ( clock_id == CLOCK_PROCESS_CPUTIME ) { 109fbd: 83 f8 02 cmp $0x2,%eax 109fc0: 75 10 jne 109fd2 _TOD_Get_uptime_as_timespec( tp ); 109fc2: 83 ec 0c sub $0xc,%esp 109fc5: 52 push %edx 109fc6: e8 f5 1b 00 00 call 10bbc0 <_TOD_Get_uptime_as_timespec> return 0; 109fcb: 83 c4 10 add $0x10,%esp 109fce: 31 c0 xor %eax,%eax 109fd0: eb 20 jmp 109ff2 } #endif #ifdef _POSIX_THREAD_CPUTIME if ( clock_id == CLOCK_THREAD_CPUTIME ) 109fd2: 83 f8 03 cmp $0x3,%eax 109fd5: 75 0d jne 109fe4 rtems_set_errno_and_return_minus_one( ENOSYS ); 109fd7: e8 14 80 00 00 call 111ff0 <__errno> 109fdc: c7 00 58 00 00 00 movl $0x58,(%eax) 109fe2: eb 0b jmp 109fef #endif rtems_set_errno_and_return_minus_one( EINVAL ); 109fe4: e8 07 80 00 00 call 111ff0 <__errno> 109fe9: c7 00 16 00 00 00 movl $0x16,(%eax) 109fef: 83 c8 ff or $0xffffffff,%eax return 0; } 109ff2: c9 leave 109ff3: c3 ret =============================================================================== 00109ff4 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 109ff4: 55 push %ebp 109ff5: 89 e5 mov %esp,%ebp 109ff7: 83 ec 08 sub $0x8,%esp 109ffa: 8b 45 08 mov 0x8(%ebp),%eax 109ffd: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 10a000: 85 d2 test %edx,%edx 10a002: 74 44 je 10a048 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 10a004: 83 f8 01 cmp $0x1,%eax 10a007: 75 28 jne 10a031 if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 10a009: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx) 10a00f: 76 37 jbe 10a048 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a011: a1 60 73 12 00 mov 0x127360,%eax 10a016: 40 inc %eax 10a017: a3 60 73 12 00 mov %eax,0x127360 rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); 10a01c: 83 ec 0c sub $0xc,%esp 10a01f: 52 push %edx 10a020: e8 f3 1b 00 00 call 10bc18 <_TOD_Set> _Thread_Enable_dispatch(); 10a025: e8 78 2e 00 00 call 10cea2 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; 10a02a: 83 c4 10 add $0x10,%esp 10a02d: 31 c0 xor %eax,%eax 10a02f: eb 25 jmp 10a056 _Thread_Disable_dispatch(); _TOD_Set( tp ); _Thread_Enable_dispatch(); } #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 10a031: 83 f8 02 cmp $0x2,%eax 10a034: 74 05 je 10a03b rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 10a036: 83 f8 03 cmp $0x3,%eax 10a039: 75 0d jne 10a048 rtems_set_errno_and_return_minus_one( ENOSYS ); 10a03b: e8 b0 7f 00 00 call 111ff0 <__errno> 10a040: c7 00 58 00 00 00 movl $0x58,(%eax) 10a046: eb 0b jmp 10a053 #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 10a048: e8 a3 7f 00 00 call 111ff0 <__errno> 10a04d: c7 00 16 00 00 00 movl $0x16,(%eax) 10a053: 83 c8 ff or $0xffffffff,%eax return 0; } 10a056: c9 leave 10a057: c3 ret =============================================================================== 0010d430 : const char *pathname, size_t pathnamelen, int flags, rtems_filesystem_location_info_t *pathloc ) { 10d430: 55 push %ebp 10d431: 89 e5 mov %esp,%ebp 10d433: 57 push %edi 10d434: 56 push %esi 10d435: 53 push %ebx 10d436: 83 ec 1c sub $0x1c,%esp 10d439: 8b 4d 0c mov 0xc(%ebp),%ecx 10d43c: 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 ) ) 10d43f: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp) 10d446: 74 0d je 10d455 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EPERM ); 10d448: e8 07 23 00 00 call 10f754 <__errno> 10d44d: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10d453: eb 77 jmp 10d4cc <== NOT EXECUTED /* get the device name table */ device_name_table = (rtems_device_name_t *)pathloc->node_access; 10d455: 8b 33 mov (%ebx),%esi if (!device_name_table) 10d457: 85 f6 test %esi,%esi 10d459: 74 04 je 10d45f 10d45b: 31 ff xor %edi,%edi 10d45d: eb 5a jmp 10d4b9 rtems_set_errno_and_return_minus_one( EFAULT ); 10d45f: e8 f0 22 00 00 call 10f754 <__errno> 10d464: c7 00 0e 00 00 00 movl $0xe,(%eax) 10d46a: eb 60 jmp 10d4cc for (i = 0; i < rtems_device_table_size; i++) { if (!device_name_table[i].device_name) 10d46c: 8b 16 mov (%esi),%edx 10d46e: 85 d2 test %edx,%edx 10d470: 74 43 je 10d4b5 continue; if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0) 10d472: 50 push %eax 10d473: 51 push %ecx 10d474: 52 push %edx 10d475: ff 75 08 pushl 0x8(%ebp) 10d478: 89 55 e4 mov %edx,-0x1c(%ebp) 10d47b: 89 4d e0 mov %ecx,-0x20(%ebp) 10d47e: e8 b1 2f 00 00 call 110434 10d483: 83 c4 10 add $0x10,%esp 10d486: 85 c0 test %eax,%eax 10d488: 8b 55 e4 mov -0x1c(%ebp),%edx 10d48b: 8b 4d e0 mov -0x20(%ebp),%ecx 10d48e: 75 25 jne 10d4b5 continue; if (device_name_table[i].device_name[pathnamelen] != '\0') 10d490: 80 3c 0a 00 cmpb $0x0,(%edx,%ecx,1) 10d494: 75 1f jne 10d4b5 <== NEVER TAKEN continue; /* find the device, set proper values */ pathloc->node_access = (void *)&device_name_table[i]; 10d496: 89 33 mov %esi,(%ebx) pathloc->handlers = &devFS_file_handlers; 10d498: c7 43 08 8c 0f 12 00 movl $0x120f8c,0x8(%ebx) pathloc->ops = &devFS_ops; 10d49f: c7 43 0c 44 0f 12 00 movl $0x120f44,0xc(%ebx) pathloc->mt_entry = rtems_filesystem_root.mt_entry; 10d4a6: a1 e0 10 12 00 mov 0x1210e0,%eax 10d4ab: 8b 40 28 mov 0x28(%eax),%eax 10d4ae: 89 43 10 mov %eax,0x10(%ebx) return 0; 10d4b1: 31 c0 xor %eax,%eax 10d4b3: eb 1a jmp 10d4cf /* 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++) { 10d4b5: 47 inc %edi 10d4b6: 83 c6 14 add $0x14,%esi 10d4b9: 3b 3d 48 f1 11 00 cmp 0x11f148,%edi 10d4bf: 72 ab jb 10d46c pathloc->mt_entry = rtems_filesystem_root.mt_entry; return 0; } /* no such file or directory */ rtems_set_errno_and_return_minus_one( ENOENT ); 10d4c1: e8 8e 22 00 00 call 10f754 <__errno> 10d4c6: c7 00 02 00 00 00 movl $0x2,(%eax) 10d4cc: 83 c8 ff or $0xffffffff,%eax } 10d4cf: 8d 65 f4 lea -0xc(%ebp),%esp 10d4d2: 5b pop %ebx 10d4d3: 5e pop %esi 10d4d4: 5f pop %edi 10d4d5: c9 leave 10d4d6: c3 ret =============================================================================== 00106c40 : const char *path, mode_t mode, dev_t dev, rtems_filesystem_location_info_t *pathloc ) { 106c40: 55 push %ebp 106c41: 89 e5 mov %esp,%ebp 106c43: 57 push %edi 106c44: 56 push %esi 106c45: 53 push %ebx 106c46: 83 ec 1c sub $0x1c,%esp 106c49: 8b 7d 08 mov 0x8(%ebp),%edi 106c4c: 8b 4d 10 mov 0x10(%ebp),%ecx 106c4f: 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') && 106c52: 80 3f 64 cmpb $0x64,(%edi) 106c55: 75 18 jne 106c6f 106c57: 80 7f 01 65 cmpb $0x65,0x1(%edi) 106c5b: 75 12 jne 106c6f <== NEVER TAKEN 106c5d: 80 7f 02 76 cmpb $0x76,0x2(%edi) 106c61: 75 0c jne 106c6f <== NEVER TAKEN (path[2] == 'v') && (path[3] == '\0')) return 0; 106c63: 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')) 106c65: 80 7f 03 00 cmpb $0x0,0x3(%edi) 106c69: 0f 84 c9 00 00 00 je 106d38 return 0; /* must be a character device or a block device */ if (!S_ISBLK(mode) && !S_ISCHR(mode)) 106c6f: 8b 45 0c mov 0xc(%ebp),%eax 106c72: 25 00 f0 00 00 and $0xf000,%eax 106c77: 3d 00 20 00 00 cmp $0x2000,%eax 106c7c: 74 14 je 106c92 106c7e: 3d 00 60 00 00 cmp $0x6000,%eax 106c83: 74 0d je 106c92 rtems_set_errno_and_return_minus_one( EINVAL ); 106c85: e8 ca 8a 00 00 call 10f754 <__errno> 106c8a: c7 00 16 00 00 00 movl $0x16,(%eax) 106c90: eb 23 jmp 106cb5 ) { union __rtems_dev_t temp; temp.device = device; return temp.__overlay.major; 106c92: 89 4d e4 mov %ecx,-0x1c(%ebp) dev_t device ) { union __rtems_dev_t temp; temp.device = device; 106c95: 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; 106c98: 8b 45 18 mov 0x18(%ebp),%eax 106c9b: 8b 08 mov (%eax),%ecx if (!device_name_table) 106c9d: 85 c9 test %ecx,%ecx 106c9f: 74 09 je 106caa 106ca1: 89 ca mov %ecx,%edx 106ca3: 83 ce ff or $0xffffffff,%esi 106ca6: 31 db xor %ebx,%ebx 106ca8: eb 46 jmp 106cf0 rtems_set_errno_and_return_minus_one( EFAULT ); 106caa: e8 a5 8a 00 00 call 10f754 <__errno> 106caf: c7 00 0e 00 00 00 movl $0xe,(%eax) 106cb5: 83 c8 ff or $0xffffffff,%eax 106cb8: eb 7e jmp 106d38 for (slot = -1, i = 0; i < rtems_device_table_size; i++){ if (device_name_table[i].device_name == NULL) 106cba: 8b 02 mov (%edx),%eax 106cbc: 85 c0 test %eax,%eax 106cbe: 74 2a je 106cea slot = i; else if (strcmp(path, device_name_table[i].device_name) == 0) 106cc0: 83 ec 08 sub $0x8,%esp 106cc3: 50 push %eax 106cc4: 57 push %edi 106cc5: 89 55 d8 mov %edx,-0x28(%ebp) 106cc8: 89 4d dc mov %ecx,-0x24(%ebp) 106ccb: e8 bc 96 00 00 call 11038c 106cd0: 83 c4 10 add $0x10,%esp 106cd3: 85 c0 test %eax,%eax 106cd5: 8b 55 d8 mov -0x28(%ebp),%edx 106cd8: 8b 4d dc mov -0x24(%ebp),%ecx 106cdb: 75 0f jne 106cec rtems_set_errno_and_return_minus_one( EEXIST ); 106cdd: e8 72 8a 00 00 call 10f754 <__errno> 106ce2: c7 00 11 00 00 00 movl $0x11,(%eax) 106ce8: eb cb jmp 106cb5 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; 106cea: 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++){ 106cec: 43 inc %ebx 106ced: 83 c2 14 add $0x14,%edx 106cf0: 3b 1d 48 f1 11 00 cmp 0x11f148,%ebx 106cf6: 72 c2 jb 106cba else if (strcmp(path, device_name_table[i].device_name) == 0) rtems_set_errno_and_return_minus_one( EEXIST ); } if (slot == -1) 106cf8: 83 fe ff cmp $0xffffffff,%esi 106cfb: 75 0d jne 106d0a rtems_set_errno_and_return_minus_one( ENOMEM ); 106cfd: e8 52 8a 00 00 call 10f754 <__errno> 106d02: c7 00 0c 00 00 00 movl $0xc,(%eax) 106d08: eb ab jmp 106cb5 _ISR_Disable(level); 106d0a: 9c pushf 106d0b: fa cli 106d0c: 5b pop %ebx device_name_table[slot].device_name = (char *)path; 106d0d: 6b d6 14 imul $0x14,%esi,%edx 106d10: 8d 14 11 lea (%ecx,%edx,1),%edx 106d13: 89 3a mov %edi,(%edx) device_name_table[slot].device_name_length = strlen(path); 106d15: 31 c0 xor %eax,%eax 106d17: 83 c9 ff or $0xffffffff,%ecx 106d1a: f2 ae repnz scas %es:(%edi),%al 106d1c: f7 d1 not %ecx 106d1e: 49 dec %ecx 106d1f: 89 4a 04 mov %ecx,0x4(%edx) device_name_table[slot].major = major; 106d22: 8b 45 e4 mov -0x1c(%ebp),%eax 106d25: 89 42 08 mov %eax,0x8(%edx) device_name_table[slot].minor = minor; 106d28: 8b 45 e0 mov -0x20(%ebp),%eax 106d2b: 89 42 0c mov %eax,0xc(%edx) device_name_table[slot].mode = mode; 106d2e: 8b 45 0c mov 0xc(%ebp),%eax 106d31: 89 42 10 mov %eax,0x10(%edx) _ISR_Enable(level); 106d34: 53 push %ebx 106d35: 9d popf return 0; 106d36: 31 c0 xor %eax,%eax } 106d38: 8d 65 f4 lea -0xc(%ebp),%esp 106d3b: 5b pop %ebx 106d3c: 5e pop %esi 106d3d: 5f pop %edi 106d3e: c9 leave 106d3f: c3 ret =============================================================================== 00108084 : /* * Drain output queue */ static void drainOutput (struct rtems_termios_tty *tty) { 108084: 55 push %ebp 108085: 89 e5 mov %esp,%ebp 108087: 53 push %ebx 108088: 83 ec 04 sub $0x4,%esp 10808b: 89 c3 mov %eax,%ebx rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { 10808d: 83 b8 b4 00 00 00 00 cmpl $0x0,0xb4(%eax) 108094: 74 46 je 1080dc rtems_interrupt_disable (level); 108096: 9c pushf 108097: fa cli 108098: 58 pop %eax while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) { 108099: eb 2f jmp 1080ca tty->rawOutBufState = rob_wait; 10809b: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) 1080a2: 00 00 00 rtems_interrupt_enable (level); 1080a5: 50 push %eax 1080a6: 9d popf sc = rtems_semaphore_obtain( 1080a7: 50 push %eax 1080a8: 6a 00 push $0x0 1080aa: 6a 00 push $0x0 1080ac: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 1080b2: e8 b1 20 00 00 call 10a168 tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 1080b7: 83 c4 10 add $0x10,%esp 1080ba: 85 c0 test %eax,%eax 1080bc: 74 09 je 1080c7 <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 1080be: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1080c1: 50 push %eax <== NOT EXECUTED 1080c2: e8 75 26 00 00 call 10a73c <== NOT EXECUTED rtems_interrupt_disable (level); 1080c7: 9c pushf 1080c8: fa cli 1080c9: 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) { 1080ca: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx 1080d0: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 1080d6: 39 d1 cmp %edx,%ecx 1080d8: 75 c1 jne 10809b 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); 1080da: 50 push %eax 1080db: 9d popf } } 1080dc: 8b 5d fc mov -0x4(%ebp),%ebx 1080df: c9 leave 1080e0: c3 ret =============================================================================== 00108c3b : /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { 108c3b: 55 push %ebp 108c3c: 89 e5 mov %esp,%ebp 108c3e: 53 push %ebx 108c3f: 83 ec 24 sub $0x24,%esp if ((tty->termios.c_lflag & ECHOCTL) && 108c42: f6 42 3d 02 testb $0x2,0x3d(%edx) 108c46: 74 3e je 108c86 <== NEVER TAKEN iscntrl(c) && (c != '\t') && (c != '\n')) { 108c48: 0f b6 c8 movzbl %al,%ecx 108c4b: 8b 1d 1c 31 12 00 mov 0x12311c,%ebx 108c51: f6 44 0b 01 20 testb $0x20,0x1(%ebx,%ecx,1) 108c56: 74 2e je 108c86 108c58: 3c 09 cmp $0x9,%al 108c5a: 74 2a je 108c86 108c5c: 3c 0a cmp $0xa,%al 108c5e: 74 26 je 108c86 char echobuf[2]; echobuf[0] = '^'; 108c60: c6 45 f6 5e movb $0x5e,-0xa(%ebp) echobuf[1] = c ^ 0x40; 108c64: 83 f0 40 xor $0x40,%eax 108c67: 88 45 f7 mov %al,-0x9(%ebp) rtems_termios_puts (echobuf, 2, tty); 108c6a: 50 push %eax 108c6b: 52 push %edx 108c6c: 6a 02 push $0x2 108c6e: 8d 45 f6 lea -0xa(%ebp),%eax 108c71: 50 push %eax 108c72: 89 55 e4 mov %edx,-0x1c(%ebp) 108c75: e8 84 fd ff ff call 1089fe tty->column += 2; 108c7a: 8b 55 e4 mov -0x1c(%ebp),%edx 108c7d: 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')) { 108c81: 83 c4 10 add $0x10,%esp 108c84: eb 08 jmp 108c8e echobuf[0] = '^'; echobuf[1] = c ^ 0x40; rtems_termios_puts (echobuf, 2, tty); tty->column += 2; } else { oproc (c, tty); 108c86: 0f b6 c0 movzbl %al,%eax 108c89: e8 90 fe ff ff call 108b1e } } 108c8e: 8b 5d fc mov -0x4(%ebp),%ebx 108c91: c9 leave 108c92: c3 ret =============================================================================== 0010811e : void endgrent(void) { 10811e: 55 push %ebp 10811f: 89 e5 mov %esp,%ebp 108121: 83 ec 08 sub $0x8,%esp if (group_fp != NULL) 108124: a1 98 6b 12 00 mov 0x126b98,%eax 108129: 85 c0 test %eax,%eax 10812b: 74 0c je 108139 <== NEVER TAKEN fclose(group_fp); 10812d: 83 ec 0c sub $0xc,%esp 108130: 50 push %eax 108131: e8 fe 9e 00 00 call 112034 108136: 83 c4 10 add $0x10,%esp } 108139: c9 leave 10813a: c3 ret =============================================================================== 00107fd1 : void endpwent(void) { 107fd1: 55 push %ebp 107fd2: 89 e5 mov %esp,%ebp 107fd4: 83 ec 08 sub $0x8,%esp if (passwd_fp != NULL) 107fd7: a1 74 6c 12 00 mov 0x126c74,%eax 107fdc: 85 c0 test %eax,%eax 107fde: 74 0c je 107fec <== NEVER TAKEN fclose(passwd_fp); 107fe0: 83 ec 0c sub $0xc,%esp 107fe3: 50 push %eax 107fe4: e8 4b a0 00 00 call 112034 107fe9: 83 c4 10 add $0x10,%esp } 107fec: c9 leave 107fed: c3 ret =============================================================================== 00108c93 : * 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) { 108c93: 55 push %ebp 108c94: 89 e5 mov %esp,%ebp 108c96: 57 push %edi 108c97: 56 push %esi 108c98: 53 push %ebx 108c99: 83 ec 2c sub $0x2c,%esp 108c9c: 89 c3 mov %eax,%ebx 108c9e: 89 55 e4 mov %edx,-0x1c(%ebp) if (tty->ccount == 0) 108ca1: 83 78 20 00 cmpl $0x0,0x20(%eax) 108ca5: 0f 84 59 01 00 00 je 108e04 return; if (lineFlag) { 108cab: 85 d2 test %edx,%edx 108cad: 0f 84 46 01 00 00 je 108df9 if (!(tty->termios.c_lflag & ECHO)) { 108cb3: 8b 40 3c mov 0x3c(%eax),%eax 108cb6: a8 08 test $0x8,%al 108cb8: 75 0c jne 108cc6 <== ALWAYS TAKEN tty->ccount = 0; 108cba: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED return; 108cc1: e9 3e 01 00 00 jmp 108e04 <== NOT EXECUTED } if (!(tty->termios.c_lflag & ECHOE)) { 108cc6: a8 10 test $0x10,%al 108cc8: 0f 85 2b 01 00 00 jne 108df9 <== ALWAYS TAKEN tty->ccount = 0; 108cce: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED echo (tty->termios.c_cc[VKILL], tty); 108cd5: 0f b6 43 44 movzbl 0x44(%ebx),%eax <== NOT EXECUTED 108cd9: 89 da mov %ebx,%edx <== NOT EXECUTED 108cdb: e8 5b ff ff ff call 108c3b <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) 108ce0: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED 108ce4: 0f 84 1a 01 00 00 je 108e04 <== NOT EXECUTED echo ('\n', tty); 108cea: 89 da mov %ebx,%edx <== NOT EXECUTED 108cec: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 108cf1: eb 2a jmp 108d1d <== NOT EXECUTED return; } } while (tty->ccount) { unsigned char c = tty->cbuf[--tty->ccount]; 108cf3: 8b 7b 1c mov 0x1c(%ebx),%edi 108cf6: 8d 50 ff lea -0x1(%eax),%edx 108cf9: 89 53 20 mov %edx,0x20(%ebx) 108cfc: 8a 4c 07 ff mov -0x1(%edi,%eax,1),%cl if (tty->termios.c_lflag & ECHO) { 108d00: 8b 53 3c mov 0x3c(%ebx),%edx 108d03: f6 c2 08 test $0x8,%dl 108d06: 0f 84 e7 00 00 00 je 108df3 <== NEVER TAKEN if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { 108d0c: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 108d10: 75 17 jne 108d29 108d12: f6 c2 10 test $0x10,%dl 108d15: 75 12 jne 108d29 <== ALWAYS TAKEN echo (tty->termios.c_cc[VERASE], tty); 108d17: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED 108d1b: 89 da mov %ebx,%edx <== NOT EXECUTED } } if (!lineFlag) break; } } 108d1d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108d20: 5b pop %ebx <== NOT EXECUTED 108d21: 5e pop %esi <== NOT EXECUTED 108d22: 5f pop %edi <== NOT EXECUTED 108d23: 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); 108d24: e9 12 ff ff ff jmp 108c3b <== NOT EXECUTED } else if (c == '\t') { 108d29: 80 f9 09 cmp $0x9,%cl 108d2c: 8b 35 1c 31 12 00 mov 0x12311c,%esi 108d32: 89 75 e0 mov %esi,-0x20(%ebp) 108d35: 75 60 jne 108d97 int col = tty->read_start_column; 108d37: 8b 73 2c mov 0x2c(%ebx),%esi int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 108d3a: 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) 108d3f: 81 e2 00 02 00 00 and $0x200,%edx 108d45: 89 55 dc mov %edx,-0x24(%ebp) 108d48: 89 45 d4 mov %eax,-0x2c(%ebp) int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 108d4b: eb 28 jmp 108d75 c = tty->cbuf[i++]; 108d4d: 8a 54 0f ff mov -0x1(%edi,%ecx,1),%dl if (c == '\t') { 108d51: 80 fa 09 cmp $0x9,%dl 108d54: 75 05 jne 108d5b col = (col | 7) + 1; 108d56: 83 ce 07 or $0x7,%esi 108d59: eb 18 jmp 108d73 } else if (iscntrl (c)) { 108d5b: 0f b6 d2 movzbl %dl,%edx 108d5e: 8b 45 e0 mov -0x20(%ebp),%eax 108d61: f6 44 10 01 20 testb $0x20,0x1(%eax,%edx,1) 108d66: 74 0b je 108d73 <== ALWAYS TAKEN if (tty->termios.c_lflag & ECHOCTL) 108d68: 83 7d dc 00 cmpl $0x0,-0x24(%ebp) <== NOT EXECUTED 108d6c: 74 06 je 108d74 <== NOT EXECUTED col += 2; 108d6e: 83 c6 02 add $0x2,%esi <== NOT EXECUTED 108d71: eb 01 jmp 108d74 <== NOT EXECUTED } else { col++; 108d73: 46 inc %esi 108d74: 41 inc %ecx int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 108d75: 3b 4d d4 cmp -0x2c(%ebp),%ecx 108d78: 75 d3 jne 108d4d 108d7a: eb 14 jmp 108d90 /* * Back up over the tab */ while (tty->column > col) { rtems_termios_puts ("\b", 1, tty); 108d7c: 57 push %edi 108d7d: 53 push %ebx 108d7e: 6a 01 push $0x1 108d80: 68 44 f0 11 00 push $0x11f044 108d85: e8 74 fc ff ff call 1089fe tty->column--; 108d8a: ff 4b 28 decl 0x28(%ebx) 108d8d: 83 c4 10 add $0x10,%esp } /* * Back up over the tab */ while (tty->column > col) { 108d90: 39 73 28 cmp %esi,0x28(%ebx) 108d93: 7f e7 jg 108d7c 108d95: eb 5c jmp 108df3 rtems_termios_puts ("\b", 1, tty); tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { 108d97: 0f b6 f1 movzbl %cl,%esi 108d9a: 8b 45 e0 mov -0x20(%ebp),%eax 108d9d: f6 44 30 01 20 testb $0x20,0x1(%eax,%esi,1) 108da2: 74 21 je 108dc5 <== ALWAYS TAKEN 108da4: 80 e6 02 and $0x2,%dh <== NOT EXECUTED 108da7: 74 1c je 108dc5 <== NOT EXECUTED rtems_termios_puts ("\b \b", 3, tty); 108da9: 51 push %ecx <== NOT EXECUTED 108daa: 53 push %ebx <== NOT EXECUTED 108dab: 6a 03 push $0x3 <== NOT EXECUTED 108dad: 68 42 f0 11 00 push $0x11f042 <== NOT EXECUTED 108db2: e8 47 fc ff ff call 1089fe <== NOT EXECUTED if (tty->column) 108db7: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 108dba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108dbd: 85 c0 test %eax,%eax <== NOT EXECUTED 108dbf: 74 04 je 108dc5 <== NOT EXECUTED tty->column--; 108dc1: 48 dec %eax <== NOT EXECUTED 108dc2: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED } if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) { 108dc5: a1 1c 31 12 00 mov 0x12311c,%eax 108dca: f6 44 30 01 20 testb $0x20,0x1(%eax,%esi,1) 108dcf: 74 06 je 108dd7 <== ALWAYS TAKEN 108dd1: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED 108dd5: 74 1c je 108df3 <== NOT EXECUTED rtems_termios_puts ("\b \b", 3, tty); 108dd7: 52 push %edx 108dd8: 53 push %ebx 108dd9: 6a 03 push $0x3 108ddb: 68 42 f0 11 00 push $0x11f042 108de0: e8 19 fc ff ff call 1089fe if (tty->column) 108de5: 8b 43 28 mov 0x28(%ebx),%eax 108de8: 83 c4 10 add $0x10,%esp 108deb: 85 c0 test %eax,%eax 108ded: 74 04 je 108df3 <== NEVER TAKEN tty->column--; 108def: 48 dec %eax 108df0: 89 43 28 mov %eax,0x28(%ebx) } } } if (!lineFlag) 108df3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 108df7: 74 0b je 108e04 echo ('\n', tty); return; } } while (tty->ccount) { 108df9: 8b 43 20 mov 0x20(%ebx),%eax 108dfc: 85 c0 test %eax,%eax 108dfe: 0f 85 ef fe ff ff jne 108cf3 } } if (!lineFlag) break; } } 108e04: 8d 65 f4 lea -0xc(%ebp),%esp 108e07: 5b pop %ebx 108e08: 5e pop %esi 108e09: 5f pop %edi 108e0a: c9 leave 108e0b: c3 ret =============================================================================== 00107bd8 : int fcntl( int fd, int cmd, ... ) { 107bd8: 55 push %ebp 107bd9: 89 e5 mov %esp,%ebp 107bdb: 57 push %edi 107bdc: 56 push %esi 107bdd: 53 push %ebx 107bde: 83 ec 0c sub $0xc,%esp 107be1: 8b 5d 08 mov 0x8(%ebp),%ebx int ret; va_list ap; va_start( ap, cmd ); 107be4: 8d 75 10 lea 0x10(%ebp),%esi int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 107be7: 8b 0d 44 21 12 00 mov 0x122144,%ecx 107bed: 39 cb cmp %ecx,%ebx 107bef: 73 14 jae 107c05 iop = rtems_libio_iop( fd ); 107bf1: 8b 15 d8 61 12 00 mov 0x1261d8,%edx 107bf7: 6b db 38 imul $0x38,%ebx,%ebx 107bfa: 8d 1c 1a lea (%edx,%ebx,1),%ebx rtems_libio_check_is_open(iop); 107bfd: 8b 43 14 mov 0x14(%ebx),%eax 107c00: f6 c4 01 test $0x1,%ah 107c03: 75 10 jne 107c15 107c05: e8 aa a3 00 00 call 111fb4 <__errno> 107c0a: c7 00 09 00 00 00 movl $0x9,(%eax) 107c10: e9 e6 00 00 00 jmp 107cfb /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 107c15: 83 7d 0c 09 cmpl $0x9,0xc(%ebp) 107c19: 0f 87 af 00 00 00 ja 107cce 107c1f: 8b 7d 0c mov 0xc(%ebp),%edi 107c22: ff 24 bd 90 08 12 00 jmp *0x120890(,%edi,4) case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); 107c29: 8b 36 mov (%esi),%esi if ( fd2 ) 107c2b: 85 f6 test %esi,%esi 107c2d: 74 0e je 107c3d diop = rtems_libio_iop( fd2 ); 107c2f: 31 c0 xor %eax,%eax 107c31: 39 ce cmp %ecx,%esi 107c33: 73 15 jae 107c4a <== NEVER TAKEN 107c35: 6b c6 38 imul $0x38,%esi,%eax 107c38: 8d 04 02 lea (%edx,%eax,1),%eax 107c3b: eb 0d jmp 107c4a else { /* allocate a file control block */ diop = rtems_libio_allocate(); 107c3d: e8 d1 04 00 00 call 108113 if ( diop == 0 ) { 107c42: 85 c0 test %eax,%eax 107c44: 0f 84 b1 00 00 00 je 107cfb <== NEVER TAKEN ret = -1; break; } } diop->flags = iop->flags; 107c4a: 8b 53 14 mov 0x14(%ebx),%edx 107c4d: 89 50 14 mov %edx,0x14(%eax) diop->pathinfo = iop->pathinfo; 107c50: 8d 78 18 lea 0x18(%eax),%edi 107c53: 8d 73 18 lea 0x18(%ebx),%esi 107c56: b9 05 00 00 00 mov $0x5,%ecx 107c5b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ret = (int) (diop - rtems_libio_iops); 107c5d: 2b 05 d8 61 12 00 sub 0x1261d8,%eax 107c63: c1 f8 03 sar $0x3,%eax 107c66: 69 f0 b7 6d db b6 imul $0xb6db6db7,%eax,%esi 107c6c: eb 6d jmp 107cdb break; case F_GETFD: /* get f_flags */ ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0); 107c6e: f6 c4 08 test $0x8,%ah 107c71: 0f 95 c0 setne %al 107c74: 0f b6 c0 movzbl %al,%eax 107c77: 89 c6 mov %eax,%esi 107c79: eb 64 jmp 107cdf * 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 ) ) 107c7b: 83 3e 00 cmpl $0x0,(%esi) 107c7e: 74 05 je 107c85 iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; 107c80: 80 cc 08 or $0x8,%ah 107c83: eb 03 jmp 107c88 else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; 107c85: 80 e4 f7 and $0xf7,%ah 107c88: 89 43 14 mov %eax,0x14(%ebx) 107c8b: eb 30 jmp 107cbd break; case F_GETFL: /* more flags (cloexec) */ ret = rtems_libio_to_fcntl_flags( iop->flags ); 107c8d: 83 ec 0c sub $0xc,%esp 107c90: 50 push %eax 107c91: e8 3f 04 00 00 call 1080d5 107c96: 89 c6 mov %eax,%esi 107c98: 83 c4 10 add $0x10,%esp 107c9b: eb 3e jmp 107cdb break; case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); 107c9d: 83 ec 0c sub $0xc,%esp 107ca0: ff 36 pushl (%esi) 107ca2: e8 f9 03 00 00 call 1080a0 /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = (iop->flags & ~mask) | (flags & mask); 107ca7: 25 01 02 00 00 and $0x201,%eax 107cac: 8b 53 14 mov 0x14(%ebx),%edx 107caf: 81 e2 fe fd ff ff and $0xfffffdfe,%edx 107cb5: 09 d0 or %edx,%eax 107cb7: 89 43 14 mov %eax,0x14(%ebx) 107cba: 83 c4 10 add $0x10,%esp rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0; 107cbd: 31 f6 xor %esi,%esi 107cbf: eb 1e jmp 107cdf errno = ENOTSUP; ret = -1; break; case F_GETOWN: /* for sockets. */ errno = ENOTSUP; 107cc1: e8 ee a2 00 00 call 111fb4 <__errno> 107cc6: c7 00 86 00 00 00 movl $0x86,(%eax) 107ccc: eb 2d jmp 107cfb ret = -1; break; default: errno = EINVAL; 107cce: e8 e1 a2 00 00 call 111fb4 <__errno> 107cd3: c7 00 16 00 00 00 movl $0x16,(%eax) 107cd9: eb 20 jmp 107cfb /* * If we got this far successfully, then we give the optional * filesystem specific handler a chance to process this. */ if (ret >= 0) { 107cdb: 85 f6 test %esi,%esi 107cdd: 78 1f js 107cfe <== NEVER TAKEN int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop ); 107cdf: 50 push %eax 107ce0: 50 push %eax 107ce1: 8b 43 20 mov 0x20(%ebx),%eax 107ce4: 53 push %ebx 107ce5: ff 75 0c pushl 0xc(%ebp) 107ce8: ff 50 30 call *0x30(%eax) 107ceb: 89 c3 mov %eax,%ebx if (err) { 107ced: 83 c4 10 add $0x10,%esp 107cf0: 85 c0 test %eax,%eax 107cf2: 74 0a je 107cfe <== ALWAYS TAKEN errno = err; 107cf4: e8 bb a2 00 00 call 111fb4 <__errno> <== NOT EXECUTED 107cf9: 89 18 mov %ebx,(%eax) <== NOT EXECUTED ret = -1; 107cfb: 83 ce ff or $0xffffffff,%esi va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; } 107cfe: 89 f0 mov %esi,%eax 107d00: 8d 65 f4 lea -0xc(%ebp),%esp 107d03: 5b pop %ebx 107d04: 5e pop %esi 107d05: 5f pop %edi 107d06: c9 leave 107d07: c3 ret =============================================================================== 0010fae3 : */ int fifo_open( pipe_control_t **pipep, rtems_libio_t *iop ) { 10fae3: 55 push %ebp 10fae4: 89 e5 mov %esp,%ebp 10fae6: 57 push %edi 10fae7: 56 push %esi 10fae8: 53 push %ebx 10fae9: 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) { 10faec: 83 3d 00 70 12 00 00 cmpl $0x0,0x127000 10faf3: 75 50 jne 10fb45 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 ); 10faf5: 53 push %ebx 10faf6: 6a 00 push $0x0 10faf8: 6a 00 push $0x0 10fafa: ff 35 00 72 12 00 pushl 0x127200 10fb00: e8 07 c1 ff ff call 10bc0c rtems_libio_lock(); if (pipe_semaphore == RTEMS_ID_NONE) { 10fb05: 83 c4 10 add $0x10,%esp free(pipe); } static rtems_status_code pipe_lock(void) { rtems_status_code sc = RTEMS_SUCCESSFUL; 10fb08: 31 db xor %ebx,%ebx if (pipe_semaphore == RTEMS_ID_NONE) { rtems_libio_lock(); if (pipe_semaphore == RTEMS_ID_NONE) { 10fb0a: 83 3d 00 70 12 00 00 cmpl $0x0,0x127000 10fb11: 75 1d jne 10fb30 <== NEVER TAKEN sc = rtems_semaphore_create( 10fb13: 83 ec 0c sub $0xc,%esp 10fb16: 68 00 70 12 00 push $0x127000 10fb1b: 6a 00 push $0x0 10fb1d: 6a 54 push $0x54 10fb1f: 6a 01 push $0x1 10fb21: 68 45 50 49 50 push $0x50495045 10fb26: e8 b9 be ff ff call 10b9e4 10fb2b: 89 c3 mov %eax,%ebx 10fb2d: 83 c4 20 add $0x20,%esp } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10fb30: 83 ec 0c sub $0xc,%esp 10fb33: ff 35 00 72 12 00 pushl 0x127200 10fb39: e8 ba c1 ff ff call 10bcf8 } rtems_libio_unlock(); } if (sc == RTEMS_SUCCESSFUL) { 10fb3e: 83 c4 10 add $0x10,%esp 10fb41: 85 db test %ebx,%ebx 10fb43: 75 19 jne 10fb5e sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 10fb45: 51 push %ecx 10fb46: 6a 00 push $0x0 10fb48: 6a 00 push $0x0 10fb4a: ff 35 00 70 12 00 pushl 0x127000 10fb50: e8 b7 c0 ff ff call 10bc0c } if (sc == RTEMS_SUCCESSFUL) { 10fb55: 83 c4 10 add $0x10,%esp return 0; 10fb58: 31 f6 xor %esi,%esi if (sc == RTEMS_SUCCESSFUL) { sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); } if (sc == RTEMS_SUCCESSFUL) { 10fb5a: 85 c0 test %eax,%eax 10fb5c: 74 05 je 10fb63 <== ALWAYS TAKEN return 0; } else { return -ENOMEM; 10fb5e: be f4 ff ff ff mov $0xfffffff4,%esi { pipe_control_t *pipe; int err = 0; err = pipe_lock(); if (err) 10fb63: 85 f6 test %esi,%esi 10fb65: 0f 85 37 03 00 00 jne 10fea2 return err; pipe = *pipep; 10fb6b: 8b 45 08 mov 0x8(%ebp),%eax 10fb6e: 8b 18 mov (%eax),%ebx if (pipe == NULL) { 10fb70: 85 db test %ebx,%ebx 10fb72: 0f 85 56 01 00 00 jne 10fcce { static char c = 'a'; pipe_control_t *pipe; int err = -ENOMEM; pipe = malloc(sizeof(pipe_control_t)); 10fb78: 83 ec 0c sub $0xc,%esp 10fb7b: 6a 34 push $0x34 10fb7d: e8 2e 94 ff ff call 108fb0 10fb82: 89 c3 mov %eax,%ebx 10fb84: 89 45 d4 mov %eax,-0x2c(%ebp) if (pipe == NULL) 10fb87: 83 c4 10 add $0x10,%esp 10fb8a: 85 c0 test %eax,%eax 10fb8c: 0f 84 35 01 00 00 je 10fcc7 return err; memset(pipe, 0, sizeof(pipe_control_t)); 10fb92: b9 0d 00 00 00 mov $0xd,%ecx 10fb97: 89 c7 mov %eax,%edi 10fb99: 89 f0 mov %esi,%eax 10fb9b: f3 ab rep stos %eax,%es:(%edi) pipe->Size = PIPE_BUF; 10fb9d: c7 43 04 00 02 00 00 movl $0x200,0x4(%ebx) pipe->Buffer = malloc(pipe->Size); 10fba4: 83 ec 0c sub $0xc,%esp 10fba7: 68 00 02 00 00 push $0x200 10fbac: e8 ff 93 ff ff call 108fb0 10fbb1: 89 03 mov %eax,(%ebx) if (! pipe->Buffer) 10fbb3: 83 c4 10 add $0x10,%esp 10fbb6: 85 c0 test %eax,%eax 10fbb8: 0f 84 fb 00 00 00 je 10fcb9 <== NEVER TAKEN goto err_buf; err = -ENOMEM; if (rtems_barrier_create( 10fbbe: 8d 43 2c lea 0x2c(%ebx),%eax 10fbc1: 50 push %eax 10fbc2: 6a 00 push $0x0 10fbc4: 6a 00 push $0x0 rtems_build_name ('P', 'I', 'r', c), 10fbc6: 0f be 05 88 50 12 00 movsbl 0x125088,%eax if (! pipe->Buffer) goto err_buf; err = -ENOMEM; if (rtems_barrier_create( 10fbcd: 0d 00 72 49 50 or $0x50497200,%eax 10fbd2: 50 push %eax 10fbd3: e8 40 18 00 00 call 111418 10fbd8: 83 c4 10 add $0x10,%esp 10fbdb: 85 c0 test %eax,%eax 10fbdd: 0f 85 c6 00 00 00 jne 10fca9 rtems_build_name ('P', 'I', 'r', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->readBarrier) != RTEMS_SUCCESSFUL) goto err_rbar; if (rtems_barrier_create( 10fbe3: 8d 43 30 lea 0x30(%ebx),%eax 10fbe6: 50 push %eax 10fbe7: 6a 00 push $0x0 10fbe9: 6a 00 push $0x0 rtems_build_name ('P', 'I', 'w', c), 10fbeb: 0f be 05 88 50 12 00 movsbl 0x125088,%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( 10fbf2: 0d 00 77 49 50 or $0x50497700,%eax 10fbf7: 50 push %eax 10fbf8: e8 1b 18 00 00 call 111418 10fbfd: 83 c4 10 add $0x10,%esp 10fc00: 85 c0 test %eax,%eax 10fc02: 0f 85 90 00 00 00 jne 10fc98 rtems_build_name ('P', 'I', 'w', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->writeBarrier) != RTEMS_SUCCESSFUL) goto err_wbar; if (rtems_semaphore_create( 10fc08: 83 ec 0c sub $0xc,%esp 10fc0b: 8d 43 28 lea 0x28(%ebx),%eax 10fc0e: 50 push %eax 10fc0f: 6a 00 push $0x0 10fc11: 6a 10 push $0x10 10fc13: 6a 01 push $0x1 rtems_build_name ('P', 'I', 's', c), 1, 10fc15: 0f be 05 88 50 12 00 movsbl 0x125088,%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( 10fc1c: 0d 00 73 49 50 or $0x50497300,%eax 10fc21: 50 push %eax 10fc22: e8 bd bd ff ff call 10b9e4 10fc27: 83 c4 20 add $0x20,%esp 10fc2a: 85 c0 test %eax,%eax 10fc2c: 75 59 jne 10fc87 Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) _Objects_Get( &_Barrier_Information, id, location ); 10fc2e: 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 10fc2f: 8d 7d e0 lea -0x20(%ebp),%edi 10fc32: 57 push %edi 10fc33: ff 73 2c pushl 0x2c(%ebx) 10fc36: 68 5c 7c 12 00 push $0x127c5c 10fc3b: e8 18 d5 ff ff call 10d158 <_Objects_Get> |= STATES_INTERRUPTIBLE_BY_SIGNAL; 10fc40: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax) _Thread_Enable_dispatch(); 10fc47: e8 1a df ff ff call 10db66 <_Thread_Enable_dispatch> 10fc4c: 83 c4 0c add $0xc,%esp 10fc4f: 57 push %edi 10fc50: ff 73 30 pushl 0x30(%ebx) 10fc53: 68 5c 7c 12 00 push $0x127c5c 10fc58: e8 fb d4 ff ff call 10d158 <_Objects_Get> _Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state |= STATES_INTERRUPTIBLE_BY_SIGNAL; 10fc5d: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax) _Thread_Enable_dispatch(); 10fc64: e8 fd de ff ff call 10db66 <_Thread_Enable_dispatch> #ifdef RTEMS_POSIX_API pipe_interruptible(pipe); #endif *pipep = pipe; if (c ++ == 'z') 10fc69: a0 88 50 12 00 mov 0x125088,%al 10fc6e: 8d 50 01 lea 0x1(%eax),%edx 10fc71: 88 15 88 50 12 00 mov %dl,0x125088 10fc77: 83 c4 10 add $0x10,%esp 10fc7a: 3c 7a cmp $0x7a,%al 10fc7c: 75 50 jne 10fcce c = 'a'; 10fc7e: c6 05 88 50 12 00 61 movb $0x61,0x125088 10fc85: eb 47 jmp 10fcce return 0; err_sem: rtems_barrier_delete(pipe->writeBarrier); 10fc87: 83 ec 0c sub $0xc,%esp 10fc8a: 8b 55 d4 mov -0x2c(%ebp),%edx 10fc8d: ff 72 30 pushl 0x30(%edx) 10fc90: e8 3b 18 00 00 call 1114d0 10fc95: 83 c4 10 add $0x10,%esp err_wbar: rtems_barrier_delete(pipe->readBarrier); 10fc98: 83 ec 0c sub $0xc,%esp 10fc9b: 8b 45 d4 mov -0x2c(%ebp),%eax 10fc9e: ff 70 2c pushl 0x2c(%eax) 10fca1: e8 2a 18 00 00 call 1114d0 10fca6: 83 c4 10 add $0x10,%esp err_rbar: free(pipe->Buffer); 10fca9: 83 ec 0c sub $0xc,%esp 10fcac: 8b 55 d4 mov -0x2c(%ebp),%edx 10fcaf: ff 32 pushl (%edx) 10fcb1: e8 d6 8c ff ff call 10898c 10fcb6: 83 c4 10 add $0x10,%esp err_buf: free(pipe); 10fcb9: 83 ec 0c sub $0xc,%esp 10fcbc: ff 75 d4 pushl -0x2c(%ebp) 10fcbf: e8 c8 8c ff ff call 10898c 10fcc4: 83 c4 10 add $0x10,%esp if (err) goto out; } if (! PIPE_LOCK(pipe)) err = -EINTR; 10fcc7: be f4 ff ff ff mov $0xfffffff4,%esi 10fccc: eb 33 jmp 10fd01 err = pipe_alloc(&pipe); if (err) goto out; } if (! PIPE_LOCK(pipe)) 10fcce: 50 push %eax 10fccf: 6a 00 push $0x0 10fcd1: 6a 00 push $0x0 10fcd3: ff 73 28 pushl 0x28(%ebx) 10fcd6: e8 31 bf ff ff call 10bc0c 10fcdb: 83 c4 10 add $0x10,%esp 10fcde: 85 c0 test %eax,%eax 10fce0: 74 05 je 10fce7 <== ALWAYS TAKEN err = -EINTR; 10fce2: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED if (*pipep == NULL) { 10fce7: 8b 45 08 mov 0x8(%ebp),%eax 10fcea: 83 38 00 cmpl $0x0,(%eax) 10fced: 75 12 jne 10fd01 if (err) 10fcef: 85 f6 test %esi,%esi 10fcf1: 74 09 je 10fcfc <== ALWAYS TAKEN pipe_free(pipe); 10fcf3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10fcf5: e8 1c fd ff ff call 10fa16 <== NOT EXECUTED 10fcfa: eb 05 jmp 10fd01 <== NOT EXECUTED else *pipep = pipe; 10fcfc: 8b 55 08 mov 0x8(%ebp),%edx 10fcff: 89 1a mov %ebx,(%edx) } out: pipe_unlock(); 10fd01: e8 fa fc ff ff call 10fa00 pipe_control_t *pipe; unsigned int prevCounter; int err; err = pipe_new(pipep); if (err) 10fd06: 85 f6 test %esi,%esi 10fd08: 0f 85 94 01 00 00 jne 10fea2 return err; pipe = *pipep; 10fd0e: 8b 45 08 mov 0x8(%ebp),%eax 10fd11: 8b 18 mov (%eax),%ebx switch (LIBIO_ACCMODE(iop)) { 10fd13: 8b 55 0c mov 0xc(%ebp),%edx 10fd16: 8b 42 14 mov 0x14(%edx),%eax 10fd19: 83 e0 06 and $0x6,%eax 10fd1c: 83 f8 04 cmp $0x4,%eax 10fd1f: 0f 84 91 00 00 00 je 10fdb6 10fd25: 83 f8 06 cmp $0x6,%eax 10fd28: 0f 84 10 01 00 00 je 10fe3e 10fd2e: 83 f8 02 cmp $0x2,%eax 10fd31: 0f 85 49 01 00 00 jne 10fe80 <== NEVER TAKEN case LIBIO_FLAGS_READ: pipe->readerCounter ++; 10fd37: ff 43 20 incl 0x20(%ebx) if (pipe->Readers ++ == 0) 10fd3a: 8b 43 10 mov 0x10(%ebx),%eax 10fd3d: 8d 50 01 lea 0x1(%eax),%edx 10fd40: 89 53 10 mov %edx,0x10(%ebx) 10fd43: 85 c0 test %eax,%eax 10fd45: 75 11 jne 10fd58 <== NEVER TAKEN PIPE_WAKEUPWRITERS(pipe); 10fd47: 57 push %edi 10fd48: 57 push %edi 10fd49: 8d 45 e4 lea -0x1c(%ebp),%eax 10fd4c: 50 push %eax 10fd4d: ff 73 30 pushl 0x30(%ebx) 10fd50: e8 03 18 00 00 call 111558 10fd55: 83 c4 10 add $0x10,%esp if (pipe->Writers == 0) { 10fd58: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10fd5c: 0f 85 1e 01 00 00 jne 10fe80 /* Not an error */ if (LIBIO_NODELAY(iop)) 10fd62: 8b 45 0c mov 0xc(%ebp),%eax 10fd65: f6 40 14 01 testb $0x1,0x14(%eax) 10fd69: 0f 85 11 01 00 00 jne 10fe80 break; prevCounter = pipe->writerCounter; 10fd6f: 8b 7b 24 mov 0x24(%ebx),%edi err = -EINTR; /* Wait until a writer opens the pipe */ do { PIPE_UNLOCK(pipe); 10fd72: 83 ec 0c sub $0xc,%esp 10fd75: ff 73 28 pushl 0x28(%ebx) 10fd78: e8 7b bf ff ff call 10bcf8 if (! PIPE_READWAIT(pipe)) 10fd7d: 5a pop %edx 10fd7e: 59 pop %ecx 10fd7f: 6a 00 push $0x0 10fd81: ff 73 2c pushl 0x2c(%ebx) 10fd84: e8 27 18 00 00 call 1115b0 10fd89: 83 c4 10 add $0x10,%esp 10fd8c: 85 c0 test %eax,%eax 10fd8e: 0f 85 f9 00 00 00 jne 10fe8d <== NEVER TAKEN goto out_error; if (! PIPE_LOCK(pipe)) 10fd94: 50 push %eax 10fd95: 6a 00 push $0x0 10fd97: 6a 00 push $0x0 10fd99: ff 73 28 pushl 0x28(%ebx) 10fd9c: e8 6b be ff ff call 10bc0c 10fda1: 83 c4 10 add $0x10,%esp 10fda4: 85 c0 test %eax,%eax 10fda6: 0f 85 e1 00 00 00 jne 10fe8d <== NEVER TAKEN goto out_error; } while (prevCounter == pipe->writerCounter); 10fdac: 3b 7b 24 cmp 0x24(%ebx),%edi 10fdaf: 74 c1 je 10fd72 <== NEVER TAKEN 10fdb1: e9 ca 00 00 00 jmp 10fe80 } break; case LIBIO_FLAGS_WRITE: pipe->writerCounter ++; 10fdb6: ff 43 24 incl 0x24(%ebx) if (pipe->Writers ++ == 0) 10fdb9: 8b 43 14 mov 0x14(%ebx),%eax 10fdbc: 8d 50 01 lea 0x1(%eax),%edx 10fdbf: 89 53 14 mov %edx,0x14(%ebx) 10fdc2: 85 c0 test %eax,%eax 10fdc4: 75 11 jne 10fdd7 <== NEVER TAKEN PIPE_WAKEUPREADERS(pipe); 10fdc6: 57 push %edi 10fdc7: 57 push %edi 10fdc8: 8d 45 e4 lea -0x1c(%ebp),%eax 10fdcb: 50 push %eax 10fdcc: ff 73 2c pushl 0x2c(%ebx) 10fdcf: e8 84 17 00 00 call 111558 10fdd4: 83 c4 10 add $0x10,%esp if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) { 10fdd7: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10fddb: 0f 85 9f 00 00 00 jne 10fe80 10fde1: 8b 55 0c mov 0xc(%ebp),%edx 10fde4: f6 42 14 01 testb $0x1,0x14(%edx) 10fde8: 74 18 je 10fe02 PIPE_UNLOCK(pipe); 10fdea: 83 ec 0c sub $0xc,%esp 10fded: ff 73 28 pushl 0x28(%ebx) 10fdf0: e8 03 bf ff ff call 10bcf8 err = -ENXIO; goto out_error; 10fdf5: 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; 10fdf8: be fa ff ff ff mov $0xfffffffa,%esi goto out_error; 10fdfd: e9 90 00 00 00 jmp 10fe92 } if (pipe->Readers == 0) { prevCounter = pipe->readerCounter; 10fe02: 8b 7b 20 mov 0x20(%ebx),%edi err = -EINTR; do { PIPE_UNLOCK(pipe); 10fe05: 83 ec 0c sub $0xc,%esp 10fe08: ff 73 28 pushl 0x28(%ebx) 10fe0b: e8 e8 be ff ff call 10bcf8 if (! PIPE_WRITEWAIT(pipe)) 10fe10: 5a pop %edx 10fe11: 59 pop %ecx 10fe12: 6a 00 push $0x0 10fe14: ff 73 30 pushl 0x30(%ebx) 10fe17: e8 94 17 00 00 call 1115b0 10fe1c: 83 c4 10 add $0x10,%esp 10fe1f: 85 c0 test %eax,%eax 10fe21: 75 6a jne 10fe8d <== NEVER TAKEN goto out_error; if (! PIPE_LOCK(pipe)) 10fe23: 50 push %eax 10fe24: 6a 00 push $0x0 10fe26: 6a 00 push $0x0 10fe28: ff 73 28 pushl 0x28(%ebx) 10fe2b: e8 dc bd ff ff call 10bc0c 10fe30: 83 c4 10 add $0x10,%esp 10fe33: 85 c0 test %eax,%eax 10fe35: 75 56 jne 10fe8d <== NEVER TAKEN goto out_error; } while (prevCounter == pipe->readerCounter); 10fe37: 3b 7b 20 cmp 0x20(%ebx),%edi 10fe3a: 74 c9 je 10fe05 <== NEVER TAKEN 10fe3c: eb 42 jmp 10fe80 } break; case LIBIO_FLAGS_READ_WRITE: pipe->readerCounter ++; 10fe3e: ff 43 20 incl 0x20(%ebx) if (pipe->Readers ++ == 0) 10fe41: 8b 43 10 mov 0x10(%ebx),%eax 10fe44: 8d 50 01 lea 0x1(%eax),%edx 10fe47: 89 53 10 mov %edx,0x10(%ebx) 10fe4a: 85 c0 test %eax,%eax 10fe4c: 75 11 jne 10fe5f <== NEVER TAKEN PIPE_WAKEUPWRITERS(pipe); 10fe4e: 51 push %ecx 10fe4f: 51 push %ecx 10fe50: 8d 45 e4 lea -0x1c(%ebp),%eax 10fe53: 50 push %eax 10fe54: ff 73 30 pushl 0x30(%ebx) 10fe57: e8 fc 16 00 00 call 111558 10fe5c: 83 c4 10 add $0x10,%esp pipe->writerCounter ++; 10fe5f: ff 43 24 incl 0x24(%ebx) if (pipe->Writers ++ == 0) 10fe62: 8b 43 14 mov 0x14(%ebx),%eax 10fe65: 8d 50 01 lea 0x1(%eax),%edx 10fe68: 89 53 14 mov %edx,0x14(%ebx) 10fe6b: 85 c0 test %eax,%eax 10fe6d: 75 11 jne 10fe80 <== NEVER TAKEN PIPE_WAKEUPREADERS(pipe); 10fe6f: 52 push %edx 10fe70: 52 push %edx 10fe71: 8d 45 e4 lea -0x1c(%ebp),%eax 10fe74: 50 push %eax 10fe75: ff 73 2c pushl 0x2c(%ebx) 10fe78: e8 db 16 00 00 call 111558 10fe7d: 83 c4 10 add $0x10,%esp break; } PIPE_UNLOCK(pipe); 10fe80: 83 ec 0c sub $0xc,%esp 10fe83: ff 73 28 pushl 0x28(%ebx) 10fe86: e8 6d be ff ff call 10bcf8 10fe8b: eb 12 jmp 10fe9f goto out_error; } if (pipe->Readers == 0) { prevCounter = pipe->readerCounter; err = -EINTR; 10fe8d: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED PIPE_UNLOCK(pipe); return 0; out_error: pipe_release(pipep, iop); 10fe92: 50 push %eax 10fe93: 50 push %eax 10fe94: ff 75 0c pushl 0xc(%ebp) 10fe97: ff 75 08 pushl 0x8(%ebp) 10fe9a: e8 b2 fb ff ff call 10fa51 return err; 10fe9f: 83 c4 10 add $0x10,%esp } 10fea2: 89 f0 mov %esi,%eax 10fea4: 8d 65 f4 lea -0xc(%ebp),%esp 10fea7: 5b pop %ebx 10fea8: 5e pop %esi 10fea9: 5f pop %edi 10feaa: c9 leave 10feab: c3 ret =============================================================================== 00107d7c : long fpathconf( int fd, int name ) { 107d7c: 55 push %ebp 107d7d: 89 e5 mov %esp,%ebp 107d7f: 83 ec 08 sub $0x8,%esp 107d82: 8b 45 08 mov 0x8(%ebp),%eax 107d85: 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); 107d88: 3b 05 44 21 12 00 cmp 0x122144,%eax 107d8e: 73 11 jae 107da1 iop = rtems_libio_iop(fd); 107d90: 6b c0 38 imul $0x38,%eax,%eax 107d93: 03 05 d8 61 12 00 add 0x1261d8,%eax rtems_libio_check_is_open(iop); 107d99: 8b 48 14 mov 0x14(%eax),%ecx 107d9c: f6 c5 01 test $0x1,%ch 107d9f: 75 0d jne 107dae <== ALWAYS TAKEN 107da1: e8 0e a2 00 00 call 111fb4 <__errno> 107da6: c7 00 09 00 00 00 movl $0x9,(%eax) 107dac: eb 5b jmp 107e09 rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ); 107dae: 80 e1 02 and $0x2,%cl 107db1: 74 4b je 107dfe /* * Now process the information request. */ the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options; 107db3: 8b 40 28 mov 0x28(%eax),%eax switch ( name ) { 107db6: 83 fa 0b cmp $0xb,%edx 107db9: 77 43 ja 107dfe 107dbb: ff 24 95 b8 08 12 00 jmp *0x1208b8(,%edx,4) case _PC_LINK_MAX: return_value = the_limits->link_max; 107dc2: 8b 40 38 mov 0x38(%eax),%eax break; 107dc5: eb 45 jmp 107e0c case _PC_MAX_CANON: return_value = the_limits->max_canon; 107dc7: 8b 40 3c mov 0x3c(%eax),%eax break; 107dca: eb 40 jmp 107e0c case _PC_MAX_INPUT: return_value = the_limits->max_input; 107dcc: 8b 40 40 mov 0x40(%eax),%eax break; 107dcf: eb 3b jmp 107e0c case _PC_NAME_MAX: return_value = the_limits->name_max; 107dd1: 8b 40 44 mov 0x44(%eax),%eax break; 107dd4: eb 36 jmp 107e0c case _PC_PATH_MAX: return_value = the_limits->path_max; 107dd6: 8b 40 48 mov 0x48(%eax),%eax break; 107dd9: eb 31 jmp 107e0c case _PC_PIPE_BUF: return_value = the_limits->pipe_buf; 107ddb: 8b 40 4c mov 0x4c(%eax),%eax break; 107dde: eb 2c jmp 107e0c case _PC_CHOWN_RESTRICTED: return_value = the_limits->posix_chown_restrictions; 107de0: 8b 40 54 mov 0x54(%eax),%eax break; 107de3: eb 27 jmp 107e0c case _PC_NO_TRUNC: return_value = the_limits->posix_no_trunc; 107de5: 8b 40 58 mov 0x58(%eax),%eax break; 107de8: eb 22 jmp 107e0c case _PC_VDISABLE: return_value = the_limits->posix_vdisable; 107dea: 8b 40 64 mov 0x64(%eax),%eax break; 107ded: eb 1d jmp 107e0c case _PC_ASYNC_IO: return_value = the_limits->posix_async_io; 107def: 8b 40 50 mov 0x50(%eax),%eax break; 107df2: eb 18 jmp 107e0c case _PC_PRIO_IO: return_value = the_limits->posix_prio_io; 107df4: 8b 40 5c mov 0x5c(%eax),%eax break; 107df7: eb 13 jmp 107e0c case _PC_SYNC_IO: return_value = the_limits->posix_sync_io; 107df9: 8b 40 60 mov 0x60(%eax),%eax break; 107dfc: eb 0e jmp 107e0c default: rtems_set_errno_and_return_minus_one( EINVAL ); 107dfe: e8 b1 a1 00 00 call 111fb4 <__errno> 107e03: c7 00 16 00 00 00 movl $0x16,(%eax) 107e09: 83 c8 ff or $0xffffffff,%eax break; } return return_value; } 107e0c: c9 leave 107e0d: c3 ret =============================================================================== 00107348 : #include void free( void *ptr ) { 107348: 55 push %ebp 107349: 89 e5 mov %esp,%ebp 10734b: 53 push %ebx 10734c: 83 ec 04 sub $0x4,%esp 10734f: 8b 5d 08 mov 0x8(%ebp),%ebx MSBUMP(free_calls, 1); 107352: ff 05 fc 51 12 00 incl 0x1251fc if ( !ptr ) 107358: 85 db test %ebx,%ebx 10735a: 74 5f je 1073bb return; /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 10735c: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c 107363: 75 15 jne 10737a <== NEVER TAKEN !malloc_is_system_state_OK() ) { 107365: e8 56 01 00 00 call 1074c0 return; /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 10736a: 84 c0 test %al,%al 10736c: 75 0c jne 10737a !malloc_is_system_state_OK() ) { malloc_deferred_free(ptr); 10736e: 89 5d 08 mov %ebx,0x8(%ebp) RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end ); } } 107371: 8b 5d fc mov -0x4(%ebp),%ebx 107374: 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); 107375: e9 ae 01 00 00 jmp 107528 } /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 10737a: a1 50 36 12 00 mov 0x123650,%eax 10737f: 85 c0 test %eax,%eax 107381: 74 0a je 10738d (*rtems_malloc_statistics_helpers->at_free)(ptr); 107383: 83 ec 0c sub $0xc,%esp 107386: 53 push %ebx 107387: ff 50 08 call *0x8(%eax) 10738a: 83 c4 10 add $0x10,%esp if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) { 10738d: 50 push %eax 10738e: 50 push %eax 10738f: 53 push %ebx 107390: ff 35 50 11 12 00 pushl 0x121150 107396: e8 1d 46 00 00 call 10b9b8 <_Protected_heap_Free> 10739b: 83 c4 10 add $0x10,%esp 10739e: 84 c0 test %al,%al 1073a0: 75 19 jne 1073bb printk( "Program heap: free of bad pointer %p -- range %p - %p \n", ptr, RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end 1073a2: a1 50 11 12 00 mov 0x121150,%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", 1073a7: ff 70 1c pushl 0x1c(%eax) 1073aa: ff 70 18 pushl 0x18(%eax) 1073ad: 53 push %ebx 1073ae: 68 63 ef 11 00 push $0x11ef63 1073b3: e8 d8 0b 00 00 call 107f90 1073b8: 83 c4 10 add $0x10,%esp RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end ); } } 1073bb: 8b 5d fc mov -0x4(%ebp),%ebx 1073be: c9 leave 1073bf: c3 ret =============================================================================== 001085c0 : * NOTE: this must be called with * thread dispatching disabled! */ static void free_user_env(void *venv) { 1085c0: 55 push %ebp 1085c1: 89 e5 mov %esp,%ebp 1085c3: 53 push %ebx 1085c4: 83 ec 04 sub $0x4,%esp 1085c7: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_user_env_t *env = (rtems_user_env_t*) venv ; if (env != &rtems_global_user_env 1085ca: 81 fb 08 52 12 00 cmp $0x125208,%ebx 1085d0: 74 26 je 1085f8 <== NEVER TAKEN #ifdef HAVE_USERENV_REFCNT && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); 1085d2: 83 ec 0c sub $0xc,%esp 1085d5: 8d 43 04 lea 0x4(%ebx),%eax 1085d8: 50 push %eax 1085d9: e8 6a f1 ff ff call 107748 rtems_filesystem_freenode( &env->root_directory); 1085de: 8d 43 18 lea 0x18(%ebx),%eax 1085e1: 89 04 24 mov %eax,(%esp) 1085e4: e8 5f f1 ff ff call 107748 free(env); 1085e9: 83 c4 10 add $0x10,%esp 1085ec: 89 5d 08 mov %ebx,0x8(%ebp) } } 1085ef: 8b 5d fc mov -0x4(%ebp),%ebx 1085f2: c9 leave && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); rtems_filesystem_freenode( &env->root_directory); free(env); 1085f3: e9 64 f1 ff ff jmp 10775c } } 1085f8: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1085fb: c9 leave <== NOT EXECUTED 1085fc: c3 ret <== NOT EXECUTED =============================================================================== 0011e7b8 : int getdents( int dd_fd, char *dd_buf, int dd_len ) { 11e7b8: 55 push %ebp 11e7b9: 89 e5 mov %esp,%ebp 11e7bb: 57 push %edi 11e7bc: 56 push %esi 11e7bd: 53 push %ebx 11e7be: 83 ec 2c sub $0x2c,%esp 11e7c1: 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 ); 11e7c4: 31 db xor %ebx,%ebx 11e7c6: 3b 05 44 31 12 00 cmp 0x123144,%eax 11e7cc: 73 09 jae 11e7d7 <== NEVER TAKEN 11e7ce: 6b d8 38 imul $0x38,%eax,%ebx 11e7d1: 03 1d 00 73 12 00 add 0x127300,%ebx /* * Make sure we are working on a directory */ loc = iop->pathinfo; 11e7d7: 8d 7d d4 lea -0x2c(%ebp),%edi 11e7da: 8d 73 18 lea 0x18(%ebx),%esi 11e7dd: b9 05 00 00 00 mov $0x5,%ecx 11e7e2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) 11e7e4: 83 ec 0c sub $0xc,%esp 11e7e7: 8d 45 d4 lea -0x2c(%ebp),%eax 11e7ea: 50 push %eax 11e7eb: 8b 45 e0 mov -0x20(%ebp),%eax 11e7ee: ff 50 10 call *0x10(%eax) 11e7f1: 83 c4 10 add $0x10,%esp 11e7f4: 48 dec %eax 11e7f5: 74 10 je 11e807 rtems_set_errno_and_return_minus_one( ENOTDIR ); 11e7f7: e8 d8 38 ff ff call 1120d4 <__errno> 11e7fc: c7 00 14 00 00 00 movl $0x14,(%eax) 11e802: 83 c8 ff or $0xffffffff,%eax 11e805: eb 11 jmp 11e818 /* * 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 ); 11e807: 50 push %eax 11e808: 8b 43 20 mov 0x20(%ebx),%eax 11e80b: ff 75 10 pushl 0x10(%ebp) 11e80e: ff 75 0c pushl 0xc(%ebp) 11e811: 53 push %ebx 11e812: ff 50 08 call *0x8(%eax) 11e815: 83 c4 10 add $0x10,%esp } 11e818: 8d 65 f4 lea -0xc(%ebp),%esp 11e81b: 5b pop %ebx 11e81c: 5e pop %esi 11e81d: 5f pop %edi 11e81e: c9 leave 11e81f: c3 ret =============================================================================== 00110724 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 110724: 55 push %ebp 110725: 89 e5 mov %esp,%ebp 110727: 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 ) 11072a: 8b 4a 18 mov 0x18(%edx),%ecx return -1; /* It wasn't a directory --> return error */ 11072d: 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 ) 110730: 83 79 4c 01 cmpl $0x1,0x4c(%ecx) 110734: 75 10 jne 110746 <== NEVER TAKEN return -1; /* It wasn't a directory --> return error */ iop->offset = 0; 110736: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) 11073d: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) return 0; 110744: 31 c0 xor %eax,%eax } 110746: c9 leave 110747: c3 ret =============================================================================== 0011098d : int imfs_dir_rmnod( rtems_filesystem_location_info_t *parent_pathloc, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN */ ) { 11098d: 55 push %ebp 11098e: 89 e5 mov %esp,%ebp 110990: 53 push %ebx 110991: 83 ec 04 sub $0x4,%esp 110994: 8b 45 0c mov 0xc(%ebp),%eax IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 110997: 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 ); 110999: 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 ) ) 11099c: 39 53 50 cmp %edx,0x50(%ebx) 11099f: 74 0d je 1109ae rtems_set_errno_and_return_minus_one( ENOTEMPTY ); 1109a1: e8 a6 07 00 00 call 11114c <__errno> 1109a6: c7 00 5a 00 00 00 movl $0x5a,(%eax) 1109ac: eb 13 jmp 1109c1 /* * You cannot remove the file system root node. */ if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access ) 1109ae: 8b 40 10 mov 0x10(%eax),%eax 1109b1: 39 58 1c cmp %ebx,0x1c(%eax) 1109b4: 75 10 jne 1109c6 rtems_set_errno_and_return_minus_one( EBUSY ); 1109b6: e8 91 07 00 00 call 11114c <__errno> 1109bb: c7 00 10 00 00 00 movl $0x10,(%eax) 1109c1: 83 c8 ff or $0xffffffff,%eax 1109c4: eb 1c jmp 1109e2 /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) 1109c6: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx) 1109ca: 75 ea jne 1109b6 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EBUSY ); IMFS_create_orphan( the_jnode ); 1109cc: 83 ec 0c sub $0xc,%esp 1109cf: 53 push %ebx 1109d0: e8 67 d4 ff ff call 10de3c IMFS_check_node_remove( the_jnode ); 1109d5: 89 1c 24 mov %ebx,(%esp) 1109d8: e8 a1 d4 ff ff call 10de7e return 0; 1109dd: 83 c4 10 add $0x10,%esp 1109e0: 31 c0 xor %eax,%eax } 1109e2: 8b 5d fc mov -0x4(%ebp),%ebx 1109e5: c9 leave 1109e6: c3 ret =============================================================================== 00107c6c : /* * Initialize useable but dummy databases */ void init_etc_passwd_group(void) { 107c6c: 55 push %ebp 107c6d: 89 e5 mov %esp,%ebp 107c6f: 53 push %ebx 107c70: 83 ec 04 sub $0x4,%esp FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) 107c73: 80 3d 5c 6d 12 00 00 cmpb $0x0,0x126d5c 107c7a: 0f 85 b8 00 00 00 jne 107d38 return; etc_passwd_initted = 1; 107c80: c6 05 5c 6d 12 00 01 movb $0x1,0x126d5c mkdir("/etc", 0777); 107c87: 50 push %eax 107c88: 50 push %eax 107c89: 68 ff 01 00 00 push $0x1ff 107c8e: 68 0f 08 12 00 push $0x12080f 107c93: e8 7c 07 00 00 call 108414 /* * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { 107c98: 59 pop %ecx 107c99: 5b pop %ebx 107c9a: 68 5a f5 11 00 push $0x11f55a 107c9f: 68 14 08 12 00 push $0x120814 107ca4: e8 8f aa 00 00 call 112738 107ca9: 83 c4 10 add $0x10,%esp 107cac: 85 c0 test %eax,%eax 107cae: 74 06 je 107cb6 fclose(fp); 107cb0: 83 ec 0c sub $0xc,%esp 107cb3: 50 push %eax 107cb4: eb 2a jmp 107ce0 } else if ((fp = fopen("/etc/passwd", "w")) != NULL) { 107cb6: 52 push %edx 107cb7: 52 push %edx 107cb8: 68 74 f4 11 00 push $0x11f474 107cbd: 68 14 08 12 00 push $0x120814 107cc2: e8 71 aa 00 00 call 112738 107cc7: 89 c3 mov %eax,%ebx 107cc9: 83 c4 10 add $0x10,%esp 107ccc: 85 c0 test %eax,%eax 107cce: 74 18 je 107ce8 <== NEVER TAKEN fprintf(fp, "root:*:0:0:root::/:/bin/sh\n" 107cd0: 50 push %eax 107cd1: 50 push %eax 107cd2: 53 push %ebx 107cd3: 68 20 08 12 00 push $0x120820 107cd8: e8 27 ab 00 00 call 112804 "rtems:*:1:1:RTEMS Application::/:/bin/sh\n" "tty:!:2:2:tty owner::/:/bin/false\n" ); fclose(fp); 107cdd: 89 1c 24 mov %ebx,(%esp) 107ce0: e8 4f a3 00 00 call 112034 107ce5: 83 c4 10 add $0x10,%esp } /* * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { 107ce8: 51 push %ecx 107ce9: 51 push %ecx 107cea: 68 5a f5 11 00 push $0x11f55a 107cef: 68 87 08 12 00 push $0x120887 107cf4: e8 3f aa 00 00 call 112738 107cf9: 83 c4 10 add $0x10,%esp 107cfc: 85 c0 test %eax,%eax 107cfe: 74 06 je 107d06 fclose(fp); 107d00: 83 ec 0c sub $0xc,%esp 107d03: 50 push %eax 107d04: eb 2a jmp 107d30 } else if ((fp = fopen("/etc/group", "w")) != NULL) { 107d06: 52 push %edx 107d07: 52 push %edx 107d08: 68 74 f4 11 00 push $0x11f474 107d0d: 68 87 08 12 00 push $0x120887 107d12: e8 21 aa 00 00 call 112738 107d17: 89 c3 mov %eax,%ebx 107d19: 83 c4 10 add $0x10,%esp 107d1c: 85 c0 test %eax,%eax 107d1e: 74 18 je 107d38 <== NEVER TAKEN fprintf( fp, "root:x:0:root\n" 107d20: 50 push %eax 107d21: 50 push %eax 107d22: 53 push %ebx 107d23: 68 92 08 12 00 push $0x120892 107d28: e8 d7 aa 00 00 call 112804 "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); 107d2d: 89 1c 24 mov %ebx,(%esp) 107d30: e8 ff a2 00 00 call 112034 107d35: 83 c4 10 add $0x10,%esp } } 107d38: 8b 5d fc mov -0x4(%ebp),%ebx 107d3b: c9 leave 107d3c: c3 ret =============================================================================== 00108e0c : /* * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) { 108e0c: 55 push %ebp 108e0d: 89 e5 mov %esp,%ebp 108e0f: 53 push %ebx 108e10: 83 ec 14 sub $0x14,%esp 108e13: 89 d3 mov %edx,%ebx 108e15: 88 c1 mov %al,%cl if (tty->termios.c_iflag & ISTRIP) 108e17: 8b 52 30 mov 0x30(%edx),%edx 108e1a: f6 c2 20 test $0x20,%dl 108e1d: 74 03 je 108e22 <== ALWAYS TAKEN c &= 0x7f; 108e1f: 83 e1 7f and $0x7f,%ecx <== NOT EXECUTED if (tty->termios.c_iflag & IUCLC) 108e22: f6 c6 02 test $0x2,%dh 108e25: 74 16 je 108e3d c = tolower (c); 108e27: 0f b6 c9 movzbl %cl,%ecx 108e2a: a1 1c 31 12 00 mov 0x12311c,%eax 108e2f: 0f be 44 08 01 movsbl 0x1(%eax,%ecx,1),%eax 108e34: 83 e0 03 and $0x3,%eax 108e37: 48 dec %eax 108e38: 75 03 jne 108e3d 108e3a: 83 c1 20 add $0x20,%ecx if (c == '\r') { 108e3d: 80 f9 0d cmp $0xd,%cl 108e40: 75 14 jne 108e56 if (tty->termios.c_iflag & IGNCR) return 0; 108e42: 31 c0 xor %eax,%eax if (tty->termios.c_iflag & IUCLC) c = tolower (c); if (c == '\r') { if (tty->termios.c_iflag & IGNCR) 108e44: f6 c2 80 test $0x80,%dl 108e47: 0f 85 d9 00 00 00 jne 108f26 <== NEVER TAKEN return 0; if (tty->termios.c_iflag & ICRNL) 108e4d: 80 e6 01 and $0x1,%dh 108e50: 74 1a je 108e6c <== NEVER TAKEN c = '\n'; 108e52: b1 0a mov $0xa,%cl 108e54: eb 16 jmp 108e6c } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { 108e56: 80 f9 0a cmp $0xa,%cl 108e59: 75 09 jne 108e64 108e5b: 80 e2 40 and $0x40,%dl 108e5e: 74 0c je 108e6c <== ALWAYS TAKEN c = '\r'; 108e60: b1 0d mov $0xd,%cl <== NOT EXECUTED 108e62: eb 08 jmp 108e6c <== NOT EXECUTED } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 108e64: 84 c9 test %cl,%cl 108e66: 0f 84 87 00 00 00 je 108ef3 <== NEVER TAKEN 108e6c: 8b 53 3c mov 0x3c(%ebx),%edx 108e6f: f6 c2 02 test $0x2,%dl 108e72: 74 7f je 108ef3 if (c == tty->termios.c_cc[VERASE]) { 108e74: 3a 4b 43 cmp 0x43(%ebx),%cl 108e77: 75 04 jne 108e7d erase (tty, 0); 108e79: 31 d2 xor %edx,%edx 108e7b: eb 0a jmp 108e87 return 0; } else if (c == tty->termios.c_cc[VKILL]) { 108e7d: 3a 4b 44 cmp 0x44(%ebx),%cl 108e80: 75 11 jne 108e93 erase (tty, 1); 108e82: ba 01 00 00 00 mov $0x1,%edx 108e87: 89 d8 mov %ebx,%eax 108e89: e8 05 fe ff ff call 108c93 108e8e: e9 91 00 00 00 jmp 108f24 return 0; } else if (c == tty->termios.c_cc[VEOF]) { return 1; 108e93: 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]) { 108e98: 3a 4b 45 cmp 0x45(%ebx),%cl 108e9b: 0f 84 85 00 00 00 je 108f26 <== NEVER TAKEN return 1; } else if (c == '\n') { 108ea1: 80 f9 0a cmp $0xa,%cl 108ea4: 75 1a jne 108ec0 if (tty->termios.c_lflag & (ECHO | ECHONL)) 108ea6: 80 e2 48 and $0x48,%dl 108ea9: 74 09 je 108eb4 <== NEVER TAKEN echo (c, tty); 108eab: 89 da mov %ebx,%edx 108ead: b0 0a mov $0xa,%al 108eaf: e8 87 fd ff ff call 108c3b tty->cbuf[tty->ccount++] = c; 108eb4: 8b 43 20 mov 0x20(%ebx),%eax 108eb7: 8b 53 1c mov 0x1c(%ebx),%edx 108eba: c6 04 02 0a movb $0xa,(%edx,%eax,1) 108ebe: eb 28 jmp 108ee8 return 1; } else if ((c == tty->termios.c_cc[VEOL]) || 108ec0: 3a 4b 4c cmp 0x4c(%ebx),%cl 108ec3: 74 05 je 108eca <== NEVER TAKEN 108ec5: 3a 4b 51 cmp 0x51(%ebx),%cl 108ec8: 75 29 jne 108ef3 <== ALWAYS TAKEN (c == tty->termios.c_cc[VEOL2])) { if (tty->termios.c_lflag & ECHO) 108eca: 80 e2 08 and $0x8,%dl <== NOT EXECUTED 108ecd: 74 10 je 108edf <== NOT EXECUTED echo (c, tty); 108ecf: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 108ed2: 89 da mov %ebx,%edx <== NOT EXECUTED 108ed4: 88 4d f4 mov %cl,-0xc(%ebp) <== NOT EXECUTED 108ed7: e8 5f fd ff ff call 108c3b <== NOT EXECUTED 108edc: 8a 4d f4 mov -0xc(%ebp),%cl <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 108edf: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 108ee2: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED 108ee5: 88 0c 02 mov %cl,(%edx,%eax,1) <== NOT EXECUTED 108ee8: 40 inc %eax 108ee9: 89 43 20 mov %eax,0x20(%ebx) return 1; 108eec: b8 01 00 00 00 mov $0x1,%eax 108ef1: eb 33 jmp 108f26 } /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { 108ef3: 8b 15 50 30 12 00 mov 0x123050,%edx 108ef9: 4a dec %edx if (tty->termios.c_lflag & ECHO) echo (c, tty); tty->cbuf[tty->ccount++] = c; } return 0; 108efa: 31 c0 xor %eax,%eax } /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { 108efc: 39 53 20 cmp %edx,0x20(%ebx) 108eff: 7d 25 jge 108f26 <== NEVER TAKEN if (tty->termios.c_lflag & ECHO) 108f01: f6 43 3c 08 testb $0x8,0x3c(%ebx) 108f05: 74 10 je 108f17 <== NEVER TAKEN echo (c, tty); 108f07: 0f b6 c1 movzbl %cl,%eax 108f0a: 89 da mov %ebx,%edx 108f0c: 88 4d f4 mov %cl,-0xc(%ebp) 108f0f: e8 27 fd ff ff call 108c3b 108f14: 8a 4d f4 mov -0xc(%ebp),%cl tty->cbuf[tty->ccount++] = c; 108f17: 8b 43 20 mov 0x20(%ebx),%eax 108f1a: 8b 53 1c mov 0x1c(%ebx),%edx 108f1d: 88 0c 02 mov %cl,(%edx,%eax,1) 108f20: 40 inc %eax 108f21: 89 43 20 mov %eax,0x20(%ebx) } return 0; 108f24: 31 c0 xor %eax,%eax } 108f26: 83 c4 14 add $0x14,%esp 108f29: 5b pop %ebx 108f2a: c9 leave 108f2b: c3 ret =============================================================================== 00121f78 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 121f78: 55 push %ebp 121f79: 89 e5 mov %esp,%ebp 121f7b: 57 push %edi 121f7c: 56 push %esi 121f7d: 53 push %ebx 121f7e: 83 ec 4c sub $0x4c,%esp 121f81: 8b 5d 0c mov 0xc(%ebp),%ebx 121f84: 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() ) 121f87: e8 64 fd ff ff call 121cf0 121f8c: 39 45 08 cmp %eax,0x8(%ebp) 121f8f: 74 0d je 121f9e rtems_set_errno_and_return_minus_one( ESRCH ); 121f91: e8 4e 3a ff ff call 1159e4 <__errno> 121f96: c7 00 03 00 00 00 movl $0x3,(%eax) 121f9c: eb 0f jmp 121fad /* * Validate the signal passed. */ if ( !sig ) 121f9e: 85 db test %ebx,%ebx 121fa0: 75 13 jne 121fb5 rtems_set_errno_and_return_minus_one( EINVAL ); 121fa2: e8 3d 3a ff ff call 1159e4 <__errno> 121fa7: c7 00 16 00 00 00 movl $0x16,(%eax) 121fad: 83 c8 ff or $0xffffffff,%eax 121fb0: e9 ef 01 00 00 jmp 1221a4 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 121fb5: 8d 4b ff lea -0x1(%ebx),%ecx if ( !is_valid_signo(sig) ) 121fb8: 83 f9 1f cmp $0x1f,%ecx 121fbb: 77 e5 ja 121fa2 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 ) 121fbd: 6b d3 0c imul $0xc,%ebx,%edx return 0; 121fc0: 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 ) 121fc2: 83 ba 18 ba 12 00 01 cmpl $0x1,0x12ba18(%edx) 121fc9: 0f 84 d5 01 00 00 je 1221a4 /* * 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 ) ) 121fcf: 83 fb 04 cmp $0x4,%ebx 121fd2: 74 0a je 121fde 121fd4: 83 fb 08 cmp $0x8,%ebx 121fd7: 74 05 je 121fde 121fd9: 83 fb 0b cmp $0xb,%ebx 121fdc: 75 16 jne 121ff4 return pthread_kill( pthread_self(), sig ); 121fde: e8 89 03 00 00 call 12236c 121fe3: 56 push %esi 121fe4: 56 push %esi 121fe5: 53 push %ebx 121fe6: 50 push %eax 121fe7: e8 d8 02 00 00 call 1222c4 121fec: 83 c4 10 add $0x10,%esp 121fef: e9 b0 01 00 00 jmp 1221a4 static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 121ff4: be 01 00 00 00 mov $0x1,%esi 121ff9: d3 e6 shl %cl,%esi /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 121ffb: 89 5d dc mov %ebx,-0x24(%ebp) siginfo->si_code = SI_USER; 121ffe: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) if ( !value ) { 122005: 85 ff test %edi,%edi 122007: 75 09 jne 122012 siginfo->si_value.sival_int = 0; 122009: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 122010: eb 05 jmp 122017 } else { siginfo->si_value = *value; 122012: 8b 07 mov (%edi),%eax 122014: 89 45 e4 mov %eax,-0x1c(%ebp) 122017: a1 94 b4 12 00 mov 0x12b494,%eax 12201c: 40 inc %eax 12201d: a3 94 b4 12 00 mov %eax,0x12b494 /* * 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; 122022: a1 dc b9 12 00 mov 0x12b9dc,%eax api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 122027: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx 12202d: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx 122033: f7 d2 not %edx 122035: 85 d6 test %edx,%esi 122037: 0f 85 ed 00 00 00 jne 12212a } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); return 0; } 12203d: 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 ); 122043: eb 23 jmp 122068 !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; 122045: 89 d0 mov %edx,%eax api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 122047: 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) 12204d: 85 72 30 test %esi,0x30(%edx) 122050: 0f 85 d4 00 00 00 jne 12212a /* * Is this thread is blocked waiting for another signal but has * not blocked this one? */ if (~api->signals_blocked & mask) 122056: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx 12205c: f7 d1 not %ecx 12205e: 85 ce test %ecx,%esi 122060: 0f 85 c4 00 00 00 jne 12212a 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 ) { 122066: 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 ); 122068: 81 fa a0 bb 12 00 cmp $0x12bba0,%edx 12206e: 75 d5 jne 122045 * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 122070: 0f b6 0d f4 71 12 00 movzbl 0x1271f4,%ecx 122077: 41 inc %ecx * * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; 122078: 31 c0 xor %eax,%eax interested_priority = PRIORITY_MAXIMUM + 1; for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { 12207a: 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 ] ) 122081: 8b 7d cc mov -0x34(%ebp),%edi 122084: 8b 14 bd 6c b4 12 00 mov 0x12b46c(,%edi,4),%edx 12208b: 85 d2 test %edx,%edx 12208d: 0f 84 86 00 00 00 je 122119 <== NEVER TAKEN continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 122093: 8b 52 04 mov 0x4(%edx),%edx */ if ( !the_info ) continue; #endif maximum = the_info->maximum; 122096: 0f b7 7a 10 movzwl 0x10(%edx),%edi 12209a: 89 7d c4 mov %edi,-0x3c(%ebp) object_table = the_info->local_table; 12209d: 8b 52 1c mov 0x1c(%edx),%edx 1220a0: 89 55 c0 mov %edx,-0x40(%ebp) for ( index = 1 ; index <= maximum ; index++ ) { 1220a3: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp) 1220aa: 89 5d b4 mov %ebx,-0x4c(%ebp) 1220ad: eb 5f jmp 12210e the_thread = (Thread_Control *) object_table[ index ]; 1220af: 8b 5d d0 mov -0x30(%ebp),%ebx 1220b2: 8b 7d c0 mov -0x40(%ebp),%edi 1220b5: 8b 14 9f mov (%edi,%ebx,4),%edx if ( !the_thread ) 1220b8: 85 d2 test %edx,%edx 1220ba: 74 4f je 12210b /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 1220bc: 8b 5a 14 mov 0x14(%edx),%ebx 1220bf: 89 5d d4 mov %ebx,-0x2c(%ebp) 1220c2: 39 cb cmp %ecx,%ebx 1220c4: 77 45 ja 12210b #if defined(RTEMS_DEBUG) if ( !api ) continue; #endif if ( !_POSIX_signals_Is_interested( api, mask ) ) 1220c6: 8b ba ec 00 00 00 mov 0xec(%edx),%edi 1220cc: 8b bf d0 00 00 00 mov 0xd0(%edi),%edi 1220d2: f7 d7 not %edi 1220d4: 85 fe test %edi,%esi 1220d6: 74 33 je 12210b * * 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 ) { 1220d8: 39 cb cmp %ecx,%ebx 1220da: 72 2a jb 122106 * and blocking interruptibutable by signal. * * If the interested thread is ready, don't think about changing. */ if ( interested && !_States_Is_ready( interested->current_state ) ) { 1220dc: 85 c0 test %eax,%eax 1220de: 74 2b je 12210b <== NEVER TAKEN 1220e0: 8b 78 10 mov 0x10(%eax),%edi 1220e3: 89 7d c8 mov %edi,-0x38(%ebp) 1220e6: 85 ff test %edi,%edi 1220e8: 74 21 je 12210b <== NEVER TAKEN /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 1220ea: 8b 7a 10 mov 0x10(%edx),%edi 1220ed: 85 ff test %edi,%edi 1220ef: 74 15 je 122106 continue; } DEBUG_STEP("6"); /* prefer blocked/interruptible over blocked/not interruptible */ if ( !_States_Is_interruptible_by_signal(interested->current_state) ) { 1220f1: f7 45 c8 00 00 00 10 testl $0x10000000,-0x38(%ebp) 1220f8: 75 11 jne 12210b DEBUG_STEP("7"); if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) { 1220fa: 81 e7 00 00 00 10 and $0x10000000,%edi 122100: 74 09 je 12210b 122102: 89 d9 mov %ebx,%ecx 122104: eb 03 jmp 122109 */ if ( interested && !_States_Is_ready( interested->current_state ) ) { /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 122106: 8b 4d d4 mov -0x2c(%ebp),%ecx 122109: 89 d0 mov %edx,%eax #endif maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 12210b: ff 45 d0 incl -0x30(%ebp) 12210e: 8b 55 c4 mov -0x3c(%ebp),%edx 122111: 39 55 d0 cmp %edx,-0x30(%ebp) 122114: 76 99 jbe 1220af 122116: 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++) { 122119: ff 45 cc incl -0x34(%ebp) 12211c: 83 7d cc 04 cmpl $0x4,-0x34(%ebp) 122120: 0f 85 5b ff ff ff jne 122081 } } } } if ( interested ) { 122126: 85 c0 test %eax,%eax 122128: 74 13 je 12213d /* * 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 ) ) { 12212a: 51 push %ecx mask = signo_to_mask( sig ); /* * Build up a siginfo structure */ siginfo = &siginfo_struct; 12212b: 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 ) ) { 12212e: 52 push %edx 12212f: 53 push %ebx 122130: 50 push %eax 122131: e8 8a 00 00 00 call 1221c0 <_POSIX_signals_Unblock_thread> 122136: 83 c4 10 add $0x10,%esp 122139: 84 c0 test %al,%al 12213b: 75 60 jne 12219d /* * 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 ); 12213d: 83 ec 0c sub $0xc,%esp 122140: 56 push %esi 122141: e8 66 00 00 00 call 1221ac <_POSIX_signals_Set_process_signals> if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 122146: 6b db 0c imul $0xc,%ebx,%ebx 122149: 83 c4 10 add $0x10,%esp 12214c: 83 bb 10 ba 12 00 02 cmpl $0x2,0x12ba10(%ebx) 122153: 75 48 jne 12219d psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get( &_POSIX_signals_Inactive_siginfo ); 122155: 83 ec 0c sub $0xc,%esp 122158: 68 90 bb 12 00 push $0x12bb90 12215d: e8 da cf fe ff call 10f13c <_Chain_Get> if ( !psiginfo ) { 122162: 83 c4 10 add $0x10,%esp 122165: 85 c0 test %eax,%eax 122167: 75 15 jne 12217e _Thread_Enable_dispatch(); 122169: e8 28 e7 fe ff call 110896 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 12216e: e8 71 38 ff ff call 1159e4 <__errno> 122173: c7 00 0b 00 00 00 movl $0xb,(%eax) 122179: e9 2f fe ff ff jmp 121fad } psiginfo->Info = *siginfo; 12217e: 8d 78 08 lea 0x8(%eax),%edi 122181: 8d 75 dc lea -0x24(%ebp),%esi 122184: b9 03 00 00 00 mov $0x3,%ecx 122189: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 12218b: 52 push %edx 12218c: 52 push %edx 12218d: 50 push %eax 12218e: 81 c3 08 bc 12 00 add $0x12bc08,%ebx 122194: 53 push %ebx 122195: e8 66 cf fe ff call 10f100 <_Chain_Append> 12219a: 83 c4 10 add $0x10,%esp } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); 12219d: e8 f4 e6 fe ff call 110896 <_Thread_Enable_dispatch> return 0; 1221a2: 31 c0 xor %eax,%eax } 1221a4: 8d 65 f4 lea -0xc(%ebp),%esp 1221a7: 5b pop %ebx 1221a8: 5e pop %esi 1221a9: 5f pop %edi 1221aa: c9 leave 1221ab: c3 ret =============================================================================== 0011d0a4 : extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) { 11d0a4: 55 push %ebp 11d0a5: 89 e5 mov %esp,%ebp 11d0a7: 53 push %ebx 11d0a8: 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())) 11d0ab: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c 11d0b2: 75 4f jne 11d103 <== NEVER TAKEN /* * This was already done if the user called exit() directly . _wrapup_reent(0); */ if (_REENT != _global_impure_ptr) { 11d0b4: 8b 1d 60 fa 11 00 mov 0x11fa60,%ebx 11d0ba: 39 1d 20 31 12 00 cmp %ebx,0x123120 11d0c0: 74 12 je 11d0d4 _wrapup_reent(_global_impure_ptr); 11d0c2: 83 ec 0c sub $0xc,%esp 11d0c5: 53 push %ebx 11d0c6: e8 b5 05 00 00 call 11d680 <_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; 11d0cb: 89 1d 20 31 12 00 mov %ebx,0x123120 11d0d1: 83 c4 10 add $0x10,%esp * * Should this be changed to do *all* file streams? * _fwalk (_REENT, fclose); */ fclose (stdin); 11d0d4: 83 ec 0c sub $0xc,%esp 11d0d7: a1 20 31 12 00 mov 0x123120,%eax 11d0dc: ff 70 04 pushl 0x4(%eax) 11d0df: e8 c0 41 ff ff call 1112a4 fclose (stdout); 11d0e4: 5a pop %edx 11d0e5: a1 20 31 12 00 mov 0x123120,%eax 11d0ea: ff 70 08 pushl 0x8(%eax) 11d0ed: e8 b2 41 ff ff call 1112a4 fclose (stderr); 11d0f2: 58 pop %eax 11d0f3: a1 20 31 12 00 mov 0x123120,%eax 11d0f8: ff 70 0c pushl 0xc(%eax) 11d0fb: e8 a4 41 ff ff call 1112a4 11d100: 83 c4 10 add $0x10,%esp } 11d103: 8b 5d fc mov -0x4(%ebp),%ebx 11d106: c9 leave 11d107: c3 ret =============================================================================== 0011cfb0 : off_t lseek( int fd, off_t offset, int whence ) { 11cfb0: 55 push %ebp 11cfb1: 89 e5 mov %esp,%ebp 11cfb3: 57 push %edi 11cfb4: 56 push %esi 11cfb5: 53 push %ebx 11cfb6: 83 ec 1c sub $0x1c,%esp 11cfb9: 8b 5d 08 mov 0x8(%ebp),%ebx 11cfbc: 8b 45 0c mov 0xc(%ebp),%eax 11cfbf: 8b 55 10 mov 0x10(%ebp),%edx 11cfc2: 8b 4d 14 mov 0x14(%ebp),%ecx rtems_libio_t *iop; off_t old_offset; off_t status; rtems_libio_check_fd( fd ); 11cfc5: 3b 1d 44 11 12 00 cmp 0x121144,%ebx 11cfcb: 73 0f jae 11cfdc iop = rtems_libio_iop( fd ); 11cfcd: 6b db 38 imul $0x38,%ebx,%ebx 11cfd0: 03 1d d8 51 12 00 add 0x1251d8,%ebx rtems_libio_check_is_open(iop); 11cfd6: f6 43 15 01 testb $0x1,0x15(%ebx) 11cfda: 75 0d jne 11cfe9 11cfdc: e8 6b 41 ff ff call 11114c <__errno> 11cfe1: c7 00 09 00 00 00 movl $0x9,(%eax) 11cfe7: eb 4b jmp 11d034 /* * Now process the lseek(). */ old_offset = iop->offset; 11cfe9: 8b 73 0c mov 0xc(%ebx),%esi 11cfec: 8b 7b 10 mov 0x10(%ebx),%edi 11cfef: 89 75 e0 mov %esi,-0x20(%ebp) 11cff2: 89 7d e4 mov %edi,-0x1c(%ebp) switch ( whence ) { 11cff5: 83 f9 01 cmp $0x1,%ecx 11cff8: 74 11 je 11d00b 11cffa: 83 f9 02 cmp $0x2,%ecx 11cffd: 74 18 je 11d017 11cfff: 85 c9 test %ecx,%ecx 11d001: 75 26 jne 11d029 case SEEK_SET: iop->offset = offset; 11d003: 89 43 0c mov %eax,0xc(%ebx) 11d006: 89 53 10 mov %edx,0x10(%ebx) break; 11d009: eb 30 jmp 11d03b case SEEK_CUR: iop->offset += offset; 11d00b: 8b 75 e0 mov -0x20(%ebp),%esi 11d00e: 8b 7d e4 mov -0x1c(%ebp),%edi 11d011: 01 c6 add %eax,%esi 11d013: 11 d7 adc %edx,%edi 11d015: eb 0a jmp 11d021 break; case SEEK_END: iop->offset = iop->size + offset; 11d017: 89 c6 mov %eax,%esi 11d019: 89 d7 mov %edx,%edi 11d01b: 03 73 04 add 0x4(%ebx),%esi 11d01e: 13 7b 08 adc 0x8(%ebx),%edi 11d021: 89 73 0c mov %esi,0xc(%ebx) 11d024: 89 7b 10 mov %edi,0x10(%ebx) break; 11d027: eb 12 jmp 11d03b default: rtems_set_errno_and_return_minus_one( EINVAL ); 11d029: e8 1e 41 ff ff call 11114c <__errno> 11d02e: c7 00 16 00 00 00 movl $0x16,(%eax) 11d034: 83 c8 ff or $0xffffffff,%eax 11d037: 89 c2 mov %eax,%edx 11d039: eb 23 jmp 11d05e /* * At this time, handlers assume iop->offset has the desired * new offset. */ status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence ); 11d03b: 8b 73 20 mov 0x20(%ebx),%esi 11d03e: 51 push %ecx 11d03f: 52 push %edx 11d040: 50 push %eax 11d041: 53 push %ebx 11d042: ff 56 14 call *0x14(%esi) if ( status == (off_t) -1 ) 11d045: 83 c4 10 add $0x10,%esp 11d048: 83 fa ff cmp $0xffffffff,%edx 11d04b: 75 11 jne 11d05e 11d04d: 83 f8 ff cmp $0xffffffff,%eax 11d050: 75 0c jne 11d05e <== NEVER TAKEN iop->offset = old_offset; 11d052: 8b 75 e0 mov -0x20(%ebp),%esi 11d055: 8b 7d e4 mov -0x1c(%ebp),%edi 11d058: 89 73 0c mov %esi,0xc(%ebx) 11d05b: 89 7b 10 mov %edi,0x10(%ebx) /* * So if the operation failed, we have to restore iop->offset. */ return status; } 11d05e: 8d 65 f4 lea -0xc(%ebp),%esp 11d061: 5b pop %ebx 11d062: 5e pop %esi 11d063: 5f pop %edi 11d064: c9 leave 11d065: c3 ret =============================================================================== 001075e4 : #include "malloc_p.h" void *malloc( size_t size ) { 1075e4: 55 push %ebp 1075e5: 89 e5 mov %esp,%ebp 1075e7: 56 push %esi 1075e8: 53 push %ebx 1075e9: 8b 75 08 mov 0x8(%ebp),%esi void *return_this; MSBUMP(malloc_calls, 1); 1075ec: ff 05 f4 51 12 00 incl 0x1251f4 /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 1075f2: e8 07 ff ff ff call 1074fe /* * Validate the parameters */ if ( !size ) return (void *) 0; 1075f7: 31 db xor %ebx,%ebx malloc_deferred_frees_process(); /* * Validate the parameters */ if ( !size ) 1075f9: 85 f6 test %esi,%esi 1075fb: 74 78 je 107675 return (void *) 0; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 1075fd: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c 107604: 75 09 jne 10760f !malloc_is_system_state_OK() ) 107606: e8 b5 fe ff ff call 1074c0 return (void *) 0; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 10760b: 84 c0 test %al,%al 10760d: 74 66 je 107675 <== 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 ); 10760f: 6a 00 push $0x0 107611: 6a 00 push $0x0 107613: 56 push %esi 107614: ff 35 50 11 12 00 pushl 0x121150 10761a: e8 61 43 00 00 call 10b980 <_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 ) { 10761f: 83 c4 10 add $0x10,%esp 107622: 89 c3 mov %eax,%ebx 107624: 85 c0 test %eax,%eax 107626: 75 28 jne 107650 if (rtems_malloc_sbrk_helpers) 107628: a1 54 36 12 00 mov 0x123654,%eax 10762d: 85 c0 test %eax,%eax 10762f: 74 10 je 107641 return_this = (*rtems_malloc_sbrk_helpers->extend)( size ); 107631: 83 ec 0c sub $0xc,%esp 107634: 56 push %esi 107635: ff 50 04 call *0x4(%eax) 107638: 89 c3 mov %eax,%ebx if ( !return_this ) { 10763a: 83 c4 10 add $0x10,%esp 10763d: 85 c0 test %eax,%eax 10763f: 75 0f jne 107650 errno = ENOMEM; 107641: e8 06 9b 00 00 call 11114c <__errno> 107646: c7 00 0c 00 00 00 movl $0xc,(%eax) return (void *) 0; 10764c: 31 db xor %ebx,%ebx 10764e: eb 25 jmp 107675 } /* * If the user wants us to dirty the allocated memory, then do it. */ if ( rtems_malloc_dirty_helper ) 107650: a1 58 36 12 00 mov 0x123658,%eax 107655: 85 c0 test %eax,%eax 107657: 74 09 je 107662 (*rtems_malloc_dirty_helper)( return_this, size ); 107659: 52 push %edx 10765a: 52 push %edx 10765b: 56 push %esi 10765c: 53 push %ebx 10765d: ff d0 call *%eax 10765f: 83 c4 10 add $0x10,%esp /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 107662: a1 50 36 12 00 mov 0x123650,%eax 107667: 85 c0 test %eax,%eax 107669: 74 0a je 107675 (*rtems_malloc_statistics_helpers->at_malloc)(return_this); 10766b: 83 ec 0c sub $0xc,%esp 10766e: 53 push %ebx 10766f: ff 50 04 call *0x4(%eax) 107672: 83 c4 10 add $0x10,%esp return return_this; } 107675: 89 d8 mov %ebx,%eax 107677: 8d 65 f8 lea -0x8(%ebp),%esp 10767a: 5b pop %ebx 10767b: 5e pop %esi 10767c: c9 leave 10767d: c3 ret =============================================================================== 0010794c : } void *malloc_sbrk_extend_and_allocate( size_t size ) { 10794c: 55 push %ebp 10794d: 89 e5 mov %esp,%ebp 10794f: 57 push %edi 107950: 56 push %esi 107951: 53 push %ebx 107952: 83 ec 0c sub $0xc,%esp 107955: 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; 107958: 8b 0d 74 53 12 00 mov 0x125374,%ecx if ( sbrk_amount == 0 ) return (void *) 0; 10795e: 31 f6 xor %esi,%esi * in "page" amounts. */ sbrk_amount = RTEMS_Malloc_Sbrk_amount; if ( sbrk_amount == 0 ) 107960: 85 c9 test %ecx,%ecx 107962: 74 67 je 1079cb <== NEVER TAKEN return (void *) 0; the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount); 107964: 8d 1c 0f lea (%edi,%ecx,1),%ebx 107967: 89 d8 mov %ebx,%eax 107969: 31 d2 xor %edx,%edx 10796b: f7 f1 div %ecx 10796d: 89 c3 mov %eax,%ebx 10796f: 0f af d9 imul %ecx,%ebx starting_address = (void *) sbrk(the_size); 107972: 83 ec 0c sub $0xc,%esp 107975: 53 push %ebx 107976: e8 d8 8a ff ff call 100453 if ( starting_address == (void*) -1 ) 10797b: 83 c4 10 add $0x10,%esp 10797e: 83 f8 ff cmp $0xffffffff,%eax 107981: 74 48 je 1079cb return (void *) 0; if ( !_Protected_heap_Extend( 107983: 52 push %edx 107984: 53 push %ebx 107985: 50 push %eax 107986: ff 35 50 11 12 00 pushl 0x121150 10798c: e8 87 43 00 00 call 10bd18 <_Protected_heap_Extend> 107991: 83 c4 10 add $0x10,%esp 107994: 84 c0 test %al,%al 107996: 75 18 jne 1079b0 RTEMS_Malloc_Heap, starting_address, the_size) ) { sbrk(-the_size); 107998: 83 ec 0c sub $0xc,%esp 10799b: f7 db neg %ebx 10799d: 53 push %ebx 10799e: e8 b0 8a ff ff call 100453 errno = ENOMEM; 1079a3: e8 7c 9d 00 00 call 111724 <__errno> 1079a8: c7 00 0c 00 00 00 movl $0xc,(%eax) 1079ae: eb 18 jmp 1079c8 return (void *) 0; } MSBUMP(space_available, the_size); 1079b0: 01 1d 48 53 12 00 add %ebx,0x125348 1079b6: 6a 00 push $0x0 1079b8: 6a 00 push $0x0 1079ba: 57 push %edi 1079bb: ff 35 50 11 12 00 pushl 0x121150 1079c1: e8 1a 43 00 00 call 10bce0 <_Protected_heap_Allocate_aligned_with_boundary> 1079c6: 89 c6 mov %eax,%esi return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); return return_this; 1079c8: 83 c4 10 add $0x10,%esp } 1079cb: 89 f0 mov %esi,%eax 1079cd: 8d 65 f4 lea -0xc(%ebp),%esp 1079d0: 5b pop %ebx 1079d1: 5e pop %esi 1079d2: 5f pop %edi 1079d3: c9 leave 1079d4: c3 ret =============================================================================== 0011042f : */ int memfile_ftruncate( rtems_libio_t *iop, rtems_off64_t length ) { 11042f: 55 push %ebp 110430: 89 e5 mov %esp,%ebp 110432: 53 push %ebx 110433: 83 ec 14 sub $0x14,%esp 110436: 8b 4d 08 mov 0x8(%ebp),%ecx 110439: 8b 45 0c mov 0xc(%ebp),%eax 11043c: 8b 55 10 mov 0x10(%ebp),%edx IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 11043f: 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 ) 110442: 3b 53 54 cmp 0x54(%ebx),%edx 110445: 7c 15 jl 11045c <== NEVER TAKEN 110447: 7f 05 jg 11044e <== NEVER TAKEN 110449: 3b 43 50 cmp 0x50(%ebx),%eax 11044c: 76 0e jbe 11045c return IMFS_memfile_extend( the_jnode, length ); 11044e: 51 push %ecx 11044f: 52 push %edx 110450: 50 push %eax 110451: 53 push %ebx 110452: e8 bf fc ff ff call 110116 110457: 83 c4 10 add $0x10,%esp 11045a: eb 24 jmp 110480 /* * 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; 11045c: 89 43 50 mov %eax,0x50(%ebx) 11045f: 89 53 54 mov %edx,0x54(%ebx) iop->size = the_jnode->info.file.size; 110462: 89 41 04 mov %eax,0x4(%ecx) 110465: 89 51 08 mov %edx,0x8(%ecx) IMFS_update_atime( the_jnode ); 110468: 50 push %eax 110469: 50 push %eax 11046a: 6a 00 push $0x0 11046c: 8d 45 f0 lea -0x10(%ebp),%eax 11046f: 50 push %eax 110470: e8 4b 6f ff ff call 1073c0 110475: 8b 45 f0 mov -0x10(%ebp),%eax 110478: 89 43 40 mov %eax,0x40(%ebx) return 0; 11047b: 83 c4 10 add $0x10,%esp 11047e: 31 c0 xor %eax,%eax } 110480: 8b 5d fc mov -0x4(%ebp),%ebx 110483: c9 leave 110484: c3 ret =============================================================================== 00110485 : rtems_off64_t memfile_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) { 110485: 55 push %ebp 110486: 89 e5 mov %esp,%ebp 110488: 56 push %esi 110489: 53 push %ebx 11048a: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 11048d: 8b 73 18 mov 0x18(%ebx),%esi if (the_jnode->type == IMFS_LINEAR_FILE) { 110490: 83 7e 4c 06 cmpl $0x6,0x4c(%esi) 110494: 75 1a jne 1104b0 if (iop->offset > the_jnode->info.linearfile.size) 110496: 8b 56 50 mov 0x50(%esi),%edx 110499: 8b 46 54 mov 0x54(%esi),%eax 11049c: 39 43 10 cmp %eax,0x10(%ebx) 11049f: 7c 41 jl 1104e2 <== NEVER TAKEN 1104a1: 7f 05 jg 1104a8 <== NEVER TAKEN 1104a3: 39 53 0c cmp %edx,0xc(%ebx) 1104a6: 76 3a jbe 1104e2 <== ALWAYS TAKEN iop->offset = the_jnode->info.linearfile.size; 1104a8: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED 1104ab: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED 1104ae: eb 32 jmp 1104e2 <== NOT EXECUTED } else { /* Must be a block file (IMFS_MEMORY_FILE). */ if (IMFS_memfile_extend( the_jnode, iop->offset )) 1104b0: 50 push %eax 1104b1: ff 73 10 pushl 0x10(%ebx) 1104b4: ff 73 0c pushl 0xc(%ebx) 1104b7: 56 push %esi 1104b8: e8 59 fc ff ff call 110116 1104bd: 83 c4 10 add $0x10,%esp 1104c0: 85 c0 test %eax,%eax 1104c2: 74 12 je 1104d6 rtems_set_errno_and_return_minus_one( ENOSPC ); 1104c4: e8 83 0c 00 00 call 11114c <__errno> 1104c9: c7 00 1c 00 00 00 movl $0x1c,(%eax) 1104cf: 83 c8 ff or $0xffffffff,%eax 1104d2: 89 c2 mov %eax,%edx 1104d4: eb 12 jmp 1104e8 iop->size = the_jnode->info.file.size; 1104d6: 8b 46 50 mov 0x50(%esi),%eax 1104d9: 8b 56 54 mov 0x54(%esi),%edx 1104dc: 89 43 04 mov %eax,0x4(%ebx) 1104df: 89 53 08 mov %edx,0x8(%ebx) } return iop->offset; 1104e2: 8b 43 0c mov 0xc(%ebx),%eax 1104e5: 8b 53 10 mov 0x10(%ebx),%edx } 1104e8: 8d 65 f8 lea -0x8(%ebp),%esp 1104eb: 5b pop %ebx 1104ec: 5e pop %esi 1104ed: c9 leave 1104ee: c3 ret =============================================================================== 001103a0 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 1103a0: 55 push %ebp 1103a1: 89 e5 mov %esp,%ebp 1103a3: 56 push %esi 1103a4: 53 push %ebx 1103a5: 8b 75 08 mov 0x8(%ebp),%esi IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 1103a8: 8b 5e 18 mov 0x18(%esi),%ebx /* * Perform 'copy on write' for linear files */ if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND)) 1103ab: f7 46 14 04 02 00 00 testl $0x204,0x14(%esi) 1103b2: 74 54 je 110408 && (the_jnode->type == IMFS_LINEAR_FILE)) { 1103b4: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) 1103b8: 75 4e jne 110408 <== ALWAYS TAKEN uint32_t count = the_jnode->info.linearfile.size; 1103ba: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED const unsigned char *buffer = the_jnode->info.linearfile.direct; 1103bd: 8b 53 58 mov 0x58(%ebx),%edx <== NOT EXECUTED the_jnode->type = IMFS_MEMORY_FILE; 1103c0: c7 43 4c 05 00 00 00 movl $0x5,0x4c(%ebx) <== NOT EXECUTED the_jnode->info.file.size = 0; 1103c7: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED 1103ce: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED the_jnode->info.file.indirect = 0; 1103d5: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED the_jnode->info.file.doubly_indirect = 0; 1103dc: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED the_jnode->info.file.triply_indirect = 0; 1103e3: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED if ((count != 0) 1103ea: 85 c0 test %eax,%eax <== NOT EXECUTED 1103ec: 74 1a je 110408 <== NOT EXECUTED && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) 1103ee: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1103f1: 50 push %eax <== NOT EXECUTED 1103f2: 52 push %edx <== NOT EXECUTED 1103f3: 6a 00 push $0x0 <== NOT EXECUTED 1103f5: 6a 00 push $0x0 <== NOT EXECUTED 1103f7: 53 push %ebx <== NOT EXECUTED 1103f8: e8 0b fe ff ff call 110208 <== NOT EXECUTED 1103fd: 89 c2 mov %eax,%edx <== NOT EXECUTED 1103ff: 83 c4 20 add $0x20,%esp <== NOT EXECUTED return -1; 110402: 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)) 110405: 42 inc %edx <== NOT EXECUTED 110406: 74 20 je 110428 <== NOT EXECUTED return -1; } if (iop->flags & LIBIO_FLAGS_APPEND) 110408: f6 46 15 02 testb $0x2,0x15(%esi) 11040c: 74 0c je 11041a iop->offset = the_jnode->info.file.size; 11040e: 8b 43 50 mov 0x50(%ebx),%eax 110411: 8b 53 54 mov 0x54(%ebx),%edx 110414: 89 46 0c mov %eax,0xc(%esi) 110417: 89 56 10 mov %edx,0x10(%esi) iop->size = the_jnode->info.file.size; 11041a: 8b 43 50 mov 0x50(%ebx),%eax 11041d: 8b 53 54 mov 0x54(%ebx),%edx 110420: 89 46 04 mov %eax,0x4(%esi) 110423: 89 56 08 mov %edx,0x8(%esi) return 0; 110426: 31 c0 xor %eax,%eax } 110428: 8d 65 f8 lea -0x8(%ebp),%esp 11042b: 5b pop %ebx 11042c: 5e pop %esi 11042d: c9 leave 11042e: c3 ret =============================================================================== 001077b5 : const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { 1077b5: 55 push %ebp 1077b6: 89 e5 mov %esp,%ebp 1077b8: 57 push %edi 1077b9: 56 push %esi 1077ba: 53 push %ebx 1077bb: 83 ec 4c sub $0x4c,%esp 1077be: 8b 75 10 mov 0x10(%ebp),%esi /* * Are the file system options valid? */ if ( options != RTEMS_FILESYSTEM_READ_ONLY && 1077c1: 83 7d 14 01 cmpl $0x1,0x14(%ebp) 1077c5: 77 13 ja 1077da rtems_set_errno_and_return_minus_one( EINVAL ); /* * Get mount handler */ mount_h = rtems_filesystem_get_mount_handler( filesystemtype ); 1077c7: 83 ec 0c sub $0xc,%esp 1077ca: 56 push %esi 1077cb: e8 37 6c 00 00 call 10e407 1077d0: 89 45 b0 mov %eax,-0x50(%ebp) if ( !mount_h ) 1077d3: 83 c4 10 add $0x10,%esp 1077d6: 85 c0 test %eax,%eax 1077d8: 75 10 jne 1077ea rtems_set_errno_and_return_minus_one( EINVAL ); 1077da: e8 6d 99 00 00 call 11114c <__errno> 1077df: c7 00 16 00 00 00 movl $0x16,(%eax) 1077e5: e9 ca 00 00 00 jmp 1078b4 { 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; 1077ea: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 1077ee: 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 : "/"; 1077f2: 8b 45 0c mov 0xc(%ebp),%eax 1077f5: 89 45 b8 mov %eax,-0x48(%ebp) 1077f8: 80 7d b7 00 cmpb $0x0,-0x49(%ebp) 1077fc: 75 07 jne 107805 1077fe: c7 45 b8 5c ef 11 00 movl $0x11ef5c,-0x48(%ebp) size_t filesystemtype_size = strlen( filesystemtype ) + 1; 107805: 83 ca ff or $0xffffffff,%edx 107808: 31 c0 xor %eax,%eax 10780a: 89 d1 mov %edx,%ecx 10780c: 89 f7 mov %esi,%edi 10780e: f2 ae repnz scas %es:(%edi),%al 107810: f7 d1 not %ecx 107812: 89 4d bc mov %ecx,-0x44(%ebp) size_t source_size = source_or_null != NULL ? strlen( source_or_null ) + 1 : 0; 107815: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) 10781c: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 107820: 74 0c je 10782e 107822: 89 d1 mov %edx,%ecx 107824: 8b 7d 08 mov 0x8(%ebp),%edi 107827: f2 ae repnz scas %es:(%edi),%al 107829: f7 d1 not %ecx 10782b: 89 4d c4 mov %ecx,-0x3c(%ebp) size_t target_size = strlen( target ) + 1; 10782e: 31 c0 xor %eax,%eax 107830: 83 c9 ff or $0xffffffff,%ecx 107833: 8b 7d b8 mov -0x48(%ebp),%edi 107836: f2 ae repnz scas %es:(%edi),%al 107838: f7 d1 not %ecx 10783a: 89 4d c0 mov %ecx,-0x40(%ebp) 10783d: 49 dec %ecx 10783e: 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 ); 107841: 50 push %eax 107842: 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; 107843: 8b 55 c4 mov -0x3c(%ebp),%edx 107846: 8b 7d bc mov -0x44(%ebp),%edi 107849: 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 ) 10784d: 03 45 c0 add -0x40(%ebp),%eax + filesystemtype_size + source_size + target_size; rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size ); 107850: 50 push %eax 107851: 6a 01 push $0x1 107853: e8 84 f9 ff ff call 1071dc 107858: 89 c3 mov %eax,%ebx if ( mt_entry != NULL ) { 10785a: 83 c4 10 add $0x10,%esp 10785d: 85 c0 test %eax,%eax 10785f: 74 48 je 1078a9 <== NEVER TAKEN char *str = (char *) mt_entry + sizeof( *mt_entry ); 107861: 8d 40 74 lea 0x74(%eax),%eax memcpy( str, filesystemtype, filesystemtype_size ); 107864: 89 c7 mov %eax,%edi 107866: 8b 4d bc mov -0x44(%ebp),%ecx 107869: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10786b: 89 fa mov %edi,%edx mt_entry->type = str; 10786d: 89 43 6c mov %eax,0x6c(%ebx) str += filesystemtype_size; memcpy( str, source_or_null, source_size ); 107870: 8b 75 08 mov 0x8(%ebp),%esi 107873: 8b 4d c4 mov -0x3c(%ebp),%ecx 107876: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 107878: 89 f8 mov %edi,%eax mt_entry->dev = str; 10787a: 89 53 70 mov %edx,0x70(%ebx) str += source_size; memcpy( str, target, target_size ); 10787d: 8b 75 b8 mov -0x48(%ebp),%esi 107880: 8b 4d c0 mov -0x40(%ebp),%ecx 107883: f3 a4 rep movsb %ds:(%esi),%es:(%edi) mt_entry->target = str; 107885: 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; 107888: 89 5b 2c mov %ebx,0x2c(%ebx) mt_entry->options = options; 10788b: 8b 45 14 mov 0x14(%ebp),%eax 10788e: 89 43 30 mov %eax,0x30(%ebx) mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf; 107891: 8d 7b 38 lea 0x38(%ebx),%edi 107894: be 9c ef 11 00 mov $0x11ef9c,%esi 107899: b1 0c mov $0xc,%cl 10789b: 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 ) { 10789d: 80 7d b7 00 cmpb $0x0,-0x49(%ebp) 1078a1: 0f 84 a3 00 00 00 je 10794a 1078a7: eb 13 jmp 1078bc target, filesystemtype, &target_length ); if ( !mt_entry ) rtems_set_errno_and_return_minus_one( ENOMEM ); 1078a9: e8 9e 98 00 00 call 11114c <__errno> <== NOT EXECUTED 1078ae: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 1078b4: 83 c8 ff or $0xffffffff,%eax 1078b7: e9 26 01 00 00 jmp 1079e2 * The mount_point should be a directory with read/write/execute * permissions in the existing tree. */ if ( has_target ) { if ( rtems_filesystem_evaluate_path( 1078bc: 83 ec 0c sub $0xc,%esp 1078bf: 6a 01 push $0x1 1078c1: 8d 75 d4 lea -0x2c(%ebp),%esi 1078c4: 56 push %esi 1078c5: 6a 07 push $0x7 1078c7: ff 75 ac pushl -0x54(%ebp) 1078ca: ff 75 0c pushl 0xc(%ebp) 1078cd: e8 a4 f9 ff ff call 107276 1078d2: 83 c4 20 add $0x20,%esp 1078d5: 40 inc %eax 1078d6: 0f 84 df 00 00 00 je 1079bb <== NEVER TAKEN /* * Test to see if it is a directory */ if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 1078dc: 83 ec 0c sub $0xc,%esp 1078df: 56 push %esi 1078e0: 8b 45 e0 mov -0x20(%ebp),%eax 1078e3: ff 50 10 call *0x10(%eax) 1078e6: 83 c4 10 add $0x10,%esp 1078e9: 48 dec %eax 1078ea: 74 10 je 1078fc errno = ENOTDIR; 1078ec: e8 5b 98 00 00 call 11114c <__errno> 1078f1: c7 00 14 00 00 00 movl $0x14,(%eax) goto cleanup_and_bail; 1078f7: e9 c1 00 00 00 jmp 1079bd /* * You can only mount one file system onto a single mount point. */ if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) { 1078fc: 57 push %edi 1078fd: 57 push %edi 1078fe: ff 75 d4 pushl -0x2c(%ebp) 107901: 68 2c 77 10 00 push $0x10772c 107906: e8 62 fe ff ff call 10776d 10790b: 83 c4 10 add $0x10,%esp 10790e: 84 c0 test %al,%al 107910: 74 10 je 107922 errno = EBUSY; 107912: e8 35 98 00 00 call 11114c <__errno> 107917: c7 00 10 00 00 00 movl $0x10,(%eax) goto cleanup_and_bail; 10791d: e9 9b 00 00 00 jmp 1079bd * 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; 107922: 8b 45 d4 mov -0x2c(%ebp),%eax 107925: 89 43 08 mov %eax,0x8(%ebx) mt_entry->mt_point_node.handlers = loc.handlers; 107928: 8b 45 dc mov -0x24(%ebp),%eax 10792b: 89 43 10 mov %eax,0x10(%ebx) mt_entry->mt_point_node.ops = loc.ops; 10792e: 8b 45 e0 mov -0x20(%ebp),%eax 107931: 89 43 14 mov %eax,0x14(%ebx) mt_entry->mt_point_node.mt_entry = loc.mt_entry; 107934: 8b 55 e4 mov -0x1c(%ebp),%edx 107937: 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 ) ) { 10793a: 83 ec 0c sub $0xc,%esp 10793d: 53 push %ebx 10793e: ff 50 20 call *0x20(%eax) 107941: 83 c4 10 add $0x10,%esp 107944: 85 c0 test %eax,%eax 107946: 74 1d je 107965 <== ALWAYS TAKEN 107948: eb 73 jmp 1079bd <== 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; 10794a: 31 f6 xor %esi,%esi } } else { /* * Do we already have a base file system ? */ if ( !rtems_chain_is_empty( &mount_chain ) ) { 10794c: 81 3d 44 2f 12 00 48 cmpl $0x122f48,0x122f44 107953: 2f 12 00 107956: 74 0d je 107965 <== ALWAYS TAKEN errno = EINVAL; 107958: e8 ef 97 00 00 call 11114c <__errno> <== NOT EXECUTED 10795d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED goto cleanup_and_bail; 107963: eb 58 jmp 1079bd <== 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 ) ) { 107965: 51 push %ecx 107966: 51 push %ecx 107967: ff 75 18 pushl 0x18(%ebp) 10796a: 53 push %ebx 10796b: ff 55 b0 call *-0x50(%ebp) 10796e: 83 c4 10 add $0x10,%esp 107971: 85 c0 test %eax,%eax 107973: 74 0f je 107984 /* * Try to undo the mount operation */ loc.ops->unmount_h( mt_entry ); 107975: 83 ec 0c sub $0xc,%esp 107978: 53 push %ebx 107979: 8b 45 e0 mov -0x20(%ebp),%eax 10797c: ff 50 28 call *0x28(%eax) goto cleanup_and_bail; 10797f: 83 c4 10 add $0x10,%esp 107982: eb 39 jmp 1079bd } /* * Add the mount table entry to the mount table chain */ rtems_libio_lock(); 107984: e8 b4 fd ff ff call 10773d 107989: 52 push %edx 10798a: 52 push %edx 10798b: 53 push %ebx 10798c: 68 44 2f 12 00 push $0x122f44 107991: e8 4a 30 00 00 call 10a9e0 <_Chain_Append> rtems_chain_append( &mount_chain, &mt_entry->Node ); rtems_libio_unlock(); 107996: e8 bc fd ff ff call 107757 if ( !has_target ) 10799b: 83 c4 10 add $0x10,%esp rtems_filesystem_root = mt_entry->mt_fs_root; return 0; 10799e: 31 c0 xor %eax,%eax */ rtems_libio_lock(); rtems_chain_append( &mount_chain, &mt_entry->Node ); rtems_libio_unlock(); if ( !has_target ) 1079a0: 80 7d b7 00 cmpb $0x0,-0x49(%ebp) 1079a4: 75 3c jne 1079e2 rtems_filesystem_root = mt_entry->mt_fs_root; 1079a6: 8b 3d 60 30 12 00 mov 0x123060,%edi 1079ac: 83 c7 18 add $0x18,%edi 1079af: 8d 73 1c lea 0x1c(%ebx),%esi 1079b2: b9 05 00 00 00 mov $0x5,%ecx 1079b7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 1079b9: eb 27 jmp 1079e2 ) { 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; 1079bb: 31 f6 xor %esi,%esi return 0; cleanup_and_bail: free( mt_entry ); 1079bd: 83 ec 0c sub $0xc,%esp 1079c0: 53 push %ebx 1079c1: e8 82 f9 ff ff call 107348 if ( loc_to_free ) 1079c6: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( loc_to_free ); return -1; 1079c9: 83 c8 ff or $0xffffffff,%eax cleanup_and_bail: free( mt_entry ); if ( loc_to_free ) 1079cc: 85 f6 test %esi,%esi 1079ce: 74 12 je 1079e2 <== NEVER TAKEN rtems_filesystem_freenode( loc_to_free ); 1079d0: 83 ec 0c sub $0xc,%esp 1079d3: 56 push %esi 1079d4: 89 45 a8 mov %eax,-0x58(%ebp) 1079d7: e8 58 f9 ff ff call 107334 1079dc: 83 c4 10 add $0x10,%esp 1079df: 8b 45 a8 mov -0x58(%ebp),%eax return -1; } 1079e2: 8d 65 f4 lea -0xc(%ebp),%esp 1079e5: 5b pop %ebx 1079e6: 5e pop %esi 1079e7: 5f pop %edi 1079e8: c9 leave 1079e9: c3 ret =============================================================================== 00107d3c : const char *target, const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { 107d3c: 55 push %ebp 107d3d: 89 e5 mov %esp,%ebp 107d3f: 57 push %edi 107d40: 56 push %esi 107d41: 53 push %ebx 107d42: 83 ec 1c sub $0x1c,%esp 107d45: 8b 4d 08 mov 0x8(%ebp),%ecx 107d48: 8b 5d 0c mov 0xc(%ebp),%ebx 107d4b: 8b 75 10 mov 0x10(%ebp),%esi 107d4e: 8b 7d 14 mov 0x14(%ebp),%edi 107d51: 8b 55 18 mov 0x18(%ebp),%edx int rv = -1; if (target != NULL) { 107d54: 85 db test %ebx,%ebx 107d56: 74 3b je 107d93 rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO); 107d58: 50 push %eax 107d59: 50 push %eax 107d5a: 68 ff 01 00 00 push $0x1ff 107d5f: 53 push %ebx 107d60: 89 55 e0 mov %edx,-0x20(%ebp) 107d63: 89 4d e4 mov %ecx,-0x1c(%ebp) 107d66: e8 bd 08 00 00 call 108628 if (rv == 0) { 107d6b: 83 c4 10 add $0x10,%esp 107d6e: 85 c0 test %eax,%eax 107d70: 8b 55 e0 mov -0x20(%ebp),%edx 107d73: 8b 4d e4 mov -0x1c(%ebp),%ecx 107d76: 75 29 jne 107da1 <== NEVER TAKEN rv = mount( 107d78: 89 55 18 mov %edx,0x18(%ebp) 107d7b: 89 7d 14 mov %edi,0x14(%ebp) 107d7e: 89 75 10 mov %esi,0x10(%ebp) 107d81: 89 5d 0c mov %ebx,0xc(%ebp) 107d84: 89 4d 08 mov %ecx,0x8(%ebp) } else { errno = EINVAL; } return rv; } 107d87: 8d 65 f4 lea -0xc(%ebp),%esp 107d8a: 5b pop %ebx 107d8b: 5e pop %esi 107d8c: 5f pop %edi 107d8d: c9 leave int rv = -1; if (target != NULL) { rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO); if (rv == 0) { rv = mount( 107d8e: e9 a2 00 00 00 jmp 107e35 options, data ); } } else { errno = EINVAL; 107d93: e8 40 9a 00 00 call 1117d8 <__errno> 107d98: c7 00 16 00 00 00 movl $0x16,(%eax) const char *filesystemtype, rtems_filesystem_options_t options, const void *data ) { int rv = -1; 107d9e: 83 c8 ff or $0xffffffff,%eax } else { errno = EINVAL; } return rv; } 107da1: 8d 65 f4 lea -0xc(%ebp),%esp 107da4: 5b pop %ebx 107da5: 5e pop %esi 107da6: 5f pop %edi 107da7: c9 leave 107da8: c3 ret =============================================================================== 00107a45 : */ bool newlib_create_hook( rtems_tcb *current_task __attribute__((unused)), rtems_tcb *creating_task ) { 107a45: 55 push %ebp 107a46: 89 e5 mov %esp,%ebp 107a48: 57 push %edi 107a49: 56 push %esi 107a4a: 53 push %ebx 107a4b: 83 ec 1c sub $0x1c,%esp struct _reent *ptr; if (_Thread_libc_reent == 0) 107a4e: 83 3d c8 53 12 00 00 cmpl $0x0,0x1253c8 107a55: 75 14 jne 107a6b { _REENT = _global_impure_ptr; 107a57: a1 60 fa 11 00 mov 0x11fa60,%eax 107a5c: a3 20 31 12 00 mov %eax,0x123120 RTEMS_INLINE_ROUTINE void _Thread_Set_libc_reent ( struct _reent **libc_reent ) { _Thread_libc_reent = libc_reent; 107a61: c7 05 c8 53 12 00 20 movl $0x123120,0x1253c8 107a68: 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)); 107a6b: 83 ec 0c sub $0xc,%esp 107a6e: 68 24 04 00 00 push $0x424 107a73: e8 3e 55 00 00 call 10cfb6 <_Workspace_Allocate> 107a78: 89 c2 mov %eax,%edx #endif if (ptr) { 107a7a: 83 c4 10 add $0x10,%esp _REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */ creating_task->libc_reent = ptr; return TRUE; } return FALSE; 107a7d: 31 c0 xor %eax,%eax * hooks run with thread dispatching disabled. */ ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent)); #endif if (ptr) { 107a7f: 85 d2 test %edx,%edx 107a81: 0f 84 28 02 00 00 je 107caf <== NEVER TAKEN _REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */ 107a87: c7 02 00 00 00 00 movl $0x0,(%edx) 107a8d: 8d b2 ec 02 00 00 lea 0x2ec(%edx),%esi 107a93: 89 72 04 mov %esi,0x4(%edx) 107a96: 8d 8a 54 03 00 00 lea 0x354(%edx),%ecx 107a9c: 89 4a 08 mov %ecx,0x8(%edx) 107a9f: 8d 8a bc 03 00 00 lea 0x3bc(%edx),%ecx 107aa5: 89 4a 0c mov %ecx,0xc(%edx) 107aa8: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) 107aaf: 8d 4a 14 lea 0x14(%edx),%ecx 107ab2: bb 19 00 00 00 mov $0x19,%ebx 107ab7: 89 cf mov %ecx,%edi 107ab9: 89 d9 mov %ebx,%ecx 107abb: f3 aa rep stos %al,%es:(%edi) 107abd: 89 cb mov %ecx,%ebx 107abf: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) 107ac6: c7 42 34 ee ec 11 00 movl $0x11ecee,0x34(%edx) 107acd: c7 42 38 00 00 00 00 movl $0x0,0x38(%edx) 107ad4: c7 42 3c 00 00 00 00 movl $0x0,0x3c(%edx) 107adb: c7 42 40 00 00 00 00 movl $0x0,0x40(%edx) 107ae2: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx) 107ae9: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) 107af0: c7 42 4c 00 00 00 00 movl $0x0,0x4c(%edx) 107af7: c7 42 50 00 00 00 00 movl $0x0,0x50(%edx) 107afe: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) 107b05: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx) 107b0c: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx) 107b13: c6 42 60 00 movb $0x0,0x60(%edx) 107b17: 8d 42 7c lea 0x7c(%edx),%eax 107b1a: 89 45 e4 mov %eax,-0x1c(%ebp) 107b1d: b1 09 mov $0x9,%cl 107b1f: 89 c7 mov %eax,%edi 107b21: 89 d8 mov %ebx,%eax 107b23: f3 ab rep stos %eax,%es:(%edi) 107b25: c7 82 a0 00 00 00 00 movl $0x0,0xa0(%edx) 107b2c: 00 00 00 107b2f: c7 82 a4 00 00 00 01 movl $0x1,0xa4(%edx) 107b36: 00 00 00 107b39: c7 82 a8 00 00 00 00 movl $0x0,0xa8(%edx) 107b40: 00 00 00 107b43: 66 c7 82 ac 00 00 00 movw $0x330e,0xac(%edx) 107b4a: 0e 33 107b4c: 66 c7 82 ae 00 00 00 movw $0xabcd,0xae(%edx) 107b53: cd ab 107b55: 66 c7 82 b0 00 00 00 movw $0x1234,0xb0(%edx) 107b5c: 34 12 107b5e: 66 c7 82 b2 00 00 00 movw $0xe66d,0xb2(%edx) 107b65: 6d e6 107b67: 66 c7 82 b4 00 00 00 movw $0xdeec,0xb4(%edx) 107b6e: ec de 107b70: 66 c7 82 b6 00 00 00 movw $0x5,0xb6(%edx) 107b77: 05 00 107b79: 66 c7 82 b8 00 00 00 movw $0xb,0xb8(%edx) 107b80: 0b 00 107b82: c7 82 bc 00 00 00 00 movl $0x0,0xbc(%edx) 107b89: 00 00 00 107b8c: c7 82 c0 00 00 00 00 movl $0x0,0xc0(%edx) 107b93: 00 00 00 107b96: c7 82 c4 00 00 00 00 movl $0x0,0xc4(%edx) 107b9d: 00 00 00 107ba0: c7 82 c8 00 00 00 00 movl $0x0,0xc8(%edx) 107ba7: 00 00 00 107baa: c7 82 cc 00 00 00 00 movl $0x0,0xcc(%edx) 107bb1: 00 00 00 107bb4: c7 82 d0 00 00 00 00 movl $0x0,0xd0(%edx) 107bbb: 00 00 00 107bbe: c7 82 f8 00 00 00 00 movl $0x0,0xf8(%edx) 107bc5: 00 00 00 107bc8: c7 82 fc 00 00 00 00 movl $0x0,0xfc(%edx) 107bcf: 00 00 00 107bd2: c7 82 00 01 00 00 00 movl $0x0,0x100(%edx) 107bd9: 00 00 00 107bdc: c7 82 04 01 00 00 00 movl $0x0,0x104(%edx) 107be3: 00 00 00 107be6: c7 82 08 01 00 00 00 movl $0x0,0x108(%edx) 107bed: 00 00 00 107bf0: c7 82 0c 01 00 00 00 movl $0x0,0x10c(%edx) 107bf7: 00 00 00 107bfa: c7 82 10 01 00 00 00 movl $0x0,0x110(%edx) 107c01: 00 00 00 107c04: c7 82 14 01 00 00 00 movl $0x0,0x114(%edx) 107c0b: 00 00 00 107c0e: c7 82 18 01 00 00 00 movl $0x0,0x118(%edx) 107c15: 00 00 00 107c18: c7 82 1c 01 00 00 00 movl $0x0,0x11c(%edx) 107c1f: 00 00 00 107c22: c6 82 d4 00 00 00 00 movb $0x0,0xd4(%edx) 107c29: c6 82 dc 00 00 00 00 movb $0x0,0xdc(%edx) 107c30: c7 82 f4 00 00 00 00 movl $0x0,0xf4(%edx) 107c37: 00 00 00 107c3a: c7 82 48 01 00 00 00 movl $0x0,0x148(%edx) 107c41: 00 00 00 107c44: c7 82 4c 01 00 00 00 movl $0x0,0x14c(%edx) 107c4b: 00 00 00 107c4e: c7 82 50 01 00 00 00 movl $0x0,0x150(%edx) 107c55: 00 00 00 107c58: c7 82 54 01 00 00 00 movl $0x0,0x154(%edx) 107c5f: 00 00 00 107c62: c7 82 d4 02 00 00 00 movl $0x0,0x2d4(%edx) 107c69: 00 00 00 107c6c: c7 82 d4 01 00 00 00 movl $0x0,0x1d4(%edx) 107c73: 00 00 00 107c76: c7 82 dc 02 00 00 00 movl $0x0,0x2dc(%edx) 107c7d: 00 00 00 107c80: c7 82 e0 02 00 00 00 movl $0x0,0x2e0(%edx) 107c87: 00 00 00 107c8a: c7 82 e4 02 00 00 00 movl $0x0,0x2e4(%edx) 107c91: 00 00 00 107c94: c7 82 e8 02 00 00 00 movl $0x0,0x2e8(%edx) 107c9b: 00 00 00 107c9e: b1 4e mov $0x4e,%cl 107ca0: 89 f7 mov %esi,%edi 107ca2: f3 ab rep stos %eax,%es:(%edi) creating_task->libc_reent = ptr; 107ca4: 8b 45 0c mov 0xc(%ebp),%eax 107ca7: 89 90 e4 00 00 00 mov %edx,0xe4(%eax) return TRUE; 107cad: b0 01 mov $0x1,%al } return FALSE; } 107caf: 8d 65 f4 lea -0xc(%ebp),%esp 107cb2: 5b pop %ebx 107cb3: 5e pop %esi 107cb4: 5f pop %edi 107cb5: c9 leave 107cb6: c3 ret =============================================================================== 00107cb7 : void newlib_delete_hook( rtems_tcb *current_task, rtems_tcb *deleted_task ) { 107cb7: 55 push %ebp 107cb8: 89 e5 mov %esp,%ebp 107cba: 57 push %edi 107cbb: 56 push %esi 107cbc: 53 push %ebx 107cbd: 83 ec 0c sub $0xc,%esp 107cc0: 8b 7d 08 mov 0x8(%ebp),%edi 107cc3: 8b 75 0c mov 0xc(%ebp),%esi /* * The reentrancy structure was allocated by newlib using malloc() */ if (current_task == deleted_task) { 107cc6: 39 f7 cmp %esi,%edi 107cc8: 75 08 jne 107cd2 ptr = _REENT; 107cca: 8b 1d 20 31 12 00 mov 0x123120,%ebx 107cd0: eb 06 jmp 107cd8 } else { ptr = deleted_task->libc_reent; 107cd2: 8b 9e e4 00 00 00 mov 0xe4(%esi),%ebx } if (ptr && ptr != _global_impure_ptr) { 107cd8: 85 db test %ebx,%ebx 107cda: 74 20 je 107cfc <== NEVER TAKEN 107cdc: 3b 1d 60 fa 11 00 cmp 0x11fa60,%ebx 107ce2: 74 18 je 107cfc _reclaim_reent(ptr); */ /* * Just in case there are some buffers lying around. */ _fwalk(ptr, newlib_free_buffers); 107ce4: 50 push %eax 107ce5: 50 push %eax 107ce6: 68 f4 79 10 00 push $0x1079f4 107ceb: 53 push %ebx 107cec: e8 43 9c 00 00 call 111934 <_fwalk> #if REENT_MALLOCED free(ptr); #else _Workspace_Free(ptr); 107cf1: 89 1c 24 mov %ebx,(%esp) 107cf4: e8 d6 52 00 00 call 10cfcf <_Workspace_Free> 107cf9: 83 c4 10 add $0x10,%esp #endif } deleted_task->libc_reent = NULL; 107cfc: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) 107d03: 00 00 00 /* * Require the switch back to another task to install its own */ if ( current_task == deleted_task ) { 107d06: 39 f7 cmp %esi,%edi 107d08: 75 0a jne 107d14 _REENT = 0; 107d0a: c7 05 20 31 12 00 00 movl $0x0,0x123120 107d11: 00 00 00 } } 107d14: 8d 65 f4 lea -0xc(%ebp),%esp 107d17: 5b pop %ebx 107d18: 5e pop %esi 107d19: 5f pop %edi 107d1a: c9 leave 107d1b: c3 ret =============================================================================== 001079f4 : */ int newlib_free_buffers( FILE *fp ) { 1079f4: 55 push %ebp 1079f5: 89 e5 mov %esp,%ebp 1079f7: 53 push %ebx 1079f8: 83 ec 10 sub $0x10,%esp 1079fb: 8b 5d 08 mov 0x8(%ebp),%ebx switch ( fileno(fp) ) { 1079fe: 53 push %ebx 1079ff: e8 1c 9b 00 00 call 111520 107a04: 83 c4 10 add $0x10,%esp 107a07: 83 f8 02 cmp $0x2,%eax 107a0a: 77 26 ja 107a32 <== NEVER TAKEN case 0: case 1: case 2: if (fp->_flags & __SMBF) { 107a0c: f6 43 0c 80 testb $0x80,0xc(%ebx) 107a10: 74 2c je 107a3e <== ALWAYS TAKEN free( fp->_bf._base ); 107a12: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107a15: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 107a18: e8 2b f9 ff ff call 107348 <== NOT EXECUTED fp->_flags &= ~__SMBF; 107a1d: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) <== NOT EXECUTED fp->_bf._base = fp->_p = (unsigned char *) NULL; 107a23: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED 107a29: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED 107a30: eb 09 jmp 107a3b <== NOT EXECUTED } break; default: fclose(fp); 107a32: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107a35: 53 push %ebx <== NOT EXECUTED 107a36: e8 69 98 00 00 call 1112a4 <== NOT EXECUTED 107a3b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 107a3e: 31 c0 xor %eax,%eax 107a40: 8b 5d fc mov -0x4(%ebp),%ebx 107a43: c9 leave 107a44: c3 ret =============================================================================== 00107d7c : int open( const char *pathname, int flags, ... ) { 107d7c: 55 push %ebp 107d7d: 89 e5 mov %esp,%ebp 107d7f: 57 push %edi 107d80: 56 push %esi 107d81: 53 push %ebx 107d82: 83 ec 3c sub $0x3c,%esp /* * Set the Evaluation flags */ eval_flags = 0; status = flags + 1; 107d85: 8b 45 0c mov 0xc(%ebp),%eax 107d88: 40 inc %eax if ( ( status & _FREAD ) == _FREAD ) 107d89: 89 c6 mov %eax,%esi 107d8b: 83 e6 01 and $0x1,%esi eval_flags |= RTEMS_LIBIO_PERMS_READ; 107d8e: f7 de neg %esi 107d90: 83 e6 04 and $0x4,%esi if ( ( status & _FWRITE ) == _FWRITE ) 107d93: a8 02 test $0x2,%al 107d95: 74 03 je 107d9a eval_flags |= RTEMS_LIBIO_PERMS_WRITE; 107d97: 83 ce 02 or $0x2,%esi va_start(ap, flags); mode = va_arg( ap, int ); 107d9a: 8b 45 10 mov 0x10(%ebp),%eax 107d9d: 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(); 107da0: e8 46 64 00 00 call 10e1eb 107da5: 89 c3 mov %eax,%ebx if ( iop == 0 ) { 107da7: 85 c0 test %eax,%eax 107da9: 0f 84 56 01 00 00 je 107f05 } /* * See if the file exists. */ status = rtems_filesystem_evaluate_path( 107daf: 83 c9 ff or $0xffffffff,%ecx 107db2: 8b 7d 08 mov 0x8(%ebp),%edi 107db5: 31 c0 xor %eax,%eax 107db7: f2 ae repnz scas %es:(%edi),%al 107db9: f7 d1 not %ecx 107dbb: 49 dec %ecx 107dbc: 83 ec 0c sub $0xc,%esp 107dbf: 6a 01 push $0x1 107dc1: 8d 45 d4 lea -0x2c(%ebp),%eax 107dc4: 50 push %eax 107dc5: 56 push %esi 107dc6: 51 push %ecx 107dc7: ff 75 08 pushl 0x8(%ebp) 107dca: e8 a7 f4 ff ff call 107276 107dcf: 89 c6 mov %eax,%esi pathname, strlen( pathname ), eval_flags, &loc, true ); if ( status == -1 ) { 107dd1: 83 c4 20 add $0x20,%esp 107dd4: 83 f8 ff cmp $0xffffffff,%eax 107dd7: 75 6c jne 107e45 if ( errno != ENOENT ) { 107dd9: e8 6e 93 00 00 call 11114c <__errno> 107dde: 83 38 02 cmpl $0x2,(%eax) 107de1: 75 27 jne 107e0a rc = errno; goto done; } /* If the file does not exist and we are not trying to create it--> error */ if ( !(flags & O_CREAT) ) { 107de3: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 107dea: 0f 84 1c 01 00 00 je 107f0c rc = ENOENT; goto done; } /* Create the node for the new regular file */ rc = mknod( pathname, S_IFREG | mode, 0LL ); 107df0: 6a 00 push $0x0 107df2: 6a 00 push $0x0 107df4: 8b 45 c4 mov -0x3c(%ebp),%eax 107df7: 80 cc 80 or $0x80,%ah 107dfa: 50 push %eax 107dfb: ff 75 08 pushl 0x8(%ebp) 107dfe: e8 99 f8 ff ff call 10769c if ( rc ) { 107e03: 83 c4 10 add $0x10,%esp 107e06: 85 c0 test %eax,%eax 107e08: 74 0e je 107e18 <== ALWAYS TAKEN rc = errno; 107e0a: e8 3d 93 00 00 call 11114c <__errno> 107e0f: 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; 107e11: 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; 107e13: e9 10 01 00 00 jmp 107f28 /* * 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( 107e18: 89 f1 mov %esi,%ecx 107e1a: 8b 7d 08 mov 0x8(%ebp),%edi 107e1d: 31 c0 xor %eax,%eax 107e1f: f2 ae repnz scas %es:(%edi),%al 107e21: f7 d1 not %ecx 107e23: 49 dec %ecx 107e24: 83 ec 0c sub $0xc,%esp 107e27: 6a 01 push $0x1 107e29: 8d 45 d4 lea -0x2c(%ebp),%eax 107e2c: 50 push %eax 107e2d: 6a 00 push $0x0 107e2f: 51 push %ecx 107e30: ff 75 08 pushl 0x8(%ebp) 107e33: e8 3e f4 ff ff call 107276 pathname, strlen( pathname ), 0x0, &loc, true ); if ( status != 0 ) { /* The file did not exist */ 107e38: 83 c4 20 add $0x20,%esp 107e3b: 85 c0 test %eax,%eax 107e3d: 0f 85 d2 00 00 00 jne 107f15 <== NEVER TAKEN 107e43: eb 13 jmp 107e58 rc = EACCES; goto done; } } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) { 107e45: 8b 45 0c mov 0xc(%ebp),%eax 107e48: 25 00 0a 00 00 and $0xa00,%eax 107e4d: 3d 00 0a 00 00 cmp $0xa00,%eax 107e52: 0f 84 c6 00 00 00 je 107f1e <== NEVER TAKEN /* * Fill in the file control block based on the loc structure * returned by successful path evaluation. */ iop->flags |= rtems_libio_fcntl_flags( flags ); 107e58: 8b 73 14 mov 0x14(%ebx),%esi 107e5b: 83 ec 0c sub $0xc,%esp 107e5e: ff 75 0c pushl 0xc(%ebp) 107e61: e8 12 63 00 00 call 10e178 107e66: 09 f0 or %esi,%eax 107e68: 89 43 14 mov %eax,0x14(%ebx) iop->pathinfo = loc; 107e6b: 8d 7b 18 lea 0x18(%ebx),%edi 107e6e: 8d 75 d4 lea -0x2c(%ebp),%esi 107e71: b9 05 00 00 00 mov $0x5,%ecx 107e76: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode ); 107e78: 8b 43 20 mov 0x20(%ebx),%eax 107e7b: ff 75 c4 pushl -0x3c(%ebp) 107e7e: ff 75 0c pushl 0xc(%ebp) 107e81: ff 75 08 pushl 0x8(%ebp) 107e84: 53 push %ebx 107e85: ff 10 call *(%eax) if ( rc ) { 107e87: 83 c4 20 add $0x20,%esp 107e8a: 85 c0 test %eax,%eax 107e8c: 74 0f je 107e9d rc = errno; 107e8e: e8 b9 92 00 00 call 11114c <__errno> 107e93: 8b 30 mov (%eax),%esi rc = EEXIST; loc_to_free = &loc; goto done; } loc_to_free = &loc; 107e95: 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; 107e98: e9 8b 00 00 00 jmp 107f28 } /* * Optionally truncate the file. */ if ( (flags & O_TRUNC) == O_TRUNC ) { 107e9d: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 107ea4: 0f 84 ae 00 00 00 je 107f58 rc = ftruncate( iop - rtems_libio_iops, 0 ); 107eaa: 50 push %eax 107eab: 6a 00 push $0x0 107ead: 6a 00 push $0x0 107eaf: 89 d8 mov %ebx,%eax 107eb1: 2b 05 d8 51 12 00 sub 0x1251d8,%eax 107eb7: c1 f8 03 sar $0x3,%eax 107eba: 69 c0 b7 6d db b6 imul $0xb6db6db7,%eax,%eax 107ec0: 50 push %eax 107ec1: e8 ca 61 00 00 call 10e090 107ec6: 89 c6 mov %eax,%esi if ( rc ) { 107ec8: 83 c4 10 add $0x10,%esp 107ecb: 85 c0 test %eax,%eax 107ecd: 0f 84 85 00 00 00 je 107f58 if(errno) rc = errno; 107ed3: e8 74 92 00 00 call 11114c <__errno> 107ed8: 83 38 00 cmpl $0x0,(%eax) 107edb: 74 07 je 107ee4 <== NEVER TAKEN 107edd: e8 6a 92 00 00 call 11114c <__errno> 107ee2: 8b 30 mov (%eax),%esi close( iop - rtems_libio_iops ); 107ee4: 83 ec 0c sub $0xc,%esp 107ee7: 2b 1d d8 51 12 00 sub 0x1251d8,%ebx 107eed: c1 fb 03 sar $0x3,%ebx 107ef0: 69 db b7 6d db b6 imul $0xb6db6db7,%ebx,%ebx 107ef6: 53 push %ebx 107ef7: e8 24 61 00 00 call 10e020 107efc: 83 c4 10 add $0x10,%esp /* those are released by close(): */ iop = 0; loc_to_free = NULL; 107eff: 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; 107f01: 31 db xor %ebx,%ebx 107f03: eb 23 jmp 107f28 */ /* allocate a file control block */ iop = rtems_libio_allocate(); if ( iop == 0 ) { rc = ENFILE; 107f05: be 17 00 00 00 mov $0x17,%esi 107f0a: eb 40 jmp 107f4c 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; 107f0c: 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; 107f0e: be 02 00 00 00 mov $0x2,%esi 107f13: eb 17 jmp 107f2c 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; 107f15: 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; 107f17: be 0d 00 00 00 mov $0xd,%esi <== NOT EXECUTED 107f1c: eb 0e jmp 107f2c <== 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; 107f1e: 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; 107f21: be 11 00 00 00 mov $0x11,%esi 107f26: eb 04 jmp 107f2c * Single exit and clean up path. */ done: va_end(ap); if ( rc ) { 107f28: 85 f6 test %esi,%esi 107f2a: 74 2c je 107f58 <== NEVER TAKEN if ( iop ) 107f2c: 85 db test %ebx,%ebx 107f2e: 74 0c je 107f3c rtems_libio_free( iop ); 107f30: 83 ec 0c sub $0xc,%esp 107f33: 53 push %ebx 107f34: e8 2b 63 00 00 call 10e264 107f39: 83 c4 10 add $0x10,%esp if ( loc_to_free ) 107f3c: 85 ff test %edi,%edi 107f3e: 74 0c je 107f4c rtems_filesystem_freenode( loc_to_free ); 107f40: 83 ec 0c sub $0xc,%esp 107f43: 57 push %edi 107f44: e8 eb f3 ff ff call 107334 107f49: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( rc ); 107f4c: e8 fb 91 00 00 call 11114c <__errno> 107f51: 89 30 mov %esi,(%eax) 107f53: 83 c8 ff or $0xffffffff,%eax 107f56: eb 0f jmp 107f67 } return iop - rtems_libio_iops; 107f58: 2b 1d d8 51 12 00 sub 0x1251d8,%ebx 107f5e: c1 fb 03 sar $0x3,%ebx 107f61: 69 c3 b7 6d db b6 imul $0xb6db6db7,%ebx,%eax } 107f67: 8d 65 f4 lea -0xc(%ebp),%esp 107f6a: 5b pop %ebx 107f6b: 5e pop %esi 107f6c: 5f pop %edi 107f6d: c9 leave 107f6e: c3 ret =============================================================================== 00108b1e : /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) { 108b1e: 55 push %ebp 108b1f: 89 e5 mov %esp,%ebp 108b21: 56 push %esi 108b22: 53 push %ebx 108b23: 83 ec 10 sub $0x10,%esp 108b26: 89 d3 mov %edx,%ebx 108b28: 88 45 f4 mov %al,-0xc(%ebp) int i; if (tty->termios.c_oflag & OPOST) { 108b2b: 8b 52 34 mov 0x34(%edx),%edx 108b2e: f6 c2 01 test $0x1,%dl 108b31: 0f 84 ed 00 00 00 je 108c24 <== NEVER TAKEN switch (c) { 108b37: 3c 09 cmp $0x9,%al 108b39: 74 75 je 108bb0 108b3b: 77 0d ja 108b4a <== ALWAYS TAKEN 108b3d: 3c 08 cmp $0x8,%al <== NOT EXECUTED 108b3f: 0f 85 aa 00 00 00 jne 108bef <== NOT EXECUTED 108b45: e9 98 00 00 00 jmp 108be2 <== NOT EXECUTED 108b4a: 3c 0a cmp $0xa,%al 108b4c: 74 0a je 108b58 108b4e: 3c 0d cmp $0xd,%al 108b50: 0f 85 99 00 00 00 jne 108bef <== ALWAYS TAKEN 108b56: eb 32 jmp 108b8a <== NOT EXECUTED case '\n': if (tty->termios.c_oflag & ONLRET) 108b58: f6 c2 20 test $0x20,%dl 108b5b: 74 07 je 108b64 <== ALWAYS TAKEN tty->column = 0; 108b5d: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED if (tty->termios.c_oflag & ONLCR) { 108b64: 80 e2 04 and $0x4,%dl 108b67: 0f 84 b7 00 00 00 je 108c24 <== NEVER TAKEN rtems_termios_puts ("\r", 1, tty); 108b6d: 56 push %esi 108b6e: 53 push %ebx 108b6f: 6a 01 push $0x1 108b71: 68 40 f0 11 00 push $0x11f040 108b76: e8 83 fe ff ff call 1089fe tty->column = 0; 108b7b: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) 108b82: 83 c4 10 add $0x10,%esp 108b85: e9 9a 00 00 00 jmp 108c24 } break; case '\r': if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0)) 108b8a: f6 c2 10 test $0x10,%dl <== NOT EXECUTED 108b8d: 74 0a je 108b99 <== NOT EXECUTED 108b8f: 83 7b 28 00 cmpl $0x0,0x28(%ebx) <== NOT EXECUTED 108b93: 0f 84 9b 00 00 00 je 108c34 <== NOT EXECUTED return; if (tty->termios.c_oflag & OCRNL) { 108b99: f6 c2 08 test $0x8,%dl <== NOT EXECUTED 108b9c: 74 09 je 108ba7 <== NOT EXECUTED c = '\n'; 108b9e: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED if (tty->termios.c_oflag & ONLRET) 108ba2: 80 e2 20 and $0x20,%dl <== NOT EXECUTED 108ba5: 74 7d je 108c24 <== NOT EXECUTED tty->column = 0; break; } tty->column = 0; 108ba7: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED break; 108bae: eb 74 jmp 108c24 <== NOT EXECUTED case '\t': i = 8 - (tty->column & 7); 108bb0: 8b 4b 28 mov 0x28(%ebx),%ecx 108bb3: 89 ce mov %ecx,%esi 108bb5: 83 e6 07 and $0x7,%esi 108bb8: b8 08 00 00 00 mov $0x8,%eax 108bbd: 29 f0 sub %esi,%eax if ((tty->termios.c_oflag & TABDLY) == XTABS) { 108bbf: 81 e2 00 18 00 00 and $0x1800,%edx 108bc5: 81 fa 00 18 00 00 cmp $0x1800,%edx 108bcb: 8d 14 08 lea (%eax,%ecx,1),%edx 108bce: 75 0d jne 108bdd <== NEVER TAKEN tty->column += i; 108bd0: 89 53 28 mov %edx,0x28(%ebx) rtems_termios_puts ( " ", i, tty); 108bd3: 51 push %ecx 108bd4: 53 push %ebx 108bd5: 50 push %eax 108bd6: 68 00 ec 11 00 push $0x11ec00 108bdb: eb 4f jmp 108c2c return; } tty->column += i; 108bdd: 89 53 28 mov %edx,0x28(%ebx) <== NOT EXECUTED break; 108be0: eb 42 jmp 108c24 <== NOT EXECUTED case '\b': if (tty->column > 0) 108be2: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 108be5: 85 c0 test %eax,%eax <== NOT EXECUTED 108be7: 7e 3b jle 108c24 <== NOT EXECUTED tty->column--; 108be9: 48 dec %eax <== NOT EXECUTED 108bea: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 108bed: eb 35 jmp 108c24 <== NOT EXECUTED break; default: if (tty->termios.c_oflag & OLCUC) 108bef: 80 e2 02 and $0x2,%dl 108bf2: 74 1c je 108c10 <== ALWAYS TAKEN c = toupper(c); 108bf4: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 108bf7: 8b 15 1c 31 12 00 mov 0x12311c,%edx <== NOT EXECUTED 108bfd: 0f be 54 02 01 movsbl 0x1(%edx,%eax,1),%edx <== NOT EXECUTED 108c02: 83 e2 03 and $0x3,%edx <== NOT EXECUTED 108c05: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 108c08: 75 03 jne 108c0d <== NOT EXECUTED 108c0a: 83 e8 20 sub $0x20,%eax <== NOT EXECUTED 108c0d: 88 45 f4 mov %al,-0xc(%ebp) <== NOT EXECUTED if (!iscntrl(c)) 108c10: 0f b6 45 f4 movzbl -0xc(%ebp),%eax 108c14: 8b 15 1c 31 12 00 mov 0x12311c,%edx 108c1a: f6 44 02 01 20 testb $0x20,0x1(%edx,%eax,1) 108c1f: 75 03 jne 108c24 <== NEVER TAKEN tty->column++; 108c21: ff 43 28 incl 0x28(%ebx) break; } } rtems_termios_puts (&c, 1, tty); 108c24: 52 push %edx 108c25: 53 push %ebx 108c26: 6a 01 push $0x1 108c28: 8d 45 f4 lea -0xc(%ebp),%eax 108c2b: 50 push %eax 108c2c: e8 cd fd ff ff call 1089fe 108c31: 83 c4 10 add $0x10,%esp } 108c34: 8d 65 f8 lea -0x8(%ebp),%esp 108c37: 5b pop %ebx 108c38: 5e pop %esi 108c39: c9 leave 108c3a: c3 ret =============================================================================== 00108ff0 : extern int pipe_create(int filsdes[2]); int pipe( int filsdes[2] ) { 108ff0: 55 push %ebp 108ff1: 89 e5 mov %esp,%ebp 108ff3: 83 ec 08 sub $0x8,%esp 108ff6: 8b 45 08 mov 0x8(%ebp),%eax if (filsdes == NULL) 108ff9: 85 c0 test %eax,%eax 108ffb: 75 10 jne 10900d <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EFAULT ); 108ffd: e8 b2 99 00 00 call 1129b4 <__errno> 109002: c7 00 0e 00 00 00 movl $0xe,(%eax) return pipe_create(filsdes); } 109008: 83 c8 ff or $0xffffffff,%eax 10900b: c9 leave 10900c: c3 ret ) { if (filsdes == NULL) rtems_set_errno_and_return_minus_one( EFAULT ); return pipe_create(filsdes); 10900d: 89 45 08 mov %eax,0x8(%ebp) } 109010: c9 leave ) { if (filsdes == NULL) rtems_set_errno_and_return_minus_one( EFAULT ); return pipe_create(filsdes); 109011: e9 b6 5e 00 00 jmp 10eecc =============================================================================== 0010eecc : * Called by pipe() to create an anonymous pipe. */ int pipe_create( int filsdes[2] ) { 10eecc: 55 push %ebp 10eecd: 89 e5 mov %esp,%ebp 10eecf: 57 push %edi 10eed0: 56 push %esi 10eed1: 53 push %ebx 10eed2: 83 ec 34 sub $0x34,%esp rtems_libio_t *iop; int err = 0; if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0) 10eed5: 68 ff 01 00 00 push $0x1ff 10eeda: 68 08 0e 12 00 push $0x120e08 10eedf: e8 58 14 00 00 call 11033c 10eee4: 83 c4 10 add $0x10,%esp return -1; 10eee7: 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) 10eeee: 85 c0 test %eax,%eax 10eef0: 0f 85 e8 00 00 00 jne 10efde <== NEVER TAKEN return -1; /* /tmp/.fifoXXXX */ char fifopath[15]; memcpy(fifopath, "/tmp/.fifo", 10); 10eef6: 8d 5d d9 lea -0x27(%ebp),%ebx 10eef9: be 0d 0e 12 00 mov $0x120e0d,%esi 10eefe: b9 0a 00 00 00 mov $0xa,%ecx 10ef03: 89 df mov %ebx,%edi 10ef05: f3 a4 rep movsb %ds:(%esi),%es:(%edi) sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); 10ef07: 0f b7 05 00 60 12 00 movzwl 0x126000,%eax 10ef0e: 8d 50 01 lea 0x1(%eax),%edx 10ef11: 66 89 15 00 60 12 00 mov %dx,0x126000 10ef18: 57 push %edi 10ef19: 50 push %eax 10ef1a: 68 18 0e 12 00 push $0x120e18 10ef1f: 8d 45 e3 lea -0x1d(%ebp),%eax 10ef22: 50 push %eax 10ef23: e8 78 44 00 00 call 1133a0 /* Try creating FIFO file until find an available file name */ while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) { 10ef28: 59 pop %ecx 10ef29: 5e pop %esi 10ef2a: 68 80 01 00 00 push $0x180 10ef2f: 53 push %ebx 10ef30: e8 c7 11 00 00 call 1100fc 10ef35: 83 c4 10 add $0x10,%esp 10ef38: 85 c0 test %eax,%eax 10ef3a: 74 0a je 10ef46 if (errno != EEXIST){ 10ef3c: e8 73 3a 00 00 call 1129b4 <__errno> 10ef41: e9 98 00 00 00 jmp 10efde 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); 10ef46: 52 push %edx 10ef47: 52 push %edx 10ef48: 68 00 40 00 00 push $0x4000 10ef4d: 53 push %ebx 10ef4e: e8 89 9e ff ff call 108ddc 10ef53: 8b 55 08 mov 0x8(%ebp),%edx 10ef56: 89 02 mov %eax,(%edx) if (filsdes[0] < 0) { 10ef58: 83 c4 10 add $0x10,%esp 10ef5b: 85 c0 test %eax,%eax 10ef5d: 79 0d jns 10ef6c err = errno; 10ef5f: e8 50 3a 00 00 call 1129b4 <__errno> 10ef64: 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); 10ef66: 83 ec 0c sub $0xc,%esp 10ef69: 53 push %ebx 10ef6a: eb 51 jmp 10efbd } else { /* Reset open file to blocking mode */ iop = rtems_libio_iop(filsdes[0]); 10ef6c: 31 d2 xor %edx,%edx 10ef6e: 3b 05 44 21 12 00 cmp 0x122144,%eax 10ef74: 73 09 jae 10ef7f <== NEVER TAKEN 10ef76: 6b d0 38 imul $0x38,%eax,%edx 10ef79: 03 15 00 62 12 00 add 0x126200,%edx iop->flags &= ~LIBIO_FLAGS_NO_DELAY; 10ef7f: 83 62 14 fe andl $0xfffffffe,0x14(%edx) filsdes[1] = open(fifopath, O_WRONLY); 10ef83: 50 push %eax 10ef84: 50 push %eax 10ef85: 6a 01 push $0x1 10ef87: 8d 45 d9 lea -0x27(%ebp),%eax 10ef8a: 50 push %eax 10ef8b: e8 4c 9e ff ff call 108ddc 10ef90: 8b 55 08 mov 0x8(%ebp),%edx 10ef93: 89 42 04 mov %eax,0x4(%edx) if (filsdes[1] < 0) { 10ef96: 83 c4 10 add $0x10,%esp int pipe_create( int filsdes[2] ) { rtems_libio_t *iop; int err = 0; 10ef99: 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) { 10ef9b: 85 c0 test %eax,%eax 10ef9d: 79 17 jns 10efb6 err = errno; 10ef9f: e8 10 3a 00 00 call 1129b4 <__errno> 10efa4: 8b 30 mov (%eax),%esi close(filsdes[0]); 10efa6: 83 ec 0c sub $0xc,%esp 10efa9: 8b 45 08 mov 0x8(%ebp),%eax 10efac: ff 30 pushl (%eax) 10efae: e8 31 90 ff ff call 107fe4 10efb3: 83 c4 10 add $0x10,%esp } unlink(fifopath); 10efb6: 83 ec 0c sub $0xc,%esp 10efb9: 8d 45 d9 lea -0x27(%ebp),%eax 10efbc: 50 push %eax 10efbd: e8 b6 b9 ff ff call 10a978 10efc2: 83 c4 10 add $0x10,%esp } if(err != 0) rtems_set_errno_and_return_minus_one(err); return 0; 10efc5: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) err = errno; close(filsdes[0]); } unlink(fifopath); } if(err != 0) 10efcc: 85 f6 test %esi,%esi 10efce: 74 0e je 10efde rtems_set_errno_and_return_minus_one(err); 10efd0: e8 df 39 00 00 call 1129b4 <__errno> 10efd5: 89 30 mov %esi,(%eax) 10efd7: c7 45 d4 ff ff ff ff movl $0xffffffff,-0x2c(%ebp) return 0; } 10efde: 8b 45 d4 mov -0x2c(%ebp),%eax 10efe1: 8d 65 f4 lea -0xc(%ebp),%esp 10efe4: 5b pop %ebx 10efe5: 5e pop %esi 10efe6: 5f pop %edi 10efe7: c9 leave 10efe8: c3 ret =============================================================================== 001101bb : pipe_control_t *pipe, uint32_t cmd, void *buffer, rtems_libio_t *iop ) { 1101bb: 55 push %ebp 1101bc: 89 e5 mov %esp,%ebp 1101be: 56 push %esi 1101bf: 53 push %ebx 1101c0: 8b 5d 08 mov 0x8(%ebp),%ebx 1101c3: 8b 75 10 mov 0x10(%ebp),%esi *(unsigned int *)buffer = pipe->Length; PIPE_UNLOCK(pipe); return 0; } return -EINVAL; 1101c6: b8 ea ff ff ff mov $0xffffffea,%eax uint32_t cmd, void *buffer, rtems_libio_t *iop ) { if (cmd == FIONREAD) { 1101cb: 81 7d 0c 7f 66 04 40 cmpl $0x4004667f,0xc(%ebp) 1101d2: 75 36 jne 11020a if (buffer == NULL) return -EFAULT; 1101d4: b0 f2 mov $0xf2,%al void *buffer, rtems_libio_t *iop ) { if (cmd == FIONREAD) { if (buffer == NULL) 1101d6: 85 f6 test %esi,%esi 1101d8: 74 30 je 11020a return -EFAULT; if (! PIPE_LOCK(pipe)) 1101da: 51 push %ecx 1101db: 6a 00 push $0x0 1101dd: 6a 00 push $0x0 1101df: ff 73 28 pushl 0x28(%ebx) 1101e2: e8 25 ba ff ff call 10bc0c 1101e7: 89 c2 mov %eax,%edx 1101e9: 83 c4 10 add $0x10,%esp return -EINTR; 1101ec: b8 fc ff ff ff mov $0xfffffffc,%eax { if (cmd == FIONREAD) { if (buffer == NULL) return -EFAULT; if (! PIPE_LOCK(pipe)) 1101f1: 85 d2 test %edx,%edx 1101f3: 75 15 jne 11020a <== NEVER TAKEN return -EINTR; /* Return length of pipe */ *(unsigned int *)buffer = pipe->Length; 1101f5: 8b 43 0c mov 0xc(%ebx),%eax 1101f8: 89 06 mov %eax,(%esi) PIPE_UNLOCK(pipe); 1101fa: 83 ec 0c sub $0xc,%esp 1101fd: ff 73 28 pushl 0x28(%ebx) 110200: e8 f3 ba ff ff call 10bcf8 return 0; 110205: 83 c4 10 add $0x10,%esp 110208: 31 c0 xor %eax,%eax } return -EINVAL; } 11020a: 8d 65 f8 lea -0x8(%ebp),%esp 11020d: 5b pop %ebx 11020e: 5e pop %esi 11020f: c9 leave 110210: c3 ret =============================================================================== 0010feac : pipe_control_t *pipe, void *buffer, size_t count, rtems_libio_t *iop ) { 10feac: 55 push %ebp 10fead: 89 e5 mov %esp,%ebp 10feaf: 57 push %edi 10feb0: 56 push %esi 10feb1: 53 push %ebx 10feb2: 83 ec 30 sub $0x30,%esp 10feb5: 8b 5d 08 mov 0x8(%ebp),%ebx int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) 10feb8: 6a 00 push $0x0 10feba: 6a 00 push $0x0 10febc: ff 73 28 pushl 0x28(%ebx) 10febf: e8 48 bd ff ff call 10bc0c 10fec4: 83 c4 10 add $0x10,%esp return -EINTR; 10fec7: be fc ff ff ff mov $0xfffffffc,%esi rtems_libio_t *iop ) { int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) 10fecc: 85 c0 test %eax,%eax 10fece: 0f 85 2f 01 00 00 jne 110003 <== NEVER TAKEN 10fed4: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) 10fedb: e9 f0 00 00 00 jmp 10ffd0 return -EINTR; while (read < count) { while (PIPE_EMPTY(pipe)) { /* Not an error */ if (pipe->Writers == 0) 10fee0: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10fee4: 0f 84 f2 00 00 00 je 10ffdc goto out_locked; if (LIBIO_NODELAY(iop)) { 10feea: 8b 45 14 mov 0x14(%ebp),%eax 10feed: f6 40 14 01 testb $0x1,0x14(%eax) 10fef1: 0f 85 e9 00 00 00 jne 10ffe0 ret = -EAGAIN; goto out_locked; } /* Wait until pipe is no more empty or no writer exists */ pipe->waitingReaders ++; 10fef7: ff 43 18 incl 0x18(%ebx) PIPE_UNLOCK(pipe); 10fefa: 83 ec 0c sub $0xc,%esp 10fefd: ff 73 28 pushl 0x28(%ebx) 10ff00: e8 f3 bd ff ff call 10bcf8 if (! PIPE_READWAIT(pipe)) 10ff05: 5f pop %edi 10ff06: 58 pop %eax 10ff07: 6a 00 push $0x0 10ff09: ff 73 2c pushl 0x2c(%ebx) 10ff0c: e8 9f 16 00 00 call 1115b0 10ff11: 83 c4 0c add $0xc,%esp 10ff14: 83 f8 01 cmp $0x1,%eax 10ff17: 19 f6 sbb %esi,%esi 10ff19: f7 d6 not %esi 10ff1b: 83 e6 fc and $0xfffffffc,%esi ret = -EINTR; if (! PIPE_LOCK(pipe)) { 10ff1e: 6a 00 push $0x0 10ff20: 6a 00 push $0x0 10ff22: ff 73 28 pushl 0x28(%ebx) 10ff25: e8 e2 bc ff ff call 10bc0c 10ff2a: 83 c4 10 add $0x10,%esp 10ff2d: 85 c0 test %eax,%eax 10ff2f: 0f 85 c0 00 00 00 jne 10fff5 <== NEVER TAKEN /* WARN waitingReaders not restored! */ ret = -EINTR; goto out_nolock; } pipe->waitingReaders --; 10ff35: ff 4b 18 decl 0x18(%ebx) if (ret != 0) 10ff38: 85 f6 test %esi,%esi 10ff3a: 0f 85 a5 00 00 00 jne 10ffe5 <== NEVER TAKEN if (! PIPE_LOCK(pipe)) return -EINTR; while (read < count) { while (PIPE_EMPTY(pipe)) { 10ff40: 8b 53 0c mov 0xc(%ebx),%edx 10ff43: 85 d2 test %edx,%edx 10ff45: 74 99 je 10fee0 if (ret != 0) goto out_locked; } /* Read chunk bytes */ chunk = MIN(count - read, pipe->Length); 10ff47: 8b 45 10 mov 0x10(%ebp),%eax 10ff4a: 2b 45 d0 sub -0x30(%ebp),%eax 10ff4d: 89 55 d4 mov %edx,-0x2c(%ebp) 10ff50: 39 c2 cmp %eax,%edx 10ff52: 76 03 jbe 10ff57 10ff54: 89 45 d4 mov %eax,-0x2c(%ebp) chunk1 = pipe->Size - pipe->Start; 10ff57: 8b 73 08 mov 0x8(%ebx),%esi 10ff5a: 8b 43 04 mov 0x4(%ebx),%eax 10ff5d: 29 f0 sub %esi,%eax if (chunk > chunk1) { 10ff5f: 39 45 d4 cmp %eax,-0x2c(%ebp) 10ff62: 8b 7d 0c mov 0xc(%ebp),%edi 10ff65: 8b 4d d0 mov -0x30(%ebp),%ecx 10ff68: 8d 14 0f lea (%edi,%ecx,1),%edx 10ff6b: 7e 1b jle 10ff88 memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1); 10ff6d: 03 33 add (%ebx),%esi 10ff6f: 89 d7 mov %edx,%edi 10ff71: 89 c1 mov %eax,%ecx 10ff73: f3 a4 rep movsb %ds:(%esi),%es:(%edi) memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1); 10ff75: 8b 55 d0 mov -0x30(%ebp),%edx 10ff78: 01 c2 add %eax,%edx 10ff7a: 03 55 0c add 0xc(%ebp),%edx 10ff7d: 8b 4d d4 mov -0x2c(%ebp),%ecx 10ff80: 29 c1 sub %eax,%ecx 10ff82: 8b 33 mov (%ebx),%esi 10ff84: 89 d7 mov %edx,%edi 10ff86: eb 07 jmp 10ff8f } else memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk); 10ff88: 03 33 add (%ebx),%esi 10ff8a: 89 d7 mov %edx,%edi 10ff8c: 8b 4d d4 mov -0x2c(%ebp),%ecx 10ff8f: f3 a4 rep movsb %ds:(%esi),%es:(%edi) pipe->Start += chunk; 10ff91: 8b 45 d4 mov -0x2c(%ebp),%eax 10ff94: 03 43 08 add 0x8(%ebx),%eax pipe->Start %= pipe->Size; 10ff97: 31 d2 xor %edx,%edx 10ff99: f7 73 04 divl 0x4(%ebx) 10ff9c: 89 53 08 mov %edx,0x8(%ebx) pipe->Length -= chunk; 10ff9f: 8b 43 0c mov 0xc(%ebx),%eax 10ffa2: 2b 45 d4 sub -0x2c(%ebp),%eax 10ffa5: 89 43 0c mov %eax,0xc(%ebx) /* For buffering optimization */ if (PIPE_EMPTY(pipe)) 10ffa8: 85 c0 test %eax,%eax 10ffaa: 75 07 jne 10ffb3 pipe->Start = 0; 10ffac: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) if (pipe->waitingWriters > 0) 10ffb3: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx) 10ffb7: 74 11 je 10ffca PIPE_WAKEUPWRITERS(pipe); 10ffb9: 56 push %esi 10ffba: 56 push %esi 10ffbb: 8d 45 e4 lea -0x1c(%ebp),%eax 10ffbe: 50 push %eax 10ffbf: ff 73 30 pushl 0x30(%ebx) 10ffc2: e8 91 15 00 00 call 111558 10ffc7: 83 c4 10 add $0x10,%esp read += chunk; 10ffca: 8b 4d d4 mov -0x2c(%ebp),%ecx 10ffcd: 01 4d d0 add %ecx,-0x30(%ebp) int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) return -EINTR; while (read < count) { 10ffd0: 8b 7d 10 mov 0x10(%ebp),%edi 10ffd3: 39 7d d0 cmp %edi,-0x30(%ebp) 10ffd6: 0f 82 64 ff ff ff jb 10ff40 while (PIPE_EMPTY(pipe)) { /* Not an error */ if (pipe->Writers == 0) 10ffdc: 31 f6 xor %esi,%esi 10ffde: eb 05 jmp 10ffe5 goto out_locked; if (LIBIO_NODELAY(iop)) { ret = -EAGAIN; 10ffe0: be f5 ff ff ff mov $0xfffffff5,%esi PIPE_WAKEUPWRITERS(pipe); read += chunk; } out_locked: PIPE_UNLOCK(pipe); 10ffe5: 83 ec 0c sub $0xc,%esp 10ffe8: ff 73 28 pushl 0x28(%ebx) 10ffeb: e8 08 bd ff ff call 10bcf8 10fff0: 83 c4 10 add $0x10,%esp 10fff3: eb 05 jmp 10fffa PIPE_UNLOCK(pipe); if (! PIPE_READWAIT(pipe)) ret = -EINTR; if (! PIPE_LOCK(pipe)) { /* WARN waitingReaders not restored! */ ret = -EINTR; 10fff5: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED out_locked: PIPE_UNLOCK(pipe); out_nolock: if (read > 0) 10fffa: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 10fffe: 7e 03 jle 110003 110000: 8b 75 d0 mov -0x30(%ebp),%esi return read; return ret; } 110003: 89 f0 mov %esi,%eax 110005: 8d 65 f4 lea -0xc(%ebp),%esp 110008: 5b pop %ebx 110009: 5e pop %esi 11000a: 5f pop %edi 11000b: c9 leave 11000c: c3 ret =============================================================================== 0010fa51 : */ void pipe_release( pipe_control_t **pipep, rtems_libio_t *iop ) { 10fa51: 55 push %ebp 10fa52: 89 e5 mov %esp,%ebp 10fa54: 57 push %edi 10fa55: 56 push %esi 10fa56: 53 push %ebx 10fa57: 83 ec 1c sub $0x1c,%esp 10fa5a: 8b 7d 08 mov 0x8(%ebp),%edi pipe_control_t *pipe = *pipep; 10fa5d: 8b 1f mov (%edi),%ebx /* WARN pipe not released! */ if (!PIPE_LOCK(pipe)) rtems_fatal_error_occurred(0xdeadbeef); #endif mode = LIBIO_ACCMODE(iop); 10fa5f: 8b 45 0c mov 0xc(%ebp),%eax 10fa62: 8b 40 14 mov 0x14(%eax),%eax 10fa65: 89 c6 mov %eax,%esi 10fa67: 83 e6 06 and $0x6,%esi if (mode & LIBIO_FLAGS_READ) 10fa6a: a8 02 test $0x2,%al 10fa6c: 74 03 je 10fa71 pipe->Readers --; 10fa6e: ff 4b 10 decl 0x10(%ebx) if (mode & LIBIO_FLAGS_WRITE) 10fa71: f7 c6 04 00 00 00 test $0x4,%esi 10fa77: 74 03 je 10fa7c pipe->Writers --; 10fa79: ff 4b 14 decl 0x14(%ebx) PIPE_UNLOCK(pipe); 10fa7c: 83 ec 0c sub $0xc,%esp 10fa7f: ff 73 28 pushl 0x28(%ebx) 10fa82: e8 71 c2 ff ff call 10bcf8 if (pipe->Readers == 0 && pipe->Writers == 0) { 10fa87: 8b 43 10 mov 0x10(%ebx),%eax 10fa8a: 83 c4 10 add $0x10,%esp 10fa8d: 85 c0 test %eax,%eax 10fa8f: 75 15 jne 10faa6 10fa91: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10fa95: 75 0f jne 10faa6 #if 0 /* To delete an anonymous pipe file when all users closed it */ if (pipe->Anonymous) delfile = TRUE; #endif pipe_free(pipe); 10fa97: 89 d8 mov %ebx,%eax 10fa99: e8 78 ff ff ff call 10fa16 *pipep = NULL; 10fa9e: c7 07 00 00 00 00 movl $0x0,(%edi) 10faa4: eb 30 jmp 10fad6 } else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE) 10faa6: 83 fe 04 cmp $0x4,%esi 10faa9: 74 0f je 10faba 10faab: 85 c0 test %eax,%eax 10faad: 75 0b jne 10faba <== NEVER TAKEN /* Notify waiting Writers that all their partners left */ PIPE_WAKEUPWRITERS(pipe); 10faaf: 57 push %edi 10fab0: 57 push %edi 10fab1: 8d 45 e4 lea -0x1c(%ebp),%eax 10fab4: 50 push %eax 10fab5: ff 73 30 pushl 0x30(%ebx) 10fab8: eb 14 jmp 10face else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ) 10faba: 83 fe 02 cmp $0x2,%esi 10fabd: 74 17 je 10fad6 <== NEVER TAKEN 10fabf: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10fac3: 75 11 jne 10fad6 <== NEVER TAKEN PIPE_WAKEUPREADERS(pipe); 10fac5: 56 push %esi 10fac6: 56 push %esi 10fac7: 8d 45 e4 lea -0x1c(%ebp),%eax 10faca: 50 push %eax 10facb: ff 73 2c pushl 0x2c(%ebx) 10face: e8 85 1a 00 00 call 111558 10fad3: 83 c4 10 add $0x10,%esp pipe_unlock(); 10fad6: e8 25 ff ff ff call 10fa00 iop->flags &= ~LIBIO_FLAGS_OPEN; if(iop->pathinfo.ops->unlink_h(&iop->pathinfo)) return; #endif } 10fadb: 8d 65 f4 lea -0xc(%ebp),%esp 10fade: 5b pop %ebx 10fadf: 5e pop %esi 10fae0: 5f pop %edi 10fae1: c9 leave 10fae2: c3 ret =============================================================================== 0011000d : pipe_control_t *pipe, const void *buffer, size_t count, rtems_libio_t *iop ) { 11000d: 55 push %ebp 11000e: 89 e5 mov %esp,%ebp 110010: 57 push %edi 110011: 56 push %esi 110012: 53 push %ebx 110013: 83 ec 2c sub $0x2c,%esp 110016: 8b 5d 08 mov 0x8(%ebp),%ebx int chunk, chunk1, written = 0, ret = 0; /* Write nothing */ if (count == 0) return 0; 110019: 31 f6 xor %esi,%esi ) { int chunk, chunk1, written = 0, ret = 0; /* Write nothing */ if (count == 0) 11001b: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 11001f: 0f 84 8c 01 00 00 je 1101b1 <== NEVER TAKEN return 0; if (! PIPE_LOCK(pipe)) 110025: 52 push %edx 110026: 6a 00 push $0x0 110028: 6a 00 push $0x0 11002a: ff 73 28 pushl 0x28(%ebx) 11002d: e8 da bb ff ff call 10bc0c 110032: 83 c4 10 add $0x10,%esp return -EINTR; 110035: be fc ff ff ff mov $0xfffffffc,%esi /* Write nothing */ if (count == 0) return 0; if (! PIPE_LOCK(pipe)) 11003a: 85 c0 test %eax,%eax 11003c: 0f 85 6f 01 00 00 jne 1101b1 <== NEVER TAKEN return -EINTR; if (pipe->Readers == 0) { 110042: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 110046: 0f 84 16 01 00 00 je 110162 ret = -EPIPE; goto out_locked; } /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; 11004c: bf 01 00 00 00 mov $0x1,%edi 110051: 8b 45 10 mov 0x10(%ebp),%eax 110054: 3b 43 04 cmp 0x4(%ebx),%eax 110057: 77 02 ja 11005b <== NEVER TAKEN 110059: 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; 11005b: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) 110062: e9 eb 00 00 00 jmp 110152 /* 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)) { 110067: 8b 4d 14 mov 0x14(%ebp),%ecx 11006a: f6 41 14 01 testb $0x1,0x14(%ecx) 11006e: 0f 85 fc 00 00 00 jne 110170 ret = -EAGAIN; goto out_locked; } /* Wait until there is chunk bytes space or no reader exists */ pipe->waitingWriters ++; 110074: ff 43 1c incl 0x1c(%ebx) PIPE_UNLOCK(pipe); 110077: 83 ec 0c sub $0xc,%esp 11007a: ff 73 28 pushl 0x28(%ebx) 11007d: e8 76 bc ff ff call 10bcf8 if (! PIPE_WRITEWAIT(pipe)) 110082: 5e pop %esi 110083: 58 pop %eax 110084: 6a 00 push $0x0 110086: ff 73 30 pushl 0x30(%ebx) 110089: e8 22 15 00 00 call 1115b0 11008e: 83 c4 0c add $0xc,%esp 110091: 83 f8 01 cmp $0x1,%eax 110094: 19 f6 sbb %esi,%esi 110096: f7 d6 not %esi 110098: 83 e6 fc and $0xfffffffc,%esi ret = -EINTR; if (! PIPE_LOCK(pipe)) { 11009b: 6a 00 push $0x0 11009d: 6a 00 push $0x0 11009f: ff 73 28 pushl 0x28(%ebx) 1100a2: e8 65 bb ff ff call 10bc0c 1100a7: 83 c4 10 add $0x10,%esp 1100aa: 85 c0 test %eax,%eax 1100ac: 0f 85 f1 00 00 00 jne 1101a3 <== NEVER TAKEN /* WARN waitingWriters not restored! */ ret = -EINTR; goto out_nolock; } pipe->waitingWriters --; 1100b2: ff 4b 1c decl 0x1c(%ebx) if (ret != 0) 1100b5: 85 f6 test %esi,%esi 1100b7: 0f 85 bf 00 00 00 jne 11017c <== NEVER TAKEN goto out_locked; if (pipe->Readers == 0) { 1100bd: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 1100c1: 0f 84 b0 00 00 00 je 110177 <== 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) { 1100c7: 8b 73 04 mov 0x4(%ebx),%esi 1100ca: 8b 43 0c mov 0xc(%ebx),%eax 1100cd: 89 f1 mov %esi,%ecx 1100cf: 29 c1 sub %eax,%ecx 1100d1: 39 f9 cmp %edi,%ecx 1100d3: 72 92 jb 110067 ret = -EPIPE; goto out_locked; } } chunk = MIN(count - written, PIPE_SPACE(pipe)); 1100d5: 8b 55 10 mov 0x10(%ebp),%edx 1100d8: 2b 55 d4 sub -0x2c(%ebp),%edx 1100db: 89 4d d0 mov %ecx,-0x30(%ebp) 1100de: 39 d1 cmp %edx,%ecx 1100e0: 76 03 jbe 1100e5 1100e2: 89 55 d0 mov %edx,-0x30(%ebp) chunk1 = pipe->Size - PIPE_WSTART(pipe); 1100e5: 03 43 08 add 0x8(%ebx),%eax 1100e8: 31 d2 xor %edx,%edx 1100ea: f7 f6 div %esi 1100ec: 29 d6 sub %edx,%esi 1100ee: 89 75 cc mov %esi,-0x34(%ebp) if (chunk > chunk1) { 1100f1: 39 75 d0 cmp %esi,-0x30(%ebp) 1100f4: 8b 4d 0c mov 0xc(%ebp),%ecx 1100f7: 8b 45 d4 mov -0x2c(%ebp),%eax 1100fa: 8d 34 01 lea (%ecx,%eax,1),%esi 1100fd: 7e 20 jle 11011f memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1); 1100ff: 8b 03 mov (%ebx),%eax 110101: 01 d0 add %edx,%eax 110103: 89 c7 mov %eax,%edi 110105: 8b 4d cc mov -0x34(%ebp),%ecx 110108: f3 a4 rep movsb %ds:(%esi),%es:(%edi) memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1); 11010a: 8b 03 mov (%ebx),%eax 11010c: 8b 4d d0 mov -0x30(%ebp),%ecx 11010f: 2b 4d cc sub -0x34(%ebp),%ecx 110112: 8b 75 cc mov -0x34(%ebp),%esi 110115: 03 75 d4 add -0x2c(%ebp),%esi 110118: 03 75 0c add 0xc(%ebp),%esi 11011b: 89 c7 mov %eax,%edi 11011d: eb 09 jmp 110128 } else memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk); 11011f: 8b 03 mov (%ebx),%eax 110121: 01 d0 add %edx,%eax 110123: 89 c7 mov %eax,%edi 110125: 8b 4d d0 mov -0x30(%ebp),%ecx 110128: f3 a4 rep movsb %ds:(%esi),%es:(%edi) pipe->Length += chunk; 11012a: 8b 45 d0 mov -0x30(%ebp),%eax 11012d: 01 43 0c add %eax,0xc(%ebx) if (pipe->waitingReaders > 0) 110130: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 110134: 74 11 je 110147 PIPE_WAKEUPREADERS(pipe); 110136: 51 push %ecx 110137: 51 push %ecx 110138: 8d 4d e4 lea -0x1c(%ebp),%ecx 11013b: 51 push %ecx 11013c: ff 73 2c pushl 0x2c(%ebx) 11013f: e8 14 14 00 00 call 111558 110144: 83 c4 10 add $0x10,%esp written += chunk; 110147: 8b 45 d0 mov -0x30(%ebp),%eax 11014a: 01 45 d4 add %eax,-0x2c(%ebp) /* Write of more than PIPE_BUF bytes can be interleaved */ chunk = 1; 11014d: 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) { 110152: 8b 4d 10 mov 0x10(%ebp),%ecx 110155: 39 4d d4 cmp %ecx,-0x2c(%ebp) 110158: 0f 82 69 ff ff ff jb 1100c7 11015e: 31 f6 xor %esi,%esi 110160: eb 1a jmp 11017c if (! PIPE_LOCK(pipe)) return -EINTR; if (pipe->Readers == 0) { ret = -EPIPE; 110162: 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; 110167: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) 11016e: eb 0c jmp 11017c chunk = count <= pipe->Size ? count : 1; while (written < count) { while (PIPE_SPACE(pipe) < chunk) { if (LIBIO_NODELAY(iop)) { ret = -EAGAIN; 110170: be f5 ff ff ff mov $0xfffffff5,%esi 110175: eb 05 jmp 11017c pipe->waitingWriters --; if (ret != 0) goto out_locked; if (pipe->Readers == 0) { ret = -EPIPE; 110177: 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); 11017c: 83 ec 0c sub $0xc,%esp 11017f: ff 73 28 pushl 0x28(%ebx) 110182: e8 71 bb ff ff call 10bcf8 110187: 83 c4 10 add $0x10,%esp out_nolock: #ifdef RTEMS_POSIX_API /* Signal SIGPIPE */ if (ret == -EPIPE) 11018a: 83 fe e0 cmp $0xffffffe0,%esi 11018d: 75 19 jne 1101a8 kill(getpid(), SIGPIPE); 11018f: e8 24 07 00 00 call 1108b8 110194: 52 push %edx 110195: 52 push %edx 110196: 6a 0d push $0xd 110198: 50 push %eax 110199: e8 a2 09 00 00 call 110b40 11019e: 83 c4 10 add $0x10,%esp 1101a1: eb 05 jmp 1101a8 PIPE_UNLOCK(pipe); if (! PIPE_WRITEWAIT(pipe)) ret = -EINTR; if (! PIPE_LOCK(pipe)) { /* WARN waitingWriters not restored! */ ret = -EINTR; 1101a3: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED /* Signal SIGPIPE */ if (ret == -EPIPE) kill(getpid(), SIGPIPE); #endif if (written > 0) 1101a8: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 1101ac: 7e 03 jle 1101b1 1101ae: 8b 75 d4 mov -0x2c(%ebp),%esi return written; return ret; } 1101b1: 89 f0 mov %esi,%eax 1101b3: 8d 65 f4 lea -0xc(%ebp),%esp 1101b6: 5b pop %ebx 1101b7: 5e pop %esi 1101b8: 5f pop %edi 1101b9: c9 leave 1101ba: c3 ret =============================================================================== 0010a7d4 : int posix_memalign( void **pointer, size_t alignment, size_t size ) { 10a7d4: 55 push %ebp 10a7d5: 89 e5 mov %esp,%ebp 10a7d7: 53 push %ebx 10a7d8: 83 ec 04 sub $0x4,%esp 10a7db: 8b 45 0c mov 0xc(%ebp),%eax /* * Update call statistics */ MSBUMP(memalign_calls, 1); 10a7de: ff 05 64 c3 12 00 incl 0x12c364 if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *))) 10a7e4: 8d 58 ff lea -0x1(%eax),%ebx 10a7e7: 85 c3 test %eax,%ebx 10a7e9: 75 0d jne 10a7f8 <== NEVER TAKEN 10a7eb: 83 f8 03 cmp $0x3,%eax 10a7ee: 76 08 jbe 10a7f8 /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); } 10a7f0: 59 pop %ecx 10a7f1: 5b pop %ebx 10a7f2: c9 leave /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); 10a7f3: e9 74 01 00 00 jmp 10a96c } 10a7f8: b8 16 00 00 00 mov $0x16,%eax 10a7fd: 5a pop %edx 10a7fe: 5b pop %ebx 10a7ff: c9 leave 10a800: c3 ret =============================================================================== 0010efdc : int pthread_attr_getinheritsched( const pthread_attr_t *attr, int *inheritsched ) { 10efdc: 55 push %ebp 10efdd: 89 e5 mov %esp,%ebp 10efdf: 8b 55 08 mov 0x8(%ebp),%edx 10efe2: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized || !inheritsched ) return EINVAL; 10efe5: b8 16 00 00 00 mov $0x16,%eax int pthread_attr_getinheritsched( const pthread_attr_t *attr, int *inheritsched ) { if ( !attr || !attr->is_initialized || !inheritsched ) 10efea: 85 d2 test %edx,%edx 10efec: 74 17 je 10f005 <== NEVER TAKEN 10efee: 85 c9 test %ecx,%ecx 10eff0: 74 0e je 10f000 <== NEVER TAKEN 10eff2: 83 3a 00 cmpl $0x0,(%edx) 10eff5: 74 09 je 10f000 <== NEVER TAKEN return EINVAL; *inheritsched = attr->inheritsched; 10eff7: 8b 42 10 mov 0x10(%edx),%eax 10effa: 89 01 mov %eax,(%ecx) return 0; 10effc: 31 c0 xor %eax,%eax 10effe: eb 05 jmp 10f005 const pthread_attr_t *attr, int *inheritsched ) { if ( !attr || !attr->is_initialized || !inheritsched ) return EINVAL; 10f000: b8 16 00 00 00 mov $0x16,%eax *inheritsched = attr->inheritsched; return 0; } 10f005: c9 leave 10f006: c3 ret =============================================================================== 0010f1f8 : int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { 10f1f8: 55 push %ebp 10f1f9: 89 e5 mov %esp,%ebp 10f1fb: 8b 55 08 mov 0x8(%ebp),%edx 10f1fe: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 10f201: b8 16 00 00 00 mov $0x16,%eax int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { if ( !attr || !attr->is_initialized ) 10f206: 85 d2 test %edx,%edx 10f208: 74 1e je 10f228 10f20a: 83 3a 00 cmpl $0x0,(%edx) 10f20d: 74 19 je 10f228 return EINVAL; switch ( policy ) { 10f20f: 83 f9 04 cmp $0x4,%ecx 10f212: 77 0f ja 10f223 10f214: b0 01 mov $0x1,%al 10f216: d3 e0 shl %cl,%eax 10f218: a8 17 test $0x17,%al 10f21a: 74 07 je 10f223 <== NEVER TAKEN case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: case SCHED_SPORADIC: attr->schedpolicy = policy; 10f21c: 89 4a 14 mov %ecx,0x14(%edx) return 0; 10f21f: 31 c0 xor %eax,%eax 10f221: eb 05 jmp 10f228 default: return ENOTSUP; 10f223: b8 86 00 00 00 mov $0x86,%eax } } 10f228: c9 leave 10f229: c3 ret =============================================================================== 0010a518 : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 10a518: 55 push %ebp 10a519: 89 e5 mov %esp,%ebp 10a51b: 57 push %edi 10a51c: 56 push %esi 10a51d: 53 push %ebx 10a51e: 83 ec 1c sub $0x1c,%esp 10a521: 8b 5d 08 mov 0x8(%ebp),%ebx 10a524: 8b 75 10 mov 0x10(%ebp),%esi /* * Error check parameters */ if ( !barrier ) return EINVAL; 10a527: b8 16 00 00 00 mov $0x16,%eax const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 10a52c: 85 db test %ebx,%ebx 10a52e: 0f 84 96 00 00 00 je 10a5ca return EINVAL; if ( count == 0 ) 10a534: 85 f6 test %esi,%esi 10a536: 0f 84 8e 00 00 00 je 10a5ca return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10a53c: 8b 7d 0c mov 0xc(%ebp),%edi 10a53f: 85 ff test %edi,%edi 10a541: 75 0f jne 10a552 the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 10a543: 83 ec 0c sub $0xc,%esp 10a546: 8d 7d d8 lea -0x28(%ebp),%edi 10a549: 57 push %edi 10a54a: e8 19 ff ff ff call 10a468 10a54f: 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; 10a552: 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 ) 10a557: 83 3f 00 cmpl $0x0,(%edi) 10a55a: 74 6e je 10a5ca return EINVAL; switch ( the_attr->process_shared ) { 10a55c: 83 7f 04 00 cmpl $0x0,0x4(%edi) 10a560: 75 68 jne 10a5ca <== NEVER TAKEN } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 10a562: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) the_attributes.maximum_count = count; 10a569: 89 75 e4 mov %esi,-0x1c(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a56c: a1 30 63 12 00 mov 0x126330,%eax 10a571: 40 inc %eax 10a572: a3 30 63 12 00 mov %eax,0x126330 * 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 ); 10a577: 83 ec 0c sub $0xc,%esp 10a57a: 68 f4 66 12 00 push $0x1266f4 10a57f: e8 0c 1e 00 00 call 10c390 <_Objects_Allocate> 10a584: 89 c6 mov %eax,%esi */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 10a586: 83 c4 10 add $0x10,%esp 10a589: 85 c0 test %eax,%eax 10a58b: 75 0c jne 10a599 _Thread_Enable_dispatch(); 10a58d: e8 0c 2c 00 00 call 10d19e <_Thread_Enable_dispatch> return EAGAIN; 10a592: b8 0b 00 00 00 mov $0xb,%eax 10a597: eb 31 jmp 10a5ca } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 10a599: 50 push %eax 10a59a: 50 push %eax 10a59b: 8d 45 e0 lea -0x20(%ebp),%eax 10a59e: 50 push %eax 10a59f: 8d 46 10 lea 0x10(%esi),%eax 10a5a2: 50 push %eax 10a5a3: e8 a8 14 00 00 call 10ba50 <_CORE_barrier_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10a5a8: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10a5ab: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10a5ae: 8b 15 10 67 12 00 mov 0x126710,%edx 10a5b4: 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; 10a5b7: 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; 10a5be: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10a5c0: e8 d9 2b 00 00 call 10d19e <_Thread_Enable_dispatch> return 0; 10a5c5: 83 c4 10 add $0x10,%esp 10a5c8: 31 c0 xor %eax,%eax } 10a5ca: 8d 65 f4 lea -0xc(%ebp),%esp 10a5cd: 5b pop %ebx 10a5ce: 5e pop %esi 10a5cf: 5f pop %edi 10a5d0: c9 leave 10a5d1: c3 ret =============================================================================== 00109ed0 : void pthread_cleanup_push( void (*routine)( void * ), void *arg ) { 109ed0: 55 push %ebp 109ed1: 89 e5 mov %esp,%ebp 109ed3: 56 push %esi 109ed4: 53 push %ebx 109ed5: 8b 5d 08 mov 0x8(%ebp),%ebx 109ed8: 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 ) 109edb: 85 db test %ebx,%ebx 109edd: 74 4b je 109f2a rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 109edf: a1 08 63 12 00 mov 0x126308,%eax 109ee4: 40 inc %eax 109ee5: a3 08 63 12 00 mov %eax,0x126308 return; _Thread_Disable_dispatch(); handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); 109eea: 83 ec 0c sub $0xc,%esp 109eed: 6a 10 push $0x10 109eef: e8 02 3c 00 00 call 10daf6 <_Workspace_Allocate> if ( handler ) { 109ef4: 83 c4 10 add $0x10,%esp 109ef7: 85 c0 test %eax,%eax 109ef9: 74 24 je 109f1f <== NEVER TAKEN thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 109efb: 8b 15 50 68 12 00 mov 0x126850,%edx handler_stack = &thread_support->Cancellation_Handlers; 109f01: 8b 92 ec 00 00 00 mov 0xec(%edx),%edx 109f07: 81 c2 e4 00 00 00 add $0xe4,%edx handler->routine = routine; 109f0d: 89 58 08 mov %ebx,0x8(%eax) handler->arg = arg; 109f10: 89 70 0c mov %esi,0xc(%eax) _Chain_Append( handler_stack, &handler->Node ); 109f13: 51 push %ecx 109f14: 51 push %ecx 109f15: 50 push %eax 109f16: 52 push %edx 109f17: e8 88 15 00 00 call 10b4a4 <_Chain_Append> 109f1c: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); } 109f1f: 8d 65 f8 lea -0x8(%ebp),%esp 109f22: 5b pop %ebx 109f23: 5e pop %esi 109f24: c9 leave handler->routine = routine; handler->arg = arg; _Chain_Append( handler_stack, &handler->Node ); } _Thread_Enable_dispatch(); 109f25: e9 70 2c 00 00 jmp 10cb9a <_Thread_Enable_dispatch> } 109f2a: 8d 65 f8 lea -0x8(%ebp),%esp 109f2d: 5b pop %ebx 109f2e: 5e pop %esi 109f2f: c9 leave 109f30: c3 ret =============================================================================== 0010ac40 : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 10ac40: 55 push %ebp 10ac41: 89 e5 mov %esp,%ebp 10ac43: 56 push %esi 10ac44: 53 push %ebx POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 10ac45: 8b 5d 0c mov 0xc(%ebp),%ebx 10ac48: 85 db test %ebx,%ebx 10ac4a: 75 05 jne 10ac51 else the_attr = &_POSIX_Condition_variables_Default_attributes; 10ac4c: bb b0 15 12 00 mov $0x1215b0,%ebx /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) return EINVAL; 10ac51: 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 ) 10ac56: 83 7b 04 01 cmpl $0x1,0x4(%ebx) 10ac5a: 74 76 je 10acd2 <== NEVER TAKEN return EINVAL; if ( !the_attr->is_initialized ) 10ac5c: 83 3b 00 cmpl $0x0,(%ebx) 10ac5f: 74 71 je 10acd2 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10ac61: a1 20 73 12 00 mov 0x127320,%eax 10ac66: 40 inc %eax 10ac67: a3 20 73 12 00 mov %eax,0x127320 RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control *_POSIX_Condition_variables_Allocate( void ) { return (POSIX_Condition_variables_Control *) _Objects_Allocate( &_POSIX_Condition_variables_Information ); 10ac6c: 83 ec 0c sub $0xc,%esp 10ac6f: 68 7c 77 12 00 push $0x12777c 10ac74: e8 f7 22 00 00 call 10cf70 <_Objects_Allocate> 10ac79: 89 c6 mov %eax,%esi _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 10ac7b: 83 c4 10 add $0x10,%esp 10ac7e: 85 c0 test %eax,%eax 10ac80: 75 0c jne 10ac8e _Thread_Enable_dispatch(); 10ac82: e8 f7 30 00 00 call 10dd7e <_Thread_Enable_dispatch> return ENOMEM; 10ac87: b8 0c 00 00 00 mov $0xc,%eax 10ac8c: eb 44 jmp 10acd2 } the_cond->process_shared = the_attr->process_shared; 10ac8e: 8b 43 04 mov 0x4(%ebx),%eax 10ac91: 89 46 10 mov %eax,0x10(%esi) the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 10ac94: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) _Thread_queue_Initialize( 10ac9b: 6a 74 push $0x74 10ac9d: 68 00 08 00 10 push $0x10000800 10aca2: 6a 00 push $0x0 10aca4: 8d 46 18 lea 0x18(%esi),%eax 10aca7: 50 push %eax 10aca8: e8 c7 37 00 00 call 10e474 <_Thread_queue_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10acad: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10acb0: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10acb3: 8b 15 98 77 12 00 mov 0x127798,%edx 10acb9: 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; 10acbc: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 10acc3: 8b 55 08 mov 0x8(%ebp),%edx 10acc6: 89 02 mov %eax,(%edx) _Thread_Enable_dispatch(); 10acc8: e8 b1 30 00 00 call 10dd7e <_Thread_Enable_dispatch> return 0; 10accd: 83 c4 10 add $0x10,%esp 10acd0: 31 c0 xor %eax,%eax } 10acd2: 8d 65 f8 lea -0x8(%ebp),%esp 10acd5: 5b pop %ebx 10acd6: 5e pop %esi 10acd7: c9 leave 10acd8: c3 ret =============================================================================== 0010aaf4 : */ int pthread_condattr_destroy( pthread_condattr_t *attr ) { 10aaf4: 55 push %ebp 10aaf5: 89 e5 mov %esp,%ebp 10aaf7: 8b 55 08 mov 0x8(%ebp),%edx if ( !attr || attr->is_initialized == false ) return EINVAL; 10aafa: b8 16 00 00 00 mov $0x16,%eax int pthread_condattr_destroy( pthread_condattr_t *attr ) { if ( !attr || attr->is_initialized == false ) 10aaff: 85 d2 test %edx,%edx 10ab01: 74 0d je 10ab10 10ab03: 83 3a 00 cmpl $0x0,(%edx) 10ab06: 74 08 je 10ab10 <== NEVER TAKEN return EINVAL; attr->is_initialized = false; 10ab08: c7 02 00 00 00 00 movl $0x0,(%edx) return 0; 10ab0e: 30 c0 xor %al,%al } 10ab10: c9 leave 10ab11: c3 ret =============================================================================== 0010a228 : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 10a228: 55 push %ebp 10a229: 89 e5 mov %esp,%ebp 10a22b: 57 push %edi 10a22c: 56 push %esi 10a22d: 53 push %ebx 10a22e: 83 ec 5c sub $0x5c,%esp struct sched_param schedparam; Objects_Name name; int rc; if ( !start_routine ) return EFAULT; 10a231: 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 ) 10a238: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a23c: 0f 84 0f 02 00 00 je 10a451 return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 10a242: 8b 5d 0c mov 0xc(%ebp),%ebx 10a245: 85 db test %ebx,%ebx 10a247: 75 05 jne 10a24e 10a249: bb 1c 02 12 00 mov $0x12021c,%ebx if ( !the_attr->is_initialized ) return EINVAL; 10a24e: 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 ) 10a255: 83 3b 00 cmpl $0x0,(%ebx) 10a258: 0f 84 f3 01 00 00 je 10a451 * 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) ) 10a25e: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a262: 74 0e je 10a272 10a264: a1 14 22 12 00 mov 0x122214,%eax 10a269: 39 43 08 cmp %eax,0x8(%ebx) 10a26c: 0f 82 df 01 00 00 jb 10a451 * 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 ) { 10a272: 8b 43 10 mov 0x10(%ebx),%eax 10a275: 83 f8 01 cmp $0x1,%eax 10a278: 74 0b je 10a285 10a27a: 83 f8 02 cmp $0x2,%eax 10a27d: 0f 85 c7 01 00 00 jne 10a44a 10a283: eb 1f jmp 10a2a4 case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a285: a1 58 68 12 00 mov 0x126858,%eax 10a28a: 8b b0 ec 00 00 00 mov 0xec(%eax),%esi schedpolicy = api->schedpolicy; 10a290: 8b 86 84 00 00 00 mov 0x84(%esi),%eax 10a296: 89 45 ac mov %eax,-0x54(%ebp) schedparam = api->schedparam; 10a299: 8d 7d c4 lea -0x3c(%ebp),%edi 10a29c: 81 c6 88 00 00 00 add $0x88,%esi 10a2a2: eb 0c jmp 10a2b0 break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 10a2a4: 8b 43 14 mov 0x14(%ebx),%eax 10a2a7: 89 45 ac mov %eax,-0x54(%ebp) schedparam = the_attr->schedparam; 10a2aa: 8d 7d c4 lea -0x3c(%ebp),%edi 10a2ad: 8d 73 18 lea 0x18(%ebx),%esi 10a2b0: b9 07 00 00 00 mov $0x7,%ecx 10a2b5: 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; 10a2b7: 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 ) 10a2be: 83 7b 0c 00 cmpl $0x0,0xc(%ebx) 10a2c2: 0f 85 89 01 00 00 jne 10a451 return ENOTSUP; /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 10a2c8: 83 ec 0c sub $0xc,%esp 10a2cb: ff 75 c4 pushl -0x3c(%ebp) 10a2ce: e8 f1 58 00 00 call 10fbc4 <_POSIX_Priority_Is_valid> 10a2d3: 83 c4 10 add $0x10,%esp return EINVAL; 10a2d6: 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 ) ) 10a2dd: 84 c0 test %al,%al 10a2df: 0f 84 6c 01 00 00 je 10a451 <== NEVER TAKEN return EINVAL; core_priority = _POSIX_Priority_To_core( schedparam.sched_priority ); 10a2e5: 8b 45 c4 mov -0x3c(%ebp),%eax 10a2e8: 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); 10a2eb: 0f b6 3d 18 22 12 00 movzbl 0x122218,%edi /* * Set the core scheduling policy information. */ rc = _POSIX_Thread_Translate_sched_param( 10a2f2: 8d 45 e0 lea -0x20(%ebp),%eax 10a2f5: 50 push %eax 10a2f6: 8d 45 e4 lea -0x1c(%ebp),%eax 10a2f9: 50 push %eax 10a2fa: 8d 45 c4 lea -0x3c(%ebp),%eax 10a2fd: 50 push %eax 10a2fe: ff 75 ac pushl -0x54(%ebp) 10a301: e8 de 58 00 00 call 10fbe4 <_POSIX_Thread_Translate_sched_param> 10a306: 89 45 b4 mov %eax,-0x4c(%ebp) schedpolicy, &schedparam, &budget_algorithm, &budget_callout ); if ( rc ) 10a309: 83 c4 10 add $0x10,%esp 10a30c: 85 c0 test %eax,%eax 10a30e: 0f 85 3d 01 00 00 jne 10a451 #endif /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 10a314: 83 ec 0c sub $0xc,%esp 10a317: ff 35 d4 63 12 00 pushl 0x1263d4 10a31d: e8 56 15 00 00 call 10b878 <_API_Mutex_Lock> * _POSIX_Threads_Allocate */ RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information ); 10a322: c7 04 24 54 65 12 00 movl $0x126554,(%esp) 10a329: e8 aa 1e 00 00 call 10c1d8 <_Objects_Allocate> 10a32e: 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 ) { 10a331: 83 c4 10 add $0x10,%esp 10a334: 85 c0 test %eax,%eax 10a336: 75 05 jne 10a33d _RTEMS_Unlock_allocator(); 10a338: 83 ec 0c sub $0xc,%esp 10a33b: eb 53 jmp 10a390 /* * Initialize the core thread for this task. */ name.name_p = NULL; /* posix threads don't have a name by default */ status = _Thread_Initialize( 10a33d: 8b 4d e0 mov -0x20(%ebp),%ecx 10a340: 8b 75 e4 mov -0x1c(%ebp),%esi 10a343: 8b 53 08 mov 0x8(%ebx),%edx 10a346: a1 14 22 12 00 mov 0x122214,%eax 10a34b: d1 e0 shl %eax 10a34d: 39 d0 cmp %edx,%eax 10a34f: 73 02 jae 10a353 10a351: 89 d0 mov %edx,%eax 10a353: 52 push %edx 10a354: 6a 00 push $0x0 10a356: 6a 00 push $0x0 10a358: 51 push %ecx 10a359: 56 push %esi 10a35a: 6a 01 push $0x1 10a35c: 81 e7 ff 00 00 00 and $0xff,%edi 10a362: 2b 7d a8 sub -0x58(%ebp),%edi 10a365: 57 push %edi 10a366: 6a 01 push $0x1 10a368: 50 push %eax 10a369: ff 73 04 pushl 0x4(%ebx) 10a36c: ff 75 b0 pushl -0x50(%ebp) 10a36f: 68 54 65 12 00 push $0x126554 10a374: e8 ff 2c 00 00 call 10d078 <_Thread_Initialize> budget_callout, 0, /* isr level */ name /* posix threads don't have a name */ ); if ( !status ) { 10a379: 83 c4 30 add $0x30,%esp 10a37c: 84 c0 test %al,%al 10a37e: 75 2a jne 10a3aa RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 10a380: 56 push %esi 10a381: 56 push %esi 10a382: ff 75 b0 pushl -0x50(%ebp) 10a385: 68 54 65 12 00 push $0x126554 10a38a: e8 41 21 00 00 call 10c4d0 <_Objects_Free> _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 10a38f: 5b pop %ebx 10a390: ff 35 d4 63 12 00 pushl 0x1263d4 10a396: e8 25 15 00 00 call 10b8c0 <_API_Mutex_Unlock> return EAGAIN; 10a39b: 83 c4 10 add $0x10,%esp 10a39e: c7 45 b4 0b 00 00 00 movl $0xb,-0x4c(%ebp) 10a3a5: e9 a7 00 00 00 jmp 10a451 } /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10a3aa: 8b 45 b0 mov -0x50(%ebp),%eax 10a3ad: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx api->Attributes = *the_attr; 10a3b3: b9 10 00 00 00 mov $0x10,%ecx 10a3b8: 89 d7 mov %edx,%edi 10a3ba: 89 de mov %ebx,%esi 10a3bc: f3 a5 rep movsl %ds:(%esi),%es:(%edi) api->detachstate = the_attr->detachstate; 10a3be: 8b 43 3c mov 0x3c(%ebx),%eax 10a3c1: 89 42 40 mov %eax,0x40(%edx) api->schedpolicy = schedpolicy; 10a3c4: 8b 45 ac mov -0x54(%ebp),%eax 10a3c7: 89 82 84 00 00 00 mov %eax,0x84(%edx) api->schedparam = schedparam; 10a3cd: 8d ba 88 00 00 00 lea 0x88(%edx),%edi 10a3d3: 8d 75 c4 lea -0x3c(%ebp),%esi 10a3d6: b1 07 mov $0x7,%cl 10a3d8: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 10a3da: 83 ec 0c sub $0xc,%esp 10a3dd: 6a 00 push $0x0 10a3df: ff 75 14 pushl 0x14(%ebp) 10a3e2: ff 75 10 pushl 0x10(%ebp) 10a3e5: 6a 01 push $0x1 10a3e7: ff 75 b0 pushl -0x50(%ebp) 10a3ea: 89 55 a4 mov %edx,-0x5c(%ebp) 10a3ed: e8 32 35 00 00 call 10d924 <_Thread_Start> _RTEMS_Unlock_allocator(); return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { 10a3f2: 83 c4 20 add $0x20,%esp 10a3f5: 83 7d ac 04 cmpl $0x4,-0x54(%ebp) 10a3f9: 8b 55 a4 mov -0x5c(%ebp),%edx 10a3fc: 75 2e jne 10a42c _Watchdog_Insert_ticks( 10a3fe: 83 ec 0c sub $0xc,%esp &api->Sporadic_timer, _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ) 10a401: 8d 82 90 00 00 00 lea 0x90(%edx),%eax return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 10a407: 50 push %eax 10a408: e8 6f 36 00 00 call 10da7c <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10a40d: 8b 55 a4 mov -0x5c(%ebp),%edx 10a410: 89 82 b4 00 00 00 mov %eax,0xb4(%edx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10a416: 58 pop %eax 10a417: 59 pop %ecx 10a418: 81 c2 a8 00 00 00 add $0xa8,%edx 10a41e: 52 push %edx 10a41f: 68 f4 63 12 00 push $0x1263f4 10a424: e8 07 39 00 00 call 10dd30 <_Watchdog_Insert> 10a429: 83 c4 10 add $0x10,%esp } /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 10a42c: 8b 45 b0 mov -0x50(%ebp),%eax 10a42f: 8b 50 08 mov 0x8(%eax),%edx 10a432: 8b 45 08 mov 0x8(%ebp),%eax 10a435: 89 10 mov %edx,(%eax) _RTEMS_Unlock_allocator(); 10a437: 83 ec 0c sub $0xc,%esp 10a43a: ff 35 d4 63 12 00 pushl 0x1263d4 10a440: e8 7b 14 00 00 call 10b8c0 <_API_Mutex_Unlock> return 0; 10a445: 83 c4 10 add $0x10,%esp 10a448: eb 07 jmp 10a451 schedpolicy = the_attr->schedpolicy; schedparam = the_attr->schedparam; break; default: return EINVAL; 10a44a: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp) */ *thread = the_thread->Object.id; _RTEMS_Unlock_allocator(); return 0; } 10a451: 8b 45 b4 mov -0x4c(%ebp),%eax 10a454: 8d 65 f4 lea -0xc(%ebp),%esp 10a457: 5b pop %ebx 10a458: 5e pop %esi 10a459: 5f pop %edi 10a45a: c9 leave 10a45b: c3 ret =============================================================================== 00110d60 : } void pthread_exit( void *value_ptr ) { 110d60: 55 push %ebp 110d61: 89 e5 mov %esp,%ebp 110d63: 83 ec 10 sub $0x10,%esp _POSIX_Thread_Exit( _Thread_Executing, value_ptr ); 110d66: ff 75 08 pushl 0x8(%ebp) 110d69: ff 35 68 58 12 00 pushl 0x125868 110d6f: e8 88 ff ff ff call 110cfc <_POSIX_Thread_Exit> 110d74: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 110d77: c9 leave <== NOT EXECUTED 110d78: c3 ret <== NOT EXECUTED =============================================================================== 0010bf24 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 10bf24: 55 push %ebp 10bf25: 89 e5 mov %esp,%ebp 10bf27: 53 push %ebx 10bf28: 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 ); 10bf2b: 8d 45 f4 lea -0xc(%ebp),%eax 10bf2e: 50 push %eax 10bf2f: ff 75 0c pushl 0xc(%ebp) 10bf32: e8 b9 00 00 00 call 10bff0 <_POSIX_Absolute_timeout_to_ticks> 10bf37: 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, 10bf39: 83 c4 0c add $0xc,%esp 10bf3c: 83 f8 03 cmp $0x3,%eax 10bf3f: 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 ); 10bf42: ff 75 f4 pushl -0xc(%ebp) 10bf45: 0f b6 c2 movzbl %dl,%eax 10bf48: 50 push %eax 10bf49: ff 75 08 pushl 0x8(%ebp) 10bf4c: 88 55 e4 mov %dl,-0x1c(%ebp) 10bf4f: e8 e8 fe ff ff call 10be3c <_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) ) { 10bf54: 83 c4 10 add $0x10,%esp 10bf57: 8a 55 e4 mov -0x1c(%ebp),%dl 10bf5a: 84 d2 test %dl,%dl 10bf5c: 75 1d jne 10bf7b 10bf5e: 83 f8 10 cmp $0x10,%eax 10bf61: 75 18 jne 10bf7b <== NEVER TAKEN if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10bf63: 85 db test %ebx,%ebx 10bf65: 74 08 je 10bf6f <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10bf67: 4b dec %ebx 10bf68: 83 fb 01 cmp $0x1,%ebx 10bf6b: 77 0e ja 10bf7b <== NEVER TAKEN 10bf6d: eb 07 jmp 10bf76 * 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; 10bf6f: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10bf74: eb 05 jmp 10bf7b <== NOT EXECUTED if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10bf76: b8 74 00 00 00 mov $0x74,%eax } return lock_status; } 10bf7b: 8b 5d fc mov -0x4(%ebp),%ebx 10bf7e: c9 leave 10bf7f: c3 ret =============================================================================== 0010bb9c : int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { 10bb9c: 55 push %ebp 10bb9d: 89 e5 mov %esp,%ebp 10bb9f: 8b 55 08 mov 0x8(%ebp),%edx 10bba2: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 10bba5: b8 16 00 00 00 mov $0x16,%eax int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { if ( !attr || !attr->is_initialized ) 10bbaa: 85 d2 test %edx,%edx 10bbac: 74 0f je 10bbbd 10bbae: 83 3a 00 cmpl $0x0,(%edx) 10bbb1: 74 0a je 10bbbd return EINVAL; switch ( pshared ) { 10bbb3: 83 f9 01 cmp $0x1,%ecx 10bbb6: 77 05 ja 10bbbd <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10bbb8: 89 4a 04 mov %ecx,0x4(%edx) return 0; 10bbbb: 30 c0 xor %al,%al default: return EINVAL; } } 10bbbd: c9 leave 10bbbe: c3 ret =============================================================================== 00109dc4 : #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { 109dc4: 55 push %ebp 109dc5: 89 e5 mov %esp,%ebp 109dc7: 8b 55 08 mov 0x8(%ebp),%edx 109dca: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 109dcd: b8 16 00 00 00 mov $0x16,%eax int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { if ( !attr || !attr->is_initialized ) 109dd2: 85 d2 test %edx,%edx 109dd4: 74 0f je 109de5 109dd6: 83 3a 00 cmpl $0x0,(%edx) 109dd9: 74 0a je 109de5 <== NEVER TAKEN return EINVAL; switch ( type ) { 109ddb: 83 f9 03 cmp $0x3,%ecx 109dde: 77 05 ja 109de5 case PTHREAD_MUTEX_NORMAL: case PTHREAD_MUTEX_RECURSIVE: case PTHREAD_MUTEX_ERRORCHECK: case PTHREAD_MUTEX_DEFAULT: attr->type = type; 109de0: 89 4a 10 mov %ecx,0x10(%edx) return 0; 109de3: 30 c0 xor %al,%al default: return EINVAL; } } 109de5: c9 leave 109de6: c3 ret =============================================================================== 0010a874 : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 10a874: 55 push %ebp 10a875: 89 e5 mov %esp,%ebp 10a877: 56 push %esi 10a878: 53 push %ebx 10a879: 83 ec 10 sub $0x10,%esp 10a87c: 8b 5d 08 mov 0x8(%ebp),%ebx 10a87f: 8b 75 0c mov 0xc(%ebp),%esi if ( !once_control || !init_routine ) 10a882: 85 f6 test %esi,%esi 10a884: 74 51 je 10a8d7 10a886: 85 db test %ebx,%ebx 10a888: 74 4d je 10a8d7 once_control->init_executed = true; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; 10a88a: 31 c0 xor %eax,%eax ) { if ( !once_control || !init_routine ) return EINVAL; if ( !once_control->init_executed ) { 10a88c: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a890: 75 4a jne 10a8dc rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 10a892: 52 push %edx 10a893: 8d 45 f4 lea -0xc(%ebp),%eax 10a896: 50 push %eax 10a897: 68 00 01 00 00 push $0x100 10a89c: 68 00 01 00 00 push $0x100 10a8a1: e8 a6 0a 00 00 call 10b34c if ( !once_control->init_executed ) { 10a8a6: 83 c4 10 add $0x10,%esp 10a8a9: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a8ad: 75 0f jne 10a8be <== NEVER TAKEN once_control->is_initialized = true; 10a8af: c7 03 01 00 00 00 movl $0x1,(%ebx) once_control->init_executed = true; 10a8b5: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) (*init_routine)(); 10a8bc: ff d6 call *%esi } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10a8be: 50 push %eax 10a8bf: 8d 45 f4 lea -0xc(%ebp),%eax 10a8c2: 50 push %eax 10a8c3: 68 00 01 00 00 push $0x100 10a8c8: ff 75 f4 pushl -0xc(%ebp) 10a8cb: e8 7c 0a 00 00 call 10b34c 10a8d0: 83 c4 10 add $0x10,%esp } return 0; 10a8d3: 31 c0 xor %eax,%eax 10a8d5: eb 05 jmp 10a8dc pthread_once_t *once_control, void (*init_routine)(void) ) { if ( !once_control || !init_routine ) return EINVAL; 10a8d7: b8 16 00 00 00 mov $0x16,%eax (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; } 10a8dc: 8d 65 f8 lea -0x8(%ebp),%esp 10a8df: 5b pop %ebx 10a8e0: 5e pop %esi 10a8e1: c9 leave 10a8e2: c3 ret =============================================================================== 0010b0a0 : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 10b0a0: 55 push %ebp 10b0a1: 89 e5 mov %esp,%ebp 10b0a3: 56 push %esi 10b0a4: 53 push %ebx 10b0a5: 83 ec 10 sub $0x10,%esp 10b0a8: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Error check parameters */ if ( !rwlock ) return EINVAL; 10b0ab: b8 16 00 00 00 mov $0x16,%eax const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 10b0b0: 85 db test %ebx,%ebx 10b0b2: 0f 84 8b 00 00 00 je 10b143 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10b0b8: 8b 75 0c mov 0xc(%ebp),%esi 10b0bb: 85 f6 test %esi,%esi 10b0bd: 75 0f jne 10b0ce the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 10b0bf: 83 ec 0c sub $0xc,%esp 10b0c2: 8d 75 ec lea -0x14(%ebp),%esi 10b0c5: 56 push %esi 10b0c6: e8 5d 09 00 00 call 10ba28 10b0cb: 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; 10b0ce: 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 ) 10b0d3: 83 3e 00 cmpl $0x0,(%esi) 10b0d6: 74 6b je 10b143 <== NEVER TAKEN return EINVAL; switch ( the_attr->process_shared ) { 10b0d8: 83 7e 04 00 cmpl $0x0,0x4(%esi) 10b0dc: 75 65 jne 10b143 <== NEVER TAKEN */ RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes( CORE_RWLock_Attributes *the_attributes ) { the_attributes->XXX = 0; 10b0de: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b0e5: a1 30 83 12 00 mov 0x128330,%eax 10b0ea: 40 inc %eax 10b0eb: a3 30 83 12 00 mov %eax,0x128330 * 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 ); 10b0f0: 83 ec 0c sub $0xc,%esp 10b0f3: 68 34 85 12 00 push $0x128534 10b0f8: e8 33 23 00 00 call 10d430 <_Objects_Allocate> 10b0fd: 89 c6 mov %eax,%esi */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 10b0ff: 83 c4 10 add $0x10,%esp 10b102: 85 c0 test %eax,%eax 10b104: 75 0c jne 10b112 _Thread_Enable_dispatch(); 10b106: e8 33 31 00 00 call 10e23e <_Thread_Enable_dispatch> return EAGAIN; 10b10b: b8 0b 00 00 00 mov $0xb,%eax 10b110: eb 31 jmp 10b143 } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 10b112: 50 push %eax 10b113: 50 push %eax 10b114: 8d 45 f4 lea -0xc(%ebp),%eax 10b117: 50 push %eax 10b118: 8d 46 10 lea 0x10(%esi),%eax 10b11b: 50 push %eax 10b11c: e8 7b 1b 00 00 call 10cc9c <_CORE_RWLock_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10b121: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10b124: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10b127: 8b 15 50 85 12 00 mov 0x128550,%edx 10b12d: 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; 10b130: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 10b137: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10b139: e8 00 31 00 00 call 10e23e <_Thread_Enable_dispatch> return 0; 10b13e: 83 c4 10 add $0x10,%esp 10b141: 31 c0 xor %eax,%eax } 10b143: 8d 65 f8 lea -0x8(%ebp),%esp 10b146: 5b pop %ebx 10b147: 5e pop %esi 10b148: c9 leave 10b149: c3 ret =============================================================================== 0010b1b4 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10b1b4: 55 push %ebp 10b1b5: 89 e5 mov %esp,%ebp 10b1b7: 57 push %edi 10b1b8: 56 push %esi 10b1b9: 53 push %ebx 10b1ba: 83 ec 2c sub $0x2c,%esp 10b1bd: 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; 10b1c0: 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 ) 10b1c5: 85 ff test %edi,%edi 10b1c7: 0f 84 87 00 00 00 je 10b254 * * 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 ); 10b1cd: 50 push %eax 10b1ce: 50 push %eax 10b1cf: 8d 45 e0 lea -0x20(%ebp),%eax 10b1d2: 50 push %eax 10b1d3: ff 75 0c pushl 0xc(%ebp) 10b1d6: e8 29 59 00 00 call 110b04 <_POSIX_Absolute_timeout_to_ticks> 10b1db: 89 c6 mov %eax,%esi 10b1dd: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10b1e0: 8d 45 e4 lea -0x1c(%ebp),%eax 10b1e3: 50 push %eax 10b1e4: ff 37 pushl (%edi) 10b1e6: 68 34 85 12 00 push $0x128534 10b1eb: e8 70 26 00 00 call 10d860 <_Objects_Get> switch ( location ) { 10b1f0: 83 c4 10 add $0x10,%esp 10b1f3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b1f7: 75 5b jne 10b254 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, 10b1f9: 83 fe 03 cmp $0x3,%esi 10b1fc: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 10b1ff: 83 ec 0c sub $0xc,%esp 10b202: 6a 00 push $0x0 10b204: ff 75 e0 pushl -0x20(%ebp) 10b207: 0f b6 ca movzbl %dl,%ecx 10b20a: 51 push %ecx 10b20b: ff 37 pushl (%edi) 10b20d: 83 c0 10 add $0x10,%eax 10b210: 50 push %eax 10b211: 88 55 d4 mov %dl,-0x2c(%ebp) 10b214: e8 b7 1a 00 00 call 10ccd0 <_CORE_RWLock_Obtain_for_reading> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10b219: 83 c4 20 add $0x20,%esp 10b21c: e8 1d 30 00 00 call 10e23e <_Thread_Enable_dispatch> if ( !do_wait ) { 10b221: 8a 55 d4 mov -0x2c(%ebp),%dl 10b224: 84 d2 test %dl,%dl 10b226: 75 17 jne 10b23f if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { 10b228: a1 78 88 12 00 mov 0x128878,%eax 10b22d: 83 78 34 02 cmpl $0x2,0x34(%eax) 10b231: 75 0c jne 10b23f if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10b233: 85 f6 test %esi,%esi 10b235: 74 1d je 10b254 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b237: 4e dec %esi status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10b238: 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 || 10b23a: 83 fe 01 cmp $0x1,%esi 10b23d: 76 15 jbe 10b254 <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b23f: 83 ec 0c sub $0xc,%esp (CORE_RWLock_Status) _Thread_Executing->Wait.return_code 10b242: a1 78 88 12 00 mov 0x128878,%eax status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b247: ff 70 34 pushl 0x34(%eax) 10b24a: e8 bd 00 00 00 call 10b30c <_POSIX_RWLock_Translate_core_RWLock_return_code> 10b24f: 89 c3 mov %eax,%ebx 10b251: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10b254: 89 d8 mov %ebx,%eax 10b256: 8d 65 f4 lea -0xc(%ebp),%esp 10b259: 5b pop %ebx 10b25a: 5e pop %esi 10b25b: 5f pop %edi 10b25c: c9 leave 10b25d: c3 ret =============================================================================== 0010b260 : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10b260: 55 push %ebp 10b261: 89 e5 mov %esp,%ebp 10b263: 57 push %edi 10b264: 56 push %esi 10b265: 53 push %ebx 10b266: 83 ec 2c sub $0x2c,%esp 10b269: 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; 10b26c: 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 ) 10b271: 85 ff test %edi,%edi 10b273: 0f 84 87 00 00 00 je 10b300 * * 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 ); 10b279: 50 push %eax 10b27a: 50 push %eax 10b27b: 8d 45 e0 lea -0x20(%ebp),%eax 10b27e: 50 push %eax 10b27f: ff 75 0c pushl 0xc(%ebp) 10b282: e8 7d 58 00 00 call 110b04 <_POSIX_Absolute_timeout_to_ticks> 10b287: 89 c6 mov %eax,%esi 10b289: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10b28c: 8d 45 e4 lea -0x1c(%ebp),%eax 10b28f: 50 push %eax 10b290: ff 37 pushl (%edi) 10b292: 68 34 85 12 00 push $0x128534 10b297: e8 c4 25 00 00 call 10d860 <_Objects_Get> switch ( location ) { 10b29c: 83 c4 10 add $0x10,%esp 10b29f: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b2a3: 75 5b jne 10b300 (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, 10b2a5: 83 fe 03 cmp $0x3,%esi 10b2a8: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 10b2ab: 83 ec 0c sub $0xc,%esp 10b2ae: 6a 00 push $0x0 10b2b0: ff 75 e0 pushl -0x20(%ebp) 10b2b3: 0f b6 ca movzbl %dl,%ecx 10b2b6: 51 push %ecx 10b2b7: ff 37 pushl (%edi) 10b2b9: 83 c0 10 add $0x10,%eax 10b2bc: 50 push %eax 10b2bd: 88 55 d4 mov %dl,-0x2c(%ebp) 10b2c0: e8 c3 1a 00 00 call 10cd88 <_CORE_RWLock_Obtain_for_writing> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10b2c5: 83 c4 20 add $0x20,%esp 10b2c8: e8 71 2f 00 00 call 10e23e <_Thread_Enable_dispatch> if ( !do_wait && 10b2cd: 8a 55 d4 mov -0x2c(%ebp),%dl 10b2d0: 84 d2 test %dl,%dl 10b2d2: 75 17 jne 10b2eb (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { 10b2d4: a1 78 88 12 00 mov 0x128878,%eax ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 10b2d9: 83 78 34 02 cmpl $0x2,0x34(%eax) 10b2dd: 75 0c jne 10b2eb (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10b2df: 85 f6 test %esi,%esi 10b2e1: 74 1d je 10b300 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b2e3: 4e dec %esi status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10b2e4: 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 || 10b2e6: 83 fe 01 cmp $0x1,%esi 10b2e9: 76 15 jbe 10b300 <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b2eb: 83 ec 0c sub $0xc,%esp (CORE_RWLock_Status) _Thread_Executing->Wait.return_code 10b2ee: 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( 10b2f3: ff 70 34 pushl 0x34(%eax) 10b2f6: e8 11 00 00 00 call 10b30c <_POSIX_RWLock_Translate_core_RWLock_return_code> 10b2fb: 89 c3 mov %eax,%ebx 10b2fd: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10b300: 89 d8 mov %ebx,%eax 10b302: 8d 65 f4 lea -0xc(%ebp),%esp 10b305: 5b pop %ebx 10b306: 5e pop %esi 10b307: 5f pop %edi 10b308: c9 leave 10b309: c3 ret =============================================================================== 0010ba48 : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { 10ba48: 55 push %ebp 10ba49: 89 e5 mov %esp,%ebp 10ba4b: 8b 55 08 mov 0x8(%ebp),%edx 10ba4e: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr ) return EINVAL; 10ba51: b8 16 00 00 00 mov $0x16,%eax int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { if ( !attr ) 10ba56: 85 d2 test %edx,%edx 10ba58: 74 0f je 10ba69 return EINVAL; if ( !attr->is_initialized ) 10ba5a: 83 3a 00 cmpl $0x0,(%edx) 10ba5d: 74 0a je 10ba69 return EINVAL; switch ( pshared ) { 10ba5f: 83 f9 01 cmp $0x1,%ecx 10ba62: 77 05 ja 10ba69 <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10ba64: 89 4a 04 mov %ecx,0x4(%edx) return 0; 10ba67: 30 c0 xor %al,%al default: return EINVAL; } } 10ba69: c9 leave 10ba6a: c3 ret =============================================================================== 0010c748 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 10c748: 55 push %ebp 10c749: 89 e5 mov %esp,%ebp 10c74b: 57 push %edi 10c74c: 56 push %esi 10c74d: 53 push %ebx 10c74e: 83 ec 2c sub $0x2c,%esp 10c751: 8b 75 10 mov 0x10(%ebp),%esi /* * Check all the parameters */ if ( !param ) return EINVAL; 10c754: c7 45 d4 16 00 00 00 movl $0x16,-0x2c(%ebp) int rc; /* * Check all the parameters */ if ( !param ) 10c75b: 85 f6 test %esi,%esi 10c75d: 0f 84 00 01 00 00 je 10c863 return EINVAL; rc = _POSIX_Thread_Translate_sched_param( 10c763: 8d 45 e0 lea -0x20(%ebp),%eax 10c766: 50 push %eax 10c767: 8d 45 e4 lea -0x1c(%ebp),%eax 10c76a: 50 push %eax 10c76b: 56 push %esi 10c76c: ff 75 0c pushl 0xc(%ebp) 10c76f: e8 e0 52 00 00 call 111a54 <_POSIX_Thread_Translate_sched_param> 10c774: 89 45 d4 mov %eax,-0x2c(%ebp) policy, param, &budget_algorithm, &budget_callout ); if ( rc ) 10c777: 83 c4 10 add $0x10,%esp 10c77a: 85 c0 test %eax,%eax 10c77c: 0f 85 e1 00 00 00 jne 10c863 10c782: 53 push %ebx return rc; /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); 10c783: 8d 45 dc lea -0x24(%ebp),%eax 10c786: 50 push %eax 10c787: ff 75 08 pushl 0x8(%ebp) 10c78a: 68 14 a6 12 00 push $0x12a614 10c78f: e8 84 1c 00 00 call 10e418 <_Objects_Get> 10c794: 89 c2 mov %eax,%edx switch ( location ) { 10c796: 83 c4 10 add $0x10,%esp 10c799: 83 7d dc 00 cmpl $0x0,-0x24(%ebp) 10c79d: 0f 85 b9 00 00 00 jne 10c85c case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10c7a3: 8b 98 ec 00 00 00 mov 0xec(%eax),%ebx if ( api->schedpolicy == SCHED_SPORADIC ) 10c7a9: 83 bb 84 00 00 00 04 cmpl $0x4,0x84(%ebx) 10c7b0: 75 18 jne 10c7ca (void) _Watchdog_Remove( &api->Sporadic_timer ); 10c7b2: 83 ec 0c sub $0xc,%esp 10c7b5: 8d 83 a8 00 00 00 lea 0xa8(%ebx),%eax 10c7bb: 50 push %eax 10c7bc: 89 55 d0 mov %edx,-0x30(%ebp) 10c7bf: e8 28 35 00 00 call 10fcec <_Watchdog_Remove> 10c7c4: 83 c4 10 add $0x10,%esp 10c7c7: 8b 55 d0 mov -0x30(%ebp),%edx api->schedpolicy = policy; 10c7ca: 8b 45 0c mov 0xc(%ebp),%eax 10c7cd: 89 83 84 00 00 00 mov %eax,0x84(%ebx) api->schedparam = *param; 10c7d3: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi 10c7d9: b9 07 00 00 00 mov $0x7,%ecx 10c7de: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_thread->budget_algorithm = budget_algorithm; 10c7e0: 8b 45 e4 mov -0x1c(%ebp),%eax 10c7e3: 89 42 7c mov %eax,0x7c(%edx) the_thread->budget_callout = budget_callout; 10c7e6: 8b 45 e0 mov -0x20(%ebp),%eax 10c7e9: 89 82 80 00 00 00 mov %eax,0x80(%edx) switch ( api->schedpolicy ) { 10c7ef: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10c7f3: 78 60 js 10c855 <== NEVER TAKEN 10c7f5: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) 10c7f9: 7e 08 jle 10c803 10c7fb: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) 10c7ff: 75 54 jne 10c855 <== NEVER TAKEN 10c801: eb 24 jmp 10c827 case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c803: a1 a0 a3 12 00 mov 0x12a3a0,%eax 10c808: 89 42 78 mov %eax,0x78(%edx) 10c80b: 0f b6 05 78 62 12 00 movzbl 0x126278,%eax 10c812: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax the_thread->real_priority = 10c818: 89 42 18 mov %eax,0x18(%edx) _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 10c81b: 51 push %ecx 10c81c: 6a 01 push $0x1 10c81e: 50 push %eax 10c81f: 52 push %edx 10c820: e8 8b 21 00 00 call 10e9b0 <_Thread_Change_priority> 10c825: eb 2b jmp 10c852 true ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 10c827: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 10c82d: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) _Watchdog_Remove( &api->Sporadic_timer ); 10c833: 83 ec 0c sub $0xc,%esp 10c836: 81 c3 a8 00 00 00 add $0xa8,%ebx 10c83c: 53 push %ebx 10c83d: 89 55 d0 mov %edx,-0x30(%ebp) 10c840: e8 a7 34 00 00 call 10fcec <_Watchdog_Remove> _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 10c845: 58 pop %eax 10c846: 5a pop %edx 10c847: 8b 55 d0 mov -0x30(%ebp),%edx 10c84a: 52 push %edx 10c84b: 6a 00 push $0x0 10c84d: e8 e1 fd ff ff call 10c633 <_POSIX_Threads_Sporadic_budget_TSR> break; 10c852: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10c855: e8 9c 25 00 00 call 10edf6 <_Thread_Enable_dispatch> return 0; 10c85a: eb 07 jmp 10c863 #endif case OBJECTS_ERROR: break; } return ESRCH; 10c85c: c7 45 d4 03 00 00 00 movl $0x3,-0x2c(%ebp) } 10c863: 8b 45 d4 mov -0x2c(%ebp),%eax 10c866: 8d 65 f4 lea -0xc(%ebp),%esp 10c869: 5b pop %ebx 10c86a: 5e pop %esi 10c86b: 5f pop %edi 10c86c: c9 leave 10c86d: c3 ret =============================================================================== 0010a644 : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 10a644: 55 push %ebp 10a645: 89 e5 mov %esp,%ebp 10a647: 53 push %ebx 10a648: 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() ) 10a64b: 83 3d 4c 68 12 00 00 cmpl $0x0,0x12684c 10a652: 75 48 jne 10a69c <== NEVER TAKEN return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a654: a1 50 68 12 00 mov 0x126850,%eax 10a659: 8b 80 ec 00 00 00 mov 0xec(%eax),%eax 10a65f: 8b 15 08 63 12 00 mov 0x126308,%edx 10a665: 42 inc %edx 10a666: 89 15 08 63 12 00 mov %edx,0x126308 */ void pthread_testcancel( void ) { POSIX_API_Control *thread_support; bool cancel = false; 10a66c: 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 && 10a66e: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax) 10a675: 75 0a jne 10a681 <== 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)); 10a677: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax) 10a67e: 0f 95 c3 setne %bl thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a681: e8 14 25 00 00 call 10cb9a <_Thread_Enable_dispatch> if ( cancel ) 10a686: 84 db test %bl,%bl 10a688: 74 12 je 10a69c _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10a68a: 50 push %eax 10a68b: 50 push %eax 10a68c: 6a ff push $0xffffffff 10a68e: ff 35 50 68 12 00 pushl 0x126850 10a694: e8 7b 52 00 00 call 10f914 <_POSIX_Thread_Exit> 10a699: 83 c4 10 add $0x10,%esp } 10a69c: 8b 5d fc mov -0x4(%ebp),%ebx 10a69f: c9 leave 10a6a0: c3 ret =============================================================================== 0011d124 : ssize_t read( int fd, void *buffer, size_t count ) { 11d124: 55 push %ebp 11d125: 89 e5 mov %esp,%ebp 11d127: 56 push %esi 11d128: 53 push %ebx 11d129: 8b 5d 08 mov 0x8(%ebp),%ebx 11d12c: 8b 55 0c mov 0xc(%ebp),%edx 11d12f: 8b 4d 10 mov 0x10(%ebp),%ecx ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11d132: 3b 1d 44 11 12 00 cmp 0x121144,%ebx 11d138: 73 14 jae 11d14e <== NEVER TAKEN iop = rtems_libio_iop( fd ); 11d13a: 6b db 38 imul $0x38,%ebx,%ebx 11d13d: 03 1d d8 51 12 00 add 0x1251d8,%ebx rtems_libio_check_is_open( iop ); 11d143: 8b 73 14 mov 0x14(%ebx),%esi 11d146: f7 c6 00 01 00 00 test $0x100,%esi 11d14c: 75 0d jne 11d15b 11d14e: e8 f9 3f ff ff call 11114c <__errno> 11d153: c7 00 09 00 00 00 movl $0x9,(%eax) 11d159: eb 1a jmp 11d175 rtems_libio_check_buffer( buffer ); 11d15b: 85 d2 test %edx,%edx 11d15d: 74 0b je 11d16a <== NEVER TAKEN rtems_libio_check_count( count ); 11d15f: 31 c0 xor %eax,%eax 11d161: 85 c9 test %ecx,%ecx 11d163: 74 31 je 11d196 rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 11d165: 83 e6 02 and $0x2,%esi 11d168: 75 10 jne 11d17a 11d16a: e8 dd 3f ff ff call 11114c <__errno> 11d16f: c7 00 16 00 00 00 movl $0x16,(%eax) 11d175: 83 c8 ff or $0xffffffff,%eax 11d178: eb 1c jmp 11d196 /* * Now process the read(). */ rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count ); 11d17a: 50 push %eax 11d17b: 8b 43 20 mov 0x20(%ebx),%eax 11d17e: 51 push %ecx 11d17f: 52 push %edx 11d180: 53 push %ebx 11d181: ff 50 08 call *0x8(%eax) if ( rc > 0 ) 11d184: 83 c4 10 add $0x10,%esp 11d187: 85 c0 test %eax,%eax 11d189: 7e 0b jle 11d196 iop->offset += rc; 11d18b: 89 c1 mov %eax,%ecx 11d18d: c1 f9 1f sar $0x1f,%ecx 11d190: 01 43 0c add %eax,0xc(%ebx) 11d193: 11 4b 10 adc %ecx,0x10(%ebx) return rc; } 11d196: 8d 65 f8 lea -0x8(%ebp),%esp 11d199: 5b pop %ebx 11d19a: 5e pop %esi 11d19b: c9 leave 11d19c: c3 ret =============================================================================== 00109ea4 : ssize_t readlink( const char *pathname, char *buf, size_t bufsize ) { 109ea4: 55 push %ebp 109ea5: 89 e5 mov %esp,%ebp 109ea7: 57 push %edi 109ea8: 56 push %esi 109ea9: 53 push %ebx 109eaa: 83 ec 2c sub $0x2c,%esp 109ead: 8b 55 08 mov 0x8(%ebp),%edx 109eb0: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_filesystem_location_info_t loc; int result; if (!buf) 109eb3: 85 db test %ebx,%ebx 109eb5: 75 10 jne 109ec7 rtems_set_errno_and_return_minus_one( EFAULT ); 109eb7: e8 9c 99 00 00 call 113858 <__errno> 109ebc: c7 00 0e 00 00 00 movl $0xe,(%eax) 109ec2: 83 cf ff or $0xffffffff,%edi 109ec5: eb 69 jmp 109f30 result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ), 109ec7: 31 c0 xor %eax,%eax 109ec9: 83 c9 ff or $0xffffffff,%ecx 109ecc: 89 d7 mov %edx,%edi 109ece: f2 ae repnz scas %es:(%edi),%al 109ed0: f7 d1 not %ecx 109ed2: 49 dec %ecx 109ed3: 83 ec 0c sub $0xc,%esp 109ed6: 6a 00 push $0x0 109ed8: 8d 75 d4 lea -0x2c(%ebp),%esi 109edb: 56 push %esi 109edc: 6a 00 push $0x0 109ede: 51 push %ecx 109edf: 52 push %edx 109ee0: e8 6d f0 ff ff call 108f52 0, &loc, false ); if ( result != 0 ) 109ee5: 83 c4 20 add $0x20,%esp return -1; 109ee8: 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 ) 109eeb: 85 c0 test %eax,%eax 109eed: 75 41 jne 109f30 <== NEVER TAKEN return -1; if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){ 109eef: 83 ec 0c sub $0xc,%esp 109ef2: 56 push %esi 109ef3: 8b 45 e0 mov -0x20(%ebp),%eax 109ef6: ff 50 10 call *0x10(%eax) 109ef9: 83 c4 10 add $0x10,%esp 109efc: 83 f8 04 cmp $0x4,%eax 109eff: 74 16 je 109f17 rtems_filesystem_freenode( &loc ); 109f01: 83 ec 0c sub $0xc,%esp 109f04: 56 push %esi 109f05: e8 06 f1 ff ff call 109010 rtems_set_errno_and_return_minus_one( EINVAL ); 109f0a: e8 49 99 00 00 call 113858 <__errno> 109f0f: c7 00 16 00 00 00 movl $0x16,(%eax) 109f15: eb 16 jmp 109f2d } result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); 109f17: 50 push %eax 109f18: ff 75 10 pushl 0x10(%ebp) 109f1b: 53 push %ebx 109f1c: 56 push %esi 109f1d: 8b 45 e0 mov -0x20(%ebp),%eax 109f20: ff 50 3c call *0x3c(%eax) 109f23: 89 c7 mov %eax,%edi rtems_filesystem_freenode( &loc ); 109f25: 89 34 24 mov %esi,(%esp) 109f28: e8 e3 f0 ff ff call 109010 return result; 109f2d: 83 c4 10 add $0x10,%esp } 109f30: 89 f8 mov %edi,%eax 109f32: 8d 65 f4 lea -0xc(%ebp),%esp 109f35: 5b pop %ebx 109f36: 5e pop %esi 109f37: 5f pop %edi 109f38: c9 leave 109f39: c3 ret =============================================================================== 00108c54 : ssize_t readv( int fd, const struct iovec *iov, int iovcnt ) { 108c54: 55 push %ebp 108c55: 89 e5 mov %esp,%ebp 108c57: 57 push %edi 108c58: 56 push %esi 108c59: 53 push %ebx 108c5a: 83 ec 2c sub $0x2c,%esp 108c5d: 8b 75 08 mov 0x8(%ebp),%esi 108c60: 8b 7d 0c mov 0xc(%ebp),%edi int v; int bytes; rtems_libio_t *iop; bool all_zeros; rtems_libio_check_fd( fd ); 108c63: 3b 35 44 21 12 00 cmp 0x122144,%esi 108c69: 73 11 jae 108c7c iop = rtems_libio_iop( fd ); 108c6b: 6b f6 38 imul $0x38,%esi,%esi 108c6e: 03 35 d8 61 12 00 add 0x1261d8,%esi rtems_libio_check_is_open( iop ); 108c74: 8b 46 14 mov 0x14(%esi),%eax 108c77: f6 c4 01 test $0x1,%ah 108c7a: 75 10 jne 108c8c 108c7c: e8 ab 90 00 00 call 111d2c <__errno> 108c81: c7 00 09 00 00 00 movl $0x9,(%eax) 108c87: e9 a4 00 00 00 jmp 108d30 rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 108c8c: a8 02 test $0x2,%al 108c8e: 74 35 je 108cc5 <== NEVER TAKEN /* * Argument validation on IO vector */ if ( !iov ) 108c90: 85 ff test %edi,%edi 108c92: 74 31 je 108cc5 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt <= 0 ) 108c94: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 108c98: 7e 2b jle 108cc5 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt > IOV_MAX ) 108c9a: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp) 108ca1: 7f 22 jg 108cc5 <== NEVER TAKEN 108ca3: b2 01 mov $0x1,%dl 108ca5: 31 c0 xor %eax,%eax 108ca7: 31 c9 xor %ecx,%ecx 108ca9: 89 75 d4 mov %esi,-0x2c(%ebp) 108cac: eb 03 jmp 108cb1 if ( iov[v].iov_base == 0 ) rtems_set_errno_and_return_minus_one( EINVAL ); /* check for wrap */ old = total; total += iov[v].iov_len; 108cae: 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 ) 108cb1: 83 3c c7 00 cmpl $0x0,(%edi,%eax,8) 108cb5: 74 0e je 108cc5 rtems_set_errno_and_return_minus_one( EINVAL ); /* check for wrap */ old = total; total += iov[v].iov_len; 108cb7: 8b 5c c7 04 mov 0x4(%edi,%eax,8),%ebx 108cbb: 8d 34 19 lea (%ecx,%ebx,1),%esi 108cbe: 89 75 e4 mov %esi,-0x1c(%ebp) if ( total < old ) 108cc1: 39 ce cmp %ecx,%esi 108cc3: 7d 0d jge 108cd2 rtems_set_errno_and_return_minus_one( EINVAL ); 108cc5: e8 62 90 00 00 call 111d2c <__errno> 108cca: c7 00 16 00 00 00 movl $0x16,(%eax) 108cd0: eb 5e jmp 108d30 if ( iov[v].iov_len ) all_zeros = false; 108cd2: 85 db test %ebx,%ebx 108cd4: 0f 94 c1 sete %cl 108cd7: f7 d9 neg %ecx 108cd9: 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++ ) { 108cdb: 40 inc %eax 108cdc: 3b 45 10 cmp 0x10(%ebp),%eax 108cdf: 7c cd jl 108cae 108ce1: 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; 108ce4: 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 ) { 108ce6: 84 d2 test %dl,%dl 108ce8: 75 49 jne 108d33 108cea: 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)( 108cf1: 50 push %eax 108cf2: 8b 46 20 mov 0x20(%esi),%eax 108cf5: 8b 55 e4 mov -0x1c(%ebp),%edx 108cf8: ff 74 d7 04 pushl 0x4(%edi,%edx,8) 108cfc: ff 34 d7 pushl (%edi,%edx,8) 108cff: 56 push %esi 108d00: ff 50 08 call *0x8(%eax) iop, iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) 108d03: 83 c4 10 add $0x10,%esp 108d06: 83 f8 00 cmp $0x0,%eax 108d09: 7c 25 jl 108d30 <== NEVER TAKEN return -1; if ( bytes > 0 ) { 108d0b: 74 0d je 108d1a <== NEVER TAKEN iop->offset += bytes; 108d0d: 89 c1 mov %eax,%ecx 108d0f: c1 f9 1f sar $0x1f,%ecx 108d12: 01 46 0c add %eax,0xc(%esi) 108d15: 11 4e 10 adc %ecx,0x10(%esi) total += bytes; 108d18: 01 c3 add %eax,%ebx } if (bytes != iov[ v ].iov_len) 108d1a: 8b 55 e4 mov -0x1c(%ebp),%edx 108d1d: 3b 44 d7 04 cmp 0x4(%edi,%edx,8),%eax 108d21: 75 10 jne 108d33 <== NEVER TAKEN } /* * Now process the readv(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { 108d23: 42 inc %edx 108d24: 89 55 e4 mov %edx,-0x1c(%ebp) 108d27: 8b 45 10 mov 0x10(%ebp),%eax 108d2a: 39 c2 cmp %eax,%edx 108d2c: 7c c3 jl 108cf1 108d2e: eb 03 jmp 108d33 iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) return -1; 108d30: 83 cb ff or $0xffffffff,%ebx if (bytes != iov[ v ].iov_len) break; } return total; } 108d33: 89 d8 mov %ebx,%eax 108d35: 8d 65 f4 lea -0xc(%ebp),%esp 108d38: 5b pop %ebx 108d39: 5e pop %esi 108d3a: 5f pop %edi 108d3b: c9 leave 108d3c: c3 ret =============================================================================== 0011d228 : void *realloc( void *ptr, size_t size ) { 11d228: 55 push %ebp 11d229: 89 e5 mov %esp,%ebp 11d22b: 57 push %edi 11d22c: 56 push %esi 11d22d: 53 push %ebx 11d22e: 83 ec 2c sub $0x2c,%esp 11d231: 8b 5d 08 mov 0x8(%ebp),%ebx 11d234: 8b 75 0c mov 0xc(%ebp),%esi uintptr_t old_size; char *new_area; MSBUMP(realloc_calls, 1); 11d237: ff 05 00 52 12 00 incl 0x125200 /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 11d23d: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c 11d244: 75 1a jne 11d260 <== NEVER TAKEN if (_Thread_Dispatch_disable_level > 0) 11d246: a1 20 53 12 00 mov 0x125320,%eax 11d24b: 85 c0 test %eax,%eax 11d24d: 0f 85 ad 00 00 00 jne 11d300 <== NEVER TAKEN return (void *) 0; if (_ISR_Nest_level > 0) 11d253: 83 3d 64 58 12 00 00 cmpl $0x0,0x125864 11d25a: 0f 85 a0 00 00 00 jne 11d300 <== NEVER TAKEN } /* * Continue with realloc(). */ if ( !ptr ) 11d260: 85 db test %ebx,%ebx 11d262: 75 13 jne 11d277 return malloc( size ); 11d264: 83 ec 0c sub $0xc,%esp 11d267: 56 push %esi 11d268: e8 77 a3 fe ff call 1075e4 11d26d: 89 c3 mov %eax,%ebx 11d26f: 83 c4 10 add $0x10,%esp 11d272: e9 8b 00 00 00 jmp 11d302 if ( !size ) { 11d277: 85 f6 test %esi,%esi 11d279: 75 0e jne 11d289 <== ALWAYS TAKEN free( ptr ); 11d27b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11d27e: 53 push %ebx <== NOT EXECUTED 11d27f: e8 c4 a0 fe ff call 107348 <== NOT EXECUTED return (void *) 0; 11d284: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11d287: eb 77 jmp 11d300 <== NOT EXECUTED } if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) { 11d289: 52 push %edx 11d28a: 8d 45 e4 lea -0x1c(%ebp),%eax 11d28d: 50 push %eax 11d28e: 53 push %ebx 11d28f: ff 35 50 11 12 00 pushl 0x121150 11d295: e8 ee 00 00 00 call 11d388 <_Protected_heap_Get_block_size> 11d29a: 83 c4 10 add $0x10,%esp 11d29d: 84 c0 test %al,%al 11d29f: 75 0d jne 11d2ae errno = EINVAL; 11d2a1: e8 a6 3e ff ff call 11114c <__errno> 11d2a6: c7 00 16 00 00 00 movl $0x16,(%eax) 11d2ac: eb 52 jmp 11d300 } /* * Now resize it. */ if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) { 11d2ae: 50 push %eax 11d2af: 56 push %esi 11d2b0: 53 push %ebx 11d2b1: ff 35 50 11 12 00 pushl 0x121150 11d2b7: e8 04 01 00 00 call 11d3c0 <_Protected_heap_Resize_block> 11d2bc: 83 c4 10 add $0x10,%esp 11d2bf: 84 c0 test %al,%al 11d2c1: 75 3f jne 11d302 * 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 ); 11d2c3: 83 ec 0c sub $0xc,%esp 11d2c6: 56 push %esi 11d2c7: e8 18 a3 fe ff call 1075e4 MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ 11d2cc: ff 0d f4 51 12 00 decl 0x1251f4 if ( !new_area ) { 11d2d2: 83 c4 10 add $0x10,%esp 11d2d5: 85 c0 test %eax,%eax 11d2d7: 74 27 je 11d300 return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 11d2d9: 8b 55 e4 mov -0x1c(%ebp),%edx 11d2dc: 89 f1 mov %esi,%ecx 11d2de: 39 d6 cmp %edx,%esi 11d2e0: 76 02 jbe 11d2e4 <== NEVER TAKEN 11d2e2: 89 d1 mov %edx,%ecx 11d2e4: 89 c7 mov %eax,%edi 11d2e6: 89 de mov %ebx,%esi 11d2e8: f3 a4 rep movsb %ds:(%esi),%es:(%edi) free( ptr ); 11d2ea: 83 ec 0c sub $0xc,%esp 11d2ed: 53 push %ebx 11d2ee: 89 45 d4 mov %eax,-0x2c(%ebp) 11d2f1: e8 52 a0 fe ff call 107348 return new_area; 11d2f6: 83 c4 10 add $0x10,%esp 11d2f9: 8b 45 d4 mov -0x2c(%ebp),%eax 11d2fc: 89 c3 mov %eax,%ebx 11d2fe: eb 02 jmp 11d302 new_area = malloc( size ); MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ if ( !new_area ) { return (void *) 0; 11d300: 31 db xor %ebx,%ebx memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; } 11d302: 89 d8 mov %ebx,%eax 11d304: 8d 65 f4 lea -0xc(%ebp),%esp 11d307: 5b pop %ebx 11d308: 5e pop %esi 11d309: 5f pop %edi 11d30a: c9 leave 11d30b: c3 ret =============================================================================== 00108390 : #include int rmdir( const char *pathname ) { 108390: 55 push %ebp 108391: 89 e5 mov %esp,%ebp 108393: 57 push %edi 108394: 56 push %esi 108395: 53 push %ebx 108396: 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 ); 108399: ff 75 08 pushl 0x8(%ebp) 10839c: e8 fe f2 ff ff call 10769f 1083a1: 89 45 b4 mov %eax,-0x4c(%ebp) if ( parentpathlen == 0 ) 1083a4: 83 c4 10 add $0x10,%esp 1083a7: 85 c0 test %eax,%eax 1083a9: 8d 45 d0 lea -0x30(%ebp),%eax 1083ac: 75 15 jne 1083c3 rtems_filesystem_get_start_loc( pathname, &i, &parentloc ); 1083ae: 51 push %ecx 1083af: 50 push %eax 1083b0: 8d 45 e4 lea -0x1c(%ebp),%eax 1083b3: 50 push %eax 1083b4: ff 75 08 pushl 0x8(%ebp) 1083b7: e8 08 01 00 00 call 1084c4 1083bc: 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; 1083bf: 31 db xor %ebx,%ebx 1083c1: eb 25 jmp 1083e8 parentpathlen = rtems_filesystem_dirname ( pathname ); if ( parentpathlen == 0 ) rtems_filesystem_get_start_loc( pathname, &i, &parentloc ); else { result = rtems_filesystem_evaluate_path(pathname, parentpathlen, 1083c3: 83 ec 0c sub $0xc,%esp 1083c6: 6a 00 push $0x0 1083c8: 50 push %eax 1083c9: 6a 02 push $0x2 1083cb: ff 75 b4 pushl -0x4c(%ebp) 1083ce: ff 75 08 pushl 0x8(%ebp) 1083d1: e8 88 f2 ff ff call 10765e 1083d6: 89 c2 mov %eax,%edx RTEMS_LIBIO_PERMS_WRITE, &parentloc, false ); if ( result != 0 ) 1083d8: 83 c4 20 add $0x20,%esp return -1; 1083db: 83 c8 ff or $0xffffffff,%eax else { result = rtems_filesystem_evaluate_path(pathname, parentpathlen, RTEMS_LIBIO_PERMS_WRITE, &parentloc, false ); if ( result != 0 ) 1083de: 85 d2 test %edx,%edx 1083e0: 0f 85 d6 00 00 00 jne 1084bc <== NEVER TAKEN return -1; free_parentloc = true; 1083e6: b3 01 mov $0x1,%bl /* * Start from the parent to find the node that should be under it. */ loc = parentloc; 1083e8: 8d 7d bc lea -0x44(%ebp),%edi 1083eb: 8d 75 d0 lea -0x30(%ebp),%esi 1083ee: b9 05 00 00 00 mov $0x5,%ecx 1083f3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) name = pathname + parentpathlen; 1083f5: 8b 75 08 mov 0x8(%ebp),%esi 1083f8: 03 75 b4 add -0x4c(%ebp),%esi name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 1083fb: 83 c9 ff or $0xffffffff,%ecx 1083fe: 89 f7 mov %esi,%edi 108400: 31 c0 xor %eax,%eax 108402: f2 ae repnz scas %es:(%edi),%al 108404: f7 d1 not %ecx 108406: 49 dec %ecx 108407: 52 push %edx 108408: 52 push %edx 108409: 51 push %ecx 10840a: 56 push %esi 10840b: e8 ce f2 ff ff call 1076de 108410: 01 c6 add %eax,%esi result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 108412: 83 c9 ff or $0xffffffff,%ecx 108415: 89 f7 mov %esi,%edi 108417: 31 c0 xor %eax,%eax 108419: f2 ae repnz scas %es:(%edi),%al 10841b: f7 d1 not %ecx 10841d: 49 dec %ecx 10841e: c7 04 24 00 00 00 00 movl $0x0,(%esp) 108425: 8d 7d bc lea -0x44(%ebp),%edi 108428: 57 push %edi 108429: 6a 00 push $0x0 10842b: 51 push %ecx 10842c: 56 push %esi 10842d: e8 ce f1 ff ff call 107600 0, &loc, false ); if ( result != 0 ) { 108432: 83 c4 20 add $0x20,%esp 108435: 85 c0 test %eax,%eax 108437: 74 13 je 10844c if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); return -1; 108439: 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 ) 10843c: 84 db test %bl,%bl 10843e: 74 7c je 1084bc rtems_filesystem_freenode( &parentloc ); 108440: 83 ec 0c sub $0xc,%esp 108443: 8d 55 d0 lea -0x30(%ebp),%edx 108446: 52 push %edx 108447: 89 45 b0 mov %eax,-0x50(%ebp) 10844a: eb 65 jmp 1084b1 } /* * Verify you can remove this node as a directory. */ if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 10844c: 83 ec 0c sub $0xc,%esp 10844f: 57 push %edi 108450: 8b 45 c8 mov -0x38(%ebp),%eax 108453: ff 50 10 call *0x10(%eax) 108456: 83 c4 10 add $0x10,%esp 108459: 48 dec %eax 10845a: 74 2f je 10848b rtems_filesystem_freenode( &loc ); 10845c: 83 ec 0c sub $0xc,%esp 10845f: 57 push %edi 108460: e8 b7 f2 ff ff call 10771c if ( free_parentloc ) 108465: 83 c4 10 add $0x10,%esp 108468: 84 db test %bl,%bl 10846a: 74 0f je 10847b <== NEVER TAKEN rtems_filesystem_freenode( &parentloc ); 10846c: 83 ec 0c sub $0xc,%esp 10846f: 8d 45 d0 lea -0x30(%ebp),%eax 108472: 50 push %eax 108473: e8 a4 f2 ff ff call 10771c 108478: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( ENOTDIR ); 10847b: e8 6c 94 00 00 call 1118ec <__errno> 108480: c7 00 14 00 00 00 movl $0x14,(%eax) 108486: 83 c8 ff or $0xffffffff,%eax 108489: eb 31 jmp 1084bc /* * Use the filesystems rmnod to remove the node. */ result = (*loc.handlers->rmnod_h)( &parentloc, &loc ); 10848b: 50 push %eax 10848c: 50 push %eax 10848d: 57 push %edi 10848e: 8d 75 d0 lea -0x30(%ebp),%esi 108491: 56 push %esi 108492: 8b 45 c4 mov -0x3c(%ebp),%eax 108495: ff 50 34 call *0x34(%eax) rtems_filesystem_freenode( &loc ); 108498: 89 3c 24 mov %edi,(%esp) 10849b: 89 45 b0 mov %eax,-0x50(%ebp) 10849e: e8 79 f2 ff ff call 10771c if ( free_parentloc ) 1084a3: 83 c4 10 add $0x10,%esp 1084a6: 84 db test %bl,%bl 1084a8: 8b 45 b0 mov -0x50(%ebp),%eax 1084ab: 74 0f je 1084bc rtems_filesystem_freenode( &parentloc ); 1084ad: 83 ec 0c sub $0xc,%esp 1084b0: 56 push %esi 1084b1: e8 66 f2 ff ff call 10771c 1084b6: 83 c4 10 add $0x10,%esp 1084b9: 8b 45 b0 mov -0x50(%ebp),%eax return result; } 1084bc: 8d 65 f4 lea -0xc(%ebp),%esp 1084bf: 5b pop %ebx 1084c0: 5e pop %esi 1084c1: 5f pop %edi 1084c2: c9 leave 1084c3: c3 ret =============================================================================== 0010af21 : * errno - otherwise */ int rtems_aio_enqueue (rtems_aio_request *req) { 10af21: 55 push %ebp 10af22: 89 e5 mov %esp,%ebp 10af24: 57 push %edi 10af25: 56 push %esi 10af26: 53 push %ebx 10af27: 83 ec 58 sub $0x58,%esp 10af2a: 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); 10af2d: 68 b8 72 12 00 push $0x1272b8 10af32: e8 c5 08 00 00 call 10b7fc 10af37: 89 45 b4 mov %eax,-0x4c(%ebp) if (result != 0) { 10af3a: 83 c4 10 add $0x10,%esp 10af3d: 85 c0 test %eax,%eax 10af3f: 74 0e je 10af4f <== ALWAYS TAKEN free (req); 10af41: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af44: 53 push %ebx <== NOT EXECUTED 10af45: e8 e6 cd ff ff call 107d30 <== NOT EXECUTED 10af4a: e9 c6 01 00 00 jmp 10b115 <== 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); 10af4f: e8 a8 10 00 00 call 10bffc 10af54: 57 push %edi 10af55: 8d 55 c4 lea -0x3c(%ebp),%edx 10af58: 52 push %edx 10af59: 8d 55 e0 lea -0x20(%ebp),%edx 10af5c: 52 push %edx 10af5d: 50 push %eax 10af5e: e8 9d 0c 00 00 call 10bc00 req->caller_thread = pthread_self (); 10af63: e8 94 10 00 00 call 10bffc 10af68: 89 43 10 mov %eax,0x10(%ebx) req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 10af6b: 8b 43 14 mov 0x14(%ebx),%eax 10af6e: 8b 55 c4 mov -0x3c(%ebp),%edx 10af71: 2b 50 14 sub 0x14(%eax),%edx 10af74: 89 53 0c mov %edx,0xc(%ebx) req->policy = policy; 10af77: 8b 55 e0 mov -0x20(%ebp),%edx 10af7a: 89 53 08 mov %edx,0x8(%ebx) req->aiocbp->error_code = EINPROGRESS; 10af7d: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax) req->aiocbp->return_value = 0; 10af84: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) if ((aio_request_queue.idle_threads == 0) && 10af8b: 83 c4 10 add $0x10,%esp 10af8e: 83 3d 20 73 12 00 00 cmpl $0x0,0x127320 10af95: 0f 85 b7 00 00 00 jne 10b052 <== NEVER TAKEN 10af9b: 83 3d 1c 73 12 00 04 cmpl $0x4,0x12731c 10afa2: 0f 8f aa 00 00 00 jg 10b052 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); 10afa8: 56 push %esi 10afa9: 6a 01 push $0x1 10afab: ff 30 pushl (%eax) 10afad: 68 00 73 12 00 push $0x127300 10afb2: e8 81 fb ff ff call 10ab38 10afb7: 89 c6 mov %eax,%esi if (r_chain->new_fd == 1) { 10afb9: 83 c4 10 add $0x10,%esp 10afbc: 83 78 18 01 cmpl $0x1,0x18(%eax) 10afc0: 8d 50 08 lea 0x8(%eax),%edx 10afc3: 8d 78 1c lea 0x1c(%eax),%edi 10afc6: 8d 40 20 lea 0x20(%eax),%eax 10afc9: 89 45 b0 mov %eax,-0x50(%ebp) 10afcc: 75 66 jne 10b034 RTEMS_INLINE_ROUTINE void _Chain_Prepend( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert(_Chain_Head(the_chain), the_node); 10afce: 51 push %ecx 10afcf: 51 push %ecx 10afd0: 53 push %ebx 10afd1: 52 push %edx 10afd2: e8 c9 1f 00 00 call 10cfa0 <_Chain_Insert> rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 10afd7: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) pthread_mutex_init (&r_chain->mutex, NULL); 10afde: 5b pop %ebx 10afdf: 58 pop %eax 10afe0: 6a 00 push $0x0 10afe2: 57 push %edi 10afe3: e8 f4 06 00 00 call 10b6dc pthread_cond_init (&r_chain->cond, NULL); 10afe8: 5a pop %edx 10afe9: 59 pop %ecx 10afea: 6a 00 push $0x0 10afec: ff 75 b0 pushl -0x50(%ebp) 10afef: e8 a8 03 00 00 call 10b39c AIO_printf ("New thread \n"); result = pthread_create (&thid, &aio_request_queue.attr, 10aff4: 56 push %esi 10aff5: 68 14 ac 10 00 push $0x10ac14 10affa: 68 c0 72 12 00 push $0x1272c0 10afff: 8d 45 e4 lea -0x1c(%ebp),%eax 10b002: 50 push %eax 10b003: e8 c4 09 00 00 call 10b9cc 10b008: 89 c3 mov %eax,%ebx rtems_aio_handle, (void *) r_chain); if (result != 0) { 10b00a: 83 c4 20 add $0x20,%esp 10b00d: 85 c0 test %eax,%eax 10b00f: 74 18 je 10b029 <== ALWAYS TAKEN pthread_mutex_unlock (&aio_request_queue.mutex); 10b011: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b014: 68 b8 72 12 00 push $0x1272b8 <== NOT EXECUTED 10b019: e8 5e 08 00 00 call 10b87c <== NOT EXECUTED return result; 10b01e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b021: 89 5d b4 mov %ebx,-0x4c(%ebp) <== NOT EXECUTED 10b024: e9 ef 00 00 00 jmp 10b118 <== NOT EXECUTED } ++aio_request_queue.active_threads; 10b029: ff 05 1c 73 12 00 incl 0x12731c 10b02f: e9 d4 00 00 00 jmp 10b108 } else { /* put request in the fd chain it belongs to */ pthread_mutex_lock (&r_chain->mutex); 10b034: 83 ec 0c sub $0xc,%esp 10b037: 57 push %edi 10b038: 89 55 ac mov %edx,-0x54(%ebp) 10b03b: e8 bc 07 00 00 call 10b7fc rtems_aio_insert_prio (&r_chain->perfd, req); 10b040: 5e pop %esi 10b041: 58 pop %eax 10b042: 53 push %ebx 10b043: 8b 55 ac mov -0x54(%ebp),%edx 10b046: 52 push %edx 10b047: e8 ec fd ff ff call 10ae38 pthread_cond_signal (&r_chain->cond); 10b04c: 5b pop %ebx 10b04d: ff 75 b0 pushl -0x50(%ebp) 10b050: eb 36 jmp 10b088 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, 10b052: 51 push %ecx 10b053: 6a 00 push $0x0 10b055: ff 30 pushl (%eax) 10b057: 68 00 73 12 00 push $0x127300 10b05c: e8 d7 fa ff ff call 10ab38 10b061: 89 c6 mov %eax,%esi req->aiocbp->aio_fildes, 0); if (r_chain != NULL) 10b063: 83 c4 10 add $0x10,%esp 10b066: 85 c0 test %eax,%eax 10b068: 74 2d je 10b097 { pthread_mutex_lock (&r_chain->mutex); 10b06a: 8d 78 1c lea 0x1c(%eax),%edi 10b06d: 83 ec 0c sub $0xc,%esp 10b070: 57 push %edi 10b071: e8 86 07 00 00 call 10b7fc rtems_aio_insert_prio (&r_chain->perfd, req); 10b076: 58 pop %eax 10b077: 5a pop %edx 10b078: 53 push %ebx 10b079: 8d 46 08 lea 0x8(%esi),%eax 10b07c: 50 push %eax 10b07d: e8 b6 fd ff ff call 10ae38 pthread_cond_signal (&r_chain->cond); 10b082: 83 c6 20 add $0x20,%esi 10b085: 89 34 24 mov %esi,(%esp) 10b088: e8 ab 03 00 00 call 10b438 pthread_mutex_unlock (&r_chain->mutex); 10b08d: 89 3c 24 mov %edi,(%esp) 10b090: e8 e7 07 00 00 call 10b87c 10b095: eb 6e jmp 10b105 } else { /* or to the idle chain */ chain = &aio_request_queue.idle_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10b097: 56 push %esi 10b098: 6a 01 push $0x1 10b09a: 8b 43 14 mov 0x14(%ebx),%eax 10b09d: ff 30 pushl (%eax) 10b09f: 68 0c 73 12 00 push $0x12730c 10b0a4: e8 8f fa ff ff call 10ab38 10b0a9: 89 c6 mov %eax,%esi if (r_chain->new_fd == 1) { 10b0ab: 83 c4 10 add $0x10,%esp 10b0ae: 83 78 18 01 cmpl $0x1,0x18(%eax) 10b0b2: 8d 40 08 lea 0x8(%eax),%eax 10b0b5: 75 2c jne 10b0e3 10b0b7: 51 push %ecx 10b0b8: 51 push %ecx 10b0b9: 53 push %ebx 10b0ba: 50 push %eax 10b0bb: e8 e0 1e 00 00 call 10cfa0 <_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; 10b0c0: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) pthread_mutex_init (&r_chain->mutex, NULL); 10b0c7: 58 pop %eax 10b0c8: 5a pop %edx 10b0c9: 6a 00 push $0x0 10b0cb: 8d 46 1c lea 0x1c(%esi),%eax 10b0ce: 50 push %eax 10b0cf: e8 08 06 00 00 call 10b6dc pthread_cond_init (&r_chain->cond, NULL); 10b0d4: 5b pop %ebx 10b0d5: 5f pop %edi 10b0d6: 6a 00 push $0x0 10b0d8: 83 c6 20 add $0x20,%esi 10b0db: 56 push %esi 10b0dc: e8 bb 02 00 00 call 10b39c 10b0e1: eb 09 jmp 10b0ec } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req); 10b0e3: 51 push %ecx 10b0e4: 51 push %ecx 10b0e5: 53 push %ebx 10b0e6: 50 push %eax 10b0e7: e8 4c fd ff ff call 10ae38 10b0ec: 83 c4 10 add $0x10,%esp if (aio_request_queue.idle_threads > 0) 10b0ef: 83 3d 20 73 12 00 00 cmpl $0x0,0x127320 10b0f6: 7e 10 jle 10b108 <== ALWAYS TAKEN pthread_cond_signal (&aio_request_queue.new_req); 10b0f8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b0fb: 68 bc 72 12 00 push $0x1272bc <== NOT EXECUTED 10b100: e8 33 03 00 00 call 10b438 <== NOT EXECUTED 10b105: 83 c4 10 add $0x10,%esp } } pthread_mutex_unlock (&aio_request_queue.mutex); 10b108: 83 ec 0c sub $0xc,%esp 10b10b: 68 b8 72 12 00 push $0x1272b8 10b110: e8 67 07 00 00 call 10b87c return 0; 10b115: 83 c4 10 add $0x10,%esp } 10b118: 8b 45 b4 mov -0x4c(%ebp),%eax 10b11b: 8d 65 f4 lea -0xc(%ebp),%esp 10b11e: 5b pop %ebx 10b11f: 5e pop %esi 10b120: 5f pop %edi 10b121: c9 leave 10b122: c3 ret =============================================================================== 0010ac14 : * NULL - if error */ static void * rtems_aio_handle (void *arg) { 10ac14: 55 push %ebp 10ac15: 89 e5 mov %esp,%ebp 10ac17: 57 push %edi 10ac18: 56 push %esi 10ac19: 53 push %ebx 10ac1a: 83 ec 4c sub $0x4c,%esp rtems_aio_request_chain *r_chain = arg; 10ac1d: 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); 10ac20: 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); 10ac23: 8d 43 1c lea 0x1c(%ebx),%eax 10ac26: 89 45 b4 mov %eax,-0x4c(%ebp) 10ac29: 83 ec 0c sub $0xc,%esp 10ac2c: 50 push %eax 10ac2d: e8 ca 0b 00 00 call 10b7fc if (result != 0) 10ac32: 83 c4 10 add $0x10,%esp 10ac35: 85 c0 test %eax,%eax 10ac37: 0f 85 f1 01 00 00 jne 10ae2e <== NEVER TAKEN } } AIO_printf ("Thread finished\n"); return NULL; } 10ac3d: 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 ); 10ac40: 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)) { 10ac43: 39 c6 cmp %eax,%esi 10ac45: 0f 84 cd 00 00 00 je 10ad18 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); 10ac4b: e8 ac 13 00 00 call 10bffc 10ac50: 52 push %edx 10ac51: 8d 55 c0 lea -0x40(%ebp),%edx 10ac54: 52 push %edx 10ac55: 8d 4d e4 lea -0x1c(%ebp),%ecx 10ac58: 51 push %ecx 10ac59: 50 push %eax 10ac5a: e8 a1 0f 00 00 call 10bc00 param.sched_priority = req->priority; 10ac5f: 8b 46 0c mov 0xc(%esi),%eax 10ac62: 89 45 c0 mov %eax,-0x40(%ebp) pthread_setschedparam (pthread_self(), req->policy, ¶m); 10ac65: 8b 56 08 mov 0x8(%esi),%edx 10ac68: 89 55 b0 mov %edx,-0x50(%ebp) 10ac6b: e8 8c 13 00 00 call 10bffc 10ac70: 83 c4 0c add $0xc,%esp 10ac73: 8d 4d c0 lea -0x40(%ebp),%ecx 10ac76: 51 push %ecx 10ac77: 8b 55 b0 mov -0x50(%ebp),%edx 10ac7a: 52 push %edx 10ac7b: 50 push %eax 10ac7c: e8 8b 13 00 00 call 10c00c */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10ac81: 89 34 24 mov %esi,(%esp) 10ac84: e8 db 22 00 00 call 10cf64 <_Chain_Extract> rtems_chain_extract (node); pthread_mutex_unlock (&r_chain->mutex); 10ac89: 59 pop %ecx 10ac8a: ff 75 b4 pushl -0x4c(%ebp) 10ac8d: e8 ea 0b 00 00 call 10b87c switch (req->aiocbp->aio_lio_opcode) { 10ac92: 8b 46 14 mov 0x14(%esi),%eax 10ac95: 83 c4 10 add $0x10,%esp 10ac98: 8b 50 2c mov 0x2c(%eax),%edx 10ac9b: 83 fa 02 cmp $0x2,%edx 10ac9e: 74 20 je 10acc0 10aca0: 83 fa 03 cmp $0x3,%edx 10aca3: 74 36 je 10acdb <== NEVER TAKEN 10aca5: 4a dec %edx 10aca6: 75 45 jne 10aced <== NEVER TAKEN case LIO_READ: AIO_printf ("read\n"); result = pread (req->aiocbp->aio_fildes, 10aca8: 83 ec 0c sub $0xc,%esp 10acab: ff 70 08 pushl 0x8(%eax) 10acae: ff 70 04 pushl 0x4(%eax) 10acb1: ff 70 10 pushl 0x10(%eax) 10acb4: ff 70 0c pushl 0xc(%eax) 10acb7: ff 30 pushl (%eax) 10acb9: e8 76 94 00 00 call 114134 10acbe: eb 16 jmp 10acd6 req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; case LIO_WRITE: AIO_printf ("write\n"); result = pwrite (req->aiocbp->aio_fildes, 10acc0: 83 ec 0c sub $0xc,%esp 10acc3: ff 70 08 pushl 0x8(%eax) 10acc6: ff 70 04 pushl 0x4(%eax) 10acc9: ff 70 10 pushl 0x10(%eax) 10accc: ff 70 0c pushl 0xc(%eax) 10accf: ff 30 pushl (%eax) 10acd1: e8 12 95 00 00 call 1141e8 (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; 10acd6: 83 c4 20 add $0x20,%esp 10acd9: eb 0d jmp 10ace8 case LIO_SYNC: AIO_printf ("sync\n"); result = fsync (req->aiocbp->aio_fildes); 10acdb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10acde: ff 30 pushl (%eax) <== NOT EXECUTED 10ace0: e8 f7 5c 00 00 call 1109dc <== NOT EXECUTED break; 10ace5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED default: result = -1; } if (result == -1) { 10ace8: 83 f8 ff cmp $0xffffffff,%eax 10aceb: 75 19 jne 10ad06 <== ALWAYS TAKEN req->aiocbp->return_value = -1; 10aced: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED 10acf0: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED req->aiocbp->error_code = errno; 10acf7: e8 00 8a 00 00 call 1136fc <__errno> <== NOT EXECUTED 10acfc: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10acfe: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED 10ad01: e9 1d ff ff ff jmp 10ac23 <== NOT EXECUTED } else { req->aiocbp->return_value = result; 10ad06: 8b 56 14 mov 0x14(%esi),%edx 10ad09: 89 42 34 mov %eax,0x34(%edx) req->aiocbp->error_code = 0; 10ad0c: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) 10ad13: e9 0b ff ff ff jmp 10ac23 struct timespec timeout; AIO_printf ("Chain is empty [WQ], wait for work\n"); pthread_mutex_unlock (&r_chain->mutex); 10ad18: 83 ec 0c sub $0xc,%esp 10ad1b: ff 75 b4 pushl -0x4c(%ebp) 10ad1e: e8 59 0b 00 00 call 10b87c pthread_mutex_lock (&aio_request_queue.mutex); 10ad23: c7 04 24 b8 72 12 00 movl $0x1272b8,(%esp) 10ad2a: e8 cd 0a 00 00 call 10b7fc if (rtems_chain_is_empty (chain)) 10ad2f: 83 c4 10 add $0x10,%esp 10ad32: 39 73 08 cmp %esi,0x8(%ebx) 10ad35: 0f 85 de 00 00 00 jne 10ae19 <== NEVER TAKEN { clock_gettime (CLOCK_REALTIME, &timeout); 10ad3b: 52 push %edx 10ad3c: 52 push %edx 10ad3d: 57 push %edi 10ad3e: 6a 01 push $0x1 10ad40: e8 47 05 00 00 call 10b28c timeout.tv_sec += 3; 10ad45: 83 45 dc 03 addl $0x3,-0x24(%ebp) timeout.tv_nsec = 0; 10ad49: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) result = pthread_cond_timedwait (&r_chain->cond, 10ad50: 8d 73 20 lea 0x20(%ebx),%esi 10ad53: 83 c4 0c add $0xc,%esp 10ad56: 57 push %edi 10ad57: 68 b8 72 12 00 push $0x1272b8 10ad5c: 56 push %esi 10ad5d: e8 46 07 00 00 call 10b4a8 &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) { 10ad62: 83 c4 10 add $0x10,%esp 10ad65: 83 f8 74 cmp $0x74,%eax 10ad68: 0f 85 ab 00 00 00 jne 10ae19 <== NEVER TAKEN 10ad6e: 83 ec 0c sub $0xc,%esp 10ad71: 53 push %ebx 10ad72: e8 ed 21 00 00 call 10cf64 <_Chain_Extract> rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex); 10ad77: 58 pop %eax 10ad78: ff 75 b4 pushl -0x4c(%ebp) 10ad7b: e8 5c 08 00 00 call 10b5dc pthread_cond_destroy (&r_chain->cond); 10ad80: 89 34 24 mov %esi,(%esp) 10ad83: e8 60 05 00 00 call 10b2e8 free (r_chain); 10ad88: 89 1c 24 mov %ebx,(%esp) 10ad8b: e8 a0 cf ff ff call 107d30 /* 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)) { 10ad90: 83 c4 10 add $0x10,%esp 10ad93: 81 3d 0c 73 12 00 10 cmpl $0x127310,0x12730c 10ad9a: 73 12 00 10ad9d: 75 54 jne 10adf3 AIO_printf ("Chain is empty [IQ], wait for work\n"); ++aio_request_queue.idle_threads; 10ad9f: ff 05 20 73 12 00 incl 0x127320 --aio_request_queue.active_threads; 10ada5: ff 0d 1c 73 12 00 decl 0x12731c clock_gettime (CLOCK_REALTIME, &timeout); 10adab: 53 push %ebx 10adac: 53 push %ebx 10adad: 57 push %edi 10adae: 6a 01 push $0x1 10adb0: e8 d7 04 00 00 call 10b28c timeout.tv_sec += 3; 10adb5: 83 45 dc 03 addl $0x3,-0x24(%ebp) timeout.tv_nsec = 0; 10adb9: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) result = pthread_cond_timedwait (&aio_request_queue.new_req, 10adc0: 83 c4 0c add $0xc,%esp 10adc3: 57 push %edi 10adc4: 68 b8 72 12 00 push $0x1272b8 10adc9: 68 bc 72 12 00 push $0x1272bc 10adce: e8 d5 06 00 00 call 10b4a8 &aio_request_queue.mutex, &timeout); /* If no new fd chain was added in the idle requests then this thread is finished */ if (result == ETIMEDOUT) { 10add3: 83 c4 10 add $0x10,%esp 10add6: 83 f8 74 cmp $0x74,%eax 10add9: 75 18 jne 10adf3 <== NEVER TAKEN AIO_printf ("Etimeout\n"); --aio_request_queue.idle_threads; 10addb: ff 0d 20 73 12 00 decl 0x127320 pthread_mutex_unlock (&aio_request_queue.mutex); 10ade1: 83 ec 0c sub $0xc,%esp 10ade4: 68 b8 72 12 00 push $0x1272b8 10ade9: e8 8e 0a 00 00 call 10b87c return NULL; 10adee: 83 c4 10 add $0x10,%esp 10adf1: eb 3b jmp 10ae2e } } /* 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; 10adf3: ff 0d 20 73 12 00 decl 0x127320 ++aio_request_queue.active_threads; 10adf9: ff 05 1c 73 12 00 incl 0x12731c } } AIO_printf ("Thread finished\n"); return NULL; } 10adff: 8b 1d 0c 73 12 00 mov 0x12730c,%ebx 10ae05: 83 ec 0c sub $0xc,%esp 10ae08: 53 push %ebx 10ae09: e8 56 21 00 00 call 10cf64 <_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); 10ae0e: 89 1c 24 mov %ebx,(%esp) 10ae11: e8 cd fd ff ff call 10abe3 10ae16: 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); 10ae19: 83 ec 0c sub $0xc,%esp 10ae1c: 68 b8 72 12 00 push $0x1272b8 10ae21: e8 56 0a 00 00 call 10b87c 10ae26: 83 c4 10 add $0x10,%esp 10ae29: e9 f5 fd ff ff jmp 10ac23 } } AIO_printf ("Thread finished\n"); return NULL; } 10ae2e: 31 c0 xor %eax,%eax 10ae30: 8d 65 f4 lea -0xc(%ebp),%esp 10ae33: 5b pop %ebx 10ae34: 5e pop %esi 10ae35: 5f pop %edi 10ae36: c9 leave 10ae37: c3 ret =============================================================================== 0010aa3c : * 0 - if initialization succeeded */ int rtems_aio_init (void) { 10aa3c: 55 push %ebp 10aa3d: 89 e5 mov %esp,%ebp 10aa3f: 53 push %ebx 10aa40: 83 ec 10 sub $0x10,%esp int result = 0; result = pthread_attr_init (&aio_request_queue.attr); 10aa43: 68 c0 72 12 00 push $0x1272c0 10aa48: e8 33 0f 00 00 call 10b980 10aa4d: 89 c3 mov %eax,%ebx if (result != 0) 10aa4f: 83 c4 10 add $0x10,%esp 10aa52: 85 c0 test %eax,%eax 10aa54: 0f 85 d7 00 00 00 jne 10ab31 <== NEVER TAKEN return result; result = 10aa5a: 51 push %ecx 10aa5b: 51 push %ecx 10aa5c: 6a 00 push $0x0 10aa5e: 68 c0 72 12 00 push $0x1272c0 10aa63: e8 40 0f 00 00 call 10b9a8 pthread_attr_setdetachstate (&aio_request_queue.attr, PTHREAD_CREATE_DETACHED); if (result != 0) 10aa68: 83 c4 10 add $0x10,%esp 10aa6b: 85 c0 test %eax,%eax 10aa6d: 74 10 je 10aa7f <== ALWAYS TAKEN pthread_attr_destroy (&aio_request_queue.attr); 10aa6f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa72: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED 10aa77: e8 e4 0e 00 00 call 10b960 <== NOT EXECUTED 10aa7c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED result = pthread_mutex_init (&aio_request_queue.mutex, NULL); 10aa7f: 52 push %edx 10aa80: 52 push %edx 10aa81: 6a 00 push $0x0 10aa83: 68 b8 72 12 00 push $0x1272b8 10aa88: e8 4f 0c 00 00 call 10b6dc if (result != 0) 10aa8d: 83 c4 10 add $0x10,%esp 10aa90: 85 c0 test %eax,%eax 10aa92: 74 10 je 10aaa4 <== ALWAYS TAKEN pthread_attr_destroy (&aio_request_queue.attr); 10aa94: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa97: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED 10aa9c: e8 bf 0e 00 00 call 10b960 <== NOT EXECUTED 10aaa1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED result = pthread_cond_init (&aio_request_queue.new_req, NULL); 10aaa4: 50 push %eax 10aaa5: 50 push %eax 10aaa6: 6a 00 push $0x0 10aaa8: 68 bc 72 12 00 push $0x1272bc 10aaad: e8 ea 08 00 00 call 10b39c 10aab2: 89 c3 mov %eax,%ebx if (result != 0) { 10aab4: 83 c4 10 add $0x10,%esp 10aab7: 85 c0 test %eax,%eax 10aab9: 74 1c je 10aad7 <== ALWAYS TAKEN pthread_mutex_destroy (&aio_request_queue.mutex); 10aabb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aabe: 68 b8 72 12 00 push $0x1272b8 <== NOT EXECUTED 10aac3: e8 14 0b 00 00 call 10b5dc <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); 10aac8: c7 04 24 c0 72 12 00 movl $0x1272c0,(%esp) <== NOT EXECUTED 10aacf: e8 8c 0e 00 00 call 10b960 <== NOT EXECUTED 10aad4: 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; 10aad7: c7 05 00 73 12 00 04 movl $0x127304,0x127300 10aade: 73 12 00 head->previous = NULL; 10aae1: c7 05 04 73 12 00 00 movl $0x0,0x127304 10aae8: 00 00 00 tail->previous = head; 10aaeb: c7 05 08 73 12 00 00 movl $0x127300,0x127308 10aaf2: 73 12 00 ) { Chain_Node *head = _Chain_Head( the_chain ); Chain_Node *tail = _Chain_Tail( the_chain ); head->next = tail; 10aaf5: c7 05 0c 73 12 00 10 movl $0x127310,0x12730c 10aafc: 73 12 00 head->previous = NULL; 10aaff: c7 05 10 73 12 00 00 movl $0x0,0x127310 10ab06: 00 00 00 tail->previous = head; 10ab09: c7 05 14 73 12 00 0c movl $0x12730c,0x127314 10ab10: 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; 10ab13: c7 05 1c 73 12 00 00 movl $0x0,0x12731c 10ab1a: 00 00 00 aio_request_queue.idle_threads = 0; 10ab1d: c7 05 20 73 12 00 00 movl $0x0,0x127320 10ab24: 00 00 00 aio_request_queue.initialized = AIO_QUEUE_INITIALIZED; 10ab27: c7 05 18 73 12 00 0b movl $0xb00b,0x127318 10ab2e: b0 00 00 return result; } 10ab31: 89 d8 mov %ebx,%eax 10ab33: 8b 5d fc mov -0x4(%ebp),%ebx 10ab36: c9 leave 10ab37: c3 ret =============================================================================== 0010ae38 : * NONE */ void rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req) { 10ae38: 55 push %ebp 10ae39: 89 e5 mov %esp,%ebp 10ae3b: 56 push %esi 10ae3c: 53 push %ebx 10ae3d: 8b 4d 08 mov 0x8(%ebp),%ecx 10ae40: 8b 55 0c mov 0xc(%ebp),%edx } } AIO_printf ("Thread finished\n"); return NULL; } 10ae43: 8b 01 mov (%ecx),%eax 10ae45: 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)) { 10ae48: 39 d8 cmp %ebx,%eax 10ae4a: 74 27 je 10ae73 <== 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; 10ae4c: 8b 48 14 mov 0x14(%eax),%ecx 10ae4f: 8b 49 14 mov 0x14(%ecx),%ecx while (req->aiocbp->aio_reqprio > prio && 10ae52: 8b 72 14 mov 0x14(%edx),%esi 10ae55: 8b 76 14 mov 0x14(%esi),%esi 10ae58: eb 08 jmp 10ae62 } } AIO_printf ("Thread finished\n"); return NULL; } 10ae5a: 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; 10ae5c: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED 10ae5f: 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 && 10ae62: 39 ce cmp %ecx,%esi 10ae64: 7e 04 jle 10ae6a <== ALWAYS TAKEN 10ae66: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10ae68: 75 f0 jne 10ae5a <== 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 ); 10ae6a: 89 55 0c mov %edx,0xc(%ebp) 10ae6d: 8b 40 04 mov 0x4(%eax),%eax 10ae70: 89 45 08 mov %eax,0x8(%ebp) } rtems_chain_insert (node->previous, &req->next_prio); } } 10ae73: 5b pop %ebx 10ae74: 5e pop %esi 10ae75: c9 leave 10ae76: e9 25 21 00 00 jmp 10cfa0 <_Chain_Insert> =============================================================================== 0010abe3 : * NONE */ void rtems_aio_move_to_work (rtems_aio_request_chain *r_chain) { 10abe3: 55 push %ebp 10abe4: 89 e5 mov %esp,%ebp 10abe6: 83 ec 08 sub $0x8,%esp 10abe9: 8b 55 08 mov 0x8(%ebp),%edx } } AIO_printf ("Thread finished\n"); return NULL; } 10abec: a1 00 73 12 00 mov 0x127300,%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 && 10abf1: 8b 4a 14 mov 0x14(%edx),%ecx 10abf4: eb 02 jmp 10abf8 } } AIO_printf ("Thread finished\n"); return NULL; } 10abf6: 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 && 10abf8: 39 48 14 cmp %ecx,0x14(%eax) 10abfb: 7d 07 jge 10ac04 10abfd: 3d 04 73 12 00 cmp $0x127304,%eax 10ac02: 75 f2 jne 10abf6 <== ALWAYS TAKEN 10ac04: 51 push %ecx 10ac05: 51 push %ecx 10ac06: 52 push %edx 10ac07: ff 70 04 pushl 0x4(%eax) 10ac0a: e8 91 23 00 00 call 10cfa0 <_Chain_Insert> 10ac0f: 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); } 10ac12: c9 leave 10ac13: c3 ret =============================================================================== 0010aec4 : * 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) { 10aec4: 55 push %ebp 10aec5: 89 e5 mov %esp,%ebp 10aec7: 53 push %ebx 10aec8: 83 ec 04 sub $0x4,%esp 10aecb: 8b 55 08 mov 0x8(%ebp),%edx 10aece: 8b 4d 0c mov 0xc(%ebp),%ecx } } AIO_printf ("Thread finished\n"); return NULL; } 10aed1: 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 ); 10aed3: 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; 10aed6: 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)) 10aedb: 39 d3 cmp %edx,%ebx 10aedd: 75 08 jne 10aee7 10aedf: eb 3b jmp 10af1c } } AIO_printf ("Thread finished\n"); return NULL; } 10aee1: 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) { 10aee3: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 10aee5: 74 30 je 10af17 <== NOT EXECUTED node = rtems_chain_next (node); current = (rtems_aio_request *) node; 10aee7: 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) { 10aee9: 39 4b 14 cmp %ecx,0x14(%ebx) 10aeec: 75 f3 jne 10aee1 <== NEVER TAKEN 10aeee: 83 ec 0c sub $0xc,%esp 10aef1: 53 push %ebx 10aef2: e8 6d 20 00 00 call 10cf64 <_Chain_Extract> if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; else { rtems_chain_extract (node); current->aiocbp->error_code = ECANCELED; 10aef7: 8b 43 14 mov 0x14(%ebx),%eax 10aefa: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) current->aiocbp->return_value = -1; 10af01: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) free (current); 10af08: 89 1c 24 mov %ebx,(%esp) 10af0b: e8 20 ce ff ff call 107d30 } return AIO_CANCELED; 10af10: 83 c4 10 add $0x10,%esp 10af13: 31 c0 xor %eax,%eax 10af15: eb 05 jmp 10af1c node = rtems_chain_next (node); current = (rtems_aio_request *) node; } if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; 10af17: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED current->aiocbp->return_value = -1; free (current); } return AIO_CANCELED; } 10af1c: 8b 5d fc mov -0x4(%ebp),%ebx 10af1f: c9 leave 10af20: c3 ret =============================================================================== 0010ab34 : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10ab34: 55 push %ebp 10ab35: 89 e5 mov %esp,%ebp 10ab37: 56 push %esi 10ab38: 53 push %ebx 10ab39: 8b 5d 10 mov 0x10(%ebp),%ebx 10ab3c: 8b 75 14 mov 0x14(%ebp),%esi RTEMS_INLINE_ROUTINE bool rtems_chain_append_with_empty_check( rtems_chain_control *chain, rtems_chain_node *node ) { return _Chain_Append_with_empty_check( chain, node ); 10ab3f: 50 push %eax 10ab40: 50 push %eax 10ab41: ff 75 0c pushl 0xc(%ebp) 10ab44: ff 75 08 pushl 0x8(%ebp) 10ab47: e8 8c 04 00 00 call 10afd8 <_Chain_Append_with_empty_check> rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_append_with_empty_check( chain, node ); if ( was_empty ) { 10ab4c: 83 c4 10 add $0x10,%esp 10ab4f: 84 c0 test %al,%al 10ab51: 74 11 je 10ab64 <== NEVER TAKEN sc = rtems_event_send( task, events ); 10ab53: 89 75 0c mov %esi,0xc(%ebp) 10ab56: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10ab59: 8d 65 f8 lea -0x8(%ebp),%esp 10ab5c: 5b pop %ebx 10ab5d: 5e pop %esi 10ab5e: c9 leave { rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_append_with_empty_check( chain, node ); if ( was_empty ) { sc = rtems_event_send( task, events ); 10ab5f: e9 cc f6 ff ff jmp 10a230 } return sc; } 10ab64: 31 c0 xor %eax,%eax 10ab66: 8d 65 f8 lea -0x8(%ebp),%esp 10ab69: 5b pop %ebx 10ab6a: 5e pop %esi 10ab6b: c9 leave 10ab6c: c3 ret <== NOT EXECUTED =============================================================================== 0010abac : rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) { 10abac: 55 push %ebp 10abad: 89 e5 mov %esp,%ebp 10abaf: 57 push %edi 10abb0: 56 push %esi 10abb1: 53 push %ebx 10abb2: 83 ec 1c sub $0x1c,%esp 10abb5: 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( 10abb8: 8d 75 e4 lea -0x1c(%ebp),%esi 10abbb: eb 13 jmp 10abd0 10abbd: 56 push %esi 10abbe: ff 75 10 pushl 0x10(%ebp) 10abc1: 6a 00 push $0x0 10abc3: 57 push %edi 10abc4: e8 07 f5 ff ff call 10a0d0 ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( 10abc9: 83 c4 10 add $0x10,%esp 10abcc: 85 c0 test %eax,%eax 10abce: 75 16 jne 10abe6 <== ALWAYS TAKEN */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 10abd0: 83 ec 0c sub $0xc,%esp 10abd3: ff 75 08 pushl 0x8(%ebp) 10abd6: e8 9d 04 00 00 call 10b078 <_Chain_Get> 10abdb: 89 c3 mov %eax,%ebx sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 10abdd: 83 c4 10 add $0x10,%esp 10abe0: 85 c0 test %eax,%eax 10abe2: 74 d9 je 10abbd 10abe4: 31 c0 xor %eax,%eax timeout, &out ); } *node_ptr = node; 10abe6: 8b 55 14 mov 0x14(%ebp),%edx 10abe9: 89 1a mov %ebx,(%edx) return sc; } 10abeb: 8d 65 f4 lea -0xc(%ebp),%esp 10abee: 5b pop %ebx 10abef: 5e pop %esi 10abf0: 5f pop %edi 10abf1: c9 leave 10abf2: c3 ret =============================================================================== 0010abf4 : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10abf4: 55 push %ebp 10abf5: 89 e5 mov %esp,%ebp 10abf7: 56 push %esi 10abf8: 53 push %ebx 10abf9: 8b 5d 10 mov 0x10(%ebp),%ebx 10abfc: 8b 75 14 mov 0x14(%ebp),%esi RTEMS_INLINE_ROUTINE bool rtems_chain_prepend_with_empty_check( rtems_chain_control *chain, rtems_chain_node *node ) { return _Chain_Prepend_with_empty_check( chain, node ); 10abff: 50 push %eax 10ac00: 50 push %eax 10ac01: ff 75 0c pushl 0xc(%ebp) 10ac04: ff 75 08 pushl 0x8(%ebp) 10ac07: e8 b0 04 00 00 call 10b0bc <_Chain_Prepend_with_empty_check> rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_prepend_with_empty_check( chain, node ); if (was_empty) { 10ac0c: 83 c4 10 add $0x10,%esp 10ac0f: 84 c0 test %al,%al 10ac11: 74 11 je 10ac24 <== NEVER TAKEN sc = rtems_event_send( task, events ); 10ac13: 89 75 0c mov %esi,0xc(%ebp) 10ac16: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10ac19: 8d 65 f8 lea -0x8(%ebp),%esp 10ac1c: 5b pop %ebx 10ac1d: 5e pop %esi 10ac1e: c9 leave { rtems_status_code sc = RTEMS_SUCCESSFUL; bool was_empty = rtems_chain_prepend_with_empty_check( chain, node ); if (was_empty) { sc = rtems_event_send( task, events ); 10ac1f: e9 0c f6 ff ff jmp 10a230 } return sc; } 10ac24: 31 c0 xor %eax,%eax 10ac26: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ac29: 5b pop %ebx <== NOT EXECUTED 10ac2a: 5e pop %esi <== NOT EXECUTED 10ac2b: c9 leave <== NOT EXECUTED 10ac2c: c3 ret <== NOT EXECUTED =============================================================================== 00107698 : void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) { 107698: 55 push %ebp 107699: 89 e5 mov %esp,%ebp 10769b: 57 push %edi 10769c: 56 push %esi 10769d: 53 push %ebx 10769e: 83 ec 6c sub $0x6c,%esp 1076a1: 8b 7d 08 mov 0x8(%ebp),%edi Timestamp_Control uptime, total, ran, last_context_switch; #else uint32_t total_units = 0; #endif if ( !print ) 1076a4: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 1076a8: 0f 84 54 01 00 00 je 107802 <== NEVER TAKEN * When not using nanosecond CPU usage resolution, we have to count * the number of "ticks" we gave credit for to give the user a rough * guideline as to what each number means proportionally. */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ last_context_switch = _Thread_Time_of_last_context_switch; 1076ae: a1 f4 01 13 00 mov 0x1301f4,%eax 1076b3: 8b 15 f8 01 13 00 mov 0x1301f8,%edx 1076b9: 89 45 c0 mov %eax,-0x40(%ebp) 1076bc: 89 55 c4 mov %edx,-0x3c(%ebp) _TOD_Get_uptime( &uptime ); 1076bf: 83 ec 0c sub $0xc,%esp 1076c2: 8d 5d d8 lea -0x28(%ebp),%ebx 1076c5: 53 push %ebx 1076c6: e8 75 4b 00 00 call 10c240 <_TOD_Get_uptime> _Timestamp_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total ); 1076cb: 83 c4 0c add $0xc,%esp 1076ce: 8d 75 d0 lea -0x30(%ebp),%esi 1076d1: 56 push %esi 1076d2: 53 push %ebx 1076d3: 68 e0 06 13 00 push $0x1306e0 1076d8: e8 1f 6b 00 00 call 10e1fc <_Timespec_Subtract> } } } #endif (*print)( 1076dd: 5b pop %ebx 1076de: 5e pop %esi 1076df: 68 5d 14 12 00 push $0x12145d 1076e4: 57 push %edi 1076e5: ff 55 0c call *0xc(%ebp) 1076e8: 83 c4 10 add $0x10,%esp " ID | NAME | TICKS | PERCENT\n" #endif "------------+----------------------------------------+---------------+---------\n" ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 1076eb: 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 ]; 1076f0: 8b 04 9d fc 00 13 00 mov 0x1300fc(,%ebx,4),%eax 1076f7: 8b 70 04 mov 0x4(%eax),%esi if ( information ) { 1076fa: 85 f6 test %esi,%esi 1076fc: 0f 84 da 00 00 00 je 1077dc <== NEVER TAKEN 107702: c7 45 a4 01 00 00 00 movl $0x1,-0x5c(%ebp) 107709: 89 5d 94 mov %ebx,-0x6c(%ebp) 10770c: e9 bb 00 00 00 jmp 1077cc for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 107711: 8b 46 1c mov 0x1c(%esi),%eax 107714: 8b 4d a4 mov -0x5c(%ebp),%ecx 107717: 8b 14 88 mov (%eax,%ecx,4),%edx if ( !the_thread ) 10771a: 85 d2 test %edx,%edx 10771c: 0f 84 a7 00 00 00 je 1077c9 <== NEVER TAKEN continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 107722: 51 push %ecx 107723: 8d 5d ab lea -0x55(%ebp),%ebx 107726: 53 push %ebx 107727: 6a 0d push $0xd 107729: ff 72 08 pushl 0x8(%edx) 10772c: 89 55 a0 mov %edx,-0x60(%ebp) 10772f: e8 98 39 00 00 call 10b0cc (*print)( 107734: 53 push %ebx 107735: 8b 55 a0 mov -0x60(%ebp),%edx 107738: ff 72 08 pushl 0x8(%edx) 10773b: 68 cf 15 12 00 push $0x1215cf 107740: 57 push %edi 107741: 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; 107744: 8b 55 a0 mov -0x60(%ebp),%edx 107747: 8b 8a 84 00 00 00 mov 0x84(%edx),%ecx 10774d: 8b 9a 88 00 00 00 mov 0x88(%edx),%ebx 107753: 89 4d c8 mov %ecx,-0x38(%ebp) 107756: 89 5d cc mov %ebx,-0x34(%ebp) if ( _Thread_Executing->Object.id == the_thread->Object.id ) { 107759: 83 c4 20 add $0x20,%esp 10775c: a1 ac 06 13 00 mov 0x1306ac,%eax 107761: 8b 5a 08 mov 0x8(%edx),%ebx 107764: 39 58 08 cmp %ebx,0x8(%eax) 107767: 75 27 jne 107790 Timestamp_Control used; _Timestamp_Subtract( &last_context_switch, &uptime, &used ); 107769: 50 push %eax 10776a: 8d 45 b8 lea -0x48(%ebp),%eax 10776d: 50 push %eax 10776e: 8d 55 d8 lea -0x28(%ebp),%edx 107771: 52 push %edx 107772: 8d 55 c0 lea -0x40(%ebp),%edx 107775: 52 push %edx 107776: 89 45 a0 mov %eax,-0x60(%ebp) 107779: e8 7e 6a 00 00 call 10e1fc <_Timespec_Subtract> _Timestamp_Add_to( &ran, &used ); 10777e: 59 pop %ecx 10777f: 5b pop %ebx 107780: 8b 45 a0 mov -0x60(%ebp),%eax 107783: 50 push %eax 107784: 8d 45 c8 lea -0x38(%ebp),%eax 107787: 50 push %eax 107788: e8 83 69 00 00 call 10e110 <_Timespec_Add_to> 10778d: 83 c4 10 add $0x10,%esp }; _Timestamp_Divide( &ran, &total, &ival, &fval ); 107790: 8d 4d e0 lea -0x20(%ebp),%ecx 107793: 51 push %ecx 107794: 8d 5d e4 lea -0x1c(%ebp),%ebx 107797: 53 push %ebx 107798: 8d 45 d0 lea -0x30(%ebp),%eax 10779b: 50 push %eax 10779c: 8d 4d c8 lea -0x38(%ebp),%ecx 10779f: 51 push %ecx 1077a0: e8 9b 69 00 00 call 10e140 <_Timespec_Divide> /* * Print the information */ (*print)( context, 1077a5: 58 pop %eax 1077a6: 5a pop %edx 1077a7: ff 75 e0 pushl -0x20(%ebp) 1077aa: ff 75 e4 pushl -0x1c(%ebp) 1077ad: 8b 45 cc mov -0x34(%ebp),%eax 1077b0: b9 e8 03 00 00 mov $0x3e8,%ecx 1077b5: 31 d2 xor %edx,%edx 1077b7: f7 f1 div %ecx 1077b9: 50 push %eax 1077ba: ff 75 c8 pushl -0x38(%ebp) 1077bd: 68 e2 15 12 00 push $0x1215e2 1077c2: 57 push %edi 1077c3: ff 55 0c call *0xc(%ebp) 1077c6: 83 c4 20 add $0x20,%esp continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 1077c9: ff 45 a4 incl -0x5c(%ebp) 1077cc: 0f b7 46 10 movzwl 0x10(%esi),%eax 1077d0: 39 45 a4 cmp %eax,-0x5c(%ebp) 1077d3: 0f 86 38 ff ff ff jbe 107711 1077d9: 8b 5d 94 mov -0x6c(%ebp),%ebx " ID | NAME | TICKS | PERCENT\n" #endif "------------+----------------------------------------+---------------+---------\n" ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 1077dc: 43 inc %ebx 1077dd: 83 fb 04 cmp $0x4,%ebx 1077e0: 0f 85 0a ff ff ff jne 1076f0 } } } #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( 1077e6: 8b 45 d4 mov -0x2c(%ebp),%eax 1077e9: b9 e8 03 00 00 mov $0x3e8,%ecx 1077ee: 31 d2 xor %edx,%edx 1077f0: f7 f1 div %ecx 1077f2: 50 push %eax 1077f3: ff 75 d0 pushl -0x30(%ebp) 1077f6: 68 fa 15 12 00 push $0x1215fa 1077fb: 57 push %edi 1077fc: ff 55 0c call *0xc(%ebp) 1077ff: 83 c4 10 add $0x10,%esp "-------------------------------------------------------------------------------\n", _Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset, total_units ); #endif } 107802: 8d 65 f4 lea -0xc(%ebp),%esp 107805: 5b pop %ebx 107806: 5e pop %esi 107807: 5f pop %edi 107808: c9 leave 107809: c3 ret =============================================================================== 001110cc : [RTEMS_IO_ERROR] = EIO, [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_deviceio_errno(rtems_status_code sc) { 1110cc: 55 push %ebp 1110cd: 89 e5 mov %esp,%ebp 1110cf: 53 push %ebx 1110d0: 83 ec 04 sub $0x4,%esp 1110d3: 8b 55 08 mov 0x8(%ebp),%edx if (sc == RTEMS_SUCCESSFUL) { return 0; 1110d6: 31 c0 xor %eax,%eax [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_deviceio_errno(rtems_status_code sc) { if (sc == RTEMS_SUCCESSFUL) { 1110d8: 85 d2 test %edx,%edx 1110da: 74 1b je 1110f7 return 0; } else { int eno = EINVAL; 1110dc: bb 16 00 00 00 mov $0x16,%ebx if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) { 1110e1: 83 fa 1c cmp $0x1c,%edx 1110e4: 77 07 ja 1110ed <== NEVER TAKEN eno = status_code_to_errno [sc]; 1110e6: 8b 1c 95 40 f7 11 00 mov 0x11f740(,%edx,4),%ebx } errno = eno; 1110ed: e8 5a 00 00 00 call 11114c <__errno> 1110f2: 89 18 mov %ebx,(%eax) return -1; 1110f4: 83 c8 ff or $0xffffffff,%eax } } 1110f7: 5a pop %edx 1110f8: 5b pop %ebx 1110f9: c9 leave 1110fa: c3 ret =============================================================================== 0010e407 : rtems_filesystem_fsmount_me_t rtems_filesystem_get_mount_handler( const char *type ) { 10e407: 55 push %ebp 10e408: 89 e5 mov %esp,%ebp 10e40a: 83 ec 18 sub $0x18,%esp 10e40d: 8b 45 08 mov 0x8(%ebp),%eax find_arg fa = { 10e410: 89 45 f0 mov %eax,-0x10(%ebp) 10e413: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) .type = type, .mount_h = NULL }; if ( type != NULL ) { 10e41a: 85 c0 test %eax,%eax 10e41c: 74 13 je 10e431 <== NEVER TAKEN rtems_filesystem_iterate( find_handler, &fa ); 10e41e: 50 push %eax 10e41f: 50 push %eax 10e420: 8d 45 f0 lea -0x10(%ebp),%eax 10e423: 50 push %eax 10e424: 68 30 e3 10 00 push $0x10e330 10e429: e8 62 ff ff ff call 10e390 10e42e: 83 c4 10 add $0x10,%esp } return fa.mount_h; } 10e431: 8b 45 f4 mov -0xc(%ebp),%eax 10e434: c9 leave 10e435: c3 ret =============================================================================== 001070fc : * configuration is a single instantiation of the IMFS or miniIMFS with * a single "/dev" directory in it. */ void rtems_filesystem_initialize( void ) { 1070fc: 55 push %ebp 1070fd: 89 e5 mov %esp,%ebp 1070ff: 57 push %edi 107100: 56 push %esi 107101: 53 push %ebx 107102: 83 ec 2c sub $0x2c,%esp /* * Set the default umask to "022". */ rtems_filesystem_umask = 022; 107105: a1 60 30 12 00 mov 0x123060,%eax 10710a: c7 40 2c 12 00 00 00 movl $0x12,0x2c(%eax) /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) 107111: 83 3d 00 d8 11 00 00 cmpl $0x0,0x11d800 107118: 75 0a jne 107124 <== ALWAYS TAKEN rtems_fatal_error_occurred( 0xABCD0001 ); 10711a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10711d: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED 107122: eb 28 jmp 10714c <== NOT EXECUTED mt = &rtems_filesystem_mount_table[0]; 107124: a1 4c 11 12 00 mov 0x12114c,%eax status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL ); 107129: 83 ec 0c sub $0xc,%esp 10712c: 6a 00 push $0x0 10712e: ff 70 04 pushl 0x4(%eax) 107131: ff 30 pushl (%eax) 107133: ff 70 0c pushl 0xc(%eax) 107136: ff 70 08 pushl 0x8(%eax) 107139: e8 77 06 00 00 call 1077b5 if ( status == -1 ) 10713e: 83 c4 20 add $0x20,%esp 107141: 40 inc %eax 107142: 75 0d jne 107151 <== ALWAYS TAKEN rtems_fatal_error_occurred( 0xABCD0002 ); 107144: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107147: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED 10714c: e8 eb 35 00 00 call 10a73c <== NOT EXECUTED rtems_filesystem_link_counts = 0; 107151: a1 60 30 12 00 mov 0x123060,%eax 107156: 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); 10715c: 83 ec 0c sub $0xc,%esp 10715f: 6a 00 push $0x0 107161: 8d 5d d4 lea -0x2c(%ebp),%ebx 107164: 53 push %ebx 107165: 6a 00 push $0x0 107167: 6a 01 push $0x1 107169: 68 5c ef 11 00 push $0x11ef5c 10716e: e8 03 01 00 00 call 107276 rtems_filesystem_root = loc; 107173: 8b 3d 60 30 12 00 mov 0x123060,%edi 107179: 83 c7 18 add $0x18,%edi 10717c: b9 05 00 00 00 mov $0x5,%ecx 107181: 89 de mov %ebx,%esi 107183: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0); 107185: 83 c4 14 add $0x14,%esp 107188: 6a 00 push $0x0 10718a: 53 push %ebx 10718b: 6a 00 push $0x0 10718d: 6a 01 push $0x1 10718f: 68 5c ef 11 00 push $0x11ef5c 107194: e8 dd 00 00 00 call 107276 rtems_filesystem_current = loc; 107199: 8b 3d 60 30 12 00 mov 0x123060,%edi 10719f: 83 c7 04 add $0x4,%edi 1071a2: b9 05 00 00 00 mov $0x5,%ecx 1071a7: 89 de mov %ebx,%esi 1071a9: 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); 1071ab: 83 c4 18 add $0x18,%esp 1071ae: 68 ff 01 00 00 push $0x1ff 1071b3: 68 5e ef 11 00 push $0x11ef5e 1071b8: e8 c3 04 00 00 call 107680 if ( status != 0 ) 1071bd: 83 c4 10 add $0x10,%esp 1071c0: 85 c0 test %eax,%eax 1071c2: 74 0d je 1071d1 <== ALWAYS TAKEN rtems_fatal_error_occurred( 0xABCD0003 ); 1071c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1071c7: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED 1071cc: e9 7b ff ff ff jmp 10714c <== 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. */ } 1071d1: 8d 65 f4 lea -0xc(%ebp),%esp 1071d4: 5b pop %ebx 1071d5: 5e pop %esi 1071d6: 5f pop %edi 1071d7: c9 leave 1071d8: c3 ret =============================================================================== 0010e390 : bool rtems_filesystem_iterate( rtems_per_filesystem_routine routine, void *routine_arg ) { 10e390: 55 push %ebp 10e391: 89 e5 mov %esp,%ebp 10e393: 57 push %edi 10e394: 56 push %esi 10e395: 53 push %ebx 10e396: 83 ec 1c sub $0x1c,%esp 10e399: 8b 75 08 mov 0x8(%ebp),%esi 10e39c: 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; 10e39f: 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]; 10e3a1: bb e0 d7 11 00 mov $0x11d7e0,%ebx rtems_chain_node *node = NULL; bool stop = false; while ( table_entry->type && !stop ) { 10e3a6: eb 0c jmp 10e3b4 stop = (*routine)( table_entry, routine_arg ); 10e3a8: 51 push %ecx 10e3a9: 51 push %ecx 10e3aa: 57 push %edi 10e3ab: 53 push %ebx 10e3ac: ff d6 call *%esi ++table_entry; 10e3ae: 83 c3 08 add $0x8,%ebx 10e3b1: 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 ) { 10e3b4: 83 3b 00 cmpl $0x0,(%ebx) 10e3b7: 74 06 je 10e3bf 10e3b9: 84 c0 test %al,%al 10e3bb: 74 eb je 10e3a8 10e3bd: eb 40 jmp 10e3ff stop = (*routine)( table_entry, routine_arg ); ++table_entry; } if ( !stop ) { 10e3bf: 84 c0 test %al,%al 10e3c1: 75 3c jne 10e3ff rtems_libio_lock(); 10e3c3: 88 45 e4 mov %al,-0x1c(%ebp) 10e3c6: e8 95 ff ff ff call 10e360 } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 10e3cb: 8b 1d 88 30 12 00 mov 0x123088,%ebx ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( 10e3d1: 8a 55 e4 mov -0x1c(%ebp),%dl 10e3d4: eb 10 jmp 10e3e6 !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 ); 10e3d6: 52 push %edx 10e3d7: 52 push %edx 10e3d8: 57 push %edi 10e3d9: 8d 43 08 lea 0x8(%ebx),%eax 10e3dc: 50 push %eax 10e3dd: ff d6 call *%esi 10e3df: 88 c2 mov %al,%dl } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 10e3e1: 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 ) 10e3e3: 83 c4 10 add $0x10,%esp ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( 10e3e6: 81 fb 8c 30 12 00 cmp $0x12308c,%ebx 10e3ec: 74 04 je 10e3f2 node = rtems_chain_first( &filesystem_chain ); !rtems_chain_is_tail( &filesystem_chain, node ) && !stop; 10e3ee: 84 d2 test %dl,%dl 10e3f0: 74 e4 je 10e3d6 <== ALWAYS TAKEN ) { const filesystem_node *fsn = (filesystem_node *) node; stop = (*routine)( &fsn->entry, routine_arg ); } rtems_libio_unlock(); 10e3f2: 88 55 e4 mov %dl,-0x1c(%ebp) 10e3f5: e8 80 ff ff ff call 10e37a 10e3fa: 8a 55 e4 mov -0x1c(%ebp),%dl 10e3fd: 88 d0 mov %dl,%al } return stop; } 10e3ff: 8d 65 f4 lea -0xc(%ebp),%esp 10e402: 5b pop %ebx 10e403: 5e pop %esi 10e404: 5f pop %edi 10e405: c9 leave 10e406: c3 ret =============================================================================== 0010776d : bool rtems_filesystem_mount_iterate( rtems_per_filesystem_mount_routine routine, void *routine_arg ) { 10776d: 55 push %ebp 10776e: 89 e5 mov %esp,%ebp 107770: 57 push %edi 107771: 56 push %esi 107772: 53 push %ebx 107773: 83 ec 1c sub $0x1c,%esp 107776: 8b 7d 08 mov 0x8(%ebp),%edi 107779: 8b 75 0c mov 0xc(%ebp),%esi rtems_chain_node *node = NULL; bool stop = false; rtems_libio_lock(); 10777c: e8 bc ff ff ff call 10773d stop = (*routine)( mt_entry, routine_arg ); } rtems_libio_unlock(); return stop; } 107781: 8b 1d 44 2f 12 00 mov 0x122f44,%ebx rtems_per_filesystem_mount_routine routine, void *routine_arg ) { rtems_chain_node *node = NULL; bool stop = false; 107787: 31 c0 xor %eax,%eax rtems_libio_lock(); for ( 107789: eb 0b jmp 107796 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 ); 10778b: 50 push %eax 10778c: 50 push %eax 10778d: 56 push %esi 10778e: 53 push %ebx 10778f: ff d7 call *%edi } rtems_libio_unlock(); return stop; } 107791: 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 ) 107793: 83 c4 10 add $0x10,%esp { rtems_chain_node *node = NULL; bool stop = false; rtems_libio_lock(); for ( 107796: 81 fb 48 2f 12 00 cmp $0x122f48,%ebx 10779c: 74 04 je 1077a2 node = rtems_chain_first( &mount_chain ); !rtems_chain_is_tail( &mount_chain, node ) && !stop; 10779e: 84 c0 test %al,%al 1077a0: 74 e9 je 10778b <== 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(); 1077a2: 88 45 e4 mov %al,-0x1c(%ebp) 1077a5: e8 ad ff ff ff call 107757 return stop; } 1077aa: 8a 45 e4 mov -0x1c(%ebp),%al 1077ad: 8d 65 f4 lea -0xc(%ebp),%esp 1077b0: 5b pop %ebx 1077b1: 5e pop %esi 1077b2: 5f pop %edi 1077b3: c9 leave 1077b4: c3 ret =============================================================================== 001072f6 : int rtems_filesystem_prefix_separators( const char *pathname, int pathnamelen ) { 1072f6: 55 push %ebp 1072f7: 89 e5 mov %esp,%ebp 1072f9: 57 push %edi 1072fa: 56 push %esi 1072fb: 53 push %ebx 1072fc: 83 ec 0c sub $0xc,%esp 1072ff: 8b 7d 08 mov 0x8(%ebp),%edi 107302: 8b 75 0c mov 0xc(%ebp),%esi /* * Eat any separators at start of the path. */ int stripped = 0; 107305: 31 db xor %ebx,%ebx while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) ) 107307: eb 01 jmp 10730a { pathname++; pathnamelen--; stripped++; 107309: 43 inc %ebx { /* * Eat any separators at start of the path. */ int stripped = 0; while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) ) 10730a: 8a 04 1f mov (%edi,%ebx,1),%al 10730d: 39 de cmp %ebx,%esi 10730f: 74 17 je 107328 <== NEVER TAKEN 107311: 84 c0 test %al,%al 107313: 74 13 je 107328 <== NEVER TAKEN 107315: 83 ec 0c sub $0xc,%esp 107318: 0f be c0 movsbl %al,%eax 10731b: 50 push %eax 10731c: e8 df 0c 00 00 call 108000 107321: 83 c4 10 add $0x10,%esp 107324: 85 c0 test %eax,%eax 107326: 75 e1 jne 107309 pathname++; pathnamelen--; stripped++; } return stripped; } 107328: 89 d8 mov %ebx,%eax 10732a: 8d 65 f4 lea -0xc(%ebp),%esp 10732d: 5b pop %ebx 10732e: 5e pop %esi 10732f: 5f pop %edi 107330: c9 leave 107331: c3 ret =============================================================================== 00107bbd : int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *)) { 107bbd: 55 push %ebp 107bbe: 89 e5 mov %esp,%ebp 107bc0: 56 push %esi 107bc1: 53 push %ebx 107bc2: 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 ) ); 107bc5: 83 ec 0c sub $0xc,%esp 107bc8: 6a 08 push $0x8 107bca: e8 89 03 00 00 call 107f58 107bcf: 89 c3 mov %eax,%ebx *key = new_key; 107bd1: 8b 45 08 mov 0x8(%ebp),%eax 107bd4: 89 18 mov %ebx,(%eax) new_key->val = NULL; 107bd6: c7 03 00 00 00 00 movl $0x0,(%ebx) new_key->dtor = dtor; 107bdc: 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 ); 107bdf: 83 c4 0c add $0xc,%esp 107be2: 56 push %esi 107be3: 53 push %ebx 107be4: 6a 00 push $0x0 107be6: e8 1d 34 00 00 call 10b008 107beb: 89 c2 mov %eax,%edx if ( status == RTEMS_SUCCESSFUL ) 107bed: 83 c4 10 add $0x10,%esp return 0; 107bf0: 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 ) 107bf2: 85 d2 test %edx,%edx 107bf4: 74 0f je 107c05 <== ALWAYS TAKEN return 0; free( new_key ); 107bf6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107bf9: 53 push %ebx <== NOT EXECUTED 107bfa: e8 79 fe ff ff call 107a78 <== NOT EXECUTED return -1; 107bff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107c02: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED } 107c05: 8d 65 f8 lea -0x8(%ebp),%esp 107c08: 5b pop %ebx 107c09: 5e pop %esi 107c0a: c9 leave 107c0b: c3 ret =============================================================================== 00107c1c : int rtems_gxx_key_delete (__gthread_key_t key) { 107c1c: 55 push %ebp 107c1d: 89 e5 mov %esp,%ebp 107c1f: 53 push %ebx 107c20: 83 ec 0c sub $0xc,%esp 107c23: 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 ); 107c26: 53 push %ebx 107c27: 6a 00 push $0x0 107c29: e8 6e 34 00 00 call 10b09c if ( status == RTEMS_SUCCESSFUL ) { 107c2e: 83 c4 10 add $0x10,%esp 107c31: 85 c0 test %eax,%eax 107c33: 75 11 jne 107c46 <== NEVER TAKEN /* Hmm - hopefully all tasks using this key have gone away... */ if ( key ) free( *(void **)key ); 107c35: 85 db test %ebx,%ebx 107c37: 74 0d je 107c46 <== NEVER TAKEN 107c39: 83 ec 0c sub $0xc,%esp 107c3c: ff 33 pushl (%ebx) 107c3e: e8 35 fe ff ff call 107a78 107c43: 83 c4 10 add $0x10,%esp return 0; } key = NULL; return 0; } 107c46: 31 c0 xor %eax,%eax 107c48: 8b 5d fc mov -0x4(%ebp),%ebx 107c4b: c9 leave 107c4c: c3 ret =============================================================================== 00107b64 : /* 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)) { 107b64: 55 push %ebp 107b65: 89 e5 mov %esp,%ebp 107b67: 56 push %esi 107b68: 53 push %ebx 107b69: 83 ec 10 sub $0x10,%esp 107b6c: 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 ) { 107b6f: 8b 03 mov (%ebx),%eax 107b71: 85 c0 test %eax,%eax 107b73: 75 3f jne 107bb4 rtems_mode saveMode; __gthread_once_t o; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 107b75: 52 push %edx 107b76: 8d 45 f4 lea -0xc(%ebp),%eax 107b79: 50 push %eax 107b7a: 68 00 01 00 00 push $0x100 107b7f: 68 00 01 00 00 push $0x100 107b84: e8 ff 32 00 00 call 10ae88 if ( (o = *(volatile __gthread_once_t *)once) == 0 ) { 107b89: 8b 33 mov (%ebx),%esi 107b8b: 83 c4 10 add $0x10,%esp 107b8e: 85 f6 test %esi,%esi 107b90: 75 06 jne 107b98 <== NEVER TAKEN *(volatile __gthread_once_t *)once = 1; 107b92: c7 03 01 00 00 00 movl $0x1,(%ebx) } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 107b98: 50 push %eax 107b99: 8d 45 f4 lea -0xc(%ebp),%eax 107b9c: 50 push %eax 107b9d: 68 00 01 00 00 push $0x100 107ba2: ff 75 f4 pushl -0xc(%ebp) 107ba5: e8 de 32 00 00 call 10ae88 if ( o == 0 ) 107baa: 83 c4 10 add $0x10,%esp 107bad: 85 f6 test %esi,%esi 107baf: 75 03 jne 107bb4 <== NEVER TAKEN (*func)(); 107bb1: ff 55 0c call *0xc(%ebp) } return 0; } 107bb4: 31 c0 xor %eax,%eax 107bb6: 8d 65 f8 lea -0x8(%ebp),%esp 107bb9: 5b pop %ebx 107bba: 5e pop %esi 107bbb: c9 leave 107bbc: c3 ret =============================================================================== 00107ca5 : int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr) { 107ca5: 55 push %ebp 107ca6: 89 e5 mov %esp,%ebp 107ca8: 53 push %ebx 107ca9: 83 ec 08 sub $0x8,%esp 107cac: 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 ); 107caf: ff 73 04 pushl 0x4(%ebx) 107cb2: 53 push %ebx 107cb3: 6a 00 push $0x0 107cb5: e8 4e 33 00 00 call 10b008 107cba: 89 c2 mov %eax,%edx if ( status == RTEMS_SUCCESSFUL ) { 107cbc: 83 c4 10 add $0x10,%esp /* now let's set the proper value */ key->val = (void *)ptr; return 0; } return -1; 107cbf: 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 ) { 107cc2: 85 d2 test %edx,%edx 107cc4: 75 07 jne 107ccd <== NEVER TAKEN /* now let's set the proper value */ key->val = (void *)ptr; 107cc6: 8b 45 0c mov 0xc(%ebp),%eax 107cc9: 89 03 mov %eax,(%ebx) return 0; 107ccb: 31 c0 xor %eax,%eax } return -1; } 107ccd: 8b 5d fc mov -0x4(%ebp),%ebx 107cd0: c9 leave 107cd1: c3 ret =============================================================================== 0010a930 : void *rtems_heap_allocate_aligned_with_boundary( size_t size, uintptr_t alignment, uintptr_t boundary ) { 10a930: 55 push %ebp 10a931: 89 e5 mov %esp,%ebp 10a933: 83 ec 08 sub $0x8,%esp if ( 10a936: 83 3d 08 c6 12 00 03 cmpl $0x3,0x12c608 10a93d: 75 0d jne 10a94c <== NEVER TAKEN _System_state_Is_up( _System_state_Get() ) && !malloc_is_system_state_OK() 10a93f: e8 34 f1 ff ff call 109a78 10a944: 88 c2 mov %al,%dl ) { return NULL; 10a946: 31 c0 xor %eax,%eax uintptr_t boundary ) { if ( _System_state_Is_up( _System_state_Get() ) && !malloc_is_system_state_OK() 10a948: 84 d2 test %dl,%dl 10a94a: 74 1c je 10a968 ) { return NULL; } malloc_deferred_frees_process(); 10a94c: e8 65 f1 ff ff call 109ab6 /* FIXME: Statistics, boundary checks */ return _Protected_heap_Allocate_aligned_with_boundary( 10a951: ff 75 10 pushl 0x10(%ebp) 10a954: ff 75 0c pushl 0xc(%ebp) 10a957: ff 75 08 pushl 0x8(%ebp) 10a95a: ff 35 b0 79 12 00 pushl 0x1279b0 10a960: e8 eb 43 00 00 call 10ed50 <_Protected_heap_Allocate_aligned_with_boundary> 10a965: 83 c4 10 add $0x10,%esp RTEMS_Malloc_Heap, size, alignment, boundary ); } 10a968: c9 leave 10a969: c3 ret =============================================================================== 00107022 : rtems_status_code rtems_io_lookup_name( const char *name, rtems_driver_name_t *device_info ) { 107022: 55 push %ebp 107023: 89 e5 mov %esp,%ebp 107025: 57 push %edi 107026: 56 push %esi 107027: 53 push %ebx 107028: 83 ec 48 sub $0x48,%esp 10702b: 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( 10702e: 31 c0 xor %eax,%eax 107030: 83 c9 ff or $0xffffffff,%ecx 107033: 89 f7 mov %esi,%edi 107035: f2 ae repnz scas %es:(%edi),%al 107037: f7 d1 not %ecx 107039: 49 dec %ecx 10703a: 6a 01 push $0x1 10703c: 8d 55 d4 lea -0x2c(%ebp),%edx 10703f: 52 push %edx 107040: 6a 00 push $0x0 107042: 51 push %ecx 107043: 56 push %esi 107044: 89 55 c4 mov %edx,-0x3c(%ebp) 107047: e8 2a 02 00 00 call 107276 10704c: 89 c7 mov %eax,%edi name, strlen( name ), 0x00, &loc, true ); the_jnode = loc.node_access; 10704e: 8b 5d d4 mov -0x2c(%ebp),%ebx node_type = (*loc.ops->node_type_h)( &loc ); 107051: 83 c4 14 add $0x14,%esp 107054: 8b 55 c4 mov -0x3c(%ebp),%edx 107057: 52 push %edx 107058: 8b 45 e0 mov -0x20(%ebp),%eax 10705b: ff 50 10 call *0x10(%eax) if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) { 10705e: 83 c4 10 add $0x10,%esp 107061: 83 f8 02 cmp $0x2,%eax 107064: 8b 55 c4 mov -0x3c(%ebp),%edx 107067: 75 07 jne 107070 107069: 85 ff test %edi,%edi 10706b: 0f 95 c0 setne %al 10706e: 74 16 je 107086 <== ALWAYS TAKEN rtems_filesystem_freenode( &loc ); 107070: 83 ec 0c sub $0xc,%esp 107073: 8d 45 d4 lea -0x2c(%ebp),%eax 107076: 50 push %eax 107077: e8 b8 02 00 00 call 107334 return RTEMS_UNSATISFIED; 10707c: 83 c4 10 add $0x10,%esp 10707f: b8 0d 00 00 00 mov $0xd,%eax 107084: eb 32 jmp 1070b8 } device_info->device_name = (char *) name; 107086: 8b 4d 0c mov 0xc(%ebp),%ecx 107089: 89 31 mov %esi,(%ecx) device_info->device_name_length = strlen( name ); 10708b: 83 c9 ff or $0xffffffff,%ecx 10708e: 89 f7 mov %esi,%edi 107090: f2 ae repnz scas %es:(%edi),%al 107092: f7 d1 not %ecx 107094: 49 dec %ecx 107095: 8b 45 0c mov 0xc(%ebp),%eax 107098: 89 48 04 mov %ecx,0x4(%eax) device_info->major = the_jnode->info.device.major; 10709b: 8b 43 50 mov 0x50(%ebx),%eax 10709e: 8b 4d 0c mov 0xc(%ebp),%ecx 1070a1: 89 41 08 mov %eax,0x8(%ecx) device_info->minor = the_jnode->info.device.minor; 1070a4: 8b 43 54 mov 0x54(%ebx),%eax 1070a7: 89 41 0c mov %eax,0xc(%ecx) rtems_filesystem_freenode( &loc ); 1070aa: 83 ec 0c sub $0xc,%esp 1070ad: 52 push %edx 1070ae: e8 81 02 00 00 call 107334 return RTEMS_SUCCESSFUL; 1070b3: 83 c4 10 add $0x10,%esp 1070b6: 31 c0 xor %eax,%eax } 1070b8: 8d 65 f4 lea -0xc(%ebp),%esp 1070bb: 5b pop %ebx 1070bc: 5e pop %esi 1070bd: 5f pop %edi 1070be: c9 leave 1070bf: c3 ret =============================================================================== 0010b71c : rtems_status_code rtems_io_register_driver( rtems_device_major_number major, const rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 10b71c: 55 push %ebp 10b71d: 89 e5 mov %esp,%ebp 10b71f: 57 push %edi 10b720: 56 push %esi 10b721: 53 push %ebx 10b722: 83 ec 0c sub $0xc,%esp 10b725: 8b 5d 08 mov 0x8(%ebp),%ebx 10b728: 8b 75 0c mov 0xc(%ebp),%esi 10b72b: 8b 45 10 mov 0x10(%ebp),%eax rtems_device_major_number major_limit = _IO_Number_of_drivers; 10b72e: 8b 15 78 8d 12 00 mov 0x128d78,%edx if ( rtems_interrupt_is_in_progress() ) 10b734: 83 3d 1c 89 12 00 00 cmpl $0x0,0x12891c 10b73b: 0f 85 cc 00 00 00 jne 10b80d <== NEVER TAKEN return RTEMS_CALLED_FROM_ISR; if ( registered_major == NULL ) 10b741: 85 c0 test %eax,%eax 10b743: 0f 84 cb 00 00 00 je 10b814 return RTEMS_INVALID_ADDRESS; /* Set it to an invalid value */ *registered_major = major_limit; 10b749: 89 10 mov %edx,(%eax) if ( driver_table == NULL ) 10b74b: 85 f6 test %esi,%esi 10b74d: 0f 84 c1 00 00 00 je 10b814 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10b753: 83 3e 00 cmpl $0x0,(%esi) 10b756: 0f 85 cc 00 00 00 jne 10b828 10b75c: 83 7e 04 00 cmpl $0x0,0x4(%esi) 10b760: 0f 85 c2 00 00 00 jne 10b828 10b766: e9 a9 00 00 00 jmp 10b814 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b76b: 8b 15 d8 83 12 00 mov 0x1283d8,%edx 10b771: 42 inc %edx 10b772: 89 15 d8 83 12 00 mov %edx,0x1283d8 if ( major >= major_limit ) return RTEMS_INVALID_NUMBER; _Thread_Disable_dispatch(); if ( major == 0 ) { 10b778: 85 db test %ebx,%ebx 10b77a: 75 32 jne 10b7ae static rtems_status_code rtems_io_obtain_major_number( rtems_device_major_number *major ) { rtems_device_major_number n = _IO_Number_of_drivers; 10b77c: 8b 0d 78 8d 12 00 mov 0x128d78,%ecx 10b782: 8b 15 7c 8d 12 00 mov 0x128d7c,%edx 10b788: eb 15 jmp 10b79f static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10b78a: 83 3a 00 cmpl $0x0,(%edx) 10b78d: 0f 85 9f 00 00 00 jne 10b832 10b793: 83 7a 04 00 cmpl $0x0,0x4(%edx) 10b797: 0f 85 95 00 00 00 jne 10b832 10b79d: eb 04 jmp 10b7a3 rtems_device_major_number n = _IO_Number_of_drivers; rtems_device_major_number m = 0; /* major is error checked by caller */ for ( m = 0; m < n; ++m ) { 10b79f: 39 cb cmp %ecx,%ebx 10b7a1: 72 e7 jb 10b78a if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 10b7a3: 89 18 mov %ebx,(%eax) if ( m != n ) 10b7a5: 39 cb cmp %ecx,%ebx 10b7a7: 75 30 jne 10b7d9 10b7a9: e9 8d 00 00 00 jmp 10b83b _Thread_Enable_dispatch(); return sc; } major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; 10b7ae: 6b d3 18 imul $0x18,%ebx,%edx 10b7b1: 03 15 7c 8d 12 00 add 0x128d7c,%edx static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10b7b7: 31 c9 xor %ecx,%ecx 10b7b9: 83 3a 00 cmpl $0x0,(%edx) 10b7bc: 75 09 jne 10b7c7 10b7be: 31 c9 xor %ecx,%ecx 10b7c0: 83 7a 04 00 cmpl $0x0,0x4(%edx) 10b7c4: 0f 94 c1 sete %cl } major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; if ( !rtems_io_is_empty_table( table ) ) { 10b7c7: 85 c9 test %ecx,%ecx 10b7c9: 75 0c jne 10b7d7 _Thread_Enable_dispatch(); 10b7cb: e8 22 1a 00 00 call 10d1f2 <_Thread_Enable_dispatch> return RTEMS_RESOURCE_IN_USE; 10b7d0: b8 0c 00 00 00 mov $0xc,%eax 10b7d5: eb 49 jmp 10b820 } *registered_major = major; 10b7d7: 89 18 mov %ebx,(%eax) } _IO_Driver_address_table [major] = *driver_table; 10b7d9: 6b c3 18 imul $0x18,%ebx,%eax 10b7dc: 03 05 7c 8d 12 00 add 0x128d7c,%eax 10b7e2: b9 06 00 00 00 mov $0x6,%ecx 10b7e7: 89 c7 mov %eax,%edi 10b7e9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Thread_Enable_dispatch(); 10b7eb: e8 02 1a 00 00 call 10d1f2 <_Thread_Enable_dispatch> return rtems_io_initialize( major, 0, NULL ); 10b7f0: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) 10b7f7: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) 10b7fe: 89 5d 08 mov %ebx,0x8(%ebp) } 10b801: 83 c4 0c add $0xc,%esp 10b804: 5b pop %ebx 10b805: 5e pop %esi 10b806: 5f pop %edi 10b807: c9 leave _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); 10b808: e9 63 71 00 00 jmp 112970 ) { rtems_device_major_number major_limit = _IO_Number_of_drivers; if ( rtems_interrupt_is_in_progress() ) return RTEMS_CALLED_FROM_ISR; 10b80d: b8 12 00 00 00 mov $0x12,%eax 10b812: eb 0c jmp 10b820 if ( driver_table == NULL ) return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; 10b814: b8 09 00 00 00 mov $0x9,%eax 10b819: eb 05 jmp 10b820 if ( major >= major_limit ) return RTEMS_INVALID_NUMBER; 10b81b: b8 0a 00 00 00 mov $0xa,%eax _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); } 10b820: 83 c4 0c add $0xc,%esp 10b823: 5b pop %ebx 10b824: 5e pop %esi 10b825: 5f pop %edi 10b826: c9 leave 10b827: c3 ret return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; if ( major >= major_limit ) 10b828: 39 d3 cmp %edx,%ebx 10b82a: 0f 82 3b ff ff ff jb 10b76b 10b830: eb e9 jmp 10b81b rtems_device_major_number n = _IO_Number_of_drivers; rtems_device_major_number m = 0; /* major is error checked by caller */ for ( m = 0; m < n; ++m ) { 10b832: 43 inc %ebx 10b833: 83 c2 18 add $0x18,%edx 10b836: e9 64 ff ff ff jmp 10b79f if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); 10b83b: e8 b2 19 00 00 call 10d1f2 <_Thread_Enable_dispatch> *major = m; if ( m != n ) return RTEMS_SUCCESSFUL; return RTEMS_TOO_MANY; 10b840: b8 05 00 00 00 mov $0x5,%eax if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); return sc; 10b845: eb d9 jmp 10b820 =============================================================================== 0010c744 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10c744: 55 push %ebp 10c745: 89 e5 mov %esp,%ebp 10c747: 57 push %edi 10c748: 56 push %esi 10c749: 53 push %ebx 10c74a: 83 ec 0c sub $0xc,%esp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10c74d: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 10c751: 74 3d je 10c790 <== NEVER TAKEN 10c753: 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 ]; 10c758: 8b 04 9d fc 00 13 00 mov 0x1300fc(,%ebx,4),%eax 10c75f: 8b 78 04 mov 0x4(%eax),%edi if ( !information ) 10c762: be 01 00 00 00 mov $0x1,%esi 10c767: 85 ff test %edi,%edi 10c769: 75 17 jne 10c782 10c76b: eb 1d jmp 10c78a continue; for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 10c76d: 8b 47 1c mov 0x1c(%edi),%eax 10c770: 8b 04 b0 mov (%eax,%esi,4),%eax if ( !the_thread ) 10c773: 85 c0 test %eax,%eax 10c775: 74 0a je 10c781 <== NEVER TAKEN continue; (*routine)(the_thread); 10c777: 83 ec 0c sub $0xc,%esp 10c77a: 50 push %eax 10c77b: ff 55 08 call *0x8(%ebp) 10c77e: 83 c4 10 add $0x10,%esp information = _Objects_Information_table[ api_index ][ 1 ]; if ( !information ) continue; for ( i=1 ; i <= information->maximum ; i++ ) { 10c781: 46 inc %esi 10c782: 0f b7 47 10 movzwl 0x10(%edi),%eax 10c786: 39 c6 cmp %eax,%esi 10c788: 76 e3 jbe 10c76d Objects_Information *information; if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10c78a: 43 inc %ebx 10c78b: 83 fb 04 cmp $0x4,%ebx 10c78e: 75 c8 jne 10c758 (*routine)(the_thread); } } } 10c790: 8d 65 f4 lea -0xc(%ebp),%esp 10c793: 5b pop %ebx 10c794: 5e pop %esi 10c795: 5f pop %edi 10c796: c9 leave 10c797: c3 ret =============================================================================== 0010e264 : */ void rtems_libio_free( rtems_libio_t *iop ) { 10e264: 55 push %ebp 10e265: 89 e5 mov %esp,%ebp 10e267: 53 push %ebx 10e268: 83 ec 04 sub $0x4,%esp 10e26b: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_libio_lock(); 10e26e: e8 d5 fe ff ff call 10e148 if (iop->sem) 10e273: 8b 43 2c mov 0x2c(%ebx),%eax 10e276: 85 c0 test %eax,%eax 10e278: 74 0c je 10e286 <== NEVER TAKEN rtems_semaphore_delete(iop->sem); 10e27a: 83 ec 0c sub $0xc,%esp 10e27d: 50 push %eax 10e27e: e8 55 be ff ff call 10a0d8 10e283: 83 c4 10 add $0x10,%esp iop->flags &= ~LIBIO_FLAGS_OPEN; 10e286: 81 63 14 ff fe ff ff andl $0xfffffeff,0x14(%ebx) iop->data1 = rtems_libio_iop_freelist; 10e28d: a1 dc 51 12 00 mov 0x1251dc,%eax 10e292: 89 43 34 mov %eax,0x34(%ebx) rtems_libio_iop_freelist = iop; 10e295: 89 1d dc 51 12 00 mov %ebx,0x1251dc rtems_libio_unlock(); } 10e29b: 8b 5d fc mov -0x4(%ebp),%ebx 10e29e: c9 leave iop->flags &= ~LIBIO_FLAGS_OPEN; iop->data1 = rtems_libio_iop_freelist; rtems_libio_iop_freelist = iop; rtems_libio_unlock(); 10e29f: e9 be fe ff ff jmp 10e162 =============================================================================== 00107434 : * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) { 107434: 55 push %ebp 107435: 89 e5 mov %esp,%ebp 107437: 53 push %ebx 107438: 83 ec 04 sub $0x4,%esp rtems_status_code rc; uint32_t i; rtems_libio_t *iop; if (rtems_libio_number_iops > 0) 10743b: 8b 1d 44 11 12 00 mov 0x121144,%ebx 107441: 85 db test %ebx,%ebx 107443: 74 3e je 107483 <== NEVER TAKEN { rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, 107445: 50 push %eax 107446: 50 push %eax 107447: 6a 38 push $0x38 107449: 53 push %ebx 10744a: e8 8d fd ff ff call 1071dc 10744f: a3 d8 51 12 00 mov %eax,0x1251d8 sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) 107454: 83 c4 10 add $0x10,%esp 107457: 85 c0 test %eax,%eax 107459: 75 07 jne 107462 rtems_fatal_error_occurred(RTEMS_NO_MEMORY); 10745b: 83 ec 0c sub $0xc,%esp 10745e: 6a 1a push $0x1a 107460: eb 44 jmp 1074a6 iop = rtems_libio_iop_freelist = rtems_libio_iops; 107462: a3 dc 51 12 00 mov %eax,0x1251dc 107467: 89 c2 mov %eax,%edx for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++) 107469: 31 c9 xor %ecx,%ecx 10746b: eb 03 jmp 107470 iop->data1 = iop + 1; 10746d: 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++) 107470: 41 inc %ecx 107471: 83 c2 38 add $0x38,%edx 107474: 39 d9 cmp %ebx,%ecx 107476: 72 f5 jb 10746d iop->data1 = iop + 1; iop->data1 = NULL; 107478: 6b db 38 imul $0x38,%ebx,%ebx 10747b: c7 44 18 fc 00 00 00 movl $0x0,-0x4(%eax,%ebx,1) 107482: 00 /* * Create the binary semaphore used to provide mutual exclusion * on the IOP Table. */ rc = rtems_semaphore_create( 107483: 83 ec 0c sub $0xc,%esp 107486: 68 e0 51 12 00 push $0x1251e0 10748b: 6a 00 push $0x0 10748d: 6a 54 push $0x54 10748f: 6a 01 push $0x1 107491: 68 4f 49 42 4c push $0x4c42494f 107496: e8 a5 2a 00 00 call 109f40 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_libio_semaphore ); if ( rc != RTEMS_SUCCESSFUL ) 10749b: 83 c4 20 add $0x20,%esp 10749e: 85 c0 test %eax,%eax 1074a0: 74 09 je 1074ab <== ALWAYS TAKEN rtems_fatal_error_occurred( rc ); 1074a2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1074a5: 50 push %eax <== NOT EXECUTED 1074a6: e8 91 32 00 00 call 10a73c /* * Initialize the base file system infrastructure. */ if (rtems_fs_init_helper) 1074ab: a1 40 11 12 00 mov 0x121140,%eax 1074b0: 85 c0 test %eax,%eax 1074b2: 74 06 je 1074ba <== NEVER TAKEN (* rtems_fs_init_helper)(); } 1074b4: 8b 5d fc mov -0x4(%ebp),%ebx 1074b7: c9 leave /* * Initialize the base file system infrastructure. */ if (rtems_fs_init_helper) (* rtems_fs_init_helper)(); 1074b8: ff e0 jmp *%eax } 1074ba: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1074bd: c9 leave <== NOT EXECUTED 1074be: c3 ret <== NOT EXECUTED =============================================================================== 001085fd : rtems_status_code rtems_libio_set_private_env(void) { 1085fd: 55 push %ebp 1085fe: 89 e5 mov %esp,%ebp 108600: 57 push %edi 108601: 56 push %esi 108602: 53 push %ebx 108603: 83 ec 3c sub $0x3c,%esp rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_id task_id = rtems_task_self(); 108606: e8 4d 27 00 00 call 10ad58 10860b: 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); 10860d: 83 ec 0c sub $0xc,%esp 108610: 6a 00 push $0x0 108612: 8d 45 d4 lea -0x2c(%ebp),%eax 108615: 50 push %eax 108616: 6a 00 push $0x0 108618: 6a 01 push $0x1 10861a: 68 c4 f7 11 00 push $0x11f7c4 10861f: e8 66 f0 ff ff call 10768a 108624: 89 c2 mov %eax,%edx if (rv != 0) 108626: 83 c4 20 add $0x20,%esp error_1: rtems_filesystem_freenode(&root_loc); error_0: return RTEMS_NO_MEMORY; 108629: 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) 10862e: 85 d2 test %edx,%edx 108630: 0f 85 c0 00 00 00 jne 1086f6 <== NEVER TAKEN goto error_0; rv = rtems_filesystem_evaluate_path("/", 1, 0, ¤t_loc, 0); 108636: 83 ec 0c sub $0xc,%esp 108639: 6a 00 push $0x0 10863b: 8d 45 c0 lea -0x40(%ebp),%eax 10863e: 50 push %eax 10863f: 6a 00 push $0x0 108641: 6a 01 push $0x1 108643: 68 c4 f7 11 00 push $0x11f7c4 108648: e8 3d f0 ff ff call 10768a if (rv != 0) 10864d: 83 c4 20 add $0x20,%esp 108650: 85 c0 test %eax,%eax 108652: 0f 85 8a 00 00 00 jne 1086e2 <== 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 108658: a1 3c 30 12 00 mov 0x12303c,%eax /* * Bharath: I'm not sure if the check can be reduced to * if( rtems_current_user_env->task_id != task_id ) { */ if ( 10865d: 3d 08 52 12 00 cmp $0x125208,%eax 108662: 74 04 je 108668 rtems_current_user_env == &rtems_global_user_env || rtems_current_user_env->task_id != task_id 108664: 39 18 cmp %ebx,(%eax) 108666: 74 32 je 10869a ) { new_env = malloc(sizeof(rtems_user_env_t)); 108668: 83 ec 0c sub $0xc,%esp 10866b: 6a 48 push $0x48 10866d: e8 8a f5 ff ff call 107bfc 108672: 89 c6 mov %eax,%esi if (new_env == NULL) 108674: 83 c4 10 add $0x10,%esp 108677: 85 c0 test %eax,%eax 108679: 74 58 je 1086d3 #ifdef HAVE_USERENV_REFCNT new_env->refcnt = 1; #endif sc = rtems_task_variable_add( 10867b: 50 push %eax 10867c: 68 c0 85 10 00 push $0x1085c0 108681: 68 3c 30 12 00 push $0x12303c 108686: 6a 00 push $0x0 108688: e8 3f 27 00 00 call 10adcc RTEMS_SELF, (void*)&rtems_current_user_env, (void(*)(void *))free_user_env ); if (sc != RTEMS_SUCCESSFUL) 10868d: 83 c4 10 add $0x10,%esp 108690: 85 c0 test %eax,%eax 108692: 75 33 jne 1086c7 goto error_3; rtems_current_user_env = new_env; 108694: 89 35 3c 30 12 00 mov %esi,0x12303c } /* Inherit the global values */ *rtems_current_user_env = rtems_global_user_env; 10869a: a1 3c 30 12 00 mov 0x12303c,%eax 10869f: be 08 52 12 00 mov $0x125208,%esi 1086a4: b9 12 00 00 00 mov $0x12,%ecx 1086a9: 89 c7 mov %eax,%edi 1086ab: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_current_user_env->task_id = task_id; 1086ad: 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; 1086af: 8d 78 18 lea 0x18(%eax),%edi 1086b2: 8d 75 d4 lea -0x2c(%ebp),%esi 1086b5: b1 05 mov $0x5,%cl 1086b7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_filesystem_current = current_loc; 1086b9: 8d 78 04 lea 0x4(%eax),%edi 1086bc: 8d 75 c0 lea -0x40(%ebp),%esi 1086bf: b1 05 mov $0x5,%cl 1086c1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return RTEMS_SUCCESSFUL; 1086c3: 31 c0 xor %eax,%eax 1086c5: eb 2f jmp 1086f6 error_3: free(new_env); 1086c7: 83 ec 0c sub $0xc,%esp 1086ca: 56 push %esi 1086cb: e8 8c f0 ff ff call 10775c 1086d0: 83 c4 10 add $0x10,%esp error_2: rtems_filesystem_freenode(¤t_loc); 1086d3: 83 ec 0c sub $0xc,%esp 1086d6: 8d 45 c0 lea -0x40(%ebp),%eax 1086d9: 50 push %eax 1086da: e8 69 f0 ff ff call 107748 1086df: 83 c4 10 add $0x10,%esp error_1: rtems_filesystem_freenode(&root_loc); 1086e2: 83 ec 0c sub $0xc,%esp 1086e5: 8d 45 d4 lea -0x2c(%ebp),%eax 1086e8: 50 push %eax 1086e9: e8 5a f0 ff ff call 107748 1086ee: 83 c4 10 add $0x10,%esp error_0: return RTEMS_NO_MEMORY; 1086f1: b8 1a 00 00 00 mov $0x1a,%eax } 1086f6: 8d 65 f4 lea -0xc(%ebp),%esp 1086f9: 5b pop %ebx 1086fa: 5e pop %esi 1086fb: 5f pop %edi 1086fc: c9 leave 1086fd: c3 ret =============================================================================== 001086fe : * 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) { 1086fe: 55 push %ebp 1086ff: 89 e5 mov %esp,%ebp 108701: 56 push %esi 108702: 53 push %ebx 108703: 83 ec 20 sub $0x20,%esp 108706: 8b 75 08 mov 0x8(%ebp),%esi rtems_id current_task_id; /* * get current task id */ current_task_id = rtems_task_self(); 108709: e8 4a 26 00 00 call 10ad58 10870e: 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; 108710: 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 ) 108712: 39 de cmp %ebx,%esi 108714: 74 3c je 108752 <== NEVER TAKEN return RTEMS_SUCCESSFUL; /* * Try to get the requested user environment */ sc = rtems_task_variable_get( 108716: 52 push %edx task_id, (void*)&rtems_current_user_env, (void*)&shared_user_env ); 108717: 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( 10871a: 50 push %eax 10871b: 68 3c 30 12 00 push $0x12303c 108720: 56 push %esi 108721: e8 3a 27 00 00 call 10ae60 (void*)&shared_user_env ); /* * If it was not successful, return the error code */ if (sc != RTEMS_SUCCESSFUL) 108726: 83 c4 10 add $0x10,%esp 108729: 85 c0 test %eax,%eax 10872b: 75 25 jne 108752 * 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) { 10872d: 8b 15 3c 30 12 00 mov 0x12303c,%edx 108733: 39 1a cmp %ebx,(%edx) 108735: 75 12 jne 108749 rtems_user_env_t *tmp = rtems_current_user_env; free_user_env( tmp ); 108737: 83 ec 0c sub $0xc,%esp 10873a: 52 push %edx 10873b: 89 45 e4 mov %eax,-0x1c(%ebp) 10873e: e8 7d fe ff ff call 1085c0 108743: 83 c4 10 add $0x10,%esp 108746: 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; 108749: 8b 55 f4 mov -0xc(%ebp),%edx 10874c: 89 15 3c 30 12 00 mov %edx,0x12303c #ifdef HAVE_USERENV_REFCNT rtems_current_user_env->refcnt++; #endif return RTEMS_SUCCESSFUL; } 108752: 8d 65 f8 lea -0x8(%ebp),%esp 108755: 5b pop %ebx 108756: 5e pop %esi 108757: c9 leave 108758: c3 ret =============================================================================== 0010e1ad : */ uint32_t rtems_libio_to_fcntl_flags( uint32_t flags ) { 10e1ad: 55 push %ebp 10e1ae: 89 e5 mov %esp,%ebp 10e1b0: 8b 55 08 mov 0x8(%ebp),%edx uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10e1b3: 89 d1 mov %edx,%ecx 10e1b5: 83 e1 06 and $0x6,%ecx fcntl_flags |= O_RDWR; 10e1b8: 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 ) { 10e1bd: 83 f9 06 cmp $0x6,%ecx 10e1c0: 74 0f je 10e1d1 fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { fcntl_flags |= O_RDONLY; 10e1c2: 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) { 10e1c4: f6 c2 02 test $0x2,%dl 10e1c7: 75 08 jne 10e1d1 <== ALWAYS TAKEN ) { uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { fcntl_flags |= O_RDWR; 10e1c9: 31 c0 xor %eax,%eax 10e1cb: f6 c2 04 test $0x4,%dl <== NOT EXECUTED 10e1ce: 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 ) { 10e1d1: f6 c2 01 test $0x1,%dl 10e1d4: 74 03 je 10e1d9 fcntl_flags |= O_NONBLOCK; 10e1d6: 80 cc 40 or $0x40,%ah } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 10e1d9: f6 c6 02 test $0x2,%dh 10e1dc: 74 03 je 10e1e1 fcntl_flags |= O_APPEND; 10e1de: 83 c8 08 or $0x8,%eax } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 10e1e1: 80 e6 04 and $0x4,%dh 10e1e4: 74 03 je 10e1e9 fcntl_flags |= O_CREAT; 10e1e6: 80 cc 02 or $0x2,%ah } return fcntl_flags; } 10e1e9: c9 leave 10e1ea: c3 ret =============================================================================== 00109d7c : * size and thus we skip updating the statistics. */ static void rtems_malloc_statistics_at_free( void *pointer ) { 109d7c: 55 push %ebp 109d7d: 89 e5 mov %esp,%ebp 109d7f: 83 ec 1c sub $0x1c,%esp uintptr_t size; if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) { 109d82: 8d 45 f4 lea -0xc(%ebp),%eax 109d85: 50 push %eax 109d86: ff 75 08 pushl 0x8(%ebp) 109d89: ff 35 b0 79 12 00 pushl 0x1279b0 109d8f: e8 64 50 00 00 call 10edf8 <_Protected_heap_Get_block_size> 109d94: 83 c4 10 add $0x10,%esp 109d97: 84 c0 test %al,%al 109d99: 74 11 je 109dac <== NEVER TAKEN MSBUMP(lifetime_freed, size); 109d9b: 8b 45 f4 mov -0xc(%ebp),%eax 109d9e: 31 d2 xor %edx,%edx 109da0: 01 05 80 c3 12 00 add %eax,0x12c380 109da6: 11 15 84 c3 12 00 adc %edx,0x12c384 } } 109dac: c9 leave 109dad: c3 ret =============================================================================== 00109dae : } static void rtems_malloc_statistics_at_malloc( void *pointer ) { 109dae: 55 push %ebp 109daf: 89 e5 mov %esp,%ebp 109db1: 83 ec 18 sub $0x18,%esp 109db4: 8b 45 08 mov 0x8(%ebp),%eax uintptr_t actual_size = 0; 109db7: 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 ) 109dbe: 85 c0 test %eax,%eax 109dc0: 74 43 je 109e05 <== NEVER TAKEN return; _Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size); 109dc2: 52 push %edx 109dc3: 8d 55 f4 lea -0xc(%ebp),%edx 109dc6: 52 push %edx 109dc7: 50 push %eax 109dc8: ff 35 b0 79 12 00 pushl 0x1279b0 109dce: e8 25 50 00 00 call 10edf8 <_Protected_heap_Get_block_size> MSBUMP(lifetime_allocated, actual_size); 109dd3: 8b 45 f4 mov -0xc(%ebp),%eax 109dd6: 31 d2 xor %edx,%edx 109dd8: 03 05 78 c3 12 00 add 0x12c378,%eax 109dde: 13 15 7c c3 12 00 adc 0x12c37c,%edx 109de4: a3 78 c3 12 00 mov %eax,0x12c378 109de9: 89 15 7c c3 12 00 mov %edx,0x12c37c current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed); 109def: 2b 05 80 c3 12 00 sub 0x12c380,%eax if (current_depth > s->max_depth) 109df5: 83 c4 10 add $0x10,%esp 109df8: 3b 05 74 c3 12 00 cmp 0x12c374,%eax 109dfe: 76 05 jbe 109e05 s->max_depth = current_depth; 109e00: a3 74 c3 12 00 mov %eax,0x12c374 } 109e05: c9 leave 109e06: c3 ret =============================================================================== 00111a0c : int rtems_memalign( void **pointer, size_t alignment, size_t size ) { 111a0c: 55 push %ebp 111a0d: 89 e5 mov %esp,%ebp 111a0f: 57 push %edi 111a10: 56 push %esi 111a11: 53 push %ebx 111a12: 83 ec 0c sub $0xc,%esp 111a15: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Parameter error checks */ if ( !pointer ) return EINVAL; 111a18: be 16 00 00 00 mov $0x16,%esi void *return_this; /* * Parameter error checks */ if ( !pointer ) 111a1d: 85 db test %ebx,%ebx 111a1f: 74 55 je 111a76 return EINVAL; *pointer = NULL; 111a21: 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()) && 111a27: 83 3d 54 85 12 00 03 cmpl $0x3,0x128554 111a2e: 75 09 jne 111a39 <== NEVER TAKEN !malloc_is_system_state_OK() ) 111a30: e8 c7 67 ff ff call 1081fc *pointer = NULL; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 111a35: 84 c0 test %al,%al 111a37: 74 3d je 111a76 <== NEVER TAKEN return EINVAL; /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 111a39: e8 fc 67 ff ff call 10823a Heap_Control *heap, uintptr_t size, uintptr_t alignment ) { return 111a3e: 6a 00 push $0x0 111a40: ff 75 0c pushl 0xc(%ebp) 111a43: ff 75 10 pushl 0x10(%ebp) 111a46: ff 35 50 41 12 00 pushl 0x124150 111a4c: e8 cb af ff ff call 10ca1c <_Protected_heap_Allocate_aligned_with_boundary> 111a51: 89 c7 mov %eax,%edi return_this = _Protected_heap_Allocate_aligned( RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 111a53: 83 c4 10 add $0x10,%esp return ENOMEM; 111a56: be 0c 00 00 00 mov $0xc,%esi return_this = _Protected_heap_Allocate_aligned( RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 111a5b: 85 c0 test %eax,%eax 111a5d: 74 17 je 111a76 return ENOMEM; /* * If configured, update the more involved statistics */ if ( rtems_malloc_statistics_helpers ) 111a5f: a1 70 66 12 00 mov 0x126670,%eax 111a64: 85 c0 test %eax,%eax 111a66: 74 0a je 111a72 (*rtems_malloc_statistics_helpers->at_malloc)(pointer); 111a68: 83 ec 0c sub $0xc,%esp 111a6b: 53 push %ebx 111a6c: ff 50 04 call *0x4(%eax) 111a6f: 83 c4 10 add $0x10,%esp *pointer = return_this; 111a72: 89 3b mov %edi,(%ebx) return 0; 111a74: 31 f6 xor %esi,%esi } 111a76: 89 f0 mov %esi,%eax 111a78: 8d 65 f4 lea -0xc(%ebp),%esp 111a7b: 5b pop %ebx 111a7c: 5e pop %esi 111a7d: 5f pop %edi 111a7e: c9 leave 111a7f: c3 ret =============================================================================== 0011033c : return (retval); } int rtems_mkdir(const char *path, mode_t mode) { 11033c: 55 push %ebp 11033d: 89 e5 mov %esp,%ebp 11033f: 57 push %edi 110340: 56 push %esi 110341: 53 push %ebx 110342: 83 ec 78 sub $0x78,%esp int success = 0; char *dup_path = strdup(path); 110345: ff 75 08 pushl 0x8(%ebp) 110348: e8 47 33 00 00 call 113694 11034d: 89 c3 mov %eax,%ebx if (dup_path != NULL) { 11034f: 83 c4 10 add $0x10,%esp success = build(dup_path, mode); free(dup_path); } return success != 0 ? 0 : -1; 110352: 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) { 110355: 85 db test %ebx,%ebx 110357: 0f 84 1e 01 00 00 je 11047b <== NEVER TAKEN p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; 11035d: 31 c0 xor %eax,%eax 11035f: 80 3b 2f cmpb $0x2f,(%ebx) 110362: 0f 94 c0 sete %al 110365: 8d 3c 03 lea (%ebx,%eax,1),%edi char *p; p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ 110368: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) 11036f: b8 01 00 00 00 mov $0x1,%eax ++p; for (first = 1, last = 0; !last ; ++p) { if (p[0] == '\0') 110374: 8a 0f mov (%edi),%cl last = 1; 110376: 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') 11037b: 84 c9 test %cl,%cl 11037d: 74 0b je 11038a last = 1; else if (p[0] != '/') 11037f: 80 f9 2f cmp $0x2f,%cl 110382: 0f 85 c8 00 00 00 jne 110450 110388: 30 d2 xor %dl,%dl continue; *p = '\0'; 11038a: c6 07 00 movb $0x0,(%edi) if (!last && p[1] == '\0') 11038d: be 01 00 00 00 mov $0x1,%esi 110392: 85 d2 test %edx,%edx 110394: 75 0b jne 1103a1 110396: 31 d2 xor %edx,%edx 110398: 80 7f 01 00 cmpb $0x0,0x1(%edi) 11039c: 0f 94 c2 sete %dl 11039f: 89 d6 mov %edx,%esi last = 1; if (first) { 1103a1: 85 c0 test %eax,%eax 1103a3: 74 1a je 1103bf * mkdir [-m mode] dir * * We change the user's umask and then restore it, * instead of doing chmod's. */ oumask = umask(0); 1103a5: 83 ec 0c sub $0xc,%esp 1103a8: 6a 00 push $0x0 1103aa: e8 75 01 00 00 call 110524 1103af: 89 45 94 mov %eax,-0x6c(%ebp) numask = oumask & ~(S_IWUSR | S_IXUSR); 1103b2: 24 3f and $0x3f,%al (void)umask(numask); 1103b4: 89 04 24 mov %eax,(%esp) 1103b7: e8 68 01 00 00 call 110524 1103bc: 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) { 1103bf: b8 ff 01 00 00 mov $0x1ff,%eax oumask = umask(0); numask = oumask & ~(S_IWUSR | S_IXUSR); (void)umask(numask); first = 0; } if (last) 1103c4: 85 f6 test %esi,%esi 1103c6: 74 11 je 1103d9 (void)umask(oumask); 1103c8: 83 ec 0c sub $0xc,%esp 1103cb: ff 75 94 pushl -0x6c(%ebp) 1103ce: e8 51 01 00 00 call 110524 1103d3: 83 c4 10 add $0x10,%esp if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { 1103d6: 8b 45 0c mov 0xc(%ebp),%eax 1103d9: 52 push %edx 1103da: 52 push %edx 1103db: 50 push %eax 1103dc: 53 push %ebx 1103dd: e8 fe 82 ff ff call 1086e0 1103e2: 83 c4 10 add $0x10,%esp 1103e5: 85 c0 test %eax,%eax 1103e7: 79 5e jns 110447 if (errno == EEXIST || errno == EISDIR) { 1103e9: e8 c6 25 00 00 call 1129b4 <__errno> 1103ee: 83 38 11 cmpl $0x11,(%eax) 1103f1: 74 0a je 1103fd 1103f3: e8 bc 25 00 00 call 1129b4 <__errno> 1103f8: 83 38 15 cmpl $0x15,(%eax) 1103fb: 75 59 jne 110456 <== ALWAYS TAKEN if (stat(path, &sb) < 0) { 1103fd: 50 push %eax 1103fe: 50 push %eax 1103ff: 8d 45 a0 lea -0x60(%ebp),%eax 110402: 50 push %eax 110403: 53 push %ebx 110404: e8 8b 00 00 00 call 110494 110409: 83 c4 10 add $0x10,%esp 11040c: 85 c0 test %eax,%eax 11040e: 78 46 js 110456 <== NEVER TAKEN retval = 0; break; } else if (!S_ISDIR(sb.st_mode)) { 110410: 8b 45 ac mov -0x54(%ebp),%eax 110413: 25 00 f0 00 00 and $0xf000,%eax 110418: 3d 00 40 00 00 cmp $0x4000,%eax 11041d: 74 22 je 110441 if (last) 11041f: 85 f6 test %esi,%esi 110421: 74 0f je 110432 errno = EEXIST; 110423: e8 8c 25 00 00 call 1129b4 <__errno> 110428: c7 00 11 00 00 00 movl $0x11,(%eax) else errno = ENOTDIR; retval = 0; 11042e: 31 ff xor %edi,%edi 110430: eb 38 jmp 11046a break; } else if (!S_ISDIR(sb.st_mode)) { if (last) errno = EEXIST; else errno = ENOTDIR; 110432: e8 7d 25 00 00 call 1129b4 <__errno> 110437: c7 00 14 00 00 00 movl $0x14,(%eax) retval = 0; 11043d: 31 ff xor %edi,%edi 11043f: eb 1b jmp 11045c break; } if (last) 110441: 85 f6 test %esi,%esi 110443: 75 3e jne 110483 110445: eb 04 jmp 11044b } else { retval = 0; break; } } if (!last) 110447: 85 f6 test %esi,%esi 110449: 75 3f jne 11048a *p = '/'; 11044b: c6 07 2f movb $0x2f,(%edi) 11044e: 31 c0 xor %eax,%eax p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; for (first = 1, last = 0; !last ; ++p) { 110450: 47 inc %edi 110451: e9 1e ff ff ff jmp 110374 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; 110456: 31 ff xor %edi,%edi } } if (!last) *p = '/'; } if (!first && !last) 110458: 85 f6 test %esi,%esi 11045a: 75 0e jne 11046a <== ALWAYS TAKEN (void)umask(oumask); 11045c: 83 ec 0c sub $0xc,%esp 11045f: ff 75 94 pushl -0x6c(%ebp) 110462: e8 bd 00 00 00 call 110524 110467: 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); 11046a: 83 ec 0c sub $0xc,%esp 11046d: 53 push %ebx 11046e: e8 11 7d ff ff call 108184 } return success != 0 ? 0 : -1; 110473: 83 c4 10 add $0x10,%esp 110476: 83 ff 01 cmp $0x1,%edi 110479: 19 c0 sbb %eax,%eax } 11047b: 8d 65 f4 lea -0xc(%ebp),%esp 11047e: 5b pop %ebx 11047f: 5e pop %esi 110480: 5f pop %edi 110481: c9 leave 110482: c3 ret errno = ENOTDIR; retval = 0; break; } if (last) retval = 2; 110483: bf 02 00 00 00 mov $0x2,%edi 110488: eb e0 jmp 11046a } else { retval = 0; break; } } if (!last) 11048a: bf 01 00 00 00 mov $0x1,%edi 11048f: eb d9 jmp 11046a =============================================================================== 001147ec : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 1147ec: 55 push %ebp 1147ed: 89 e5 mov %esp,%ebp 1147ef: 57 push %edi 1147f0: 56 push %esi 1147f1: 53 push %ebx 1147f2: 83 ec 1c sub $0x1c,%esp 1147f5: 8b 75 0c mov 0xc(%ebp),%esi 1147f8: 8b 55 10 mov 0x10(%ebp),%edx 1147fb: 8b 7d 14 mov 0x14(%ebp),%edi register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 1147fe: b8 03 00 00 00 mov $0x3,%eax rtems_id *id ) { register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 114803: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 114807: 0f 84 ce 00 00 00 je 1148db return RTEMS_INVALID_NAME; if ( !starting_address ) return RTEMS_INVALID_ADDRESS; 11480d: b0 09 mov $0x9,%al register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !starting_address ) 11480f: 85 f6 test %esi,%esi 114811: 0f 84 c4 00 00 00 je 1148db return RTEMS_INVALID_ADDRESS; if ( !id ) 114817: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp) 11481b: 0f 84 ba 00 00 00 je 1148db <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 114821: 85 ff test %edi,%edi 114823: 0f 84 ad 00 00 00 je 1148d6 114829: 85 d2 test %edx,%edx 11482b: 0f 84 a5 00 00 00 je 1148d6 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; 114831: b0 08 mov $0x8,%al return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 114833: 39 fa cmp %edi,%edx 114835: 0f 82 a0 00 00 00 jb 1148db 11483b: f7 c7 03 00 00 00 test $0x3,%edi 114841: 0f 85 94 00 00 00 jne 1148db !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) return RTEMS_INVALID_ADDRESS; 114847: 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 ) ) 114849: f7 c6 03 00 00 00 test $0x3,%esi 11484f: 0f 85 86 00 00 00 jne 1148db 114855: a1 94 ef 13 00 mov 0x13ef94,%eax 11485a: 40 inc %eax 11485b: a3 94 ef 13 00 mov %eax,0x13ef94 * 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 ); 114860: 83 ec 0c sub $0xc,%esp 114863: 68 24 ee 13 00 push $0x13ee24 114868: 89 55 e4 mov %edx,-0x1c(%ebp) 11486b: e8 14 3e 00 00 call 118684 <_Objects_Allocate> 114870: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 114872: 83 c4 10 add $0x10,%esp 114875: 85 c0 test %eax,%eax 114877: 8b 55 e4 mov -0x1c(%ebp),%edx 11487a: 75 0c jne 114888 _Thread_Enable_dispatch(); 11487c: e8 4d 4c 00 00 call 1194ce <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 114881: b8 05 00 00 00 mov $0x5,%eax 114886: eb 53 jmp 1148db _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 114888: 89 70 10 mov %esi,0x10(%eax) the_partition->length = length; 11488b: 89 50 14 mov %edx,0x14(%eax) the_partition->buffer_size = buffer_size; 11488e: 89 78 18 mov %edi,0x18(%eax) the_partition->attribute_set = attribute_set; 114891: 8b 45 18 mov 0x18(%ebp),%eax 114894: 89 43 1c mov %eax,0x1c(%ebx) the_partition->number_of_used_blocks = 0; 114897: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) _Chain_Initialize( &the_partition->Memory, starting_address, 11489e: 57 push %edi 11489f: 89 d0 mov %edx,%eax 1148a1: 31 d2 xor %edx,%edx 1148a3: f7 f7 div %edi 1148a5: 50 push %eax 1148a6: 56 push %esi 1148a7: 8d 43 24 lea 0x24(%ebx),%eax 1148aa: 50 push %eax 1148ab: e8 84 2a 00 00 call 117334 <_Chain_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 1148b0: 8b 43 08 mov 0x8(%ebx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 1148b3: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 1148b6: 8b 15 40 ee 13 00 mov 0x13ee40,%edx 1148bc: 89 1c 8a mov %ebx,(%edx,%ecx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 1148bf: 8b 55 08 mov 0x8(%ebp),%edx 1148c2: 89 53 0c mov %edx,0xc(%ebx) &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 1148c5: 8b 55 1c mov 0x1c(%ebp),%edx 1148c8: 89 02 mov %eax,(%edx) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 1148ca: e8 ff 4b 00 00 call 1194ce <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1148cf: 83 c4 10 add $0x10,%esp 1148d2: 31 c0 xor %eax,%eax 1148d4: eb 05 jmp 1148db 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; 1148d6: b8 08 00 00 00 mov $0x8,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1148db: 8d 65 f4 lea -0xc(%ebp),%esp 1148de: 5b pop %ebx 1148df: 5e pop %esi 1148e0: 5f pop %edi 1148e1: c9 leave 1148e2: c3 ret =============================================================================== 0010b031 : rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) { 10b031: 55 push %ebp 10b032: 89 e5 mov %esp,%ebp 10b034: 57 push %edi 10b035: 56 push %esi 10b036: 53 push %ebx 10b037: 83 ec 30 sub $0x30,%esp 10b03a: 8b 75 08 mov 0x8(%ebp),%esi 10b03d: 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 ); 10b040: 8d 45 e4 lea -0x1c(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) _Objects_Get( &_Rate_monotonic_Information, id, location ); 10b043: 50 push %eax 10b044: 56 push %esi 10b045: 68 54 83 12 00 push $0x128354 10b04a: e8 3d 1e 00 00 call 10ce8c <_Objects_Get> 10b04f: 89 c7 mov %eax,%edi switch ( location ) { 10b051: 83 c4 10 add $0x10,%esp 10b054: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b058: 0f 85 3b 01 00 00 jne 10b199 <== NEVER TAKEN case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 10b05e: a1 8c 89 12 00 mov 0x12898c,%eax 10b063: 39 47 40 cmp %eax,0x40(%edi) 10b066: 74 0f je 10b077 _Thread_Enable_dispatch(); 10b068: e8 fd 27 00 00 call 10d86a <_Thread_Enable_dispatch> return RTEMS_NOT_OWNER_OF_RESOURCE; 10b06d: be 17 00 00 00 mov $0x17,%esi 10b072: e9 27 01 00 00 jmp 10b19e } if ( length == RTEMS_PERIOD_STATUS ) { 10b077: 85 db test %ebx,%ebx 10b079: 75 1b jne 10b096 switch ( the_period->state ) { 10b07b: 8b 47 38 mov 0x38(%edi),%eax 10b07e: 31 f6 xor %esi,%esi 10b080: 83 f8 04 cmp $0x4,%eax 10b083: 77 07 ja 10b08c <== NEVER TAKEN 10b085: 8b 34 85 68 16 12 00 mov 0x121668(,%eax,4),%esi case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 10b08c: e8 d9 27 00 00 call 10d86a <_Thread_Enable_dispatch> return( return_value ); 10b091: e9 08 01 00 00 jmp 10b19e } _ISR_Disable( level ); 10b096: 9c pushf 10b097: fa cli 10b098: 8f 45 d4 popl -0x2c(%ebp) if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 10b09b: 8b 47 38 mov 0x38(%edi),%eax 10b09e: 85 c0 test %eax,%eax 10b0a0: 75 4c jne 10b0ee _ISR_Enable( level ); 10b0a2: ff 75 d4 pushl -0x2c(%ebp) 10b0a5: 9d popf /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 10b0a6: 83 ec 0c sub $0xc,%esp 10b0a9: 57 push %edi 10b0aa: e8 3f fe ff ff call 10aeee <_Rate_monotonic_Initiate_statistics> the_period->state = RATE_MONOTONIC_ACTIVE; 10b0af: 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; 10b0b6: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) the_watchdog->routine = routine; 10b0bd: c7 47 2c a8 b3 10 00 movl $0x10b3a8,0x2c(%edi) the_watchdog->id = id; 10b0c4: 89 77 30 mov %esi,0x30(%edi) the_watchdog->user_data = user_data; 10b0c7: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 10b0ce: 89 5f 3c mov %ebx,0x3c(%edi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b0d1: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b0d4: 58 pop %eax 10b0d5: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, length ); 10b0d6: 83 c7 10 add $0x10,%edi 10b0d9: 57 push %edi 10b0da: 68 28 85 12 00 push $0x128528 10b0df: e8 2c 35 00 00 call 10e610 <_Watchdog_Insert> _Thread_Enable_dispatch(); 10b0e4: e8 81 27 00 00 call 10d86a <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b0e9: 83 c4 10 add $0x10,%esp 10b0ec: eb 65 jmp 10b153 } if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { 10b0ee: 83 f8 02 cmp $0x2,%eax 10b0f1: 75 64 jne 10b157 /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 10b0f3: 83 ec 0c sub $0xc,%esp 10b0f6: 57 push %edi 10b0f7: e8 5a fe ff ff call 10af56 <_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; 10b0fc: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi) the_period->next_length = length; 10b103: 89 5f 3c mov %ebx,0x3c(%edi) _ISR_Enable( level ); 10b106: ff 75 d4 pushl -0x2c(%ebp) 10b109: 9d popf _Thread_Executing->Wait.id = the_period->Object.id; 10b10a: a1 8c 89 12 00 mov 0x12898c,%eax 10b10f: 8b 57 08 mov 0x8(%edi),%edx 10b112: 89 50 20 mov %edx,0x20(%eax) _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b115: 5b pop %ebx 10b116: 5e pop %esi 10b117: 68 00 40 00 00 push $0x4000 10b11c: 50 push %eax 10b11d: e8 fe 2e 00 00 call 10e020 <_Thread_Set_state> /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 10b122: 9c pushf 10b123: fa cli 10b124: 5a pop %edx local_state = the_period->state; 10b125: 8b 47 38 mov 0x38(%edi),%eax the_period->state = RATE_MONOTONIC_ACTIVE; 10b128: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi) _ISR_Enable( level ); 10b12f: 52 push %edx 10b130: 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 ) 10b131: 83 c4 10 add $0x10,%esp 10b134: 83 f8 03 cmp $0x3,%eax 10b137: 75 15 jne 10b14e _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b139: 51 push %ecx 10b13a: 51 push %ecx 10b13b: 68 00 40 00 00 push $0x4000 10b140: ff 35 8c 89 12 00 pushl 0x12898c 10b146: e8 ed 23 00 00 call 10d538 <_Thread_Clear_state> 10b14b: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 10b14e: e8 17 27 00 00 call 10d86a <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b153: 31 f6 xor %esi,%esi 10b155: eb 47 jmp 10b19e #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b157: be 04 00 00 00 mov $0x4,%esi _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_EXPIRED ) { 10b15c: 83 f8 04 cmp $0x4,%eax 10b15f: 75 3d jne 10b19e <== NEVER TAKEN /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 10b161: 83 ec 0c sub $0xc,%esp 10b164: 57 push %edi 10b165: e8 ec fd ff ff call 10af56 <_Rate_monotonic_Update_statistics> _ISR_Enable( level ); 10b16a: ff 75 d4 pushl -0x2c(%ebp) 10b16d: 9d popf the_period->state = RATE_MONOTONIC_ACTIVE; 10b16e: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi) the_period->next_length = length; 10b175: 89 5f 3c mov %ebx,0x3c(%edi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b178: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b17b: 58 pop %eax 10b17c: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, length ); 10b17d: 83 c7 10 add $0x10,%edi 10b180: 57 push %edi 10b181: 68 28 85 12 00 push $0x128528 10b186: e8 85 34 00 00 call 10e610 <_Watchdog_Insert> _Thread_Enable_dispatch(); 10b18b: e8 da 26 00 00 call 10d86a <_Thread_Enable_dispatch> return RTEMS_TIMEOUT; 10b190: 83 c4 10 add $0x10,%esp 10b193: 66 be 06 00 mov $0x6,%si 10b197: eb 05 jmp 10b19e #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b199: be 04 00 00 00 mov $0x4,%esi } 10b19e: 89 f0 mov %esi,%eax 10b1a0: 8d 65 f4 lea -0xc(%ebp),%esp 10b1a3: 5b pop %ebx 10b1a4: 5e pop %esi 10b1a5: 5f pop %edi 10b1a6: c9 leave 10b1a7: c3 ret =============================================================================== 0010b1a8 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 10b1a8: 55 push %ebp 10b1a9: 89 e5 mov %esp,%ebp 10b1ab: 57 push %edi 10b1ac: 56 push %esi 10b1ad: 53 push %ebx 10b1ae: 83 ec 7c sub $0x7c,%esp 10b1b1: 8b 5d 08 mov 0x8(%ebp),%ebx 10b1b4: 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 ) 10b1b7: 85 ff test %edi,%edi 10b1b9: 0f 84 2b 01 00 00 je 10b2ea <== NEVER TAKEN return; (*print)( context, "Period information by period\n" ); 10b1bf: 52 push %edx 10b1c0: 52 push %edx 10b1c1: 68 7c 16 12 00 push $0x12167c 10b1c6: 53 push %ebx 10b1c7: ff d7 call *%edi #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( context, "--- CPU times are in seconds ---\n" ); 10b1c9: 5e pop %esi 10b1ca: 58 pop %eax 10b1cb: 68 9a 16 12 00 push $0x12169a 10b1d0: 53 push %ebx 10b1d1: ff d7 call *%edi (*print)( context, "--- Wall times are in seconds ---\n" ); 10b1d3: 5a pop %edx 10b1d4: 59 pop %ecx 10b1d5: 68 bc 16 12 00 push $0x1216bc 10b1da: 53 push %ebx 10b1db: ff d7 call *%edi Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 10b1dd: 5e pop %esi 10b1de: 58 pop %eax 10b1df: 68 df 16 12 00 push $0x1216df 10b1e4: 53 push %ebx 10b1e5: ff d7 call *%edi #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ " " #endif " WALL TIME\n" ); (*print)( context, " " 10b1e7: 5a pop %edx 10b1e8: 59 pop %ecx 10b1e9: 68 2a 17 12 00 push $0x12172a 10b1ee: 53 push %ebx 10b1ef: 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 ; 10b1f1: 8b 35 5c 83 12 00 mov 0x12835c,%esi 10b1f7: 83 c4 10 add $0x10,%esp 10b1fa: e9 df 00 00 00 jmp 10b2de id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 10b1ff: 50 push %eax 10b200: 50 push %eax 10b201: 8d 45 88 lea -0x78(%ebp),%eax 10b204: 50 push %eax 10b205: 56 push %esi 10b206: e8 85 56 00 00 call 110890 if ( status != RTEMS_SUCCESSFUL ) 10b20b: 83 c4 10 add $0x10,%esp 10b20e: 85 c0 test %eax,%eax 10b210: 0f 85 c7 00 00 00 jne 10b2dd #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 ); 10b216: 51 push %ecx 10b217: 51 push %ecx 10b218: 8d 55 c0 lea -0x40(%ebp),%edx 10b21b: 52 push %edx 10b21c: 56 push %esi 10b21d: e8 12 57 00 00 call 110934 #endif rtems_object_get_name( the_status.owner, sizeof(name), name ); 10b222: 83 c4 0c add $0xc,%esp 10b225: 8d 45 e3 lea -0x1d(%ebp),%eax 10b228: 50 push %eax 10b229: 6a 05 push $0x5 10b22b: ff 75 c0 pushl -0x40(%ebp) 10b22e: e8 01 02 00 00 call 10b434 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 10b233: 58 pop %eax 10b234: 5a pop %edx 10b235: ff 75 8c pushl -0x74(%ebp) 10b238: ff 75 88 pushl -0x78(%ebp) 10b23b: 8d 55 e3 lea -0x1d(%ebp),%edx 10b23e: 52 push %edx 10b23f: 56 push %esi 10b240: 68 76 17 12 00 push $0x121776 10b245: 53 push %ebx 10b246: ff d7 call *%edi ); /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 10b248: 8b 45 88 mov -0x78(%ebp),%eax 10b24b: 83 c4 20 add $0x20,%esp 10b24e: 85 c0 test %eax,%eax 10b250: 75 0f jne 10b261 (*print)( context, "\n" ); 10b252: 51 push %ecx 10b253: 51 push %ecx 10b254: 68 f0 19 12 00 push $0x1219f0 10b259: 53 push %ebx 10b25a: ff d7 call *%edi continue; 10b25c: 83 c4 10 add $0x10,%esp 10b25f: eb 7c jmp 10b2dd 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 ); 10b261: 52 push %edx 10b262: 8d 55 d8 lea -0x28(%ebp),%edx 10b265: 52 push %edx 10b266: 50 push %eax 10b267: 8d 45 a0 lea -0x60(%ebp),%eax 10b26a: 50 push %eax 10b26b: e8 74 30 00 00 call 10e2e4 <_Timespec_Divide_by_integer> (*print)( context, 10b270: 8b 45 dc mov -0x24(%ebp),%eax 10b273: b9 e8 03 00 00 mov $0x3e8,%ecx 10b278: 99 cltd 10b279: f7 f9 idiv %ecx 10b27b: 50 push %eax 10b27c: ff 75 d8 pushl -0x28(%ebp) 10b27f: 8b 45 9c mov -0x64(%ebp),%eax 10b282: 99 cltd 10b283: f7 f9 idiv %ecx 10b285: 50 push %eax 10b286: ff 75 98 pushl -0x68(%ebp) 10b289: 8b 45 94 mov -0x6c(%ebp),%eax 10b28c: 99 cltd 10b28d: f7 f9 idiv %ecx 10b28f: 50 push %eax 10b290: ff 75 90 pushl -0x70(%ebp) 10b293: 68 8d 17 12 00 push $0x12178d 10b298: 53 push %ebx 10b299: 89 4d 84 mov %ecx,-0x7c(%ebp) 10b29c: 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); 10b29e: 83 c4 2c add $0x2c,%esp 10b2a1: 8d 55 d8 lea -0x28(%ebp),%edx 10b2a4: 52 push %edx 10b2a5: 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; 10b2a8: 8d 45 b8 lea -0x48(%ebp),%eax _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); 10b2ab: 50 push %eax 10b2ac: e8 33 30 00 00 call 10e2e4 <_Timespec_Divide_by_integer> (*print)( context, 10b2b1: 8b 45 dc mov -0x24(%ebp),%eax 10b2b4: 8b 4d 84 mov -0x7c(%ebp),%ecx 10b2b7: 99 cltd 10b2b8: f7 f9 idiv %ecx 10b2ba: 50 push %eax 10b2bb: ff 75 d8 pushl -0x28(%ebp) 10b2be: 8b 45 b4 mov -0x4c(%ebp),%eax 10b2c1: 99 cltd 10b2c2: f7 f9 idiv %ecx 10b2c4: 50 push %eax 10b2c5: ff 75 b0 pushl -0x50(%ebp) 10b2c8: 8b 45 ac mov -0x54(%ebp),%eax 10b2cb: 99 cltd 10b2cc: f7 f9 idiv %ecx 10b2ce: 50 push %eax 10b2cf: ff 75 a8 pushl -0x58(%ebp) 10b2d2: 68 ac 17 12 00 push $0x1217ac 10b2d7: 53 push %ebx 10b2d8: ff d7 call *%edi 10b2da: 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++ ) { 10b2dd: 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 ; 10b2de: 3b 35 60 83 12 00 cmp 0x128360,%esi 10b2e4: 0f 86 15 ff ff ff jbe 10b1ff the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 10b2ea: 8d 65 f4 lea -0xc(%ebp),%esp 10b2ed: 5b pop %ebx 10b2ee: 5e pop %esi 10b2ef: 5f pop %edi 10b2f0: c9 leave 10b2f1: c3 ret =============================================================================== 00115b4c : rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) { 115b4c: 55 push %ebp 115b4d: 89 e5 mov %esp,%ebp 115b4f: 53 push %ebx 115b50: 83 ec 14 sub $0x14,%esp 115b53: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; 115b56: 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 ) 115b5b: 85 db test %ebx,%ebx 115b5d: 74 6d je 115bcc return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 115b5f: 50 push %eax 115b60: 50 push %eax 115b61: 8d 45 f4 lea -0xc(%ebp),%eax 115b64: 50 push %eax 115b65: ff 75 08 pushl 0x8(%ebp) 115b68: e8 83 39 00 00 call 1194f0 <_Thread_Get> switch ( location ) { 115b6d: 83 c4 10 add $0x10,%esp 115b70: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 115b74: 75 51 jne 115bc7 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 115b76: 8b 90 e8 00 00 00 mov 0xe8(%eax),%edx asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 115b7c: 83 7a 0c 00 cmpl $0x0,0xc(%edx) 115b80: 74 39 je 115bbb if ( asr->is_enabled ) { 115b82: 80 7a 08 00 cmpb $0x0,0x8(%edx) 115b86: 74 22 je 115baa rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115b88: 9c pushf 115b89: fa cli 115b8a: 59 pop %ecx *signal_set |= signals; 115b8b: 09 5a 14 or %ebx,0x14(%edx) _ISR_Enable( _level ); 115b8e: 51 push %ecx 115b8f: 9d popf _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 115b90: 83 3d e0 f4 13 00 00 cmpl $0x0,0x13f4e0 115b97: 74 19 je 115bb2 115b99: 3b 05 e4 f4 13 00 cmp 0x13f4e4,%eax 115b9f: 75 11 jne 115bb2 <== NEVER TAKEN _Thread_Dispatch_necessary = true; 115ba1: c6 05 f0 f4 13 00 01 movb $0x1,0x13f4f0 115ba8: eb 08 jmp 115bb2 rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115baa: 9c pushf 115bab: fa cli 115bac: 58 pop %eax *signal_set |= signals; 115bad: 09 5a 18 or %ebx,0x18(%edx) _ISR_Enable( _level ); 115bb0: 50 push %eax 115bb1: 9d popf } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 115bb2: e8 17 39 00 00 call 1194ce <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115bb7: 31 c0 xor %eax,%eax 115bb9: eb 11 jmp 115bcc } _Thread_Enable_dispatch(); 115bbb: e8 0e 39 00 00 call 1194ce <_Thread_Enable_dispatch> return RTEMS_NOT_DEFINED; 115bc0: b8 0b 00 00 00 mov $0xb,%eax 115bc5: eb 05 jmp 115bcc case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115bc7: b8 04 00 00 00 mov $0x4,%eax } 115bcc: 8b 5d fc mov -0x4(%ebp),%ebx 115bcf: c9 leave 115bd0: c3 ret =============================================================================== 001072b4 : * rtems_stack_checker_Begin_extension */ void rtems_stack_checker_begin_extension( Thread_Control *the_thread ) { 1072b4: 55 push %ebp 1072b5: 89 e5 mov %esp,%ebp 1072b7: 57 push %edi 1072b8: 56 push %esi 1072b9: 8b 45 08 mov 0x8(%ebp),%eax Stack_check_Control *the_pattern; if ( the_thread->Object.id == 0 ) /* skip system tasks */ 1072bc: 83 78 08 00 cmpl $0x0,0x8(%eax) 1072c0: 74 15 je 1072d7 <== NEVER TAKEN return; the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack); *the_pattern = Stack_check_Pattern; 1072c2: 8b b8 bc 00 00 00 mov 0xbc(%eax),%edi 1072c8: 83 c7 08 add $0x8,%edi 1072cb: be 08 72 12 00 mov $0x127208,%esi 1072d0: b9 04 00 00 00 mov $0x4,%ecx 1072d5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } 1072d7: 5e pop %esi 1072d8: 5f pop %edi 1072d9: c9 leave 1072da: c3 ret =============================================================================== 0010728d : */ bool rtems_stack_checker_create_extension( Thread_Control *running __attribute__((unused)), Thread_Control *the_thread ) { 10728d: 55 push %ebp 10728e: 89 e5 mov %esp,%ebp 107290: 57 push %edi 107291: 8b 7d 0c mov 0xc(%ebp),%edi Stack_check_Initialize(); 107294: e8 8a ff ff ff call 107223 if (the_thread) 107299: 85 ff test %edi,%edi 10729b: 74 12 je 1072af <== NEVER TAKEN Stack_check_Dope_stack(&the_thread->Start.Initial_stack); 10729d: 8b 8f b8 00 00 00 mov 0xb8(%edi),%ecx 1072a3: 8b 97 bc 00 00 00 mov 0xbc(%edi),%edx 1072a9: b0 a5 mov $0xa5,%al 1072ab: 89 d7 mov %edx,%edi 1072ad: f3 aa rep stos %al,%es:(%edi) return true; } 1072af: b0 01 mov $0x1,%al 1072b1: 5f pop %edi 1072b2: c9 leave 1072b3: c3 ret =============================================================================== 001073e8 : /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) { 1073e8: 55 push %ebp 1073e9: 89 e5 mov %esp,%ebp 1073eb: 53 push %ebx 1073ec: 83 ec 04 sub $0x4,%esp Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 1073ef: a1 1c 79 12 00 mov 0x12791c,%eax ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 1073f4: 8b 90 bc 00 00 00 mov 0xbc(%eax),%edx return false; 1073fa: 31 db xor %ebx,%ebx ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 1073fc: 39 d5 cmp %edx,%ebp 1073fe: 72 0e jb 10740e <== NEVER TAKEN return false; } if ( sp > (the_stack->area + the_stack->size) ) { 107400: 8b 80 b8 00 00 00 mov 0xb8(%eax),%eax 107406: 8d 04 02 lea (%edx,%eax,1),%eax } /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) 107409: 39 c5 cmp %eax,%ebp 10740b: 0f 96 c3 setbe %bl { Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; bool sp_ok; bool pattern_ok = true; 10740e: b0 01 mov $0x1,%al /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 107410: 83 3d f8 6e 12 00 00 cmpl $0x0,0x126ef8 107417: 74 19 je 107432 <== NEVER TAKEN pattern_ok = (!memcmp( 107419: 83 c2 08 add $0x8,%edx 10741c: 51 push %ecx 10741d: 6a 10 push $0x10 10741f: 68 08 72 12 00 push $0x127208 107424: 52 push %edx 107425: e8 9e cb 00 00 call 113fc8 10742a: 83 c4 10 add $0x10,%esp 10742d: 85 c0 test %eax,%eax 10742f: 0f 94 c0 sete %al /* * Let's report as much as we can. */ if ( !sp_ok || !pattern_ok ) { 107432: 84 db test %bl,%bl 107434: 74 04 je 10743a <== NEVER TAKEN 107436: 84 c0 test %al,%al 107438: 75 11 jne 10744b <== ALWAYS TAKEN Stack_check_report_blown_task( _Thread_Executing, pattern_ok ); 10743a: 52 push %edx <== NOT EXECUTED 10743b: 52 push %edx <== NOT EXECUTED 10743c: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10743f: 50 push %eax <== NOT EXECUTED 107440: ff 35 1c 79 12 00 pushl 0x12791c <== NOT EXECUTED 107446: e8 90 fe ff ff call 1072db <== NOT EXECUTED /* * The Stack Pointer and the Pattern Area are OK so return false. */ return false; } 10744b: 31 c0 xor %eax,%eax 10744d: 8b 5d fc mov -0x4(%ebp),%ebx 107450: c9 leave 107451: c3 ret =============================================================================== 001074b7 : void rtems_stack_checker_report_usage( void ) { 1074b7: 55 push %ebp <== NOT EXECUTED 1074b8: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1074ba: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin ); 1074bd: 68 1c 8c 10 00 push $0x108c1c <== NOT EXECUTED 1074c2: 6a 00 push $0x0 <== NOT EXECUTED 1074c4: e8 89 ff ff ff call 107452 <== NOT EXECUTED 1074c9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1074cc: c9 leave <== NOT EXECUTED 1074cd: c3 ret <== NOT EXECUTED =============================================================================== 00107452 : void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) { 107452: 55 push %ebp <== NOT EXECUTED 107453: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107455: 56 push %esi <== NOT EXECUTED 107456: 53 push %ebx <== NOT EXECUTED 107457: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10745a: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED if ( !print ) 10745d: 85 db test %ebx,%ebx <== NOT EXECUTED 10745f: 74 4f je 1074b0 <== NOT EXECUTED return; print_context = context; 107461: 89 35 f0 6e 12 00 mov %esi,0x126ef0 <== NOT EXECUTED print_handler = print; 107467: 89 1d f4 6e 12 00 mov %ebx,0x126ef4 <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 10746d: 51 push %ecx <== NOT EXECUTED 10746e: 51 push %ecx <== NOT EXECUTED 10746f: 68 4f 17 12 00 push $0x12174f <== NOT EXECUTED 107474: 56 push %esi <== NOT EXECUTED 107475: ff d3 call *%ebx <== NOT EXECUTED (*print)( context, 107477: 58 pop %eax <== NOT EXECUTED 107478: 5a pop %edx <== NOT EXECUTED 107479: 68 66 17 12 00 push $0x121766 <== NOT EXECUTED 10747e: 56 push %esi <== NOT EXECUTED 10747f: 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 ); 107481: c7 04 24 08 71 10 00 movl $0x107108,(%esp) <== NOT EXECUTED 107488: e8 df 63 00 00 call 10d86c <== NOT EXECUTED #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) /* dump interrupt stack info if any */ Stack_check_Dump_threads_usage((Thread_Control *) -1); 10748d: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED 107494: e8 6f fc ff ff call 107108 <== NOT EXECUTED #endif print_context = NULL; 107499: c7 05 f0 6e 12 00 00 movl $0x0,0x126ef0 <== NOT EXECUTED 1074a0: 00 00 00 print_handler = NULL; 1074a3: c7 05 f4 6e 12 00 00 movl $0x0,0x126ef4 <== NOT EXECUTED 1074aa: 00 00 00 1074ad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1074b0: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1074b3: 5b pop %ebx <== NOT EXECUTED 1074b4: 5e pop %esi <== NOT EXECUTED 1074b5: c9 leave <== NOT EXECUTED 1074b6: c3 ret <== NOT EXECUTED =============================================================================== 0010738f : */ void rtems_stack_checker_switch_extension( Thread_Control *running __attribute__((unused)), Thread_Control *heir __attribute__((unused)) ) { 10738f: 55 push %ebp 107390: 89 e5 mov %esp,%ebp 107392: 53 push %ebx 107393: 83 ec 14 sub $0x14,%esp 107396: 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); 107399: 8b 83 bc 00 00 00 mov 0xbc(%ebx),%eax 10739f: 8d 48 08 lea 0x8(%eax),%ecx { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { return false; 1073a2: 31 d2 xor %edx,%edx ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 1073a4: 39 c5 cmp %eax,%ebp 1073a6: 72 0b jb 1073b3 <== NEVER TAKEN return false; } if ( sp > (the_stack->area + the_stack->size) ) { 1073a8: 03 83 b8 00 00 00 add 0xb8(%ebx),%eax } /* * rtems_stack_checker_switch_extension */ void rtems_stack_checker_switch_extension( 1073ae: 39 c5 cmp %eax,%ebp 1073b0: 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, 1073b3: 50 push %eax 1073b4: 6a 10 push $0x10 1073b6: 68 08 72 12 00 push $0x127208 1073bb: 51 push %ecx 1073bc: 88 55 f4 mov %dl,-0xc(%ebp) 1073bf: e8 04 cc 00 00 call 113fc8 1073c4: 83 c4 10 add $0x10,%esp 1073c7: 85 c0 test %eax,%eax 1073c9: 0f 94 c0 sete %al (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { 1073cc: 8a 55 f4 mov -0xc(%ebp),%dl 1073cf: 84 d2 test %dl,%dl 1073d1: 74 04 je 1073d7 <== NEVER TAKEN 1073d3: 84 c0 test %al,%al 1073d5: 75 0c jne 1073e3 <== ALWAYS TAKEN Stack_check_report_blown_task( running, pattern_ok ); 1073d7: 52 push %edx <== NOT EXECUTED 1073d8: 52 push %edx <== NOT EXECUTED 1073d9: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 1073dc: 50 push %eax <== NOT EXECUTED 1073dd: 53 push %ebx <== NOT EXECUTED 1073de: e8 f8 fe ff ff call 1072db <== NOT EXECUTED } } 1073e3: 8b 5d fc mov -0x4(%ebp),%ebx 1073e6: c9 leave 1073e7: c3 ret =============================================================================== 0010efe0 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 10efe0: 55 push %ebp 10efe1: 89 e5 mov %esp,%ebp 10efe3: 57 push %edi 10efe4: 56 push %esi 10efe5: 53 push %ebx 10efe6: 83 ec 2c sub $0x2c,%esp 10efe9: 8b 75 08 mov 0x8(%ebp),%esi 10efec: 8b 5d 0c mov 0xc(%ebp),%ebx 10efef: 8b 7d 10 mov 0x10(%ebp),%edi STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10eff2: b8 09 00 00 00 mov $0x9,%eax ) { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 10eff7: 85 db test %ebx,%ebx 10eff9: 74 6e je 10f069 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; errno = 0; 10effb: e8 a4 2a 00 00 call 111aa4 <__errno> 10f000: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f006: c7 03 00 00 00 00 movl $0x0,(%ebx) 10f00c: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); 10f013: 50 push %eax 10f014: 50 push %eax 10f015: 8d 45 e4 lea -0x1c(%ebp),%eax 10f018: 50 push %eax 10f019: 56 push %esi 10f01a: e8 29 55 00 00 call 114548 #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 10f01f: 83 c4 10 add $0x10,%esp 10f022: 85 ff test %edi,%edi 10f024: 74 05 je 10f02b *endptr = end; 10f026: 8b 45 e4 mov -0x1c(%ebp),%eax 10f029: 89 07 mov %eax,(%edi) /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 10f02b: b8 0b 00 00 00 mov $0xb,%eax /* If the user wants the end pointer back, then return it. */ if ( endptr ) *endptr = end; /* nothing was converted */ if ( end == s ) 10f030: 39 75 e4 cmp %esi,-0x1c(%ebp) 10f033: 74 2e je 10f063 return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f035: dd 05 b8 3d 12 00 fldl 0x123db8 10f03b: d9 c9 fxch %st(1) 10f03d: dd e1 fucom %st(1) 10f03f: df e0 fnstsw %ax 10f041: dd d9 fstp %st(1) 10f043: 9e sahf 10f044: 76 17 jbe 10f05d 10f046: dd 5d c8 fstpl -0x38(%ebp) 10f049: e8 56 2a 00 00 call 111aa4 <__errno> 10f04e: 89 c2 mov %eax,%edx return RTEMS_INVALID_NUMBER; 10f050: b8 0a 00 00 00 mov $0xa,%eax return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f055: 83 3a 22 cmpl $0x22,(%edx) 10f058: dd 45 c8 fldl -0x38(%ebp) 10f05b: 74 0a je 10f067 <== ALWAYS TAKEN #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 10f05d: dd 1b fstpl (%ebx) #endif return RTEMS_SUCCESSFUL; 10f05f: 31 c0 xor %eax,%eax 10f061: eb 06 jmp 10f069 10f063: dd d8 fstp %st(0) 10f065: eb 02 jmp 10f069 10f067: dd d8 fstp %st(0) } 10f069: 8d 65 f4 lea -0xc(%ebp),%esp 10f06c: 5b pop %ebx 10f06d: 5e pop %esi 10f06e: 5f pop %edi 10f06f: c9 leave 10f070: c3 ret =============================================================================== 0010f074 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 10f074: 55 push %ebp 10f075: 89 e5 mov %esp,%ebp 10f077: 57 push %edi 10f078: 56 push %esi 10f079: 53 push %ebx 10f07a: 83 ec 2c sub $0x2c,%esp 10f07d: 8b 75 08 mov 0x8(%ebp),%esi 10f080: 8b 5d 0c mov 0xc(%ebp),%ebx 10f083: 8b 7d 10 mov 0x10(%ebp),%edi STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f086: b8 09 00 00 00 mov $0x9,%eax ) { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 10f08b: 85 db test %ebx,%ebx 10f08d: 74 67 je 10f0f6 return RTEMS_INVALID_ADDRESS; errno = 0; 10f08f: e8 10 2a 00 00 call 111aa4 <__errno> 10f094: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f09a: c7 03 00 00 00 00 movl $0x0,(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); 10f0a0: 50 push %eax 10f0a1: 50 push %eax 10f0a2: 8d 45 e4 lea -0x1c(%ebp),%eax 10f0a5: 50 push %eax 10f0a6: 56 push %esi 10f0a7: e8 b8 54 00 00 call 114564 #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 10f0ac: 83 c4 10 add $0x10,%esp 10f0af: 85 ff test %edi,%edi 10f0b1: 74 05 je 10f0b8 *endptr = end; 10f0b3: 8b 45 e4 mov -0x1c(%ebp),%eax 10f0b6: 89 07 mov %eax,(%edi) /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 10f0b8: b8 0b 00 00 00 mov $0xb,%eax /* If the user wants the end pointer back, then return it. */ if ( endptr ) *endptr = end; /* nothing was converted */ if ( end == s ) 10f0bd: 39 75 e4 cmp %esi,-0x1c(%ebp) 10f0c0: 74 2e je 10f0f0 return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f0c2: d9 05 c0 3d 12 00 flds 0x123dc0 10f0c8: d9 c9 fxch %st(1) 10f0ca: dd e1 fucom %st(1) 10f0cc: df e0 fnstsw %ax 10f0ce: dd d9 fstp %st(1) 10f0d0: 9e sahf 10f0d1: 76 17 jbe 10f0ea 10f0d3: d9 5d c8 fstps -0x38(%ebp) 10f0d6: e8 c9 29 00 00 call 111aa4 <__errno> 10f0db: 89 c2 mov %eax,%edx return RTEMS_INVALID_NUMBER; 10f0dd: b8 0a 00 00 00 mov $0xa,%eax return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f0e2: 83 3a 22 cmpl $0x22,(%edx) 10f0e5: d9 45 c8 flds -0x38(%ebp) 10f0e8: 74 0a je 10f0f4 <== ALWAYS TAKEN #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 10f0ea: d9 1b fstps (%ebx) #endif return RTEMS_SUCCESSFUL; 10f0ec: 31 c0 xor %eax,%eax 10f0ee: eb 06 jmp 10f0f6 10f0f0: dd d8 fstp %st(0) 10f0f2: eb 02 jmp 10f0f6 10f0f4: dd d8 fstp %st(0) } 10f0f6: 8d 65 f4 lea -0xc(%ebp),%esp 10f0f9: 5b pop %ebx 10f0fa: 5e pop %esi 10f0fb: 5f pop %edi 10f0fc: c9 leave 10f0fd: c3 ret =============================================================================== 0010f180 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 10f180: 55 push %ebp 10f181: 89 e5 mov %esp,%ebp 10f183: 57 push %edi 10f184: 56 push %esi 10f185: 53 push %ebx 10f186: 83 ec 2c sub $0x2c,%esp 10f189: 8b 5d 0c mov 0xc(%ebp),%ebx 10f18c: 8b 7d 10 mov 0x10(%ebp),%edi STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f18f: b9 09 00 00 00 mov $0x9,%ecx ) { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 10f194: 85 db test %ebx,%ebx 10f196: 74 76 je 10f20e return RTEMS_INVALID_ADDRESS; errno = 0; 10f198: e8 07 29 00 00 call 111aa4 <__errno> 10f19d: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f1a3: c7 03 00 00 00 00 movl $0x0,(%ebx) 10f1a9: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); #elif defined(STRING_TO_POINTER) result = STRING_TO_METHOD( s, &end, 16 ); #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); 10f1b0: 50 push %eax 10f1b1: ff 75 14 pushl 0x14(%ebp) 10f1b4: 8d 45 e4 lea -0x1c(%ebp),%eax 10f1b7: 50 push %eax 10f1b8: ff 75 08 pushl 0x8(%ebp) 10f1bb: e8 80 55 00 00 call 114740 10f1c0: 89 c6 mov %eax,%esi #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 10f1c2: 83 c4 10 add $0x10,%esp 10f1c5: 85 ff test %edi,%edi 10f1c7: 74 05 je 10f1ce *endptr = end; 10f1c9: 8b 45 e4 mov -0x1c(%ebp),%eax 10f1cc: 89 07 mov %eax,(%edi) /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 10f1ce: b9 0b 00 00 00 mov $0xb,%ecx /* If the user wants the end pointer back, then return it. */ if ( endptr ) *endptr = end; /* nothing was converted */ if ( end == s ) 10f1d3: 8b 45 08 mov 0x8(%ebp),%eax 10f1d6: 39 45 e4 cmp %eax,-0x1c(%ebp) 10f1d9: 74 33 je 10f20e return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f1db: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx 10f1e1: 75 05 jne 10f1e8 10f1e3: 83 fe ff cmp $0xffffffff,%esi 10f1e6: 74 0a je 10f1f2 <== ALWAYS TAKEN return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MIN /* there was an underflow */ if ( (result == STRING_TO_MIN) && (errno == ERANGE)) 10f1e8: 8d 82 00 00 00 80 lea -0x80000000(%edx),%eax 10f1ee: 09 f0 or %esi,%eax 10f1f0: 75 15 jne 10f207 10f1f2: 89 55 d4 mov %edx,-0x2c(%ebp) 10f1f5: e8 aa 28 00 00 call 111aa4 <__errno> return RTEMS_INVALID_NUMBER; 10f1fa: b9 0a 00 00 00 mov $0xa,%ecx return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MIN /* there was an underflow */ if ( (result == STRING_TO_MIN) && (errno == ERANGE)) 10f1ff: 83 38 22 cmpl $0x22,(%eax) 10f202: 8b 55 d4 mov -0x2c(%ebp),%edx 10f205: 74 07 je 10f20e #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 10f207: 89 33 mov %esi,(%ebx) 10f209: 89 53 04 mov %edx,0x4(%ebx) #endif return RTEMS_SUCCESSFUL; 10f20c: 31 c9 xor %ecx,%ecx } 10f20e: 89 c8 mov %ecx,%eax 10f210: 8d 65 f4 lea -0xc(%ebp),%esp 10f213: 5b pop %ebx 10f214: 5e pop %esi 10f215: 5f pop %edi 10f216: c9 leave 10f217: c3 ret =============================================================================== 0010f2a0 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 10f2a0: 55 push %ebp 10f2a1: 89 e5 mov %esp,%ebp 10f2a3: 57 push %edi 10f2a4: 56 push %esi 10f2a5: 53 push %ebx 10f2a6: 83 ec 2c sub $0x2c,%esp 10f2a9: 8b 7d 08 mov 0x8(%ebp),%edi 10f2ac: 8b 5d 0c mov 0xc(%ebp),%ebx 10f2af: 8b 55 10 mov 0x10(%ebp),%edx STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f2b2: b8 09 00 00 00 mov $0x9,%eax ) { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 10f2b7: 85 db test %ebx,%ebx 10f2b9: 74 56 je 10f311 return RTEMS_INVALID_ADDRESS; errno = 0; 10f2bb: 89 55 d4 mov %edx,-0x2c(%ebp) 10f2be: e8 e1 27 00 00 call 111aa4 <__errno> 10f2c3: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f2c9: c7 03 00 00 00 00 movl $0x0,(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); #elif defined(STRING_TO_POINTER) result = STRING_TO_METHOD( s, &end, 16 ); 10f2cf: 50 push %eax 10f2d0: 6a 10 push $0x10 10f2d2: 8d 45 e4 lea -0x1c(%ebp),%eax 10f2d5: 50 push %eax 10f2d6: 57 push %edi 10f2d7: e8 04 59 00 00 call 114be0 10f2dc: 89 c6 mov %eax,%esi #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 10f2de: 83 c4 10 add $0x10,%esp 10f2e1: 8b 55 d4 mov -0x2c(%ebp),%edx 10f2e4: 85 d2 test %edx,%edx 10f2e6: 74 05 je 10f2ed *endptr = end; 10f2e8: 8b 45 e4 mov -0x1c(%ebp),%eax 10f2eb: 89 02 mov %eax,(%edx) /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 10f2ed: b8 0b 00 00 00 mov $0xb,%eax /* If the user wants the end pointer back, then return it. */ if ( endptr ) *endptr = end; /* nothing was converted */ if ( end == s ) 10f2f2: 39 7d e4 cmp %edi,-0x1c(%ebp) 10f2f5: 74 1a je 10f311 return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f2f7: 83 fe ff cmp $0xffffffff,%esi 10f2fa: 75 11 jne 10f30d <== ALWAYS TAKEN 10f2fc: e8 a3 27 00 00 call 111aa4 <__errno> <== NOT EXECUTED 10f301: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_NUMBER; 10f303: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f308: 83 3a 22 cmpl $0x22,(%edx) <== NOT EXECUTED 10f30b: 74 04 je 10f311 <== NOT EXECUTED if ( (result == STRING_TO_MIN) && (errno == ERANGE)) return RTEMS_INVALID_NUMBER; #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; 10f30d: 89 33 mov %esi,(%ebx) #else *n = (STRING_TO_TYPE) result; #endif return RTEMS_SUCCESSFUL; 10f30f: 31 c0 xor %eax,%eax } 10f311: 8d 65 f4 lea -0xc(%ebp),%esp 10f314: 5b pop %ebx 10f315: 5e pop %esi 10f316: 5f pop %edi 10f317: c9 leave 10f318: c3 ret =============================================================================== 0010f378 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 10f378: 55 push %ebp 10f379: 89 e5 mov %esp,%ebp 10f37b: 57 push %edi 10f37c: 56 push %esi 10f37d: 53 push %ebx 10f37e: 83 ec 2c sub $0x2c,%esp 10f381: 8b 7d 08 mov 0x8(%ebp),%edi 10f384: 8b 5d 0c mov 0xc(%ebp),%ebx 10f387: 8b 55 10 mov 0x10(%ebp),%edx STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f38a: b8 09 00 00 00 mov $0x9,%eax ) { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 10f38f: 85 db test %ebx,%ebx 10f391: 74 57 je 10f3ea return RTEMS_INVALID_ADDRESS; errno = 0; 10f393: 89 55 d4 mov %edx,-0x2c(%ebp) 10f396: e8 09 27 00 00 call 111aa4 <__errno> 10f39b: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f3a1: c7 03 00 00 00 00 movl $0x0,(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); #elif defined(STRING_TO_POINTER) result = STRING_TO_METHOD( s, &end, 16 ); #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); 10f3a7: 50 push %eax 10f3a8: ff 75 14 pushl 0x14(%ebp) 10f3ab: 8d 45 e4 lea -0x1c(%ebp),%eax 10f3ae: 50 push %eax 10f3af: 57 push %edi 10f3b0: e8 2b 58 00 00 call 114be0 10f3b5: 89 c6 mov %eax,%esi #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 10f3b7: 83 c4 10 add $0x10,%esp 10f3ba: 8b 55 d4 mov -0x2c(%ebp),%edx 10f3bd: 85 d2 test %edx,%edx 10f3bf: 74 05 je 10f3c6 *endptr = end; 10f3c1: 8b 45 e4 mov -0x1c(%ebp),%eax 10f3c4: 89 02 mov %eax,(%edx) /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 10f3c6: b8 0b 00 00 00 mov $0xb,%eax /* If the user wants the end pointer back, then return it. */ if ( endptr ) *endptr = end; /* nothing was converted */ if ( end == s ) 10f3cb: 39 7d e4 cmp %edi,-0x1c(%ebp) 10f3ce: 74 1a je 10f3ea return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f3d0: 83 fe ff cmp $0xffffffff,%esi 10f3d3: 75 11 jne 10f3e6 10f3d5: e8 ca 26 00 00 call 111aa4 <__errno> 10f3da: 89 c2 mov %eax,%edx return RTEMS_INVALID_NUMBER; 10f3dc: b8 0a 00 00 00 mov $0xa,%eax return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f3e1: 83 3a 22 cmpl $0x22,(%edx) 10f3e4: 74 04 je 10f3ea <== ALWAYS TAKEN #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 10f3e6: 89 33 mov %esi,(%ebx) #endif return RTEMS_SUCCESSFUL; 10f3e8: 31 c0 xor %eax,%eax } 10f3ea: 8d 65 f4 lea -0xc(%ebp),%esp 10f3ed: 5b pop %ebx 10f3ee: 5e pop %esi 10f3ef: 5f pop %edi 10f3f0: c9 leave 10f3f1: c3 ret =============================================================================== 0010f480 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 10f480: 55 push %ebp 10f481: 89 e5 mov %esp,%ebp 10f483: 57 push %edi 10f484: 56 push %esi 10f485: 53 push %ebx 10f486: 83 ec 2c sub $0x2c,%esp 10f489: 8b 7d 08 mov 0x8(%ebp),%edi 10f48c: 8b 5d 0c mov 0xc(%ebp),%ebx 10f48f: 8b 55 10 mov 0x10(%ebp),%edx STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f492: b8 09 00 00 00 mov $0x9,%eax ) { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 10f497: 85 db test %ebx,%ebx 10f499: 74 57 je 10f4f2 return RTEMS_INVALID_ADDRESS; errno = 0; 10f49b: 89 55 d4 mov %edx,-0x2c(%ebp) 10f49e: e8 01 26 00 00 call 111aa4 <__errno> 10f4a3: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f4a9: c7 03 00 00 00 00 movl $0x0,(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); #elif defined(STRING_TO_POINTER) result = STRING_TO_METHOD( s, &end, 16 ); #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); 10f4af: 50 push %eax 10f4b0: ff 75 14 pushl 0x14(%ebp) 10f4b3: 8d 45 e4 lea -0x1c(%ebp),%eax 10f4b6: 50 push %eax 10f4b7: 57 push %edi 10f4b8: e8 23 57 00 00 call 114be0 10f4bd: 89 c6 mov %eax,%esi #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 10f4bf: 83 c4 10 add $0x10,%esp 10f4c2: 8b 55 d4 mov -0x2c(%ebp),%edx 10f4c5: 85 d2 test %edx,%edx 10f4c7: 74 05 je 10f4ce *endptr = end; 10f4c9: 8b 45 e4 mov -0x1c(%ebp),%eax 10f4cc: 89 02 mov %eax,(%edx) /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 10f4ce: b8 0b 00 00 00 mov $0xb,%eax /* If the user wants the end pointer back, then return it. */ if ( endptr ) *endptr = end; /* nothing was converted */ if ( end == s ) 10f4d3: 39 7d e4 cmp %edi,-0x1c(%ebp) 10f4d6: 74 1a je 10f4f2 return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f4d8: 83 fe ff cmp $0xffffffff,%esi 10f4db: 75 11 jne 10f4ee 10f4dd: e8 c2 25 00 00 call 111aa4 <__errno> 10f4e2: 89 c2 mov %eax,%edx return RTEMS_INVALID_NUMBER; 10f4e4: b8 0a 00 00 00 mov $0xa,%eax return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f4e9: 83 3a 22 cmpl $0x22,(%edx) 10f4ec: 74 04 je 10f4f2 <== ALWAYS TAKEN #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 10f4ee: 89 33 mov %esi,(%ebx) #endif return RTEMS_SUCCESSFUL; 10f4f0: 31 c0 xor %eax,%eax } 10f4f2: 8d 65 f4 lea -0xc(%ebp),%esp 10f4f5: 5b pop %ebx 10f4f6: 5e pop %esi 10f4f7: 5f pop %edi 10f4f8: c9 leave 10f4f9: c3 ret =============================================================================== 0010f3f4 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 10f3f4: 55 push %ebp 10f3f5: 89 e5 mov %esp,%ebp 10f3f7: 57 push %edi 10f3f8: 56 push %esi 10f3f9: 53 push %ebx 10f3fa: 83 ec 2c sub $0x2c,%esp 10f3fd: 8b 5d 0c mov 0xc(%ebp),%ebx 10f400: 8b 7d 10 mov 0x10(%ebp),%edi STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f403: b8 09 00 00 00 mov $0x9,%eax ) { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 10f408: 85 db test %ebx,%ebx 10f40a: 74 6b je 10f477 return RTEMS_INVALID_ADDRESS; errno = 0; 10f40c: e8 93 26 00 00 call 111aa4 <__errno> 10f411: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f417: c7 03 00 00 00 00 movl $0x0,(%ebx) 10f41d: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); #elif defined(STRING_TO_POINTER) result = STRING_TO_METHOD( s, &end, 16 ); #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); 10f424: 50 push %eax 10f425: ff 75 14 pushl 0x14(%ebp) 10f428: 8d 45 e4 lea -0x1c(%ebp),%eax 10f42b: 50 push %eax 10f42c: ff 75 08 pushl 0x8(%ebp) 10f42f: e8 c8 57 00 00 call 114bfc 10f434: 89 c6 mov %eax,%esi #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 10f436: 83 c4 10 add $0x10,%esp 10f439: 85 ff test %edi,%edi 10f43b: 74 05 je 10f442 *endptr = end; 10f43d: 8b 45 e4 mov -0x1c(%ebp),%eax 10f440: 89 07 mov %eax,(%edi) /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 10f442: b8 0b 00 00 00 mov $0xb,%eax /* If the user wants the end pointer back, then return it. */ if ( endptr ) *endptr = end; /* nothing was converted */ if ( end == s ) 10f447: 8b 4d 08 mov 0x8(%ebp),%ecx 10f44a: 39 4d e4 cmp %ecx,-0x1c(%ebp) 10f44d: 74 28 je 10f477 return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f44f: 83 fa ff cmp $0xffffffff,%edx 10f452: 75 1c jne 10f470 10f454: 83 fe ff cmp $0xffffffff,%esi 10f457: 75 17 jne 10f470 <== NEVER TAKEN 10f459: 89 55 d4 mov %edx,-0x2c(%ebp) 10f45c: e8 43 26 00 00 call 111aa4 <__errno> 10f461: 89 c1 mov %eax,%ecx return RTEMS_INVALID_NUMBER; 10f463: b8 0a 00 00 00 mov $0xa,%eax return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f468: 83 39 22 cmpl $0x22,(%ecx) 10f46b: 8b 55 d4 mov -0x2c(%ebp),%edx 10f46e: 74 07 je 10f477 <== ALWAYS TAKEN #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 10f470: 89 33 mov %esi,(%ebx) 10f472: 89 53 04 mov %edx,0x4(%ebx) #endif return RTEMS_SUCCESSFUL; 10f475: 31 c0 xor %eax,%eax } 10f477: 8d 65 f4 lea -0xc(%ebp),%esp 10f47a: 5b pop %ebx 10f47b: 5e pop %esi 10f47c: 5f pop %edi 10f47d: c9 leave 10f47e: c3 ret =============================================================================== 0010707c : int rtems_tarfs_load( char *mountpoint, uint8_t *tar_image, size_t tar_size ) { 10707c: 55 push %ebp 10707d: 89 e5 mov %esp,%ebp 10707f: 57 push %edi 107080: 56 push %esi 107081: 53 push %ebx 107082: 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( 107088: 31 c0 xor %eax,%eax 10708a: 83 c9 ff or $0xffffffff,%ecx 10708d: 8b 7d 08 mov 0x8(%ebp),%edi 107090: f2 ae repnz scas %es:(%edi),%al 107092: f7 d1 not %ecx 107094: 49 dec %ecx 107095: 6a 00 push $0x0 107097: 8d 45 d0 lea -0x30(%ebp),%eax 10709a: 50 push %eax 10709b: 6a 00 push $0x0 10709d: 51 push %ecx 10709e: ff 75 08 pushl 0x8(%ebp) 1070a1: e8 d4 09 00 00 call 107a7a 1070a6: 89 85 54 fe ff ff mov %eax,-0x1ac(%ebp) strlen(mountpoint), 0, &root_loc, 0 ); if (status != 0) 1070ac: 83 c4 20 add $0x20,%esp 1070af: 85 c0 test %eax,%eax 1070b1: 0f 85 d9 01 00 00 jne 107290 return -1; if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops) 1070b7: 8b 45 dc mov -0x24(%ebp),%eax 1070ba: 31 f6 xor %esi,%esi 1070bc: 3d 8c 45 12 00 cmp $0x12458c,%eax 1070c1: 74 1b je 1070de 1070c3: 3d 84 4f 12 00 cmp $0x124f84,%eax 1070c8: 0f 85 c2 01 00 00 jne 107290 <== ALWAYS TAKEN 1070ce: 8b b5 54 fe ff ff mov -0x1ac(%ebp),%esi <== NOT EXECUTED 1070d4: eb 08 jmp 1070de <== NOT EXECUTED 1070d6: 8b b5 50 fe ff ff mov -0x1b0(%ebp),%esi 1070dc: eb 18 jmp 1070f6 * should not have this path. */ else if (linkflag == REGTYPE) { const char *name; loc = root_loc; 1070de: 8d 45 bc lea -0x44(%ebp),%eax 1070e1: 89 85 34 fe ff ff mov %eax,-0x1cc(%ebp) 1070e7: 8d 55 d0 lea -0x30(%ebp),%edx 1070ea: 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); 1070f0: 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) 1070f6: 8d 86 00 02 00 00 lea 0x200(%esi),%eax 1070fc: 89 85 50 fe ff ff mov %eax,-0x1b0(%ebp) 107102: 8b 55 10 mov 0x10(%ebp),%edx 107105: 39 d0 cmp %edx,%eax 107107: 0f 87 8d 01 00 00 ja 10729a <== NEVER TAKEN break; /* * Read a header. */ hdr_ptr = (char *) &tar_image[offset]; 10710d: 03 75 0c add 0xc(%ebp),%esi offset += 512; if (strncmp(&hdr_ptr[257], "ustar", 5)) 107110: 8d 86 01 01 00 00 lea 0x101(%esi),%eax 107116: 52 push %edx 107117: 6a 05 push $0x5 107119: 68 d4 45 12 00 push $0x1245d4 10711e: 50 push %eax 10711f: e8 08 e6 00 00 call 11572c 107124: 83 c4 10 add $0x10,%esp 107127: 85 c0 test %eax,%eax 107129: 0f 85 6b 01 00 00 jne 10729a break; strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE); 10712f: 50 push %eax 107130: 6a 63 push $0x63 107132: 56 push %esi 107133: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax 107139: 50 push %eax 10713a: e8 7d e6 00 00 call 1157bc filename[MAX_NAME_FIELD_SIZE] = '\0'; 10713f: c6 45 bb 00 movb $0x0,-0x45(%ebp) linkflag = hdr_ptr[156]; 107143: 8a 96 9c 00 00 00 mov 0x9c(%esi),%dl file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8); 107149: 59 pop %ecx 10714a: 5f pop %edi 10714b: 6a 08 push $0x8 10714d: 8d 46 64 lea 0x64(%esi),%eax 107150: 50 push %eax 107151: 88 95 44 fe ff ff mov %dl,-0x1bc(%ebp) 107157: e8 54 6e 00 00 call 10dfb0 <_rtems_octal2ulong> 10715c: 89 85 48 fe ff ff mov %eax,-0x1b8(%ebp) file_size = _rtems_octal2ulong(&hdr_ptr[124], 12); 107162: 5f pop %edi 107163: 58 pop %eax 107164: 6a 0c push $0xc 107166: 8d 46 7c lea 0x7c(%esi),%eax 107169: 50 push %eax 10716a: e8 41 6e 00 00 call 10dfb0 <_rtems_octal2ulong> 10716f: 89 85 4c fe ff ff mov %eax,-0x1b4(%ebp) hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8); 107175: 5a pop %edx 107176: 59 pop %ecx 107177: 6a 08 push $0x8 107179: 8d 86 94 00 00 00 lea 0x94(%esi),%eax 10717f: 50 push %eax 107180: e8 2b 6e 00 00 call 10dfb0 <_rtems_octal2ulong> 107185: 89 c7 mov %eax,%edi if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum) 107187: 89 34 24 mov %esi,(%esp) 10718a: e8 4f 6e 00 00 call 10dfde <_rtems_tar_header_checksum> 10718f: 83 c4 10 add $0x10,%esp 107192: 39 f8 cmp %edi,%eax 107194: 8a 95 44 fe ff ff mov -0x1bc(%ebp),%dl 10719a: 0f 85 fa 00 00 00 jne 10729a <== 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) { 1071a0: 80 fa 35 cmp $0x35,%dl 1071a3: 75 57 jne 1071fc strcpy(full_filename, mountpoint); 1071a5: 50 push %eax 1071a6: 50 push %eax 1071a7: ff 75 08 pushl 0x8(%ebp) 1071aa: 53 push %ebx 1071ab: e8 14 e2 00 00 call 1153c4 if (full_filename[strlen(full_filename)-1] != '/') 1071b0: 31 c0 xor %eax,%eax 1071b2: 83 c9 ff or $0xffffffff,%ecx 1071b5: 89 df mov %ebx,%edi 1071b7: f2 ae repnz scas %es:(%edi),%al 1071b9: f7 d1 not %ecx 1071bb: 83 c4 10 add $0x10,%esp 1071be: 80 bc 0d 56 fe ff ff cmpb $0x2f,-0x1aa(%ebp,%ecx,1) 1071c5: 2f 1071c6: 74 10 je 1071d8 <== ALWAYS TAKEN strcat(full_filename, "/"); 1071c8: 57 push %edi <== NOT EXECUTED 1071c9: 57 push %edi <== NOT EXECUTED 1071ca: 68 79 04 12 00 push $0x120479 <== NOT EXECUTED 1071cf: 53 push %ebx <== NOT EXECUTED 1071d0: e8 3b e0 00 00 call 115210 <== NOT EXECUTED 1071d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED strcat(full_filename, filename); 1071d8: 56 push %esi 1071d9: 56 push %esi 1071da: 8d 95 58 ff ff ff lea -0xa8(%ebp),%edx 1071e0: 52 push %edx 1071e1: 53 push %ebx 1071e2: e8 29 e0 00 00 call 115210 mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO); 1071e7: 5a pop %edx 1071e8: 59 pop %ecx 1071e9: 68 ff 01 00 00 push $0x1ff 1071ee: 53 push %ebx 1071ef: e8 58 0f 00 00 call 10814c 1071f4: 83 c4 10 add $0x10,%esp 1071f7: e9 da fe ff ff jmp 1070d6 * 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) { 1071fc: 80 fa 30 cmp $0x30,%dl 1071ff: 0f 85 d1 fe ff ff jne 1070d6 const char *name; loc = root_loc; 107205: b9 05 00 00 00 mov $0x5,%ecx 10720a: 8b bd 34 fe ff ff mov -0x1cc(%ebp),%edi 107210: 8b b5 30 fe ff ff mov -0x1d0(%ebp),%esi 107216: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) { 107218: 50 push %eax 107219: 8d 45 e4 lea -0x1c(%ebp),%eax 10721c: 50 push %eax 10721d: 8d 55 bc lea -0x44(%ebp),%edx 107220: 52 push %edx 107221: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax 107227: 50 push %eax 107228: e8 af 78 00 00 call 10eadc 10722d: 83 c4 10 add $0x10,%esp 107230: 85 c0 test %eax,%eax 107232: 75 41 jne 107275 <== NEVER TAKEN node = IMFS_create_node( 107234: 83 ec 0c sub $0xc,%esp 107237: 6a 00 push $0x0 &loc, IMFS_LINEAR_FILE, (char *)name, (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG, 107239: 8b 85 48 fe ff ff mov -0x1b8(%ebp),%eax 10723f: 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( 107244: 80 cc 80 or $0x80,%ah 107247: 50 push %eax 107248: ff 75 e4 pushl -0x1c(%ebp) 10724b: 6a 06 push $0x6 10724d: 8d 55 bc lea -0x44(%ebp),%edx 107250: 52 push %edx 107251: e8 79 73 00 00 call 10e5cf &loc, IMFS_LINEAR_FILE, (char *)name, (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG, NULL ); node->info.linearfile.size = file_size; 107256: 8b 95 4c fe ff ff mov -0x1b4(%ebp),%edx 10725c: 89 50 50 mov %edx,0x50(%eax) 10725f: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.linearfile.direct = &tar_image[offset]; 107266: 8b 55 0c mov 0xc(%ebp),%edx 107269: 03 95 50 fe ff ff add -0x1b0(%ebp),%edx 10726f: 89 50 58 mov %edx,0x58(%eax) 107272: 83 c4 20 add $0x20,%esp } nblocks = (((file_size) + 511) & ~511) / 512; 107275: 8b 85 4c fe ff ff mov -0x1b4(%ebp),%eax 10727b: 05 ff 01 00 00 add $0x1ff,%eax offset += 512 * nblocks; 107280: 25 00 fe ff ff and $0xfffffe00,%eax 107285: 01 85 50 fe ff ff add %eax,-0x1b0(%ebp) 10728b: e9 46 fe ff ff jmp 1070d6 ); if (status != 0) return -1; if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops) return -1; 107290: c7 85 54 fe ff ff ff movl $0xffffffff,-0x1ac(%ebp) 107297: ff ff ff nblocks = (((file_size) + 511) & ~511) / 512; offset += 512 * nblocks; } } return status; } 10729a: 8b 85 54 fe ff ff mov -0x1ac(%ebp),%eax 1072a0: 8d 65 f4 lea -0xc(%ebp),%esp 1072a3: 5b pop %ebx 1072a4: 5e pop %esi 1072a5: 5f pop %edi 1072a6: c9 leave 1072a7: c3 ret =============================================================================== 00110d7c : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 110d7c: 55 push %ebp 110d7d: 89 e5 mov %esp,%ebp 110d7f: 57 push %edi 110d80: 56 push %esi 110d81: 53 push %ebx 110d82: 83 ec 1c sub $0x1c,%esp 110d85: 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; 110d88: 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 ) 110d8d: 85 c9 test %ecx,%ecx 110d8f: 0f 84 fb 00 00 00 je 110e90 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 110d95: 8b 35 68 58 12 00 mov 0x125868,%esi api = executing->API_Extensions[ THREAD_API_RTEMS ]; 110d9b: 8b 9e e8 00 00 00 mov 0xe8(%esi),%ebx asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 110da1: 80 7e 74 01 cmpb $0x1,0x74(%esi) 110da5: 19 ff sbb %edi,%edi 110da7: 81 e7 00 01 00 00 and $0x100,%edi if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 110dad: 83 7e 7c 00 cmpl $0x0,0x7c(%esi) 110db1: 74 06 je 110db9 old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 110db3: 81 cf 00 02 00 00 or $0x200,%edi old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 110db9: 80 7b 08 01 cmpb $0x1,0x8(%ebx) 110dbd: 19 d2 sbb %edx,%edx 110dbf: 81 e2 00 04 00 00 and $0x400,%edx old_mode |= _ISR_Get_level(); 110dc5: 89 55 e4 mov %edx,-0x1c(%ebp) 110dc8: 89 4d e0 mov %ecx,-0x20(%ebp) 110dcb: e8 a5 c5 ff ff call 10d375 <_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; 110dd0: 8b 55 e4 mov -0x1c(%ebp),%edx 110dd3: 09 d0 or %edx,%eax old_mode |= _ISR_Get_level(); 110dd5: 09 f8 or %edi,%eax 110dd7: 8b 4d e0 mov -0x20(%ebp),%ecx 110dda: 89 01 mov %eax,(%ecx) *previous_mode_set = old_mode; /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 110ddc: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) 110de3: 74 0b je 110df0 executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; 110de5: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp) 110dec: 0f 94 46 74 sete 0x74(%esi) if ( mask & RTEMS_TIMESLICE_MASK ) { 110df0: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 110df7: 74 21 je 110e1a if ( _Modes_Is_timeslice(mode_set) ) { 110df9: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp) 110e00: 74 11 je 110e13 executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 110e02: c7 46 7c 01 00 00 00 movl $0x1,0x7c(%esi) executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 110e09: a1 f0 52 12 00 mov 0x1252f0,%eax 110e0e: 89 46 78 mov %eax,0x78(%esi) 110e11: eb 07 jmp 110e1a } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 110e13: c7 46 7c 00 00 00 00 movl $0x0,0x7c(%esi) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 110e1a: f6 45 0c 01 testb $0x1,0xc(%ebp) 110e1e: 74 0a je 110e2a */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( Modes_Control mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 110e20: f6 45 08 01 testb $0x1,0x8(%ebp) 110e24: 74 03 je 110e29 110e26: fa cli 110e27: eb 01 jmp 110e2a 110e29: fb sti /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 110e2a: 31 c9 xor %ecx,%ecx if ( mask & RTEMS_ASR_MASK ) { 110e2c: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 110e33: 74 2a je 110e5f * Output: * *previous_mode_set - previous mode set * always return RTEMS_SUCCESSFUL; */ rtems_status_code rtems_task_mode( 110e35: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp) 110e3c: 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 ) { 110e3f: 3a 43 08 cmp 0x8(%ebx),%al 110e42: 74 1b je 110e5f asr->is_enabled = is_asr_enabled; 110e44: 88 43 08 mov %al,0x8(%ebx) ) { rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); 110e47: 9c pushf 110e48: fa cli 110e49: 58 pop %eax _signals = information->signals_pending; 110e4a: 8b 53 18 mov 0x18(%ebx),%edx information->signals_pending = information->signals_posted; 110e4d: 8b 4b 14 mov 0x14(%ebx),%ecx 110e50: 89 4b 18 mov %ecx,0x18(%ebx) information->signals_posted = _signals; 110e53: 89 53 14 mov %edx,0x14(%ebx) _ISR_Enable( _level ); 110e56: 50 push %eax 110e57: 9d popf /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 110e58: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 110e5c: 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; 110e5f: 31 c0 xor %eax,%eax needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 110e61: 83 3d 9c 54 12 00 03 cmpl $0x3,0x12549c 110e68: 75 26 jne 110e90 <== NEVER TAKEN bool are_signals_pending ) { Thread_Control *executing; executing = _Thread_Executing; 110e6a: 8b 15 68 58 12 00 mov 0x125868,%edx if ( are_signals_pending || 110e70: 84 c9 test %cl,%cl 110e72: 75 0e jne 110e82 110e74: 3b 15 6c 58 12 00 cmp 0x12586c,%edx 110e7a: 74 14 je 110e90 (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) { 110e7c: 80 7a 74 00 cmpb $0x0,0x74(%edx) 110e80: 74 0e je 110e90 <== NEVER TAKEN _Thread_Dispatch_necessary = true; 110e82: c6 05 74 58 12 00 01 movb $0x1,0x125874 if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); 110e89: e8 0e b1 ff ff call 10bf9c <_Thread_Dispatch> } return RTEMS_SUCCESSFUL; 110e8e: 31 c0 xor %eax,%eax } 110e90: 83 c4 1c add $0x1c,%esp 110e93: 5b pop %ebx 110e94: 5e pop %esi 110e95: 5f pop %edi 110e96: c9 leave 110e97: c3 ret =============================================================================== 0010dd30 : rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10dd30: 55 push %ebp 10dd31: 89 e5 mov %esp,%ebp 10dd33: 56 push %esi 10dd34: 53 push %ebx 10dd35: 83 ec 10 sub $0x10,%esp 10dd38: 8b 5d 0c mov 0xc(%ebp),%ebx 10dd3b: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10dd3e: 85 db test %ebx,%ebx 10dd40: 74 10 je 10dd52 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 ) ); 10dd42: 0f b6 15 f4 41 12 00 movzbl 0x1241f4,%edx !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; 10dd49: b8 13 00 00 00 mov $0x13,%eax ) { register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10dd4e: 39 d3 cmp %edx,%ebx 10dd50: 77 52 ja 10dda4 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) return RTEMS_INVALID_ADDRESS; 10dd52: 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 ) 10dd57: 85 f6 test %esi,%esi 10dd59: 74 49 je 10dda4 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10dd5b: 51 push %ecx 10dd5c: 51 push %ecx 10dd5d: 8d 45 f4 lea -0xc(%ebp),%eax 10dd60: 50 push %eax 10dd61: ff 75 08 pushl 0x8(%ebp) 10dd64: e8 fb 1d 00 00 call 10fb64 <_Thread_Get> switch ( location ) { 10dd69: 83 c4 10 add $0x10,%esp 10dd6c: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10dd70: 75 2d jne 10dd9f case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10dd72: 8b 50 14 mov 0x14(%eax),%edx 10dd75: 89 16 mov %edx,(%esi) if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10dd77: 85 db test %ebx,%ebx 10dd79: 74 1b je 10dd96 the_thread->real_priority = new_priority; 10dd7b: 89 58 18 mov %ebx,0x18(%eax) if ( the_thread->resource_count == 0 || 10dd7e: 83 78 1c 00 cmpl $0x0,0x1c(%eax) 10dd82: 74 05 je 10dd89 10dd84: 39 58 14 cmp %ebx,0x14(%eax) 10dd87: 76 0d jbe 10dd96 <== ALWAYS TAKEN the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, false ); 10dd89: 52 push %edx 10dd8a: 6a 00 push $0x0 10dd8c: 53 push %ebx 10dd8d: 50 push %eax 10dd8e: e8 69 19 00 00 call 10f6fc <_Thread_Change_priority> 10dd93: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10dd96: e8 a7 1d 00 00 call 10fb42 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10dd9b: 31 c0 xor %eax,%eax 10dd9d: eb 05 jmp 10dda4 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10dd9f: b8 04 00 00 00 mov $0x4,%eax } 10dda4: 8d 65 f8 lea -0x8(%ebp),%esp 10dda7: 5b pop %ebx 10dda8: 5e pop %esi 10dda9: c9 leave 10ddaa: c3 ret =============================================================================== 00108507 : } } rtems_status_code rtems_termios_close (void *arg) { 108507: 55 push %ebp 108508: 89 e5 mov %esp,%ebp 10850a: 56 push %esi 10850b: 53 push %ebx 10850c: 8b 75 08 mov 0x8(%ebp),%esi rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 10850f: 8b 06 mov (%esi),%eax 108511: 8b 58 34 mov 0x34(%eax),%ebx rtems_status_code sc; sc = rtems_semaphore_obtain( 108514: 51 push %ecx 108515: 6a 00 push $0x0 108517: 6a 00 push $0x0 108519: ff 35 1c 52 12 00 pushl 0x12521c 10851f: e8 44 1c 00 00 call 10a168 rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 108524: 83 c4 10 add $0x10,%esp 108527: 85 c0 test %eax,%eax 108529: 0f 85 88 00 00 00 jne 1085b7 <== NEVER TAKEN rtems_fatal_error_occurred (sc); if (--tty->refcount == 0) { 10852f: 8b 43 08 mov 0x8(%ebx),%eax 108532: 48 dec %eax 108533: 89 43 08 mov %eax,0x8(%ebx) 108536: 85 c0 test %eax,%eax 108538: 0f 85 3e 01 00 00 jne 10867c if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 10853e: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 108544: c1 e0 05 shl $0x5,%eax 108547: 8b 80 d8 4e 12 00 mov 0x124ed8(%eax),%eax 10854d: 85 c0 test %eax,%eax 10854f: 74 08 je 108559 /* * call discipline-specific close */ sc = rtems_termios_linesw[tty->t_line].l_close(tty); 108551: 83 ec 0c sub $0xc,%esp 108554: 53 push %ebx 108555: ff d0 call *%eax 108557: eb 26 jmp 10857f } else { /* * default: just flush output buffer */ sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 108559: 52 push %edx 10855a: 6a 00 push $0x0 10855c: 6a 00 push $0x0 10855e: ff 73 18 pushl 0x18(%ebx) 108561: e8 02 1c 00 00 call 10a168 if (sc != RTEMS_SUCCESSFUL) { 108566: 83 c4 10 add $0x10,%esp 108569: 85 c0 test %eax,%eax 10856b: 75 4a jne 1085b7 <== NEVER TAKEN rtems_fatal_error_occurred (sc); } drainOutput (tty); 10856d: 89 d8 mov %ebx,%eax 10856f: e8 10 fb ff ff call 108084 rtems_semaphore_release (tty->osem); 108574: 83 ec 0c sub $0xc,%esp 108577: ff 73 18 pushl 0x18(%ebx) 10857a: e8 d5 1c 00 00 call 10a254 10857f: 83 c4 10 add $0x10,%esp } if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 108582: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 108589: 75 35 jne 1085c0 /* * send "terminate" to I/O tasks */ sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT ); 10858b: 50 push %eax 10858c: 50 push %eax 10858d: 6a 01 push $0x1 10858f: ff b3 c4 00 00 00 pushl 0xc4(%ebx) 108595: e8 66 17 00 00 call 109d00 if (sc != RTEMS_SUCCESSFUL) 10859a: 83 c4 10 add $0x10,%esp 10859d: 85 c0 test %eax,%eax 10859f: 75 16 jne 1085b7 <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT ); 1085a1: 51 push %ecx 1085a2: 51 push %ecx 1085a3: 6a 01 push $0x1 1085a5: ff b3 c8 00 00 00 pushl 0xc8(%ebx) 1085ab: e8 50 17 00 00 call 109d00 if (sc != RTEMS_SUCCESSFUL) 1085b0: 83 c4 10 add $0x10,%esp 1085b3: 85 c0 test %eax,%eax 1085b5: 74 09 je 1085c0 <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 1085b7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1085ba: 50 push %eax <== NOT EXECUTED 1085bb: e8 7c 21 00 00 call 10a73c <== NOT EXECUTED } if (tty->device.lastClose) 1085c0: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax 1085c6: 85 c0 test %eax,%eax 1085c8: 74 0d je 1085d7 (*tty->device.lastClose)(tty->major, tty->minor, arg); 1085ca: 52 push %edx 1085cb: 56 push %esi 1085cc: ff 73 10 pushl 0x10(%ebx) 1085cf: ff 73 0c pushl 0xc(%ebx) 1085d2: ff d0 call *%eax 1085d4: 83 c4 10 add $0x10,%esp if (tty->forw == NULL) { 1085d7: 8b 13 mov (%ebx),%edx 1085d9: 85 d2 test %edx,%edx 1085db: 8b 43 04 mov 0x4(%ebx),%eax 1085de: 75 11 jne 1085f1 rtems_termios_ttyTail = tty->back; 1085e0: a3 20 52 12 00 mov %eax,0x125220 if ( rtems_termios_ttyTail != NULL ) { 1085e5: 85 c0 test %eax,%eax 1085e7: 74 0b je 1085f4 rtems_termios_ttyTail->forw = NULL; 1085e9: c7 00 00 00 00 00 movl $0x0,(%eax) 1085ef: eb 03 jmp 1085f4 } } else { tty->forw->back = tty->back; 1085f1: 89 42 04 mov %eax,0x4(%edx) } if (tty->back == NULL) { 1085f4: 8b 53 04 mov 0x4(%ebx),%edx 1085f7: 85 d2 test %edx,%edx 1085f9: 8b 03 mov (%ebx),%eax 1085fb: 75 12 jne 10860f <== NEVER TAKEN rtems_termios_ttyHead = tty->forw; 1085fd: a3 24 52 12 00 mov %eax,0x125224 if ( rtems_termios_ttyHead != NULL ) { 108602: 85 c0 test %eax,%eax 108604: 74 0b je 108611 rtems_termios_ttyHead->back = NULL; 108606: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) 10860d: eb 02 jmp 108611 } } else { tty->back->forw = tty->forw; 10860f: 89 02 mov %eax,(%edx) } rtems_semaphore_delete (tty->isem); 108611: 83 ec 0c sub $0xc,%esp 108614: ff 73 14 pushl 0x14(%ebx) 108617: e8 bc 1a 00 00 call 10a0d8 rtems_semaphore_delete (tty->osem); 10861c: 59 pop %ecx 10861d: ff 73 18 pushl 0x18(%ebx) 108620: e8 b3 1a 00 00 call 10a0d8 rtems_semaphore_delete (tty->rawOutBuf.Semaphore); 108625: 5a pop %edx 108626: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 10862c: e8 a7 1a 00 00 call 10a0d8 if ((tty->device.pollRead == NULL) || 108631: 83 c4 10 add $0x10,%esp 108634: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx) 10863b: 74 09 je 108646 10863d: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 108644: 75 0e jne 108654 (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)) rtems_semaphore_delete (tty->rawInBuf.Semaphore); 108646: 83 ec 0c sub $0xc,%esp 108649: ff 73 68 pushl 0x68(%ebx) 10864c: e8 87 1a 00 00 call 10a0d8 108651: 83 c4 10 add $0x10,%esp free (tty->rawInBuf.theBuf); 108654: 83 ec 0c sub $0xc,%esp 108657: ff 73 58 pushl 0x58(%ebx) 10865a: e8 e9 ec ff ff call 107348 free (tty->rawOutBuf.theBuf); 10865f: 58 pop %eax 108660: ff 73 7c pushl 0x7c(%ebx) 108663: e8 e0 ec ff ff call 107348 free (tty->cbuf); 108668: 5e pop %esi 108669: ff 73 1c pushl 0x1c(%ebx) 10866c: e8 d7 ec ff ff call 107348 free (tty); 108671: 89 1c 24 mov %ebx,(%esp) 108674: e8 cf ec ff ff call 107348 108679: 83 c4 10 add $0x10,%esp } rtems_semaphore_release (rtems_termios_ttyMutex); 10867c: 83 ec 0c sub $0xc,%esp 10867f: ff 35 1c 52 12 00 pushl 0x12521c 108685: e8 ca 1b 00 00 call 10a254 return RTEMS_SUCCESSFUL; } 10868a: 31 c0 xor %eax,%eax 10868c: 8d 65 f8 lea -0x8(%ebp),%esp 10868f: 5b pop %ebx 108690: 5e pop %esi 108691: c9 leave 108692: c3 ret =============================================================================== 00109840 : * for each transmitted character. * It returns number of characters left to transmit */ int rtems_termios_dequeue_characters (void *ttyp, int len) { 109840: 55 push %ebp 109841: 89 e5 mov %esp,%ebp 109843: 83 ec 08 sub $0x8,%esp 109846: 8b 45 08 mov 0x8(%ebp),%eax rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len; 109849: 8b 55 0c mov 0xc(%ebp),%edx 10984c: 01 90 90 00 00 00 add %edx,0x90(%eax) if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 109852: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax) 109859: 75 1f jne 10987a /* * send wake up to transmitter task */ sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT); 10985b: 52 push %edx 10985c: 52 push %edx 10985d: 6a 02 push $0x2 10985f: ff b0 c8 00 00 00 pushl 0xc8(%eax) 109865: e8 96 04 00 00 call 109d00 if (sc != RTEMS_SUCCESSFUL) 10986a: 83 c4 10 add $0x10,%esp 10986d: 85 c0 test %eax,%eax 10986f: 74 30 je 1098a1 <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 109871: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109874: 50 push %eax <== NOT EXECUTED 109875: e8 c2 0e 00 00 call 10a73c <== NOT EXECUTED return 0; /* nothing to output in IRQ... */ } if (tty->t_line == PPPDISC ) { 10987a: 83 b8 cc 00 00 00 05 cmpl $0x5,0xcc(%eax) 109881: 75 15 jne 109898 /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 109883: 8b 15 88 4f 12 00 mov 0x124f88,%edx 109889: 85 d2 test %edx,%edx 10988b: 74 14 je 1098a1 <== NEVER TAKEN rtems_termios_linesw[tty->t_line].l_start(tty); 10988d: 83 ec 0c sub $0xc,%esp 109890: 50 push %eax 109891: ff d2 call *%edx 109893: 83 c4 10 add $0x10,%esp 109896: eb 09 jmp 1098a1 } return 0; /* nothing to output in IRQ... */ } return rtems_termios_refill_transmitter(tty); 109898: 89 45 08 mov %eax,0x8(%ebp) } 10989b: c9 leave rtems_termios_linesw[tty->t_line].l_start(tty); } return 0; /* nothing to output in IRQ... */ } return rtems_termios_refill_transmitter(tty); 10989c: e9 6d fd ff ff jmp 10960e } 1098a1: 31 c0 xor %eax,%eax 1098a3: c9 leave 1098a4: c3 ret =============================================================================== 0010931f : * 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) { 10931f: 55 push %ebp 109320: 89 e5 mov %esp,%ebp 109322: 57 push %edi 109323: 56 push %esi 109324: 53 push %ebx 109325: 83 ec 2c sub $0x2c,%esp 109328: 8b 5d 08 mov 0x8(%ebp),%ebx 10932b: 8b 7d 0c mov 0xc(%ebp),%edi 10932e: 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) { 109331: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 109337: c1 e0 05 shl $0x5,%eax 10933a: 89 ca mov %ecx,%edx 10933c: 83 b8 e4 4e 12 00 00 cmpl $0x0,0x124ee4(%eax) 109343: 75 3b jne 109380 109345: 89 4d e0 mov %ecx,-0x20(%ebp) 109348: c6 45 df 00 movb $0x0,-0x21(%ebp) 10934c: 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); 10934e: 8d 43 30 lea 0x30(%ebx),%eax 109351: 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, 109354: 8d 53 4a lea 0x4a(%ebx),%edx 109357: 89 55 d0 mov %edx,-0x30(%ebp) 10935a: e9 26 02 00 00 jmp 109585 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++; 10935f: 0f be 0f movsbl (%edi),%ecx 109362: 47 inc %edi rtems_termios_linesw[tty->t_line].l_rint(c,tty); 109363: 56 push %esi 109364: 56 push %esi 109365: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 10936b: c1 e0 05 shl $0x5,%eax 10936e: 53 push %ebx 10936f: 51 push %ecx 109370: 89 55 cc mov %edx,-0x34(%ebp) 109373: ff 90 e4 4e 12 00 call *0x124ee4(%eax) 109379: 8b 55 cc mov -0x34(%ebp),%edx 10937c: 4a dec %edx 10937d: 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--) { 109380: 85 d2 test %edx,%edx 109382: 75 db jne 10935f */ 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; 109384: 31 f6 xor %esi,%esi } /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 109386: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx) 10938d: 0f 85 0d 02 00 00 jne 1095a0 <== NEVER TAKEN 109393: 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; 109399: 89 d6 mov %edx,%esi } /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 10939b: 85 c0 test %eax,%eax 10939d: 0f 84 fd 01 00 00 je 1095a0 <== NEVER TAKEN (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 1093a3: 51 push %ecx 1093a4: 51 push %ecx 1093a5: ff b3 e0 00 00 00 pushl 0xe0(%ebx) 1093ab: 8d 53 30 lea 0x30(%ebx),%edx 1093ae: 52 push %edx 1093af: ff d0 call *%eax tty->tty_rcvwakeup = 1; 1093b1: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) 1093b8: 00 00 00 1093bb: e9 dd 01 00 00 jmp 10959d } return 0; } while (len--) { c = *buf++; 1093c0: 8a 0f mov (%edi),%cl 1093c2: 88 4d de mov %cl,-0x22(%ebp) 1093c5: 47 inc %edi /* FIXME: implement IXANY: any character restarts output */ /* if incoming XON/XOFF controls outgoing stream: */ if (tty->flow_ctrl & FL_MDXON) { 1093c6: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1093cc: f6 c4 02 test $0x2,%ah 1093cf: 74 46 je 109417 /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { 1093d1: 0f be c1 movsbl %cl,%eax 1093d4: 0f b6 53 4a movzbl 0x4a(%ebx),%edx 1093d8: 39 d0 cmp %edx,%eax 1093da: 75 28 jne 109404 if (c == tty->termios.c_cc[VSTART]) { 1093dc: 0f b6 53 49 movzbl 0x49(%ebx),%edx 1093e0: 39 d0 cmp %edx,%eax 1093e2: 75 0b jne 1093ef <== ALWAYS TAKEN /* received VSTOP and VSTART==VSTOP? */ /* then toggle "stop output" status */ tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; 1093e4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1093ea: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED 1093ed: eb 09 jmp 1093f8 <== NOT EXECUTED } else { /* VSTOP received (other code than VSTART) */ /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; 1093ef: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1093f5: 83 c8 10 or $0x10,%eax 1093f8: 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) { 1093fe: c6 45 df 01 movb $0x1,-0x21(%ebp) 109402: eb 19 jmp 10941d /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; } flow_rcv = true; } else if (c == tty->termios.c_cc[VSTART]) { 109404: 0f b6 53 49 movzbl 0x49(%ebx),%edx 109408: 39 d0 cmp %edx,%eax 10940a: 75 0b jne 109417 <== ALWAYS TAKEN /* VSTART received */ /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; 10940c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109412: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED 109415: eb e1 jmp 1093f8 <== NOT EXECUTED flow_rcv = true; } } if (flow_rcv) { 109417: 80 7d df 00 cmpb $0x0,-0x21(%ebp) 10941b: 74 51 je 10946e <== ALWAYS TAKEN /* restart output according to FL_ORCVXOF flag */ if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) { 10941d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109423: 83 e0 30 and $0x30,%eax 109426: 83 f8 20 cmp $0x20,%eax 109429: 0f 85 53 01 00 00 jne 109582 <== ALWAYS TAKEN /* disable interrupts */ rtems_interrupt_disable(level); 10942f: 9c pushf <== NOT EXECUTED 109430: fa cli <== NOT EXECUTED 109431: 8f 45 e4 popl -0x1c(%ebp) <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 109434: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10943a: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 10943d: 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) { 109443: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 10944a: 74 19 je 109465 <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1); 10944c: 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)( 109452: 52 push %edx <== NOT EXECUTED 109453: 6a 01 push $0x1 <== NOT EXECUTED 109455: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 109458: 50 push %eax <== NOT EXECUTED 109459: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10945c: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 109462: 83 c4 10 add $0x10,%esp <== NOT EXECUTED tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1); } /* reenable interrupts */ rtems_interrupt_enable(level); 109465: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 109468: 9d popf <== NOT EXECUTED 109469: e9 14 01 00 00 jmp 109582 <== NOT EXECUTED } } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; 10946e: 8b 43 60 mov 0x60(%ebx),%eax 109471: 8b 4b 64 mov 0x64(%ebx),%ecx 109474: 40 inc %eax 109475: 31 d2 xor %edx,%edx 109477: f7 f1 div %ecx 109479: 89 55 e4 mov %edx,-0x1c(%ebp) /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); 10947c: 9c pushf 10947d: fa cli 10947e: 8f 45 d8 popl -0x28(%ebp) if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 109481: 8b 53 5c mov 0x5c(%ebx),%edx 109484: 8b 43 64 mov 0x64(%ebx),%eax % tty->rawInBuf.Size) > tty->highwater) && 109487: 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) 10948a: 29 d0 sub %edx,%eax 10948c: 03 45 e4 add -0x1c(%ebp),%eax % tty->rawInBuf.Size) > tty->highwater) && 10948f: 31 d2 xor %edx,%edx 109491: 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) 109493: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx 109499: 0f 86 98 00 00 00 jbe 109537 <== ALWAYS TAKEN % tty->rawInBuf.Size) > tty->highwater) && !(tty->flow_ctrl & FL_IREQXOF)) { 10949f: 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) && 1094a5: a8 01 test $0x1,%al <== NOT EXECUTED 1094a7: 0f 85 8a 00 00 00 jne 109537 <== NOT EXECUTED !(tty->flow_ctrl & FL_IREQXOF)) { /* incoming data stream should be stopped */ tty->flow_ctrl |= FL_IREQXOF; 1094ad: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1094b3: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 1094b6: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF)) 1094bc: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1094c2: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED 1094c7: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED 1094cc: 75 33 jne 109501 <== NOT EXECUTED == (FL_MDXOF ) ) { if ((tty->flow_ctrl & FL_OSTOP) || 1094ce: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1094d4: a8 20 test $0x20,%al <== NOT EXECUTED 1094d6: 75 09 jne 1094e1 <== NOT EXECUTED 1094d8: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 1094df: 75 56 jne 109537 <== 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; 1094e1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1094e7: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 1094ea: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED (*tty->device.write)(tty->minor, 1094f0: 51 push %ecx <== NOT EXECUTED 1094f1: 6a 01 push $0x1 <== NOT EXECUTED 1094f3: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED 1094f6: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1094f9: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 1094ff: eb 33 jmp 109534 <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTOP]), 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) { 109501: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109507: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED 10950c: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED 109511: 75 24 jne 109537 <== NOT EXECUTED tty->flow_ctrl |= FL_IRTSOFF; 109513: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109519: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 10951c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* deactivate RTS line */ if (tty->device.stopRemoteTx != NULL) { 109522: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED 109528: 85 c0 test %eax,%eax <== NOT EXECUTED 10952a: 74 0b je 109537 <== NOT EXECUTED tty->device.stopRemoteTx(tty->minor); 10952c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10952f: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109532: ff d0 call *%eax <== NOT EXECUTED 109534: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } } /* reenable interrupts */ rtems_interrupt_enable(level); 109537: ff 75 d8 pushl -0x28(%ebp) 10953a: 9d popf if (newTail == tty->rawInBuf.Head) { 10953b: 8b 43 5c mov 0x5c(%ebx),%eax 10953e: 39 45 e4 cmp %eax,-0x1c(%ebp) 109541: 75 03 jne 109546 <== ALWAYS TAKEN dropped++; 109543: 46 inc %esi <== NOT EXECUTED 109544: eb 3c jmp 109582 <== NOT EXECUTED } else { tty->rawInBuf.theBuf[newTail] = c; 109546: 8b 43 58 mov 0x58(%ebx),%eax 109549: 8a 4d de mov -0x22(%ebp),%cl 10954c: 8b 55 e4 mov -0x1c(%ebp),%edx 10954f: 88 0c 10 mov %cl,(%eax,%edx,1) tty->rawInBuf.Tail = newTail; 109552: 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 )) { 109555: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx) 10955c: 75 24 jne 109582 <== NEVER TAKEN 10955e: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax 109564: 85 c0 test %eax,%eax 109566: 74 1a je 109582 <== ALWAYS TAKEN (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 109568: 52 push %edx <== NOT EXECUTED 109569: 52 push %edx <== NOT EXECUTED 10956a: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED 109570: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 109573: ff d0 call *%eax <== NOT EXECUTED tty->tty_rcvwakeup = 1; 109575: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED 10957c: 00 00 00 10957f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109582: ff 4d e0 decl -0x20(%ebp) tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 109585: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) 109589: 0f 85 31 fe ff ff jne 1093c0 } } } } tty->rawInBufDropped += dropped; 10958f: 01 73 78 add %esi,0x78(%ebx) rtems_semaphore_release (tty->rawInBuf.Semaphore); 109592: 83 ec 0c sub $0xc,%esp 109595: ff 73 68 pushl 0x68(%ebx) 109598: e8 b7 0c 00 00 call 10a254 return dropped; 10959d: 83 c4 10 add $0x10,%esp } 1095a0: 89 f0 mov %esi,%eax 1095a2: 8d 65 f4 lea -0xc(%ebp),%esp 1095a5: 5b pop %ebx 1095a6: 5e pop %esi 1095a7: 5f pop %edi 1095a8: c9 leave 1095a9: c3 ret =============================================================================== 001086b2 : } } rtems_status_code rtems_termios_ioctl (void *arg) { 1086b2: 55 push %ebp 1086b3: 89 e5 mov %esp,%ebp 1086b5: 57 push %edi 1086b6: 56 push %esi 1086b7: 53 push %ebx 1086b8: 83 ec 20 sub $0x20,%esp rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 1086bb: 8b 55 08 mov 0x8(%ebp),%edx 1086be: 8b 02 mov (%edx),%eax 1086c0: 8b 58 34 mov 0x34(%eax),%ebx struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer; 1086c3: 8b 72 08 mov 0x8(%edx),%esi rtems_status_code sc; args->ioctl_return = 0; 1086c6: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 1086cd: 6a 00 push $0x0 1086cf: 6a 00 push $0x0 1086d1: ff 73 18 pushl 0x18(%ebx) 1086d4: e8 8f 1a 00 00 call 10a168 1086d9: 89 45 e4 mov %eax,-0x1c(%ebp) if (sc != RTEMS_SUCCESSFUL) { 1086dc: 83 c4 10 add $0x10,%esp 1086df: 85 c0 test %eax,%eax 1086e1: 74 0b je 1086ee <== ALWAYS TAKEN args->ioctl_return = sc; 1086e3: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1086e6: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED return sc; 1086e9: e9 05 03 00 00 jmp 1089f3 <== NOT EXECUTED } switch (args->command) { 1086ee: 8b 55 08 mov 0x8(%ebp),%edx 1086f1: 8b 42 04 mov 0x4(%edx),%eax 1086f4: 83 f8 04 cmp $0x4,%eax 1086f7: 0f 84 4d 02 00 00 je 10894a 1086fd: 77 10 ja 10870f 1086ff: 83 f8 02 cmp $0x2,%eax 108702: 74 77 je 10877b 108704: 0f 87 1e 02 00 00 ja 108928 10870a: 48 dec %eax 10870b: 75 2f jne 10873c <== NEVER TAKEN 10870d: eb 55 jmp 108764 10870f: 3d 7f 66 04 40 cmp $0x4004667f,%eax 108714: 0f 84 a5 02 00 00 je 1089bf <== NEVER TAKEN 10871a: 77 0a ja 108726 10871c: 83 f8 05 cmp $0x5,%eax 10871f: 75 1b jne 10873c 108721: e9 0e 02 00 00 jmp 108934 108726: 3d 1a 74 04 40 cmp $0x4004741a,%eax 10872b: 0f 84 7e 02 00 00 je 1089af 108731: 3d 1b 74 04 80 cmp $0x8004741b,%eax 108736: 0f 84 21 02 00 00 je 10895d <== ALWAYS TAKEN default: if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) { 10873c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 108742: c1 e0 05 shl $0x5,%eax 108745: 8b 80 ec 4e 12 00 mov 0x124eec(%eax),%eax sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args); } else { sc = RTEMS_INVALID_NUMBER; 10874b: 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) { 108752: 85 c0 test %eax,%eax 108754: 0f 84 82 02 00 00 je 1089dc <== NEVER TAKEN sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args); 10875a: 52 push %edx 10875b: 52 push %edx 10875c: ff 75 08 pushl 0x8(%ebp) 10875f: e9 40 02 00 00 jmp 1089a4 sc = RTEMS_INVALID_NUMBER; } break; case RTEMS_IO_GET_ATTRIBUTES: *(struct termios *)args->buffer = tty->termios; 108764: 8b 4d 08 mov 0x8(%ebp),%ecx 108767: 8b 41 08 mov 0x8(%ecx),%eax 10876a: 8d 73 30 lea 0x30(%ebx),%esi 10876d: b9 09 00 00 00 mov $0x9,%ecx 108772: 89 c7 mov %eax,%edi 108774: f3 a5 rep movsl %ds:(%esi),%es:(%edi) break; 108776: e9 61 02 00 00 jmp 1089dc case RTEMS_IO_SET_ATTRIBUTES: tty->termios = *(struct termios *)args->buffer; 10877b: 8b 45 08 mov 0x8(%ebp),%eax 10877e: 8b 70 08 mov 0x8(%eax),%esi 108781: 8d 7b 30 lea 0x30(%ebx),%edi 108784: b9 09 00 00 00 mov $0x9,%ecx 108789: 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) && 10878b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108791: f6 c4 02 test $0x2,%ah 108794: 74 57 je 1087ed 108796: f6 43 31 04 testb $0x4,0x31(%ebx) 10879a: 75 51 jne 1087ed <== ALWAYS TAKEN !(tty->termios.c_iflag & IXON)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF); 10879c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1087a2: 25 ef fd ff ff and $0xfffffdef,%eax <== NOT EXECUTED 1087a7: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* has output been stopped due to received XOFF? */ if (tty->flow_ctrl & FL_OSTOP) { 1087ad: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1087b3: a8 20 test $0x20,%al <== NOT EXECUTED 1087b5: 74 36 je 1087ed <== NOT EXECUTED /* disable interrupts */ rtems_interrupt_disable(level); 1087b7: 9c pushf <== NOT EXECUTED 1087b8: fa cli <== NOT EXECUTED 1087b9: 5e pop %esi <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 1087ba: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1087c0: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 1087c3: 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) { 1087c9: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 1087d0: 74 19 je 1087eb <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)( tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 1087d2: 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)( 1087d8: 57 push %edi <== NOT EXECUTED 1087d9: 6a 01 push $0x1 <== NOT EXECUTED 1087db: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 1087de: 50 push %eax <== NOT EXECUTED 1087df: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1087e2: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 1087e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } /* reenable interrupts */ rtems_interrupt_enable(level); 1087eb: 56 push %esi <== NOT EXECUTED 1087ec: 9d popf <== NOT EXECUTED } } /* check for incoming XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) { 1087ed: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1087f3: f6 c4 04 test $0x4,%ah 1087f6: 74 24 je 10881c <== ALWAYS TAKEN 1087f8: f6 43 31 10 testb $0x10,0x31(%ebx) <== NOT EXECUTED 1087fc: 75 1e jne 10881c <== NOT EXECUTED /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXOF); 1087fe: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108804: 80 e4 fb and $0xfb,%ah <== NOT EXECUTED 108807: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* FIXME: what happens, if we had sent XOFF but not yet XON? */ tty->flow_ctrl &= ~(FL_ISNTXOF); 10880d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108813: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 108816: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } /* check for incoming RTS/CTS flow control switched off */ if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) { 10881c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108822: f6 c4 01 test $0x1,%ah 108825: 74 43 je 10886a <== ALWAYS TAKEN 108827: 83 7b 38 00 cmpl $0x0,0x38(%ebx) <== NOT EXECUTED 10882b: 78 3d js 10886a <== NOT EXECUTED /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDRTS); 10882d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108833: 80 e4 fe and $0xfe,%ah <== NOT EXECUTED 108836: 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)) { 10883c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108842: a8 04 test $0x4,%al <== NOT EXECUTED 108844: 74 15 je 10885b <== NOT EXECUTED 108846: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 10884c: 85 c0 test %eax,%eax <== NOT EXECUTED 10884e: 74 0b je 10885b <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 108850: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108853: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108856: ff d0 call *%eax <== NOT EXECUTED 108858: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } tty->flow_ctrl &= ~(FL_IRTSOFF); 10885b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108861: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 108864: 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) { 10886a: 83 7b 38 00 cmpl $0x0,0x38(%ebx) 10886e: 79 0f jns 10887f <== ALWAYS TAKEN tty->flow_ctrl |= FL_MDRTS; 108870: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108876: 80 cc 01 or $0x1,%ah <== NOT EXECUTED 108879: 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) { 10887f: 8b 53 30 mov 0x30(%ebx),%edx 108882: f6 c6 10 test $0x10,%dh 108885: 74 0f je 108896 tty->flow_ctrl |= FL_MDXOF; 108887: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10888d: 80 cc 04 or $0x4,%ah 108890: 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) { 108896: 80 e6 04 and $0x4,%dh 108899: 74 0f je 1088aa <== NEVER TAKEN tty->flow_ctrl |= FL_MDXON; 10889b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1088a1: 80 cc 02 or $0x2,%ah 1088a4: 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) { 1088aa: f6 43 3c 02 testb $0x2,0x3c(%ebx) 1088ae: 75 39 jne 1088e9 tty->rawInBufSemaphoreOptions = RTEMS_WAIT; tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { tty->vtimeTicks = tty->termios.c_cc[VTIME] * 1088b0: 0f b6 73 46 movzbl 0x46(%ebx),%esi rtems_clock_get_ticks_per_second() / 10; 1088b4: e8 6f 12 00 00 call 109b28 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] * 1088b9: 0f af c6 imul %esi,%eax rtems_clock_get_ticks_per_second() / 10; 1088bc: b9 0a 00 00 00 mov $0xa,%ecx 1088c1: 31 d2 xor %edx,%edx 1088c3: 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] * 1088c5: 89 43 54 mov %eax,0x54(%ebx) rtems_clock_get_ticks_per_second() / 10; if (tty->termios.c_cc[VTIME]) { 1088c8: 80 7b 46 00 cmpb $0x0,0x46(%ebx) 1088cc: 74 15 je 1088e3 tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 1088ce: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) tty->rawInBufSemaphoreTimeout = tty->vtimeTicks; 1088d5: 89 43 70 mov %eax,0x70(%ebx) if (tty->termios.c_cc[VMIN]) 1088d8: 80 7b 47 00 cmpb $0x0,0x47(%ebx) 1088dc: 75 19 jne 1088f7 tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; 1088de: 89 43 74 mov %eax,0x74(%ebx) 1088e1: eb 24 jmp 108907 } else { if (tty->termios.c_cc[VMIN]) { 1088e3: 80 7b 47 00 cmpb $0x0,0x47(%ebx) 1088e7: 74 17 je 108900 <== ALWAYS TAKEN tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 1088e9: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; 1088f0: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; 1088f7: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx) 1088fe: eb 07 jmp 108907 } else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; 108900: c7 43 6c 01 00 00 00 movl $0x1,0x6c(%ebx) } } } if (tty->device.setAttributes) 108907: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax 10890d: 85 c0 test %eax,%eax 10890f: 0f 84 c7 00 00 00 je 1089dc <== NEVER TAKEN (*tty->device.setAttributes)(tty->minor, &tty->termios); 108915: 56 push %esi 108916: 56 push %esi 108917: 8d 53 30 lea 0x30(%ebx),%edx 10891a: 52 push %edx 10891b: ff 73 10 pushl 0x10(%ebx) 10891e: ff d0 call *%eax 108920: 83 c4 10 add $0x10,%esp 108923: e9 b4 00 00 00 jmp 1089dc break; case RTEMS_IO_TCDRAIN: drainOutput (tty); 108928: 89 d8 mov %ebx,%eax 10892a: e8 55 f7 ff ff call 108084 break; 10892f: e9 a8 00 00 00 jmp 1089dc case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; 108934: 8b 06 mov (%esi),%eax 108936: 8b 56 04 mov 0x4(%esi),%edx 108939: 89 83 d4 00 00 00 mov %eax,0xd4(%ebx) 10893f: 89 93 d8 00 00 00 mov %edx,0xd8(%ebx) break; 108945: e9 92 00 00 00 jmp 1089dc case RTEMS_IO_RCVWAKEUP: tty->tty_rcv = *wakeup; 10894a: 8b 06 mov (%esi),%eax 10894c: 8b 56 04 mov 0x4(%esi),%edx 10894f: 89 83 dc 00 00 00 mov %eax,0xdc(%ebx) 108955: 89 93 e0 00 00 00 mov %edx,0xe0(%ebx) break; 10895b: eb 7f jmp 1089dc #if 1 /* FIXME */ case TIOCSETD: /* * close old line discipline */ if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 10895d: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 108963: c1 e0 05 shl $0x5,%eax 108966: 8b 80 d8 4e 12 00 mov 0x124ed8(%eax),%eax 10896c: 85 c0 test %eax,%eax 10896e: 74 0c je 10897c sc = rtems_termios_linesw[tty->t_line].l_close(tty); 108970: 83 ec 0c sub $0xc,%esp 108973: 53 push %ebx 108974: ff d0 call *%eax 108976: 89 45 e4 mov %eax,-0x1c(%ebp) 108979: 83 c4 10 add $0x10,%esp } tty->t_line=*(int*)(args->buffer); 10897c: 8b 55 08 mov 0x8(%ebp),%edx 10897f: 8b 42 08 mov 0x8(%edx),%eax 108982: 8b 00 mov (%eax),%eax 108984: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx) tty->t_sc = NULL; /* ensure that no more valid data */ 10898a: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx) 108991: 00 00 00 /* * open new line discipline */ if (rtems_termios_linesw[tty->t_line].l_open != NULL) { 108994: c1 e0 05 shl $0x5,%eax 108997: 8b 80 d4 4e 12 00 mov 0x124ed4(%eax),%eax 10899d: 85 c0 test %eax,%eax 10899f: 74 3b je 1089dc <== NEVER TAKEN sc = rtems_termios_linesw[tty->t_line].l_open(tty); 1089a1: 83 ec 0c sub $0xc,%esp 1089a4: 53 push %ebx 1089a5: ff d0 call *%eax 1089a7: 89 45 e4 mov %eax,-0x1c(%ebp) 1089aa: e9 71 ff ff ff jmp 108920 } break; case TIOCGETD: *(int*)(args->buffer)=tty->t_line; 1089af: 8b 4d 08 mov 0x8(%ebp),%ecx 1089b2: 8b 41 08 mov 0x8(%ecx),%eax 1089b5: 8b 93 cc 00 00 00 mov 0xcc(%ebx),%edx 1089bb: 89 10 mov %edx,(%eax) break; 1089bd: eb 1d jmp 1089dc #endif case FIONREAD: { int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head; 1089bf: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED 1089c2: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED if ( rawnc < 0 ) 1089c5: 29 d0 sub %edx,%eax <== NOT EXECUTED 1089c7: 79 05 jns 1089ce <== NOT EXECUTED rawnc += tty->rawInBuf.Size; 1089c9: 8b 53 64 mov 0x64(%ebx),%edx <== NOT EXECUTED 1089cc: 01 d0 add %edx,%eax <== NOT EXECUTED /* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; 1089ce: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1089d1: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED 1089d4: 03 43 20 add 0x20(%ebx),%eax <== NOT EXECUTED 1089d7: 2b 43 24 sub 0x24(%ebx),%eax <== NOT EXECUTED 1089da: 89 02 mov %eax,(%edx) <== NOT EXECUTED } break; } rtems_semaphore_release (tty->osem); 1089dc: 83 ec 0c sub $0xc,%esp 1089df: ff 73 18 pushl 0x18(%ebx) 1089e2: e8 6d 18 00 00 call 10a254 args->ioctl_return = sc; 1089e7: 8b 55 e4 mov -0x1c(%ebp),%edx 1089ea: 8b 45 08 mov 0x8(%ebp),%eax 1089ed: 89 50 0c mov %edx,0xc(%eax) return sc; 1089f0: 83 c4 10 add $0x10,%esp } 1089f3: 8b 45 e4 mov -0x1c(%ebp),%eax 1089f6: 8d 65 f4 lea -0xc(%ebp),%esp 1089f9: 5b pop %ebx 1089fa: 5e pop %esi 1089fb: 5f pop %edi 1089fc: c9 leave 1089fd: c3 ret =============================================================================== 001080e1 : rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) { 1080e1: 55 push %ebp 1080e2: 89 e5 mov %esp,%ebp 1080e4: 57 push %edi 1080e5: 56 push %esi 1080e6: 53 push %ebx 1080e7: 83 ec 20 sub $0x20,%esp struct rtems_termios_tty *tty; /* * See if the device has already been opened */ sc = rtems_semaphore_obtain( 1080ea: 6a 00 push $0x0 1080ec: 6a 00 push $0x0 1080ee: ff 35 1c 52 12 00 pushl 0x12521c 1080f4: e8 6f 20 00 00 call 10a168 1080f9: 89 45 e4 mov %eax,-0x1c(%ebp) rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 1080fc: 83 c4 10 add $0x10,%esp 1080ff: 85 c0 test %eax,%eax 108101: 0f 85 d3 03 00 00 jne 1084da <== NEVER TAKEN return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 108107: 8b 35 24 52 12 00 mov 0x125224,%esi 10810d: 89 f2 mov %esi,%edx 10810f: eb 16 jmp 108127 if ((tty->major == major) && (tty->minor == minor)) 108111: 8b 45 08 mov 0x8(%ebp),%eax 108114: 39 42 0c cmp %eax,0xc(%edx) 108117: 75 0c jne 108125 108119: 8b 4d 0c mov 0xc(%ebp),%ecx 10811c: 39 4a 10 cmp %ecx,0x10(%edx) 10811f: 0f 84 26 03 00 00 je 10844b <== 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) { 108125: 8b 12 mov (%edx),%edx 108127: 85 d2 test %edx,%edx 108129: 75 e6 jne 108111 10812b: e9 b5 03 00 00 jmp 1084e5 /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); if (tty == NULL) { rtems_semaphore_release (rtems_termios_ttyMutex); 108130: 83 ec 0c sub $0xc,%esp 108133: eb 30 jmp 108165 return RTEMS_NO_MEMORY; } /* * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; 108135: a1 54 30 12 00 mov 0x123054,%eax 10813a: 89 42 64 mov %eax,0x64(%edx) tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size); 10813d: 8b 42 64 mov 0x64(%edx),%eax 108140: 83 ec 0c sub $0xc,%esp 108143: 50 push %eax 108144: 89 55 e0 mov %edx,-0x20(%ebp) 108147: e8 98 f4 ff ff call 1075e4 10814c: 89 c7 mov %eax,%edi 10814e: 8b 55 e0 mov -0x20(%ebp),%edx 108151: 89 42 58 mov %eax,0x58(%edx) if (tty->rawInBuf.theBuf == NULL) { 108154: 83 c4 10 add $0x10,%esp 108157: 85 c0 test %eax,%eax 108159: 75 24 jne 10817f free(tty); 10815b: 83 ec 0c sub $0xc,%esp 10815e: 52 push %edx 10815f: e8 e4 f1 ff ff call 107348 rtems_semaphore_release (rtems_termios_ttyMutex); 108164: 5b pop %ebx 108165: ff 35 1c 52 12 00 pushl 0x12521c 10816b: e8 e4 20 00 00 call 10a254 return RTEMS_NO_MEMORY; 108170: 83 c4 10 add $0x10,%esp 108173: c7 45 e4 1a 00 00 00 movl $0x1a,-0x1c(%ebp) 10817a: e9 5b 03 00 00 jmp 1084da } /* * allocate raw output buffer */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; 10817f: a1 58 30 12 00 mov 0x123058,%eax 108184: 89 82 88 00 00 00 mov %eax,0x88(%edx) tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size); 10818a: 8b 82 88 00 00 00 mov 0x88(%edx),%eax 108190: 83 ec 0c sub $0xc,%esp 108193: 50 push %eax 108194: 89 55 e0 mov %edx,-0x20(%ebp) 108197: e8 48 f4 ff ff call 1075e4 10819c: 8b 55 e0 mov -0x20(%ebp),%edx 10819f: 89 42 7c mov %eax,0x7c(%edx) if (tty->rawOutBuf.theBuf == NULL) { 1081a2: 83 c4 10 add $0x10,%esp 1081a5: 85 c0 test %eax,%eax 1081a7: 75 05 jne 1081ae <== ALWAYS TAKEN free((void *)(tty->rawInBuf.theBuf)); 1081a9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1081ac: eb 2e jmp 1081dc <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); 1081ae: 83 ec 0c sub $0xc,%esp 1081b1: ff 35 50 30 12 00 pushl 0x123050 1081b7: 89 55 e0 mov %edx,-0x20(%ebp) 1081ba: 89 45 dc mov %eax,-0x24(%ebp) 1081bd: e8 22 f4 ff ff call 1075e4 1081c2: 8b 55 e0 mov -0x20(%ebp),%edx 1081c5: 89 42 1c mov %eax,0x1c(%edx) if (tty->cbuf == NULL) { 1081c8: 83 c4 10 add $0x10,%esp 1081cb: 85 c0 test %eax,%eax 1081cd: 8b 4d dc mov -0x24(%ebp),%ecx 1081d0: 75 19 jne 1081eb free((void *)(tty->rawOutBuf.theBuf)); 1081d2: 83 ec 0c sub $0xc,%esp 1081d5: 51 push %ecx 1081d6: e8 6d f1 ff ff call 107348 free((void *)(tty->rawInBuf.theBuf)); 1081db: 59 pop %ecx 1081dc: 57 push %edi 1081dd: e8 66 f1 ff ff call 107348 free(tty); 1081e2: 5a pop %edx 1081e3: 8b 55 e0 mov -0x20(%ebp),%edx 1081e6: e9 73 ff ff ff jmp 10815e return RTEMS_NO_MEMORY; } /* * Initialize wakeup callbacks */ tty->tty_snd.sw_pfn = NULL; 1081eb: c7 82 d4 00 00 00 00 movl $0x0,0xd4(%edx) 1081f2: 00 00 00 tty->tty_snd.sw_arg = NULL; 1081f5: c7 82 d8 00 00 00 00 movl $0x0,0xd8(%edx) 1081fc: 00 00 00 tty->tty_rcv.sw_pfn = NULL; 1081ff: c7 82 dc 00 00 00 00 movl $0x0,0xdc(%edx) 108206: 00 00 00 tty->tty_rcv.sw_arg = NULL; 108209: c7 82 e0 00 00 00 00 movl $0x0,0xe0(%edx) 108210: 00 00 00 tty->tty_rcvwakeup = 0; 108213: c7 82 e4 00 00 00 00 movl $0x0,0xe4(%edx) 10821a: 00 00 00 /* * link tty */ tty->forw = rtems_termios_ttyHead; 10821d: 89 32 mov %esi,(%edx) tty->back = NULL; 10821f: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) if (rtems_termios_ttyHead != NULL) 108226: 85 f6 test %esi,%esi 108228: 74 03 je 10822d rtems_termios_ttyHead->back = tty; 10822a: 89 56 04 mov %edx,0x4(%esi) rtems_termios_ttyHead = tty; 10822d: 89 1d 24 52 12 00 mov %ebx,0x125224 if (rtems_termios_ttyTail == NULL) 108233: 83 3d 20 52 12 00 00 cmpl $0x0,0x125220 10823a: 75 06 jne 108242 rtems_termios_ttyTail = tty; 10823c: 89 1d 20 52 12 00 mov %ebx,0x125220 tty->minor = minor; 108242: 8b 45 0c mov 0xc(%ebp),%eax 108245: 89 43 10 mov %eax,0x10(%ebx) tty->major = major; 108248: 8b 4d 08 mov 0x8(%ebp),%ecx 10824b: 89 4b 0c mov %ecx,0xc(%ebx) /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 10824e: 83 ec 0c sub $0xc,%esp 108251: 8d 43 14 lea 0x14(%ebx),%eax 108254: 50 push %eax 108255: 6a 00 push $0x0 108257: 6a 54 push $0x54 108259: 6a 01 push $0x1 rtems_build_name ('T', 'R', 'i', c), 10825b: 0f be 05 5c 30 12 00 movsbl 0x12305c,%eax tty->major = major; /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 108262: 0d 00 69 52 54 or $0x54526900,%eax 108267: 50 push %eax 108268: 89 55 e0 mov %edx,-0x20(%ebp) 10826b: e8 d0 1c 00 00 call 109f40 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) 108270: 83 c4 20 add $0x20,%esp 108273: 85 c0 test %eax,%eax 108275: 8b 55 e0 mov -0x20(%ebp),%edx 108278: 0f 85 42 02 00 00 jne 1084c0 rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 10827e: 83 ec 0c sub $0xc,%esp 108281: 8d 43 18 lea 0x18(%ebx),%eax 108284: 50 push %eax 108285: 6a 00 push $0x0 108287: 6a 54 push $0x54 108289: 6a 01 push $0x1 rtems_build_name ('T', 'R', 'o', c), 10828b: 0f be 05 5c 30 12 00 movsbl 0x12305c,%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 ( 108292: 0d 00 6f 52 54 or $0x54526f00,%eax 108297: 50 push %eax 108298: 89 55 e0 mov %edx,-0x20(%ebp) 10829b: e8 a0 1c 00 00 call 109f40 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) 1082a0: 83 c4 20 add $0x20,%esp 1082a3: 85 c0 test %eax,%eax 1082a5: 8b 55 e0 mov -0x20(%ebp),%edx 1082a8: 0f 85 12 02 00 00 jne 1084c0 rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 1082ae: 83 ec 0c sub $0xc,%esp 1082b1: 8d 83 8c 00 00 00 lea 0x8c(%ebx),%eax 1082b7: 50 push %eax 1082b8: 6a 00 push $0x0 1082ba: 6a 20 push $0x20 1082bc: 6a 00 push $0x0 rtems_build_name ('T', 'R', 'x', c), 1082be: 0f be 05 5c 30 12 00 movsbl 0x12305c,%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 ( 1082c5: 0d 00 78 52 54 or $0x54527800,%eax 1082ca: 50 push %eax 1082cb: 89 55 e0 mov %edx,-0x20(%ebp) 1082ce: e8 6d 1c 00 00 call 109f40 rtems_build_name ('T', 'R', 'x', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO, RTEMS_NO_PRIORITY, &tty->rawOutBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 1082d3: 83 c4 20 add $0x20,%esp 1082d6: 85 c0 test %eax,%eax 1082d8: 8b 55 e0 mov -0x20(%ebp),%edx 1082db: 0f 85 df 01 00 00 jne 1084c0 rtems_fatal_error_occurred (sc); tty->rawOutBufState = rob_idle; 1082e1: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx) 1082e8: 00 00 00 /* * Set callbacks */ tty->device = *callbacks; 1082eb: 8d bb 98 00 00 00 lea 0x98(%ebx),%edi 1082f1: b9 08 00 00 00 mov $0x8,%ecx 1082f6: 8b 75 14 mov 0x14(%ebp),%esi 1082f9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 1082fb: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 108302: 75 74 jne 108378 sc = rtems_task_create ( 108304: 50 push %eax 108305: 50 push %eax 108306: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax 10830c: 50 push %eax 10830d: 6a 00 push $0x0 10830f: 68 00 05 00 00 push $0x500 108314: 68 00 04 00 00 push $0x400 108319: 6a 0a push $0xa rtems_build_name ('T', 'x', 'T', c), 10831b: 0f be 05 5c 30 12 00 movsbl 0x12305c,%eax /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { sc = rtems_task_create ( 108322: 0d 00 54 78 54 or $0x54785400,%eax 108327: 50 push %eax 108328: 89 55 e0 mov %edx,-0x20(%ebp) 10832b: e8 b4 1f 00 00 call 10a2e4 TERMIOS_TXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->txTaskId); if (sc != RTEMS_SUCCESSFUL) 108330: 83 c4 20 add $0x20,%esp 108333: 85 c0 test %eax,%eax 108335: 8b 55 e0 mov -0x20(%ebp),%edx 108338: 0f 85 82 01 00 00 jne 1084c0 <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_task_create ( 10833e: 57 push %edi 10833f: 57 push %edi 108340: 8d 83 c4 00 00 00 lea 0xc4(%ebx),%eax 108346: 50 push %eax 108347: 6a 00 push $0x0 108349: 68 00 05 00 00 push $0x500 10834e: 68 00 04 00 00 push $0x400 108353: 6a 09 push $0x9 rtems_build_name ('R', 'x', 'T', c), 108355: 0f be 05 5c 30 12 00 movsbl 0x12305c,%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 ( 10835c: 0d 00 54 78 52 or $0x52785400,%eax 108361: 50 push %eax 108362: 89 55 e0 mov %edx,-0x20(%ebp) 108365: e8 7a 1f 00 00 call 10a2e4 TERMIOS_RXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->rxTaskId); if (sc != RTEMS_SUCCESSFUL) 10836a: 83 c4 20 add $0x20,%esp 10836d: 85 c0 test %eax,%eax 10836f: 8b 55 e0 mov -0x20(%ebp),%edx 108372: 0f 85 48 01 00 00 jne 1084c0 <== NEVER TAKEN rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || 108378: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx) 10837f: 74 09 je 10838a 108381: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 108388: 75 30 jne 1083ba (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 10838a: 83 ec 0c sub $0xc,%esp 10838d: 8d 43 68 lea 0x68(%ebx),%eax 108390: 50 push %eax 108391: 6a 00 push $0x0 108393: 6a 24 push $0x24 108395: 6a 00 push $0x0 rtems_build_name ('T', 'R', 'r', c), 108397: 0f be 05 5c 30 12 00 movsbl 0x12305c,%eax rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 10839e: 0d 00 72 52 54 or $0x54527200,%eax 1083a3: 50 push %eax 1083a4: 89 55 e0 mov %edx,-0x20(%ebp) 1083a7: e8 94 1b 00 00 call 109f40 rtems_build_name ('T', 'R', 'r', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->rawInBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 1083ac: 83 c4 20 add $0x20,%esp 1083af: 85 c0 test %eax,%eax 1083b1: 8b 55 e0 mov -0x20(%ebp),%edx 1083b4: 0f 85 06 01 00 00 jne 1084c0 } /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; 1083ba: c7 43 30 02 25 00 00 movl $0x2502,0x30(%ebx) tty->termios.c_oflag = OPOST | ONLCR | XTABS; 1083c1: c7 43 34 05 18 00 00 movl $0x1805,0x34(%ebx) tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; 1083c8: c7 43 38 bd 08 00 00 movl $0x8bd,0x38(%ebx) tty->termios.c_lflag = 1083cf: c7 43 3c 3b 82 00 00 movl $0x823b,0x3c(%ebx) ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL; tty->termios.c_cc[VINTR] = '\003'; 1083d6: c6 43 41 03 movb $0x3,0x41(%ebx) tty->termios.c_cc[VQUIT] = '\034'; 1083da: c6 43 42 1c movb $0x1c,0x42(%ebx) tty->termios.c_cc[VERASE] = '\177'; 1083de: c6 43 43 7f movb $0x7f,0x43(%ebx) tty->termios.c_cc[VKILL] = '\025'; 1083e2: c6 43 44 15 movb $0x15,0x44(%ebx) tty->termios.c_cc[VEOF] = '\004'; 1083e6: c6 43 45 04 movb $0x4,0x45(%ebx) tty->termios.c_cc[VEOL] = '\000'; 1083ea: c6 43 4c 00 movb $0x0,0x4c(%ebx) tty->termios.c_cc[VEOL2] = '\000'; 1083ee: c6 43 51 00 movb $0x0,0x51(%ebx) tty->termios.c_cc[VSTART] = '\021'; 1083f2: c6 43 49 11 movb $0x11,0x49(%ebx) tty->termios.c_cc[VSTOP] = '\023'; 1083f6: c6 43 4a 13 movb $0x13,0x4a(%ebx) tty->termios.c_cc[VSUSP] = '\032'; 1083fa: c6 43 4b 1a movb $0x1a,0x4b(%ebx) tty->termios.c_cc[VREPRINT] = '\022'; 1083fe: c6 43 4d 12 movb $0x12,0x4d(%ebx) tty->termios.c_cc[VDISCARD] = '\017'; 108402: c6 43 4e 0f movb $0xf,0x4e(%ebx) tty->termios.c_cc[VWERASE] = '\027'; 108406: c6 43 4f 17 movb $0x17,0x4f(%ebx) tty->termios.c_cc[VLNEXT] = '\026'; 10840a: c6 43 50 16 movb $0x16,0x50(%ebx) /* start with no flow control, clear flow control flags */ tty->flow_ctrl = 0; 10840e: c7 83 b8 00 00 00 00 movl $0x0,0xb8(%ebx) 108415: 00 00 00 /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2; 108418: 8b 43 64 mov 0x64(%ebx),%eax 10841b: d1 e8 shr %eax 10841d: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) tty->highwater = tty->rawInBuf.Size * 3/4; 108423: 8b 43 64 mov 0x64(%ebx),%eax 108426: 8d 04 40 lea (%eax,%eax,2),%eax 108429: c1 e8 02 shr $0x2,%eax 10842c: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx) /* * Bump name characer */ if (c++ == 'z') 108432: a0 5c 30 12 00 mov 0x12305c,%al 108437: 8d 48 01 lea 0x1(%eax),%ecx 10843a: 88 0d 5c 30 12 00 mov %cl,0x12305c 108440: 3c 7a cmp $0x7a,%al 108442: 75 07 jne 10844b c = 'a'; 108444: c6 05 5c 30 12 00 61 movb $0x61,0x12305c } args->iop->data1 = tty; 10844b: 8b 4d 10 mov 0x10(%ebp),%ecx 10844e: 8b 01 mov (%ecx),%eax 108450: 89 50 34 mov %edx,0x34(%eax) if (!tty->refcount++) { 108453: 8b 42 08 mov 0x8(%edx),%eax 108456: 8d 48 01 lea 0x1(%eax),%ecx 108459: 89 4a 08 mov %ecx,0x8(%edx) 10845c: 85 c0 test %eax,%eax 10845e: 75 69 jne 1084c9 if (tty->device.firstOpen) 108460: 8b 82 98 00 00 00 mov 0x98(%edx),%eax 108466: 85 c0 test %eax,%eax 108468: 74 15 je 10847f (*tty->device.firstOpen)(major, minor, arg); 10846a: 56 push %esi 10846b: ff 75 10 pushl 0x10(%ebp) 10846e: ff 75 0c pushl 0xc(%ebp) 108471: ff 75 08 pushl 0x8(%ebp) 108474: 89 55 e0 mov %edx,-0x20(%ebp) 108477: ff d0 call *%eax 108479: 83 c4 10 add $0x10,%esp 10847c: 8b 55 e0 mov -0x20(%ebp),%edx /* * start I/O tasks, if needed */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 10847f: 83 ba b4 00 00 00 02 cmpl $0x2,0xb4(%edx) 108486: 75 41 jne 1084c9 sc = rtems_task_start( 108488: 53 push %ebx 108489: 52 push %edx 10848a: 68 aa 95 10 00 push $0x1095aa 10848f: ff b2 c4 00 00 00 pushl 0xc4(%edx) 108495: 89 55 e0 mov %edx,-0x20(%ebp) 108498: e8 bb 20 00 00 call 10a558 tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 10849d: 83 c4 10 add $0x10,%esp 1084a0: 85 c0 test %eax,%eax 1084a2: 8b 55 e0 mov -0x20(%ebp),%edx 1084a5: 75 19 jne 1084c0 <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_task_start( 1084a7: 51 push %ecx 1084a8: 52 push %edx 1084a9: 68 dc 97 10 00 push $0x1097dc 1084ae: ff b2 c8 00 00 00 pushl 0xc8(%edx) 1084b4: e8 9f 20 00 00 call 10a558 tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 1084b9: 83 c4 10 add $0x10,%esp 1084bc: 85 c0 test %eax,%eax 1084be: 74 09 je 1084c9 <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 1084c0: 83 ec 0c sub $0xc,%esp 1084c3: 50 push %eax 1084c4: e8 73 22 00 00 call 10a73c } } rtems_semaphore_release (rtems_termios_ttyMutex); 1084c9: 83 ec 0c sub $0xc,%esp 1084cc: ff 35 1c 52 12 00 pushl 0x12521c 1084d2: e8 7d 1d 00 00 call 10a254 return RTEMS_SUCCESSFUL; 1084d7: 83 c4 10 add $0x10,%esp } 1084da: 8b 45 e4 mov -0x1c(%ebp),%eax 1084dd: 8d 65 f4 lea -0xc(%ebp),%esp 1084e0: 5b pop %ebx 1084e1: 5e pop %esi 1084e2: 5f pop %edi 1084e3: c9 leave 1084e4: c3 ret static char c = 'a'; /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); 1084e5: 52 push %edx 1084e6: 52 push %edx 1084e7: 68 e8 00 00 00 push $0xe8 1084ec: 6a 01 push $0x1 1084ee: e8 e9 ec ff ff call 1071dc 1084f3: 89 c2 mov %eax,%edx 1084f5: 89 c3 mov %eax,%ebx if (tty == NULL) { 1084f7: 83 c4 10 add $0x10,%esp 1084fa: 85 c0 test %eax,%eax 1084fc: 0f 85 33 fc ff ff jne 108135 108502: e9 29 fc ff ff jmp 108130 =============================================================================== 001089fe : * Send characters to device-specific code */ void rtems_termios_puts ( const void *_buf, int len, struct rtems_termios_tty *tty) { 1089fe: 55 push %ebp 1089ff: 89 e5 mov %esp,%ebp 108a01: 57 push %edi 108a02: 56 push %esi 108a03: 53 push %ebx 108a04: 83 ec 3c sub $0x3c,%esp 108a07: 8b 45 08 mov 0x8(%ebp),%eax 108a0a: 8b 75 0c mov 0xc(%ebp),%esi 108a0d: 8b 5d 10 mov 0x10(%ebp),%ebx const unsigned char *buf = _buf; 108a10: 89 c7 mov %eax,%edi unsigned int newHead; rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { 108a12: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx) 108a19: 75 1b jne 108a36 (*tty->device.write)(tty->minor, (void *)buf, len); 108a1b: 89 75 10 mov %esi,0x10(%ebp) 108a1e: 89 45 0c mov %eax,0xc(%ebp) 108a21: 8b 43 10 mov 0x10(%ebx),%eax 108a24: 89 45 08 mov %eax,0x8(%ebp) 108a27: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 108a2d: 8d 65 f4 lea -0xc(%ebp),%esp 108a30: 5b pop %ebx 108a31: 5e pop %esi 108a32: 5f pop %edi 108a33: 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); 108a34: ff e0 jmp *%eax return; } newHead = tty->rawOutBuf.Head; 108a36: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 108a3c: 89 45 e4 mov %eax,-0x1c(%ebp) while (len) { 108a3f: e9 ca 00 00 00 jmp 108b0e * len -= ncopy * * To minimize latency, the memcpy should be done * with interrupts enabled. */ newHead = (newHead + 1) % tty->rawOutBuf.Size; 108a44: 8b 45 e4 mov -0x1c(%ebp),%eax 108a47: 40 inc %eax 108a48: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx 108a4e: 31 d2 xor %edx,%edx 108a50: f7 f1 div %ecx 108a52: 89 55 c4 mov %edx,-0x3c(%ebp) 108a55: 89 55 e4 mov %edx,-0x1c(%ebp) rtems_interrupt_disable (level); 108a58: 9c pushf 108a59: fa cli 108a5a: 8f 45 d4 popl -0x2c(%ebp) 108a5d: 8b 55 d4 mov -0x2c(%ebp),%edx 108a60: 8b 4d c4 mov -0x3c(%ebp),%ecx while (newHead == tty->rawOutBuf.Tail) { 108a63: eb 35 jmp 108a9a tty->rawOutBufState = rob_wait; 108a65: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) 108a6c: 00 00 00 rtems_interrupt_enable (level); 108a6f: 52 push %edx 108a70: 9d popf sc = rtems_semaphore_obtain( 108a71: 50 push %eax 108a72: 6a 00 push $0x0 108a74: 6a 00 push $0x0 108a76: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 108a7c: 89 4d e0 mov %ecx,-0x20(%ebp) 108a7f: e8 e4 16 00 00 call 10a168 tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 108a84: 83 c4 10 add $0x10,%esp 108a87: 85 c0 test %eax,%eax 108a89: 8b 4d e0 mov -0x20(%ebp),%ecx 108a8c: 74 09 je 108a97 <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 108a8e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108a91: 50 push %eax <== NOT EXECUTED 108a92: e8 a5 1c 00 00 call 10a73c <== NOT EXECUTED rtems_interrupt_disable (level); 108a97: 9c pushf 108a98: fa cli 108a99: 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) { 108a9a: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 108aa0: 39 c1 cmp %eax,%ecx 108aa2: 74 c1 je 108a65 108aa4: 89 55 d4 mov %edx,-0x2c(%ebp) 108aa7: 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++; 108aaa: 8b 8b 80 00 00 00 mov 0x80(%ebx),%ecx 108ab0: 8a 07 mov (%edi),%al 108ab2: 8b 53 7c mov 0x7c(%ebx),%edx 108ab5: 88 04 0a mov %al,(%edx,%ecx,1) 108ab8: 47 inc %edi tty->rawOutBuf.Head = newHead; 108ab9: 8b 4d c4 mov -0x3c(%ebp),%ecx 108abc: 89 8b 80 00 00 00 mov %ecx,0x80(%ebx) if (tty->rawOutBufState == rob_idle) { 108ac2: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) 108ac9: 75 3e jne 108b09 /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { 108acb: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108ad1: a8 10 test $0x10,%al 108ad3: 75 1b jne 108af0 <== NEVER TAKEN (*tty->device.write)(tty->minor, (char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 108ad5: 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, 108adb: 51 push %ecx 108adc: 6a 01 push $0x1 108ade: 03 43 7c add 0x7c(%ebx),%eax 108ae1: 50 push %eax 108ae2: ff 73 10 pushl 0x10(%ebx) 108ae5: ff 93 a4 00 00 00 call *0xa4(%ebx) 108aeb: 83 c4 10 add $0x10,%esp 108aee: eb 0f jmp 108aff (char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } else { /* remember that output has been stopped due to flow ctrl*/ tty->flow_ctrl |= FL_OSTOP; 108af0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108af6: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 108af9: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } tty->rawOutBufState = rob_busy; 108aff: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) 108b06: 00 00 00 } rtems_interrupt_enable (level); 108b09: ff 75 d4 pushl -0x2c(%ebp) 108b0c: 9d popf len--; 108b0d: 4e dec %esi if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, (void *)buf, len); return; } newHead = tty->rawOutBuf.Head; while (len) { 108b0e: 85 f6 test %esi,%esi 108b10: 0f 85 2e ff ff ff jne 108a44 tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 108b16: 8d 65 f4 lea -0xc(%ebp),%esp 108b19: 5b pop %ebx 108b1a: 5e pop %esi 108b1b: 5f pop %edi 108b1c: c9 leave 108b1d: c3 ret =============================================================================== 00109025 : return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) { 109025: 55 push %ebp 109026: 89 e5 mov %esp,%ebp 109028: 57 push %edi 109029: 56 push %esi 10902a: 53 push %ebx 10902b: 83 ec 40 sub $0x40,%esp 10902e: 8b 75 08 mov 0x8(%ebp),%esi rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 109031: 8b 06 mov (%esi),%eax 109033: 8b 58 34 mov 0x34(%eax),%ebx uint32_t count = args->count; 109036: 8b 46 10 mov 0x10(%esi),%eax 109039: 89 45 e4 mov %eax,-0x1c(%ebp) char *buffer = args->buffer; 10903c: 8b 46 0c mov 0xc(%esi),%eax 10903f: 89 45 e0 mov %eax,-0x20(%ebp) rtems_status_code sc; sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 109042: 6a 00 push $0x0 109044: 6a 00 push $0x0 109046: ff 73 14 pushl 0x14(%ebx) 109049: e8 1a 11 00 00 call 10a168 10904e: 89 45 dc mov %eax,-0x24(%ebp) if (sc != RTEMS_SUCCESSFUL) 109051: 83 c4 10 add $0x10,%esp 109054: 85 c0 test %eax,%eax 109056: 0f 85 9d 02 00 00 jne 1092f9 <== NEVER TAKEN return sc; if (rtems_termios_linesw[tty->t_line].l_read != NULL) { 10905c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 109062: c1 e0 05 shl $0x5,%eax 109065: 8b 80 dc 4e 12 00 mov 0x124edc(%eax),%eax 10906b: 85 c0 test %eax,%eax 10906d: 74 19 je 109088 sc = rtems_termios_linesw[tty->t_line].l_read(tty,args); 10906f: 57 push %edi 109070: 57 push %edi 109071: 56 push %esi 109072: 53 push %ebx 109073: ff d0 call *%eax 109075: 89 45 dc mov %eax,-0x24(%ebp) tty->tty_rcvwakeup = 0; 109078: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 10907f: 00 00 00 rtems_semaphore_release (tty->isem); 109082: 59 pop %ecx 109083: e9 66 02 00 00 jmp 1092ee return sc; } if (tty->cindex == tty->ccount) { 109088: 8b 43 20 mov 0x20(%ebx),%eax 10908b: 39 43 24 cmp %eax,0x24(%ebx) 10908e: 0f 85 2d 02 00 00 jne 1092c1 <== NEVER TAKEN tty->cindex = tty->ccount = 0; 109094: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) 10909b: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) tty->read_start_column = tty->column; 1090a2: 8b 43 28 mov 0x28(%ebx),%eax 1090a5: 89 43 2c mov %eax,0x2c(%ebx) if (tty->device.pollRead != NULL && 1090a8: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx) 1090af: 0f 84 c4 00 00 00 je 109179 1090b5: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx) 1090bc: 0f 85 b7 00 00 00 jne 109179 static rtems_status_code fillBufferPoll (struct rtems_termios_tty *tty) { int n; if (tty->termios.c_lflag & ICANON) { 1090c2: f6 43 3c 02 testb $0x2,0x3c(%ebx) 1090c6: 74 35 je 1090fd for (;;) { n = (*tty->device.pollRead)(tty->minor); 1090c8: 83 ec 0c sub $0xc,%esp 1090cb: ff 73 10 pushl 0x10(%ebx) 1090ce: ff 93 a0 00 00 00 call *0xa0(%ebx) if (n < 0) { 1090d4: 83 c4 10 add $0x10,%esp 1090d7: 85 c0 test %eax,%eax 1090d9: 79 0f jns 1090ea rtems_task_wake_after (1); 1090db: 83 ec 0c sub $0xc,%esp 1090de: 6a 01 push $0x1 1090e0: e8 d7 14 00 00 call 10a5bc 1090e5: 83 c4 10 add $0x10,%esp 1090e8: eb de jmp 1090c8 } else { if (siproc (n, tty)) 1090ea: 0f b6 c0 movzbl %al,%eax 1090ed: 89 da mov %ebx,%edx 1090ef: e8 38 fe ff ff call 108f2c 1090f4: 85 c0 test %eax,%eax 1090f6: 74 d0 je 1090c8 1090f8: e9 c4 01 00 00 jmp 1092c1 } } } else { rtems_interval then, now; then = rtems_clock_get_ticks_since_boot(); 1090fd: e8 3a 0a 00 00 call 109b3c 109102: 89 c7 mov %eax,%edi for (;;) { n = (*tty->device.pollRead)(tty->minor); 109104: 83 ec 0c sub $0xc,%esp 109107: ff 73 10 pushl 0x10(%ebx) 10910a: ff 93 a0 00 00 00 call *0xa0(%ebx) if (n < 0) { 109110: 83 c4 10 add $0x10,%esp 109113: 85 c0 test %eax,%eax 109115: 79 3d jns 109154 if (tty->termios.c_cc[VMIN]) { 109117: 80 7b 47 00 cmpb $0x0,0x47(%ebx) 10911b: 74 0e je 10912b <== NEVER TAKEN if (tty->termios.c_cc[VTIME] && tty->ccount) { 10911d: 80 7b 46 00 cmpb $0x0,0x46(%ebx) 109121: 74 22 je 109145 <== NEVER TAKEN 109123: 83 7b 20 00 cmpl $0x0,0x20(%ebx) 109127: 74 1c je 109145 109129: eb 0a jmp 109135 if ((now - then) > tty->vtimeTicks) { break; } } } else { if (!tty->termios.c_cc[VTIME]) 10912b: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED 10912f: 0f 84 8c 01 00 00 je 1092c1 <== NOT EXECUTED break; now = rtems_clock_get_ticks_since_boot(); 109135: e8 02 0a 00 00 call 109b3c if ((now - then) > tty->vtimeTicks) { 10913a: 29 f8 sub %edi,%eax 10913c: 3b 43 54 cmp 0x54(%ebx),%eax 10913f: 0f 87 7c 01 00 00 ja 1092c1 break; } } rtems_task_wake_after (1); 109145: 83 ec 0c sub $0xc,%esp 109148: 6a 01 push $0x1 10914a: e8 6d 14 00 00 call 10a5bc 10914f: 83 c4 10 add $0x10,%esp 109152: eb b0 jmp 109104 } else { siproc (n, tty); 109154: 0f b6 c0 movzbl %al,%eax 109157: 89 da mov %ebx,%edx 109159: e8 ce fd ff ff call 108f2c if (tty->ccount >= tty->termios.c_cc[VMIN]) 10915e: 8a 43 47 mov 0x47(%ebx),%al 109161: 0f b6 d0 movzbl %al,%edx 109164: 39 53 20 cmp %edx,0x20(%ebx) 109167: 0f 8d 54 01 00 00 jge 1092c1 <== NEVER TAKEN break; if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 10916d: 84 c0 test %al,%al 10916f: 74 93 je 109104 <== NEVER TAKEN 109171: 80 7b 46 00 cmpb $0x0,0x46(%ebx) 109175: 74 8d je 109104 <== NEVER TAKEN 109177: eb 84 jmp 1090fd * Fill the input buffer from the raw input queue */ static rtems_status_code fillBufferQueue (struct rtems_termios_tty *tty) { rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout; 109179: 8b 53 74 mov 0x74(%ebx),%edx rtems_status_code sc; int wait = (int)1; 10917c: 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)( 109181: 8d 43 49 lea 0x49(%ebx),%eax 109184: 89 45 d0 mov %eax,-0x30(%ebp) 109187: e9 e6 00 00 00 jmp 109272 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; 10918c: 8b 43 5c mov 0x5c(%ebx),%eax 10918f: 8b 4b 64 mov 0x64(%ebx),%ecx 109192: 40 inc %eax 109193: 31 d2 xor %edx,%edx 109195: f7 f1 div %ecx c = tty->rawInBuf.theBuf[newHead]; 109197: 8b 43 58 mov 0x58(%ebx),%eax 10919a: 8a 04 10 mov (%eax,%edx,1),%al 10919d: 88 45 db mov %al,-0x25(%ebp) tty->rawInBuf.Head = newHead; 1091a0: 89 53 5c mov %edx,0x5c(%ebx) if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) 1091a3: 8b 43 60 mov 0x60(%ebx),%eax 1091a6: 89 45 c4 mov %eax,-0x3c(%ebp) 1091a9: 8b 4b 64 mov 0x64(%ebx),%ecx % tty->rawInBuf.Size) 1091ac: 8b 43 64 mov 0x64(%ebx),%eax 1091af: 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) 1091b2: 8b 45 c4 mov -0x3c(%ebp),%eax 1091b5: 8d 04 01 lea (%ecx,%eax,1),%eax 1091b8: 29 d0 sub %edx,%eax % tty->rawInBuf.Size) 1091ba: 31 d2 xor %edx,%edx 1091bc: 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) 1091bf: 3b 93 bc 00 00 00 cmp 0xbc(%ebx),%edx 1091c5: 73 74 jae 10923b <== NEVER TAKEN % tty->rawInBuf.Size) < tty->lowwater) { tty->flow_ctrl &= ~FL_IREQXOF; 1091c7: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1091cd: 83 e0 fe and $0xfffffffe,%eax 1091d0: 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)) 1091d6: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1091dc: 25 02 02 00 00 and $0x202,%eax 1091e1: 3d 02 02 00 00 cmp $0x202,%eax 1091e6: 75 24 jne 10920c <== ALWAYS TAKEN == (FL_MDXON | FL_ISNTXOF)) && ((tty->rawOutBufState == rob_idle) 1091e8: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 1091ef: 74 0a je 1091fb <== NOT EXECUTED || (tty->flow_ctrl & FL_OSTOP))) { 1091f1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1091f7: a8 20 test $0x20,%al <== NOT EXECUTED 1091f9: 74 11 je 10920c <== NOT EXECUTED /* XON should be sent now... */ (*tty->device.write)( 1091fb: 52 push %edx <== NOT EXECUTED 1091fc: 6a 01 push $0x1 <== NOT EXECUTED 1091fe: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED 109201: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109204: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 10920a: eb 2c jmp 109238 <== NOT EXECUTED tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1); } else if (tty->flow_ctrl & FL_MDRTS) { 10920c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109212: f6 c4 01 test $0x1,%ah 109215: 74 24 je 10923b <== ALWAYS TAKEN tty->flow_ctrl &= ~FL_IRTSOFF; 109217: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10921d: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 109220: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* activate RTS line */ if (tty->device.startRemoteTx != NULL) { 109226: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 10922c: 85 c0 test %eax,%eax <== NOT EXECUTED 10922e: 74 0b je 10923b <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 109230: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109233: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109236: ff d0 call *%eax <== NOT EXECUTED 109238: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { 10923b: f6 43 3c 02 testb $0x2,0x3c(%ebx) 10923f: 74 12 je 109253 <== NEVER TAKEN if (siproc (c, tty)) 109241: 0f b6 45 db movzbl -0x25(%ebp),%eax 109245: 89 da mov %ebx,%edx 109247: e8 e0 fc ff ff call 108f2c wait = 0; 10924c: 85 c0 test %eax,%eax 10924e: 0f 94 c0 sete %al 109251: eb 15 jmp 109268 } else { siproc (c, tty); 109253: 0f b6 45 db movzbl -0x25(%ebp),%eax <== NOT EXECUTED 109257: 89 da mov %ebx,%edx <== NOT EXECUTED 109259: e8 ce fc ff ff call 108f2c <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 10925e: 0f b6 43 47 movzbl 0x47(%ebx),%eax <== NOT EXECUTED wait = 0; 109262: 39 43 20 cmp %eax,0x20(%ebx) <== NOT EXECUTED 109265: 0f 9c c0 setl %al <== NOT EXECUTED 109268: 0f b6 c0 movzbl %al,%eax 10926b: f7 d8 neg %eax 10926d: 21 c7 and %eax,%edi } timeout = tty->rawInBufSemaphoreTimeout; 10926f: 8b 53 70 mov 0x70(%ebx),%edx while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 109272: 8b 4b 5c mov 0x5c(%ebx),%ecx 109275: 8b 43 60 mov 0x60(%ebx),%eax 109278: 39 c1 cmp %eax,%ecx 10927a: 74 0f je 10928b (tty->ccount < (CBUFSIZE-1))) { 10927c: a1 50 30 12 00 mov 0x123050,%eax 109281: 48 dec %eax while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 109282: 39 43 20 cmp %eax,0x20(%ebx) 109285: 0f 8c 01 ff ff ff jl 10918c <== ALWAYS TAKEN } /* * Wait for characters */ if ( wait ) { 10928b: 85 ff test %edi,%edi 10928d: 74 32 je 1092c1 sc = rtems_semaphore_obtain( 10928f: 50 push %eax 109290: 52 push %edx 109291: ff 73 6c pushl 0x6c(%ebx) 109294: ff 73 68 pushl 0x68(%ebx) 109297: 89 55 cc mov %edx,-0x34(%ebp) 10929a: e8 c9 0e 00 00 call 10a168 tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout); if (sc != RTEMS_SUCCESSFUL) 10929f: 83 c4 10 add $0x10,%esp 1092a2: 85 c0 test %eax,%eax 1092a4: 8b 55 cc mov -0x34(%ebp),%edx 1092a7: 74 c9 je 109272 <== ALWAYS TAKEN 1092a9: eb 16 jmp 1092c1 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { *buffer++ = tty->cbuf[tty->cindex++]; 1092ab: 8b 7b 1c mov 0x1c(%ebx),%edi 1092ae: 8b 45 e4 mov -0x1c(%ebp),%eax 1092b1: 8a 04 07 mov (%edi,%eax,1),%al 1092b4: 88 01 mov %al,(%ecx) 1092b6: 41 inc %ecx 1092b7: 8b 45 e4 mov -0x1c(%ebp),%eax 1092ba: 40 inc %eax 1092bb: 89 43 24 mov %eax,0x24(%ebx) count--; 1092be: 4a dec %edx 1092bf: eb 06 jmp 1092c7 1092c1: 8b 55 e4 mov -0x1c(%ebp),%edx 1092c4: 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)) { 1092c7: 85 d2 test %edx,%edx 1092c9: 74 0b je 1092d6 1092cb: 8b 43 24 mov 0x24(%ebx),%eax 1092ce: 89 45 e4 mov %eax,-0x1c(%ebp) 1092d1: 3b 43 20 cmp 0x20(%ebx),%eax 1092d4: 7c d5 jl 1092ab 1092d6: 89 55 e4 mov %edx,-0x1c(%ebp) *buffer++ = tty->cbuf[tty->cindex++]; count--; } args->bytes_moved = args->count - count; 1092d9: 8b 46 10 mov 0x10(%esi),%eax 1092dc: 29 d0 sub %edx,%eax 1092de: 89 46 18 mov %eax,0x18(%esi) tty->tty_rcvwakeup = 0; 1092e1: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) 1092e8: 00 00 00 rtems_semaphore_release (tty->isem); 1092eb: 83 ec 0c sub $0xc,%esp 1092ee: ff 73 14 pushl 0x14(%ebx) 1092f1: e8 5e 0f 00 00 call 10a254 return sc; 1092f6: 83 c4 10 add $0x10,%esp } 1092f9: 8b 45 dc mov -0x24(%ebp),%eax 1092fc: 8d 65 f4 lea -0xc(%ebp),%esp 1092ff: 5b pop %ebx 109300: 5e pop %esi 109301: 5f pop %edi 109302: c9 leave 109303: c3 ret =============================================================================== 0010960e : * 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) { 10960e: 55 push %ebp 10960f: 89 e5 mov %esp,%ebp 109611: 57 push %edi 109612: 56 push %esi 109613: 53 push %ebx 109614: 83 ec 0c sub $0xc,%esp 109617: 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)) 10961a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109620: 25 03 04 00 00 and $0x403,%eax 109625: 3d 01 04 00 00 cmp $0x401,%eax 10962a: 75 2c jne 109658 <== ALWAYS TAKEN == (FL_MDXOF | FL_IREQXOF)) { /* XOFF should be sent now... */ (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1); 10962c: 57 push %edi <== NOT EXECUTED 10962d: 6a 01 push $0x1 <== NOT EXECUTED 10962f: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED 109632: 50 push %eax <== NOT EXECUTED 109633: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109636: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED rtems_interrupt_disable(level); 10963c: 9c pushf <== NOT EXECUTED 10963d: fa cli <== NOT EXECUTED 10963e: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 10963f: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; 109645: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10964b: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 10964e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED rtems_interrupt_enable(level); 109654: 52 push %edx <== NOT EXECUTED 109655: 9d popf <== NOT EXECUTED 109656: eb 38 jmp 109690 <== NOT EXECUTED nToSend = 1; } else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) { 109658: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10965e: 83 e0 03 and $0x3,%eax 109661: 83 f8 02 cmp $0x2,%eax 109664: 75 37 jne 10969d <== 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); 109666: 56 push %esi <== NOT EXECUTED 109667: 6a 01 push $0x1 <== NOT EXECUTED 109669: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED 10966c: 50 push %eax <== NOT EXECUTED 10966d: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109670: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED rtems_interrupt_disable(level); 109676: 9c pushf <== NOT EXECUTED 109677: fa cli <== NOT EXECUTED 109678: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 109679: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl &= ~FL_ISNTXOF; 10967f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109685: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 109688: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED rtems_interrupt_enable(level); 10968e: 52 push %edx <== NOT EXECUTED 10968f: 9d popf <== NOT EXECUTED 109690: 83 c4 10 add $0x10,%esp <== NOT EXECUTED nToSend = 1; 109693: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 109698: e9 35 01 00 00 jmp 1097d2 <== NOT EXECUTED } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { 10969d: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 1096a3: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 1096a9: 39 c2 cmp %eax,%edx 1096ab: 75 25 jne 1096d2 /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); } return 0; 1096ad: 31 f6 xor %esi,%esi } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { /* * buffer was empty */ if (tty->rawOutBufState == rob_wait) { 1096af: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) 1096b6: 0f 85 16 01 00 00 jne 1097d2 <== ALWAYS TAKEN /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 1096bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1096bf: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED 1096c5: e8 8a 0b 00 00 call 10a254 <== NOT EXECUTED 1096ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1096cd: e9 00 01 00 00 jmp 1097d2 <== NOT EXECUTED } return 0; } rtems_interrupt_disable(level); 1096d2: 9c pushf 1096d3: fa cli 1096d4: 58 pop %eax len = tty->t_dqlen; 1096d5: 8b bb 90 00 00 00 mov 0x90(%ebx),%edi tty->t_dqlen = 0; 1096db: c7 83 90 00 00 00 00 movl $0x0,0x90(%ebx) 1096e2: 00 00 00 rtems_interrupt_enable(level); 1096e5: 50 push %eax 1096e6: 9d popf newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size; 1096e7: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 1096ed: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx 1096f3: 8d 04 07 lea (%edi,%eax,1),%eax 1096f6: 31 d2 xor %edx,%edx 1096f8: f7 f1 div %ecx 1096fa: 89 d7 mov %edx,%edi tty->rawOutBuf.Tail = newTail; 1096fc: 89 93 84 00 00 00 mov %edx,0x84(%ebx) if (tty->rawOutBufState == rob_wait) { 109702: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) 109709: 75 11 jne 10971c /* * wake up any pending writer task */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 10970b: 83 ec 0c sub $0xc,%esp 10970e: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 109714: e8 3b 0b 00 00 call 10a254 109719: 83 c4 10 add $0x10,%esp } if (newTail == tty->rawOutBuf.Head) { 10971c: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 109722: 39 c7 cmp %eax,%edi 109724: 75 2a jne 109750 /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; 109726: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx) 10972d: 00 00 00 nToSend = 0; /* * check to see if snd wakeup callback was set */ if ( tty->tty_snd.sw_pfn != NULL) { 109730: 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; 109736: 31 f6 xor %esi,%esi /* * check to see if snd wakeup callback was set */ if ( tty->tty_snd.sw_pfn != NULL) { 109738: 85 c0 test %eax,%eax 10973a: 0f 84 8c 00 00 00 je 1097cc <== ALWAYS TAKEN (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg); 109740: 51 push %ecx <== NOT EXECUTED 109741: 51 push %ecx <== NOT EXECUTED 109742: ff b3 d8 00 00 00 pushl 0xd8(%ebx) <== NOT EXECUTED 109748: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED 10974b: 52 push %edx <== NOT EXECUTED 10974c: ff d0 call *%eax <== NOT EXECUTED 10974e: eb 79 jmp 1097c9 <== NOT EXECUTED } } /* check, whether output should stop due to received XOFF */ else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF)) 109750: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 109756: 25 10 02 00 00 and $0x210,%eax 10975b: 3d 10 02 00 00 cmp $0x210,%eax 109760: 75 22 jne 109784 <== 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); 109762: 9c pushf <== NOT EXECUTED 109763: fa cli <== NOT EXECUTED 109764: 5a pop %edx <== NOT EXECUTED tty->flow_ctrl |= FL_OSTOP; 109765: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10976b: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 10976e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ 109774: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED 10977b: 00 00 00 rtems_interrupt_enable(level); 10977e: 52 push %edx <== NOT EXECUTED 10977f: 9d popf <== NOT EXECUTED nToSend = 0; 109780: 31 f6 xor %esi,%esi <== NOT EXECUTED 109782: eb 48 jmp 1097cc <== NOT EXECUTED } else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) 109784: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 10978a: 39 c7 cmp %eax,%edi 10978c: 76 08 jbe 109796 nToSend = tty->rawOutBuf.Size - newTail; 10978e: 8b b3 88 00 00 00 mov 0x88(%ebx),%esi 109794: eb 06 jmp 10979c else nToSend = tty->rawOutBuf.Head - newTail; 109796: 8b b3 80 00 00 00 mov 0x80(%ebx),%esi 10979c: 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)) { 10979e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1097a4: f6 c4 06 test $0x6,%ah 1097a7: 74 05 je 1097ae nToSend = 1; 1097a9: be 01 00 00 00 mov $0x1,%esi } tty->rawOutBufState = rob_busy; /*apm*/ 1097ae: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) 1097b5: 00 00 00 (*tty->device.write)( 1097b8: 52 push %edx 1097b9: 56 push %esi 1097ba: 8b 43 7c mov 0x7c(%ebx),%eax 1097bd: 01 f8 add %edi,%eax 1097bf: 50 push %eax 1097c0: ff 73 10 pushl 0x10(%ebx) 1097c3: ff 93 a4 00 00 00 call *0xa4(%ebx) 1097c9: 83 c4 10 add $0x10,%esp tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ 1097cc: 89 bb 84 00 00 00 mov %edi,0x84(%ebx) } return nToSend; } 1097d2: 89 f0 mov %esi,%eax 1097d4: 8d 65 f4 lea -0xc(%ebp),%esp 1097d7: 5b pop %ebx 1097d8: 5e pop %esi 1097d9: 5f pop %edi 1097da: c9 leave 1097db: c3 ret =============================================================================== 001095aa : /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) { 1095aa: 55 push %ebp 1095ab: 89 e5 mov %esp,%ebp 1095ad: 57 push %edi 1095ae: 56 push %esi 1095af: 53 push %ebx 1095b0: 83 ec 1c sub $0x1c,%esp 1095b3: 8b 5d 08 mov 0x8(%ebp),%ebx while (1) { /* * wait for rtems event */ rtems_event_receive( 1095b6: 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); 1095b9: 8d 75 e7 lea -0x19(%ebp),%esi while (1) { /* * wait for rtems event */ rtems_event_receive( 1095bc: 57 push %edi 1095bd: 6a 00 push $0x0 1095bf: 6a 02 push $0x2 1095c1: 6a 03 push $0x3 1095c3: e8 d8 05 00 00 call 109ba0 (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) { 1095c8: 83 c4 10 add $0x10,%esp 1095cb: f6 45 e0 01 testb $0x1,-0x20(%ebp) 1095cf: 74 17 je 1095e8 <== ALWAYS TAKEN tty->rxTaskId = 0; 1095d1: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) 1095d8: 00 00 00 rtems_task_delete(RTEMS_SELF); 1095db: 83 ec 0c sub $0xc,%esp 1095de: 6a 00 push $0x0 <== NOT EXECUTED 1095e0: e8 37 0e 00 00 call 10a41c <== NOT EXECUTED 1095e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * do something */ c = tty->device.pollRead(tty->minor); 1095e8: 83 ec 0c sub $0xc,%esp 1095eb: ff 73 10 pushl 0x10(%ebx) 1095ee: ff 93 a0 00 00 00 call *0xa0(%ebx) if (c != EOF) { 1095f4: 83 c4 10 add $0x10,%esp 1095f7: 83 f8 ff cmp $0xffffffff,%eax 1095fa: 74 c0 je 1095bc /* * pollRead did call enqueue on its own */ c_buf = c; 1095fc: 88 45 e7 mov %al,-0x19(%ebp) rtems_termios_enqueue_raw_characters ( tty,&c_buf,1); 1095ff: 50 push %eax 109600: 6a 01 push $0x1 109602: 56 push %esi 109603: 53 push %ebx 109604: e8 16 fd ff ff call 10931f 109609: 83 c4 10 add $0x10,%esp 10960c: eb ae jmp 1095bc =============================================================================== 001097dc : /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) { 1097dc: 55 push %ebp 1097dd: 89 e5 mov %esp,%ebp 1097df: 56 push %esi 1097e0: 53 push %ebx 1097e1: 83 ec 10 sub $0x10,%esp 1097e4: 8b 5d 08 mov 0x8(%ebp),%ebx while (1) { /* * wait for rtems event */ rtems_event_receive( 1097e7: 8d 75 f4 lea -0xc(%ebp),%esi 1097ea: 56 push %esi 1097eb: 6a 00 push $0x0 1097ed: 6a 02 push $0x2 1097ef: 6a 03 push $0x3 1097f1: e8 aa 03 00 00 call 109ba0 (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) { 1097f6: 83 c4 10 add $0x10,%esp 1097f9: f6 45 f4 01 testb $0x1,-0xc(%ebp) 1097fd: 74 17 je 109816 <== ALWAYS TAKEN tty->txTaskId = 0; 1097ff: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED 109806: 00 00 00 rtems_task_delete(RTEMS_SELF); 109809: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10980c: 6a 00 push $0x0 <== NOT EXECUTED 10980e: e8 09 0c 00 00 call 10a41c <== NOT EXECUTED 109813: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 109816: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 10981c: c1 e0 05 shl $0x5,%eax 10981f: 8b 80 e8 4e 12 00 mov 0x124ee8(%eax),%eax 109825: 85 c0 test %eax,%eax 109827: 74 09 je 109832 <== ALWAYS TAKEN rtems_termios_linesw[tty->t_line].l_start(tty); 109829: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10982c: 53 push %ebx <== NOT EXECUTED 10982d: ff d0 call *%eax <== NOT EXECUTED 10982f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * try to push further characters to device */ rtems_termios_refill_transmitter(tty); 109832: 83 ec 0c sub $0xc,%esp 109835: 53 push %ebx 109836: e8 d3 fd ff ff call 10960e } 10983b: 83 c4 10 add $0x10,%esp 10983e: eb aa jmp 1097ea =============================================================================== 00108f7e : rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) { 108f7e: 55 push %ebp 108f7f: 89 e5 mov %esp,%ebp 108f81: 57 push %edi 108f82: 56 push %esi 108f83: 53 push %ebx 108f84: 83 ec 20 sub $0x20,%esp 108f87: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 108f8a: 8b 03 mov (%ebx),%eax 108f8c: 8b 70 34 mov 0x34(%eax),%esi rtems_status_code sc; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 108f8f: 6a 00 push $0x0 108f91: 6a 00 push $0x0 108f93: ff 76 18 pushl 0x18(%esi) 108f96: e8 cd 11 00 00 call 10a168 108f9b: 89 c7 mov %eax,%edi if (sc != RTEMS_SUCCESSFUL) 108f9d: 83 c4 10 add $0x10,%esp 108fa0: 85 c0 test %eax,%eax 108fa2: 75 77 jne 10901b <== NEVER TAKEN return sc; if (rtems_termios_linesw[tty->t_line].l_write != NULL) { 108fa4: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax 108faa: c1 e0 05 shl $0x5,%eax 108fad: 8b 80 e0 4e 12 00 mov 0x124ee0(%eax),%eax 108fb3: 85 c0 test %eax,%eax 108fb5: 74 0b je 108fc2 sc = rtems_termios_linesw[tty->t_line].l_write(tty,args); 108fb7: 57 push %edi 108fb8: 57 push %edi 108fb9: 53 push %ebx 108fba: 56 push %esi 108fbb: ff d0 call *%eax 108fbd: 89 c7 mov %eax,%edi rtems_semaphore_release (tty->osem); 108fbf: 5b pop %ebx 108fc0: eb 4e jmp 109010 return sc; } if (tty->termios.c_oflag & OPOST) { 108fc2: f6 46 34 01 testb $0x1,0x34(%esi) 108fc6: 74 2f je 108ff7 <== NEVER TAKEN uint32_t count = args->count; 108fc8: 8b 4b 10 mov 0x10(%ebx),%ecx char *buffer = args->buffer; 108fcb: 8b 43 0c mov 0xc(%ebx),%eax 108fce: 89 45 e4 mov %eax,-0x1c(%ebp) while (count--) 108fd1: eb 18 jmp 108feb oproc (*buffer++, tty); 108fd3: 8b 55 e4 mov -0x1c(%ebp),%edx 108fd6: 0f b6 02 movzbl (%edx),%eax 108fd9: 42 inc %edx 108fda: 89 55 e4 mov %edx,-0x1c(%ebp) 108fdd: 89 f2 mov %esi,%edx 108fdf: 89 4d e0 mov %ecx,-0x20(%ebp) 108fe2: e8 37 fb ff ff call 108b1e 108fe7: 8b 4d e0 mov -0x20(%ebp),%ecx 108fea: 49 dec %ecx return sc; } if (tty->termios.c_oflag & OPOST) { uint32_t count = args->count; char *buffer = args->buffer; while (count--) 108feb: 85 c9 test %ecx,%ecx 108fed: 75 e4 jne 108fd3 oproc (*buffer++, tty); args->bytes_moved = args->count; 108fef: 8b 43 10 mov 0x10(%ebx),%eax 108ff2: 89 43 18 mov %eax,0x18(%ebx) 108ff5: eb 16 jmp 10900d } else { rtems_termios_puts (args->buffer, args->count, tty); 108ff7: 51 push %ecx <== NOT EXECUTED 108ff8: 56 push %esi <== NOT EXECUTED 108ff9: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108ffc: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 108fff: e8 fa f9 ff ff call 1089fe <== NOT EXECUTED args->bytes_moved = args->count; 109004: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 109007: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED 10900a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } rtems_semaphore_release (tty->osem); 10900d: 83 ec 0c sub $0xc,%esp 109010: ff 76 18 pushl 0x18(%esi) 109013: e8 3c 12 00 00 call 10a254 return sc; 109018: 83 c4 10 add $0x10,%esp } 10901b: 89 f8 mov %edi,%eax 10901d: 8d 65 f4 lea -0xc(%ebp),%esp 109020: 5b pop %ebx 109021: 5e pop %esi 109022: 5f pop %edi 109023: c9 leave 109024: c3 ret =============================================================================== 001163a0 : */ rtems_status_code rtems_timer_cancel( rtems_id id ) { 1163a0: 55 push %ebp 1163a1: 89 e5 mov %esp,%ebp 1163a3: 83 ec 1c sub $0x1c,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 1163a6: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 1163a9: 50 push %eax 1163aa: ff 75 08 pushl 0x8(%ebp) 1163ad: 68 fc f8 13 00 push $0x13f8fc 1163b2: e8 39 27 00 00 call 118af0 <_Objects_Get> switch ( location ) { 1163b7: 83 c4 10 add $0x10,%esp 1163ba: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 1163be: 75 1e jne 1163de case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 1163c0: 83 78 38 04 cmpl $0x4,0x38(%eax) 1163c4: 74 0f je 1163d5 <== NEVER TAKEN (void) _Watchdog_Remove( &the_timer->Ticker ); 1163c6: 83 ec 0c sub $0xc,%esp 1163c9: 83 c0 10 add $0x10,%eax 1163cc: 50 push %eax 1163cd: e8 32 41 00 00 call 11a504 <_Watchdog_Remove> 1163d2: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 1163d5: e8 f4 30 00 00 call 1194ce <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1163da: 31 c0 xor %eax,%eax 1163dc: eb 05 jmp 1163e3 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1163de: b8 04 00 00 00 mov $0x4,%eax } 1163e3: c9 leave 1163e4: c3 ret =============================================================================== 00116800 : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 116800: 55 push %ebp 116801: 89 e5 mov %esp,%ebp 116803: 57 push %edi 116804: 56 push %esi 116805: 53 push %ebx 116806: 83 ec 1c sub $0x1c,%esp 116809: 8b 7d 0c mov 0xc(%ebp),%edi Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 11680c: 8b 35 3c f9 13 00 mov 0x13f93c,%esi if ( !timer_server ) return RTEMS_INCORRECT_STATE; 116812: 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 ) 116817: 85 f6 test %esi,%esi 116819: 0f 84 b1 00 00 00 je 1168d0 return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; 11681f: b3 0b mov $0xb,%bl Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 116821: 80 3d a8 ef 13 00 00 cmpb $0x0,0x13efa8 116828: 0f 84 a2 00 00 00 je 1168d0 <== NEVER TAKEN return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; 11682e: b3 09 mov $0x9,%bl return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) 116830: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 116834: 0f 84 96 00 00 00 je 1168d0 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 11683a: 83 ec 0c sub $0xc,%esp 11683d: 57 push %edi 11683e: e8 ad d6 ff ff call 113ef0 <_TOD_Validate> 116843: 83 c4 10 add $0x10,%esp return RTEMS_INVALID_CLOCK; 116846: b3 14 mov $0x14,%bl return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 116848: 84 c0 test %al,%al 11684a: 0f 84 80 00 00 00 je 1168d0 return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 116850: 83 ec 0c sub $0xc,%esp 116853: 57 push %edi 116854: e8 2f d6 ff ff call 113e88 <_TOD_To_seconds> 116859: 89 c7 mov %eax,%edi if ( seconds <= _TOD_Seconds_since_epoch() ) 11685b: 83 c4 10 add $0x10,%esp 11685e: 3b 05 40 f0 13 00 cmp 0x13f040,%eax 116864: 76 6a jbe 1168d0 116866: 51 push %ecx return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); 116867: 8d 45 e4 lea -0x1c(%ebp),%eax 11686a: 50 push %eax 11686b: ff 75 08 pushl 0x8(%ebp) 11686e: 68 fc f8 13 00 push $0x13f8fc 116873: e8 78 22 00 00 call 118af0 <_Objects_Get> 116878: 89 c3 mov %eax,%ebx switch ( location ) { 11687a: 83 c4 10 add $0x10,%esp 11687d: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 116881: 75 48 jne 1168cb case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 116883: 83 ec 0c sub $0xc,%esp 116886: 8d 40 10 lea 0x10(%eax),%eax 116889: 50 push %eax 11688a: e8 75 3c 00 00 call 11a504 <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 11688f: 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; 116896: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) the_watchdog->routine = routine; 11689d: 8b 45 10 mov 0x10(%ebp),%eax 1168a0: 89 43 2c mov %eax,0x2c(%ebx) the_watchdog->id = id; 1168a3: 8b 45 08 mov 0x8(%ebp),%eax 1168a6: 89 43 30 mov %eax,0x30(%ebx) the_watchdog->user_data = user_data; 1168a9: 8b 45 14 mov 0x14(%ebp),%eax 1168ac: 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(); 1168af: 2b 3d 40 f0 13 00 sub 0x13f040,%edi 1168b5: 89 7b 1c mov %edi,0x1c(%ebx) (*timer_server->schedule_operation)( timer_server, the_timer ); 1168b8: 58 pop %eax 1168b9: 5a pop %edx 1168ba: 53 push %ebx 1168bb: 56 push %esi 1168bc: ff 56 04 call *0x4(%esi) _Thread_Enable_dispatch(); 1168bf: e8 0a 2c 00 00 call 1194ce <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1168c4: 83 c4 10 add $0x10,%esp 1168c7: 31 db xor %ebx,%ebx 1168c9: eb 05 jmp 1168d0 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1168cb: bb 04 00 00 00 mov $0x4,%ebx } 1168d0: 89 d8 mov %ebx,%eax 1168d2: 8d 65 f4 lea -0xc(%ebp),%esp 1168d5: 5b pop %ebx 1168d6: 5e pop %esi 1168d7: 5f pop %edi 1168d8: c9 leave 1168d9: c3 ret =============================================================================== 0010b14d : static int rtems_verror( rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) { 10b14d: 55 push %ebp 10b14e: 89 e5 mov %esp,%ebp 10b150: 57 push %edi 10b151: 56 push %esi 10b152: 53 push %ebx 10b153: 83 ec 1c sub $0x1c,%esp 10b156: 89 c3 mov %eax,%ebx 10b158: 89 55 e4 mov %edx,-0x1c(%ebp) 10b15b: 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) { 10b15e: a9 00 00 00 20 test $0x20000000,%eax 10b163: 74 2c je 10b191 if (rtems_panic_in_progress++) 10b165: a1 48 b3 12 00 mov 0x12b348,%eax 10b16a: 8d 50 01 lea 0x1(%eax),%edx 10b16d: 89 15 48 b3 12 00 mov %edx,0x12b348 10b173: 85 c0 test %eax,%eax 10b175: 74 0b je 10b182 <== ALWAYS TAKEN rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b177: a1 94 b4 12 00 mov 0x12b494,%eax <== NOT EXECUTED 10b17c: 40 inc %eax <== NOT EXECUTED 10b17d: a3 94 b4 12 00 mov %eax,0x12b494 <== NOT EXECUTED _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) return 0; 10b182: 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) 10b184: 83 3d 48 b3 12 00 02 cmpl $0x2,0x12b348 10b18b: 0f 8f da 00 00 00 jg 10b26b <== NEVER TAKEN return 0; } (void) fflush(stdout); /* in case stdout/stderr same */ 10b191: 83 ec 0c sub $0xc,%esp 10b194: a1 a0 91 12 00 mov 0x1291a0,%eax 10b199: ff 70 08 pushl 0x8(%eax) 10b19c: e8 db ab 00 00 call 115d7c status = error_flag & ~RTEMS_ERROR_MASK; 10b1a1: 89 df mov %ebx,%edi 10b1a3: 81 e7 ff ff ff 8f and $0x8fffffff,%edi if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 10b1a9: 83 c4 10 add $0x10,%esp rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) { int local_errno = 0; 10b1ac: 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? */ 10b1ae: 81 e3 00 00 00 40 and $0x40000000,%ebx 10b1b4: 74 07 je 10b1bd local_errno = errno; 10b1b6: e8 29 a8 00 00 call 1159e4 <__errno> 10b1bb: 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); 10b1bd: 53 push %ebx 10b1be: ff 75 e0 pushl -0x20(%ebp) 10b1c1: ff 75 e4 pushl -0x1c(%ebp) 10b1c4: a1 a0 91 12 00 mov 0x1291a0,%eax 10b1c9: ff 70 0c pushl 0xc(%eax) 10b1cc: e8 53 11 01 00 call 11c324 10b1d1: 89 c3 mov %eax,%ebx if (status) 10b1d3: 83 c4 10 add $0x10,%esp 10b1d6: 85 ff test %edi,%edi 10b1d8: 74 24 je 10b1fe chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); 10b1da: 83 ec 0c sub $0xc,%esp 10b1dd: 57 push %edi 10b1de: e8 55 ff ff ff call 10b138 10b1e3: 83 c4 0c add $0xc,%esp 10b1e6: 50 push %eax 10b1e7: 68 6f 44 12 00 push $0x12446f 10b1ec: a1 a0 91 12 00 mov 0x1291a0,%eax 10b1f1: ff 70 0c pushl 0xc(%eax) 10b1f4: e8 77 af 00 00 call 116170 #endif chars_written += vfprintf(stderr, printf_format, arglist); if (status) chars_written += 10b1f9: 01 c3 add %eax,%ebx 10b1fb: 83 c4 10 add $0x10,%esp fprintf(stderr, " (status: %s)", rtems_status_text(status)); if (local_errno) { 10b1fe: 83 fe 00 cmp $0x0,%esi 10b201: 74 40 je 10b243 if ((local_errno > 0) && *strerror(local_errno)) 10b203: 7e 25 jle 10b22a 10b205: 83 ec 0c sub $0xc,%esp 10b208: 56 push %esi 10b209: e8 0e b8 00 00 call 116a1c 10b20e: 83 c4 10 add $0x10,%esp 10b211: 80 38 00 cmpb $0x0,(%eax) 10b214: 74 14 je 10b22a <== NEVER TAKEN chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); 10b216: 83 ec 0c sub $0xc,%esp 10b219: 56 push %esi 10b21a: e8 fd b7 00 00 call 116a1c 10b21f: 83 c4 0c add $0xc,%esp 10b222: 50 push %eax 10b223: 68 7d 44 12 00 push $0x12447d 10b228: eb 07 jmp 10b231 else chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno); 10b22a: 51 push %ecx 10b22b: 56 push %esi 10b22c: 68 8a 44 12 00 push $0x12448a 10b231: a1 a0 91 12 00 mov 0x1291a0,%eax 10b236: ff 70 0c pushl 0xc(%eax) 10b239: e8 32 af 00 00 call 116170 10b23e: 01 c3 add %eax,%ebx 10b240: 83 c4 10 add $0x10,%esp } chars_written += fprintf(stderr, "\n"); 10b243: 52 push %edx 10b244: 52 push %edx 10b245: 68 fc 4b 12 00 push $0x124bfc 10b24a: a1 a0 91 12 00 mov 0x1291a0,%eax 10b24f: ff 70 0c pushl 0xc(%eax) 10b252: e8 19 af 00 00 call 116170 10b257: 8d 34 18 lea (%eax,%ebx,1),%esi (void) fflush(stderr); 10b25a: 58 pop %eax 10b25b: a1 a0 91 12 00 mov 0x1291a0,%eax 10b260: ff 70 0c pushl 0xc(%eax) 10b263: e8 14 ab 00 00 call 115d7c return chars_written; 10b268: 83 c4 10 add $0x10,%esp } 10b26b: 89 f0 mov %esi,%eax 10b26d: 8d 65 f4 lea -0xc(%ebp),%esp 10b270: 5b pop %ebx 10b271: 5e pop %esi 10b272: 5f pop %edi 10b273: c9 leave 10b274: c3 ret =============================================================================== 00107930 : /* * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) { 107930: 55 push %ebp 107931: 89 e5 mov %esp,%ebp 107933: 57 push %edi 107934: 56 push %esi 107935: 53 push %ebx 107936: 83 ec 3c sub $0x3c,%esp 107939: 89 c3 mov %eax,%ebx 10793b: 89 55 e0 mov %edx,-0x20(%ebp) int c; unsigned int i = 0; unsigned int limit = INT_MAX; int sign = 0; 10793e: 31 f6 xor %esi,%esi static int scanInt(FILE *fp, int *val) { int c; unsigned int i = 0; unsigned int limit = INT_MAX; 107940: c7 45 e4 ff ff ff 7f movl $0x7fffffff,-0x1c(%ebp) */ static int scanInt(FILE *fp, int *val) { int c; unsigned int i = 0; 107947: 31 ff xor %edi,%edi sign = 1; } if (!isdigit(c)) return 0; d = c - '0'; if ((i > (limit / 10)) 107949: 89 7d c4 mov %edi,-0x3c(%ebp) unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 10794c: 8b 43 04 mov 0x4(%ebx),%eax 10794f: 48 dec %eax 107950: 89 43 04 mov %eax,0x4(%ebx) 107953: 85 c0 test %eax,%eax 107955: 79 15 jns 10796c <== ALWAYS TAKEN 107957: 50 push %eax <== NOT EXECUTED 107958: 50 push %eax <== NOT EXECUTED 107959: 53 push %ebx <== NOT EXECUTED 10795a: ff 35 e0 4d 12 00 pushl 0x124de0 <== NOT EXECUTED 107960: e8 8f bf 00 00 call 1138f4 <__srget_r> <== NOT EXECUTED 107965: 89 c1 mov %eax,%ecx <== NOT EXECUTED 107967: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10796a: eb 08 jmp 107974 <== NOT EXECUTED 10796c: 8b 03 mov (%ebx),%eax 10796e: 0f b6 08 movzbl (%eax),%ecx 107971: 40 inc %eax 107972: 89 03 mov %eax,(%ebx) if (c == ':') 107974: 83 f9 3a cmp $0x3a,%ecx 107977: 74 4a je 1079c3 break; if (sign == 0) { 107979: 85 f6 test %esi,%esi 10797b: 75 11 jne 10798e if (c == '-') { sign = -1; limit++; continue; } sign = 1; 10797d: 66 be 01 00 mov $0x1,%si for (;;) { c = getc(fp); if (c == ':') break; if (sign == 0) { if (c == '-') { 107981: 83 f9 2d cmp $0x2d,%ecx 107984: 75 08 jne 10798e sign = -1; limit++; 107986: ff 45 e4 incl -0x1c(%ebp) c = getc(fp); if (c == ':') break; if (sign == 0) { if (c == '-') { sign = -1; 107989: 83 ce ff or $0xffffffff,%esi limit++; continue; 10798c: eb be jmp 10794c } sign = 1; } if (!isdigit(c)) 10798e: a1 dc 4d 12 00 mov 0x124ddc,%eax 107993: f6 44 08 01 04 testb $0x4,0x1(%eax,%ecx,1) 107998: 74 41 je 1079db return 0; d = c - '0'; if ((i > (limit / 10)) 10799a: 8b 45 e4 mov -0x1c(%ebp),%eax 10799d: bf 0a 00 00 00 mov $0xa,%edi 1079a2: 31 d2 xor %edx,%edx 1079a4: f7 f7 div %edi 1079a6: 89 55 d4 mov %edx,-0x2c(%ebp) 1079a9: 39 45 c4 cmp %eax,-0x3c(%ebp) 1079ac: 77 2d ja 1079db } sign = 1; } if (!isdigit(c)) return 0; d = c - '0'; 1079ae: 83 e9 30 sub $0x30,%ecx if ((i > (limit / 10)) || ((i == (limit / 10)) && (d > (limit % 10)))) 1079b1: 39 45 c4 cmp %eax,-0x3c(%ebp) 1079b4: 75 04 jne 1079ba 1079b6: 39 d1 cmp %edx,%ecx 1079b8: 77 21 ja 1079db <== ALWAYS TAKEN return 0; i = i * 10 + d; 1079ba: 6b 7d c4 0a imul $0xa,-0x3c(%ebp),%edi 1079be: 8d 3c 39 lea (%ecx,%edi,1),%edi 1079c1: eb 86 jmp 107949 1079c3: 8b 7d c4 mov -0x3c(%ebp),%edi } if (sign == 0) return 0; 1079c6: 31 c0 xor %eax,%eax if ((i > (limit / 10)) || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; i = i * 10 + d; } if (sign == 0) 1079c8: 85 f6 test %esi,%esi 1079ca: 74 11 je 1079dd <== NEVER TAKEN return 0; *val = i * sign; 1079cc: 0f af f7 imul %edi,%esi 1079cf: 8b 45 e0 mov -0x20(%ebp),%eax 1079d2: 89 30 mov %esi,(%eax) return 1; 1079d4: b8 01 00 00 00 mov $0x1,%eax 1079d9: eb 02 jmp 1079dd if (!isdigit(c)) return 0; d = c - '0'; if ((i > (limit / 10)) || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; 1079db: 31 c0 xor %eax,%eax } if (sign == 0) return 0; *val = i * sign; return 1; } 1079dd: 8d 65 f4 lea -0xc(%ebp),%esp 1079e0: 5b pop %ebx 1079e1: 5e pop %esi 1079e2: 5f pop %edi 1079e3: c9 leave 1079e4: c3 ret =============================================================================== 00107a70 : FILE *fp, struct group *grp, char *buffer, size_t bufsize ) { 107a70: 55 push %ebp 107a71: 89 e5 mov %esp,%ebp 107a73: 57 push %edi 107a74: 56 push %esi 107a75: 53 push %ebx 107a76: 83 ec 34 sub $0x34,%esp 107a79: 89 c7 mov %eax,%edi 107a7b: 89 d3 mov %edx,%ebx 107a7d: 89 4d d4 mov %ecx,-0x2c(%ebp) int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 107a80: 6a 00 push $0x0 107a82: 8d 45 08 lea 0x8(%ebp),%eax 107a85: 50 push %eax 107a86: 8d 4d d4 lea -0x2c(%ebp),%ecx 107a89: 89 f8 mov %edi,%eax 107a8b: e8 55 ff ff ff call 1079e5 107a90: 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; 107a93: 31 f6 xor %esi,%esi { int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 107a95: 85 c0 test %eax,%eax 107a97: 0f 84 c2 00 00 00 je 107b5f || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) 107a9d: 50 push %eax 107a9e: 50 push %eax 107a9f: 8d 53 04 lea 0x4(%ebx),%edx 107aa2: 6a 00 push $0x0 107aa4: 8d 45 08 lea 0x8(%ebp),%eax 107aa7: 50 push %eax 107aa8: 8d 4d d4 lea -0x2c(%ebp),%ecx 107aab: 89 f8 mov %edi,%eax 107aad: e8 33 ff ff ff call 1079e5 107ab2: 83 c4 10 add $0x10,%esp 107ab5: 85 c0 test %eax,%eax 107ab7: 0f 84 a2 00 00 00 je 107b5f <== NEVER TAKEN || !scanInt(fp, &grgid) 107abd: 8d 55 e4 lea -0x1c(%ebp),%edx 107ac0: 89 f8 mov %edi,%eax 107ac2: e8 69 fe ff ff call 107930 107ac7: 85 c0 test %eax,%eax 107ac9: 0f 84 90 00 00 00 je 107b5f <== NEVER TAKEN || !scanString(fp, &grmem, &buffer, &bufsize, 1)) 107acf: 51 push %ecx 107ad0: 51 push %ecx 107ad1: 8d 55 e0 lea -0x20(%ebp),%edx 107ad4: 6a 01 push $0x1 107ad6: 8d 45 08 lea 0x8(%ebp),%eax 107ad9: 50 push %eax 107ada: 8d 4d d4 lea -0x2c(%ebp),%ecx 107add: 89 f8 mov %edi,%eax 107adf: e8 01 ff ff ff call 1079e5 107ae4: 83 c4 10 add $0x10,%esp 107ae7: 85 c0 test %eax,%eax 107ae9: 74 74 je 107b5f <== NEVER TAKEN return 0; grp->gr_gid = grgid; 107aeb: 8b 45 e4 mov -0x1c(%ebp),%eax 107aee: 66 89 43 08 mov %ax,0x8(%ebx) /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 107af2: 8b 4d e0 mov -0x20(%ebp),%ecx 107af5: 89 ca mov %ecx,%edx 107af7: b8 01 00 00 00 mov $0x1,%eax 107afc: 89 c6 mov %eax,%esi 107afe: eb 0b jmp 107b0b if(*cp == ',') memcount++; 107b00: 3c 2c cmp $0x2c,%al 107b02: 0f 94 c0 sete %al 107b05: 0f b6 c0 movzbl %al,%eax 107b08: 01 c6 add %eax,%esi grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 107b0a: 42 inc %edx 107b0b: 8a 02 mov (%edx),%al 107b0d: 84 c0 test %al,%al 107b0f: 75 ef jne 107b00 } /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) 107b11: 8d 04 b5 13 00 00 00 lea 0x13(,%esi,4),%eax return 0; 107b18: 31 f6 xor %esi,%esi } /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) 107b1a: 39 45 08 cmp %eax,0x8(%ebp) 107b1d: 72 40 jb 107b5f <== NEVER TAKEN return 0; grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15); 107b1f: 8b 45 d4 mov -0x2c(%ebp),%eax 107b22: 83 c0 0f add $0xf,%eax 107b25: 83 e0 f0 and $0xfffffff0,%eax 107b28: 89 43 0c mov %eax,0xc(%ebx) /* * Fill in pointer array */ grp->gr_mem[0] = grmem; 107b2b: 89 08 mov %ecx,(%eax) } /* * Extract a single group record from the database */ static int scangr( 107b2d: 8b 45 e0 mov -0x20(%ebp),%eax 107b30: 40 inc %eax /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 107b31: ba 01 00 00 00 mov $0x1,%edx 107b36: eb 11 jmp 107b49 if(*cp == ',') { 107b38: 80 f9 2c cmp $0x2c,%cl 107b3b: 75 0b jne 107b48 *cp = '\0'; 107b3d: c6 40 ff 00 movb $0x0,-0x1(%eax) grp->gr_mem[memcount++] = cp + 1; 107b41: 8b 4b 0c mov 0xc(%ebx),%ecx 107b44: 89 04 91 mov %eax,(%ecx,%edx,4) 107b47: 42 inc %edx 107b48: 40 inc %eax /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 107b49: 8a 48 ff mov -0x1(%eax),%cl 107b4c: 84 c9 test %cl,%cl 107b4e: 75 e8 jne 107b38 if(*cp == ',') { *cp = '\0'; grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; 107b50: 8b 43 0c mov 0xc(%ebx),%eax 107b53: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) return 1; 107b5a: be 01 00 00 00 mov $0x1,%esi } 107b5f: 89 f0 mov %esi,%eax 107b61: 8d 65 f4 lea -0xc(%ebp),%esp 107b64: 5b pop %ebx 107b65: 5e pop %esi 107b66: 5f pop %edi 107b67: c9 leave 107b68: c3 ret =============================================================================== 00107b69 : FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) { 107b69: 55 push %ebp 107b6a: 89 e5 mov %esp,%ebp 107b6c: 57 push %edi 107b6d: 56 push %esi 107b6e: 53 push %ebx 107b6f: 83 ec 34 sub $0x34,%esp 107b72: 89 c6 mov %eax,%esi 107b74: 89 d3 mov %edx,%ebx 107b76: 89 4d d4 mov %ecx,-0x2c(%ebp) int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 107b79: 8d 7d d4 lea -0x2c(%ebp),%edi 107b7c: 6a 00 push $0x0 107b7e: 8d 45 08 lea 0x8(%ebp),%eax 107b81: 50 push %eax 107b82: 89 f9 mov %edi,%ecx 107b84: 89 f0 mov %esi,%eax 107b86: e8 5a fe ff ff call 1079e5 107b8b: 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; 107b8e: 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) 107b95: 85 c0 test %eax,%eax 107b97: 0f 84 c4 00 00 00 je 107c61 || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) 107b9d: 51 push %ecx 107b9e: 51 push %ecx 107b9f: 8d 53 04 lea 0x4(%ebx),%edx 107ba2: 6a 00 push $0x0 107ba4: 8d 45 08 lea 0x8(%ebp),%eax 107ba7: 50 push %eax 107ba8: 89 f9 mov %edi,%ecx 107baa: 89 f0 mov %esi,%eax 107bac: e8 34 fe ff ff call 1079e5 107bb1: 83 c4 10 add $0x10,%esp 107bb4: 85 c0 test %eax,%eax 107bb6: 0f 84 a5 00 00 00 je 107c61 <== NEVER TAKEN || !scanInt(fp, &pwuid) 107bbc: 8d 55 e4 lea -0x1c(%ebp),%edx 107bbf: 89 f0 mov %esi,%eax 107bc1: e8 6a fd ff ff call 107930 107bc6: 85 c0 test %eax,%eax 107bc8: 0f 84 93 00 00 00 je 107c61 || !scanInt(fp, &pwgid) 107bce: 8d 55 e0 lea -0x20(%ebp),%edx 107bd1: 89 f0 mov %esi,%eax 107bd3: e8 58 fd ff ff call 107930 107bd8: 85 c0 test %eax,%eax 107bda: 0f 84 81 00 00 00 je 107c61 || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) 107be0: 52 push %edx 107be1: 52 push %edx 107be2: 8d 53 0c lea 0xc(%ebx),%edx 107be5: 6a 00 push $0x0 107be7: 8d 45 08 lea 0x8(%ebp),%eax 107bea: 50 push %eax 107beb: 89 f9 mov %edi,%ecx 107bed: 89 f0 mov %esi,%eax 107bef: e8 f1 fd ff ff call 1079e5 107bf4: 83 c4 10 add $0x10,%esp 107bf7: 85 c0 test %eax,%eax 107bf9: 74 66 je 107c61 <== NEVER TAKEN || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0) 107bfb: 50 push %eax 107bfc: 50 push %eax 107bfd: 8d 53 10 lea 0x10(%ebx),%edx 107c00: 6a 00 push $0x0 107c02: 8d 45 08 lea 0x8(%ebp),%eax 107c05: 50 push %eax 107c06: 89 f9 mov %edi,%ecx 107c08: 89 f0 mov %esi,%eax 107c0a: e8 d6 fd ff ff call 1079e5 107c0f: 83 c4 10 add $0x10,%esp 107c12: 85 c0 test %eax,%eax 107c14: 74 4b je 107c61 <== NEVER TAKEN || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0) 107c16: 51 push %ecx 107c17: 51 push %ecx 107c18: 8d 53 14 lea 0x14(%ebx),%edx 107c1b: 6a 00 push $0x0 107c1d: 8d 45 08 lea 0x8(%ebp),%eax 107c20: 50 push %eax 107c21: 89 f9 mov %edi,%ecx 107c23: 89 f0 mov %esi,%eax 107c25: e8 bb fd ff ff call 1079e5 107c2a: 83 c4 10 add $0x10,%esp 107c2d: 85 c0 test %eax,%eax 107c2f: 74 30 je 107c61 <== NEVER TAKEN || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1)) 107c31: 52 push %edx 107c32: 52 push %edx 107c33: 8d 53 18 lea 0x18(%ebx),%edx 107c36: 6a 01 push $0x1 107c38: 8d 45 08 lea 0x8(%ebp),%eax 107c3b: 50 push %eax 107c3c: 89 f9 mov %edi,%ecx 107c3e: 89 f0 mov %esi,%eax 107c40: e8 a0 fd ff ff call 1079e5 107c45: 83 c4 10 add $0x10,%esp 107c48: 85 c0 test %eax,%eax 107c4a: 74 15 je 107c61 return 0; pwd->pw_uid = pwuid; 107c4c: 8b 45 e4 mov -0x1c(%ebp),%eax 107c4f: 66 89 43 08 mov %ax,0x8(%ebx) pwd->pw_gid = pwgid; 107c53: 8b 45 e0 mov -0x20(%ebp),%eax 107c56: 66 89 43 0a mov %ax,0xa(%ebx) return 1; 107c5a: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp) } 107c61: 8b 45 d0 mov -0x30(%ebp),%eax 107c64: 8d 65 f4 lea -0xc(%ebp),%esp 107c67: 5b pop %ebx 107c68: 5e pop %esi 107c69: 5f pop %edi 107c6a: c9 leave 107c6b: c3 ret =============================================================================== 0010a8f4 : #include int sched_get_priority_max( int policy ) { 10a8f4: 55 push %ebp 10a8f5: 89 e5 mov %esp,%ebp 10a8f7: 83 ec 08 sub $0x8,%esp 10a8fa: 8b 4d 08 mov 0x8(%ebp),%ecx switch ( policy ) { 10a8fd: 83 f9 04 cmp $0x4,%ecx 10a900: 77 0b ja 10a90d 10a902: b8 01 00 00 00 mov $0x1,%eax 10a907: d3 e0 shl %cl,%eax 10a909: a8 17 test $0x17,%al 10a90b: 75 10 jne 10a91d <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a90d: e8 5a 74 00 00 call 111d6c <__errno> 10a912: c7 00 16 00 00 00 movl $0x16,(%eax) 10a918: 83 c8 ff or $0xffffffff,%eax 10a91b: eb 08 jmp 10a925 } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; 10a91d: 0f b6 05 18 22 12 00 movzbl 0x122218,%eax 10a924: 48 dec %eax } 10a925: c9 leave 10a926: c3 ret =============================================================================== 0010a928 : #include int sched_get_priority_min( int policy ) { 10a928: 55 push %ebp 10a929: 89 e5 mov %esp,%ebp 10a92b: 83 ec 08 sub $0x8,%esp 10a92e: 8b 4d 08 mov 0x8(%ebp),%ecx switch ( policy ) { 10a931: 83 f9 04 cmp $0x4,%ecx 10a934: 77 11 ja 10a947 10a936: ba 01 00 00 00 mov $0x1,%edx 10a93b: d3 e2 shl %cl,%edx default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MINIMUM_PRIORITY; 10a93d: b8 01 00 00 00 mov $0x1,%eax int sched_get_priority_min( int policy ) { switch ( policy ) { 10a942: 80 e2 17 and $0x17,%dl 10a945: 75 0e jne 10a955 <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a947: e8 20 74 00 00 call 111d6c <__errno> 10a94c: c7 00 16 00 00 00 movl $0x16,(%eax) 10a952: 83 c8 ff or $0xffffffff,%eax } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 10a955: c9 leave 10a956: c3 ret =============================================================================== 0010a958 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 10a958: 55 push %ebp 10a959: 89 e5 mov %esp,%ebp 10a95b: 56 push %esi 10a95c: 53 push %ebx 10a95d: 8b 75 08 mov 0x8(%ebp),%esi 10a960: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10a963: 85 f6 test %esi,%esi 10a965: 74 16 je 10a97d <== NEVER TAKEN 10a967: e8 b4 d0 ff ff call 107a20 10a96c: 39 c6 cmp %eax,%esi 10a96e: 74 0d je 10a97d rtems_set_errno_and_return_minus_one( ESRCH ); 10a970: e8 f7 73 00 00 call 111d6c <__errno> 10a975: c7 00 03 00 00 00 movl $0x3,(%eax) 10a97b: eb 0f jmp 10a98c if ( !interval ) 10a97d: 85 db test %ebx,%ebx 10a97f: 75 10 jne 10a991 rtems_set_errno_and_return_minus_one( EINVAL ); 10a981: e8 e6 73 00 00 call 111d6c <__errno> 10a986: c7 00 16 00 00 00 movl $0x16,(%eax) 10a98c: 83 c8 ff or $0xffffffff,%eax 10a98f: eb 13 jmp 10a9a4 _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 10a991: 50 push %eax 10a992: 50 push %eax 10a993: 53 push %ebx 10a994: ff 35 e0 62 12 00 pushl 0x1262e0 10a99a: e8 81 30 00 00 call 10da20 <_Timespec_From_ticks> return 0; 10a99f: 83 c4 10 add $0x10,%esp 10a9a2: 31 c0 xor %eax,%eax } 10a9a4: 8d 65 f8 lea -0x8(%ebp),%esp 10a9a7: 5b pop %ebx 10a9a8: 5e pop %esi 10a9a9: c9 leave 10a9aa: c3 ret =============================================================================== 0010cff0 : int sem_init( sem_t *sem, int pshared, unsigned int value ) { 10cff0: 55 push %ebp 10cff1: 89 e5 mov %esp,%ebp 10cff3: 53 push %ebx 10cff4: 83 ec 14 sub $0x14,%esp 10cff7: 8b 5d 08 mov 0x8(%ebp),%ebx int status; POSIX_Semaphore_Control *the_semaphore; if ( !sem ) 10cffa: 85 db test %ebx,%ebx 10cffc: 75 10 jne 10d00e <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10cffe: e8 65 80 00 00 call 115068 <__errno> 10d003: c7 00 16 00 00 00 movl $0x16,(%eax) 10d009: 83 c8 ff or $0xffffffff,%eax 10d00c: eb 21 jmp 10d02f status = _POSIX_Semaphore_Create_support( 10d00e: 8d 45 f4 lea -0xc(%ebp),%eax 10d011: 50 push %eax 10d012: ff 75 10 pushl 0x10(%ebp) 10d015: ff 75 0c pushl 0xc(%ebp) 10d018: 6a 00 push $0x0 10d01a: e8 8d 58 00 00 call 1128ac <_POSIX_Semaphore_Create_support> pshared, value, &the_semaphore ); if ( status != -1 ) 10d01f: 83 c4 10 add $0x10,%esp 10d022: 83 f8 ff cmp $0xffffffff,%eax 10d025: 74 08 je 10d02f *sem = the_semaphore->Object.id; 10d027: 8b 55 f4 mov -0xc(%ebp),%edx 10d02a: 8b 52 08 mov 0x8(%edx),%edx 10d02d: 89 13 mov %edx,(%ebx) return status; } 10d02f: 8b 5d fc mov -0x4(%ebp),%ebx 10d032: c9 leave 10d033: c3 ret =============================================================================== 0010d034 : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 10d034: 55 push %ebp 10d035: 89 e5 mov %esp,%ebp 10d037: 57 push %edi 10d038: 56 push %esi 10d039: 53 push %ebx 10d03a: 83 ec 2c sub $0x2c,%esp 10d03d: 8b 75 08 mov 0x8(%ebp),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10d040: a1 48 af 12 00 mov 0x12af48,%eax 10d045: 40 inc %eax 10d046: a3 48 af 12 00 mov %eax,0x12af48 va_list arg; mode_t mode; unsigned int value = 0; 10d04b: 31 ff xor %edi,%edi POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10d04d: 8b 45 0c mov 0xc(%ebp),%eax 10d050: 25 00 02 00 00 and $0x200,%eax 10d055: 89 45 d4 mov %eax,-0x2c(%ebp) 10d058: 74 03 je 10d05d va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); 10d05a: 8b 7d 14 mov 0x14(%ebp),%edi va_end(arg); } status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 10d05d: 52 push %edx 10d05e: 52 push %edx 10d05f: 8d 45 e4 lea -0x1c(%ebp),%eax 10d062: 50 push %eax 10d063: 56 push %esi 10d064: e8 77 59 00 00 call 1129e0 <_POSIX_Semaphore_Name_to_id> 10d069: 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 ) { 10d06b: 83 c4 10 add $0x10,%esp 10d06e: 85 c0 test %eax,%eax 10d070: 74 19 je 10d08b /* * 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) ) ) { 10d072: 83 f8 02 cmp $0x2,%eax 10d075: 75 06 jne 10d07d <== NEVER TAKEN 10d077: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 10d07b: 75 59 jne 10d0d6 _Thread_Enable_dispatch(); 10d07d: e8 6c 27 00 00 call 10f7ee <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 10d082: e8 e1 7f 00 00 call 115068 <__errno> 10d087: 89 18 mov %ebx,(%eax) 10d089: eb 1f jmp 10d0aa /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10d08b: 8b 45 0c mov 0xc(%ebp),%eax 10d08e: 25 00 0a 00 00 and $0xa00,%eax 10d093: 3d 00 0a 00 00 cmp $0xa00,%eax 10d098: 75 15 jne 10d0af _Thread_Enable_dispatch(); 10d09a: e8 4f 27 00 00 call 10f7ee <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 10d09f: e8 c4 7f 00 00 call 115068 <__errno> 10d0a4: c7 00 11 00 00 00 movl $0x11,(%eax) 10d0aa: 83 c8 ff or $0xffffffff,%eax 10d0ad: eb 4a jmp 10d0f9 10d0af: 50 push %eax } the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); 10d0b0: 8d 45 dc lea -0x24(%ebp),%eax 10d0b3: 50 push %eax 10d0b4: ff 75 e4 pushl -0x1c(%ebp) 10d0b7: 68 0c b2 12 00 push $0x12b20c 10d0bc: e8 db 1c 00 00 call 10ed9c <_Objects_Get> 10d0c1: 89 45 e0 mov %eax,-0x20(%ebp) the_semaphore->open_count += 1; 10d0c4: ff 40 18 incl 0x18(%eax) _Thread_Enable_dispatch(); 10d0c7: e8 22 27 00 00 call 10f7ee <_Thread_Enable_dispatch> _Thread_Enable_dispatch(); 10d0cc: e8 1d 27 00 00 call 10f7ee <_Thread_Enable_dispatch> goto return_id; 10d0d1: 83 c4 10 add $0x10,%esp 10d0d4: eb 1d jmp 10d0f3 /* * 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( 10d0d6: 8d 45 e0 lea -0x20(%ebp),%eax 10d0d9: 50 push %eax 10d0da: 57 push %edi 10d0db: 6a 00 push $0x0 10d0dd: 56 push %esi 10d0de: e8 c9 57 00 00 call 1128ac <_POSIX_Semaphore_Create_support> 10d0e3: 89 c3 mov %eax,%ebx /* * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); 10d0e5: e8 04 27 00 00 call 10f7ee <_Thread_Enable_dispatch> if ( status == -1 ) 10d0ea: 83 c4 10 add $0x10,%esp return SEM_FAILED; 10d0ed: 83 c8 ff or $0xffffffff,%eax * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); if ( status == -1 ) 10d0f0: 43 inc %ebx 10d0f1: 74 06 je 10d0f9 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; 10d0f3: 8b 45 e0 mov -0x20(%ebp),%eax 10d0f6: 83 c0 08 add $0x8,%eax #endif return id; } 10d0f9: 8d 65 f4 lea -0xc(%ebp),%esp 10d0fc: 5b pop %ebx 10d0fd: 5e pop %esi 10d0fe: 5f pop %edi 10d0ff: c9 leave 10d100: c3 ret =============================================================================== 0010a7dc : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 10a7dc: 55 push %ebp 10a7dd: 89 e5 mov %esp,%ebp 10a7df: 57 push %edi 10a7e0: 56 push %esi 10a7e1: 53 push %ebx 10a7e2: 83 ec 1c sub $0x1c,%esp 10a7e5: 8b 5d 08 mov 0x8(%ebp),%ebx 10a7e8: 8b 55 0c mov 0xc(%ebp),%edx 10a7eb: 8b 45 10 mov 0x10(%ebp),%eax ISR_Level level; if ( oact ) 10a7ee: 85 c0 test %eax,%eax 10a7f0: 74 12 je 10a804 *oact = _POSIX_signals_Vectors[ sig ]; 10a7f2: 6b f3 0c imul $0xc,%ebx,%esi 10a7f5: 81 c6 dc 78 12 00 add $0x1278dc,%esi 10a7fb: b9 03 00 00 00 mov $0x3,%ecx 10a800: 89 c7 mov %eax,%edi 10a802: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !sig ) 10a804: 85 db test %ebx,%ebx 10a806: 74 0d je 10a815 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10a808: 8d 43 ff lea -0x1(%ebx),%eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 10a80b: 83 f8 1f cmp $0x1f,%eax 10a80e: 77 05 ja 10a815 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 10a810: 83 fb 09 cmp $0x9,%ebx 10a813: 75 10 jne 10a825 rtems_set_errno_and_return_minus_one( EINVAL ); 10a815: e8 d6 77 00 00 call 111ff0 <__errno> 10a81a: c7 00 16 00 00 00 movl $0x16,(%eax) 10a820: 83 c8 ff or $0xffffffff,%eax 10a823: eb 57 jmp 10a87c * 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; 10a825: 31 c0 xor %eax,%eax /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 10a827: 85 d2 test %edx,%edx 10a829: 74 51 je 10a87c <== 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 ); 10a82b: 9c pushf 10a82c: fa cli 10a82d: 8f 45 e4 popl -0x1c(%ebp) if ( act->sa_handler == SIG_DFL ) { 10a830: 83 7a 08 00 cmpl $0x0,0x8(%edx) 10a834: 75 1a jne 10a850 _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 10a836: 6b f3 0c imul $0xc,%ebx,%esi 10a839: 8d 86 dc 78 12 00 lea 0x1278dc(%esi),%eax 10a83f: 81 c6 5c 12 12 00 add $0x12125c,%esi 10a845: b9 03 00 00 00 mov $0x3,%ecx 10a84a: 89 c7 mov %eax,%edi 10a84c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10a84e: eb 26 jmp 10a876 } else { _POSIX_signals_Clear_process_signals( sig ); 10a850: 83 ec 0c sub $0xc,%esp 10a853: 53 push %ebx 10a854: 89 55 e0 mov %edx,-0x20(%ebp) 10a857: e8 70 4e 00 00 call 10f6cc <_POSIX_signals_Clear_process_signals> _POSIX_signals_Vectors[ sig ] = *act; 10a85c: 6b db 0c imul $0xc,%ebx,%ebx 10a85f: 81 c3 dc 78 12 00 add $0x1278dc,%ebx 10a865: b9 03 00 00 00 mov $0x3,%ecx 10a86a: 8b 55 e0 mov -0x20(%ebp),%edx 10a86d: 89 df mov %ebx,%edi 10a86f: 89 d6 mov %edx,%esi 10a871: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10a873: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10a876: ff 75 e4 pushl -0x1c(%ebp) 10a879: 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; 10a87a: 31 c0 xor %eax,%eax } 10a87c: 8d 65 f4 lea -0xc(%ebp),%esp 10a87f: 5b pop %ebx 10a880: 5e pop %esi 10a881: 5f pop %edi 10a882: c9 leave 10a883: c3 ret =============================================================================== 0010ab97 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 10ab97: 55 push %ebp 10ab98: 89 e5 mov %esp,%ebp 10ab9a: 57 push %edi 10ab9b: 56 push %esi 10ab9c: 53 push %ebx 10ab9d: 83 ec 3c sub $0x3c,%esp 10aba0: 8b 75 08 mov 0x8(%ebp),%esi 10aba3: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; /* * Error check parameters before disabling interrupts. */ if ( !set ) 10aba6: 85 f6 test %esi,%esi 10aba8: 74 24 je 10abce /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; if ( timeout ) { 10abaa: 85 db test %ebx,%ebx 10abac: 74 30 je 10abde if ( !_Timespec_Is_valid( timeout ) ) 10abae: 83 ec 0c sub $0xc,%esp 10abb1: 53 push %ebx 10abb2: e8 1d 31 00 00 call 10dcd4 <_Timespec_Is_valid> 10abb7: 83 c4 10 add $0x10,%esp 10abba: 84 c0 test %al,%al 10abbc: 74 10 je 10abce rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 10abbe: 83 ec 0c sub $0xc,%esp 10abc1: 53 push %ebx 10abc2: e8 65 31 00 00 call 10dd2c <_Timespec_To_ticks> if ( !interval ) 10abc7: 83 c4 10 add $0x10,%esp 10abca: 85 c0 test %eax,%eax 10abcc: 75 12 jne 10abe0 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10abce: e8 b5 79 00 00 call 112588 <__errno> 10abd3: c7 00 16 00 00 00 movl $0x16,(%eax) 10abd9: e9 39 01 00 00 jmp 10ad17 /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; 10abde: 31 c0 xor %eax,%eax /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 10abe0: 8b 7d 0c mov 0xc(%ebp),%edi 10abe3: 85 ff test %edi,%edi 10abe5: 75 03 jne 10abea 10abe7: 8d 7d dc lea -0x24(%ebp),%edi the_thread = _Thread_Executing; 10abea: 8b 15 a8 78 12 00 mov 0x1278a8,%edx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10abf0: 8b 8a ec 00 00 00 mov 0xec(%edx),%ecx 10abf6: 89 4d d4 mov %ecx,-0x2c(%ebp) * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 10abf9: 9c pushf 10abfa: fa cli 10abfb: 8f 45 d0 popl -0x30(%ebp) if ( *set & api->signals_pending ) { 10abfe: 8b 1e mov (%esi),%ebx 10ac00: 89 5d c4 mov %ebx,-0x3c(%ebp) 10ac03: 8b 5d d4 mov -0x2c(%ebp),%ebx 10ac06: 8b 8b d4 00 00 00 mov 0xd4(%ebx),%ecx 10ac0c: 85 4d c4 test %ecx,-0x3c(%ebp) 10ac0f: 74 32 je 10ac43 /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending ); 10ac11: 83 ec 0c sub $0xc,%esp 10ac14: 51 push %ecx 10ac15: e8 3e ff ff ff call 10ab58 <_POSIX_signals_Get_lowest> 10ac1a: 89 07 mov %eax,(%edi) _POSIX_signals_Clear_signals( 10ac1c: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ac23: 6a 00 push $0x0 10ac25: 57 push %edi 10ac26: 50 push %eax 10ac27: 53 push %ebx 10ac28: e8 db 50 00 00 call 10fd08 <_POSIX_signals_Clear_signals> the_info->si_signo, the_info, false, false ); _ISR_Enable( level ); 10ac2d: ff 75 d0 pushl -0x30(%ebp) 10ac30: 9d popf the_info->si_code = SI_USER; 10ac31: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10ac38: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return the_info->si_signo; 10ac3f: 8b 1f mov (%edi),%ebx 10ac41: eb 3d jmp 10ac80 } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 10ac43: 8b 0d d0 7a 12 00 mov 0x127ad0,%ecx 10ac49: 85 4d c4 test %ecx,-0x3c(%ebp) 10ac4c: 74 3a je 10ac88 signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending ); 10ac4e: 83 ec 0c sub $0xc,%esp 10ac51: 51 push %ecx 10ac52: e8 01 ff ff ff call 10ab58 <_POSIX_signals_Get_lowest> 10ac57: 89 c3 mov %eax,%ebx _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 10ac59: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ac60: 6a 01 push $0x1 10ac62: 57 push %edi 10ac63: 50 push %eax 10ac64: ff 75 d4 pushl -0x2c(%ebp) 10ac67: e8 9c 50 00 00 call 10fd08 <_POSIX_signals_Clear_signals> _ISR_Enable( level ); 10ac6c: ff 75 d0 pushl -0x30(%ebp) 10ac6f: 9d popf the_info->si_signo = signo; 10ac70: 89 1f mov %ebx,(%edi) the_info->si_code = SI_USER; 10ac72: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10ac79: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return signo; 10ac80: 83 c4 20 add $0x20,%esp 10ac83: e9 92 00 00 00 jmp 10ad1a } the_info->si_signo = -1; 10ac88: c7 07 ff ff ff ff movl $0xffffffff,(%edi) 10ac8e: 8b 0d 60 73 12 00 mov 0x127360,%ecx 10ac94: 41 inc %ecx 10ac95: 89 0d 60 73 12 00 mov %ecx,0x127360 _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 10ac9b: c7 42 44 68 7a 12 00 movl $0x127a68,0x44(%edx) the_thread->Wait.return_code = EINTR; 10aca2: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx) the_thread->Wait.option = *set; 10aca9: 8b 0e mov (%esi),%ecx 10acab: 89 4a 30 mov %ecx,0x30(%edx) the_thread->Wait.return_argument = the_info; 10acae: 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; 10acb1: c7 05 98 7a 12 00 01 movl $0x1,0x127a98 10acb8: 00 00 00 _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue ); _ISR_Enable( level ); 10acbb: ff 75 d0 pushl -0x30(%ebp) 10acbe: 9d popf _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 10acbf: 52 push %edx 10acc0: 68 f8 d9 10 00 push $0x10d9f8 10acc5: 50 push %eax 10acc6: 68 68 7a 12 00 push $0x127a68 10accb: e8 4c 2a 00 00 call 10d71c <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10acd0: e8 c5 25 00 00 call 10d29a <_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 ); 10acd5: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10acdc: 6a 00 push $0x0 10acde: 57 push %edi 10acdf: ff 37 pushl (%edi) 10ace1: ff 75 d4 pushl -0x2c(%ebp) 10ace4: e8 1f 50 00 00 call 10fd08 <_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) 10ace9: 83 c4 20 add $0x20,%esp 10acec: a1 a8 78 12 00 mov 0x1278a8,%eax 10acf1: 83 78 34 04 cmpl $0x4,0x34(%eax) 10acf5: 75 10 jne 10ad07 || !(*set & signo_to_mask( the_info->si_signo )) ) { 10acf7: 8b 1f mov (%edi),%ebx 10acf9: 8d 4b ff lea -0x1(%ebx),%ecx 10acfc: b8 01 00 00 00 mov $0x1,%eax 10ad01: d3 e0 shl %cl,%eax 10ad03: 85 06 test %eax,(%esi) 10ad05: 75 13 jne 10ad1a errno = _Thread_Executing->Wait.return_code; 10ad07: e8 7c 78 00 00 call 112588 <__errno> 10ad0c: 8b 15 a8 78 12 00 mov 0x1278a8,%edx 10ad12: 8b 52 34 mov 0x34(%edx),%edx 10ad15: 89 10 mov %edx,(%eax) return -1; 10ad17: 83 cb ff or $0xffffffff,%ebx } return the_info->si_signo; } 10ad1a: 89 d8 mov %ebx,%eax 10ad1c: 8d 65 f4 lea -0xc(%ebp),%esp 10ad1f: 5b pop %ebx 10ad20: 5e pop %esi 10ad21: 5f pop %edi 10ad22: c9 leave 10ad23: c3 ret =============================================================================== 0010ca18 : int sigwait( const sigset_t *set, int *sig ) { 10ca18: 55 push %ebp 10ca19: 89 e5 mov %esp,%ebp 10ca1b: 53 push %ebx 10ca1c: 83 ec 08 sub $0x8,%esp 10ca1f: 8b 5d 0c mov 0xc(%ebp),%ebx int status; status = sigtimedwait( set, NULL, NULL ); 10ca22: 6a 00 push $0x0 10ca24: 6a 00 push $0x0 10ca26: ff 75 08 pushl 0x8(%ebp) 10ca29: e8 45 fe ff ff call 10c873 10ca2e: 89 c2 mov %eax,%edx if ( status != -1 ) { 10ca30: 83 c4 10 add $0x10,%esp 10ca33: 83 f8 ff cmp $0xffffffff,%eax 10ca36: 74 0a je 10ca42 if ( sig ) *sig = status; return 0; 10ca38: 31 c0 xor %eax,%eax int status; status = sigtimedwait( set, NULL, NULL ); if ( status != -1 ) { if ( sig ) 10ca3a: 85 db test %ebx,%ebx 10ca3c: 74 0b je 10ca49 <== NEVER TAKEN *sig = status; 10ca3e: 89 13 mov %edx,(%ebx) 10ca40: eb 07 jmp 10ca49 return 0; } return errno; 10ca42: e8 79 73 00 00 call 113dc0 <__errno> 10ca47: 8b 00 mov (%eax),%eax } 10ca49: 8b 5d fc mov -0x4(%ebp),%ebx 10ca4c: c9 leave 10ca4d: c3 ret =============================================================================== 00108f2c : /* * Process input character, with semaphore. */ static int siproc (unsigned char c, struct rtems_termios_tty *tty) { 108f2c: 55 push %ebp 108f2d: 89 e5 mov %esp,%ebp 108f2f: 56 push %esi 108f30: 53 push %ebx 108f31: 89 d3 mov %edx,%ebx 108f33: 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)) { 108f35: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx) 108f3c: 74 30 je 108f6e <== NEVER TAKEN rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 108f3e: 52 push %edx 108f3f: 6a 00 push $0x0 108f41: 6a 00 push $0x0 108f43: ff 73 18 pushl 0x18(%ebx) 108f46: e8 1d 12 00 00 call 10a168 i = iproc (c, tty); 108f4b: 89 f2 mov %esi,%edx 108f4d: 0f b6 c2 movzbl %dl,%eax 108f50: 89 da mov %ebx,%edx 108f52: e8 b5 fe ff ff call 108e0c 108f57: 89 c6 mov %eax,%esi rtems_semaphore_release (tty->osem); 108f59: 58 pop %eax 108f5a: ff 73 18 pushl 0x18(%ebx) 108f5d: e8 f2 12 00 00 call 10a254 108f62: 83 c4 10 add $0x10,%esp } else { i = iproc (c, tty); } return i; } 108f65: 89 f0 mov %esi,%eax 108f67: 8d 65 f8 lea -0x8(%ebp),%esp 108f6a: 5b pop %ebx 108f6b: 5e pop %esi 108f6c: c9 leave 108f6d: 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); 108f6e: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 108f71: 89 da mov %ebx,%edx <== NOT EXECUTED } return i; } 108f73: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108f76: 5b pop %ebx <== NOT EXECUTED 108f77: 5e pop %esi <== NOT EXECUTED 108f78: 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); 108f79: e9 8e fe ff ff jmp 108e0c <== NOT EXECUTED =============================================================================== 0010a100 : #include int statvfs (const char *path, struct statvfs *sb) { 10a100: 55 push %ebp 10a101: 89 e5 mov %esp,%ebp 10a103: 57 push %edi 10a104: 56 push %esi 10a105: 53 push %ebx 10a106: 83 ec 38 sub $0x38,%esp 10a109: 8b 55 08 mov 0x8(%ebp),%edx 10a10c: 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 ) ) 10a10f: 31 c0 xor %eax,%eax 10a111: 83 c9 ff or $0xffffffff,%ecx 10a114: 89 d7 mov %edx,%edi 10a116: f2 ae repnz scas %es:(%edi),%al 10a118: f7 d1 not %ecx 10a11a: 49 dec %ecx 10a11b: 6a 01 push $0x1 10a11d: 8d 5d d4 lea -0x2c(%ebp),%ebx 10a120: 53 push %ebx 10a121: 6a 00 push $0x0 10a123: 51 push %ecx 10a124: 52 push %edx 10a125: e8 28 ee ff ff call 108f52 10a12a: 83 c4 20 add $0x20,%esp return -1; 10a12d: 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 ) ) 10a130: 85 c0 test %eax,%eax 10a132: 75 26 jne 10a15a <== NEVER TAKEN return -1; mt_entry = loc.mt_entry; 10a134: 8b 55 e4 mov -0x1c(%ebp),%edx fs_mount_root = &mt_entry->mt_fs_root; memset (sb, 0, sizeof (struct statvfs)); 10a137: b9 0e 00 00 00 mov $0xe,%ecx 10a13c: 89 f7 mov %esi,%edi 10a13e: f3 ab rep stos %eax,%es:(%edi) result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb ); 10a140: 50 push %eax 10a141: 50 push %eax 10a142: 8b 42 28 mov 0x28(%edx),%eax 10a145: 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; 10a146: 83 c2 1c add $0x1c,%edx memset (sb, 0, sizeof (struct statvfs)); result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb ); 10a149: 52 push %edx 10a14a: ff 50 44 call *0x44(%eax) 10a14d: 89 c7 mov %eax,%edi rtems_filesystem_freenode( &loc ); 10a14f: 89 1c 24 mov %ebx,(%esp) 10a152: e8 b9 ee ff ff call 109010 return result; 10a157: 83 c4 10 add $0x10,%esp } 10a15a: 89 f8 mov %edi,%eax 10a15c: 8d 65 f4 lea -0xc(%ebp),%esp 10a15f: 5b pop %ebx 10a160: 5e pop %esi 10a161: 5f pop %edi 10a162: c9 leave 10a163: c3 ret =============================================================================== 00108f68 : fdatasync(fn); } /* iterate over all FILE *'s for this thread */ static void sync_per_thread(Thread_Control *t) { 108f68: 55 push %ebp 108f69: 89 e5 mov %esp,%ebp 108f6b: 53 push %ebx 108f6c: 83 ec 04 sub $0x4,%esp 108f6f: 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; 108f72: 8b 88 e4 00 00 00 mov 0xe4(%eax),%ecx if ( this_reent ) { 108f78: 85 c9 test %ecx,%ecx 108f7a: 74 32 je 108fae <== NEVER TAKEN current_reent = _Thread_Executing->libc_reent; 108f7c: 8b 15 68 68 12 00 mov 0x126868,%edx 108f82: 8b 9a e4 00 00 00 mov 0xe4(%edx),%ebx _Thread_Executing->libc_reent = this_reent; 108f88: 89 8a e4 00 00 00 mov %ecx,0xe4(%edx) _fwalk (t->libc_reent, sync_wrapper); 108f8e: 52 push %edx 108f8f: 52 push %edx 108f90: 68 b3 8f 10 00 push $0x108fb3 108f95: ff b0 e4 00 00 00 pushl 0xe4(%eax) 108f9b: e8 3c 9f 00 00 call 112edc <_fwalk> _Thread_Executing->libc_reent = current_reent; 108fa0: a1 68 68 12 00 mov 0x126868,%eax 108fa5: 89 98 e4 00 00 00 mov %ebx,0xe4(%eax) 108fab: 83 c4 10 add $0x10,%esp } } 108fae: 8b 5d fc mov -0x4(%ebp),%ebx 108fb1: c9 leave 108fb2: c3 ret =============================================================================== 00109828 : int tcsetattr( int fd, int opt, struct termios *tp ) { 109828: 55 push %ebp 109829: 89 e5 mov %esp,%ebp 10982b: 56 push %esi 10982c: 53 push %ebx 10982d: 8b 5d 08 mov 0x8(%ebp),%ebx 109830: 8b 45 0c mov 0xc(%ebp),%eax 109833: 8b 75 10 mov 0x10(%ebp),%esi switch (opt) { 109836: 85 c0 test %eax,%eax 109838: 74 22 je 10985c 10983a: 48 dec %eax 10983b: 74 0d je 10984a default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 10983d: e8 de 92 00 00 call 112b20 <__errno> 109842: c7 00 86 00 00 00 movl $0x86,(%eax) 109848: eb 2a jmp 109874 case TCSADRAIN: if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0) 10984a: 50 push %eax 10984b: 6a 00 push $0x0 10984d: 6a 03 push $0x3 10984f: 53 push %ebx 109850: e8 3f 64 00 00 call 10fc94 109855: 83 c4 10 add $0x10,%esp 109858: 85 c0 test %eax,%eax 10985a: 78 18 js 109874 <== NEVER TAKEN return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 10985c: 89 75 10 mov %esi,0x10(%ebp) 10985f: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp) 109866: 89 5d 08 mov %ebx,0x8(%ebp) } } 109869: 8d 65 f8 lea -0x8(%ebp),%esp 10986c: 5b pop %ebx 10986d: 5e pop %esi 10986e: c9 leave return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 10986f: e9 20 64 00 00 jmp 10fc94 } } 109874: 83 c8 ff or $0xffffffff,%eax 109877: 8d 65 f8 lea -0x8(%ebp),%esp 10987a: 5b pop %ebx 10987b: 5e pop %esi 10987c: c9 leave 10987d: c3 ret =============================================================================== 0010a030 : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 10a030: 55 push %ebp 10a031: 89 e5 mov %esp,%ebp 10a033: 56 push %esi 10a034: 53 push %ebx 10a035: 8b 5d 0c mov 0xc(%ebp),%ebx 10a038: 8b 75 10 mov 0x10(%ebp),%esi POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 10a03b: 83 7d 08 01 cmpl $0x1,0x8(%ebp) 10a03f: 75 1d jne 10a05e rtems_set_errno_and_return_minus_one( EINVAL ); if ( !timerid ) 10a041: 85 f6 test %esi,%esi 10a043: 74 19 je 10a05e /* * The data of the structure evp are checked in order to verify if they * are coherent. */ if (evp != NULL) { 10a045: 85 db test %ebx,%ebx 10a047: 74 22 je 10a06b /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 10a049: 8b 03 mov (%ebx),%eax 10a04b: 48 dec %eax 10a04c: 83 f8 01 cmp $0x1,%eax 10a04f: 77 0d ja 10a05e <== 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 ) 10a051: 8b 43 04 mov 0x4(%ebx),%eax 10a054: 85 c0 test %eax,%eax 10a056: 74 06 je 10a05e <== NEVER TAKEN static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10a058: 48 dec %eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 10a059: 83 f8 1f cmp $0x1f,%eax 10a05c: 76 0d jbe 10a06b <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10a05e: e8 19 7d 00 00 call 111d7c <__errno> 10a063: c7 00 16 00 00 00 movl $0x16,(%eax) 10a069: eb 2f jmp 10a09a rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a06b: a1 74 73 12 00 mov 0x127374,%eax 10a070: 40 inc %eax 10a071: a3 74 73 12 00 mov %eax,0x127374 * 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 ); 10a076: 83 ec 0c sub $0xc,%esp 10a079: 68 78 76 12 00 push $0x127678 10a07e: e8 75 1b 00 00 call 10bbf8 <_Objects_Allocate> /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 10a083: 83 c4 10 add $0x10,%esp 10a086: 85 c0 test %eax,%eax 10a088: 75 18 jne 10a0a2 _Thread_Enable_dispatch(); 10a08a: e8 77 29 00 00 call 10ca06 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 10a08f: e8 e8 7c 00 00 call 111d7c <__errno> 10a094: c7 00 0b 00 00 00 movl $0xb,(%eax) 10a09a: 83 c8 ff or $0xffffffff,%eax 10a09d: e9 83 00 00 00 jmp 10a125 } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 10a0a2: c6 40 3c 02 movb $0x2,0x3c(%eax) ptimer->thread_id = _Thread_Executing->Object.id; 10a0a6: 8b 15 bc 78 12 00 mov 0x1278bc,%edx 10a0ac: 8b 52 08 mov 0x8(%edx),%edx 10a0af: 89 50 38 mov %edx,0x38(%eax) if ( evp != NULL ) { 10a0b2: 85 db test %ebx,%ebx 10a0b4: 74 11 je 10a0c7 ptimer->inf.sigev_notify = evp->sigev_notify; 10a0b6: 8b 13 mov (%ebx),%edx 10a0b8: 89 50 40 mov %edx,0x40(%eax) ptimer->inf.sigev_signo = evp->sigev_signo; 10a0bb: 8b 53 04 mov 0x4(%ebx),%edx 10a0be: 89 50 44 mov %edx,0x44(%eax) ptimer->inf.sigev_value = evp->sigev_value; 10a0c1: 8b 53 08 mov 0x8(%ebx),%edx 10a0c4: 89 50 48 mov %edx,0x48(%eax) } ptimer->overrun = 0; 10a0c7: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax) ptimer->timer_data.it_value.tv_sec = 0; 10a0ce: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) ptimer->timer_data.it_value.tv_nsec = 0; 10a0d5: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) ptimer->timer_data.it_interval.tv_sec = 0; 10a0dc: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) ptimer->timer_data.it_interval.tv_nsec = 0; 10a0e3: 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; 10a0ea: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_watchdog->routine = routine; 10a0f1: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) the_watchdog->id = id; 10a0f8: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) the_watchdog->user_data = user_data; 10a0ff: 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 ), 10a106: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10a109: 0f b7 da movzwl %dx,%ebx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10a10c: 8b 0d 94 76 12 00 mov 0x127694,%ecx 10a112: 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; 10a115: 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; 10a11c: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 10a11e: e8 e3 28 00 00 call 10ca06 <_Thread_Enable_dispatch> return 0; 10a123: 31 c0 xor %eax,%eax } 10a125: 8d 65 f8 lea -0x8(%ebp),%esp 10a128: 5b pop %ebx 10a129: 5e pop %esi 10a12a: c9 leave 10a12b: c3 ret =============================================================================== 0010a12c : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 10a12c: 55 push %ebp 10a12d: 89 e5 mov %esp,%ebp 10a12f: 57 push %edi 10a130: 56 push %esi 10a131: 53 push %ebx 10a132: 83 ec 2c sub $0x2c,%esp 10a135: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; bool activated; uint32_t initial_period; struct itimerspec normalize; if ( !value ) 10a138: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a13c: 0f 84 58 01 00 00 je 10a29a <== 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) ) ) { 10a142: 83 ec 0c sub $0xc,%esp 10a145: 8b 45 10 mov 0x10(%ebp),%eax 10a148: 83 c0 08 add $0x8,%eax 10a14b: 50 push %eax 10a14c: e8 13 33 00 00 call 10d464 <_Timespec_Is_valid> 10a151: 83 c4 10 add $0x10,%esp 10a154: 84 c0 test %al,%al 10a156: 0f 84 3e 01 00 00 je 10a29a rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !_Timespec_Is_valid( &(value->it_interval) ) ) { 10a15c: 83 ec 0c sub $0xc,%esp 10a15f: ff 75 10 pushl 0x10(%ebp) 10a162: e8 fd 32 00 00 call 10d464 <_Timespec_Is_valid> 10a167: 83 c4 10 add $0x10,%esp 10a16a: 84 c0 test %al,%al 10a16c: 0f 84 28 01 00 00 je 10a29a <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); } if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 10a172: 85 db test %ebx,%ebx 10a174: 74 09 je 10a17f 10a176: 83 fb 04 cmp $0x4,%ebx 10a179: 0f 85 1b 01 00 00 jne 10a29a rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 10a17f: 8d 7d cc lea -0x34(%ebp),%edi 10a182: b9 04 00 00 00 mov $0x4,%ecx 10a187: 8b 75 10 mov 0x10(%ebp),%esi 10a18a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { 10a18c: 83 fb 04 cmp $0x4,%ebx 10a18f: 75 2f jne 10a1c0 struct timespec now; _TOD_Get( &now ); 10a191: 83 ec 0c sub $0xc,%esp 10a194: 8d 5d dc lea -0x24(%ebp),%ebx 10a197: 53 push %ebx 10a198: e8 b3 15 00 00 call 10b750 <_TOD_Get> /* Check for seconds in the past */ if ( _Timespec_Greater_than( &now, &normalize.it_value ) ) 10a19d: 59 pop %ecx 10a19e: 5e pop %esi 10a19f: 8d 75 d4 lea -0x2c(%ebp),%esi 10a1a2: 56 push %esi 10a1a3: 53 push %ebx 10a1a4: e8 97 32 00 00 call 10d440 <_Timespec_Greater_than> 10a1a9: 83 c4 10 add $0x10,%esp 10a1ac: 84 c0 test %al,%al 10a1ae: 0f 85 e6 00 00 00 jne 10a29a rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value ); 10a1b4: 52 push %edx 10a1b5: 56 push %esi 10a1b6: 56 push %esi 10a1b7: 53 push %ebx 10a1b8: e8 cb 32 00 00 call 10d488 <_Timespec_Subtract> 10a1bd: 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 ); 10a1c0: 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 ); 10a1c1: 8d 45 e4 lea -0x1c(%ebp),%eax 10a1c4: 50 push %eax 10a1c5: ff 75 08 pushl 0x8(%ebp) 10a1c8: 68 78 76 12 00 push $0x127678 10a1cd: e8 56 1e 00 00 call 10c028 <_Objects_Get> 10a1d2: 89 c3 mov %eax,%ebx switch ( location ) { 10a1d4: 83 c4 10 add $0x10,%esp 10a1d7: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10a1db: 0f 85 b9 00 00 00 jne 10a29a 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 ) { 10a1e1: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 10a1e5: 75 3b jne 10a222 10a1e7: 83 7d d8 00 cmpl $0x0,-0x28(%ebp) 10a1eb: 75 35 jne 10a222 /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 10a1ed: 83 ec 0c sub $0xc,%esp 10a1f0: 8d 40 10 lea 0x10(%eax),%eax 10a1f3: 50 push %eax 10a1f4: e8 5b 36 00 00 call 10d854 <_Watchdog_Remove> /* The old data of the timer are returned */ if ( ovalue ) 10a1f9: 83 c4 10 add $0x10,%esp 10a1fc: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10a200: 74 0d je 10a20f *ovalue = ptimer->timer_data; 10a202: 8d 73 54 lea 0x54(%ebx),%esi 10a205: b9 04 00 00 00 mov $0x4,%ecx 10a20a: 8b 7d 14 mov 0x14(%ebp),%edi 10a20d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* The new data are set */ ptimer->timer_data = normalize; 10a20f: 8d 7b 54 lea 0x54(%ebx),%edi 10a212: 8d 75 cc lea -0x34(%ebp),%esi 10a215: b9 04 00 00 00 mov $0x4,%ecx 10a21a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a21c: c6 43 3c 04 movb $0x4,0x3c(%ebx) 10a220: eb 35 jmp 10a257 _Thread_Enable_dispatch(); return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); 10a222: 83 ec 0c sub $0xc,%esp 10a225: ff 75 10 pushl 0x10(%ebp) 10a228: e8 8f 32 00 00 call 10d4bc <_Timespec_To_ticks> 10a22d: 89 43 64 mov %eax,0x64(%ebx) initial_period = _Timespec_To_ticks( &normalize.it_value ); 10a230: 8d 45 d4 lea -0x2c(%ebp),%eax 10a233: 89 04 24 mov %eax,(%esp) 10a236: e8 81 32 00 00 call 10d4bc <_Timespec_To_ticks> activated = _POSIX_Timer_Insert_helper( 10a23b: 89 1c 24 mov %ebx,(%esp) 10a23e: 68 b0 a2 10 00 push $0x10a2b0 10a243: ff 73 08 pushl 0x8(%ebx) 10a246: 50 push %eax 10a247: 8d 43 10 lea 0x10(%ebx),%eax 10a24a: 50 push %eax 10a24b: e8 40 57 00 00 call 10f990 <_POSIX_Timer_Insert_helper> initial_period, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 10a250: 83 c4 20 add $0x20,%esp 10a253: 84 c0 test %al,%al 10a255: 75 07 jne 10a25e _Thread_Enable_dispatch(); 10a257: e8 aa 27 00 00 call 10ca06 <_Thread_Enable_dispatch> 10a25c: eb 38 jmp 10a296 /* * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) 10a25e: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10a262: 74 0d je 10a271 *ovalue = ptimer->timer_data; 10a264: 8d 73 54 lea 0x54(%ebx),%esi 10a267: b9 04 00 00 00 mov $0x4,%ecx 10a26c: 8b 7d 14 mov 0x14(%ebp),%edi 10a26f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ptimer->timer_data = normalize; 10a271: 8d 7b 54 lea 0x54(%ebx),%edi 10a274: 8d 75 cc lea -0x34(%ebp),%esi 10a277: b9 04 00 00 00 mov $0x4,%ecx 10a27c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a27e: c6 43 3c 03 movb $0x3,0x3c(%ebx) _TOD_Get( &ptimer->time ); 10a282: 83 ec 0c sub $0xc,%esp 10a285: 83 c3 6c add $0x6c,%ebx 10a288: 53 push %ebx 10a289: e8 c2 14 00 00 call 10b750 <_TOD_Get> _Thread_Enable_dispatch(); 10a28e: e8 73 27 00 00 call 10ca06 <_Thread_Enable_dispatch> return 0; 10a293: 83 c4 10 add $0x10,%esp 10a296: 31 c0 xor %eax,%eax 10a298: eb 0e jmp 10a2a8 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10a29a: e8 dd 7a 00 00 call 111d7c <__errno> 10a29f: c7 00 16 00 00 00 movl $0x16,(%eax) 10a2a5: 83 c8 ff or $0xffffffff,%eax } 10a2a8: 8d 65 f4 lea -0xc(%ebp),%esp 10a2ab: 5b pop %ebx 10a2ac: 5e pop %esi 10a2ad: 5f pop %edi 10a2ae: c9 leave 10a2af: c3 ret =============================================================================== 00109f6c : useconds_t ualarm( useconds_t useconds, useconds_t interval ) { 109f6c: 55 push %ebp 109f6d: 89 e5 mov %esp,%ebp 109f6f: 57 push %edi 109f70: 56 push %esi 109f71: 53 push %ebx 109f72: 83 ec 1c sub $0x1c,%esp 109f75: 8b 75 08 mov 0x8(%ebp),%esi /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 109f78: 83 3d e0 7c 12 00 00 cmpl $0x0,0x127ce0 109f7f: 75 2c jne 109fad Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 109f81: c7 05 cc 7c 12 00 00 movl $0x0,0x127ccc 109f88: 00 00 00 the_watchdog->routine = routine; 109f8b: c7 05 e0 7c 12 00 34 movl $0x109f34,0x127ce0 109f92: 9f 10 00 the_watchdog->id = id; 109f95: c7 05 e4 7c 12 00 00 movl $0x0,0x127ce4 109f9c: 00 00 00 the_watchdog->user_data = user_data; 109f9f: c7 05 e8 7c 12 00 00 movl $0x0,0x127ce8 109fa6: 00 00 00 useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 109fa9: 31 db xor %ebx,%ebx 109fab: eb 4f jmp 109ffc if ( !the_timer->routine ) { _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { Watchdog_States state; state = _Watchdog_Remove( the_timer ); 109fad: 83 ec 0c sub $0xc,%esp 109fb0: 68 c4 7c 12 00 push $0x127cc4 109fb5: e8 82 34 00 00 call 10d43c <_Watchdog_Remove> if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) { 109fba: 83 e8 02 sub $0x2,%eax 109fbd: 83 c4 10 add $0x10,%esp useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 109fc0: 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) ) { 109fc2: 83 f8 01 cmp $0x1,%eax 109fc5: 77 35 ja 109ffc <== 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); 109fc7: a1 d8 7c 12 00 mov 0x127cd8,%eax 109fcc: 03 05 d0 7c 12 00 add 0x127cd0,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 109fd2: 57 push %edi 109fd3: 57 push %edi 109fd4: 8d 55 e0 lea -0x20(%ebp),%edx 109fd7: 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); 109fd8: 2b 05 dc 7c 12 00 sub 0x127cdc,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 109fde: 50 push %eax 109fdf: e8 f8 2f 00 00 call 10cfdc <_Timespec_From_ticks> remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 109fe4: 69 4d e0 40 42 0f 00 imul $0xf4240,-0x20(%ebp),%ecx remaining += tp.tv_nsec / 1000; 109feb: 8b 45 e4 mov -0x1c(%ebp),%eax 109fee: bf e8 03 00 00 mov $0x3e8,%edi 109ff3: 99 cltd 109ff4: f7 ff idiv %edi 109ff6: 8d 1c 08 lea (%eax,%ecx,1),%ebx 109ff9: 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 ) { 109ffc: 85 f6 test %esi,%esi 109ffe: 74 44 je 10a044 Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 10a000: b9 40 42 0f 00 mov $0xf4240,%ecx 10a005: 89 f0 mov %esi,%eax 10a007: 31 d2 xor %edx,%edx 10a009: f7 f1 div %ecx 10a00b: 89 45 e0 mov %eax,-0x20(%ebp) tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 10a00e: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx 10a014: 89 55 e4 mov %edx,-0x1c(%ebp) ticks = _Timespec_To_ticks( &tp ); 10a017: 83 ec 0c sub $0xc,%esp 10a01a: 8d 75 e0 lea -0x20(%ebp),%esi 10a01d: 56 push %esi 10a01e: e8 15 30 00 00 call 10d038 <_Timespec_To_ticks> if ( ticks == 0 ) ticks = 1; _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) ); 10a023: 89 34 24 mov %esi,(%esp) 10a026: e8 0d 30 00 00 call 10d038 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10a02b: a3 d0 7c 12 00 mov %eax,0x127cd0 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10a030: 59 pop %ecx 10a031: 5e pop %esi 10a032: 68 c4 7c 12 00 push $0x127cc4 10a037: 68 b4 74 12 00 push $0x1274b4 10a03c: e8 db 32 00 00 call 10d31c <_Watchdog_Insert> 10a041: 83 c4 10 add $0x10,%esp } return remaining; } 10a044: 89 d8 mov %ebx,%eax 10a046: 8d 65 f4 lea -0xc(%ebp),%esp 10a049: 5b pop %ebx 10a04a: 5e pop %esi 10a04b: 5f pop %edi 10a04c: c9 leave 10a04d: c3 ret =============================================================================== 0010a6c8 : #include int unlink( const char *path ) { 10a6c8: 55 push %ebp 10a6c9: 89 e5 mov %esp,%ebp 10a6cb: 57 push %edi 10a6cc: 56 push %esi 10a6cd: 53 push %ebx 10a6ce: 83 ec 58 sub $0x58,%esp /* * Get the node to be unlinked. Find the parent path first. */ parentpathlen = rtems_filesystem_dirname ( path ); 10a6d1: ff 75 08 pushl 0x8(%ebp) 10a6d4: e8 1a d9 ff ff call 107ff3 10a6d9: 89 45 b4 mov %eax,-0x4c(%ebp) if ( parentpathlen == 0 ) 10a6dc: 83 c4 10 add $0x10,%esp 10a6df: 85 c0 test %eax,%eax 10a6e1: 8d 45 d0 lea -0x30(%ebp),%eax 10a6e4: 75 15 jne 10a6fb rtems_filesystem_get_start_loc( path, &i, &parentloc ); 10a6e6: 51 push %ecx 10a6e7: 50 push %eax 10a6e8: 8d 45 e4 lea -0x1c(%ebp),%eax 10a6eb: 50 push %eax 10a6ec: ff 75 08 pushl 0x8(%ebp) 10a6ef: e8 d4 e6 ff ff call 108dc8 10a6f4: 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; 10a6f7: 31 db xor %ebx,%ebx 10a6f9: eb 25 jmp 10a720 parentpathlen = rtems_filesystem_dirname ( path ); if ( parentpathlen == 0 ) rtems_filesystem_get_start_loc( path, &i, &parentloc ); else { result = rtems_filesystem_evaluate_path( path, parentpathlen, 10a6fb: 83 ec 0c sub $0xc,%esp 10a6fe: 6a 00 push $0x0 10a700: 50 push %eax 10a701: 6a 02 push $0x2 10a703: ff 75 b4 pushl -0x4c(%ebp) 10a706: ff 75 08 pushl 0x8(%ebp) 10a709: e8 a4 d8 ff ff call 107fb2 10a70e: 89 c2 mov %eax,%edx RTEMS_LIBIO_PERMS_WRITE, &parentloc, false ); if ( result != 0 ) 10a710: 83 c4 20 add $0x20,%esp return -1; 10a713: 83 c8 ff or $0xffffffff,%eax else { result = rtems_filesystem_evaluate_path( path, parentpathlen, RTEMS_LIBIO_PERMS_WRITE, &parentloc, false ); if ( result != 0 ) 10a716: 85 d2 test %edx,%edx 10a718: 0f 85 d6 00 00 00 jne 10a7f4 <== NEVER TAKEN return -1; free_parentloc = true; 10a71e: b3 01 mov $0x1,%bl /* * Start from the parent to find the node that should be under it. */ loc = parentloc; 10a720: 8d 7d bc lea -0x44(%ebp),%edi 10a723: 8d 75 d0 lea -0x30(%ebp),%esi 10a726: b9 05 00 00 00 mov $0x5,%ecx 10a72b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) name = path + parentpathlen; 10a72d: 8b 75 08 mov 0x8(%ebp),%esi 10a730: 03 75 b4 add -0x4c(%ebp),%esi name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 10a733: 83 c9 ff or $0xffffffff,%ecx 10a736: 89 f7 mov %esi,%edi 10a738: 31 c0 xor %eax,%eax 10a73a: f2 ae repnz scas %es:(%edi),%al 10a73c: f7 d1 not %ecx 10a73e: 49 dec %ecx 10a73f: 52 push %edx 10a740: 52 push %edx 10a741: 51 push %ecx 10a742: 56 push %esi 10a743: e8 ea d8 ff ff call 108032 10a748: 01 c6 add %eax,%esi result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 10a74a: 83 c9 ff or $0xffffffff,%ecx 10a74d: 89 f7 mov %esi,%edi 10a74f: 31 c0 xor %eax,%eax 10a751: f2 ae repnz scas %es:(%edi),%al 10a753: f7 d1 not %ecx 10a755: 49 dec %ecx 10a756: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10a75d: 8d 7d bc lea -0x44(%ebp),%edi 10a760: 57 push %edi 10a761: 6a 00 push $0x0 10a763: 51 push %ecx 10a764: 56 push %esi 10a765: e8 ea d7 ff ff call 107f54 0, &loc, false ); if ( result != 0 ) { 10a76a: 83 c4 20 add $0x20,%esp 10a76d: 85 c0 test %eax,%eax 10a76f: 74 13 je 10a784 if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); return -1; 10a771: 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 ) 10a774: 84 db test %bl,%bl 10a776: 74 7c je 10a7f4 <== NEVER TAKEN rtems_filesystem_freenode( &parentloc ); 10a778: 83 ec 0c sub $0xc,%esp 10a77b: 8d 55 d0 lea -0x30(%ebp),%edx 10a77e: 52 push %edx 10a77f: 89 45 b0 mov %eax,-0x50(%ebp) 10a782: eb 65 jmp 10a7e9 return -1; } if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) { 10a784: 83 ec 0c sub $0xc,%esp 10a787: 57 push %edi 10a788: 8b 45 c8 mov -0x38(%ebp),%eax 10a78b: ff 50 10 call *0x10(%eax) 10a78e: 83 c4 10 add $0x10,%esp 10a791: 48 dec %eax 10a792: 75 2f jne 10a7c3 rtems_filesystem_freenode( &loc ); 10a794: 83 ec 0c sub $0xc,%esp 10a797: 57 push %edi 10a798: e8 d3 d8 ff ff call 108070 if ( free_parentloc ) 10a79d: 83 c4 10 add $0x10,%esp 10a7a0: 84 db test %bl,%bl 10a7a2: 74 0f je 10a7b3 rtems_filesystem_freenode( &parentloc ); 10a7a4: 83 ec 0c sub $0xc,%esp 10a7a7: 8d 45 d0 lea -0x30(%ebp),%eax 10a7aa: 50 push %eax 10a7ab: e8 c0 d8 ff ff call 108070 10a7b0: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EISDIR ); 10a7b3: e8 94 a0 00 00 call 11484c <__errno> 10a7b8: c7 00 15 00 00 00 movl $0x15,(%eax) 10a7be: 83 c8 ff or $0xffffffff,%eax 10a7c1: eb 31 jmp 10a7f4 } result = (*loc.ops->unlink_h)( &parentloc, &loc ); 10a7c3: 50 push %eax 10a7c4: 50 push %eax 10a7c5: 57 push %edi 10a7c6: 8d 75 d0 lea -0x30(%ebp),%esi 10a7c9: 56 push %esi 10a7ca: 8b 45 c8 mov -0x38(%ebp),%eax 10a7cd: ff 50 0c call *0xc(%eax) rtems_filesystem_freenode( &loc ); 10a7d0: 89 3c 24 mov %edi,(%esp) 10a7d3: 89 45 b0 mov %eax,-0x50(%ebp) 10a7d6: e8 95 d8 ff ff call 108070 if ( free_parentloc ) 10a7db: 83 c4 10 add $0x10,%esp 10a7de: 84 db test %bl,%bl 10a7e0: 8b 45 b0 mov -0x50(%ebp),%eax 10a7e3: 74 0f je 10a7f4 rtems_filesystem_freenode( &parentloc ); 10a7e5: 83 ec 0c sub $0xc,%esp 10a7e8: 56 push %esi 10a7e9: e8 82 d8 ff ff call 108070 10a7ee: 83 c4 10 add $0x10,%esp 10a7f1: 8b 45 b0 mov -0x50(%ebp),%eax return result; } 10a7f4: 8d 65 f4 lea -0xc(%ebp),%esp 10a7f7: 5b pop %ebx 10a7f8: 5e pop %esi 10a7f9: 5f pop %edi 10a7fa: c9 leave 10a7fb: c3 ret =============================================================================== 0010a935 : */ int unmount( const char *path ) { 10a935: 55 push %ebp 10a936: 89 e5 mov %esp,%ebp 10a938: 57 push %edi 10a939: 56 push %esi 10a93a: 53 push %ebx 10a93b: 83 ec 38 sub $0x38,%esp 10a93e: 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 ) ) 10a941: 83 cb ff or $0xffffffff,%ebx 10a944: 31 c0 xor %eax,%eax 10a946: 89 d9 mov %ebx,%ecx 10a948: 89 d7 mov %edx,%edi 10a94a: f2 ae repnz scas %es:(%edi),%al 10a94c: f7 d1 not %ecx 10a94e: 49 dec %ecx 10a94f: 6a 01 push $0x1 10a951: 8d 7d d4 lea -0x2c(%ebp),%edi 10a954: 57 push %edi 10a955: 6a 00 push $0x0 10a957: 51 push %ecx 10a958: 52 push %edx 10a959: e8 e8 d5 ff ff call 107f46 10a95e: 83 c4 20 add $0x20,%esp 10a961: 85 c0 test %eax,%eax 10a963: 0f 85 f2 00 00 00 jne 10aa5b return -1; mt_entry = loc.mt_entry; 10a969: 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 ){ 10a96c: 8b 45 d4 mov -0x2c(%ebp),%eax 10a96f: 39 46 1c cmp %eax,0x1c(%esi) 10a972: 74 1c je 10a990 rtems_filesystem_freenode( &loc ); 10a974: 83 ec 0c sub $0xc,%esp 10a977: 57 push %edi 10a978: e8 87 d6 ff ff call 108004 rtems_set_errno_and_return_minus_one( EACCES ); 10a97d: e8 52 77 00 00 call 1120d4 <__errno> 10a982: c7 00 0d 00 00 00 movl $0xd,(%eax) 10a988: 83 c4 10 add $0x10,%esp 10a98b: e9 cb 00 00 00 jmp 10aa5b /* * Free the loc node and just use the nodes from the mt_entry . */ rtems_filesystem_freenode( &loc ); 10a990: 83 ec 0c sub $0xc,%esp 10a993: 57 push %edi 10a994: e8 6b d6 ff ff call 108004 * 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 ) 10a999: 83 c4 10 add $0x10,%esp 10a99c: a1 dc 50 12 00 mov 0x1250dc,%eax 10a9a1: 39 70 14 cmp %esi,0x14(%eax) 10a9a4: 74 25 je 10a9cb /* * Verify there are no file systems below the path specified */ if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point, 10a9a6: 51 push %ecx 10a9a7: 51 push %ecx 10a9a8: ff 76 2c pushl 0x2c(%esi) 10a9ab: 68 24 a9 10 00 push $0x10a924 10a9b0: e8 44 dd ff ff call 1086f9 10a9b5: 83 c4 10 add $0x10,%esp 10a9b8: 84 c0 test %al,%al 10a9ba: 75 0f jne 10a9cb * 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 ) 10a9bc: 83 ec 0c sub $0xc,%esp 10a9bf: 56 push %esi 10a9c0: e8 27 d9 ff ff call 1082ec 10a9c5: 83 c4 10 add $0x10,%esp 10a9c8: 48 dec %eax 10a9c9: 75 10 jne 10a9db rtems_set_errno_and_return_minus_one( EBUSY ); 10a9cb: e8 04 77 00 00 call 1120d4 <__errno> 10a9d0: c7 00 10 00 00 00 movl $0x10,(%eax) 10a9d6: e9 80 00 00 00 jmp 10aa5b * 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 ) 10a9db: 83 ec 0c sub $0xc,%esp 10a9de: 8b 46 14 mov 0x14(%esi),%eax 10a9e1: 56 push %esi 10a9e2: ff 50 28 call *0x28(%eax) 10a9e5: 83 c4 10 add $0x10,%esp return -1; 10a9e8: 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 ) 10a9eb: 85 c0 test %eax,%eax 10a9ed: 75 6f jne 10aa5e <== 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){ 10a9ef: 83 ec 0c sub $0xc,%esp 10a9f2: 8b 46 28 mov 0x28(%esi),%eax 10a9f5: 56 push %esi 10a9f6: ff 50 2c call *0x2c(%eax) 10a9f9: 83 c4 10 add $0x10,%esp 10a9fc: 85 c0 test %eax,%eax 10a9fe: 74 1d je 10aa1d <== ALWAYS TAKEN if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 ) 10aa00: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa03: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED 10aa06: 56 push %esi <== NOT EXECUTED 10aa07: ff 50 20 call *0x20(%eax) <== NOT EXECUTED 10aa0a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_fatal_error_occurred( 0 ); return -1; 10aa0d: 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 ) 10aa0f: 85 c0 test %eax,%eax <== NOT EXECUTED 10aa11: 74 4b je 10aa5e <== NOT EXECUTED rtems_fatal_error_occurred( 0 ); 10aa13: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa16: 6a 00 push $0x0 <== NOT EXECUTED 10aa18: e8 9b 0e 00 00 call 10b8b8 <== 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 ); 10aa1d: 52 push %edx 10aa1e: 6a 00 push $0x0 10aa20: 6a 00 push $0x0 10aa22: ff 35 08 73 12 00 pushl 0x127308 10aa28: e8 fb 08 00 00 call 10b328 */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10aa2d: 89 34 24 mov %esi,(%esp) 10aa30: e8 4b 11 00 00 call 10bb80 <_Chain_Extract> } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10aa35: 58 pop %eax 10aa36: ff 35 08 73 12 00 pushl 0x127308 10aa3c: e8 d3 09 00 00 call 10b414 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; 10aa41: 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 ); 10aa44: 89 04 24 mov %eax,(%esp) 10aa47: e8 b8 d5 ff ff call 108004 free( mt_entry ); 10aa4c: 89 34 24 mov %esi,(%esp) 10aa4f: e8 c4 d5 ff ff call 108018 return 0; 10aa54: 83 c4 10 add $0x10,%esp 10aa57: 31 d2 xor %edx,%edx 10aa59: eb 03 jmp 10aa5e * 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; 10aa5b: 83 ca ff or $0xffffffff,%edx rtems_filesystem_freenode( fs_mount_loc ); free( mt_entry ); return 0; } 10aa5e: 89 d0 mov %edx,%eax 10aa60: 8d 65 f4 lea -0xc(%ebp),%esp 10aa63: 5b pop %ebx 10aa64: 5e pop %esi 10aa65: 5f pop %edi 10aa66: c9 leave 10aa67: c3 ret =============================================================================== 0011d30c : ssize_t write( int fd, const void *buffer, size_t count ) { 11d30c: 55 push %ebp 11d30d: 89 e5 mov %esp,%ebp 11d30f: 56 push %esi 11d310: 53 push %ebx 11d311: 8b 5d 08 mov 0x8(%ebp),%ebx 11d314: 8b 55 0c mov 0xc(%ebp),%edx 11d317: 8b 4d 10 mov 0x10(%ebp),%ecx ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11d31a: 3b 1d 44 11 12 00 cmp 0x121144,%ebx 11d320: 73 14 jae 11d336 iop = rtems_libio_iop( fd ); 11d322: 6b db 38 imul $0x38,%ebx,%ebx 11d325: 03 1d d8 51 12 00 add 0x1251d8,%ebx rtems_libio_check_is_open( iop ); 11d32b: 8b 73 14 mov 0x14(%ebx),%esi 11d32e: f7 c6 00 01 00 00 test $0x100,%esi 11d334: 75 0d jne 11d343 11d336: e8 11 3e ff ff call 11114c <__errno> 11d33b: c7 00 09 00 00 00 movl $0x9,(%eax) 11d341: eb 1a jmp 11d35d rtems_libio_check_buffer( buffer ); 11d343: 85 d2 test %edx,%edx 11d345: 74 0b je 11d352 <== NEVER TAKEN rtems_libio_check_count( count ); 11d347: 31 c0 xor %eax,%eax 11d349: 85 c9 test %ecx,%ecx 11d34b: 74 31 je 11d37e rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 11d34d: 83 e6 04 and $0x4,%esi 11d350: 75 10 jne 11d362 11d352: e8 f5 3d ff ff call 11114c <__errno> 11d357: c7 00 16 00 00 00 movl $0x16,(%eax) 11d35d: 83 c8 ff or $0xffffffff,%eax 11d360: eb 1c jmp 11d37e /* * Now process the write() request. */ rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count ); 11d362: 50 push %eax 11d363: 8b 43 20 mov 0x20(%ebx),%eax 11d366: 51 push %ecx 11d367: 52 push %edx 11d368: 53 push %ebx 11d369: ff 50 0c call *0xc(%eax) if ( rc > 0 ) 11d36c: 83 c4 10 add $0x10,%esp 11d36f: 85 c0 test %eax,%eax 11d371: 7e 0b jle 11d37e iop->offset += rc; 11d373: 89 c1 mov %eax,%ecx 11d375: c1 f9 1f sar $0x1f,%ecx 11d378: 01 43 0c add %eax,0xc(%ebx) 11d37b: 11 4b 10 adc %ecx,0x10(%ebx) return rc; } 11d37e: 8d 65 f8 lea -0x8(%ebp),%esp 11d381: 5b pop %ebx 11d382: 5e pop %esi 11d383: c9 leave 11d384: c3 ret =============================================================================== 0010a93c : ssize_t writev( int fd, const struct iovec *iov, int iovcnt ) { 10a93c: 55 push %ebp 10a93d: 89 e5 mov %esp,%ebp 10a93f: 57 push %edi 10a940: 56 push %esi 10a941: 53 push %ebx 10a942: 83 ec 1c sub $0x1c,%esp 10a945: 8b 75 08 mov 0x8(%ebp),%esi 10a948: 8b 7d 0c mov 0xc(%ebp),%edi int bytes; rtems_libio_t *iop; ssize_t old; bool all_zeros; rtems_libio_check_fd( fd ); 10a94b: 3b 35 44 21 12 00 cmp 0x122144,%esi 10a951: 73 11 jae 10a964 iop = rtems_libio_iop( fd ); 10a953: 6b f6 38 imul $0x38,%esi,%esi 10a956: 03 35 d8 61 12 00 add 0x1261d8,%esi rtems_libio_check_is_open( iop ); 10a95c: 8b 46 14 mov 0x14(%esi),%eax 10a95f: f6 c4 01 test $0x1,%ah 10a962: 75 10 jne 10a974 10a964: e8 c3 73 00 00 call 111d2c <__errno> 10a969: c7 00 09 00 00 00 movl $0x9,(%eax) 10a96f: e9 ad 00 00 00 jmp 10aa21 rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 10a974: a8 04 test $0x4,%al 10a976: 74 42 je 10a9ba <== NEVER TAKEN /* * Argument validation on IO vector */ if ( !iov ) 10a978: 85 ff test %edi,%edi 10a97a: 74 3e je 10a9ba rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt <= 0 ) 10a97c: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a980: 7e 38 jle 10a9ba rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt > IOV_MAX ) 10a982: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp) 10a989: 7f 2f jg 10a9ba <== NEVER TAKEN 10a98b: b2 01 mov $0x1,%dl 10a98d: 31 c0 xor %eax,%eax 10a98f: 31 c9 xor %ecx,%ecx 10a991: eb 02 jmp 10a995 if ( iov[v].iov_len ) all_zeros = false; /* check for wrap */ old = total; total += iov[v].iov_len; 10a993: 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 ) 10a995: 83 3c c7 00 cmpl $0x0,(%edi,%eax,8) 10a999: 74 1f je 10a9ba rtems_set_errno_and_return_minus_one( EINVAL ); if ( iov[v].iov_len ) all_zeros = false; 10a99b: 83 7c c7 04 00 cmpl $0x0,0x4(%edi,%eax,8) 10a9a0: 0f 94 c3 sete %bl 10a9a3: f7 db neg %ebx 10a9a5: 21 da and %ebx,%edx /* check for wrap */ old = total; total += iov[v].iov_len; 10a9a7: 8b 5c c7 04 mov 0x4(%edi,%eax,8),%ebx 10a9ab: 8d 1c 19 lea (%ecx,%ebx,1),%ebx if ( total < old || total > SSIZE_MAX ) 10a9ae: 81 fb ff 7f 00 00 cmp $0x7fff,%ebx 10a9b4: 7f 04 jg 10a9ba <== NEVER TAKEN 10a9b6: 39 cb cmp %ecx,%ebx 10a9b8: 7d 0d jge 10a9c7 rtems_set_errno_and_return_minus_one( EINVAL ); 10a9ba: e8 6d 73 00 00 call 111d2c <__errno> 10a9bf: c7 00 16 00 00 00 movl $0x16,(%eax) 10a9c5: eb 5a jmp 10aa21 * 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++ ) { 10a9c7: 40 inc %eax 10a9c8: 3b 45 10 cmp 0x10(%ebp),%eax 10a9cb: 7c c6 jl 10a993 /* * A writev with all zeros is supposed to have no effect per OpenGroup. */ if ( all_zeros == true ) { return 0; 10a9cd: 31 db xor %ebx,%ebx } /* * A writev with all zeros is supposed to have no effect per OpenGroup. */ if ( all_zeros == true ) { 10a9cf: 84 d2 test %dl,%dl 10a9d1: 75 51 jne 10aa24 10a9d3: 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 ) 10a9da: 8b 55 e4 mov -0x1c(%ebp),%edx 10a9dd: 8b 44 d7 04 mov 0x4(%edi,%edx,8),%eax 10a9e1: 85 c0 test %eax,%eax 10a9e3: 74 2f je 10aa14 <== NEVER TAKEN continue; bytes = (*iop->pathinfo.handlers->write_h)( 10a9e5: 52 push %edx 10a9e6: 8b 56 20 mov 0x20(%esi),%edx 10a9e9: 50 push %eax 10a9ea: 8b 45 e4 mov -0x1c(%ebp),%eax 10a9ed: ff 34 c7 pushl (%edi,%eax,8) 10a9f0: 56 push %esi 10a9f1: ff 52 0c call *0xc(%edx) iop, iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) 10a9f4: 83 c4 10 add $0x10,%esp 10a9f7: 83 f8 00 cmp $0x0,%eax 10a9fa: 7c 25 jl 10aa21 <== NEVER TAKEN return -1; if ( bytes > 0 ) { 10a9fc: 74 0d je 10aa0b <== NEVER TAKEN iop->offset += bytes; 10a9fe: 89 c1 mov %eax,%ecx 10aa00: c1 f9 1f sar $0x1f,%ecx 10aa03: 01 46 0c add %eax,0xc(%esi) 10aa06: 11 4e 10 adc %ecx,0x10(%esi) total += bytes; 10aa09: 01 c3 add %eax,%ebx } if (bytes != iov[ v ].iov_len) 10aa0b: 8b 55 e4 mov -0x1c(%ebp),%edx 10aa0e: 3b 44 d7 04 cmp 0x4(%edi,%edx,8),%eax 10aa12: 75 10 jne 10aa24 <== NEVER TAKEN } /* * Now process the writev(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { 10aa14: ff 45 e4 incl -0x1c(%ebp) 10aa17: 8b 45 10 mov 0x10(%ebp),%eax 10aa1a: 39 45 e4 cmp %eax,-0x1c(%ebp) 10aa1d: 7c bb jl 10a9da 10aa1f: eb 03 jmp 10aa24 iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) return -1; 10aa21: 83 cb ff or $0xffffffff,%ebx if (bytes != iov[ v ].iov_len) break; } return total; } 10aa24: 89 d8 mov %ebx,%eax 10aa26: 8d 65 f4 lea -0xc(%ebp),%esp 10aa29: 5b pop %ebx 10aa2a: 5e pop %esi 10aa2b: 5f pop %edi 10aa2c: c9 leave 10aa2d: c3 ret