=============================================================================== 0010d5b8 : #define MAXSYMLINK 5 int IMFS_Set_handlers( rtems_filesystem_location_info_t *loc ) { 10d5b8: 55 push %ebp 10d5b9: 89 e5 mov %esp,%ebp 10d5bb: 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; 10d5be: 8b 50 10 mov 0x10(%eax),%edx 10d5c1: 8b 52 34 mov 0x34(%edx),%edx switch( node->type ) { 10d5c4: 8b 08 mov (%eax),%ecx 10d5c6: 8b 49 4c mov 0x4c(%ecx),%ecx 10d5c9: 49 dec %ecx 10d5ca: 83 f9 06 cmp $0x6,%ecx 10d5cd: 77 29 ja 10d5f8 <== NEVER TAKEN 10d5cf: ff 24 8d 3c ea 11 00 jmp *0x11ea3c(,%ecx,4) case IMFS_DIRECTORY: loc->handlers = fs_info->directory_handlers; 10d5d6: 8b 52 0c mov 0xc(%edx),%edx 10d5d9: eb 1a jmp 10d5f5 break; case IMFS_DEVICE: loc->handlers = &IMFS_device_handlers; 10d5db: c7 40 08 60 ea 11 00 movl $0x11ea60,0x8(%eax) break; 10d5e2: eb 14 jmp 10d5f8 case IMFS_SYM_LINK: case IMFS_HARD_LINK: loc->handlers = &IMFS_link_handlers; 10d5e4: c7 40 08 d0 ea 11 00 movl $0x11ead0,0x8(%eax) break; 10d5eb: eb 0b jmp 10d5f8 case IMFS_LINEAR_FILE: loc->handlers = fs_info->memfile_handlers; break; case IMFS_MEMORY_FILE: loc->handlers = fs_info->memfile_handlers; 10d5ed: 8b 52 08 mov 0x8(%edx),%edx 10d5f0: eb 03 jmp 10d5f5 break; case IMFS_FIFO: loc->handlers = fs_info->fifo_handlers; 10d5f2: 8b 52 10 mov 0x10(%edx),%edx 10d5f5: 89 50 08 mov %edx,0x8(%eax) break; } return 0; } 10d5f8: 31 c0 xor %eax,%eax 10d5fa: c9 leave 10d5fb: c3 ret =============================================================================== 0010d46b : IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) { 10d46b: 55 push %ebp 10d46c: 89 e5 mov %esp,%ebp 10d46e: 57 push %edi 10d46f: 56 push %esi 10d470: 53 push %ebx 10d471: 83 ec 1c sub $0x1c,%esp 10d474: 8b 4d 08 mov 0x8(%ebp),%ecx 10d477: 8b 5d 0c mov 0xc(%ebp),%ebx 10d47a: 8b 75 18 mov 0x18(%ebp),%esi /* * MUST have a parent node to call this routine. */ if ( parent_loc == NULL ) return NULL; 10d47d: 31 c0 xor %eax,%eax IMFS_fs_info_t *fs_info; /* * MUST have a parent node to call this routine. */ if ( parent_loc == NULL ) 10d47f: 85 c9 test %ecx,%ecx 10d481: 0f 84 f4 00 00 00 je 10d57b <== NEVER TAKEN return NULL; parent = parent_loc->node_access; 10d487: 8b 11 mov (%ecx),%edx fs_info = parent_loc->mt_entry->fs_info; 10d489: 8b 49 10 mov 0x10(%ecx),%ecx 10d48c: 8b 79 34 mov 0x34(%ecx),%edi /* * Reject creation of FIFOs if support is disabled. */ if ( type == IMFS_FIFO && 10d48f: 83 fb 07 cmp $0x7,%ebx 10d492: 75 0d jne 10d4a1 10d494: 81 7f 10 d4 e9 11 00 cmpl $0x11e9d4,0x10(%edi) 10d49b: 0f 84 da 00 00 00 je 10d57b return NULL; /* * Allocate filesystem node and fill in basic information */ node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask ); 10d4a1: 50 push %eax 10d4a2: a1 50 20 12 00 mov 0x122050,%eax 10d4a7: 8b 40 2c mov 0x2c(%eax),%eax 10d4aa: f7 d0 not %eax 10d4ac: 23 45 14 and 0x14(%ebp),%eax 10d4af: 50 push %eax 10d4b0: ff 75 10 pushl 0x10(%ebp) 10d4b3: 53 push %ebx 10d4b4: 89 55 e4 mov %edx,-0x1c(%ebp) 10d4b7: e8 40 ff ff ff call 10d3fc if ( !node ) 10d4bc: 83 c4 10 add $0x10,%esp 10d4bf: 85 c0 test %eax,%eax 10d4c1: 8b 55 e4 mov -0x1c(%ebp),%edx 10d4c4: 0f 84 b1 00 00 00 je 10d57b return NULL; /* * Set the type specific information */ if ( type == IMFS_DIRECTORY ) { 10d4ca: 83 fb 01 cmp $0x1,%ebx 10d4cd: 75 15 jne 10d4e4 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10d4cf: 8d 48 54 lea 0x54(%eax),%ecx 10d4d2: 89 48 50 mov %ecx,0x50(%eax) RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 10d4d5: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) rtems_chain_initialize_empty(&node->info.directory.Entries); 10d4dc: 8d 48 50 lea 0x50(%eax),%ecx 10d4df: 89 48 58 mov %ecx,0x58(%eax) 10d4e2: eb 75 jmp 10d559 } else if ( type == IMFS_HARD_LINK ) { 10d4e4: 83 fb 03 cmp $0x3,%ebx 10d4e7: 74 05 je 10d4ee node->info.hard_link.link_node = info->hard_link.link_node; } else if ( type == IMFS_SYM_LINK ) { 10d4e9: 83 fb 04 cmp $0x4,%ebx 10d4ec: 75 07 jne 10d4f5 node->info.sym_link.name = info->sym_link.name; 10d4ee: 8b 0e mov (%esi),%ecx 10d4f0: 89 48 50 mov %ecx,0x50(%eax) 10d4f3: eb 64 jmp 10d559 } else if ( type == IMFS_DEVICE ) { 10d4f5: 83 fb 02 cmp $0x2,%ebx 10d4f8: 75 0d jne 10d507 node->info.device.major = info->device.major; 10d4fa: 8b 0e mov (%esi),%ecx 10d4fc: 89 48 50 mov %ecx,0x50(%eax) node->info.device.minor = info->device.minor; 10d4ff: 8b 4e 04 mov 0x4(%esi),%ecx 10d502: 89 48 54 mov %ecx,0x54(%eax) 10d505: eb 52 jmp 10d559 } else if ( type == IMFS_LINEAR_FILE ) { 10d507: 83 fb 06 cmp $0x6,%ebx 10d50a: 75 17 jne 10d523 node->info.linearfile.size = 0; 10d50c: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10d513: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.linearfile.direct = 0; 10d51a: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) 10d521: eb 36 jmp 10d559 } else if ( type == IMFS_MEMORY_FILE ) { 10d523: 83 fb 05 cmp $0x5,%ebx 10d526: 75 25 jne 10d54d node->info.file.size = 0; 10d528: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10d52f: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.file.indirect = 0; 10d536: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) node->info.file.doubly_indirect = 0; 10d53d: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) node->info.file.triply_indirect = 0; 10d544: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) 10d54b: eb 0c jmp 10d559 } else if ( type == IMFS_FIFO ) { 10d54d: 83 fb 07 cmp $0x7,%ebx 10d550: 75 07 jne 10d559 <== NEVER TAKEN node->info.fifo.pipe = NULL; 10d552: 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; 10d559: 89 50 08 mov %edx,0x8(%eax) node->st_ino = ++fs_info->ino_count; 10d55c: 8b 4f 04 mov 0x4(%edi),%ecx 10d55f: 41 inc %ecx 10d560: 89 4f 04 mov %ecx,0x4(%edi) 10d563: 89 48 38 mov %ecx,0x38(%eax) 10d566: 53 push %ebx 10d567: 53 push %ebx 10d568: 50 push %eax rtems_chain_append( &parent->info.directory.Entries, &node->Node ); 10d569: 83 c2 50 add $0x50,%edx 10d56c: 52 push %edx 10d56d: 89 45 e4 mov %eax,-0x1c(%ebp) 10d570: e8 5b d4 ff ff call 10a9d0 <_Chain_Append> return node; 10d575: 83 c4 10 add $0x10,%esp 10d578: 8b 45 e4 mov -0x1c(%ebp),%eax } 10d57b: 8d 65 f4 lea -0xc(%ebp),%esp 10d57e: 5b pop %ebx 10d57f: 5e pop %esi 10d580: 5f pop %edi 10d581: c9 leave 10d582: c3 ret =============================================================================== 0010d699 : const char *pathname, /* IN */ size_t pathnamelen, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10d699: 55 push %ebp 10d69a: 89 e5 mov %esp,%ebp 10d69c: 57 push %edi 10d69d: 56 push %esi 10d69e: 53 push %ebx 10d69f: 83 ec 5c sub $0x5c,%esp 10d6a2: 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 ) ) { 10d6a5: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp) 10d6ac: 74 0d je 10d6bb <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EIO ); 10d6ae: e8 f9 39 00 00 call 1110ac <__errno> <== NOT EXECUTED 10d6b3: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 10d6b9: eb 42 jmp 10d6fd <== NOT EXECUTED /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10d6bb: 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; 10d6bd: 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; 10d6c2: 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) ) { 10d6c9: e9 29 01 00 00 jmp 10d7f7 type = IMFS_get_token( &pathname[i], pathnamelen, token, &len ); 10d6ce: 8d 45 e4 lea -0x1c(%ebp),%eax 10d6d1: 50 push %eax 10d6d2: 8d 4d af lea -0x51(%ebp),%ecx 10d6d5: 51 push %ecx 10d6d6: ff 75 0c pushl 0xc(%ebp) 10d6d9: 8b 45 08 mov 0x8(%ebp),%eax 10d6dc: 03 45 a4 add -0x5c(%ebp),%eax 10d6df: 50 push %eax 10d6e0: e8 b3 05 00 00 call 10dc98 10d6e5: 89 c6 mov %eax,%esi pathnamelen -= len; 10d6e7: 8b 55 e4 mov -0x1c(%ebp),%edx i += len; if ( !pathloc->node_access ) 10d6ea: 83 c4 10 add $0x10,%esp 10d6ed: 83 3b 00 cmpl $0x0,(%ebx) 10d6f0: 75 13 jne 10d705 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOENT ); 10d6f2: e8 b5 39 00 00 call 1110ac <__errno> 10d6f7: c7 00 02 00 00 00 movl $0x2,(%eax) 10d6fd: 83 cf ff or $0xffffffff,%edi 10d700: e9 75 01 00 00 jmp 10d87a /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10d705: 85 c0 test %eax,%eax 10d707: 74 21 je 10d72a if ( node->type == IMFS_DIRECTORY ) 10d709: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10d70d: 75 1b jne 10d72a if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10d70f: 57 push %edi 10d710: 57 push %edi 10d711: 6a 01 push $0x1 10d713: 53 push %ebx 10d714: 89 55 a0 mov %edx,-0x60(%ebp) 10d717: e8 e0 fe ff ff call 10d5fc 10d71c: 83 c4 10 add $0x10,%esp 10d71f: 85 c0 test %eax,%eax 10d721: 8b 55 a0 mov -0x60(%ebp),%edx 10d724: 0f 84 3e 01 00 00 je 10d868 */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], pathnamelen, token, &len ); pathnamelen -= len; 10d72a: 29 55 0c sub %edx,0xc(%ebp) i += len; 10d72d: 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; 10d730: 8b 3b mov (%ebx),%edi switch( type ) { 10d732: 83 fe 03 cmp $0x3,%esi 10d735: 74 38 je 10d76f 10d737: 83 fe 04 cmp $0x4,%esi 10d73a: 0f 84 a7 00 00 00 je 10d7e7 10d740: 83 fe 02 cmp $0x2,%esi 10d743: 0f 85 ae 00 00 00 jne 10d7f7 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10d749: a1 50 20 12 00 mov 0x122050,%eax 10d74e: 3b 78 18 cmp 0x18(%eax),%edi 10d751: 0f 84 a0 00 00 00 je 10d7f7 /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access) { 10d757: 8b 43 10 mov 0x10(%ebx),%eax /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == 10d75a: 3b 78 1c cmp 0x1c(%eax),%edi 10d75d: 75 0b jne 10d76a */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; /* Throw out the .. in this case */ } else { newloc = pathloc->mt_entry->mt_point_node; 10d75f: 8d 7d d0 lea -0x30(%ebp),%edi 10d762: 8d 70 08 lea 0x8(%eax),%esi 10d765: e9 ad 00 00 00 jmp 10d817 pathnamelen+len, flags,pathloc); } } else { if ( !node->Parent ) 10d76a: 8b 7f 08 mov 0x8(%edi),%edi 10d76d: eb 6c jmp 10d7db case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { 10d76f: 8b 47 4c mov 0x4c(%edi),%eax 10d772: 83 f8 03 cmp $0x3,%eax 10d775: 75 11 jne 10d788 IMFS_evaluate_hard_link( pathloc, 0 ); 10d777: 51 push %ecx 10d778: 51 push %ecx 10d779: 6a 00 push $0x0 10d77b: 53 push %ebx 10d77c: e8 d9 fe ff ff call 10d65a node = pathloc->node_access; 10d781: 8b 3b mov (%ebx),%edi 10d783: 83 c4 10 add $0x10,%esp 10d786: eb 1d jmp 10d7a5 * It would be a design error if we evaluated the link and * was broken. */ IMFS_assert( node ); } else if ( node->type == IMFS_SYM_LINK ) { 10d788: 83 f8 04 cmp $0x4,%eax 10d78b: 75 18 jne 10d7a5 result = IMFS_evaluate_sym_link( pathloc, 0 ); 10d78d: 52 push %edx 10d78e: 52 push %edx 10d78f: 6a 00 push $0x0 10d791: 53 push %ebx 10d792: e8 ed 00 00 00 call 10d884 /* * In contrast to a hard link, it is possible to have a broken * symbolic link. */ node = pathloc->node_access; 10d797: 8b 3b mov (%ebx),%edi if ( result == -1 ) 10d799: 83 c4 10 add $0x10,%esp 10d79c: 83 f8 ff cmp $0xffffffff,%eax 10d79f: 0f 84 d3 00 00 00 je 10d878 <== NEVER TAKEN } /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10d7a5: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10d7a9: 74 10 je 10d7bb rtems_set_errno_and_return_minus_one( ENOTDIR ); 10d7ab: e8 fc 38 00 00 call 1110ac <__errno> 10d7b0: c7 00 14 00 00 00 movl $0x14,(%eax) 10d7b6: e9 42 ff ff ff jmp 10d6fd /* * 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 ) { 10d7bb: 8b 47 5c mov 0x5c(%edi),%eax 10d7be: 85 c0 test %eax,%eax 10d7c0: 74 08 je 10d7ca newloc = node->info.directory.mt_fs->mt_fs_root; 10d7c2: 8d 7d d0 lea -0x30(%ebp),%edi 10d7c5: 8d 70 1c lea 0x1c(%eax),%esi 10d7c8: eb 4d jmp 10d817 } /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10d7ca: 50 push %eax 10d7cb: 50 push %eax 10d7cc: 8d 45 af lea -0x51(%ebp),%eax 10d7cf: 50 push %eax 10d7d0: 57 push %edi 10d7d1: e8 56 04 00 00 call 10dc2c 10d7d6: 89 c7 mov %eax,%edi if ( !node ) 10d7d8: 83 c4 10 add $0x10,%esp 10d7db: 85 ff test %edi,%edi 10d7dd: 0f 84 0f ff ff ff je 10d6f2 /* * Set the node access to the point we have found. */ pathloc->node_access = node; 10d7e3: 89 3b mov %edi,(%ebx) 10d7e5: eb 10 jmp 10d7f7 case IMFS_NO_MORE_PATH: case IMFS_CURRENT_DIR: break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10d7e7: e8 c0 38 00 00 call 1110ac <__errno> 10d7ec: c7 00 5b 00 00 00 movl $0x5b,(%eax) 10d7f2: e9 06 ff ff ff jmp 10d6fd /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 10d7f7: 83 fe 04 cmp $0x4,%esi 10d7fa: 74 08 je 10d804 <== NEVER TAKEN 10d7fc: 85 f6 test %esi,%esi 10d7fe: 0f 85 ca fe ff ff jne 10d6ce * 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 ) { 10d804: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10d808: 75 41 jne 10d84b if ( node->info.directory.mt_fs != NULL ) { 10d80a: 8b 77 5c mov 0x5c(%edi),%esi 10d80d: 85 f6 test %esi,%esi 10d80f: 74 3a je 10d84b newloc = node->info.directory.mt_fs->mt_fs_root; 10d811: 8d 7d d0 lea -0x30(%ebp),%edi 10d814: 83 c6 1c add $0x1c,%esi 10d817: b9 05 00 00 00 mov $0x5,%ecx 10d81c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10d81e: 8d 75 d0 lea -0x30(%ebp),%esi 10d821: b1 05 mov $0x5,%cl 10d823: 89 df mov %ebx,%edi 10d825: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalpath_h)( &pathname[i-len], 10d827: 8b 45 e4 mov -0x1c(%ebp),%eax 10d82a: 8b 53 0c mov 0xc(%ebx),%edx 10d82d: 53 push %ebx 10d82e: ff 75 10 pushl 0x10(%ebp) 10d831: 8b 4d 0c mov 0xc(%ebp),%ecx 10d834: 01 c1 add %eax,%ecx 10d836: 51 push %ecx 10d837: 8b 4d a4 mov -0x5c(%ebp),%ecx 10d83a: 29 c1 sub %eax,%ecx 10d83c: 8b 45 08 mov 0x8(%ebp),%eax 10d83f: 01 c8 add %ecx,%eax 10d841: 50 push %eax 10d842: ff 12 call *(%edx) 10d844: 89 c7 mov %eax,%edi 10d846: 83 c4 10 add $0x10,%esp 10d849: eb 2f jmp 10d87a flags, pathloc ); } else { result = IMFS_Set_handlers( pathloc ); } } else { result = IMFS_Set_handlers( pathloc ); 10d84b: 83 ec 0c sub $0xc,%esp 10d84e: 53 push %ebx 10d84f: e8 64 fd ff ff call 10d5b8 10d854: 89 c7 mov %eax,%edi 10d856: 5a pop %edx 10d857: 59 pop %ecx /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) 10d858: ff 75 10 pushl 0x10(%ebp) 10d85b: 53 push %ebx 10d85c: e8 9b fd ff ff call 10d5fc 10d861: 83 c4 10 add $0x10,%esp 10d864: 85 c0 test %eax,%eax 10d866: 75 12 jne 10d87a rtems_set_errno_and_return_minus_one( EACCES ); 10d868: e8 3f 38 00 00 call 1110ac <__errno> 10d86d: c7 00 0d 00 00 00 movl $0xd,(%eax) 10d873: e9 85 fe ff ff jmp 10d6fd 10d878: 89 c7 mov %eax,%edi <== NOT EXECUTED return result; } 10d87a: 89 f8 mov %edi,%eax 10d87c: 8d 65 f4 lea -0xc(%ebp),%esp 10d87f: 5b pop %ebx 10d880: 5e pop %esi 10d881: 5f pop %edi 10d882: c9 leave 10d883: c3 ret =============================================================================== 0010d978 : int IMFS_evaluate_for_make( const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) { 10d978: 55 push %ebp 10d979: 89 e5 mov %esp,%ebp 10d97b: 57 push %edi 10d97c: 56 push %esi 10d97d: 53 push %ebx 10d97e: 83 ec 5c sub $0x5c,%esp 10d981: 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; 10d984: 8b 1a mov (%edx),%ebx /* * Get the path length. */ pathlen = strlen( path ); 10d986: 31 c0 xor %eax,%eax 10d988: 83 c9 ff or $0xffffffff,%ecx 10d98b: 8b 7d 08 mov 0x8(%ebp),%edi 10d98e: f2 ae repnz scas %es:(%edi),%al 10d990: f7 d1 not %ecx 10d992: 49 dec %ecx 10d993: 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; 10d996: 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 ); 10d99d: 8d 7d af lea -0x51(%ebp),%edi 10d9a0: 89 d6 mov %edx,%esi 10d9a2: 8d 45 e4 lea -0x1c(%ebp),%eax 10d9a5: 50 push %eax 10d9a6: 57 push %edi 10d9a7: ff 75 a0 pushl -0x60(%ebp) 10d9aa: 8b 45 08 mov 0x8(%ebp),%eax 10d9ad: 03 45 a4 add -0x5c(%ebp),%eax 10d9b0: 50 push %eax 10d9b1: e8 e2 02 00 00 call 10dc98 10d9b6: 89 c2 mov %eax,%edx pathlen -= len; 10d9b8: 8b 4d e4 mov -0x1c(%ebp),%ecx 10d9bb: 29 4d a0 sub %ecx,-0x60(%ebp) i += len; if ( !pathloc->node_access ) 10d9be: 83 c4 10 add $0x10,%esp 10d9c1: 83 3e 00 cmpl $0x0,(%esi) 10d9c4: 0f 84 79 01 00 00 je 10db43 <== NEVER TAKEN /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10d9ca: 85 c0 test %eax,%eax 10d9cc: 74 36 je 10da04 if ( node->type == IMFS_DIRECTORY ) 10d9ce: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10d9d2: 75 30 jne 10da04 if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10d9d4: 53 push %ebx 10d9d5: 53 push %ebx 10d9d6: 6a 01 push $0x1 10d9d8: 56 push %esi 10d9d9: 89 45 9c mov %eax,-0x64(%ebp) 10d9dc: 89 4d 98 mov %ecx,-0x68(%ebp) 10d9df: e8 18 fc ff ff call 10d5fc 10d9e4: 83 c4 10 add $0x10,%esp 10d9e7: 85 c0 test %eax,%eax 10d9e9: 8b 55 9c mov -0x64(%ebp),%edx 10d9ec: 8b 4d 98 mov -0x68(%ebp),%ecx 10d9ef: 75 13 jne 10da04 rtems_set_errno_and_return_minus_one( EACCES ); 10d9f1: e8 b6 36 00 00 call 1110ac <__errno> 10d9f6: c7 00 0d 00 00 00 movl $0xd,(%eax) 10d9fc: 83 cb ff or $0xffffffff,%ebx 10d9ff: e9 99 01 00 00 jmp 10db9d while( !done ) { type = IMFS_get_token( &path[i], pathlen, token, &len ); pathlen -= len; i += len; 10da04: 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; 10da07: 8b 1e mov (%esi),%ebx switch( type ) { 10da09: 83 fa 02 cmp $0x2,%edx 10da0c: 74 1f je 10da2d 10da0e: 77 0a ja 10da1a 10da10: 85 d2 test %edx,%edx 10da12: 0f 84 d9 00 00 00 je 10daf1 10da18: eb 88 jmp 10d9a2 10da1a: 83 fa 03 cmp $0x3,%edx 10da1d: 74 40 je 10da5f 10da1f: 83 fa 04 cmp $0x4,%edx 10da22: 0f 85 7a ff ff ff jne 10d9a2 <== NEVER TAKEN 10da28: e9 d4 00 00 00 jmp 10db01 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10da2d: a1 50 20 12 00 mov 0x122050,%eax 10da32: 3b 58 18 cmp 0x18(%eax),%ebx 10da35: 0f 84 67 ff ff ff je 10d9a2 /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){ 10da3b: 8b 46 10 mov 0x10(%esi),%eax 10da3e: 3b 58 1c cmp 0x1c(%eax),%ebx 10da41: 75 0c jne 10da4f 10da43: 89 f2 mov %esi,%edx 10da45: 89 c6 mov %eax,%esi if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; } else { newloc = pathloc->mt_entry->mt_point_node; 10da47: 8d 7d d0 lea -0x30(%ebp),%edi 10da4a: 83 c6 08 add $0x8,%esi 10da4d: eb 5a jmp 10daa9 *pathloc = newloc; return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); } } else { if ( !node->Parent ) 10da4f: 8b 5b 08 mov 0x8(%ebx),%ebx 10da52: 85 db test %ebx,%ebx 10da54: 0f 85 90 00 00 00 jne 10daea 10da5a: e9 e4 00 00 00 jmp 10db43 pathloc->node_access = node; break; case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { 10da5f: 8b 43 4c mov 0x4c(%ebx),%eax 10da62: 83 f8 03 cmp $0x3,%eax 10da65: 74 05 je 10da6c result = IMFS_evaluate_link( pathloc, 0 ); if ( result == -1 ) return -1; } else if ( node->type == IMFS_SYM_LINK ) { 10da67: 83 f8 04 cmp $0x4,%eax 10da6a: 75 16 jne 10da82 result = IMFS_evaluate_link( pathloc, 0 ); 10da6c: 50 push %eax 10da6d: 50 push %eax 10da6e: 6a 00 push $0x0 10da70: 56 push %esi 10da71: e8 7f fe ff ff call 10d8f5 if ( result == -1 ) 10da76: 83 c4 10 add $0x10,%esp 10da79: 83 f8 ff cmp $0xffffffff,%eax 10da7c: 0f 84 19 01 00 00 je 10db9b <== NEVER TAKEN return -1; } node = pathloc->node_access; 10da82: 8b 06 mov (%esi),%eax if ( !node ) 10da84: 85 c0 test %eax,%eax 10da86: 0f 84 e9 00 00 00 je 10db75 <== NEVER TAKEN /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10da8c: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 10da90: 0f 85 df 00 00 00 jne 10db75 /* * 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 ) { 10da96: 8b 50 5c mov 0x5c(%eax),%edx 10da99: 85 d2 test %edx,%edx 10da9b: 74 3b je 10dad8 10da9d: 89 f0 mov %esi,%eax 10da9f: 89 d6 mov %edx,%esi 10daa1: 89 c2 mov %eax,%edx newloc = node->info.directory.mt_fs->mt_fs_root; 10daa3: 8d 7d d0 lea -0x30(%ebp),%edi 10daa6: 83 c6 1c add $0x1c,%esi 10daa9: b9 05 00 00 00 mov $0x5,%ecx 10daae: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10dab0: 8d 75 d0 lea -0x30(%ebp),%esi 10dab3: b1 05 mov $0x5,%cl 10dab5: 89 d7 mov %edx,%edi 10dab7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10dab9: 56 push %esi 10daba: 8b 42 0c mov 0xc(%edx),%eax 10dabd: ff 75 10 pushl 0x10(%ebp) 10dac0: 52 push %edx 10dac1: 8b 55 a4 mov -0x5c(%ebp),%edx 10dac4: 2b 55 e4 sub -0x1c(%ebp),%edx 10dac7: 03 55 08 add 0x8(%ebp),%edx 10daca: 52 push %edx 10dacb: ff 50 04 call *0x4(%eax) 10dace: 89 c3 mov %eax,%ebx 10dad0: 83 c4 10 add $0x10,%esp 10dad3: e9 c5 00 00 00 jmp 10db9d /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10dad8: 53 push %ebx 10dad9: 53 push %ebx 10dada: 57 push %edi 10dadb: 50 push %eax 10dadc: e8 4b 01 00 00 call 10dc2c 10dae1: 89 c3 mov %eax,%ebx /* * If there is no node we have found the name of the node we * wish to create. */ if ( ! node ) 10dae3: 83 c4 10 add $0x10,%esp 10dae6: 85 c0 test %eax,%eax 10dae8: 74 27 je 10db11 done = true; else pathloc->node_access = node; 10daea: 89 1e mov %ebx,(%esi) 10daec: e9 b1 fe ff ff jmp 10d9a2 break; case IMFS_NO_MORE_PATH: rtems_set_errno_and_return_minus_one( EEXIST ); 10daf1: e8 b6 35 00 00 call 1110ac <__errno> 10daf6: c7 00 11 00 00 00 movl $0x11,(%eax) 10dafc: e9 fb fe ff ff jmp 10d9fc break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10db01: e8 a6 35 00 00 call 1110ac <__errno> 10db06: c7 00 5b 00 00 00 movl $0x5b,(%eax) 10db0c: e9 eb fe ff ff jmp 10d9fc 10db11: 89 f2 mov %esi,%edx case IMFS_CURRENT_DIR: break; } } *name = &path[ i - len ]; 10db13: 8b 45 a4 mov -0x5c(%ebp),%eax 10db16: 2b 45 e4 sub -0x1c(%ebp),%eax 10db19: 03 45 08 add 0x8(%ebp),%eax 10db1c: 8b 4d 10 mov 0x10(%ebp),%ecx 10db1f: 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( 10db21: 8b 5d 08 mov 0x8(%ebp),%ebx 10db24: 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++) { 10db27: eb 2a jmp 10db53 if ( !IMFS_is_separator( path[ i ] ) ) 10db29: 83 ec 0c sub $0xc,%esp 10db2c: 0f be c0 movsbl %al,%eax 10db2f: 50 push %eax 10db30: 89 55 9c mov %edx,-0x64(%ebp) 10db33: e8 c8 a4 ff ff call 108000 10db38: 43 inc %ebx 10db39: 83 c4 10 add $0x10,%esp 10db3c: 85 c0 test %eax,%eax 10db3e: 8b 55 9c mov -0x64(%ebp),%edx 10db41: 75 10 jne 10db53 rtems_set_errno_and_return_minus_one( ENOENT ); 10db43: e8 64 35 00 00 call 1110ac <__errno> 10db48: c7 00 02 00 00 00 movl $0x2,(%eax) 10db4e: e9 a9 fe ff ff jmp 10d9fc /* * 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++) { 10db53: 8a 03 mov (%ebx),%al 10db55: 84 c0 test %al,%al 10db57: 75 d0 jne 10db29 /* * Verify we can execute and write to this directory. */ result = IMFS_Set_handlers( pathloc ); 10db59: 83 ec 0c sub $0xc,%esp 10db5c: 52 push %edx 10db5d: 89 55 9c mov %edx,-0x64(%ebp) 10db60: e8 53 fa ff ff call 10d5b8 10db65: 89 c3 mov %eax,%ebx /* * The returned node must be a directory */ node = pathloc->node_access; if ( node->type != IMFS_DIRECTORY ) 10db67: 8b 55 9c mov -0x64(%ebp),%edx 10db6a: 8b 02 mov (%edx),%eax 10db6c: 83 c4 10 add $0x10,%esp 10db6f: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 10db73: 74 10 je 10db85 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTDIR ); 10db75: e8 32 35 00 00 call 1110ac <__errno> 10db7a: c7 00 14 00 00 00 movl $0x14,(%eax) 10db80: e9 77 fe ff ff jmp 10d9fc /* * We must have Write and execute permission on the returned node. */ if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) 10db85: 51 push %ecx 10db86: 51 push %ecx 10db87: 6a 03 push $0x3 10db89: 52 push %edx 10db8a: e8 6d fa ff ff call 10d5fc 10db8f: 83 c4 10 add $0x10,%esp 10db92: 85 c0 test %eax,%eax 10db94: 75 07 jne 10db9d 10db96: e9 56 fe ff ff jmp 10d9f1 10db9b: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10db9d: 89 d8 mov %ebx,%eax 10db9f: 8d 65 f4 lea -0xc(%ebp),%esp 10dba2: 5b pop %ebx 10dba3: 5e pop %esi 10dba4: 5f pop %edi 10dba5: c9 leave 10dba6: c3 ret =============================================================================== 0010d5fc : */ int IMFS_evaluate_permission( rtems_filesystem_location_info_t *node, int flags ) { 10d5fc: 55 push %ebp 10d5fd: 89 e5 mov %esp,%ebp 10d5ff: 57 push %edi 10d600: 56 push %esi 10d601: 53 push %ebx 10d602: 83 ec 0c sub $0xc,%esp 10d605: 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 ) ) 10d608: f7 c6 f8 ff ff ff test $0xfffffff8,%esi 10d60e: 74 10 je 10d620 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EPERM ); 10d610: e8 97 3a 00 00 call 1110ac <__errno> <== NOT EXECUTED 10d615: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10d61b: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10d61e: eb 32 jmp 10d652 <== NOT EXECUTED jnode = node->node_access; 10d620: 8b 45 08 mov 0x8(%ebp),%eax 10d623: 8b 18 mov (%eax),%ebx #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 10d625: e8 2e 0a 00 00 call 10e058 10d62a: 89 c7 mov %eax,%edi st_gid = getegid(); 10d62c: e8 17 0a 00 00 call 10e048 * Check if I am owner or a group member or someone else. */ flags_to_test = flags; if ( st_uid == jnode->st_uid ) 10d631: 66 3b 7b 3c cmp 0x3c(%ebx),%di 10d635: 75 05 jne 10d63c flags_to_test <<= 6; 10d637: c1 e6 06 shl $0x6,%esi 10d63a: eb 09 jmp 10d645 else if ( st_gid == jnode->st_gid ) 10d63c: 66 3b 43 3e cmp 0x3e(%ebx),%ax 10d640: 75 03 jne 10d645 <== NEVER TAKEN flags_to_test <<= 3; 10d642: 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 ) 10d645: 8b 43 30 mov 0x30(%ebx),%eax 10d648: 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 ); 10d64a: 39 f0 cmp %esi,%eax 10d64c: 0f 94 c0 sete %al 10d64f: 0f b6 c0 movzbl %al,%eax */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) return 1; return 0; } 10d652: 83 c4 0c add $0xc,%esp 10d655: 5b pop %ebx 10d656: 5e pop %esi 10d657: 5f pop %edi 10d658: c9 leave 10d659: c3 ret =============================================================================== 00107b78 : rtems_off64_t IMFS_fifo_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) { 107b78: 55 push %ebp 107b79: 89 e5 mov %esp,%ebp 107b7b: 53 push %ebx 107b7c: 83 ec 10 sub $0x10,%esp 107b7f: 8b 45 08 mov 0x8(%ebp),%eax off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop); 107b82: 50 push %eax 107b83: ff 75 14 pushl 0x14(%ebp) 107b86: ff 75 10 pushl 0x10(%ebp) 107b89: ff 75 0c pushl 0xc(%ebp) 107b8c: 8b 40 18 mov 0x18(%eax),%eax 107b8f: ff 70 50 pushl 0x50(%eax) 107b92: e8 a9 85 00 00 call 110140 107b97: 89 c3 mov %eax,%ebx 107b99: 99 cltd IMFS_FIFO_RETURN(err); 107b9a: 83 c4 20 add $0x20,%esp 107b9d: 85 d2 test %edx,%edx 107b9f: 79 0e jns 107baf <== NEVER TAKEN 107ba1: e8 42 b3 00 00 call 112ee8 <__errno> 107ba6: f7 db neg %ebx 107ba8: 89 18 mov %ebx,(%eax) 107baa: 83 c8 ff or $0xffffffff,%eax 107bad: 89 c2 mov %eax,%edx } 107baf: 8b 5d fc mov -0x4(%ebp),%ebx 107bb2: c9 leave 107bb3: c3 ret =============================================================================== 00107c14 : ssize_t IMFS_fifo_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 107c14: 55 push %ebp 107c15: 89 e5 mov %esp,%ebp 107c17: 56 push %esi 107c18: 53 push %ebx 107c19: 83 ec 10 sub $0x10,%esp 107c1c: 8b 45 08 mov 0x8(%ebp),%eax IMFS_jnode_t *jnode = iop->pathinfo.node_access; 107c1f: 8b 70 18 mov 0x18(%eax),%esi int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop); 107c22: 50 push %eax 107c23: ff 75 10 pushl 0x10(%ebp) 107c26: ff 75 0c pushl 0xc(%ebp) 107c29: ff 76 50 pushl 0x50(%esi) 107c2c: e8 03 83 00 00 call 10ff34 107c31: 89 c3 mov %eax,%ebx if (err > 0) { 107c33: 83 c4 10 add $0x10,%esp 107c36: 83 f8 00 cmp $0x0,%eax 107c39: 7e 1b jle 107c56 IMFS_mtime_ctime_update(jnode); 107c3b: 50 push %eax 107c3c: 50 push %eax 107c3d: 6a 00 push $0x0 107c3f: 8d 45 f0 lea -0x10(%ebp),%eax 107c42: 50 push %eax 107c43: e8 e4 0d 00 00 call 108a2c 107c48: 8b 45 f0 mov -0x10(%ebp),%eax 107c4b: 89 46 44 mov %eax,0x44(%esi) 107c4e: 89 46 48 mov %eax,0x48(%esi) 107c51: 83 c4 10 add $0x10,%esp 107c54: eb 0e jmp 107c64 } IMFS_FIFO_RETURN(err); 107c56: 74 0c je 107c64 <== NEVER TAKEN 107c58: e8 8b b2 00 00 call 112ee8 <__errno> 107c5d: f7 db neg %ebx 107c5f: 89 18 mov %ebx,(%eax) 107c61: 83 cb ff or $0xffffffff,%ebx } 107c64: 89 d8 mov %ebx,%eax 107c66: 8d 65 f8 lea -0x8(%ebp),%esp 107c69: 5b pop %ebx 107c6a: 5e pop %esi 107c6b: c9 leave 107c6c: c3 ret =============================================================================== 0010dc2c : IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) { 10dc2c: 55 push %ebp 10dc2d: 89 e5 mov %esp,%ebp 10dc2f: 57 push %edi 10dc30: 56 push %esi 10dc31: 53 push %ebx 10dc32: 83 ec 14 sub $0x14,%esp 10dc35: 8b 5d 08 mov 0x8(%ebp),%ebx 10dc38: 8b 7d 0c mov 0xc(%ebp),%edi /* * Check for "." and ".." */ if ( !strcmp( name, dotname ) ) 10dc3b: 68 58 ea 11 00 push $0x11ea58 10dc40: 57 push %edi 10dc41: e8 26 41 00 00 call 111d6c 10dc46: 83 c4 10 add $0x10,%esp 10dc49: 85 c0 test %eax,%eax 10dc4b: 74 40 je 10dc8d <== NEVER TAKEN return directory; if ( !strcmp( name, dotdotname ) ) 10dc4d: 51 push %ecx 10dc4e: 51 push %ecx 10dc4f: 68 5a ea 11 00 push $0x11ea5a 10dc54: 57 push %edi 10dc55: e8 12 41 00 00 call 111d6c 10dc5a: 83 c4 10 add $0x10,%esp 10dc5d: 85 c0 test %eax,%eax 10dc5f: 75 05 jne 10dc66 <== ALWAYS TAKEN return directory->Parent; 10dc61: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10dc64: eb 27 jmp 10dc8d <== NOT EXECUTED the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; 10dc66: 8b 73 50 mov 0x50(%ebx),%esi 10dc69: 83 c3 54 add $0x54,%ebx 10dc6c: eb 15 jmp 10dc83 !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 ) ) 10dc6e: 8d 46 0c lea 0xc(%esi),%eax 10dc71: 52 push %edx 10dc72: 52 push %edx 10dc73: 50 push %eax 10dc74: 57 push %edi 10dc75: e8 f2 40 00 00 call 111d6c 10dc7a: 83 c4 10 add $0x10,%esp 10dc7d: 85 c0 test %eax,%eax 10dc7f: 74 0a je 10dc8b the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { 10dc81: 8b 36 mov (%esi),%esi if ( !strcmp( name, dotdotname ) ) return directory->Parent; the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; 10dc83: 39 de cmp %ebx,%esi 10dc85: 75 e7 jne 10dc6e if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; 10dc87: 31 db xor %ebx,%ebx 10dc89: eb 02 jmp 10dc8d for ( the_node = the_chain->first; !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; 10dc8b: 89 f3 mov %esi,%ebx if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10dc8d: 89 d8 mov %ebx,%eax 10dc8f: 8d 65 f4 lea -0xc(%ebp),%esp 10dc92: 5b pop %ebx 10dc93: 5e pop %esi 10dc94: 5f pop %edi 10dc95: c9 leave 10dc96: c3 ret =============================================================================== 0010dba8 : ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next)) int IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 10dba8: 55 push %ebp 10dba9: 89 e5 mov %esp,%ebp 10dbab: 57 push %edi 10dbac: 56 push %esi 10dbad: 53 push %ebx 10dbae: 83 ec 2c sub $0x2c,%esp 10dbb1: 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; 10dbb4: 8b 58 1c mov 0x1c(%eax),%ebx loc = temp_mt_entry->mt_fs_root; 10dbb7: 8d 7d d4 lea -0x2c(%ebp),%edi 10dbba: 8d 70 1c lea 0x1c(%eax),%esi 10dbbd: b9 05 00 00 00 mov $0x5,%ecx 10dbc2: 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; 10dbc4: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) do { next = jnode->Parent; loc.node_access = (void *)jnode; IMFS_Set_handlers( &loc ); 10dbcb: 8d 75 d4 lea -0x2c(%ebp),%esi */ temp_mt_entry->mt_fs_root.node_access = NULL; do { next = jnode->Parent; 10dbce: 8b 7b 08 mov 0x8(%ebx),%edi loc.node_access = (void *)jnode; 10dbd1: 89 5d d4 mov %ebx,-0x2c(%ebp) IMFS_Set_handlers( &loc ); 10dbd4: 83 ec 0c sub $0xc,%esp 10dbd7: 56 push %esi 10dbd8: e8 db f9 ff ff call 10d5b8 if ( jnode->type != IMFS_DIRECTORY ) { 10dbdd: 83 c4 10 add $0x10,%esp 10dbe0: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10dbe4: 75 08 jne 10dbee */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10dbe6: 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 ) ) { 10dbe9: 39 43 50 cmp %eax,0x50(%ebx) 10dbec: 75 13 jne 10dc01 result = IMFS_unlink( NULL, &loc ); 10dbee: 50 push %eax 10dbef: 50 push %eax 10dbf0: 56 push %esi 10dbf1: 6a 00 push $0x0 10dbf3: e8 ec 92 ff ff call 106ee4 if (result != 0) 10dbf8: 83 c4 10 add $0x10,%esp 10dbfb: 85 c0 test %eax,%eax 10dbfd: 75 1d jne 10dc1c <== NEVER TAKEN return -1; jnode = next; 10dbff: 89 fb mov %edi,%ebx } if ( jnode != NULL ) { 10dc01: 85 db test %ebx,%ebx 10dc03: 74 1c je 10dc21 if ( jnode->type == IMFS_DIRECTORY ) { 10dc05: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10dc09: 75 c3 jne 10dbce <== NEVER TAKEN 10dc0b: 8d 43 54 lea 0x54(%ebx),%eax if ( jnode_has_children( jnode ) ) 10dc0e: 39 43 50 cmp %eax,0x50(%ebx) 10dc11: 74 bb je 10dbce jnode = jnode_get_first_child( jnode ); 10dc13: 8b 5b 50 mov 0x50(%ebx),%ebx } } } while (jnode != NULL); 10dc16: 85 db test %ebx,%ebx 10dc18: 75 b4 jne 10dbce <== ALWAYS TAKEN 10dc1a: eb 05 jmp 10dc21 <== NOT EXECUTED return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { result = IMFS_unlink( NULL, &loc ); if (result != 0) return -1; 10dc1c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10dc1f: eb 02 jmp 10dc23 <== NOT EXECUTED jnode = jnode_get_first_child( jnode ); } } } while (jnode != NULL); return 0; 10dc21: 31 c0 xor %eax,%eax } 10dc23: 8d 65 f4 lea -0xc(%ebp),%esp 10dc26: 5b pop %ebx 10dc27: 5e pop %esi 10dc28: 5f pop %edi 10dc29: c9 leave 10dc2a: c3 ret =============================================================================== 0010dc98 : const char *path, int pathlen, char *token, int *token_len ) { 10dc98: 55 push %ebp 10dc99: 89 e5 mov %esp,%ebp 10dc9b: 57 push %edi 10dc9c: 56 push %esi 10dc9d: 53 push %ebx 10dc9e: 83 ec 1c sub $0x1c,%esp 10dca1: 8b 7d 08 mov 0x8(%ebp),%edi 10dca4: 8b 75 10 mov 0x10(%ebp),%esi register char c; /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; 10dca7: 8a 17 mov (%edi),%dl int pathlen, char *token, int *token_len ) { register int i = 0; 10dca9: 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) ) { 10dcab: eb 10 jmp 10dcbd token[i] = c; 10dcad: 88 14 1e mov %dl,(%esi,%ebx,1) if ( i == IMFS_NAME_MAX ) 10dcb0: 83 fb 20 cmp $0x20,%ebx 10dcb3: 0f 84 86 00 00 00 je 10dd3f return IMFS_INVALID_TOKEN; if ( !IMFS_is_valid_name_char(c) ) type = IMFS_INVALID_TOKEN; c = path [++i]; 10dcb9: 43 inc %ebx 10dcba: 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) ) { 10dcbd: 83 ec 0c sub $0xc,%esp 10dcc0: 0f be c2 movsbl %dl,%eax 10dcc3: 50 push %eax 10dcc4: 88 55 e4 mov %dl,-0x1c(%ebp) 10dcc7: e8 34 a3 ff ff call 108000 10dccc: 83 c4 10 add $0x10,%esp 10dccf: 85 c0 test %eax,%eax 10dcd1: 8a 55 e4 mov -0x1c(%ebp),%dl 10dcd4: 75 05 jne 10dcdb 10dcd6: 3b 5d 0c cmp 0xc(%ebp),%ebx 10dcd9: 7c d2 jl 10dcad /* * Copy a seperator into token. */ if ( i == 0 ) { 10dcdb: 85 db test %ebx,%ebx 10dcdd: 75 10 jne 10dcef token[i] = c; 10dcdf: 88 16 mov %dl,(%esi) if ( (token[i] != '\0') && pathlen ) { 10dce1: 84 d2 test %dl,%dl 10dce3: 74 06 je 10dceb 10dce5: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10dce9: 75 16 jne 10dd01 i++; type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; 10dceb: 31 ff xor %edi,%edi 10dced: eb 1c jmp 10dd0b char *token, int *token_len ) { register int i = 0; IMFS_token_types type = IMFS_NAME; 10dcef: 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') { 10dcf4: 80 7c 1e ff 00 cmpb $0x0,-0x1(%esi,%ebx,1) 10dcf9: 74 10 je 10dd0b <== NEVER TAKEN token[i] = '\0'; 10dcfb: c6 04 1e 00 movb $0x0,(%esi,%ebx,1) 10dcff: eb 0a jmp 10dd0b if ( i == 0 ) { token[i] = c; if ( (token[i] != '\0') && pathlen ) { i++; type = IMFS_CURRENT_DIR; 10dd01: bf 01 00 00 00 mov $0x1,%edi if ( i == 0 ) { token[i] = c; if ( (token[i] != '\0') && pathlen ) { i++; 10dd06: bb 01 00 00 00 mov $0x1,%ebx /* * Set token_len to the number of characters copied. */ *token_len = i; 10dd0b: 8b 45 14 mov 0x14(%ebp),%eax 10dd0e: 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 ) { 10dd10: 83 ff 03 cmp $0x3,%edi 10dd13: 75 3d jne 10dd52 if ( strcmp( token, "..") == 0 ) 10dd15: 52 push %edx 10dd16: 52 push %edx 10dd17: 68 5d ea 11 00 push $0x11ea5d 10dd1c: 56 push %esi 10dd1d: e8 4a 40 00 00 call 111d6c 10dd22: 83 c4 10 add $0x10,%esp 10dd25: 85 c0 test %eax,%eax 10dd27: 74 1d je 10dd46 type = IMFS_UP_DIR; else if ( strcmp( token, "." ) == 0 ) 10dd29: 50 push %eax 10dd2a: 50 push %eax 10dd2b: 68 5e ea 11 00 push $0x11ea5e 10dd30: 56 push %esi 10dd31: e8 36 40 00 00 call 111d6c 10dd36: 83 c4 10 add $0x10,%esp 10dd39: 85 c0 test %eax,%eax 10dd3b: 74 10 je 10dd4d 10dd3d: eb 13 jmp 10dd52 while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) { token[i] = c; if ( i == IMFS_NAME_MAX ) return IMFS_INVALID_TOKEN; 10dd3f: bf 04 00 00 00 mov $0x4,%edi 10dd44: eb 0c jmp 10dd52 * it was a special name. */ if ( type == IMFS_NAME ) { if ( strcmp( token, "..") == 0 ) type = IMFS_UP_DIR; 10dd46: bf 02 00 00 00 mov $0x2,%edi 10dd4b: eb 05 jmp 10dd52 else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; 10dd4d: bf 01 00 00 00 mov $0x1,%edi } return type; } 10dd52: 89 f8 mov %edi,%eax 10dd54: 8d 65 f4 lea -0xc(%ebp),%esp 10dd57: 5b pop %ebx 10dd58: 5e pop %esi 10dd59: 5f pop %edi 10dd5a: c9 leave 10dd5b: 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 01 12 00 mov 0x120148,%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 8c 3e 12 00 mov %eax,0x123e8c /* * 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 d2 69 00 00 call 10d583 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 0c ea 11 00 mov $0x11ea0c,%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 b5 a4 00 00 call 1110ac <__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 90 3e 12 00 mov 0x123e90,%ecx 106c0e: 89 08 mov %ecx,(%eax) 106c10: 41 inc %ecx 106c11: 89 0d 90 3e 12 00 mov %ecx,0x123e90 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 =============================================================================== 0011008e : */ MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) { 11008e: 55 push %ebp 11008f: 89 e5 mov %esp,%ebp 110091: 57 push %edi 110092: 56 push %esi 110093: 53 push %ebx 110094: 83 ec 2c sub $0x2c,%esp 110097: 8b 7d 08 mov 0x8(%ebp),%edi 11009a: 8b 5d 0c mov 0xc(%ebp),%ebx 11009d: 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 ) 1100a0: a1 8c 3e 12 00 mov 0x123e8c,%eax 1100a5: 89 c1 mov %eax,%ecx 1100a7: c1 e9 02 shr $0x2,%ecx 1100aa: 8d 51 01 lea 0x1(%ecx),%edx 1100ad: 0f af d1 imul %ecx,%edx 1100b0: 42 inc %edx 1100b1: 0f af d1 imul %ecx,%edx 1100b4: 4a dec %edx 1100b5: 0f af d0 imul %eax,%edx 1100b8: 83 fe 00 cmp $0x0,%esi 1100bb: 7c 16 jl 1100d3 <== NEVER TAKEN 1100bd: 7f 04 jg 1100c3 <== NEVER TAKEN 1100bf: 39 d3 cmp %edx,%ebx 1100c1: 72 10 jb 1100d3 rtems_set_errno_and_return_minus_one( EINVAL ); 1100c3: e8 e4 0f 00 00 call 1110ac <__errno> 1100c8: c7 00 16 00 00 00 movl $0x16,(%eax) 1100ce: e9 92 00 00 00 jmp 110165 /* * Verify new file size is actually larger than current size */ if ( new_length <= the_jnode->info.file.size ) 1100d3: 8b 57 50 mov 0x50(%edi),%edx 1100d6: 8b 4f 54 mov 0x54(%edi),%ecx 1100d9: 89 55 e0 mov %edx,-0x20(%ebp) 1100dc: 89 4d e4 mov %ecx,-0x1c(%ebp) 1100df: 39 ce cmp %ecx,%esi 1100e1: 0f 8c 8f 00 00 00 jl 110176 <== NEVER TAKEN 1100e7: 7f 08 jg 1100f1 <== NEVER TAKEN 1100e9: 39 d3 cmp %edx,%ebx 1100eb: 0f 86 85 00 00 00 jbe 110176 return 0; /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; 1100f1: 89 45 d8 mov %eax,-0x28(%ebp) 1100f4: 89 c1 mov %eax,%ecx 1100f6: c1 f9 1f sar $0x1f,%ecx 1100f9: 89 4d dc mov %ecx,-0x24(%ebp) 1100fc: ff 75 dc pushl -0x24(%ebp) 1100ff: ff 75 d8 pushl -0x28(%ebp) 110102: 56 push %esi 110103: 53 push %ebx 110104: e8 57 bf 00 00 call 11c060 <__divdi3> 110109: 83 c4 10 add $0x10,%esp 11010c: 89 45 d4 mov %eax,-0x2c(%ebp) old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; 11010f: ff 75 dc pushl -0x24(%ebp) 110112: ff 75 d8 pushl -0x28(%ebp) 110115: ff 75 e4 pushl -0x1c(%ebp) 110118: ff 75 e0 pushl -0x20(%ebp) 11011b: e8 40 bf 00 00 call 11c060 <__divdi3> 110120: 83 c4 10 add $0x10,%esp 110123: 89 45 e0 mov %eax,-0x20(%ebp) /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 110126: 89 c2 mov %eax,%edx 110128: eb 41 jmp 11016b if ( IMFS_memfile_addblock( the_jnode, block ) ) { 11012a: 51 push %ecx 11012b: 51 push %ecx 11012c: 52 push %edx 11012d: 57 push %edi 11012e: 89 55 d0 mov %edx,-0x30(%ebp) 110131: e8 99 fd ff ff call 10fecf 110136: 83 c4 10 add $0x10,%esp 110139: 85 c0 test %eax,%eax 11013b: 8b 55 d0 mov -0x30(%ebp),%edx 11013e: 74 2a je 11016a 110140: eb 13 jmp 110155 for ( ; block>=old_blocks ; block-- ) { IMFS_memfile_remove_block( the_jnode, block ); 110142: 50 push %eax 110143: 50 push %eax 110144: 52 push %edx 110145: 57 push %edi 110146: 89 55 d0 mov %edx,-0x30(%ebp) 110149: e8 16 ff ff ff call 110064 /* * 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-- ) { 11014e: 8b 55 d0 mov -0x30(%ebp),%edx 110151: 4a dec %edx 110152: 83 c4 10 add $0x10,%esp 110155: 3b 55 e0 cmp -0x20(%ebp),%edx 110158: 73 e8 jae 110142 IMFS_memfile_remove_block( the_jnode, block ); } rtems_set_errno_and_return_minus_one( ENOSPC ); 11015a: e8 4d 0f 00 00 call 1110ac <__errno> 11015f: c7 00 1c 00 00 00 movl $0x1c,(%eax) 110165: 83 c8 ff or $0xffffffff,%eax 110168: eb 0e jmp 110178 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++ ) { 11016a: 42 inc %edx 11016b: 3b 55 d4 cmp -0x2c(%ebp),%edx 11016e: 76 ba jbe 11012a } /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; 110170: 89 5f 50 mov %ebx,0x50(%edi) 110173: 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; 110176: 31 c0 xor %eax,%eax /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; return 0; } 110178: 8d 65 f4 lea -0xc(%ebp),%esp 11017b: 5b pop %ebx 11017c: 5e pop %esi 11017d: 5f pop %edi 11017e: c9 leave 11017f: c3 ret =============================================================================== 0010fbd4 : #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) { 10fbd4: 55 push %ebp 10fbd5: 89 e5 mov %esp,%ebp 10fbd7: 57 push %edi 10fbd8: 56 push %esi 10fbd9: 53 push %ebx 10fbda: 83 ec 1c sub $0x1c,%esp 10fbdd: 8b 75 08 mov 0x8(%ebp),%esi 10fbe0: 8b 7d 0c mov 0xc(%ebp),%edi my_block = block; /* * Is the block number in the simple indirect portion? */ if ( my_block <= LAST_INDIRECT ) { 10fbe3: 8b 0d 8c 3e 12 00 mov 0x123e8c,%ecx 10fbe9: c1 e9 02 shr $0x2,%ecx 10fbec: 8d 41 ff lea -0x1(%ecx),%eax 10fbef: 39 c7 cmp %eax,%edi 10fbf1: 77 40 ja 10fc33 p = info->indirect; 10fbf3: 8b 46 58 mov 0x58(%esi),%eax if ( malloc_it ) { 10fbf6: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10fbfa: 74 25 je 10fc21 if ( !p ) { 10fbfc: 85 c0 test %eax,%eax 10fbfe: 75 12 jne 10fc12 p = memfile_alloc_block(); 10fc00: e8 ad ff ff ff call 10fbb2 if ( !p ) return 0; 10fc05: 31 db xor %ebx,%ebx if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); if ( !p ) 10fc07: 85 c0 test %eax,%eax 10fc09: 0f 84 f7 00 00 00 je 10fd06 <== NEVER TAKEN return 0; info->indirect = p; 10fc0f: 89 46 58 mov %eax,0x58(%esi) } return &info->indirect[ my_block ]; 10fc12: 8d 1c bd 00 00 00 00 lea 0x0(,%edi,4),%ebx 10fc19: 03 5e 58 add 0x58(%esi),%ebx 10fc1c: e9 e5 00 00 00 jmp 10fd06 } if ( !p ) return 0; 10fc21: 31 db xor %ebx,%ebx info->indirect = p; } return &info->indirect[ my_block ]; } if ( !p ) 10fc23: 85 c0 test %eax,%eax 10fc25: 0f 84 db 00 00 00 je 10fd06 <== NEVER TAKEN return 0; return &info->indirect[ my_block ]; 10fc2b: 8d 1c b8 lea (%eax,%edi,4),%ebx 10fc2e: e9 d3 00 00 00 jmp 10fd06 /* * Is the block number in the doubly indirect portion? */ if ( my_block <= LAST_DOUBLY_INDIRECT ) { 10fc33: 8d 41 01 lea 0x1(%ecx),%eax 10fc36: 0f af c1 imul %ecx,%eax 10fc39: 8d 50 ff lea -0x1(%eax),%edx 10fc3c: 39 d7 cmp %edx,%edi 10fc3e: 77 40 ja 10fc80 my_block -= FIRST_DOUBLY_INDIRECT; 10fc40: 29 cf sub %ecx,%edi singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 10fc42: 89 f8 mov %edi,%eax 10fc44: 31 d2 xor %edx,%edx 10fc46: f7 f1 div %ecx 10fc48: 89 55 e4 mov %edx,-0x1c(%ebp) 10fc4b: 89 c7 mov %eax,%edi doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; p = info->doubly_indirect; 10fc4d: 8b 46 5c mov 0x5c(%esi),%eax if ( malloc_it ) { 10fc50: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10fc54: 74 1b je 10fc71 if ( !p ) { 10fc56: 85 c0 test %eax,%eax 10fc58: 75 12 jne 10fc6c p = memfile_alloc_block(); 10fc5a: e8 53 ff ff ff call 10fbb2 if ( !p ) return 0; 10fc5f: 31 db xor %ebx,%ebx p = info->doubly_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); if ( !p ) 10fc61: 85 c0 test %eax,%eax 10fc63: 0f 84 9d 00 00 00 je 10fd06 <== NEVER TAKEN return 0; info->doubly_indirect = p; 10fc69: 89 46 5c mov %eax,0x5c(%esi) } p1 = (block_p *)p[ doubly ]; 10fc6c: 8d 34 b8 lea (%eax,%edi,4),%esi 10fc6f: eb 65 jmp 10fcd6 return (block_p *)&p1[ singly ]; } if ( !p ) return 0; 10fc71: 31 db xor %ebx,%ebx } return (block_p *)&p1[ singly ]; } if ( !p ) 10fc73: 85 c0 test %eax,%eax 10fc75: 0f 84 8b 00 00 00 je 10fd06 <== NEVER TAKEN return 0; p = (block_p *)p[ doubly ]; 10fc7b: 8b 04 b8 mov (%eax,%edi,4),%eax 10fc7e: eb 7c jmp 10fcfc } /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 10fc80: 8d 50 01 lea 0x1(%eax),%edx 10fc83: 0f af d1 imul %ecx,%edx 10fc86: 4a dec %edx } /* * This means the requested block number is out of range. */ return 0; 10fc87: 31 db xor %ebx,%ebx } /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 10fc89: 39 d7 cmp %edx,%edi 10fc8b: 77 79 ja 10fd06 <== NEVER TAKEN my_block -= FIRST_TRIPLY_INDIRECT; 10fc8d: 29 c7 sub %eax,%edi 10fc8f: 89 f8 mov %edi,%eax singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 10fc91: 31 d2 xor %edx,%edx 10fc93: f7 f1 div %ecx 10fc95: 89 55 e4 mov %edx,-0x1c(%ebp) doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; 10fc98: 31 d2 xor %edx,%edx 10fc9a: f7 f1 div %ecx 10fc9c: 89 55 e0 mov %edx,-0x20(%ebp) 10fc9f: 89 c7 mov %eax,%edi doubly %= IMFS_MEMFILE_BLOCK_SLOTS; p = info->triply_indirect; 10fca1: 8b 46 60 mov 0x60(%esi),%eax if ( malloc_it ) { 10fca4: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10fca8: 74 41 je 10fceb if ( !p ) { 10fcaa: 85 c0 test %eax,%eax 10fcac: 75 0c jne 10fcba p = memfile_alloc_block(); 10fcae: e8 ff fe ff ff call 10fbb2 if ( !p ) 10fcb3: 85 c0 test %eax,%eax 10fcb5: 74 4f je 10fd06 <== NEVER TAKEN return 0; info->triply_indirect = p; 10fcb7: 89 46 60 mov %eax,0x60(%esi) } p1 = (block_p *) p[ triply ]; 10fcba: 8d 34 b8 lea (%eax,%edi,4),%esi 10fcbd: 8b 06 mov (%esi),%eax if ( !p1 ) { 10fcbf: 85 c0 test %eax,%eax 10fcc1: 75 0d jne 10fcd0 p1 = memfile_alloc_block(); 10fcc3: e8 ea fe ff ff call 10fbb2 if ( !p1 ) return 0; 10fcc8: 31 db xor %ebx,%ebx } p1 = (block_p *) p[ triply ]; if ( !p1 ) { p1 = memfile_alloc_block(); if ( !p1 ) 10fcca: 85 c0 test %eax,%eax 10fccc: 74 38 je 10fd06 <== NEVER TAKEN return 0; p[ triply ] = (block_p) p1; 10fcce: 89 06 mov %eax,(%esi) } p2 = (block_p *)p1[ doubly ]; 10fcd0: 8b 55 e0 mov -0x20(%ebp),%edx 10fcd3: 8d 34 90 lea (%eax,%edx,4),%esi 10fcd6: 8b 06 mov (%esi),%eax if ( !p2 ) { 10fcd8: 85 c0 test %eax,%eax 10fcda: 75 24 jne 10fd00 p2 = memfile_alloc_block(); 10fcdc: e8 d1 fe ff ff call 10fbb2 if ( !p2 ) return 0; 10fce1: 31 db xor %ebx,%ebx } p2 = (block_p *)p1[ doubly ]; if ( !p2 ) { p2 = memfile_alloc_block(); if ( !p2 ) 10fce3: 85 c0 test %eax,%eax 10fce5: 74 1f je 10fd06 <== NEVER TAKEN return 0; p1[ doubly ] = (block_p) p2; 10fce7: 89 06 mov %eax,(%esi) 10fce9: eb 15 jmp 10fd00 } return (block_p *)&p2[ singly ]; } if ( !p ) 10fceb: 85 c0 test %eax,%eax 10fced: 74 17 je 10fd06 <== NEVER TAKEN return 0; p1 = (block_p *) p[ triply ]; 10fcef: 8b 04 b8 mov (%eax,%edi,4),%eax if ( !p1 ) 10fcf2: 85 c0 test %eax,%eax 10fcf4: 74 10 je 10fd06 <== NEVER TAKEN return 0; p2 = (block_p *)p1[ doubly ]; 10fcf6: 8b 55 e0 mov -0x20(%ebp),%edx 10fcf9: 8b 04 90 mov (%eax,%edx,4),%eax if ( !p2 ) 10fcfc: 85 c0 test %eax,%eax 10fcfe: 74 06 je 10fd06 <== NEVER TAKEN return 0; return (block_p *)&p2[ singly ]; 10fd00: 8b 55 e4 mov -0x1c(%ebp),%edx 10fd03: 8d 1c 90 lea (%eax,%edx,4),%ebx /* * This means the requested block number is out of range. */ return 0; } 10fd06: 89 d8 mov %ebx,%eax 10fd08: 83 c4 1c add $0x1c,%esp 10fd0b: 5b pop %ebx 10fd0c: 5e pop %esi 10fd0d: 5f pop %edi 10fd0e: c9 leave 10fd0f: c3 ret =============================================================================== 0010fd10 : IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) { 10fd10: 55 push %ebp 10fd11: 89 e5 mov %esp,%ebp 10fd13: 57 push %edi 10fd14: 56 push %esi 10fd15: 53 push %ebx 10fd16: 83 ec 4c sub $0x4c,%esp 10fd19: 8b 75 0c mov 0xc(%ebp),%esi 10fd1c: 8b 7d 10 mov 0x10(%ebp),%edi 10fd1f: 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) { 10fd22: 8b 45 08 mov 0x8(%ebp),%eax 10fd25: 83 78 4c 06 cmpl $0x6,0x4c(%eax) 10fd29: 75 3f jne 10fd6a unsigned char *file_ptr; file_ptr = (unsigned char *)the_jnode->info.linearfile.direct; 10fd2b: 8b 48 58 mov 0x58(%eax),%ecx if (my_length > (the_jnode->info.linearfile.size - start)) 10fd2e: 89 c2 mov %eax,%edx 10fd30: 8b 40 50 mov 0x50(%eax),%eax 10fd33: 8b 52 54 mov 0x54(%edx),%edx 10fd36: 89 45 b0 mov %eax,-0x50(%ebp) 10fd39: 89 55 b4 mov %edx,-0x4c(%ebp) 10fd3c: 29 f0 sub %esi,%eax 10fd3e: 19 fa sbb %edi,%edx 10fd40: 89 45 d0 mov %eax,-0x30(%ebp) 10fd43: 89 55 d4 mov %edx,-0x2c(%ebp) 10fd46: 31 c0 xor %eax,%eax 10fd48: 39 d0 cmp %edx,%eax 10fd4a: 7c 0e jl 10fd5a <== NEVER TAKEN 10fd4c: 7f 05 jg 10fd53 <== NEVER TAKEN 10fd4e: 3b 5d d0 cmp -0x30(%ebp),%ebx 10fd51: 76 07 jbe 10fd5a <== NEVER TAKEN my_length = the_jnode->info.linearfile.size - start; 10fd53: 8b 55 b0 mov -0x50(%ebp),%edx 10fd56: 29 f2 sub %esi,%edx 10fd58: eb 02 jmp 10fd5c /* * Linear files (as created from a tar file are easier to handle * than block files). */ my_length = length; 10fd5a: 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); 10fd5c: 01 ce add %ecx,%esi 10fd5e: 8b 7d 14 mov 0x14(%ebp),%edi 10fd61: 89 d1 mov %edx,%ecx 10fd63: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10fd65: e9 1d 01 00 00 jmp 10fe87 /* * 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; 10fd6a: 89 f0 mov %esi,%eax if ( last_byte > the_jnode->info.file.size ) 10fd6c: 8b 55 08 mov 0x8(%ebp),%edx 10fd6f: 8b 52 50 mov 0x50(%edx),%edx 10fd72: 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; 10fd75: 8d 0c 33 lea (%ebx,%esi,1),%ecx 10fd78: 89 4d d0 mov %ecx,-0x30(%ebp) if ( last_byte > the_jnode->info.file.size ) 10fd7b: 31 c9 xor %ecx,%ecx 10fd7d: 8b 55 08 mov 0x8(%ebp),%edx 10fd80: 3b 4a 54 cmp 0x54(%edx),%ecx 10fd83: 7c 14 jl 10fd99 <== NEVER TAKEN 10fd85: 7f 08 jg 10fd8f <== NEVER TAKEN 10fd87: 8b 4d cc mov -0x34(%ebp),%ecx 10fd8a: 39 4d d0 cmp %ecx,-0x30(%ebp) 10fd8d: 76 0a jbe 10fd99 my_length = the_jnode->info.file.size - start; 10fd8f: 8b 55 cc mov -0x34(%ebp),%edx 10fd92: 29 c2 sub %eax,%edx 10fd94: 89 55 d0 mov %edx,-0x30(%ebp) 10fd97: eb 03 jmp 10fd9c /* * Linear files (as created from a tar file are easier to handle * than block files). */ my_length = length; 10fd99: 89 5d d0 mov %ebx,-0x30(%ebp) */ /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 10fd9c: 8b 0d 8c 3e 12 00 mov 0x123e8c,%ecx 10fda2: 89 4d c4 mov %ecx,-0x3c(%ebp) 10fda5: 89 c8 mov %ecx,%eax 10fda7: 99 cltd 10fda8: 89 d3 mov %edx,%ebx 10fdaa: 52 push %edx 10fdab: 51 push %ecx 10fdac: 57 push %edi 10fdad: 56 push %esi 10fdae: 89 4d c0 mov %ecx,-0x40(%ebp) 10fdb1: e8 f6 c3 00 00 call 11c1ac <__moddi3> 10fdb6: 83 c4 10 add $0x10,%esp 10fdb9: 89 45 cc mov %eax,-0x34(%ebp) block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 10fdbc: 8b 4d c0 mov -0x40(%ebp),%ecx 10fdbf: 53 push %ebx 10fdc0: 51 push %ecx 10fdc1: 57 push %edi 10fdc2: 56 push %esi 10fdc3: e8 98 c2 00 00 call 11c060 <__divdi3> 10fdc8: 83 c4 10 add $0x10,%esp 10fdcb: 89 c3 mov %eax,%ebx if ( start_offset ) { 10fdcd: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 10fdd1: 74 3d je 10fe10 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 ); 10fdd3: 57 push %edi 10fdd4: 6a 00 push $0x0 10fdd6: 50 push %eax 10fdd7: ff 75 08 pushl 0x8(%ebp) 10fdda: e8 f5 fd ff ff call 10fbd4 if ( !block_ptr ) 10fddf: 83 c4 10 add $0x10,%esp return copied; 10fde2: 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 ) 10fde4: 85 c0 test %eax,%eax 10fde6: 0f 84 ba 00 00 00 je 10fea6 <== 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; 10fdec: 8b 4d c4 mov -0x3c(%ebp),%ecx 10fdef: 2b 4d cc sub -0x34(%ebp),%ecx 10fdf2: 8b 55 d0 mov -0x30(%ebp),%edx 10fdf5: 39 ca cmp %ecx,%edx 10fdf7: 76 02 jbe 10fdfb 10fdf9: 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 ); 10fdfb: 8b 75 cc mov -0x34(%ebp),%esi 10fdfe: 03 30 add (%eax),%esi dest += to_copy; 10fe00: 8b 7d 14 mov 0x14(%ebp),%edi 10fe03: 89 d1 mov %edx,%ecx 10fe05: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10fe07: 89 7d cc mov %edi,-0x34(%ebp) block++; 10fe0a: 43 inc %ebx my_length -= to_copy; 10fe0b: 29 55 d0 sub %edx,-0x30(%ebp) 10fe0e: eb 08 jmp 10fe18 unsigned int last_byte; unsigned int copied; unsigned int start_offset; unsigned char *dest; dest = destination; 10fe10: 8b 45 14 mov 0x14(%ebp),%eax 10fe13: 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; 10fe16: 31 d2 xor %edx,%edx } /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 10fe18: 8b 0d 8c 3e 12 00 mov 0x123e8c,%ecx 10fe1e: 89 4d c8 mov %ecx,-0x38(%ebp) while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 10fe21: eb 2f jmp 10fe52 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 10fe23: 56 push %esi 10fe24: 6a 00 push $0x0 10fe26: 53 push %ebx 10fe27: ff 75 08 pushl 0x8(%ebp) 10fe2a: 89 55 c0 mov %edx,-0x40(%ebp) 10fe2d: e8 a2 fd ff ff call 10fbd4 if ( !block_ptr ) 10fe32: 83 c4 10 add $0x10,%esp 10fe35: 85 c0 test %eax,%eax 10fe37: 8b 55 c0 mov -0x40(%ebp),%edx 10fe3a: 74 6a je 10fea6 <== NEVER TAKEN return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); 10fe3c: 8b 30 mov (%eax),%esi 10fe3e: 8b 7d cc mov -0x34(%ebp),%edi 10fe41: 8b 4d c8 mov -0x38(%ebp),%ecx 10fe44: f3 a4 rep movsb %ds:(%esi),%es:(%edi) dest += to_copy; 10fe46: 89 7d cc mov %edi,-0x34(%ebp) block++; 10fe49: 43 inc %ebx my_length -= to_copy; 10fe4a: 8b 7d c8 mov -0x38(%ebp),%edi 10fe4d: 29 7d d0 sub %edi,-0x30(%ebp) copied += to_copy; 10fe50: 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 ) { 10fe52: 8b 45 d0 mov -0x30(%ebp),%eax 10fe55: 3b 05 8c 3e 12 00 cmp 0x123e8c,%eax 10fe5b: 73 c6 jae 10fe23 /* * Phase 3: possibly the first part of one block */ IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { 10fe5d: 85 c0 test %eax,%eax 10fe5f: 74 26 je 10fe87 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 10fe61: 51 push %ecx 10fe62: 6a 00 push $0x0 10fe64: 53 push %ebx 10fe65: ff 75 08 pushl 0x8(%ebp) 10fe68: 89 55 c0 mov %edx,-0x40(%ebp) 10fe6b: e8 64 fd ff ff call 10fbd4 if ( !block_ptr ) 10fe70: 83 c4 10 add $0x10,%esp 10fe73: 85 c0 test %eax,%eax 10fe75: 8b 55 c0 mov -0x40(%ebp),%edx 10fe78: 74 2c je 10fea6 <== NEVER TAKEN return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); 10fe7a: 8b 30 mov (%eax),%esi 10fe7c: 8b 7d cc mov -0x34(%ebp),%edi 10fe7f: 8b 4d d0 mov -0x30(%ebp),%ecx 10fe82: f3 a4 rep movsb %ds:(%esi),%es:(%edi) copied += my_length; 10fe84: 03 55 d0 add -0x30(%ebp),%edx } IMFS_update_atime( the_jnode ); 10fe87: 50 push %eax 10fe88: 50 push %eax 10fe89: 6a 00 push $0x0 10fe8b: 8d 45 e0 lea -0x20(%ebp),%eax 10fe8e: 50 push %eax 10fe8f: 89 55 c0 mov %edx,-0x40(%ebp) 10fe92: e8 29 75 ff ff call 1073c0 10fe97: 8b 45 e0 mov -0x20(%ebp),%eax 10fe9a: 8b 4d 08 mov 0x8(%ebp),%ecx 10fe9d: 89 41 40 mov %eax,0x40(%ecx) return copied; 10fea0: 8b 55 c0 mov -0x40(%ebp),%edx 10fea3: 83 c4 10 add $0x10,%esp } 10fea6: 89 d0 mov %edx,%eax 10fea8: 8d 65 f4 lea -0xc(%ebp),%esp 10feab: 5b pop %ebx 10feac: 5e pop %esi 10fead: 5f pop %edi 10feae: c9 leave 10feaf: c3 ret =============================================================================== 0010ff6e : * is better to stick to simple, easy to understand algorithms. */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) { 10ff6e: 55 push %ebp 10ff6f: 89 e5 mov %esp,%ebp 10ff71: 57 push %edi 10ff72: 56 push %esi 10ff73: 53 push %ebx 10ff74: 83 ec 1c sub $0x1c,%esp 10ff77: 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; 10ff7a: 8b 35 8c 3e 12 00 mov 0x123e8c,%esi 10ff80: c1 ee 02 shr $0x2,%esi * + doubly indirect * + triply indirect */ info = &the_jnode->info.file; if ( info->indirect ) { 10ff83: 83 7b 58 00 cmpl $0x0,0x58(%ebx) 10ff87: 74 0f je 10ff98 memfile_free_blocks_in_table( &info->indirect, to_free ); 10ff89: 57 push %edi 10ff8a: 57 push %edi 10ff8b: 56 push %esi 10ff8c: 8d 43 58 lea 0x58(%ebx),%eax 10ff8f: 50 push %eax 10ff90: e8 8c ff ff ff call 10ff21 10ff95: 83 c4 10 add $0x10,%esp } if ( info->doubly_indirect ) { 10ff98: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx) 10ff9c: 74 3e je 10ffdc 10ff9e: 31 ff xor %edi,%edi 10ffa0: eb 1f jmp 10ffc1 for ( i=0 ; idoubly_indirect[i] ) { 10ffa2: 8b 43 5c mov 0x5c(%ebx),%eax 10ffa5: 8d 14 bd 00 00 00 00 lea 0x0(,%edi,4),%edx 10ffac: 83 3c b8 00 cmpl $0x0,(%eax,%edi,4) 10ffb0: 74 0e je 10ffc0 <== NEVER TAKEN memfile_free_blocks_in_table( 10ffb2: 51 push %ecx 10ffb3: 51 push %ecx 10ffb4: 56 push %esi 10ffb5: 01 d0 add %edx,%eax 10ffb7: 50 push %eax 10ffb8: e8 64 ff ff ff call 10ff21 10ffbd: 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 ); 10ffcd: 57 push %edi 10ffce: 57 push %edi 10ffcf: 56 push %esi 10ffd0: 8d 43 5c lea 0x5c(%ebx),%eax 10ffd3: 50 push %eax 10ffd4: e8 48 ff ff ff call 10ff21 10ffd9: 83 c4 10 add $0x10,%esp } if ( info->triply_indirect ) { 10ffdc: 83 7b 60 00 cmpl $0x0,0x60(%ebx) 10ffe0: 74 78 je 11005a 10ffe2: 31 ff xor %edi,%edi 10ffe4: eb 59 jmp 11003f 10ffe6: 8d 04 bd 00 00 00 00 lea 0x0(,%edi,4),%eax 10ffed: 89 45 e4 mov %eax,-0x1c(%ebp) for ( i=0 ; itriply_indirect[i]; 10fff0: 8b 43 60 mov 0x60(%ebx),%eax 10fff3: 8b 04 b8 mov (%eax,%edi,4),%eax if ( !p ) /* ensure we have a valid pointer */ 10fff6: 85 c0 test %eax,%eax 10fff8: 74 51 je 11004b <== NEVER TAKEN 10fffa: 31 d2 xor %edx,%edx 10fffc: eb 21 jmp 11001f break; for ( j=0 ; j<== NEVER TAKEN memfile_free_blocks_in_table( (block_p **)&p[j], to_free); 110003: 51 push %ecx 110004: 51 push %ecx 110005: 56 push %esi 110006: 50 push %eax 110007: 89 45 dc mov %eax,-0x24(%ebp) 11000a: 89 55 e0 mov %edx,-0x20(%ebp) 11000d: e8 0f ff ff ff call 10ff21 110012: 83 c4 10 add $0x10,%esp 110015: 8b 55 e0 mov -0x20(%ebp),%edx 110018: 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( 11002c: 52 push %edx 11002d: 52 push %edx 11002e: 56 push %esi 11002f: 8b 45 e4 mov -0x1c(%ebp),%eax 110032: 03 43 60 add 0x60(%ebx),%eax 110035: 50 push %eax 110036: e8 e6 fe ff ff call 10ff21 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( 11004b: 50 push %eax 11004c: 50 push %eax 11004d: 56 push %esi (block_p **)&info->triply_indirect, to_free ); 11004e: 83 c3 60 add $0x60,%ebx } } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( 110051: 53 push %ebx 110052: e8 ca fe ff ff call 10ff21 110057: 83 c4 10 add $0x10,%esp (block_p **)&info->triply_indirect, to_free ); } return 0; } 11005a: 31 c0 xor %eax,%eax 11005c: 8d 65 f4 lea -0xc(%ebp),%esp 11005f: 5b pop %ebx 110060: 5e pop %esi 110061: 5f pop %edi 110062: c9 leave 110063: c3 ret =============================================================================== 00110180 : IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 110180: 55 push %ebp 110181: 89 e5 mov %esp,%ebp 110183: 57 push %edi 110184: 56 push %esi 110185: 53 push %ebx 110186: 83 ec 3c sub $0x3c,%esp 110189: 8b 75 0c mov 0xc(%ebp),%esi 11018c: 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; 11018f: 8b 4d 18 mov 0x18(%ebp),%ecx 110192: 01 f1 add %esi,%ecx if ( last_byte > the_jnode->info.file.size ) { 110194: 89 c8 mov %ecx,%eax 110196: 31 d2 xor %edx,%edx 110198: 8b 5d 08 mov 0x8(%ebp),%ebx 11019b: 3b 53 54 cmp 0x54(%ebx),%edx 11019e: 7c 2c jl 1101cc <== NEVER TAKEN 1101a0: 7f 05 jg 1101a7 <== NEVER TAKEN 1101a2: 3b 4b 50 cmp 0x50(%ebx),%ecx 1101a5: 76 25 jbe 1101cc <== NEVER TAKEN status = IMFS_memfile_extend( the_jnode, last_byte ); 1101a7: 51 push %ecx 1101a8: 52 push %edx 1101a9: 50 push %eax 1101aa: ff 75 08 pushl 0x8(%ebp) 1101ad: e8 dc fe ff ff call 11008e if ( status ) 1101b2: 83 c4 10 add $0x10,%esp 1101b5: 85 c0 test %eax,%eax 1101b7: 74 13 je 1101cc rtems_set_errno_and_return_minus_one( ENOSPC ); 1101b9: e8 ee 0e 00 00 call 1110ac <__errno> 1101be: c7 00 1c 00 00 00 movl $0x1c,(%eax) 1101c4: 83 cb ff or $0xffffffff,%ebx 1101c7: e9 03 01 00 00 jmp 1102cf */ /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 1101cc: a1 8c 3e 12 00 mov 0x123e8c,%eax 1101d1: 89 45 c8 mov %eax,-0x38(%ebp) 1101d4: 99 cltd 1101d5: 89 d3 mov %edx,%ebx 1101d7: 52 push %edx 1101d8: 50 push %eax 1101d9: 57 push %edi 1101da: 56 push %esi 1101db: 89 45 c4 mov %eax,-0x3c(%ebp) 1101de: e8 c9 bf 00 00 call 11c1ac <__moddi3> 1101e3: 83 c4 10 add $0x10,%esp 1101e6: 89 45 cc mov %eax,-0x34(%ebp) block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 1101e9: 8b 4d c4 mov -0x3c(%ebp),%ecx 1101ec: 53 push %ebx 1101ed: 51 push %ecx 1101ee: 57 push %edi 1101ef: 56 push %esi 1101f0: e8 6b be 00 00 call 11c060 <__divdi3> 1101f5: 83 c4 10 add $0x10,%esp 1101f8: 89 45 d0 mov %eax,-0x30(%ebp) if ( start_offset ) { 1101fb: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 1101ff: 74 44 je 110245 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 ); 110201: 52 push %edx 110202: 6a 00 push $0x0 110204: 50 push %eax 110205: ff 75 08 pushl 0x8(%ebp) 110208: e8 c7 f9 ff ff call 10fbd4 if ( !block_ptr ) 11020d: 83 c4 10 add $0x10,%esp return copied; 110210: 31 db xor %ebx,%ebx 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 ) 110212: 85 c0 test %eax,%eax 110214: 0f 84 b5 00 00 00 je 1102cf <== 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; 11021a: 8b 55 c8 mov -0x38(%ebp),%edx 11021d: 2b 55 cc sub -0x34(%ebp),%edx 110220: 3b 55 18 cmp 0x18(%ebp),%edx 110223: 76 03 jbe 110228 110225: 8b 55 18 mov 0x18(%ebp),%edx block, to_copy, src ); #endif memcpy( &(*block_ptr)[ start_offset ], src, to_copy ); 110228: 8b 00 mov (%eax),%eax 11022a: 03 45 cc add -0x34(%ebp),%eax src += to_copy; 11022d: 89 c7 mov %eax,%edi 11022f: 8b 75 14 mov 0x14(%ebp),%esi 110232: 89 d1 mov %edx,%ecx 110234: f3 a4 rep movsb %ds:(%esi),%es:(%edi) block++; 110236: ff 45 d0 incl -0x30(%ebp) my_length -= to_copy; 110239: 8b 5d 18 mov 0x18(%ebp),%ebx 11023c: 29 d3 sub %edx,%ebx 11023e: 89 5d d4 mov %ebx,-0x2c(%ebp) copied += to_copy; 110241: 89 d3 mov %edx,%ebx 110243: eb 0b jmp 110250 unsigned int last_byte; unsigned int start_offset; int copied; const unsigned char *src; src = source; 110245: 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 ) { 110248: 8b 45 18 mov 0x18(%ebp),%eax 11024b: 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; 11024e: 31 db xor %ebx,%ebx /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 110250: 8b 15 8c 3e 12 00 mov 0x123e8c,%edx while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 110256: eb 2b jmp 110283 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 110258: 50 push %eax 110259: 6a 00 push $0x0 11025b: ff 75 d0 pushl -0x30(%ebp) 11025e: ff 75 08 pushl 0x8(%ebp) 110261: 89 55 c4 mov %edx,-0x3c(%ebp) 110264: e8 6b f9 ff ff call 10fbd4 if ( !block_ptr ) 110269: 83 c4 10 add $0x10,%esp 11026c: 85 c0 test %eax,%eax 11026e: 8b 55 c4 mov -0x3c(%ebp),%edx 110271: 74 5c je 1102cf <== 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 ); 110273: 8b 00 mov (%eax),%eax src += to_copy; 110275: 89 c7 mov %eax,%edi 110277: 89 d1 mov %edx,%ecx 110279: f3 a4 rep movsb %ds:(%esi),%es:(%edi) block++; 11027b: ff 45 d0 incl -0x30(%ebp) my_length -= to_copy; 11027e: 29 55 d4 sub %edx,-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( 110281: 01 d3 add %edx,%ebx /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 110283: 8b 45 d4 mov -0x2c(%ebp),%eax 110286: 3b 05 8c 3e 12 00 cmp 0x123e8c,%eax 11028c: 73 ca jae 110258 * 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 ) { 11028e: 85 c0 test %eax,%eax 110290: 74 21 je 1102b3 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 110292: 57 push %edi 110293: 6a 00 push $0x0 110295: ff 75 d0 pushl -0x30(%ebp) 110298: ff 75 08 pushl 0x8(%ebp) 11029b: e8 34 f9 ff ff call 10fbd4 if ( !block_ptr ) 1102a0: 83 c4 10 add $0x10,%esp 1102a3: 85 c0 test %eax,%eax 1102a5: 74 28 je 1102cf <== 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 ); 1102a7: 8b 00 mov (%eax),%eax 1102a9: 89 c7 mov %eax,%edi 1102ab: 8b 4d d4 mov -0x2c(%ebp),%ecx 1102ae: f3 a4 rep movsb %ds:(%esi),%es:(%edi) my_length = 0; copied += to_copy; 1102b0: 03 5d d4 add -0x2c(%ebp),%ebx } IMFS_mtime_ctime_update( the_jnode ); 1102b3: 56 push %esi 1102b4: 56 push %esi 1102b5: 6a 00 push $0x0 1102b7: 8d 45 e0 lea -0x20(%ebp),%eax 1102ba: 50 push %eax 1102bb: e8 00 71 ff ff call 1073c0 1102c0: 8b 45 e0 mov -0x20(%ebp),%eax 1102c3: 8b 55 08 mov 0x8(%ebp),%edx 1102c6: 89 42 44 mov %eax,0x44(%edx) 1102c9: 89 42 48 mov %eax,0x48(%edx) return copied; 1102cc: 83 c4 10 add $0x10,%esp } 1102cf: 89 d8 mov %ebx,%eax 1102d1: 8d 65 f4 lea -0xc(%ebp),%esp 1102d4: 5b pop %ebx 1102d5: 5e pop %esi 1102d6: 5f pop %edi 1102d7: c9 leave 1102d8: 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 05 a3 00 00 call 1110ac <__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 =============================================================================== 00109538 : * This routine prints the contents of the specified jnode. */ void IMFS_print_jnode( IMFS_jnode_t *the_jnode ) { 109538: 55 push %ebp 109539: 89 e5 mov %esp,%ebp 10953b: 53 push %ebx 10953c: 83 ec 0c sub $0xc,%esp 10953f: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_assert( the_jnode ); fprintf(stdout, "%s", the_jnode->name ); 109542: a1 20 81 12 00 mov 0x128120,%eax 109547: ff 70 08 pushl 0x8(%eax) 10954a: 8d 43 0c lea 0xc(%ebx),%eax 10954d: 50 push %eax 10954e: e8 dd bd 00 00 call 115330 switch( the_jnode->type ) { 109553: 8b 43 4c mov 0x4c(%ebx),%eax 109556: 83 c4 10 add $0x10,%esp 109559: 8d 50 ff lea -0x1(%eax),%edx 10955c: 83 fa 06 cmp $0x6,%edx 10955f: 77 75 ja 1095d6 <== NEVER TAKEN 109561: a1 20 81 12 00 mov 0x128120,%eax 109566: ff 24 95 90 3f 12 00 jmp *0x123f90(,%edx,4) case IMFS_DIRECTORY: fprintf(stdout, "/" ); 10956d: 51 push %ecx 10956e: 51 push %ecx 10956f: ff 70 08 pushl 0x8(%eax) 109572: 6a 2f push $0x2f 109574: e8 0b bd 00 00 call 115284 109579: eb 2b jmp 1095a6 break; case IMFS_DEVICE: fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")", 10957b: ff 73 54 pushl 0x54(%ebx) 10957e: ff 73 50 pushl 0x50(%ebx) 109581: 68 b5 3e 12 00 push $0x123eb5 109586: eb 16 jmp 10959e the_jnode->info.device.major, the_jnode->info.device.minor ); break; case IMFS_LINEAR_FILE: fprintf(stdout, " (file %" PRId32 " %p)", 109588: ff 73 58 pushl 0x58(%ebx) 10958b: ff 73 50 pushl 0x50(%ebx) 10958e: 68 c8 3e 12 00 push $0x123ec8 109593: eb 09 jmp 10959e the_jnode->info.file.indirect, the_jnode->info.file.doubly_indirect, the_jnode->info.file.triply_indirect ); #else fprintf(stdout, " (file %" PRId32 ")", 109595: 52 push %edx 109596: ff 73 50 pushl 0x50(%ebx) 109599: 68 d7 3e 12 00 push $0x123ed7 10959e: ff 70 08 pushl 0x8(%eax) 1095a1: e8 7e bc 00 00 call 115224 (uint32_t)the_jnode->info.file.size ); #endif break; 1095a6: 83 c4 10 add $0x10,%esp default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 1095a9: c7 45 08 c1 41 12 00 movl $0x1241c1,0x8(%ebp) } 1095b0: 8b 5d fc mov -0x4(%ebp),%ebx 1095b3: c9 leave default: fprintf(stdout, " bad type %d\n", the_jnode->type ); return; } puts(""); 1095b4: e9 2f d5 00 00 jmp 116ae8 case IMFS_HARD_LINK: fprintf(stdout, " links not printed\n" ); return; case IMFS_SYM_LINK: fprintf(stdout, " links not printed\n" ); 1095b9: 53 push %ebx 1095ba: 53 push %ebx 1095bb: ff 70 08 pushl 0x8(%eax) 1095be: 68 e3 3e 12 00 push $0x123ee3 1095c3: eb 0a jmp 1095cf return; case IMFS_FIFO: fprintf(stdout, " FIFO not printed\n" ); 1095c5: 51 push %ecx 1095c6: 51 push %ecx 1095c7: ff 70 08 pushl 0x8(%eax) 1095ca: 68 f7 3e 12 00 push $0x123ef7 1095cf: e8 5c bd 00 00 call 115330 1095d4: eb 14 jmp 1095ea return; default: fprintf(stdout, " bad type %d\n", the_jnode->type ); 1095d6: 52 push %edx <== NOT EXECUTED 1095d7: 50 push %eax <== NOT EXECUTED 1095d8: 68 0a 3f 12 00 push $0x123f0a <== NOT EXECUTED 1095dd: a1 20 81 12 00 mov 0x128120,%eax <== NOT EXECUTED 1095e2: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1095e5: e8 3a bc 00 00 call 115224 <== NOT EXECUTED return; 1095ea: 83 c4 10 add $0x10,%esp } puts(""); } 1095ed: 8b 5d fc mov -0x4(%ebp),%ebx 1095f0: c9 leave 1095f1: 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 6a b1 00 00 call 111f7c 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 d0 3b 00 00 call 10a9f4 <_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 95 3b 00 00 call 10a9d0 <_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 =============================================================================== 0010de28 : int IMFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 10de28: 55 push %ebp 10de29: 89 e5 mov %esp,%ebp 10de2b: 56 push %esi 10de2c: 53 push %ebx 10de2d: 8b 4d 08 mov 0x8(%ebp),%ecx 10de30: 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; 10de33: 8b 11 mov (%ecx),%edx switch ( the_jnode->type ) { 10de35: 8b 5a 4c mov 0x4c(%edx),%ebx 10de38: 83 eb 02 sub $0x2,%ebx 10de3b: 83 fb 05 cmp $0x5,%ebx 10de3e: 77 33 ja 10de73 <== NEVER TAKEN 10de40: ff 24 9d 40 eb 11 00 jmp *0x11eb40(,%ebx,4) case IMFS_DEVICE: io = &the_jnode->info.device; buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor ); 10de47: 8b 5a 54 mov 0x54(%edx),%ebx rtems_device_minor_number _minor ) { union __rtems_dev_t temp; temp.__overlay.major = _major; 10de4a: 8b 72 50 mov 0x50(%edx),%esi 10de4d: 89 70 18 mov %esi,0x18(%eax) 10de50: 89 58 1c mov %ebx,0x1c(%eax) break; 10de53: eb 2e jmp 10de83 case IMFS_LINEAR_FILE: case IMFS_MEMORY_FILE: buf->st_size = the_jnode->info.file.size; 10de55: 8b 5a 50 mov 0x50(%edx),%ebx 10de58: 8b 72 54 mov 0x54(%edx),%esi 10de5b: 89 58 20 mov %ebx,0x20(%eax) 10de5e: 89 70 24 mov %esi,0x24(%eax) break; 10de61: eb 20 jmp 10de83 case IMFS_SYM_LINK: buf->st_size = 0; break; case IMFS_FIFO: buf->st_size = 0; 10de63: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) 10de6a: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) break; 10de71: eb 10 jmp 10de83 default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 10de73: e8 34 32 00 00 call 1110ac <__errno> 10de78: c7 00 86 00 00 00 movl $0x86,(%eax) 10de7e: 83 c8 ff or $0xffffffff,%eax 10de81: eb 47 jmp 10deca /* * The device number of the IMFS is the major number and the minor is the * instance. */ fs_info = loc->mt_entry->fs_info; 10de83: 8b 49 10 mov 0x10(%ecx),%ecx buf->st_dev = rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance ); 10de86: 8b 49 34 mov 0x34(%ecx),%ecx 10de89: 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 = 10de8b: c7 00 fe ff 00 00 movl $0xfffe,(%eax) 10de91: 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; 10de94: 8b 4a 30 mov 0x30(%edx),%ecx 10de97: 89 48 0c mov %ecx,0xc(%eax) buf->st_nlink = the_jnode->st_nlink; 10de9a: 8b 4a 34 mov 0x34(%edx),%ecx 10de9d: 66 89 48 10 mov %cx,0x10(%eax) buf->st_ino = the_jnode->st_ino; 10dea1: 8b 4a 38 mov 0x38(%edx),%ecx 10dea4: 89 48 08 mov %ecx,0x8(%eax) buf->st_uid = the_jnode->st_uid; 10dea7: 8b 4a 3c mov 0x3c(%edx),%ecx 10deaa: 66 89 48 12 mov %cx,0x12(%eax) buf->st_gid = the_jnode->st_gid; 10deae: 66 8b 4a 3e mov 0x3e(%edx),%cx 10deb2: 66 89 48 14 mov %cx,0x14(%eax) buf->st_atime = the_jnode->stat_atime; 10deb6: 8b 4a 40 mov 0x40(%edx),%ecx 10deb9: 89 48 28 mov %ecx,0x28(%eax) buf->st_mtime = the_jnode->stat_mtime; 10debc: 8b 4a 44 mov 0x44(%edx),%ecx 10debf: 89 48 30 mov %ecx,0x30(%eax) buf->st_ctime = the_jnode->stat_ctime; 10dec2: 8b 52 48 mov 0x48(%edx),%edx 10dec5: 89 50 38 mov %edx,0x38(%eax) return 0; 10dec8: 31 c0 xor %eax,%eax } 10deca: 5b pop %ebx 10decb: 5e pop %esi 10decc: c9 leave 10decd: 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 a8 a1 00 00 call 1110ac <__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 8d 66 00 00 call 10d5b8 /* * 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 09 a1 00 00 call 1110ac <__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 f6 a0 00 00 call 1110ac <__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 =============================================================================== 00107118 : static rtems_printk_plugin_t print_handler; void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) { 107118: 55 push %ebp <== NOT EXECUTED 107119: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10711b: 57 push %edi <== NOT EXECUTED 10711c: 56 push %esi <== NOT EXECUTED 10711d: 53 push %ebx <== NOT EXECUTED 10711e: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 107121: 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) { 107124: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED 107127: 75 1d jne 107146 <== NOT EXECUTED if (!Stack_check_Interrupt_stack.area) 107129: 83 3d dc 71 12 00 00 cmpl $0x0,0x1271dc <== NOT EXECUTED 107130: 0f 84 f5 00 00 00 je 10722b <== NOT EXECUTED return; stack = &Stack_check_Interrupt_stack; 107136: ba d8 71 12 00 mov $0x1271d8,%edx <== NOT EXECUTED the_thread = 0; current = 0; 10713b: 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; 107142: 31 db xor %ebx,%ebx <== NOT EXECUTED 107144: eb 0f jmp 107155 <== NOT EXECUTED current = 0; } else #endif { stack = &the_thread->Start.Initial_stack; 107146: 8d 93 c4 00 00 00 lea 0xc4(%ebx),%edx <== NOT EXECUTED current = (void *)_CPU_Context_Get_SP( &the_thread->Registers ); 10714c: 8b 83 d8 00 00 00 mov 0xd8(%ebx),%eax <== NOT EXECUTED 107152: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED } low = Stack_check_usable_stack_start(stack); 107155: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 107158: 8d 48 10 lea 0x10(%eax),%ecx <== NOT EXECUTED size = Stack_check_usable_stack_size(stack); 10715b: 8b 32 mov (%edx),%esi <== NOT EXECUTED 10715d: 83 ee 10 sub $0x10,%esi <== NOT EXECUTED 107160: 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; 107163: 83 c0 20 add $0x20,%eax <== NOT EXECUTED for (ebase = base + length; base < ebase; base++) 107166: 83 e6 fc and $0xfffffffc,%esi <== NOT EXECUTED 107169: 8d 34 30 lea (%eax,%esi,1),%esi <== NOT EXECUTED 10716c: eb 0b jmp 107179 <== NOT EXECUTED if (*base != U32_PATTERN) 10716e: 81 38 a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%eax) <== NOT EXECUTED 107174: 75 0b jne 107181 <== 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++) 107176: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 107179: 39 f0 cmp %esi,%eax <== NOT EXECUTED 10717b: 72 f1 jb 10716e <== 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; 10717d: 31 ff xor %edi,%edi <== NOT EXECUTED 10717f: eb 0e jmp 10718f <== NOT EXECUTED 107181: 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 ) 107183: 85 c0 test %eax,%eax <== NOT EXECUTED 107185: 74 08 je 10718f <== NOT EXECUTED used = Stack_check_Calculate_used( low, size, high_water_mark ); 107187: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED 10718a: 8d 3c 39 lea (%ecx,%edi,1),%edi <== NOT EXECUTED 10718d: 29 c7 sub %eax,%edi <== NOT EXECUTED else used = 0; #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if ( the_thread ) 10718f: 85 db test %ebx,%ebx <== NOT EXECUTED 107191: 8b 35 b4 6e 12 00 mov 0x126eb4,%esi <== NOT EXECUTED 107197: 74 28 je 1071c1 <== NOT EXECUTED #endif { (*print_handler)( 107199: 50 push %eax <== NOT EXECUTED 10719a: 8d 45 e3 lea -0x1d(%ebp),%eax <== NOT EXECUTED 10719d: 50 push %eax <== NOT EXECUTED 10719e: 6a 05 push $0x5 <== NOT EXECUTED 1071a0: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 1071a3: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED 1071a6: e8 89 53 00 00 call 10c534 <== NOT EXECUTED 1071ab: 50 push %eax <== NOT EXECUTED 1071ac: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 1071af: 68 ab 0c 12 00 push $0x120cab <== NOT EXECUTED 1071b4: ff 35 b0 6e 12 00 pushl 0x126eb0 <== NOT EXECUTED 1071ba: ff d6 call *%esi <== NOT EXECUTED 1071bc: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1071bf: eb 16 jmp 1071d7 <== 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 ); 1071c1: 53 push %ebx <== NOT EXECUTED 1071c2: 6a ff push $0xffffffff <== NOT EXECUTED 1071c4: 68 b8 0c 12 00 push $0x120cb8 <== NOT EXECUTED 1071c9: ff 35 b0 6e 12 00 pushl 0x126eb0 <== NOT EXECUTED 1071cf: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED 1071d2: ff d6 call *%esi <== NOT EXECUTED 1071d4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1071d7: 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, 1071da: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); } #endif (*print_handler)( 1071dd: 51 push %ecx <== NOT EXECUTED 1071de: 51 push %ecx <== NOT EXECUTED 1071df: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 1071e2: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED print_context, " %010p - %010p %010p %8" PRId32 " ", stack->area, stack->area + stack->size - 1, 1071e5: 8b 12 mov (%edx),%edx <== NOT EXECUTED else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); } #endif (*print_handler)( 1071e7: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED 1071eb: 52 push %edx <== NOT EXECUTED 1071ec: 50 push %eax <== NOT EXECUTED 1071ed: 68 c6 0c 12 00 push $0x120cc6 <== NOT EXECUTED 1071f2: ff 35 b0 6e 12 00 pushl 0x126eb0 <== NOT EXECUTED 1071f8: ff 15 b4 6e 12 00 call *0x126eb4 <== NOT EXECUTED stack->area + stack->size - 1, current, size ); if (Stack_check_Initialized == 0) { 1071fe: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 107201: 83 3d b8 6e 12 00 00 cmpl $0x0,0x126eb8 <== NOT EXECUTED 107208: 8b 35 b4 6e 12 00 mov 0x126eb4,%esi <== NOT EXECUTED 10720e: 75 09 jne 107219 <== NOT EXECUTED (*print_handler)( print_context, "Unavailable\n" ); 107210: 52 push %edx <== NOT EXECUTED 107211: 52 push %edx <== NOT EXECUTED 107212: 68 e4 0c 12 00 push $0x120ce4 <== NOT EXECUTED 107217: eb 07 jmp 107220 <== NOT EXECUTED } else { (*print_handler)( print_context, "%8" PRId32 "\n", used ); 107219: 50 push %eax <== NOT EXECUTED 10721a: 57 push %edi <== NOT EXECUTED 10721b: 68 f1 0c 12 00 push $0x120cf1 <== NOT EXECUTED 107220: ff 35 b0 6e 12 00 pushl 0x126eb0 <== NOT EXECUTED 107226: ff d6 call *%esi <== NOT EXECUTED 107228: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 10722b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10722e: 5b pop %ebx <== NOT EXECUTED 10722f: 5e pop %esi <== NOT EXECUTED 107230: 5f pop %edi <== NOT EXECUTED 107231: c9 leave <== NOT EXECUTED 107232: c3 ret <== NOT EXECUTED =============================================================================== 00107233 : /* * Stack_check_Initialize */ void Stack_check_Initialize( void ) { 107233: 55 push %ebp 107234: 89 e5 mov %esp,%ebp 107236: 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 ) 107237: 83 3d b8 6e 12 00 00 cmpl $0x0,0x126eb8 10723e: 75 5a jne 10729a /* * Dope the pattern and fill areas */ p = Stack_check_Pattern.pattern; for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) { p[i] = pattern[ i%4 ]; 107240: c7 05 c8 71 12 00 0d movl $0xfeedf00d,0x1271c8 107247: f0 ed fe 10724a: c7 05 cc 71 12 00 06 movl $0xbad0d06,0x1271cc 107251: 0d ad 0b 107254: c7 05 d0 71 12 00 0d movl $0xdeadf00d,0x1271d0 10725b: f0 ad de 10725e: c7 05 d4 71 12 00 06 movl $0x600d0d06,0x1271d4 107265: 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) { 107268: 8b 15 dc 78 12 00 mov 0x1278dc,%edx 10726e: 85 d2 test %edx,%edx 107270: 74 1e je 107290 <== NEVER TAKEN 107272: 8b 0d e0 78 12 00 mov 0x1278e0,%ecx 107278: 85 c9 test %ecx,%ecx 10727a: 74 14 je 107290 <== NEVER TAKEN Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low; 10727c: 89 15 dc 71 12 00 mov %edx,0x1271dc Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high - 107282: 29 d1 sub %edx,%ecx 107284: 89 0d d8 71 12 00 mov %ecx,0x1271d8 (char *) _CPU_Interrupt_stack_low; Stack_check_Dope_stack(&Stack_check_Interrupt_stack); 10728a: b0 a5 mov $0xa5,%al 10728c: 89 d7 mov %edx,%edi 10728e: f3 aa rep stos %al,%es:(%edi) } #endif Stack_check_Initialized = 1; 107290: c7 05 b8 6e 12 00 01 movl $0x1,0x126eb8 107297: 00 00 00 } 10729a: 5f pop %edi 10729b: c9 leave 10729c: c3 ret =============================================================================== 001072eb : Thread_Control *running, bool pattern_ok ) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE; void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok) { 1072eb: 55 push %ebp <== NOT EXECUTED 1072ec: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1072ee: 56 push %esi <== NOT EXECUTED 1072ef: 53 push %ebx <== NOT EXECUTED 1072f0: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 1072f3: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1072f6: 8a 55 0c mov 0xc(%ebp),%dl <== NOT EXECUTED Stack_Control *stack = &running->Start.Initial_stack; void *pattern_area = Stack_check_Get_pattern_area(stack); 1072f9: 8b b3 c8 00 00 00 mov 0xc8(%ebx),%esi <== NOT EXECUTED char name [32]; printk("BLOWN STACK!!!\n"); 1072ff: 68 f7 0c 12 00 push $0x120cf7 <== NOT EXECUTED 107304: 88 55 d4 mov %dl,-0x2c(%ebp) <== NOT EXECUTED 107307: e8 08 19 00 00 call 108c14 <== NOT EXECUTED printk("task control block: 0x%08" PRIxPTR "\n", running); 10730c: 5a pop %edx <== NOT EXECUTED 10730d: 59 pop %ecx <== NOT EXECUTED 10730e: 53 push %ebx <== NOT EXECUTED 10730f: 68 07 0d 12 00 push $0x120d07 <== NOT EXECUTED 107314: e8 fb 18 00 00 call 108c14 <== NOT EXECUTED printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id); 107319: 59 pop %ecx <== NOT EXECUTED 10731a: 58 pop %eax <== NOT EXECUTED 10731b: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10731e: 68 24 0d 12 00 push $0x120d24 <== NOT EXECUTED 107323: e8 ec 18 00 00 call 108c14 <== NOT EXECUTED printk( 107328: 58 pop %eax <== NOT EXECUTED 107329: 5a pop %edx <== NOT EXECUTED 10732a: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10732d: 68 36 0d 12 00 push $0x120d36 <== NOT EXECUTED 107332: e8 dd 18 00 00 call 108c14 <== NOT EXECUTED "task name: 0x%08" PRIx32 "\n", running->Object.name.name_u32 ); printk( 107337: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10733a: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED 10733d: 50 push %eax <== NOT EXECUTED 10733e: 6a 20 push $0x20 <== NOT EXECUTED 107340: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 107343: e8 ec 51 00 00 call 10c534 <== NOT EXECUTED 107348: 5a pop %edx <== NOT EXECUTED 107349: 59 pop %ecx <== NOT EXECUTED 10734a: 50 push %eax <== NOT EXECUTED 10734b: 68 4a 0d 12 00 push $0x120d4a <== NOT EXECUTED 107350: e8 bf 18 00 00 call 108c14 <== 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) 107355: 8b 8b c8 00 00 00 mov 0xc8(%ebx),%ecx <== NOT EXECUTED 10735b: 8b 83 c4 00 00 00 mov 0xc4(%ebx),%eax <== NOT EXECUTED ); printk( "task name string: %s\n", rtems_object_get_name(running->Object.id, sizeof(name), name) ); printk( 107361: 8d 1c 01 lea (%ecx,%eax,1),%ebx <== NOT EXECUTED 107364: 53 push %ebx <== NOT EXECUTED 107365: 51 push %ecx <== NOT EXECUTED 107366: 50 push %eax <== NOT EXECUTED 107367: 68 60 0d 12 00 push $0x120d60 <== NOT EXECUTED 10736c: e8 a3 18 00 00 call 108c14 <== 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) { 107371: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 107374: 8a 55 d4 mov -0x2c(%ebp),%dl <== NOT EXECUTED 107377: 84 d2 test %dl,%dl <== NOT EXECUTED 107379: 75 17 jne 107392 <== 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_area(stack); 10737b: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED (unsigned long) stack->size, stack->area, ((char *) stack->area + stack->size) ); if (!pattern_ok) { printk( 10737e: 83 c6 18 add $0x18,%esi <== NOT EXECUTED 107381: 56 push %esi <== NOT EXECUTED 107382: 50 push %eax <== NOT EXECUTED 107383: 6a 10 push $0x10 <== NOT EXECUTED 107385: 68 91 0d 12 00 push $0x120d91 <== NOT EXECUTED 10738a: e8 85 18 00 00 call 108c14 <== NOT EXECUTED 10738f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_configuration_get_user_multiprocessing_table()->node ); } #endif rtems_fatal_error_occurred(0x81); 107392: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107395: 68 81 00 00 00 push $0x81 <== NOT EXECUTED 10739a: e8 d9 58 00 00 call 10cc78 <== NOT EXECUTED =============================================================================== 0010cdfc <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 10cdfc: 55 push %ebp 10cdfd: 89 e5 mov %esp,%ebp 10cdff: 53 push %ebx 10ce00: 83 ec 04 sub $0x4,%esp 10ce03: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; Thread_Control *executing = _Thread_Executing; 10ce06: 8b 15 44 88 12 00 mov 0x128844,%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 ); 10ce0c: 9c pushf 10ce0d: fa cli 10ce0e: 58 pop %eax if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 10ce0f: 8b 4b 44 mov 0x44(%ebx),%ecx 10ce12: 85 c9 test %ecx,%ecx 10ce14: 75 0b jne 10ce21 <_CORE_RWLock_Release+0x25> _ISR_Enable( level ); 10ce16: 50 push %eax 10ce17: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10ce18: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) return CORE_RWLOCK_SUCCESSFUL; 10ce1f: eb 72 jmp 10ce93 <_CORE_RWLock_Release+0x97> } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { 10ce21: 49 dec %ecx 10ce22: 75 0f jne 10ce33 <_CORE_RWLock_Release+0x37> the_rwlock->number_of_readers -= 1; 10ce24: 8b 4b 48 mov 0x48(%ebx),%ecx 10ce27: 49 dec %ecx 10ce28: 89 4b 48 mov %ecx,0x48(%ebx) if ( the_rwlock->number_of_readers != 0 ) { 10ce2b: 85 c9 test %ecx,%ecx 10ce2d: 74 04 je 10ce33 <_CORE_RWLock_Release+0x37> /* must be unlocked again */ _ISR_Enable( level ); 10ce2f: 50 push %eax 10ce30: 9d popf return CORE_RWLOCK_SUCCESSFUL; 10ce31: eb 60 jmp 10ce93 <_CORE_RWLock_Release+0x97> } } /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */ executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10ce33: 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; 10ce3a: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) _ISR_Enable( level ); 10ce41: 50 push %eax 10ce42: 9d popf next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 10ce43: 83 ec 0c sub $0xc,%esp 10ce46: 53 push %ebx 10ce47: e8 68 15 00 00 call 10e3b4 <_Thread_queue_Dequeue> if ( next ) { 10ce4c: 83 c4 10 add $0x10,%esp 10ce4f: 85 c0 test %eax,%eax 10ce51: 74 40 je 10ce93 <_CORE_RWLock_Release+0x97> if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 10ce53: 83 78 30 01 cmpl $0x1,0x30(%eax) 10ce57: 75 09 jne 10ce62 <_CORE_RWLock_Release+0x66> the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10ce59: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx) return CORE_RWLOCK_SUCCESSFUL; 10ce60: eb 31 jmp 10ce93 <_CORE_RWLock_Release+0x97> } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 10ce62: ff 43 48 incl 0x48(%ebx) the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10ce65: 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 ); 10ce6c: 83 ec 0c sub $0xc,%esp 10ce6f: 53 push %ebx 10ce70: e8 2b 19 00 00 call 10e7a0 <_Thread_queue_First> if ( !next || 10ce75: 83 c4 10 add $0x10,%esp 10ce78: 85 c0 test %eax,%eax 10ce7a: 74 17 je 10ce93 <_CORE_RWLock_Release+0x97> 10ce7c: 83 78 30 01 cmpl $0x1,0x30(%eax) 10ce80: 74 11 je 10ce93 <_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; 10ce82: ff 43 48 incl 0x48(%ebx) _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 10ce85: 52 push %edx 10ce86: 52 push %edx 10ce87: 50 push %eax 10ce88: 53 push %ebx 10ce89: e8 06 18 00 00 call 10e694 <_Thread_queue_Extract> } 10ce8e: 83 c4 10 add $0x10,%esp 10ce91: eb d9 jmp 10ce6c <_CORE_RWLock_Release+0x70> } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10ce93: 31 c0 xor %eax,%eax 10ce95: 8b 5d fc mov -0x4(%ebp),%ebx 10ce98: c9 leave 10ce99: c3 ret =============================================================================== 0010ce9c <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 10ce9c: 55 push %ebp 10ce9d: 89 e5 mov %esp,%ebp 10ce9f: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10cea2: 8d 45 f4 lea -0xc(%ebp),%eax 10cea5: 50 push %eax 10cea6: ff 75 08 pushl 0x8(%ebp) 10cea9: e8 aa 11 00 00 call 10e058 <_Thread_Get> switch ( location ) { 10ceae: 83 c4 10 add $0x10,%esp 10ceb1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10ceb5: 75 17 jne 10cece <_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 ); 10ceb7: 83 ec 0c sub $0xc,%esp 10ceba: 50 push %eax 10cebb: e8 ac 19 00 00 call 10e86c <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10cec0: a1 f4 82 12 00 mov 0x1282f4,%eax 10cec5: 48 dec %eax 10cec6: a3 f4 82 12 00 mov %eax,0x1282f4 10cecb: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10cece: c9 leave 10cecf: c3 ret =============================================================================== 00117364 <_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 ) { 117364: 55 push %ebp 117365: 89 e5 mov %esp,%ebp 117367: 57 push %edi 117368: 56 push %esi 117369: 53 push %ebx 11736a: 83 ec 1c sub $0x1c,%esp 11736d: 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; 117370: 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 ) { 117375: 8b 55 10 mov 0x10(%ebp),%edx 117378: 3b 53 4c cmp 0x4c(%ebx),%edx 11737b: 77 4e ja 1173cb <_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 ) { 11737d: 83 7b 48 00 cmpl $0x0,0x48(%ebx) 117381: 75 09 jne 11738c <_CORE_message_queue_Broadcast+0x28> 117383: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 11738a: eb 23 jmp 1173af <_CORE_message_queue_Broadcast+0x4b> *count = 0; 11738c: 8b 45 1c mov 0x1c(%ebp),%eax 11738f: c7 00 00 00 00 00 movl $0x0,(%eax) 117395: eb 32 jmp 1173c9 <_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; 117397: ff 45 e4 incl -0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 11739a: 8b 42 2c mov 0x2c(%edx),%eax 11739d: 89 c7 mov %eax,%edi 11739f: 8b 75 0c mov 0xc(%ebp),%esi 1173a2: 8b 4d 10 mov 0x10(%ebp),%ecx 1173a5: f3 a4 rep movsb %ds:(%esi),%es:(%edi) buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 1173a7: 8b 42 28 mov 0x28(%edx),%eax 1173aa: 8b 55 10 mov 0x10(%ebp),%edx 1173ad: 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 = 1173af: 83 ec 0c sub $0xc,%esp 1173b2: 53 push %ebx 1173b3: e8 9c 22 00 00 call 119654 <_Thread_queue_Dequeue> 1173b8: 89 c2 mov %eax,%edx 1173ba: 83 c4 10 add $0x10,%esp 1173bd: 85 c0 test %eax,%eax 1173bf: 75 d6 jne 117397 <_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; 1173c1: 8b 55 e4 mov -0x1c(%ebp),%edx 1173c4: 8b 45 1c mov 0x1c(%ebp),%eax 1173c7: 89 10 mov %edx,(%eax) return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 1173c9: 31 c0 xor %eax,%eax } 1173cb: 8d 65 f4 lea -0xc(%ebp),%esp 1173ce: 5b pop %ebx 1173cf: 5e pop %esi 1173d0: 5f pop %edi 1173d1: c9 leave 1173d2: c3 ret =============================================================================== 00112218 <_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 ) { 112218: 55 push %ebp 112219: 89 e5 mov %esp,%ebp 11221b: 57 push %edi 11221c: 56 push %esi 11221d: 53 push %ebx 11221e: 83 ec 1c sub $0x1c,%esp 112221: 8b 5d 08 mov 0x8(%ebp),%ebx 112224: 8b 7d 10 mov 0x10(%ebp),%edi 112227: 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; 11222a: 89 7b 44 mov %edi,0x44(%ebx) the_message_queue->number_of_pending_messages = 0; 11222d: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) the_message_queue->maximum_message_size = maximum_message_size; 112234: 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; 112237: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) the_message_queue->notify_argument = the_argument; 11223e: 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)) { 112245: 89 d0 mov %edx,%eax 112247: f6 c2 03 test $0x3,%dl 11224a: 74 0c je 112258 <_CORE_message_queue_Initialize+0x40> allocated_message_size += sizeof(uint32_t); 11224c: 83 c0 04 add $0x4,%eax allocated_message_size &= ~(sizeof(uint32_t) - 1); 11224f: 83 e0 fc and $0xfffffffc,%eax } if (allocated_message_size < maximum_message_size) return false; 112252: 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) 112254: 39 d0 cmp %edx,%eax 112256: 72 68 jb 1122c0 <_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)); 112258: 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 * 11225b: 89 d1 mov %edx,%ecx 11225d: 0f af cf imul %edi,%ecx (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) return false; 112260: 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) 112262: 39 c1 cmp %eax,%ecx 112264: 72 5a jb 1122c0 <_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 ); 112266: 83 ec 0c sub $0xc,%esp 112269: 51 push %ecx 11226a: 89 55 e4 mov %edx,-0x1c(%ebp) 11226d: e8 a0 26 00 00 call 114912 <_Workspace_Allocate> return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 112272: 89 43 5c mov %eax,0x5c(%ebx) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 112275: 83 c4 10 add $0x10,%esp 112278: 85 c0 test %eax,%eax 11227a: 8b 55 e4 mov -0x1c(%ebp),%edx 11227d: 74 41 je 1122c0 <_CORE_message_queue_Initialize+0xa8> /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 11227f: 52 push %edx 112280: 57 push %edi 112281: 50 push %eax 112282: 8d 43 68 lea 0x68(%ebx),%eax 112285: 50 push %eax 112286: e8 e1 49 00 00 call 116c6c <_Chain_Initialize> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 11228b: 8d 43 54 lea 0x54(%ebx),%eax 11228e: 89 43 50 mov %eax,0x50(%ebx) RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 112291: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) the_message_queue->message_buffers, (size_t) maximum_pending_messages, allocated_message_size + sizeof( CORE_message_queue_Buffer_control ) ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); 112298: 8d 43 50 lea 0x50(%ebx),%eax 11229b: 89 43 58 mov %eax,0x58(%ebx) _Thread_queue_Initialize( 11229e: 6a 06 push $0x6 1122a0: 68 80 00 00 00 push $0x80 1122a5: 8b 45 0c mov 0xc(%ebp),%eax 1122a8: 83 38 01 cmpl $0x1,(%eax) 1122ab: 0f 94 c0 sete %al 1122ae: 0f b6 c0 movzbl %al,%eax 1122b1: 50 push %eax 1122b2: 53 push %ebx 1122b3: e8 04 1d 00 00 call 113fbc <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 1122b8: 83 c4 20 add $0x20,%esp 1122bb: be 01 00 00 00 mov $0x1,%esi } 1122c0: 89 f0 mov %esi,%eax 1122c2: 8d 65 f4 lea -0xc(%ebp),%esp 1122c5: 5b pop %ebx 1122c6: 5e pop %esi 1122c7: 5f pop %edi 1122c8: c9 leave 1122c9: c3 ret =============================================================================== 001122cc <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 1122cc: 55 push %ebp 1122cd: 89 e5 mov %esp,%ebp 1122cf: 57 push %edi 1122d0: 56 push %esi 1122d1: 53 push %ebx 1122d2: 83 ec 2c sub $0x2c,%esp 1122d5: 8b 55 08 mov 0x8(%ebp),%edx 1122d8: 8b 45 0c mov 0xc(%ebp),%eax 1122db: 89 45 dc mov %eax,-0x24(%ebp) 1122de: 8b 5d 10 mov 0x10(%ebp),%ebx 1122e1: 89 5d e0 mov %ebx,-0x20(%ebp) 1122e4: 8b 4d 14 mov 0x14(%ebp),%ecx 1122e7: 8b 75 1c mov 0x1c(%ebp),%esi 1122ea: 89 75 d4 mov %esi,-0x2c(%ebp) 1122ed: 8a 45 18 mov 0x18(%ebp),%al 1122f0: 88 45 db mov %al,-0x25(%ebp) ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *executing; executing = _Thread_Executing; 1122f3: a1 9c c9 12 00 mov 0x12c99c,%eax executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 1122f8: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) _ISR_Disable( level ); 1122ff: 9c pushf 112300: fa cli 112301: 8f 45 e4 popl -0x1c(%ebp) */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 112304: 8b 5a 50 mov 0x50(%edx),%ebx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 112307: 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)) 11230a: 39 f3 cmp %esi,%ebx 11230c: 0f 84 8a 00 00 00 je 11239c <_CORE_message_queue_Seize+0xd0> { Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; 112312: 8b 33 mov (%ebx),%esi the_chain->first = new_first; 112314: 89 72 50 mov %esi,0x50(%edx) CORE_message_queue_Buffer_control *_CORE_message_queue_Get_pending_message ( CORE_message_queue_Control *the_message_queue ) { return (CORE_message_queue_Buffer_control *) _Chain_Get_unprotected( &the_message_queue->Pending_messages ); 112317: 8d 7a 50 lea 0x50(%edx),%edi 11231a: 89 7e 04 mov %edi,0x4(%esi) the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); if ( the_message != NULL ) { 11231d: 85 db test %ebx,%ebx 11231f: 74 7b je 11239c <_CORE_message_queue_Seize+0xd0><== NEVER TAKEN the_message_queue->number_of_pending_messages -= 1; 112321: ff 4a 48 decl 0x48(%edx) _ISR_Enable( level ); 112324: ff 75 e4 pushl -0x1c(%ebp) 112327: 9d popf *size_p = the_message->Contents.size; 112328: 8b 43 0c mov 0xc(%ebx),%eax 11232b: 89 01 mov %eax,(%ecx) _Thread_Executing->Wait.count = 11232d: 8b 73 08 mov 0x8(%ebx),%esi 112330: a1 9c c9 12 00 mov 0x12c99c,%eax 112335: 89 70 24 mov %esi,0x24(%eax) _CORE_message_queue_Get_message_priority( the_message ); _CORE_message_queue_Copy_buffer( the_message->Contents.buffer, 112338: 8d 73 10 lea 0x10(%ebx),%esi 11233b: 89 75 e4 mov %esi,-0x1c(%ebp) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 11233e: 8b 09 mov (%ecx),%ecx 112340: 8b 7d e0 mov -0x20(%ebp),%edi 112343: 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 ); 112345: 83 ec 0c sub $0xc,%esp 112348: 52 push %edx 112349: 89 55 d0 mov %edx,-0x30(%ebp) 11234c: e8 3b 19 00 00 call 113c8c <_Thread_queue_Dequeue> if ( !the_thread ) { 112351: 83 c4 10 add $0x10,%esp 112354: 85 c0 test %eax,%eax 112356: 8b 55 d0 mov -0x30(%ebp),%edx 112359: 75 15 jne 112370 <_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 ); 11235b: 89 5d 0c mov %ebx,0xc(%ebp) 11235e: 83 c2 68 add $0x68,%edx 112361: 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 ); } 112364: 8d 65 f4 lea -0xc(%ebp),%esp 112367: 5b pop %ebx 112368: 5e pop %esi 112369: 5f pop %edi 11236a: c9 leave 11236b: e9 28 fe ff ff jmp 112198 <_Chain_Append> CORE_message_queue_Buffer_control *the_message, int priority ) { #if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY) the_message->priority = priority; 112370: 8b 48 24 mov 0x24(%eax),%ecx 112373: 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; 112376: 8b 48 30 mov 0x30(%eax),%ecx 112379: 89 4b 0c mov %ecx,0xc(%ebx) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 11237c: 8b 70 2c mov 0x2c(%eax),%esi 11237f: 8b 7d e4 mov -0x1c(%ebp),%edi 112382: 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( 112384: 8b 43 08 mov 0x8(%ebx),%eax 112387: 89 45 10 mov %eax,0x10(%ebp) 11238a: 89 5d 0c mov %ebx,0xc(%ebp) 11238d: 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 ); } 112390: 8d 65 f4 lea -0xc(%ebp),%esp 112393: 5b pop %ebx 112394: 5e pop %esi 112395: 5f pop %edi 112396: c9 leave the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 112397: e9 08 49 00 00 jmp 116ca4 <_CORE_message_queue_Insert_message> return; } #endif } if ( !wait ) { 11239c: 80 7d db 00 cmpb $0x0,-0x25(%ebp) 1123a0: 75 13 jne 1123b5 <_CORE_message_queue_Seize+0xe9> _ISR_Enable( level ); 1123a2: ff 75 e4 pushl -0x1c(%ebp) 1123a5: 9d popf executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 1123a6: 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 ); } 1123ad: 8d 65 f4 lea -0xc(%ebp),%esp 1123b0: 5b pop %ebx 1123b1: 5e pop %esi 1123b2: 5f pop %edi 1123b3: c9 leave 1123b4: 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; 1123b5: 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; 1123bc: 89 50 44 mov %edx,0x44(%eax) executing->Wait.id = id; 1123bf: 8b 5d dc mov -0x24(%ebp),%ebx 1123c2: 89 58 20 mov %ebx,0x20(%eax) executing->Wait.return_argument_second.mutable_object = buffer; 1123c5: 8b 75 e0 mov -0x20(%ebp),%esi 1123c8: 89 70 2c mov %esi,0x2c(%eax) executing->Wait.return_argument = size_p; 1123cb: 89 48 28 mov %ecx,0x28(%eax) /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 1123ce: ff 75 e4 pushl -0x1c(%ebp) 1123d1: 9d popf _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 1123d2: c7 45 10 6c 40 11 00 movl $0x11406c,0x10(%ebp) 1123d9: 8b 45 d4 mov -0x2c(%ebp),%eax 1123dc: 89 45 0c mov %eax,0xc(%ebp) 1123df: 89 55 08 mov %edx,0x8(%ebp) } 1123e2: 8d 65 f4 lea -0xc(%ebp),%esp 1123e5: 5b pop %ebx 1123e6: 5e pop %esi 1123e7: 5f pop %edi 1123e8: 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 ); 1123e9: e9 a6 19 00 00 jmp 113d94 <_Thread_queue_Enqueue_with_handler> =============================================================================== 0010ac1d <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 10ac1d: 55 push %ebp 10ac1e: 89 e5 mov %esp,%ebp 10ac20: 53 push %ebx 10ac21: 83 ec 14 sub $0x14,%esp 10ac24: 8b 5d 08 mov 0x8(%ebp),%ebx 10ac27: 8a 55 10 mov 0x10(%ebp),%dl _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10ac2a: a1 e4 42 12 00 mov 0x1242e4,%eax 10ac2f: 85 c0 test %eax,%eax 10ac31: 74 19 je 10ac4c <_CORE_mutex_Seize+0x2f> 10ac33: 84 d2 test %dl,%dl 10ac35: 74 15 je 10ac4c <_CORE_mutex_Seize+0x2f><== NEVER TAKEN 10ac37: 83 3d 64 44 12 00 01 cmpl $0x1,0x124464 10ac3e: 76 0c jbe 10ac4c <_CORE_mutex_Seize+0x2f> 10ac40: 53 push %ebx 10ac41: 6a 12 push $0x12 10ac43: 6a 00 push $0x0 10ac45: 6a 00 push $0x0 10ac47: e8 e4 05 00 00 call 10b230 <_Internal_error_Occurred> 10ac4c: 51 push %ecx 10ac4d: 51 push %ecx 10ac4e: 8d 45 18 lea 0x18(%ebp),%eax 10ac51: 50 push %eax 10ac52: 53 push %ebx 10ac53: 88 55 f4 mov %dl,-0xc(%ebp) 10ac56: e8 b9 46 00 00 call 10f314 <_CORE_mutex_Seize_interrupt_trylock> 10ac5b: 83 c4 10 add $0x10,%esp 10ac5e: 85 c0 test %eax,%eax 10ac60: 8a 55 f4 mov -0xc(%ebp),%dl 10ac63: 74 48 je 10acad <_CORE_mutex_Seize+0x90> 10ac65: 84 d2 test %dl,%dl 10ac67: 75 12 jne 10ac7b <_CORE_mutex_Seize+0x5e> 10ac69: ff 75 18 pushl 0x18(%ebp) 10ac6c: 9d popf 10ac6d: a1 34 48 12 00 mov 0x124834,%eax 10ac72: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) 10ac79: eb 32 jmp 10acad <_CORE_mutex_Seize+0x90> 10ac7b: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) 10ac82: a1 34 48 12 00 mov 0x124834,%eax 10ac87: 89 58 44 mov %ebx,0x44(%eax) 10ac8a: 8b 55 0c mov 0xc(%ebp),%edx 10ac8d: 89 50 20 mov %edx,0x20(%eax) 10ac90: a1 e4 42 12 00 mov 0x1242e4,%eax 10ac95: 40 inc %eax 10ac96: a3 e4 42 12 00 mov %eax,0x1242e4 10ac9b: ff 75 18 pushl 0x18(%ebp) 10ac9e: 9d popf 10ac9f: 50 push %eax 10aca0: 50 push %eax 10aca1: ff 75 14 pushl 0x14(%ebp) 10aca4: 53 push %ebx 10aca5: e8 26 ff ff ff call 10abd0 <_CORE_mutex_Seize_interrupt_blocking> 10acaa: 83 c4 10 add $0x10,%esp } 10acad: 8b 5d fc mov -0x4(%ebp),%ebx 10acb0: c9 leave 10acb1: c3 ret =============================================================================== 0010add8 <_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 ) { 10add8: 55 push %ebp 10add9: 89 e5 mov %esp,%ebp 10addb: 53 push %ebx 10addc: 83 ec 10 sub $0x10,%esp 10addf: 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)) ) { 10ade2: 53 push %ebx 10ade3: e8 64 14 00 00 call 10c24c <_Thread_queue_Dequeue> 10ade8: 89 c2 mov %eax,%edx 10adea: 83 c4 10 add $0x10,%esp { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10aded: 31 c0 xor %eax,%eax if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 10adef: 85 d2 test %edx,%edx 10adf1: 75 15 jne 10ae08 <_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 ); 10adf3: 9c pushf 10adf4: fa cli 10adf5: 59 pop %ecx if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10adf6: 8b 53 48 mov 0x48(%ebx),%edx the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; 10adf9: 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 ) 10adfb: 3b 53 40 cmp 0x40(%ebx),%edx 10adfe: 73 06 jae 10ae06 <_CORE_semaphore_Surrender+0x2e><== NEVER TAKEN the_semaphore->count += 1; 10ae00: 42 inc %edx 10ae01: 89 53 48 mov %edx,0x48(%ebx) { Thread_Control *the_thread; ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 10ae04: 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 ); 10ae06: 51 push %ecx 10ae07: 9d popf } return status; } 10ae08: 8b 5d fc mov -0x4(%ebp),%ebx 10ae0b: c9 leave 10ae0c: c3 ret =============================================================================== 00109d48 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 109d48: 55 push %ebp 109d49: 89 e5 mov %esp,%ebp 109d4b: 57 push %edi 109d4c: 56 push %esi 109d4d: 53 push %ebx 109d4e: 83 ec 2c sub $0x2c,%esp 109d51: 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 ]; 109d54: 8b bb f4 00 00 00 mov 0xf4(%ebx),%edi option_set = (rtems_option) the_thread->Wait.option; 109d5a: 8b 43 30 mov 0x30(%ebx),%eax 109d5d: 89 45 e0 mov %eax,-0x20(%ebp) _ISR_Disable( level ); 109d60: 9c pushf 109d61: fa cli 109d62: 58 pop %eax pending_events = api->pending_events; 109d63: 8b 17 mov (%edi),%edx 109d65: 89 55 d4 mov %edx,-0x2c(%ebp) event_condition = (rtems_event_set) the_thread->Wait.count; 109d68: 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 ) ) { 109d6b: 21 f2 and %esi,%edx 109d6d: 75 07 jne 109d76 <_Event_Surrender+0x2e> _ISR_Enable( level ); 109d6f: 50 push %eax 109d70: 9d popf return; 109d71: e9 af 00 00 00 jmp 109e25 <_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() && 109d76: 83 3d 30 48 12 00 00 cmpl $0x0,0x124830 109d7d: 74 49 je 109dc8 <_Event_Surrender+0x80> 109d7f: 3b 1d 34 48 12 00 cmp 0x124834,%ebx 109d85: 75 41 jne 109dc8 <_Event_Surrender+0x80> _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 109d87: 8b 0d e4 4b 12 00 mov 0x124be4,%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 ) && 109d8d: 83 f9 02 cmp $0x2,%ecx 109d90: 74 09 je 109d9b <_Event_Surrender+0x53> <== NEVER TAKEN ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { 109d92: 8b 0d e4 4b 12 00 mov 0x124be4,%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) || 109d98: 49 dec %ecx 109d99: 75 2d jne 109dc8 <_Event_Surrender+0x80> (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 109d9b: 39 f2 cmp %esi,%edx 109d9d: 74 06 je 109da5 <_Event_Surrender+0x5d> 109d9f: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109da3: 74 1f je 109dc4 <_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) ); 109da5: 89 d6 mov %edx,%esi 109da7: f7 d6 not %esi 109da9: 23 75 d4 and -0x2c(%ebp),%esi 109dac: 89 37 mov %esi,(%edi) api->pending_events = _Event_sets_Clear( pending_events,seized_events ); the_thread->Wait.count = 0; 109dae: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109db5: 8b 4b 28 mov 0x28(%ebx),%ecx 109db8: 89 11 mov %edx,(%ecx) _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 109dba: c7 05 e4 4b 12 00 03 movl $0x3,0x124be4 109dc1: 00 00 00 } _ISR_Enable( level ); 109dc4: 50 push %eax 109dc5: 9d popf return; 109dc6: eb 5d jmp 109e25 <_Event_Surrender+0xdd> } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 109dc8: f6 43 11 01 testb $0x1,0x11(%ebx) 109dcc: 74 55 je 109e23 <_Event_Surrender+0xdb> if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 109dce: 39 f2 cmp %esi,%edx 109dd0: 74 06 je 109dd8 <_Event_Surrender+0x90> 109dd2: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109dd6: 74 4b je 109e23 <_Event_Surrender+0xdb> <== NEVER TAKEN 109dd8: 89 d6 mov %edx,%esi 109dda: f7 d6 not %esi 109ddc: 23 75 d4 and -0x2c(%ebp),%esi 109ddf: 89 37 mov %esi,(%edi) api->pending_events = _Event_sets_Clear( pending_events, seized_events ); the_thread->Wait.count = 0; 109de1: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109de8: 8b 4b 28 mov 0x28(%ebx),%ecx 109deb: 89 11 mov %edx,(%ecx) _ISR_Flash( level ); 109ded: 50 push %eax 109dee: 9d popf 109def: fa cli if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 109df0: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 109df4: 74 06 je 109dfc <_Event_Surrender+0xb4> _ISR_Enable( level ); 109df6: 50 push %eax 109df7: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 109df8: 51 push %ecx 109df9: 51 push %ecx 109dfa: eb 17 jmp 109e13 <_Event_Surrender+0xcb> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 109dfc: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 109e03: 50 push %eax 109e04: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 109e05: 83 ec 0c sub $0xc,%esp 109e08: 8d 43 48 lea 0x48(%ebx),%eax 109e0b: 50 push %eax 109e0c: e8 a7 2f 00 00 call 10cdb8 <_Watchdog_Remove> 109e11: 58 pop %eax 109e12: 5a pop %edx 109e13: 68 f8 ff 03 10 push $0x1003fff8 109e18: 53 push %ebx 109e19: e8 3e 1d 00 00 call 10bb5c <_Thread_Clear_state> 109e1e: 83 c4 10 add $0x10,%esp 109e21: eb 02 jmp 109e25 <_Event_Surrender+0xdd> _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 109e23: 50 push %eax 109e24: 9d popf } 109e25: 8d 65 f4 lea -0xc(%ebp),%esp 109e28: 5b pop %ebx 109e29: 5e pop %esi 109e2a: 5f pop %edi 109e2b: c9 leave 109e2c: c3 ret =============================================================================== 00109e30 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 109e30: 55 push %ebp 109e31: 89 e5 mov %esp,%ebp 109e33: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 109e36: 8d 45 f4 lea -0xc(%ebp),%eax 109e39: 50 push %eax 109e3a: ff 75 08 pushl 0x8(%ebp) 109e3d: e8 ae 20 00 00 call 10bef0 <_Thread_Get> switch ( location ) { 109e42: 83 c4 10 add $0x10,%esp 109e45: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 109e49: 75 49 jne 109e94 <_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 ); 109e4b: 9c pushf 109e4c: fa cli 109e4d: 5a pop %edx _ISR_Enable( level ); return; } #endif the_thread->Wait.count = 0; 109e4e: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) if ( _Thread_Is_executing( the_thread ) ) { 109e55: 3b 05 34 48 12 00 cmp 0x124834,%eax 109e5b: 75 13 jne 109e70 <_Event_Timeout+0x40> if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 109e5d: 8b 0d e4 4b 12 00 mov 0x124be4,%ecx 109e63: 49 dec %ecx 109e64: 75 0a jne 109e70 <_Event_Timeout+0x40> _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 109e66: c7 05 e4 4b 12 00 02 movl $0x2,0x124be4 109e6d: 00 00 00 } the_thread->Wait.return_code = RTEMS_TIMEOUT; 109e70: c7 40 34 06 00 00 00 movl $0x6,0x34(%eax) _ISR_Enable( level ); 109e77: 52 push %edx 109e78: 9d popf 109e79: 52 push %edx 109e7a: 52 push %edx 109e7b: 68 f8 ff 03 10 push $0x1003fff8 109e80: 50 push %eax 109e81: e8 d6 1c 00 00 call 10bb5c <_Thread_Clear_state> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 109e86: a1 e4 42 12 00 mov 0x1242e4,%eax 109e8b: 48 dec %eax 109e8c: a3 e4 42 12 00 mov %eax,0x1242e4 _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; 109e91: 83 c4 10 add $0x10,%esp case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 109e94: c9 leave 109e95: c3 ret =============================================================================== 0010f973 <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t *extended_size_ptr ) { 10f973: 55 push %ebp 10f974: 89 e5 mov %esp,%ebp 10f976: 57 push %edi 10f977: 56 push %esi 10f978: 53 push %ebx 10f979: 83 ec 4c sub $0x4c,%esp 10f97c: 8b 5d 08 mov 0x8(%ebp),%ebx 10f97f: 8b 4d 10 mov 0x10(%ebp),%ecx Heap_Statistics *const stats = &heap->stats; Heap_Block *const first_block = heap->first_block; 10f982: 8b 43 20 mov 0x20(%ebx),%eax 10f985: 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; 10f988: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) Heap_Block *extend_last_block = NULL; 10f98f: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) uintptr_t const page_size = heap->page_size; 10f996: 8b 53 10 mov 0x10(%ebx),%edx 10f999: 89 55 c4 mov %edx,-0x3c(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10f99c: 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; 10f99f: 8b 7b 30 mov 0x30(%ebx),%edi 10f9a2: 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; 10f9a5: 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 ) { 10f9a7: 8b 7d 0c mov 0xc(%ebp),%edi 10f9aa: 01 cf add %ecx,%edi 10f9ac: 0f 82 d4 01 00 00 jb 10fb86 <_Heap_Extend+0x213> return false; } extend_area_ok = _Heap_Get_first_and_last_block( 10f9b2: 52 push %edx 10f9b3: 52 push %edx 10f9b4: 8d 55 e0 lea -0x20(%ebp),%edx 10f9b7: 52 push %edx 10f9b8: 8d 55 e4 lea -0x1c(%ebp),%edx 10f9bb: 52 push %edx 10f9bc: 50 push %eax 10f9bd: ff 75 c4 pushl -0x3c(%ebp) 10f9c0: 51 push %ecx 10f9c1: ff 75 0c pushl 0xc(%ebp) 10f9c4: e8 8a b9 ff ff call 10b353 <_Heap_Get_first_and_last_block> page_size, min_block_size, &extend_first_block, &extend_last_block ); if (!extend_area_ok ) { 10f9c9: 83 c4 20 add $0x20,%esp 10f9cc: 84 c0 test %al,%al 10f9ce: 0f 84 b2 01 00 00 je 10fb86 <_Heap_Extend+0x213> 10f9d4: 8b 4d c0 mov -0x40(%ebp),%ecx 10f9d7: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) 10f9de: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) 10f9e5: 31 f6 xor %esi,%esi 10f9e7: 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; 10f9ee: 8b 43 18 mov 0x18(%ebx),%eax 10f9f1: 89 5d b8 mov %ebx,-0x48(%ebp) 10f9f4: eb 02 jmp 10f9f8 <_Heap_Extend+0x85> 10f9f6: 89 c8 mov %ecx,%eax uintptr_t const sub_area_end = start_block->prev_size; 10f9f8: 8b 19 mov (%ecx),%ebx Heap_Block *const end_block = _Heap_Block_of_alloc_area( sub_area_end, page_size ); if ( 10f9fa: 39 c7 cmp %eax,%edi 10f9fc: 76 09 jbe 10fa07 <_Heap_Extend+0x94> 10f9fe: 39 5d 0c cmp %ebx,0xc(%ebp) 10fa01: 0f 82 7d 01 00 00 jb 10fb84 <_Heap_Extend+0x211> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10fa07: 39 c7 cmp %eax,%edi 10fa09: 74 06 je 10fa11 <_Heap_Extend+0x9e> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10fa0b: 39 df cmp %ebx,%edi 10fa0d: 72 07 jb 10fa16 <_Heap_Extend+0xa3> 10fa0f: eb 08 jmp 10fa19 <_Heap_Extend+0xa6> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin ) { return false; } if ( extend_area_end == sub_area_begin ) { 10fa11: 89 4d d0 mov %ecx,-0x30(%ebp) 10fa14: eb 03 jmp 10fa19 <_Heap_Extend+0xa6> merge_below_block = start_block; } else if ( extend_area_end < sub_area_end ) { 10fa16: 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); 10fa19: 8d 43 f8 lea -0x8(%ebx),%eax 10fa1c: 89 45 d4 mov %eax,-0x2c(%ebp) 10fa1f: 89 d8 mov %ebx,%eax 10fa21: 31 d2 xor %edx,%edx 10fa23: 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); 10fa26: 29 55 d4 sub %edx,-0x2c(%ebp) link_below_block = start_block; } if ( sub_area_end == extend_area_begin ) { 10fa29: 3b 5d 0c cmp 0xc(%ebp),%ebx 10fa2c: 75 07 jne 10fa35 <_Heap_Extend+0xc2> start_block->prev_size = extend_area_end; 10fa2e: 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 ) 10fa30: 8b 75 d4 mov -0x2c(%ebp),%esi 10fa33: eb 08 jmp 10fa3d <_Heap_Extend+0xca> merge_above_block = end_block; } else if ( sub_area_end < extend_area_begin ) { 10fa35: 73 06 jae 10fa3d <_Heap_Extend+0xca> 10fa37: 8b 55 d4 mov -0x2c(%ebp),%edx 10fa3a: 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; 10fa3d: 8b 45 d4 mov -0x2c(%ebp),%eax 10fa40: 8b 48 04 mov 0x4(%eax),%ecx 10fa43: 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); 10fa46: 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 ); 10fa48: 3b 4d c0 cmp -0x40(%ebp),%ecx 10fa4b: 75 a9 jne 10f9f6 <_Heap_Extend+0x83> 10fa4d: 8b 5d b8 mov -0x48(%ebp),%ebx if ( extend_area_begin < heap->area_begin ) { 10fa50: 8b 55 0c mov 0xc(%ebp),%edx 10fa53: 3b 53 18 cmp 0x18(%ebx),%edx 10fa56: 73 05 jae 10fa5d <_Heap_Extend+0xea> heap->area_begin = extend_area_begin; 10fa58: 89 53 18 mov %edx,0x18(%ebx) 10fa5b: eb 08 jmp 10fa65 <_Heap_Extend+0xf2> } else if ( heap->area_end < extend_area_end ) { 10fa5d: 39 7b 1c cmp %edi,0x1c(%ebx) 10fa60: 73 03 jae 10fa65 <_Heap_Extend+0xf2> heap->area_end = extend_area_end; 10fa62: 89 7b 1c mov %edi,0x1c(%ebx) } extend_first_block_size = (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 10fa65: 8b 45 e0 mov -0x20(%ebp),%eax 10fa68: 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 = 10fa6b: 89 c1 mov %eax,%ecx 10fa6d: 29 d1 sub %edx,%ecx 10fa6f: 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; 10fa72: 89 3a mov %edi,(%edx) extend_first_block->size_and_flag = extend_first_block_size | HEAP_PREV_BLOCK_USED; 10fa74: 83 c9 01 or $0x1,%ecx 10fa77: 89 4a 04 mov %ecx,0x4(%edx) _Heap_Protection_block_initialize( heap, extend_first_block ); extend_last_block->prev_size = extend_first_block_size; 10fa7a: 8b 4d d4 mov -0x2c(%ebp),%ecx 10fa7d: 89 08 mov %ecx,(%eax) extend_last_block->size_and_flag = 0; 10fa7f: 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 ) { 10fa86: 39 53 20 cmp %edx,0x20(%ebx) 10fa89: 76 05 jbe 10fa90 <_Heap_Extend+0x11d> heap->first_block = extend_first_block; 10fa8b: 89 53 20 mov %edx,0x20(%ebx) 10fa8e: eb 08 jmp 10fa98 <_Heap_Extend+0x125> } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 10fa90: 39 43 24 cmp %eax,0x24(%ebx) 10fa93: 73 03 jae 10fa98 <_Heap_Extend+0x125> heap->last_block = extend_last_block; 10fa95: 89 43 24 mov %eax,0x24(%ebx) } if ( merge_below_block != NULL ) { 10fa98: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 10fa9c: 74 3b je 10fad9 <_Heap_Extend+0x166> Heap_Control *heap, uintptr_t extend_area_begin, Heap_Block *first_block ) { uintptr_t const page_size = heap->page_size; 10fa9e: 8b 43 10 mov 0x10(%ebx),%eax 10faa1: 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 ); 10faa4: 8b 4d 0c mov 0xc(%ebp),%ecx 10faa7: 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; 10faaa: 89 c8 mov %ecx,%eax 10faac: 31 d2 xor %edx,%edx 10faae: f7 75 d4 divl -0x2c(%ebp) if ( remainder != 0 ) { 10fab1: 85 d2 test %edx,%edx 10fab3: 74 05 je 10faba <_Heap_Extend+0x147> <== ALWAYS TAKEN return value - remainder + alignment; 10fab5: 03 4d d4 add -0x2c(%ebp),%ecx <== NOT EXECUTED 10fab8: 29 d1 sub %edx,%ecx <== NOT EXECUTED uintptr_t const new_first_block_begin = 10faba: 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; 10fabd: 8b 45 d0 mov -0x30(%ebp),%eax 10fac0: 8b 00 mov (%eax),%eax 10fac2: 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 = 10fac5: 8b 45 d0 mov -0x30(%ebp),%eax 10fac8: 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; 10faca: 83 c8 01 or $0x1,%eax 10facd: 89 42 04 mov %eax,0x4(%edx) _Heap_Free_block( heap, new_first_block ); 10fad0: 89 d8 mov %ebx,%eax 10fad2: e8 81 fe ff ff call 10f958 <_Heap_Free_block> 10fad7: eb 14 jmp 10faed <_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 ) { 10fad9: 83 7d c8 00 cmpl $0x0,-0x38(%ebp) 10fadd: 74 0e je 10faed <_Heap_Extend+0x17a> _Heap_Link_below( 10fadf: 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; 10fae2: 8b 45 c8 mov -0x38(%ebp),%eax 10fae5: 29 d0 sub %edx,%eax 10fae7: 83 c8 01 or $0x1,%eax 10faea: 89 42 04 mov %eax,0x4(%edx) link_below_block, extend_last_block ); } if ( merge_above_block != NULL ) { 10faed: 85 f6 test %esi,%esi 10faef: 74 30 je 10fb21 <_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, 10faf1: 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( 10faf4: 29 f7 sub %esi,%edi RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down( uintptr_t value, uintptr_t alignment ) { return value - (value % alignment); 10faf6: 89 f8 mov %edi,%eax 10faf8: 31 d2 xor %edx,%edx 10fafa: f7 73 10 divl 0x10(%ebx) 10fafd: 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) 10faff: 8b 46 04 mov 0x4(%esi),%eax 10fb02: 29 f8 sub %edi,%eax | HEAP_PREV_BLOCK_USED; 10fb04: 83 c8 01 or $0x1,%eax 10fb07: 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; 10fb0b: 8b 46 04 mov 0x4(%esi),%eax 10fb0e: 83 e0 01 and $0x1,%eax block->size_and_flag = size | flag; 10fb11: 09 f8 or %edi,%eax 10fb13: 89 46 04 mov %eax,0x4(%esi) _Heap_Block_set_size( last_block, last_block_new_size ); _Heap_Free_block( heap, last_block ); 10fb16: 89 f2 mov %esi,%edx 10fb18: 89 d8 mov %ebx,%eax 10fb1a: e8 39 fe ff ff call 10f958 <_Heap_Free_block> 10fb1f: eb 21 jmp 10fb42 <_Heap_Extend+0x1cf> ); } if ( merge_above_block != NULL ) { _Heap_Merge_above( heap, merge_above_block, extend_area_end ); } else if ( link_above_block != NULL ) { 10fb21: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 10fb25: 74 1b je 10fb42 <_Heap_Extend+0x1cf> _Heap_Link_above( 10fb27: 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 ); 10fb2a: 8b 45 e4 mov -0x1c(%ebp),%eax 10fb2d: 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; 10fb30: 8b 7d cc mov -0x34(%ebp),%edi 10fb33: 8b 57 04 mov 0x4(%edi),%edx 10fb36: 83 e2 01 and $0x1,%edx block->size_and_flag = size | flag; 10fb39: 09 d0 or %edx,%eax 10fb3b: 89 47 04 mov %eax,0x4(%edi) last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 10fb3e: 83 49 04 01 orl $0x1,0x4(%ecx) extend_first_block, extend_last_block ); } if ( merge_below_block == NULL && merge_above_block == NULL ) { 10fb42: 85 f6 test %esi,%esi 10fb44: 75 10 jne 10fb56 <_Heap_Extend+0x1e3> 10fb46: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 10fb4a: 75 0a jne 10fb56 <_Heap_Extend+0x1e3> _Heap_Free_block( heap, extend_first_block ); 10fb4c: 8b 55 e4 mov -0x1c(%ebp),%edx 10fb4f: 89 d8 mov %ebx,%eax 10fb51: e8 02 fe ff ff call 10f958 <_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 10fb56: 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( 10fb59: 8b 43 20 mov 0x20(%ebx),%eax 10fb5c: 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; 10fb5e: 8b 4a 04 mov 0x4(%edx),%ecx 10fb61: 83 e1 01 and $0x1,%ecx block->size_and_flag = size | flag; 10fb64: 09 c8 or %ecx,%eax 10fb66: 89 42 04 mov %eax,0x4(%edx) } _Heap_Set_last_block_size( heap ); extended_size = stats->free_size - free_size; 10fb69: 8b 43 30 mov 0x30(%ebx),%eax 10fb6c: 2b 45 bc sub -0x44(%ebp),%eax /* Statistics */ stats->size += extended_size; 10fb6f: 01 43 2c add %eax,0x2c(%ebx) if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; 10fb72: 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 ) 10fb77: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10fb7b: 74 09 je 10fb86 <_Heap_Extend+0x213> <== NEVER TAKEN *extended_size_ptr = extended_size; 10fb7d: 8b 55 14 mov 0x14(%ebp),%edx 10fb80: 89 02 mov %eax,(%edx) 10fb82: eb 02 jmp 10fb86 <_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; 10fb84: 31 f6 xor %esi,%esi if ( extended_size_ptr != NULL ) *extended_size_ptr = extended_size; return true; } 10fb86: 89 f0 mov %esi,%eax 10fb88: 8d 65 f4 lea -0xc(%ebp),%esp 10fb8b: 5b pop %ebx 10fb8c: 5e pop %esi 10fb8d: 5f pop %edi 10fb8e: c9 leave 10fb8f: c3 ret =============================================================================== 0010f5b8 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 10f5b8: 55 push %ebp 10f5b9: 89 e5 mov %esp,%ebp 10f5bb: 57 push %edi 10f5bc: 56 push %esi 10f5bd: 53 push %ebx 10f5be: 83 ec 14 sub $0x14,%esp 10f5c1: 8b 4d 08 mov 0x8(%ebp),%ecx 10f5c4: 8b 45 0c mov 0xc(%ebp),%eax 10f5c7: 8d 58 f8 lea -0x8(%eax),%ebx 10f5ca: 31 d2 xor %edx,%edx 10f5cc: 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); 10f5cf: 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 10f5d1: 8b 41 20 mov 0x20(%ecx),%eax 10f5d4: 89 45 ec mov %eax,-0x14(%ebp) && (uintptr_t) block <= (uintptr_t) heap->last_block; 10f5d7: 31 d2 xor %edx,%edx 10f5d9: 39 c3 cmp %eax,%ebx 10f5db: 72 08 jb 10f5e5 <_Heap_Free+0x2d> 10f5dd: 31 d2 xor %edx,%edx 10f5df: 39 59 24 cmp %ebx,0x24(%ecx) 10f5e2: 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; 10f5e5: 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 ) ) { 10f5e7: 85 d2 test %edx,%edx 10f5e9: 0f 84 21 01 00 00 je 10f710 <_Heap_Free+0x158> --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10f5ef: 8b 43 04 mov 0x4(%ebx),%eax 10f5f2: 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; 10f5f5: 89 c6 mov %eax,%esi 10f5f7: 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); 10f5fa: 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; 10f5fd: 31 ff xor %edi,%edi 10f5ff: 3b 55 ec cmp -0x14(%ebp),%edx 10f602: 72 0a jb 10f60e <_Heap_Free+0x56> <== NEVER TAKEN 10f604: 31 c0 xor %eax,%eax 10f606: 39 51 24 cmp %edx,0x24(%ecx) 10f609: 0f 93 c0 setae %al 10f60c: 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; 10f60e: 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 ) ) { 10f610: 85 ff test %edi,%edi 10f612: 0f 84 f8 00 00 00 je 10f710 <_Heap_Free+0x158> <== NEVER TAKEN --stats->used_blocks; ++stats->frees; stats->free_size += block_size; return( true ); } 10f618: 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 ) ) { 10f61b: f7 c7 01 00 00 00 test $0x1,%edi 10f621: 0f 84 e9 00 00 00 je 10f710 <_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; 10f627: 83 e7 fe and $0xfffffffe,%edi 10f62a: 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 10f62d: 8b 41 24 mov 0x24(%ecx),%eax 10f630: 89 45 e4 mov %eax,-0x1c(%ebp) && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); 10f633: 31 c0 xor %eax,%eax 10f635: 3b 55 e4 cmp -0x1c(%ebp),%edx 10f638: 74 0a je 10f644 <_Heap_Free+0x8c> 10f63a: 31 c0 xor %eax,%eax 10f63c: f6 44 3a 04 01 testb $0x1,0x4(%edx,%edi,1) 10f641: 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 10f644: 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 ) ) { 10f647: f6 45 f0 01 testb $0x1,-0x10(%ebp) 10f64b: 75 62 jne 10f6af <_Heap_Free+0xf7> uintptr_t const prev_size = block->prev_size; 10f64d: 8b 03 mov (%ebx),%eax 10f64f: 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); 10f652: 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; 10f654: 31 ff xor %edi,%edi 10f656: 3b 5d ec cmp -0x14(%ebp),%ebx 10f659: 72 0a jb 10f665 <_Heap_Free+0xad> <== NEVER TAKEN 10f65b: 31 c0 xor %eax,%eax 10f65d: 39 5d e4 cmp %ebx,-0x1c(%ebp) 10f660: 0f 93 c0 setae %al 10f663: 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 ); 10f665: 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 ) ) { 10f667: 85 ff test %edi,%edi 10f669: 0f 84 a1 00 00 00 je 10f710 <_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) ) { 10f66f: f6 43 04 01 testb $0x1,0x4(%ebx) 10f673: 0f 84 97 00 00 00 je 10f710 <_Heap_Free+0x158> <== NEVER TAKEN _HAssert( false ); return( false ); } if ( next_is_free ) { /* coalesce both */ 10f679: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 10f67d: 74 1a je 10f699 <_Heap_Free+0xe1> uintptr_t const size = block_size + prev_size + next_block_size; 10f67f: 8b 45 e8 mov -0x18(%ebp),%eax 10f682: 8d 04 06 lea (%esi,%eax,1),%eax 10f685: 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; 10f688: 8b 7a 08 mov 0x8(%edx),%edi Heap_Block *prev = block->prev; 10f68b: 8b 52 0c mov 0xc(%edx),%edx prev->next = next; 10f68e: 89 7a 08 mov %edi,0x8(%edx) next->prev = prev; 10f691: 89 57 0c mov %edx,0xc(%edi) _Heap_Free_list_remove( next_block ); stats->free_blocks -= 1; 10f694: ff 49 38 decl 0x38(%ecx) 10f697: eb 33 jmp 10f6cc <_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; 10f699: 8b 45 f0 mov -0x10(%ebp),%eax 10f69c: 8d 04 06 lea (%esi,%eax,1),%eax prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 10f69f: 89 c7 mov %eax,%edi 10f6a1: 83 cf 01 or $0x1,%edi 10f6a4: 89 7b 04 mov %edi,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10f6a7: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = size; 10f6ab: 89 02 mov %eax,(%edx) 10f6ad: eb 56 jmp 10f705 <_Heap_Free+0x14d> } } else if ( next_is_free ) { /* coalesce next */ 10f6af: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 10f6b3: 74 24 je 10f6d9 <_Heap_Free+0x121> uintptr_t const size = block_size + next_block_size; 10f6b5: 8b 45 e8 mov -0x18(%ebp),%eax 10f6b8: 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; 10f6ba: 8b 7a 08 mov 0x8(%edx),%edi Heap_Block *prev = old_block->prev; 10f6bd: 8b 52 0c mov 0xc(%edx),%edx new_block->next = next; 10f6c0: 89 7b 08 mov %edi,0x8(%ebx) new_block->prev = prev; 10f6c3: 89 53 0c mov %edx,0xc(%ebx) next->prev = new_block; 10f6c6: 89 5f 0c mov %ebx,0xc(%edi) prev->next = new_block; 10f6c9: 89 5a 08 mov %ebx,0x8(%edx) _Heap_Free_list_replace( next_block, block ); block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 10f6cc: 89 c2 mov %eax,%edx 10f6ce: 83 ca 01 or $0x1,%edx 10f6d1: 89 53 04 mov %edx,0x4(%ebx) next_block = _Heap_Block_at( block, size ); next_block->prev_size = size; 10f6d4: 89 04 03 mov %eax,(%ebx,%eax,1) 10f6d7: eb 2c jmp 10f705 <_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; 10f6d9: 8b 41 08 mov 0x8(%ecx),%eax new_block->next = next; 10f6dc: 89 43 08 mov %eax,0x8(%ebx) new_block->prev = block_before; 10f6df: 89 4b 0c mov %ecx,0xc(%ebx) block_before->next = new_block; 10f6e2: 89 59 08 mov %ebx,0x8(%ecx) next->prev = new_block; 10f6e5: 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; 10f6e8: 89 f0 mov %esi,%eax 10f6ea: 83 c8 01 or $0x1,%eax 10f6ed: 89 43 04 mov %eax,0x4(%ebx) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 10f6f0: 83 62 04 fe andl $0xfffffffe,0x4(%edx) next_block->prev_size = block_size; 10f6f4: 89 32 mov %esi,(%edx) /* Statistics */ ++stats->free_blocks; 10f6f6: 8b 41 38 mov 0x38(%ecx),%eax 10f6f9: 40 inc %eax 10f6fa: 89 41 38 mov %eax,0x38(%ecx) if ( stats->max_free_blocks < stats->free_blocks ) { 10f6fd: 39 41 3c cmp %eax,0x3c(%ecx) 10f700: 73 03 jae 10f705 <_Heap_Free+0x14d> stats->max_free_blocks = stats->free_blocks; 10f702: 89 41 3c mov %eax,0x3c(%ecx) } } /* Statistics */ --stats->used_blocks; 10f705: ff 49 40 decl 0x40(%ecx) ++stats->frees; 10f708: ff 41 50 incl 0x50(%ecx) stats->free_size += block_size; 10f70b: 01 71 30 add %esi,0x30(%ecx) return( true ); 10f70e: b0 01 mov $0x1,%al } 10f710: 83 c4 14 add $0x14,%esp 10f713: 5b pop %ebx 10f714: 5e pop %esi 10f715: 5f pop %edi 10f716: c9 leave 10f717: c3 ret =============================================================================== 0011cb80 <_Heap_Size_of_alloc_area>: bool _Heap_Size_of_alloc_area( Heap_Control *heap, void *alloc_begin_ptr, uintptr_t *alloc_size ) { 11cb80: 55 push %ebp 11cb81: 89 e5 mov %esp,%ebp 11cb83: 57 push %edi 11cb84: 56 push %esi 11cb85: 53 push %ebx 11cb86: 8b 5d 08 mov 0x8(%ebp),%ebx 11cb89: 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); 11cb8c: 8d 4e f8 lea -0x8(%esi),%ecx 11cb8f: 89 f0 mov %esi,%eax 11cb91: 31 d2 xor %edx,%edx 11cb93: 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); 11cb96: 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 11cb98: 8b 53 20 mov 0x20(%ebx),%edx && (uintptr_t) block <= (uintptr_t) heap->last_block; 11cb9b: 31 ff xor %edi,%edi 11cb9d: 39 d1 cmp %edx,%ecx 11cb9f: 72 0a jb 11cbab <_Heap_Size_of_alloc_area+0x2b> 11cba1: 31 c0 xor %eax,%eax 11cba3: 39 4b 24 cmp %ecx,0x24(%ebx) 11cba6: 0f 93 c0 setae %al 11cba9: 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; 11cbab: 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 ) ) { 11cbad: 85 ff test %edi,%edi 11cbaf: 74 30 je 11cbe1 <_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; 11cbb1: 8b 41 04 mov 0x4(%ecx),%eax 11cbb4: 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); 11cbb7: 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; 11cbb9: 31 ff xor %edi,%edi 11cbbb: 39 d1 cmp %edx,%ecx 11cbbd: 72 0a jb 11cbc9 <_Heap_Size_of_alloc_area+0x49><== NEVER TAKEN 11cbbf: 31 c0 xor %eax,%eax 11cbc1: 39 4b 24 cmp %ecx,0x24(%ebx) 11cbc4: 0f 93 c0 setae %al 11cbc7: 89 c7 mov %eax,%edi if ( !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) ) { return false; 11cbc9: 31 c0 xor %eax,%eax } block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( 11cbcb: 85 ff test %edi,%edi 11cbcd: 74 12 je 11cbe1 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) 11cbcf: f6 41 04 01 testb $0x1,0x4(%ecx) 11cbd3: 74 0c je 11cbe1 <_Heap_Size_of_alloc_area+0x61><== NEVER TAKEN ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 11cbd5: 29 f1 sub %esi,%ecx 11cbd7: 8d 51 04 lea 0x4(%ecx),%edx 11cbda: 8b 45 10 mov 0x10(%ebp),%eax 11cbdd: 89 10 mov %edx,(%eax) return true; 11cbdf: b0 01 mov $0x1,%al } 11cbe1: 5b pop %ebx 11cbe2: 5e pop %esi 11cbe3: 5f pop %edi 11cbe4: c9 leave 11cbe5: c3 ret =============================================================================== 0010bc0e <_Heap_Walk>: bool _Heap_Walk( Heap_Control *heap, int source, bool dump ) { 10bc0e: 55 push %ebp 10bc0f: 89 e5 mov %esp,%ebp 10bc11: 57 push %edi 10bc12: 56 push %esi 10bc13: 53 push %ebx 10bc14: 83 ec 4c sub $0x4c,%esp 10bc17: 8b 75 08 mov 0x8(%ebp),%esi 10bc1a: 8b 5d 0c mov 0xc(%ebp),%ebx uintptr_t const page_size = heap->page_size; 10bc1d: 8b 46 10 mov 0x10(%esi),%eax 10bc20: 89 45 d8 mov %eax,-0x28(%ebp) uintptr_t const min_block_size = heap->min_block_size; 10bc23: 8b 4e 14 mov 0x14(%esi),%ecx 10bc26: 89 4d d4 mov %ecx,-0x2c(%ebp) Heap_Block *const first_block = heap->first_block; 10bc29: 8b 46 20 mov 0x20(%esi),%eax 10bc2c: 89 45 d0 mov %eax,-0x30(%ebp) Heap_Block *const last_block = heap->last_block; 10bc2f: 8b 4e 24 mov 0x24(%esi),%ecx 10bc32: 89 4d c8 mov %ecx,-0x38(%ebp) Heap_Block *block = first_block; Heap_Walk_printer printer = dump ? _Heap_Walk_print : _Heap_Walk_print_nothing; 10bc35: c7 45 e4 d0 bb 10 00 movl $0x10bbd0,-0x1c(%ebp) 10bc3c: 80 7d 10 00 cmpb $0x0,0x10(%ebp) 10bc40: 74 07 je 10bc49 <_Heap_Walk+0x3b> 10bc42: c7 45 e4 d5 bb 10 00 movl $0x10bbd5,-0x1c(%ebp) if ( !_System_state_Is_up( _System_state_Get() ) ) { return true; 10bc49: 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() ) ) { 10bc4b: 83 3d ec 64 12 00 03 cmpl $0x3,0x1264ec 10bc52: 0f 85 e8 02 00 00 jne 10bf40 <_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)( 10bc58: 52 push %edx 10bc59: ff 76 0c pushl 0xc(%esi) 10bc5c: ff 76 08 pushl 0x8(%esi) 10bc5f: ff 75 c8 pushl -0x38(%ebp) 10bc62: ff 75 d0 pushl -0x30(%ebp) 10bc65: ff 76 1c pushl 0x1c(%esi) 10bc68: ff 76 18 pushl 0x18(%esi) 10bc6b: ff 75 d4 pushl -0x2c(%ebp) 10bc6e: ff 75 d8 pushl -0x28(%ebp) 10bc71: 68 09 f7 11 00 push $0x11f709 10bc76: 6a 00 push $0x0 10bc78: 53 push %ebx 10bc79: 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 ) { 10bc7c: 83 c4 30 add $0x30,%esp 10bc7f: 83 7d d8 00 cmpl $0x0,-0x28(%ebp) 10bc83: 75 0b jne 10bc90 <_Heap_Walk+0x82> (*printer)( source, true, "page size is zero\n" ); 10bc85: 50 push %eax 10bc86: 68 9a f7 11 00 push $0x11f79a 10bc8b: e9 6b 02 00 00 jmp 10befb <_Heap_Walk+0x2ed> return false; } if ( !_Addresses_Is_aligned( (void *) page_size ) ) { 10bc90: f6 45 d8 03 testb $0x3,-0x28(%ebp) 10bc94: 74 0d je 10bca3 <_Heap_Walk+0x95> (*printer)( 10bc96: ff 75 d8 pushl -0x28(%ebp) 10bc99: 68 ad f7 11 00 push $0x11f7ad 10bc9e: e9 58 02 00 00 jmp 10befb <_Heap_Walk+0x2ed> RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bca3: 8b 45 d4 mov -0x2c(%ebp),%eax 10bca6: 31 d2 xor %edx,%edx 10bca8: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( !_Heap_Is_aligned( min_block_size, page_size ) ) { 10bcab: 85 d2 test %edx,%edx 10bcad: 74 0d je 10bcbc <_Heap_Walk+0xae> (*printer)( 10bcaf: ff 75 d4 pushl -0x2c(%ebp) 10bcb2: 68 cb f7 11 00 push $0x11f7cb 10bcb7: e9 3f 02 00 00 jmp 10befb <_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; 10bcbc: 8b 45 d0 mov -0x30(%ebp),%eax 10bcbf: 83 c0 08 add $0x8,%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bcc2: 31 d2 xor %edx,%edx 10bcc4: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( 10bcc7: 85 d2 test %edx,%edx 10bcc9: 74 0d je 10bcd8 <_Heap_Walk+0xca> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size ) ) { (*printer)( 10bccb: ff 75 d0 pushl -0x30(%ebp) 10bcce: 68 ef f7 11 00 push $0x11f7ef 10bcd3: e9 23 02 00 00 jmp 10befb <_Heap_Walk+0x2ed> ); return false; } if ( !_Heap_Is_prev_used( first_block ) ) { 10bcd8: 8b 45 d0 mov -0x30(%ebp),%eax 10bcdb: f6 40 04 01 testb $0x1,0x4(%eax) 10bcdf: 75 0b jne 10bcec <_Heap_Walk+0xde> (*printer)( 10bce1: 57 push %edi 10bce2: 68 20 f8 11 00 push $0x11f820 10bce7: e9 0f 02 00 00 jmp 10befb <_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; 10bcec: 8b 4d c8 mov -0x38(%ebp),%ecx 10bcef: 8b 79 04 mov 0x4(%ecx),%edi 10bcf2: 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); 10bcf5: 01 cf add %ecx,%edi ); return false; } if ( _Heap_Is_free( last_block ) ) { 10bcf7: f6 47 04 01 testb $0x1,0x4(%edi) 10bcfb: 75 0b jne 10bd08 <_Heap_Walk+0xfa> (*printer)( 10bcfd: 56 push %esi 10bcfe: 68 4e f8 11 00 push $0x11f84e 10bd03: e9 f3 01 00 00 jmp 10befb <_Heap_Walk+0x2ed> ); return false; } if ( 10bd08: 3b 7d d0 cmp -0x30(%ebp),%edi 10bd0b: 74 0b je 10bd18 <_Heap_Walk+0x10a> <== ALWAYS TAKEN _Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block ) { (*printer)( 10bd0d: 51 push %ecx <== NOT EXECUTED 10bd0e: 68 63 f8 11 00 push $0x11f863 <== NOT EXECUTED 10bd13: e9 e3 01 00 00 jmp 10befb <_Heap_Walk+0x2ed> <== NOT EXECUTED int source, Heap_Walk_printer printer, Heap_Control *heap ) { uintptr_t const page_size = heap->page_size; 10bd18: 8b 46 10 mov 0x10(%esi),%eax 10bd1b: 89 45 e0 mov %eax,-0x20(%ebp) block = next_block; } while ( block != first_block ); return true; } 10bd1e: 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 ); 10bd21: 89 75 dc mov %esi,-0x24(%ebp) 10bd24: eb 75 jmp 10bd9b <_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; 10bd26: 31 c0 xor %eax,%eax 10bd28: 39 4e 20 cmp %ecx,0x20(%esi) 10bd2b: 77 08 ja 10bd35 <_Heap_Walk+0x127> 10bd2d: 31 c0 xor %eax,%eax 10bd2f: 39 4e 24 cmp %ecx,0x24(%esi) 10bd32: 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 ) ) { 10bd35: 85 c0 test %eax,%eax 10bd37: 75 0b jne 10bd44 <_Heap_Walk+0x136> (*printer)( 10bd39: 51 push %ecx 10bd3a: 68 92 f8 11 00 push $0x11f892 10bd3f: e9 b7 01 00 00 jmp 10befb <_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; 10bd44: 8d 41 08 lea 0x8(%ecx),%eax RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bd47: 31 d2 xor %edx,%edx 10bd49: f7 75 e0 divl -0x20(%ebp) ); return false; } if ( 10bd4c: 85 d2 test %edx,%edx 10bd4e: 74 0b je 10bd5b <_Heap_Walk+0x14d> !_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size ) ) { (*printer)( 10bd50: 51 push %ecx 10bd51: 68 b2 f8 11 00 push $0x11f8b2 10bd56: e9 a0 01 00 00 jmp 10befb <_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; 10bd5b: 8b 41 04 mov 0x4(%ecx),%eax 10bd5e: 83 e0 fe and $0xfffffffe,%eax ); return false; } if ( _Heap_Is_used( free_block ) ) { 10bd61: f6 44 01 04 01 testb $0x1,0x4(%ecx,%eax,1) 10bd66: 74 0b je 10bd73 <_Heap_Walk+0x165> (*printer)( 10bd68: 51 push %ecx 10bd69: 68 e2 f8 11 00 push $0x11f8e2 10bd6e: e9 88 01 00 00 jmp 10befb <_Heap_Walk+0x2ed> ); return false; } if ( free_block->prev != prev_block ) { 10bd73: 8b 41 0c mov 0xc(%ecx),%eax 10bd76: 3b 45 dc cmp -0x24(%ebp),%eax 10bd79: 74 1a je 10bd95 <_Heap_Walk+0x187> (*printer)( 10bd7b: 83 ec 0c sub $0xc,%esp 10bd7e: 50 push %eax 10bd7f: 51 push %ecx 10bd80: 68 fe f8 11 00 push $0x11f8fe 10bd85: 6a 01 push $0x1 10bd87: 53 push %ebx 10bd88: ff 55 e4 call *-0x1c(%ebp) 10bd8b: 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; 10bd8e: 31 c0 xor %eax,%eax 10bd90: e9 ab 01 00 00 jmp 10bf40 <_Heap_Walk+0x332> return false; } prev_block = free_block; free_block = free_block->next; 10bd95: 89 4d dc mov %ecx,-0x24(%ebp) 10bd98: 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 ) { 10bd9b: 39 f1 cmp %esi,%ecx 10bd9d: 75 87 jne 10bd26 <_Heap_Walk+0x118> 10bd9f: 89 5d dc mov %ebx,-0x24(%ebp) 10bda2: eb 02 jmp 10bda6 <_Heap_Walk+0x198> block->prev_size ); } block = next_block; } while ( block != first_block ); 10bda4: 89 df mov %ebx,%edi return true; } 10bda6: 8b 4f 04 mov 0x4(%edi),%ecx 10bda9: 89 4d cc mov %ecx,-0x34(%ebp) 10bdac: 83 e1 fe and $0xfffffffe,%ecx 10bdaf: 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); 10bdb2: 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; 10bdb5: 31 c0 xor %eax,%eax 10bdb7: 39 5e 20 cmp %ebx,0x20(%esi) 10bdba: 77 08 ja 10bdc4 <_Heap_Walk+0x1b6> <== NEVER TAKEN 10bdbc: 31 c0 xor %eax,%eax 10bdbe: 39 5e 24 cmp %ebx,0x24(%esi) 10bdc1: 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 ) ) { 10bdc4: 85 c0 test %eax,%eax 10bdc6: 75 11 jne 10bdd9 <_Heap_Walk+0x1cb> 10bdc8: 89 d9 mov %ebx,%ecx 10bdca: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bdcd: 83 ec 0c sub $0xc,%esp 10bdd0: 51 push %ecx 10bdd1: 57 push %edi 10bdd2: 68 30 f9 11 00 push $0x11f930 10bdd7: eb ac jmp 10bd85 <_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; 10bdd9: 3b 7d c8 cmp -0x38(%ebp),%edi 10bddc: 0f 95 c1 setne %cl RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned( uintptr_t value, uintptr_t alignment ) { return (value % alignment) == 0; 10bddf: 8b 45 e0 mov -0x20(%ebp),%eax 10bde2: 31 d2 xor %edx,%edx 10bde4: f7 75 d8 divl -0x28(%ebp) ); return false; } if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) { 10bde7: 85 d2 test %edx,%edx 10bde9: 74 15 je 10be00 <_Heap_Walk+0x1f2> 10bdeb: 84 c9 test %cl,%cl 10bded: 74 11 je 10be00 <_Heap_Walk+0x1f2> 10bdef: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bdf2: 83 ec 0c sub $0xc,%esp 10bdf5: ff 75 e0 pushl -0x20(%ebp) 10bdf8: 57 push %edi 10bdf9: 68 5d f9 11 00 push $0x11f95d 10bdfe: eb 85 jmp 10bd85 <_Heap_Walk+0x177> ); return false; } if ( block_size < min_block_size && is_not_last_block ) { 10be00: 8b 45 d4 mov -0x2c(%ebp),%eax 10be03: 39 45 e0 cmp %eax,-0x20(%ebp) 10be06: 73 18 jae 10be20 <_Heap_Walk+0x212> 10be08: 84 c9 test %cl,%cl 10be0a: 74 14 je 10be20 <_Heap_Walk+0x212> <== NEVER TAKEN 10be0c: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10be0f: 52 push %edx 10be10: 52 push %edx 10be11: 50 push %eax 10be12: ff 75 e0 pushl -0x20(%ebp) 10be15: 57 push %edi 10be16: 68 8b f9 11 00 push $0x11f98b 10be1b: e9 65 ff ff ff jmp 10bd85 <_Heap_Walk+0x177> ); return false; } if ( next_block_begin <= block_begin && is_not_last_block ) { 10be20: 39 fb cmp %edi,%ebx 10be22: 77 18 ja 10be3c <_Heap_Walk+0x22e> 10be24: 84 c9 test %cl,%cl 10be26: 74 14 je 10be3c <_Heap_Walk+0x22e> 10be28: 89 d9 mov %ebx,%ecx 10be2a: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10be2d: 83 ec 0c sub $0xc,%esp 10be30: 51 push %ecx 10be31: 57 push %edi 10be32: 68 b6 f9 11 00 push $0x11f9b6 10be37: e9 49 ff ff ff jmp 10bd85 <_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; 10be3c: 8b 4d cc mov -0x34(%ebp),%ecx 10be3f: 83 e1 01 and $0x1,%ecx 10be42: 89 4d c4 mov %ecx,-0x3c(%ebp) ); return false; } if ( !_Heap_Is_prev_used( next_block ) ) { 10be45: f6 43 04 01 testb $0x1,0x4(%ebx) 10be49: 0f 85 ba 00 00 00 jne 10bf09 <_Heap_Walk+0x2fb> block = next_block; } while ( block != first_block ); return true; } 10be4f: 8b 46 08 mov 0x8(%esi),%eax 10be52: 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 ? 10be55: 8b 4f 08 mov 0x8(%edi),%ecx 10be58: 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)( 10be5b: ba d6 f6 11 00 mov $0x11f6d6,%edx 10be60: 3b 4e 0c cmp 0xc(%esi),%ecx 10be63: 74 0e je 10be73 <_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)" : "") 10be65: ba 0d f6 11 00 mov $0x11f60d,%edx 10be6a: 39 f1 cmp %esi,%ecx 10be6c: 75 05 jne 10be73 <_Heap_Walk+0x265> 10be6e: ba e5 f6 11 00 mov $0x11f6e5,%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 ? 10be73: 8b 47 0c mov 0xc(%edi),%eax 10be76: 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)( 10be79: b8 ef f6 11 00 mov $0x11f6ef,%eax 10be7e: 8b 4d c0 mov -0x40(%ebp),%ecx 10be81: 39 4d cc cmp %ecx,-0x34(%ebp) 10be84: 74 0f je 10be95 <_Heap_Walk+0x287> block, block_size, block->prev, block->prev == first_free_block ? " (= first free)" : (block->prev == free_list_head ? " (= head)" : ""), 10be86: b8 0d f6 11 00 mov $0x11f60d,%eax 10be8b: 39 75 cc cmp %esi,-0x34(%ebp) 10be8e: 75 05 jne 10be95 <_Heap_Walk+0x287> 10be90: b8 ff f6 11 00 mov $0x11f6ff,%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)( 10be95: 83 ec 0c sub $0xc,%esp 10be98: 52 push %edx 10be99: ff 75 b4 pushl -0x4c(%ebp) 10be9c: 50 push %eax 10be9d: ff 75 cc pushl -0x34(%ebp) 10bea0: ff 75 e0 pushl -0x20(%ebp) 10bea3: 57 push %edi 10bea4: 68 ea f9 11 00 push $0x11f9ea 10bea9: 6a 00 push $0x0 10beab: ff 75 dc pushl -0x24(%ebp) 10beae: 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 ) { 10beb1: 8b 03 mov (%ebx),%eax 10beb3: 83 c4 30 add $0x30,%esp 10beb6: 39 45 e0 cmp %eax,-0x20(%ebp) 10beb9: 74 16 je 10bed1 <_Heap_Walk+0x2c3> 10bebb: 89 d9 mov %ebx,%ecx 10bebd: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10bec0: 56 push %esi 10bec1: 51 push %ecx 10bec2: 50 push %eax 10bec3: ff 75 e0 pushl -0x20(%ebp) 10bec6: 57 push %edi 10bec7: 68 1f fa 11 00 push $0x11fa1f 10becc: e9 b4 fe ff ff jmp 10bd85 <_Heap_Walk+0x177> ); return false; } if ( !prev_used ) { 10bed1: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 10bed5: 75 0b jne 10bee2 <_Heap_Walk+0x2d4> 10bed7: 8b 5d dc mov -0x24(%ebp),%ebx (*printer)( 10beda: 57 push %edi 10bedb: 68 58 fa 11 00 push $0x11fa58 10bee0: eb 19 jmp 10befb <_Heap_Walk+0x2ed> block = next_block; } while ( block != first_block ); return true; } 10bee2: 8b 46 08 mov 0x8(%esi),%eax 10bee5: eb 07 jmp 10beee <_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 ) { 10bee7: 39 f8 cmp %edi,%eax 10bee9: 74 4a je 10bf35 <_Heap_Walk+0x327> return true; } free_block = free_block->next; 10beeb: 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 ) { 10beee: 39 f0 cmp %esi,%eax 10bef0: 75 f5 jne 10bee7 <_Heap_Walk+0x2d9> 10bef2: 8b 5d dc mov -0x24(%ebp),%ebx return false; } if ( !_Heap_Walk_is_in_free_list( heap, block ) ) { (*printer)( 10bef5: 57 push %edi 10bef6: 68 c3 fa 11 00 push $0x11fac3 10befb: 6a 01 push $0x1 10befd: 53 push %ebx 10befe: ff 55 e4 call *-0x1c(%ebp) 10bf01: 83 c4 10 add $0x10,%esp 10bf04: e9 85 fe ff ff jmp 10bd8e <_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) { 10bf09: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 10bf0d: 74 0e je 10bf1d <_Heap_Walk+0x30f> (*printer)( 10bf0f: 83 ec 0c sub $0xc,%esp 10bf12: ff 75 e0 pushl -0x20(%ebp) 10bf15: 57 push %edi 10bf16: 68 87 fa 11 00 push $0x11fa87 10bf1b: eb 0d jmp 10bf2a <_Heap_Walk+0x31c> "block 0x%08x: size %u\n", block, block_size ); } else { (*printer)( 10bf1d: 51 push %ecx 10bf1e: 51 push %ecx 10bf1f: ff 37 pushl (%edi) 10bf21: ff 75 e0 pushl -0x20(%ebp) 10bf24: 57 push %edi 10bf25: 68 9e fa 11 00 push $0x11fa9e 10bf2a: 6a 00 push $0x0 10bf2c: ff 75 dc pushl -0x24(%ebp) 10bf2f: ff 55 e4 call *-0x1c(%ebp) 10bf32: 83 c4 20 add $0x20,%esp block->prev_size ); } block = next_block; } while ( block != first_block ); 10bf35: 3b 5d d0 cmp -0x30(%ebp),%ebx 10bf38: 0f 85 66 fe ff ff jne 10bda4 <_Heap_Walk+0x196> return true; 10bf3e: b0 01 mov $0x1,%al } 10bf40: 8d 65 f4 lea -0xc(%ebp),%esp 10bf43: 5b pop %ebx 10bf44: 5e pop %esi 10bf45: 5f pop %edi 10bf46: c9 leave 10bf47: c3 ret =============================================================================== 0010b230 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10b230: 55 push %ebp 10b231: 89 e5 mov %esp,%ebp 10b233: 53 push %ebx 10b234: 83 ec 08 sub $0x8,%esp 10b237: 8b 45 08 mov 0x8(%ebp),%eax 10b23a: 8b 55 0c mov 0xc(%ebp),%edx 10b23d: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10b240: a3 7c 43 12 00 mov %eax,0x12437c _Internal_errors_What_happened.is_internal = is_internal; 10b245: 88 15 80 43 12 00 mov %dl,0x124380 _Internal_errors_What_happened.the_error = the_error; 10b24b: 89 1d 84 43 12 00 mov %ebx,0x124384 _User_extensions_Fatal( the_source, is_internal, the_error ); 10b251: 53 push %ebx 10b252: 0f b6 d2 movzbl %dl,%edx 10b255: 52 push %edx 10b256: 50 push %eax 10b257: e8 23 19 00 00 call 10cb7f <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 10b25c: c7 05 64 44 12 00 05 movl $0x5,0x124464 <== NOT EXECUTED 10b263: 00 00 00 _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10b266: fa cli <== NOT EXECUTED 10b267: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b269: f4 hlt <== NOT EXECUTED 10b26a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b26d: eb fe jmp 10b26d <_Internal_error_Occurred+0x3d><== NOT EXECUTED =============================================================================== 0010b2c0 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10b2c0: 55 push %ebp 10b2c1: 89 e5 mov %esp,%ebp 10b2c3: 56 push %esi 10b2c4: 53 push %ebx 10b2c5: 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; 10b2c8: 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 ) 10b2ca: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 10b2ce: 74 53 je 10b323 <_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 ); 10b2d0: 8d 73 20 lea 0x20(%ebx),%esi 10b2d3: 83 ec 0c sub $0xc,%esp 10b2d6: 56 push %esi 10b2d7: e8 30 f7 ff ff call 10aa0c <_Chain_Get> 10b2dc: 89 c1 mov %eax,%ecx if ( information->auto_extend ) { 10b2de: 83 c4 10 add $0x10,%esp 10b2e1: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10b2e5: 74 3c je 10b323 <_Objects_Allocate+0x63> /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10b2e7: 85 c0 test %eax,%eax 10b2e9: 75 1a jne 10b305 <_Objects_Allocate+0x45> _Objects_Extend_information( information ); 10b2eb: 83 ec 0c sub $0xc,%esp 10b2ee: 53 push %ebx 10b2ef: e8 60 00 00 00 call 10b354 <_Objects_Extend_information> the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10b2f4: 89 34 24 mov %esi,(%esp) 10b2f7: e8 10 f7 ff ff call 10aa0c <_Chain_Get> 10b2fc: 89 c1 mov %eax,%ecx } if ( the_object ) { 10b2fe: 83 c4 10 add $0x10,%esp 10b301: 85 c0 test %eax,%eax 10b303: 74 1e je 10b323 <_Objects_Allocate+0x63> uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 10b305: 0f b7 41 08 movzwl 0x8(%ecx),%eax 10b309: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10b30d: 29 d0 sub %edx,%eax _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; 10b30f: 0f b7 73 14 movzwl 0x14(%ebx),%esi 10b313: 31 d2 xor %edx,%edx 10b315: f7 f6 div %esi information->inactive_per_block[ block ]--; 10b317: c1 e0 02 shl $0x2,%eax 10b31a: 03 43 30 add 0x30(%ebx),%eax 10b31d: ff 08 decl (%eax) information->inactive--; 10b31f: 66 ff 4b 2c decw 0x2c(%ebx) ); } #endif return the_object; } 10b323: 89 c8 mov %ecx,%eax 10b325: 8d 65 f8 lea -0x8(%ebp),%esp 10b328: 5b pop %ebx 10b329: 5e pop %esi 10b32a: c9 leave 10b32b: c3 ret =============================================================================== 0010b648 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 10b648: 55 push %ebp 10b649: 89 e5 mov %esp,%ebp 10b64b: 57 push %edi 10b64c: 56 push %esi 10b64d: 53 push %ebx 10b64e: 83 ec 0c sub $0xc,%esp 10b651: 8b 75 08 mov 0x8(%ebp),%esi 10b654: 8b 7d 0c mov 0xc(%ebp),%edi Objects_Information *info; int the_class_api_maximum; if ( !the_class ) return NULL; 10b657: 31 db xor %ebx,%ebx ) { Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 10b659: 66 85 ff test %di,%di 10b65c: 74 37 je 10b695 <_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 ); 10b65e: 83 ec 0c sub $0xc,%esp 10b661: 56 push %esi 10b662: e8 b1 40 00 00 call 10f718 <_Objects_API_maximum_class> if ( the_class_api_maximum == 0 ) 10b667: 83 c4 10 add $0x10,%esp 10b66a: 85 c0 test %eax,%eax 10b66c: 74 27 je 10b695 <_Objects_Get_information+0x4d> return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 10b66e: 0f b7 ff movzwl %di,%edi 10b671: 39 c7 cmp %eax,%edi 10b673: 77 20 ja 10b695 <_Objects_Get_information+0x4d> return NULL; if ( !_Objects_Information_table[ the_api ] ) 10b675: 8b 04 b5 bc 42 12 00 mov 0x1242bc(,%esi,4),%eax 10b67c: 85 c0 test %eax,%eax 10b67e: 74 15 je 10b695 <_Objects_Get_information+0x4d><== NEVER TAKEN return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10b680: 8b 1c b8 mov (%eax,%edi,4),%ebx if ( !info ) 10b683: 85 db test %ebx,%ebx 10b685: 74 0e je 10b695 <_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; 10b687: 31 c0 xor %eax,%eax 10b689: 66 83 7b 10 00 cmpw $0x0,0x10(%ebx) 10b68e: 0f 95 c0 setne %al 10b691: f7 d8 neg %eax 10b693: 21 c3 and %eax,%ebx #endif return info; } 10b695: 89 d8 mov %ebx,%eax 10b697: 8d 65 f4 lea -0xc(%ebp),%esp 10b69a: 5b pop %ebx 10b69b: 5e pop %esi 10b69c: 5f pop %edi 10b69d: c9 leave 10b69e: c3 ret =============================================================================== 00118abc <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 118abc: 55 push %ebp 118abd: 89 e5 mov %esp,%ebp 118abf: 53 push %ebx 118ac0: 8b 55 08 mov 0x8(%ebp),%edx 118ac3: 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; 118ac6: b8 01 00 00 00 mov $0x1,%eax 118acb: 2b 42 08 sub 0x8(%edx),%eax 118ace: 03 45 0c add 0xc(%ebp),%eax if ( information->maximum >= index ) { 118ad1: 0f b7 5a 10 movzwl 0x10(%edx),%ebx 118ad5: 39 c3 cmp %eax,%ebx 118ad7: 72 12 jb 118aeb <_Objects_Get_no_protection+0x2f> if ( (the_object = information->local_table[ index ]) != NULL ) { 118ad9: 8b 52 1c mov 0x1c(%edx),%edx 118adc: 8b 04 82 mov (%edx,%eax,4),%eax 118adf: 85 c0 test %eax,%eax 118ae1: 74 08 je 118aeb <_Objects_Get_no_protection+0x2f><== NEVER TAKEN *location = OBJECTS_LOCAL; 118ae3: c7 01 00 00 00 00 movl $0x0,(%ecx) return the_object; 118ae9: eb 08 jmp 118af3 <_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; 118aeb: c7 01 01 00 00 00 movl $0x1,(%ecx) return NULL; 118af1: 31 c0 xor %eax,%eax } 118af3: 5b pop %ebx 118af4: c9 leave 118af5: c3 ret =============================================================================== 0010c874 <_Objects_Id_to_name>: */ Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10c874: 55 push %ebp 10c875: 89 e5 mov %esp,%ebp 10c877: 53 push %ebx 10c878: 83 ec 14 sub $0x14,%esp /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10c87b: 8b 45 08 mov 0x8(%ebp),%eax 10c87e: 85 c0 test %eax,%eax 10c880: 75 08 jne 10c88a <_Objects_Id_to_name+0x16> 10c882: a1 80 78 12 00 mov 0x127880,%eax 10c887: 8b 40 08 mov 0x8(%eax),%eax 10c88a: 89 c2 mov %eax,%edx 10c88c: c1 ea 18 shr $0x18,%edx 10c88f: 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 ) 10c892: 8d 4a ff lea -0x1(%edx),%ecx the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; 10c895: bb 03 00 00 00 mov $0x3,%ebx 10c89a: 83 f9 02 cmp $0x2,%ecx 10c89d: 77 36 ja 10c8d5 <_Objects_Id_to_name+0x61> 10c89f: eb 3b jmp 10c8dc <_Objects_Id_to_name+0x68> */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10c8a1: 89 c1 mov %eax,%ecx 10c8a3: 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 ]; 10c8a6: 8b 14 8a mov (%edx,%ecx,4),%edx if ( !information ) 10c8a9: 85 d2 test %edx,%edx 10c8ab: 74 28 je 10c8d5 <_Objects_Id_to_name+0x61><== NEVER TAKEN return OBJECTS_INVALID_ID; #if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES) if ( information->is_string ) 10c8ad: 80 7a 38 00 cmpb $0x0,0x38(%edx) 10c8b1: 75 22 jne 10c8d5 <_Objects_Id_to_name+0x61><== NEVER TAKEN return OBJECTS_INVALID_ID; #endif the_object = _Objects_Get( information, tmpId, &ignored_location ); 10c8b3: 51 push %ecx 10c8b4: 8d 4d f4 lea -0xc(%ebp),%ecx 10c8b7: 51 push %ecx 10c8b8: 50 push %eax 10c8b9: 52 push %edx 10c8ba: e8 5d ff ff ff call 10c81c <_Objects_Get> if ( !the_object ) 10c8bf: 83 c4 10 add $0x10,%esp 10c8c2: 85 c0 test %eax,%eax 10c8c4: 74 0f je 10c8d5 <_Objects_Id_to_name+0x61> return OBJECTS_INVALID_ID; *name = the_object->name; 10c8c6: 8b 50 0c mov 0xc(%eax),%edx 10c8c9: 8b 45 0c mov 0xc(%ebp),%eax 10c8cc: 89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10c8ce: e8 9f 07 00 00 call 10d072 <_Thread_Enable_dispatch> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10c8d3: 31 db xor %ebx,%ebx } 10c8d5: 89 d8 mov %ebx,%eax 10c8d7: 8b 5d fc mov -0x4(%ebp),%ebx 10c8da: c9 leave 10c8db: 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 ] ) 10c8dc: 8b 14 95 08 73 12 00 mov 0x127308(,%edx,4),%edx 10c8e3: 85 d2 test %edx,%edx 10c8e5: 75 ba jne 10c8a1 <_Objects_Id_to_name+0x2d> 10c8e7: eb ec jmp 10c8d5 <_Objects_Id_to_name+0x61> =============================================================================== 0010e2b8 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 10e2b8: 55 push %ebp 10e2b9: 89 e5 mov %esp,%ebp 10e2bb: 57 push %edi 10e2bc: 56 push %esi 10e2bd: 53 push %ebx 10e2be: 83 ec 30 sub $0x30,%esp 10e2c1: 8b 75 08 mov 0x8(%ebp),%esi 10e2c4: 8b 5d 14 mov 0x14(%ebp),%ebx 10e2c7: 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 ); 10e2ca: 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( 10e2cd: 50 push %eax 10e2ce: 56 push %esi 10e2cf: 68 7c d9 12 00 push $0x12d97c 10e2d4: 88 55 d4 mov %dl,-0x2c(%ebp) 10e2d7: e8 f0 2a 00 00 call 110dcc <_Objects_Get> switch ( location ) { 10e2dc: 83 c4 10 add $0x10,%esp 10e2df: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10e2e3: 8a 55 d4 mov -0x2c(%ebp),%dl 10e2e6: 0f 85 aa 00 00 00 jne 10e396 <_POSIX_Message_queue_Receive_support+0xde> case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 10e2ec: 8b 78 14 mov 0x14(%eax),%edi 10e2ef: 89 f9 mov %edi,%ecx 10e2f1: 83 e1 03 and $0x3,%ecx 10e2f4: 49 dec %ecx 10e2f5: 75 0a jne 10e301 <_POSIX_Message_queue_Receive_support+0x49> _Thread_Enable_dispatch(); 10e2f7: e8 22 33 00 00 call 11161e <_Thread_Enable_dispatch> 10e2fc: e9 95 00 00 00 jmp 10e396 <_POSIX_Message_queue_Receive_support+0xde> rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10e301: 8b 40 10 mov 0x10(%eax),%eax if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 10e304: 8b 48 68 mov 0x68(%eax),%ecx 10e307: 39 4d 10 cmp %ecx,0x10(%ebp) 10e30a: 73 15 jae 10e321 <_POSIX_Message_queue_Receive_support+0x69> _Thread_Enable_dispatch(); 10e30c: e8 0d 33 00 00 call 11161e <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EMSGSIZE ); 10e311: e8 be 8a 00 00 call 116dd4 <__errno> 10e316: c7 00 7a 00 00 00 movl $0x7a,(%eax) 10e31c: e9 80 00 00 00 jmp 10e3a1 <_POSIX_Message_queue_Receive_support+0xe9> /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 10e321: 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 ) 10e328: 31 c9 xor %ecx,%ecx 10e32a: 84 d2 test %dl,%dl 10e32c: 74 09 je 10e337 <_POSIX_Message_queue_Receive_support+0x7f><== NEVER TAKEN do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true; 10e32e: 81 e7 00 40 00 00 and $0x4000,%edi 10e334: 0f 94 c1 sete %cl do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 10e337: 52 push %edx 10e338: 52 push %edx 10e339: ff 75 1c pushl 0x1c(%ebp) 10e33c: 0f b6 c9 movzbl %cl,%ecx 10e33f: 51 push %ecx 10e340: 8d 55 e0 lea -0x20(%ebp),%edx 10e343: 52 push %edx 10e344: ff 75 0c pushl 0xc(%ebp) 10e347: 56 push %esi 10e348: 83 c0 1c add $0x1c,%eax 10e34b: 50 push %eax 10e34c: e8 73 1c 00 00 call 10ffc4 <_CORE_message_queue_Seize> &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 10e351: 83 c4 20 add $0x20,%esp 10e354: e8 c5 32 00 00 call 11161e <_Thread_Enable_dispatch> *msg_prio = _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); 10e359: a1 f4 d9 12 00 mov 0x12d9f4,%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); 10e35e: 8b 50 24 mov 0x24(%eax),%edx 10e361: c1 fa 1f sar $0x1f,%edx 10e364: 8b 48 24 mov 0x24(%eax),%ecx 10e367: 31 d1 xor %edx,%ecx 10e369: 89 0b mov %ecx,(%ebx) 10e36b: 29 13 sub %edx,(%ebx) if ( !_Thread_Executing->Wait.return_code ) 10e36d: 83 78 34 00 cmpl $0x0,0x34(%eax) 10e371: 75 05 jne 10e378 <_POSIX_Message_queue_Receive_support+0xc0> return length_out; 10e373: 8b 45 e0 mov -0x20(%ebp),%eax 10e376: eb 2c jmp 10e3a4 <_POSIX_Message_queue_Receive_support+0xec> rtems_set_errno_and_return_minus_one( 10e378: e8 57 8a 00 00 call 116dd4 <__errno> 10e37d: 89 c3 mov %eax,%ebx 10e37f: 83 ec 0c sub $0xc,%esp 10e382: a1 f4 d9 12 00 mov 0x12d9f4,%eax 10e387: ff 70 34 pushl 0x34(%eax) 10e38a: e8 ed 01 00 00 call 10e57c <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10e38f: 89 03 mov %eax,(%ebx) 10e391: 83 c4 10 add $0x10,%esp 10e394: eb 0b jmp 10e3a1 <_POSIX_Message_queue_Receive_support+0xe9> #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10e396: e8 39 8a 00 00 call 116dd4 <__errno> 10e39b: c7 00 09 00 00 00 movl $0x9,(%eax) 10e3a1: 83 c8 ff or $0xffffffff,%eax } 10e3a4: 8d 65 f4 lea -0xc(%ebp),%esp 10e3a7: 5b pop %ebx 10e3a8: 5e pop %esi 10e3a9: 5f pop %edi 10e3aa: c9 leave 10e3ab: c3 ret =============================================================================== 0010e86c <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>: #include void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( Thread_Control *the_thread ) { 10e86c: 55 push %ebp 10e86d: 89 e5 mov %esp,%ebp 10e86f: 83 ec 08 sub $0x8,%esp 10e872: 8b 55 08 mov 0x8(%ebp),%edx POSIX_API_Control *thread_support; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10e875: 8b 82 f8 00 00 00 mov 0xf8(%edx),%eax if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10e87b: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax) 10e882: 75 2c jne 10e8b0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44><== NEVER TAKEN 10e884: 83 b8 dc 00 00 00 01 cmpl $0x1,0xdc(%eax) 10e88b: 75 23 jne 10e8b0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x44> thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && 10e88d: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax) 10e894: 74 1a je 10e8b0 <_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; 10e896: a1 d4 52 12 00 mov 0x1252d4,%eax 10e89b: 48 dec %eax 10e89c: a3 d4 52 12 00 mov %eax,0x1252d4 thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 10e8a1: 50 push %eax 10e8a2: 50 push %eax 10e8a3: 6a ff push $0xffffffff 10e8a5: 52 push %edx 10e8a6: e8 51 08 00 00 call 10f0fc <_POSIX_Thread_Exit> 10e8ab: 83 c4 10 add $0x10,%esp } else _Thread_Enable_dispatch(); } 10e8ae: c9 leave 10e8af: c3 ret 10e8b0: 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(); 10e8b1: e9 c0 d9 ff ff jmp 10c276 <_Thread_Enable_dispatch> =============================================================================== 0010faf0 <_POSIX_Thread_Translate_sched_param>: int policy, struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) { 10faf0: 55 push %ebp 10faf1: 89 e5 mov %esp,%ebp 10faf3: 57 push %edi 10faf4: 56 push %esi 10faf5: 53 push %ebx 10faf6: 83 ec 28 sub $0x28,%esp 10faf9: 8b 55 08 mov 0x8(%ebp),%edx 10fafc: 8b 5d 0c mov 0xc(%ebp),%ebx 10faff: 8b 7d 10 mov 0x10(%ebp),%edi if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 10fb02: ff 33 pushl (%ebx) 10fb04: 89 55 e0 mov %edx,-0x20(%ebp) 10fb07: e8 c4 ff ff ff call 10fad0 <_POSIX_Priority_Is_valid> 10fb0c: 83 c4 10 add $0x10,%esp return EINVAL; 10fb0f: 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 ) ) 10fb14: 84 c0 test %al,%al 10fb16: 8b 55 e0 mov -0x20(%ebp),%edx 10fb19: 0f 84 a4 00 00 00 je 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3><== NEVER TAKEN return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 10fb1f: c7 07 00 00 00 00 movl $0x0,(%edi) *budget_callout = NULL; 10fb25: 8b 45 14 mov 0x14(%ebp),%eax 10fb28: c7 00 00 00 00 00 movl $0x0,(%eax) if ( policy == SCHED_OTHER ) { 10fb2e: 85 d2 test %edx,%edx 10fb30: 75 0b jne 10fb3d <_POSIX_Thread_Translate_sched_param+0x4d> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 10fb32: c7 07 01 00 00 00 movl $0x1,(%edi) 10fb38: e9 83 00 00 00 jmp 10fbc0 <_POSIX_Thread_Translate_sched_param+0xd0> return 0; } if ( policy == SCHED_FIFO ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; 10fb3d: 31 f6 xor %esi,%esi if ( policy == SCHED_OTHER ) { *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; return 0; } if ( policy == SCHED_FIFO ) { 10fb3f: 83 fa 01 cmp $0x1,%edx 10fb42: 74 7f je 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; return 0; } if ( policy == SCHED_RR ) { 10fb44: 83 fa 02 cmp $0x2,%edx 10fb47: 75 08 jne 10fb51 <_POSIX_Thread_Translate_sched_param+0x61> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE; 10fb49: c7 07 02 00 00 00 movl $0x2,(%edi) return 0; 10fb4f: eb 72 jmp 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3> *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; *budget_callout = _POSIX_Threads_Sporadic_budget_callout; return 0; } return EINVAL; 10fb51: 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 ) { 10fb56: 83 fa 04 cmp $0x4,%edx 10fb59: 75 68 jne 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3> if ( (param->sched_ss_repl_period.tv_sec == 0) && 10fb5b: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10fb5f: 75 06 jne 10fb67 <_POSIX_Thread_Translate_sched_param+0x77> 10fb61: 83 7b 0c 00 cmpl $0x0,0xc(%ebx) 10fb65: 74 5c je 10fbc3 <_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) && 10fb67: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10fb6b: 75 0b jne 10fb78 <_POSIX_Thread_Translate_sched_param+0x88> (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; 10fb6d: 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) && 10fb72: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10fb76: 74 4b je 10fbc3 <_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 ) < 10fb78: 83 ec 0c sub $0xc,%esp 10fb7b: 8d 43 08 lea 0x8(%ebx),%eax 10fb7e: 50 push %eax 10fb7f: e8 14 de ff ff call 10d998 <_Timespec_To_ticks> 10fb84: 89 45 e4 mov %eax,-0x1c(%ebp) _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) 10fb87: 8d 43 10 lea 0x10(%ebx),%eax 10fb8a: 89 04 24 mov %eax,(%esp) 10fb8d: e8 06 de ff ff call 10d998 <_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 ) < 10fb92: 83 c4 10 add $0x10,%esp _Timespec_To_ticks( ¶m->sched_ss_init_budget ) ) return EINVAL; 10fb95: 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 ) < 10fb9a: 39 45 e4 cmp %eax,-0x1c(%ebp) 10fb9d: 72 24 jb 10fbc3 <_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 ) ) 10fb9f: 83 ec 0c sub $0xc,%esp 10fba2: ff 73 04 pushl 0x4(%ebx) 10fba5: e8 26 ff ff ff call 10fad0 <_POSIX_Priority_Is_valid> 10fbaa: 83 c4 10 add $0x10,%esp 10fbad: 84 c0 test %al,%al 10fbaf: 74 12 je 10fbc3 <_POSIX_Thread_Translate_sched_param+0xd3> return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; 10fbb1: c7 07 03 00 00 00 movl $0x3,(%edi) *budget_callout = _POSIX_Threads_Sporadic_budget_callout; 10fbb7: 8b 45 14 mov 0x14(%ebp),%eax 10fbba: c7 00 e9 a7 10 00 movl $0x10a7e9,(%eax) return 0; 10fbc0: 66 31 f6 xor %si,%si } return EINVAL; } 10fbc3: 89 f0 mov %esi,%eax 10fbc5: 8d 65 f4 lea -0xc(%ebp),%esp 10fbc8: 5b pop %ebx 10fbc9: 5e pop %esi 10fbca: 5f pop %edi 10fbcb: c9 leave 10fbcc: c3 ret =============================================================================== 0010a4ec <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body(void) { 10a4ec: 55 push %ebp 10a4ed: 89 e5 mov %esp,%ebp 10a4ef: 57 push %edi 10a4f0: 56 push %esi 10a4f1: 53 push %ebx 10a4f2: 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; 10a4f5: 8b 3d 10 12 12 00 mov 0x121210,%edi maximum = Configuration_POSIX_API.number_of_initialization_threads; 10a4fb: 8b 15 0c 12 12 00 mov 0x12120c,%edx if ( !user_threads || maximum == 0 ) 10a501: 85 d2 test %edx,%edx 10a503: 74 54 je 10a559 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN 10a505: 85 ff test %edi,%edi 10a507: 74 50 je 10a559 <_POSIX_Threads_Initialize_user_threads_body+0x6d><== NEVER TAKEN 10a509: 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 ); 10a50b: 8d 75 a4 lea -0x5c(%ebp),%esi 10a50e: 83 ec 0c sub $0xc,%esp 10a511: 56 push %esi 10a512: 89 55 94 mov %edx,-0x6c(%ebp) 10a515: e8 b6 56 00 00 call 10fbd0 (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 10a51a: 5a pop %edx 10a51b: 59 pop %ecx 10a51c: 6a 02 push $0x2 10a51e: 56 push %esi 10a51f: e8 d4 56 00 00 call 10fbf8 (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size); 10a524: 59 pop %ecx 10a525: 58 pop %eax 10a526: ff 74 df 04 pushl 0x4(%edi,%ebx,8) 10a52a: 56 push %esi 10a52b: e8 f4 56 00 00 call 10fc24 status = pthread_create( 10a530: 6a 00 push $0x0 10a532: ff 34 df pushl (%edi,%ebx,8) 10a535: 56 push %esi 10a536: 8d 45 e4 lea -0x1c(%ebp),%eax 10a539: 50 push %eax 10a53a: e8 e5 fc ff ff call 10a224 &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) 10a53f: 83 c4 20 add $0x20,%esp 10a542: 85 c0 test %eax,%eax 10a544: 8b 55 94 mov -0x6c(%ebp),%edx 10a547: 74 0b je 10a554 <_POSIX_Threads_Initialize_user_threads_body+0x68> _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); 10a549: 52 push %edx 10a54a: 50 push %eax 10a54b: 6a 01 push $0x1 10a54d: 6a 02 push $0x2 10a54f: e8 e4 1b 00 00 call 10c138 <_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++ ) { 10a554: 43 inc %ebx 10a555: 39 d3 cmp %edx,%ebx 10a557: 72 b5 jb 10a50e <_POSIX_Threads_Initialize_user_threads_body+0x22><== NEVER TAKEN NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status ); } } 10a559: 8d 65 f4 lea -0xc(%ebp),%esp 10a55c: 5b pop %ebx 10a55d: 5e pop %esi 10a55e: 5f pop %edi 10a55f: c9 leave 10a560: c3 ret =============================================================================== 0010ec4f <_POSIX_Threads_Sporadic_budget_TSR>: */ void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id __attribute__((unused)), void *argument ) { 10ec4f: 55 push %ebp 10ec50: 89 e5 mov %esp,%ebp 10ec52: 56 push %esi 10ec53: 53 push %ebx 10ec54: 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 ]; 10ec57: 8b b3 f8 00 00 00 mov 0xf8(%ebx),%esi /* ticks is guaranteed to be at least one */ ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget ); 10ec5d: 83 ec 0c sub $0xc,%esp 10ec60: 8d 86 98 00 00 00 lea 0x98(%esi),%eax 10ec66: 50 push %eax 10ec67: e8 94 0e 00 00 call 10fb00 <_Timespec_To_ticks> the_thread->cpu_time_budget = ticks; 10ec6c: 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); 10ec6f: 0f b6 05 f4 01 12 00 movzbl 0x1201f4,%eax 10ec76: 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; 10ec7c: 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 ) { 10ec7f: 83 c4 10 add $0x10,%esp 10ec82: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx) 10ec86: 75 12 jne 10ec9a <_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 ) { 10ec88: 39 43 14 cmp %eax,0x14(%ebx) 10ec8b: 76 0d jbe 10ec9a <_POSIX_Threads_Sporadic_budget_TSR+0x4b> _Thread_Change_priority( the_thread, new_priority, true ); 10ec8d: 52 push %edx 10ec8e: 6a 01 push $0x1 10ec90: 50 push %eax 10ec91: 53 push %ebx 10ec92: e8 a5 cd ff ff call 10ba3c <_Thread_Change_priority> 10ec97: 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 ); 10ec9a: 83 ec 0c sub $0xc,%esp 10ec9d: 8d 86 90 00 00 00 lea 0x90(%esi),%eax 10eca3: 50 push %eax 10eca4: e8 57 0e 00 00 call 10fb00 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10eca9: 89 86 b4 00 00 00 mov %eax,0xb4(%esi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10ecaf: 83 c4 10 add $0x10,%esp _Watchdog_Insert_ticks( &api->Sporadic_timer, ticks ); 10ecb2: 81 c6 a8 00 00 00 add $0xa8,%esi 10ecb8: 89 75 0c mov %esi,0xc(%ebp) 10ecbb: c7 45 08 ac 43 12 00 movl $0x1243ac,0x8(%ebp) } 10ecc2: 8d 65 f8 lea -0x8(%ebp),%esp 10ecc5: 5b pop %ebx 10ecc6: 5e pop %esi 10ecc7: c9 leave 10ecc8: e9 d3 df ff ff jmp 10cca0 <_Watchdog_Insert> =============================================================================== 0010eccd <_POSIX_Threads_Sporadic_budget_callout>: * _POSIX_Threads_Sporadic_budget_callout */ void _POSIX_Threads_Sporadic_budget_callout( Thread_Control *the_thread ) { 10eccd: 55 push %ebp 10ecce: 89 e5 mov %esp,%ebp 10ecd0: 83 ec 08 sub $0x8,%esp 10ecd3: 8b 45 08 mov 0x8(%ebp),%eax POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10ecd6: 8b 88 f8 00 00 00 mov 0xf8(%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 */ 10ecdc: c7 40 78 ff ff ff ff movl $0xffffffff,0x78(%eax) 10ece3: 0f b6 15 f4 01 12 00 movzbl 0x1201f4,%edx 10ecea: 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; 10ecf0: 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 ) { 10ecf3: 83 78 1c 00 cmpl $0x0,0x1c(%eax) 10ecf7: 75 12 jne 10ed0b <_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 ) { 10ecf9: 39 50 14 cmp %edx,0x14(%eax) 10ecfc: 73 0d jae 10ed0b <_POSIX_Threads_Sporadic_budget_callout+0x3e><== NEVER TAKEN _Thread_Change_priority( the_thread, new_priority, true ); 10ecfe: 51 push %ecx 10ecff: 6a 01 push $0x1 10ed01: 52 push %edx 10ed02: 50 push %eax 10ed03: e8 34 cd ff ff call 10ba3c <_Thread_Change_priority> 10ed08: 83 c4 10 add $0x10,%esp #if 0 printk( "lower priority\n" ); #endif } } } 10ed0b: c9 leave 10ed0c: c3 ret =============================================================================== 0010a2ac <_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) { 10a2ac: 55 push %ebp 10a2ad: 89 e5 mov %esp,%ebp 10a2af: 53 push %ebx 10a2b0: 83 ec 04 sub $0x4,%esp 10a2b3: 8b 5d 0c mov 0xc(%ebp),%ebx bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 10a2b6: ff 43 68 incl 0x68(%ebx) /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10a2b9: 83 7b 54 00 cmpl $0x0,0x54(%ebx) 10a2bd: 75 06 jne 10a2c5 <_POSIX_Timer_TSR+0x19> 10a2bf: 83 7b 58 00 cmpl $0x0,0x58(%ebx) 10a2c3: 74 34 je 10a2f9 <_POSIX_Timer_TSR+0x4d> <== NEVER TAKEN ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { activated = _POSIX_Timer_Insert_helper( 10a2c5: 83 ec 0c sub $0xc,%esp 10a2c8: 53 push %ebx 10a2c9: 68 ac a2 10 00 push $0x10a2ac 10a2ce: ff 73 08 pushl 0x8(%ebx) 10a2d1: ff 73 64 pushl 0x64(%ebx) 10a2d4: 8d 43 10 lea 0x10(%ebx),%eax 10a2d7: 50 push %eax 10a2d8: e8 d3 55 00 00 call 10f8b0 <_POSIX_Timer_Insert_helper> ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 10a2dd: 83 c4 20 add $0x20,%esp 10a2e0: 84 c0 test %al,%al 10a2e2: 74 30 je 10a314 <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 10a2e4: 83 ec 0c sub $0xc,%esp 10a2e7: 8d 43 6c lea 0x6c(%ebx),%eax 10a2ea: 50 push %eax 10a2eb: e8 50 14 00 00 call 10b740 <_TOD_Get> /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a2f0: c6 43 3c 03 movb $0x3,0x3c(%ebx) 10a2f4: 83 c4 10 add $0x10,%esp 10a2f7: eb 04 jmp 10a2fd <_POSIX_Timer_TSR+0x51> } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a2f9: 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 ) ) { 10a2fd: 50 push %eax 10a2fe: 50 push %eax 10a2ff: ff 73 44 pushl 0x44(%ebx) 10a302: ff 73 38 pushl 0x38(%ebx) 10a305: e8 7a 51 00 00 call 10f484 } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 10a30a: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) 10a311: 83 c4 10 add $0x10,%esp } 10a314: 8b 5d fc mov -0x4(%ebp),%ebx 10a317: c9 leave 10a318: c3 ret =============================================================================== 00110ac8 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) { 110ac8: 55 push %ebp 110ac9: 89 e5 mov %esp,%ebp 110acb: 57 push %edi 110acc: 56 push %esi 110acd: 53 push %ebx 110ace: 83 ec 68 sub $0x68,%esp 110ad1: 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, 110ad4: 6a 01 push $0x1 110ad6: 0f b6 45 10 movzbl 0x10(%ebp),%eax 110ada: 50 push %eax 110adb: 8d 45 dc lea -0x24(%ebp),%eax 110ade: 50 push %eax 110adf: 53 push %ebx 110ae0: ff 75 08 pushl 0x8(%ebp) 110ae3: e8 8c 00 00 00 call 110b74 <_POSIX_signals_Clear_signals> 110ae8: 83 c4 20 add $0x20,%esp is_global, true ) ) return false; 110aeb: 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, 110aed: 84 c0 test %al,%al 110aef: 74 78 je 110b69 <_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 ) 110af1: 6b d3 0c imul $0xc,%ebx,%edx 110af4: 8b 82 4c 48 12 00 mov 0x12484c(%edx),%eax 110afa: 83 f8 01 cmp $0x1,%eax 110afd: 74 6a je 110b69 <_POSIX_signals_Check_signal+0xa1><== NEVER TAKEN return false; /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 110aff: 8b 4d 08 mov 0x8(%ebp),%ecx 110b02: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx 110b08: 89 4d a4 mov %ecx,-0x5c(%ebp) api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 110b0b: 0b 8a 48 48 12 00 or 0x124848(%edx),%ecx 110b11: 8b 75 08 mov 0x8(%ebp),%esi 110b14: 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, 110b1a: 8d 7d b4 lea -0x4c(%ebp),%edi 110b1d: 8b 35 34 48 12 00 mov 0x124834,%esi 110b23: 83 c6 20 add $0x20,%esi 110b26: b9 0a 00 00 00 mov $0xa,%ecx 110b2b: 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 ) { 110b2d: 83 ba 44 48 12 00 02 cmpl $0x2,0x124844(%edx) 110b34: 75 09 jne 110b3f <_POSIX_signals_Check_signal+0x77> case SA_SIGINFO: (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 110b36: 52 push %edx 110b37: 6a 00 push $0x0 110b39: 8d 55 dc lea -0x24(%ebp),%edx 110b3c: 52 push %edx 110b3d: eb 03 jmp 110b42 <_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 ); 110b3f: 83 ec 0c sub $0xc,%esp 110b42: 53 push %ebx 110b43: ff d0 call *%eax break; 110b45: 83 c4 10 add $0x10,%esp } /* * Restore the blocking information */ memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information, 110b48: 8b 3d 34 48 12 00 mov 0x124834,%edi 110b4e: 83 c7 20 add $0x20,%edi 110b51: 8d 75 b4 lea -0x4c(%ebp),%esi 110b54: b9 0a 00 00 00 mov $0xa,%ecx 110b59: 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; 110b5b: 8b 75 a4 mov -0x5c(%ebp),%esi 110b5e: 8b 4d 08 mov 0x8(%ebp),%ecx 110b61: 89 b1 d0 00 00 00 mov %esi,0xd0(%ecx) return true; 110b67: b1 01 mov $0x1,%cl } 110b69: 88 c8 mov %cl,%al 110b6b: 8d 65 f4 lea -0xc(%ebp),%esp 110b6e: 5b pop %ebx 110b6f: 5e pop %esi 110b70: 5f pop %edi 110b71: c9 leave 110b72: c3 ret =============================================================================== 0011105c <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( int signo ) { 11105c: 55 push %ebp 11105d: 89 e5 mov %esp,%ebp 11105f: 53 push %ebx 111060: 8b 4d 08 mov 0x8(%ebp),%ecx clear_signal = true; mask = signo_to_mask( signo ); ISR_Level level; _ISR_Disable( level ); 111063: 9c pushf 111064: fa cli 111065: 5a pop %edx if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 111066: 6b c1 0c imul $0xc,%ecx,%eax 111069: 83 b8 44 48 12 00 02 cmpl $0x2,0x124844(%eax) 111070: 75 0e jne 111080 <_POSIX_signals_Clear_process_signals+0x24> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 111072: 8d 98 40 4a 12 00 lea 0x124a40(%eax),%ebx if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 111078: 39 98 3c 4a 12 00 cmp %ebx,0x124a3c(%eax) 11107e: 75 0e jne 11108e <_POSIX_signals_Clear_process_signals+0x32><== NEVER TAKEN 111080: 49 dec %ecx 111081: b8 fe ff ff ff mov $0xfffffffe,%eax clear_signal = false; } if ( clear_signal ) { _POSIX_signals_Pending &= ~mask; 111086: d3 c0 rol %cl,%eax 111088: 21 05 38 4a 12 00 and %eax,0x124a38 } _ISR_Enable( level ); 11108e: 52 push %edx 11108f: 9d popf } 111090: 5b pop %ebx 111091: c9 leave 111092: c3 ret =============================================================================== 0010ab64 <_POSIX_signals_Get_lowest>: #include int _POSIX_signals_Get_lowest( sigset_t set ) { 10ab64: 55 push %ebp 10ab65: 89 e5 mov %esp,%ebp 10ab67: 56 push %esi 10ab68: 53 push %ebx 10ab69: 8b 55 08 mov 0x8(%ebp),%edx int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10ab6c: b8 1b 00 00 00 mov $0x1b,%eax 10ab71: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include int _POSIX_signals_Get_lowest( 10ab76: 8d 48 ff lea -0x1(%eax),%ecx 10ab79: 89 de mov %ebx,%esi 10ab7b: d3 e6 shl %cl,%esi ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) { 10ab7d: 85 d6 test %edx,%esi 10ab7f: 75 1e jne 10ab9f <_POSIX_signals_Get_lowest+0x3b><== NEVER TAKEN sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10ab81: 40 inc %eax 10ab82: 83 f8 20 cmp $0x20,%eax 10ab85: 75 ef jne 10ab76 <_POSIX_signals_Get_lowest+0x12> 10ab87: b0 01 mov $0x1,%al 10ab89: bb 01 00 00 00 mov $0x1,%ebx #include #include #include #include int _POSIX_signals_Get_lowest( 10ab8e: 8d 48 ff lea -0x1(%eax),%ecx 10ab91: 89 de mov %ebx,%esi 10ab93: 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 ) ) { 10ab95: 85 d6 test %edx,%esi 10ab97: 75 06 jne 10ab9f <_POSIX_signals_Get_lowest+0x3b> */ #if (SIGHUP != 1) #error "Assumption that SIGHUP==1 violated!!" #endif for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10ab99: 40 inc %eax 10ab9a: 83 f8 1b cmp $0x1b,%eax 10ab9d: 75 ef jne 10ab8e <_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; } 10ab9f: 5b pop %ebx 10aba0: 5e pop %esi 10aba1: c9 leave 10aba2: c3 ret =============================================================================== 00121868 <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 121868: 55 push %ebp 121869: 89 e5 mov %esp,%ebp 12186b: 57 push %edi 12186c: 56 push %esi 12186d: 53 push %ebx 12186e: 83 ec 0c sub $0xc,%esp 121871: 8b 5d 08 mov 0x8(%ebp),%ebx 121874: 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 ]; 121877: 8b 83 f8 00 00 00 mov 0xf8(%ebx),%eax 12187d: 8d 4e ff lea -0x1(%esi),%ecx 121880: ba 01 00 00 00 mov $0x1,%edx 121885: d3 e2 shl %cl,%edx /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 121887: 8b 4b 10 mov 0x10(%ebx),%ecx 12188a: 89 cf mov %ecx,%edi 12188c: 81 e7 00 80 00 10 and $0x10008000,%edi 121892: 81 ff 00 80 00 10 cmp $0x10008000,%edi 121898: 75 58 jne 1218f2 <_POSIX_signals_Unblock_thread+0x8a> if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 12189a: 85 53 30 test %edx,0x30(%ebx) 12189d: 75 12 jne 1218b1 <_POSIX_signals_Unblock_thread+0x49> 12189f: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 1218a5: f7 d0 not %eax /* * This should only be reached via pthread_kill(). */ return false; 1218a7: 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) ) { 1218a9: 85 c2 test %eax,%edx 1218ab: 0f 84 b0 00 00 00 je 121961 <_POSIX_signals_Unblock_thread+0xf9> the_thread->Wait.return_code = EINTR; 1218b1: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) the_info = (siginfo_t *) the_thread->Wait.return_argument; 1218b8: 8b 43 28 mov 0x28(%ebx),%eax if ( !info ) { 1218bb: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 1218bf: 75 12 jne 1218d3 <_POSIX_signals_Unblock_thread+0x6b> the_info->si_signo = signo; 1218c1: 89 30 mov %esi,(%eax) the_info->si_code = SI_USER; 1218c3: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) the_info->si_value.sival_int = 0; 1218ca: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) 1218d1: eb 0c jmp 1218df <_POSIX_signals_Unblock_thread+0x77> } else { *the_info = *info; 1218d3: b9 03 00 00 00 mov $0x3,%ecx 1218d8: 89 c7 mov %eax,%edi 1218da: 8b 75 10 mov 0x10(%ebp),%esi 1218dd: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } _Thread_queue_Extract_with_proxy( the_thread ); 1218df: 83 ec 0c sub $0xc,%esp 1218e2: 53 push %ebx 1218e3: e8 0c f4 fe ff call 110cf4 <_Thread_queue_Extract_with_proxy> return true; 1218e8: 83 c4 10 add $0x10,%esp 1218eb: bf 01 00 00 00 mov $0x1,%edi 1218f0: eb 6f jmp 121961 <_POSIX_signals_Unblock_thread+0xf9> } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 1218f2: 8b 80 d0 00 00 00 mov 0xd0(%eax),%eax 1218f8: 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; 1218fa: 31 ff xor %edi,%edi } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 1218fc: 85 c2 test %eax,%edx 1218fe: 74 61 je 121961 <_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 ) ) { 121900: f7 c1 00 00 00 10 test $0x10000000,%ecx 121906: 74 3d je 121945 <_POSIX_signals_Unblock_thread+0xdd> the_thread->Wait.return_code = EINTR; 121908: 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) ) 12190f: f7 c1 e0 be 03 00 test $0x3bee0,%ecx 121915: 74 0b je 121922 <_POSIX_signals_Unblock_thread+0xba> _Thread_queue_Extract_with_proxy( the_thread ); 121917: 83 ec 0c sub $0xc,%esp 12191a: 53 push %ebx 12191b: e8 d4 f3 fe ff call 110cf4 <_Thread_queue_Extract_with_proxy> 121920: eb 1e jmp 121940 <_POSIX_signals_Unblock_thread+0xd8> else if ( _States_Is_delaying(the_thread->current_state) ) { 121922: 80 e1 08 and $0x8,%cl 121925: 74 3a je 121961 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN (void) _Watchdog_Remove( &the_thread->Timer ); 121927: 83 ec 0c sub $0xc,%esp 12192a: 8d 43 48 lea 0x48(%ebx),%eax 12192d: 50 push %eax 12192e: e8 4d fc fe ff call 111580 <_Watchdog_Remove> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 121933: 58 pop %eax 121934: 5a pop %edx 121935: 68 f8 ff 03 10 push $0x1003fff8 12193a: 53 push %ebx 12193b: e8 e4 e9 fe ff call 110324 <_Thread_Clear_state> 121940: 83 c4 10 add $0x10,%esp 121943: eb 1c jmp 121961 <_POSIX_signals_Unblock_thread+0xf9> _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { 121945: 85 c9 test %ecx,%ecx 121947: 75 18 jne 121961 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 121949: 83 3d a4 a9 12 00 00 cmpl $0x0,0x12a9a4 121950: 74 0f je 121961 <_POSIX_signals_Unblock_thread+0xf9> 121952: 3b 1d a8 a9 12 00 cmp 0x12a9a8,%ebx 121958: 75 07 jne 121961 <_POSIX_signals_Unblock_thread+0xf9><== NEVER TAKEN _Thread_Dispatch_necessary = true; 12195a: c6 05 b4 a9 12 00 01 movb $0x1,0x12a9b4 } } return false; } 121961: 89 f8 mov %edi,%eax 121963: 8d 65 f4 lea -0xc(%ebp),%esp 121966: 5b pop %ebx 121967: 5e pop %esi 121968: 5f pop %edi 121969: c9 leave 12196a: c3 ret =============================================================================== 0010b3b4 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 10b3b4: 55 push %ebp 10b3b5: 89 e5 mov %esp,%ebp 10b3b7: 53 push %ebx 10b3b8: 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 ); 10b3bb: 8d 45 f4 lea -0xc(%ebp),%eax 10b3be: 50 push %eax 10b3bf: ff 75 08 pushl 0x8(%ebp) 10b3c2: 68 14 73 12 00 push $0x127314 10b3c7: e8 cc 1a 00 00 call 10ce98 <_Objects_Get> 10b3cc: 89 c3 mov %eax,%ebx switch ( location ) { 10b3ce: 83 c4 10 add $0x10,%esp 10b3d1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10b3d5: 75 64 jne 10b43b <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN case OBJECTS_LOCAL: the_thread = the_period->owner; 10b3d7: 8b 40 40 mov 0x40(%eax),%eax if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10b3da: f6 40 11 40 testb $0x40,0x11(%eax) 10b3de: 74 18 je 10b3f8 <_Rate_monotonic_Timeout+0x44> 10b3e0: 8b 53 08 mov 0x8(%ebx),%edx 10b3e3: 39 50 20 cmp %edx,0x20(%eax) 10b3e6: 75 10 jne 10b3f8 <_Rate_monotonic_Timeout+0x44> RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 10b3e8: 52 push %edx 10b3e9: 52 push %edx 10b3ea: 68 f8 ff 03 10 push $0x1003fff8 10b3ef: 50 push %eax 10b3f0: e8 0f 1f 00 00 call 10d304 <_Thread_Clear_state> the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 10b3f5: 59 pop %ecx 10b3f6: eb 10 jmp 10b408 <_Rate_monotonic_Timeout+0x54> _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 10b3f8: 83 7b 38 01 cmpl $0x1,0x38(%ebx) 10b3fc: 75 2b jne 10b429 <_Rate_monotonic_Timeout+0x75> the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 10b3fe: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) _Rate_monotonic_Initiate_statistics( the_period ); 10b405: 83 ec 0c sub $0xc,%esp 10b408: 53 push %ebx 10b409: e8 ec fa ff ff call 10aefa <_Rate_monotonic_Initiate_statistics> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b40e: 8b 43 3c mov 0x3c(%ebx),%eax 10b411: 89 43 1c mov %eax,0x1c(%ebx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b414: 58 pop %eax 10b415: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); 10b416: 83 c3 10 add $0x10,%ebx 10b419: 53 push %ebx 10b41a: 68 d0 74 12 00 push $0x1274d0 10b41f: e8 b8 31 00 00 call 10e5dc <_Watchdog_Insert> 10b424: 83 c4 10 add $0x10,%esp 10b427: eb 07 jmp 10b430 <_Rate_monotonic_Timeout+0x7c> } else the_period->state = RATE_MONOTONIC_EXPIRED; 10b429: 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; 10b430: a1 08 74 12 00 mov 0x127408,%eax 10b435: 48 dec %eax 10b436: a3 08 74 12 00 mov %eax,0x127408 case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10b43b: 8b 5d fc mov -0x4(%ebp),%ebx 10b43e: c9 leave 10b43f: c3 ret =============================================================================== 0010acb4 <_TOD_Validate>: */ bool _TOD_Validate( const rtems_time_of_day *the_tod ) { 10acb4: 55 push %ebp 10acb5: 89 e5 mov %esp,%ebp 10acb7: 56 push %esi 10acb8: 53 push %ebx 10acb9: 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(); 10acbc: 8b 35 44 42 12 00 mov 0x124244,%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; 10acc2: 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) || 10acc4: 85 c9 test %ecx,%ecx 10acc6: 74 57 je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN ) { uint32_t days_in_month; uint32_t ticks_per_second; ticks_per_second = TOD_MICROSECONDS_PER_SECOND / 10acc8: b8 40 42 0f 00 mov $0xf4240,%eax 10accd: 31 d2 xor %edx,%edx 10accf: f7 f6 div %esi rtems_configuration_get_microseconds_per_tick(); if ((!the_tod) || 10acd1: 39 41 18 cmp %eax,0x18(%ecx) 10acd4: 73 49 jae 10ad1f <_TOD_Validate+0x6b> (the_tod->ticks >= ticks_per_second) || 10acd6: 83 79 14 3b cmpl $0x3b,0x14(%ecx) 10acda: 77 43 ja 10ad1f <_TOD_Validate+0x6b> (the_tod->second >= TOD_SECONDS_PER_MINUTE) || 10acdc: 83 79 10 3b cmpl $0x3b,0x10(%ecx) 10ace0: 77 3d ja 10ad1f <_TOD_Validate+0x6b> (the_tod->minute >= TOD_MINUTES_PER_HOUR) || 10ace2: 83 79 0c 17 cmpl $0x17,0xc(%ecx) 10ace6: 77 37 ja 10ad1f <_TOD_Validate+0x6b> (the_tod->hour >= TOD_HOURS_PER_DAY) || (the_tod->month == 0) || 10ace8: 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) || 10aceb: 85 c0 test %eax,%eax 10aced: 74 30 je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN (the_tod->month == 0) || 10acef: 83 f8 0c cmp $0xc,%eax 10acf2: 77 2b ja 10ad1f <_TOD_Validate+0x6b> (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || 10acf4: 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) || 10acf6: 81 fe c3 07 00 00 cmp $0x7c3,%esi 10acfc: 76 21 jbe 10ad1f <_TOD_Validate+0x6b> (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) 10acfe: 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) || 10ad01: 85 d2 test %edx,%edx 10ad03: 74 1a je 10ad1f <_TOD_Validate+0x6b> <== NEVER TAKEN (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 10ad05: 83 e6 03 and $0x3,%esi 10ad08: 75 09 jne 10ad13 <_TOD_Validate+0x5f> days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 10ad0a: 8b 04 85 24 14 12 00 mov 0x121424(,%eax,4),%eax 10ad11: eb 07 jmp 10ad1a <_TOD_Validate+0x66> else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 10ad13: 8b 04 85 f0 13 12 00 mov 0x1213f0(,%eax,4),%eax * false - if the the_tod is invalid * * NOTE: This routine only works for leap-years through 2099. */ bool _TOD_Validate( 10ad1a: 39 c2 cmp %eax,%edx 10ad1c: 0f 96 c3 setbe %bl if ( the_tod->day > days_in_month ) return false; return true; } 10ad1f: 88 d8 mov %bl,%al 10ad21: 5b pop %ebx 10ad22: 5e pop %esi 10ad23: c9 leave 10ad24: c3 ret =============================================================================== 0010ba3c <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10ba3c: 55 push %ebp 10ba3d: 89 e5 mov %esp,%ebp 10ba3f: 57 push %edi 10ba40: 56 push %esi 10ba41: 53 push %ebx 10ba42: 83 ec 28 sub $0x28,%esp 10ba45: 8b 5d 08 mov 0x8(%ebp),%ebx 10ba48: 8b 7d 0c mov 0xc(%ebp),%edi 10ba4b: 8a 45 10 mov 0x10(%ebp),%al 10ba4e: 88 45 e7 mov %al,-0x19(%ebp) */ /* * Save original state */ original_state = the_thread->current_state; 10ba51: 8b 73 10 mov 0x10(%ebx),%esi /* * 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 ); 10ba54: 53 push %ebx 10ba55: e8 3e 0d 00 00 call 10c798 <_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 ) 10ba5a: 83 c4 10 add $0x10,%esp 10ba5d: 39 7b 14 cmp %edi,0x14(%ebx) 10ba60: 74 0c je 10ba6e <_Thread_Change_priority+0x32> _Thread_Set_priority( the_thread, new_priority ); 10ba62: 50 push %eax 10ba63: 50 push %eax 10ba64: 57 push %edi 10ba65: 53 push %ebx 10ba66: e8 f5 0b 00 00 call 10c660 <_Thread_Set_priority> 10ba6b: 83 c4 10 add $0x10,%esp _ISR_Disable( level ); 10ba6e: 9c pushf 10ba6f: fa cli 10ba70: 59 pop %ecx /* * 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; 10ba71: 8b 43 10 mov 0x10(%ebx),%eax if ( state != STATES_TRANSIENT ) { 10ba74: 83 f8 04 cmp $0x4,%eax 10ba77: 74 2f je 10baa8 <_Thread_Change_priority+0x6c> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10ba79: 83 e6 04 and $0x4,%esi 10ba7c: 75 08 jne 10ba86 <_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); 10ba7e: 89 c2 mov %eax,%edx 10ba80: 83 e2 fb and $0xfffffffb,%edx 10ba83: 89 53 10 mov %edx,0x10(%ebx) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); 10ba86: 51 push %ecx 10ba87: 9d popf if ( _States_Is_waiting_on_thread_queue( state ) ) { 10ba88: a9 e0 be 03 00 test $0x3bee0,%eax 10ba8d: 0f 84 c0 00 00 00 je 10bb53 <_Thread_Change_priority+0x117> _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10ba93: 89 5d 0c mov %ebx,0xc(%ebp) 10ba96: 8b 43 44 mov 0x44(%ebx),%eax 10ba99: 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 ); } 10ba9c: 8d 65 f4 lea -0xc(%ebp),%esp 10ba9f: 5b pop %ebx 10baa0: 5e pop %esi 10baa1: 5f pop %edi 10baa2: 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 ); 10baa3: e9 30 0b 00 00 jmp 10c5d8 <_Thread_queue_Requeue> } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10baa8: 83 e6 04 and $0x4,%esi 10baab: 75 53 jne 10bb00 <_Thread_Change_priority+0xc4><== NEVER TAKEN * Interrupts are STILL disabled. * We now know the thread will be in the READY state when we remove * the TRANSIENT state. So we have to place it on the appropriate * Ready Queue with interrupts off. */ the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10baad: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10bab4: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax 10baba: 66 8b 93 96 00 00 00 mov 0x96(%ebx),%dx 10bac1: 66 09 10 or %dx,(%eax) _Priority_Major_bit_map |= the_priority_map->ready_major; 10bac4: 66 a1 88 43 12 00 mov 0x124388,%ax 10baca: 0b 83 94 00 00 00 or 0x94(%ebx),%eax 10bad0: 66 a3 88 43 12 00 mov %ax,0x124388 _Priority_bit_map_Add( &the_thread->Priority_map ); if ( prepend_it ) 10bad6: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10bada: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax 10bae0: 74 0e je 10baf0 <_Thread_Change_priority+0xb4> Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10bae2: 89 43 04 mov %eax,0x4(%ebx) before_node = after_node->next; 10bae5: 8b 10 mov (%eax),%edx after_node->next = the_node; 10bae7: 89 18 mov %ebx,(%eax) the_node->next = before_node; 10bae9: 89 13 mov %edx,(%ebx) before_node->previous = the_node; 10baeb: 89 5a 04 mov %ebx,0x4(%edx) 10baee: eb 10 jmp 10bb00 <_Thread_Change_priority+0xc4> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10baf0: 8d 50 04 lea 0x4(%eax),%edx 10baf3: 89 13 mov %edx,(%ebx) ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; 10baf5: 8b 50 08 mov 0x8(%eax),%edx the_chain->last = the_node; 10baf8: 89 58 08 mov %ebx,0x8(%eax) old_last_node->next = the_node; 10bafb: 89 1a mov %ebx,(%edx) the_node->previous = old_last_node; 10bafd: 89 53 04 mov %edx,0x4(%ebx) _Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node ); else _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node ); } _ISR_Flash( level ); 10bb00: 51 push %ecx 10bb01: 9d popf 10bb02: fa cli 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 ); 10bb03: 66 8b 1d 88 43 12 00 mov 0x124388,%bx 10bb0a: 31 c0 xor %eax,%eax 10bb0c: 89 c2 mov %eax,%edx 10bb0e: 66 0f bc d3 bsf %bx,%dx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10bb12: 0f b7 d2 movzwl %dx,%edx 10bb15: 66 8b 9c 12 f8 43 12 mov 0x1243f8(%edx,%edx,1),%bx 10bb1c: 00 10bb1d: 66 0f bc c3 bsf %bx,%ax return (_Priority_Bits_index( major ) << 4) + 10bb21: c1 e2 04 shl $0x4,%edx 10bb24: 0f b7 c0 movzwl %ax,%eax */ RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void ) { _Thread_Heir = (Thread_Control *) _Thread_Ready_chain[ _Priority_bit_map_Get_highest() ].first; 10bb27: 8d 04 02 lea (%edx,%eax,1),%eax 10bb2a: 6b c0 0c imul $0xc,%eax,%eax 10bb2d: 03 05 b0 42 12 00 add 0x1242b0,%eax * ready thread. */ RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void ) { _Thread_Heir = (Thread_Control *) 10bb33: 8b 10 mov (%eax),%edx 10bb35: 89 15 38 48 12 00 mov %edx,0x124838 * is also the heir thread, and false otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void ) { return ( _Thread_Executing == _Thread_Heir ); 10bb3b: a1 34 48 12 00 mov 0x124834,%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. */ _Thread_Calculate_heir(); if ( !_Thread_Is_executing_also_the_heir() && 10bb40: 39 d0 cmp %edx,%eax 10bb42: 74 0d je 10bb51 <_Thread_Change_priority+0x115> 10bb44: 80 78 74 00 cmpb $0x0,0x74(%eax) 10bb48: 74 07 je 10bb51 <_Thread_Change_priority+0x115> _Thread_Executing->is_preemptible ) _Thread_Dispatch_necessary = true; 10bb4a: c6 05 40 48 12 00 01 movb $0x1,0x124840 _ISR_Enable( level ); 10bb51: 51 push %ecx 10bb52: 9d popf } 10bb53: 8d 65 f4 lea -0xc(%ebp),%esp 10bb56: 5b pop %ebx 10bb57: 5e pop %esi 10bb58: 5f pop %edi 10bb59: c9 leave 10bb5a: c3 ret =============================================================================== 0010bb5c <_Thread_Clear_state>: void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 10bb5c: 55 push %ebp 10bb5d: 89 e5 mov %esp,%ebp 10bb5f: 53 push %ebx 10bb60: 8b 45 08 mov 0x8(%ebp),%eax 10bb63: 8b 55 0c mov 0xc(%ebp),%edx ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10bb66: 9c pushf 10bb67: fa cli 10bb68: 59 pop %ecx current_state = the_thread->current_state; 10bb69: 8b 58 10 mov 0x10(%eax),%ebx if ( current_state & state ) { 10bb6c: 85 da test %ebx,%edx 10bb6e: 74 71 je 10bbe1 <_Thread_Clear_state+0x85> 10bb70: f7 d2 not %edx 10bb72: 21 da and %ebx,%edx current_state = the_thread->current_state = _States_Clear( state, current_state ); 10bb74: 89 50 10 mov %edx,0x10(%eax) if ( _States_Is_ready( current_state ) ) { 10bb77: 85 d2 test %edx,%edx 10bb79: 75 66 jne 10bbe1 <_Thread_Clear_state+0x85> RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10bb7b: 8b 90 90 00 00 00 mov 0x90(%eax),%edx 10bb81: 66 8b 98 96 00 00 00 mov 0x96(%eax),%bx 10bb88: 66 09 1a or %bx,(%edx) _Priority_Major_bit_map |= the_priority_map->ready_major; 10bb8b: 66 8b 15 88 43 12 00 mov 0x124388,%dx 10bb92: 0b 90 94 00 00 00 or 0x94(%eax),%edx 10bb98: 66 89 15 88 43 12 00 mov %dx,0x124388 _Priority_bit_map_Add( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10bb9f: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10bba5: 8d 5a 04 lea 0x4(%edx),%ebx 10bba8: 89 18 mov %ebx,(%eax) ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; 10bbaa: 8b 5a 08 mov 0x8(%edx),%ebx the_chain->last = the_node; 10bbad: 89 42 08 mov %eax,0x8(%edx) old_last_node->next = the_node; 10bbb0: 89 03 mov %eax,(%ebx) the_node->previous = old_last_node; 10bbb2: 89 58 04 mov %ebx,0x4(%eax) _ISR_Flash( level ); 10bbb5: 51 push %ecx 10bbb6: 9d popf 10bbb7: fa cli * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 10bbb8: 8b 50 14 mov 0x14(%eax),%edx 10bbbb: 8b 1d 38 48 12 00 mov 0x124838,%ebx 10bbc1: 3b 53 14 cmp 0x14(%ebx),%edx 10bbc4: 73 1b jae 10bbe1 <_Thread_Clear_state+0x85> _Thread_Heir = the_thread; 10bbc6: a3 38 48 12 00 mov %eax,0x124838 if ( _Thread_Executing->is_preemptible || 10bbcb: a1 34 48 12 00 mov 0x124834,%eax 10bbd0: 80 78 74 00 cmpb $0x0,0x74(%eax) 10bbd4: 75 04 jne 10bbda <_Thread_Clear_state+0x7e> 10bbd6: 85 d2 test %edx,%edx 10bbd8: 75 07 jne 10bbe1 <_Thread_Clear_state+0x85><== ALWAYS TAKEN the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 10bbda: c6 05 40 48 12 00 01 movb $0x1,0x124840 } } } _ISR_Enable( level ); 10bbe1: 51 push %ecx 10bbe2: 9d popf } 10bbe3: 5b pop %ebx 10bbe4: c9 leave 10bbe5: c3 ret =============================================================================== 0010bd5c <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 10bd5c: 55 push %ebp 10bd5d: 89 e5 mov %esp,%ebp 10bd5f: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10bd62: 8d 45 f4 lea -0xc(%ebp),%eax 10bd65: 50 push %eax 10bd66: ff 75 08 pushl 0x8(%ebp) 10bd69: e8 82 01 00 00 call 10bef0 <_Thread_Get> switch ( location ) { 10bd6e: 83 c4 10 add $0x10,%esp 10bd71: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10bd75: 75 1b jne 10bd92 <_Thread_Delay_ended+0x36><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_Clear_state( 10bd77: 52 push %edx 10bd78: 52 push %edx 10bd79: 68 18 00 00 10 push $0x10000018 10bd7e: 50 push %eax 10bd7f: e8 d8 fd ff ff call 10bb5c <_Thread_Clear_state> 10bd84: a1 e4 42 12 00 mov 0x1242e4,%eax 10bd89: 48 dec %eax 10bd8a: a3 e4 42 12 00 mov %eax,0x1242e4 10bd8f: 83 c4 10 add $0x10,%esp | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Thread_Unnest_dispatch(); break; } } 10bd92: c9 leave 10bd93: c3 ret =============================================================================== 0010bd94 <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10bd94: 55 push %ebp 10bd95: 89 e5 mov %esp,%ebp 10bd97: 57 push %edi 10bd98: 56 push %esi 10bd99: 53 push %ebx 10bd9a: 83 ec 1c sub $0x1c,%esp Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10bd9d: 8b 1d 34 48 12 00 mov 0x124834,%ebx _ISR_Disable( level ); 10bda3: 9c pushf 10bda4: fa cli 10bda5: 58 pop %eax #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); _Timestamp_Subtract( 10bda6: 8d 7d d8 lea -0x28(%ebp),%edi Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10bda9: e9 f9 00 00 00 jmp 10bea7 <_Thread_Dispatch+0x113> heir = _Thread_Heir; 10bdae: 8b 35 38 48 12 00 mov 0x124838,%esi _Thread_Dispatch_disable_level = 1; 10bdb4: c7 05 e4 42 12 00 01 movl $0x1,0x1242e4 10bdbb: 00 00 00 _Thread_Dispatch_necessary = false; 10bdbe: c6 05 40 48 12 00 00 movb $0x0,0x124840 _Thread_Executing = heir; 10bdc5: 89 35 34 48 12 00 mov %esi,0x124834 /* * 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 ) 10bdcb: 39 de cmp %ebx,%esi 10bdcd: 0f 84 e2 00 00 00 je 10beb5 <_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 ) 10bdd3: 83 7e 7c 01 cmpl $0x1,0x7c(%esi) 10bdd7: 75 09 jne 10bde2 <_Thread_Dispatch+0x4e> heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10bdd9: 8b 15 b4 42 12 00 mov 0x1242b4,%edx 10bddf: 89 56 78 mov %edx,0x78(%esi) _ISR_Enable( level ); 10bde2: 50 push %eax 10bde3: 9d popf #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); 10bde4: 83 ec 0c sub $0xc,%esp 10bde7: 8d 45 e0 lea -0x20(%ebp),%eax 10bdea: 50 push %eax 10bdeb: e8 08 36 00 00 call 10f3f8 <_TOD_Get_uptime> _Timestamp_Subtract( 10bdf0: 83 c4 0c add $0xc,%esp 10bdf3: 57 push %edi 10bdf4: 8d 45 e0 lea -0x20(%ebp),%eax 10bdf7: 50 push %eax 10bdf8: 68 98 43 12 00 push $0x124398 10bdfd: e8 32 0c 00 00 call 10ca34 <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timestamp_Add_to( &executing->cpu_time_used, &ran ); 10be02: 58 pop %eax 10be03: 5a pop %edx 10be04: 57 push %edi 10be05: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10be0b: 50 push %eax 10be0c: e8 f3 0b 00 00 call 10ca04 <_Timespec_Add_to> _Thread_Time_of_last_context_switch = uptime; 10be11: 8b 45 e0 mov -0x20(%ebp),%eax 10be14: 8b 55 e4 mov -0x1c(%ebp),%edx 10be17: a3 98 43 12 00 mov %eax,0x124398 10be1c: 89 15 9c 43 12 00 mov %edx,0x12439c #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10be22: a1 6c 43 12 00 mov 0x12436c,%eax 10be27: 83 c4 10 add $0x10,%esp 10be2a: 85 c0 test %eax,%eax 10be2c: 74 10 je 10be3e <_Thread_Dispatch+0xaa> <== NEVER TAKEN executing->libc_reent = *_Thread_libc_reent; 10be2e: 8b 10 mov (%eax),%edx 10be30: 89 93 f0 00 00 00 mov %edx,0xf0(%ebx) *_Thread_libc_reent = heir->libc_reent; 10be36: 8b 96 f0 00 00 00 mov 0xf0(%esi),%edx 10be3c: 89 10 mov %edx,(%eax) } _User_extensions_Thread_switch( executing, heir ); 10be3e: 51 push %ecx 10be3f: 51 push %ecx 10be40: 56 push %esi 10be41: 53 push %ebx 10be42: e8 25 0e 00 00 call 10cc6c <_User_extensions_Thread_switch> if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10be47: 58 pop %eax 10be48: 5a pop %edx 10be49: 81 c6 d4 00 00 00 add $0xd4,%esi 10be4f: 56 push %esi 10be50: 8d 83 d4 00 00 00 lea 0xd4(%ebx),%eax 10be56: 50 push %eax 10be57: e8 d4 10 00 00 call 10cf30 <_CPU_Context_switch> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10be5c: 83 c4 10 add $0x10,%esp 10be5f: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx) 10be66: 74 36 je 10be9e <_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 ); 10be68: a1 68 43 12 00 mov 0x124368,%eax 10be6d: 39 c3 cmp %eax,%ebx 10be6f: 74 2d je 10be9e <_Thread_Dispatch+0x10a> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10be71: 85 c0 test %eax,%eax 10be73: 74 11 je 10be86 <_Thread_Dispatch+0xf2> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10be75: 83 ec 0c sub $0xc,%esp 10be78: 05 ec 00 00 00 add $0xec,%eax 10be7d: 50 push %eax 10be7e: e8 e1 10 00 00 call 10cf64 <_CPU_Context_save_fp> 10be83: 83 c4 10 add $0x10,%esp _Context_Restore_fp( &executing->fp_context ); 10be86: 83 ec 0c sub $0xc,%esp 10be89: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax 10be8f: 50 push %eax 10be90: e8 d9 10 00 00 call 10cf6e <_CPU_Context_restore_fp> _Thread_Allocated_fp = executing; 10be95: 89 1d 68 43 12 00 mov %ebx,0x124368 10be9b: 83 c4 10 add $0x10,%esp if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10be9e: 8b 1d 34 48 12 00 mov 0x124834,%ebx _ISR_Disable( level ); 10bea4: 9c pushf 10bea5: fa cli 10bea6: 58 pop %eax Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Thread_Dispatch_necessary == true ) { 10bea7: 8a 15 40 48 12 00 mov 0x124840,%dl 10bead: 84 d2 test %dl,%dl 10beaf: 0f 85 f9 fe ff ff jne 10bdae <_Thread_Dispatch+0x1a> _ISR_Disable( level ); } post_switch: _Thread_Dispatch_disable_level = 0; 10beb5: c7 05 e4 42 12 00 00 movl $0x0,0x1242e4 10bebc: 00 00 00 _ISR_Enable( level ); 10bebf: 50 push %eax 10bec0: 9d popf _API_extensions_Run_postswitch(); 10bec1: e8 0d ea ff ff call 10a8d3 <_API_extensions_Run_postswitch> } 10bec6: 8d 65 f4 lea -0xc(%ebp),%esp 10bec9: 5b pop %ebx 10beca: 5e pop %esi 10becb: 5f pop %edi 10becc: c9 leave 10becd: c3 ret =============================================================================== 00110f10 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 110f10: 55 push %ebp 110f11: 89 e5 mov %esp,%ebp 110f13: 53 push %ebx 110f14: 83 ec 14 sub $0x14,%esp #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing; 110f17: 8b 1d 34 48 12 00 mov 0x124834,%ebx /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 110f1d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax _ISR_Set_level(level); 110f23: 85 c0 test %eax,%eax 110f25: 74 03 je 110f2a <_Thread_Handler+0x1a> 110f27: fa cli 110f28: eb 01 jmp 110f2b <_Thread_Handler+0x1b> 110f2a: fb sti #if defined(EXECUTE_GLOBAL_CONSTRUCTORS) doneCons = doneConstructors; 110f2b: a0 a0 3f 12 00 mov 0x123fa0,%al 110f30: 88 45 f7 mov %al,-0x9(%ebp) doneConstructors = 1; 110f33: c6 05 a0 3f 12 00 01 movb $0x1,0x123fa0 #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 110f3a: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx) 110f41: 74 24 je 110f67 <_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 ); 110f43: a1 68 43 12 00 mov 0x124368,%eax 110f48: 39 c3 cmp %eax,%ebx 110f4a: 74 1b je 110f67 <_Thread_Handler+0x57> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 110f4c: 85 c0 test %eax,%eax 110f4e: 74 11 je 110f61 <_Thread_Handler+0x51> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 110f50: 83 ec 0c sub $0xc,%esp 110f53: 05 ec 00 00 00 add $0xec,%eax 110f58: 50 push %eax 110f59: e8 06 c0 ff ff call 10cf64 <_CPU_Context_save_fp> 110f5e: 83 c4 10 add $0x10,%esp _Thread_Allocated_fp = executing; 110f61: 89 1d 68 43 12 00 mov %ebx,0x124368 /* * 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 ); 110f67: 83 ec 0c sub $0xc,%esp 110f6a: 53 push %ebx 110f6b: e8 ac bb ff ff call 10cb1c <_User_extensions_Thread_begin> /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 110f70: e8 59 af ff ff call 10bece <_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) */ { 110f75: 83 c4 10 add $0x10,%esp 110f78: 80 7d f7 00 cmpb $0x0,-0x9(%ebp) 110f7c: 75 05 jne 110f83 <_Thread_Handler+0x73> INIT_NAME (); 110f7e: e8 5d be 00 00 call 11cde0 <__start_set_sysctl_set> } #endif if ( executing->Start.prototype == THREAD_START_NUMERIC ) { 110f83: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax 110f89: 85 c0 test %eax,%eax 110f8b: 75 0b jne 110f98 <_Thread_Handler+0x88> executing->Wait.return_argument = (*(Thread_Entry_numeric) executing->Start.entry_point)( 110f8d: 83 ec 0c sub $0xc,%esp 110f90: ff b3 a8 00 00 00 pushl 0xa8(%ebx) 110f96: eb 0c jmp 110fa4 <_Thread_Handler+0x94> executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { 110f98: 48 dec %eax 110f99: 75 15 jne 110fb0 <_Thread_Handler+0xa0> <== NEVER TAKEN executing->Wait.return_argument = (*(Thread_Entry_pointer) executing->Start.entry_point)( 110f9b: 83 ec 0c sub $0xc,%esp 110f9e: ff b3 a4 00 00 00 pushl 0xa4(%ebx) 110fa4: ff 93 9c 00 00 00 call *0x9c(%ebx) executing->Start.numeric_argument ); } #if defined(RTEMS_POSIX_API) else if ( executing->Start.prototype == THREAD_START_POINTER ) { executing->Wait.return_argument = 110faa: 89 43 28 mov %eax,0x28(%ebx) 110fad: 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 ); 110fb0: 83 ec 0c sub $0xc,%esp 110fb3: 53 push %ebx 110fb4: e8 94 bb ff ff call 10cb4d <_User_extensions_Thread_exitted> _Internal_error_Occurred( 110fb9: 83 c4 0c add $0xc,%esp 110fbc: 6a 05 push $0x5 110fbe: 6a 01 push $0x1 110fc0: 6a 00 push $0x0 110fc2: e8 69 a2 ff ff call 10b230 <_Internal_error_Occurred> =============================================================================== 0010bf60 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10bf60: 55 push %ebp 10bf61: 89 e5 mov %esp,%ebp 10bf63: 57 push %edi 10bf64: 56 push %esi 10bf65: 53 push %ebx 10bf66: 83 ec 1c sub $0x1c,%esp 10bf69: 8b 5d 0c mov 0xc(%ebp),%ebx 10bf6c: 8b 4d 10 mov 0x10(%ebp),%ecx 10bf6f: 8b 75 14 mov 0x14(%ebp),%esi 10bf72: 8a 55 18 mov 0x18(%ebp),%dl 10bf75: 8a 45 20 mov 0x20(%ebp),%al 10bf78: 88 45 e7 mov %al,-0x19(%ebp) /* * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; 10bf7b: c7 83 f4 00 00 00 00 movl $0x0,0xf4(%ebx) 10bf82: 00 00 00 10bf85: c7 83 f8 00 00 00 00 movl $0x0,0xf8(%ebx) 10bf8c: 00 00 00 extensions_area = NULL; the_thread->libc_reent = NULL; 10bf8f: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx) 10bf96: 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 ) { 10bf99: 85 c9 test %ecx,%ecx 10bf9b: 75 31 jne 10bfce <_Thread_Initialize+0x6e> actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10bf9d: 51 push %ecx 10bf9e: 51 push %ecx 10bf9f: 56 push %esi 10bfa0: 53 push %ebx 10bfa1: 88 55 e0 mov %dl,-0x20(%ebp) 10bfa4: e8 63 08 00 00 call 10c80c <_Thread_Stack_Allocate> if ( !actual_stack_size || actual_stack_size < stack_size ) 10bfa9: 83 c4 10 add $0x10,%esp 10bfac: 39 f0 cmp %esi,%eax 10bfae: 8a 55 e0 mov -0x20(%ebp),%dl 10bfb1: 0f 82 c1 01 00 00 jb 10c178 <_Thread_Initialize+0x218> 10bfb7: 85 c0 test %eax,%eax 10bfb9: 0f 84 b9 01 00 00 je 10c178 <_Thread_Initialize+0x218><== NEVER TAKEN return false; /* stack allocation failed */ stack = the_thread->Start.stack; 10bfbf: 8b 8b d0 00 00 00 mov 0xd0(%ebx),%ecx the_thread->Start.core_allocated_stack = true; 10bfc5: c6 83 c0 00 00 00 01 movb $0x1,0xc0(%ebx) 10bfcc: eb 09 jmp 10bfd7 <_Thread_Initialize+0x77> } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = false; 10bfce: c6 83 c0 00 00 00 00 movb $0x0,0xc0(%ebx) 10bfd5: 89 f0 mov %esi,%eax Stack_Control *the_stack, void *starting_address, size_t size ) { the_stack->area = starting_address; 10bfd7: 89 8b c8 00 00 00 mov %ecx,0xc8(%ebx) the_stack->size = size; 10bfdd: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx) extensions_area = NULL; the_thread->libc_reent = NULL; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) fp_area = NULL; 10bfe3: 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 ) { 10bfe5: 84 d2 test %dl,%dl 10bfe7: 74 17 je 10c000 <_Thread_Initialize+0xa0> fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10bfe9: 83 ec 0c sub $0xc,%esp 10bfec: 6a 6c push $0x6c 10bfee: e8 df 0e 00 00 call 10ced2 <_Workspace_Allocate> 10bff3: 89 c7 mov %eax,%edi if ( !fp_area ) 10bff5: 83 c4 10 add $0x10,%esp 10bff8: 85 c0 test %eax,%eax 10bffa: 0f 84 08 01 00 00 je 10c108 <_Thread_Initialize+0x1a8> goto failed; fp_area = _Context_Fp_start( fp_area, 0 ); } the_thread->fp_context = fp_area; 10c000: 89 bb ec 00 00 00 mov %edi,0xec(%ebx) the_thread->Start.fp_context = fp_area; 10c006: 89 bb cc 00 00 00 mov %edi,0xcc(%ebx) Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 10c00c: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) the_watchdog->routine = routine; 10c013: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) the_watchdog->id = id; 10c01a: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) the_watchdog->user_data = user_data; 10c021: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c028: a1 78 43 12 00 mov 0x124378,%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; 10c02d: 31 f6 xor %esi,%esi #endif /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c02f: 85 c0 test %eax,%eax 10c031: 74 1d je 10c050 <_Thread_Initialize+0xf0> extensions_area = _Workspace_Allocate( 10c033: 83 ec 0c sub $0xc,%esp 10c036: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10c03d: 50 push %eax 10c03e: e8 8f 0e 00 00 call 10ced2 <_Workspace_Allocate> 10c043: 89 c6 mov %eax,%esi (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) 10c045: 83 c4 10 add $0x10,%esp 10c048: 85 c0 test %eax,%eax 10c04a: 0f 84 ba 00 00 00 je 10c10a <_Thread_Initialize+0x1aa> goto failed; } the_thread->extensions = (void **) extensions_area; 10c050: 89 b3 fc 00 00 00 mov %esi,0xfc(%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 ) { 10c056: 85 f6 test %esi,%esi 10c058: 74 16 je 10c070 <_Thread_Initialize+0x110> for ( i = 0; i <= _Thread_Maximum_extensions ; i++ ) 10c05a: 8b 15 78 43 12 00 mov 0x124378,%edx 10c060: 31 c0 xor %eax,%eax 10c062: eb 08 jmp 10c06c <_Thread_Initialize+0x10c> the_thread->extensions[i] = NULL; 10c064: 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++ ) 10c06b: 40 inc %eax 10c06c: 39 d0 cmp %edx,%eax 10c06e: 76 f4 jbe 10c064 <_Thread_Initialize+0x104> /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10c070: 8a 45 e7 mov -0x19(%ebp),%al 10c073: 88 83 ac 00 00 00 mov %al,0xac(%ebx) the_thread->Start.budget_algorithm = budget_algorithm; 10c079: 8b 45 24 mov 0x24(%ebp),%eax 10c07c: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx) the_thread->Start.budget_callout = budget_callout; 10c082: 8b 45 28 mov 0x28(%ebp),%eax 10c085: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) switch ( budget_algorithm ) { 10c08b: 83 7d 24 02 cmpl $0x2,0x24(%ebp) 10c08f: 75 08 jne 10c099 <_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; 10c091: a1 b4 42 12 00 mov 0x1242b4,%eax 10c096: 89 43 78 mov %eax,0x78(%ebx) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; #endif } the_thread->Start.isr_level = isr_level; 10c099: 8b 45 2c mov 0x2c(%ebp),%eax 10c09c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) the_thread->current_state = STATES_DORMANT; 10c0a2: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) the_thread->Wait.queue = NULL; 10c0a9: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) the_thread->resource_count = 0; 10c0b0: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->real_priority = priority; 10c0b7: 8b 45 1c mov 0x1c(%ebp),%eax 10c0ba: 89 43 18 mov %eax,0x18(%ebx) the_thread->Start.initial_priority = priority; 10c0bd: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) _Thread_Set_priority( the_thread, priority ); 10c0c3: 52 push %edx 10c0c4: 52 push %edx 10c0c5: 50 push %eax 10c0c6: 53 push %ebx 10c0c7: e8 94 05 00 00 call 10c660 <_Thread_Set_priority> /* * Initialize the CPU usage statistics */ #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ _Timestamp_Set_to_zero( &the_thread->cpu_time_used ); 10c0cc: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) 10c0d3: 00 00 00 10c0d6: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) 10c0dd: 00 00 00 _Thread_Stack_Free( the_thread ); return false; } 10c0e0: 8b 45 08 mov 0x8(%ebp),%eax 10c0e3: 8b 40 1c mov 0x1c(%eax),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 10c0e6: 0f b7 53 08 movzwl 0x8(%ebx),%edx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10c0ea: 89 1c 90 mov %ebx,(%eax,%edx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 10c0ed: 8b 45 30 mov 0x30(%ebp),%eax 10c0f0: 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 ); 10c0f3: 89 1c 24 mov %ebx,(%esp) 10c0f6: e8 c1 0a 00 00 call 10cbbc <_User_extensions_Thread_create> 10c0fb: 88 c2 mov %al,%dl if ( extension_status ) 10c0fd: 83 c4 10 add $0x10,%esp return true; 10c100: 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 ) 10c102: 84 d2 test %dl,%dl 10c104: 74 04 je 10c10a <_Thread_Initialize+0x1aa> 10c106: eb 72 jmp 10c17a <_Thread_Initialize+0x21a> * Zero out all the allocated memory fields */ for ( i=0 ; i <= THREAD_API_LAST ; i++ ) the_thread->API_Extensions[i] = NULL; extensions_area = NULL; 10c108: 31 f6 xor %esi,%esi extension_status = _User_extensions_Thread_create( the_thread ); if ( extension_status ) return true; failed: if ( the_thread->libc_reent ) 10c10a: 8b 83 f0 00 00 00 mov 0xf0(%ebx),%eax 10c110: 85 c0 test %eax,%eax 10c112: 74 0c je 10c120 <_Thread_Initialize+0x1c0> _Workspace_Free( the_thread->libc_reent ); 10c114: 83 ec 0c sub $0xc,%esp 10c117: 50 push %eax 10c118: e8 ce 0d 00 00 call 10ceeb <_Workspace_Free> 10c11d: 83 c4 10 add $0x10,%esp for ( i=0 ; i <= THREAD_API_LAST ; i++ ) if ( the_thread->API_Extensions[i] ) 10c120: 8b 83 f4 00 00 00 mov 0xf4(%ebx),%eax 10c126: 85 c0 test %eax,%eax 10c128: 74 0c je 10c136 <_Thread_Initialize+0x1d6> _Workspace_Free( the_thread->API_Extensions[i] ); 10c12a: 83 ec 0c sub $0xc,%esp 10c12d: 50 push %eax 10c12e: e8 b8 0d 00 00 call 10ceeb <_Workspace_Free> 10c133: 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] ) 10c136: 8b 83 f8 00 00 00 mov 0xf8(%ebx),%eax 10c13c: 85 c0 test %eax,%eax 10c13e: 74 0c je 10c14c <_Thread_Initialize+0x1ec> _Workspace_Free( the_thread->API_Extensions[i] ); 10c140: 83 ec 0c sub $0xc,%esp 10c143: 50 push %eax 10c144: e8 a2 0d 00 00 call 10ceeb <_Workspace_Free> 10c149: 83 c4 10 add $0x10,%esp if ( extensions_area ) 10c14c: 85 f6 test %esi,%esi 10c14e: 74 0c je 10c15c <_Thread_Initialize+0x1fc> (void) _Workspace_Free( extensions_area ); 10c150: 83 ec 0c sub $0xc,%esp 10c153: 56 push %esi 10c154: e8 92 0d 00 00 call 10ceeb <_Workspace_Free> 10c159: 83 c4 10 add $0x10,%esp #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 10c15c: 85 ff test %edi,%edi 10c15e: 74 0c je 10c16c <_Thread_Initialize+0x20c> (void) _Workspace_Free( fp_area ); 10c160: 83 ec 0c sub $0xc,%esp 10c163: 57 push %edi 10c164: e8 82 0d 00 00 call 10ceeb <_Workspace_Free> 10c169: 83 c4 10 add $0x10,%esp #endif _Thread_Stack_Free( the_thread ); 10c16c: 83 ec 0c sub $0xc,%esp 10c16f: 53 push %ebx 10c170: e8 e7 06 00 00 call 10c85c <_Thread_Stack_Free> return false; 10c175: 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 */ 10c178: 31 c0 xor %eax,%eax _Thread_Stack_Free( the_thread ); return false; } 10c17a: 8d 65 f4 lea -0xc(%ebp),%esp 10c17d: 5b pop %ebx 10c17e: 5e pop %esi 10c17f: 5f pop %edi 10c180: c9 leave 10c181: c3 ret =============================================================================== 0010f400 <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) { 10f400: 55 push %ebp 10f401: 89 e5 mov %esp,%ebp 10f403: 53 push %ebx 10f404: 8b 45 08 mov 0x8(%ebp),%eax ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10f407: 9c pushf 10f408: fa cli 10f409: 59 pop %ecx current_state = the_thread->current_state; 10f40a: 8b 50 10 mov 0x10(%eax),%edx if ( current_state & STATES_SUSPENDED ) { 10f40d: f6 c2 02 test $0x2,%dl 10f410: 74 70 je 10f482 <_Thread_Resume+0x82> <== NEVER TAKEN 10f412: 83 e2 fd and $0xfffffffd,%edx current_state = the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); 10f415: 89 50 10 mov %edx,0x10(%eax) if ( _States_Is_ready( current_state ) ) { 10f418: 85 d2 test %edx,%edx 10f41a: 75 66 jne 10f482 <_Thread_Resume+0x82> RTEMS_INLINE_ROUTINE void _Priority_bit_map_Add ( Priority_bit_map_Information *the_priority_map ) { *the_priority_map->minor |= the_priority_map->ready_minor; 10f41c: 8b 90 90 00 00 00 mov 0x90(%eax),%edx 10f422: 66 8b 98 96 00 00 00 mov 0x96(%eax),%bx 10f429: 66 09 1a or %bx,(%edx) _Priority_Major_bit_map |= the_priority_map->ready_major; 10f42c: 66 8b 15 50 74 12 00 mov 0x127450,%dx 10f433: 0b 90 94 00 00 00 or 0x94(%eax),%edx 10f439: 66 89 15 50 74 12 00 mov %dx,0x127450 _Priority_bit_map_Add( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10f440: 8b 90 8c 00 00 00 mov 0x8c(%eax),%edx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10f446: 8d 5a 04 lea 0x4(%edx),%ebx 10f449: 89 18 mov %ebx,(%eax) ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; 10f44b: 8b 5a 08 mov 0x8(%edx),%ebx the_chain->last = the_node; 10f44e: 89 42 08 mov %eax,0x8(%edx) old_last_node->next = the_node; 10f451: 89 03 mov %eax,(%ebx) the_node->previous = old_last_node; 10f453: 89 58 04 mov %ebx,0x4(%eax) _ISR_Flash( level ); 10f456: 51 push %ecx 10f457: 9d popf 10f458: fa cli if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 10f459: 8b 50 14 mov 0x14(%eax),%edx 10f45c: 8b 1d 00 79 12 00 mov 0x127900,%ebx 10f462: 3b 53 14 cmp 0x14(%ebx),%edx 10f465: 73 1b jae 10f482 <_Thread_Resume+0x82> _Thread_Heir = the_thread; 10f467: a3 00 79 12 00 mov %eax,0x127900 if ( _Thread_Executing->is_preemptible || 10f46c: a1 fc 78 12 00 mov 0x1278fc,%eax 10f471: 80 78 74 00 cmpb $0x0,0x74(%eax) 10f475: 75 04 jne 10f47b <_Thread_Resume+0x7b> 10f477: 85 d2 test %edx,%edx 10f479: 75 07 jne 10f482 <_Thread_Resume+0x82> <== ALWAYS TAKEN the_thread->current_priority == 0 ) _Thread_Dispatch_necessary = true; 10f47b: c6 05 08 79 12 00 01 movb $0x1,0x127908 } } } _ISR_Enable( level ); 10f482: 51 push %ecx 10f483: 9d popf } 10f484: 5b pop %ebx 10f485: c9 leave 10f486: c3 ret =============================================================================== 0010c944 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10c944: 55 push %ebp 10c945: 89 e5 mov %esp,%ebp 10c947: 53 push %ebx 10c948: 83 ec 04 sub $0x4,%esp Thread_Control *executing; executing = _Thread_Executing; 10c94b: 8b 1d 34 48 12 00 mov 0x124834,%ebx /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10c951: 80 7b 74 00 cmpb $0x0,0x74(%ebx) 10c955: 74 4c je 10c9a3 <_Thread_Tickle_timeslice+0x5f> return; if ( !_States_Is_ready( executing->current_state ) ) 10c957: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10c95b: 75 46 jne 10c9a3 <_Thread_Tickle_timeslice+0x5f> /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10c95d: 8b 43 7c mov 0x7c(%ebx),%eax 10c960: 83 f8 01 cmp $0x1,%eax 10c963: 72 3e jb 10c9a3 <_Thread_Tickle_timeslice+0x5f> 10c965: 83 f8 02 cmp $0x2,%eax 10c968: 76 07 jbe 10c971 <_Thread_Tickle_timeslice+0x2d> 10c96a: 83 f8 03 cmp $0x3,%eax 10c96d: 75 34 jne 10c9a3 <_Thread_Tickle_timeslice+0x5f><== NEVER TAKEN 10c96f: eb 1a jmp 10c98b <_Thread_Tickle_timeslice+0x47> 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 ) { 10c971: 8b 43 78 mov 0x78(%ebx),%eax 10c974: 48 dec %eax 10c975: 89 43 78 mov %eax,0x78(%ebx) 10c978: 85 c0 test %eax,%eax 10c97a: 7f 27 jg 10c9a3 <_Thread_Tickle_timeslice+0x5f> * at the priority of the currently executing thread, then the * 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. */ _Thread_Yield_processor(); 10c97c: e8 27 00 00 00 call 10c9a8 <_Thread_Yield_processor> executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c981: a1 b4 42 12 00 mov 0x1242b4,%eax 10c986: 89 43 78 mov %eax,0x78(%ebx) 10c989: eb 18 jmp 10c9a3 <_Thread_Tickle_timeslice+0x5f> } break; #if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 10c98b: 8b 43 78 mov 0x78(%ebx),%eax 10c98e: 48 dec %eax 10c98f: 89 43 78 mov %eax,0x78(%ebx) 10c992: 85 c0 test %eax,%eax 10c994: 75 0d jne 10c9a3 <_Thread_Tickle_timeslice+0x5f> (*executing->budget_callout)( executing ); 10c996: 83 ec 0c sub $0xc,%esp 10c999: 53 push %ebx 10c99a: ff 93 80 00 00 00 call *0x80(%ebx) 10c9a0: 83 c4 10 add $0x10,%esp break; #endif } } 10c9a3: 8b 5d fc mov -0x4(%ebp),%ebx 10c9a6: c9 leave 10c9a7: c3 ret =============================================================================== 0010c3e0 <_Thread_queue_Enqueue_priority>: Thread_blocking_operation_States _Thread_queue_Enqueue_priority ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) { 10c3e0: 55 push %ebp 10c3e1: 89 e5 mov %esp,%ebp 10c3e3: 57 push %edi 10c3e4: 56 push %esi 10c3e5: 53 push %ebx 10c3e6: 83 ec 14 sub $0x14,%esp 10c3e9: 8b 4d 08 mov 0x8(%ebp),%ecx 10c3ec: 8b 45 0c mov 0xc(%ebp),%eax 10c3ef: 8d 50 3c lea 0x3c(%eax),%edx 10c3f2: 89 50 38 mov %edx,0x38(%eax) RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); the_chain->permanent_null = NULL; 10c3f5: c7 40 3c 00 00 00 00 movl $0x0,0x3c(%eax) Chain_Node *previous_node; Chain_Node *search_node; Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); 10c3fc: 8d 50 38 lea 0x38(%eax),%edx 10c3ff: 89 50 40 mov %edx,0x40(%eax) priority = the_thread->current_priority; 10c402: 8b 58 14 mov 0x14(%eax),%ebx RTEMS_INLINE_ROUTINE uint32_t _Thread_queue_Header_number ( Priority_Control the_priority ) { return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER); 10c405: 89 df mov %ebx,%edi 10c407: c1 ef 06 shr $0x6,%edi header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 10c40a: 6b ff 0c imul $0xc,%edi,%edi 10c40d: 8d 3c 39 lea (%ecx,%edi,1),%edi 10c410: 89 7d ec mov %edi,-0x14(%ebp) block_state = the_thread_queue->state; 10c413: 8b 51 38 mov 0x38(%ecx),%edx 10c416: 89 55 e4 mov %edx,-0x1c(%ebp) restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 10c419: 89 7d e8 mov %edi,-0x18(%ebp) priority = the_thread->current_priority; header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; block_state = the_thread_queue->state; if ( _Thread_queue_Is_reverse_search( priority ) ) 10c41c: f6 c3 20 test $0x20,%bl 10c41f: 75 73 jne 10c494 <_Thread_queue_Enqueue_priority+0xb4> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10c421: 8d 77 04 lea 0x4(%edi),%esi 10c424: 89 75 e8 mov %esi,-0x18(%ebp) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 10c427: 9c pushf 10c428: fa cli 10c429: 8f 45 f0 popl -0x10(%ebp) 10c42c: 8b 75 f0 mov -0x10(%ebp),%esi search_thread = (Thread_Control *) header->first; 10c42f: 8b 17 mov (%edi),%edx if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; 10c431: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp) 10c438: 89 75 e0 mov %esi,-0x20(%ebp) _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c43b: eb 1f jmp 10c45c <_Thread_queue_Enqueue_priority+0x7c> search_priority = search_thread->current_priority; 10c43d: 8b 72 14 mov 0x14(%edx),%esi 10c440: 89 75 ec mov %esi,-0x14(%ebp) if ( priority <= search_priority ) 10c443: 39 f3 cmp %esi,%ebx 10c445: 76 1a jbe 10c461 <_Thread_queue_Enqueue_priority+0x81> break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10c447: ff 75 f0 pushl -0x10(%ebp) 10c44a: 9d popf 10c44b: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c44c: 8b 75 e4 mov -0x1c(%ebp),%esi 10c44f: 85 72 10 test %esi,0x10(%edx) 10c452: 75 06 jne 10c45a <_Thread_queue_Enqueue_priority+0x7a><== ALWAYS TAKEN _ISR_Enable( level ); 10c454: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10c457: 9d popf <== NOT EXECUTED goto restart_forward_search; 10c458: eb cd jmp 10c427 <_Thread_queue_Enqueue_priority+0x47><== NOT EXECUTED } search_thread = (Thread_Control *)search_thread->Object.Node.next; 10c45a: 8b 12 mov (%edx),%edx restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c45c: 3b 55 e8 cmp -0x18(%ebp),%edx 10c45f: 75 dc jne 10c43d <_Thread_queue_Enqueue_priority+0x5d> 10c461: 8b 75 e0 mov -0x20(%ebp),%esi } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10c464: 83 79 30 01 cmpl $0x1,0x30(%ecx) 10c468: 0f 85 ae 00 00 00 jne 10c51c <_Thread_queue_Enqueue_priority+0x13c> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c46e: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) if ( priority == search_priority ) 10c475: 3b 5d ec cmp -0x14(%ebp),%ebx 10c478: 0f 84 87 00 00 00 je 10c505 <_Thread_queue_Enqueue_priority+0x125> goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10c47e: 8b 5a 04 mov 0x4(%edx),%ebx the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c481: 89 10 mov %edx,(%eax) the_node->previous = previous_node; 10c483: 89 58 04 mov %ebx,0x4(%eax) previous_node->next = the_node; 10c486: 89 03 mov %eax,(%ebx) search_node->previous = the_node; 10c488: 89 42 04 mov %eax,0x4(%edx) the_thread->Wait.queue = the_thread_queue; 10c48b: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c48e: ff 75 f0 pushl -0x10(%ebp) 10c491: 9d popf 10c492: eb 6a jmp 10c4fe <_Thread_queue_Enqueue_priority+0x11e> return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 10c494: 0f b6 3d f4 01 12 00 movzbl 0x1201f4,%edi 10c49b: 47 inc %edi 10c49c: 89 7d e0 mov %edi,-0x20(%ebp) _ISR_Disable( level ); 10c49f: 9c pushf 10c4a0: fa cli 10c4a1: 8f 45 f0 popl -0x10(%ebp) 10c4a4: 8b 75 f0 mov -0x10(%ebp),%esi search_thread = (Thread_Control *) header->last; 10c4a7: 8b 7d e8 mov -0x18(%ebp),%edi 10c4aa: 8b 57 08 mov 0x8(%edi),%edx 10c4ad: 8b 7d e0 mov -0x20(%ebp),%edi 10c4b0: 89 75 e0 mov %esi,-0x20(%ebp) while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c4b3: eb 1d jmp 10c4d2 <_Thread_queue_Enqueue_priority+0xf2> search_priority = search_thread->current_priority; 10c4b5: 8b 7a 14 mov 0x14(%edx),%edi if ( priority >= search_priority ) 10c4b8: 39 fb cmp %edi,%ebx 10c4ba: 73 1b jae 10c4d7 <_Thread_queue_Enqueue_priority+0xf7> break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 10c4bc: ff 75 f0 pushl -0x10(%ebp) 10c4bf: 9d popf 10c4c0: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c4c1: 8b 75 e4 mov -0x1c(%ebp),%esi 10c4c4: 85 72 10 test %esi,0x10(%edx) 10c4c7: 75 06 jne 10c4cf <_Thread_queue_Enqueue_priority+0xef> _ISR_Enable( level ); 10c4c9: ff 75 f0 pushl -0x10(%ebp) 10c4cc: 9d popf goto restart_reverse_search; 10c4cd: eb c5 jmp 10c494 <_Thread_queue_Enqueue_priority+0xb4> } search_thread = (Thread_Control *) search_thread->Object.Node.previous; 10c4cf: 8b 52 04 mov 0x4(%edx),%edx restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c4d2: 3b 55 ec cmp -0x14(%ebp),%edx 10c4d5: 75 de jne 10c4b5 <_Thread_queue_Enqueue_priority+0xd5> 10c4d7: 8b 75 e0 mov -0x20(%ebp),%esi } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10c4da: 83 79 30 01 cmpl $0x1,0x30(%ecx) 10c4de: 75 3c jne 10c51c <_Thread_queue_Enqueue_priority+0x13c> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c4e0: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) if ( priority == search_priority ) 10c4e7: 39 fb cmp %edi,%ebx 10c4e9: 74 1a je 10c505 <_Thread_queue_Enqueue_priority+0x125> goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10c4eb: 8b 1a mov (%edx),%ebx the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10c4ed: 89 18 mov %ebx,(%eax) the_node->previous = search_node; 10c4ef: 89 50 04 mov %edx,0x4(%eax) search_node->next = the_node; 10c4f2: 89 02 mov %eax,(%edx) next_node->previous = the_node; 10c4f4: 89 43 04 mov %eax,0x4(%ebx) the_thread->Wait.queue = the_thread_queue; 10c4f7: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c4fa: ff 75 f0 pushl -0x10(%ebp) 10c4fd: 9d popf return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10c4fe: b8 01 00 00 00 mov $0x1,%eax 10c503: eb 1f jmp 10c524 <_Thread_queue_Enqueue_priority+0x144> 10c505: 83 c2 3c add $0x3c,%edx equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 10c508: 8b 5a 04 mov 0x4(%edx),%ebx the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c50b: 89 10 mov %edx,(%eax) the_node->previous = previous_node; 10c50d: 89 58 04 mov %ebx,0x4(%eax) previous_node->next = the_node; 10c510: 89 03 mov %eax,(%ebx) search_node->previous = the_node; 10c512: 89 42 04 mov %eax,0x4(%edx) the_thread->Wait.queue = the_thread_queue; 10c515: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c518: 56 push %esi 10c519: 9d popf 10c51a: eb e2 jmp 10c4fe <_Thread_queue_Enqueue_priority+0x11e> * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; 10c51c: 8b 45 10 mov 0x10(%ebp),%eax 10c51f: 89 30 mov %esi,(%eax) return the_thread_queue->sync_state; 10c521: 8b 41 30 mov 0x30(%ecx),%eax } 10c524: 83 c4 14 add $0x14,%esp 10c527: 5b pop %ebx 10c528: 5e pop %esi 10c529: 5f pop %edi 10c52a: c9 leave 10c52b: c3 ret =============================================================================== 0010c5d8 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10c5d8: 55 push %ebp 10c5d9: 89 e5 mov %esp,%ebp 10c5db: 57 push %edi 10c5dc: 56 push %esi 10c5dd: 53 push %ebx 10c5de: 83 ec 1c sub $0x1c,%esp 10c5e1: 8b 75 08 mov 0x8(%ebp),%esi 10c5e4: 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 ) 10c5e7: 85 f6 test %esi,%esi 10c5e9: 74 36 je 10c621 <_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 ) { 10c5eb: 83 7e 34 01 cmpl $0x1,0x34(%esi) 10c5ef: 75 30 jne 10c621 <_Thread_queue_Requeue+0x49><== NEVER TAKEN Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10c5f1: 9c pushf 10c5f2: fa cli 10c5f3: 5b pop %ebx if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10c5f4: f7 47 10 e0 be 03 00 testl $0x3bee0,0x10(%edi) 10c5fb: 74 22 je 10c61f <_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; 10c5fd: 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 ); 10c604: 50 push %eax 10c605: 6a 01 push $0x1 10c607: 57 push %edi 10c608: 56 push %esi 10c609: e8 82 32 00 00 call 10f890 <_Thread_queue_Extract_priority_helper> (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10c60e: 83 c4 0c add $0xc,%esp 10c611: 8d 45 e4 lea -0x1c(%ebp),%eax 10c614: 50 push %eax 10c615: 57 push %edi 10c616: 56 push %esi 10c617: e8 c4 fd ff ff call 10c3e0 <_Thread_queue_Enqueue_priority> 10c61c: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10c61f: 53 push %ebx 10c620: 9d popf } } 10c621: 8d 65 f4 lea -0xc(%ebp),%esp 10c624: 5b pop %ebx 10c625: 5e pop %esi 10c626: 5f pop %edi 10c627: c9 leave 10c628: c3 ret =============================================================================== 0010c62c <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored __attribute__((unused)) ) { 10c62c: 55 push %ebp 10c62d: 89 e5 mov %esp,%ebp 10c62f: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10c632: 8d 45 f4 lea -0xc(%ebp),%eax 10c635: 50 push %eax 10c636: ff 75 08 pushl 0x8(%ebp) 10c639: e8 b2 f8 ff ff call 10bef0 <_Thread_Get> switch ( location ) { 10c63e: 83 c4 10 add $0x10,%esp 10c641: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10c645: 75 17 jne 10c65e <_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 ); 10c647: 83 ec 0c sub $0xc,%esp 10c64a: 50 push %eax 10c64b: e8 f4 32 00 00 call 10f944 <_Thread_queue_Process_timeout> */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10c650: a1 e4 42 12 00 mov 0x1242e4,%eax 10c655: 48 dec %eax 10c656: a3 e4 42 12 00 mov %eax,0x1242e4 10c65b: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10c65e: c9 leave 10c65f: c3 ret =============================================================================== 0011696c <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 11696c: 55 push %ebp 11696d: 89 e5 mov %esp,%ebp 11696f: 57 push %edi 116970: 56 push %esi 116971: 53 push %ebx 116972: 83 ec 4c sub $0x4c,%esp 116975: 8b 5d 08 mov 0x8(%ebp),%ebx 116978: 8d 45 dc lea -0x24(%ebp),%eax 11697b: 8d 55 e0 lea -0x20(%ebp),%edx 11697e: 89 55 b4 mov %edx,-0x4c(%ebp) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 116981: 89 55 dc mov %edx,-0x24(%ebp) the_chain->permanent_null = NULL; 116984: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) Timer_server_Control *ts = (Timer_server_Control *) arg; Chain_Control insert_chain; Chain_Control fire_chain; _Chain_Initialize_empty( &insert_chain ); 11698b: 89 45 e4 mov %eax,-0x1c(%ebp) */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 11698e: 8d 7d d0 lea -0x30(%ebp),%edi 116991: 8d 55 d4 lea -0x2c(%ebp),%edx 116994: 89 55 b0 mov %edx,-0x50(%ebp) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 116997: 89 55 d0 mov %edx,-0x30(%ebp) the_chain->permanent_null = NULL; 11699a: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) the_chain->last = _Chain_Head(the_chain); 1169a1: 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 ); 1169a4: 8d 43 30 lea 0x30(%ebx),%eax 1169a7: 89 45 c0 mov %eax,-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 ); 1169aa: 8d 73 68 lea 0x68(%ebx),%esi static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 1169ad: 8d 53 08 lea 0x8(%ebx),%edx 1169b0: 89 55 bc mov %edx,-0x44(%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; 1169b3: 8d 4d dc lea -0x24(%ebp),%ecx 1169b6: 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; 1169b9: a1 f0 d7 13 00 mov 0x13d7f0,%eax /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 1169be: 8b 53 3c mov 0x3c(%ebx),%edx watchdogs->last_snapshot = snapshot; 1169c1: 89 43 3c mov %eax,0x3c(%ebx) _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1169c4: 51 push %ecx 1169c5: 8d 4d d0 lea -0x30(%ebp),%ecx 1169c8: 51 push %ecx 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 a0 39 00 00 call 11a374 <_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 44 d7 13 00 mov 0x13d744,%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 13 jbe 1169fa <_Timer_server_Body+0x8e> /* * 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: 8d 55 d0 lea -0x30(%ebp),%edx 1169eb: 52 push %edx if ( snapshot > last_snapshot ) { /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ delta = snapshot - last_snapshot; 1169ec: 8b 4d c4 mov -0x3c(%ebp),%ecx 1169ef: 29 c1 sub %eax,%ecx _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1169f1: 51 push %ecx 1169f2: 56 push %esi 1169f3: e8 7c 39 00 00 call 11a374 <_Watchdog_Adjust_to_chain> 1169f8: eb 0f jmp 116a09 <_Timer_server_Body+0x9d> } else if ( snapshot < last_snapshot ) { 1169fa: 73 10 jae 116a0c <_Timer_server_Body+0xa0> /* * 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 ); 1169fc: 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; 1169fd: 2b 45 c4 sub -0x3c(%ebp),%eax _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 116a00: 50 push %eax 116a01: 6a 01 push $0x1 116a03: 56 push %esi 116a04: e8 ff 38 00 00 call 11a308 <_Watchdog_Adjust> 116a09: 83 c4 10 add $0x10,%esp } watchdogs->last_snapshot = snapshot; 116a0c: 8b 45 c4 mov -0x3c(%ebp),%eax 116a0f: 89 43 74 mov %eax,0x74(%ebx) } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 116a12: 8b 43 78 mov 0x78(%ebx),%eax 116a15: 83 ec 0c sub $0xc,%esp 116a18: 50 push %eax 116a19: e8 ea 08 00 00 call 117308 <_Chain_Get> if ( timer == NULL ) { 116a1e: 83 c4 10 add $0x10,%esp 116a21: 85 c0 test %eax,%eax 116a23: 74 29 je 116a4e <_Timer_server_Body+0xe2> static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 116a25: 8b 50 38 mov 0x38(%eax),%edx 116a28: 83 fa 01 cmp $0x1,%edx 116a2b: 75 0b jne 116a38 <_Timer_server_Body+0xcc> _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116a2d: 52 push %edx 116a2e: 52 push %edx 116a2f: 83 c0 10 add $0x10,%eax 116a32: 50 push %eax 116a33: ff 75 c0 pushl -0x40(%ebp) 116a36: eb 0c jmp 116a44 <_Timer_server_Body+0xd8> } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116a38: 83 fa 03 cmp $0x3,%edx 116a3b: 75 d5 jne 116a12 <_Timer_server_Body+0xa6><== NEVER TAKEN _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116a3d: 51 push %ecx 116a3e: 51 push %ecx 116a3f: 83 c0 10 add $0x10,%eax 116a42: 50 push %eax 116a43: 56 push %esi 116a44: e8 b3 39 00 00 call 11a3fc <_Watchdog_Insert> 116a49: 83 c4 10 add $0x10,%esp 116a4c: eb c4 jmp 116a12 <_Timer_server_Body+0xa6> * of zero it will be processed in the next iteration of the timer server * body loop. */ _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); 116a4e: 9c pushf 116a4f: fa cli 116a50: 5a pop %edx tmp = ts->insert_chain; 116a51: 8b 43 78 mov 0x78(%ebx),%eax if ( _Chain_Is_empty( insert_chain ) ) { 116a54: b0 01 mov $0x1,%al 116a56: 8b 4d b4 mov -0x4c(%ebp),%ecx 116a59: 39 4d dc cmp %ecx,-0x24(%ebp) 116a5c: 75 09 jne 116a67 <_Timer_server_Body+0xfb> ts->insert_chain = NULL; 116a5e: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx) do_loop = false; 116a65: 31 c0 xor %eax,%eax } _ISR_Enable( level ); 116a67: 52 push %edx 116a68: 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 ) { 116a69: 84 c0 test %al,%al 116a6b: 0f 85 48 ff ff ff jne 1169b9 <_Timer_server_Body+0x4d> _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: 8b 45 b0 mov -0x50(%ebp),%eax 116a74: 39 45 d0 cmp %eax,-0x30(%ebp) 116a77: 74 37 je 116ab0 <_Timer_server_Body+0x144> /* * 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: 5a pop %edx */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 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+0x13d> { Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; 116a84: 8b 08 mov (%eax),%ecx the_chain->first = new_first; 116a86: 89 4d d0 mov %ecx,-0x30(%ebp) new_first->previous = _Chain_Head(the_chain); 116a89: 89 79 04 mov %edi,0x4(%ecx) 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+0x13d><== NEVER TAKEN watchdog->state = WATCHDOG_INACTIVE; 116a90: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) _ISR_Enable( level ); 116a97: 52 push %edx 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+0x10d> watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; _ISR_Enable( level ); } else { _ISR_Enable( level ); 116aa9: 52 push %edx 116aaa: 9d popf 116aab: e9 03 ff ff ff jmp 1169b3 <_Timer_server_Body+0x47> * 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 17 fe ff ff call 1168d0 <_Thread_Disable_dispatch> _Thread_Set_state( ts->thread, STATES_DELAYING ); 116ab9: 50 push %eax 116aba: 50 push %eax 116abb: 6a 08 push $0x8 116abd: ff 33 pushl (%ebx) 116abf: e8 18 31 00 00 call 119bdc <_Thread_Set_state> _Timer_server_Reset_interval_system_watchdog( ts ); 116ac4: 89 d8 mov %ebx,%eax 116ac6: e8 15 fe ff ff call 1168e0 <_Timer_server_Reset_interval_system_watchdog> _Timer_server_Reset_tod_system_watchdog( ts ); 116acb: 89 d8 mov %ebx,%eax 116acd: e8 54 fe ff ff call 116926 <_Timer_server_Reset_tod_system_watchdog> _Thread_Enable_dispatch(); 116ad2: e8 ff 27 00 00 call 1192d6 <_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: 59 pop %ecx 116adc: ff 75 bc pushl -0x44(%ebp) 116adf: e8 30 3a 00 00 call 11a514 <_Watchdog_Remove> static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 116ae4: 8d 43 40 lea 0x40(%ebx),%eax 116ae7: 89 04 24 mov %eax,(%esp) 116aea: e8 25 3a 00 00 call 11a514 <_Watchdog_Remove> 116aef: 83 c4 10 add $0x10,%esp 116af2: e9 bc fe ff ff jmp 1169b3 <_Timer_server_Body+0x47> =============================================================================== 00116af7 <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 116af7: 55 push %ebp 116af8: 89 e5 mov %esp,%ebp 116afa: 57 push %edi 116afb: 56 push %esi 116afc: 53 push %ebx 116afd: 83 ec 2c sub $0x2c,%esp 116b00: 8b 5d 08 mov 0x8(%ebp),%ebx 116b03: 8b 75 0c mov 0xc(%ebp),%esi if ( ts->insert_chain == NULL ) { 116b06: 8b 43 78 mov 0x78(%ebx),%eax 116b09: 85 c0 test %eax,%eax 116b0b: 0f 85 de 00 00 00 jne 116bef <_Timer_server_Schedule_operation_method+0xf8> * 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(); 116b11: e8 ba fd ff ff call 1168d0 <_Thread_Disable_dispatch> if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 116b16: 8b 46 38 mov 0x38(%esi),%eax 116b19: 83 f8 01 cmp $0x1,%eax 116b1c: 75 5a jne 116b78 <_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 ); 116b1e: 9c pushf 116b1f: fa cli 116b20: 8f 45 e0 popl -0x20(%ebp) snapshot = _Watchdog_Ticks_since_boot; 116b23: 8b 15 f0 d7 13 00 mov 0x13d7f0,%edx last_snapshot = ts->Interval_watchdogs.last_snapshot; 116b29: 8b 4b 3c mov 0x3c(%ebx),%ecx */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 116b2c: 8b 43 30 mov 0x30(%ebx),%eax */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 116b2f: 8d 7b 34 lea 0x34(%ebx),%edi if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) { 116b32: 39 f8 cmp %edi,%eax 116b34: 74 19 je 116b4f <_Timer_server_Schedule_operation_method+0x58> first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain ); /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; 116b36: 89 d7 mov %edx,%edi 116b38: 29 cf sub %ecx,%edi 116b3a: 89 7d e4 mov %edi,-0x1c(%ebp) delta_interval = first_watchdog->delta_interval; 116b3d: 8b 78 10 mov 0x10(%eax),%edi if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 116b40: 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) { 116b42: 3b 7d e4 cmp -0x1c(%ebp),%edi 116b45: 76 05 jbe 116b4c <_Timer_server_Schedule_operation_method+0x55> delta_interval -= delta; 116b47: 89 f9 mov %edi,%ecx 116b49: 2b 4d e4 sub -0x1c(%ebp),%ecx } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 116b4c: 89 48 10 mov %ecx,0x10(%eax) } ts->Interval_watchdogs.last_snapshot = snapshot; 116b4f: 89 53 3c mov %edx,0x3c(%ebx) _ISR_Enable( level ); 116b52: ff 75 e0 pushl -0x20(%ebp) 116b55: 9d popf _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116b56: 50 push %eax 116b57: 50 push %eax 116b58: 83 c6 10 add $0x10,%esi 116b5b: 56 push %esi 116b5c: 8d 43 30 lea 0x30(%ebx),%eax 116b5f: 50 push %eax 116b60: e8 97 38 00 00 call 11a3fc <_Watchdog_Insert> if ( !ts->active ) { 116b65: 8a 43 7c mov 0x7c(%ebx),%al 116b68: 83 c4 10 add $0x10,%esp 116b6b: 84 c0 test %al,%al 116b6d: 75 74 jne 116be3 <_Timer_server_Schedule_operation_method+0xec> _Timer_server_Reset_interval_system_watchdog( ts ); 116b6f: 89 d8 mov %ebx,%eax 116b71: e8 6a fd ff ff call 1168e0 <_Timer_server_Reset_interval_system_watchdog> 116b76: eb 6b jmp 116be3 <_Timer_server_Schedule_operation_method+0xec> } } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116b78: 83 f8 03 cmp $0x3,%eax 116b7b: 75 66 jne 116be3 <_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 ); 116b7d: 9c pushf 116b7e: fa cli 116b7f: 8f 45 e0 popl -0x20(%ebp) snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 116b82: 8b 15 44 d7 13 00 mov 0x13d744,%edx last_snapshot = ts->TOD_watchdogs.last_snapshot; 116b88: 8b 43 74 mov 0x74(%ebx),%eax */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 116b8b: 8b 4b 68 mov 0x68(%ebx),%ecx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 116b8e: 8d 7b 6c lea 0x6c(%ebx),%edi if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { 116b91: 39 f9 cmp %edi,%ecx 116b93: 74 27 je 116bbc <_Timer_server_Schedule_operation_method+0xc5> first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 116b95: 8b 79 10 mov 0x10(%ecx),%edi 116b98: 89 7d d4 mov %edi,-0x2c(%ebp) if ( snapshot > last_snapshot ) { 116b9b: 39 c2 cmp %eax,%edx 116b9d: 76 15 jbe 116bb4 <_Timer_server_Schedule_operation_method+0xbd> /* * We advanced in time. */ delta = snapshot - last_snapshot; 116b9f: 89 d7 mov %edx,%edi 116ba1: 29 c7 sub %eax,%edi 116ba3: 89 7d e4 mov %edi,-0x1c(%ebp) if (delta_interval > delta) { delta_interval -= delta; } else { delta_interval = 0; 116ba6: 31 c0 xor %eax,%eax if ( snapshot > last_snapshot ) { /* * We advanced in time. */ delta = snapshot - last_snapshot; if (delta_interval > delta) { 116ba8: 39 7d d4 cmp %edi,-0x2c(%ebp) 116bab: 76 0c jbe 116bb9 <_Timer_server_Schedule_operation_method+0xc2><== NEVER TAKEN delta_interval -= delta; 116bad: 8b 45 d4 mov -0x2c(%ebp),%eax 116bb0: 29 f8 sub %edi,%eax 116bb2: eb 05 jmp 116bb9 <_Timer_server_Schedule_operation_method+0xc2> } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 116bb4: 03 45 d4 add -0x2c(%ebp),%eax delta_interval += delta; 116bb7: 29 d0 sub %edx,%eax } first_watchdog->delta_interval = delta_interval; 116bb9: 89 41 10 mov %eax,0x10(%ecx) } ts->TOD_watchdogs.last_snapshot = snapshot; 116bbc: 89 53 74 mov %edx,0x74(%ebx) _ISR_Enable( level ); 116bbf: ff 75 e0 pushl -0x20(%ebp) 116bc2: 9d popf _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116bc3: 57 push %edi 116bc4: 57 push %edi 116bc5: 83 c6 10 add $0x10,%esi 116bc8: 56 push %esi 116bc9: 8d 43 68 lea 0x68(%ebx),%eax 116bcc: 50 push %eax 116bcd: e8 2a 38 00 00 call 11a3fc <_Watchdog_Insert> if ( !ts->active ) { 116bd2: 8a 43 7c mov 0x7c(%ebx),%al 116bd5: 83 c4 10 add $0x10,%esp 116bd8: 84 c0 test %al,%al 116bda: 75 07 jne 116be3 <_Timer_server_Schedule_operation_method+0xec> _Timer_server_Reset_tod_system_watchdog( ts ); 116bdc: 89 d8 mov %ebx,%eax 116bde: e8 43 fd ff ff call 116926 <_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 ); } } 116be3: 8d 65 f4 lea -0xc(%ebp),%esp 116be6: 5b pop %ebx 116be7: 5e pop %esi 116be8: 5f pop %edi 116be9: c9 leave if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 116bea: e9 e7 26 00 00 jmp 1192d6 <_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 ); 116bef: 8b 43 78 mov 0x78(%ebx),%eax 116bf2: 89 75 0c mov %esi,0xc(%ebp) 116bf5: 89 45 08 mov %eax,0x8(%ebp) } } 116bf8: 8d 65 f4 lea -0xc(%ebp),%esp 116bfb: 5b pop %ebx 116bfc: 5e pop %esi 116bfd: 5f pop %edi 116bfe: c9 leave * 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 ); 116bff: e9 c8 06 00 00 jmp 1172cc <_Chain_Append> =============================================================================== 0010cb7f <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10cb7f: 55 push %ebp 10cb80: 89 e5 mov %esp,%ebp 10cb82: 57 push %edi 10cb83: 56 push %esi 10cb84: 53 push %ebx 10cb85: 83 ec 0c sub $0xc,%esp 10cb88: 8b 7d 10 mov 0x10(%ebp),%edi Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10cb8b: 8b 1d e0 44 12 00 mov 0x1244e0,%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 ); 10cb91: 0f b6 75 0c movzbl 0xc(%ebp),%esi ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10cb95: eb 15 jmp 10cbac <_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 ) 10cb97: 8b 43 30 mov 0x30(%ebx),%eax 10cb9a: 85 c0 test %eax,%eax 10cb9c: 74 0b je 10cba9 <_User_extensions_Fatal+0x2a> (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10cb9e: 52 push %edx 10cb9f: 57 push %edi 10cba0: 56 push %esi 10cba1: ff 75 08 pushl 0x8(%ebp) 10cba4: ff d0 call *%eax 10cba6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 10cba9: 8b 5b 04 mov 0x4(%ebx),%ebx ) { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10cbac: 81 fb d8 44 12 00 cmp $0x1244d8,%ebx 10cbb2: 75 e3 jne 10cb97 <_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 ); } } 10cbb4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cbb7: 5b pop %ebx <== NOT EXECUTED 10cbb8: 5e pop %esi <== NOT EXECUTED 10cbb9: 5f pop %edi <== NOT EXECUTED 10cbba: c9 leave <== NOT EXECUTED 10cbbb: c3 ret <== NOT EXECUTED =============================================================================== 0010ca68 <_User_extensions_Handler_initialization>: #include #include #include void _User_extensions_Handler_initialization(void) { 10ca68: 55 push %ebp 10ca69: 89 e5 mov %esp,%ebp 10ca6b: 57 push %edi 10ca6c: 56 push %esi 10ca6d: 53 push %ebx 10ca6e: 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; 10ca71: a1 30 02 12 00 mov 0x120230,%eax 10ca76: 89 45 e4 mov %eax,-0x1c(%ebp) initial_extensions = Configuration.User_extension_table; 10ca79: 8b 35 34 02 12 00 mov 0x120234,%esi */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 10ca7f: c7 05 d8 44 12 00 dc movl $0x1244dc,0x1244d8 10ca86: 44 12 00 the_chain->permanent_null = NULL; 10ca89: c7 05 dc 44 12 00 00 movl $0x0,0x1244dc 10ca90: 00 00 00 the_chain->last = _Chain_Head(the_chain); 10ca93: c7 05 e0 44 12 00 d8 movl $0x1244d8,0x1244e0 10ca9a: 44 12 00 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 10ca9d: c7 05 e8 42 12 00 ec movl $0x1242ec,0x1242e8 10caa4: 42 12 00 the_chain->permanent_null = NULL; 10caa7: c7 05 ec 42 12 00 00 movl $0x0,0x1242ec 10caae: 00 00 00 the_chain->last = _Chain_Head(the_chain); 10cab1: c7 05 f0 42 12 00 e8 movl $0x1242e8,0x1242f0 10cab8: 42 12 00 _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10cabb: 85 f6 test %esi,%esi 10cabd: 74 53 je 10cb12 <_User_extensions_Handler_initialization+0xaa><== NEVER TAKEN extension = (User_extensions_Control *) _Workspace_Allocate_or_fatal_error( 10cabf: 6b c8 34 imul $0x34,%eax,%ecx 10cac2: 83 ec 0c sub $0xc,%esp 10cac5: 51 push %ecx 10cac6: 89 4d e0 mov %ecx,-0x20(%ebp) 10cac9: e8 32 04 00 00 call 10cf00 <_Workspace_Allocate_or_fatal_error> 10cace: 89 c3 mov %eax,%ebx number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10cad0: 31 c0 xor %eax,%eax 10cad2: 8b 4d e0 mov -0x20(%ebp),%ecx 10cad5: 89 df mov %ebx,%edi 10cad7: f3 aa rep stos %al,%es:(%edi) 10cad9: 89 f0 mov %esi,%eax extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10cadb: 83 c4 10 add $0x10,%esp 10cade: 31 d2 xor %edx,%edx 10cae0: eb 2b jmp 10cb0d <_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; 10cae2: 8d 7b 14 lea 0x14(%ebx),%edi 10cae5: 89 c6 mov %eax,%esi 10cae7: b9 08 00 00 00 mov $0x8,%ecx 10caec: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _User_extensions_Add_set( extension ); 10caee: 83 ec 0c sub $0xc,%esp 10caf1: 53 push %ebx 10caf2: 89 45 dc mov %eax,-0x24(%ebp) 10caf5: 89 55 e0 mov %edx,-0x20(%ebp) 10caf8: e8 43 30 00 00 call 10fb40 <_User_extensions_Add_set> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; 10cafd: 83 c3 34 add $0x34,%ebx extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10cb00: 8b 55 e0 mov -0x20(%ebp),%edx 10cb03: 42 inc %edx 10cb04: 8b 45 dc mov -0x24(%ebp),%eax 10cb07: 83 c0 20 add $0x20,%eax 10cb0a: 83 c4 10 add $0x10,%esp 10cb0d: 3b 55 e4 cmp -0x1c(%ebp),%edx 10cb10: 72 d0 jb 10cae2 <_User_extensions_Handler_initialization+0x7a> _User_extensions_Add_set_with_table (extension, &initial_extensions[i]); extension++; } } } 10cb12: 8d 65 f4 lea -0xc(%ebp),%esp 10cb15: 5b pop %ebx 10cb16: 5e pop %esi 10cb17: 5f pop %edi 10cb18: c9 leave 10cb19: c3 ret =============================================================================== 0010e4b0 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10e4b0: 55 push %ebp 10e4b1: 89 e5 mov %esp,%ebp 10e4b3: 57 push %edi 10e4b4: 56 push %esi 10e4b5: 53 push %ebx 10e4b6: 83 ec 1c sub $0x1c,%esp 10e4b9: 8b 75 08 mov 0x8(%ebp),%esi 10e4bc: 8b 7d 0c mov 0xc(%ebp),%edi 10e4bf: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 10e4c2: 9c pushf 10e4c3: fa cli 10e4c4: 58 pop %eax */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 10e4c5: 8b 16 mov (%esi),%edx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10e4c7: 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 ) ) { 10e4ca: 39 ca cmp %ecx,%edx 10e4cc: 74 44 je 10e512 <_Watchdog_Adjust+0x62> switch ( direction ) { 10e4ce: 85 ff test %edi,%edi 10e4d0: 74 3c je 10e50e <_Watchdog_Adjust+0x5e> 10e4d2: 4f dec %edi 10e4d3: 75 3d jne 10e512 <_Watchdog_Adjust+0x62> <== NEVER TAKEN case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10e4d5: 01 5a 10 add %ebx,0x10(%edx) break; 10e4d8: eb 38 jmp 10e512 <_Watchdog_Adjust+0x62> RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First( Chain_Control *header ) { return ( (Watchdog_Control *) header->first ); 10e4da: 8b 16 mov (%esi),%edx case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 10e4dc: 8b 7a 10 mov 0x10(%edx),%edi 10e4df: 39 fb cmp %edi,%ebx 10e4e1: 73 07 jae 10e4ea <_Watchdog_Adjust+0x3a> _Watchdog_First( header )->delta_interval -= units; 10e4e3: 29 df sub %ebx,%edi 10e4e5: 89 7a 10 mov %edi,0x10(%edx) break; 10e4e8: eb 28 jmp 10e512 <_Watchdog_Adjust+0x62> } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 10e4ea: c7 42 10 01 00 00 00 movl $0x1,0x10(%edx) _ISR_Enable( level ); 10e4f1: 50 push %eax 10e4f2: 9d popf _Watchdog_Tickle( header ); 10e4f3: 83 ec 0c sub $0xc,%esp 10e4f6: 56 push %esi 10e4f7: 89 4d e4 mov %ecx,-0x1c(%ebp) 10e4fa: e8 9d 01 00 00 call 10e69c <_Watchdog_Tickle> _ISR_Disable( level ); 10e4ff: 9c pushf 10e500: fa cli 10e501: 58 pop %eax if ( _Chain_Is_empty( header ) ) 10e502: 83 c4 10 add $0x10,%esp 10e505: 8b 4d e4 mov -0x1c(%ebp),%ecx 10e508: 39 0e cmp %ecx,(%esi) 10e50a: 74 06 je 10e512 <_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; 10e50c: 29 fb sub %edi,%ebx switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10e50e: 85 db test %ebx,%ebx 10e510: 75 c8 jne 10e4da <_Watchdog_Adjust+0x2a> <== ALWAYS TAKEN } break; } } _ISR_Enable( level ); 10e512: 50 push %eax 10e513: 9d popf } 10e514: 8d 65 f4 lea -0xc(%ebp),%esp 10e517: 5b pop %ebx 10e518: 5e pop %esi 10e519: 5f pop %edi 10e51a: c9 leave 10e51b: c3 ret =============================================================================== 0010cdb8 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10cdb8: 55 push %ebp 10cdb9: 89 e5 mov %esp,%ebp 10cdbb: 56 push %esi 10cdbc: 53 push %ebx 10cdbd: 8b 55 08 mov 0x8(%ebp),%edx ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10cdc0: 9c pushf 10cdc1: fa cli 10cdc2: 5e pop %esi previous_state = the_watchdog->state; 10cdc3: 8b 42 08 mov 0x8(%edx),%eax switch ( previous_state ) { 10cdc6: 83 f8 01 cmp $0x1,%eax 10cdc9: 74 09 je 10cdd4 <_Watchdog_Remove+0x1c> 10cdcb: 72 42 jb 10ce0f <_Watchdog_Remove+0x57> 10cdcd: 83 f8 03 cmp $0x3,%eax 10cdd0: 77 3d ja 10ce0f <_Watchdog_Remove+0x57> <== NEVER TAKEN 10cdd2: eb 09 jmp 10cddd <_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; 10cdd4: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) break; 10cddb: eb 32 jmp 10ce0f <_Watchdog_Remove+0x57> case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10cddd: 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 ); } 10cde4: 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) ) 10cde6: 83 39 00 cmpl $0x0,(%ecx) 10cde9: 74 06 je 10cdf1 <_Watchdog_Remove+0x39> next_watchdog->delta_interval += the_watchdog->delta_interval; 10cdeb: 8b 5a 10 mov 0x10(%edx),%ebx 10cdee: 01 59 10 add %ebx,0x10(%ecx) if ( _Watchdog_Sync_count ) 10cdf1: 8b 1d 18 44 12 00 mov 0x124418,%ebx 10cdf7: 85 db test %ebx,%ebx 10cdf9: 74 0c je 10ce07 <_Watchdog_Remove+0x4f> _Watchdog_Sync_level = _ISR_Nest_level; 10cdfb: 8b 1d 30 48 12 00 mov 0x124830,%ebx 10ce01: 89 1d 90 43 12 00 mov %ebx,0x124390 { Chain_Node *next; Chain_Node *previous; next = the_node->next; previous = the_node->previous; 10ce07: 8b 5a 04 mov 0x4(%edx),%ebx next->previous = previous; 10ce0a: 89 59 04 mov %ebx,0x4(%ecx) previous->next = next; 10ce0d: 89 0b mov %ecx,(%ebx) _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10ce0f: 8b 0d 1c 44 12 00 mov 0x12441c,%ecx 10ce15: 89 4a 18 mov %ecx,0x18(%edx) _ISR_Enable( level ); 10ce18: 56 push %esi 10ce19: 9d popf return( previous_state ); } 10ce1a: 5b pop %ebx 10ce1b: 5e pop %esi 10ce1c: c9 leave 10ce1d: c3 ret =============================================================================== 0010e040 <_Watchdog_Report_chain>: void _Watchdog_Report_chain( const char *name, Chain_Control *header ) { 10e040: 55 push %ebp 10e041: 89 e5 mov %esp,%ebp 10e043: 57 push %edi 10e044: 56 push %esi 10e045: 53 push %ebx 10e046: 83 ec 20 sub $0x20,%esp 10e049: 8b 7d 08 mov 0x8(%ebp),%edi 10e04c: 8b 75 0c mov 0xc(%ebp),%esi ISR_Level level; Chain_Node *node; _ISR_Disable( level ); 10e04f: 9c pushf 10e050: fa cli 10e051: 8f 45 e4 popl -0x1c(%ebp) printk( "Watchdog Chain: %s %p\n", name, header ); 10e054: 56 push %esi 10e055: 57 push %edi 10e056: 68 80 0f 12 00 push $0x120f80 10e05b: e8 88 aa ff ff call 108ae8 */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 10e060: 8b 1e mov (%esi),%ebx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10e062: 83 c6 04 add $0x4,%esi if ( !_Chain_Is_empty( header ) ) { 10e065: 83 c4 10 add $0x10,%esp 10e068: 39 f3 cmp %esi,%ebx 10e06a: 74 1d je 10e089 <_Watchdog_Report_chain+0x49> node != _Chain_Tail(header) ; node = node->next ) { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); 10e06c: 52 push %edx 10e06d: 52 push %edx 10e06e: 53 push %ebx 10e06f: 6a 00 push $0x0 10e071: e8 32 00 00 00 call 10e0a8 <_Watchdog_Report> _ISR_Disable( level ); printk( "Watchdog Chain: %s %p\n", name, header ); if ( !_Chain_Is_empty( header ) ) { for ( node = header->first ; node != _Chain_Tail(header) ; node = node->next ) 10e076: 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 = header->first ; 10e078: 83 c4 10 add $0x10,%esp 10e07b: 39 f3 cmp %esi,%ebx 10e07d: 75 ed jne 10e06c <_Watchdog_Report_chain+0x2c><== NEVER TAKEN { Watchdog_Control *watch = (Watchdog_Control *) node; _Watchdog_Report( NULL, watch ); } printk( "== end of %s \n", name ); 10e07f: 50 push %eax 10e080: 50 push %eax 10e081: 57 push %edi 10e082: 68 97 0f 12 00 push $0x120f97 10e087: eb 08 jmp 10e091 <_Watchdog_Report_chain+0x51> } else { printk( "Chain is empty\n" ); 10e089: 83 ec 0c sub $0xc,%esp 10e08c: 68 a6 0f 12 00 push $0x120fa6 10e091: e8 52 aa ff ff call 108ae8 10e096: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10e099: ff 75 e4 pushl -0x1c(%ebp) 10e09c: 9d popf } 10e09d: 8d 65 f4 lea -0xc(%ebp),%esp 10e0a0: 5b pop %ebx 10e0a1: 5e pop %esi 10e0a2: 5f pop %edi 10e0a3: c9 leave 10e0a4: c3 ret =============================================================================== 0010b1d8 <_rename_r>: int _rename_r( struct _reent *ptr __attribute__((unused)), const char *old, const char *new ) { 10b1d8: 55 push %ebp 10b1d9: 89 e5 mov %esp,%ebp 10b1db: 57 push %edi 10b1dc: 56 push %esi 10b1dd: 53 push %ebx 10b1de: 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 ); 10b1e1: ff 75 0c pushl 0xc(%ebp) 10b1e4: e8 5e ed ff ff call 109f47 10b1e9: 89 45 94 mov %eax,-0x6c(%ebp) if ( old_parent_pathlen == 0 ) 10b1ec: 83 c4 10 add $0x10,%esp 10b1ef: 85 c0 test %eax,%eax 10b1f1: 8d 45 b8 lea -0x48(%ebp),%eax 10b1f4: 75 15 jne 10b20b <_rename_r+0x33> rtems_filesystem_get_start_loc( old, &i, &old_parent_loc ); 10b1f6: 51 push %ecx 10b1f7: 50 push %eax 10b1f8: 8d 45 e4 lea -0x1c(%ebp),%eax 10b1fb: 50 push %eax 10b1fc: ff 75 0c pushl 0xc(%ebp) 10b1ff: e8 48 03 00 00 call 10b54c 10b204: 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; 10b207: 31 db xor %ebx,%ebx 10b209: eb 23 jmp 10b22e <_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, 10b20b: 83 ec 0c sub $0xc,%esp 10b20e: 6a 00 push $0x0 10b210: 50 push %eax 10b211: 6a 02 push $0x2 10b213: ff 75 94 pushl -0x6c(%ebp) 10b216: ff 75 0c pushl 0xc(%ebp) 10b219: e8 e8 ec ff ff call 109f06 RTEMS_LIBIO_PERMS_WRITE, &old_parent_loc, false ); if ( result != 0 ) 10b21e: 83 c4 20 add $0x20,%esp return -1; 10b221: 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 ) 10b224: 85 c0 test %eax,%eax 10b226: 0f 85 50 01 00 00 jne 10b37c <_rename_r+0x1a4> <== NEVER TAKEN return -1; free_old_parentloc = true; 10b22c: b3 01 mov $0x1,%bl /* * Start from the parent to find the node that should be under it. */ old_loc = old_parent_loc; 10b22e: 8d 7d cc lea -0x34(%ebp),%edi 10b231: 8d 75 b8 lea -0x48(%ebp),%esi 10b234: b9 05 00 00 00 mov $0x5,%ecx 10b239: f3 a5 rep movsl %ds:(%esi),%es:(%edi) name = old + old_parent_pathlen; 10b23b: 8b 75 0c mov 0xc(%ebp),%esi 10b23e: 03 75 94 add -0x6c(%ebp),%esi 10b241: 89 75 e0 mov %esi,-0x20(%ebp) name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 10b244: 83 c9 ff or $0xffffffff,%ecx 10b247: 89 f7 mov %esi,%edi 10b249: 31 c0 xor %eax,%eax 10b24b: f2 ae repnz scas %es:(%edi),%al 10b24d: f7 d1 not %ecx 10b24f: 49 dec %ecx 10b250: 52 push %edx 10b251: 52 push %edx 10b252: 51 push %ecx 10b253: 56 push %esi 10b254: e8 2d ed ff ff call 109f86 10b259: 01 c6 add %eax,%esi 10b25b: 89 75 e0 mov %esi,-0x20(%ebp) result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 10b25e: 83 c9 ff or $0xffffffff,%ecx 10b261: 89 f7 mov %esi,%edi 10b263: 31 c0 xor %eax,%eax 10b265: f2 ae repnz scas %es:(%edi),%al 10b267: f7 d1 not %ecx 10b269: 49 dec %ecx 10b26a: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10b271: 8d 7d cc lea -0x34(%ebp),%edi 10b274: 57 push %edi 10b275: 6a 00 push $0x0 10b277: 51 push %ecx 10b278: 56 push %esi 10b279: e8 2a ec ff ff call 109ea8 0, &old_loc, false ); if ( result != 0 ) { 10b27e: 83 c4 20 add $0x20,%esp 10b281: 85 c0 test %eax,%eax 10b283: 74 16 je 10b29b <_rename_r+0xc3> if ( free_old_parentloc ) rtems_filesystem_freenode( &old_parent_loc ); return -1; 10b285: 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 ) 10b288: 84 db test %bl,%bl 10b28a: 0f 84 ec 00 00 00 je 10b37c <_rename_r+0x1a4> <== NEVER TAKEN rtems_filesystem_freenode( &old_parent_loc ); 10b290: 83 ec 0c sub $0xc,%esp 10b293: 8d 45 b8 lea -0x48(%ebp),%eax 10b296: e9 d8 00 00 00 jmp 10b373 <_rename_r+0x19b> /* * Get the parent of the new node we are renaming to. */ rtems_filesystem_get_start_loc( new, &i, &new_parent_loc ); 10b29b: 50 push %eax 10b29c: 8d 75 a4 lea -0x5c(%ebp),%esi 10b29f: 56 push %esi 10b2a0: 8d 45 e4 lea -0x1c(%ebp),%eax 10b2a3: 50 push %eax 10b2a4: ff 75 10 pushl 0x10(%ebp) 10b2a7: e8 a0 02 00 00 call 10b54c result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name ); 10b2ac: 83 c4 0c add $0xc,%esp 10b2af: 8d 45 e0 lea -0x20(%ebp),%eax 10b2b2: 50 push %eax 10b2b3: 56 push %esi 10b2b4: 8b 45 10 mov 0x10(%ebp),%eax 10b2b7: 03 45 e4 add -0x1c(%ebp),%eax 10b2ba: 50 push %eax 10b2bb: 8b 45 b0 mov -0x50(%ebp),%eax 10b2be: ff 50 04 call *0x4(%eax) if ( result != 0 ) { 10b2c1: 83 c4 10 add $0x10,%esp 10b2c4: 85 c0 test %eax,%eax 10b2c6: 74 2d je 10b2f5 <_rename_r+0x11d> rtems_filesystem_freenode( &new_parent_loc ); 10b2c8: 83 ec 0c sub $0xc,%esp 10b2cb: 56 push %esi 10b2cc: e8 43 ee ff ff call 10a114 if ( free_old_parentloc ) 10b2d1: 83 c4 10 add $0x10,%esp 10b2d4: 84 db test %bl,%bl 10b2d6: 74 0f je 10b2e7 <_rename_r+0x10f> <== NEVER TAKEN rtems_filesystem_freenode( &old_parent_loc ); 10b2d8: 83 ec 0c sub $0xc,%esp 10b2db: 8d 45 b8 lea -0x48(%ebp),%eax 10b2de: 50 push %eax 10b2df: e8 30 ee ff ff call 10a114 10b2e4: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &old_loc ); 10b2e7: 83 ec 0c sub $0xc,%esp 10b2ea: 8d 45 cc lea -0x34(%ebp),%eax 10b2ed: 50 push %eax 10b2ee: e8 21 ee ff ff call 10a114 10b2f3: eb 3e jmp 10b333 <_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 ) { 10b2f5: 8b 45 b4 mov -0x4c(%ebp),%eax 10b2f8: 39 45 c8 cmp %eax,-0x38(%ebp) 10b2fb: 74 3e je 10b33b <_rename_r+0x163> rtems_filesystem_freenode( &new_parent_loc ); 10b2fd: 83 ec 0c sub $0xc,%esp 10b300: 56 push %esi 10b301: e8 0e ee ff ff call 10a114 if ( free_old_parentloc ) 10b306: 83 c4 10 add $0x10,%esp 10b309: 84 db test %bl,%bl 10b30b: 74 0f je 10b31c <_rename_r+0x144> rtems_filesystem_freenode( &old_parent_loc ); 10b30d: 83 ec 0c sub $0xc,%esp 10b310: 8d 45 b8 lea -0x48(%ebp),%eax 10b313: 50 push %eax 10b314: e8 fb ed ff ff call 10a114 10b319: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &old_loc ); 10b31c: 83 ec 0c sub $0xc,%esp 10b31f: 8d 45 cc lea -0x34(%ebp),%eax 10b322: 50 push %eax 10b323: e8 ec ed ff ff call 10a114 rtems_set_errno_and_return_minus_one( EXDEV ); 10b328: e8 27 95 00 00 call 114854 <__errno> 10b32d: c7 00 12 00 00 00 movl $0x12,(%eax) 10b333: 83 c4 10 add $0x10,%esp 10b336: 83 cf ff or $0xffffffff,%edi 10b339: eb 41 jmp 10b37c <_rename_r+0x1a4> } result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name ); 10b33b: ff 75 e0 pushl -0x20(%ebp) 10b33e: 56 push %esi 10b33f: 57 push %edi 10b340: 8d 55 b8 lea -0x48(%ebp),%edx 10b343: 52 push %edx 10b344: 8b 45 b0 mov -0x50(%ebp),%eax 10b347: 89 55 90 mov %edx,-0x70(%ebp) 10b34a: ff 50 40 call *0x40(%eax) 10b34d: 89 c7 mov %eax,%edi rtems_filesystem_freenode( &new_parent_loc ); 10b34f: 89 34 24 mov %esi,(%esp) 10b352: e8 bd ed ff ff call 10a114 if ( free_old_parentloc ) 10b357: 83 c4 10 add $0x10,%esp 10b35a: 84 db test %bl,%bl 10b35c: 8b 55 90 mov -0x70(%ebp),%edx 10b35f: 74 0c je 10b36d <_rename_r+0x195> rtems_filesystem_freenode( &old_parent_loc ); 10b361: 83 ec 0c sub $0xc,%esp 10b364: 52 push %edx 10b365: e8 aa ed ff ff call 10a114 10b36a: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &old_loc ); 10b36d: 83 ec 0c sub $0xc,%esp 10b370: 8d 45 cc lea -0x34(%ebp),%eax 10b373: 50 push %eax 10b374: e8 9b ed ff ff call 10a114 return result; 10b379: 83 c4 10 add $0x10,%esp } 10b37c: 89 f8 mov %edi,%eax 10b37e: 8d 65 f4 lea -0xc(%ebp),%esp 10b381: 5b pop %ebx 10b382: 5e pop %esi 10b383: 5f pop %edi 10b384: c9 leave 10b385: c3 ret =============================================================================== 0010a7c0 : * operation(s) cannot be canceled */ int aio_cancel(int fildes, struct aiocb *aiocbp) { 10a7c0: 55 push %ebp 10a7c1: 89 e5 mov %esp,%ebp 10a7c3: 57 push %edi 10a7c4: 56 push %esi 10a7c5: 53 push %ebx 10a7c6: 83 ec 18 sub $0x18,%esp 10a7c9: 8b 75 08 mov 0x8(%ebp),%esi 10a7cc: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request_chain *r_chain; int result; pthread_mutex_lock (&aio_request_queue.mutex); 10a7cf: 68 78 72 12 00 push $0x127278 10a7d4: e8 0b 10 00 00 call 10b7e4 if (aiocbp == NULL) 10a7d9: 83 c4 10 add $0x10,%esp 10a7dc: 85 db test %ebx,%ebx 10a7de: 0f 85 05 01 00 00 jne 10a8e9 { if (fcntl (fildes, F_GETFL) < 0) { 10a7e4: 53 push %ebx 10a7e5: 53 push %ebx 10a7e6: 6a 03 push $0x3 10a7e8: 56 push %esi 10a7e9: e8 9e 5f 00 00 call 11078c 10a7ee: 83 c4 10 add $0x10,%esp 10a7f1: 85 c0 test %eax,%eax 10a7f3: 79 1d jns 10a812 <== NEVER TAKEN pthread_mutex_unlock(&aio_request_queue.mutex); 10a7f5: 83 ec 0c sub $0xc,%esp 10a7f8: 68 78 72 12 00 push $0x127278 10a7fd: e8 62 10 00 00 call 10b864 rtems_set_errno_and_return_minus_one (EBADF); 10a802: e8 35 8e 00 00 call 11363c <__errno> 10a807: c7 00 09 00 00 00 movl $0x9,(%eax) 10a80d: e9 f5 00 00 00 jmp 10a907 } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, 10a812: 51 push %ecx <== NOT EXECUTED 10a813: 6a 00 push $0x0 <== NOT EXECUTED 10a815: 56 push %esi <== NOT EXECUTED 10a816: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED 10a81b: e8 20 03 00 00 call 10ab40 <== NOT EXECUTED 10a820: 89 c3 mov %eax,%ebx <== NOT EXECUTED fildes, 0); if (r_chain == NULL) 10a822: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a825: 85 c0 test %eax,%eax <== NOT EXECUTED 10a827: 0f 85 82 00 00 00 jne 10a8af <== NOT EXECUTED { if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) 10a82d: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED 10a834: 72 12 00 10a837: 74 5c je 10a895 <== NOT EXECUTED { r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, 10a839: 52 push %edx <== NOT EXECUTED 10a83a: 6a 00 push $0x0 <== NOT EXECUTED 10a83c: 56 push %esi <== NOT EXECUTED 10a83d: 68 cc 72 12 00 push $0x1272cc <== NOT EXECUTED 10a842: e8 f9 02 00 00 call 10ab40 <== NOT EXECUTED 10a847: 89 c3 mov %eax,%ebx <== NOT EXECUTED fildes, 0); if (r_chain == NULL) { 10a849: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a84c: 85 c0 test %eax,%eax <== NOT EXECUTED 10a84e: 75 17 jne 10a867 <== NOT EXECUTED pthread_mutex_unlock(&aio_request_queue.mutex); 10a850: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a853: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10a858: e8 07 10 00 00 call 10b864 <== NOT EXECUTED return AIO_ALLDONE; 10a85d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a860: b3 02 mov $0x2,%bl <== NOT EXECUTED 10a862: e9 1b 01 00 00 jmp 10a982 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10a867: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a86a: 50 push %eax <== NOT EXECUTED 10a86b: e8 d0 26 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED } rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10a870: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a873: e8 07 06 00 00 call 10ae7f <== NOT EXECUTED pthread_mutex_destroy (&r_chain->mutex); 10a878: 8d 73 1c lea 0x1c(%ebx),%esi <== NOT EXECUTED 10a87b: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10a87e: e8 41 0d 00 00 call 10b5c4 <== NOT EXECUTED pthread_cond_destroy (&r_chain->mutex); 10a883: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10a886: e8 45 0a 00 00 call 10b2d0 <== NOT EXECUTED free (r_chain); 10a88b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a88e: e8 ad d4 ff ff call 107d40 <== NOT EXECUTED 10a893: eb 3e jmp 10a8d3 <== NOT EXECUTED pthread_mutex_unlock (&aio_request_queue.mutex); return AIO_CANCELED; } pthread_mutex_unlock (&aio_request_queue.mutex); 10a895: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a898: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10a89d: e8 c2 0f 00 00 call 10b864 <== NOT EXECUTED return AIO_ALLDONE; 10a8a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a8a5: bb 02 00 00 00 mov $0x2,%ebx <== NOT EXECUTED 10a8aa: e9 d3 00 00 00 jmp 10a982 <== NOT EXECUTED } pthread_mutex_lock (&r_chain->mutex); 10a8af: 8d 70 1c lea 0x1c(%eax),%esi <== NOT EXECUTED 10a8b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a8b5: 56 push %esi <== NOT EXECUTED 10a8b6: e8 29 0f 00 00 call 10b7e4 <== NOT EXECUTED 10a8bb: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a8be: e8 7d 26 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract (&r_chain->next_fd); rtems_aio_remove_fd (r_chain); 10a8c3: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a8c6: e8 b4 05 00 00 call 10ae7f <== NOT EXECUTED pthread_mutex_unlock (&r_chain->mutex); 10a8cb: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10a8ce: e8 91 0f 00 00 call 10b864 <== NOT EXECUTED pthread_mutex_unlock (&aio_request_queue.mutex); 10a8d3: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED 10a8da: e8 85 0f 00 00 call 10b864 <== NOT EXECUTED return AIO_CANCELED; 10a8df: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a8e2: 31 db xor %ebx,%ebx <== NOT EXECUTED 10a8e4: e9 99 00 00 00 jmp 10a982 <== NOT EXECUTED } else { if (aiocbp->aio_fildes != fildes) { 10a8e9: 8b 3b mov (%ebx),%edi 10a8eb: 39 f7 cmp %esi,%edi 10a8ed: 74 20 je 10a90f <== NEVER TAKEN pthread_mutex_unlock (&aio_request_queue.mutex); 10a8ef: 83 ec 0c sub $0xc,%esp 10a8f2: 68 78 72 12 00 push $0x127278 10a8f7: e8 68 0f 00 00 call 10b864 rtems_set_errno_and_return_minus_one (EINVAL); 10a8fc: e8 3b 8d 00 00 call 11363c <__errno> 10a901: c7 00 16 00 00 00 movl $0x16,(%eax) 10a907: 83 c4 10 add $0x10,%esp 10a90a: 83 cb ff or $0xffffffff,%ebx 10a90d: eb 73 jmp 10a982 } r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, 10a90f: 50 push %eax 10a910: 6a 00 push $0x0 10a912: 57 push %edi <== NOT EXECUTED 10a913: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED 10a918: e8 23 02 00 00 call 10ab40 <== NOT EXECUTED 10a91d: 89 c6 mov %eax,%esi <== NOT EXECUTED fildes, 0); if (r_chain == NULL) 10a91f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a922: 85 c0 test %eax,%eax <== NOT EXECUTED 10a924: 75 2e jne 10a954 <== NOT EXECUTED if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) 10a926: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED 10a92d: 72 12 00 10a930: 74 22 je 10a954 <== NOT EXECUTED { r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, 10a932: 56 push %esi <== NOT EXECUTED 10a933: 6a 00 push $0x0 <== NOT EXECUTED 10a935: 57 push %edi <== NOT EXECUTED 10a936: 68 cc 72 12 00 push $0x1272cc <== NOT EXECUTED 10a93b: e8 00 02 00 00 call 10ab40 <== NOT EXECUTED fildes, 0); if (r_chain == NULL) 10a940: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a943: 85 c0 test %eax,%eax <== NOT EXECUTED 10a945: 74 a8 je 10a8ef <== NOT EXECUTED { pthread_mutex_unlock (&aio_request_queue.mutex); rtems_set_errno_and_return_minus_one (EINVAL); } result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp); 10a947: 51 push %ecx <== NOT EXECUTED 10a948: 51 push %ecx <== NOT EXECUTED 10a949: 53 push %ebx <== NOT EXECUTED 10a94a: 50 push %eax <== NOT EXECUTED 10a94b: e8 6f 05 00 00 call 10aebf <== NOT EXECUTED 10a950: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10a952: eb 1f jmp 10a973 <== NOT EXECUTED pthread_mutex_unlock (&aio_request_queue.mutex); return result; } pthread_mutex_lock (&r_chain->mutex); 10a954: 8d 7e 1c lea 0x1c(%esi),%edi <== NOT EXECUTED 10a957: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a95a: 57 push %edi <== NOT EXECUTED 10a95b: e8 84 0e 00 00 call 10b7e4 <== NOT EXECUTED result = rtems_aio_remove_req (&r_chain->next_fd, aiocbp); 10a960: 58 pop %eax <== NOT EXECUTED 10a961: 5a pop %edx <== NOT EXECUTED 10a962: 53 push %ebx <== NOT EXECUTED 10a963: 56 push %esi <== NOT EXECUTED 10a964: e8 56 05 00 00 call 10aebf <== NOT EXECUTED 10a969: 89 c3 mov %eax,%ebx <== NOT EXECUTED pthread_mutex_unlock (&r_chain->mutex); 10a96b: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10a96e: e8 f1 0e 00 00 call 10b864 <== NOT EXECUTED pthread_mutex_unlock (&aio_request_queue.mutex); 10a973: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED 10a97a: e8 e5 0e 00 00 call 10b864 <== NOT EXECUTED return result; 10a97f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return AIO_ALLDONE; } 10a982: 89 d8 mov %ebx,%eax 10a984: 8d 65 f4 lea -0xc(%ebp),%esp 10a987: 5b pop %ebx 10a988: 5e pop %esi 10a989: 5f pop %edi 10a98a: c9 leave 10a98b: c3 ret =============================================================================== 0010a998 : int aio_fsync( int op, struct aiocb *aiocbp ) { 10a998: 55 push %ebp 10a999: 89 e5 mov %esp,%ebp 10a99b: 53 push %ebx 10a99c: 83 ec 04 sub $0x4,%esp 10a99f: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_aio_request *req; int mode; if (op != O_SYNC) 10a9a2: 81 7d 08 00 20 00 00 cmpl $0x2000,0x8(%ebp) 10a9a9: 74 1b je 10a9c6 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10a9ab: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10a9b2: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a9b9: e8 7e 8c 00 00 call 11363c <__errno> 10a9be: c7 00 16 00 00 00 movl $0x16,(%eax) 10a9c4: eb 74 jmp 10aa3a mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10a9c6: 50 push %eax 10a9c7: 50 push %eax 10a9c8: 6a 03 push $0x3 10a9ca: ff 33 pushl (%ebx) 10a9cc: e8 bb 5d 00 00 call 11078c if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10a9d1: 83 e0 03 and $0x3,%eax 10a9d4: 48 dec %eax 10a9d5: 83 c4 10 add $0x10,%esp 10a9d8: 83 f8 01 cmp $0x1,%eax 10a9db: 76 1b jbe 10a9f8 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10a9dd: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10a9e4: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10a9eb: e8 4c 8c 00 00 call 11363c <__errno> 10a9f0: c7 00 09 00 00 00 movl $0x9,(%eax) 10a9f6: eb 42 jmp 10aa3a req = malloc (sizeof (rtems_aio_request)); 10a9f8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a9fb: 6a 18 push $0x18 <== NOT EXECUTED 10a9fd: e8 c2 d7 ff ff call 1081c4 <== NOT EXECUTED if (req == NULL) 10aa02: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aa05: 85 c0 test %eax,%eax <== NOT EXECUTED 10aa07: 75 1b jne 10aa24 <== NOT EXECUTED rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10aa09: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10aa10: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10aa17: e8 20 8c 00 00 call 11363c <__errno> <== NOT EXECUTED 10aa1c: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10aa22: eb 16 jmp 10aa3a <== NOT EXECUTED req->aiocbp = aiocbp; 10aa24: 89 58 14 mov %ebx,0x14(%eax) <== NOT EXECUTED req->aiocbp->aio_lio_opcode = LIO_SYNC; 10aa27: c7 43 2c 03 00 00 00 movl $0x3,0x2c(%ebx) <== NOT EXECUTED return rtems_aio_enqueue (req); 10aa2e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10aa31: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10aa34: c9 leave <== NOT EXECUTED rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); req->aiocbp = aiocbp; req->aiocbp->aio_lio_opcode = LIO_SYNC; return rtems_aio_enqueue (req); 10aa35: e9 d7 04 00 00 jmp 10af11 <== NOT EXECUTED } 10aa3a: 83 c8 ff or $0xffffffff,%eax 10aa3d: 8b 5d fc mov -0x4(%ebp),%ebx 10aa40: c9 leave 10aa41: c3 ret =============================================================================== 0010b10c : * 0 - otherwise */ int aio_read (struct aiocb *aiocbp) { 10b10c: 55 push %ebp 10b10d: 89 e5 mov %esp,%ebp 10b10f: 53 push %ebx 10b110: 83 ec 0c sub $0xc,%esp 10b113: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10b116: 6a 03 push $0x3 10b118: ff 33 pushl (%ebx) 10b11a: e8 6d 56 00 00 call 11078c if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10b11f: 83 e0 03 and $0x3,%eax 10b122: 83 c4 10 add $0x10,%esp 10b125: 83 f8 02 cmp $0x2,%eax 10b128: 74 1f je 10b149 10b12a: 85 c0 test %eax,%eax 10b12c: 74 1b je 10b149 <== NEVER TAKEN rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10b12e: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10b135: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b13c: e8 fb 84 00 00 call 11363c <__errno> 10b141: c7 00 09 00 00 00 movl $0x9,(%eax) 10b147: eb 69 jmp 10b1b2 if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10b149: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10b14d: 75 06 jne 10b155 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10b14f: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10b153: 79 1b jns 10b170 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10b155: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10b15c: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b163: e8 d4 84 00 00 call 11363c <__errno> 10b168: c7 00 16 00 00 00 movl $0x16,(%eax) 10b16e: eb 42 jmp 10b1b2 req = malloc (sizeof (rtems_aio_request)); 10b170: 83 ec 0c sub $0xc,%esp 10b173: 6a 18 push $0x18 10b175: e8 4a d0 ff ff call 1081c4 if (req == NULL) 10b17a: 83 c4 10 add $0x10,%esp 10b17d: 85 c0 test %eax,%eax 10b17f: 75 1b jne 10b19c <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10b181: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10b188: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10b18f: e8 a8 84 00 00 call 11363c <__errno> <== NOT EXECUTED 10b194: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10b19a: eb 16 jmp 10b1b2 <== NOT EXECUTED req->aiocbp = aiocbp; 10b19c: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_READ; 10b19f: c7 43 2c 01 00 00 00 movl $0x1,0x2c(%ebx) return rtems_aio_enqueue (req); 10b1a6: 89 45 08 mov %eax,0x8(%ebp) } 10b1a9: 8b 5d fc mov -0x4(%ebp),%ebx 10b1ac: 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); 10b1ad: e9 5f fd ff ff jmp 10af11 } 10b1b2: 83 c8 ff or $0xffffffff,%eax 10b1b5: 8b 5d fc mov -0x4(%ebp),%ebx 10b1b8: c9 leave 10b1b9: c3 ret =============================================================================== 0010b1c8 : * 0 - otherwise */ int aio_write (struct aiocb *aiocbp) { 10b1c8: 55 push %ebp 10b1c9: 89 e5 mov %esp,%ebp 10b1cb: 53 push %ebx 10b1cc: 83 ec 0c sub $0xc,%esp 10b1cf: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_aio_request *req; int mode; mode = fcntl (aiocbp->aio_fildes, F_GETFL); 10b1d2: 6a 03 push $0x3 10b1d4: ff 33 pushl (%ebx) 10b1d6: e8 b1 55 00 00 call 11078c if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR))) 10b1db: 83 e0 03 and $0x3,%eax 10b1de: 48 dec %eax 10b1df: 83 c4 10 add $0x10,%esp 10b1e2: 83 f8 01 cmp $0x1,%eax 10b1e5: 76 1b jbe 10b202 rtems_aio_set_errno_return_minus_one (EBADF, aiocbp); 10b1e7: c7 43 30 09 00 00 00 movl $0x9,0x30(%ebx) 10b1ee: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b1f5: e8 42 84 00 00 call 11363c <__errno> 10b1fa: c7 00 09 00 00 00 movl $0x9,(%eax) 10b200: eb 69 jmp 10b26b if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX) 10b202: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10b206: 75 06 jne 10b20e rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); if (aiocbp->aio_offset < 0) 10b208: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10b20c: 79 1b jns 10b229 rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp); 10b20e: c7 43 30 16 00 00 00 movl $0x16,0x30(%ebx) 10b215: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) 10b21c: e8 1b 84 00 00 call 11363c <__errno> 10b221: c7 00 16 00 00 00 movl $0x16,(%eax) 10b227: eb 42 jmp 10b26b req = malloc (sizeof (rtems_aio_request)); 10b229: 83 ec 0c sub $0xc,%esp 10b22c: 6a 18 push $0x18 10b22e: e8 91 cf ff ff call 1081c4 if (req == NULL) 10b233: 83 c4 10 add $0x10,%esp 10b236: 85 c0 test %eax,%eax 10b238: 75 1b jne 10b255 <== ALWAYS TAKEN rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp); 10b23a: c7 43 30 0b 00 00 00 movl $0xb,0x30(%ebx) <== NOT EXECUTED 10b241: c7 43 34 ff ff ff ff movl $0xffffffff,0x34(%ebx) <== NOT EXECUTED 10b248: e8 ef 83 00 00 call 11363c <__errno> <== NOT EXECUTED 10b24d: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10b253: eb 16 jmp 10b26b <== NOT EXECUTED req->aiocbp = aiocbp; 10b255: 89 58 14 mov %ebx,0x14(%eax) req->aiocbp->aio_lio_opcode = LIO_WRITE; 10b258: c7 43 2c 02 00 00 00 movl $0x2,0x2c(%ebx) return rtems_aio_enqueue (req); 10b25f: 89 45 08 mov %eax,0x8(%ebp) } 10b262: 8b 5d fc mov -0x4(%ebp),%ebx 10b265: 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); 10b266: e9 a6 fc ff ff jmp 10af11 } 10b26b: 83 c8 ff or $0xffffffff,%eax 10b26e: 8b 5d fc mov -0x4(%ebp),%ebx 10b271: c9 leave 10b272: c3 ret =============================================================================== 00107528 : #include int chroot( const char *pathname ) { 107528: 55 push %ebp 107529: 89 e5 mov %esp,%ebp 10752b: 57 push %edi 10752c: 56 push %esi 10752d: 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) { 107530: 81 3d 3c 30 12 00 c8 cmpl $0x1251c8,0x12303c 107537: 51 12 00 10753a: 75 1e jne 10755a rtems_libio_set_private_env(); /* try to set a new private env*/ 10753c: e8 cc 10 00 00 call 10860d if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 107541: 81 3d 3c 30 12 00 c8 cmpl $0x1251c8,0x12303c 107548: 51 12 00 10754b: 75 0d jne 10755a rtems_set_errno_and_return_minus_one( ENOTSUP ); 10754d: e8 32 a3 00 00 call 111884 <__errno> 107552: c7 00 86 00 00 00 movl $0x86,(%eax) 107558: eb 22 jmp 10757c } result = chdir(pathname); 10755a: 83 ec 0c sub $0xc,%esp 10755d: ff 75 08 pushl 0x8(%ebp) 107560: e8 67 73 00 00 call 10e8cc if (result) { 107565: 83 c4 10 add $0x10,%esp 107568: 85 c0 test %eax,%eax 10756a: 74 15 je 107581 rtems_set_errno_and_return_minus_one( errno ); 10756c: e8 13 a3 00 00 call 111884 <__errno> 107571: 89 c6 mov %eax,%esi 107573: e8 0c a3 00 00 call 111884 <__errno> 107578: 8b 00 mov (%eax),%eax 10757a: 89 06 mov %eax,(%esi) 10757c: 83 c8 ff or $0xffffffff,%eax 10757f: eb 44 jmp 1075c5 } /* clone the new root location */ if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) { 107581: 83 ec 0c sub $0xc,%esp 107584: 6a 00 push $0x0 107586: 8d 75 e4 lea -0x1c(%ebp),%esi 107589: 56 push %esi 10758a: 6a 00 push $0x0 10758c: 6a 01 push $0x1 10758e: 68 6e f3 11 00 push $0x11f36e 107593: e8 02 01 00 00 call 10769a 107598: 83 c4 20 add $0x20,%esp 10759b: 85 c0 test %eax,%eax 10759d: 75 cd jne 10756c <== 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); 10759f: 83 ec 0c sub $0xc,%esp 1075a2: a1 3c 30 12 00 mov 0x12303c,%eax 1075a7: 83 c0 18 add $0x18,%eax 1075aa: 50 push %eax 1075ab: e8 a8 01 00 00 call 107758 rtems_filesystem_root = loc; 1075b0: 8b 3d 3c 30 12 00 mov 0x12303c,%edi 1075b6: 83 c7 18 add $0x18,%edi 1075b9: b9 05 00 00 00 mov $0x5,%ecx 1075be: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return 0; 1075c0: 83 c4 10 add $0x10,%esp 1075c3: 31 c0 xor %eax,%eax } 1075c5: 8d 65 f8 lea -0x8(%ebp),%esp 1075c8: 5e pop %esi 1075c9: 5f pop %edi 1075ca: c9 leave 1075cb: c3 ret =============================================================================== 00109f94 : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 109f94: 55 push %ebp 109f95: 89 e5 mov %esp,%ebp 109f97: 83 ec 08 sub $0x8,%esp 109f9a: 8b 45 08 mov 0x8(%ebp),%eax 109f9d: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 109fa0: 85 d2 test %edx,%edx 109fa2: 74 3c je 109fe0 rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 109fa4: 83 f8 01 cmp $0x1,%eax 109fa7: 75 0b jne 109fb4 _TOD_Get(tp); 109fa9: 83 ec 0c sub $0xc,%esp 109fac: 52 push %edx 109fad: e8 9e 1b 00 00 call 10bb50 <_TOD_Get> 109fb2: eb 13 jmp 109fc7 return 0; } #ifdef CLOCK_MONOTONIC if ( clock_id == CLOCK_MONOTONIC ) { 109fb4: 83 f8 04 cmp $0x4,%eax 109fb7: 74 05 je 109fbe <== NEVER TAKEN return 0; } #endif #ifdef _POSIX_CPUTIME if ( clock_id == CLOCK_PROCESS_CPUTIME ) { 109fb9: 83 f8 02 cmp $0x2,%eax 109fbc: 75 10 jne 109fce _TOD_Get_uptime_as_timespec( tp ); 109fbe: 83 ec 0c sub $0xc,%esp 109fc1: 52 push %edx 109fc2: e8 e5 1b 00 00 call 10bbac <_TOD_Get_uptime_as_timespec> return 0; 109fc7: 83 c4 10 add $0x10,%esp 109fca: 31 c0 xor %eax,%eax 109fcc: eb 20 jmp 109fee } #endif #ifdef _POSIX_THREAD_CPUTIME if ( clock_id == CLOCK_THREAD_CPUTIME ) 109fce: 83 f8 03 cmp $0x3,%eax 109fd1: 75 0d jne 109fe0 rtems_set_errno_and_return_minus_one( ENOSYS ); 109fd3: e8 68 7f 00 00 call 111f40 <__errno> 109fd8: c7 00 58 00 00 00 movl $0x58,(%eax) 109fde: eb 0b jmp 109feb #endif rtems_set_errno_and_return_minus_one( EINVAL ); 109fe0: e8 5b 7f 00 00 call 111f40 <__errno> 109fe5: c7 00 16 00 00 00 movl $0x16,(%eax) 109feb: 83 c8 ff or $0xffffffff,%eax return 0; } 109fee: c9 leave 109fef: c3 ret =============================================================================== 00109ff0 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 109ff0: 55 push %ebp 109ff1: 89 e5 mov %esp,%ebp 109ff3: 83 ec 08 sub $0x8,%esp 109ff6: 8b 45 08 mov 0x8(%ebp),%eax 109ff9: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 109ffc: 85 d2 test %edx,%edx 109ffe: 74 44 je 10a044 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 10a000: 83 f8 01 cmp $0x1,%eax 10a003: 75 28 jne 10a02d if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 10a005: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx) 10a00b: 76 37 jbe 10a044 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a00d: a1 24 63 12 00 mov 0x126324,%eax 10a012: 40 inc %eax 10a013: a3 24 63 12 00 mov %eax,0x126324 rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); 10a018: 83 ec 0c sub $0xc,%esp 10a01b: 52 push %edx 10a01c: e8 e3 1b 00 00 call 10bc04 <_TOD_Set> _Thread_Enable_dispatch(); 10a021: e8 68 2c 00 00 call 10cc8e <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; 10a026: 83 c4 10 add $0x10,%esp 10a029: 31 c0 xor %eax,%eax 10a02b: eb 25 jmp 10a052 _Thread_Disable_dispatch(); _TOD_Set( tp ); _Thread_Enable_dispatch(); } #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 10a02d: 83 f8 02 cmp $0x2,%eax 10a030: 74 05 je 10a037 rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 10a032: 83 f8 03 cmp $0x3,%eax 10a035: 75 0d jne 10a044 rtems_set_errno_and_return_minus_one( ENOSYS ); 10a037: e8 04 7f 00 00 call 111f40 <__errno> 10a03c: c7 00 58 00 00 00 movl $0x58,(%eax) 10a042: eb 0b jmp 10a04f #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 10a044: e8 f7 7e 00 00 call 111f40 <__errno> 10a049: c7 00 16 00 00 00 movl $0x16,(%eax) 10a04f: 83 c8 ff or $0xffffffff,%eax return 0; } 10a052: c9 leave 10a053: c3 ret =============================================================================== 0010d340 : const char *pathname, size_t pathnamelen, int flags, rtems_filesystem_location_info_t *pathloc ) { 10d340: 55 push %ebp 10d341: 89 e5 mov %esp,%ebp 10d343: 57 push %edi 10d344: 56 push %esi 10d345: 53 push %ebx 10d346: 83 ec 1c sub $0x1c,%esp 10d349: 8b 4d 0c mov 0xc(%ebp),%ecx 10d34c: 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 ) ) 10d34f: f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp) 10d356: 74 0d je 10d365 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EPERM ); 10d358: e8 5b 23 00 00 call 10f6b8 <__errno> <== NOT EXECUTED 10d35d: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10d363: eb 77 jmp 10d3dc <== NOT EXECUTED /* get the device name table */ device_name_table = (rtems_device_name_t *)pathloc->node_access; 10d365: 8b 33 mov (%ebx),%esi if (!device_name_table) 10d367: 85 f6 test %esi,%esi 10d369: 74 04 je 10d36f 10d36b: 31 ff xor %edi,%edi 10d36d: eb 5a jmp 10d3c9 rtems_set_errno_and_return_minus_one( EFAULT ); 10d36f: e8 44 23 00 00 call 10f6b8 <__errno> 10d374: c7 00 0e 00 00 00 movl $0xe,(%eax) 10d37a: eb 60 jmp 10d3dc for (i = 0; i < rtems_device_table_size; i++) { if (!device_name_table[i].device_name) 10d37c: 8b 16 mov (%esi),%edx 10d37e: 85 d2 test %edx,%edx 10d380: 74 43 je 10d3c5 continue; if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0) 10d382: 50 push %eax 10d383: 51 push %ecx 10d384: 52 push %edx 10d385: ff 75 08 pushl 0x8(%ebp) 10d388: 89 55 e4 mov %edx,-0x1c(%ebp) 10d38b: 89 4d e0 mov %ecx,-0x20(%ebp) 10d38e: e8 01 30 00 00 call 110394 10d393: 83 c4 10 add $0x10,%esp 10d396: 85 c0 test %eax,%eax 10d398: 8b 55 e4 mov -0x1c(%ebp),%edx 10d39b: 8b 4d e0 mov -0x20(%ebp),%ecx 10d39e: 75 25 jne 10d3c5 continue; if (device_name_table[i].device_name[pathnamelen] != '\0') 10d3a0: 80 3c 0a 00 cmpb $0x0,(%edx,%ecx,1) 10d3a4: 75 1f jne 10d3c5 <== NEVER TAKEN continue; /* find the device, set proper values */ pathloc->node_access = (void *)&device_name_table[i]; 10d3a6: 89 33 mov %esi,(%ebx) pathloc->handlers = &devFS_file_handlers; 10d3a8: c7 43 08 7c ff 11 00 movl $0x11ff7c,0x8(%ebx) pathloc->ops = &devFS_ops; 10d3af: c7 43 0c 34 ff 11 00 movl $0x11ff34,0xc(%ebx) pathloc->mt_entry = rtems_filesystem_root.mt_entry; 10d3b6: a1 d0 00 12 00 mov 0x1200d0,%eax 10d3bb: 8b 40 28 mov 0x28(%eax),%eax 10d3be: 89 43 10 mov %eax,0x10(%ebx) return 0; 10d3c1: 31 c0 xor %eax,%eax 10d3c3: eb 1a jmp 10d3df /* 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++) { 10d3c5: 47 inc %edi 10d3c6: 83 c6 14 add $0x14,%esi 10d3c9: 3b 3d 48 e1 11 00 cmp 0x11e148,%edi 10d3cf: 72 ab jb 10d37c pathloc->mt_entry = rtems_filesystem_root.mt_entry; return 0; } /* no such file or directory */ rtems_set_errno_and_return_minus_one( ENOENT ); 10d3d1: e8 e2 22 00 00 call 10f6b8 <__errno> 10d3d6: c7 00 02 00 00 00 movl $0x2,(%eax) 10d3dc: 83 c8 ff or $0xffffffff,%eax } 10d3df: 8d 65 f4 lea -0xc(%ebp),%esp 10d3e2: 5b pop %ebx 10d3e3: 5e pop %esi 10d3e4: 5f pop %edi 10d3e5: c9 leave 10d3e6: 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 2e 8a 00 00 call 10f6b8 <__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 09 8a 00 00 call 10f6b8 <__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 1c 96 00 00 call 1102ec 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 d6 89 00 00 call 10f6b8 <__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 e1 11 00 cmp 0x11e148,%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 b6 89 00 00 call 10f6b8 <__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 ad 20 00 00 call 10a164 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 65 26 00 00 call 10a72c <== 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 08 21 12 00 mov 0x122108,%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 5e 12 00 mov 0x125e98,%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 5e 9e 00 00 call 111f94 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 5f 12 00 mov 0x125f74,%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 ab 9f 00 00 call 111f94 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 08 21 12 00 mov 0x122108,%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 bc e6 11 00 push $0x11e6bc 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 ba e6 11 00 push $0x11e6ba <== 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 08 21 12 00 mov 0x122108,%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 ba e6 11 00 push $0x11e6ba 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 =============================================================================== 00107be8 : int fcntl( int fd, int cmd, ... ) { 107be8: 55 push %ebp 107be9: 89 e5 mov %esp,%ebp 107beb: 57 push %edi 107bec: 56 push %esi 107bed: 53 push %ebx 107bee: 83 ec 0c sub $0xc,%esp 107bf1: 8b 5d 08 mov 0x8(%ebp),%ebx int ret; va_list ap; va_start( ap, cmd ); 107bf4: 8d 75 10 lea 0x10(%ebp),%esi int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 107bf7: 8b 0d 44 21 12 00 mov 0x122144,%ecx 107bfd: 39 cb cmp %ecx,%ebx 107bff: 73 14 jae 107c15 iop = rtems_libio_iop( fd ); 107c01: 8b 15 98 61 12 00 mov 0x126198,%edx 107c07: 6b db 38 imul $0x38,%ebx,%ebx 107c0a: 8d 1c 1a lea (%edx,%ebx,1),%ebx rtems_libio_check_is_open(iop); 107c0d: 8b 43 14 mov 0x14(%ebx),%eax 107c10: f6 c4 01 test $0x1,%ah 107c13: 75 10 jne 107c25 107c15: e8 fa a2 00 00 call 111f14 <__errno> 107c1a: c7 00 09 00 00 00 movl $0x9,(%eax) 107c20: e9 e6 00 00 00 jmp 107d0b /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 107c25: 83 7d 0c 09 cmpl $0x9,0xc(%ebp) 107c29: 0f 87 af 00 00 00 ja 107cde 107c2f: 8b 7d 0c mov 0xc(%ebp),%edi 107c32: ff 24 bd 28 ff 11 00 jmp *0x11ff28(,%edi,4) case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); 107c39: 8b 36 mov (%esi),%esi if ( fd2 ) 107c3b: 85 f6 test %esi,%esi 107c3d: 74 0e je 107c4d diop = rtems_libio_iop( fd2 ); 107c3f: 31 c0 xor %eax,%eax 107c41: 39 ce cmp %ecx,%esi 107c43: 73 15 jae 107c5a <== NEVER TAKEN 107c45: 6b c6 38 imul $0x38,%esi,%eax 107c48: 8d 04 02 lea (%edx,%eax,1),%eax 107c4b: eb 0d jmp 107c5a else { /* allocate a file control block */ diop = rtems_libio_allocate(); 107c4d: e8 d1 04 00 00 call 108123 if ( diop == 0 ) { 107c52: 85 c0 test %eax,%eax 107c54: 0f 84 b1 00 00 00 je 107d0b <== NEVER TAKEN ret = -1; break; } } diop->flags = iop->flags; 107c5a: 8b 53 14 mov 0x14(%ebx),%edx 107c5d: 89 50 14 mov %edx,0x14(%eax) diop->pathinfo = iop->pathinfo; 107c60: 8d 78 18 lea 0x18(%eax),%edi 107c63: 8d 73 18 lea 0x18(%ebx),%esi 107c66: b9 05 00 00 00 mov $0x5,%ecx 107c6b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ret = (int) (diop - rtems_libio_iops); 107c6d: 2b 05 98 61 12 00 sub 0x126198,%eax 107c73: c1 f8 03 sar $0x3,%eax 107c76: 69 f0 b7 6d db b6 imul $0xb6db6db7,%eax,%esi 107c7c: eb 6d jmp 107ceb break; case F_GETFD: /* get f_flags */ ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0); 107c7e: f6 c4 08 test $0x8,%ah 107c81: 0f 95 c0 setne %al 107c84: 0f b6 c0 movzbl %al,%eax 107c87: 89 c6 mov %eax,%esi 107c89: eb 64 jmp 107cef * 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 ) ) 107c8b: 83 3e 00 cmpl $0x0,(%esi) 107c8e: 74 05 je 107c95 iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; 107c90: 80 cc 08 or $0x8,%ah 107c93: eb 03 jmp 107c98 else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; 107c95: 80 e4 f7 and $0xf7,%ah 107c98: 89 43 14 mov %eax,0x14(%ebx) 107c9b: eb 30 jmp 107ccd break; case F_GETFL: /* more flags (cloexec) */ ret = rtems_libio_to_fcntl_flags( iop->flags ); 107c9d: 83 ec 0c sub $0xc,%esp 107ca0: 50 push %eax 107ca1: e8 3f 04 00 00 call 1080e5 107ca6: 89 c6 mov %eax,%esi 107ca8: 83 c4 10 add $0x10,%esp 107cab: eb 3e jmp 107ceb break; case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); 107cad: 83 ec 0c sub $0xc,%esp 107cb0: ff 36 pushl (%esi) 107cb2: e8 f9 03 00 00 call 1080b0 /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = (iop->flags & ~mask) | (flags & mask); 107cb7: 25 01 02 00 00 and $0x201,%eax 107cbc: 8b 53 14 mov 0x14(%ebx),%edx 107cbf: 81 e2 fe fd ff ff and $0xfffffdfe,%edx 107cc5: 09 d0 or %edx,%eax 107cc7: 89 43 14 mov %eax,0x14(%ebx) 107cca: 83 c4 10 add $0x10,%esp rtems_libio_t *iop; rtems_libio_t *diop; int fd2; int flags; int mask; int ret = 0; 107ccd: 31 f6 xor %esi,%esi 107ccf: eb 1e jmp 107cef errno = ENOTSUP; ret = -1; break; case F_GETOWN: /* for sockets. */ errno = ENOTSUP; 107cd1: e8 3e a2 00 00 call 111f14 <__errno> 107cd6: c7 00 86 00 00 00 movl $0x86,(%eax) 107cdc: eb 2d jmp 107d0b ret = -1; break; default: errno = EINVAL; 107cde: e8 31 a2 00 00 call 111f14 <__errno> 107ce3: c7 00 16 00 00 00 movl $0x16,(%eax) 107ce9: eb 20 jmp 107d0b /* * If we got this far successfully, then we give the optional * filesystem specific handler a chance to process this. */ if (ret >= 0) { 107ceb: 85 f6 test %esi,%esi 107ced: 78 1f js 107d0e <== NEVER TAKEN int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop ); 107cef: 50 push %eax 107cf0: 50 push %eax 107cf1: 8b 43 20 mov 0x20(%ebx),%eax 107cf4: 53 push %ebx 107cf5: ff 75 0c pushl 0xc(%ebp) 107cf8: ff 50 30 call *0x30(%eax) 107cfb: 89 c3 mov %eax,%ebx if (err) { 107cfd: 83 c4 10 add $0x10,%esp 107d00: 85 c0 test %eax,%eax 107d02: 74 0a je 107d0e <== ALWAYS TAKEN errno = err; 107d04: e8 0b a2 00 00 call 111f14 <__errno> <== NOT EXECUTED 107d09: 89 18 mov %ebx,(%eax) <== NOT EXECUTED ret = -1; 107d0b: 83 ce ff or $0xffffffff,%esi va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; } 107d0e: 89 f0 mov %esi,%eax 107d10: 8d 65 f4 lea -0xc(%ebp),%esp 107d13: 5b pop %ebx 107d14: 5e pop %esi 107d15: 5f pop %edi 107d16: c9 leave 107d17: c3 ret =============================================================================== 0010fa07 : */ int fifo_open( pipe_control_t **pipep, rtems_libio_t *iop ) { 10fa07: 55 push %ebp 10fa08: 89 e5 mov %esp,%ebp 10fa0a: 57 push %edi 10fa0b: 56 push %esi 10fa0c: 53 push %ebx 10fa0d: 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) { 10fa10: 83 3d a0 6f 12 00 00 cmpl $0x0,0x126fa0 10fa17: 75 50 jne 10fa69 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 ); 10fa19: 53 push %ebx 10fa1a: 6a 00 push $0x0 10fa1c: 6a 00 push $0x0 10fa1e: ff 35 a0 71 12 00 pushl 0x1271a0 10fa24: e8 e7 c1 ff ff call 10bc10 rtems_libio_lock(); if (pipe_semaphore == RTEMS_ID_NONE) { 10fa29: 83 c4 10 add $0x10,%esp free(pipe); } static rtems_status_code pipe_lock(void) { rtems_status_code sc = RTEMS_SUCCESSFUL; 10fa2c: 31 db xor %ebx,%ebx if (pipe_semaphore == RTEMS_ID_NONE) { rtems_libio_lock(); if (pipe_semaphore == RTEMS_ID_NONE) { 10fa2e: 83 3d a0 6f 12 00 00 cmpl $0x0,0x126fa0 10fa35: 75 1d jne 10fa54 <== NEVER TAKEN sc = rtems_semaphore_create( 10fa37: 83 ec 0c sub $0xc,%esp 10fa3a: 68 a0 6f 12 00 push $0x126fa0 10fa3f: 6a 00 push $0x0 10fa41: 6a 54 push $0x54 10fa43: 6a 01 push $0x1 10fa45: 68 45 50 49 50 push $0x50495045 10fa4a: e8 99 bf ff ff call 10b9e8 10fa4f: 89 c3 mov %eax,%ebx 10fa51: 83 c4 20 add $0x20,%esp } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10fa54: 83 ec 0c sub $0xc,%esp 10fa57: ff 35 a0 71 12 00 pushl 0x1271a0 10fa5d: e8 9a c2 ff ff call 10bcfc } rtems_libio_unlock(); } if (sc == RTEMS_SUCCESSFUL) { 10fa62: 83 c4 10 add $0x10,%esp 10fa65: 85 db test %ebx,%ebx 10fa67: 75 19 jne 10fa82 sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 10fa69: 51 push %ecx 10fa6a: 6a 00 push $0x0 10fa6c: 6a 00 push $0x0 10fa6e: ff 35 a0 6f 12 00 pushl 0x126fa0 10fa74: e8 97 c1 ff ff call 10bc10 } if (sc == RTEMS_SUCCESSFUL) { 10fa79: 83 c4 10 add $0x10,%esp return 0; 10fa7c: 31 f6 xor %esi,%esi if (sc == RTEMS_SUCCESSFUL) { sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); } if (sc == RTEMS_SUCCESSFUL) { 10fa7e: 85 c0 test %eax,%eax 10fa80: 74 05 je 10fa87 <== ALWAYS TAKEN return 0; } else { return -ENOMEM; 10fa82: be f4 ff ff ff mov $0xfffffff4,%esi { pipe_control_t *pipe; int err = 0; err = pipe_lock(); if (err) 10fa87: 85 f6 test %esi,%esi 10fa89: 0f 85 37 03 00 00 jne 10fdc6 return err; pipe = *pipep; 10fa8f: 8b 45 08 mov 0x8(%ebp),%eax 10fa92: 8b 18 mov (%eax),%ebx if (pipe == NULL) { 10fa94: 85 db test %ebx,%ebx 10fa96: 0f 85 56 01 00 00 jne 10fbf2 { static char c = 'a'; pipe_control_t *pipe; int err = -ENOMEM; pipe = malloc(sizeof(pipe_control_t)); 10fa9c: 83 ec 0c sub $0xc,%esp 10fa9f: 6a 34 push $0x34 10faa1: e8 12 95 ff ff call 108fb8 10faa6: 89 c3 mov %eax,%ebx 10faa8: 89 45 d4 mov %eax,-0x2c(%ebp) if (pipe == NULL) 10faab: 83 c4 10 add $0x10,%esp 10faae: 85 c0 test %eax,%eax 10fab0: 0f 84 35 01 00 00 je 10fbeb return err; memset(pipe, 0, sizeof(pipe_control_t)); 10fab6: b9 0d 00 00 00 mov $0xd,%ecx 10fabb: 89 c7 mov %eax,%edi 10fabd: 89 f0 mov %esi,%eax 10fabf: f3 ab rep stos %eax,%es:(%edi) pipe->Size = PIPE_BUF; 10fac1: c7 43 04 00 02 00 00 movl $0x200,0x4(%ebx) pipe->Buffer = malloc(pipe->Size); 10fac8: 83 ec 0c sub $0xc,%esp 10facb: 68 00 02 00 00 push $0x200 10fad0: e8 e3 94 ff ff call 108fb8 10fad5: 89 03 mov %eax,(%ebx) if (! pipe->Buffer) 10fad7: 83 c4 10 add $0x10,%esp 10fada: 85 c0 test %eax,%eax 10fadc: 0f 84 fb 00 00 00 je 10fbdd <== NEVER TAKEN goto err_buf; err = -ENOMEM; if (rtems_barrier_create( 10fae2: 8d 43 2c lea 0x2c(%ebx),%eax 10fae5: 50 push %eax 10fae6: 6a 00 push $0x0 10fae8: 6a 00 push $0x0 rtems_build_name ('P', 'I', 'r', c), 10faea: 0f be 05 74 50 12 00 movsbl 0x125074,%eax if (! pipe->Buffer) goto err_buf; err = -ENOMEM; if (rtems_barrier_create( 10faf1: 0d 00 72 49 50 or $0x50497200,%eax 10faf6: 50 push %eax 10faf7: e8 44 18 00 00 call 111340 10fafc: 83 c4 10 add $0x10,%esp 10faff: 85 c0 test %eax,%eax 10fb01: 0f 85 c6 00 00 00 jne 10fbcd rtems_build_name ('P', 'I', 'r', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->readBarrier) != RTEMS_SUCCESSFUL) goto err_rbar; if (rtems_barrier_create( 10fb07: 8d 43 30 lea 0x30(%ebx),%eax 10fb0a: 50 push %eax 10fb0b: 6a 00 push $0x0 10fb0d: 6a 00 push $0x0 rtems_build_name ('P', 'I', 'w', c), 10fb0f: 0f be 05 74 50 12 00 movsbl 0x125074,%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( 10fb16: 0d 00 77 49 50 or $0x50497700,%eax 10fb1b: 50 push %eax 10fb1c: e8 1f 18 00 00 call 111340 10fb21: 83 c4 10 add $0x10,%esp 10fb24: 85 c0 test %eax,%eax 10fb26: 0f 85 90 00 00 00 jne 10fbbc rtems_build_name ('P', 'I', 'w', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->writeBarrier) != RTEMS_SUCCESSFUL) goto err_wbar; if (rtems_semaphore_create( 10fb2c: 83 ec 0c sub $0xc,%esp 10fb2f: 8d 43 28 lea 0x28(%ebx),%eax 10fb32: 50 push %eax 10fb33: 6a 00 push $0x0 10fb35: 6a 10 push $0x10 10fb37: 6a 01 push $0x1 rtems_build_name ('P', 'I', 's', c), 1, 10fb39: 0f be 05 74 50 12 00 movsbl 0x125074,%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( 10fb40: 0d 00 73 49 50 or $0x50497300,%eax 10fb45: 50 push %eax 10fb46: e8 9d be ff ff call 10b9e8 10fb4b: 83 c4 20 add $0x20,%esp 10fb4e: 85 c0 test %eax,%eax 10fb50: 75 59 jne 10fbab Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) _Objects_Get( &_Barrier_Information, id, location ); 10fb52: 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 10fb53: 8d 7d e0 lea -0x20(%ebp),%edi 10fb56: 57 push %edi 10fb57: ff 73 2c pushl 0x2c(%ebx) 10fb5a: 68 e4 7b 12 00 push $0x127be4 10fb5f: e8 f4 d5 ff ff call 10d158 <_Objects_Get> |= STATES_INTERRUPTIBLE_BY_SIGNAL; 10fb64: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax) _Thread_Enable_dispatch(); 10fb6b: e8 f6 dd ff ff call 10d966 <_Thread_Enable_dispatch> 10fb70: 83 c4 0c add $0xc,%esp 10fb73: 57 push %edi 10fb74: ff 73 30 pushl 0x30(%ebx) 10fb77: 68 e4 7b 12 00 push $0x127be4 10fb7c: e8 d7 d5 ff ff call 10d158 <_Objects_Get> _Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state |= STATES_INTERRUPTIBLE_BY_SIGNAL; 10fb81: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax) _Thread_Enable_dispatch(); 10fb88: e8 d9 dd ff ff call 10d966 <_Thread_Enable_dispatch> #ifdef RTEMS_POSIX_API pipe_interruptible(pipe); #endif *pipep = pipe; if (c ++ == 'z') 10fb8d: a0 74 50 12 00 mov 0x125074,%al 10fb92: 8d 50 01 lea 0x1(%eax),%edx 10fb95: 88 15 74 50 12 00 mov %dl,0x125074 10fb9b: 83 c4 10 add $0x10,%esp 10fb9e: 3c 7a cmp $0x7a,%al 10fba0: 75 50 jne 10fbf2 c = 'a'; 10fba2: c6 05 74 50 12 00 61 movb $0x61,0x125074 10fba9: eb 47 jmp 10fbf2 return 0; err_sem: rtems_barrier_delete(pipe->writeBarrier); 10fbab: 83 ec 0c sub $0xc,%esp 10fbae: 8b 55 d4 mov -0x2c(%ebp),%edx 10fbb1: ff 72 30 pushl 0x30(%edx) 10fbb4: e8 3f 18 00 00 call 1113f8 10fbb9: 83 c4 10 add $0x10,%esp err_wbar: rtems_barrier_delete(pipe->readBarrier); 10fbbc: 83 ec 0c sub $0xc,%esp 10fbbf: 8b 45 d4 mov -0x2c(%ebp),%eax 10fbc2: ff 70 2c pushl 0x2c(%eax) 10fbc5: e8 2e 18 00 00 call 1113f8 10fbca: 83 c4 10 add $0x10,%esp err_rbar: free(pipe->Buffer); 10fbcd: 83 ec 0c sub $0xc,%esp 10fbd0: 8b 55 d4 mov -0x2c(%ebp),%edx 10fbd3: ff 32 pushl (%edx) 10fbd5: e8 ba 8d ff ff call 108994 10fbda: 83 c4 10 add $0x10,%esp err_buf: free(pipe); 10fbdd: 83 ec 0c sub $0xc,%esp 10fbe0: ff 75 d4 pushl -0x2c(%ebp) 10fbe3: e8 ac 8d ff ff call 108994 10fbe8: 83 c4 10 add $0x10,%esp if (err) goto out; } if (! PIPE_LOCK(pipe)) err = -EINTR; 10fbeb: be f4 ff ff ff mov $0xfffffff4,%esi 10fbf0: eb 33 jmp 10fc25 err = pipe_alloc(&pipe); if (err) goto out; } if (! PIPE_LOCK(pipe)) 10fbf2: 50 push %eax 10fbf3: 6a 00 push $0x0 10fbf5: 6a 00 push $0x0 10fbf7: ff 73 28 pushl 0x28(%ebx) 10fbfa: e8 11 c0 ff ff call 10bc10 10fbff: 83 c4 10 add $0x10,%esp 10fc02: 85 c0 test %eax,%eax 10fc04: 74 05 je 10fc0b <== ALWAYS TAKEN err = -EINTR; 10fc06: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED if (*pipep == NULL) { 10fc0b: 8b 45 08 mov 0x8(%ebp),%eax 10fc0e: 83 38 00 cmpl $0x0,(%eax) 10fc11: 75 12 jne 10fc25 if (err) 10fc13: 85 f6 test %esi,%esi 10fc15: 74 09 je 10fc20 <== ALWAYS TAKEN pipe_free(pipe); 10fc17: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10fc19: e8 1c fd ff ff call 10f93a <== NOT EXECUTED 10fc1e: eb 05 jmp 10fc25 <== NOT EXECUTED else *pipep = pipe; 10fc20: 8b 55 08 mov 0x8(%ebp),%edx 10fc23: 89 1a mov %ebx,(%edx) } out: pipe_unlock(); 10fc25: e8 fa fc ff ff call 10f924 pipe_control_t *pipe; unsigned int prevCounter; int err; err = pipe_new(pipep); if (err) 10fc2a: 85 f6 test %esi,%esi 10fc2c: 0f 85 94 01 00 00 jne 10fdc6 return err; pipe = *pipep; 10fc32: 8b 45 08 mov 0x8(%ebp),%eax 10fc35: 8b 18 mov (%eax),%ebx switch (LIBIO_ACCMODE(iop)) { 10fc37: 8b 55 0c mov 0xc(%ebp),%edx 10fc3a: 8b 42 14 mov 0x14(%edx),%eax 10fc3d: 83 e0 06 and $0x6,%eax 10fc40: 83 f8 04 cmp $0x4,%eax 10fc43: 0f 84 91 00 00 00 je 10fcda 10fc49: 83 f8 06 cmp $0x6,%eax 10fc4c: 0f 84 10 01 00 00 je 10fd62 10fc52: 83 f8 02 cmp $0x2,%eax 10fc55: 0f 85 49 01 00 00 jne 10fda4 <== NEVER TAKEN case LIBIO_FLAGS_READ: pipe->readerCounter ++; 10fc5b: ff 43 20 incl 0x20(%ebx) if (pipe->Readers ++ == 0) 10fc5e: 8b 43 10 mov 0x10(%ebx),%eax 10fc61: 8d 50 01 lea 0x1(%eax),%edx 10fc64: 89 53 10 mov %edx,0x10(%ebx) 10fc67: 85 c0 test %eax,%eax 10fc69: 75 11 jne 10fc7c <== NEVER TAKEN PIPE_WAKEUPWRITERS(pipe); 10fc6b: 57 push %edi 10fc6c: 57 push %edi 10fc6d: 8d 45 e4 lea -0x1c(%ebp),%eax 10fc70: 50 push %eax 10fc71: ff 73 30 pushl 0x30(%ebx) 10fc74: e8 07 18 00 00 call 111480 10fc79: 83 c4 10 add $0x10,%esp if (pipe->Writers == 0) { 10fc7c: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10fc80: 0f 85 1e 01 00 00 jne 10fda4 /* Not an error */ if (LIBIO_NODELAY(iop)) 10fc86: 8b 45 0c mov 0xc(%ebp),%eax 10fc89: f6 40 14 01 testb $0x1,0x14(%eax) 10fc8d: 0f 85 11 01 00 00 jne 10fda4 break; prevCounter = pipe->writerCounter; 10fc93: 8b 7b 24 mov 0x24(%ebx),%edi err = -EINTR; /* Wait until a writer opens the pipe */ do { PIPE_UNLOCK(pipe); 10fc96: 83 ec 0c sub $0xc,%esp 10fc99: ff 73 28 pushl 0x28(%ebx) 10fc9c: e8 5b c0 ff ff call 10bcfc if (! PIPE_READWAIT(pipe)) 10fca1: 5a pop %edx 10fca2: 59 pop %ecx 10fca3: 6a 00 push $0x0 10fca5: ff 73 2c pushl 0x2c(%ebx) 10fca8: e8 2b 18 00 00 call 1114d8 10fcad: 83 c4 10 add $0x10,%esp 10fcb0: 85 c0 test %eax,%eax 10fcb2: 0f 85 f9 00 00 00 jne 10fdb1 <== NEVER TAKEN goto out_error; if (! PIPE_LOCK(pipe)) 10fcb8: 50 push %eax 10fcb9: 6a 00 push $0x0 10fcbb: 6a 00 push $0x0 10fcbd: ff 73 28 pushl 0x28(%ebx) 10fcc0: e8 4b bf ff ff call 10bc10 10fcc5: 83 c4 10 add $0x10,%esp 10fcc8: 85 c0 test %eax,%eax 10fcca: 0f 85 e1 00 00 00 jne 10fdb1 <== NEVER TAKEN goto out_error; } while (prevCounter == pipe->writerCounter); 10fcd0: 3b 7b 24 cmp 0x24(%ebx),%edi 10fcd3: 74 c1 je 10fc96 <== NEVER TAKEN 10fcd5: e9 ca 00 00 00 jmp 10fda4 } break; case LIBIO_FLAGS_WRITE: pipe->writerCounter ++; 10fcda: ff 43 24 incl 0x24(%ebx) if (pipe->Writers ++ == 0) 10fcdd: 8b 43 14 mov 0x14(%ebx),%eax 10fce0: 8d 50 01 lea 0x1(%eax),%edx 10fce3: 89 53 14 mov %edx,0x14(%ebx) 10fce6: 85 c0 test %eax,%eax 10fce8: 75 11 jne 10fcfb <== NEVER TAKEN PIPE_WAKEUPREADERS(pipe); 10fcea: 57 push %edi 10fceb: 57 push %edi 10fcec: 8d 45 e4 lea -0x1c(%ebp),%eax 10fcef: 50 push %eax 10fcf0: ff 73 2c pushl 0x2c(%ebx) 10fcf3: e8 88 17 00 00 call 111480 10fcf8: 83 c4 10 add $0x10,%esp if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) { 10fcfb: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10fcff: 0f 85 9f 00 00 00 jne 10fda4 10fd05: 8b 55 0c mov 0xc(%ebp),%edx 10fd08: f6 42 14 01 testb $0x1,0x14(%edx) 10fd0c: 74 18 je 10fd26 PIPE_UNLOCK(pipe); 10fd0e: 83 ec 0c sub $0xc,%esp 10fd11: ff 73 28 pushl 0x28(%ebx) 10fd14: e8 e3 bf ff ff call 10bcfc err = -ENXIO; goto out_error; 10fd19: 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; 10fd1c: be fa ff ff ff mov $0xfffffffa,%esi goto out_error; 10fd21: e9 90 00 00 00 jmp 10fdb6 } if (pipe->Readers == 0) { prevCounter = pipe->readerCounter; 10fd26: 8b 7b 20 mov 0x20(%ebx),%edi err = -EINTR; do { PIPE_UNLOCK(pipe); 10fd29: 83 ec 0c sub $0xc,%esp 10fd2c: ff 73 28 pushl 0x28(%ebx) 10fd2f: e8 c8 bf ff ff call 10bcfc if (! PIPE_WRITEWAIT(pipe)) 10fd34: 5a pop %edx 10fd35: 59 pop %ecx 10fd36: 6a 00 push $0x0 10fd38: ff 73 30 pushl 0x30(%ebx) 10fd3b: e8 98 17 00 00 call 1114d8 10fd40: 83 c4 10 add $0x10,%esp 10fd43: 85 c0 test %eax,%eax 10fd45: 75 6a jne 10fdb1 <== NEVER TAKEN goto out_error; if (! PIPE_LOCK(pipe)) 10fd47: 50 push %eax 10fd48: 6a 00 push $0x0 10fd4a: 6a 00 push $0x0 10fd4c: ff 73 28 pushl 0x28(%ebx) 10fd4f: e8 bc be ff ff call 10bc10 10fd54: 83 c4 10 add $0x10,%esp 10fd57: 85 c0 test %eax,%eax 10fd59: 75 56 jne 10fdb1 <== NEVER TAKEN goto out_error; } while (prevCounter == pipe->readerCounter); 10fd5b: 3b 7b 20 cmp 0x20(%ebx),%edi 10fd5e: 74 c9 je 10fd29 <== NEVER TAKEN 10fd60: eb 42 jmp 10fda4 } break; case LIBIO_FLAGS_READ_WRITE: pipe->readerCounter ++; 10fd62: ff 43 20 incl 0x20(%ebx) if (pipe->Readers ++ == 0) 10fd65: 8b 43 10 mov 0x10(%ebx),%eax 10fd68: 8d 50 01 lea 0x1(%eax),%edx 10fd6b: 89 53 10 mov %edx,0x10(%ebx) 10fd6e: 85 c0 test %eax,%eax 10fd70: 75 11 jne 10fd83 <== NEVER TAKEN PIPE_WAKEUPWRITERS(pipe); 10fd72: 51 push %ecx 10fd73: 51 push %ecx 10fd74: 8d 45 e4 lea -0x1c(%ebp),%eax 10fd77: 50 push %eax 10fd78: ff 73 30 pushl 0x30(%ebx) 10fd7b: e8 00 17 00 00 call 111480 10fd80: 83 c4 10 add $0x10,%esp pipe->writerCounter ++; 10fd83: ff 43 24 incl 0x24(%ebx) if (pipe->Writers ++ == 0) 10fd86: 8b 43 14 mov 0x14(%ebx),%eax 10fd89: 8d 50 01 lea 0x1(%eax),%edx 10fd8c: 89 53 14 mov %edx,0x14(%ebx) 10fd8f: 85 c0 test %eax,%eax 10fd91: 75 11 jne 10fda4 <== NEVER TAKEN PIPE_WAKEUPREADERS(pipe); 10fd93: 52 push %edx 10fd94: 52 push %edx 10fd95: 8d 45 e4 lea -0x1c(%ebp),%eax 10fd98: 50 push %eax 10fd99: ff 73 2c pushl 0x2c(%ebx) 10fd9c: e8 df 16 00 00 call 111480 10fda1: 83 c4 10 add $0x10,%esp break; } PIPE_UNLOCK(pipe); 10fda4: 83 ec 0c sub $0xc,%esp 10fda7: ff 73 28 pushl 0x28(%ebx) 10fdaa: e8 4d bf ff ff call 10bcfc 10fdaf: eb 12 jmp 10fdc3 goto out_error; } if (pipe->Readers == 0) { prevCounter = pipe->readerCounter; err = -EINTR; 10fdb1: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED PIPE_UNLOCK(pipe); return 0; out_error: pipe_release(pipep, iop); 10fdb6: 50 push %eax 10fdb7: 50 push %eax 10fdb8: ff 75 0c pushl 0xc(%ebp) 10fdbb: ff 75 08 pushl 0x8(%ebp) 10fdbe: e8 b2 fb ff ff call 10f975 return err; 10fdc3: 83 c4 10 add $0x10,%esp } 10fdc6: 89 f0 mov %esi,%eax 10fdc8: 8d 65 f4 lea -0xc(%ebp),%esp 10fdcb: 5b pop %ebx 10fdcc: 5e pop %esi 10fdcd: 5f pop %edi 10fdce: c9 leave 10fdcf: c3 ret =============================================================================== 00107d8c : long fpathconf( int fd, int name ) { 107d8c: 55 push %ebp 107d8d: 89 e5 mov %esp,%ebp 107d8f: 83 ec 08 sub $0x8,%esp 107d92: 8b 45 08 mov 0x8(%ebp),%eax 107d95: 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); 107d98: 3b 05 44 21 12 00 cmp 0x122144,%eax 107d9e: 73 11 jae 107db1 iop = rtems_libio_iop(fd); 107da0: 6b c0 38 imul $0x38,%eax,%eax 107da3: 03 05 98 61 12 00 add 0x126198,%eax rtems_libio_check_is_open(iop); 107da9: 8b 48 14 mov 0x14(%eax),%ecx 107dac: f6 c5 01 test $0x1,%ch 107daf: 75 0d jne 107dbe <== ALWAYS TAKEN 107db1: e8 5e a1 00 00 call 111f14 <__errno> 107db6: c7 00 09 00 00 00 movl $0x9,(%eax) 107dbc: eb 5b jmp 107e19 rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ); 107dbe: 80 e1 02 and $0x2,%cl 107dc1: 74 4b je 107e0e /* * Now process the information request. */ the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options; 107dc3: 8b 40 28 mov 0x28(%eax),%eax switch ( name ) { 107dc6: 83 fa 0b cmp $0xb,%edx 107dc9: 77 43 ja 107e0e 107dcb: ff 24 95 50 ff 11 00 jmp *0x11ff50(,%edx,4) case _PC_LINK_MAX: return_value = the_limits->link_max; 107dd2: 8b 40 38 mov 0x38(%eax),%eax break; 107dd5: eb 45 jmp 107e1c case _PC_MAX_CANON: return_value = the_limits->max_canon; 107dd7: 8b 40 3c mov 0x3c(%eax),%eax break; 107dda: eb 40 jmp 107e1c case _PC_MAX_INPUT: return_value = the_limits->max_input; 107ddc: 8b 40 40 mov 0x40(%eax),%eax break; 107ddf: eb 3b jmp 107e1c case _PC_NAME_MAX: return_value = the_limits->name_max; 107de1: 8b 40 44 mov 0x44(%eax),%eax break; 107de4: eb 36 jmp 107e1c case _PC_PATH_MAX: return_value = the_limits->path_max; 107de6: 8b 40 48 mov 0x48(%eax),%eax break; 107de9: eb 31 jmp 107e1c case _PC_PIPE_BUF: return_value = the_limits->pipe_buf; 107deb: 8b 40 4c mov 0x4c(%eax),%eax break; 107dee: eb 2c jmp 107e1c case _PC_CHOWN_RESTRICTED: return_value = the_limits->posix_chown_restrictions; 107df0: 8b 40 54 mov 0x54(%eax),%eax break; 107df3: eb 27 jmp 107e1c case _PC_NO_TRUNC: return_value = the_limits->posix_no_trunc; 107df5: 8b 40 58 mov 0x58(%eax),%eax break; 107df8: eb 22 jmp 107e1c case _PC_VDISABLE: return_value = the_limits->posix_vdisable; 107dfa: 8b 40 64 mov 0x64(%eax),%eax break; 107dfd: eb 1d jmp 107e1c case _PC_ASYNC_IO: return_value = the_limits->posix_async_io; 107dff: 8b 40 50 mov 0x50(%eax),%eax break; 107e02: eb 18 jmp 107e1c case _PC_PRIO_IO: return_value = the_limits->posix_prio_io; 107e04: 8b 40 5c mov 0x5c(%eax),%eax break; 107e07: eb 13 jmp 107e1c case _PC_SYNC_IO: return_value = the_limits->posix_sync_io; 107e09: 8b 40 60 mov 0x60(%eax),%eax break; 107e0c: eb 0e jmp 107e1c default: rtems_set_errno_and_return_minus_one( EINVAL ); 107e0e: e8 01 a1 00 00 call 111f14 <__errno> 107e13: c7 00 16 00 00 00 movl $0x16,(%eax) 107e19: 83 c8 ff or $0xffffffff,%eax break; } return return_value; } 107e1c: c9 leave 107e1d: 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 bc 41 12 00 incl 0x1241bc 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 64 44 12 00 03 cmpl $0x3,0x124464 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 10 26 12 00 mov 0x122610,%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 01 12 00 pushl 0x120150 107396: e8 15 46 00 00 call 10b9b0 <_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 01 12 00 mov 0x120150,%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 db e5 11 00 push $0x11e5db 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 =============================================================================== 001085d0 : * NOTE: this must be called with * thread dispatching disabled! */ static void free_user_env(void *venv) { 1085d0: 55 push %ebp 1085d1: 89 e5 mov %esp,%ebp 1085d3: 53 push %ebx 1085d4: 83 ec 04 sub $0x4,%esp 1085d7: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_user_env_t *env = (rtems_user_env_t*) venv ; if (env != &rtems_global_user_env 1085da: 81 fb c8 51 12 00 cmp $0x1251c8,%ebx 1085e0: 74 26 je 108608 <== NEVER TAKEN #ifdef HAVE_USERENV_REFCNT && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); 1085e2: 83 ec 0c sub $0xc,%esp 1085e5: 8d 43 04 lea 0x4(%ebx),%eax 1085e8: 50 push %eax 1085e9: e8 6a f1 ff ff call 107758 rtems_filesystem_freenode( &env->root_directory); 1085ee: 8d 43 18 lea 0x18(%ebx),%eax 1085f1: 89 04 24 mov %eax,(%esp) 1085f4: e8 5f f1 ff ff call 107758 free(env); 1085f9: 83 c4 10 add $0x10,%esp 1085fc: 89 5d 08 mov %ebx,0x8(%ebp) } } 1085ff: 8b 5d fc mov -0x4(%ebp),%ebx 108602: c9 leave && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); rtems_filesystem_freenode( &env->root_directory); free(env); 108603: e9 64 f1 ff ff jmp 10776c } } 108608: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10860b: c9 leave <== NOT EXECUTED 10860c: c3 ret <== NOT EXECUTED =============================================================================== 0011de58 : int getdents( int dd_fd, char *dd_buf, int dd_len ) { 11de58: 55 push %ebp 11de59: 89 e5 mov %esp,%ebp 11de5b: 57 push %edi 11de5c: 56 push %esi 11de5d: 53 push %ebx 11de5e: 83 ec 2c sub $0x2c,%esp 11de61: 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 ); 11de64: 31 db xor %ebx,%ebx 11de66: 3b 05 44 31 12 00 cmp 0x123144,%eax 11de6c: 73 09 jae 11de77 <== NEVER TAKEN 11de6e: 6b d8 38 imul $0x38,%eax,%ebx 11de71: 03 1d c0 72 12 00 add 0x1272c0,%ebx /* * Make sure we are working on a directory */ loc = iop->pathinfo; 11de77: 8d 7d d4 lea -0x2c(%ebp),%edi 11de7a: 8d 73 18 lea 0x18(%ebx),%esi 11de7d: b9 05 00 00 00 mov $0x5,%ecx 11de82: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) 11de84: 83 ec 0c sub $0xc,%esp 11de87: 8d 45 d4 lea -0x2c(%ebp),%eax 11de8a: 50 push %eax 11de8b: 8b 45 e0 mov -0x20(%ebp),%eax 11de8e: ff 50 10 call *0x10(%eax) 11de91: 83 c4 10 add $0x10,%esp 11de94: 48 dec %eax 11de95: 74 10 je 11dea7 rtems_set_errno_and_return_minus_one( ENOTDIR ); 11de97: e8 98 41 ff ff call 112034 <__errno> 11de9c: c7 00 14 00 00 00 movl $0x14,(%eax) 11dea2: 83 c8 ff or $0xffffffff,%eax 11dea5: eb 11 jmp 11deb8 /* * 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 ); 11dea7: 50 push %eax 11dea8: 8b 43 20 mov 0x20(%ebx),%eax 11deab: ff 75 10 pushl 0x10(%ebp) 11deae: ff 75 0c pushl 0xc(%ebp) 11deb1: 53 push %ebx 11deb2: ff 50 08 call *0x8(%eax) 11deb5: 83 c4 10 add $0x10,%esp } 11deb8: 8d 65 f4 lea -0xc(%ebp),%esp 11debb: 5b pop %ebx 11debc: 5e pop %esi 11debd: 5f pop %edi 11debe: c9 leave 11debf: c3 ret =============================================================================== 00110690 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 110690: 55 push %ebp 110691: 89 e5 mov %esp,%ebp 110693: 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 ) 110696: 8b 4a 18 mov 0x18(%edx),%ecx return -1; /* It wasn't a directory --> return error */ 110699: 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 ) 11069c: 83 79 4c 01 cmpl $0x1,0x4c(%ecx) 1106a0: 75 10 jne 1106b2 <== NEVER TAKEN return -1; /* It wasn't a directory --> return error */ iop->offset = 0; 1106a2: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) 1106a9: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) return 0; 1106b0: 31 c0 xor %eax,%eax } 1106b2: c9 leave 1106b3: c3 ret =============================================================================== 001108f1 : int imfs_dir_rmnod( rtems_filesystem_location_info_t *parent_pathloc, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN */ ) { 1108f1: 55 push %ebp 1108f2: 89 e5 mov %esp,%ebp 1108f4: 53 push %ebx 1108f5: 83 ec 04 sub $0x4,%esp 1108f8: 8b 45 0c mov 0xc(%ebp),%eax IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 1108fb: 8b 18 mov (%eax),%ebx 1108fd: 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 ) ) 110900: 39 53 50 cmp %edx,0x50(%ebx) 110903: 74 0d je 110912 rtems_set_errno_and_return_minus_one( ENOTEMPTY ); 110905: e8 a2 07 00 00 call 1110ac <__errno> 11090a: c7 00 5a 00 00 00 movl $0x5a,(%eax) 110910: eb 13 jmp 110925 /* * You cannot remove the file system root node. */ if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access ) 110912: 8b 40 10 mov 0x10(%eax),%eax 110915: 39 58 1c cmp %ebx,0x1c(%eax) 110918: 75 10 jne 11092a rtems_set_errno_and_return_minus_one( EBUSY ); 11091a: e8 8d 07 00 00 call 1110ac <__errno> 11091f: c7 00 10 00 00 00 movl $0x10,(%eax) 110925: 83 c8 ff or $0xffffffff,%eax 110928: eb 1c jmp 110946 /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) 11092a: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx) 11092e: 75 ea jne 11091a <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EBUSY ); IMFS_create_orphan( the_jnode ); 110930: 83 ec 0c sub $0xc,%esp 110933: 53 push %ebx 110934: e8 23 d4 ff ff call 10dd5c IMFS_check_node_remove( the_jnode ); 110939: 89 1c 24 mov %ebx,(%esp) 11093c: e8 5d d4 ff ff call 10dd9e return 0; 110941: 83 c4 10 add $0x10,%esp 110944: 31 c0 xor %eax,%eax } 110946: 8b 5d fc mov -0x4(%ebp),%ebx 110949: c9 leave 11094a: 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 60 12 00 00 cmpb $0x0,0x12605c 107c7a: 0f 85 b8 00 00 00 jne 107d38 return; etc_passwd_initted = 1; 107c80: c6 05 5c 60 12 00 01 movb $0x1,0x12605c mkdir("/etc", 0777); 107c87: 50 push %eax 107c88: 50 push %eax 107c89: 68 ff 01 00 00 push $0x1ff 107c8e: 68 87 fe 11 00 push $0x11fe87 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 d2 eb 11 00 push $0x11ebd2 107c9f: 68 8c fe 11 00 push $0x11fe8c 107ca4: e8 ef a9 00 00 call 112698 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 ec ea 11 00 push $0x11eaec 107cbd: 68 8c fe 11 00 push $0x11fe8c 107cc2: e8 d1 a9 00 00 call 112698 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 98 fe 11 00 push $0x11fe98 107cd8: e8 87 aa 00 00 call 112764 "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 af a2 00 00 call 111f94 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 d2 eb 11 00 push $0x11ebd2 107cef: 68 ff fe 11 00 push $0x11feff 107cf4: e8 9f a9 00 00 call 112698 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 ec ea 11 00 push $0x11eaec 107d0d: 68 ff fe 11 00 push $0x11feff 107d12: e8 81 a9 00 00 call 112698 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 0a ff 11 00 push $0x11ff0a 107d28: e8 37 aa 00 00 call 112764 "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); 107d2d: 89 1c 24 mov %ebx,(%esp) 107d30: e8 5f a2 00 00 call 111f94 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 08 21 12 00 mov 0x122108,%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 40 20 12 00 mov 0x122040,%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 =============================================================================== 00121620 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 121620: 55 push %ebp 121621: 89 e5 mov %esp,%ebp 121623: 57 push %edi 121624: 56 push %esi 121625: 53 push %ebx 121626: 83 ec 4c sub $0x4c,%esp 121629: 8b 5d 0c mov 0xc(%ebp),%ebx 12162c: 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() ) 12162f: e8 64 fd ff ff call 121398 121634: 39 45 08 cmp %eax,0x8(%ebp) 121637: 74 0d je 121646 rtems_set_errno_and_return_minus_one( ESRCH ); 121639: e8 16 43 ff ff call 115954 <__errno> 12163e: c7 00 03 00 00 00 movl $0x3,(%eax) 121644: eb 0f jmp 121655 /* * Validate the signal passed. */ if ( !sig ) 121646: 85 db test %ebx,%ebx 121648: 75 13 jne 12165d rtems_set_errno_and_return_minus_one( EINVAL ); 12164a: e8 05 43 ff ff call 115954 <__errno> 12164f: c7 00 16 00 00 00 movl $0x16,(%eax) 121655: 83 c8 ff or $0xffffffff,%eax 121658: e9 ef 01 00 00 jmp 12184c static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 12165d: 8d 4b ff lea -0x1(%ebx),%ecx if ( !is_valid_signo(sig) ) 121660: 83 f9 1f cmp $0x1f,%ecx 121663: 77 e5 ja 12164a 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 ) 121665: 6b d3 0c imul $0xc,%ebx,%edx return 0; 121668: 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 ) 12166a: 83 ba c0 a9 12 00 01 cmpl $0x1,0x12a9c0(%edx) 121671: 0f 84 d5 01 00 00 je 12184c /* * 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 ) ) 121677: 83 fb 04 cmp $0x4,%ebx 12167a: 74 0a je 121686 12167c: 83 fb 08 cmp $0x8,%ebx 12167f: 74 05 je 121686 121681: 83 fb 0b cmp $0xb,%ebx 121684: 75 16 jne 12169c return pthread_kill( pthread_self(), sig ); 121686: e8 89 03 00 00 call 121a14 12168b: 56 push %esi 12168c: 56 push %esi 12168d: 53 push %ebx 12168e: 50 push %eax 12168f: e8 d8 02 00 00 call 12196c 121694: 83 c4 10 add $0x10,%esp 121697: e9 b0 01 00 00 jmp 12184c static inline sigset_t signo_to_mask( uint32_t sig ) { return 1u << (sig - 1); 12169c: be 01 00 00 00 mov $0x1,%esi 1216a1: d3 e6 shl %cl,%esi /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 1216a3: 89 5d dc mov %ebx,-0x24(%ebp) siginfo->si_code = SI_USER; 1216a6: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) if ( !value ) { 1216ad: 85 ff test %edi,%edi 1216af: 75 09 jne 1216ba siginfo->si_value.sival_int = 0; 1216b1: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 1216b8: eb 05 jmp 1216bf } else { siginfo->si_value = *value; 1216ba: 8b 07 mov (%edi),%eax 1216bc: 89 45 e4 mov %eax,-0x1c(%ebp) 1216bf: a1 58 a4 12 00 mov 0x12a458,%eax 1216c4: 40 inc %eax 1216c5: a3 58 a4 12 00 mov %eax,0x12a458 /* * 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; 1216ca: a1 a8 a9 12 00 mov 0x12a9a8,%eax api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 1216cf: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx 1216d5: 8b 92 d0 00 00 00 mov 0xd0(%edx),%edx 1216db: f7 d2 not %edx 1216dd: 85 d6 test %edx,%esi 1216df: 0f 85 ed 00 00 00 jne 1217d2 /* XXX violation of visibility -- need to define thread queue support */ the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = the_chain->first ; 1216e5: 8b 15 44 ab 12 00 mov 0x12ab44,%edx 1216eb: eb 23 jmp 121710 !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; 1216ed: 89 d0 mov %edx,%eax api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 1216ef: 8b 8a f8 00 00 00 mov 0xf8(%edx),%ecx #endif /* * Is this thread is actually blocked waiting for the signal? */ if (the_thread->Wait.option & mask) 1216f5: 85 72 30 test %esi,0x30(%edx) 1216f8: 0f 85 d4 00 00 00 jne 1217d2 /* * Is this thread is blocked waiting for another signal but has * not blocked this one? */ if (~api->signals_blocked & mask) 1216fe: 8b 89 d0 00 00 00 mov 0xd0(%ecx),%ecx 121704: f7 d1 not %ecx 121706: 85 ce test %ecx,%esi 121708: 0f 85 c4 00 00 00 jne 1217d2 the_chain = &_POSIX_signals_Wait_queue.Queues.Fifo; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 12170e: 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 = the_chain->first ; 121710: 81 fa 48 ab 12 00 cmp $0x12ab48,%edx 121716: 75 d5 jne 1216ed * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 121718: 0f b6 0d f4 61 12 00 movzbl 0x1261f4,%ecx 12171f: 41 inc %ecx * * NOTES: * * + rtems internal threads do not receive signals. */ interested = NULL; 121720: 31 c0 xor %eax,%eax interested_priority = PRIORITY_MAXIMUM + 1; for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) { 121722: 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 ] ) 121729: 8b 7d cc mov -0x34(%ebp),%edi 12172c: 8b 14 bd 30 a4 12 00 mov 0x12a430(,%edi,4),%edx 121733: 85 d2 test %edx,%edx 121735: 0f 84 86 00 00 00 je 1217c1 <== NEVER TAKEN continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 12173b: 8b 52 04 mov 0x4(%edx),%edx */ if ( !the_info ) continue; #endif maximum = the_info->maximum; 12173e: 0f b7 7a 10 movzwl 0x10(%edx),%edi 121742: 89 7d c4 mov %edi,-0x3c(%ebp) object_table = the_info->local_table; 121745: 8b 52 1c mov 0x1c(%edx),%edx 121748: 89 55 c0 mov %edx,-0x40(%ebp) for ( index = 1 ; index <= maximum ; index++ ) { 12174b: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp) 121752: 89 5d b4 mov %ebx,-0x4c(%ebp) 121755: eb 5f jmp 1217b6 the_thread = (Thread_Control *) object_table[ index ]; 121757: 8b 5d d0 mov -0x30(%ebp),%ebx 12175a: 8b 7d c0 mov -0x40(%ebp),%edi 12175d: 8b 14 9f mov (%edi,%ebx,4),%edx if ( !the_thread ) 121760: 85 d2 test %edx,%edx 121762: 74 4f je 1217b3 /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 121764: 8b 5a 14 mov 0x14(%edx),%ebx 121767: 89 5d d4 mov %ebx,-0x2c(%ebp) 12176a: 39 cb cmp %ecx,%ebx 12176c: 77 45 ja 1217b3 #if defined(RTEMS_DEBUG) if ( !api ) continue; #endif if ( !_POSIX_signals_Is_interested( api, mask ) ) 12176e: 8b ba f8 00 00 00 mov 0xf8(%edx),%edi 121774: 8b bf d0 00 00 00 mov 0xd0(%edi),%edi 12177a: f7 d7 not %edi 12177c: 85 fe test %edi,%esi 12177e: 74 33 je 1217b3 * * 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 ) { 121780: 39 cb cmp %ecx,%ebx 121782: 72 2a jb 1217ae * and blocking interruptibutable by signal. * * If the interested thread is ready, don't think about changing. */ if ( interested && !_States_Is_ready( interested->current_state ) ) { 121784: 85 c0 test %eax,%eax 121786: 74 2b je 1217b3 <== NEVER TAKEN 121788: 8b 78 10 mov 0x10(%eax),%edi 12178b: 89 7d c8 mov %edi,-0x38(%ebp) 12178e: 85 ff test %edi,%edi 121790: 74 21 je 1217b3 <== NEVER TAKEN /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 121792: 8b 7a 10 mov 0x10(%edx),%edi 121795: 85 ff test %edi,%edi 121797: 74 15 je 1217ae continue; } DEBUG_STEP("6"); /* prefer blocked/interruptible over blocked/not interruptible */ if ( !_States_Is_interruptible_by_signal(interested->current_state) ) { 121799: f7 45 c8 00 00 00 10 testl $0x10000000,-0x38(%ebp) 1217a0: 75 11 jne 1217b3 DEBUG_STEP("7"); if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) { 1217a2: 81 e7 00 00 00 10 and $0x10000000,%edi 1217a8: 74 09 je 1217b3 1217aa: 89 d9 mov %ebx,%ecx 1217ac: eb 03 jmp 1217b1 */ if ( interested && !_States_Is_ready( interested->current_state ) ) { /* preferred ready over blocked */ DEBUG_STEP("5"); if ( _States_Is_ready( the_thread->current_state ) ) { 1217ae: 8b 4d d4 mov -0x2c(%ebp),%ecx 1217b1: 89 d0 mov %edx,%eax #endif maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 1217b3: ff 45 d0 incl -0x30(%ebp) 1217b6: 8b 55 c4 mov -0x3c(%ebp),%edx 1217b9: 39 55 d0 cmp %edx,-0x30(%ebp) 1217bc: 76 99 jbe 121757 1217be: 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++) { 1217c1: ff 45 cc incl -0x34(%ebp) 1217c4: 83 7d cc 04 cmpl $0x4,-0x34(%ebp) 1217c8: 0f 85 5b ff ff ff jne 121729 } } } } if ( interested ) { 1217ce: 85 c0 test %eax,%eax 1217d0: 74 13 je 1217e5 /* * 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 ) ) { 1217d2: 51 push %ecx mask = signo_to_mask( sig ); /* * Build up a siginfo structure */ siginfo = &siginfo_struct; 1217d3: 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 ) ) { 1217d6: 52 push %edx 1217d7: 53 push %ebx 1217d8: 50 push %eax 1217d9: e8 8a 00 00 00 call 121868 <_POSIX_signals_Unblock_thread> 1217de: 83 c4 10 add $0x10,%esp 1217e1: 84 c0 test %al,%al 1217e3: 75 60 jne 121845 /* * 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 ); 1217e5: 83 ec 0c sub $0xc,%esp 1217e8: 56 push %esi 1217e9: e8 66 00 00 00 call 121854 <_POSIX_signals_Set_process_signals> if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 1217ee: 6b db 0c imul $0xc,%ebx,%ebx 1217f1: 83 c4 10 add $0x10,%esp 1217f4: 83 bb b8 a9 12 00 02 cmpl $0x2,0x12a9b8(%ebx) 1217fb: 75 48 jne 121845 psiginfo = (POSIX_signals_Siginfo_node *) _Chain_Get( &_POSIX_signals_Inactive_siginfo ); 1217fd: 83 ec 0c sub $0xc,%esp 121800: 68 38 ab 12 00 push $0x12ab38 121805: e8 2a d9 fe ff call 10f134 <_Chain_Get> if ( !psiginfo ) { 12180a: 83 c4 10 add $0x10,%esp 12180d: 85 c0 test %eax,%eax 12180f: 75 15 jne 121826 _Thread_Enable_dispatch(); 121811: e8 80 ee fe ff call 110696 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 121816: e8 39 41 ff ff call 115954 <__errno> 12181b: c7 00 0b 00 00 00 movl $0xb,(%eax) 121821: e9 2f fe ff ff jmp 121655 } psiginfo->Info = *siginfo; 121826: 8d 78 08 lea 0x8(%eax),%edi 121829: 8d 75 dc lea -0x24(%ebp),%esi 12182c: b9 03 00 00 00 mov $0x3,%ecx 121831: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 121833: 52 push %edx 121834: 52 push %edx 121835: 50 push %eax 121836: 81 c3 b0 ab 12 00 add $0x12abb0,%ebx 12183c: 53 push %ebx 12183d: e8 b6 d8 fe ff call 10f0f8 <_Chain_Append> 121842: 83 c4 10 add $0x10,%esp } DEBUG_STEP("\n"); _Thread_Enable_dispatch(); 121845: e8 4c ee fe ff call 110696 <_Thread_Enable_dispatch> return 0; 12184a: 31 c0 xor %eax,%eax } 12184c: 8d 65 f4 lea -0xc(%ebp),%esp 12184f: 5b pop %ebx 121850: 5e pop %esi 121851: 5f pop %edi 121852: c9 leave 121853: c3 ret =============================================================================== 0011c734 : extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) { 11c734: 55 push %ebp 11c735: 89 e5 mov %esp,%ebp 11c737: 53 push %ebx 11c738: 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())) 11c73b: 83 3d 64 44 12 00 03 cmpl $0x3,0x124464 11c742: 75 4f jne 11c793 <== NEVER TAKEN /* * This was already done if the user called exit() directly . _wrapup_reent(0); */ if (_REENT != _global_impure_ptr) { 11c744: 8b 1d e0 f0 11 00 mov 0x11f0e0,%ebx 11c74a: 39 1d 20 21 12 00 cmp %ebx,0x122120 11c750: 74 12 je 11c764 _wrapup_reent(_global_impure_ptr); 11c752: 83 ec 0c sub $0xc,%esp 11c755: 53 push %ebx 11c756: e8 b5 05 00 00 call 11cd10 <_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; 11c75b: 89 1d 20 21 12 00 mov %ebx,0x122120 11c761: 83 c4 10 add $0x10,%esp * * Should this be changed to do *all* file streams? * _fwalk (_REENT, fclose); */ fclose (stdin); 11c764: 83 ec 0c sub $0xc,%esp 11c767: a1 20 21 12 00 mov 0x122120,%eax 11c76c: ff 70 04 pushl 0x4(%eax) 11c76f: e8 90 4a ff ff call 111204 fclose (stdout); 11c774: 5a pop %edx 11c775: a1 20 21 12 00 mov 0x122120,%eax 11c77a: ff 70 08 pushl 0x8(%eax) 11c77d: e8 82 4a ff ff call 111204 fclose (stderr); 11c782: 58 pop %eax 11c783: a1 20 21 12 00 mov 0x122120,%eax 11c788: ff 70 0c pushl 0xc(%eax) 11c78b: e8 74 4a ff ff call 111204 11c790: 83 c4 10 add $0x10,%esp } 11c793: 8b 5d fc mov -0x4(%ebp),%ebx 11c796: c9 leave 11c797: c3 ret =============================================================================== 0011c640 : off_t lseek( int fd, off_t offset, int whence ) { 11c640: 55 push %ebp 11c641: 89 e5 mov %esp,%ebp 11c643: 57 push %edi 11c644: 56 push %esi 11c645: 53 push %ebx 11c646: 83 ec 1c sub $0x1c,%esp 11c649: 8b 5d 08 mov 0x8(%ebp),%ebx 11c64c: 8b 45 0c mov 0xc(%ebp),%eax 11c64f: 8b 55 10 mov 0x10(%ebp),%edx 11c652: 8b 4d 14 mov 0x14(%ebp),%ecx rtems_libio_t *iop; off_t old_offset; off_t status; rtems_libio_check_fd( fd ); 11c655: 3b 1d 44 01 12 00 cmp 0x120144,%ebx 11c65b: 73 0f jae 11c66c iop = rtems_libio_iop( fd ); 11c65d: 6b db 38 imul $0x38,%ebx,%ebx 11c660: 03 1d 98 41 12 00 add 0x124198,%ebx rtems_libio_check_is_open(iop); 11c666: f6 43 15 01 testb $0x1,0x15(%ebx) 11c66a: 75 0d jne 11c679 11c66c: e8 3b 4a ff ff call 1110ac <__errno> 11c671: c7 00 09 00 00 00 movl $0x9,(%eax) 11c677: eb 4b jmp 11c6c4 /* * Now process the lseek(). */ old_offset = iop->offset; 11c679: 8b 73 0c mov 0xc(%ebx),%esi 11c67c: 8b 7b 10 mov 0x10(%ebx),%edi 11c67f: 89 75 e0 mov %esi,-0x20(%ebp) 11c682: 89 7d e4 mov %edi,-0x1c(%ebp) switch ( whence ) { 11c685: 83 f9 01 cmp $0x1,%ecx 11c688: 74 11 je 11c69b 11c68a: 83 f9 02 cmp $0x2,%ecx 11c68d: 74 18 je 11c6a7 11c68f: 85 c9 test %ecx,%ecx 11c691: 75 26 jne 11c6b9 case SEEK_SET: iop->offset = offset; 11c693: 89 43 0c mov %eax,0xc(%ebx) 11c696: 89 53 10 mov %edx,0x10(%ebx) break; 11c699: eb 30 jmp 11c6cb case SEEK_CUR: iop->offset += offset; 11c69b: 8b 75 e0 mov -0x20(%ebp),%esi 11c69e: 8b 7d e4 mov -0x1c(%ebp),%edi 11c6a1: 01 c6 add %eax,%esi 11c6a3: 11 d7 adc %edx,%edi 11c6a5: eb 0a jmp 11c6b1 break; case SEEK_END: iop->offset = iop->size + offset; 11c6a7: 89 c6 mov %eax,%esi 11c6a9: 89 d7 mov %edx,%edi 11c6ab: 03 73 04 add 0x4(%ebx),%esi 11c6ae: 13 7b 08 adc 0x8(%ebx),%edi 11c6b1: 89 73 0c mov %esi,0xc(%ebx) 11c6b4: 89 7b 10 mov %edi,0x10(%ebx) break; 11c6b7: eb 12 jmp 11c6cb default: rtems_set_errno_and_return_minus_one( EINVAL ); 11c6b9: e8 ee 49 ff ff call 1110ac <__errno> 11c6be: c7 00 16 00 00 00 movl $0x16,(%eax) 11c6c4: 83 c8 ff or $0xffffffff,%eax 11c6c7: 89 c2 mov %eax,%edx 11c6c9: eb 23 jmp 11c6ee /* * At this time, handlers assume iop->offset has the desired * new offset. */ status = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence ); 11c6cb: 8b 73 20 mov 0x20(%ebx),%esi 11c6ce: 51 push %ecx 11c6cf: 52 push %edx 11c6d0: 50 push %eax 11c6d1: 53 push %ebx 11c6d2: ff 56 14 call *0x14(%esi) if ( status == (off_t) -1 ) 11c6d5: 83 c4 10 add $0x10,%esp 11c6d8: 83 fa ff cmp $0xffffffff,%edx 11c6db: 75 11 jne 11c6ee 11c6dd: 83 f8 ff cmp $0xffffffff,%eax 11c6e0: 75 0c jne 11c6ee <== NEVER TAKEN iop->offset = old_offset; 11c6e2: 8b 75 e0 mov -0x20(%ebp),%esi 11c6e5: 8b 7d e4 mov -0x1c(%ebp),%edi 11c6e8: 89 73 0c mov %esi,0xc(%ebx) 11c6eb: 89 7b 10 mov %edi,0x10(%ebx) /* * So if the operation failed, we have to restore iop->offset. */ return status; } 11c6ee: 8d 65 f4 lea -0xc(%ebp),%esp 11c6f1: 5b pop %ebx 11c6f2: 5e pop %esi 11c6f3: 5f pop %edi 11c6f4: c9 leave 11c6f5: 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 b4 41 12 00 incl 0x1241b4 /* * 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 64 44 12 00 03 cmpl $0x3,0x124464 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 01 12 00 pushl 0x120150 10761a: e8 59 43 00 00 call 10b978 <_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 14 26 12 00 mov 0x122614,%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 66 9a 00 00 call 1110ac <__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 18 26 12 00 mov 0x122618,%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 10 26 12 00 mov 0x122610,%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 94 53 12 00 mov 0x125394,%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 d0 11 12 00 pushl 0x1211d0 10798c: e8 7f 43 00 00 call 10bd10 <_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 dc 9c 00 00 call 111684 <__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 68 53 12 00 add %ebx,0x125368 1079b6: 6a 00 push $0x0 1079b8: 6a 00 push $0x0 1079ba: 57 push %edi 1079bb: ff 35 d0 11 12 00 pushl 0x1211d0 1079c1: e8 12 43 00 00 call 10bcd8 <_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 =============================================================================== 0011039b : */ int memfile_ftruncate( rtems_libio_t *iop, rtems_off64_t length ) { 11039b: 55 push %ebp 11039c: 89 e5 mov %esp,%ebp 11039e: 53 push %ebx 11039f: 83 ec 14 sub $0x14,%esp 1103a2: 8b 4d 08 mov 0x8(%ebp),%ecx 1103a5: 8b 45 0c mov 0xc(%ebp),%eax 1103a8: 8b 55 10 mov 0x10(%ebp),%edx IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 1103ab: 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 ) 1103ae: 3b 53 54 cmp 0x54(%ebx),%edx 1103b1: 7c 15 jl 1103c8 <== NEVER TAKEN 1103b3: 7f 05 jg 1103ba <== NEVER TAKEN 1103b5: 3b 43 50 cmp 0x50(%ebx),%eax 1103b8: 76 0e jbe 1103c8 return IMFS_memfile_extend( the_jnode, length ); 1103ba: 51 push %ecx 1103bb: 52 push %edx 1103bc: 50 push %eax 1103bd: 53 push %ebx 1103be: e8 cb fc ff ff call 11008e 1103c3: 83 c4 10 add $0x10,%esp 1103c6: eb 24 jmp 1103ec /* * 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; 1103c8: 89 43 50 mov %eax,0x50(%ebx) 1103cb: 89 53 54 mov %edx,0x54(%ebx) iop->size = the_jnode->info.file.size; 1103ce: 89 41 04 mov %eax,0x4(%ecx) 1103d1: 89 51 08 mov %edx,0x8(%ecx) IMFS_update_atime( the_jnode ); 1103d4: 50 push %eax 1103d5: 50 push %eax 1103d6: 6a 00 push $0x0 1103d8: 8d 45 f0 lea -0x10(%ebp),%eax 1103db: 50 push %eax 1103dc: e8 df 6f ff ff call 1073c0 1103e1: 8b 45 f0 mov -0x10(%ebp),%eax 1103e4: 89 43 40 mov %eax,0x40(%ebx) return 0; 1103e7: 83 c4 10 add $0x10,%esp 1103ea: 31 c0 xor %eax,%eax } 1103ec: 8b 5d fc mov -0x4(%ebp),%ebx 1103ef: c9 leave 1103f0: c3 ret =============================================================================== 001103f1 : rtems_off64_t memfile_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) { 1103f1: 55 push %ebp 1103f2: 89 e5 mov %esp,%ebp 1103f4: 56 push %esi 1103f5: 53 push %ebx 1103f6: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 1103f9: 8b 73 18 mov 0x18(%ebx),%esi if (the_jnode->type == IMFS_LINEAR_FILE) { 1103fc: 83 7e 4c 06 cmpl $0x6,0x4c(%esi) 110400: 75 1a jne 11041c if (iop->offset > the_jnode->info.linearfile.size) 110402: 8b 56 50 mov 0x50(%esi),%edx 110405: 8b 46 54 mov 0x54(%esi),%eax 110408: 39 43 10 cmp %eax,0x10(%ebx) 11040b: 7c 41 jl 11044e <== NEVER TAKEN 11040d: 7f 05 jg 110414 <== NEVER TAKEN 11040f: 39 53 0c cmp %edx,0xc(%ebx) 110412: 76 3a jbe 11044e <== ALWAYS TAKEN iop->offset = the_jnode->info.linearfile.size; 110414: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED 110417: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED 11041a: eb 32 jmp 11044e <== NOT EXECUTED } else { /* Must be a block file (IMFS_MEMORY_FILE). */ if (IMFS_memfile_extend( the_jnode, iop->offset )) 11041c: 50 push %eax 11041d: ff 73 10 pushl 0x10(%ebx) 110420: ff 73 0c pushl 0xc(%ebx) 110423: 56 push %esi 110424: e8 65 fc ff ff call 11008e 110429: 83 c4 10 add $0x10,%esp 11042c: 85 c0 test %eax,%eax 11042e: 74 12 je 110442 rtems_set_errno_and_return_minus_one( ENOSPC ); 110430: e8 77 0c 00 00 call 1110ac <__errno> 110435: c7 00 1c 00 00 00 movl $0x1c,(%eax) 11043b: 83 c8 ff or $0xffffffff,%eax 11043e: 89 c2 mov %eax,%edx 110440: eb 12 jmp 110454 iop->size = the_jnode->info.file.size; 110442: 8b 46 50 mov 0x50(%esi),%eax 110445: 8b 56 54 mov 0x54(%esi),%edx 110448: 89 43 04 mov %eax,0x4(%ebx) 11044b: 89 53 08 mov %edx,0x8(%ebx) } return iop->offset; 11044e: 8b 43 0c mov 0xc(%ebx),%eax 110451: 8b 53 10 mov 0x10(%ebx),%edx } 110454: 8d 65 f8 lea -0x8(%ebp),%esp 110457: 5b pop %ebx 110458: 5e pop %esi 110459: c9 leave 11045a: c3 ret =============================================================================== 0011030c : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 11030c: 55 push %ebp 11030d: 89 e5 mov %esp,%ebp 11030f: 56 push %esi 110310: 53 push %ebx 110311: 8b 75 08 mov 0x8(%ebp),%esi IMFS_jnode_t *the_jnode; the_jnode = iop->pathinfo.node_access; 110314: 8b 5e 18 mov 0x18(%esi),%ebx /* * Perform 'copy on write' for linear files */ if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND)) 110317: f7 46 14 04 02 00 00 testl $0x204,0x14(%esi) 11031e: 74 54 je 110374 && (the_jnode->type == IMFS_LINEAR_FILE)) { 110320: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) 110324: 75 4e jne 110374 <== ALWAYS TAKEN uint32_t count = the_jnode->info.linearfile.size; 110326: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED const unsigned char *buffer = the_jnode->info.linearfile.direct; 110329: 8b 53 58 mov 0x58(%ebx),%edx <== NOT EXECUTED the_jnode->type = IMFS_MEMORY_FILE; 11032c: c7 43 4c 05 00 00 00 movl $0x5,0x4c(%ebx) <== NOT EXECUTED the_jnode->info.file.size = 0; 110333: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED 11033a: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED the_jnode->info.file.indirect = 0; 110341: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED the_jnode->info.file.doubly_indirect = 0; 110348: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED the_jnode->info.file.triply_indirect = 0; 11034f: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED if ((count != 0) 110356: 85 c0 test %eax,%eax <== NOT EXECUTED 110358: 74 1a je 110374 <== NOT EXECUTED && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) 11035a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11035d: 50 push %eax <== NOT EXECUTED 11035e: 52 push %edx <== NOT EXECUTED 11035f: 6a 00 push $0x0 <== NOT EXECUTED 110361: 6a 00 push $0x0 <== NOT EXECUTED 110363: 53 push %ebx <== NOT EXECUTED 110364: e8 17 fe ff ff call 110180 <== NOT EXECUTED 110369: 89 c2 mov %eax,%edx <== NOT EXECUTED 11036b: 83 c4 20 add $0x20,%esp <== NOT EXECUTED return -1; 11036e: 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)) 110371: 42 inc %edx <== NOT EXECUTED 110372: 74 20 je 110394 <== NOT EXECUTED return -1; } if (iop->flags & LIBIO_FLAGS_APPEND) 110374: f6 46 15 02 testb $0x2,0x15(%esi) 110378: 74 0c je 110386 iop->offset = the_jnode->info.file.size; 11037a: 8b 43 50 mov 0x50(%ebx),%eax 11037d: 8b 53 54 mov 0x54(%ebx),%edx 110380: 89 46 0c mov %eax,0xc(%esi) 110383: 89 56 10 mov %edx,0x10(%esi) iop->size = the_jnode->info.file.size; 110386: 8b 43 50 mov 0x50(%ebx),%eax 110389: 8b 53 54 mov 0x54(%ebx),%edx 11038c: 89 46 04 mov %eax,0x4(%esi) 11038f: 89 56 08 mov %edx,0x8(%esi) return 0; 110392: 31 c0 xor %eax,%eax } 110394: 8d 65 f8 lea -0x8(%ebp),%esp 110397: 5b pop %ebx 110398: 5e pop %esi 110399: c9 leave 11039a: 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 57 6b 00 00 call 10e327 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 cd 98 00 00 call 1110ac <__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 d4 e5 11 00 movl $0x11e5d4,-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 14 e6 11 00 mov $0x11e614,%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 fe 97 00 00 call 1110ac <__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 bb 97 00 00 call 1110ac <__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 95 97 00 00 call 1110ac <__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 34 1f 12 00 38 cmpl $0x121f38,0x121f34 107953: 1f 12 00 107956: 74 0d je 107965 <== ALWAYS TAKEN errno = EINVAL; 107958: e8 4f 97 00 00 call 1110ac <__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 34 1f 12 00 push $0x121f34 107991: e8 3a 30 00 00 call 10a9d0 <_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 50 20 12 00 mov 0x122050,%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 a0 99 00 00 call 111738 <__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 =============================================================================== 0010dff0 : int mq_getattr( mqd_t mqdes, struct mq_attr *mqstat ) { 10dff0: 55 push %ebp 10dff1: 89 e5 mov %esp,%ebp 10dff3: 53 push %ebx 10dff4: 83 ec 14 sub $0x14,%esp 10dff7: 8b 5d 0c mov 0xc(%ebp),%ebx POSIX_Message_queue_Control *the_mq; POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; CORE_message_queue_Attributes *the_mq_attr; if ( !mqstat ) 10dffa: 85 db test %ebx,%ebx 10dffc: 75 0d jne 10e00b <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10dffe: e8 d1 8d 00 00 call 116dd4 <__errno> 10e003: c7 00 16 00 00 00 movl $0x16,(%eax) 10e009: eb 49 jmp 10e054 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( 10e00b: 50 push %eax the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); 10e00c: 8d 45 f4 lea -0xc(%ebp),%eax 10e00f: 50 push %eax 10e010: ff 75 08 pushl 0x8(%ebp) 10e013: 68 7c d9 12 00 push $0x12d97c 10e018: e8 af 2d 00 00 call 110dcc <_Objects_Get> switch ( location ) { 10e01d: 83 c4 10 add $0x10,%esp 10e020: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10e024: 75 23 jne 10e049 case OBJECTS_LOCAL: the_mq = the_mq_fd->Queue; 10e026: 8b 50 10 mov 0x10(%eax),%edx * Return the old values. */ the_mq_attr = &the_mq->Message_queue.Attributes; mqstat->mq_flags = the_mq_fd->oflag; 10e029: 8b 40 14 mov 0x14(%eax),%eax 10e02c: 89 03 mov %eax,(%ebx) mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size; 10e02e: 8b 42 68 mov 0x68(%edx),%eax 10e031: 89 43 08 mov %eax,0x8(%ebx) mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages; 10e034: 8b 42 60 mov 0x60(%edx),%eax 10e037: 89 43 04 mov %eax,0x4(%ebx) mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages; 10e03a: 8b 42 64 mov 0x64(%edx),%eax 10e03d: 89 43 0c mov %eax,0xc(%ebx) _Thread_Enable_dispatch(); 10e040: e8 d9 35 00 00 call 11161e <_Thread_Enable_dispatch> return 0; 10e045: 31 c0 xor %eax,%eax 10e047: eb 0e jmp 10e057 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10e049: e8 86 8d 00 00 call 116dd4 <__errno> 10e04e: c7 00 09 00 00 00 movl $0x9,(%eax) 10e054: 83 c8 ff or $0xffffffff,%eax } 10e057: 8b 5d fc mov -0x4(%ebp),%ebx 10e05a: c9 leave 10e05b: 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 6c 43 12 00 00 cmpl $0x0,0x12436c 107a55: 75 14 jne 107a6b { _REENT = _global_impure_ptr; 107a57: a1 e0 f0 11 00 mov 0x11f0e0,%eax 107a5c: a3 20 21 12 00 mov %eax,0x122120 RTEMS_INLINE_ROUTINE void _Thread_Set_libc_reent ( struct _reent **libc_reent ) { _Thread_libc_reent = libc_reent; 107a61: c7 05 6c 43 12 00 20 movl $0x122120,0x12436c 107a68: 21 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 5a 54 00 00 call 10ced2 <_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 66 e3 11 00 movl $0x11e366,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 f0 00 00 00 mov %edx,0xf0(%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 21 12 00 mov 0x122120,%ebx 107cd0: eb 06 jmp 107cd8 } else { ptr = deleted_task->libc_reent; 107cd2: 8b 9e f0 00 00 00 mov 0xf0(%esi),%ebx } if (ptr && ptr != _global_impure_ptr) { 107cd8: 85 db test %ebx,%ebx 107cda: 74 20 je 107cfc <== NEVER TAKEN 107cdc: 3b 1d e0 f0 11 00 cmp 0x11f0e0,%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 a3 9b 00 00 call 111894 <_fwalk> #if REENT_MALLOCED free(ptr); #else _Workspace_Free(ptr); 107cf1: 89 1c 24 mov %ebx,(%esp) 107cf4: e8 f2 51 00 00 call 10ceeb <_Workspace_Free> 107cf9: 83 c4 10 add $0x10,%esp #endif } deleted_task->libc_reent = NULL; 107cfc: c7 86 f0 00 00 00 00 movl $0x0,0xf0(%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 21 12 00 00 movl $0x0,0x122120 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 7c 9a 00 00 call 111480 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 c9 97 00 00 call 111204 <== 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 66 63 00 00 call 10e10b 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 ce 92 00 00 call 1110ac <__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 9d 92 00 00 call 1110ac <__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 32 62 00 00 call 10e098 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 19 92 00 00 call 1110ac <__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 98 41 12 00 sub 0x124198,%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 ea 60 00 00 call 10dfb0 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 d4 91 00 00 call 1110ac <__errno> 107ed8: 83 38 00 cmpl $0x0,(%eax) 107edb: 74 07 je 107ee4 <== NEVER TAKEN 107edd: e8 ca 91 00 00 call 1110ac <__errno> 107ee2: 8b 30 mov (%eax),%esi close( iop - rtems_libio_iops ); 107ee4: 83 ec 0c sub $0xc,%esp 107ee7: 2b 1d 98 41 12 00 sub 0x124198,%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 44 60 00 00 call 10df40 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 4b 62 00 00 call 10e184 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 5b 91 00 00 call 1110ac <__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 98 41 12 00 sub 0x124198,%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 b8 e6 11 00 push $0x11e6b8 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 78 e2 11 00 push $0x11e278 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 08 21 12 00 mov 0x122108,%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 08 21 12 00 mov 0x122108,%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 =============================================================================== 0010ede0 : * Called by pipe() to create an anonymous pipe. */ int pipe_create( int filsdes[2] ) { 10ede0: 55 push %ebp 10ede1: 89 e5 mov %esp,%ebp 10ede3: 57 push %edi 10ede4: 56 push %esi 10ede5: 53 push %ebx 10ede6: 83 ec 34 sub $0x34,%esp rtems_libio_t *iop; int err = 0; if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0) 10ede9: 68 ff 01 00 00 push $0x1ff 10edee: 68 80 04 12 00 push $0x120480 10edf3: e8 5c 14 00 00 call 110254 10edf8: 83 c4 10 add $0x10,%esp return -1; 10edfb: 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) 10ee02: 85 c0 test %eax,%eax 10ee04: 0f 85 e8 00 00 00 jne 10eef2 <== NEVER TAKEN return -1; /* /tmp/.fifoXXXX */ char fifopath[15]; memcpy(fifopath, "/tmp/.fifo", 10); 10ee0a: 8d 5d d9 lea -0x27(%ebp),%ebx 10ee0d: be 85 04 12 00 mov $0x120485,%esi 10ee12: b9 0a 00 00 00 mov $0xa,%ecx 10ee17: 89 df mov %ebx,%edi 10ee19: f3 a4 rep movsb %ds:(%esi),%es:(%edi) sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); 10ee1b: 0f b7 05 a0 5f 12 00 movzwl 0x125fa0,%eax 10ee22: 8d 50 01 lea 0x1(%eax),%edx 10ee25: 66 89 15 a0 5f 12 00 mov %dx,0x125fa0 10ee2c: 57 push %edi 10ee2d: 50 push %eax 10ee2e: 68 90 04 12 00 push $0x120490 10ee33: 8d 45 e3 lea -0x1d(%ebp),%eax 10ee36: 50 push %eax 10ee37: e8 d0 44 00 00 call 11330c /* Try creating FIFO file until find an available file name */ while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) { 10ee3c: 59 pop %ecx 10ee3d: 5e pop %esi 10ee3e: 68 80 01 00 00 push $0x180 10ee43: 53 push %ebx 10ee44: e8 cb 11 00 00 call 110014 10ee49: 83 c4 10 add $0x10,%esp 10ee4c: 85 c0 test %eax,%eax 10ee4e: 74 0a je 10ee5a if (errno != EEXIST){ 10ee50: e8 cb 3a 00 00 call 112920 <__errno> 10ee55: e9 98 00 00 00 jmp 10eef2 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); 10ee5a: 52 push %edx 10ee5b: 52 push %edx 10ee5c: 68 00 40 00 00 push $0x4000 10ee61: 53 push %ebx 10ee62: e8 7d 9f ff ff call 108de4 10ee67: 8b 55 08 mov 0x8(%ebp),%edx 10ee6a: 89 02 mov %eax,(%edx) if (filsdes[0] < 0) { 10ee6c: 83 c4 10 add $0x10,%esp 10ee6f: 85 c0 test %eax,%eax 10ee71: 79 0d jns 10ee80 err = errno; 10ee73: e8 a8 3a 00 00 call 112920 <__errno> 10ee78: 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); 10ee7a: 83 ec 0c sub $0xc,%esp 10ee7d: 53 push %ebx 10ee7e: eb 51 jmp 10eed1 } else { /* Reset open file to blocking mode */ iop = rtems_libio_iop(filsdes[0]); 10ee80: 31 d2 xor %edx,%edx 10ee82: 3b 05 44 21 12 00 cmp 0x122144,%eax 10ee88: 73 09 jae 10ee93 <== NEVER TAKEN 10ee8a: 6b d0 38 imul $0x38,%eax,%edx 10ee8d: 03 15 a0 61 12 00 add 0x1261a0,%edx iop->flags &= ~LIBIO_FLAGS_NO_DELAY; 10ee93: 83 62 14 fe andl $0xfffffffe,0x14(%edx) filsdes[1] = open(fifopath, O_WRONLY); 10ee97: 50 push %eax 10ee98: 50 push %eax 10ee99: 6a 01 push $0x1 10ee9b: 8d 45 d9 lea -0x27(%ebp),%eax 10ee9e: 50 push %eax 10ee9f: e8 40 9f ff ff call 108de4 10eea4: 8b 55 08 mov 0x8(%ebp),%edx 10eea7: 89 42 04 mov %eax,0x4(%edx) if (filsdes[1] < 0) { 10eeaa: 83 c4 10 add $0x10,%esp int pipe_create( int filsdes[2] ) { rtems_libio_t *iop; int err = 0; 10eead: 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) { 10eeaf: 85 c0 test %eax,%eax 10eeb1: 79 17 jns 10eeca err = errno; 10eeb3: e8 68 3a 00 00 call 112920 <__errno> 10eeb8: 8b 30 mov (%eax),%esi close(filsdes[0]); 10eeba: 83 ec 0c sub $0xc,%esp 10eebd: 8b 45 08 mov 0x8(%ebp),%eax 10eec0: ff 30 pushl (%eax) 10eec2: e8 25 91 ff ff call 107fec 10eec7: 83 c4 10 add $0x10,%esp } unlink(fifopath); 10eeca: 83 ec 0c sub $0xc,%esp 10eecd: 8d 45 d9 lea -0x27(%ebp),%eax 10eed0: 50 push %eax 10eed1: e8 aa ba ff ff call 10a980 10eed6: 83 c4 10 add $0x10,%esp } if(err != 0) rtems_set_errno_and_return_minus_one(err); return 0; 10eed9: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) err = errno; close(filsdes[0]); } unlink(fifopath); } if(err != 0) 10eee0: 85 f6 test %esi,%esi 10eee2: 74 0e je 10eef2 rtems_set_errno_and_return_minus_one(err); 10eee4: e8 37 3a 00 00 call 112920 <__errno> 10eee9: 89 30 mov %esi,(%eax) 10eeeb: c7 45 d4 ff ff ff ff movl $0xffffffff,-0x2c(%ebp) return 0; } 10eef2: 8b 45 d4 mov -0x2c(%ebp),%eax 10eef5: 8d 65 f4 lea -0xc(%ebp),%esp 10eef8: 5b pop %ebx 10eef9: 5e pop %esi 10eefa: 5f pop %edi 10eefb: c9 leave 10eefc: c3 ret =============================================================================== 001100ea : pipe_control_t *pipe, uint32_t cmd, void *buffer, rtems_libio_t *iop ) { 1100ea: 55 push %ebp 1100eb: 89 e5 mov %esp,%ebp 1100ed: 56 push %esi 1100ee: 53 push %ebx 1100ef: 8b 5d 08 mov 0x8(%ebp),%ebx 1100f2: 8b 75 10 mov 0x10(%ebp),%esi *(unsigned int *)buffer = pipe->Length; PIPE_UNLOCK(pipe); return 0; } return -EINVAL; 1100f5: b8 ea ff ff ff mov $0xffffffea,%eax uint32_t cmd, void *buffer, rtems_libio_t *iop ) { if (cmd == FIONREAD) { 1100fa: 81 7d 0c 7f 66 04 40 cmpl $0x4004667f,0xc(%ebp) 110101: 75 36 jne 110139 if (buffer == NULL) return -EFAULT; 110103: b0 f2 mov $0xf2,%al void *buffer, rtems_libio_t *iop ) { if (cmd == FIONREAD) { if (buffer == NULL) 110105: 85 f6 test %esi,%esi 110107: 74 30 je 110139 return -EFAULT; if (! PIPE_LOCK(pipe)) 110109: 51 push %ecx 11010a: 6a 00 push $0x0 11010c: 6a 00 push $0x0 11010e: ff 73 28 pushl 0x28(%ebx) 110111: e8 fa ba ff ff call 10bc10 110116: 89 c2 mov %eax,%edx 110118: 83 c4 10 add $0x10,%esp return -EINTR; 11011b: b8 fc ff ff ff mov $0xfffffffc,%eax { if (cmd == FIONREAD) { if (buffer == NULL) return -EFAULT; if (! PIPE_LOCK(pipe)) 110120: 85 d2 test %edx,%edx 110122: 75 15 jne 110139 <== NEVER TAKEN return -EINTR; /* Return length of pipe */ *(unsigned int *)buffer = pipe->Length; 110124: 8b 43 0c mov 0xc(%ebx),%eax 110127: 89 06 mov %eax,(%esi) PIPE_UNLOCK(pipe); 110129: 83 ec 0c sub $0xc,%esp 11012c: ff 73 28 pushl 0x28(%ebx) 11012f: e8 c8 bb ff ff call 10bcfc return 0; 110134: 83 c4 10 add $0x10,%esp 110137: 31 c0 xor %eax,%eax } return -EINVAL; } 110139: 8d 65 f8 lea -0x8(%ebp),%esp 11013c: 5b pop %ebx 11013d: 5e pop %esi 11013e: c9 leave 11013f: c3 ret =============================================================================== 0010fdd0 : pipe_control_t *pipe, void *buffer, size_t count, rtems_libio_t *iop ) { 10fdd0: 55 push %ebp 10fdd1: 89 e5 mov %esp,%ebp 10fdd3: 57 push %edi 10fdd4: 56 push %esi 10fdd5: 53 push %ebx 10fdd6: 83 ec 30 sub $0x30,%esp 10fdd9: 8b 5d 08 mov 0x8(%ebp),%ebx int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) 10fddc: 6a 00 push $0x0 10fdde: 6a 00 push $0x0 10fde0: ff 73 28 pushl 0x28(%ebx) 10fde3: e8 28 be ff ff call 10bc10 10fde8: 83 c4 10 add $0x10,%esp return -EINTR; 10fdeb: c7 45 d4 fc ff ff ff movl $0xfffffffc,-0x2c(%ebp) rtems_libio_t *iop ) { int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) 10fdf2: 85 c0 test %eax,%eax 10fdf4: 0f 85 2f 01 00 00 jne 10ff29 <== NEVER TAKEN 10fdfa: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) 10fe01: e9 f0 00 00 00 jmp 10fef6 return -EINTR; while (read < count) { while (PIPE_EMPTY(pipe)) { /* Not an error */ if (pipe->Writers == 0) 10fe06: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10fe0a: 0f 84 f2 00 00 00 je 10ff02 goto out_locked; if (LIBIO_NODELAY(iop)) { 10fe10: 8b 45 14 mov 0x14(%ebp),%eax 10fe13: f6 40 14 01 testb $0x1,0x14(%eax) 10fe17: 0f 85 e9 00 00 00 jne 10ff06 ret = -EAGAIN; goto out_locked; } /* Wait until pipe is no more empty or no writer exists */ pipe->waitingReaders ++; 10fe1d: ff 43 18 incl 0x18(%ebx) PIPE_UNLOCK(pipe); 10fe20: 83 ec 0c sub $0xc,%esp 10fe23: ff 73 28 pushl 0x28(%ebx) 10fe26: e8 d1 be ff ff call 10bcfc if (! PIPE_READWAIT(pipe)) 10fe2b: 5f pop %edi 10fe2c: 58 pop %eax 10fe2d: 6a 00 push $0x0 10fe2f: ff 73 2c pushl 0x2c(%ebx) 10fe32: e8 a1 16 00 00 call 1114d8 10fe37: 83 c4 0c add $0xc,%esp 10fe3a: 83 f8 01 cmp $0x1,%eax 10fe3d: 19 f6 sbb %esi,%esi 10fe3f: f7 d6 not %esi 10fe41: 83 e6 fc and $0xfffffffc,%esi ret = -EINTR; if (! PIPE_LOCK(pipe)) { 10fe44: 6a 00 push $0x0 10fe46: 6a 00 push $0x0 10fe48: ff 73 28 pushl 0x28(%ebx) 10fe4b: e8 c0 bd ff ff call 10bc10 10fe50: 83 c4 10 add $0x10,%esp 10fe53: 85 c0 test %eax,%eax 10fe55: 0f 85 c0 00 00 00 jne 10ff1b <== NEVER TAKEN /* WARN waitingReaders not restored! */ ret = -EINTR; goto out_nolock; } pipe->waitingReaders --; 10fe5b: ff 4b 18 decl 0x18(%ebx) if (ret != 0) 10fe5e: 85 f6 test %esi,%esi 10fe60: 0f 85 a5 00 00 00 jne 10ff0b <== NEVER TAKEN if (! PIPE_LOCK(pipe)) return -EINTR; while (read < count) { while (PIPE_EMPTY(pipe)) { 10fe66: 8b 53 0c mov 0xc(%ebx),%edx 10fe69: 85 d2 test %edx,%edx 10fe6b: 74 99 je 10fe06 if (ret != 0) goto out_locked; } /* Read chunk bytes */ chunk = MIN(count - read, pipe->Length); 10fe6d: 8b 45 10 mov 0x10(%ebp),%eax 10fe70: 2b 45 d4 sub -0x2c(%ebp),%eax 10fe73: 89 55 d0 mov %edx,-0x30(%ebp) 10fe76: 39 c2 cmp %eax,%edx 10fe78: 76 03 jbe 10fe7d 10fe7a: 89 45 d0 mov %eax,-0x30(%ebp) chunk1 = pipe->Size - pipe->Start; 10fe7d: 8b 73 08 mov 0x8(%ebx),%esi 10fe80: 8b 43 04 mov 0x4(%ebx),%eax 10fe83: 29 f0 sub %esi,%eax if (chunk > chunk1) { 10fe85: 39 45 d0 cmp %eax,-0x30(%ebp) 10fe88: 8b 7d 0c mov 0xc(%ebp),%edi 10fe8b: 8b 4d d4 mov -0x2c(%ebp),%ecx 10fe8e: 8d 14 0f lea (%edi,%ecx,1),%edx 10fe91: 7e 1b jle 10feae memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1); 10fe93: 03 33 add (%ebx),%esi 10fe95: 89 d7 mov %edx,%edi 10fe97: 89 c1 mov %eax,%ecx 10fe99: f3 a4 rep movsb %ds:(%esi),%es:(%edi) memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1); 10fe9b: 8b 55 d4 mov -0x2c(%ebp),%edx 10fe9e: 01 c2 add %eax,%edx 10fea0: 03 55 0c add 0xc(%ebp),%edx 10fea3: 8b 4d d0 mov -0x30(%ebp),%ecx 10fea6: 29 c1 sub %eax,%ecx 10fea8: 8b 33 mov (%ebx),%esi 10feaa: 89 d7 mov %edx,%edi 10feac: eb 07 jmp 10feb5 } else memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk); 10feae: 03 33 add (%ebx),%esi 10feb0: 89 d7 mov %edx,%edi 10feb2: 8b 4d d0 mov -0x30(%ebp),%ecx 10feb5: f3 a4 rep movsb %ds:(%esi),%es:(%edi) pipe->Start += chunk; 10feb7: 8b 45 d0 mov -0x30(%ebp),%eax 10feba: 03 43 08 add 0x8(%ebx),%eax pipe->Start %= pipe->Size; 10febd: 31 d2 xor %edx,%edx 10febf: f7 73 04 divl 0x4(%ebx) 10fec2: 89 53 08 mov %edx,0x8(%ebx) pipe->Length -= chunk; 10fec5: 8b 43 0c mov 0xc(%ebx),%eax 10fec8: 2b 45 d0 sub -0x30(%ebp),%eax 10fecb: 89 43 0c mov %eax,0xc(%ebx) /* For buffering optimization */ if (PIPE_EMPTY(pipe)) 10fece: 85 c0 test %eax,%eax 10fed0: 75 07 jne 10fed9 pipe->Start = 0; 10fed2: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) if (pipe->waitingWriters > 0) 10fed9: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx) 10fedd: 74 11 je 10fef0 PIPE_WAKEUPWRITERS(pipe); 10fedf: 56 push %esi 10fee0: 56 push %esi 10fee1: 8d 45 e4 lea -0x1c(%ebp),%eax 10fee4: 50 push %eax 10fee5: ff 73 30 pushl 0x30(%ebx) 10fee8: e8 93 15 00 00 call 111480 10feed: 83 c4 10 add $0x10,%esp read += chunk; 10fef0: 8b 4d d0 mov -0x30(%ebp),%ecx 10fef3: 01 4d d4 add %ecx,-0x2c(%ebp) int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) return -EINTR; while (read < count) { 10fef6: 8b 7d 10 mov 0x10(%ebp),%edi 10fef9: 39 7d d4 cmp %edi,-0x2c(%ebp) 10fefc: 0f 82 64 ff ff ff jb 10fe66 while (PIPE_EMPTY(pipe)) { /* Not an error */ if (pipe->Writers == 0) 10ff02: 31 f6 xor %esi,%esi 10ff04: eb 05 jmp 10ff0b goto out_locked; if (LIBIO_NODELAY(iop)) { ret = -EAGAIN; 10ff06: be f5 ff ff ff mov $0xfffffff5,%esi PIPE_WAKEUPWRITERS(pipe); read += chunk; } out_locked: PIPE_UNLOCK(pipe); 10ff0b: 83 ec 0c sub $0xc,%esp 10ff0e: ff 73 28 pushl 0x28(%ebx) 10ff11: e8 e6 bd ff ff call 10bcfc 10ff16: 83 c4 10 add $0x10,%esp 10ff19: eb 05 jmp 10ff20 PIPE_UNLOCK(pipe); if (! PIPE_READWAIT(pipe)) ret = -EINTR; if (! PIPE_LOCK(pipe)) { /* WARN waitingReaders not restored! */ ret = -EINTR; 10ff1b: be fc ff ff ff mov $0xfffffffc,%esi out_locked: PIPE_UNLOCK(pipe); out_nolock: if (read > 0) 10ff20: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 10ff24: 7f 03 jg 10ff29 return read; return ret; 10ff26: 89 75 d4 mov %esi,-0x2c(%ebp) } 10ff29: 8b 45 d4 mov -0x2c(%ebp),%eax 10ff2c: 8d 65 f4 lea -0xc(%ebp),%esp 10ff2f: 5b pop %ebx 10ff30: 5e pop %esi 10ff31: 5f pop %edi 10ff32: c9 leave 10ff33: c3 ret =============================================================================== 0010f975 : */ void pipe_release( pipe_control_t **pipep, rtems_libio_t *iop ) { 10f975: 55 push %ebp 10f976: 89 e5 mov %esp,%ebp 10f978: 57 push %edi 10f979: 56 push %esi 10f97a: 53 push %ebx 10f97b: 83 ec 1c sub $0x1c,%esp 10f97e: 8b 7d 08 mov 0x8(%ebp),%edi pipe_control_t *pipe = *pipep; 10f981: 8b 1f mov (%edi),%ebx /* WARN pipe not released! */ if (!PIPE_LOCK(pipe)) rtems_fatal_error_occurred(0xdeadbeef); #endif mode = LIBIO_ACCMODE(iop); 10f983: 8b 45 0c mov 0xc(%ebp),%eax 10f986: 8b 40 14 mov 0x14(%eax),%eax 10f989: 89 c6 mov %eax,%esi 10f98b: 83 e6 06 and $0x6,%esi if (mode & LIBIO_FLAGS_READ) 10f98e: a8 02 test $0x2,%al 10f990: 74 03 je 10f995 pipe->Readers --; 10f992: ff 4b 10 decl 0x10(%ebx) if (mode & LIBIO_FLAGS_WRITE) 10f995: f7 c6 04 00 00 00 test $0x4,%esi 10f99b: 74 03 je 10f9a0 pipe->Writers --; 10f99d: ff 4b 14 decl 0x14(%ebx) PIPE_UNLOCK(pipe); 10f9a0: 83 ec 0c sub $0xc,%esp 10f9a3: ff 73 28 pushl 0x28(%ebx) 10f9a6: e8 51 c3 ff ff call 10bcfc if (pipe->Readers == 0 && pipe->Writers == 0) { 10f9ab: 8b 43 10 mov 0x10(%ebx),%eax 10f9ae: 83 c4 10 add $0x10,%esp 10f9b1: 85 c0 test %eax,%eax 10f9b3: 75 15 jne 10f9ca 10f9b5: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10f9b9: 75 0f jne 10f9ca #if 0 /* To delete an anonymous pipe file when all users closed it */ if (pipe->Anonymous) delfile = TRUE; #endif pipe_free(pipe); 10f9bb: 89 d8 mov %ebx,%eax 10f9bd: e8 78 ff ff ff call 10f93a *pipep = NULL; 10f9c2: c7 07 00 00 00 00 movl $0x0,(%edi) 10f9c8: eb 30 jmp 10f9fa } else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE) 10f9ca: 83 fe 04 cmp $0x4,%esi 10f9cd: 74 0f je 10f9de 10f9cf: 85 c0 test %eax,%eax 10f9d1: 75 0b jne 10f9de <== NEVER TAKEN /* Notify waiting Writers that all their partners left */ PIPE_WAKEUPWRITERS(pipe); 10f9d3: 57 push %edi 10f9d4: 57 push %edi 10f9d5: 8d 45 e4 lea -0x1c(%ebp),%eax 10f9d8: 50 push %eax 10f9d9: ff 73 30 pushl 0x30(%ebx) 10f9dc: eb 14 jmp 10f9f2 else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ) 10f9de: 83 fe 02 cmp $0x2,%esi 10f9e1: 74 17 je 10f9fa <== NEVER TAKEN 10f9e3: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10f9e7: 75 11 jne 10f9fa <== NEVER TAKEN PIPE_WAKEUPREADERS(pipe); 10f9e9: 56 push %esi 10f9ea: 56 push %esi 10f9eb: 8d 45 e4 lea -0x1c(%ebp),%eax 10f9ee: 50 push %eax 10f9ef: ff 73 2c pushl 0x2c(%ebx) 10f9f2: e8 89 1a 00 00 call 111480 10f9f7: 83 c4 10 add $0x10,%esp pipe_unlock(); 10f9fa: e8 25 ff ff ff call 10f924 iop->flags &= ~LIBIO_FLAGS_OPEN; if(iop->pathinfo.ops->unlink_h(&iop->pathinfo)) return; #endif } 10f9ff: 8d 65 f4 lea -0xc(%ebp),%esp 10fa02: 5b pop %ebx 10fa03: 5e pop %esi 10fa04: 5f pop %edi 10fa05: c9 leave 10fa06: c3 ret =============================================================================== 0010ff34 : pipe_control_t *pipe, const void *buffer, size_t count, rtems_libio_t *iop ) { 10ff34: 55 push %ebp 10ff35: 89 e5 mov %esp,%ebp 10ff37: 57 push %edi 10ff38: 56 push %esi 10ff39: 53 push %ebx 10ff3a: 83 ec 2c sub $0x2c,%esp 10ff3d: 8b 5d 08 mov 0x8(%ebp),%ebx int chunk, chunk1, written = 0, ret = 0; /* Write nothing */ if (count == 0) return 0; 10ff40: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) ) { int chunk, chunk1, written = 0, ret = 0; /* Write nothing */ if (count == 0) 10ff47: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10ff4b: 0f 84 8e 01 00 00 je 1100df <== NEVER TAKEN return 0; if (! PIPE_LOCK(pipe)) 10ff51: 52 push %edx 10ff52: 6a 00 push $0x0 10ff54: 6a 00 push $0x0 10ff56: ff 73 28 pushl 0x28(%ebx) 10ff59: e8 b2 bc ff ff call 10bc10 10ff5e: 83 c4 10 add $0x10,%esp return -EINTR; 10ff61: c7 45 d4 fc ff ff ff movl $0xfffffffc,-0x2c(%ebp) /* Write nothing */ if (count == 0) return 0; if (! PIPE_LOCK(pipe)) 10ff68: 85 c0 test %eax,%eax 10ff6a: 0f 85 6f 01 00 00 jne 1100df <== NEVER TAKEN return -EINTR; if (pipe->Readers == 0) { 10ff70: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10ff74: 0f 84 16 01 00 00 je 110090 ret = -EPIPE; goto out_locked; } /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; 10ff7a: bf 01 00 00 00 mov $0x1,%edi 10ff7f: 8b 45 10 mov 0x10(%ebp),%eax 10ff82: 3b 43 04 cmp 0x4(%ebx),%eax 10ff85: 77 02 ja 10ff89 <== NEVER TAKEN 10ff87: 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; 10ff89: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) 10ff90: e9 eb 00 00 00 jmp 110080 /* 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)) { 10ff95: 8b 4d 14 mov 0x14(%ebp),%ecx 10ff98: f6 41 14 01 testb $0x1,0x14(%ecx) 10ff9c: 0f 85 fc 00 00 00 jne 11009e ret = -EAGAIN; goto out_locked; } /* Wait until there is chunk bytes space or no reader exists */ pipe->waitingWriters ++; 10ffa2: ff 43 1c incl 0x1c(%ebx) PIPE_UNLOCK(pipe); 10ffa5: 83 ec 0c sub $0xc,%esp 10ffa8: ff 73 28 pushl 0x28(%ebx) 10ffab: e8 4c bd ff ff call 10bcfc if (! PIPE_WRITEWAIT(pipe)) 10ffb0: 5e pop %esi 10ffb1: 58 pop %eax 10ffb2: 6a 00 push $0x0 10ffb4: ff 73 30 pushl 0x30(%ebx) 10ffb7: e8 1c 15 00 00 call 1114d8 10ffbc: 83 c4 0c add $0xc,%esp 10ffbf: 83 f8 01 cmp $0x1,%eax 10ffc2: 19 f6 sbb %esi,%esi 10ffc4: f7 d6 not %esi 10ffc6: 83 e6 fc and $0xfffffffc,%esi ret = -EINTR; if (! PIPE_LOCK(pipe)) { 10ffc9: 6a 00 push $0x0 10ffcb: 6a 00 push $0x0 10ffcd: ff 73 28 pushl 0x28(%ebx) 10ffd0: e8 3b bc ff ff call 10bc10 10ffd5: 83 c4 10 add $0x10,%esp 10ffd8: 85 c0 test %eax,%eax 10ffda: 0f 85 f1 00 00 00 jne 1100d1 <== NEVER TAKEN /* WARN waitingWriters not restored! */ ret = -EINTR; goto out_nolock; } pipe->waitingWriters --; 10ffe0: ff 4b 1c decl 0x1c(%ebx) if (ret != 0) 10ffe3: 85 f6 test %esi,%esi 10ffe5: 0f 85 bf 00 00 00 jne 1100aa <== NEVER TAKEN goto out_locked; if (pipe->Readers == 0) { 10ffeb: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10ffef: 0f 84 b0 00 00 00 je 1100a5 <== 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) { 10fff5: 8b 73 04 mov 0x4(%ebx),%esi 10fff8: 8b 43 0c mov 0xc(%ebx),%eax 10fffb: 89 f1 mov %esi,%ecx 10fffd: 29 c1 sub %eax,%ecx 10ffff: 39 f9 cmp %edi,%ecx 110001: 72 92 jb 10ff95 ret = -EPIPE; goto out_locked; } } chunk = MIN(count - written, PIPE_SPACE(pipe)); 110003: 8b 55 10 mov 0x10(%ebp),%edx 110006: 2b 55 d4 sub -0x2c(%ebp),%edx 110009: 89 4d d0 mov %ecx,-0x30(%ebp) 11000c: 39 d1 cmp %edx,%ecx 11000e: 76 03 jbe 110013 110010: 89 55 d0 mov %edx,-0x30(%ebp) chunk1 = pipe->Size - PIPE_WSTART(pipe); 110013: 03 43 08 add 0x8(%ebx),%eax 110016: 31 d2 xor %edx,%edx 110018: f7 f6 div %esi 11001a: 29 d6 sub %edx,%esi 11001c: 89 75 cc mov %esi,-0x34(%ebp) if (chunk > chunk1) { 11001f: 39 75 d0 cmp %esi,-0x30(%ebp) 110022: 8b 4d 0c mov 0xc(%ebp),%ecx 110025: 8b 45 d4 mov -0x2c(%ebp),%eax 110028: 8d 34 01 lea (%ecx,%eax,1),%esi 11002b: 7e 20 jle 11004d memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1); 11002d: 8b 03 mov (%ebx),%eax 11002f: 01 d0 add %edx,%eax 110031: 89 c7 mov %eax,%edi 110033: 8b 4d cc mov -0x34(%ebp),%ecx 110036: f3 a4 rep movsb %ds:(%esi),%es:(%edi) memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1); 110038: 8b 03 mov (%ebx),%eax 11003a: 8b 4d d0 mov -0x30(%ebp),%ecx 11003d: 2b 4d cc sub -0x34(%ebp),%ecx 110040: 8b 75 cc mov -0x34(%ebp),%esi 110043: 03 75 d4 add -0x2c(%ebp),%esi 110046: 03 75 0c add 0xc(%ebp),%esi 110049: 89 c7 mov %eax,%edi 11004b: eb 09 jmp 110056 } else memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk); 11004d: 8b 03 mov (%ebx),%eax 11004f: 01 d0 add %edx,%eax 110051: 89 c7 mov %eax,%edi 110053: 8b 4d d0 mov -0x30(%ebp),%ecx 110056: f3 a4 rep movsb %ds:(%esi),%es:(%edi) pipe->Length += chunk; 110058: 8b 45 d0 mov -0x30(%ebp),%eax 11005b: 01 43 0c add %eax,0xc(%ebx) if (pipe->waitingReaders > 0) 11005e: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 110062: 74 11 je 110075 PIPE_WAKEUPREADERS(pipe); 110064: 51 push %ecx 110065: 51 push %ecx 110066: 8d 4d e4 lea -0x1c(%ebp),%ecx 110069: 51 push %ecx 11006a: ff 73 2c pushl 0x2c(%ebx) 11006d: e8 0e 14 00 00 call 111480 110072: 83 c4 10 add $0x10,%esp written += chunk; 110075: 8b 45 d0 mov -0x30(%ebp),%eax 110078: 01 45 d4 add %eax,-0x2c(%ebp) /* Write of more than PIPE_BUF bytes can be interleaved */ chunk = 1; 11007b: 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) { 110080: 8b 4d 10 mov 0x10(%ebp),%ecx 110083: 39 4d d4 cmp %ecx,-0x2c(%ebp) 110086: 0f 82 69 ff ff ff jb 10fff5 11008c: 31 f6 xor %esi,%esi 11008e: eb 1a jmp 1100aa if (! PIPE_LOCK(pipe)) return -EINTR; if (pipe->Readers == 0) { ret = -EPIPE; 110090: 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; 110095: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) 11009c: eb 0c jmp 1100aa chunk = count <= pipe->Size ? count : 1; while (written < count) { while (PIPE_SPACE(pipe) < chunk) { if (LIBIO_NODELAY(iop)) { ret = -EAGAIN; 11009e: be f5 ff ff ff mov $0xfffffff5,%esi 1100a3: eb 05 jmp 1100aa pipe->waitingWriters --; if (ret != 0) goto out_locked; if (pipe->Readers == 0) { ret = -EPIPE; 1100a5: 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); 1100aa: 83 ec 0c sub $0xc,%esp 1100ad: ff 73 28 pushl 0x28(%ebx) 1100b0: e8 47 bc ff ff call 10bcfc 1100b5: 83 c4 10 add $0x10,%esp out_nolock: #ifdef RTEMS_POSIX_API /* Signal SIGPIPE */ if (ret == -EPIPE) 1100b8: 83 fe e0 cmp $0xffffffe0,%esi 1100bb: 75 19 jne 1100d6 kill(getpid(), SIGPIPE); 1100bd: e8 1e 07 00 00 call 1107e0 1100c2: 52 push %edx 1100c3: 52 push %edx 1100c4: 6a 0d push $0xd 1100c6: 50 push %eax 1100c7: e8 9c 09 00 00 call 110a68 1100cc: 83 c4 10 add $0x10,%esp 1100cf: eb 05 jmp 1100d6 PIPE_UNLOCK(pipe); if (! PIPE_WRITEWAIT(pipe)) ret = -EINTR; if (! PIPE_LOCK(pipe)) { /* WARN waitingWriters not restored! */ ret = -EINTR; 1100d1: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED /* Signal SIGPIPE */ if (ret == -EPIPE) kill(getpid(), SIGPIPE); #endif if (written > 0) 1100d6: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 1100da: 7f 03 jg 1100df 1100dc: 89 75 d4 mov %esi,-0x2c(%ebp) return written; return ret; } 1100df: 8b 45 d4 mov -0x2c(%ebp),%eax 1100e2: 8d 65 f4 lea -0xc(%ebp),%esp 1100e5: 5b pop %ebx 1100e6: 5e pop %esi 1100e7: 5f pop %edi 1100e8: c9 leave 1100e9: 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 c4 aa 12 00 incl 0x12aac4 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 =============================================================================== 0010efd8 : int pthread_attr_getinheritsched( const pthread_attr_t *attr, int *inheritsched ) { 10efd8: 55 push %ebp 10efd9: 89 e5 mov %esp,%ebp 10efdb: 8b 55 08 mov 0x8(%ebp),%edx 10efde: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized || !inheritsched ) return EINVAL; 10efe1: 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 ) 10efe6: 85 d2 test %edx,%edx 10efe8: 74 17 je 10f001 <== NEVER TAKEN 10efea: 85 c9 test %ecx,%ecx 10efec: 74 0e je 10effc 10efee: 83 3a 00 cmpl $0x0,(%edx) 10eff1: 74 09 je 10effc return EINVAL; *inheritsched = attr->inheritsched; 10eff3: 8b 42 10 mov 0x10(%edx),%eax 10eff6: 89 01 mov %eax,(%ecx) return 0; 10eff8: 31 c0 xor %eax,%eax 10effa: eb 05 jmp 10f001 const pthread_attr_t *attr, int *inheritsched ) { if ( !attr || !attr->is_initialized || !inheritsched ) return EINVAL; 10effc: b8 16 00 00 00 mov $0x16,%eax *inheritsched = attr->inheritsched; return 0; } 10f001: c9 leave 10f002: c3 ret =============================================================================== 0010f1f4 : int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { 10f1f4: 55 push %ebp 10f1f5: 89 e5 mov %esp,%ebp 10f1f7: 8b 55 08 mov 0x8(%ebp),%edx 10f1fa: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 10f1fd: b8 16 00 00 00 mov $0x16,%eax int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { if ( !attr || !attr->is_initialized ) 10f202: 85 d2 test %edx,%edx 10f204: 74 1e je 10f224 10f206: 83 3a 00 cmpl $0x0,(%edx) 10f209: 74 19 je 10f224 return EINVAL; switch ( policy ) { 10f20b: 83 f9 04 cmp $0x4,%ecx 10f20e: 77 0f ja 10f21f 10f210: b0 01 mov $0x1,%al 10f212: d3 e0 shl %cl,%eax 10f214: a8 17 test $0x17,%al 10f216: 74 07 je 10f21f <== NEVER TAKEN case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: case SCHED_SPORADIC: attr->schedpolicy = policy; 10f218: 89 4a 14 mov %ecx,0x14(%edx) return 0; 10f21b: 31 c0 xor %eax,%eax 10f21d: eb 05 jmp 10f224 default: return ENOTSUP; 10f21f: b8 86 00 00 00 mov $0x86,%eax } } 10f224: c9 leave 10f225: c3 ret =============================================================================== 0010a514 : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 10a514: 55 push %ebp 10a515: 89 e5 mov %esp,%ebp 10a517: 57 push %edi 10a518: 56 push %esi 10a519: 53 push %ebx 10a51a: 83 ec 1c sub $0x1c,%esp 10a51d: 8b 5d 08 mov 0x8(%ebp),%ebx 10a520: 8b 75 10 mov 0x10(%ebp),%esi /* * Error check parameters */ if ( !barrier ) return EINVAL; 10a523: b8 16 00 00 00 mov $0x16,%eax const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 10a528: 85 db test %ebx,%ebx 10a52a: 0f 84 96 00 00 00 je 10a5c6 return EINVAL; if ( count == 0 ) 10a530: 85 f6 test %esi,%esi 10a532: 0f 84 8e 00 00 00 je 10a5c6 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10a538: 8b 7d 0c mov 0xc(%ebp),%edi 10a53b: 85 ff test %edi,%edi 10a53d: 75 0f jne 10a54e the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 10a53f: 83 ec 0c sub $0xc,%esp 10a542: 8d 7d d8 lea -0x28(%ebp),%edi 10a545: 57 push %edi 10a546: e8 19 ff ff ff call 10a464 10a54b: 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; 10a54e: 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 ) 10a553: 83 3f 00 cmpl $0x0,(%edi) 10a556: 74 6e je 10a5c6 return EINVAL; switch ( the_attr->process_shared ) { 10a558: 83 7f 04 00 cmpl $0x0,0x4(%edi) 10a55c: 75 68 jne 10a5c6 <== NEVER TAKEN } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 10a55e: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) the_attributes.maximum_count = count; 10a565: 89 75 e4 mov %esi,-0x1c(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a568: a1 f4 63 12 00 mov 0x1263f4,%eax 10a56d: 40 inc %eax 10a56e: a3 f4 63 12 00 mov %eax,0x1263f4 * 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 ); 10a573: 83 ec 0c sub $0xc,%esp 10a576: 68 c0 67 12 00 push $0x1267c0 10a57b: e8 08 1e 00 00 call 10c388 <_Objects_Allocate> 10a580: 89 c6 mov %eax,%esi */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 10a582: 83 c4 10 add $0x10,%esp 10a585: 85 c0 test %eax,%eax 10a587: 75 0c jne 10a595 _Thread_Enable_dispatch(); 10a589: e8 08 2a 00 00 call 10cf96 <_Thread_Enable_dispatch> return EAGAIN; 10a58e: b8 0b 00 00 00 mov $0xb,%eax 10a593: eb 31 jmp 10a5c6 } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 10a595: 50 push %eax 10a596: 50 push %eax 10a597: 8d 45 e0 lea -0x20(%ebp),%eax 10a59a: 50 push %eax 10a59b: 8d 46 10 lea 0x10(%esi),%eax 10a59e: 50 push %eax 10a59f: e8 9c 14 00 00 call 10ba40 <_CORE_barrier_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10a5a4: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10a5a7: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10a5aa: 8b 15 dc 67 12 00 mov 0x1267dc,%edx 10a5b0: 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; 10a5b3: 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; 10a5ba: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10a5bc: e8 d5 29 00 00 call 10cf96 <_Thread_Enable_dispatch> return 0; 10a5c1: 83 c4 10 add $0x10,%esp 10a5c4: 31 c0 xor %eax,%eax } 10a5c6: 8d 65 f4 lea -0xc(%ebp),%esp 10a5c9: 5b pop %ebx 10a5ca: 5e pop %esi 10a5cb: 5f pop %edi 10a5cc: c9 leave 10a5cd: c3 ret =============================================================================== 00109ecc : void pthread_cleanup_push( void (*routine)( void * ), void *arg ) { 109ecc: 55 push %ebp 109ecd: 89 e5 mov %esp,%ebp 109ecf: 56 push %esi 109ed0: 53 push %ebx 109ed1: 8b 5d 08 mov 0x8(%ebp),%ebx 109ed4: 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 ) 109ed7: 85 db test %ebx,%ebx 109ed9: 74 4b je 109f26 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 109edb: a1 cc 62 12 00 mov 0x1262cc,%eax 109ee0: 40 inc %eax 109ee1: a3 cc 62 12 00 mov %eax,0x1262cc return; _Thread_Disable_dispatch(); handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); 109ee6: 83 ec 0c sub $0xc,%esp 109ee9: 6a 10 push $0x10 109eeb: e8 22 3b 00 00 call 10da12 <_Workspace_Allocate> if ( handler ) { 109ef0: 83 c4 10 add $0x10,%esp 109ef3: 85 c0 test %eax,%eax 109ef5: 74 24 je 109f1b <== NEVER TAKEN thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 109ef7: 8b 15 1c 68 12 00 mov 0x12681c,%edx handler_stack = &thread_support->Cancellation_Handlers; 109efd: 8b 92 f8 00 00 00 mov 0xf8(%edx),%edx 109f03: 81 c2 e4 00 00 00 add $0xe4,%edx handler->routine = routine; 109f09: 89 58 08 mov %ebx,0x8(%eax) handler->arg = arg; 109f0c: 89 70 0c mov %esi,0xc(%eax) _Chain_Append( handler_stack, &handler->Node ); 109f0f: 51 push %ecx 109f10: 51 push %ecx 109f11: 50 push %eax 109f12: 52 push %edx 109f13: e8 7c 15 00 00 call 10b494 <_Chain_Append> 109f18: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); } 109f1b: 8d 65 f8 lea -0x8(%ebp),%esp 109f1e: 5b pop %ebx 109f1f: 5e pop %esi 109f20: c9 leave handler->routine = routine; handler->arg = arg; _Chain_Append( handler_stack, &handler->Node ); } _Thread_Enable_dispatch(); 109f21: e9 6c 2a 00 00 jmp 10c992 <_Thread_Enable_dispatch> } 109f26: 8d 65 f8 lea -0x8(%ebp),%esp 109f29: 5b pop %ebx 109f2a: 5e pop %esi 109f2b: c9 leave 109f2c: c3 ret =============================================================================== 0010ac3c : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 10ac3c: 55 push %ebp 10ac3d: 89 e5 mov %esp,%ebp 10ac3f: 56 push %esi 10ac40: 53 push %ebx POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 10ac41: 8b 5d 0c mov 0xc(%ebp),%ebx 10ac44: 85 db test %ebx,%ebx 10ac46: 75 05 jne 10ac4d else the_attr = &_POSIX_Condition_variables_Default_attributes; 10ac48: bb 28 0c 12 00 mov $0x120c28,%ebx /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) return EINVAL; 10ac4d: 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 ) 10ac52: 83 7b 04 01 cmpl $0x1,0x4(%ebx) 10ac56: 74 76 je 10acce <== NEVER TAKEN return EINVAL; if ( !the_attr->is_initialized ) 10ac58: 83 3b 00 cmpl $0x0,(%ebx) 10ac5b: 74 71 je 10acce rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10ac5d: a1 e4 62 12 00 mov 0x1262e4,%eax 10ac62: 40 inc %eax 10ac63: a3 e4 62 12 00 mov %eax,0x1262e4 RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control *_POSIX_Condition_variables_Allocate( void ) { return (POSIX_Condition_variables_Control *) _Objects_Allocate( &_POSIX_Condition_variables_Information ); 10ac68: 83 ec 0c sub $0xc,%esp 10ac6b: 68 48 67 12 00 push $0x126748 10ac70: e8 f3 22 00 00 call 10cf68 <_Objects_Allocate> 10ac75: 89 c6 mov %eax,%esi _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 10ac77: 83 c4 10 add $0x10,%esp 10ac7a: 85 c0 test %eax,%eax 10ac7c: 75 0c jne 10ac8a _Thread_Enable_dispatch(); 10ac7e: e8 f3 2e 00 00 call 10db76 <_Thread_Enable_dispatch> return ENOMEM; 10ac83: b8 0c 00 00 00 mov $0xc,%eax 10ac88: eb 44 jmp 10acce } the_cond->process_shared = the_attr->process_shared; 10ac8a: 8b 43 04 mov 0x4(%ebx),%eax 10ac8d: 89 46 10 mov %eax,0x10(%esi) the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 10ac90: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) _Thread_queue_Initialize( 10ac97: 6a 74 push $0x74 10ac99: 68 00 08 00 10 push $0x10000800 10ac9e: 6a 00 push $0x0 10aca0: 8d 46 18 lea 0x18(%esi),%eax 10aca3: 50 push %eax 10aca4: e8 c3 35 00 00 call 10e26c <_Thread_queue_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10aca9: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10acac: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10acaf: 8b 15 64 67 12 00 mov 0x126764,%edx 10acb5: 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; 10acb8: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 10acbf: 8b 55 08 mov 0x8(%ebp),%edx 10acc2: 89 02 mov %eax,(%edx) _Thread_Enable_dispatch(); 10acc4: e8 ad 2e 00 00 call 10db76 <_Thread_Enable_dispatch> return 0; 10acc9: 83 c4 10 add $0x10,%esp 10accc: 31 c0 xor %eax,%eax } 10acce: 8d 65 f8 lea -0x8(%ebp),%esp 10acd1: 5b pop %ebx 10acd2: 5e pop %esi 10acd3: c9 leave 10acd4: c3 ret =============================================================================== 0010aaf0 : */ int pthread_condattr_destroy( pthread_condattr_t *attr ) { 10aaf0: 55 push %ebp 10aaf1: 89 e5 mov %esp,%ebp 10aaf3: 8b 55 08 mov 0x8(%ebp),%edx if ( !attr || attr->is_initialized == false ) return EINVAL; 10aaf6: b8 16 00 00 00 mov $0x16,%eax int pthread_condattr_destroy( pthread_condattr_t *attr ) { if ( !attr || attr->is_initialized == false ) 10aafb: 85 d2 test %edx,%edx 10aafd: 74 0d je 10ab0c 10aaff: 83 3a 00 cmpl $0x0,(%edx) 10ab02: 74 08 je 10ab0c <== NEVER TAKEN return EINVAL; attr->is_initialized = false; 10ab04: c7 02 00 00 00 00 movl $0x0,(%edx) return 0; 10ab0a: 30 c0 xor %al,%al } 10ab0c: c9 leave 10ab0d: c3 ret =============================================================================== 0010a224 : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 10a224: 55 push %ebp 10a225: 89 e5 mov %esp,%ebp 10a227: 57 push %edi 10a228: 56 push %esi 10a229: 53 push %ebx 10a22a: 83 ec 5c sub $0x5c,%esp struct sched_param schedparam; Objects_Name name; int rc; if ( !start_routine ) return EFAULT; 10a22d: 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 ) 10a234: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a238: 0f 84 0f 02 00 00 je 10a44d return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 10a23e: 8b 5d 0c mov 0xc(%ebp),%ebx 10a241: 85 db test %ebx,%ebx 10a243: 75 05 jne 10a24a 10a245: bb 94 f8 11 00 mov $0x11f894,%ebx if ( !the_attr->is_initialized ) return EINVAL; 10a24a: 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 ) 10a251: 83 3b 00 cmpl $0x0,(%ebx) 10a254: 0f 84 f3 01 00 00 je 10a44d * 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) ) 10a25a: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a25e: 74 0e je 10a26e 10a260: a1 14 12 12 00 mov 0x121214,%eax 10a265: 39 43 08 cmp %eax,0x8(%ebx) 10a268: 0f 82 df 01 00 00 jb 10a44d * 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 ) { 10a26e: 8b 43 10 mov 0x10(%ebx),%eax 10a271: 83 f8 01 cmp $0x1,%eax 10a274: 74 0b je 10a281 10a276: 83 f8 02 cmp $0x2,%eax 10a279: 0f 85 c7 01 00 00 jne 10a446 10a27f: eb 1f jmp 10a2a0 case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a281: a1 24 58 12 00 mov 0x125824,%eax 10a286: 8b b0 f8 00 00 00 mov 0xf8(%eax),%esi schedpolicy = api->schedpolicy; 10a28c: 8b 86 84 00 00 00 mov 0x84(%esi),%eax 10a292: 89 45 ac mov %eax,-0x54(%ebp) schedparam = api->schedparam; 10a295: 8d 7d c4 lea -0x3c(%ebp),%edi 10a298: 81 c6 88 00 00 00 add $0x88,%esi 10a29e: eb 0c jmp 10a2ac break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 10a2a0: 8b 43 14 mov 0x14(%ebx),%eax 10a2a3: 89 45 ac mov %eax,-0x54(%ebp) schedparam = the_attr->schedparam; 10a2a6: 8d 7d c4 lea -0x3c(%ebp),%edi 10a2a9: 8d 73 18 lea 0x18(%ebx),%esi 10a2ac: b9 07 00 00 00 mov $0x7,%ecx 10a2b1: 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; 10a2b3: 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 ) 10a2ba: 83 7b 0c 00 cmpl $0x0,0xc(%ebx) 10a2be: 0f 85 89 01 00 00 jne 10a44d return ENOTSUP; /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 10a2c4: 83 ec 0c sub $0xc,%esp 10a2c7: ff 75 c4 pushl -0x3c(%ebp) 10a2ca: e8 01 58 00 00 call 10fad0 <_POSIX_Priority_Is_valid> 10a2cf: 83 c4 10 add $0x10,%esp return EINVAL; 10a2d2: 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 ) ) 10a2d9: 84 c0 test %al,%al 10a2db: 0f 84 6c 01 00 00 je 10a44d <== NEVER TAKEN return EINVAL; core_priority = _POSIX_Priority_To_core( schedparam.sched_priority ); 10a2e1: 8b 45 c4 mov -0x3c(%ebp),%eax 10a2e4: 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); 10a2e7: 0f b6 3d 18 12 12 00 movzbl 0x121218,%edi /* * Set the core scheduling policy information. */ rc = _POSIX_Thread_Translate_sched_param( 10a2ee: 8d 45 e0 lea -0x20(%ebp),%eax 10a2f1: 50 push %eax 10a2f2: 8d 45 e4 lea -0x1c(%ebp),%eax 10a2f5: 50 push %eax 10a2f6: 8d 45 c4 lea -0x3c(%ebp),%eax 10a2f9: 50 push %eax 10a2fa: ff 75 ac pushl -0x54(%ebp) 10a2fd: e8 ee 57 00 00 call 10faf0 <_POSIX_Thread_Translate_sched_param> 10a302: 89 45 b4 mov %eax,-0x4c(%ebp) schedpolicy, &schedparam, &budget_algorithm, &budget_callout ); if ( rc ) 10a305: 83 c4 10 add $0x10,%esp 10a308: 85 c0 test %eax,%eax 10a30a: 0f 85 3d 01 00 00 jne 10a44d #endif /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 10a310: 83 ec 0c sub $0xc,%esp 10a313: ff 35 7c 53 12 00 pushl 0x12537c 10a319: e8 42 15 00 00 call 10b860 <_API_Mutex_Lock> * _POSIX_Threads_Allocate */ RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void ) { return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information ); 10a31e: c7 04 24 20 55 12 00 movl $0x125520,(%esp) 10a325: e8 9e 1e 00 00 call 10c1c8 <_Objects_Allocate> 10a32a: 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 ) { 10a32d: 83 c4 10 add $0x10,%esp 10a330: 85 c0 test %eax,%eax 10a332: 75 05 jne 10a339 _RTEMS_Unlock_allocator(); 10a334: 83 ec 0c sub $0xc,%esp 10a337: eb 53 jmp 10a38c /* * Initialize the core thread for this task. */ name.name_p = NULL; /* posix threads don't have a name by default */ status = _Thread_Initialize( 10a339: 8b 4d e0 mov -0x20(%ebp),%ecx 10a33c: 8b 75 e4 mov -0x1c(%ebp),%esi 10a33f: 8b 53 08 mov 0x8(%ebx),%edx 10a342: a1 14 12 12 00 mov 0x121214,%eax 10a347: d1 e0 shl %eax 10a349: 39 d0 cmp %edx,%eax 10a34b: 73 02 jae 10a34f 10a34d: 89 d0 mov %edx,%eax 10a34f: 52 push %edx 10a350: 6a 00 push $0x0 10a352: 6a 00 push $0x0 10a354: 51 push %ecx 10a355: 56 push %esi 10a356: 6a 01 push $0x1 10a358: 81 e7 ff 00 00 00 and $0xff,%edi 10a35e: 2b 7d a8 sub -0x58(%ebp),%edi 10a361: 57 push %edi 10a362: 6a 01 push $0x1 10a364: 50 push %eax 10a365: ff 73 04 pushl 0x4(%ebx) 10a368: ff 75 b0 pushl -0x50(%ebp) 10a36b: 68 20 55 12 00 push $0x125520 10a370: e8 f3 2a 00 00 call 10ce68 <_Thread_Initialize> budget_callout, 0, /* isr level */ name /* posix threads don't have a name */ ); if ( !status ) { 10a375: 83 c4 30 add $0x30,%esp 10a378: 84 c0 test %al,%al 10a37a: 75 2a jne 10a3a6 RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free ( Thread_Control *the_pthread ) { _Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object ); 10a37c: 56 push %esi 10a37d: 56 push %esi 10a37e: ff 75 b0 pushl -0x50(%ebp) 10a381: 68 20 55 12 00 push $0x125520 10a386: e8 35 21 00 00 call 10c4c0 <_Objects_Free> _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 10a38b: 5b pop %ebx 10a38c: ff 35 7c 53 12 00 pushl 0x12537c 10a392: e8 11 15 00 00 call 10b8a8 <_API_Mutex_Unlock> return EAGAIN; 10a397: 83 c4 10 add $0x10,%esp 10a39a: c7 45 b4 0b 00 00 00 movl $0xb,-0x4c(%ebp) 10a3a1: e9 a7 00 00 00 jmp 10a44d } /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10a3a6: 8b 45 b0 mov -0x50(%ebp),%eax 10a3a9: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx api->Attributes = *the_attr; 10a3af: b9 10 00 00 00 mov $0x10,%ecx 10a3b4: 89 d7 mov %edx,%edi 10a3b6: 89 de mov %ebx,%esi 10a3b8: f3 a5 rep movsl %ds:(%esi),%es:(%edi) api->detachstate = the_attr->detachstate; 10a3ba: 8b 43 3c mov 0x3c(%ebx),%eax 10a3bd: 89 42 40 mov %eax,0x40(%edx) api->schedpolicy = schedpolicy; 10a3c0: 8b 45 ac mov -0x54(%ebp),%eax 10a3c3: 89 82 84 00 00 00 mov %eax,0x84(%edx) api->schedparam = schedparam; 10a3c9: 8d ba 88 00 00 00 lea 0x88(%edx),%edi 10a3cf: 8d 75 c4 lea -0x3c(%ebp),%esi 10a3d2: b1 07 mov $0x7,%cl 10a3d4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 10a3d6: 83 ec 0c sub $0xc,%esp 10a3d9: 6a 00 push $0x0 10a3db: ff 75 14 pushl 0x14(%ebp) 10a3de: ff 75 10 pushl 0x10(%ebp) 10a3e1: 6a 01 push $0x1 10a3e3: ff 75 b0 pushl -0x50(%ebp) 10a3e6: 89 55 a4 mov %edx,-0x5c(%ebp) 10a3e9: e8 02 34 00 00 call 10d7f0 <_Thread_Start> _RTEMS_Unlock_allocator(); return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { 10a3ee: 83 c4 20 add $0x20,%esp 10a3f1: 83 7d ac 04 cmpl $0x4,-0x54(%ebp) 10a3f5: 8b 55 a4 mov -0x5c(%ebp),%edx 10a3f8: 75 2e jne 10a428 _Watchdog_Insert_ticks( 10a3fa: 83 ec 0c sub $0xc,%esp &api->Sporadic_timer, _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period ) 10a3fd: 8d 82 90 00 00 00 lea 0x90(%edx),%eax return EINVAL; } #endif if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 10a403: 50 push %eax 10a404: e8 8f 35 00 00 call 10d998 <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10a409: 8b 55 a4 mov -0x5c(%ebp),%edx 10a40c: 89 82 b4 00 00 00 mov %eax,0xb4(%edx) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10a412: 58 pop %eax 10a413: 59 pop %ecx 10a414: 81 c2 a8 00 00 00 add $0xa8,%edx 10a41a: 52 push %edx 10a41b: 68 9c 53 12 00 push $0x12539c 10a420: e8 27 38 00 00 call 10dc4c <_Watchdog_Insert> 10a425: 83 c4 10 add $0x10,%esp } /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 10a428: 8b 45 b0 mov -0x50(%ebp),%eax 10a42b: 8b 50 08 mov 0x8(%eax),%edx 10a42e: 8b 45 08 mov 0x8(%ebp),%eax 10a431: 89 10 mov %edx,(%eax) _RTEMS_Unlock_allocator(); 10a433: 83 ec 0c sub $0xc,%esp 10a436: ff 35 7c 53 12 00 pushl 0x12537c 10a43c: e8 67 14 00 00 call 10b8a8 <_API_Mutex_Unlock> return 0; 10a441: 83 c4 10 add $0x10,%esp 10a444: eb 07 jmp 10a44d schedpolicy = the_attr->schedpolicy; schedparam = the_attr->schedparam; break; default: return EINVAL; 10a446: c7 45 b4 16 00 00 00 movl $0x16,-0x4c(%ebp) */ *thread = the_thread->Object.id; _RTEMS_Unlock_allocator(); return 0; } 10a44d: 8b 45 b4 mov -0x4c(%ebp),%eax 10a450: 8d 65 f4 lea -0xc(%ebp),%esp 10a453: 5b pop %ebx 10a454: 5e pop %esi 10a455: 5f pop %edi 10a456: c9 leave 10a457: c3 ret =============================================================================== 00110cc0 : } void pthread_exit( void *value_ptr ) { 110cc0: 55 push %ebp 110cc1: 89 e5 mov %esp,%ebp 110cc3: 83 ec 10 sub $0x10,%esp _POSIX_Thread_Exit( _Thread_Executing, value_ptr ); 110cc6: ff 75 08 pushl 0x8(%ebp) 110cc9: ff 35 34 48 12 00 pushl 0x124834 110ccf: e8 88 ff ff ff call 110c5c <_POSIX_Thread_Exit> 110cd4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 110cd7: c9 leave <== NOT EXECUTED 110cd8: c3 ret <== NOT EXECUTED =============================================================================== 0010bf30 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 10bf30: 55 push %ebp 10bf31: 89 e5 mov %esp,%ebp 10bf33: 53 push %ebx 10bf34: 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 ); 10bf37: 8d 45 f4 lea -0xc(%ebp),%eax 10bf3a: 50 push %eax 10bf3b: ff 75 0c pushl 0xc(%ebp) 10bf3e: e8 b9 00 00 00 call 10bffc <_POSIX_Absolute_timeout_to_ticks> 10bf43: 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, 10bf45: 83 c4 0c add $0xc,%esp 10bf48: 83 f8 03 cmp $0x3,%eax 10bf4b: 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 ); 10bf4e: ff 75 f4 pushl -0xc(%ebp) 10bf51: 0f b6 c2 movzbl %dl,%eax 10bf54: 50 push %eax 10bf55: ff 75 08 pushl 0x8(%ebp) 10bf58: 88 55 e4 mov %dl,-0x1c(%ebp) 10bf5b: e8 e8 fe ff ff call 10be48 <_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) ) { 10bf60: 83 c4 10 add $0x10,%esp 10bf63: 8a 55 e4 mov -0x1c(%ebp),%dl 10bf66: 84 d2 test %dl,%dl 10bf68: 75 1d jne 10bf87 10bf6a: 83 f8 10 cmp $0x10,%eax 10bf6d: 75 18 jne 10bf87 <== NEVER TAKEN if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10bf6f: 85 db test %ebx,%ebx 10bf71: 74 08 je 10bf7b <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10bf73: 4b dec %ebx 10bf74: 83 fb 01 cmp $0x1,%ebx 10bf77: 77 0e ja 10bf87 <== NEVER TAKEN 10bf79: eb 07 jmp 10bf82 * 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; 10bf7b: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10bf80: eb 05 jmp 10bf87 <== NOT EXECUTED if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10bf82: b8 74 00 00 00 mov $0x74,%eax } return lock_status; } 10bf87: 8b 5d fc mov -0x4(%ebp),%ebx 10bf8a: c9 leave 10bf8b: c3 ret =============================================================================== 0010bba8 : int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { 10bba8: 55 push %ebp 10bba9: 89 e5 mov %esp,%ebp 10bbab: 8b 55 08 mov 0x8(%ebp),%edx 10bbae: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 10bbb1: b8 16 00 00 00 mov $0x16,%eax int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { if ( !attr || !attr->is_initialized ) 10bbb6: 85 d2 test %edx,%edx 10bbb8: 74 0f je 10bbc9 10bbba: 83 3a 00 cmpl $0x0,(%edx) 10bbbd: 74 0a je 10bbc9 return EINVAL; switch ( pshared ) { 10bbbf: 83 f9 01 cmp $0x1,%ecx 10bbc2: 77 05 ja 10bbc9 <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10bbc4: 89 4a 04 mov %ecx,0x4(%edx) return 0; 10bbc7: 30 c0 xor %al,%al default: return EINVAL; } } 10bbc9: c9 leave 10bbca: c3 ret =============================================================================== 00109dc0 : #if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES) int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { 109dc0: 55 push %ebp 109dc1: 89 e5 mov %esp,%ebp 109dc3: 8b 55 08 mov 0x8(%ebp),%edx 109dc6: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr || !attr->is_initialized ) return EINVAL; 109dc9: b8 16 00 00 00 mov $0x16,%eax int pthread_mutexattr_settype( pthread_mutexattr_t *attr, int type ) { if ( !attr || !attr->is_initialized ) 109dce: 85 d2 test %edx,%edx 109dd0: 74 0f je 109de1 109dd2: 83 3a 00 cmpl $0x0,(%edx) 109dd5: 74 0a je 109de1 <== NEVER TAKEN return EINVAL; switch ( type ) { 109dd7: 83 f9 03 cmp $0x3,%ecx 109dda: 77 05 ja 109de1 case PTHREAD_MUTEX_NORMAL: case PTHREAD_MUTEX_RECURSIVE: case PTHREAD_MUTEX_ERRORCHECK: case PTHREAD_MUTEX_DEFAULT: attr->type = type; 109ddc: 89 4a 10 mov %ecx,0x10(%edx) return 0; 109ddf: 30 c0 xor %al,%al default: return EINVAL; } } 109de1: c9 leave 109de2: c3 ret =============================================================================== 0010a870 : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 10a870: 55 push %ebp 10a871: 89 e5 mov %esp,%ebp 10a873: 56 push %esi 10a874: 53 push %ebx 10a875: 83 ec 10 sub $0x10,%esp 10a878: 8b 5d 08 mov 0x8(%ebp),%ebx 10a87b: 8b 75 0c mov 0xc(%ebp),%esi if ( !once_control || !init_routine ) 10a87e: 85 f6 test %esi,%esi 10a880: 74 51 je 10a8d3 10a882: 85 db test %ebx,%ebx 10a884: 74 4d je 10a8d3 once_control->init_executed = true; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; 10a886: 31 c0 xor %eax,%eax ) { if ( !once_control || !init_routine ) return EINVAL; if ( !once_control->init_executed ) { 10a888: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a88c: 75 4a jne 10a8d8 rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 10a88e: 52 push %edx 10a88f: 8d 45 f4 lea -0xc(%ebp),%eax 10a892: 50 push %eax 10a893: 68 00 01 00 00 push $0x100 10a898: 68 00 01 00 00 push $0x100 10a89d: e8 9e 0a 00 00 call 10b340 if ( !once_control->init_executed ) { 10a8a2: 83 c4 10 add $0x10,%esp 10a8a5: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a8a9: 75 0f jne 10a8ba <== NEVER TAKEN once_control->is_initialized = true; 10a8ab: c7 03 01 00 00 00 movl $0x1,(%ebx) once_control->init_executed = true; 10a8b1: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) (*init_routine)(); 10a8b8: ff d6 call *%esi } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10a8ba: 50 push %eax 10a8bb: 8d 45 f4 lea -0xc(%ebp),%eax 10a8be: 50 push %eax 10a8bf: 68 00 01 00 00 push $0x100 10a8c4: ff 75 f4 pushl -0xc(%ebp) 10a8c7: e8 74 0a 00 00 call 10b340 10a8cc: 83 c4 10 add $0x10,%esp } return 0; 10a8cf: 31 c0 xor %eax,%eax 10a8d1: eb 05 jmp 10a8d8 pthread_once_t *once_control, void (*init_routine)(void) ) { if ( !once_control || !init_routine ) return EINVAL; 10a8d3: b8 16 00 00 00 mov $0x16,%eax (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; } 10a8d8: 8d 65 f8 lea -0x8(%ebp),%esp 10a8db: 5b pop %ebx 10a8dc: 5e pop %esi 10a8dd: c9 leave 10a8de: c3 ret =============================================================================== 0010b09c : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 10b09c: 55 push %ebp 10b09d: 89 e5 mov %esp,%ebp 10b09f: 56 push %esi 10b0a0: 53 push %ebx 10b0a1: 83 ec 10 sub $0x10,%esp 10b0a4: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Error check parameters */ if ( !rwlock ) return EINVAL; 10b0a7: b8 16 00 00 00 mov $0x16,%eax const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 10b0ac: 85 db test %ebx,%ebx 10b0ae: 0f 84 8b 00 00 00 je 10b13f return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10b0b4: 8b 75 0c mov 0xc(%ebp),%esi 10b0b7: 85 f6 test %esi,%esi 10b0b9: 75 0f jne 10b0ca the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 10b0bb: 83 ec 0c sub $0xc,%esp 10b0be: 8d 75 ec lea -0x14(%ebp),%esi 10b0c1: 56 push %esi 10b0c2: e8 5d 09 00 00 call 10ba24 10b0c7: 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; 10b0ca: 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 ) 10b0cf: 83 3e 00 cmpl $0x0,(%esi) 10b0d2: 74 6b je 10b13f <== NEVER TAKEN return EINVAL; switch ( the_attr->process_shared ) { 10b0d4: 83 7e 04 00 cmpl $0x0,0x4(%esi) 10b0d8: 75 65 jne 10b13f <== NEVER TAKEN */ RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes( CORE_RWLock_Attributes *the_attributes ) { the_attributes->XXX = 0; 10b0da: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b0e1: a1 f4 82 12 00 mov 0x1282f4,%eax 10b0e6: 40 inc %eax 10b0e7: a3 f4 82 12 00 mov %eax,0x1282f4 * 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 ); 10b0ec: 83 ec 0c sub $0xc,%esp 10b0ef: 68 00 85 12 00 push $0x128500 10b0f4: e8 2f 23 00 00 call 10d428 <_Objects_Allocate> 10b0f9: 89 c6 mov %eax,%esi */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 10b0fb: 83 c4 10 add $0x10,%esp 10b0fe: 85 c0 test %eax,%eax 10b100: 75 0c jne 10b10e _Thread_Enable_dispatch(); 10b102: e8 2f 2f 00 00 call 10e036 <_Thread_Enable_dispatch> return EAGAIN; 10b107: b8 0b 00 00 00 mov $0xb,%eax 10b10c: eb 31 jmp 10b13f } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 10b10e: 50 push %eax 10b10f: 50 push %eax 10b110: 8d 45 f4 lea -0xc(%ebp),%eax 10b113: 50 push %eax 10b114: 8d 46 10 lea 0x10(%esi),%eax 10b117: 50 push %eax 10b118: e8 6f 1b 00 00 call 10cc8c <_CORE_RWLock_Initialize> uint32_t name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 10b11d: 8b 46 08 mov 0x8(%esi),%eax Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10b120: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10b123: 8b 15 1c 85 12 00 mov 0x12851c,%edx 10b129: 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; 10b12c: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 10b133: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10b135: e8 fc 2e 00 00 call 10e036 <_Thread_Enable_dispatch> return 0; 10b13a: 83 c4 10 add $0x10,%esp 10b13d: 31 c0 xor %eax,%eax } 10b13f: 8d 65 f8 lea -0x8(%ebp),%esp 10b142: 5b pop %ebx 10b143: 5e pop %esi 10b144: c9 leave 10b145: c3 ret =============================================================================== 0010b1b0 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10b1b0: 55 push %ebp 10b1b1: 89 e5 mov %esp,%ebp 10b1b3: 57 push %edi 10b1b4: 56 push %esi 10b1b5: 53 push %ebx 10b1b6: 83 ec 2c sub $0x2c,%esp 10b1b9: 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; 10b1bc: 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 ) 10b1c1: 85 ff test %edi,%edi 10b1c3: 0f 84 87 00 00 00 je 10b250 * * 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 ); 10b1c9: 50 push %eax 10b1ca: 50 push %eax 10b1cb: 8d 45 e0 lea -0x20(%ebp),%eax 10b1ce: 50 push %eax 10b1cf: ff 75 0c pushl 0xc(%ebp) 10b1d2: e8 39 58 00 00 call 110a10 <_POSIX_Absolute_timeout_to_ticks> 10b1d7: 89 c6 mov %eax,%esi 10b1d9: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10b1dc: 8d 45 e4 lea -0x1c(%ebp),%eax 10b1df: 50 push %eax 10b1e0: ff 37 pushl (%edi) 10b1e2: 68 00 85 12 00 push $0x128500 10b1e7: e8 6c 26 00 00 call 10d858 <_Objects_Get> switch ( location ) { 10b1ec: 83 c4 10 add $0x10,%esp 10b1ef: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b1f3: 75 5b jne 10b250 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, 10b1f5: 83 fe 03 cmp $0x3,%esi 10b1f8: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 10b1fb: 83 ec 0c sub $0xc,%esp 10b1fe: 6a 00 push $0x0 10b200: ff 75 e0 pushl -0x20(%ebp) 10b203: 0f b6 ca movzbl %dl,%ecx 10b206: 51 push %ecx 10b207: ff 37 pushl (%edi) 10b209: 83 c0 10 add $0x10,%eax 10b20c: 50 push %eax 10b20d: 88 55 d4 mov %dl,-0x2c(%ebp) 10b210: e8 ab 1a 00 00 call 10ccc0 <_CORE_RWLock_Obtain_for_reading> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10b215: 83 c4 20 add $0x20,%esp 10b218: e8 19 2e 00 00 call 10e036 <_Thread_Enable_dispatch> if ( !do_wait ) { 10b21d: 8a 55 d4 mov -0x2c(%ebp),%dl 10b220: 84 d2 test %dl,%dl 10b222: 75 17 jne 10b23b if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) { 10b224: a1 44 88 12 00 mov 0x128844,%eax 10b229: 83 78 34 02 cmpl $0x2,0x34(%eax) 10b22d: 75 0c jne 10b23b if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10b22f: 85 f6 test %esi,%esi 10b231: 74 1d je 10b250 <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b233: 4e dec %esi status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10b234: 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 || 10b236: 83 fe 01 cmp $0x1,%esi 10b239: 76 15 jbe 10b250 <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b23b: 83 ec 0c sub $0xc,%esp (CORE_RWLock_Status) _Thread_Executing->Wait.return_code 10b23e: a1 44 88 12 00 mov 0x128844,%eax status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b243: ff 70 34 pushl 0x34(%eax) 10b246: e8 bd 00 00 00 call 10b308 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10b24b: 89 c3 mov %eax,%ebx 10b24d: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10b250: 89 d8 mov %ebx,%eax 10b252: 8d 65 f4 lea -0xc(%ebp),%esp 10b255: 5b pop %ebx 10b256: 5e pop %esi 10b257: 5f pop %edi 10b258: c9 leave 10b259: c3 ret =============================================================================== 0010b25c : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10b25c: 55 push %ebp 10b25d: 89 e5 mov %esp,%ebp 10b25f: 57 push %edi 10b260: 56 push %esi 10b261: 53 push %ebx 10b262: 83 ec 2c sub $0x2c,%esp 10b265: 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; 10b268: 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 ) 10b26d: 85 ff test %edi,%edi 10b26f: 0f 84 87 00 00 00 je 10b2fc * * 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 ); 10b275: 50 push %eax 10b276: 50 push %eax 10b277: 8d 45 e0 lea -0x20(%ebp),%eax 10b27a: 50 push %eax 10b27b: ff 75 0c pushl 0xc(%ebp) 10b27e: e8 8d 57 00 00 call 110a10 <_POSIX_Absolute_timeout_to_ticks> 10b283: 89 c6 mov %eax,%esi 10b285: 83 c4 0c add $0xc,%esp if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE ) do_wait = false; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); 10b288: 8d 45 e4 lea -0x1c(%ebp),%eax 10b28b: 50 push %eax 10b28c: ff 37 pushl (%edi) 10b28e: 68 00 85 12 00 push $0x128500 10b293: e8 c0 25 00 00 call 10d858 <_Objects_Get> switch ( location ) { 10b298: 83 c4 10 add $0x10,%esp 10b29b: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b29f: 75 5b jne 10b2fc (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, 10b2a1: 83 fe 03 cmp $0x3,%esi 10b2a4: 0f 94 c2 sete %dl case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 10b2a7: 83 ec 0c sub $0xc,%esp 10b2aa: 6a 00 push $0x0 10b2ac: ff 75 e0 pushl -0x20(%ebp) 10b2af: 0f b6 ca movzbl %dl,%ecx 10b2b2: 51 push %ecx 10b2b3: ff 37 pushl (%edi) 10b2b5: 83 c0 10 add $0x10,%eax 10b2b8: 50 push %eax 10b2b9: 88 55 d4 mov %dl,-0x2c(%ebp) 10b2bc: e8 b7 1a 00 00 call 10cd78 <_CORE_RWLock_Obtain_for_writing> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10b2c1: 83 c4 20 add $0x20,%esp 10b2c4: e8 6d 2d 00 00 call 10e036 <_Thread_Enable_dispatch> if ( !do_wait && 10b2c9: 8a 55 d4 mov -0x2c(%ebp),%dl 10b2cc: 84 d2 test %dl,%dl 10b2ce: 75 17 jne 10b2e7 (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { 10b2d0: a1 44 88 12 00 mov 0x128844,%eax ticks, NULL ); _Thread_Enable_dispatch(); if ( !do_wait && 10b2d5: 83 78 34 02 cmpl $0x2,0x34(%eax) 10b2d9: 75 0c jne 10b2e7 (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID ) 10b2db: 85 f6 test %esi,%esi 10b2dd: 74 1d je 10b2fc <== NEVER TAKEN return EINVAL; if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST || 10b2df: 4e dec %esi status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; 10b2e0: 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 || 10b2e2: 83 fe 01 cmp $0x1,%esi 10b2e5: 76 15 jbe 10b2fc <== ALWAYS TAKEN status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW ) return ETIMEDOUT; } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10b2e7: 83 ec 0c sub $0xc,%esp (CORE_RWLock_Status) _Thread_Executing->Wait.return_code 10b2ea: a1 44 88 12 00 mov 0x128844,%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( 10b2ef: ff 70 34 pushl 0x34(%eax) 10b2f2: e8 11 00 00 00 call 10b308 <_POSIX_RWLock_Translate_core_RWLock_return_code> 10b2f7: 89 c3 mov %eax,%ebx 10b2f9: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10b2fc: 89 d8 mov %ebx,%eax 10b2fe: 8d 65 f4 lea -0xc(%ebp),%esp 10b301: 5b pop %ebx 10b302: 5e pop %esi 10b303: 5f pop %edi 10b304: c9 leave 10b305: c3 ret =============================================================================== 0010ba44 : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { 10ba44: 55 push %ebp 10ba45: 89 e5 mov %esp,%ebp 10ba47: 8b 55 08 mov 0x8(%ebp),%edx 10ba4a: 8b 4d 0c mov 0xc(%ebp),%ecx if ( !attr ) return EINVAL; 10ba4d: b8 16 00 00 00 mov $0x16,%eax int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { if ( !attr ) 10ba52: 85 d2 test %edx,%edx 10ba54: 74 0f je 10ba65 return EINVAL; if ( !attr->is_initialized ) 10ba56: 83 3a 00 cmpl $0x0,(%edx) 10ba59: 74 0a je 10ba65 return EINVAL; switch ( pshared ) { 10ba5b: 83 f9 01 cmp $0x1,%ecx 10ba5e: 77 05 ja 10ba65 <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10ba60: 89 4a 04 mov %ecx,0x4(%edx) return 0; 10ba63: 30 c0 xor %al,%al default: return EINVAL; } } 10ba65: c9 leave 10ba66: c3 ret =============================================================================== 0010c754 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 10c754: 55 push %ebp 10c755: 89 e5 mov %esp,%ebp 10c757: 57 push %edi 10c758: 56 push %esi 10c759: 53 push %ebx 10c75a: 83 ec 2c sub $0x2c,%esp 10c75d: 8b 75 10 mov 0x10(%ebp),%esi /* * Check all the parameters */ if ( !param ) return EINVAL; 10c760: c7 45 d4 16 00 00 00 movl $0x16,-0x2c(%ebp) int rc; /* * Check all the parameters */ if ( !param ) 10c767: 85 f6 test %esi,%esi 10c769: 0f 84 00 01 00 00 je 10c86f return EINVAL; rc = _POSIX_Thread_Translate_sched_param( 10c76f: 8d 45 e0 lea -0x20(%ebp),%eax 10c772: 50 push %eax 10c773: 8d 45 e4 lea -0x1c(%ebp),%eax 10c776: 50 push %eax 10c777: 56 push %esi 10c778: ff 75 0c pushl 0xc(%ebp) 10c77b: e8 00 52 00 00 call 111980 <_POSIX_Thread_Translate_sched_param> 10c780: 89 45 d4 mov %eax,-0x2c(%ebp) policy, param, &budget_algorithm, &budget_callout ); if ( rc ) 10c783: 83 c4 10 add $0x10,%esp 10c786: 85 c0 test %eax,%eax 10c788: 0f 85 e1 00 00 00 jne 10c86f 10c78e: 53 push %ebx return rc; /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); 10c78f: 8d 45 dc lea -0x24(%ebp),%eax 10c792: 50 push %eax 10c793: ff 75 08 pushl 0x8(%ebp) 10c796: 68 80 95 12 00 push $0x129580 10c79b: e8 80 1c 00 00 call 10e420 <_Objects_Get> 10c7a0: 89 c2 mov %eax,%edx switch ( location ) { 10c7a2: 83 c4 10 add $0x10,%esp 10c7a5: 83 7d dc 00 cmpl $0x0,-0x24(%ebp) 10c7a9: 0f 85 b9 00 00 00 jne 10c868 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10c7af: 8b 98 f8 00 00 00 mov 0xf8(%eax),%ebx if ( api->schedpolicy == SCHED_SPORADIC ) 10c7b5: 83 bb 84 00 00 00 04 cmpl $0x4,0x84(%ebx) 10c7bc: 75 18 jne 10c7d6 (void) _Watchdog_Remove( &api->Sporadic_timer ); 10c7be: 83 ec 0c sub $0xc,%esp 10c7c1: 8d 83 a8 00 00 00 lea 0xa8(%ebx),%eax 10c7c7: 50 push %eax 10c7c8: 89 55 d0 mov %edx,-0x30(%ebp) 10c7cb: e8 48 34 00 00 call 10fc18 <_Watchdog_Remove> 10c7d0: 83 c4 10 add $0x10,%esp 10c7d3: 8b 55 d0 mov -0x30(%ebp),%edx api->schedpolicy = policy; 10c7d6: 8b 45 0c mov 0xc(%ebp),%eax 10c7d9: 89 83 84 00 00 00 mov %eax,0x84(%ebx) api->schedparam = *param; 10c7df: 8d bb 88 00 00 00 lea 0x88(%ebx),%edi 10c7e5: b9 07 00 00 00 mov $0x7,%ecx 10c7ea: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_thread->budget_algorithm = budget_algorithm; 10c7ec: 8b 45 e4 mov -0x1c(%ebp),%eax 10c7ef: 89 42 7c mov %eax,0x7c(%edx) the_thread->budget_callout = budget_callout; 10c7f2: 8b 45 e0 mov -0x20(%ebp),%eax 10c7f5: 89 82 80 00 00 00 mov %eax,0x80(%edx) switch ( api->schedpolicy ) { 10c7fb: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10c7ff: 78 60 js 10c861 <== NEVER TAKEN 10c801: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) 10c805: 7e 08 jle 10c80f 10c807: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) 10c80b: 75 54 jne 10c861 <== NEVER TAKEN 10c80d: eb 24 jmp 10c833 case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c80f: a1 04 93 12 00 mov 0x129304,%eax 10c814: 89 42 78 mov %eax,0x78(%edx) 10c817: 0f b6 05 18 52 12 00 movzbl 0x125218,%eax 10c81e: 2b 83 88 00 00 00 sub 0x88(%ebx),%eax the_thread->real_priority = 10c824: 89 42 18 mov %eax,0x18(%edx) _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 10c827: 51 push %ecx 10c828: 6a 01 push $0x1 10c82a: 50 push %eax 10c82b: 52 push %edx 10c82c: e8 3b 1f 00 00 call 10e76c <_Thread_Change_priority> 10c831: eb 2b jmp 10c85e true ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 10c833: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 10c839: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) _Watchdog_Remove( &api->Sporadic_timer ); 10c83f: 83 ec 0c sub $0xc,%esp 10c842: 81 c3 a8 00 00 00 add $0xa8,%ebx 10c848: 53 push %ebx 10c849: 89 55 d0 mov %edx,-0x30(%ebp) 10c84c: e8 c7 33 00 00 call 10fc18 <_Watchdog_Remove> _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 10c851: 58 pop %eax 10c852: 5a pop %edx 10c853: 8b 55 d0 mov -0x30(%ebp),%edx 10c856: 52 push %edx 10c857: 6a 00 push $0x0 10c859: e8 e1 fd ff ff call 10c63f <_POSIX_Threads_Sporadic_budget_TSR> break; 10c85e: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10c861: e8 98 23 00 00 call 10ebfe <_Thread_Enable_dispatch> return 0; 10c866: eb 07 jmp 10c86f #endif case OBJECTS_ERROR: break; } return ESRCH; 10c868: c7 45 d4 03 00 00 00 movl $0x3,-0x2c(%ebp) } 10c86f: 8b 45 d4 mov -0x2c(%ebp),%eax 10c872: 8d 65 f4 lea -0xc(%ebp),%esp 10c875: 5b pop %ebx 10c876: 5e pop %esi 10c877: 5f pop %edi 10c878: c9 leave 10c879: c3 ret =============================================================================== 0010a640 : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 10a640: 55 push %ebp 10a641: 89 e5 mov %esp,%ebp 10a643: 53 push %ebx 10a644: 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() ) 10a647: 83 3d 18 68 12 00 00 cmpl $0x0,0x126818 10a64e: 75 48 jne 10a698 <== NEVER TAKEN return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a650: a1 1c 68 12 00 mov 0x12681c,%eax 10a655: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax 10a65b: 8b 15 cc 62 12 00 mov 0x1262cc,%edx 10a661: 42 inc %edx 10a662: 89 15 cc 62 12 00 mov %edx,0x1262cc */ void pthread_testcancel( void ) { POSIX_API_Control *thread_support; bool cancel = false; 10a668: 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 && 10a66a: 83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax) 10a671: 75 0a jne 10a67d <== 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)); 10a673: 83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax) 10a67a: 0f 95 c3 setne %bl thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a67d: e8 10 23 00 00 call 10c992 <_Thread_Enable_dispatch> if ( cancel ) 10a682: 84 db test %bl,%bl 10a684: 74 12 je 10a698 _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10a686: 50 push %eax 10a687: 50 push %eax 10a688: 6a ff push $0xffffffff 10a68a: ff 35 1c 68 12 00 pushl 0x12681c 10a690: e8 9b 51 00 00 call 10f830 <_POSIX_Thread_Exit> 10a695: 83 c4 10 add $0x10,%esp } 10a698: 8b 5d fc mov -0x4(%ebp),%ebx 10a69b: c9 leave 10a69c: c3 ret =============================================================================== 0011c7b4 : ssize_t read( int fd, void *buffer, size_t count ) { 11c7b4: 55 push %ebp 11c7b5: 89 e5 mov %esp,%ebp 11c7b7: 56 push %esi 11c7b8: 53 push %ebx 11c7b9: 8b 5d 08 mov 0x8(%ebp),%ebx 11c7bc: 8b 55 0c mov 0xc(%ebp),%edx 11c7bf: 8b 4d 10 mov 0x10(%ebp),%ecx ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11c7c2: 3b 1d 44 01 12 00 cmp 0x120144,%ebx 11c7c8: 73 14 jae 11c7de <== NEVER TAKEN iop = rtems_libio_iop( fd ); 11c7ca: 6b db 38 imul $0x38,%ebx,%ebx 11c7cd: 03 1d 98 41 12 00 add 0x124198,%ebx rtems_libio_check_is_open( iop ); 11c7d3: 8b 73 14 mov 0x14(%ebx),%esi 11c7d6: f7 c6 00 01 00 00 test $0x100,%esi 11c7dc: 75 0d jne 11c7eb 11c7de: e8 c9 48 ff ff call 1110ac <__errno> 11c7e3: c7 00 09 00 00 00 movl $0x9,(%eax) 11c7e9: eb 1a jmp 11c805 rtems_libio_check_buffer( buffer ); 11c7eb: 85 d2 test %edx,%edx 11c7ed: 74 0b je 11c7fa <== NEVER TAKEN rtems_libio_check_count( count ); 11c7ef: 31 c0 xor %eax,%eax 11c7f1: 85 c9 test %ecx,%ecx 11c7f3: 74 31 je 11c826 rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 11c7f5: 83 e6 02 and $0x2,%esi 11c7f8: 75 10 jne 11c80a 11c7fa: e8 ad 48 ff ff call 1110ac <__errno> 11c7ff: c7 00 16 00 00 00 movl $0x16,(%eax) 11c805: 83 c8 ff or $0xffffffff,%eax 11c808: eb 1c jmp 11c826 /* * Now process the read(). */ rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count ); 11c80a: 50 push %eax 11c80b: 8b 43 20 mov 0x20(%ebx),%eax 11c80e: 51 push %ecx 11c80f: 52 push %edx 11c810: 53 push %ebx 11c811: ff 50 08 call *0x8(%eax) if ( rc > 0 ) 11c814: 83 c4 10 add $0x10,%esp 11c817: 85 c0 test %eax,%eax 11c819: 7e 0b jle 11c826 iop->offset += rc; 11c81b: 89 c1 mov %eax,%ecx 11c81d: c1 f9 1f sar $0x1f,%ecx 11c820: 01 43 0c add %eax,0xc(%ebx) 11c823: 11 4b 10 adc %ecx,0x10(%ebx) return rc; } 11c826: 8d 65 f8 lea -0x8(%ebp),%esp 11c829: 5b pop %ebx 11c82a: 5e pop %esi 11c82b: c9 leave 11c82c: 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 fc 98 00 00 call 1137b8 <__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 a9 98 00 00 call 1137b8 <__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 =============================================================================== 00108c64 : ssize_t readv( int fd, const struct iovec *iov, int iovcnt ) { 108c64: 55 push %ebp 108c65: 89 e5 mov %esp,%ebp 108c67: 57 push %edi 108c68: 56 push %esi 108c69: 53 push %ebx 108c6a: 83 ec 2c sub $0x2c,%esp 108c6d: 8b 75 08 mov 0x8(%ebp),%esi 108c70: 8b 7d 0c mov 0xc(%ebp),%edi int v; int bytes; rtems_libio_t *iop; bool all_zeros; rtems_libio_check_fd( fd ); 108c73: 3b 35 44 11 12 00 cmp 0x121144,%esi 108c79: 73 11 jae 108c8c iop = rtems_libio_iop( fd ); 108c7b: 6b f6 38 imul $0x38,%esi,%esi 108c7e: 03 35 98 51 12 00 add 0x125198,%esi rtems_libio_check_is_open( iop ); 108c84: 8b 46 14 mov 0x14(%esi),%eax 108c87: f6 c4 01 test $0x1,%ah 108c8a: 75 10 jne 108c9c 108c8c: e8 fb 8f 00 00 call 111c8c <__errno> 108c91: c7 00 09 00 00 00 movl $0x9,(%eax) 108c97: e9 a4 00 00 00 jmp 108d40 rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 108c9c: a8 02 test $0x2,%al 108c9e: 74 35 je 108cd5 <== NEVER TAKEN /* * Argument validation on IO vector */ if ( !iov ) 108ca0: 85 ff test %edi,%edi 108ca2: 74 31 je 108cd5 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt <= 0 ) 108ca4: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 108ca8: 7e 2b jle 108cd5 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt > IOV_MAX ) 108caa: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp) 108cb1: 7f 22 jg 108cd5 <== NEVER TAKEN 108cb3: b2 01 mov $0x1,%dl 108cb5: 31 c0 xor %eax,%eax 108cb7: 31 c9 xor %ecx,%ecx 108cb9: 89 75 d4 mov %esi,-0x2c(%ebp) 108cbc: eb 03 jmp 108cc1 if ( iov[v].iov_base == 0 ) rtems_set_errno_and_return_minus_one( EINVAL ); /* check for wrap */ old = total; total += iov[v].iov_len; 108cbe: 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 ) 108cc1: 83 3c c7 00 cmpl $0x0,(%edi,%eax,8) 108cc5: 74 0e je 108cd5 rtems_set_errno_and_return_minus_one( EINVAL ); /* check for wrap */ old = total; total += iov[v].iov_len; 108cc7: 8b 5c c7 04 mov 0x4(%edi,%eax,8),%ebx 108ccb: 8d 34 19 lea (%ecx,%ebx,1),%esi 108cce: 89 75 e4 mov %esi,-0x1c(%ebp) if ( total < old ) 108cd1: 39 ce cmp %ecx,%esi 108cd3: 7d 0d jge 108ce2 rtems_set_errno_and_return_minus_one( EINVAL ); 108cd5: e8 b2 8f 00 00 call 111c8c <__errno> 108cda: c7 00 16 00 00 00 movl $0x16,(%eax) 108ce0: eb 5e jmp 108d40 if ( iov[v].iov_len ) all_zeros = false; 108ce2: 85 db test %ebx,%ebx 108ce4: 0f 94 c1 sete %cl 108ce7: f7 d9 neg %ecx 108ce9: 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++ ) { 108ceb: 40 inc %eax 108cec: 3b 45 10 cmp 0x10(%ebp),%eax 108cef: 7c cd jl 108cbe 108cf1: 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; 108cf4: 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 ) { 108cf6: 84 d2 test %dl,%dl 108cf8: 75 49 jne 108d43 108cfa: 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)( 108d01: 50 push %eax 108d02: 8b 46 20 mov 0x20(%esi),%eax 108d05: 8b 55 e4 mov -0x1c(%ebp),%edx 108d08: ff 74 d7 04 pushl 0x4(%edi,%edx,8) 108d0c: ff 34 d7 pushl (%edi,%edx,8) 108d0f: 56 push %esi 108d10: ff 50 08 call *0x8(%eax) iop, iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) 108d13: 83 c4 10 add $0x10,%esp 108d16: 83 f8 00 cmp $0x0,%eax 108d19: 7c 25 jl 108d40 <== NEVER TAKEN return -1; if ( bytes > 0 ) { 108d1b: 74 0d je 108d2a <== NEVER TAKEN iop->offset += bytes; 108d1d: 89 c1 mov %eax,%ecx 108d1f: c1 f9 1f sar $0x1f,%ecx 108d22: 01 46 0c add %eax,0xc(%esi) 108d25: 11 4e 10 adc %ecx,0x10(%esi) total += bytes; 108d28: 01 c3 add %eax,%ebx } if (bytes != iov[ v ].iov_len) 108d2a: 8b 55 e4 mov -0x1c(%ebp),%edx 108d2d: 3b 44 d7 04 cmp 0x4(%edi,%edx,8),%eax 108d31: 75 10 jne 108d43 <== NEVER TAKEN } /* * Now process the readv(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { 108d33: 42 inc %edx 108d34: 89 55 e4 mov %edx,-0x1c(%ebp) 108d37: 8b 45 10 mov 0x10(%ebp),%eax 108d3a: 39 c2 cmp %eax,%edx 108d3c: 7c c3 jl 108d01 108d3e: eb 03 jmp 108d43 iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) return -1; 108d40: 83 cb ff or $0xffffffff,%ebx if (bytes != iov[ v ].iov_len) break; } return total; } 108d43: 89 d8 mov %ebx,%eax 108d45: 8d 65 f4 lea -0xc(%ebp),%esp 108d48: 5b pop %ebx 108d49: 5e pop %esi 108d4a: 5f pop %edi 108d4b: c9 leave 108d4c: c3 ret =============================================================================== 0011c8b8 : void *realloc( void *ptr, size_t size ) { 11c8b8: 55 push %ebp 11c8b9: 89 e5 mov %esp,%ebp 11c8bb: 57 push %edi 11c8bc: 56 push %esi 11c8bd: 53 push %ebx 11c8be: 83 ec 2c sub $0x2c,%esp 11c8c1: 8b 5d 08 mov 0x8(%ebp),%ebx 11c8c4: 8b 75 0c mov 0xc(%ebp),%esi uintptr_t old_size; char *new_area; MSBUMP(realloc_calls, 1); 11c8c7: ff 05 c0 41 12 00 incl 0x1241c0 /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 11c8cd: 83 3d 64 44 12 00 03 cmpl $0x3,0x124464 11c8d4: 75 1a jne 11c8f0 <== NEVER TAKEN if (_Thread_Dispatch_disable_level > 0) 11c8d6: a1 e4 42 12 00 mov 0x1242e4,%eax 11c8db: 85 c0 test %eax,%eax 11c8dd: 0f 85 ad 00 00 00 jne 11c990 <== NEVER TAKEN return (void *) 0; if (_ISR_Nest_level > 0) 11c8e3: 83 3d 30 48 12 00 00 cmpl $0x0,0x124830 11c8ea: 0f 85 a0 00 00 00 jne 11c990 <== NEVER TAKEN } /* * Continue with realloc(). */ if ( !ptr ) 11c8f0: 85 db test %ebx,%ebx 11c8f2: 75 13 jne 11c907 return malloc( size ); 11c8f4: 83 ec 0c sub $0xc,%esp 11c8f7: 56 push %esi 11c8f8: e8 e7 ac fe ff call 1075e4 11c8fd: 89 c3 mov %eax,%ebx 11c8ff: 83 c4 10 add $0x10,%esp 11c902: e9 8b 00 00 00 jmp 11c992 if ( !size ) { 11c907: 85 f6 test %esi,%esi 11c909: 75 0e jne 11c919 <== ALWAYS TAKEN free( ptr ); 11c90b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11c90e: 53 push %ebx <== NOT EXECUTED 11c90f: e8 34 aa fe ff call 107348 <== NOT EXECUTED return (void *) 0; 11c914: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11c917: eb 77 jmp 11c990 <== NOT EXECUTED } if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) { 11c919: 52 push %edx 11c91a: 8d 45 e4 lea -0x1c(%ebp),%eax 11c91d: 50 push %eax 11c91e: 53 push %ebx 11c91f: ff 35 50 01 12 00 pushl 0x120150 11c925: e8 ee 00 00 00 call 11ca18 <_Protected_heap_Get_block_size> 11c92a: 83 c4 10 add $0x10,%esp 11c92d: 84 c0 test %al,%al 11c92f: 75 0d jne 11c93e errno = EINVAL; 11c931: e8 76 47 ff ff call 1110ac <__errno> 11c936: c7 00 16 00 00 00 movl $0x16,(%eax) 11c93c: eb 52 jmp 11c990 } /* * Now resize it. */ if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) { 11c93e: 50 push %eax 11c93f: 56 push %esi 11c940: 53 push %ebx 11c941: ff 35 50 01 12 00 pushl 0x120150 11c947: e8 04 01 00 00 call 11ca50 <_Protected_heap_Resize_block> 11c94c: 83 c4 10 add $0x10,%esp 11c94f: 84 c0 test %al,%al 11c951: 75 3f jne 11c992 * 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 ); 11c953: 83 ec 0c sub $0xc,%esp 11c956: 56 push %esi 11c957: e8 88 ac fe ff call 1075e4 MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ 11c95c: ff 0d b4 41 12 00 decl 0x1241b4 if ( !new_area ) { 11c962: 83 c4 10 add $0x10,%esp 11c965: 85 c0 test %eax,%eax 11c967: 74 27 je 11c990 return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 11c969: 8b 55 e4 mov -0x1c(%ebp),%edx 11c96c: 89 f1 mov %esi,%ecx 11c96e: 39 d6 cmp %edx,%esi 11c970: 76 02 jbe 11c974 <== NEVER TAKEN 11c972: 89 d1 mov %edx,%ecx 11c974: 89 c7 mov %eax,%edi 11c976: 89 de mov %ebx,%esi 11c978: f3 a4 rep movsb %ds:(%esi),%es:(%edi) free( ptr ); 11c97a: 83 ec 0c sub $0xc,%esp 11c97d: 53 push %ebx 11c97e: 89 45 d4 mov %eax,-0x2c(%ebp) 11c981: e8 c2 a9 fe ff call 107348 return new_area; 11c986: 83 c4 10 add $0x10,%esp 11c989: 8b 45 d4 mov -0x2c(%ebp),%eax 11c98c: 89 c3 mov %eax,%ebx 11c98e: eb 02 jmp 11c992 new_area = malloc( size ); MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ if ( !new_area ) { return (void *) 0; 11c990: 31 db xor %ebx,%ebx memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; } 11c992: 89 d8 mov %ebx,%eax 11c994: 8d 65 f4 lea -0xc(%ebp),%esp 11c997: 5b pop %ebx 11c998: 5e pop %esi 11c999: 5f pop %edi 11c99a: c9 leave 11c99b: 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 cc 93 00 00 call 11184c <__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 =============================================================================== 0010af11 : * errno - otherwise */ int rtems_aio_enqueue (rtems_aio_request *req) { 10af11: 55 push %ebp 10af12: 89 e5 mov %esp,%ebp 10af14: 57 push %edi 10af15: 56 push %esi 10af16: 53 push %ebx 10af17: 83 ec 58 sub $0x58,%esp 10af1a: 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); 10af1d: 68 78 72 12 00 push $0x127278 10af22: e8 bd 08 00 00 call 10b7e4 10af27: 89 45 b4 mov %eax,-0x4c(%ebp) if (result != 0) { 10af2a: 83 c4 10 add $0x10,%esp 10af2d: 85 c0 test %eax,%eax 10af2f: 74 0e je 10af3f <== ALWAYS TAKEN free (req); 10af31: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af34: 53 push %ebx <== NOT EXECUTED 10af35: e8 06 ce ff ff call 107d40 <== NOT EXECUTED 10af3a: e9 bf 01 00 00 jmp 10b0fe <== 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); 10af3f: e8 a0 10 00 00 call 10bfe4 10af44: 57 push %edi 10af45: 8d 55 c4 lea -0x3c(%ebp),%edx 10af48: 52 push %edx 10af49: 8d 55 e0 lea -0x20(%ebp),%edx 10af4c: 52 push %edx 10af4d: 50 push %eax 10af4e: e8 95 0c 00 00 call 10bbe8 req->caller_thread = pthread_self (); 10af53: e8 8c 10 00 00 call 10bfe4 10af58: 89 43 10 mov %eax,0x10(%ebx) req->priority = param.sched_priority - req->aiocbp->aio_reqprio; 10af5b: 8b 43 14 mov 0x14(%ebx),%eax 10af5e: 8b 55 c4 mov -0x3c(%ebp),%edx 10af61: 2b 50 14 sub 0x14(%eax),%edx 10af64: 89 53 0c mov %edx,0xc(%ebx) req->policy = policy; 10af67: 8b 55 e0 mov -0x20(%ebp),%edx 10af6a: 89 53 08 mov %edx,0x8(%ebx) req->aiocbp->error_code = EINPROGRESS; 10af6d: c7 40 30 77 00 00 00 movl $0x77,0x30(%eax) req->aiocbp->return_value = 0; 10af74: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) if ((aio_request_queue.idle_threads == 0) && 10af7b: 83 c4 10 add $0x10,%esp 10af7e: 83 3d e0 72 12 00 00 cmpl $0x0,0x1272e0 10af85: 0f 85 b7 00 00 00 jne 10b042 10af8b: 83 3d dc 72 12 00 04 cmpl $0x4,0x1272dc 10af92: 0f 8f aa 00 00 00 jg 10b042 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); 10af98: 56 push %esi 10af99: 6a 01 push $0x1 10af9b: ff 30 pushl (%eax) 10af9d: 68 c0 72 12 00 push $0x1272c0 10afa2: e8 99 fb ff ff call 10ab40 10afa7: 89 c6 mov %eax,%esi if (r_chain->new_fd == 1) { 10afa9: 83 c4 10 add $0x10,%esp 10afac: 83 78 18 01 cmpl $0x1,0x18(%eax) 10afb0: 8d 50 08 lea 0x8(%eax),%edx 10afb3: 8d 78 1c lea 0x1c(%eax),%edi 10afb6: 8d 40 20 lea 0x20(%eax),%eax 10afb9: 89 45 b0 mov %eax,-0x50(%ebp) 10afbc: 75 66 jne 10b024 RTEMS_INLINE_ROUTINE void _Chain_Prepend( Chain_Control *the_chain, Chain_Node *the_node ) { _Chain_Insert(_Chain_Head(the_chain), the_node); 10afbe: 51 push %ecx 10afbf: 51 push %ecx 10afc0: 53 push %ebx 10afc1: 52 push %edx 10afc2: e8 b5 1f 00 00 call 10cf7c <_Chain_Insert> rtems_chain_prepend (&r_chain->perfd, &req->next_prio); r_chain->new_fd = 0; 10afc7: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) pthread_mutex_init (&r_chain->mutex, NULL); 10afce: 5b pop %ebx 10afcf: 58 pop %eax 10afd0: 6a 00 push $0x0 10afd2: 57 push %edi 10afd3: e8 ec 06 00 00 call 10b6c4 pthread_cond_init (&r_chain->cond, NULL); 10afd8: 5a pop %edx 10afd9: 59 pop %ecx 10afda: 6a 00 push $0x0 10afdc: ff 75 b0 pushl -0x50(%ebp) 10afdf: e8 a0 03 00 00 call 10b384 AIO_printf ("New thread \n"); result = pthread_create (&thid, &aio_request_queue.attr, 10afe4: 56 push %esi 10afe5: 68 eb ab 10 00 push $0x10abeb 10afea: 68 80 72 12 00 push $0x127280 10afef: 8d 45 e4 lea -0x1c(%ebp),%eax 10aff2: 50 push %eax 10aff3: e8 bc 09 00 00 call 10b9b4 10aff8: 89 c3 mov %eax,%ebx rtems_aio_handle, (void *) r_chain); if (result != 0) { 10affa: 83 c4 20 add $0x20,%esp 10affd: 85 c0 test %eax,%eax 10afff: 74 18 je 10b019 <== ALWAYS TAKEN pthread_mutex_unlock (&aio_request_queue.mutex); 10b001: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b004: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10b009: e8 56 08 00 00 call 10b864 <== NOT EXECUTED return result; 10b00e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b011: 89 5d b4 mov %ebx,-0x4c(%ebp) <== NOT EXECUTED 10b014: e9 e8 00 00 00 jmp 10b101 <== NOT EXECUTED } ++aio_request_queue.active_threads; 10b019: ff 05 dc 72 12 00 incl 0x1272dc 10b01f: e9 cd 00 00 00 jmp 10b0f1 } else { /* put request in the fd chain it belongs to */ pthread_mutex_lock (&r_chain->mutex); 10b024: 83 ec 0c sub $0xc,%esp 10b027: 57 push %edi 10b028: 89 55 ac mov %edx,-0x54(%ebp) 10b02b: e8 b4 07 00 00 call 10b7e4 rtems_aio_insert_prio (&r_chain->perfd, req); 10b030: 5e pop %esi 10b031: 58 pop %eax 10b032: 53 push %ebx 10b033: 8b 55 ac mov -0x54(%ebp),%edx 10b036: 52 push %edx 10b037: e8 00 fe ff ff call 10ae3c pthread_cond_signal (&r_chain->cond); 10b03c: 5b pop %ebx 10b03d: ff 75 b0 pushl -0x50(%ebp) 10b040: eb 36 jmp 10b078 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, 10b042: 51 push %ecx 10b043: 6a 00 push $0x0 10b045: ff 30 pushl (%eax) 10b047: 68 c0 72 12 00 push $0x1272c0 10b04c: e8 ef fa ff ff call 10ab40 10b051: 89 c6 mov %eax,%esi req->aiocbp->aio_fildes, 0); if (r_chain != NULL) 10b053: 83 c4 10 add $0x10,%esp 10b056: 85 c0 test %eax,%eax 10b058: 74 2d je 10b087 <== ALWAYS TAKEN { pthread_mutex_lock (&r_chain->mutex); 10b05a: 8d 78 1c lea 0x1c(%eax),%edi <== NOT EXECUTED 10b05d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b060: 57 push %edi <== NOT EXECUTED 10b061: e8 7e 07 00 00 call 10b7e4 <== NOT EXECUTED rtems_aio_insert_prio (&r_chain->perfd, req); 10b066: 58 pop %eax <== NOT EXECUTED 10b067: 5a pop %edx <== NOT EXECUTED 10b068: 53 push %ebx <== NOT EXECUTED 10b069: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED 10b06c: 50 push %eax <== NOT EXECUTED 10b06d: e8 ca fd ff ff call 10ae3c <== NOT EXECUTED pthread_cond_signal (&r_chain->cond); 10b072: 83 c6 20 add $0x20,%esi <== NOT EXECUTED 10b075: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10b078: e8 a3 03 00 00 call 10b420 pthread_mutex_unlock (&r_chain->mutex); 10b07d: 89 3c 24 mov %edi,(%esp) 10b080: e8 df 07 00 00 call 10b864 10b085: eb 67 jmp 10b0ee } else { /* or to the idle chain */ chain = &aio_request_queue.idle_req; r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1); 10b087: 56 push %esi 10b088: 6a 01 push $0x1 10b08a: 8b 43 14 mov 0x14(%ebx),%eax 10b08d: ff 30 pushl (%eax) 10b08f: 68 cc 72 12 00 push $0x1272cc 10b094: e8 a7 fa ff ff call 10ab40 10b099: 89 c6 mov %eax,%esi if (r_chain->new_fd == 1) { 10b09b: 83 c4 10 add $0x10,%esp 10b09e: 83 78 18 01 cmpl $0x1,0x18(%eax) 10b0a2: 8d 40 08 lea 0x8(%eax),%eax 10b0a5: 75 3e jne 10b0e5 10b0a7: 51 push %ecx 10b0a8: 51 push %ecx 10b0a9: 53 push %ebx 10b0aa: 50 push %eax 10b0ab: e8 cc 1e 00 00 call 10cf7c <_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; 10b0b0: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) pthread_mutex_init (&r_chain->mutex, NULL); 10b0b7: 58 pop %eax 10b0b8: 5a pop %edx 10b0b9: 6a 00 push $0x0 10b0bb: 8d 46 1c lea 0x1c(%esi),%eax 10b0be: 50 push %eax 10b0bf: e8 00 06 00 00 call 10b6c4 pthread_cond_init (&r_chain->cond, NULL); 10b0c4: 5b pop %ebx 10b0c5: 5f pop %edi 10b0c6: 6a 00 push $0x0 10b0c8: 83 c6 20 add $0x20,%esi 10b0cb: 56 push %esi 10b0cc: e8 b3 02 00 00 call 10b384 pthread_cond_signal (&aio_request_queue.new_req); 10b0d1: c7 04 24 7c 72 12 00 movl $0x12727c,(%esp) 10b0d8: e8 43 03 00 00 call 10b420 ++aio_request_queue.idle_threads; 10b0dd: ff 05 e0 72 12 00 incl 0x1272e0 10b0e3: eb 09 jmp 10b0ee } else /* just insert the request in the existing fd chain */ rtems_aio_insert_prio (&r_chain->perfd, req); 10b0e5: 51 push %ecx 10b0e6: 51 push %ecx 10b0e7: 53 push %ebx 10b0e8: 50 push %eax 10b0e9: e8 4e fd ff ff call 10ae3c 10b0ee: 83 c4 10 add $0x10,%esp } } pthread_mutex_unlock (&aio_request_queue.mutex); 10b0f1: 83 ec 0c sub $0xc,%esp 10b0f4: 68 78 72 12 00 push $0x127278 10b0f9: e8 66 07 00 00 call 10b864 return 0; 10b0fe: 83 c4 10 add $0x10,%esp } 10b101: 8b 45 b4 mov -0x4c(%ebp),%eax 10b104: 8d 65 f4 lea -0xc(%ebp),%esp 10b107: 5b pop %ebx 10b108: 5e pop %esi 10b109: 5f pop %edi 10b10a: c9 leave 10b10b: c3 ret =============================================================================== 0010abeb : * NULL - if error */ static void * rtems_aio_handle (void *arg) { 10abeb: 55 push %ebp <== NOT EXECUTED 10abec: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10abee: 57 push %edi <== NOT EXECUTED 10abef: 56 push %esi <== NOT EXECUTED 10abf0: 53 push %ebx <== NOT EXECUTED 10abf1: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED rtems_aio_request_chain *r_chain = arg; 10abf4: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* acquire the mutex of the current fd chain. we don't need to lock the queue mutex since we can add requests to idle fd chains or even active ones if the working request has been extracted from the chain */ result = pthread_mutex_lock (&r_chain->mutex); 10abf7: 8d 7b 1c lea 0x1c(%ebx),%edi <== NOT EXECUTED 10abfa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10abfd: 57 push %edi <== NOT EXECUTED 10abfe: e8 e1 0b 00 00 call 10b7e4 <== NOT EXECUTED if (result != 0) 10ac03: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac06: 85 c0 test %eax,%eax <== NOT EXECUTED 10ac08: 0f 85 24 02 00 00 jne 10ae32 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 10ac0e: 8b 73 08 mov 0x8(%ebx),%esi <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10ac11: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED /* If the locked chain is not empty, take the first request extract it, unlock the chain and process the request, in this way the user can supply more requests to this fd chain */ if (!rtems_chain_is_empty (chain)) { 10ac14: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10ac16: 0f 84 cc 00 00 00 je 10ace8 <== NOT EXECUTED node = rtems_chain_first (chain); req = (rtems_aio_request *) node; /* See _POSIX_PRIORITIZE_IO and _POSIX_PRIORITY_SCHEDULING discussion in rtems_aio_enqueue () */ pthread_getschedparam (pthread_self(), &policy, ¶m); 10ac1c: e8 c3 13 00 00 call 10bfe4 <== NOT EXECUTED 10ac21: 52 push %edx <== NOT EXECUTED 10ac22: 8d 55 c0 lea -0x40(%ebp),%edx <== NOT EXECUTED 10ac25: 52 push %edx <== NOT EXECUTED 10ac26: 8d 4d e4 lea -0x1c(%ebp),%ecx <== NOT EXECUTED 10ac29: 51 push %ecx <== NOT EXECUTED 10ac2a: 50 push %eax <== NOT EXECUTED 10ac2b: e8 b8 0f 00 00 call 10bbe8 <== NOT EXECUTED param.sched_priority = req->priority; 10ac30: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 10ac33: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED pthread_setschedparam (pthread_self(), req->policy, ¶m); 10ac36: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED 10ac39: 89 55 b4 mov %edx,-0x4c(%ebp) <== NOT EXECUTED 10ac3c: e8 a3 13 00 00 call 10bfe4 <== NOT EXECUTED 10ac41: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ac44: 8d 4d c0 lea -0x40(%ebp),%ecx <== NOT EXECUTED 10ac47: 51 push %ecx <== NOT EXECUTED 10ac48: 8b 55 b4 mov -0x4c(%ebp),%edx <== NOT EXECUTED 10ac4b: 52 push %edx <== NOT EXECUTED 10ac4c: 50 push %eax <== NOT EXECUTED 10ac4d: e8 a2 13 00 00 call 10bff4 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10ac52: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10ac55: e8 e6 22 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract (node); pthread_mutex_unlock (&r_chain->mutex); 10ac5a: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10ac5d: e8 02 0c 00 00 call 10b864 <== NOT EXECUTED switch (req->aiocbp->aio_lio_opcode) { 10ac62: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED 10ac65: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac68: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED 10ac6b: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 10ac6e: 74 20 je 10ac90 <== NOT EXECUTED 10ac70: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 10ac73: 74 36 je 10acab <== NOT EXECUTED 10ac75: 4a dec %edx <== NOT EXECUTED 10ac76: 75 45 jne 10acbd <== NOT EXECUTED case LIO_READ: result = pread (req->aiocbp->aio_fildes, 10ac78: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac7b: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10ac7e: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED 10ac81: ff 70 10 pushl 0x10(%eax) <== NOT EXECUTED 10ac84: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10ac87: ff 30 pushl (%eax) <== NOT EXECUTED 10ac89: e8 ea 93 00 00 call 114078 <== NOT EXECUTED 10ac8e: eb 16 jmp 10aca6 <== NOT EXECUTED (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; case LIO_WRITE: result = pwrite (req->aiocbp->aio_fildes, 10ac90: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac93: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10ac96: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED 10ac99: ff 70 10 pushl 0x10(%eax) <== NOT EXECUTED 10ac9c: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10ac9f: ff 30 pushl (%eax) <== NOT EXECUTED 10aca1: e8 8a 94 00 00 call 114130 <== NOT EXECUTED (void *) req->aiocbp->aio_buf, req->aiocbp->aio_nbytes, req->aiocbp->aio_offset); break; 10aca6: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10aca9: eb 0d jmp 10acb8 <== NOT EXECUTED case LIO_SYNC: result = fsync (req->aiocbp->aio_fildes); 10acab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10acae: ff 30 pushl (%eax) <== NOT EXECUTED 10acb0: e8 27 5c 00 00 call 1108dc <== NOT EXECUTED break; 10acb5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED default: result = -1; } if (result == -1) { 10acb8: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10acbb: 75 19 jne 10acd6 <== NOT EXECUTED req->aiocbp->return_value = -1; 10acbd: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED 10acc0: c7 46 34 ff ff ff ff movl $0xffffffff,0x34(%esi) <== NOT EXECUTED req->aiocbp->error_code = errno; 10acc7: e8 70 89 00 00 call 11363c <__errno> <== NOT EXECUTED 10accc: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10acce: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED 10acd1: e9 21 ff ff ff jmp 10abf7 <== NOT EXECUTED } else { req->aiocbp->return_value = result; 10acd6: 8b 56 14 mov 0x14(%esi),%edx <== NOT EXECUTED 10acd9: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED req->aiocbp->error_code = 0; 10acdc: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED 10ace3: e9 0f ff ff ff jmp 10abf7 <== NOT EXECUTED wait for a signal on chain, this will unlock the queue. The fd chain is already unlocked */ struct timespec timeout; pthread_mutex_unlock (&r_chain->mutex); 10ace8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aceb: 57 push %edi <== NOT EXECUTED 10acec: e8 73 0b 00 00 call 10b864 <== NOT EXECUTED pthread_mutex_lock (&aio_request_queue.mutex); 10acf1: c7 04 24 78 72 12 00 movl $0x127278,(%esp) <== NOT EXECUTED 10acf8: e8 e7 0a 00 00 call 10b7e4 <== NOT EXECUTED if (rtems_chain_is_empty (chain)) 10acfd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad00: 39 73 08 cmp %esi,0x8(%ebx) <== NOT EXECUTED 10ad03: 0f 85 ee fe ff ff jne 10abf7 <== NOT EXECUTED { clock_gettime (CLOCK_REALTIME, &timeout); 10ad09: 56 push %esi <== NOT EXECUTED 10ad0a: 56 push %esi <== NOT EXECUTED 10ad0b: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 10ad0e: 50 push %eax <== NOT EXECUTED 10ad0f: 6a 01 push $0x1 <== NOT EXECUTED 10ad11: e8 5e 05 00 00 call 10b274 <== NOT EXECUTED timeout.tv_sec += 3; 10ad16: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED timeout.tv_nsec = 0; 10ad1a: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED result = pthread_cond_timedwait (&r_chain->cond, 10ad21: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED 10ad24: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ad27: 8d 55 dc lea -0x24(%ebp),%edx <== NOT EXECUTED 10ad2a: 52 push %edx <== NOT EXECUTED 10ad2b: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10ad30: 56 push %esi <== NOT EXECUTED 10ad31: e8 5a 07 00 00 call 10b490 <== NOT EXECUTED &aio_request_queue.mutex, &timeout); /* If no requests were added to the chain we delete the fd chain from the queue and start working with idle fd chains */ if (result == ETIMEDOUT) { 10ad36: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad39: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED 10ad3c: 0f 85 b5 fe ff ff jne 10abf7 <== NOT EXECUTED 10ad42: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad45: 53 push %ebx <== NOT EXECUTED 10ad46: e8 f5 21 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract (&r_chain->next_fd); pthread_mutex_destroy (&r_chain->mutex); 10ad4b: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10ad4e: e8 71 08 00 00 call 10b5c4 <== NOT EXECUTED pthread_cond_destroy (&r_chain->cond); 10ad53: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10ad56: e8 75 05 00 00 call 10b2d0 <== NOT EXECUTED free (r_chain); 10ad5b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10ad5e: e8 dd cf ff ff call 107d40 <== NOT EXECUTED /* If the idle chain is empty sleep for 3 seconds and wait for a signal. The thread now becomes idle. */ if (rtems_chain_is_empty (&aio_request_queue.idle_req)) { 10ad63: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad66: 81 3d cc 72 12 00 d0 cmpl $0x1272d0,0x1272cc <== NOT EXECUTED 10ad6d: 72 12 00 10ad70: 0f 85 a7 00 00 00 jne 10ae1d <== NOT EXECUTED ++aio_request_queue.idle_threads; 10ad76: ff 05 e0 72 12 00 incl 0x1272e0 <== NOT EXECUTED clock_gettime (CLOCK_REALTIME, &timeout); 10ad7c: 53 push %ebx <== NOT EXECUTED 10ad7d: 53 push %ebx <== NOT EXECUTED 10ad7e: 8d 4d dc lea -0x24(%ebp),%ecx <== NOT EXECUTED 10ad81: 51 push %ecx <== NOT EXECUTED 10ad82: 6a 01 push $0x1 <== NOT EXECUTED 10ad84: e8 eb 04 00 00 call 10b274 <== NOT EXECUTED timeout.tv_sec += 3; 10ad89: 83 45 dc 03 addl $0x3,-0x24(%ebp) <== NOT EXECUTED timeout.tv_nsec = 0; 10ad8d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED result = pthread_cond_timedwait (&aio_request_queue.new_req, 10ad94: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ad97: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 10ad9a: 50 push %eax <== NOT EXECUTED 10ad9b: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10ada0: 68 7c 72 12 00 push $0x12727c <== NOT EXECUTED 10ada5: e8 e6 06 00 00 call 10b490 <== NOT EXECUTED &aio_request_queue.mutex, &timeout); /* If no new fd chain was added in the idle requests then this thread is finished */ if (result == ETIMEDOUT) { 10adaa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10adad: 83 f8 74 cmp $0x74,%eax <== NOT EXECUTED 10adb0: 75 12 jne 10adc4 <== NOT EXECUTED pthread_mutex_unlock (&aio_request_queue.mutex); 10adb2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10adb5: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10adba: e8 a5 0a 00 00 call 10b864 <== NOT EXECUTED return NULL; 10adbf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10adc2: eb 6e jmp 10ae32 <== NOT EXECUTED } /* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads; 10adc4: ff 0d e0 72 12 00 decl 0x1272e0 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10adca: 8b 35 cc 72 12 00 mov 0x1272cc,%esi <== NOT EXECUTED 10add0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10add3: 56 push %esi <== NOT EXECUTED 10add4: e8 67 21 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED /* Otherwise move this chain to the working chain and start the loop all over again */ --aio_request_queue.idle_threads; node = rtems_chain_first (&aio_request_queue.idle_req); rtems_chain_extract (node); r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, 10add9: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10addc: 6a 01 push $0x1 <== NOT EXECUTED 10adde: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 10ade1: 68 c0 72 12 00 push $0x1272c0 <== NOT EXECUTED 10ade6: e8 55 fd ff ff call 10ab40 <== NOT EXECUTED 10adeb: 89 c3 mov %eax,%ebx <== NOT EXECUTED ((rtems_aio_request_chain *)node)->fildes, 1); r_chain->new_fd = 0; 10aded: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED pthread_mutex_init (&r_chain->mutex, NULL); 10adf4: 5a pop %edx <== NOT EXECUTED 10adf5: 59 pop %ecx <== NOT EXECUTED 10adf6: 6a 00 push $0x0 <== NOT EXECUTED 10adf8: 8d 40 1c lea 0x1c(%eax),%eax <== NOT EXECUTED 10adfb: 50 push %eax <== NOT EXECUTED 10adfc: e8 c3 08 00 00 call 10b6c4 <== NOT EXECUTED pthread_cond_init (&r_chain->cond, NULL); 10ae01: 5f pop %edi <== NOT EXECUTED 10ae02: 58 pop %eax <== NOT EXECUTED 10ae03: 6a 00 push $0x0 <== NOT EXECUTED 10ae05: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED 10ae08: 50 push %eax <== NOT EXECUTED 10ae09: e8 76 05 00 00 call 10b384 <== NOT EXECUTED r_chain->perfd = ((rtems_aio_request_chain *)node)->perfd; 10ae0e: 8d 7b 08 lea 0x8(%ebx),%edi <== NOT EXECUTED 10ae11: 83 c6 08 add $0x8,%esi <== NOT EXECUTED 10ae14: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 10ae19: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10ae1b: eb 0d jmp 10ae2a <== NOT EXECUTED } else /* If there was a request added in the initial fd chain then release the mutex and process it */ pthread_mutex_unlock (&aio_request_queue.mutex); 10ae1d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae20: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10ae25: e8 3a 0a 00 00 call 10b864 <== NOT EXECUTED 10ae2a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae2d: e9 c5 fd ff ff jmp 10abf7 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10ae32: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ae34: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ae37: 5b pop %ebx <== NOT EXECUTED 10ae38: 5e pop %esi <== NOT EXECUTED 10ae39: 5f pop %edi <== NOT EXECUTED 10ae3a: c9 leave <== NOT EXECUTED 10ae3b: c3 ret <== NOT EXECUTED =============================================================================== 0010aa44 : * 0 - if initialization succeeded */ int rtems_aio_init (void) { 10aa44: 55 push %ebp 10aa45: 89 e5 mov %esp,%ebp 10aa47: 53 push %ebx 10aa48: 83 ec 10 sub $0x10,%esp int result = 0; result = pthread_attr_init (&aio_request_queue.attr); 10aa4b: 68 80 72 12 00 push $0x127280 10aa50: e8 13 0f 00 00 call 10b968 10aa55: 89 c3 mov %eax,%ebx if (result != 0) 10aa57: 83 c4 10 add $0x10,%esp 10aa5a: 85 c0 test %eax,%eax 10aa5c: 0f 85 d7 00 00 00 jne 10ab39 <== NEVER TAKEN return result; result = 10aa62: 51 push %ecx 10aa63: 51 push %ecx 10aa64: 6a 00 push $0x0 10aa66: 68 80 72 12 00 push $0x127280 10aa6b: e8 20 0f 00 00 call 10b990 pthread_attr_setdetachstate (&aio_request_queue.attr, PTHREAD_CREATE_DETACHED); if (result != 0) 10aa70: 83 c4 10 add $0x10,%esp 10aa73: 85 c0 test %eax,%eax 10aa75: 74 10 je 10aa87 <== ALWAYS TAKEN pthread_attr_destroy (&aio_request_queue.attr); 10aa77: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa7a: 68 80 72 12 00 push $0x127280 <== NOT EXECUTED 10aa7f: e8 c4 0e 00 00 call 10b948 <== NOT EXECUTED 10aa84: 83 c4 10 add $0x10,%esp <== NOT EXECUTED result = pthread_mutex_init (&aio_request_queue.mutex, NULL); 10aa87: 52 push %edx 10aa88: 52 push %edx 10aa89: 6a 00 push $0x0 10aa8b: 68 78 72 12 00 push $0x127278 10aa90: e8 2f 0c 00 00 call 10b6c4 if (result != 0) 10aa95: 83 c4 10 add $0x10,%esp 10aa98: 85 c0 test %eax,%eax 10aa9a: 74 10 je 10aaac <== ALWAYS TAKEN pthread_attr_destroy (&aio_request_queue.attr); 10aa9c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa9f: 68 80 72 12 00 push $0x127280 <== NOT EXECUTED 10aaa4: e8 9f 0e 00 00 call 10b948 <== NOT EXECUTED 10aaa9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED result = pthread_cond_init (&aio_request_queue.new_req, NULL); 10aaac: 50 push %eax 10aaad: 50 push %eax 10aaae: 6a 00 push $0x0 10aab0: 68 7c 72 12 00 push $0x12727c 10aab5: e8 ca 08 00 00 call 10b384 10aaba: 89 c3 mov %eax,%ebx if (result != 0) { 10aabc: 83 c4 10 add $0x10,%esp 10aabf: 85 c0 test %eax,%eax 10aac1: 74 1c je 10aadf <== ALWAYS TAKEN pthread_mutex_destroy (&aio_request_queue.mutex); 10aac3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aac6: 68 78 72 12 00 push $0x127278 <== NOT EXECUTED 10aacb: e8 f4 0a 00 00 call 10b5c4 <== NOT EXECUTED pthread_attr_destroy (&aio_request_queue.attr); 10aad0: c7 04 24 80 72 12 00 movl $0x127280,(%esp) <== NOT EXECUTED 10aad7: e8 6c 0e 00 00 call 10b948 <== NOT EXECUTED 10aadc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 10aadf: c7 05 c0 72 12 00 c4 movl $0x1272c4,0x1272c0 10aae6: 72 12 00 the_chain->permanent_null = NULL; 10aae9: c7 05 c4 72 12 00 00 movl $0x0,0x1272c4 10aaf0: 00 00 00 the_chain->last = _Chain_Head(the_chain); 10aaf3: c7 05 c8 72 12 00 c0 movl $0x1272c0,0x1272c8 10aafa: 72 12 00 */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 10aafd: c7 05 cc 72 12 00 d0 movl $0x1272d0,0x1272cc 10ab04: 72 12 00 the_chain->permanent_null = NULL; 10ab07: c7 05 d0 72 12 00 00 movl $0x0,0x1272d0 10ab0e: 00 00 00 the_chain->last = _Chain_Head(the_chain); 10ab11: c7 05 d4 72 12 00 cc movl $0x1272cc,0x1272d4 10ab18: 72 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; 10ab1b: c7 05 dc 72 12 00 00 movl $0x0,0x1272dc 10ab22: 00 00 00 aio_request_queue.idle_threads = 0; 10ab25: c7 05 e0 72 12 00 00 movl $0x0,0x1272e0 10ab2c: 00 00 00 aio_request_queue.initialized = AIO_QUEUE_INITIALIZED; 10ab2f: c7 05 d8 72 12 00 0b movl $0xb00b,0x1272d8 10ab36: b0 00 00 return result; } 10ab39: 89 d8 mov %ebx,%eax 10ab3b: 8b 5d fc mov -0x4(%ebp),%ebx 10ab3e: c9 leave 10ab3f: c3 ret =============================================================================== 0010ae3c : * NONE */ void rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req) { 10ae3c: 55 push %ebp 10ae3d: 89 e5 mov %esp,%ebp 10ae3f: 56 push %esi 10ae40: 53 push %ebx 10ae41: 8b 4d 08 mov 0x8(%ebp),%ecx 10ae44: 8b 55 0c mov 0xc(%ebp),%edx } AIO_printf ("Thread finished\n"); return NULL; } 10ae47: 8b 01 mov (%ecx),%eax 10ae49: 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)) { 10ae4c: 39 d8 cmp %ebx,%eax 10ae4e: 74 27 je 10ae77 <== 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; 10ae50: 8b 48 14 mov 0x14(%eax),%ecx 10ae53: 8b 49 14 mov 0x14(%ecx),%ecx while (req->aiocbp->aio_reqprio > prio && 10ae56: 8b 72 14 mov 0x14(%edx),%esi 10ae59: 8b 76 14 mov 0x14(%esi),%esi 10ae5c: eb 08 jmp 10ae66 } AIO_printf ("Thread finished\n"); return NULL; } 10ae5e: 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; 10ae60: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED 10ae63: 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 && 10ae66: 39 ce cmp %ecx,%esi 10ae68: 7e 04 jle 10ae6e <== ALWAYS TAKEN 10ae6a: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10ae6c: 75 f0 jne 10ae5e <== 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 ); 10ae6e: 89 55 0c mov %edx,0xc(%ebp) 10ae71: 8b 40 04 mov 0x4(%eax),%eax 10ae74: 89 45 08 mov %eax,0x8(%ebp) } rtems_chain_insert (node->previous, &req->next_prio); } } 10ae77: 5b pop %ebx 10ae78: 5e pop %esi 10ae79: c9 leave 10ae7a: e9 fd 20 00 00 jmp 10cf7c <_Chain_Insert> =============================================================================== 0010ae7f : * Output parameters: * NONE */ void rtems_aio_remove_fd (rtems_aio_request_chain *r_chain) { 10ae7f: 55 push %ebp <== NOT EXECUTED 10ae80: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae82: 56 push %esi <== NOT EXECUTED 10ae83: 53 push %ebx <== NOT EXECUTED 10ae84: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10ae87: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED 10ae8a: 8d 70 0c lea 0xc(%eax),%esi <== NOT EXECUTED rtems_chain_node *node; chain = &r_chain->perfd; node = rtems_chain_first (chain); while (!rtems_chain_is_tail (chain, node)) 10ae8d: eb 25 jmp 10aeb4 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10ae8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae92: 53 push %ebx <== NOT EXECUTED 10ae93: e8 a8 20 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED { rtems_chain_extract (node); rtems_aio_request *req = (rtems_aio_request *) node; req->aiocbp->error_code = ECANCELED; 10ae98: 8b 53 14 mov 0x14(%ebx),%edx <== NOT EXECUTED 10ae9b: c7 42 30 8c 00 00 00 movl $0x8c,0x30(%edx) <== NOT EXECUTED req->aiocbp->return_value = -1; 10aea2: c7 42 34 ff ff ff ff movl $0xffffffff,0x34(%edx) <== NOT EXECUTED free (req); 10aea9: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10aeac: e8 8f ce ff ff call 107d40 <== NOT EXECUTED 10aeb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_chain_node *node; chain = &r_chain->perfd; node = rtems_chain_first (chain); while (!rtems_chain_is_tail (chain, node)) 10aeb4: 39 f3 cmp %esi,%ebx <== NOT EXECUTED 10aeb6: 75 d7 jne 10ae8f <== NOT EXECUTED rtems_aio_request *req = (rtems_aio_request *) node; req->aiocbp->error_code = ECANCELED; req->aiocbp->return_value = -1; free (req); } } 10aeb8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10aebb: 5b pop %ebx <== NOT EXECUTED 10aebc: 5e pop %esi <== NOT EXECUTED 10aebd: c9 leave <== NOT EXECUTED 10aebe: c3 ret <== NOT EXECUTED =============================================================================== 0010aebf : * 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) { 10aebf: 55 push %ebp <== NOT EXECUTED 10aec0: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aec2: 53 push %ebx <== NOT EXECUTED 10aec3: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10aec6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10aec9: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10aecc: 8b 18 mov (%eax),%ebx <== NOT EXECUTED 10aece: 83 c0 04 add $0x4,%eax <== NOT EXECUTED rtems_chain_node *node = rtems_chain_first (chain); rtems_aio_request *current; current = (rtems_aio_request *) node; while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) { 10aed1: eb 02 jmp 10aed5 <== NOT EXECUTED } AIO_printf ("Thread finished\n"); return NULL; } 10aed3: 8b 1b mov (%ebx),%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) { 10aed5: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10aed7: 74 2e je 10af07 <== NOT EXECUTED 10aed9: 39 53 14 cmp %edx,0x14(%ebx) <== NOT EXECUTED 10aedc: 75 f5 jne 10aed3 <== NOT EXECUTED 10aede: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aee1: 53 push %ebx <== NOT EXECUTED 10aee2: e8 59 20 00 00 call 10cf40 <_Chain_Extract> <== NOT EXECUTED if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; else { rtems_chain_extract (node); current->aiocbp->error_code = ECANCELED; 10aee7: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10aeea: c7 40 30 8c 00 00 00 movl $0x8c,0x30(%eax) <== NOT EXECUTED current->aiocbp->return_value = -1; 10aef1: c7 40 34 ff ff ff ff movl $0xffffffff,0x34(%eax) <== NOT EXECUTED free (current); 10aef8: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10aefb: e8 40 ce ff ff call 107d40 <== NOT EXECUTED } return AIO_CANCELED; 10af00: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af03: 31 c0 xor %eax,%eax <== NOT EXECUTED 10af05: eb 05 jmp 10af0c <== NOT EXECUTED node = rtems_chain_next (node); current = (rtems_aio_request *) node; } if (rtems_chain_is_tail (chain, node)) return AIO_NOTCANCELED; 10af07: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED current->aiocbp->return_value = -1; free (current); } return AIO_CANCELED; } 10af0c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10af0f: c9 leave <== NOT EXECUTED 10af10: c3 ret <== NOT EXECUTED =============================================================================== 0010aaa8 : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10aaa8: 55 push %ebp 10aaa9: 89 e5 mov %esp,%ebp 10aaab: 56 push %esi 10aaac: 53 push %ebx 10aaad: 8b 5d 10 mov 0x10(%ebp),%ebx 10aab0: 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 ); 10aab3: 50 push %eax 10aab4: 50 push %eax 10aab5: ff 75 0c pushl 0xc(%ebp) 10aab8: ff 75 08 pushl 0x8(%ebp) 10aabb: e8 88 04 00 00 call 10af48 <_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 ) { 10aac0: 83 c4 10 add $0x10,%esp 10aac3: 84 c0 test %al,%al 10aac5: 74 11 je 10aad8 <== NEVER TAKEN sc = rtems_event_send( task, events ); 10aac7: 89 75 0c mov %esi,0xc(%ebp) 10aaca: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10aacd: 8d 65 f8 lea -0x8(%ebp),%esp 10aad0: 5b pop %ebx 10aad1: 5e pop %esi 10aad2: 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 ); 10aad3: e9 d4 f6 ff ff jmp 10a1ac } return sc; } 10aad8: 31 c0 xor %eax,%eax 10aada: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10aadd: 5b pop %ebx <== NOT EXECUTED 10aade: 5e pop %esi <== NOT EXECUTED 10aadf: c9 leave <== NOT EXECUTED 10aae0: c3 ret <== NOT EXECUTED =============================================================================== 0010ab20 : rtems_chain_control *chain, rtems_event_set events, rtems_interval timeout, rtems_chain_node **node_ptr ) { 10ab20: 55 push %ebp 10ab21: 89 e5 mov %esp,%ebp 10ab23: 57 push %edi 10ab24: 56 push %esi 10ab25: 53 push %ebx 10ab26: 83 ec 1c sub $0x1c,%esp 10ab29: 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( 10ab2c: 8d 75 e4 lea -0x1c(%ebp),%esi 10ab2f: eb 13 jmp 10ab44 10ab31: 56 push %esi 10ab32: ff 75 10 pushl 0x10(%ebp) 10ab35: 6a 00 push $0x0 10ab37: 57 push %edi 10ab38: e8 0f f5 ff ff call 10a04c ) { rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_chain_node *node = NULL; while ( 10ab3d: 83 c4 10 add $0x10,%esp 10ab40: 85 c0 test %eax,%eax 10ab42: 75 16 jne 10ab5a <== ALWAYS TAKEN */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 10ab44: 83 ec 0c sub $0xc,%esp 10ab47: ff 75 08 pushl 0x8(%ebp) 10ab4a: e8 99 04 00 00 call 10afe8 <_Chain_Get> 10ab4f: 89 c3 mov %eax,%ebx sc == RTEMS_SUCCESSFUL && (node = rtems_chain_get( chain )) == NULL 10ab51: 83 c4 10 add $0x10,%esp 10ab54: 85 c0 test %eax,%eax 10ab56: 74 d9 je 10ab31 10ab58: 31 c0 xor %eax,%eax timeout, &out ); } *node_ptr = node; 10ab5a: 8b 55 14 mov 0x14(%ebp),%edx 10ab5d: 89 1a mov %ebx,(%edx) return sc; } 10ab5f: 8d 65 f4 lea -0xc(%ebp),%esp 10ab62: 5b pop %ebx 10ab63: 5e pop %esi 10ab64: 5f pop %edi 10ab65: c9 leave 10ab66: c3 ret =============================================================================== 0010ab68 : rtems_chain_control *chain, rtems_chain_node *node, rtems_id task, rtems_event_set events ) { 10ab68: 55 push %ebp 10ab69: 89 e5 mov %esp,%ebp 10ab6b: 56 push %esi 10ab6c: 53 push %ebx 10ab6d: 8b 5d 10 mov 0x10(%ebp),%ebx 10ab70: 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 ); 10ab73: 50 push %eax 10ab74: 50 push %eax 10ab75: ff 75 0c pushl 0xc(%ebp) 10ab78: ff 75 08 pushl 0x8(%ebp) 10ab7b: e8 ac 04 00 00 call 10b02c <_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) { 10ab80: 83 c4 10 add $0x10,%esp 10ab83: 84 c0 test %al,%al 10ab85: 74 11 je 10ab98 <== NEVER TAKEN sc = rtems_event_send( task, events ); 10ab87: 89 75 0c mov %esi,0xc(%ebp) 10ab8a: 89 5d 08 mov %ebx,0x8(%ebp) } return sc; } 10ab8d: 8d 65 f8 lea -0x8(%ebp),%esp 10ab90: 5b pop %ebx 10ab91: 5e pop %esi 10ab92: 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 ); 10ab93: e9 14 f6 ff ff jmp 10a1ac } return sc; } 10ab98: 31 c0 xor %eax,%eax 10ab9a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ab9d: 5b pop %ebx <== NOT EXECUTED 10ab9e: 5e pop %esi <== NOT EXECUTED 10ab9f: c9 leave <== NOT EXECUTED 10aba0: c3 ret <== NOT EXECUTED =============================================================================== 001076a8 : void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) { 1076a8: 55 push %ebp 1076a9: 89 e5 mov %esp,%ebp 1076ab: 57 push %edi 1076ac: 56 push %esi 1076ad: 53 push %ebx 1076ae: 83 ec 6c sub $0x6c,%esp 1076b1: 8b 7d 08 mov 0x8(%ebp),%edi Timestamp_Control uptime, total, ran; #else uint32_t total_units = 0; #endif if ( !print ) 1076b4: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 1076b8: 0f 84 44 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__ _TOD_Get_uptime( &uptime ); 1076be: 83 ec 0c sub $0xc,%esp 1076c1: 8d 5d d8 lea -0x28(%ebp),%ebx 1076c4: 53 push %ebx 1076c5: e8 6e 4b 00 00 call 10c238 <_TOD_Get_uptime> _Timestamp_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total ); 1076ca: 83 c4 0c add $0xc,%esp 1076cd: 8d 75 d0 lea -0x30(%ebp),%esi 1076d0: 56 push %esi 1076d1: 53 push %ebx 1076d2: 68 a8 06 13 00 push $0x1306a8 1076d7: e8 2c 6b 00 00 call 10e208 <_Timespec_Subtract> } } } #endif (*print)( 1076dc: 5b pop %ebx 1076dd: 5e pop %esi 1076de: 68 35 0b 12 00 push $0x120b35 1076e3: 57 push %edi 1076e4: ff 55 0c call *0xc(%ebp) 1076e7: 83 c4 10 add $0x10,%esp " ID | NAME | TICKS | PERCENT\n" #endif "------------+----------------------------------------+---------------+---------\n" ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 1076ea: bb 01 00 00 00 mov $0x1,%ebx #if defined(RTEMS_DEBUG) if ( !_Objects_Information_table[ api_index ] ) continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 1076ef: 8b 04 9d e0 00 13 00 mov 0x1300e0(,%ebx,4),%eax 1076f6: 8b 70 04 mov 0x4(%eax),%esi if ( information ) { 1076f9: 85 f6 test %esi,%esi 1076fb: 0f 84 db 00 00 00 je 1077dc <== NEVER TAKEN 107701: c7 45 a4 01 00 00 00 movl $0x1,-0x5c(%ebp) 107708: 89 5d 94 mov %ebx,-0x6c(%ebp) 10770b: e9 bc 00 00 00 jmp 1077cc for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 107710: 8b 46 1c mov 0x1c(%esi),%eax 107713: 8b 4d a4 mov -0x5c(%ebp),%ecx 107716: 8b 14 88 mov (%eax,%ecx,4),%edx if ( !the_thread ) 107719: 85 d2 test %edx,%edx 10771b: 0f 84 a8 00 00 00 je 1077c9 <== NEVER TAKEN continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 107721: 51 push %ecx 107722: 8d 5d b3 lea -0x4d(%ebp),%ebx 107725: 53 push %ebx 107726: 6a 0d push $0xd 107728: ff 72 08 pushl 0x8(%edx) 10772b: 89 55 a0 mov %edx,-0x60(%ebp) 10772e: e8 95 39 00 00 call 10b0c8 (*print)( 107733: 53 push %ebx 107734: 8b 55 a0 mov -0x60(%ebp),%edx 107737: ff 72 08 pushl 0x8(%edx) 10773a: 68 a7 0c 12 00 push $0x120ca7 10773f: 57 push %edi 107740: 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; 107743: 8b 55 a0 mov -0x60(%ebp),%edx 107746: 8b 8a 84 00 00 00 mov 0x84(%edx),%ecx 10774c: 8b 9a 88 00 00 00 mov 0x88(%edx),%ebx 107752: 89 4d c8 mov %ecx,-0x38(%ebp) 107755: 89 5d cc mov %ebx,-0x34(%ebp) if ( _Thread_Executing->Object.id == the_thread->Object.id ) { 107758: 83 c4 20 add $0x20,%esp 10775b: a1 98 06 13 00 mov 0x130698,%eax 107760: 8b 5a 08 mov 0x8(%edx),%ebx 107763: 39 58 08 cmp %ebx,0x8(%eax) 107766: 75 28 jne 107790 Timestamp_Control used; _Timestamp_Subtract( 107768: 50 push %eax 107769: 8d 45 c0 lea -0x40(%ebp),%eax 10776c: 50 push %eax 10776d: 8d 55 d8 lea -0x28(%ebp),%edx 107770: 52 push %edx 107771: 68 bc 01 13 00 push $0x1301bc 107776: 89 45 a0 mov %eax,-0x60(%ebp) 107779: e8 8a 6a 00 00 call 10e208 <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &used ); _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 8f 69 00 00 call 10e11c <_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 a7 69 00 00 call 10e14c <_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 ba 0c 12 00 push $0x120cba 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 37 ff ff ff jbe 107710 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 09 ff ff ff jne 1076ef } } } #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 d2 0c 12 00 push $0x120cd2 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 =============================================================================== 0011102c : [RTEMS_IO_ERROR] = EIO, [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_deviceio_errno(rtems_status_code sc) { 11102c: 55 push %ebp 11102d: 89 e5 mov %esp,%ebp 11102f: 53 push %ebx 111030: 83 ec 04 sub $0x4,%esp 111033: 8b 55 08 mov 0x8(%ebp),%edx if (sc == RTEMS_SUCCESSFUL) { return 0; 111036: 31 c0 xor %eax,%eax [RTEMS_PROXY_BLOCKING] = EIO }; int rtems_deviceio_errno(rtems_status_code sc) { if (sc == RTEMS_SUCCESSFUL) { 111038: 85 d2 test %edx,%edx 11103a: 74 1b je 111057 return 0; } else { int eno = EINVAL; 11103c: bb 16 00 00 00 mov $0x16,%ebx if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) { 111041: 83 fa 1c cmp $0x1c,%edx 111044: 77 07 ja 11104d <== NEVER TAKEN eno = status_code_to_errno [sc]; 111046: 8b 1c 95 b8 ed 11 00 mov 0x11edb8(,%edx,4),%ebx } errno = eno; 11104d: e8 5a 00 00 00 call 1110ac <__errno> 111052: 89 18 mov %ebx,(%eax) return -1; 111054: 83 c8 ff or $0xffffffff,%eax } } 111057: 5a pop %edx 111058: 5b pop %ebx 111059: c9 leave 11105a: c3 ret =============================================================================== 0010e327 : rtems_filesystem_fsmount_me_t rtems_filesystem_get_mount_handler( const char *type ) { 10e327: 55 push %ebp 10e328: 89 e5 mov %esp,%ebp 10e32a: 83 ec 18 sub $0x18,%esp 10e32d: 8b 45 08 mov 0x8(%ebp),%eax find_arg fa = { 10e330: 89 45 f0 mov %eax,-0x10(%ebp) 10e333: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) .type = type, .mount_h = NULL }; if ( type != NULL ) { 10e33a: 85 c0 test %eax,%eax 10e33c: 74 13 je 10e351 <== NEVER TAKEN rtems_filesystem_iterate( find_handler, &fa ); 10e33e: 50 push %eax 10e33f: 50 push %eax 10e340: 8d 45 f0 lea -0x10(%ebp),%eax 10e343: 50 push %eax 10e344: 68 50 e2 10 00 push $0x10e250 10e349: e8 62 ff ff ff call 10e2b0 10e34e: 83 c4 10 add $0x10,%esp } return fa.mount_h; } 10e351: 8b 45 f4 mov -0xc(%ebp),%eax 10e354: c9 leave 10e355: 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 50 20 12 00 mov 0x122050,%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 80 ce 11 00 00 cmpl $0x0,0x11ce80 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 01 12 00 mov 0x12014c,%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 db 35 00 00 call 10a72c <== NOT EXECUTED rtems_filesystem_link_counts = 0; 107151: a1 50 20 12 00 mov 0x122050,%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 d4 e5 11 00 push $0x11e5d4 10716e: e8 03 01 00 00 call 107276 rtems_filesystem_root = loc; 107173: 8b 3d 50 20 12 00 mov 0x122050,%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 d4 e5 11 00 push $0x11e5d4 107194: e8 dd 00 00 00 call 107276 rtems_filesystem_current = loc; 107199: 8b 3d 50 20 12 00 mov 0x122050,%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 d6 e5 11 00 push $0x11e5d6 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 =============================================================================== 0010e2b0 : bool rtems_filesystem_iterate( rtems_per_filesystem_routine routine, void *routine_arg ) { 10e2b0: 55 push %ebp 10e2b1: 89 e5 mov %esp,%ebp 10e2b3: 57 push %edi 10e2b4: 56 push %esi 10e2b5: 53 push %ebx 10e2b6: 83 ec 1c sub $0x1c,%esp 10e2b9: 8b 75 08 mov 0x8(%ebp),%esi 10e2bc: 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; 10e2bf: 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]; 10e2c1: bb 60 ce 11 00 mov $0x11ce60,%ebx rtems_chain_node *node = NULL; bool stop = false; while ( table_entry->type && !stop ) { 10e2c6: eb 0c jmp 10e2d4 stop = (*routine)( table_entry, routine_arg ); 10e2c8: 51 push %ecx 10e2c9: 51 push %ecx 10e2ca: 57 push %edi 10e2cb: 53 push %ebx 10e2cc: ff d6 call *%esi ++table_entry; 10e2ce: 83 c3 08 add $0x8,%ebx 10e2d1: 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 ) { 10e2d4: 83 3b 00 cmpl $0x0,(%ebx) 10e2d7: 74 06 je 10e2df 10e2d9: 84 c0 test %al,%al 10e2db: 74 eb je 10e2c8 10e2dd: eb 40 jmp 10e31f stop = (*routine)( table_entry, routine_arg ); ++table_entry; } if ( !stop ) { 10e2df: 84 c0 test %al,%al 10e2e1: 75 3c jne 10e31f rtems_libio_lock(); 10e2e3: 88 45 e4 mov %al,-0x1c(%ebp) 10e2e6: e8 95 ff ff ff call 10e280 } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 10e2eb: 8b 1d 74 20 12 00 mov 0x122074,%ebx ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( 10e2f1: 8a 55 e4 mov -0x1c(%ebp),%dl 10e2f4: eb 10 jmp 10e306 !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 ); 10e2f6: 52 push %edx 10e2f7: 52 push %edx 10e2f8: 57 push %edi 10e2f9: 8d 43 08 lea 0x8(%ebx),%eax 10e2fc: 50 push %eax 10e2fd: ff d6 call *%esi 10e2ff: 88 c2 mov %al,%dl } } rtems_libio_unlock(); rtems_set_errno_and_return_minus_one( ENOENT ); } 10e301: 8b 1b mov (%ebx),%ebx 10e303: 83 c4 10 add $0x10,%esp ++table_entry; } if ( !stop ) { rtems_libio_lock(); for ( 10e306: 81 fb 78 20 12 00 cmp $0x122078,%ebx 10e30c: 74 04 je 10e312 node = rtems_chain_first( &filesystem_chain ); !rtems_chain_is_tail( &filesystem_chain, node ) && !stop; 10e30e: 84 d2 test %dl,%dl 10e310: 74 e4 je 10e2f6 <== ALWAYS TAKEN ) { const filesystem_node *fsn = (filesystem_node *) node; stop = (*routine)( &fsn->entry, routine_arg ); } rtems_libio_unlock(); 10e312: 88 55 e4 mov %dl,-0x1c(%ebp) 10e315: e8 80 ff ff ff call 10e29a 10e31a: 8a 55 e4 mov -0x1c(%ebp),%dl 10e31d: 88 d0 mov %dl,%al } return stop; } 10e31f: 8d 65 f4 lea -0xc(%ebp),%esp 10e322: 5b pop %ebx 10e323: 5e pop %esi 10e324: 5f pop %edi 10e325: c9 leave 10e326: 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 34 1f 12 00 mov 0x121f34,%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 107793: 83 c4 10 add $0x10,%esp { rtems_chain_node *node = NULL; bool stop = false; rtems_libio_lock(); for ( 107796: 81 fb 38 1f 12 00 cmp $0x121f38,%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 =============================================================================== 00107c17 : int rtems_gxx_key_delete (__gthread_key_t key) { 107c17: 55 push %ebp 107c18: 89 e5 mov %esp,%ebp 107c1a: 53 push %ebx 107c1b: 83 ec 0c sub $0xc,%esp 107c1e: 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 ); 107c21: 53 push %ebx 107c22: 6a 00 push $0x0 107c24: e8 6b 34 00 00 call 10b094 if ( status == RTEMS_SUCCESSFUL ) { 107c29: 83 c4 10 add $0x10,%esp 107c2c: 85 c0 test %eax,%eax 107c2e: 75 11 jne 107c41 <== NEVER TAKEN /* Hmm - hopefully all tasks using this key have gone away... */ if ( key ) free( *(void **)key ); 107c30: 85 db test %ebx,%ebx 107c32: 74 0d je 107c41 <== NEVER TAKEN 107c34: 83 ec 0c sub $0xc,%esp 107c37: ff 33 pushl (%ebx) 107c39: e8 4a fe ff ff call 107a88 107c3e: 83 c4 10 add $0x10,%esp return 0; } key = NULL; return 0; } 107c41: 31 c0 xor %eax,%eax 107c43: 8b 5d fc mov -0x4(%ebp),%ebx 107c46: c9 leave 107c47: c3 ret =============================================================================== 00107b74 : /* 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)) { 107b74: 55 push %ebp 107b75: 89 e5 mov %esp,%ebp 107b77: 56 push %esi 107b78: 53 push %ebx 107b79: 83 ec 10 sub $0x10,%esp 107b7c: 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 ) { 107b7f: 8b 03 mov (%ebx),%eax 107b81: 85 c0 test %eax,%eax 107b83: 75 3f jne 107bc4 rtems_mode saveMode; __gthread_once_t o; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 107b85: 52 push %edx 107b86: 8d 45 f4 lea -0xc(%ebp),%eax 107b89: 50 push %eax 107b8a: 68 00 01 00 00 push $0x100 107b8f: 68 00 01 00 00 push $0x100 107b94: e8 e7 32 00 00 call 10ae80 if ( (o = *(volatile __gthread_once_t *)once) == 0 ) { 107b99: 8b 33 mov (%ebx),%esi 107b9b: 83 c4 10 add $0x10,%esp 107b9e: 85 f6 test %esi,%esi 107ba0: 75 06 jne 107ba8 <== NEVER TAKEN *(volatile __gthread_once_t *)once = 1; 107ba2: c7 03 01 00 00 00 movl $0x1,(%ebx) } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 107ba8: 50 push %eax 107ba9: 8d 45 f4 lea -0xc(%ebp),%eax 107bac: 50 push %eax 107bad: 68 00 01 00 00 push $0x100 107bb2: ff 75 f4 pushl -0xc(%ebp) 107bb5: e8 c6 32 00 00 call 10ae80 if ( o == 0 ) 107bba: 83 c4 10 add $0x10,%esp 107bbd: 85 f6 test %esi,%esi 107bbf: 75 03 jne 107bc4 <== NEVER TAKEN (*func)(); 107bc1: ff 55 0c call *0xc(%ebp) } return 0; } 107bc4: 31 c0 xor %eax,%eax 107bc6: 8d 65 f8 lea -0x8(%ebp),%esp 107bc9: 5b pop %ebx 107bca: 5e pop %esi 107bcb: c9 leave 107bcc: c3 ret =============================================================================== 00107ca0 : int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr) { 107ca0: 55 push %ebp 107ca1: 89 e5 mov %esp,%ebp 107ca3: 53 push %ebx 107ca4: 83 ec 08 sub $0x8,%esp 107ca7: 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 ); 107caa: ff 73 04 pushl 0x4(%ebx) 107cad: 53 push %ebx 107cae: 6a 00 push $0x0 107cb0: e8 4b 33 00 00 call 10b000 107cb5: 89 c2 mov %eax,%edx if ( status == RTEMS_SUCCESSFUL ) { 107cb7: 83 c4 10 add $0x10,%esp /* now let's set the proper value */ key->val = (void *)ptr; return 0; } return -1; 107cba: 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 ) { 107cbd: 85 d2 test %edx,%edx 107cbf: 75 07 jne 107cc8 <== NEVER TAKEN /* now let's set the proper value */ key->val = (void *)ptr; 107cc1: 8b 45 0c mov 0xc(%ebp),%eax 107cc4: 89 03 mov %eax,(%ebx) return 0; 107cc6: 31 c0 xor %eax,%eax } return -1; } 107cc8: 8b 5d fc mov -0x4(%ebp),%ebx 107ccb: c9 leave 107ccc: 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 70 ad 12 00 03 cmpl $0x3,0x12ad70 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 50 61 12 00 pushl 0x126150 10a960: e8 e3 43 00 00 call 10ed48 <_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 =============================================================================== 0010b718 : 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 ) { 10b718: 55 push %ebp 10b719: 89 e5 mov %esp,%ebp 10b71b: 57 push %edi 10b71c: 56 push %esi 10b71d: 53 push %ebx 10b71e: 83 ec 0c sub $0xc,%esp 10b721: 8b 5d 08 mov 0x8(%ebp),%ebx 10b724: 8b 75 0c mov 0xc(%ebp),%esi 10b727: 8b 45 10 mov 0x10(%ebp),%eax rtems_device_major_number major_limit = _IO_Number_of_drivers; 10b72a: 8b 15 20 7d 12 00 mov 0x127d20,%edx if ( rtems_interrupt_is_in_progress() ) 10b730: 83 3d e8 78 12 00 00 cmpl $0x0,0x1278e8 10b737: 0f 85 cc 00 00 00 jne 10b809 <== NEVER TAKEN return RTEMS_CALLED_FROM_ISR; if ( registered_major == NULL ) 10b73d: 85 c0 test %eax,%eax 10b73f: 0f 84 cb 00 00 00 je 10b810 return RTEMS_INVALID_ADDRESS; /* Set it to an invalid value */ *registered_major = major_limit; 10b745: 89 10 mov %edx,(%eax) if ( driver_table == NULL ) 10b747: 85 f6 test %esi,%esi 10b749: 0f 84 c1 00 00 00 je 10b810 static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10b74f: 83 3e 00 cmpl $0x0,(%esi) 10b752: 0f 85 cc 00 00 00 jne 10b824 10b758: 83 7e 04 00 cmpl $0x0,0x4(%esi) 10b75c: 0f 85 c2 00 00 00 jne 10b824 10b762: e9 a9 00 00 00 jmp 10b810 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b767: 8b 15 9c 73 12 00 mov 0x12739c,%edx 10b76d: 42 inc %edx 10b76e: 89 15 9c 73 12 00 mov %edx,0x12739c if ( major >= major_limit ) return RTEMS_INVALID_NUMBER; _Thread_Disable_dispatch(); if ( major == 0 ) { 10b774: 85 db test %ebx,%ebx 10b776: 75 32 jne 10b7aa static rtems_status_code rtems_io_obtain_major_number( rtems_device_major_number *major ) { rtems_device_major_number n = _IO_Number_of_drivers; 10b778: 8b 0d 20 7d 12 00 mov 0x127d20,%ecx 10b77e: 8b 15 24 7d 12 00 mov 0x127d24,%edx 10b784: eb 15 jmp 10b79b static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10b786: 83 3a 00 cmpl $0x0,(%edx) 10b789: 0f 85 9f 00 00 00 jne 10b82e 10b78f: 83 7a 04 00 cmpl $0x0,0x4(%edx) 10b793: 0f 85 95 00 00 00 jne 10b82e 10b799: eb 04 jmp 10b79f 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 ) { 10b79b: 39 cb cmp %ecx,%ebx 10b79d: 72 e7 jb 10b786 if ( rtems_io_is_empty_table( table ) ) break; } /* Assigns invalid value in case of failure */ *major = m; 10b79f: 89 18 mov %ebx,(%eax) if ( m != n ) 10b7a1: 39 cb cmp %ecx,%ebx 10b7a3: 75 30 jne 10b7d5 10b7a5: e9 8d 00 00 00 jmp 10b837 _Thread_Enable_dispatch(); return sc; } major = *registered_major; } else { rtems_driver_address_table *const table = _IO_Driver_address_table + major; 10b7aa: 6b d3 18 imul $0x18,%ebx,%edx 10b7ad: 03 15 24 7d 12 00 add 0x127d24,%edx static inline bool rtems_io_is_empty_table( const rtems_driver_address_table *table ) { return table->initialization_entry == NULL && table->open_entry == NULL; 10b7b3: 31 c9 xor %ecx,%ecx 10b7b5: 83 3a 00 cmpl $0x0,(%edx) 10b7b8: 75 09 jne 10b7c3 10b7ba: 31 c9 xor %ecx,%ecx 10b7bc: 83 7a 04 00 cmpl $0x0,0x4(%edx) 10b7c0: 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 ) ) { 10b7c3: 85 c9 test %ecx,%ecx 10b7c5: 75 0c jne 10b7d3 _Thread_Enable_dispatch(); 10b7c7: e8 2a 18 00 00 call 10cff6 <_Thread_Enable_dispatch> return RTEMS_RESOURCE_IN_USE; 10b7cc: b8 0c 00 00 00 mov $0xc,%eax 10b7d1: eb 49 jmp 10b81c } *registered_major = major; 10b7d3: 89 18 mov %ebx,(%eax) } _IO_Driver_address_table [major] = *driver_table; 10b7d5: 6b c3 18 imul $0x18,%ebx,%eax 10b7d8: 03 05 24 7d 12 00 add 0x127d24,%eax 10b7de: b9 06 00 00 00 mov $0x6,%ecx 10b7e3: 89 c7 mov %eax,%edi 10b7e5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Thread_Enable_dispatch(); 10b7e7: e8 0a 18 00 00 call 10cff6 <_Thread_Enable_dispatch> return rtems_io_initialize( major, 0, NULL ); 10b7ec: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) 10b7f3: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) 10b7fa: 89 5d 08 mov %ebx,0x8(%ebp) } 10b7fd: 83 c4 0c add $0xc,%esp 10b800: 5b pop %ebx 10b801: 5e pop %esi 10b802: 5f pop %edi 10b803: c9 leave _IO_Driver_address_table [major] = *driver_table; _Thread_Enable_dispatch(); return rtems_io_initialize( major, 0, NULL ); 10b804: e9 a3 70 00 00 jmp 1128ac ) { rtems_device_major_number major_limit = _IO_Number_of_drivers; if ( rtems_interrupt_is_in_progress() ) return RTEMS_CALLED_FROM_ISR; 10b809: b8 12 00 00 00 mov $0x12,%eax 10b80e: eb 0c jmp 10b81c if ( driver_table == NULL ) return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; 10b810: b8 09 00 00 00 mov $0x9,%eax 10b815: eb 05 jmp 10b81c if ( major >= major_limit ) return RTEMS_INVALID_NUMBER; 10b817: 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 ); } 10b81c: 83 c4 0c add $0xc,%esp 10b81f: 5b pop %ebx 10b820: 5e pop %esi 10b821: 5f pop %edi 10b822: c9 leave 10b823: c3 ret return RTEMS_INVALID_ADDRESS; if ( rtems_io_is_empty_table( driver_table ) ) return RTEMS_INVALID_ADDRESS; if ( major >= major_limit ) 10b824: 39 d3 cmp %edx,%ebx 10b826: 0f 82 3b ff ff ff jb 10b767 10b82c: eb e9 jmp 10b817 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 ) { 10b82e: 43 inc %ebx 10b82f: 83 c2 18 add $0x18,%edx 10b832: e9 64 ff ff ff jmp 10b79b if ( major == 0 ) { rtems_status_code sc = rtems_io_obtain_major_number( registered_major ); if ( sc != RTEMS_SUCCESSFUL ) { _Thread_Enable_dispatch(); 10b837: e8 ba 17 00 00 call 10cff6 <_Thread_Enable_dispatch> *major = m; if ( m != n ) return RTEMS_SUCCESSFUL; return RTEMS_TOO_MANY; 10b83c: 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; 10b841: eb d9 jmp 10b81c =============================================================================== 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_DEBUG) if ( !_Objects_Information_table[ api_index ] ) continue; #endif information = _Objects_Information_table[ api_index ][ 1 ]; 10c758: 8b 04 9d e0 00 13 00 mov 0x1300e0(,%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 =============================================================================== 0010e184 : */ void rtems_libio_free( rtems_libio_t *iop ) { 10e184: 55 push %ebp 10e185: 89 e5 mov %esp,%ebp 10e187: 53 push %ebx 10e188: 83 ec 04 sub $0x4,%esp 10e18b: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_libio_lock(); 10e18e: e8 d5 fe ff ff call 10e068 if (iop->sem) 10e193: 8b 43 2c mov 0x2c(%ebx),%eax 10e196: 85 c0 test %eax,%eax 10e198: 74 0c je 10e1a6 <== NEVER TAKEN rtems_semaphore_delete(iop->sem); 10e19a: 83 ec 0c sub $0xc,%esp 10e19d: 50 push %eax 10e19e: e8 31 bf ff ff call 10a0d4 10e1a3: 83 c4 10 add $0x10,%esp iop->flags &= ~LIBIO_FLAGS_OPEN; 10e1a6: 81 63 14 ff fe ff ff andl $0xfffffeff,0x14(%ebx) iop->data1 = rtems_libio_iop_freelist; 10e1ad: a1 9c 41 12 00 mov 0x12419c,%eax 10e1b2: 89 43 34 mov %eax,0x34(%ebx) rtems_libio_iop_freelist = iop; 10e1b5: 89 1d 9c 41 12 00 mov %ebx,0x12419c rtems_libio_unlock(); } 10e1bb: 8b 5d fc mov -0x4(%ebp),%ebx 10e1be: c9 leave iop->flags &= ~LIBIO_FLAGS_OPEN; iop->data1 = rtems_libio_iop_freelist; rtems_libio_iop_freelist = iop; rtems_libio_unlock(); 10e1bf: e9 be fe ff ff jmp 10e082 =============================================================================== 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 01 12 00 mov 0x120144,%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 98 41 12 00 mov %eax,0x124198 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 9c 41 12 00 mov %eax,0x12419c 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 a0 41 12 00 push $0x1241a0 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 a1 2a 00 00 call 109f3c 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 81 32 00 00 call 10a72c /* * Initialize the base file system infrastructure. */ if (rtems_fs_init_helper) 1074ab: a1 40 01 12 00 mov 0x120140,%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 =============================================================================== 0010860d : rtems_status_code rtems_libio_set_private_env(void) { 10860d: 55 push %ebp 10860e: 89 e5 mov %esp,%ebp 108610: 57 push %edi 108611: 56 push %esi 108612: 53 push %ebx 108613: 83 ec 3c sub $0x3c,%esp rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_id task_id = rtems_task_self(); 108616: e8 49 27 00 00 call 10ad64 10861b: 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); 10861d: 83 ec 0c sub $0xc,%esp 108620: 6a 00 push $0x0 108622: 8d 45 d4 lea -0x2c(%ebp),%eax 108625: 50 push %eax 108626: 6a 00 push $0x0 108628: 6a 01 push $0x1 10862a: 68 5c ee 11 00 push $0x11ee5c 10862f: e8 66 f0 ff ff call 10769a 108634: 89 c2 mov %eax,%edx if (rv != 0) 108636: 83 c4 20 add $0x20,%esp error_1: rtems_filesystem_freenode(&root_loc); error_0: return RTEMS_NO_MEMORY; 108639: 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) 10863e: 85 d2 test %edx,%edx 108640: 0f 85 c0 00 00 00 jne 108706 <== NEVER TAKEN goto error_0; rv = rtems_filesystem_evaluate_path("/", 1, 0, ¤t_loc, 0); 108646: 83 ec 0c sub $0xc,%esp 108649: 6a 00 push $0x0 10864b: 8d 45 c0 lea -0x40(%ebp),%eax 10864e: 50 push %eax 10864f: 6a 00 push $0x0 108651: 6a 01 push $0x1 108653: 68 5c ee 11 00 push $0x11ee5c 108658: e8 3d f0 ff ff call 10769a if (rv != 0) 10865d: 83 c4 20 add $0x20,%esp 108660: 85 c0 test %eax,%eax 108662: 0f 85 8a 00 00 00 jne 1086f2 <== 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 108668: 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 ( 10866d: 3d c8 51 12 00 cmp $0x1251c8,%eax 108672: 74 04 je 108678 rtems_current_user_env == &rtems_global_user_env || rtems_current_user_env->task_id != task_id 108674: 39 18 cmp %ebx,(%eax) 108676: 74 32 je 1086aa ) { new_env = malloc(sizeof(rtems_user_env_t)); 108678: 83 ec 0c sub $0xc,%esp 10867b: 6a 48 push $0x48 10867d: e8 8a f5 ff ff call 107c0c 108682: 89 c6 mov %eax,%esi if (new_env == NULL) 108684: 83 c4 10 add $0x10,%esp 108687: 85 c0 test %eax,%eax 108689: 74 58 je 1086e3 #ifdef HAVE_USERENV_REFCNT new_env->refcnt = 1; #endif sc = rtems_task_variable_add( 10868b: 50 push %eax 10868c: 68 d0 85 10 00 push $0x1085d0 108691: 68 3c 30 12 00 push $0x12303c 108696: 6a 00 push $0x0 108698: e8 3b 27 00 00 call 10add8 RTEMS_SELF, (void*)&rtems_current_user_env, (void(*)(void *))free_user_env ); if (sc != RTEMS_SUCCESSFUL) 10869d: 83 c4 10 add $0x10,%esp 1086a0: 85 c0 test %eax,%eax 1086a2: 75 33 jne 1086d7 goto error_3; rtems_current_user_env = new_env; 1086a4: 89 35 3c 30 12 00 mov %esi,0x12303c } /* Inherit the global values */ *rtems_current_user_env = rtems_global_user_env; 1086aa: a1 3c 30 12 00 mov 0x12303c,%eax 1086af: be c8 51 12 00 mov $0x1251c8,%esi 1086b4: b9 12 00 00 00 mov $0x12,%ecx 1086b9: 89 c7 mov %eax,%edi 1086bb: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_current_user_env->task_id = task_id; 1086bd: 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; 1086bf: 8d 78 18 lea 0x18(%eax),%edi 1086c2: 8d 75 d4 lea -0x2c(%ebp),%esi 1086c5: b1 05 mov $0x5,%cl 1086c7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_filesystem_current = current_loc; 1086c9: 8d 78 04 lea 0x4(%eax),%edi 1086cc: 8d 75 c0 lea -0x40(%ebp),%esi 1086cf: b1 05 mov $0x5,%cl 1086d1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return RTEMS_SUCCESSFUL; 1086d3: 31 c0 xor %eax,%eax 1086d5: eb 2f jmp 108706 error_3: free(new_env); 1086d7: 83 ec 0c sub $0xc,%esp 1086da: 56 push %esi 1086db: e8 8c f0 ff ff call 10776c 1086e0: 83 c4 10 add $0x10,%esp error_2: rtems_filesystem_freenode(¤t_loc); 1086e3: 83 ec 0c sub $0xc,%esp 1086e6: 8d 45 c0 lea -0x40(%ebp),%eax 1086e9: 50 push %eax 1086ea: e8 69 f0 ff ff call 107758 1086ef: 83 c4 10 add $0x10,%esp error_1: rtems_filesystem_freenode(&root_loc); 1086f2: 83 ec 0c sub $0xc,%esp 1086f5: 8d 45 d4 lea -0x2c(%ebp),%eax 1086f8: 50 push %eax 1086f9: e8 5a f0 ff ff call 107758 1086fe: 83 c4 10 add $0x10,%esp error_0: return RTEMS_NO_MEMORY; 108701: b8 1a 00 00 00 mov $0x1a,%eax } 108706: 8d 65 f4 lea -0xc(%ebp),%esp 108709: 5b pop %ebx 10870a: 5e pop %esi 10870b: 5f pop %edi 10870c: c9 leave 10870d: c3 ret =============================================================================== 0010870e : * 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) { 10870e: 55 push %ebp 10870f: 89 e5 mov %esp,%ebp 108711: 56 push %esi 108712: 53 push %ebx 108713: 83 ec 20 sub $0x20,%esp 108716: 8b 75 08 mov 0x8(%ebp),%esi rtems_id current_task_id; /* * get current task id */ current_task_id = rtems_task_self(); 108719: e8 46 26 00 00 call 10ad64 10871e: 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; 108720: 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 ) 108722: 39 de cmp %ebx,%esi 108724: 74 3c je 108762 <== NEVER TAKEN return RTEMS_SUCCESSFUL; /* * Try to get the requested user environment */ sc = rtems_task_variable_get( 108726: 52 push %edx task_id, (void*)&rtems_current_user_env, (void*)&shared_user_env ); 108727: 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( 10872a: 50 push %eax 10872b: 68 3c 30 12 00 push $0x12303c 108730: 56 push %esi 108731: e8 36 27 00 00 call 10ae6c (void*)&shared_user_env ); /* * If it was not successful, return the error code */ if (sc != RTEMS_SUCCESSFUL) 108736: 83 c4 10 add $0x10,%esp 108739: 85 c0 test %eax,%eax 10873b: 75 25 jne 108762 * 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) { 10873d: 8b 15 3c 30 12 00 mov 0x12303c,%edx 108743: 39 1a cmp %ebx,(%edx) 108745: 75 12 jne 108759 rtems_user_env_t *tmp = rtems_current_user_env; free_user_env( tmp ); 108747: 83 ec 0c sub $0xc,%esp 10874a: 52 push %edx 10874b: 89 45 e4 mov %eax,-0x1c(%ebp) 10874e: e8 7d fe ff ff call 1085d0 108753: 83 c4 10 add $0x10,%esp 108756: 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; 108759: 8b 55 f4 mov -0xc(%ebp),%edx 10875c: 89 15 3c 30 12 00 mov %edx,0x12303c #ifdef HAVE_USERENV_REFCNT rtems_current_user_env->refcnt++; #endif return RTEMS_SUCCESSFUL; } 108762: 8d 65 f8 lea -0x8(%ebp),%esp 108765: 5b pop %ebx 108766: 5e pop %esi 108767: c9 leave 108768: c3 ret =============================================================================== 0010e0cd : */ uint32_t rtems_libio_to_fcntl_flags( uint32_t flags ) { 10e0cd: 55 push %ebp 10e0ce: 89 e5 mov %esp,%ebp 10e0d0: 8b 55 08 mov 0x8(%ebp),%edx uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10e0d3: 89 d1 mov %edx,%ecx 10e0d5: 83 e1 06 and $0x6,%ecx fcntl_flags |= O_RDWR; 10e0d8: 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 ) { 10e0dd: 83 f9 06 cmp $0x6,%ecx 10e0e0: 74 0f je 10e0f1 fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { fcntl_flags |= O_RDONLY; 10e0e2: 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) { 10e0e4: f6 c2 02 test $0x2,%dl 10e0e7: 75 08 jne 10e0f1 <== ALWAYS TAKEN ) { uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { fcntl_flags |= O_RDWR; 10e0e9: 31 c0 xor %eax,%eax 10e0eb: f6 c2 04 test $0x4,%dl <== NOT EXECUTED 10e0ee: 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 ) { 10e0f1: f6 c2 01 test $0x1,%dl 10e0f4: 74 03 je 10e0f9 fcntl_flags |= O_NONBLOCK; 10e0f6: 80 cc 40 or $0x40,%ah } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 10e0f9: f6 c6 02 test $0x2,%dh 10e0fc: 74 03 je 10e101 fcntl_flags |= O_APPEND; 10e0fe: 83 c8 08 or $0x8,%eax } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 10e101: 80 e6 04 and $0x4,%dh 10e104: 74 03 je 10e109 fcntl_flags |= O_CREAT; 10e106: 80 cc 02 or $0x2,%ah } return fcntl_flags; } 10e109: c9 leave 10e10a: 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 50 61 12 00 pushl 0x126150 109d8f: e8 5c 50 00 00 call 10edf0 <_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 e0 aa 12 00 add %eax,0x12aae0 109da6: 11 15 e4 aa 12 00 adc %edx,0x12aae4 } } 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 50 61 12 00 pushl 0x126150 109dce: e8 1d 50 00 00 call 10edf0 <_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 d8 aa 12 00 add 0x12aad8,%eax 109dde: 13 15 dc aa 12 00 adc 0x12aadc,%edx 109de4: a3 d8 aa 12 00 mov %eax,0x12aad8 109de9: 89 15 dc aa 12 00 mov %edx,0x12aadc current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed); 109def: 2b 05 e0 aa 12 00 sub 0x12aae0,%eax if (current_depth > s->max_depth) 109df5: 83 c4 10 add $0x10,%esp 109df8: 3b 05 d4 aa 12 00 cmp 0x12aad4,%eax 109dfe: 76 05 jbe 109e05 s->max_depth = current_depth; 109e00: a3 d4 aa 12 00 mov %eax,0x12aad4 } 109e05: c9 leave 109e06: c3 ret =============================================================================== 00111948 : int rtems_memalign( void **pointer, size_t alignment, size_t size ) { 111948: 55 push %ebp 111949: 89 e5 mov %esp,%ebp 11194b: 57 push %edi 11194c: 56 push %esi 11194d: 53 push %ebx 11194e: 83 ec 0c sub $0xc,%esp 111951: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Parameter error checks */ if ( !pointer ) return EINVAL; 111954: be 16 00 00 00 mov $0x16,%esi void *return_this; /* * Parameter error checks */ if ( !pointer ) 111959: 85 db test %ebx,%ebx 11195b: 74 55 je 1119b2 return EINVAL; *pointer = NULL; 11195d: 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()) && 111963: 83 3d 1c 75 12 00 03 cmpl $0x3,0x12751c 11196a: 75 09 jne 111975 <== NEVER TAKEN !malloc_is_system_state_OK() ) 11196c: e8 97 68 ff ff call 108208 *pointer = NULL; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 111971: 84 c0 test %al,%al 111973: 74 3d je 1119b2 <== NEVER TAKEN return EINVAL; /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 111975: e8 cc 68 ff ff call 108246 Heap_Control *heap, uintptr_t size, uintptr_t alignment ) { return 11197a: 6a 00 push $0x0 11197c: ff 75 0c pushl 0xc(%ebp) 11197f: ff 75 10 pushl 0x10(%ebp) 111982: ff 35 50 31 12 00 pushl 0x123150 111988: e8 93 b0 ff ff call 10ca20 <_Protected_heap_Allocate_aligned_with_boundary> 11198d: 89 c7 mov %eax,%edi return_this = _Protected_heap_Allocate_aligned( RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 11198f: 83 c4 10 add $0x10,%esp return ENOMEM; 111992: be 0c 00 00 00 mov $0xc,%esi return_this = _Protected_heap_Allocate_aligned( RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 111997: 85 c0 test %eax,%eax 111999: 74 17 je 1119b2 return ENOMEM; /* * If configured, update the more involved statistics */ if ( rtems_malloc_statistics_helpers ) 11199b: a1 30 56 12 00 mov 0x125630,%eax 1119a0: 85 c0 test %eax,%eax 1119a2: 74 0a je 1119ae (*rtems_malloc_statistics_helpers->at_malloc)(pointer); 1119a4: 83 ec 0c sub $0xc,%esp 1119a7: 53 push %ebx 1119a8: ff 50 04 call *0x4(%eax) 1119ab: 83 c4 10 add $0x10,%esp *pointer = return_this; 1119ae: 89 3b mov %edi,(%ebx) return 0; 1119b0: 31 f6 xor %esi,%esi } 1119b2: 89 f0 mov %esi,%eax 1119b4: 8d 65 f4 lea -0xc(%ebp),%esp 1119b7: 5b pop %ebx 1119b8: 5e pop %esi 1119b9: 5f pop %edi 1119ba: c9 leave 1119bb: c3 ret =============================================================================== 00110254 : return (retval); } int rtems_mkdir(const char *path, mode_t mode) { 110254: 55 push %ebp 110255: 89 e5 mov %esp,%ebp 110257: 57 push %edi 110258: 56 push %esi 110259: 53 push %ebx 11025a: 83 ec 78 sub $0x78,%esp int success = 0; char *dup_path = strdup(path); 11025d: ff 75 08 pushl 0x8(%ebp) 110260: e8 8f 33 00 00 call 1135f4 110265: 89 c3 mov %eax,%ebx if (dup_path != NULL) { 110267: 83 c4 10 add $0x10,%esp success = build(dup_path, mode); free(dup_path); } return success != 0 ? 0 : -1; 11026a: 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) { 11026d: 85 db test %ebx,%ebx 11026f: 0f 84 1e 01 00 00 je 110393 <== NEVER TAKEN p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; 110275: 31 c0 xor %eax,%eax 110277: 80 3b 2f cmpb $0x2f,(%ebx) 11027a: 0f 94 c0 sete %al 11027d: 8d 3c 03 lea (%ebx,%eax,1),%edi char *p; p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ 110280: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) 110287: b8 01 00 00 00 mov $0x1,%eax ++p; for (first = 1, last = 0; !last ; ++p) { if (p[0] == '\0') 11028c: 8a 0f mov (%edi),%cl last = 1; 11028e: 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') 110293: 84 c9 test %cl,%cl 110295: 74 0b je 1102a2 last = 1; else if (p[0] != '/') 110297: 80 f9 2f cmp $0x2f,%cl 11029a: 0f 85 c8 00 00 00 jne 110368 1102a0: 30 d2 xor %dl,%dl continue; *p = '\0'; 1102a2: c6 07 00 movb $0x0,(%edi) if (!last && p[1] == '\0') 1102a5: be 01 00 00 00 mov $0x1,%esi 1102aa: 85 d2 test %edx,%edx 1102ac: 75 0b jne 1102b9 1102ae: 31 d2 xor %edx,%edx 1102b0: 80 7f 01 00 cmpb $0x0,0x1(%edi) 1102b4: 0f 94 c2 sete %dl 1102b7: 89 d6 mov %edx,%esi last = 1; if (first) { 1102b9: 85 c0 test %eax,%eax 1102bb: 74 1a je 1102d7 * mkdir [-m mode] dir * * We change the user's umask and then restore it, * instead of doing chmod's. */ oumask = umask(0); 1102bd: 83 ec 0c sub $0xc,%esp 1102c0: 6a 00 push $0x0 1102c2: e8 75 01 00 00 call 11043c 1102c7: 89 45 94 mov %eax,-0x6c(%ebp) numask = oumask & ~(S_IWUSR | S_IXUSR); 1102ca: 24 3f and $0x3f,%al (void)umask(numask); 1102cc: 89 04 24 mov %eax,(%esp) 1102cf: e8 68 01 00 00 call 11043c 1102d4: 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) { 1102d7: b8 ff 01 00 00 mov $0x1ff,%eax oumask = umask(0); numask = oumask & ~(S_IWUSR | S_IXUSR); (void)umask(numask); first = 0; } if (last) 1102dc: 85 f6 test %esi,%esi 1102de: 74 11 je 1102f1 (void)umask(oumask); 1102e0: 83 ec 0c sub $0xc,%esp 1102e3: ff 75 94 pushl -0x6c(%ebp) 1102e6: e8 51 01 00 00 call 11043c 1102eb: 83 c4 10 add $0x10,%esp if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) { 1102ee: 8b 45 0c mov 0xc(%ebp),%eax 1102f1: 52 push %edx 1102f2: 52 push %edx 1102f3: 50 push %eax 1102f4: 53 push %ebx 1102f5: e8 ee 83 ff ff call 1086e8 1102fa: 83 c4 10 add $0x10,%esp 1102fd: 85 c0 test %eax,%eax 1102ff: 79 5e jns 11035f if (errno == EEXIST || errno == EISDIR) { 110301: e8 1a 26 00 00 call 112920 <__errno> 110306: 83 38 11 cmpl $0x11,(%eax) 110309: 74 0a je 110315 11030b: e8 10 26 00 00 call 112920 <__errno> 110310: 83 38 15 cmpl $0x15,(%eax) 110313: 75 59 jne 11036e <== ALWAYS TAKEN if (stat(path, &sb) < 0) { 110315: 50 push %eax 110316: 50 push %eax 110317: 8d 45 a0 lea -0x60(%ebp),%eax 11031a: 50 push %eax 11031b: 53 push %ebx 11031c: e8 8b 00 00 00 call 1103ac 110321: 83 c4 10 add $0x10,%esp 110324: 85 c0 test %eax,%eax 110326: 78 46 js 11036e <== NEVER TAKEN retval = 0; break; } else if (!S_ISDIR(sb.st_mode)) { 110328: 8b 45 ac mov -0x54(%ebp),%eax 11032b: 25 00 f0 00 00 and $0xf000,%eax 110330: 3d 00 40 00 00 cmp $0x4000,%eax 110335: 74 22 je 110359 if (last) 110337: 85 f6 test %esi,%esi 110339: 74 0f je 11034a errno = EEXIST; 11033b: e8 e0 25 00 00 call 112920 <__errno> 110340: c7 00 11 00 00 00 movl $0x11,(%eax) else errno = ENOTDIR; retval = 0; 110346: 31 ff xor %edi,%edi 110348: eb 38 jmp 110382 break; } else if (!S_ISDIR(sb.st_mode)) { if (last) errno = EEXIST; else errno = ENOTDIR; 11034a: e8 d1 25 00 00 call 112920 <__errno> 11034f: c7 00 14 00 00 00 movl $0x14,(%eax) retval = 0; 110355: 31 ff xor %edi,%edi 110357: eb 1b jmp 110374 break; } if (last) 110359: 85 f6 test %esi,%esi 11035b: 75 3e jne 11039b 11035d: eb 04 jmp 110363 } else { retval = 0; break; } } if (!last) 11035f: 85 f6 test %esi,%esi 110361: 75 3f jne 1103a2 *p = '/'; 110363: c6 07 2f movb $0x2f,(%edi) 110366: 31 c0 xor %eax,%eax p = path; oumask = 0; retval = 1; if (p[0] == '/') /* Skip leading '/'. */ ++p; for (first = 1, last = 0; !last ; ++p) { 110368: 47 inc %edi 110369: e9 1e ff ff ff jmp 11028c 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; 11036e: 31 ff xor %edi,%edi } } if (!last) *p = '/'; } if (!first && !last) 110370: 85 f6 test %esi,%esi 110372: 75 0e jne 110382 <== ALWAYS TAKEN (void)umask(oumask); 110374: 83 ec 0c sub $0xc,%esp 110377: ff 75 94 pushl -0x6c(%ebp) 11037a: e8 bd 00 00 00 call 11043c 11037f: 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); 110382: 83 ec 0c sub $0xc,%esp 110385: 53 push %ebx 110386: e8 01 7e ff ff call 10818c } return success != 0 ? 0 : -1; 11038b: 83 c4 10 add $0x10,%esp 11038e: 83 ff 01 cmp $0x1,%edi 110391: 19 c0 sbb %eax,%eax } 110393: 8d 65 f4 lea -0xc(%ebp),%esp 110396: 5b pop %ebx 110397: 5e pop %esi 110398: 5f pop %edi 110399: c9 leave 11039a: c3 ret errno = ENOTDIR; retval = 0; break; } if (last) retval = 2; 11039b: bf 02 00 00 00 mov $0x2,%edi 1103a0: eb e0 jmp 110382 } else { retval = 0; break; } } if (!last) 1103a2: bf 01 00 00 00 mov $0x1,%edi 1103a7: eb d9 jmp 110382 =============================================================================== 001147e8 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, rtems_id *id ) { 1147e8: 55 push %ebp 1147e9: 89 e5 mov %esp,%ebp 1147eb: 57 push %edi 1147ec: 56 push %esi 1147ed: 53 push %ebx 1147ee: 83 ec 1c sub $0x1c,%esp 1147f1: 8b 75 0c mov 0xc(%ebp),%esi 1147f4: 8b 55 10 mov 0x10(%ebp),%edx 1147f7: 8b 7d 14 mov 0x14(%ebp),%edi register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; 1147fa: b8 03 00 00 00 mov $0x3,%eax rtems_id *id ) { register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 1147ff: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 114803: 0f 84 ce 00 00 00 je 1148d7 return RTEMS_INVALID_NAME; if ( !starting_address ) return RTEMS_INVALID_ADDRESS; 114809: b0 09 mov $0x9,%al register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !starting_address ) 11480b: 85 f6 test %esi,%esi 11480d: 0f 84 c4 00 00 00 je 1148d7 return RTEMS_INVALID_ADDRESS; if ( !id ) 114813: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp) 114817: 0f 84 ba 00 00 00 je 1148d7 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 11481d: 85 ff test %edi,%edi 11481f: 0f 84 ad 00 00 00 je 1148d2 114825: 85 d2 test %edx,%edx 114827: 0f 84 a5 00 00 00 je 1148d2 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; 11482d: b0 08 mov $0x8,%al return RTEMS_INVALID_ADDRESS; if ( !id ) return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 11482f: 39 fa cmp %edi,%edx 114831: 0f 82 a0 00 00 00 jb 1148d7 114837: f7 c7 03 00 00 00 test $0x3,%edi 11483d: 0f 85 94 00 00 00 jne 1148d7 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) return RTEMS_INVALID_ADDRESS; 114843: 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 ) ) 114845: f7 c6 03 00 00 00 test $0x3,%esi 11484b: 0f 85 86 00 00 00 jne 1148d7 114851: a1 b8 d6 13 00 mov 0x13d6b8,%eax 114856: 40 inc %eax 114857: a3 b8 d6 13 00 mov %eax,0x13d6b8 * 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 ); 11485c: 83 ec 0c sub $0xc,%esp 11485f: 68 44 d5 13 00 push $0x13d544 114864: 89 55 e4 mov %edx,-0x1c(%ebp) 114867: e8 20 3e 00 00 call 11868c <_Objects_Allocate> 11486c: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 11486e: 83 c4 10 add $0x10,%esp 114871: 85 c0 test %eax,%eax 114873: 8b 55 e4 mov -0x1c(%ebp),%edx 114876: 75 0c jne 114884 _Thread_Enable_dispatch(); 114878: e8 59 4a 00 00 call 1192d6 <_Thread_Enable_dispatch> return RTEMS_TOO_MANY; 11487d: b8 05 00 00 00 mov $0x5,%eax 114882: eb 53 jmp 1148d7 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 114884: 89 70 10 mov %esi,0x10(%eax) the_partition->length = length; 114887: 89 50 14 mov %edx,0x14(%eax) the_partition->buffer_size = buffer_size; 11488a: 89 78 18 mov %edi,0x18(%eax) the_partition->attribute_set = attribute_set; 11488d: 8b 45 18 mov 0x18(%ebp),%eax 114890: 89 43 1c mov %eax,0x1c(%ebx) the_partition->number_of_used_blocks = 0; 114893: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) _Chain_Initialize( &the_partition->Memory, starting_address, 11489a: 57 push %edi 11489b: 89 d0 mov %edx,%eax 11489d: 31 d2 xor %edx,%edx 11489f: f7 f7 div %edi 1148a1: 50 push %eax 1148a2: 56 push %esi 1148a3: 8d 43 24 lea 0x24(%ebx),%eax 1148a6: 50 push %eax 1148a7: e8 80 2a 00 00 call 11732c <_Chain_Initialize> Objects_Name name ) { _Objects_Set_local_object( information, _Objects_Get_index( the_object->id ), 1148ac: 8b 43 08 mov 0x8(%ebx),%eax Objects_Information *information, Objects_Control *the_object, Objects_Name name ) { _Objects_Set_local_object( 1148af: 0f b7 c8 movzwl %ax,%ecx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 1148b2: 8b 15 60 d5 13 00 mov 0x13d560,%edx 1148b8: 89 1c 8a mov %ebx,(%edx,%ecx,4) information, _Objects_Get_index( the_object->id ), the_object ); the_object->name = name; 1148bb: 8b 55 08 mov 0x8(%ebp),%edx 1148be: 89 53 0c mov %edx,0xc(%ebx) &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 1148c1: 8b 55 1c mov 0x1c(%ebp),%edx 1148c4: 89 02 mov %eax,(%edx) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 1148c6: e8 0b 4a 00 00 call 1192d6 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1148cb: 83 c4 10 add $0x10,%esp 1148ce: 31 c0 xor %eax,%eax 1148d0: eb 05 jmp 1148d7 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; 1148d2: b8 08 00 00 00 mov $0x8,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1148d7: 8d 65 f4 lea -0xc(%ebp),%esp 1148da: 5b pop %ebx 1148db: 5e pop %esi 1148dc: 5f pop %edi 1148dd: c9 leave 1148de: c3 ret =============================================================================== 0010b03d : rtems_status_code rtems_rate_monotonic_period( rtems_id id, rtems_interval length ) { 10b03d: 55 push %ebp 10b03e: 89 e5 mov %esp,%ebp 10b040: 57 push %edi 10b041: 56 push %esi 10b042: 53 push %ebx 10b043: 83 ec 30 sub $0x30,%esp 10b046: 8b 75 08 mov 0x8(%ebp),%esi 10b049: 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 ); 10b04c: 8d 45 e4 lea -0x1c(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Rate_monotonic_Control *) _Objects_Get( &_Rate_monotonic_Information, id, location ); 10b04f: 50 push %eax 10b050: 56 push %esi 10b051: 68 14 73 12 00 push $0x127314 10b056: e8 3d 1e 00 00 call 10ce98 <_Objects_Get> 10b05b: 89 c7 mov %eax,%edi switch ( location ) { 10b05d: 83 c4 10 add $0x10,%esp 10b060: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b064: 0f 85 3b 01 00 00 jne 10b1a5 <== NEVER TAKEN case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 10b06a: a1 58 79 12 00 mov 0x127958,%eax 10b06f: 39 47 40 cmp %eax,0x40(%edi) 10b072: 74 0f je 10b083 _Thread_Enable_dispatch(); 10b074: e8 fd 25 00 00 call 10d676 <_Thread_Enable_dispatch> return RTEMS_NOT_OWNER_OF_RESOURCE; 10b079: be 17 00 00 00 mov $0x17,%esi 10b07e: e9 27 01 00 00 jmp 10b1aa } if ( length == RTEMS_PERIOD_STATUS ) { 10b083: 85 db test %ebx,%ebx 10b085: 75 1b jne 10b0a2 switch ( the_period->state ) { 10b087: 8b 47 38 mov 0x38(%edi),%eax 10b08a: 31 f6 xor %esi,%esi 10b08c: 83 f8 04 cmp $0x4,%eax 10b08f: 77 07 ja 10b098 <== NEVER TAKEN 10b091: 8b 34 85 00 0d 12 00 mov 0x120d00(,%eax,4),%esi case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 10b098: e8 d9 25 00 00 call 10d676 <_Thread_Enable_dispatch> return( return_value ); 10b09d: e9 08 01 00 00 jmp 10b1aa } _ISR_Disable( level ); 10b0a2: 9c pushf 10b0a3: fa cli 10b0a4: 8f 45 d4 popl -0x2c(%ebp) if ( the_period->state == RATE_MONOTONIC_INACTIVE ) { 10b0a7: 8b 47 38 mov 0x38(%edi),%eax 10b0aa: 85 c0 test %eax,%eax 10b0ac: 75 4c jne 10b0fa _ISR_Enable( level ); 10b0ae: ff 75 d4 pushl -0x2c(%ebp) 10b0b1: 9d popf /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 10b0b2: 83 ec 0c sub $0xc,%esp 10b0b5: 57 push %edi 10b0b6: e8 3f fe ff ff call 10aefa <_Rate_monotonic_Initiate_statistics> the_period->state = RATE_MONOTONIC_ACTIVE; 10b0bb: 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; 10b0c2: c7 47 18 00 00 00 00 movl $0x0,0x18(%edi) the_watchdog->routine = routine; 10b0c9: c7 47 2c b4 b3 10 00 movl $0x10b3b4,0x2c(%edi) the_watchdog->id = id; 10b0d0: 89 77 30 mov %esi,0x30(%edi) the_watchdog->user_data = user_data; 10b0d3: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 10b0da: 89 5f 3c mov %ebx,0x3c(%edi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b0dd: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b0e0: 58 pop %eax 10b0e1: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, length ); 10b0e2: 83 c7 10 add $0x10,%edi 10b0e5: 57 push %edi 10b0e6: 68 d0 74 12 00 push $0x1274d0 10b0eb: e8 ec 34 00 00 call 10e5dc <_Watchdog_Insert> _Thread_Enable_dispatch(); 10b0f0: e8 81 25 00 00 call 10d676 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b0f5: 83 c4 10 add $0x10,%esp 10b0f8: eb 65 jmp 10b15f } if ( the_period->state == RATE_MONOTONIC_ACTIVE ) { 10b0fa: 83 f8 02 cmp $0x2,%eax 10b0fd: 75 64 jne 10b163 /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 10b0ff: 83 ec 0c sub $0xc,%esp 10b102: 57 push %edi 10b103: e8 5a fe ff ff call 10af62 <_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; 10b108: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi) the_period->next_length = length; 10b10f: 89 5f 3c mov %ebx,0x3c(%edi) _ISR_Enable( level ); 10b112: ff 75 d4 pushl -0x2c(%ebp) 10b115: 9d popf _Thread_Executing->Wait.id = the_period->Object.id; 10b116: a1 58 79 12 00 mov 0x127958,%eax 10b11b: 8b 57 08 mov 0x8(%edi),%edx 10b11e: 89 50 20 mov %edx,0x20(%eax) _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b121: 5b pop %ebx 10b122: 5e pop %esi 10b123: 68 00 40 00 00 push $0x4000 10b128: 50 push %eax 10b129: e8 42 2d 00 00 call 10de70 <_Thread_Set_state> /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 10b12e: 9c pushf 10b12f: fa cli 10b130: 5a pop %edx local_state = the_period->state; 10b131: 8b 47 38 mov 0x38(%edi),%eax the_period->state = RATE_MONOTONIC_ACTIVE; 10b134: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi) _ISR_Enable( level ); 10b13b: 52 push %edx 10b13c: 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 ) 10b13d: 83 c4 10 add $0x10,%esp 10b140: 83 f8 03 cmp $0x3,%eax 10b143: 75 15 jne 10b15a _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b145: 51 push %ecx 10b146: 51 push %ecx 10b147: 68 00 40 00 00 push $0x4000 10b14c: ff 35 58 79 12 00 pushl 0x127958 10b152: e8 ad 21 00 00 call 10d304 <_Thread_Clear_state> 10b157: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 10b15a: e8 17 25 00 00 call 10d676 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10b15f: 31 f6 xor %esi,%esi 10b161: eb 47 jmp 10b1aa #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b163: be 04 00 00 00 mov $0x4,%esi _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } if ( the_period->state == RATE_MONOTONIC_EXPIRED ) { 10b168: 83 f8 04 cmp $0x4,%eax 10b16b: 75 3d jne 10b1aa <== NEVER TAKEN /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 10b16d: 83 ec 0c sub $0xc,%esp 10b170: 57 push %edi 10b171: e8 ec fd ff ff call 10af62 <_Rate_monotonic_Update_statistics> _ISR_Enable( level ); 10b176: ff 75 d4 pushl -0x2c(%ebp) 10b179: 9d popf the_period->state = RATE_MONOTONIC_ACTIVE; 10b17a: c7 47 38 02 00 00 00 movl $0x2,0x38(%edi) the_period->next_length = length; 10b181: 89 5f 3c mov %ebx,0x3c(%edi) Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10b184: 89 5f 1c mov %ebx,0x1c(%edi) _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10b187: 58 pop %eax 10b188: 5a pop %edx _Watchdog_Insert_ticks( &the_period->Timer, length ); 10b189: 83 c7 10 add $0x10,%edi 10b18c: 57 push %edi 10b18d: 68 d0 74 12 00 push $0x1274d0 10b192: e8 45 34 00 00 call 10e5dc <_Watchdog_Insert> _Thread_Enable_dispatch(); 10b197: e8 da 24 00 00 call 10d676 <_Thread_Enable_dispatch> return RTEMS_TIMEOUT; 10b19c: 83 c4 10 add $0x10,%esp 10b19f: 66 be 06 00 mov $0x6,%si 10b1a3: eb 05 jmp 10b1aa #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10b1a5: be 04 00 00 00 mov $0x4,%esi } 10b1aa: 89 f0 mov %esi,%eax 10b1ac: 8d 65 f4 lea -0xc(%ebp),%esp 10b1af: 5b pop %ebx 10b1b0: 5e pop %esi 10b1b1: 5f pop %edi 10b1b2: c9 leave 10b1b3: c3 ret =============================================================================== 0010b1b4 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 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 7c sub $0x7c,%esp 10b1bd: 8b 5d 08 mov 0x8(%ebp),%ebx 10b1c0: 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 ) 10b1c3: 85 ff test %edi,%edi 10b1c5: 0f 84 2b 01 00 00 je 10b2f6 <== NEVER TAKEN return; (*print)( context, "Period information by period\n" ); 10b1cb: 52 push %edx 10b1cc: 52 push %edx 10b1cd: 68 14 0d 12 00 push $0x120d14 10b1d2: 53 push %ebx 10b1d3: ff d7 call *%edi #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ (*print)( context, "--- CPU times are in seconds ---\n" ); 10b1d5: 5e pop %esi 10b1d6: 58 pop %eax 10b1d7: 68 32 0d 12 00 push $0x120d32 10b1dc: 53 push %ebx 10b1dd: ff d7 call *%edi (*print)( context, "--- Wall times are in seconds ---\n" ); 10b1df: 5a pop %edx 10b1e0: 59 pop %ecx 10b1e1: 68 54 0d 12 00 push $0x120d54 10b1e6: 53 push %ebx 10b1e7: ff d7 call *%edi Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 10b1e9: 5e pop %esi 10b1ea: 58 pop %eax 10b1eb: 68 77 0d 12 00 push $0x120d77 10b1f0: 53 push %ebx 10b1f1: ff d7 call *%edi #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ " " #endif " WALL TIME\n" ); (*print)( context, " " 10b1f3: 5a pop %edx 10b1f4: 59 pop %ecx 10b1f5: 68 c2 0d 12 00 push $0x120dc2 10b1fa: 53 push %ebx 10b1fb: 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 ; 10b1fd: 8b 35 1c 73 12 00 mov 0x12731c,%esi 10b203: 83 c4 10 add $0x10,%esp 10b206: e9 df 00 00 00 jmp 10b2ea id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 10b20b: 50 push %eax 10b20c: 50 push %eax 10b20d: 8d 45 88 lea -0x78(%ebp),%eax 10b210: 50 push %eax 10b211: 56 push %esi 10b212: e8 39 56 00 00 call 110850 if ( status != RTEMS_SUCCESSFUL ) 10b217: 83 c4 10 add $0x10,%esp 10b21a: 85 c0 test %eax,%eax 10b21c: 0f 85 c7 00 00 00 jne 10b2e9 continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 10b222: 51 push %ecx 10b223: 51 push %ecx 10b224: 8d 55 c0 lea -0x40(%ebp),%edx 10b227: 52 push %edx 10b228: 56 push %esi 10b229: e8 c6 56 00 00 call 1108f4 #if defined(RTEMS_DEBUG) if ( status != RTEMS_SUCCESSFUL ) continue; #endif rtems_object_get_name( the_status.owner, sizeof(name), name ); 10b22e: 83 c4 0c add $0xc,%esp 10b231: 8d 45 e3 lea -0x1d(%ebp),%eax 10b234: 50 push %eax 10b235: 6a 05 push $0x5 10b237: ff 75 c0 pushl -0x40(%ebp) 10b23a: e8 01 02 00 00 call 10b440 /* * Print part of report line that is not dependent on granularity */ (*print)( context, 10b23f: 58 pop %eax 10b240: 5a pop %edx 10b241: ff 75 8c pushl -0x74(%ebp) 10b244: ff 75 88 pushl -0x78(%ebp) 10b247: 8d 55 e3 lea -0x1d(%ebp),%edx 10b24a: 52 push %edx 10b24b: 56 push %esi 10b24c: 68 0e 0e 12 00 push $0x120e0e 10b251: 53 push %ebx 10b252: ff d7 call *%edi ); /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 10b254: 8b 45 88 mov -0x78(%ebp),%eax 10b257: 83 c4 20 add $0x20,%esp 10b25a: 85 c0 test %eax,%eax 10b25c: 75 0f jne 10b26d (*print)( context, "\n" ); 10b25e: 51 push %ecx 10b25f: 51 push %ecx 10b260: 68 88 10 12 00 push $0x121088 10b265: 53 push %ebx 10b266: ff d7 call *%edi continue; 10b268: 83 c4 10 add $0x10,%esp 10b26b: eb 7c jmp 10b2e9 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 ); 10b26d: 52 push %edx 10b26e: 8d 55 d8 lea -0x28(%ebp),%edx 10b271: 52 push %edx 10b272: 50 push %eax 10b273: 8d 45 a0 lea -0x60(%ebp),%eax 10b276: 50 push %eax 10b277: e8 34 30 00 00 call 10e2b0 <_Timespec_Divide_by_integer> (*print)( context, 10b27c: 8b 45 dc mov -0x24(%ebp),%eax 10b27f: b9 e8 03 00 00 mov $0x3e8,%ecx 10b284: 99 cltd 10b285: f7 f9 idiv %ecx 10b287: 50 push %eax 10b288: ff 75 d8 pushl -0x28(%ebp) 10b28b: 8b 45 9c mov -0x64(%ebp),%eax 10b28e: 99 cltd 10b28f: f7 f9 idiv %ecx 10b291: 50 push %eax 10b292: ff 75 98 pushl -0x68(%ebp) 10b295: 8b 45 94 mov -0x6c(%ebp),%eax 10b298: 99 cltd 10b299: f7 f9 idiv %ecx 10b29b: 50 push %eax 10b29c: ff 75 90 pushl -0x70(%ebp) 10b29f: 68 25 0e 12 00 push $0x120e25 10b2a4: 53 push %ebx 10b2a5: 89 4d 84 mov %ecx,-0x7c(%ebp) 10b2a8: 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); 10b2aa: 83 c4 2c add $0x2c,%esp 10b2ad: 8d 55 d8 lea -0x28(%ebp),%edx 10b2b0: 52 push %edx 10b2b1: 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; 10b2b4: 8d 45 b8 lea -0x48(%ebp),%eax _Timespec_Divide_by_integer(total_wall, the_stats.count, &wall_average); 10b2b7: 50 push %eax 10b2b8: e8 f3 2f 00 00 call 10e2b0 <_Timespec_Divide_by_integer> (*print)( context, 10b2bd: 8b 45 dc mov -0x24(%ebp),%eax 10b2c0: 8b 4d 84 mov -0x7c(%ebp),%ecx 10b2c3: 99 cltd 10b2c4: f7 f9 idiv %ecx 10b2c6: 50 push %eax 10b2c7: ff 75 d8 pushl -0x28(%ebp) 10b2ca: 8b 45 b4 mov -0x4c(%ebp),%eax 10b2cd: 99 cltd 10b2ce: f7 f9 idiv %ecx 10b2d0: 50 push %eax 10b2d1: ff 75 b0 pushl -0x50(%ebp) 10b2d4: 8b 45 ac mov -0x54(%ebp),%eax 10b2d7: 99 cltd 10b2d8: f7 f9 idiv %ecx 10b2da: 50 push %eax 10b2db: ff 75 a8 pushl -0x58(%ebp) 10b2de: 68 44 0e 12 00 push $0x120e44 10b2e3: 53 push %ebx 10b2e4: ff d7 call *%edi 10b2e6: 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++ ) { 10b2e9: 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 ; 10b2ea: 3b 35 20 73 12 00 cmp 0x127320,%esi 10b2f0: 0f 86 15 ff ff ff jbe 10b20b the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 10b2f6: 8d 65 f4 lea -0xc(%ebp),%esp 10b2f9: 5b pop %ebx 10b2fa: 5e pop %esi 10b2fb: 5f pop %edi 10b2fc: c9 leave 10b2fd: c3 ret =============================================================================== 00115b48 : rtems_status_code rtems_signal_send( rtems_id id, rtems_signal_set signal_set ) { 115b48: 55 push %ebp 115b49: 89 e5 mov %esp,%ebp 115b4b: 53 push %ebx 115b4c: 83 ec 14 sub $0x14,%esp 115b4f: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; 115b52: 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 ) 115b57: 85 db test %ebx,%ebx 115b59: 74 6d je 115bc8 return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 115b5b: 50 push %eax 115b5c: 50 push %eax 115b5d: 8d 45 f4 lea -0xc(%ebp),%eax 115b60: 50 push %eax 115b61: ff 75 08 pushl 0x8(%ebp) 115b64: e8 8f 37 00 00 call 1192f8 <_Thread_Get> switch ( location ) { 115b69: 83 c4 10 add $0x10,%esp 115b6c: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 115b70: 75 51 jne 115bc3 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 115b72: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 115b78: 83 7a 0c 00 cmpl $0x0,0xc(%edx) 115b7c: 74 39 je 115bb7 if ( asr->is_enabled ) { 115b7e: 80 7a 08 00 cmpb $0x0,0x8(%edx) 115b82: 74 22 je 115ba6 rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115b84: 9c pushf 115b85: fa cli 115b86: 59 pop %ecx *signal_set |= signals; 115b87: 09 5a 14 or %ebx,0x14(%edx) _ISR_Enable( _level ); 115b8a: 51 push %ecx 115b8b: 9d popf _ASR_Post_signals( signal_set, &asr->signals_posted ); if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 115b8c: 83 3d 0c dc 13 00 00 cmpl $0x0,0x13dc0c 115b93: 74 19 je 115bae 115b95: 3b 05 10 dc 13 00 cmp 0x13dc10,%eax 115b9b: 75 11 jne 115bae <== NEVER TAKEN _Thread_Dispatch_necessary = true; 115b9d: c6 05 1c dc 13 00 01 movb $0x1,0x13dc1c 115ba4: eb 08 jmp 115bae rtems_signal_set *signal_set ) { ISR_Level _level; _ISR_Disable( _level ); 115ba6: 9c pushf 115ba7: fa cli 115ba8: 58 pop %eax *signal_set |= signals; 115ba9: 09 5a 18 or %ebx,0x18(%edx) _ISR_Enable( _level ); 115bac: 50 push %eax 115bad: 9d popf } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 115bae: e8 23 37 00 00 call 1192d6 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 115bb3: 31 c0 xor %eax,%eax 115bb5: eb 11 jmp 115bc8 } _Thread_Enable_dispatch(); 115bb7: e8 1a 37 00 00 call 1192d6 <_Thread_Enable_dispatch> return RTEMS_NOT_DEFINED; 115bbc: b8 0b 00 00 00 mov $0xb,%eax 115bc1: eb 05 jmp 115bc8 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 115bc3: b8 04 00 00 00 mov $0x4,%eax } 115bc8: 8b 5d fc mov -0x4(%ebp),%ebx 115bcb: c9 leave 115bcc: c3 ret =============================================================================== 001072c4 : * rtems_stack_checker_Begin_extension */ void rtems_stack_checker_begin_extension( Thread_Control *the_thread ) { 1072c4: 55 push %ebp 1072c5: 89 e5 mov %esp,%ebp 1072c7: 57 push %edi 1072c8: 56 push %esi 1072c9: 8b 45 08 mov 0x8(%ebp),%eax Stack_check_Control *the_pattern; if ( the_thread->Object.id == 0 ) /* skip system tasks */ 1072cc: 83 78 08 00 cmpl $0x0,0x8(%eax) 1072d0: 74 15 je 1072e7 <== NEVER TAKEN return; the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack); *the_pattern = Stack_check_Pattern; 1072d2: 8b b8 c8 00 00 00 mov 0xc8(%eax),%edi 1072d8: 83 c7 08 add $0x8,%edi 1072db: be c8 71 12 00 mov $0x1271c8,%esi 1072e0: b9 04 00 00 00 mov $0x4,%ecx 1072e5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } 1072e7: 5e pop %esi 1072e8: 5f pop %edi 1072e9: c9 leave 1072ea: c3 ret =============================================================================== 0010729d : */ bool rtems_stack_checker_create_extension( Thread_Control *running __attribute__((unused)), Thread_Control *the_thread ) { 10729d: 55 push %ebp 10729e: 89 e5 mov %esp,%ebp 1072a0: 57 push %edi 1072a1: 8b 7d 0c mov 0xc(%ebp),%edi Stack_check_Initialize(); 1072a4: e8 8a ff ff ff call 107233 if (the_thread) 1072a9: 85 ff test %edi,%edi 1072ab: 74 12 je 1072bf <== NEVER TAKEN Stack_check_Dope_stack(&the_thread->Start.Initial_stack); 1072ad: 8b 8f c4 00 00 00 mov 0xc4(%edi),%ecx 1072b3: 8b 97 c8 00 00 00 mov 0xc8(%edi),%edx 1072b9: b0 a5 mov $0xa5,%al 1072bb: 89 d7 mov %edx,%edi 1072bd: f3 aa rep stos %al,%es:(%edi) return true; } 1072bf: b0 01 mov $0x1,%al 1072c1: 5f pop %edi 1072c2: c9 leave 1072c3: c3 ret =============================================================================== 001073f8 : /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) { 1073f8: 55 push %ebp 1073f9: 89 e5 mov %esp,%ebp 1073fb: 53 push %ebx 1073fc: 83 ec 04 sub $0x4,%esp Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 1073ff: a1 e8 78 12 00 mov 0x1278e8,%eax ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 107404: 8b 90 c8 00 00 00 mov 0xc8(%eax),%edx return false; 10740a: 31 db xor %ebx,%ebx ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 10740c: 39 d5 cmp %edx,%ebp 10740e: 72 0e jb 10741e <== NEVER TAKEN return false; } if ( sp > (the_stack->area + the_stack->size) ) { 107410: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax 107416: 8d 04 02 lea (%edx,%eax,1),%eax } /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) 107419: 39 c5 cmp %eax,%ebp 10741b: 0f 96 c3 setbe %bl { Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; bool sp_ok; bool pattern_ok = true; 10741e: b0 01 mov $0x1,%al /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 107420: 83 3d b8 6e 12 00 00 cmpl $0x0,0x126eb8 107427: 74 19 je 107442 <== NEVER TAKEN pattern_ok = (!memcmp( (void *) Stack_check_Get_pattern_area(the_stack)->pattern, 107429: 83 c2 08 add $0x8,%edx /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { pattern_ok = (!memcmp( 10742c: 51 push %ecx 10742d: 6a 10 push $0x10 10742f: 68 c8 71 12 00 push $0x1271c8 107434: 52 push %edx 107435: e8 ce ca 00 00 call 113f08 10743a: 83 c4 10 add $0x10,%esp 10743d: 85 c0 test %eax,%eax 10743f: 0f 94 c0 sete %al /* * Let's report as much as we can. */ if ( !sp_ok || !pattern_ok ) { 107442: 84 db test %bl,%bl 107444: 74 04 je 10744a <== NEVER TAKEN 107446: 84 c0 test %al,%al 107448: 75 11 jne 10745b <== ALWAYS TAKEN Stack_check_report_blown_task( _Thread_Executing, pattern_ok ); 10744a: 52 push %edx <== NOT EXECUTED 10744b: 52 push %edx <== NOT EXECUTED 10744c: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10744f: 50 push %eax <== NOT EXECUTED 107450: ff 35 e8 78 12 00 pushl 0x1278e8 <== NOT EXECUTED 107456: e8 90 fe ff ff call 1072eb <== NOT EXECUTED /* * The Stack Pointer and the Pattern Area are OK so return false. */ return false; } 10745b: 31 c0 xor %eax,%eax 10745d: 8b 5d fc mov -0x4(%ebp),%ebx 107460: c9 leave 107461: c3 ret =============================================================================== 001074c7 : void rtems_stack_checker_report_usage( void ) { 1074c7: 55 push %ebp <== NOT EXECUTED 1074c8: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1074ca: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin ); 1074cd: 68 2c 8c 10 00 push $0x108c2c <== NOT EXECUTED 1074d2: 6a 00 push $0x0 <== NOT EXECUTED 1074d4: e8 89 ff ff ff call 107462 <== NOT EXECUTED 1074d9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1074dc: c9 leave <== NOT EXECUTED 1074dd: c3 ret <== NOT EXECUTED =============================================================================== 00107462 : void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) { 107462: 55 push %ebp <== NOT EXECUTED 107463: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107465: 56 push %esi <== NOT EXECUTED 107466: 53 push %ebx <== NOT EXECUTED 107467: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10746a: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED if ( !print ) 10746d: 85 db test %ebx,%ebx <== NOT EXECUTED 10746f: 74 4f je 1074c0 <== NOT EXECUTED return; print_context = context; 107471: 89 35 b0 6e 12 00 mov %esi,0x126eb0 <== NOT EXECUTED print_handler = print; 107477: 89 1d b4 6e 12 00 mov %ebx,0x126eb4 <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 10747d: 51 push %ecx <== NOT EXECUTED 10747e: 51 push %ecx <== NOT EXECUTED 10747f: 68 c7 0d 12 00 push $0x120dc7 <== NOT EXECUTED 107484: 56 push %esi <== NOT EXECUTED 107485: ff d3 call *%ebx <== NOT EXECUTED (*print)( context, 107487: 58 pop %eax <== NOT EXECUTED 107488: 5a pop %edx <== NOT EXECUTED 107489: 68 de 0d 12 00 push $0x120dde <== NOT EXECUTED 10748e: 56 push %esi <== NOT EXECUTED 10748f: 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 ); 107491: c7 04 24 18 71 10 00 movl $0x107118,(%esp) <== NOT EXECUTED 107498: e8 b3 63 00 00 call 10d850 <== NOT EXECUTED #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) /* dump interrupt stack info if any */ Stack_check_Dump_threads_usage((Thread_Control *) -1); 10749d: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED 1074a4: e8 6f fc ff ff call 107118 <== NOT EXECUTED #endif print_context = NULL; 1074a9: c7 05 b0 6e 12 00 00 movl $0x0,0x126eb0 <== NOT EXECUTED 1074b0: 00 00 00 print_handler = NULL; 1074b3: c7 05 b4 6e 12 00 00 movl $0x0,0x126eb4 <== NOT EXECUTED 1074ba: 00 00 00 1074bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1074c0: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1074c3: 5b pop %ebx <== NOT EXECUTED 1074c4: 5e pop %esi <== NOT EXECUTED 1074c5: c9 leave <== NOT EXECUTED 1074c6: c3 ret <== NOT EXECUTED =============================================================================== 0010739f : */ void rtems_stack_checker_switch_extension( Thread_Control *running __attribute__((unused)), Thread_Control *heir __attribute__((unused)) ) { 10739f: 55 push %ebp 1073a0: 89 e5 mov %esp,%ebp 1073a2: 53 push %ebx 1073a3: 83 ec 14 sub $0x14,%esp 1073a6: 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 = (void *) Stack_check_Get_pattern_area(the_stack)->pattern; 1073a9: 8b 83 c8 00 00 00 mov 0xc8(%ebx),%eax 1073af: 8d 48 08 lea 0x8(%eax),%ecx { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { return false; 1073b2: 31 d2 xor %edx,%edx ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 1073b4: 39 c5 cmp %eax,%ebp 1073b6: 72 0b jb 1073c3 <== NEVER TAKEN return false; } if ( sp > (the_stack->area + the_stack->size) ) { 1073b8: 03 83 c4 00 00 00 add 0xc4(%ebx),%eax } /* * rtems_stack_checker_switch_extension */ void rtems_stack_checker_switch_extension( 1073be: 39 c5 cmp %eax,%ebp 1073c0: 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, 1073c3: 50 push %eax 1073c4: 6a 10 push $0x10 1073c6: 68 c8 71 12 00 push $0x1271c8 1073cb: 51 push %ecx 1073cc: 88 55 f4 mov %dl,-0xc(%ebp) 1073cf: e8 34 cb 00 00 call 113f08 1073d4: 83 c4 10 add $0x10,%esp 1073d7: 85 c0 test %eax,%eax 1073d9: 0f 94 c0 sete %al (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { 1073dc: 8a 55 f4 mov -0xc(%ebp),%dl 1073df: 84 d2 test %dl,%dl 1073e1: 74 04 je 1073e7 <== NEVER TAKEN 1073e3: 84 c0 test %al,%al 1073e5: 75 0c jne 1073f3 <== ALWAYS TAKEN Stack_check_report_blown_task( running, pattern_ok ); 1073e7: 52 push %edx <== NOT EXECUTED 1073e8: 52 push %edx <== NOT EXECUTED 1073e9: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 1073ec: 50 push %eax <== NOT EXECUTED 1073ed: 53 push %ebx <== NOT EXECUTED 1073ee: e8 f8 fe ff ff call 1072eb <== NOT EXECUTED } } 1073f3: 8b 5d fc mov -0x4(%ebp),%ebx 1073f6: c9 leave 1073f7: c3 ret =============================================================================== 0010ef00 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 10ef00: 55 push %ebp 10ef01: 89 e5 mov %esp,%ebp 10ef03: 57 push %edi 10ef04: 56 push %esi 10ef05: 53 push %ebx 10ef06: 83 ec 2c sub $0x2c,%esp 10ef09: 8b 75 08 mov 0x8(%ebp),%esi 10ef0c: 8b 5d 0c mov 0xc(%ebp),%ebx 10ef0f: 8b 7d 10 mov 0x10(%ebp),%edi STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10ef12: b8 09 00 00 00 mov $0x9,%eax ) { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 10ef17: 85 db test %ebx,%ebx 10ef19: 74 6e je 10ef89 return RTEMS_INVALID_ADDRESS; errno = 0; 10ef1b: e8 f8 2a 00 00 call 111a18 <__errno> 10ef20: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10ef26: c7 03 00 00 00 00 movl $0x0,(%ebx) 10ef2c: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); 10ef33: 50 push %eax 10ef34: 50 push %eax 10ef35: 8d 45 e4 lea -0x1c(%ebp),%eax 10ef38: 50 push %eax 10ef39: 56 push %esi 10ef3a: e8 85 55 00 00 call 1144c4 #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 ) 10ef3f: 83 c4 10 add $0x10,%esp 10ef42: 85 ff test %edi,%edi 10ef44: 74 05 je 10ef4b *endptr = end; 10ef46: 8b 45 e4 mov -0x1c(%ebp),%eax 10ef49: 89 07 mov %eax,(%edi) /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 10ef4b: 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 ) 10ef50: 39 75 e4 cmp %esi,-0x1c(%ebp) 10ef53: 74 2e je 10ef83 return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10ef55: dd 05 f0 33 12 00 fldl 0x1233f0 10ef5b: d9 c9 fxch %st(1) 10ef5d: dd e1 fucom %st(1) 10ef5f: df e0 fnstsw %ax 10ef61: dd d9 fstp %st(1) 10ef63: 9e sahf 10ef64: 76 17 jbe 10ef7d 10ef66: dd 5d c8 fstpl -0x38(%ebp) 10ef69: e8 aa 2a 00 00 call 111a18 <__errno> 10ef6e: 89 c2 mov %eax,%edx return RTEMS_INVALID_NUMBER; 10ef70: 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)) 10ef75: 83 3a 22 cmpl $0x22,(%edx) 10ef78: dd 45 c8 fldl -0x38(%ebp) 10ef7b: 74 0a je 10ef87 <== ALWAYS TAKEN #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 10ef7d: dd 1b fstpl (%ebx) #endif return RTEMS_SUCCESSFUL; 10ef7f: 31 c0 xor %eax,%eax 10ef81: eb 06 jmp 10ef89 10ef83: dd d8 fstp %st(0) 10ef85: eb 02 jmp 10ef89 10ef87: dd d8 fstp %st(0) } 10ef89: 8d 65 f4 lea -0xc(%ebp),%esp 10ef8c: 5b pop %ebx 10ef8d: 5e pop %esi 10ef8e: 5f pop %edi 10ef8f: c9 leave 10ef90: c3 ret =============================================================================== 0010ef94 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 10ef94: 55 push %ebp 10ef95: 89 e5 mov %esp,%ebp 10ef97: 57 push %edi 10ef98: 56 push %esi 10ef99: 53 push %ebx 10ef9a: 83 ec 2c sub $0x2c,%esp 10ef9d: 8b 75 08 mov 0x8(%ebp),%esi 10efa0: 8b 5d 0c mov 0xc(%ebp),%ebx 10efa3: 8b 7d 10 mov 0x10(%ebp),%edi STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10efa6: b8 09 00 00 00 mov $0x9,%eax ) { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 10efab: 85 db test %ebx,%ebx 10efad: 74 67 je 10f016 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; errno = 0; 10efaf: e8 64 2a 00 00 call 111a18 <__errno> 10efb4: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10efba: c7 03 00 00 00 00 movl $0x0,(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); 10efc0: 50 push %eax 10efc1: 50 push %eax 10efc2: 8d 45 e4 lea -0x1c(%ebp),%eax 10efc5: 50 push %eax 10efc6: 56 push %esi 10efc7: e8 14 55 00 00 call 1144e0 #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 ) 10efcc: 83 c4 10 add $0x10,%esp 10efcf: 85 ff test %edi,%edi 10efd1: 74 05 je 10efd8 *endptr = end; 10efd3: 8b 45 e4 mov -0x1c(%ebp),%eax 10efd6: 89 07 mov %eax,(%edi) /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 10efd8: 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 ) 10efdd: 39 75 e4 cmp %esi,-0x1c(%ebp) 10efe0: 74 2e je 10f010 <== NEVER TAKEN return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10efe2: d9 05 f8 33 12 00 flds 0x1233f8 10efe8: d9 c9 fxch %st(1) 10efea: dd e1 fucom %st(1) 10efec: df e0 fnstsw %ax 10efee: dd d9 fstp %st(1) 10eff0: 9e sahf 10eff1: 76 17 jbe 10f00a <== NEVER TAKEN 10eff3: d9 5d c8 fstps -0x38(%ebp) 10eff6: e8 1d 2a 00 00 call 111a18 <__errno> 10effb: 89 c2 mov %eax,%edx return RTEMS_INVALID_NUMBER; 10effd: 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)) 10f002: 83 3a 22 cmpl $0x22,(%edx) 10f005: d9 45 c8 flds -0x38(%ebp) 10f008: 74 0a je 10f014 <== ALWAYS TAKEN #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 10f00a: d9 1b fstps (%ebx) #endif return RTEMS_SUCCESSFUL; 10f00c: 31 c0 xor %eax,%eax 10f00e: eb 06 jmp 10f016 10f010: dd d8 fstp %st(0) 10f012: eb 02 jmp 10f016 10f014: dd d8 fstp %st(0) } 10f016: 8d 65 f4 lea -0xc(%ebp),%esp 10f019: 5b pop %ebx 10f01a: 5e pop %esi 10f01b: 5f pop %edi 10f01c: c9 leave 10f01d: c3 ret =============================================================================== 0010f0a0 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 10f0a0: 55 push %ebp 10f0a1: 89 e5 mov %esp,%ebp 10f0a3: 57 push %edi 10f0a4: 56 push %esi 10f0a5: 53 push %ebx 10f0a6: 83 ec 2c sub $0x2c,%esp 10f0a9: 8b 5d 0c mov 0xc(%ebp),%ebx 10f0ac: 8b 7d 10 mov 0x10(%ebp),%edi STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f0af: b9 09 00 00 00 mov $0x9,%ecx ) { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 10f0b4: 85 db test %ebx,%ebx 10f0b6: 74 76 je 10f12e return RTEMS_INVALID_ADDRESS; errno = 0; 10f0b8: e8 5b 29 00 00 call 111a18 <__errno> 10f0bd: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f0c3: c7 03 00 00 00 00 movl $0x0,(%ebx) 10f0c9: 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 ); 10f0d0: 50 push %eax 10f0d1: ff 75 14 pushl 0x14(%ebp) 10f0d4: 8d 45 e4 lea -0x1c(%ebp),%eax 10f0d7: 50 push %eax 10f0d8: ff 75 08 pushl 0x8(%ebp) 10f0db: e8 e0 55 00 00 call 1146c0 10f0e0: 89 c6 mov %eax,%esi #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 10f0e2: 83 c4 10 add $0x10,%esp 10f0e5: 85 ff test %edi,%edi 10f0e7: 74 05 je 10f0ee *endptr = end; 10f0e9: 8b 45 e4 mov -0x1c(%ebp),%eax 10f0ec: 89 07 mov %eax,(%edi) /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 10f0ee: 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 ) 10f0f3: 8b 45 08 mov 0x8(%ebp),%eax 10f0f6: 39 45 e4 cmp %eax,-0x1c(%ebp) 10f0f9: 74 33 je 10f12e return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f0fb: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx 10f101: 75 05 jne 10f108 10f103: 83 fe ff cmp $0xffffffff,%esi 10f106: 74 0a je 10f112 <== ALWAYS TAKEN return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MIN /* there was an underflow */ if ( (result == STRING_TO_MIN) && (errno == ERANGE)) 10f108: 8d 82 00 00 00 80 lea -0x80000000(%edx),%eax 10f10e: 09 f0 or %esi,%eax 10f110: 75 15 jne 10f127 10f112: 89 55 d4 mov %edx,-0x2c(%ebp) 10f115: e8 fe 28 00 00 call 111a18 <__errno> return RTEMS_INVALID_NUMBER; 10f11a: 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)) 10f11f: 83 38 22 cmpl $0x22,(%eax) 10f122: 8b 55 d4 mov -0x2c(%ebp),%edx 10f125: 74 07 je 10f12e #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 10f127: 89 33 mov %esi,(%ebx) 10f129: 89 53 04 mov %edx,0x4(%ebx) #endif return RTEMS_SUCCESSFUL; 10f12c: 31 c9 xor %ecx,%ecx } 10f12e: 89 c8 mov %ecx,%eax 10f130: 8d 65 f4 lea -0xc(%ebp),%esp 10f133: 5b pop %ebx 10f134: 5e pop %esi 10f135: 5f pop %edi 10f136: c9 leave 10f137: c3 ret =============================================================================== 0010f1c0 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 10f1c0: 55 push %ebp 10f1c1: 89 e5 mov %esp,%ebp 10f1c3: 57 push %edi 10f1c4: 56 push %esi 10f1c5: 53 push %ebx 10f1c6: 83 ec 2c sub $0x2c,%esp 10f1c9: 8b 7d 08 mov 0x8(%ebp),%edi 10f1cc: 8b 5d 0c mov 0xc(%ebp),%ebx 10f1cf: 8b 55 10 mov 0x10(%ebp),%edx STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f1d2: b8 09 00 00 00 mov $0x9,%eax ) { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 10f1d7: 85 db test %ebx,%ebx 10f1d9: 74 56 je 10f231 return RTEMS_INVALID_ADDRESS; errno = 0; 10f1db: 89 55 d4 mov %edx,-0x2c(%ebp) 10f1de: e8 35 28 00 00 call 111a18 <__errno> 10f1e3: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f1e9: 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 ); 10f1ef: 50 push %eax 10f1f0: 6a 10 push $0x10 10f1f2: 8d 45 e4 lea -0x1c(%ebp),%eax 10f1f5: 50 push %eax 10f1f6: 57 push %edi 10f1f7: e8 70 59 00 00 call 114b6c 10f1fc: 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 ) 10f1fe: 83 c4 10 add $0x10,%esp 10f201: 8b 55 d4 mov -0x2c(%ebp),%edx 10f204: 85 d2 test %edx,%edx 10f206: 74 05 je 10f20d *endptr = end; 10f208: 8b 45 e4 mov -0x1c(%ebp),%eax 10f20b: 89 02 mov %eax,(%edx) /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 10f20d: 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 ) 10f212: 39 7d e4 cmp %edi,-0x1c(%ebp) 10f215: 74 1a je 10f231 return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f217: 83 fe ff cmp $0xffffffff,%esi 10f21a: 75 11 jne 10f22d <== ALWAYS TAKEN 10f21c: e8 f7 27 00 00 call 111a18 <__errno> <== NOT EXECUTED 10f221: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_NUMBER; 10f223: 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)) 10f228: 83 3a 22 cmpl $0x22,(%edx) <== NOT EXECUTED 10f22b: 74 04 je 10f231 <== 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; 10f22d: 89 33 mov %esi,(%ebx) #else *n = (STRING_TO_TYPE) result; #endif return RTEMS_SUCCESSFUL; 10f22f: 31 c0 xor %eax,%eax } 10f231: 8d 65 f4 lea -0xc(%ebp),%esp 10f234: 5b pop %ebx 10f235: 5e pop %esi 10f236: 5f pop %edi 10f237: c9 leave 10f238: c3 ret =============================================================================== 0010f298 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 10f298: 55 push %ebp 10f299: 89 e5 mov %esp,%ebp 10f29b: 57 push %edi 10f29c: 56 push %esi 10f29d: 53 push %ebx 10f29e: 83 ec 2c sub $0x2c,%esp 10f2a1: 8b 7d 08 mov 0x8(%ebp),%edi 10f2a4: 8b 5d 0c mov 0xc(%ebp),%ebx 10f2a7: 8b 55 10 mov 0x10(%ebp),%edx STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f2aa: b8 09 00 00 00 mov $0x9,%eax ) { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 10f2af: 85 db test %ebx,%ebx 10f2b1: 74 57 je 10f30a return RTEMS_INVALID_ADDRESS; errno = 0; 10f2b3: 89 55 d4 mov %edx,-0x2c(%ebp) 10f2b6: e8 5d 27 00 00 call 111a18 <__errno> 10f2bb: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f2c1: 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 ); 10f2c7: 50 push %eax 10f2c8: ff 75 14 pushl 0x14(%ebp) 10f2cb: 8d 45 e4 lea -0x1c(%ebp),%eax 10f2ce: 50 push %eax 10f2cf: 57 push %edi 10f2d0: e8 97 58 00 00 call 114b6c 10f2d5: 89 c6 mov %eax,%esi #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 10f2d7: 83 c4 10 add $0x10,%esp 10f2da: 8b 55 d4 mov -0x2c(%ebp),%edx 10f2dd: 85 d2 test %edx,%edx 10f2df: 74 05 je 10f2e6 *endptr = end; 10f2e1: 8b 45 e4 mov -0x1c(%ebp),%eax 10f2e4: 89 02 mov %eax,(%edx) /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 10f2e6: 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 ) 10f2eb: 39 7d e4 cmp %edi,-0x1c(%ebp) 10f2ee: 74 1a je 10f30a return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f2f0: 83 fe ff cmp $0xffffffff,%esi 10f2f3: 75 11 jne 10f306 10f2f5: e8 1e 27 00 00 call 111a18 <__errno> 10f2fa: 89 c2 mov %eax,%edx return RTEMS_INVALID_NUMBER; 10f2fc: 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)) 10f301: 83 3a 22 cmpl $0x22,(%edx) 10f304: 74 04 je 10f30a <== ALWAYS TAKEN #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 10f306: 89 33 mov %esi,(%ebx) #endif return RTEMS_SUCCESSFUL; 10f308: 31 c0 xor %eax,%eax } 10f30a: 8d 65 f4 lea -0xc(%ebp),%esp 10f30d: 5b pop %ebx 10f30e: 5e pop %esi 10f30f: 5f pop %edi 10f310: c9 leave 10f311: c3 ret =============================================================================== 0010f3a0 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 10f3a0: 55 push %ebp 10f3a1: 89 e5 mov %esp,%ebp 10f3a3: 57 push %edi 10f3a4: 56 push %esi 10f3a5: 53 push %ebx 10f3a6: 83 ec 2c sub $0x2c,%esp 10f3a9: 8b 7d 08 mov 0x8(%ebp),%edi 10f3ac: 8b 5d 0c mov 0xc(%ebp),%ebx 10f3af: 8b 55 10 mov 0x10(%ebp),%edx STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f3b2: b8 09 00 00 00 mov $0x9,%eax ) { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 10f3b7: 85 db test %ebx,%ebx 10f3b9: 74 57 je 10f412 return RTEMS_INVALID_ADDRESS; errno = 0; 10f3bb: 89 55 d4 mov %edx,-0x2c(%ebp) 10f3be: e8 55 26 00 00 call 111a18 <__errno> 10f3c3: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f3c9: 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 ); 10f3cf: 50 push %eax 10f3d0: ff 75 14 pushl 0x14(%ebp) 10f3d3: 8d 45 e4 lea -0x1c(%ebp),%eax 10f3d6: 50 push %eax 10f3d7: 57 push %edi 10f3d8: e8 8f 57 00 00 call 114b6c 10f3dd: 89 c6 mov %eax,%esi #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 10f3df: 83 c4 10 add $0x10,%esp 10f3e2: 8b 55 d4 mov -0x2c(%ebp),%edx 10f3e5: 85 d2 test %edx,%edx 10f3e7: 74 05 je 10f3ee *endptr = end; 10f3e9: 8b 45 e4 mov -0x1c(%ebp),%eax 10f3ec: 89 02 mov %eax,(%edx) /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 10f3ee: 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 ) 10f3f3: 39 7d e4 cmp %edi,-0x1c(%ebp) 10f3f6: 74 1a je 10f412 return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f3f8: 83 fe ff cmp $0xffffffff,%esi 10f3fb: 75 11 jne 10f40e 10f3fd: e8 16 26 00 00 call 111a18 <__errno> 10f402: 89 c2 mov %eax,%edx return RTEMS_INVALID_NUMBER; 10f404: 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)) 10f409: 83 3a 22 cmpl $0x22,(%edx) 10f40c: 74 04 je 10f412 <== ALWAYS TAKEN #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 10f40e: 89 33 mov %esi,(%ebx) #endif return RTEMS_SUCCESSFUL; 10f410: 31 c0 xor %eax,%eax } 10f412: 8d 65 f4 lea -0xc(%ebp),%esp 10f415: 5b pop %ebx 10f416: 5e pop %esi 10f417: 5f pop %edi 10f418: c9 leave 10f419: c3 ret =============================================================================== 0010f314 : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 10f314: 55 push %ebp 10f315: 89 e5 mov %esp,%ebp 10f317: 57 push %edi 10f318: 56 push %esi 10f319: 53 push %ebx 10f31a: 83 ec 2c sub $0x2c,%esp 10f31d: 8b 5d 0c mov 0xc(%ebp),%ebx 10f320: 8b 7d 10 mov 0x10(%ebp),%edi STRING_TO_INPUT_TYPE result; char *end; if ( !n ) return RTEMS_INVALID_ADDRESS; 10f323: b8 09 00 00 00 mov $0x9,%eax ) { STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 10f328: 85 db test %ebx,%ebx 10f32a: 74 6b je 10f397 return RTEMS_INVALID_ADDRESS; errno = 0; 10f32c: e8 e7 26 00 00 call 111a18 <__errno> 10f331: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 10f337: c7 03 00 00 00 00 movl $0x0,(%ebx) 10f33d: 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 ); 10f344: 50 push %eax 10f345: ff 75 14 pushl 0x14(%ebp) 10f348: 8d 45 e4 lea -0x1c(%ebp),%eax 10f34b: 50 push %eax 10f34c: ff 75 08 pushl 0x8(%ebp) 10f34f: e8 34 58 00 00 call 114b88 10f354: 89 c6 mov %eax,%esi #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 10f356: 83 c4 10 add $0x10,%esp 10f359: 85 ff test %edi,%edi 10f35b: 74 05 je 10f362 *endptr = end; 10f35d: 8b 45 e4 mov -0x1c(%ebp),%eax 10f360: 89 07 mov %eax,(%edi) /* nothing was converted */ if ( end == s ) return RTEMS_NOT_DEFINED; 10f362: 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 ) 10f367: 8b 4d 08 mov 0x8(%ebp),%ecx 10f36a: 39 4d e4 cmp %ecx,-0x1c(%ebp) 10f36d: 74 28 je 10f397 return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 10f36f: 83 fa ff cmp $0xffffffff,%edx 10f372: 75 1c jne 10f390 10f374: 83 fe ff cmp $0xffffffff,%esi 10f377: 75 17 jne 10f390 <== NEVER TAKEN 10f379: 89 55 d4 mov %edx,-0x2c(%ebp) 10f37c: e8 97 26 00 00 call 111a18 <__errno> 10f381: 89 c1 mov %eax,%ecx return RTEMS_INVALID_NUMBER; 10f383: 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)) 10f388: 83 39 22 cmpl $0x22,(%ecx) 10f38b: 8b 55 d4 mov -0x2c(%ebp),%edx 10f38e: 74 07 je 10f397 <== ALWAYS TAKEN #endif #if defined(STRING_TO_POINTER) *n = (STRING_TO_TYPE) (uintptr_t)result; #else *n = (STRING_TO_TYPE) result; 10f390: 89 33 mov %esi,(%ebx) 10f392: 89 53 04 mov %edx,0x4(%ebx) #endif return RTEMS_SUCCESSFUL; 10f395: 31 c0 xor %eax,%eax } 10f397: 8d 65 f4 lea -0xc(%ebp),%esp 10f39a: 5b pop %ebx 10f39b: 5e pop %esi 10f39c: 5f pop %edi 10f39d: c9 leave 10f39e: c3 ret =============================================================================== 0010708c : int rtems_tarfs_load( char *mountpoint, uint8_t *tar_image, size_t tar_size ) { 10708c: 55 push %ebp 10708d: 89 e5 mov %esp,%ebp 10708f: 57 push %edi 107090: 56 push %esi 107091: 53 push %ebx 107092: 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( 107098: 31 c0 xor %eax,%eax 10709a: 83 c9 ff or $0xffffffff,%ecx 10709d: 8b 7d 08 mov 0x8(%ebp),%edi 1070a0: f2 ae repnz scas %es:(%edi),%al 1070a2: f7 d1 not %ecx 1070a4: 49 dec %ecx 1070a5: 6a 00 push $0x0 1070a7: 8d 45 d0 lea -0x30(%ebp),%eax 1070aa: 50 push %eax 1070ab: 6a 00 push $0x0 1070ad: 51 push %ecx 1070ae: ff 75 08 pushl 0x8(%ebp) 1070b1: e8 d4 09 00 00 call 107a8a 1070b6: 89 85 54 fe ff ff mov %eax,-0x1ac(%ebp) strlen(mountpoint), 0, &root_loc, 0 ); if (status != 0) 1070bc: 83 c4 20 add $0x20,%esp 1070bf: 85 c0 test %eax,%eax 1070c1: 0f 85 d9 01 00 00 jne 1072a0 return -1; if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops) 1070c7: 8b 45 dc mov -0x24(%ebp),%eax 1070ca: 31 f6 xor %esi,%esi 1070cc: 3d 24 3c 12 00 cmp $0x123c24,%eax 1070d1: 74 1b je 1070ee 1070d3: 3d 1c 46 12 00 cmp $0x12461c,%eax 1070d8: 0f 85 c2 01 00 00 jne 1072a0 <== ALWAYS TAKEN 1070de: 8b b5 54 fe ff ff mov -0x1ac(%ebp),%esi <== NOT EXECUTED 1070e4: eb 08 jmp 1070ee <== NOT EXECUTED 1070e6: 8b b5 50 fe ff ff mov -0x1b0(%ebp),%esi 1070ec: eb 18 jmp 107106 * should not have this path. */ else if (linkflag == REGTYPE) { const char *name; loc = root_loc; 1070ee: 8d 45 bc lea -0x44(%ebp),%eax 1070f1: 89 85 34 fe ff ff mov %eax,-0x1cc(%ebp) 1070f7: 8d 55 d0 lea -0x30(%ebp),%edx 1070fa: 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); 107100: 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) 107106: 8d 86 00 02 00 00 lea 0x200(%esi),%eax 10710c: 89 85 50 fe ff ff mov %eax,-0x1b0(%ebp) 107112: 8b 55 10 mov 0x10(%ebp),%edx 107115: 39 d0 cmp %edx,%eax 107117: 0f 87 8d 01 00 00 ja 1072aa <== NEVER TAKEN break; /* * Read a header. */ hdr_ptr = (char *) &tar_image[offset]; 10711d: 03 75 0c add 0xc(%ebp),%esi offset += 512; if (strncmp(&hdr_ptr[257], "ustar", 5)) 107120: 8d 86 01 01 00 00 lea 0x101(%esi),%eax 107126: 52 push %edx 107127: 6a 05 push $0x5 107129: 68 6c 3c 12 00 push $0x123c6c 10712e: 50 push %eax 10712f: e8 58 e5 00 00 call 11568c 107134: 83 c4 10 add $0x10,%esp 107137: 85 c0 test %eax,%eax 107139: 0f 85 6b 01 00 00 jne 1072aa break; strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE); 10713f: 50 push %eax 107140: 6a 63 push $0x63 107142: 56 push %esi 107143: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax 107149: 50 push %eax 10714a: e8 cd e5 00 00 call 11571c filename[MAX_NAME_FIELD_SIZE] = '\0'; 10714f: c6 45 bb 00 movb $0x0,-0x45(%ebp) linkflag = hdr_ptr[156]; 107153: 8a 96 9c 00 00 00 mov 0x9c(%esi),%dl file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8); 107159: 59 pop %ecx 10715a: 5f pop %edi 10715b: 6a 08 push $0x8 10715d: 8d 46 64 lea 0x64(%esi),%eax 107160: 50 push %eax 107161: 88 95 44 fe ff ff mov %dl,-0x1bc(%ebp) 107167: e8 64 6d 00 00 call 10ded0 <_rtems_octal2ulong> 10716c: 89 85 48 fe ff ff mov %eax,-0x1b8(%ebp) file_size = _rtems_octal2ulong(&hdr_ptr[124], 12); 107172: 5f pop %edi 107173: 58 pop %eax 107174: 6a 0c push $0xc 107176: 8d 46 7c lea 0x7c(%esi),%eax 107179: 50 push %eax 10717a: e8 51 6d 00 00 call 10ded0 <_rtems_octal2ulong> 10717f: 89 85 4c fe ff ff mov %eax,-0x1b4(%ebp) hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8); 107185: 5a pop %edx 107186: 59 pop %ecx 107187: 6a 08 push $0x8 107189: 8d 86 94 00 00 00 lea 0x94(%esi),%eax 10718f: 50 push %eax 107190: e8 3b 6d 00 00 call 10ded0 <_rtems_octal2ulong> 107195: 89 c7 mov %eax,%edi if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum) 107197: 89 34 24 mov %esi,(%esp) 10719a: e8 5f 6d 00 00 call 10defe <_rtems_tar_header_checksum> 10719f: 83 c4 10 add $0x10,%esp 1071a2: 39 f8 cmp %edi,%eax 1071a4: 8a 95 44 fe ff ff mov -0x1bc(%ebp),%dl 1071aa: 0f 85 fa 00 00 00 jne 1072aa <== 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) { 1071b0: 80 fa 35 cmp $0x35,%dl 1071b3: 75 57 jne 10720c strcpy(full_filename, mountpoint); 1071b5: 50 push %eax 1071b6: 50 push %eax 1071b7: ff 75 08 pushl 0x8(%ebp) 1071ba: 53 push %ebx 1071bb: e8 64 e1 00 00 call 115324 if (full_filename[strlen(full_filename)-1] != '/') 1071c0: 31 c0 xor %eax,%eax 1071c2: 83 c9 ff or $0xffffffff,%ecx 1071c5: 89 df mov %ebx,%edi 1071c7: f2 ae repnz scas %es:(%edi),%al 1071c9: f7 d1 not %ecx 1071cb: 83 c4 10 add $0x10,%esp 1071ce: 80 bc 0d 56 fe ff ff cmpb $0x2f,-0x1aa(%ebp,%ecx,1) 1071d5: 2f 1071d6: 74 10 je 1071e8 <== ALWAYS TAKEN strcat(full_filename, "/"); 1071d8: 57 push %edi <== NOT EXECUTED 1071d9: 57 push %edi <== NOT EXECUTED 1071da: 68 19 fb 11 00 push $0x11fb19 <== NOT EXECUTED 1071df: 53 push %ebx <== NOT EXECUTED 1071e0: e8 8b df 00 00 call 115170 <== NOT EXECUTED 1071e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED strcat(full_filename, filename); 1071e8: 56 push %esi 1071e9: 56 push %esi 1071ea: 8d 95 58 ff ff ff lea -0xa8(%ebp),%edx 1071f0: 52 push %edx 1071f1: 53 push %ebx 1071f2: e8 79 df 00 00 call 115170 mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO); 1071f7: 5a pop %edx 1071f8: 59 pop %ecx 1071f9: 68 ff 01 00 00 push $0x1ff 1071fe: 53 push %ebx 1071ff: e8 58 0f 00 00 call 10815c 107204: 83 c4 10 add $0x10,%esp 107207: e9 da fe ff ff jmp 1070e6 * 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) { 10720c: 80 fa 30 cmp $0x30,%dl 10720f: 0f 85 d1 fe ff ff jne 1070e6 const char *name; loc = root_loc; 107215: b9 05 00 00 00 mov $0x5,%ecx 10721a: 8b bd 34 fe ff ff mov -0x1cc(%ebp),%edi 107220: 8b b5 30 fe ff ff mov -0x1d0(%ebp),%esi 107226: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) { 107228: 50 push %eax 107229: 8d 45 e4 lea -0x1c(%ebp),%eax 10722c: 50 push %eax 10722d: 8d 55 bc lea -0x44(%ebp),%edx 107230: 52 push %edx 107231: 8d 85 58 ff ff ff lea -0xa8(%ebp),%eax 107237: 50 push %eax 107238: e8 bf 77 00 00 call 10e9fc 10723d: 83 c4 10 add $0x10,%esp 107240: 85 c0 test %eax,%eax 107242: 75 41 jne 107285 <== NEVER TAKEN node = IMFS_create_node( 107244: 83 ec 0c sub $0xc,%esp 107247: 6a 00 push $0x0 &loc, IMFS_LINEAR_FILE, (char *)name, (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG, 107249: 8b 85 48 fe ff ff mov -0x1b8(%ebp),%eax 10724f: 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( 107254: 80 cc 80 or $0x80,%ah 107257: 50 push %eax 107258: ff 75 e4 pushl -0x1c(%ebp) 10725b: 6a 06 push $0x6 10725d: 8d 55 bc lea -0x44(%ebp),%edx 107260: 52 push %edx 107261: e8 89 72 00 00 call 10e4ef &loc, IMFS_LINEAR_FILE, (char *)name, (file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG, NULL ); node->info.linearfile.size = file_size; 107266: 8b 95 4c fe ff ff mov -0x1b4(%ebp),%edx 10726c: 89 50 50 mov %edx,0x50(%eax) 10726f: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.linearfile.direct = &tar_image[offset]; 107276: 8b 55 0c mov 0xc(%ebp),%edx 107279: 03 95 50 fe ff ff add -0x1b0(%ebp),%edx 10727f: 89 50 58 mov %edx,0x58(%eax) 107282: 83 c4 20 add $0x20,%esp } nblocks = (((file_size) + 511) & ~511) / 512; 107285: 8b 85 4c fe ff ff mov -0x1b4(%ebp),%eax 10728b: 05 ff 01 00 00 add $0x1ff,%eax offset += 512 * nblocks; 107290: 25 00 fe ff ff and $0xfffffe00,%eax 107295: 01 85 50 fe ff ff add %eax,-0x1b0(%ebp) 10729b: e9 46 fe ff ff jmp 1070e6 ); if (status != 0) return -1; if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops) return -1; 1072a0: c7 85 54 fe ff ff ff movl $0xffffffff,-0x1ac(%ebp) 1072a7: ff ff ff nblocks = (((file_size) + 511) & ~511) / 512; offset += 512 * nblocks; } } return status; } 1072aa: 8b 85 54 fe ff ff mov -0x1ac(%ebp),%eax 1072b0: 8d 65 f4 lea -0xc(%ebp),%esp 1072b3: 5b pop %ebx 1072b4: 5e pop %esi 1072b5: 5f pop %edi 1072b6: c9 leave 1072b7: c3 ret =============================================================================== 00110cdc : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 110cdc: 55 push %ebp 110cdd: 89 e5 mov %esp,%ebp 110cdf: 57 push %edi 110ce0: 56 push %esi 110ce1: 53 push %ebx 110ce2: 83 ec 1c sub $0x1c,%esp 110ce5: 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; 110ce8: 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 ) 110ced: 85 c9 test %ecx,%ecx 110cef: 0f 84 fb 00 00 00 je 110df0 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 110cf5: 8b 35 34 48 12 00 mov 0x124834,%esi api = executing->API_Extensions[ THREAD_API_RTEMS ]; 110cfb: 8b 9e f4 00 00 00 mov 0xf4(%esi),%ebx asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 110d01: 80 7e 74 01 cmpb $0x1,0x74(%esi) 110d05: 19 ff sbb %edi,%edi 110d07: 81 e7 00 01 00 00 and $0x100,%edi if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 110d0d: 83 7e 7c 00 cmpl $0x0,0x7c(%esi) 110d11: 74 06 je 110d19 old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 110d13: 81 cf 00 02 00 00 or $0x200,%edi old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 110d19: 80 7b 08 01 cmpb $0x1,0x8(%ebx) 110d1d: 19 d2 sbb %edx,%edx 110d1f: 81 e2 00 04 00 00 and $0x400,%edx old_mode |= _ISR_Get_level(); 110d25: 89 55 e4 mov %edx,-0x1c(%ebp) 110d28: 89 4d e0 mov %ecx,-0x20(%ebp) 110d2b: e8 65 c5 ff ff call 10d295 <_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; 110d30: 8b 55 e4 mov -0x1c(%ebp),%edx 110d33: 09 d0 or %edx,%eax old_mode |= _ISR_Get_level(); 110d35: 09 f8 or %edi,%eax 110d37: 8b 4d e0 mov -0x20(%ebp),%ecx 110d3a: 89 01 mov %eax,(%ecx) *previous_mode_set = old_mode; /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 110d3c: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) 110d43: 74 0b je 110d50 executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false; 110d45: f7 45 08 00 01 00 00 testl $0x100,0x8(%ebp) 110d4c: 0f 94 46 74 sete 0x74(%esi) if ( mask & RTEMS_TIMESLICE_MASK ) { 110d50: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 110d57: 74 21 je 110d7a if ( _Modes_Is_timeslice(mode_set) ) { 110d59: f7 45 08 00 02 00 00 testl $0x200,0x8(%ebp) 110d60: 74 11 je 110d73 executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 110d62: c7 46 7c 01 00 00 00 movl $0x1,0x7c(%esi) executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 110d69: a1 b4 42 12 00 mov 0x1242b4,%eax 110d6e: 89 46 78 mov %eax,0x78(%esi) 110d71: eb 07 jmp 110d7a } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 110d73: c7 46 7c 00 00 00 00 movl $0x0,0x7c(%esi) } /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 110d7a: f6 45 0c 01 testb $0x1,0xc(%ebp) 110d7e: 74 0a je 110d8a */ RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level ( Modes_Control mode_set ) { _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) ); 110d80: f6 45 08 01 testb $0x1,0x8(%ebp) 110d84: 74 03 je 110d89 110d86: fa cli 110d87: eb 01 jmp 110d8a 110d89: fb sti /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 110d8a: 31 c9 xor %ecx,%ecx if ( mask & RTEMS_ASR_MASK ) { 110d8c: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 110d93: 74 2a je 110dbf * Output: * *previous_mode_set - previous mode set * always return RTEMS_SUCCESSFUL; */ rtems_status_code rtems_task_mode( 110d95: f7 45 08 00 04 00 00 testl $0x400,0x8(%ebp) 110d9c: 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 ) { 110d9f: 3a 43 08 cmp 0x8(%ebx),%al 110da2: 74 1b je 110dbf asr->is_enabled = is_asr_enabled; 110da4: 88 43 08 mov %al,0x8(%ebx) ) { rtems_signal_set _signals; ISR_Level _level; _ISR_Disable( _level ); 110da7: 9c pushf 110da8: fa cli 110da9: 58 pop %eax _signals = information->signals_pending; 110daa: 8b 53 18 mov 0x18(%ebx),%edx information->signals_pending = information->signals_posted; 110dad: 8b 4b 14 mov 0x14(%ebx),%ecx 110db0: 89 4b 18 mov %ecx,0x18(%ebx) information->signals_posted = _signals; 110db3: 89 53 14 mov %edx,0x14(%ebx) _ISR_Enable( _level ); 110db6: 50 push %eax 110db7: 9d popf /* * This is specific to the RTEMS API */ is_asr_enabled = false; needs_asr_dispatching = false; 110db8: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 110dbc: 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; 110dbf: 31 c0 xor %eax,%eax needs_asr_dispatching = true; } } } if ( _System_state_Is_up( _System_state_Get() ) ) { 110dc1: 83 3d 64 44 12 00 03 cmpl $0x3,0x124464 110dc8: 75 26 jne 110df0 <== NEVER TAKEN bool are_signals_pending ) { Thread_Control *executing; executing = _Thread_Executing; 110dca: 8b 15 34 48 12 00 mov 0x124834,%edx if ( are_signals_pending || 110dd0: 84 c9 test %cl,%cl 110dd2: 75 0e jne 110de2 110dd4: 3b 15 38 48 12 00 cmp 0x124838,%edx 110dda: 74 14 je 110df0 (!_Thread_Is_heir( executing ) && executing->is_preemptible) ) { 110ddc: 80 7a 74 00 cmpb $0x0,0x74(%edx) 110de0: 74 0e je 110df0 <== NEVER TAKEN _Thread_Dispatch_necessary = true; 110de2: c6 05 40 48 12 00 01 movb $0x1,0x124840 if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) ) _Thread_Dispatch(); 110de9: e8 a6 af ff ff call 10bd94 <_Thread_Dispatch> } return RTEMS_SUCCESSFUL; 110dee: 31 c0 xor %eax,%eax } 110df0: 83 c4 1c add $0x1c,%esp 110df3: 5b pop %ebx 110df4: 5e pop %esi 110df5: 5f pop %edi 110df6: c9 leave 110df7: c3 ret =============================================================================== 0010dd34 : rtems_status_code rtems_task_set_priority( rtems_id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10dd34: 55 push %ebp 10dd35: 89 e5 mov %esp,%ebp 10dd37: 56 push %esi 10dd38: 53 push %ebx 10dd39: 83 ec 10 sub $0x10,%esp 10dd3c: 8b 5d 0c mov 0xc(%ebp),%ebx 10dd3f: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10dd42: 85 db test %ebx,%ebx 10dd44: 74 10 je 10dd56 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 ) ); 10dd46: 0f b6 15 f4 41 12 00 movzbl 0x1241f4,%edx !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; 10dd4d: b8 13 00 00 00 mov $0x13,%eax ) { register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10dd52: 39 d3 cmp %edx,%ebx 10dd54: 77 52 ja 10dda8 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) return RTEMS_INVALID_ADDRESS; 10dd56: 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 ) 10dd5b: 85 f6 test %esi,%esi 10dd5d: 74 49 je 10dda8 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10dd5f: 51 push %ecx 10dd60: 51 push %ecx 10dd61: 8d 45 f4 lea -0xc(%ebp),%eax 10dd64: 50 push %eax 10dd65: ff 75 08 pushl 0x8(%ebp) 10dd68: e8 f7 1b 00 00 call 10f964 <_Thread_Get> switch ( location ) { 10dd6d: 83 c4 10 add $0x10,%esp 10dd70: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10dd74: 75 2d jne 10dda3 case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10dd76: 8b 50 14 mov 0x14(%eax),%edx 10dd79: 89 16 mov %edx,(%esi) if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10dd7b: 85 db test %ebx,%ebx 10dd7d: 74 1b je 10dd9a the_thread->real_priority = new_priority; 10dd7f: 89 58 18 mov %ebx,0x18(%eax) if ( the_thread->resource_count == 0 || 10dd82: 83 78 1c 00 cmpl $0x0,0x1c(%eax) 10dd86: 74 05 je 10dd8d 10dd88: 39 58 14 cmp %ebx,0x14(%eax) 10dd8b: 76 0d jbe 10dd9a <== ALWAYS TAKEN the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, false ); 10dd8d: 52 push %edx 10dd8e: 6a 00 push $0x0 10dd90: 53 push %ebx 10dd91: 50 push %eax 10dd92: e8 19 17 00 00 call 10f4b0 <_Thread_Change_priority> 10dd97: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10dd9a: e8 a3 1b 00 00 call 10f942 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 10dd9f: 31 c0 xor %eax,%eax 10dda1: eb 05 jmp 10dda8 case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 10dda3: b8 04 00 00 00 mov $0x4,%eax } 10dda8: 8d 65 f8 lea -0x8(%ebp),%esp 10ddab: 5b pop %ebx 10ddac: 5e pop %esi 10ddad: c9 leave 10ddae: 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 dc 41 12 00 pushl 0x1241dc 10851f: e8 40 1c 00 00 call 10a164 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 98 3e 12 00 mov 0x123e98(%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 fe 1b 00 00 call 10a164 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 d1 1c 00 00 call 10a250 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 62 17 00 00 call 109cfc 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 4c 17 00 00 call 109cfc 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 6c 21 00 00 call 10a72c <== 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 e0 41 12 00 mov %eax,0x1241e0 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 rtems_termios_ttyHead = tty->forw; 1085fd: a3 e4 41 12 00 mov %eax,0x1241e4 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 b8 1a 00 00 call 10a0d4 rtems_semaphore_delete (tty->osem); 10861c: 59 pop %ecx 10861d: ff 73 18 pushl 0x18(%ebx) 108620: e8 af 1a 00 00 call 10a0d4 rtems_semaphore_delete (tty->rawOutBuf.Semaphore); 108625: 5a pop %edx 108626: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 10862c: e8 a3 1a 00 00 call 10a0d4 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 83 1a 00 00 call 10a0d4 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 dc 41 12 00 pushl 0x1241dc 108685: e8 c6 1b 00 00 call 10a250 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 92 04 00 00 call 109cfc 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 b2 0e 00 00 call 10a72c <== 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 48 3f 12 00 mov 0x123f48,%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 a4 3e 12 00 00 cmpl $0x0,0x123ea4(%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 a4 3e 12 00 call *0x123ea4(%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 b3 0c 00 00 call 10a250 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 8b 1a 00 00 call 10a164 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 ac 3e 12 00 mov 0x123eac(%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 1087f8: f6 43 31 10 testb $0x10,0x31(%ebx) 1087fc: 75 1e jne 10881c <== ALWAYS TAKEN /* 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 6b 12 00 00 call 109b24 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 98 3e 12 00 mov 0x123e98(%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 94 3e 12 00 mov 0x123e94(%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 69 18 00 00 call 10a250 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 dc 41 12 00 pushl 0x1241dc 1080f4: e8 6b 20 00 00 call 10a164 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 e4 41 12 00 mov 0x1241e4,%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 44 20 12 00 mov 0x122044,%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 dc 41 12 00 pushl 0x1241dc 10816b: e8 e0 20 00 00 call 10a250 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 48 20 12 00 mov 0x122048,%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 40 20 12 00 pushl 0x122040 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 e4 41 12 00 mov %ebx,0x1241e4 if (rtems_termios_ttyTail == NULL) 108233: 83 3d e0 41 12 00 00 cmpl $0x0,0x1241e0 10823a: 75 06 jne 108242 rtems_termios_ttyTail = tty; 10823c: 89 1d e0 41 12 00 mov %ebx,0x1241e0 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 4c 20 12 00 movsbl 0x12204c,%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 cc 1c 00 00 call 109f3c 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 4c 20 12 00 movsbl 0x12204c,%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 9c 1c 00 00 call 109f3c 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 4c 20 12 00 movsbl 0x12204c,%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 69 1c 00 00 call 109f3c 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 4c 20 12 00 movsbl 0x12204c,%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 b0 1f 00 00 call 10a2e0 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 4c 20 12 00 movsbl 0x12204c,%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 76 1f 00 00 call 10a2e0 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 4c 20 12 00 movsbl 0x12204c,%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 90 1b 00 00 call 109f3c 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 4c 20 12 00 mov 0x12204c,%al 108437: 8d 48 01 lea 0x1(%eax),%ecx 10843a: 88 0d 4c 20 12 00 mov %cl,0x12204c 108440: 3c 7a cmp $0x7a,%al 108442: 75 07 jne 10844b c = 'a'; 108444: c6 05 4c 20 12 00 61 movb $0x61,0x12204c } 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 b7 20 00 00 call 10a554 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 9b 20 00 00 call 10a554 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 63 22 00 00 call 10a72c } } rtems_semaphore_release (rtems_termios_ttyMutex); 1084c9: 83 ec 0c sub $0xc,%esp 1084cc: ff 35 dc 41 12 00 pushl 0x1241dc 1084d2: e8 79 1d 00 00 call 10a250 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 e0 16 00 00 call 10a164 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 95 1c 00 00 call 10a72c <== 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 16 11 00 00 call 10a164 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 9c 3e 12 00 mov 0x123e9c(%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 d3 14 00 00 call 10a5b8 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 36 0a 00 00 call 109b38 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 fe 09 00 00 call 109b38 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 69 14 00 00 call 10a5b8 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 40 20 12 00 mov 0x122040,%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 c5 0e 00 00 call 10a164 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 5a 0f 00 00 call 10a250 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 86 0b 00 00 call 10a250 <== 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 37 0b 00 00 call 10a250 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 d4 05 00 00 call 109b9c (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 33 0e 00 00 call 10a418 <== 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 a6 03 00 00 call 109b9c (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 05 0c 00 00 call 10a418 <== 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 a8 3e 12 00 mov 0x123ea8(%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 c9 11 00 00 call 10a164 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 a0 3e 12 00 mov 0x123ea0(%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 38 12 00 00 call 10a250 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 =============================================================================== 00116394 : */ rtems_status_code rtems_timer_cancel( rtems_id id ) { 116394: 55 push %ebp 116395: 89 e5 mov %esp,%ebp 116397: 83 ec 1c sub $0x1c,%esp Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); 11639a: 8d 45 f4 lea -0xc(%ebp),%eax Objects_Id id, Objects_Locations *location ) { return (Timer_Control *) _Objects_Get( &_Timer_Information, id, location ); 11639d: 50 push %eax 11639e: ff 75 08 pushl 0x8(%ebp) 1163a1: 68 04 e0 13 00 push $0x13e004 1163a6: e8 4d 27 00 00 call 118af8 <_Objects_Get> switch ( location ) { 1163ab: 83 c4 10 add $0x10,%esp 1163ae: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 1163b2: 75 1e jne 1163d2 case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 1163b4: 83 78 38 04 cmpl $0x4,0x38(%eax) 1163b8: 74 0f je 1163c9 <== NEVER TAKEN (void) _Watchdog_Remove( &the_timer->Ticker ); 1163ba: 83 ec 0c sub $0xc,%esp 1163bd: 83 c0 10 add $0x10,%eax 1163c0: 50 push %eax 1163c1: e8 4e 41 00 00 call 11a514 <_Watchdog_Remove> 1163c6: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 1163c9: e8 08 2f 00 00 call 1192d6 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1163ce: 31 c0 xor %eax,%eax 1163d0: eb 05 jmp 1163d7 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1163d2: b8 04 00 00 00 mov $0x4,%eax } 1163d7: c9 leave 1163d8: c3 ret =============================================================================== 001167f4 : rtems_id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 1167f4: 55 push %ebp 1167f5: 89 e5 mov %esp,%ebp 1167f7: 57 push %edi 1167f8: 56 push %esi 1167f9: 53 push %ebx 1167fa: 83 ec 1c sub $0x1c,%esp 1167fd: 8b 7d 0c mov 0xc(%ebp),%edi Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; Timer_server_Control *timer_server = _Timer_server; 116800: 8b 35 44 e0 13 00 mov 0x13e044,%esi if ( !timer_server ) return RTEMS_INCORRECT_STATE; 116806: 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 ) 11680b: 85 f6 test %esi,%esi 11680d: 0f 84 b1 00 00 00 je 1168c4 return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; 116813: b3 0b mov $0xb,%bl Timer_server_Control *timer_server = _Timer_server; if ( !timer_server ) return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 116815: 80 3d cc d6 13 00 00 cmpb $0x0,0x13d6cc 11681c: 0f 84 a2 00 00 00 je 1168c4 <== NEVER TAKEN return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; 116822: b3 09 mov $0x9,%bl return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) 116824: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 116828: 0f 84 96 00 00 00 je 1168c4 return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 11682e: 83 ec 0c sub $0xc,%esp 116831: 57 push %edi 116832: e8 b5 d6 ff ff call 113eec <_TOD_Validate> 116837: 83 c4 10 add $0x10,%esp return RTEMS_INVALID_CLOCK; 11683a: b3 14 mov $0x14,%bl return RTEMS_NOT_DEFINED; if ( !routine ) return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 11683c: 84 c0 test %al,%al 11683e: 0f 84 80 00 00 00 je 1168c4 return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 116844: 83 ec 0c sub $0xc,%esp 116847: 57 push %edi 116848: e8 37 d6 ff ff call 113e84 <_TOD_To_seconds> 11684d: 89 c7 mov %eax,%edi if ( seconds <= _TOD_Seconds_since_epoch() ) 11684f: 83 c4 10 add $0x10,%esp 116852: 3b 05 44 d7 13 00 cmp 0x13d744,%eax 116858: 76 6a jbe 1168c4 11685a: 51 push %ecx return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); 11685b: 8d 45 e4 lea -0x1c(%ebp),%eax 11685e: 50 push %eax 11685f: ff 75 08 pushl 0x8(%ebp) 116862: 68 04 e0 13 00 push $0x13e004 116867: e8 8c 22 00 00 call 118af8 <_Objects_Get> 11686c: 89 c3 mov %eax,%ebx switch ( location ) { 11686e: 83 c4 10 add $0x10,%esp 116871: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 116875: 75 48 jne 1168bf case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 116877: 83 ec 0c sub $0xc,%esp 11687a: 8d 40 10 lea 0x10(%eax),%eax 11687d: 50 push %eax 11687e: e8 91 3c 00 00 call 11a514 <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 116883: 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; 11688a: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) the_watchdog->routine = routine; 116891: 8b 45 10 mov 0x10(%ebp),%eax 116894: 89 43 2c mov %eax,0x2c(%ebx) the_watchdog->id = id; 116897: 8b 45 08 mov 0x8(%ebp),%eax 11689a: 89 43 30 mov %eax,0x30(%ebx) the_watchdog->user_data = user_data; 11689d: 8b 45 14 mov 0x14(%ebp),%eax 1168a0: 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(); 1168a3: 2b 3d 44 d7 13 00 sub 0x13d744,%edi 1168a9: 89 7b 1c mov %edi,0x1c(%ebx) (*timer_server->schedule_operation)( timer_server, the_timer ); 1168ac: 58 pop %eax 1168ad: 5a pop %edx 1168ae: 53 push %ebx 1168af: 56 push %esi 1168b0: ff 56 04 call *0x4(%esi) _Thread_Enable_dispatch(); 1168b3: e8 1e 2a 00 00 call 1192d6 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; 1168b8: 83 c4 10 add $0x10,%esp 1168bb: 31 db xor %ebx,%ebx 1168bd: eb 05 jmp 1168c4 #endif case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; 1168bf: bb 04 00 00 00 mov $0x4,%ebx } 1168c4: 89 d8 mov %ebx,%eax 1168c6: 8d 65 f4 lea -0xc(%ebp),%esp 1168c9: 5b pop %ebx 1168ca: 5e pop %esi 1168cb: 5f pop %edi 1168cc: c9 leave 1168cd: c3 ret =============================================================================== 0010b155 : static int rtems_verror( rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) { 10b155: 55 push %ebp 10b156: 89 e5 mov %esp,%ebp 10b158: 57 push %edi 10b159: 56 push %esi 10b15a: 53 push %ebx 10b15b: 83 ec 1c sub $0x1c,%esp 10b15e: 89 c3 mov %eax,%ebx 10b160: 89 55 e4 mov %edx,-0x1c(%ebp) 10b163: 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) { 10b166: a9 00 00 00 20 test $0x20000000,%eax 10b16b: 74 2c je 10b199 if (rtems_panic_in_progress++) 10b16d: a1 08 a3 12 00 mov 0x12a308,%eax 10b172: 8d 50 01 lea 0x1(%eax),%edx 10b175: 89 15 08 a3 12 00 mov %edx,0x12a308 10b17b: 85 c0 test %eax,%eax 10b17d: 74 0b je 10b18a <== ALWAYS TAKEN rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b17f: a1 58 a4 12 00 mov 0x12a458,%eax <== NOT EXECUTED 10b184: 40 inc %eax <== NOT EXECUTED 10b185: a3 58 a4 12 00 mov %eax,0x12a458 <== NOT EXECUTED _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) return 0; 10b18a: 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) 10b18c: 83 3d 08 a3 12 00 02 cmpl $0x2,0x12a308 10b193: 0f 8f da 00 00 00 jg 10b273 <== NEVER TAKEN return 0; } (void) fflush(stdout); /* in case stdout/stderr same */ 10b199: 83 ec 0c sub $0xc,%esp 10b19c: a1 a0 81 12 00 mov 0x1281a0,%eax 10b1a1: ff 70 08 pushl 0x8(%eax) 10b1a4: e8 43 ab 00 00 call 115cec status = error_flag & ~RTEMS_ERROR_MASK; 10b1a9: 89 df mov %ebx,%edi 10b1ab: 81 e7 ff ff ff 8f and $0x8fffffff,%edi if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 10b1b1: 83 c4 10 add $0x10,%esp rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) { int local_errno = 0; 10b1b4: 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? */ 10b1b6: 81 e3 00 00 00 40 and $0x40000000,%ebx 10b1bc: 74 07 je 10b1c5 local_errno = errno; 10b1be: e8 91 a7 00 00 call 115954 <__errno> 10b1c3: 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); 10b1c5: 53 push %ebx 10b1c6: ff 75 e0 pushl -0x20(%ebp) 10b1c9: ff 75 e4 pushl -0x1c(%ebp) 10b1cc: a1 a0 81 12 00 mov 0x1281a0,%eax 10b1d1: ff 70 0c pushl 0xc(%eax) 10b1d4: e8 77 09 01 00 call 11bb50 10b1d9: 89 c3 mov %eax,%ebx if (status) 10b1db: 83 c4 10 add $0x10,%esp 10b1de: 85 ff test %edi,%edi 10b1e0: 74 24 je 10b206 chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); 10b1e2: 83 ec 0c sub $0xc,%esp 10b1e5: 57 push %edi 10b1e6: e8 55 ff ff ff call 10b140 10b1eb: 83 c4 0c add $0xc,%esp 10b1ee: 50 push %eax 10b1ef: 68 27 3b 12 00 push $0x123b27 10b1f4: a1 a0 81 12 00 mov 0x1281a0,%eax 10b1f9: ff 70 0c pushl 0xc(%eax) 10b1fc: e8 df ae 00 00 call 1160e0 #endif chars_written += vfprintf(stderr, printf_format, arglist); if (status) chars_written += 10b201: 01 c3 add %eax,%ebx 10b203: 83 c4 10 add $0x10,%esp fprintf(stderr, " (status: %s)", rtems_status_text(status)); if (local_errno) { 10b206: 83 fe 00 cmp $0x0,%esi 10b209: 74 40 je 10b24b if ((local_errno > 0) && *strerror(local_errno)) 10b20b: 7e 25 jle 10b232 10b20d: 83 ec 0c sub $0xc,%esp 10b210: 56 push %esi 10b211: e8 76 b7 00 00 call 11698c 10b216: 83 c4 10 add $0x10,%esp 10b219: 80 38 00 cmpb $0x0,(%eax) 10b21c: 74 14 je 10b232 <== NEVER TAKEN chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); 10b21e: 83 ec 0c sub $0xc,%esp 10b221: 56 push %esi 10b222: e8 65 b7 00 00 call 11698c 10b227: 83 c4 0c add $0xc,%esp 10b22a: 50 push %eax 10b22b: 68 35 3b 12 00 push $0x123b35 10b230: eb 07 jmp 10b239 else chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno); 10b232: 51 push %ecx 10b233: 56 push %esi 10b234: 68 42 3b 12 00 push $0x123b42 10b239: a1 a0 81 12 00 mov 0x1281a0,%eax 10b23e: ff 70 0c pushl 0xc(%eax) 10b241: e8 9a ae 00 00 call 1160e0 10b246: 01 c3 add %eax,%ebx 10b248: 83 c4 10 add $0x10,%esp } chars_written += fprintf(stderr, "\n"); 10b24b: 52 push %edx 10b24c: 52 push %edx 10b24d: 68 b4 42 12 00 push $0x1242b4 10b252: a1 a0 81 12 00 mov 0x1281a0,%eax 10b257: ff 70 0c pushl 0xc(%eax) 10b25a: e8 81 ae 00 00 call 1160e0 10b25f: 8d 34 18 lea (%eax,%ebx,1),%esi (void) fflush(stderr); 10b262: 58 pop %eax 10b263: a1 a0 81 12 00 mov 0x1281a0,%eax 10b268: ff 70 0c pushl 0xc(%eax) 10b26b: e8 7c aa 00 00 call 115cec return chars_written; 10b270: 83 c4 10 add $0x10,%esp } 10b273: 89 f0 mov %esi,%eax 10b275: 8d 65 f4 lea -0xc(%ebp),%esp 10b278: 5b pop %ebx 10b279: 5e pop %esi 10b27a: 5f pop %edi 10b27b: c9 leave 10b27c: 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 20 41 12 00 pushl 0x124120 <== NOT EXECUTED 107960: e8 df be 00 00 call 113844 <__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 08 41 12 00 mov 0x124108,%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 =============================================================================== 0010a8f0 : #include int sched_get_priority_max( int policy ) { 10a8f0: 55 push %ebp 10a8f1: 89 e5 mov %esp,%ebp 10a8f3: 83 ec 08 sub $0x8,%esp 10a8f6: 8b 4d 08 mov 0x8(%ebp),%ecx switch ( policy ) { 10a8f9: 83 f9 04 cmp $0x4,%ecx 10a8fc: 77 0b ja 10a909 10a8fe: b8 01 00 00 00 mov $0x1,%eax 10a903: d3 e0 shl %cl,%eax 10a905: a8 17 test $0x17,%al 10a907: 75 10 jne 10a919 <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a909: e8 ae 73 00 00 call 111cbc <__errno> 10a90e: c7 00 16 00 00 00 movl $0x16,(%eax) 10a914: 83 c8 ff or $0xffffffff,%eax 10a917: eb 08 jmp 10a921 } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; 10a919: 0f b6 05 18 12 12 00 movzbl 0x121218,%eax 10a920: 48 dec %eax } 10a921: c9 leave 10a922: c3 ret =============================================================================== 0010a924 : #include int sched_get_priority_min( int policy ) { 10a924: 55 push %ebp 10a925: 89 e5 mov %esp,%ebp 10a927: 83 ec 08 sub $0x8,%esp 10a92a: 8b 4d 08 mov 0x8(%ebp),%ecx switch ( policy ) { 10a92d: 83 f9 04 cmp $0x4,%ecx 10a930: 77 11 ja 10a943 10a932: ba 01 00 00 00 mov $0x1,%edx 10a937: d3 e2 shl %cl,%edx default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MINIMUM_PRIORITY; 10a939: b8 01 00 00 00 mov $0x1,%eax int sched_get_priority_min( int policy ) { switch ( policy ) { 10a93e: 80 e2 17 and $0x17,%dl 10a941: 75 0e jne 10a951 <== ALWAYS TAKEN case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10a943: e8 74 73 00 00 call 111cbc <__errno> 10a948: c7 00 16 00 00 00 movl $0x16,(%eax) 10a94e: 83 c8 ff or $0xffffffff,%eax } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 10a951: c9 leave 10a952: c3 ret =============================================================================== 0010a954 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 10a954: 55 push %ebp 10a955: 89 e5 mov %esp,%ebp 10a957: 56 push %esi 10a958: 53 push %ebx 10a959: 8b 75 08 mov 0x8(%ebp),%esi 10a95c: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10a95f: 85 f6 test %esi,%esi 10a961: 74 16 je 10a979 <== NEVER TAKEN 10a963: e8 b8 d0 ff ff call 107a20 10a968: 39 c6 cmp %eax,%esi 10a96a: 74 0d je 10a979 rtems_set_errno_and_return_minus_one( ESRCH ); 10a96c: e8 4b 73 00 00 call 111cbc <__errno> 10a971: c7 00 03 00 00 00 movl $0x3,(%eax) 10a977: eb 0f jmp 10a988 if ( !interval ) 10a979: 85 db test %ebx,%ebx 10a97b: 75 10 jne 10a98d rtems_set_errno_and_return_minus_one( EINVAL ); 10a97d: e8 3a 73 00 00 call 111cbc <__errno> 10a982: c7 00 16 00 00 00 movl $0x16,(%eax) 10a988: 83 c8 ff or $0xffffffff,%eax 10a98b: eb 13 jmp 10a9a0 _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 10a98d: 50 push %eax 10a98e: 50 push %eax 10a98f: 53 push %ebx 10a990: ff 35 a4 52 12 00 pushl 0x1252a4 10a996: e8 a1 2f 00 00 call 10d93c <_Timespec_From_ticks> return 0; 10a99b: 83 c4 10 add $0x10,%esp 10a99e: 31 c0 xor %eax,%eax } 10a9a0: 8d 65 f8 lea -0x8(%ebp),%esp 10a9a3: 5b pop %ebx 10a9a4: 5e pop %esi 10a9a5: c9 leave 10a9a6: c3 ret =============================================================================== 0010d040 : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 10d040: 55 push %ebp 10d041: 89 e5 mov %esp,%ebp 10d043: 57 push %edi 10d044: 56 push %esi 10d045: 53 push %ebx 10d046: 83 ec 2c sub $0x2c,%esp 10d049: 8b 75 08 mov 0x8(%ebp),%esi rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10d04c: a1 cc a4 12 00 mov 0x12a4cc,%eax 10d051: 40 inc %eax 10d052: a3 cc a4 12 00 mov %eax,0x12a4cc va_list arg; mode_t mode; unsigned int value = 0; 10d057: 31 ff xor %edi,%edi POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10d059: 8b 45 0c mov 0xc(%ebp),%eax 10d05c: 25 00 02 00 00 and $0x200,%eax 10d061: 89 45 d4 mov %eax,-0x2c(%ebp) 10d064: 74 03 je 10d069 va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); 10d066: 8b 7d 14 mov 0x14(%ebp),%edi va_end(arg); } status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 10d069: 52 push %edx 10d06a: 52 push %edx 10d06b: 8d 45 e4 lea -0x1c(%ebp),%eax 10d06e: 50 push %eax 10d06f: 56 push %esi 10d070: e8 9b 58 00 00 call 112910 <_POSIX_Semaphore_Name_to_id> 10d075: 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 ) { 10d077: 83 c4 10 add $0x10,%esp 10d07a: 85 c0 test %eax,%eax 10d07c: 74 19 je 10d097 /* * 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) ) ) { 10d07e: 83 f8 02 cmp $0x2,%eax 10d081: 75 06 jne 10d089 <== NEVER TAKEN 10d083: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 10d087: 75 59 jne 10d0e2 _Thread_Enable_dispatch(); 10d089: e8 68 25 00 00 call 10f5f6 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 10d08e: e8 45 7f 00 00 call 114fd8 <__errno> 10d093: 89 18 mov %ebx,(%eax) 10d095: eb 1f jmp 10d0b6 /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10d097: 8b 45 0c mov 0xc(%ebp),%eax 10d09a: 25 00 0a 00 00 and $0xa00,%eax 10d09f: 3d 00 0a 00 00 cmp $0xa00,%eax 10d0a4: 75 15 jne 10d0bb _Thread_Enable_dispatch(); 10d0a6: e8 4b 25 00 00 call 10f5f6 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 10d0ab: e8 28 7f 00 00 call 114fd8 <__errno> 10d0b0: c7 00 11 00 00 00 movl $0x11,(%eax) 10d0b6: 83 c8 ff or $0xffffffff,%eax 10d0b9: eb 4a jmp 10d105 10d0bb: 50 push %eax } the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); 10d0bc: 8d 45 dc lea -0x24(%ebp),%eax 10d0bf: 50 push %eax 10d0c0: ff 75 e4 pushl -0x1c(%ebp) 10d0c3: 68 98 a7 12 00 push $0x12a798 10d0c8: e8 d7 1c 00 00 call 10eda4 <_Objects_Get> 10d0cd: 89 45 e0 mov %eax,-0x20(%ebp) the_semaphore->open_count += 1; 10d0d0: ff 40 18 incl 0x18(%eax) _Thread_Enable_dispatch(); 10d0d3: e8 1e 25 00 00 call 10f5f6 <_Thread_Enable_dispatch> _Thread_Enable_dispatch(); 10d0d8: e8 19 25 00 00 call 10f5f6 <_Thread_Enable_dispatch> goto return_id; 10d0dd: 83 c4 10 add $0x10,%esp 10d0e0: eb 1d jmp 10d0ff /* * 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( 10d0e2: 8d 45 e0 lea -0x20(%ebp),%eax 10d0e5: 50 push %eax 10d0e6: 57 push %edi 10d0e7: 6a 00 push $0x0 10d0e9: 56 push %esi 10d0ea: e8 ed 56 00 00 call 1127dc <_POSIX_Semaphore_Create_support> 10d0ef: 89 c3 mov %eax,%ebx /* * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); 10d0f1: e8 00 25 00 00 call 10f5f6 <_Thread_Enable_dispatch> if ( status == -1 ) 10d0f6: 83 c4 10 add $0x10,%esp return SEM_FAILED; 10d0f9: 83 c8 ff or $0xffffffff,%eax * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); if ( status == -1 ) 10d0fc: 43 inc %ebx 10d0fd: 74 06 je 10d105 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; 10d0ff: 8b 45 e0 mov -0x20(%ebp),%eax 10d102: 83 c0 08 add $0x8,%eax #endif return id; } 10d105: 8d 65 f4 lea -0xc(%ebp),%esp 10d108: 5b pop %ebx 10d109: 5e pop %esi 10d10a: 5f pop %edi 10d10b: c9 leave 10d10c: c3 ret =============================================================================== 0010a7cc : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 10a7cc: 55 push %ebp 10a7cd: 89 e5 mov %esp,%ebp 10a7cf: 57 push %edi 10a7d0: 56 push %esi 10a7d1: 53 push %ebx 10a7d2: 83 ec 1c sub $0x1c,%esp 10a7d5: 8b 5d 08 mov 0x8(%ebp),%ebx 10a7d8: 8b 55 0c mov 0xc(%ebp),%edx 10a7db: 8b 45 10 mov 0x10(%ebp),%eax ISR_Level level; if ( oact ) 10a7de: 85 c0 test %eax,%eax 10a7e0: 74 12 je 10a7f4 *oact = _POSIX_signals_Vectors[ sig ]; 10a7e2: 6b f3 0c imul $0xc,%ebx,%esi 10a7e5: 81 c6 84 68 12 00 add $0x126884,%esi 10a7eb: b9 03 00 00 00 mov $0x3,%ecx 10a7f0: 89 c7 mov %eax,%edi 10a7f2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !sig ) 10a7f4: 85 db test %ebx,%ebx 10a7f6: 74 0d je 10a805 static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10a7f8: 8d 43 ff lea -0x1(%ebx),%eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 10a7fb: 83 f8 1f cmp $0x1f,%eax 10a7fe: 77 05 ja 10a805 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 10a800: 83 fb 09 cmp $0x9,%ebx 10a803: 75 10 jne 10a815 rtems_set_errno_and_return_minus_one( EINVAL ); 10a805: e8 36 77 00 00 call 111f40 <__errno> 10a80a: c7 00 16 00 00 00 movl $0x16,(%eax) 10a810: 83 c8 ff or $0xffffffff,%eax 10a813: eb 57 jmp 10a86c * 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; 10a815: 31 c0 xor %eax,%eax /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 10a817: 85 d2 test %edx,%edx 10a819: 74 51 je 10a86c <== 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 ); 10a81b: 9c pushf 10a81c: fa cli 10a81d: 8f 45 e4 popl -0x1c(%ebp) if ( act->sa_handler == SIG_DFL ) { 10a820: 83 7a 08 00 cmpl $0x0,0x8(%edx) 10a824: 75 1a jne 10a840 _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 10a826: 6b f3 0c imul $0xc,%ebx,%esi 10a829: 8d 86 84 68 12 00 lea 0x126884(%esi),%eax 10a82f: 81 c6 f4 08 12 00 add $0x1208f4,%esi 10a835: b9 03 00 00 00 mov $0x3,%ecx 10a83a: 89 c7 mov %eax,%edi 10a83c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10a83e: eb 26 jmp 10a866 } else { _POSIX_signals_Clear_process_signals( sig ); 10a840: 83 ec 0c sub $0xc,%esp 10a843: 53 push %ebx 10a844: 89 55 e0 mov %edx,-0x20(%ebp) 10a847: e8 8c 4d 00 00 call 10f5d8 <_POSIX_signals_Clear_process_signals> _POSIX_signals_Vectors[ sig ] = *act; 10a84c: 6b db 0c imul $0xc,%ebx,%ebx 10a84f: 81 c3 84 68 12 00 add $0x126884,%ebx 10a855: b9 03 00 00 00 mov $0x3,%ecx 10a85a: 8b 55 e0 mov -0x20(%ebp),%edx 10a85d: 89 df mov %ebx,%edi 10a85f: 89 d6 mov %edx,%esi 10a861: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10a863: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10a866: ff 75 e4 pushl -0x1c(%ebp) 10a869: 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; 10a86a: 31 c0 xor %eax,%eax } 10a86c: 8d 65 f4 lea -0xc(%ebp),%esp 10a86f: 5b pop %ebx 10a870: 5e pop %esi 10a871: 5f pop %edi 10a872: c9 leave 10a873: c3 ret =============================================================================== 0010aba3 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 10aba3: 55 push %ebp 10aba4: 89 e5 mov %esp,%ebp 10aba6: 57 push %edi 10aba7: 56 push %esi 10aba8: 53 push %ebx 10aba9: 83 ec 3c sub $0x3c,%esp 10abac: 8b 75 08 mov 0x8(%ebp),%esi 10abaf: 8b 5d 10 mov 0x10(%ebp),%ebx ISR_Level level; /* * Error check parameters before disabling interrupts. */ if ( !set ) 10abb2: 85 f6 test %esi,%esi 10abb4: 74 24 je 10abda /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; if ( timeout ) { 10abb6: 85 db test %ebx,%ebx 10abb8: 74 30 je 10abea if ( !_Timespec_Is_valid( timeout ) ) 10abba: 83 ec 0c sub $0xc,%esp 10abbd: 53 push %ebx 10abbe: e8 45 30 00 00 call 10dc08 <_Timespec_Is_valid> 10abc3: 83 c4 10 add $0x10,%esp 10abc6: 84 c0 test %al,%al 10abc8: 74 10 je 10abda rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 10abca: 83 ec 0c sub $0xc,%esp 10abcd: 53 push %ebx 10abce: e8 8d 30 00 00 call 10dc60 <_Timespec_To_ticks> if ( !interval ) 10abd3: 83 c4 10 add $0x10,%esp 10abd6: 85 c0 test %eax,%eax 10abd8: 75 12 jne 10abec <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10abda: e8 19 79 00 00 call 1124f8 <__errno> 10abdf: c7 00 16 00 00 00 movl $0x16,(%eax) 10abe5: e9 39 01 00 00 jmp 10ad23 /* NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; 10abea: 31 c0 xor %eax,%eax /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 10abec: 8b 7d 0c mov 0xc(%ebp),%edi 10abef: 85 ff test %edi,%edi 10abf1: 75 03 jne 10abf6 10abf3: 8d 7d dc lea -0x24(%ebp),%edi the_thread = _Thread_Executing; 10abf6: 8b 15 74 68 12 00 mov 0x126874,%edx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10abfc: 8b 8a f8 00 00 00 mov 0xf8(%edx),%ecx 10ac02: 89 4d d4 mov %ecx,-0x2c(%ebp) * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 10ac05: 9c pushf 10ac06: fa cli 10ac07: 8f 45 d0 popl -0x30(%ebp) if ( *set & api->signals_pending ) { 10ac0a: 8b 1e mov (%esi),%ebx 10ac0c: 89 5d c4 mov %ebx,-0x3c(%ebp) 10ac0f: 8b 5d d4 mov -0x2c(%ebp),%ebx 10ac12: 8b 8b d4 00 00 00 mov 0xd4(%ebx),%ecx 10ac18: 85 4d c4 test %ecx,-0x3c(%ebp) 10ac1b: 74 32 je 10ac4f /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending ); 10ac1d: 83 ec 0c sub $0xc,%esp 10ac20: 51 push %ecx 10ac21: e8 3e ff ff ff call 10ab64 <_POSIX_signals_Get_lowest> 10ac26: 89 07 mov %eax,(%edi) _POSIX_signals_Clear_signals( 10ac28: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ac2f: 6a 00 push $0x0 10ac31: 57 push %edi 10ac32: 50 push %eax 10ac33: 53 push %ebx 10ac34: e8 fb 4f 00 00 call 10fc34 <_POSIX_signals_Clear_signals> the_info->si_signo, the_info, false, false ); _ISR_Enable( level ); 10ac39: ff 75 d0 pushl -0x30(%ebp) 10ac3c: 9d popf the_info->si_code = SI_USER; 10ac3d: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10ac44: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return the_info->si_signo; 10ac4b: 8b 1f mov (%edi),%ebx 10ac4d: eb 3d jmp 10ac8c } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 10ac4f: 8b 0d 78 6a 12 00 mov 0x126a78,%ecx 10ac55: 85 4d c4 test %ecx,-0x3c(%ebp) 10ac58: 74 3a je 10ac94 signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending ); 10ac5a: 83 ec 0c sub $0xc,%esp 10ac5d: 51 push %ecx 10ac5e: e8 01 ff ff ff call 10ab64 <_POSIX_signals_Get_lowest> 10ac63: 89 c3 mov %eax,%ebx _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 10ac65: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ac6c: 6a 01 push $0x1 10ac6e: 57 push %edi 10ac6f: 50 push %eax 10ac70: ff 75 d4 pushl -0x2c(%ebp) 10ac73: e8 bc 4f 00 00 call 10fc34 <_POSIX_signals_Clear_signals> _ISR_Enable( level ); 10ac78: ff 75 d0 pushl -0x30(%ebp) 10ac7b: 9d popf the_info->si_signo = signo; 10ac7c: 89 1f mov %ebx,(%edi) the_info->si_code = SI_USER; 10ac7e: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 10ac85: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) return signo; 10ac8c: 83 c4 20 add $0x20,%esp 10ac8f: e9 92 00 00 00 jmp 10ad26 } the_info->si_signo = -1; 10ac94: c7 07 ff ff ff ff movl $0xffffffff,(%edi) 10ac9a: 8b 0d 24 63 12 00 mov 0x126324,%ecx 10aca0: 41 inc %ecx 10aca1: 89 0d 24 63 12 00 mov %ecx,0x126324 _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 10aca7: c7 42 44 10 6a 12 00 movl $0x126a10,0x44(%edx) the_thread->Wait.return_code = EINTR; 10acae: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx) the_thread->Wait.option = *set; 10acb5: 8b 0e mov (%esi),%ecx 10acb7: 89 4a 30 mov %ecx,0x30(%edx) the_thread->Wait.return_argument = the_info; 10acba: 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; 10acbd: c7 05 40 6a 12 00 01 movl $0x1,0x126a40 10acc4: 00 00 00 _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue ); _ISR_Enable( level ); 10acc7: ff 75 d0 pushl -0x30(%ebp) 10acca: 9d popf _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 10accb: 52 push %edx 10accc: 68 00 d8 10 00 push $0x10d800 10acd1: 50 push %eax 10acd2: 68 10 6a 12 00 push $0x126a10 10acd7: e8 4c 28 00 00 call 10d528 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 10acdc: e8 c1 23 00 00 call 10d0a2 <_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 ); 10ace1: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10ace8: 6a 00 push $0x0 10acea: 57 push %edi 10aceb: ff 37 pushl (%edi) 10aced: ff 75 d4 pushl -0x2c(%ebp) 10acf0: e8 3f 4f 00 00 call 10fc34 <_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) 10acf5: 83 c4 20 add $0x20,%esp 10acf8: a1 74 68 12 00 mov 0x126874,%eax 10acfd: 83 78 34 04 cmpl $0x4,0x34(%eax) 10ad01: 75 10 jne 10ad13 || !(*set & signo_to_mask( the_info->si_signo )) ) { 10ad03: 8b 1f mov (%edi),%ebx 10ad05: 8d 4b ff lea -0x1(%ebx),%ecx 10ad08: b8 01 00 00 00 mov $0x1,%eax 10ad0d: d3 e0 shl %cl,%eax 10ad0f: 85 06 test %eax,(%esi) 10ad11: 75 13 jne 10ad26 errno = _Thread_Executing->Wait.return_code; 10ad13: e8 e0 77 00 00 call 1124f8 <__errno> 10ad18: 8b 15 74 68 12 00 mov 0x126874,%edx 10ad1e: 8b 52 34 mov 0x34(%edx),%edx 10ad21: 89 10 mov %edx,(%eax) return -1; 10ad23: 83 cb ff or $0xffffffff,%ebx } return the_info->si_signo; } 10ad26: 89 d8 mov %ebx,%eax 10ad28: 8d 65 f4 lea -0xc(%ebp),%esp 10ad2b: 5b pop %ebx 10ad2c: 5e pop %esi 10ad2d: 5f pop %edi 10ad2e: c9 leave 10ad2f: c3 ret =============================================================================== 0010ca14 : int sigwait( const sigset_t *set, int *sig ) { 10ca14: 55 push %ebp 10ca15: 89 e5 mov %esp,%ebp 10ca17: 53 push %ebx 10ca18: 83 ec 08 sub $0x8,%esp 10ca1b: 8b 5d 0c mov 0xc(%ebp),%ebx int status; status = sigtimedwait( set, NULL, NULL ); 10ca1e: 6a 00 push $0x0 10ca20: 6a 00 push $0x0 10ca22: ff 75 08 pushl 0x8(%ebp) 10ca25: e8 45 fe ff ff call 10c86f 10ca2a: 89 c2 mov %eax,%edx if ( status != -1 ) { 10ca2c: 83 c4 10 add $0x10,%esp 10ca2f: 83 f8 ff cmp $0xffffffff,%eax 10ca32: 74 0a je 10ca3e if ( sig ) *sig = status; return 0; 10ca34: 31 c0 xor %eax,%eax int status; status = sigtimedwait( set, NULL, NULL ); if ( status != -1 ) { if ( sig ) 10ca36: 85 db test %ebx,%ebx 10ca38: 74 0b je 10ca45 <== NEVER TAKEN *sig = status; 10ca3a: 89 13 mov %edx,(%ebx) 10ca3c: eb 07 jmp 10ca45 return 0; } return errno; 10ca3e: e8 cd 72 00 00 call 113d10 <__errno> 10ca43: 8b 00 mov (%eax),%eax } 10ca45: 8b 5d fc mov -0x4(%ebp),%ebx 10ca48: c9 leave 10ca49: 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 19 12 00 00 call 10a164 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 ee 12 00 00 call 10a250 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 =============================================================================== 00108f78 : fdatasync(fn); } /* iterate over all FILE *'s for this thread */ static void sync_per_thread(Thread_Control *t) { 108f78: 55 push %ebp 108f79: 89 e5 mov %esp,%ebp 108f7b: 53 push %ebx 108f7c: 83 ec 04 sub $0x4,%esp 108f7f: 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; 108f82: 8b 88 f0 00 00 00 mov 0xf0(%eax),%ecx if ( this_reent ) { 108f88: 85 c9 test %ecx,%ecx 108f8a: 74 32 je 108fbe <== NEVER TAKEN current_reent = _Thread_Executing->libc_reent; 108f8c: 8b 15 34 68 12 00 mov 0x126834,%edx 108f92: 8b 9a f0 00 00 00 mov 0xf0(%edx),%ebx _Thread_Executing->libc_reent = this_reent; 108f98: 89 8a f0 00 00 00 mov %ecx,0xf0(%edx) _fwalk (t->libc_reent, sync_wrapper); 108f9e: 52 push %edx 108f9f: 52 push %edx 108fa0: 68 c3 8f 10 00 push $0x108fc3 108fa5: ff b0 f0 00 00 00 pushl 0xf0(%eax) 108fab: e8 8c 9e 00 00 call 112e3c <_fwalk> _Thread_Executing->libc_reent = current_reent; 108fb0: a1 34 68 12 00 mov 0x126834,%eax 108fb5: 89 98 f0 00 00 00 mov %ebx,0xf0(%eax) 108fbb: 83 c4 10 add $0x10,%esp } } 108fbe: 8b 5d fc mov -0x4(%ebp),%ebx 108fc1: c9 leave 108fc2: 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 2e 92 00 00 call 112a70 <__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 4f 63 00 00 call 10fba4 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 30 63 00 00 jmp 10fba4 } } 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 =============================================================================== 0010a02c : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 10a02c: 55 push %ebp 10a02d: 89 e5 mov %esp,%ebp 10a02f: 56 push %esi 10a030: 53 push %ebx 10a031: 8b 5d 0c mov 0xc(%ebp),%ebx 10a034: 8b 75 10 mov 0x10(%ebp),%esi POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 10a037: 83 7d 08 01 cmpl $0x1,0x8(%ebp) 10a03b: 75 1d jne 10a05a rtems_set_errno_and_return_minus_one( EINVAL ); if ( !timerid ) 10a03d: 85 f6 test %esi,%esi 10a03f: 74 19 je 10a05a /* * The data of the structure evp are checked in order to verify if they * are coherent. */ if (evp != NULL) { 10a041: 85 db test %ebx,%ebx 10a043: 74 22 je 10a067 /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 10a045: 8b 03 mov (%ebx),%eax 10a047: 48 dec %eax 10a048: 83 f8 01 cmp $0x1,%eax 10a04b: 77 0d ja 10a05a <== 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 ) 10a04d: 8b 43 04 mov 0x4(%ebx),%eax 10a050: 85 c0 test %eax,%eax 10a052: 74 06 je 10a05a <== NEVER TAKEN static inline bool is_valid_signo( int signo ) { return ((signo) >= 1 && (signo) <= 32 ); 10a054: 48 dec %eax rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 10a055: 83 f8 1f cmp $0x1f,%eax 10a058: 76 0d jbe 10a067 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10a05a: e8 7d 7c 00 00 call 111cdc <__errno> 10a05f: c7 00 16 00 00 00 movl $0x16,(%eax) 10a065: eb 2f jmp 10a096 rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10a067: a1 38 63 12 00 mov 0x126338,%eax 10a06c: 40 inc %eax 10a06d: a3 38 63 12 00 mov %eax,0x126338 * 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 ); 10a072: 83 ec 0c sub $0xc,%esp 10a075: 68 44 66 12 00 push $0x126644 10a07a: e8 71 1b 00 00 call 10bbf0 <_Objects_Allocate> /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 10a07f: 83 c4 10 add $0x10,%esp 10a082: 85 c0 test %eax,%eax 10a084: 75 18 jne 10a09e _Thread_Enable_dispatch(); 10a086: e8 73 27 00 00 call 10c7fe <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 10a08b: e8 4c 7c 00 00 call 111cdc <__errno> 10a090: c7 00 0b 00 00 00 movl $0xb,(%eax) 10a096: 83 c8 ff or $0xffffffff,%eax 10a099: e9 83 00 00 00 jmp 10a121 } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 10a09e: c6 40 3c 02 movb $0x2,0x3c(%eax) ptimer->thread_id = _Thread_Executing->Object.id; 10a0a2: 8b 15 88 68 12 00 mov 0x126888,%edx 10a0a8: 8b 52 08 mov 0x8(%edx),%edx 10a0ab: 89 50 38 mov %edx,0x38(%eax) if ( evp != NULL ) { 10a0ae: 85 db test %ebx,%ebx 10a0b0: 74 11 je 10a0c3 ptimer->inf.sigev_notify = evp->sigev_notify; 10a0b2: 8b 13 mov (%ebx),%edx 10a0b4: 89 50 40 mov %edx,0x40(%eax) ptimer->inf.sigev_signo = evp->sigev_signo; 10a0b7: 8b 53 04 mov 0x4(%ebx),%edx 10a0ba: 89 50 44 mov %edx,0x44(%eax) ptimer->inf.sigev_value = evp->sigev_value; 10a0bd: 8b 53 08 mov 0x8(%ebx),%edx 10a0c0: 89 50 48 mov %edx,0x48(%eax) } ptimer->overrun = 0; 10a0c3: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax) ptimer->timer_data.it_value.tv_sec = 0; 10a0ca: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) ptimer->timer_data.it_value.tv_nsec = 0; 10a0d1: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) ptimer->timer_data.it_interval.tv_sec = 0; 10a0d8: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) ptimer->timer_data.it_interval.tv_nsec = 0; 10a0df: 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; 10a0e6: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_watchdog->routine = routine; 10a0ed: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) the_watchdog->id = id; 10a0f4: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) the_watchdog->user_data = user_data; 10a0fb: 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 ), 10a102: 8b 50 08 mov 0x8(%eax),%edx Objects_Information *information, Objects_Control *the_object, uint32_t name ) { _Objects_Set_local_object( 10a105: 0f b7 da movzwl %dx,%ebx #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 10a108: 8b 0d 60 66 12 00 mov 0x126660,%ecx 10a10e: 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; 10a111: 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; 10a118: 89 16 mov %edx,(%esi) _Thread_Enable_dispatch(); 10a11a: e8 df 26 00 00 call 10c7fe <_Thread_Enable_dispatch> return 0; 10a11f: 31 c0 xor %eax,%eax } 10a121: 8d 65 f8 lea -0x8(%ebp),%esp 10a124: 5b pop %ebx 10a125: 5e pop %esi 10a126: c9 leave 10a127: c3 ret =============================================================================== 0010a128 : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 10a128: 55 push %ebp 10a129: 89 e5 mov %esp,%ebp 10a12b: 57 push %edi 10a12c: 56 push %esi 10a12d: 53 push %ebx 10a12e: 83 ec 2c sub $0x2c,%esp 10a131: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; bool activated; uint32_t initial_period; struct itimerspec normalize; if ( !value ) 10a134: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a138: 0f 84 58 01 00 00 je 10a296 <== 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) ) ) { 10a13e: 83 ec 0c sub $0xc,%esp 10a141: 8b 45 10 mov 0x10(%ebp),%eax 10a144: 83 c0 08 add $0x8,%eax 10a147: 50 push %eax 10a148: e8 3b 32 00 00 call 10d388 <_Timespec_Is_valid> 10a14d: 83 c4 10 add $0x10,%esp 10a150: 84 c0 test %al,%al 10a152: 0f 84 3e 01 00 00 je 10a296 rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !_Timespec_Is_valid( &(value->it_interval) ) ) { 10a158: 83 ec 0c sub $0xc,%esp 10a15b: ff 75 10 pushl 0x10(%ebp) 10a15e: e8 25 32 00 00 call 10d388 <_Timespec_Is_valid> 10a163: 83 c4 10 add $0x10,%esp 10a166: 84 c0 test %al,%al 10a168: 0f 84 28 01 00 00 je 10a296 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); } if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 10a16e: 85 db test %ebx,%ebx 10a170: 74 09 je 10a17b 10a172: 83 fb 04 cmp $0x4,%ebx 10a175: 0f 85 1b 01 00 00 jne 10a296 rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 10a17b: 8d 7d cc lea -0x34(%ebp),%edi 10a17e: b9 04 00 00 00 mov $0x4,%ecx 10a183: 8b 75 10 mov 0x10(%ebp),%esi 10a186: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { 10a188: 83 fb 04 cmp $0x4,%ebx 10a18b: 75 2f jne 10a1bc struct timespec now; _TOD_Get( &now ); 10a18d: 83 ec 0c sub $0xc,%esp 10a190: 8d 5d dc lea -0x24(%ebp),%ebx 10a193: 53 push %ebx 10a194: e8 a7 15 00 00 call 10b740 <_TOD_Get> /* Check for seconds in the past */ if ( _Timespec_Greater_than( &now, &normalize.it_value ) ) 10a199: 59 pop %ecx 10a19a: 5e pop %esi 10a19b: 8d 75 d4 lea -0x2c(%ebp),%esi 10a19e: 56 push %esi 10a19f: 53 push %ebx 10a1a0: e8 bf 31 00 00 call 10d364 <_Timespec_Greater_than> 10a1a5: 83 c4 10 add $0x10,%esp 10a1a8: 84 c0 test %al,%al 10a1aa: 0f 85 e6 00 00 00 jne 10a296 rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value ); 10a1b0: 52 push %edx 10a1b1: 56 push %esi 10a1b2: 56 push %esi 10a1b3: 53 push %ebx 10a1b4: e8 f3 31 00 00 call 10d3ac <_Timespec_Subtract> 10a1b9: 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 ); 10a1bc: 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 ); 10a1bd: 8d 45 e4 lea -0x1c(%ebp),%eax 10a1c0: 50 push %eax 10a1c1: ff 75 08 pushl 0x8(%ebp) 10a1c4: 68 44 66 12 00 push $0x126644 10a1c9: e8 52 1e 00 00 call 10c020 <_Objects_Get> 10a1ce: 89 c3 mov %eax,%ebx switch ( location ) { 10a1d0: 83 c4 10 add $0x10,%esp 10a1d3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10a1d7: 0f 85 b9 00 00 00 jne 10a296 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 ) { 10a1dd: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) 10a1e1: 75 3b jne 10a21e 10a1e3: 83 7d d8 00 cmpl $0x0,-0x28(%ebp) 10a1e7: 75 35 jne 10a21e /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 10a1e9: 83 ec 0c sub $0xc,%esp 10a1ec: 8d 40 10 lea 0x10(%eax),%eax 10a1ef: 50 push %eax 10a1f0: e8 7b 35 00 00 call 10d770 <_Watchdog_Remove> /* The old data of the timer are returned */ if ( ovalue ) 10a1f5: 83 c4 10 add $0x10,%esp 10a1f8: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10a1fc: 74 0d je 10a20b *ovalue = ptimer->timer_data; 10a1fe: 8d 73 54 lea 0x54(%ebx),%esi 10a201: b9 04 00 00 00 mov $0x4,%ecx 10a206: 8b 7d 14 mov 0x14(%ebp),%edi 10a209: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* The new data are set */ ptimer->timer_data = normalize; 10a20b: 8d 7b 54 lea 0x54(%ebx),%edi 10a20e: 8d 75 cc lea -0x34(%ebp),%esi 10a211: b9 04 00 00 00 mov $0x4,%ecx 10a216: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a218: c6 43 3c 04 movb $0x4,0x3c(%ebx) 10a21c: eb 35 jmp 10a253 _Thread_Enable_dispatch(); return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); 10a21e: 83 ec 0c sub $0xc,%esp 10a221: ff 75 10 pushl 0x10(%ebp) 10a224: e8 b7 31 00 00 call 10d3e0 <_Timespec_To_ticks> 10a229: 89 43 64 mov %eax,0x64(%ebx) initial_period = _Timespec_To_ticks( &normalize.it_value ); 10a22c: 8d 45 d4 lea -0x2c(%ebp),%eax 10a22f: 89 04 24 mov %eax,(%esp) 10a232: e8 a9 31 00 00 call 10d3e0 <_Timespec_To_ticks> activated = _POSIX_Timer_Insert_helper( 10a237: 89 1c 24 mov %ebx,(%esp) 10a23a: 68 ac a2 10 00 push $0x10a2ac 10a23f: ff 73 08 pushl 0x8(%ebx) 10a242: 50 push %eax 10a243: 8d 43 10 lea 0x10(%ebx),%eax 10a246: 50 push %eax 10a247: e8 64 56 00 00 call 10f8b0 <_POSIX_Timer_Insert_helper> initial_period, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 10a24c: 83 c4 20 add $0x20,%esp 10a24f: 84 c0 test %al,%al 10a251: 75 07 jne 10a25a _Thread_Enable_dispatch(); 10a253: e8 a6 25 00 00 call 10c7fe <_Thread_Enable_dispatch> 10a258: eb 38 jmp 10a292 /* * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) 10a25a: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10a25e: 74 0d je 10a26d *ovalue = ptimer->timer_data; 10a260: 8d 73 54 lea 0x54(%ebx),%esi 10a263: b9 04 00 00 00 mov $0x4,%ecx 10a268: 8b 7d 14 mov 0x14(%ebp),%edi 10a26b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ptimer->timer_data = normalize; 10a26d: 8d 7b 54 lea 0x54(%ebx),%edi 10a270: 8d 75 cc lea -0x34(%ebp),%esi 10a273: b9 04 00 00 00 mov $0x4,%ecx 10a278: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a27a: c6 43 3c 03 movb $0x3,0x3c(%ebx) _TOD_Get( &ptimer->time ); 10a27e: 83 ec 0c sub $0xc,%esp 10a281: 83 c3 6c add $0x6c,%ebx 10a284: 53 push %ebx 10a285: e8 b6 14 00 00 call 10b740 <_TOD_Get> _Thread_Enable_dispatch(); 10a28a: e8 6f 25 00 00 call 10c7fe <_Thread_Enable_dispatch> return 0; 10a28f: 83 c4 10 add $0x10,%esp 10a292: 31 c0 xor %eax,%eax 10a294: eb 0e jmp 10a2a4 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10a296: e8 41 7a 00 00 call 111cdc <__errno> 10a29b: c7 00 16 00 00 00 movl $0x16,(%eax) 10a2a1: 83 c8 ff or $0xffffffff,%eax } 10a2a4: 8d 65 f4 lea -0xc(%ebp),%esp 10a2a7: 5b pop %ebx 10a2a8: 5e pop %esi 10a2a9: 5f pop %edi 10a2aa: c9 leave 10a2ab: c3 ret =============================================================================== 00109f68 : useconds_t ualarm( useconds_t useconds, useconds_t interval ) { 109f68: 55 push %ebp 109f69: 89 e5 mov %esp,%ebp 109f6b: 57 push %edi 109f6c: 56 push %esi 109f6d: 53 push %ebx 109f6e: 83 ec 1c sub $0x1c,%esp 109f71: 8b 75 08 mov 0x8(%ebp),%esi /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 109f74: 83 3d 28 6c 12 00 00 cmpl $0x0,0x126c28 109f7b: 75 2c jne 109fa9 Watchdog_Service_routine_entry routine, Objects_Id id, void *user_data ) { the_watchdog->state = WATCHDOG_INACTIVE; 109f7d: c7 05 14 6c 12 00 00 movl $0x0,0x126c14 109f84: 00 00 00 the_watchdog->routine = routine; 109f87: c7 05 28 6c 12 00 30 movl $0x109f30,0x126c28 109f8e: 9f 10 00 the_watchdog->id = id; 109f91: c7 05 2c 6c 12 00 00 movl $0x0,0x126c2c 109f98: 00 00 00 the_watchdog->user_data = user_data; 109f9b: c7 05 30 6c 12 00 00 movl $0x0,0x126c30 109fa2: 00 00 00 useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 109fa5: 31 db xor %ebx,%ebx 109fa7: eb 4f jmp 109ff8 if ( !the_timer->routine ) { _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { Watchdog_States state; state = _Watchdog_Remove( the_timer ); 109fa9: 83 ec 0c sub $0xc,%esp 109fac: 68 0c 6c 12 00 push $0x126c0c 109fb1: e8 a2 33 00 00 call 10d358 <_Watchdog_Remove> if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) { 109fb6: 83 e8 02 sub $0x2,%eax 109fb9: 83 c4 10 add $0x10,%esp useconds_t ualarm( useconds_t useconds, useconds_t interval ) { useconds_t remaining = 0; 109fbc: 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) ) { 109fbe: 83 f8 01 cmp $0x1,%eax 109fc1: 77 35 ja 109ff8 <== 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); 109fc3: a1 20 6c 12 00 mov 0x126c20,%eax 109fc8: 03 05 18 6c 12 00 add 0x126c18,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 109fce: 57 push %edi 109fcf: 57 push %edi 109fd0: 8d 55 e0 lea -0x20(%ebp),%edx 109fd3: 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); 109fd4: 2b 05 24 6c 12 00 sub 0x126c24,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 109fda: 50 push %eax 109fdb: e8 20 2f 00 00 call 10cf00 <_Timespec_From_ticks> remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 109fe0: 69 4d e0 40 42 0f 00 imul $0xf4240,-0x20(%ebp),%ecx remaining += tp.tv_nsec / 1000; 109fe7: 8b 45 e4 mov -0x1c(%ebp),%eax 109fea: bf e8 03 00 00 mov $0x3e8,%edi 109fef: 99 cltd 109ff0: f7 ff idiv %edi 109ff2: 8d 1c 08 lea (%eax,%ecx,1),%ebx 109ff5: 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 ) { 109ff8: 85 f6 test %esi,%esi 109ffa: 74 44 je 10a040 <== NEVER TAKEN Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 109ffc: b9 40 42 0f 00 mov $0xf4240,%ecx 10a001: 89 f0 mov %esi,%eax 10a003: 31 d2 xor %edx,%edx 10a005: f7 f1 div %ecx 10a007: 89 45 e0 mov %eax,-0x20(%ebp) tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 10a00a: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx 10a010: 89 55 e4 mov %edx,-0x1c(%ebp) ticks = _Timespec_To_ticks( &tp ); 10a013: 83 ec 0c sub $0xc,%esp 10a016: 8d 75 e0 lea -0x20(%ebp),%esi 10a019: 56 push %esi 10a01a: e8 3d 2f 00 00 call 10cf5c <_Timespec_To_ticks> if ( ticks == 0 ) ticks = 1; _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) ); 10a01f: 89 34 24 mov %esi,(%esp) 10a022: e8 35 2f 00 00 call 10cf5c <_Timespec_To_ticks> Watchdog_Control *the_watchdog, Watchdog_Interval units ) { the_watchdog->initial = units; 10a027: a3 18 6c 12 00 mov %eax,0x126c18 _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog ); 10a02c: 59 pop %ecx 10a02d: 5e pop %esi 10a02e: 68 0c 6c 12 00 push $0x126c0c 10a033: 68 fc 63 12 00 push $0x1263fc 10a038: e8 03 32 00 00 call 10d240 <_Watchdog_Insert> 10a03d: 83 c4 10 add $0x10,%esp } return remaining; } 10a040: 89 d8 mov %ebx,%eax 10a042: 8d 65 f4 lea -0xc(%ebp),%esp 10a045: 5b pop %ebx 10a046: 5e pop %esi 10a047: 5f pop %edi 10a048: c9 leave 10a049: c3 ret =============================================================================== 0010a6d4 : #include int unlink( const char *path ) { 10a6d4: 55 push %ebp 10a6d5: 89 e5 mov %esp,%ebp 10a6d7: 57 push %edi 10a6d8: 56 push %esi 10a6d9: 53 push %ebx 10a6da: 83 ec 58 sub $0x58,%esp /* * Get the node to be unlinked. Find the parent path first. */ parentpathlen = rtems_filesystem_dirname ( path ); 10a6dd: ff 75 08 pushl 0x8(%ebp) 10a6e0: e8 1a d9 ff ff call 107fff 10a6e5: 89 45 b4 mov %eax,-0x4c(%ebp) if ( parentpathlen == 0 ) 10a6e8: 83 c4 10 add $0x10,%esp 10a6eb: 85 c0 test %eax,%eax 10a6ed: 8d 45 d0 lea -0x30(%ebp),%eax 10a6f0: 75 15 jne 10a707 rtems_filesystem_get_start_loc( path, &i, &parentloc ); 10a6f2: 51 push %ecx 10a6f3: 50 push %eax 10a6f4: 8d 45 e4 lea -0x1c(%ebp),%eax 10a6f7: 50 push %eax 10a6f8: ff 75 08 pushl 0x8(%ebp) 10a6fb: e8 d4 e6 ff ff call 108dd4 10a700: 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; 10a703: 31 db xor %ebx,%ebx 10a705: eb 25 jmp 10a72c parentpathlen = rtems_filesystem_dirname ( path ); if ( parentpathlen == 0 ) rtems_filesystem_get_start_loc( path, &i, &parentloc ); else { result = rtems_filesystem_evaluate_path( path, parentpathlen, 10a707: 83 ec 0c sub $0xc,%esp 10a70a: 6a 00 push $0x0 10a70c: 50 push %eax 10a70d: 6a 02 push $0x2 10a70f: ff 75 b4 pushl -0x4c(%ebp) 10a712: ff 75 08 pushl 0x8(%ebp) 10a715: e8 a4 d8 ff ff call 107fbe 10a71a: 89 c2 mov %eax,%edx RTEMS_LIBIO_PERMS_WRITE, &parentloc, false ); if ( result != 0 ) 10a71c: 83 c4 20 add $0x20,%esp return -1; 10a71f: 83 c8 ff or $0xffffffff,%eax else { result = rtems_filesystem_evaluate_path( path, parentpathlen, RTEMS_LIBIO_PERMS_WRITE, &parentloc, false ); if ( result != 0 ) 10a722: 85 d2 test %edx,%edx 10a724: 0f 85 d6 00 00 00 jne 10a800 <== NEVER TAKEN return -1; free_parentloc = true; 10a72a: b3 01 mov $0x1,%bl /* * Start from the parent to find the node that should be under it. */ loc = parentloc; 10a72c: 8d 7d bc lea -0x44(%ebp),%edi 10a72f: 8d 75 d0 lea -0x30(%ebp),%esi 10a732: b9 05 00 00 00 mov $0x5,%ecx 10a737: f3 a5 rep movsl %ds:(%esi),%es:(%edi) name = path + parentpathlen; 10a739: 8b 75 08 mov 0x8(%ebp),%esi 10a73c: 03 75 b4 add -0x4c(%ebp),%esi name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 10a73f: 83 c9 ff or $0xffffffff,%ecx 10a742: 89 f7 mov %esi,%edi 10a744: 31 c0 xor %eax,%eax 10a746: f2 ae repnz scas %es:(%edi),%al 10a748: f7 d1 not %ecx 10a74a: 49 dec %ecx 10a74b: 52 push %edx 10a74c: 52 push %edx 10a74d: 51 push %ecx 10a74e: 56 push %esi 10a74f: e8 ea d8 ff ff call 10803e 10a754: 01 c6 add %eax,%esi result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 10a756: 83 c9 ff or $0xffffffff,%ecx 10a759: 89 f7 mov %esi,%edi 10a75b: 31 c0 xor %eax,%eax 10a75d: f2 ae repnz scas %es:(%edi),%al 10a75f: f7 d1 not %ecx 10a761: 49 dec %ecx 10a762: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10a769: 8d 7d bc lea -0x44(%ebp),%edi 10a76c: 57 push %edi 10a76d: 6a 00 push $0x0 10a76f: 51 push %ecx 10a770: 56 push %esi 10a771: e8 ea d7 ff ff call 107f60 0, &loc, false ); if ( result != 0 ) { 10a776: 83 c4 20 add $0x20,%esp 10a779: 85 c0 test %eax,%eax 10a77b: 74 13 je 10a790 if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); return -1; 10a77d: 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 ) 10a780: 84 db test %bl,%bl 10a782: 74 7c je 10a800 <== NEVER TAKEN rtems_filesystem_freenode( &parentloc ); 10a784: 83 ec 0c sub $0xc,%esp 10a787: 8d 55 d0 lea -0x30(%ebp),%edx 10a78a: 52 push %edx 10a78b: 89 45 b0 mov %eax,-0x50(%ebp) 10a78e: eb 65 jmp 10a7f5 return -1; } if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) { 10a790: 83 ec 0c sub $0xc,%esp 10a793: 57 push %edi 10a794: 8b 45 c8 mov -0x38(%ebp),%eax 10a797: ff 50 10 call *0x10(%eax) 10a79a: 83 c4 10 add $0x10,%esp 10a79d: 48 dec %eax 10a79e: 75 2f jne 10a7cf rtems_filesystem_freenode( &loc ); 10a7a0: 83 ec 0c sub $0xc,%esp 10a7a3: 57 push %edi 10a7a4: e8 d3 d8 ff ff call 10807c if ( free_parentloc ) 10a7a9: 83 c4 10 add $0x10,%esp 10a7ac: 84 db test %bl,%bl 10a7ae: 74 0f je 10a7bf rtems_filesystem_freenode( &parentloc ); 10a7b0: 83 ec 0c sub $0xc,%esp 10a7b3: 8d 45 d0 lea -0x30(%ebp),%eax 10a7b6: 50 push %eax 10a7b7: e8 c0 d8 ff ff call 10807c 10a7bc: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EISDIR ); 10a7bf: e8 04 a0 00 00 call 1147c8 <__errno> 10a7c4: c7 00 15 00 00 00 movl $0x15,(%eax) 10a7ca: 83 c8 ff or $0xffffffff,%eax 10a7cd: eb 31 jmp 10a800 } result = (*loc.ops->unlink_h)( &parentloc, &loc ); 10a7cf: 50 push %eax 10a7d0: 50 push %eax 10a7d1: 57 push %edi 10a7d2: 8d 75 d0 lea -0x30(%ebp),%esi 10a7d5: 56 push %esi 10a7d6: 8b 45 c8 mov -0x38(%ebp),%eax 10a7d9: ff 50 0c call *0xc(%eax) rtems_filesystem_freenode( &loc ); 10a7dc: 89 3c 24 mov %edi,(%esp) 10a7df: 89 45 b0 mov %eax,-0x50(%ebp) 10a7e2: e8 95 d8 ff ff call 10807c if ( free_parentloc ) 10a7e7: 83 c4 10 add $0x10,%esp 10a7ea: 84 db test %bl,%bl 10a7ec: 8b 45 b0 mov -0x50(%ebp),%eax 10a7ef: 74 0f je 10a800 rtems_filesystem_freenode( &parentloc ); 10a7f1: 83 ec 0c sub $0xc,%esp 10a7f4: 56 push %esi 10a7f5: e8 82 d8 ff ff call 10807c 10a7fa: 83 c4 10 add $0x10,%esp 10a7fd: 8b 45 b0 mov -0x50(%ebp),%eax return result; } 10a800: 8d 65 f4 lea -0xc(%ebp),%esp 10a803: 5b pop %ebx 10a804: 5e pop %esi 10a805: 5f pop %edi 10a806: c9 leave 10a807: 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 b2 76 00 00 call 112034 <__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 64 76 00 00 call 112034 <__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 8b 0e 00 00 call 10b8a8 <== 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 c8 72 12 00 pushl 0x1272c8 10aa28: e8 f7 08 00 00 call 10b324 */ 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 3b 11 00 00 call 10bb70 <_Chain_Extract> } static inline void rtems_libio_unlock( void ) { rtems_semaphore_release( rtems_libio_semaphore ); 10aa35: 58 pop %eax 10aa36: ff 35 c8 72 12 00 pushl 0x1272c8 10aa3c: e8 cf 09 00 00 call 10b410 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 =============================================================================== 0011c99c : ssize_t write( int fd, const void *buffer, size_t count ) { 11c99c: 55 push %ebp 11c99d: 89 e5 mov %esp,%ebp 11c99f: 56 push %esi 11c9a0: 53 push %ebx 11c9a1: 8b 5d 08 mov 0x8(%ebp),%ebx 11c9a4: 8b 55 0c mov 0xc(%ebp),%edx 11c9a7: 8b 4d 10 mov 0x10(%ebp),%ecx ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11c9aa: 3b 1d 44 01 12 00 cmp 0x120144,%ebx 11c9b0: 73 14 jae 11c9c6 iop = rtems_libio_iop( fd ); 11c9b2: 6b db 38 imul $0x38,%ebx,%ebx 11c9b5: 03 1d 98 41 12 00 add 0x124198,%ebx rtems_libio_check_is_open( iop ); 11c9bb: 8b 73 14 mov 0x14(%ebx),%esi 11c9be: f7 c6 00 01 00 00 test $0x100,%esi 11c9c4: 75 0d jne 11c9d3 11c9c6: e8 e1 46 ff ff call 1110ac <__errno> 11c9cb: c7 00 09 00 00 00 movl $0x9,(%eax) 11c9d1: eb 1a jmp 11c9ed rtems_libio_check_buffer( buffer ); 11c9d3: 85 d2 test %edx,%edx 11c9d5: 74 0b je 11c9e2 <== NEVER TAKEN rtems_libio_check_count( count ); 11c9d7: 31 c0 xor %eax,%eax 11c9d9: 85 c9 test %ecx,%ecx 11c9db: 74 31 je 11ca0e rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 11c9dd: 83 e6 04 and $0x4,%esi 11c9e0: 75 10 jne 11c9f2 11c9e2: e8 c5 46 ff ff call 1110ac <__errno> 11c9e7: c7 00 16 00 00 00 movl $0x16,(%eax) 11c9ed: 83 c8 ff or $0xffffffff,%eax 11c9f0: eb 1c jmp 11ca0e /* * Now process the write() request. */ rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count ); 11c9f2: 50 push %eax 11c9f3: 8b 43 20 mov 0x20(%ebx),%eax 11c9f6: 51 push %ecx 11c9f7: 52 push %edx 11c9f8: 53 push %ebx 11c9f9: ff 50 0c call *0xc(%eax) if ( rc > 0 ) 11c9fc: 83 c4 10 add $0x10,%esp 11c9ff: 85 c0 test %eax,%eax 11ca01: 7e 0b jle 11ca0e iop->offset += rc; 11ca03: 89 c1 mov %eax,%ecx 11ca05: c1 f9 1f sar $0x1f,%ecx 11ca08: 01 43 0c add %eax,0xc(%ebx) 11ca0b: 11 4b 10 adc %ecx,0x10(%ebx) return rc; } 11ca0e: 8d 65 f8 lea -0x8(%ebp),%esp 11ca11: 5b pop %ebx 11ca12: 5e pop %esi 11ca13: c9 leave 11ca14: c3 ret =============================================================================== 0010a948 : ssize_t writev( int fd, const struct iovec *iov, int iovcnt ) { 10a948: 55 push %ebp 10a949: 89 e5 mov %esp,%ebp 10a94b: 57 push %edi 10a94c: 56 push %esi 10a94d: 53 push %ebx 10a94e: 83 ec 1c sub $0x1c,%esp 10a951: 8b 75 08 mov 0x8(%ebp),%esi 10a954: 8b 7d 0c mov 0xc(%ebp),%edi int bytes; rtems_libio_t *iop; ssize_t old; bool all_zeros; rtems_libio_check_fd( fd ); 10a957: 3b 35 44 11 12 00 cmp 0x121144,%esi 10a95d: 73 11 jae 10a970 iop = rtems_libio_iop( fd ); 10a95f: 6b f6 38 imul $0x38,%esi,%esi 10a962: 03 35 98 51 12 00 add 0x125198,%esi rtems_libio_check_is_open( iop ); 10a968: 8b 46 14 mov 0x14(%esi),%eax 10a96b: f6 c4 01 test $0x1,%ah 10a96e: 75 10 jne 10a980 10a970: e8 17 73 00 00 call 111c8c <__errno> 10a975: c7 00 09 00 00 00 movl $0x9,(%eax) 10a97b: e9 ad 00 00 00 jmp 10aa2d rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 10a980: a8 04 test $0x4,%al 10a982: 74 42 je 10a9c6 <== NEVER TAKEN /* * Argument validation on IO vector */ if ( !iov ) 10a984: 85 ff test %edi,%edi 10a986: 74 3e je 10a9c6 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt <= 0 ) 10a988: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a98c: 7e 38 jle 10a9c6 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt > IOV_MAX ) 10a98e: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp) 10a995: 7f 2f jg 10a9c6 <== NEVER TAKEN 10a997: b2 01 mov $0x1,%dl 10a999: 31 c0 xor %eax,%eax 10a99b: 31 c9 xor %ecx,%ecx 10a99d: eb 02 jmp 10a9a1 if ( iov[v].iov_len ) all_zeros = false; /* check for wrap */ old = total; total += iov[v].iov_len; 10a99f: 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 ) 10a9a1: 83 3c c7 00 cmpl $0x0,(%edi,%eax,8) 10a9a5: 74 1f je 10a9c6 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iov[v].iov_len ) all_zeros = false; 10a9a7: 83 7c c7 04 00 cmpl $0x0,0x4(%edi,%eax,8) 10a9ac: 0f 94 c3 sete %bl 10a9af: f7 db neg %ebx 10a9b1: 21 da and %ebx,%edx /* check for wrap */ old = total; total += iov[v].iov_len; 10a9b3: 8b 5c c7 04 mov 0x4(%edi,%eax,8),%ebx 10a9b7: 8d 1c 19 lea (%ecx,%ebx,1),%ebx if ( total < old || total > SSIZE_MAX ) 10a9ba: 81 fb ff 7f 00 00 cmp $0x7fff,%ebx 10a9c0: 7f 04 jg 10a9c6 <== NEVER TAKEN 10a9c2: 39 cb cmp %ecx,%ebx 10a9c4: 7d 0d jge 10a9d3 rtems_set_errno_and_return_minus_one( EINVAL ); 10a9c6: e8 c1 72 00 00 call 111c8c <__errno> 10a9cb: c7 00 16 00 00 00 movl $0x16,(%eax) 10a9d1: eb 5a jmp 10aa2d * 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++ ) { 10a9d3: 40 inc %eax 10a9d4: 3b 45 10 cmp 0x10(%ebp),%eax 10a9d7: 7c c6 jl 10a99f /* * A writev with all zeros is supposed to have no effect per OpenGroup. */ if ( all_zeros == true ) { return 0; 10a9d9: 31 db xor %ebx,%ebx } /* * A writev with all zeros is supposed to have no effect per OpenGroup. */ if ( all_zeros == true ) { 10a9db: 84 d2 test %dl,%dl 10a9dd: 75 51 jne 10aa30 10a9df: 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 ) 10a9e6: 8b 55 e4 mov -0x1c(%ebp),%edx 10a9e9: 8b 44 d7 04 mov 0x4(%edi,%edx,8),%eax 10a9ed: 85 c0 test %eax,%eax 10a9ef: 74 2f je 10aa20 <== NEVER TAKEN continue; bytes = (*iop->pathinfo.handlers->write_h)( 10a9f1: 52 push %edx 10a9f2: 8b 56 20 mov 0x20(%esi),%edx 10a9f5: 50 push %eax 10a9f6: 8b 45 e4 mov -0x1c(%ebp),%eax 10a9f9: ff 34 c7 pushl (%edi,%eax,8) 10a9fc: 56 push %esi 10a9fd: ff 52 0c call *0xc(%edx) iop, iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) 10aa00: 83 c4 10 add $0x10,%esp 10aa03: 83 f8 00 cmp $0x0,%eax 10aa06: 7c 25 jl 10aa2d <== NEVER TAKEN return -1; if ( bytes > 0 ) { 10aa08: 74 0d je 10aa17 <== NEVER TAKEN iop->offset += bytes; 10aa0a: 89 c1 mov %eax,%ecx 10aa0c: c1 f9 1f sar $0x1f,%ecx 10aa0f: 01 46 0c add %eax,0xc(%esi) 10aa12: 11 4e 10 adc %ecx,0x10(%esi) total += bytes; 10aa15: 01 c3 add %eax,%ebx } if (bytes != iov[ v ].iov_len) 10aa17: 8b 55 e4 mov -0x1c(%ebp),%edx 10aa1a: 3b 44 d7 04 cmp 0x4(%edi,%edx,8),%eax 10aa1e: 75 10 jne 10aa30 <== NEVER TAKEN } /* * Now process the writev(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { 10aa20: ff 45 e4 incl -0x1c(%ebp) 10aa23: 8b 45 10 mov 0x10(%ebp),%eax 10aa26: 39 45 e4 cmp %eax,-0x1c(%ebp) 10aa29: 7c bb jl 10a9e6 10aa2b: eb 03 jmp 10aa30 iov[v].iov_base, iov[v].iov_len ); if ( bytes < 0 ) return -1; 10aa2d: 83 cb ff or $0xffffffff,%ebx if (bytes != iov[ v ].iov_len) break; } return total; } 10aa30: 89 d8 mov %ebx,%eax 10aa32: 8d 65 f4 lea -0xc(%ebp),%esp 10aa35: 5b pop %ebx 10aa36: 5e pop %esi 10aa37: 5f pop %edi 10aa38: c9 leave 10aa39: c3 ret