===============================================================================0010d5a8 : #define MAXSYMLINK 5 int IMFS_Set_handlers( rtems_filesystem_location_info_t *loc ) { 10d5a8:55 push %ebp 10d5a9:89 e5 mov %esp,%ebp 10d5ab: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; 10d5ae:8b 50 10 mov 0x10(%eax),%edx 10d5b1:8b 52 34 mov 0x34(%edx),%edx switch( node->type ) { 10d5b4:8b 08 mov (%eax),%ecx 10d5b6:8b 49 4c mov 0x4c(%ecx),%ecx 10d5b9:49 dec %ecx 10d5ba:83 f9 06 cmp $0x6,%ecx 10d5bd:77 29 ja 10d5e8 handlers = fs_info->directory_handlers; 10d5c6:8b 52 0c mov 0xc(%edx),%edx 10d5c9:eb 1a jmp 10d5e5 break; case IMFS_DEVICE: loc->handlers = &IMFS_device_handlers; 10d5cb:c7 40 08 34 ea 11 00 movl $0x11ea34,0x8(%eax) break; 10d5d2:eb 14 jmp 10d5e8 case IMFS_SYM_LINK: case IMFS_HARD_LINK: loc->handlers = &IMFS_link_handlers; 10d5d4:c7 40 08 a4 ea 11 00 movl $0x11eaa4,0x8(%eax) break; 10d5db:eb 0b jmp 10d5e8 case IMFS_LINEAR_FILE: loc->handlers = fs_info->memfile_handlers; break; case IMFS_MEMORY_FILE: loc->handlers = fs_info->memfile_handlers; 10d5dd:8b 52 08 mov 0x8(%edx),%edx 10d5e0:eb 03 jmp 10d5e5 break; case IMFS_FIFO: loc->handlers = fs_info->fifo_handlers; 10d5e2:8b 52 10 mov 0x10(%edx),%edx 10d5e5:89 50 08 mov %edx,0x8(%eax) break; } return 0; } 10d5e8:31 c0 xor %eax,%eax 10d5ea:c9 leave 10d5eb:c3 ret ===============================================================================0010d45b : IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) { 10d45b:55 push %ebp 10d45c:89 e5 mov %esp,%ebp 10d45e:57 push %edi 10d45f:56 push %esi 10d460:53 push %ebx 10d461:83 ec 1c sub $0x1c,%esp 10d464:8b 4d 08 mov 0x8(%ebp),%ecx 10d467:8b 5d 0c mov 0xc(%ebp),%ebx 10d46a:8b 75 18 mov 0x18(%ebp),%esi /* * MUST have a parent node to call this routine. */ if ( parent_loc == NULL ) return NULL; 10d46d:31 c0 xor %eax,%eax IMFS_fs_info_t *fs_info; /* * MUST have a parent node to call this routine. */ if ( parent_loc == NULL ) 10d46f:85 c9 test %ecx,%ecx 10d471:0f 84 f4 00 00 00 je 10d56b node_access; 10d477:8b 11 mov (%ecx),%edx fs_info = parent_loc->mt_entry->fs_info; 10d479:8b 49 10 mov 0x10(%ecx),%ecx 10d47c:8b 79 34 mov 0x34(%ecx),%edi /* * Reject creation of FIFOs if support is disabled. */ if ( type == IMFS_FIFO && 10d47f:83 fb 07 cmp $0x7,%ebx 10d482:75 0d jne 10d491 10d484:81 7f 10 a8 e9 11 00 cmpl $0x11e9a8,0x10(%edi) 10d48b:0f 84 da 00 00 00 je 10d56b return NULL; /* * Allocate filesystem node and fill in basic information */ node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask ); 10d491:50 push %eax 10d492:a1 50 20 12 00 mov 0x122050,%eax 10d497:8b 40 2c mov 0x2c(%eax),%eax 10d49a:f7 d0 not %eax 10d49c:23 45 14 and 0x14(%ebp),%eax 10d49f:50 push %eax 10d4a0:ff 75 10 pushl 0x10(%ebp) 10d4a3:53 push %ebx 10d4a4:89 55 e4 mov %edx,-0x1c(%ebp) 10d4a7:e8 40 ff ff ff call 10d3ec if ( !node ) 10d4ac:83 c4 10 add $0x10,%esp 10d4af:85 c0 test %eax,%eax 10d4b1:8b 55 e4 mov -0x1c(%ebp),%edx 10d4b4:0f 84 b1 00 00 00 je 10d56b return NULL; /* * Set the type specific information */ if ( type == IMFS_DIRECTORY ) { 10d4ba:83 fb 01 cmp $0x1,%ebx 10d4bd:75 15 jne 10d4d4 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10d4bf:8d 48 54 lea 0x54(%eax),%ecx 10d4c2: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; 10d4c5:c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) rtems_chain_initialize_empty(&node->info.directory.Entries); 10d4cc:8d 48 50 lea 0x50(%eax),%ecx 10d4cf:89 48 58 mov %ecx,0x58(%eax) 10d4d2:eb 75 jmp 10d549 } else if ( type == IMFS_HARD_LINK ) { 10d4d4:83 fb 03 cmp $0x3,%ebx 10d4d7:74 05 je 10d4de node->info.hard_link.link_node = info->hard_link.link_node; } else if ( type == IMFS_SYM_LINK ) { 10d4d9:83 fb 04 cmp $0x4,%ebx 10d4dc:75 07 jne 10d4e5 node->info.sym_link.name = info->sym_link.name; 10d4de:8b 0e mov (%esi),%ecx 10d4e0:89 48 50 mov %ecx,0x50(%eax) 10d4e3:eb 64 jmp 10d549 } else if ( type == IMFS_DEVICE ) { 10d4e5:83 fb 02 cmp $0x2,%ebx 10d4e8:75 0d jne 10d4f7 node->info.device.major = info->device.major; 10d4ea:8b 0e mov (%esi),%ecx 10d4ec:89 48 50 mov %ecx,0x50(%eax) node->info.device.minor = info->device.minor; 10d4ef:8b 4e 04 mov 0x4(%esi),%ecx 10d4f2:89 48 54 mov %ecx,0x54(%eax) 10d4f5:eb 52 jmp 10d549 } else if ( type == IMFS_LINEAR_FILE ) { 10d4f7:83 fb 06 cmp $0x6,%ebx 10d4fa:75 17 jne 10d513 node->info.linearfile.size = 0; 10d4fc:c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10d503:c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.linearfile.direct = 0; 10d50a:c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) 10d511:eb 36 jmp 10d549 } else if ( type == IMFS_MEMORY_FILE ) { 10d513:83 fb 05 cmp $0x5,%ebx 10d516:75 25 jne 10d53d node->info.file.size = 0; 10d518:c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10d51f:c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.file.indirect = 0; 10d526:c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) node->info.file.doubly_indirect = 0; 10d52d:c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) node->info.file.triply_indirect = 0; 10d534:c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) 10d53b:eb 0c jmp 10d549 } else if ( type == IMFS_FIFO ) { 10d53d:83 fb 07 cmp $0x7,%ebx 10d540:75 07 jne 10d549 info.fifo.pipe = NULL; 10d542: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; 10d549:89 50 08 mov %edx,0x8(%eax) node->st_ino = ++fs_info->ino_count; 10d54c:8b 4f 04 mov 0x4(%edi),%ecx 10d54f:41 inc %ecx 10d550:89 4f 04 mov %ecx,0x4(%edi) 10d553:89 48 38 mov %ecx,0x38(%eax) 10d556:53 push %ebx 10d557:53 push %ebx 10d558:50 push %eax rtems_chain_append( &parent->info.directory.Entries, &node->Node ); 10d559:83 c2 50 add $0x50,%edx 10d55c:52 push %edx 10d55d:89 45 e4 mov %eax,-0x1c(%ebp) 10d560:e8 5b d4 ff ff call 10a9c0 return node; 10d565:83 c4 10 add $0x10,%esp 10d568:8b 45 e4 mov -0x1c(%ebp),%eax } 10d56b:8d 65 f4 lea -0xc(%ebp),%esp 10d56e:5b pop %ebx 10d56f:5e pop %esi 10d570:5f pop %edi 10d571:c9 leave 10d572:c3 ret ===============================================================================0010d689 : const char *pathname, /* IN */ size_t pathnamelen, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10d689:55 push %ebp 10d68a:89 e5 mov %esp,%ebp 10d68c:57 push %edi 10d68d:56 push %esi 10d68e:53 push %ebx 10d68f:83 ec 5c sub $0x5c,%esp 10d692: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 ) ) { 10d695:f7 45 10 f8 ff ff ff testl $0xfffffff8,0x10(%ebp) 10d69c:74 0d je 10d6ab node_access; 10d720:8b 3b mov (%ebx),%edi switch( type ) { 10d722:83 fe 03 cmp $0x3,%esi 10d725:74 38 je 10d75f 10d727:83 fe 04 cmp $0x4,%esi 10d72a:0f 84 a7 00 00 00 je 10d7d7 10d730:83 fe 02 cmp $0x2,%esi 10d733:0f 85 ae 00 00 00 jne 10d7e7 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10d739:a1 50 20 12 00 mov 0x122050,%eax 10d73e:3b 78 18 cmp 0x18(%eax),%edi 10d741:0f 84 a0 00 00 00 je 10d7e7 /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access) { 10d747:8b 43 10 mov 0x10(%ebx),%eax /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == 10d74a:3b 78 1c cmp 0x1c(%eax),%edi 10d74d:75 0b jne 10d75a */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; /* Throw out the .. in this case */ } else { newloc = pathloc->mt_entry->mt_point_node; 10d74f:8d 7d d0 lea -0x30(%ebp),%edi 10d752:8d 70 08 lea 0x8(%eax),%esi 10d755:e9 ad 00 00 00 jmp 10d807 pathnamelen+len, flags,pathloc); } } else { if ( !node->Parent ) 10d75a:8b 7f 08 mov 0x8(%edi),%edi 10d75d:eb 6c jmp 10d7cb case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { 10d75f:8b 47 4c mov 0x4c(%edi),%eax 10d762:83 f8 03 cmp $0x3,%eax 10d765:75 11 jne 10d778 IMFS_evaluate_hard_link( pathloc, 0 ); 10d767:51 push %ecx 10d768:51 push %ecx 10d769:6a 00 push $0x0 10d76b:53 push %ebx 10d76c:e8 d9 fe ff ff call 10d64a node = pathloc->node_access; 10d771:8b 3b mov (%ebx),%edi 10d773:83 c4 10 add $0x10,%esp 10d776:eb 1d jmp 10d795 * It would be a design error if we evaluated the link and * was broken. */ IMFS_assert( node ); } else if ( node->type == IMFS_SYM_LINK ) { 10d778:83 f8 04 cmp $0x4,%eax 10d77b:75 18 jne 10d795 result = IMFS_evaluate_sym_link( pathloc, 0 ); 10d77d:52 push %edx 10d77e:52 push %edx 10d77f:6a 00 push $0x0 10d781:53 push %ebx 10d782:e8 ed 00 00 00 call 10d874 /* * In contrast to a hard link, it is possible to have a broken * symbolic link. */ node = pathloc->node_access; 10d787:8b 3b mov (%ebx),%edi if ( result == -1 ) 10d789:83 c4 10 add $0x10,%esp 10d78c:83 f8 ff cmp $0xffffffff,%eax 10d78f:0f 84 d3 00 00 00 je 10d868 type != IMFS_DIRECTORY ) 10d795:83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10d799:74 10 je 10d7ab rtems_set_errno_and_return_minus_one( ENOTDIR ); 10d79b:e8 fc 38 00 00 call 11109c 10d7a0:c7 00 14 00 00 00 movl $0x14,(%eax) 10d7a6:e9 42 ff ff ff jmp 10d6ed /* * 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 ) { 10d7ab:8b 47 5c mov 0x5c(%edi),%eax 10d7ae:85 c0 test %eax,%eax 10d7b0:74 08 je 10d7ba newloc = node->info.directory.mt_fs->mt_fs_root; 10d7b2:8d 7d d0 lea -0x30(%ebp),%edi 10d7b5:8d 70 1c lea 0x1c(%eax),%esi 10d7b8:eb 4d jmp 10d807 } /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10d7ba:50 push %eax 10d7bb:50 push %eax 10d7bc:8d 45 af lea -0x51(%ebp),%eax 10d7bf:50 push %eax 10d7c0:57 push %edi 10d7c1:e8 56 04 00 00 call 10dc1c 10d7c6:89 c7 mov %eax,%edi if ( !node ) 10d7c8:83 c4 10 add $0x10,%esp 10d7cb:85 ff test %edi,%edi 10d7cd:0f 84 0f ff ff ff je 10d6e2 /* * Set the node access to the point we have found. */ pathloc->node_access = node; 10d7d3:89 3b mov %edi,(%ebx) 10d7d5:eb 10 jmp 10d7e7 case IMFS_NO_MORE_PATH: case IMFS_CURRENT_DIR: break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10d7d7:e8 c0 38 00 00 call 11109c 10d7dc:c7 00 5b 00 00 00 movl $0x5b,(%eax) 10d7e2:e9 06 ff ff ff jmp 10d6ed /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 10d7e7:83 fe 04 cmp $0x4,%esi 10d7ea:74 08 je 10d7f4 type == IMFS_DIRECTORY ) { 10d7f4:83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10d7f8:75 41 jne 10d83b if ( node->info.directory.mt_fs != NULL ) { 10d7fa:8b 77 5c mov 0x5c(%edi),%esi 10d7fd:85 f6 test %esi,%esi 10d7ff:74 3a je 10d83b newloc = node->info.directory.mt_fs->mt_fs_root; 10d801:8d 7d d0 lea -0x30(%ebp),%edi 10d804:83 c6 1c add $0x1c,%esi 10d807:b9 05 00 00 00 mov $0x5,%ecx 10d80c:f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10d80e:8d 75 d0 lea -0x30(%ebp),%esi 10d811:b1 05 mov $0x5,%cl 10d813:89 df mov %ebx,%edi 10d815:f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalpath_h)( &pathname[i-len], 10d817:8b 45 e4 mov -0x1c(%ebp),%eax 10d81a:8b 53 0c mov 0xc(%ebx),%edx 10d81d:53 push %ebx 10d81e:ff 75 10 pushl 0x10(%ebp) 10d821:8b 4d 0c mov 0xc(%ebp),%ecx 10d824:01 c1 add %eax,%ecx 10d826:51 push %ecx 10d827:8b 4d a4 mov -0x5c(%ebp),%ecx 10d82a:29 c1 sub %eax,%ecx 10d82c:8b 45 08 mov 0x8(%ebp),%eax 10d82f:01 c8 add %ecx,%eax 10d831:50 push %eax 10d832:ff 12 call *(%edx) 10d834:89 c7 mov %eax,%edi 10d836:83 c4 10 add $0x10,%esp 10d839:eb 2f jmp 10d86a flags, pathloc ); } else { result = IMFS_Set_handlers( pathloc ); } } else { result = IMFS_Set_handlers( pathloc ); 10d83b:83 ec 0c sub $0xc,%esp 10d83e:53 push %ebx 10d83f:e8 64 fd ff ff call 10d5a8 10d844:89 c7 mov %eax,%edi 10d846:5a pop %edx 10d847:59 pop %ecx /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) 10d848:ff 75 10 pushl 0x10(%ebp) 10d84b:53 push %ebx 10d84c:e8 9b fd ff ff call 10d5ec 10d851:83 c4 10 add $0x10,%esp 10d854:85 c0 test %eax,%eax 10d856:75 12 jne 10d86a rtems_set_errno_and_return_minus_one( EACCES ); 10d858:e8 3f 38 00 00 call 11109c 10d85d:c7 00 0d 00 00 00 movl $0xd,(%eax) 10d863:e9 85 fe ff ff jmp 10d6ed 10d868:89 c7 mov %eax,%edi node_access; 10d974:8b 1a mov (%edx),%ebx /* * Get the path length. */ pathlen = strlen( path ); 10d976:31 c0 xor %eax,%eax 10d978:83 c9 ff or $0xffffffff,%ecx 10d97b:8b 7d 08 mov 0x8(%ebp),%edi 10d97e:f2 ae repnz scas %es:(%edi),%al 10d980:f7 d1 not %ecx 10d982:49 dec %ecx 10d983: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; 10d986: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 ); 10d98d:8d 7d af lea -0x51(%ebp),%edi 10d990:89 d6 mov %edx,%esi 10d992:8d 45 e4 lea -0x1c(%ebp),%eax 10d995:50 push %eax 10d996:57 push %edi 10d997:ff 75 a0 pushl -0x60(%ebp) 10d99a:8b 45 08 mov 0x8(%ebp),%eax 10d99d:03 45 a4 add -0x5c(%ebp),%eax 10d9a0:50 push %eax 10d9a1:e8 e2 02 00 00 call 10dc88 10d9a6:89 c2 mov %eax,%edx pathlen -= len; 10d9a8:8b 4d e4 mov -0x1c(%ebp),%ecx 10d9ab:29 4d a0 sub %ecx,-0x60(%ebp) i += len; if ( !pathloc->node_access ) 10d9ae:83 c4 10 add $0x10,%esp 10d9b1:83 3e 00 cmpl $0x0,(%esi) 10d9b4:0f 84 79 01 00 00 je 10db33 type == IMFS_DIRECTORY ) 10d9be:83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10d9c2:75 30 jne 10d9f4 if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10d9c4:53 push %ebx 10d9c5:53 push %ebx 10d9c6:6a 01 push $0x1 10d9c8:56 push %esi 10d9c9:89 45 9c mov %eax,-0x64(%ebp) 10d9cc:89 4d 98 mov %ecx,-0x68(%ebp) 10d9cf:e8 18 fc ff ff call 10d5ec 10d9d4:83 c4 10 add $0x10,%esp 10d9d7:85 c0 test %eax,%eax 10d9d9:8b 55 9c mov -0x64(%ebp),%edx 10d9dc:8b 4d 98 mov -0x68(%ebp),%ecx 10d9df:75 13 jne 10d9f4 rtems_set_errno_and_return_minus_one( EACCES ); 10d9e1:e8 b6 36 00 00 call 11109c 10d9e6:c7 00 0d 00 00 00 movl $0xd,(%eax) 10d9ec:83 cb ff or $0xffffffff,%ebx 10d9ef:e9 99 01 00 00 jmp 10db8d while( !done ) { type = IMFS_get_token( &path[i], pathlen, token, &len ); pathlen -= len; i += len; 10d9f4: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; 10d9f7:8b 1e mov (%esi),%ebx switch( type ) { 10d9f9:83 fa 02 cmp $0x2,%edx 10d9fc:74 1f je 10da1d 10d9fe:77 0a ja 10da0a 10da00:85 d2 test %edx,%edx 10da02:0f 84 d9 00 00 00 je 10dae1 10da08:eb 88 jmp 10d992 10da0a:83 fa 03 cmp $0x3,%edx 10da0d:74 40 je 10da4f 10da0f:83 fa 04 cmp $0x4,%edx 10da12:0f 85 7a ff ff ff jne 10d992 size == 0 ) return NULL; 10b2b8: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 ) 10b2ba:83 7b 18 00 cmpl $0x0,0x18(%ebx) 10b2be:74 53 je 10b313 Inactive ); 10b2c0:8d 73 20 lea 0x20(%ebx),%esi 10b2c3:83 ec 0c sub $0xc,%esp 10b2c6:56 push %esi 10b2c7:e8 30 f7 ff ff call 10a9fc 10b2cc:89 c1 mov %eax,%ecx if ( information->auto_extend ) { 10b2ce:83 c4 10 add $0x10,%esp 10b2d1:80 7b 12 00 cmpb $0x0,0x12(%ebx) 10b2d5:74 3c je 10b313 /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10b2d7:85 c0 test %eax,%eax 10b2d9:75 1a jne 10b2f5 _Objects_Extend_information( information ); 10b2db:83 ec 0c sub $0xc,%esp 10b2de:53 push %ebx 10b2df:e8 60 00 00 00 call 10b344 the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10b2e4:89 34 24 mov %esi,(%esp) 10b2e7:e8 10 f7 ff ff call 10a9fc 10b2ec:89 c1 mov %eax,%ecx } if ( the_object ) { 10b2ee:83 c4 10 add $0x10,%esp 10b2f1:85 c0 test %eax,%eax 10b2f3:74 1e je 10b313 uint32_t block; block = (uint32_t) _Objects_Get_index( the_object->id ) - 10b2f5:0f b7 41 08 movzwl 0x8(%ecx),%eax 10b2f9:0f b7 53 08 movzwl 0x8(%ebx),%edx 10b2fd:29 d0 sub %edx,%eax _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; 10b2ff:0f b7 73 14 movzwl 0x14(%ebx),%esi 10b303:31 d2 xor %edx,%edx 10b305:f7 f6 div %esi information->inactive_per_block[ block ]--; 10b307:c1 e0 02 shl $0x2,%eax 10b30a:03 43 30 add 0x30(%ebx),%eax 10b30d:ff 08 decl (%eax) information->inactive--; 10b30f:66 ff 4b 2c decw 0x2c(%ebx) ); } #endif return the_object; } 10b313:89 c8 mov %ecx,%eax 10b315:8d 65 f8 lea -0x8(%ebp),%esp 10b318:5b pop %ebx 10b319:5e pop %esi 10b31a:c9 leave 10b31b:c3 ret ===============================================================================0010b638 : Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint16_t the_class ) { 10b638:55 push %ebp 10b639:89 e5 mov %esp,%ebp 10b63b:57 push %edi 10b63c:56 push %esi 10b63d:53 push %ebx 10b63e:83 ec 0c sub $0xc,%esp 10b641:8b 75 08 mov 0x8(%ebp),%esi 10b644:8b 7d 0c mov 0xc(%ebp),%edi Objects_Information *info; int the_class_api_maximum; if ( !the_class ) return NULL; 10b647:31 db xor %ebx,%ebx ) { Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 10b649:66 85 ff test %di,%di 10b64c:74 37 je 10b685 /* * 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 ); 10b64e:83 ec 0c sub $0xc,%esp 10b651:56 push %esi 10b652:e8 b1 40 00 00 call 10f708 if ( the_class_api_maximum == 0 ) 10b657:83 c4 10 add $0x10,%esp 10b65a:85 c0 test %eax,%eax 10b65c:74 27 je 10b685 return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 10b65e:0f b7 ff movzwl %di,%edi 10b661:39 c7 cmp %eax,%edi 10b663:77 20 ja 10b685 return NULL; if ( !_Objects_Information_table[ the_api ] ) 10b665:8b 04 b5 bc 42 12 00 mov 0x1242bc(,%esi,4),%eax 10b66c:85 c0 test %eax,%eax 10b66e:74 15 je 10b685 Object.id : id; 10c86b:8b 45 08 mov 0x8(%ebp),%eax 10c86e:85 c0 test %eax,%eax 10c870:75 08 jne 10c87a 10c872:a1 80 78 12 00 mov 0x127880,%eax 10c877:8b 40 08 mov 0x8(%eax),%eax 10c87a:89 c2 mov %eax,%edx 10c87c:c1 ea 18 shr $0x18,%edx 10c87f: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 ) 10c882:8d 4a ff lea -0x1(%edx),%ecx the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; 10c885:bb 03 00 00 00 mov $0x3,%ebx 10c88a:83 f9 02 cmp $0x2,%ecx 10c88d:77 36 ja 10c8c5 10c88f:eb 3b jmp 10c8cc */ RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_class( Objects_Id id ) { return (uint32_t) 10c891:89 c1 mov %eax,%ecx 10c893: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 ]; 10c896:8b 14 8a mov (%edx,%ecx,4),%edx if ( !information ) 10c899:85 d2 test %edx,%edx 10c89b:74 28 je 10c8c5 is_string ) 10c89d:80 7a 38 00 cmpb $0x0,0x38(%edx) 10c8a1:75 22 jne 10c8c5 name; 10c8b6:8b 50 0c mov 0xc(%eax),%edx 10c8b9:8b 45 0c mov 0xc(%ebp),%eax 10c8bc:89 10 mov %edx,(%eax) _Thread_Enable_dispatch(); 10c8be:e8 9f 07 00 00 call 10d062 return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10c8c3:31 db xor %ebx,%ebx } 10c8c5:89 d8 mov %ebx,%eax 10c8c7:8b 5d fc mov -0x4(%ebp),%ebx 10c8ca:c9 leave 10c8cb: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 ] ) 10c8cc:8b 14 95 08 73 12 00 mov 0x127308(,%edx,4),%edx 10c8d3:85 d2 test %edx,%edx 10c8d5:75 ba jne 10c891 10c8d7:eb ec jmp 10c8c5 ===============================================================================0010e2a8 : size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 10e2a8:55 push %ebp 10e2a9:89 e5 mov %esp,%ebp 10e2ab:57 push %edi 10e2ac:56 push %esi 10e2ad:53 push %ebx 10e2ae:83 ec 30 sub $0x30,%esp 10e2b1:8b 75 08 mov 0x8(%ebp),%esi 10e2b4:8b 5d 14 mov 0x14(%ebp),%ebx 10e2b7: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 ); 10e2ba: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( 10e2bd:50 push %eax 10e2be:56 push %esi 10e2bf:68 5c d9 12 00 push $0x12d95c 10e2c4:88 55 d4 mov %dl,-0x2c(%ebp) 10e2c7:e8 f0 2a 00 00 call 110dbc switch ( location ) { 10e2cc:83 c4 10 add $0x10,%esp 10e2cf:83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10e2d3:8a 55 d4 mov -0x2c(%ebp),%dl 10e2d6:0f 85 aa 00 00 00 jne 10e386 case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 10e2dc:8b 78 14 mov 0x14(%eax),%edi 10e2df:89 f9 mov %edi,%ecx 10e2e1:83 e1 03 and $0x3,%ecx 10e2e4:49 dec %ecx 10e2e5:75 0a jne 10e2f1 _Thread_Enable_dispatch(); 10e2e7:e8 22 33 00 00 call 11160e 10e2ec:e9 95 00 00 00 jmp 10e386 rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10e2f1:8b 40 10 mov 0x10(%eax),%eax if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 10e2f4:8b 48 68 mov 0x68(%eax),%ecx 10e2f7:39 4d 10 cmp %ecx,0x10(%ebp) 10e2fa:73 15 jae 10e311 _Thread_Enable_dispatch(); 10e2fc:e8 0d 33 00 00 call 11160e rtems_set_errno_and_return_minus_one( EMSGSIZE ); 10e301:e8 be 8a 00 00 call 116dc4 10e306:c7 00 7a 00 00 00 movl $0x7a,(%eax) 10e30c:e9 80 00 00 00 jmp 10e391 /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 10e311: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 ) 10e318:31 c9 xor %ecx,%ecx 10e31a:84 d2 test %dl,%dl 10e31c:74 09 je 10e327 oflag & O_NONBLOCK) ? false : true; 10e31e:81 e7 00 40 00 00 and $0x4000,%edi 10e324:0f 94 c1 sete %cl do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 10e327:52 push %edx 10e328:52 push %edx 10e329:ff 75 1c pushl 0x1c(%ebp) 10e32c:0f b6 c9 movzbl %cl,%ecx 10e32f:51 push %ecx 10e330:8d 55 e0 lea -0x20(%ebp),%edx 10e333:52 push %edx 10e334:ff 75 0c pushl 0xc(%ebp) 10e337:56 push %esi 10e338:83 c0 1c add $0x1c,%eax 10e33b:50 push %eax 10e33c:e8 73 1c 00 00 call 10ffb4 &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 10e341:83 c4 20 add $0x20,%esp 10e344:e8 c5 32 00 00 call 11160e *msg_prio = _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); 10e349:a1 d4 d9 12 00 mov 0x12d9d4,%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); 10e34e:8b 50 24 mov 0x24(%eax),%edx 10e351:c1 fa 1f sar $0x1f,%edx 10e354:8b 48 24 mov 0x24(%eax),%ecx 10e357:31 d1 xor %edx,%ecx 10e359:89 0b mov %ecx,(%ebx) 10e35b:29 13 sub %edx,(%ebx) if ( !_Thread_Executing->Wait.return_code ) 10e35d:83 78 34 00 cmpl $0x0,0x34(%eax) 10e361:75 05 jne 10e368 return length_out; 10e363:8b 45 e0 mov -0x20(%ebp),%eax 10e366:eb 2c jmp 10e394 rtems_set_errno_and_return_minus_one( 10e368:e8 57 8a 00 00 call 116dc4 10e36d:89 c3 mov %eax,%ebx 10e36f:83 ec 0c sub $0xc,%esp 10e372:a1 d4 d9 12 00 mov 0x12d9d4,%eax 10e377:ff 70 34 pushl 0x34(%eax) 10e37a:e8 ed 01 00 00 call 10e56c 10e37f:89 03 mov %eax,(%ebx) 10e381:83 c4 10 add $0x10,%esp 10e384:eb 0b jmp 10e391 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10e386:e8 39 8a 00 00 call 116dc4 10e38b:c7 00 09 00 00 00 movl $0x9,(%eax) 10e391:83 c8 ff or $0xffffffff,%eax } 10e394:8d 65 f4 lea -0xc(%ebp),%esp 10e397:5b pop %ebx 10e398:5e pop %esi 10e399:5f pop %edi 10e39a:c9 leave 10e39b:c3 ret ===============================================================================0010e85c : #include void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch( Thread_Control *the_thread ) { 10e85c:55 push %ebp 10e85d:89 e5 mov %esp,%ebp 10e85f:83 ec 08 sub $0x8,%esp 10e862:8b 55 08 mov 0x8(%ebp),%edx POSIX_API_Control *thread_support; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10e865:8b 82 f8 00 00 00 mov 0xf8(%edx),%eax if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10e86b:83 b8 d8 00 00 00 00 cmpl $0x0,0xd8(%eax) 10e872:75 2c jne 10e8a0 cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && 10e87d:83 b8 e0 00 00 00 00 cmpl $0x0,0xe0(%eax) 10e884:74 1a je 10e8a0 */ RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void ) { RTEMS_COMPILER_MEMORY_BARRIER(); _Thread_Dispatch_disable_level -= 1; 10e886:a1 d4 52 12 00 mov 0x1252d4,%eax 10e88b:48 dec %eax 10e88c:a3 d4 52 12 00 mov %eax,0x1252d4 thread_support->cancelation_requested ) { _Thread_Unnest_dispatch(); _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 10e891:50 push %eax 10e892:50 push %eax 10e893:6a ff push $0xffffffff 10e895:52 push %edx 10e896:e8 51 08 00 00 call 10f0ec 10e89b:83 c4 10 add $0x10,%esp } else _Thread_Enable_dispatch(); } 10e89e:c9 leave 10e89f:c3 ret 10e8a0: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(); 10e8a1:e9 c0 d9 ff ff jmp 10c266 ===============================================================================0010fae0 : int policy, struct sched_param *param, Thread_CPU_budget_algorithms *budget_algorithm, Thread_CPU_budget_algorithm_callout *budget_callout ) { 10fae0:55 push %ebp 10fae1:89 e5 mov %esp,%ebp 10fae3:57 push %edi 10fae4:56 push %esi 10fae5:53 push %ebx 10fae6:83 ec 28 sub $0x28,%esp 10fae9:8b 55 08 mov 0x8(%ebp),%edx 10faec:8b 5d 0c mov 0xc(%ebp),%ebx 10faef:8b 7d 10 mov 0x10(%ebp),%edi if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 10faf2:ff 33 pushl (%ebx) 10faf4:89 55 e0 mov %edx,-0x20(%ebp) 10faf7:e8 c4 ff ff ff call 10fac0 10fafc:83 c4 10 add $0x10,%esp return EINVAL; 10faff: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 ) ) 10fb04:84 c0 test %al,%al 10fb06:8b 55 e0 mov -0x20(%ebp),%edx 10fb09:0f 84 a4 00 00 00 je 10fbb3 sched_ss_repl_period.tv_sec == 0) && 10fb4b:83 7b 08 00 cmpl $0x0,0x8(%ebx) 10fb4f:75 06 jne 10fb57 10fb51:83 7b 0c 00 cmpl $0x0,0xc(%ebx) 10fb55:74 5c je 10fbb3 (param->sched_ss_repl_period.tv_nsec == 0) ) return EINVAL; if ( (param->sched_ss_init_budget.tv_sec == 0) && 10fb57:83 7b 10 00 cmpl $0x0,0x10(%ebx) 10fb5b:75 0b jne 10fb68 (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; 10fb5d: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) && 10fb62:83 7b 14 00 cmpl $0x0,0x14(%ebx) 10fb66:74 4b je 10fbb3 (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; if ( _Timespec_To_ticks( &param->sched_ss_repl_period ) < 10fb68:83 ec 0c sub $0xc,%esp 10fb6b:8d 43 08 lea 0x8(%ebx),%eax 10fb6e:50 push %eax 10fb6f:e8 14 de ff ff call 10d988 10fb74:89 45 e4 mov %eax,-0x1c(%ebp) _Timespec_To_ticks( &param->sched_ss_init_budget ) ) 10fb77:8d 43 10 lea 0x10(%ebx),%eax 10fb7a:89 04 24 mov %eax,(%esp) 10fb7d:e8 06 de ff ff call 10d988 if ( (param->sched_ss_init_budget.tv_sec == 0) && (param->sched_ss_init_budget.tv_nsec == 0) ) return EINVAL; if ( _Timespec_To_ticks( &param->sched_ss_repl_period ) < 10fb82:83 c4 10 add $0x10,%esp _Timespec_To_ticks( &param->sched_ss_init_budget ) ) return EINVAL; 10fb85: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( &param->sched_ss_repl_period ) < 10fb8a:39 45 e4 cmp %eax,-0x1c(%ebp) 10fb8d:72 24 jb 10fbb3 _Timespec_To_ticks( &param->sched_ss_init_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) ) 10fb8f:83 ec 0c sub $0xc,%esp 10fb92:ff 73 04 pushl 0x4(%ebx) 10fb95:e8 26 ff ff ff call 10fac0 10fb9a:83 c4 10 add $0x10,%esp 10fb9d:84 c0 test %al,%al 10fb9f:74 12 je 10fbb3 return EINVAL; *budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; 10fba1:c7 07 03 00 00 00 movl $0x3,(%edi) *budget_callout = _POSIX_Threads_Sporadic_budget_callout; 10fba7:8b 45 14 mov 0x14(%ebp),%eax 10fbaa:c7 00 d9 a7 10 00 movl $0x10a7d9,(%eax) return 0; 10fbb0:66 31 f6 xor %si,%si } return EINVAL; } 10fbb3:89 f0 mov %esi,%eax 10fbb5:8d 65 f4 lea -0xc(%ebp),%esp 10fbb8:5b pop %ebx 10fbb9:5e pop %esi 10fbba:5f pop %edi 10fbbb:c9 leave 10fbbc:c3 ret ===============================================================================0010a4dc : * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body(void) { 10a4dc:55 push %ebp 10a4dd:89 e5 mov %esp,%ebp 10a4df:57 push %edi 10a4e0:56 push %esi 10a4e1:53 push %ebx 10a4e2: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; 10a4e5:8b 3d 10 12 12 00 mov 0x121210,%edi maximum = Configuration_POSIX_API.number_of_initialization_threads; 10a4eb:8b 15 0c 12 12 00 mov 0x12120c,%edx if ( !user_threads || maximum == 0 ) 10a4f1:85 d2 test %edx,%edx 10a4f3:74 54 je 10a549 Wait.queue, the_thread ); 10ba83:89 5d 0c mov %ebx,0xc(%ebp) 10ba86:8b 43 44 mov 0x44(%ebx),%eax 10ba89: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 ); } 10ba8c:8d 65 f4 lea -0xc(%ebp),%esp 10ba8f:5b pop %ebx 10ba90:5e pop %esi 10ba91:5f pop %edi 10ba92: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 ); 10ba93:e9 30 0b 00 00 jmp 10c5c8 } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10ba98:83 e6 04 and $0x4,%esi 10ba9b:75 53 jne 10baf0 current_state = _States_Clear( STATES_TRANSIENT, state ); 10ba9d: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; 10baa4:8b 83 90 00 00 00 mov 0x90(%ebx),%eax 10baaa:66 8b 93 96 00 00 00 mov 0x96(%ebx),%dx 10bab1:66 09 10 or %dx,(%eax) _Priority_Major_bit_map |= the_priority_map->ready_major; 10bab4:66 a1 88 43 12 00 mov 0x124388,%ax 10baba:0b 83 94 00 00 00 or 0x94(%ebx),%eax 10bac0:66 a3 88 43 12 00 mov %ax,0x124388 _Priority_bit_map_Add( &the_thread->Priority_map ); if ( prepend_it ) 10bac6:80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10baca:8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax 10bad0:74 0e je 10bae0 Chain_Node *the_node ) { Chain_Node *before_node; the_node->previous = after_node; 10bad2:89 43 04 mov %eax,0x4(%ebx) before_node = after_node->next; 10bad5:8b 10 mov (%eax),%edx after_node->next = the_node; 10bad7:89 18 mov %ebx,(%eax) the_node->next = before_node; 10bad9:89 13 mov %edx,(%ebx) before_node->previous = the_node; 10badb:89 5a 04 mov %ebx,0x4(%edx) 10bade:eb 10 jmp 10baf0 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10bae0:8d 50 04 lea 0x4(%eax),%edx 10bae3:89 13 mov %edx,(%ebx) ) { Chain_Node *old_last_node; the_node->next = _Chain_Tail(the_chain); old_last_node = the_chain->last; 10bae5:8b 50 08 mov 0x8(%eax),%edx the_chain->last = the_node; 10bae8:89 58 08 mov %ebx,0x8(%eax) old_last_node->next = the_node; 10baeb:89 1a mov %ebx,(%edx) the_node->previous = old_last_node; 10baed: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 ); 10baf0:51 push %ecx 10baf1:9d popf 10baf2: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 ); 10baf3:66 8b 1d 88 43 12 00 mov 0x124388,%bx 10bafa:31 c0 xor %eax,%eax 10bafc:89 c2 mov %eax,%edx 10bafe:66 0f bc d3 bsf %bx,%dx _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor ); 10bb02:0f b7 d2 movzwl %dx,%edx 10bb05:66 8b 9c 12 f8 43 12 mov 0x1243f8(%edx,%edx,1),%bx 10bb0c:00 10bb0d:66 0f bc c3 bsf %bx,%ax return (_Priority_Bits_index( major ) current_priority < _Thread_Heir->current_priority ) { 10bba8:8b 50 14 mov 0x14(%eax),%edx 10bbab:8b 1d 38 48 12 00 mov 0x124838,%ebx 10bbb1:3b 53 14 cmp 0x14(%ebx),%edx 10bbb4:73 1b jae 10bbd1 _Thread_Heir = the_thread; 10bbb6:a3 38 48 12 00 mov %eax,0x124838 if ( _Thread_Executing->is_preemptible || 10bbbb:a1 34 48 12 00 mov 0x124834,%eax 10bbc0:80 78 74 00 cmpb $0x0,0x74(%eax) 10bbc4:75 04 jne 10bbca 10bbc6:85 d2 test %edx,%edx 10bbc8:75 07 jne 10bbd1 current_priority == 0 ) _Thread_Dispatch_necessary = true; 10bbca:c6 05 40 48 12 00 01 movb $0x1,0x124840 } } } _ISR_Enable( level ); 10bbd1:51 push %ecx 10bbd2:9d popf } 10bbd3:5b pop %ebx 10bbd4:c9 leave 10bbd5:c3 ret ===============================================================================0010bd4c : void _Thread_Delay_ended( Objects_Id id, void *ignored __attribute__((unused)) ) { 10bd4c:55 push %ebp 10bd4d:89 e5 mov %esp,%ebp 10bd4f:83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10bd52:8d 45 f4 lea -0xc(%ebp),%eax 10bd55:50 push %eax 10bd56:ff 75 08 pushl 0x8(%ebp) 10bd59:e8 82 01 00 00 call 10bee0 switch ( location ) { 10bd5e:83 c4 10 add $0x10,%esp 10bd61:83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10bd65:75 1b jne 10bd82 rtems_ada_self = rtems_ada_self; rtems_ada_self = heir->rtems_ada_self; #endif if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) 10bdc3:83 7e 7c 01 cmpl $0x1,0x7c(%esi) 10bdc7:75 09 jne 10bdd2 heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10bdc9:8b 15 b4 42 12 00 mov 0x1242b4,%edx 10bdcf:89 56 78 mov %edx,0x78(%esi) _ISR_Enable( level ); 10bdd2:50 push %eax 10bdd3:9d popf #ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__ { Timestamp_Control uptime, ran; _TOD_Get_uptime( &uptime ); 10bdd4:83 ec 0c sub $0xc,%esp 10bdd7:8d 45 e0 lea -0x20(%ebp),%eax 10bdda:50 push %eax 10bddb:e8 08 36 00 00 call 10f3e8 _Timestamp_Subtract( 10bde0:83 c4 0c add $0xc,%esp 10bde3:57 push %edi 10bde4:8d 45 e0 lea -0x20(%ebp),%eax 10bde7:50 push %eax 10bde8:68 98 43 12 00 push $0x124398 10bded:e8 32 0c 00 00 call 10ca24 &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timestamp_Add_to( &executing->cpu_time_used, &ran ); 10bdf2:58 pop %eax 10bdf3:5a pop %edx 10bdf4:57 push %edi 10bdf5:8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10bdfb:50 push %eax 10bdfc:e8 f3 0b 00 00 call 10c9f4 _Thread_Time_of_last_context_switch = uptime; 10be01:8b 45 e0 mov -0x20(%ebp),%eax 10be04:8b 55 e4 mov -0x1c(%ebp),%edx 10be07:a3 98 43 12 00 mov %eax,0x124398 10be0c:89 15 9c 43 12 00 mov %edx,0x12439c #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10be12:a1 6c 43 12 00 mov 0x12436c,%e