=============================================================================== 0010c238 : #define MAXSYMLINK 5 int IMFS_Set_handlers( rtems_filesystem_location_info_t *loc ) { 10c238: 55 push %ebp 10c239: 89 e5 mov %esp,%ebp 10c23b: 8b 4d 08 mov 0x8(%ebp),%ecx IMFS_jnode_t *node = loc->node_access; IMFS_fs_info_t *fs_info; fs_info = loc->mt_entry->fs_info; 10c23e: 8b 41 0c mov 0xc(%ecx),%eax 10c241: 8b 50 2c mov 0x2c(%eax),%edx switch( node->type ) { 10c244: 8b 01 mov (%ecx),%eax 10c246: 8b 40 4c mov 0x4c(%eax),%eax 10c249: 48 dec %eax 10c24a: 83 f8 05 cmp $0x5,%eax 10c24d: 77 24 ja 10c273 <== NEVER TAKEN 10c24f: ff 24 85 c4 75 11 00 jmp *0x1175c4(,%eax,4) case IMFS_DIRECTORY: loc->handlers = fs_info->directory_handlers; 10c256: 8b 42 08 mov 0x8(%edx),%eax 10c259: eb 15 jmp 10c270 break; case IMFS_DEVICE: loc->handlers = &IMFS_device_handlers; 10c25b: c7 41 04 b8 76 11 00 movl $0x1176b8,0x4(%ecx) 10c262: eb 0f jmp 10c273 break; case IMFS_SYM_LINK: case IMFS_HARD_LINK: loc->handlers = &IMFS_link_handlers; 10c264: c7 41 04 f0 76 11 00 movl $0x1176f0,0x4(%ecx) 10c26b: eb 06 jmp 10c273 break; case IMFS_LINEAR_FILE: loc->handlers = fs_info->memfile_handlers; break; case IMFS_MEMORY_FILE: loc->handlers = fs_info->memfile_handlers; 10c26d: 8b 42 04 mov 0x4(%edx),%eax 10c270: 89 41 04 mov %eax,0x4(%ecx) break; } return 0; } 10c273: 31 c0 xor %eax,%eax 10c275: c9 leave 10c276: c3 ret =============================================================================== 0010d718 : int IMFS_chown( rtems_filesystem_location_info_t *pathloc, /* IN */ uid_t owner, /* IN */ gid_t group /* IN */ ) { 10d718: 55 push %ebp 10d719: 89 e5 mov %esp,%ebp 10d71b: 57 push %edi 10d71c: 56 push %esi 10d71d: 53 push %ebx 10d71e: 83 ec 1c sub $0x1c,%esp 10d721: 8b 75 0c mov 0xc(%ebp),%esi 10d724: 8b 7d 10 mov 0x10(%ebp),%edi IMFS_jnode_t *jnode; #if defined(RTEMS_POSIX_API) uid_t st_uid; #endif jnode = (IMFS_jnode_t *) pathloc->node_access; 10d727: 8b 45 08 mov 0x8(%ebp),%eax 10d72a: 8b 18 mov (%eax),%ebx /* * Verify I am the owner of the node or the super user. */ #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 10d72c: e8 87 0c 00 00 call 10e3b8 if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) 10d731: 66 3b 43 3c cmp 0x3c(%ebx),%ax 10d735: 74 15 je 10d74c <== ALWAYS TAKEN 10d737: 66 85 c0 test %ax,%ax <== NOT EXECUTED 10d73a: 74 10 je 10d74c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EPERM ); 10d73c: e8 9f 38 00 00 call 110fe0 <__errno> <== NOT EXECUTED 10d741: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10d747: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10d74a: eb 20 jmp 10d76c <== NOT EXECUTED #endif jnode->st_uid = owner; 10d74c: 66 89 73 3c mov %si,0x3c(%ebx) jnode->st_gid = group; 10d750: 66 89 7b 3e mov %di,0x3e(%ebx) IMFS_update_ctime( jnode ); 10d754: 50 push %eax 10d755: 50 push %eax 10d756: 6a 00 push $0x0 10d758: 8d 45 ec lea -0x14(%ebp),%eax 10d75b: 50 push %eax 10d75c: e8 07 9d ff ff call 107468 10d761: 8b 45 ec mov -0x14(%ebp),%eax 10d764: 89 43 48 mov %eax,0x48(%ebx) 10d767: 31 c0 xor %eax,%eax 10d769: 83 c4 10 add $0x10,%esp return 0; } 10d76c: 8d 65 f4 lea -0xc(%ebp),%esp 10d76f: 5b pop %ebx 10d770: 5e pop %esi 10d771: 5f pop %edi 10d772: c9 leave 10d773: c3 ret =============================================================================== 0010e770 : IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) { 10e770: 55 push %ebp 10e771: 89 e5 mov %esp,%ebp 10e773: 57 push %edi 10e774: 56 push %esi 10e775: 53 push %ebx 10e776: 83 ec 1c sub $0x1c,%esp 10e779: 8b 75 14 mov 0x14(%ebp),%esi IMFS_jnode_t *node; struct timeval tv; IMFS_jnode_t *parent = NULL; IMFS_fs_info_t *fs_info; if ( parent_loc != NULL ) 10e77c: 31 ff xor %edi,%edi 10e77e: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 10e782: 74 05 je 10e789 parent = parent_loc->node_access; 10e784: 8b 45 08 mov 0x8(%ebp),%eax 10e787: 8b 38 mov (%eax),%edi /* * Allocate an IMFS jnode */ node = calloc( 1, sizeof( IMFS_jnode_t ) ); 10e789: 50 push %eax 10e78a: 50 push %eax 10e78b: 6a 60 push $0x60 10e78d: 6a 01 push $0x1 10e78f: e8 3c e5 ff ff call 10ccd0 10e794: 89 c3 mov %eax,%ebx if ( !node ) 10e796: 83 c4 10 add $0x10,%esp 10e799: 85 c0 test %eax,%eax 10e79b: 0f 84 00 01 00 00 je 10e8a1 <== NEVER TAKEN /* * Fill in the basic information */ node->st_nlink = 1; 10e7a1: 66 c7 40 34 01 00 movw $0x1,0x34(%eax) node->type = type; 10e7a7: 8b 55 0c mov 0xc(%ebp),%edx 10e7aa: 89 50 4c mov %edx,0x4c(%eax) strncpy( node->name, name, IMFS_NAME_MAX ); 10e7ad: 50 push %eax 10e7ae: 6a 20 push $0x20 10e7b0: ff 75 10 pushl 0x10(%ebp) 10e7b3: 8d 43 0c lea 0xc(%ebx),%eax 10e7b6: 50 push %eax 10e7b7: e8 f4 1b 00 00 call 1103b0 /* * Fill in the mode and permission information for the jnode structure. */ node->st_mode = mode & ~rtems_filesystem_umask; 10e7bc: a1 6c b6 11 00 mov 0x11b66c,%eax 10e7c1: 8b 40 24 mov 0x24(%eax),%eax 10e7c4: f7 d0 not %eax 10e7c6: 21 c6 and %eax,%esi 10e7c8: 89 73 30 mov %esi,0x30(%ebx) #if defined(RTEMS_POSIX_API) node->st_uid = geteuid(); 10e7cb: e8 74 e6 ff ff call 10ce44 10e7d0: 66 89 43 3c mov %ax,0x3c(%ebx) node->st_gid = getegid(); 10e7d4: e8 5b e6 ff ff call 10ce34 10e7d9: 66 89 43 3e mov %ax,0x3e(%ebx) /* * Now set all the times. */ gettimeofday( &tv, 0 ); 10e7dd: 5a pop %edx 10e7de: 59 pop %ecx 10e7df: 6a 00 push $0x0 10e7e1: 8d 45 ec lea -0x14(%ebp),%eax 10e7e4: 50 push %eax 10e7e5: e8 6a e6 ff ff call 10ce54 node->stat_atime = (time_t) tv.tv_sec; 10e7ea: 8b 45 ec mov -0x14(%ebp),%eax 10e7ed: 89 43 40 mov %eax,0x40(%ebx) node->stat_mtime = (time_t) tv.tv_sec; 10e7f0: 89 43 44 mov %eax,0x44(%ebx) node->stat_ctime = (time_t) tv.tv_sec; 10e7f3: 89 43 48 mov %eax,0x48(%ebx) /* * Set the type specific information */ switch (type) { 10e7f6: 83 c4 10 add $0x10,%esp 10e7f9: 8b 45 0c mov 0xc(%ebp),%eax 10e7fc: 48 dec %eax 10e7fd: 83 f8 05 cmp $0x5,%eax 10e800: 77 62 ja 10e864 <== NEVER TAKEN 10e802: ff 24 85 e0 7a 11 00 jmp *0x117ae0(,%eax,4) 10e809: 8d 43 54 lea 0x54(%ebx),%eax 10e80c: 89 43 50 mov %eax,0x50(%ebx) 10e80f: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) 10e816: 8d 43 50 lea 0x50(%ebx),%eax 10e819: 89 43 58 mov %eax,0x58(%ebx) 10e81c: eb 5c jmp 10e87a case IMFS_HARD_LINK: node->info.hard_link.link_node = info->hard_link.link_node; break; case IMFS_SYM_LINK: node->info.sym_link.name = info->sym_link.name; 10e81e: 8b 55 18 mov 0x18(%ebp),%edx 10e821: 8b 02 mov (%edx),%eax 10e823: 89 43 50 mov %eax,0x50(%ebx) 10e826: eb 52 jmp 10e87a break; case IMFS_DEVICE: node->info.device.major = info->device.major; 10e828: 8b 55 18 mov 0x18(%ebp),%edx 10e82b: 8b 02 mov (%edx),%eax 10e82d: 89 43 50 mov %eax,0x50(%ebx) node->info.device.minor = info->device.minor; 10e830: 8b 42 04 mov 0x4(%edx),%eax 10e833: 89 43 54 mov %eax,0x54(%ebx) 10e836: eb 42 jmp 10e87a break; case IMFS_LINEAR_FILE: node->info.linearfile.size = 0; 10e838: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED node->info.linearfile.direct = 0; 10e83f: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED case IMFS_MEMORY_FILE: node->info.file.size = 0; 10e846: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) node->info.file.indirect = 0; 10e84d: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) node->info.file.doubly_indirect = 0; 10e854: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) node->info.file.triply_indirect = 0; 10e85b: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) 10e862: eb 16 jmp 10e87a break; default: assert(0); 10e864: 68 a3 6b 11 00 push $0x116ba3 <== NOT EXECUTED 10e869: 68 f8 7a 11 00 push $0x117af8 <== NOT EXECUTED 10e86e: 6a 74 push $0x74 <== NOT EXECUTED 10e870: 68 90 7a 11 00 push $0x117a90 <== NOT EXECUTED 10e875: e8 0e 7a ff ff call 106288 <__assert_func> <== NOT EXECUTED /* * If this node has a parent, then put it in that directory list. */ if ( parent ) { 10e87a: 85 ff test %edi,%edi 10e87c: 74 23 je 10e8a1 10e87e: 50 push %eax 10e87f: 50 push %eax 10e880: 53 push %ebx 10e881: 8d 47 50 lea 0x50(%edi),%eax 10e884: 50 push %eax 10e885: e8 62 b2 ff ff call 109aec <_Chain_Append> rtems_chain_append( &parent->info.directory.Entries, &node->Node ); node->Parent = parent; 10e88a: 89 7b 08 mov %edi,0x8(%ebx) fs_info = parent_loc->mt_entry->fs_info; 10e88d: 8b 55 08 mov 0x8(%ebp),%edx 10e890: 8b 42 0c mov 0xc(%edx),%eax 10e893: 8b 50 2c mov 0x2c(%eax),%edx node->st_ino = ++fs_info->ino_count; 10e896: 8b 02 mov (%edx),%eax 10e898: 40 inc %eax 10e899: 89 02 mov %eax,(%edx) 10e89b: 89 43 38 mov %eax,0x38(%ebx) 10e89e: 83 c4 10 add $0x10,%esp } return node; } 10e8a1: 89 d8 mov %ebx,%eax 10e8a3: 8d 65 f4 lea -0xc(%ebp),%esp 10e8a6: 5b pop %ebx 10e8a7: 5e pop %esi 10e8a8: 5f pop %edi 10e8a9: c9 leave 10e8aa: c3 ret =============================================================================== 00107936 : void IMFS_dump_directory( IMFS_jnode_t *the_directory, int level ) { 107936: 55 push %ebp 107937: 89 e5 mov %esp,%ebp 107939: 57 push %edi 10793a: 56 push %esi 10793b: 53 push %ebx 10793c: 83 ec 0c sub $0xc,%esp 10793f: 8b 45 08 mov 0x8(%ebp),%eax 107942: 8b 7d 0c mov 0xc(%ebp),%edi rtems_chain_node *the_node; rtems_chain_control *the_chain; IMFS_jnode_t *the_jnode; int i; assert( the_directory ); 107945: 85 c0 test %eax,%eax 107947: 75 0e jne 107957 <== ALWAYS TAKEN 107949: 68 2b cc 11 00 push $0x11cc2b <== NOT EXECUTED 10794e: 68 14 cd 11 00 push $0x11cd14 <== NOT EXECUTED 107953: 6a 7f push $0x7f <== NOT EXECUTED 107955: eb 13 jmp 10796a <== NOT EXECUTED assert( level >= 0 ); 107957: 85 ff test %edi,%edi 107959: 79 19 jns 107974 <== ALWAYS TAKEN 10795b: 68 39 cc 11 00 push $0x11cc39 <== NOT EXECUTED 107960: 68 14 cd 11 00 push $0x11cd14 <== NOT EXECUTED 107965: 68 81 00 00 00 push $0x81 <== NOT EXECUTED 10796a: 68 8c cb 11 00 push $0x11cb8c <== NOT EXECUTED 10796f: e8 d8 05 00 00 call 107f4c <__assert_func> <== NOT EXECUTED assert( the_directory->type == IMFS_DIRECTORY ); 107974: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 107978: 74 11 je 10798b <== ALWAYS TAKEN 10797a: 68 44 cc 11 00 push $0x11cc44 <== NOT EXECUTED 10797f: 68 14 cd 11 00 push $0x11cd14 <== NOT EXECUTED 107984: 68 83 00 00 00 push $0x83 <== NOT EXECUTED 107989: eb df jmp 10796a <== NOT EXECUTED the_chain = &the_directory->info.directory.Entries; for ( the_node = the_chain->first; 10798b: 8b 70 50 mov 0x50(%eax),%esi 10798e: 83 c0 54 add $0x54,%eax 107991: 89 45 f0 mov %eax,-0x10(%ebp) for ( i=0 ; i<=level ; i++ ) fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); if ( the_jnode->type == IMFS_DIRECTORY ) IMFS_dump_directory( the_jnode, level + 1 ); 107994: 8d 47 01 lea 0x1(%edi),%eax 107997: 89 45 ec mov %eax,-0x14(%ebp) 10799a: eb 40 jmp 1079dc 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; 10799c: 31 db xor %ebx,%ebx for ( i=0 ; i<=level ; i++ ) fprintf(stdout, "...." ); 10799e: 50 push %eax 10799f: 50 push %eax 1079a0: a1 80 14 12 00 mov 0x121480,%eax 1079a5: ff 70 08 pushl 0x8(%eax) 1079a8: 68 6a cc 11 00 push $0x11cc6a 1079ad: e8 a2 b2 00 00 call 112c54 !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; for ( i=0 ; i<=level ; i++ ) 1079b2: 43 inc %ebx 1079b3: 83 c4 10 add $0x10,%esp 1079b6: 39 fb cmp %edi,%ebx 1079b8: 7e e4 jle 10799e fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); 1079ba: 83 ec 0c sub $0xc,%esp 1079bd: 56 push %esi 1079be: e8 73 fe ff ff call 107836 if ( the_jnode->type == IMFS_DIRECTORY ) 1079c3: 83 c4 10 add $0x10,%esp 1079c6: 83 7e 4c 01 cmpl $0x1,0x4c(%esi) 1079ca: 75 0e jne 1079da IMFS_dump_directory( the_jnode, level + 1 ); 1079cc: 50 push %eax 1079cd: 50 push %eax 1079ce: ff 75 ec pushl -0x14(%ebp) 1079d1: 56 push %esi 1079d2: e8 5f ff ff ff call 107936 1079d7: 83 c4 10 add $0x10,%esp the_chain = &the_directory->info.directory.Entries; for ( the_node = the_chain->first; !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { 1079da: 8b 36 mov (%esi),%esi assert( the_directory->type == IMFS_DIRECTORY ); the_chain = &the_directory->info.directory.Entries; for ( the_node = the_chain->first; !rtems_chain_is_tail( the_chain, the_node ); 1079dc: 3b 75 f0 cmp -0x10(%ebp),%esi 1079df: 75 bb jne 10799c fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); if ( the_jnode->type == IMFS_DIRECTORY ) IMFS_dump_directory( the_jnode, level + 1 ); } } 1079e1: 8d 65 f4 lea -0xc(%ebp),%esp 1079e4: 5b pop %ebx 1079e5: 5e pop %esi 1079e6: 5f pop %edi 1079e7: c9 leave 1079e8: c3 ret =============================================================================== 0010c3d7 : int IMFS_eval_path( const char *pathname, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10c3d7: 55 push %ebp 10c3d8: 89 e5 mov %esp,%ebp 10c3da: 57 push %edi 10c3db: 56 push %esi 10c3dc: 53 push %ebx 10c3dd: 83 ec 4c sub $0x4c,%esp 10c3e0: 8b 5d 10 mov 0x10(%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 ) ) { 10c3e3: f7 45 0c f8 ff ff ff testl $0xfffffff8,0xc(%ebp) 10c3ea: 74 19 je 10c405 <== ALWAYS TAKEN assert( 0 ); 10c3ec: 68 a3 6b 11 00 push $0x116ba3 <== NOT EXECUTED 10c3f1: 68 dc 75 11 00 push $0x1175dc <== NOT EXECUTED 10c3f6: 68 ea 01 00 00 push $0x1ea <== NOT EXECUTED 10c3fb: 68 eb 75 11 00 push $0x1175eb <== NOT EXECUTED 10c400: e8 83 9e ff ff call 106288 <__assert_func> <== NOT EXECUTED /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10c405: 8b 33 mov (%ebx),%esi 10c407: c7 45 b0 00 00 00 00 movl $0x0,-0x50(%ebp) 10c40e: bf 01 00 00 00 mov $0x1,%edi 10c413: e9 1d 01 00 00 jmp 10c535 * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], token, &len ); 10c418: 50 push %eax 10c419: 8d 45 f0 lea -0x10(%ebp),%eax 10c41c: 50 push %eax 10c41d: 8d 45 bf lea -0x41(%ebp),%eax 10c420: 50 push %eax 10c421: 8b 45 08 mov 0x8(%ebp),%eax 10c424: 03 45 b0 add -0x50(%ebp),%eax 10c427: 50 push %eax 10c428: e8 73 04 00 00 call 10c8a0 10c42d: 89 c7 mov %eax,%edi i += len; 10c42f: 8b 45 f0 mov -0x10(%ebp),%eax 10c432: 89 45 ac mov %eax,-0x54(%ebp) if ( !pathloc->node_access ) 10c435: 83 c4 10 add $0x10,%esp 10c438: 83 3b 00 cmpl $0x0,(%ebx) 10c43b: 0f 84 d0 00 00 00 je 10c511 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( ENOENT ); /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10c441: 85 ff test %edi,%edi 10c443: 74 1b je 10c460 if ( node->type == IMFS_DIRECTORY ) 10c445: 83 7e 4c 01 cmpl $0x1,0x4c(%esi) 10c449: 75 15 jne 10c460 if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10c44b: 50 push %eax 10c44c: 50 push %eax 10c44d: 6a 01 push $0x1 10c44f: 53 push %ebx 10c450: e8 22 fe ff ff call 10c277 10c455: 83 c4 10 add $0x10,%esp 10c458: 85 c0 test %eax,%eax 10c45a: 0f 84 3c 01 00 00 je 10c59c */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], token, &len ); i += len; 10c460: 8b 45 ac mov -0x54(%ebp),%eax 10c463: 01 45 b0 add %eax,-0x50(%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; 10c466: 8b 33 mov (%ebx),%esi switch( type ) { 10c468: 83 ff 03 cmp $0x3,%edi 10c46b: 74 34 je 10c4a1 10c46d: 83 ff 04 cmp $0x4,%edi 10c470: 0f 84 b2 00 00 00 je 10c528 10c476: 83 ff 02 cmp $0x2,%edi 10c479: 0f 85 b6 00 00 00 jne 10c535 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10c47f: a1 6c b6 11 00 mov 0x11b66c,%eax 10c484: 3b 70 14 cmp 0x14(%eax),%esi 10c487: 74 8f je 10c418 /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == 10c489: 8b 43 0c mov 0xc(%ebx),%eax 10c48c: 3b 70 18 cmp 0x18(%eax),%esi 10c48f: 75 0b jne 10c49c */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; /* Throw out the .. in this case */ } else { newloc = pathloc->mt_entry->mt_point_node; 10c491: 8d 7d e0 lea -0x20(%ebp),%edi 10c494: 8d 70 08 lea 0x8(%eax),%esi 10c497: e9 b9 00 00 00 jmp 10c555 *pathloc = newloc; return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc); } } else { if ( !node->Parent ) 10c49c: 8b 76 08 mov 0x8(%esi),%esi 10c49f: eb 6c jmp 10c50d case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { 10c4a1: 8b 46 4c mov 0x4c(%esi),%eax 10c4a4: 83 f8 03 cmp $0x3,%eax 10c4a7: 75 15 jne 10c4be IMFS_evaluate_hard_link( pathloc, 0 ); 10c4a9: 50 push %eax 10c4aa: 50 push %eax 10c4ab: 6a 00 push $0x0 10c4ad: 53 push %ebx 10c4ae: e8 2a fe ff ff call 10c2dd node = pathloc->node_access; 10c4b3: 8b 33 mov (%ebx),%esi if ( !node ) 10c4b5: 83 c4 10 add $0x10,%esp 10c4b8: 85 f6 test %esi,%esi 10c4ba: 75 23 jne 10c4df <== ALWAYS TAKEN 10c4bc: eb 27 jmp 10c4e5 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); } else if ( node->type == IMFS_SYM_LINK ) { 10c4be: 83 f8 04 cmp $0x4,%eax 10c4c1: 75 1c jne 10c4df result = IMFS_evaluate_sym_link( pathloc, 0 ); 10c4c3: 50 push %eax 10c4c4: 50 push %eax 10c4c5: 6a 00 push $0x0 10c4c7: 53 push %ebx 10c4c8: e8 62 fe ff ff call 10c32f 10c4cd: 89 c6 mov %eax,%esi node = pathloc->node_access; 10c4cf: 8b 03 mov (%ebx),%eax if ( result == -1 ) 10c4d1: 83 c4 10 add $0x10,%esp 10c4d4: 83 fe ff cmp $0xffffffff,%esi 10c4d7: 0f 84 cd 00 00 00 je 10c5aa <== NEVER TAKEN } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_sym_link( pathloc, 0 ); node = pathloc->node_access; 10c4dd: 89 c6 mov %eax,%esi /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10c4df: 83 7e 4c 01 cmpl $0x1,0x4c(%esi) 10c4e3: 74 10 je 10c4f5 rtems_set_errno_and_return_minus_one( ENOTDIR ); 10c4e5: e8 3e 2c 00 00 call 10f128 <__errno> 10c4ea: c7 00 14 00 00 00 movl $0x14,(%eax) 10c4f0: e9 b2 00 00 00 jmp 10c5a7 /* * 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 ) { 10c4f5: 8b 46 5c mov 0x5c(%esi),%eax 10c4f8: 85 c0 test %eax,%eax 10c4fa: 75 53 jne 10c54f /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10c4fc: 50 push %eax 10c4fd: 50 push %eax 10c4fe: 8d 45 bf lea -0x41(%ebp),%eax 10c501: 50 push %eax 10c502: 56 push %esi 10c503: e8 0c 03 00 00 call 10c814 10c508: 89 c6 mov %eax,%esi if ( !node ) 10c50a: 83 c4 10 add $0x10,%esp 10c50d: 85 f6 test %esi,%esi 10c50f: 75 10 jne 10c521 rtems_set_errno_and_return_minus_one( ENOENT ); 10c511: e8 12 2c 00 00 call 10f128 <__errno> 10c516: c7 00 02 00 00 00 movl $0x2,(%eax) 10c51c: e9 86 00 00 00 jmp 10c5a7 /* * Set the node access to the point we have found. */ pathloc->node_access = node; 10c521: 89 33 mov %esi,(%ebx) 10c523: e9 f0 fe ff ff jmp 10c418 case IMFS_NO_MORE_PATH: case IMFS_CURRENT_DIR: break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10c528: e8 fb 2b 00 00 call 10f128 <__errno> 10c52d: c7 00 5b 00 00 00 movl $0x5b,(%eax) 10c533: eb 72 jmp 10c5a7 /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 10c535: 85 ff test %edi,%edi 10c537: 74 09 je 10c542 10c539: 83 ff 04 cmp $0x4,%edi 10c53c: 0f 85 d6 fe ff ff jne 10c418 <== ALWAYS TAKEN * 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 ) { 10c542: 83 7e 4c 01 cmpl $0x1,0x4c(%esi) 10c546: 75 3b jne 10c583 if ( node->info.directory.mt_fs != NULL ) { 10c548: 8b 46 5c mov 0x5c(%esi),%eax 10c54b: 85 c0 test %eax,%eax 10c54d: 74 34 je 10c583 newloc = node->info.directory.mt_fs->mt_fs_root; 10c54f: 8d 7d e0 lea -0x20(%ebp),%edi 10c552: 8d 70 18 lea 0x18(%eax),%esi 10c555: b9 04 00 00 00 mov $0x4,%ecx 10c55a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10c55c: 8d 75 e0 lea -0x20(%ebp),%esi 10c55f: b1 04 mov $0x4,%cl 10c561: 89 df mov %ebx,%edi 10c563: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc ); 10c565: 50 push %eax 10c566: 8b 53 08 mov 0x8(%ebx),%edx 10c569: 53 push %ebx 10c56a: ff 75 0c pushl 0xc(%ebp) 10c56d: 8b 45 f0 mov -0x10(%ebp),%eax 10c570: 29 45 b0 sub %eax,-0x50(%ebp) 10c573: 8b 45 08 mov 0x8(%ebp),%eax 10c576: 03 45 b0 add -0x50(%ebp),%eax 10c579: 50 push %eax 10c57a: ff 12 call *(%edx) 10c57c: 89 c6 mov %eax,%esi 10c57e: 83 c4 10 add $0x10,%esp 10c581: eb 27 jmp 10c5aa } else { result = IMFS_Set_handlers( pathloc ); } } else { result = IMFS_Set_handlers( pathloc ); 10c583: 53 push %ebx 10c584: e8 af fc ff ff call 10c238 10c589: 89 c6 mov %eax,%esi 10c58b: 57 push %edi /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) 10c58c: ff 75 0c pushl 0xc(%ebp) 10c58f: 53 push %ebx 10c590: e8 e2 fc ff ff call 10c277 10c595: 83 c4 10 add $0x10,%esp 10c598: 85 c0 test %eax,%eax 10c59a: 75 0e jne 10c5aa rtems_set_errno_and_return_minus_one( EACCES ); 10c59c: e8 87 2b 00 00 call 10f128 <__errno> 10c5a1: c7 00 0d 00 00 00 movl $0xd,(%eax) 10c5a7: 83 ce ff or $0xffffffff,%esi return result; } 10c5aa: 89 f0 mov %esi,%eax 10c5ac: 8d 65 f4 lea -0xc(%ebp),%esp 10c5af: 5b pop %ebx 10c5b0: 5e pop %esi 10c5b1: 5f pop %edi 10c5b2: c9 leave 10c5b3: c3 ret =============================================================================== 0010c63b : int IMFS_evaluate_for_make( const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) { 10c63b: 55 push %ebp 10c63c: 89 e5 mov %esp,%ebp 10c63e: 57 push %edi 10c63f: 56 push %esi 10c640: 53 push %ebx 10c641: 83 ec 4c sub $0x4c,%esp 10c644: 8b 5d 0c mov 0xc(%ebp),%ebx /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10c647: 8b 33 mov (%ebx),%esi 10c649: c7 45 b0 00 00 00 00 movl $0x0,-0x50(%ebp) * Evaluate all tokens until we are done or an error occurs. */ while( !done ) { type = IMFS_get_token( &path[i], token, &len ); 10c650: 50 push %eax 10c651: 8d 45 f0 lea -0x10(%ebp),%eax 10c654: 50 push %eax 10c655: 8d 55 bf lea -0x41(%ebp),%edx 10c658: 52 push %edx 10c659: 8b 45 08 mov 0x8(%ebp),%eax 10c65c: 03 45 b0 add -0x50(%ebp),%eax 10c65f: 50 push %eax 10c660: e8 3b 02 00 00 call 10c8a0 10c665: 89 c7 mov %eax,%edi i += len; 10c667: 8b 45 f0 mov -0x10(%ebp),%eax 10c66a: 89 45 ac mov %eax,-0x54(%ebp) if ( !pathloc->node_access ) 10c66d: 83 c4 10 add $0x10,%esp 10c670: 83 3b 00 cmpl $0x0,(%ebx) 10c673: 0f 84 40 01 00 00 je 10c7b9 <== NEVER TAKEN /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10c679: 85 ff test %edi,%edi 10c67b: 74 1b je 10c698 if ( node->type == IMFS_DIRECTORY ) 10c67d: 83 7e 4c 01 cmpl $0x1,0x4c(%esi) 10c681: 75 15 jne 10c698 if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10c683: 50 push %eax 10c684: 50 push %eax 10c685: 6a 01 push $0x1 10c687: 53 push %ebx 10c688: e8 ea fb ff ff call 10c277 10c68d: 83 c4 10 add $0x10,%esp 10c690: 85 c0 test %eax,%eax 10c692: 0f 84 63 01 00 00 je 10c7fb */ while( !done ) { type = IMFS_get_token( &path[i], token, &len ); i += len; 10c698: 8b 55 ac mov -0x54(%ebp),%edx 10c69b: 01 55 b0 add %edx,-0x50(%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; 10c69e: 8b 33 mov (%ebx),%esi switch( type ) { 10c6a0: 83 ff 02 cmp $0x2,%edi 10c6a3: 74 1b je 10c6c0 10c6a5: 77 0a ja 10c6b1 10c6a7: 85 ff test %edi,%edi 10c6a9: 0f 84 cf 00 00 00 je 10c77e 10c6af: eb 9f jmp 10c650 10c6b1: 83 ff 03 cmp $0x3,%edi 10c6b4: 74 34 je 10c6ea 10c6b6: 83 ff 04 cmp $0x4,%edi 10c6b9: 75 95 jne 10c650 <== NEVER TAKEN 10c6bb: e9 cb 00 00 00 jmp 10c78b case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10c6c0: a1 6c b6 11 00 mov 0x11b66c,%eax 10c6c5: 3b 70 14 cmp 0x14(%eax),%esi 10c6c8: 74 86 je 10c650 /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){ 10c6ca: 8b 43 0c mov 0xc(%ebx),%eax 10c6cd: 3b 70 18 cmp 0x18(%eax),%esi 10c6d0: 75 08 jne 10c6da if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; } else { newloc = pathloc->mt_entry->mt_point_node; 10c6d2: 8d 7d e0 lea -0x20(%ebp),%edi 10c6d5: 8d 70 08 lea 0x8(%eax),%esi 10c6d8: eb 56 jmp 10c730 *pathloc = newloc; return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); } } else { if ( !node->Parent ) 10c6da: 8b 76 08 mov 0x8(%esi),%esi 10c6dd: 85 f6 test %esi,%esi 10c6df: 0f 85 92 00 00 00 jne 10c777 10c6e5: e9 cf 00 00 00 jmp 10c7b9 pathloc->node_access = node; break; case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { 10c6ea: 8b 46 4c mov 0x4c(%esi),%eax 10c6ed: 83 f8 03 cmp $0x3,%eax 10c6f0: 74 05 je 10c6f7 result = IMFS_evaluate_link( pathloc, 0 ); if ( result == -1 ) return -1; } else if ( node->type == IMFS_SYM_LINK ) { 10c6f2: 83 f8 04 cmp $0x4,%eax 10c6f5: 75 18 jne 10c70f result = IMFS_evaluate_link( pathloc, 0 ); 10c6f7: 57 push %edi 10c6f8: 57 push %edi 10c6f9: 6a 00 push $0x0 10c6fb: 53 push %ebx 10c6fc: e8 b3 fe ff ff call 10c5b4 10c701: 89 c6 mov %eax,%esi if ( result == -1 ) 10c703: 83 c4 10 add $0x10,%esp 10c706: 83 f8 ff cmp $0xffffffff,%eax 10c709: 0f 84 fa 00 00 00 je 10c809 <== NEVER TAKEN return -1; } node = pathloc->node_access; 10c70f: 8b 03 mov (%ebx),%eax if ( !node ) 10c711: 85 c0 test %eax,%eax 10c713: 0f 84 c4 00 00 00 je 10c7dd <== NEVER TAKEN /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10c719: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 10c71d: 0f 85 ba 00 00 00 jne 10c7dd /* * 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 ) { 10c723: 8b 50 5c mov 0x5c(%eax),%edx 10c726: 85 d2 test %edx,%edx 10c728: 74 38 je 10c762 newloc = node->info.directory.mt_fs->mt_fs_root; 10c72a: 8d 7d e0 lea -0x20(%ebp),%edi 10c72d: 8d 72 18 lea 0x18(%edx),%esi 10c730: b9 04 00 00 00 mov $0x4,%ecx 10c735: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10c737: 8d 75 e0 lea -0x20(%ebp),%esi 10c73a: b1 04 mov $0x4,%cl 10c73c: 89 df mov %ebx,%edi 10c73e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10c740: 56 push %esi 10c741: 8b 53 08 mov 0x8(%ebx),%edx 10c744: ff 75 10 pushl 0x10(%ebp) 10c747: 53 push %ebx 10c748: 8b 45 f0 mov -0x10(%ebp),%eax 10c74b: 29 45 b0 sub %eax,-0x50(%ebp) 10c74e: 8b 45 08 mov 0x8(%ebp),%eax 10c751: 03 45 b0 add -0x50(%ebp),%eax 10c754: 50 push %eax 10c755: ff 52 04 call *0x4(%edx) 10c758: 89 c6 mov %eax,%esi 10c75a: 83 c4 10 add $0x10,%esp 10c75d: e9 a7 00 00 00 jmp 10c809 /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10c762: 51 push %ecx 10c763: 51 push %ecx 10c764: 8d 55 bf lea -0x41(%ebp),%edx 10c767: 52 push %edx 10c768: 50 push %eax 10c769: e8 a6 00 00 00 call 10c814 10c76e: 89 c6 mov %eax,%esi /* * If there is no node we have found the name of the node we * wish to create. */ if ( ! node ) 10c770: 83 c4 10 add $0x10,%esp 10c773: 85 c0 test %eax,%eax 10c775: 74 21 je 10c798 done = true; else pathloc->node_access = node; 10c777: 89 33 mov %esi,(%ebx) 10c779: e9 d2 fe ff ff jmp 10c650 break; case IMFS_NO_MORE_PATH: rtems_set_errno_and_return_minus_one( EEXIST ); 10c77e: e8 a5 29 00 00 call 10f128 <__errno> 10c783: c7 00 11 00 00 00 movl $0x11,(%eax) 10c789: eb 7b jmp 10c806 break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10c78b: e8 98 29 00 00 call 10f128 <__errno> 10c790: c7 00 5b 00 00 00 movl $0x5b,(%eax) 10c796: eb 6e jmp 10c806 case IMFS_CURRENT_DIR: break; } } *name = &path[ i - len ]; 10c798: 8b 45 b0 mov -0x50(%ebp),%eax 10c79b: 2b 45 f0 sub -0x10(%ebp),%eax 10c79e: 03 45 08 add 0x8(%ebp),%eax 10c7a1: 8b 55 10 mov 0x10(%ebp),%edx 10c7a4: 89 02 mov %eax,(%edx) 10c7a6: 8b 45 08 mov 0x8(%ebp),%eax 10c7a9: 03 45 b0 add -0x50(%ebp),%eax 10c7ac: eb 18 jmp 10c7c6 /* * 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++) { 10c7ae: 40 inc %eax if ( !IMFS_is_separator( path[ i ] ) ) 10c7af: 80 fa 2f cmp $0x2f,%dl 10c7b2: 74 12 je 10c7c6 10c7b4: 80 fa 5c cmp $0x5c,%dl 10c7b7: 74 0d je 10c7c6 rtems_set_errno_and_return_minus_one( ENOENT ); 10c7b9: e8 6a 29 00 00 call 10f128 <__errno> 10c7be: c7 00 02 00 00 00 movl $0x2,(%eax) 10c7c4: eb 40 jmp 10c806 /* * 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++) { 10c7c6: 8a 10 mov (%eax),%dl 10c7c8: 84 d2 test %dl,%dl 10c7ca: 75 e2 jne 10c7ae /* * Verify we can execute and write to this directory. */ result = IMFS_Set_handlers( pathloc ); 10c7cc: 53 push %ebx 10c7cd: e8 66 fa ff ff call 10c238 10c7d2: 89 c6 mov %eax,%esi /* * The returned node must be a directory */ node = pathloc->node_access; if ( node->type != IMFS_DIRECTORY ) 10c7d4: 8b 03 mov (%ebx),%eax 10c7d6: 5a pop %edx 10c7d7: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 10c7db: 74 0d je 10c7ea <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTDIR ); 10c7dd: e8 46 29 00 00 call 10f128 <__errno> 10c7e2: c7 00 14 00 00 00 movl $0x14,(%eax) 10c7e8: eb 1c jmp 10c806 /* * We must have Write and execute permission on the returned node. */ if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) 10c7ea: 57 push %edi 10c7eb: 57 push %edi 10c7ec: 6a 03 push $0x3 10c7ee: 53 push %ebx 10c7ef: e8 83 fa ff ff call 10c277 10c7f4: 83 c4 10 add $0x10,%esp 10c7f7: 85 c0 test %eax,%eax 10c7f9: 75 0e jne 10c809 rtems_set_errno_and_return_minus_one( EACCES ); 10c7fb: e8 28 29 00 00 call 10f128 <__errno> 10c800: c7 00 0d 00 00 00 movl $0xd,(%eax) 10c806: 83 ce ff or $0xffffffff,%esi return result; } 10c809: 89 f0 mov %esi,%eax 10c80b: 8d 65 f4 lea -0xc(%ebp),%esp 10c80e: 5b pop %ebx 10c80f: 5e pop %esi 10c810: 5f pop %edi 10c811: c9 leave 10c812: c3 ret =============================================================================== 0010c2dd : int IMFS_evaluate_hard_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10c2dd: 55 push %ebp 10c2de: 89 e5 mov %esp,%ebp 10c2e0: 53 push %ebx 10c2e1: 83 ec 04 sub $0x4,%esp 10c2e4: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *jnode = node->node_access; 10c2e7: 8b 03 mov (%ebx),%eax /* * Check for things that should never happen. */ if ( jnode->type != IMFS_HARD_LINK ) 10c2e9: 83 78 4c 03 cmpl $0x3,0x4c(%eax) 10c2ed: 74 0d je 10c2fc rtems_fatal_error_occurred (0xABCD0000); 10c2ef: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c2f2: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED 10c2f7: e8 98 d4 ff ff call 109794 <== NOT EXECUTED /* * Set the hard link value and the handlers. */ node->node_access = jnode->info.hard_link.link_node; 10c2fc: 8b 40 50 mov 0x50(%eax),%eax 10c2ff: 89 03 mov %eax,(%ebx) IMFS_Set_handlers( node ); 10c301: 53 push %ebx 10c302: e8 31 ff ff ff call 10c238 /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) 10c307: 50 push %eax 10c308: ff 75 0c pushl 0xc(%ebp) 10c30b: 53 push %ebx 10c30c: e8 66 ff ff ff call 10c277 10c311: 83 c4 10 add $0x10,%esp 10c314: 31 d2 xor %edx,%edx 10c316: 85 c0 test %eax,%eax 10c318: 75 0e jne 10c328 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EACCES ); 10c31a: e8 09 2e 00 00 call 10f128 <__errno> <== NOT EXECUTED 10c31f: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10c325: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED return result; } 10c328: 89 d0 mov %edx,%eax 10c32a: 8b 5d fc mov -0x4(%ebp),%ebx 10c32d: c9 leave 10c32e: c3 ret =============================================================================== 0010c277 : int IMFS_evaluate_permission( rtems_filesystem_location_info_t *node, int flags ) { 10c277: 55 push %ebp 10c278: 89 e5 mov %esp,%ebp 10c27a: 57 push %edi 10c27b: 56 push %esi 10c27c: 53 push %ebx 10c27d: 83 ec 0c sub $0xc,%esp 10c280: 8b 7d 0c mov 0xc(%ebp),%edi uid_t st_uid; gid_t st_gid; IMFS_jnode_t *jnode; int flags_to_test; if ( !rtems_libio_is_valid_perms( flags ) ) 10c283: f7 c7 f8 ff ff ff test $0xfffffff8,%edi 10c289: 74 10 je 10c29b <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EPERM ); 10c28b: e8 98 2e 00 00 call 10f128 <__errno> <== NOT EXECUTED 10c290: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10c296: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10c299: eb 3a jmp 10c2d5 <== NOT EXECUTED jnode = node->node_access; 10c29b: 8b 45 08 mov 0x8(%ebp),%eax 10c29e: 8b 30 mov (%eax),%esi #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 10c2a0: e8 9f 0b 00 00 call 10ce44 10c2a5: 89 c3 mov %eax,%ebx st_gid = getegid(); 10c2a7: e8 88 0b 00 00 call 10ce34 * Check if I am owner or a group member or someone else. */ flags_to_test = flags; if ( st_uid == jnode->st_uid ) 10c2ac: 66 3b 5e 3c cmp 0x3c(%esi),%bx 10c2b0: 75 07 jne 10c2b9 flags_to_test <<= 6; 10c2b2: 89 fa mov %edi,%edx 10c2b4: c1 e2 06 shl $0x6,%edx 10c2b7: eb 0f jmp 10c2c8 else if ( st_gid == jnode->st_gid ) 10c2b9: 89 fa mov %edi,%edx 10c2bb: 66 3b 46 3e cmp 0x3e(%esi),%ax 10c2bf: 75 07 jne 10c2c8 <== NEVER TAKEN flags_to_test <<= 3; 10c2c1: 8d 14 fd 00 00 00 00 lea 0x0(,%edi,8),%edx /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10c2c8: 89 d0 mov %edx,%eax 10c2ca: 23 46 30 and 0x30(%esi),%eax 10c2cd: 39 d0 cmp %edx,%eax 10c2cf: 0f 94 c0 sete %al 10c2d2: 0f b6 c0 movzbl %al,%eax return 1; return 0; } 10c2d5: 83 c4 0c add $0xc,%esp 10c2d8: 5b pop %ebx 10c2d9: 5e pop %esi 10c2da: 5f pop %edi 10c2db: c9 leave 10c2dc: c3 ret =============================================================================== 0010c32f : int IMFS_evaluate_sym_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10c32f: 55 push %ebp 10c330: 89 e5 mov %esp,%ebp 10c332: 57 push %edi 10c333: 56 push %esi 10c334: 53 push %ebx 10c335: 83 ec 0c sub $0xc,%esp IMFS_jnode_t *jnode = node->node_access; 10c338: 8b 45 08 mov 0x8(%ebp),%eax 10c33b: 8b 18 mov (%eax),%ebx /* * Check for things that should never happen. */ if ( jnode->type != IMFS_SYM_LINK ) 10c33d: 83 7b 4c 04 cmpl $0x4,0x4c(%ebx) 10c341: 74 0a je 10c34d <== ALWAYS TAKEN rtems_fatal_error_occurred (0xABCD0000); 10c343: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c346: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED 10c34b: eb 0f jmp 10c35c <== NOT EXECUTED if ( !jnode->Parent ) 10c34d: 8b 43 08 mov 0x8(%ebx),%eax 10c350: 85 c0 test %eax,%eax 10c352: 75 0d jne 10c361 <== ALWAYS TAKEN rtems_fatal_error_occurred( 0xBAD00000 ); 10c354: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c357: 68 00 00 d0 ba push $0xbad00000 <== NOT EXECUTED 10c35c: e8 33 d4 ff ff call 109794 <== NOT EXECUTED /* * Move the node_access to either the symbolic links parent or * root depending on the symbolic links path. */ node->node_access = jnode->Parent; 10c361: 8b 55 08 mov 0x8(%ebp),%edx 10c364: 89 02 mov %eax,(%edx) rtems_filesystem_get_sym_start_loc( 10c366: 8b 43 50 mov 0x50(%ebx),%eax 10c369: 8a 00 mov (%eax),%al 10c36b: 3c 2f cmp $0x2f,%al 10c36d: 74 0a je 10c379 10c36f: 3c 5c cmp $0x5c,%al 10c371: 74 06 je 10c379 <== NEVER TAKEN 10c373: 31 d2 xor %edx,%edx 10c375: 84 c0 test %al,%al 10c377: 75 17 jne 10c390 <== ALWAYS TAKEN 10c379: a1 6c b6 11 00 mov 0x11b66c,%eax 10c37e: 8d 70 14 lea 0x14(%eax),%esi 10c381: b9 04 00 00 00 mov $0x4,%ecx 10c386: 8b 7d 08 mov 0x8(%ebp),%edi 10c389: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10c38b: ba 01 00 00 00 mov $0x1,%edx /* * Use eval path to evaluate the path of the symbolic link. */ result = IMFS_eval_path( 10c390: 51 push %ecx 10c391: ff 75 08 pushl 0x8(%ebp) 10c394: ff 75 0c pushl 0xc(%ebp) 10c397: 03 53 50 add 0x50(%ebx),%edx 10c39a: 52 push %edx 10c39b: e8 37 00 00 00 call 10c3d7 10c3a0: 89 c3 mov %eax,%ebx &jnode->info.sym_link.name[i], flags, node ); IMFS_Set_handlers( node ); 10c3a2: ff 75 08 pushl 0x8(%ebp) 10c3a5: e8 8e fe ff ff call 10c238 /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) 10c3aa: 83 c4 0c add $0xc,%esp 10c3ad: ff 75 0c pushl 0xc(%ebp) 10c3b0: ff 75 08 pushl 0x8(%ebp) 10c3b3: e8 bf fe ff ff call 10c277 10c3b8: 83 c4 10 add $0x10,%esp 10c3bb: 85 c0 test %eax,%eax 10c3bd: 75 0e jne 10c3cd <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EACCES ); 10c3bf: e8 64 2d 00 00 call 10f128 <__errno> <== NOT EXECUTED 10c3c4: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10c3ca: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED return result; } 10c3cd: 89 d8 mov %ebx,%eax 10c3cf: 8d 65 f4 lea -0xc(%ebp),%esp 10c3d2: 5b pop %ebx 10c3d3: 5e pop %esi 10c3d4: 5f pop %edi 10c3d5: c9 leave 10c3d6: c3 ret =============================================================================== 0010e8ac : int IMFS_fchmod( rtems_filesystem_location_info_t *loc, mode_t mode ) { 10e8ac: 55 push %ebp 10e8ad: 89 e5 mov %esp,%ebp 10e8af: 56 push %esi 10e8b0: 53 push %ebx 10e8b1: 83 ec 10 sub $0x10,%esp 10e8b4: 8b 5d 0c mov 0xc(%ebp),%ebx IMFS_jnode_t *jnode; #if defined(RTEMS_POSIX_API) uid_t st_uid; #endif jnode = loc->node_access; 10e8b7: 8b 45 08 mov 0x8(%ebp),%eax 10e8ba: 8b 30 mov (%eax),%esi /* * Verify I am the owner of the node or the super user. */ #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 10e8bc: e8 83 e5 ff ff call 10ce44 if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) 10e8c1: 66 3b 46 3c cmp 0x3c(%esi),%ax 10e8c5: 74 05 je 10e8cc <== ALWAYS TAKEN 10e8c7: 66 85 c0 test %ax,%ax <== NOT EXECUTED 10e8ca: 75 08 jne 10e8d4 <== NOT EXECUTED #endif /* * Change only the RWX permissions on the jnode to mode. */ if ( mode & (~ (S_IRWXU | S_IRWXG | S_IRWXO ) ) ) 10e8cc: f7 c3 00 fe ff ff test $0xfffffe00,%ebx 10e8d2: 74 10 je 10e8e4 rtems_set_errno_and_return_minus_one( EPERM ); 10e8d4: e8 4f 08 00 00 call 10f128 <__errno> 10e8d9: c7 00 01 00 00 00 movl $0x1,(%eax) 10e8df: 83 c8 ff or $0xffffffff,%eax 10e8e2: eb 25 jmp 10e909 jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO); jnode->st_mode |= mode; 10e8e4: 8b 46 30 mov 0x30(%esi),%eax 10e8e7: 25 00 fe ff ff and $0xfffffe00,%eax 10e8ec: 09 c3 or %eax,%ebx 10e8ee: 89 5e 30 mov %ebx,0x30(%esi) IMFS_update_ctime( jnode ); 10e8f1: 50 push %eax 10e8f2: 50 push %eax 10e8f3: 6a 00 push $0x0 10e8f5: 8d 45 f0 lea -0x10(%ebp),%eax 10e8f8: 50 push %eax 10e8f9: e8 56 e5 ff ff call 10ce54 10e8fe: 8b 45 f0 mov -0x10(%ebp),%eax 10e901: 89 46 48 mov %eax,0x48(%esi) 10e904: 31 c0 xor %eax,%eax 10e906: 83 c4 10 add $0x10,%esp return 0; } 10e909: 8d 65 f8 lea -0x8(%ebp),%esp 10e90c: 5b pop %ebx 10e90d: 5e pop %esi 10e90e: c9 leave 10e90f: c3 ret =============================================================================== 0010c814 : IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) { 10c814: 55 push %ebp 10c815: 89 e5 mov %esp,%ebp 10c817: 57 push %edi 10c818: 56 push %esi 10c819: 53 push %ebx 10c81a: 83 ec 0c sub $0xc,%esp 10c81d: 8b 5d 08 mov 0x8(%ebp),%ebx 10c820: 8b 7d 0c mov 0xc(%ebp),%edi /* * Check for fatal errors. A NULL directory show a problem in the * the IMFS code. */ assert( directory ); 10c823: 85 db test %ebx,%ebx 10c825: 75 16 jne 10c83d <== ALWAYS TAKEN 10c827: 68 39 76 11 00 push $0x117639 <== NOT EXECUTED 10c82c: 68 a0 76 11 00 push $0x1176a0 <== NOT EXECUTED 10c831: 6a 2a push $0x2a <== NOT EXECUTED 10c833: 68 43 76 11 00 push $0x117643 <== NOT EXECUTED 10c838: e8 4b 9a ff ff call 106288 <__assert_func> <== NOT EXECUTED if ( !name ) 10c83d: 85 ff test %edi,%edi 10c83f: 74 52 je 10c893 <== NEVER TAKEN /* * Check for "." and ".." */ if ( !strcmp( name, dotname ) ) 10c841: 51 push %ecx 10c842: 51 push %ecx 10c843: 68 98 76 11 00 push $0x117698 10c848: 57 push %edi 10c849: e8 d6 39 00 00 call 110224 10c84e: 83 c4 10 add $0x10,%esp 10c851: 85 c0 test %eax,%eax 10c853: 74 40 je 10c895 <== NEVER TAKEN return directory; if ( !strcmp( name, dotdotname ) ) 10c855: 52 push %edx 10c856: 52 push %edx 10c857: 68 9a 76 11 00 push $0x11769a 10c85c: 57 push %edi 10c85d: e8 c2 39 00 00 call 110224 10c862: 83 c4 10 add $0x10,%esp 10c865: 85 c0 test %eax,%eax 10c867: 75 05 jne 10c86e <== ALWAYS TAKEN return directory->Parent; 10c869: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10c86c: eb 27 jmp 10c895 <== NOT EXECUTED the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; 10c86e: 8b 73 50 mov 0x50(%ebx),%esi * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10c871: 83 c3 54 add $0x54,%ebx 10c874: eb 19 jmp 10c88f !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 ) ) 10c876: 50 push %eax 10c877: 50 push %eax 10c878: 8d 46 0c lea 0xc(%esi),%eax 10c87b: 50 push %eax 10c87c: 57 push %edi 10c87d: e8 a2 39 00 00 call 110224 10c882: 83 c4 10 add $0x10,%esp 10c885: 85 c0 test %eax,%eax 10c887: 75 04 jne 10c88d 10c889: 89 f3 mov %esi,%ebx 10c88b: eb 08 jmp 10c895 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 ) { 10c88d: 8b 36 mov (%esi),%esi return directory->Parent; the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; !rtems_chain_is_tail( the_chain, the_node ); 10c88f: 39 de cmp %ebx,%esi 10c891: 75 e3 jne 10c876 10c893: 31 db xor %ebx,%ebx if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10c895: 89 d8 mov %ebx,%eax 10c897: 8d 65 f4 lea -0xc(%ebp),%esp 10c89a: 5b pop %ebx 10c89b: 5e pop %esi 10c89c: 5f pop %edi 10c89d: c9 leave 10c89e: c3 ret =============================================================================== 0010de94 : ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next)) int IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 10de94: 55 push %ebp 10de95: 89 e5 mov %esp,%ebp 10de97: 57 push %edi 10de98: 56 push %esi 10de99: 53 push %ebx 10de9a: 83 ec 1c sub $0x1c,%esp 10de9d: 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; 10dea0: 8b 58 18 mov 0x18(%eax),%ebx loc = temp_mt_entry->mt_fs_root; 10dea3: 8d 7d e4 lea -0x1c(%ebp),%edi 10dea6: 8d 70 18 lea 0x18(%eax),%esi 10dea9: b9 04 00 00 00 mov $0x4,%ecx 10deae: 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; 10deb0: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) do { next = jnode->Parent; loc.node_access = (void *)jnode; IMFS_Set_handlers( &loc ); 10deb7: 8d 75 e4 lea -0x1c(%ebp),%esi */ temp_mt_entry->mt_fs_root.node_access = NULL; do { next = jnode->Parent; 10deba: 8b 7b 08 mov 0x8(%ebx),%edi loc.node_access = (void *)jnode; 10debd: 89 5d e4 mov %ebx,-0x1c(%ebp) IMFS_Set_handlers( &loc ); 10dec0: 83 ec 0c sub $0xc,%esp 10dec3: 56 push %esi 10dec4: e8 e7 f9 ff ff call 10d8b0 if ( jnode->type != IMFS_DIRECTORY ) { 10dec9: 83 c4 10 add $0x10,%esp 10decc: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10ded0: 75 08 jne 10deda result = IMFS_unlink( &loc ); if (result != 0) return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { 10ded2: 8d 43 54 lea 0x54(%ebx),%eax 10ded5: 39 43 50 cmp %eax,0x50(%ebx) 10ded8: 75 12 jne 10deec result = IMFS_unlink( &loc ); 10deda: 83 ec 0c sub $0xc,%esp 10dedd: 56 push %esi 10dede: e8 c1 8c ff ff call 106ba4 if (result != 0) 10dee3: 83 c4 10 add $0x10,%esp 10dee6: 85 c0 test %eax,%eax 10dee8: 75 1d jne 10df07 <== NEVER TAKEN 10deea: 89 fb mov %edi,%ebx return -1; jnode = next; } if ( jnode != NULL ) { 10deec: 85 db test %ebx,%ebx 10deee: 74 1c je 10df0c if ( jnode->type == IMFS_DIRECTORY ) { 10def0: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10def4: 75 c4 jne 10deba <== NEVER TAKEN if ( jnode_has_children( jnode ) ) 10def6: 8d 43 54 lea 0x54(%ebx),%eax 10def9: 39 43 50 cmp %eax,0x50(%ebx) 10defc: 74 bc je 10deba jnode = jnode_get_first_child( jnode ); 10defe: 8b 5b 50 mov 0x50(%ebx),%ebx } } } while (jnode != NULL); 10df01: 85 db test %ebx,%ebx 10df03: 75 b5 jne 10deba <== ALWAYS TAKEN 10df05: eb 05 jmp 10df0c <== NOT EXECUTED 10df07: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10df0a: eb 02 jmp 10df0e <== NOT EXECUTED 10df0c: 31 c0 xor %eax,%eax return 0; } 10df0e: 8d 65 f4 lea -0xc(%ebp),%esp 10df11: 5b pop %ebx 10df12: 5e pop %esi 10df13: 5f pop %edi 10df14: c9 leave 10df15: c3 ret =============================================================================== 0010c8a0 : IMFS_token_types IMFS_get_token( const char *path, char *token, int *token_len ) { 10c8a0: 55 push %ebp 10c8a1: 89 e5 mov %esp,%ebp 10c8a3: 56 push %esi 10c8a4: 53 push %ebx 10c8a5: 8b 4d 08 mov 0x8(%ebp),%ecx 10c8a8: 8b 75 0c mov 0xc(%ebp),%esi register char c; /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; 10c8ab: 8a 01 mov (%ecx),%al 10c8ad: 31 d2 xor %edx,%edx 10c8af: eb 10 jmp 10c8c1 while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) { token[i] = c; 10c8b1: 88 04 16 mov %al,(%esi,%edx,1) if ( i == IMFS_NAME_MAX ) 10c8b4: 75 07 jne 10c8bd 10c8b6: bb 04 00 00 00 mov $0x4,%ebx 10c8bb: eb 77 jmp 10c934 return IMFS_INVALID_TOKEN; if ( !IMFS_is_valid_name_char(c) ) type = IMFS_INVALID_TOKEN; c = path [++i]; 10c8bd: 42 inc %edx 10c8be: 8a 04 11 mov (%ecx,%edx,1),%al /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) { 10c8c1: 3c 2f cmp $0x2f,%al 10c8c3: 74 0d je 10c8d2 10c8c5: 3c 5c cmp $0x5c,%al 10c8c7: 74 09 je 10c8d2 10c8c9: 84 c0 test %al,%al 10c8cb: 74 05 je 10c8d2 10c8cd: 83 fa 20 cmp $0x20,%edx 10c8d0: 7e df jle 10c8b1 <== ALWAYS TAKEN /* * Copy a seperator into token. */ if ( i == 0 ) { 10c8d2: 85 d2 test %edx,%edx 10c8d4: 75 0e jne 10c8e4 token[i] = c; 10c8d6: 88 06 mov %al,(%esi) if ( token[i] != '\0' ) { 10c8d8: 31 db xor %ebx,%ebx 10c8da: 84 c0 test %al,%al 10c8dc: 74 1b je 10c8f9 10c8de: b2 01 mov $0x1,%dl 10c8e0: b3 01 mov $0x1,%bl 10c8e2: eb 15 jmp 10c8f9 i++; type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; } } else if (token[ i-1 ] != '\0') { 10c8e4: bb 03 00 00 00 mov $0x3,%ebx 10c8e9: 80 7c 16 ff 00 cmpb $0x0,-0x1(%esi,%edx,1) 10c8ee: 74 09 je 10c8f9 <== NEVER TAKEN token[i] = '\0'; 10c8f0: c6 04 16 00 movb $0x0,(%esi,%edx,1) 10c8f4: bb 03 00 00 00 mov $0x3,%ebx /* * Set token_len to the number of characters copied. */ *token_len = i; 10c8f9: 8b 45 10 mov 0x10(%ebp),%eax 10c8fc: 89 10 mov %edx,(%eax) /* * If we copied something that was not a seperator see if * it was a special name. */ if ( type == IMFS_NAME ) { 10c8fe: 83 fb 03 cmp $0x3,%ebx 10c901: 75 31 jne 10c934 if ( strcmp( token, "..") == 0 ) 10c903: 52 push %edx 10c904: 52 push %edx 10c905: 68 f9 71 11 00 push $0x1171f9 10c90a: 56 push %esi 10c90b: e8 14 39 00 00 call 110224 10c910: 83 c4 10 add $0x10,%esp 10c913: 85 c0 test %eax,%eax 10c915: 75 04 jne 10c91b 10c917: b3 02 mov $0x2,%bl 10c919: eb 19 jmp 10c934 type = IMFS_UP_DIR; else if ( strcmp( token, "." ) == 0 ) 10c91b: 50 push %eax 10c91c: 50 push %eax 10c91d: 68 fa 71 11 00 push $0x1171fa 10c922: 56 push %esi 10c923: e8 fc 38 00 00 call 110224 10c928: 83 c4 10 add $0x10,%esp 10c92b: 85 c0 test %eax,%eax 10c92d: 75 05 jne 10c934 10c92f: bb 01 00 00 00 mov $0x1,%ebx type = IMFS_CURRENT_DIR; } return type; } 10c934: 89 d8 mov %ebx,%eax 10c936: 8d 65 f8 lea -0x8(%ebp),%esp 10c939: 5b pop %ebx 10c93a: 5e pop %esi 10c93b: c9 leave 10c93c: c3 ret =============================================================================== 0010c940 : rtems_filesystem_mount_table_entry_t *temp_mt_entry, const rtems_filesystem_operations_table *op_table, const rtems_filesystem_file_handlers_r *memfile_handlers, const rtems_filesystem_file_handlers_r *directory_handlers ) { 10c940: 55 push %ebp 10c941: 89 e5 mov %esp,%ebp 10c943: 57 push %edi 10c944: 56 push %esi 10c945: 53 push %ebx 10c946: 83 ec 0c sub $0xc,%esp 10c949: 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, 10c94c: 8b 0d dc 92 11 00 mov 0x1192dc,%ecx 10c952: b8 10 00 00 00 mov $0x10,%eax 10c957: 31 d2 xor %edx,%edx int bit_mask; /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); 10c959: 39 c8 cmp %ecx,%eax 10c95b: 74 0d je 10c96a bit_mask <<= 1) { 10c95d: d1 e0 shl %eax 10c95f: 42 inc %edx int bit_mask; /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); 10c960: 83 fa 06 cmp $0x6,%edx 10c963: 75 f4 jne 10c959 <== ALWAYS TAKEN 10c965: b8 80 00 00 00 mov $0x80,%eax <== NOT EXECUTED bit_mask <<= 1) { if (bit_mask == requested_bytes_per_block) { is_valid = true; } } *dest_bytes_per_block = ((is_valid) 10c96a: a3 54 d5 11 00 mov %eax,0x11d554 * 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_node( 10c96f: 83 ec 0c sub $0xc,%esp 10c972: 6a 00 push $0x0 10c974: 68 ed 41 00 00 push $0x41ed 10c979: 68 55 72 11 00 push $0x117255 10c97e: 6a 01 push $0x1 10c980: 6a 00 push $0x0 10c982: e8 e9 1d 00 00 call 10e770 10c987: 89 43 18 mov %eax,0x18(%ebx) "", ( S_IFDIR | 0755 ), NULL ); temp_mt_entry->mt_fs_root.handlers = directory_handlers; 10c98a: 8b 45 14 mov 0x14(%ebp),%eax 10c98d: 89 43 1c mov %eax,0x1c(%ebx) temp_mt_entry->mt_fs_root.ops = op_table; 10c990: 8b 45 0c mov 0xc(%ebp),%eax 10c993: 89 43 20 mov %eax,0x20(%ebx) temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS; 10c996: 8d 7b 30 lea 0x30(%ebx),%edi 10c999: be 60 7a 11 00 mov $0x117a60,%esi 10c99e: b9 0c 00 00 00 mov $0xc,%ecx 10c9a3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Create custom file system data. */ fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) ); 10c9a5: 83 c4 18 add $0x18,%esp 10c9a8: 6a 0c push $0xc 10c9aa: 6a 01 push $0x1 10c9ac: e8 1f 03 00 00 call 10ccd0 10c9b1: 89 c2 mov %eax,%edx if ( !fs_info ){ 10c9b3: 83 c4 10 add $0x10,%esp 10c9b6: 85 c0 test %eax,%eax 10c9b8: 75 1e jne 10c9d8 <== ALWAYS TAKEN free(temp_mt_entry->mt_fs_root.node_access); 10c9ba: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c9bd: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10c9c0: e8 b3 9a ff ff call 106478 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(ENOMEM); 10c9c5: e8 5e 27 00 00 call 10f128 <__errno> <== NOT EXECUTED 10c9ca: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10c9d0: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10c9d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c9d6: eb 21 jmp 10c9f9 <== NOT EXECUTED } temp_mt_entry->fs_info = fs_info; 10c9d8: 89 43 2c mov %eax,0x2c(%ebx) /* * Set st_ino for the root to 1. */ fs_info->ino_count = 1; 10c9db: c7 00 01 00 00 00 movl $0x1,(%eax) fs_info->memfile_handlers = memfile_handlers; 10c9e1: 8b 45 10 mov 0x10(%ebp),%eax 10c9e4: 89 42 04 mov %eax,0x4(%edx) fs_info->directory_handlers = directory_handlers; 10c9e7: 8b 45 14 mov 0x14(%ebp),%eax 10c9ea: 89 42 08 mov %eax,0x8(%edx) jnode = temp_mt_entry->mt_fs_root.node_access; jnode->st_ino = fs_info->ino_count; 10c9ed: 8b 43 18 mov 0x18(%ebx),%eax 10c9f0: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax) 10c9f7: 31 c0 xor %eax,%eax return 0; } 10c9f9: 8d 65 f4 lea -0xc(%ebp),%esp 10c9fc: 5b pop %ebx 10c9fd: 5e pop %esi 10c9fe: 5f pop %edi 10c9ff: c9 leave 10ca00: c3 ret =============================================================================== 0010697c : int IMFS_link( rtems_filesystem_location_info_t *to_loc, /* IN */ rtems_filesystem_location_info_t *parent_loc, /* IN */ const char *token /* IN */ ) { 10697c: 55 push %ebp 10697d: 89 e5 mov %esp,%ebp 10697f: 53 push %ebx 106980: 83 ec 44 sub $0x44,%esp /* * Verify this node can be linked to. */ info.hard_link.link_node = to_loc->node_access; 106983: 8b 45 08 mov 0x8(%ebp),%eax 106986: 8b 00 mov (%eax),%eax 106988: 89 45 e0 mov %eax,-0x20(%ebp) if ( info.hard_link.link_node->st_nlink >= LINK_MAX ) 10698b: 66 83 78 34 07 cmpw $0x7,0x34(%eax) 106990: 76 0d jbe 10699f rtems_set_errno_and_return_minus_one( EMLINK ); 106992: e8 49 a6 00 00 call 110fe0 <__errno> 106997: c7 00 1f 00 00 00 movl $0x1f,(%eax) 10699d: eb 39 jmp 1069d8 /* * Remove any separators at the end of the string. */ IMFS_get_token( token, new_name, &i ); 10699f: 52 push %edx 1069a0: 8d 45 f8 lea -0x8(%ebp),%eax 1069a3: 50 push %eax 1069a4: 8d 5d bf lea -0x41(%ebp),%ebx 1069a7: 53 push %ebx 1069a8: ff 75 10 pushl 0x10(%ebp) 1069ab: e8 f4 75 00 00 call 10dfa4 /* * Create a new link node. */ new_node = IMFS_create_node( 1069b0: 8d 45 e0 lea -0x20(%ebp),%eax 1069b3: 89 04 24 mov %eax,(%esp) 1069b6: 68 ff a1 00 00 push $0xa1ff 1069bb: 53 push %ebx 1069bc: 6a 03 push $0x3 1069be: ff 75 0c pushl 0xc(%ebp) 1069c1: e8 ae 6d 00 00 call 10d774 new_name, ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if ( !new_node ) 1069c6: 83 c4 20 add $0x20,%esp 1069c9: 85 c0 test %eax,%eax 1069cb: 75 10 jne 1069dd <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOMEM ); 1069cd: e8 0e a6 00 00 call 110fe0 <__errno> <== NOT EXECUTED 1069d2: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 1069d8: 83 c8 ff or $0xffffffff,%eax 1069db: eb 22 jmp 1069ff /* * Increment the link count of the node being pointed to. */ info.hard_link.link_node->st_nlink++; 1069dd: 8b 45 e0 mov -0x20(%ebp),%eax 1069e0: 66 ff 40 34 incw 0x34(%eax) IMFS_update_ctime( info.hard_link.link_node ); 1069e4: 50 push %eax 1069e5: 50 push %eax 1069e6: 6a 00 push $0x0 1069e8: 8d 45 f0 lea -0x10(%ebp),%eax 1069eb: 50 push %eax 1069ec: e8 77 0a 00 00 call 107468 1069f1: 8b 55 f0 mov -0x10(%ebp),%edx 1069f4: 8b 45 e0 mov -0x20(%ebp),%eax 1069f7: 89 50 48 mov %edx,0x48(%eax) 1069fa: 31 c0 xor %eax,%eax 1069fc: 83 c4 10 add $0x10,%esp return 0; } 1069ff: 8b 5d fc mov -0x4(%ebp),%ebx 106a02: c9 leave 106a03: c3 ret =============================================================================== 0010fd2f : MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) { 10fd2f: 55 push %ebp 10fd30: 89 e5 mov %esp,%ebp 10fd32: 53 push %ebx 10fd33: 83 ec 04 sub $0x4,%esp 10fd36: 8b 45 08 mov 0x8(%ebp),%eax block_p memory; block_p *block_entry_ptr; assert( the_jnode ); 10fd39: 85 c0 test %eax,%eax 10fd3b: 75 11 jne 10fd4e <== ALWAYS TAKEN 10fd3d: 68 bc b5 11 00 push $0x11b5bc <== NOT EXECUTED 10fd42: 68 48 b7 11 00 push $0x11b748 <== NOT EXECUTED 10fd47: 68 69 01 00 00 push $0x169 <== NOT EXECUTED 10fd4c: eb 15 jmp 10fd63 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 10fd4e: 83 78 4c 05 cmpl $0x5,0x4c(%eax) 10fd52: 74 19 je 10fd6d <== ALWAYS TAKEN 10fd54: 68 12 b6 11 00 push $0x11b612 <== NOT EXECUTED 10fd59: 68 48 b7 11 00 push $0x11b748 <== NOT EXECUTED 10fd5e: 68 6d 01 00 00 push $0x16d <== NOT EXECUTED 10fd63: 68 c6 b5 11 00 push $0x11b5c6 <== NOT EXECUTED 10fd68: e8 37 70 ff ff call 106da4 <__assert_func> <== NOT EXECUTED if ( the_jnode->type != IMFS_MEMORY_FILE ) rtems_set_errno_and_return_minus_one( EIO ); block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 ); 10fd6d: 52 push %edx 10fd6e: 6a 01 push $0x1 10fd70: ff 75 0c pushl 0xc(%ebp) 10fd73: 50 push %eax 10fd74: e8 95 fb ff ff call 10f90e 10fd79: 89 c3 mov %eax,%ebx if ( *block_entry_ptr ) 10fd7b: 83 c4 10 add $0x10,%esp 10fd7e: 31 c0 xor %eax,%eax 10fd80: 83 3b 00 cmpl $0x0,(%ebx) 10fd83: 75 14 jne 10fd99 #if 0 fprintf(stdout, "%d %p", block, block_entry_ptr ); fflush(stdout); #endif memory = memfile_alloc_block(); 10fd85: e8 62 fb ff ff call 10f8ec 10fd8a: 89 c2 mov %eax,%edx if ( !memory ) 10fd8c: b8 01 00 00 00 mov $0x1,%eax 10fd91: 85 d2 test %edx,%edx 10fd93: 74 04 je 10fd99 <== NEVER TAKEN return 1; *block_entry_ptr = memory; 10fd95: 89 13 mov %edx,(%ebx) 10fd97: 31 c0 xor %eax,%eax return 0; } 10fd99: 8b 5d fc mov -0x4(%ebp),%ebx 10fd9c: c9 leave 10fd9d: c3 ret =============================================================================== 0010fd9e : MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) { 10fd9e: 55 push %ebp 10fd9f: 89 e5 mov %esp,%ebp 10fda1: 57 push %edi 10fda2: 56 push %esi 10fda3: 53 push %ebx 10fda4: 83 ec 0c sub $0xc,%esp 10fda7: 8b 7d 08 mov 0x8(%ebp),%edi 10fdaa: 8b 75 0c mov 0xc(%ebp),%esi /* * Perform internal consistency checks */ assert( the_jnode ); 10fdad: 85 ff test %edi,%edi 10fdaf: 75 11 jne 10fdc2 <== ALWAYS TAKEN 10fdb1: 68 bc b5 11 00 push $0x11b5bc <== NOT EXECUTED 10fdb6: 68 60 b7 11 00 push $0x11b760 <== NOT EXECUTED 10fdbb: 68 31 01 00 00 push $0x131 <== NOT EXECUTED 10fdc0: eb 15 jmp 10fdd7 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 10fdc2: 83 7f 4c 05 cmpl $0x5,0x4c(%edi) 10fdc6: 74 19 je 10fde1 <== ALWAYS TAKEN 10fdc8: 68 12 b6 11 00 push $0x11b612 <== NOT EXECUTED 10fdcd: 68 60 b7 11 00 push $0x11b760 <== NOT EXECUTED 10fdd2: 68 35 01 00 00 push $0x135 <== NOT EXECUTED 10fdd7: 68 c6 b5 11 00 push $0x11b5c6 <== NOT EXECUTED 10fddc: e8 c3 6f ff ff call 106da4 <__assert_func> <== NOT EXECUTED if ( the_jnode->type != IMFS_MEMORY_FILE ) rtems_set_errno_and_return_minus_one( EIO ); if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE ) 10fde1: 8b 0d ac 11 12 00 mov 0x1211ac,%ecx 10fde7: 89 ca mov %ecx,%edx 10fde9: c1 ea 02 shr $0x2,%edx 10fdec: 8d 42 01 lea 0x1(%edx),%eax 10fdef: 0f af c2 imul %edx,%eax 10fdf2: 40 inc %eax 10fdf3: 0f af c2 imul %edx,%eax 10fdf6: 48 dec %eax 10fdf7: 0f af c1 imul %ecx,%eax 10fdfa: 39 c6 cmp %eax,%esi 10fdfc: 72 0d jb 10fe0b <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10fdfe: e8 dd 11 00 00 call 110fe0 <__errno> <== NOT EXECUTED 10fe03: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10fe09: eb 4c jmp 10fe57 <== NOT EXECUTED if ( new_length <= the_jnode->info.file.size ) 10fe0b: 8b 5f 50 mov 0x50(%edi),%ebx 10fe0e: 31 d2 xor %edx,%edx 10fe10: 39 de cmp %ebx,%esi 10fe12: 7e 53 jle 10fe67 /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; 10fe14: 89 f0 mov %esi,%eax 10fe16: 99 cltd 10fe17: f7 f9 idiv %ecx 10fe19: 89 45 f0 mov %eax,-0x10(%ebp) old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; 10fe1c: 89 d8 mov %ebx,%eax 10fe1e: 99 cltd 10fe1f: f7 f9 idiv %ecx 10fe21: 89 45 ec mov %eax,-0x14(%ebp) 10fe24: 89 c3 mov %eax,%ebx 10fe26: eb 35 jmp 10fe5d /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { if ( IMFS_memfile_addblock( the_jnode, block ) ) { 10fe28: 50 push %eax 10fe29: 50 push %eax 10fe2a: 53 push %ebx 10fe2b: 57 push %edi 10fe2c: e8 fe fe ff ff call 10fd2f 10fe31: 83 c4 10 add $0x10,%esp 10fe34: 85 c0 test %eax,%eax 10fe36: 74 24 je 10fe5c <== ALWAYS TAKEN 10fe38: eb 0d jmp 10fe47 <== NOT EXECUTED for ( ; block>=old_blocks ; block-- ) { IMFS_memfile_remove_block( the_jnode, block ); 10fe3a: 51 push %ecx <== NOT EXECUTED 10fe3b: 51 push %ecx <== NOT EXECUTED 10fe3c: 53 push %ebx <== NOT EXECUTED 10fe3d: 57 push %edi <== NOT EXECUTED 10fe3e: e8 4f fc ff ff call 10fa92 <== NOT EXECUTED * 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-- ) { 10fe43: 4b dec %ebx <== NOT EXECUTED 10fe44: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fe47: 3b 5d ec cmp -0x14(%ebp),%ebx <== NOT EXECUTED 10fe4a: 73 ee jae 10fe3a <== NOT EXECUTED IMFS_memfile_remove_block( the_jnode, block ); } rtems_set_errno_and_return_minus_one( ENOSPC ); 10fe4c: e8 8f 11 00 00 call 110fe0 <__errno> <== NOT EXECUTED 10fe51: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 10fe57: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 10fe5a: eb 0b jmp 10fe67 <== NOT EXECUTED /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 10fe5c: 43 inc %ebx 10fe5d: 3b 5d f0 cmp -0x10(%ebp),%ebx 10fe60: 76 c6 jbe 10fe28 /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; 10fe62: 89 77 50 mov %esi,0x50(%edi) 10fe65: 31 d2 xor %edx,%edx return 0; } 10fe67: 89 d0 mov %edx,%eax 10fe69: 8d 65 f4 lea -0xc(%ebp),%esp 10fe6c: 5b pop %ebx 10fe6d: 5e pop %esi 10fe6e: 5f pop %edi 10fe6f: c9 leave 10fe70: c3 ret =============================================================================== 0010f90e : #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) { 10f90e: 55 push %ebp 10f90f: 89 e5 mov %esp,%ebp 10f911: 57 push %edi 10f912: 56 push %esi 10f913: 53 push %ebx 10f914: 83 ec 1c sub $0x1c,%esp 10f917: 8b 75 08 mov 0x8(%ebp),%esi 10f91a: 8b 5d 0c mov 0xc(%ebp),%ebx 10f91d: 8b 7d 10 mov 0x10(%ebp),%edi /* * Perform internal consistency checks */ assert( the_jnode ); 10f920: 85 f6 test %esi,%esi 10f922: 75 11 jne 10f935 <== ALWAYS TAKEN 10f924: 68 bc b5 11 00 push $0x11b5bc <== NOT EXECUTED 10f929: 68 cc b6 11 00 push $0x11b6cc <== NOT EXECUTED 10f92e: 68 86 03 00 00 push $0x386 <== NOT EXECUTED 10f933: eb 15 jmp 10f94a <== NOT EXECUTED if ( !the_jnode ) return NULL; assert( the_jnode->type == IMFS_MEMORY_FILE ); 10f935: 83 7e 4c 05 cmpl $0x5,0x4c(%esi) 10f939: 74 19 je 10f954 <== ALWAYS TAKEN 10f93b: 68 12 b6 11 00 push $0x11b612 <== NOT EXECUTED 10f940: 68 cc b6 11 00 push $0x11b6cc <== NOT EXECUTED 10f945: 68 8a 03 00 00 push $0x38a <== NOT EXECUTED 10f94a: 68 c6 b5 11 00 push $0x11b5c6 <== NOT EXECUTED 10f94f: e8 50 74 ff ff call 106da4 <__assert_func> <== NOT EXECUTED /* * Is the block number in the simple indirect portion? */ if ( my_block <= LAST_INDIRECT ) { 10f954: a1 ac 11 12 00 mov 0x1211ac,%eax 10f959: c1 e8 02 shr $0x2,%eax 10f95c: 89 45 e4 mov %eax,-0x1c(%ebp) 10f95f: 48 dec %eax 10f960: 39 c3 cmp %eax,%ebx 10f962: 77 32 ja 10f996 <== NEVER TAKEN #if 0 fprintf(stdout, "(s %d) ", block ); fflush(stdout); #endif p = info->indirect; 10f964: 8b 46 54 mov 0x54(%esi),%eax if ( malloc_it ) { 10f967: 85 ff test %edi,%edi 10f969: 74 23 je 10f98e if ( !p ) { 10f96b: 85 c0 test %eax,%eax 10f96d: 75 10 jne 10f97f p = memfile_alloc_block(); 10f96f: e8 78 ff ff ff call 10f8ec if ( !p ) 10f974: 85 c0 test %eax,%eax 10f976: 0f 84 0a 01 00 00 je 10fa86 <== NEVER TAKEN return 0; info->indirect = p; 10f97c: 89 46 54 mov %eax,0x54(%esi) } return &info->indirect[ my_block ]; 10f97f: 8d 14 9d 00 00 00 00 lea 0x0(,%ebx,4),%edx 10f986: 03 56 54 add 0x54(%esi),%edx 10f989: e9 fa 00 00 00 jmp 10fa88 } if ( !p ) return 0; return &info->indirect[ my_block ]; 10f98e: 8d 14 98 lea (%eax,%ebx,4),%edx 10f991: e9 ec 00 00 00 jmp 10fa82 /* * Is the block number in the doubly indirect portion? */ if ( my_block <= LAST_DOUBLY_INDIRECT ) { 10f996: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 10f999: 41 inc %ecx <== NOT EXECUTED 10f99a: 0f af 4d e4 imul -0x1c(%ebp),%ecx <== NOT EXECUTED 10f99e: 8d 41 ff lea -0x1(%ecx),%eax <== NOT EXECUTED 10f9a1: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10f9a3: 77 5a ja 10f9ff <== NOT EXECUTED #if 0 fprintf(stdout, "(d %d) ", block ); fflush(stdout); #endif my_block -= FIRST_DOUBLY_INDIRECT; 10f9a5: 2b 5d e4 sub -0x1c(%ebp),%ebx <== NOT EXECUTED singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 10f9a8: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10f9aa: 31 d2 xor %edx,%edx <== NOT EXECUTED 10f9ac: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED 10f9af: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 10f9b2: 89 c3 mov %eax,%ebx <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; p = info->doubly_indirect; 10f9b4: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED if ( malloc_it ) { 10f9b7: 85 ff test %edi,%edi <== NOT EXECUTED 10f9b9: 74 31 je 10f9ec <== NOT EXECUTED if ( !p ) { 10f9bb: 85 c0 test %eax,%eax <== NOT EXECUTED 10f9bd: 75 10 jne 10f9cf <== NOT EXECUTED p = memfile_alloc_block(); 10f9bf: e8 28 ff ff ff call 10f8ec <== NOT EXECUTED if ( !p ) 10f9c4: 85 c0 test %eax,%eax <== NOT EXECUTED 10f9c6: 0f 84 ba 00 00 00 je 10fa86 <== NOT EXECUTED return 0; info->doubly_indirect = p; 10f9cc: 89 46 58 mov %eax,0x58(%esi) <== NOT EXECUTED } p1 = (block_p *)p[ doubly ]; 10f9cf: 8d 1c 98 lea (%eax,%ebx,4),%ebx <== NOT EXECUTED 10f9d2: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p1 ) { 10f9d4: 85 c0 test %eax,%eax <== NOT EXECUTED 10f9d6: 75 0f jne 10f9e7 <== NOT EXECUTED p1 = memfile_alloc_block(); 10f9d8: e8 0f ff ff ff call 10f8ec <== NOT EXECUTED if ( !p1 ) 10f9dd: 85 c0 test %eax,%eax <== NOT EXECUTED 10f9df: 0f 84 a1 00 00 00 je 10fa86 <== NOT EXECUTED return 0; p[ doubly ] = (block_p) p1; 10f9e5: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } return (block_p *)&p1[ singly ]; 10f9e7: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10f9ea: eb 7a jmp 10fa66 <== NOT EXECUTED } if ( !p ) 10f9ec: 85 c0 test %eax,%eax <== NOT EXECUTED 10f9ee: 0f 84 92 00 00 00 je 10fa86 <== NOT EXECUTED return 0; p = (block_p *)p[ doubly ]; 10f9f4: 8b 04 98 mov (%eax,%ebx,4),%eax <== NOT EXECUTED #if 0 fprintf(stdout, "(d %d %d %d %d %p %p) ", block, my_block, doubly, singly, p, &p[singly] ); fflush(stdout); #endif return (block_p *)&p[ singly ]; 10f9f7: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10f9fa: e9 80 00 00 00 jmp 10fa7f <== NOT EXECUTED #endif /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 10f9ff: 8d 41 01 lea 0x1(%ecx),%eax <== NOT EXECUTED 10fa02: 0f af 45 e4 imul -0x1c(%ebp),%eax <== NOT EXECUTED 10fa06: 48 dec %eax <== NOT EXECUTED 10fa07: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10fa09: 77 7b ja 10fa86 <== NOT EXECUTED my_block -= FIRST_TRIPLY_INDIRECT; 10fa0b: 29 cb sub %ecx,%ebx <== NOT EXECUTED singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 10fa0d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10fa0f: 31 d2 xor %edx,%edx <== NOT EXECUTED 10fa11: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED 10fa14: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; 10fa17: 31 d2 xor %edx,%edx <== NOT EXECUTED 10fa19: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED 10fa1c: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 10fa1f: 89 c3 mov %eax,%ebx <== NOT EXECUTED doubly %= IMFS_MEMFILE_BLOCK_SLOTS; p = info->triply_indirect; 10fa21: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED if ( malloc_it ) { 10fa24: 85 ff test %edi,%edi <== NOT EXECUTED 10fa26: 74 43 je 10fa6b <== NOT EXECUTED if ( !p ) { 10fa28: 85 c0 test %eax,%eax <== NOT EXECUTED 10fa2a: 75 0c jne 10fa38 <== NOT EXECUTED p = memfile_alloc_block(); 10fa2c: e8 bb fe ff ff call 10f8ec <== NOT EXECUTED if ( !p ) 10fa31: 85 c0 test %eax,%eax <== NOT EXECUTED 10fa33: 74 51 je 10fa86 <== NOT EXECUTED return 0; info->triply_indirect = p; 10fa35: 89 46 5c mov %eax,0x5c(%esi) <== NOT EXECUTED } p1 = (block_p *) p[ triply ]; 10fa38: 8d 1c 98 lea (%eax,%ebx,4),%ebx <== NOT EXECUTED 10fa3b: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p1 ) { 10fa3d: 85 c0 test %eax,%eax <== NOT EXECUTED 10fa3f: 75 0b jne 10fa4c <== NOT EXECUTED p1 = memfile_alloc_block(); 10fa41: e8 a6 fe ff ff call 10f8ec <== NOT EXECUTED if ( !p1 ) 10fa46: 85 c0 test %eax,%eax <== NOT EXECUTED 10fa48: 74 3c je 10fa86 <== NOT EXECUTED return 0; p[ triply ] = (block_p) p1; 10fa4a: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } p2 = (block_p *)p1[ doubly ]; 10fa4c: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 10fa4f: 8d 1c 88 lea (%eax,%ecx,4),%ebx <== NOT EXECUTED 10fa52: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p2 ) { 10fa54: 85 c0 test %eax,%eax <== NOT EXECUTED 10fa56: 75 0b jne 10fa63 <== NOT EXECUTED p2 = memfile_alloc_block(); 10fa58: e8 8f fe ff ff call 10f8ec <== NOT EXECUTED if ( !p2 ) 10fa5d: 85 c0 test %eax,%eax <== NOT EXECUTED 10fa5f: 74 25 je 10fa86 <== NOT EXECUTED return 0; p1[ doubly ] = (block_p) p2; 10fa61: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } return (block_p *)&p2[ singly ]; 10fa63: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 10fa66: 8d 14 88 lea (%eax,%ecx,4),%edx <== NOT EXECUTED 10fa69: eb 1d jmp 10fa88 <== NOT EXECUTED } if ( !p ) 10fa6b: 85 c0 test %eax,%eax <== NOT EXECUTED 10fa6d: 74 17 je 10fa86 <== NOT EXECUTED #if 0 fprintf(stdout, "(t %d %d %d %d %d) ", block, my_block, triply, doubly, singly ); fflush(stdout); #endif p1 = (block_p *) p[ triply ]; 10fa6f: 8b 04 98 mov (%eax,%ebx,4),%eax <== NOT EXECUTED if ( !p1 ) 10fa72: 85 c0 test %eax,%eax <== NOT EXECUTED 10fa74: 74 10 je 10fa86 <== NOT EXECUTED return 0; p2 = (block_p *)p1[ doubly ]; 10fa76: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10fa79: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED if ( !p2 ) return 0; return (block_p *)&p2[ singly ]; 10fa7c: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 10fa7f: 8d 14 88 lea (%eax,%ecx,4),%edx <== NOT EXECUTED p1 = (block_p *) p[ triply ]; if ( !p1 ) return 0; p2 = (block_p *)p1[ doubly ]; if ( !p2 ) 10fa82: 85 c0 test %eax,%eax 10fa84: 75 02 jne 10fa88 <== ALWAYS TAKEN return 0; return (block_p *)&p2[ singly ]; 10fa86: 31 d2 xor %edx,%edx <== NOT EXECUTED /* * This means the requested block number is out of range. */ return 0; } 10fa88: 89 d0 mov %edx,%eax 10fa8a: 8d 65 f4 lea -0xc(%ebp),%esp 10fa8d: 5b pop %ebx 10fa8e: 5e pop %esi 10fa8f: 5f pop %edi 10fa90: c9 leave 10fa91: c3 ret =============================================================================== 00110172 : IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) { 110172: 55 push %ebp 110173: 89 e5 mov %esp,%ebp 110175: 57 push %edi 110176: 56 push %esi 110177: 53 push %ebx 110178: 83 ec 3c sub $0x3c,%esp 11017b: 8b 5d 14 mov 0x14(%ebp),%ebx /* * Perform internal consistency checks */ assert( the_jnode ); 11017e: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 110182: 75 11 jne 110195 <== ALWAYS TAKEN 110184: 68 bc b5 11 00 push $0x11b5bc <== NOT EXECUTED 110189: 68 00 b7 11 00 push $0x11b700 <== NOT EXECUTED 11018e: 68 4a 02 00 00 push $0x24a <== NOT EXECUTED 110193: eb 1d jmp 1101b2 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE || 110195: 8b 45 08 mov 0x8(%ebp),%eax 110198: 8b 48 4c mov 0x4c(%eax),%ecx 11019b: 8d 41 fb lea -0x5(%ecx),%eax 11019e: 83 f8 01 cmp $0x1,%eax 1101a1: 76 19 jbe 1101bc <== ALWAYS TAKEN 1101a3: 68 7c b6 11 00 push $0x11b67c <== NOT EXECUTED 1101a8: 68 00 b7 11 00 push $0x11b700 <== NOT EXECUTED 1101ad: 68 4f 02 00 00 push $0x24f <== NOT EXECUTED 1101b2: 68 c6 b5 11 00 push $0x11b5c6 <== NOT EXECUTED 1101b7: e8 e8 6b ff ff call 106da4 <__assert_func> <== NOT EXECUTED /* * Error checks on arguments */ assert( dest ); 1101bc: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 1101c0: 75 11 jne 1101d3 <== ALWAYS TAKEN 1101c2: 68 c7 b6 11 00 push $0x11b6c7 <== NOT EXECUTED 1101c7: 68 00 b7 11 00 push $0x11b700 <== NOT EXECUTED 1101cc: 68 58 02 00 00 push $0x258 <== NOT EXECUTED 1101d1: eb df jmp 1101b2 <== NOT EXECUTED /* * If there is nothing to read, then quick exit. */ my_length = length; if ( !my_length ) 1101d3: 85 db test %ebx,%ebx 1101d5: 75 13 jne 1101ea <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 1101d7: e8 04 0e 00 00 call 110fe0 <__errno> <== NOT EXECUTED 1101dc: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1101e2: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 1101e5: e9 86 01 00 00 jmp 110370 <== NOT EXECUTED /* * Linear files (as created from a tar file are easier to handle * than block files). */ if (the_jnode->type == IMFS_LINEAR_FILE) { 1101ea: 83 f9 06 cmp $0x6,%ecx 1101ed: 75 47 jne 110236 <== ALWAYS TAKEN unsigned char *file_ptr; file_ptr = (unsigned char *)the_jnode->info.linearfile.direct; if (my_length > (the_jnode->info.linearfile.size - start)) 1101ef: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1101f2: 8b 52 50 mov 0x50(%edx),%edx <== NOT EXECUTED 1101f5: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1101f8: 29 ca sub %ecx,%edx <== NOT EXECUTED 1101fa: 89 55 c4 mov %edx,-0x3c(%ebp) <== NOT EXECUTED 1101fd: 39 da cmp %ebx,%edx <== NOT EXECUTED 1101ff: 76 03 jbe 110204 <== NOT EXECUTED 110201: 89 5d c4 mov %ebx,-0x3c(%ebp) <== NOT EXECUTED my_length = the_jnode->info.linearfile.size - start; memcpy(dest, &file_ptr[start], my_length); 110204: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 110207: 8b 76 54 mov 0x54(%esi),%esi <== NOT EXECUTED 11020a: 01 75 0c add %esi,0xc(%ebp) <== NOT EXECUTED 11020d: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 110210: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 110213: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED 110216: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED IMFS_update_atime( the_jnode ); 110218: 50 push %eax <== NOT EXECUTED 110219: 50 push %eax <== NOT EXECUTED 11021a: 6a 00 push $0x0 <== NOT EXECUTED 11021c: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 11021f: 50 push %eax <== NOT EXECUTED 110220: e8 43 72 ff ff call 107468 <== NOT EXECUTED 110225: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 110228: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 11022b: 89 47 40 mov %eax,0x40(%edi) <== NOT EXECUTED return my_length; 11022e: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED 110231: e9 37 01 00 00 jmp 11036d <== NOT EXECUTED * If the last byte we are supposed to read is past the end of this * in memory file, then shorten the length to read. */ last_byte = start + length; if ( last_byte > the_jnode->info.file.size ) 110236: 8b 45 08 mov 0x8(%ebp),%eax 110239: 8b 48 50 mov 0x50(%eax),%ecx 11023c: 8b 55 0c mov 0xc(%ebp),%edx 11023f: 8d 04 13 lea (%ebx,%edx,1),%eax 110242: 39 c8 cmp %ecx,%eax 110244: 76 05 jbe 11024b <== NEVER TAKEN my_length = the_jnode->info.file.size - start; 110246: 89 cb mov %ecx,%ebx 110248: 2b 5d 0c sub 0xc(%ebp),%ebx /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 11024b: 8b 3d ac 11 12 00 mov 0x1211ac,%edi 110251: 8b 45 0c mov 0xc(%ebp),%eax 110254: 99 cltd 110255: f7 ff idiv %edi 110257: 89 d6 mov %edx,%esi 110259: 89 45 cc mov %eax,-0x34(%ebp) block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 11025c: 89 45 d4 mov %eax,-0x2c(%ebp) if ( start_offset ) { 11025f: 85 d2 test %edx,%edx 110261: 75 0f jne 110272 110263: 8b 4d 10 mov 0x10(%ebp),%ecx 110266: 89 4d dc mov %ecx,-0x24(%ebp) 110269: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) 110270: eb 54 jmp 1102c6 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 ); 110272: 50 push %eax 110273: 6a 00 push $0x0 110275: ff 75 cc pushl -0x34(%ebp) 110278: ff 75 08 pushl 0x8(%ebp) 11027b: e8 8e f6 ff ff call 10f90e assert( block_ptr ); 110280: 83 c4 10 add $0x10,%esp 110283: 85 c0 test %eax,%eax 110285: 75 14 jne 11029b <== ALWAYS TAKEN 110287: 68 49 b6 11 00 push $0x11b649 <== NOT EXECUTED 11028c: 68 00 b7 11 00 push $0x11b700 <== NOT EXECUTED 110291: 68 94 02 00 00 push $0x294 <== NOT EXECUTED 110296: e9 17 ff ff ff jmp 1101b2 <== NOT EXECUTED */ 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; 11029b: 89 fa mov %edi,%edx 11029d: 29 f2 sub %esi,%edx 11029f: 89 5d c0 mov %ebx,-0x40(%ebp) 1102a2: 39 d3 cmp %edx,%ebx 1102a4: 76 03 jbe 1102a9 1102a6: 89 55 c0 mov %edx,-0x40(%ebp) to_copy = my_length; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); assert( block_ptr ); if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ start_offset ], to_copy ); 1102a9: 03 30 add (%eax),%esi dest += to_copy; 1102ab: 8b 7d 10 mov 0x10(%ebp),%edi 1102ae: 8b 4d c0 mov -0x40(%ebp),%ecx 1102b1: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 1102b3: 89 7d dc mov %edi,-0x24(%ebp) block++; 1102b6: 8b 45 cc mov -0x34(%ebp),%eax 1102b9: 40 inc %eax 1102ba: 89 45 d4 mov %eax,-0x2c(%ebp) my_length -= to_copy; 1102bd: 2b 5d c0 sub -0x40(%ebp),%ebx 1102c0: 8b 55 c0 mov -0x40(%ebp),%edx 1102c3: 89 55 d8 mov %edx,-0x28(%ebp) /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 1102c6: 8b 0d ac 11 12 00 mov 0x1211ac,%ecx 1102cc: 89 4d e0 mov %ecx,-0x20(%ebp) 1102cf: eb 42 jmp 110313 while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 1102d1: 57 push %edi 1102d2: 6a 00 push $0x0 1102d4: ff 75 d4 pushl -0x2c(%ebp) 1102d7: ff 75 08 pushl 0x8(%ebp) 1102da: e8 2f f6 ff ff call 10f90e assert( block_ptr ); 1102df: 83 c4 10 add $0x10,%esp 1102e2: 85 c0 test %eax,%eax 1102e4: 75 14 jne 1102fa <== ALWAYS TAKEN 1102e6: 68 49 b6 11 00 push $0x11b649 <== NOT EXECUTED 1102eb: 68 00 b7 11 00 push $0x11b700 <== NOT EXECUTED 1102f0: 68 a5 02 00 00 push $0x2a5 <== NOT EXECUTED 1102f5: e9 b8 fe ff ff jmp 1101b2 <== NOT EXECUTED if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); 1102fa: 8b 30 mov (%eax),%esi 1102fc: 8b 7d dc mov -0x24(%ebp),%edi 1102ff: 8b 4d e0 mov -0x20(%ebp),%ecx 110302: f3 a4 rep movsb %ds:(%esi),%es:(%edi) dest += to_copy; 110304: 89 7d dc mov %edi,-0x24(%ebp) block++; 110307: ff 45 d4 incl -0x2c(%ebp) my_length -= to_copy; 11030a: 2b 5d e0 sub -0x20(%ebp),%ebx copied += to_copy; 11030d: 8b 75 e0 mov -0x20(%ebp),%esi 110310: 01 75 d8 add %esi,-0x28(%ebp) /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 110313: 3b 1d ac 11 12 00 cmp 0x1211ac,%ebx 110319: 73 b6 jae 1102d1 * Phase 3: possibly the first part of one block */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { 11031b: 85 db test %ebx,%ebx 11031d: 74 35 je 110354 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 11031f: 56 push %esi 110320: 6a 00 push $0x0 110322: ff 75 d4 pushl -0x2c(%ebp) 110325: ff 75 08 pushl 0x8(%ebp) 110328: e8 e1 f5 ff ff call 10f90e assert( block_ptr ); 11032d: 83 c4 10 add $0x10,%esp 110330: 85 c0 test %eax,%eax 110332: 75 14 jne 110348 <== ALWAYS TAKEN 110334: 68 49 b6 11 00 push $0x11b649 <== NOT EXECUTED 110339: 68 00 b7 11 00 push $0x11b700 <== NOT EXECUTED 11033e: 68 b7 02 00 00 push $0x2b7 <== NOT EXECUTED 110343: e9 6a fe ff ff jmp 1101b2 <== NOT EXECUTED if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); 110348: 8b 30 mov (%eax),%esi 11034a: 8b 7d dc mov -0x24(%ebp),%edi 11034d: 89 d9 mov %ebx,%ecx 11034f: f3 a4 rep movsb %ds:(%esi),%es:(%edi) copied += my_length; 110351: 01 5d d8 add %ebx,-0x28(%ebp) } IMFS_update_atime( the_jnode ); 110354: 53 push %ebx 110355: 53 push %ebx 110356: 6a 00 push $0x0 110358: 8d 45 ec lea -0x14(%ebp),%eax 11035b: 50 push %eax 11035c: e8 07 71 ff ff call 107468 110361: 8b 45 ec mov -0x14(%ebp),%eax 110364: 8b 7d 08 mov 0x8(%ebp),%edi 110367: 89 47 40 mov %eax,0x40(%edi) return copied; 11036a: 8b 4d d8 mov -0x28(%ebp),%ecx 11036d: 83 c4 10 add $0x10,%esp } 110370: 89 c8 mov %ecx,%eax 110372: 8d 65 f4 lea -0xc(%ebp),%esp 110375: 5b pop %ebx 110376: 5e pop %esi 110377: 5f pop %edi 110378: c9 leave 110379: c3 ret =============================================================================== 0010fb26 : */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) { 10fb26: 55 push %ebp 10fb27: 89 e5 mov %esp,%ebp 10fb29: 57 push %edi 10fb2a: 56 push %esi 10fb2b: 53 push %ebx 10fb2c: 83 ec 0c sub $0xc,%esp /* * Perform internal consistency checks */ assert( the_jnode ); 10fb2f: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 10fb33: 75 11 jne 10fb46 <== ALWAYS TAKEN 10fb35: 68 bc b5 11 00 push $0x11b5bc <== NOT EXECUTED 10fb3a: 68 14 b7 11 00 push $0x11b714 <== NOT EXECUTED 10fb3f: 68 ec 01 00 00 push $0x1ec <== NOT EXECUTED 10fb44: eb 18 jmp 10fb5e <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 10fb46: 8b 45 08 mov 0x8(%ebp),%eax 10fb49: 83 78 4c 05 cmpl $0x5,0x4c(%eax) 10fb4d: 74 19 je 10fb68 <== ALWAYS TAKEN 10fb4f: 68 12 b6 11 00 push $0x11b612 <== NOT EXECUTED 10fb54: 68 14 b7 11 00 push $0x11b714 <== NOT EXECUTED 10fb59: 68 f0 01 00 00 push $0x1f0 <== NOT EXECUTED 10fb5e: 68 c6 b5 11 00 push $0x11b5c6 <== NOT EXECUTED 10fb63: e8 3c 72 ff ff call 106da4 <__assert_func> <== NOT EXECUTED /* * 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; 10fb68: 8b 3d ac 11 12 00 mov 0x1211ac,%edi 10fb6e: c1 ef 02 shr $0x2,%edi * + triply indirect */ info = &the_jnode->info.file; if ( info->indirect ) { 10fb71: 8b 55 08 mov 0x8(%ebp),%edx 10fb74: 83 7a 54 00 cmpl $0x0,0x54(%edx) 10fb78: 74 11 je 10fb8b memfile_free_blocks_in_table( &info->indirect, to_free ); 10fb7a: 50 push %eax 10fb7b: 50 push %eax 10fb7c: 57 push %edi 10fb7d: 89 d0 mov %edx,%eax 10fb7f: 83 c0 54 add $0x54,%eax 10fb82: 50 push %eax 10fb83: e8 34 ff ff ff call 10fabc 10fb88: 83 c4 10 add $0x10,%esp } if ( info->doubly_indirect ) { 10fb8b: 31 db xor %ebx,%ebx 10fb8d: 8b 45 08 mov 0x8(%ebp),%eax 10fb90: 83 78 58 00 cmpl $0x0,0x58(%eax) 10fb94: 75 24 jne 10fbba <== NEVER TAKEN 10fb96: eb 40 jmp 10fbd8 for ( i=0 ; idoubly_indirect[i] ) { 10fb98: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10fb9b: 8b 42 58 mov 0x58(%edx),%eax <== NOT EXECUTED 10fb9e: 8d 14 9d 00 00 00 00 lea 0x0(,%ebx,4),%edx <== NOT EXECUTED 10fba5: 83 3c 98 00 cmpl $0x0,(%eax,%ebx,4) <== NOT EXECUTED 10fba9: 74 0e je 10fbb9 <== NOT EXECUTED memfile_free_blocks_in_table( 10fbab: 56 push %esi <== NOT EXECUTED 10fbac: 56 push %esi <== NOT EXECUTED 10fbad: 57 push %edi <== NOT EXECUTED 10fbae: 01 d0 add %edx,%eax <== NOT EXECUTED 10fbb0: 50 push %eax <== NOT EXECUTED 10fbb1: e8 06 ff ff ff call 10fabc <== NOT EXECUTED 10fbb6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED memfile_free_blocks_in_table( &info->indirect, to_free ); } if ( info->doubly_indirect ) { for ( i=0 ; i<== NOT EXECUTED 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 ); 10fbc6: 53 push %ebx <== NOT EXECUTED 10fbc7: 53 push %ebx <== NOT EXECUTED 10fbc8: 57 push %edi <== NOT EXECUTED 10fbc9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10fbcc: 83 c0 58 add $0x58,%eax <== NOT EXECUTED 10fbcf: 50 push %eax <== NOT EXECUTED 10fbd0: e8 e7 fe ff ff call 10fabc <== NOT EXECUTED 10fbd5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } if ( info->triply_indirect ) { 10fbd8: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) 10fbdf: 8b 45 08 mov 0x8(%ebp),%eax 10fbe2: 83 78 5c 00 cmpl $0x0,0x5c(%eax) 10fbe6: 75 5c jne 10fc44 <== NEVER TAKEN 10fbe8: eb 79 jmp 10fc63 10fbea: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10fbed: c1 e2 02 shl $0x2,%edx <== NOT EXECUTED 10fbf0: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED for ( i=0 ; itriply_indirect[i]; 10fbf3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10fbf6: 8b 42 5c mov 0x5c(%edx),%eax <== NOT EXECUTED 10fbf9: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10fbfc: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED if ( !p ) /* ensure we have a valid pointer */ 10fbff: 85 c0 test %eax,%eax <== NOT EXECUTED 10fc01: 74 4e je 10fc51 <== NOT EXECUTED break; 10fc03: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10fc05: 31 f6 xor %esi,%esi <== NOT EXECUTED 10fc07: eb 15 jmp 10fc1e <== NOT EXECUTED for ( j=0 ; j<== NOT EXECUTED memfile_free_blocks_in_table( (block_p **)&p[j], to_free); 10fc0e: 51 push %ecx <== NOT EXECUTED 10fc0f: 51 push %ecx <== NOT EXECUTED 10fc10: 57 push %edi <== NOT EXECUTED 10fc11: 53 push %ebx <== NOT EXECUTED 10fc12: e8 a5 fe ff ff call 10fabc <== NOT EXECUTED 10fc17: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( info->triply_indirect ) { for ( i=0 ; itriply_indirect[i]; if ( !p ) /* ensure we have a valid pointer */ break; for ( j=0 ; j<== NOT EXECUTED if ( p[j] ) { memfile_free_blocks_in_table( (block_p **)&p[j], to_free); } } memfile_free_blocks_in_table( 10fc2a: 52 push %edx <== NOT EXECUTED 10fc2b: 52 push %edx <== NOT EXECUTED 10fc2c: 57 push %edi <== NOT EXECUTED 10fc2d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10fc30: 8b 40 5c mov 0x5c(%eax),%eax <== NOT EXECUTED 10fc33: 01 45 f0 add %eax,-0x10(%ebp) <== NOT EXECUTED 10fc36: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10fc39: e8 7e fe ff ff call 10fabc <== NOT EXECUTED memfile_free_blocks_in_table( &info->doubly_indirect, to_free ); } if ( info->triply_indirect ) { for ( i=0 ; i<== NOT EXECUTED } } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( 10fc51: 50 push %eax <== NOT EXECUTED 10fc52: 50 push %eax <== NOT EXECUTED 10fc53: 57 push %edi <== NOT EXECUTED 10fc54: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10fc57: 83 c0 5c add $0x5c,%eax <== NOT EXECUTED 10fc5a: 50 push %eax <== NOT EXECUTED 10fc5b: e8 5c fe ff ff call 10fabc <== NOT EXECUTED 10fc60: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (block_p **)&info->triply_indirect, to_free ); } return 0; } 10fc63: 31 c0 xor %eax,%eax 10fc65: 8d 65 f4 lea -0xc(%ebp),%esp 10fc68: 5b pop %ebx 10fc69: 5e pop %esi 10fc6a: 5f pop %edi 10fc6b: c9 leave 10fc6c: c3 ret =============================================================================== 0010fa92 : MEMFILE_STATIC int IMFS_memfile_remove_block( IMFS_jnode_t *the_jnode, unsigned int block ) { 10fa92: 55 push %ebp <== NOT EXECUTED 10fa93: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fa95: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED block_p *block_entry_ptr; block_p ptr; block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 10fa98: 6a 00 push $0x0 <== NOT EXECUTED 10fa9a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10fa9d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10faa0: e8 69 fe ff ff call 10f90e <== NOT EXECUTED ptr = *block_entry_ptr; 10faa5: 8b 10 mov (%eax),%edx <== NOT EXECUTED *block_entry_ptr = 0; 10faa7: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED memfile_free_block( ptr ); 10faad: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 10fab0: e8 1e fe ff ff call 10f8d3 <== NOT EXECUTED return 1; } 10fab5: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10faba: c9 leave <== NOT EXECUTED 10fabb: c3 ret <== NOT EXECUTED =============================================================================== 0010ff04 : IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 10ff04: 55 push %ebp 10ff05: 89 e5 mov %esp,%ebp 10ff07: 57 push %edi 10ff08: 56 push %esi 10ff09: 53 push %ebx 10ff0a: 83 ec 3c sub $0x3c,%esp /* * Perform internal consistency checks */ assert( the_jnode ); 10ff0d: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 10ff11: 75 11 jne 10ff24 <== ALWAYS TAKEN 10ff13: 68 bc b5 11 00 push $0x11b5bc <== NOT EXECUTED 10ff18: 68 ec b6 11 00 push $0x11b6ec <== NOT EXECUTED 10ff1d: 68 e1 02 00 00 push $0x2e1 <== NOT EXECUTED 10ff22: eb 18 jmp 10ff3c <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 10ff24: 8b 45 08 mov 0x8(%ebp),%eax 10ff27: 83 78 4c 05 cmpl $0x5,0x4c(%eax) 10ff2b: 74 19 je 10ff46 <== ALWAYS TAKEN 10ff2d: 68 12 b6 11 00 push $0x11b612 <== NOT EXECUTED 10ff32: 68 ec b6 11 00 push $0x11b6ec <== NOT EXECUTED 10ff37: 68 e5 02 00 00 push $0x2e5 <== NOT EXECUTED 10ff3c: 68 c6 b5 11 00 push $0x11b5c6 <== NOT EXECUTED 10ff41: e8 5e 6e ff ff call 106da4 <__assert_func> <== NOT EXECUTED /* * Error check arguments */ assert( source ); 10ff46: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10ff4a: 75 11 jne 10ff5d <== ALWAYS TAKEN 10ff4c: 68 42 b6 11 00 push $0x11b642 <== NOT EXECUTED 10ff51: 68 ec b6 11 00 push $0x11b6ec <== NOT EXECUTED 10ff56: 68 ed 02 00 00 push $0x2ed <== NOT EXECUTED 10ff5b: eb df jmp 10ff3c <== NOT EXECUTED /* * If there is nothing to write, then quick exit. */ my_length = length; if ( !my_length ) 10ff5d: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10ff61: 75 0d jne 10ff70 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10ff63: e8 78 10 00 00 call 110fe0 <__errno> <== NOT EXECUTED 10ff68: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10ff6e: eb 29 jmp 10ff99 <== NOT EXECUTED /* * 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 + length; 10ff70: 8b 45 14 mov 0x14(%ebp),%eax 10ff73: 03 45 0c add 0xc(%ebp),%eax if ( last_byte > the_jnode->info.file.size ) { 10ff76: 8b 55 08 mov 0x8(%ebp),%edx 10ff79: 3b 42 50 cmp 0x50(%edx),%eax 10ff7c: 76 27 jbe 10ffa5 <== NEVER TAKEN status = IMFS_memfile_extend( the_jnode, last_byte ); 10ff7e: 51 push %ecx 10ff7f: 51 push %ecx 10ff80: 50 push %eax 10ff81: 52 push %edx 10ff82: e8 17 fe ff ff call 10fd9e if ( status ) 10ff87: 83 c4 10 add $0x10,%esp 10ff8a: 85 c0 test %eax,%eax 10ff8c: 74 17 je 10ffa5 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOSPC ); 10ff8e: e8 4d 10 00 00 call 110fe0 <__errno> <== NOT EXECUTED 10ff93: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 10ff99: c7 45 dc ff ff ff ff movl $0xffffffff,-0x24(%ebp) <== NOT EXECUTED 10ffa0: e9 24 01 00 00 jmp 1100c9 <== NOT EXECUTED /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 10ffa5: 8b 1d ac 11 12 00 mov 0x1211ac,%ebx 10ffab: 8b 45 0c mov 0xc(%ebp),%eax 10ffae: 99 cltd 10ffaf: f7 fb idiv %ebx 10ffb1: 89 d7 mov %edx,%edi 10ffb3: 89 45 c4 mov %eax,-0x3c(%ebp) block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 10ffb6: 89 45 d8 mov %eax,-0x28(%ebp) if ( start_offset ) { 10ffb9: 85 d2 test %edx,%edx 10ffbb: 75 12 jne 10ffcf 10ffbd: 8b 5d 14 mov 0x14(%ebp),%ebx 10ffc0: 8b 4d 10 mov 0x10(%ebp),%ecx 10ffc3: 89 4d e0 mov %ecx,-0x20(%ebp) 10ffc6: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) 10ffcd: eb 50 jmp 11001f 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 ); 10ffcf: 50 push %eax 10ffd0: 6a 00 push $0x0 10ffd2: ff 75 c4 pushl -0x3c(%ebp) 10ffd5: ff 75 08 pushl 0x8(%ebp) 10ffd8: e8 31 f9 ff ff call 10f90e assert( block_ptr ); 10ffdd: 83 c4 10 add $0x10,%esp 10ffe0: 85 c0 test %eax,%eax 10ffe2: 75 14 jne 10fff8 <== ALWAYS TAKEN 10ffe4: 68 49 b6 11 00 push $0x11b649 <== NOT EXECUTED 10ffe9: 68 ec b6 11 00 push $0x11b6ec <== NOT EXECUTED 10ffee: 68 1a 03 00 00 push $0x31a <== NOT EXECUTED 10fff3: e9 44 ff ff ff jmp 10ff3c <== NOT EXECUTED */ 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; 10fff8: 89 da mov %ebx,%edx 10fffa: 29 fa sub %edi,%edx 10fffc: 3b 55 14 cmp 0x14(%ebp),%edx 10ffff: 76 03 jbe 110004 <== NEVER TAKEN 110001: 8b 55 14 mov 0x14(%ebp),%edx if ( !block_ptr ) return copied; #if 0 fprintf(stdout, "write %d at %d in %d: %*s\n", to_copy, start_offset, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ start_offset ], src, to_copy ); 110004: 03 38 add (%eax),%edi src += to_copy; 110006: 8b 75 10 mov 0x10(%ebp),%esi 110009: 89 d1 mov %edx,%ecx 11000b: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 11000d: 89 75 e0 mov %esi,-0x20(%ebp) block++; 110010: 8b 45 c4 mov -0x3c(%ebp),%eax 110013: 40 inc %eax 110014: 89 45 d8 mov %eax,-0x28(%ebp) my_length -= to_copy; 110017: 8b 5d 14 mov 0x14(%ebp),%ebx 11001a: 29 d3 sub %edx,%ebx copied += to_copy; 11001c: 89 55 dc mov %edx,-0x24(%ebp) /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 11001f: 8b 15 ac 11 12 00 mov 0x1211ac,%edx 110025: 89 55 c4 mov %edx,-0x3c(%ebp) 110028: eb 42 jmp 11006c while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 11002a: 57 push %edi 11002b: 6a 00 push $0x0 11002d: ff 75 d8 pushl -0x28(%ebp) 110030: ff 75 08 pushl 0x8(%ebp) 110033: e8 d6 f8 ff ff call 10f90e assert( block_ptr ); 110038: 83 c4 10 add $0x10,%esp 11003b: 85 c0 test %eax,%eax 11003d: 75 14 jne 110053 <== ALWAYS TAKEN 11003f: 68 49 b6 11 00 push $0x11b649 <== NOT EXECUTED 110044: 68 ec b6 11 00 push $0x11b6ec <== NOT EXECUTED 110049: 68 2e 03 00 00 push $0x32e <== NOT EXECUTED 11004e: e9 e9 fe ff ff jmp 10ff3c <== NOT EXECUTED if ( !block_ptr ) return copied; #if 0 fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ 0 ], src, to_copy ); 110053: 8b 38 mov (%eax),%edi src += to_copy; 110055: 8b 75 e0 mov -0x20(%ebp),%esi 110058: 8b 4d c4 mov -0x3c(%ebp),%ecx 11005b: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 11005d: 89 75 e0 mov %esi,-0x20(%ebp) block++; 110060: ff 45 d8 incl -0x28(%ebp) my_length -= to_copy; 110063: 2b 5d c4 sub -0x3c(%ebp),%ebx IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 110066: 8b 45 c4 mov -0x3c(%ebp),%eax 110069: 01 45 dc add %eax,-0x24(%ebp) /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 11006c: 3b 1d ac 11 12 00 cmp 0x1211ac,%ebx 110072: 73 b6 jae 11002a */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); to_copy = my_length; if ( my_length ) { 110074: 85 db test %ebx,%ebx 110076: 74 35 je 1100ad block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 110078: 56 push %esi 110079: 6a 00 push $0x0 11007b: ff 75 d8 pushl -0x28(%ebp) 11007e: ff 75 08 pushl 0x8(%ebp) 110081: e8 88 f8 ff ff call 10f90e assert( block_ptr ); 110086: 83 c4 10 add $0x10,%esp 110089: 85 c0 test %eax,%eax 11008b: 75 14 jne 1100a1 <== ALWAYS TAKEN 11008d: 68 49 b6 11 00 push $0x11b649 <== NOT EXECUTED 110092: 68 ec b6 11 00 push $0x11b6ec <== NOT EXECUTED 110097: 68 44 03 00 00 push $0x344 <== NOT EXECUTED 11009c: e9 9b fe ff ff jmp 10ff3c <== NOT EXECUTED if ( !block_ptr ) return copied; #if 0 fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ 0 ], src, my_length ); 1100a1: 8b 38 mov (%eax),%edi 1100a3: 8b 75 e0 mov -0x20(%ebp),%esi 1100a6: 89 d9 mov %ebx,%ecx 1100a8: f3 a4 rep movsb %ds:(%esi),%es:(%edi) my_length = 0; copied += to_copy; 1100aa: 01 5d dc add %ebx,-0x24(%ebp) } IMFS_atime_mtime_update( the_jnode ); 1100ad: 53 push %ebx 1100ae: 53 push %ebx 1100af: 6a 00 push $0x0 1100b1: 8d 45 ec lea -0x14(%ebp),%eax 1100b4: 50 push %eax 1100b5: e8 ae 73 ff ff call 107468 1100ba: 8b 45 ec mov -0x14(%ebp),%eax 1100bd: 8b 55 08 mov 0x8(%ebp),%edx 1100c0: 89 42 44 mov %eax,0x44(%edx) 1100c3: 89 42 40 mov %eax,0x40(%edx) 1100c6: 83 c4 10 add $0x10,%esp return copied; } 1100c9: 8b 45 dc mov -0x24(%ebp),%eax 1100cc: 8d 65 f4 lea -0xc(%ebp),%esp 1100cf: 5b pop %ebx 1100d0: 5e pop %esi 1100d1: 5f pop %edi 1100d2: c9 leave 1100d3: c3 ret =============================================================================== 0010ca04 : const char *token, /* IN */ mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10ca04: 55 push %ebp 10ca05: 89 e5 mov %esp,%ebp 10ca07: 57 push %edi 10ca08: 56 push %esi 10ca09: 53 push %ebx 10ca0a: 83 ec 50 sub $0x50,%esp 10ca0d: 8b 7d 0c mov 0xc(%ebp),%edi 10ca10: 8b 5d 10 mov 0x10(%ebp),%ebx 10ca13: 8b 75 14 mov 0x14(%ebp),%esi IMFS_jnode_t *new_node; int result; char new_name[ IMFS_NAME_MAX + 1 ]; IMFS_types_union info; IMFS_get_token( token, new_name, &result ); 10ca16: 8d 45 f0 lea -0x10(%ebp),%eax 10ca19: 50 push %eax 10ca1a: 8d 45 bf lea -0x41(%ebp),%eax 10ca1d: 50 push %eax 10ca1e: ff 75 08 pushl 0x8(%ebp) 10ca21: e8 7a fe ff ff call 10c8a0 /* * Figure out what type of IMFS node this is. */ if ( S_ISDIR(mode) ) 10ca26: 89 f8 mov %edi,%eax 10ca28: 25 00 f0 00 00 and $0xf000,%eax 10ca2d: 83 c4 10 add $0x10,%esp 10ca30: 3d 00 40 00 00 cmp $0x4000,%eax 10ca35: 74 34 je 10ca6b type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) 10ca37: ba 05 00 00 00 mov $0x5,%edx 10ca3c: 3d 00 80 00 00 cmp $0x8000,%eax 10ca41: 74 2d je 10ca70 type = IMFS_MEMORY_FILE; else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { 10ca43: 3d 00 60 00 00 cmp $0x6000,%eax 10ca48: 74 07 je 10ca51 <== NEVER TAKEN 10ca4a: 3d 00 20 00 00 cmp $0x2000,%eax 10ca4f: 75 0d jne 10ca5e <== NEVER TAKEN type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor ); 10ca51: 89 5d e0 mov %ebx,-0x20(%ebp) 10ca54: 89 75 e4 mov %esi,-0x1c(%ebp) 10ca57: ba 02 00 00 00 mov $0x2,%edx 10ca5c: eb 12 jmp 10ca70 } else { rtems_set_errno_and_return_minus_one( EINVAL ); 10ca5e: e8 c5 26 00 00 call 10f128 <__errno> <== NOT EXECUTED 10ca63: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10ca69: eb 2e jmp 10ca99 <== NOT EXECUTED 10ca6b: ba 01 00 00 00 mov $0x1,%edx /* * Allocate and fill in an IMFS jnode */ new_node = IMFS_create_node( 10ca70: 83 ec 0c sub $0xc,%esp 10ca73: 8d 45 e0 lea -0x20(%ebp),%eax 10ca76: 50 push %eax 10ca77: 57 push %edi 10ca78: 8d 45 bf lea -0x41(%ebp),%eax 10ca7b: 50 push %eax 10ca7c: 52 push %edx 10ca7d: ff 75 18 pushl 0x18(%ebp) 10ca80: e8 eb 1c 00 00 call 10e770 new_name, mode, &info ); if ( !new_node ) 10ca85: 83 c4 20 add $0x20,%esp 10ca88: 31 d2 xor %edx,%edx 10ca8a: 85 c0 test %eax,%eax 10ca8c: 75 0e jne 10ca9c <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOMEM ); 10ca8e: e8 95 26 00 00 call 10f128 <__errno> <== NOT EXECUTED 10ca93: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10ca99: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED return 0; } 10ca9c: 89 d0 mov %edx,%eax 10ca9e: 8d 65 f4 lea -0xc(%ebp),%esp 10caa1: 5b pop %ebx 10caa2: 5e pop %esi 10caa3: 5f pop %edi 10caa4: c9 leave 10caa5: c3 ret =============================================================================== 00106aa8 : #include int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 106aa8: 55 push %ebp 106aa9: 89 e5 mov %esp,%ebp 106aab: 83 ec 08 sub $0x8,%esp 106aae: 8b 55 08 mov 0x8(%ebp),%edx IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 106ab1: 8b 42 08 mov 0x8(%edx),%eax /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 106ab4: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 106ab8: 74 10 je 106aca <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTDIR ); 106aba: e8 21 a5 00 00 call 110fe0 <__errno> <== NOT EXECUTED 106abf: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 106ac5: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 106ac8: eb 05 jmp 106acf <== 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; 106aca: 89 50 5c mov %edx,0x5c(%eax) 106acd: 31 c0 xor %eax,%eax return 0; } 106acf: c9 leave 106ad0: c3 ret =============================================================================== 00107836 : */ void IMFS_print_jnode( IMFS_jnode_t *the_jnode ) { 107836: 55 push %ebp 107837: 89 e5 mov %esp,%ebp 107839: 53 push %ebx 10783a: 83 ec 04 sub $0x4,%esp 10783d: 8b 5d 08 mov 0x8(%ebp),%ebx assert( the_jnode ); 107840: 85 db test %ebx,%ebx 107842: 75 11 jne 107855 <== ALWAYS TAKEN 107844: 68 82 cb 11 00 push $0x11cb82 <== NOT EXECUTED 107849: 68 28 cd 11 00 push $0x11cd28 <== NOT EXECUTED 10784e: 6a 38 push $0x38 <== NOT EXECUTED 107850: e9 98 00 00 00 jmp 1078ed <== NOT EXECUTED fprintf(stdout, "%s", the_jnode->name ); 107855: 50 push %eax 107856: 50 push %eax 107857: a1 80 14 12 00 mov 0x121480,%eax 10785c: ff 70 08 pushl 0x8(%eax) 10785f: 8d 43 0c lea 0xc(%ebx),%eax 107862: 50 push %eax 107863: e8 ec b3 00 00 call 112c54 switch( the_jnode->type ) { 107868: 8b 43 4c mov 0x4c(%ebx),%eax 10786b: 83 c4 10 add $0x10,%esp 10786e: 8d 50 ff lea -0x1(%eax),%edx 107871: 83 fa 05 cmp $0x5,%edx 107874: 0f 87 9a 00 00 00 ja 107914 <== NEVER TAKEN 10787a: a1 80 14 12 00 mov 0x121480,%eax 10787f: ff 24 95 fc cc 11 00 jmp *0x11ccfc(,%edx,4) case IMFS_DIRECTORY: fprintf(stdout, "/" ); 107886: 51 push %ecx 107887: 51 push %ecx 107888: ff 70 08 pushl 0x8(%eax) 10788b: 6a 2f push $0x2f 10788d: e8 f2 b2 00 00 call 112b84 107892: eb 2b jmp 1078bf break; case IMFS_DEVICE: fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")", 107894: ff 73 54 pushl 0x54(%ebx) 107897: ff 73 50 pushl 0x50(%ebx) 10789a: 68 db cb 11 00 push $0x11cbdb 10789f: eb 16 jmp 1078b7 the_jnode->info.device.major, the_jnode->info.device.minor ); break; case IMFS_LINEAR_FILE: fprintf(stdout, " (file %" PRId32 " %p)", 1078a1: ff 73 54 pushl 0x54(%ebx) <== NOT EXECUTED 1078a4: ff 73 50 pushl 0x50(%ebx) <== NOT EXECUTED 1078a7: 68 ee cb 11 00 push $0x11cbee <== NOT EXECUTED 1078ac: eb 09 jmp 1078b7 <== NOT EXECUTED the_jnode->info.file.indirect, the_jnode->info.file.doubly_indirect, the_jnode->info.file.triply_indirect ); #else fprintf(stdout, " (file %" PRId32 ")", 1078ae: 52 push %edx 1078af: ff 73 50 pushl 0x50(%ebx) 1078b2: 68 fd cb 11 00 push $0x11cbfd 1078b7: ff 70 08 pushl 0x8(%eax) 1078ba: e8 89 b2 00 00 call 112b48 1078bf: 83 c4 10 add $0x10,%esp default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 1078c2: c7 45 08 99 ce 11 00 movl $0x11ce99,0x8(%ebp) } 1078c9: 8b 5d fc mov -0x4(%ebp),%ebx 1078cc: c9 leave default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 1078cd: e9 5e c9 00 00 jmp 114230 (uint32_t)the_jnode->info.file.size ); #endif break; case IMFS_HARD_LINK: fprintf(stdout, " links not printed\n" ); 1078d2: 53 push %ebx <== NOT EXECUTED 1078d3: 53 push %ebx <== NOT EXECUTED 1078d4: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1078d7: 68 09 cc 11 00 push $0x11cc09 <== NOT EXECUTED 1078dc: e8 73 b3 00 00 call 112c54 <== NOT EXECUTED assert(0); 1078e1: 68 6f c5 11 00 push $0x11c56f <== NOT EXECUTED 1078e6: 68 28 cd 11 00 push $0x11cd28 <== NOT EXECUTED 1078eb: 6a 5d push $0x5d <== NOT EXECUTED 1078ed: 68 8c cb 11 00 push $0x11cb8c <== NOT EXECUTED 1078f2: e8 55 06 00 00 call 107f4c <__assert_func> <== NOT EXECUTED break; case IMFS_SYM_LINK: fprintf(stdout, " links not printed\n" ); 1078f7: 51 push %ecx <== NOT EXECUTED 1078f8: 51 push %ecx <== NOT EXECUTED 1078f9: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1078fc: 68 09 cc 11 00 push $0x11cc09 <== NOT EXECUTED 107901: e8 4e b3 00 00 call 112c54 <== NOT EXECUTED assert(0); 107906: 68 6f c5 11 00 push $0x11c56f <== NOT EXECUTED 10790b: 68 28 cd 11 00 push $0x11cd28 <== NOT EXECUTED 107910: 6a 62 push $0x62 <== NOT EXECUTED 107912: eb d9 jmp 1078ed <== NOT EXECUTED break; default: fprintf(stdout, " bad type %d\n", the_jnode->type ); 107914: 52 push %edx <== NOT EXECUTED 107915: 50 push %eax <== NOT EXECUTED 107916: 68 1d cc 11 00 push $0x11cc1d <== NOT EXECUTED 10791b: a1 80 14 12 00 mov 0x121480,%eax <== NOT EXECUTED 107920: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 107923: e8 20 b2 00 00 call 112b48 <== NOT EXECUTED assert(0); 107928: 68 6f c5 11 00 push $0x11c56f <== NOT EXECUTED 10792d: 68 28 cd 11 00 push $0x11cd28 <== NOT EXECUTED 107932: 6a 67 push $0x67 <== NOT EXECUTED 107934: eb b7 jmp 1078ed <== NOT EXECUTED =============================================================================== 00106ae4 : int IMFS_readlink( rtems_filesystem_location_info_t *loc, char *buf, /* OUT */ size_t bufsize ) { 106ae4: 55 push %ebp 106ae5: 89 e5 mov %esp,%ebp 106ae7: 53 push %ebx 106ae8: 83 ec 04 sub $0x4,%esp 106aeb: 8b 5d 0c mov 0xc(%ebp),%ebx IMFS_jnode_t *node; int i; node = loc->node_access; 106aee: 8b 45 08 mov 0x8(%ebp),%eax 106af1: 8b 08 mov (%eax),%ecx if ( node->type != IMFS_SYM_LINK ) 106af3: 31 d2 xor %edx,%edx 106af5: 83 79 4c 04 cmpl $0x4,0x4c(%ecx) 106af9: 74 14 je 106b0f <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 106afb: e8 e0 a4 00 00 call 110fe0 <__errno> <== NOT EXECUTED 106b00: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 106b06: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 106b09: eb 13 jmp 106b1e <== NOT EXECUTED for( i=0; ((iinfo.sym_link.name[i] != '\0')); i++ ) buf[i] = node->info.sym_link.name[i]; 106b0b: 88 04 13 mov %al,(%ebx,%edx,1) node = loc->node_access; if ( node->type != IMFS_SYM_LINK ) rtems_set_errno_and_return_minus_one( EINVAL ); for( i=0; ((iinfo.sym_link.name[i] != '\0')); i++ ) 106b0e: 42 inc %edx 106b0f: 3b 55 10 cmp 0x10(%ebp),%edx 106b12: 73 0a jae 106b1e 106b14: 8b 41 50 mov 0x50(%ecx),%eax 106b17: 8a 04 10 mov (%eax,%edx,1),%al 106b1a: 84 c0 test %al,%al 106b1c: 75 ed jne 106b0b buf[i] = node->info.sym_link.name[i]; return i; } 106b1e: 89 d0 mov %edx,%eax 106b20: 5a pop %edx 106b21: 5b pop %ebx 106b22: c9 leave 106b23: c3 ret =============================================================================== 0010cab8 : */ int IMFS_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 10cab8: 55 push %ebp 10cab9: 89 e5 mov %esp,%ebp 10cabb: 56 push %esi 10cabc: 53 push %ebx 10cabd: 83 ec 10 sub $0x10,%esp 10cac0: 8b 75 08 mov 0x8(%ebp),%esi IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 10cac3: 8b 1e mov (%esi),%ebx /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 10cac5: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10cac9: 74 13 je 10cade <== NEVER TAKEN 10cacb: 83 ec 0c sub $0xc,%esp 10cace: 53 push %ebx 10cacf: e8 70 12 00 00 call 10dd44 <_Chain_Extract> rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 10cad4: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 10cadb: 83 c4 10 add $0x10,%esp /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 10cade: 66 ff 4b 34 decw 0x34(%ebx) IMFS_update_ctime( the_jnode ); 10cae2: 50 push %eax 10cae3: 50 push %eax 10cae4: 6a 00 push $0x0 10cae6: 8d 45 f0 lea -0x10(%ebp),%eax 10cae9: 50 push %eax 10caea: e8 65 03 00 00 call 10ce54 10caef: 8b 45 f0 mov -0x10(%ebp),%eax 10caf2: 89 43 48 mov %eax,0x48(%ebx) /* * The file cannot be open and the link must be less than 1 to free. */ if ( !rtems_libio_is_file_open( the_jnode ) && (the_jnode->st_nlink < 1) ) { 10caf5: 89 1c 24 mov %ebx,(%esp) 10caf8: e8 07 04 00 00 call 10cf04 10cafd: 83 c4 10 add $0x10,%esp 10cb00: 85 c0 test %eax,%eax 10cb02: 75 40 jne 10cb44 <== NEVER TAKEN 10cb04: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) 10cb09: 75 39 jne 10cb44 <== NEVER TAKEN /* * Is rtems_filesystem_current this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 10cb0b: 8b 15 6c b6 11 00 mov 0x11b66c,%edx 10cb11: 8b 42 04 mov 0x4(%edx),%eax 10cb14: 3b 06 cmp (%esi),%eax 10cb16: 75 07 jne 10cb1f <== ALWAYS TAKEN rtems_filesystem_current.node_access = NULL; 10cb18: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED /* * Free memory associated with a memory file. */ if ( the_jnode->type == IMFS_SYM_LINK ) { 10cb1f: 83 7b 4c 04 cmpl $0x4,0x4c(%ebx) 10cb23: 75 13 jne 10cb38 if ( the_jnode->info.sym_link.name ) 10cb25: 8b 43 50 mov 0x50(%ebx),%eax 10cb28: 85 c0 test %eax,%eax 10cb2a: 74 0c je 10cb38 <== NEVER TAKEN free( (void*) the_jnode->info.sym_link.name ); 10cb2c: 83 ec 0c sub $0xc,%esp 10cb2f: 50 push %eax 10cb30: e8 43 99 ff ff call 106478 10cb35: 83 c4 10 add $0x10,%esp } free( the_jnode ); 10cb38: 83 ec 0c sub $0xc,%esp 10cb3b: 53 push %ebx 10cb3c: e8 37 99 ff ff call 106478 10cb41: 83 c4 10 add $0x10,%esp } return 0; } 10cb44: 31 c0 xor %eax,%eax 10cb46: 8d 65 f8 lea -0x8(%ebp),%esp 10cb49: 5b pop %ebx 10cb4a: 5e pop %esi 10cb4b: c9 leave 10cb4c: c3 ret =============================================================================== 0010cb50 : int IMFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 10cb50: 55 push %ebp 10cb51: 89 e5 mov %esp,%ebp 10cb53: 53 push %ebx 10cb54: 83 ec 04 sub $0x4,%esp 10cb57: 8b 5d 0c mov 0xc(%ebp),%ebx IMFS_jnode_t *the_jnode; IMFS_device_t *io; the_jnode = loc->node_access; 10cb5a: 8b 45 08 mov 0x8(%ebp),%eax 10cb5d: 8b 08 mov (%eax),%ecx switch ( the_jnode->type ) { 10cb5f: 8b 41 4c mov 0x4c(%ecx),%eax 10cb62: 83 f8 04 cmp $0x4,%eax 10cb65: 74 25 je 10cb8c <== NEVER TAKEN 10cb67: 7f 07 jg 10cb70 10cb69: 83 f8 02 cmp $0x2,%eax 10cb6c: 75 27 jne 10cb95 <== NEVER TAKEN 10cb6e: eb 07 jmp 10cb77 10cb70: 83 f8 06 cmp $0x6,%eax 10cb73: 7f 20 jg 10cb95 <== NEVER TAKEN 10cb75: eb 0d jmp 10cb84 case IMFS_DEVICE: io = &the_jnode->info.device; buf->st_dev = rtems_filesystem_make_dev_t( io->major, io->minor ); 10cb77: 8b 51 54 mov 0x54(%ecx),%edx 10cb7a: 8b 41 50 mov 0x50(%ecx),%eax 10cb7d: 89 03 mov %eax,(%ebx) 10cb7f: 89 53 04 mov %edx,0x4(%ebx) 10cb82: eb 21 jmp 10cba5 break; case IMFS_LINEAR_FILE: case IMFS_MEMORY_FILE: buf->st_size = the_jnode->info.file.size; 10cb84: 8b 41 50 mov 0x50(%ecx),%eax 10cb87: 89 43 20 mov %eax,0x20(%ebx) 10cb8a: eb 19 jmp 10cba5 break; case IMFS_SYM_LINK: buf->st_size = 0; 10cb8c: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED 10cb93: eb 10 jmp 10cba5 <== NOT EXECUTED break; default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 10cb95: e8 8e 25 00 00 call 10f128 <__errno> <== NOT EXECUTED 10cb9a: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10cba0: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10cba3: eb 3e jmp 10cbe3 <== NOT EXECUTED break; } buf->st_mode = the_jnode->st_mode; 10cba5: 8b 41 30 mov 0x30(%ecx),%eax 10cba8: 89 43 0c mov %eax,0xc(%ebx) buf->st_nlink = the_jnode->st_nlink; 10cbab: 8b 41 34 mov 0x34(%ecx),%eax 10cbae: 66 89 43 10 mov %ax,0x10(%ebx) buf->st_ino = the_jnode->st_ino; 10cbb2: 8b 41 38 mov 0x38(%ecx),%eax 10cbb5: 89 43 08 mov %eax,0x8(%ebx) buf->st_uid = the_jnode->st_uid; 10cbb8: 8b 41 3c mov 0x3c(%ecx),%eax 10cbbb: 66 89 43 12 mov %ax,0x12(%ebx) buf->st_gid = the_jnode->st_gid; 10cbbf: 66 8b 41 3e mov 0x3e(%ecx),%ax 10cbc3: 66 89 43 14 mov %ax,0x14(%ebx) buf->st_atime = the_jnode->stat_atime; 10cbc7: 8b 41 40 mov 0x40(%ecx),%eax 10cbca: 89 43 24 mov %eax,0x24(%ebx) buf->st_mtime = the_jnode->stat_mtime; 10cbcd: 8b 41 44 mov 0x44(%ecx),%eax 10cbd0: 89 43 2c mov %eax,0x2c(%ebx) buf->st_ctime = the_jnode->stat_ctime; 10cbd3: 8b 41 48 mov 0x48(%ecx),%eax 10cbd6: 89 43 34 mov %eax,0x34(%ebx) buf->st_blksize = imfs_rq_memfile_bytes_per_block; 10cbd9: a1 dc 92 11 00 mov 0x1192dc,%eax 10cbde: 89 43 3c mov %eax,0x3c(%ebx) 10cbe1: 31 c0 xor %eax,%eax return 0; } 10cbe3: 5a pop %edx 10cbe4: 5b pop %ebx 10cbe5: c9 leave 10cbe6: c3 ret =============================================================================== 00106b24 : int IMFS_symlink( rtems_filesystem_location_info_t *parent_loc, const char *link_name, const char *node_name ) { 106b24: 55 push %ebp 106b25: 89 e5 mov %esp,%ebp 106b27: 53 push %ebx 106b28: 83 ec 48 sub $0x48,%esp /* * Remove any separators at the end of the string. */ IMFS_get_token( node_name, new_name, &i ); 106b2b: 8d 45 f8 lea -0x8(%ebp),%eax 106b2e: 50 push %eax 106b2f: 8d 5d c7 lea -0x39(%ebp),%ebx 106b32: 53 push %ebx 106b33: ff 75 10 pushl 0x10(%ebp) 106b36: e8 69 74 00 00 call 10dfa4 /* * Duplicate link name */ info.sym_link.name = strdup( link_name); 106b3b: 58 pop %eax 106b3c: ff 75 0c pushl 0xc(%ebp) 106b3f: e8 fc bf 00 00 call 112b40 106b44: 89 45 e8 mov %eax,-0x18(%ebp) if (info.sym_link.name == NULL) { 106b47: 83 c4 10 add $0x10,%esp 106b4a: 85 c0 test %eax,%eax 106b4c: 75 10 jne 106b5e <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOMEM); 106b4e: e8 8d a4 00 00 call 110fe0 <__errno> <== NOT EXECUTED 106b53: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 106b59: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 106b5c: eb 3c jmp 106b9a <== NOT EXECUTED /* * Create a new link node. */ new_node = IMFS_create_node( 106b5e: 83 ec 0c sub $0xc,%esp 106b61: 8d 45 e8 lea -0x18(%ebp),%eax 106b64: 50 push %eax 106b65: 68 ff a1 00 00 push $0xa1ff 106b6a: 53 push %ebx 106b6b: 6a 04 push $0x4 106b6d: ff 75 08 pushl 0x8(%ebp) 106b70: e8 ff 6b 00 00 call 10d774 new_name, ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if (new_node == NULL) { 106b75: 83 c4 20 add $0x20,%esp 106b78: 31 d2 xor %edx,%edx 106b7a: 85 c0 test %eax,%eax 106b7c: 75 1c jne 106b9a <== ALWAYS TAKEN free( info.sym_link.name); 106b7e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106b81: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 106b84: e8 6f 07 00 00 call 1072f8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM); 106b89: e8 52 a4 00 00 call 110fe0 <__errno> <== NOT EXECUTED 106b8e: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 106b94: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 106b97: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 106b9a: 89 d0 mov %edx,%eax 106b9c: 8b 5d fc mov -0x4(%ebp),%ebx 106b9f: c9 leave 106ba0: c3 ret =============================================================================== 00106ba4 : #include int IMFS_unlink( rtems_filesystem_location_info_t *loc /* IN */ ) { 106ba4: 55 push %ebp 106ba5: 89 e5 mov %esp,%ebp 106ba7: 57 push %edi 106ba8: 56 push %esi 106ba9: 53 push %ebx 106baa: 83 ec 2c sub $0x2c,%esp IMFS_jnode_t *node; rtems_filesystem_location_info_t the_link; int result = 0; node = loc->node_access; 106bad: 8b 45 08 mov 0x8(%ebp),%eax 106bb0: 8b 18 mov (%eax),%ebx /* * If this is the last last pointer to the node * free the node. */ if ( node->type == IMFS_HARD_LINK ) { 106bb2: 83 7b 4c 03 cmpl $0x3,0x4c(%ebx) 106bb6: 75 76 jne 106c2e if ( !node->info.hard_link.link_node ) 106bb8: 8b 43 50 mov 0x50(%ebx),%eax 106bbb: 85 c0 test %eax,%eax 106bbd: 75 10 jne 106bcf <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 106bbf: e8 1c a4 00 00 call 110fe0 <__errno> <== NOT EXECUTED 106bc4: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 106bca: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 106bcd: eb 71 jmp 106c40 <== NOT EXECUTED the_link = *loc; 106bcf: 8d 7d dc lea -0x24(%ebp),%edi 106bd2: b9 04 00 00 00 mov $0x4,%ecx 106bd7: 8b 75 08 mov 0x8(%ebp),%esi 106bda: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_link.node_access = node->info.hard_link.link_node; 106bdc: 89 45 dc mov %eax,-0x24(%ebp) IMFS_Set_handlers( &the_link ); 106bdf: 83 ec 0c sub $0xc,%esp 106be2: 8d 7d dc lea -0x24(%ebp),%edi 106be5: 57 push %edi 106be6: e8 c5 6c 00 00 call 10d8b0 /* * 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) 106beb: 8b 53 50 mov 0x50(%ebx),%edx 106bee: 8b 42 34 mov 0x34(%edx),%eax 106bf1: 83 c4 10 add $0x10,%esp 106bf4: 66 83 f8 01 cmp $0x1,%ax 106bf8: 75 16 jne 106c10 { result = (*the_link.handlers->rmnod_h)( &the_link ); 106bfa: 83 ec 0c sub $0xc,%esp 106bfd: 57 push %edi 106bfe: 8b 45 e0 mov -0x20(%ebp),%eax 106c01: ff 50 34 call *0x34(%eax) if ( result != 0 ) 106c04: 83 c4 10 add $0x10,%esp 106c07: 83 ca ff or $0xffffffff,%edx 106c0a: 85 c0 test %eax,%eax 106c0c: 74 20 je 106c2e 106c0e: eb 30 jmp 106c40 return -1; } else { node->info.hard_link.link_node->st_nlink --; 106c10: 48 dec %eax 106c11: 66 89 42 34 mov %ax,0x34(%edx) IMFS_update_ctime( node->info.hard_link.link_node ); 106c15: 50 push %eax 106c16: 50 push %eax 106c17: 6a 00 push $0x0 106c19: 8d 45 ec lea -0x14(%ebp),%eax 106c1c: 50 push %eax 106c1d: e8 46 08 00 00 call 107468 106c22: 8b 53 50 mov 0x50(%ebx),%edx 106c25: 8b 45 ec mov -0x14(%ebp),%eax 106c28: 89 42 48 mov %eax,0x48(%edx) 106c2b: 83 c4 10 add $0x10,%esp /* * Now actually free the node we were asked to free. */ result = (*loc->handlers->rmnod_h)( loc ); 106c2e: 83 ec 0c sub $0xc,%esp 106c31: 8b 55 08 mov 0x8(%ebp),%edx 106c34: 8b 42 04 mov 0x4(%edx),%eax 106c37: 52 push %edx 106c38: ff 50 34 call *0x34(%eax) 106c3b: 89 c2 mov %eax,%edx 106c3d: 83 c4 10 add $0x10,%esp return result; } 106c40: 89 d0 mov %edx,%eax 106c42: 8d 65 f4 lea -0xc(%ebp),%esp 106c45: 5b pop %ebx 106c46: 5e pop %esi 106c47: 5f pop %edi 106c48: c9 leave 106c49: c3 ret =============================================================================== 00106c4c : #include int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 106c4c: 55 push %ebp 106c4d: 89 e5 mov %esp,%ebp 106c4f: 83 ec 08 sub $0x8,%esp IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 106c52: 8b 45 08 mov 0x8(%ebp),%eax 106c55: 8b 40 08 mov 0x8(%eax),%eax /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 106c58: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 106c5c: 74 0d je 106c6b <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTDIR ); 106c5e: e8 7d a3 00 00 call 110fe0 <__errno> <== NOT EXECUTED 106c63: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 106c69: eb 11 jmp 106c7c <== NOT EXECUTED /* * Did the node indicate that there was a directory mounted here? */ if ( node->info.directory.mt_fs == NULL ) 106c6b: 83 78 5c 00 cmpl $0x0,0x5c(%eax) 106c6f: 75 10 jne 106c81 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */ 106c71: e8 6a a3 00 00 call 110fe0 <__errno> <== NOT EXECUTED 106c76: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 106c7c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 106c7f: eb 09 jmp 106c8a <== 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; 106c81: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) 106c88: 31 c0 xor %eax,%eax return 0; } 106c8a: c9 leave 106c8b: c3 ret =============================================================================== 001065fc : void RTEMS_Malloc_Initialize( void *start, size_t length, size_t sbrk_amount ) { 1065fc: 55 push %ebp 1065fd: 89 e5 mov %esp,%ebp 1065ff: 57 push %edi 106600: 56 push %esi 106601: 53 push %ebx 106602: 83 ec 0c sub $0xc,%esp 106605: 8b 75 08 mov 0x8(%ebp),%esi 106608: 8b 5d 0c mov 0xc(%ebp),%ebx #endif /* * If configured, initialize the statistics support */ if ( rtems_malloc_statistics_helpers ) 10660b: a1 d4 bb 11 00 mov 0x11bbd4,%eax 106610: 85 c0 test %eax,%eax 106612: 74 02 je 106616 <== ALWAYS TAKEN (*rtems_malloc_statistics_helpers->initialize)(); 106614: ff 10 call *(%eax) <== NOT EXECUTED /* * Initialize the garbage collection list to start with nothing on it. */ malloc_deferred_frees_initialize(); 106616: e8 79 ff ff ff call 106594 starting_address = start; /* * Initialize the optional sbrk support for extending the heap */ if (rtems_malloc_sbrk_helpers) { 10661b: a1 d8 bb 11 00 mov 0x11bbd8,%eax 106620: 89 f2 mov %esi,%edx 106622: 85 c0 test %eax,%eax 106624: 74 0d je 106633 <== ALWAYS TAKEN starting_address = (*rtems_malloc_sbrk_helpers->initialize)( 106626: 52 push %edx <== NOT EXECUTED 106627: 52 push %edx <== NOT EXECUTED 106628: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10662b: 56 push %esi <== NOT EXECUTED 10662c: ff 10 call *(%eax) <== NOT EXECUTED 10662e: 89 c2 mov %eax,%edx <== NOT EXECUTED 106630: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * of the time under UNIX because zero'ing memory when it is first * given to a process eliminates the chance of a process seeing data * left over from another process. This would be a security violation. */ if ( rtems_configuration_get_do_zero_of_workspace() ) 106633: a1 30 d8 11 00 mov 0x11d830,%eax 106638: 80 78 28 00 cmpb $0x0,0x28(%eax) 10663c: 74 08 je 106646 <== ALWAYS TAKEN memset( starting_address, 0, length ); 10663e: 31 c0 xor %eax,%eax 106640: 89 d7 mov %edx,%edi <== NOT EXECUTED 106642: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 106644: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED void *starting_address, size_t size, uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); 106646: 6a 04 push $0x4 106648: 53 push %ebx 106649: 52 push %edx 10664a: 68 50 d6 11 00 push $0x11d650 10664f: e8 d8 39 00 00 call 10a02c <_Heap_Initialize> &RTEMS_Malloc_Heap, starting_address, length, CPU_HEAP_ALIGNMENT ); if ( !status ) 106654: 83 c4 10 add $0x10,%esp 106657: 85 c0 test %eax,%eax 106659: 75 0a jne 106665 <== ALWAYS TAKEN rtems_fatal_error_occurred( status ); 10665b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10665e: 6a 00 push $0x0 <== NOT EXECUTED 106660: e8 2f 31 00 00 call 109794 <== NOT EXECUTED rtems_print_buffer( (start + length) - 48, 48 ); rtems_fatal_error_occurred( RTEMS_NO_MEMORY ); } #endif MSBUMP(space_available, length); 106665: 01 1d a8 d6 11 00 add %ebx,0x11d6a8 } 10666b: 8d 65 f4 lea -0xc(%ebp),%esp 10666e: 5b pop %ebx 10666f: 5e pop %esi 106670: 5f pop %edi 106671: c9 leave 106672: c3 ret =============================================================================== 0010674a : static rtems_printk_plugin_t print_handler; void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) { 10674a: 55 push %ebp <== NOT EXECUTED 10674b: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10674d: 57 push %edi <== NOT EXECUTED 10674e: 56 push %esi <== NOT EXECUTED 10674f: 53 push %ebx <== NOT EXECUTED 106750: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 106753: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED void *high_water_mark; void *current; Stack_Control *stack; char name[5]; if ( !the_thread ) 106756: 85 db test %ebx,%ebx <== NOT EXECUTED 106758: 0f 84 fc 00 00 00 je 10685a <== NOT EXECUTED return; if ( !print_handler ) 10675e: a1 f4 0d 12 00 mov 0x120df4,%eax <== NOT EXECUTED 106763: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED 106766: 85 c0 test %eax,%eax <== NOT EXECUTED 106768: 0f 84 ec 00 00 00 je 10685a <== NOT EXECUTED /* * Obtain interrupt stack information */ if (the_thread == (Thread_Control *) -1) { 10676e: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED 106771: 75 1d jne 106790 <== NOT EXECUTED if (Stack_check_Interrupt_stack.area) { 106773: 83 3d 1c 10 12 00 00 cmpl $0x0,0x12101c <== NOT EXECUTED 10677a: 0f 84 da 00 00 00 je 10685a <== NOT EXECUTED stack = &Stack_check_Interrupt_stack; the_thread = 0; current = 0; } else return; 106780: 31 db xor %ebx,%ebx <== NOT EXECUTED 106782: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 106789: be 18 10 12 00 mov $0x121018,%esi <== NOT EXECUTED 10678e: eb 0f jmp 10679f <== NOT EXECUTED } else { stack = &the_thread->Start.Initial_stack; 106790: 8d b3 c4 00 00 00 lea 0xc4(%ebx),%esi <== NOT EXECUTED current = (void *)_CPU_Context_Get_SP( &the_thread->Registers ); 106796: 8b 83 d8 00 00 00 mov 0xd8(%ebx),%eax <== NOT EXECUTED 10679c: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED } low = Stack_check_usable_stack_start(stack); 10679f: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 1067a2: 8d 78 10 lea 0x10(%eax),%edi <== NOT EXECUTED size = Stack_check_usable_stack_size(stack); 1067a5: 8b 06 mov (%esi),%eax <== NOT EXECUTED 1067a7: 83 e8 10 sub $0x10,%eax <== NOT EXECUTED 1067aa: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED high_water_mark = Stack_check_find_high_water_mark(low, size); 1067ad: 50 push %eax <== NOT EXECUTED 1067ae: 57 push %edi <== NOT EXECUTED 1067af: e8 6b ff ff ff call 10671f <== NOT EXECUTED if ( high_water_mark ) 1067b4: 5a pop %edx <== NOT EXECUTED 1067b5: 59 pop %ecx <== NOT EXECUTED 1067b6: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED 1067bd: 85 c0 test %eax,%eax <== NOT EXECUTED 1067bf: 74 09 je 1067ca <== NOT EXECUTED used = Stack_check_Calculate_used( low, size, high_water_mark ); 1067c1: 03 7d d8 add -0x28(%ebp),%edi <== NOT EXECUTED 1067c4: 89 7d dc mov %edi,-0x24(%ebp) <== NOT EXECUTED 1067c7: 29 45 dc sub %eax,-0x24(%ebp) <== NOT EXECUTED else used = 0; if ( the_thread ) { 1067ca: 85 db test %ebx,%ebx <== NOT EXECUTED 1067cc: 74 26 je 1067f4 <== NOT EXECUTED (*print_handler)( 1067ce: 50 push %eax <== NOT EXECUTED 1067cf: 8d 45 ef lea -0x11(%ebp),%eax <== NOT EXECUTED 1067d2: 50 push %eax <== NOT EXECUTED 1067d3: 6a 05 push $0x5 <== NOT EXECUTED 1067d5: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 1067d8: e8 1f 34 00 00 call 109bfc <== NOT EXECUTED 1067dd: 50 push %eax <== NOT EXECUTED 1067de: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 1067e1: 68 d9 99 11 00 push $0x1199d9 <== NOT EXECUTED 1067e6: ff 35 f0 0d 12 00 pushl 0x120df0 <== NOT EXECUTED 1067ec: ff 55 d4 call *-0x2c(%ebp) <== NOT EXECUTED 1067ef: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1067f2: eb 14 jmp 106808 <== NOT EXECUTED "0x%08" PRIx32 " %4s", the_thread->Object.id, rtems_object_get_name( the_thread->Object.id, sizeof(name), name ) ); } else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); 1067f4: 57 push %edi <== NOT EXECUTED 1067f5: 6a ff push $0xffffffff <== NOT EXECUTED 1067f7: 68 e6 99 11 00 push $0x1199e6 <== NOT EXECUTED 1067fc: ff 35 f0 0d 12 00 pushl 0x120df0 <== NOT EXECUTED 106802: ff 55 d4 call *-0x2c(%ebp) <== NOT EXECUTED 106805: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } (*print_handler)( 106808: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10680b: 53 push %ebx <== NOT EXECUTED 10680c: 53 push %ebx <== NOT EXECUTED 10680d: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 106810: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 106813: 8b 16 mov (%esi),%edx <== NOT EXECUTED 106815: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED 106819: 52 push %edx <== NOT EXECUTED 10681a: 50 push %eax <== NOT EXECUTED 10681b: 68 f4 99 11 00 push $0x1199f4 <== NOT EXECUTED 106820: ff 35 f0 0d 12 00 pushl 0x120df0 <== NOT EXECUTED 106826: ff 15 f4 0d 12 00 call *0x120df4 <== NOT EXECUTED stack->area + stack->size - 1, current, size ); if (Stack_check_Initialized == 0) { 10682c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10682f: 83 3d ec 0d 12 00 00 cmpl $0x0,0x120dec <== NOT EXECUTED 106836: a1 f4 0d 12 00 mov 0x120df4,%eax <== NOT EXECUTED 10683b: 75 09 jne 106846 <== NOT EXECUTED (*print_handler)( print_context, "Unavailable\n" ); 10683d: 51 push %ecx <== NOT EXECUTED 10683e: 51 push %ecx <== NOT EXECUTED 10683f: 68 12 9a 11 00 push $0x119a12 <== NOT EXECUTED 106844: eb 09 jmp 10684f <== NOT EXECUTED } else { (*print_handler)( print_context, "%8" PRId32 "\n", used ); 106846: 52 push %edx <== NOT EXECUTED 106847: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED 10684a: 68 1f 9a 11 00 push $0x119a1f <== NOT EXECUTED 10684f: ff 35 f0 0d 12 00 pushl 0x120df0 <== NOT EXECUTED 106855: ff d0 call *%eax <== NOT EXECUTED 106857: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 10685a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10685d: 5b pop %ebx <== NOT EXECUTED 10685e: 5e pop %esi <== NOT EXECUTED 10685f: 5f pop %edi <== NOT EXECUTED 106860: c9 leave <== NOT EXECUTED 106861: c3 ret <== NOT EXECUTED =============================================================================== 00106a13 : /* * Stack_check_Initialize */ void Stack_check_Initialize( void ) { 106a13: 55 push %ebp 106a14: 89 e5 mov %esp,%ebp 106a16: 57 push %edi 106a17: 83 ec 04 sub $0x4,%esp uint32_t *p; if (Stack_check_Initialized) 106a1a: 83 3d ec 0d 12 00 00 cmpl $0x0,0x120dec 106a21: 75 59 jne 106a7c for ( p = Stack_check_Pattern.pattern; p < &Stack_check_Pattern.pattern[PATTERN_SIZE_WORDS]; p += 4 ) { p[0] = 0xFEEDF00D; /* FEED FOOD to BAD DOG */ 106a23: c7 05 08 10 12 00 0d movl $0xfeedf00d,0x121008 106a2a: f0 ed fe p[1] = 0x0BAD0D06; 106a2d: c7 05 0c 10 12 00 06 movl $0xbad0d06,0x12100c 106a34: 0d ad 0b p[2] = 0xDEADF00D; /* DEAD FOOD GOOD DOG */ 106a37: c7 05 10 10 12 00 0d movl $0xdeadf00d,0x121010 106a3e: f0 ad de p[3] = 0x600D0D06; 106a41: c7 05 14 10 12 00 06 movl $0x600d0d06,0x121014 106a48: 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) { 106a4b: 8b 3d 94 11 12 00 mov 0x121194,%edi 106a51: 85 ff test %edi,%edi 106a53: 74 1d je 106a72 <== NEVER TAKEN 106a55: a1 54 11 12 00 mov 0x121154,%eax 106a5a: 85 c0 test %eax,%eax 106a5c: 74 14 je 106a72 <== NEVER TAKEN Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low; 106a5e: 89 3d 1c 10 12 00 mov %edi,0x12101c Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high - 106a64: 89 c1 mov %eax,%ecx 106a66: 29 f9 sub %edi,%ecx 106a68: 89 0d 18 10 12 00 mov %ecx,0x121018 (char *) _CPU_Interrupt_stack_low; Stack_check_Dope_stack(&Stack_check_Interrupt_stack); 106a6e: b0 a5 mov $0xa5,%al 106a70: f3 aa rep stos %al,%es:(%edi) } #endif Stack_check_Initialized = 1; 106a72: c7 05 ec 0d 12 00 01 movl $0x1,0x120dec 106a79: 00 00 00 } 106a7c: 58 pop %eax 106a7d: 5f pop %edi 106a7e: c9 leave 106a7f: c3 ret =============================================================================== 0010671f : */ void *Stack_check_find_high_water_mark( const void *s, size_t n ) { 10671f: 55 push %ebp <== NOT EXECUTED 106720: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106722: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED /* * start at lower memory and find first word that does not * match pattern */ base += PATTERN_SIZE_WORDS; 106725: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 106728: 83 c2 10 add $0x10,%edx <== NOT EXECUTED for (ebase = base + length; base < ebase; base++) 10672b: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 10672e: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED 106731: eb 0f jmp 106742 <== NOT EXECUTED if (*base != U32_PATTERN) 106733: 81 3a a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%edx) <== NOT EXECUTED 106739: 74 04 je 10673f <== NOT EXECUTED return (void *) base; 10673b: 89 d0 mov %edx,%eax <== NOT EXECUTED 10673d: eb 09 jmp 106748 <== 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++) 10673f: 83 c2 04 add $0x4,%edx <== NOT EXECUTED 106742: 39 c2 cmp %eax,%edx <== NOT EXECUTED 106744: 72 ed jb 106733 <== NOT EXECUTED 106746: 31 c0 xor %eax,%eax <== NOT EXECUTED if (*base != U32_PATTERN) return (void *) base; #endif return (void *)0; } 106748: c9 leave <== NOT EXECUTED 106749: c3 ret <== NOT EXECUTED =============================================================================== 001068da : */ void Stack_check_report_blown_task( Thread_Control *running, bool pattern_ok ) { 1068da: 55 push %ebp 1068db: 89 e5 mov %esp,%ebp 1068dd: 56 push %esi 1068de: 53 push %ebx 1068df: 8b 75 08 mov 0x8(%ebp),%esi 1068e2: 8a 5d 0c mov 0xc(%ebp),%bl Stack_Control *stack = &running->Start.Initial_stack; printk( 1068e5: ff 76 0c pushl 0xc(%esi) 1068e8: ff 76 08 pushl 0x8(%esi) 1068eb: 56 push %esi 1068ec: 68 86 9a 11 00 push $0x119a86 1068f1: e8 c0 12 00 00 call 107bb6 rtems_configuration_get_user_multiprocessing_table()->node ); } #endif printk( 1068f6: 8b 96 c8 00 00 00 mov 0xc8(%esi),%edx 1068fc: 8b 86 c4 00 00 00 mov 0xc4(%esi),%eax 106902: 50 push %eax 106903: 8d 44 02 ff lea -0x1(%edx,%eax,1),%eax 106907: 50 push %eax 106908: 52 push %edx 106909: 68 c4 9a 11 00 push $0x119ac4 10690e: e8 a3 12 00 00 call 107bb6 stack->area, stack->area + stack->size - 1, stack->size ); if ( !pattern_ok ) { 106913: 83 c4 20 add $0x20,%esp 106916: 84 db test %bl,%bl 106918: 75 1a jne 106934 <== NEVER TAKEN printk( 10691a: 53 push %ebx 10691b: 6a 10 push $0x10 10691d: 8b 86 c8 00 00 00 mov 0xc8(%esi),%eax 106923: 83 c0 08 add $0x8,%eax 106926: 50 push %eax 106927: 68 f2 9a 11 00 push $0x119af2 10692c: e8 85 12 00 00 call 107bb6 106931: 83 c4 10 add $0x10,%esp " Damaged pattern begins at 0x%08lx and is %d bytes long\n", (unsigned long) Stack_check_Get_pattern_area(stack), PATTERN_SIZE_BYTES); } rtems_fatal_error_occurred( 0x81 ); 106934: 83 ec 0c sub $0xc,%esp 106937: 68 81 00 00 00 push $0x81 10693c: e8 4b 3b 00 00 call 10a48c =============================================================================== 001099a9 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 1099a9: 55 push %ebp 1099aa: 89 e5 mov %esp,%ebp 1099ac: 53 push %ebx 1099ad: 83 ec 04 sub $0x4,%esp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 1099b0: 8b 1d bc d9 11 00 mov 0x11d9bc,%ebx 1099b6: eb 0b jmp 1099c3 <_API_extensions_Run_postdriver+0x1a> !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) 1099b8: 8b 43 0c mov 0xc(%ebx),%eax 1099bb: 85 c0 test %eax,%eax 1099bd: 74 02 je 1099c1 <_API_extensions_Run_postdriver+0x18><== NEVER TAKEN (*the_extension->postdriver_hook)(); 1099bf: ff d0 call *%eax Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 1099c1: 8b 1b mov (%ebx),%ebx { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 1099c3: 81 fb c0 d9 11 00 cmp $0x11d9c0,%ebx 1099c9: 75 ed jne 1099b8 <_API_extensions_Run_postdriver+0xf> the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) (*the_extension->postdriver_hook)(); } } 1099cb: 5a pop %edx 1099cc: 5b pop %ebx 1099cd: c9 leave 1099ce: c3 ret =============================================================================== 001099cf <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 1099cf: 55 push %ebp 1099d0: 89 e5 mov %esp,%ebp 1099d2: 53 push %ebx 1099d3: 83 ec 04 sub $0x4,%esp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 1099d6: 8b 1d bc d9 11 00 mov 0x11d9bc,%ebx 1099dc: eb 17 jmp 1099f5 <_API_extensions_Run_postswitch+0x26> !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) 1099de: 8b 43 10 mov 0x10(%ebx),%eax 1099e1: 85 c0 test %eax,%eax 1099e3: 74 0e je 1099f3 <_API_extensions_Run_postswitch+0x24><== NEVER TAKEN (*the_extension->postswitch_hook)( _Thread_Executing ); 1099e5: 83 ec 0c sub $0xc,%esp 1099e8: ff 35 58 d8 11 00 pushl 0x11d858 1099ee: ff d0 call *%eax 1099f0: 83 c4 10 add $0x10,%esp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 1099f3: 8b 1b mov (%ebx),%ebx { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 1099f5: 81 fb c0 d9 11 00 cmp $0x11d9c0,%ebx 1099fb: 75 e1 jne 1099de <_API_extensions_Run_postswitch+0xf> the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) (*the_extension->postswitch_hook)( _Thread_Executing ); } } 1099fd: 8b 5d fc mov -0x4(%ebp),%ebx 109a00: c9 leave 109a01: c3 ret =============================================================================== 00109983 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 109983: 55 push %ebp 109984: 89 e5 mov %esp,%ebp 109986: 53 push %ebx 109987: 83 ec 04 sub $0x4,%esp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10998a: 8b 1d bc d9 11 00 mov 0x11d9bc,%ebx 109990: eb 0b jmp 10999d <_API_extensions_Run_predriver+0x1a> !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) 109992: 8b 43 08 mov 0x8(%ebx),%eax 109995: 85 c0 test %eax,%eax 109997: 74 02 je 10999b <_API_extensions_Run_predriver+0x18><== ALWAYS TAKEN (*the_extension->predriver_hook)(); 109999: ff d0 call *%eax <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; the_node = the_node->next ) { 10999b: 8b 1b mov (%ebx),%ebx { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10999d: 81 fb c0 d9 11 00 cmp $0x11d9c0,%ebx 1099a3: 75 ed jne 109992 <_API_extensions_Run_predriver+0xf> the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) (*the_extension->predriver_hook)(); } } 1099a5: 58 pop %eax 1099a6: 5b pop %ebx 1099a7: c9 leave 1099a8: c3 ret =============================================================================== 0010b720 <_CORE_RWLock_Obtain_for_reading>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_RWLock_API_mp_support_callout api_rwlock_mp_support ) { 10b720: 55 push %ebp 10b721: 89 e5 mov %esp,%ebp 10b723: 57 push %edi 10b724: 56 push %esi 10b725: 53 push %ebx 10b726: 83 ec 0c sub $0xc,%esp 10b729: 8b 5d 08 mov 0x8(%ebp),%ebx 10b72c: 8b 45 0c mov 0xc(%ebp),%eax 10b72f: 89 45 f0 mov %eax,-0x10(%ebp) 10b732: 8b 45 14 mov 0x14(%ebp),%eax 10b735: 89 45 e8 mov %eax,-0x18(%ebp) 10b738: 8a 45 10 mov 0x10(%ebp),%al 10b73b: 88 45 ef mov %al,-0x11(%ebp) ISR_Level level; Thread_Control *executing = _Thread_Executing; 10b73e: 8b 35 90 fc 11 00 mov 0x11fc90,%esi * If unlocked, then OK to read. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 10b744: 9c pushf 10b745: fa cli 10b746: 5f pop %edi switch ( the_rwlock->current_state ) { 10b747: 8b 43 44 mov 0x44(%ebx),%eax 10b74a: 85 c0 test %eax,%eax 10b74c: 74 05 je 10b753 <_CORE_RWLock_Obtain_for_reading+0x33> 10b74e: 48 dec %eax 10b74f: 75 2e jne 10b77f <_CORE_RWLock_Obtain_for_reading+0x5f> 10b751: eb 0e jmp 10b761 <_CORE_RWLock_Obtain_for_reading+0x41> case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10b753: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) the_rwlock->number_of_readers += 1; 10b75a: ff 43 48 incl 0x48(%ebx) _ISR_Enable( level ); 10b75d: 57 push %edi 10b75e: 9d popf 10b75f: eb 15 jmp 10b776 <_CORE_RWLock_Obtain_for_reading+0x56> executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; return; case CORE_RWLOCK_LOCKED_FOR_READING: { Thread_Control *waiter; waiter = _Thread_queue_First( &the_rwlock->Wait_queue ); 10b761: 83 ec 0c sub $0xc,%esp 10b764: 53 push %ebx 10b765: e8 2e 19 00 00 call 10d098 <_Thread_queue_First> if ( !waiter ) { 10b76a: 83 c4 10 add $0x10,%esp 10b76d: 85 c0 test %eax,%eax 10b76f: 75 0e jne 10b77f <_CORE_RWLock_Obtain_for_reading+0x5f><== NEVER TAKEN the_rwlock->number_of_readers += 1; 10b771: ff 43 48 incl 0x48(%ebx) _ISR_Enable( level ); 10b774: 57 push %edi 10b775: 9d popf executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10b776: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) 10b77d: eb 4d jmp 10b7cc <_CORE_RWLock_Obtain_for_reading+0xac> /* * If the thread is not willing to wait, then return immediately. */ if ( !wait ) { 10b77f: 80 7d ef 00 cmpb $0x0,-0x11(%ebp) 10b783: 75 0b jne 10b790 <_CORE_RWLock_Obtain_for_reading+0x70> _ISR_Enable( level ); 10b785: 57 push %edi 10b786: 9d popf executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10b787: c7 46 34 02 00 00 00 movl $0x2,0x34(%esi) 10b78e: eb 3c jmp 10b7cc <_CORE_RWLock_Obtain_for_reading+0xac> { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10b790: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) /* * We need to wait to enter this critical section */ _Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue ); executing->Wait.queue = &the_rwlock->Wait_queue; 10b797: 89 5e 44 mov %ebx,0x44(%esi) executing->Wait.id = id; 10b79a: 8b 45 f0 mov -0x10(%ebp),%eax 10b79d: 89 46 20 mov %eax,0x20(%esi) executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ; 10b7a0: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi) executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10b7a7: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) _ISR_Enable( level ); 10b7ae: 57 push %edi 10b7af: 9d popf _Thread_queue_Enqueue_with_handler( 10b7b0: c7 45 10 f0 b8 10 00 movl $0x10b8f0,0x10(%ebp) 10b7b7: 8b 45 e8 mov -0x18(%ebp),%eax 10b7ba: 89 45 0c mov %eax,0xc(%ebp) 10b7bd: 89 5d 08 mov %ebx,0x8(%ebp) timeout, _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10b7c0: 8d 65 f4 lea -0xc(%ebp),%esp 10b7c3: 5b pop %ebx 10b7c4: 5e pop %esi 10b7c5: 5f pop %edi 10b7c6: c9 leave executing->Wait.id = id; executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ; executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; _ISR_Enable( level ); _Thread_queue_Enqueue_with_handler( 10b7c7: e9 d0 15 00 00 jmp 10cd9c <_Thread_queue_Enqueue_with_handler> timeout, _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10b7cc: 8d 65 f4 lea -0xc(%ebp),%esp 10b7cf: 5b pop %ebx 10b7d0: 5e pop %esi 10b7d1: 5f pop %edi 10b7d2: c9 leave 10b7d3: c3 ret =============================================================================== 0010b850 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 10b850: 55 push %ebp 10b851: 89 e5 mov %esp,%ebp 10b853: 53 push %ebx 10b854: 83 ec 04 sub $0x4,%esp 10b857: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; Thread_Control *executing = _Thread_Executing; 10b85a: 8b 0d 90 fc 11 00 mov 0x11fc90,%ecx * 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 ); 10b860: 9c pushf 10b861: fa cli 10b862: 5a pop %edx if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 10b863: 8b 43 44 mov 0x44(%ebx),%eax 10b866: 85 c0 test %eax,%eax 10b868: 75 0b jne 10b875 <_CORE_RWLock_Release+0x25><== ALWAYS TAKEN _ISR_Enable( level ); 10b86a: 52 push %edx <== NOT EXECUTED 10b86b: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10b86c: c7 41 34 02 00 00 00 movl $0x2,0x34(%ecx) <== NOT EXECUTED 10b873: eb 72 jmp 10b8e7 <_CORE_RWLock_Release+0x97><== NOT EXECUTED return CORE_RWLOCK_SUCCESSFUL; } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { 10b875: 48 dec %eax 10b876: 75 0f jne 10b887 <_CORE_RWLock_Release+0x37> the_rwlock->number_of_readers -= 1; 10b878: 8b 43 48 mov 0x48(%ebx),%eax 10b87b: 48 dec %eax 10b87c: 89 43 48 mov %eax,0x48(%ebx) if ( the_rwlock->number_of_readers != 0 ) { 10b87f: 85 c0 test %eax,%eax 10b881: 74 04 je 10b887 <_CORE_RWLock_Release+0x37> /* must be unlocked again */ _ISR_Enable( level ); 10b883: 52 push %edx 10b884: 9d popf 10b885: eb 60 jmp 10b8e7 <_CORE_RWLock_Release+0x97> return CORE_RWLOCK_SUCCESSFUL; } } /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */ executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10b887: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) /* * Implicitly transition to "unlocked" and find another thread interested * in obtaining this rwlock. */ the_rwlock->current_state = CORE_RWLOCK_UNLOCKED; 10b88e: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) _ISR_Enable( level ); 10b895: 52 push %edx 10b896: 9d popf next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 10b897: 83 ec 0c sub $0xc,%esp 10b89a: 53 push %ebx 10b89b: e8 e4 13 00 00 call 10cc84 <_Thread_queue_Dequeue> if ( next ) { 10b8a0: 83 c4 10 add $0x10,%esp 10b8a3: 85 c0 test %eax,%eax 10b8a5: 74 40 je 10b8e7 <_CORE_RWLock_Release+0x97> if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 10b8a7: 83 78 30 01 cmpl $0x1,0x30(%eax) 10b8ab: 75 09 jne 10b8b6 <_CORE_RWLock_Release+0x66> the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10b8ad: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx) 10b8b4: eb 31 jmp 10b8e7 <_CORE_RWLock_Release+0x97> } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 10b8b6: ff 43 48 incl 0x48(%ebx) the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10b8b9: 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 ); 10b8c0: 83 ec 0c sub $0xc,%esp 10b8c3: 53 push %ebx 10b8c4: e8 cf 17 00 00 call 10d098 <_Thread_queue_First> if ( !next || 10b8c9: 83 c4 10 add $0x10,%esp 10b8cc: 85 c0 test %eax,%eax 10b8ce: 74 17 je 10b8e7 <_CORE_RWLock_Release+0x97> 10b8d0: 83 78 30 01 cmpl $0x1,0x30(%eax) 10b8d4: 74 11 je 10b8e7 <_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; 10b8d6: ff 43 48 incl 0x48(%ebx) _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 10b8d9: 52 push %edx 10b8da: 52 push %edx 10b8db: 50 push %eax 10b8dc: 53 push %ebx 10b8dd: e8 9e 16 00 00 call 10cf80 <_Thread_queue_Extract> 10b8e2: 83 c4 10 add $0x10,%esp 10b8e5: eb d9 jmp 10b8c0 <_CORE_RWLock_Release+0x70> } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10b8e7: 31 c0 xor %eax,%eax 10b8e9: 8b 5d fc mov -0x4(%ebp),%ebx 10b8ec: c9 leave 10b8ed: c3 ret =============================================================================== 0010b8f0 <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 10b8f0: 55 push %ebp 10b8f1: 89 e5 mov %esp,%ebp 10b8f3: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10b8f6: 8d 45 fc lea -0x4(%ebp),%eax 10b8f9: 50 push %eax 10b8fa: ff 75 08 pushl 0x8(%ebp) 10b8fd: e8 6a 10 00 00 call 10c96c <_Thread_Get> switch ( location ) { 10b902: 83 c4 10 add $0x10,%esp 10b905: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) 10b909: 75 17 jne 10b922 <_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 ); 10b90b: 83 ec 0c sub $0xc,%esp 10b90e: 50 push %eax 10b90f: e8 74 18 00 00 call 10d188 <_Thread_queue_Process_timeout> 10b914: a1 d0 fb 11 00 mov 0x11fbd0,%eax 10b919: 48 dec %eax 10b91a: a3 d0 fb 11 00 mov %eax,0x11fbd0 10b91f: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10b922: c9 leave 10b923: c3 ret =============================================================================== 0010aa34 <_CORE_barrier_Wait>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 10aa34: 55 push %ebp 10aa35: 89 e5 mov %esp,%ebp 10aa37: 57 push %edi 10aa38: 56 push %esi 10aa39: 53 push %ebx 10aa3a: 83 ec 04 sub $0x4,%esp 10aa3d: 8b 55 08 mov 0x8(%ebp),%edx 10aa40: 8b 75 0c mov 0xc(%ebp),%esi 10aa43: 8b 45 14 mov 0x14(%ebp),%eax 10aa46: 89 45 f0 mov %eax,-0x10(%ebp) 10aa49: 8b 7d 18 mov 0x18(%ebp),%edi Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 10aa4c: 8b 0d 50 ed 11 00 mov 0x11ed50,%ecx executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; 10aa52: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) _ISR_Disable( level ); 10aa59: 9c pushf 10aa5a: fa cli 10aa5b: 5b pop %ebx the_barrier->number_of_waiting_threads++; 10aa5c: 8b 42 48 mov 0x48(%edx),%eax 10aa5f: 40 inc %eax 10aa60: 89 42 48 mov %eax,0x48(%edx) if ( the_barrier->number_of_waiting_threads == 10aa63: 3b 42 44 cmp 0x44(%edx),%eax 10aa66: 75 22 jne 10aa8a <_CORE_barrier_Wait+0x56> the_barrier->Attributes.maximum_count) { if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { 10aa68: 83 7a 40 00 cmpl $0x0,0x40(%edx) 10aa6c: 75 1c jne 10aa8a <_CORE_barrier_Wait+0x56><== NEVER TAKEN executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED; 10aa6e: c7 41 34 01 00 00 00 movl $0x1,0x34(%ecx) _ISR_Enable( level ); 10aa75: 53 push %ebx 10aa76: 9d popf _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support ); 10aa77: 89 7d 10 mov %edi,0x10(%ebp) 10aa7a: 89 75 0c mov %esi,0xc(%ebp) 10aa7d: 89 55 08 mov %edx,0x8(%ebp) executing->Wait.queue = &the_barrier->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); } 10aa80: 5a pop %edx 10aa81: 5b pop %ebx 10aa82: 5e pop %esi 10aa83: 5f pop %edi 10aa84: c9 leave if ( the_barrier->number_of_waiting_threads == the_barrier->Attributes.maximum_count) { if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED; _ISR_Enable( level ); _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support ); 10aa85: e9 c6 42 00 00 jmp 10ed50 <_CORE_barrier_Release> { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10aa8a: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx) return; } } _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue ); executing->Wait.queue = &the_barrier->Wait_queue; 10aa91: 89 51 44 mov %edx,0x44(%ecx) executing->Wait.id = id; 10aa94: 89 71 20 mov %esi,0x20(%ecx) _ISR_Enable( level ); 10aa97: 53 push %ebx 10aa98: 9d popf _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); 10aa99: c7 45 10 5c c5 10 00 movl $0x10c55c,0x10(%ebp) 10aaa0: 8b 45 f0 mov -0x10(%ebp),%eax 10aaa3: 89 45 0c mov %eax,0xc(%ebp) 10aaa6: 89 55 08 mov %edx,0x8(%ebp) } 10aaa9: 58 pop %eax 10aaaa: 5b pop %ebx 10aaab: 5e pop %esi 10aaac: 5f pop %edi 10aaad: c9 leave _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue ); executing->Wait.queue = &the_barrier->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); 10aaae: e9 a5 17 00 00 jmp 10c258 <_Thread_queue_Enqueue_with_handler> =============================================================================== 00113b08 <_CORE_message_queue_Broadcast>: size_t size, Objects_Id id, CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, uint32_t *count ) { 113b08: 55 push %ebp 113b09: 89 e5 mov %esp,%ebp 113b0b: 57 push %edi 113b0c: 56 push %esi 113b0d: 53 push %ebx 113b0e: 83 ec 0c sub $0xc,%esp Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 113b11: b8 01 00 00 00 mov $0x1,%eax 113b16: 8b 4d 10 mov 0x10(%ebp),%ecx 113b19: 8b 55 08 mov 0x8(%ebp),%edx 113b1c: 3b 4a 4c cmp 0x4c(%edx),%ecx 113b1f: 77 43 ja 113b64 <_CORE_message_queue_Broadcast+0x5c><== NEVER TAKEN * There must be no pending messages if there is a thread waiting to * receive a message. */ number_broadcasted = 0; while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) { 113b21: 31 db xor %ebx,%ebx * 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 ) { 113b23: 8b 75 08 mov 0x8(%ebp),%esi 113b26: 83 7e 48 00 cmpl $0x0,0x48(%esi) 113b2a: 74 21 je 113b4d <_CORE_message_queue_Broadcast+0x45><== ALWAYS TAKEN *count = 0; 113b2c: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 113b2f: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 113b35: 31 c0 xor %eax,%eax <== NOT EXECUTED 113b37: eb 2b jmp 113b64 <_CORE_message_queue_Broadcast+0x5c><== NOT EXECUTED */ number_broadcasted = 0; while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) { waitp = &the_thread->Wait; number_broadcasted += 1; 113b39: 43 inc %ebx * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 113b3a: 8b 78 2c mov 0x2c(%eax),%edi 113b3d: 8b 75 0c mov 0xc(%ebp),%esi 113b40: 8b 4d 10 mov 0x10(%ebp),%ecx 113b43: f3 a4 rep movsb %ds:(%esi),%es:(%edi) buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 113b45: 8b 40 28 mov 0x28(%eax),%eax 113b48: 8b 55 10 mov 0x10(%ebp),%edx 113b4b: 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 = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) { 113b4d: 83 ec 0c sub $0xc,%esp 113b50: ff 75 08 pushl 0x8(%ebp) 113b53: e8 98 1f 00 00 call 115af0 <_Thread_queue_Dequeue> 113b58: 83 c4 10 add $0x10,%esp 113b5b: 85 c0 test %eax,%eax 113b5d: 75 da jne 113b39 <_CORE_message_queue_Broadcast+0x31> if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif } *count = number_broadcasted; 113b5f: 8b 4d 1c mov 0x1c(%ebp),%ecx 113b62: 89 19 mov %ebx,(%ecx) return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 113b64: 8d 65 f4 lea -0xc(%ebp),%esp 113b67: 5b pop %ebx 113b68: 5e pop %esi 113b69: 5f pop %edi 113b6a: c9 leave 113b6b: c3 ret =============================================================================== 00112ec8 <_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 ) { 112ec8: 55 push %ebp 112ec9: 89 e5 mov %esp,%ebp 112ecb: 57 push %edi 112ecc: 56 push %esi 112ecd: 53 push %ebx 112ece: 83 ec 0c sub $0xc,%esp 112ed1: 8b 5d 08 mov 0x8(%ebp),%ebx 112ed4: 8b 7d 10 mov 0x10(%ebp),%edi 112ed7: 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; 112eda: 89 7b 44 mov %edi,0x44(%ebx) the_message_queue->number_of_pending_messages = 0; 112edd: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) the_message_queue->maximum_message_size = maximum_message_size; 112ee4: 89 53 4c mov %edx,0x4c(%ebx) 112ee7: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) 112eee: 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)) { 112ef5: 89 d0 mov %edx,%eax 112ef7: f6 c2 03 test $0x3,%dl 112efa: 74 0a je 112f06 <_CORE_message_queue_Initialize+0x3e> allocated_message_size += sizeof(uint32_t); 112efc: 8d 42 04 lea 0x4(%edx),%eax allocated_message_size &= ~(sizeof(uint32_t) - 1); 112eff: 83 e0 fc and $0xfffffffc,%eax } if (allocated_message_size < maximum_message_size) 112f02: 39 d0 cmp %edx,%eax 112f04: 72 5f jb 112f65 <_CORE_message_queue_Initialize+0x9d><== 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 * 112f06: 8d 70 14 lea 0x14(%eax),%esi 112f09: 89 f2 mov %esi,%edx 112f0b: 0f af d7 imul %edi,%edx (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 112f0e: 39 c2 cmp %eax,%edx 112f10: 72 53 jb 112f65 <_CORE_message_queue_Initialize+0x9d><== NEVER TAKEN return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 112f12: 83 ec 0c sub $0xc,%esp 112f15: 52 push %edx 112f16: e8 92 de ff ff call 110dad <_Workspace_Allocate> 112f1b: 89 43 5c mov %eax,0x5c(%ebx) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 112f1e: 83 c4 10 add $0x10,%esp 112f21: 85 c0 test %eax,%eax 112f23: 74 40 je 112f65 <_CORE_message_queue_Initialize+0x9d> /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 112f25: 56 push %esi 112f26: 57 push %edi 112f27: 50 push %eax 112f28: 8d 43 68 lea 0x68(%ebx),%eax 112f2b: 50 push %eax 112f2c: e8 93 fe ff ff call 112dc4 <_Chain_Initialize> 112f31: 8d 43 54 lea 0x54(%ebx),%eax 112f34: 89 43 50 mov %eax,0x50(%ebx) 112f37: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) 112f3e: 8d 43 50 lea 0x50(%ebx),%eax 112f41: 89 43 58 mov %eax,0x58(%ebx) allocated_message_size + sizeof( CORE_message_queue_Buffer_control ) ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); _Thread_queue_Initialize( 112f44: 6a 06 push $0x6 112f46: 68 80 00 00 00 push $0x80 112f4b: 8b 45 0c mov 0xc(%ebp),%eax 112f4e: 83 38 01 cmpl $0x1,(%eax) 112f51: 0f 94 c0 sete %al 112f54: 0f b6 c0 movzbl %al,%eax 112f57: 50 push %eax 112f58: 53 push %ebx 112f59: e8 5a d4 ff ff call 1103b8 <_Thread_queue_Initialize> 112f5e: b0 01 mov $0x1,%al 112f60: 83 c4 20 add $0x20,%esp 112f63: eb 02 jmp 112f67 <_CORE_message_queue_Initialize+0x9f> THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 112f65: 31 c0 xor %eax,%eax } 112f67: 8d 65 f4 lea -0xc(%ebp),%esp 112f6a: 5b pop %ebx 112f6b: 5e pop %esi 112f6c: 5f pop %edi 112f6d: c9 leave 112f6e: c3 ret =============================================================================== 0010e7f8 <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 10e7f8: 55 push %ebp 10e7f9: 89 e5 mov %esp,%ebp 10e7fb: 57 push %edi 10e7fc: 56 push %esi 10e7fd: 53 push %ebx 10e7fe: 83 ec 2c sub $0x2c,%esp 10e801: 8b 45 08 mov 0x8(%ebp),%eax 10e804: 89 45 d0 mov %eax,-0x30(%ebp) 10e807: 8b 55 0c mov 0xc(%ebp),%edx 10e80a: 89 55 ec mov %edx,-0x14(%ebp) 10e80d: 8b 7d 10 mov 0x10(%ebp),%edi 10e810: 89 7d e8 mov %edi,-0x18(%ebp) 10e813: 8b 45 14 mov 0x14(%ebp),%eax 10e816: 89 45 e4 mov %eax,-0x1c(%ebp) 10e819: 8b 55 1c mov 0x1c(%ebp),%edx 10e81c: 89 55 dc mov %edx,-0x24(%ebp) 10e81f: 8a 45 18 mov 0x18(%ebp),%al 10e822: 88 45 e3 mov %al,-0x1d(%ebp) ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *executing; Thread_Control *the_thread; executing = _Thread_Executing; 10e825: 8b 35 18 64 12 00 mov 0x126418,%esi executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 10e82b: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) _ISR_Disable( level ); 10e832: 9c pushf 10e833: fa cli 10e834: 59 pop %ecx * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10e835: 8b 55 d0 mov -0x30(%ebp),%edx 10e838: 8b 5a 50 mov 0x50(%edx),%ebx 10e83b: 89 d0 mov %edx,%eax 10e83d: 83 c0 54 add $0x54,%eax 10e840: 39 c3 cmp %eax,%ebx 10e842: 0f 84 9e 00 00 00 je 10e8e6 <_CORE_message_queue_Seize+0xee> 10e848: 8b 13 mov (%ebx),%edx 10e84a: 8b 7d d0 mov -0x30(%ebp),%edi 10e84d: 89 57 50 mov %edx,0x50(%edi) 10e850: 89 f8 mov %edi,%eax 10e852: 83 c0 50 add $0x50,%eax 10e855: 89 42 04 mov %eax,0x4(%edx) the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); if ( the_message != NULL ) { 10e858: 85 db test %ebx,%ebx 10e85a: 0f 84 86 00 00 00 je 10e8e6 <_CORE_message_queue_Seize+0xee><== NEVER TAKEN the_message_queue->number_of_pending_messages -= 1; 10e860: ff 4f 48 decl 0x48(%edi) _ISR_Enable( level ); 10e863: 51 push %ecx 10e864: 9d popf *size_p = the_message->Contents.size; 10e865: 8b 43 0c mov 0xc(%ebx),%eax 10e868: 8b 55 e4 mov -0x1c(%ebp),%edx 10e86b: 89 02 mov %eax,(%edx) _Thread_Executing->Wait.count = the_message->priority; 10e86d: 8b 53 08 mov 0x8(%ebx),%edx 10e870: a1 18 64 12 00 mov 0x126418,%eax 10e875: 89 50 24 mov %edx,0x24(%eax) _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size_p); 10e878: 8d 7b 10 lea 0x10(%ebx),%edi 10e87b: 89 7d f0 mov %edi,-0x10(%ebp) * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 10e87e: 8b 45 e4 mov -0x1c(%ebp),%eax 10e881: 8b 08 mov (%eax),%ecx 10e883: 8b 7d e8 mov -0x18(%ebp),%edi 10e886: 8b 75 f0 mov -0x10(%ebp),%esi 10e889: f3 a4 rep movsb %ds:(%esi),%es:(%edi) * * 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 ); 10e88b: 83 ec 0c sub $0xc,%esp 10e88e: ff 75 d0 pushl -0x30(%ebp) 10e891: e8 d6 17 00 00 call 11006c <_Thread_queue_Dequeue> 10e896: 89 c2 mov %eax,%edx if ( !the_thread ) { 10e898: 83 c4 10 add $0x10,%esp 10e89b: 85 c0 test %eax,%eax 10e89d: 75 18 jne 10e8b7 <_CORE_message_queue_Seize+0xbf> * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size 10e89f: 89 5d 0c mov %ebx,0xc(%ebp) 10e8a2: 8b 45 d0 mov -0x30(%ebp),%eax 10e8a5: 83 c0 68 add $0x68,%eax 10e8a8: 89 45 08 mov %eax,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 ); } 10e8ab: 8d 65 f4 lea -0xc(%ebp),%esp 10e8ae: 5b pop %ebx 10e8af: 5e pop %esi 10e8b0: 5f pop %edi 10e8b1: c9 leave 10e8b2: e9 71 fe ff ff jmp 10e728 <_Chain_Append> * There was a thread waiting to send a message. This code * puts the messages in the message queue on behalf of the * waiting task. */ the_message->priority = the_thread->Wait.count; 10e8b7: 8b 40 24 mov 0x24(%eax),%eax 10e8ba: 89 43 08 mov %eax,0x8(%ebx) the_message->Contents.size = (size_t) the_thread->Wait.option; 10e8bd: 8b 4a 30 mov 0x30(%edx),%ecx 10e8c0: 89 4b 0c mov %ecx,0xc(%ebx) * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 10e8c3: 8b 72 2c mov 0x2c(%edx),%esi 10e8c6: 8b 7d f0 mov -0x10(%ebp),%edi 10e8c9: 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( 10e8cb: 8b 43 08 mov 0x8(%ebx),%eax 10e8ce: 89 45 10 mov %eax,0x10(%ebp) 10e8d1: 89 5d 0c mov %ebx,0xc(%ebp) 10e8d4: 8b 45 d0 mov -0x30(%ebp),%eax 10e8d7: 89 45 08 mov %eax,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 ); } 10e8da: 8d 65 f4 lea -0xc(%ebp),%esp 10e8dd: 5b pop %ebx 10e8de: 5e pop %esi 10e8df: 5f pop %edi 10e8e0: c9 leave the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 10e8e1: e9 16 45 00 00 jmp 112dfc <_CORE_message_queue_Insert_message> the_message->priority ); return; } if ( !wait ) { 10e8e6: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 10e8ea: 75 11 jne 10e8fd <_CORE_message_queue_Seize+0x105> _ISR_Enable( level ); 10e8ec: 51 push %ecx 10e8ed: 9d popf executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 10e8ee: c7 46 34 04 00 00 00 movl $0x4,0x34(%esi) 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 ); } 10e8f5: 8d 65 f4 lea -0xc(%ebp),%esp 10e8f8: 5b pop %ebx 10e8f9: 5e pop %esi 10e8fa: 5f pop %edi 10e8fb: c9 leave 10e8fc: c3 ret { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10e8fd: 8b 55 d0 mov -0x30(%ebp),%edx 10e900: 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; 10e907: 89 56 44 mov %edx,0x44(%esi) executing->Wait.id = id; 10e90a: 8b 7d ec mov -0x14(%ebp),%edi 10e90d: 89 7e 20 mov %edi,0x20(%esi) executing->Wait.return_argument_second.mutable_object = buffer; 10e910: 8b 45 e8 mov -0x18(%ebp),%eax 10e913: 89 46 2c mov %eax,0x2c(%esi) executing->Wait.return_argument = size_p; 10e916: 8b 55 e4 mov -0x1c(%ebp),%edx 10e919: 89 56 28 mov %edx,0x28(%esi) /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 10e91c: 51 push %ecx 10e91d: 9d popf _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 10e91e: c7 45 10 88 04 11 00 movl $0x110488,0x10(%ebp) 10e925: 8b 7d dc mov -0x24(%ebp),%edi 10e928: 89 7d 0c mov %edi,0xc(%ebp) 10e92b: 8b 45 d0 mov -0x30(%ebp),%eax 10e92e: 89 45 08 mov %eax,0x8(%ebp) } 10e931: 8d 65 f4 lea -0xc(%ebp),%esp 10e934: 5b pop %ebx 10e935: 5e pop %esi 10e936: 5f pop %edi 10e937: 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 ); 10e938: e9 47 18 00 00 jmp 110184 <_Thread_queue_Enqueue_with_handler> =============================================================================== 00109b38 <_CORE_message_queue_Submit>: CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, CORE_message_queue_Submit_types submit_type, bool wait, Watchdog_Interval timeout ) { 109b38: 55 push %ebp 109b39: 89 e5 mov %esp,%ebp 109b3b: 57 push %edi 109b3c: 56 push %esi 109b3d: 53 push %ebx 109b3e: 83 ec 1c sub $0x1c,%esp 109b41: 8b 5d 10 mov 0x10(%ebp),%ebx 109b44: 8a 45 20 mov 0x20(%ebp),%al 109b47: 88 45 f3 mov %al,-0xd(%ebp) ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 109b4a: b8 01 00 00 00 mov $0x1,%eax 109b4f: 8b 55 08 mov 0x8(%ebp),%edx 109b52: 3b 5a 4c cmp 0x4c(%edx),%ebx 109b55: 0f 87 d9 00 00 00 ja 109c34 <_CORE_message_queue_Submit+0xfc> /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { 109b5b: 8b 75 08 mov 0x8(%ebp),%esi 109b5e: 83 7e 48 00 cmpl $0x0,0x48(%esi) 109b62: 75 2e jne 109b92 <_CORE_message_queue_Submit+0x5a> the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 109b64: 83 ec 0c sub $0xc,%esp 109b67: 56 push %esi 109b68: e8 57 16 00 00 call 10b1c4 <_Thread_queue_Dequeue> 109b6d: 89 c2 mov %eax,%edx if ( the_thread ) { 109b6f: 83 c4 10 add $0x10,%esp 109b72: 85 c0 test %eax,%eax 109b74: 74 1c je 109b92 <_CORE_message_queue_Submit+0x5a> * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 109b76: 8b 78 2c mov 0x2c(%eax),%edi 109b79: 8b 75 0c mov 0xc(%ebp),%esi 109b7c: 89 d9 mov %ebx,%ecx 109b7e: f3 a4 rep movsb %ds:(%esi),%es:(%edi) _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 109b80: 8b 40 28 mov 0x28(%eax),%eax 109b83: 89 18 mov %ebx,(%eax) the_thread->Wait.count = submit_type; 109b85: 8b 45 1c mov 0x1c(%ebp),%eax 109b88: 89 42 24 mov %eax,0x24(%edx) 109b8b: 31 c0 xor %eax,%eax 109b8d: e9 a2 00 00 00 jmp 109c34 <_CORE_message_queue_Submit+0xfc> /* * No one waiting on the message queue at this time, so attempt to * queue the message up for a future receive. */ if ( the_message_queue->number_of_pending_messages < 109b92: 8b 55 08 mov 0x8(%ebp),%edx 109b95: 8b 42 48 mov 0x48(%edx),%eax 109b98: 3b 42 44 cmp 0x44(%edx),%eax 109b9b: 73 37 jae 109bd4 <_CORE_message_queue_Submit+0x9c> ); /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. 109b9d: 83 ec 0c sub $0xc,%esp 109ba0: 89 d0 mov %edx,%eax 109ba2: 83 c0 68 add $0x68,%eax 109ba5: 50 push %eax 109ba6: e8 65 ff ff ff call 109b10 <_Chain_Get> /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 109bab: 83 c4 10 add $0x10,%esp 109bae: 85 c0 test %eax,%eax 109bb0: 74 7d je 109c2f <_CORE_message_queue_Submit+0xf7><== NEVER TAKEN * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 109bb2: 8d 78 10 lea 0x10(%eax),%edi 109bb5: 8b 75 0c mov 0xc(%ebp),%esi 109bb8: 89 d9 mov %ebx,%ecx 109bba: f3 a4 rep movsb %ds:(%esi),%es:(%edi) _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size ); the_message->Contents.size = size; 109bbc: 89 58 0c mov %ebx,0xc(%eax) the_message->priority = submit_type; 109bbf: 8b 55 1c mov 0x1c(%ebp),%edx 109bc2: 89 50 08 mov %edx,0x8(%eax) _CORE_message_queue_Insert_message( 109bc5: 51 push %ecx 109bc6: 52 push %edx 109bc7: 50 push %eax 109bc8: ff 75 08 pushl 0x8(%ebp) 109bcb: e8 c4 41 00 00 call 10dd94 <_CORE_message_queue_Insert_message> 109bd0: 31 c0 xor %eax,%eax 109bd2: eb 56 jmp 109c2a <_CORE_message_queue_Submit+0xf2> * No message buffers were available so we may need to return an * overflow error or block the sender until the message is placed * on the queue. */ if ( !wait ) { 109bd4: b8 02 00 00 00 mov $0x2,%eax 109bd9: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) 109bdd: 74 55 je 109c34 <_CORE_message_queue_Submit+0xfc> /* * Do NOT block on a send if the caller is in an ISR. It is * deadly to block in an ISR. */ if ( _ISR_Is_in_progress() ) { 109bdf: a1 34 d8 11 00 mov 0x11d834,%eax 109be4: 85 c0 test %eax,%eax 109be6: 75 47 jne 109c2f <_CORE_message_queue_Submit+0xf7><== NEVER TAKEN * it as a variable. Doing this emphasizes how dangerous it * would be to use this variable prior to here. */ { Thread_Control *executing = _Thread_Executing; 109be8: a1 58 d8 11 00 mov 0x11d858,%eax _ISR_Disable( level ); 109bed: 9c pushf 109bee: fa cli 109bef: 59 pop %ecx { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 109bf0: 8b 75 08 mov 0x8(%ebp),%esi 109bf3: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; 109bfa: 89 70 44 mov %esi,0x44(%eax) executing->Wait.id = id; 109bfd: 8b 55 14 mov 0x14(%ebp),%edx 109c00: 89 50 20 mov %edx,0x20(%eax) executing->Wait.return_argument_second.immutable_object = buffer; 109c03: 8b 55 0c mov 0xc(%ebp),%edx 109c06: 89 50 2c mov %edx,0x2c(%eax) executing->Wait.option = (uint32_t) size; 109c09: 89 58 30 mov %ebx,0x30(%eax) executing->Wait.count = submit_type; 109c0c: 8b 75 1c mov 0x1c(%ebp),%esi 109c0f: 89 70 24 mov %esi,0x24(%eax) _ISR_Enable( level ); 109c12: 51 push %ecx 109c13: 9d popf _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 109c14: 50 push %eax 109c15: 68 e0 b5 10 00 push $0x10b5e0 109c1a: ff 75 24 pushl 0x24(%ebp) 109c1d: ff 75 08 pushl 0x8(%ebp) 109c20: e8 b7 16 00 00 call 10b2dc <_Thread_queue_Enqueue_with_handler> 109c25: b8 07 00 00 00 mov $0x7,%eax 109c2a: 83 c4 10 add $0x10,%esp 109c2d: eb 05 jmp 109c34 <_CORE_message_queue_Submit+0xfc> } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; 109c2f: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } 109c34: 8d 65 f4 lea -0xc(%ebp),%esp 109c37: 5b pop %ebx 109c38: 5e pop %esi 109c39: 5f pop %edi 109c3a: c9 leave 109c3b: c3 ret =============================================================================== 00109c48 <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 109c48: 55 push %ebp 109c49: 89 e5 mov %esp,%ebp 109c4b: 57 push %edi 109c4c: 56 push %esi 109c4d: 53 push %ebx 109c4e: 83 ec 0c sub $0xc,%esp 109c51: 8b 5d 08 mov 0x8(%ebp),%ebx 109c54: 8b 45 10 mov 0x10(%ebp),%eax /* Add this to the RTEMS environment later ????????? rtems_assert( initial_lock == CORE_MUTEX_LOCKED || initial_lock == CORE_MUTEX_UNLOCKED ); */ the_mutex->Attributes = *the_mutex_attributes; 109c57: 8d 7b 40 lea 0x40(%ebx),%edi 109c5a: b9 04 00 00 00 mov $0x4,%ecx 109c5f: 8b 75 0c mov 0xc(%ebp),%esi 109c62: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_mutex->lock = initial_lock; 109c64: 89 43 50 mov %eax,0x50(%ebx) the_mutex->blocked_count = 0; 109c67: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) if ( initial_lock == CORE_MUTEX_LOCKED ) { 109c6e: 85 c0 test %eax,%eax 109c70: 75 35 jne 109ca7 <_CORE_mutex_Initialize+0x5f> the_mutex->nest_count = 1; 109c72: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx) the_mutex->holder = _Thread_Executing; 109c79: 8b 15 58 d8 11 00 mov 0x11d858,%edx 109c7f: 89 53 5c mov %edx,0x5c(%ebx) the_mutex->holder_id = _Thread_Executing->Object.id; 109c82: 8b 42 08 mov 0x8(%edx),%eax 109c85: 89 43 60 mov %eax,0x60(%ebx) /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. * Any other value of @a alignment is taken "as is", i.e., even odd 109c88: 8b 43 48 mov 0x48(%ebx),%eax if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 109c8b: 83 f8 02 cmp $0x2,%eax 109c8e: 74 05 je 109c95 <_CORE_mutex_Initialize+0x4d> 109c90: 83 f8 03 cmp $0x3,%eax 109c93: 75 27 jne 109cbc <_CORE_mutex_Initialize+0x74><== ALWAYS TAKEN _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 109c95: 8b 42 14 mov 0x14(%edx),%eax 109c98: b9 06 00 00 00 mov $0x6,%ecx 109c9d: 3b 43 4c cmp 0x4c(%ebx),%eax 109ca0: 72 3a jb 109cdc <_CORE_mutex_Initialize+0x94><== NEVER TAKEN _Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = _Thread_Executing->current_priority; #endif _Thread_Executing->resource_count++; 109ca2: ff 42 1c incl 0x1c(%edx) 109ca5: eb 15 jmp 109cbc <_CORE_mutex_Initialize+0x74> } } else { the_mutex->nest_count = 0; 109ca7: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) the_mutex->holder = NULL; 109cae: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) the_mutex->holder_id = 0; 109cb5: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) } _Thread_queue_Initialize( 109cbc: 6a 05 push $0x5 109cbe: 68 00 04 00 00 push $0x400 109cc3: 8b 45 0c mov 0xc(%ebp),%eax 109cc6: 83 78 08 00 cmpl $0x0,0x8(%eax) 109cca: 0f 95 c0 setne %al 109ccd: 0f b6 c0 movzbl %al,%eax 109cd0: 50 push %eax 109cd1: 53 push %ebx 109cd2: e8 39 18 00 00 call 10b510 <_Thread_queue_Initialize> 109cd7: 31 c9 xor %ecx,%ecx 109cd9: 83 c4 10 add $0x10,%esp STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 109cdc: 89 c8 mov %ecx,%eax 109cde: 8d 65 f4 lea -0xc(%ebp),%esp 109ce1: 5b pop %ebx 109ce2: 5e pop %esi 109ce3: 5f pop %edi 109ce4: c9 leave 109ce5: c3 ret =============================================================================== 00109d34 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 109d34: 55 push %ebp 109d35: 89 e5 mov %esp,%ebp 109d37: 56 push %esi 109d38: 53 push %ebx 109d39: 8b 75 08 mov 0x8(%ebp),%esi 109d3c: 8a 5d 10 mov 0x10(%ebp),%bl _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 109d3f: a1 98 d7 11 00 mov 0x11d798,%eax 109d44: 85 c0 test %eax,%eax 109d46: 74 19 je 109d61 <_CORE_mutex_Seize+0x2d> 109d48: 84 db test %bl,%bl 109d4a: 74 15 je 109d61 <_CORE_mutex_Seize+0x2d><== NEVER TAKEN 109d4c: 83 3d 38 d9 11 00 01 cmpl $0x1,0x11d938 109d53: 76 0c jbe 109d61 <_CORE_mutex_Seize+0x2d> 109d55: 50 push %eax 109d56: 6a 13 push $0x13 109d58: 6a 00 push $0x0 109d5a: 6a 00 push $0x0 109d5c: e8 93 04 00 00 call 10a1f4 <_Internal_error_Occurred> 109d61: 50 push %eax 109d62: 50 push %eax 109d63: 8d 45 18 lea 0x18(%ebp),%eax 109d66: 50 push %eax 109d67: 56 push %esi 109d68: e8 f3 40 00 00 call 10de60 <_CORE_mutex_Seize_interrupt_trylock> 109d6d: 83 c4 10 add $0x10,%esp 109d70: 85 c0 test %eax,%eax 109d72: 74 49 je 109dbd <_CORE_mutex_Seize+0x89> 109d74: 84 db test %bl,%bl 109d76: 75 12 jne 109d8a <_CORE_mutex_Seize+0x56> 109d78: ff 75 18 pushl 0x18(%ebp) 109d7b: 9d popf 109d7c: a1 58 d8 11 00 mov 0x11d858,%eax 109d81: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) 109d88: eb 33 jmp 109dbd <_CORE_mutex_Seize+0x89> { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 109d8a: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) 109d91: 8b 15 58 d8 11 00 mov 0x11d858,%edx 109d97: 89 72 44 mov %esi,0x44(%edx) 109d9a: 8b 45 0c mov 0xc(%ebp),%eax 109d9d: 89 42 20 mov %eax,0x20(%edx) /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109da0: a1 98 d7 11 00 mov 0x11d798,%eax 109da5: 40 inc %eax 109da6: a3 98 d7 11 00 mov %eax,0x11d798 109dab: ff 75 18 pushl 0x18(%ebp) 109dae: 9d popf 109daf: 53 push %ebx 109db0: 53 push %ebx 109db1: ff 75 14 pushl 0x14(%ebp) 109db4: 56 push %esi 109db5: e8 2e ff ff ff call 109ce8 <_CORE_mutex_Seize_interrupt_blocking> 109dba: 83 c4 10 add $0x10,%esp } 109dbd: 8d 65 f8 lea -0x8(%ebp),%esp 109dc0: 5b pop %ebx 109dc1: 5e pop %esi 109dc2: c9 leave 109dc3: c3 ret =============================================================================== 0010de60 <_CORE_mutex_Seize_interrupt_trylock>: #if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__) int _CORE_mutex_Seize_interrupt_trylock( CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { 10de60: 55 push %ebp 10de61: 89 e5 mov %esp,%ebp 10de63: 56 push %esi 10de64: 53 push %ebx 10de65: 8b 4d 08 mov 0x8(%ebp),%ecx bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ); 10de68: 8b 45 0c mov 0xc(%ebp),%eax 10de6b: 8b 30 mov (%eax),%esi /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * 10de6d: 8b 15 58 d8 11 00 mov 0x11d858,%edx * @param[in] the_heap is the heap to operate upon 10de73: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) * @param[in] starting_address is the starting address of the user block 10de7a: 83 79 50 00 cmpl $0x0,0x50(%ecx) 10de7e: 0f 84 82 00 00 00 je 10df06 <_CORE_mutex_Seize_interrupt_trylock+0xa6> * to be resized 10de84: c7 41 50 00 00 00 00 movl $0x0,0x50(%ecx) * @param[in] size is the new size 10de8b: 89 51 5c mov %edx,0x5c(%ecx) * 10de8e: 8b 42 08 mov 0x8(%edx),%eax 10de91: 89 41 60 mov %eax,0x60(%ecx) * @return TRUE if successfully able to resize the block. 10de94: c7 41 54 01 00 00 00 movl $0x1,0x54(%ecx) /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. * Any other value of @a alignment is taken "as is", i.e., even odd 10de9b: 8b 41 48 mov 0x48(%ecx),%eax * @param[in] starting_address is the starting address of the user block * to be resized * @param[in] size is the new size * * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. 10de9e: 83 f8 02 cmp $0x2,%eax 10dea1: 74 05 je 10dea8 <_CORE_mutex_Seize_interrupt_trylock+0x48> 10dea3: 83 f8 03 cmp $0x3,%eax 10dea6: 75 03 jne 10deab <_CORE_mutex_Seize_interrupt_trylock+0x4b> void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10dea8: ff 42 1c incl 0x1c(%edx) * at @a starting_address to @a the_heap. Any coalescing which is * possible with the freeing of this routine is performed. * 10deab: 83 79 48 03 cmpl $0x3,0x48(%ecx) 10deaf: 74 04 je 10deb5 <_CORE_mutex_Seize_interrupt_trylock+0x55> * @param[in] the_heap is the heap to operate upon 10deb1: 56 push %esi 10deb2: 9d popf 10deb3: eb 74 jmp 10df29 <_CORE_mutex_Seize_interrupt_trylock+0xc9> void *start_address ); /** * This routine walks the heap to verify its integrity. * 10deb5: 8b 42 14 mov 0x14(%edx),%eax * @param[in] the_heap is the heap to operate upon 10deb8: 3b 41 4c cmp 0x4c(%ecx),%eax 10debb: 75 04 jne 10dec1 <_CORE_mutex_Seize_interrupt_trylock+0x61><== ALWAYS TAKEN * @param[in] source is a user specified integer which may be used to 10debd: 56 push %esi <== NOT EXECUTED 10debe: 9d popf <== NOT EXECUTED 10debf: eb 68 jmp 10df29 <_CORE_mutex_Seize_interrupt_trylock+0xc9><== NOT EXECUTED * indicate where in the application this was invoked from * @param[in] do_dump is set to TRUE if errors should be printed * @return TRUE if the test passed fine, FALSE otherwise. */ 10dec1: 76 27 jbe 10deea <_CORE_mutex_Seize_interrupt_trylock+0x8a> /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10dec3: a1 98 d7 11 00 mov 0x11d798,%eax 10dec8: 40 inc %eax 10dec9: a3 98 d7 11 00 mov %eax,0x11d798 * indicate where in the application this was invoked from * @param[in] do_dump is set to TRUE if errors should be printed * @return TRUE if the test passed fine, FALSE otherwise. */ bool _Protected_heap_Walk( Heap_Control *the_heap, 10dece: 56 push %esi 10decf: 9d popf int source, 10ded0: 50 push %eax 10ded1: 6a 00 push $0x0 10ded3: ff 71 4c pushl 0x4c(%ecx) 10ded6: ff 71 5c pushl 0x5c(%ecx) 10ded9: e8 0e cb ff ff call 10a9ec <_Thread_Change_priority> bool do_dump ); /** * This routine walks the heap and tots up the free and allocated 10dede: e8 a9 cf ff ff call 10ae8c <_Thread_Enable_dispatch> 10dee3: 31 c0 xor %eax,%eax 10dee5: 83 c4 10 add $0x10,%esp 10dee8: eb 48 jmp 10df32 <_CORE_mutex_Seize_interrupt_trylock+0xd2> * sizes. * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area 10deea: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) * 10def1: c7 41 50 01 00 00 00 movl $0x1,0x50(%ecx) * @return true if successfully able to return information 10def8: c7 41 54 00 00 00 00 movl $0x0,0x54(%ecx) */ 10deff: ff 4a 1c decl 0x1c(%edx) bool _Protected_heap_Get_information( 10df02: 56 push %esi 10df03: 9d popf 10df04: eb 23 jmp 10df29 <_CORE_mutex_Seize_interrupt_trylock+0xc9> * in the specified heap. * * @param[in] the_heap pointer to heap header. * @param[in] info pointer to the free block information. * * @return free block information filled in. 10df06: 8b 59 5c mov 0x5c(%ecx),%ebx 10df09: 39 d3 cmp %edx,%ebx 10df0b: 75 20 jne 10df2d <_CORE_mutex_Seize_interrupt_trylock+0xcd> */ 10df0d: 8b 41 40 mov 0x40(%ecx),%eax 10df10: 85 c0 test %eax,%eax 10df12: 74 05 je 10df19 <_CORE_mutex_Seize_interrupt_trylock+0xb9> 10df14: 48 dec %eax 10df15: 75 16 jne 10df2d <_CORE_mutex_Seize_interrupt_trylock+0xcd> 10df17: eb 07 jmp 10df20 <_CORE_mutex_Seize_interrupt_trylock+0xc0> bool _Protected_heap_Get_free_information( Heap_Control *the_heap, 10df19: ff 41 54 incl 0x54(%ecx) Heap_Information *info 10df1c: 56 push %esi 10df1d: 9d popf 10df1e: eb 09 jmp 10df29 <_CORE_mutex_Seize_interrupt_trylock+0xc9> ); #ifdef __cplusplus 10df20: c7 43 34 02 00 00 00 movl $0x2,0x34(%ebx) } 10df27: 56 push %esi 10df28: 9d popf 10df29: 31 c0 xor %eax,%eax 10df2b: eb 05 jmp 10df32 <_CORE_mutex_Seize_interrupt_trylock+0xd2> 10df2d: b8 01 00 00 00 mov $0x1,%eax return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); } 10df32: 8d 65 f8 lea -0x8(%ebp),%esp 10df35: 5b pop %ebx 10df36: 5e pop %esi 10df37: c9 leave 10df38: c3 ret =============================================================================== 00109dc4 <_CORE_mutex_Surrender>: CORE_mutex_Status _CORE_mutex_Surrender( CORE_mutex_Control *the_mutex, Objects_Id id, CORE_mutex_API_mp_support_callout api_mutex_mp_support ) { 109dc4: 55 push %ebp 109dc5: 89 e5 mov %esp,%ebp 109dc7: 53 push %ebx 109dc8: 83 ec 04 sub $0x4,%esp 109dcb: 8b 5d 08 mov 0x8(%ebp),%ebx Thread_Control *the_thread; Thread_Control *holder; #ifdef __RTEMS_STRICT_ORDER_MUTEX__ Chain_Node *first_node; #endif holder = the_mutex->holder; 109dce: 8b 4b 5c mov 0x5c(%ebx),%ecx * allowed when the mutex in quetion is FIFO or simple Priority * discipline. But Priority Ceiling or Priority Inheritance mutexes * must be released by the thread which acquired them. */ if ( the_mutex->Attributes.only_owner_release ) { 109dd1: 80 7b 44 00 cmpb $0x0,0x44(%ebx) 109dd5: 74 11 je 109de8 <_CORE_mutex_Surrender+0x24> if ( !_Thread_Is_executing( holder ) ) 109dd7: b8 03 00 00 00 mov $0x3,%eax 109ddc: 3b 0d 58 d8 11 00 cmp 0x11d858,%ecx 109de2: 0f 85 cb 00 00 00 jne 109eb3 <_CORE_mutex_Surrender+0xef> return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) 109de8: 8b 43 54 mov 0x54(%ebx),%eax 109deb: 85 c0 test %eax,%eax 109ded: 0f 84 be 00 00 00 je 109eb1 <_CORE_mutex_Surrender+0xed> return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 109df3: 48 dec %eax 109df4: 89 43 54 mov %eax,0x54(%ebx) if ( the_mutex->nest_count != 0 ) { 109df7: 85 c0 test %eax,%eax 109df9: 74 17 je 109e12 <_CORE_mutex_Surrender+0x4e> switch ( the_mutex->Attributes.lock_nesting_behavior ) { 109dfb: 8b 53 40 mov 0x40(%ebx),%edx 109dfe: 85 d2 test %edx,%edx 109e00: 0f 84 ab 00 00 00 je 109eb1 <_CORE_mutex_Surrender+0xed><== ALWAYS TAKEN 109e06: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 109e0b: 4a dec %edx <== NOT EXECUTED 109e0c: 0f 84 a1 00 00 00 je 109eb3 <_CORE_mutex_Surrender+0xef><== NOT EXECUTED /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. * Any other value of @a alignment is taken "as is", i.e., even odd 109e12: 8b 43 48 mov 0x48(%ebx),%eax /* * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 109e15: 83 f8 02 cmp $0x2,%eax 109e18: 74 05 je 109e1f <_CORE_mutex_Surrender+0x5b> 109e1a: 83 f8 03 cmp $0x3,%eax 109e1d: 75 03 jne 109e22 <_CORE_mutex_Surrender+0x5e> the_mutex->nest_count++; return CORE_MUTEX_RELEASE_NOT_ORDER; } first_node = _Chain_Get_first_unprotected(&holder->lock_mutex); #endif holder->resource_count--; 109e1f: ff 49 1c decl 0x1c(%ecx) } the_mutex->holder = NULL; 109e22: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) the_mutex->holder_id = 0; 109e29: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) 109e30: 8b 43 48 mov 0x48(%ebx),%eax /* * Whether or not someone is waiting for the mutex, an * inherited priority must be lowered if this is the last * mutex (i.e. resource) this task has. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 109e33: 83 f8 02 cmp $0x2,%eax 109e36: 74 05 je 109e3d <_CORE_mutex_Surrender+0x79> 109e38: 83 f8 03 cmp $0x3,%eax 109e3b: 75 1b jne 109e58 <_CORE_mutex_Surrender+0x94> _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { #ifdef __RTEMS_STRICT_ORDER_MUTEX__ if(the_mutex->queue.priority_before != holder->current_priority) _Thread_Change_priority(holder,the_mutex->queue.priority_before,TRUE); #endif if ( holder->resource_count == 0 && 109e3d: 83 79 1c 00 cmpl $0x0,0x1c(%ecx) 109e41: 75 15 jne 109e58 <_CORE_mutex_Surrender+0x94> 109e43: 8b 41 18 mov 0x18(%ecx),%eax 109e46: 3b 41 14 cmp 0x14(%ecx),%eax 109e49: 74 0d je 109e58 <_CORE_mutex_Surrender+0x94> holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 109e4b: 52 push %edx 109e4c: 6a 01 push $0x1 109e4e: 50 push %eax 109e4f: 51 push %ecx 109e50: e8 97 0b 00 00 call 10a9ec <_Thread_Change_priority> 109e55: 83 c4 10 add $0x10,%esp /* * Now we check if another thread was waiting for this mutex. If so, * transfer the mutex to that thread. */ if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) { 109e58: 83 ec 0c sub $0xc,%esp 109e5b: 53 push %ebx 109e5c: e8 63 13 00 00 call 10b1c4 <_Thread_queue_Dequeue> 109e61: 89 c2 mov %eax,%edx 109e63: 83 c4 10 add $0x10,%esp 109e66: 85 c0 test %eax,%eax 109e68: 74 40 je 109eaa <_CORE_mutex_Surrender+0xe6> } else #endif { the_mutex->holder = the_thread; 109e6a: 89 43 5c mov %eax,0x5c(%ebx) the_mutex->holder_id = the_thread->Object.id; 109e6d: 8b 40 08 mov 0x8(%eax),%eax 109e70: 89 43 60 mov %eax,0x60(%ebx) the_mutex->nest_count = 1; 109e73: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx) switch ( the_mutex->Attributes.discipline ) { 109e7a: 8b 43 48 mov 0x48(%ebx),%eax 109e7d: 83 f8 02 cmp $0x2,%eax 109e80: 74 07 je 109e89 <_CORE_mutex_Surrender+0xc5> 109e82: 83 f8 03 cmp $0x3,%eax 109e85: 75 2a jne 109eb1 <_CORE_mutex_Surrender+0xed> 109e87: eb 05 jmp 109e8e <_CORE_mutex_Surrender+0xca> case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: #ifdef __RTEMS_STRICT_ORDER_MUTEX__ _Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue); the_mutex->queue.priority_before = the_thread->current_priority; #endif the_thread->resource_count++; 109e89: ff 42 1c incl 0x1c(%edx) 109e8c: eb 23 jmp 109eb1 <_CORE_mutex_Surrender+0xed> case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: #ifdef __RTEMS_STRICT_ORDER_MUTEX__ _Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue); the_mutex->queue.priority_before = the_thread->current_priority; #endif the_thread->resource_count++; 109e8e: ff 42 1c incl 0x1c(%edx) if (the_mutex->Attributes.priority_ceiling < 109e91: 8b 43 4c mov 0x4c(%ebx),%eax 109e94: 3b 42 14 cmp 0x14(%edx),%eax 109e97: 73 18 jae 109eb1 <_CORE_mutex_Surrender+0xed><== NEVER TAKEN the_thread->current_priority){ _Thread_Change_priority( 109e99: 51 push %ecx 109e9a: 6a 00 push $0x0 109e9c: 50 push %eax 109e9d: 52 push %edx 109e9e: e8 49 0b 00 00 call 10a9ec <_Thread_Change_priority> 109ea3: 31 c0 xor %eax,%eax 109ea5: 83 c4 10 add $0x10,%esp 109ea8: eb 09 jmp 109eb3 <_CORE_mutex_Surrender+0xef> } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 109eaa: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx) 109eb1: 31 c0 xor %eax,%eax return CORE_MUTEX_STATUS_SUCCESSFUL; } 109eb3: 8b 5d fc mov -0x4(%ebp),%ebx 109eb6: c9 leave 109eb7: c3 ret =============================================================================== 00109f04 <_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 ) { 109f04: 55 push %ebp 109f05: 89 e5 mov %esp,%ebp 109f07: 53 push %ebx 109f08: 83 ec 10 sub $0x10,%esp 109f0b: 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)) ) { 109f0e: 53 push %ebx 109f0f: e8 b0 12 00 00 call 10b1c4 <_Thread_queue_Dequeue> 109f14: 83 c4 10 add $0x10,%esp 109f17: 31 d2 xor %edx,%edx 109f19: 85 c0 test %eax,%eax 109f1b: 75 18 jne 109f35 <_CORE_semaphore_Surrender+0x31> if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); 109f1d: 9c pushf 109f1e: fa cli 109f1f: 59 pop %ecx if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 109f20: 8b 43 48 mov 0x48(%ebx),%eax 109f23: ba 04 00 00 00 mov $0x4,%edx 109f28: 3b 43 40 cmp 0x40(%ebx),%eax 109f2b: 73 06 jae 109f33 <_CORE_semaphore_Surrender+0x2f><== NEVER TAKEN the_semaphore->count += 1; 109f2d: 40 inc %eax 109f2e: 89 43 48 mov %eax,0x48(%ebx) 109f31: 31 d2 xor %edx,%edx else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); 109f33: 51 push %ecx 109f34: 9d popf } return status; } 109f35: 89 d0 mov %edx,%eax 109f37: 8b 5d fc mov -0x4(%ebp),%ebx 109f3a: c9 leave 109f3b: c3 ret =============================================================================== 0010a750 <_CORE_spinlock_Release>: */ CORE_spinlock_Status _CORE_spinlock_Release( CORE_spinlock_Control *the_spinlock ) { 10a750: 55 push %ebp 10a751: 89 e5 mov %esp,%ebp 10a753: 53 push %ebx 10a754: 8b 4d 08 mov 0x8(%ebp),%ecx ISR_Level level; _ISR_Disable( level ); 10a757: 9c pushf 10a758: fa cli 10a759: 5b pop %ebx /* * It must locked before it can be unlocked. */ if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 10a75a: 8b 41 04 mov 0x4(%ecx),%eax 10a75d: 85 c0 test %eax,%eax 10a75f: 75 06 jne 10a767 <_CORE_spinlock_Release+0x17> _ISR_Enable( level ); 10a761: 53 push %ebx 10a762: 9d popf 10a763: b0 06 mov $0x6,%al 10a765: eb 2f jmp 10a796 <_CORE_spinlock_Release+0x46> } /* * It must locked by the current thread before it can be unlocked. */ if ( the_spinlock->holder != _Thread_Executing->Object.id ) { 10a767: 8b 51 0c mov 0xc(%ecx),%edx 10a76a: a1 d8 e7 11 00 mov 0x11e7d8,%eax 10a76f: 3b 50 08 cmp 0x8(%eax),%edx 10a772: 74 09 je 10a77d <_CORE_spinlock_Release+0x2d><== ALWAYS TAKEN _ISR_Enable( level ); 10a774: 53 push %ebx <== NOT EXECUTED 10a775: 9d popf <== NOT EXECUTED 10a776: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10a77b: eb 19 jmp 10a796 <_CORE_spinlock_Release+0x46><== NOT EXECUTED } /* * Let it be unlocked. */ the_spinlock->users -= 1; 10a77d: 8b 41 08 mov 0x8(%ecx),%eax 10a780: 48 dec %eax 10a781: 89 41 08 mov %eax,0x8(%ecx) the_spinlock->lock = CORE_SPINLOCK_UNLOCKED; 10a784: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) the_spinlock->holder = 0; 10a78b: c7 41 0c 00 00 00 00 movl $0x0,0xc(%ecx) _ISR_Enable( level ); 10a792: 53 push %ebx 10a793: 9d popf 10a794: 31 c0 xor %eax,%eax return CORE_SPINLOCK_SUCCESSFUL; } 10a796: 5b pop %ebx 10a797: c9 leave 10a798: c3 ret =============================================================================== 0010a79c <_CORE_spinlock_Wait>: CORE_spinlock_Status _CORE_spinlock_Wait( CORE_spinlock_Control *the_spinlock, bool wait, Watchdog_Interval timeout ) { 10a79c: 55 push %ebp 10a79d: 89 e5 mov %esp,%ebp 10a79f: 57 push %edi 10a7a0: 56 push %esi 10a7a1: 53 push %ebx 10a7a2: 83 ec 0c sub $0xc,%esp 10a7a5: 8b 5d 08 mov 0x8(%ebp),%ebx 10a7a8: 8b 7d 10 mov 0x10(%ebp),%edi 10a7ab: 8a 45 0c mov 0xc(%ebp),%al 10a7ae: 88 45 f3 mov %al,-0xd(%ebp) ISR_Level level; Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout; 10a7b1: a1 68 e8 11 00 mov 0x11e868,%eax 10a7b6: 8d 34 07 lea (%edi,%eax,1),%esi _ISR_Disable( level ); 10a7b9: 9c pushf 10a7ba: fa cli 10a7bb: 59 pop %ecx if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) && 10a7bc: 8b 43 04 mov 0x4(%ebx),%eax 10a7bf: 48 dec %eax 10a7c0: 75 16 jne 10a7d8 <_CORE_spinlock_Wait+0x3c> 10a7c2: 8b 53 0c mov 0xc(%ebx),%edx 10a7c5: a1 d8 e7 11 00 mov 0x11e7d8,%eax 10a7ca: 3b 50 08 cmp 0x8(%eax),%edx 10a7cd: 75 09 jne 10a7d8 <_CORE_spinlock_Wait+0x3c> (the_spinlock->holder == _Thread_Executing->Object.id) ) { _ISR_Enable( level ); 10a7cf: 51 push %ecx 10a7d0: 9d popf 10a7d1: b8 01 00 00 00 mov $0x1,%eax 10a7d6: eb 70 jmp 10a848 <_CORE_spinlock_Wait+0xac> return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; 10a7d8: 8b 43 08 mov 0x8(%ebx),%eax 10a7db: 40 inc %eax 10a7dc: 89 43 08 mov %eax,0x8(%ebx) for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 10a7df: 8b 43 04 mov 0x4(%ebx),%eax 10a7e2: 85 c0 test %eax,%eax 10a7e4: 75 18 jne 10a7fe <_CORE_spinlock_Wait+0x62> the_spinlock->lock = CORE_SPINLOCK_LOCKED; 10a7e6: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) the_spinlock->holder = _Thread_Executing->Object.id; 10a7ed: a1 d8 e7 11 00 mov 0x11e7d8,%eax 10a7f2: 8b 40 08 mov 0x8(%eax),%eax 10a7f5: 89 43 0c mov %eax,0xc(%ebx) _ISR_Enable( level ); 10a7f8: 51 push %ecx 10a7f9: 9d popf 10a7fa: 31 c0 xor %eax,%eax 10a7fc: eb 4a jmp 10a848 <_CORE_spinlock_Wait+0xac> } /* * Spinlock is unavailable. If not willing to wait, return. */ if ( !wait ) { 10a7fe: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) 10a802: 75 10 jne 10a814 <_CORE_spinlock_Wait+0x78><== ALWAYS TAKEN the_spinlock->users -= 1; 10a804: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10a807: 48 dec %eax <== NOT EXECUTED 10a808: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10a80b: 51 push %ecx <== NOT EXECUTED 10a80c: 9d popf <== NOT EXECUTED 10a80d: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10a812: eb 34 jmp 10a848 <_CORE_spinlock_Wait+0xac><== NOT EXECUTED } /* * They are willing to wait but there could be a timeout. */ if ( timeout && (limit <= _Watchdog_Ticks_since_boot) ) { 10a814: 85 ff test %edi,%edi 10a816: 74 19 je 10a831 <_CORE_spinlock_Wait+0x95><== ALWAYS TAKEN 10a818: a1 68 e8 11 00 mov 0x11e868,%eax <== NOT EXECUTED 10a81d: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10a81f: 77 10 ja 10a831 <_CORE_spinlock_Wait+0x95><== NOT EXECUTED the_spinlock->users -= 1; 10a821: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10a824: 48 dec %eax <== NOT EXECUTED 10a825: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10a828: 51 push %ecx <== NOT EXECUTED 10a829: 9d popf <== NOT EXECUTED 10a82a: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 10a82f: eb 17 jmp 10a848 <_CORE_spinlock_Wait+0xac><== NOT EXECUTED * * A spinlock cannot be deleted while it is being used so we are * safe from deletion. */ _ISR_Enable( level ); 10a831: 51 push %ecx 10a832: 9d popf /* An ISR could occur here */ _Thread_Enable_dispatch(); 10a833: e8 68 0f 00 00 call 10b7a0 <_Thread_Enable_dispatch> 10a838: a1 18 e7 11 00 mov 0x11e718,%eax 10a83d: 40 inc %eax 10a83e: a3 18 e7 11 00 mov %eax,0x11e718 /* Another thread could get dispatched here */ /* Reenter the critical sections so we can attempt the lock again. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 10a843: 9c pushf 10a844: fa cli 10a845: 59 pop %ecx 10a846: eb 97 jmp 10a7df <_CORE_spinlock_Wait+0x43> } } 10a848: 83 c4 0c add $0xc,%esp 10a84b: 5b pop %ebx 10a84c: 5e pop %esi 10a84d: 5f pop %edi 10a84e: c9 leave 10a84f: c3 ret =============================================================================== 0010dcf1 <_Debug_Is_enabled>: */ bool _Debug_Is_enabled( rtems_debug_control level ) { 10dcf1: 55 push %ebp <== NOT EXECUTED 10dcf2: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dcf4: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10dcf7: 85 05 5c d8 11 00 test %eax,0x11d85c <== NOT EXECUTED 10dcfd: 0f 95 c0 setne %al <== NOT EXECUTED return (_Debug_Level & level) ? true : false; } 10dd00: c9 leave <== NOT EXECUTED 10dd01: c3 ret <== NOT EXECUTED =============================================================================== 00108bcc <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 108bcc: 55 push %ebp 108bcd: 89 e5 mov %esp,%ebp 108bcf: 57 push %edi 108bd0: 56 push %esi 108bd1: 53 push %ebx 108bd2: 83 ec 0c sub $0xc,%esp 108bd5: 8b 45 08 mov 0x8(%ebp),%eax 108bd8: 8b 75 0c mov 0xc(%ebp),%esi 108bdb: 8b 55 10 mov 0x10(%ebp),%edx 108bde: 89 55 ec mov %edx,-0x14(%ebp) 108be1: 8b 4d 14 mov 0x14(%ebp),%ecx 108be4: 89 4d e8 mov %ecx,-0x18(%ebp) rtems_event_set pending_events; ISR_Level level; RTEMS_API_Control *api; Thread_blocking_operation_States sync_state; executing = _Thread_Executing; 108be7: 8b 1d 58 d8 11 00 mov 0x11d858,%ebx executing->Wait.return_code = RTEMS_SUCCESSFUL; 108bed: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) api = executing->API_Extensions[ THREAD_API_RTEMS ]; 108bf4: 8b 93 f4 00 00 00 mov 0xf4(%ebx),%edx 108bfa: 89 55 f0 mov %edx,-0x10(%ebp) _ISR_Disable( level ); 108bfd: 9c pushf 108bfe: fa cli 108bff: 5f pop %edi pending_events = api->pending_events; 108c00: 8b 4d f0 mov -0x10(%ebp),%ecx 108c03: 8b 11 mov (%ecx),%edx seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 108c05: 89 c1 mov %eax,%ecx 108c07: 21 d1 and %edx,%ecx 108c09: 74 23 je 108c2e <_Event_Seize+0x62> 108c0b: 39 c1 cmp %eax,%ecx 108c0d: 74 08 je 108c17 <_Event_Seize+0x4b> 108c0f: f7 c6 02 00 00 00 test $0x2,%esi 108c15: 74 17 je 108c2e <_Event_Seize+0x62> <== NEVER TAKEN (seized_events == event_in || _Options_Is_any( option_set )) ) { api->pending_events = 108c17: 89 c8 mov %ecx,%eax 108c19: f7 d0 not %eax 108c1b: 21 d0 and %edx,%eax 108c1d: 8b 55 f0 mov -0x10(%ebp),%edx 108c20: 89 02 mov %eax,(%edx) _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 108c22: 57 push %edi 108c23: 9d popf *event_out = seized_events; 108c24: 8b 45 e8 mov -0x18(%ebp),%eax 108c27: 89 08 mov %ecx,(%eax) 108c29: e9 ad 00 00 00 jmp 108cdb <_Event_Seize+0x10f> return; } if ( _Options_Is_no_wait( option_set ) ) { 108c2e: f7 c6 01 00 00 00 test $0x1,%esi 108c34: 74 13 je 108c49 <_Event_Seize+0x7d> _ISR_Enable( level ); 108c36: 57 push %edi 108c37: 9d popf executing->Wait.return_code = RTEMS_UNSATISFIED; 108c38: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx) *event_out = seized_events; 108c3f: 8b 55 e8 mov -0x18(%ebp),%edx 108c42: 89 0a mov %ecx,(%edx) 108c44: e9 92 00 00 00 jmp 108cdb <_Event_Seize+0x10f> return; } _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 108c49: c7 05 8c e0 11 00 01 movl $0x1,0x11e08c 108c50: 00 00 00 executing->Wait.option = (uint32_t) option_set; 108c53: 89 73 30 mov %esi,0x30(%ebx) executing->Wait.count = (uint32_t) event_in; 108c56: 89 43 24 mov %eax,0x24(%ebx) executing->Wait.return_argument = event_out; 108c59: 8b 4d e8 mov -0x18(%ebp),%ecx 108c5c: 89 4b 28 mov %ecx,0x28(%ebx) _ISR_Enable( level ); 108c5f: 57 push %edi 108c60: 9d popf if ( ticks ) { 108c61: 83 7d ec 00 cmpl $0x0,-0x14(%ebp) 108c65: 74 34 je 108c9b <_Event_Seize+0xcf> _Watchdog_Initialize( 108c67: 8b 43 08 mov 0x8(%ebx),%eax * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 108c6a: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) * @param[in] the_heap is the heap to operate upon 108c71: c7 43 64 1c 8e 10 00 movl $0x108e1c,0x64(%ebx) * @param[in] starting_address is the starting address of the memory for 108c78: 89 43 68 mov %eax,0x68(%ebx) * the heap 108c7b: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 108c82: 8b 45 ec mov -0x14(%ebp),%eax 108c85: 89 43 54 mov %eax,0x54(%ebx) void *starting_address, size_t *size 108c88: 52 push %edx 108c89: 52 push %edx 108c8a: 8d 43 48 lea 0x48(%ebx),%eax 108c8d: 50 push %eax 108c8e: 68 78 d8 11 00 push $0x11d878 108c93: e8 90 2f 00 00 call 10bc28 <_Watchdog_Insert> 108c98: 83 c4 10 add $0x10,%esp NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 108c9b: 50 push %eax 108c9c: 50 push %eax 108c9d: 68 00 01 00 00 push $0x100 108ca2: 53 push %ebx 108ca3: e8 d4 29 00 00 call 10b67c <_Thread_Set_state> _ISR_Disable( level ); 108ca8: 9c pushf 108ca9: fa cli 108caa: 5a pop %edx sync_state = _Event_Sync_state; 108cab: a1 8c e0 11 00 mov 0x11e08c,%eax _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 108cb0: c7 05 8c e0 11 00 00 movl $0x0,0x11e08c 108cb7: 00 00 00 if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { 108cba: 83 c4 10 add $0x10,%esp 108cbd: 83 f8 01 cmp $0x1,%eax 108cc0: 75 04 jne 108cc6 <_Event_Seize+0xfa> _ISR_Enable( level ); 108cc2: 52 push %edx 108cc3: 9d popf 108cc4: eb 15 jmp 108cdb <_Event_Seize+0x10f> * An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); 108cc6: 89 55 10 mov %edx,0x10(%ebp) 108cc9: 89 5d 0c mov %ebx,0xc(%ebp) 108ccc: 89 45 08 mov %eax,0x8(%ebp) } 108ccf: 8d 65 f4 lea -0xc(%ebp),%esp 108cd2: 5b pop %ebx 108cd3: 5e pop %esi 108cd4: 5f pop %edi 108cd5: c9 leave * An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); 108cd6: e9 c5 1c 00 00 jmp 10a9a0 <_Thread_blocking_operation_Cancel> } 108cdb: 8d 65 f4 lea -0xc(%ebp),%esp 108cde: 5b pop %ebx 108cdf: 5e pop %esi 108ce0: 5f pop %edi 108ce1: c9 leave 108ce2: c3 ret =============================================================================== 00108d30 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 108d30: 55 push %ebp 108d31: 89 e5 mov %esp,%ebp 108d33: 57 push %edi 108d34: 56 push %esi 108d35: 53 push %ebx 108d36: 83 ec 0c sub $0xc,%esp 108d39: 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 ]; 108d3c: 8b 83 f4 00 00 00 mov 0xf4(%ebx),%eax 108d42: 89 45 f0 mov %eax,-0x10(%ebp) option_set = (rtems_option) the_thread->Wait.option; 108d45: 8b 53 30 mov 0x30(%ebx),%edx 108d48: 89 55 ec mov %edx,-0x14(%ebp) _ISR_Disable( level ); 108d4b: 9c pushf 108d4c: fa cli 108d4d: 5f pop %edi pending_events = api->pending_events; 108d4e: 8b 30 mov (%eax),%esi event_condition = (rtems_event_set) the_thread->Wait.count; 108d50: 8b 53 24 mov 0x24(%ebx),%edx seized_events = _Event_sets_Get( pending_events, event_condition ); /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { 108d53: 89 d1 mov %edx,%ecx 108d55: 21 f1 and %esi,%ecx 108d57: 75 07 jne 108d60 <_Event_Surrender+0x30> _ISR_Enable( level ); 108d59: 57 push %edi 108d5a: 9d popf 108d5b: e9 b1 00 00 00 jmp 108e11 <_Event_Surrender+0xe1> /* * 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() && 108d60: a1 34 d8 11 00 mov 0x11d834,%eax 108d65: 85 c0 test %eax,%eax 108d67: 74 49 je 108db2 <_Event_Surrender+0x82> 108d69: 3b 1d 58 d8 11 00 cmp 0x11d858,%ebx 108d6f: 75 41 jne 108db2 <_Event_Surrender+0x82> <== NEVER TAKEN 108d71: a1 8c e0 11 00 mov 0x11e08c,%eax 108d76: 48 dec %eax 108d77: 74 0a je 108d83 <_Event_Surrender+0x53> <== ALWAYS TAKEN 108d79: a1 8c e0 11 00 mov 0x11e08c,%eax <== NOT EXECUTED 108d7e: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 108d81: 75 2f jne 108db2 <_Event_Surrender+0x82> <== NOT EXECUTED _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 108d83: 39 d1 cmp %edx,%ecx 108d85: 74 06 je 108d8d <_Event_Surrender+0x5d> <== ALWAYS TAKEN 108d87: f6 45 ec 02 testb $0x2,-0x14(%ebp) <== NOT EXECUTED 108d8b: 74 21 je 108dae <_Event_Surrender+0x7e> <== NOT EXECUTED api->pending_events = _Event_sets_Clear( pending_events,seized_events ); 108d8d: 89 c8 mov %ecx,%eax 108d8f: f7 d0 not %eax 108d91: 21 f0 and %esi,%eax 108d93: 8b 55 f0 mov -0x10(%ebp),%edx 108d96: 89 02 mov %eax,(%edx) the_thread->Wait.count = 0; 108d98: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 108d9f: 8b 43 28 mov 0x28(%ebx),%eax 108da2: 89 08 mov %ecx,(%eax) _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 108da4: c7 05 8c e0 11 00 03 movl $0x3,0x11e08c 108dab: 00 00 00 } _ISR_Enable( level ); 108dae: 57 push %edi 108daf: 9d popf 108db0: eb 5f jmp 108e11 <_Event_Surrender+0xe1> } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 108db2: f6 43 11 01 testb $0x1,0x11(%ebx) 108db6: 74 57 je 108e0f <_Event_Surrender+0xdf> <== NEVER TAKEN if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 108db8: 39 d1 cmp %edx,%ecx 108dba: 74 06 je 108dc2 <_Event_Surrender+0x92> 108dbc: f6 45 ec 02 testb $0x2,-0x14(%ebp) 108dc0: 74 4d je 108e0f <_Event_Surrender+0xdf> <== NEVER TAKEN api->pending_events = _Event_sets_Clear( pending_events, seized_events ); 108dc2: 89 c8 mov %ecx,%eax 108dc4: f7 d0 not %eax 108dc6: 21 f0 and %esi,%eax 108dc8: 8b 55 f0 mov -0x10(%ebp),%edx 108dcb: 89 02 mov %eax,(%edx) the_thread->Wait.count = 0; 108dcd: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 108dd4: 8b 43 28 mov 0x28(%ebx),%eax 108dd7: 89 08 mov %ecx,(%eax) _ISR_Flash( level ); 108dd9: 57 push %edi 108dda: 9d popf 108ddb: fa cli if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 108ddc: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 108de0: 74 06 je 108de8 <_Event_Surrender+0xb8> _ISR_Enable( level ); 108de2: 57 push %edi 108de3: 9d popf void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 108de4: 51 push %ecx 108de5: 51 push %ecx 108de6: eb 17 jmp 108dff <_Event_Surrender+0xcf> * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 108de8: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 108def: 57 push %edi 108df0: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 108df1: 83 ec 0c sub $0xc,%esp 108df4: 8d 43 48 lea 0x48(%ebx),%eax 108df7: 50 push %eax 108df8: e8 43 2f 00 00 call 10bd40 <_Watchdog_Remove> void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 108dfd: 58 pop %eax 108dfe: 5a pop %edx 108dff: 68 f8 ff 03 10 push $0x1003fff8 108e04: 53 push %ebx 108e05: e8 02 1d 00 00 call 10ab0c <_Thread_Clear_state> 108e0a: 83 c4 10 add $0x10,%esp 108e0d: eb 02 jmp 108e11 <_Event_Surrender+0xe1> _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 108e0f: 57 push %edi <== NOT EXECUTED 108e10: 9d popf <== NOT EXECUTED } 108e11: 8d 65 f4 lea -0xc(%ebp),%esp 108e14: 5b pop %ebx 108e15: 5e pop %esi 108e16: 5f pop %edi 108e17: c9 leave 108e18: c3 ret =============================================================================== 00108e1c <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 108e1c: 55 push %ebp 108e1d: 89 e5 mov %esp,%ebp 108e1f: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 108e22: 8d 45 fc lea -0x4(%ebp),%eax 108e25: 50 push %eax 108e26: ff 75 08 pushl 0x8(%ebp) 108e29: e8 7e 20 00 00 call 10aeac <_Thread_Get> 108e2e: 89 c2 mov %eax,%edx switch ( location ) { 108e30: 83 c4 10 add $0x10,%esp 108e33: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) 108e37: 75 5f jne 108e98 <_Event_Timeout+0x7c> <== NEVER TAKEN * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ _ISR_Disable( level ); 108e39: 9c pushf 108e3a: fa cli 108e3b: 59 pop %ecx if ( !the_thread->Wait.count ) { /* verify thread is waiting */ 108e3c: 83 78 24 00 cmpl $0x0,0x24(%eax) 108e40: 75 0f jne 108e51 <_Event_Timeout+0x35> <== ALWAYS TAKEN 108e42: a1 98 d7 11 00 mov 0x11d798,%eax <== NOT EXECUTED 108e47: 48 dec %eax <== NOT EXECUTED 108e48: a3 98 d7 11 00 mov %eax,0x11d798 <== NOT EXECUTED _Thread_Unnest_dispatch(); _ISR_Enable( level ); 108e4d: 51 push %ecx <== NOT EXECUTED 108e4e: 9d popf <== NOT EXECUTED 108e4f: eb 47 jmp 108e98 <_Event_Timeout+0x7c> <== NOT EXECUTED return; } the_thread->Wait.count = 0; 108e51: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) if ( _Thread_Is_executing( the_thread ) ) { 108e58: 3b 05 58 d8 11 00 cmp 0x11d858,%eax 108e5e: 75 14 jne 108e74 <_Event_Timeout+0x58> Thread_blocking_operation_States sync = _Event_Sync_state; 108e60: a1 8c e0 11 00 mov 0x11e08c,%eax if ( (sync == THREAD_BLOCKING_OPERATION_SYNCHRONIZED) || 108e65: 83 f8 01 cmp $0x1,%eax 108e68: 77 0a ja 108e74 <_Event_Timeout+0x58> <== NEVER TAKEN (sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 108e6a: c7 05 8c e0 11 00 02 movl $0x2,0x11e08c 108e71: 00 00 00 } } the_thread->Wait.return_code = RTEMS_TIMEOUT; 108e74: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) _ISR_Enable( level ); 108e7b: 51 push %ecx 108e7c: 9d popf void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 108e7d: 50 push %eax 108e7e: 50 push %eax 108e7f: 68 f8 ff 03 10 push $0x1003fff8 108e84: 52 push %edx 108e85: e8 82 1c 00 00 call 10ab0c <_Thread_Clear_state> 108e8a: a1 98 d7 11 00 mov 0x11d798,%eax 108e8f: 48 dec %eax 108e90: a3 98 d7 11 00 mov %eax,0x11d798 108e95: 83 c4 10 add $0x10,%esp case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 108e98: c9 leave 108e99: c3 ret =============================================================================== 0010df90 <_Heap_Allocate>: void *_Heap_Allocate( Heap_Control *the_heap, size_t size ) { 10df90: 55 push %ebp 10df91: 89 e5 mov %esp,%ebp 10df93: 57 push %edi 10df94: 56 push %esi 10df95: 53 push %ebx 10df96: 83 ec 10 sub $0x10,%esp 10df99: 8b 75 08 mov 0x8(%ebp),%esi Heap_Block *the_block; void *ptr = NULL; Heap_Statistics *const stats = &the_heap->stats; Heap_Block *const tail = _Heap_Tail(the_heap); the_size = 10df9c: ff 76 14 pushl 0x14(%esi) 10df9f: ff 76 10 pushl 0x10(%esi) 10dfa2: ff 75 0c pushl 0xc(%ebp) 10dfa5: e8 91 c1 ff ff call 10a13b <_Heap_Calc_block_size> _Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size); if(the_size == 0) 10dfaa: 83 c4 10 add $0x10,%esp 10dfad: 31 d2 xor %edx,%edx 10dfaf: 85 c0 test %eax,%eax 10dfb1: 74 3c je 10dfef <_Heap_Allocate+0x5f> <== NEVER TAKEN * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( 10dfb3: 8b 5e 08 mov 0x8(%esi),%ebx 10dfb6: 31 ff xor %edi,%edi 10dfb8: eb 27 jmp 10dfe1 <_Heap_Allocate+0x51> /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); /* Don't bother to mask out the HEAP_PREV_USED bit as it won't change the result of the comparison. */ if(the_block->size >= the_size) { 10dfba: 39 43 04 cmp %eax,0x4(%ebx) 10dfbd: 72 1e jb 10dfdd <_Heap_Allocate+0x4d> (void)_Heap_Block_allocate(the_heap, the_block, the_size ); 10dfbf: 52 push %edx 10dfc0: 50 push %eax 10dfc1: 53 push %ebx 10dfc2: 56 push %esi 10dfc3: e8 b0 c1 ff ff call 10a178 <_Heap_Block_allocate> * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 10dfc8: 8d 53 08 lea 0x8(%ebx),%edx ptr = _Heap_User_area(the_block); stats->allocs += 1; 10dfcb: ff 46 48 incl 0x48(%esi) stats->searches += search_count + 1; 10dfce: 8b 46 4c mov 0x4c(%esi),%eax 10dfd1: 8d 44 07 01 lea 0x1(%edi,%eax,1),%eax 10dfd5: 89 46 4c mov %eax,0x4c(%esi) 10dfd8: 83 c4 10 add $0x10,%esp 10dfdb: eb 0a jmp 10dfe7 <_Heap_Allocate+0x57> return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; the_block = the_block->next, ++search_count) 10dfdd: 8b 5b 08 mov 0x8(%ebx),%ebx 10dfe0: 47 inc %edi if(the_size == 0) return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 10dfe1: 39 f3 cmp %esi,%ebx 10dfe3: 75 d5 jne 10dfba <_Heap_Allocate+0x2a> 10dfe5: 31 d2 xor %edx,%edx _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; } } if(stats->max_search < search_count) 10dfe7: 39 7e 44 cmp %edi,0x44(%esi) 10dfea: 73 03 jae 10dfef <_Heap_Allocate+0x5f> stats->max_search = search_count; 10dfec: 89 7e 44 mov %edi,0x44(%esi) return ptr; } 10dfef: 89 d0 mov %edx,%eax 10dff1: 8d 65 f4 lea -0xc(%ebp),%esp 10dff4: 5b pop %ebx 10dff5: 5e pop %esi 10dff6: 5f pop %edi 10dff7: c9 leave 10dff8: c3 ret =============================================================================== 0010b7f8 <_Heap_Allocate_aligned>: void *_Heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) { 10b7f8: 55 push %ebp 10b7f9: 89 e5 mov %esp,%ebp 10b7fb: 57 push %edi 10b7fc: 56 push %esi 10b7fd: 53 push %ebx 10b7fe: 83 ec 30 sub $0x30,%esp 10b801: 8b 45 0c mov 0xc(%ebp),%eax uint32_t search_count; Heap_Block *the_block; void *user_ptr = NULL; uint32_t const page_size = the_heap->page_size; 10b804: 8b 55 08 mov 0x8(%ebp),%edx 10b807: 8b 52 10 mov 0x10(%edx),%edx 10b80a: 89 55 dc mov %edx,-0x24(%ebp) Heap_Statistics *const stats = &the_heap->stats; Heap_Block *const tail = _Heap_Tail(the_heap); uint32_t const end_to_user_offs = size - HEAP_BLOCK_HEADER_OFFSET; 10b80d: 8d 48 fc lea -0x4(%eax),%ecx 10b810: 89 4d e0 mov %ecx,-0x20(%ebp) uint32_t const the_size = _Heap_Calc_block_size(size, page_size, the_heap->min_block_size); 10b813: 8b 55 08 mov 0x8(%ebp),%edx 10b816: ff 72 14 pushl 0x14(%edx) 10b819: ff 75 dc pushl -0x24(%ebp) 10b81c: 50 push %eax 10b81d: e8 2d 04 00 00 call 10bc4f <_Heap_Calc_block_size> 10b822: 89 45 e4 mov %eax,-0x1c(%ebp) if(the_size == 0) 10b825: 83 c4 10 add $0x10,%esp 10b828: 31 c0 xor %eax,%eax 10b82a: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) 10b82e: 0f 84 30 01 00 00 je 10b964 <_Heap_Allocate_aligned+0x16c><== NEVER TAKEN return NULL; if(alignment == 0) 10b834: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10b838: 75 07 jne 10b841 <_Heap_Allocate_aligned+0x49> 10b83a: c7 45 10 04 00 00 00 movl $0x4,0x10(%ebp) ) { return ( the_thread == _Thread_Heir ); } /** 10b841: 8b 4d 08 mov 0x8(%ebp),%ecx 10b844: 8b 59 08 mov 0x8(%ecx),%ebx 10b847: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp) 10b84e: e9 f8 00 00 00 jmp 10b94b <_Heap_Allocate_aligned+0x153> 10b853: 8b 43 04 mov 0x4(%ebx),%eax 10b856: 83 e0 fe and $0xfffffffe,%eax 10b859: 89 45 e8 mov %eax,-0x18(%ebp) uint32_t const block_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); if(block_size >= the_size) { /* the_block is large enough. */ 10b85c: 8b 55 e4 mov -0x1c(%ebp),%edx 10b85f: 39 d0 cmp %edx,%eax 10b861: 0f 82 de 00 00 00 jb 10b945 <_Heap_Allocate_aligned+0x14d> _H_uptr_t user_addr; _H_uptr_t aligned_user_addr; _H_uptr_t const user_area = _H_p2u(_Heap_User_area(the_block)); 10b867: 8d 4b 08 lea 0x8(%ebx),%ecx /* Calculate 'aligned_user_addr' that will become the user pointer we return. It should be at least 'end_to_user_offs' bytes less than the the 'block_end' and should be aligned on 'alignment' boundary. Calculations are from the 'block_end' as we are going to split free block so that the upper part of the block becomes used block. */ _H_uptr_t const block_end = _H_p2u(the_block) + block_size; 10b86a: 01 d8 add %ebx,%eax 10b86c: 89 45 ec mov %eax,-0x14(%ebp) aligned_user_addr = block_end - end_to_user_offs; 10b86f: 89 c6 mov %eax,%esi 10b871: 2b 75 e0 sub -0x20(%ebp),%esi RTEMS_INLINE_ROUTINE void _Thread_Dispatch_initialization( void ) { _Thread_Dispatch_disable_level = 1; } 10b874: 89 f0 mov %esi,%eax 10b876: 31 d2 xor %edx,%edx 10b878: f7 75 10 divl 0x10(%ebp) 10b87b: 89 f7 mov %esi,%edi 10b87d: 29 d7 sub %edx,%edi 10b87f: 89 f8 mov %edi,%eax 10b881: 31 d2 xor %edx,%edx 10b883: f7 75 dc divl -0x24(%ebp) 10b886: 89 fe mov %edi,%esi 10b888: 29 d6 sub %edx,%esi only at 'page_size' aligned addresses */ user_addr = aligned_user_addr; _Heap_Align_down_uptr(&user_addr, page_size); /* Make sure 'user_addr' calculated didn't run out of 'the_block'. */ if(user_addr >= user_area) { 10b88a: 39 ce cmp %ecx,%esi 10b88c: 0f 82 b3 00 00 00 jb 10b945 <_Heap_Allocate_aligned+0x14d> /* The block seems to be acceptable. Check if the remainder of 'the_block' is less than 'min_block_size' so that 'the_block' won't actually be split at the address we assume. */ if(user_addr - user_area < the_heap->min_block_size) { 10b892: 8b 55 08 mov 0x8(%ebp),%edx 10b895: 8b 52 14 mov 0x14(%edx),%edx 10b898: 89 55 f0 mov %edx,-0x10(%ebp) 10b89b: 89 f0 mov %esi,%eax 10b89d: 29 c8 sub %ecx,%eax 10b89f: 39 d0 cmp %edx,%eax 10b8a1: 73 2f jae 10b8d2 <_Heap_Allocate_aligned+0xda> 'aligned_user_addr' to be outside of [0,page_size) range. If we do, we will need to store this distance somewhere to be able to resurrect the block address from the user pointer. (Having the distance within [0,page_size) range allows resurrection by aligning user pointer down to the nearest 'page_size' boundary.) */ if(aligned_user_addr - user_addr >= page_size) { 10b8a3: 89 f8 mov %edi,%eax 10b8a5: 29 c8 sub %ecx,%eax 10b8a7: 89 ce mov %ecx,%esi 10b8a9: 3b 45 dc cmp -0x24(%ebp),%eax 10b8ac: 72 24 jb 10b8d2 <_Heap_Allocate_aligned+0xda> RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); } /** 10b8ae: 89 c8 mov %ecx,%eax 10b8b0: 31 d2 xor %edx,%edx 10b8b2: f7 75 10 divl 0x10(%ebp) 10b8b5: 89 d6 mov %edx,%esi * This function returns TRUE if dispatching is disabled, and FALSE 10b8b7: 89 ca mov %ecx,%edx 10b8b9: 85 f6 test %esi,%esi 10b8bb: 74 08 je 10b8c5 <_Heap_Allocate_aligned+0xcd> 10b8bd: 8b 45 10 mov 0x10(%ebp),%eax 10b8c0: 8d 14 01 lea (%ecx,%eax,1),%edx 10b8c3: 29 f2 sub %esi,%edx /* The user pointer will be too far from 'user_addr'. See if we can make 'aligned_user_addr' to be close enough to the 'user_addr'. */ aligned_user_addr = user_addr; _Heap_Align_up_uptr(&aligned_user_addr, alignment); if(aligned_user_addr - user_addr >= page_size) { 10b8c5: 89 d0 mov %edx,%eax 10b8c7: 29 c8 sub %ecx,%eax 10b8c9: 3b 45 dc cmp -0x24(%ebp),%eax 10b8cc: 73 77 jae 10b945 <_Heap_Allocate_aligned+0x14d> 10b8ce: 89 ce mov %ecx,%esi 10b8d0: 89 d7 mov %edx,%edi aligned_user_addr = 0; } } } if(aligned_user_addr) { 10b8d2: 85 ff test %edi,%edi 10b8d4: 74 6f je 10b945 <_Heap_Allocate_aligned+0x14d><== NEVER TAKEN /* The block is indeed acceptable: calculate the size of the block to be allocated and perform allocation. */ uint32_t const alloc_size = block_end - user_addr + HEAP_BLOCK_USER_OFFSET; 10b8d6: 8b 55 ec mov -0x14(%ebp),%edx 10b8d9: 83 c2 08 add $0x8,%edx 10b8dc: 29 f2 sub %esi,%edx Heap_Block *the_block, uint32_t alloc_size) { Heap_Statistics *const stats = &the_heap->stats; uint32_t const block_size = _Heap_Block_size(the_block); uint32_t const the_rest = block_size - alloc_size; 10b8de: 8b 4d e8 mov -0x18(%ebp),%ecx 10b8e1: 29 d1 sub %edx,%ecx _HAssert(_Heap_Is_aligned(block_size, the_heap->page_size)); _HAssert(_Heap_Is_aligned(alloc_size, the_heap->page_size)); _HAssert(alloc_size <= block_size); _HAssert(_Heap_Is_prev_used(the_block)); if(the_rest >= the_heap->min_block_size) { 10b8e3: 3b 4d f0 cmp -0x10(%ebp),%ecx 10b8e6: 72 14 jb 10b8fc <_Heap_Allocate_aligned+0x104> /* Split the block so that lower part is still free, and upper part becomes used. */ the_block->size = the_rest | HEAP_PREV_USED; 10b8e8: 89 c8 mov %ecx,%eax 10b8ea: 83 c8 01 or $0x1,%eax 10b8ed: 89 43 04 mov %eax,0x4(%ebx) Context_Control *context_p = &context_area; if ( _System_state_Is_up(_System_state_Get ()) ) context_p = &_Thread_Executing->Registers; _Context_Switch( context_p, &_Thread_BSP_context ); 10b8f0: 8d 04 0b lea (%ebx,%ecx,1),%eax /** @brief _Thread_Is_proxy_blocking * * status which indicates that a proxy is blocking, and FALSE otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking ( uint32_t code 10b8f3: 89 c3 mov %eax,%ebx the_block = _Heap_Block_at(the_block, the_rest); the_block->prev_size = the_rest; 10b8f5: 89 08 mov %ecx,(%eax) the_block->size = alloc_size; 10b8f7: 89 50 04 mov %edx,0x4(%eax) 10b8fa: eb 15 jmp 10b911 <_Heap_Allocate_aligned+0x119> * This routine resets the current context of the calling thread * to that of its initial state. */ RTEMS_INLINE_ROUTINE void _Thread_Restart_self( void ) { 10b8fc: 8b 53 08 mov 0x8(%ebx),%edx #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) 10b8ff: 8b 43 0c mov 0xc(%ebx),%eax if ( _Thread_Executing->fp_context != NULL ) 10b902: 89 50 08 mov %edx,0x8(%eax) _Context_Restore_fp( &_Thread_Executing->fp_context ); 10b905: 89 42 0c mov %eax,0xc(%edx) /* Don't split the block as remainder is either zero or too small to be used as a separate free block. Change 'alloc_size' to the size of the block and remove the block from the list of free blocks. */ _Heap_Block_remove(the_block); alloc_size = block_size; stats->free_blocks -= 1; 10b908: 8b 55 08 mov 0x8(%ebp),%edx 10b90b: ff 4a 38 decl 0x38(%edx) 10b90e: 8b 55 e8 mov -0x18(%ebp),%edx } /* Mark the block as used (in the next block). */ _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED; 10b911: 83 4c 13 04 01 orl $0x1,0x4(%ebx,%edx,1) /* Update statistics */ stats->free_size -= alloc_size; 10b916: 8b 4d 08 mov 0x8(%ebp),%ecx 10b919: 8b 41 30 mov 0x30(%ecx),%eax 10b91c: 29 d0 sub %edx,%eax 10b91e: 89 41 30 mov %eax,0x30(%ecx) if(stats->min_free_size > stats->free_size) 10b921: 39 41 34 cmp %eax,0x34(%ecx) 10b924: 76 03 jbe 10b929 <_Heap_Allocate_aligned+0x131> stats->min_free_size = stats->free_size; 10b926: 89 41 34 mov %eax,0x34(%ecx) stats->used_blocks += 1; 10b929: 8b 45 08 mov 0x8(%ebp),%eax 10b92c: ff 40 40 incl 0x40(%eax) _HAssert(_Heap_Is_aligned_ptr((void*)aligned_user_addr, alignment)); the_block = block_allocate(the_heap, the_block, alloc_size); stats->searches += search_count + 1; 10b92f: 89 c2 mov %eax,%edx 10b931: 8b 40 4c mov 0x4c(%eax),%eax 10b934: 8b 4d d8 mov -0x28(%ebp),%ecx 10b937: 8d 44 01 01 lea 0x1(%ecx,%eax,1),%eax 10b93b: 89 42 4c mov %eax,0x4c(%edx) stats->allocs += 1; 10b93e: ff 42 48 incl 0x48(%edx) check_result(the_heap, the_block, user_addr, aligned_user_addr, size); user_ptr = (void*)aligned_user_addr; 10b941: 89 f8 mov %edi,%eax 10b943: eb 11 jmp 10b956 <_Heap_Allocate_aligned+0x15e> /* Find large enough free block that satisfies the alignment requirements. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; the_block = the_block->next, ++search_count) 10b945: 8b 5b 08 mov 0x8(%ebx),%ebx 10b948: ff 45 d8 incl -0x28(%ebp) alignment = CPU_ALIGNMENT; /* Find large enough free block that satisfies the alignment requirements. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 10b94b: 3b 5d 08 cmp 0x8(%ebp),%ebx 10b94e: 0f 85 ff fe ff ff jne 10b853 <_Heap_Allocate_aligned+0x5b> 10b954: 31 c0 xor %eax,%eax } } } } if(stats->max_search < search_count) 10b956: 8b 55 d8 mov -0x28(%ebp),%edx 10b959: 8b 4d 08 mov 0x8(%ebp),%ecx 10b95c: 39 51 44 cmp %edx,0x44(%ecx) 10b95f: 73 03 jae 10b964 <_Heap_Allocate_aligned+0x16c> stats->max_search = search_count; 10b961: 89 51 44 mov %edx,0x44(%ecx) return user_ptr; } 10b964: 8d 65 f4 lea -0xc(%ebp),%esp 10b967: 5b pop %ebx 10b968: 5e pop %esi 10b969: 5f pop %edi 10b96a: c9 leave 10b96b: c3 ret =============================================================================== 0010ff58 <_Heap_Extend>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t *amount_extended ) { 10ff58: 55 push %ebp 10ff59: 89 e5 mov %esp,%ebp 10ff5b: 57 push %edi 10ff5c: 56 push %esi 10ff5d: 53 push %ebx 10ff5e: 83 ec 0c sub $0xc,%esp 10ff61: 8b 4d 08 mov 0x8(%ebp),%ecx 10ff64: 8b 55 0c mov 0xc(%ebp),%edx 10ff67: 8b 75 10 mov 0x10(%ebp),%esi * 5. non-contiguous higher address (NOT SUPPORTED) * * As noted, this code only supports (4). */ if ( starting_address >= the_heap->begin && /* case 3 */ 10ff6a: 3b 51 18 cmp 0x18(%ecx),%edx 10ff6d: 72 0a jb 10ff79 <_Heap_Extend+0x21> 10ff6f: b8 01 00 00 00 mov $0x1,%eax 10ff74: 3b 51 1c cmp 0x1c(%ecx),%edx 10ff77: 72 5f jb 10ffd8 <_Heap_Extend+0x80> starting_address < the_heap->end ) return HEAP_EXTEND_ERROR; if ( starting_address != the_heap->end ) 10ff79: b8 02 00 00 00 mov $0x2,%eax 10ff7e: 3b 51 1c cmp 0x1c(%ecx),%edx 10ff81: 75 55 jne 10ffd8 <_Heap_Extend+0x80> * Currently only case 4 should make it to this point. * The basic trick is to make the extend area look like a used * block and free it. */ old_final = the_heap->final; 10ff83: 8b 59 24 mov 0x24(%ecx),%ebx Context_Control *context_p = &context_area; if ( _System_state_Is_up(_System_state_Get ()) ) context_p = &_Thread_Executing->Registers; _Context_Switch( context_p, &_Thread_BSP_context ); 10ff86: 8d 04 32 lea (%edx,%esi,1),%eax the_heap->end = _Addresses_Add_offset( the_heap->end, size ); 10ff89: 89 41 1c mov %eax,0x1c(%ecx) the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD; 10ff8c: 29 d8 sub %ebx,%eax 10ff8e: 8d 78 f8 lea -0x8(%eax),%edi * the outer most dispatching critical section, then a dispatching * operation will be performed and, if necessary, control of the * processor will be transferred to the heir thread. */ #if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \ 10ff91: 89 f8 mov %edi,%eax 10ff93: 31 d2 xor %edx,%edx 10ff95: f7 71 10 divl 0x10(%ecx) 10ff98: 29 d7 sub %edx,%edi _Heap_Align_down( &the_size, the_heap->page_size ); *amount_extended = size; 10ff9a: 8b 45 14 mov 0x14(%ebp),%eax 10ff9d: 89 30 mov %esi,(%eax) if( the_size < the_heap->min_block_size ) 10ff9f: 31 c0 xor %eax,%eax 10ffa1: 3b 79 14 cmp 0x14(%ecx),%edi 10ffa4: 72 32 jb 10ffd8 <_Heap_Extend+0x80> <== NEVER TAKEN return HEAP_EXTEND_SUCCESSFUL; old_final->size = the_size | (old_final->size & HEAP_PREV_USED); 10ffa6: 8b 43 04 mov 0x4(%ebx),%eax 10ffa9: 83 e0 01 and $0x1,%eax 10ffac: 09 f8 or %edi,%eax 10ffae: 89 43 04 mov %eax,0x4(%ebx) /** @brief _Thread_Is_proxy_blocking * * status which indicates that a proxy is blocking, and FALSE otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking ( uint32_t code 10ffb1: 8d 04 3b lea (%ebx,%edi,1),%eax new_final = _Heap_Block_at( old_final, the_size ); new_final->size = HEAP_PREV_USED; 10ffb4: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) the_heap->final = new_final; 10ffbb: 89 41 24 mov %eax,0x24(%ecx) stats->size += size; 10ffbe: 01 71 2c add %esi,0x2c(%ecx) stats->used_blocks += 1; 10ffc1: ff 41 40 incl 0x40(%ecx) stats->frees -= 1; /* Don't count subsequent call as actual free() */ 10ffc4: ff 49 50 decl 0x50(%ecx) _Heap_Free( the_heap, _Heap_User_area( old_final ) ); 10ffc7: 50 push %eax 10ffc8: 50 push %eax 10ffc9: 8d 43 08 lea 0x8(%ebx),%eax 10ffcc: 50 push %eax 10ffcd: 51 push %ecx 10ffce: e8 05 ba ff ff call 10b9d8 <_Heap_Free> 10ffd3: 31 c0 xor %eax,%eax 10ffd5: 83 c4 10 add $0x10,%esp return HEAP_EXTEND_SUCCESSFUL; } 10ffd8: 8d 65 f4 lea -0xc(%ebp),%esp 10ffdb: 5b pop %ebx 10ffdc: 5e pop %esi 10ffdd: 5f pop %edi 10ffde: c9 leave 10ffdf: c3 ret =============================================================================== 0010dffc <_Heap_Free>: bool _Heap_Free( Heap_Control *the_heap, void *starting_address ) { 10dffc: 55 push %ebp 10dffd: 89 e5 mov %esp,%ebp 10dfff: 57 push %edi 10e000: 56 push %esi 10e001: 53 push %ebx 10e002: 83 ec 14 sub $0x14,%esp 10e005: 8b 7d 08 mov 0x8(%ebp),%edi 10e008: 8b 4d 0c mov 0xc(%ebp),%ecx uint32_t the_size; uint32_t next_size; Heap_Statistics *const stats = &the_heap->stats; bool next_is_free; if ( !_Addresses_Is_in_range( 10e00b: 8b 47 24 mov 0x24(%edi),%eax 10e00e: 89 45 e0 mov %eax,-0x20(%ebp) 10e011: 8b 57 20 mov 0x20(%edi),%edx 10e014: 89 55 e4 mov %edx,-0x1c(%ebp) 10e017: 39 d1 cmp %edx,%ecx 10e019: 0f 93 c2 setae %dl 10e01c: 39 c1 cmp %eax,%ecx 10e01e: 0f 96 c0 setbe %al 10e021: 84 d0 test %dl,%al 10e023: 0f 84 2f 01 00 00 je 10e158 <_Heap_Free+0x15c> 10e029: 8d 59 f8 lea -0x8(%ecx),%ebx 10e02c: 89 c8 mov %ecx,%eax 10e02e: 31 d2 xor %edx,%edx 10e030: f7 77 10 divl 0x10(%edi) 10e033: 29 d3 sub %edx,%ebx return( FALSE ); } _Heap_Start_of_block( the_heap, starting_address, &the_block ); if ( !_Heap_Is_block_in( the_heap, the_block ) ) { 10e035: 3b 5d e4 cmp -0x1c(%ebp),%ebx 10e038: 0f 93 c2 setae %dl 10e03b: 3b 5d e0 cmp -0x20(%ebp),%ebx 10e03e: 0f 96 c0 setbe %al 10e041: 84 d0 test %dl,%al 10e043: 0f 84 0f 01 00 00 je 10e158 <_Heap_Free+0x15c> <== NEVER TAKEN 10e049: 8b 4b 04 mov 0x4(%ebx),%ecx 10e04c: 89 c8 mov %ecx,%eax 10e04e: 83 e0 fe and $0xfffffffe,%eax 10e051: 89 45 e8 mov %eax,-0x18(%ebp) 10e054: 8d 34 03 lea (%ebx,%eax,1),%esi } the_size = _Heap_Block_size( the_block ); next_block = _Heap_Block_at( the_block, the_size ); if ( !_Heap_Is_block_in( the_heap, next_block ) ) { 10e057: 3b 75 e4 cmp -0x1c(%ebp),%esi 10e05a: 0f 93 c2 setae %dl 10e05d: 3b 75 e0 cmp -0x20(%ebp),%esi 10e060: 0f 96 c0 setbe %al 10e063: 84 d0 test %dl,%al 10e065: 0f 84 ed 00 00 00 je 10e158 <_Heap_Free+0x15c> <== NEVER TAKEN 10e06b: 8b 46 04 mov 0x4(%esi),%eax _HAssert( FALSE ); return( FALSE ); } if ( !_Heap_Is_prev_used( next_block ) ) { 10e06e: a8 01 test $0x1,%al 10e070: 0f 84 e2 00 00 00 je 10e158 <_Heap_Free+0x15c> <== NEVER TAKEN 10e076: 83 e0 fe and $0xfffffffe,%eax 10e079: 89 45 ec mov %eax,-0x14(%ebp) _HAssert( FALSE ); return( FALSE ); } next_size = _Heap_Block_size( next_block ); next_is_free = next_block < the_heap->final && 10e07c: 31 c0 xor %eax,%eax 10e07e: 3b 75 e0 cmp -0x20(%ebp),%esi 10e081: 73 0c jae 10e08f <_Heap_Free+0x93> 10e083: 8b 55 ec mov -0x14(%ebp),%edx 10e086: 8b 44 16 04 mov 0x4(%esi,%edx,1),%eax 10e08a: f7 d0 not %eax 10e08c: 83 e0 01 and $0x1,%eax 10e08f: 88 45 f3 mov %al,-0xd(%ebp) !_Heap_Is_prev_used(_Heap_Block_at(next_block, next_size)); if ( !_Heap_Is_prev_used( the_block ) ) { 10e092: 80 e1 01 and $0x1,%cl 10e095: 75 56 jne 10e0ed <_Heap_Free+0xf1> uint32_t const prev_size = the_block->prev_size; 10e097: 8b 0b mov (%ebx),%ecx 10e099: 29 cb sub %ecx,%ebx Heap_Block *const prev_block = _Heap_Block_at( the_block, -prev_size ); if ( !_Heap_Is_block_in( the_heap, prev_block ) ) { 10e09b: 3b 5d e4 cmp -0x1c(%ebp),%ebx 10e09e: 0f 93 c2 setae %dl 10e0a1: 3b 5d e0 cmp -0x20(%ebp),%ebx 10e0a4: 0f 96 c0 setbe %al 10e0a7: 84 d0 test %dl,%al 10e0a9: 0f 84 a9 00 00 00 je 10e158 <_Heap_Free+0x15c> <== 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) ) { 10e0af: f6 43 04 01 testb $0x1,0x4(%ebx) 10e0b3: 0f 84 9f 00 00 00 je 10e158 <_Heap_Free+0x15c> <== NEVER TAKEN _HAssert( FALSE ); return( FALSE ); } if ( next_is_free ) { /* coalesce both */ 10e0b9: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) 10e0bd: 74 19 je 10e0d8 <_Heap_Free+0xdc> uint32_t const size = the_size + prev_size + next_size; 10e0bf: 8b 55 e8 mov -0x18(%ebp),%edx 10e0c2: 03 55 ec add -0x14(%ebp),%edx 10e0c5: 01 ca add %ecx,%edx * Any other value of @a alignment is taken "as is", i.e., even odd * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon 10e0c7: 8b 4e 08 mov 0x8(%esi),%ecx * @param[in] size is the amount of memory to allocate in bytes 10e0ca: 8b 46 0c mov 0xc(%esi),%eax * @param[in] alignment the required alignment 10e0cd: 89 48 08 mov %ecx,0x8(%eax) * @return NULL if unsuccessful and a pointer to the block if successful 10e0d0: 89 41 0c mov %eax,0xc(%ecx) _Heap_Block_remove( next_block ); stats->free_blocks -= 1; 10e0d3: ff 4f 38 decl 0x38(%edi) 10e0d6: eb 33 jmp 10e10b <_Heap_Free+0x10f> next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; } else { /* coalesce prev */ uint32_t const size = the_size + prev_size; 10e0d8: 8b 55 e8 mov -0x18(%ebp),%edx 10e0db: 01 ca add %ecx,%edx prev_block->size = size | HEAP_PREV_USED; 10e0dd: 89 d0 mov %edx,%eax 10e0df: 83 c8 01 or $0x1,%eax 10e0e2: 89 43 04 mov %eax,0x4(%ebx) next_block->size &= ~HEAP_PREV_USED; 10e0e5: 83 66 04 fe andl $0xfffffffe,0x4(%esi) next_block->prev_size = size; 10e0e9: 89 16 mov %edx,(%esi) 10e0eb: eb 5b jmp 10e148 <_Heap_Free+0x14c> } } else if ( next_is_free ) { /* coalesce next */ 10e0ed: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) 10e0f1: 74 25 je 10e118 <_Heap_Free+0x11c> uint32_t const size = the_size + next_size; 10e0f3: 8b 55 ec mov -0x14(%ebp),%edx 10e0f6: 03 55 e8 add -0x18(%ebp),%edx * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ 10e0f9: 8b 4e 08 mov 0x8(%esi),%ecx bool _Protected_heap_Get_block_size( 10e0fc: 8b 46 0c mov 0xc(%esi),%eax Heap_Control *the_heap, void *starting_address, size_t *size 10e0ff: 89 4b 08 mov %ecx,0x8(%ebx) ); 10e102: 89 43 0c mov %eax,0xc(%ebx) 10e105: 89 58 08 mov %ebx,0x8(%eax) 10e108: 89 59 0c mov %ebx,0xc(%ecx) _Heap_Block_replace( next_block, the_block ); the_block->size = size | HEAP_PREV_USED; 10e10b: 89 d0 mov %edx,%eax 10e10d: 83 c8 01 or $0x1,%eax 10e110: 89 43 04 mov %eax,0x4(%ebx) next_block = _Heap_Block_at( the_block, size ); next_block->prev_size = size; 10e113: 89 14 13 mov %edx,(%ebx,%edx,1) 10e116: eb 30 jmp 10e148 <_Heap_Free+0x14c> bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ); 10e118: 8b 47 08 mov 0x8(%edi),%eax /** 10e11b: 89 43 08 mov %eax,0x8(%ebx) * This routine returns the block of memory which begins 10e11e: 89 7b 0c mov %edi,0xc(%ebx) * at @a starting_address to @a the_heap. Any coalescing which is 10e121: 89 5f 08 mov %ebx,0x8(%edi) 10e124: 89 58 0c mov %ebx,0xc(%eax) } else { /* no coalesce */ /* Add 'the_block' to the head of the free blocks list as it tends to produce less fragmentation than adding to the tail. */ _Heap_Block_insert_after( _Heap_Head( the_heap), the_block ); the_block->size = the_size | HEAP_PREV_USED; 10e127: 8b 45 e8 mov -0x18(%ebp),%eax 10e12a: 83 c8 01 or $0x1,%eax 10e12d: 89 43 04 mov %eax,0x4(%ebx) next_block->size &= ~HEAP_PREV_USED; 10e130: 83 66 04 fe andl $0xfffffffe,0x4(%esi) next_block->prev_size = the_size; 10e134: 8b 45 e8 mov -0x18(%ebp),%eax 10e137: 89 06 mov %eax,(%esi) stats->free_blocks += 1; 10e139: 8b 47 38 mov 0x38(%edi),%eax 10e13c: 40 inc %eax 10e13d: 89 47 38 mov %eax,0x38(%edi) if ( stats->max_free_blocks < stats->free_blocks ) 10e140: 39 47 3c cmp %eax,0x3c(%edi) 10e143: 73 03 jae 10e148 <_Heap_Free+0x14c> stats->max_free_blocks = stats->free_blocks; 10e145: 89 47 3c mov %eax,0x3c(%edi) } stats->used_blocks -= 1; 10e148: ff 4f 40 decl 0x40(%edi) stats->free_size += the_size; 10e14b: 8b 55 e8 mov -0x18(%ebp),%edx 10e14e: 01 57 30 add %edx,0x30(%edi) stats->frees += 1; 10e151: ff 47 50 incl 0x50(%edi) 10e154: b0 01 mov $0x1,%al 10e156: eb 02 jmp 10e15a <_Heap_Free+0x15e> return( TRUE ); 10e158: 31 c0 xor %eax,%eax } 10e15a: 83 c4 14 add $0x14,%esp 10e15d: 5b pop %ebx 10e15e: 5e pop %esi 10e15f: 5f pop %edi 10e160: c9 leave 10e161: c3 ret =============================================================================== 0010ffe0 <_Heap_Get_free_information>: void _Heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 10ffe0: 55 push %ebp 10ffe1: 89 e5 mov %esp,%ebp 10ffe3: 53 push %ebx 10ffe4: 8b 5d 08 mov 0x8(%ebp),%ebx 10ffe7: 8b 55 0c mov 0xc(%ebp),%edx Heap_Block *the_block; Heap_Block *const tail = _Heap_Tail(the_heap); info->number = 0; 10ffea: c7 02 00 00 00 00 movl $0x0,(%edx) info->largest = 0; 10fff0: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) info->total = 0; 10fff7: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) ) { return ( the_thread == _Thread_Heir ); } /** 10fffe: 8b 4b 08 mov 0x8(%ebx),%ecx 110001: eb 16 jmp 110019 <_Heap_Get_free_information+0x39> 110003: 8b 41 04 mov 0x4(%ecx),%eax 110006: 83 e0 fe and $0xfffffffe,%eax uint32_t const the_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); info->number++; 110009: ff 02 incl (%edx) info->total += the_size; 11000b: 01 42 08 add %eax,0x8(%edx) if ( info->largest < the_size ) 11000e: 39 42 04 cmp %eax,0x4(%edx) 110011: 73 03 jae 110016 <_Heap_Get_free_information+0x36><== NEVER TAKEN info->largest = the_size; 110013: 89 42 04 mov %eax,0x4(%edx) info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; the_block = the_block->next) 110016: 8b 49 08 mov 0x8(%ecx),%ecx info->number = 0; info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; 110019: 39 d9 cmp %ebx,%ecx 11001b: 75 e6 jne 110003 <_Heap_Get_free_information+0x23> info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 11001d: 5b pop %ebx 11001e: c9 leave 11001f: c3 ret =============================================================================== 00110020 <_Heap_Get_information>: Heap_Get_information_status _Heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 110020: 55 push %ebp 110021: 89 e5 mov %esp,%ebp 110023: 53 push %ebx 110024: 8b 45 08 mov 0x8(%ebp),%eax 110027: 8b 55 0c mov 0xc(%ebp),%edx Heap_Block *the_block = the_heap->start; 11002a: 8b 48 20 mov 0x20(%eax),%ecx Heap_Block *const end = the_heap->final; 11002d: 8b 58 24 mov 0x24(%eax),%ebx _HAssert(the_block->prev_size == HEAP_PREV_USED); _HAssert(_Heap_Is_prev_used(the_block)); the_info->Free.number = 0; 110030: c7 02 00 00 00 00 movl $0x0,(%edx) the_info->Free.total = 0; 110036: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) the_info->Free.largest = 0; 11003d: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) the_info->Used.number = 0; 110044: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) the_info->Used.total = 0; 11004b: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx) the_info->Used.largest = 0; 110052: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) 110059: eb 36 jmp 110091 <_Heap_Get_information+0x71> 11005b: 8b 41 04 mov 0x4(%ecx),%eax 11005e: 83 e0 fe and $0xfffffffe,%eax /** @brief _Thread_Is_proxy_blocking * * status which indicates that a proxy is blocking, and FALSE otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking ( uint32_t code 110061: 01 c1 add %eax,%ecx while ( the_block != end ) { uint32_t const the_size = _Heap_Block_size(the_block); Heap_Block *const next_block = _Heap_Block_at(the_block, the_size); if ( _Heap_Is_prev_used(next_block) ) { 110063: f6 41 04 01 testb $0x1,0x4(%ecx) 110067: 74 10 je 110079 <_Heap_Get_information+0x59> the_info->Used.number++; 110069: ff 42 0c incl 0xc(%edx) the_info->Used.total += the_size; 11006c: 01 42 14 add %eax,0x14(%edx) if ( the_info->Used.largest < the_size ) 11006f: 39 42 10 cmp %eax,0x10(%edx) 110072: 73 1d jae 110091 <_Heap_Get_information+0x71> the_info->Used.largest = the_size; 110074: 89 42 10 mov %eax,0x10(%edx) 110077: eb 18 jmp 110091 <_Heap_Get_information+0x71> } else { the_info->Free.number++; 110079: ff 02 incl (%edx) the_info->Free.total += the_size; 11007b: 01 42 08 add %eax,0x8(%edx) if ( the_info->Free.largest < the_size ) 11007e: 39 42 04 cmp %eax,0x4(%edx) 110081: 73 03 jae 110086 <_Heap_Get_information+0x66><== NEVER TAKEN the_info->Free.largest = the_size; 110083: 89 42 04 mov %eax,0x4(%edx) if ( the_size != next_block->prev_size ) 110086: 3b 01 cmp (%ecx),%eax 110088: 74 07 je 110091 <_Heap_Get_information+0x71><== ALWAYS TAKEN 11008a: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 11008f: eb 0a jmp 11009b <_Heap_Get_information+0x7b><== NOT EXECUTED the_info->Free.largest = 0; the_info->Used.number = 0; the_info->Used.total = 0; the_info->Used.largest = 0; while ( the_block != end ) { 110091: 39 d9 cmp %ebx,%ecx 110093: 75 c6 jne 11005b <_Heap_Get_information+0x3b> } /* Handle the last dummy block. Don't consider this block to be "used" as client never allocated it. Make 'Used.total' contain this blocks' overhead though. */ the_info->Used.total += HEAP_OVERHEAD; 110095: 83 42 14 08 addl $0x8,0x14(%edx) 110099: 31 c0 xor %eax,%eax return HEAP_GET_INFORMATION_SUCCESSFUL; } 11009b: 5b pop %ebx 11009c: c9 leave 11009d: c3 ret =============================================================================== 0010a02c <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 10a02c: 55 push %ebp 10a02d: 89 e5 mov %esp,%ebp 10a02f: 57 push %edi 10a030: 56 push %esi 10a031: 53 push %ebx 10a032: 83 ec 0c sub $0xc,%esp 10a035: 8b 75 08 mov 0x8(%ebp),%esi 10a038: 8b 7d 0c mov 0xc(%ebp),%edi 10a03b: 8b 4d 14 mov 0x14(%ebp),%ecx _H_uptr_t start; _H_uptr_t aligned_start; uint32_t overhead; Heap_Statistics *const stats = &the_heap->stats; if (page_size == 0) 10a03e: 85 c9 test %ecx,%ecx 10a040: 75 04 jne 10a046 <_Heap_Initialize+0x1a> 10a042: b1 04 mov $0x4,%cl 10a044: eb 0c jmp 10a052 <_Heap_Initialize+0x26> * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area * * @return true if successfully able to return information */ 10a046: 89 c8 mov %ecx,%eax 10a048: 83 e0 03 and $0x3,%eax 10a04b: 74 05 je 10a052 <_Heap_Initialize+0x26> 10a04d: 83 c1 04 add $0x4,%ecx 10a050: 29 c1 sub %eax,%ecx /* Calculate aligned_start so that aligned_start + HEAP_BLOCK_USER_OFFSET (value of user pointer) is aligned on 'page_size' boundary. Make sure resulting 'aligned_start' is not below 'starting_address'. */ start = _H_p2u(starting_address); aligned_start = start + HEAP_BLOCK_USER_OFFSET; 10a052: 8d 5f 08 lea 0x8(%edi),%ebx 10a055: 89 d8 mov %ebx,%eax 10a057: 31 d2 xor %edx,%edx 10a059: f7 f1 div %ecx 10a05b: 85 d2 test %edx,%edx 10a05d: 74 05 je 10a064 <_Heap_Initialize+0x38> 10a05f: 8d 1c 19 lea (%ecx,%ebx,1),%ebx 10a062: 29 d3 sub %edx,%ebx _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 10a064: 83 eb 08 sub $0x8,%ebx * sizes. * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area * * @return true if successfully able to return information 10a067: b8 10 00 00 00 mov $0x10,%eax 10a06c: 31 d2 xor %edx,%edx 10a06e: f7 f1 div %ecx */ 10a070: b8 10 00 00 00 mov $0x10,%eax 10a075: 85 d2 test %edx,%edx 10a077: 74 05 je 10a07e <_Heap_Initialize+0x52> 10a079: 8d 41 10 lea 0x10(%ecx),%eax 10a07c: 29 d0 sub %edx,%eax 10a07e: 89 46 14 mov %eax,0x14(%esi) /* Calculate 'the_size' -- size of the first block so that there is enough space at the end for the permanent last block. It is equal to 'size' minus total overhead aligned down to the nearest multiple of 'page_size'. */ overhead = HEAP_OVERHEAD + (aligned_start - start); 10a081: 89 d8 mov %ebx,%eax 10a083: 29 f8 sub %edi,%eax 10a085: 83 c0 08 add $0x8,%eax if ( size < overhead ) 10a088: 39 45 10 cmp %eax,0x10(%ebp) 10a08b: 0f 82 a0 00 00 00 jb 10a131 <_Heap_Initialize+0x105> return 0; /* Too small area for the heap */ the_size = size - overhead; 10a091: 8b 55 10 mov 0x10(%ebp),%edx 10a094: 29 c2 sub %eax,%edx 10a096: 89 55 e8 mov %edx,-0x18(%ebp) * * @return free block information filled in. */ bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info 10a099: 89 d0 mov %edx,%eax 10a09b: 31 d2 xor %edx,%edx 10a09d: f7 f1 div %ecx _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) 10a09f: 8b 45 e8 mov -0x18(%ebp),%eax 10a0a2: 29 d0 sub %edx,%eax 10a0a4: 89 c2 mov %eax,%edx 10a0a6: 0f 84 85 00 00 00 je 10a131 <_Heap_Initialize+0x105><== NEVER TAKEN return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 10a0ac: 89 4e 10 mov %ecx,0x10(%esi) the_heap->begin = starting_address; 10a0af: 89 7e 18 mov %edi,0x18(%esi) the_heap->end = starting_address + size; 10a0b2: 03 7d 10 add 0x10(%ebp),%edi 10a0b5: 89 7e 1c mov %edi,0x1c(%esi) the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; 10a0b8: 89 0b mov %ecx,(%ebx) the_block->size = the_size | HEAP_PREV_USED; 10a0ba: 83 c8 01 or $0x1,%eax 10a0bd: 89 43 04 mov %eax,0x4(%ebx) the_block->next = _Heap_Tail( the_heap ); 10a0c0: 89 73 08 mov %esi,0x8(%ebx) the_block->prev = _Heap_Head( the_heap ); 10a0c3: 89 73 0c mov %esi,0xc(%ebx) _Heap_Head(the_heap)->next = the_block; 10a0c6: 89 5e 08 mov %ebx,0x8(%esi) _Heap_Tail(the_heap)->prev = the_block; 10a0c9: 89 5e 0c mov %ebx,0xc(%esi) the_heap->start = the_block; 10a0cc: 89 5e 20 mov %ebx,0x20(%esi) * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 10a0cf: 8d 04 13 lea (%ebx,%edx,1),%eax _HAssert(_Heap_Is_aligned(the_heap->page_size, CPU_ALIGNMENT)); _HAssert(_Heap_Is_aligned(the_heap->min_block_size, page_size)); _HAssert(_Heap_Is_aligned_ptr(_Heap_User_area(the_block), page_size)); the_block = _Heap_Block_at( the_block, the_size ); the_heap->final = the_block; /* Permanent final block of the heap */ 10a0d2: 89 46 24 mov %eax,0x24(%esi) the_block->prev_size = the_size; /* Previous block is free */ 10a0d5: 89 10 mov %edx,(%eax) the_block->size = page_size; 10a0d7: 89 48 04 mov %ecx,0x4(%eax) stats->size = size; 10a0da: 8b 45 10 mov 0x10(%ebp),%eax 10a0dd: 89 46 2c mov %eax,0x2c(%esi) stats->free_size = the_size; 10a0e0: 89 56 30 mov %edx,0x30(%esi) stats->min_free_size = the_size; 10a0e3: 89 56 34 mov %edx,0x34(%esi) stats->free_blocks = 1; 10a0e6: c7 46 38 01 00 00 00 movl $0x1,0x38(%esi) stats->max_free_blocks = 1; 10a0ed: c7 46 3c 01 00 00 00 movl $0x1,0x3c(%esi) stats->used_blocks = 0; 10a0f4: c7 46 40 00 00 00 00 movl $0x0,0x40(%esi) stats->max_search = 0; 10a0fb: c7 46 44 00 00 00 00 movl $0x0,0x44(%esi) stats->allocs = 0; 10a102: c7 46 48 00 00 00 00 movl $0x0,0x48(%esi) stats->searches = 0; 10a109: c7 46 4c 00 00 00 00 movl $0x0,0x4c(%esi) stats->frees = 0; 10a110: c7 46 50 00 00 00 00 movl $0x0,0x50(%esi) stats->resizes = 0; 10a117: c7 46 54 00 00 00 00 movl $0x0,0x54(%esi) stats->instance = instance++; 10a11e: a1 4c d5 11 00 mov 0x11d54c,%eax 10a123: 89 46 28 mov %eax,0x28(%esi) 10a126: 40 inc %eax 10a127: a3 4c d5 11 00 mov %eax,0x11d54c return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 10a12c: 8d 42 fc lea -0x4(%edx),%eax 10a12f: eb 02 jmp 10a133 <_Heap_Initialize+0x107> 10a131: 31 c0 xor %eax,%eax } 10a133: 83 c4 0c add $0xc,%esp 10a136: 5b pop %ebx 10a137: 5e pop %esi 10a138: 5f pop %edi 10a139: c9 leave 10a13a: c3 ret =============================================================================== 00115a54 <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 115a54: 55 push %ebp 115a55: 89 e5 mov %esp,%ebp 115a57: 57 push %edi 115a58: 56 push %esi 115a59: 53 push %ebx 115a5a: 83 ec 2c sub $0x2c,%esp Heap_Block *next_next_block; uint32_t old_block_size; uint32_t old_user_size; uint32_t prev_used_flag; Heap_Statistics *const stats = &the_heap->stats; uint32_t const min_block_size = the_heap->min_block_size; 115a5d: 8b 45 08 mov 0x8(%ebp),%eax 115a60: 8b 40 14 mov 0x14(%eax),%eax 115a63: 89 45 ec mov %eax,-0x14(%ebp) uint32_t const page_size = the_heap->page_size; 115a66: 8b 55 08 mov 0x8(%ebp),%edx 115a69: 8b 72 10 mov 0x10(%edx),%esi *old_mem_size = 0; 115a6c: 8b 4d 14 mov 0x14(%ebp),%ecx 115a6f: c7 01 00 00 00 00 movl $0x0,(%ecx) *avail_mem_size = 0; 115a75: 8b 45 18 mov 0x18(%ebp),%eax 115a78: c7 00 00 00 00 00 movl $0x0,(%eax) 115a7e: 8b 55 0c mov 0xc(%ebp),%edx 115a81: 83 ea 08 sub $0x8,%edx 115a84: 89 55 f0 mov %edx,-0x10(%ebp) 115a87: 8b 45 0c mov 0xc(%ebp),%eax 115a8a: 8b 4d 08 mov 0x8(%ebp),%ecx 115a8d: 31 d2 xor %edx,%edx 115a8f: f7 71 10 divl 0x10(%ecx) 115a92: 29 55 f0 sub %edx,-0x10(%ebp) 115a95: 89 c8 mov %ecx,%eax 115a97: 8b 49 24 mov 0x24(%ecx),%ecx 115a9a: 8b 58 20 mov 0x20(%eax),%ebx _Heap_Start_of_block(the_heap, starting_address, &the_block); _HAssert(_Heap_Is_block_in(the_heap, the_block)); if (!_Heap_Is_block_in(the_heap, the_block)) 115a9d: 39 5d f0 cmp %ebx,-0x10(%ebp) 115aa0: 0f 93 c2 setae %dl 115aa3: 39 4d f0 cmp %ecx,-0x10(%ebp) 115aa6: 0f 96 c0 setbe %al 115aa9: 84 d0 test %dl,%al 115aab: 0f 84 7e 01 00 00 je 115c2f <_Heap_Resize_block+0x1db> return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 115ab1: 8b 55 f0 mov -0x10(%ebp),%edx 115ab4: 8b 52 04 mov 0x4(%edx),%edx 115ab7: 89 55 d8 mov %edx,-0x28(%ebp) 115aba: 83 e2 fe and $0xfffffffe,%edx 115abd: 89 55 e4 mov %edx,-0x1c(%ebp) 115ac0: 8b 7d f0 mov -0x10(%ebp),%edi 115ac3: 01 d7 add %edx,%edi old_block_size = _Heap_Block_size(the_block); next_block = _Heap_Block_at(the_block, old_block_size); _HAssert(_Heap_Is_block_in(the_heap, next_block)); _HAssert(_Heap_Is_prev_used(next_block)); if ( !_Heap_Is_block_in(the_heap, next_block) || 115ac5: 39 df cmp %ebx,%edi 115ac7: 0f 93 c2 setae %dl 115aca: 39 cf cmp %ecx,%edi 115acc: 0f 96 c0 setbe %al 115acf: 84 d0 test %dl,%al 115ad1: 0f 84 58 01 00 00 je 115c2f <_Heap_Resize_block+0x1db><== NEVER TAKEN 115ad7: 8b 47 04 mov 0x4(%edi),%eax 115ada: a8 01 test $0x1,%al 115adc: 0f 84 4d 01 00 00 je 115c2f <_Heap_Resize_block+0x1db><== NEVER TAKEN 115ae2: 83 e0 fe and $0xfffffffe,%eax 115ae5: 89 45 dc mov %eax,-0x24(%ebp) 115ae8: 01 f8 add %edi,%eax 115aea: 89 45 e0 mov %eax,-0x20(%ebp) !_Heap_Is_prev_used(next_block)) return HEAP_RESIZE_FATAL_ERROR; next_block_size = _Heap_Block_size(next_block); next_next_block = _Heap_Block_at(next_block, next_block_size); next_is_used = (next_block == the_heap->final) || 115aed: b8 01 00 00 00 mov $0x1,%eax 115af2: 39 cf cmp %ecx,%edi 115af4: 74 09 je 115aff <_Heap_Resize_block+0xab><== NEVER TAKEN 115af6: 8b 4d e0 mov -0x20(%ebp),%ecx 115af9: 8b 41 04 mov 0x4(%ecx),%eax 115afc: 83 e0 01 and $0x1,%eax _Heap_Start_of_block(the_heap, starting_address, &the_block); _HAssert(_Heap_Is_block_in(the_heap, the_block)); if (!_Heap_Is_block_in(the_heap, the_block)) return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 115aff: 8b 55 d8 mov -0x28(%ebp),%edx 115b02: 83 e2 01 and $0x1,%edx 115b05: 89 55 e8 mov %edx,-0x18(%ebp) !_Heap_Is_prev_used(next_block)) return HEAP_RESIZE_FATAL_ERROR; next_block_size = _Heap_Block_size(next_block); next_next_block = _Heap_Block_at(next_block, next_block_size); next_is_used = (next_block == the_heap->final) || 115b08: 88 c1 mov %al,%cl _Heap_Is_prev_used(next_next_block); /* See _Heap_Size_of_user_area() source for explanations */ old_user_size = _Addresses_Subtract(next_block, starting_address) 115b0a: 89 f8 mov %edi,%eax 115b0c: 2b 45 0c sub 0xc(%ebp),%eax 115b0f: 83 c0 04 add $0x4,%eax + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 115b12: 8b 55 14 mov 0x14(%ebp),%edx 115b15: 89 02 mov %eax,(%edx) if (size > old_user_size) { 115b17: 39 45 10 cmp %eax,0x10(%ebp) 115b1a: 76 50 jbe 115b6c <_Heap_Resize_block+0x118> /* Need to extend the block: allocate part of the next block and then merge 'the_block' and allocated block together. */ if (next_is_used) /* Next block is in use, -- no way to extend */ 115b1c: 84 c9 test %cl,%cl 115b1e: 0f 85 12 01 00 00 jne 115c36 <_Heap_Resize_block+0x1e2> return HEAP_RESIZE_UNSATISFIED; else { uint32_t add_block_size = size - old_user_size; 115b24: 8b 4d 10 mov 0x10(%ebp),%ecx 115b27: 29 c1 sub %eax,%ecx 115b29: 89 c8 mov %ecx,%eax 115b2b: 31 d2 xor %edx,%edx 115b2d: f7 f6 div %esi 115b2f: 85 d2 test %edx,%edx 115b31: 74 04 je 115b37 <_Heap_Resize_block+0xe3><== NEVER TAKEN 115b33: 01 f1 add %esi,%ecx 115b35: 29 d1 sub %edx,%ecx 115b37: 89 c8 mov %ecx,%eax 115b39: 3b 4d ec cmp -0x14(%ebp),%ecx 115b3c: 73 03 jae 115b41 <_Heap_Resize_block+0xed><== NEVER TAKEN 115b3e: 8b 45 ec mov -0x14(%ebp),%eax _Heap_Align_up(&add_block_size, page_size); if (add_block_size < min_block_size) add_block_size = min_block_size; if (add_block_size > next_block_size) 115b41: 3b 45 dc cmp -0x24(%ebp),%eax 115b44: 0f 87 ec 00 00 00 ja 115c36 <_Heap_Resize_block+0x1e2><== NEVER TAKEN return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */ add_block_size = 115b4a: 53 push %ebx 115b4b: 50 push %eax 115b4c: 57 push %edi 115b4d: ff 75 08 pushl 0x8(%ebp) 115b50: e8 23 46 ff ff call 10a178 <_Heap_Block_allocate> _Heap_Block_allocate(the_heap, next_block, add_block_size); /* Merge two subsequent blocks */ the_block->size = (old_block_size + add_block_size) | prev_used_flag; 115b55: 03 45 e4 add -0x1c(%ebp),%eax 115b58: 0b 45 e8 or -0x18(%ebp),%eax 115b5b: 8b 55 f0 mov -0x10(%ebp),%edx 115b5e: 89 42 04 mov %eax,0x4(%edx) --stats->used_blocks; 115b61: 8b 4d 08 mov 0x8(%ebp),%ecx 115b64: ff 49 40 decl 0x40(%ecx) 115b67: e9 b6 00 00 00 jmp 115c22 <_Heap_Resize_block+0x1ce> } } else { /* Calculate how much memory we could free */ uint32_t free_block_size = old_user_size - size; 115b6c: 89 c3 mov %eax,%ebx 115b6e: 2b 5d 10 sub 0x10(%ebp),%ebx 115b71: 89 d8 mov %ebx,%eax 115b73: 31 d2 xor %edx,%edx 115b75: f7 f6 div %esi _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 115b77: 89 de mov %ebx,%esi 115b79: 29 d6 sub %edx,%esi 115b7b: 0f 84 a4 00 00 00 je 115c25 <_Heap_Resize_block+0x1d1> /* To free some memory the block should be shortened so that it can can hold 'size' user bytes and still remain not shorter than 'min_block_size'. */ uint32_t new_block_size = old_block_size - free_block_size; 115b81: 8b 5d e4 mov -0x1c(%ebp),%ebx 115b84: 29 f3 sub %esi,%ebx if (new_block_size < min_block_size) { 115b86: 3b 5d ec cmp -0x14(%ebp),%ebx 115b89: 73 16 jae 115ba1 <_Heap_Resize_block+0x14d> uint32_t delta = min_block_size - new_block_size; 115b8b: 8b 45 ec mov -0x14(%ebp),%eax 115b8e: 29 d8 sub %ebx,%eax _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 115b90: 29 c6 sub %eax,%esi 115b92: 75 0b jne 115b9f <_Heap_Resize_block+0x14b><== NEVER TAKEN ++stats->resizes; 115b94: 8b 55 08 mov 0x8(%ebp),%edx 115b97: ff 42 54 incl 0x54(%edx) 115b9a: e9 8c 00 00 00 jmp 115c2b <_Heap_Resize_block+0x1d7> return HEAP_RESIZE_SUCCESSFUL; } new_block_size += delta; 115b9f: 01 c3 add %eax,%ebx <== NOT EXECUTED _HAssert(new_block_size >= min_block_size); _HAssert(new_block_size + free_block_size == old_block_size); _HAssert(_Heap_Is_aligned(new_block_size, page_size)); _HAssert(_Heap_Is_aligned(free_block_size, page_size)); if (!next_is_used) { 115ba1: 84 c9 test %cl,%cl 115ba3: 75 43 jne 115be8 <_Heap_Resize_block+0x194><== NEVER TAKEN 115ba5: 8b 55 f0 mov -0x10(%ebp),%edx 115ba8: 01 da add %ebx,%edx /* Extend the next block to the low addresses by 'free_block_size' */ Heap_Block *const new_next_block = _Heap_Block_at(the_block, new_block_size); uint32_t const new_next_block_size = next_block_size + free_block_size; 115baa: 8b 45 dc mov -0x24(%ebp),%eax 115bad: 8d 0c 06 lea (%esi,%eax,1),%ecx _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; 115bb0: 0b 5d e8 or -0x18(%ebp),%ebx 115bb3: 8b 45 f0 mov -0x10(%ebp),%eax 115bb6: 89 58 04 mov %ebx,0x4(%eax) new_next_block->size = new_next_block_size | HEAP_PREV_USED; 115bb9: 89 c8 mov %ecx,%eax 115bbb: 83 c8 01 or $0x1,%eax 115bbe: 89 42 04 mov %eax,0x4(%edx) next_next_block->prev_size = new_next_block_size; 115bc1: 8b 45 e0 mov -0x20(%ebp),%eax 115bc4: 89 08 mov %ecx,(%eax) { return (state == SYSTEM_STATE_FAILED); } /**@}*/ 115bc6: 8b 5f 08 mov 0x8(%edi),%ebx #endif 115bc9: 8b 47 0c mov 0xc(%edi),%eax /* end of include file */ 115bcc: 89 5a 08 mov %ebx,0x8(%edx) 115bcf: 89 42 0c mov %eax,0xc(%edx) 115bd2: 89 50 08 mov %edx,0x8(%eax) 115bd5: 89 53 0c mov %edx,0xc(%ebx) _Heap_Block_replace(next_block, new_next_block); the_heap->stats.free_size += free_block_size; 115bd8: 8b 55 08 mov 0x8(%ebp),%edx 115bdb: 01 72 30 add %esi,0x30(%edx) *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 115bde: 83 e9 04 sub $0x4,%ecx 115be1: 8b 45 18 mov 0x18(%ebp),%eax 115be4: 89 08 mov %ecx,(%eax) 115be6: eb 3d jmp 115c25 <_Heap_Resize_block+0x1d1> } else if (free_block_size >= min_block_size) { 115be8: 3b 75 ec cmp -0x14(%ebp),%esi <== NOT EXECUTED 115beb: 72 38 jb 115c25 <_Heap_Resize_block+0x1d1><== NOT EXECUTED /* Split the block into 2 used parts, then free the second one. */ the_block->size = new_block_size | prev_used_flag; 115bed: 09 5d e8 or %ebx,-0x18(%ebp) <== NOT EXECUTED 115bf0: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 115bf3: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 115bf6: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED 115bf9: 89 d0 mov %edx,%eax <== NOT EXECUTED 115bfb: 01 d8 add %ebx,%eax <== NOT EXECUTED next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; 115bfd: 89 f2 mov %esi,%edx <== NOT EXECUTED 115bff: 83 ca 01 or $0x1,%edx <== NOT EXECUTED 115c02: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 115c05: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 115c08: ff 42 40 incl 0x40(%edx) <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 115c0b: ff 4a 50 decl 0x50(%edx) <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 115c0e: 51 push %ecx <== NOT EXECUTED 115c0f: 51 push %ecx <== NOT EXECUTED 115c10: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 115c13: 50 push %eax <== NOT EXECUTED 115c14: 52 push %edx <== NOT EXECUTED 115c15: e8 e2 83 ff ff call 10dffc <_Heap_Free> <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 115c1a: 8d 46 fc lea -0x4(%esi),%eax <== NOT EXECUTED 115c1d: 8b 4d 18 mov 0x18(%ebp),%ecx <== NOT EXECUTED 115c20: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 115c22: 83 c4 10 add $0x10,%esp } } } ++stats->resizes; 115c25: 8b 45 08 mov 0x8(%ebp),%eax 115c28: ff 40 54 incl 0x54(%eax) 115c2b: 31 c0 xor %eax,%eax 115c2d: eb 0c jmp 115c3b <_Heap_Resize_block+0x1e7> return HEAP_RESIZE_SUCCESSFUL; 115c2f: b8 02 00 00 00 mov $0x2,%eax 115c34: eb 05 jmp 115c3b <_Heap_Resize_block+0x1e7> 115c36: b8 01 00 00 00 mov $0x1,%eax } 115c3b: 8d 65 f4 lea -0xc(%ebp),%esp 115c3e: 5b pop %ebx 115c3f: 5e pop %esi 115c40: 5f pop %edi 115c41: c9 leave 115c42: c3 ret =============================================================================== 00115c44 <_Heap_Size_of_user_area>: bool _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 115c44: 55 push %ebp 115c45: 89 e5 mov %esp,%ebp 115c47: 57 push %edi 115c48: 56 push %esi 115c49: 53 push %ebx 115c4a: 8b 75 08 mov 0x8(%ebp),%esi Heap_Block *the_block; Heap_Block *next_block; uint32_t the_size; if ( !_Addresses_Is_in_range( 115c4d: 8b 7e 24 mov 0x24(%esi),%edi 115c50: 8b 5e 20 mov 0x20(%esi),%ebx 115c53: 39 5d 0c cmp %ebx,0xc(%ebp) 115c56: 0f 93 c2 setae %dl 115c59: 39 7d 0c cmp %edi,0xc(%ebp) 115c5c: 0f 96 c0 setbe %al 115c5f: 84 d0 test %dl,%al 115c61: 74 49 je 115cac <_Heap_Size_of_user_area+0x68> 115c63: 8b 4d 0c mov 0xc(%ebp),%ecx 115c66: 83 e9 08 sub $0x8,%ecx 115c69: 8b 45 0c mov 0xc(%ebp),%eax 115c6c: 31 d2 xor %edx,%edx 115c6e: f7 76 10 divl 0x10(%esi) 115c71: 29 d1 sub %edx,%ecx return( FALSE ); _Heap_Start_of_block( the_heap, starting_address, &the_block ); _HAssert(_Heap_Is_block_in( the_heap, the_block )); if ( !_Heap_Is_block_in( the_heap, the_block ) ) 115c73: 39 d9 cmp %ebx,%ecx 115c75: 0f 93 c2 setae %dl 115c78: 39 f9 cmp %edi,%ecx 115c7a: 0f 96 c0 setbe %al 115c7d: 84 d0 test %dl,%al 115c7f: 74 2b je 115cac <_Heap_Size_of_user_area+0x68><== NEVER TAKEN 115c81: 8b 41 04 mov 0x4(%ecx),%eax 115c84: 83 e0 fe and $0xfffffffe,%eax 115c87: 01 c1 add %eax,%ecx the_size = _Heap_Block_size( the_block ); next_block = _Heap_Block_at( the_block, the_size ); _HAssert(_Heap_Is_block_in( the_heap, next_block )); _HAssert(_Heap_Is_prev_used( next_block )); if ( 115c89: 39 d9 cmp %ebx,%ecx 115c8b: 0f 93 c2 setae %dl 115c8e: 39 f9 cmp %edi,%ecx 115c90: 0f 96 c0 setbe %al 115c93: 84 d0 test %dl,%al 115c95: 74 15 je 115cac <_Heap_Size_of_user_area+0x68><== NEVER TAKEN 115c97: f6 41 04 01 testb $0x1,0x4(%ecx) 115c9b: 74 0f je 115cac <_Heap_Size_of_user_area+0x68><== NEVER TAKEN and then add correction equal to the offset of the 'size' field of the 'Heap_Block' structure. The correction is due to the fact that 'prev_size' field of the next block is actually used as user accessible area of 'the_block'. */ *size = _Addresses_Subtract ( next_block, starting_address ) 115c9d: 2b 4d 0c sub 0xc(%ebp),%ecx 115ca0: 8d 51 04 lea 0x4(%ecx),%edx 115ca3: 8b 45 10 mov 0x10(%ebp),%eax 115ca6: 89 10 mov %edx,(%eax) 115ca8: b0 01 mov $0x1,%al 115caa: eb 02 jmp 115cae <_Heap_Size_of_user_area+0x6a> + HEAP_BLOCK_HEADER_OFFSET; return( TRUE ); 115cac: 31 c0 xor %eax,%eax } 115cae: 5b pop %ebx 115caf: 5e pop %esi 115cb0: 5f pop %edi 115cb1: c9 leave 115cb2: c3 ret =============================================================================== 00110110 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 110110: 55 push %ebp 110111: 89 e5 mov %esp,%ebp 110113: 57 push %edi 110114: 56 push %esi 110115: 53 push %ebx 110116: 83 ec 1c sub $0x1c,%esp 110119: 8b 5d 0c mov 0xc(%ebp),%ebx Heap_Block *the_block = the_heap->start; 11011c: 8b 45 08 mov 0x8(%ebp),%eax 11011f: 8b 70 20 mov 0x20(%eax),%esi Heap_Block *const end = the_heap->final; 110122: 8b 50 24 mov 0x24(%eax),%edx 110125: 89 55 e8 mov %edx,-0x18(%ebp) /* if ( !_System_state_Is_up( _System_state_Get() ) ) return TRUE; */ if (source < 0) 110128: 85 db test %ebx,%ebx 11012a: 79 03 jns 11012f <_Heap_Walk+0x1f> <== ALWAYS TAKEN source = the_heap->stats.instance; 11012c: 8b 58 28 mov 0x28(%eax),%ebx <== NOT EXECUTED /* * Handle the 1st block */ if (!_Heap_Is_prev_used(the_block)) { 11012f: 31 c9 xor %ecx,%ecx 110131: f6 46 04 01 testb $0x1,0x4(%esi) 110135: 75 15 jne 11014c <_Heap_Walk+0x3c> <== ALWAYS TAKEN printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source); 110137: 50 push %eax <== NOT EXECUTED 110138: 50 push %eax <== NOT EXECUTED 110139: 53 push %ebx <== NOT EXECUTED 11013a: 68 18 bb 11 00 push $0x11bb18 <== NOT EXECUTED 11013f: e8 92 83 ff ff call 1084d6 <== NOT EXECUTED 110144: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 110149: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } if (the_block->prev_size != the_heap->page_size) { 11014c: 8b 06 mov (%esi),%eax 11014e: 8b 7d 08 mov 0x8(%ebp),%edi 110151: 3b 47 10 cmp 0x10(%edi),%eax 110154: 0f 84 38 01 00 00 je 110292 <_Heap_Walk+0x182> <== ALWAYS TAKEN printk("PASS: %d !prev_size of 1st block isn't page_size\n", source); 11015a: 50 push %eax <== NOT EXECUTED 11015b: 50 push %eax <== NOT EXECUTED 11015c: 53 push %ebx <== NOT EXECUTED 11015d: 68 4e bb 11 00 push $0x11bb4e <== NOT EXECUTED 110162: e8 6f 83 ff ff call 1084d6 <== NOT EXECUTED 110167: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 11016c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11016f: e9 1e 01 00 00 jmp 110292 <_Heap_Walk+0x182> <== NOT EXECUTED 110174: 8b 46 04 mov 0x4(%esi),%eax 110177: 89 45 f0 mov %eax,-0x10(%ebp) 11017a: 83 e0 fe and $0xfffffffe,%eax 11017d: 89 45 ec mov %eax,-0x14(%ebp) /** @brief _Thread_Is_proxy_blocking * * status which indicates that a proxy is blocking, and FALSE otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking ( uint32_t code 110180: 01 f0 add %esi,%eax 110182: 89 45 e0 mov %eax,-0x20(%ebp) printk(" prev_size %d", the_block->prev_size); else printk(" (prev_size) %d", the_block->prev_size); } if (!_Heap_Is_block_in(the_heap, next_block)) { 110185: 8b 55 08 mov 0x8(%ebp),%edx 110188: 3b 42 20 cmp 0x20(%edx),%eax 11018b: 0f 93 c2 setae %dl 11018e: 8b 7d 08 mov 0x8(%ebp),%edi 110191: 3b 47 24 cmp 0x24(%edi),%eax 110194: 0f 96 c0 setbe %al 110197: 84 d0 test %dl,%al 110199: 75 0f jne 1101aa <_Heap_Walk+0x9a> <== ALWAYS TAKEN if (do_dump) printk("\n"); printk("PASS: %d !block %p is out of heap\n", source, next_block); 11019b: 50 push %eax <== NOT EXECUTED 11019c: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 11019f: 53 push %ebx <== NOT EXECUTED 1101a0: 68 80 bb 11 00 push $0x11bb80 <== NOT EXECUTED 1101a5: e9 d7 00 00 00 jmp 110281 <_Heap_Walk+0x171> <== NOT EXECUTED error = 1; break; } if (!_Heap_Is_prev_used(next_block)) { 1101aa: 8b 45 e0 mov -0x20(%ebp),%eax 1101ad: f6 40 04 01 testb $0x1,0x4(%eax) 1101b1: 0f 85 85 00 00 00 jne 11023c <_Heap_Walk+0x12c> if (do_dump) printk( " prev %p next %p", the_block->prev, the_block->next); if (_Heap_Block_size(the_block) != next_block->prev_size) { 1101b7: 8b 55 ec mov -0x14(%ebp),%edx 1101ba: 3b 10 cmp (%eax),%edx 1101bc: 74 15 je 1101d3 <_Heap_Walk+0xc3> <== ALWAYS TAKEN if (do_dump) printk("\n"); printk("PASS: %d !front and back sizes don't match", source); 1101be: 50 push %eax <== NOT EXECUTED 1101bf: 50 push %eax <== NOT EXECUTED 1101c0: 53 push %ebx <== NOT EXECUTED 1101c1: 68 a3 bb 11 00 push $0x11bba3 <== NOT EXECUTED 1101c6: e8 0b 83 ff ff call 1084d6 <== NOT EXECUTED 1101cb: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 1101d0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } if (!prev_used) { 1101d3: f6 45 f0 01 testb $0x1,-0x10(%ebp) 1101d7: 75 29 jne 110202 <_Heap_Walk+0xf2> <== ALWAYS TAKEN if (do_dump || error) printk("\n"); 1101d9: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1101db: 74 10 je 1101ed <_Heap_Walk+0xdd> <== NOT EXECUTED 1101dd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1101e0: 68 75 b6 11 00 push $0x11b675 <== NOT EXECUTED 1101e5: e8 ec 82 ff ff call 1084d6 <== NOT EXECUTED 1101ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED printk("PASS: %d !two consecutive blocks are free", source); 1101ed: 57 push %edi <== NOT EXECUTED 1101ee: 57 push %edi <== NOT EXECUTED 1101ef: 53 push %ebx <== NOT EXECUTED 1101f0: 68 ce bb 11 00 push $0x11bbce <== NOT EXECUTED 1101f5: e8 dc 82 ff ff call 1084d6 <== NOT EXECUTED 1101fa: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 1101ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { return ( the_thread == _Thread_Heir ); } /** 110202: 8b 7d 08 mov 0x8(%ebp),%edi 110205: 8b 47 08 mov 0x8(%edi),%eax 110208: eb 03 jmp 11020d <_Heap_Walk+0xfd> } { /* Check if 'the_block' is in the free block list */ Heap_Block* block = _Heap_First(the_heap); while(block != the_block && block != tail) block = block->next; 11020a: 8b 40 08 mov 0x8(%eax),%eax error = 1; } { /* Check if 'the_block' is in the free block list */ Heap_Block* block = _Heap_First(the_heap); while(block != the_block && block != tail) 11020d: 39 f0 cmp %esi,%eax 11020f: 74 2b je 11023c <_Heap_Walk+0x12c> 110211: 3b 45 08 cmp 0x8(%ebp),%eax 110214: 75 f4 jne 11020a <_Heap_Walk+0xfa> <== ALWAYS TAKEN block = block->next; if(block != the_block) { if (do_dump || error) printk("\n"); 110216: 85 c9 test %ecx,%ecx <== NOT EXECUTED 110218: 74 10 je 11022a <_Heap_Walk+0x11a> <== NOT EXECUTED 11021a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11021d: 68 75 b6 11 00 push $0x11b675 <== NOT EXECUTED 110222: e8 af 82 ff ff call 1084d6 <== NOT EXECUTED 110227: 83 c4 10 add $0x10,%esp <== NOT EXECUTED printk("PASS: %d !the_block not in the free list", source); 11022a: 51 push %ecx <== NOT EXECUTED 11022b: 51 push %ecx <== NOT EXECUTED 11022c: 53 push %ebx <== NOT EXECUTED 11022d: 68 f8 bb 11 00 push $0x11bbf8 <== NOT EXECUTED 110232: e8 9f 82 ff ff call 1084d6 <== NOT EXECUTED 110237: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11023a: eb 04 jmp 110240 <_Heap_Walk+0x130> <== NOT EXECUTED error = 1; } } } if (do_dump || error) printk("\n"); 11023c: 85 c9 test %ecx,%ecx 11023e: 74 15 je 110255 <_Heap_Walk+0x145> <== ALWAYS TAKEN 110240: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110243: 68 75 b6 11 00 push $0x11b675 <== NOT EXECUTED 110248: e8 89 82 ff ff call 1084d6 <== NOT EXECUTED 11024d: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 110252: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (the_size < the_heap->min_block_size) { 110255: 8b 55 ec mov -0x14(%ebp),%edx 110258: 8b 45 08 mov 0x8(%ebp),%eax 11025b: 3b 50 14 cmp 0x14(%eax),%edx 11025e: 73 0a jae 11026a <_Heap_Walk+0x15a> <== ALWAYS TAKEN printk("PASS: %d !block size is too small\n", source); 110260: 52 push %edx <== NOT EXECUTED 110261: 52 push %edx <== NOT EXECUTED 110262: 53 push %ebx <== NOT EXECUTED 110263: 68 21 bc 11 00 push $0x11bc21 <== NOT EXECUTED 110268: eb 17 jmp 110281 <_Heap_Walk+0x171> <== NOT EXECUTED error = 1; break; } if (!_Heap_Is_aligned( the_size, the_heap->page_size)) { 11026a: 8b 45 ec mov -0x14(%ebp),%eax 11026d: 8b 7d 08 mov 0x8(%ebp),%edi 110270: 31 d2 xor %edx,%edx 110272: f7 77 10 divl 0x10(%edi) 110275: 85 d2 test %edx,%edx 110277: 74 12 je 11028b <_Heap_Walk+0x17b> <== ALWAYS TAKEN printk("PASS: %d !block size is misaligned\n", source); 110279: 50 push %eax <== NOT EXECUTED 11027a: 50 push %eax <== NOT EXECUTED 11027b: 53 push %ebx <== NOT EXECUTED 11027c: 68 44 bc 11 00 push $0x11bc44 <== NOT EXECUTED 110281: e8 50 82 ff ff call 1084d6 <== NOT EXECUTED 110286: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110289: eb 12 jmp 11029d <_Heap_Walk+0x18d> <== NOT EXECUTED error = 1; } if (++passes > (do_dump ? 10 : 0) && error) 11028b: 85 c9 test %ecx,%ecx 11028d: 75 0e jne 11029d <_Heap_Walk+0x18d> <== NEVER TAKEN break; 11028f: 8b 75 e0 mov -0x20(%ebp),%esi if (the_block->prev_size != the_heap->page_size) { printk("PASS: %d !prev_size of 1st block isn't page_size\n", source); error = 1; } while ( the_block != end ) { 110292: 3b 75 e8 cmp -0x18(%ebp),%esi 110295: 0f 85 d9 fe ff ff jne 110174 <_Heap_Walk+0x64> 11029b: eb 17 jmp 1102b4 <_Heap_Walk+0x1a4> the_block = next_block; } if (the_block != end) { printk("PASS: %d !last block address isn't equal to 'final' %p %p\n", 11029d: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 1102a0: 56 push %esi <== NOT EXECUTED 1102a1: 53 push %ebx <== NOT EXECUTED 1102a2: 68 68 bc 11 00 push $0x11bc68 <== NOT EXECUTED 1102a7: e8 2a 82 ff ff call 1084d6 <== NOT EXECUTED 1102ac: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 1102b1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1102b4: 8b 46 04 mov 0x4(%esi),%eax 1102b7: 83 e0 fe and $0xfffffffe,%eax source, the_block, end); error = 1; } if (_Heap_Block_size(the_block) != the_heap->page_size) { 1102ba: 8b 75 08 mov 0x8(%ebp),%esi 1102bd: 8b 56 10 mov 0x10(%esi),%edx 1102c0: 39 d0 cmp %edx,%eax 1102c2: 74 15 je 1102d9 <_Heap_Walk+0x1c9> <== ALWAYS TAKEN printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source, 1102c4: 52 push %edx <== NOT EXECUTED 1102c5: 50 push %eax <== NOT EXECUTED 1102c6: 53 push %ebx <== NOT EXECUTED 1102c7: 68 a3 bc 11 00 push $0x11bca3 <== NOT EXECUTED 1102cc: e8 05 82 ff ff call 1084d6 <== NOT EXECUTED 1102d1: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 1102d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1102d9: 88 c8 mov %cl,%al if(do_dump && error) _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 ); return error; } 1102db: 8d 65 f4 lea -0xc(%ebp),%esp 1102de: 5b pop %ebx 1102df: 5e pop %esi 1102e0: 5f pop %edi 1102e1: c9 leave 1102e2: c3 ret =============================================================================== 0010a1f4 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 10a1f4: 55 push %ebp 10a1f5: 89 e5 mov %esp,%ebp 10a1f7: 53 push %ebx 10a1f8: 83 ec 08 sub $0x8,%esp 10a1fb: 8b 55 08 mov 0x8(%ebp),%edx 10a1fe: 8b 45 0c mov 0xc(%ebp),%eax 10a201: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10a204: 89 15 40 d8 11 00 mov %edx,0x11d840 _Internal_errors_What_happened.is_internal = is_internal; 10a20a: a2 44 d8 11 00 mov %al,0x11d844 _Internal_errors_What_happened.the_error = the_error; 10a20f: 89 1d 48 d8 11 00 mov %ebx,0x11d848 _User_extensions_Fatal( the_source, is_internal, the_error ); 10a215: 53 push %ebx 10a216: 0f b6 c0 movzbl %al,%eax 10a219: 50 push %eax 10a21a: 52 push %edx 10a21b: e8 eb 18 00 00 call 10bb0b <_User_extensions_Fatal> * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10a220: c7 05 38 d9 11 00 05 movl $0x5,0x11d938 <== NOT EXECUTED 10a227: 00 00 00 _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10a22a: fa cli <== NOT EXECUTED 10a22b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a22d: f4 hlt <== NOT EXECUTED 10a22e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a231: eb fe jmp 10a231 <_Internal_error_Occurred+0x3d><== NOT EXECUTED =============================================================================== 0010a288 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10a288: 55 push %ebp 10a289: 89 e5 mov %esp,%ebp 10a28b: 56 push %esi 10a28c: 53 push %ebx 10a28d: 8b 5d 08 mov 0x8(%ebp),%ebx * If the application is using the optional manager stubs and * still attempts to create the object, the information block * should be all zeroed out because it is in the BSS. So let's * check that code for this manager is even present. */ if ( information->size == 0 ) 10a290: 31 c9 xor %ecx,%ecx 10a292: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 10a296: 74 59 je 10a2f1 <_Objects_Allocate+0x69><== 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 ); 10a298: 8d 73 20 lea 0x20(%ebx),%esi 10a29b: 83 ec 0c sub $0xc,%esp 10a29e: 56 push %esi 10a29f: e8 6c f8 ff ff call 109b10 <_Chain_Get> 10a2a4: 89 c1 mov %eax,%ecx if ( information->auto_extend ) { 10a2a6: 83 c4 10 add $0x10,%esp 10a2a9: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10a2ad: 74 42 je 10a2f1 <_Objects_Allocate+0x69> /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10a2af: 85 c0 test %eax,%eax 10a2b1: 75 1a jne 10a2cd <_Objects_Allocate+0x45> _Objects_Extend_information( information ); 10a2b3: 83 ec 0c sub $0xc,%esp 10a2b6: 53 push %ebx 10a2b7: e8 64 00 00 00 call 10a320 <_Objects_Extend_information> the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10a2bc: 89 34 24 mov %esi,(%esp) 10a2bf: e8 4c f8 ff ff call 109b10 <_Chain_Get> 10a2c4: 89 c1 mov %eax,%ecx } if ( the_object ) { 10a2c6: 83 c4 10 add $0x10,%esp 10a2c9: 85 c0 test %eax,%eax 10a2cb: 74 24 je 10a2f1 <_Objects_Allocate+0x69><== NEVER TAKEN uint32_t block; block = _Objects_Get_index( the_object->id ) - 10a2cd: 8b 41 08 mov 0x8(%ecx),%eax 10a2d0: 25 ff ff 00 00 and $0xffff,%eax 10a2d5: 8b 53 08 mov 0x8(%ebx),%edx 10a2d8: 81 e2 ff ff 00 00 and $0xffff,%edx 10a2de: 29 d0 sub %edx,%eax _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]--; 10a2e0: 31 d2 xor %edx,%edx 10a2e2: f7 73 14 divl 0x14(%ebx) 10a2e5: c1 e0 02 shl $0x2,%eax 10a2e8: 03 43 30 add 0x30(%ebx),%eax 10a2eb: ff 08 decl (%eax) information->inactive--; 10a2ed: 66 ff 4b 2c decw 0x2c(%ebx) } } return the_object; } 10a2f1: 89 c8 mov %ecx,%eax 10a2f3: 8d 65 f8 lea -0x8(%ebp),%esp 10a2f6: 5b pop %ebx 10a2f7: 5e pop %esi 10a2f8: c9 leave 10a2f9: c3 ret =============================================================================== 0010a320 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 10a320: 55 push %ebp 10a321: 89 e5 mov %esp,%ebp 10a323: 57 push %edi 10a324: 56 push %esi 10a325: 53 push %ebx 10a326: 83 ec 5c sub $0x5c,%esp 10a329: 8b 5d 08 mov 0x8(%ebp),%ebx * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 10a32c: 8b 43 08 mov 0x8(%ebx),%eax 10a32f: 25 ff ff 00 00 and $0xffff,%eax 10a334: 89 45 c8 mov %eax,-0x38(%ebp) minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; if ( information->maximum < minimum_index ) 10a337: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10a33b: 39 c1 cmp %eax,%ecx 10a33d: 73 13 jae 10a352 <_Objects_Extend_information+0x32> 10a33f: 89 45 c4 mov %eax,-0x3c(%ebp) 10a342: c7 45 bc 00 00 00 00 movl $0x0,-0x44(%ebp) 10a349: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp) 10a350: eb 35 jmp 10a387 <_Objects_Extend_information+0x67> block_count = 0; else { block_count = information->maximum / information->allocation_size; 10a352: 8b 7b 14 mov 0x14(%ebx),%edi 10a355: 89 c8 mov %ecx,%eax 10a357: 31 d2 xor %edx,%edx 10a359: f7 f7 div %edi 10a35b: 89 c6 mov %eax,%esi 10a35d: 89 45 bc mov %eax,-0x44(%ebp) 10a360: 8b 45 c8 mov -0x38(%ebp),%eax 10a363: 89 45 c4 mov %eax,-0x3c(%ebp) 10a366: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp) 10a36d: eb 13 jmp 10a382 <_Objects_Extend_information+0x62> for ( ; block < block_count; block++ ) { if ( information->object_blocks[ block ] == NULL ) 10a36f: 8b 43 34 mov 0x34(%ebx),%eax 10a372: 8b 55 c0 mov -0x40(%ebp),%edx 10a375: 83 3c 90 00 cmpl $0x0,(%eax,%edx,4) 10a379: 74 0c je 10a387 <_Objects_Extend_information+0x67> break; else index_base += information->allocation_size; 10a37b: 01 7d c4 add %edi,-0x3c(%ebp) if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10a37e: 42 inc %edx 10a37f: 89 55 c0 mov %edx,-0x40(%ebp) 10a382: 39 75 c0 cmp %esi,-0x40(%ebp) 10a385: 72 e8 jb 10a36f <_Objects_Extend_information+0x4f> /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 10a387: 39 4d c4 cmp %ecx,-0x3c(%ebp) 10a38a: 0f 82 30 01 00 00 jb 10a4c0 <_Objects_Extend_information+0x1a0> /* * Up the block count and maximum */ block_count++; 10a390: 8b 75 bc mov -0x44(%ebp),%esi 10a393: 46 inc %esi maximum = information->maximum + information->allocation_size; 10a394: 03 4b 14 add 0x14(%ebx),%ecx 10a397: 89 4d d0 mov %ecx,-0x30(%ebp) /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 10a39a: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10a39e: 8b 7d c8 mov -0x38(%ebp),%edi 10a3a1: 8d 14 39 lea (%ecx,%edi,1),%edx 10a3a4: 74 21 je 10a3c7 <_Objects_Extend_information+0xa7> object_blocks = (void**) 10a3a6: 83 ec 0c sub $0xc,%esp 10a3a9: 8d 04 76 lea (%esi,%esi,2),%eax 10a3ac: 8d 04 02 lea (%edx,%eax,1),%eax 10a3af: c1 e0 02 shl $0x2,%eax 10a3b2: 50 push %eax 10a3b3: e8 71 1a 00 00 call 10be29 <_Workspace_Allocate> 10a3b8: 89 45 a0 mov %eax,-0x60(%ebp) block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)) ); if ( !object_blocks ) 10a3bb: 83 c4 10 add $0x10,%esp 10a3be: 85 c0 test %eax,%eax 10a3c0: 75 1d jne 10a3df <_Objects_Extend_information+0xbf><== ALWAYS TAKEN 10a3c2: e9 c9 01 00 00 jmp 10a590 <_Objects_Extend_information+0x270><== NOT EXECUTED return; } else { object_blocks = (void**) 10a3c7: 83 ec 0c sub $0xc,%esp 10a3ca: 8d 04 76 lea (%esi,%esi,2),%eax 10a3cd: 8d 04 02 lea (%edx,%eax,1),%eax 10a3d0: c1 e0 02 shl $0x2,%eax 10a3d3: 50 push %eax 10a3d4: e8 65 1a 00 00 call 10be3e <_Workspace_Allocate_or_fatal_error> 10a3d9: 89 45 a0 mov %eax,-0x60(%ebp) 10a3dc: 83 c4 10 add $0x10,%esp /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 10a3df: 8b 45 a0 mov -0x60(%ebp),%eax 10a3e2: 8d 04 b0 lea (%eax,%esi,4),%eax 10a3e5: 89 45 cc mov %eax,-0x34(%ebp) * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 10a3e8: 8b 55 a0 mov -0x60(%ebp),%edx 10a3eb: 8d 34 f2 lea (%edx,%esi,8),%esi 10a3ee: 89 75 d4 mov %esi,-0x2c(%ebp) * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 10a3f1: 0f b7 43 10 movzwl 0x10(%ebx),%eax 10a3f5: 31 d2 xor %edx,%edx 10a3f7: 3b 45 c8 cmp -0x38(%ebp),%eax 10a3fa: 76 39 jbe 10a435 <_Objects_Extend_information+0x115> /* * Copy each section of the table over. This has to be performed as * separate parts as size of each block has changed. */ memcpy( object_blocks, 10a3fc: 8b 45 bc mov -0x44(%ebp),%eax 10a3ff: c1 e0 02 shl $0x2,%eax 10a402: 8b 73 34 mov 0x34(%ebx),%esi 10a405: 8b 7d a0 mov -0x60(%ebp),%edi 10a408: 89 c1 mov %eax,%ecx 10a40a: f3 a4 rep movsb %ds:(%esi),%es:(%edi) information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 10a40c: 8b 73 30 mov 0x30(%ebx),%esi 10a40f: 8b 7d cc mov -0x34(%ebp),%edi 10a412: 89 c1 mov %eax,%ecx 10a414: f3 a4 rep movsb %ds:(%esi),%es:(%edi) information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 10a416: 0f b7 4b 10 movzwl 0x10(%ebx),%ecx 10a41a: 03 4d c8 add -0x38(%ebp),%ecx 10a41d: c1 e1 02 shl $0x2,%ecx 10a420: 8b 73 1c mov 0x1c(%ebx),%esi 10a423: 8b 7d d4 mov -0x2c(%ebp),%edi 10a426: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10a428: eb 10 jmp 10a43a <_Objects_Extend_information+0x11a> /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { local_table[ index ] = NULL; 10a42a: 8b 45 d4 mov -0x2c(%ebp),%eax 10a42d: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10a434: 42 inc %edx 10a435: 3b 55 c8 cmp -0x38(%ebp),%edx 10a438: 72 f0 jb 10a42a <_Objects_Extend_information+0x10a> /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 10a43a: 8b 55 bc mov -0x44(%ebp),%edx 10a43d: 8b 4d a0 mov -0x60(%ebp),%ecx 10a440: c7 04 91 00 00 00 00 movl $0x0,(%ecx,%edx,4) inactive_per_block[block_count] = 0; 10a447: 8b 75 cc mov -0x34(%ebp),%esi 10a44a: c7 04 96 00 00 00 00 movl $0x0,(%esi,%edx,4) for ( index=index_base ; index < ( information->allocation_size + index_base ); 10a451: 8b 4d c4 mov -0x3c(%ebp),%ecx 10a454: 03 4b 14 add 0x14(%ebx),%ecx 10a457: 8b 7d c4 mov -0x3c(%ebp),%edi 10a45a: 8b 45 d4 mov -0x2c(%ebp),%eax 10a45d: 8d 14 b8 lea (%eax,%edi,4),%edx 10a460: 89 f8 mov %edi,%eax 10a462: eb 0a jmp 10a46e <_Objects_Extend_information+0x14e> index++ ) { local_table[ index ] = NULL; 10a464: c7 02 00 00 00 00 movl $0x0,(%edx) object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { 10a46a: 40 inc %eax 10a46b: 83 c2 04 add $0x4,%edx object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); 10a46e: 39 c8 cmp %ecx,%eax 10a470: 72 f2 jb 10a464 <_Objects_Extend_information+0x144> index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 10a472: 9c pushf 10a473: fa cli 10a474: 59 pop %ecx old_tables = information->object_blocks; 10a475: 8b 73 34 mov 0x34(%ebx),%esi information->object_blocks = object_blocks; 10a478: 8b 55 a0 mov -0x60(%ebp),%edx 10a47b: 89 53 34 mov %edx,0x34(%ebx) information->inactive_per_block = inactive_per_block; 10a47e: 8b 7d cc mov -0x34(%ebp),%edi 10a481: 89 7b 30 mov %edi,0x30(%ebx) information->local_table = local_table; 10a484: 8b 45 d4 mov -0x2c(%ebp),%eax 10a487: 89 43 1c mov %eax,0x1c(%ebx) information->maximum = maximum; 10a48a: 8b 55 d0 mov -0x30(%ebp),%edx 10a48d: 66 89 53 10 mov %dx,0x10(%ebx) information->maximum_id = _Objects_Build_id( 10a491: 8b 13 mov (%ebx),%edx 10a493: c1 e2 18 shl $0x18,%edx 10a496: 81 ca 00 00 01 00 or $0x10000,%edx 10a49c: 0f b7 43 04 movzwl 0x4(%ebx),%eax 10a4a0: c1 e0 1b shl $0x1b,%eax 10a4a3: 09 c2 or %eax,%edx 10a4a5: 0f b7 45 d0 movzwl -0x30(%ebp),%eax 10a4a9: 09 c2 or %eax,%edx 10a4ab: 89 53 0c mov %edx,0xc(%ebx) information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 10a4ae: 51 push %ecx 10a4af: 9d popf if ( old_tables ) 10a4b0: 85 f6 test %esi,%esi 10a4b2: 74 0c je 10a4c0 <_Objects_Extend_information+0x1a0> _Workspace_Free( old_tables ); 10a4b4: 83 ec 0c sub $0xc,%esp 10a4b7: 56 push %esi 10a4b8: e8 57 19 00 00 call 10be14 <_Workspace_Free> 10a4bd: 83 c4 10 add $0x10,%esp /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 10a4c0: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10a4c4: 8b 43 18 mov 0x18(%ebx),%eax 10a4c7: 74 32 je 10a4fb <_Objects_Extend_information+0x1db> information->object_blocks[ block ] = 10a4c9: 8b 4d c0 mov -0x40(%ebp),%ecx 10a4cc: 8b 73 34 mov 0x34(%ebx),%esi 10a4cf: 8d 0c 8e lea (%esi,%ecx,4),%ecx 10a4d2: 89 4d d8 mov %ecx,-0x28(%ebp) 10a4d5: 83 ec 0c sub $0xc,%esp 10a4d8: 0f af 43 14 imul 0x14(%ebx),%eax 10a4dc: 50 push %eax 10a4dd: e8 47 19 00 00 call 10be29 <_Workspace_Allocate> 10a4e2: 8b 7d d8 mov -0x28(%ebp),%edi 10a4e5: 89 07 mov %eax,(%edi) _Workspace_Allocate( (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 10a4e7: 8b 43 34 mov 0x34(%ebx),%eax 10a4ea: 83 c4 10 add $0x10,%esp 10a4ed: 8b 55 c0 mov -0x40(%ebp),%edx 10a4f0: 83 3c 90 00 cmpl $0x0,(%eax,%edx,4) 10a4f4: 75 26 jne 10a51c <_Objects_Extend_information+0x1fc><== ALWAYS TAKEN 10a4f6: e9 95 00 00 00 jmp 10a590 <_Objects_Extend_information+0x270><== NOT EXECUTED return; } else { information->object_blocks[ block ] = 10a4fb: 8b 4d c0 mov -0x40(%ebp),%ecx 10a4fe: 8b 73 34 mov 0x34(%ebx),%esi 10a501: 8d 0c 8e lea (%esi,%ecx,4),%ecx 10a504: 89 4d dc mov %ecx,-0x24(%ebp) 10a507: 83 ec 0c sub $0xc,%esp 10a50a: 0f af 43 14 imul 0x14(%ebx),%eax 10a50e: 50 push %eax 10a50f: e8 2a 19 00 00 call 10be3e <_Workspace_Allocate_or_fatal_error> 10a514: 8b 7d dc mov -0x24(%ebp),%edi 10a517: 89 07 mov %eax,(%edi) 10a519: 83 c4 10 add $0x10,%esp /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 10a51c: 8b 45 c0 mov -0x40(%ebp),%eax 10a51f: c1 e0 02 shl $0x2,%eax 10a522: 89 45 e0 mov %eax,-0x20(%ebp) 10a525: ff 73 18 pushl 0x18(%ebx) 10a528: ff 73 14 pushl 0x14(%ebx) 10a52b: 8b 43 34 mov 0x34(%ebx),%eax 10a52e: 8b 55 c0 mov -0x40(%ebp),%edx 10a531: ff 34 90 pushl (%eax,%edx,4) 10a534: 8d 7d e8 lea -0x18(%ebp),%edi 10a537: 57 push %edi 10a538: e8 1f 38 00 00 call 10dd5c <_Chain_Initialize> information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10a53d: 8d 4b 20 lea 0x20(%ebx),%ecx 10a540: 89 4d b8 mov %ecx,-0x48(%ebp) 10a543: 8b 75 c4 mov -0x3c(%ebp),%esi 10a546: eb 24 jmp 10a56c <_Objects_Extend_information+0x24c> index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 10a548: 8b 03 mov (%ebx),%eax 10a54a: c1 e0 18 shl $0x18,%eax 10a54d: 0d 00 00 01 00 or $0x10000,%eax 10a552: 0f b7 53 04 movzwl 0x4(%ebx),%edx 10a556: c1 e2 1b shl $0x1b,%edx 10a559: 09 d0 or %edx,%eax 10a55b: 09 f0 or %esi,%eax 10a55d: 89 41 08 mov %eax,0x8(%ecx) information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10a560: 50 push %eax 10a561: 50 push %eax 10a562: 51 push %ecx 10a563: ff 75 b8 pushl -0x48(%ebp) 10a566: e8 81 f5 ff ff call 109aec <_Chain_Append> index++; 10a56b: 46 inc %esi * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { 10a56c: 89 3c 24 mov %edi,(%esp) 10a56f: e8 9c f5 ff ff call 109b10 <_Chain_Get> 10a574: 89 c1 mov %eax,%ecx 10a576: 83 c4 10 add $0x10,%esp 10a579: 85 c0 test %eax,%eax 10a57b: 75 cb jne 10a548 <_Objects_Extend_information+0x228> _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 10a57d: 8b 43 30 mov 0x30(%ebx),%eax 10a580: 8b 53 14 mov 0x14(%ebx),%edx 10a583: 8b 75 e0 mov -0x20(%ebp),%esi 10a586: 89 14 30 mov %edx,(%eax,%esi,1) information->inactive += information->allocation_size; 10a589: 8b 43 14 mov 0x14(%ebx),%eax 10a58c: 66 01 43 2c add %ax,0x2c(%ebx) } 10a590: 8d 65 f4 lea -0xc(%ebp),%esp 10a593: 5b pop %ebx 10a594: 5e pop %esi 10a595: 5f pop %edi 10a596: c9 leave 10a597: c3 ret =============================================================================== 0010a62c <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint32_t the_class ) { 10a62c: 55 push %ebp 10a62d: 89 e5 mov %esp,%ebp 10a62f: 56 push %esi 10a630: 53 push %ebx 10a631: 8b 5d 08 mov 0x8(%ebp),%ebx 10a634: 8b 75 0c mov 0xc(%ebp),%esi /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10a637: 8d 43 ff lea -0x1(%ebx),%eax 10a63a: 83 f8 03 cmp $0x3,%eax 10a63d: 77 2f ja 10a66e <_Objects_Get_information+0x42> 10a63f: eb 36 jmp 10a677 <_Objects_Get_information+0x4b> return NULL; if ( !the_class ) return NULL; the_class_api_maximum = _Objects_API_maximum_class( the_api ); 10a641: 83 ec 0c sub $0xc,%esp 10a644: 53 push %ebx 10a645: e8 1a 3b 00 00 call 10e164 <_Objects_API_maximum_class> if ( the_class_api_maximum < 0 || 10a64a: 83 c4 10 add $0x10,%esp 10a64d: 85 c0 test %eax,%eax 10a64f: 78 1d js 10a66e <_Objects_Get_information+0x42><== NEVER TAKEN 10a651: 39 c6 cmp %eax,%esi 10a653: 77 19 ja 10a66e <_Objects_Get_information+0x42><== NEVER TAKEN the_class > (uint32_t) the_class_api_maximum ) return NULL; if ( !_Objects_Information_table[ the_api ] ) 10a655: 8b 04 9d 6c d7 11 00 mov 0x11d76c(,%ebx,4),%eax 10a65c: 85 c0 test %eax,%eax 10a65e: 74 0e je 10a66e <_Objects_Get_information+0x42><== NEVER TAKEN return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10a660: 8b 04 b0 mov (%eax,%esi,4),%eax if ( !info ) 10a663: 85 c0 test %eax,%eax 10a665: 74 09 je 10a670 <_Objects_Get_information+0x44><== NEVER TAKEN * In a multprocessing configuration, we may access remote objects. * Thus we may have 0 local instances and still have a valid object * pointer. */ #if !defined(RTEMS_MULTIPROCESSING) if ( info->maximum == 0 ) 10a667: 66 83 78 10 00 cmpw $0x0,0x10(%eax) 10a66c: 75 02 jne 10a670 <_Objects_Get_information+0x44> 10a66e: 31 c0 xor %eax,%eax return NULL; #endif return info; } 10a670: 8d 65 f8 lea -0x8(%ebp),%esp 10a673: 5b pop %ebx 10a674: 5e pop %esi 10a675: c9 leave 10a676: c3 ret int the_class_api_maximum; if ( !_Objects_Is_api_valid( the_api ) ) return NULL; if ( !the_class ) 10a677: 85 f6 test %esi,%esi 10a679: 74 f3 je 10a66e <_Objects_Get_information+0x42> 10a67b: eb c4 jmp 10a641 <_Objects_Get_information+0x15> =============================================================================== 00114fbc <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 114fbc: 55 push %ebp 114fbd: 89 e5 mov %esp,%ebp 114fbf: 53 push %ebx 114fc0: 8b 4d 08 mov 0x8(%ebp),%ecx 114fc3: 8b 5d 10 mov 0x10(%ebp),%ebx /* * You can't just extract the index portion or you can get tricked * by a value between 1 and maximum. */ index = id - information->minimum_id + 1; 114fc6: ba 01 00 00 00 mov $0x1,%edx 114fcb: 2b 51 08 sub 0x8(%ecx),%edx 114fce: 03 55 0c add 0xc(%ebp),%edx if ( information->maximum >= index ) { 114fd1: 0f b7 41 10 movzwl 0x10(%ecx),%eax 114fd5: 39 d0 cmp %edx,%eax 114fd7: 72 12 jb 114feb <_Objects_Get_no_protection+0x2f> if ( (the_object = information->local_table[ index ]) != NULL ) { 114fd9: 8b 41 1c mov 0x1c(%ecx),%eax 114fdc: 8b 04 90 mov (%eax,%edx,4),%eax 114fdf: 85 c0 test %eax,%eax 114fe1: 74 08 je 114feb <_Objects_Get_no_protection+0x2f><== NEVER TAKEN *location = OBJECTS_LOCAL; 114fe3: c7 03 00 00 00 00 movl $0x0,(%ebx) 114fe9: eb 08 jmp 114ff3 <_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; 114feb: c7 03 01 00 00 00 movl $0x1,(%ebx) 114ff1: 31 c0 xor %eax,%eax return NULL; } 114ff3: 5b pop %ebx 114ff4: c9 leave 114ff5: c3 ret =============================================================================== 0010b66c <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10b66c: 55 push %ebp 10b66d: 89 e5 mov %esp,%ebp 10b66f: 53 push %ebx 10b670: 83 ec 14 sub $0x14,%esp 10b673: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Id tmpId; Objects_Information *information; Objects_Control *the_object = (Objects_Control *) 0; Objects_Locations ignored_location; if ( !name ) 10b676: b8 01 00 00 00 mov $0x1,%eax 10b67b: 85 db test %ebx,%ebx 10b67d: 74 59 je 10b6d8 <_Objects_Id_to_name+0x6c><== NEVER TAKEN return OBJECTS_INVALID_NAME; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10b67f: 8b 4d 08 mov 0x8(%ebp),%ecx 10b682: 85 c9 test %ecx,%ecx 10b684: 75 08 jne 10b68e <_Objects_Id_to_name+0x22> 10b686: a1 44 15 12 00 mov 0x121544,%eax 10b68b: 8b 48 08 mov 0x8(%eax),%ecx uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10b68e: 89 ca mov %ecx,%edx 10b690: c1 ea 18 shr $0x18,%edx 10b693: 83 e2 07 and $0x7,%edx /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10b696: 8d 42 ff lea -0x1(%edx),%eax 10b699: 83 f8 03 cmp $0x3,%eax 10b69c: 77 35 ja 10b6d3 <_Objects_Id_to_name+0x67> 10b69e: eb 3d jmp 10b6dd <_Objects_Id_to_name+0x71> if ( !_Objects_Information_table[ the_api ] ) return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 10b6a0: 89 c8 mov %ecx,%eax 10b6a2: c1 e8 1b shr $0x1b,%eax 10b6a5: 8b 14 82 mov (%edx,%eax,4),%edx if ( !information ) 10b6a8: 85 d2 test %edx,%edx 10b6aa: 74 27 je 10b6d3 <_Objects_Id_to_name+0x67><== NEVER TAKEN return OBJECTS_INVALID_ID; if ( information->is_string ) 10b6ac: 80 7a 38 00 cmpb $0x0,0x38(%edx) 10b6b0: 75 21 jne 10b6d3 <_Objects_Id_to_name+0x67><== NEVER TAKEN return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &ignored_location ); 10b6b2: 50 push %eax 10b6b3: 8d 45 f8 lea -0x8(%ebp),%eax 10b6b6: 50 push %eax 10b6b7: 51 push %ecx 10b6b8: 52 push %edx 10b6b9: e8 56 ff ff ff call 10b614 <_Objects_Get> if ( !the_object ) 10b6be: 83 c4 10 add $0x10,%esp 10b6c1: 85 c0 test %eax,%eax 10b6c3: 74 0e je 10b6d3 <_Objects_Id_to_name+0x67> return OBJECTS_INVALID_ID; *name = the_object->name; 10b6c5: 8b 40 0c mov 0xc(%eax),%eax 10b6c8: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10b6ca: e8 85 07 00 00 call 10be54 <_Thread_Enable_dispatch> 10b6cf: 31 c0 xor %eax,%eax 10b6d1: eb 05 jmp 10b6d8 <_Objects_Id_to_name+0x6c> return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10b6d3: b8 03 00 00 00 mov $0x3,%eax } 10b6d8: 8b 5d fc mov -0x4(%ebp),%ebx 10b6db: c9 leave 10b6dc: 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 ] ) 10b6dd: 8b 14 95 58 14 12 00 mov 0x121458(,%edx,4),%edx 10b6e4: 85 d2 test %edx,%edx 10b6e6: 75 b8 jne 10b6a0 <_Objects_Id_to_name+0x34><== ALWAYS TAKEN 10b6e8: eb e9 jmp 10b6d3 <_Objects_Id_to_name+0x67><== NOT EXECUTED =============================================================================== 001132d0 <_Objects_Name_to_id_string>: Objects_Name_or_id_lookup_errors _Objects_Name_to_id_string( Objects_Information *information, const char *name, Objects_Id *id ) { 1132d0: 55 push %ebp 1132d1: 89 e5 mov %esp,%ebp 1132d3: 57 push %edi 1132d4: 56 push %esi 1132d5: 53 push %ebx 1132d6: 83 ec 0c sub $0xc,%esp 1132d9: 8b 7d 08 mov 0x8(%ebp),%edi uint32_t index; uint32_t name_length; /* ASSERT: information->is_string == TRUE */ if ( !id ) 1132dc: b8 02 00 00 00 mov $0x2,%eax 1132e1: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 1132e5: 74 59 je 113340 <_Objects_Name_to_id_string+0x70><== NEVER TAKEN return OBJECTS_INVALID_ADDRESS; if ( !name ) 1132e7: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 1132eb: 74 4e je 11333b <_Objects_Name_to_id_string+0x6b><== NEVER TAKEN return OBJECTS_INVALID_NAME; if ( information->maximum != 0 ) { 1132ed: 8b 47 10 mov 0x10(%edi),%eax 1132f0: 66 85 c0 test %ax,%ax 1132f3: 74 46 je 11333b <_Objects_Name_to_id_string+0x6b><== NEVER TAKEN 1132f5: be 01 00 00 00 mov $0x1,%esi name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 1132fa: 0f b7 c0 movzwl %ax,%eax 1132fd: 89 45 f0 mov %eax,-0x10(%ebp) 113300: eb 34 jmp 113336 <_Objects_Name_to_id_string+0x66> the_object = information->local_table[ index ]; 113302: 8b 47 1c mov 0x1c(%edi),%eax 113305: 8b 1c b0 mov (%eax,%esi,4),%ebx if ( !the_object ) 113308: 85 db test %ebx,%ebx 11330a: 74 29 je 113335 <_Objects_Name_to_id_string+0x65> continue; if ( !the_object->name.name_p ) 11330c: 8b 53 0c mov 0xc(%ebx),%edx 11330f: 85 d2 test %edx,%edx 113311: 74 22 je 113335 <_Objects_Name_to_id_string+0x65> continue; if (!strncmp( name, the_object->name.name_p, information->name_length)) { 113313: 50 push %eax 113314: 0f b7 47 3a movzwl 0x3a(%edi),%eax 113318: 50 push %eax 113319: 52 push %edx 11331a: ff 75 0c pushl 0xc(%ebp) 11331d: e8 5e 25 00 00 call 115880 113322: 83 c4 10 add $0x10,%esp 113325: 85 c0 test %eax,%eax 113327: 75 0c jne 113335 <_Objects_Name_to_id_string+0x65> *id = the_object->id; 113329: 8b 43 08 mov 0x8(%ebx),%eax 11332c: 8b 55 10 mov 0x10(%ebp),%edx 11332f: 89 02 mov %eax,(%edx) 113331: 31 c0 xor %eax,%eax 113333: eb 0b jmp 113340 <_Objects_Name_to_id_string+0x70> return OBJECTS_INVALID_NAME; if ( information->maximum != 0 ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 113335: 46 inc %esi 113336: 3b 75 f0 cmp -0x10(%ebp),%esi 113339: 76 c7 jbe 113302 <_Objects_Name_to_id_string+0x32> 11333b: b8 01 00 00 00 mov $0x1,%eax } } } return OBJECTS_INVALID_NAME; } 113340: 8d 65 f4 lea -0xc(%ebp),%esp 113343: 5b pop %ebx 113344: 5e pop %esi 113345: 5f pop %edi 113346: c9 leave 113347: c3 ret =============================================================================== 0010a814 <_Objects_Name_to_id_u32>: Objects_Information *information, uint32_t name, uint32_t node, Objects_Id *id ) { 10a814: 55 push %ebp 10a815: 89 e5 mov %esp,%ebp 10a817: 57 push %edi 10a818: 56 push %esi 10a819: 53 push %ebx 10a81a: 8b 7d 08 mov 0x8(%ebp),%edi 10a81d: 8b 5d 0c mov 0xc(%ebp),%ebx 10a820: 8b 55 10 mov 0x10(%ebp),%edx 10a823: 8b 75 14 mov 0x14(%ebp),%esi Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == FALSE */ if ( !id ) 10a826: b8 02 00 00 00 mov $0x2,%eax 10a82b: 85 f6 test %esi,%esi 10a82d: 74 49 je 10a878 <_Objects_Name_to_id_u32+0x64> return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 10a82f: 85 db test %ebx,%ebx 10a831: 74 40 je 10a873 <_Objects_Name_to_id_u32+0x5f> return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10a833: 8b 47 10 mov 0x10(%edi),%eax 10a836: 66 85 c0 test %ax,%ax 10a839: 74 38 je 10a873 <_Objects_Name_to_id_u32+0x5f><== NEVER TAKEN 10a83b: 85 d2 test %edx,%edx 10a83d: 74 28 je 10a867 <_Objects_Name_to_id_u32+0x53> 10a83f: 81 fa ff ff ff 7f cmp $0x7fffffff,%edx 10a845: 74 20 je 10a867 <_Objects_Name_to_id_u32+0x53> 10a847: 4a dec %edx 10a848: 75 29 jne 10a873 <_Objects_Name_to_id_u32+0x5f> 10a84a: eb 1b jmp 10a867 <_Objects_Name_to_id_u32+0x53> if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { the_object = information->local_table[ index ]; 10a84c: 8b 47 1c mov 0x1c(%edi),%eax 10a84f: 8b 04 90 mov (%eax,%edx,4),%eax if ( !the_object ) 10a852: 85 c0 test %eax,%eax 10a854: 74 0e je 10a864 <_Objects_Name_to_id_u32+0x50> continue; if ( name == the_object->name.name_u32 ) { 10a856: 3b 58 0c cmp 0xc(%eax),%ebx 10a859: 75 09 jne 10a864 <_Objects_Name_to_id_u32+0x50> *id = the_object->id; 10a85b: 8b 40 08 mov 0x8(%eax),%eax 10a85e: 89 06 mov %eax,(%esi) 10a860: 31 c0 xor %eax,%eax 10a862: eb 14 jmp 10a878 <_Objects_Name_to_id_u32+0x64> search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 10a864: 42 inc %edx 10a865: eb 08 jmp 10a86f <_Objects_Name_to_id_u32+0x5b> 10a867: ba 01 00 00 00 mov $0x1,%edx 10a86c: 0f b7 c8 movzwl %ax,%ecx 10a86f: 39 ca cmp %ecx,%edx 10a871: 76 d9 jbe 10a84c <_Objects_Name_to_id_u32+0x38> 10a873: b8 01 00 00 00 mov $0x1,%eax name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif } 10a878: 5b pop %ebx 10a879: 5e pop %esi 10a87a: 5f pop %edi 10a87b: c9 leave 10a87c: c3 ret =============================================================================== 0010ae7c <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 10ae7c: 55 push %ebp 10ae7d: 89 e5 mov %esp,%ebp 10ae7f: 57 push %edi 10ae80: 56 push %esi 10ae81: 53 push %ebx 10ae82: 83 ec 14 sub $0x14,%esp 10ae85: 8b 5d 08 mov 0x8(%ebp),%ebx 10ae88: 8b 7d 10 mov 0x10(%ebp),%edi size_t length; const char *s; s = name; length = strnlen( name, information->name_length ) + 1; 10ae8b: 0f b7 43 3a movzwl 0x3a(%ebx),%eax 10ae8f: 50 push %eax 10ae90: 57 push %edi 10ae91: e8 a6 63 00 00 call 11123c 10ae96: 89 45 f0 mov %eax,-0x10(%ebp) 10ae99: 89 c6 mov %eax,%esi 10ae9b: 46 inc %esi if ( information->is_string ) { 10ae9c: 83 c4 10 add $0x10,%esp 10ae9f: 80 7b 38 00 cmpb $0x0,0x38(%ebx) 10aea3: 74 56 je 10aefb <_Objects_Set_name+0x7f> char *d; d = _Workspace_Allocate( length ); 10aea5: 83 ec 0c sub $0xc,%esp 10aea8: 56 push %esi 10aea9: e8 4f 16 00 00 call 10c4fd <_Workspace_Allocate> 10aeae: 89 c3 mov %eax,%ebx if ( !d ) 10aeb0: 83 c4 10 add $0x10,%esp 10aeb3: 31 c0 xor %eax,%eax 10aeb5: 85 db test %ebx,%ebx 10aeb7: 0f 84 81 00 00 00 je 10af3e <_Objects_Set_name+0xc2><== NEVER TAKEN return FALSE; if ( the_object->name.name_p ) { 10aebd: 8b 55 0c mov 0xc(%ebp),%edx 10aec0: 8b 42 0c mov 0xc(%edx),%eax 10aec3: 85 c0 test %eax,%eax 10aec5: 74 16 je 10aedd <_Objects_Set_name+0x61> _Workspace_Free( (void *)the_object->name.name_p ); 10aec7: 83 ec 0c sub $0xc,%esp 10aeca: 50 push %eax 10aecb: e8 18 16 00 00 call 10c4e8 <_Workspace_Free> the_object->name.name_p = NULL; 10aed0: 8b 45 0c mov 0xc(%ebp),%eax 10aed3: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) 10aeda: 83 c4 10 add $0x10,%esp } strncpy( d, name, length ); 10aedd: 50 push %eax 10aede: 56 push %esi 10aedf: 57 push %edi 10aee0: 53 push %ebx 10aee1: e8 ce 62 00 00 call 1111b4 d[ length ] = '\0'; 10aee6: 8b 55 f0 mov -0x10(%ebp),%edx 10aee9: c6 44 13 01 00 movb $0x0,0x1(%ebx,%edx,1) the_object->name.name_p = d; 10aeee: 8b 45 0c mov 0xc(%ebp),%eax 10aef1: 89 58 0c mov %ebx,0xc(%eax) 10aef4: b0 01 mov $0x1,%al 10aef6: 83 c4 10 add $0x10,%esp 10aef9: eb 43 jmp 10af3e <_Objects_Set_name+0xc2> } else { the_object->name.name_u32 = _Objects_Build_name( 10aefb: b8 00 00 00 20 mov $0x20000000,%eax 10af00: 85 f6 test %esi,%esi 10af02: 74 4e je 10af52 <_Objects_Set_name+0xd6><== NEVER TAKEN 10af04: 0f be 07 movsbl (%edi),%eax 10af07: c1 e0 18 shl $0x18,%eax 10af0a: 83 fe 01 cmp $0x1,%esi 10af0d: 74 43 je 10af52 <_Objects_Set_name+0xd6> 10af0f: 0f be 5f 01 movsbl 0x1(%edi),%ebx 10af13: c1 e3 10 shl $0x10,%ebx 10af16: 83 fe 02 cmp $0x2,%esi 10af19: 76 2b jbe 10af46 <_Objects_Set_name+0xca> 10af1b: 0f be 57 02 movsbl 0x2(%edi),%edx 10af1f: c1 e2 08 shl $0x8,%edx 10af22: b9 20 00 00 00 mov $0x20,%ecx 10af27: 83 fe 03 cmp $0x3,%esi 10af2a: 76 04 jbe 10af30 <_Objects_Set_name+0xb4> 10af2c: 0f be 4f 03 movsbl 0x3(%edi),%ecx 10af30: 09 d8 or %ebx,%eax 10af32: 09 d0 or %edx,%eax 10af34: 09 c8 or %ecx,%eax 10af36: 8b 55 0c mov 0xc(%ebp),%edx 10af39: 89 42 0c mov %eax,0xc(%edx) 10af3c: b0 01 mov $0x1,%al ); } return TRUE; } 10af3e: 8d 65 f4 lea -0xc(%ebp),%esp 10af41: 5b pop %ebx 10af42: 5e pop %esi 10af43: 5f pop %edi 10af44: c9 leave 10af45: c3 ret strncpy( d, name, length ); d[ length ] = '\0'; the_object->name.name_p = d; } else { the_object->name.name_u32 = _Objects_Build_name( 10af46: b9 20 00 00 00 mov $0x20,%ecx 10af4b: ba 00 20 00 00 mov $0x2000,%edx 10af50: eb de jmp 10af30 <_Objects_Set_name+0xb4> 10af52: bb 00 00 20 00 mov $0x200000,%ebx 10af57: eb ed jmp 10af46 <_Objects_Set_name+0xca> =============================================================================== 0010a888 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 10a888: 55 push %ebp 10a889: 89 e5 mov %esp,%ebp 10a88b: 57 push %edi 10a88c: 56 push %esi 10a88d: 53 push %ebx 10a88e: 83 ec 0c sub $0xc,%esp 10a891: 8b 75 08 mov 0x8(%ebp),%esi * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 10a894: 8b 46 08 mov 0x8(%esi),%eax 10a897: 0f b7 f8 movzwl %ax,%edi /* * Search the list to find block or chunnk with all objects inactive. */ index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; 10a89a: 8b 4e 14 mov 0x14(%esi),%ecx 10a89d: 0f b7 46 10 movzwl 0x10(%esi),%eax 10a8a1: 29 f8 sub %edi,%eax 10a8a3: 31 d2 xor %edx,%edx 10a8a5: f7 f1 div %ecx 10a8a7: 89 c3 mov %eax,%ebx 10a8a9: 31 d2 xor %edx,%edx 10a8ab: eb 7c jmp 10a929 <_Objects_Shrink_information+0xa1> for ( block = 0; block < block_count; block++ ) { 10a8ad: 8d 04 95 00 00 00 00 lea 0x0(,%edx,4),%eax 10a8b4: 89 45 f0 mov %eax,-0x10(%ebp) if ( information->inactive_per_block[ block ] == information->allocation_size ) { 10a8b7: 8b 46 30 mov 0x30(%esi),%eax 10a8ba: 39 0c 90 cmp %ecx,(%eax,%edx,4) 10a8bd: 75 67 jne 10a926 <_Objects_Shrink_information+0x9e> /* * XXX - Not to sure how to use a chain where you need to iterate and * and remove elements. */ the_object = (Objects_Control *) information->Inactive.first; 10a8bf: 8b 56 20 mov 0x20(%esi),%edx 10a8c2: 8b 42 08 mov 0x8(%edx),%eax 10a8c5: 0f b7 c8 movzwl %ax,%ecx */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 10a8c8: 39 f9 cmp %edi,%ecx 10a8ca: 72 1b jb 10a8e7 <_Objects_Shrink_information+0x5f> 10a8cc: 89 f8 mov %edi,%eax 10a8ce: 03 46 14 add 0x14(%esi),%eax 10a8d1: 39 c1 cmp %eax,%ecx 10a8d3: 73 12 jae 10a8e7 <_Objects_Shrink_information+0x5f> * @param[in] start_address is the starting address of the user block * to free * @return TRUE if successfully freed, FALSE otherwise */ bool _Protected_heap_Free( Heap_Control *the_heap, 10a8d5: 8b 1a mov (%edx),%ebx if ( !_Chain_Is_last( &the_object->Node ) ) the_object = (Objects_Control *) the_object->Node.next; else the_object = NULL; _Chain_Extract( &extract_me->Node ); 10a8d7: 83 ec 0c sub $0xc,%esp 10a8da: 52 push %edx 10a8db: e8 64 34 00 00 call 10dd44 <_Chain_Extract> 10a8e0: 89 da mov %ebx,%edx 10a8e2: 83 c4 10 add $0x10,%esp 10a8e5: eb 02 jmp 10a8e9 <_Objects_Shrink_information+0x61> } else { the_object = (Objects_Control *) the_object->Node.next; 10a8e7: 8b 12 mov (%edx),%edx } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 10a8e9: 85 d2 test %edx,%edx 10a8eb: 74 05 je 10a8f2 <_Objects_Shrink_information+0x6a><== NEVER TAKEN 10a8ed: 83 3a 00 cmpl $0x0,(%edx) 10a8f0: 75 d0 jne 10a8c2 <_Objects_Shrink_information+0x3a> /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); 10a8f2: 83 ec 0c sub $0xc,%esp 10a8f5: 8b 46 34 mov 0x34(%esi),%eax 10a8f8: 8b 55 f0 mov -0x10(%ebp),%edx 10a8fb: ff 34 10 pushl (%eax,%edx,1) 10a8fe: e8 11 15 00 00 call 10be14 <_Workspace_Free> information->object_blocks[ block ] = NULL; 10a903: 8b 46 34 mov 0x34(%esi),%eax 10a906: 8b 55 f0 mov -0x10(%ebp),%edx 10a909: c7 04 10 00 00 00 00 movl $0x0,(%eax,%edx,1) information->inactive_per_block[ block ] = 0; 10a910: 8b 46 30 mov 0x30(%esi),%eax 10a913: c7 04 10 00 00 00 00 movl $0x0,(%eax,%edx,1) information->inactive -= information->allocation_size; 10a91a: 8b 46 14 mov 0x14(%esi),%eax 10a91d: 66 29 46 2c sub %ax,0x2c(%esi) 10a921: 83 c4 10 add $0x10,%esp 10a924: eb 07 jmp 10a92d <_Objects_Shrink_information+0xa5> return; } index_base += information->allocation_size; 10a926: 01 cf add %ecx,%edi */ index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { 10a928: 42 inc %edx 10a929: 39 da cmp %ebx,%edx 10a92b: 72 80 jb 10a8ad <_Objects_Shrink_information+0x25> return; } index_base += information->allocation_size; } } 10a92d: 8d 65 f4 lea -0xc(%ebp),%esp 10a930: 5b pop %ebx 10a931: 5e pop %esi 10a932: 5f pop %edi 10a933: c9 leave 10a934: c3 ret =============================================================================== 00109844 <_POSIX_API_Initialize>: void _POSIX_API_Initialize( rtems_configuration_table *configuration_table ) { 109844: 55 push %ebp 109845: 89 e5 mov %esp,%ebp 109847: 53 push %ebx 109848: 83 ec 04 sub $0x4,%esp /* XXX need to assert here based on size assumptions */ assert( sizeof(pthread_t) == sizeof(Objects_Id) ); api_configuration = configuration_table->POSIX_api_configuration; 10984b: 8b 45 08 mov 0x8(%ebp),%eax 10984e: 8b 58 44 mov 0x44(%eax),%ebx if ( !api_configuration ) 109851: 85 db test %ebx,%ebx 109853: 75 05 jne 10985a <_POSIX_API_Initialize+0x16><== ALWAYS TAKEN 109855: bb e8 72 11 00 mov $0x1172e8,%ebx <== NOT EXECUTED api_configuration = &_POSIX_Default_configuration; _Objects_Information_table[OBJECTS_POSIX_API] = _POSIX_Objects; 10985a: c7 05 78 d7 11 00 4c movl $0x11dc4c,0x11d778 109861: dc 11 00 _POSIX_signals_Manager_Initialization( 109864: 83 ec 0c sub $0xc,%esp 109867: ff 73 14 pushl 0x14(%ebx) 10986a: e8 f5 3b 00 00 call 10d464 <_POSIX_signals_Manager_Initialization> api_configuration->maximum_queued_signals ); _POSIX_Threads_Manager_initialization( 10986f: 83 c4 0c add $0xc,%esp 109872: ff 73 30 pushl 0x30(%ebx) 109875: ff 73 2c pushl 0x2c(%ebx) 109878: ff 33 pushl (%ebx) 10987a: e8 67 3d 00 00 call 10d5e6 <_POSIX_Threads_Manager_initialization> api_configuration->maximum_threads, api_configuration->number_of_initialization_threads, api_configuration->User_initialization_threads_table ); _POSIX_Condition_variables_Manager_initialization( 10987f: 58 pop %eax 109880: ff 73 08 pushl 0x8(%ebx) 109883: e8 cc 3a 00 00 call 10d354 <_POSIX_Condition_variables_Manager_initialization> api_configuration->maximum_condition_variables ); _POSIX_Key_Manager_initialization( api_configuration->maximum_keys ); 109888: 58 pop %eax 109889: ff 73 0c pushl 0xc(%ebx) 10988c: e8 eb 3a 00 00 call 10d37c <_POSIX_Key_Manager_initialization> _POSIX_Mutex_Manager_initialization( 109891: 58 pop %eax 109892: ff 73 04 pushl 0x4(%ebx) 109895: e8 52 3b 00 00 call 10d3ec <_POSIX_Mutex_Manager_initialization> api_configuration->maximum_mutexes ); _POSIX_Message_queue_Manager_initialization( 10989a: 58 pop %eax 10989b: ff 73 18 pushl 0x18(%ebx) 10989e: e8 01 3b 00 00 call 10d3a4 <_POSIX_Message_queue_Manager_initialization> api_configuration->maximum_message_queues ); _POSIX_Semaphore_Manager_initialization( 1098a3: 58 pop %eax 1098a4: ff 73 1c pushl 0x1c(%ebx) 1098a7: e8 40 40 00 00 call 10d8ec <_POSIX_Semaphore_Manager_initialization> api_configuration->maximum_semaphores ); _POSIX_Timer_Manager_initialization( api_configuration->maximum_timers ); 1098ac: 59 pop %ecx 1098ad: ff 73 10 pushl 0x10(%ebx) 1098b0: e8 0f 40 00 00 call 10d8c4 <_POSIX_Timer_Manager_initialization> _POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers ); 1098b5: 5a pop %edx 1098b6: ff 73 20 pushl 0x20(%ebx) 1098b9: e8 56 3b 00 00 call 10d414 <_POSIX_Barrier_Manager_initialization> _POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks ); 1098be: 58 pop %eax 1098bf: ff 73 24 pushl 0x24(%ebx) 1098c2: e8 75 3b 00 00 call 10d43c <_POSIX_RWLock_Manager_initialization> _POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks); 1098c7: 83 c4 10 add $0x10,%esp 1098ca: 8b 43 28 mov 0x28(%ebx),%eax 1098cd: 89 45 08 mov %eax,0x8(%ebp) } 1098d0: 8b 5d fc mov -0x4(%ebp),%ebx 1098d3: c9 leave _POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers ); _POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks ); _POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks); 1098d4: e9 d3 3c 00 00 jmp 10d5ac <_POSIX_Spinlock_Manager_initialization> =============================================================================== 00109a50 <_POSIX_Condition_variables_Get>: POSIX_Condition_variables_Control *_POSIX_Condition_variables_Get ( pthread_cond_t *cond, Objects_Locations *location ) { 109a50: 55 push %ebp 109a51: 89 e5 mov %esp,%ebp 109a53: 56 push %esi 109a54: 53 push %ebx 109a55: 8b 5d 08 mov 0x8(%ebp),%ebx 109a58: 8b 75 0c mov 0xc(%ebp),%esi Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 109a5b: 85 db test %ebx,%ebx 109a5d: 74 16 je 109a75 <_POSIX_Condition_variables_Get+0x25> *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 109a5f: 83 3b ff cmpl $0xffffffff,(%ebx) 109a62: 75 1b jne 109a7f <_POSIX_Condition_variables_Get+0x2f><== ALWAYS TAKEN /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 109a64: 52 push %edx <== NOT EXECUTED 109a65: 52 push %edx <== NOT EXECUTED 109a66: 6a 00 push $0x0 <== NOT EXECUTED 109a68: 53 push %ebx <== NOT EXECUTED 109a69: e8 2a 00 00 00 call 109a98 <== NOT EXECUTED if ( status ) { 109a6e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109a71: 85 c0 test %eax,%eax <== NOT EXECUTED 109a73: 74 0a je 109a7f <_POSIX_Condition_variables_Get+0x2f><== NOT EXECUTED *location = OBJECTS_ERROR; 109a75: c7 06 01 00 00 00 movl $0x1,(%esi) 109a7b: 31 c0 xor %eax,%eax 109a7d: eb 11 jmp 109a90 <_POSIX_Condition_variables_Get+0x40> /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 109a7f: 50 push %eax 109a80: 56 push %esi 109a81: ff 33 pushl (%ebx) 109a83: 68 d4 14 12 00 push $0x1214d4 109a88: e8 3b 29 00 00 call 10c3c8 <_Objects_Get> 109a8d: 83 c4 10 add $0x10,%esp _Objects_Get( &_POSIX_Condition_variables_Information, *id, location ); } 109a90: 8d 65 f8 lea -0x8(%ebp),%esp 109a93: 5b pop %ebx 109a94: 5e pop %esi 109a95: c9 leave 109a96: c3 ret =============================================================================== 00109c00 <_POSIX_Condition_variables_Wait_support>: pthread_cond_t *cond, pthread_mutex_t *mutex, Watchdog_Interval timeout, bool already_timedout ) { 109c00: 55 push %ebp 109c01: 89 e5 mov %esp,%ebp 109c03: 57 push %edi 109c04: 56 push %esi 109c05: 53 push %ebx 109c06: 83 ec 24 sub $0x24,%esp 109c09: 8b 7d 08 mov 0x8(%ebp),%edi 109c0c: 8b 75 0c mov 0xc(%ebp),%esi 109c0f: 8a 45 14 mov 0x14(%ebp),%al 109c12: 88 45 e3 mov %al,-0x1d(%ebp) register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; int status; int mutex_status; if ( !_POSIX_Mutex_Get( mutex, &location ) ) { 109c15: 8d 5d f0 lea -0x10(%ebp),%ebx 109c18: 53 push %ebx 109c19: 56 push %esi 109c1a: e8 82 01 00 00 call 109da1 <_POSIX_Mutex_Get> 109c1f: 83 c4 10 add $0x10,%esp 109c22: 85 c0 test %eax,%eax 109c24: 0f 84 af 00 00 00 je 109cd9 <_POSIX_Condition_variables_Wait_support+0xd9> 109c2a: a1 60 10 12 00 mov 0x121060,%eax 109c2f: 48 dec %eax 109c30: a3 60 10 12 00 mov %eax,0x121060 return EINVAL; } _Thread_Unnest_dispatch(); the_cond = _POSIX_Condition_variables_Get( cond, &location ); 109c35: 52 push %edx 109c36: 52 push %edx 109c37: 53 push %ebx 109c38: 57 push %edi 109c39: e8 12 fe ff ff call 109a50 <_POSIX_Condition_variables_Get> 109c3e: 89 c3 mov %eax,%ebx switch ( location ) { 109c40: 83 c4 10 add $0x10,%esp 109c43: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 109c47: 0f 85 8c 00 00 00 jne 109cd9 <_POSIX_Condition_variables_Wait_support+0xd9> case OBJECTS_LOCAL: if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) { 109c4d: 8b 40 14 mov 0x14(%eax),%eax 109c50: 85 c0 test %eax,%eax 109c52: 74 0b je 109c5f <_POSIX_Condition_variables_Wait_support+0x5f> 109c54: 3b 06 cmp (%esi),%eax 109c56: 74 07 je 109c5f <_POSIX_Condition_variables_Wait_support+0x5f><== ALWAYS TAKEN _Thread_Enable_dispatch(); 109c58: e8 2b 2f 00 00 call 10cb88 <_Thread_Enable_dispatch><== NOT EXECUTED 109c5d: eb 7a jmp 109cd9 <_POSIX_Condition_variables_Wait_support+0xd9><== NOT EXECUTED return EINVAL; } (void) pthread_mutex_unlock( mutex ); 109c5f: 83 ec 0c sub $0xc,%esp 109c62: 56 push %esi 109c63: e8 10 03 00 00 call 109f78 _Thread_Enable_dispatch(); return EINVAL; } */ if ( !already_timedout ) { 109c68: 83 c4 10 add $0x10,%esp 109c6b: 80 7d e3 00 cmpb $0x0,-0x1d(%ebp) 109c6f: 75 4e jne 109cbf <_POSIX_Condition_variables_Wait_support+0xbf> the_cond->Mutex = *mutex; 109c71: 8b 06 mov (%esi),%eax 109c73: 89 43 14 mov %eax,0x14(%ebx) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 109c76: c7 43 48 01 00 00 00 movl $0x1,0x48(%ebx) _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 109c7d: 8b 15 20 11 12 00 mov 0x121120,%edx 109c83: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) _Thread_Executing->Wait.queue = &the_cond->Wait_queue; 109c8a: 8d 4b 18 lea 0x18(%ebx),%ecx 109c8d: 89 4a 44 mov %ecx,0x44(%edx) _Thread_Executing->Wait.id = *cond; 109c90: 8b 07 mov (%edi),%eax 109c92: 89 42 20 mov %eax,0x20(%edx) _Thread_queue_Enqueue( &the_cond->Wait_queue, timeout ); 109c95: 50 push %eax 109c96: 68 28 d3 10 00 push $0x10d328 109c9b: ff 75 10 pushl 0x10(%ebp) 109c9e: 51 push %ecx 109c9f: e8 34 33 00 00 call 10cfd8 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 109ca4: e8 df 2e 00 00 call 10cb88 <_Thread_Enable_dispatch> /* * Switch ourself out because we blocked as a result of the * _Thread_queue_Enqueue. */ status = _Thread_Executing->Wait.return_code; 109ca9: a1 20 11 12 00 mov 0x121120,%eax 109cae: 8b 58 34 mov 0x34(%eax),%ebx if ( status && status != ETIMEDOUT ) 109cb1: 83 c4 10 add $0x10,%esp 109cb4: 85 db test %ebx,%ebx 109cb6: 74 11 je 109cc9 <_POSIX_Condition_variables_Wait_support+0xc9> 109cb8: 83 fb 74 cmp $0x74,%ebx 109cbb: 75 21 jne 109cde <_POSIX_Condition_variables_Wait_support+0xde><== NEVER TAKEN 109cbd: eb 0a jmp 109cc9 <_POSIX_Condition_variables_Wait_support+0xc9> return status; } else { _Thread_Enable_dispatch(); 109cbf: e8 c4 2e 00 00 call 10cb88 <_Thread_Enable_dispatch> 109cc4: bb 74 00 00 00 mov $0x74,%ebx /* * When we get here the dispatch disable level is 0. */ mutex_status = pthread_mutex_lock( mutex ); 109cc9: 83 ec 0c sub $0xc,%esp 109ccc: 56 push %esi 109ccd: e8 26 02 00 00 call 109ef8 if ( mutex_status ) 109cd2: 83 c4 10 add $0x10,%esp 109cd5: 85 c0 test %eax,%eax 109cd7: 74 05 je 109cde <_POSIX_Condition_variables_Wait_support+0xde> 109cd9: bb 16 00 00 00 mov $0x16,%ebx case OBJECTS_ERROR: break; } return EINVAL; } 109cde: 89 d8 mov %ebx,%eax 109ce0: 8d 65 f4 lea -0xc(%ebp),%esp 109ce3: 5b pop %ebx 109ce4: 5e pop %esi 109ce5: 5f pop %edi 109ce6: c9 leave 109ce7: c3 ret =============================================================================== 0010ea38 <_POSIX_Keys_Run_destructors>: */ void _POSIX_Keys_Run_destructors( Thread_Control *thread ) { 10ea38: 55 push %ebp 10ea39: 89 e5 mov %esp,%ebp 10ea3b: 57 push %edi 10ea3c: 56 push %esi 10ea3d: 53 push %ebx 10ea3e: 83 ec 0c sub $0xc,%esp uint32_t iterations; bool are_all_null; POSIX_Keys_Control *the_key; void *value; thread_index = _Objects_Get_index( thread->Object.id ); 10ea41: 8b 45 08 mov 0x8(%ebp),%eax 10ea44: 8b 40 08 mov 0x8(%eax),%eax uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10ea47: 89 c2 mov %eax,%edx 10ea49: c1 ea 18 shr $0x18,%edx 10ea4c: 83 e2 07 and $0x7,%edx the_key = (POSIX_Keys_Control *) _POSIX_Keys_Information.local_table[ index ]; if ( the_key && the_key->is_active && the_key->destructor ) { value = the_key->Values[ thread_api ][ thread_index ]; 10ea4f: 25 ff ff 00 00 and $0xffff,%eax 10ea54: c1 e0 02 shl $0x2,%eax 10ea57: 89 45 ec mov %eax,-0x14(%ebp) 10ea5a: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) 10ea61: 83 c2 04 add $0x4,%edx 10ea64: 89 55 e8 mov %edx,-0x18(%ebp) 10ea67: be 01 00 00 00 mov $0x1,%esi 10ea6c: bf 01 00 00 00 mov $0x1,%edi 10ea71: eb 49 jmp 10eabc <_POSIX_Keys_Run_destructors+0x84> are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { the_key = (POSIX_Keys_Control *) 10ea73: a1 e8 db 11 00 mov 0x11dbe8,%eax 10ea78: 8b 1c b0 mov (%eax,%esi,4),%ebx _POSIX_Keys_Information.local_table[ index ]; if ( the_key && the_key->is_active && the_key->destructor ) { 10ea7b: 85 db test %ebx,%ebx 10ea7d: 74 3c je 10eabb <_POSIX_Keys_Run_destructors+0x83> 10ea7f: 80 7b 10 00 cmpb $0x0,0x10(%ebx) 10ea83: 74 36 je 10eabb <_POSIX_Keys_Run_destructors+0x83><== NEVER TAKEN 10ea85: 8b 53 14 mov 0x14(%ebx),%edx 10ea88: 85 d2 test %edx,%edx 10ea8a: 74 2f je 10eabb <_POSIX_Keys_Run_destructors+0x83><== NEVER TAKEN value = the_key->Values[ thread_api ][ thread_index ]; 10ea8c: 8b 4d e8 mov -0x18(%ebp),%ecx 10ea8f: 8b 44 8b 08 mov 0x8(%ebx,%ecx,4),%eax 10ea93: 8b 4d ec mov -0x14(%ebp),%ecx 10ea96: 8b 04 08 mov (%eax,%ecx,1),%eax if ( value ) { 10ea99: 85 c0 test %eax,%eax 10ea9b: 74 1e je 10eabb <_POSIX_Keys_Run_destructors+0x83><== NEVER TAKEN (*the_key->destructor)( value ); 10ea9d: 83 ec 0c sub $0xc,%esp 10eaa0: 50 push %eax 10eaa1: ff d2 call *%edx if ( the_key->Values[ thread_api ][ thread_index ] ) 10eaa3: 8b 55 e8 mov -0x18(%ebp),%edx 10eaa6: 8b 44 93 08 mov 0x8(%ebx,%edx,4),%eax 10eaaa: 83 c4 10 add $0x10,%esp 10eaad: 8b 4d ec mov -0x14(%ebp),%ecx 10eab0: 83 3c 08 00 cmpl $0x0,(%eax,%ecx,1) 10eab4: 0f 94 c0 sete %al 10eab7: f7 d8 neg %eax 10eab9: 21 c7 and %eax,%edi for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 10eabb: 46 inc %esi 10eabc: 0f b7 05 dc db 11 00 movzwl 0x11dbdc,%eax 10eac3: 39 c6 cmp %eax,%esi 10eac5: 76 ac jbe 10ea73 <_POSIX_Keys_Run_destructors+0x3b> are_all_null = FALSE; } } } if ( are_all_null == TRUE ) 10eac7: 89 f8 mov %edi,%eax 10eac9: 84 c0 test %al,%al 10eacb: 75 09 jne 10ead6 <_POSIX_Keys_Run_destructors+0x9e> return; iterations++; 10eacd: ff 45 f0 incl -0x10(%ebp) * loop. It seems rude to unnecessarily lock up a system. * * Reference: 17.1.1.2 P1003.1c/Draft 10, p. 163, line 99. */ if ( iterations >= PTHREAD_DESTRUCTOR_ITERATIONS ) 10ead0: 83 7d f0 04 cmpl $0x4,-0x10(%ebp) 10ead4: 75 91 jne 10ea67 <_POSIX_Keys_Run_destructors+0x2f> return; } } 10ead6: 8d 65 f4 lea -0xc(%ebp),%esp 10ead9: 5b pop %ebx 10eada: 5e pop %esi 10eadb: 5f pop %edi 10eadc: c9 leave 10eadd: c3 ret =============================================================================== 001123e4 <_POSIX_Message_queue_Create_support>: const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 1123e4: 55 push %ebp 1123e5: 89 e5 mov %esp,%ebp 1123e7: 57 push %edi 1123e8: 56 push %esi 1123e9: 53 push %ebx 1123ea: 83 ec 24 sub $0x24,%esp 1123ed: 8b 75 10 mov 0x10(%ebp),%esi CORE_message_queue_Attributes *the_mq_attr; struct mq_attr attr; char *name; size_t n; n = strnlen( name_arg, NAME_MAX ); 1123f0: 68 ff 00 00 00 push $0xff 1123f5: ff 75 08 pushl 0x8(%ebp) 1123f8: e8 b7 35 00 00 call 1159b4 1123fd: 89 c3 mov %eax,%ebx if ( n > NAME_MAX ) 1123ff: 83 c4 10 add $0x10,%esp 112402: b8 5b 00 00 00 mov $0x5b,%eax 112407: 81 fb ff 00 00 00 cmp $0xff,%ebx 11240d: 0f 87 34 01 00 00 ja 112547 <_POSIX_Message_queue_Create_support+0x163><== NEVER TAKEN /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 112413: a1 58 63 12 00 mov 0x126358,%eax 112418: 40 inc %eax 112419: a3 58 63 12 00 mov %eax,0x126358 * but were not compared against any existing implementation for * compatibility. See README.mqueue for an example program we * think will print out the defaults. Report anything you find with it. */ if ( attr_ptr == NULL ) { 11241e: 85 f6 test %esi,%esi 112420: 75 0d jne 11242f <_POSIX_Message_queue_Create_support+0x4b> 112422: c7 45 e0 10 00 00 00 movl $0x10,-0x20(%ebp) 112429: 66 be 0a 00 mov $0xa,%si 11242d: eb 31 jmp 112460 <_POSIX_Message_queue_Create_support+0x7c> attr.mq_maxmsg = 10; attr.mq_msgsize = 16; } else { if ( attr_ptr->mq_maxmsg <= 0 ){ 11242f: 83 7e 04 00 cmpl $0x0,0x4(%esi) 112433: 7e 06 jle 11243b <_POSIX_Message_queue_Create_support+0x57> _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ 112435: 83 7e 08 00 cmpl $0x0,0x8(%esi) 112439: 7f 12 jg 11244d <_POSIX_Message_queue_Create_support+0x69> _Thread_Enable_dispatch(); 11243b: e8 f4 d8 ff ff call 10fd34 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EINVAL ); 112440: e8 c7 1f 00 00 call 11440c <__errno> 112445: c7 00 16 00 00 00 movl $0x16,(%eax) 11244b: eb 39 jmp 112486 <_POSIX_Message_queue_Create_support+0xa2> } attr = *attr_ptr; 11244d: 8d 7d e4 lea -0x1c(%ebp),%edi 112450: b9 04 00 00 00 mov $0x4,%ecx 112455: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 112457: 8b 45 ec mov -0x14(%ebp),%eax 11245a: 89 45 e0 mov %eax,-0x20(%ebp) 11245d: 8b 75 e8 mov -0x18(%ebp),%esi * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus extern "C" { 112460: 83 ec 0c sub $0xc,%esp 112463: 68 c8 66 12 00 push $0x1266c8 112468: e8 77 cc ff ff call 10f0e4 <_Objects_Allocate> 11246d: 89 c7 mov %eax,%edi } the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { 11246f: 83 c4 10 add $0x10,%esp 112472: 85 c0 test %eax,%eax 112474: 75 18 jne 11248e <_POSIX_Message_queue_Create_support+0xaa><== ALWAYS TAKEN _Thread_Enable_dispatch(); 112476: e8 b9 d8 ff ff call 10fd34 <_Thread_Enable_dispatch><== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENFILE ); 11247b: e8 8c 1f 00 00 call 11440c <__errno> <== NOT EXECUTED 112480: c7 00 17 00 00 00 movl $0x17,(%eax) <== NOT EXECUTED 112486: 83 c8 ff or $0xffffffff,%eax 112489: e9 b9 00 00 00 jmp 112547 <_POSIX_Message_queue_Create_support+0x163> } the_mq->process_shared = pshared; 11248e: 8b 45 0c mov 0xc(%ebp),%eax 112491: 89 47 10 mov %eax,0x10(%edi) the_mq->named = TRUE; 112494: c6 47 14 01 movb $0x1,0x14(%edi) the_mq->open_count = 1; 112498: c7 47 18 01 00 00 00 movl $0x1,0x18(%edi) the_mq->linked = TRUE; 11249f: c6 47 15 01 movb $0x1,0x15(%edi) /* * Make a copy of the user's string for name just in case it was * dynamically constructed. */ name = _Workspace_Allocate(n); 1124a3: 83 ec 0c sub $0xc,%esp 1124a6: 53 push %ebx 1124a7: e8 01 e9 ff ff call 110dad <_Workspace_Allocate> 1124ac: 89 c3 mov %eax,%ebx if (!name) { 1124ae: 83 c4 10 add $0x10,%esp 1124b1: 85 c0 test %eax,%eax 1124b3: 75 1f jne 1124d4 <_POSIX_Message_queue_Create_support+0xf0><== ALWAYS TAKEN Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 1124b5: 51 push %ecx <== NOT EXECUTED 1124b6: 51 push %ecx <== NOT EXECUTED 1124b7: 57 push %edi <== NOT EXECUTED 1124b8: 68 c8 66 12 00 push $0x1266c8 <== NOT EXECUTED 1124bd: e8 32 cf ff ff call 10f3f4 <_Objects_Free> <== NOT EXECUTED _POSIX_Message_queue_Free( the_mq ); _Thread_Enable_dispatch(); 1124c2: e8 6d d8 ff ff call 10fd34 <_Thread_Enable_dispatch><== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); 1124c7: e8 40 1f 00 00 call 11440c <__errno> <== NOT EXECUTED 1124cc: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 1124d2: eb 4f jmp 112523 <_POSIX_Message_queue_Create_support+0x13f><== NOT EXECUTED } strcpy( name, name_arg ); 1124d4: 52 push %edx 1124d5: 52 push %edx 1124d6: ff 75 08 pushl 0x8(%ebp) 1124d9: 50 push %eax 1124da: e8 b9 30 00 00 call 115598 * Note that thread blocking discipline should be based on the * current scheduling policy. */ the_mq_attr = &the_mq->Message_queue.Attributes; the_mq_attr->discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; 1124df: c7 47 5c 00 00 00 00 movl $0x0,0x5c(%edi) if ( ! _CORE_message_queue_Initialize( 1124e6: ff 75 e0 pushl -0x20(%ebp) 1124e9: 56 push %esi 1124ea: 8d 47 5c lea 0x5c(%edi),%eax 1124ed: 50 push %eax 1124ee: 8d 47 1c lea 0x1c(%edi),%eax 1124f1: 50 push %eax 1124f2: e8 d1 09 00 00 call 112ec8 <_CORE_message_queue_Initialize> 1124f7: 83 c4 20 add $0x20,%esp 1124fa: 84 c0 test %al,%al 1124fc: 75 2d jne 11252b <_POSIX_Message_queue_Create_support+0x147><== ALWAYS TAKEN 1124fe: 50 push %eax <== NOT EXECUTED 1124ff: 50 push %eax <== NOT EXECUTED 112500: 57 push %edi <== NOT EXECUTED 112501: 68 c8 66 12 00 push $0x1266c8 <== NOT EXECUTED 112506: e8 e9 ce ff ff call 10f3f4 <_Objects_Free> <== NOT EXECUTED attr.mq_maxmsg, attr.mq_msgsize ) ) { _POSIX_Message_queue_Free( the_mq ); _Workspace_Free(name); 11250b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 11250e: e8 85 e8 ff ff call 110d98 <_Workspace_Free> <== NOT EXECUTED _Thread_Enable_dispatch(); 112513: e8 1c d8 ff ff call 10fd34 <_Thread_Enable_dispatch><== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); 112518: e8 ef 1e 00 00 call 11440c <__errno> <== NOT EXECUTED 11251d: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 112523: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 112526: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112529: eb 1c jmp 112547 <_POSIX_Message_queue_Create_support+0x163><== NOT EXECUTED 11252b: 0f b7 47 08 movzwl 0x8(%edi),%eax 11252f: 8b 15 e4 66 12 00 mov 0x1266e4,%edx 112535: 89 3c 82 mov %edi,(%edx,%eax,4) 112538: 89 5f 0c mov %ebx,0xc(%edi) &_POSIX_Message_queue_Information, &the_mq->Object, name ); *message_queue = the_mq; 11253b: 8b 45 14 mov 0x14(%ebp),%eax 11253e: 89 38 mov %edi,(%eax) _Thread_Enable_dispatch(); 112540: e8 ef d7 ff ff call 10fd34 <_Thread_Enable_dispatch> 112545: 31 c0 xor %eax,%eax return 0; } 112547: 8d 65 f4 lea -0xc(%ebp),%esp 11254a: 5b pop %ebx 11254b: 5e pop %esi 11254c: 5f pop %edi 11254d: c9 leave 11254e: c3 ret =============================================================================== 0010c4fc <_POSIX_Message_queue_Delete>: */ void _POSIX_Message_queue_Delete( POSIX_Message_queue_Control *the_mq ) { 10c4fc: 55 push %ebp 10c4fd: 89 e5 mov %esp,%ebp 10c4ff: 53 push %ebx 10c500: 83 ec 04 sub $0x4,%esp 10c503: 8b 5d 08 mov 0x8(%ebp),%ebx if ( !the_mq->linked && !the_mq->open_count ) { 10c506: 80 7b 15 00 cmpb $0x0,0x15(%ebx) 10c50a: 75 46 jne 10c552 <_POSIX_Message_queue_Delete+0x56> 10c50c: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 10c510: 75 40 jne 10c552 <_POSIX_Message_queue_Delete+0x56> /* the name memory may have been freed by unlink. */ Objects_Control *the_object = &the_mq->Object; if ( the_object->name.name_p ) 10c512: 8b 43 0c mov 0xc(%ebx),%eax 10c515: 85 c0 test %eax,%eax 10c517: 74 0c je 10c525 <_POSIX_Message_queue_Delete+0x29><== ALWAYS TAKEN _Workspace_Free( (void *)the_object->name.name_p ); 10c519: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c51c: 50 push %eax <== NOT EXECUTED 10c51d: e8 76 48 00 00 call 110d98 <_Workspace_Free> <== NOT EXECUTED 10c522: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Objects_Close( &_POSIX_Message_queue_Information, the_object ); 10c525: 51 push %ecx 10c526: 51 push %ecx 10c527: 53 push %ebx 10c528: 68 c8 66 12 00 push $0x1266c8 10c52d: e8 26 2c 00 00 call 10f158 <_Objects_Close> _CORE_message_queue_Close( 10c532: 83 c4 0c add $0xc,%esp 10c535: 6a 05 push $0x5 10c537: 6a 00 push $0x0 10c539: 8d 43 1c lea 0x1c(%ebx),%eax 10c53c: 50 push %eax 10c53d: e8 32 22 00 00 call 10e774 <_CORE_message_queue_Close> Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 10c542: 58 pop %eax 10c543: 5a pop %edx 10c544: 53 push %ebx 10c545: 68 c8 66 12 00 push $0x1266c8 10c54a: e8 a5 2e 00 00 call 10f3f4 <_Objects_Free> 10c54f: 83 c4 10 add $0x10,%esp ); _POSIX_Message_queue_Free( the_mq ); } } 10c552: 8b 5d fc mov -0x4(%ebp),%ebx 10c555: c9 leave 10c556: c3 ret =============================================================================== 0010c820 <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 10c820: 55 push %ebp 10c821: 89 e5 mov %esp,%ebp 10c823: 57 push %edi 10c824: 56 push %esi 10c825: 53 push %ebx 10c826: 83 ec 20 sub $0x20,%esp 10c829: 8b 7d 08 mov 0x8(%ebp),%edi 10c82c: 8b 75 14 mov 0x14(%ebp),%esi 10c82f: 8a 5d 18 mov 0x18(%ebp),%bl */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 10c832: 8d 45 f0 lea -0x10(%ebp),%eax 10c835: 50 push %eax 10c836: 57 push %edi 10c837: 68 44 68 12 00 push $0x126844 10c83c: e8 e7 2c 00 00 call 10f528 <_Objects_Get> 10c841: 89 c1 mov %eax,%ecx Objects_Locations location; size_t length_out; bool do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 10c843: 83 c4 10 add $0x10,%esp 10c846: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 10c84a: 0f 85 b0 00 00 00 jne 10c900 <_POSIX_Message_queue_Receive_support+0xe0> case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 10c850: 8b 50 14 mov 0x14(%eax),%edx 10c853: 89 d0 mov %edx,%eax 10c855: 83 e0 03 and $0x3,%eax 10c858: 48 dec %eax 10c859: 75 0a jne 10c865 <_POSIX_Message_queue_Receive_support+0x45> _Thread_Enable_dispatch(); 10c85b: e8 d4 34 00 00 call 10fd34 <_Thread_Enable_dispatch> 10c860: e9 9b 00 00 00 jmp 10c900 <_POSIX_Message_queue_Receive_support+0xe0> rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10c865: 8b 49 10 mov 0x10(%ecx),%ecx if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 10c868: 8b 45 10 mov 0x10(%ebp),%eax 10c86b: 3b 41 68 cmp 0x68(%ecx),%eax 10c86e: 73 15 jae 10c885 <_POSIX_Message_queue_Receive_support+0x65> _Thread_Enable_dispatch(); 10c870: e8 bf 34 00 00 call 10fd34 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EMSGSIZE ); 10c875: e8 92 7b 00 00 call 11440c <__errno> 10c87a: c7 00 7a 00 00 00 movl $0x7a,(%eax) 10c880: e9 86 00 00 00 jmp 10c90b <_POSIX_Message_queue_Receive_support+0xeb> length_out = -1; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10c885: 31 c0 xor %eax,%eax 10c887: 84 db test %bl,%bl 10c889: 74 0b je 10c896 <_POSIX_Message_queue_Receive_support+0x76><== NEVER TAKEN do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE; 10c88b: c1 ea 0e shr $0xe,%edx 10c88e: 83 f2 01 xor $0x1,%edx 10c891: 88 d0 mov %dl,%al 10c893: 83 e0 01 and $0x1,%eax /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 10c896: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp) do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 10c89d: 52 push %edx 10c89e: 52 push %edx 10c89f: ff 75 1c pushl 0x1c(%ebp) 10c8a2: 0f b6 c0 movzbl %al,%eax 10c8a5: 50 push %eax 10c8a6: 8d 45 ec lea -0x14(%ebp),%eax 10c8a9: 50 push %eax 10c8aa: ff 75 0c pushl 0xc(%ebp) 10c8ad: 57 push %edi 10c8ae: 8d 41 1c lea 0x1c(%ecx),%eax 10c8b1: 50 push %eax 10c8b2: e8 41 1f 00 00 call 10e7f8 <_CORE_message_queue_Seize> &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 10c8b7: 83 c4 20 add $0x20,%esp 10c8ba: e8 75 34 00 00 call 10fd34 <_Thread_Enable_dispatch> *msg_prio = 10c8bf: 8b 0d 18 64 12 00 mov 0x126418,%ecx 10c8c5: 8b 41 24 mov 0x24(%ecx),%eax 10c8c8: c1 f8 1f sar $0x1f,%eax 10c8cb: 89 c2 mov %eax,%edx 10c8cd: 33 51 24 xor 0x24(%ecx),%edx 10c8d0: 89 16 mov %edx,(%esi) 10c8d2: 29 06 sub %eax,(%esi) _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 10c8d4: 83 79 34 00 cmpl $0x0,0x34(%ecx) 10c8d8: 75 05 jne 10c8df <_POSIX_Message_queue_Receive_support+0xbf> return length_out; 10c8da: 8b 45 ec mov -0x14(%ebp),%eax 10c8dd: eb 2f jmp 10c90e <_POSIX_Message_queue_Receive_support+0xee> rtems_set_errno_and_return_minus_one( 10c8df: e8 28 7b 00 00 call 11440c <__errno> 10c8e4: 89 c3 mov %eax,%ebx 10c8e6: 83 ec 0c sub $0xc,%esp 10c8e9: a1 18 64 12 00 mov 0x126418,%eax 10c8ee: ff 70 34 pushl 0x34(%eax) 10c8f1: e8 fa 01 00 00 call 10caf0 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10c8f6: 89 03 mov %eax,(%ebx) 10c8f8: 83 c8 ff or $0xffffffff,%eax 10c8fb: 83 c4 10 add $0x10,%esp 10c8fe: eb 0e jmp 10c90e <_POSIX_Message_queue_Receive_support+0xee> #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10c900: e8 07 7b 00 00 call 11440c <__errno> 10c905: c7 00 09 00 00 00 movl $0x9,(%eax) 10c90b: 83 c8 ff or $0xffffffff,%eax } 10c90e: 8d 65 f4 lea -0xc(%ebp),%esp 10c911: 5b pop %ebx 10c912: 5e pop %esi 10c913: 5f pop %edi 10c914: c9 leave 10c915: c3 ret =============================================================================== 0010c938 <_POSIX_Message_queue_Send_support>: size_t msg_len, uint32_t msg_prio, bool wait, Watchdog_Interval timeout ) { 10c938: 55 push %ebp 10c939: 89 e5 mov %esp,%ebp 10c93b: 56 push %esi 10c93c: 53 push %ebx 10c93d: 83 ec 20 sub $0x20,%esp 10c940: 8b 75 08 mov 0x8(%ebp),%esi 10c943: 8b 5d 14 mov 0x14(%ebp),%ebx 10c946: 8a 45 18 mov 0x18(%ebp),%al 10c949: 88 45 e7 mov %al,-0x19(%ebp) /* * Validate the priority. * XXX - Do not validate msg_prio is not less than 0. */ if ( msg_prio > MQ_PRIO_MAX ) 10c94c: 83 fb 20 cmp $0x20,%ebx 10c94f: 76 10 jbe 10c961 <_POSIX_Message_queue_Send_support+0x29> rtems_set_errno_and_return_minus_one( EINVAL ); 10c951: e8 b6 7a 00 00 call 11440c <__errno> 10c956: c7 00 16 00 00 00 movl $0x16,(%eax) 10c95c: e9 9c 00 00 00 jmp 10c9fd <_POSIX_Message_queue_Send_support+0xc5> 10c961: 50 push %eax 10c962: 8d 45 f4 lea -0xc(%ebp),%eax 10c965: 50 push %eax 10c966: 56 push %esi 10c967: 68 44 68 12 00 push $0x126844 10c96c: e8 b7 2b 00 00 call 10f528 <_Objects_Get> the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 10c971: 83 c4 10 add $0x10,%esp 10c974: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10c978: 75 78 jne 10c9f2 <_POSIX_Message_queue_Send_support+0xba> case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) { 10c97a: 8b 50 14 mov 0x14(%eax),%edx 10c97d: f6 c2 03 test $0x3,%dl 10c980: 75 07 jne 10c989 <_POSIX_Message_queue_Send_support+0x51> _Thread_Enable_dispatch(); 10c982: e8 ad 33 00 00 call 10fd34 <_Thread_Enable_dispatch> 10c987: eb 69 jmp 10c9f2 <_POSIX_Message_queue_Send_support+0xba> rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10c989: 8b 48 10 mov 0x10(%eax),%ecx /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10c98c: 31 c0 xor %eax,%eax 10c98e: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) 10c992: 74 0b je 10c99f <_POSIX_Message_queue_Send_support+0x67><== NEVER TAKEN do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? FALSE : TRUE; 10c994: c1 ea 0e shr $0xe,%edx 10c997: 83 f2 01 xor $0x1,%edx 10c99a: 88 d0 mov %dl,%al 10c99c: 83 e0 01 and $0x1,%eax do_wait = wait; /* * Now perform the actual message receive */ msg_status = _CORE_message_queue_Submit( 10c99f: ff 75 1c pushl 0x1c(%ebp) 10c9a2: 0f b6 c0 movzbl %al,%eax 10c9a5: 50 push %eax 10c9a6: f7 db neg %ebx 10c9a8: 53 push %ebx 10c9a9: 6a 00 push $0x0 10c9ab: 56 push %esi 10c9ac: ff 75 10 pushl 0x10(%ebp) 10c9af: ff 75 0c pushl 0xc(%ebp) 10c9b2: 8d 41 1c lea 0x1c(%ecx),%eax 10c9b5: 50 push %eax 10c9b6: e8 85 1f 00 00 call 10e940 <_CORE_message_queue_Submit> 10c9bb: 89 c6 mov %eax,%esi _POSIX_Message_queue_Priority_to_core( msg_prio ), do_wait, timeout /* no timeout */ ); _Thread_Enable_dispatch(); 10c9bd: 83 c4 20 add $0x20,%esp 10c9c0: e8 6f 33 00 00 call 10fd34 <_Thread_Enable_dispatch> * after it wakes up. The returned status is correct for * non-blocking operations but if we blocked, then we need * to look at the status in our TCB. */ if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT ) 10c9c5: 83 fe 07 cmp $0x7,%esi 10c9c8: 75 08 jne 10c9d2 <_POSIX_Message_queue_Send_support+0x9a> msg_status = _Thread_Executing->Wait.return_code; 10c9ca: a1 18 64 12 00 mov 0x126418,%eax 10c9cf: 8b 70 34 mov 0x34(%eax),%esi if ( !msg_status ) 10c9d2: 31 c0 xor %eax,%eax 10c9d4: 85 f6 test %esi,%esi 10c9d6: 74 28 je 10ca00 <_POSIX_Message_queue_Send_support+0xc8> return msg_status; rtems_set_errno_and_return_minus_one( 10c9d8: e8 2f 7a 00 00 call 11440c <__errno> 10c9dd: 89 c3 mov %eax,%ebx 10c9df: 83 ec 0c sub $0xc,%esp 10c9e2: 56 push %esi 10c9e3: e8 08 01 00 00 call 10caf0 <_POSIX_Message_queue_Translate_core_message_queue_return_code> 10c9e8: 89 03 mov %eax,(%ebx) 10c9ea: 83 c8 ff or $0xffffffff,%eax 10c9ed: 83 c4 10 add $0x10,%esp 10c9f0: eb 0e jmp 10ca00 <_POSIX_Message_queue_Send_support+0xc8> #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10c9f2: e8 15 7a 00 00 call 11440c <__errno> 10c9f7: c7 00 09 00 00 00 movl $0x9,(%eax) 10c9fd: 83 c8 ff or $0xffffffff,%eax } 10ca00: 8d 65 f8 lea -0x8(%ebp),%esp 10ca03: 5b pop %ebx 10ca04: 5e pop %esi 10ca05: c9 leave 10ca06: c3 ret =============================================================================== 0010a80d <_POSIX_Mutex_Get>: POSIX_Mutex_Control *_POSIX_Mutex_Get ( pthread_mutex_t *mutex, Objects_Locations *location ) { 10a80d: 55 push %ebp 10a80e: 89 e5 mov %esp,%ebp 10a810: 56 push %esi 10a811: 53 push %ebx 10a812: 8b 5d 08 mov 0x8(%ebp),%ebx 10a815: 8b 75 0c mov 0xc(%ebp),%esi Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 10a818: 85 db test %ebx,%ebx 10a81a: 74 16 je 10a832 <_POSIX_Mutex_Get+0x25> 10a81c: 83 3b ff cmpl $0xffffffff,(%ebx) 10a81f: 75 1b jne 10a83c <_POSIX_Mutex_Get+0x2f> <== ALWAYS TAKEN 10a821: 51 push %ecx <== NOT EXECUTED 10a822: 51 push %ecx <== NOT EXECUTED 10a823: 6a 00 push $0x0 <== NOT EXECUTED 10a825: 53 push %ebx <== NOT EXECUTED 10a826: e8 6d 00 00 00 call 10a898 <== NOT EXECUTED 10a82b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a82e: 85 c0 test %eax,%eax <== NOT EXECUTED 10a830: 74 0a je 10a83c <_POSIX_Mutex_Get+0x2f> <== NOT EXECUTED 10a832: c7 06 01 00 00 00 movl $0x1,(%esi) 10a838: 31 c0 xor %eax,%eax 10a83a: eb 11 jmp 10a84d <_POSIX_Mutex_Get+0x40> return (POSIX_Mutex_Control *) 10a83c: 52 push %edx 10a83d: 56 push %esi 10a83e: ff 33 pushl (%ebx) 10a840: 68 18 2f 12 00 push $0x122f18 10a845: e8 1a 29 00 00 call 10d164 <_Objects_Get> 10a84a: 83 c4 10 add $0x10,%esp _Objects_Get( &_POSIX_Mutex_Information, *id, location ); } 10a84d: 8d 65 f8 lea -0x8(%ebp),%esp 10a850: 5b pop %ebx 10a851: 5e pop %esi 10a852: c9 leave 10a853: c3 ret =============================================================================== 0010a7c4 <_POSIX_Mutex_Get_interrupt_disable>: POSIX_Mutex_Control *_POSIX_Mutex_Get_interrupt_disable ( pthread_mutex_t *mutex, Objects_Locations *location, ISR_Level *level ) { 10a7c4: 55 push %ebp 10a7c5: 89 e5 mov %esp,%ebp 10a7c7: 56 push %esi 10a7c8: 53 push %ebx 10a7c9: 8b 5d 08 mov 0x8(%ebp),%ebx 10a7cc: 8b 75 0c mov 0xc(%ebp),%esi Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 10a7cf: 85 db test %ebx,%ebx 10a7d1: 74 16 je 10a7e9 <_POSIX_Mutex_Get_interrupt_disable+0x25><== NEVER TAKEN 10a7d3: 83 3b ff cmpl $0xffffffff,(%ebx) 10a7d6: 75 1b jne 10a7f3 <_POSIX_Mutex_Get_interrupt_disable+0x2f><== ALWAYS TAKEN 10a7d8: 50 push %eax <== NOT EXECUTED 10a7d9: 50 push %eax <== NOT EXECUTED 10a7da: 6a 00 push $0x0 <== NOT EXECUTED 10a7dc: 53 push %ebx <== NOT EXECUTED 10a7dd: e8 b6 00 00 00 call 10a898 <== NOT EXECUTED 10a7e2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a7e5: 85 c0 test %eax,%eax <== NOT EXECUTED 10a7e7: 74 0a je 10a7f3 <_POSIX_Mutex_Get_interrupt_disable+0x2f><== NOT EXECUTED 10a7e9: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10a7ef: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a7f1: eb 13 jmp 10a806 <_POSIX_Mutex_Get_interrupt_disable+0x42><== NOT EXECUTED return (POSIX_Mutex_Control *) 10a7f3: ff 75 10 pushl 0x10(%ebp) 10a7f6: 56 push %esi 10a7f7: ff 33 pushl (%ebx) 10a7f9: 68 18 2f 12 00 push $0x122f18 10a7fe: e8 15 29 00 00 call 10d118 <_Objects_Get_isr_disable> 10a803: 83 c4 10 add $0x10,%esp _Objects_Get_isr_disable( &_POSIX_Mutex_Information, *id, location, level ); } 10a806: 8d 65 f8 lea -0x8(%ebp),%esp 10a809: 5b pop %ebx 10a80a: 5e pop %esi 10a80b: c9 leave 10a80c: c3 ret =============================================================================== 00110ae0 <_POSIX_Semaphore_Create_support>: const char *name, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) { 110ae0: 55 push %ebp 110ae1: 89 e5 mov %esp,%ebp 110ae3: 57 push %edi 110ae4: 56 push %esi 110ae5: 53 push %ebx 110ae6: 83 ec 0c sub $0xc,%esp 110ae9: 8b 75 08 mov 0x8(%ebp),%esi /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 110aec: a1 10 35 12 00 mov 0x123510,%eax 110af1: 40 inc %eax 110af2: a3 10 35 12 00 mov %eax,0x123510 char *name_p = (char *)name; _Thread_Disable_dispatch(); /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) { 110af7: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 110afb: 74 12 je 110b0f <_POSIX_Semaphore_Create_support+0x2f> _Thread_Enable_dispatch(); 110afd: e8 e6 d1 ff ff call 10dce8 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSYS ); 110b02: e8 5d 1b 00 00 call 112664 <__errno> 110b07: c7 00 58 00 00 00 movl $0x58,(%eax) 110b0d: eb 28 jmp 110b37 <_POSIX_Semaphore_Create_support+0x57> } if ( name ) { 110b0f: 85 f6 test %esi,%esi 110b11: 74 2c je 110b3f <_POSIX_Semaphore_Create_support+0x5f> if( strlen(name) > PATH_MAX ) { 110b13: 31 c0 xor %eax,%eax 110b15: 83 c9 ff or $0xffffffff,%ecx 110b18: 89 f7 mov %esi,%edi 110b1a: f2 ae repnz scas %es:(%edi),%al 110b1c: f7 d1 not %ecx 110b1e: 49 dec %ecx 110b1f: 81 f9 ff 00 00 00 cmp $0xff,%ecx 110b25: 76 18 jbe 110b3f <_POSIX_Semaphore_Create_support+0x5f><== ALWAYS TAKEN _Thread_Enable_dispatch(); 110b27: e8 bc d1 ff ff call 10dce8 <_Thread_Enable_dispatch><== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 110b2c: e8 33 1b 00 00 call 112664 <__errno> <== NOT EXECUTED 110b31: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED 110b37: 83 c8 ff or $0xffffffff,%eax 110b3a: e9 90 00 00 00 jmp 110bcf <_POSIX_Semaphore_Create_support+0xef> * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 110b3f: 83 ec 0c sub $0xc,%esp 110b42: 68 00 38 12 00 push $0x123800 110b47: e8 98 c5 ff ff call 10d0e4 <_Objects_Allocate> 110b4c: 89 c3 mov %eax,%ebx } } the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { 110b4e: 83 c4 10 add $0x10,%esp 110b51: 85 c0 test %eax,%eax 110b53: 75 12 jne 110b67 <_POSIX_Semaphore_Create_support+0x87> _Thread_Enable_dispatch(); 110b55: e8 8e d1 ff ff call 10dce8 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( ENOSPC ); 110b5a: e8 05 1b 00 00 call 112664 <__errno> 110b5f: c7 00 1c 00 00 00 movl $0x1c,(%eax) 110b65: eb d0 jmp 110b37 <_POSIX_Semaphore_Create_support+0x57> } the_semaphore->process_shared = pshared; 110b67: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) if ( name ) { 110b6e: 85 f6 test %esi,%esi 110b70: 74 11 je 110b83 <_POSIX_Semaphore_Create_support+0xa3> the_semaphore->named = TRUE; 110b72: c6 40 14 01 movb $0x1,0x14(%eax) the_semaphore->open_count = 1; 110b76: c7 40 18 01 00 00 00 movl $0x1,0x18(%eax) the_semaphore->linked = TRUE; 110b7d: c6 40 15 01 movb $0x1,0x15(%eax) 110b81: eb 0f jmp 110b92 <_POSIX_Semaphore_Create_support+0xb2> } else { the_semaphore->named = FALSE; 110b83: c6 40 14 00 movb $0x0,0x14(%eax) the_semaphore->open_count = 0; 110b87: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) the_semaphore->linked = FALSE; 110b8e: c6 40 15 00 movb $0x0,0x15(%eax) * be derived from the current scheduling policy. One * thing is certain, no matter what we decide, it won't be * the same as all other POSIX implementations. :) */ the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO; 110b92: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 110b99: c7 43 5c ff ff ff ff movl $0xffffffff,0x5c(%ebx) _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 110ba0: 50 push %eax 110ba1: ff 75 10 pushl 0x10(%ebp) 110ba4: 8d 43 5c lea 0x5c(%ebx),%eax 110ba7: 50 push %eax 110ba8: 8d 43 1c lea 0x1c(%ebx),%eax 110bab: 50 push %eax 110bac: e8 6f c1 ff ff call 10cd20 <_CORE_semaphore_Initialize> 110bb1: 0f b7 53 08 movzwl 0x8(%ebx),%edx 110bb5: a1 1c 38 12 00 mov 0x12381c,%eax 110bba: 89 1c 90 mov %ebx,(%eax,%edx,4) 110bbd: 89 73 0c mov %esi,0xc(%ebx) &_POSIX_Semaphore_Information, &the_semaphore->Object, name_p ); *the_sem = the_semaphore; 110bc0: 8b 45 14 mov 0x14(%ebp),%eax 110bc3: 89 18 mov %ebx,(%eax) _Thread_Enable_dispatch(); 110bc5: e8 1e d1 ff ff call 10dce8 <_Thread_Enable_dispatch> 110bca: 31 c0 xor %eax,%eax 110bcc: 83 c4 10 add $0x10,%esp return 0; } 110bcf: 8d 65 f4 lea -0xc(%ebp),%esp 110bd2: 5b pop %ebx 110bd3: 5e pop %esi 110bd4: 5f pop %edi 110bd5: c9 leave 110bd6: c3 ret =============================================================================== 0010d6cd <_POSIX_Threads_Create_extension>: bool _POSIX_Threads_Create_extension( Thread_Control *executing, Thread_Control *created ) { 10d6cd: 55 push %ebp 10d6ce: 89 e5 mov %esp,%ebp 10d6d0: 57 push %edi 10d6d1: 56 push %esi 10d6d2: 53 push %ebx 10d6d3: 83 ec 18 sub $0x18,%esp POSIX_API_Control *api; POSIX_API_Control *executing_api; api = _Workspace_Allocate( sizeof( POSIX_API_Control ) ); 10d6d6: 68 e4 00 00 00 push $0xe4 10d6db: e8 49 e7 ff ff call 10be29 <_Workspace_Allocate> 10d6e0: 89 c3 mov %eax,%ebx if ( !api ) 10d6e2: 83 c4 10 add $0x10,%esp 10d6e5: 31 c0 xor %eax,%eax 10d6e7: 85 db test %ebx,%ebx 10d6e9: 0f 84 05 01 00 00 je 10d7f4 <_POSIX_Threads_Create_extension+0x127><== NEVER TAKEN return false; created->API_Extensions[ THREAD_API_POSIX ] = api; 10d6ef: 8b 45 0c mov 0xc(%ebp),%eax 10d6f2: 89 98 f8 00 00 00 mov %ebx,0xf8(%eax) /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; 10d6f8: be 38 79 11 00 mov $0x117938,%esi 10d6fd: b9 0e 00 00 00 mov $0xe,%ecx 10d702: 89 df mov %ebx,%edi 10d704: f3 a5 rep movsl %ds:(%esi),%es:(%edi) api->detachstate = _POSIX_Threads_Default_attributes.detachstate; 10d706: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; 10d70d: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx) api->schedparam = _POSIX_Threads_Default_attributes.schedparam; 10d714: be 50 79 11 00 mov $0x117950,%esi 10d719: 8d bb 80 00 00 00 lea 0x80(%ebx),%edi 10d71f: b1 06 mov $0x6,%cl 10d721: f3 a5 rep movsl %ds:(%esi),%es:(%edi) api->schedparam.sched_priority = 10d723: b8 ff 00 00 00 mov $0xff,%eax 10d728: 8b 55 0c mov 0xc(%ebp),%edx 10d72b: 2b 42 14 sub 0x14(%edx),%eax 10d72e: 89 83 80 00 00 00 mov %eax,0x80(%ebx) _POSIX_Priority_From_core( created->current_priority ); /* * POSIX 1003.1 1996, 18.2.2.2 */ api->cancelation_requested = 0; 10d734: c7 83 d4 00 00 00 00 movl $0x0,0xd4(%ebx) 10d73b: 00 00 00 api->cancelability_state = PTHREAD_CANCEL_ENABLE; 10d73e: c7 83 cc 00 00 00 00 movl $0x0,0xcc(%ebx) 10d745: 00 00 00 api->cancelability_type = PTHREAD_CANCEL_DEFERRED; 10d748: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx) 10d74f: 00 00 00 10d752: 8d 83 dc 00 00 00 lea 0xdc(%ebx),%eax 10d758: 89 83 d8 00 00 00 mov %eax,0xd8(%ebx) 10d75e: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx) 10d765: 00 00 00 10d768: 8d 83 d8 00 00 00 lea 0xd8(%ebx),%eax 10d76e: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx) * If the thread is not a posix thread, then all posix signals are blocked * by default. */ /* XXX use signal constants */ api->signals_pending = 0; 10d774: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) 10d77b: 00 00 00 if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API && 10d77e: 8b 52 08 mov 0x8(%edx),%edx 10d781: 89 d0 mov %edx,%eax 10d783: c1 e8 18 shr $0x18,%eax 10d786: 83 e0 07 and $0x7,%eax 10d789: 83 f8 03 cmp $0x3,%eax 10d78c: 75 1f jne 10d7ad <_POSIX_Threads_Create_extension+0xe0> 10d78e: c1 ea 1b shr $0x1b,%edx 10d791: 4a dec %edx 10d792: 75 19 jne 10d7ad <_POSIX_Threads_Create_extension+0xe0><== NEVER TAKEN _Objects_Get_class( created->Object.id ) == 1 ) { executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; api->signals_blocked = executing_api->signals_blocked; 10d794: a1 58 d8 11 00 mov 0x11d858,%eax 10d799: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax 10d79f: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax 10d7a5: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx) 10d7ab: eb 0a jmp 10d7b7 <_POSIX_Threads_Create_extension+0xea> } else { api->signals_blocked = 0xffffffff; 10d7ad: c7 83 c4 00 00 00 ff movl $0xffffffff,0xc4(%ebx) 10d7b4: ff ff ff } _Thread_queue_Initialize( 10d7b7: 6a 00 push $0x0 10d7b9: 68 00 10 00 00 push $0x1000 10d7be: 6a 00 push $0x0 10d7c0: 8d 43 3c lea 0x3c(%ebx),%eax 10d7c3: 50 push %eax 10d7c4: e8 47 dd ff ff call 10b510 <_Thread_queue_Initialize> THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_JOIN_AT_EXIT, 0 ); _Watchdog_Initialize( 10d7c9: 8b 55 0c mov 0xc(%ebp),%edx 10d7cc: 8b 42 08 mov 0x8(%edx),%eax * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10d7cf: c7 83 a4 00 00 00 00 movl $0x0,0xa4(%ebx) 10d7d6: 00 00 00 * @param[in] the_heap is the heap to operate upon 10d7d9: c7 83 b8 00 00 00 3a movl $0x10d83a,0xb8(%ebx) 10d7e0: d8 10 00 * @param[in] starting_address is the starting address of the memory for 10d7e3: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) * the heap 10d7e9: 89 93 c0 00 00 00 mov %edx,0xc0(%ebx) 10d7ef: b0 01 mov $0x1,%al 10d7f1: 83 c4 10 add $0x10,%esp created->Object.id, created ); return true; } 10d7f4: 8d 65 f4 lea -0xc(%ebp),%esp 10d7f7: 5b pop %ebx 10d7f8: 5e pop %esi 10d7f9: 5f pop %edi 10d7fa: c9 leave 10d7fb: c3 ret =============================================================================== 00109d4c <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body( void ) { 109d4c: 55 push %ebp 109d4d: 89 e5 mov %esp,%ebp 109d4f: 57 push %edi 109d50: 56 push %esi 109d51: 53 push %ebx 109d52: 83 ec 4c sub $0x4c,%esp uint32_t maximum; posix_initialization_threads_table *user_threads; pthread_t thread_id; pthread_attr_t attr; user_threads = _POSIX_Threads_User_initialization_threads; 109d55: 8b 35 20 15 12 00 mov 0x121520,%esi maximum = _POSIX_Threads_Number_of_initialization_threads; 109d5b: a1 d8 15 12 00 mov 0x1215d8,%eax 109d60: 89 45 b0 mov %eax,-0x50(%ebp) if ( !user_threads || maximum == 0 ) 109d63: 85 f6 test %esi,%esi 109d65: 74 51 je 109db8 <_POSIX_Threads_Initialize_user_threads_body+0x6c><== NEVER TAKEN 109d67: 85 c0 test %eax,%eax 109d69: 74 4d je 109db8 <_POSIX_Threads_Initialize_user_threads_body+0x6c><== NEVER TAKEN return; 109d6b: 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 ); 109d6d: 8d 7d b8 lea -0x48(%ebp),%edi 109d70: eb 41 jmp 109db3 <_POSIX_Threads_Initialize_user_threads_body+0x67> 109d72: 83 ec 0c sub $0xc,%esp 109d75: 57 push %edi 109d76: e8 cd 54 00 00 call 10f248 (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 109d7b: 58 pop %eax 109d7c: 5a pop %edx 109d7d: 6a 02 push $0x2 109d7f: 57 push %edi 109d80: e8 eb 54 00 00 call 10f270 (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size); 109d85: 59 pop %ecx 109d86: 58 pop %eax 109d87: ff 74 de 04 pushl 0x4(%esi,%ebx,8) 109d8b: 57 push %edi 109d8c: e8 13 55 00 00 call 10f2a4 status = pthread_create( 109d91: 6a 00 push $0x0 109d93: ff 34 de pushl (%esi,%ebx,8) 109d96: 57 push %edi 109d97: 8d 45 f0 lea -0x10(%ebp),%eax 109d9a: 50 push %eax 109d9b: e8 84 fc ff ff call 109a24 &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) 109da0: 83 c4 20 add $0x20,%esp 109da3: 85 c0 test %eax,%eax 109da5: 74 0b je 109db2 <_POSIX_Threads_Initialize_user_threads_body+0x66> _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, status ); 109da7: 52 push %edx 109da8: 50 push %eax 109da9: 6a 01 push $0x1 109dab: 6a 02 push $0x2 109dad: e8 36 1e 00 00 call 10bbe8 <_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++ ) { 109db2: 43 inc %ebx 109db3: 3b 5d b0 cmp -0x50(%ebp),%ebx 109db6: 72 ba jb 109d72 <_POSIX_Threads_Initialize_user_threads_body+0x26> NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, status ); } } 109db8: 8d 65 f4 lea -0xc(%ebp),%esp 109dbb: 5b pop %ebx 109dbc: 5e pop %esi 109dbd: 5f pop %edi 109dbe: c9 leave 109dbf: c3 ret =============================================================================== 0010d83a <_POSIX_Threads_Sporadic_budget_TSR>: void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id, void *argument ) { 10d83a: 55 push %ebp 10d83b: 89 e5 mov %esp,%ebp 10d83d: 56 push %esi 10d83e: 53 push %ebx 10d83f: 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 ]; 10d842: 8b b3 f8 00 00 00 mov 0xf8(%ebx),%esi ticks = _Timespec_To_ticks( &api->schedparam.ss_initial_budget ); 10d848: 83 ec 0c sub $0xc,%esp 10d84b: 8d 86 90 00 00 00 lea 0x90(%esi),%eax 10d851: 50 push %eax 10d852: e8 99 0c 00 00 call 10e4f0 <_Timespec_To_ticks> if ( !ticks ) 10d857: 83 c4 10 add $0x10,%esp 10d85a: 85 c0 test %eax,%eax 10d85c: 75 02 jne 10d860 <_POSIX_Threads_Sporadic_budget_TSR+0x26><== ALWAYS TAKEN 10d85e: b0 01 mov $0x1,%al <== NOT EXECUTED ticks = 1; the_thread->cpu_time_budget = ticks; 10d860: 89 43 78 mov %eax,0x78(%ebx) 10d863: b8 ff 00 00 00 mov $0xff,%eax 10d868: 2b 86 98 00 00 00 sub 0x98(%esi),%eax new_priority = _POSIX_Priority_To_core( api->ss_high_priority ); the_thread->real_priority = new_priority; 10d86e: 89 43 18 mov %eax,0x18(%ebx) if ( the_thread->resource_count == 0 || 10d871: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx) 10d875: 74 05 je 10d87c <_POSIX_Threads_Sporadic_budget_TSR+0x42> 10d877: 39 43 14 cmp %eax,0x14(%ebx) 10d87a: 76 0d jbe 10d889 <_POSIX_Threads_Sporadic_budget_TSR+0x4f><== NEVER TAKEN the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 10d87c: 52 push %edx 10d87d: 6a 01 push $0x1 10d87f: 50 push %eax 10d880: 53 push %ebx 10d881: e8 66 d1 ff ff call 10a9ec <_Thread_Change_priority> 10d886: 83 c4 10 add $0x10,%esp ticks = _Timespec_To_ticks( &api->schedparam.ss_replenish_period ); 10d889: 83 ec 0c sub $0xc,%esp 10d88c: 8d 86 88 00 00 00 lea 0x88(%esi),%eax 10d892: 50 push %eax 10d893: e8 58 0c 00 00 call 10e4f0 <_Timespec_To_ticks> if ( !ticks ) 10d898: 83 c4 10 add $0x10,%esp 10d89b: 85 c0 test %eax,%eax 10d89d: 75 02 jne 10d8a1 <_POSIX_Threads_Sporadic_budget_TSR+0x67><== ALWAYS TAKEN 10d89f: b0 01 mov $0x1,%al <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10d8a1: 89 86 a8 00 00 00 mov %eax,0xa8(%esi) void *starting_address, size_t *size 10d8a7: 8d 86 9c 00 00 00 lea 0x9c(%esi),%eax 10d8ad: 89 45 0c mov %eax,0xc(%ebp) 10d8b0: c7 45 08 78 d8 11 00 movl $0x11d878,0x8(%ebp) ticks = 1; _Watchdog_Insert_ticks( &api->Sporadic_timer, ticks ); } 10d8b7: 8d 65 f8 lea -0x8(%ebp),%esp 10d8ba: 5b pop %ebx 10d8bb: 5e pop %esi 10d8bc: c9 leave 10d8bd: e9 66 e3 ff ff jmp 10bc28 <_Watchdog_Insert> =============================================================================== 0010d7fc <_POSIX_Threads_Sporadic_budget_callout>: */ void _POSIX_Threads_Sporadic_budget_callout( Thread_Control *the_thread ) { 10d7fc: 55 push %ebp 10d7fd: 89 e5 mov %esp,%ebp 10d7ff: 83 ec 08 sub $0x8,%esp 10d802: 8b 4d 08 mov 0x8(%ebp),%ecx POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10d805: 8b 81 f8 00 00 00 mov 0xf8(%ecx),%eax * 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 */ 10d80b: c7 41 78 ff ff ff ff movl $0xffffffff,0x78(%ecx) /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of 10d812: ba ff 00 00 00 mov $0xff,%edx 10d817: 2b 90 84 00 00 00 sub 0x84(%eax),%edx new_priority = _POSIX_Priority_To_core( api->schedparam.ss_low_priority ); the_thread->real_priority = new_priority; 10d81d: 89 51 18 mov %edx,0x18(%ecx) if ( the_thread->resource_count == 0 || 10d820: 83 79 1c 00 cmpl $0x0,0x1c(%ecx) 10d824: 74 05 je 10d82b <_POSIX_Threads_Sporadic_budget_callout+0x2f><== ALWAYS TAKEN 10d826: 39 51 14 cmp %edx,0x14(%ecx) <== NOT EXECUTED 10d829: 76 0d jbe 10d838 <_POSIX_Threads_Sporadic_budget_callout+0x3c><== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 10d82b: 50 push %eax 10d82c: 6a 01 push $0x1 10d82e: 52 push %edx 10d82f: 51 push %ecx 10d830: e8 b7 d1 ff ff call 10a9ec <_Thread_Change_priority> 10d835: 83 c4 10 add $0x10,%esp } 10d838: c9 leave 10d839: c3 ret =============================================================================== 0010e9dc <_POSIX_Threads_cancel_run>: #include void _POSIX_Threads_cancel_run( Thread_Control *the_thread ) { 10e9dc: 55 push %ebp 10e9dd: 89 e5 mov %esp,%ebp 10e9df: 57 push %edi 10e9e0: 56 push %esi 10e9e1: 53 push %ebx 10e9e2: 83 ec 0c sub $0xc,%esp POSIX_Cancel_Handler_control *handler; Chain_Control *handler_stack; POSIX_API_Control *thread_support; ISR_Level level; thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10e9e5: 8b 45 08 mov 0x8(%ebp),%eax 10e9e8: 8b b0 f8 00 00 00 mov 0xf8(%eax),%esi handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; 10e9ee: c7 86 cc 00 00 00 01 movl $0x1,0xcc(%esi) 10e9f5: 00 00 00 * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10e9f8: 8d be dc 00 00 00 lea 0xdc(%esi),%edi 10e9fe: eb 26 jmp 10ea26 <_POSIX_Threads_cancel_run+0x4a> while ( !_Chain_Is_empty( handler_stack ) ) { _ISR_Disable( level ); 10ea00: 9c pushf <== NOT EXECUTED 10ea01: fa cli <== NOT EXECUTED 10ea02: 59 pop %ecx <== NOT EXECUTED handler = (POSIX_Cancel_Handler_control *) 10ea03: 8b 5f 04 mov 0x4(%edi),%ebx <== NOT EXECUTED 10ea06: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10ea08: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10ea0b: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10ea0e: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 10ea10: 51 push %ecx <== NOT EXECUTED 10ea11: 9d popf <== NOT EXECUTED (*handler->routine)( handler->arg ); 10ea12: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ea15: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10ea18: ff 53 08 call *0x8(%ebx) <== NOT EXECUTED _Workspace_Free( handler ); 10ea1b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10ea1e: e8 f1 d3 ff ff call 10be14 <_Workspace_Free> <== NOT EXECUTED 10ea23: 83 c4 10 add $0x10,%esp <== NOT EXECUTED handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; while ( !_Chain_Is_empty( handler_stack ) ) { 10ea26: 39 be d8 00 00 00 cmp %edi,0xd8(%esi) 10ea2c: 75 d2 jne 10ea00 <_POSIX_Threads_cancel_run+0x24><== NEVER TAKEN (*handler->routine)( handler->arg ); _Workspace_Free( handler ); } } 10ea2e: 8d 65 f4 lea -0xc(%ebp),%esp 10ea31: 5b pop %ebx 10ea32: 5e pop %esi 10ea33: 5f pop %edi 10ea34: c9 leave 10ea35: c3 ret =============================================================================== 0010f508 <_POSIX_Timer_Insert_helper>: Watchdog_Interval ticks, Objects_Id id, Watchdog_Service_routine_entry TSR, void *arg ) { 10f508: 55 push %ebp 10f509: 89 e5 mov %esp,%ebp 10f50b: 56 push %esi 10f50c: 53 push %ebx 10f50d: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; (void) _Watchdog_Remove( timer ); 10f510: 83 ec 0c sub $0xc,%esp 10f513: 53 push %ebx 10f514: e8 4b e2 ff ff call 10d764 <_Watchdog_Remove> _ISR_Disable( level ); 10f519: 9c pushf 10f51a: fa cli 10f51b: 5e pop %esi /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( timer->state != WATCHDOG_INACTIVE ) { 10f51c: 83 c4 10 add $0x10,%esp 10f51f: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10f523: 74 06 je 10f52b <_POSIX_Timer_Insert_helper+0x23><== ALWAYS TAKEN _ISR_Enable( level ); 10f525: 56 push %esi <== NOT EXECUTED 10f526: 9d popf <== NOT EXECUTED 10f527: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f529: eb 33 jmp 10f55e <_POSIX_Timer_Insert_helper+0x56><== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10f52b: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) * @param[in] the_heap is the heap to operate upon 10f532: 8b 45 14 mov 0x14(%ebp),%eax 10f535: 89 43 1c mov %eax,0x1c(%ebx) * @param[in] starting_address is the starting address of the memory for 10f538: 8b 45 10 mov 0x10(%ebp),%eax 10f53b: 89 43 20 mov %eax,0x20(%ebx) * the heap 10f53e: 8b 45 18 mov 0x18(%ebp),%eax 10f541: 89 43 24 mov %eax,0x24(%ebx) * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10f544: 8b 45 0c mov 0xc(%ebp),%eax 10f547: 89 43 0c mov %eax,0xc(%ebx) void *starting_address, size_t *size 10f54a: 50 push %eax 10f54b: 50 push %eax 10f54c: 53 push %ebx 10f54d: 68 30 1b 12 00 push $0x121b30 10f552: e8 f5 e0 ff ff call 10d64c <_Watchdog_Insert> * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ _Watchdog_Initialize( timer, TSR, id, arg ); _Watchdog_Insert_ticks( timer, ticks ); _ISR_Enable( level ); 10f557: 56 push %esi 10f558: 9d popf 10f559: b0 01 mov $0x1,%al 10f55b: 83 c4 10 add $0x10,%esp return true; } 10f55e: 8d 65 f8 lea -0x8(%ebp),%esp 10f561: 5b pop %ebx 10f562: 5e pop %esi 10f563: c9 leave 10f564: c3 ret =============================================================================== 0010a310 <_POSIX_Timer_TSR>: /* * This is the operation that is run when a timer expires */ void _POSIX_Timer_TSR(Objects_Id timer, void *data) { 10a310: 55 push %ebp 10a311: 89 e5 mov %esp,%ebp 10a313: 53 push %ebx 10a314: 83 ec 04 sub $0x4,%esp 10a317: 8b 5d 0c mov 0xc(%ebp),%ebx bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 10a31a: ff 43 68 incl 0x68(%ebx) /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10a31d: 83 7b 54 00 cmpl $0x0,0x54(%ebx) 10a321: 75 06 jne 10a329 <_POSIX_Timer_TSR+0x19> <== ALWAYS TAKEN 10a323: 83 7b 58 00 cmpl $0x0,0x58(%ebx) <== NOT EXECUTED 10a327: 74 34 je 10a35d <_POSIX_Timer_TSR+0x4d> <== NOT EXECUTED ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { activated = _POSIX_Timer_Insert_helper( 10a329: 83 ec 0c sub $0xc,%esp 10a32c: 53 push %ebx 10a32d: 68 10 a3 10 00 push $0x10a310 10a332: ff 73 08 pushl 0x8(%ebx) 10a335: ff 73 64 pushl 0x64(%ebx) 10a338: 8d 43 10 lea 0x10(%ebx),%eax 10a33b: 50 push %eax 10a33c: e8 c7 51 00 00 call 10f508 <_POSIX_Timer_Insert_helper> ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 10a341: 83 c4 20 add $0x20,%esp 10a344: 84 c0 test %al,%al 10a346: 74 30 je 10a378 <_POSIX_Timer_TSR+0x68> <== NEVER TAKEN return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 10a348: 83 ec 0c sub $0xc,%esp 10a34b: 8d 43 6c lea 0x6c(%ebx),%eax 10a34e: 50 push %eax 10a34f: e8 28 15 00 00 call 10b87c <_TOD_Get> /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a354: c6 43 3c 03 movb $0x3,0x3c(%ebx) 10a358: 83 c4 10 add $0x10,%esp 10a35b: eb 04 jmp 10a361 <_POSIX_Timer_TSR+0x51> } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a35d: 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 ) ) { 10a361: 50 push %eax 10a362: 50 push %eax 10a363: ff 73 44 pushl 0x44(%ebx) 10a366: ff 73 38 pushl 0x38(%ebx) 10a369: e8 0a 4f 00 00 call 10f278 } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 10a36e: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) 10a375: 83 c4 10 add $0x10,%esp } 10a378: 8b 5d fc mov -0x4(%ebp),%ebx 10a37b: c9 leave 10a37c: c3 ret =============================================================================== 0010eae0 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) { 10eae0: 55 push %ebp 10eae1: 89 e5 mov %esp,%ebp 10eae3: 57 push %edi 10eae4: 56 push %esi 10eae5: 53 push %ebx 10eae6: 83 ec 28 sub $0x28,%esp 10eae9: 8b 7d 08 mov 0x8(%ebp),%edi 10eaec: 8b 75 0c mov 0xc(%ebp),%esi siginfo_t siginfo_struct; sigset_t saved_signals_blocked; if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct, 10eaef: 6a 01 push $0x1 10eaf1: 0f b6 45 10 movzbl 0x10(%ebp),%eax 10eaf5: 50 push %eax 10eaf6: 8d 45 e8 lea -0x18(%ebp),%eax 10eaf9: 50 push %eax 10eafa: 56 push %esi 10eafb: 57 push %edi 10eafc: e8 5f 00 00 00 call 10eb60 <_POSIX_signals_Clear_signals> 10eb01: 83 c4 20 add $0x20,%esp 10eb04: 84 c0 test %al,%al 10eb06: 74 4e je 10eb56 <_POSIX_signals_Check_signal+0x76> #endif /* * Just to prevent sending a signal which is currently being ignored. */ if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN ) 10eb08: 6b d6 0c imul $0xc,%esi,%edx 10eb0b: 8b 8a 44 dd 11 00 mov 0x11dd44(%edx),%ecx 10eb11: 83 f9 01 cmp $0x1,%ecx 10eb14: 74 40 je 10eb56 <_POSIX_signals_Check_signal+0x76><== NEVER TAKEN return false; /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 10eb16: 8b 9f c4 00 00 00 mov 0xc4(%edi),%ebx api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 10eb1c: 89 d8 mov %ebx,%eax 10eb1e: 0b 82 40 dd 11 00 or 0x11dd40(%edx),%eax 10eb24: 89 87 c4 00 00 00 mov %eax,0xc4(%edi) /* * Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 10eb2a: 83 ba 3c dd 11 00 02 cmpl $0x2,0x11dd3c(%edx) 10eb31: 75 10 jne 10eb43 <_POSIX_signals_Check_signal+0x63> case SA_SIGINFO: (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 10eb33: 50 push %eax 10eb34: 6a 00 push $0x0 10eb36: 8d 45 e8 lea -0x18(%ebp),%eax 10eb39: 50 push %eax 10eb3a: 56 push %esi 10eb3b: ff 92 44 dd 11 00 call *0x11dd44(%edx) 10eb41: eb 06 jmp 10eb49 <_POSIX_signals_Check_signal+0x69> &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; default: (*_POSIX_signals_Vectors[ signo ].sa_handler)( signo ); 10eb43: 83 ec 0c sub $0xc,%esp 10eb46: 56 push %esi 10eb47: ff d1 call *%ecx 10eb49: 83 c4 10 add $0x10,%esp } /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 10eb4c: 89 9f c4 00 00 00 mov %ebx,0xc4(%edi) 10eb52: b0 01 mov $0x1,%al 10eb54: eb 02 jmp 10eb58 <_POSIX_signals_Check_signal+0x78> return true; 10eb56: 31 c0 xor %eax,%eax } 10eb58: 8d 65 f4 lea -0xc(%ebp),%esp 10eb5b: 5b pop %ebx 10eb5c: 5e pop %esi 10eb5d: 5f pop %edi 10eb5e: c9 leave 10eb5f: c3 ret =============================================================================== 0010f0ec <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( sigset_t mask ) { 10f0ec: 55 push %ebp 10f0ed: 89 e5 mov %esp,%ebp 10f0ef: 8b 45 08 mov 0x8(%ebp),%eax ISR_Level level; _ISR_Disable( level ); 10f0f2: 9c pushf 10f0f3: fa cli 10f0f4: 5a pop %edx _POSIX_signals_Pending &= ~mask; 10f0f5: f7 d0 not %eax 10f0f7: 23 05 08 df 11 00 and 0x11df08,%eax 10f0fd: a3 08 df 11 00 mov %eax,0x11df08 if ( !_POSIX_signals_Pending ) 10f102: 85 c0 test %eax,%eax 10f104: 75 06 jne 10f10c <_POSIX_signals_Clear_process_signals+0x20><== NEVER TAKEN _Thread_Do_post_task_switch_extension--; 10f106: ff 0d 3c d8 11 00 decl 0x11d83c _ISR_Enable( level ); 10f10c: 52 push %edx 10f10d: 9d popf } 10f10e: c9 leave 10f10f: c3 ret =============================================================================== 0010eb60 <_POSIX_signals_Clear_signals>: int signo, siginfo_t *info, bool is_global, bool check_blocked ) { 10eb60: 55 push %ebp 10eb61: 89 e5 mov %esp,%ebp 10eb63: 57 push %edi 10eb64: 56 push %esi 10eb65: 53 push %ebx 10eb66: 83 ec 0c sub $0xc,%esp 10eb69: 8b 5d 08 mov 0x8(%ebp),%ebx 10eb6c: 8b 7d 0c mov 0xc(%ebp),%edi 10eb6f: 8a 45 14 mov 0x14(%ebp),%al sigset_t signals_blocked; ISR_Level level; bool do_callout; POSIX_signals_Siginfo_node *psiginfo; mask = signo_to_mask( signo ); 10eb72: 8d 4f ff lea -0x1(%edi),%ecx 10eb75: be 01 00 00 00 mov $0x1,%esi 10eb7a: d3 e6 shl %cl,%esi /* set blocked signals based on if checking for them, SIGNAL_ALL_MASK * insures that no signals are blocked and all are checked. */ if ( check_blocked ) 10eb7c: 83 ca ff or $0xffffffff,%edx 10eb7f: 80 7d 18 00 cmpb $0x0,0x18(%ebp) 10eb83: 74 08 je 10eb8d <_POSIX_signals_Clear_signals+0x2d> signals_blocked = ~api->signals_blocked; 10eb85: 8b 93 c4 00 00 00 mov 0xc4(%ebx),%edx 10eb8b: f7 d2 not %edx signals_blocked = SIGNAL_ALL_MASK; /* XXX this is not right for siginfo type signals yet */ /* XXX since they can't be cleared the same way */ _ISR_Disable( level ); 10eb8d: 9c pushf 10eb8e: fa cli 10eb8f: 8f 45 f0 popl -0x10(%ebp) if ( is_global ) { 10eb92: 84 c0 test %al,%al 10eb94: 0f 84 8d 00 00 00 je 10ec27 <_POSIX_signals_Clear_signals+0xc7> if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { 10eb9a: 89 f0 mov %esi,%eax 10eb9c: 23 05 08 df 11 00 and 0x11df08,%eax 10eba2: 85 d0 test %edx,%eax 10eba4: 0f 84 9b 00 00 00 je 10ec45 <_POSIX_signals_Clear_signals+0xe5> if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 10ebaa: 6b d7 0c imul $0xc,%edi,%edx 10ebad: 83 ba 3c dd 11 00 02 cmpl $0x2,0x11dd3c(%edx) 10ebb4: 75 61 jne 10ec17 <_POSIX_signals_Clear_signals+0xb7> psiginfo = (POSIX_signals_Siginfo_node *) 10ebb6: 8d 8a 0c df 11 00 lea 0x11df0c(%edx),%ecx * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10ebbc: 8b 9a 0c df 11 00 mov 0x11df0c(%edx),%ebx * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10ebc2: 8d 79 04 lea 0x4(%ecx),%edi 10ebc5: 39 fb cmp %edi,%ebx 10ebc7: 75 04 jne 10ebcd <_POSIX_signals_Clear_signals+0x6d><== ALWAYS TAKEN 10ebc9: 31 db xor %ebx,%ebx 10ebcb: eb 0b jmp 10ebd8 <_POSIX_signals_Clear_signals+0x78><== NOT EXECUTED 10ebcd: 8b 03 mov (%ebx),%eax 10ebcf: 89 82 0c df 11 00 mov %eax,0x11df0c(%edx) 10ebd5: 89 48 04 mov %ecx,0x4(%eax) _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); if ( _Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 10ebd8: 39 ba 0c df 11 00 cmp %edi,0x11df0c(%edx) 10ebde: 75 0c jne 10ebec <_POSIX_signals_Clear_signals+0x8c><== NEVER TAKEN _POSIX_signals_Clear_process_signals( mask ); 10ebe0: 83 ec 0c sub $0xc,%esp 10ebe3: 56 push %esi 10ebe4: e8 03 05 00 00 call 10f0ec <_POSIX_signals_Clear_process_signals> 10ebe9: 83 c4 10 add $0x10,%esp if ( psiginfo ) { 10ebec: b0 01 mov $0x1,%al 10ebee: 85 db test %ebx,%ebx 10ebf0: 74 55 je 10ec47 <_POSIX_signals_Clear_signals+0xe7><== NEVER TAKEN *info = psiginfo->Info; 10ebf2: 8d 73 08 lea 0x8(%ebx),%esi 10ebf5: b9 03 00 00 00 mov $0x3,%ecx 10ebfa: 8b 7d 10 mov 0x10(%ebp),%edi 10ebfd: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10ebff: c7 03 c0 de 11 00 movl $0x11dec0,(%ebx) 10ec05: a1 c4 de 11 00 mov 0x11dec4,%eax 10ec0a: 89 1d c4 de 11 00 mov %ebx,0x11dec4 10ec10: 89 18 mov %ebx,(%eax) 10ec12: 89 43 04 mov %eax,0x4(%ebx) 10ec15: eb 2a jmp 10ec41 <_POSIX_signals_Clear_signals+0xe1> &psiginfo->Node ); } else do_callout = false; } else _POSIX_signals_Clear_process_signals( mask ); 10ec17: 83 ec 0c sub $0xc,%esp 10ec1a: 56 push %esi 10ec1b: e8 cc 04 00 00 call 10f0ec <_POSIX_signals_Clear_process_signals> 10ec20: b0 01 mov $0x1,%al 10ec22: 83 c4 10 add $0x10,%esp 10ec25: eb 20 jmp 10ec47 <_POSIX_signals_Clear_signals+0xe7> do_callout = true; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { 10ec27: 8b 8b c8 00 00 00 mov 0xc8(%ebx),%ecx 10ec2d: 89 f0 mov %esi,%eax 10ec2f: 21 c8 and %ecx,%eax 10ec31: 85 d0 test %edx,%eax 10ec33: 74 10 je 10ec45 <_POSIX_signals_Clear_signals+0xe5> api->signals_pending &= ~mask; 10ec35: 89 f0 mov %esi,%eax 10ec37: f7 d0 not %eax 10ec39: 21 c8 and %ecx,%eax 10ec3b: 89 83 c8 00 00 00 mov %eax,0xc8(%ebx) 10ec41: b0 01 mov $0x1,%al 10ec43: eb 02 jmp 10ec47 <_POSIX_signals_Clear_signals+0xe7> 10ec45: 31 c0 xor %eax,%eax do_callout = true; } } _ISR_Enable( level ); 10ec47: ff 75 f0 pushl -0x10(%ebp) 10ec4a: 9d popf return do_callout; } 10ec4b: 8d 65 f4 lea -0xc(%ebp),%esp 10ec4e: 5b pop %ebx 10ec4f: 5e pop %esi 10ec50: 5f pop %edi 10ec51: c9 leave 10ec52: c3 ret =============================================================================== 001099f8 <_POSIX_signals_Get_highest>: #include int _POSIX_signals_Get_highest( sigset_t set ) { 1099f8: 55 push %ebp 1099f9: 89 e5 mov %esp,%ebp 1099fb: 56 push %esi 1099fc: 53 push %ebx 1099fd: 8b 5d 08 mov 0x8(%ebp),%ebx 109a00: b8 1b 00 00 00 mov $0x1b,%eax int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) 109a05: ba 01 00 00 00 mov $0x1,%edx 109a0a: 8d 48 ff lea -0x1(%eax),%ecx 109a0d: 89 d6 mov %edx,%esi 109a0f: d3 e6 shl %cl,%esi 109a11: 85 de test %ebx,%esi 109a13: 75 20 jne 109a35 <_POSIX_signals_Get_highest+0x3d><== NEVER TAKEN sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 109a15: 40 inc %eax 109a16: 83 f8 20 cmp $0x20,%eax 109a19: 75 ef jne 109a0a <_POSIX_signals_Get_highest+0x12> 109a1b: b0 01 mov $0x1,%al } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( set & signo_to_mask( signo ) ) 109a1d: ba 01 00 00 00 mov $0x1,%edx 109a22: 8d 48 ff lea -0x1(%eax),%ecx 109a25: 89 d6 mov %edx,%esi 109a27: d3 e6 shl %cl,%esi 109a29: 85 de test %ebx,%esi 109a2b: 75 08 jne 109a35 <_POSIX_signals_Get_highest+0x3d> return signo; } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 109a2d: 40 inc %eax 109a2e: 83 f8 1b cmp $0x1b,%eax 109a31: 75 ef jne 109a22 <_POSIX_signals_Get_highest+0x2a><== ALWAYS TAKEN 109a33: 30 c0 xor %al,%al <== NOT EXECUTED if ( set & signo_to_mask( signo ) ) return signo; } return 0; } 109a35: 5b pop %ebx 109a36: 5e pop %esi 109a37: c9 leave 109a38: c3 ret =============================================================================== 0010d509 <_POSIX_signals_Post_switch_extension>: */ void _POSIX_signals_Post_switch_extension( Thread_Control *the_thread ) { 10d509: 55 push %ebp 10d50a: 89 e5 mov %esp,%ebp 10d50c: 56 push %esi 10d50d: 53 push %ebx POSIX_API_Control *api; int signo; ISR_Level level; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10d50e: 8b 45 08 mov 0x8(%ebp),%eax 10d511: 8b b0 f8 00 00 00 mov 0xf8(%eax),%esi if ( !api ) 10d517: 85 f6 test %esi,%esi 10d519: 74 7a je 10d595 <_POSIX_signals_Post_switch_extension+0x8c><== NEVER TAKEN * The first thing done is to check there are any signals to be * processed at all. No point in doing this loop otherwise. */ while (1) { restart: _ISR_Disable( level ); 10d51b: 9c pushf 10d51c: fa cli 10d51d: 59 pop %ecx if ( !(~api->signals_blocked & 10d51e: 8b 15 08 df 11 00 mov 0x11df08,%edx 10d524: 0b 96 c8 00 00 00 or 0xc8(%esi),%edx 10d52a: 8b 86 c4 00 00 00 mov 0xc4(%esi),%eax 10d530: f7 d0 not %eax 10d532: 85 c2 test %eax,%edx 10d534: 75 04 jne 10d53a <_POSIX_signals_Post_switch_extension+0x31> (api->signals_pending | _POSIX_signals_Pending)) ) { _ISR_Enable( level ); 10d536: 51 push %ecx 10d537: 9d popf 10d538: eb 5b jmp 10d595 <_POSIX_signals_Post_switch_extension+0x8c> break; } _ISR_Enable( level ); 10d53a: 51 push %ecx 10d53b: 9d popf 10d53c: bb 1b 00 00 00 mov $0x1b,%ebx for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( _POSIX_signals_Check_signal( api, signo, false ) ) 10d541: 50 push %eax 10d542: 6a 00 push $0x0 10d544: 53 push %ebx 10d545: 56 push %esi 10d546: e8 95 15 00 00 call 10eae0 <_POSIX_signals_Check_signal> 10d54b: 83 c4 10 add $0x10,%esp 10d54e: 84 c0 test %al,%al 10d550: 75 c9 jne 10d51b <_POSIX_signals_Post_switch_extension+0x12><== NEVER TAKEN goto restart; if ( _POSIX_signals_Check_signal( api, signo, true ) ) 10d552: 51 push %ecx 10d553: 6a 01 push $0x1 10d555: 53 push %ebx 10d556: 56 push %esi 10d557: e8 84 15 00 00 call 10eae0 <_POSIX_signals_Check_signal> 10d55c: 83 c4 10 add $0x10,%esp 10d55f: 84 c0 test %al,%al 10d561: 75 b8 jne 10d51b <_POSIX_signals_Post_switch_extension+0x12><== NEVER TAKEN _ISR_Enable( level ); break; } _ISR_Enable( level ); for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10d563: 43 inc %ebx 10d564: 83 fb 20 cmp $0x20,%ebx 10d567: 75 d8 jne 10d541 <_POSIX_signals_Post_switch_extension+0x38> 10d569: b3 01 mov $0x1,%bl /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( _POSIX_signals_Check_signal( api, signo, false ) ) 10d56b: 52 push %edx 10d56c: 6a 00 push $0x0 10d56e: 53 push %ebx 10d56f: 56 push %esi 10d570: e8 6b 15 00 00 call 10eae0 <_POSIX_signals_Check_signal> 10d575: 83 c4 10 add $0x10,%esp 10d578: 84 c0 test %al,%al 10d57a: 75 9f jne 10d51b <_POSIX_signals_Post_switch_extension+0x12> goto restart; if ( _POSIX_signals_Check_signal( api, signo, true ) ) 10d57c: 50 push %eax 10d57d: 6a 01 push $0x1 10d57f: 53 push %ebx 10d580: 56 push %esi 10d581: e8 5a 15 00 00 call 10eae0 <_POSIX_signals_Check_signal> 10d586: 83 c4 10 add $0x10,%esp 10d589: 84 c0 test %al,%al 10d58b: 75 8e jne 10d51b <_POSIX_signals_Post_switch_extension+0x12> } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10d58d: 43 inc %ebx 10d58e: 83 fb 1b cmp $0x1b,%ebx 10d591: 75 d8 jne 10d56b <_POSIX_signals_Post_switch_extension+0x62><== ALWAYS TAKEN 10d593: eb 86 jmp 10d51b <_POSIX_signals_Post_switch_extension+0x12><== NOT EXECUTED goto restart; } } return; } 10d595: 8d 65 f8 lea -0x8(%ebp),%esp 10d598: 5b pop %ebx 10d599: 5e pop %esi 10d59a: c9 leave 10d59b: c3 ret =============================================================================== 0011868c <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 11868c: 55 push %ebp 11868d: 89 e5 mov %esp,%ebp 11868f: 57 push %edi 118690: 56 push %esi 118691: 53 push %ebx 118692: 83 ec 0c sub $0xc,%esp 118695: 8b 5d 08 mov 0x8(%ebp),%ebx 118698: 8b 75 10 mov 0x10(%ebp),%esi POSIX_API_Control *api; sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 11869b: 8b bb f8 00 00 00 mov 0xf8(%ebx),%edi mask = signo_to_mask( signo ); 1186a1: 8b 4d 0c mov 0xc(%ebp),%ecx 1186a4: 49 dec %ecx 1186a5: ba 01 00 00 00 mov $0x1,%edx 1186aa: d3 e2 shl %cl,%edx /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 1186ac: 8b 4b 10 mov 0x10(%ebx),%ecx 1186af: 89 c8 mov %ecx,%eax 1186b1: 25 00 80 00 10 and $0x10008000,%eax 1186b6: 3d 00 80 00 10 cmp $0x10008000,%eax 1186bb: 75 4c jne 118709 <_POSIX_signals_Unblock_thread+0x7d> if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) { 1186bd: 85 53 30 test %edx,0x30(%ebx) 1186c0: 75 10 jne 1186d2 <_POSIX_signals_Unblock_thread+0x46> 1186c2: 8b 87 c4 00 00 00 mov 0xc4(%edi),%eax 1186c8: f7 d0 not %eax 1186ca: 85 c2 test %eax,%edx 1186cc: 0f 84 a0 00 00 00 je 118772 <_POSIX_signals_Unblock_thread+0xe6><== ALWAYS TAKEN the_thread->Wait.return_code = EINTR; 1186d2: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) the_info = (siginfo_t *) the_thread->Wait.return_argument; 1186d9: 8b 7b 28 mov 0x28(%ebx),%edi if ( !info ) { 1186dc: 85 f6 test %esi,%esi 1186de: 75 15 jne 1186f5 <_POSIX_signals_Unblock_thread+0x69> the_info->si_signo = signo; 1186e0: 8b 45 0c mov 0xc(%ebp),%eax 1186e3: 89 07 mov %eax,(%edi) the_info->si_code = SI_USER; 1186e5: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) the_info->si_value.sival_int = 0; 1186ec: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) 1186f3: eb 07 jmp 1186fc <_POSIX_signals_Unblock_thread+0x70> } else { *the_info = *info; 1186f5: b9 03 00 00 00 mov $0x3,%ecx 1186fa: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } _Thread_queue_Extract_with_proxy( the_thread ); 1186fc: 83 ec 0c sub $0xc,%esp 1186ff: 53 push %ebx 118700: e8 67 41 ff ff call 10c86c <_Thread_queue_Extract_with_proxy> 118705: b0 01 mov $0x1,%al 118707: eb 48 jmp 118751 <_POSIX_signals_Unblock_thread+0xc5> } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 118709: 8b 87 c4 00 00 00 mov 0xc4(%edi),%eax 11870f: f7 d0 not %eax 118711: 85 c2 test %eax,%edx 118713: 74 5d je 118772 <_POSIX_signals_Unblock_thread+0xe6> * it is not blocked, THEN * we need to dispatch at the end of this ISR. * + Any other combination, do nothing. */ the_thread->do_post_task_switch_extension = true; 118715: c6 43 75 01 movb $0x1,0x75(%ebx) if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { 118719: f7 c1 00 00 00 10 test $0x10000000,%ecx 11871f: 74 35 je 118756 <_POSIX_signals_Unblock_thread+0xca> the_thread->Wait.return_code = EINTR; 118721: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) #if 0 if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) _Thread_queue_Extract_with_proxy( the_thread ); else #endif if ( _States_Is_delaying(the_thread->current_state) ){ 118728: 80 e1 08 and $0x8,%cl 11872b: 74 45 je 118772 <_POSIX_signals_Unblock_thread+0xe6><== NEVER TAKEN if ( _Watchdog_Is_active( &the_thread->Timer ) ) 11872d: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 118731: 75 0f jne 118742 <_POSIX_signals_Unblock_thread+0xb6><== NEVER TAKEN (void) _Watchdog_Remove( &the_thread->Timer ); 118733: 83 ec 0c sub $0xc,%esp 118736: 8d 43 48 lea 0x48(%ebx),%eax 118739: 50 push %eax 11873a: e8 a5 4c ff ff call 10d3e4 <_Watchdog_Remove> 11873f: 83 c4 10 add $0x10,%esp RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 118742: 50 push %eax 118743: 50 push %eax 118744: 68 f8 ff 03 10 push $0x1003fff8 118749: 53 push %ebx 11874a: e8 3d 37 ff ff call 10be8c <_Thread_Clear_state> 11874f: 31 c0 xor %eax,%eax 118751: 83 c4 10 add $0x10,%esp 118754: eb 1e jmp 118774 <_POSIX_signals_Unblock_thread+0xe8> _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { 118756: 85 c9 test %ecx,%ecx 118758: 75 18 jne 118772 <_POSIX_signals_Unblock_thread+0xe6><== NEVER TAKEN if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 11875a: a1 30 93 12 00 mov 0x129330,%eax 11875f: 85 c0 test %eax,%eax 118761: 74 0f je 118772 <_POSIX_signals_Unblock_thread+0xe6> 118763: 3b 1d 54 93 12 00 cmp 0x129354,%ebx 118769: 75 07 jne 118772 <_POSIX_signals_Unblock_thread+0xe6><== NEVER TAKEN _ISR_Signals_to_thread_executing = TRUE; 11876b: c6 05 e8 93 12 00 01 movb $0x1,0x1293e8 118772: 31 c0 xor %eax,%eax } } return false; } 118774: 8d 65 f4 lea -0xc(%ebp),%esp 118777: 5b pop %ebx 118778: 5e pop %esi 118779: 5f pop %edi 11877a: c9 leave 11877b: c3 ret =============================================================================== 0010c788 <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 10c788: 55 push %ebp 10c789: 89 e5 mov %esp,%ebp 10c78b: 56 push %esi 10c78c: 53 push %ebx 10c78d: 8b 75 08 mov 0x8(%ebp),%esi 10c790: 8b 5d 0c mov 0xc(%ebp),%ebx Heap_Get_information_status status; if ( !the_heap ) 10c793: 85 f6 test %esi,%esi 10c795: 74 33 je 10c7ca <_Protected_heap_Get_information+0x42><== NEVER TAKEN return false; if ( !the_info ) 10c797: 85 db test %ebx,%ebx 10c799: 74 2f je 10c7ca <_Protected_heap_Get_information+0x42><== NEVER TAKEN return false; _RTEMS_Lock_allocator(); 10c79b: 83 ec 0c sub $0xc,%esp 10c79e: ff 35 3c 2b 12 00 pushl 0x122b3c 10c7a4: e8 3f ea ff ff call 10b1e8 <_API_Mutex_Lock> status = _Heap_Get_information( the_heap, the_info ); 10c7a9: 5a pop %edx 10c7aa: 59 pop %ecx 10c7ab: 53 push %ebx 10c7ac: 56 push %esi 10c7ad: e8 6e 38 00 00 call 110020 <_Heap_Get_information> 10c7b2: 89 c3 mov %eax,%ebx _RTEMS_Unlock_allocator(); 10c7b4: 58 pop %eax 10c7b5: ff 35 3c 2b 12 00 pushl 0x122b3c 10c7bb: e8 70 ea ff ff call 10b230 <_API_Mutex_Unlock> if ( status == HEAP_GET_INFORMATION_SUCCESSFUL ) 10c7c0: 83 c4 10 add $0x10,%esp 10c7c3: 85 db test %ebx,%ebx 10c7c5: 0f 94 c0 sete %al 10c7c8: eb 02 jmp 10c7cc <_Protected_heap_Get_information+0x44> 10c7ca: 31 c0 xor %eax,%eax return true; return false; } 10c7cc: 8d 65 f8 lea -0x8(%ebp),%esp 10c7cf: 5b pop %ebx 10c7d0: 5e pop %esi 10c7d1: c9 leave 10c7d2: c3 ret =============================================================================== 0010dbf3 <_RTEMS_tasks_Create_extension>: bool _RTEMS_tasks_Create_extension( Thread_Control *executing, Thread_Control *created ) { 10dbf3: 55 push %ebp 10dbf4: 89 e5 mov %esp,%ebp 10dbf6: 53 push %ebx 10dbf7: 83 ec 10 sub $0x10,%esp 10dbfa: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Notepads must be the last entry in the structure and they * can be left off if disabled in the configuration. */ to_allocate = sizeof( RTEMS_API_Control ); if ( !rtems_configuration_get_notepads_enabled() ) 10dbfd: a1 30 d8 11 00 mov 0x11d830,%eax 10dc02: 8b 40 40 mov 0x40(%eax),%eax 10dc05: 80 78 04 01 cmpb $0x1,0x4(%eax) 10dc09: 19 c0 sbb %eax,%eax 10dc0b: 83 e0 c0 and $0xffffffc0,%eax 10dc0e: 83 c0 60 add $0x60,%eax to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); 10dc11: 50 push %eax 10dc12: e8 12 e2 ff ff call 10be29 <_Workspace_Allocate> 10dc17: 89 c2 mov %eax,%edx if ( !api ) 10dc19: 83 c4 10 add $0x10,%esp 10dc1c: 31 c0 xor %eax,%eax 10dc1e: 85 d2 test %edx,%edx 10dc20: 74 5d je 10dc7f <_RTEMS_tasks_Create_extension+0x8c><== NEVER TAKEN return false; created->API_Extensions[ THREAD_API_RTEMS ] = api; 10dc22: 89 93 f4 00 00 00 mov %edx,0xf4(%ebx) api->pending_events = EVENT_SETS_NONE_PENDING; 10dc28: c7 02 00 00 00 00 movl $0x0,(%edx) #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of 10dc2e: c6 42 08 01 movb $0x1,0x8(%edx) * @a page_size byte units. If @a page_size is 0 or is not multiple of 10dc32: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 10dc39: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) * 10dc40: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx) * @param[in] the_heap is the heap to operate upon 10dc47: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) * @param[in] starting_address is the starting address of the memory for 10dc4e: c7 42 1c 00 00 00 00 movl $0x0,0x1c(%edx) _ASR_Initialize( &api->Signal ); created->task_variables = NULL; 10dc55: c7 83 04 01 00 00 00 movl $0x0,0x104(%ebx) 10dc5c: 00 00 00 if ( rtems_configuration_get_notepads_enabled() ) { 10dc5f: a1 30 d8 11 00 mov 0x11d830,%eax 10dc64: 8b 40 40 mov 0x40(%eax),%eax 10dc67: 80 78 04 00 cmpb $0x0,0x4(%eax) 10dc6b: 74 10 je 10dc7d <_RTEMS_tasks_Create_extension+0x8a> 10dc6d: 31 c0 xor %eax,%eax for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; 10dc6f: c7 44 82 20 00 00 00 movl $0x0,0x20(%edx,%eax,4) 10dc76: 00 api->pending_events = EVENT_SETS_NONE_PENDING; _ASR_Initialize( &api->Signal ); created->task_variables = NULL; if ( rtems_configuration_get_notepads_enabled() ) { for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) 10dc77: 40 inc %eax 10dc78: 83 f8 10 cmp $0x10,%eax 10dc7b: 75 f2 jne 10dc6f <_RTEMS_tasks_Create_extension+0x7c> 10dc7d: b0 01 mov $0x1,%al api->Notepads[i] = 0; } return true; } 10dc7f: 8b 5d fc mov -0x4(%ebp),%ebx 10dc82: c9 leave 10dc83: c3 ret =============================================================================== 001094e4 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 1094e4: 55 push %ebp 1094e5: 89 e5 mov %esp,%ebp 1094e7: 57 push %edi 1094e8: 56 push %esi 1094e9: 53 push %ebx 1094ea: 83 ec 1c sub $0x1c,%esp rtems_status_code return_value; rtems_initialization_tasks_table *user_tasks; rtems_api_configuration_table *api_configuration; api_configuration = _Configuration_Table->RTEMS_api_configuration; 1094ed: a1 30 d8 11 00 mov 0x11d830,%eax 1094f2: 8b 40 40 mov 0x40(%eax),%eax /* * NOTE: This is slightly different from the Ada implementation. */ user_tasks = api_configuration->User_initialization_tasks_table; 1094f5: 8b 50 2c mov 0x2c(%eax),%edx maximum = api_configuration->number_of_initialization_tasks; 1094f8: 8b 78 28 mov 0x28(%eax),%edi if ( !user_tasks || maximum == 0 ) 1094fb: 85 d2 test %edx,%edx 1094fd: 74 53 je 109552 <_RTEMS_tasks_Initialize_user_tasks_body+0x6e><== NEVER TAKEN 1094ff: 85 ff test %edi,%edi 109501: 74 4f je 109552 <_RTEMS_tasks_Initialize_user_tasks_body+0x6e><== NEVER TAKEN return; 109503: 89 d3 mov %edx,%ebx 109505: 31 f6 xor %esi,%esi 109507: eb 45 jmp 10954e <_RTEMS_tasks_Initialize_user_tasks_body+0x6a> for ( index=0 ; index < maximum ; index++ ) { return_value = rtems_task_create( 109509: 50 push %eax 10950a: 50 push %eax 10950b: 8d 45 f0 lea -0x10(%ebp),%eax 10950e: 50 push %eax 10950f: ff 73 0c pushl 0xc(%ebx) 109512: ff 73 14 pushl 0x14(%ebx) 109515: ff 73 04 pushl 0x4(%ebx) 109518: ff 73 08 pushl 0x8(%ebx) 10951b: ff 33 pushl (%ebx) 10951d: e8 ca fd ff ff call 1092ec user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 109522: 83 c4 20 add $0x20,%esp 109525: 85 c0 test %eax,%eax 109527: 75 19 jne 109542 <_RTEMS_tasks_Initialize_user_tasks_body+0x5e> _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); return_value = rtems_task_start( 109529: 51 push %ecx 10952a: ff 73 18 pushl 0x18(%ebx) 10952d: ff 73 10 pushl 0x10(%ebx) 109530: ff 75 f0 pushl -0x10(%ebp) 109533: e8 24 00 00 00 call 10955c 109538: 83 c3 1c add $0x1c,%ebx id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 10953b: 83 c4 10 add $0x10,%esp 10953e: 85 c0 test %eax,%eax 109540: 74 0b je 10954d <_RTEMS_tasks_Initialize_user_tasks_body+0x69> _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 109542: 52 push %edx 109543: 50 push %eax 109544: 6a 01 push $0x1 109546: 6a 01 push $0x1 109548: e8 a7 0c 00 00 call 10a1f4 <_Internal_error_Occurred> maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) return; for ( index=0 ; index < maximum ; index++ ) { 10954d: 46 inc %esi 10954e: 39 fe cmp %edi,%esi 109550: 72 b7 jb 109509 <_RTEMS_tasks_Initialize_user_tasks_body+0x25> ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); } } 109552: 8d 65 f4 lea -0xc(%ebp),%esp 109555: 5b pop %ebx 109556: 5e pop %esi 109557: 5f pop %edi 109558: c9 leave 109559: c3 ret =============================================================================== 0010db40 <_RTEMS_tasks_Post_switch_extension>: */ void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) { 10db40: 55 push %ebp 10db41: 89 e5 mov %esp,%ebp 10db43: 57 push %edi 10db44: 56 push %esi 10db45: 53 push %ebx 10db46: 83 ec 1c sub $0x1c,%esp RTEMS_API_Control *api; ASR_Information *asr; rtems_signal_set signal_set; Modes_Control prev_mode; api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10db49: 8b 45 08 mov 0x8(%ebp),%eax 10db4c: 8b b0 f4 00 00 00 mov 0xf4(%eax),%esi if ( !api ) 10db52: 85 f6 test %esi,%esi 10db54: 74 45 je 10db9b <_RTEMS_tasks_Post_switch_extension+0x5b><== NEVER TAKEN * Signal Processing */ asr = &api->Signal; _ISR_Disable( level ); 10db56: 9c pushf 10db57: fa cli 10db58: 58 pop %eax signal_set = asr->signals_posted; 10db59: 8b 7e 14 mov 0x14(%esi),%edi asr->signals_posted = 0; 10db5c: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) _ISR_Enable( level ); 10db63: 50 push %eax 10db64: 9d popf if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 10db65: 85 ff test %edi,%edi 10db67: 74 32 je 10db9b <_RTEMS_tasks_Post_switch_extension+0x5b> return; asr->nest_level += 1; 10db69: ff 46 1c incl 0x1c(%esi) rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10db6c: 50 push %eax 10db6d: 8d 5d f0 lea -0x10(%ebp),%ebx 10db70: 53 push %ebx 10db71: 68 ff ff 00 00 push $0xffff 10db76: ff 76 10 pushl 0x10(%esi) 10db79: e8 56 11 00 00 call 10ecd4 (*asr->handler)( signal_set ); 10db7e: 89 3c 24 mov %edi,(%esp) 10db81: ff 56 0c call *0xc(%esi) asr->nest_level -= 1; 10db84: ff 4e 1c decl 0x1c(%esi) rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10db87: 83 c4 0c add $0xc,%esp 10db8a: 53 push %ebx 10db8b: 68 ff ff 00 00 push $0xffff 10db90: ff 75 f0 pushl -0x10(%ebp) 10db93: e8 3c 11 00 00 call 10ecd4 10db98: 83 c4 10 add $0x10,%esp } 10db9b: 8d 65 f4 lea -0xc(%ebp),%esp 10db9e: 5b pop %ebx 10db9f: 5e pop %esi 10dba0: 5f pop %edi 10dba1: c9 leave 10dba2: c3 ret =============================================================================== 0010a314 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 10a314: 55 push %ebp 10a315: 89 e5 mov %esp,%ebp 10a317: 53 push %ebx 10a318: 83 ec 18 sub $0x18,%esp 10a31b: 8d 45 f8 lea -0x8(%ebp),%eax 10a31e: 50 push %eax 10a31f: ff 75 08 pushl 0x8(%ebp) 10a322: 68 44 1b 12 00 push $0x121b44 10a327: e8 98 1a 00 00 call 10bdc4 <_Objects_Get> 10a32c: 89 c3 mov %eax,%ebx /* * 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 ); switch ( location ) { 10a32e: 83 c4 10 add $0x10,%esp 10a331: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) 10a335: 75 64 jne 10a39b <_Rate_monotonic_Timeout+0x87><== NEVER TAKEN case OBJECTS_LOCAL: the_thread = the_period->owner; 10a337: 8b 50 50 mov 0x50(%eax),%edx if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10a33a: f6 42 11 40 testb $0x40,0x11(%edx) 10a33e: 74 18 je 10a358 <_Rate_monotonic_Timeout+0x44> 10a340: 8b 42 20 mov 0x20(%edx),%eax 10a343: 3b 43 08 cmp 0x8(%ebx),%eax 10a346: 75 10 jne 10a358 <_Rate_monotonic_Timeout+0x44><== NEVER TAKEN void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10a348: 50 push %eax 10a349: 50 push %eax 10a34a: 68 f8 ff 03 10 push $0x1003fff8 10a34f: 52 push %edx 10a350: e8 af 1e 00 00 call 10c204 <_Thread_Clear_state> the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 10a355: 59 pop %ecx 10a356: eb 10 jmp 10a368 <_Rate_monotonic_Timeout+0x54> _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 10a358: 83 7b 38 01 cmpl $0x1,0x38(%ebx) 10a35c: 75 2b jne 10a389 <_Rate_monotonic_Timeout+0x75><== ALWAYS TAKEN the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING; 10a35e: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) <== NOT EXECUTED _Rate_monotonic_Initiate_statistics( the_period ); 10a365: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a368: 53 push %ebx 10a369: e8 6a fa ff ff call 109dd8 <_Rate_monotonic_Initiate_statistics> * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10a36e: 8b 43 4c mov 0x4c(%ebx),%eax 10a371: 89 43 1c mov %eax,0x1c(%ebx) void *starting_address, size_t *size 10a374: 58 pop %eax 10a375: 5a pop %edx 10a376: 8d 43 10 lea 0x10(%ebx),%eax 10a379: 50 push %eax 10a37a: 68 1c 1d 12 00 push $0x121d1c 10a37f: e8 5c 31 00 00 call 10d4e0 <_Watchdog_Insert> 10a384: 83 c4 10 add $0x10,%esp 10a387: eb 07 jmp 10a390 <_Rate_monotonic_Timeout+0x7c> _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else the_period->state = RATE_MONOTONIC_EXPIRED; 10a389: c7 43 38 04 00 00 00 movl $0x4,0x38(%ebx) 10a390: a1 3c 1c 12 00 mov 0x121c3c,%eax 10a395: 48 dec %eax 10a396: a3 3c 1c 12 00 mov %eax,0x121c3c case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10a39b: 8b 5d fc mov -0x4(%ebp),%ebx 10a39e: c9 leave 10a39f: c3 ret =============================================================================== 00109a64 <_TOD_Validate>: */ bool _TOD_Validate( rtems_time_of_day *the_tod ) { 109a64: 55 push %ebp 109a65: 89 e5 mov %esp,%ebp 109a67: 53 push %ebx 109a68: 83 ec 04 sub $0x4,%esp 109a6b: 8b 5d 08 mov 0x8(%ebp),%ebx uint32_t days_in_month; if ((!the_tod) || 109a6e: 85 db test %ebx,%ebx 109a70: 74 5d je 109acf <_TOD_Validate+0x6b> <== NEVER TAKEN 109a72: b8 40 42 0f 00 mov $0xf4240,%eax 109a77: 31 d2 xor %edx,%edx 109a79: f7 35 30 94 12 00 divl 0x129430 109a7f: 39 43 18 cmp %eax,0x18(%ebx) 109a82: 73 4b jae 109acf <_TOD_Validate+0x6b> 109a84: 83 7b 14 3b cmpl $0x3b,0x14(%ebx) 109a88: 77 45 ja 109acf <_TOD_Validate+0x6b> 109a8a: 83 7b 10 3b cmpl $0x3b,0x10(%ebx) 109a8e: 77 3f ja 109acf <_TOD_Validate+0x6b> 109a90: 83 7b 0c 17 cmpl $0x17,0xc(%ebx) 109a94: 77 39 ja 109acf <_TOD_Validate+0x6b> 109a96: 8b 43 04 mov 0x4(%ebx),%eax 109a99: 85 c0 test %eax,%eax 109a9b: 74 32 je 109acf <_TOD_Validate+0x6b> <== NEVER TAKEN 109a9d: 83 f8 0c cmp $0xc,%eax 109aa0: 77 2d ja 109acf <_TOD_Validate+0x6b> 109aa2: 8b 0b mov (%ebx),%ecx 109aa4: 81 f9 c3 07 00 00 cmp $0x7c3,%ecx 109aaa: 76 23 jbe 109acf <_TOD_Validate+0x6b> 109aac: 8b 53 08 mov 0x8(%ebx),%edx 109aaf: 85 d2 test %edx,%edx 109ab1: 74 1c je 109acf <_TOD_Validate+0x6b> <== NEVER TAKEN (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 109ab3: 80 e1 03 and $0x3,%cl 109ab6: 75 09 jne 109ac1 <_TOD_Validate+0x5d> days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 109ab8: 8b 04 85 64 a7 11 00 mov 0x11a764(,%eax,4),%eax 109abf: eb 07 jmp 109ac8 <_TOD_Validate+0x64> else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 109ac1: 8b 04 85 30 a7 11 00 mov 0x11a730(,%eax,4),%eax 109ac8: 39 c2 cmp %eax,%edx 109aca: 0f 96 c0 setbe %al 109acd: eb 02 jmp 109ad1 <_TOD_Validate+0x6d> 109acf: 31 c0 xor %eax,%eax if ( the_tod->day > days_in_month ) return false; return true; } 109ad1: 5a pop %edx 109ad2: 5b pop %ebx 109ad3: c9 leave 109ad4: c3 ret =============================================================================== 0010a9ec <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10a9ec: 55 push %ebp 10a9ed: 89 e5 mov %esp,%ebp 10a9ef: 57 push %edi 10a9f0: 56 push %esi 10a9f1: 53 push %ebx 10a9f2: 83 ec 18 sub $0x18,%esp 10a9f5: 8b 5d 08 mov 0x8(%ebp),%ebx 10a9f8: 8b 75 0c mov 0xc(%ebp),%esi 10a9fb: 8a 45 10 mov 0x10(%ebp),%al 10a9fe: 88 45 f3 mov %al,-0xd(%ebp) */ /* * Save original state */ original_state = the_thread->current_state; 10aa01: 8b 7b 10 mov 0x10(%ebx),%edi /* * Set a transient state for the thread so it is pulled off the Ready chains. * This will prevent it from being scheduled no matter what happens in an * ISR. */ _Thread_Set_transient( the_thread ); 10aa04: 53 push %ebx 10aa05: e8 3e 0d 00 00 call 10b748 <_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 ) 10aa0a: 83 c4 10 add $0x10,%esp 10aa0d: 39 73 14 cmp %esi,0x14(%ebx) 10aa10: 74 0c je 10aa1e <_Thread_Change_priority+0x32> _Thread_Set_priority( the_thread, new_priority ); 10aa12: 50 push %eax 10aa13: 50 push %eax 10aa14: 56 push %esi 10aa15: 53 push %ebx 10aa16: e8 f9 0b 00 00 call 10b614 <_Thread_Set_priority> 10aa1b: 83 c4 10 add $0x10,%esp _ISR_Disable( level ); 10aa1e: 9c pushf 10aa1f: fa cli 10aa20: 5e pop %esi /* * If the thread has more than STATES_TRANSIENT set, then it is blocked, * If it is blocked on a thread queue, then we need to requeue it. */ state = the_thread->current_state; 10aa21: 8b 53 10 mov 0x10(%ebx),%edx if ( state != STATES_TRANSIENT ) { 10aa24: 83 fa 04 cmp $0x4,%edx 10aa27: 74 30 je 10aa59 <_Thread_Change_priority+0x6d> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10aa29: 83 e7 04 and $0x4,%edi 10aa2c: 75 08 jne 10aa36 <_Thread_Change_priority+0x4a><== NEVER TAKEN the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10aa2e: 89 d0 mov %edx,%eax 10aa30: 83 e0 fb and $0xfffffffb,%eax 10aa33: 89 43 10 mov %eax,0x10(%ebx) _ISR_Enable( level ); 10aa36: 56 push %esi 10aa37: 9d popf if ( _States_Is_waiting_on_thread_queue( state ) ) { 10aa38: 81 e2 e0 be 03 00 and $0x3bee0,%edx 10aa3e: 0f 84 c0 00 00 00 je 10ab04 <_Thread_Change_priority+0x118> _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10aa44: 89 5d 0c mov %ebx,0xc(%ebp) 10aa47: 8b 43 44 mov 0x44(%ebx),%eax 10aa4a: 89 45 08 mov %eax,0x8(%ebp) if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10aa4d: 8d 65 f4 lea -0xc(%ebp),%esp 10aa50: 5b pop %ebx 10aa51: 5e pop %esi 10aa52: 5f pop %edi 10aa53: 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 ); 10aa54: e9 33 0b 00 00 jmp 10b58c <_Thread_queue_Requeue> } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10aa59: 83 e7 04 and $0x4,%edi 10aa5c: 75 53 jne 10aab1 <_Thread_Change_priority+0xc5><== 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 ); 10aa5e: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in 10aa65: 8b 93 90 00 00 00 mov 0x90(%ebx),%edx 10aa6b: 66 8b 83 96 00 00 00 mov 0x96(%ebx),%ax 10aa72: 66 09 02 or %ax,(%edx) * @return TRUE if successfully able to determine the size, FALSE otherwise 10aa75: 66 a1 4c d8 11 00 mov 0x11d84c,%ax 10aa7b: 0b 83 94 00 00 00 or 0x94(%ebx),%eax 10aa81: 66 a3 4c d8 11 00 mov %ax,0x11d84c _Priority_Add_to_bit_map( &the_thread->Priority_map ); if ( prepend_it ) 10aa87: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) 10aa8b: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx 10aa91: 74 0e je 10aaa1 <_Thread_Change_priority+0xb5> 10aa93: 89 53 04 mov %edx,0x4(%ebx) 10aa96: 8b 02 mov (%edx),%eax 10aa98: 89 1a mov %ebx,(%edx) 10aa9a: 89 03 mov %eax,(%ebx) 10aa9c: 89 58 04 mov %ebx,0x4(%eax) 10aa9f: eb 10 jmp 10aab1 <_Thread_Change_priority+0xc5> 10aaa1: 8d 42 04 lea 0x4(%edx),%eax 10aaa4: 89 03 mov %eax,(%ebx) 10aaa6: 8b 42 08 mov 0x8(%edx),%eax 10aaa9: 89 5a 08 mov %ebx,0x8(%edx) 10aaac: 89 18 mov %ebx,(%eax) 10aaae: 89 43 04 mov %eax,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 ); 10aab1: 56 push %esi 10aab2: 9d popf 10aab3: fa cli void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10aab4: 66 8b 0d 4c d8 11 00 mov 0x11d84c,%cx 10aabb: 31 d2 xor %edx,%edx 10aabd: 89 d0 mov %edx,%eax 10aabf: 66 0f bc c1 bsf %cx,%ax * at @a starting_address to @a the_heap. Any coalescing which is 10aac3: 0f b7 c0 movzwl %ax,%eax 10aac6: 66 8b 8c 00 c4 d8 11 mov 0x11d8c4(%eax,%eax,1),%cx 10aacd: 00 10aace: 66 0f bc d1 bsf %cx,%dx /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10aad2: c1 e0 04 shl $0x4,%eax 10aad5: 0f b7 d2 movzwl %dx,%edx 10aad8: 01 d0 add %edx,%eax 10aada: 6b c0 0c imul $0xc,%eax,%eax 10aadd: 8b 15 60 d7 11 00 mov 0x11d760,%edx 10aae3: 8b 04 10 mov (%eax,%edx,1),%eax 10aae6: a3 24 d8 11 00 mov %eax,0x11d824 void *starting_address, size_t size ); /** * This function attempts to allocate a block of @a size bytes from 10aaeb: 8b 15 58 d8 11 00 mov 0x11d858,%edx * 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() && 10aaf1: 39 c2 cmp %eax,%edx 10aaf3: 74 0d je 10ab02 <_Thread_Change_priority+0x116> 10aaf5: 80 7a 76 00 cmpb $0x0,0x76(%edx) 10aaf9: 74 07 je 10ab02 <_Thread_Change_priority+0x116><== NEVER TAKEN _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; 10aafb: c6 05 68 d8 11 00 01 movb $0x1,0x11d868 _ISR_Enable( level ); 10ab02: 56 push %esi 10ab03: 9d popf } 10ab04: 8d 65 f4 lea -0xc(%ebp),%esp 10ab07: 5b pop %ebx 10ab08: 5e pop %esi 10ab09: 5f pop %edi 10ab0a: c9 leave 10ab0b: c3 ret =============================================================================== 0010ab0c <_Thread_Clear_state>: void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 10ab0c: 55 push %ebp 10ab0d: 89 e5 mov %esp,%ebp 10ab0f: 53 push %ebx 10ab10: 8b 4d 08 mov 0x8(%ebp),%ecx 10ab13: 8b 45 0c mov 0xc(%ebp),%eax ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10ab16: 9c pushf 10ab17: fa cli 10ab18: 5b pop %ebx current_state = the_thread->current_state; 10ab19: 8b 51 10 mov 0x10(%ecx),%edx if ( current_state & state ) { 10ab1c: 85 d0 test %edx,%eax 10ab1e: 74 6f je 10ab8f <_Thread_Clear_state+0x83> * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10ab20: f7 d0 not %eax 10ab22: 21 d0 and %edx,%eax current_state = 10ab24: 89 41 10 mov %eax,0x10(%ecx) the_thread->current_state = _States_Clear( state, current_state ); if ( _States_Is_ready( current_state ) ) { 10ab27: 85 c0 test %eax,%eax 10ab29: 75 64 jne 10ab8f <_Thread_Clear_state+0x83> * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in 10ab2b: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx 10ab31: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax 10ab38: 66 09 02 or %ax,(%edx) * @return TRUE if successfully able to determine the size, FALSE otherwise 10ab3b: 66 a1 4c d8 11 00 mov 0x11d84c,%ax 10ab41: 0b 81 94 00 00 00 or 0x94(%ecx),%eax 10ab47: 66 a3 4c d8 11 00 mov %ax,0x11d84c _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10ab4d: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax 10ab53: 8d 50 04 lea 0x4(%eax),%edx 10ab56: 89 11 mov %edx,(%ecx) 10ab58: 8b 50 08 mov 0x8(%eax),%edx 10ab5b: 89 48 08 mov %ecx,0x8(%eax) 10ab5e: 89 0a mov %ecx,(%edx) 10ab60: 89 51 04 mov %edx,0x4(%ecx) _ISR_Flash( level ); 10ab63: 53 push %ebx 10ab64: 9d popf 10ab65: 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 ) { 10ab66: 8b 51 14 mov 0x14(%ecx),%edx 10ab69: a1 24 d8 11 00 mov 0x11d824,%eax 10ab6e: 3b 50 14 cmp 0x14(%eax),%edx 10ab71: 73 1c jae 10ab8f <_Thread_Clear_state+0x83> _Thread_Heir = the_thread; 10ab73: 89 0d 24 d8 11 00 mov %ecx,0x11d824 if ( _Thread_Executing->is_preemptible || 10ab79: a1 58 d8 11 00 mov 0x11d858,%eax 10ab7e: 80 78 76 00 cmpb $0x0,0x76(%eax) 10ab82: 75 04 jne 10ab88 <_Thread_Clear_state+0x7c> 10ab84: 85 d2 test %edx,%edx 10ab86: 75 07 jne 10ab8f <_Thread_Clear_state+0x83><== ALWAYS TAKEN the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10ab88: c6 05 68 d8 11 00 01 movb $0x1,0x11d868 } } } _ISR_Enable( level ); 10ab8f: 53 push %ebx 10ab90: 9d popf } 10ab91: 5b pop %ebx 10ab92: c9 leave 10ab93: c3 ret =============================================================================== 0010ac74 <_Thread_Create_idle>: * * _Thread_Create_idle */ void _Thread_Create_idle( void ) { 10ac74: 55 push %ebp 10ac75: 89 e5 mov %esp,%ebp 10ac77: 83 ec 14 sub $0x14,%esp 10ac7a: 68 f4 d8 11 00 push $0x11d8f4 10ac7f: e8 04 f6 ff ff call 10a288 <_Objects_Allocate> /* * The entire workspace is zeroed during its initialization. Thus, all * fields not explicitly assigned were explicitly zeroed by * _Workspace_Initialization. */ _Thread_Idle = _Thread_Internal_allocate(); 10ac84: a3 40 d9 11 00 mov %eax,0x11d940 /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10ac89: a1 98 d7 11 00 mov 0x11d798,%eax 10ac8e: 40 inc %eax 10ac8f: a3 98 d7 11 00 mov %eax,0x11d798 * that when _Thread_Initialize unnests dispatch that we do not * do anything stupid. */ _Thread_Disable_dispatch(); _Thread_Initialize( 10ac94: a1 30 d8 11 00 mov 0x11d830,%eax 10ac99: 8b 50 18 mov 0x18(%eax),%edx 10ac9c: 83 c4 0c add $0xc,%esp 10ac9f: 68 40 73 11 00 push $0x117340 10aca4: 6a 00 push $0x0 10aca6: 6a 00 push $0x0 10aca8: 6a 00 push $0x0 10acaa: 6a 01 push $0x1 10acac: 0f b6 05 84 93 11 00 movzbl 0x119384,%eax 10acb3: 50 push %eax 10acb4: 6a 00 push $0x0 10acb6: a1 80 93 11 00 mov 0x119380,%eax 10acbb: 39 d0 cmp %edx,%eax 10acbd: 73 02 jae 10acc1 <_Thread_Create_idle+0x4d><== ALWAYS TAKEN 10acbf: 89 d0 mov %edx,%eax <== NOT EXECUTED 10acc1: 50 push %eax 10acc2: 6a 00 push $0x0 10acc4: ff 35 40 d9 11 00 pushl 0x11d940 10acca: 68 f4 d8 11 00 push $0x11d8f4 10accf: e8 50 02 00 00 call 10af24 <_Thread_Initialize> 10acd4: a1 98 d7 11 00 mov 0x11d798,%eax 10acd9: 48 dec %eax 10acda: a3 98 d7 11 00 mov %eax,0x11d798 /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 10acdf: 8b 15 40 d9 11 00 mov 0x11d940,%edx 10ace5: 89 15 58 d8 11 00 mov %edx,0x11d858 10aceb: 89 15 24 d8 11 00 mov %edx,0x11d824 _Thread_Executing = _Thread_Idle; _Thread_Start( 10acf1: 83 c4 24 add $0x24,%esp 10acf4: 6a 00 push $0x0 10acf6: 6a 00 push $0x0 10acf8: a1 30 d8 11 00 mov 0x11d830,%eax 10acfd: ff 70 14 pushl 0x14(%eax) 10ad00: 6a 00 push $0x0 10ad02: 52 push %edx 10ad03: e8 8c 0b 00 00 call 10b894 <_Thread_Start> 10ad08: 83 c4 20 add $0x20,%esp _Configuration_Table->idle_task, NULL, 0 ); } 10ad0b: c9 leave 10ad0c: c3 ret =============================================================================== 0010ad10 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 10ad10: 55 push %ebp 10ad11: 89 e5 mov %esp,%ebp 10ad13: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10ad16: 8d 45 fc lea -0x4(%ebp),%eax 10ad19: 50 push %eax 10ad1a: ff 75 08 pushl 0x8(%ebp) 10ad1d: e8 8a 01 00 00 call 10aeac <_Thread_Get> switch ( location ) { 10ad22: 83 c4 10 add $0x10,%esp 10ad25: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) 10ad29: 75 1b jne 10ad46 <_Thread_Delay_ended+0x36><== NEVER TAKEN void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10ad2b: 52 push %edx 10ad2c: 52 push %edx 10ad2d: 68 f8 ff 03 10 push $0x1003fff8 10ad32: 50 push %eax 10ad33: e8 d4 fd ff ff call 10ab0c <_Thread_Clear_state> 10ad38: a1 98 d7 11 00 mov 0x11d798,%eax 10ad3d: 48 dec %eax 10ad3e: a3 98 d7 11 00 mov %eax,0x11d798 10ad43: 83 c4 10 add $0x10,%esp case OBJECTS_LOCAL: _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; } } 10ad46: c9 leave 10ad47: c3 ret =============================================================================== 0010ad48 <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10ad48: 55 push %ebp 10ad49: 89 e5 mov %esp,%ebp 10ad4b: 57 push %edi 10ad4c: 56 push %esi 10ad4d: 53 push %ebx 10ad4e: 83 ec 1c sub $0x1c,%esp Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10ad51: 8b 1d 58 d8 11 00 mov 0x11d858,%ebx _ISR_Disable( level ); 10ad57: 9c pushf 10ad58: fa cli 10ad59: 5a pop %edx #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec uptime, ran; _TOD_Get_uptime( &uptime ); _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); 10ad5a: 8d 7d e4 lea -0x1c(%ebp),%edi 10ad5d: e9 f1 00 00 00 jmp 10ae53 <_Thread_Dispatch+0x10b> ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Context_Switch_necessary == TRUE ) { heir = _Thread_Heir; 10ad62: 8b 35 24 d8 11 00 mov 0x11d824,%esi _Thread_Dispatch_disable_level = 1; 10ad68: c7 05 98 d7 11 00 01 movl $0x1,0x11d798 10ad6f: 00 00 00 _Context_Switch_necessary = FALSE; 10ad72: c6 05 68 d8 11 00 00 movb $0x0,0x11d868 _Thread_Executing = heir; 10ad79: 89 35 58 d8 11 00 mov %esi,0x11d858 #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 ) 10ad7f: 83 7e 7c 01 cmpl $0x1,0x7c(%esi) 10ad83: 75 08 jne 10ad8d <_Thread_Dispatch+0x45> heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10ad85: a1 64 d7 11 00 mov 0x11d764,%eax 10ad8a: 89 46 78 mov %eax,0x78(%esi) _ISR_Enable( level ); 10ad8d: 52 push %edx 10ad8e: 9d popf #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec uptime, ran; _TOD_Get_uptime( &uptime ); 10ad8f: 83 ec 0c sub $0xc,%esp 10ad92: 8d 45 ec lea -0x14(%ebp),%eax 10ad95: 50 push %eax 10ad96: e8 a1 31 00 00 call 10df3c <_TOD_Get_uptime> _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); 10ad9b: 83 c4 0c add $0xc,%esp 10ad9e: 57 push %edi 10ad9f: 8d 45 ec lea -0x14(%ebp),%eax 10ada2: 50 push %eax 10ada3: 68 60 d8 11 00 push $0x11d860 10ada8: e8 37 0c 00 00 call 10b9e4 <_Timespec_Subtract> _Timespec_Add_to( &executing->cpu_time_used, &ran ); 10adad: 58 pop %eax 10adae: 5a pop %edx 10adaf: 57 push %edi 10adb0: 8d 83 84 00 00 00 lea 0x84(%ebx),%eax 10adb6: 50 push %eax 10adb7: e8 f8 0b 00 00 call 10b9b4 <_Timespec_Add_to> _Thread_Time_of_last_context_switch = uptime; 10adbc: 8b 45 ec mov -0x14(%ebp),%eax 10adbf: 8b 55 f0 mov -0x10(%ebp),%edx 10adc2: a3 60 d8 11 00 mov %eax,0x11d860 10adc7: 89 15 64 d8 11 00 mov %edx,0x11d864 #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10adcd: 8b 15 20 d8 11 00 mov 0x11d820,%edx 10add3: 83 c4 10 add $0x10,%esp 10add6: 85 d2 test %edx,%edx 10add8: 74 10 je 10adea <_Thread_Dispatch+0xa2> <== NEVER TAKEN executing->libc_reent = *_Thread_libc_reent; 10adda: 8b 02 mov (%edx),%eax 10addc: 89 83 f0 00 00 00 mov %eax,0xf0(%ebx) *_Thread_libc_reent = heir->libc_reent; 10ade2: 8b 86 f0 00 00 00 mov 0xf0(%esi),%eax 10ade8: 89 02 mov %eax,(%edx) } _User_extensions_Thread_switch( executing, heir ); 10adea: 51 push %ecx 10adeb: 51 push %ecx 10adec: 56 push %esi 10aded: 53 push %ebx 10adee: e8 01 0e 00 00 call 10bbf4 <_User_extensions_Thread_switch> if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10adf3: 58 pop %eax 10adf4: 5a pop %edx 10adf5: 8d 86 d4 00 00 00 lea 0xd4(%esi),%eax 10adfb: 50 push %eax 10adfc: 8d 83 d4 00 00 00 lea 0xd4(%ebx),%eax 10ae02: 50 push %eax 10ae03: e8 b8 10 00 00 call 10bec0 <_CPU_Context_switch> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10ae08: 83 c4 10 add $0x10,%esp 10ae0b: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx) 10ae12: 74 36 je 10ae4a <_Thread_Dispatch+0x102> Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10ae14: a1 1c d8 11 00 mov 0x11d81c,%eax 10ae19: 39 c3 cmp %eax,%ebx 10ae1b: 74 2d je 10ae4a <_Thread_Dispatch+0x102> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10ae1d: 85 c0 test %eax,%eax 10ae1f: 74 11 je 10ae32 <_Thread_Dispatch+0xea> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10ae21: 83 ec 0c sub $0xc,%esp 10ae24: 05 ec 00 00 00 add $0xec,%eax 10ae29: 50 push %eax 10ae2a: e8 c5 10 00 00 call 10bef4 <_CPU_Context_save_fp> 10ae2f: 83 c4 10 add $0x10,%esp _Context_Restore_fp( &executing->fp_context ); 10ae32: 83 ec 0c sub $0xc,%esp 10ae35: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax 10ae3b: 50 push %eax 10ae3c: e8 bd 10 00 00 call 10befe <_CPU_Context_restore_fp> _Thread_Allocated_fp = executing; 10ae41: 89 1d 1c d8 11 00 mov %ebx,0x11d81c 10ae47: 83 c4 10 add $0x10,%esp if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10ae4a: 8b 1d 58 d8 11 00 mov 0x11d858,%ebx _ISR_Disable( level ); 10ae50: 9c pushf 10ae51: fa cli 10ae52: 5a pop %edx Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Context_Switch_necessary == TRUE ) { 10ae53: a0 68 d8 11 00 mov 0x11d868,%al 10ae58: 84 c0 test %al,%al 10ae5a: 0f 85 02 ff ff ff jne 10ad62 <_Thread_Dispatch+0x1a> executing = _Thread_Executing; _ISR_Disable( level ); } _Thread_Dispatch_disable_level = 0; 10ae60: c7 05 98 d7 11 00 00 movl $0x0,0x11d798 10ae67: 00 00 00 _ISR_Enable( level ); 10ae6a: 52 push %edx 10ae6b: 9d popf if ( _Thread_Do_post_task_switch_extension || 10ae6c: 83 3d 3c d8 11 00 00 cmpl $0x0,0x11d83c 10ae73: 75 06 jne 10ae7b <_Thread_Dispatch+0x133> 10ae75: 80 7b 75 00 cmpb $0x0,0x75(%ebx) 10ae79: 74 09 je 10ae84 <_Thread_Dispatch+0x13c> executing->do_post_task_switch_extension ) { executing->do_post_task_switch_extension = false; 10ae7b: c6 43 75 00 movb $0x0,0x75(%ebx) _API_extensions_Run_postswitch(); 10ae7f: e8 4b eb ff ff call 1099cf <_API_extensions_Run_postswitch> } } 10ae84: 8d 65 f4 lea -0xc(%ebp),%esp 10ae87: 5b pop %ebx 10ae88: 5e pop %esi 10ae89: 5f pop %edi 10ae8a: c9 leave 10ae8b: c3 ret =============================================================================== 0010ef3c <_Thread_Evaluate_mode>: * * XXX */ bool _Thread_Evaluate_mode( void ) { 10ef3c: 55 push %ebp 10ef3d: 89 e5 mov %esp,%ebp Thread_Control *executing; executing = _Thread_Executing; 10ef3f: a1 58 d8 11 00 mov 0x11d858,%eax if ( !_States_Is_ready( executing->current_state ) || 10ef44: 83 78 10 00 cmpl $0x0,0x10(%eax) 10ef48: 75 0e jne 10ef58 <_Thread_Evaluate_mode+0x1c><== NEVER TAKEN 10ef4a: 3b 05 24 d8 11 00 cmp 0x11d824,%eax 10ef50: 74 11 je 10ef63 <_Thread_Evaluate_mode+0x27> 10ef52: 80 78 76 00 cmpb $0x0,0x76(%eax) 10ef56: 74 0b je 10ef63 <_Thread_Evaluate_mode+0x27><== NEVER TAKEN ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) { _Context_Switch_necessary = TRUE; 10ef58: c6 05 68 d8 11 00 01 movb $0x1,0x11d868 10ef5f: b0 01 mov $0x1,%al 10ef61: eb 02 jmp 10ef65 <_Thread_Evaluate_mode+0x29> return TRUE; 10ef63: 31 c0 xor %eax,%eax } return FALSE; } 10ef65: c9 leave 10ef66: c3 ret =============================================================================== 0010aeac <_Thread_Get>: Thread_Control *_Thread_Get ( Objects_Id id, Objects_Locations *location ) { 10aeac: 55 push %ebp 10aead: 89 e5 mov %esp,%ebp 10aeaf: 53 push %ebx 10aeb0: 83 ec 04 sub $0x4,%esp 10aeb3: 8b 5d 08 mov 0x8(%ebp),%ebx 10aeb6: 8b 4d 0c mov 0xc(%ebp),%ecx uint32_t the_class; Objects_Information **api_information; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 10aeb9: 85 db test %ebx,%ebx 10aebb: 75 18 jne 10aed5 <_Thread_Get+0x29> /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10aebd: a1 98 d7 11 00 mov 0x11d798,%eax 10aec2: 40 inc %eax 10aec3: a3 98 d7 11 00 mov %eax,0x11d798 _Thread_Disable_dispatch(); *location = OBJECTS_LOCAL; 10aec8: c7 01 00 00 00 00 movl $0x0,(%ecx) tp = _Thread_Executing; 10aece: a1 58 d8 11 00 mov 0x11d858,%eax 10aed3: eb 40 jmp 10af15 <_Thread_Get+0x69> uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10aed5: 89 da mov %ebx,%edx 10aed7: c1 ea 18 shr $0x18,%edx 10aeda: 83 e2 07 and $0x7,%edx /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10aedd: 8d 42 ff lea -0x1(%edx),%eax 10aee0: 83 f8 03 cmp $0x3,%eax 10aee3: 76 35 jbe 10af1a <_Thread_Get+0x6e> goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ *location = OBJECTS_ERROR; 10aee5: c7 01 01 00 00 00 movl $0x1,(%ecx) 10aeeb: 31 c0 xor %eax,%eax 10aeed: eb 26 jmp 10af15 <_Thread_Get+0x69> goto done; } api_information = _Objects_Information_table[ the_api ]; 10aeef: 8b 04 95 6c d7 11 00 mov 0x11d76c(,%edx,4),%eax if ( !api_information ) { 10aef6: 85 c0 test %eax,%eax 10aef8: 74 07 je 10af01 <_Thread_Get+0x55> *location = OBJECTS_ERROR; goto done; } information = api_information[ the_class ]; 10aefa: 8b 40 04 mov 0x4(%eax),%eax if ( !information ) { 10aefd: 85 c0 test %eax,%eax 10aeff: 75 08 jne 10af09 <_Thread_Get+0x5d> <== ALWAYS TAKEN *location = OBJECTS_ERROR; 10af01: c7 01 01 00 00 00 movl $0x1,(%ecx) 10af07: eb 0c jmp 10af15 <_Thread_Get+0x69> goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 10af09: 52 push %edx 10af0a: 51 push %ecx 10af0b: 53 push %ebx 10af0c: 50 push %eax 10af0d: e8 ba f7 ff ff call 10a6cc <_Objects_Get> 10af12: 83 c4 10 add $0x10,%esp done: return tp; } 10af15: 8b 5d fc mov -0x4(%ebp),%ebx 10af18: c9 leave 10af19: c3 ret *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 10af1a: 89 d8 mov %ebx,%eax 10af1c: c1 e8 1b shr $0x1b,%eax 10af1f: 48 dec %eax 10af20: 74 cd je 10aeef <_Thread_Get+0x43> 10af22: eb c1 jmp 10aee5 <_Thread_Get+0x39> =============================================================================== 0010ef68 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 10ef68: 55 push %ebp 10ef69: 89 e5 mov %esp,%ebp 10ef6b: 53 push %ebx 10ef6c: 83 ec 04 sub $0x4,%esp #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing; 10ef6f: 8b 1d 58 d8 11 00 mov 0x11d858,%ebx /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 10ef75: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax _ISR_Set_level(level); 10ef7b: 85 c0 test %eax,%eax 10ef7d: 74 03 je 10ef82 <_Thread_Handler+0x1a> 10ef7f: fa cli 10ef80: eb 01 jmp 10ef83 <_Thread_Handler+0x1b> 10ef82: fb sti #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; 10ef83: a0 90 d5 11 00 mov 0x11d590,%al 10ef88: 88 45 fb mov %al,-0x5(%ebp) doneConstructors = 1; 10ef8b: c6 05 90 d5 11 00 01 movb $0x1,0x11d590 #endif #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && !_Thread_Is_allocated_fp( executing ) ) { 10ef92: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx) 10ef99: 74 24 je 10efbf <_Thread_Handler+0x57> Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10ef9b: a1 1c d8 11 00 mov 0x11d81c,%eax 10efa0: 39 c3 cmp %eax,%ebx 10efa2: 74 1b je 10efbf <_Thread_Handler+0x57> if ( _Thread_Allocated_fp != NULL ) 10efa4: 85 c0 test %eax,%eax 10efa6: 74 11 je 10efb9 <_Thread_Handler+0x51> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10efa8: 83 ec 0c sub $0xc,%esp 10efab: 05 ec 00 00 00 add $0xec,%eax 10efb0: 50 push %eax 10efb1: e8 3e cf ff ff call 10bef4 <_CPU_Context_save_fp> 10efb6: 83 c4 10 add $0x10,%esp _Thread_Allocated_fp = executing; 10efb9: 89 1d 1c d8 11 00 mov %ebx,0x11d81c * 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 ); 10efbf: 83 ec 0c sub $0xc,%esp 10efc2: 53 push %ebx 10efc3: e8 e0 ca ff ff call 10baa8 <_User_extensions_Thread_begin> /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 10efc8: e8 bf be ff ff call 10ae8c <_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) */ 10efcd: 83 c4 10 add $0x10,%esp 10efd0: 80 7d fb 00 cmpb $0x0,-0x5(%ebp) 10efd4: 75 05 jne 10efdb <_Thread_Handler+0x73> { _init (); 10efd6: e8 85 6e 00 00 call 115e60 <__start_set_sysctl_set> #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 10efdb: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax 10efe1: 83 f8 01 cmp $0x1,%eax 10efe4: 74 13 je 10eff9 <_Thread_Handler+0x91> 10efe6: 72 0c jb 10eff4 <_Thread_Handler+0x8c> <== ALWAYS TAKEN 10efe8: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10efeb: 74 11 je 10effe <_Thread_Handler+0x96> <== NOT EXECUTED 10efed: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10eff0: 75 36 jne 10f028 <_Thread_Handler+0xc0> <== NOT EXECUTED 10eff2: eb 1a jmp 10f00e <_Thread_Handler+0xa6> <== NOT EXECUTED case THREAD_START_NUMERIC: executing->Wait.return_argument = 10eff4: 83 ec 0c sub $0xc,%esp 10eff7: eb 1d jmp 10f016 <_Thread_Handler+0xae> (*(Thread_Entry_numeric) executing->Start.entry_point)( executing->Start.numeric_argument ); break; case THREAD_START_POINTER: executing->Wait.return_argument = 10eff9: 83 ec 0c sub $0xc,%esp 10effc: eb 08 jmp 10f006 <_Thread_Handler+0x9e> (*(Thread_Entry_pointer) executing->Start.entry_point)( executing->Start.pointer_argument ); break; case THREAD_START_BOTH_POINTER_FIRST: executing->Wait.return_argument = 10effe: 52 push %edx <== NOT EXECUTED 10efff: 52 push %edx <== NOT EXECUTED 10f000: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 10f006: ff b3 a4 00 00 00 pushl 0xa4(%ebx) 10f00c: eb 0e jmp 10f01c <_Thread_Handler+0xb4> executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 10f00e: 50 push %eax <== NOT EXECUTED 10f00f: 50 push %eax <== NOT EXECUTED 10f010: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 10f016: ff b3 a8 00 00 00 pushl 0xa8(%ebx) 10f01c: ff 93 9c 00 00 00 call *0x9c(%ebx) 10f022: 89 43 28 mov %eax,0x28(%ebx) 10f025: 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 ); 10f028: 83 ec 0c sub $0xc,%esp 10f02b: 53 push %ebx 10f02c: e8 a8 ca ff ff call 10bad9 <_User_extensions_Thread_exitted> _Internal_error_Occurred( 10f031: 83 c4 0c add $0xc,%esp 10f034: 6a 06 push $0x6 10f036: 6a 01 push $0x1 10f038: 6a 00 push $0x0 10f03a: e8 b5 b1 ff ff call 10a1f4 <_Internal_error_Occurred> =============================================================================== 0010af24 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10af24: 55 push %ebp 10af25: 89 e5 mov %esp,%ebp 10af27: 57 push %edi 10af28: 56 push %esi 10af29: 53 push %ebx 10af2a: 83 ec 0c sub $0xc,%esp 10af2d: 8b 5d 0c mov 0xc(%ebp),%ebx 10af30: 8b 55 10 mov 0x10(%ebp),%edx 10af33: 8b 75 14 mov 0x14(%ebp),%esi 10af36: 8a 45 18 mov 0x18(%ebp),%al 10af39: 88 45 f3 mov %al,-0xd(%ebp) 10af3c: 8a 45 20 mov 0x20(%ebp),%al 10af3f: 88 45 f2 mov %al,-0xe(%ebp) /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 10af42: 85 d2 test %edx,%edx 10af44: 75 2a jne 10af70 <_Thread_Initialize+0x4c><== NEVER TAKEN actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10af46: 51 push %ecx 10af47: 51 push %ecx 10af48: 56 push %esi 10af49: 53 push %ebx 10af4a: e8 69 08 00 00 call 10b7b8 <_Thread_Stack_Allocate> if ( !actual_stack_size || actual_stack_size < stack_size ) 10af4f: 83 c4 10 add $0x10,%esp 10af52: 85 c0 test %eax,%eax 10af54: 74 04 je 10af5a <_Thread_Initialize+0x36> 10af56: 39 f0 cmp %esi,%eax 10af58: 73 07 jae 10af61 <_Thread_Initialize+0x3d><== ALWAYS TAKEN 10af5a: 31 d2 xor %edx,%edx 10af5c: e9 8c 01 00 00 jmp 10b0ed <_Thread_Initialize+0x1c9> return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 10af61: 8b 93 d0 00 00 00 mov 0xd0(%ebx),%edx the_thread->Start.core_allocated_stack = TRUE; 10af67: c6 83 c0 00 00 00 01 movb $0x1,0xc0(%ebx) 10af6e: eb 09 jmp 10af79 <_Thread_Initialize+0x55> } else { stack = stack_area; actual_stack_size = stack_size; the_thread->Start.core_allocated_stack = FALSE; 10af70: c6 83 c0 00 00 00 00 movb $0x0,0xc0(%ebx) <== NOT EXECUTED 10af77: 89 f0 mov %esi,%eax <== NOT EXECUTED /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of 10af79: 89 93 c8 00 00 00 mov %edx,0xc8(%ebx) * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 10af7f: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx) if ( is_fp ) { fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); if ( !fp_area ) { _Thread_Stack_Free( the_thread ); return FALSE; 10af85: 31 f6 xor %esi,%esi /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 10af87: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) 10af8b: 74 17 je 10afa4 <_Thread_Initialize+0x80> fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10af8d: 83 ec 0c sub $0xc,%esp 10af90: 6a 6c push $0x6c 10af92: e8 92 0e 00 00 call 10be29 <_Workspace_Allocate> 10af97: 89 c6 mov %eax,%esi if ( !fp_area ) { 10af99: 83 c4 10 add $0x10,%esp 10af9c: 85 c0 test %eax,%eax 10af9e: 0f 84 3b 01 00 00 je 10b0df <_Thread_Initialize+0x1bb><== NEVER TAKEN fp_area = _Context_Fp_start( fp_area, 0 ); } else fp_area = NULL; the_thread->fp_context = fp_area; 10afa4: 89 b3 ec 00 00 00 mov %esi,0xec(%ebx) the_thread->Start.fp_context = fp_area; 10afaa: 89 b3 cc 00 00 00 mov %esi,0xcc(%ebx) * 10afb0: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) * @param[in] the_heap is the heap to operate upon 10afb7: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) * @param[in] starting_address is the starting address of the memory for 10afbe: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) * the heap 10afc5: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) /* * Clear the libc reent hook. */ the_thread->libc_reent = NULL; 10afcc: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx) 10afd3: 00 00 00 /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10afd6: a1 38 d8 11 00 mov 0x11d838,%eax (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); return FALSE; 10afdb: 31 ff xor %edi,%edi /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10afdd: 85 c0 test %eax,%eax 10afdf: 74 1d je 10affe <_Thread_Initialize+0xda> extensions_area = _Workspace_Allocate( 10afe1: 83 ec 0c sub $0xc,%esp 10afe4: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10afeb: 50 push %eax 10afec: e8 38 0e 00 00 call 10be29 <_Workspace_Allocate> 10aff1: 89 c7 mov %eax,%edi (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 10aff3: 83 c4 10 add $0x10,%esp 10aff6: 85 c0 test %eax,%eax 10aff8: 0f 84 d1 00 00 00 je 10b0cf <_Thread_Initialize+0x1ab><== NEVER TAKEN return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 10affe: 89 bb 00 01 00 00 mov %edi,0x100(%ebx) * create the extension long after tasks have been created * so they cannot rely on the thread create user extension * call. */ if ( the_thread->extensions ) { 10b004: 31 d2 xor %edx,%edx 10b006: 85 ff test %edi,%edi 10b008: 75 10 jne 10b01a <_Thread_Initialize+0xf6> 10b00a: eb 18 jmp 10b024 <_Thread_Initialize+0x100> uint32_t i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) the_thread->extensions[i] = NULL; 10b00c: 8b 83 00 01 00 00 mov 0x100(%ebx),%eax 10b012: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) * call. */ if ( the_thread->extensions ) { uint32_t i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 10b019: 42 inc %edx 10b01a: a1 38 d8 11 00 mov 0x11d838,%eax 10b01f: 40 inc %eax 10b020: 39 c2 cmp %eax,%edx 10b022: 72 e8 jb 10b00c <_Thread_Initialize+0xe8> /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10b024: 8a 45 f2 mov -0xe(%ebp),%al 10b027: 88 83 ac 00 00 00 mov %al,0xac(%ebx) the_thread->Start.budget_algorithm = budget_algorithm; 10b02d: 8b 45 24 mov 0x24(%ebp),%eax 10b030: 89 83 b0 00 00 00 mov %eax,0xb0(%ebx) the_thread->Start.budget_callout = budget_callout; 10b036: 8b 45 28 mov 0x28(%ebp),%eax 10b039: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) switch ( budget_algorithm ) { 10b03f: 83 7d 24 02 cmpl $0x2,0x24(%ebp) 10b043: 75 08 jne 10b04d <_Thread_Initialize+0x129><== ALWAYS TAKEN case THREAD_CPU_BUDGET_ALGORITHM_NONE: case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: break; case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10b045: a1 64 d7 11 00 mov 0x11d764,%eax <== NOT EXECUTED 10b04a: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 10b04d: 8b 45 2c mov 0x2c(%ebp),%eax 10b050: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) the_thread->current_state = STATES_DORMANT; 10b056: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) the_thread->Wait.queue = NULL; 10b05d: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) the_thread->resource_count = 0; 10b064: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->suspend_count = 0; 10b06b: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) the_thread->real_priority = priority; 10b072: 8b 45 1c mov 0x1c(%ebp),%eax 10b075: 89 43 18 mov %eax,0x18(%ebx) the_thread->Start.initial_priority = priority; 10b078: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) _Thread_Set_priority( the_thread, priority ); 10b07e: 52 push %edx 10b07f: 52 push %edx 10b080: 50 push %eax 10b081: 53 push %ebx 10b082: e8 8d 05 00 00 call 10b614 <_Thread_Set_priority> /* * Initialize the CPU usage statistics */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS the_thread->cpu_time_used.tv_sec = 0; 10b087: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) 10b08e: 00 00 00 the_thread->cpu_time_used.tv_nsec = 0; 10b091: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) 10b098: 00 00 00 10b09b: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10b09f: 8b 45 08 mov 0x8(%ebp),%eax 10b0a2: 8b 40 1c mov 0x1c(%eax),%eax 10b0a5: 89 1c 90 mov %ebx,(%eax,%edx,4) 10b0a8: 8b 45 30 mov 0x30(%ebp),%eax 10b0ab: 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 ); 10b0ae: 89 1c 24 mov %ebx,(%esp) 10b0b1: e8 92 0a 00 00 call 10bb48 <_User_extensions_Thread_create> if ( !extension_status ) { 10b0b6: 83 c4 10 add $0x10,%esp 10b0b9: b2 01 mov $0x1,%dl 10b0bb: 84 c0 test %al,%al 10b0bd: 75 2e jne 10b0ed <_Thread_Initialize+0x1c9> if ( extensions_area ) 10b0bf: 85 ff test %edi,%edi 10b0c1: 74 0c je 10b0cf <_Thread_Initialize+0x1ab><== ALWAYS TAKEN (void) _Workspace_Free( extensions_area ); 10b0c3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b0c6: 57 push %edi <== NOT EXECUTED 10b0c7: e8 48 0d 00 00 call 10be14 <_Workspace_Free> <== NOT EXECUTED 10b0cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 10b0cf: 85 f6 test %esi,%esi 10b0d1: 74 0c je 10b0df <_Thread_Initialize+0x1bb><== ALWAYS TAKEN (void) _Workspace_Free( fp_area ); 10b0d3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b0d6: 56 push %esi <== NOT EXECUTED 10b0d7: e8 38 0d 00 00 call 10be14 <_Workspace_Free> <== NOT EXECUTED 10b0dc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 10b0df: 83 ec 0c sub $0xc,%esp 10b0e2: 53 push %ebx 10b0e3: e8 20 07 00 00 call 10b808 <_Thread_Stack_Free> 10b0e8: 31 d2 xor %edx,%edx 10b0ea: 83 c4 10 add $0x10,%esp return FALSE; } return TRUE; } 10b0ed: 88 d0 mov %dl,%al 10b0ef: 8d 65 f4 lea -0xc(%ebp),%esp 10b0f2: 5b pop %ebx 10b0f3: 5e pop %esi 10b0f4: 5f pop %edi 10b0f5: c9 leave 10b0f6: c3 ret =============================================================================== 0010ef70 <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10ef70: 55 push %ebp 10ef71: 89 e5 mov %esp,%ebp 10ef73: 53 push %ebx 10ef74: 83 ec 10 sub $0x10,%esp 10ef77: 8b 5d 08 mov 0x8(%ebp),%ebx the_thread->resource_count = 0; 10ef7a: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->suspend_count = 0; 10ef81: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) the_thread->is_preemptible = the_thread->Start.is_preemptible; 10ef88: 8a 83 ac 00 00 00 mov 0xac(%ebx),%al 10ef8e: 88 43 76 mov %al,0x76(%ebx) the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 10ef91: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax 10ef97: 89 43 7c mov %eax,0x7c(%ebx) the_thread->budget_callout = the_thread->Start.budget_callout; 10ef9a: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax 10efa0: 89 83 80 00 00 00 mov %eax,0x80(%ebx) the_thread->Start.pointer_argument = pointer_argument; 10efa6: 8b 45 0c mov 0xc(%ebp),%eax 10efa9: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) the_thread->Start.numeric_argument = numeric_argument; 10efaf: 8b 45 10 mov 0x10(%ebp),%eax 10efb2: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 10efb8: 53 push %ebx 10efb9: e8 9e ce ff ff call 10be5c <_Thread_queue_Extract_with_proxy> 10efbe: 83 c4 10 add $0x10,%esp 10efc1: 84 c0 test %al,%al 10efc3: 75 15 jne 10efda <_Thread_Reset+0x6a> <== NEVER TAKEN if ( _Watchdog_Is_active( &the_thread->Timer ) ) 10efc5: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 10efc9: 75 0f jne 10efda <_Thread_Reset+0x6a> <== ALWAYS TAKEN (void) _Watchdog_Remove( &the_thread->Timer ); 10efcb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10efce: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10efd1: 50 push %eax <== NOT EXECUTED 10efd2: e8 c5 d7 ff ff call 10c79c <_Watchdog_Remove> <== NOT EXECUTED 10efd7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 10efda: 8b 83 bc 00 00 00 mov 0xbc(%ebx),%eax 10efe0: 39 43 14 cmp %eax,0x14(%ebx) 10efe3: 74 12 je 10eff7 <_Thread_Reset+0x87> the_thread->real_priority = the_thread->Start.initial_priority; 10efe5: 89 43 18 mov %eax,0x18(%ebx) _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 10efe8: 89 45 0c mov %eax,0xc(%ebp) 10efeb: 89 5d 08 mov %ebx,0x8(%ebp) } } 10efee: 8b 5d fc mov -0x4(%ebp),%ebx 10eff1: c9 leave (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { the_thread->real_priority = the_thread->Start.initial_priority; _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 10eff2: e9 41 d0 ff ff jmp 10c038 <_Thread_Set_priority> } } 10eff7: 8b 5d fc mov -0x4(%ebp),%ebx 10effa: c9 leave 10effb: c3 ret =============================================================================== 0010e498 <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 10e498: 55 push %ebp 10e499: 89 e5 mov %esp,%ebp 10e49b: 56 push %esi 10e49c: 53 push %ebx ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10e49d: 8b 0d 58 d8 11 00 mov 0x11d858,%ecx ready = executing->ready; 10e4a3: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx _ISR_Disable( level ); 10e4a9: 9c pushf 10e4aa: fa cli 10e4ab: 5e pop %esi if ( _Chain_Has_only_one_node( ready ) ) { 10e4ac: 8b 03 mov (%ebx),%eax 10e4ae: 3b 43 08 cmp 0x8(%ebx),%eax 10e4b1: 75 04 jne 10e4b7 <_Thread_Reset_timeslice+0x1f> _ISR_Enable( level ); 10e4b3: 56 push %esi 10e4b4: 9d popf 10e4b5: eb 35 jmp 10e4ec <_Thread_Reset_timeslice+0x54> 10e4b7: 8b 11 mov (%ecx),%edx 10e4b9: 8b 41 04 mov 0x4(%ecx),%eax 10e4bc: 89 42 04 mov %eax,0x4(%edx) 10e4bf: 89 10 mov %edx,(%eax) 10e4c1: 8d 43 04 lea 0x4(%ebx),%eax 10e4c4: 89 01 mov %eax,(%ecx) 10e4c6: 8b 43 08 mov 0x8(%ebx),%eax 10e4c9: 89 4b 08 mov %ecx,0x8(%ebx) 10e4cc: 89 08 mov %ecx,(%eax) 10e4ce: 89 41 04 mov %eax,0x4(%ecx) return; } _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 10e4d1: 56 push %esi 10e4d2: 9d popf 10e4d3: fa cli if ( _Thread_Is_heir( executing ) ) 10e4d4: 3b 0d 24 d8 11 00 cmp 0x11d824,%ecx 10e4da: 75 07 jne 10e4e3 <_Thread_Reset_timeslice+0x4b><== NEVER TAKEN _Thread_Heir = (Thread_Control *) ready->first; 10e4dc: 8b 03 mov (%ebx),%eax 10e4de: a3 24 d8 11 00 mov %eax,0x11d824 _Context_Switch_necessary = TRUE; 10e4e3: c6 05 68 d8 11 00 01 movb $0x1,0x11d868 _ISR_Enable( level ); 10e4ea: 56 push %esi 10e4eb: 9d popf } 10e4ec: 5b pop %ebx 10e4ed: 5e pop %esi 10e4ee: c9 leave 10e4ef: c3 ret =============================================================================== 0010bfb0 <_Thread_Restart>: bool _Thread_Restart( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10bfb0: 55 push %ebp 10bfb1: 89 e5 mov %esp,%ebp 10bfb3: 53 push %ebx 10bfb4: 83 ec 04 sub $0x4,%esp 10bfb7: 8b 5d 08 mov 0x8(%ebp),%ebx if ( !_States_Is_dormant( the_thread->current_state ) ) { 10bfba: 31 c0 xor %eax,%eax 10bfbc: f6 43 10 01 testb $0x1,0x10(%ebx) 10bfc0: 75 70 jne 10c032 <_Thread_Restart+0x82> _Thread_Set_transient( the_thread ); 10bfc2: 83 ec 0c sub $0xc,%esp 10bfc5: 53 push %ebx 10bfc6: e8 a1 01 00 00 call 10c16c <_Thread_Set_transient> _Thread_Reset( the_thread, pointer_argument, numeric_argument ); 10bfcb: 83 c4 0c add $0xc,%esp 10bfce: ff 75 10 pushl 0x10(%ebp) 10bfd1: ff 75 0c pushl 0xc(%ebp) 10bfd4: 53 push %ebx 10bfd5: e8 96 2f 00 00 call 10ef70 <_Thread_Reset> _Thread_Load_environment( the_thread ); 10bfda: 89 1c 24 mov %ebx,(%esp) 10bfdd: e8 8a 2c 00 00 call 10ec6c <_Thread_Load_environment> _Thread_Ready( the_thread ); 10bfe2: 89 1c 24 mov %ebx,(%esp) 10bfe5: e8 e6 2e 00 00 call 10eed0 <_Thread_Ready> _User_extensions_Thread_restart( the_thread ); 10bfea: 89 1c 24 mov %ebx,(%esp) 10bfed: e8 ee 05 00 00 call 10c5e0 <_User_extensions_Thread_restart> if ( _Thread_Is_executing ( the_thread ) ) 10bff2: 83 c4 10 add $0x10,%esp 10bff5: b0 01 mov $0x1,%al 10bff7: 3b 1d c4 0c 12 00 cmp 0x120cc4,%ebx 10bffd: 75 33 jne 10c032 <_Thread_Restart+0x82> * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @param[in] alignment the required alignment 10bfff: 83 bb ec 00 00 00 00 cmpl $0x0,0xec(%ebx) 10c006: 74 12 je 10c01a <_Thread_Restart+0x6a> * @return NULL if unsuccessful and a pointer to the block if successful 10c008: 83 ec 0c sub $0xc,%esp 10c00b: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax 10c011: 50 push %eax 10c012: e8 47 09 00 00 call 10c95e <_CPU_Context_restore_fp> 10c017: 83 c4 10 add $0x10,%esp */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, 10c01a: 83 ec 0c sub $0xc,%esp 10c01d: a1 c4 0c 12 00 mov 0x120cc4,%eax 10c022: 05 d4 00 00 00 add $0xd4,%eax 10c027: 50 push %eax 10c028: e8 20 09 00 00 call 10c94d <_CPU_Context_restore> 10c02d: b0 01 mov $0x1,%al <== NOT EXECUTED 10c02f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return TRUE; } return FALSE; } 10c032: 8b 5d fc mov -0x4(%ebp),%ebx 10c035: c9 leave 10c036: c3 ret =============================================================================== 0010c9c0 <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) { 10c9c0: 55 push %ebp 10c9c1: 89 e5 mov %esp,%ebp 10c9c3: 53 push %ebx 10c9c4: 8b 4d 08 mov 0x8(%ebp),%ecx 10c9c7: 8a 45 0c mov 0xc(%ebp),%al ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10c9ca: 9c pushf 10c9cb: fa cli 10c9cc: 5b pop %ebx if ( force == TRUE ) 10c9cd: 84 c0 test %al,%al 10c9cf: 74 09 je 10c9da <_Thread_Resume+0x1a> <== NEVER TAKEN the_thread->suspend_count = 0; 10c9d1: c7 41 70 00 00 00 00 movl $0x0,0x70(%ecx) 10c9d8: eb 03 jmp 10c9dd <_Thread_Resume+0x1d> else the_thread->suspend_count--; 10c9da: ff 49 70 decl 0x70(%ecx) <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 10c9dd: 83 79 70 00 cmpl $0x0,0x70(%ecx) 10c9e1: 74 04 je 10c9e7 <_Thread_Resume+0x27> <== ALWAYS TAKEN _ISR_Enable( level ); 10c9e3: 53 push %ebx <== NOT EXECUTED 10c9e4: 9d popf <== NOT EXECUTED 10c9e5: eb 77 jmp 10ca5e <_Thread_Resume+0x9e> <== NOT EXECUTED return; } current_state = the_thread->current_state; 10c9e7: 8b 41 10 mov 0x10(%ecx),%eax if ( current_state & STATES_SUSPENDED ) { 10c9ea: a8 02 test $0x2,%al 10c9ec: 74 6e je 10ca5c <_Thread_Resume+0x9c> <== NEVER TAKEN * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10c9ee: 83 e0 fd and $0xfffffffd,%eax current_state = 10c9f1: 89 41 10 mov %eax,0x10(%ecx) the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); if ( _States_Is_ready( current_state ) ) { 10c9f4: 85 c0 test %eax,%eax 10c9f6: 75 64 jne 10ca5c <_Thread_Resume+0x9c> <== NEVER TAKEN * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in 10c9f8: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx 10c9fe: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax 10ca05: 66 09 02 or %ax,(%edx) * @return TRUE if successfully able to determine the size, FALSE otherwise 10ca08: 66 a1 48 93 12 00 mov 0x129348,%ax 10ca0e: 0b 81 94 00 00 00 or 0x94(%ecx),%eax 10ca14: 66 a3 48 93 12 00 mov %ax,0x129348 _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10ca1a: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax 10ca20: 8d 50 04 lea 0x4(%eax),%edx 10ca23: 89 11 mov %edx,(%ecx) 10ca25: 8b 50 08 mov 0x8(%eax),%edx 10ca28: 89 48 08 mov %ecx,0x8(%eax) 10ca2b: 89 0a mov %ecx,(%edx) 10ca2d: 89 51 04 mov %edx,0x4(%ecx) _ISR_Flash( level ); 10ca30: 53 push %ebx 10ca31: 9d popf 10ca32: fa cli if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 10ca33: 8b 51 14 mov 0x14(%ecx),%edx 10ca36: a1 20 93 12 00 mov 0x129320,%eax 10ca3b: 3b 50 14 cmp 0x14(%eax),%edx 10ca3e: 73 1c jae 10ca5c <_Thread_Resume+0x9c> _Thread_Heir = the_thread; 10ca40: 89 0d 20 93 12 00 mov %ecx,0x129320 if ( _Thread_Executing->is_preemptible || 10ca46: a1 54 93 12 00 mov 0x129354,%eax 10ca4b: 80 78 76 00 cmpb $0x0,0x76(%eax) 10ca4f: 75 04 jne 10ca55 <_Thread_Resume+0x95> 10ca51: 85 d2 test %edx,%edx 10ca53: 75 07 jne 10ca5c <_Thread_Resume+0x9c> <== ALWAYS TAKEN the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10ca55: c6 05 64 93 12 00 01 movb $0x1,0x129364 } } } _ISR_Enable( level ); 10ca5c: 53 push %ebx 10ca5d: 9d popf } 10ca5e: 5b pop %ebx 10ca5f: c9 leave 10ca60: c3 ret =============================================================================== 0010b7b8 <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 10b7b8: 55 push %ebp 10b7b9: 89 e5 mov %esp,%ebp 10b7bb: 53 push %ebx 10b7bc: 83 ec 04 sub $0x4,%esp 10b7bf: a1 80 93 11 00 mov 0x119380,%eax 10b7c4: 8b 5d 0c mov 0xc(%ebp),%ebx 10b7c7: 39 c3 cmp %eax,%ebx 10b7c9: 73 02 jae 10b7cd <_Thread_Stack_Allocate+0x15> 10b7cb: 89 c3 mov %eax,%ebx * Call ONLY the CPU table stack allocate hook, _or_ the * the RTEMS workspace allocate. This is so the stack free * routine can call the correct deallocation routine. */ if ( _Configuration_Table->stack_allocate_hook ) { 10b7cd: a1 30 d8 11 00 mov 0x11d830,%eax 10b7d2: 8b 40 20 mov 0x20(%eax),%eax 10b7d5: 85 c0 test %eax,%eax 10b7d7: 74 08 je 10b7e1 <_Thread_Stack_Allocate+0x29><== ALWAYS TAKEN stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size ); 10b7d9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b7dc: 53 push %ebx <== NOT EXECUTED 10b7dd: ff d0 call *%eax <== NOT EXECUTED 10b7df: eb 09 jmp 10b7ea <_Thread_Stack_Allocate+0x32><== NOT EXECUTED * get and keep the stack adjust factor, the stack alignment, and * the context initialization sequence in sync. */ the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); 10b7e1: 83 ec 0c sub $0xc,%esp 10b7e4: 53 push %ebx 10b7e5: e8 3f 06 00 00 call 10be29 <_Workspace_Allocate> 10b7ea: 89 c1 mov %eax,%ecx 10b7ec: 83 c4 10 add $0x10,%esp } if ( !stack_addr ) 10b7ef: 31 c0 xor %eax,%eax 10b7f1: 85 c9 test %ecx,%ecx 10b7f3: 0f 95 c0 setne %al 10b7f6: f7 d8 neg %eax 10b7f8: 21 d8 and %ebx,%eax the_stack_size = 0; the_thread->Start.stack = stack_addr; 10b7fa: 8b 55 08 mov 0x8(%ebp),%edx 10b7fd: 89 8a d0 00 00 00 mov %ecx,0xd0(%edx) return the_stack_size; } 10b803: 8b 5d fc mov -0x4(%ebp),%ebx 10b806: c9 leave 10b807: c3 ret =============================================================================== 0010b808 <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 10b808: 55 push %ebp 10b809: 89 e5 mov %esp,%ebp 10b80b: 8b 55 08 mov 0x8(%ebp),%edx /* * If the API provided the stack space, then don't free it. */ if ( !the_thread->Start.core_allocated_stack ) 10b80e: 80 ba c0 00 00 00 00 cmpb $0x0,0xc0(%edx) 10b815: 74 21 je 10b838 <_Thread_Stack_Free+0x30><== NEVER TAKEN * Call ONLY the CPU table stack free hook, or the * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ if ( _Configuration_Table->stack_free_hook ) 10b817: a1 30 d8 11 00 mov 0x11d830,%eax 10b81c: 8b 48 24 mov 0x24(%eax),%ecx 10b81f: 85 c9 test %ecx,%ecx 10b821: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax 10b827: 74 06 je 10b82f <_Thread_Stack_Free+0x27><== ALWAYS TAKEN (*_Configuration_Table->stack_free_hook)( 10b829: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10b82c: c9 leave <== NOT EXECUTED * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ if ( _Configuration_Table->stack_free_hook ) (*_Configuration_Table->stack_free_hook)( 10b82d: ff e1 jmp *%ecx <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); 10b82f: 89 45 08 mov %eax,0x8(%ebp) } 10b832: c9 leave if ( _Configuration_Table->stack_free_hook ) (*_Configuration_Table->stack_free_hook)( the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); 10b833: e9 dc 05 00 00 jmp 10be14 <_Workspace_Free> } 10b838: c9 leave <== NOT EXECUTED 10b839: c3 ret <== NOT EXECUTED =============================================================================== 0010b8f0 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10b8f0: 55 push %ebp 10b8f1: 89 e5 mov %esp,%ebp 10b8f3: 53 push %ebx 10b8f4: 83 ec 04 sub $0x4,%esp Thread_Control *executing; executing = _Thread_Executing; 10b8f7: 8b 1d 58 d8 11 00 mov 0x11d858,%ebx /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10b8fd: 80 7b 76 00 cmpb $0x0,0x76(%ebx) 10b901: 74 4c je 10b94f <_Thread_Tickle_timeslice+0x5f> return; if ( !_States_Is_ready( executing->current_state ) ) 10b903: 83 7b 10 00 cmpl $0x0,0x10(%ebx) 10b907: 75 46 jne 10b94f <_Thread_Tickle_timeslice+0x5f><== NEVER TAKEN /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10b909: 8b 43 7c mov 0x7c(%ebx),%eax 10b90c: 83 f8 01 cmp $0x1,%eax 10b90f: 72 3e jb 10b94f <_Thread_Tickle_timeslice+0x5f> 10b911: 83 f8 02 cmp $0x2,%eax 10b914: 76 07 jbe 10b91d <_Thread_Tickle_timeslice+0x2d> 10b916: 83 f8 03 cmp $0x3,%eax 10b919: 75 34 jne 10b94f <_Thread_Tickle_timeslice+0x5f><== NEVER TAKEN 10b91b: eb 1a jmp 10b937 <_Thread_Tickle_timeslice+0x47> case THREAD_CPU_BUDGET_ALGORITHM_NONE: break; case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: if ( (int)(--executing->cpu_time_budget) <= 0 ) { 10b91d: 8b 43 78 mov 0x78(%ebx),%eax 10b920: 48 dec %eax 10b921: 89 43 78 mov %eax,0x78(%ebx) 10b924: 85 c0 test %eax,%eax 10b926: 7f 27 jg 10b94f <_Thread_Tickle_timeslice+0x5f> _Thread_Reset_timeslice(); 10b928: e8 6b 2b 00 00 call 10e498 <_Thread_Reset_timeslice> executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10b92d: a1 64 d7 11 00 mov 0x11d764,%eax 10b932: 89 43 78 mov %eax,0x78(%ebx) 10b935: eb 18 jmp 10b94f <_Thread_Tickle_timeslice+0x5f> } break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 10b937: 8b 43 78 mov 0x78(%ebx),%eax 10b93a: 48 dec %eax 10b93b: 89 43 78 mov %eax,0x78(%ebx) 10b93e: 85 c0 test %eax,%eax 10b940: 75 0d jne 10b94f <_Thread_Tickle_timeslice+0x5f> (*executing->budget_callout)( executing ); 10b942: 83 ec 0c sub $0xc,%esp 10b945: 53 push %ebx 10b946: ff 93 80 00 00 00 call *0x80(%ebx) 10b94c: 83 c4 10 add $0x10,%esp break; } } 10b94f: 8b 5d fc mov -0x4(%ebp),%ebx 10b952: c9 leave 10b953: c3 ret =============================================================================== 0010b954 <_Thread_Yield_processor>: * ready chain * select heir */ void _Thread_Yield_processor( void ) { 10b954: 55 push %ebp 10b955: 89 e5 mov %esp,%ebp 10b957: 56 push %esi 10b958: 53 push %ebx ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10b959: 8b 0d 58 d8 11 00 mov 0x11d858,%ecx ready = executing->ready; 10b95f: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx _ISR_Disable( level ); 10b965: 9c pushf 10b966: fa cli 10b967: 5e pop %esi if ( !_Chain_Has_only_one_node( ready ) ) { 10b968: 8b 03 mov (%ebx),%eax 10b96a: 3b 43 08 cmp 0x8(%ebx),%eax 10b96d: 74 2e je 10b99d <_Thread_Yield_processor+0x49> 10b96f: 8b 11 mov (%ecx),%edx 10b971: 8b 41 04 mov 0x4(%ecx),%eax 10b974: 89 42 04 mov %eax,0x4(%edx) 10b977: 89 10 mov %edx,(%eax) 10b979: 8d 43 04 lea 0x4(%ebx),%eax 10b97c: 89 01 mov %eax,(%ecx) 10b97e: 8b 43 08 mov 0x8(%ebx),%eax 10b981: 89 4b 08 mov %ecx,0x8(%ebx) 10b984: 89 08 mov %ecx,(%eax) 10b986: 89 41 04 mov %eax,0x4(%ecx) _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 10b989: 56 push %esi 10b98a: 9d popf 10b98b: fa cli if ( _Thread_Is_heir( executing ) ) 10b98c: 3b 0d 24 d8 11 00 cmp 0x11d824,%ecx 10b992: 75 11 jne 10b9a5 <_Thread_Yield_processor+0x51><== NEVER TAKEN _Thread_Heir = (Thread_Control *) ready->first; 10b994: 8b 03 mov (%ebx),%eax 10b996: a3 24 d8 11 00 mov %eax,0x11d824 10b99b: eb 08 jmp 10b9a5 <_Thread_Yield_processor+0x51> _Context_Switch_necessary = TRUE; } else if ( !_Thread_Is_heir( executing ) ) 10b99d: 3b 0d 24 d8 11 00 cmp 0x11d824,%ecx 10b9a3: 74 07 je 10b9ac <_Thread_Yield_processor+0x58><== ALWAYS TAKEN _Context_Switch_necessary = TRUE; 10b9a5: c6 05 68 d8 11 00 01 movb $0x1,0x11d868 _ISR_Enable( level ); 10b9ac: 56 push %esi 10b9ad: 9d popf } 10b9ae: 5b pop %ebx 10b9af: 5e pop %esi 10b9b0: c9 leave 10b9b1: c3 ret =============================================================================== 0010b368 <_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 ) { 10b368: 55 push %ebp 10b369: 89 e5 mov %esp,%ebp 10b36b: 57 push %edi 10b36c: 56 push %esi 10b36d: 53 push %ebx 10b36e: 83 ec 18 sub $0x18,%esp 10b371: 8b 4d 0c mov 0xc(%ebp),%ecx 10b374: 8d 41 3c lea 0x3c(%ecx),%eax 10b377: 89 41 38 mov %eax,0x38(%ecx) 10b37a: c7 41 3c 00 00 00 00 movl $0x0,0x3c(%ecx) 10b381: 8d 41 38 lea 0x38(%ecx),%eax 10b384: 89 41 40 mov %eax,0x40(%ecx) Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 10b387: 8b 79 14 mov 0x14(%ecx),%edi extern "C" { #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. 10b38a: 89 f8 mov %edi,%eax 10b38c: c1 e8 06 shr $0x6,%eax header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 10b38f: 6b c0 0c imul $0xc,%eax,%eax 10b392: 8b 5d 08 mov 0x8(%ebp),%ebx 10b395: 01 c3 add %eax,%ebx block_state = the_thread_queue->state; 10b397: 8b 55 08 mov 0x8(%ebp),%edx 10b39a: 8b 52 38 mov 0x38(%edx),%edx 10b39d: 89 55 e8 mov %edx,-0x18(%ebp) if ( _Thread_queue_Is_reverse_search( priority ) ) 10b3a0: f7 c7 20 00 00 00 test $0x20,%edi 10b3a6: 75 77 jne 10b41f <_Thread_queue_Enqueue_priority+0xb7> * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10b3a8: 83 c3 04 add $0x4,%ebx 10b3ab: 89 5d ec mov %ebx,-0x14(%ebp) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; 10b3ae: 89 45 dc mov %eax,-0x24(%ebp) if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 10b3b1: 9c pushf 10b3b2: fa cli 10b3b3: 5e pop %esi search_thread = (Thread_Control *) header->first; 10b3b4: 8b 45 dc mov -0x24(%ebp),%eax 10b3b7: 8b 5d 08 mov 0x8(%ebp),%ebx 10b3ba: 8b 14 18 mov (%eax,%ebx,1),%edx 10b3bd: c7 45 e0 ff ff ff ff movl $0xffffffff,-0x20(%ebp) 10b3c4: eb 1b jmp 10b3e1 <_Thread_queue_Enqueue_priority+0x79> while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { search_priority = search_thread->current_priority; 10b3c6: 8b 5a 14 mov 0x14(%edx),%ebx 10b3c9: 89 5d e0 mov %ebx,-0x20(%ebp) if ( priority <= search_priority ) 10b3cc: 39 df cmp %ebx,%edi 10b3ce: 76 16 jbe 10b3e6 <_Thread_queue_Enqueue_priority+0x7e> break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10b3d0: 56 push %esi 10b3d1: 9d popf 10b3d2: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10b3d3: 8b 45 e8 mov -0x18(%ebp),%eax 10b3d6: 85 42 10 test %eax,0x10(%edx) 10b3d9: 75 04 jne 10b3df <_Thread_queue_Enqueue_priority+0x77><== ALWAYS TAKEN _ISR_Enable( level ); 10b3db: 56 push %esi <== NOT EXECUTED 10b3dc: 9d popf <== NOT EXECUTED 10b3dd: eb d2 jmp 10b3b1 <_Thread_queue_Enqueue_priority+0x49><== NOT EXECUTED goto restart_forward_search; } search_thread = 10b3df: 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 ) ) { 10b3e1: 3b 55 ec cmp -0x14(%ebp),%edx 10b3e4: 75 e0 jne 10b3c6 <_Thread_queue_Enqueue_priority+0x5e> 10b3e6: 89 55 f0 mov %edx,-0x10(%ebp) 10b3e9: 89 f3 mov %esi,%ebx } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10b3eb: 8b 45 08 mov 0x8(%ebp),%eax 10b3ee: 83 78 30 01 cmpl $0x1,0x30(%eax) 10b3f2: 0f 85 b4 00 00 00 jne 10b4ac <_Thread_queue_Enqueue_priority+0x144><== NEVER TAKEN THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10b3f8: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) if ( priority == search_priority ) 10b3ff: 3b 7d e0 cmp -0x20(%ebp),%edi 10b402: 0f 84 87 00 00 00 je 10b48f <_Thread_queue_Enqueue_priority+0x127> goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10b408: 8b 42 04 mov 0x4(%edx),%eax the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10b40b: 89 11 mov %edx,(%ecx) the_node->previous = previous_node; 10b40d: 89 41 04 mov %eax,0x4(%ecx) previous_node->next = the_node; 10b410: 89 08 mov %ecx,(%eax) search_node->previous = the_node; 10b412: 89 4a 04 mov %ecx,0x4(%edx) the_thread->Wait.queue = the_thread_queue; 10b415: 8b 55 08 mov 0x8(%ebp),%edx 10b418: 89 51 44 mov %edx,0x44(%ecx) _ISR_Enable( level ); 10b41b: 56 push %esi 10b41c: 9d popf 10b41d: eb 69 jmp 10b488 <_Thread_queue_Enqueue_priority+0x120> restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 10b41f: 8d 43 08 lea 0x8(%ebx),%eax 10b422: 89 45 e4 mov %eax,-0x1c(%ebp) the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 10b425: 0f b6 05 84 93 11 00 movzbl 0x119384,%eax 10b42c: 40 inc %eax 10b42d: 89 45 e0 mov %eax,-0x20(%ebp) _ISR_Disable( level ); 10b430: 9c pushf 10b431: fa cli 10b432: 5e pop %esi search_thread = (Thread_Control *) header->last; 10b433: 8b 45 e4 mov -0x1c(%ebp),%eax 10b436: 8b 10 mov (%eax),%edx 10b438: eb 1c jmp 10b456 <_Thread_queue_Enqueue_priority+0xee> while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { search_priority = search_thread->current_priority; 10b43a: 8b 42 14 mov 0x14(%edx),%eax 10b43d: 89 45 e0 mov %eax,-0x20(%ebp) if ( priority >= search_priority ) 10b440: 39 c7 cmp %eax,%edi 10b442: 73 16 jae 10b45a <_Thread_queue_Enqueue_priority+0xf2> break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 10b444: 56 push %esi 10b445: 9d popf 10b446: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10b447: 8b 45 e8 mov -0x18(%ebp),%eax 10b44a: 85 42 10 test %eax,0x10(%edx) 10b44d: 75 04 jne 10b453 <_Thread_queue_Enqueue_priority+0xeb><== ALWAYS TAKEN _ISR_Enable( level ); 10b44f: 56 push %esi <== NOT EXECUTED 10b450: 9d popf <== NOT EXECUTED 10b451: eb d2 jmp 10b425 <_Thread_queue_Enqueue_priority+0xbd><== NOT EXECUTED goto restart_reverse_search; } search_thread = (Thread_Control *) 10b453: 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 ) ) { 10b456: 39 da cmp %ebx,%edx 10b458: 75 e0 jne 10b43a <_Thread_queue_Enqueue_priority+0xd2> 10b45a: 89 55 f0 mov %edx,-0x10(%ebp) 10b45d: 89 f3 mov %esi,%ebx } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10b45f: 8b 45 08 mov 0x8(%ebp),%eax 10b462: 83 78 30 01 cmpl $0x1,0x30(%eax) 10b466: 75 44 jne 10b4ac <_Thread_queue_Enqueue_priority+0x144><== NEVER TAKEN THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10b468: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) if ( priority == search_priority ) 10b46f: 3b 7d e0 cmp -0x20(%ebp),%edi 10b472: 74 1b je 10b48f <_Thread_queue_Enqueue_priority+0x127> goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10b474: 8b 02 mov (%edx),%eax the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10b476: 89 01 mov %eax,(%ecx) the_node->previous = search_node; 10b478: 89 51 04 mov %edx,0x4(%ecx) search_node->next = the_node; 10b47b: 89 0a mov %ecx,(%edx) next_node->previous = the_node; 10b47d: 89 48 04 mov %ecx,0x4(%eax) the_thread->Wait.queue = the_thread_queue; 10b480: 8b 55 08 mov 0x8(%ebp),%edx 10b483: 89 51 44 mov %edx,0x44(%ecx) _ISR_Enable( level ); 10b486: 56 push %esi 10b487: 9d popf 10b488: b8 01 00 00 00 mov $0x1,%eax 10b48d: eb 28 jmp 10b4b7 <_Thread_queue_Enqueue_priority+0x14f> 10b48f: 8b 45 f0 mov -0x10(%ebp),%eax 10b492: 83 c0 3c add $0x3c,%eax return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 10b495: 8b 50 04 mov 0x4(%eax),%edx the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10b498: 89 01 mov %eax,(%ecx) the_node->previous = previous_node; 10b49a: 89 51 04 mov %edx,0x4(%ecx) previous_node->next = the_node; 10b49d: 89 0a mov %ecx,(%edx) search_node->previous = the_node; 10b49f: 89 48 04 mov %ecx,0x4(%eax) the_thread->Wait.queue = the_thread_queue; 10b4a2: 8b 45 08 mov 0x8(%ebp),%eax 10b4a5: 89 41 44 mov %eax,0x44(%ecx) _ISR_Enable( level ); 10b4a8: 53 push %ebx 10b4a9: 9d popf 10b4aa: eb dc jmp 10b488 <_Thread_queue_Enqueue_priority+0x120> * 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; 10b4ac: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b4af: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return the_thread_queue->sync_state; 10b4b1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b4b4: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED } 10b4b7: 83 c4 18 add $0x18,%esp 10b4ba: 5b pop %ebx 10b4bb: 5e pop %esi 10b4bc: 5f pop %edi 10b4bd: c9 leave 10b4be: c3 ret =============================================================================== 0010f040 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10f040: 55 push %ebp 10f041: 89 e5 mov %esp,%ebp 10f043: 53 push %ebx 10f044: 83 ec 04 sub $0x4,%esp 10f047: 8b 5d 0c mov 0xc(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 10f04a: 9c pushf 10f04b: fa cli 10f04c: 59 pop %ecx if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10f04d: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) 10f054: 75 07 jne 10f05d <_Thread_queue_Extract_fifo+0x1d><== ALWAYS TAKEN _ISR_Enable( level ); 10f056: 51 push %ecx <== NOT EXECUTED 10f057: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10f058: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f05b: c9 leave <== NOT EXECUTED 10f05c: c3 ret <== NOT EXECUTED 10f05d: 8b 13 mov (%ebx),%edx 10f05f: 8b 43 04 mov 0x4(%ebx),%eax 10f062: 89 42 04 mov %eax,0x4(%edx) 10f065: 89 10 mov %edx,(%eax) return; } _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; 10f067: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10f06e: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 10f072: 74 04 je 10f078 <_Thread_queue_Extract_fifo+0x38> _ISR_Enable( level ); 10f074: 51 push %ecx 10f075: 9d popf 10f076: eb 18 jmp 10f090 <_Thread_queue_Extract_fifo+0x50> * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 10f078: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10f07f: 51 push %ecx 10f080: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 10f081: 83 ec 0c sub $0xc,%esp 10f084: 8d 43 48 lea 0x48(%ebx),%eax 10f087: 50 push %eax 10f088: e8 b3 cc ff ff call 10bd40 <_Watchdog_Remove> 10f08d: 83 c4 10 add $0x10,%esp void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10f090: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 10f097: 89 5d 08 mov %ebx,0x8(%ebp) #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10f09a: 8b 5d fc mov -0x4(%ebp),%ebx 10f09d: c9 leave 10f09e: e9 69 ba ff ff jmp 10ab0c <_Thread_Clear_state> =============================================================================== 0010e2f0 <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, bool requeuing ) { 10e2f0: 55 push %ebp 10e2f1: 89 e5 mov %esp,%ebp 10e2f3: 57 push %edi 10e2f4: 56 push %esi 10e2f5: 53 push %ebx 10e2f6: 83 ec 0c sub $0xc,%esp 10e2f9: 8b 5d 0c mov 0xc(%ebp),%ebx 10e2fc: 8a 45 10 mov 0x10(%ebp),%al 10e2ff: 88 45 eb mov %al,-0x15(%ebp) Chain_Node *new_first_node; Chain_Node *new_second_node; Chain_Node *last_node; the_node = (Chain_Node *) the_thread; _ISR_Disable( level ); 10e302: 9c pushf 10e303: fa cli 10e304: 8f 45 ec popl -0x14(%ebp) if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10e307: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) 10e30e: 75 09 jne 10e319 <_Thread_queue_Extract_priority_helper+0x29><== ALWAYS TAKEN _ISR_Enable( level ); 10e310: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10e313: 9d popf <== NOT EXECUTED 10e314: e9 8f 00 00 00 jmp 10e3a8 <_Thread_queue_Extract_priority_helper+0xb8><== NOT EXECUTED /* * The thread was actually waiting on a thread queue so let's remove it. */ next_node = the_node->next; 10e319: 8b 33 mov (%ebx),%esi previous_node = the_node->previous; 10e31b: 8b 4b 04 mov 0x4(%ebx),%ecx * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10e31e: 8b 53 38 mov 0x38(%ebx),%edx if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10e321: 8d 43 3c lea 0x3c(%ebx),%eax 10e324: 39 c2 cmp %eax,%edx 10e326: 74 33 je 10e35b <_Thread_queue_Extract_priority_helper+0x6b> new_first_node = the_thread->Wait.Block2n.first; new_first_thread = (Thread_Control *) new_first_node; last_node = the_thread->Wait.Block2n.last; 10e328: 8b 43 40 mov 0x40(%ebx),%eax 10e32b: 89 45 f0 mov %eax,-0x10(%ebp) new_second_node = new_first_node->next; 10e32e: 8b 3a mov (%edx),%edi previous_node->next = new_first_node; 10e330: 89 11 mov %edx,(%ecx) next_node->previous = new_first_node; 10e332: 89 56 04 mov %edx,0x4(%esi) new_first_node->next = next_node; 10e335: 89 32 mov %esi,(%edx) new_first_node->previous = previous_node; 10e337: 89 4a 04 mov %ecx,0x4(%edx) if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10e33a: 8b 43 38 mov 0x38(%ebx),%eax 10e33d: 3b 43 40 cmp 0x40(%ebx),%eax 10e340: 74 1e je 10e360 <_Thread_queue_Extract_priority_helper+0x70> /* > two threads on 2-n */ new_second_node->previous = 10e342: 8d 42 38 lea 0x38(%edx),%eax 10e345: 89 47 04 mov %eax,0x4(%edi) _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 10e348: 89 7a 38 mov %edi,0x38(%edx) new_first_thread->Wait.Block2n.last = last_node; 10e34b: 8b 45 f0 mov -0x10(%ebp),%eax 10e34e: 89 42 40 mov %eax,0x40(%edx) last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10e351: 8d 42 3c lea 0x3c(%edx),%eax 10e354: 8b 55 f0 mov -0x10(%ebp),%edx 10e357: 89 02 mov %eax,(%edx) 10e359: eb 05 jmp 10e360 <_Thread_queue_Extract_priority_helper+0x70> } } else { previous_node->next = next_node; 10e35b: 89 31 mov %esi,(%ecx) next_node->previous = previous_node; 10e35d: 89 4e 04 mov %ecx,0x4(%esi) /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 10e360: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) 10e364: 74 06 je 10e36c <_Thread_queue_Extract_priority_helper+0x7c> _ISR_Enable( level ); 10e366: ff 75 ec pushl -0x14(%ebp) 10e369: 9d popf 10e36a: eb 3c jmp 10e3a8 <_Thread_queue_Extract_priority_helper+0xb8> return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10e36c: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 10e370: 74 06 je 10e378 <_Thread_queue_Extract_priority_helper+0x88> _ISR_Enable( level ); 10e372: ff 75 ec pushl -0x14(%ebp) 10e375: 9d popf 10e376: eb 1a jmp 10e392 <_Thread_queue_Extract_priority_helper+0xa2> * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 10e378: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10e37f: ff 75 ec pushl -0x14(%ebp) 10e382: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 10e383: 83 ec 0c sub $0xc,%esp 10e386: 8d 43 48 lea 0x48(%ebx),%eax 10e389: 50 push %eax 10e38a: e8 b1 d9 ff ff call 10bd40 <_Watchdog_Remove> 10e38f: 83 c4 10 add $0x10,%esp void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10e392: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 10e399: 89 5d 08 mov %ebx,0x8(%ebp) #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10e39c: 8d 65 f4 lea -0xc(%ebp),%esp 10e39f: 5b pop %ebx 10e3a0: 5e pop %esi 10e3a1: 5f pop %edi 10e3a2: c9 leave 10e3a3: e9 64 c7 ff ff jmp 10ab0c <_Thread_Clear_state> 10e3a8: 8d 65 f4 lea -0xc(%ebp),%esp 10e3ab: 5b pop %ebx 10e3ac: 5e pop %esi 10e3ad: 5f pop %edi 10e3ae: c9 leave 10e3af: c3 ret =============================================================================== 0010e3b0 <_Thread_queue_Process_timeout>: #include void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { 10e3b0: 55 push %ebp 10e3b1: 89 e5 mov %esp,%ebp 10e3b3: 83 ec 08 sub $0x8,%esp 10e3b6: 8b 4d 08 mov 0x8(%ebp),%ecx Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 10e3b9: 8b 51 44 mov 0x44(%ecx),%edx * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED && 10e3bc: 8b 42 30 mov 0x30(%edx),%eax 10e3bf: 85 c0 test %eax,%eax 10e3c1: 74 1c je 10e3df <_Thread_queue_Process_timeout+0x2f> 10e3c3: 3b 0d 58 d8 11 00 cmp 0x11d858,%ecx 10e3c9: 75 14 jne 10e3df <_Thread_queue_Process_timeout+0x2f><== NEVER TAKEN _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { 10e3cb: 83 f8 03 cmp $0x3,%eax 10e3ce: 74 23 je 10e3f3 <_Thread_queue_Process_timeout+0x43><== NEVER TAKEN the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10e3d0: 8b 42 3c mov 0x3c(%edx),%eax 10e3d3: 89 41 34 mov %eax,0x34(%ecx) the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10e3d6: c7 42 30 02 00 00 00 movl $0x2,0x30(%edx) 10e3dd: eb 14 jmp 10e3f3 <_Thread_queue_Process_timeout+0x43> } } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10e3df: 8b 42 3c mov 0x3c(%edx),%eax 10e3e2: 89 41 34 mov %eax,0x34(%ecx) _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10e3e5: 50 push %eax 10e3e6: 50 push %eax 10e3e7: 51 push %ecx 10e3e8: ff 71 44 pushl 0x44(%ecx) 10e3eb: e8 d0 fe ff ff call 10e2c0 <_Thread_queue_Extract> 10e3f0: 83 c4 10 add $0x10,%esp } } 10e3f3: c9 leave 10e3f4: c3 ret =============================================================================== 0010b58c <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10b58c: 55 push %ebp 10b58d: 89 e5 mov %esp,%ebp 10b58f: 57 push %edi 10b590: 56 push %esi 10b591: 53 push %ebx 10b592: 83 ec 1c sub $0x1c,%esp 10b595: 8b 5d 08 mov 0x8(%ebp),%ebx 10b598: 8b 75 0c mov 0xc(%ebp),%esi /* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue ) 10b59b: 85 db test %ebx,%ebx 10b59d: 74 36 je 10b5d5 <_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 ) { 10b59f: 83 7b 34 01 cmpl $0x1,0x34(%ebx) 10b5a3: 75 30 jne 10b5d5 <_Thread_queue_Requeue+0x49><== NEVER TAKEN Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10b5a5: 9c pushf 10b5a6: fa cli 10b5a7: 5f pop %edi if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10b5a8: f7 46 10 e0 be 03 00 testl $0x3bee0,0x10(%esi) 10b5af: 74 22 je 10b5d3 <_Thread_queue_Requeue+0x47><== NEVER TAKEN { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10b5b1: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); 10b5b8: 50 push %eax 10b5b9: 6a 01 push $0x1 10b5bb: 56 push %esi 10b5bc: 53 push %ebx 10b5bd: e8 2e 2d 00 00 call 10e2f0 <_Thread_queue_Extract_priority_helper> (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10b5c2: 83 c4 0c add $0xc,%esp 10b5c5: 8d 45 f0 lea -0x10(%ebp),%eax 10b5c8: 50 push %eax 10b5c9: 56 push %esi 10b5ca: 53 push %ebx 10b5cb: e8 98 fd ff ff call 10b368 <_Thread_queue_Enqueue_priority> 10b5d0: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 10b5d3: 57 push %edi 10b5d4: 9d popf } } 10b5d5: 8d 65 f4 lea -0xc(%ebp),%esp 10b5d8: 5b pop %ebx 10b5d9: 5e pop %esi 10b5da: 5f pop %edi 10b5db: c9 leave 10b5dc: c3 ret =============================================================================== 0010b5e0 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 10b5e0: 55 push %ebp 10b5e1: 89 e5 mov %esp,%ebp 10b5e3: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10b5e6: 8d 45 fc lea -0x4(%ebp),%eax 10b5e9: 50 push %eax 10b5ea: ff 75 08 pushl 0x8(%ebp) 10b5ed: e8 ba f8 ff ff call 10aeac <_Thread_Get> switch ( location ) { 10b5f2: 83 c4 10 add $0x10,%esp 10b5f5: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) 10b5f9: 75 17 jne 10b612 <_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 ); 10b5fb: 83 ec 0c sub $0xc,%esp 10b5fe: 50 push %eax 10b5ff: e8 ac 2d 00 00 call 10e3b0 <_Thread_queue_Process_timeout> 10b604: a1 98 d7 11 00 mov 0x11d798,%eax 10b609: 48 dec %eax 10b60a: a3 98 d7 11 00 mov %eax,0x11d798 10b60f: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10b612: c9 leave 10b613: c3 ret =============================================================================== 00113240 <_Timer_Server_body>: * @param[in] ignored is the the task argument that is ignored */ Thread _Timer_Server_body( uint32_t ignored ) { 113240: 55 push %ebp 113241: 89 e5 mov %esp,%ebp 113243: 57 push %edi 113244: 56 push %esi 113245: 53 push %ebx 113246: 83 ec 1c sub $0x1c,%esp * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 113249: 8d 75 e8 lea -0x18(%ebp),%esi 11324c: 8d 45 ec lea -0x14(%ebp),%eax 11324f: 89 45 e0 mov %eax,-0x20(%ebp) 113252: 89 45 e8 mov %eax,-0x18(%ebp) 113255: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) 11325c: 89 75 f0 mov %esi,-0x10(%ebp) /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 11325f: a1 88 42 13 00 mov 0x134288,%eax 113264: a3 bc 40 13 00 mov %eax,0x1340bc _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 113269: a1 c8 41 13 00 mov 0x1341c8,%eax 11326e: a3 b8 40 13 00 mov %eax,0x1340b8 /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 113273: a1 38 41 13 00 mov 0x134138,%eax 113278: 40 inc %eax 113279: a3 38 41 13 00 mov %eax,0x134138 /* * Insert the timers that were inserted before we got to run. * This should be done with dispatching disabled. */ _Thread_Disable_dispatch(); _Timer_Server_process_insertions(); 11327e: e8 6d ff ff ff call 1131f0 <_Timer_Server_process_insertions> _Thread_Enable_dispatch(); 113283: e8 30 25 00 00 call 1157b8 <_Thread_Enable_dispatch> ticks = snapshot - _Timer_Server_ticks_last_time; else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; _Timer_Server_ticks_last_time = snapshot; _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire ); 113288: 89 f7 mov %esi,%edi 11328a: a1 38 41 13 00 mov 0x134138,%eax 11328f: 40 inc %eax 113290: a3 38 41 13 00 mov %eax,0x134138 /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 113295: 51 push %ecx 113296: 51 push %ecx 113297: 6a 08 push $0x8 113299: ff 35 bc 4a 13 00 pushl 0x134abc 11329f: e8 30 2e 00 00 call 1160d4 <_Thread_Set_state> * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 1132a4: 8b 15 ac 40 13 00 mov 0x1340ac,%edx _Timer_Server_reset_ticks_timer(); 1132aa: 83 c4 10 add $0x10,%esp 1132ad: 81 fa b0 40 13 00 cmp $0x1340b0,%edx 1132b3: 74 1e je 1132d3 <_Timer_Server_body+0x93> 1132b5: a1 bc 4a 13 00 mov 0x134abc,%eax Heap_Control *the_heap, 1132ba: 8b 52 10 mov 0x10(%edx),%edx 1132bd: 89 50 54 mov %edx,0x54(%eax) void *starting_address, size_t *size 1132c0: 52 push %edx 1132c1: 52 push %edx 1132c2: 83 c0 48 add $0x48,%eax 1132c5: 50 push %eax 1132c6: 68 18 42 13 00 push $0x134218 1132cb: e8 04 36 00 00 call 1168d4 <_Watchdog_Insert> 1132d0: 83 c4 10 add $0x10,%esp * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 1132d3: a1 c0 40 13 00 mov 0x1340c0,%eax _Timer_Server_reset_seconds_timer(); 1132d8: 3d c4 40 13 00 cmp $0x1340c4,%eax 1132dd: 74 1c je 1132fb <_Timer_Server_body+0xbb> * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, 1132df: 8b 40 10 mov 0x10(%eax),%eax 1132e2: a3 e4 40 13 00 mov %eax,0x1340e4 size_t size ); 1132e7: 50 push %eax 1132e8: 50 push %eax 1132e9: 68 d8 40 13 00 push $0x1340d8 1132ee: 68 0c 42 13 00 push $0x13420c 1132f3: e8 dc 35 00 00 call 1168d4 <_Watchdog_Insert> 1132f8: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 1132fb: e8 b8 24 00 00 call 1157b8 <_Thread_Enable_dispatch> /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 113300: a1 38 41 13 00 mov 0x134138,%eax 113305: 40 inc %eax 113306: a3 38 41 13 00 mov %eax,0x134138 /* * At this point, at least one of the timers this task relies * upon has fired. Stop them both while we process any outstanding * timers. Before we block, we will restart them. */ _Timer_Server_stop_ticks_timer(); 11330b: 83 ec 0c sub $0xc,%esp 11330e: a1 bc 4a 13 00 mov 0x134abc,%eax 113313: 83 c0 48 add $0x48,%eax 113316: 50 push %eax 113317: e8 d0 36 00 00 call 1169ec <_Watchdog_Remove> _Timer_Server_stop_seconds_timer(); 11331c: c7 04 24 d8 40 13 00 movl $0x1340d8,(%esp) 113323: e8 c4 36 00 00 call 1169ec <_Watchdog_Remove> ) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 113328: 8b 15 88 42 13 00 mov 0x134288,%edx if ( snapshot >= _Timer_Server_ticks_last_time ) 11332e: a1 bc 40 13 00 mov 0x1340bc,%eax 113333: 83 c4 10 add $0x10,%esp 113336: 39 c2 cmp %eax,%edx 113338: 72 08 jb 113342 <_Timer_Server_body+0x102><== NEVER TAKEN ticks = snapshot - _Timer_Server_ticks_last_time; 11333a: 89 d1 mov %edx,%ecx 11333c: 29 c1 sub %eax,%ecx 11333e: 89 c8 mov %ecx,%eax 113340: eb 04 jmp 113346 <_Timer_Server_body+0x106> else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; 113342: f7 d0 not %eax <== NOT EXECUTED 113344: 01 d0 add %edx,%eax <== NOT EXECUTED _Timer_Server_ticks_last_time = snapshot; 113346: 89 15 bc 40 13 00 mov %edx,0x1340bc _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire ); 11334c: 53 push %ebx 11334d: 57 push %edi 11334e: 50 push %eax 11334f: 68 ac 40 13 00 push $0x1340ac 113354: e8 eb 34 00 00 call 116844 <_Watchdog_Adjust_to_chain> /* * 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 _Timer_Seconds_chain to indicate this. */ snapshot = _TOD_Seconds_since_epoch; 113359: 8b 1d c8 41 13 00 mov 0x1341c8,%ebx if ( snapshot > _Timer_Server_seconds_last_time ) { 11335f: a1 b8 40 13 00 mov 0x1340b8,%eax 113364: 83 c4 10 add $0x10,%esp 113367: 39 c3 cmp %eax,%ebx 113369: 76 13 jbe 11337e <_Timer_Server_body+0x13e> /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ ticks = snapshot - _Timer_Server_seconds_last_time; _Watchdog_Adjust_to_chain( &_Timer_Seconds_chain, ticks, to_fire ); 11336b: 51 push %ecx 11336c: 57 push %edi 11336d: 89 da mov %ebx,%edx 11336f: 29 c2 sub %eax,%edx 113371: 52 push %edx 113372: 68 c0 40 13 00 push $0x1340c0 113377: e8 c8 34 00 00 call 116844 <_Watchdog_Adjust_to_chain> 11337c: eb 12 jmp 113390 <_Timer_Server_body+0x150> } else if ( snapshot < _Timer_Server_seconds_last_time ) { 11337e: 73 13 jae 113393 <_Timer_Server_body+0x153> /* * The current TOD is before the last TOD which indicates that * TOD has been set backwards. */ ticks = _Timer_Server_seconds_last_time - snapshot; _Watchdog_Adjust( &_Timer_Seconds_chain, WATCHDOG_BACKWARD, ticks ); 113380: 52 push %edx 113381: 29 d8 sub %ebx,%eax 113383: 50 push %eax 113384: 6a 01 push $0x1 113386: 68 c0 40 13 00 push $0x1340c0 11338b: e8 48 34 00 00 call 1167d8 <_Watchdog_Adjust> 113390: 83 c4 10 add $0x10,%esp } _Timer_Server_seconds_last_time = snapshot; 113393: 89 1d b8 40 13 00 mov %ebx,0x1340b8 _Timer_Server_process_seconds_chain( &to_fire ); /* * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); 113399: e8 52 fe ff ff call 1131f0 <_Timer_Server_process_insertions> /* * Enable dispatching to process the set that are ready "to fire." */ _Thread_Enable_dispatch(); 11339e: e8 15 24 00 00 call 1157b8 <_Thread_Enable_dispatch> */ while (1) { Watchdog_Control *watch; ISR_Level level; _ISR_Disable( level ); 1133a3: 9c pushf 1133a4: fa cli 1133a5: 59 pop %ecx * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 1133a6: 8b 55 e8 mov -0x18(%ebp),%edx 1133a9: 3b 55 e0 cmp -0x20(%ebp),%edx 1133ac: 74 0c je 1133ba <_Timer_Server_body+0x17a> 1133ae: 8b 02 mov (%edx),%eax 1133b0: 89 45 e8 mov %eax,-0x18(%ebp) 1133b3: 89 70 04 mov %esi,0x4(%eax) watch = (Watchdog_Control *) _Chain_Get_unprotected( &to_fire ); if ( watch == NULL ) { 1133b6: 85 d2 test %edx,%edx 1133b8: 75 07 jne 1133c1 <_Timer_Server_body+0x181><== ALWAYS TAKEN _ISR_Enable( level ); 1133ba: 51 push %ecx 1133bb: 9d popf 1133bc: e9 c9 fe ff ff jmp 11328a <_Timer_Server_body+0x4a> break; } watch->state = WATCHDOG_INACTIVE; 1133c1: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) _ISR_Enable( level ); 1133c8: 51 push %ecx 1133c9: 9d popf (*watch->routine)( watch->id, watch->user_data ); 1133ca: 53 push %ebx 1133cb: 53 push %ebx 1133cc: ff 72 24 pushl 0x24(%edx) 1133cf: ff 72 20 pushl 0x20(%edx) 1133d2: ff 52 1c call *0x1c(%edx) 1133d5: 83 c4 10 add $0x10,%esp 1133d8: eb c9 jmp 1133a3 <_Timer_Server_body+0x163> =============================================================================== 001131f0 <_Timer_Server_process_insertions>: * onto one of the Timer Server chains. * * @note It is only to be called from the Timer Server task. */ static void _Timer_Server_process_insertions(void) { 1131f0: 55 push %ebp 1131f1: 89 e5 mov %esp,%ebp 1131f3: 83 ec 08 sub $0x8,%esp Timer_Control *the_timer; while ( 1 ) { the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted ); 1131f6: 83 ec 0c sub $0xc,%esp 1131f9: 68 cc 40 13 00 push $0x1340cc 1131fe: e8 a5 08 00 00 call 113aa8 <_Chain_Get> if ( the_timer == NULL ) 113203: 83 c4 10 add $0x10,%esp 113206: 85 c0 test %eax,%eax 113208: 74 34 je 11323e <_Timer_Server_process_insertions+0x4e> break; if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { 11320a: 8b 50 38 mov 0x38(%eax),%edx 11320d: 83 fa 01 cmp $0x1,%edx 113210: 75 0d jne 11321f <_Timer_Server_process_insertions+0x2f> _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 113212: 51 push %ecx 113213: 51 push %ecx 113214: 83 c0 10 add $0x10,%eax 113217: 50 push %eax 113218: 68 ac 40 13 00 push $0x1340ac 11321d: eb 10 jmp 11322f <_Timer_Server_process_insertions+0x3f> } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 11321f: 83 fa 03 cmp $0x3,%edx 113222: 75 13 jne 113237 <_Timer_Server_process_insertions+0x47><== NEVER TAKEN _Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker ); 113224: 52 push %edx 113225: 52 push %edx 113226: 83 c0 10 add $0x10,%eax 113229: 50 push %eax 11322a: 68 c0 40 13 00 push $0x1340c0 11322f: e8 a0 36 00 00 call 1168d4 <_Watchdog_Insert> 113234: 83 c4 10 add $0x10,%esp } /* * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); 113237: e8 b4 ff ff ff call 1131f0 <_Timer_Server_process_insertions> 11323c: eb b8 jmp 1131f6 <_Timer_Server_process_insertions+0x6> } } 11323e: c9 leave 11323f: c3 ret =============================================================================== 0010cf04 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 10cf04: 55 push %ebp 10cf05: 89 e5 mov %esp,%ebp 10cf07: 57 push %edi 10cf08: 56 push %esi 10cf09: 53 push %ebx 10cf0a: 83 ec 1c sub $0x1c,%esp 10cf0d: 8b 45 08 mov 0x8(%ebp),%eax /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10cf10: 8b 18 mov (%eax),%ebx left += lhs->tv_nsec; 10cf12: 8b 40 04 mov 0x4(%eax),%eax 10cf15: 89 45 e4 mov %eax,-0x1c(%ebp) right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10cf18: b8 00 ca 9a 3b mov $0x3b9aca00,%eax 10cf1d: 8b 4d 0c mov 0xc(%ebp),%ecx 10cf20: f7 29 imull (%ecx) 10cf22: 89 c6 mov %eax,%esi 10cf24: 89 d7 mov %edx,%edi right += rhs->tv_nsec; 10cf26: 8b 41 04 mov 0x4(%ecx),%eax 10cf29: 99 cltd 10cf2a: 01 c6 add %eax,%esi 10cf2c: 11 d7 adc %edx,%edi if ( right == 0 ) { 10cf2e: 89 f8 mov %edi,%eax 10cf30: 09 f0 or %esi,%eax 10cf32: 75 14 jne 10cf48 <_Timespec_Divide+0x44> <== ALWAYS TAKEN *ival_percentage = 0; 10cf34: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10cf37: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED *fval_percentage = 0; 10cf3d: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10cf40: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED 10cf46: eb 70 jmp 10cfb8 <_Timespec_Divide+0xb4> <== NOT EXECUTED /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10cf48: b8 00 ca 9a 3b mov $0x3b9aca00,%eax 10cf4d: f7 eb imul %ebx 10cf4f: 89 45 e8 mov %eax,-0x18(%ebp) 10cf52: 89 55 ec mov %edx,-0x14(%ebp) * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 10cf55: 8b 45 e4 mov -0x1c(%ebp),%eax 10cf58: 99 cltd 10cf59: 01 45 e8 add %eax,-0x18(%ebp) 10cf5c: 11 55 ec adc %edx,-0x14(%ebp) 10cf5f: 69 5d ec a0 86 01 00 imul $0x186a0,-0x14(%ebp),%ebx 10cf66: b9 a0 86 01 00 mov $0x186a0,%ecx 10cf6b: 8b 45 e8 mov -0x18(%ebp),%eax 10cf6e: f7 e1 mul %ecx 10cf70: 89 45 d8 mov %eax,-0x28(%ebp) 10cf73: 01 da add %ebx,%edx 10cf75: 89 55 dc mov %edx,-0x24(%ebp) 10cf78: 57 push %edi 10cf79: 56 push %esi 10cf7a: ff 75 dc pushl -0x24(%ebp) 10cf7d: ff 75 d8 pushl -0x28(%ebp) 10cf80: e8 33 ae 00 00 call 117db8 <__udivdi3> 10cf85: 83 c4 10 add $0x10,%esp 10cf88: 89 c3 mov %eax,%ebx 10cf8a: 89 d6 mov %edx,%esi *ival_percentage = answer / 1000; 10cf8c: 6a 00 push $0x0 10cf8e: 68 e8 03 00 00 push $0x3e8 10cf93: 52 push %edx 10cf94: 50 push %eax 10cf95: e8 1e ae 00 00 call 117db8 <__udivdi3> 10cf9a: 83 c4 10 add $0x10,%esp 10cf9d: 8b 4d 10 mov 0x10(%ebp),%ecx 10cfa0: 89 01 mov %eax,(%ecx) *fval_percentage = answer % 1000; 10cfa2: 6a 00 push $0x0 10cfa4: 68 e8 03 00 00 push $0x3e8 10cfa9: 56 push %esi 10cfaa: 53 push %ebx 10cfab: e8 14 af 00 00 call 117ec4 <__umoddi3> 10cfb0: 83 c4 10 add $0x10,%esp 10cfb3: 8b 4d 14 mov 0x14(%ebp),%ecx 10cfb6: 89 01 mov %eax,(%ecx) } 10cfb8: 8d 65 f4 lea -0xc(%ebp),%esp 10cfbb: 5b pop %ebx 10cfbc: 5e pop %esi 10cfbd: 5f pop %edi 10cfbe: c9 leave 10cfbf: c3 ret =============================================================================== 0010d510 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 10d510: 55 push %ebp 10d511: 89 e5 mov %esp,%ebp 10d513: 53 push %ebx 10d514: 83 ec 10 sub $0x10,%esp 10d517: 8b 5d 08 mov 0x8(%ebp),%ebx _Chain_Extract( &the_extension->Node ); 10d51a: 53 push %ebx 10d51b: e8 6c 23 00 00 call 10f88c <_Chain_Extract> /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 10d520: 83 c4 10 add $0x10,%esp 10d523: 83 7b 24 00 cmpl $0x0,0x24(%ebx) 10d527: 74 0f je 10d538 <_User_extensions_Remove_set+0x28><== ALWAYS TAKEN _Chain_Extract( &the_extension->Switch.Node ); 10d529: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10d52c: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10d52f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d532: c9 leave <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) _Chain_Extract( &the_extension->Switch.Node ); 10d533: e9 54 23 00 00 jmp 10f88c <_Chain_Extract> <== NOT EXECUTED } 10d538: 8b 5d fc mov -0x4(%ebp),%ebx 10d53b: c9 leave 10d53c: c3 ret =============================================================================== 0010d260 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10d260: 55 push %ebp 10d261: 89 e5 mov %esp,%ebp 10d263: 57 push %edi 10d264: 56 push %esi 10d265: 53 push %ebx 10d266: 83 ec 0c sub $0xc,%esp 10d269: 8b 7d 08 mov 0x8(%ebp),%edi 10d26c: 8b 4d 0c mov 0xc(%ebp),%ecx 10d26f: 8b 75 10 mov 0x10(%ebp),%esi ISR_Level level; _ISR_Disable( level ); 10d272: 9c pushf 10d273: fa cli 10d274: 5a pop %edx * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10d275: 8b 07 mov (%edi),%eax * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10d277: 8d 5f 04 lea 0x4(%edi),%ebx 10d27a: 89 5d f0 mov %ebx,-0x10(%ebp) * hence the compiler must not assume *header to remain * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { 10d27d: 39 d8 cmp %ebx,%eax 10d27f: 74 41 je 10d2c2 <_Watchdog_Adjust+0x62> switch ( direction ) { 10d281: 85 c9 test %ecx,%ecx 10d283: 74 39 je 10d2be <_Watchdog_Adjust+0x5e> 10d285: 49 dec %ecx 10d286: 75 3a jne 10d2c2 <_Watchdog_Adjust+0x62> <== NEVER TAKEN case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10d288: 01 70 10 add %esi,0x10(%eax) 10d28b: eb 35 jmp 10d2c2 <_Watchdog_Adjust+0x62> 10d28d: 8b 07 mov (%edi),%eax break; case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 10d28f: 8b 58 10 mov 0x10(%eax),%ebx 10d292: 39 de cmp %ebx,%esi 10d294: 73 07 jae 10d29d <_Watchdog_Adjust+0x3d> _Watchdog_First( header )->delta_interval -= units; 10d296: 29 f3 sub %esi,%ebx 10d298: 89 58 10 mov %ebx,0x10(%eax) 10d29b: eb 25 jmp 10d2c2 <_Watchdog_Adjust+0x62> break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 10d29d: c7 40 10 01 00 00 00 movl $0x1,0x10(%eax) _ISR_Enable( level ); 10d2a4: 52 push %edx 10d2a5: 9d popf _Watchdog_Tickle( header ); 10d2a6: 83 ec 0c sub $0xc,%esp 10d2a9: 57 push %edi 10d2aa: e8 9d 01 00 00 call 10d44c <_Watchdog_Tickle> _ISR_Disable( level ); 10d2af: 9c pushf 10d2b0: fa cli 10d2b1: 5a pop %edx if ( _Chain_Is_empty( header ) ) 10d2b2: 83 c4 10 add $0x10,%esp 10d2b5: 8b 45 f0 mov -0x10(%ebp),%eax 10d2b8: 39 07 cmp %eax,(%edi) 10d2ba: 74 06 je 10d2c2 <_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; 10d2bc: 29 de sub %ebx,%esi switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10d2be: 85 f6 test %esi,%esi 10d2c0: 75 cb jne 10d28d <_Watchdog_Adjust+0x2d> <== ALWAYS TAKEN } break; } } _ISR_Enable( level ); 10d2c2: 52 push %edx 10d2c3: 9d popf } 10d2c4: 8d 65 f4 lea -0xc(%ebp),%esp 10d2c7: 5b pop %ebx 10d2c8: 5e pop %esi 10d2c9: 5f pop %edi 10d2ca: c9 leave 10d2cb: c3 ret =============================================================================== 00116844 <_Watchdog_Adjust_to_chain>: Chain_Control *header, Watchdog_Interval units_arg, Chain_Control *to_fire ) { 116844: 55 push %ebp 116845: 89 e5 mov %esp,%ebp 116847: 57 push %edi 116848: 56 push %esi 116849: 53 push %ebx 11684a: 83 ec 0c sub $0xc,%esp 11684d: 8b 75 08 mov 0x8(%ebp),%esi 116850: 8b 45 0c mov 0xc(%ebp),%eax Watchdog_Interval units = units_arg; ISR_Level level; Chain_Node *node; if ( !units ) { 116853: 85 c0 test %eax,%eax 116855: 74 74 je 1168cb <_Watchdog_Adjust_to_chain+0x87> return; } _ISR_Disable( level ); 116857: 9c pushf 116858: fa cli 116859: 8f 45 ec popl -0x14(%ebp) * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 11685c: 8d 7e 04 lea 0x4(%esi),%edi if ( !_Chain_Is_empty( header ) ) { 11685f: 39 3e cmp %edi,(%esi) 116861: 74 64 je 1168c7 <_Watchdog_Adjust_to_chain+0x83> 116863: 8b 55 10 mov 0x10(%ebp),%edx 116866: 83 c2 04 add $0x4,%edx 116869: 89 55 f0 mov %edx,-0x10(%ebp) 11686c: 89 c3 mov %eax,%ebx 11686e: 8b 06 mov (%esi),%eax while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 116870: 8b 48 10 mov 0x10(%eax),%ecx 116873: 39 cb cmp %ecx,%ebx 116875: 73 07 jae 11687e <_Watchdog_Adjust_to_chain+0x3a> _Watchdog_First( header )->delta_interval -= units; 116877: 29 d9 sub %ebx,%ecx 116879: 89 48 10 mov %ecx,0x10(%eax) 11687c: eb 49 jmp 1168c7 <_Watchdog_Adjust_to_chain+0x83> break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 0; 11687e: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 116885: 8b 16 mov (%esi),%edx 116887: 39 fa cmp %edi,%edx 116889: 75 04 jne 11688f <_Watchdog_Adjust_to_chain+0x4b><== ALWAYS TAKEN 11688b: 31 d2 xor %edx,%edx <== NOT EXECUTED 11688d: eb 07 jmp 116896 <_Watchdog_Adjust_to_chain+0x52><== NOT EXECUTED 11688f: 8b 02 mov (%edx),%eax 116891: 89 06 mov %eax,(%esi) 116893: 89 70 04 mov %esi,0x4(%eax) 116896: 8b 45 f0 mov -0x10(%ebp),%eax 116899: 89 02 mov %eax,(%edx) 11689b: 8b 45 10 mov 0x10(%ebp),%eax 11689e: 8b 40 08 mov 0x8(%eax),%eax 1168a1: 89 45 e8 mov %eax,-0x18(%ebp) 1168a4: 8b 45 10 mov 0x10(%ebp),%eax 1168a7: 89 50 08 mov %edx,0x8(%eax) 1168aa: 8b 45 e8 mov -0x18(%ebp),%eax 1168ad: 89 10 mov %edx,(%eax) 1168af: 89 42 04 mov %eax,0x4(%edx) do { node = _Chain_Get_unprotected( header ); _Chain_Append_unprotected( to_fire, node ); _ISR_Flash( level ); 1168b2: ff 75 ec pushl -0x14(%ebp) 1168b5: 9d popf 1168b6: fa cli * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 1168b7: 8b 06 mov (%esi),%eax } while ( !_Chain_Is_empty( header ) && _Watchdog_First( header )->delta_interval == 0 ); 1168b9: 39 f8 cmp %edi,%eax 1168bb: 74 0a je 1168c7 <_Watchdog_Adjust_to_chain+0x83> 1168bd: 83 78 10 00 cmpl $0x0,0x10(%eax) 1168c1: 74 c2 je 116885 <_Watchdog_Adjust_to_chain+0x41> return; } _ISR_Disable( level ); if ( !_Chain_Is_empty( header ) ) { while ( units ) { 1168c3: 29 cb sub %ecx,%ebx 1168c5: 75 a7 jne 11686e <_Watchdog_Adjust_to_chain+0x2a><== NEVER TAKEN break; } } } _ISR_Enable( level ); 1168c7: ff 75 ec pushl -0x14(%ebp) 1168ca: 9d popf } 1168cb: 83 c4 0c add $0xc,%esp 1168ce: 5b pop %ebx 1168cf: 5e pop %esi 1168d0: 5f pop %edi 1168d1: c9 leave 1168d2: c3 ret =============================================================================== 0010bc28 <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 10bc28: 55 push %ebp 10bc29: 89 e5 mov %esp,%ebp 10bc2b: 57 push %edi 10bc2c: 56 push %esi 10bc2d: 53 push %ebx 10bc2e: 83 ec 04 sub $0x4,%esp 10bc31: 8b 75 0c mov 0xc(%ebp),%esi Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level; 10bc34: 8b 3d 34 d8 11 00 mov 0x11d834,%edi _ISR_Disable( level ); 10bc3a: 9c pushf 10bc3b: fa cli 10bc3c: 8f 45 f0 popl -0x10(%ebp) /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_watchdog->state != WATCHDOG_INACTIVE ) { 10bc3f: 83 7e 08 00 cmpl $0x0,0x8(%esi) 10bc43: 74 09 je 10bc4e <_Watchdog_Insert+0x26> <== ALWAYS TAKEN _ISR_Enable( level ); 10bc45: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10bc48: 9d popf <== NOT EXECUTED 10bc49: e9 89 00 00 00 jmp 10bcd7 <_Watchdog_Insert+0xaf> <== NOT EXECUTED return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 10bc4e: c7 46 08 01 00 00 00 movl $0x1,0x8(%esi) _Watchdog_Sync_count++; 10bc55: a1 e4 d8 11 00 mov 0x11d8e4,%eax 10bc5a: 40 inc %eax 10bc5b: a3 e4 d8 11 00 mov %eax,0x11d8e4 restart: delta_interval = the_watchdog->initial; 10bc60: 8b 4e 0c mov 0xc(%esi),%ecx * cache *header!! * * Till Straumann, 7/2003 (gcc-3.2.2 -O4 on powerpc) * */ for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ; 10bc63: 8b 45 08 mov 0x8(%ebp),%eax 10bc66: 8b 18 mov (%eax),%ebx ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10bc68: 85 c9 test %ecx,%ecx 10bc6a: 74 35 je 10bca1 <_Watchdog_Insert+0x79> 10bc6c: 83 3b 00 cmpl $0x0,(%ebx) 10bc6f: 74 30 je 10bca1 <_Watchdog_Insert+0x79> break; if ( delta_interval < after->delta_interval ) { 10bc71: 8b 53 10 mov 0x10(%ebx),%edx 10bc74: 39 d1 cmp %edx,%ecx 10bc76: 73 07 jae 10bc7f <_Watchdog_Insert+0x57> after->delta_interval -= delta_interval; 10bc78: 29 ca sub %ecx,%edx 10bc7a: 89 53 10 mov %edx,0x10(%ebx) 10bc7d: eb 22 jmp 10bca1 <_Watchdog_Insert+0x79> * used around this flash point allowed interrupts to execute * which violated the design assumptions. The critical section * mechanism used here WAS redesigned to address this. */ _ISR_Flash( level ); 10bc7f: ff 75 f0 pushl -0x10(%ebp) 10bc82: 9d popf 10bc83: fa cli if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 10bc84: 83 7e 08 01 cmpl $0x1,0x8(%esi) 10bc88: 75 38 jne 10bcc2 <_Watchdog_Insert+0x9a> <== NEVER TAKEN goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 10bc8a: a1 54 d8 11 00 mov 0x11d854,%eax 10bc8f: 39 f8 cmp %edi,%eax 10bc91: 76 08 jbe 10bc9b <_Watchdog_Insert+0x73> _Watchdog_Sync_level = insert_isr_nest_level; 10bc93: 89 3d 54 d8 11 00 mov %edi,0x11d854 10bc99: eb c5 jmp 10bc60 <_Watchdog_Insert+0x38> if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; break; } delta_interval -= after->delta_interval; 10bc9b: 29 d1 sub %edx,%ecx ); #ifdef __cplusplus } #endif 10bc9d: 8b 1b mov (%ebx),%ebx 10bc9f: eb c7 jmp 10bc68 <_Watchdog_Insert+0x40> * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( 10bca1: c7 46 08 02 00 00 00 movl $0x2,0x8(%esi) } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 10bca8: 89 4e 10 mov %ecx,0x10(%esi) _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 10bcab: 8b 43 04 mov 0x4(%ebx),%eax 10bcae: 89 46 04 mov %eax,0x4(%esi) 10bcb1: 8b 10 mov (%eax),%edx 10bcb3: 89 30 mov %esi,(%eax) 10bcb5: 89 16 mov %edx,(%esi) 10bcb7: 89 72 04 mov %esi,0x4(%edx) the_watchdog->start_time = _Watchdog_Ticks_since_boot; 10bcba: a1 e8 d8 11 00 mov 0x11d8e8,%eax 10bcbf: 89 46 14 mov %eax,0x14(%esi) exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; 10bcc2: 89 3d 54 d8 11 00 mov %edi,0x11d854 _Watchdog_Sync_count--; 10bcc8: a1 e4 d8 11 00 mov 0x11d8e4,%eax 10bccd: 48 dec %eax 10bcce: a3 e4 d8 11 00 mov %eax,0x11d8e4 _ISR_Enable( level ); 10bcd3: ff 75 f0 pushl -0x10(%ebp) 10bcd6: 9d popf } 10bcd7: 58 pop %eax 10bcd8: 5b pop %ebx 10bcd9: 5e pop %esi 10bcda: 5f pop %edi 10bcdb: c9 leave 10bcdc: c3 ret =============================================================================== 0010bd40 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10bd40: 55 push %ebp 10bd41: 89 e5 mov %esp,%ebp 10bd43: 56 push %esi 10bd44: 53 push %ebx 10bd45: 8b 4d 08 mov 0x8(%ebp),%ecx ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10bd48: 9c pushf 10bd49: fa cli 10bd4a: 5e pop %esi previous_state = the_watchdog->state; 10bd4b: 8b 59 08 mov 0x8(%ecx),%ebx switch ( previous_state ) { 10bd4e: 83 fb 01 cmp $0x1,%ebx 10bd51: 74 09 je 10bd5c <_Watchdog_Remove+0x1c> <== NEVER TAKEN 10bd53: 72 41 jb 10bd96 <_Watchdog_Remove+0x56> 10bd55: 83 fb 03 cmp $0x3,%ebx 10bd58: 77 3c ja 10bd96 <_Watchdog_Remove+0x56> <== NEVER TAKEN 10bd5a: eb 09 jmp 10bd65 <_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; 10bd5c: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED 10bd63: eb 31 jmp 10bd96 <_Watchdog_Remove+0x56> <== NOT EXECUTED break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10bd65: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) ); #ifdef __cplusplus } #endif 10bd6c: 8b 11 mov (%ecx),%edx next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 10bd6e: 83 3a 00 cmpl $0x0,(%edx) 10bd71: 74 06 je 10bd79 <_Watchdog_Remove+0x39> next_watchdog->delta_interval += the_watchdog->delta_interval; 10bd73: 8b 41 10 mov 0x10(%ecx),%eax 10bd76: 01 42 10 add %eax,0x10(%edx) if ( _Watchdog_Sync_count ) 10bd79: a1 e4 d8 11 00 mov 0x11d8e4,%eax 10bd7e: 85 c0 test %eax,%eax 10bd80: 74 0a je 10bd8c <_Watchdog_Remove+0x4c> <== ALWAYS TAKEN _Watchdog_Sync_level = _ISR_Nest_level; 10bd82: a1 34 d8 11 00 mov 0x11d834,%eax <== NOT EXECUTED 10bd87: a3 54 d8 11 00 mov %eax,0x11d854 <== NOT EXECUTED 10bd8c: 8b 11 mov (%ecx),%edx 10bd8e: 8b 41 04 mov 0x4(%ecx),%eax 10bd91: 89 42 04 mov %eax,0x4(%edx) 10bd94: 89 10 mov %edx,(%eax) _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10bd96: a1 e8 d8 11 00 mov 0x11d8e8,%eax 10bd9b: 89 41 18 mov %eax,0x18(%ecx) _ISR_Enable( level ); 10bd9e: 56 push %esi 10bd9f: 9d popf return( previous_state ); } 10bda0: 89 d8 mov %ebx,%eax 10bda2: 5b pop %ebx 10bda3: 5e pop %esi 10bda4: c9 leave 10bda5: c3 ret =============================================================================== 0010bda8 <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10bda8: 55 push %ebp 10bda9: 89 e5 mov %esp,%ebp 10bdab: 57 push %edi 10bdac: 56 push %esi 10bdad: 53 push %ebx 10bdae: 83 ec 0c sub $0xc,%esp 10bdb1: 8b 7d 08 mov 0x8(%ebp),%edi * See the comment in watchdoginsert.c and watchdogadjust.c * about why it's safe not to declare header a pointer to * volatile data - till, 2003/7 */ _ISR_Disable( level ); 10bdb4: 9c pushf 10bdb5: fa cli 10bdb6: 5e pop %esi * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10bdb7: 8b 17 mov (%edi),%edx * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10bdb9: 8d 47 04 lea 0x4(%edi),%eax 10bdbc: 89 45 f0 mov %eax,-0x10(%ebp) if ( _Chain_Is_empty( header ) ) 10bdbf: 39 c2 cmp %eax,%edx 10bdc1: 74 44 je 10be07 <_Watchdog_Tickle+0x5f> 10bdc3: 89 d3 mov %edx,%ebx * to be inserted has already had its delta_interval adjusted to 0, and * so is added to the head of the chain with a delta_interval of 0. * * Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc) */ if (the_watchdog->delta_interval != 0) { 10bdc5: 8b 42 10 mov 0x10(%edx),%eax 10bdc8: 85 c0 test %eax,%eax 10bdca: 74 08 je 10bdd4 <_Watchdog_Tickle+0x2c> <== NEVER TAKEN the_watchdog->delta_interval--; 10bdcc: 48 dec %eax 10bdcd: 89 42 10 mov %eax,0x10(%edx) if ( the_watchdog->delta_interval != 0 ) 10bdd0: 85 c0 test %eax,%eax 10bdd2: 75 33 jne 10be07 <_Watchdog_Tickle+0x5f> goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10bdd4: 83 ec 0c sub $0xc,%esp 10bdd7: 53 push %ebx 10bdd8: e8 63 ff ff ff call 10bd40 <_Watchdog_Remove> _ISR_Enable( level ); 10bddd: 56 push %esi 10bdde: 9d popf switch( watchdog_state ) { 10bddf: 83 c4 10 add $0x10,%esp 10bde2: 83 f8 02 cmp $0x2,%eax 10bde5: 75 0e jne 10bdf5 <_Watchdog_Tickle+0x4d> <== NEVER TAKEN case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10bde7: 50 push %eax 10bde8: 50 push %eax 10bde9: ff 73 24 pushl 0x24(%ebx) 10bdec: ff 73 20 pushl 0x20(%ebx) 10bdef: ff 53 1c call *0x1c(%ebx) 10bdf2: 83 c4 10 add $0x10,%esp case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10bdf5: 9c pushf 10bdf6: fa cli 10bdf7: 5e pop %esi 10bdf8: 8b 07 mov (%edi),%eax the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10bdfa: 3b 45 f0 cmp -0x10(%ebp),%eax 10bdfd: 74 08 je 10be07 <_Watchdog_Tickle+0x5f> 10bdff: 89 c3 mov %eax,%ebx 10be01: 83 78 10 00 cmpl $0x0,0x10(%eax) 10be05: eb cb jmp 10bdd2 <_Watchdog_Tickle+0x2a> leave: _ISR_Enable(level); 10be07: 56 push %esi 10be08: 9d popf } 10be09: 8d 65 f4 lea -0xc(%ebp),%esp 10be0c: 5b pop %ebx 10be0d: 5e pop %esi 10be0e: 5f pop %edi 10be0f: c9 leave 10be10: c3 ret =============================================================================== 0010be66 <_Workspace_Handler_initialization>: */ void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 10be66: 55 push %ebp 10be67: 89 e5 mov %esp,%ebp 10be69: 57 push %edi 10be6a: 83 ec 14 sub $0x14,%esp 10be6d: 8b 55 08 mov 0x8(%ebp),%edx uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) 10be70: 85 d2 test %edx,%edx 10be72: 74 05 je 10be79 <_Workspace_Handler_initialization+0x13> 10be74: f6 c2 03 test $0x3,%dl 10be77: 74 05 je 10be7e <_Workspace_Handler_initialization+0x18><== ALWAYS TAKEN _Internal_error_Occurred( 10be79: 51 push %ecx 10be7a: 6a 02 push $0x2 10be7c: eb 2e jmp 10beac <_Workspace_Handler_initialization+0x46> INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _Configuration_Table->do_zero_of_workspace ) 10be7e: a1 30 d8 11 00 mov 0x11d830,%eax 10be83: 80 78 28 00 cmpb $0x0,0x28(%eax) 10be87: 74 09 je 10be92 <_Workspace_Handler_initialization+0x2c><== ALWAYS TAKEN memset( starting_address, 0, size ); 10be89: 31 c0 xor %eax,%eax 10be8b: 89 d7 mov %edx,%edi <== NOT EXECUTED 10be8d: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10be90: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED memory_available = _Heap_Initialize( 10be92: 6a 04 push $0x4 10be94: ff 75 0c pushl 0xc(%ebp) 10be97: 52 push %edx 10be98: 68 bc d7 11 00 push $0x11d7bc 10be9d: e8 8a e1 ff ff call 10a02c <_Heap_Initialize> starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 10bea2: 83 c4 10 add $0x10,%esp 10bea5: 85 c0 test %eax,%eax 10bea7: 75 0c jne 10beb5 <_Workspace_Handler_initialization+0x4f><== ALWAYS TAKEN _Internal_error_Occurred( 10bea9: 52 push %edx <== NOT EXECUTED 10beaa: 6a 03 push $0x3 <== NOT EXECUTED 10beac: 6a 01 push $0x1 10beae: 6a 00 push $0x0 10beb0: e8 3f e3 ff ff call 10a1f4 <_Internal_error_Occurred> INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } 10beb5: 8b 7d fc mov -0x4(%ebp),%edi 10beb8: c9 leave 10beb9: c3 ret =============================================================================== 001062c2 <__assert>: void __assert( const char *file, int line, const char *failedexpr ) { 1062c2: 55 push %ebp <== NOT EXECUTED 1062c3: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1062c5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED __assert_func (file, line, NULL, failedexpr); 1062c8: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1062cb: 6a 00 push $0x0 <== NOT EXECUTED 1062cd: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1062d0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1062d3: e8 b0 ff ff ff call 106288 <__assert_func> <== NOT EXECUTED 1062d8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1062db: c9 leave <== NOT EXECUTED 1062dc: c3 ret <== NOT EXECUTED =============================================================================== 00106288 <__assert_func>: const char *file, int line, const char *func, const char *failedexpr ) { 106288: 55 push %ebp 106289: 89 e5 mov %esp,%ebp 10628b: 83 ec 08 sub $0x8,%esp 10628e: 8b 45 10 mov 0x10(%ebp),%eax printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n", 106291: ba bd 71 11 00 mov $0x1171bd,%edx 106296: 85 c0 test %eax,%eax 106298: 75 07 jne 1062a1 <__assert_func+0x19> <== ALWAYS TAKEN 10629a: ba 55 72 11 00 mov $0x117255,%edx <== NOT EXECUTED 10629f: 89 d0 mov %edx,%eax <== NOT EXECUTED 1062a1: 51 push %ecx 1062a2: 51 push %ecx 1062a3: 50 push %eax 1062a4: 52 push %edx 1062a5: ff 75 0c pushl 0xc(%ebp) 1062a8: ff 75 08 pushl 0x8(%ebp) 1062ab: ff 75 14 pushl 0x14(%ebp) 1062ae: 68 ca 71 11 00 push $0x1171ca 1062b3: e8 a6 0d 00 00 call 10705e file, line, (func) ? ", function: " : "", (func) ? func : "" ); rtems_fatal_error_occurred(0); 1062b8: 83 c4 14 add $0x14,%esp 1062bb: 6a 00 push $0x0 1062bd: e8 d2 34 00 00 call 109794 =============================================================================== 0011573a <_exit>: /* * If the toolset uses init/fini sections, then we need to * run the global destructors now. */ #if defined(__USE_INIT_FINI__) _fini(); 11573a: 55 push %ebp 11573b: 89 e5 mov %esp,%ebp 11573d: 83 ec 08 sub $0x8,%esp 115740: e8 28 07 00 00 call 115e6d <_fini> * We need to do the exit processing on the global reentrancy structure. * This has already been done on the per task reentrancy structure * associated with this task. */ libc_wrapup(); 115745: e8 8a ff ff ff call 1156d4 rtems_shutdown_executive(status); 11574a: 83 ec 0c sub $0xc,%esp 11574d: ff 75 08 pushl 0x8(%ebp) 115750: e8 d7 00 00 00 call 11582c 115755: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115758: eb fe jmp 115758 <_exit+0x1e> <== NOT EXECUTED =============================================================================== 001071f6 <_fcntl_r>: struct _reent *ptr, int fd, int cmd, int arg ) { 1071f6: 55 push %ebp <== NOT EXECUTED 1071f7: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1071f9: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1071fc: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return fcntl( fd, cmd, arg ); 1071ff: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 107202: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 107205: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 107208: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10720b: c9 leave <== NOT EXECUTED int fd, int cmd, int arg ) { return fcntl( fd, cmd, arg ); 10720c: e9 9f fe ff ff jmp 1070b0 <== NOT EXECUTED =============================================================================== 001180b6 <_getpid_r>: #include pid_t _getpid_r( struct _reent *ptr ) { 1180b6: 55 push %ebp <== NOT EXECUTED 1180b7: 89 e5 mov %esp,%ebp <== NOT EXECUTED return getpid(); } 1180b9: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 1180be: c9 leave <== NOT EXECUTED 1180bf: c3 ret <== NOT EXECUTED =============================================================================== 0010cea4 <_gettimeofday>: int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { 10cea4: 55 push %ebp <== NOT EXECUTED 10cea5: 89 e5 mov %esp,%ebp <== NOT EXECUTED return gettimeofday( tp, tzp ); } 10cea7: c9 leave <== NOT EXECUTED int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp ); 10cea8: e9 a7 ff ff ff jmp 10ce54 <== NOT EXECUTED =============================================================================== 00107b86 <_link_r>: int _link_r( struct _reent *ptr, const char *existing, const char *new ) { 107b86: 55 push %ebp <== NOT EXECUTED 107b87: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107b89: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return link( existing, new ); 107b8c: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 107b8f: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 107b92: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 107b95: c9 leave <== NOT EXECUTED struct _reent *ptr, const char *existing, const char *new ) { return link( existing, new ); 107b96: e9 3d fe ff ff jmp 1079d8 <== NOT EXECUTED =============================================================================== 001157f8 <_realloc_r>: void *_realloc_r( struct _reent *ignored, void *ptr, size_t size ) { 1157f8: 55 push %ebp <== NOT EXECUTED 1157f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1157fb: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return realloc( ptr, size ); 1157fe: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 115801: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 115804: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 115807: c9 leave <== NOT EXECUTED struct _reent *ignored, void *ptr, size_t size ) { return realloc( ptr, size ); 115808: e9 4f 00 00 00 jmp 11585c <== NOT EXECUTED =============================================================================== 0010841f <_stat_r>: int _STAT_R_NAME( struct _reent *ptr, const char *path, struct stat *buf ) { 10841f: 55 push %ebp <== NOT EXECUTED 108420: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108422: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return _STAT_NAME( path, buf ); 108425: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 108428: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10842b: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10842e: c9 leave <== NOT EXECUTED struct _reent *ptr, const char *path, struct stat *buf ) { return _STAT_NAME( path, buf ); 10842f: e9 4c ff ff ff jmp 108380 <== NOT EXECUTED =============================================================================== 0010b218 <_unlink_r>: int _unlink_r( struct _reent *ptr, const char *path ) { 10b218: 55 push %ebp <== NOT EXECUTED 10b219: 89 e5 mov %esp,%ebp <== NOT EXECUTED return unlink( path ); 10b21b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b21e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10b221: c9 leave <== NOT EXECUTED int _unlink_r( struct _reent *ptr, const char *path ) { return unlink( path ); 10b222: e9 e9 fe ff ff jmp 10b110 <== NOT EXECUTED =============================================================================== 00108dc4 : int adjtime( struct timeval *delta, struct timeval *olddelta ) { 108dc4: 55 push %ebp 108dc5: 89 e5 mov %esp,%ebp 108dc7: 57 push %edi 108dc8: 56 push %esi 108dc9: 53 push %ebx 108dca: 83 ec 1c sub $0x1c,%esp 108dcd: 8b 5d 08 mov 0x8(%ebp),%ebx 108dd0: 8b 75 0c mov 0xc(%ebp),%esi long adjustment; /* * Simple validations */ if ( !delta ) 108dd3: 85 db test %ebx,%ebx 108dd5: 74 09 je 108de0 rtems_set_errno_and_return_minus_one( EINVAL ); if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND ) 108dd7: 81 7b 04 3f 42 0f 00 cmpl $0xf423f,0x4(%ebx) 108dde: 76 13 jbe 108df3 rtems_set_errno_and_return_minus_one( EINVAL ); 108de0: e8 47 6a 00 00 call 10f82c <__errno> 108de5: c7 00 16 00 00 00 movl $0x16,(%eax) 108deb: 83 c8 ff or $0xffffffff,%eax 108dee: e9 9e 00 00 00 jmp 108e91 if ( olddelta ) { 108df3: 85 f6 test %esi,%esi 108df5: 74 0d je 108e04 olddelta->tv_sec = 0; 108df7: c7 06 00 00 00 00 movl $0x0,(%esi) olddelta->tv_usec = 0; 108dfd: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) } /* convert delta to microseconds */ adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND); 108e04: 69 03 40 42 0f 00 imul $0xf4240,(%ebx),%eax adjustment += delta->tv_usec; /* too small to account for */ if ( adjustment < _TOD_Microseconds_per_tick ) 108e0a: 03 43 04 add 0x4(%ebx),%eax 108e0d: 3b 05 74 e7 11 00 cmp 0x11e774,%eax 108e13: 72 7a jb 108e8f /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 108e15: a1 d8 e5 11 00 mov 0x11e5d8,%eax 108e1a: 40 inc %eax 108e1b: a3 d8 e5 11 00 mov %eax,0x11e5d8 * This prevents context switches while we are adjusting the TOD */ _Thread_Disable_dispatch(); _TOD_Get( &ts ); 108e20: 83 ec 0c sub $0xc,%esp 108e23: 8d 45 ec lea -0x14(%ebp),%eax 108e26: 50 push %eax 108e27: e8 30 17 00 00 call 10a55c <_TOD_Get> ts.tv_sec += delta->tv_sec; ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; 108e2c: 69 7b 04 e8 03 00 00 imul $0x3e8,0x4(%ebx),%edi 108e33: 03 7d f0 add -0x10(%ebp),%edi int adjtime( struct timeval *delta, struct timeval *olddelta ) { 108e36: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx 108e3b: 89 f8 mov %edi,%eax 108e3d: 31 d2 xor %edx,%edx 108e3f: f7 f1 div %ecx 108e41: 89 45 dc mov %eax,-0x24(%ebp) 108e44: 89 c1 mov %eax,%ecx 108e46: 03 0b add (%ebx),%ecx 108e48: 03 4d ec add -0x14(%ebp),%ecx 108e4b: 69 c0 00 36 65 c4 imul $0xc4653600,%eax,%eax 108e51: 01 f8 add %edi,%eax 108e53: 83 c4 10 add $0x10,%esp 108e56: eb 05 jmp 108e5d 108e58: 05 00 ca 9a 3b add $0x3b9aca00,%eax 108e5d: 89 ca mov %ecx,%edx 108e5f: 49 dec %ecx ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; ts.tv_sec++; } /* if adjustment is too much negative */ while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) { 108e60: 3d 00 36 65 c4 cmp $0xc4653600,%eax 108e65: 76 f1 jbe 108e58 108e67: 89 55 ec mov %edx,-0x14(%ebp) 108e6a: 89 45 f0 mov %eax,-0x10(%ebp) ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND; ts.tv_sec--; } _TOD_Set( &ts ); 108e6d: 83 ec 0c sub $0xc,%esp 108e70: 8d 45 ec lea -0x14(%ebp),%eax 108e73: 50 push %eax 108e74: e8 73 17 00 00 call 10a5ec <_TOD_Set> _Thread_Enable_dispatch(); 108e79: e8 8a 26 00 00 call 10b508 <_Thread_Enable_dispatch> /* set the user's output */ if ( olddelta ) 108e7e: 83 c4 10 add $0x10,%esp 108e81: 85 f6 test %esi,%esi 108e83: 74 0a je 108e8f <== NEVER TAKEN *olddelta = *delta; 108e85: 8b 13 mov (%ebx),%edx 108e87: 8b 43 04 mov 0x4(%ebx),%eax 108e8a: 89 46 04 mov %eax,0x4(%esi) 108e8d: 89 16 mov %edx,(%esi) 108e8f: 31 c0 xor %eax,%eax return 0; } 108e91: 8d 65 f4 lea -0xc(%ebp),%esp 108e94: 5b pop %ebx 108e95: 5e pop %esi 108e96: 5f pop %edi 108e97: c9 leave 108e98: c3 ret =============================================================================== 0010a708 : } unsigned int alarm( unsigned int seconds ) { 10a708: 55 push %ebp 10a709: 89 e5 mov %esp,%ebp 10a70b: 53 push %ebx 10a70c: 83 ec 14 sub $0x14,%esp /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 10a70f: 83 3d 04 29 12 00 00 cmpl $0x0,0x122904 10a716: 75 2c jne 10a744 * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10a718: c7 05 f0 28 12 00 00 movl $0x0,0x1228f0 10a71f: 00 00 00 * @param[in] the_heap is the heap to operate upon 10a722: c7 05 04 29 12 00 a7 movl $0x10a7a7,0x122904 10a729: a7 10 00 * @param[in] starting_address is the starting address of the memory for 10a72c: c7 05 08 29 12 00 00 movl $0x0,0x122908 10a733: 00 00 00 * the heap 10a736: c7 05 0c 29 12 00 00 movl $0x0,0x12290c 10a73d: 00 00 00 10a740: 31 db xor %ebx,%ebx 10a742: eb 43 jmp 10a787 _Watchdog_Initialize( the_timer, _POSIX_signals_Alarm_TSR, 0, NULL ); } else { switch ( _Watchdog_Remove( the_timer ) ) { 10a744: 83 ec 0c sub $0xc,%esp 10a747: 68 e8 28 12 00 push $0x1228e8 10a74c: e8 e3 41 00 00 call 10e934 <_Watchdog_Remove> 10a751: 83 c4 10 add $0x10,%esp 10a754: 83 e8 02 sub $0x2,%eax 10a757: 31 db xor %ebx,%ebx 10a759: 83 f8 01 cmp $0x1,%eax 10a75c: 77 29 ja 10a787 <== NEVER TAKEN * The stop_time and start_time fields are snapshots of ticks since * boot. Since alarm() is dealing in seconds, we must account for * this. */ remaining = the_timer->initial - 10a75e: 8b 0d 00 29 12 00 mov 0x122900,%ecx 10a764: 2b 0d fc 28 12 00 sub 0x1228fc,%ecx 10a76a: b8 40 42 0f 00 mov $0xf4240,%eax 10a76f: 31 d2 xor %edx,%edx 10a771: f7 35 64 2b 12 00 divl 0x122b64 10a777: 89 c3 mov %eax,%ebx 10a779: 89 c8 mov %ecx,%eax 10a77b: 31 d2 xor %edx,%edx 10a77d: f7 f3 div %ebx 10a77f: 8b 1d f4 28 12 00 mov 0x1228f4,%ebx 10a785: 29 c3 sub %eax,%ebx * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, 10a787: 8b 45 08 mov 0x8(%ebp),%eax 10a78a: a3 f4 28 12 00 mov %eax,0x1228f4 size_t size ); 10a78f: 50 push %eax 10a790: 50 push %eax 10a791: 68 e8 28 12 00 push $0x1228e8 10a796: 68 9c 2a 12 00 push $0x122a9c 10a79b: e8 7c 40 00 00 call 10e81c <_Watchdog_Insert> } _Watchdog_Insert_seconds( the_timer, seconds ); return remaining; } 10a7a0: 89 d8 mov %ebx,%eax 10a7a2: 8b 5d fc mov -0x4(%ebp),%ebx 10a7a5: c9 leave 10a7a6: c3 ret =============================================================================== 00108e24 : */ int alphasort( const void *d1, const void *d2 ) { 108e24: 55 push %ebp <== NOT EXECUTED 108e25: 89 e5 mov %esp,%ebp <== NOT EXECUTED return(strcmp((*(struct dirent **)d1)->d_name, 108e27: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 108e2a: 8b 00 mov (%eax),%eax <== NOT EXECUTED 108e2c: 83 c0 0c add $0xc,%eax <== NOT EXECUTED 108e2f: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 108e32: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108e35: 8b 00 mov (%eax),%eax <== NOT EXECUTED 108e37: 83 c0 0c add $0xc,%eax <== NOT EXECUTED 108e3a: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED (*(struct dirent **)d2)->d_name)); } 108e3d: c9 leave <== NOT EXECUTED int alphasort( const void *d1, const void *d2 ) { return(strcmp((*(struct dirent **)d1)->d_name, 108e3e: e9 55 a8 00 00 jmp 113698 <== NOT EXECUTED =============================================================================== 0010ccd0 : ) { register char *cptr; int length; MSBUMP(calloc_calls, 1); 10ccd0: 55 push %ebp 10ccd1: 89 e5 mov %esp,%ebp 10ccd3: 57 push %edi 10ccd4: 53 push %ebx 10ccd5: 83 ec 1c sub $0x1c,%esp 10ccd8: 8b 5d 0c mov 0xc(%ebp),%ebx 10ccdb: ff 05 bc d6 11 00 incl 0x11d6bc length = nelem * elsize; 10cce1: 0f af 5d 08 imul 0x8(%ebp),%ebx cptr = malloc( length ); 10cce5: 53 push %ebx 10cce6: e8 89 99 ff ff call 106674 10cceb: 89 c2 mov %eax,%edx if ( cptr ) 10cced: 83 c4 10 add $0x10,%esp 10ccf0: 85 c0 test %eax,%eax 10ccf2: 74 08 je 10ccfc <== NEVER TAKEN memset( cptr, '\0', length ); 10ccf4: 31 c0 xor %eax,%eax 10ccf6: 89 d7 mov %edx,%edi 10ccf8: 89 d9 mov %ebx,%ecx 10ccfa: f3 aa rep stos %al,%es:(%edi) MSBUMP(malloc_calls, -1); /* subtract off the malloc */ 10ccfc: ff 0d ac d6 11 00 decl 0x11d6ac return cptr; } 10cd02: 89 d0 mov %edx,%eax 10cd04: 8d 65 f8 lea -0x8(%ebp),%esp 10cd07: 5b pop %ebx 10cd08: 5f pop %edi 10cd09: c9 leave 10cd0a: c3 ret =============================================================================== 0010dc74 : #include int chdir( const char *pathname ) { 10dc74: 55 push %ebp 10dc75: 89 e5 mov %esp,%ebp 10dc77: 57 push %edi 10dc78: 56 push %esi 10dc79: 83 ec 10 sub $0x10,%esp /* * Get the node where we wish to go. */ result = rtems_filesystem_evaluate_path( 10dc7c: 6a 01 push $0x1 10dc7e: 8d 75 e8 lea -0x18(%ebp),%esi 10dc81: 56 push %esi 10dc82: 6a 01 push $0x1 10dc84: ff 75 08 pushl 0x8(%ebp) 10dc87: e8 26 8e ff ff call 106ab2 pathname, RTEMS_LIBIO_PERMS_SEARCH, &loc, true ); if ( result != 0 ) 10dc8c: 83 c4 10 add $0x10,%esp 10dc8f: 83 ca ff or $0xffffffff,%edx 10dc92: 85 c0 test %eax,%eax 10dc94: 0f 85 8d 00 00 00 jne 10dd27 /* * Verify you can change directory into this node. */ if ( !loc.ops->node_type_h ) { 10dc9a: 8b 45 f0 mov -0x10(%ebp),%eax 10dc9d: 8b 50 10 mov 0x10(%eax),%edx 10dca0: 85 d2 test %edx,%edx 10dca2: 75 1d jne 10dcc1 <== ALWAYS TAKEN rtems_filesystem_freenode( &loc ); 10dca4: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10dca7: 85 c0 test %eax,%eax <== NOT EXECUTED 10dca9: 74 09 je 10dcb4 <== NOT EXECUTED 10dcab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10dcae: 56 push %esi <== NOT EXECUTED 10dcaf: ff d0 call *%eax <== NOT EXECUTED 10dcb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 10dcb4: e8 f7 2c 00 00 call 1109b0 <__errno> <== NOT EXECUTED 10dcb9: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10dcbf: eb 2e jmp 10dcef <== NOT EXECUTED } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 10dcc1: 83 ec 0c sub $0xc,%esp 10dcc4: 56 push %esi 10dcc5: ff d2 call *%edx 10dcc7: 83 c4 10 add $0x10,%esp 10dcca: 48 dec %eax 10dccb: 74 27 je 10dcf4 rtems_filesystem_freenode( &loc ); 10dccd: 8b 45 f0 mov -0x10(%ebp),%eax 10dcd0: 85 c0 test %eax,%eax 10dcd2: 74 10 je 10dce4 <== NEVER TAKEN 10dcd4: 8b 40 1c mov 0x1c(%eax),%eax 10dcd7: 85 c0 test %eax,%eax 10dcd9: 74 09 je 10dce4 <== NEVER TAKEN 10dcdb: 83 ec 0c sub $0xc,%esp 10dcde: 56 push %esi 10dcdf: ff d0 call *%eax 10dce1: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( ENOTDIR ); 10dce4: e8 c7 2c 00 00 call 1109b0 <__errno> 10dce9: c7 00 14 00 00 00 movl $0x14,(%eax) 10dcef: 83 ca ff or $0xffffffff,%edx 10dcf2: eb 33 jmp 10dd27 } rtems_filesystem_freenode( &rtems_filesystem_current ); 10dcf4: a1 ac e3 11 00 mov 0x11e3ac,%eax 10dcf9: 8b 50 0c mov 0xc(%eax),%edx 10dcfc: 85 d2 test %edx,%edx 10dcfe: 74 13 je 10dd13 <== NEVER TAKEN 10dd00: 8b 52 1c mov 0x1c(%edx),%edx 10dd03: 85 d2 test %edx,%edx 10dd05: 74 0c je 10dd13 <== NEVER TAKEN 10dd07: 83 ec 0c sub $0xc,%esp 10dd0a: 83 c0 04 add $0x4,%eax 10dd0d: 50 push %eax 10dd0e: ff d2 call *%edx 10dd10: 83 c4 10 add $0x10,%esp rtems_filesystem_current = loc; 10dd13: a1 ac e3 11 00 mov 0x11e3ac,%eax 10dd18: 8d 78 04 lea 0x4(%eax),%edi 10dd1b: 8d 75 e8 lea -0x18(%ebp),%esi 10dd1e: b9 04 00 00 00 mov $0x4,%ecx 10dd23: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10dd25: 31 d2 xor %edx,%edx return 0; } 10dd27: 89 d0 mov %edx,%eax 10dd29: 8d 65 f8 lea -0x8(%ebp),%esp 10dd2c: 5e pop %esi 10dd2d: 5f pop %edi 10dd2e: c9 leave 10dd2f: c3 ret =============================================================================== 00108000 : int chmod( const char *path, mode_t mode ) { 108000: 55 push %ebp 108001: 89 e5 mov %esp,%ebp 108003: 56 push %esi 108004: 53 push %ebx 108005: 83 ec 10 sub $0x10,%esp int status; rtems_filesystem_location_info_t loc; int result; status = rtems_filesystem_evaluate_path( path, 0, &loc, true ); 108008: 6a 01 push $0x1 10800a: 8d 75 e8 lea -0x18(%ebp),%esi 10800d: 56 push %esi 10800e: 6a 00 push $0x0 108010: ff 75 08 pushl 0x8(%ebp) 108013: e8 92 01 00 00 call 1081aa if ( status != 0 ) 108018: 83 c4 10 add $0x10,%esp 10801b: 83 cb ff or $0xffffffff,%ebx 10801e: 85 c0 test %eax,%eax 108020: 75 7d jne 10809f return -1; if ( !loc.handlers ){ 108022: 8b 45 ec mov -0x14(%ebp),%eax 108025: 85 c0 test %eax,%eax 108027: 75 24 jne 10804d <== ALWAYS TAKEN rtems_filesystem_freenode( &loc ); 108029: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10802c: 85 c0 test %eax,%eax <== NOT EXECUTED 10802e: 74 10 je 108040 <== NOT EXECUTED 108030: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 108033: 85 c0 test %eax,%eax <== NOT EXECUTED 108035: 74 09 je 108040 <== NOT EXECUTED 108037: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10803a: 56 push %esi <== NOT EXECUTED 10803b: ff d0 call *%eax <== NOT EXECUTED 10803d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); 108040: e8 2b a6 00 00 call 112670 <__errno> <== NOT EXECUTED 108045: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10804b: eb 29 jmp 108076 <== NOT EXECUTED } if ( !loc.handlers->fchmod_h ){ 10804d: 8b 40 1c mov 0x1c(%eax),%eax 108050: 85 c0 test %eax,%eax 108052: 75 27 jne 10807b <== ALWAYS TAKEN rtems_filesystem_freenode( &loc ); 108054: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 108057: 85 c0 test %eax,%eax <== NOT EXECUTED 108059: 74 10 je 10806b <== NOT EXECUTED 10805b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10805e: 85 c0 test %eax,%eax <== NOT EXECUTED 108060: 74 09 je 10806b <== NOT EXECUTED 108062: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108065: 56 push %esi <== NOT EXECUTED 108066: ff d0 call *%eax <== NOT EXECUTED 108068: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 10806b: e8 00 a6 00 00 call 112670 <__errno> <== NOT EXECUTED 108070: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 108076: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 108079: eb 24 jmp 10809f <== NOT EXECUTED } result = (*loc.handlers->fchmod_h)( &loc, mode ); 10807b: 52 push %edx 10807c: 52 push %edx 10807d: ff 75 0c pushl 0xc(%ebp) 108080: 56 push %esi 108081: ff d0 call *%eax 108083: 89 c3 mov %eax,%ebx rtems_filesystem_freenode( &loc ); 108085: 8b 45 f0 mov -0x10(%ebp),%eax 108088: 83 c4 10 add $0x10,%esp 10808b: 85 c0 test %eax,%eax 10808d: 74 10 je 10809f <== NEVER TAKEN 10808f: 8b 40 1c mov 0x1c(%eax),%eax 108092: 85 c0 test %eax,%eax 108094: 74 09 je 10809f <== NEVER TAKEN 108096: 83 ec 0c sub $0xc,%esp 108099: 56 push %esi 10809a: ff d0 call *%eax 10809c: 83 c4 10 add $0x10,%esp return result; } 10809f: 89 d8 mov %ebx,%eax 1080a1: 8d 65 f8 lea -0x8(%ebp),%esp 1080a4: 5b pop %ebx 1080a5: 5e pop %esi 1080a6: c9 leave 1080a7: c3 ret =============================================================================== 001080a8 : int chown( const char *path, uid_t owner, gid_t group ) { 1080a8: 55 push %ebp 1080a9: 89 e5 mov %esp,%ebp 1080ab: 57 push %edi 1080ac: 56 push %esi 1080ad: 53 push %ebx 1080ae: 83 ec 1c sub $0x1c,%esp 1080b1: 8b 45 0c mov 0xc(%ebp),%eax 1080b4: 66 89 45 e2 mov %ax,-0x1e(%ebp) 1080b8: 8b 7d 10 mov 0x10(%ebp),%edi rtems_filesystem_location_info_t loc; int result; if ( rtems_filesystem_evaluate_path( path, 0x00, &loc, true ) ) 1080bb: 6a 01 push $0x1 1080bd: 8d 75 e4 lea -0x1c(%ebp),%esi 1080c0: 56 push %esi 1080c1: 6a 00 push $0x0 1080c3: ff 75 08 pushl 0x8(%ebp) 1080c6: e8 df 00 00 00 call 1081aa 1080cb: 83 c4 10 add $0x10,%esp 1080ce: 83 cb ff or $0xffffffff,%ebx 1080d1: 85 c0 test %eax,%eax 1080d3: 75 53 jne 108128 return -1; if ( !loc.ops->chown_h ) { 1080d5: 8b 45 ec mov -0x14(%ebp),%eax 1080d8: 8b 50 18 mov 0x18(%eax),%edx 1080db: 85 d2 test %edx,%edx 1080dd: 75 20 jne 1080ff <== ALWAYS TAKEN rtems_filesystem_freenode( &loc ); 1080df: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1080e2: 85 c0 test %eax,%eax <== NOT EXECUTED 1080e4: 74 09 je 1080ef <== NOT EXECUTED 1080e6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1080e9: 56 push %esi <== NOT EXECUTED 1080ea: ff d0 call *%eax <== NOT EXECUTED 1080ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1080ef: e8 7c a5 00 00 call 112670 <__errno> <== NOT EXECUTED 1080f4: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1080fa: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 1080fd: eb 29 jmp 108128 <== NOT EXECUTED } result = (*loc.ops->chown_h)( &loc, owner, group ); 1080ff: 50 push %eax 108100: 0f b7 c7 movzwl %di,%eax 108103: 50 push %eax 108104: 0f b7 45 e2 movzwl -0x1e(%ebp),%eax 108108: 50 push %eax 108109: 56 push %esi 10810a: ff d2 call *%edx 10810c: 89 c3 mov %eax,%ebx rtems_filesystem_freenode( &loc ); 10810e: 8b 45 ec mov -0x14(%ebp),%eax 108111: 83 c4 10 add $0x10,%esp 108114: 85 c0 test %eax,%eax 108116: 74 10 je 108128 <== NEVER TAKEN 108118: 8b 40 1c mov 0x1c(%eax),%eax 10811b: 85 c0 test %eax,%eax 10811d: 74 09 je 108128 <== NEVER TAKEN 10811f: 83 ec 0c sub $0xc,%esp 108122: 56 push %esi 108123: ff d0 call *%eax 108125: 83 c4 10 add $0x10,%esp return result; } 108128: 89 d8 mov %ebx,%eax 10812a: 8d 65 f4 lea -0xc(%ebp),%esp 10812d: 5b pop %ebx 10812e: 5e pop %esi 10812f: 5f pop %edi 108130: c9 leave 108131: c3 ret =============================================================================== 00106908 : #include int chroot( const char *pathname ) { 106908: 55 push %ebp 106909: 89 e5 mov %esp,%ebp 10690b: 57 push %edi 10690c: 56 push %esi 10690d: 53 push %ebx 10690e: 83 ec 1c sub $0x1c,%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) { 106911: 81 3d ac e3 11 00 00 cmpl $0x120a00,0x11e3ac 106918: 0a 12 00 10691b: 75 1e jne 10693b <== NEVER TAKEN rtems_libio_set_private_env(); /* try to set a new private env*/ 10691d: e8 47 12 00 00 call 107b69 if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 106922: 81 3d ac e3 11 00 00 cmpl $0x120a00,0x11e3ac 106929: 0a 12 00 10692c: 75 0d jne 10693b <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); 10692e: e8 7d a0 00 00 call 1109b0 <__errno> <== NOT EXECUTED 106933: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 106939: eb 22 jmp 10695d <== NOT EXECUTED } result = chdir(pathname); 10693b: 83 ec 0c sub $0xc,%esp 10693e: ff 75 08 pushl 0x8(%ebp) 106941: e8 2e 73 00 00 call 10dc74 if (result) { 106946: 83 c4 10 add $0x10,%esp 106949: 85 c0 test %eax,%eax 10694b: 74 15 je 106962 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( errno ); 10694d: e8 5e a0 00 00 call 1109b0 <__errno> <== NOT EXECUTED 106952: 89 c3 mov %eax,%ebx <== NOT EXECUTED 106954: e8 57 a0 00 00 call 1109b0 <__errno> <== NOT EXECUTED 106959: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10695b: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10695d: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 106960: eb 4c jmp 1069ae <== NOT EXECUTED } /* clone the new root location */ if (rtems_filesystem_evaluate_path(".", 0, &loc, 0)) { 106962: 6a 00 push $0x0 106964: 8d 45 e4 lea -0x1c(%ebp),%eax 106967: 50 push %eax 106968: 6a 00 push $0x0 10696a: 68 f9 9c 11 00 push $0x119cf9 10696f: e8 3e 01 00 00 call 106ab2 106974: 83 c4 10 add $0x10,%esp 106977: 85 c0 test %eax,%eax 106979: 75 d2 jne 10694d <== 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); 10697b: a1 ac e3 11 00 mov 0x11e3ac,%eax 106980: 8b 50 1c mov 0x1c(%eax),%edx 106983: 85 d2 test %edx,%edx 106985: 74 13 je 10699a <== NEVER TAKEN 106987: 8b 52 1c mov 0x1c(%edx),%edx 10698a: 85 d2 test %edx,%edx 10698c: 74 0c je 10699a <== NEVER TAKEN 10698e: 83 ec 0c sub $0xc,%esp 106991: 83 c0 14 add $0x14,%eax 106994: 50 push %eax 106995: ff d2 call *%edx 106997: 83 c4 10 add $0x10,%esp rtems_filesystem_root = loc; 10699a: a1 ac e3 11 00 mov 0x11e3ac,%eax 10699f: 8d 78 14 lea 0x14(%eax),%edi 1069a2: 8d 75 e4 lea -0x1c(%ebp),%esi 1069a5: b9 04 00 00 00 mov $0x4,%ecx 1069aa: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 1069ac: 31 c0 xor %eax,%eax return 0; } 1069ae: 8d 65 f4 lea -0xc(%ebp),%esp 1069b1: 5b pop %ebx 1069b2: 5e pop %esi 1069b3: 5f pop %edi 1069b4: c9 leave 1069b5: c3 ret =============================================================================== 0010985c : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 10985c: 55 push %ebp 10985d: 89 e5 mov %esp,%ebp 10985f: 83 ec 08 sub $0x8,%esp 109862: 8b 45 08 mov 0x8(%ebp),%eax 109865: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 109868: 85 d2 test %edx,%edx 10986a: 74 3c je 1098a8 rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) 10986c: 83 f8 01 cmp $0x1,%eax 10986f: 75 0b jne 10987c _TOD_Get(tp); 109871: 83 ec 0c sub $0xc,%esp 109874: 52 push %edx 109875: e8 06 20 00 00 call 10b880 <_TOD_Get> 10987a: eb 13 jmp 10988f #ifdef CLOCK_MONOTONIC else if ( clock_id == CLOCK_MONOTONIC ) 10987c: 83 f8 04 cmp $0x4,%eax 10987f: 74 05 je 109886 <== NEVER TAKEN _TOD_Get_uptime(tp); #endif #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 109881: 83 f8 02 cmp $0x2,%eax 109884: 75 10 jne 109896 _TOD_Get_uptime(tp); 109886: 83 ec 0c sub $0xc,%esp 109889: 52 push %edx 10988a: e8 45 20 00 00 call 10b8d4 <_TOD_Get_uptime> 10988f: 31 c0 xor %eax,%eax 109891: 83 c4 10 add $0x10,%esp 109894: eb 20 jmp 1098b6 #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 109896: 83 f8 03 cmp $0x3,%eax 109899: 75 0d jne 1098a8 rtems_set_errno_and_return_minus_one( ENOSYS ); 10989b: e8 60 6f 00 00 call 110800 <__errno> 1098a0: c7 00 58 00 00 00 movl $0x58,(%eax) 1098a6: eb 0b jmp 1098b3 #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 1098a8: e8 53 6f 00 00 call 110800 <__errno> 1098ad: c7 00 16 00 00 00 movl $0x16,(%eax) 1098b3: 83 c8 ff or $0xffffffff,%eax return 0; } 1098b6: c9 leave 1098b7: c3 ret =============================================================================== 001098b8 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 1098b8: 55 push %ebp 1098b9: 89 e5 mov %esp,%ebp 1098bb: 83 ec 08 sub $0x8,%esp 1098be: 8b 45 08 mov 0x8(%ebp),%eax 1098c1: 8b 55 0c mov 0xc(%ebp),%edx if ( !tp ) 1098c4: 85 d2 test %edx,%edx 1098c6: 74 44 je 10990c <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 1098c8: 83 f8 01 cmp $0x1,%eax 1098cb: 75 28 jne 1098f5 if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 1098cd: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx) 1098d3: 76 37 jbe 10990c /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1098d5: a1 f0 10 12 00 mov 0x1210f0,%eax 1098da: 40 inc %eax 1098db: a3 f0 10 12 00 mov %eax,0x1210f0 rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); 1098e0: 83 ec 0c sub $0xc,%esp 1098e3: 52 push %edx 1098e4: e8 7b 20 00 00 call 10b964 <_TOD_Set> _Thread_Enable_dispatch(); 1098e9: e8 92 2f 00 00 call 10c880 <_Thread_Enable_dispatch> 1098ee: 31 c0 xor %eax,%eax 1098f0: 83 c4 10 add $0x10,%esp 1098f3: eb 25 jmp 10991a } #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 1098f5: 83 f8 02 cmp $0x2,%eax 1098f8: 74 05 je 1098ff rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 1098fa: 83 f8 03 cmp $0x3,%eax 1098fd: 75 0d jne 10990c rtems_set_errno_and_return_minus_one( ENOSYS ); 1098ff: e8 fc 6e 00 00 call 110800 <__errno> 109904: c7 00 58 00 00 00 movl $0x58,(%eax) 10990a: eb 0b jmp 109917 #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 10990c: e8 ef 6e 00 00 call 110800 <__errno> 109911: c7 00 16 00 00 00 movl $0x16,(%eax) 109917: 83 c8 ff or $0xffffffff,%eax return 0; } 10991a: c9 leave 10991b: c3 ret =============================================================================== 0010cd0c : #include int close( int fd ) { 10cd0c: 55 push %ebp 10cd0d: 89 e5 mov %esp,%ebp 10cd0f: 56 push %esi 10cd10: 53 push %ebx 10cd11: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_t *iop; rtems_status_code rc; rtems_libio_check_fd(fd); 10cd14: 3b 05 d8 92 11 00 cmp 0x1192d8,%eax 10cd1a: 73 0f jae 10cd2b iop = rtems_libio_iop(fd); 10cd1c: 6b d8 34 imul $0x34,%eax,%ebx 10cd1f: 03 1d 38 d6 11 00 add 0x11d638,%ebx rtems_libio_check_is_open(iop); 10cd25: f6 43 0d 01 testb $0x1,0xd(%ebx) 10cd29: 75 10 jne 10cd3b 10cd2b: e8 f8 23 00 00 call 10f128 <__errno> 10cd30: c7 00 09 00 00 00 movl $0x9,(%eax) 10cd36: 83 c8 ff or $0xffffffff,%eax 10cd39: eb 3f jmp 10cd7a rc = RTEMS_SUCCESSFUL; if ( iop->handlers->close_h ) 10cd3b: 8b 43 30 mov 0x30(%ebx),%eax 10cd3e: 8b 40 04 mov 0x4(%eax),%eax 10cd41: 31 f6 xor %esi,%esi 10cd43: 85 c0 test %eax,%eax 10cd45: 74 0b je 10cd52 <== NEVER TAKEN rc = (*iop->handlers->close_h)( iop ); 10cd47: 83 ec 0c sub $0xc,%esp 10cd4a: 53 push %ebx 10cd4b: ff d0 call *%eax 10cd4d: 89 c6 mov %eax,%esi 10cd4f: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &iop->pathinfo ); 10cd52: 8b 43 18 mov 0x18(%ebx),%eax 10cd55: 85 c0 test %eax,%eax 10cd57: 74 13 je 10cd6c <== NEVER TAKEN 10cd59: 8b 50 1c mov 0x1c(%eax),%edx 10cd5c: 85 d2 test %edx,%edx 10cd5e: 74 0c je 10cd6c 10cd60: 83 ec 0c sub $0xc,%esp 10cd63: 8d 43 10 lea 0x10(%ebx),%eax 10cd66: 50 push %eax 10cd67: ff d2 call *%edx 10cd69: 83 c4 10 add $0x10,%esp rtems_libio_free( iop ); 10cd6c: 83 ec 0c sub $0xc,%esp 10cd6f: 53 push %ebx 10cd70: e8 47 02 00 00 call 10cfbc return rc; 10cd75: 89 f0 mov %esi,%eax 10cd77: 83 c4 10 add $0x10,%esp } 10cd7a: 8d 65 f8 lea -0x8(%ebp),%esp 10cd7d: 5b pop %ebx 10cd7e: 5e pop %esi 10cd7f: c9 leave 10cd80: c3 ret =============================================================================== 001073e4 : * close a directory. */ int closedir( DIR *dirp ) { 1073e4: 55 push %ebp 1073e5: 89 e5 mov %esp,%ebp 1073e7: 56 push %esi 1073e8: 53 push %ebx 1073e9: 8b 75 08 mov 0x8(%ebp),%esi int fd; if ( !dirp ) 1073ec: 85 f6 test %esi,%esi 1073ee: 75 15 jne 107405 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EBADF ); 1073f0: e8 bb a1 00 00 call 1115b0 <__errno> <== NOT EXECUTED 1073f5: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED dirp->dd_fd = -1; dirp->dd_loc = 0; (void)free((void *)dirp->dd_buf); (void)free((void *)dirp); return(close(fd)); } 1073fb: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1073fe: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 107401: 5b pop %ebx <== NOT EXECUTED 107402: 5e pop %esi <== NOT EXECUTED 107403: c9 leave <== NOT EXECUTED 107404: c3 ret <== NOT EXECUTED int fd; if ( !dirp ) rtems_set_errno_and_return_minus_one( EBADF ); fd = dirp->dd_fd; 107405: 8b 1e mov (%esi),%ebx dirp->dd_fd = -1; 107407: c7 06 ff ff ff ff movl $0xffffffff,(%esi) dirp->dd_loc = 0; 10740d: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) (void)free((void *)dirp->dd_buf); 107414: 83 ec 0c sub $0xc,%esp 107417: ff 76 0c pushl 0xc(%esi) 10741a: e8 35 02 00 00 call 107654 (void)free((void *)dirp); 10741f: 89 34 24 mov %esi,(%esp) 107422: e8 2d 02 00 00 call 107654 return(close(fd)); 107427: 83 c4 10 add $0x10,%esp 10742a: 89 5d 08 mov %ebx,0x8(%ebp) } 10742d: 8d 65 f8 lea -0x8(%ebp),%esp 107430: 5b pop %ebx 107431: 5e pop %esi 107432: c9 leave fd = dirp->dd_fd; dirp->dd_fd = -1; dirp->dd_loc = 0; (void)free((void *)dirp->dd_buf); (void)free((void *)dirp); return(close(fd)); 107433: e9 00 00 00 00 jmp 107438 =============================================================================== 0010e6f2 : */ int device_close( rtems_libio_t *iop ) { 10e6f2: 55 push %ebp 10e6f3: 89 e5 mov %esp,%ebp 10e6f5: 83 ec 1c sub $0x1c,%esp 10e6f8: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_open_close_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 10e6fb: 8b 50 2c mov 0x2c(%eax),%edx args.iop = iop; 10e6fe: 89 45 f4 mov %eax,-0xc(%ebp) args.flags = 0; 10e701: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%ebp) args.mode = 0; 10e708: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) status = rtems_io_close( 10e70f: 8d 45 f4 lea -0xc(%ebp),%eax 10e712: 50 push %eax 10e713: ff 72 54 pushl 0x54(%edx) 10e716: ff 72 50 pushl 0x50(%edx) 10e719: e8 de 06 00 00 call 10edfc 10e71e: 89 c2 mov %eax,%edx the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) { 10e720: 83 c4 10 add $0x10,%esp 10e723: 31 c0 xor %eax,%eax 10e725: 85 d2 test %edx,%edx 10e727: 74 07 je 10e730 <== ALWAYS TAKEN return rtems_deviceio_errno(status); 10e729: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e72b: e8 bb fe ff ff call 10e5eb <== NOT EXECUTED } return 0; } 10e730: c9 leave 10e731: c3 ret =============================================================================== 0010e615 : int device_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 10e615: 55 push %ebp <== NOT EXECUTED 10e616: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e618: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10e61b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED rtems_libio_ioctl_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; args.iop = iop; 10e61e: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED args.command = command; 10e621: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e624: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.buffer = buffer; 10e627: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10e62a: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED the_jnode = iop->file_info; 10e62d: 8b 52 2c mov 0x2c(%edx),%edx <== NOT EXECUTED status = rtems_io_control( 10e630: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10e633: 50 push %eax <== NOT EXECUTED 10e634: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED 10e637: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED 10e63a: e8 fd 07 00 00 call 10ee3c <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10e63f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e642: 85 c0 test %eax,%eax <== NOT EXECUTED 10e644: 74 07 je 10e64d <== NOT EXECUTED return rtems_deviceio_errno(status); 10e646: e8 a0 ff ff ff call 10e5eb <== NOT EXECUTED 10e64b: eb 03 jmp 10e650 <== NOT EXECUTED return args.ioctl_return; 10e64d: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 10e650: c9 leave <== NOT EXECUTED 10e651: c3 ret <== NOT EXECUTED =============================================================================== 0010e732 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 10e732: 55 push %ebp 10e733: 89 e5 mov %esp,%ebp 10e735: 83 ec 1c sub $0x1c,%esp 10e738: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_open_close_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 10e73b: 8b 50 2c mov 0x2c(%eax),%edx args.iop = iop; 10e73e: 89 45 f4 mov %eax,-0xc(%ebp) args.flags = iop->flags; 10e741: 8b 40 0c mov 0xc(%eax),%eax 10e744: 89 45 f8 mov %eax,-0x8(%ebp) args.mode = mode; 10e747: 8b 45 14 mov 0x14(%ebp),%eax 10e74a: 89 45 fc mov %eax,-0x4(%ebp) status = rtems_io_open( 10e74d: 8d 45 f4 lea -0xc(%ebp),%eax 10e750: 50 push %eax 10e751: ff 72 54 pushl 0x54(%edx) 10e754: ff 72 50 pushl 0x50(%edx) 10e757: e8 20 07 00 00 call 10ee7c 10e75c: 89 c2 mov %eax,%edx the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10e75e: 83 c4 10 add $0x10,%esp 10e761: 31 c0 xor %eax,%eax 10e763: 85 d2 test %edx,%edx 10e765: 74 07 je 10e76e <== ALWAYS TAKEN return rtems_deviceio_errno(status); 10e767: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e769: e8 7d fe ff ff call 10e5eb <== NOT EXECUTED return 0; } 10e76e: c9 leave 10e76f: c3 ret =============================================================================== 0010e6a2 : ssize_t device_read( rtems_libio_t *iop, void *buffer, size_t count ) { 10e6a2: 55 push %ebp <== NOT EXECUTED 10e6a3: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e6a5: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10e6a8: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED rtems_libio_rw_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 10e6ab: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED args.iop = iop; 10e6ae: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED args.offset = iop->offset; 10e6b1: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10e6b4: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED args.buffer = buffer; 10e6b7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e6ba: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED args.count = count; 10e6bd: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10e6c0: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = iop->flags; 10e6c3: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10e6c6: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED args.bytes_moved = 0; 10e6c9: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_read( 10e6d0: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10e6d3: 50 push %eax <== NOT EXECUTED 10e6d4: ff 71 54 pushl 0x54(%ecx) <== NOT EXECUTED 10e6d7: ff 71 50 pushl 0x50(%ecx) <== NOT EXECUTED 10e6da: e8 dd 07 00 00 call 10eebc <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10e6df: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e6e2: 85 c0 test %eax,%eax <== NOT EXECUTED 10e6e4: 74 07 je 10e6ed <== NOT EXECUTED return rtems_deviceio_errno(status); 10e6e6: e8 00 ff ff ff call 10e5eb <== NOT EXECUTED 10e6eb: eb 03 jmp 10e6f0 <== NOT EXECUTED return (ssize_t) args.bytes_moved; 10e6ed: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 10e6f0: c9 leave <== NOT EXECUTED 10e6f1: c3 ret <== NOT EXECUTED =============================================================================== 0010e652 : ssize_t device_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 10e652: 55 push %ebp 10e653: 89 e5 mov %esp,%ebp 10e655: 83 ec 2c sub $0x2c,%esp 10e658: 8b 55 08 mov 0x8(%ebp),%edx rtems_libio_rw_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 10e65b: 8b 4a 2c mov 0x2c(%edx),%ecx args.iop = iop; 10e65e: 89 55 e8 mov %edx,-0x18(%ebp) args.offset = iop->offset; 10e661: 8b 42 08 mov 0x8(%edx),%eax 10e664: 89 45 ec mov %eax,-0x14(%ebp) args.buffer = (void *) buffer; 10e667: 8b 45 0c mov 0xc(%ebp),%eax 10e66a: 89 45 f0 mov %eax,-0x10(%ebp) args.count = count; 10e66d: 8b 45 10 mov 0x10(%ebp),%eax 10e670: 89 45 f4 mov %eax,-0xc(%ebp) args.flags = iop->flags; 10e673: 8b 42 0c mov 0xc(%edx),%eax 10e676: 89 45 f8 mov %eax,-0x8(%ebp) args.bytes_moved = 0; 10e679: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) status = rtems_io_write( 10e680: 8d 45 e8 lea -0x18(%ebp),%eax 10e683: 50 push %eax 10e684: ff 71 54 pushl 0x54(%ecx) 10e687: ff 71 50 pushl 0x50(%ecx) 10e68a: e8 6d 08 00 00 call 10eefc the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10e68f: 83 c4 10 add $0x10,%esp 10e692: 85 c0 test %eax,%eax 10e694: 74 07 je 10e69d <== ALWAYS TAKEN return rtems_deviceio_errno(status); 10e696: e8 50 ff ff ff call 10e5eb <== NOT EXECUTED 10e69b: eb 03 jmp 10e6a0 <== NOT EXECUTED return (ssize_t) args.bytes_moved; 10e69d: 8b 45 fc mov -0x4(%ebp),%eax } 10e6a0: c9 leave 10e6a1: c3 ret =============================================================================== 00107c82 : /* * Drain output queue */ static void drainOutput (struct rtems_termios_tty *tty) { 107c82: 55 push %ebp 107c83: 89 e5 mov %esp,%ebp 107c85: 53 push %ebx 107c86: 83 ec 04 sub $0x4,%esp 107c89: 89 c3 mov %eax,%ebx rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { 107c8b: 83 b8 b4 00 00 00 00 cmpl $0x0,0xb4(%eax) 107c92: 74 46 je 107cda <== NEVER TAKEN rtems_interrupt_disable (level); 107c94: 9c pushf 107c95: fa cli 107c96: 59 pop %ecx 107c97: eb 2f jmp 107cc8 while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) { tty->rawOutBufState = rob_wait; 107c99: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) 107ca0: 00 00 00 rtems_interrupt_enable (level); 107ca3: 51 push %ecx 107ca4: 9d popf sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, 107ca5: 51 push %ecx 107ca6: 6a 00 push $0x0 107ca8: 6a 00 push $0x0 107caa: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 107cb0: e8 bf 14 00 00 call 109174 RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 107cb5: 83 c4 10 add $0x10,%esp 107cb8: 85 c0 test %eax,%eax 107cba: 74 09 je 107cc5 <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 107cbc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107cbf: 50 push %eax <== NOT EXECUTED 107cc0: e8 cf 1a 00 00 call 109794 <== NOT EXECUTED rtems_interrupt_disable (level); 107cc5: 9c pushf 107cc6: fa cli 107cc7: 59 pop %ecx 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) { 107cc8: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx 107cce: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 107cd4: 39 c2 cmp %eax,%edx 107cd6: 75 c1 jne 107c99 RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } rtems_interrupt_enable (level); 107cd8: 51 push %ecx 107cd9: 9d popf } } 107cda: 8b 5d fc mov -0x4(%ebp),%ebx 107cdd: c9 leave 107cde: c3 ret =============================================================================== 00106ebc : int dup2( int fildes, int fildes2 ) { 106ebc: 55 push %ebp 106ebd: 89 e5 mov %esp,%ebp 106ebf: 57 push %edi 106ec0: 56 push %esi 106ec1: 53 push %ebx 106ec2: 83 ec 64 sub $0x64,%esp 106ec5: 8b 7d 08 mov 0x8(%ebp),%edi 106ec8: 8b 75 0c mov 0xc(%ebp),%esi /* * If fildes is not valid, then fildes2 should not be closed. */ status = fstat( fildes, &buf ); 106ecb: 8d 5d a8 lea -0x58(%ebp),%ebx 106ece: 53 push %ebx 106ecf: 57 push %edi 106ed0: e8 9b 04 00 00 call 107370 if ( status == -1 ) 106ed5: 83 c4 10 add $0x10,%esp 106ed8: 40 inc %eax 106ed9: 74 1e je 106ef9 <== NEVER TAKEN /* * If fildes2 is not valid, then we should not do anything either. */ status = fstat( fildes2, &buf ); 106edb: 52 push %edx 106edc: 52 push %edx 106edd: 53 push %ebx 106ede: 56 push %esi 106edf: e8 8c 04 00 00 call 107370 if ( status == -1 ) 106ee4: 83 c4 10 add $0x10,%esp 106ee7: 40 inc %eax 106ee8: 74 0f je 106ef9 <== ALWAYS TAKEN /* * This fcntl handles everything else. */ return fcntl( fildes, F_DUPFD, fildes2 ); 106eea: 50 push %eax <== NOT EXECUTED 106eeb: 56 push %esi <== NOT EXECUTED 106eec: 6a 00 push $0x0 <== NOT EXECUTED 106eee: 57 push %edi <== NOT EXECUTED 106eef: e8 bc 01 00 00 call 1070b0 <== NOT EXECUTED 106ef4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106ef7: eb 03 jmp 106efc <== NOT EXECUTED 106ef9: 83 c8 ff or $0xffffffff,%eax } 106efc: 8d 65 f4 lea -0xc(%ebp),%esp 106eff: 5b pop %ebx 106f00: 5e pop %esi 106f01: 5f pop %edi 106f02: c9 leave 106f03: c3 ret =============================================================================== 001078b7 : /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { 1078b7: 55 push %ebp <== NOT EXECUTED 1078b8: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1078ba: 53 push %ebx <== NOT EXECUTED 1078bb: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 1078be: 89 d3 mov %edx,%ebx <== NOT EXECUTED 1078c0: 88 c1 mov %al,%cl <== NOT EXECUTED if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) { 1078c2: f6 42 3d 02 testb $0x2,0x3d(%edx) <== NOT EXECUTED 1078c6: 74 38 je 107900 <== NOT EXECUTED 1078c8: 0f b6 d0 movzbl %al,%edx <== NOT EXECUTED 1078cb: a1 00 b7 11 00 mov 0x11b700,%eax <== NOT EXECUTED 1078d0: f6 04 10 20 testb $0x20,(%eax,%edx,1) <== NOT EXECUTED 1078d4: 74 2a je 107900 <== NOT EXECUTED 1078d6: 80 f9 09 cmp $0x9,%cl <== NOT EXECUTED 1078d9: 74 25 je 107900 <== NOT EXECUTED 1078db: 80 f9 0a cmp $0xa,%cl <== NOT EXECUTED 1078de: 74 20 je 107900 <== NOT EXECUTED char echobuf[2]; echobuf[0] = '^'; 1078e0: c6 45 fa 5e movb $0x5e,-0x6(%ebp) <== NOT EXECUTED echobuf[1] = c ^ 0x40; 1078e4: 83 f1 40 xor $0x40,%ecx <== NOT EXECUTED 1078e7: 88 4d fb mov %cl,-0x5(%ebp) <== NOT EXECUTED rtems_termios_puts (echobuf, 2, tty); 1078ea: 50 push %eax <== NOT EXECUTED 1078eb: 53 push %ebx <== NOT EXECUTED 1078ec: 6a 02 push $0x2 <== NOT EXECUTED 1078ee: 8d 45 fa lea -0x6(%ebp),%eax <== NOT EXECUTED 1078f1: 50 push %eax <== NOT EXECUTED 1078f2: e8 9c fd ff ff call 107693 <== NOT EXECUTED tty->column += 2; 1078f7: 83 43 28 02 addl $0x2,0x28(%ebx) <== NOT EXECUTED 1078fb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1078fe: eb 0a jmp 10790a <== NOT EXECUTED } else { oproc (c, tty); 107900: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 107903: 89 da mov %ebx,%edx <== NOT EXECUTED 107905: e8 9e fe ff ff call 1077a8 <== NOT EXECUTED } } 10790a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10790d: c9 leave <== NOT EXECUTED 10790e: c3 ret <== NOT EXECUTED =============================================================================== 0010790f : * 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) { 10790f: 55 push %ebp <== NOT EXECUTED 107910: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107912: 57 push %edi <== NOT EXECUTED 107913: 56 push %esi <== NOT EXECUTED 107914: 53 push %ebx <== NOT EXECUTED 107915: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107918: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10791a: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED if (tty->ccount == 0) 10791d: 83 78 20 00 cmpl $0x0,0x20(%eax) <== NOT EXECUTED 107921: 0f 84 4d 01 00 00 je 107a74 <== NOT EXECUTED return; if (lineFlag) { 107927: 85 d2 test %edx,%edx <== NOT EXECUTED 107929: 0f 84 3a 01 00 00 je 107a69 <== NOT EXECUTED if (!(tty->termios.c_lflag & ECHO)) { 10792f: 8b 40 3c mov 0x3c(%eax),%eax <== NOT EXECUTED 107932: a8 08 test $0x8,%al <== NOT EXECUTED 107934: 75 0c jne 107942 <== NOT EXECUTED tty->ccount = 0; 107936: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED 10793d: e9 32 01 00 00 jmp 107a74 <== NOT EXECUTED return; } if (!(tty->termios.c_lflag & ECHOE)) { 107942: a8 10 test $0x10,%al <== NOT EXECUTED 107944: 0f 85 1f 01 00 00 jne 107a69 <== NOT EXECUTED tty->ccount = 0; 10794a: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED echo (tty->termios.c_cc[VKILL], tty); 107951: 0f b6 43 44 movzbl 0x44(%ebx),%eax <== NOT EXECUTED 107955: 89 da mov %ebx,%edx <== NOT EXECUTED 107957: e8 5b ff ff ff call 1078b7 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) 10795c: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED 107960: 0f 84 0e 01 00 00 je 107a74 <== NOT EXECUTED echo ('\n', tty); 107966: 89 da mov %ebx,%edx <== NOT EXECUTED 107968: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10796d: eb 28 jmp 107997 <== NOT EXECUTED return; } } while (tty->ccount) { unsigned char c = tty->cbuf[--tty->ccount]; 10796f: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED 107972: 8d 41 ff lea -0x1(%ecx),%eax <== NOT EXECUTED 107975: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED 107978: 8a 54 0a ff mov -0x1(%edx,%ecx,1),%dl <== NOT EXECUTED if (tty->termios.c_lflag & ECHO) { 10797c: 8b 43 3c mov 0x3c(%ebx),%eax <== NOT EXECUTED 10797f: a8 08 test $0x8,%al <== NOT EXECUTED 107981: 0f 84 dc 00 00 00 je 107a63 <== NOT EXECUTED if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { 107987: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 10798b: 75 16 jne 1079a3 <== NOT EXECUTED 10798d: a8 10 test $0x10,%al <== NOT EXECUTED 10798f: 75 12 jne 1079a3 <== NOT EXECUTED echo (tty->termios.c_cc[VERASE], tty); 107991: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED 107995: 89 da mov %ebx,%edx <== NOT EXECUTED } } if (!lineFlag) break; } } 107997: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10799a: 5b pop %ebx <== NOT EXECUTED 10799b: 5e pop %esi <== NOT EXECUTED 10799c: 5f pop %edi <== NOT EXECUTED 10799d: 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); 10799e: e9 14 ff ff ff jmp 1078b7 <== NOT EXECUTED } else if (c == '\t') { 1079a3: 80 fa 09 cmp $0x9,%dl <== NOT EXECUTED 1079a6: 8b 3d 00 b7 11 00 mov 0x11b700,%edi <== NOT EXECUTED 1079ac: 75 5e jne 107a0c <== NOT EXECUTED int col = tty->read_start_column; 1079ae: 8b 73 2c mov 0x2c(%ebx),%esi <== NOT EXECUTED while (i != tty->ccount) { c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; } else if (iscntrl (c)) { 1079b1: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED if (tty->termios.c_lflag & ECHOCTL) 1079b6: 25 00 02 00 00 and $0x200,%eax <== NOT EXECUTED 1079bb: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 1079be: eb 2b jmp 1079eb <== NOT EXECUTED /* * Find the character before the tab */ while (i != tty->ccount) { c = tty->cbuf[i++]; 1079c0: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 1079c3: 8a 44 10 ff mov -0x1(%eax,%edx,1),%al <== NOT EXECUTED if (c == '\t') { 1079c7: 3c 09 cmp $0x9,%al <== NOT EXECUTED 1079c9: 75 0a jne 1079d5 <== NOT EXECUTED col = (col | 7) + 1; 1079cb: 89 f0 mov %esi,%eax <== NOT EXECUTED 1079cd: 83 c8 07 or $0x7,%eax <== NOT EXECUTED 1079d0: 8d 70 01 lea 0x1(%eax),%esi <== NOT EXECUTED 1079d3: eb 15 jmp 1079ea <== NOT EXECUTED } else if (iscntrl (c)) { 1079d5: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 1079d8: f6 04 07 20 testb $0x20,(%edi,%eax,1) <== NOT EXECUTED 1079dc: 74 0b je 1079e9 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOCTL) 1079de: 83 7d ec 00 cmpl $0x0,-0x14(%ebp) <== NOT EXECUTED 1079e2: 74 06 je 1079ea <== NOT EXECUTED col += 2; 1079e4: 83 c6 02 add $0x2,%esi <== NOT EXECUTED 1079e7: eb 01 jmp 1079ea <== NOT EXECUTED } else { col++; 1079e9: 46 inc %esi <== NOT EXECUTED 1079ea: 42 inc %edx <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 1079eb: 39 ca cmp %ecx,%edx <== NOT EXECUTED 1079ed: 75 d1 jne 1079c0 <== NOT EXECUTED 1079ef: eb 14 jmp 107a05 <== NOT EXECUTED /* * Back up over the tab */ while (tty->column > col) { rtems_termios_puts ("\b", 1, tty); 1079f1: 50 push %eax <== NOT EXECUTED 1079f2: 53 push %ebx <== NOT EXECUTED 1079f3: 6a 01 push $0x1 <== NOT EXECUTED 1079f5: 68 54 72 11 00 push $0x117254 <== NOT EXECUTED 1079fa: e8 94 fc ff ff call 107693 <== NOT EXECUTED tty->column--; 1079ff: ff 4b 28 decl 0x28(%ebx) <== NOT EXECUTED 107a02: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Back up over the tab */ while (tty->column > col) { 107a05: 39 73 28 cmp %esi,0x28(%ebx) <== NOT EXECUTED 107a08: 7f e7 jg 1079f1 <== NOT EXECUTED 107a0a: eb 57 jmp 107a63 <== NOT EXECUTED rtems_termios_puts ("\b", 1, tty); tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { 107a0c: 0f b6 f2 movzbl %dl,%esi <== NOT EXECUTED 107a0f: f6 04 37 20 testb $0x20,(%edi,%esi,1) <== NOT EXECUTED 107a13: 74 21 je 107a36 <== NOT EXECUTED 107a15: f6 c4 02 test $0x2,%ah <== NOT EXECUTED 107a18: 74 1c je 107a36 <== NOT EXECUTED rtems_termios_puts ("\b \b", 3, tty); 107a1a: 50 push %eax <== NOT EXECUTED 107a1b: 53 push %ebx <== NOT EXECUTED 107a1c: 6a 03 push $0x3 <== NOT EXECUTED 107a1e: 68 52 72 11 00 push $0x117252 <== NOT EXECUTED 107a23: e8 6b fc ff ff call 107693 <== NOT EXECUTED if (tty->column) 107a28: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 107a2b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107a2e: 85 c0 test %eax,%eax <== NOT EXECUTED 107a30: 74 04 je 107a36 <== NOT EXECUTED tty->column--; 107a32: 48 dec %eax <== NOT EXECUTED 107a33: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED } if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) { 107a36: a1 00 b7 11 00 mov 0x11b700,%eax <== NOT EXECUTED 107a3b: f6 04 30 20 testb $0x20,(%eax,%esi,1) <== NOT EXECUTED 107a3f: 74 06 je 107a47 <== NOT EXECUTED 107a41: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED 107a45: 74 1c je 107a63 <== NOT EXECUTED rtems_termios_puts ("\b \b", 3, tty); 107a47: 50 push %eax <== NOT EXECUTED 107a48: 53 push %ebx <== NOT EXECUTED 107a49: 6a 03 push $0x3 <== NOT EXECUTED 107a4b: 68 52 72 11 00 push $0x117252 <== NOT EXECUTED 107a50: e8 3e fc ff ff call 107693 <== NOT EXECUTED if (tty->column) 107a55: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 107a58: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107a5b: 85 c0 test %eax,%eax <== NOT EXECUTED 107a5d: 74 04 je 107a63 <== NOT EXECUTED tty->column--; 107a5f: 48 dec %eax <== NOT EXECUTED 107a60: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED } } } if (!lineFlag) 107a63: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 107a67: 74 0b je 107a74 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) echo ('\n', tty); return; } } while (tty->ccount) { 107a69: 8b 4b 20 mov 0x20(%ebx),%ecx <== NOT EXECUTED 107a6c: 85 c9 test %ecx,%ecx <== NOT EXECUTED 107a6e: 0f 85 fb fe ff ff jne 10796f <== NOT EXECUTED } } if (!lineFlag) break; } } 107a74: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107a77: 5b pop %ebx <== NOT EXECUTED 107a78: 5e pop %esi <== NOT EXECUTED 107a79: 5f pop %edi <== NOT EXECUTED 107a7a: c9 leave <== NOT EXECUTED 107a7b: c3 ret <== NOT EXECUTED =============================================================================== 001070b0 : int fcntl( int fd, int cmd, ... ) { 1070b0: 55 push %ebp 1070b1: 89 e5 mov %esp,%ebp 1070b3: 57 push %edi 1070b4: 56 push %esi 1070b5: 53 push %ebx 1070b6: 83 ec 0c sub $0xc,%esp 1070b9: 8b 45 08 mov 0x8(%ebp),%eax 1070bc: 8d 55 10 lea 0x10(%ebp),%edx int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 1070bf: 8b 0d 38 d0 11 00 mov 0x11d038,%ecx 1070c5: 39 c8 cmp %ecx,%eax 1070c7: 73 14 jae 1070dd <== NEVER TAKEN iop = rtems_libio_iop( fd ); 1070c9: 8b 35 68 13 12 00 mov 0x121368,%esi 1070cf: 6b c0 34 imul $0x34,%eax,%eax 1070d2: 8d 1c 06 lea (%esi,%eax,1),%ebx rtems_libio_check_is_open(iop); 1070d5: 8b 43 0c mov 0xc(%ebx),%eax 1070d8: f6 c4 01 test $0x1,%ah 1070db: 75 10 jne 1070ed <== ALWAYS TAKEN 1070dd: e8 fe 9e 00 00 call 110fe0 <__errno> <== NOT EXECUTED 1070e2: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 1070e8: e9 fc 00 00 00 jmp 1071e9 <== NOT EXECUTED /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 1070ed: 83 7d 0c 09 cmpl $0x9,0xc(%ebp) 1070f1: 0f 87 bf 00 00 00 ja 1071b6 1070f7: 8b 7d 0c mov 0xc(%ebp),%edi 1070fa: ff 24 bd 08 ad 11 00 jmp *0x11ad08(,%edi,4) case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); 107101: 8b 02 mov (%edx),%eax if ( fd2 ) 107103: 85 c0 test %eax,%eax 107105: 74 0e je 107115 <== ALWAYS TAKEN diop = rtems_libio_iop( fd2 ); 107107: 31 d2 xor %edx,%edx <== NOT EXECUTED 107109: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10710b: 73 1a jae 107127 <== NOT EXECUTED 10710d: 6b c0 34 imul $0x34,%eax,%eax <== NOT EXECUTED 107110: 8d 14 06 lea (%esi,%eax,1),%edx <== NOT EXECUTED 107113: eb 12 jmp 107127 <== NOT EXECUTED else { /* allocate a file control block */ diop = rtems_libio_allocate(); 107115: e8 93 05 00 00 call 1076ad 10711a: 89 c2 mov %eax,%edx if ( diop == 0 ) { 10711c: 83 ce ff or $0xffffffff,%esi 10711f: 85 c0 test %eax,%eax 107121: 0f 84 c5 00 00 00 je 1071ec <== NEVER TAKEN ret = -1; break; } } diop->handlers = iop->handlers; 107127: 8b 43 30 mov 0x30(%ebx),%eax 10712a: 89 42 30 mov %eax,0x30(%edx) diop->file_info = iop->file_info; 10712d: 8b 43 2c mov 0x2c(%ebx),%eax 107130: 89 42 2c mov %eax,0x2c(%edx) diop->flags = iop->flags; 107133: 8b 43 0c mov 0xc(%ebx),%eax 107136: 89 42 0c mov %eax,0xc(%edx) diop->pathinfo = iop->pathinfo; 107139: 8d 7a 10 lea 0x10(%edx),%edi 10713c: 8d 73 10 lea 0x10(%ebx),%esi 10713f: b9 04 00 00 00 mov $0x4,%ecx 107144: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ret = (int) (diop - rtems_libio_iops); 107146: 2b 15 68 13 12 00 sub 0x121368,%edx 10714c: c1 fa 02 sar $0x2,%edx 10714f: 69 f2 c5 4e ec c4 imul $0xc4ec4ec5,%edx,%esi 107155: eb 6c jmp 1071c3 break; case F_GETFD: /* get f_flags */ ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0); 107157: 89 c6 mov %eax,%esi 107159: c1 ee 0b shr $0xb,%esi 10715c: 83 e6 01 and $0x1,%esi 10715f: eb 66 jmp 1071c7 * 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 ) ) 107161: 83 3a 00 cmpl $0x0,(%edx) 107164: 74 05 je 10716b <== NEVER TAKEN iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; 107166: 80 cc 08 or $0x8,%ah 107169: eb 03 jmp 10716e else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; 10716b: 80 e4 f7 and $0xf7,%ah <== NOT EXECUTED 10716e: 89 43 0c mov %eax,0xc(%ebx) 107171: 31 f6 xor %esi,%esi 107173: eb 52 jmp 1071c7 break; case F_GETFL: /* more flags (cloexec) */ ret = rtems_libio_to_fcntl_flags( iop->flags ); 107175: 83 ec 0c sub $0xc,%esp 107178: 50 push %eax 107179: e8 e2 03 00 00 call 107560 10717e: 89 c6 mov %eax,%esi 107180: 83 c4 10 add $0x10,%esp 107183: eb 3e jmp 1071c3 break; case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); 107185: 83 ec 0c sub $0xc,%esp 107188: ff 32 pushl (%edx) 10718a: e8 b0 05 00 00 call 10773f /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = (iop->flags & ~mask) | (flags & mask); 10718f: 25 01 02 00 00 and $0x201,%eax 107194: 8b 53 0c mov 0xc(%ebx),%edx 107197: 81 e2 fe fd ff ff and $0xfffffdfe,%edx 10719d: 09 c2 or %eax,%edx 10719f: 89 53 0c mov %edx,0xc(%ebx) 1071a2: 31 f6 xor %esi,%esi 1071a4: 83 c4 10 add $0x10,%esp 1071a7: eb 1e jmp 1071c7 errno = ENOTSUP; ret = -1; break; case F_GETOWN: /* for sockets. */ errno = ENOTSUP; 1071a9: e8 32 9e 00 00 call 110fe0 <__errno> 1071ae: c7 00 86 00 00 00 movl $0x86,(%eax) 1071b4: eb 33 jmp 1071e9 ret = -1; break; default: errno = EINVAL; 1071b6: e8 25 9e 00 00 call 110fe0 <__errno> 1071bb: c7 00 16 00 00 00 movl $0x16,(%eax) 1071c1: eb 26 jmp 1071e9 /* * If we got this far successfully, then we give the optional * filesystem specific handler a chance to process this. */ if (ret >= 0) { 1071c3: 85 f6 test %esi,%esi 1071c5: 78 25 js 1071ec <== NEVER TAKEN if (iop->handlers->fcntl_h) { 1071c7: 8b 43 30 mov 0x30(%ebx),%eax 1071ca: 8b 40 30 mov 0x30(%eax),%eax 1071cd: 85 c0 test %eax,%eax 1071cf: 74 1b je 1071ec <== NEVER TAKEN int err = (*iop->handlers->fcntl_h)( cmd, iop ); 1071d1: 52 push %edx 1071d2: 52 push %edx 1071d3: 53 push %ebx 1071d4: ff 75 0c pushl 0xc(%ebp) 1071d7: ff d0 call *%eax 1071d9: 89 c3 mov %eax,%ebx if (err) { 1071db: 83 c4 10 add $0x10,%esp 1071de: 85 c0 test %eax,%eax 1071e0: 74 0a je 1071ec <== ALWAYS TAKEN errno = err; 1071e2: e8 f9 9d 00 00 call 110fe0 <__errno> <== NOT EXECUTED 1071e7: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 1071e9: 83 ce ff or $0xffffffff,%esi va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; } 1071ec: 89 f0 mov %esi,%eax 1071ee: 8d 65 f4 lea -0xc(%ebp),%esp 1071f1: 5b pop %ebx 1071f2: 5e pop %esi 1071f3: 5f pop %edi 1071f4: c9 leave 1071f5: c3 ret =============================================================================== 00107214 : #include int fdatasync( int fd ) { 107214: 55 push %ebp 107215: 89 e5 mov %esp,%ebp 107217: 83 ec 08 sub $0x8,%esp 10721a: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_t *iop; rtems_libio_check_fd( fd ); 10721d: 3b 05 38 d0 11 00 cmp 0x11d038,%eax 107223: 73 15 jae 10723a <== NEVER TAKEN iop = rtems_libio_iop( fd ); 107225: 6b d0 34 imul $0x34,%eax,%edx 107228: 03 15 68 13 12 00 add 0x121368,%edx rtems_libio_check_is_open(iop); 10722e: 8b 42 0c mov 0xc(%edx),%eax 107231: f6 c4 01 test $0x1,%ah 107234: 74 04 je 10723a <== NEVER TAKEN rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF ); 107236: a8 04 test $0x4,%al 107238: 75 0d jne 107247 10723a: e8 a1 9d 00 00 call 110fe0 <__errno> 10723f: c7 00 09 00 00 00 movl $0x9,(%eax) 107245: eb 1d jmp 107264 /* * Now process the fdatasync(). */ if ( !iop->handlers->fdatasync_h ) 107247: 8b 42 30 mov 0x30(%edx),%eax 10724a: 8b 48 2c mov 0x2c(%eax),%ecx 10724d: 85 c9 test %ecx,%ecx 10724f: 75 0d jne 10725e <== NEVER TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); 107251: e8 8a 9d 00 00 call 110fe0 <__errno> 107256: c7 00 86 00 00 00 movl $0x86,(%eax) 10725c: eb 06 jmp 107264 return (*iop->handlers->fdatasync_h)( iop ); 10725e: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 107261: c9 leave <== NOT EXECUTED */ if ( !iop->handlers->fdatasync_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->fdatasync_h)( iop ); 107262: ff e1 jmp *%ecx <== NOT EXECUTED } 107264: 83 c8 ff or $0xffffffff,%eax 107267: c9 leave 107268: c3 ret =============================================================================== 0010a432 : bool file_systems_below_this_mountpoint( const char *path, rtems_filesystem_location_info_t *fs_root_loc, rtems_filesystem_mount_table_entry_t *fs_to_unmount ) { 10a432: 55 push %ebp <== NOT EXECUTED 10a433: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a435: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED /* * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; 10a438: 8b 15 94 29 12 00 mov 0x122994,%edx <== NOT EXECUTED 10a43e: eb 0e jmp 10a44e <== NOT EXECUTED !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); the_node = the_node->next ) { the_mount_entry = ( rtems_filesystem_mount_table_entry_t * )the_node; if (the_mount_entry->mt_point_node.mt_entry == fs_root_loc->mt_entry ) { 10a440: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED 10a443: 3b 41 0c cmp 0xc(%ecx),%eax <== NOT EXECUTED 10a446: 75 04 jne 10a44c <== NOT EXECUTED 10a448: b0 01 mov $0x1,%al <== NOT EXECUTED 10a44a: eb 0c jmp 10a458 <== NOT EXECUTED * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); the_node = the_node->next ) { 10a44c: 8b 12 mov (%edx),%edx <== NOT EXECUTED * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); 10a44e: 81 fa 98 29 12 00 cmp $0x122998,%edx <== NOT EXECUTED 10a454: 75 ea jne 10a440 <== NOT EXECUTED 10a456: 31 c0 xor %eax,%eax <== NOT EXECUTED return true; } } return false; } 10a458: c9 leave <== NOT EXECUTED 10a459: c3 ret <== NOT EXECUTED =============================================================================== 0010726c : long fpathconf( int fd, int name ) { 10726c: 55 push %ebp 10726d: 89 e5 mov %esp,%ebp 10726f: 83 ec 08 sub $0x8,%esp 107272: 8b 45 08 mov 0x8(%ebp),%eax 107275: 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); 107278: 3b 05 38 d0 11 00 cmp 0x11d038,%eax 10727e: 73 0f jae 10728f iop = rtems_libio_iop(fd); 107280: 6b c0 34 imul $0x34,%eax,%eax 107283: 03 05 68 13 12 00 add 0x121368,%eax rtems_libio_check_is_open(iop); 107289: f6 40 0d 01 testb $0x1,0xd(%eax) 10728d: 75 0d jne 10729c <== ALWAYS TAKEN 10728f: e8 4c 9d 00 00 call 110fe0 <__errno> 107294: c7 00 09 00 00 00 movl $0x9,(%eax) 10729a: eb 56 jmp 1072f2 /* * Now process the information request. */ the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options; 10729c: 8b 40 1c mov 0x1c(%eax),%eax switch ( name ) { 10729f: 83 fa 0b cmp $0xb,%edx 1072a2: 77 43 ja 1072e7 1072a4: ff 24 95 30 ad 11 00 jmp *0x11ad30(,%edx,4) case _PC_LINK_MAX: return_value = the_limits->link_max; 1072ab: 8b 40 30 mov 0x30(%eax),%eax 1072ae: eb 45 jmp 1072f5 break; case _PC_MAX_CANON: return_value = the_limits->max_canon; 1072b0: 8b 40 34 mov 0x34(%eax),%eax 1072b3: eb 40 jmp 1072f5 break; case _PC_MAX_INPUT: return_value = the_limits->max_input; 1072b5: 8b 40 38 mov 0x38(%eax),%eax 1072b8: eb 3b jmp 1072f5 break; case _PC_NAME_MAX: return_value = the_limits->name_max; 1072ba: 8b 40 3c mov 0x3c(%eax),%eax 1072bd: eb 36 jmp 1072f5 break; case _PC_PATH_MAX: return_value = the_limits->path_max; 1072bf: 8b 40 40 mov 0x40(%eax),%eax 1072c2: eb 31 jmp 1072f5 break; case _PC_PIPE_BUF: return_value = the_limits->pipe_buf; 1072c4: 8b 40 44 mov 0x44(%eax),%eax 1072c7: eb 2c jmp 1072f5 break; case _PC_CHOWN_RESTRICTED: return_value = the_limits->posix_chown_restrictions; 1072c9: 8b 40 4c mov 0x4c(%eax),%eax 1072cc: eb 27 jmp 1072f5 break; case _PC_NO_TRUNC: return_value = the_limits->posix_no_trunc; 1072ce: 8b 40 50 mov 0x50(%eax),%eax 1072d1: eb 22 jmp 1072f5 break; case _PC_VDISABLE: return_value = the_limits->posix_vdisable; 1072d3: 8b 40 5c mov 0x5c(%eax),%eax 1072d6: eb 1d jmp 1072f5 break; case _PC_ASYNC_IO: return_value = the_limits->posix_async_io; 1072d8: 8b 40 48 mov 0x48(%eax),%eax 1072db: eb 18 jmp 1072f5 break; case _PC_PRIO_IO: return_value = the_limits->posix_prio_io; 1072dd: 8b 40 54 mov 0x54(%eax),%eax 1072e0: eb 13 jmp 1072f5 break; case _PC_SYNC_IO: return_value = the_limits->posix_sync_io; 1072e2: 8b 40 58 mov 0x58(%eax),%eax 1072e5: eb 0e jmp 1072f5 break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 1072e7: e8 f4 9c 00 00 call 110fe0 <__errno> 1072ec: c7 00 16 00 00 00 movl $0x16,(%eax) 1072f2: 83 c8 ff or $0xffffffff,%eax break; } return return_value; } 1072f5: c9 leave 1072f6: c3 ret =============================================================================== 00106478 : void free( void *ptr ) { MSBUMP(free_calls, 1); 106478: 55 push %ebp 106479: 89 e5 mov %esp,%ebp 10647b: 53 push %ebx 10647c: 83 ec 04 sub $0x4,%esp 10647f: 8b 5d 08 mov 0x8(%ebp),%ebx 106482: ff 05 b4 d6 11 00 incl 0x11d6b4 if ( !ptr ) 106488: 85 db test %ebx,%ebx 10648a: 74 5f je 1064eb /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 10648c: 83 3d 38 d9 11 00 03 cmpl $0x3,0x11d938 106493: 75 15 jne 1064aa <== NEVER TAKEN 106495: e8 de 00 00 00 call 106578 10649a: 84 c0 test %al,%al 10649c: 75 0c jne 1064aa <== ALWAYS TAKEN !malloc_is_system_state_OK() ) { malloc_deferred_free(ptr); 10649e: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED RTEMS_Malloc_Heap.begin, RTEMS_Malloc_Heap.end ); } } 1064a1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1064a4: c9 leave <== NOT EXECUTED * 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); 1064a5: e9 0d 01 00 00 jmp 1065b7 <== NOT EXECUTED #endif /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 1064aa: a1 d4 bb 11 00 mov 0x11bbd4,%eax 1064af: 85 c0 test %eax,%eax 1064b1: 74 0a je 1064bd <== ALWAYS TAKEN (*rtems_malloc_statistics_helpers->at_free)(ptr); 1064b3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1064b6: 53 push %ebx <== NOT EXECUTED 1064b7: ff 50 08 call *0x8(%eax) <== NOT EXECUTED 1064ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( !_Protected_heap_Free( &RTEMS_Malloc_Heap, ptr ) ) { 1064bd: 50 push %eax 1064be: 50 push %eax 1064bf: 53 push %ebx 1064c0: 68 50 d6 11 00 push $0x11d650 1064c5: e8 a2 44 00 00 call 10a96c <_Protected_heap_Free> 1064ca: 83 c4 10 add $0x10,%esp 1064cd: 84 c0 test %al,%al 1064cf: 75 1a jne 1064eb <== ALWAYS TAKEN printk( "Program heap: free of bad pointer %p -- range %p - %p \n", 1064d1: ff 35 6c d6 11 00 pushl 0x11d66c <== NOT EXECUTED 1064d7: ff 35 68 d6 11 00 pushl 0x11d668 <== NOT EXECUTED 1064dd: 53 push %ebx <== NOT EXECUTED 1064de: 68 fc 71 11 00 push $0x1171fc <== NOT EXECUTED 1064e3: e8 76 0b 00 00 call 10705e <== NOT EXECUTED 1064e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED RTEMS_Malloc_Heap.begin, RTEMS_Malloc_Heap.end ); } } 1064eb: 8b 5d fc mov -0x4(%ebp),%ebx 1064ee: c9 leave 1064ef: c3 ret =============================================================================== 00107a74 : * NOTE: this must be called with * thread dispatching disabled! */ static void free_user_env(void *venv) { 107a74: 55 push %ebp <== NOT EXECUTED 107a75: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107a77: 53 push %ebx <== NOT EXECUTED 107a78: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 107a7b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED rtems_user_env_t *env = (rtems_user_env_t*) venv ; if (env != &rtems_global_user_env 107a7e: 81 fb 00 0a 12 00 cmp $0x120a00,%ebx <== NOT EXECUTED 107a84: 74 40 je 107ac6 <== NOT EXECUTED #ifdef HAVE_USERENV_REFCNT && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); 107a86: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 107a89: 85 c0 test %eax,%eax <== NOT EXECUTED 107a8b: 74 13 je 107aa0 <== NOT EXECUTED 107a8d: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 107a90: 85 d2 test %edx,%edx <== NOT EXECUTED 107a92: 74 0c je 107aa0 <== NOT EXECUTED 107a94: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107a97: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 107a9a: 50 push %eax <== NOT EXECUTED 107a9b: ff d2 call *%edx <== NOT EXECUTED 107a9d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &env->root_directory); 107aa0: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 107aa3: 85 c0 test %eax,%eax <== NOT EXECUTED 107aa5: 74 13 je 107aba <== NOT EXECUTED 107aa7: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 107aaa: 85 d2 test %edx,%edx <== NOT EXECUTED 107aac: 74 0c je 107aba <== NOT EXECUTED 107aae: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107ab1: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 107ab4: 50 push %eax <== NOT EXECUTED 107ab5: ff d2 call *%edx <== NOT EXECUTED 107ab7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free(env); 107aba: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 107abd: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 107ac0: c9 leave <== NOT EXECUTED && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); rtems_filesystem_freenode( &env->root_directory); free(env); 107ac1: e9 0e f1 ff ff jmp 106bd4 <== NOT EXECUTED } } 107ac6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 107ac9: c9 leave <== NOT EXECUTED 107aca: c3 ret <== NOT EXECUTED =============================================================================== 00115538 : int fstat( int fd, struct stat *sbuf ) { 115538: 55 push %ebp 115539: 89 e5 mov %esp,%ebp 11553b: 57 push %edi 11553c: 56 push %esi 11553d: 53 push %ebx 11553e: 83 ec 0c sub $0xc,%esp 115541: 8b 45 08 mov 0x8(%ebp),%eax 115544: 8b 75 0c mov 0xc(%ebp),%esi /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) 115547: 85 f6 test %esi,%esi 115549: 75 0d jne 115558 rtems_set_errno_and_return_minus_one( EFAULT ); 11554b: e8 d8 9b ff ff call 10f128 <__errno> 115550: c7 00 0e 00 00 00 movl $0xe,(%eax) 115556: eb 54 jmp 1155ac /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); 115558: 3b 05 d8 92 11 00 cmp 0x1192d8,%eax 11555e: 73 57 jae 1155b7 115560: 6b d8 34 imul $0x34,%eax,%ebx 115563: 03 1d 38 d6 11 00 add 0x11d638,%ebx rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); 115569: f6 43 0d 01 testb $0x1,0xd(%ebx) 11556d: 74 48 je 1155b7 <== NEVER TAKEN if ( !iop->handlers ) 11556f: 8b 43 30 mov 0x30(%ebx),%eax 115572: 85 c0 test %eax,%eax 115574: 74 41 je 1155b7 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->fstat_h ) 115576: 83 78 18 00 cmpl $0x0,0x18(%eax) 11557a: 75 0d jne 115589 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); 11557c: e8 a7 9b ff ff call 10f128 <__errno> <== NOT EXECUTED 115581: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 115587: eb 23 jmp 1155ac <== NOT EXECUTED /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); 115589: b9 13 00 00 00 mov $0x13,%ecx 11558e: 31 c0 xor %eax,%eax 115590: 89 f7 mov %esi,%edi 115592: f3 ab rep stos %eax,%es:(%edi) return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf ); 115594: 8b 53 30 mov 0x30(%ebx),%edx 115597: 89 75 0c mov %esi,0xc(%ebp) 11559a: 8d 43 10 lea 0x10(%ebx),%eax 11559d: 89 45 08 mov %eax,0x8(%ebp) 1155a0: 8b 4a 18 mov 0x18(%edx),%ecx } 1155a3: 83 c4 0c add $0xc,%esp 1155a6: 5b pop %ebx 1155a7: 5e pop %esi 1155a8: 5f pop %edi 1155a9: c9 leave * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf ); 1155aa: ff e1 jmp *%ecx } 1155ac: 83 c8 ff or $0xffffffff,%eax 1155af: 83 c4 0c add $0xc,%esp 1155b2: 5b pop %ebx 1155b3: 5e pop %esi 1155b4: 5f pop %edi 1155b5: c9 leave 1155b6: c3 ret /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); rtems_libio_check_fd( fd ); 1155b7: e8 6c 9b ff ff call 10f128 <__errno> 1155bc: c7 00 09 00 00 00 movl $0x9,(%eax) 1155c2: eb e8 jmp 1155ac =============================================================================== 00107414 : #include int fsync( int fd ) { 107414: 55 push %ebp 107415: 89 e5 mov %esp,%ebp 107417: 83 ec 08 sub $0x8,%esp 10741a: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_t *iop; rtems_libio_check_fd( fd ); 10741d: 3b 05 38 d0 11 00 cmp 0x11d038,%eax 107423: 73 16 jae 10743b <== NEVER TAKEN iop = rtems_libio_iop( fd ); 107425: 6b c0 34 imul $0x34,%eax,%eax 107428: 03 05 68 13 12 00 add 0x121368,%eax rtems_libio_check_is_open(iop); 10742e: f6 40 0d 01 testb $0x1,0xd(%eax) 107432: 74 07 je 10743b <== NEVER TAKEN /* * Now process the fsync(). */ if ( !iop->handlers ) 107434: 8b 50 30 mov 0x30(%eax),%edx 107437: 85 d2 test %edx,%edx 107439: 75 0d jne 107448 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EBADF ); 10743b: e8 a0 9b 00 00 call 110fe0 <__errno> <== NOT EXECUTED 107440: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 107446: eb 1a jmp 107462 <== NOT EXECUTED if ( !iop->handlers->fsync_h ) 107448: 8b 4a 28 mov 0x28(%edx),%ecx 10744b: 85 c9 test %ecx,%ecx 10744d: 75 0d jne 10745c rtems_set_errno_and_return_minus_one( ENOTSUP ); 10744f: e8 8c 9b 00 00 call 110fe0 <__errno> 107454: c7 00 86 00 00 00 movl $0x86,(%eax) 10745a: eb 06 jmp 107462 return (*iop->handlers->fsync_h)( iop ); 10745c: 89 45 08 mov %eax,0x8(%ebp) } 10745f: c9 leave rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->fsync_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->fsync_h)( iop ); 107460: ff e1 jmp *%ecx } 107462: 83 c8 ff or $0xffffffff,%eax 107465: c9 leave 107466: c3 ret =============================================================================== 0010cd90 : int ftruncate( int fd, off_t length ) { 10cd90: 55 push %ebp 10cd91: 89 e5 mov %esp,%ebp 10cd93: 57 push %edi 10cd94: 56 push %esi 10cd95: 53 push %ebx 10cd96: 83 ec 1c sub $0x1c,%esp 10cd99: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_t *iop; rtems_filesystem_location_info_t loc; rtems_libio_check_fd( fd ); 10cd9c: 3b 05 d8 92 11 00 cmp 0x1192d8,%eax 10cda2: 73 0f jae 10cdb3 <== NEVER TAKEN iop = rtems_libio_iop( fd ); 10cda4: 6b d8 34 imul $0x34,%eax,%ebx 10cda7: 03 1d 38 d6 11 00 add 0x11d638,%ebx rtems_libio_check_is_open(iop); 10cdad: f6 43 0d 01 testb $0x1,0xd(%ebx) 10cdb1: 75 0d jne 10cdc0 <== ALWAYS TAKEN 10cdb3: e8 70 23 00 00 call 10f128 <__errno> <== NOT EXECUTED 10cdb8: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10cdbe: eb 5b jmp 10ce1b <== NOT EXECUTED /* * Make sure we are not working on a directory */ loc = iop->pathinfo; 10cdc0: 8d 7d e4 lea -0x1c(%ebp),%edi 10cdc3: 8d 73 10 lea 0x10(%ebx),%esi 10cdc6: b9 04 00 00 00 mov $0x4,%ecx 10cdcb: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !loc.ops->node_type_h ) 10cdcd: 8b 45 ec mov -0x14(%ebp),%eax 10cdd0: 8b 50 10 mov 0x10(%eax),%edx 10cdd3: 85 d2 test %edx,%edx 10cdd5: 74 39 je 10ce10 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) 10cdd7: 83 ec 0c sub $0xc,%esp 10cdda: 8d 45 e4 lea -0x1c(%ebp),%eax 10cddd: 50 push %eax 10cdde: ff d2 call *%edx 10cde0: 83 c4 10 add $0x10,%esp 10cde3: 48 dec %eax 10cde4: 75 0d jne 10cdf3 rtems_set_errno_and_return_minus_one( EISDIR ); 10cde6: e8 3d 23 00 00 call 10f128 <__errno> 10cdeb: c7 00 15 00 00 00 movl $0x15,(%eax) 10cdf1: eb 28 jmp 10ce1b rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 10cdf3: f6 43 0c 04 testb $0x4,0xc(%ebx) 10cdf7: 75 0d jne 10ce06 <== ALWAYS TAKEN 10cdf9: e8 2a 23 00 00 call 10f128 <__errno> <== NOT EXECUTED 10cdfe: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10ce04: eb 15 jmp 10ce1b <== NOT EXECUTED if ( !iop->handlers->ftruncate_h ) 10ce06: 8b 43 30 mov 0x30(%ebx),%eax 10ce09: 8b 40 20 mov 0x20(%eax),%eax 10ce0c: 85 c0 test %eax,%eax 10ce0e: 75 10 jne 10ce20 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); 10ce10: e8 13 23 00 00 call 10f128 <__errno> <== NOT EXECUTED 10ce15: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10ce1b: 83 c8 ff or $0xffffffff,%eax 10ce1e: eb 0b jmp 10ce2b return (*iop->handlers->ftruncate_h)( iop, length ); 10ce20: 52 push %edx 10ce21: 52 push %edx 10ce22: ff 75 0c pushl 0xc(%ebp) 10ce25: 53 push %ebx 10ce26: ff d0 call *%eax 10ce28: 83 c4 10 add $0x10,%esp } 10ce2b: 8d 65 f4 lea -0xc(%ebp),%esp 10ce2e: 5b pop %ebx 10ce2f: 5e pop %esi 10ce30: 5f pop %edi 10ce31: c9 leave 10ce32: c3 ret =============================================================================== 0010efcc : int getdents( int dd_fd, char *dd_buf, int dd_len ) { 10efcc: 55 push %ebp 10efcd: 89 e5 mov %esp,%ebp 10efcf: 57 push %edi 10efd0: 56 push %esi 10efd1: 53 push %ebx 10efd2: 83 ec 1c sub $0x1c,%esp 10efd5: 8b 45 08 mov 0x8(%ebp),%eax /* * Get the file control block structure associated with the file descriptor */ iop = rtems_libio_iop( dd_fd ); 10efd8: 31 db xor %ebx,%ebx 10efda: 3b 05 18 e2 11 00 cmp 0x11e218,%eax 10efe0: 73 09 jae 10efeb <== NEVER TAKEN 10efe2: 6b d8 34 imul $0x34,%eax,%ebx 10efe5: 03 1d 18 26 12 00 add 0x122618,%ebx /* * Make sure we are working on a directory */ loc = iop->pathinfo; 10efeb: 8d 7d e4 lea -0x1c(%ebp),%edi 10efee: 8d 73 10 lea 0x10(%ebx),%esi 10eff1: b9 04 00 00 00 mov $0x4,%ecx 10eff6: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !loc.ops->node_type_h ) 10eff8: 8b 45 ec mov -0x14(%ebp),%eax 10effb: 8b 50 10 mov 0x10(%eax),%edx 10effe: 85 d2 test %edx,%edx 10f000: 74 29 je 10f02b <== NEVER TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) 10f002: 83 ec 0c sub $0xc,%esp 10f005: 8d 45 e4 lea -0x1c(%ebp),%eax 10f008: 50 push %eax 10f009: ff d2 call *%edx 10f00b: 83 c4 10 add $0x10,%esp 10f00e: 48 dec %eax 10f00f: 74 10 je 10f021 rtems_set_errno_and_return_minus_one( ENOTDIR ); 10f011: e8 ca 2d 00 00 call 111de0 <__errno> 10f016: c7 00 14 00 00 00 movl $0x14,(%eax) 10f01c: 83 c8 ff or $0xffffffff,%eax 10f01f: eb 24 jmp 10f045 /* * Return the number of bytes that were actually transfered as a result * of the read attempt. */ if ( !iop->handlers->read_h ) 10f021: 8b 43 30 mov 0x30(%ebx),%eax 10f024: 8b 40 08 mov 0x8(%eax),%eax 10f027: 85 c0 test %eax,%eax 10f029: 75 0d jne 10f038 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); 10f02b: e8 b0 2d 00 00 call 111de0 <__errno> <== NOT EXECUTED 10f030: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10f036: eb e4 jmp 10f01c <== NOT EXECUTED return (*iop->handlers->read_h)( iop, dd_buf, dd_len ); 10f038: 52 push %edx 10f039: ff 75 10 pushl 0x10(%ebp) 10f03c: ff 75 0c pushl 0xc(%ebp) 10f03f: 53 push %ebx 10f040: ff d0 call *%eax 10f042: 83 c4 10 add $0x10,%esp } 10f045: 8d 65 f4 lea -0xc(%ebp),%esp 10f048: 5b pop %ebx 10f049: 5e pop %esi 10f04a: 5f pop %edi 10f04b: c9 leave 10f04c: c3 ret =============================================================================== 0010ce54 : int gettimeofday( struct timeval *tp, void * __tz ) { 10ce54: 55 push %ebp 10ce55: 89 e5 mov %esp,%ebp 10ce57: 56 push %esi 10ce58: 53 push %ebx 10ce59: 83 ec 20 sub $0x20,%esp 10ce5c: 8b 75 08 mov 0x8(%ebp),%esi /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) { 10ce5f: 85 f6 test %esi,%esi 10ce61: 75 10 jne 10ce73 <== ALWAYS TAKEN errno = EFAULT; 10ce63: e8 c0 22 00 00 call 10f128 <__errno> <== NOT EXECUTED 10ce68: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 10ce6e: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10ce71: eb 2a jmp 10ce9d <== NOT EXECUTED ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 10ce73: 9c pushf 10ce74: fa cli 10ce75: 5b pop %ebx * This routine grows @a the_heap memory area using the size bytes which 10ce76: 83 ec 0c sub $0xc,%esp 10ce79: 8d 45 f0 lea -0x10(%ebp),%eax 10ce7c: 50 push %eax 10ce7d: e8 ba d0 ff ff call 109f3c <_TOD_Get> * begin at @a starting_address. 10ce82: 53 push %ebx 10ce83: 9d popf * * @param[in] the_heap is the heap to operate upon 10ce84: 8b 45 f0 mov -0x10(%ebp),%eax 10ce87: 89 06 mov %eax,(%esi) * @param[in] starting_address is the starting address of the memory 10ce89: 8b 45 f4 mov -0xc(%ebp),%eax 10ce8c: b9 e8 03 00 00 mov $0x3e8,%ecx 10ce91: 31 d2 xor %edx,%edx 10ce93: f7 f1 div %ecx 10ce95: 89 46 04 mov %eax,0x4(%esi) 10ce98: 31 c0 xor %eax,%eax 10ce9a: 83 c4 10 add $0x10,%esp * with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X * do it. This puts us in good company. */ return 0; } 10ce9d: 8d 65 f8 lea -0x8(%ebp),%esp 10cea0: 5b pop %ebx 10cea1: 5e pop %esi 10cea2: c9 leave 10cea3: c3 ret =============================================================================== 0011052c : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 11052c: 55 push %ebp 11052d: 89 e5 mov %esp,%ebp 11052f: 8b 4d 08 mov 0x8(%ebp),%ecx IMFS_jnode_t *the_jnode; /* Is the node a directory ? */ the_jnode = (IMFS_jnode_t *) iop->file_info; if ( the_jnode->type != IMFS_DIRECTORY ) 110532: 8b 41 2c mov 0x2c(%ecx),%eax 110535: 83 ca ff or $0xffffffff,%edx 110538: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 11053c: 75 09 jne 110547 <== NEVER TAKEN return -1; /* It wasn't a directory --> return error */ iop->offset = 0; 11053e: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) 110545: 31 d2 xor %edx,%edx return 0; } 110547: 89 d0 mov %edx,%eax 110549: c9 leave 11054a: c3 ret =============================================================================== 00110615 : */ int imfs_dir_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 110615: 55 push %ebp 110616: 89 e5 mov %esp,%ebp 110618: 56 push %esi 110619: 53 push %ebx 11061a: 83 ec 10 sub $0x10,%esp 11061d: 8b 75 08 mov 0x8(%ebp),%esi IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 110620: 8b 1e mov (%esi),%ebx /* * You cannot remove a node that still has children */ if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) ) 110622: 8d 43 54 lea 0x54(%ebx),%eax 110625: 39 43 50 cmp %eax,0x50(%ebx) 110628: 74 0d je 110637 rtems_set_errno_and_return_minus_one( ENOTEMPTY ); 11062a: e8 b1 09 00 00 call 110fe0 <__errno> 11062f: c7 00 5a 00 00 00 movl $0x5a,(%eax) 110635: eb 19 jmp 110650 /* * You cannot remove the file system root node. */ if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access ) 110637: 8b 46 0c mov 0xc(%esi),%eax 11063a: 39 58 18 cmp %ebx,0x18(%eax) 11063d: 74 06 je 110645 /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) 11063f: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx) 110643: 74 10 je 110655 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EBUSY ); 110645: e8 96 09 00 00 call 110fe0 <__errno> 11064a: c7 00 10 00 00 00 movl $0x10,(%eax) 110650: 83 c8 ff or $0xffffffff,%eax 110653: eb 6c jmp 1106c1 /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 110655: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 110659: 74 13 je 11066e 11065b: 83 ec 0c sub $0xc,%esp 11065e: 53 push %ebx 11065f: e8 d0 e9 ff ff call 10f034 <_Chain_Extract> rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 110664: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 11066b: 83 c4 10 add $0x10,%esp /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 11066e: 66 ff 4b 34 decw 0x34(%ebx) IMFS_update_ctime( the_jnode ); 110672: 51 push %ecx 110673: 51 push %ecx 110674: 6a 00 push $0x0 110676: 8d 45 f0 lea -0x10(%ebp),%eax 110679: 50 push %eax 11067a: e8 e9 6d ff ff call 107468 11067f: 8b 45 f0 mov -0x10(%ebp),%eax 110682: 89 43 48 mov %eax,0x48(%ebx) /* * The file cannot be open and the link must be less than 1 to free. */ if ( !rtems_libio_is_file_open( the_jnode ) && (the_jnode->st_nlink < 1) ) { 110685: 89 1c 24 mov %ebx,(%esp) 110688: e8 13 6f ff ff call 1075a0 11068d: 83 c4 10 add $0x10,%esp 110690: 85 c0 test %eax,%eax 110692: 75 2b jne 1106bf 110694: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) 110699: 75 24 jne 1106bf /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 11069b: 8b 15 cc f3 11 00 mov 0x11f3cc,%edx 1106a1: 8b 42 04 mov 0x4(%edx),%eax 1106a4: 3b 06 cmp (%esi),%eax 1106a6: 75 07 jne 1106af <== ALWAYS TAKEN rtems_filesystem_current.node_access = NULL; 1106a8: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED /* * Free memory associated with a memory file. */ free( the_jnode ); 1106af: 83 ec 0c sub $0xc,%esp 1106b2: 53 push %ebx 1106b3: e8 40 6c ff ff call 1072f8 1106b8: 31 c0 xor %eax,%eax 1106ba: 83 c4 10 add $0x10,%esp 1106bd: eb 02 jmp 1106c1 1106bf: 31 c0 xor %eax,%eax } return 0; } 1106c1: 8d 65 f8 lea -0x8(%ebp),%esp 1106c4: 5b pop %ebx 1106c5: 5e pop %esi 1106c6: c9 leave 1106c7: c3 ret =============================================================================== 0010f8e0 : int ioctl( int fd, ioctl_command_t command, ... ) { 10f8e0: 55 push %ebp 10f8e1: 89 e5 mov %esp,%ebp 10f8e3: 83 ec 08 sub $0x8,%esp 10f8e6: 8b 45 08 mov 0x8(%ebp),%eax va_list ap; rtems_status_code rc; rtems_libio_t *iop; void *buffer; rtems_libio_check_fd( fd ); 10f8e9: 3b 05 38 f0 11 00 cmp 0x11f038,%eax 10f8ef: 73 19 jae 10f90a <== NEVER TAKEN iop = rtems_libio_iop( fd ); 10f8f1: 6b c0 34 imul $0x34,%eax,%eax 10f8f4: 03 05 a8 3b 12 00 add 0x123ba8,%eax rtems_libio_check_is_open(iop); 10f8fa: f6 40 0d 01 testb $0x1,0xd(%eax) 10f8fe: 74 0a je 10f90a <== NEVER TAKEN va_start(ap, command); buffer = va_arg(ap, void *); 10f900: 8b 4d 10 mov 0x10(%ebp),%ecx /* * Now process the ioctl(). */ if ( !iop->handlers ) 10f903: 8b 50 30 mov 0x30(%eax),%edx 10f906: 85 d2 test %edx,%edx 10f908: 75 0d jne 10f917 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EBADF ); 10f90a: e8 e9 29 00 00 call 1122f8 <__errno> <== NOT EXECUTED 10f90f: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10f915: eb 12 jmp 10f929 <== NOT EXECUTED if ( !iop->handlers->ioctl_h ) 10f917: 8b 52 10 mov 0x10(%edx),%edx 10f91a: 85 d2 test %edx,%edx 10f91c: 75 10 jne 10f92e <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); 10f91e: e8 d5 29 00 00 call 1122f8 <__errno> <== NOT EXECUTED 10f923: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10f929: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10f92c: eb 0d jmp 10f93b <== NOT EXECUTED rc = (*iop->handlers->ioctl_h)( iop, command, buffer ); 10f92e: 83 ec 04 sub $0x4,%esp 10f931: 51 push %ecx 10f932: ff 75 0c pushl 0xc(%ebp) 10f935: 50 push %eax 10f936: ff d2 call *%edx 10f938: 83 c4 10 add $0x10,%esp return rc; } 10f93b: c9 leave 10f93c: c3 ret =============================================================================== 00107a7c : /* * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) { 107a7c: 55 push %ebp <== NOT EXECUTED 107a7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107a7f: 56 push %esi <== NOT EXECUTED 107a80: 53 push %ebx <== NOT EXECUTED 107a81: 89 d6 mov %edx,%esi <== NOT EXECUTED 107a83: 88 c3 mov %al,%bl <== NOT EXECUTED if (tty->termios.c_iflag & ISTRIP) 107a85: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED 107a88: f6 c1 20 test $0x20,%cl <== NOT EXECUTED 107a8b: 74 03 je 107a90 <== NOT EXECUTED c &= 0x7f; 107a8d: 83 e3 7f and $0x7f,%ebx <== NOT EXECUTED if (tty->termios.c_iflag & IUCLC) 107a90: f6 c5 02 test $0x2,%ch <== NOT EXECUTED 107a93: 74 13 je 107aa8 <== NOT EXECUTED c = tolower (c); 107a95: 0f b6 d3 movzbl %bl,%edx <== NOT EXECUTED 107a98: a1 00 b7 11 00 mov 0x11b700,%eax <== NOT EXECUTED 107a9d: f6 04 10 01 testb $0x1,(%eax,%edx,1) <== NOT EXECUTED 107aa1: 74 03 je 107aa6 <== NOT EXECUTED 107aa3: 83 c2 20 add $0x20,%edx <== NOT EXECUTED 107aa6: 88 d3 mov %dl,%bl <== NOT EXECUTED if (c == '\r') { 107aa8: 80 fb 0d cmp $0xd,%bl <== NOT EXECUTED 107aab: 75 11 jne 107abe <== NOT EXECUTED if (tty->termios.c_iflag & IGNCR) 107aad: 84 c9 test %cl,%cl <== NOT EXECUTED 107aaf: 0f 88 c9 00 00 00 js 107b7e <== NOT EXECUTED return 0; if (tty->termios.c_iflag & ICRNL) 107ab5: 80 e5 01 and $0x1,%ch <== NOT EXECUTED 107ab8: 74 1c je 107ad6 <== NOT EXECUTED 107aba: b3 0a mov $0xa,%bl <== NOT EXECUTED 107abc: eb 18 jmp 107ad6 <== NOT EXECUTED c = '\n'; } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { 107abe: 80 fb 0a cmp $0xa,%bl <== NOT EXECUTED 107ac1: 75 0b jne 107ace <== NOT EXECUTED 107ac3: 80 e1 40 and $0x40,%cl <== NOT EXECUTED 107ac6: 0f 85 b8 00 00 00 jne 107b84 <== NOT EXECUTED 107acc: eb 08 jmp 107ad6 <== NOT EXECUTED c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 107ace: 84 db test %bl,%bl <== NOT EXECUTED 107ad0: 0f 84 80 00 00 00 je 107b56 <== NOT EXECUTED 107ad6: 8b 56 3c mov 0x3c(%esi),%edx <== NOT EXECUTED 107ad9: f6 c2 02 test $0x2,%dl <== NOT EXECUTED 107adc: 74 78 je 107b56 <== NOT EXECUTED if (c == tty->termios.c_cc[VERASE]) { 107ade: 3a 5e 43 cmp 0x43(%esi),%bl <== NOT EXECUTED 107ae1: 75 04 jne 107ae7 <== NOT EXECUTED erase (tty, 0); 107ae3: 31 d2 xor %edx,%edx <== NOT EXECUTED 107ae5: eb 0a jmp 107af1 <== NOT EXECUTED return 0; } else if (c == tty->termios.c_cc[VKILL]) { 107ae7: 3a 5e 44 cmp 0x44(%esi),%bl <== NOT EXECUTED 107aea: 75 11 jne 107afd <== NOT EXECUTED erase (tty, 1); 107aec: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 107af1: 89 f0 mov %esi,%eax <== NOT EXECUTED 107af3: e8 17 fe ff ff call 10790f <== NOT EXECUTED 107af8: e9 81 00 00 00 jmp 107b7e <== NOT EXECUTED return 0; } else if (c == tty->termios.c_cc[VEOF]) { 107afd: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 107b02: 3a 5e 45 cmp 0x45(%esi),%bl <== NOT EXECUTED 107b05: 74 79 je 107b80 <== NOT EXECUTED return 1; } else if (c == '\n') { 107b07: 80 fb 0a cmp $0xa,%bl <== NOT EXECUTED 107b0a: 75 1d jne 107b29 <== NOT EXECUTED if (tty->termios.c_lflag & (ECHO | ECHONL)) 107b0c: 80 e2 48 and $0x48,%dl <== NOT EXECUTED 107b0f: 74 0c je 107b1d <== NOT EXECUTED echo (c, tty); 107b11: 89 f2 mov %esi,%edx <== NOT EXECUTED 107b13: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 107b18: e8 9a fd ff ff call 1078b7 <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 107b1d: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED 107b20: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED 107b23: c6 04 02 0a movb $0xa,(%edx,%eax,1) <== NOT EXECUTED 107b27: eb 22 jmp 107b4b <== NOT EXECUTED return 1; } else if ((c == tty->termios.c_cc[VEOL]) 107b29: 3a 5e 4c cmp 0x4c(%esi),%bl <== NOT EXECUTED 107b2c: 74 05 je 107b33 <== NOT EXECUTED 107b2e: 3a 5e 51 cmp 0x51(%esi),%bl <== NOT EXECUTED 107b31: 75 23 jne 107b56 <== NOT EXECUTED || (c == tty->termios.c_cc[VEOL2])) { if (tty->termios.c_lflag & ECHO) 107b33: 80 e2 08 and $0x8,%dl <== NOT EXECUTED 107b36: 74 0a je 107b42 <== NOT EXECUTED echo (c, tty); 107b38: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 107b3b: 89 f2 mov %esi,%edx <== NOT EXECUTED 107b3d: e8 75 fd ff ff call 1078b7 <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 107b42: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED 107b45: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED 107b48: 88 1c 02 mov %bl,(%edx,%eax,1) <== NOT EXECUTED 107b4b: 40 inc %eax <== NOT EXECUTED 107b4c: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED 107b4f: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 107b54: eb 2a jmp 107b80 <== NOT EXECUTED } /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { 107b56: a1 3c b6 11 00 mov 0x11b63c,%eax <== NOT EXECUTED 107b5b: 48 dec %eax <== NOT EXECUTED 107b5c: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED 107b5f: 7d 1d jge 107b7e <== NOT EXECUTED if (tty->termios.c_lflag & ECHO) 107b61: f6 46 3c 08 testb $0x8,0x3c(%esi) <== NOT EXECUTED 107b65: 74 0a je 107b71 <== NOT EXECUTED echo (c, tty); 107b67: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 107b6a: 89 f2 mov %esi,%edx <== NOT EXECUTED 107b6c: e8 46 fd ff ff call 1078b7 <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 107b71: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED 107b74: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED 107b77: 88 1c 02 mov %bl,(%edx,%eax,1) <== NOT EXECUTED 107b7a: 40 inc %eax <== NOT EXECUTED 107b7b: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED 107b7e: 31 c0 xor %eax,%eax <== NOT EXECUTED } return 0; } 107b80: 5b pop %ebx <== NOT EXECUTED 107b81: 5e pop %esi <== NOT EXECUTED 107b82: c9 leave <== NOT EXECUTED 107b83: c3 ret <== NOT EXECUTED * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { if (tty->termios.c_lflag & ECHO) echo (c, tty); tty->cbuf[tty->ccount++] = c; 107b84: b3 0d mov $0xd,%bl <== NOT EXECUTED 107b86: e9 4b ff ff ff jmp 107ad6 <== NOT EXECUTED =============================================================================== 001155dc : #include int isatty( int fd ) { 1155dc: 55 push %ebp 1155dd: 89 e5 mov %esp,%ebp 1155df: 83 ec 60 sub $0x60,%esp struct stat buf; if (fstat (fd, &buf) < 0) 1155e2: 8d 45 b4 lea -0x4c(%ebp),%eax 1155e5: 50 push %eax 1155e6: ff 75 08 pushl 0x8(%ebp) 1155e9: e8 4a ff ff ff call 115538 1155ee: 83 c4 10 add $0x10,%esp 1155f1: 31 d2 xor %edx,%edx 1155f3: 85 c0 test %eax,%eax 1155f5: 78 12 js 115609 <== NEVER TAKEN 1155f7: 8b 45 c0 mov -0x40(%ebp),%eax 1155fa: 25 00 f0 00 00 and $0xf000,%eax 1155ff: 31 d2 xor %edx,%edx 115601: 3d 00 20 00 00 cmp $0x2000,%eax 115606: 0f 94 c2 sete %dl if (S_ISCHR (buf.st_mode)) return 1; return 0; } 115609: 89 d0 mov %edx,%eax 11560b: c9 leave 11560c: c3 ret =============================================================================== 0011841c : int killinfo( pid_t pid, int sig, const union sigval *value ) { 11841c: 55 push %ebp 11841d: 89 e5 mov %esp,%ebp 11841f: 57 push %edi 118420: 56 push %esi 118421: 53 push %ebx 118422: 83 ec 2c sub $0x2c,%esp 118425: 8b 75 10 mov 0x10(%ebp),%esi /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 118428: e8 7f fc ff ff call 1180ac 11842d: 39 45 08 cmp %eax,0x8(%ebp) 118430: 74 0d je 11843f <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ESRCH ); 118432: e8 e5 81 ff ff call 11061c <__errno> <== NOT EXECUTED 118437: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED 11843d: eb 11 jmp 118450 <== NOT EXECUTED /* * Validate the signal passed. */ if ( !sig ) 11843f: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 118443: 75 13 jne 118458 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 118445: e8 d2 81 ff ff call 11061c <__errno> <== NOT EXECUTED 11844a: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 118450: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 118453: e9 05 02 00 00 jmp 11865d <== NOT EXECUTED if ( !is_valid_signo(sig) ) 118458: 8b 4d 0c mov 0xc(%ebp),%ecx 11845b: 49 dec %ecx 11845c: 83 f9 1f cmp $0x1f,%ecx 11845f: 77 e4 ja 118445 <== NEVER TAKEN /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 118461: 6b 45 0c 0c imul $0xc,0xc(%ebp),%eax 118465: 31 d2 xor %edx,%edx 118467: 83 b8 88 98 12 00 01 cmpl $0x1,0x129888(%eax) 11846e: 0f 84 e9 01 00 00 je 11865d * 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 ) ) 118474: 83 7d 0c 08 cmpl $0x8,0xc(%ebp) 118478: 74 0c je 118486 11847a: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) 11847e: 74 06 je 118486 118480: 83 7d 0c 0b cmpl $0xb,0xc(%ebp) 118484: 75 1a jne 1184a0 return pthread_kill( pthread_self(), sig ); 118486: e8 99 03 00 00 call 118824 11848b: 53 push %ebx 11848c: 53 push %ebx 11848d: ff 75 0c pushl 0xc(%ebp) 118490: 50 push %eax 118491: e8 e6 02 00 00 call 11877c 118496: 89 c2 mov %eax,%edx 118498: 83 c4 10 add $0x10,%esp 11849b: e9 bd 01 00 00 jmp 11865d mask = signo_to_mask( sig ); 1184a0: bb 01 00 00 00 mov $0x1,%ebx 1184a5: d3 e3 shl %cl,%ebx /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 1184a7: 8b 45 0c mov 0xc(%ebp),%eax 1184aa: 89 45 e8 mov %eax,-0x18(%ebp) siginfo->si_code = SI_USER; 1184ad: c7 45 ec 01 00 00 00 movl $0x1,-0x14(%ebp) if ( !value ) { 1184b4: 85 f6 test %esi,%esi 1184b6: 75 09 jne 1184c1 siginfo->si_value.sival_int = 0; 1184b8: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) 1184bf: eb 05 jmp 1184c6 } else { siginfo->si_value = *value; 1184c1: 8b 06 mov (%esi),%eax 1184c3: 89 45 f0 mov %eax,-0x10(%ebp) rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 1184c6: a1 94 92 12 00 mov 0x129294,%eax 1184cb: 40 inc %eax 1184cc: a3 94 92 12 00 mov %eax,0x129294 /* * 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; 1184d1: 8b 35 54 93 12 00 mov 0x129354,%esi api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 1184d7: 8b 86 f8 00 00 00 mov 0xf8(%esi),%eax 1184dd: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax 1184e3: f7 d0 not %eax 1184e5: 85 c3 test %eax,%ebx 1184e7: 0f 85 f4 00 00 00 jne 1185e1 goto process_it; 1184ed: b9 0c 9a 12 00 mov $0x129a0c,%ecx index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; 1184f2: 8b 11 mov (%ecx),%edx _Context_Restore_fp( &_Thread_Executing->fp_context ); #endif _CPU_Context_Restart_self( &_Thread_Executing->Registers ); } 1184f4: 8d 79 04 lea 0x4(%ecx),%edi 1184f7: eb 23 jmp 11851c !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; 1184f9: 89 d6 mov %edx,%esi api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 1184fb: 8b 82 f8 00 00 00 mov 0xf8(%edx),%eax if ((the_thread->Wait.option & mask) || (~api->signals_blocked & mask)) { 118501: 85 5a 30 test %ebx,0x30(%edx) 118504: 0f 85 d7 00 00 00 jne 1185e1 <== ALWAYS TAKEN 11850a: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED 118510: f7 d0 not %eax <== NOT EXECUTED 118512: 85 c3 test %eax,%ebx <== NOT EXECUTED 118514: 0f 85 c7 00 00 00 jne 1185e1 <== NOT EXECUTED the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 11851a: 8b 12 mov (%edx),%edx <== NOT EXECUTED index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; 11851c: 39 fa cmp %edi,%edx 11851e: 75 d9 jne 1184f9 118520: 83 c1 0c add $0xc,%ecx */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 118523: 81 f9 3c 9a 12 00 cmp $0x129a3c,%ecx 118529: 75 c7 jne 1184f2 * * + rtems internal threads do not receive signals. */ interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 11852b: 0f b6 05 e4 d0 11 00 movzbl 0x11d0e4,%eax 118532: 40 inc %eax 118533: 89 45 e0 mov %eax,-0x20(%ebp) 118536: c7 45 d0 02 00 00 00 movl $0x2,-0x30(%ebp) 11853d: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) the_api++ ) { /* * Thie can occur when no one is interested and ITRON is not configured. */ if ( !_Objects_Information_table[ the_api ] ) 118544: 8b 55 d0 mov -0x30(%ebp),%edx 118547: 8b 04 95 68 92 12 00 mov 0x129268(,%edx,4),%eax 11854e: 85 c0 test %eax,%eax 118550: 74 79 je 1185cb continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 118552: 8b 40 04 mov 0x4(%eax),%eax /* * This cannot happen in the current (as of Dec 2007) implementation * of initialization but at some point, the object information * structure for a particular manager may not be installed. */ if ( !the_info ) 118555: 85 c0 test %eax,%eax 118557: 74 72 je 1185cb <== NEVER TAKEN continue; maximum = the_info->maximum; 118559: 0f b7 50 10 movzwl 0x10(%eax),%edx 11855d: 89 55 d4 mov %edx,-0x2c(%ebp) object_table = the_info->local_table; 118560: 8b 40 1c mov 0x1c(%eax),%eax 118563: 89 45 d8 mov %eax,-0x28(%ebp) 118566: bf 01 00 00 00 mov $0x1,%edi 11856b: eb 59 jmp 1185c6 for ( index = 1 ; index <= maximum ; index++ ) { the_thread = (Thread_Control *) object_table[ index ]; 11856d: 8b 45 d8 mov -0x28(%ebp),%eax 118570: 8b 14 b8 mov (%eax,%edi,4),%edx if ( !the_thread ) 118573: 85 d2 test %edx,%edx 118575: 74 43 je 1185ba /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 118577: 8b 72 14 mov 0x14(%edx),%esi 11857a: 3b 75 e0 cmp -0x20(%ebp),%esi 11857d: 77 3b ja 1185ba <== NEVER TAKEN /* * If this thread is not interested, then go on to the next thread. */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 11857f: 8b 82 f8 00 00 00 mov 0xf8(%edx),%eax if ( !api || !_POSIX_signals_Is_interested( api, mask ) ) 118585: 85 c0 test %eax,%eax 118587: 74 31 je 1185ba <== NEVER TAKEN 118589: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax 11858f: f7 d0 not %eax 118591: 85 c3 test %eax,%ebx 118593: 74 25 je 1185ba * Now we know the thread under connsideration is interested. * If the thread under consideration is of higher priority, then * it becomes the interested thread. */ if ( the_thread->current_priority < interested_priority ) { 118595: 3b 75 e0 cmp -0x20(%ebp),%esi 118598: 72 25 jb 1185bf <== ALWAYS TAKEN * Now the thread and the interested thread have the same priority. * If the interested thread is ready, then we don't need to send it * to a blocked thread. */ if ( _States_Is_ready( interested_thread->current_state ) ) 11859a: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 11859d: 8b 48 10 mov 0x10(%eax),%ecx <== NOT EXECUTED 1185a0: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1185a2: 74 16 je 1185ba <== NOT EXECUTED * Now the interested thread is blocked. * If the thread we are considering is not, the it becomes the * interested thread. */ if ( _States_Is_ready( the_thread->current_state ) ) { 1185a4: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 1185a7: 85 c0 test %eax,%eax <== NOT EXECUTED 1185a9: 74 14 je 1185bf <== NOT EXECUTED * Now we know both threads are blocked. * If the interested thread is interruptible, then just use it. */ /* XXX need a new states macro */ if ( interested_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) 1185ab: 81 e1 00 00 00 10 and $0x10000000,%ecx <== NOT EXECUTED 1185b1: 75 07 jne 1185ba <== NOT EXECUTED * If the thread under consideration is interruptible by a signal, * then it becomes the interested thread. */ /* XXX need a new states macro */ if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { 1185b3: a9 00 00 00 10 test $0x10000000,%eax <== NOT EXECUTED 1185b8: 75 05 jne 1185bf <== NOT EXECUTED 1185ba: 8b 75 e0 mov -0x20(%ebp),%esi 1185bd: eb 03 jmp 1185c2 1185bf: 89 55 dc mov %edx,-0x24(%ebp) continue; maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 1185c2: 47 inc %edi 1185c3: 89 75 e0 mov %esi,-0x20(%ebp) 1185c6: 3b 7d d4 cmp -0x2c(%ebp),%edi 1185c9: 76 a2 jbe 11856d interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 1185cb: ff 45 d0 incl -0x30(%ebp) interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; 1185ce: 83 7d d0 05 cmpl $0x5,-0x30(%ebp) 1185d2: 0f 85 6c ff ff ff jne 118544 interested_priority = the_thread->current_priority; } } } if ( interested_thread ) { 1185d8: 83 7d dc 00 cmpl $0x0,-0x24(%ebp) 1185dc: 74 1c je 1185fa 1185de: 8b 75 dc mov -0x24(%ebp),%esi * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = true; 1185e1: c6 46 75 01 movb $0x1,0x75(%esi) /* * 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 ) ) { 1185e5: 51 push %ecx 1185e6: 8d 45 e8 lea -0x18(%ebp),%eax 1185e9: 50 push %eax 1185ea: ff 75 0c pushl 0xc(%ebp) 1185ed: 56 push %esi 1185ee: e8 99 00 00 00 call 11868c <_POSIX_signals_Unblock_thread> 1185f3: 83 c4 10 add $0x10,%esp 1185f6: 84 c0 test %al,%al 1185f8: 75 5c jne 118656 /* * 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 ); 1185fa: 83 ec 0c sub $0xc,%esp 1185fd: 53 push %ebx 1185fe: e8 65 00 00 00 call 118668 <_POSIX_signals_Set_process_signals> if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 118603: 6b 5d 0c 0c imul $0xc,0xc(%ebp),%ebx 118607: 83 c4 10 add $0x10,%esp 11860a: 83 bb 80 98 12 00 02 cmpl $0x2,0x129880(%ebx) 118611: 75 43 jne 118656 psiginfo = (POSIX_signals_Siginfo_node *) 118613: 83 ec 0c sub $0xc,%esp 118616: 68 00 9a 12 00 push $0x129a00 11861b: e8 90 26 ff ff call 10acb0 <_Chain_Get> _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { 118620: 83 c4 10 add $0x10,%esp 118623: 85 c0 test %eax,%eax 118625: 75 10 jne 118637 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EAGAIN ); 118627: e8 f0 7f ff ff call 11061c <__errno> <== NOT EXECUTED 11862c: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 118632: e9 19 fe ff ff jmp 118450 <== NOT EXECUTED } psiginfo->Info = *siginfo; 118637: 8d 78 08 lea 0x8(%eax),%edi 11863a: 8d 75 e8 lea -0x18(%ebp),%esi 11863d: b9 03 00 00 00 mov $0x3,%ecx 118642: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 118644: 52 push %edx 118645: 52 push %edx 118646: 50 push %eax 118647: 8d 83 50 9a 12 00 lea 0x129a50(%ebx),%eax 11864d: 50 push %eax 11864e: e8 39 26 ff ff call 10ac8c <_Chain_Append> 118653: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 118656: e8 b1 3b ff ff call 10c20c <_Thread_Enable_dispatch> 11865b: 31 d2 xor %edx,%edx return 0; } 11865d: 89 d0 mov %edx,%eax 11865f: 8d 65 f4 lea -0xc(%ebp),%esp 118662: 5b pop %ebx 118663: 5e pop %esi 118664: 5f pop %edi 118665: c9 leave 118666: c3 ret =============================================================================== 00106844 : rtems_extension libc_delete_hook( rtems_tcb *current_task, rtems_tcb *deleted_task ) { 106844: 55 push %ebp 106845: 89 e5 mov %esp,%ebp 106847: 57 push %edi 106848: 56 push %esi 106849: 53 push %ebx 10684a: 83 ec 0c sub $0xc,%esp 10684d: 8b 7d 08 mov 0x8(%ebp),%edi 106850: 8b 75 0c mov 0xc(%ebp),%esi /* * The reentrancy structure was allocated by newlib using malloc() */ if (current_task == deleted_task) { 106853: 39 f7 cmp %esi,%edi 106855: 75 08 jne 10685f ptr = _REENT; 106857: 8b 1d 20 b7 11 00 mov 0x11b720,%ebx 10685d: eb 06 jmp 106865 } else { ptr = deleted_task->libc_reent; 10685f: 8b 9e f0 00 00 00 mov 0xf0(%esi),%ebx } if (ptr && ptr != &libc_global_reent) { 106865: 85 db test %ebx,%ebx 106867: 74 20 je 106889 <== NEVER TAKEN 106869: 81 fb 38 b2 11 00 cmp $0x11b238,%ebx 10686f: 74 18 je 106889 _reclaim_reent(ptr); */ /* * Just in case there are some buffers lying around. */ _fwalk(ptr, newlib_free_buffers); 106871: 50 push %eax 106872: 50 push %eax 106873: 68 a9 68 10 00 push $0x1068a9 106878: 53 push %ebx 106879: e8 62 8f 00 00 call 10f7e0 <_fwalk> #if REENT_MALLOCED free(ptr); #else _Workspace_Free(ptr); 10687e: 89 1c 24 mov %ebx,(%esp) 106881: e8 8e 55 00 00 call 10be14 <_Workspace_Free> 106886: 83 c4 10 add $0x10,%esp #endif } deleted_task->libc_reent = NULL; 106889: c7 86 f0 00 00 00 00 movl $0x0,0xf0(%esi) 106890: 00 00 00 /* * Require the switch back to another task to install its own */ if ( current_task == deleted_task ) { 106893: 39 f7 cmp %esi,%edi 106895: 75 0a jne 1068a1 _REENT = 0; 106897: c7 05 20 b7 11 00 00 movl $0x0,0x11b720 10689e: 00 00 00 } } 1068a1: 8d 65 f4 lea -0xc(%ebp),%esp 1068a4: 5b pop %ebx 1068a5: 5e pop %esi 1068a6: 5f pop %edi 1068a7: c9 leave 1068a8: c3 ret =============================================================================== 001156d4 : extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) { 1156d4: 55 push %ebp 1156d5: 89 e5 mov %esp,%ebp 1156d7: 83 ec 08 sub $0x8,%esp /* * In case RTEMS is already down, don't do this. It could be * dangerous. */ if (!_System_state_Is_up(_System_state_Get())) 1156da: 83 3d 38 d9 11 00 03 cmpl $0x3,0x11d938 1156e1: 75 55 jne 115738 <== NEVER TAKEN /* * This was already done if the user called exit() directly . _wrapup_reent(0); */ if (_REENT != &libc_global_reent) { 1156e3: 81 3d 20 b7 11 00 38 cmpl $0x11b238,0x11b720 1156ea: b2 11 00 1156ed: 74 1a je 115709 _wrapup_reent(&libc_global_reent); 1156ef: 83 ec 0c sub $0xc,%esp 1156f2: 68 38 b2 11 00 push $0x11b238 1156f7: e8 b8 05 00 00 call 115cb4 <_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 = &libc_global_reent; 1156fc: c7 05 20 b7 11 00 38 movl $0x11b238,0x11b720 115703: b2 11 00 115706: 83 c4 10 add $0x10,%esp * * Should this be changed to do *all* file streams? * _fwalk (_REENT, fclose); */ fclose (stdin); 115709: 83 ec 0c sub $0xc,%esp 11570c: a1 20 b7 11 00 mov 0x11b720,%eax 115711: ff 70 04 pushl 0x4(%eax) 115714: e8 5b 9b ff ff call 10f274 fclose (stdout); 115719: 5a pop %edx 11571a: a1 20 b7 11 00 mov 0x11b720,%eax 11571f: ff 70 08 pushl 0x8(%eax) 115722: e8 4d 9b ff ff call 10f274 fclose (stderr); 115727: 58 pop %eax 115728: a1 20 b7 11 00 mov 0x11b720,%eax 11572d: ff 70 0c pushl 0xc(%eax) 115730: e8 3f 9b ff ff call 10f274 115735: 83 c4 10 add $0x10,%esp } 115738: c9 leave 115739: c3 ret =============================================================================== 001079d8 : int link( const char *existing, const char *new ) { 1079d8: 55 push %ebp 1079d9: 89 e5 mov %esp,%ebp 1079db: 57 push %edi 1079dc: 56 push %esi 1079dd: 53 push %ebx 1079de: 83 ec 3c sub $0x3c,%esp 1079e1: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Get the node we are linking to. */ result = rtems_filesystem_evaluate_path( existing, 0, &existing_loc, true ); 1079e4: 6a 01 push $0x1 1079e6: 8d 45 e0 lea -0x20(%ebp),%eax 1079e9: 50 push %eax 1079ea: 6a 00 push $0x0 1079ec: ff 75 08 pushl 0x8(%ebp) 1079ef: e8 3e fb ff ff call 107532 if ( result != 0 ) 1079f4: 83 c4 10 add $0x10,%esp 1079f7: 83 ce ff or $0xffffffff,%esi 1079fa: 85 c0 test %eax,%eax 1079fc: 0f 85 7a 01 00 00 jne 107b7c /* * Get the parent of the node we are creating. */ rtems_filesystem_get_start_loc( new, &i, &parent_loc ); 107a02: 8a 03 mov (%ebx),%al 107a04: 3c 2f cmp $0x2f,%al 107a06: 74 08 je 107a10 107a08: 3c 5c cmp $0x5c,%al 107a0a: 74 04 je 107a10 <== NEVER TAKEN 107a0c: 84 c0 test %al,%al 107a0e: 75 16 jne 107a26 <== ALWAYS TAKEN 107a10: 8d 7d d0 lea -0x30(%ebp),%edi 107a13: a1 4c 09 12 00 mov 0x12094c,%eax 107a18: 8d 70 14 lea 0x14(%eax),%esi 107a1b: b9 04 00 00 00 mov $0x4,%ecx 107a20: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 107a22: b1 01 mov $0x1,%cl 107a24: eb 12 jmp 107a38 107a26: 8d 7d d0 lea -0x30(%ebp),%edi 107a29: a1 4c 09 12 00 mov 0x12094c,%eax 107a2e: 8d 70 04 lea 0x4(%eax),%esi 107a31: b9 04 00 00 00 mov $0x4,%ecx 107a36: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !parent_loc.ops->evalformake_h ) { 107a38: 8b 45 d8 mov -0x28(%ebp),%eax 107a3b: 8b 50 04 mov 0x4(%eax),%edx 107a3e: 85 d2 test %edx,%edx 107a40: 75 21 jne 107a63 <== ALWAYS TAKEN rtems_filesystem_freenode( &existing_loc ); 107a42: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 107a45: 85 c0 test %eax,%eax <== NOT EXECUTED 107a47: 0f 84 de 00 00 00 je 107b2b <== NOT EXECUTED 107a4d: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 107a50: 85 d2 test %edx,%edx <== NOT EXECUTED 107a52: 0f 84 d3 00 00 00 je 107b2b <== NOT EXECUTED 107a58: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107a5b: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 107a5e: e9 c2 00 00 00 jmp 107b25 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start ); 107a63: 56 push %esi 107a64: 8d 45 f0 lea -0x10(%ebp),%eax 107a67: 50 push %eax 107a68: 8d 7d d0 lea -0x30(%ebp),%edi 107a6b: 57 push %edi 107a6c: 8d 04 0b lea (%ebx,%ecx,1),%eax 107a6f: 50 push %eax 107a70: ff d2 call *%edx 107a72: 89 c6 mov %eax,%esi if ( result != 0 ) { 107a74: 83 c4 10 add $0x10,%esp 107a77: 85 c0 test %eax,%eax 107a79: 74 29 je 107aa4 rtems_filesystem_freenode( &existing_loc ); 107a7b: 8b 45 e8 mov -0x18(%ebp),%eax 107a7e: 85 c0 test %eax,%eax 107a80: 74 13 je 107a95 <== NEVER TAKEN 107a82: 8b 50 1c mov 0x1c(%eax),%edx 107a85: 85 d2 test %edx,%edx 107a87: 74 0c je 107a95 <== NEVER TAKEN 107a89: 83 ec 0c sub $0xc,%esp 107a8c: 8d 45 e0 lea -0x20(%ebp),%eax 107a8f: 50 push %eax 107a90: ff d2 call *%edx 107a92: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( result ); 107a95: e8 16 9b 00 00 call 1115b0 <__errno> 107a9a: 89 30 mov %esi,(%eax) 107a9c: 83 ce ff or $0xffffffff,%esi 107a9f: e9 d8 00 00 00 jmp 107b7c /* * Check to see if the caller is trying to link across file system * boundaries. */ if ( parent_loc.mt_entry != existing_loc.mt_entry ) { 107aa4: 8b 45 dc mov -0x24(%ebp),%eax 107aa7: 3b 45 ec cmp -0x14(%ebp),%eax 107aaa: 74 41 je 107aed rtems_filesystem_freenode( &existing_loc ); 107aac: 8b 45 e8 mov -0x18(%ebp),%eax 107aaf: 85 c0 test %eax,%eax 107ab1: 74 13 je 107ac6 <== NEVER TAKEN 107ab3: 8b 50 1c mov 0x1c(%eax),%edx 107ab6: 85 d2 test %edx,%edx 107ab8: 74 0c je 107ac6 <== NEVER TAKEN 107aba: 83 ec 0c sub $0xc,%esp 107abd: 8d 45 e0 lea -0x20(%ebp),%eax 107ac0: 50 push %eax 107ac1: ff d2 call *%edx 107ac3: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &parent_loc ); 107ac6: 8b 45 d8 mov -0x28(%ebp),%eax 107ac9: 85 c0 test %eax,%eax 107acb: 74 13 je 107ae0 <== NEVER TAKEN 107acd: 8b 50 1c mov 0x1c(%eax),%edx 107ad0: 85 d2 test %edx,%edx 107ad2: 74 0c je 107ae0 <== NEVER TAKEN 107ad4: 83 ec 0c sub $0xc,%esp 107ad7: 8d 45 d0 lea -0x30(%ebp),%eax 107ada: 50 push %eax 107adb: ff d2 call *%edx 107add: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EXDEV ); 107ae0: e8 cb 9a 00 00 call 1115b0 <__errno> 107ae5: c7 00 12 00 00 00 movl $0x12,(%eax) 107aeb: eb af jmp 107a9c } if ( !parent_loc.ops->link_h ) { 107aed: 8b 45 d8 mov -0x28(%ebp),%eax 107af0: 8b 40 08 mov 0x8(%eax),%eax 107af3: 85 c0 test %eax,%eax 107af5: 75 44 jne 107b3b <== ALWAYS TAKEN rtems_filesystem_freenode( &existing_loc ); 107af7: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 107afa: 85 c0 test %eax,%eax <== NOT EXECUTED 107afc: 74 13 je 107b11 <== NOT EXECUTED 107afe: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 107b01: 85 d2 test %edx,%edx <== NOT EXECUTED 107b03: 74 0c je 107b11 <== NOT EXECUTED 107b05: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107b08: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 107b0b: 50 push %eax <== NOT EXECUTED 107b0c: ff d2 call *%edx <== NOT EXECUTED 107b0e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); 107b11: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 107b14: 85 c0 test %eax,%eax <== NOT EXECUTED 107b16: 74 13 je 107b2b <== NOT EXECUTED 107b18: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 107b1b: 85 d2 test %edx,%edx <== NOT EXECUTED 107b1d: 74 0c je 107b2b <== NOT EXECUTED 107b1f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107b22: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 107b25: 50 push %eax <== NOT EXECUTED 107b26: ff d2 call *%edx <== NOT EXECUTED 107b28: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 107b2b: e8 80 9a 00 00 call 1115b0 <__errno> <== NOT EXECUTED 107b30: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 107b36: e9 61 ff ff ff jmp 107a9c <== NOT EXECUTED } result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start ); 107b3b: 52 push %edx 107b3c: ff 75 f0 pushl -0x10(%ebp) 107b3f: 57 push %edi 107b40: 8d 7d e0 lea -0x20(%ebp),%edi 107b43: 57 push %edi 107b44: ff d0 call *%eax 107b46: 89 c6 mov %eax,%esi rtems_filesystem_freenode( &existing_loc ); 107b48: 8b 45 e8 mov -0x18(%ebp),%eax 107b4b: 83 c4 10 add $0x10,%esp 107b4e: 85 c0 test %eax,%eax 107b50: 74 10 je 107b62 <== NEVER TAKEN 107b52: 8b 40 1c mov 0x1c(%eax),%eax 107b55: 85 c0 test %eax,%eax 107b57: 74 09 je 107b62 <== NEVER TAKEN 107b59: 83 ec 0c sub $0xc,%esp 107b5c: 57 push %edi 107b5d: ff d0 call *%eax 107b5f: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &parent_loc ); 107b62: 8b 45 d8 mov -0x28(%ebp),%eax 107b65: 85 c0 test %eax,%eax 107b67: 74 13 je 107b7c <== NEVER TAKEN 107b69: 8b 50 1c mov 0x1c(%eax),%edx 107b6c: 85 d2 test %edx,%edx 107b6e: 74 0c je 107b7c <== NEVER TAKEN 107b70: 83 ec 0c sub $0xc,%esp 107b73: 8d 45 d0 lea -0x30(%ebp),%eax 107b76: 50 push %eax 107b77: ff d2 call *%edx 107b79: 83 c4 10 add $0x10,%esp return result; } 107b7c: 89 f0 mov %esi,%eax 107b7e: 8d 65 f4 lea -0xc(%ebp),%esp 107b81: 5b pop %ebx 107b82: 5e pop %esi 107b83: 5f pop %edi 107b84: c9 leave 107b85: c3 ret =============================================================================== 00115610 : off_t lseek( int fd, off_t offset, int whence ) { 115610: 55 push %ebp 115611: 89 e5 mov %esp,%ebp 115613: 56 push %esi 115614: 53 push %ebx 115615: 8b 45 08 mov 0x8(%ebp),%eax 115618: 8b 4d 0c mov 0xc(%ebp),%ecx 11561b: 8b 55 10 mov 0x10(%ebp),%edx rtems_libio_t *iop; off_t old_offset; off_t status; rtems_libio_check_fd( fd ); 11561e: 3b 05 d8 92 11 00 cmp 0x1192d8,%eax 115624: 73 0f jae 115635 <== NEVER TAKEN iop = rtems_libio_iop( fd ); 115626: 6b d8 34 imul $0x34,%eax,%ebx 115629: 03 1d 38 d6 11 00 add 0x11d638,%ebx rtems_libio_check_is_open(iop); 11562f: f6 43 0d 01 testb $0x1,0xd(%ebx) 115633: 75 0d jne 115642 <== ALWAYS TAKEN 115635: e8 ee 9a ff ff call 10f128 <__errno> <== NOT EXECUTED 11563a: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 115640: eb 46 jmp 115688 <== NOT EXECUTED /* * Check as many errors as possible before touching iop->offset. */ if ( !iop->handlers->lseek_h ) 115642: 8b 43 30 mov 0x30(%ebx),%eax 115645: 83 78 14 00 cmpl $0x0,0x14(%eax) 115649: 75 0d jne 115658 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); 11564b: e8 d8 9a ff ff call 10f128 <__errno> <== NOT EXECUTED 115650: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 115656: eb 30 jmp 115688 <== NOT EXECUTED /* * Now process the lseek(). */ old_offset = iop->offset; 115658: 8b 73 08 mov 0x8(%ebx),%esi switch ( whence ) { 11565b: 83 fa 01 cmp $0x1,%edx 11565e: 74 0e je 11566e 115660: 83 fa 02 cmp $0x2,%edx 115663: 74 0e je 115673 115665: 85 d2 test %edx,%edx 115667: 75 14 jne 11567d case SEEK_SET: iop->offset = offset; 115669: 89 4b 08 mov %ecx,0x8(%ebx) 11566c: eb 1f jmp 11568d break; case SEEK_CUR: iop->offset += offset; 11566e: 8d 04 31 lea (%ecx,%esi,1),%eax 115671: eb 05 jmp 115678 break; case SEEK_END: iop->offset = iop->size + offset; 115673: 89 c8 mov %ecx,%eax 115675: 03 43 04 add 0x4(%ebx),%eax 115678: 89 43 08 mov %eax,0x8(%ebx) 11567b: eb 10 jmp 11568d break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 11567d: e8 a6 9a ff ff call 10f128 <__errno> 115682: c7 00 16 00 00 00 movl $0x16,(%eax) 115688: 83 c8 ff or $0xffffffff,%eax 11568b: eb 15 jmp 1156a2 /* * At this time, handlers assume iop->offset has the desired * new offset. */ status = (*iop->handlers->lseek_h)( iop, offset, whence ); 11568d: 50 push %eax 11568e: 8b 43 30 mov 0x30(%ebx),%eax 115691: 52 push %edx 115692: 51 push %ecx 115693: 53 push %ebx 115694: ff 50 14 call *0x14(%eax) if ( status == (off_t) -1 ) 115697: 83 c4 10 add $0x10,%esp 11569a: 83 f8 ff cmp $0xffffffff,%eax 11569d: 75 03 jne 1156a2 iop->offset = old_offset; 11569f: 89 73 08 mov %esi,0x8(%ebx) /* * So if the operation failed, we have to restore iop->offset. */ return status; } 1156a2: 8d 65 f8 lea -0x8(%ebp),%esp 1156a5: 5b pop %ebx 1156a6: 5e pop %esi 1156a7: c9 leave 1156a8: c3 ret =============================================================================== 00106674 : size_t size ) { void *return_this; MSBUMP(malloc_calls, 1); 106674: 55 push %ebp 106675: 89 e5 mov %esp,%ebp 106677: 56 push %esi 106678: 53 push %ebx 106679: 8b 75 08 mov 0x8(%ebp),%esi 10667c: ff 05 ac d6 11 00 incl 0x11d6ac /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 106682: e8 48 ff ff ff call 1065cf /* * Validate the parameters */ if ( !size ) 106687: 85 f6 test %esi,%esi 106689: 74 75 je 106700 <== NEVER TAKEN return (void *) 0; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 10668b: 83 3d 38 d9 11 00 03 cmpl $0x3,0x11d938 106692: 75 09 jne 10669d 106694: e8 df fe ff ff call 106578 106699: 84 c0 test %al,%al 10669b: 74 63 je 106700 <== NEVER TAKEN * Try to give a segment in the current heap if there is not * enough space then try to grow the heap. * If this fails then return a NULL pointer. */ return_this = _Protected_heap_Allocate( &RTEMS_Malloc_Heap, size ); 10669d: 51 push %ecx 10669e: 51 push %ecx 10669f: 56 push %esi 1066a0: 68 50 d6 11 00 push $0x11d650 1066a5: e8 8e 42 00 00 call 10a938 <_Protected_heap_Allocate> 1066aa: 89 c3 mov %eax,%ebx if ( !return_this ) { 1066ac: 83 c4 10 add $0x10,%esp 1066af: 85 c0 test %eax,%eax 1066b1: 75 26 jne 1066d9 <== ALWAYS TAKEN if (rtems_malloc_sbrk_helpers) 1066b3: a1 d8 bb 11 00 mov 0x11bbd8,%eax <== NOT EXECUTED 1066b8: 85 c0 test %eax,%eax <== NOT EXECUTED 1066ba: 74 0e je 1066ca <== NOT EXECUTED return_this = (*rtems_malloc_sbrk_helpers->extend)( size ); 1066bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1066bf: 56 push %esi <== NOT EXECUTED 1066c0: ff 50 04 call *0x4(%eax) <== NOT EXECUTED if ( !return_this ) { 1066c3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1066c6: 85 c0 test %eax,%eax <== NOT EXECUTED 1066c8: 75 0d jne 1066d7 <== NOT EXECUTED errno = ENOMEM; 1066ca: e8 59 8a 00 00 call 10f128 <__errno> <== NOT EXECUTED 1066cf: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 1066d5: eb 2b jmp 106702 <== NOT EXECUTED return (void *) 0; 1066d7: 89 c3 mov %eax,%ebx <== NOT EXECUTED } /* * If the user wants us to dirty the allocated memory, then do it. */ if ( rtems_malloc_dirty_helper ) 1066d9: a1 dc bb 11 00 mov 0x11bbdc,%eax 1066de: 85 c0 test %eax,%eax 1066e0: 74 09 je 1066eb <== ALWAYS TAKEN (*rtems_malloc_dirty_helper)( return_this, size ); 1066e2: 52 push %edx <== NOT EXECUTED 1066e3: 52 push %edx <== NOT EXECUTED 1066e4: 56 push %esi <== NOT EXECUTED 1066e5: 53 push %ebx <== NOT EXECUTED 1066e6: ff d0 call *%eax <== NOT EXECUTED 1066e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 1066eb: a1 d4 bb 11 00 mov 0x11bbd4,%eax 1066f0: 85 c0 test %eax,%eax 1066f2: 74 0e je 106702 <== ALWAYS TAKEN (*rtems_malloc_statistics_helpers->at_malloc)(return_this); 1066f4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1066f7: 53 push %ebx <== NOT EXECUTED 1066f8: ff 50 04 call *0x4(%eax) <== NOT EXECUTED 1066fb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1066fe: eb 02 jmp 106702 <== NOT EXECUTED 106700: 31 db xor %ebx,%ebx if (rtems_malloc_boundary_helpers) (*rtems_malloc_boundary_helpers->at_malloc)(return_this, size); #endif return return_this; } 106702: 89 d8 mov %ebx,%eax 106704: 8d 65 f8 lea -0x8(%ebp),%esp 106707: 5b pop %ebx 106708: 5e pop %esi 106709: c9 leave 10670a: c3 ret =============================================================================== 001065b7 : } void malloc_deferred_free( void *pointer ) { 1065b7: 55 push %ebp <== NOT EXECUTED 1065b8: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1065ba: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 1065bd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1065c0: 68 44 d6 11 00 push $0x11d644 <== NOT EXECUTED 1065c5: e8 22 35 00 00 call 109aec <_Chain_Append> <== NOT EXECUTED 1065ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_chain_append(&RTEMS_Malloc_GC_list, (rtems_chain_node *)pointer); } 1065cd: c9 leave <== NOT EXECUTED 1065ce: c3 ret <== NOT EXECUTED =============================================================================== 001065cf : { rtems_chain_initialize_empty(&RTEMS_Malloc_GC_list); } void malloc_deferred_frees_process(void) { 1065cf: 55 push %ebp 1065d0: 89 e5 mov %esp,%ebp 1065d2: 83 ec 08 sub $0x8,%esp 1065d5: eb 0c jmp 1065e3 /* * If some free's have been deferred, then do them now. */ while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL) free(to_be_freed); 1065d7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1065da: 50 push %eax <== NOT EXECUTED 1065db: e8 98 fe ff ff call 106478 <== NOT EXECUTED 1065e0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1065e3: 83 ec 0c sub $0xc,%esp 1065e6: 68 44 d6 11 00 push $0x11d644 1065eb: e8 20 35 00 00 call 109b10 <_Chain_Get> rtems_chain_node *to_be_freed; /* * If some free's have been deferred, then do them now. */ while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL) 1065f0: 83 c4 10 add $0x10,%esp 1065f3: 85 c0 test %eax,%eax 1065f5: 75 e0 jne 1065d7 <== NEVER TAKEN free(to_be_freed); } 1065f7: c9 leave 1065f8: c3 ret =============================================================================== 00106578 : #include "malloc_p.h" rtems_chain_control RTEMS_Malloc_GC_list; bool malloc_is_system_state_OK(void) { 106578: 55 push %ebp 106579: 89 e5 mov %esp,%ebp if ( _Thread_Dispatch_disable_level > 0 ) 10657b: a1 98 d7 11 00 mov 0x11d798,%eax 106580: 31 d2 xor %edx,%edx 106582: 85 c0 test %eax,%eax 106584: 75 0a jne 106590 <== NEVER TAKEN return false; if ( _ISR_Nest_level > 0 ) 106586: a1 34 d8 11 00 mov 0x11d834,%eax 10658b: 85 c0 test %eax,%eax 10658d: 0f 94 c2 sete %dl return false; return true; } 106590: 88 d0 mov %dl,%al 106592: c9 leave 106593: c3 ret =============================================================================== 0010f8ec : */ int memfile_blocks_allocated = 0; void *memfile_alloc_block(void) { 10f8ec: 55 push %ebp 10f8ed: 89 e5 mov %esp,%ebp 10f8ef: 83 ec 10 sub $0x10,%esp void *memory; memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK); 10f8f2: ff 35 ac 11 12 00 pushl 0x1211ac 10f8f8: 6a 01 push $0x1 10f8fa: e8 fd 74 ff ff call 106dfc if ( memory ) 10f8ff: 83 c4 10 add $0x10,%esp 10f902: 85 c0 test %eax,%eax 10f904: 74 06 je 10f90c <== NEVER TAKEN memfile_blocks_allocated++; 10f906: ff 05 b8 12 12 00 incl 0x1212b8 return memory; } 10f90c: c9 leave 10f90d: c3 ret =============================================================================== 0010fc6d : return memfile_check_rmnod( the_jnode ); } int memfile_check_rmnod( IMFS_jnode_t *the_jnode ){ 10fc6d: 55 push %ebp 10fc6e: 89 e5 mov %esp,%ebp 10fc70: 53 push %ebx 10fc71: 83 ec 10 sub $0x10,%esp 10fc74: 8b 5d 08 mov 0x8(%ebp),%ebx /* * The file cannot be open and the link must be less than 1 to free. */ if ( !rtems_libio_is_file_open( the_jnode ) && (the_jnode->st_nlink < 1) ) { 10fc77: 53 push %ebx 10fc78: e8 23 79 ff ff call 1075a0 10fc7d: 83 c4 10 add $0x10,%esp 10fc80: 85 c0 test %eax,%eax 10fc82: 75 36 jne 10fcba 10fc84: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) 10fc89: 75 2f jne 10fcba <== NEVER TAKEN /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == the_jnode ) 10fc8b: a1 cc f3 11 00 mov 0x11f3cc,%eax 10fc90: 39 58 04 cmp %ebx,0x4(%eax) 10fc93: 75 07 jne 10fc9c <== ALWAYS TAKEN rtems_filesystem_current.node_access = NULL; 10fc95: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED /* * Free memory associated with a memory file. */ if (the_jnode->type != IMFS_LINEAR_FILE) 10fc9c: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) 10fca0: 74 0c je 10fcae <== NEVER TAKEN IMFS_memfile_remove( the_jnode ); 10fca2: 83 ec 0c sub $0xc,%esp 10fca5: 53 push %ebx 10fca6: e8 7b fe ff ff call 10fb26 10fcab: 83 c4 10 add $0x10,%esp free( the_jnode ); 10fcae: 83 ec 0c sub $0xc,%esp 10fcb1: 53 push %ebx 10fcb2: e8 41 76 ff ff call 1072f8 10fcb7: 83 c4 10 add $0x10,%esp } return 0; } 10fcba: 31 c0 xor %eax,%eax 10fcbc: 8b 5d fc mov -0x4(%ebp),%ebx 10fcbf: c9 leave 10fcc0: c3 ret =============================================================================== 0010fabc : void memfile_free_blocks_in_table( block_p **block_table, int entries ) { 10fabc: 55 push %ebp 10fabd: 89 e5 mov %esp,%ebp 10fabf: 57 push %edi 10fac0: 56 push %esi 10fac1: 53 push %ebx 10fac2: 83 ec 0c sub $0xc,%esp 10fac5: 8b 75 08 mov 0x8(%ebp),%esi /* * Perform internal consistency checks */ assert( block_table ); 10fac8: 85 f6 test %esi,%esi 10faca: 75 19 jne 10fae5 <== ALWAYS TAKEN 10facc: 68 36 b6 11 00 push $0x11b636 <== NOT EXECUTED 10fad1: 68 28 b7 11 00 push $0x11b728 <== NOT EXECUTED 10fad6: 68 b1 01 00 00 push $0x1b1 <== NOT EXECUTED 10fadb: 68 c6 b5 11 00 push $0x11b5c6 <== NOT EXECUTED 10fae0: e8 bf 72 ff ff call 106da4 <__assert_func> <== NOT EXECUTED /* * Now go through all the slots in the table and free the memory. */ b = *block_table; 10fae5: 8b 3e mov (%esi),%edi 10fae7: 31 db xor %ebx,%ebx 10fae9: eb 1b jmp 10fb06 for ( i=0 ; i memfile_free_block( b[i] ); 10faf2: 83 ec 0c sub $0xc,%esp 10faf5: 50 push %eax 10faf6: e8 d8 fd ff ff call 10f8d3 b[i] = 0; 10fafb: c7 04 9f 00 00 00 00 movl $0x0,(%edi,%ebx,4) 10fb02: 83 c4 10 add $0x10,%esp * Now go through all the slots in the table and free the memory. */ b = *block_table; for ( i=0 ; i /* * Now that all the blocks in the block table are free, we can * free the block table itself. */ memfile_free_block( *block_table ); 10fb0b: 83 ec 0c sub $0xc,%esp 10fb0e: ff 36 pushl (%esi) 10fb10: e8 be fd ff ff call 10f8d3 *block_table = 0; 10fb15: c7 06 00 00 00 00 movl $0x0,(%esi) 10fb1b: 83 c4 10 add $0x10,%esp } 10fb1e: 8d 65 f4 lea -0xc(%ebp),%esp 10fb21: 5b pop %ebx 10fb22: 5e pop %esi 10fb23: 5f pop %edi 10fb24: c9 leave 10fb25: c3 ret =============================================================================== 0010fe71 : int memfile_ftruncate( rtems_libio_t *iop, off_t length ) { 10fe71: 55 push %ebp 10fe72: 89 e5 mov %esp,%ebp 10fe74: 53 push %ebx 10fe75: 83 ec 14 sub $0x14,%esp 10fe78: 8b 55 08 mov 0x8(%ebp),%edx 10fe7b: 8b 45 0c mov 0xc(%ebp),%eax IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 10fe7e: 8b 5a 2c mov 0x2c(%edx),%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 ) 10fe81: 3b 43 50 cmp 0x50(%ebx),%eax 10fe84: 7e 0b jle 10fe91 <== ALWAYS TAKEN return IMFS_memfile_extend( the_jnode, length ); 10fe86: 52 push %edx <== NOT EXECUTED 10fe87: 52 push %edx <== NOT EXECUTED 10fe88: 50 push %eax <== NOT EXECUTED 10fe89: 53 push %ebx <== NOT EXECUTED 10fe8a: e8 0f ff ff ff call 10fd9e <== NOT EXECUTED 10fe8f: eb 1b jmp 10feac <== NOT EXECUTED * 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; 10fe91: 89 43 50 mov %eax,0x50(%ebx) iop->size = the_jnode->info.file.size; 10fe94: 89 42 04 mov %eax,0x4(%edx) IMFS_update_atime( the_jnode ); 10fe97: 50 push %eax 10fe98: 50 push %eax 10fe99: 6a 00 push $0x0 10fe9b: 8d 45 f4 lea -0xc(%ebp),%eax 10fe9e: 50 push %eax 10fe9f: e8 c4 75 ff ff call 107468 10fea4: 8b 45 f4 mov -0xc(%ebp),%eax 10fea7: 89 43 40 mov %eax,0x40(%ebx) 10feaa: 31 c0 xor %eax,%eax 10feac: 83 c4 10 add $0x10,%esp return 0; } 10feaf: 8b 5d fc mov -0x4(%ebp),%ebx 10feb2: c9 leave 10feb3: c3 ret =============================================================================== 0010feb4 : off_t memfile_lseek( rtems_libio_t *iop, off_t offset, int whence ) { 10feb4: 55 push %ebp 10feb5: 89 e5 mov %esp,%ebp 10feb7: 56 push %esi 10feb8: 53 push %ebx 10feb9: 8b 75 08 mov 0x8(%ebp),%esi IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 10febc: 8b 5e 2c mov 0x2c(%esi),%ebx if (the_jnode->type == IMFS_LINEAR_FILE) { 10febf: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) 10fec3: 75 0d jne 10fed2 <== ALWAYS TAKEN if (iop->offset > the_jnode->info.linearfile.size) 10fec5: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10fec8: 39 46 08 cmp %eax,0x8(%esi) <== NOT EXECUTED 10fecb: 7e 2d jle 10fefa <== NOT EXECUTED iop->offset = the_jnode->info.linearfile.size; 10fecd: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED 10fed0: eb 28 jmp 10fefa <== NOT EXECUTED } else { /* Must be a block file (IMFS_MEMORY_FILE). */ if (IMFS_memfile_extend( the_jnode, iop->offset )) 10fed2: 51 push %ecx 10fed3: 51 push %ecx 10fed4: ff 76 08 pushl 0x8(%esi) 10fed7: 53 push %ebx 10fed8: e8 c1 fe ff ff call 10fd9e 10fedd: 83 c4 10 add $0x10,%esp 10fee0: 85 c0 test %eax,%eax 10fee2: 74 10 je 10fef4 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOSPC ); 10fee4: e8 f7 10 00 00 call 110fe0 <__errno> <== NOT EXECUTED 10fee9: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 10feef: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10fef2: eb 09 jmp 10fefd <== NOT EXECUTED iop->size = the_jnode->info.file.size; 10fef4: 8b 43 50 mov 0x50(%ebx),%eax 10fef7: 89 46 04 mov %eax,0x4(%esi) } return iop->offset; 10fefa: 8b 46 08 mov 0x8(%esi),%eax } 10fefd: 8d 65 f8 lea -0x8(%ebp),%esp 10ff00: 5b pop %ebx 10ff01: 5e pop %esi 10ff02: c9 leave 10ff03: c3 ret =============================================================================== 001100fb : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 1100fb: 55 push %ebp 1100fc: 89 e5 mov %esp,%ebp 1100fe: 56 push %esi 1100ff: 53 push %ebx 110100: 8b 75 08 mov 0x8(%ebp),%esi IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 110103: 8b 5e 2c mov 0x2c(%esi),%ebx /* * Perform 'copy on write' for linear files */ if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND)) 110106: f7 46 0c 04 02 00 00 testl $0x204,0xc(%esi) 11010d: 74 46 je 110155 11010f: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) 110113: 75 40 jne 110155 <== ALWAYS TAKEN && (the_jnode->type == IMFS_LINEAR_FILE)) { uint32_t count = the_jnode->info.linearfile.size; 110115: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED const unsigned char *buffer = the_jnode->info.linearfile.direct; 110118: 8b 53 54 mov 0x54(%ebx),%edx <== NOT EXECUTED the_jnode->type = IMFS_MEMORY_FILE; 11011b: c7 43 4c 05 00 00 00 movl $0x5,0x4c(%ebx) <== NOT EXECUTED the_jnode->info.file.size = 0; 110122: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED the_jnode->info.file.indirect = 0; 110129: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED the_jnode->info.file.doubly_indirect = 0; 110130: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED the_jnode->info.file.triply_indirect = 0; 110137: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED if ((count != 0) 11013e: 85 c0 test %eax,%eax <== NOT EXECUTED 110140: 74 13 je 110155 <== NOT EXECUTED 110142: 50 push %eax <== NOT EXECUTED 110143: 52 push %edx <== NOT EXECUTED 110144: 6a 00 push $0x0 <== NOT EXECUTED 110146: 53 push %ebx <== NOT EXECUTED 110147: e8 b8 fd ff ff call 10ff04 <== NOT EXECUTED 11014c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11014f: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 110152: 40 inc %eax <== NOT EXECUTED 110153: 74 14 je 110169 <== NOT EXECUTED && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) return -1; } if (iop->flags & LIBIO_FLAGS_APPEND) 110155: f6 46 0d 02 testb $0x2,0xd(%esi) 110159: 74 06 je 110161 iop->offset = the_jnode->info.file.size; 11015b: 8b 43 50 mov 0x50(%ebx),%eax 11015e: 89 46 08 mov %eax,0x8(%esi) iop->size = the_jnode->info.file.size; 110161: 8b 43 50 mov 0x50(%ebx),%eax 110164: 89 46 04 mov %eax,0x4(%esi) 110167: 31 d2 xor %edx,%edx return 0; } 110169: 89 d0 mov %edx,%eax 11016b: 8d 65 f8 lea -0x8(%ebp),%esp 11016e: 5b pop %ebx 11016f: 5e pop %esi 110170: c9 leave 110171: c3 ret =============================================================================== 0010fcc1 : */ int memfile_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 10fcc1: 55 push %ebp 10fcc2: 89 e5 mov %esp,%ebp 10fcc4: 53 push %ebx 10fcc5: 83 ec 14 sub $0x14,%esp IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 10fcc8: 8b 45 08 mov 0x8(%ebp),%eax 10fccb: 8b 18 mov (%eax),%ebx /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 10fccd: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10fcd1: 74 13 je 10fce6 <== NEVER TAKEN 10fcd3: 83 ec 0c sub $0xc,%esp 10fcd6: 53 push %ebx 10fcd7: e8 58 f3 ff ff call 10f034 <_Chain_Extract> rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 10fcdc: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 10fce3: 83 c4 10 add $0x10,%esp /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 10fce6: 66 ff 4b 34 decw 0x34(%ebx) IMFS_update_ctime( the_jnode ); 10fcea: 50 push %eax 10fceb: 50 push %eax 10fcec: 6a 00 push $0x0 10fcee: 8d 45 f4 lea -0xc(%ebp),%eax 10fcf1: 50 push %eax 10fcf2: e8 71 77 ff ff call 107468 10fcf7: 8b 45 f4 mov -0xc(%ebp),%eax 10fcfa: 89 43 48 mov %eax,0x48(%ebx) return memfile_check_rmnod( the_jnode ); 10fcfd: 89 1c 24 mov %ebx,(%esp) 10fd00: e8 68 ff ff ff call 10fc6d } 10fd05: 8b 5d fc mov -0x4(%ebp),%ebx 10fd08: c9 leave 10fd09: c3 ret =============================================================================== 0010670c : int mknod( const char *pathname, mode_t mode, dev_t dev ) { 10670c: 55 push %ebp 10670d: 89 e5 mov %esp,%ebp 10670f: 57 push %edi 106710: 56 push %esi 106711: 53 push %ebx 106712: 83 ec 2c sub $0x2c,%esp 106715: 8b 5d 08 mov 0x8(%ebp),%ebx 106718: 8b 45 10 mov 0x10(%ebp),%eax 10671b: 8b 55 14 mov 0x14(%ebp),%edx 10671e: 89 45 c8 mov %eax,-0x38(%ebp) 106721: 89 55 cc mov %edx,-0x34(%ebp) int result; /* * The file type is field within the mode. Check we have a sane mode set. */ switch (mode & S_IFMT) { 106724: 8b 45 0c mov 0xc(%ebp),%eax 106727: 25 00 f0 00 00 and $0xf000,%eax 10672c: 3d 00 40 00 00 cmp $0x4000,%eax 106731: 74 2b je 10675e 106733: 77 0e ja 106743 106735: 3d 00 10 00 00 cmp $0x1000,%eax 10673a: 74 29 je 106765 10673c: 3d 00 20 00 00 cmp $0x2000,%eax 106741: eb 0c jmp 10674f 106743: 3d 00 60 00 00 cmp $0x6000,%eax 106748: 74 14 je 10675e <== NEVER TAKEN 10674a: 3d 00 80 00 00 cmp $0x8000,%eax 10674f: 74 0d je 10675e <== ALWAYS TAKEN case S_IFBLK: case S_IFREG: case S_IFIFO: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 106751: e8 d2 89 00 00 call 10f128 <__errno> <== NOT EXECUTED 106756: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10675c: eb 12 jmp 106770 <== NOT EXECUTED } if ( S_ISFIFO(mode) ) 10675e: 3d 00 10 00 00 cmp $0x1000,%eax 106763: 75 13 jne 106778 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); 106765: e8 be 89 00 00 call 10f128 <__errno> 10676a: c7 00 86 00 00 00 movl $0x86,(%eax) 106770: 83 ce ff or $0xffffffff,%esi 106773: e9 a6 00 00 00 jmp 10681e rtems_filesystem_get_start_loc( pathname, &i, &temp_loc ); 106778: 8a 03 mov (%ebx),%al 10677a: 3c 2f cmp $0x2f,%al 10677c: 74 08 je 106786 10677e: 3c 5c cmp $0x5c,%al 106780: 74 04 je 106786 <== NEVER TAKEN 106782: 84 c0 test %al,%al 106784: 75 16 jne 10679c <== ALWAYS TAKEN 106786: 8d 7d dc lea -0x24(%ebp),%edi 106789: a1 6c b6 11 00 mov 0x11b66c,%eax 10678e: 8d 70 14 lea 0x14(%eax),%esi 106791: b9 04 00 00 00 mov $0x4,%ecx 106796: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 106798: b1 01 mov $0x1,%cl 10679a: eb 12 jmp 1067ae 10679c: 8d 7d dc lea -0x24(%ebp),%edi 10679f: a1 6c b6 11 00 mov 0x11b66c,%eax 1067a4: 8d 70 04 lea 0x4(%eax),%esi 1067a7: b9 04 00 00 00 mov $0x4,%ecx 1067ac: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !temp_loc.ops->evalformake_h ) { 1067ae: 8b 45 e4 mov -0x1c(%ebp),%eax 1067b1: 8b 50 04 mov 0x4(%eax),%edx 1067b4: 85 d2 test %edx,%edx 1067b6: 74 ad je 106765 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*temp_loc.ops->evalformake_h)( 1067b8: 50 push %eax 1067b9: 8d 45 ec lea -0x14(%ebp),%eax 1067bc: 50 push %eax 1067bd: 8d 7d dc lea -0x24(%ebp),%edi 1067c0: 57 push %edi 1067c1: 8d 04 0b lea (%ebx,%ecx,1),%eax 1067c4: 50 push %eax 1067c5: ff d2 call *%edx &pathname[i], &temp_loc, &name_start ); if ( result != 0 ) 1067c7: 83 c4 10 add $0x10,%esp 1067ca: 83 ce ff or $0xffffffff,%esi 1067cd: 85 c0 test %eax,%eax 1067cf: 75 4d jne 10681e return -1; if ( !temp_loc.ops->mknod_h ) { 1067d1: 8b 45 e4 mov -0x1c(%ebp),%eax 1067d4: 8b 50 14 mov 0x14(%eax),%edx 1067d7: 85 d2 test %edx,%edx 1067d9: 75 15 jne 1067f0 <== ALWAYS TAKEN rtems_filesystem_freenode( &temp_loc ); 1067db: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1067de: 85 c0 test %eax,%eax <== NOT EXECUTED 1067e0: 74 83 je 106765 <== NOT EXECUTED 1067e2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1067e5: 57 push %edi <== NOT EXECUTED 1067e6: ff d0 call *%eax <== NOT EXECUTED 1067e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1067eb: e9 75 ff ff ff jmp 106765 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc ); 1067f0: 83 ec 0c sub $0xc,%esp 1067f3: 57 push %edi 1067f4: ff 75 cc pushl -0x34(%ebp) 1067f7: ff 75 c8 pushl -0x38(%ebp) 1067fa: ff 75 0c pushl 0xc(%ebp) 1067fd: ff 75 ec pushl -0x14(%ebp) 106800: ff d2 call *%edx 106802: 89 c6 mov %eax,%esi rtems_filesystem_freenode( &temp_loc ); 106804: 8b 45 e4 mov -0x1c(%ebp),%eax 106807: 83 c4 20 add $0x20,%esp 10680a: 85 c0 test %eax,%eax 10680c: 74 10 je 10681e <== NEVER TAKEN 10680e: 8b 40 1c mov 0x1c(%eax),%eax 106811: 85 c0 test %eax,%eax 106813: 74 09 je 10681e 106815: 83 ec 0c sub $0xc,%esp 106818: 57 push %edi 106819: ff d0 call *%eax 10681b: 83 c4 10 add $0x10,%esp return result; } 10681e: 89 f0 mov %esi,%eax 106820: 8d 65 f4 lea -0xc(%ebp),%esp 106823: 5b pop %ebx 106824: 5e pop %esi 106825: 5f pop %edi 106826: c9 leave 106827: c3 ret =============================================================================== 0010d119 : const rtems_filesystem_operations_table *fs_ops, rtems_filesystem_options_t options, const char *device, const char *mount_point ) { 10d119: 55 push %ebp 10d11a: 89 e5 mov %esp,%ebp 10d11c: 57 push %edi 10d11d: 56 push %esi 10d11e: 53 push %ebx 10d11f: 83 ec 1c sub $0x1c,%esp 10d122: 8b 75 10 mov 0x10(%ebp),%esi /* * Is there a file system operations table? */ if ( fs_ops == NULL ) { 10d125: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10d129: 74 05 je 10d130 /* * Are the file system options valid? */ if ( options != RTEMS_FILESYSTEM_READ_ONLY && 10d12b: 83 fe 01 cmp $0x1,%esi 10d12e: 76 10 jbe 10d140 options != RTEMS_FILESYSTEM_READ_WRITE ) { errno = EINVAL; 10d130: e8 f3 1f 00 00 call 10f128 <__errno> 10d135: c7 00 16 00 00 00 movl $0x16,(%eax) 10d13b: e9 e4 01 00 00 jmp 10d324 return -1; } /* Do they support being mounted at all ? */ if ( !fs_ops->fsmount_me_h ) { 10d140: 8b 45 0c mov 0xc(%ebp),%eax 10d143: 83 78 24 00 cmpl $0x0,0x24(%eax) 10d147: 75 17 jne 10d160 <== ALWAYS TAKEN errno = ENOTSUP; 10d149: e8 da 1f 00 00 call 10f128 <__errno> <== NOT EXECUTED 10d14e: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10d154: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 10d15b: e9 94 01 00 00 jmp 10d2f4 <== NOT EXECUTED /* * Allocate a mount table entry */ size = sizeof(rtems_filesystem_mount_table_entry_t); if ( device ) 10d160: b8 64 00 00 00 mov $0x64,%eax 10d165: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10d169: 74 0f je 10d17a <== ALWAYS TAKEN size += strlen( device ) + 1; 10d16b: 31 c0 xor %eax,%eax 10d16d: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 10d170: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 10d173: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 10d175: f7 d1 not %ecx <== NOT EXECUTED 10d177: 8d 41 64 lea 0x64(%ecx),%eax <== NOT EXECUTED temp_mt_entry = malloc( size ); 10d17a: 83 ec 0c sub $0xc,%esp 10d17d: 50 push %eax 10d17e: e8 f1 94 ff ff call 106674 10d183: 89 c3 mov %eax,%ebx 10d185: 89 45 e0 mov %eax,-0x20(%ebp) if ( !temp_mt_entry ) { 10d188: 83 c4 10 add $0x10,%esp 10d18b: 85 c0 test %eax,%eax 10d18d: 75 10 jne 10d19f <== ALWAYS TAKEN errno = ENOMEM; 10d18f: e8 94 1f 00 00 call 10f128 <__errno> <== NOT EXECUTED 10d194: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10d19a: e9 85 01 00 00 jmp 10d324 <== NOT EXECUTED return -1; } temp_mt_entry->mt_fs_root.mt_entry = temp_mt_entry; 10d19f: 89 43 24 mov %eax,0x24(%ebx) temp_mt_entry->options = options; 10d1a2: 89 70 28 mov %esi,0x28(%eax) if ( device ) { 10d1a5: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10d1a9: 74 16 je 10d1c1 <== ALWAYS TAKEN temp_mt_entry->dev = 10d1ab: 8d 40 64 lea 0x64(%eax),%eax <== NOT EXECUTED 10d1ae: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED (char *)temp_mt_entry + sizeof( rtems_filesystem_mount_table_entry_t ); strcpy( temp_mt_entry->dev, device ); 10d1b1: 52 push %edx <== NOT EXECUTED 10d1b2: 52 push %edx <== NOT EXECUTED 10d1b3: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10d1b6: 50 push %eax <== NOT EXECUTED 10d1b7: e8 cc 30 00 00 call 110288 <== NOT EXECUTED 10d1bc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d1bf: eb 07 jmp 10d1c8 <== NOT EXECUTED } else temp_mt_entry->dev = 0; 10d1c1: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) /* * The mount_point should be a directory with read/write/execute * permissions in the existing tree. */ if ( mount_point ) { 10d1c8: 83 7d 18 00 cmpl $0x0,0x18(%ebp) 10d1cc: 0f 84 a8 00 00 00 je 10d27a if ( rtems_filesystem_evaluate_path( 10d1d2: 6a 01 push $0x1 10d1d4: 8d 75 e4 lea -0x1c(%ebp),%esi 10d1d7: 56 push %esi 10d1d8: 6a 07 push $0x7 10d1da: ff 75 18 pushl 0x18(%ebp) 10d1dd: e8 74 91 ff ff call 106356 10d1e2: 83 c4 10 add $0x10,%esp 10d1e5: 40 inc %eax 10d1e6: 0f 84 08 01 00 00 je 10d2f4 <== NEVER TAKEN /* * Test for node_type_h */ if (!loc.ops->node_type_h) { 10d1ec: 8b 45 ec mov -0x14(%ebp),%eax 10d1ef: 8b 40 10 mov 0x10(%eax),%eax 10d1f2: 85 c0 test %eax,%eax 10d1f4: 75 10 jne 10d206 <== ALWAYS TAKEN errno = ENOTSUP; 10d1f6: e8 2d 1f 00 00 call 10f128 <__errno> <== NOT EXECUTED 10d1fb: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10d201: e9 f0 00 00 00 jmp 10d2f6 <== NOT EXECUTED /* * Test to see if it is a directory */ if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 10d206: 83 ec 0c sub $0xc,%esp 10d209: 56 push %esi 10d20a: ff d0 call *%eax 10d20c: 83 c4 10 add $0x10,%esp 10d20f: 48 dec %eax 10d210: 74 10 je 10d222 errno = ENOTDIR; 10d212: e8 11 1f 00 00 call 10f128 <__errno> 10d217: c7 00 14 00 00 00 movl $0x14,(%eax) 10d21d: e9 d4 00 00 00 jmp 10d2f6 /* * For each mount table entry */ for ( the_node = rtems_filesystem_mount_table_control.first; 10d222: a1 30 dd 11 00 mov 0x11dd30,%eax !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); the_node = the_node->next ) { the_mount_entry = (rtems_filesystem_mount_table_entry_t *) the_node; if ( the_mount_entry->mt_fs_root.node_access == loc->node_access ) 10d227: 8b 55 e4 mov -0x1c(%ebp),%edx 10d22a: eb 07 jmp 10d233 10d22c: 39 50 18 cmp %edx,0x18(%eax) 10d22f: 74 0e je 10d23f * For each mount table entry */ for ( the_node = rtems_filesystem_mount_table_control.first; !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); the_node = the_node->next ) { 10d231: 8b 00 mov (%eax),%eax /* * For each mount table entry */ for ( the_node = rtems_filesystem_mount_table_control.first; !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); 10d233: 3d 34 dd 11 00 cmp $0x11dd34,%eax 10d238: 75 f2 jne 10d22c 10d23a: e9 f0 00 00 00 jmp 10d32f /* * You can only mount one file system onto a single mount point. */ if ( Is_node_fs_root( &loc ) ){ errno = EBUSY; 10d23f: e8 e4 1e 00 00 call 10f128 <__errno> 10d244: c7 00 10 00 00 00 movl $0x10,(%eax) 10d24a: eb 0b jmp 10d257 * This link to the parent is only done when we are dealing with system * below the base file system */ if ( !loc.ops->mount_h ){ errno = ENOTSUP; 10d24c: e8 d7 1e 00 00 call 10f128 <__errno> <== NOT EXECUTED 10d251: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10d257: 8d 75 e4 lea -0x1c(%ebp),%esi 10d25a: e9 97 00 00 00 jmp 10d2f6 goto cleanup_and_bail; } if ( loc.ops->mount_h( temp_mt_entry ) ) { 10d25f: 83 ec 0c sub $0xc,%esp 10d262: 53 push %ebx 10d263: ff d0 call *%eax 10d265: 83 c4 10 add $0x10,%esp 10d268: 85 c0 test %eax,%eax 10d26a: 8d 45 e4 lea -0x1c(%ebp),%eax 10d26d: 74 07 je 10d276 <== ALWAYS TAKEN 10d26f: 89 c6 mov %eax,%esi <== NOT EXECUTED 10d271: e9 80 00 00 00 jmp 10d2f6 <== NOT EXECUTED 10d276: 89 c6 mov %eax,%esi 10d278: eb 33 jmp 10d2ad * This is a mount of the base file system --> The * mt_point_node.node_access will be set to null to indicate that this * is the root of the entire file system. */ temp_mt_entry->mt_fs_root.node_access = NULL; 10d27a: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) temp_mt_entry->mt_fs_root.handlers = NULL; 10d281: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) temp_mt_entry->mt_fs_root.ops = NULL; 10d288: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) temp_mt_entry->mt_point_node.node_access = NULL; 10d28f: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) temp_mt_entry->mt_point_node.handlers = NULL; 10d296: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) temp_mt_entry->mt_point_node.ops = NULL; 10d29d: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) temp_mt_entry->mt_point_node.mt_entry = NULL; 10d2a4: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) 10d2ab: 31 f6 xor %esi,%esi } if ( fs_ops->fsmount_me_h( temp_mt_entry ) ) { 10d2ad: 83 ec 0c sub $0xc,%esp 10d2b0: 53 push %ebx 10d2b1: 8b 55 0c mov 0xc(%ebp),%edx 10d2b4: ff 52 24 call *0x24(%edx) 10d2b7: 83 c4 10 add $0x10,%esp 10d2ba: 85 c0 test %eax,%eax 10d2bc: 74 15 je 10d2d3 <== ALWAYS TAKEN /* try to undo the mount operation */ if ( loc.ops->unmount_h ) { 10d2be: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10d2c1: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 10d2c4: 85 c0 test %eax,%eax <== NOT EXECUTED 10d2c6: 74 2e je 10d2f6 <== NOT EXECUTED loc.ops->unmount_h( temp_mt_entry ); 10d2c8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d2cb: 53 push %ebx <== NOT EXECUTED 10d2cc: ff d0 call *%eax <== NOT EXECUTED 10d2ce: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d2d1: eb 23 jmp 10d2f6 <== NOT EXECUTED 10d2d3: 50 push %eax 10d2d4: 50 push %eax 10d2d5: 53 push %ebx 10d2d6: 68 30 dd 11 00 push $0x11dd30 10d2db: e8 0c c8 ff ff call 109aec <_Chain_Append> */ rtems_chain_append( &rtems_filesystem_mount_table_control, &temp_mt_entry->Node ); if ( mt_entry ) 10d2e0: 83 c4 10 add $0x10,%esp 10d2e3: 31 c0 xor %eax,%eax 10d2e5: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 10d2e9: 74 3c je 10d327 <== NEVER TAKEN *mt_entry = temp_mt_entry; 10d2eb: 8b 7d 08 mov 0x8(%ebp),%edi 10d2ee: 89 1f mov %ebx,(%edi) 10d2f0: 31 c0 xor %eax,%eax 10d2f2: eb 33 jmp 10d327 10d2f4: 31 f6 xor %esi,%esi return 0; cleanup_and_bail: free( temp_mt_entry ); 10d2f6: 83 ec 0c sub $0xc,%esp 10d2f9: ff 75 e0 pushl -0x20(%ebp) 10d2fc: e8 77 91 ff ff call 106478 if ( loc_to_free ) 10d301: 83 c4 10 add $0x10,%esp 10d304: 85 f6 test %esi,%esi 10d306: 74 1c je 10d324 <== NEVER TAKEN rtems_filesystem_freenode( loc_to_free ); 10d308: 8b 46 08 mov 0x8(%esi),%eax 10d30b: 85 c0 test %eax,%eax 10d30d: 74 15 je 10d324 <== NEVER TAKEN 10d30f: 8b 40 1c mov 0x1c(%eax),%eax 10d312: 85 c0 test %eax,%eax 10d314: 74 0e je 10d324 <== NEVER TAKEN 10d316: 83 ec 0c sub $0xc,%esp 10d319: 56 push %esi 10d31a: ff d0 call *%eax 10d31c: 83 c8 ff or $0xffffffff,%eax 10d31f: 83 c4 10 add $0x10,%esp 10d322: eb 03 jmp 10d327 10d324: 83 c8 ff or $0xffffffff,%eax return -1; } 10d327: 8d 65 f4 lea -0xc(%ebp),%esp 10d32a: 5b pop %ebx 10d32b: 5e pop %esi 10d32c: 5f pop %edi 10d32d: c9 leave 10d32e: c3 ret * 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. */ temp_mt_entry->mt_point_node.node_access = loc.node_access; 10d32f: 89 53 08 mov %edx,0x8(%ebx) temp_mt_entry->mt_point_node.handlers = loc.handlers; 10d332: 8b 45 e8 mov -0x18(%ebp),%eax 10d335: 89 43 0c mov %eax,0xc(%ebx) temp_mt_entry->mt_point_node.ops = loc.ops; 10d338: 8b 55 ec mov -0x14(%ebp),%edx 10d33b: 89 53 10 mov %edx,0x10(%ebx) temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry; 10d33e: 8b 45 f0 mov -0x10(%ebp),%eax 10d341: 89 43 14 mov %eax,0x14(%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 ){ 10d344: 8b 42 20 mov 0x20(%edx),%eax 10d347: 85 c0 test %eax,%eax 10d349: 0f 85 10 ff ff ff jne 10d25f <== ALWAYS TAKEN 10d34f: e9 f8 fe ff ff jmp 10d24c <== NOT EXECUTED =============================================================================== 0010cb00 : */ int mq_unlink( const char *name ) { 10cb00: 55 push %ebp 10cb01: 89 e5 mov %esp,%ebp 10cb03: 53 push %ebx 10cb04: 83 ec 1c sub $0x1c,%esp /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10cb07: a1 58 63 12 00 mov 0x126358,%eax 10cb0c: 40 inc %eax 10cb0d: a3 58 63 12 00 mov %eax,0x126358 register POSIX_Message_queue_Control *the_mq; Objects_Id the_mq_id; _Thread_Disable_dispatch(); status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); 10cb12: 8d 45 f8 lea -0x8(%ebp),%eax 10cb15: 50 push %eax 10cb16: ff 75 08 pushl 0x8(%ebp) 10cb19: e8 32 5a 00 00 call 112550 <_POSIX_Message_queue_Name_to_id> 10cb1e: 89 c3 mov %eax,%ebx if ( status != 0 ) { 10cb20: 83 c4 10 add $0x10,%esp 10cb23: 85 c0 test %eax,%eax 10cb25: 74 11 je 10cb38 _Thread_Enable_dispatch(); 10cb27: e8 08 32 00 00 call 10fd34 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( status ); 10cb2c: e8 db 78 00 00 call 11440c <__errno> 10cb31: 89 18 mov %ebx,(%eax) 10cb33: 83 c8 ff or $0xffffffff,%eax 10cb36: eb 3c jmp 10cb74 } the_mq = (POSIX_Message_queue_Control *) _Objects_Get_local_object( 10cb38: 8b 45 f8 mov -0x8(%ebp),%eax bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 10cb3b: 31 db xor %ebx,%ebx 10cb3d: 66 3b 05 d8 66 12 00 cmp 0x1266d8,%ax 10cb44: 77 0b ja 10cb51 <== NEVER TAKEN * This heap routine returns information about the free blocks * in the specified heap. 10cb46: 0f b7 d0 movzwl %ax,%edx 10cb49: a1 e4 66 12 00 mov 0x1266e4,%eax 10cb4e: 8b 1c 90 mov (%eax,%edx,4),%ebx &_POSIX_Message_queue_Information, _Objects_Get_index( the_mq_id ) ); the_mq->linked = FALSE; 10cb51: c6 43 15 00 movb $0x0,0x15(%ebx) /** * This function attempts to allocate a block of @a size bytes from * @a the_heap. If insufficient memory is free in @a the_heap to allocate * a block of the requested size, then NULL is returned. * 10cb55: 50 push %eax 10cb56: 50 push %eax 10cb57: 53 push %ebx 10cb58: 68 c8 66 12 00 push $0x1266c8 10cb5d: e8 da 2a 00 00 call 10f63c <_Objects_Namespace_remove> _POSIX_Message_queue_Namespace_remove( the_mq ); _POSIX_Message_queue_Delete( the_mq ); 10cb62: 89 1c 24 mov %ebx,(%esp) 10cb65: e8 92 f9 ff ff call 10c4fc <_POSIX_Message_queue_Delete> _Thread_Enable_dispatch(); 10cb6a: e8 c5 31 00 00 call 10fd34 <_Thread_Enable_dispatch> 10cb6f: 31 c0 xor %eax,%eax 10cb71: 83 c4 10 add $0x10,%esp return 0; } 10cb74: 8b 5d fc mov -0x4(%ebp),%ebx 10cb77: c9 leave 10cb78: c3 ret =============================================================================== 0010d834 : int nanosleep( const struct timespec *rqtp, struct timespec *rmtp ) { 10d834: 55 push %ebp 10d835: 89 e5 mov %esp,%ebp 10d837: 56 push %esi 10d838: 53 push %ebx 10d839: 8b 5d 08 mov 0x8(%ebp),%ebx 10d83c: 8b 75 0c mov 0xc(%ebp),%esi Watchdog_Interval ticks; if ( !_Timespec_Is_valid( rqtp ) ) 10d83f: 83 ec 0c sub $0xc,%esp 10d842: 53 push %ebx 10d843: e8 a8 11 00 00 call 10e9f0 <_Timespec_Is_valid> 10d848: 83 c4 10 add $0x10,%esp 10d84b: 84 c0 test %al,%al 10d84d: 74 0b je 10d85a * Return EINVAL if the delay interval is negative. * * NOTE: This behavior is beyond the POSIX specification. * FSU and GNU/Linux pthreads shares this behavior. */ if ( rqtp->tv_sec < 0 || rqtp->tv_nsec < 0 ) 10d84f: 83 3b 00 cmpl $0x0,(%ebx) 10d852: 78 06 js 10d85a <== NEVER TAKEN 10d854: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10d858: 79 10 jns 10d86a <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10d85a: e8 0d 1e 00 00 call 10f66c <__errno> 10d85f: c7 00 16 00 00 00 movl $0x16,(%eax) 10d865: e9 c3 00 00 00 jmp 10d92d ticks = _Timespec_To_ticks( rqtp ); 10d86a: 83 ec 0c sub $0xc,%esp 10d86d: 53 push %ebx 10d86e: e8 a1 11 00 00 call 10ea14 <_Timespec_To_ticks> 10d873: 89 c3 mov %eax,%ebx * A nanosleep for zero time is implemented as a yield. * This behavior is also beyond the POSIX specification but is * consistent with the RTEMS API and yields desirable behavior. */ if ( !ticks ) { 10d875: 83 c4 10 add $0x10,%esp 10d878: 85 c0 test %eax,%eax 10d87a: 75 2f jne 10d8ab /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10d87c: a1 98 de 11 00 mov 0x11de98,%eax 10d881: 40 inc %eax 10d882: a3 98 de 11 00 mov %eax,0x11de98 _Thread_Disable_dispatch(); _Thread_Yield_processor(); 10d887: e8 7c e4 ff ff call 10bd08 <_Thread_Yield_processor> _Thread_Enable_dispatch(); 10d88c: e8 af d9 ff ff call 10b240 <_Thread_Enable_dispatch> if ( rmtp ) { 10d891: 85 f6 test %esi,%esi 10d893: 0f 84 99 00 00 00 je 10d932 <== NEVER TAKEN rmtp->tv_sec = 0; 10d899: c7 06 00 00 00 00 movl $0x0,(%esi) rmtp->tv_nsec = 0; 10d89f: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) 10d8a6: e9 87 00 00 00 jmp 10d932 10d8ab: a1 98 de 11 00 mov 0x11de98,%eax 10d8b0: 40 inc %eax 10d8b1: a3 98 de 11 00 mov %eax,0x11de98 /* * Block for the desired amount of time */ _Thread_Disable_dispatch(); _Thread_Set_state( 10d8b6: 50 push %eax 10d8b7: 50 push %eax 10d8b8: 68 08 00 00 10 push $0x10000008 10d8bd: ff 35 58 df 11 00 pushl 0x11df58 10d8c3: e8 68 e1 ff ff call 10ba30 <_Thread_Set_state> _Thread_Executing, STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Watchdog_Initialize( 10d8c8: a1 58 df 11 00 mov 0x11df58,%eax 10d8cd: 8b 50 08 mov 0x8(%eax),%edx * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10d8d0: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) * @param[in] the_heap is the heap to operate upon 10d8d7: c7 40 64 c4 b0 10 00 movl $0x10b0c4,0x64(%eax) * @param[in] starting_address is the starting address of the memory for 10d8de: 89 50 68 mov %edx,0x68(%eax) * the heap 10d8e1: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax) * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10d8e8: 89 58 54 mov %ebx,0x54(%eax) void *starting_address, size_t *size 10d8eb: 5a pop %edx 10d8ec: 59 pop %ecx 10d8ed: 83 c0 48 add $0x48,%eax 10d8f0: 50 push %eax 10d8f1: 68 78 df 11 00 push $0x11df78 10d8f6: e8 4d e7 ff ff call 10c048 <_Watchdog_Insert> _Thread_Delay_ended, _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); _Thread_Enable_dispatch(); 10d8fb: e8 40 d9 ff ff call 10b240 <_Thread_Enable_dispatch> /* calculate time remaining */ if ( rmtp ) { 10d900: 83 c4 10 add $0x10,%esp 10d903: 85 f6 test %esi,%esi 10d905: 74 2b je 10d932 <== NEVER TAKEN ticks -= 10d907: a1 58 df 11 00 mov 0x11df58,%eax 10d90c: 03 58 5c add 0x5c(%eax),%ebx 10d90f: 2b 58 60 sub 0x60(%eax),%ebx _Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time; _Timespec_From_ticks( ticks, rmtp ); 10d912: 50 push %eax 10d913: 50 push %eax 10d914: 56 push %esi 10d915: 53 push %ebx 10d916: e8 a9 10 00 00 call 10e9c4 <_Timespec_From_ticks> /* * If there is time remaining, then we were interrupted by a signal. */ if ( ticks ) 10d91b: 83 c4 10 add $0x10,%esp 10d91e: 85 db test %ebx,%ebx 10d920: 74 10 je 10d932 rtems_set_errno_and_return_minus_one( EINTR ); 10d922: e8 45 1d 00 00 call 10f66c <__errno> 10d927: c7 00 04 00 00 00 movl $0x4,(%eax) 10d92d: 83 c8 ff or $0xffffffff,%eax 10d930: eb 02 jmp 10d934 10d932: 31 c0 xor %eax,%eax } return 0; } 10d934: 8d 65 f8 lea -0x8(%ebp),%esp 10d937: 5b pop %ebx 10d938: 5e pop %esi 10d939: c9 leave 10d93a: c3 ret =============================================================================== 001068a9 : */ int newlib_free_buffers( FILE *fp ) { 1068a9: 55 push %ebp 1068aa: 89 e5 mov %esp,%ebp 1068ac: 53 push %ebx 1068ad: 83 ec 10 sub $0x10,%esp 1068b0: 8b 5d 08 mov 0x8(%ebp),%ebx switch ( fileno(fp) ) { 1068b3: 53 push %ebx 1068b4: e8 5b 8b 00 00 call 10f414 1068b9: 83 c4 10 add $0x10,%esp 1068bc: 83 f8 02 cmp $0x2,%eax 1068bf: 77 26 ja 1068e7 <== NEVER TAKEN case 0: case 1: case 2: if (fp->_flags & __SMBF) { 1068c1: 80 7b 0c 00 cmpb $0x0,0xc(%ebx) 1068c5: 79 2c jns 1068f3 free( fp->_bf._base ); 1068c7: 83 ec 0c sub $0xc,%esp 1068ca: ff 73 10 pushl 0x10(%ebx) 1068cd: e8 a6 fb ff ff call 106478 fp->_flags &= ~__SMBF; 1068d2: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) fp->_bf._base = fp->_p = (unsigned char *) NULL; 1068d8: c7 03 00 00 00 00 movl $0x0,(%ebx) 1068de: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) 1068e5: eb 09 jmp 1068f0 } break; default: fclose(fp); 1068e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1068ea: 53 push %ebx <== NOT EXECUTED 1068eb: e8 84 89 00 00 call 10f274 <== NOT EXECUTED 1068f0: 83 c4 10 add $0x10,%esp } return 0; } 1068f3: 31 c0 xor %eax,%eax 1068f5: 8b 5d fc mov -0x4(%ebp),%ebx 1068f8: c9 leave 1068f9: c3 ret =============================================================================== 00106a98 : rtems_device_driver null_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 106a98: 55 push %ebp 106a99: 89 e5 mov %esp,%ebp 106a9b: 53 push %ebx 106a9c: 83 ec 04 sub $0x4,%esp 106a9f: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_device_driver status; if ( !initialized ) { 106aa2: 80 3d 64 0f 12 00 00 cmpb $0x0,0x120f64 106aa9: 75 2b jne 106ad6 initialized = 1; 106aab: c6 05 64 0f 12 00 01 movb $0x1,0x120f64 status = rtems_io_register_name( 106ab2: 50 push %eax 106ab3: 6a 00 push $0x0 106ab5: 53 push %ebx 106ab6: 68 01 9d 11 00 push $0x119d01 106abb: e8 f5 00 00 00 call 106bb5 "/dev/null", major, (rtems_device_minor_number) 0 ); if (status != RTEMS_SUCCESSFUL) 106ac0: 83 c4 10 add $0x10,%esp 106ac3: 85 c0 test %eax,%eax 106ac5: 74 09 je 106ad0 <== ALWAYS TAKEN rtems_fatal_error_occurred(status); 106ac7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106aca: 50 push %eax <== NOT EXECUTED 106acb: e8 3c 38 00 00 call 10a30c <== NOT EXECUTED NULL_major = major; 106ad0: 89 1d 78 11 12 00 mov %ebx,0x121178 } return RTEMS_SUCCESSFUL; } 106ad6: 31 c0 xor %eax,%eax 106ad8: 8b 5d fc mov -0x4(%ebp),%ebx 106adb: c9 leave 106adc: c3 ret =============================================================================== 00106a7d : rtems_device_driver null_write( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 106a7d: 55 push %ebp 106a7e: 89 e5 mov %esp,%ebp 106a80: 8b 55 10 mov 0x10(%ebp),%edx rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) pargp; if ( rw_args ) 106a83: 85 d2 test %edx,%edx 106a85: 74 06 je 106a8d <== ALWAYS TAKEN rw_args->bytes_moved = rw_args->count; 106a87: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 106a8a: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED return NULL_SUCCESSFUL; } 106a8d: 31 c0 xor %eax,%eax 106a8f: c9 leave 106a90: c3 ret =============================================================================== 00106bb0 : int open( const char *pathname, int flags, ... ) { 106bb0: 55 push %ebp 106bb1: 89 e5 mov %esp,%ebp 106bb3: 57 push %edi 106bb4: 56 push %esi 106bb5: 53 push %ebx 106bb6: 83 ec 1c sub $0x1c,%esp /* * Set the Evaluation flags */ eval_flags = 0; status = flags + 1; 106bb9: 8b 45 0c mov 0xc(%ebp),%eax 106bbc: 40 inc %eax if ( ( status & _FREAD ) == _FREAD ) 106bbd: 89 c3 mov %eax,%ebx 106bbf: 83 e3 01 and $0x1,%ebx 106bc2: f7 db neg %ebx 106bc4: 83 e3 04 and $0x4,%ebx eval_flags |= RTEMS_LIBIO_PERMS_READ; if ( ( status & _FWRITE ) == _FWRITE ) 106bc7: a8 02 test $0x2,%al 106bc9: 74 03 je 106bce eval_flags |= RTEMS_LIBIO_PERMS_WRITE; 106bcb: 83 cb 02 or $0x2,%ebx va_start(ap, flags); mode = va_arg( ap, int ); 106bce: 8b 45 10 mov 0x10(%ebp),%eax 106bd1: 89 45 dc mov %eax,-0x24(%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(); 106bd4: e8 38 64 00 00 call 10d011 106bd9: 89 45 e0 mov %eax,-0x20(%ebp) if ( iop == 0 ) { 106bdc: be 17 00 00 00 mov $0x17,%esi 106be1: 85 c0 test %eax,%eax 106be3: 0f 84 8e 01 00 00 je 106d77 /* * See if the file exists. */ status = rtems_filesystem_evaluate_path( 106be9: 6a 01 push $0x1 106beb: 8d 7d e4 lea -0x1c(%ebp),%edi 106bee: 57 push %edi 106bef: 53 push %ebx 106bf0: ff 75 08 pushl 0x8(%ebp) 106bf3: e8 5e f7 ff ff call 106356 pathname, eval_flags, &loc, true ); if ( status == -1 ) { 106bf8: 83 c4 10 add $0x10,%esp 106bfb: 40 inc %eax 106bfc: 75 61 jne 106c5f if ( errno != ENOENT ) { 106bfe: e8 25 85 00 00 call 10f128 <__errno> 106c03: 83 38 02 cmpl $0x2,(%eax) 106c06: 75 2c jne 106c34 rc = errno; goto done; } /* If the file does not exist and we are not trying to create it--> error */ if ( !(flags & O_CREAT) ) { 106c08: be 02 00 00 00 mov $0x2,%esi 106c0d: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 106c14: 0f 84 2c 01 00 00 je 106d46 rc = ENOENT; goto done; } /* Create the node for the new regular file */ rc = mknod( pathname, S_IFREG | mode, 0LL ); 106c1a: 6a 00 push $0x0 106c1c: 6a 00 push $0x0 106c1e: 8b 45 dc mov -0x24(%ebp),%eax 106c21: 80 cc 80 or $0x80,%ah 106c24: 50 push %eax 106c25: ff 75 08 pushl 0x8(%ebp) 106c28: e8 df fa ff ff call 10670c if ( rc ) { 106c2d: 83 c4 10 add $0x10,%esp 106c30: 85 c0 test %eax,%eax 106c32: 74 0c je 106c40 <== ALWAYS TAKEN rc = errno; 106c34: e8 ef 84 00 00 call 10f128 <__errno> 106c39: 8b 30 mov (%eax),%esi 106c3b: e9 02 01 00 00 jmp 106d42 goto done; } /* Sanity check to see if the file name exists after the mknod() */ status = rtems_filesystem_evaluate_path( pathname, 0x0, &loc, true ); 106c40: 6a 01 push $0x1 106c42: 57 push %edi 106c43: 6a 00 push $0x0 106c45: ff 75 08 pushl 0x8(%ebp) 106c48: e8 09 f7 ff ff call 106356 if ( status != 0 ) { /* The file did not exist */ 106c4d: 83 c4 10 add $0x10,%esp 106c50: be 0d 00 00 00 mov $0xd,%esi 106c55: 85 c0 test %eax,%eax 106c57: 0f 85 e9 00 00 00 jne 106d46 <== NEVER TAKEN 106c5d: eb 1b jmp 106c7a rc = EACCES; goto done; } } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) { 106c5f: 8b 45 0c mov 0xc(%ebp),%eax 106c62: 25 00 0a 00 00 and $0xa00,%eax 106c67: 3d 00 0a 00 00 cmp $0xa00,%eax 106c6c: 75 0c jne 106c7a 106c6e: be 11 00 00 00 mov $0x11,%esi 106c73: 89 fb mov %edi,%ebx 106c75: e9 ce 00 00 00 jmp 106d48 /* * Fill in the file control block based on the loc structure * returned by successful path evaluation. */ iop->handlers = loc.handlers; 106c7a: 8b 45 e8 mov -0x18(%ebp),%eax 106c7d: 8b 55 e0 mov -0x20(%ebp),%edx 106c80: 89 42 30 mov %eax,0x30(%edx) iop->file_info = loc.node_access; 106c83: 8b 45 e4 mov -0x1c(%ebp),%eax 106c86: 89 42 2c mov %eax,0x2c(%edx) iop->flags |= rtems_libio_fcntl_flags( flags ); 106c89: 8b 5a 0c mov 0xc(%edx),%ebx 106c8c: 83 ec 0c sub $0xc,%esp 106c8f: ff 75 0c pushl 0xc(%ebp) 106c92: e8 0c 64 00 00 call 10d0a3 106c97: 09 c3 or %eax,%ebx 106c99: 8b 45 e0 mov -0x20(%ebp),%eax 106c9c: 89 58 0c mov %ebx,0xc(%eax) iop->pathinfo = loc; 106c9f: 89 c7 mov %eax,%edi 106ca1: 83 c7 10 add $0x10,%edi 106ca4: 8d 75 e4 lea -0x1c(%ebp),%esi 106ca7: b9 04 00 00 00 mov $0x4,%ecx 106cac: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !iop->handlers->open_h ) { 106cae: 89 c2 mov %eax,%edx 106cb0: 8b 40 30 mov 0x30(%eax),%eax 106cb3: 8b 00 mov (%eax),%eax 106cb5: 83 c4 10 add $0x10,%esp 106cb8: 85 c0 test %eax,%eax 106cba: 0f 84 df 00 00 00 je 106d9f <== NEVER TAKEN rc = ENOTSUP; goto done; } rc = (*iop->handlers->open_h)( iop, pathname, flags, mode ); 106cc0: ff 75 dc pushl -0x24(%ebp) 106cc3: ff 75 0c pushl 0xc(%ebp) 106cc6: ff 75 08 pushl 0x8(%ebp) 106cc9: 52 push %edx 106cca: ff d0 call *%eax 106ccc: 89 c6 mov %eax,%esi if ( rc ) 106cce: 83 c4 10 add $0x10,%esp 106cd1: 85 c0 test %eax,%eax 106cd3: 0f 85 cb 00 00 00 jne 106da4 <== NEVER TAKEN /* * Optionally truncate the file. */ if ( (flags & O_TRUNC) == O_TRUNC ) { 106cd9: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 106ce0: 0f 84 9d 00 00 00 je 106d83 rc = ftruncate( iop - rtems_libio_iops, 0 ); 106ce6: 50 push %eax 106ce7: 50 push %eax 106ce8: 6a 00 push $0x0 106cea: 8b 45 e0 mov -0x20(%ebp),%eax 106ced: 2b 05 38 d6 11 00 sub 0x11d638,%eax 106cf3: c1 f8 02 sar $0x2,%eax 106cf6: 69 c0 c5 4e ec c4 imul $0xc4ec4ec5,%eax,%eax 106cfc: 50 push %eax 106cfd: e8 8e 60 00 00 call 10cd90 106d02: 89 c6 mov %eax,%esi if ( rc ) { 106d04: 83 c4 10 add $0x10,%esp 106d07: 85 c0 test %eax,%eax 106d09: 74 78 je 106d83 <== ALWAYS TAKEN if(errno) rc = errno; 106d0b: e8 18 84 00 00 call 10f128 <__errno> <== NOT EXECUTED 106d10: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 106d13: 74 07 je 106d1c <== NOT EXECUTED 106d15: e8 0e 84 00 00 call 10f128 <__errno> <== NOT EXECUTED 106d1a: 8b 30 mov (%eax),%esi <== NOT EXECUTED close( iop - rtems_libio_iops ); 106d1c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106d1f: a1 38 d6 11 00 mov 0x11d638,%eax <== NOT EXECUTED 106d24: 29 45 e0 sub %eax,-0x20(%ebp) <== NOT EXECUTED 106d27: c1 7d e0 02 sarl $0x2,-0x20(%ebp) <== NOT EXECUTED 106d2b: 69 45 e0 c5 4e ec c4 imul $0xc4ec4ec5,-0x20(%ebp),%eax <== NOT EXECUTED 106d32: 50 push %eax <== NOT EXECUTED 106d33: e8 d4 5f 00 00 call 10cd0c <== NOT EXECUTED 106d38: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 106d3f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED */ done: va_end(ap); if ( rc ) { 106d42: 85 f6 test %esi,%esi 106d44: 74 3d je 106d83 <== NEVER TAKEN 106d46: 31 db xor %ebx,%ebx if ( iop ) 106d48: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) 106d4c: 74 0e je 106d5c <== NEVER TAKEN rtems_libio_free( iop ); 106d4e: 83 ec 0c sub $0xc,%esp 106d51: ff 75 e0 pushl -0x20(%ebp) 106d54: e8 63 62 00 00 call 10cfbc 106d59: 83 c4 10 add $0x10,%esp if ( loc_to_free ) 106d5c: 85 db test %ebx,%ebx 106d5e: 74 17 je 106d77 rtems_filesystem_freenode( loc_to_free ); 106d60: 8b 43 08 mov 0x8(%ebx),%eax 106d63: 85 c0 test %eax,%eax 106d65: 74 10 je 106d77 <== NEVER TAKEN 106d67: 8b 40 1c mov 0x1c(%eax),%eax 106d6a: 85 c0 test %eax,%eax 106d6c: 74 09 je 106d77 <== NEVER TAKEN 106d6e: 83 ec 0c sub $0xc,%esp 106d71: 53 push %ebx 106d72: ff d0 call *%eax 106d74: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( rc ); 106d77: e8 ac 83 00 00 call 10f128 <__errno> 106d7c: 89 30 mov %esi,(%eax) 106d7e: 83 c8 ff or $0xffffffff,%eax 106d81: eb 14 jmp 106d97 } return iop - rtems_libio_iops; 106d83: 8b 15 38 d6 11 00 mov 0x11d638,%edx 106d89: 29 55 e0 sub %edx,-0x20(%ebp) 106d8c: c1 7d e0 02 sarl $0x2,-0x20(%ebp) 106d90: 69 45 e0 c5 4e ec c4 imul $0xc4ec4ec5,-0x20(%ebp),%eax } 106d97: 8d 65 f4 lea -0xc(%ebp),%esp 106d9a: 5b pop %ebx 106d9b: 5e pop %esi 106d9c: 5f pop %edi 106d9d: c9 leave 106d9e: c3 ret if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); rtems_set_errno_and_return_minus_one( rc ); } return iop - rtems_libio_iops; 106d9f: be 86 00 00 00 mov $0x86,%esi <== NOT EXECUTED 106da4: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED 106da7: eb 9f jmp 106d48 <== NOT EXECUTED =============================================================================== 00106b50 : /* * This is a replaceable stub */ void open_dev_console(void) { 106b50: 55 push %ebp 106b51: 89 e5 mov %esp,%ebp 106b53: 83 ec 0c sub $0xc,%esp int error_code = 'S' << 24 | 'T' << 16 | 'D' << 8; /* * Attempt to open /dev/console. */ if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) { 106b56: 6a 00 push $0x0 106b58: 6a 00 push $0x0 106b5a: 68 73 60 11 00 push $0x116073 106b5f: e8 4c 00 00 00 call 106bb0 106b64: 83 c4 10 add $0x10,%esp 106b67: 40 inc %eax 106b68: 74 41 je 106bab /* * But if we find /dev/console once, we better find it twice more * or something is REALLY wrong. */ if ((stdout_fd = open("/dev/console", O_WRONLY, 0)) == -1) 106b6a: 52 push %edx 106b6b: 6a 00 push $0x0 106b6d: 6a 01 push $0x1 106b6f: 68 73 60 11 00 push $0x116073 106b74: e8 37 00 00 00 call 106bb0 106b79: 83 c4 10 add $0x10,%esp 106b7c: 40 inc %eax 106b7d: 75 0a jne 106b89 <== ALWAYS TAKEN rtems_fatal_error_occurred( error_code | '1' ); 106b7f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106b82: 68 31 44 54 53 push $0x53544431 <== NOT EXECUTED 106b87: eb 1d jmp 106ba6 <== NOT EXECUTED if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1) 106b89: 50 push %eax 106b8a: 6a 00 push $0x0 106b8c: 6a 01 push $0x1 106b8e: 68 73 60 11 00 push $0x116073 106b93: e8 18 00 00 00 call 106bb0 106b98: 83 c4 10 add $0x10,%esp 106b9b: 40 inc %eax 106b9c: 75 0d jne 106bab <== ALWAYS TAKEN rtems_fatal_error_occurred( error_code | '2' ); 106b9e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106ba1: 68 32 44 54 53 push $0x53544432 <== NOT EXECUTED 106ba6: e8 e9 2b 00 00 call 109794 <== NOT EXECUTED } 106bab: c9 leave 106bac: c3 ret =============================================================================== 00108450 : * open a directory. */ DIR * opendir( const char *name ) { 108450: 55 push %ebp 108451: 89 e5 mov %esp,%ebp 108453: 56 push %esi 108454: 53 push %ebx register DIR *dirp; register int fd; if ((fd = open(name, 0)) == -1) 108455: 52 push %edx 108456: 52 push %edx 108457: 6a 00 push $0x0 108459: ff 75 08 pushl 0x8(%ebp) 10845c: e8 77 00 00 00 call 1084d8 108461: 89 c6 mov %eax,%esi 108463: 83 c4 10 add $0x10,%esp 108466: 31 db xor %ebx,%ebx 108468: 83 f8 ff cmp $0xffffffff,%eax 10846b: 74 62 je 1084cf <== NEVER TAKEN return NULL; if (fcntl(fd, F_SETFD, 1) == -1 || 10846d: 50 push %eax 10846e: 6a 01 push $0x1 108470: 6a 02 push $0x2 108472: 56 push %esi 108473: e8 8c 65 00 00 call 10ea04 108478: 83 c4 10 add $0x10,%esp 10847b: 40 inc %eax 10847c: 74 31 je 1084af <== NEVER TAKEN 10847e: 83 ec 0c sub $0xc,%esp 108481: 6a 18 push $0x18 108483: e8 10 f8 ff ff call 107c98 108488: 89 c3 mov %eax,%ebx 10848a: 83 c4 10 add $0x10,%esp 10848d: 85 c0 test %eax,%eax 10848f: 74 1e je 1084af <== NEVER TAKEN * If CLSIZE is an exact multiple of DIRBLKSIZ, use a CLSIZE * buffer that it cluster boundary aligned. * Hopefully this can be a big win someday by allowing page trades * to user space to be done by getdirentries() */ dirp->dd_buf = malloc (512); 108491: 83 ec 0c sub $0xc,%esp 108494: 68 00 02 00 00 push $0x200 108499: e8 fa f7 ff ff call 107c98 10849e: 89 43 0c mov %eax,0xc(%ebx) dirp->dd_len = 512; 1084a1: c7 43 10 00 02 00 00 movl $0x200,0x10(%ebx) if (dirp->dd_buf == NULL) { 1084a8: 83 c4 10 add $0x10,%esp 1084ab: 85 c0 test %eax,%eax 1084ad: 75 10 jne 1084bf <== ALWAYS TAKEN close (fd); 1084af: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1084b2: 56 push %esi <== NOT EXECUTED 1084b3: e8 80 ef ff ff call 107438 <== NOT EXECUTED 1084b8: 31 db xor %ebx,%ebx <== NOT EXECUTED 1084ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1084bd: eb 10 jmp 1084cf <== NOT EXECUTED return NULL; } dirp->dd_fd = fd; 1084bf: 89 33 mov %esi,(%ebx) dirp->dd_loc = 0; 1084c1: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) dirp->dd_seek = 0; 1084c8: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) /* * Set up seek point for rewinddir. */ return dirp; } 1084cf: 89 d8 mov %ebx,%eax 1084d1: 8d 65 f8 lea -0x8(%ebp),%esp 1084d4: 5b pop %ebx 1084d5: 5e pop %esi 1084d6: c9 leave 1084d7: c3 ret =============================================================================== 001077a8 : /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) { 1077a8: 55 push %ebp 1077a9: 89 e5 mov %esp,%ebp 1077ab: 56 push %esi 1077ac: 53 push %ebx 1077ad: 83 ec 10 sub $0x10,%esp 1077b0: 89 d3 mov %edx,%ebx 1077b2: 88 45 f4 mov %al,-0xc(%ebp) int i; if (tty->termios.c_oflag & OPOST) { 1077b5: 8b 4a 34 mov 0x34(%edx),%ecx 1077b8: f6 c1 01 test $0x1,%cl 1077bb: 0f 84 df 00 00 00 je 1078a0 <== NEVER TAKEN switch (c) { 1077c1: 3c 09 cmp $0x9,%al 1077c3: 74 76 je 10783b 1077c5: 77 0d ja 1077d4 <== ALWAYS TAKEN 1077c7: 3c 08 cmp $0x8,%al <== NOT EXECUTED 1077c9: 0f 85 a6 00 00 00 jne 107875 <== NOT EXECUTED 1077cf: e9 94 00 00 00 jmp 107868 <== NOT EXECUTED 1077d4: 3c 0a cmp $0xa,%al 1077d6: 74 0a je 1077e2 1077d8: 3c 0d cmp $0xd,%al 1077da: 0f 85 95 00 00 00 jne 107875 <== ALWAYS TAKEN 1077e0: eb 33 jmp 107815 <== NOT EXECUTED case '\n': if (tty->termios.c_oflag & ONLRET) 1077e2: 80 e1 20 and $0x20,%cl 1077e5: 74 07 je 1077ee <== ALWAYS TAKEN tty->column = 0; 1077e7: c7 42 28 00 00 00 00 movl $0x0,0x28(%edx) <== NOT EXECUTED if (tty->termios.c_oflag & ONLCR) { 1077ee: f6 43 34 04 testb $0x4,0x34(%ebx) 1077f2: 0f 84 a8 00 00 00 je 1078a0 <== NEVER TAKEN rtems_termios_puts ("\r", 1, tty); 1077f8: 50 push %eax 1077f9: 53 push %ebx 1077fa: 6a 01 push $0x1 1077fc: 68 47 72 11 00 push $0x117247 107801: e8 8d fe ff ff call 107693 tty->column = 0; 107806: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) 10780d: 83 c4 10 add $0x10,%esp 107810: e9 8b 00 00 00 jmp 1078a0 } break; case '\r': if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0)) 107815: f6 c1 10 test $0x10,%cl <== NOT EXECUTED 107818: 74 0a je 107824 <== NOT EXECUTED 10781a: 83 7a 28 00 cmpl $0x0,0x28(%edx) <== NOT EXECUTED 10781e: 0f 84 8c 00 00 00 je 1078b0 <== NOT EXECUTED return; if (tty->termios.c_oflag & OCRNL) { 107824: f6 c1 08 test $0x8,%cl <== NOT EXECUTED 107827: 74 09 je 107832 <== NOT EXECUTED c = '\n'; 107829: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED if (tty->termios.c_oflag & ONLRET) 10782d: 80 e1 20 and $0x20,%cl <== NOT EXECUTED 107830: 74 6e je 1078a0 <== NOT EXECUTED tty->column = 0; break; } tty->column = 0; 107832: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED 107839: eb 65 jmp 1078a0 <== NOT EXECUTED break; case '\t': i = 8 - (tty->column & 7); 10783b: 8b 52 28 mov 0x28(%edx),%edx 10783e: 89 d0 mov %edx,%eax 107840: 83 e0 07 and $0x7,%eax 107843: be 08 00 00 00 mov $0x8,%esi 107848: 29 c6 sub %eax,%esi if ((tty->termios.c_oflag & TABDLY) == XTABS) { 10784a: 81 e1 00 18 00 00 and $0x1800,%ecx 107850: 81 f9 00 18 00 00 cmp $0x1800,%ecx 107856: 8d 04 16 lea (%esi,%edx,1),%eax 107859: 75 15 jne 107870 <== NEVER TAKEN tty->column += i; 10785b: 89 43 28 mov %eax,0x28(%ebx) rtems_termios_puts ( " ", i, tty); 10785e: 50 push %eax 10785f: 53 push %ebx 107860: 56 push %esi 107861: 68 49 72 11 00 push $0x117249 107866: eb 40 jmp 1078a8 } tty->column += i; break; case '\b': if (tty->column > 0) 107868: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 10786b: 85 c0 test %eax,%eax <== NOT EXECUTED 10786d: 7e 31 jle 1078a0 <== NOT EXECUTED tty->column--; 10786f: 48 dec %eax <== NOT EXECUTED 107870: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 107873: eb 2b jmp 1078a0 <== NOT EXECUTED break; default: if (tty->termios.c_oflag & OLCUC) 107875: 80 e1 02 and $0x2,%cl 107878: 74 14 je 10788e <== ALWAYS TAKEN c = toupper(c); 10787a: 0f b6 d0 movzbl %al,%edx <== NOT EXECUTED 10787d: a1 00 b7 11 00 mov 0x11b700,%eax <== NOT EXECUTED 107882: f6 04 10 02 testb $0x2,(%eax,%edx,1) <== NOT EXECUTED 107886: 74 03 je 10788b <== NOT EXECUTED 107888: 83 ea 20 sub $0x20,%edx <== NOT EXECUTED 10788b: 88 55 f4 mov %dl,-0xc(%ebp) <== NOT EXECUTED if (!iscntrl(c)) 10788e: 0f b6 55 f4 movzbl -0xc(%ebp),%edx 107892: a1 00 b7 11 00 mov 0x11b700,%eax 107897: f6 04 10 20 testb $0x20,(%eax,%edx,1) 10789b: 75 03 jne 1078a0 <== NEVER TAKEN tty->column++; 10789d: ff 43 28 incl 0x28(%ebx) break; } } rtems_termios_puts (&c, 1, tty); 1078a0: 56 push %esi 1078a1: 53 push %ebx 1078a2: 6a 01 push $0x1 1078a4: 8d 45 f4 lea -0xc(%ebp),%eax 1078a7: 50 push %eax 1078a8: e8 e6 fd ff ff call 107693 1078ad: 83 c4 10 add $0x10,%esp } 1078b0: 8d 65 f8 lea -0x8(%ebp),%esp 1078b3: 5b pop %ebx 1078b4: 5e pop %esi 1078b5: c9 leave 1078b6: c3 ret =============================================================================== 00108204 : int posix_memalign( void **pointer, size_t alignment, size_t size ) { 108204: 55 push %ebp 108205: 89 e5 mov %esp,%ebp 108207: 53 push %ebx 108208: 8b 5d 08 mov 0x8(%ebp),%ebx 10820b: 8b 55 0c mov 0xc(%ebp),%edx 10820e: 8b 4d 10 mov 0x10(%ebp),%ecx /* * Update call statistics */ MSBUMP(memalign_calls, 1); 108211: ff 05 9c 29 12 00 incl 0x12299c if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *))) 108217: 8d 42 ff lea -0x1(%edx),%eax 10821a: 85 d0 test %edx,%eax 10821c: 75 05 jne 108223 <== NEVER TAKEN 10821e: 83 fa 03 cmp $0x3,%edx 108221: 77 08 ja 10822b /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); } 108223: b8 16 00 00 00 mov $0x16,%eax 108228: 5b pop %ebx 108229: c9 leave 10822a: c3 ret /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); 10822b: 89 4d 10 mov %ecx,0x10(%ebp) 10822e: 89 55 0c mov %edx,0xc(%ebp) 108231: 89 5d 08 mov %ebx,0x8(%ebp) } 108234: 5b pop %ebx 108235: c9 leave /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); 108236: e9 c1 03 00 00 jmp 1085fc =============================================================================== 001091cc : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 1091cc: 55 push %ebp 1091cd: 89 e5 mov %esp,%ebp 1091cf: 57 push %edi 1091d0: 56 push %esi 1091d1: 53 push %ebx 1091d2: 83 ec 1c sub $0x1c,%esp 1091d5: 8b 7d 08 mov 0x8(%ebp),%edi 1091d8: 8b 75 10 mov 0x10(%ebp),%esi const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 1091db: 85 ff test %edi,%edi 1091dd: 0f 84 94 00 00 00 je 109277 return EINVAL; if ( count == 0 ) 1091e3: 85 f6 test %esi,%esi 1091e5: 0f 84 8c 00 00 00 je 109277 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 1091eb: 8b 45 0c mov 0xc(%ebp),%eax 1091ee: 85 c0 test %eax,%eax 1091f0: 75 11 jne 109203 the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 1091f2: 83 ec 0c sub $0xc,%esp 1091f5: 8d 5d e4 lea -0x1c(%ebp),%ebx 1091f8: 53 push %ebx 1091f9: e8 1a ff ff ff call 109118 1091fe: 89 d8 mov %ebx,%eax 109200: 83 c4 10 add $0x10,%esp } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 109203: 83 38 00 cmpl $0x0,(%eax) 109206: 74 6f je 109277 return EINVAL; switch ( the_attr->process_shared ) { 109208: 83 78 04 00 cmpl $0x0,0x4(%eax) 10920c: 75 69 jne 109277 <== NEVER TAKEN } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 10920e: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) the_attributes.maximum_count = count; 109215: 89 75 f0 mov %esi,-0x10(%ebp) /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109218: a1 90 ec 11 00 mov 0x11ec90,%eax 10921d: 40 inc %eax 10921e: a3 90 ec 11 00 mov %eax,0x11ec90 */ /**@{*/ #ifdef __cplusplus extern "C" { #endif 109223: 83 ec 0c sub $0xc,%esp 109226: 68 80 f0 11 00 push $0x11f080 10922b: e8 d4 1f 00 00 call 10b204 <_Objects_Allocate> 109230: 89 c3 mov %eax,%ebx */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 109232: 83 c4 10 add $0x10,%esp 109235: 85 c0 test %eax,%eax 109237: 75 0c jne 109245 _Thread_Enable_dispatch(); 109239: e8 ca 2b 00 00 call 10be08 <_Thread_Enable_dispatch> 10923e: b8 0b 00 00 00 mov $0xb,%eax 109243: eb 37 jmp 10927c return EAGAIN; } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 109245: 50 push %eax 109246: 50 push %eax 109247: 8d 45 ec lea -0x14(%ebp),%eax 10924a: 50 push %eax 10924b: 8d 43 10 lea 0x10(%ebx),%eax 10924e: 50 push %eax 10924f: e8 ac 17 00 00 call 10aa00 <_CORE_barrier_Initialize> 109254: 8b 4b 08 mov 0x8(%ebx),%ecx 109257: 0f b7 d1 movzwl %cx,%edx 10925a: a1 9c f0 11 00 mov 0x11f09c,%eax 10925f: 89 1c 90 mov %ebx,(%eax,%edx,4) 109262: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) ); /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; 109269: 89 0f mov %ecx,(%edi) _Thread_Enable_dispatch(); 10926b: e8 98 2b 00 00 call 10be08 <_Thread_Enable_dispatch> 109270: 31 c0 xor %eax,%eax 109272: 83 c4 10 add $0x10,%esp 109275: eb 05 jmp 10927c return 0; 109277: b8 16 00 00 00 mov $0x16,%eax } 10927c: 8d 65 f4 lea -0xc(%ebp),%esp 10927f: 5b pop %ebx 109280: 5e pop %esi 109281: 5f pop %edi 109282: c9 leave 109283: c3 ret =============================================================================== 00108a54 : */ int pthread_cancel( pthread_t thread ) { 108a54: 55 push %ebp 108a55: 89 e5 mov %esp,%ebp 108a57: 56 push %esi 108a58: 53 push %ebx 108a59: 83 ec 10 sub $0x10,%esp /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 108a5c: a1 84 f5 11 00 mov 0x11f584,%eax 108a61: ba 47 00 00 00 mov $0x47,%edx 108a66: 85 c0 test %eax,%eax 108a68: 75 5d jne 108ac7 <== NEVER TAKEN return EPROTO; the_thread = _Thread_Get( thread, &location ); 108a6a: 52 push %edx 108a6b: 52 push %edx 108a6c: 8d 45 f4 lea -0xc(%ebp),%eax 108a6f: 50 push %eax 108a70: ff 75 08 pushl 0x8(%ebp) 108a73: e8 74 2d 00 00 call 10b7ec <_Thread_Get> 108a78: 89 c6 mov %eax,%esi switch ( location ) { 108a7a: 83 c4 10 add $0x10,%esp 108a7d: ba 16 00 00 00 mov $0x16,%edx 108a82: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 108a86: 75 3f jne 108ac7 <== NEVER TAKEN case OBJECTS_LOCAL: thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 108a88: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax thread_support->cancelation_requested = 1; 108a8e: c7 80 d4 00 00 00 01 movl $0x1,0xd4(%eax) 108a95: 00 00 00 if (thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 108a98: 31 db xor %ebx,%ebx 108a9a: 83 b8 cc 00 00 00 00 cmpl $0x0,0xcc(%eax) 108aa1: 75 0a jne 108aad <== NEVER TAKEN 108aa3: 83 b8 d0 00 00 00 01 cmpl $0x1,0xd0(%eax) 108aaa: 0f 94 c3 sete %bl thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS) cancel = true; _Thread_Enable_dispatch(); 108aad: e8 1a 2d 00 00 call 10b7cc <_Thread_Enable_dispatch> if ( cancel ) 108ab2: 31 d2 xor %edx,%edx 108ab4: 84 db test %bl,%bl 108ab6: 74 0f je 108ac7 _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 108ab8: 50 push %eax 108ab9: 50 push %eax 108aba: 6a ff push $0xffffffff 108abc: 56 push %esi 108abd: e8 a2 02 00 00 call 108d64 <_POSIX_Thread_Exit> 108ac2: 31 d2 xor %edx,%edx 108ac4: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 108ac7: 89 d0 mov %edx,%eax 108ac9: 8d 65 f8 lea -0x8(%ebp),%esp 108acc: 5b pop %ebx 108acd: 5e pop %esi 108ace: c9 leave 108acf: c3 ret =============================================================================== 00108ed4 : */ void pthread_cleanup_pop( int execute ) { 108ed4: 55 push %ebp 108ed5: 89 e5 mov %esp,%ebp 108ed7: 57 push %edi 108ed8: 56 push %esi 108ed9: 53 push %ebx 108eda: 83 ec 1c sub $0x1c,%esp 108edd: 8b 45 08 mov 0x8(%ebp),%eax 108ee0: 89 45 e0 mov %eax,-0x20(%ebp) POSIX_Cancel_Handler_control tmp_handler; Chain_Control *handler_stack; POSIX_API_Control *thread_support; ISR_Level level; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 108ee3: a1 40 0d 12 00 mov 0x120d40,%eax 108ee8: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 108eee: a1 80 0c 12 00 mov 0x120c80,%eax 108ef3: 40 inc %eax 108ef4: a3 80 0c 12 00 mov %eax,0x120c80 * ensure that we do not get prempted and deleted while we are holding * memory that needs to be freed. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 108ef9: 9c pushf 108efa: fa cli 108efb: 5f pop %edi * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 108efc: 8d 82 dc 00 00 00 lea 0xdc(%edx),%eax if ( _Chain_Is_empty( handler_stack ) ) { 108f02: 39 82 d8 00 00 00 cmp %eax,0xd8(%edx) 108f08: 75 09 jne 108f13 _Thread_Enable_dispatch(); 108f0a: e8 29 30 00 00 call 10bf38 <_Thread_Enable_dispatch> _ISR_Enable( level ); 108f0f: 57 push %edi 108f10: 9d popf 108f11: eb 4c jmp 108f5f return; } handler = (POSIX_Cancel_Handler_control *) 108f13: 8b 40 04 mov 0x4(%eax),%eax 108f16: 89 45 d8 mov %eax,-0x28(%ebp) 108f19: 8b 10 mov (%eax),%edx 108f1b: 8b 40 04 mov 0x4(%eax),%eax 108f1e: 89 42 04 mov %eax,0x4(%edx) 108f21: 89 10 mov %edx,(%eax) _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 108f23: 57 push %edi 108f24: 9d popf tmp_handler = *handler; 108f25: 8d 7d e4 lea -0x1c(%ebp),%edi 108f28: b9 04 00 00 00 mov $0x4,%ecx 108f2d: 8b 75 d8 mov -0x28(%ebp),%esi 108f30: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 108f32: 8b 5d ec mov -0x14(%ebp),%ebx 108f35: 8b 7d f0 mov -0x10(%ebp),%edi _Workspace_Free( handler ); 108f38: 83 ec 0c sub $0xc,%esp 108f3b: ff 75 d8 pushl -0x28(%ebp) 108f3e: e8 0d 40 00 00 call 10cf50 <_Workspace_Free> _Thread_Enable_dispatch(); 108f43: e8 f0 2f 00 00 call 10bf38 <_Thread_Enable_dispatch> if ( execute ) 108f48: 83 c4 10 add $0x10,%esp 108f4b: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) 108f4f: 74 0e je 108f5f <== NEVER TAKEN (*tmp_handler.routine)( tmp_handler.arg ); 108f51: 89 7d 08 mov %edi,0x8(%ebp) 108f54: 89 d9 mov %ebx,%ecx } 108f56: 8d 65 f4 lea -0xc(%ebp),%esp 108f59: 5b pop %ebx 108f5a: 5e pop %esi 108f5b: 5f pop %edi 108f5c: c9 leave _Workspace_Free( handler ); _Thread_Enable_dispatch(); if ( execute ) (*tmp_handler.routine)( tmp_handler.arg ); 108f5d: ff e1 jmp *%ecx } 108f5f: 8d 65 f4 lea -0xc(%ebp),%esp 108f62: 5b pop %ebx 108f63: 5e pop %esi 108f64: 5f pop %edi 108f65: c9 leave 108f66: c3 ret =============================================================================== 00108f68 : void pthread_cleanup_push( void (*routine)( void * ), void *arg ) { 108f68: 55 push %ebp 108f69: 89 e5 mov %esp,%ebp 108f6b: 56 push %esi 108f6c: 53 push %ebx 108f6d: 8b 5d 08 mov 0x8(%ebp),%ebx 108f70: 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 ) 108f73: 85 db test %ebx,%ebx 108f75: 74 4b je 108fc2 /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 108f77: a1 80 0c 12 00 mov 0x120c80,%eax 108f7c: 40 inc %eax 108f7d: a3 80 0c 12 00 mov %eax,0x120c80 return; _Thread_Disable_dispatch(); handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); 108f82: 83 ec 0c sub $0xc,%esp 108f85: 6a 10 push $0x10 108f87: e8 d9 3f 00 00 call 10cf65 <_Workspace_Allocate> 108f8c: 89 c2 mov %eax,%edx if ( handler ) { 108f8e: 83 c4 10 add $0x10,%esp 108f91: 85 c0 test %eax,%eax 108f93: 74 22 je 108fb7 <== NEVER TAKEN thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; handler_stack = &thread_support->Cancellation_Handlers; 108f95: a1 40 0d 12 00 mov 0x120d40,%eax 108f9a: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax 108fa0: 05 d8 00 00 00 add $0xd8,%eax handler->routine = routine; 108fa5: 89 5a 08 mov %ebx,0x8(%edx) handler->arg = arg; 108fa8: 89 72 0c mov %esi,0xc(%edx) _Chain_Append( handler_stack, &handler->Node ); 108fab: 51 push %ecx 108fac: 51 push %ecx 108fad: 52 push %edx 108fae: 50 push %eax 108faf: e8 e4 1b 00 00 call 10ab98 <_Chain_Append> 108fb4: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); } 108fb7: 8d 65 f8 lea -0x8(%ebp),%esp 108fba: 5b pop %ebx 108fbb: 5e pop %esi 108fbc: c9 leave handler->routine = routine; handler->arg = arg; _Chain_Append( handler_stack, &handler->Node ); } _Thread_Enable_dispatch(); 108fbd: e9 76 2f 00 00 jmp 10bf38 <_Thread_Enable_dispatch> } 108fc2: 8d 65 f8 lea -0x8(%ebp),%esp 108fc5: 5b pop %ebx 108fc6: 5e pop %esi 108fc7: c9 leave 108fc8: c3 ret =============================================================================== 00109a98 : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 109a98: 55 push %ebp 109a99: 89 e5 mov %esp,%ebp 109a9b: 56 push %esi 109a9c: 53 push %ebx 109a9d: 8b 45 0c mov 0xc(%ebp),%eax POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 109aa0: be c8 a8 11 00 mov $0x11a8c8,%esi 109aa5: 85 c0 test %eax,%eax 109aa7: 74 02 je 109aab 109aa9: 89 c6 mov %eax,%esi /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 109aab: 83 7e 04 01 cmpl $0x1,0x4(%esi) 109aaf: 74 77 je 109b28 <== NEVER TAKEN return EINVAL; if ( !the_attr->is_initialized ) 109ab1: 83 3e 00 cmpl $0x0,(%esi) 109ab4: 74 72 je 109b28 /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109ab6: a1 60 10 12 00 mov 0x121060,%eax 109abb: 40 inc %eax 109abc: a3 60 10 12 00 mov %eax,0x121060 /**@{*/ #ifdef __cplusplus extern "C" { #endif 109ac1: 83 ec 0c sub $0xc,%esp 109ac4: 68 d4 14 12 00 push $0x1214d4 109ac9: e8 b6 24 00 00 call 10bf84 <_Objects_Allocate> 109ace: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 109ad0: 83 c4 10 add $0x10,%esp 109ad3: 85 c0 test %eax,%eax 109ad5: 75 0c jne 109ae3 _Thread_Enable_dispatch(); 109ad7: e8 ac 30 00 00 call 10cb88 <_Thread_Enable_dispatch> 109adc: b8 0c 00 00 00 mov $0xc,%eax 109ae1: eb 4a jmp 109b2d return ENOMEM; } the_cond->process_shared = the_attr->process_shared; 109ae3: 8b 46 04 mov 0x4(%esi),%eax 109ae6: 89 43 10 mov %eax,0x10(%ebx) the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 109ae9: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) /* XXX some more initialization might need to go here */ _Thread_queue_Initialize( 109af0: 6a 74 push $0x74 109af2: 68 00 08 00 00 push $0x800 109af7: 6a 00 push $0x0 109af9: 8d 43 18 lea 0x18(%ebx),%eax 109afc: 50 push %eax 109afd: e8 56 37 00 00 call 10d258 <_Thread_queue_Initialize> 109b02: 8b 4b 08 mov 0x8(%ebx),%ecx 109b05: 0f b7 d1 movzwl %cx,%edx 109b08: a1 f0 14 12 00 mov 0x1214f0,%eax 109b0d: 89 1c 90 mov %ebx,(%eax,%edx,4) 109b10: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 109b17: 8b 45 08 mov 0x8(%ebp),%eax 109b1a: 89 08 mov %ecx,(%eax) _Thread_Enable_dispatch(); 109b1c: e8 67 30 00 00 call 10cb88 <_Thread_Enable_dispatch> 109b21: 31 c0 xor %eax,%eax 109b23: 83 c4 10 add $0x10,%esp 109b26: eb 05 jmp 109b2d return 0; 109b28: b8 16 00 00 00 mov $0x16,%eax } 109b2d: 8d 65 f8 lea -0x8(%ebp),%esp 109b30: 5b pop %ebx 109b31: 5e pop %esi 109b32: c9 leave 109b33: c3 ret =============================================================================== 00109950 : */ int pthread_condattr_destroy( pthread_condattr_t *attr ) { 109950: 55 push %ebp 109951: 89 e5 mov %esp,%ebp 109953: 8b 45 08 mov 0x8(%ebp),%eax if ( !attr || attr->is_initialized == FALSE ) 109956: 85 c0 test %eax,%eax 109958: 74 0f je 109969 10995a: 83 38 00 cmpl $0x0,(%eax) 10995d: 74 0a je 109969 <== NEVER TAKEN return EINVAL; attr->is_initialized = FALSE; 10995f: c7 00 00 00 00 00 movl $0x0,(%eax) 109965: 31 c0 xor %eax,%eax 109967: eb 05 jmp 10996e return 0; 109969: b8 16 00 00 00 mov $0x16,%eax } 10996e: c9 leave 10996f: c3 ret =============================================================================== 00109a24 : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 109a24: 55 push %ebp 109a25: 89 e5 mov %esp,%ebp 109a27: 57 push %edi 109a28: 56 push %esi 109a29: 53 push %ebx 109a2a: 83 ec 2c sub $0x2c,%esp 109a2d: 8b 75 0c mov 0xc(%ebp),%esi POSIX_API_Control *api; int schedpolicy = SCHED_RR; struct sched_param schedparam; Objects_Name name; if ( !start_routine ) 109a30: b8 0e 00 00 00 mov $0xe,%eax 109a35: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 109a39: 0f 84 6e 02 00 00 je 109cad return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 109a3f: c7 45 c8 4c a9 11 00 movl $0x11a94c,-0x38(%ebp) 109a46: 85 f6 test %esi,%esi 109a48: 74 03 je 109a4d 109a4a: 89 75 c8 mov %esi,-0x38(%ebp) if ( !the_attr->is_initialized ) 109a4d: 8b 45 c8 mov -0x38(%ebp),%eax 109a50: 83 38 00 cmpl $0x0,(%eax) 109a53: 0f 84 4f 02 00 00 je 109ca8 * 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) ) 109a59: 83 78 04 00 cmpl $0x0,0x4(%eax) 109a5d: 74 0f je 109a6e 109a5f: 8b 40 08 mov 0x8(%eax),%eax 109a62: 3b 05 00 cd 11 00 cmp 0x11cd00,%eax 109a68: 0f 82 3a 02 00 00 jb 109ca8 <== ALWAYS TAKEN * 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 ) { 109a6e: 8b 55 c8 mov -0x38(%ebp),%edx 109a71: 8b 42 10 mov 0x10(%edx),%eax 109a74: 83 f8 01 cmp $0x1,%eax 109a77: 74 0b je 109a84 109a79: 83 f8 02 cmp $0x2,%eax 109a7c: 0f 85 26 02 00 00 jne 109ca8 109a82: eb 1c jmp 109aa0 case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 109a84: a1 b0 11 12 00 mov 0x1211b0,%eax 109a89: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax schedpolicy = api->schedpolicy; 109a8f: 8b 50 7c mov 0x7c(%eax),%edx 109a92: 89 55 d0 mov %edx,-0x30(%ebp) schedparam = api->schedparam; 109a95: 8d 7d dc lea -0x24(%ebp),%edi 109a98: 8d b0 80 00 00 00 lea 0x80(%eax),%esi 109a9e: eb 12 jmp 109ab2 break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 109aa0: 8b 45 c8 mov -0x38(%ebp),%eax 109aa3: 8b 40 14 mov 0x14(%eax),%eax 109aa6: 89 45 d0 mov %eax,-0x30(%ebp) schedparam = the_attr->schedparam; 109aa9: 8d 7d dc lea -0x24(%ebp),%edi 109aac: 8b 75 c8 mov -0x38(%ebp),%esi 109aaf: 83 c6 18 add $0x18,%esi 109ab2: b9 06 00 00 00 mov $0x6,%ecx 109ab7: 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 ) 109ab9: b8 86 00 00 00 mov $0x86,%eax 109abe: 8b 55 c8 mov -0x38(%ebp),%edx 109ac1: 83 7a 0c 00 cmpl $0x0,0xc(%edx) 109ac5: 0f 85 e2 01 00 00 jne 109cad /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 109acb: 8b 7d dc mov -0x24(%ebp),%edi 109ace: 8d 47 ff lea -0x1(%edi),%eax 109ad1: 3d fd 00 00 00 cmp $0xfd,%eax 109ad6: 0f 87 cc 01 00 00 ja 109ca8 <== NEVER TAKEN */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 109adc: 83 7d d0 01 cmpl $0x1,-0x30(%ebp) 109ae0: 74 24 je 109b06 109ae2: 7f 10 jg 109af4 109ae4: be 01 00 00 00 mov $0x1,%esi 109ae9: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) 109aed: 74 19 je 109b08 109aef: e9 b4 01 00 00 jmp 109ca8 109af4: 83 7d d0 02 cmpl $0x2,-0x30(%ebp) 109af8: 74 12 je 109b0c <== NEVER TAKEN 109afa: 83 7d d0 03 cmpl $0x3,-0x30(%ebp) 109afe: 0f 85 a4 01 00 00 jne 109ca8 <== NEVER TAKEN 109b04: eb 0d jmp 109b13 109b06: 31 f6 xor %esi,%esi 109b08: 31 db xor %ebx,%ebx 109b0a: eb 44 jmp 109b50 109b0c: be 02 00 00 00 mov $0x2,%esi <== NOT EXECUTED 109b11: eb f5 jmp 109b08 <== NOT EXECUTED case SCHED_SPORADIC: budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; budget_callout = _POSIX_Threads_Sporadic_budget_callout; if ( _Timespec_To_ticks( &schedparam.ss_replenish_period ) < 109b13: 83 ec 0c sub $0xc,%esp 109b16: 8d 45 e4 lea -0x1c(%ebp),%eax 109b19: 50 push %eax 109b1a: e8 6d 39 00 00 call 10d48c <_Timespec_To_ticks> 109b1f: 89 c3 mov %eax,%ebx 109b21: 8d 45 ec lea -0x14(%ebp),%eax 109b24: 89 04 24 mov %eax,(%esp) 109b27: e8 60 39 00 00 call 10d48c <_Timespec_To_ticks> 109b2c: 83 c4 10 add $0x10,%esp 109b2f: 39 c3 cmp %eax,%ebx 109b31: 0f 82 71 01 00 00 jb 109ca8 <== NEVER TAKEN _Timespec_To_ticks( &schedparam.ss_initial_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( schedparam.ss_low_priority ) ) 109b37: 8b 45 e0 mov -0x20(%ebp),%eax 109b3a: 48 dec %eax 109b3b: 3d fd 00 00 00 cmp $0xfd,%eax 109b40: 0f 87 62 01 00 00 ja 109ca8 <== NEVER TAKEN 109b46: be 03 00 00 00 mov $0x3,%esi 109b4b: bb e8 9f 10 00 mov $0x109fe8,%ebx #endif /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 109b50: 83 ec 0c sub $0xc,%esp 109b53: ff 35 a8 11 12 00 pushl 0x1211a8 109b59: e8 5e 18 00 00 call 10b3bc <_API_Mutex_Lock> * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 109b5e: c7 04 24 60 13 12 00 movl $0x121360,(%esp) 109b65: e8 12 21 00 00 call 10bc7c <_Objects_Allocate> 109b6a: 89 45 cc mov %eax,-0x34(%ebp) * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { 109b6d: 83 c4 10 add $0x10,%esp 109b70: 85 c0 test %eax,%eax 109b72: 75 05 jne 109b79 _RTEMS_Unlock_allocator(); 109b74: 83 ec 0c sub $0xc,%esp 109b77: eb 51 jmp 109bca /* * Initialize the core thread for this task. */ name.name_p = NULL; /* posix threads don't have a name by default */ status = _Thread_Initialize( 109b79: 8b 45 c8 mov -0x38(%ebp),%eax 109b7c: 8b 50 08 mov 0x8(%eax),%edx 109b7f: 50 push %eax 109b80: 6a 00 push $0x0 109b82: 6a 00 push $0x0 109b84: 53 push %ebx 109b85: 56 push %esi 109b86: 6a 01 push $0x1 109b88: b8 ff 00 00 00 mov $0xff,%eax 109b8d: 29 f8 sub %edi,%eax 109b8f: 50 push %eax 109b90: 6a 01 push $0x1 109b92: a1 00 cd 11 00 mov 0x11cd00,%eax 109b97: d1 e0 shl %eax 109b99: 39 d0 cmp %edx,%eax 109b9b: 73 02 jae 109b9f 109b9d: 89 d0 mov %edx,%eax 109b9f: 50 push %eax 109ba0: 8b 55 c8 mov -0x38(%ebp),%edx 109ba3: ff 72 04 pushl 0x4(%edx) 109ba6: ff 75 cc pushl -0x34(%ebp) 109ba9: 68 60 13 12 00 push $0x121360 109bae: e8 91 2d 00 00 call 10c944 <_Thread_Initialize> budget_callout, 0, /* isr level */ name /* posix threads don't have a name */ ); if ( !status ) { 109bb3: 83 c4 30 add $0x30,%esp 109bb6: 84 c0 test %al,%al 109bb8: 75 25 jne 109bdf * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 109bba: 50 push %eax 109bbb: 50 push %eax 109bbc: ff 75 cc pushl -0x34(%ebp) 109bbf: 68 60 13 12 00 push $0x121360 109bc4: e8 c3 23 00 00 call 10bf8c <_Objects_Free> _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 109bc9: 58 pop %eax 109bca: ff 35 a8 11 12 00 pushl 0x1211a8 109bd0: e8 2f 18 00 00 call 10b404 <_API_Mutex_Unlock> 109bd5: b8 0b 00 00 00 mov $0xb,%eax 109bda: e9 c4 00 00 00 jmp 109ca3 /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 109bdf: 8b 45 cc mov -0x34(%ebp),%eax 109be2: 8b 98 f8 00 00 00 mov 0xf8(%eax),%ebx api->Attributes = *the_attr; 109be8: b9 0e 00 00 00 mov $0xe,%ecx 109bed: 89 df mov %ebx,%edi 109bef: 8b 75 c8 mov -0x38(%ebp),%esi 109bf2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) api->detachstate = the_attr->detachstate; 109bf4: 8b 55 c8 mov -0x38(%ebp),%edx 109bf7: 8b 42 34 mov 0x34(%edx),%eax 109bfa: 89 43 38 mov %eax,0x38(%ebx) api->schedpolicy = schedpolicy; 109bfd: 8b 45 d0 mov -0x30(%ebp),%eax 109c00: 89 43 7c mov %eax,0x7c(%ebx) api->schedparam = schedparam; 109c03: 8d bb 80 00 00 00 lea 0x80(%ebx),%edi 109c09: 8d 75 dc lea -0x24(%ebp),%esi 109c0c: b1 06 mov $0x6,%cl 109c0e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) * first run. * * NOTE: Since the thread starts with all unblocked, this is necessary. */ the_thread->do_post_task_switch_extension = true; 109c10: 8b 55 cc mov -0x34(%ebp),%edx 109c13: c6 42 75 01 movb $0x1,0x75(%edx) /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 109c17: 83 ec 0c sub $0xc,%esp 109c1a: 6a 00 push $0x0 109c1c: ff 75 14 pushl 0x14(%ebp) 109c1f: ff 75 10 pushl 0x10(%ebp) 109c22: 6a 01 push $0x1 109c24: 52 push %edx 109c25: e8 8a 36 00 00 call 10d2b4 <_Thread_Start> 109c2a: 89 c6 mov %eax,%esi start_routine, arg, 0 /* unused */ ); if ( schedpolicy == SCHED_SPORADIC ) { 109c2c: 83 c4 20 add $0x20,%esp 109c2f: 83 7d d0 03 cmpl $0x3,-0x30(%ebp) 109c33: 75 2b jne 109c60 _Watchdog_Insert_ticks( 109c35: 83 ec 0c sub $0xc,%esp 109c38: 8d 83 88 00 00 00 lea 0x88(%ebx),%eax 109c3e: 50 push %eax 109c3f: e8 48 38 00 00 call 10d48c <_Timespec_To_ticks> * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 109c44: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) void *starting_address, size_t *size 109c4a: 59 pop %ecx 109c4b: 5f pop %edi 109c4c: 8d 83 9c 00 00 00 lea 0x9c(%ebx),%eax 109c52: 50 push %eax 109c53: 68 d0 11 12 00 push $0x1211d0 109c58: e8 37 3b 00 00 call 10d794 <_Watchdog_Insert> 109c5d: 83 c4 10 add $0x10,%esp * * NOTE: This can only happen if someone slips in and touches the * thread while we are creating it. */ if ( !status ) { 109c60: 89 f0 mov %esi,%eax 109c62: 84 c0 test %al,%al 109c64: 75 22 jne 109c88 <== ALWAYS TAKEN * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 109c66: 52 push %edx <== NOT EXECUTED 109c67: 52 push %edx <== NOT EXECUTED 109c68: ff 75 cc pushl -0x34(%ebp) <== NOT EXECUTED 109c6b: 68 60 13 12 00 push $0x121360 <== NOT EXECUTED 109c70: e8 17 23 00 00 call 10bf8c <_Objects_Free> <== NOT EXECUTED _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 109c75: 58 pop %eax <== NOT EXECUTED 109c76: ff 35 a8 11 12 00 pushl 0x1211a8 <== NOT EXECUTED 109c7c: e8 83 17 00 00 call 10b404 <_API_Mutex_Unlock> <== NOT EXECUTED 109c81: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 109c86: eb 1b jmp 109ca3 <== NOT EXECUTED /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 109c88: 8b 45 cc mov -0x34(%ebp),%eax 109c8b: 8b 50 08 mov 0x8(%eax),%edx 109c8e: 8b 45 08 mov 0x8(%ebp),%eax 109c91: 89 10 mov %edx,(%eax) _RTEMS_Unlock_allocator(); 109c93: 83 ec 0c sub $0xc,%esp 109c96: ff 35 a8 11 12 00 pushl 0x1211a8 109c9c: e8 63 17 00 00 call 10b404 <_API_Mutex_Unlock> 109ca1: 31 c0 xor %eax,%eax 109ca3: 83 c4 10 add $0x10,%esp 109ca6: eb 05 jmp 109cad return 0; 109ca8: b8 16 00 00 00 mov $0x16,%eax } 109cad: 8d 65 f4 lea -0xc(%ebp),%esp 109cb0: 5b pop %ebx 109cb1: 5e pop %esi 109cb2: 5f pop %edi 109cb3: c9 leave 109cb4: c3 ret =============================================================================== 0010ecb8 : } void pthread_exit( void *value_ptr ) { 10ecb8: 55 push %ebp 10ecb9: 89 e5 mov %esp,%ebp 10ecbb: 83 ec 10 sub $0x10,%esp _POSIX_Thread_Exit( _Thread_Executing, value_ptr ); 10ecbe: ff 75 08 pushl 0x8(%ebp) 10ecc1: ff 35 58 d8 11 00 pushl 0x11d858 10ecc7: e8 88 ff ff ff call 10ec54 <_POSIX_Thread_Exit> 10eccc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10eccf: c9 leave <== NOT EXECUTED 10ecd0: c3 ret <== NOT EXECUTED =============================================================================== 0010aecc : int pthread_getschedparam( pthread_t thread, int *policy, struct sched_param *param ) { 10aecc: 55 push %ebp 10aecd: 89 e5 mov %esp,%ebp 10aecf: 57 push %edi 10aed0: 56 push %esi 10aed1: 53 push %ebx 10aed2: 83 ec 1c sub $0x1c,%esp 10aed5: 8b 75 0c mov 0xc(%ebp),%esi Objects_Locations location; POSIX_API_Control *api; register Thread_Control *the_thread; if ( !policy || !param ) 10aed8: 85 f6 test %esi,%esi 10aeda: 74 06 je 10aee2 10aedc: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10aee0: 75 07 jne 10aee9 10aee2: b8 16 00 00 00 mov $0x16,%eax 10aee7: eb 4d jmp 10af36 return EINVAL; the_thread = _Thread_Get( thread, &location ); 10aee9: 50 push %eax 10aeea: 50 push %eax 10aeeb: 8d 45 f0 lea -0x10(%ebp),%eax 10aeee: 50 push %eax 10aeef: ff 75 08 pushl 0x8(%ebp) 10aef2: e8 4d 2a 00 00 call 10d944 <_Thread_Get> 10aef7: 89 c3 mov %eax,%ebx switch ( location ) { 10aef9: 83 c4 10 add $0x10,%esp 10aefc: b8 03 00 00 00 mov $0x3,%eax 10af01: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 10af05: 75 2f jne 10af36 <== NEVER TAKEN case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10af07: 8b 93 f8 00 00 00 mov 0xf8(%ebx),%edx if ( policy ) *policy = api->schedpolicy; 10af0d: 8b 42 7c mov 0x7c(%edx),%eax 10af10: 89 06 mov %eax,(%esi) if ( param ) { *param = api->schedparam; 10af12: 8d b2 80 00 00 00 lea 0x80(%edx),%esi 10af18: b9 06 00 00 00 mov $0x6,%ecx 10af1d: 8b 7d 10 mov 0x10(%ebp),%edi 10af20: f3 a5 rep movsl %ds:(%esi),%es:(%edi) param->sched_priority = 10af22: b8 ff 00 00 00 mov $0xff,%eax 10af27: 2b 43 14 sub 0x14(%ebx),%eax 10af2a: 8b 55 10 mov 0x10(%ebp),%edx 10af2d: 89 02 mov %eax,(%edx) _POSIX_Priority_From_core( the_thread->current_priority ); } _Thread_Enable_dispatch(); 10af2f: e8 f0 29 00 00 call 10d924 <_Thread_Enable_dispatch> 10af34: 31 c0 xor %eax,%eax break; } return ESRCH; } 10af36: 8d 65 f4 lea -0xc(%ebp),%esp 10af39: 5b pop %ebx 10af3a: 5e pop %esi 10af3b: 5f pop %edi 10af3c: c9 leave 10af3d: c3 ret =============================================================================== 00108ec8 : int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) { 108ec8: 55 push %ebp 108ec9: 89 e5 mov %esp,%ebp 108ecb: 57 push %edi 108ecc: 56 push %esi 108ecd: 53 push %ebx 108ece: 83 ec 18 sub $0x18,%esp 108ed1: a1 a8 00 12 00 mov 0x1200a8,%eax 108ed6: 40 inc %eax 108ed7: a3 a8 00 12 00 mov %eax,0x1200a8 * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 108edc: 68 dc 04 12 00 push $0x1204dc 108ee1: e8 7e 21 00 00 call 10b064 <_Objects_Allocate> 108ee6: 89 45 f0 mov %eax,-0x10(%ebp) _Thread_Disable_dispatch(); the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { 108ee9: 83 c4 10 add $0x10,%esp 108eec: 85 c0 test %eax,%eax 108eee: 75 0f jne 108eff _Thread_Enable_dispatch(); 108ef0: e8 73 2d 00 00 call 10bc68 <_Thread_Enable_dispatch> 108ef5: b8 0b 00 00 00 mov $0xb,%eax 108efa: e9 c4 00 00 00 jmp 108fc3 return EAGAIN; } the_key->destructor = destructor; 108eff: 8b 45 0c mov 0xc(%ebp),%eax 108f02: 8b 55 f0 mov -0x10(%ebp),%edx 108f05: 89 42 14 mov %eax,0x14(%edx) 108f08: bb 01 00 00 00 mov $0x1,%ebx for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { if ( _Objects_Information_table[ the_api ] ) { 108f0d: 8b 04 9d 7c 00 12 00 mov 0x12007c(,%ebx,4),%eax 108f14: 85 c0 test %eax,%eax 108f16: 74 6e je 108f86 INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY ); #endif bytes_to_allocate = sizeof( void * ) * 108f18: 8b 40 04 mov 0x4(%eax),%eax 108f1b: 0f b7 40 10 movzwl 0x10(%eax),%eax 108f1f: 8d 34 85 04 00 00 00 lea 0x4(,%eax,4),%esi (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); 108f26: 83 ec 0c sub $0xc,%esp 108f29: 56 push %esi 108f2a: e8 d2 3d 00 00 call 10cd01 <_Workspace_Allocate> 108f2f: 89 c7 mov %eax,%edi if ( !table ) { 108f31: 83 c4 10 add $0x10,%esp 108f34: 85 c0 test %eax,%eax 108f36: 75 3f jne 108f77 for ( --the_api; 108f38: 8d 73 ff lea -0x1(%ebx),%esi 108f3b: 8b 45 f0 mov -0x10(%ebp),%eax 108f3e: 8d 5c 98 14 lea 0x14(%eax,%ebx,4),%ebx 108f42: eb 11 jmp 108f55 the_api >= 1; the_api-- ) _Workspace_Free( the_key->Values[ the_api ] ); 108f44: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108f47: ff 33 pushl (%ebx) <== NOT EXECUTED 108f49: e8 9e 3d 00 00 call 10ccec <_Workspace_Free> <== NOT EXECUTED (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { for ( --the_api; the_api >= 1; the_api-- ) 108f4e: 4e dec %esi <== NOT EXECUTED 108f4f: 83 eb 04 sub $0x4,%ebx <== NOT EXECUTED 108f52: 83 c4 10 add $0x10,%esp <== NOT EXECUTED bytes_to_allocate = sizeof( void * ) * (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { for ( --the_api; the_api >= 1; 108f55: 85 f6 test %esi,%esi 108f57: 75 eb jne 108f44 <== NEVER TAKEN * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 108f59: 50 push %eax 108f5a: 50 push %eax 108f5b: ff 75 f0 pushl -0x10(%ebp) 108f5e: 68 dc 04 12 00 push $0x1204dc 108f63: e8 0c 24 00 00 call 10b374 <_Objects_Free> the_api-- ) _Workspace_Free( the_key->Values[ the_api ] ); _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); 108f68: e8 fb 2c 00 00 call 10bc68 <_Thread_Enable_dispatch> 108f6d: b8 0c 00 00 00 mov $0xc,%eax 108f72: 83 c4 10 add $0x10,%esp 108f75: eb 4c jmp 108fc3 return ENOMEM; } the_key->Values[ the_api ] = table; 108f77: 8b 55 f0 mov -0x10(%ebp),%edx 108f7a: 89 44 9a 18 mov %eax,0x18(%edx,%ebx,4) memset( table, '\0', bytes_to_allocate ); 108f7e: 89 f1 mov %esi,%ecx 108f80: 31 c0 xor %eax,%eax 108f82: f3 aa rep stos %al,%es:(%edi) 108f84: eb 0b jmp 108f91 } else { the_key->Values[ the_api ] = NULL; 108f86: 8b 55 f0 mov -0x10(%ebp),%edx 108f89: c7 44 9a 18 00 00 00 movl $0x0,0x18(%edx,%ebx,4) 108f90: 00 * for. [NOTE: Currently RTEMS Classic API tasks are always enabled.] */ for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 108f91: 43 inc %ebx * APIs are optional. Thus there may be no ITRON tasks to have keys * for. [NOTE: Currently RTEMS Classic API tasks are always enabled.] */ for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; 108f92: 83 fb 05 cmp $0x5,%ebx 108f95: 0f 85 72 ff ff ff jne 108f0d } } the_key->is_active = TRUE; 108f9b: 8b 5d f0 mov -0x10(%ebp),%ebx 108f9e: c6 43 10 01 movb $0x1,0x10(%ebx) 108fa2: 8b 4b 08 mov 0x8(%ebx),%ecx 108fa5: 0f b7 d1 movzwl %cx,%edx 108fa8: a1 f8 04 12 00 mov 0x1204f8,%eax 108fad: 89 1c 90 mov %ebx,(%eax,%edx,4) 108fb0: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) _Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; 108fb7: 8b 45 08 mov 0x8(%ebp),%eax 108fba: 89 08 mov %ecx,(%eax) _Thread_Enable_dispatch(); 108fbc: e8 a7 2c 00 00 call 10bc68 <_Thread_Enable_dispatch> 108fc1: 31 c0 xor %eax,%eax return 0; } 108fc3: 8d 65 f4 lea -0xc(%ebp),%esp 108fc6: 5b pop %ebx 108fc7: 5e pop %esi 108fc8: 5f pop %edi 108fc9: c9 leave 108fca: c3 ret =============================================================================== 00108fcc : */ int pthread_key_delete( pthread_key_t key ) { 108fcc: 55 push %ebp 108fcd: 89 e5 mov %esp,%ebp 108fcf: 53 push %ebx 108fd0: 83 ec 18 sub $0x18,%esp static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 108fd3: 8d 45 f8 lea -0x8(%ebp),%eax 108fd6: 50 push %eax 108fd7: ff 75 08 pushl 0x8(%ebp) 108fda: 68 dc 04 12 00 push $0x1204dc 108fdf: e8 c4 24 00 00 call 10b4a8 <_Objects_Get> 108fe4: 89 c3 mov %eax,%ebx register POSIX_Keys_Control *the_key; Objects_Locations location; uint32_t the_api; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 108fe6: 83 c4 10 add $0x10,%esp 108fe9: b8 16 00 00 00 mov $0x16,%eax 108fee: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) 108ff2: 75 77 jne 10906b <== NEVER TAKEN case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Keys_Information, &the_key->Object ); 108ff4: 52 push %edx 108ff5: 52 push %edx 108ff6: 53 push %ebx 108ff7: 68 dc 04 12 00 push $0x1204dc 108ffc: e8 d7 20 00 00 call 10b0d8 <_Objects_Close> the_key->is_active = FALSE; 109001: c6 43 10 00 movb $0x0,0x10(%ebx) for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 109005: 8b 43 1c mov 0x1c(%ebx),%eax 109008: 83 c4 10 add $0x10,%esp 10900b: 85 c0 test %eax,%eax 10900d: 74 0c je 10901b <== NEVER TAKEN _Workspace_Free( the_key->Values[ the_api ] ); 10900f: 83 ec 0c sub $0xc,%esp 109012: 50 push %eax 109013: e8 d4 3c 00 00 call 10ccec <_Workspace_Free> 109018: 83 c4 10 add $0x10,%esp the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 10901b: 8b 43 20 mov 0x20(%ebx),%eax 10901e: 85 c0 test %eax,%eax 109020: 74 0c je 10902e <== NEVER TAKEN _Workspace_Free( the_key->Values[ the_api ] ); 109022: 83 ec 0c sub $0xc,%esp 109025: 50 push %eax 109026: e8 c1 3c 00 00 call 10ccec <_Workspace_Free> 10902b: 83 c4 10 add $0x10,%esp the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 10902e: 8b 43 24 mov 0x24(%ebx),%eax 109031: 85 c0 test %eax,%eax 109033: 74 0c je 109041 <== NEVER TAKEN _Workspace_Free( the_key->Values[ the_api ] ); 109035: 83 ec 0c sub $0xc,%esp 109038: 50 push %eax 109039: e8 ae 3c 00 00 call 10ccec <_Workspace_Free> 10903e: 83 c4 10 add $0x10,%esp the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 109041: 8b 43 28 mov 0x28(%ebx),%eax 109044: 85 c0 test %eax,%eax 109046: 74 0c je 109054 <== ALWAYS TAKEN _Workspace_Free( the_key->Values[ the_api ] ); 109048: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10904b: 50 push %eax <== NOT EXECUTED 10904c: e8 9b 3c 00 00 call 10ccec <_Workspace_Free> <== NOT EXECUTED 109051: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 109054: 50 push %eax 109055: 50 push %eax 109056: 53 push %ebx 109057: 68 dc 04 12 00 push $0x1204dc 10905c: e8 13 23 00 00 call 10b374 <_Objects_Free> * NOTE: The destructor is not called and it is the responsibility * of the application to free the memory. */ _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); 109061: e8 02 2c 00 00 call 10bc68 <_Thread_Enable_dispatch> 109066: 31 c0 xor %eax,%eax 109068: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return EINVAL; } 10906b: 8b 5d fc mov -0x4(%ebp),%ebx 10906e: c9 leave 10906f: c3 ret =============================================================================== 0011877c : int pthread_kill( pthread_t thread, int sig ) { 11877c: 55 push %ebp 11877d: 89 e5 mov %esp,%ebp 11877f: 57 push %edi 118780: 56 push %esi 118781: 53 push %ebx 118782: 83 ec 1c sub $0x1c,%esp 118785: 8b 75 0c mov 0xc(%ebp),%esi POSIX_API_Control *api; Thread_Control *the_thread; Objects_Locations location; if ( !sig ) 118788: 85 f6 test %esi,%esi 11878a: 74 08 je 118794 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 11878c: 8d 7e ff lea -0x1(%esi),%edi 11878f: 83 ff 1f cmp $0x1f,%edi 118792: 76 0d jbe 1187a1 rtems_set_errno_and_return_minus_one( EINVAL ); 118794: e8 83 7e ff ff call 11061c <__errno> 118799: c7 00 16 00 00 00 movl $0x16,(%eax) 11879f: eb 77 jmp 118818 the_thread = _Thread_Get( thread, &location ); 1187a1: 52 push %edx 1187a2: 52 push %edx 1187a3: 8d 45 f0 lea -0x10(%ebp),%eax 1187a6: 50 push %eax 1187a7: ff 75 08 pushl 0x8(%ebp) 1187aa: e8 a9 3a ff ff call 10c258 <_Thread_Get> 1187af: 89 c3 mov %eax,%ebx switch ( location ) { 1187b1: 83 c4 10 add $0x10,%esp 1187b4: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 1187b8: 75 53 jne 11880d <== NEVER TAKEN case OBJECTS_LOCAL: /* * If sig == 0 then just validate arguments */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 1187ba: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx if ( sig ) { if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 1187c0: 6b c6 0c imul $0xc,%esi,%eax 1187c3: 83 b8 88 98 12 00 01 cmpl $0x1,0x129888(%eax) 1187ca: 74 38 je 118804 <== NEVER TAKEN return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 1187cc: b8 01 00 00 00 mov $0x1,%eax 1187d1: 89 f9 mov %edi,%ecx 1187d3: d3 e0 shl %cl,%eax 1187d5: 09 82 c8 00 00 00 or %eax,0xc8(%edx) (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 1187db: 50 push %eax 1187dc: 6a 00 push $0x0 1187de: 56 push %esi 1187df: 53 push %ebx 1187e0: e8 a7 fe ff ff call 11868c <_POSIX_signals_Unblock_thread> the_thread->do_post_task_switch_extension = true; 1187e5: c6 43 75 01 movb $0x1,0x75(%ebx) if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 1187e9: a1 30 93 12 00 mov 0x129330,%eax 1187ee: 83 c4 10 add $0x10,%esp 1187f1: 85 c0 test %eax,%eax 1187f3: 74 0f je 118804 1187f5: 3b 1d 54 93 12 00 cmp 0x129354,%ebx 1187fb: 75 07 jne 118804 <== ALWAYS TAKEN _ISR_Signals_to_thread_executing = TRUE; 1187fd: c6 05 e8 93 12 00 01 movb $0x1,0x1293e8 <== NOT EXECUTED } _Thread_Enable_dispatch(); 118804: e8 03 3a ff ff call 10c20c <_Thread_Enable_dispatch> 118809: 31 c0 xor %eax,%eax 11880b: eb 0e jmp 11881b #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( ESRCH ); 11880d: e8 0a 7e ff ff call 11061c <__errno> <== NOT EXECUTED 118812: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED 118818: 83 c8 ff or $0xffffffff,%eax } 11881b: 8d 65 f4 lea -0xc(%ebp),%esp 11881e: 5b pop %ebx 11881f: 5e pop %esi 118820: 5f pop %edi 118821: c9 leave 118822: c3 ret =============================================================================== 0010a898 : int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr ) { 10a898: 55 push %ebp 10a899: 89 e5 mov %esp,%ebp 10a89b: 57 push %edi 10a89c: 56 push %esi 10a89d: 53 push %ebx 10a89e: 83 ec 0c sub $0xc,%esp 10a8a1: 8b 45 0c mov 0xc(%ebp),%eax #if 0 register POSIX_Mutex_Control *mutex_in_use; Objects_Locations location; #endif if ( attr ) the_attr = attr; 10a8a4: be 60 c3 11 00 mov $0x11c360,%esi 10a8a9: 85 c0 test %eax,%eax 10a8ab: 74 02 je 10a8af 10a8ad: 89 c6 mov %eax,%esi else the_attr = &_POSIX_Mutex_Default_attributes; /* Check for NULL mutex */ if ( !mutex ) 10a8af: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 10a8b3: 0f 84 df 00 00 00 je 10a998 break; } } #endif if ( !the_attr->is_initialized ) 10a8b9: 83 3e 00 cmpl $0x0,(%esi) 10a8bc: 0f 84 d6 00 00 00 je 10a998 /* * XXX: Be careful about attributes when global!!! */ assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE ); 10a8c2: 83 7e 04 00 cmpl $0x0,0x4(%esi) 10a8c6: 74 16 je 10a8de <== ALWAYS TAKEN 10a8c8: 68 74 c3 11 00 push $0x11c374 <== NOT EXECUTED 10a8cd: 68 f4 c3 11 00 push $0x11c3f4 <== NOT EXECUTED 10a8d2: 6a 68 push $0x68 <== NOT EXECUTED 10a8d4: 68 a8 c3 11 00 push $0x11c3a8 <== NOT EXECUTED 10a8d9: e8 6a d5 ff ff call 107e48 <__assert_func> <== NOT EXECUTED /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 10a8de: 8b 46 0c mov 0xc(%esi),%eax 10a8e1: 83 f8 01 cmp $0x1,%eax 10a8e4: 74 10 je 10a8f6 10a8e6: 83 f8 02 cmp $0x2,%eax 10a8e9: 74 12 je 10a8fd 10a8eb: 31 ff xor %edi,%edi 10a8ed: 85 c0 test %eax,%eax 10a8ef: 74 11 je 10a902 10a8f1: e9 a2 00 00 00 jmp 10a998 10a8f6: bf 02 00 00 00 mov $0x2,%edi 10a8fb: eb 05 jmp 10a902 10a8fd: bf 03 00 00 00 mov $0x3,%edi break; default: return EINVAL; } if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) ) 10a902: 8b 46 08 mov 0x8(%esi),%eax 10a905: 48 dec %eax 10a906: 3d fd 00 00 00 cmp $0xfd,%eax 10a90b: 0f 87 87 00 00 00 ja 10a998 /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a911: a1 68 2b 12 00 mov 0x122b68,%eax 10a916: 40 inc %eax 10a917: a3 68 2b 12 00 mov %eax,0x122b68 * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 10a91c: 83 ec 0c sub $0xc,%esp 10a91f: 68 18 2f 12 00 push $0x122f18 10a924: e8 f7 23 00 00 call 10cd20 <_Objects_Allocate> 10a929: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); the_mutex = _POSIX_Mutex_Allocate(); if ( !the_mutex ) { 10a92b: 83 c4 10 add $0x10,%esp 10a92e: 85 c0 test %eax,%eax 10a930: 75 0c jne 10a93e _Thread_Enable_dispatch(); 10a932: e8 ed 2f 00 00 call 10d924 <_Thread_Enable_dispatch> 10a937: b8 0b 00 00 00 mov $0xb,%eax 10a93c: eb 5f jmp 10a99d return EAGAIN; } the_mutex->process_shared = the_attr->process_shared; 10a93e: 8b 46 04 mov 0x4(%esi),%eax 10a941: 89 43 10 mov %eax,0x10(%ebx) the_mutex_attr = &the_mutex->Mutex.Attributes; if ( the_attr->recursive ) the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 10a944: 31 c0 xor %eax,%eax 10a946: 83 7e 10 00 cmpl $0x0,0x10(%esi) 10a94a: 0f 94 c0 sete %al 10a94d: 89 43 54 mov %eax,0x54(%ebx) else the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR; the_mutex_attr->only_owner_release = TRUE; 10a950: c6 43 58 01 movb $0x1,0x58(%ebx) the_mutex_attr->priority_ceiling = 10a954: b8 ff 00 00 00 mov $0xff,%eax 10a959: 2b 46 08 sub 0x8(%esi),%eax 10a95c: 89 43 60 mov %eax,0x60(%ebx) _POSIX_Priority_To_core( the_attr->prio_ceiling ); the_mutex_attr->discipline = the_discipline; 10a95f: 89 7b 5c mov %edi,0x5c(%ebx) /* * Must be initialized to unlocked. */ _CORE_mutex_Initialize( 10a962: 50 push %eax 10a963: 6a 01 push $0x1 10a965: 8d 43 54 lea 0x54(%ebx),%eax 10a968: 50 push %eax 10a969: 8d 43 14 lea 0x14(%ebx),%eax 10a96c: 50 push %eax 10a96d: e8 12 1d 00 00 call 10c684 <_CORE_mutex_Initialize> 10a972: 8b 4b 08 mov 0x8(%ebx),%ecx 10a975: 0f b7 d1 movzwl %cx,%edx 10a978: a1 34 2f 12 00 mov 0x122f34,%eax 10a97d: 89 1c 90 mov %ebx,(%eax,%edx,4) 10a980: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) CORE_MUTEX_UNLOCKED ); _Objects_Open_u32( &_POSIX_Mutex_Information, &the_mutex->Object, 0 ); *mutex = the_mutex->Object.id; 10a987: 8b 45 08 mov 0x8(%ebp),%eax 10a98a: 89 08 mov %ecx,(%eax) _Thread_Enable_dispatch(); 10a98c: e8 93 2f 00 00 call 10d924 <_Thread_Enable_dispatch> 10a991: 31 c0 xor %eax,%eax 10a993: 83 c4 10 add $0x10,%esp 10a996: eb 05 jmp 10a99d return 0; 10a998: b8 16 00 00 00 mov $0x16,%eax } 10a99d: 8d 65 f4 lea -0xc(%ebp),%esp 10a9a0: 5b pop %ebx 10a9a1: 5e pop %esi 10a9a2: 5f pop %edi 10a9a3: c9 leave 10a9a4: c3 ret =============================================================================== 0010aa18 : int pthread_mutex_setprioceiling( pthread_mutex_t *mutex, int prioceiling, int *old_ceiling ) { 10aa18: 55 push %ebp 10aa19: 89 e5 mov %esp,%ebp 10aa1b: 57 push %edi 10aa1c: 56 push %esi 10aa1d: 53 push %ebx 10aa1e: 83 ec 1c sub $0x1c,%esp 10aa21: 8b 75 08 mov 0x8(%ebp),%esi 10aa24: 8b 7d 10 mov 0x10(%ebp),%edi register POSIX_Mutex_Control *the_mutex; Objects_Locations location; Priority_Control the_priority; int status; if ( !old_ceiling ) 10aa27: 85 ff test %edi,%edi 10aa29: 74 5f je 10aa8a return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) 10aa2b: 8b 45 0c mov 0xc(%ebp),%eax 10aa2e: 48 dec %eax 10aa2f: 3d fd 00 00 00 cmp $0xfd,%eax 10aa34: 77 54 ja 10aa8a /* * Must acquire the mutex before we can change it's ceiling */ status = pthread_mutex_lock( mutex ); 10aa36: 83 ec 0c sub $0xc,%esp 10aa39: 56 push %esi 10aa3a: e8 69 ff ff ff call 10a9a8 10aa3f: 89 c3 mov %eax,%ebx if ( status ) 10aa41: 83 c4 10 add $0x10,%esp 10aa44: 85 c0 test %eax,%eax 10aa46: 75 47 jne 10aa8f return status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); 10aa48: 52 push %edx 10aa49: 52 push %edx 10aa4a: 8d 45 f0 lea -0x10(%ebp),%eax 10aa4d: 50 push %eax 10aa4e: 56 push %esi 10aa4f: e8 b9 fd ff ff call 10a80d <_POSIX_Mutex_Get> 10aa54: 89 c1 mov %eax,%ecx switch ( location ) { 10aa56: 83 c4 10 add $0x10,%esp 10aa59: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 10aa5d: 75 2b jne 10aa8a <== NEVER TAKEN case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( 10aa5f: b8 ff 00 00 00 mov $0xff,%eax 10aa64: 89 c2 mov %eax,%edx 10aa66: 2b 51 60 sub 0x60(%ecx),%edx 10aa69: 89 17 mov %edx,(%edi) the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; 10aa6b: 2b 45 0c sub 0xc(%ebp),%eax 10aa6e: 89 41 60 mov %eax,0x60(%ecx) _CORE_mutex_Surrender( 10aa71: 50 push %eax 10aa72: 6a 00 push $0x0 10aa74: ff 71 08 pushl 0x8(%ecx) 10aa77: 8d 41 14 lea 0x14(%ecx),%eax 10aa7a: 50 push %eax 10aa7b: e8 80 1d 00 00 call 10c800 <_CORE_mutex_Surrender> &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 10aa80: e8 9f 2e 00 00 call 10d924 <_Thread_Enable_dispatch> 10aa85: 83 c4 10 add $0x10,%esp 10aa88: eb 05 jmp 10aa8f return 0; 10aa8a: bb 16 00 00 00 mov $0x16,%ebx case OBJECTS_ERROR: break; } return EINVAL; } 10aa8f: 89 d8 mov %ebx,%eax 10aa91: 8d 65 f4 lea -0xc(%ebp),%esp 10aa94: 5b pop %ebx 10aa95: 5e pop %esi 10aa96: 5f pop %edi 10aa97: c9 leave 10aa98: c3 ret =============================================================================== 0010aa9c : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 10aa9c: 55 push %ebp 10aa9d: 89 e5 mov %esp,%ebp 10aa9f: 83 ec 20 sub $0x20,%esp * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10aaa2: 8d 45 fc lea -0x4(%ebp),%eax 10aaa5: 50 push %eax 10aaa6: ff 75 0c pushl 0xc(%ebp) 10aaa9: e8 96 00 00 00 call 10ab44 <_POSIX_Absolute_timeout_to_ticks> switch ( status ) { 10aaae: 83 c4 10 add $0x10,%esp 10aab1: 31 d2 xor %edx,%edx 10aab3: 83 f8 02 cmp $0x2,%eax 10aab6: 76 07 jbe 10aabf <== NEVER TAKEN 10aab8: 83 f8 03 cmp $0x3,%eax 10aabb: 75 02 jne 10aabf <== NEVER TAKEN 10aabd: b2 01 mov $0x1,%dl case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } lock_status = _POSIX_Mutex_Lock_support( 10aabf: 50 push %eax 10aac0: ff 75 fc pushl -0x4(%ebp) 10aac3: 0f b6 c2 movzbl %dl,%eax 10aac6: 50 push %eax 10aac7: ff 75 08 pushl 0x8(%ebp) 10aaca: e8 ed fe ff ff call 10a9bc <_POSIX_Mutex_Lock_support> break; } } return lock_status; } 10aacf: c9 leave 10aad0: c3 ret =============================================================================== 0010a72c : int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { 10a72c: 55 push %ebp 10a72d: 89 e5 mov %esp,%ebp 10a72f: 8b 45 08 mov 0x8(%ebp),%eax 10a732: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr || !attr->is_initialized ) 10a735: 85 c0 test %eax,%eax 10a737: 74 11 je 10a74a 10a739: 83 38 00 cmpl $0x0,(%eax) 10a73c: 74 0c je 10a74a return EINVAL; switch ( pshared ) { 10a73e: 83 fa 01 cmp $0x1,%edx 10a741: 77 07 ja 10a74a <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10a743: 89 50 04 mov %edx,0x4(%eax) 10a746: 31 c0 xor %eax,%eax 10a748: eb 05 jmp 10a74f return 0; 10a74a: b8 16 00 00 00 mov $0x16,%eax default: return EINVAL; } } 10a74f: c9 leave 10a750: c3 ret =============================================================================== 0010a0b0 : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 10a0b0: 55 push %ebp 10a0b1: 89 e5 mov %esp,%ebp 10a0b3: 56 push %esi 10a0b4: 53 push %ebx 10a0b5: 83 ec 10 sub $0x10,%esp 10a0b8: 8b 5d 08 mov 0x8(%ebp),%ebx 10a0bb: 8b 75 0c mov 0xc(%ebp),%esi if ( !once_control || !init_routine ) 10a0be: 85 db test %ebx,%ebx 10a0c0: 74 04 je 10a0c6 10a0c2: 85 f6 test %esi,%esi 10a0c4: 75 07 jne 10a0cd 10a0c6: b8 16 00 00 00 mov $0x16,%eax 10a0cb: eb 4b jmp 10a118 return EINVAL; if ( !once_control->init_executed ) { 10a0cd: 31 c0 xor %eax,%eax 10a0cf: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a0d3: 75 43 jne 10a118 rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 10a0d5: 52 push %edx 10a0d6: 8d 45 f4 lea -0xc(%ebp),%eax 10a0d9: 50 push %eax 10a0da: 68 00 01 00 00 push $0x100 10a0df: 68 00 01 00 00 push $0x100 10a0e4: e8 8f 0c 00 00 call 10ad78 if ( !once_control->init_executed ) { 10a0e9: 83 c4 10 add $0x10,%esp 10a0ec: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 10a0f0: 75 0f jne 10a101 <== NEVER TAKEN once_control->is_initialized = TRUE; 10a0f2: c7 03 01 00 00 00 movl $0x1,(%ebx) once_control->init_executed = TRUE; 10a0f8: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) (*init_routine)(); 10a0ff: ff d6 call *%esi } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10a101: 50 push %eax 10a102: 8d 45 f4 lea -0xc(%ebp),%eax 10a105: 50 push %eax 10a106: 68 00 01 00 00 push $0x100 10a10b: ff 75 f4 pushl -0xc(%ebp) 10a10e: e8 65 0c 00 00 call 10ad78 10a113: 31 c0 xor %eax,%eax 10a115: 83 c4 10 add $0x10,%esp } return 0; } 10a118: 8d 65 f8 lea -0x8(%ebp),%esp 10a11b: 5b pop %ebx 10a11c: 5e pop %esi 10a11d: c9 leave 10a11e: c3 ret =============================================================================== 001097cc : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 1097cc: 55 push %ebp 1097cd: 89 e5 mov %esp,%ebp 1097cf: 56 push %esi 1097d0: 53 push %ebx 1097d1: 83 ec 10 sub $0x10,%esp 1097d4: 8b 75 08 mov 0x8(%ebp),%esi const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 1097d7: 85 f6 test %esi,%esi 1097d9: 0f 84 82 00 00 00 je 109861 return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 1097df: 8b 45 0c mov 0xc(%ebp),%eax 1097e2: 85 c0 test %eax,%eax 1097e4: 75 11 jne 1097f7 <== ALWAYS TAKEN the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 1097e6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1097e9: 8d 5d ec lea -0x14(%ebp),%ebx <== NOT EXECUTED 1097ec: 53 push %ebx <== NOT EXECUTED 1097ed: e8 9a 09 00 00 call 10a18c <== NOT EXECUTED 1097f2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1097f4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 1097f7: 83 38 00 cmpl $0x0,(%eax) 1097fa: 74 65 je 109861 <== NEVER TAKEN return EINVAL; switch ( the_attr->process_shared ) { 1097fc: 83 78 04 00 cmpl $0x0,0x4(%eax) 109800: 75 5f jne 109861 <== NEVER TAKEN /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109802: a1 d0 fb 11 00 mov 0x11fbd0,%eax 109807: 40 inc %eax 109808: a3 d0 fb 11 00 mov %eax,0x11fbd0 */ /**@{*/ #ifdef __cplusplus extern "C" { #endif 10980d: 83 ec 0c sub $0xc,%esp 109810: 68 00 fe 11 00 push $0x11fe00 109815: e8 2e 25 00 00 call 10bd48 <_Objects_Allocate> 10981a: 89 c3 mov %eax,%ebx */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 10981c: 83 c4 10 add $0x10,%esp 10981f: 85 c0 test %eax,%eax 109821: 75 0c jne 10982f _Thread_Enable_dispatch(); 109823: e8 24 31 00 00 call 10c94c <_Thread_Enable_dispatch> 109828: b8 0b 00 00 00 mov $0xb,%eax 10982d: eb 37 jmp 109866 return EAGAIN; } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 10982f: 50 push %eax 109830: 50 push %eax 109831: 8d 45 f4 lea -0xc(%ebp),%eax 109834: 50 push %eax 109835: 8d 43 10 lea 0x10(%ebx),%eax 109838: 50 push %eax 109839: e8 ae 1e 00 00 call 10b6ec <_CORE_RWLock_Initialize> 10983e: 8b 4b 08 mov 0x8(%ebx),%ecx 109841: 0f b7 d1 movzwl %cx,%edx 109844: a1 1c fe 11 00 mov 0x11fe1c,%eax 109849: 89 1c 90 mov %ebx,(%eax,%edx,4) 10984c: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 109853: 89 0e mov %ecx,(%esi) _Thread_Enable_dispatch(); 109855: e8 f2 30 00 00 call 10c94c <_Thread_Enable_dispatch> 10985a: 31 c0 xor %eax,%eax 10985c: 83 c4 10 add $0x10,%esp 10985f: eb 05 jmp 109866 return 0; 109861: b8 16 00 00 00 mov $0x16,%eax } 109866: 8d 65 f8 lea -0x8(%ebp),%esp 109869: 5b pop %ebx 10986a: 5e pop %esi 10986b: c9 leave 10986c: c3 ret =============================================================================== 001098d4 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 1098d4: 55 push %ebp 1098d5: 89 e5 mov %esp,%ebp 1098d7: 57 push %edi 1098d8: 56 push %esi 1098d9: 53 push %ebx 1098da: 83 ec 1c sub $0x1c,%esp 1098dd: 8b 7d 08 mov 0x8(%ebp),%edi Objects_Locations location; Watchdog_Interval ticks; bool do_wait; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 1098e0: 85 ff test %edi,%edi 1098e2: 0f 84 8e 00 00 00 je 109976 * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 1098e8: 52 push %edx 1098e9: 52 push %edx 1098ea: 8d 45 ec lea -0x14(%ebp),%eax 1098ed: 50 push %eax 1098ee: ff 75 0c pushl 0xc(%ebp) 1098f1: e8 22 5a 00 00 call 10f318 <_POSIX_Absolute_timeout_to_ticks> 1098f6: 89 c6 mov %eax,%esi switch (status) { 1098f8: 83 c4 10 add $0x10,%esp 1098fb: 31 db xor %ebx,%ebx 1098fd: 83 f8 02 cmp $0x2,%eax 109900: 76 07 jbe 109909 109902: 83 f8 03 cmp $0x3,%eax 109905: 75 02 jne 109909 <== NEVER TAKEN 109907: b3 01 mov $0x1,%bl 109909: 50 push %eax 10990a: 8d 45 f0 lea -0x10(%ebp),%eax 10990d: 50 push %eax 10990e: ff 37 pushl (%edi) 109910: 68 00 fe 11 00 push $0x11fe00 109915: e8 72 28 00 00 call 10c18c <_Objects_Get> 10991a: 89 c2 mov %eax,%edx do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 10991c: 83 c4 10 add $0x10,%esp 10991f: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 109923: 75 51 jne 109976 case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 109925: 83 ec 0c sub $0xc,%esp 109928: 6a 00 push $0x0 10992a: ff 75 ec pushl -0x14(%ebp) 10992d: 0f b6 c3 movzbl %bl,%eax 109930: 50 push %eax 109931: ff 37 pushl (%edi) 109933: 8d 42 10 lea 0x10(%edx),%eax 109936: 50 push %eax 109937: e8 e4 1d 00 00 call 10b720 <_CORE_RWLock_Obtain_for_reading> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10993c: 83 c4 20 add $0x20,%esp 10993f: e8 08 30 00 00 call 10c94c <_Thread_Enable_dispatch> if ( !do_wait && 109944: 84 db test %bl,%bl 109946: 75 19 jne 109961 <== ALWAYS TAKEN 109948: a1 90 fc 11 00 mov 0x11fc90,%eax <== NOT EXECUTED 10994d: 83 78 34 02 cmpl $0x2,0x34(%eax) <== NOT EXECUTED 109951: 75 0e jne 109961 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 109953: 85 f6 test %esi,%esi <== NOT EXECUTED 109955: 74 1f je 109976 <== NOT EXECUTED 109957: b8 74 00 00 00 mov $0x74,%eax <== NOT EXECUTED 10995c: 83 fe 02 cmp $0x2,%esi <== NOT EXECUTED 10995f: 76 1a jbe 10997b <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 109961: 83 ec 0c sub $0xc,%esp 109964: a1 90 fc 11 00 mov 0x11fc90,%eax 109969: ff 70 34 pushl 0x34(%eax) 10996c: e8 c3 00 00 00 call 109a34 <_POSIX_RWLock_Translate_core_RWLock_return_code> 109971: 83 c4 10 add $0x10,%esp 109974: eb 05 jmp 10997b 109976: b8 16 00 00 00 mov $0x16,%eax case OBJECTS_ERROR: break; } return EINVAL; } 10997b: 8d 65 f4 lea -0xc(%ebp),%esp 10997e: 5b pop %ebx 10997f: 5e pop %esi 109980: 5f pop %edi 109981: c9 leave 109982: c3 ret =============================================================================== 00109984 : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 109984: 55 push %ebp 109985: 89 e5 mov %esp,%ebp 109987: 57 push %edi 109988: 56 push %esi 109989: 53 push %ebx 10998a: 83 ec 1c sub $0x1c,%esp 10998d: 8b 7d 08 mov 0x8(%ebp),%edi Objects_Locations location; Watchdog_Interval ticks; bool do_wait; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 109990: 85 ff test %edi,%edi 109992: 0f 84 8e 00 00 00 je 109a26 * So we check the abstime provided, and hold on to whether it * is valid or not. If it isn't correct and in the future, * then we do a polling operation and convert the UNSATISFIED * status into the appropriate error. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 109998: 52 push %edx 109999: 52 push %edx 10999a: 8d 45 ec lea -0x14(%ebp),%eax 10999d: 50 push %eax 10999e: ff 75 0c pushl 0xc(%ebp) 1099a1: e8 72 59 00 00 call 10f318 <_POSIX_Absolute_timeout_to_ticks> 1099a6: 89 c6 mov %eax,%esi switch (status) { 1099a8: 83 c4 10 add $0x10,%esp 1099ab: 31 db xor %ebx,%ebx 1099ad: 83 f8 02 cmp $0x2,%eax 1099b0: 76 07 jbe 1099b9 1099b2: 83 f8 03 cmp $0x3,%eax 1099b5: 75 02 jne 1099b9 <== NEVER TAKEN 1099b7: b3 01 mov $0x1,%bl 1099b9: 50 push %eax 1099ba: 8d 45 f0 lea -0x10(%ebp),%eax 1099bd: 50 push %eax 1099be: ff 37 pushl (%edi) 1099c0: 68 00 fe 11 00 push $0x11fe00 1099c5: e8 c2 27 00 00 call 10c18c <_Objects_Get> 1099ca: 89 c2 mov %eax,%edx do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 1099cc: 83 c4 10 add $0x10,%esp 1099cf: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 1099d3: 75 51 jne 109a26 case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 1099d5: 83 ec 0c sub $0xc,%esp 1099d8: 6a 00 push $0x0 1099da: ff 75 ec pushl -0x14(%ebp) 1099dd: 0f b6 c3 movzbl %bl,%eax 1099e0: 50 push %eax 1099e1: ff 37 pushl (%edi) 1099e3: 8d 42 10 lea 0x10(%edx),%eax 1099e6: 50 push %eax 1099e7: e8 e8 1d 00 00 call 10b7d4 <_CORE_RWLock_Obtain_for_writing> do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 1099ec: 83 c4 20 add $0x20,%esp 1099ef: e8 58 2f 00 00 call 10c94c <_Thread_Enable_dispatch> if ( !do_wait && 1099f4: 84 db test %bl,%bl 1099f6: 75 19 jne 109a11 <== ALWAYS TAKEN 1099f8: a1 90 fc 11 00 mov 0x11fc90,%eax <== NOT EXECUTED 1099fd: 83 78 34 02 cmpl $0x2,0x34(%eax) <== NOT EXECUTED 109a01: 75 0e jne 109a11 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 109a03: 85 f6 test %esi,%esi <== NOT EXECUTED 109a05: 74 1f je 109a26 <== NOT EXECUTED 109a07: b8 74 00 00 00 mov $0x74,%eax <== NOT EXECUTED 109a0c: 83 fe 02 cmp $0x2,%esi <== NOT EXECUTED 109a0f: 76 1a jbe 109a2b <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 109a11: 83 ec 0c sub $0xc,%esp 109a14: a1 90 fc 11 00 mov 0x11fc90,%eax 109a19: ff 70 34 pushl 0x34(%eax) 109a1c: e8 13 00 00 00 call 109a34 <_POSIX_RWLock_Translate_core_RWLock_return_code> 109a21: 83 c4 10 add $0x10,%esp 109a24: eb 05 jmp 109a2b 109a26: b8 16 00 00 00 mov $0x16,%eax case OBJECTS_ERROR: break; } return EINVAL; } 109a2b: 8d 65 f4 lea -0xc(%ebp),%esp 109a2e: 5b pop %ebx 109a2f: 5e pop %esi 109a30: 5f pop %edi 109a31: c9 leave 109a32: c3 ret =============================================================================== 0010a1ac : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { 10a1ac: 55 push %ebp 10a1ad: 89 e5 mov %esp,%ebp 10a1af: 8b 45 08 mov 0x8(%ebp),%eax 10a1b2: 8b 55 0c mov 0xc(%ebp),%edx if ( !attr ) 10a1b5: 85 c0 test %eax,%eax 10a1b7: 74 11 je 10a1ca return EINVAL; if ( !attr->is_initialized ) 10a1b9: 83 38 00 cmpl $0x0,(%eax) 10a1bc: 74 0c je 10a1ca return EINVAL; switch ( pshared ) { 10a1be: 83 fa 01 cmp $0x1,%edx 10a1c1: 77 07 ja 10a1ca <== NEVER TAKEN case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10a1c3: 89 50 04 mov %edx,0x4(%eax) 10a1c6: 31 c0 xor %eax,%eax 10a1c8: eb 05 jmp 10a1cf return 0; 10a1ca: b8 16 00 00 00 mov $0x16,%eax default: return EINVAL; } } 10a1cf: c9 leave 10a1d0: c3 ret =============================================================================== 00109164 : int pthread_setcancelstate( int state, int *oldstate ) { 109164: 55 push %ebp 109165: 89 e5 mov %esp,%ebp 109167: 53 push %ebx 109168: 83 ec 04 sub $0x4,%esp 10916b: 8b 4d 08 mov 0x8(%ebp),%ecx 10916e: 8b 5d 0c mov 0xc(%ebp),%ebx * 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() ) 109171: a1 84 f5 11 00 mov 0x11f584,%eax 109176: ba 47 00 00 00 mov $0x47,%edx 10917b: 85 c0 test %eax,%eax 10917d: 75 6e jne 1091ed <== NEVER TAKEN return EPROTO; if ( !oldstate ) 10917f: 85 db test %ebx,%ebx 109181: 74 65 je 1091e8 <== NEVER TAKEN return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) 109183: 83 f9 01 cmp $0x1,%ecx 109186: 77 60 ja 1091e8 <== NEVER TAKEN return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 109188: a1 a8 f5 11 00 mov 0x11f5a8,%eax 10918d: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109193: a1 e8 f4 11 00 mov 0x11f4e8,%eax 109198: 40 inc %eax 109199: a3 e8 f4 11 00 mov %eax,0x11f4e8 _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; 10919e: 8b 82 cc 00 00 00 mov 0xcc(%edx),%eax 1091a4: 89 03 mov %eax,(%ebx) thread_support->cancelability_state = state; 1091a6: 89 8a cc 00 00 00 mov %ecx,0xcc(%edx) if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 1091ac: 85 c9 test %ecx,%ecx 1091ae: 75 15 jne 1091c5 <== NEVER TAKEN 1091b0: 83 ba d0 00 00 00 01 cmpl $0x1,0xd0(%edx) 1091b7: 75 0c jne 1091c5 <== ALWAYS TAKEN 1091b9: 83 ba d4 00 00 00 00 cmpl $0x0,0xd4(%edx) <== NOT EXECUTED 1091c0: 0f 95 c3 setne %bl <== NOT EXECUTED 1091c3: eb 02 jmp 1091c7 <== NOT EXECUTED 1091c5: 31 db xor %ebx,%ebx thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 1091c7: e8 00 26 00 00 call 10b7cc <_Thread_Enable_dispatch> if ( cancel ) 1091cc: 31 d2 xor %edx,%edx 1091ce: 84 db test %bl,%bl 1091d0: 74 1b je 1091ed <== ALWAYS TAKEN _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 1091d2: 50 push %eax <== NOT EXECUTED 1091d3: 50 push %eax <== NOT EXECUTED 1091d4: 6a ff push $0xffffffff <== NOT EXECUTED 1091d6: ff 35 a8 f5 11 00 pushl 0x11f5a8 <== NOT EXECUTED 1091dc: e8 83 fb ff ff call 108d64 <_POSIX_Thread_Exit> <== NOT EXECUTED 1091e1: 31 d2 xor %edx,%edx <== NOT EXECUTED 1091e3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1091e6: eb 05 jmp 1091ed <== NOT EXECUTED 1091e8: ba 16 00 00 00 mov $0x16,%edx <== NOT EXECUTED return 0; } 1091ed: 89 d0 mov %edx,%eax 1091ef: 8b 5d fc mov -0x4(%ebp),%ebx 1091f2: c9 leave 1091f3: c3 ret =============================================================================== 001091f4 : int pthread_setcanceltype( int type, int *oldtype ) { 1091f4: 55 push %ebp 1091f5: 89 e5 mov %esp,%ebp 1091f7: 53 push %ebx 1091f8: 83 ec 04 sub $0x4,%esp 1091fb: 8b 4d 08 mov 0x8(%ebp),%ecx 1091fe: 8b 5d 0c mov 0xc(%ebp),%ebx * 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() ) 109201: a1 84 f5 11 00 mov 0x11f584,%eax 109206: ba 47 00 00 00 mov $0x47,%edx 10920b: 85 c0 test %eax,%eax 10920d: 75 6d jne 10927c <== NEVER TAKEN return EPROTO; if ( !oldtype ) 10920f: 85 db test %ebx,%ebx 109211: 74 64 je 109277 <== NEVER TAKEN return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) 109213: 83 f9 01 cmp $0x1,%ecx 109216: 77 5f ja 109277 <== NEVER TAKEN return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 109218: a1 a8 f5 11 00 mov 0x11f5a8,%eax 10921d: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx 109223: a1 e8 f4 11 00 mov 0x11f4e8,%eax 109228: 40 inc %eax 109229: a3 e8 f4 11 00 mov %eax,0x11f4e8 _Thread_Disable_dispatch(); *oldtype = thread_support->cancelability_type; 10922e: 8b 82 d0 00 00 00 mov 0xd0(%edx),%eax 109234: 89 03 mov %eax,(%ebx) thread_support->cancelability_type = type; 109236: 89 8a d0 00 00 00 mov %ecx,0xd0(%edx) if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10923c: 83 ba cc 00 00 00 00 cmpl $0x0,0xcc(%edx) 109243: 75 0f jne 109254 <== NEVER TAKEN 109245: 49 dec %ecx 109246: 75 0c jne 109254 109248: 83 ba d4 00 00 00 00 cmpl $0x0,0xd4(%edx) 10924f: 0f 95 c3 setne %bl 109252: eb 02 jmp 109256 109254: 31 db xor %ebx,%ebx thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 109256: e8 71 25 00 00 call 10b7cc <_Thread_Enable_dispatch> if ( cancel ) 10925b: 31 d2 xor %edx,%edx 10925d: 84 db test %bl,%bl 10925f: 74 1b je 10927c <== ALWAYS TAKEN _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 109261: 50 push %eax <== NOT EXECUTED 109262: 50 push %eax <== NOT EXECUTED 109263: 6a ff push $0xffffffff <== NOT EXECUTED 109265: ff 35 a8 f5 11 00 pushl 0x11f5a8 <== NOT EXECUTED 10926b: e8 f4 fa ff ff call 108d64 <_POSIX_Thread_Exit> <== NOT EXECUTED 109270: 31 d2 xor %edx,%edx <== NOT EXECUTED 109272: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109275: eb 05 jmp 10927c <== NOT EXECUTED 109277: ba 16 00 00 00 mov $0x16,%edx <== NOT EXECUTED return 0; } 10927c: 89 d0 mov %edx,%eax 10927e: 8b 5d fc mov -0x4(%ebp),%ebx 109281: c9 leave 109282: c3 ret =============================================================================== 0010b2b4 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 10b2b4: 55 push %ebp 10b2b5: 89 e5 mov %esp,%ebp 10b2b7: 57 push %edi 10b2b8: 56 push %esi 10b2b9: 53 push %ebx 10b2ba: 83 ec 2c sub $0x2c,%esp /* * Check all the parameters */ if ( !param ) 10b2bd: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10b2c1: 0f 84 7e 01 00 00 je 10b445 return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 10b2c7: 8b 55 10 mov 0x10(%ebp),%edx 10b2ca: 8b 02 mov (%edx),%eax 10b2cc: 48 dec %eax 10b2cd: 3d fd 00 00 00 cmp $0xfd,%eax 10b2d2: 0f 87 6d 01 00 00 ja 10b445 <== NEVER TAKEN return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 10b2d8: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 10b2dc: 74 1f je 10b2fd 10b2de: 7f 0b jg 10b2eb 10b2e0: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10b2e4: 74 20 je 10b306 10b2e6: e9 5a 01 00 00 jmp 10b445 10b2eb: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) 10b2ef: 74 25 je 10b316 10b2f1: 83 7d 0c 03 cmpl $0x3,0xc(%ebp) 10b2f5: 0f 85 4a 01 00 00 jne 10b445 <== NEVER TAKEN 10b2fb: eb 22 jmp 10b31f 10b2fd: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) 10b304: eb 07 jmp 10b30d 10b306: c7 45 dc 01 00 00 00 movl $0x1,-0x24(%ebp) 10b30d: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) 10b314: eb 53 jmp 10b369 10b316: c7 45 dc 02 00 00 00 movl $0x2,-0x24(%ebp) 10b31d: eb ee jmp 10b30d case SCHED_SPORADIC: budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; budget_callout = _POSIX_Threads_Sporadic_budget_callout; if ( _Timespec_To_ticks( ¶m->ss_replenish_period ) < 10b31f: 83 ec 0c sub $0xc,%esp 10b322: 8b 45 10 mov 0x10(%ebp),%eax 10b325: 83 c0 08 add $0x8,%eax 10b328: 50 push %eax 10b329: e8 d2 31 00 00 call 10e500 <_Timespec_To_ticks> 10b32e: 89 c3 mov %eax,%ebx 10b330: 8b 45 10 mov 0x10(%ebp),%eax 10b333: 83 c0 10 add $0x10,%eax 10b336: 89 04 24 mov %eax,(%esp) 10b339: e8 c2 31 00 00 call 10e500 <_Timespec_To_ticks> 10b33e: 83 c4 10 add $0x10,%esp 10b341: 39 c3 cmp %eax,%ebx 10b343: 0f 82 fc 00 00 00 jb 10b445 <== NEVER TAKEN _Timespec_To_ticks( ¶m->ss_initial_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->ss_low_priority ) ) 10b349: 8b 75 10 mov 0x10(%ebp),%esi 10b34c: 8b 46 04 mov 0x4(%esi),%eax 10b34f: 48 dec %eax 10b350: 3d fd 00 00 00 cmp $0xfd,%eax 10b355: 0f 87 ea 00 00 00 ja 10b445 10b35b: c7 45 dc 03 00 00 00 movl $0x3,-0x24(%ebp) 10b362: c7 45 e0 dc b1 10 00 movl $0x10b1dc,-0x20(%ebp) static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10b369: 53 push %ebx 10b36a: 8d 45 f0 lea -0x10(%ebp),%eax 10b36d: 50 push %eax 10b36e: ff 75 08 pushl 0x8(%ebp) 10b371: 68 d8 2d 12 00 push $0x122dd8 10b376: e8 e9 1d 00 00 call 10d164 <_Objects_Get> 10b37b: 89 45 d4 mov %eax,-0x2c(%ebp) /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 10b37e: 83 c4 10 add $0x10,%esp 10b381: b8 03 00 00 00 mov $0x3,%eax 10b386: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 10b38a: 0f 85 ba 00 00 00 jne 10b44a case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10b390: 8b 45 d4 mov -0x2c(%ebp),%eax 10b393: 8b 98 f8 00 00 00 mov 0xf8(%eax),%ebx if ( api->schedpolicy == SCHED_SPORADIC ) 10b399: 83 7b 7c 03 cmpl $0x3,0x7c(%ebx) 10b39d: 75 12 jne 10b3b1 (void) _Watchdog_Remove( &api->Sporadic_timer ); 10b39f: 83 ec 0c sub $0xc,%esp 10b3a2: 8d 83 9c 00 00 00 lea 0x9c(%ebx),%eax 10b3a8: 50 push %eax 10b3a9: e8 72 35 00 00 call 10e920 <_Watchdog_Remove> 10b3ae: 83 c4 10 add $0x10,%esp api->schedpolicy = policy; 10b3b1: 8b 55 0c mov 0xc(%ebp),%edx 10b3b4: 89 53 7c mov %edx,0x7c(%ebx) api->schedparam = *param; 10b3b7: 8d bb 80 00 00 00 lea 0x80(%ebx),%edi 10b3bd: b9 06 00 00 00 mov $0x6,%ecx 10b3c2: 8b 75 10 mov 0x10(%ebp),%esi 10b3c5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_thread->budget_algorithm = budget_algorithm; 10b3c7: 8b 55 dc mov -0x24(%ebp),%edx 10b3ca: 8b 45 d4 mov -0x2c(%ebp),%eax 10b3cd: 89 50 7c mov %edx,0x7c(%eax) the_thread->budget_callout = budget_callout; 10b3d0: 8b 75 e0 mov -0x20(%ebp),%esi 10b3d3: 89 b0 80 00 00 00 mov %esi,0x80(%eax) switch ( api->schedpolicy ) { 10b3d9: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10b3dd: 78 5d js 10b43c <== NEVER TAKEN 10b3df: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) 10b3e3: 7e 08 jle 10b3ed 10b3e5: 83 7d 0c 03 cmpl $0x3,0xc(%ebp) 10b3e9: 75 51 jne 10b43c <== NEVER TAKEN 10b3eb: eb 25 jmp 10b412 case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10b3ed: a1 34 2b 12 00 mov 0x122b34,%eax 10b3f2: 8b 55 d4 mov -0x2c(%ebp),%edx 10b3f5: 89 42 78 mov %eax,0x78(%edx) /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of 10b3f8: b8 ff 00 00 00 mov $0xff,%eax 10b3fd: 2b 83 80 00 00 00 sub 0x80(%ebx),%eax the_thread->real_priority = 10b403: 89 42 18 mov %eax,0x18(%edx) _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 10b406: 51 push %ecx 10b407: 6a 01 push $0x1 10b409: 50 push %eax 10b40a: 52 push %edx 10b40b: e8 74 20 00 00 call 10d484 <_Thread_Change_priority> 10b410: eb 27 jmp 10b439 TRUE ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 10b412: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 10b418: 89 83 98 00 00 00 mov %eax,0x98(%ebx) _Watchdog_Remove( &api->Sporadic_timer ); 10b41e: 83 ec 0c sub $0xc,%esp 10b421: 8d 83 9c 00 00 00 lea 0x9c(%ebx),%eax 10b427: 50 push %eax 10b428: e8 f3 34 00 00 call 10e920 <_Watchdog_Remove> _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 10b42d: 58 pop %eax 10b42e: 5a pop %edx 10b42f: ff 75 d4 pushl -0x2c(%ebp) 10b432: 6a 00 push $0x0 10b434: e8 e1 fd ff ff call 10b21a <_POSIX_Threads_Sporadic_budget_TSR> 10b439: 83 c4 10 add $0x10,%esp break; } _Thread_Enable_dispatch(); 10b43c: e8 e3 24 00 00 call 10d924 <_Thread_Enable_dispatch> 10b441: 31 c0 xor %eax,%eax 10b443: eb 05 jmp 10b44a return 0; 10b445: b8 16 00 00 00 mov $0x16,%eax case OBJECTS_ERROR: break; } return ESRCH; } 10b44a: 8d 65 f4 lea -0xc(%ebp),%esp 10b44d: 5b pop %ebx 10b44e: 5e pop %esi 10b44f: 5f pop %edi 10b450: c9 leave 10b451: c3 ret =============================================================================== 0010e898 : int pthread_sigmask( int how, const sigset_t *set, sigset_t *oset ) { 10e898: 55 push %ebp 10e899: 89 e5 mov %esp,%ebp 10e89b: 57 push %edi 10e89c: 56 push %esi 10e89d: 53 push %ebx 10e89e: 83 ec 0c sub $0xc,%esp 10e8a1: 8b 75 08 mov 0x8(%ebp),%esi 10e8a4: 8b 5d 0c mov 0xc(%ebp),%ebx 10e8a7: 8b 55 10 mov 0x10(%ebp),%edx POSIX_API_Control *api; if ( !set && !oset ) 10e8aa: 85 db test %ebx,%ebx 10e8ac: 0f 94 45 f3 sete -0xd(%ebp) 10e8b0: 75 04 jne 10e8b6 10e8b2: 85 d2 test %edx,%edx 10e8b4: 74 4e je 10e904 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10e8b6: 8b 3d b8 01 12 00 mov 0x1201b8,%edi 10e8bc: 8b 8f f8 00 00 00 mov 0xf8(%edi),%ecx if ( oset ) 10e8c2: 85 d2 test %edx,%edx 10e8c4: 74 08 je 10e8ce *oset = api->signals_blocked; 10e8c6: 8b 81 c4 00 00 00 mov 0xc4(%ecx),%eax 10e8cc: 89 02 mov %eax,(%edx) if ( !set ) 10e8ce: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) 10e8d2: 75 61 jne 10e935 <== NEVER TAKEN return 0; switch ( how ) { 10e8d4: 83 fe 01 cmp $0x1,%esi 10e8d7: 74 0b je 10e8e4 10e8d9: 83 fe 02 cmp $0x2,%esi 10e8dc: 74 10 je 10e8ee 10e8de: 85 f6 test %esi,%esi 10e8e0: 74 18 je 10e8fa 10e8e2: eb 20 jmp 10e904 case SIG_BLOCK: api->signals_blocked |= *set; 10e8e4: 8b 03 mov (%ebx),%eax 10e8e6: 09 81 c4 00 00 00 or %eax,0xc4(%ecx) 10e8ec: eb 26 jmp 10e914 break; case SIG_UNBLOCK: api->signals_blocked &= ~*set; 10e8ee: 8b 03 mov (%ebx),%eax 10e8f0: f7 d0 not %eax 10e8f2: 21 81 c4 00 00 00 and %eax,0xc4(%ecx) 10e8f8: eb 1a jmp 10e914 break; case SIG_SETMASK: api->signals_blocked = *set; 10e8fa: 8b 03 mov (%ebx),%eax 10e8fc: 89 81 c4 00 00 00 mov %eax,0xc4(%ecx) 10e902: eb 10 jmp 10e914 break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10e904: e8 07 16 00 00 call 10ff10 <__errno> 10e909: c7 00 16 00 00 00 movl $0x16,(%eax) 10e90f: 83 c8 ff or $0xffffffff,%eax 10e912: eb 23 jmp 10e937 /* XXX are there critical section problems here? */ /* XXX evaluate the new set */ if ( ~api->signals_blocked & 10e914: 8b 15 68 08 12 00 mov 0x120868,%edx 10e91a: 0b 91 c8 00 00 00 or 0xc8(%ecx),%edx 10e920: 8b 81 c4 00 00 00 mov 0xc4(%ecx),%eax 10e926: f7 d0 not %eax 10e928: 85 c2 test %eax,%edx 10e92a: 74 09 je 10e935 (api->signals_pending | _POSIX_signals_Pending) ) { _Thread_Executing->do_post_task_switch_extension = true; 10e92c: c6 47 75 01 movb $0x1,0x75(%edi) _Thread_Dispatch(); 10e930: e8 6b d2 ff ff call 10bba0 <_Thread_Dispatch> 10e935: 31 c0 xor %eax,%eax } return 0; } 10e937: 83 c4 0c add $0xc,%esp 10e93a: 5b pop %ebx 10e93b: 5e pop %esi 10e93c: 5f pop %edi 10e93d: c9 leave 10e93e: c3 ret =============================================================================== 001092ac : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 1092ac: 55 push %ebp 1092ad: 89 e5 mov %esp,%ebp 1092af: 53 push %ebx 1092b0: 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() ) 1092b3: a1 84 f5 11 00 mov 0x11f584,%eax 1092b8: 85 c0 test %eax,%eax 1092ba: 75 46 jne 109302 <== NEVER TAKEN return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 1092bc: a1 a8 f5 11 00 mov 0x11f5a8,%eax 1092c1: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx 1092c7: a1 e8 f4 11 00 mov 0x11f4e8,%eax 1092cc: 40 inc %eax 1092cd: a3 e8 f4 11 00 mov %eax,0x11f4e8 _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 1092d2: 31 db xor %ebx,%ebx 1092d4: 83 ba cc 00 00 00 00 cmpl $0x0,0xcc(%edx) 1092db: 75 0a jne 1092e7 <== NEVER TAKEN 1092dd: 83 ba d4 00 00 00 00 cmpl $0x0,0xd4(%edx) 1092e4: 0f 95 c3 setne %bl thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 1092e7: e8 e0 24 00 00 call 10b7cc <_Thread_Enable_dispatch> if ( cancel ) 1092ec: 84 db test %bl,%bl 1092ee: 74 12 je 109302 _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 1092f0: 50 push %eax 1092f1: 50 push %eax 1092f2: 6a ff push $0xffffffff 1092f4: ff 35 a8 f5 11 00 pushl 0x11f5a8 1092fa: e8 65 fa ff ff call 108d64 <_POSIX_Thread_Exit> 1092ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109302: 8b 5d fc mov -0x4(%ebp),%ebx 109305: c9 leave 109306: c3 ret =============================================================================== 0011575c : ssize_t read( int fd, void *buffer, size_t count ) { 11575c: 55 push %ebp 11575d: 89 e5 mov %esp,%ebp 11575f: 56 push %esi 115760: 53 push %ebx 115761: 8b 45 08 mov 0x8(%ebp),%eax 115764: 8b 75 0c mov 0xc(%ebp),%esi 115767: 8b 4d 10 mov 0x10(%ebp),%ecx ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11576a: 3b 05 d8 92 11 00 cmp 0x1192d8,%eax 115770: 73 2d jae 11579f <== NEVER TAKEN iop = rtems_libio_iop( fd ); 115772: 6b d8 34 imul $0x34,%eax,%ebx 115775: 03 1d 38 d6 11 00 add 0x11d638,%ebx rtems_libio_check_is_open( iop ); 11577b: 8b 53 0c mov 0xc(%ebx),%edx 11577e: f6 c6 01 test $0x1,%dh 115781: 74 1c je 11579f <== NEVER TAKEN rtems_libio_check_buffer( buffer ); 115783: 85 f6 test %esi,%esi 115785: 75 0d jne 115794 <== ALWAYS TAKEN 115787: e8 9c 99 ff ff call 10f128 <__errno> <== NOT EXECUTED 11578c: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 115792: eb 2d jmp 1157c1 <== NOT EXECUTED rtems_libio_check_count( count ); 115794: 31 c0 xor %eax,%eax 115796: 85 c9 test %ecx,%ecx 115798: 74 3c je 1157d6 <== NEVER TAKEN rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF ); 11579a: 80 e2 02 and $0x2,%dl 11579d: 75 0d jne 1157ac <== ALWAYS TAKEN 11579f: e8 84 99 ff ff call 10f128 <__errno> <== NOT EXECUTED 1157a4: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 1157aa: eb 15 jmp 1157c1 <== NOT EXECUTED /* * Now process the read(). */ if ( !iop->handlers->read_h ) 1157ac: 8b 43 30 mov 0x30(%ebx),%eax 1157af: 8b 40 08 mov 0x8(%eax),%eax 1157b2: 85 c0 test %eax,%eax 1157b4: 75 10 jne 1157c6 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); 1157b6: e8 6d 99 ff ff call 10f128 <__errno> <== NOT EXECUTED 1157bb: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1157c1: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1157c4: eb 10 jmp 1157d6 <== NOT EXECUTED rc = (*iop->handlers->read_h)( iop, buffer, count ); 1157c6: 52 push %edx 1157c7: 51 push %ecx 1157c8: 56 push %esi 1157c9: 53 push %ebx 1157ca: ff d0 call *%eax if ( rc > 0 ) 1157cc: 83 c4 10 add $0x10,%esp 1157cf: 85 c0 test %eax,%eax 1157d1: 7e 03 jle 1157d6 iop->offset += rc; 1157d3: 01 43 08 add %eax,0x8(%ebx) return rc; } 1157d6: 8d 65 f8 lea -0x8(%ebp),%esp 1157d9: 5b pop %ebx 1157da: 5e pop %esi 1157db: c9 leave 1157dc: c3 ret =============================================================================== 00108c94 : /* * get next entry in a directory. */ struct dirent * readdir( DIR *dirp ) { 108c94: 55 push %ebp 108c95: 89 e5 mov %esp,%ebp 108c97: 56 push %esi 108c98: 53 push %ebx 108c99: 8b 5d 08 mov 0x8(%ebp),%ebx register struct dirent *dp; if ( !dirp ) 108c9c: 85 db test %ebx,%ebx 108c9e: 74 5b je 108cfb <== NEVER TAKEN return NULL; for (;;) { if (dirp->dd_loc == 0) { 108ca0: 83 7b 04 00 cmpl $0x0,0x4(%ebx) 108ca4: 75 18 jne 108cbe dirp->dd_size = getdents (dirp->dd_fd, 108ca6: 50 push %eax 108ca7: ff 73 10 pushl 0x10(%ebx) 108caa: ff 73 0c pushl 0xc(%ebx) 108cad: ff 33 pushl (%ebx) 108caf: e8 18 63 00 00 call 10efcc 108cb4: 89 43 08 mov %eax,0x8(%ebx) dirp->dd_buf, dirp->dd_len); if (dirp->dd_size <= 0) 108cb7: 83 c4 10 add $0x10,%esp 108cba: 85 c0 test %eax,%eax 108cbc: 7e 3d jle 108cfb return NULL; } if (dirp->dd_loc >= dirp->dd_size) { 108cbe: 8b 4b 04 mov 0x4(%ebx),%ecx 108cc1: 3b 4b 08 cmp 0x8(%ebx),%ecx 108cc4: 7c 09 jl 108ccf dirp->dd_loc = 0; 108cc6: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) 108ccd: eb d1 jmp 108ca0 continue; } dp = (struct dirent *)(dirp->dd_buf + dirp->dd_loc); 108ccf: 89 ca mov %ecx,%edx 108cd1: 03 53 0c add 0xc(%ebx),%edx if ((intptr_t)dp & 03) /* bogus pointer check */ 108cd4: f6 c2 03 test $0x3,%dl 108cd7: 75 22 jne 108cfb <== NEVER TAKEN return NULL; if (dp->d_reclen <= 0 || 108cd9: 8b 42 08 mov 0x8(%edx),%eax 108cdc: 66 85 c0 test %ax,%ax 108cdf: 74 1a je 108cfb <== NEVER TAKEN 108ce1: 0f b7 f0 movzwl %ax,%esi 108ce4: 8b 43 10 mov 0x10(%ebx),%eax 108ce7: 40 inc %eax 108ce8: 29 c8 sub %ecx,%eax 108cea: 39 c6 cmp %eax,%esi 108cec: 7f 0d jg 108cfb <== NEVER TAKEN dp->d_reclen > dirp->dd_len + 1 - dirp->dd_loc) return NULL; dirp->dd_loc += dp->d_reclen; 108cee: 8d 04 0e lea (%esi,%ecx,1),%eax 108cf1: 89 43 04 mov %eax,0x4(%ebx) if (dp->d_ino == 0) 108cf4: 83 3a 00 cmpl $0x0,(%edx) 108cf7: 74 a7 je 108ca0 <== NEVER TAKEN 108cf9: eb 02 jmp 108cfd 108cfb: 31 d2 xor %edx,%edx continue; return (dp); } } 108cfd: 89 d0 mov %edx,%eax 108cff: 8d 65 f8 lea -0x8(%ebp),%esp 108d02: 5b pop %ebx 108d03: 5e pop %esi 108d04: c9 leave 108d05: c3 ret =============================================================================== 00109440 : ssize_t readlink( const char *pathname, char *buf, size_t bufsize ) { 109440: 55 push %ebp 109441: 89 e5 mov %esp,%ebp 109443: 57 push %edi 109444: 56 push %esi 109445: 53 push %ebx 109446: 83 ec 1c sub $0x1c,%esp 109449: 8b 7d 0c mov 0xc(%ebp),%edi rtems_filesystem_location_info_t loc; int result; if (!buf) 10944c: 85 ff test %edi,%edi 10944e: 75 0d jne 10945d <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EFAULT ); 109450: e8 1b 92 00 00 call 112670 <__errno> <== NOT EXECUTED 109455: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 10945b: eb 43 jmp 1094a0 <== NOT EXECUTED result = rtems_filesystem_evaluate_path( pathname, 0, &loc, false ); 10945d: 6a 00 push $0x0 10945f: 8d 75 e4 lea -0x1c(%ebp),%esi 109462: 56 push %esi 109463: 6a 00 push $0x0 109465: ff 75 08 pushl 0x8(%ebp) 109468: e8 3d ed ff ff call 1081aa if ( result != 0 ) 10946d: 83 c4 10 add $0x10,%esp 109470: 83 cb ff or $0xffffffff,%ebx 109473: 85 c0 test %eax,%eax 109475: 0f 85 87 00 00 00 jne 109502 <== NEVER TAKEN return -1; if ( !loc.ops->node_type_h ){ 10947b: 8b 45 ec mov -0x14(%ebp),%eax 10947e: 8b 50 10 mov 0x10(%eax),%edx 109481: 85 d2 test %edx,%edx 109483: 75 20 jne 1094a5 <== ALWAYS TAKEN rtems_filesystem_freenode( &loc ); 109485: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 109488: 85 c0 test %eax,%eax <== NOT EXECUTED 10948a: 74 09 je 109495 <== NOT EXECUTED 10948c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10948f: 56 push %esi <== NOT EXECUTED 109490: ff d0 call *%eax <== NOT EXECUTED 109492: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 109495: e8 d6 91 00 00 call 112670 <__errno> <== NOT EXECUTED 10949a: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1094a0: 83 cb ff or $0xffffffff,%ebx 1094a3: eb 5d jmp 109502 } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){ 1094a5: 83 ec 0c sub $0xc,%esp 1094a8: 56 push %esi 1094a9: ff d2 call *%edx 1094ab: 83 c4 10 add $0x10,%esp 1094ae: 83 f8 04 cmp $0x4,%eax 1094b1: 8b 45 ec mov -0x14(%ebp),%eax 1094b4: 74 21 je 1094d7 rtems_filesystem_freenode( &loc ); 1094b6: 85 c0 test %eax,%eax 1094b8: 74 10 je 1094ca <== NEVER TAKEN 1094ba: 8b 40 1c mov 0x1c(%eax),%eax 1094bd: 85 c0 test %eax,%eax 1094bf: 74 09 je 1094ca <== NEVER TAKEN 1094c1: 83 ec 0c sub $0xc,%esp 1094c4: 56 push %esi 1094c5: ff d0 call *%eax 1094c7: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EINVAL ); 1094ca: e8 a1 91 00 00 call 112670 <__errno> 1094cf: c7 00 16 00 00 00 movl $0x16,(%eax) 1094d5: eb c9 jmp 1094a0 } if ( !loc.ops->readlink_h ){ 1094d7: 8b 50 3c mov 0x3c(%eax),%edx 1094da: 85 d2 test %edx,%edx 1094dc: 74 a7 je 109485 <== NEVER TAKEN rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); 1094de: 50 push %eax 1094df: ff 75 10 pushl 0x10(%ebp) 1094e2: 57 push %edi 1094e3: 56 push %esi 1094e4: ff d2 call *%edx 1094e6: 89 c3 mov %eax,%ebx rtems_filesystem_freenode( &loc ); 1094e8: 8b 45 ec mov -0x14(%ebp),%eax 1094eb: 83 c4 10 add $0x10,%esp 1094ee: 85 c0 test %eax,%eax 1094f0: 74 10 je 109502 <== NEVER TAKEN 1094f2: 8b 40 1c mov 0x1c(%eax),%eax 1094f5: 85 c0 test %eax,%eax 1094f7: 74 09 je 109502 <== NEVER TAKEN 1094f9: 83 ec 0c sub $0xc,%esp 1094fc: 56 push %esi 1094fd: ff d0 call *%eax 1094ff: 83 c4 10 add $0x10,%esp return result; } 109502: 89 d8 mov %ebx,%eax 109504: 8d 65 f4 lea -0xc(%ebp),%esp 109507: 5b pop %ebx 109508: 5e pop %esi 109509: 5f pop %edi 10950a: c9 leave 10950b: c3 ret =============================================================================== 0011585c : { size_t old_size; char *new_area; size_t resize; MSBUMP(realloc_calls, 1); 11585c: 55 push %ebp 11585d: 89 e5 mov %esp,%ebp 11585f: 57 push %edi 115860: 56 push %esi 115861: 53 push %ebx 115862: 83 ec 1c sub $0x1c,%esp 115865: 8b 5d 0c mov 0xc(%ebp),%ebx 115868: ff 05 b8 d6 11 00 incl 0x11d6b8 /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 11586e: 83 3d 38 d9 11 00 03 cmpl $0x3,0x11d938 115875: 75 1a jne 115891 <== NEVER TAKEN if (_Thread_Dispatch_disable_level > 0) 115877: a1 98 d7 11 00 mov 0x11d798,%eax 11587c: 85 c0 test %eax,%eax 11587e: 0f 85 b7 00 00 00 jne 11593b <== NEVER TAKEN return (void *) 0; if (_ISR_Nest_level > 0) 115884: a1 34 d8 11 00 mov 0x11d834,%eax 115889: 85 c0 test %eax,%eax 11588b: 0f 85 aa 00 00 00 jne 11593b <== NEVER TAKEN } /* * Continue with realloc(). */ if ( !ptr ) 115891: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 115895: 75 0e jne 1158a5 <== ALWAYS TAKEN return malloc( size ); 115897: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11589a: 53 push %ebx <== NOT EXECUTED 11589b: e8 d4 0d ff ff call 106674 <== NOT EXECUTED 1158a0: e9 8e 00 00 00 jmp 115933 <== NOT EXECUTED if ( !size ) { 1158a5: 85 db test %ebx,%ebx 1158a7: 75 14 jne 1158bd <== ALWAYS TAKEN free( ptr ); 1158a9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1158ac: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1158af: e8 c4 0b ff ff call 106478 <== NOT EXECUTED 1158b4: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp) <== NOT EXECUTED 1158bb: eb 79 jmp 115936 <== NOT EXECUTED return (void *) 0; } if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) { 1158bd: 52 push %edx 1158be: 8d 45 f0 lea -0x10(%ebp),%eax 1158c1: 50 push %eax 1158c2: ff 75 08 pushl 0x8(%ebp) 1158c5: 68 50 d6 11 00 push $0x11d650 1158ca: e8 05 01 00 00 call 1159d4 <_Protected_heap_Get_block_size> 1158cf: 83 c4 10 add $0x10,%esp 1158d2: 84 c0 test %al,%al 1158d4: 75 0d jne 1158e3 errno = EINVAL; 1158d6: e8 4d 98 ff ff call 10f128 <__errno> 1158db: c7 00 16 00 00 00 movl $0x16,(%eax) 1158e1: eb 58 jmp 11593b #if defined(RTEMS_MALLOC_BOUNDARY_HELPERS) if (rtems_malloc_boundary_helpers) resize += (*rtems_malloc_boundary_helpers->overhead)(); #endif if ( _Protected_heap_Resize_block( &RTEMS_Malloc_Heap, ptr, resize ) ) { 1158e3: 50 push %eax 1158e4: 53 push %ebx 1158e5: ff 75 08 pushl 0x8(%ebp) 1158e8: 68 50 d6 11 00 push $0x11d650 1158ed: e8 1a 01 00 00 call 115a0c <_Protected_heap_Resize_block> 1158f2: 83 c4 10 add $0x10,%esp 1158f5: 84 c0 test %al,%al 1158f7: 75 49 jne 115942 * 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 ); 1158f9: 83 ec 0c sub $0xc,%esp 1158fc: 53 push %ebx 1158fd: e8 72 0d ff ff call 106674 115902: 89 45 d8 mov %eax,-0x28(%ebp) MSBUMP(malloc_calls, -1); /* subtract off the malloc */ 115905: ff 0d ac d6 11 00 decl 0x11d6ac if ( !new_area ) { 11590b: 83 c4 10 add $0x10,%esp 11590e: 85 c0 test %eax,%eax 115910: 74 29 je 11593b <== NEVER TAKEN return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 115912: 8b 45 f0 mov -0x10(%ebp),%eax 115915: 89 d9 mov %ebx,%ecx 115917: 39 c3 cmp %eax,%ebx 115919: 76 02 jbe 11591d <== NEVER TAKEN 11591b: 89 c1 mov %eax,%ecx 11591d: 8b 7d d8 mov -0x28(%ebp),%edi 115920: 8b 75 08 mov 0x8(%ebp),%esi 115923: f3 a4 rep movsb %ds:(%esi),%es:(%edi) free( ptr ); 115925: 83 ec 0c sub $0xc,%esp 115928: ff 75 08 pushl 0x8(%ebp) 11592b: e8 48 0b ff ff call 106478 115930: 8b 45 d8 mov -0x28(%ebp),%eax 115933: 89 45 08 mov %eax,0x8(%ebp) 115936: 83 c4 10 add $0x10,%esp 115939: eb 07 jmp 115942 return new_area; 11593b: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp) } 115942: 8b 45 08 mov 0x8(%ebp),%eax 115945: 8d 65 f4 lea -0xc(%ebp),%esp 115948: 5b pop %ebx 115949: 5e pop %esi 11594a: 5f pop %edi 11594b: c9 leave 11594c: c3 ret =============================================================================== 00108d08 : #include void rewinddir( DIR *dirp ) { 108d08: 55 push %ebp 108d09: 89 e5 mov %esp,%ebp 108d0b: 53 push %ebx 108d0c: 83 ec 04 sub $0x4,%esp 108d0f: 8b 5d 08 mov 0x8(%ebp),%ebx off_t status; if ( !dirp ) 108d12: 85 db test %ebx,%ebx 108d14: 74 19 je 108d2f return; status = lseek( dirp->dd_fd, 0, SEEK_SET ); 108d16: 50 push %eax 108d17: 6a 00 push $0x0 108d19: 6a 00 push $0x0 108d1b: ff 33 pushl (%ebx) 108d1d: e8 ba f0 ff ff call 107ddc if( status == -1 ) 108d22: 83 c4 10 add $0x10,%esp 108d25: 40 inc %eax 108d26: 74 07 je 108d2f <== NEVER TAKEN return; dirp->dd_loc = 0; 108d28: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) } 108d2f: 8b 5d fc mov -0x4(%ebp),%ebx 108d32: c9 leave 108d33: c3 ret =============================================================================== 0010960c : #include int rmdir( const char *pathname ) { 10960c: 55 push %ebp 10960d: 89 e5 mov %esp,%ebp 10960f: 56 push %esi 109610: 53 push %ebx 109611: 83 ec 10 sub $0x10,%esp /* * Get the node where we wish to go. */ result = rtems_filesystem_evaluate_path( pathname, 0, &loc, false ); 109614: 6a 00 push $0x0 109616: 8d 75 e8 lea -0x18(%ebp),%esi 109619: 56 push %esi 10961a: 6a 00 push $0x0 10961c: ff 75 08 pushl 0x8(%ebp) 10961f: e8 5a ec ff ff call 10827e if ( result != 0 ) 109624: 83 c4 10 add $0x10,%esp 109627: 85 c0 test %eax,%eax 109629: 0f 85 be 00 00 00 jne 1096ed return -1; result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc ); 10962f: 50 push %eax 109630: 50 push %eax 109631: 56 push %esi 109632: 6a 02 push $0x2 109634: e8 cf eb ff ff call 108208 if (result != 0) { 109639: 83 c4 10 add $0x10,%esp 10963c: 85 c0 test %eax,%eax 10963e: 8b 45 f0 mov -0x10(%ebp),%eax 109641: 74 21 je 109664 <== ALWAYS TAKEN rtems_filesystem_freenode( &loc ); 109643: 85 c0 test %eax,%eax <== NOT EXECUTED 109645: 0f 84 a2 00 00 00 je 1096ed <== NOT EXECUTED 10964b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10964e: 85 c0 test %eax,%eax <== NOT EXECUTED 109650: 0f 84 97 00 00 00 je 1096ed <== NOT EXECUTED 109656: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109659: 56 push %esi <== NOT EXECUTED 10965a: ff d0 call *%eax <== NOT EXECUTED 10965c: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 10965f: e9 84 00 00 00 jmp 1096e8 <== NOT EXECUTED /* * Verify you can remove this node as a directory. */ if ( !loc.ops->node_type_h ){ 109664: 8b 50 10 mov 0x10(%eax),%edx 109667: 85 d2 test %edx,%edx 109669: 74 41 je 1096ac <== NEVER TAKEN rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ){ 10966b: 83 ec 0c sub $0xc,%esp 10966e: 56 push %esi 10966f: ff d2 call *%edx 109671: 83 c4 10 add $0x10,%esp 109674: 48 dec %eax 109675: 74 24 je 10969b rtems_filesystem_freenode( &loc ); 109677: 8b 45 f0 mov -0x10(%ebp),%eax 10967a: 85 c0 test %eax,%eax 10967c: 74 10 je 10968e <== NEVER TAKEN 10967e: 8b 40 1c mov 0x1c(%eax),%eax 109681: 85 c0 test %eax,%eax 109683: 74 09 je 10968e <== NEVER TAKEN 109685: 83 ec 0c sub $0xc,%esp 109688: 56 push %esi 109689: ff d0 call *%eax 10968b: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( ENOTDIR ); 10968e: e8 65 8c 00 00 call 1122f8 <__errno> 109693: c7 00 14 00 00 00 movl $0x14,(%eax) 109699: eb 52 jmp 1096ed /* * Use the filesystems rmnod to remove the node. */ if ( !loc.handlers->rmnod_h ){ 10969b: 8b 45 ec mov -0x14(%ebp),%eax 10969e: 8b 40 34 mov 0x34(%eax),%eax 1096a1: 85 c0 test %eax,%eax 1096a3: 75 24 jne 1096c9 <== ALWAYS TAKEN rtems_filesystem_freenode( &loc ); 1096a5: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1096a8: 85 c0 test %eax,%eax <== NOT EXECUTED 1096aa: 74 10 je 1096bc <== NOT EXECUTED 1096ac: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1096af: 85 c0 test %eax,%eax <== NOT EXECUTED 1096b1: 74 09 je 1096bc <== NOT EXECUTED 1096b3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1096b6: 56 push %esi <== NOT EXECUTED 1096b7: ff d0 call *%eax <== NOT EXECUTED 1096b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1096bc: e8 37 8c 00 00 call 1122f8 <__errno> <== NOT EXECUTED 1096c1: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1096c7: eb 24 jmp 1096ed <== NOT EXECUTED } result = (*loc.handlers->rmnod_h)( &loc ); 1096c9: 83 ec 0c sub $0xc,%esp 1096cc: 56 push %esi 1096cd: ff d0 call *%eax 1096cf: 89 c3 mov %eax,%ebx rtems_filesystem_freenode( &loc ); 1096d1: 8b 45 f0 mov -0x10(%ebp),%eax 1096d4: 83 c4 10 add $0x10,%esp 1096d7: 85 c0 test %eax,%eax 1096d9: 74 15 je 1096f0 <== NEVER TAKEN 1096db: 8b 40 1c mov 0x1c(%eax),%eax 1096de: 85 c0 test %eax,%eax 1096e0: 74 0e je 1096f0 <== NEVER TAKEN 1096e2: 83 ec 0c sub $0xc,%esp 1096e5: 56 push %esi 1096e6: ff d0 call *%eax 1096e8: 83 c4 10 add $0x10,%esp 1096eb: eb 03 jmp 1096f0 1096ed: 83 cb ff or $0xffffffff,%ebx return result; } 1096f0: 89 d8 mov %ebx,%eax 1096f2: 8d 65 f8 lea -0x8(%ebp),%esp 1096f5: 5b pop %ebx 1096f6: 5e pop %esi 1096f7: c9 leave 1096f8: c3 ret =============================================================================== 0010ffd8 : const char * rtems_assoc_name_bad( uint32_t bad_value ) { 10ffd8: 55 push %ebp <== NOT EXECUTED 10ffd9: 89 e5 mov %esp,%ebp <== NOT EXECUTED sprintf(bad_buffer, "< %" PRId32 "[0x%" PRIx32 " ] >", bad_value, bad_value); #else static char bad_buffer[40] = ""; #endif return bad_buffer; } 10ffdb: b8 80 f4 11 00 mov $0x11f480,%eax <== NOT EXECUTED 10ffe0: c9 leave <== NOT EXECUTED 10ffe1: c3 ret <== NOT EXECUTED =============================================================================== 0010e288 : const char *rtems_assoc_name_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 10e288: 55 push %ebp <== NOT EXECUTED 10e289: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e28b: 53 push %ebx <== NOT EXECUTED 10e28c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e28f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 10e292: 53 push %ebx <== NOT EXECUTED 10e293: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10e296: e8 1d 00 00 00 call 10e2b8 <== NOT EXECUTED if (nap) 10e29b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e29e: 85 c0 test %eax,%eax <== NOT EXECUTED 10e2a0: 74 07 je 10e2a9 <== NOT EXECUTED return nap->name; 10e2a2: 8b 00 mov (%eax),%eax <== NOT EXECUTED return rtems_assoc_name_bad(local_value); } 10e2a4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e2a7: c9 leave <== NOT EXECUTED 10e2a8: c3 ret <== NOT EXECUTED nap = rtems_assoc_ptr_by_local(ap, local_value); if (nap) return nap->name; return rtems_assoc_name_bad(local_value); 10e2a9: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 10e2ac: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e2af: c9 leave <== NOT EXECUTED nap = rtems_assoc_ptr_by_local(ap, local_value); if (nap) return nap->name; return rtems_assoc_name_bad(local_value); 10e2b0: e9 23 1d 00 00 jmp 10ffd8 <== NOT EXECUTED =============================================================================== 0010f0a4 : const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 10f0a4: 55 push %ebp 10f0a5: 89 e5 mov %esp,%ebp 10f0a7: 56 push %esi 10f0a8: 53 push %ebx 10f0a9: 8b 5d 08 mov 0x8(%ebp),%ebx 10f0ac: 8b 75 0c mov 0xc(%ebp),%esi const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 10f0af: 8b 03 mov (%ebx),%eax 10f0b1: 85 c0 test %eax,%eax 10f0b3: 74 1b je 10f0d0 <== NEVER TAKEN 10f0b5: 52 push %edx 10f0b6: 52 push %edx 10f0b7: 68 09 7b 11 00 push $0x117b09 10f0bc: 50 push %eax 10f0bd: e8 62 11 00 00 call 110224 10f0c2: 83 c4 10 add $0x10,%esp 10f0c5: 85 c0 test %eax,%eax 10f0c7: 75 07 jne 10f0d0 <== ALWAYS TAKEN default_ap = ap++; 10f0c9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10f0cb: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 10f0ce: eb 0c jmp 10f0dc <== NOT EXECUTED 10f0d0: 31 c0 xor %eax,%eax 10f0d2: eb 08 jmp 10f0dc for ( ; ap->name; ap++) if (ap->local_value == local_value) 10f0d4: 39 73 04 cmp %esi,0x4(%ebx) 10f0d7: 74 0a je 10f0e3 const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 10f0d9: 83 c3 0c add $0xc,%ebx 10f0dc: 83 3b 00 cmpl $0x0,(%ebx) 10f0df: 75 f3 jne 10f0d4 10f0e1: 89 c3 mov %eax,%ebx if (ap->local_value == local_value) return ap; return default_ap; } 10f0e3: 89 d8 mov %ebx,%eax 10f0e5: 8d 65 f8 lea -0x8(%ebp),%esp 10f0e8: 5b pop %ebx 10f0e9: 5e pop %esi 10f0ea: c9 leave 10f0eb: c3 ret =============================================================================== 0010e970 : const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 10e970: 55 push %ebp 10e971: 89 e5 mov %esp,%ebp 10e973: 56 push %esi 10e974: 53 push %ebx 10e975: 8b 5d 08 mov 0x8(%ebp),%ebx 10e978: 8b 75 0c mov 0xc(%ebp),%esi const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 10e97b: 8b 03 mov (%ebx),%eax 10e97d: 85 c0 test %eax,%eax 10e97f: 74 1b je 10e99c <== NEVER TAKEN 10e981: 52 push %edx 10e982: 52 push %edx 10e983: 68 09 7b 11 00 push $0x117b09 10e988: 50 push %eax 10e989: e8 96 18 00 00 call 110224 10e98e: 83 c4 10 add $0x10,%esp 10e991: 85 c0 test %eax,%eax 10e993: 75 07 jne 10e99c <== ALWAYS TAKEN default_ap = ap++; 10e995: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e997: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 10e99a: eb 0c jmp 10e9a8 <== NOT EXECUTED 10e99c: 31 c0 xor %eax,%eax 10e99e: eb 08 jmp 10e9a8 for ( ; ap->name; ap++) if (ap->remote_value == remote_value) 10e9a0: 39 73 08 cmp %esi,0x8(%ebx) 10e9a3: 74 0a je 10e9af const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 10e9a5: 83 c3 0c add $0xc,%ebx 10e9a8: 83 3b 00 cmpl $0x0,(%ebx) 10e9ab: 75 f3 jne 10e9a0 10e9ad: 89 c3 mov %eax,%ebx if (ap->remote_value == remote_value) return ap; return default_ap; } 10e9af: 89 d8 mov %ebx,%eax 10e9b1: 8d 65 f8 lea -0x8(%ebp),%esp 10e9b4: 5b pop %ebx 10e9b5: 5e pop %esi 10e9b6: c9 leave 10e9b7: c3 ret =============================================================================== 0010e9b8 : uint32_t rtems_assoc_remote_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 10e9b8: 55 push %ebp <== NOT EXECUTED 10e9b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e9bb: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 10e9be: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10e9c1: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10e9c4: e8 db 06 00 00 call 10f0a4 <== NOT EXECUTED 10e9c9: 89 c2 mov %eax,%edx <== NOT EXECUTED if (nap) 10e9cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e9ce: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e9d0: 85 d2 test %edx,%edx <== NOT EXECUTED 10e9d2: 74 03 je 10e9d7 <== NOT EXECUTED return nap->remote_value; 10e9d4: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED return 0; } 10e9d7: c9 leave <== NOT EXECUTED 10e9d8: c3 ret <== NOT EXECUTED =============================================================================== 00109568 : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 109568: 55 push %ebp 109569: 89 e5 mov %esp,%ebp 10956b: 57 push %edi 10956c: 56 push %esi 10956d: 53 push %ebx 10956e: 83 ec 1c sub $0x1c,%esp 109571: 8b 75 0c mov 0xc(%ebp),%esi 109574: 8b 55 10 mov 0x10(%ebp),%edx 109577: 8b 7d 14 mov 0x14(%ebp),%edi Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 10957a: b8 03 00 00 00 mov $0x3,%eax 10957f: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 109583: 0f 84 90 00 00 00 je 109619 <== NEVER TAKEN return RTEMS_INVALID_NAME; if ( !id ) 109589: b8 09 00 00 00 mov $0x9,%eax 10958e: 85 ff test %edi,%edi 109590: 0f 84 83 00 00 00 je 109619 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 109596: f7 c6 10 00 00 00 test $0x10,%esi 10959c: 74 12 je 1095b0 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 10959e: b8 0a 00 00 00 mov $0xa,%eax 1095a3: 85 d2 test %edx,%edx 1095a5: 74 72 je 109619 if ( !id ) return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 1095a7: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) 1095ae: eb 07 jmp 1095b7 if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; 1095b0: c7 45 ec 01 00 00 00 movl $0x1,-0x14(%ebp) the_attributes.maximum_count = maximum_waiters; 1095b7: 89 55 f0 mov %edx,-0x10(%ebp) /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1095ba: a1 cc 12 12 00 mov 0x1212cc,%eax 1095bf: 40 inc %eax 1095c0: a3 cc 12 12 00 mov %eax,0x1212cc #ifdef __cplusplus extern "C" { #endif /** 1095c5: 83 ec 0c sub $0xc,%esp 1095c8: 68 d4 11 12 00 push $0x1211d4 1095cd: e8 62 1b 00 00 call 10b134 <_Objects_Allocate> 1095d2: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 1095d4: 83 c4 10 add $0x10,%esp 1095d7: 85 c0 test %eax,%eax 1095d9: 75 0c jne 1095e7 _Thread_Enable_dispatch(); 1095db: e8 58 27 00 00 call 10bd38 <_Thread_Enable_dispatch> 1095e0: b8 05 00 00 00 mov $0x5,%eax 1095e5: eb 32 jmp 109619 return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 1095e7: 89 70 10 mov %esi,0x10(%eax) _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 1095ea: 50 push %eax 1095eb: 50 push %eax 1095ec: 8d 45 ec lea -0x14(%ebp),%eax 1095ef: 50 push %eax 1095f0: 8d 43 14 lea 0x14(%ebx),%eax 1095f3: 50 push %eax 1095f4: e8 07 13 00 00 call 10a900 <_CORE_barrier_Initialize> 1095f9: 8b 4b 08 mov 0x8(%ebx),%ecx 1095fc: 0f b7 d1 movzwl %cx,%edx 1095ff: a1 f0 11 12 00 mov 0x1211f0,%eax 109604: 89 1c 90 mov %ebx,(%eax,%edx,4) 109607: 8b 45 08 mov 0x8(%ebp),%eax 10960a: 89 43 0c mov %eax,0xc(%ebx) &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 10960d: 89 0f mov %ecx,(%edi) _Thread_Enable_dispatch(); 10960f: e8 24 27 00 00 call 10bd38 <_Thread_Enable_dispatch> 109614: 31 c0 xor %eax,%eax 109616: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; } 109619: 8d 65 f4 lea -0xc(%ebp),%esp 10961c: 5b pop %ebx 10961d: 5e pop %esi 10961e: 5f pop %edi 10961f: c9 leave 109620: c3 ret =============================================================================== 001096a8 : rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 1096a8: 55 push %ebp 1096a9: 89 e5 mov %esp,%ebp 1096ab: 56 push %esi 1096ac: 53 push %ebx 1096ad: 83 ec 10 sub $0x10,%esp 1096b0: 8b 5d 08 mov 0x8(%ebp),%ebx 1096b3: 8b 75 0c mov 0xc(%ebp),%esi Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 1096b6: b8 09 00 00 00 mov $0x9,%eax 1096bb: 85 f6 test %esi,%esi 1096bd: 74 39 je 1096f8 <== NEVER TAKEN * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap 1096bf: 52 push %edx 1096c0: 8d 45 f4 lea -0xc(%ebp),%eax 1096c3: 50 push %eax 1096c4: 53 push %ebx 1096c5: 68 d4 11 12 00 push $0x1211d4 1096ca: e8 a9 1e 00 00 call 10b578 <_Objects_Get> 1096cf: 89 c2 mov %eax,%edx return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 1096d1: 83 c4 10 add $0x10,%esp 1096d4: b8 04 00 00 00 mov $0x4,%eax 1096d9: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 1096dd: 75 19 jne 1096f8 case OBJECTS_LOCAL: *released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL ); 1096df: 50 push %eax 1096e0: 6a 00 push $0x0 1096e2: 53 push %ebx 1096e3: 8d 42 14 lea 0x14(%edx),%eax 1096e6: 50 push %eax 1096e7: e8 48 12 00 00 call 10a934 <_CORE_barrier_Release> 1096ec: 89 06 mov %eax,(%esi) _Thread_Enable_dispatch(); 1096ee: e8 45 26 00 00 call 10bd38 <_Thread_Enable_dispatch> 1096f3: 31 c0 xor %eax,%eax 1096f5: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1096f8: 8d 65 f8 lea -0x8(%ebp),%esp 1096fb: 5b pop %ebx 1096fc: 5e pop %esi 1096fd: c9 leave 1096fe: c3 ret =============================================================================== 00108984 : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 108984: 55 push %ebp 108985: 89 e5 mov %esp,%ebp 108987: 53 push %ebx 108988: 83 ec 04 sub $0x4,%esp 10898b: 8b 55 08 mov 0x8(%ebp),%edx 10898e: 8b 5d 0c mov 0xc(%ebp),%ebx if ( !time_buffer ) 108991: b8 09 00 00 00 mov $0x9,%eax 108996: 85 db test %ebx,%ebx 108998: 74 44 je 1089de <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; switch ( option ) { 10899a: b8 0a 00 00 00 mov $0xa,%eax 10899f: 83 fa 04 cmp $0x4,%edx 1089a2: 77 3a ja 1089de 1089a4: ff 24 95 58 72 11 00 jmp *0x117258(,%edx,4) case RTEMS_CLOCK_GET_TOD: return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 1089ab: 89 5d 08 mov %ebx,0x8(%ebp) break; } return RTEMS_INVALID_NUMBER; } 1089ae: 58 pop %eax 1089af: 5b pop %ebx 1089b0: c9 leave if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; switch ( option ) { case RTEMS_CLOCK_GET_TOD: return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 1089b1: e9 76 00 00 00 jmp 108a2c case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH: return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); 1089b6: 89 5d 08 mov %ebx,0x8(%ebp) break; } return RTEMS_INVALID_NUMBER; } 1089b9: 5b pop %ebx 1089ba: 5b pop %ebx 1089bb: c9 leave switch ( option ) { case RTEMS_CLOCK_GET_TOD: return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH: return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); 1089bc: e9 23 00 00 00 jmp 1089e4 case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_since_boot(); 1089c1: e8 5a 00 00 00 call 108a20 1089c6: eb 05 jmp 1089cd return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_TICKS_PER_SECOND: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_per_second(); 1089c8: e8 3f 00 00 00 call 108a0c 1089cd: 89 03 mov %eax,(%ebx) 1089cf: 31 c0 xor %eax,%eax 1089d1: eb 0b jmp 1089de return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_TIME_VALUE: return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); 1089d3: 89 5d 08 mov %ebx,0x8(%ebp) break; } return RTEMS_INVALID_NUMBER; } 1089d6: 59 pop %ecx 1089d7: 5b pop %ebx 1089d8: c9 leave *interval = rtems_clock_get_ticks_per_second(); return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_TIME_VALUE: return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); 1089d9: e9 ea 00 00 00 jmp 108ac8 break; } return RTEMS_INVALID_NUMBER; } 1089de: 5a pop %edx 1089df: 5b pop %ebx 1089e0: c9 leave 1089e1: c3 ret =============================================================================== 001089e4 : #include rtems_status_code rtems_clock_get_seconds_since_epoch( rtems_interval *the_interval ) { 1089e4: 55 push %ebp 1089e5: 89 e5 mov %esp,%ebp 1089e7: 8b 55 08 mov 0x8(%ebp),%edx if ( !the_interval ) 1089ea: b8 09 00 00 00 mov $0x9,%eax 1089ef: 85 d2 test %edx,%edx 1089f1: 74 17 je 108a0a <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 1089f3: b8 0b 00 00 00 mov $0xb,%eax 1089f8: 80 3d ac d7 11 00 00 cmpb $0x0,0x11d7ac 1089ff: 74 09 je 108a0a return RTEMS_NOT_DEFINED; *the_interval = _TOD_Seconds_since_epoch; 108a01: a1 28 d8 11 00 mov 0x11d828,%eax 108a06: 89 02 mov %eax,(%edx) 108a08: 31 c0 xor %eax,%eax return RTEMS_SUCCESSFUL; } 108a0a: c9 leave 108a0b: c3 ret =============================================================================== 00108a2c : #include rtems_status_code rtems_clock_get_tod( rtems_time_of_day *time_buffer ) { 108a2c: 55 push %ebp 108a2d: 89 e5 mov %esp,%ebp 108a2f: 56 push %esi 108a30: 53 push %ebx 108a31: 83 ec 50 sub $0x50,%esp 108a34: 8b 75 08 mov 0x8(%ebp),%esi rtems_time_of_day *tmbuf = time_buffer; struct tm time; struct timeval now; if ( !time_buffer ) 108a37: b8 09 00 00 00 mov $0x9,%eax 108a3c: 85 f6 test %esi,%esi 108a3e: 74 7f je 108abf <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 108a40: b8 0b 00 00 00 mov $0xb,%eax 108a45: 80 3d ac d7 11 00 00 cmpb $0x0,0x11d7ac 108a4c: 74 71 je 108abf ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 108a4e: 9c pushf 108a4f: fa cli 108a50: 5b pop %ebx * This routine grows @a the_heap memory area using the size bytes which 108a51: 83 ec 0c sub $0xc,%esp 108a54: 8d 45 e8 lea -0x18(%ebp),%eax 108a57: 50 push %eax 108a58: e8 df 14 00 00 call 109f3c <_TOD_Get> * begin at @a starting_address. 108a5d: 53 push %ebx 108a5e: 9d popf * * @param[in] the_heap is the heap to operate upon 108a5f: 8b 45 e8 mov -0x18(%ebp),%eax 108a62: 89 45 f0 mov %eax,-0x10(%ebp) * @param[in] starting_address is the starting address of the memory 108a65: 8b 45 ec mov -0x14(%ebp),%eax 108a68: b9 e8 03 00 00 mov $0x3e8,%ecx 108a6d: 31 d2 xor %edx,%edx 108a6f: f7 f1 div %ecx 108a71: 89 45 f4 mov %eax,-0xc(%ebp) /* Obtain the current time */ _TOD_Get_timeval( &now ); /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); 108a74: 58 pop %eax 108a75: 5a pop %edx 108a76: 8d 45 c4 lea -0x3c(%ebp),%eax 108a79: 50 push %eax 108a7a: 8d 45 f0 lea -0x10(%ebp),%eax 108a7d: 50 push %eax 108a7e: e8 ed 6d 00 00 call 10f870 /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; 108a83: 8b 45 d8 mov -0x28(%ebp),%eax 108a86: 05 6c 07 00 00 add $0x76c,%eax 108a8b: 89 06 mov %eax,(%esi) tmbuf->month = time.tm_mon + 1; 108a8d: 8b 45 d4 mov -0x2c(%ebp),%eax 108a90: 40 inc %eax 108a91: 89 46 04 mov %eax,0x4(%esi) tmbuf->day = time.tm_mday; 108a94: 8b 45 d0 mov -0x30(%ebp),%eax 108a97: 89 46 08 mov %eax,0x8(%esi) tmbuf->hour = time.tm_hour; 108a9a: 8b 45 cc mov -0x34(%ebp),%eax 108a9d: 89 46 0c mov %eax,0xc(%esi) tmbuf->minute = time.tm_min; 108aa0: 8b 45 c8 mov -0x38(%ebp),%eax 108aa3: 89 46 10 mov %eax,0x10(%esi) tmbuf->second = time.tm_sec; 108aa6: 8b 45 c4 mov -0x3c(%ebp),%eax 108aa9: 89 46 14 mov %eax,0x14(%esi) tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 108aac: 8b 45 f4 mov -0xc(%ebp),%eax 108aaf: 31 d2 xor %edx,%edx 108ab1: f7 35 34 d9 11 00 divl 0x11d934 108ab7: 89 46 18 mov %eax,0x18(%esi) 108aba: 31 c0 xor %eax,%eax 108abc: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; } 108abf: 8d 65 f8 lea -0x8(%ebp),%esp 108ac2: 5b pop %ebx 108ac3: 5e pop %esi 108ac4: c9 leave 108ac5: c3 ret =============================================================================== 00108ac8 : #include rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { 108ac8: 55 push %ebp 108ac9: 89 e5 mov %esp,%ebp 108acb: 56 push %esi 108acc: 53 push %ebx 108acd: 83 ec 20 sub $0x20,%esp 108ad0: 8b 75 08 mov 0x8(%ebp),%esi if ( !time ) 108ad3: b8 09 00 00 00 mov $0x9,%eax 108ad8: 85 f6 test %esi,%esi 108ada: 74 38 je 108b14 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 108adc: b8 0b 00 00 00 mov $0xb,%eax 108ae1: 80 3d ac d7 11 00 00 cmpb $0x0,0x11d7ac 108ae8: 74 2a je 108b14 ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 108aea: 9c pushf 108aeb: fa cli 108aec: 5b pop %ebx * This routine grows @a the_heap memory area using the size bytes which 108aed: 83 ec 0c sub $0xc,%esp 108af0: 8d 45 f0 lea -0x10(%ebp),%eax 108af3: 50 push %eax 108af4: e8 43 14 00 00 call 109f3c <_TOD_Get> * begin at @a starting_address. 108af9: 53 push %ebx 108afa: 9d popf * * @param[in] the_heap is the heap to operate upon 108afb: 8b 45 f0 mov -0x10(%ebp),%eax 108afe: 89 06 mov %eax,(%esi) * @param[in] starting_address is the starting address of the memory 108b00: 8b 45 f4 mov -0xc(%ebp),%eax 108b03: b9 e8 03 00 00 mov $0x3e8,%ecx 108b08: 31 d2 xor %edx,%edx 108b0a: f7 f1 div %ecx 108b0c: 89 46 04 mov %eax,0x4(%esi) 108b0f: 31 c0 xor %eax,%eax 108b11: 83 c4 10 add $0x10,%esp return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); return RTEMS_SUCCESSFUL; } 108b14: 8d 65 f8 lea -0x8(%ebp),%esp 108b17: 5b pop %ebx 108b18: 5e pop %esi 108b19: c9 leave 108b1a: c3 ret =============================================================================== 00108cf4 : * error code - if unsuccessful */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { 108cf4: 55 push %ebp 108cf5: 89 e5 mov %esp,%ebp 108cf7: 83 ec 08 sub $0x8,%esp 108cfa: 8b 55 08 mov 0x8(%ebp),%edx if ( !uptime ) 108cfd: b8 09 00 00 00 mov $0x9,%eax 108d02: 85 d2 test %edx,%edx 108d04: 74 0e je 108d14 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime( uptime ); 108d06: 83 ec 0c sub $0xc,%esp 108d09: 52 push %edx 108d0a: e8 85 15 00 00 call 10a294 <_TOD_Get_uptime> 108d0f: 31 c0 xor %eax,%eax 108d11: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; } 108d14: c9 leave 108d15: c3 ret =============================================================================== 00109950 : */ rtems_status_code rtems_clock_set( rtems_time_of_day *time_buffer ) { 109950: 55 push %ebp 109951: 89 e5 mov %esp,%ebp 109953: 53 push %ebx 109954: 83 ec 14 sub $0x14,%esp 109957: 8b 5d 08 mov 0x8(%ebp),%ebx struct timespec newtime; if ( !time_buffer ) 10995a: ba 09 00 00 00 mov $0x9,%edx 10995f: 85 db test %ebx,%ebx 109961: 74 54 je 1099b7 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { 109963: 83 ec 0c sub $0xc,%esp 109966: 53 push %ebx 109967: e8 f8 00 00 00 call 109a64 <_TOD_Validate> 10996c: 83 c4 10 add $0x10,%esp 10996f: ba 14 00 00 00 mov $0x14,%edx 109974: 84 c0 test %al,%al 109976: 74 3f je 1099b7 newtime.tv_sec = _TOD_To_seconds( time_buffer ); 109978: 83 ec 0c sub $0xc,%esp 10997b: 53 push %ebx 10997c: e8 7b 00 00 00 call 1099fc <_TOD_To_seconds> 109981: 89 45 f4 mov %eax,-0xc(%ebp) newtime.tv_nsec = time_buffer->ticks * 109984: 8b 43 18 mov 0x18(%ebx),%eax 109987: 0f af 05 30 94 12 00 imul 0x129430,%eax 10998e: 69 c0 e8 03 00 00 imul $0x3e8,%eax,%eax 109994: 89 45 f8 mov %eax,-0x8(%ebp) /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109997: a1 94 92 12 00 mov 0x129294,%eax 10999c: 40 inc %eax 10999d: a3 94 92 12 00 mov %eax,0x129294 (_TOD_Microseconds_per_tick * TOD_NANOSECONDS_PER_MICROSECOND); _Thread_Disable_dispatch(); _TOD_Set( &newtime ); 1099a2: 8d 45 f4 lea -0xc(%ebp),%eax 1099a5: 89 04 24 mov %eax,(%esp) 1099a8: e8 13 18 00 00 call 10b1c0 <_TOD_Set> _Thread_Enable_dispatch(); 1099ad: e8 5a 28 00 00 call 10c20c <_Thread_Enable_dispatch> 1099b2: 31 d2 xor %edx,%edx 1099b4: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 1099b7: 89 d0 mov %edx,%eax 1099b9: 8b 5d fc mov -0x4(%ebp),%ebx 1099bc: c9 leave 1099bd: c3 ret =============================================================================== 00108b1c : * error code - if unsuccessful */ rtems_status_code rtems_clock_set_nanoseconds_extension( rtems_nanoseconds_extension_routine routine ) { 108b1c: 55 push %ebp 108b1d: 89 e5 mov %esp,%ebp 108b1f: 8b 55 08 mov 0x8(%ebp),%edx if ( !routine ) 108b22: b8 09 00 00 00 mov $0x9,%eax 108b27: 85 d2 test %edx,%edx 108b29: 74 08 je 108b33 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; _Watchdog_Nanoseconds_since_tick_handler = routine; 108b2b: 89 15 3c d9 11 00 mov %edx,0x11d93c 108b31: 31 c0 xor %eax,%eax return RTEMS_SUCCESSFUL; } 108b33: c9 leave 108b34: c3 ret =============================================================================== 00106b88 : void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) { 106b88: 55 push %ebp 106b89: 89 e5 mov %esp,%ebp 106b8b: 57 push %edi 106b8c: 56 push %esi 106b8d: 53 push %ebx 106b8e: 83 ec 4c sub $0x4c,%esp struct timespec uptime, total, ran; #else uint32_t total_units = 0; #endif if ( !print ) 106b91: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 106b95: 0f 84 43 01 00 00 je 106cde <== 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. */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _TOD_Get_uptime( &uptime ); 106b9b: 83 ec 0c sub $0xc,%esp 106b9e: 8d 5d e4 lea -0x1c(%ebp),%ebx 106ba1: 53 push %ebx 106ba2: e8 89 45 00 00 call 10b130 <_TOD_Get_uptime> _Timespec_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total ); 106ba7: 83 c4 0c add $0xc,%esp 106baa: 8d 45 dc lea -0x24(%ebp),%eax 106bad: 50 push %eax 106bae: 53 push %ebx 106baf: 68 2c 98 12 00 push $0x12982c 106bb4: e8 07 64 00 00 call 10cfc0 <_Timespec_Subtract> } } } #endif (*print)( context, "CPU Usage by thread\n" 106bb9: 58 pop %eax 106bba: 5a pop %edx 106bbb: 68 2a a1 11 00 push $0x11a12a 106bc0: ff 75 08 pushl 0x8(%ebp) 106bc3: ff 55 0c call *0xc(%ebp) 106bc6: bf 01 00 00 00 mov $0x1,%edi 106bcb: 83 c4 10 add $0x10,%esp ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 106bce: 8b 04 bd 68 92 12 00 mov 0x129268(,%edi,4),%eax 106bd5: 85 c0 test %eax,%eax 106bd7: 0f 84 d9 00 00 00 je 106cb6 continue; information = _Objects_Information_table[ api_index ][ 1 ]; 106bdd: 8b 40 04 mov 0x4(%eax),%eax 106be0: 89 45 b0 mov %eax,-0x50(%ebp) if ( information ) { 106be3: be 01 00 00 00 mov $0x1,%esi 106be8: 85 c0 test %eax,%eax 106bea: 0f 85 b7 00 00 00 jne 106ca7 <== ALWAYS TAKEN 106bf0: e9 c1 00 00 00 jmp 106cb6 <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 106bf5: 8b 55 b0 mov -0x50(%ebp),%edx 106bf8: 8b 42 1c mov 0x1c(%edx),%eax 106bfb: 8b 1c b0 mov (%eax,%esi,4),%ebx if ( !the_thread ) 106bfe: 85 db test %ebx,%ebx 106c00: 0f 84 a0 00 00 00 je 106ca6 <== NEVER TAKEN continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 106c06: 50 push %eax 106c07: 8d 45 bf lea -0x41(%ebp),%eax 106c0a: 50 push %eax 106c0b: 6a 0d push $0xd 106c0d: ff 73 08 pushl 0x8(%ebx) 106c10: e8 8f 32 00 00 call 109ea4 (*print)( 106c15: 8d 55 bf lea -0x41(%ebp),%edx 106c18: 52 push %edx 106c19: ff 73 08 pushl 0x8(%ebx) 106c1c: 68 6f a1 11 00 push $0x11a16f 106c21: ff 75 08 pushl 0x8(%ebp) 106c24: ff 55 0c call *0xc(%ebp) #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS /* * If this is the currently executing thread, account for time * since the last context switch. */ ran = the_thread->cpu_time_used; 106c27: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx 106c2d: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 106c33: 89 45 d8 mov %eax,-0x28(%ebp) 106c36: 89 55 d4 mov %edx,-0x2c(%ebp) if ( _Thread_Executing->Object.id == the_thread->Object.id ) { 106c39: 83 c4 20 add $0x20,%esp 106c3c: a1 54 93 12 00 mov 0x129354,%eax 106c41: 8b 40 08 mov 0x8(%eax),%eax 106c44: 3b 43 08 cmp 0x8(%ebx),%eax 106c47: 75 22 jne 106c6b struct timespec used; _Timespec_Subtract( 106c49: 50 push %eax 106c4a: 8d 5d cc lea -0x34(%ebp),%ebx 106c4d: 53 push %ebx 106c4e: 8d 45 e4 lea -0x1c(%ebp),%eax 106c51: 50 push %eax 106c52: 68 5c 93 12 00 push $0x12935c 106c57: e8 64 63 00 00 call 10cfc0 <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &used ); _Timespec_Add_to( &ran, &used ); 106c5c: 59 pop %ecx 106c5d: 58 pop %eax 106c5e: 53 push %ebx 106c5f: 8d 45 d4 lea -0x2c(%ebp),%eax 106c62: 50 push %eax 106c63: e8 6c 62 00 00 call 10ced4 <_Timespec_Add_to> 106c68: 83 c4 10 add $0x10,%esp }; _Timespec_Divide( &ran, &total, &ival, &fval ); 106c6b: 8d 45 ec lea -0x14(%ebp),%eax 106c6e: 50 push %eax 106c6f: 8d 45 f0 lea -0x10(%ebp),%eax 106c72: 50 push %eax 106c73: 8d 45 dc lea -0x24(%ebp),%eax 106c76: 50 push %eax 106c77: 8d 45 d4 lea -0x2c(%ebp),%eax 106c7a: 50 push %eax 106c7b: e8 84 62 00 00 call 10cf04 <_Timespec_Divide> /* * Print the information */ (*print)( context, 106c80: 58 pop %eax 106c81: 5a pop %edx 106c82: ff 75 ec pushl -0x14(%ebp) 106c85: ff 75 f0 pushl -0x10(%ebp) 106c88: 8b 45 d8 mov -0x28(%ebp),%eax 106c8b: b9 e8 03 00 00 mov $0x3e8,%ecx 106c90: 31 d2 xor %edx,%edx 106c92: f7 f1 div %ecx 106c94: 50 push %eax 106c95: ff 75 d4 pushl -0x2c(%ebp) 106c98: 68 82 a1 11 00 push $0x11a182 106c9d: ff 75 08 pushl 0x8(%ebp) 106ca0: ff 55 0c call *0xc(%ebp) 106ca3: 83 c4 20 add $0x20,%esp api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 106ca6: 46 inc %esi 106ca7: 8b 55 b0 mov -0x50(%ebp),%edx 106caa: 0f b7 42 10 movzwl 0x10(%edx),%eax 106cae: 39 c6 cmp %eax,%esi 106cb0: 0f 86 3f ff ff ff jbe 106bf5 #endif ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 106cb6: 47 inc %edi " ID NAME TICKS PERCENT\n" #endif ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 106cb7: 83 ff 05 cmp $0x5,%edi 106cba: 0f 85 0e ff ff ff jne 106bce } } } #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS (*print)( context, "Time since last CPU Usage reset %" PRId32 106cc0: 8b 45 e0 mov -0x20(%ebp),%eax 106cc3: b9 e8 03 00 00 mov $0x3e8,%ecx 106cc8: 31 d2 xor %edx,%edx 106cca: f7 f1 div %ecx 106ccc: 50 push %eax 106ccd: ff 75 dc pushl -0x24(%ebp) 106cd0: 68 9a a1 11 00 push $0x11a19a 106cd5: ff 75 08 pushl 0x8(%ebp) 106cd8: ff 55 0c call *0xc(%ebp) 106cdb: 83 c4 10 add $0x10,%esp "Ticks since last reset = %" PRId32 "\n", _Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset ); (*print)( context, "Total Units = %" PRId32 "\n", total_units ); #endif } 106cde: 8d 65 f4 lea -0xc(%ebp),%esp 106ce1: 5b pop %ebx 106ce2: 5e pop %esi 106ce3: 5f pop %edi 106ce4: c9 leave 106ce5: c3 ret =============================================================================== 0010e5eb : { 0, 0, 0 }, }; static int rtems_deviceio_errno(rtems_status_code code) { 10e5eb: 55 push %ebp <== NOT EXECUTED 10e5ec: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e5ee: 53 push %ebx <== NOT EXECUTED 10e5ef: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED int rc; if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t) code))) 10e5f2: 50 push %eax <== NOT EXECUTED 10e5f3: 68 dc 79 11 00 push $0x1179dc <== NOT EXECUTED 10e5f8: e8 bb 03 00 00 call 10e9b8 <== NOT EXECUTED 10e5fd: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10e5ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e602: 85 c0 test %eax,%eax <== NOT EXECUTED 10e604: 74 07 je 10e60d <== NOT EXECUTED { errno = rc; 10e606: e8 1d 0b 00 00 call 10f128 <__errno> <== NOT EXECUTED 10e60b: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return -1; } return -1; } 10e60d: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10e610: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e613: c9 leave <== NOT EXECUTED 10e614: c3 ret <== NOT EXECUTED =============================================================================== 00107040 : int rtems_error( int error_flag, const char *printf_format, ... ) { 107040: 55 push %ebp <== NOT EXECUTED 107041: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107043: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107046: 8d 4d 10 lea 0x10(%ebp),%ecx <== NOT EXECUTED va_list arglist; int chars_written; va_start(arglist, printf_format); chars_written = rtems_verror(error_flag, printf_format, arglist); 107049: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10704c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10704f: e8 6d fe ff ff call 106ec1 <== NOT EXECUTED va_end(arglist); return chars_written; } 107054: c9 leave <== NOT EXECUTED 107055: c3 ret <== NOT EXECUTED =============================================================================== 00108b74 : rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 108b74: 55 push %ebp 108b75: 89 e5 mov %esp,%ebp 108b77: 83 ec 08 sub $0x8,%esp 108b7a: 8b 4d 08 mov 0x8(%ebp),%ecx 108b7d: 8b 55 14 mov 0x14(%ebp),%edx RTEMS_API_Control *api; if ( !event_out ) 108b80: b8 09 00 00 00 mov $0x9,%eax 108b85: 85 d2 test %edx,%edx 108b87: 74 3f je 108bc8 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; 108b89: a1 58 d8 11 00 mov 0x11d858,%eax 108b8e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax if ( _Event_sets_Is_empty( event_in ) ) { 108b94: 85 c9 test %ecx,%ecx 108b96: 75 08 jne 108ba0 *event_out = api->pending_events; 108b98: 8b 00 mov (%eax),%eax 108b9a: 89 02 mov %eax,(%edx) 108b9c: 31 c0 xor %eax,%eax 108b9e: eb 28 jmp 108bc8 /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 108ba0: a1 98 d7 11 00 mov 0x11d798,%eax 108ba5: 40 inc %eax 108ba6: a3 98 d7 11 00 mov %eax,0x11d798 return RTEMS_SUCCESSFUL; } _Thread_Disable_dispatch(); _Event_Seize( event_in, option_set, ticks, event_out ); 108bab: 52 push %edx 108bac: ff 75 10 pushl 0x10(%ebp) 108baf: ff 75 0c pushl 0xc(%ebp) 108bb2: 51 push %ecx 108bb3: e8 14 00 00 00 call 108bcc <_Event_Seize> _Thread_Enable_dispatch(); 108bb8: e8 cf 22 00 00 call 10ae8c <_Thread_Enable_dispatch> return( _Thread_Executing->Wait.return_code ); 108bbd: a1 58 d8 11 00 mov 0x11d858,%eax 108bc2: 8b 40 34 mov 0x34(%eax),%eax 108bc5: 83 c4 10 add $0x10,%esp } 108bc8: c9 leave 108bc9: c3 ret =============================================================================== 001062e0 : int rtems_filesystem_evaluate_parent( int flags, rtems_filesystem_location_info_t *pathloc ) { 1062e0: 55 push %ebp 1062e1: 89 e5 mov %esp,%ebp 1062e3: 57 push %edi 1062e4: 56 push %esi 1062e5: 83 ec 10 sub $0x10,%esp 1062e8: 8b 75 0c mov 0xc(%ebp),%esi rtems_filesystem_location_info_t parent; int result; if ( !pathloc ) 1062eb: 85 f6 test %esi,%esi 1062ed: 75 0d jne 1062fc <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */ 1062ef: e8 34 8e 00 00 call 10f128 <__errno> <== NOT EXECUTED 1062f4: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 1062fa: eb 13 jmp 10630f <== NOT EXECUTED if ( !pathloc->ops->evalpath_h ) 1062fc: 8b 46 08 mov 0x8(%esi),%eax 1062ff: 83 38 00 cmpl $0x0,(%eax) 106302: 75 10 jne 106314 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); 106304: e8 1f 8e 00 00 call 10f128 <__errno> <== NOT EXECUTED 106309: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10630f: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED 106312: eb 39 jmp 10634d <== NOT EXECUTED parent = *pathloc; 106314: 8d 7d e8 lea -0x18(%ebp),%edi 106317: b9 04 00 00 00 mov $0x4,%ecx 10631c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) result = (*pathloc->ops->evalpath_h)( "..", flags, &parent ); 10631e: 52 push %edx 10631f: 8d 75 e8 lea -0x18(%ebp),%esi 106322: 56 push %esi 106323: ff 75 08 pushl 0x8(%ebp) 106326: 68 f9 71 11 00 push $0x1171f9 10632b: ff 10 call *(%eax) 10632d: 89 c7 mov %eax,%edi if (result != 0){ 10632f: 83 c4 10 add $0x10,%esp 106332: 85 c0 test %eax,%eax 106334: 75 d9 jne 10630f <== NEVER TAKEN return -1; } rtems_filesystem_freenode( &parent ); 106336: 8b 45 f0 mov -0x10(%ebp),%eax 106339: 85 c0 test %eax,%eax 10633b: 74 10 je 10634d <== NEVER TAKEN 10633d: 8b 40 1c mov 0x1c(%eax),%eax 106340: 85 c0 test %eax,%eax 106342: 74 09 je 10634d <== NEVER TAKEN 106344: 83 ec 0c sub $0xc,%esp 106347: 56 push %esi 106348: ff d0 call *%eax 10634a: 83 c4 10 add $0x10,%esp return result; } 10634d: 89 f8 mov %edi,%eax 10634f: 8d 65 f8 lea -0x8(%ebp),%esp 106352: 5e pop %esi 106353: 5f pop %edi 106354: c9 leave 106355: c3 ret =============================================================================== 00106356 : const char *pathname, int flags, rtems_filesystem_location_info_t *pathloc, int follow_link ) { 106356: 55 push %ebp 106357: 89 e5 mov %esp,%ebp 106359: 57 push %edi 10635a: 56 push %esi 10635b: 53 push %ebx 10635c: 83 ec 1c sub $0x1c,%esp 10635f: 8b 5d 08 mov 0x8(%ebp),%ebx 106362: 8b 45 0c mov 0xc(%ebp),%eax 106365: 89 45 f0 mov %eax,-0x10(%ebp) 106368: 8b 55 10 mov 0x10(%ebp),%edx 10636b: 89 55 e0 mov %edx,-0x20(%ebp) 10636e: 8b 7d 14 mov 0x14(%ebp),%edi 106371: 89 7d ec mov %edi,-0x14(%ebp) /* * Verify Input parameters. */ if ( !pathname ) 106374: 85 db test %ebx,%ebx 106376: 75 0d jne 106385 rtems_set_errno_and_return_minus_one( EFAULT ); 106378: e8 ab 8d 00 00 call 10f128 <__errno> 10637d: c7 00 0e 00 00 00 movl $0xe,(%eax) 106383: eb 11 jmp 106396 if ( !pathloc ) 106385: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) 106389: 75 13 jne 10639e <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */ 10638b: e8 98 8d 00 00 call 10f128 <__errno> <== NOT EXECUTED 106390: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 106396: 83 ce ff or $0xffffffff,%esi 106399: e9 cd 00 00 00 jmp 10646b /* * Evaluate the path using the optable evalpath. */ rtems_filesystem_get_start_loc( pathname, &i, pathloc ); 10639e: 8a 03 mov (%ebx),%al 1063a0: 3c 2f cmp $0x2f,%al 1063a2: 74 08 je 1063ac 1063a4: 3c 5c cmp $0x5c,%al 1063a6: 74 04 je 1063ac <== NEVER TAKEN 1063a8: 84 c0 test %al,%al 1063aa: 75 16 jne 1063c2 <== ALWAYS TAKEN 1063ac: a1 6c b6 11 00 mov 0x11b66c,%eax 1063b1: 8d 70 14 lea 0x14(%eax),%esi 1063b4: b9 04 00 00 00 mov $0x4,%ecx 1063b9: 8b 7d e0 mov -0x20(%ebp),%edi 1063bc: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 1063be: b1 01 mov $0x1,%cl 1063c0: eb 12 jmp 1063d4 1063c2: a1 6c b6 11 00 mov 0x11b66c,%eax 1063c7: 8d 70 04 lea 0x4(%eax),%esi 1063ca: b9 04 00 00 00 mov $0x4,%ecx 1063cf: 8b 7d e0 mov -0x20(%ebp),%edi 1063d2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !pathloc->ops->evalpath_h ) 1063d4: 8b 55 e0 mov -0x20(%ebp),%edx 1063d7: 8b 42 08 mov 0x8(%edx),%eax 1063da: 8b 10 mov (%eax),%edx 1063dc: 85 d2 test %edx,%edx 1063de: 74 66 je 106446 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); result = (*pathloc->ops->evalpath_h)( &pathname[i], flags, pathloc ); 1063e0: 56 push %esi 1063e1: ff 75 e0 pushl -0x20(%ebp) 1063e4: ff 75 f0 pushl -0x10(%ebp) 1063e7: 8d 04 0b lea (%ebx,%ecx,1),%eax 1063ea: 50 push %eax 1063eb: ff d2 call *%edx 1063ed: 89 c6 mov %eax,%esi /* * Get the Node type and determine if you need to follow the link or * not. */ if ( (result == 0) && follow_link ) { 1063ef: 83 c4 10 add $0x10,%esp 1063f2: 85 c0 test %eax,%eax 1063f4: 75 75 jne 10646b 1063f6: 83 7d ec 00 cmpl $0x0,-0x14(%ebp) 1063fa: 74 6f je 10646b if ( !pathloc->ops->node_type_h ){ 1063fc: 8b 7d e0 mov -0x20(%ebp),%edi 1063ff: 8b 47 08 mov 0x8(%edi),%eax 106402: 8b 50 10 mov 0x10(%eax),%edx 106405: 85 d2 test %edx,%edx 106407: 75 0d jne 106416 <== ALWAYS TAKEN rtems_filesystem_freenode( pathloc ); 106409: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10640c: 85 c0 test %eax,%eax <== NOT EXECUTED 10640e: 74 36 je 106446 <== NOT EXECUTED 106410: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106413: 57 push %edi <== NOT EXECUTED 106414: eb 2b jmp 106441 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } type = (*pathloc->ops->node_type_h)( pathloc ); 106416: 83 ec 0c sub $0xc,%esp 106419: ff 75 e0 pushl -0x20(%ebp) 10641c: ff d2 call *%edx if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) || 10641e: 83 e8 03 sub $0x3,%eax 106421: 83 c4 10 add $0x10,%esp 106424: 83 f8 01 cmp $0x1,%eax 106427: 77 42 ja 10646b ( type == RTEMS_FILESYSTEM_SYM_LINK ) ) { if ( !pathloc->ops->eval_link_h ){ 106429: 8b 55 e0 mov -0x20(%ebp),%edx 10642c: 8b 42 08 mov 0x8(%edx),%eax 10642f: 8b 48 34 mov 0x34(%eax),%ecx 106432: 85 c9 test %ecx,%ecx 106434: 75 20 jne 106456 <== ALWAYS TAKEN rtems_filesystem_freenode( pathloc ); 106436: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 106439: 85 c0 test %eax,%eax <== NOT EXECUTED 10643b: 74 09 je 106446 <== NOT EXECUTED 10643d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106440: 52 push %edx <== NOT EXECUTED 106441: ff d0 call *%eax <== NOT EXECUTED 106443: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 106446: e8 dd 8c 00 00 call 10f128 <__errno> <== NOT EXECUTED 10644b: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 106451: e9 40 ff ff ff jmp 106396 <== NOT EXECUTED * pathloc will be passed up (and eventually released). * Hence, the (valid) originial node that we submit to * eval_link_h() should be released by the handler. */ result = (*pathloc->ops->eval_link_h)( pathloc, flags ); 106456: 8b 7d f0 mov -0x10(%ebp),%edi 106459: 89 7d 0c mov %edi,0xc(%ebp) 10645c: 8b 45 e0 mov -0x20(%ebp),%eax 10645f: 89 45 08 mov %eax,0x8(%ebp) } } return result; } 106462: 8d 65 f4 lea -0xc(%ebp),%esp 106465: 5b pop %ebx 106466: 5e pop %esi 106467: 5f pop %edi 106468: c9 leave * pathloc will be passed up (and eventually released). * Hence, the (valid) originial node that we submit to * eval_link_h() should be released by the handler. */ result = (*pathloc->ops->eval_link_h)( pathloc, flags ); 106469: ff e1 jmp *%ecx } } return result; } 10646b: 89 f0 mov %esi,%eax 10646d: 8d 65 f4 lea -0xc(%ebp),%esp 106470: 5b pop %ebx 106471: 5e pop %esi 106472: 5f pop %edi 106473: c9 leave 106474: c3 ret =============================================================================== 0010cbe8 : * configuration is a single instantiation of the IMFS or miniIMFS with * a single "/dev" directory in it. */ void rtems_filesystem_initialize( void ) { 10cbe8: 55 push %ebp 10cbe9: 89 e5 mov %esp,%ebp 10cbeb: 57 push %edi 10cbec: 56 push %esi 10cbed: 53 push %ebx 10cbee: 83 ec 2c sub $0x2c,%esp /* * Set the default umask to "022". */ rtems_filesystem_umask = 022; 10cbf1: a1 6c b6 11 00 mov 0x11b66c,%eax 10cbf6: c7 40 24 12 00 00 00 movl $0x12,0x24(%eax) init_fs_mount_table(); 10cbfd: e8 f2 04 00 00 call 10d0f4 /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) 10cc02: 83 3d e8 5e 11 00 00 cmpl $0x0,0x115ee8 10cc09: 75 0a jne 10cc15 <== ALWAYS TAKEN rtems_fatal_error_occurred( 0xABCD0001 ); 10cc0b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cc0e: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED 10cc13: eb 2a jmp 10cc3f <== NOT EXECUTED mt = &rtems_filesystem_mount_table[0]; 10cc15: a1 e0 92 11 00 mov 0x1192e0,%eax status = mount( 10cc1a: 83 ec 0c sub $0xc,%esp 10cc1d: ff 70 0c pushl 0xc(%eax) 10cc20: ff 70 08 pushl 0x8(%eax) 10cc23: ff 70 04 pushl 0x4(%eax) 10cc26: ff 30 pushl (%eax) 10cc28: 8d 45 f0 lea -0x10(%ebp),%eax 10cc2b: 50 push %eax 10cc2c: e8 e8 04 00 00 call 10d119 &entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point ); if ( status == -1 ) 10cc31: 83 c4 20 add $0x20,%esp 10cc34: 40 inc %eax 10cc35: 75 0d jne 10cc44 <== ALWAYS TAKEN rtems_fatal_error_occurred( 0xABCD0002 ); 10cc37: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cc3a: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED 10cc3f: e8 50 cb ff ff call 109794 <== NOT EXECUTED rtems_filesystem_link_counts = 0; 10cc44: a1 6c b6 11 00 mov 0x11b66c,%eax 10cc49: 66 c7 40 28 00 00 movw $0x0,0x28(%eax) * set_private_env() - but then: that's * gonna hit performance. * * Till Straumann, 10/25/2002 */ rtems_filesystem_root = entry->mt_fs_root; 10cc4f: 8d 78 14 lea 0x14(%eax),%edi 10cc52: 8b 45 f0 mov -0x10(%ebp),%eax 10cc55: 8d 70 18 lea 0x18(%eax),%esi 10cc58: b9 04 00 00 00 mov $0x4,%ecx 10cc5d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 10cc5f: 6a 00 push $0x0 10cc61: 8d 5d e0 lea -0x20(%ebp),%ebx 10cc64: 53 push %ebx 10cc65: 6a 00 push $0x0 10cc67: 68 28 77 11 00 push $0x117728 10cc6c: e8 e5 96 ff ff call 106356 rtems_filesystem_root = loc; 10cc71: a1 6c b6 11 00 mov 0x11b66c,%eax 10cc76: 8d 78 14 lea 0x14(%eax),%edi 10cc79: b9 04 00 00 00 mov $0x4,%ecx 10cc7e: 89 de mov %ebx,%esi 10cc80: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 10cc82: 6a 00 push $0x0 10cc84: 53 push %ebx 10cc85: 6a 00 push $0x0 10cc87: 68 28 77 11 00 push $0x117728 10cc8c: e8 c5 96 ff ff call 106356 rtems_filesystem_current = loc; 10cc91: a1 6c b6 11 00 mov 0x11b66c,%eax 10cc96: 8d 78 04 lea 0x4(%eax),%edi 10cc99: b9 04 00 00 00 mov $0x4,%ecx 10cc9e: 89 de mov %ebx,%esi 10cca0: 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); 10cca2: 83 c4 18 add $0x18,%esp 10cca5: 68 ff 01 00 00 push $0x1ff 10ccaa: 68 2a 77 11 00 push $0x11772a 10ccaf: e8 24 04 00 00 call 10d0d8 if ( status != 0 ) 10ccb4: 83 c4 10 add $0x10,%esp 10ccb7: 85 c0 test %eax,%eax 10ccb9: 74 0d je 10ccc8 <== ALWAYS TAKEN rtems_fatal_error_occurred( 0xABCD0003 ); 10ccbb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ccbe: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED 10ccc3: e9 77 ff ff ff jmp 10cc3f <== NOT EXECUTED * before device drivers are initialized. So we return via a base * filesystem image and nothing auto-mounted at this point. */ #endif } 10ccc8: 8d 65 f4 lea -0xc(%ebp),%esp 10cccb: 5b pop %ebx 10cccc: 5e pop %esi 10cccd: 5f pop %edi 10ccce: c9 leave 10cccf: c3 ret =============================================================================== 0010a420 : ); bool rtems_filesystem_nodes_equal( const rtems_filesystem_location_info_t *loc1, const rtems_filesystem_location_info_t *loc2 ){ 10a420: 55 push %ebp <== NOT EXECUTED 10a421: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a423: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a426: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10a428: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a42b: 3b 10 cmp (%eax),%edx <== NOT EXECUTED 10a42d: 0f 94 c0 sete %al <== NOT EXECUTED return ( loc1->node_access == loc2->node_access ); } 10a430: c9 leave <== NOT EXECUTED 10a431: c3 ret <== NOT EXECUTED =============================================================================== 001094d0 : rtems_status_code rtems_interrupt_catch( rtems_isr_entry new_isr_handler, rtems_vector_number vector, rtems_isr_entry *old_isr_handler ) { 1094d0: 55 push %ebp <== NOT EXECUTED 1094d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1094d3: 53 push %ebx <== NOT EXECUTED 1094d4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1094d7: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1094da: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 1094dd: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED if ( !_ISR_Is_vector_number_valid( vector ) ) 1094e0: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 1094e5: 81 fb ff 00 00 00 cmp $0xff,%ebx <== NOT EXECUTED 1094eb: 77 1d ja 10950a <== NOT EXECUTED return RTEMS_INVALID_NUMBER; if ( !_ISR_Is_valid_user_handler( (void *) new_isr_handler ) ) 1094ed: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1094ef: 74 14 je 109505 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_ISR_Is_valid_user_handler( (void *) old_isr_handler ) ) 1094f1: 85 d2 test %edx,%edx <== NOT EXECUTED 1094f3: 74 10 je 109505 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _ISR_Install_vector( 1094f5: 50 push %eax <== NOT EXECUTED 1094f6: 52 push %edx <== NOT EXECUTED 1094f7: 51 push %ecx <== NOT EXECUTED 1094f8: 53 push %ebx <== NOT EXECUTED 1094f9: e8 44 cc ff ff call 106142 <_CPU_ISR_install_vector><== NOT EXECUTED 1094fe: 31 c0 xor %eax,%eax <== NOT EXECUTED 109500: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109503: eb 05 jmp 10950a <== NOT EXECUTED vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler ); return RTEMS_SUCCESSFUL; 109505: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } 10950a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10950d: c9 leave <== NOT EXECUTED 10950e: c3 ret <== NOT EXECUTED =============================================================================== 00106188 : rtems_status_code rtems_io_lookup_name( const char *name, rtems_driver_name_t *device_info ) { 106188: 55 push %ebp <== NOT EXECUTED 106189: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10618b: 57 push %edi <== NOT EXECUTED 10618c: 56 push %esi <== NOT EXECUTED 10618d: 53 push %ebx <== NOT EXECUTED 10618e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 106191: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 106194: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 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( name, 0x00, &loc, true ); 106197: 6a 01 push $0x1 <== NOT EXECUTED 106199: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10619c: 50 push %eax <== NOT EXECUTED 10619d: 6a 00 push $0x0 <== NOT EXECUTED 10619f: 57 push %edi <== NOT EXECUTED 1061a0: e8 b1 01 00 00 call 106356 <== NOT EXECUTED 1061a5: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_jnode = loc.node_access; 1061a7: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 1061aa: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED if ( !loc.ops->node_type_h ) { 1061ad: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1061b0: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 1061b3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1061b6: 85 d2 test %edx,%edx <== NOT EXECUTED 1061b8: 75 23 jne 1061dd <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1061ba: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1061bd: 85 c0 test %eax,%eax <== NOT EXECUTED 1061bf: 74 0c je 1061cd <== NOT EXECUTED 1061c1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1061c4: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 1061c7: 52 push %edx <== NOT EXECUTED 1061c8: ff d0 call *%eax <== NOT EXECUTED 1061ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1061cd: e8 56 8f 00 00 call 10f128 <__errno> <== NOT EXECUTED 1061d2: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1061d8: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1061db: eb 78 jmp 106255 <== NOT EXECUTED } node_type = (*loc.ops->node_type_h)( &loc ); 1061dd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1061e0: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 1061e3: 50 push %eax <== NOT EXECUTED 1061e4: ff d2 call *%edx <== NOT EXECUTED if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) { 1061e6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1061e9: 85 db test %ebx,%ebx <== NOT EXECUTED 1061eb: 75 05 jne 1061f2 <== NOT EXECUTED 1061ed: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 1061f0: 74 1e je 106210 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1061f2: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1061f5: 85 c0 test %eax,%eax <== NOT EXECUTED 1061f7: 74 53 je 10624c <== NOT EXECUTED 1061f9: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 1061fc: 85 d2 test %edx,%edx <== NOT EXECUTED 1061fe: 74 4c je 10624c <== NOT EXECUTED 106200: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106203: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 106206: 50 push %eax <== NOT EXECUTED 106207: ff d2 call *%edx <== NOT EXECUTED 106209: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 10620e: eb 37 jmp 106247 <== NOT EXECUTED return RTEMS_UNSATISFIED; } device_info->device_name = (char *) name; 106210: 89 3e mov %edi,(%esi) <== NOT EXECUTED device_info->device_name_length = strlen( name ); 106212: 31 c0 xor %eax,%eax <== NOT EXECUTED 106214: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 106217: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 106219: f7 d1 not %ecx <== NOT EXECUTED 10621b: 49 dec %ecx <== NOT EXECUTED 10621c: 89 4e 04 mov %ecx,0x4(%esi) <== NOT EXECUTED device_info->major = the_jnode->info.device.major; 10621f: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 106222: 8b 42 50 mov 0x50(%edx),%eax <== NOT EXECUTED 106225: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED device_info->minor = the_jnode->info.device.minor; 106228: 8b 42 54 mov 0x54(%edx),%eax <== NOT EXECUTED 10622b: 89 46 0c mov %eax,0xc(%esi) <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 10622e: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 106231: 85 c0 test %eax,%eax <== NOT EXECUTED 106233: 74 1e je 106253 <== NOT EXECUTED 106235: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 106238: 85 c0 test %eax,%eax <== NOT EXECUTED 10623a: 74 17 je 106253 <== NOT EXECUTED 10623c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10623f: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 106242: 52 push %edx <== NOT EXECUTED 106243: ff d0 call *%eax <== NOT EXECUTED 106245: 31 c0 xor %eax,%eax <== NOT EXECUTED 106247: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10624a: eb 09 jmp 106255 <== NOT EXECUTED 10624c: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 106251: eb 02 jmp 106255 <== NOT EXECUTED 106253: 31 c0 xor %eax,%eax <== NOT EXECUTED #endif return RTEMS_SUCCESSFUL; } 106255: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106258: 5b pop %ebx <== NOT EXECUTED 106259: 5e pop %esi <== NOT EXECUTED 10625a: 5f pop %edi <== NOT EXECUTED 10625b: c9 leave <== NOT EXECUTED 10625c: c3 ret <== NOT EXECUTED =============================================================================== 0010a4fc : 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 ) { 10a4fc: 55 push %ebp 10a4fd: 89 e5 mov %esp,%ebp 10a4ff: 57 push %edi 10a500: 56 push %esi 10a501: 53 push %ebx 10a502: 83 ec 08 sub $0x8,%esp 10a505: 8b 5d 08 mov 0x8(%ebp),%ebx 10a508: 8b 75 0c mov 0xc(%ebp),%esi 10a50b: 8b 45 10 mov 0x10(%ebp),%eax 10a50e: 89 45 f0 mov %eax,-0x10(%ebp) /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 10a511: 85 f6 test %esi,%esi 10a513: 0f 84 9a 00 00 00 je 10a5b3 return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 10a519: 85 c0 test %eax,%eax 10a51b: 0f 84 92 00 00 00 je 10a5b3 return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 10a521: 83 3e 00 cmpl $0x0,(%esi) 10a524: 75 0a jne 10a530 10a526: 83 7e 04 00 cmpl $0x0,0x4(%esi) 10a52a: 0f 84 83 00 00 00 je 10a5b3 <== ALWAYS TAKEN return RTEMS_INVALID_ADDRESS; *registered_major = 0; 10a530: 8b 45 f0 mov -0x10(%ebp),%eax 10a533: c7 00 00 00 00 00 movl $0x0,(%eax) /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 10a539: 8b 15 10 15 12 00 mov 0x121510,%edx 10a53f: b8 0a 00 00 00 mov $0xa,%eax 10a544: 39 d3 cmp %edx,%ebx 10a546: 73 77 jae 10a5bf /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 10a548: 85 db test %ebx,%ebx 10a54a: 75 2b jne 10a577 bool found = false; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 10a54c: 8d 5a ff lea -0x1(%edx),%ebx 10a54f: 6b c2 18 imul $0x18,%edx,%eax 10a552: 83 e8 18 sub $0x18,%eax 10a555: 03 05 14 15 12 00 add 0x121514,%eax 10a55b: eb 0f jmp 10a56c if ( !_IO_Driver_address_table[major].initialization_entry && 10a55d: 83 38 00 cmpl $0x0,(%eax) 10a560: 75 06 jne 10a568 10a562: 83 78 04 00 cmpl $0x0,0x4(%eax) 10a566: 74 0f je 10a577 <== ALWAYS TAKEN * in use. */ if ( major == 0 ) { bool found = false; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 10a568: 4b dec %ebx 10a569: 83 e8 18 sub $0x18,%eax 10a56c: 85 db test %ebx,%ebx 10a56e: 75 ed jne 10a55d 10a570: b8 05 00 00 00 mov $0x5,%eax 10a575: eb 48 jmp 10a5bf if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 10a577: 6b fb 18 imul $0x18,%ebx,%edi 10a57a: 03 3d 14 15 12 00 add 0x121514,%edi 10a580: 83 3f 00 cmpl $0x0,(%edi) 10a583: 75 35 jne 10a5ba 10a585: 83 7f 04 00 cmpl $0x0,0x4(%edi) 10a589: 75 2f jne 10a5ba <== NEVER TAKEN _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 10a58b: b9 06 00 00 00 mov $0x6,%ecx 10a590: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *registered_major = major; 10a592: 8b 45 f0 mov -0x10(%ebp),%eax 10a595: 89 18 mov %ebx,(%eax) return rtems_io_initialize( major, 0, NULL ); 10a597: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) 10a59e: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) 10a5a5: 89 5d 08 mov %ebx,0x8(%ebp) } 10a5a8: 5b pop %ebx 10a5a9: 5e pop %esi 10a5aa: 5b pop %ebx 10a5ab: 5e pop %esi 10a5ac: 5f pop %edi 10a5ad: c9 leave _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10a5ae: e9 ed fd ff ff jmp 10a3a0 10a5b3: b8 09 00 00 00 mov $0x9,%eax 10a5b8: eb 05 jmp 10a5bf 10a5ba: b8 0c 00 00 00 mov $0xc,%eax } 10a5bf: 5a pop %edx 10a5c0: 59 pop %ecx 10a5c1: 5b pop %ebx 10a5c2: 5e pop %esi 10a5c3: 5f pop %edi 10a5c4: c9 leave 10a5c5: c3 ret =============================================================================== 0010a5c8 : */ rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { 10a5c8: 55 push %ebp 10a5c9: 89 e5 mov %esp,%ebp 10a5cb: 57 push %edi 10a5cc: 83 ec 04 sub $0x4,%esp 10a5cf: 8b 55 08 mov 0x8(%ebp),%edx if ( major < _IO_Number_of_drivers ) { 10a5d2: b8 0d 00 00 00 mov $0xd,%eax 10a5d7: 3b 15 10 15 12 00 cmp 0x121510,%edx 10a5dd: 73 12 jae 10a5f1 <== NEVER TAKEN memset( 10a5df: 6b fa 18 imul $0x18,%edx,%edi 10a5e2: 03 3d 14 15 12 00 add 0x121514,%edi 10a5e8: b9 06 00 00 00 mov $0x6,%ecx 10a5ed: 31 c0 xor %eax,%eax 10a5ef: f3 ab rep stos %eax,%es:(%edi) sizeof( rtems_driver_address_table ) ); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10a5f1: 5a pop %edx 10a5f2: 5f pop %edi 10a5f3: c9 leave 10a5f4: c3 ret =============================================================================== 0010b4d8 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10b4d8: 55 push %ebp 10b4d9: 89 e5 mov %esp,%ebp 10b4db: 57 push %edi 10b4dc: 56 push %esi 10b4dd: 53 push %ebx 10b4de: 83 ec 0c sub $0xc,%esp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10b4e1: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 10b4e5: 74 41 je 10b528 <== NEVER TAKEN return; 10b4e7: bf 01 00 00 00 mov $0x1,%edi for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 10b4ec: 8b 04 bd 68 92 12 00 mov 0x129268(,%edi,4),%eax 10b4f3: 85 c0 test %eax,%eax 10b4f5: 74 2b je 10b522 continue; information = _Objects_Information_table[ api_index ][ 1 ]; 10b4f7: 8b 70 04 mov 0x4(%eax),%esi if ( information ) { 10b4fa: bb 01 00 00 00 mov $0x1,%ebx 10b4ff: 85 f6 test %esi,%esi 10b501: 75 17 jne 10b51a <== ALWAYS TAKEN 10b503: eb 1d jmp 10b522 <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { the_thread = (Thread_Control *)information->local_table[ i ]; 10b505: 8b 46 1c mov 0x1c(%esi),%eax 10b508: 8b 04 98 mov (%eax,%ebx,4),%eax if ( !the_thread ) 10b50b: 85 c0 test %eax,%eax 10b50d: 74 0a je 10b519 <== NEVER TAKEN continue; (*routine)(the_thread); 10b50f: 83 ec 0c sub $0xc,%esp 10b512: 50 push %eax 10b513: ff 55 08 call *0x8(%ebp) 10b516: 83 c4 10 add $0x10,%esp api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) continue; information = _Objects_Information_table[ api_index ][ 1 ]; if ( information ) { for ( i=1 ; i <= information->maximum ; i++ ) { 10b519: 43 inc %ebx 10b51a: 0f b7 46 10 movzwl 0x10(%esi),%eax 10b51e: 39 c3 cmp %eax,%ebx 10b520: 76 e3 jbe 10b505 if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10b522: 47 inc %edi if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 10b523: 83 ff 05 cmp $0x5,%edi 10b526: 75 c4 jne 10b4ec (*routine)(the_thread); } } } } 10b528: 8d 65 f4 lea -0xc(%ebp),%esp 10b52b: 5b pop %ebx 10b52c: 5e pop %esi 10b52d: 5f pop %edi 10b52e: c9 leave 10b52f: c3 ret =============================================================================== 0010d011 : * This routine searches the IOP Table for an unused entry. If it * finds one, it returns it. Otherwise, it returns NULL. */ rtems_libio_t *rtems_libio_allocate( void ) { 10d011: 55 push %ebp 10d012: 89 e5 mov %esp,%ebp 10d014: 57 push %edi 10d015: 53 push %ebx 10d016: 83 ec 24 sub $0x24,%esp rtems_libio_t *iop, *next; rtems_status_code rc; rtems_id sema; rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 10d019: 6a 00 push $0x0 10d01b: 6a 00 push $0x0 10d01d: ff 35 40 d6 11 00 pushl 0x11d640 10d023: e8 4c c1 ff ff call 109174 if (rtems_libio_iop_freelist) { 10d028: 8b 15 3c d6 11 00 mov 0x11d63c,%edx 10d02e: 83 c4 10 add $0x10,%esp 10d031: 85 d2 test %edx,%edx 10d033: 74 55 je 10d08a rc = rtems_semaphore_create( 10d035: 83 ec 0c sub $0xc,%esp 10d038: 8d 45 f4 lea -0xc(%ebp),%eax 10d03b: 50 push %eax 10d03c: 6a 00 push $0x0 10d03e: 6a 54 push $0x54 10d040: 6a 01 push $0x1 10d042: 2b 15 38 d6 11 00 sub 0x11d638,%edx 10d048: c1 fa 02 sar $0x2,%edx 10d04b: 69 c2 c5 4e ec c4 imul $0xc4ec4ec5,%edx,%eax 10d051: 0d 00 49 42 4c or $0x4c424900,%eax 10d056: 50 push %eax 10d057: e8 e4 be ff ff call 108f40 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &sema ); if (rc != RTEMS_SUCCESSFUL) 10d05c: 83 c4 20 add $0x20,%esp 10d05f: 85 c0 test %eax,%eax 10d061: 75 27 jne 10d08a <== NEVER TAKEN goto failed; iop = rtems_libio_iop_freelist; 10d063: 8b 1d 3c d6 11 00 mov 0x11d63c,%ebx next = iop->data1; 10d069: 8b 53 28 mov 0x28(%ebx),%edx (void) memset( iop, 0, sizeof(rtems_libio_t) ); 10d06c: b9 0d 00 00 00 mov $0xd,%ecx 10d071: 89 df mov %ebx,%edi 10d073: f3 ab rep stos %eax,%es:(%edi) iop->flags = LIBIO_FLAGS_OPEN; 10d075: c7 43 0c 00 01 00 00 movl $0x100,0xc(%ebx) iop->sem = sema; 10d07c: 8b 45 f4 mov -0xc(%ebp),%eax 10d07f: 89 43 20 mov %eax,0x20(%ebx) rtems_libio_iop_freelist = next; 10d082: 89 15 3c d6 11 00 mov %edx,0x11d63c 10d088: eb 02 jmp 10d08c } failed: iop = 0; done: 10d08a: 31 db xor %ebx,%ebx rtems_semaphore_release( rtems_libio_semaphore ); 10d08c: 83 ec 0c sub $0xc,%esp 10d08f: ff 35 40 d6 11 00 pushl 0x11d640 10d095: e8 c2 c1 ff ff call 10925c return iop; } 10d09a: 89 d8 mov %ebx,%eax 10d09c: 8d 65 f8 lea -0x8(%ebp),%esp 10d09f: 5b pop %ebx 10d0a0: 5f pop %edi 10d0a1: c9 leave 10d0a2: c3 ret =============================================================================== 0010cfbc : */ void rtems_libio_free( rtems_libio_t *iop ) { 10cfbc: 55 push %ebp 10cfbd: 89 e5 mov %esp,%ebp 10cfbf: 53 push %ebx 10cfc0: 83 ec 08 sub $0x8,%esp 10cfc3: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 10cfc6: 6a 00 push $0x0 10cfc8: 6a 00 push $0x0 10cfca: ff 35 40 d6 11 00 pushl 0x11d640 10cfd0: e8 9f c1 ff ff call 109174 if (iop->sem) 10cfd5: 8b 43 20 mov 0x20(%ebx),%eax 10cfd8: 83 c4 10 add $0x10,%esp 10cfdb: 85 c0 test %eax,%eax 10cfdd: 74 0c je 10cfeb <== NEVER TAKEN rtems_semaphore_delete(iop->sem); 10cfdf: 83 ec 0c sub $0xc,%esp 10cfe2: 50 push %eax 10cfe3: e8 fc c0 ff ff call 1090e4 10cfe8: 83 c4 10 add $0x10,%esp iop->flags &= ~LIBIO_FLAGS_OPEN; 10cfeb: 81 63 0c ff fe ff ff andl $0xfffffeff,0xc(%ebx) iop->data1 = rtems_libio_iop_freelist; 10cff2: a1 3c d6 11 00 mov 0x11d63c,%eax 10cff7: 89 43 28 mov %eax,0x28(%ebx) rtems_libio_iop_freelist = iop; 10cffa: 89 1d 3c d6 11 00 mov %ebx,0x11d63c rtems_semaphore_release(rtems_libio_semaphore); 10d000: a1 40 d6 11 00 mov 0x11d640,%eax 10d005: 89 45 08 mov %eax,0x8(%ebp) } 10d008: 8b 5d fc mov -0x4(%ebp),%ebx 10d00b: c9 leave iop->flags &= ~LIBIO_FLAGS_OPEN; iop->data1 = rtems_libio_iop_freelist; rtems_libio_iop_freelist = iop; rtems_semaphore_release(rtems_libio_semaphore); 10d00c: e9 4b c2 ff ff jmp 10925c =============================================================================== 001064f0 : * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) { 1064f0: 55 push %ebp 1064f1: 89 e5 mov %esp,%ebp 1064f3: 53 push %ebx 1064f4: 83 ec 04 sub $0x4,%esp rtems_status_code rc; int i; rtems_libio_t *iop; if (rtems_libio_number_iops > 0) 1064f7: a1 d8 92 11 00 mov 0x1192d8,%eax 1064fc: 85 c0 test %eax,%eax 1064fe: 74 46 je 106546 { rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, 106500: 52 push %edx 106501: 52 push %edx 106502: 6a 34 push $0x34 106504: 50 push %eax 106505: e8 c6 67 00 00 call 10ccd0 10650a: 89 c1 mov %eax,%ecx 10650c: a3 38 d6 11 00 mov %eax,0x11d638 sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) 106511: 83 c4 10 add $0x10,%esp 106514: 85 c0 test %eax,%eax 106516: 75 07 jne 10651f <== ALWAYS TAKEN rtems_fatal_error_occurred(RTEMS_NO_MEMORY); 106518: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10651b: 6a 1a push $0x1a <== NOT EXECUTED 10651d: eb 4a jmp 106569 <== NOT EXECUTED iop = rtems_libio_iop_freelist = rtems_libio_iops; 10651f: a3 3c d6 11 00 mov %eax,0x11d63c for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++) 106524: 8b 1d d8 92 11 00 mov 0x1192d8,%ebx 10652a: 89 c2 mov %eax,%edx 10652c: 31 c0 xor %eax,%eax 10652e: eb 03 jmp 106533 iop->data1 = iop + 1; 106530: 89 52 f4 mov %edx,-0xc(%edx) 106533: 40 inc %eax 106534: 83 c2 34 add $0x34,%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 < (rtems_libio_number_iops - 1) ; i++, iop++) 106537: 39 d8 cmp %ebx,%eax 106539: 75 f5 jne 106530 iop->data1 = iop + 1; iop->data1 = NULL; 10653b: 6b c0 34 imul $0x34,%eax,%eax 10653e: c7 44 01 f4 00 00 00 movl $0x0,-0xc(%ecx,%eax,1) 106545: 00 /* * Create the binary semaphore used to provide mutual exclusion * on the IOP Table. */ rc = rtems_semaphore_create( 106546: 83 ec 0c sub $0xc,%esp 106549: 68 40 d6 11 00 push $0x11d640 10654e: 6a 00 push $0x0 106550: 6a 54 push $0x54 106552: 6a 01 push $0x1 106554: 68 4f 49 42 4c push $0x4c42494f 106559: e8 e2 29 00 00 call 108f40 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_libio_semaphore ); if ( rc != RTEMS_SUCCESSFUL ) 10655e: 83 c4 20 add $0x20,%esp 106561: 85 c0 test %eax,%eax 106563: 74 09 je 10656e <== ALWAYS TAKEN rtems_fatal_error_occurred( rc ); 106565: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106568: 50 push %eax <== NOT EXECUTED 106569: e8 26 32 00 00 call 109794 <== NOT EXECUTED /* * Initialize the base file system infrastructure. */ rtems_filesystem_initialize(); } 10656e: 8b 5d fc mov -0x4(%ebp),%ebx 106571: c9 leave /* * Initialize the base file system infrastructure. */ rtems_filesystem_initialize(); 106572: e9 71 66 00 00 jmp 10cbe8 =============================================================================== 00107b69 : rtems_filesystem_freenode( &env->root_directory); free(env); } } rtems_status_code rtems_libio_set_private_env(void) { 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 30 sub $0x30,%esp rtems_status_code sc; rtems_id task_id; rtems_filesystem_location_info_t loc; sc=rtems_task_ident(RTEMS_SELF,0,&task_id); 107b72: 8d 45 f0 lea -0x10(%ebp),%eax 107b75: 50 push %eax 107b76: 6a 00 push $0x0 107b78: 6a 00 push $0x0 107b7a: e8 c9 25 00 00 call 10a148 107b7f: 89 c3 mov %eax,%ebx if (sc != RTEMS_SUCCESSFUL) return sc; 107b81: 83 c4 10 add $0x10,%esp 107b84: 85 c0 test %eax,%eax 107b86: 0f 85 d4 00 00 00 jne 107c60 <== NEVER TAKEN /* Only for the first time a malloc is necesary */ if (rtems_current_user_env==&rtems_global_user_env) { 107b8c: 81 3d ac e3 11 00 00 cmpl $0x120a00,0x11e3ac 107b93: 0a 12 00 107b96: 75 4e jne 107be6 rtems_user_env_t *tmp = malloc(sizeof(rtems_user_env_t)); 107b98: 83 ec 0c sub $0xc,%esp 107b9b: 6a 40 push $0x40 107b9d: e8 b2 f4 ff ff call 107054 107ba2: 89 c6 mov %eax,%esi if (!tmp) 107ba4: 83 c4 10 add $0x10,%esp 107ba7: 85 c0 test %eax,%eax 107ba9: 75 07 jne 107bb2 <== ALWAYS TAKEN 107bab: b3 1a mov $0x1a,%bl <== NOT EXECUTED 107bad: e9 ae 00 00 00 jmp 107c60 <== NOT EXECUTED #ifdef HAVE_USERENV_REFCNT tmp->refcnt = 1; #endif sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,(void(*)(void *))free_user_env); 107bb2: 57 push %edi 107bb3: 68 74 7a 10 00 push $0x107a74 107bb8: 68 ac e3 11 00 push $0x11e3ac 107bbd: 6a 00 push $0x0 107bbf: e8 a4 26 00 00 call 10a268 107bc4: 89 c7 mov %eax,%edi if (sc != RTEMS_SUCCESSFUL) { 107bc6: 83 c4 10 add $0x10,%esp 107bc9: 85 c0 test %eax,%eax 107bcb: 74 13 je 107be0 <== ALWAYS TAKEN /* don't use free_user_env because the pathlocs are * not initialized yet */ free(tmp); 107bcd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107bd0: 56 push %esi <== NOT EXECUTED 107bd1: e8 fe ef ff ff call 106bd4 <== NOT EXECUTED 107bd6: 89 fb mov %edi,%ebx <== NOT EXECUTED 107bd8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107bdb: e9 80 00 00 00 jmp 107c60 <== NOT EXECUTED return sc; } rtems_current_user_env = tmp; 107be0: 89 35 ac e3 11 00 mov %esi,0x11e3ac }; *rtems_current_user_env = rtems_global_user_env; /* get the global values*/ 107be6: 8b 3d ac e3 11 00 mov 0x11e3ac,%edi 107bec: be 00 0a 12 00 mov $0x120a00,%esi 107bf1: b9 10 00 00 00 mov $0x10,%ecx 107bf6: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_current_user_env->task_id=task_id; /* mark the local values*/ 107bf8: 8b 15 ac e3 11 00 mov 0x11e3ac,%edx 107bfe: 8b 45 f0 mov -0x10(%ebp),%eax 107c01: 89 02 mov %eax,(%edx) /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 107c03: 8d 7a 14 lea 0x14(%edx),%edi 107c06: a1 40 0a 12 00 mov 0x120a40,%eax 107c0b: 8d 70 18 lea 0x18(%eax),%esi 107c0e: b1 04 mov $0x4,%cl 107c10: f3 a5 rep movsl %ds:(%esi),%es:(%edi) * code we must _not_ free the original locs because * what we are trying to do here is forking off * clones. */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 107c12: 6a 00 push $0x0 107c14: 8d 45 e0 lea -0x20(%ebp),%eax 107c17: 89 45 c8 mov %eax,-0x38(%ebp) 107c1a: 50 push %eax 107c1b: 6a 00 push $0x0 107c1d: 68 cf 9d 11 00 push $0x119dcf 107c22: e8 8b ee ff ff call 106ab2 rtems_filesystem_root = loc; 107c27: a1 ac e3 11 00 mov 0x11e3ac,%eax 107c2c: 8d 78 14 lea 0x14(%eax),%edi 107c2f: b9 04 00 00 00 mov $0x4,%ecx 107c34: 8b 75 c8 mov -0x38(%ebp),%esi 107c37: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_filesystem_evaluate_path("/", 0, &loc, 0); 107c39: 6a 00 push $0x0 107c3b: 8d 45 e0 lea -0x20(%ebp),%eax 107c3e: 50 push %eax 107c3f: 6a 00 push $0x0 107c41: 68 cf 9d 11 00 push $0x119dcf 107c46: e8 67 ee ff ff call 106ab2 rtems_filesystem_current = loc; 107c4b: a1 ac e3 11 00 mov 0x11e3ac,%eax 107c50: 8d 78 04 lea 0x4(%eax),%edi 107c53: b9 04 00 00 00 mov $0x4,%ecx 107c58: 8b 75 c8 mov -0x38(%ebp),%esi 107c5b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 107c5d: 83 c4 20 add $0x20,%esp return RTEMS_SUCCESSFUL; } 107c60: 89 d8 mov %ebx,%eax 107c62: 8d 65 f4 lea -0xc(%ebp),%esp 107c65: 5b pop %ebx 107c66: 5e pop %esi 107c67: 5f pop %edi 107c68: c9 leave 107c69: c3 ret =============================================================================== 00107acb : * b) mutex access to rtems_filesystem_current, rtems_filesytem_root * while changing any of those (chdir(), chroot()). */ #ifndef HAVE_USERENV_REFCNT rtems_status_code rtems_libio_share_private_env(rtems_id task_id) { 107acb: 55 push %ebp <== NOT EXECUTED 107acc: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107ace: 53 push %ebx <== NOT EXECUTED 107acf: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED rtems_status_code sc; rtems_user_env_t * shared_user_env; rtems_id current_task_id; sc=rtems_task_ident(RTEMS_SELF,0,¤t_task_id); 107ad2: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 107ad5: 50 push %eax <== NOT EXECUTED 107ad6: 6a 00 push $0x0 <== NOT EXECUTED 107ad8: 6a 00 push $0x0 <== NOT EXECUTED 107ada: e8 69 26 00 00 call 10a148 <== NOT EXECUTED 107adf: 89 c2 mov %eax,%edx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 107ae1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107ae4: 85 c0 test %eax,%eax <== NOT EXECUTED 107ae6: 75 7a jne 107b62 <== NOT EXECUTED if (rtems_current_user_env->task_id==current_task_id) { 107ae8: 8b 1d ac e3 11 00 mov 0x11e3ac,%ebx <== NOT EXECUTED 107aee: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 107af0: 3b 45 f4 cmp -0xc(%ebp),%eax <== NOT EXECUTED 107af3: 75 23 jne 107b18 <== NOT EXECUTED /* kill the current user env & task_var*/ rtems_user_env_t *tmp = rtems_current_user_env; sc = rtems_task_variable_delete(RTEMS_SELF,(void*)&rtems_current_user_env); 107af5: 51 push %ecx <== NOT EXECUTED 107af6: 51 push %ecx <== NOT EXECUTED 107af7: 68 ac e3 11 00 push $0x11e3ac <== NOT EXECUTED 107afc: 6a 00 push $0x0 <== NOT EXECUTED 107afe: e8 fd 27 00 00 call 10a300 <== NOT EXECUTED 107b03: 89 c2 mov %eax,%edx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 107b05: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107b08: 85 c0 test %eax,%eax <== NOT EXECUTED 107b0a: 75 56 jne 107b62 <== NOT EXECUTED free_user_env(tmp); 107b0c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107b0f: 53 push %ebx <== NOT EXECUTED 107b10: e8 5f ff ff ff call 107a74 <== NOT EXECUTED 107b15: 83 c4 10 add $0x10,%esp <== NOT EXECUTED }; /* AT THIS POINT, rtems_current_user_env is DANGLING */ sc = rtems_task_variable_get(task_id,(void*)&rtems_current_user_env, 107b18: 52 push %edx <== NOT EXECUTED 107b19: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 107b1c: 50 push %eax <== NOT EXECUTED 107b1d: 68 ac e3 11 00 push $0x11e3ac <== NOT EXECUTED 107b22: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 107b25: e8 56 28 00 00 call 10a380 <== NOT EXECUTED 107b2a: 89 c2 mov %eax,%edx <== NOT EXECUTED (void*)&shared_user_env ); if (sc != RTEMS_SUCCESSFUL) 107b2c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107b2f: 85 c0 test %eax,%eax <== NOT EXECUTED 107b31: 75 25 jne 107b58 <== NOT EXECUTED goto bailout; sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,free_user_env); 107b33: 50 push %eax <== NOT EXECUTED 107b34: 68 74 7a 10 00 push $0x107a74 <== NOT EXECUTED 107b39: 68 ac e3 11 00 push $0x11e3ac <== NOT EXECUTED 107b3e: 6a 00 push $0x0 <== NOT EXECUTED 107b40: e8 23 27 00 00 call 10a268 <== NOT EXECUTED 107b45: 89 c2 mov %eax,%edx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 107b47: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107b4a: 85 c0 test %eax,%eax <== NOT EXECUTED 107b4c: 75 0a jne 107b58 <== NOT EXECUTED goto bailout; /* the current_user_env is the same pointer that remote env */ rtems_current_user_env = shared_user_env; 107b4e: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 107b51: a3 ac e3 11 00 mov %eax,0x11e3ac <== NOT EXECUTED 107b56: eb 0a jmp 107b62 <== NOT EXECUTED return RTEMS_SUCCESSFUL; bailout: /* fallback to the global env */ rtems_current_user_env = &rtems_global_user_env; 107b58: c7 05 ac e3 11 00 00 movl $0x120a00,0x11e3ac <== NOT EXECUTED 107b5f: 0a 12 00 return sc; } 107b62: 89 d0 mov %edx,%eax <== NOT EXECUTED 107b64: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 107b67: c9 leave <== NOT EXECUTED 107b68: c3 ret <== NOT EXECUTED =============================================================================== 0010cec4 : */ uint32_t rtems_libio_to_fcntl_flags( uint32_t flags ) { 10cec4: 55 push %ebp 10cec5: 89 e5 mov %esp,%ebp 10cec7: 8b 4d 08 mov 0x8(%ebp),%ecx uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10ceca: 89 c8 mov %ecx,%eax 10cecc: 83 e0 06 and $0x6,%eax 10cecf: ba 02 00 00 00 mov $0x2,%edx 10ced4: 83 f8 06 cmp $0x6,%eax 10ced7: 74 0f je 10cee8 <== NEVER TAKEN fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { 10ced9: 31 d2 xor %edx,%edx 10cedb: f6 c1 02 test $0x2,%cl 10cede: 75 08 jne 10cee8 <== ALWAYS TAKEN 10cee0: 89 ca mov %ecx,%edx <== NOT EXECUTED 10cee2: c1 ea 02 shr $0x2,%edx <== NOT EXECUTED 10cee5: 83 e2 01 and $0x1,%edx <== 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 ) { 10cee8: f6 c1 01 test $0x1,%cl 10ceeb: 74 03 je 10cef0 fcntl_flags |= O_NONBLOCK; 10ceed: 80 ce 40 or $0x40,%dh } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 10cef0: f6 c5 02 test $0x2,%ch 10cef3: 74 03 je 10cef8 fcntl_flags |= O_APPEND; 10cef5: 83 ca 08 or $0x8,%edx } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 10cef8: 80 e5 04 and $0x4,%ch 10cefb: 74 03 je 10cf00 fcntl_flags |= O_CREAT; 10cefd: 80 ce 02 or $0x2,%dh } return fcntl_flags; } 10cf00: 89 d0 mov %edx,%eax 10cf02: c9 leave 10cf03: c3 ret =============================================================================== 001085fc : int rtems_memalign( void **pointer, size_t alignment, size_t size ) { 1085fc: 55 push %ebp 1085fd: 89 e5 mov %esp,%ebp 1085ff: 56 push %esi 108600: 53 push %ebx 108601: 8b 75 08 mov 0x8(%ebp),%esi void *return_this; /* * Parameter error checks */ if ( !pointer ) 108604: 85 f6 test %esi,%esi 108606: 74 55 je 10865d return EINVAL; *pointer = NULL; 108608: c7 06 00 00 00 00 movl $0x0,(%esi) /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 10860e: 83 3d 24 2c 12 00 03 cmpl $0x3,0x122c24 108615: 75 09 jne 108620 <== NEVER TAKEN 108617: e8 f8 f1 ff ff call 107814 10861c: 84 c0 test %al,%al 10861e: 74 3d je 10865d <== NEVER TAKEN /* * * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 108620: e8 46 f2 ff ff call 10786b /* * Perform the aligned allocation requested */ return_this = _Protected_heap_Allocate_aligned( 108625: 50 push %eax 108626: ff 75 0c pushl 0xc(%ebp) 108629: ff 75 10 pushl 0x10(%ebp) 10862c: 68 3c 29 12 00 push $0x12293c 108631: e8 06 40 00 00 call 10c63c <_Protected_heap_Allocate_aligned> 108636: 89 c3 mov %eax,%ebx &RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 108638: 83 c4 10 add $0x10,%esp 10863b: b8 0c 00 00 00 mov $0xc,%eax 108640: 85 db test %ebx,%ebx 108642: 74 1e je 108662 return ENOMEM; /* * If configured, update the more involved statistics */ if ( rtems_malloc_statistics_helpers ) 108644: a1 34 0a 12 00 mov 0x120a34,%eax 108649: 85 c0 test %eax,%eax 10864b: 74 0a je 108657 <== ALWAYS TAKEN (*rtems_malloc_statistics_helpers->at_malloc)(pointer); 10864d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108650: 56 push %esi <== NOT EXECUTED 108651: ff 50 04 call *0x4(%eax) <== NOT EXECUTED 108654: 83 c4 10 add $0x10,%esp <== NOT EXECUTED */ if (rtems_malloc_boundary_helpers) (*rtems_malloc_boundary_helpers->at_malloc)(return_this, size); #endif *pointer = return_this; 108657: 89 1e mov %ebx,(%esi) 108659: 31 c0 xor %eax,%eax 10865b: eb 05 jmp 108662 return 0; 10865d: b8 16 00 00 00 mov $0x16,%eax } 108662: 8d 65 f8 lea -0x8(%ebp),%esp 108665: 5b pop %ebx 108666: 5e pop %esi 108667: c9 leave 108668: c3 ret =============================================================================== 00110d44 : uint32_t count, size_t max_message_size, rtems_attribute attribute_set, Objects_Id *id ) { 110d44: 55 push %ebp 110d45: 89 e5 mov %esp,%ebp 110d47: 57 push %edi 110d48: 56 push %esi 110d49: 53 push %ebx 110d4a: 83 ec 1c sub $0x1c,%esp 110d4d: 8b 7d 10 mov 0x10(%ebp),%edi 110d50: 8b 75 14 mov 0x14(%ebp),%esi CORE_message_queue_Attributes the_msgq_attributes; #if defined(RTEMS_MULTIPROCESSING) bool is_global; #endif if ( !rtems_is_name_valid( name ) ) 110d53: b8 03 00 00 00 mov $0x3,%eax 110d58: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 110d5c: 0f 84 b2 00 00 00 je 110e14 return RTEMS_INVALID_NAME; if ( !id ) 110d62: b8 09 00 00 00 mov $0x9,%eax 110d67: 83 7d 18 00 cmpl $0x0,0x18(%ebp) 110d6b: 0f 84 a3 00 00 00 je 110e14 <== NEVER TAKEN if ( (is_global = _Attributes_Is_global( attribute_set ) ) && !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) 110d71: b8 0a 00 00 00 mov $0xa,%eax 110d76: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 110d7a: 0f 84 94 00 00 00 je 110e14 <== NEVER TAKEN return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 110d80: b8 08 00 00 00 mov $0x8,%eax 110d85: 85 ff test %edi,%edi 110d87: 0f 84 87 00 00 00 je 110e14 <== NEVER TAKEN /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 110d8d: a1 38 41 13 00 mov 0x134138,%eax 110d92: 40 inc %eax 110d93: a3 38 41 13 00 mov %eax,0x134138 #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); 110d98: e8 4f 79 00 00 call 1186ec <_Message_queue_Allocate> 110d9d: 89 c3 mov %eax,%ebx if ( !the_message_queue ) { 110d9f: 85 c0 test %eax,%eax 110da1: 75 0c jne 110daf _Thread_Enable_dispatch(); 110da3: e8 10 4a 00 00 call 1157b8 <_Thread_Enable_dispatch> 110da8: b8 05 00 00 00 mov $0x5,%eax 110dad: eb 65 jmp 110e14 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_message_queue->attribute_set = attribute_set; 110daf: 89 70 10 mov %esi,0x10(%eax) if (_Attributes_Is_priority( attribute_set ) ) the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 110db2: 31 c0 xor %eax,%eax 110db4: f7 c6 04 00 00 00 test $0x4,%esi 110dba: 0f 95 c0 setne %al 110dbd: 89 45 f0 mov %eax,-0x10(%ebp) else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( ! _CORE_message_queue_Initialize( 110dc0: 57 push %edi 110dc1: ff 75 0c pushl 0xc(%ebp) 110dc4: 8d 45 f0 lea -0x10(%ebp),%eax 110dc7: 50 push %eax 110dc8: 8d 43 14 lea 0x14(%ebx),%eax 110dcb: 50 push %eax 110dcc: e8 3b 2e 00 00 call 113c0c <_CORE_message_queue_Initialize> 110dd1: 83 c4 10 add $0x10,%esp 110dd4: 84 c0 test %al,%al 110dd6: 75 1c jne 110df4 * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, 110dd8: 50 push %eax 110dd9: 50 push %eax 110dda: 53 push %ebx 110ddb: 68 38 4a 13 00 push $0x134a38 110de0: e8 a3 40 00 00 call 114e88 <_Objects_Free> _Objects_MP_Close( &_Message_queue_Information, the_message_queue->Object.id); #endif _Message_queue_Free( the_message_queue ); _Thread_Enable_dispatch(); 110de5: e8 ce 49 00 00 call 1157b8 <_Thread_Enable_dispatch> 110dea: b8 0d 00 00 00 mov $0xd,%eax 110def: 83 c4 10 add $0x10,%esp 110df2: eb 20 jmp 110e14 110df4: 8b 4b 08 mov 0x8(%ebx),%ecx 110df7: 0f b7 d1 movzwl %cx,%edx 110dfa: a1 54 4a 13 00 mov 0x134a54,%eax 110dff: 89 1c 90 mov %ebx,(%eax,%edx,4) 110e02: 8b 45 08 mov 0x8(%ebp),%eax 110e05: 89 43 0c mov %eax,0xc(%ebx) &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 110e08: 8b 45 18 mov 0x18(%ebp),%eax 110e0b: 89 08 mov %ecx,(%eax) name, 0 ); #endif _Thread_Enable_dispatch(); 110e0d: e8 a6 49 00 00 call 1157b8 <_Thread_Enable_dispatch> 110e12: 31 c0 xor %eax,%eax return RTEMS_SUCCESSFUL; } 110e14: 8d 65 f4 lea -0xc(%ebp),%esp 110e17: 5b pop %ebx 110e18: 5e pop %esi 110e19: 5f pop %edi 110e1a: c9 leave 110e1b: c3 ret =============================================================================== 00110e80 : rtems_status_code rtems_message_queue_flush( Objects_Id id, uint32_t *count ) { 110e80: 55 push %ebp 110e81: 89 e5 mov %esp,%ebp 110e83: 53 push %ebx 110e84: 83 ec 14 sub $0x14,%esp 110e87: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 110e8a: b8 09 00 00 00 mov $0x9,%eax 110e8f: 85 db test %ebx,%ebx 110e91: 74 3a je 110ecd <== NEVER TAKEN * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 110e93: 50 push %eax 110e94: 8d 45 f8 lea -0x8(%ebp),%eax 110e97: 50 push %eax 110e98: ff 75 08 pushl 0x8(%ebp) 110e9b: 68 38 4a 13 00 push $0x134a38 110ea0: e8 53 41 00 00 call 114ff8 <_Objects_Get> 110ea5: 89 c2 mov %eax,%edx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 110ea7: 83 c4 10 add $0x10,%esp 110eaa: b8 04 00 00 00 mov $0x4,%eax 110eaf: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) 110eb3: 75 18 jne 110ecd case OBJECTS_LOCAL: *count = _CORE_message_queue_Flush( &the_message_queue->message_queue ); 110eb5: 83 ec 0c sub $0xc,%esp 110eb8: 8d 42 14 lea 0x14(%edx),%eax 110ebb: 50 push %eax 110ebc: e8 e7 2c 00 00 call 113ba8 <_CORE_message_queue_Flush> 110ec1: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 110ec3: e8 f0 48 00 00 call 1157b8 <_Thread_Enable_dispatch> 110ec8: 31 c0 xor %eax,%eax 110eca: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110ecd: 8b 5d fc mov -0x4(%ebp),%ebx 110ed0: c9 leave 110ed1: c3 ret =============================================================================== 00110ed4 : rtems_status_code rtems_message_queue_get_number_pending( Objects_Id id, uint32_t *count ) { 110ed4: 55 push %ebp 110ed5: 89 e5 mov %esp,%ebp 110ed7: 53 push %ebx 110ed8: 83 ec 14 sub $0x14,%esp 110edb: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 110ede: b8 09 00 00 00 mov $0x9,%eax 110ee3: 85 db test %ebx,%ebx 110ee5: 74 2e je 110f15 <== NEVER TAKEN 110ee7: 50 push %eax 110ee8: 8d 45 f8 lea -0x8(%ebp),%eax 110eeb: 50 push %eax 110eec: ff 75 08 pushl 0x8(%ebp) 110eef: 68 38 4a 13 00 push $0x134a38 110ef4: e8 ff 40 00 00 call 114ff8 <_Objects_Get> 110ef9: 89 c2 mov %eax,%edx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 110efb: 83 c4 10 add $0x10,%esp 110efe: b8 04 00 00 00 mov $0x4,%eax 110f03: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) 110f07: 75 0c jne 110f15 case OBJECTS_LOCAL: *count = the_message_queue->message_queue.number_of_pending_messages; 110f09: 8b 42 5c mov 0x5c(%edx),%eax 110f0c: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 110f0e: e8 a5 48 00 00 call 1157b8 <_Thread_Enable_dispatch> 110f13: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110f15: 8b 5d fc mov -0x4(%ebp),%ebx 110f18: c9 leave 110f19: c3 ret =============================================================================== 00108ec0 : rtems_status_code rtems_message_queue_send( Objects_Id id, const void *buffer, size_t size ) { 108ec0: 55 push %ebp 108ec1: 89 e5 mov %esp,%ebp 108ec3: 56 push %esi 108ec4: 53 push %ebx 108ec5: 83 ec 10 sub $0x10,%esp 108ec8: 8b 5d 08 mov 0x8(%ebp),%ebx 108ecb: 8b 75 0c mov 0xc(%ebp),%esi register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 108ece: b8 09 00 00 00 mov $0x9,%eax 108ed3: 85 f6 test %esi,%esi 108ed5: 74 4f je 108f26 <== NEVER TAKEN * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 108ed7: 50 push %eax 108ed8: 8d 45 f4 lea -0xc(%ebp),%eax 108edb: 50 push %eax 108edc: 53 push %ebx 108edd: 68 90 e0 11 00 push $0x11e090 108ee2: e8 e5 17 00 00 call 10a6cc <_Objects_Get> 108ee7: 89 c2 mov %eax,%edx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 108ee9: 83 c4 10 add $0x10,%esp 108eec: b8 04 00 00 00 mov $0x4,%eax 108ef1: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 108ef5: 75 2f jne 108f26 <== NEVER TAKEN * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 108ef7: 6a 00 push $0x0 108ef9: 6a 00 push $0x0 108efb: 68 ff ff ff 7f push $0x7fffffff 108f00: 6a 00 push $0x0 108f02: 53 push %ebx 108f03: ff 75 10 pushl 0x10(%ebp) 108f06: 56 push %esi 108f07: 8d 42 14 lea 0x14(%edx),%eax 108f0a: 50 push %eax 108f0b: e8 28 0c 00 00 call 109b38 <_CORE_message_queue_Submit> 108f10: 89 c3 mov %eax,%ebx MESSAGE_QUEUE_MP_HANDLER, FALSE, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 108f12: 83 c4 20 add $0x20,%esp 108f15: e8 72 1f 00 00 call 10ae8c <_Thread_Enable_dispatch> /* * Since this API does not allow for blocking sends, we can directly * return the returned status. */ return _Message_queue_Translate_core_message_queue_return_code(status); 108f1a: 83 ec 0c sub $0xc,%esp 108f1d: 53 push %ebx 108f1e: e8 0d 00 00 00 call 108f30 <_Message_queue_Translate_core_message_queue_return_code> 108f23: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 108f26: 8d 65 f8 lea -0x8(%ebp),%esp 108f29: 5b pop %ebx 108f2a: 5e pop %esi 108f2b: c9 leave 108f2c: c3 ret =============================================================================== 00111040 : rtems_status_code rtems_message_queue_urgent( Objects_Id id, const void *buffer, size_t size ) { 111040: 55 push %ebp 111041: 89 e5 mov %esp,%ebp 111043: 56 push %esi 111044: 53 push %ebx 111045: 83 ec 10 sub $0x10,%esp 111048: 8b 5d 08 mov 0x8(%ebp),%ebx 11104b: 8b 75 0c mov 0xc(%ebp),%esi register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 11104e: b8 09 00 00 00 mov $0x9,%eax 111053: 85 f6 test %esi,%esi 111055: 74 4f je 1110a6 <== NEVER TAKEN * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 111057: 50 push %eax 111058: 8d 45 f4 lea -0xc(%ebp),%eax 11105b: 50 push %eax 11105c: 53 push %ebx 11105d: 68 38 4a 13 00 push $0x134a38 111062: e8 91 3f 00 00 call 114ff8 <_Objects_Get> 111067: 89 c2 mov %eax,%edx return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 111069: 83 c4 10 add $0x10,%esp 11106c: b8 04 00 00 00 mov $0x4,%eax 111071: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 111075: 75 2f jne 1110a6 size_t size 111077: 6a 00 push $0x0 111079: 6a 00 push $0x0 11107b: 68 00 00 00 80 push $0x80000000 111080: 6a 00 push $0x0 111082: 53 push %ebx 111083: ff 75 10 pushl 0x10(%ebp) 111086: 56 push %esi 111087: 8d 42 14 lea 0x14(%edx),%eax 11108a: 50 push %eax 11108b: e8 6c 2d 00 00 call 113dfc <_CORE_message_queue_Submit> 111090: 89 c3 mov %eax,%ebx id, MESSAGE_QUEUE_MP_HANDLER, FALSE, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 111092: 83 c4 20 add $0x20,%esp 111095: e8 1e 47 00 00 call 1157b8 <_Thread_Enable_dispatch> /* * Since this API does not allow for blocking sends, we can directly * return the returned status. */ return _Message_queue_Translate_core_message_queue_return_code(status); 11109a: 83 ec 0c sub $0xc,%esp 11109d: 53 push %ebx 11109e: e8 8d ff ff ff call 111030 <_Message_queue_Translate_core_message_queue_return_code> 1110a3: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1110a6: 8d 65 f8 lea -0x8(%ebp),%esp 1110a9: 5b pop %ebx 1110aa: 5e pop %esi 1110ab: c9 leave 1110ac: c3 ret =============================================================================== 00109448 : */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) { 109448: 55 push %ebp 109449: 89 e5 mov %esp,%ebp 10944b: 57 push %edi 10944c: 56 push %esi 10944d: 53 push %ebx 10944e: 83 ec 1c sub $0x1c,%esp 109451: 8b 7d 0c mov 0xc(%ebp),%edi Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 109454: b8 09 00 00 00 mov $0x9,%eax 109459: 85 ff test %edi,%edi 10945b: 74 50 je 1094ad <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10945d: 8b 5d 08 mov 0x8(%ebp),%ebx 109460: 85 db test %ebx,%ebx 109462: 75 08 jne 10946c 109464: a1 4c 0d 12 00 mov 0x120d4c,%eax 109469: 8b 58 08 mov 0x8(%eax),%ebx information = _Objects_Get_information_id( tmpId ); 10946c: 83 ec 0c sub $0xc,%esp 10946f: 53 push %ebx 109470: e8 b3 16 00 00 call 10ab28 <_Objects_Get_information_id> 109475: 89 c6 mov %eax,%esi if ( !information ) 109477: 83 c4 10 add $0x10,%esp 10947a: 85 c0 test %eax,%eax 10947c: 74 2a je 1094a8 return RTEMS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &location ); 10947e: 51 push %ecx 10947f: 8d 45 f0 lea -0x10(%ebp),%eax 109482: 50 push %eax 109483: 53 push %ebx 109484: 56 push %esi 109485: e8 36 18 00 00 call 10acc0 <_Objects_Get> switch ( location ) { 10948a: 83 c4 10 add $0x10,%esp 10948d: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 109491: 75 15 jne 1094a8 case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); 109493: 52 push %edx 109494: 57 push %edi 109495: 50 push %eax 109496: 56 push %esi 109497: e8 e0 19 00 00 call 10ae7c <_Objects_Set_name> _Thread_Enable_dispatch(); 10949c: e8 bf 20 00 00 call 10b560 <_Thread_Enable_dispatch> 1094a1: 31 c0 xor %eax,%eax 1094a3: 83 c4 10 add $0x10,%esp 1094a6: eb 05 jmp 1094ad return RTEMS_SUCCESSFUL; 1094a8: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1094ad: 8d 65 f4 lea -0xc(%ebp),%esp 1094b0: 5b pop %ebx 1094b1: 5e pop %esi 1094b2: 5f pop %edi 1094b3: c9 leave 1094b4: c3 ret =============================================================================== 00107028 : void rtems_panic( const char *printf_format, ... ) { 107028: 55 push %ebp <== NOT EXECUTED 107029: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10702b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10702e: 8d 4d 0c lea 0xc(%ebp),%ecx <== NOT EXECUTED va_list arglist; va_start(arglist, printf_format); (void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist); 107031: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 107034: b8 00 00 00 20 mov $0x20000000,%eax <== NOT EXECUTED 107039: e8 83 fe ff ff call 106ec1 <== NOT EXECUTED va_end(arglist); } 10703e: c9 leave <== NOT EXECUTED 10703f: c3 ret <== NOT EXECUTED =============================================================================== 001110b0 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, Objects_Id *id ) { 1110b0: 55 push %ebp 1110b1: 89 e5 mov %esp,%ebp 1110b3: 57 push %edi 1110b4: 56 push %esi 1110b5: 53 push %ebx 1110b6: 83 ec 0c sub $0xc,%esp 1110b9: 8b 7d 10 mov 0x10(%ebp),%edi 1110bc: 8b 75 14 mov 0x14(%ebp),%esi register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 1110bf: b8 03 00 00 00 mov $0x3,%eax 1110c4: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 1110c8: 0f 84 c9 00 00 00 je 111197 return RTEMS_INVALID_NAME; if ( !starting_address ) 1110ce: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 1110d2: 0f 84 b3 00 00 00 je 11118b <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( !id ) 1110d8: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp) 1110dc: 0f 84 a9 00 00 00 je 11118b <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 1110e2: 85 ff test %edi,%edi 1110e4: 0f 84 a8 00 00 00 je 111192 1110ea: 85 f6 test %esi,%esi 1110ec: 0f 84 a0 00 00 00 je 111192 1110f2: 39 f7 cmp %esi,%edi 1110f4: 0f 82 98 00 00 00 jb 111192 1110fa: f7 c6 03 00 00 00 test $0x3,%esi 111100: 0f 85 8c 00 00 00 jne 111192 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 111106: f6 45 0c 03 testb $0x3,0xc(%ebp) 11110a: 75 7f jne 11118b /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 11110c: a1 38 41 13 00 mov 0x134138,%eax 111111: 40 inc %eax 111112: a3 38 41 13 00 mov %eax,0x134138 * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of 111117: 83 ec 0c sub $0xc,%esp 11111a: 68 6c 3f 13 00 push $0x133f6c 11111f: e8 54 3a 00 00 call 114b78 <_Objects_Allocate> 111124: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 111126: 83 c4 10 add $0x10,%esp 111129: 85 c0 test %eax,%eax 11112b: 75 0c jne 111139 _Thread_Enable_dispatch(); 11112d: e8 86 46 00 00 call 1157b8 <_Thread_Enable_dispatch> 111132: b8 05 00 00 00 mov $0x5,%eax 111137: eb 5e jmp 111197 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 111139: 8b 45 0c mov 0xc(%ebp),%eax 11113c: 89 43 10 mov %eax,0x10(%ebx) the_partition->length = length; 11113f: 89 7b 14 mov %edi,0x14(%ebx) the_partition->buffer_size = buffer_size; 111142: 89 73 18 mov %esi,0x18(%ebx) the_partition->attribute_set = attribute_set; 111145: 8b 45 18 mov 0x18(%ebp),%eax 111148: 89 43 1c mov %eax,0x1c(%ebx) the_partition->number_of_used_blocks = 0; 11114b: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) _Chain_Initialize( &the_partition->Memory, starting_address, 111152: 56 push %esi 111153: 89 f8 mov %edi,%eax 111155: 31 d2 xor %edx,%edx 111157: f7 f6 div %esi 111159: 50 push %eax 11115a: ff 75 0c pushl 0xc(%ebp) 11115d: 8d 43 24 lea 0x24(%ebx),%eax 111160: 50 push %eax 111161: e8 6a 29 00 00 call 113ad0 <_Chain_Initialize> 111166: 8b 4b 08 mov 0x8(%ebx),%ecx 111169: 0f b7 d1 movzwl %cx,%edx 11116c: a1 88 3f 13 00 mov 0x133f88,%eax 111171: 89 1c 90 mov %ebx,(%eax,%edx,4) 111174: 8b 45 08 mov 0x8(%ebp),%eax 111177: 89 43 0c mov %eax,0xc(%ebx) &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 11117a: 8b 45 1c mov 0x1c(%ebp),%eax 11117d: 89 08 mov %ecx,(%eax) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 11117f: e8 34 46 00 00 call 1157b8 <_Thread_Enable_dispatch> 111184: 31 c0 xor %eax,%eax 111186: 83 c4 10 add $0x10,%esp 111189: eb 0c jmp 111197 return RTEMS_SUCCESSFUL; 11118b: b8 09 00 00 00 mov $0x9,%eax 111190: eb 05 jmp 111197 111192: b8 08 00 00 00 mov $0x8,%eax } 111197: 8d 65 f4 lea -0xc(%ebp),%esp 11119a: 5b pop %ebx 11119b: 5e pop %esi 11119c: 5f pop %edi 11119d: c9 leave 11119e: c3 ret =============================================================================== 00111204 : rtems_status_code rtems_partition_get_buffer( Objects_Id id, void **buffer ) { 111204: 55 push %ebp 111205: 89 e5 mov %esp,%ebp 111207: 57 push %edi 111208: 56 push %esi 111209: 53 push %ebx 11120a: 83 ec 1c sub $0x1c,%esp 11120d: 8b 7d 0c mov 0xc(%ebp),%edi register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 111210: b8 09 00 00 00 mov $0x9,%eax 111215: 85 ff test %edi,%edi 111217: 74 4f je 111268 <== NEVER TAKEN ); /** * This routine returns the block of memory which begins * at @a starting_address to @a the_heap. Any coalescing which is * possible with the freeing of this routine is performed. 111219: 50 push %eax 11121a: 8d 45 f0 lea -0x10(%ebp),%eax 11121d: 50 push %eax 11121e: ff 75 08 pushl 0x8(%ebp) 111221: 68 6c 3f 13 00 push $0x133f6c 111226: e8 cd 3d 00 00 call 114ff8 <_Objects_Get> 11122b: 89 c3 mov %eax,%ebx return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 11122d: 83 c4 10 add $0x10,%esp 111230: b8 04 00 00 00 mov $0x4,%eax 111235: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 111239: 75 2d jne 111268 #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of 11123b: 83 ec 0c sub $0xc,%esp 11123e: 8d 43 24 lea 0x24(%ebx),%eax 111241: 50 push %eax 111242: e8 61 28 00 00 call 113aa8 <_Chain_Get> 111247: 89 c6 mov %eax,%esi case OBJECTS_LOCAL: the_buffer = _Partition_Allocate_buffer( the_partition ); if ( the_buffer ) { 111249: 83 c4 10 add $0x10,%esp 11124c: 85 c0 test %eax,%eax 11124e: 74 0e je 11125e the_partition->number_of_used_blocks += 1; 111250: ff 43 20 incl 0x20(%ebx) _Thread_Enable_dispatch(); 111253: e8 60 45 00 00 call 1157b8 <_Thread_Enable_dispatch> *buffer = the_buffer; 111258: 89 37 mov %esi,(%edi) 11125a: 31 c0 xor %eax,%eax 11125c: eb 0a jmp 111268 return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 11125e: e8 55 45 00 00 call 1157b8 <_Thread_Enable_dispatch> 111263: b8 0d 00 00 00 mov $0xd,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111268: 8d 65 f4 lea -0xc(%ebp),%esp 11126b: 5b pop %ebx 11126c: 5e pop %esi 11126d: 5f pop %edi 11126e: c9 leave 11126f: c3 ret =============================================================================== 001107e4 : void *internal_start, void *external_start, uint32_t length, Objects_Id *id ) { 1107e4: 55 push %ebp 1107e5: 89 e5 mov %esp,%ebp 1107e7: 57 push %edi 1107e8: 56 push %esi 1107e9: 53 push %ebx 1107ea: 83 ec 0c sub $0xc,%esp 1107ed: 8b 75 0c mov 0xc(%ebp),%esi 1107f0: 8b 7d 10 mov 0x10(%ebp),%edi register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name) ) 1107f3: b8 03 00 00 00 mov $0x3,%eax 1107f8: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 1107fc: 74 6f je 11086d return RTEMS_INVALID_NAME; if ( !id ) 1107fe: 83 7d 18 00 cmpl $0x0,0x18(%ebp) 110802: 74 64 je 110868 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( internal_start ) || 110804: 89 f8 mov %edi,%eax 110806: 09 f0 or %esi,%eax 110808: a8 03 test $0x3,%al 11080a: 75 5c jne 110868 /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 11080c: a1 38 41 13 00 mov 0x134138,%eax 110811: 40 inc %eax 110812: a3 38 41 13 00 mov %eax,0x134138 #ifdef __cplusplus extern "C" { #endif /** * This routine initializes @a the_heap record to manage the 110817: 83 ec 0c sub $0xc,%esp 11081a: 68 2c 3f 13 00 push $0x133f2c 11081f: e8 54 43 00 00 call 114b78 <_Objects_Allocate> 110824: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { 110826: 83 c4 10 add $0x10,%esp 110829: 85 c0 test %eax,%eax 11082b: 75 0c jne 110839 _Thread_Enable_dispatch(); 11082d: e8 86 4f 00 00 call 1157b8 <_Thread_Enable_dispatch> 110832: b8 05 00 00 00 mov $0x5,%eax 110837: eb 34 jmp 11086d return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; 110839: 89 70 10 mov %esi,0x10(%eax) the_port->external_base = external_start; 11083c: 89 78 14 mov %edi,0x14(%eax) the_port->length = length - 1; 11083f: 8b 45 14 mov 0x14(%ebp),%eax 110842: 48 dec %eax 110843: 89 43 18 mov %eax,0x18(%ebx) 110846: 8b 4b 08 mov 0x8(%ebx),%ecx 110849: 0f b7 d1 movzwl %cx,%edx 11084c: a1 48 3f 13 00 mov 0x133f48,%eax 110851: 89 1c 90 mov %ebx,(%eax,%edx,4) 110854: 8b 45 08 mov 0x8(%ebp),%eax 110857: 89 43 0c mov %eax,0xc(%ebx) &_Dual_ported_memory_Information, &the_port->Object, (Objects_Name) name ); *id = the_port->Object.id; 11085a: 8b 45 18 mov 0x18(%ebp),%eax 11085d: 89 08 mov %ecx,(%eax) _Thread_Enable_dispatch(); 11085f: e8 54 4f 00 00 call 1157b8 <_Thread_Enable_dispatch> 110864: 31 c0 xor %eax,%eax 110866: eb 05 jmp 11086d return RTEMS_SUCCESSFUL; 110868: b8 09 00 00 00 mov $0x9,%eax } 11086d: 8d 65 f4 lea -0xc(%ebp),%esp 110870: 5b pop %ebx 110871: 5e pop %esi 110872: 5f pop %edi 110873: c9 leave 110874: c3 ret =============================================================================== 001108cc : rtems_status_code rtems_port_external_to_internal( Objects_Id id, void *external, void **internal ) { 1108cc: 55 push %ebp 1108cd: 89 e5 mov %esp,%ebp 1108cf: 56 push %esi 1108d0: 53 push %ebx 1108d1: 83 ec 10 sub $0x10,%esp 1108d4: 8b 75 0c mov 0xc(%ebp),%esi 1108d7: 8b 5d 10 mov 0x10(%ebp),%ebx register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !internal ) 1108da: b8 09 00 00 00 mov $0x9,%eax 1108df: 85 db test %ebx,%ebx 1108e1: 74 3c je 11091f <== NEVER TAKEN * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add 1108e3: 50 push %eax 1108e4: 8d 45 f4 lea -0xc(%ebp),%eax 1108e7: 50 push %eax 1108e8: ff 75 08 pushl 0x8(%ebp) 1108eb: 68 2c 3f 13 00 push $0x133f2c 1108f0: e8 03 47 00 00 call 114ff8 <_Objects_Get> 1108f5: 89 c1 mov %eax,%ecx return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 1108f7: 83 c4 10 add $0x10,%esp 1108fa: b8 04 00 00 00 mov $0x4,%eax 1108ff: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 110903: 75 1a jne 11091f * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 110905: 89 f2 mov %esi,%edx 110907: 2b 51 14 sub 0x14(%ecx),%edx case OBJECTS_LOCAL: ending = _Addresses_Subtract( external, the_port->external_base ); if ( ending > the_port->length ) 11090a: 3b 51 18 cmp 0x18(%ecx),%edx 11090d: 76 04 jbe 110913 *internal = external; 11090f: 89 33 mov %esi,(%ebx) 110911: eb 05 jmp 110918 else *internal = _Addresses_Add_offset( the_port->internal_base, 110913: 03 51 10 add 0x10(%ecx),%edx 110916: 89 13 mov %edx,(%ebx) ending ); _Thread_Enable_dispatch(); 110918: e8 9b 4e 00 00 call 1157b8 <_Thread_Enable_dispatch> 11091d: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11091f: 8d 65 f8 lea -0x8(%ebp),%esp 110922: 5b pop %ebx 110923: 5e pop %esi 110924: c9 leave 110925: c3 ret =============================================================================== 0011094c : rtems_status_code rtems_port_internal_to_external( Objects_Id id, void *internal, void **external ) { 11094c: 55 push %ebp 11094d: 89 e5 mov %esp,%ebp 11094f: 56 push %esi 110950: 53 push %ebx 110951: 83 ec 10 sub $0x10,%esp 110954: 8b 75 0c mov 0xc(%ebp),%esi 110957: 8b 5d 10 mov 0x10(%ebp),%ebx register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !external ) 11095a: b8 09 00 00 00 mov $0x9,%eax 11095f: 85 db test %ebx,%ebx 110961: 74 3c je 11099f <== NEVER TAKEN * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add 110963: 50 push %eax 110964: 8d 45 f4 lea -0xc(%ebp),%eax 110967: 50 push %eax 110968: ff 75 08 pushl 0x8(%ebp) 11096b: 68 2c 3f 13 00 push $0x133f2c 110970: e8 83 46 00 00 call 114ff8 <_Objects_Get> 110975: 89 c1 mov %eax,%ecx return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 110977: 83 c4 10 add $0x10,%esp 11097a: b8 04 00 00 00 mov $0x4,%eax 11097f: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 110983: 75 1a jne 11099f * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 110985: 89 f2 mov %esi,%edx 110987: 2b 51 10 sub 0x10(%ecx),%edx case OBJECTS_LOCAL: ending = _Addresses_Subtract( internal, the_port->internal_base ); if ( ending > the_port->length ) 11098a: 3b 51 18 cmp 0x18(%ecx),%edx 11098d: 76 04 jbe 110993 *external = internal; 11098f: 89 33 mov %esi,(%ebx) 110991: eb 05 jmp 110998 else *external = _Addresses_Add_offset( the_port->external_base, 110993: 03 51 14 add 0x14(%ecx),%edx 110996: 89 13 mov %edx,(%ebx) ending ); _Thread_Enable_dispatch(); 110998: e8 1b 4e 00 00 call 1157b8 <_Thread_Enable_dispatch> 11099d: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11099f: 8d 65 f8 lea -0x8(%ebp),%esp 1109a2: 5b pop %ebx 1109a3: 5e pop %esi 1109a4: c9 leave 1109a5: c3 ret =============================================================================== 00109ce4 : rtems_status_code rtems_rate_monotonic_create( rtems_name name, Objects_Id *id ) { 109ce4: 55 push %ebp 109ce5: 89 e5 mov %esp,%ebp 109ce7: 57 push %edi 109ce8: 56 push %esi 109ce9: 53 push %ebx 109cea: 83 ec 0c sub $0xc,%esp 109ced: 8b 75 08 mov 0x8(%ebp),%esi Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 109cf0: b8 03 00 00 00 mov $0x3,%eax 109cf5: 85 f6 test %esi,%esi 109cf7: 0f 84 ac 00 00 00 je 109da9 return RTEMS_INVALID_NAME; if ( !id ) 109cfd: b8 09 00 00 00 mov $0x9,%eax 109d02: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 109d06: 0f 84 9d 00 00 00 je 109da9 <== NEVER TAKEN /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109d0c: a1 3c 1c 12 00 mov 0x121c3c,%eax 109d11: 40 inc %eax 109d12: a3 3c 1c 12 00 mov %eax,0x121c3c #ifdef __cplusplus extern "C" { #endif /** 109d17: 83 ec 0c sub $0xc,%esp 109d1a: 68 44 1b 12 00 push $0x121b44 109d1f: e8 84 1b 00 00 call 10b8a8 <_Objects_Allocate> 109d24: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { 109d26: 83 c4 10 add $0x10,%esp 109d29: 85 c0 test %eax,%eax 109d2b: 75 0c jne 109d39 _Thread_Enable_dispatch(); 109d2d: e8 52 28 00 00 call 10c584 <_Thread_Enable_dispatch> 109d32: b8 05 00 00 00 mov $0x5,%eax 109d37: eb 70 jmp 109da9 return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 109d39: a1 fc 1c 12 00 mov 0x121cfc,%eax 109d3e: 89 43 50 mov %eax,0x50(%ebx) the_period->state = RATE_MONOTONIC_INACTIVE; 109d41: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 109d48: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) * @param[in] the_heap is the heap to operate upon 109d4f: c7 43 2c 00 00 00 00 movl $0x0,0x2c(%ebx) * @param[in] starting_address is the starting address of the memory for 109d56: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx) * the heap 109d5d: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL ); _Rate_monotonic_Reset_statistics( the_period ); 109d64: 8d 7b 54 lea 0x54(%ebx),%edi 109d67: b9 0e 00 00 00 mov $0xe,%ecx 109d6c: 31 c0 xor %eax,%eax 109d6e: f3 ab rep stos %eax,%es:(%edi) 109d70: c7 43 5c ff ff ff 7f movl $0x7fffffff,0x5c(%ebx) 109d77: c7 43 60 ff ff ff 7f movl $0x7fffffff,0x60(%ebx) 109d7e: c7 43 74 ff ff ff 7f movl $0x7fffffff,0x74(%ebx) 109d85: c7 43 78 ff ff ff 7f movl $0x7fffffff,0x78(%ebx) 109d8c: 8b 4b 08 mov 0x8(%ebx),%ecx 109d8f: 0f b7 d1 movzwl %cx,%edx 109d92: a1 60 1b 12 00 mov 0x121b60,%eax 109d97: 89 1c 90 mov %ebx,(%eax,%edx,4) 109d9a: 89 73 0c mov %esi,0xc(%ebx) &_Rate_monotonic_Information, &the_period->Object, (Objects_Name) name ); *id = the_period->Object.id; 109d9d: 8b 45 0c mov 0xc(%ebp),%eax 109da0: 89 08 mov %ecx,(%eax) _Thread_Enable_dispatch(); 109da2: e8 dd 27 00 00 call 10c584 <_Thread_Enable_dispatch> 109da7: 31 c0 xor %eax,%eax return RTEMS_SUCCESSFUL; } 109da9: 8d 65 f4 lea -0xc(%ebp),%esp 109dac: 5b pop %ebx 109dad: 5e pop %esi 109dae: 5f pop %edi 109daf: c9 leave 109db0: c3 ret =============================================================================== 0010f338 : rtems_status_code rtems_rate_monotonic_get_statistics( Objects_Id id, rtems_rate_monotonic_period_statistics *statistics ) { 10f338: 55 push %ebp 10f339: 89 e5 mov %esp,%ebp 10f33b: 57 push %edi 10f33c: 56 push %esi 10f33d: 83 ec 20 sub $0x20,%esp 10f340: 8b 7d 0c mov 0xc(%ebp),%edi Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 10f343: b8 09 00 00 00 mov $0x9,%eax 10f348: 85 ff test %edi,%edi 10f34a: 74 33 je 10f37f <== NEVER TAKEN /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 10f34c: 50 push %eax 10f34d: 8d 45 f4 lea -0xc(%ebp),%eax 10f350: 50 push %eax 10f351: ff 75 08 pushl 0x8(%ebp) 10f354: 68 44 1b 12 00 push $0x121b44 10f359: e8 66 ca ff ff call 10bdc4 <_Objects_Get> 10f35e: 89 c2 mov %eax,%edx return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 10f360: 83 c4 10 add $0x10,%esp 10f363: b8 04 00 00 00 mov $0x4,%eax 10f368: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10f36c: 75 11 jne 10f37f case OBJECTS_LOCAL: *statistics = the_period->Statistics; 10f36e: 8d 72 54 lea 0x54(%edx),%esi 10f371: b9 0e 00 00 00 mov $0xe,%ecx 10f376: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Thread_Enable_dispatch(); 10f378: e8 07 d2 ff ff call 10c584 <_Thread_Enable_dispatch> 10f37d: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f37f: 8d 65 f8 lea -0x8(%ebp),%esp 10f382: 5e pop %esi 10f383: 5f pop %edi 10f384: c9 leave 10f385: c3 ret =============================================================================== 0010f388 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 10f388: 55 push %ebp 10f389: 89 e5 mov %esp,%ebp 10f38b: 57 push %edi 10f38c: 56 push %esi 10f38d: 53 push %ebx 10f38e: 83 ec 1c sub $0x1c,%esp 10f391: 8b 75 0c mov 0xc(%ebp),%esi Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 10f394: b8 09 00 00 00 mov $0x9,%eax 10f399: 85 f6 test %esi,%esi 10f39b: 0f 84 91 00 00 00 je 10f432 <== NEVER TAKEN 10f3a1: 50 push %eax 10f3a2: 8d 45 f0 lea -0x10(%ebp),%eax 10f3a5: 50 push %eax 10f3a6: ff 75 08 pushl 0x8(%ebp) 10f3a9: 68 44 1b 12 00 push $0x121b44 10f3ae: e8 11 ca ff ff call 10bdc4 <_Objects_Get> 10f3b3: 89 c7 mov %eax,%edi return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 10f3b5: 83 c4 10 add $0x10,%esp 10f3b8: b8 04 00 00 00 mov $0x4,%eax 10f3bd: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 10f3c1: 75 6f jne 10f432 case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 10f3c3: 8b 47 50 mov 0x50(%edi),%eax 10f3c6: 31 d2 xor %edx,%edx 10f3c8: 85 c0 test %eax,%eax 10f3ca: 74 03 je 10f3cf <== NEVER TAKEN 10f3cc: 8b 50 08 mov 0x8(%eax),%edx 10f3cf: 89 16 mov %edx,(%esi) status->state = the_period->state; 10f3d1: 8b 47 38 mov 0x38(%edi),%eax 10f3d4: 89 46 04 mov %eax,0x4(%esi) if ( status->state == RATE_MONOTONIC_INACTIVE ) { 10f3d7: 85 c0 test %eax,%eax 10f3d9: 75 1e jne 10f3f9 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS status->since_last_period.tv_sec = 0; 10f3db: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) status->since_last_period.tv_nsec = 0; 10f3e2: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) #else status->since_last_period = 0; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS status->executed_since_last_period.tv_sec = 0; 10f3e9: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi) status->executed_since_last_period.tv_nsec = 0; 10f3f0: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) 10f3f7: eb 32 jmp 10f42b * This lets them share one single invocation of _TOD_Get_uptime(). */ #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) struct timespec uptime; _TOD_Get_uptime( &uptime ); 10f3f9: 83 ec 0c sub $0xc,%esp 10f3fc: 8d 5d e8 lea -0x18(%ebp),%ebx 10f3ff: 53 push %ebx 10f400: e8 57 c1 ff ff call 10b55c <_TOD_Get_uptime> #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 10f405: 83 c4 0c add $0xc,%esp 10f408: 8d 46 08 lea 0x8(%esi),%eax 10f40b: 50 push %eax 10f40c: 53 push %ebx 10f40d: 8d 47 44 lea 0x44(%edi),%eax 10f410: 50 push %eax 10f411: e8 86 de ff ff call 10d29c <_Timespec_Subtract> status->since_last_period = _Watchdog_Ticks_since_boot - the_period->time_at_period; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _Timespec_Subtract( 10f416: 83 c4 0c add $0xc,%esp 10f419: 8d 46 10 lea 0x10(%esi),%eax 10f41c: 50 push %eax 10f41d: 53 push %ebx 10f41e: 68 04 1d 12 00 push $0x121d04 10f423: e8 74 de ff ff call 10d29c <_Timespec_Subtract> 10f428: 83 c4 10 add $0x10,%esp the_period->owner->cpu_time_used - the_period->owner_executed_at_period; #endif } _Thread_Enable_dispatch(); 10f42b: e8 54 d1 ff ff call 10c584 <_Thread_Enable_dispatch> 10f430: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f432: 8d 65 f4 lea -0xc(%ebp),%esp 10f435: 5b pop %ebx 10f436: 5e pop %esi 10f437: 5f pop %edi 10f438: c9 leave 10f439: c3 ret =============================================================================== 00109f7e : rtems_status_code rtems_rate_monotonic_period( Objects_Id id, rtems_interval length ) { 109f7e: 55 push %ebp 109f7f: 89 e5 mov %esp,%ebp 109f81: 57 push %edi 109f82: 56 push %esi 109f83: 53 push %ebx 109f84: 83 ec 20 sub $0x20,%esp 109f87: 8b 7d 0c mov 0xc(%ebp),%edi /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 109f8a: 8d 45 f0 lea -0x10(%ebp),%eax 109f8d: 50 push %eax 109f8e: ff 75 08 pushl 0x8(%ebp) 109f91: 68 44 1b 12 00 push $0x121b44 109f96: e8 29 1e 00 00 call 10bdc4 <_Objects_Get> 109f9b: 89 c3 mov %eax,%ebx rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 109f9d: 83 c4 10 add $0x10,%esp 109fa0: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 109fa4: 0f 85 44 01 00 00 jne 10a0ee case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 109faa: 8b 40 50 mov 0x50(%eax),%eax 109fad: 3b 05 fc 1c 12 00 cmp 0x121cfc,%eax 109fb3: 74 0f je 109fc4 _Thread_Enable_dispatch(); 109fb5: e8 ca 25 00 00 call 10c584 <_Thread_Enable_dispatch> 109fba: bb 17 00 00 00 mov $0x17,%ebx 109fbf: e9 2f 01 00 00 jmp 10a0f3 return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 109fc4: 85 ff test %edi,%edi 109fc6: 75 21 jne 109fe9 switch ( the_period->state ) { 109fc8: 8b 43 38 mov 0x38(%ebx),%eax 109fcb: bb 0b 00 00 00 mov $0xb,%ebx 109fd0: 85 c0 test %eax,%eax 109fd2: 74 0b je 109fdf 109fd4: 83 e8 03 sub $0x3,%eax 109fd7: 83 f8 02 cmp $0x2,%eax 109fda: 19 db sbb %ebx,%ebx 109fdc: 83 e3 06 and $0x6,%ebx case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 109fdf: e8 a0 25 00 00 call 10c584 <_Thread_Enable_dispatch> 109fe4: e9 0a 01 00 00 jmp 10a0f3 return( return_value ); } _ISR_Disable( level ); 109fe9: 9c pushf 109fea: fa cli 109feb: 5e pop %esi switch ( the_period->state ) { 109fec: 8b 43 38 mov 0x38(%ebx),%eax 109fef: 83 f8 02 cmp $0x2,%eax 109ff2: 74 60 je 10a054 109ff4: 83 f8 04 cmp $0x4,%eax 109ff7: 0f 84 ba 00 00 00 je 10a0b7 109ffd: 85 c0 test %eax,%eax 109fff: 0f 85 e9 00 00 00 jne 10a0ee <== NEVER TAKEN case RATE_MONOTONIC_INACTIVE: { _ISR_Enable( level ); 10a005: 56 push %esi 10a006: 9d popf /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 10a007: 83 ec 0c sub $0xc,%esp 10a00a: 53 push %ebx 10a00b: e8 c8 fd ff ff call 109dd8 <_Rate_monotonic_Initiate_statistics> the_period->state = RATE_MONOTONIC_ACTIVE; 10a010: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx) * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10a017: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) * @param[in] the_heap is the heap to operate upon 10a01e: c7 43 2c 14 a3 10 00 movl $0x10a314,0x2c(%ebx) * @param[in] starting_address is the starting address of the memory for 10a025: 8b 45 08 mov 0x8(%ebp),%eax 10a028: 89 43 30 mov %eax,0x30(%ebx) * the heap 10a02b: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 10a032: 89 7b 4c mov %edi,0x4c(%ebx) * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10a035: 89 7b 1c mov %edi,0x1c(%ebx) void *starting_address, size_t *size 10a038: 58 pop %eax 10a039: 5a pop %edx 10a03a: 8d 43 10 lea 0x10(%ebx),%eax 10a03d: 50 push %eax 10a03e: 68 1c 1d 12 00 push $0x121d1c 10a043: e8 98 34 00 00 call 10d4e0 <_Watchdog_Insert> _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10a048: e8 37 25 00 00 call 10c584 <_Thread_Enable_dispatch> 10a04d: 31 db xor %ebx,%ebx 10a04f: e9 95 00 00 00 jmp 10a0e9 case RATE_MONOTONIC_ACTIVE: /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 10a054: 83 ec 0c sub $0xc,%esp 10a057: 53 push %ebx 10a058: e8 e3 fd ff ff call 109e40 <_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; 10a05d: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) the_period->next_length = length; 10a064: 89 7b 4c mov %edi,0x4c(%ebx) _ISR_Enable( level ); 10a067: 56 push %esi 10a068: 9d popf _Thread_Executing->Wait.id = the_period->Object.id; 10a069: 8b 15 fc 1c 12 00 mov 0x121cfc,%edx 10a06f: 8b 43 08 mov 0x8(%ebx),%eax 10a072: 89 42 20 mov %eax,0x20(%edx) _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10a075: 5e pop %esi 10a076: 5f pop %edi 10a077: 68 00 40 00 00 push $0x4000 10a07c: 52 push %edx 10a07d: e8 1e 2d 00 00 call 10cda0 <_Thread_Set_state> /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 10a082: 9c pushf 10a083: fa cli 10a084: 58 pop %eax local_state = the_period->state; 10a085: 8b 53 38 mov 0x38(%ebx),%edx the_period->state = RATE_MONOTONIC_ACTIVE; 10a088: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx) _ISR_Enable( level ); 10a08f: 50 push %eax 10a090: 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 ) 10a091: 83 c4 10 add $0x10,%esp 10a094: 83 fa 03 cmp $0x3,%edx 10a097: 75 15 jne 10a0ae <== ALWAYS TAKEN _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10a099: 51 push %ecx <== NOT EXECUTED 10a09a: 51 push %ecx <== NOT EXECUTED 10a09b: 68 00 40 00 00 push $0x4000 <== NOT EXECUTED 10a0a0: ff 35 fc 1c 12 00 pushl 0x121cfc <== NOT EXECUTED 10a0a6: e8 59 21 00 00 call 10c204 <_Thread_Clear_state> <== NOT EXECUTED 10a0ab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 10a0ae: e8 d1 24 00 00 call 10c584 <_Thread_Enable_dispatch> 10a0b3: 31 db xor %ebx,%ebx 10a0b5: eb 3c jmp 10a0f3 case RATE_MONOTONIC_EXPIRED: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 10a0b7: 83 ec 0c sub $0xc,%esp 10a0ba: 53 push %ebx 10a0bb: e8 80 fd ff ff call 109e40 <_Rate_monotonic_Update_statistics> _ISR_Enable( level ); 10a0c0: 56 push %esi 10a0c1: 9d popf the_period->state = RATE_MONOTONIC_ACTIVE; 10a0c2: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx) the_period->next_length = length; 10a0c9: 89 7b 4c mov %edi,0x4c(%ebx) * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10a0cc: 89 7b 1c mov %edi,0x1c(%ebx) void *starting_address, size_t *size 10a0cf: 58 pop %eax 10a0d0: 5a pop %edx 10a0d1: 8d 43 10 lea 0x10(%ebx),%eax 10a0d4: 50 push %eax 10a0d5: 68 1c 1d 12 00 push $0x121d1c 10a0da: e8 01 34 00 00 call 10d4e0 <_Watchdog_Insert> _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10a0df: e8 a0 24 00 00 call 10c584 <_Thread_Enable_dispatch> 10a0e4: bb 06 00 00 00 mov $0x6,%ebx 10a0e9: 83 c4 10 add $0x10,%esp 10a0ec: eb 05 jmp 10a0f3 return RTEMS_TIMEOUT; 10a0ee: bb 04 00 00 00 mov $0x4,%ebx case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a0f3: 89 d8 mov %ebx,%eax 10a0f5: 8d 65 f4 lea -0xc(%ebp),%esp 10a0f8: 5b pop %ebx 10a0f9: 5e pop %esi 10a0fa: 5f pop %edi 10a0fb: c9 leave 10a0fc: c3 ret =============================================================================== 0010a100 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 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 6c sub $0x6c,%esp 10a109: 8b 75 0c mov 0xc(%ebp),%esi rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 10a10c: 85 f6 test %esi,%esi 10a10e: 0f 84 44 01 00 00 je 10a258 <== NEVER TAKEN return; (*print)( context, "Period information by period\n" ); 10a114: 51 push %ecx 10a115: 51 push %ecx 10a116: 68 e4 a9 11 00 push $0x11a9e4 10a11b: ff 75 08 pushl 0x8(%ebp) 10a11e: ff d6 call *%esi #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 10a120: 58 pop %eax 10a121: 5a pop %edx 10a122: 68 02 aa 11 00 push $0x11aa02 10a127: ff 75 08 pushl 0x8(%ebp) 10a12a: ff d6 call *%esi #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 10a12c: 5f pop %edi 10a12d: 58 pop %eax 10a12e: 68 24 aa 11 00 push $0x11aa24 10a133: ff 75 08 pushl 0x8(%ebp) 10a136: ff d6 call *%esi Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 10a138: 59 pop %ecx 10a139: 5b pop %ebx 10a13a: 68 47 aa 11 00 push $0x11aa47 10a13f: ff 75 08 pushl 0x8(%ebp) 10a142: ff d6 call *%esi #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 10a144: 58 pop %eax 10a145: 5a pop %edx 10a146: 68 92 aa 11 00 push $0x11aa92 10a14b: ff 75 08 pushl 0x8(%ebp) 10a14e: ff d6 call *%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 ; 10a150: 8b 3d 4c 1b 12 00 mov 0x121b4c,%edi 10a156: 83 c4 10 add $0x10,%esp 10a159: e9 ee 00 00 00 jmp 10a24c id <= _Rate_monotonic_Information.maximum_id ; id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 10a15e: 50 push %eax 10a15f: 50 push %eax 10a160: 8d 45 94 lea -0x6c(%ebp),%eax 10a163: 50 push %eax 10a164: 57 push %edi 10a165: e8 ce 51 00 00 call 10f338 if ( status != RTEMS_SUCCESSFUL ) 10a16a: 83 c4 10 add $0x10,%esp 10a16d: 85 c0 test %eax,%eax 10a16f: 0f 85 d6 00 00 00 jne 10a24b continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 10a175: 50 push %eax 10a176: 50 push %eax 10a177: 8d 55 cc lea -0x34(%ebp),%edx 10a17a: 52 push %edx 10a17b: 57 push %edi 10a17c: e8 07 52 00 00 call 10f388 #if defined(RTEMS_DEBUG) if ( status != RTEMS_SUCCESSFUL ) continue; #endif name[ 0 ] = '\0'; 10a181: c6 45 ef 00 movb $0x0,-0x11(%ebp) if ( the_status.owner ) { 10a185: 8b 55 cc mov -0x34(%ebp),%edx 10a188: 83 c4 10 add $0x10,%esp 10a18b: 85 d2 test %edx,%edx 10a18d: 74 10 je 10a19f <== NEVER TAKEN rtems_object_get_name( the_status.owner, sizeof(name), name ); 10a18f: 50 push %eax 10a190: 8d 45 ef lea -0x11(%ebp),%eax 10a193: 50 push %eax 10a194: 6a 05 push $0x5 10a196: 52 push %edx 10a197: e8 04 02 00 00 call 10a3a0 10a19c: 83 c4 10 add $0x10,%esp /* * Print part of report line that is not dependent on granularity */ (*print)( context, 10a19f: 53 push %ebx 10a1a0: 53 push %ebx 10a1a1: ff 75 98 pushl -0x68(%ebp) 10a1a4: ff 75 94 pushl -0x6c(%ebp) 10a1a7: 8d 45 ef lea -0x11(%ebp),%eax 10a1aa: 50 push %eax 10a1ab: 57 push %edi 10a1ac: 68 de aa 11 00 push $0x11aade 10a1b1: ff 75 08 pushl 0x8(%ebp) 10a1b4: ff d6 call *%esi /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 10a1b6: 8b 45 94 mov -0x6c(%ebp),%eax 10a1b9: 83 c4 20 add $0x20,%esp 10a1bc: 85 c0 test %eax,%eax 10a1be: 75 11 jne 10a1d1 (*print)( context, "\n" ); 10a1c0: 51 push %ecx 10a1c1: 51 push %ecx 10a1c2: 68 91 ad 11 00 push $0x11ad91 10a1c7: ff 75 08 pushl 0x8(%ebp) 10a1ca: ff d6 call *%esi 10a1cc: 83 c4 10 add $0x10,%esp 10a1cf: eb 7a jmp 10a24b */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 10a1d1: 52 push %edx 10a1d2: 8d 55 e4 lea -0x1c(%ebp),%edx 10a1d5: 52 push %edx 10a1d6: 50 push %eax 10a1d7: 8d 45 ac lea -0x54(%ebp),%eax 10a1da: 50 push %eax 10a1db: e8 f8 2f 00 00 call 10d1d8 <_Timespec_Divide_by_integer> &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 10a1e0: 8b 45 e8 mov -0x18(%ebp),%eax 10a1e3: bb e8 03 00 00 mov $0x3e8,%ebx 10a1e8: 99 cltd 10a1e9: f7 fb idiv %ebx 10a1eb: 50 push %eax 10a1ec: ff 75 e4 pushl -0x1c(%ebp) 10a1ef: 8b 45 a8 mov -0x58(%ebp),%eax 10a1f2: 99 cltd 10a1f3: f7 fb idiv %ebx 10a1f5: 50 push %eax 10a1f6: ff 75 a4 pushl -0x5c(%ebp) 10a1f9: 8b 45 a0 mov -0x60(%ebp),%eax 10a1fc: 99 cltd 10a1fd: f7 fb idiv %ebx 10a1ff: 50 push %eax 10a200: ff 75 9c pushl -0x64(%ebp) 10a203: 68 f5 aa 11 00 push $0x11aaf5 10a208: ff 75 08 pushl 0x8(%ebp) 10a20b: ff d6 call *%esi * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 10a20d: 83 c4 2c add $0x2c,%esp 10a210: 8d 45 e4 lea -0x1c(%ebp),%eax 10a213: 50 push %eax 10a214: ff 75 94 pushl -0x6c(%ebp) 10a217: 8d 45 c4 lea -0x3c(%ebp),%eax 10a21a: 50 push %eax 10a21b: e8 b8 2f 00 00 call 10d1d8 <_Timespec_Divide_by_integer> &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 10a220: 8b 45 e8 mov -0x18(%ebp),%eax 10a223: 99 cltd 10a224: f7 fb idiv %ebx 10a226: 50 push %eax 10a227: ff 75 e4 pushl -0x1c(%ebp) 10a22a: 8b 45 c0 mov -0x40(%ebp),%eax 10a22d: 99 cltd 10a22e: f7 fb idiv %ebx 10a230: 50 push %eax 10a231: ff 75 bc pushl -0x44(%ebp) 10a234: 8b 45 b8 mov -0x48(%ebp),%eax 10a237: 99 cltd 10a238: f7 fb idiv %ebx 10a23a: 50 push %eax 10a23b: ff 75 b4 pushl -0x4c(%ebp) 10a23e: 68 14 ab 11 00 push $0x11ab14 10a243: ff 75 08 pushl 0x8(%ebp) 10a246: ff d6 call *%esi 10a248: 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++ ) { 10a24b: 47 inc %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 ; id <= _Rate_monotonic_Information.maximum_id ; 10a24c: 3b 3d 50 1b 12 00 cmp 0x121b50,%edi 10a252: 0f 86 06 ff ff ff jbe 10a15e the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 10a258: 8d 65 f4 lea -0xc(%ebp),%esp 10a25b: 5b pop %ebx 10a25c: 5e pop %esi 10a25d: 5f pop %edi 10a25e: c9 leave 10a25f: c3 ret =============================================================================== 00111ac0 : rtems_status_code rtems_region_extend( Objects_Id id, void *starting_address, uint32_t length ) { 111ac0: 55 push %ebp 111ac1: 89 e5 mov %esp,%ebp 111ac3: 57 push %edi 111ac4: 56 push %esi 111ac5: 53 push %ebx 111ac6: 83 ec 1c sub $0x1c,%esp 111ac9: 8b 7d 0c mov 0xc(%ebp),%edi Heap_Extend_status heap_status; Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; Region_Control *the_region; if ( !starting_address ) 111acc: bb 09 00 00 00 mov $0x9,%ebx 111ad1: 85 ff test %edi,%edi 111ad3: 0f 84 82 00 00 00 je 111b5b <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 111ad9: 83 ec 0c sub $0xc,%esp 111adc: ff 35 f0 41 13 00 pushl 0x1341f0 111ae2: e8 29 1f 00 00 call 113a10 <_API_Mutex_Lock> /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 111ae7: 83 c4 0c add $0xc,%esp 111aea: 8d 45 ec lea -0x14(%ebp),%eax 111aed: 50 push %eax 111aee: ff 75 08 pushl 0x8(%ebp) 111af1: 68 ec 3f 13 00 push $0x133fec 111af6: e8 c1 34 00 00 call 114fbc <_Objects_Get_no_protection> 111afb: 89 c6 mov %eax,%esi the_region = _Region_Get( id, &location ); switch ( location ) { 111afd: 83 c4 10 add $0x10,%esp 111b00: 8b 45 ec mov -0x14(%ebp),%eax 111b03: 85 c0 test %eax,%eax 111b05: 74 08 je 111b0f 111b07: bb 04 00 00 00 mov $0x4,%ebx 111b0c: 48 dec %eax 111b0d: eb 25 jmp 111b34 case OBJECTS_LOCAL: heap_status = _Heap_Extend( 111b0f: 8d 45 f0 lea -0x10(%ebp),%eax 111b12: 50 push %eax 111b13: ff 75 10 pushl 0x10(%ebp) 111b16: 57 push %edi 111b17: 8d 46 68 lea 0x68(%esi),%eax 111b1a: 50 push %eax 111b1b: e8 ec 28 00 00 call 11440c <_Heap_Extend> starting_address, length, &amount_extended ); switch ( heap_status ) { 111b20: 83 c4 10 add $0x10,%esp 111b23: bb 09 00 00 00 mov $0x9,%ebx 111b28: 83 f8 01 cmp $0x1,%eax 111b2b: 74 1d je 111b4a 111b2d: 72 09 jb 111b38 case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; the_region->maximum_segment_size += amount_extended; return_status = RTEMS_SUCCESSFUL; break; 111b2f: b3 18 mov $0x18,%bl starting_address, length, &amount_extended ); switch ( heap_status ) { 111b31: 83 f8 02 cmp $0x2,%eax 111b34: 75 0f jne 111b45 <== NEVER TAKEN 111b36: eb 12 jmp 111b4a case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 111b38: 8b 45 f0 mov -0x10(%ebp),%eax 111b3b: 01 46 54 add %eax,0x54(%esi) the_region->maximum_segment_size += amount_extended; 111b3e: 01 46 5c add %eax,0x5c(%esi) 111b41: 31 db xor %ebx,%ebx 111b43: eb 05 jmp 111b4a return_status = RTEMS_SUCCESSFUL; break; 111b45: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111b4a: 83 ec 0c sub $0xc,%esp 111b4d: ff 35 f0 41 13 00 pushl 0x1341f0 111b53: e8 00 1f 00 00 call 113a58 <_API_Mutex_Unlock> 111b58: 83 c4 10 add $0x10,%esp return return_status; } 111b5b: 89 d8 mov %ebx,%eax 111b5d: 8d 65 f4 lea -0xc(%ebp),%esp 111b60: 5b pop %ebx 111b61: 5e pop %esi 111b62: 5f pop %edi 111b63: c9 leave 111b64: c3 ret =============================================================================== 00111c80 : uint32_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 111c80: 55 push %ebp 111c81: 89 e5 mov %esp,%ebp 111c83: 57 push %edi 111c84: 56 push %esi 111c85: 53 push %ebx 111c86: 83 ec 1c sub $0x1c,%esp Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; void *the_segment; if ( !segment ) 111c89: bb 09 00 00 00 mov $0x9,%ebx 111c8e: 83 7d 18 00 cmpl $0x0,0x18(%ebp) 111c92: 0f 84 fd 00 00 00 je 111d95 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; *segment = NULL; 111c98: 8b 45 18 mov 0x18(%ebp),%eax 111c9b: c7 00 00 00 00 00 movl $0x0,(%eax) if ( size == 0 ) 111ca1: bb 08 00 00 00 mov $0x8,%ebx 111ca6: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 111caa: 0f 84 e5 00 00 00 je 111d95 <== NEVER TAKEN return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 111cb0: 83 ec 0c sub $0xc,%esp 111cb3: ff 35 f0 41 13 00 pushl 0x1341f0 111cb9: e8 52 1d 00 00 call 113a10 <_API_Mutex_Lock> executing = _Thread_Executing; 111cbe: 8b 3d f8 41 13 00 mov 0x1341f8,%edi 111cc4: 83 c4 0c add $0xc,%esp 111cc7: 8d 45 f0 lea -0x10(%ebp),%eax 111cca: 50 push %eax 111ccb: ff 75 08 pushl 0x8(%ebp) 111cce: 68 ec 3f 13 00 push $0x133fec 111cd3: e8 e4 32 00 00 call 114fbc <_Objects_Get_no_protection> 111cd8: 89 c6 mov %eax,%esi the_region = _Region_Get( id, &location ); switch ( location ) { 111cda: 83 c4 10 add $0x10,%esp 111cdd: 8b 45 f0 mov -0x10(%ebp),%eax 111ce0: 85 c0 test %eax,%eax 111ce2: 74 14 je 111cf8 111ce4: 31 db xor %ebx,%ebx 111ce6: 83 f8 01 cmp $0x1,%eax 111ce9: 0f 95 c3 setne %bl 111cec: 4b dec %ebx 111ced: 83 e3 eb and $0xffffffeb,%ebx 111cf0: 83 c3 19 add $0x19,%ebx 111cf3: e9 8c 00 00 00 jmp 111d84 case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) 111cf8: bb 08 00 00 00 mov $0x8,%ebx 111cfd: 8b 55 0c mov 0xc(%ebp),%edx 111d00: 3b 56 5c cmp 0x5c(%esi),%edx 111d03: 77 7f ja 111d84 /** * This function attempts to allocate a block of @a size bytes from * @a the_heap. If insufficient memory is free in @a the_heap to allocate * a block of the requested size, then NULL is returned. * 111d05: 50 push %eax 111d06: 50 push %eax 111d07: ff 75 0c pushl 0xc(%ebp) 111d0a: 8d 46 68 lea 0x68(%esi),%eax 111d0d: 50 push %eax 111d0e: e8 8d 26 00 00 call 1143a0 <_Heap_Allocate> the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 111d13: 83 c4 10 add $0x10,%esp 111d16: 85 c0 test %eax,%eax 111d18: 74 0c je 111d26 the_region->number_of_used_blocks += 1; 111d1a: ff 46 64 incl 0x64(%esi) *segment = the_segment; 111d1d: 8b 55 18 mov 0x18(%ebp),%edx 111d20: 89 02 mov %eax,(%edx) 111d22: 31 db xor %ebx,%ebx 111d24: eb 5e jmp 111d84 return_status = RTEMS_SUCCESSFUL; } else if ( _Options_Is_no_wait( option_set ) ) { 111d26: bb 0d 00 00 00 mov $0xd,%ebx 111d2b: f6 45 10 01 testb $0x1,0x10(%ebp) 111d2f: 75 53 jne 111d84 /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 111d31: a1 38 41 13 00 mov 0x134138,%eax 111d36: 40 inc %eax 111d37: a3 38 41 13 00 mov %eax,0x134138 * Switch from using the memory allocation mutex to using a * dispatching disabled critical section. We have to do this * because this thread is going to block. */ _Thread_Disable_dispatch(); _RTEMS_Unlock_allocator(); 111d3c: 83 ec 0c sub $0xc,%esp 111d3f: ff 35 f0 41 13 00 pushl 0x1341f0 111d45: e8 0e 1d 00 00 call 113a58 <_API_Mutex_Unlock> executing->Wait.queue = &the_region->Wait_queue; 111d4a: 8d 46 10 lea 0x10(%esi),%eax 111d4d: 89 47 44 mov %eax,0x44(%edi) executing->Wait.id = id; 111d50: 8b 55 08 mov 0x8(%ebp),%edx 111d53: 89 57 20 mov %edx,0x20(%edi) executing->Wait.count = size; 111d56: 8b 55 0c mov 0xc(%ebp),%edx 111d59: 89 57 24 mov %edx,0x24(%edi) executing->Wait.return_argument = segment; 111d5c: 8b 55 18 mov 0x18(%ebp),%edx 111d5f: 89 57 28 mov %edx,0x28(%edi) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 111d62: c7 46 40 01 00 00 00 movl $0x1,0x40(%esi) _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 111d69: 83 c4 0c add $0xc,%esp 111d6c: 68 0c 5f 11 00 push $0x115f0c 111d71: ff 75 14 pushl 0x14(%ebp) 111d74: 50 push %eax 111d75: e8 8e 3e 00 00 call 115c08 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 111d7a: e8 39 3a 00 00 call 1157b8 <_Thread_Enable_dispatch> return (rtems_status_code) executing->Wait.return_code; 111d7f: 8b 5f 34 mov 0x34(%edi),%ebx 111d82: eb 0e jmp 111d92 case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111d84: 83 ec 0c sub $0xc,%esp 111d87: ff 35 f0 41 13 00 pushl 0x1341f0 111d8d: e8 c6 1c 00 00 call 113a58 <_API_Mutex_Unlock> 111d92: 83 c4 10 add $0x10,%esp return return_status; } 111d95: 89 d8 mov %ebx,%eax 111d97: 8d 65 f4 lea -0xc(%ebp),%esp 111d9a: 5b pop %ebx 111d9b: 5e pop %esi 111d9c: 5f pop %edi 111d9d: c9 leave 111d9e: c3 ret =============================================================================== 00111e50 : Objects_Id id, void *segment, size_t size, size_t *old_size ) { 111e50: 55 push %ebp 111e51: 89 e5 mov %esp,%ebp 111e53: 57 push %edi 111e54: 56 push %esi 111e55: 53 push %ebx 111e56: 83 ec 1c sub $0x1c,%esp 111e59: 8b 7d 14 mov 0x14(%ebp),%edi uint32_t osize; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; Heap_Resize_status status; register Region_Control *the_region; if ( !old_size ) 111e5c: 85 ff test %edi,%edi 111e5e: 0f 84 aa 00 00 00 je 111f0e return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 111e64: 83 ec 0c sub $0xc,%esp 111e67: ff 35 f0 41 13 00 pushl 0x1341f0 111e6d: e8 9e 1b 00 00 call 113a10 <_API_Mutex_Lock> 111e72: 83 c4 0c add $0xc,%esp 111e75: 8d 45 ec lea -0x14(%ebp),%eax 111e78: 50 push %eax 111e79: ff 75 08 pushl 0x8(%ebp) 111e7c: 68 ec 3f 13 00 push $0x133fec 111e81: e8 36 31 00 00 call 114fbc <_Objects_Get_no_protection> 111e86: 89 c3 mov %eax,%ebx the_region = _Region_Get( id, &location ); switch ( location ) { 111e88: 83 c4 10 add $0x10,%esp 111e8b: 8b 45 ec mov -0x14(%ebp),%eax 111e8e: 85 c0 test %eax,%eax 111e90: 74 1f je 111eb1 111e92: 31 db xor %ebx,%ebx 111e94: 83 f8 01 cmp $0x1,%eax 111e97: 0f 95 c3 setne %bl 111e9a: 4b dec %ebx 111e9b: 83 e3 eb and $0xffffffeb,%ebx 111e9e: 83 c3 19 add $0x19,%ebx case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 111ea1: 83 ec 0c sub $0xc,%esp 111ea4: ff 35 f0 41 13 00 pushl 0x1341f0 111eaa: e8 a9 1b 00 00 call 113a58 <_API_Mutex_Unlock> 111eaf: eb 39 jmp 111eea case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 7 ); status = _Heap_Resize_block( 111eb1: 83 ec 0c sub $0xc,%esp 111eb4: 8d 45 f0 lea -0x10(%ebp),%eax 111eb7: 50 push %eax 111eb8: 8d 45 e8 lea -0x18(%ebp),%eax 111ebb: 50 push %eax 111ebc: ff 75 10 pushl 0x10(%ebp) 111ebf: ff 75 0c pushl 0xc(%ebp) 111ec2: 8d 43 68 lea 0x68(%ebx),%eax 111ec5: 50 push %eax 111ec6: e8 b9 29 00 00 call 114884 <_Heap_Resize_block> 111ecb: 89 c6 mov %eax,%esi segment, (uint32_t) size, &osize, &avail_size ); *old_size = (uint32_t) osize; 111ecd: 8b 45 e8 mov -0x18(%ebp),%eax 111ed0: 89 07 mov %eax,(%edi) _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 ) 111ed2: 83 c4 20 add $0x20,%esp 111ed5: 85 f6 test %esi,%esi 111ed7: 75 16 jne 111eef <== ALWAYS TAKEN 111ed9: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 111edd: 74 10 je 111eef <== NOT EXECUTED _Region_Process_queue( the_region ); /* unlocks allocator */ 111edf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111ee2: 53 push %ebx <== NOT EXECUTED 111ee3: e8 8c 68 00 00 call 118774 <_Region_Process_queue> <== NOT EXECUTED 111ee8: 31 db xor %ebx,%ebx <== NOT EXECUTED 111eea: 83 c4 10 add $0x10,%esp 111eed: eb 24 jmp 111f13 else _RTEMS_Unlock_allocator(); 111eef: 83 ec 0c sub $0xc,%esp 111ef2: ff 35 f0 41 13 00 pushl 0x1341f0 111ef8: e8 5b 1b 00 00 call 113a58 <_API_Mutex_Unlock> return 111efd: 83 c4 10 add $0x10,%esp 111f00: 31 db xor %ebx,%ebx 111f02: 85 f6 test %esi,%esi 111f04: 74 0d je 111f13 <== NEVER TAKEN 111f06: bb 0d 00 00 00 mov $0xd,%ebx 111f0b: 4e dec %esi 111f0c: 74 05 je 111f13 <== NEVER TAKEN return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); return return_status; 111f0e: bb 09 00 00 00 mov $0x9,%ebx } 111f13: 89 d8 mov %ebx,%eax 111f15: 8d 65 f4 lea -0xc(%ebp),%esp 111f18: 5b pop %ebx 111f19: 5e pop %esi 111f1a: 5f pop %edi 111f1b: c9 leave 111f1c: c3 ret =============================================================================== 00108f40 : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 108f40: 55 push %ebp 108f41: 89 e5 mov %esp,%ebp 108f43: 57 push %edi 108f44: 56 push %esi 108f45: 53 push %ebx 108f46: 83 ec 2c sub $0x2c,%esp 108f49: 8b 5d 10 mov 0x10(%ebp),%ebx register Semaphore_Control *the_semaphore; CORE_mutex_Attributes the_mutex_attributes; CORE_semaphore_Attributes the_semaphore_attributes; if ( !rtems_is_name_valid( name ) ) 108f4c: b8 03 00 00 00 mov $0x3,%eax 108f51: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 108f55: 0f 84 7f 01 00 00 je 1090da <== NEVER TAKEN return RTEMS_INVALID_NAME; if ( !id ) 108f5b: b8 09 00 00 00 mov $0x9,%eax 108f60: 83 7d 18 00 cmpl $0x0,0x18(%ebp) 108f64: 0f 84 70 01 00 00 je 1090da <== NEVER TAKEN return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 108f6a: 89 da mov %ebx,%edx 108f6c: 81 e2 c0 00 00 00 and $0xc0,%edx 108f72: 74 28 je 108f9c * @param[in] alignment the required alignment * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, 108f74: 89 d8 mov %ebx,%eax 108f76: 83 e0 30 and $0x30,%eax _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 108f79: 83 f8 10 cmp $0x10,%eax 108f7c: 74 09 je 108f87 108f7e: 83 f8 20 cmp $0x20,%eax 108f81: 0f 85 4e 01 00 00 jne 1090d5 <== NEVER TAKEN 108f87: f6 c3 04 test $0x4,%bl 108f8a: 0f 84 45 01 00 00 je 1090d5 <== NEVER TAKEN _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 108f90: 81 fa c0 00 00 00 cmp $0xc0,%edx 108f96: 0f 84 39 01 00 00 je 1090d5 _Attributes_Is_priority_ceiling( attribute_set ) ) return RTEMS_NOT_DEFINED; if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) ) 108f9c: 89 df mov %ebx,%edi 108f9e: 83 e7 30 and $0x30,%edi 108fa1: 74 0f je 108fb2 108fa3: b8 0a 00 00 00 mov $0xa,%eax 108fa8: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 108fac: 0f 87 28 01 00 00 ja 1090da /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 108fb2: a1 98 d7 11 00 mov 0x11d798,%eax 108fb7: 40 inc %eax 108fb8: a3 98 d7 11 00 mov %eax,0x11d798 #ifdef __cplusplus extern "C" { #endif /** 108fbd: 83 ec 0c sub $0xc,%esp 108fc0: 68 e0 d6 11 00 push $0x11d6e0 108fc5: e8 be 12 00 00 call 10a288 <_Objects_Allocate> 108fca: 89 c6 mov %eax,%esi _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 108fcc: 83 c4 10 add $0x10,%esp 108fcf: 85 c0 test %eax,%eax 108fd1: 75 0f jne 108fe2 _Thread_Enable_dispatch(); 108fd3: e8 b4 1e 00 00 call 10ae8c <_Thread_Enable_dispatch> 108fd8: b8 05 00 00 00 mov $0x5,%eax 108fdd: e9 f8 00 00 00 jmp 1090da _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_semaphore->attribute_set = attribute_set; 108fe2: 89 58 10 mov %ebx,0x10(%eax) * If it is not a counting semaphore, then it is either a * simple binary semaphore or a more powerful mutex style binary * semaphore. */ if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) { 108fe5: 85 ff test %edi,%edi 108fe7: 0f 84 92 00 00 00 je 10907f CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) 108fed: f6 c3 40 test $0x40,%bl 108ff0: 74 09 je 108ffb the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 108ff2: c7 45 e4 02 00 00 00 movl $0x2,-0x1c(%ebp) 108ff9: eb 18 jmp 109013 else if ( _Attributes_Is_priority_ceiling( attribute_set ) ) 108ffb: 84 db test %bl,%bl 108ffd: 79 09 jns 109008 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 108fff: c7 45 e4 03 00 00 00 movl $0x3,-0x1c(%ebp) 109006: eb 0b jmp 109013 else if ( _Attributes_Is_priority( attribute_set ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; 109008: 31 c0 xor %eax,%eax 10900a: f6 c3 04 test $0x4,%bl 10900d: 0f 95 c0 setne %al 109010: 89 45 e4 mov %eax,-0x1c(%ebp) else the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 109013: 83 ff 10 cmp $0x10,%edi 109016: 75 1a jne 109032 the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 109018: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) switch ( the_mutex_attributes.discipline ) { 10901f: 8b 45 e4 mov -0x1c(%ebp),%eax 109022: 83 f8 01 cmp $0x1,%eax 109025: 76 12 jbe 109039 109027: 83 f8 03 cmp $0x3,%eax 10902a: 77 11 ja 10903d <== NEVER TAKEN case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_mutex_attributes.only_owner_release = TRUE; 10902c: c6 45 e0 01 movb $0x1,-0x20(%ebp) 109030: eb 0b jmp 10903d break; } } else { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS; 109032: c7 45 dc 02 00 00 00 movl $0x2,-0x24(%ebp) the_mutex_attributes.only_owner_release = FALSE; 109039: c6 45 e0 00 movb $0x0,-0x20(%ebp) } the_mutex_attributes.priority_ceiling = priority_ceiling; 10903d: 8b 45 14 mov 0x14(%ebp),%eax 109040: 89 45 e8 mov %eax,-0x18(%ebp) mutex_status = _CORE_mutex_Initialize( 109043: 51 push %ecx 109044: 31 c0 xor %eax,%eax 109046: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 10904a: 0f 94 c0 sete %al 10904d: 50 push %eax 10904e: 8d 45 dc lea -0x24(%ebp),%eax 109051: 50 push %eax 109052: 8d 46 14 lea 0x14(%esi),%eax 109055: 50 push %eax 109056: e8 ed 0b 00 00 call 109c48 <_CORE_mutex_Initialize> &the_semaphore->Core_control.mutex, &the_mutex_attributes, (count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED ); if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) { 10905b: 83 c4 10 add $0x10,%esp 10905e: 83 f8 06 cmp $0x6,%eax 109061: 75 50 jne 1090b3 <== ALWAYS TAKEN * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 109063: 52 push %edx <== NOT EXECUTED 109064: 52 push %edx <== NOT EXECUTED 109065: 56 push %esi <== NOT EXECUTED 109066: 68 e0 d6 11 00 push $0x11d6e0 <== NOT EXECUTED 10906b: e8 28 15 00 00 call 10a598 <_Objects_Free> <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 109070: e8 17 1e 00 00 call 10ae8c <_Thread_Enable_dispatch><== NOT EXECUTED 109075: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED 10907a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10907d: eb 5b jmp 1090da <== NOT EXECUTED return RTEMS_INVALID_PRIORITY; } } else { if ( _Attributes_Is_priority( attribute_set ) ) the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 10907f: 31 c0 xor %eax,%eax 109081: f6 c3 04 test $0x4,%bl 109084: 0f 95 c0 setne %al 109087: 89 45 f0 mov %eax,-0x10(%ebp) /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 10908a: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp) /* * The following are just to make Purify happy. */ the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 109091: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM; 109098: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp) _CORE_semaphore_Initialize( 10909f: 50 push %eax 1090a0: ff 75 0c pushl 0xc(%ebp) 1090a3: 8d 45 ec lea -0x14(%ebp),%eax 1090a6: 50 push %eax 1090a7: 8d 46 14 lea 0x14(%esi),%eax 1090aa: 50 push %eax 1090ab: e8 14 0e 00 00 call 109ec4 <_CORE_semaphore_Initialize> 1090b0: 83 c4 10 add $0x10,%esp 1090b3: 8b 4e 08 mov 0x8(%esi),%ecx 1090b6: 0f b7 d1 movzwl %cx,%edx 1090b9: a1 fc d6 11 00 mov 0x11d6fc,%eax 1090be: 89 34 90 mov %esi,(%eax,%edx,4) 1090c1: 8b 45 08 mov 0x8(%ebp),%eax 1090c4: 89 46 0c mov %eax,0xc(%esi) &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 1090c7: 8b 45 18 mov 0x18(%ebp),%eax 1090ca: 89 08 mov %ecx,(%eax) the_semaphore->Object.id, name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 1090cc: e8 bb 1d 00 00 call 10ae8c <_Thread_Enable_dispatch> 1090d1: 31 c0 xor %eax,%eax 1090d3: eb 05 jmp 1090da return RTEMS_SUCCESSFUL; 1090d5: b8 0b 00 00 00 mov $0xb,%eax } 1090da: 8d 65 f4 lea -0xc(%ebp),%esp 1090dd: 5b pop %ebx 1090de: 5e pop %esi 1090df: 5f pop %edi 1090e0: c9 leave 1090e1: c3 ret =============================================================================== 001121dc : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 1121dc: 55 push %ebp 1121dd: 89 e5 mov %esp,%ebp 1121df: 83 ec 1c sub $0x1c,%esp * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap 1121e2: 8d 45 fc lea -0x4(%ebp),%eax 1121e5: 50 push %eax 1121e6: ff 75 08 pushl 0x8(%ebp) 1121e9: 68 2c 40 13 00 push $0x13402c 1121ee: e8 05 2e 00 00 call 114ff8 <_Objects_Get> 1121f3: 89 c2 mov %eax,%edx register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 1121f5: 83 c4 10 add $0x10,%esp 1121f8: b8 04 00 00 00 mov $0x4,%eax 1121fd: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) 112201: 75 2b jne 11222e case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 112203: f6 42 10 30 testb $0x30,0x10(%edx) 112207: 8d 42 14 lea 0x14(%edx),%eax 11220a: 74 0d je 112219 <== NEVER TAKEN _CORE_mutex_Flush( 11220c: 51 push %ecx 11220d: 6a 01 push $0x1 11220f: 6a 00 push $0x0 112211: 50 push %eax 112212: e8 e9 1c 00 00 call 113f00 <_CORE_mutex_Flush> 112217: eb 0b jmp 112224 &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 112219: 52 push %edx <== NOT EXECUTED 11221a: 6a 01 push $0x1 <== NOT EXECUTED 11221c: 6a 00 push $0x0 <== NOT EXECUTED 11221e: 50 push %eax <== NOT EXECUTED 11221f: e8 58 1f 00 00 call 11417c <_CORE_semaphore_Flush> <== NOT EXECUTED 112224: 83 c4 10 add $0x10,%esp &the_semaphore->Core_control.semaphore, SEND_OBJECT_WAS_DELETED, CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT ); } _Thread_Enable_dispatch(); 112227: e8 8c 35 00 00 call 1157b8 <_Thread_Enable_dispatch> 11222c: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11222e: c9 leave 11222f: c3 ret =============================================================================== 0011582c : */ void rtems_shutdown_executive( uint32_t result ) { 11582c: 55 push %ebp 11582d: 89 e5 mov %esp,%ebp 11582f: 83 ec 28 sub $0x28,%esp if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 115832: 83 3d 38 d9 11 00 04 cmpl $0x4,0x11d938 115839: 74 1d je 115858 <== NEVER TAKEN RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 11583b: c7 05 38 d9 11 00 04 movl $0x4,0x11d938 115842: 00 00 00 #endif } /** * This routine sets the current system state to that specified by * the called. 115845: 50 push %eax 115846: 50 push %eax 115847: 68 80 d7 11 00 push $0x11d780 11584c: 8d 45 e8 lea -0x18(%ebp),%eax 11584f: 50 push %eax 115850: e8 6b 66 ff ff call 10bec0 <_CPU_Context_switch> 115855: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_SHUTDOWN ); _Thread_Stop_multitasking(); } } 115858: c9 leave <== NOT EXECUTED 115859: c3 ret <== NOT EXECUTED =============================================================================== 00109ef0 : rtems_status_code rtems_signal_catch( rtems_asr_entry asr_handler, rtems_mode mode_set ) { 109ef0: 55 push %ebp 109ef1: 89 e5 mov %esp,%ebp 109ef3: 83 ec 08 sub $0x8,%esp 109ef6: 8b 4d 08 mov 0x8(%ebp),%ecx RTEMS_API_Control *api; ASR_Information *asr; /* XXX normalize mode */ executing = _Thread_Executing; api = (RTEMS_API_Control*)executing->API_Extensions[ THREAD_API_RTEMS ]; 109ef9: a1 c4 12 12 00 mov 0x1212c4,%eax 109efe: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109f04: a1 04 12 12 00 mov 0x121204,%eax 109f09: 40 inc %eax 109f0a: a3 04 12 12 00 mov %eax,0x121204 asr = &api->Signal; _Thread_Disable_dispatch(); /* cannot reschedule while */ /* the thread is inconsistent */ if ( !_ASR_Is_null_handler( asr_handler ) ) { 109f0f: 85 c9 test %ecx,%ecx 109f11: 74 0b je 109f1e <== NEVER TAKEN asr->mode_set = mode_set; 109f13: 8b 45 0c mov 0xc(%ebp),%eax 109f16: 89 42 10 mov %eax,0x10(%edx) asr->handler = asr_handler; 109f19: 89 4a 0c mov %ecx,0xc(%edx) 109f1c: eb 27 jmp 109f45 #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of 109f1e: c6 42 08 01 movb $0x1,0x8(%edx) <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of 109f22: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) <== NOT EXECUTED * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 109f29: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED * 109f30: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 109f37: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 109f3e: c7 42 1c 00 00 00 00 movl $0x0,0x1c(%edx) <== NOT EXECUTED } else _ASR_Initialize( asr ); _Thread_Enable_dispatch(); 109f45: e8 8e 1e 00 00 call 10bdd8 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; } 109f4a: 31 c0 xor %eax,%eax 109f4c: c9 leave 109f4d: c3 ret =============================================================================== 001123cc : rtems_status_code rtems_signal_send( Objects_Id id, rtems_signal_set signal_set ) { 1123cc: 55 push %ebp 1123cd: 89 e5 mov %esp,%ebp 1123cf: 53 push %ebx 1123d0: 83 ec 14 sub $0x14,%esp 1123d3: 8b 5d 0c mov 0xc(%ebp),%ebx register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 1123d6: b8 0a 00 00 00 mov $0xa,%eax 1123db: 85 db test %ebx,%ebx 1123dd: 74 71 je 112450 <== NEVER TAKEN return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 1123df: 50 push %eax 1123e0: 50 push %eax 1123e1: 8d 45 f8 lea -0x8(%ebp),%eax 1123e4: 50 push %eax 1123e5: ff 75 08 pushl 0x8(%ebp) 1123e8: e8 eb 33 00 00 call 1157d8 <_Thread_Get> 1123ed: 89 c1 mov %eax,%ecx switch ( location ) { 1123ef: 83 c4 10 add $0x10,%esp 1123f2: b8 04 00 00 00 mov $0x4,%eax 1123f7: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) 1123fb: 75 53 jne 112450 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 1123fd: 8b 91 f4 00 00 00 mov 0xf4(%ecx),%edx asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 112403: 83 7a 0c 00 cmpl $0x0,0xc(%edx) 112407: 74 3d je 112446 if ( asr->is_enabled ) { 112409: 80 7a 08 00 cmpb $0x0,0x8(%edx) 11240d: 74 26 je 112435 <== NEVER TAKEN * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 11240f: 9c pushf 112410: fa cli 112411: 58 pop %eax ); 112412: 09 5a 14 or %ebx,0x14(%edx) 112415: 50 push %eax 112416: 9d popf _ASR_Post_signals( signal_set, &asr->signals_posted ); the_thread->do_post_task_switch_extension = true; 112417: c6 41 75 01 movb $0x1,0x75(%ecx) if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 11241b: a1 d4 41 13 00 mov 0x1341d4,%eax 112420: 85 c0 test %eax,%eax 112422: 74 19 je 11243d 112424: 3b 0d f8 41 13 00 cmp 0x1341f8,%ecx 11242a: 75 11 jne 11243d <== NEVER TAKEN _ISR_Signals_to_thread_executing = TRUE; 11242c: c6 05 8c 42 13 00 01 movb $0x1,0x13428c 112433: eb 08 jmp 11243d * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 112435: 9c pushf <== NOT EXECUTED 112436: fa cli <== NOT EXECUTED 112437: 58 pop %eax <== NOT EXECUTED ); 112438: 09 5a 18 or %ebx,0x18(%edx) <== NOT EXECUTED 11243b: 50 push %eax <== NOT EXECUTED 11243c: 9d popf <== NOT EXECUTED } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 11243d: e8 76 33 00 00 call 1157b8 <_Thread_Enable_dispatch> 112442: 31 c0 xor %eax,%eax 112444: eb 0a jmp 112450 return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 112446: e8 6d 33 00 00 call 1157b8 <_Thread_Enable_dispatch> 11244b: b8 0b 00 00 00 mov $0xb,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112450: 8b 5d fc mov -0x4(%ebp),%ebx 112453: c9 leave 112454: c3 ret =============================================================================== 001066f8 : * rtems_stack_checker_Begin_extension */ void rtems_stack_checker_begin_extension( Thread_Control *the_thread ) { 1066f8: 55 push %ebp 1066f9: 89 e5 mov %esp,%ebp 1066fb: 57 push %edi 1066fc: 56 push %esi 1066fd: 8b 45 08 mov 0x8(%ebp),%eax Stack_check_Control *the_pattern; if ( the_thread->Object.id == 0 ) /* skip system tasks */ 106700: 83 78 08 00 cmpl $0x0,0x8(%eax) 106704: 74 15 je 10671b <== NEVER TAKEN return; the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack); *the_pattern = Stack_check_Pattern; 106706: 8b 80 c8 00 00 00 mov 0xc8(%eax),%eax 10670c: 8d 78 08 lea 0x8(%eax),%edi 10670f: be 08 10 12 00 mov $0x121008,%esi 106714: b9 04 00 00 00 mov $0x4,%ecx 106719: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } 10671b: 5e pop %esi 10671c: 5f pop %edi 10671d: c9 leave 10671e: c3 ret =============================================================================== 00106a80 : */ bool rtems_stack_checker_create_extension( Thread_Control *running, Thread_Control *the_thread ) { 106a80: 55 push %ebp 106a81: 89 e5 mov %esp,%ebp 106a83: 57 push %edi 106a84: 83 ec 04 sub $0x4,%esp 106a87: 8b 7d 0c mov 0xc(%ebp),%edi Stack_check_Initialize(); 106a8a: e8 84 ff ff ff call 106a13 if (the_thread) 106a8f: 85 ff test %edi,%edi 106a91: 74 10 je 106aa3 <== NEVER TAKEN Stack_check_Dope_stack(&the_thread->Start.Initial_stack); 106a93: 8b 8f c4 00 00 00 mov 0xc4(%edi),%ecx 106a99: 8b bf c8 00 00 00 mov 0xc8(%edi),%edi 106a9f: b0 a5 mov $0xa5,%al 106aa1: f3 aa rep stos %al,%es:(%edi) return true; } 106aa3: b0 01 mov $0x1,%al 106aa5: 5a pop %edx 106aa6: 5f pop %edi 106aa7: c9 leave 106aa8: c3 ret =============================================================================== 00106941 : /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) { 106941: 55 push %ebp <== NOT EXECUTED 106942: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106944: 53 push %ebx <== NOT EXECUTED 106945: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 106948: a1 44 12 12 00 mov 0x121244,%eax <== NOT EXECUTED ) { void *sp = __builtin_frame_address(0); #if defined(__GNUC__) if ( sp < the_stack->area ) { 10694d: 8b 90 c8 00 00 00 mov 0xc8(%eax),%edx <== NOT EXECUTED 106953: 31 db xor %ebx,%ebx <== NOT EXECUTED 106955: 39 d5 cmp %edx,%ebp <== NOT EXECUTED 106957: 72 0e jb 106967 <== NOT EXECUTED 106959: 8b 88 c4 00 00 00 mov 0xc4(%eax),%ecx <== NOT EXECUTED 10695f: 8d 04 0a lea (%edx,%ecx,1),%eax <== NOT EXECUTED 106962: 39 c5 cmp %eax,%ebp <== NOT EXECUTED 106964: 0f 96 c3 setbe %bl <== NOT EXECUTED /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 106967: b0 01 mov $0x1,%al <== NOT EXECUTED 106969: 83 3d ec 0d 12 00 00 cmpl $0x0,0x120dec <== NOT EXECUTED 106970: 74 19 je 10698b <== NOT EXECUTED pattern_ok = (!memcmp( 106972: 51 push %ecx <== NOT EXECUTED 106973: 6a 10 push $0x10 <== NOT EXECUTED 106975: 68 08 10 12 00 push $0x121008 <== NOT EXECUTED 10697a: 8d 42 08 lea 0x8(%edx),%eax <== NOT EXECUTED 10697d: 50 push %eax <== NOT EXECUTED 10697e: e8 c5 9e 00 00 call 110848 <== NOT EXECUTED 106983: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106986: 85 c0 test %eax,%eax <== NOT EXECUTED 106988: 0f 94 c0 sete %al <== NOT EXECUTED } /* * The Stack Pointer and the Pattern Area are OK so return false. */ if ( sp_ok && pattern_ok ) 10698b: 84 db test %bl,%bl <== NOT EXECUTED 10698d: 74 06 je 106995 <== NOT EXECUTED 10698f: 31 d2 xor %edx,%edx <== NOT EXECUTED 106991: 84 c0 test %al,%al <== NOT EXECUTED 106993: 75 16 jne 1069ab <== NOT EXECUTED return false; /* * Let's report as much as we can. */ Stack_check_report_blown_task( _Thread_Executing, pattern_ok ); 106995: 52 push %edx <== NOT EXECUTED 106996: 52 push %edx <== NOT EXECUTED 106997: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10699a: 50 push %eax <== NOT EXECUTED 10699b: ff 35 44 12 12 00 pushl 0x121244 <== NOT EXECUTED 1069a1: e8 34 ff ff ff call 1068da <== NOT EXECUTED 1069a6: b2 01 mov $0x1,%dl <== NOT EXECUTED 1069a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return true; } 1069ab: 88 d0 mov %dl,%al <== NOT EXECUTED 1069ad: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1069b0: c9 leave <== NOT EXECUTED 1069b1: c3 ret <== NOT EXECUTED =============================================================================== 001068c3 : void rtems_stack_checker_report_usage( void ) { 1068c3: 55 push %ebp <== NOT EXECUTED 1068c4: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1068c6: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin ); 1068c9: 68 d0 7b 10 00 push $0x107bd0 <== NOT EXECUTED 1068ce: 6a 00 push $0x0 <== NOT EXECUTED 1068d0: e8 8d ff ff ff call 106862 <== NOT EXECUTED 1068d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1068d8: c9 leave <== NOT EXECUTED 1068d9: c3 ret <== NOT EXECUTED =============================================================================== 00106862 : void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) { 106862: 55 push %ebp <== NOT EXECUTED 106863: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106865: 56 push %esi <== NOT EXECUTED 106866: 53 push %ebx <== NOT EXECUTED 106867: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10686a: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED print_context = context; 10686d: 89 1d f0 0d 12 00 mov %ebx,0x120df0 <== NOT EXECUTED print_handler = print; 106873: 89 35 f4 0d 12 00 mov %esi,0x120df4 <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 106879: 51 push %ecx <== NOT EXECUTED 10687a: 51 push %ecx <== NOT EXECUTED 10687b: 68 25 9a 11 00 push $0x119a25 <== NOT EXECUTED 106880: 53 push %ebx <== NOT EXECUTED 106881: ff d6 call *%esi <== NOT EXECUTED (*print)( context, 106883: 58 pop %eax <== NOT EXECUTED 106884: 5a pop %edx <== NOT EXECUTED 106885: 68 3c 9a 11 00 push $0x119a3c <== NOT EXECUTED 10688a: 53 push %ebx <== NOT EXECUTED 10688b: ff d6 call *%esi <== 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 ); 10688d: c7 04 24 4a 67 10 00 movl $0x10674a,(%esp) <== NOT EXECUTED 106894: e8 43 47 00 00 call 10afdc <== NOT EXECUTED /* dump interrupt stack info if any */ Stack_check_Dump_threads_usage((Thread_Control *) -1); 106899: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED 1068a0: e8 a5 fe ff ff call 10674a <== NOT EXECUTED print_context = NULL; 1068a5: c7 05 f0 0d 12 00 00 movl $0x0,0x120df0 <== NOT EXECUTED 1068ac: 00 00 00 print_handler = NULL; 1068af: c7 05 f4 0d 12 00 00 movl $0x0,0x120df4 <== NOT EXECUTED 1068b6: 00 00 00 1068b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1068bc: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1068bf: 5b pop %ebx <== NOT EXECUTED 1068c0: 5e pop %esi <== NOT EXECUTED 1068c1: c9 leave <== NOT EXECUTED 1068c2: c3 ret <== NOT EXECUTED =============================================================================== 001069b2 : */ void rtems_stack_checker_switch_extension( Thread_Control *running, Thread_Control *heir ) { 1069b2: 55 push %ebp 1069b3: 89 e5 mov %esp,%ebp 1069b5: 56 push %esi 1069b6: 53 push %ebx 1069b7: 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; 1069ba: 8b 93 c8 00 00 00 mov 0xc8(%ebx),%edx ) { void *sp = __builtin_frame_address(0); #if defined(__GNUC__) if ( sp < the_stack->area ) { 1069c0: 31 f6 xor %esi,%esi 1069c2: 39 d5 cmp %edx,%ebp 1069c4: 72 0f jb 1069d5 <== NEVER TAKEN 1069c6: 89 d0 mov %edx,%eax 1069c8: 03 83 c4 00 00 00 add 0xc4(%ebx),%eax 1069ce: 39 c5 cmp %eax,%ebp 1069d0: 0f 96 c0 setbe %al 1069d3: 89 c6 mov %eax,%esi /* * 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, 1069d5: 50 push %eax 1069d6: 6a 10 push $0x10 1069d8: 68 08 10 12 00 push $0x121008 1069dd: 8d 42 08 lea 0x8(%edx),%eax 1069e0: 50 push %eax 1069e1: e8 62 9e 00 00 call 110848 1069e6: 83 c4 10 add $0x10,%esp 1069e9: 85 c0 test %eax,%eax 1069eb: 0f 94 c0 sete %al (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { 1069ee: 89 f2 mov %esi,%edx 1069f0: 84 d2 test %dl,%dl 1069f2: 74 04 je 1069f8 <== NEVER TAKEN 1069f4: 84 c0 test %al,%al 1069f6: 75 14 jne 106a0c Stack_check_report_blown_task( running, pattern_ok ); 1069f8: 0f b6 c0 movzbl %al,%eax 1069fb: 89 45 0c mov %eax,0xc(%ebp) 1069fe: 89 5d 08 mov %ebx,0x8(%ebp) } } 106a01: 8d 65 f8 lea -0x8(%ebp),%esp 106a04: 5b pop %ebx 106a05: 5e pop %esi 106a06: c9 leave pattern_ok = (!memcmp( pattern, (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { Stack_check_report_blown_task( running, pattern_ok ); 106a07: e9 ce fe ff ff jmp 1068da } } 106a0c: 8d 65 f8 lea -0x8(%ebp),%esp 106a0f: 5b pop %ebx 106a10: 5e pop %esi 106a11: c9 leave 106a12: c3 ret =============================================================================== 00106eac : const char * rtems_status_text( rtems_status_code status ) { 106eac: 55 push %ebp <== NOT EXECUTED 106ead: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106eaf: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return rtems_assoc_name_by_local(rtems_status_assoc, status); 106eb2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106eb5: 68 18 a5 11 00 push $0x11a518 <== NOT EXECUTED 106eba: e8 c9 73 00 00 call 10e288 <== NOT EXECUTED } 106ebf: c9 leave <== NOT EXECUTED 106ec0: c3 ret <== NOT EXECUTED =============================================================================== 001092ec : size_t stack_size, rtems_mode initial_modes, rtems_attribute attribute_set, Objects_Id *id ) { 1092ec: 55 push %ebp 1092ed: 89 e5 mov %esp,%ebp 1092ef: 57 push %edi 1092f0: 56 push %esi 1092f1: 53 push %ebx 1092f2: 83 ec 0c sub $0xc,%esp 1092f5: 8b 5d 14 mov 0x14(%ebp),%ebx 1092f8: 8b 7d 18 mov 0x18(%ebp),%edi Priority_Control core_priority; RTEMS_API_Control *api; ASR_Information *asr; if ( !id ) 1092fb: b8 09 00 00 00 mov $0x9,%eax 109300: 83 7d 1c 00 cmpl $0x0,0x1c(%ebp) 109304: 0f 84 08 01 00 00 je 109412 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10930a: b8 03 00 00 00 mov $0x3,%eax 10930f: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 109313: 0f 84 f9 00 00 00 je 109412 /* * Validate the RTEMS API priority and convert it to the core priority range. */ if ( !_Attributes_Is_system_task( the_attribute_set ) ) { 109319: 66 85 ff test %di,%di 10931c: 78 24 js 109342 bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ); 10931e: 31 d2 xor %edx,%edx 109320: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 109324: 74 0f je 109335 109326: 0f b6 05 84 93 11 00 movzbl 0x119384,%eax 10932d: 31 d2 xor %edx,%edx 10932f: 39 45 0c cmp %eax,0xc(%ebp) 109332: 0f 96 c2 setbe %dl if ( !_RTEMS_tasks_Priority_is_valid( initial_priority ) ) 109335: b8 13 00 00 00 mov $0x13,%eax 10933a: 85 d2 test %edx,%edx 10933c: 0f 84 d0 00 00 00 je 109412 */ /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 109342: 83 ec 0c sub $0xc,%esp 109345: ff 35 50 d8 11 00 pushl 0x11d850 10934b: e8 28 07 00 00 call 109a78 <_API_Mutex_Lock> #ifdef __cplusplus extern "C" { #endif /** 109350: c7 04 24 20 d7 11 00 movl $0x11d720,(%esp) 109357: e8 2c 0f 00 00 call 10a288 <_Objects_Allocate> 10935c: 89 c6 mov %eax,%esi * the event of an error. */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { 10935e: 83 c4 10 add $0x10,%esp 109361: 85 c0 test %eax,%eax 109363: 75 18 jne 10937d _RTEMS_Unlock_allocator(); 109365: 83 ec 0c sub $0xc,%esp 109368: ff 35 50 d8 11 00 pushl 0x11d850 10936e: e8 4d 07 00 00 call 109ac0 <_API_Mutex_Unlock> 109373: b8 05 00 00 00 mov $0x5,%eax 109378: e9 92 00 00 00 jmp 10940f /* * Initialize the core thread for this task. */ status = _Thread_Initialize( 10937d: 50 push %eax 10937e: ff 75 08 pushl 0x8(%ebp) 109381: 89 d8 mov %ebx,%eax 109383: 83 e0 01 and $0x1,%eax 109386: 50 push %eax 109387: 6a 00 push $0x0 109389: 89 d8 mov %ebx,%eax 10938b: c1 e8 09 shr $0x9,%eax 10938e: 83 e0 01 and $0x1,%eax 109391: 50 push %eax 109392: 89 d8 mov %ebx,%eax 109394: c1 e8 08 shr $0x8,%eax 109397: 83 f0 01 xor $0x1,%eax 10939a: 83 e0 01 and $0x1,%eax 10939d: 50 push %eax 10939e: ff 75 0c pushl 0xc(%ebp) 1093a1: 83 e7 01 and $0x1,%edi 1093a4: 57 push %edi 1093a5: ff 75 10 pushl 0x10(%ebp) 1093a8: 6a 00 push $0x0 1093aa: 56 push %esi 1093ab: 68 20 d7 11 00 push $0x11d720 1093b0: e8 6f 1b 00 00 call 10af24 <_Thread_Initialize> NULL, /* no budget algorithm callout */ _Modes_Get_interrupt_level(initial_modes), (Objects_Name) name ); if ( !status ) { 1093b5: 83 c4 30 add $0x30,%esp 1093b8: 84 c0 test %al,%al 1093ba: 75 27 jne 1093e3 * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 1093bc: 83 ec 0c sub $0xc,%esp 1093bf: ff 76 08 pushl 0x8(%esi) 1093c2: e8 45 12 00 00 call 10a60c <_Objects_Get_information_id> 1093c7: 5a pop %edx 1093c8: 59 pop %ecx 1093c9: 56 push %esi 1093ca: 50 push %eax 1093cb: e8 c8 11 00 00 call 10a598 <_Objects_Free> #if defined(RTEMS_MULTIPROCESSING) if ( is_global ) _Objects_MP_Free_global_object( the_global_object ); #endif _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 1093d0: 58 pop %eax 1093d1: ff 35 50 d8 11 00 pushl 0x11d850 1093d7: e8 e4 06 00 00 call 109ac0 <_API_Mutex_Unlock> 1093dc: b8 0d 00 00 00 mov $0xd,%eax 1093e1: eb 2c jmp 10940f } api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true; 1093e3: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax 1093e9: c1 eb 0a shr $0xa,%ebx 1093ec: 83 f3 01 xor $0x1,%ebx 1093ef: 88 da mov %bl,%dl 1093f1: 83 e2 01 and $0x1,%edx 1093f4: 88 50 08 mov %dl,0x8(%eax) *id = the_thread->Object.id; 1093f7: 8b 46 08 mov 0x8(%esi),%eax 1093fa: 8b 55 1c mov 0x1c(%ebp),%edx 1093fd: 89 02 mov %eax,(%edx) ); } #endif _RTEMS_Unlock_allocator(); 1093ff: 83 ec 0c sub $0xc,%esp 109402: ff 35 50 d8 11 00 pushl 0x11d850 109408: e8 b3 06 00 00 call 109ac0 <_API_Mutex_Unlock> 10940d: 31 c0 xor %eax,%eax 10940f: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; } 109412: 8d 65 f4 lea -0xc(%ebp),%esp 109415: 5b pop %ebx 109416: 5e pop %esi 109417: 5f pop %edi 109418: c9 leave 109419: c3 ret =============================================================================== 0010aa24 : rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 10aa24: 55 push %ebp 10aa25: 89 e5 mov %esp,%ebp 10aa27: 56 push %esi 10aa28: 53 push %ebx 10aa29: 83 ec 10 sub $0x10,%esp 10aa2c: 8b 4d 08 mov 0x8(%ebp),%ecx 10aa2f: 8b 5d 0c mov 0xc(%ebp),%ebx 10aa32: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10aa35: a1 a4 28 12 00 mov 0x1228a4,%eax 10aa3a: 8b 40 40 mov 0x40(%eax),%eax 10aa3d: ba 16 00 00 00 mov $0x16,%edx 10aa42: 80 78 04 00 cmpb $0x0,0x4(%eax) 10aa46: 74 61 je 10aaa9 <== NEVER TAKEN return RTEMS_NOT_CONFIGURED; if ( !note ) 10aa48: ba 09 00 00 00 mov $0x9,%edx 10aa4d: 85 f6 test %esi,%esi 10aa4f: 74 58 je 10aaa9 <== NEVER TAKEN /* * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) 10aa51: ba 0a 00 00 00 mov $0xa,%edx 10aa56: 83 fb 0f cmp $0xf,%ebx 10aa59: 77 4e ja 10aaa9 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10aa5b: 85 c9 test %ecx,%ecx 10aa5d: 74 0a je 10aa69 10aa5f: a1 cc 28 12 00 mov 0x1228cc,%eax 10aa64: 3b 48 08 cmp 0x8(%eax),%ecx 10aa67: 75 13 jne 10aa7c _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10aa69: a1 cc 28 12 00 mov 0x1228cc,%eax 10aa6e: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax 10aa74: 8b 44 98 20 mov 0x20(%eax,%ebx,4),%eax 10aa78: 89 06 mov %eax,(%esi) 10aa7a: eb 2b jmp 10aaa7 return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10aa7c: 50 push %eax 10aa7d: 50 push %eax 10aa7e: 8d 45 f4 lea -0xc(%ebp),%eax 10aa81: 50 push %eax 10aa82: 51 push %ecx 10aa83: e8 d8 1c 00 00 call 10c760 <_Thread_Get> switch ( location ) { 10aa88: 83 c4 10 add $0x10,%esp 10aa8b: ba 04 00 00 00 mov $0x4,%edx 10aa90: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10aa94: 75 13 jne 10aaa9 <== ALWAYS TAKEN case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10aa96: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10aa9c: 8b 44 98 20 mov 0x20(%eax,%ebx,4),%eax <== NOT EXECUTED 10aaa0: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10aaa2: e8 99 1c 00 00 call 10c740 <_Thread_Enable_dispatch><== NOT EXECUTED 10aaa7: 31 d2 xor %edx,%edx case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10aaa9: 89 d0 mov %edx,%eax 10aaab: 8d 65 f8 lea -0x8(%ebp),%esp 10aaae: 5b pop %ebx 10aaaf: 5e pop %esi 10aab0: c9 leave 10aab1: c3 ret =============================================================================== 001094a0 : rtems_status_code rtems_task_ident( rtems_name name, uint32_t node, Objects_Id *id ) { 1094a0: 55 push %ebp 1094a1: 89 e5 mov %esp,%ebp 1094a3: 83 ec 08 sub $0x8,%esp 1094a6: 8b 4d 08 mov 0x8(%ebp),%ecx 1094a9: 8b 55 10 mov 0x10(%ebp),%edx Objects_Name_or_id_lookup_errors status; if ( !id ) 1094ac: b8 09 00 00 00 mov $0x9,%eax 1094b1: 85 d2 test %edx,%edx 1094b3: 74 2b je 1094e0 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( name == OBJECTS_ID_OF_SELF ) { 1094b5: 85 c9 test %ecx,%ecx 1094b7: 75 0e jne 1094c7 *id = _Thread_Executing->Object.id; 1094b9: a1 58 d8 11 00 mov 0x11d858,%eax 1094be: 8b 40 08 mov 0x8(%eax),%eax 1094c1: 89 02 mov %eax,(%edx) 1094c3: 31 c0 xor %eax,%eax 1094c5: eb 19 jmp 1094e0 return RTEMS_SUCCESSFUL; } status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id ); 1094c7: 52 push %edx 1094c8: ff 75 0c pushl 0xc(%ebp) 1094cb: 51 push %ecx 1094cc: 68 20 d7 11 00 push $0x11d720 1094d1: e8 3e 13 00 00 call 10a814 <_Objects_Name_to_id_u32> return _Status_Object_name_errors_to_status[ status ]; 1094d6: 8b 04 85 1c 73 11 00 mov 0x11731c(,%eax,4),%eax 1094dd: 83 c4 10 add $0x10,%esp } 1094e0: c9 leave 1094e1: c3 ret =============================================================================== 001099ec : */ rtems_status_code rtems_task_is_suspended( Objects_Id id ) { 1099ec: 55 push %ebp 1099ed: 89 e5 mov %esp,%ebp 1099ef: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 1099f2: 8d 45 fc lea -0x4(%ebp),%eax 1099f5: 50 push %eax 1099f6: ff 75 08 pushl 0x8(%ebp) 1099f9: e8 46 1a 00 00 call 10b444 <_Thread_Get> 1099fe: 89 c2 mov %eax,%edx switch ( location ) { 109a00: 83 c4 10 add $0x10,%esp 109a03: b8 04 00 00 00 mov $0x4,%eax 109a08: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) 109a0c: 75 19 jne 109a27 <== NEVER TAKEN case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 109a0e: f6 42 10 02 testb $0x2,0x10(%edx) 109a12: 75 09 jne 109a1d _Thread_Enable_dispatch(); 109a14: e8 0b 1a 00 00 call 10b424 <_Thread_Enable_dispatch> 109a19: 31 c0 xor %eax,%eax 109a1b: eb 0a jmp 109a27 return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 109a1d: e8 02 1a 00 00 call 10b424 <_Thread_Enable_dispatch> 109a22: b8 0f 00 00 00 mov $0xf,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 109a27: c9 leave 109a28: c3 ret =============================================================================== 0010ecd4 : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 10ecd4: 55 push %ebp 10ecd5: 89 e5 mov %esp,%ebp 10ecd7: 57 push %edi 10ecd8: 56 push %esi 10ecd9: 53 push %ebx 10ecda: 83 ec 0c sub $0xc,%esp 10ecdd: 8b 7d 08 mov 0x8(%ebp),%edi ASR_Information *asr; bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) 10ece0: b8 09 00 00 00 mov $0x9,%eax 10ece5: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10ece9: 0f 84 04 01 00 00 je 10edf3 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 10ecef: a1 58 d8 11 00 mov 0x11d858,%eax 10ecf4: 89 45 ec mov %eax,-0x14(%ebp) api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10ecf7: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx 10ecfd: 89 55 f0 mov %edx,-0x10(%ebp) asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 10ed00: 80 78 76 01 cmpb $0x1,0x76(%eax) 10ed04: 19 f6 sbb %esi,%esi 10ed06: 81 e6 00 01 00 00 and $0x100,%esi if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 10ed0c: 83 78 7c 00 cmpl $0x0,0x7c(%eax) 10ed10: 74 06 je 10ed18 old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 10ed12: 81 ce 00 02 00 00 or $0x200,%esi old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 10ed18: 8b 5d f0 mov -0x10(%ebp),%ebx 10ed1b: 80 7b 08 01 cmpb $0x1,0x8(%ebx) 10ed1f: 19 db sbb %ebx,%ebx 10ed21: 81 e3 00 04 00 00 and $0x400,%ebx old_mode |= _ISR_Get_level(); 10ed27: e8 6f d3 ff ff call 10c09b <_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; 10ed2c: 09 c3 or %eax,%ebx old_mode |= _ISR_Get_level(); *previous_mode_set = old_mode; 10ed2e: 09 f3 or %esi,%ebx 10ed30: 8b 45 10 mov 0x10(%ebp),%eax 10ed33: 89 18 mov %ebx,(%eax) /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 10ed35: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) 10ed3c: 74 11 je 10ed4f executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE; 10ed3e: 89 f8 mov %edi,%eax 10ed40: c1 e8 08 shr $0x8,%eax 10ed43: 83 f0 01 xor $0x1,%eax 10ed46: 83 e0 01 and $0x1,%eax 10ed49: 8b 55 ec mov -0x14(%ebp),%edx 10ed4c: 88 42 76 mov %al,0x76(%edx) if ( mask & RTEMS_TIMESLICE_MASK ) { 10ed4f: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 10ed56: 74 26 je 10ed7e if ( _Modes_Is_timeslice(mode_set) ) { 10ed58: f7 c7 00 02 00 00 test $0x200,%edi 10ed5e: 74 14 je 10ed74 executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 10ed60: 8b 5d ec mov -0x14(%ebp),%ebx 10ed63: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx) executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10ed6a: a1 64 d7 11 00 mov 0x11d764,%eax 10ed6f: 89 43 78 mov %eax,0x78(%ebx) 10ed72: eb 0a jmp 10ed7e } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 10ed74: 8b 45 ec mov -0x14(%ebp),%eax 10ed77: c7 40 7c 00 00 00 00 movl $0x0,0x7c(%eax) /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 10ed7e: f6 45 0c 01 testb $0x1,0xc(%ebp) 10ed82: 74 0c je 10ed90 * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @param[in] alignment the required alignment 10ed84: f7 c7 01 00 00 00 test $0x1,%edi 10ed8a: 74 03 je 10ed8f 10ed8c: fa cli 10ed8d: eb 01 jmp 10ed90 10ed8f: fb sti */ is_asr_enabled = FALSE; needs_asr_dispatching = FALSE; if ( mask & RTEMS_ASR_MASK ) { 10ed90: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 10ed97: 74 3b je 10edd4 10ed99: c1 ef 0a shr $0xa,%edi 10ed9c: 83 f7 01 xor $0x1,%edi 10ed9f: 89 f8 mov %edi,%eax 10eda1: 83 e0 01 and $0x1,%eax is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true; if ( is_asr_enabled != asr->is_enabled ) { 10eda4: 8b 55 f0 mov -0x10(%ebp),%edx 10eda7: 3a 42 08 cmp 0x8(%edx),%al 10edaa: 74 28 je 10edd4 asr->is_enabled = is_asr_enabled; 10edac: 88 42 08 mov %al,0x8(%edx) uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10edaf: 9c pushf 10edb0: fa cli 10edb1: 59 pop %ecx /** 10edb2: 8b 5d f0 mov -0x10(%ebp),%ebx 10edb5: 8b 53 18 mov 0x18(%ebx),%edx * This routine grows @a the_heap memory area using the size bytes which 10edb8: 8b 43 14 mov 0x14(%ebx),%eax 10edbb: 89 43 18 mov %eax,0x18(%ebx) * begin at @a starting_address. 10edbe: 89 53 14 mov %edx,0x14(%ebx) * 10edc1: 51 push %ecx 10edc2: 9d popf _ASR_Swap_signals( asr ); if ( _ASR_Are_signals_pending( asr ) ) { 10edc3: 83 7b 14 00 cmpl $0x0,0x14(%ebx) 10edc7: 74 0b je 10edd4 <== ALWAYS TAKEN needs_asr_dispatching = true; executing->do_post_task_switch_extension = true; 10edc9: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10edcc: c6 40 75 01 movb $0x1,0x75(%eax) <== NOT EXECUTED 10edd0: b3 01 mov $0x1,%bl <== NOT EXECUTED 10edd2: eb 02 jmp 10edd6 <== NOT EXECUTED 10edd4: 31 db xor %ebx,%ebx } } } if ( _System_state_Is_up(_System_state_Current) ) 10edd6: 83 3d 38 d9 11 00 03 cmpl $0x3,0x11d938 10eddd: 75 12 jne 10edf1 <== NEVER TAKEN if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) 10eddf: e8 58 01 00 00 call 10ef3c <_Thread_Evaluate_mode> 10ede4: 84 c0 test %al,%al 10ede6: 75 04 jne 10edec 10ede8: 84 db test %bl,%bl 10edea: 74 05 je 10edf1 <== ALWAYS TAKEN _Thread_Dispatch(); 10edec: e8 57 bf ff ff call 10ad48 <_Thread_Dispatch> 10edf1: 31 c0 xor %eax,%eax return RTEMS_SUCCESSFUL; } 10edf3: 83 c4 0c add $0xc,%esp 10edf6: 5b pop %ebx 10edf7: 5e pop %esi 10edf8: 5f pop %edi 10edf9: c9 leave 10edfa: c3 ret =============================================================================== 0010ab88 : rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 10ab88: 55 push %ebp 10ab89: 89 e5 mov %esp,%ebp 10ab8b: 56 push %esi 10ab8c: 53 push %ebx 10ab8d: 83 ec 10 sub $0x10,%esp 10ab90: 8b 4d 08 mov 0x8(%ebp),%ecx 10ab93: 8b 5d 0c mov 0xc(%ebp),%ebx 10ab96: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10ab99: a1 a4 28 12 00 mov 0x1228a4,%eax 10ab9e: 8b 40 40 mov 0x40(%eax),%eax 10aba1: ba 16 00 00 00 mov $0x16,%edx 10aba6: 80 78 04 00 cmpb $0x0,0x4(%eax) 10abaa: 74 54 je 10ac00 <== NEVER TAKEN /* * NOTE: There is no check for < RTEMS_NOTEPAD_FIRST because that would * be checking an unsigned number for being negative. */ if ( notepad > RTEMS_NOTEPAD_LAST ) 10abac: ba 0a 00 00 00 mov $0xa,%edx 10abb1: 83 fb 0f cmp $0xf,%ebx 10abb4: 77 4a ja 10ac00 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10abb6: 85 c9 test %ecx,%ecx 10abb8: 74 0a je 10abc4 10abba: a1 cc 28 12 00 mov 0x1228cc,%eax 10abbf: 3b 48 08 cmp 0x8(%eax),%ecx 10abc2: 75 11 jne 10abd5 <== ALWAYS TAKEN _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10abc4: a1 cc 28 12 00 mov 0x1228cc,%eax 10abc9: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax 10abcf: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4) 10abd3: eb 29 jmp 10abfe return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10abd5: 50 push %eax 10abd6: 50 push %eax 10abd7: 8d 45 f4 lea -0xc(%ebp),%eax 10abda: 50 push %eax 10abdb: 51 push %ecx 10abdc: e8 7f 1b 00 00 call 10c760 <_Thread_Get> switch ( location ) { 10abe1: 83 c4 10 add $0x10,%esp 10abe4: ba 04 00 00 00 mov $0x4,%edx 10abe9: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10abed: 75 11 jne 10ac00 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10abef: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax 10abf5: 89 74 98 20 mov %esi,0x20(%eax,%ebx,4) _Thread_Enable_dispatch(); 10abf9: e8 42 1b 00 00 call 10c740 <_Thread_Enable_dispatch> 10abfe: 31 d2 xor %edx,%edx case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ac00: 89 d0 mov %edx,%eax 10ac02: 8d 65 f8 lea -0x8(%ebp),%esp 10ac05: 5b pop %ebx 10ac06: 5e pop %esi 10ac07: c9 leave 10ac08: c3 ret =============================================================================== 0010a3a8 : rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10a3a8: 55 push %ebp 10a3a9: 89 e5 mov %esp,%ebp 10a3ab: 56 push %esi 10a3ac: 53 push %ebx 10a3ad: 83 ec 10 sub $0x10,%esp 10a3b0: 8b 5d 0c mov 0xc(%ebp),%ebx 10a3b3: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10a3b6: 85 db test %ebx,%ebx 10a3b8: 74 10 je 10a3ca 10a3ba: 0f b6 05 24 d0 11 00 movzbl 0x11d024,%eax 10a3c1: ba 13 00 00 00 mov $0x13,%edx 10a3c6: 39 c3 cmp %eax,%ebx 10a3c8: 77 52 ja 10a41c !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10a3ca: ba 09 00 00 00 mov $0x9,%edx 10a3cf: 85 f6 test %esi,%esi 10a3d1: 74 49 je 10a41c <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10a3d3: 52 push %edx 10a3d4: 52 push %edx 10a3d5: 8d 45 f4 lea -0xc(%ebp),%eax 10a3d8: 50 push %eax 10a3d9: ff 75 08 pushl 0x8(%ebp) 10a3dc: e8 93 1a 00 00 call 10be74 <_Thread_Get> 10a3e1: 89 c1 mov %eax,%ecx switch ( location ) { 10a3e3: 83 c4 10 add $0x10,%esp 10a3e6: ba 04 00 00 00 mov $0x4,%edx 10a3eb: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10a3ef: 75 2b jne 10a41c case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10a3f1: 8b 40 14 mov 0x14(%eax),%eax 10a3f4: 89 06 mov %eax,(%esi) if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10a3f6: 85 db test %ebx,%ebx 10a3f8: 74 1b je 10a415 the_thread->real_priority = new_priority; 10a3fa: 89 59 18 mov %ebx,0x18(%ecx) if ( the_thread->resource_count == 0 || 10a3fd: 83 79 1c 00 cmpl $0x0,0x1c(%ecx) 10a401: 74 05 je 10a408 10a403: 39 59 14 cmp %ebx,0x14(%ecx) 10a406: 76 0d jbe 10a415 <== ALWAYS TAKEN the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, FALSE ); 10a408: 50 push %eax 10a409: 6a 00 push $0x0 10a40b: 53 push %ebx 10a40c: 51 push %ecx 10a40d: e8 a2 15 00 00 call 10b9b4 <_Thread_Change_priority> 10a412: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10a415: e8 3a 1a 00 00 call 10be54 <_Thread_Enable_dispatch> 10a41a: 31 d2 xor %edx,%edx case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a41c: 89 d0 mov %edx,%eax 10a41e: 8d 65 f8 lea -0x8(%ebp),%esp 10a421: 5b pop %ebx 10a422: 5e pop %esi 10a423: c9 leave 10a424: c3 ret =============================================================================== 0010a268 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 10a268: 55 push %ebp 10a269: 89 e5 mov %esp,%ebp 10a26b: 57 push %edi 10a26c: 56 push %esi 10a26d: 53 push %ebx 10a26e: 83 ec 1c sub $0x1c,%esp 10a271: 8b 75 0c mov 0xc(%ebp),%esi 10a274: 8b 7d 10 mov 0x10(%ebp),%edi Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 10a277: b8 09 00 00 00 mov $0x9,%eax 10a27c: 85 f6 test %esi,%esi 10a27e: 74 75 je 10a2f5 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 10a280: 50 push %eax 10a281: 50 push %eax 10a282: 8d 45 f0 lea -0x10(%ebp),%eax 10a285: 50 push %eax 10a286: ff 75 08 pushl 0x8(%ebp) 10a289: e8 86 1a 00 00 call 10bd14 <_Thread_Get> 10a28e: 89 c3 mov %eax,%ebx switch (location) { 10a290: 83 c4 10 add $0x10,%esp 10a293: b8 04 00 00 00 mov $0x4,%eax 10a298: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 10a29c: 75 57 jne 10a2f5 <== NEVER TAKEN case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 10a29e: 8b 83 04 01 00 00 mov 0x104(%ebx),%eax 10a2a4: eb 0c jmp 10a2b2 while (tvp) { if (tvp->ptr == ptr) { 10a2a6: 39 70 04 cmp %esi,0x4(%eax) 10a2a9: 75 05 jne 10a2b0 tvp->dtor = dtor; 10a2ab: 89 78 10 mov %edi,0x10(%eax) 10a2ae: eb 3e jmp 10a2ee _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 10a2b0: 8b 00 mov (%eax),%eax case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 10a2b2: 85 c0 test %eax,%eax 10a2b4: 75 f0 jne 10a2a6 } /* * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) 10a2b6: 83 ec 0c sub $0xc,%esp 10a2b9: 6a 14 push $0x14 10a2bb: e8 d1 29 00 00 call 10cc91 <_Workspace_Allocate> 10a2c0: 89 c2 mov %eax,%edx _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 10a2c2: 83 c4 10 add $0x10,%esp 10a2c5: 85 c0 test %eax,%eax 10a2c7: 75 0c jne 10a2d5 _Thread_Enable_dispatch(); 10a2c9: e8 26 1a 00 00 call 10bcf4 <_Thread_Enable_dispatch> 10a2ce: b8 1a 00 00 00 mov $0x1a,%eax 10a2d3: eb 20 jmp 10a2f5 return RTEMS_NO_MEMORY; } new->gval = *ptr; 10a2d5: 8b 06 mov (%esi),%eax 10a2d7: 89 42 08 mov %eax,0x8(%edx) new->ptr = ptr; 10a2da: 89 72 04 mov %esi,0x4(%edx) new->dtor = dtor; 10a2dd: 89 7a 10 mov %edi,0x10(%edx) new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 10a2e0: 8b 83 04 01 00 00 mov 0x104(%ebx),%eax 10a2e6: 89 02 mov %eax,(%edx) the_thread->task_variables = new; 10a2e8: 89 93 04 01 00 00 mov %edx,0x104(%ebx) _Thread_Enable_dispatch(); 10a2ee: e8 01 1a 00 00 call 10bcf4 <_Thread_Enable_dispatch> 10a2f3: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a2f5: 8d 65 f4 lea -0xc(%ebp),%esp 10a2f8: 5b pop %ebx 10a2f9: 5e pop %esi 10a2fa: 5f pop %edi 10a2fb: c9 leave 10a2fc: c3 ret =============================================================================== 0010a300 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 10a300: 55 push %ebp 10a301: 89 e5 mov %esp,%ebp 10a303: 56 push %esi 10a304: 53 push %ebx 10a305: 83 ec 10 sub $0x10,%esp 10a308: 8b 75 0c mov 0xc(%ebp),%esi Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 10a30b: b8 09 00 00 00 mov $0x9,%eax 10a310: 85 f6 test %esi,%esi 10a312: 74 64 je 10a378 return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); 10a314: 52 push %edx 10a315: 52 push %edx 10a316: 8d 45 f4 lea -0xc(%ebp),%eax 10a319: 50 push %eax 10a31a: ff 75 08 pushl 0x8(%ebp) 10a31d: e8 f2 19 00 00 call 10bd14 <_Thread_Get> 10a322: 89 c3 mov %eax,%ebx switch (location) { 10a324: 83 c4 10 add $0x10,%esp 10a327: b8 04 00 00 00 mov $0x4,%eax 10a32c: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10a330: 75 46 jne 10a378 <== NEVER TAKEN case OBJECTS_LOCAL: tvp = the_thread->task_variables; 10a332: 8b 93 04 01 00 00 mov 0x104(%ebx),%edx 10a338: 31 c0 xor %eax,%eax 10a33a: eb 2e jmp 10a36a while (tvp) { if (tvp->ptr == ptr) { 10a33c: 39 72 04 cmp %esi,0x4(%edx) 10a33f: 75 25 jne 10a366 if (prev) 10a341: 85 c0 test %eax,%eax 10a343: 8b 0a mov (%edx),%ecx 10a345: 74 04 je 10a34b prev->next = tvp->next; 10a347: 89 08 mov %ecx,(%eax) 10a349: eb 06 jmp 10a351 else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 10a34b: 89 8b 04 01 00 00 mov %ecx,0x104(%ebx) _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); 10a351: 50 push %eax 10a352: 50 push %eax 10a353: 52 push %edx 10a354: 53 push %ebx 10a355: e8 8e 00 00 00 call 10a3e8 <_RTEMS_Tasks_Invoke_task_variable_dtor> _Thread_Enable_dispatch(); 10a35a: e8 95 19 00 00 call 10bcf4 <_Thread_Enable_dispatch> 10a35f: 31 c0 xor %eax,%eax 10a361: 83 c4 10 add $0x10,%esp 10a364: eb 12 jmp 10a378 return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 10a366: 89 d0 mov %edx,%eax 10a368: 8b 12 mov (%edx),%edx the_thread = _Thread_Get (tid, &location); switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 10a36a: 85 d2 test %edx,%edx 10a36c: 75 ce jne 10a33c return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 10a36e: e8 81 19 00 00 call 10bcf4 <_Thread_Enable_dispatch> 10a373: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a378: 8d 65 f8 lea -0x8(%ebp),%esp 10a37b: 5b pop %ebx 10a37c: 5e pop %esi 10a37d: c9 leave 10a37e: c3 ret =============================================================================== 0010a380 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 10a380: 55 push %ebp 10a381: 89 e5 mov %esp,%ebp 10a383: 56 push %esi 10a384: 53 push %ebx 10a385: 83 ec 10 sub $0x10,%esp 10a388: 8b 5d 0c mov 0xc(%ebp),%ebx 10a38b: 8b 75 10 mov 0x10(%ebp),%esi Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 10a38e: 85 db test %ebx,%ebx 10a390: 74 48 je 10a3da return RTEMS_INVALID_ADDRESS; if ( !result ) 10a392: 85 f6 test %esi,%esi 10a394: 74 44 je 10a3da return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 10a396: 50 push %eax 10a397: 50 push %eax 10a398: 8d 45 f4 lea -0xc(%ebp),%eax 10a39b: 50 push %eax 10a39c: ff 75 08 pushl 0x8(%ebp) 10a39f: e8 70 19 00 00 call 10bd14 <_Thread_Get> 10a3a4: 89 c2 mov %eax,%edx switch (location) { 10a3a6: 83 c4 10 add $0x10,%esp 10a3a9: b8 04 00 00 00 mov $0x4,%eax 10a3ae: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10a3b2: 75 2b jne 10a3df <== NEVER TAKEN case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 10a3b4: 8b 82 04 01 00 00 mov 0x104(%edx),%eax 10a3ba: eb 15 jmp 10a3d1 while (tvp) { if (tvp->ptr == ptr) { 10a3bc: 39 58 04 cmp %ebx,0x4(%eax) 10a3bf: 75 0e jne 10a3cf /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 10a3c1: 8b 40 0c mov 0xc(%eax),%eax 10a3c4: 89 06 mov %eax,(%esi) _Thread_Enable_dispatch(); 10a3c6: e8 29 19 00 00 call 10bcf4 <_Thread_Enable_dispatch> 10a3cb: 31 c0 xor %eax,%eax 10a3cd: eb 10 jmp 10a3df return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 10a3cf: 8b 00 mov (%eax),%eax case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 10a3d1: 85 c0 test %eax,%eax 10a3d3: 75 e7 jne 10a3bc _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 10a3d5: e8 1a 19 00 00 call 10bcf4 <_Thread_Enable_dispatch> return RTEMS_INVALID_ADDRESS; 10a3da: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a3df: 8d 65 f8 lea -0x8(%ebp),%esp 10a3e2: 5b pop %ebx 10a3e3: 5e pop %esi 10a3e4: c9 leave 10a3e5: c3 ret =============================================================================== 0010a150 : */ rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer ) { 10a150: 55 push %ebp 10a151: 89 e5 mov %esp,%ebp 10a153: 53 push %ebx 10a154: 83 ec 04 sub $0x4,%esp 10a157: 8b 5d 08 mov 0x8(%ebp),%ebx Watchdog_Interval seconds; if ( !_TOD_Is_set ) 10a15a: b8 0b 00 00 00 mov $0xb,%eax 10a15f: 80 3d d0 0d 12 00 00 cmpb $0x0,0x120dd0 10a166: 0f 84 9e 00 00 00 je 10a20a return RTEMS_NOT_DEFINED; if ( !time_buffer ) 10a16c: b8 09 00 00 00 mov $0x9,%eax 10a171: 85 db test %ebx,%ebx 10a173: 0f 84 91 00 00 00 je 10a20a <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; time_buffer->ticks = 0; 10a179: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) if ( !_TOD_Validate( time_buffer ) ) 10a180: 83 ec 0c sub $0xc,%esp 10a183: 53 push %ebx 10a184: e8 d7 f4 ff ff call 109660 <_TOD_Validate> 10a189: 83 c4 10 add $0x10,%esp 10a18c: 84 c0 test %al,%al 10a18e: 74 75 je 10a205 return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); 10a190: 83 ec 0c sub $0xc,%esp 10a193: 53 push %ebx 10a194: e8 5f f4 ff ff call 1095f8 <_TOD_To_seconds> 10a199: 89 c3 mov %eax,%ebx if ( seconds <= _TOD_Seconds_since_epoch ) 10a19b: 83 c4 10 add $0x10,%esp 10a19e: 3b 05 4c 0e 12 00 cmp 0x120e4c,%eax 10a1a4: 76 5f jbe 10a205 /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a1a6: a1 bc 0d 12 00 mov 0x120dbc,%eax 10a1ab: 40 inc %eax 10a1ac: a3 bc 0d 12 00 mov %eax,0x120dbc return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME ); 10a1b1: 50 push %eax 10a1b2: 50 push %eax 10a1b3: 6a 10 push $0x10 10a1b5: ff 35 7c 0e 12 00 pushl 0x120e7c 10a1bb: e8 24 21 00 00 call 10c2e4 <_Thread_Set_state> _Watchdog_Initialize( 10a1c0: a1 7c 0e 12 00 mov 0x120e7c,%eax 10a1c5: 8b 50 08 mov 0x8(%eax),%edx * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10a1c8: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) * @param[in] the_heap is the heap to operate upon 10a1cf: c7 40 64 78 b9 10 00 movl $0x10b978,0x64(%eax) * @param[in] starting_address is the starting address of the memory for 10a1d6: 89 50 68 mov %edx,0x68(%eax) * the heap 10a1d9: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax) * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, 10a1e0: 2b 1d 4c 0e 12 00 sub 0x120e4c,%ebx 10a1e6: 89 58 54 mov %ebx,0x54(%eax) size_t size ); 10a1e9: 5a pop %edx 10a1ea: 59 pop %ecx 10a1eb: 83 c0 48 add $0x48,%eax 10a1ee: 50 push %eax 10a1ef: 68 90 0e 12 00 push $0x120e90 10a1f4: e8 03 27 00 00 call 10c8fc <_Watchdog_Insert> ); _Watchdog_Insert_seconds( &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); 10a1f9: e8 f6 18 00 00 call 10baf4 <_Thread_Enable_dispatch> 10a1fe: 31 c0 xor %eax,%eax 10a200: 83 c4 10 add $0x10,%esp 10a203: eb 05 jmp 10a20a return RTEMS_SUCCESSFUL; 10a205: b8 14 00 00 00 mov $0x14,%eax } 10a20a: 8b 5d fc mov -0x4(%ebp),%ebx 10a20d: c9 leave 10a20e: c3 ret =============================================================================== 001071a0 : rtems_status_code rtems_termios_bufsize ( int cbufsize, int raw_input, int raw_output ) { 1071a0: 55 push %ebp <== NOT EXECUTED 1071a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED rtems_termios_cbufsize = cbufsize; 1071a3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1071a6: a3 3c b6 11 00 mov %eax,0x11b63c <== NOT EXECUTED rtems_termios_raw_input_size = raw_input; 1071ab: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1071ae: a3 40 b6 11 00 mov %eax,0x11b640 <== NOT EXECUTED rtems_termios_raw_output_size = raw_output; 1071b3: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1071b6: a3 44 b6 11 00 mov %eax,0x11b644 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 1071bb: 31 c0 xor %eax,%eax <== NOT EXECUTED 1071bd: c9 leave <== NOT EXECUTED 1071be: c3 ret <== NOT EXECUTED =============================================================================== 0010833e : } } rtems_status_code rtems_termios_close (void *arg) { 10833e: 55 push %ebp 10833f: 89 e5 mov %esp,%ebp 108341: 56 push %esi 108342: 53 push %ebx 108343: 8b 75 08 mov 0x8(%ebp),%esi rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 108346: 8b 06 mov (%esi),%eax 108348: 8b 58 28 mov 0x28(%eax),%ebx rtems_status_code sc; sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 10834b: 50 push %eax 10834c: 6a 00 push $0x0 10834e: 6a 00 push $0x0 108350: ff 35 d4 d6 11 00 pushl 0x11d6d4 108356: e8 19 0e 00 00 call 109174 if (sc != RTEMS_SUCCESSFUL) 10835b: 83 c4 10 add $0x10,%esp 10835e: 85 c0 test %eax,%eax 108360: 75 69 jne 1083cb <== NEVER TAKEN rtems_fatal_error_occurred (sc); if (--tty->refcount == 0) { 108362: 8b 43 08 mov 0x8(%ebx),%eax 108365: 48 dec %eax 108366: 89 43 08 mov %eax,0x8(%ebx) 108369: 85 c0 test %eax,%eax 10836b: 0f 85 1f 01 00 00 jne 108490 if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 108371: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 108377: c1 e0 05 shl $0x5,%eax 10837a: 8b 80 50 d4 11 00 mov 0x11d450(%eax),%eax 108380: 85 c0 test %eax,%eax 108382: 74 0b je 10838f <== ALWAYS TAKEN /* * call discipline-specific close */ sc = rtems_termios_linesw[tty->t_line].l_close(tty); 108384: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108387: 53 push %ebx <== NOT EXECUTED 108388: ff d0 call *%eax <== NOT EXECUTED 10838a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10838d: eb 07 jmp 108396 <== NOT EXECUTED } else { /* * default: just flush output buffer */ drainOutput (tty); 10838f: 89 d8 mov %ebx,%eax 108391: e8 ec f8 ff ff call 107c82 } if (tty->device.outputUsesInterrupts 108396: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 10839d: 75 35 jne 1083d4 <== ALWAYS TAKEN == TERMIOS_TASK_DRIVEN) { /* * send "terminate" to I/O tasks */ sc = rtems_event_send( 10839f: 50 push %eax <== NOT EXECUTED 1083a0: 50 push %eax <== NOT EXECUTED 1083a1: 6a 01 push $0x1 <== NOT EXECUTED 1083a3: ff b3 c4 00 00 00 pushl 0xc4(%ebx) <== NOT EXECUTED 1083a9: e8 36 09 00 00 call 108ce4 <== NOT EXECUTED tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) 1083ae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1083b1: 85 c0 test %eax,%eax <== NOT EXECUTED 1083b3: 75 16 jne 1083cb <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_event_send( 1083b5: 51 push %ecx <== NOT EXECUTED 1083b6: 51 push %ecx <== NOT EXECUTED 1083b7: 6a 01 push $0x1 <== NOT EXECUTED 1083b9: ff b3 c8 00 00 00 pushl 0xc8(%ebx) <== NOT EXECUTED 1083bf: e8 20 09 00 00 call 108ce4 <== NOT EXECUTED tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) 1083c4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1083c7: 85 c0 test %eax,%eax <== NOT EXECUTED 1083c9: 74 09 je 1083d4 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 1083cb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1083ce: 50 push %eax <== NOT EXECUTED 1083cf: e8 c0 13 00 00 call 109794 <== NOT EXECUTED } if (tty->device.lastClose) 1083d4: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax 1083da: 85 c0 test %eax,%eax 1083dc: 74 0d je 1083eb <== NEVER TAKEN (*tty->device.lastClose)(tty->major, tty->minor, arg); 1083de: 52 push %edx 1083df: 56 push %esi 1083e0: ff 73 10 pushl 0x10(%ebx) 1083e3: ff 73 0c pushl 0xc(%ebx) 1083e6: ff d0 call *%eax 1083e8: 83 c4 10 add $0x10,%esp if (tty->forw == NULL) { 1083eb: 8b 13 mov (%ebx),%edx 1083ed: 85 d2 test %edx,%edx 1083ef: 8b 43 04 mov 0x4(%ebx),%eax 1083f2: 75 11 jne 108405 <== NEVER TAKEN rtems_termios_ttyTail = tty->back; 1083f4: a3 d8 d6 11 00 mov %eax,0x11d6d8 if ( rtems_termios_ttyTail != NULL ) { 1083f9: 85 c0 test %eax,%eax 1083fb: 74 0b je 108408 <== ALWAYS TAKEN rtems_termios_ttyTail->forw = NULL; 1083fd: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 108403: eb 03 jmp 108408 <== NOT EXECUTED } } else { tty->forw->back = tty->back; 108405: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED } if (tty->back == NULL) { 108408: 8b 53 04 mov 0x4(%ebx),%edx 10840b: 85 d2 test %edx,%edx 10840d: 8b 03 mov (%ebx),%eax 10840f: 75 12 jne 108423 <== NEVER TAKEN rtems_termios_ttyHead = tty->forw; 108411: a3 dc d6 11 00 mov %eax,0x11d6dc if ( rtems_termios_ttyHead != NULL ) { 108416: 85 c0 test %eax,%eax 108418: 74 0b je 108425 <== ALWAYS TAKEN rtems_termios_ttyHead->back = NULL; 10841a: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED 108421: eb 02 jmp 108425 <== NOT EXECUTED } } else { tty->back->forw = tty->forw; 108423: 89 02 mov %eax,(%edx) <== NOT EXECUTED } rtems_semaphore_delete (tty->isem); 108425: 83 ec 0c sub $0xc,%esp 108428: ff 73 14 pushl 0x14(%ebx) 10842b: e8 b4 0c 00 00 call 1090e4 rtems_semaphore_delete (tty->osem); 108430: 58 pop %eax 108431: ff 73 18 pushl 0x18(%ebx) 108434: e8 ab 0c 00 00 call 1090e4 rtems_semaphore_delete (tty->rawOutBuf.Semaphore); 108439: 58 pop %eax 10843a: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 108440: e8 9f 0c 00 00 call 1090e4 if ((tty->device.pollRead == NULL) || 108445: 83 c4 10 add $0x10,%esp 108448: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx) 10844f: 74 09 je 10845a <== ALWAYS TAKEN 108451: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) <== NOT EXECUTED 108458: 75 0e jne 108468 <== NOT EXECUTED (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)) rtems_semaphore_delete (tty->rawInBuf.Semaphore); 10845a: 83 ec 0c sub $0xc,%esp 10845d: ff 73 68 pushl 0x68(%ebx) 108460: e8 7f 0c 00 00 call 1090e4 108465: 83 c4 10 add $0x10,%esp free (tty->rawInBuf.theBuf); 108468: 83 ec 0c sub $0xc,%esp 10846b: ff 73 58 pushl 0x58(%ebx) 10846e: e8 05 e0 ff ff call 106478 free (tty->rawOutBuf.theBuf); 108473: 5e pop %esi 108474: ff 73 7c pushl 0x7c(%ebx) 108477: e8 fc df ff ff call 106478 free (tty->cbuf); 10847c: 59 pop %ecx 10847d: ff 73 1c pushl 0x1c(%ebx) 108480: e8 f3 df ff ff call 106478 free (tty); 108485: 89 1c 24 mov %ebx,(%esp) 108488: e8 eb df ff ff call 106478 10848d: 83 c4 10 add $0x10,%esp } rtems_semaphore_release (rtems_termios_ttyMutex); 108490: 83 ec 0c sub $0xc,%esp 108493: ff 35 d4 d6 11 00 pushl 0x11d6d4 108499: e8 be 0d 00 00 call 10925c return RTEMS_SUCCESSFUL; } 10849e: 31 c0 xor %eax,%eax 1084a0: 8d 65 f8 lea -0x8(%ebp),%esp 1084a3: 5b pop %ebx 1084a4: 5e pop %esi 1084a5: c9 leave 1084a6: c3 ret =============================================================================== 001073a7 : * for each transmitted character. * It returns number of characters left to transmit */ int rtems_termios_dequeue_characters (void *ttyp, int len) { 1073a7: 55 push %ebp 1073a8: 89 e5 mov %esp,%ebp 1073aa: 83 ec 08 sub $0x8,%esp 1073ad: 8b 55 08 mov 0x8(%ebp),%edx rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len; 1073b0: 8b 45 0c mov 0xc(%ebp),%eax 1073b3: 01 82 90 00 00 00 add %eax,0x90(%edx) if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 1073b9: 83 ba b4 00 00 00 02 cmpl $0x2,0xb4(%edx) 1073c0: 75 1f jne 1073e1 <== ALWAYS TAKEN /* * send wake up to transmitter task */ sc = rtems_event_send(tty->txTaskId, 1073c2: 50 push %eax <== NOT EXECUTED 1073c3: 50 push %eax <== NOT EXECUTED 1073c4: 6a 02 push $0x2 <== NOT EXECUTED 1073c6: ff b2 c8 00 00 00 pushl 0xc8(%edx) <== NOT EXECUTED 1073cc: e8 13 19 00 00 call 108ce4 <== NOT EXECUTED TERMIOS_TX_START_EVENT); if (sc != RTEMS_SUCCESSFUL) 1073d1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1073d4: 85 c0 test %eax,%eax <== NOT EXECUTED 1073d6: 74 2f je 107407 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 1073d8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1073db: 50 push %eax <== NOT EXECUTED 1073dc: e8 b3 23 00 00 call 109794 <== NOT EXECUTED return 0; /* nothing to output in IRQ... */ } else if (tty->t_line == PPPDISC ) { 1073e1: 83 ba cc 00 00 00 05 cmpl $0x5,0xcc(%edx) 1073e8: 75 14 jne 1073fe <== ALWAYS TAKEN /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 1073ea: a1 00 d5 11 00 mov 0x11d500,%eax <== NOT EXECUTED 1073ef: 85 c0 test %eax,%eax <== NOT EXECUTED 1073f1: 74 14 je 107407 <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_start(tty); 1073f3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1073f6: 52 push %edx <== NOT EXECUTED 1073f7: ff d0 call *%eax <== NOT EXECUTED 1073f9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1073fc: eb 09 jmp 107407 <== NOT EXECUTED } return 0; /* nothing to output in IRQ... */ } else { return rtems_termios_refill_transmitter(tty); 1073fe: 89 55 08 mov %edx,0x8(%ebp) } } 107401: c9 leave rtems_termios_linesw[tty->t_line].l_start(tty); } return 0; /* nothing to output in IRQ... */ } else { return rtems_termios_refill_transmitter(tty); 107402: e9 d3 fd ff ff jmp 1071da } } 107407: 31 c0 xor %eax,%eax 107409: c9 leave <== NOT EXECUTED 10740a: c3 ret <== NOT EXECUTED =============================================================================== 0010740b : * 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) { 10740b: 55 push %ebp <== NOT EXECUTED 10740c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10740e: 57 push %edi <== NOT EXECUTED 10740f: 56 push %esi <== NOT EXECUTED 107410: 53 push %ebx <== NOT EXECUTED 107411: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 107414: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED char c; int dropped = 0; bool flow_rcv = false; /* true, if flow control char received */ rtems_interrupt_level level; if (rtems_termios_linesw[tty->t_line].l_rint != NULL) { 107417: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 10741d: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 107420: 83 b8 5c d4 11 00 00 cmpl $0x0,0x11d45c(%eax) <== NOT EXECUTED 107427: 75 37 jne 107460 <== NOT EXECUTED 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, 107429: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED 10742c: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 10742f: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED 107432: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 107435: 31 ff xor %edi,%edi <== NOT EXECUTED 107437: c6 45 ea 00 movb $0x0,-0x16(%ebp) <== NOT EXECUTED 10743b: e9 27 02 00 00 jmp 107667 <== NOT EXECUTED 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++; 107440: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 107443: 0f be 11 movsbl (%ecx),%edx <== NOT EXECUTED 107446: 41 inc %ecx <== NOT EXECUTED 107447: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_rint(c,tty); 10744a: 56 push %esi <== NOT EXECUTED 10744b: 56 push %esi <== NOT EXECUTED 10744c: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 107452: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 107455: 53 push %ebx <== NOT EXECUTED 107456: 52 push %edx <== NOT EXECUTED 107457: ff 90 5c d4 11 00 call *0x11d45c(%eax) <== NOT EXECUTED 10745d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 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--) { 107460: ff 4d 10 decl 0x10(%ebp) <== NOT EXECUTED 107463: 83 7d 10 ff cmpl $0xffffffff,0x10(%ebp) <== NOT EXECUTED 107467: 75 d7 jne 107440 <== NOT EXECUTED } /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 107469: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx) <== NOT EXECUTED 107470: 0f 85 11 02 00 00 jne 107687 <== NOT EXECUTED 107476: 8b 93 dc 00 00 00 mov 0xdc(%ebx),%edx <== NOT EXECUTED 10747c: 85 d2 test %edx,%edx <== NOT EXECUTED 10747e: 0f 84 03 02 00 00 je 107687 <== NOT EXECUTED (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 107484: 51 push %ecx <== NOT EXECUTED 107485: 51 push %ecx <== NOT EXECUTED 107486: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED 10748c: 8d 43 30 lea 0x30(%ebx),%eax <== NOT EXECUTED 10748f: 50 push %eax <== NOT EXECUTED 107490: ff d2 call *%edx <== NOT EXECUTED tty->tty_rcvwakeup = 1; 107492: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED 107499: 00 00 00 10749c: 31 ff xor %edi,%edi <== NOT EXECUTED 10749e: e9 df 01 00 00 jmp 107682 <== NOT EXECUTED } return 0; } while (len--) { c = *buf++; 1074a3: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1074a6: 8a 00 mov (%eax),%al <== NOT EXECUTED 1074a8: 88 45 eb mov %al,-0x15(%ebp) <== NOT EXECUTED /* FIXME: implement IXANY: any character restarts output */ /* if incoming XON/XOFF controls outgoing stream: */ if (tty->flow_ctrl & FL_MDXON) { 1074ab: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1074b1: f6 c4 02 test $0x2,%ah <== NOT EXECUTED 1074b4: 74 43 je 1074f9 <== NOT EXECUTED /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { 1074b6: 0f be 55 eb movsbl -0x15(%ebp),%edx <== NOT EXECUTED 1074ba: 0f b6 43 4a movzbl 0x4a(%ebx),%eax <== NOT EXECUTED 1074be: 39 c2 cmp %eax,%edx <== NOT EXECUTED 1074c0: 75 1e jne 1074e0 <== NOT EXECUTED if (c == tty->termios.c_cc[VSTART]) { 1074c2: 0f b6 43 49 movzbl 0x49(%ebx),%eax <== NOT EXECUTED 1074c6: 39 c2 cmp %eax,%edx <== NOT EXECUTED 1074c8: 75 0b jne 1074d5 <== NOT EXECUTED /* received VSTOP and VSTART==VSTOP? */ /* then toggle "stop output" status */ tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; 1074ca: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1074d0: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED 1074d3: eb 1c jmp 1074f1 <== NOT EXECUTED } else { /* VSTOP received (other code than VSTART) */ /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; 1074d5: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1074db: 83 c8 10 or $0x10,%eax <== NOT EXECUTED 1074de: eb 11 jmp 1074f1 <== NOT EXECUTED } flow_rcv = true; } else if (c == tty->termios.c_cc[VSTART]) { 1074e0: 0f b6 43 49 movzbl 0x49(%ebx),%eax <== NOT EXECUTED 1074e4: 39 c2 cmp %eax,%edx <== NOT EXECUTED 1074e6: 75 11 jne 1074f9 <== NOT EXECUTED /* VSTART received */ /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; 1074e8: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1074ee: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED 1074f1: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED 1074f7: eb 06 jmp 1074ff <== NOT EXECUTED flow_rcv = true; } } if (flow_rcv) { 1074f9: 80 7d ea 00 cmpb $0x0,-0x16(%ebp) <== NOT EXECUTED 1074fd: 74 55 je 107554 <== NOT EXECUTED /* restart output according to FL_ORCVXOF flag */ if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) { 1074ff: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 107505: 83 e0 30 and $0x30,%eax <== NOT EXECUTED 107508: c6 45 ea 01 movb $0x1,-0x16(%ebp) <== NOT EXECUTED 10750c: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED 10750f: 0f 85 4f 01 00 00 jne 107664 <== NOT EXECUTED /* disable interrupts */ rtems_interrupt_disable(level); 107515: 9c pushf <== NOT EXECUTED 107516: fa cli <== NOT EXECUTED 107517: 5e pop %esi <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 107518: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10751e: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 107521: 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) { 107527: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 10752e: 74 19 je 107549 <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)(tty->minor, 107530: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED 107536: 52 push %edx <== NOT EXECUTED 107537: 6a 01 push $0x1 <== NOT EXECUTED 107539: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 10753c: 50 push %eax <== NOT EXECUTED 10753d: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 107540: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 107546: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1); } /* reenable interrupts */ rtems_interrupt_enable(level); 107549: 56 push %esi <== NOT EXECUTED 10754a: 9d popf <== NOT EXECUTED 10754b: c6 45 ea 01 movb $0x1,-0x16(%ebp) <== NOT EXECUTED 10754f: e9 10 01 00 00 jmp 107664 <== NOT EXECUTED } } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; 107554: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED 107557: 8b 4b 64 mov 0x64(%ebx),%ecx <== NOT EXECUTED 10755a: 40 inc %eax <== NOT EXECUTED 10755b: 31 d2 xor %edx,%edx <== NOT EXECUTED 10755d: f7 f1 div %ecx <== NOT EXECUTED 10755f: 89 d6 mov %edx,%esi <== NOT EXECUTED /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); 107561: 9c pushf <== NOT EXECUTED 107562: fa cli <== NOT EXECUTED 107563: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 107566: 8b 4b 5c mov 0x5c(%ebx),%ecx <== NOT EXECUTED 107569: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED 10756c: 8b 53 64 mov 0x64(%ebx),%edx <== NOT EXECUTED 10756f: 29 c8 sub %ecx,%eax <== NOT EXECUTED 107571: 01 f0 add %esi,%eax <== NOT EXECUTED 107573: 89 d1 mov %edx,%ecx <== NOT EXECUTED 107575: 31 d2 xor %edx,%edx <== NOT EXECUTED 107577: f7 f1 div %ecx <== NOT EXECUTED 107579: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx <== NOT EXECUTED 10757f: 0f 86 98 00 00 00 jbe 10761d <== NOT EXECUTED 107585: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10758b: a8 01 test $0x1,%al <== NOT EXECUTED 10758d: 0f 85 8a 00 00 00 jne 10761d <== NOT EXECUTED % tty->rawInBuf.Size) > tty->highwater) && !(tty->flow_ctrl & FL_IREQXOF)) { /* incoming data stream should be stopped */ tty->flow_ctrl |= FL_IREQXOF; 107593: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 107599: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10759c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF)) 1075a2: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1075a8: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED 1075ad: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED 1075b2: 75 33 jne 1075e7 <== NOT EXECUTED == (FL_MDXOF ) ){ if ((tty->flow_ctrl & FL_OSTOP) || 1075b4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1075ba: a8 20 test $0x20,%al <== NOT EXECUTED 1075bc: 75 09 jne 1075c7 <== NOT EXECUTED 1075be: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 1075c5: 75 56 jne 10761d <== 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; 1075c7: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1075cd: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 1075d0: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED (*tty->device.write)(tty->minor, 1075d6: 51 push %ecx <== NOT EXECUTED 1075d7: 6a 01 push $0x1 <== NOT EXECUTED 1075d9: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 1075dc: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1075df: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 1075e5: eb 33 jmp 10761a <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTOP]), 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) 1075e7: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1075ed: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED 1075f2: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED 1075f7: 75 24 jne 10761d <== NOT EXECUTED == (FL_MDRTS ) ) { tty->flow_ctrl |= FL_IRTSOFF; 1075f9: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1075ff: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 107602: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* deactivate RTS line */ if (tty->device.stopRemoteTx != NULL) { 107608: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED 10760e: 85 c0 test %eax,%eax <== NOT EXECUTED 107610: 74 0b je 10761d <== NOT EXECUTED tty->device.stopRemoteTx(tty->minor); 107612: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107615: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 107618: ff d0 call *%eax <== NOT EXECUTED 10761a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } } /* reenable interrupts */ rtems_interrupt_enable(level); 10761d: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 107620: 9d popf <== NOT EXECUTED if (newTail == tty->rawInBuf.Head) { 107621: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED 107624: 39 c6 cmp %eax,%esi <== NOT EXECUTED 107626: 75 03 jne 10762b <== NOT EXECUTED dropped++; 107628: 47 inc %edi <== NOT EXECUTED 107629: eb 39 jmp 107664 <== NOT EXECUTED } else { tty->rawInBuf.theBuf[newTail] = c; 10762b: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED 10762e: 8a 55 eb mov -0x15(%ebp),%dl <== NOT EXECUTED 107631: 88 14 30 mov %dl,(%eax,%esi,1) <== NOT EXECUTED tty->rawInBuf.Tail = newTail; 107634: 89 73 60 mov %esi,0x60(%ebx) <== NOT EXECUTED /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 107637: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx) <== NOT EXECUTED 10763e: 75 24 jne 107664 <== NOT EXECUTED 107640: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax <== NOT EXECUTED 107646: 85 c0 test %eax,%eax <== NOT EXECUTED 107648: 74 1a je 107664 <== NOT EXECUTED (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 10764a: 52 push %edx <== NOT EXECUTED 10764b: 52 push %edx <== NOT EXECUTED 10764c: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED 107652: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 107655: ff d0 call *%eax <== NOT EXECUTED tty->tty_rcvwakeup = 1; 107657: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED 10765e: 00 00 00 107661: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } while (len--) { c = *buf++; 107664: ff 45 0c incl 0xc(%ebp) <== NOT EXECUTED tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 107667: ff 4d 10 decl 0x10(%ebp) <== NOT EXECUTED 10766a: 83 7d 10 ff cmpl $0xffffffff,0x10(%ebp) <== NOT EXECUTED 10766e: 0f 85 2f fe ff ff jne 1074a3 <== NOT EXECUTED tty->tty_rcvwakeup = 1; } } } } tty->rawInBufDropped += dropped; 107674: 01 7b 78 add %edi,0x78(%ebx) <== NOT EXECUTED rtems_semaphore_release (tty->rawInBuf.Semaphore); 107677: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10767a: ff 73 68 pushl 0x68(%ebx) <== NOT EXECUTED 10767d: e8 da 1b 00 00 call 10925c <== NOT EXECUTED 107682: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107685: eb 02 jmp 107689 <== NOT EXECUTED return dropped; 107687: 31 ff xor %edi,%edi <== NOT EXECUTED } 107689: 89 f8 mov %edi,%eax <== NOT EXECUTED 10768b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10768e: 5b pop %ebx <== NOT EXECUTED 10768f: 5e pop %esi <== NOT EXECUTED 107690: 5f pop %edi <== NOT EXECUTED 107691: c9 leave <== NOT EXECUTED 107692: c3 ret <== NOT EXECUTED =============================================================================== 00107164 : struct rtems_termios_tty *rtems_termios_ttyTail; rtems_id rtems_termios_ttyMutex; void rtems_termios_initialize (void) { 107164: 55 push %ebp 107165: 89 e5 mov %esp,%ebp 107167: 83 ec 08 sub $0x8,%esp rtems_status_code sc; /* * Create the mutex semaphore for the tty list */ if (!rtems_termios_ttyMutex) { 10716a: 83 3d d4 d6 11 00 00 cmpl $0x0,0x11d6d4 107171: 75 28 jne 10719b <== NEVER TAKEN sc = rtems_semaphore_create ( 107173: 83 ec 0c sub $0xc,%esp 107176: 68 d4 d6 11 00 push $0x11d6d4 10717b: 6a 00 push $0x0 10717d: 6a 54 push $0x54 10717f: 6a 01 push $0x1 107181: 68 69 6d 52 54 push $0x54526d69 107186: e8 b5 1d 00 00 call 108f40 rtems_build_name ('T', 'R', 'm', 'i'), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_termios_ttyMutex); if (sc != RTEMS_SUCCESSFUL) 10718b: 83 c4 20 add $0x20,%esp 10718e: 85 c0 test %eax,%eax 107190: 74 09 je 10719b <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 107192: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107195: 50 push %eax <== NOT EXECUTED 107196: e8 f9 25 00 00 call 109794 <== NOT EXECUTED } } 10719b: c9 leave 10719c: c3 ret =============================================================================== 00107fe9 : } } rtems_status_code rtems_termios_ioctl (void *arg) { 107fe9: 55 push %ebp <== NOT EXECUTED 107fea: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107fec: 57 push %edi <== NOT EXECUTED 107fed: 56 push %esi <== NOT EXECUTED 107fee: 53 push %ebx <== NOT EXECUTED 107fef: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 107ff2: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 107ff5: 8b 02 mov (%edx),%eax <== NOT EXECUTED 107ff7: 8b 58 28 mov 0x28(%eax),%ebx <== NOT EXECUTED struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer; 107ffa: 8b 72 08 mov 0x8(%edx),%esi <== NOT EXECUTED rtems_status_code sc; args->ioctl_return = 0; 107ffd: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 108004: 6a 00 push $0x0 <== NOT EXECUTED 108006: 6a 00 push $0x0 <== NOT EXECUTED 108008: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10800b: e8 64 11 00 00 call 109174 <== NOT EXECUTED 108010: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) { 108013: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108016: 85 c0 test %eax,%eax <== NOT EXECUTED 108018: 74 0b je 108025 <== NOT EXECUTED args->ioctl_return = sc; 10801a: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10801d: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED 108020: e9 0e 03 00 00 jmp 108333 <== NOT EXECUTED return sc; } switch (args->command) { 108025: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 108028: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10802b: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10802e: 0f 84 56 02 00 00 je 10828a <== NOT EXECUTED 108034: 77 10 ja 108046 <== NOT EXECUTED 108036: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 108039: 74 75 je 1080b0 <== NOT EXECUTED 10803b: 0f 87 27 02 00 00 ja 108268 <== NOT EXECUTED 108041: 48 dec %eax <== NOT EXECUTED 108042: 75 2f jne 108073 <== NOT EXECUTED 108044: eb 55 jmp 10809b <== NOT EXECUTED 108046: 3d 7f 66 04 40 cmp $0x4004667f,%eax <== NOT EXECUTED 10804b: 0f 84 ae 02 00 00 je 1082ff <== NOT EXECUTED 108051: 77 0a ja 10805d <== NOT EXECUTED 108053: 83 f8 05 cmp $0x5,%eax <== NOT EXECUTED 108056: 75 1b jne 108073 <== NOT EXECUTED 108058: e9 17 02 00 00 jmp 108274 <== NOT EXECUTED 10805d: 3d 1a 74 04 40 cmp $0x4004741a,%eax <== NOT EXECUTED 108062: 0f 84 87 02 00 00 je 1082ef <== NOT EXECUTED 108068: 3d 1b 74 04 80 cmp $0x8004741b,%eax <== NOT EXECUTED 10806d: 0f 84 2a 02 00 00 je 10829d <== NOT EXECUTED default: if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) { 108073: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 108079: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 10807c: 8b 80 64 d4 11 00 mov 0x11d464(%eax),%eax <== NOT EXECUTED 108082: c7 45 e0 0a 00 00 00 movl $0xa,-0x20(%ebp) <== NOT EXECUTED 108089: 85 c0 test %eax,%eax <== NOT EXECUTED 10808b: 0f 84 8b 02 00 00 je 10831c <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args); 108091: 52 push %edx <== NOT EXECUTED 108092: 52 push %edx <== NOT EXECUTED 108093: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 108096: e9 49 02 00 00 jmp 1082e4 <== NOT EXECUTED sc = RTEMS_INVALID_NUMBER; } break; case RTEMS_IO_GET_ATTRIBUTES: *(struct termios *)args->buffer = tty->termios; 10809b: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10809e: 8b 79 08 mov 0x8(%ecx),%edi <== NOT EXECUTED 1080a1: 8d 73 30 lea 0x30(%ebx),%esi <== NOT EXECUTED 1080a4: b9 09 00 00 00 mov $0x9,%ecx <== NOT EXECUTED 1080a9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1080ab: e9 6c 02 00 00 jmp 10831c <== NOT EXECUTED break; case RTEMS_IO_SET_ATTRIBUTES: tty->termios = *(struct termios *)args->buffer; 1080b0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1080b3: 8b 70 08 mov 0x8(%eax),%esi <== NOT EXECUTED 1080b6: 8d 7b 30 lea 0x30(%ebx),%edi <== NOT EXECUTED 1080b9: b9 09 00 00 00 mov $0x9,%ecx <== NOT EXECUTED 1080be: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* * check for flow control options to be switched off */ /* check for outgoing XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXON) && 1080c0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1080c6: f6 c4 02 test $0x2,%ah <== NOT EXECUTED 1080c9: 74 57 je 108122 <== NOT EXECUTED 1080cb: f6 43 31 04 testb $0x4,0x31(%ebx) <== NOT EXECUTED 1080cf: 75 51 jne 108122 <== NOT EXECUTED !(tty->termios.c_iflag & IXON)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF); 1080d1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1080d7: 25 ef fd ff ff and $0xfffffdef,%eax <== NOT EXECUTED 1080dc: 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) { 1080e2: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1080e8: a8 20 test $0x20,%al <== NOT EXECUTED 1080ea: 74 36 je 108122 <== NOT EXECUTED /* disable interrupts */ rtems_interrupt_disable(level); 1080ec: 9c pushf <== NOT EXECUTED 1080ed: fa cli <== NOT EXECUTED 1080ee: 5e pop %esi <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 1080ef: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1080f5: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 1080f8: 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) { 1080fe: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 108105: 74 19 je 108120 <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)(tty->minor, 108107: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED 10810d: 57 push %edi <== NOT EXECUTED 10810e: 6a 01 push $0x1 <== NOT EXECUTED 108110: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 108113: 50 push %eax <== NOT EXECUTED 108114: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108117: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 10811d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } /* reenable interrupts */ rtems_interrupt_enable(level); 108120: 56 push %esi <== NOT EXECUTED 108121: 9d popf <== NOT EXECUTED } } /* check for incoming XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXOF) && 108122: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108128: f6 c4 04 test $0x4,%ah <== NOT EXECUTED 10812b: 74 24 je 108151 <== NOT EXECUTED 10812d: f6 43 31 10 testb $0x10,0x31(%ebx) <== NOT EXECUTED 108131: 75 1e jne 108151 <== NOT EXECUTED !(tty->termios.c_iflag & IXOFF)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXOF); 108133: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108139: 80 e4 fb and $0xfb,%ah <== NOT EXECUTED 10813c: 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); 108142: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108148: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 10814b: 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) && 108151: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108157: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 10815a: 74 43 je 10819f <== NOT EXECUTED 10815c: 83 7b 38 00 cmpl $0x0,0x38(%ebx) <== NOT EXECUTED 108160: 78 3d js 10819f <== NOT EXECUTED !(tty->termios.c_cflag & CRTSCTS)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDRTS); 108162: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108168: 80 e4 fe and $0xfe,%ah <== NOT EXECUTED 10816b: 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) && 108171: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108177: a8 04 test $0x4,%al <== NOT EXECUTED 108179: 74 15 je 108190 <== NOT EXECUTED 10817b: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 108181: 85 c0 test %eax,%eax <== NOT EXECUTED 108183: 74 0b je 108190 <== NOT EXECUTED (tty->device.startRemoteTx != NULL)) { tty->device.startRemoteTx(tty->minor); 108185: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108188: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10818b: ff d0 call *%eax <== NOT EXECUTED 10818d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } tty->flow_ctrl &= ~(FL_IRTSOFF); 108190: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108196: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 108199: 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) { 10819f: 83 7b 38 00 cmpl $0x0,0x38(%ebx) <== NOT EXECUTED 1081a3: 79 0f jns 1081b4 <== NOT EXECUTED tty->flow_ctrl |= FL_MDRTS; 1081a5: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1081ab: 80 cc 01 or $0x1,%ah <== NOT EXECUTED 1081ae: 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) { 1081b4: f6 43 31 10 testb $0x10,0x31(%ebx) <== NOT EXECUTED 1081b8: 74 0f je 1081c9 <== NOT EXECUTED tty->flow_ctrl |= FL_MDXOF; 1081ba: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1081c0: 80 cc 04 or $0x4,%ah <== NOT EXECUTED 1081c3: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } /* check for outgoing XON/XOF flow control switched on */ if (tty->termios.c_iflag & IXON) { 1081c9: f6 43 31 04 testb $0x4,0x31(%ebx) <== NOT EXECUTED 1081cd: 74 0f je 1081de <== NOT EXECUTED tty->flow_ctrl |= FL_MDXON; 1081cf: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1081d5: 80 cc 02 or $0x2,%ah <== NOT EXECUTED 1081d8: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED 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) { 1081de: f6 43 3c 02 testb $0x2,0x3c(%ebx) <== NOT EXECUTED 1081e2: 75 45 jne 108229 <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { rtems_interval ticksPerSecond; rtems_clock_get (RTEMS_CLOCK_GET_TICKS_PER_SECOND, &ticksPerSecond); 1081e4: 56 push %esi <== NOT EXECUTED 1081e5: 56 push %esi <== NOT EXECUTED 1081e6: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 1081e9: 50 push %eax <== NOT EXECUTED 1081ea: 6a 03 push $0x3 <== NOT EXECUTED 1081ec: e8 93 07 00 00 call 108984 <== NOT EXECUTED tty->vtimeTicks = tty->termios.c_cc[VTIME] * ticksPerSecond / 10; 1081f1: 0f b6 43 46 movzbl 0x46(%ebx),%eax <== NOT EXECUTED 1081f5: 0f af 45 f0 imul -0x10(%ebp),%eax <== NOT EXECUTED 1081f9: b9 0a 00 00 00 mov $0xa,%ecx <== NOT EXECUTED 1081fe: 31 d2 xor %edx,%edx <== NOT EXECUTED 108200: f7 f1 div %ecx <== NOT EXECUTED 108202: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED if (tty->termios.c_cc[VTIME]) { 108205: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108208: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED 10820c: 74 15 je 108223 <== NOT EXECUTED tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 10820e: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = tty->vtimeTicks; 108215: 89 43 70 mov %eax,0x70(%ebx) <== NOT EXECUTED if (tty->termios.c_cc[VMIN]) 108218: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED 10821c: 75 19 jne 108237 <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; 10821e: 89 43 74 mov %eax,0x74(%ebx) <== NOT EXECUTED 108221: eb 24 jmp 108247 <== NOT EXECUTED } else { if (tty->termios.c_cc[VMIN]) { 108223: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED 108227: 74 17 je 108240 <== NOT EXECUTED tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 108229: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; 108230: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; 108237: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx) <== NOT EXECUTED 10823e: eb 07 jmp 108247 <== NOT EXECUTED } else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; 108240: c7 43 6c 01 00 00 00 movl $0x1,0x6c(%ebx) <== NOT EXECUTED } } } if (tty->device.setAttributes) 108247: 8b 93 a8 00 00 00 mov 0xa8(%ebx),%edx <== NOT EXECUTED 10824d: 85 d2 test %edx,%edx <== NOT EXECUTED 10824f: 0f 84 c7 00 00 00 je 10831c <== NOT EXECUTED (*tty->device.setAttributes)(tty->minor, &tty->termios); 108255: 51 push %ecx <== NOT EXECUTED 108256: 51 push %ecx <== NOT EXECUTED 108257: 8d 43 30 lea 0x30(%ebx),%eax <== NOT EXECUTED 10825a: 50 push %eax <== NOT EXECUTED 10825b: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10825e: ff d2 call *%edx <== NOT EXECUTED 108260: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108263: e9 b4 00 00 00 jmp 10831c <== NOT EXECUTED break; case RTEMS_IO_TCDRAIN: drainOutput (tty); 108268: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10826a: e8 13 fa ff ff call 107c82 <== NOT EXECUTED 10826f: e9 a8 00 00 00 jmp 10831c <== NOT EXECUTED break; case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; 108274: 8b 16 mov (%esi),%edx <== NOT EXECUTED 108276: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 108279: 89 83 d8 00 00 00 mov %eax,0xd8(%ebx) <== NOT EXECUTED 10827f: 89 93 d4 00 00 00 mov %edx,0xd4(%ebx) <== NOT EXECUTED 108285: e9 92 00 00 00 jmp 10831c <== NOT EXECUTED break; case RTEMS_IO_RCVWAKEUP: tty->tty_rcv = *wakeup; 10828a: 8b 16 mov (%esi),%edx <== NOT EXECUTED 10828c: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10828f: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx) <== NOT EXECUTED 108295: 89 93 dc 00 00 00 mov %edx,0xdc(%ebx) <== NOT EXECUTED 10829b: eb 7f jmp 10831c <== NOT EXECUTED #if 1 /* FIXME */ case TIOCSETD: /* * close old line discipline */ if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 10829d: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 1082a3: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 1082a6: 8b 80 50 d4 11 00 mov 0x11d450(%eax),%eax <== NOT EXECUTED 1082ac: 85 c0 test %eax,%eax <== NOT EXECUTED 1082ae: 74 0c je 1082bc <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_close(tty); 1082b0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1082b3: 53 push %ebx <== NOT EXECUTED 1082b4: ff d0 call *%eax <== NOT EXECUTED 1082b6: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 1082b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } tty->t_line=*(int*)(args->buffer); 1082bc: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1082bf: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 1082c2: 8b 00 mov (%eax),%eax <== NOT EXECUTED 1082c4: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx) <== NOT EXECUTED tty->t_sc = NULL; /* ensure that no more valid data */ 1082ca: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx) <== NOT EXECUTED 1082d1: 00 00 00 /* * open new line discipline */ if (rtems_termios_linesw[tty->t_line].l_open != NULL) { 1082d4: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 1082d7: 8b 80 4c d4 11 00 mov 0x11d44c(%eax),%eax <== NOT EXECUTED 1082dd: 85 c0 test %eax,%eax <== NOT EXECUTED 1082df: 74 3b je 10831c <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_open(tty); 1082e1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1082e4: 53 push %ebx <== NOT EXECUTED 1082e5: ff d0 call *%eax <== NOT EXECUTED 1082e7: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 1082ea: e9 71 ff ff ff jmp 108260 <== NOT EXECUTED } break; case TIOCGETD: *(int*)(args->buffer)=tty->t_line; 1082ef: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1082f2: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 1082f5: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 1082fb: 89 02 mov %eax,(%edx) <== NOT EXECUTED 1082fd: eb 1d jmp 10831c <== NOT EXECUTED break; #endif case FIONREAD: { int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head; 1082ff: 8b 53 60 mov 0x60(%ebx),%edx <== NOT EXECUTED 108302: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED if ( rawnc < 0 ) 108305: 29 c2 sub %eax,%edx <== NOT EXECUTED 108307: 79 05 jns 10830e <== NOT EXECUTED rawnc += tty->rawInBuf.Size; 108309: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED 10830c: 01 c2 add %eax,%edx <== NOT EXECUTED /* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; 10830e: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 108311: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 108314: 03 53 20 add 0x20(%ebx),%edx <== NOT EXECUTED 108317: 2b 53 24 sub 0x24(%ebx),%edx <== NOT EXECUTED 10831a: 89 10 mov %edx,(%eax) <== NOT EXECUTED } break; } rtems_semaphore_release (tty->osem); 10831c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10831f: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 108322: e8 35 0f 00 00 call 10925c <== NOT EXECUTED args->ioctl_return = sc; 108327: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 10832a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10832d: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED 108330: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return sc; } 108333: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 108336: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108339: 5b pop %ebx <== NOT EXECUTED 10833a: 5e pop %esi <== NOT EXECUTED 10833b: 5f pop %edi <== NOT EXECUTED 10833c: c9 leave <== NOT EXECUTED 10833d: c3 ret <== NOT EXECUTED =============================================================================== 001084a7 : rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) { 1084a7: 55 push %ebp 1084a8: 89 e5 mov %esp,%ebp 1084aa: 57 push %edi 1084ab: 56 push %esi 1084ac: 53 push %ebx 1084ad: 83 ec 10 sub $0x10,%esp struct rtems_termios_tty *tty; /* * See if the device has already been opened */ sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, 1084b0: 6a 00 push $0x0 1084b2: 6a 00 push $0x0 1084b4: ff 35 d4 d6 11 00 pushl 0x11d6d4 1084ba: e8 b5 0c 00 00 call 109174 1084bf: 89 45 f0 mov %eax,-0x10(%ebp) RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 1084c2: 83 c4 10 add $0x10,%esp 1084c5: 85 c0 test %eax,%eax 1084c7: 0f 85 c0 03 00 00 jne 10888d <== NEVER TAKEN return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 1084cd: a1 dc d6 11 00 mov 0x11d6dc,%eax 1084d2: eb 1c jmp 1084f0 if ((tty->major == major) && (tty->minor == minor)) 1084d4: 8b 4d 08 mov 0x8(%ebp),%ecx 1084d7: 8b 55 e8 mov -0x18(%ebp),%edx 1084da: 39 4a 0c cmp %ecx,0xc(%edx) 1084dd: 75 0c jne 1084eb <== NEVER TAKEN 1084df: 8b 75 0c mov 0xc(%ebp),%esi 1084e2: 39 72 10 cmp %esi,0x10(%edx) 1084e5: 0f 84 14 03 00 00 je 1087ff <== 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) { 1084eb: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1084ee: 8b 00 mov (%eax),%eax <== NOT EXECUTED 1084f0: 89 45 e8 mov %eax,-0x18(%ebp) 1084f3: 83 7d e8 00 cmpl $0x0,-0x18(%ebp) 1084f7: 75 db jne 1084d4 1084f9: e9 9a 03 00 00 jmp 108898 /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); if (tty == NULL) { rtems_semaphore_release (rtems_termios_ttyMutex); 1084fe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108501: e9 9d 00 00 00 jmp 1085a3 <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; 108506: a1 40 b6 11 00 mov 0x11b640,%eax 10850b: 8b 55 e8 mov -0x18(%ebp),%edx 10850e: 89 42 64 mov %eax,0x64(%edx) tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size); 108511: 8b 42 64 mov 0x64(%edx),%eax 108514: 83 ec 0c sub $0xc,%esp 108517: 50 push %eax 108518: e8 57 e1 ff ff call 106674 10851d: 8b 4d e8 mov -0x18(%ebp),%ecx 108520: 89 41 58 mov %eax,0x58(%ecx) if (tty->rawInBuf.theBuf == NULL) { 108523: 83 c4 10 add $0x10,%esp 108526: 85 c0 test %eax,%eax 108528: 75 06 jne 108530 <== ALWAYS TAKEN free(tty); 10852a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10852d: 51 push %ecx <== NOT EXECUTED 10852e: eb 6d jmp 10859d <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate raw output buffer */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; 108530: a1 44 b6 11 00 mov 0x11b644,%eax 108535: 8b 75 e8 mov -0x18(%ebp),%esi 108538: 89 86 88 00 00 00 mov %eax,0x88(%esi) tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size); 10853e: 8b 86 88 00 00 00 mov 0x88(%esi),%eax 108544: 83 ec 0c sub $0xc,%esp 108547: 50 push %eax 108548: e8 27 e1 ff ff call 106674 10854d: 89 46 7c mov %eax,0x7c(%esi) if (tty->rawOutBuf.theBuf == NULL) { 108550: 83 c4 10 add $0x10,%esp 108553: 85 c0 test %eax,%eax 108555: 75 10 jne 108567 <== ALWAYS TAKEN free((void *)(tty->rawInBuf.theBuf)); 108557: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10855a: ff 76 58 pushl 0x58(%esi) <== NOT EXECUTED 10855d: e8 16 df ff ff call 106478 <== NOT EXECUTED free(tty); 108562: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 108565: eb 36 jmp 10859d <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); 108567: 83 ec 0c sub $0xc,%esp 10856a: ff 35 3c b6 11 00 pushl 0x11b63c 108570: e8 ff e0 ff ff call 106674 108575: 8b 55 e8 mov -0x18(%ebp),%edx 108578: 89 42 1c mov %eax,0x1c(%edx) if (tty->cbuf == NULL) { 10857b: 83 c4 10 add $0x10,%esp 10857e: 85 c0 test %eax,%eax 108580: 75 38 jne 1085ba <== ALWAYS TAKEN free((void *)(tty->rawOutBuf.theBuf)); 108582: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108585: ff 72 7c pushl 0x7c(%edx) <== NOT EXECUTED 108588: e8 eb de ff ff call 106478 <== NOT EXECUTED free((void *)(tty->rawInBuf.theBuf)); 10858d: 58 pop %eax <== NOT EXECUTED 10858e: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 108591: ff 71 58 pushl 0x58(%ecx) <== NOT EXECUTED 108594: e8 df de ff ff call 106478 <== NOT EXECUTED free(tty); 108599: 58 pop %eax <== NOT EXECUTED 10859a: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 10859d: e8 d6 de ff ff call 106478 <== NOT EXECUTED rtems_semaphore_release (rtems_termios_ttyMutex); 1085a2: 5f pop %edi <== NOT EXECUTED 1085a3: ff 35 d4 d6 11 00 pushl 0x11d6d4 <== NOT EXECUTED 1085a9: e8 ae 0c 00 00 call 10925c <== NOT EXECUTED 1085ae: c7 45 f0 1a 00 00 00 movl $0x1a,-0x10(%ebp) <== NOT EXECUTED 1085b5: e9 d0 02 00 00 jmp 10888a <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * Initialize wakeup callbacks */ tty->tty_snd.sw_pfn = NULL; 1085ba: 8b 75 e8 mov -0x18(%ebp),%esi 1085bd: c7 86 d4 00 00 00 00 movl $0x0,0xd4(%esi) 1085c4: 00 00 00 tty->tty_snd.sw_arg = NULL; 1085c7: c7 86 d8 00 00 00 00 movl $0x0,0xd8(%esi) 1085ce: 00 00 00 tty->tty_rcv.sw_pfn = NULL; 1085d1: c7 86 dc 00 00 00 00 movl $0x0,0xdc(%esi) 1085d8: 00 00 00 tty->tty_rcv.sw_arg = NULL; 1085db: c7 86 e0 00 00 00 00 movl $0x0,0xe0(%esi) 1085e2: 00 00 00 tty->tty_rcvwakeup = 0; 1085e5: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) 1085ec: 00 00 00 /* * link tty */ tty->forw = rtems_termios_ttyHead; 1085ef: a1 dc d6 11 00 mov 0x11d6dc,%eax 1085f4: 89 06 mov %eax,(%esi) tty->back = NULL; 1085f6: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) if (rtems_termios_ttyHead != NULL) 1085fd: 85 c0 test %eax,%eax 1085ff: 74 03 je 108604 <== ALWAYS TAKEN rtems_termios_ttyHead->back = tty; 108601: 89 70 04 mov %esi,0x4(%eax) <== NOT EXECUTED rtems_termios_ttyHead = tty; 108604: 89 1d dc d6 11 00 mov %ebx,0x11d6dc if (rtems_termios_ttyTail == NULL) 10860a: 83 3d d8 d6 11 00 00 cmpl $0x0,0x11d6d8 108611: 75 06 jne 108619 <== NEVER TAKEN rtems_termios_ttyTail = tty; 108613: 89 1d d8 d6 11 00 mov %ebx,0x11d6d8 tty->minor = minor; 108619: 8b 45 0c mov 0xc(%ebp),%eax 10861c: 89 43 10 mov %eax,0x10(%ebx) tty->major = major; 10861f: 8b 55 08 mov 0x8(%ebp),%edx 108622: 89 53 0c mov %edx,0xc(%ebx) /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 108625: 83 ec 0c sub $0xc,%esp 108628: 8d 43 14 lea 0x14(%ebx),%eax 10862b: 50 push %eax 10862c: 6a 00 push $0x0 10862e: 6a 54 push $0x54 108630: 6a 01 push $0x1 108632: 0f be 05 48 b6 11 00 movsbl 0x11b648,%eax 108639: 0d 00 69 52 54 or $0x54526900,%eax 10863e: 50 push %eax 10863f: e8 fc 08 00 00 call 108f40 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) 108644: 83 c4 20 add $0x20,%esp 108647: 85 c0 test %eax,%eax 108649: 0f 85 24 02 00 00 jne 108873 <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 10864f: 83 ec 0c sub $0xc,%esp 108652: 8d 43 18 lea 0x18(%ebx),%eax 108655: 50 push %eax 108656: 6a 00 push $0x0 108658: 6a 54 push $0x54 10865a: 6a 01 push $0x1 10865c: 0f be 05 48 b6 11 00 movsbl 0x11b648,%eax 108663: 0d 00 6f 52 54 or $0x54526f00,%eax 108668: 50 push %eax 108669: e8 d2 08 00 00 call 108f40 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) 10866e: 83 c4 20 add $0x20,%esp 108671: 85 c0 test %eax,%eax 108673: 0f 85 fa 01 00 00 jne 108873 <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 108679: 83 ec 0c sub $0xc,%esp 10867c: 8d 83 8c 00 00 00 lea 0x8c(%ebx),%eax 108682: 50 push %eax 108683: 6a 00 push $0x0 108685: 6a 20 push $0x20 108687: 6a 00 push $0x0 108689: 0f be 05 48 b6 11 00 movsbl 0x11b648,%eax 108690: 0d 00 78 52 54 or $0x54527800,%eax 108695: 50 push %eax 108696: e8 a5 08 00 00 call 108f40 rtems_build_name ('T', 'R', 'x', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO, RTEMS_NO_PRIORITY, &tty->rawOutBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 10869b: 83 c4 20 add $0x20,%esp 10869e: 85 c0 test %eax,%eax 1086a0: 0f 85 cd 01 00 00 jne 108873 <== NEVER TAKEN rtems_fatal_error_occurred (sc); tty->rawOutBufState = rob_idle; 1086a6: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx) 1086ad: 00 00 00 /* * Set callbacks */ tty->device = *callbacks; 1086b0: 8d bb 98 00 00 00 lea 0x98(%ebx),%edi 1086b6: b9 08 00 00 00 mov $0x8,%ecx 1086bb: 8b 75 14 mov 0x14(%ebp),%esi 1086be: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 1086c0: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 1086c7: 75 68 jne 108731 <== ALWAYS TAKEN sc = rtems_task_create ( 1086c9: 56 push %esi <== NOT EXECUTED 1086ca: 56 push %esi <== NOT EXECUTED 1086cb: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax <== NOT EXECUTED 1086d1: 50 push %eax <== NOT EXECUTED 1086d2: 6a 00 push $0x0 <== NOT EXECUTED 1086d4: 68 00 05 00 00 push $0x500 <== NOT EXECUTED 1086d9: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 1086de: 6a 0a push $0xa <== NOT EXECUTED 1086e0: 0f be 05 48 b6 11 00 movsbl 0x11b648,%eax <== NOT EXECUTED 1086e7: 0d 00 54 78 54 or $0x54785400,%eax <== NOT EXECUTED 1086ec: 50 push %eax <== NOT EXECUTED 1086ed: e8 fa 0b 00 00 call 1092ec <== NOT EXECUTED TERMIOS_TXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->txTaskId); if (sc != RTEMS_SUCCESSFUL) 1086f2: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1086f5: 85 c0 test %eax,%eax <== NOT EXECUTED 1086f7: 0f 85 76 01 00 00 jne 108873 <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_task_create ( 1086fd: 51 push %ecx <== NOT EXECUTED 1086fe: 51 push %ecx <== NOT EXECUTED 1086ff: 8d 83 c4 00 00 00 lea 0xc4(%ebx),%eax <== NOT EXECUTED 108705: 50 push %eax <== NOT EXECUTED 108706: 6a 00 push $0x0 <== NOT EXECUTED 108708: 68 00 05 00 00 push $0x500 <== NOT EXECUTED 10870d: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 108712: 6a 09 push $0x9 <== NOT EXECUTED 108714: 0f be 05 48 b6 11 00 movsbl 0x11b648,%eax <== NOT EXECUTED 10871b: 0d 00 54 78 52 or $0x52785400,%eax <== NOT EXECUTED 108720: 50 push %eax <== NOT EXECUTED 108721: e8 c6 0b 00 00 call 1092ec <== NOT EXECUTED TERMIOS_RXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->rxTaskId); if (sc != RTEMS_SUCCESSFUL) 108726: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 108729: 85 c0 test %eax,%eax <== NOT EXECUTED 10872b: 0f 85 42 01 00 00 jne 108873 <== NOT EXECUTED rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || 108731: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx) 108738: 74 09 je 108743 <== ALWAYS TAKEN 10873a: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) <== NOT EXECUTED 108741: 75 2a jne 10876d <== NOT EXECUTED (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 108743: 83 ec 0c sub $0xc,%esp 108746: 8d 43 68 lea 0x68(%ebx),%eax 108749: 50 push %eax 10874a: 6a 00 push $0x0 10874c: 6a 24 push $0x24 10874e: 6a 00 push $0x0 108750: 0f be 05 48 b6 11 00 movsbl 0x11b648,%eax 108757: 0d 00 72 52 54 or $0x54527200,%eax 10875c: 50 push %eax 10875d: e8 de 07 00 00 call 108f40 rtems_build_name ('T', 'R', 'r', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->rawInBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 108762: 83 c4 20 add $0x20,%esp 108765: 85 c0 test %eax,%eax 108767: 0f 85 06 01 00 00 jne 108873 <== NEVER TAKEN } /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; 10876d: c7 43 30 02 25 00 00 movl $0x2502,0x30(%ebx) tty->termios.c_oflag = OPOST | ONLCR | XTABS; 108774: c7 43 34 05 18 00 00 movl $0x1805,0x34(%ebx) tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; 10877b: c7 43 38 bd 08 00 00 movl $0x8bd,0x38(%ebx) tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL; 108782: c7 43 3c 3b 82 00 00 movl $0x823b,0x3c(%ebx) tty->termios.c_cc[VINTR] = '\003'; 108789: c6 43 41 03 movb $0x3,0x41(%ebx) tty->termios.c_cc[VQUIT] = '\034'; 10878d: c6 43 42 1c movb $0x1c,0x42(%ebx) tty->termios.c_cc[VERASE] = '\177'; 108791: c6 43 43 7f movb $0x7f,0x43(%ebx) tty->termios.c_cc[VKILL] = '\025'; 108795: c6 43 44 15 movb $0x15,0x44(%ebx) tty->termios.c_cc[VEOF] = '\004'; 108799: c6 43 45 04 movb $0x4,0x45(%ebx) tty->termios.c_cc[VEOL] = '\000'; 10879d: c6 43 4c 00 movb $0x0,0x4c(%ebx) tty->termios.c_cc[VEOL2] = '\000'; 1087a1: c6 43 51 00 movb $0x0,0x51(%ebx) tty->termios.c_cc[VSTART] = '\021'; 1087a5: c6 43 49 11 movb $0x11,0x49(%ebx) tty->termios.c_cc[VSTOP] = '\023'; 1087a9: c6 43 4a 13 movb $0x13,0x4a(%ebx) tty->termios.c_cc[VSUSP] = '\032'; 1087ad: c6 43 4b 1a movb $0x1a,0x4b(%ebx) tty->termios.c_cc[VREPRINT] = '\022'; 1087b1: c6 43 4d 12 movb $0x12,0x4d(%ebx) tty->termios.c_cc[VDISCARD] = '\017'; 1087b5: c6 43 4e 0f movb $0xf,0x4e(%ebx) tty->termios.c_cc[VWERASE] = '\027'; 1087b9: c6 43 4f 17 movb $0x17,0x4f(%ebx) tty->termios.c_cc[VLNEXT] = '\026'; 1087bd: c6 43 50 16 movb $0x16,0x50(%ebx) /* start with no flow control, clear flow control flags */ tty->flow_ctrl = 0; 1087c1: c7 83 b8 00 00 00 00 movl $0x0,0xb8(%ebx) 1087c8: 00 00 00 /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2; 1087cb: 8b 43 64 mov 0x64(%ebx),%eax 1087ce: d1 e8 shr %eax 1087d0: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) tty->highwater = tty->rawInBuf.Size * 3/4; 1087d6: 8b 43 64 mov 0x64(%ebx),%eax 1087d9: 8d 04 40 lea (%eax,%eax,2),%eax 1087dc: c1 e8 02 shr $0x2,%eax 1087df: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx) /* * Bump name characer */ if (c++ == 'z') 1087e5: 8a 15 48 b6 11 00 mov 0x11b648,%dl 1087eb: 8d 42 01 lea 0x1(%edx),%eax 1087ee: a2 48 b6 11 00 mov %al,0x11b648 1087f3: 80 fa 7a cmp $0x7a,%dl 1087f6: 75 07 jne 1087ff <== ALWAYS TAKEN c = 'a'; 1087f8: c6 05 48 b6 11 00 61 movb $0x61,0x11b648 <== NOT EXECUTED } args->iop->data1 = tty; 1087ff: 8b 55 10 mov 0x10(%ebp),%edx 108802: 8b 02 mov (%edx),%eax 108804: 8b 4d e8 mov -0x18(%ebp),%ecx 108807: 89 48 28 mov %ecx,0x28(%eax) if (!tty->refcount++) { 10880a: 8b 51 08 mov 0x8(%ecx),%edx 10880d: 8d 42 01 lea 0x1(%edx),%eax 108810: 89 41 08 mov %eax,0x8(%ecx) 108813: 85 d2 test %edx,%edx 108815: 75 65 jne 10887c if (tty->device.firstOpen) 108817: 8b 81 98 00 00 00 mov 0x98(%ecx),%eax 10881d: 85 c0 test %eax,%eax 10881f: 74 0f je 108830 <== NEVER TAKEN (*tty->device.firstOpen)(major, minor, arg); 108821: 52 push %edx 108822: ff 75 10 pushl 0x10(%ebp) 108825: ff 75 0c pushl 0xc(%ebp) 108828: ff 75 08 pushl 0x8(%ebp) 10882b: ff d0 call *%eax 10882d: 83 c4 10 add $0x10,%esp /* * start I/O tasks, if needed */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 108830: 8b 75 e8 mov -0x18(%ebp),%esi 108833: 83 be b4 00 00 00 02 cmpl $0x2,0xb4(%esi) 10883a: 75 40 jne 10887c <== ALWAYS TAKEN sc = rtems_task_start(tty->rxTaskId, 10883c: 50 push %eax <== NOT EXECUTED 10883d: 56 push %esi <== NOT EXECUTED 10883e: 68 1e 89 10 00 push $0x10891e <== NOT EXECUTED 108843: ff b6 c4 00 00 00 pushl 0xc4(%esi) <== NOT EXECUTED 108849: e8 0e 0d 00 00 call 10955c <== NOT EXECUTED rtems_termios_rxdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 10884e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108851: 85 c0 test %eax,%eax <== NOT EXECUTED 108853: 75 1e jne 108873 <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_task_start(tty->txTaskId, 108855: 50 push %eax <== NOT EXECUTED 108856: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 108859: 68 bb 88 10 00 push $0x1088bb <== NOT EXECUTED 10885e: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 108861: ff b0 c8 00 00 00 pushl 0xc8(%eax) <== NOT EXECUTED 108867: e8 f0 0c 00 00 call 10955c <== NOT EXECUTED rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 10886c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10886f: 85 c0 test %eax,%eax <== NOT EXECUTED 108871: 74 09 je 10887c <== NOT EXECUTED rtems_fatal_error_occurred (sc); 108873: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108876: 50 push %eax <== NOT EXECUTED 108877: e8 18 0f 00 00 call 109794 <== NOT EXECUTED } } rtems_semaphore_release (rtems_termios_ttyMutex); 10887c: 83 ec 0c sub $0xc,%esp 10887f: ff 35 d4 d6 11 00 pushl 0x11d6d4 108885: e8 d2 09 00 00 call 10925c 10888a: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; } 10888d: 8b 45 f0 mov -0x10(%ebp),%eax 108890: 8d 65 f4 lea -0xc(%ebp),%esp 108893: 5b pop %ebx 108894: 5e pop %esi 108895: 5f pop %edi 108896: c9 leave 108897: c3 ret static char c = 'a'; /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); 108898: 50 push %eax 108899: 50 push %eax 10889a: 68 e8 00 00 00 push $0xe8 10889f: 6a 01 push $0x1 1088a1: e8 2a 44 00 00 call 10ccd0 1088a6: 89 45 e8 mov %eax,-0x18(%ebp) 1088a9: 89 c3 mov %eax,%ebx if (tty == NULL) { 1088ab: 83 c4 10 add $0x10,%esp 1088ae: 85 c0 test %eax,%eax 1088b0: 0f 85 50 fc ff ff jne 108506 <== ALWAYS TAKEN 1088b6: e9 43 fc ff ff jmp 1084fe <== NOT EXECUTED =============================================================================== 00107693 : * Send characters to device-specific code */ void rtems_termios_puts ( const void *_buf, int len, struct rtems_termios_tty *tty) { 107693: 55 push %ebp 107694: 89 e5 mov %esp,%ebp 107696: 57 push %edi 107697: 56 push %esi 107698: 53 push %ebx 107699: 83 ec 1c sub $0x1c,%esp 10769c: 8b 45 08 mov 0x8(%ebp),%eax 10769f: 8b 55 0c mov 0xc(%ebp),%edx 1076a2: 89 55 e8 mov %edx,-0x18(%ebp) 1076a5: 8b 5d 10 mov 0x10(%ebp),%ebx const unsigned char *buf = _buf; 1076a8: 89 45 ec mov %eax,-0x14(%ebp) unsigned int newHead; rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { 1076ab: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx) 1076b2: 75 1b jne 1076cf <== ALWAYS TAKEN (*tty->device.write)(tty->minor, (void *)buf, len); 1076b4: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED 1076b7: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1076ba: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 1076bd: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 1076c0: 8b 8b a4 00 00 00 mov 0xa4(%ebx),%ecx <== NOT EXECUTED tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 1076c6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1076c9: 5b pop %ebx <== NOT EXECUTED 1076ca: 5e pop %esi <== NOT EXECUTED 1076cb: 5f pop %edi <== NOT EXECUTED 1076cc: c9 leave <== NOT EXECUTED 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); 1076cd: ff e1 jmp *%ecx <== NOT EXECUTED return; } newHead = tty->rawOutBuf.Head; 1076cf: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 1076d5: 89 45 f0 mov %eax,-0x10(%ebp) 1076d8: e9 b9 00 00 00 jmp 107796 * len -= ncopy * * To minimize latency, the memcpy should be done * with interrupts enabled. */ newHead = (newHead + 1) % tty->rawOutBuf.Size; 1076dd: 8b 75 f0 mov -0x10(%ebp),%esi 1076e0: 46 inc %esi 1076e1: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx 1076e7: 89 f0 mov %esi,%eax 1076e9: 31 d2 xor %edx,%edx 1076eb: f7 f1 div %ecx 1076ed: 89 d6 mov %edx,%esi 1076ef: 89 55 f0 mov %edx,-0x10(%ebp) rtems_interrupt_disable (level); 1076f2: 9c pushf 1076f3: fa cli 1076f4: 5f pop %edi 1076f5: eb 2f jmp 107726 while (newHead == tty->rawOutBuf.Tail) { tty->rawOutBufState = rob_wait; 1076f7: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) 1076fe: 00 00 00 rtems_interrupt_enable (level); 107701: 57 push %edi 107702: 9d popf sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, 107703: 51 push %ecx 107704: 6a 00 push $0x0 107706: 6a 00 push $0x0 107708: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 10770e: e8 61 1a 00 00 call 109174 RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 107713: 83 c4 10 add $0x10,%esp 107716: 85 c0 test %eax,%eax 107718: 74 09 je 107723 <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 10771a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10771d: 50 push %eax <== NOT EXECUTED 10771e: e8 71 20 00 00 call 109794 <== NOT EXECUTED rtems_interrupt_disable (level); 107723: 9c pushf 107724: fa cli 107725: 5f pop %edi * 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) { 107726: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 10772c: 39 c6 cmp %eax,%esi 10772e: 74 c7 je 1076f7 RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++; 107730: 8b 8b 80 00 00 00 mov 0x80(%ebx),%ecx 107736: 8b 53 7c mov 0x7c(%ebx),%edx 107739: 8b 45 ec mov -0x14(%ebp),%eax 10773c: 8a 00 mov (%eax),%al 10773e: 88 04 0a mov %al,(%edx,%ecx,1) tty->rawOutBuf.Head = newHead; 107741: 89 b3 80 00 00 00 mov %esi,0x80(%ebx) if (tty->rawOutBufState == rob_idle) { 107747: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) 10774e: 75 3e jne 10778e /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { 107750: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 107756: a8 10 test $0x10,%al 107758: 75 1b jne 107775 <== NEVER TAKEN (*tty->device.write)(tty->minor, 10775a: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 107760: 52 push %edx 107761: 6a 01 push $0x1 107763: 03 43 7c add 0x7c(%ebx),%eax 107766: 50 push %eax 107767: ff 73 10 pushl 0x10(%ebx) 10776a: ff 93 a4 00 00 00 call *0xa4(%ebx) 107770: 83 c4 10 add $0x10,%esp 107773: eb 0f jmp 107784 (char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } else { /* remember that output has been stopped due to flow ctrl*/ tty->flow_ctrl |= FL_OSTOP; 107775: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10777b: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 10777e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } tty->rawOutBufState = rob_busy; 107784: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) 10778b: 00 00 00 RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++; 10778e: ff 45 ec incl -0x14(%ebp) /* remember that output has been stopped due to flow ctrl*/ tty->flow_ctrl |= FL_OSTOP; } tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); 107791: 57 push %edi 107792: 9d popf len--; 107793: ff 4d e8 decl -0x18(%ebp) if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, (void *)buf, len); return; } newHead = tty->rawOutBuf.Head; while (len) { 107796: 83 7d e8 00 cmpl $0x0,-0x18(%ebp) 10779a: 0f 85 3d ff ff ff jne 1076dd tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 1077a0: 8d 65 f4 lea -0xc(%ebp),%esp 1077a3: 5b pop %ebx 1077a4: 5e pop %esi 1077a5: 5f pop %edi 1077a6: c9 leave 1077a7: c3 ret =============================================================================== 00107cdf : return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) { 107cdf: 55 push %ebp <== NOT EXECUTED 107ce0: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107ce2: 57 push %edi <== NOT EXECUTED 107ce3: 56 push %esi <== NOT EXECUTED 107ce4: 53 push %ebx <== NOT EXECUTED 107ce5: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 107ce8: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 107ceb: 8b 02 mov (%edx),%eax <== NOT EXECUTED 107ced: 8b 70 28 mov 0x28(%eax),%esi <== NOT EXECUTED uint32_t count = args->count; 107cf0: 8b 4a 0c mov 0xc(%edx),%ecx <== NOT EXECUTED 107cf3: 89 4d d0 mov %ecx,-0x30(%ebp) <== NOT EXECUTED char *buffer = args->buffer; 107cf6: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 107cf9: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED rtems_status_code sc; sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 107cfc: 6a 00 push $0x0 <== NOT EXECUTED 107cfe: 6a 00 push $0x0 <== NOT EXECUTED 107d00: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 107d03: e8 6c 14 00 00 call 109174 <== NOT EXECUTED 107d08: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 107d0b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107d0e: 85 c0 test %eax,%eax <== NOT EXECUTED 107d10: 0f 85 c8 02 00 00 jne 107fde <== NOT EXECUTED return sc; if (rtems_termios_linesw[tty->t_line].l_read != NULL) { 107d16: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED 107d1c: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 107d1f: 8b 80 54 d4 11 00 mov 0x11d454(%eax),%eax <== NOT EXECUTED 107d25: 85 c0 test %eax,%eax <== NOT EXECUTED 107d27: 74 1b je 107d44 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_read(tty,args); 107d29: 52 push %edx <== NOT EXECUTED 107d2a: 52 push %edx <== NOT EXECUTED 107d2b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 107d2e: 56 push %esi <== NOT EXECUTED 107d2f: ff d0 call *%eax <== NOT EXECUTED 107d31: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED tty->tty_rcvwakeup = 0; 107d34: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) <== NOT EXECUTED 107d3b: 00 00 00 rtems_semaphore_release (tty->isem); 107d3e: 58 pop %eax <== NOT EXECUTED 107d3f: e9 8f 02 00 00 jmp 107fd3 <== NOT EXECUTED return sc; } if (tty->cindex == tty->ccount) { 107d44: 8b 46 24 mov 0x24(%esi),%eax <== NOT EXECUTED 107d47: 3b 46 20 cmp 0x20(%esi),%eax <== NOT EXECUTED 107d4a: 0f 85 5c 02 00 00 jne 107fac <== NOT EXECUTED tty->cindex = tty->ccount = 0; 107d50: c7 46 20 00 00 00 00 movl $0x0,0x20(%esi) <== NOT EXECUTED 107d57: c7 46 24 00 00 00 00 movl $0x0,0x24(%esi) <== NOT EXECUTED tty->read_start_column = tty->column; 107d5e: 8b 46 28 mov 0x28(%esi),%eax <== NOT EXECUTED 107d61: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED if (tty->device.pollRead != NULL 107d64: 83 be a0 00 00 00 00 cmpl $0x0,0xa0(%esi) <== NOT EXECUTED 107d6b: 0f 84 f8 00 00 00 je 107e69 <== NOT EXECUTED 107d71: 83 be b4 00 00 00 00 cmpl $0x0,0xb4(%esi) <== NOT EXECUTED 107d78: 0f 85 eb 00 00 00 jne 107e69 <== NOT EXECUTED static rtems_status_code fillBufferPoll (struct rtems_termios_tty *tty) { int n; if (tty->termios.c_lflag & ICANON) { 107d7e: f6 46 3c 02 testb $0x2,0x3c(%esi) <== NOT EXECUTED 107d82: 74 35 je 107db9 <== NOT EXECUTED for (;;) { n = (*tty->device.pollRead)(tty->minor); 107d84: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107d87: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 107d8a: ff 96 a0 00 00 00 call *0xa0(%esi) <== NOT EXECUTED if (n < 0) { 107d90: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107d93: 85 c0 test %eax,%eax <== NOT EXECUTED 107d95: 79 0f jns 107da6 <== NOT EXECUTED rtems_task_wake_after (1); 107d97: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107d9a: 6a 01 push $0x1 <== NOT EXECUTED 107d9c: e8 1f 18 00 00 call 1095c0 <== NOT EXECUTED 107da1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107da4: eb de jmp 107d84 <== NOT EXECUTED } else { if (siproc (n, tty)) 107da6: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 107da9: 89 f2 mov %esi,%edx <== NOT EXECUTED 107dab: e8 db fd ff ff call 107b8b <== NOT EXECUTED 107db0: 85 c0 test %eax,%eax <== NOT EXECUTED 107db2: 74 d0 je 107d84 <== NOT EXECUTED 107db4: e9 f3 01 00 00 jmp 107fac <== NOT EXECUTED } } } else { rtems_interval then, now; if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 107db9: 80 7e 47 00 cmpb $0x0,0x47(%esi) <== NOT EXECUTED 107dbd: 75 16 jne 107dd5 <== NOT EXECUTED 107dbf: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED 107dc3: 74 10 je 107dd5 <== NOT EXECUTED rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then); 107dc5: 50 push %eax <== NOT EXECUTED 107dc6: 50 push %eax <== NOT EXECUTED 107dc7: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 107dca: 50 push %eax <== NOT EXECUTED 107dcb: 6a 02 push $0x2 <== NOT EXECUTED 107dcd: e8 b2 0b 00 00 call 108984 <== NOT EXECUTED 107dd2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED else { siproc (n, tty); if (tty->ccount >= tty->termios.c_cc[VMIN]) break; if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then); 107dd5: 8d 7d f0 lea -0x10(%ebp),%edi <== NOT EXECUTED } } else { if (!tty->termios.c_cc[VTIME]) break; rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now); 107dd8: 8d 5d ec lea -0x14(%ebp),%ebx <== NOT EXECUTED else { rtems_interval then, now; if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then); for (;;) { n = (*tty->device.pollRead)(tty->minor); 107ddb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107dde: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 107de1: ff 96 a0 00 00 00 call *0xa0(%esi) <== NOT EXECUTED if (n < 0) { 107de7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107dea: 85 c0 test %eax,%eax <== NOT EXECUTED 107dec: 79 46 jns 107e34 <== NOT EXECUTED if (tty->termios.c_cc[VMIN]) { 107dee: 80 7e 47 00 cmpb $0x0,0x47(%esi) <== NOT EXECUTED 107df2: 74 0e je 107e02 <== NOT EXECUTED if (tty->termios.c_cc[VTIME] && tty->ccount) { 107df4: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED 107df8: 74 2e je 107e28 <== NOT EXECUTED 107dfa: 83 7e 20 00 cmpl $0x0,0x20(%esi) <== NOT EXECUTED 107dfe: 74 28 je 107e28 <== NOT EXECUTED 107e00: eb 0a jmp 107e0c <== NOT EXECUTED break; } } } else { if (!tty->termios.c_cc[VTIME]) 107e02: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED 107e06: 0f 84 a0 01 00 00 je 107fac <== NOT EXECUTED break; rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now); 107e0c: 50 push %eax <== NOT EXECUTED 107e0d: 50 push %eax <== NOT EXECUTED 107e0e: 53 push %ebx <== NOT EXECUTED 107e0f: 6a 02 push $0x2 <== NOT EXECUTED 107e11: e8 6e 0b 00 00 call 108984 <== NOT EXECUTED if ((now - then) > tty->vtimeTicks) { 107e16: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 107e19: 2b 45 f0 sub -0x10(%ebp),%eax <== NOT EXECUTED 107e1c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107e1f: 3b 46 54 cmp 0x54(%esi),%eax <== NOT EXECUTED 107e22: 0f 87 84 01 00 00 ja 107fac <== NOT EXECUTED break; } } rtems_task_wake_after (1); 107e28: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107e2b: 6a 01 push $0x1 <== NOT EXECUTED 107e2d: e8 8e 17 00 00 call 1095c0 <== NOT EXECUTED 107e32: eb 2d jmp 107e61 <== NOT EXECUTED } else { siproc (n, tty); 107e34: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 107e37: 89 f2 mov %esi,%edx <== NOT EXECUTED 107e39: e8 4d fd ff ff call 107b8b <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 107e3e: 8a 56 47 mov 0x47(%esi),%dl <== NOT EXECUTED 107e41: 0f b6 c2 movzbl %dl,%eax <== NOT EXECUTED 107e44: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED 107e47: 0f 8d 5f 01 00 00 jge 107fac <== NOT EXECUTED break; if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 107e4d: 84 d2 test %dl,%dl <== NOT EXECUTED 107e4f: 74 8a je 107ddb <== NOT EXECUTED 107e51: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED 107e55: 74 84 je 107ddb <== NOT EXECUTED rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then); 107e57: 50 push %eax <== NOT EXECUTED 107e58: 50 push %eax <== NOT EXECUTED 107e59: 57 push %edi <== NOT EXECUTED 107e5a: 6a 02 push $0x2 <== NOT EXECUTED 107e5c: e8 23 0b 00 00 call 108984 <== NOT EXECUTED 107e61: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107e64: e9 72 ff ff ff jmp 107ddb <== NOT EXECUTED * Fill the input buffer from the raw input queue */ static rtems_status_code fillBufferQueue (struct rtems_termios_tty *tty) { rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout; 107e69: 8b 7e 74 mov 0x74(%esi),%edi <== NOT EXECUTED 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)(tty->minor, 107e6c: 8d 56 49 lea 0x49(%esi),%edx <== NOT EXECUTED 107e6f: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED 107e72: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 107e77: e9 11 01 00 00 jmp 107f8d <== NOT EXECUTED 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; 107e7c: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED 107e7f: 8b 56 64 mov 0x64(%esi),%edx <== NOT EXECUTED 107e82: 40 inc %eax <== NOT EXECUTED 107e83: 89 d1 mov %edx,%ecx <== NOT EXECUTED 107e85: 31 d2 xor %edx,%edx <== NOT EXECUTED 107e87: f7 f1 div %ecx <== NOT EXECUTED c = tty->rawInBuf.theBuf[newHead]; 107e89: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED 107e8c: 0f b6 3c 10 movzbl (%eax,%edx,1),%edi <== NOT EXECUTED tty->rawInBuf.Head = newHead; 107e90: 89 56 5c mov %edx,0x5c(%esi) <== NOT EXECUTED if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) 107e93: 8b 5e 60 mov 0x60(%esi),%ebx <== NOT EXECUTED 107e96: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED 107e99: 8b 4e 64 mov 0x64(%esi),%ecx <== NOT EXECUTED 107e9c: 01 d8 add %ebx,%eax <== NOT EXECUTED 107e9e: 29 d0 sub %edx,%eax <== NOT EXECUTED 107ea0: 31 d2 xor %edx,%edx <== NOT EXECUTED 107ea2: f7 f1 div %ecx <== NOT EXECUTED 107ea4: 3b 96 bc 00 00 00 cmp 0xbc(%esi),%edx <== NOT EXECUTED 107eaa: 73 74 jae 107f20 <== NOT EXECUTED % tty->rawInBuf.Size) < tty->lowwater) { tty->flow_ctrl &= ~FL_IREQXOF; 107eac: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 107eb2: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 107eb5: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED /* if tx stopped and XON should be sent... */ if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF)) 107ebb: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 107ec1: 25 02 02 00 00 and $0x202,%eax <== NOT EXECUTED 107ec6: 3d 02 02 00 00 cmp $0x202,%eax <== NOT EXECUTED 107ecb: 75 24 jne 107ef1 <== NOT EXECUTED 107ecd: 83 be 94 00 00 00 00 cmpl $0x0,0x94(%esi) <== NOT EXECUTED 107ed4: 74 0a je 107ee0 <== NOT EXECUTED 107ed6: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 107edc: a8 20 test $0x20,%al <== NOT EXECUTED 107ede: 74 11 je 107ef1 <== NOT EXECUTED == (FL_MDXON | FL_ISNTXOF)) && ((tty->rawOutBufState == rob_idle) || (tty->flow_ctrl & FL_OSTOP))) { /* XON should be sent now... */ (*tty->device.write)(tty->minor, 107ee0: 50 push %eax <== NOT EXECUTED 107ee1: 6a 01 push $0x1 <== NOT EXECUTED 107ee3: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 107ee6: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 107ee9: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED 107eef: eb 2c jmp 107f1d <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTART]), 1); } else if (tty->flow_ctrl & FL_MDRTS) { 107ef1: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 107ef7: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 107efa: 74 24 je 107f20 <== NOT EXECUTED tty->flow_ctrl &= ~FL_IRTSOFF; 107efc: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 107f02: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 107f05: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED /* activate RTS line */ if (tty->device.startRemoteTx != NULL) { 107f0b: 8b 86 b0 00 00 00 mov 0xb0(%esi),%eax <== NOT EXECUTED 107f11: 85 c0 test %eax,%eax <== NOT EXECUTED 107f13: 74 0b je 107f20 <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 107f15: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107f18: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 107f1b: ff d0 call *%eax <== NOT EXECUTED 107f1d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { 107f20: f6 46 3c 02 testb $0x2,0x3c(%esi) <== NOT EXECUTED 107f24: 74 12 je 107f38 <== NOT EXECUTED if (siproc (c, tty)) 107f26: 89 fa mov %edi,%edx <== NOT EXECUTED 107f28: 0f b6 c2 movzbl %dl,%eax <== NOT EXECUTED 107f2b: 89 f2 mov %esi,%edx <== NOT EXECUTED 107f2d: e8 59 fc ff ff call 107b8b <== NOT EXECUTED 107f32: 85 c0 test %eax,%eax <== NOT EXECUTED 107f34: 75 17 jne 107f4d <== NOT EXECUTED 107f36: eb 1c jmp 107f54 <== NOT EXECUTED wait = 0; } else { siproc (c, tty); 107f38: 89 f9 mov %edi,%ecx <== NOT EXECUTED 107f3a: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 107f3d: 89 f2 mov %esi,%edx <== NOT EXECUTED 107f3f: e8 47 fc ff ff call 107b8b <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 107f44: 0f b6 46 47 movzbl 0x47(%esi),%eax <== NOT EXECUTED 107f48: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED 107f4b: 7c 07 jl 107f54 <== NOT EXECUTED 107f4d: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED wait = 0; } timeout = tty->rawInBufSemaphoreTimeout; 107f54: 8b 4e 70 mov 0x70(%esi),%ecx <== NOT EXECUTED while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 107f57: 8b 56 5c mov 0x5c(%esi),%edx <== NOT EXECUTED 107f5a: 8b 46 60 mov 0x60(%esi),%eax <== NOT EXECUTED 107f5d: 39 c2 cmp %eax,%edx <== NOT EXECUTED 107f5f: 74 0f je 107f70 <== NOT EXECUTED 107f61: a1 3c b6 11 00 mov 0x11b63c,%eax <== NOT EXECUTED 107f66: 48 dec %eax <== NOT EXECUTED 107f67: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED 107f6a: 0f 8c 0c ff ff ff jl 107e7c <== NOT EXECUTED 107f70: 8b 5d dc mov -0x24(%ebp),%ebx <== NOT EXECUTED 107f73: 89 cf mov %ecx,%edi <== NOT EXECUTED } /* * Wait for characters */ if ( wait ) { 107f75: 85 db test %ebx,%ebx <== NOT EXECUTED 107f77: 74 33 je 107fac <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->rawInBuf.Semaphore, 107f79: 50 push %eax <== NOT EXECUTED 107f7a: 51 push %ecx <== NOT EXECUTED 107f7b: ff 76 6c pushl 0x6c(%esi) <== NOT EXECUTED 107f7e: ff 76 68 pushl 0x68(%esi) <== NOT EXECUTED 107f81: e8 ee 11 00 00 call 109174 <== NOT EXECUTED tty->rawInBufSemaphoreOptions, timeout); if (sc != RTEMS_SUCCESSFUL) 107f86: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107f89: 85 c0 test %eax,%eax <== NOT EXECUTED 107f8b: 75 1f jne 107fac <== NOT EXECUTED { rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout; rtems_status_code sc; int wait = (int)1; while ( wait ) { 107f8d: 89 5d dc mov %ebx,-0x24(%ebp) <== NOT EXECUTED 107f90: 89 f9 mov %edi,%ecx <== NOT EXECUTED 107f92: eb c3 jmp 107f57 <== NOT EXECUTED sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { *buffer++ = tty->cbuf[tty->cindex++]; 107f94: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED 107f97: 8a 04 10 mov (%eax,%edx,1),%al <== NOT EXECUTED 107f9a: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED 107f9d: 88 01 mov %al,(%ecx) <== NOT EXECUTED 107f9f: 41 inc %ecx <== NOT EXECUTED 107fa0: 89 4d d4 mov %ecx,-0x2c(%ebp) <== NOT EXECUTED 107fa3: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 107fa6: 89 46 24 mov %eax,0x24(%esi) <== NOT EXECUTED count--; 107fa9: ff 4d d0 decl -0x30(%ebp) <== NOT EXECUTED else sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 107fac: 83 7d d0 00 cmpl $0x0,-0x30(%ebp) <== NOT EXECUTED 107fb0: 74 08 je 107fba <== NOT EXECUTED 107fb2: 8b 56 24 mov 0x24(%esi),%edx <== NOT EXECUTED 107fb5: 3b 56 20 cmp 0x20(%esi),%edx <== NOT EXECUTED 107fb8: 7c da jl 107f94 <== NOT EXECUTED *buffer++ = tty->cbuf[tty->cindex++]; count--; } args->bytes_moved = args->count - count; 107fba: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 107fbd: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 107fc0: 2b 45 d0 sub -0x30(%ebp),%eax <== NOT EXECUTED 107fc3: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED tty->tty_rcvwakeup = 0; 107fc6: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) <== NOT EXECUTED 107fcd: 00 00 00 rtems_semaphore_release (tty->isem); 107fd0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107fd3: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 107fd6: e8 81 12 00 00 call 10925c <== NOT EXECUTED 107fdb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return sc; } 107fde: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 107fe1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107fe4: 5b pop %ebx <== NOT EXECUTED 107fe5: 5e pop %esi <== NOT EXECUTED 107fe6: 5f pop %edi <== NOT EXECUTED 107fe7: c9 leave <== NOT EXECUTED 107fe8: c3 ret <== NOT EXECUTED =============================================================================== 001071da : * 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) { 1071da: 55 push %ebp 1071db: 89 e5 mov %esp,%ebp 1071dd: 57 push %edi 1071de: 56 push %esi 1071df: 53 push %ebx 1071e0: 83 ec 0c sub $0xc,%esp 1071e3: 8b 75 08 mov 0x8(%ebp),%esi int nToSend; rtems_interrupt_level level; int len; /* check for XOF/XON to send */ if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF)) 1071e6: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax 1071ec: 25 03 04 00 00 and $0x403,%eax 1071f1: 3d 01 04 00 00 cmp $0x401,%eax 1071f6: 75 2c jne 107224 <== ALWAYS TAKEN == (FL_MDXOF | FL_IREQXOF)) { /* XOFF should be sent now... */ (*tty->device.write)(tty->minor, 1071f8: 57 push %edi <== NOT EXECUTED 1071f9: 6a 01 push $0x1 <== NOT EXECUTED 1071fb: 8d 46 4a lea 0x4a(%esi),%eax <== NOT EXECUTED 1071fe: 50 push %eax <== NOT EXECUTED 1071ff: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 107202: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTOP]), 1); rtems_interrupt_disable(level); 107208: 9c pushf <== NOT EXECUTED 107209: fa cli <== NOT EXECUTED 10720a: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 10720b: ff 8e 90 00 00 00 decl 0x90(%esi) <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; 107211: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 107217: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 10721a: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED rtems_interrupt_enable(level); 107220: 52 push %edx <== NOT EXECUTED 107221: 9d popf <== NOT EXECUTED 107222: eb 38 jmp 10725c <== NOT EXECUTED nToSend = 1; } else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) 107224: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax 10722a: 83 e0 03 and $0x3,%eax 10722d: 83 f8 02 cmp $0x2,%eax 107230: 75 37 jne 107269 <== 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, 107232: 53 push %ebx <== NOT EXECUTED 107233: 6a 01 push $0x1 <== NOT EXECUTED 107235: 8d 46 49 lea 0x49(%esi),%eax <== NOT EXECUTED 107238: 50 push %eax <== NOT EXECUTED 107239: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 10723c: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTART]), 1); rtems_interrupt_disable(level); 107242: 9c pushf <== NOT EXECUTED 107243: fa cli <== NOT EXECUTED 107244: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 107245: ff 8e 90 00 00 00 decl 0x90(%esi) <== NOT EXECUTED tty->flow_ctrl &= ~FL_ISNTXOF; 10724b: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 107251: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 107254: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED rtems_interrupt_enable(level); 10725a: 52 push %edx <== NOT EXECUTED 10725b: 9d popf <== NOT EXECUTED 10725c: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 107261: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107264: e9 34 01 00 00 jmp 10739d <== NOT EXECUTED nToSend = 1; } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { 107269: 8b 96 80 00 00 00 mov 0x80(%esi),%edx 10726f: 8b 86 84 00 00 00 mov 0x84(%esi),%eax 107275: 39 c2 cmp %eax,%edx 107277: 75 21 jne 10729a <== ALWAYS TAKEN /* * buffer was empty */ if (tty->rawOutBufState == rob_wait) { 107279: 31 db xor %ebx,%ebx 10727b: 83 be 94 00 00 00 02 cmpl $0x2,0x94(%esi) <== NOT EXECUTED 107282: 0f 85 15 01 00 00 jne 10739d <== NOT EXECUTED /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 107288: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10728b: ff b6 8c 00 00 00 pushl 0x8c(%esi) <== NOT EXECUTED 107291: e8 c6 1f 00 00 call 10925c <== NOT EXECUTED 107296: 31 db xor %ebx,%ebx <== NOT EXECUTED 107298: eb c7 jmp 107261 <== NOT EXECUTED } return 0; } rtems_interrupt_disable(level); 10729a: 9c pushf 10729b: fa cli 10729c: 58 pop %eax len = tty->t_dqlen; 10729d: 8b 8e 90 00 00 00 mov 0x90(%esi),%ecx tty->t_dqlen = 0; 1072a3: c7 86 90 00 00 00 00 movl $0x0,0x90(%esi) 1072aa: 00 00 00 rtems_interrupt_enable(level); 1072ad: 50 push %eax 1072ae: 9d popf newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size; 1072af: 8b 96 84 00 00 00 mov 0x84(%esi),%edx 1072b5: 8b 9e 88 00 00 00 mov 0x88(%esi),%ebx 1072bb: 01 d1 add %edx,%ecx 1072bd: 89 c8 mov %ecx,%eax 1072bf: 31 d2 xor %edx,%edx 1072c1: f7 f3 div %ebx 1072c3: 89 d7 mov %edx,%edi tty->rawOutBuf.Tail = newTail; 1072c5: 89 96 84 00 00 00 mov %edx,0x84(%esi) if (tty->rawOutBufState == rob_wait) { 1072cb: 83 be 94 00 00 00 02 cmpl $0x2,0x94(%esi) 1072d2: 75 11 jne 1072e5 /* * wake up any pending writer task */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 1072d4: 83 ec 0c sub $0xc,%esp 1072d7: ff b6 8c 00 00 00 pushl 0x8c(%esi) 1072dd: e8 7a 1f 00 00 call 10925c 1072e2: 83 c4 10 add $0x10,%esp } if (newTail == tty->rawOutBuf.Head) { 1072e5: 8b 86 80 00 00 00 mov 0x80(%esi),%eax 1072eb: 39 c7 cmp %eax,%edi 1072ed: 75 2c jne 10731b /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; 1072ef: c7 86 94 00 00 00 00 movl $0x0,0x94(%esi) 1072f6: 00 00 00 nToSend = 0; /* * check to see if snd wakeup callback was set */ if ( tty->tty_snd.sw_pfn != NULL) { 1072f9: 8b 96 d4 00 00 00 mov 0xd4(%esi),%edx 1072ff: 31 db xor %ebx,%ebx 107301: 85 d2 test %edx,%edx 107303: 0f 84 8e 00 00 00 je 107397 <== ALWAYS TAKEN (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg); 107309: 51 push %ecx <== NOT EXECUTED 10730a: 51 push %ecx <== NOT EXECUTED 10730b: ff b6 d8 00 00 00 pushl 0xd8(%esi) <== NOT EXECUTED 107311: 8d 46 30 lea 0x30(%esi),%eax <== NOT EXECUTED 107314: 50 push %eax <== NOT EXECUTED 107315: ff d2 call *%edx <== NOT EXECUTED 107317: 31 db xor %ebx,%ebx <== NOT EXECUTED 107319: eb 79 jmp 107394 <== NOT EXECUTED } } /* check, whether output should stop due to received XOFF */ else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF)) 10731b: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax 107321: 25 10 02 00 00 and $0x210,%eax 107326: 3d 10 02 00 00 cmp $0x210,%eax 10732b: 75 22 jne 10734f <== 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); 10732d: 9c pushf <== NOT EXECUTED 10732e: fa cli <== NOT EXECUTED 10732f: 5a pop %edx <== NOT EXECUTED tty->flow_ctrl |= FL_OSTOP; 107330: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 107336: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 107339: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ 10733f: c7 86 94 00 00 00 01 movl $0x1,0x94(%esi) <== NOT EXECUTED 107346: 00 00 00 rtems_interrupt_enable(level); 107349: 52 push %edx <== NOT EXECUTED 10734a: 9d popf <== NOT EXECUTED 10734b: 31 db xor %ebx,%ebx <== NOT EXECUTED 10734d: eb 48 jmp 107397 <== NOT EXECUTED } else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) 10734f: 8b 86 80 00 00 00 mov 0x80(%esi),%eax 107355: 39 c7 cmp %eax,%edi 107357: 76 08 jbe 107361 nToSend = tty->rawOutBuf.Size - newTail; 107359: 8b 9e 88 00 00 00 mov 0x88(%esi),%ebx 10735f: eb 06 jmp 107367 else nToSend = tty->rawOutBuf.Head - newTail; 107361: 8b 9e 80 00 00 00 mov 0x80(%esi),%ebx 107367: 29 fb sub %edi,%ebx /* 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)) { 107369: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax 10736f: f6 c4 06 test $0x6,%ah 107372: 74 05 je 107379 <== ALWAYS TAKEN 107374: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED nToSend = 1; } tty->rawOutBufState = rob_busy; /*apm*/ 107379: c7 86 94 00 00 00 01 movl $0x1,0x94(%esi) 107380: 00 00 00 (*tty->device.write)(tty->minor, 107383: 50 push %eax 107384: 53 push %ebx 107385: 8b 46 7c mov 0x7c(%esi),%eax 107388: 01 f8 add %edi,%eax 10738a: 50 push %eax 10738b: ff 76 10 pushl 0x10(%esi) 10738e: ff 96 a4 00 00 00 call *0xa4(%esi) 107394: 83 c4 10 add $0x10,%esp &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ 107397: 89 be 84 00 00 00 mov %edi,0x84(%esi) } return nToSend; } 10739d: 89 d8 mov %ebx,%eax 10739f: 8d 65 f4 lea -0xc(%ebp),%esp 1073a2: 5b pop %ebx 1073a3: 5e pop %esi 1073a4: 5f pop %edi 1073a5: c9 leave 1073a6: c3 ret =============================================================================== 0010891e : /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) { 10891e: 55 push %ebp <== NOT EXECUTED 10891f: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108921: 57 push %edi <== NOT EXECUTED 108922: 56 push %esi <== NOT EXECUTED 108923: 53 push %ebx <== NOT EXECUTED 108924: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 108927: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED char c_buf; while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_RX_PROC_EVENT | 10892a: 8d 7d ec lea -0x14(%ebp),%edi <== NOT EXECUTED if (c != EOF) { /* * pollRead did call enqueue on its own */ c_buf = c; rtems_termios_enqueue_raw_characters ( 10892d: 8d 75 f3 lea -0xd(%ebp),%esi <== NOT EXECUTED char c_buf; while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_RX_PROC_EVENT | 108930: 57 push %edi <== NOT EXECUTED 108931: 6a 00 push $0x0 <== NOT EXECUTED 108933: 6a 02 push $0x2 <== NOT EXECUTED 108935: 6a 03 push $0x3 <== NOT EXECUTED 108937: e8 38 02 00 00 call 108b74 <== NOT EXECUTED TERMIOS_RX_TERMINATE_EVENT), RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &the_event); if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) { 10893c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10893f: f6 45 ec 01 testb $0x1,-0x14(%ebp) <== NOT EXECUTED 108943: 74 16 je 10895b <== NOT EXECUTED tty->rxTaskId = 0; 108945: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED 10894c: 00 00 00 rtems_task_delete(RTEMS_SELF); 10894f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108952: 6a 00 push $0x0 <== NOT EXECUTED 108954: e8 c3 0a 00 00 call 10941c <== NOT EXECUTED 108959: eb 21 jmp 10897c <== NOT EXECUTED } else { /* * do something */ c = tty->device.pollRead(tty->minor); 10895b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10895e: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108961: ff 93 a0 00 00 00 call *0xa0(%ebx) <== NOT EXECUTED if (c != EOF) { 108967: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10896a: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10896d: 74 c1 je 108930 <== NOT EXECUTED /* * pollRead did call enqueue on its own */ c_buf = c; 10896f: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED rtems_termios_enqueue_raw_characters ( 108972: 50 push %eax <== NOT EXECUTED 108973: 6a 01 push $0x1 <== NOT EXECUTED 108975: 56 push %esi <== NOT EXECUTED 108976: 53 push %ebx <== NOT EXECUTED 108977: e8 8f ea ff ff call 10740b <== NOT EXECUTED 10897c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10897f: eb af jmp 108930 <== NOT EXECUTED =============================================================================== 001071bf : * signal receive interrupt to rx daemon * NOTE: This routine runs in the context of the * device receive interrupt handler. */ void rtems_termios_rxirq_occured(struct rtems_termios_tty *tty) { 1071bf: 55 push %ebp <== NOT EXECUTED 1071c0: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1071c2: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED /* * send event to rx daemon task */ rtems_event_send(tty->rxTaskId,TERMIOS_RX_PROC_EVENT); 1071c5: 6a 02 push $0x2 <== NOT EXECUTED 1071c7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1071ca: ff b0 c4 00 00 00 pushl 0xc4(%eax) <== NOT EXECUTED 1071d0: e8 0f 1b 00 00 call 108ce4 <== NOT EXECUTED 1071d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1071d8: c9 leave <== NOT EXECUTED 1071d9: c3 ret <== NOT EXECUTED =============================================================================== 001088bb : /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) { 1088bb: 55 push %ebp <== NOT EXECUTED 1088bc: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1088be: 56 push %esi <== NOT EXECUTED 1088bf: 53 push %ebx <== NOT EXECUTED 1088c0: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 1088c3: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_TX_START_EVENT | 1088c6: 8d 75 f4 lea -0xc(%ebp),%esi <== NOT EXECUTED 1088c9: 56 push %esi <== NOT EXECUTED 1088ca: 6a 00 push $0x0 <== NOT EXECUTED 1088cc: 6a 02 push $0x2 <== NOT EXECUTED 1088ce: 6a 03 push $0x3 <== NOT EXECUTED 1088d0: e8 9f 02 00 00 call 108b74 <== NOT EXECUTED TERMIOS_TX_TERMINATE_EVENT), RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &the_event); if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) { 1088d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1088d8: f6 45 f4 01 testb $0x1,-0xc(%ebp) <== NOT EXECUTED 1088dc: 74 16 je 1088f4 <== NOT EXECUTED tty->txTaskId = 0; 1088de: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED 1088e5: 00 00 00 rtems_task_delete(RTEMS_SELF); 1088e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1088eb: 6a 00 push $0x0 <== NOT EXECUTED 1088ed: e8 2a 0b 00 00 call 10941c <== NOT EXECUTED 1088f2: eb 25 jmp 108919 <== NOT EXECUTED } else { /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 1088f4: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 1088fa: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 1088fd: 8b 80 60 d4 11 00 mov 0x11d460(%eax),%eax <== NOT EXECUTED 108903: 85 c0 test %eax,%eax <== NOT EXECUTED 108905: 74 09 je 108910 <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_start(tty); 108907: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10890a: 53 push %ebx <== NOT EXECUTED 10890b: ff d0 call *%eax <== NOT EXECUTED 10890d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * try to push further characters to device */ rtems_termios_refill_transmitter(tty); 108910: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108913: 53 push %ebx <== NOT EXECUTED 108914: e8 c1 e8 ff ff call 1071da <== NOT EXECUTED 108919: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10891c: eb ab jmp 1088c9 <== NOT EXECUTED =============================================================================== 00107bd9 : rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) { 107bd9: 55 push %ebp 107bda: 89 e5 mov %esp,%ebp 107bdc: 57 push %edi 107bdd: 56 push %esi 107bde: 53 push %ebx 107bdf: 83 ec 10 sub $0x10,%esp rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 107be2: 8b 55 08 mov 0x8(%ebp),%edx 107be5: 8b 02 mov (%edx),%eax 107be7: 8b 78 28 mov 0x28(%eax),%edi rtems_status_code sc; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 107bea: 6a 00 push $0x0 107bec: 6a 00 push $0x0 107bee: ff 77 18 pushl 0x18(%edi) 107bf1: e8 7e 15 00 00 call 109174 107bf6: 89 45 f0 mov %eax,-0x10(%ebp) if (sc != RTEMS_SUCCESSFUL) 107bf9: 83 c4 10 add $0x10,%esp 107bfc: 85 c0 test %eax,%eax 107bfe: 75 77 jne 107c77 <== NEVER TAKEN return sc; if (rtems_termios_linesw[tty->t_line].l_write != NULL) { 107c00: 8b 87 cc 00 00 00 mov 0xcc(%edi),%eax 107c06: c1 e0 05 shl $0x5,%eax 107c09: 8b 80 58 d4 11 00 mov 0x11d458(%eax),%eax 107c0f: 85 c0 test %eax,%eax 107c11: 74 0e je 107c21 <== ALWAYS TAKEN sc = rtems_termios_linesw[tty->t_line].l_write(tty,args); 107c13: 52 push %edx <== NOT EXECUTED 107c14: 52 push %edx <== NOT EXECUTED 107c15: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 107c18: 57 push %edi <== NOT EXECUTED 107c19: ff d0 call *%eax <== NOT EXECUTED 107c1b: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED rtems_semaphore_release (tty->osem); 107c1e: 5e pop %esi <== NOT EXECUTED 107c1f: eb 4b jmp 107c6c <== NOT EXECUTED return sc; } if (tty->termios.c_oflag & OPOST) { 107c21: f6 47 34 01 testb $0x1,0x34(%edi) 107c25: 74 26 je 107c4d <== NEVER TAKEN uint32_t count = args->count; 107c27: 8b 45 08 mov 0x8(%ebp),%eax 107c2a: 8b 70 0c mov 0xc(%eax),%esi char *buffer = args->buffer; 107c2d: 8b 58 08 mov 0x8(%eax),%ebx 107c30: eb 0c jmp 107c3e while (count--) oproc (*buffer++, tty); 107c32: 0f b6 03 movzbl (%ebx),%eax 107c35: 43 inc %ebx 107c36: 89 fa mov %edi,%edx 107c38: e8 6b fb ff ff call 1077a8 107c3d: 4e dec %esi return sc; } if (tty->termios.c_oflag & OPOST) { uint32_t count = args->count; char *buffer = args->buffer; while (count--) 107c3e: 85 f6 test %esi,%esi 107c40: 75 f0 jne 107c32 oproc (*buffer++, tty); args->bytes_moved = args->count; 107c42: 8b 55 08 mov 0x8(%ebp),%edx 107c45: 8b 42 0c mov 0xc(%edx),%eax 107c48: 89 42 14 mov %eax,0x14(%edx) 107c4b: eb 1c jmp 107c69 } else { rtems_termios_puts (args->buffer, args->count, tty); 107c4d: 53 push %ebx <== NOT EXECUTED 107c4e: 57 push %edi <== NOT EXECUTED 107c4f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 107c52: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 107c55: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 107c58: e8 36 fa ff ff call 107693 <== NOT EXECUTED args->bytes_moved = args->count; 107c5d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 107c60: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 107c63: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED 107c66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } rtems_semaphore_release (tty->osem); 107c69: 83 ec 0c sub $0xc,%esp 107c6c: ff 77 18 pushl 0x18(%edi) 107c6f: e8 e8 15 00 00 call 10925c 107c74: 83 c4 10 add $0x10,%esp return sc; } 107c77: 8b 45 f0 mov -0x10(%ebp),%eax 107c7a: 8d 65 f4 lea -0xc(%ebp),%esp 107c7d: 5b pop %ebx 107c7e: 5e pop %esi 107c7f: 5f pop %edi 107c80: c9 leave 107c81: c3 ret =============================================================================== 00112ad8 : */ rtems_status_code rtems_timer_cancel( Objects_Id id ) { 112ad8: 55 push %ebp 112ad9: 89 e5 mov %esp,%ebp 112adb: 83 ec 1c sub $0x1c,%esp /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 112ade: 8d 45 fc lea -0x4(%ebp),%eax 112ae1: 50 push %eax 112ae2: ff 75 08 pushl 0x8(%ebp) 112ae5: 68 78 4a 13 00 push $0x134a78 112aea: e8 09 25 00 00 call 114ff8 <_Objects_Get> 112aef: 89 c2 mov %eax,%edx Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112af1: 83 c4 10 add $0x10,%esp 112af4: b8 04 00 00 00 mov $0x4,%eax 112af9: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) 112afd: 75 1c jne 112b1b case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 112aff: 83 7a 38 04 cmpl $0x4,0x38(%edx) 112b03: 74 0f je 112b14 <== NEVER TAKEN (void) _Watchdog_Remove( &the_timer->Ticker ); 112b05: 83 ec 0c sub $0xc,%esp 112b08: 8d 42 10 lea 0x10(%edx),%eax 112b0b: 50 push %eax 112b0c: e8 db 3e 00 00 call 1169ec <_Watchdog_Remove> 112b11: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 112b14: e8 9f 2c 00 00 call 1157b8 <_Thread_Enable_dispatch> 112b19: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112b1b: c9 leave 112b1c: c3 ret =============================================================================== 0010a038 : rtems_status_code rtems_timer_create( rtems_name name, Objects_Id *id ) { 10a038: 55 push %ebp 10a039: 89 e5 mov %esp,%ebp 10a03b: 57 push %edi 10a03c: 56 push %esi 10a03d: 53 push %ebx 10a03e: 83 ec 0c sub $0xc,%esp 10a041: 8b 75 08 mov 0x8(%ebp),%esi 10a044: 8b 7d 0c mov 0xc(%ebp),%edi Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 10a047: b8 03 00 00 00 mov $0x3,%eax 10a04c: 85 f6 test %esi,%esi 10a04e: 74 73 je 10a0c3 return RTEMS_INVALID_NAME; if ( !id ) 10a050: b8 09 00 00 00 mov $0x9,%eax 10a055: 85 ff test %edi,%edi 10a057: 74 6a je 10a0c3 <== NEVER TAKEN /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a059: a1 98 0a 12 00 mov 0x120a98,%eax 10a05e: 40 inc %eax 10a05f: a3 98 0a 12 00 mov %eax,0x120a98 #ifdef __cplusplus extern "C" { #endif /** 10a064: 83 ec 0c sub $0xc,%esp 10a067: 68 80 10 12 00 push $0x121080 10a06c: e8 f7 0d 00 00 call 10ae68 <_Objects_Allocate> 10a071: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { 10a073: 83 c4 10 add $0x10,%esp 10a076: 85 c0 test %eax,%eax 10a078: 75 0c jne 10a086 _Thread_Enable_dispatch(); 10a07a: e8 ed 19 00 00 call 10ba6c <_Thread_Enable_dispatch> 10a07f: b8 05 00 00 00 mov $0x5,%eax 10a084: eb 3d jmp 10a0c3 return RTEMS_TOO_MANY; } the_timer->the_class = TIMER_DORMANT; 10a086: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax) * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10a08d: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) * @param[in] the_heap is the heap to operate upon 10a094: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) * @param[in] starting_address is the starting address of the memory for 10a09b: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) * the heap 10a0a2: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) 10a0a9: 8b 48 08 mov 0x8(%eax),%ecx 10a0ac: 0f b7 d1 movzwl %cx,%edx 10a0af: a1 9c 10 12 00 mov 0x12109c,%eax 10a0b4: 89 1c 90 mov %ebx,(%eax,%edx,4) 10a0b7: 89 73 0c mov %esi,0xc(%ebx) &_Timer_Information, &the_timer->Object, (Objects_Name) name ); *id = the_timer->Object.id; 10a0ba: 89 0f mov %ecx,(%edi) _Thread_Enable_dispatch(); 10a0bc: e8 ab 19 00 00 call 10ba6c <_Thread_Enable_dispatch> 10a0c1: 31 c0 xor %eax,%eax return RTEMS_SUCCESSFUL; } 10a0c3: 8d 65 f4 lea -0xc(%ebp),%esp 10a0c6: 5b pop %ebx 10a0c7: 5e pop %esi 10a0c8: 5f pop %edi 10a0c9: c9 leave 10a0ca: c3 ret =============================================================================== 0010a0cc : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 10a0cc: 55 push %ebp 10a0cd: 89 e5 mov %esp,%ebp 10a0cf: 57 push %edi 10a0d0: 56 push %esi 10a0d1: 53 push %ebx 10a0d2: 83 ec 1c sub $0x1c,%esp 10a0d5: 8b 7d 10 mov 0x10(%ebp),%edi Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 10a0d8: b8 0a 00 00 00 mov $0xa,%eax 10a0dd: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10a0e1: 0f 84 8e 00 00 00 je 10a175 return RTEMS_INVALID_NUMBER; if ( !routine ) 10a0e7: b8 09 00 00 00 mov $0x9,%eax 10a0ec: 85 ff test %edi,%edi 10a0ee: 0f 84 81 00 00 00 je 10a175 <== NEVER TAKEN /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 10a0f4: 52 push %edx 10a0f5: 8d 45 f0 lea -0x10(%ebp),%eax 10a0f8: 50 push %eax 10a0f9: ff 75 08 pushl 0x8(%ebp) 10a0fc: 68 80 10 12 00 push $0x121080 10a101: e8 a6 11 00 00 call 10b2ac <_Objects_Get> 10a106: 89 c3 mov %eax,%ebx return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 10a108: 83 c4 10 add $0x10,%esp 10a10b: b8 04 00 00 00 mov $0x4,%eax 10a110: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 10a114: 75 5f jne 10a175 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 10a116: 8d 73 10 lea 0x10(%ebx),%esi 10a119: 83 ec 0c sub $0xc,%esp 10a11c: 56 push %esi 10a11d: e8 6a 28 00 00 call 10c98c <_Watchdog_Remove> _ISR_Disable( level ); 10a122: 9c pushf 10a123: fa cli 10a124: 5a pop %edx /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { 10a125: 83 c4 10 add $0x10,%esp 10a128: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 10a12c: 74 0b je 10a139 <== ALWAYS TAKEN _ISR_Enable( level ); 10a12e: 52 push %edx <== NOT EXECUTED 10a12f: 9d popf <== NOT EXECUTED _Thread_Enable_dispatch(); 10a130: e8 37 19 00 00 call 10ba6c <_Thread_Enable_dispatch><== NOT EXECUTED 10a135: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a137: eb 3c jmp 10a175 <== NOT EXECUTED /* * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL; 10a139: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10a140: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) * @param[in] the_heap is the heap to operate upon 10a147: 89 7b 2c mov %edi,0x2c(%ebx) * @param[in] starting_address is the starting address of the memory for 10a14a: 8b 45 08 mov 0x8(%ebp),%eax 10a14d: 89 43 30 mov %eax,0x30(%ebx) * the heap 10a150: 8b 45 14 mov 0x14(%ebp),%eax 10a153: 89 43 34 mov %eax,0x34(%ebx) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 10a156: 52 push %edx 10a157: 9d popf * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10a158: 8b 45 0c mov 0xc(%ebp),%eax 10a15b: 89 43 1c mov %eax,0x1c(%ebx) void *starting_address, size_t *size 10a15e: 50 push %eax 10a15f: 50 push %eax 10a160: 56 push %esi 10a161: 68 78 0b 12 00 push $0x120b78 10a166: e8 09 27 00 00 call 10c874 <_Watchdog_Insert> _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 10a16b: e8 fc 18 00 00 call 10ba6c <_Thread_Enable_dispatch> 10a170: 31 c0 xor %eax,%eax 10a172: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a175: 8d 65 f4 lea -0xc(%ebp),%esp 10a178: 5b pop %ebx 10a179: 5e pop %esi 10a17a: 5f pop %edi 10a17b: c9 leave 10a17c: c3 ret =============================================================================== 00112cc4 : Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 112cc4: 55 push %ebp 112cc5: 89 e5 mov %esp,%ebp 112cc7: 57 push %edi 112cc8: 56 push %esi 112cc9: 53 push %ebx 112cca: 83 ec 1c sub $0x1c,%esp 112ccd: 8b 5d 0c mov 0xc(%ebp),%ebx Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD_Is_set ) 112cd0: b8 0b 00 00 00 mov $0xb,%eax 112cd5: 80 3d 4c 41 13 00 00 cmpb $0x0,0x13414c 112cdc: 0f 84 ae 00 00 00 je 112d90 return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) 112ce2: 83 ec 0c sub $0xc,%esp 112ce5: 53 push %ebx 112ce6: e8 85 da ff ff call 110770 <_TOD_Validate> 112ceb: 83 c4 10 add $0x10,%esp 112cee: 84 c0 test %al,%al 112cf0: 0f 84 95 00 00 00 je 112d8b return RTEMS_INVALID_CLOCK; if ( !routine ) 112cf6: b8 09 00 00 00 mov $0x9,%eax 112cfb: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 112cff: 0f 84 8b 00 00 00 je 112d90 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; seconds = _TOD_To_seconds( wall_time ); 112d05: 83 ec 0c sub $0xc,%esp 112d08: 53 push %ebx 112d09: e8 fa d9 ff ff call 110708 <_TOD_To_seconds> 112d0e: 89 c7 mov %eax,%edi if ( seconds <= _TOD_Seconds_since_epoch ) 112d10: 83 c4 10 add $0x10,%esp 112d13: 3b 05 c8 41 13 00 cmp 0x1341c8,%eax 112d19: 76 70 jbe 112d8b /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 112d1b: 51 push %ecx 112d1c: 8d 45 f0 lea -0x10(%ebp),%eax 112d1f: 50 push %eax 112d20: ff 75 08 pushl 0x8(%ebp) 112d23: 68 78 4a 13 00 push $0x134a78 112d28: e8 cb 22 00 00 call 114ff8 <_Objects_Get> 112d2d: 89 c6 mov %eax,%esi return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112d2f: 83 c4 10 add $0x10,%esp 112d32: b8 04 00 00 00 mov $0x4,%eax 112d37: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 112d3b: 75 53 jne 112d90 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 112d3d: 8d 5e 10 lea 0x10(%esi),%ebx 112d40: 83 ec 0c sub $0xc,%esp 112d43: 53 push %ebx 112d44: e8 a3 3c 00 00 call 1169ec <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY; 112d49: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi) * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 112d50: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) * @param[in] the_heap is the heap to operate upon 112d57: 8b 45 10 mov 0x10(%ebp),%eax 112d5a: 89 46 2c mov %eax,0x2c(%esi) * @param[in] starting_address is the starting address of the memory for 112d5d: 8b 45 08 mov 0x8(%ebp),%eax 112d60: 89 46 30 mov %eax,0x30(%esi) * the heap 112d63: 8b 45 14 mov 0x14(%ebp),%eax 112d66: 89 46 34 mov %eax,0x34(%esi) * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, 112d69: 2b 3d c8 41 13 00 sub 0x1341c8,%edi 112d6f: 89 7e 1c mov %edi,0x1c(%esi) size_t size ); 112d72: 58 pop %eax 112d73: 5a pop %edx 112d74: 53 push %ebx 112d75: 68 0c 42 13 00 push $0x13420c 112d7a: e8 55 3b 00 00 call 1168d4 <_Watchdog_Insert> _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _Watchdog_Insert_seconds( &the_timer->Ticker, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); 112d7f: e8 34 2a 00 00 call 1157b8 <_Thread_Enable_dispatch> 112d84: 31 c0 xor %eax,%eax 112d86: 83 c4 10 add $0x10,%esp 112d89: eb 05 jmp 112d90 return RTEMS_SUCCESSFUL; 112d8b: b8 14 00 00 00 mov $0x14,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112d90: 8d 65 f4 lea -0xc(%ebp),%esp 112d93: 5b pop %ebx 112d94: 5e pop %esi 112d95: 5f pop %edi 112d96: c9 leave 112d97: c3 ret =============================================================================== 00112d98 : rtems_status_code rtems_timer_get_information( Objects_Id id, rtems_timer_information *the_info ) { 112d98: 55 push %ebp 112d99: 89 e5 mov %esp,%ebp 112d9b: 53 push %ebx 112d9c: 83 ec 14 sub $0x14,%esp 112d9f: 8b 5d 0c mov 0xc(%ebp),%ebx Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 112da2: b8 09 00 00 00 mov $0x9,%eax 112da7: 85 db test %ebx,%ebx 112da9: 74 40 je 112deb <== NEVER TAKEN /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 112dab: 50 push %eax 112dac: 8d 45 f8 lea -0x8(%ebp),%eax 112daf: 50 push %eax 112db0: ff 75 08 pushl 0x8(%ebp) 112db3: 68 78 4a 13 00 push $0x134a78 112db8: e8 3b 22 00 00 call 114ff8 <_Objects_Get> 112dbd: 89 c2 mov %eax,%edx return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112dbf: 83 c4 10 add $0x10,%esp 112dc2: b8 04 00 00 00 mov $0x4,%eax 112dc7: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) 112dcb: 75 1e jne 112deb case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 112dcd: 8b 42 38 mov 0x38(%edx),%eax 112dd0: 89 03 mov %eax,(%ebx) the_info->initial = the_timer->Ticker.initial; 112dd2: 8b 42 1c mov 0x1c(%edx),%eax 112dd5: 89 43 04 mov %eax,0x4(%ebx) the_info->start_time = the_timer->Ticker.start_time; 112dd8: 8b 42 24 mov 0x24(%edx),%eax 112ddb: 89 43 08 mov %eax,0x8(%ebx) the_info->stop_time = the_timer->Ticker.stop_time; 112dde: 8b 42 28 mov 0x28(%edx),%eax 112de1: 89 43 0c mov %eax,0xc(%ebx) _Thread_Enable_dispatch(); 112de4: e8 cf 29 00 00 call 1157b8 <_Thread_Enable_dispatch> 112de9: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112deb: 8b 5d fc mov -0x4(%ebp),%ebx 112dee: c9 leave 112def: c3 ret =============================================================================== 00113048 : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 113048: 55 push %ebp 113049: 89 e5 mov %esp,%ebp 11304b: 57 push %edi 11304c: 56 push %esi 11304d: 53 push %ebx 11304e: 83 ec 1c sub $0x1c,%esp 113051: 8b 55 08 mov 0x8(%ebp),%edx 113054: 8b 75 10 mov 0x10(%ebp),%esi bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ); 113057: 31 c0 xor %eax,%eax 113059: 85 d2 test %edx,%edx 11305b: 74 0f je 11306c 11305d: 0f b6 05 c4 b9 12 00 movzbl 0x12b9c4,%eax 113064: 39 c2 cmp %eax,%edx 113066: 0f 96 c0 setbe %al 113069: 0f b6 c0 movzbl %al,%eax * Make sure the requested priority is valid. The if is * structured so we check it is invalid before looking for * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { 11306c: 89 d7 mov %edx,%edi 11306e: 85 c0 test %eax,%eax 113070: 75 0e jne 113080 <== NEVER TAKEN if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 113072: b8 13 00 00 00 mov $0x13,%eax 113077: 42 inc %edx 113078: 0f 85 31 01 00 00 jne 1131af 11307e: 31 ff xor %edi,%edi /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 113080: a1 38 41 13 00 mov 0x134138,%eax 113085: 40 inc %eax 113086: a3 38 41 13 00 mov %eax,0x134138 /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 11308b: 8a 1d ac fb 12 00 mov 0x12fbac,%bl initialized = true; 113091: c6 05 ac fb 12 00 01 movb $0x1,0x12fbac _Thread_Enable_dispatch(); 113098: e8 1b 27 00 00 call 1157b8 <_Thread_Enable_dispatch> if ( tmpInitialized ) 11309d: b8 0e 00 00 00 mov $0xe,%eax 1130a2: 84 db test %bl,%bl 1130a4: 0f 85 05 01 00 00 jne 1131af 1130aa: c7 05 cc 40 13 00 d0 movl $0x1340d0,0x1340cc 1130b1: 40 13 00 1130b4: c7 05 d0 40 13 00 00 movl $0x0,0x1340d0 1130bb: 00 00 00 1130be: c7 05 d4 40 13 00 cc movl $0x1340cc,0x1340d4 1130c5: 40 13 00 * other library rules. For example, if using a TSR written in Ada the * Server should run at the same priority as the priority Ada task. * Otherwise, the priority ceiling for the mutex used to protect the * GNAT run-time is violated. */ status = rtems_task_create( 1130c8: 52 push %edx 1130c9: 52 push %edx 1130ca: 8d 45 f0 lea -0x10(%ebp),%eax 1130cd: 50 push %eax 1130ce: 81 ce 00 80 00 00 or $0x8000,%esi 1130d4: 56 push %esi 1130d5: 68 00 01 00 00 push $0x100 1130da: ff 75 0c pushl 0xc(%ebp) 1130dd: 57 push %edi 1130de: 68 45 4d 49 54 push $0x54494d45 1130e3: e8 70 f3 ff ff call 112458 /* user may want floating point but we need */ /* system task specified for 0 priority */ attribute_set | RTEMS_SYSTEM_TASK, &id /* get the id back */ ); if (status) { 1130e8: 83 c4 20 add $0x20,%esp 1130eb: 85 c0 test %eax,%eax 1130ed: 0f 85 b5 00 00 00 jne 1131a8 * to a TCB pointer from here out. * * NOTE: Setting the pointer to the Timer Server TCB to a value other than * NULL indicates that task-based timer support is initialized. */ _Timer_Server = (Thread_Control *)_Objects_Get_local_object( 1130f3: 8b 4d f0 mov -0x10(%ebp),%ecx bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 1130f6: 31 c0 xor %eax,%eax 1130f8: 66 3b 0d 7c 40 13 00 cmp 0x13407c,%cx 1130ff: 77 0b ja 11310c <== NEVER TAKEN * This heap routine returns information about the free blocks * in the specified heap. 113101: 0f b7 d1 movzwl %cx,%edx 113104: a1 88 40 13 00 mov 0x134088,%eax 113109: 8b 04 90 mov (%eax,%edx,4),%eax 11310c: a3 bc 4a 13 00 mov %eax,0x134abc 113111: c7 05 ac 40 13 00 b0 movl $0x1340b0,0x1340ac 113118: 40 13 00 11311b: c7 05 b0 40 13 00 00 movl $0x0,0x1340b0 113122: 00 00 00 113125: c7 05 b4 40 13 00 ac movl $0x1340ac,0x1340b4 11312c: 40 13 00 11312f: c7 05 c0 40 13 00 c4 movl $0x1340c4,0x1340c0 113136: 40 13 00 113139: c7 05 c4 40 13 00 00 movl $0x0,0x1340c4 113140: 00 00 00 113143: c7 05 c8 40 13 00 c0 movl $0x1340c0,0x1340c8 11314a: 40 13 00 * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 11314d: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) * @param[in] the_heap is the heap to operate upon 113154: c7 40 64 3c 56 11 00 movl $0x11563c,0x64(%eax) * @param[in] starting_address is the starting address of the memory for 11315b: 89 48 68 mov %ecx,0x68(%eax) * the heap 11315e: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax) * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 113165: c7 05 e0 40 13 00 00 movl $0x0,0x1340e0 11316c: 00 00 00 * @param[in] the_heap is the heap to operate upon 11316f: c7 05 f4 40 13 00 3c movl $0x11563c,0x1340f4 113176: 56 11 00 * @param[in] starting_address is the starting address of the memory for 113179: 89 0d f8 40 13 00 mov %ecx,0x1340f8 * the heap 11317f: c7 05 fc 40 13 00 00 movl $0x0,0x1340fc 113186: 00 00 00 /* * Initialize the pointer to the timer reset method so applications * that do not use the Timer Server do not have to pull it in. */ _Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method; 113189: c7 05 b8 4a 13 00 b7 movl $0x1131b7,0x134ab8 113190: 31 11 00 /* * Start the timer server */ status = rtems_task_start( 113193: 50 push %eax 113194: 6a 00 push $0x0 113196: 68 40 32 11 00 push $0x113240 11319b: 51 push %ecx 11319c: e8 53 f7 ff ff call 1128f4 id, /* the id from create */ (rtems_task_entry) _Timer_Server_body, /* the timer server entry point */ 0 /* there is no argument */ ); if (status) { 1131a1: 83 c4 10 add $0x10,%esp 1131a4: 85 c0 test %eax,%eax 1131a6: 74 07 je 1131af <== ALWAYS TAKEN * but there is actually no way (in normal circumstances) that the * start can fail. The id and starting address are known to be * be good. If this service fails, something is weirdly wrong on the * target such as a stray write in an ISR or incorrect memory layout. */ initialized = false; 1131a8: c6 05 ac fb 12 00 00 movb $0x0,0x12fbac } return status; } 1131af: 8d 65 f4 lea -0xc(%ebp),%esp 1131b2: 5b pop %ebx 1131b3: 5e pop %esi 1131b4: 5f pop %edi 1131b5: c9 leave 1131b6: c3 ret =============================================================================== 00112e14 : */ rtems_status_code rtems_timer_reset( Objects_Id id ) { 112e14: 55 push %ebp 112e15: 89 e5 mov %esp,%ebp 112e17: 53 push %ebx 112e18: 83 ec 18 sub $0x18,%esp 112e1b: 8d 45 f8 lea -0x8(%ebp),%eax 112e1e: 50 push %eax 112e1f: ff 75 08 pushl 0x8(%ebp) 112e22: 68 78 4a 13 00 push $0x134a78 112e27: e8 cc 21 00 00 call 114ff8 <_Objects_Get> 112e2c: 89 c3 mov %eax,%ebx Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112e2e: 83 c4 10 add $0x10,%esp 112e31: b8 04 00 00 00 mov $0x4,%eax 112e36: 83 7d f8 00 cmpl $0x0,-0x8(%ebp) 112e3a: 75 6e jne 112eaa case OBJECTS_LOCAL: switch ( the_timer->the_class ) { 112e3c: 8b 43 38 mov 0x38(%ebx),%eax 112e3f: 83 f8 01 cmp $0x1,%eax 112e42: 74 24 je 112e68 112e44: 72 07 jb 112e4d 112e46: 83 f8 04 cmp $0x4,%eax 112e49: 77 58 ja 112ea3 <== NEVER TAKEN 112e4b: eb 4a jmp 112e97 case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); 112e4d: 83 c3 10 add $0x10,%ebx 112e50: 83 ec 0c sub $0xc,%esp 112e53: 53 push %ebx 112e54: e8 93 3b 00 00 call 1169ec <_Watchdog_Remove> _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 112e59: 58 pop %eax 112e5a: 5a pop %edx 112e5b: 53 push %ebx 112e5c: 68 18 42 13 00 push $0x134218 112e61: e8 6e 3a 00 00 call 1168d4 <_Watchdog_Insert> 112e66: eb 2a jmp 112e92 break; case TIMER_INTERVAL_ON_TASK: if ( !_Timer_Server_schedule_operation ) { 112e68: 83 3d b8 4a 13 00 00 cmpl $0x0,0x134ab8 112e6f: 75 0c jne 112e7d <== ALWAYS TAKEN _Thread_Enable_dispatch(); 112e71: e8 42 29 00 00 call 1157b8 <_Thread_Enable_dispatch><== NOT EXECUTED 112e76: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 112e7b: eb 2d jmp 112eaa <== NOT EXECUTED return RTEMS_INCORRECT_STATE; } _Watchdog_Remove( &the_timer->Ticker ); 112e7d: 83 ec 0c sub $0xc,%esp 112e80: 8d 43 10 lea 0x10(%ebx),%eax 112e83: 50 push %eax 112e84: e8 63 3b 00 00 call 1169ec <_Watchdog_Remove> (*_Timer_Server_schedule_operation)( the_timer ); 112e89: 89 1c 24 mov %ebx,(%esp) 112e8c: ff 15 b8 4a 13 00 call *0x134ab8 112e92: 83 c4 10 add $0x10,%esp 112e95: eb 0c jmp 112ea3 break; case TIMER_TIME_OF_DAY: case TIMER_TIME_OF_DAY_ON_TASK: case TIMER_DORMANT: _Thread_Enable_dispatch(); 112e97: e8 1c 29 00 00 call 1157b8 <_Thread_Enable_dispatch> 112e9c: b8 0b 00 00 00 mov $0xb,%eax 112ea1: eb 07 jmp 112eaa return RTEMS_NOT_DEFINED; } _Thread_Enable_dispatch(); 112ea3: e8 10 29 00 00 call 1157b8 <_Thread_Enable_dispatch> 112ea8: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112eaa: 8b 5d fc mov -0x4(%ebp),%ebx 112ead: c9 leave 112eae: c3 ret =============================================================================== 00112eb0 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 112eb0: 55 push %ebp 112eb1: 89 e5 mov %esp,%ebp 112eb3: 57 push %edi 112eb4: 56 push %esi 112eb5: 53 push %ebx 112eb6: 83 ec 1c sub $0x1c,%esp 112eb9: 8b 7d 08 mov 0x8(%ebp),%edi 112ebc: 8b 75 10 mov 0x10(%ebp),%esi Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 112ebf: b8 0e 00 00 00 mov $0xe,%eax 112ec4: 83 3d bc 4a 13 00 00 cmpl $0x0,0x134abc 112ecb: 0f 84 91 00 00 00 je 112f62 return RTEMS_INCORRECT_STATE; if ( !routine ) 112ed1: b8 09 00 00 00 mov $0x9,%eax 112ed6: 85 f6 test %esi,%esi 112ed8: 0f 84 84 00 00 00 je 112f62 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 112ede: b8 0a 00 00 00 mov $0xa,%eax 112ee3: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 112ee7: 74 79 je 112f62 112ee9: 50 push %eax 112eea: 8d 45 f0 lea -0x10(%ebp),%eax 112eed: 50 push %eax 112eee: 57 push %edi 112eef: 68 78 4a 13 00 push $0x134a78 112ef4: e8 ff 20 00 00 call 114ff8 <_Objects_Get> 112ef9: 89 c3 mov %eax,%ebx return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112efb: 83 c4 10 add $0x10,%esp 112efe: b8 04 00 00 00 mov $0x4,%eax 112f03: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 112f07: 75 59 jne 112f62 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 112f09: 83 ec 0c sub $0xc,%esp 112f0c: 8d 43 10 lea 0x10(%ebx),%eax 112f0f: 50 push %eax 112f10: e8 d7 3a 00 00 call 1169ec <_Watchdog_Remove> _ISR_Disable( level ); 112f15: 9c pushf 112f16: fa cli 112f17: 5a pop %edx /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { 112f18: 83 c4 10 add $0x10,%esp 112f1b: 83 7b 18 00 cmpl $0x0,0x18(%ebx) 112f1f: 74 0b je 112f2c <== ALWAYS TAKEN _ISR_Enable( level ); 112f21: 52 push %edx <== NOT EXECUTED 112f22: 9d popf <== NOT EXECUTED _Thread_Enable_dispatch(); 112f23: e8 90 28 00 00 call 1157b8 <_Thread_Enable_dispatch><== NOT EXECUTED 112f28: 31 c0 xor %eax,%eax <== NOT EXECUTED 112f2a: eb 36 jmp 112f62 <== NOT EXECUTED /* * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL_ON_TASK; 112f2c: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 112f33: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) * @param[in] the_heap is the heap to operate upon 112f3a: 89 73 2c mov %esi,0x2c(%ebx) * @param[in] starting_address is the starting address of the memory for 112f3d: 89 7b 30 mov %edi,0x30(%ebx) * the heap 112f40: 8b 45 14 mov 0x14(%ebp),%eax 112f43: 89 43 34 mov %eax,0x34(%ebx) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = ticks; 112f46: 8b 45 0c mov 0xc(%ebp),%eax 112f49: 89 43 1c mov %eax,0x1c(%ebx) _ISR_Enable( level ); 112f4c: 52 push %edx 112f4d: 9d popf /* * _Timer_Server_schedule_operation != NULL because we checked that * _Timer_Server was != NULL above. Both are set at the same time. */ (*_Timer_Server_schedule_operation)( the_timer ); 112f4e: 83 ec 0c sub $0xc,%esp 112f51: 53 push %ebx 112f52: ff 15 b8 4a 13 00 call *0x134ab8 _Thread_Enable_dispatch(); 112f58: e8 5b 28 00 00 call 1157b8 <_Thread_Enable_dispatch> 112f5d: 31 c0 xor %eax,%eax 112f5f: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112f62: 8d 65 f4 lea -0xc(%ebp),%esp 112f65: 5b pop %ebx 112f66: 5e pop %esi 112f67: 5f pop %edi 112f68: c9 leave 112f69: c3 ret =============================================================================== 00112f6c : Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 112f6c: 55 push %ebp 112f6d: 89 e5 mov %esp,%ebp 112f6f: 57 push %edi 112f70: 56 push %esi 112f71: 53 push %ebx 112f72: 83 ec 1c sub $0x1c,%esp 112f75: 8b 5d 0c mov 0xc(%ebp),%ebx 112f78: 8b 7d 10 mov 0x10(%ebp),%edi Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_Timer_Server ) 112f7b: b8 0e 00 00 00 mov $0xe,%eax 112f80: 83 3d bc 4a 13 00 00 cmpl $0x0,0x134abc 112f87: 0f 84 b3 00 00 00 je 113040 <== NEVER TAKEN return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 112f8d: b8 0b 00 00 00 mov $0xb,%eax 112f92: 80 3d 4c 41 13 00 00 cmpb $0x0,0x13414c 112f99: 0f 84 a1 00 00 00 je 113040 <== NEVER TAKEN return RTEMS_NOT_DEFINED; if ( !routine ) 112f9f: b8 09 00 00 00 mov $0x9,%eax 112fa4: 85 ff test %edi,%edi 112fa6: 0f 84 94 00 00 00 je 113040 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 112fac: 83 ec 0c sub $0xc,%esp 112faf: 53 push %ebx 112fb0: e8 bb d7 ff ff call 110770 <_TOD_Validate> 112fb5: 83 c4 10 add $0x10,%esp 112fb8: 84 c0 test %al,%al 112fba: 74 7f je 11303b <== NEVER TAKEN return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 112fbc: 83 ec 0c sub $0xc,%esp 112fbf: 53 push %ebx 112fc0: e8 43 d7 ff ff call 110708 <_TOD_To_seconds> 112fc5: 89 c6 mov %eax,%esi if ( seconds <= _TOD_Seconds_since_epoch ) 112fc7: 83 c4 10 add $0x10,%esp 112fca: 3b 05 c8 41 13 00 cmp 0x1341c8,%eax 112fd0: 76 69 jbe 11303b <== NEVER TAKEN /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 112fd2: 50 push %eax 112fd3: 8d 45 f0 lea -0x10(%ebp),%eax 112fd6: 50 push %eax 112fd7: ff 75 08 pushl 0x8(%ebp) 112fda: 68 78 4a 13 00 push $0x134a78 112fdf: e8 14 20 00 00 call 114ff8 <_Objects_Get> 112fe4: 89 c3 mov %eax,%ebx return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 112fe6: 83 c4 10 add $0x10,%esp 112fe9: b8 04 00 00 00 mov $0x4,%eax 112fee: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 112ff2: 75 4c jne 113040 <== NEVER TAKEN case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 112ff4: 83 ec 0c sub $0xc,%esp 112ff7: 8d 43 10 lea 0x10(%ebx),%eax 112ffa: 50 push %eax 112ffb: e8 ec 39 00 00 call 1169ec <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 113000: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 113007: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) * @param[in] the_heap is the heap to operate upon 11300e: 89 7b 2c mov %edi,0x2c(%ebx) * @param[in] starting_address is the starting address of the memory for 113011: 8b 45 08 mov 0x8(%ebp),%eax 113014: 89 43 30 mov %eax,0x30(%ebx) * the heap 113017: 8b 45 14 mov 0x14(%ebp),%eax 11301a: 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; 11301d: 2b 35 c8 41 13 00 sub 0x1341c8,%esi 113023: 89 73 1c mov %esi,0x1c(%ebx) /* * _Timer_Server_schedule_operation != NULL because we checked that * _Timer_Server was != NULL above. Both are set at the same time. */ (*_Timer_Server_schedule_operation)( the_timer ); 113026: 89 1c 24 mov %ebx,(%esp) 113029: ff 15 b8 4a 13 00 call *0x134ab8 _Thread_Enable_dispatch(); 11302f: e8 84 27 00 00 call 1157b8 <_Thread_Enable_dispatch> 113034: 31 c0 xor %eax,%eax 113036: 83 c4 10 add $0x10,%esp 113039: eb 05 jmp 113040 return RTEMS_SUCCESSFUL; 11303b: b8 14 00 00 00 mov $0x14,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 113040: 8d 65 f4 lea -0xc(%ebp),%esp 113043: 5b pop %ebx 113044: 5e pop %esi 113045: 5f pop %edi 113046: c9 leave 113047: c3 ret =============================================================================== 00106ec1 : static int rtems_verror( uint32_t error_flag, const char *printf_format, va_list arglist ) { 106ec1: 55 push %ebp <== NOT EXECUTED 106ec2: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106ec4: 57 push %edi <== NOT EXECUTED 106ec5: 56 push %esi <== NOT EXECUTED 106ec6: 53 push %ebx <== NOT EXECUTED 106ec7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106eca: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 106ecd: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 106ed0: 89 cb mov %ecx,%ebx <== NOT EXECUTED int local_errno = 0; int chars_written = 0; rtems_status_code status; if (error_flag & RTEMS_ERROR_PANIC) 106ed2: 25 00 00 00 20 and $0x20000000,%eax <== NOT EXECUTED 106ed7: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 106eda: 74 2a je 106f06 <== NOT EXECUTED { if (rtems_panic_in_progress++) 106edc: 8b 15 30 91 12 00 mov 0x129130,%edx <== NOT EXECUTED 106ee2: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 106ee5: a3 30 91 12 00 mov %eax,0x129130 <== NOT EXECUTED 106eea: 85 d2 test %edx,%edx <== NOT EXECUTED 106eec: 74 0b je 106ef9 <== NOT EXECUTED 106eee: a1 94 92 12 00 mov 0x129294,%eax <== NOT EXECUTED 106ef3: 40 inc %eax <== NOT EXECUTED 106ef4: a3 94 92 12 00 mov %eax,0x129294 <== NOT EXECUTED _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) 106ef9: 83 3d 30 91 12 00 02 cmpl $0x2,0x129130 <== NOT EXECUTED 106f00: 0f 8f 18 01 00 00 jg 10701e <== NOT EXECUTED return 0; } (void) fflush(stdout); /* in case stdout/stderr same */ 106f06: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106f09: a1 c0 f4 11 00 mov 0x11f4c0,%eax <== NOT EXECUTED 106f0e: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 106f11: e8 b6 99 00 00 call 1108cc <== NOT EXECUTED status = error_flag & ~RTEMS_ERROR_MASK; 106f16: 8b 75 ec mov -0x14(%ebp),%esi <== NOT EXECUTED 106f19: 81 e6 ff ff ff 8f and $0x8fffffff,%esi <== NOT EXECUTED if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 106f1f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106f22: 31 ff xor %edi,%edi <== NOT EXECUTED 106f24: f7 45 ec 00 00 00 40 testl $0x40000000,-0x14(%ebp) <== NOT EXECUTED 106f2b: 74 07 je 106f34 <== NOT EXECUTED local_errno = errno; 106f2d: e8 ea 96 00 00 call 11061c <__errno> <== NOT EXECUTED 106f32: 8b 38 mov (%eax),%edi <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if (_System_state_Is_multiprocessing) fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node); #endif chars_written += vfprintf(stderr, printf_format, arglist); 106f34: 50 push %eax <== NOT EXECUTED 106f35: 53 push %ebx <== NOT EXECUTED 106f36: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 106f39: a1 c0 f4 11 00 mov 0x11f4c0,%eax <== NOT EXECUTED 106f3e: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 106f41: e8 6e e3 00 00 call 1152b4 <== NOT EXECUTED 106f46: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (status) 106f48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106f4b: 85 f6 test %esi,%esi <== NOT EXECUTED 106f4d: 74 28 je 106f77 <== NOT EXECUTED const char * rtems_status_text( rtems_status_code status ) { return rtems_assoc_name_by_local(rtems_status_assoc, status); 106f4f: 50 push %eax <== NOT EXECUTED 106f50: 50 push %eax <== NOT EXECUTED 106f51: 56 push %esi <== NOT EXECUTED 106f52: 68 18 a5 11 00 push $0x11a518 <== NOT EXECUTED 106f57: e8 2c 73 00 00 call 10e288 <== NOT EXECUTED #endif chars_written += vfprintf(stderr, printf_format, arglist); if (status) chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); 106f5c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 106f5f: 50 push %eax <== NOT EXECUTED 106f60: 68 09 a2 11 00 push $0x11a209 <== NOT EXECUTED 106f65: a1 c0 f4 11 00 mov 0x11f4c0,%eax <== NOT EXECUTED 106f6a: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 106f6d: e8 0a 9d 00 00 call 110c7c <== NOT EXECUTED 106f72: 01 c3 add %eax,%ebx <== NOT EXECUTED 106f74: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (local_errno) 106f77: 83 ff 00 cmp $0x0,%edi <== NOT EXECUTED 106f7a: 74 40 je 106fbc <== NOT EXECUTED { if ((local_errno > 0) && *strerror(local_errno)) 106f7c: 7e 25 jle 106fa3 <== NOT EXECUTED 106f7e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106f81: 57 push %edi <== NOT EXECUTED 106f82: e8 d1 a9 00 00 call 111958 <== NOT EXECUTED 106f87: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106f8a: 80 38 00 cmpb $0x0,(%eax) <== NOT EXECUTED 106f8d: 74 14 je 106fa3 <== NOT EXECUTED chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); 106f8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106f92: 57 push %edi <== NOT EXECUTED 106f93: e8 c0 a9 00 00 call 111958 <== NOT EXECUTED 106f98: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 106f9b: 50 push %eax <== NOT EXECUTED 106f9c: 68 17 a2 11 00 push $0x11a217 <== NOT EXECUTED 106fa1: eb 07 jmp 106faa <== NOT EXECUTED else chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno); 106fa3: 50 push %eax <== NOT EXECUTED 106fa4: 57 push %edi <== NOT EXECUTED 106fa5: 68 24 a2 11 00 push $0x11a224 <== NOT EXECUTED 106faa: a1 c0 f4 11 00 mov 0x11f4c0,%eax <== NOT EXECUTED 106faf: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 106fb2: e8 c5 9c 00 00 call 110c7c <== NOT EXECUTED 106fb7: 01 c3 add %eax,%ebx <== NOT EXECUTED 106fb9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } chars_written += fprintf(stderr, "\n"); 106fbc: 56 push %esi <== NOT EXECUTED 106fbd: 56 push %esi <== NOT EXECUTED 106fbe: 68 f5 a9 11 00 push $0x11a9f5 <== NOT EXECUTED 106fc3: a1 c0 f4 11 00 mov 0x11f4c0,%eax <== NOT EXECUTED 106fc8: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 106fcb: e8 ac 9c 00 00 call 110c7c <== NOT EXECUTED 106fd0: 89 c6 mov %eax,%esi <== NOT EXECUTED (void) fflush(stderr); 106fd2: 59 pop %ecx <== NOT EXECUTED 106fd3: a1 c0 f4 11 00 mov 0x11f4c0,%eax <== NOT EXECUTED 106fd8: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 106fdb: e8 ec 98 00 00 call 1108cc <== NOT EXECUTED if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT)) 106fe0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); else chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno); } chars_written += fprintf(stderr, "\n"); 106fe3: 8d 04 1e lea (%esi,%ebx,1),%eax <== NOT EXECUTED (void) fflush(stderr); if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT)) 106fe6: f7 45 ec 00 00 00 30 testl $0x30000000,-0x14(%ebp) <== NOT EXECUTED 106fed: 74 31 je 107020 <== NOT EXECUTED { if (error_flag & RTEMS_ERROR_PANIC) 106fef: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 106ff3: 74 16 je 10700b <== NOT EXECUTED { rtems_error(0, "fatal error, exiting"); 106ff5: 52 push %edx <== NOT EXECUTED 106ff6: 52 push %edx <== NOT EXECUTED 106ff7: 68 38 a2 11 00 push $0x11a238 <== NOT EXECUTED 106ffc: 6a 00 push $0x0 <== NOT EXECUTED 106ffe: e8 3d 00 00 00 call 107040 <== NOT EXECUTED _exit(local_errno); 107003: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 107006: e8 fb 05 00 00 call 107606 <_exit> <== NOT EXECUTED } else { rtems_error(0, "fatal error, aborting"); 10700b: 50 push %eax <== NOT EXECUTED 10700c: 50 push %eax <== NOT EXECUTED 10700d: 68 4d a2 11 00 push $0x11a24d <== NOT EXECUTED 107012: 6a 00 push $0x0 <== NOT EXECUTED 107014: e8 27 00 00 00 call 107040 <== NOT EXECUTED abort(); 107019: e8 ca 95 00 00 call 1105e8 <== NOT EXECUTED 10701e: 31 c0 xor %eax,%eax <== NOT EXECUTED } } return chars_written; } 107020: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107023: 5b pop %ebx <== NOT EXECUTED 107024: 5e pop %esi <== NOT EXECUTED 107025: 5f pop %edi <== NOT EXECUTED 107026: c9 leave <== NOT EXECUTED 107027: c3 ret <== NOT EXECUTED =============================================================================== 00109d5d : */ bool rtems_workspace_allocate( uintptr_t bytes, void **pointer ) { 109d5d: 55 push %ebp 109d5e: 89 e5 mov %esp,%ebp 109d60: 53 push %ebx 109d61: 83 ec 04 sub $0x4,%esp 109d64: 8b 45 08 mov 0x8(%ebp),%eax 109d67: 8b 5d 0c mov 0xc(%ebp),%ebx void *ptr; /* * check the arguments */ if ( !pointer ) 109d6a: 85 db test %ebx,%ebx 109d6c: 74 1e je 109d8c <== NEVER TAKEN return false; if ( !bytes ) 109d6e: 85 c0 test %eax,%eax 109d70: 74 1a je 109d8c <== NEVER TAKEN return false; /* * Allocate the memory */ ptr = _Protected_heap_Allocate( &_Workspace_Area, (intptr_t) bytes ); 109d72: 52 push %edx 109d73: 52 push %edx 109d74: 50 push %eax 109d75: 68 c8 19 12 00 push $0x1219c8 109d7a: e8 c5 13 00 00 call 10b144 <_Protected_heap_Allocate> if (!ptr) 109d7f: 83 c4 10 add $0x10,%esp 109d82: 85 c0 test %eax,%eax 109d84: 74 06 je 109d8c <== NEVER TAKEN return false; *pointer = ptr; 109d86: 89 03 mov %eax,(%ebx) 109d88: b0 01 mov $0x1,%al 109d8a: eb 02 jmp 109d8e return true; 109d8c: 31 c0 xor %eax,%eax } 109d8e: 8b 5d fc mov -0x4(%ebp),%ebx 109d91: c9 leave 109d92: c3 ret =============================================================================== 00109d48 : * _Workspace_Allocate */ bool rtems_workspace_free( void *pointer ) { 109d48: 55 push %ebp <== NOT EXECUTED 109d49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109d4b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Protected_heap_Free( &_Workspace_Area, pointer ); 109d4e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109d51: 68 c8 19 12 00 push $0x1219c8 <== NOT EXECUTED 109d56: e8 1d 14 00 00 call 10b178 <_Protected_heap_Free> <== NOT EXECUTED } 109d5b: c9 leave <== NOT EXECUTED 109d5c: c3 ret <== NOT EXECUTED =============================================================================== 00109d93 : #include /* for memset */ bool rtems_workspace_get_information( Heap_Information_block *the_info ) { 109d93: 55 push %ebp 109d94: 89 e5 mov %esp,%ebp 109d96: 83 ec 08 sub $0x8,%esp 109d99: 8b 55 08 mov 0x8(%ebp),%edx if ( !the_info ) 109d9c: 31 c0 xor %eax,%eax 109d9e: 85 d2 test %edx,%edx 109da0: 74 10 je 109db2 <== NEVER TAKEN return false; return _Protected_heap_Get_information( &_Workspace_Area, the_info ); 109da2: 51 push %ecx 109da3: 51 push %ecx 109da4: 52 push %edx 109da5: 68 c8 19 12 00 push $0x1219c8 109daa: e8 fd 13 00 00 call 10b1ac <_Protected_heap_Get_information> 109daf: 83 c4 10 add $0x10,%esp } 109db2: c9 leave 109db3: c3 ret =============================================================================== 00108e43 : scandir( const char *dirname, struct dirent ***namelist, int (*select)(struct dirent *), int (*dcomp)(const struct dirent **, const struct dirent **)) { 108e43: 55 push %ebp 108e44: 89 e5 mov %esp,%ebp 108e46: 57 push %edi 108e47: 56 push %esi 108e48: 53 push %ebx 108e49: 83 ec 78 sub $0x78,%esp struct stat stb; long arraysz; DIR *dirp = NULL; int i; if ((dirp = opendir(dirname)) == NULL) 108e4c: ff 75 08 pushl 0x8(%ebp) 108e4f: e8 f0 f8 ff ff call 108744 108e54: 89 45 a0 mov %eax,-0x60(%ebp) 108e57: 83 c4 10 add $0x10,%esp 108e5a: 85 c0 test %eax,%eax 108e5c: 0f 84 99 01 00 00 je 108ffb <== NEVER TAKEN return(-1); if (fstat(dirp->dd_fd, &stb) < 0) 108e62: 51 push %ecx 108e63: 51 push %ecx 108e64: 8d 5d a8 lea -0x58(%ebp),%ebx 108e67: 53 push %ebx 108e68: ff 30 pushl (%eax) 108e6a: e8 15 60 00 00 call 10ee84 108e6f: 83 c4 10 add $0x10,%esp 108e72: 85 c0 test %eax,%eax 108e74: 0f 88 3d 01 00 00 js 108fb7 <== NEVER TAKEN /* * estimate the array size by taking the size of the directory file * and dividing it by a multiple of the minimum size entry. */ arraysz = (stb.st_size / 24); 108e7a: 8b 45 c8 mov -0x38(%ebp),%eax 108e7d: b9 18 00 00 00 mov $0x18,%ecx 108e82: 99 cltd 108e83: f7 f9 idiv %ecx 108e85: 89 45 9c mov %eax,-0x64(%ebp) names = (struct dirent **)malloc(arraysz * sizeof(struct dirent *)); 108e88: 83 ec 0c sub $0xc,%esp 108e8b: c1 e0 02 shl $0x2,%eax 108e8e: 50 push %eax 108e8f: e8 f8 f0 ff ff call 107f8c 108e94: 89 c6 mov %eax,%esi if (names == NULL) 108e96: 83 c4 10 add $0x10,%esp 108e99: c7 45 98 00 00 00 00 movl $0x0,-0x68(%ebp) 108ea0: 85 c0 test %eax,%eax 108ea2: 0f 85 c2 00 00 00 jne 108f6a 108ea8: 89 45 98 mov %eax,-0x68(%ebp) 108eab: e9 10 01 00 00 jmp 108fc0 goto cleanup_and_bail; while ((d = readdir(dirp)) != NULL) { if (select != NULL && !(*select)(d)) 108eb0: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 108eb4: 74 12 je 108ec8 <== NEVER TAKEN 108eb6: 83 ec 0c sub $0xc,%esp 108eb9: 53 push %ebx 108eba: ff 55 10 call *0x10(%ebp) 108ebd: 83 c4 10 add $0x10,%esp 108ec0: 85 c0 test %eax,%eax 108ec2: 0f 84 a2 00 00 00 je 108f6a continue; /* just selected names */ /* * Make a minimum size copy of the data */ p = (struct dirent *)malloc(DIRSIZ(d)); 108ec8: 83 ec 0c sub $0xc,%esp 108ecb: 0f b7 43 0a movzwl 0xa(%ebx),%eax 108ecf: 83 c0 04 add $0x4,%eax 108ed2: 83 e0 fc and $0xfffffffc,%eax 108ed5: 83 c0 0c add $0xc,%eax 108ed8: 50 push %eax 108ed9: e8 ae f0 ff ff call 107f8c 108ede: 89 c7 mov %eax,%edi if (p == NULL) 108ee0: 83 c4 10 add $0x10,%esp 108ee3: 85 c0 test %eax,%eax 108ee5: 0f 84 d5 00 00 00 je 108fc0 <== NEVER TAKEN goto cleanup_and_bail; p->d_ino = d->d_ino; 108eeb: 8b 03 mov (%ebx),%eax 108eed: 89 07 mov %eax,(%edi) p->d_reclen = d->d_reclen; 108eef: 8b 43 08 mov 0x8(%ebx),%eax 108ef2: 66 89 47 08 mov %ax,0x8(%edi) p->d_namlen = d->d_namlen; 108ef6: 0f b7 43 0a movzwl 0xa(%ebx),%eax 108efa: 66 89 47 0a mov %ax,0xa(%edi) strncpy(p->d_name, d->d_name, p->d_namlen + 1); 108efe: 52 push %edx 108eff: 40 inc %eax 108f00: 50 push %eax 108f01: 8d 43 0c lea 0xc(%ebx),%eax 108f04: 50 push %eax 108f05: 8d 47 0c lea 0xc(%edi),%eax 108f08: 50 push %eax 108f09: e8 6e a9 00 00 call 11387c /* * Check to make sure the array has space left and * realloc the maximum size. */ if (++nitems >= arraysz) { 108f0e: ff 45 98 incl -0x68(%ebp) 108f11: 83 c4 10 add $0x10,%esp 108f14: 8b 45 9c mov -0x64(%ebp),%eax 108f17: 39 45 98 cmp %eax,-0x68(%ebp) 108f1a: 72 40 jb 108f5c <== ALWAYS TAKEN if (fstat(dirp->dd_fd, &stb) < 0) 108f1c: 51 push %ecx <== NOT EXECUTED 108f1d: 51 push %ecx <== NOT EXECUTED 108f1e: 8d 55 a8 lea -0x58(%ebp),%edx <== NOT EXECUTED 108f21: 52 push %edx <== NOT EXECUTED 108f22: 8b 45 a0 mov -0x60(%ebp),%eax <== NOT EXECUTED 108f25: ff 30 pushl (%eax) <== NOT EXECUTED 108f27: e8 58 5f 00 00 call 10ee84 <== NOT EXECUTED 108f2c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f2f: 85 c0 test %eax,%eax <== NOT EXECUTED 108f31: 0f 88 89 00 00 00 js 108fc0 <== NOT EXECUTED goto cleanup_and_bail; /* just might have grown */ arraysz = stb.st_size / 12; 108f37: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 108f3a: bb 0c 00 00 00 mov $0xc,%ebx <== NOT EXECUTED 108f3f: 89 c8 mov %ecx,%eax <== NOT EXECUTED 108f41: 99 cltd <== NOT EXECUTED 108f42: f7 fb idiv %ebx <== NOT EXECUTED 108f44: 89 45 9c mov %eax,-0x64(%ebp) <== NOT EXECUTED names = (struct dirent **)realloc((char *)names, 108f47: 52 push %edx <== NOT EXECUTED 108f48: 52 push %edx <== NOT EXECUTED 108f49: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 108f4c: 50 push %eax <== NOT EXECUTED 108f4d: 56 push %esi <== NOT EXECUTED 108f4e: e8 1d 61 00 00 call 10f070 <== NOT EXECUTED 108f53: 89 c6 mov %eax,%esi <== NOT EXECUTED arraysz * sizeof(struct dirent *)); if (names == NULL) 108f55: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f58: 85 c0 test %eax,%eax <== NOT EXECUTED 108f5a: 74 64 je 108fc0 <== NOT EXECUTED goto cleanup_and_bail; } names[nitems-1] = p; 108f5c: b8 01 00 00 00 mov $0x1,%eax 108f61: 2b 45 98 sub -0x68(%ebp),%eax 108f64: 6b c0 fc imul $0xfffffffc,%eax,%eax 108f67: 89 3c 30 mov %edi,(%eax,%esi,1) arraysz = (stb.st_size / 24); names = (struct dirent **)malloc(arraysz * sizeof(struct dirent *)); if (names == NULL) goto cleanup_and_bail; while ((d = readdir(dirp)) != NULL) { 108f6a: 83 ec 0c sub $0xc,%esp 108f6d: ff 75 a0 pushl -0x60(%ebp) 108f70: e8 1f fd ff ff call 108c94 108f75: 89 c3 mov %eax,%ebx 108f77: 83 c4 10 add $0x10,%esp 108f7a: 85 c0 test %eax,%eax 108f7c: 0f 85 2e ff ff ff jne 108eb0 if (names == NULL) goto cleanup_and_bail; } names[nitems-1] = p; } closedir(dirp); 108f82: 83 ec 0c sub $0xc,%esp 108f85: ff 75 a0 pushl -0x60(%ebp) 108f88: e8 f7 e6 ff ff call 107684 if (nitems && dcomp != NULL){ 108f8d: 83 c4 10 add $0x10,%esp 108f90: 83 7d 98 00 cmpl $0x0,-0x68(%ebp) 108f94: 74 17 je 108fad <== NEVER TAKEN 108f96: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 108f9a: 74 11 je 108fad qsort(names, nitems, sizeof(struct dirent *), 108f9c: ff 75 14 pushl 0x14(%ebp) 108f9f: 6a 04 push $0x4 108fa1: ff 75 98 pushl -0x68(%ebp) 108fa4: 56 push %esi 108fa5: e8 46 9d 00 00 call 112cf0 108faa: 83 c4 10 add $0x10,%esp (int (*)(const void *, const void *)) dcomp); } *namelist = names; 108fad: 8b 45 0c mov 0xc(%ebp),%eax 108fb0: 89 30 mov %esi,(%eax) return(nitems); 108fb2: 8b 45 98 mov -0x68(%ebp),%eax 108fb5: eb 47 jmp 108ffe 108fb7: 31 f6 xor %esi,%esi 108fb9: c7 45 98 00 00 00 00 movl $0x0,-0x68(%ebp) <== NOT EXECUTED cleanup_and_bail: if ( dirp ) closedir( dirp ); 108fc0: 83 ec 0c sub $0xc,%esp 108fc3: ff 75 a0 pushl -0x60(%ebp) 108fc6: e8 b9 e6 ff ff call 107684 if ( names ) { 108fcb: 83 c4 10 add $0x10,%esp 108fce: 31 db xor %ebx,%ebx 108fd0: 85 f6 test %esi,%esi 108fd2: 74 27 je 108ffb <== ALWAYS TAKEN 108fd4: eb 0f jmp 108fe5 <== NOT EXECUTED for (i=0; i < nitems; i++ ) free( names[i] ); 108fd6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108fd9: ff 34 9e pushl (%esi,%ebx,4) <== NOT EXECUTED 108fdc: e8 77 ea ff ff call 107a58 <== NOT EXECUTED if ( dirp ) closedir( dirp ); if ( names ) { for (i=0; i < nitems; i++ ) 108fe1: 43 inc %ebx <== NOT EXECUTED 108fe2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108fe5: 3b 5d 98 cmp -0x68(%ebp),%ebx <== NOT EXECUTED 108fe8: 72 ec jb 108fd6 <== NOT EXECUTED free( names[i] ); free( names ); 108fea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108fed: 56 push %esi <== NOT EXECUTED 108fee: e8 65 ea ff ff call 107a58 <== NOT EXECUTED 108ff3: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 108ff6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108ff9: eb 03 jmp 108ffe <== NOT EXECUTED 108ffb: 83 c8 ff or $0xffffffff,%eax } return(-1); } 108ffe: 8d 65 f4 lea -0xc(%ebp),%esp 109001: 5b pop %ebx 109002: 5e pop %esi 109003: 5f pop %edi 109004: c9 leave 109005: c3 ret =============================================================================== 0010a178 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 10a178: 55 push %ebp 10a179: 89 e5 mov %esp,%ebp 10a17b: 56 push %esi 10a17c: 53 push %ebx 10a17d: 8b 5d 08 mov 0x8(%ebp),%ebx 10a180: 8b 75 0c mov 0xc(%ebp),%esi /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10a183: 85 db test %ebx,%ebx 10a185: 74 16 je 10a19d <== NEVER TAKEN 10a187: e8 54 d1 ff ff call 1072e0 10a18c: 39 c3 cmp %eax,%ebx 10a18e: 74 0d je 10a19d rtems_set_errno_and_return_minus_one( ESRCH ); 10a190: e8 6b 66 00 00 call 110800 <__errno> 10a195: c7 00 03 00 00 00 movl $0x3,(%eax) 10a19b: eb 0f jmp 10a1ac if ( !interval ) 10a19d: 85 f6 test %esi,%esi 10a19f: 75 10 jne 10a1b1 rtems_set_errno_and_return_minus_one( EINVAL ); 10a1a1: e8 5a 66 00 00 call 110800 <__errno> 10a1a6: c7 00 16 00 00 00 movl $0x16,(%eax) 10a1ac: 83 c8 ff or $0xffffffff,%eax 10a1af: eb 13 jmp 10a1c4 _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 10a1b1: 50 push %eax 10a1b2: 50 push %eax 10a1b3: 56 push %esi 10a1b4: ff 35 bc 10 12 00 pushl 0x1210bc 10a1ba: e8 45 32 00 00 call 10d404 <_Timespec_From_ticks> 10a1bf: 31 c0 xor %eax,%eax 10a1c1: 83 c4 10 add $0x10,%esp return 0; } 10a1c4: 8d 65 f8 lea -0x8(%ebp),%esp 10a1c7: 5b pop %ebx 10a1c8: 5e pop %esi 10a1c9: c9 leave 10a1ca: c3 ret =============================================================================== 00109008 : void seekdir( DIR *dirp, long loc ) { 109008: 55 push %ebp 109009: 89 e5 mov %esp,%ebp 10900b: 53 push %ebx 10900c: 83 ec 04 sub $0x4,%esp 10900f: 8b 5d 08 mov 0x8(%ebp),%ebx off_t status; if ( !dirp ) 109012: 85 db test %ebx,%ebx 109014: 74 1a je 109030 return; status = lseek( dirp->dd_fd, loc, SEEK_SET ); 109016: 50 push %eax 109017: 6a 00 push $0x0 109019: ff 75 0c pushl 0xc(%ebp) 10901c: ff 33 pushl (%ebx) 10901e: e8 b9 ed ff ff call 107ddc /* * This is not a nice way to error out, but we have no choice here. */ if ( status == -1 ) 109023: 83 c4 10 add $0x10,%esp 109026: 40 inc %eax 109027: 74 07 je 109030 <== NEVER TAKEN return; dirp->dd_loc = 0; 109029: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) } 109030: 8b 5d fc mov -0x4(%ebp),%ebx 109033: c9 leave 109034: c3 ret =============================================================================== 0010b5c4 : */ int sem_destroy( sem_t *sem ) { 10b5c4: 55 push %ebp 10b5c5: 89 e5 mov %esp,%ebp 10b5c7: 83 ec 1c sub $0x1c,%esp 10b5ca: 8d 45 fc lea -0x4(%ebp),%eax 10b5cd: 50 push %eax 10b5ce: 8b 45 08 mov 0x8(%ebp),%eax 10b5d1: ff 30 pushl (%eax) 10b5d3: 68 00 38 12 00 push $0x123800 10b5d8: e8 4b 1f 00 00 call 10d528 <_Objects_Get> register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 10b5dd: 83 c4 10 add $0x10,%esp 10b5e0: 83 7d fc 00 cmpl $0x0,-0x4(%ebp) 10b5e4: 75 22 jne 10b608 case OBJECTS_LOCAL: /* * Undefined operation on a named semaphore. */ if ( the_semaphore->named == TRUE ) { 10b5e6: 80 78 14 00 cmpb $0x0,0x14(%eax) 10b5ea: 74 07 je 10b5f3 <== ALWAYS TAKEN _Thread_Enable_dispatch(); 10b5ec: e8 f7 26 00 00 call 10dce8 <_Thread_Enable_dispatch><== NOT EXECUTED 10b5f1: eb 15 jmp 10b608 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); } _POSIX_Semaphore_Delete( the_semaphore ); 10b5f3: 83 ec 0c sub $0xc,%esp 10b5f6: 50 push %eax 10b5f7: e8 dc 55 00 00 call 110bd8 <_POSIX_Semaphore_Delete> _Thread_Enable_dispatch(); 10b5fc: e8 e7 26 00 00 call 10dce8 <_Thread_Enable_dispatch> 10b601: 31 c0 xor %eax,%eax 10b603: 83 c4 10 add $0x10,%esp 10b606: eb 0e jmp 10b616 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10b608: e8 57 70 00 00 call 112664 <__errno> 10b60d: c7 00 16 00 00 00 movl $0x16,(%eax) 10b613: 83 c8 ff or $0xffffffff,%eax } 10b616: c9 leave 10b617: c3 ret =============================================================================== 0010b65c : int sem_init( sem_t *sem, int pshared, unsigned int value ) { 10b65c: 55 push %ebp 10b65d: 89 e5 mov %esp,%ebp 10b65f: 53 push %ebx 10b660: 83 ec 14 sub $0x14,%esp 10b663: 8b 5d 08 mov 0x8(%ebp),%ebx int status; POSIX_Semaphore_Control *the_semaphore; if ( !sem ) 10b666: 85 db test %ebx,%ebx 10b668: 75 10 jne 10b67a <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10b66a: e8 f5 6f 00 00 call 112664 <__errno> <== NOT EXECUTED 10b66f: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b675: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 10b678: eb 23 jmp 10b69d <== NOT EXECUTED status = _POSIX_Semaphore_Create_support( 10b67a: 8d 45 f8 lea -0x8(%ebp),%eax 10b67d: 50 push %eax 10b67e: ff 75 10 pushl 0x10(%ebp) 10b681: ff 75 0c pushl 0xc(%ebp) 10b684: 6a 00 push $0x0 10b686: e8 55 54 00 00 call 110ae0 <_POSIX_Semaphore_Create_support> 10b68b: 89 c2 mov %eax,%edx pshared, value, &the_semaphore ); if ( status != -1 ) 10b68d: 83 c4 10 add $0x10,%esp 10b690: 83 f8 ff cmp $0xffffffff,%eax 10b693: 74 08 je 10b69d *sem = the_semaphore->Object.id; 10b695: 8b 45 f8 mov -0x8(%ebp),%eax 10b698: 8b 40 08 mov 0x8(%eax),%eax 10b69b: 89 03 mov %eax,(%ebx) return status; } 10b69d: 89 d0 mov %edx,%eax 10b69f: 8b 5d fc mov -0x4(%ebp),%ebx 10b6a2: c9 leave 10b6a3: c3 ret =============================================================================== 0010b6a4 : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 10b6a4: 55 push %ebp 10b6a5: 89 e5 mov %esp,%ebp 10b6a7: 57 push %edi 10b6a8: 56 push %esi 10b6a9: 53 push %ebx 10b6aa: 83 ec 1c sub $0x1c,%esp 10b6ad: 8b 75 0c mov 0xc(%ebp),%esi /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10b6b0: a1 10 35 12 00 mov 0x123510,%eax 10b6b5: 40 inc %eax 10b6b6: a3 10 35 12 00 mov %eax,0x123510 POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10b6bb: 89 f0 mov %esi,%eax 10b6bd: 25 00 02 00 00 and $0x200,%eax 10b6c2: 89 45 e0 mov %eax,-0x20(%ebp) 10b6c5: 75 04 jne 10b6cb 10b6c7: 31 ff xor %edi,%edi 10b6c9: eb 03 jmp 10b6ce va_start(arg, oflag); mode = (mode_t) va_arg( arg, unsigned int ); value = va_arg( arg, unsigned int ); 10b6cb: 8b 7d 14 mov 0x14(%ebp),%edi va_end(arg); } status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 10b6ce: 52 push %edx 10b6cf: 52 push %edx 10b6d0: 8d 45 f0 lea -0x10(%ebp),%eax 10b6d3: 50 push %eax 10b6d4: ff 75 08 pushl 0x8(%ebp) 10b6d7: e8 44 55 00 00 call 110c20 <_POSIX_Semaphore_Name_to_id> 10b6dc: 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 ) { 10b6de: 83 c4 10 add $0x10,%esp 10b6e1: 85 c0 test %eax,%eax 10b6e3: 74 19 je 10b6fe /* * 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) ) ) { 10b6e5: 83 f8 02 cmp $0x2,%eax 10b6e8: 75 06 jne 10b6f0 <== NEVER TAKEN 10b6ea: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) 10b6ee: 75 5e jne 10b74e _Thread_Enable_dispatch(); 10b6f0: e8 f3 25 00 00 call 10dce8 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 10b6f5: e8 6a 6f 00 00 call 112664 <__errno> 10b6fa: 89 18 mov %ebx,(%eax) 10b6fc: eb 1e jmp 10b71c /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10b6fe: 81 e6 00 0a 00 00 and $0xa00,%esi 10b704: 81 fe 00 0a 00 00 cmp $0xa00,%esi 10b70a: 75 15 jne 10b721 _Thread_Enable_dispatch(); 10b70c: e8 d7 25 00 00 call 10dce8 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 10b711: e8 4e 6f 00 00 call 112664 <__errno> 10b716: c7 00 11 00 00 00 movl $0x11,(%eax) 10b71c: 83 c8 ff or $0xffffffff,%eax 10b71f: eb 52 jmp 10b773 * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, 10b721: 50 push %eax 10b722: 8d 45 e8 lea -0x18(%ebp),%eax 10b725: 50 push %eax 10b726: ff 75 f0 pushl -0x10(%ebp) 10b729: 68 00 38 12 00 push $0x123800 10b72e: e8 f5 1d 00 00 call 10d528 <_Objects_Get> } the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); 10b733: 89 45 ec mov %eax,-0x14(%ebp) the_semaphore->open_count += 1; 10b736: ff 40 18 incl 0x18(%eax) _Thread_Enable_dispatch(); 10b739: e8 aa 25 00 00 call 10dce8 <_Thread_Enable_dispatch> _Thread_Enable_dispatch(); 10b73e: e8 a5 25 00 00 call 10dce8 <_Thread_Enable_dispatch> id = &the_semaphore->Object.id; return (sem_t *)id; 10b743: 8b 45 ec mov -0x14(%ebp),%eax 10b746: 83 c0 08 add $0x8,%eax 10b749: 83 c4 10 add $0x10,%esp 10b74c: eb 25 jmp 10b773 /* * 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( 10b74e: 8d 45 ec lea -0x14(%ebp),%eax 10b751: 50 push %eax 10b752: 57 push %edi 10b753: 6a 00 push $0x0 10b755: ff 75 08 pushl 0x8(%ebp) 10b758: e8 83 53 00 00 call 110ae0 <_POSIX_Semaphore_Create_support> 10b75d: 89 c3 mov %eax,%ebx /* * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); 10b75f: e8 84 25 00 00 call 10dce8 <_Thread_Enable_dispatch> if ( status == -1 ) 10b764: 83 c4 10 add $0x10,%esp 10b767: 83 c8 ff or $0xffffffff,%eax 10b76a: 43 inc %ebx 10b76b: 74 06 je 10b773 <== NEVER TAKEN return SEM_FAILED; id = &the_semaphore->Object.id; return (sem_t *)id; 10b76d: 8b 45 ec mov -0x14(%ebp),%eax 10b770: 83 c0 08 add $0x8,%eax } 10b773: 8d 65 f4 lea -0xc(%ebp),%esp 10b776: 5b pop %ebx 10b777: 5e pop %esi 10b778: 5f pop %edi 10b779: c9 leave 10b77a: c3 ret =============================================================================== 0010b80c : */ int sem_unlink( const char *name ) { 10b80c: 55 push %ebp 10b80d: 89 e5 mov %esp,%ebp 10b80f: 53 push %ebx 10b810: 83 ec 1c sub $0x1c,%esp /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10b813: a1 10 35 12 00 mov 0x123510,%eax 10b818: 40 inc %eax 10b819: a3 10 35 12 00 mov %eax,0x123510 register POSIX_Semaphore_Control *the_semaphore; sem_t the_semaphore_id; _Thread_Disable_dispatch(); status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 10b81e: 8d 45 f8 lea -0x8(%ebp),%eax 10b821: 50 push %eax 10b822: ff 75 08 pushl 0x8(%ebp) 10b825: e8 f6 53 00 00 call 110c20 <_POSIX_Semaphore_Name_to_id> 10b82a: 89 c3 mov %eax,%ebx if ( status != 0 ) { 10b82c: 83 c4 10 add $0x10,%esp 10b82f: 85 c0 test %eax,%eax 10b831: 74 11 je 10b844 _Thread_Enable_dispatch(); 10b833: e8 b0 24 00 00 call 10dce8 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( status ); 10b838: e8 27 6e 00 00 call 112664 <__errno> 10b83d: 89 18 mov %ebx,(%eax) 10b83f: 83 c8 ff or $0xffffffff,%eax 10b842: eb 3c jmp 10b880 } the_semaphore = (POSIX_Semaphore_Control *) _Objects_Get_local_object( 10b844: 8b 45 f8 mov -0x8(%ebp),%eax bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 10b847: 31 db xor %ebx,%ebx 10b849: 66 3b 05 10 38 12 00 cmp 0x123810,%ax 10b850: 77 0b ja 10b85d <== NEVER TAKEN * This heap routine returns information about the free blocks * in the specified heap. 10b852: 0f b7 d0 movzwl %ax,%edx 10b855: a1 1c 38 12 00 mov 0x12381c,%eax 10b85a: 8b 1c 90 mov (%eax,%edx,4),%ebx &_POSIX_Semaphore_Information, _Objects_Get_index( the_semaphore_id ) ); the_semaphore->linked = FALSE; 10b85d: c6 43 15 00 movb $0x0,0x15(%ebx) static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10b861: 50 push %eax 10b862: 50 push %eax 10b863: 53 push %ebx 10b864: 68 00 38 12 00 push $0x123800 10b869: e8 ce 1d 00 00 call 10d63c <_Objects_Namespace_remove> _POSIX_Semaphore_Namespace_remove( the_semaphore ); _POSIX_Semaphore_Delete( the_semaphore ); 10b86e: 89 1c 24 mov %ebx,(%esp) 10b871: e8 62 53 00 00 call 110bd8 <_POSIX_Semaphore_Delete> _Thread_Enable_dispatch(); 10b876: e8 6d 24 00 00 call 10dce8 <_Thread_Enable_dispatch> 10b87b: 31 c0 xor %eax,%eax 10b87d: 83 c4 10 add $0x10,%esp return 0; } 10b880: 8b 5d fc mov -0x4(%ebp),%ebx 10b883: c9 leave 10b884: c3 ret =============================================================================== 0010966c : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 10966c: 55 push %ebp 10966d: 89 e5 mov %esp,%ebp 10966f: 57 push %edi 109670: 56 push %esi 109671: 53 push %ebx 109672: 83 ec 0c sub $0xc,%esp 109675: 8b 5d 08 mov 0x8(%ebp),%ebx 109678: 8b 7d 10 mov 0x10(%ebp),%edi ISR_Level level; if ( oact ) 10967b: 85 ff test %edi,%edi 10967d: 74 10 je 10968f *oact = _POSIX_signals_Vectors[ sig ]; 10967f: 6b c3 0c imul $0xc,%ebx,%eax 109682: 8d b0 9c 06 12 00 lea 0x12069c(%eax),%esi 109688: b9 03 00 00 00 mov $0x3,%ecx 10968d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !sig ) 10968f: 85 db test %ebx,%ebx 109691: 74 0d je 1096a0 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 109693: 8d 4b ff lea -0x1(%ebx),%ecx 109696: 83 f9 1f cmp $0x1f,%ecx 109699: 77 05 ja 1096a0 * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 10969b: 83 fb 09 cmp $0x9,%ebx 10969e: 75 10 jne 1096b0 rtems_set_errno_and_return_minus_one( EINVAL ); 1096a0: e8 6b 68 00 00 call 10ff10 <__errno> 1096a5: c7 00 16 00 00 00 movl $0x16,(%eax) 1096ab: 83 c8 ff or $0xffffffff,%eax 1096ae: eb 5a jmp 10970a /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 1096b0: 31 c0 xor %eax,%eax 1096b2: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 1096b6: 74 52 je 10970a <== 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 ); 1096b8: 9c pushf 1096b9: fa cli 1096ba: 8f 45 f0 popl -0x10(%ebp) if ( act->sa_handler == SIG_DFL ) { 1096bd: 8b 45 0c mov 0xc(%ebp),%eax 1096c0: 83 78 08 00 cmpl $0x0,0x8(%eax) 1096c4: 75 18 jne 1096de _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; 1096c6: 6b c3 0c imul $0xc,%ebx,%eax 1096c9: 8d b8 9c 06 12 00 lea 0x12069c(%eax),%edi 1096cf: 8d b0 e0 9e 11 00 lea 0x119ee0(%eax),%esi 1096d5: b9 03 00 00 00 mov $0x3,%ecx 1096da: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 1096dc: eb 26 jmp 109704 } else { _POSIX_signals_Clear_process_signals( signo_to_mask(sig) ); 1096de: 83 ec 0c sub $0xc,%esp 1096e1: b8 01 00 00 00 mov $0x1,%eax 1096e6: d3 e0 shl %cl,%eax 1096e8: 50 push %eax 1096e9: e8 1a 4e 00 00 call 10e508 <_POSIX_signals_Clear_process_signals> _POSIX_signals_Vectors[ sig ] = *act; 1096ee: 6b c3 0c imul $0xc,%ebx,%eax 1096f1: 8d b8 9c 06 12 00 lea 0x12069c(%eax),%edi 1096f7: b9 03 00 00 00 mov $0x3,%ecx 1096fc: 8b 75 0c mov 0xc(%ebp),%esi 1096ff: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 109701: 83 c4 10 add $0x10,%esp } _ISR_Enable( level ); 109704: ff 75 f0 pushl -0x10(%ebp) 109707: 9d popf 109708: 31 c0 xor %eax,%eax * + If we are now ignoring a signal that was previously pending, * we clear the pending signal indicator. */ return 0; } 10970a: 8d 65 f4 lea -0xc(%ebp),%esp 10970d: 5b pop %ebx 10970e: 5e pop %esi 10970f: 5f pop %edi 109710: c9 leave 109711: c3 ret =============================================================================== 0010b250 : #include int sigsuspend( const sigset_t *sigmask ) { 10b250: 55 push %ebp 10b251: 89 e5 mov %esp,%ebp 10b253: 56 push %esi 10b254: 53 push %ebx 10b255: 83 ec 14 sub $0x14,%esp int status; POSIX_API_Control *api; api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; status = sigprocmask( SIG_BLOCK, sigmask, &saved_signals_blocked ); 10b258: 8d 5d f4 lea -0xc(%ebp),%ebx 10b25b: 53 push %ebx 10b25c: ff 75 08 pushl 0x8(%ebp) 10b25f: 6a 01 push $0x1 10b261: e8 c6 ff ff ff call 10b22c (void) sigfillset( &all_signals ); 10b266: 8d 75 f0 lea -0x10(%ebp),%esi 10b269: 89 34 24 mov %esi,(%esp) 10b26c: e8 13 ff ff ff call 10b184 status = sigtimedwait( &all_signals, NULL, NULL ); 10b271: 83 c4 0c add $0xc,%esp 10b274: 6a 00 push $0x0 10b276: 6a 00 push $0x0 10b278: 56 push %esi 10b279: e8 6b 00 00 00 call 10b2e9 10b27e: 89 c6 mov %eax,%esi (void) sigprocmask( SIG_SETMASK, &saved_signals_blocked, NULL ); 10b280: 83 c4 0c add $0xc,%esp 10b283: 6a 00 push $0x0 10b285: 53 push %ebx 10b286: 6a 00 push $0x0 10b288: e8 9f ff ff ff call 10b22c /* * sigtimedwait() returns the signal number while sigsuspend() * is supposed to return -1 and EINTR when a signal is caught. */ if ( status != -1 ) 10b28d: 83 c4 10 add $0x10,%esp 10b290: 46 inc %esi 10b291: 74 0b je 10b29e <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINTR ); 10b293: e8 78 6b 00 00 call 111e10 <__errno> 10b298: c7 00 04 00 00 00 movl $0x4,(%eax) return status; } 10b29e: 83 c8 ff or $0xffffffff,%eax 10b2a1: 8d 65 f8 lea -0x8(%ebp),%esp 10b2a4: 5b pop %ebx 10b2a5: 5e pop %esi 10b2a6: c9 leave 10b2a7: c3 ret =============================================================================== 00109a39 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 109a39: 55 push %ebp 109a3a: 89 e5 mov %esp,%ebp 109a3c: 57 push %edi 109a3d: 56 push %esi 109a3e: 53 push %ebx 109a3f: 83 ec 1c sub $0x1c,%esp 109a42: 8b 5d 10 mov 0x10(%ebp),%ebx * NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; if ( timeout ) { 109a45: 85 db test %ebx,%ebx 109a47: 74 35 je 109a7e if ( !_Timespec_Is_valid( timeout ) ) 109a49: 83 ec 0c sub $0xc,%esp 109a4c: 53 push %ebx 109a4d: e8 92 31 00 00 call 10cbe4 <_Timespec_Is_valid> 109a52: 83 c4 10 add $0x10,%esp 109a55: 84 c0 test %al,%al 109a57: 74 12 je 109a6b rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 109a59: 83 ec 0c sub $0xc,%esp 109a5c: 53 push %ebx 109a5d: e8 de 31 00 00 call 10cc40 <_Timespec_To_ticks> 109a62: 89 c3 mov %eax,%ebx if ( !interval ) 109a64: 83 c4 10 add $0x10,%esp 109a67: 85 c0 test %eax,%eax 109a69: 75 15 jne 109a80 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 109a6b: e8 10 6a 00 00 call 110480 <__errno> 109a70: c7 00 16 00 00 00 movl $0x16,(%eax) 109a76: 83 cb ff or $0xffffffff,%ebx 109a79: e9 05 01 00 00 jmp 109b83 109a7e: 31 db xor %ebx,%ebx /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 109a80: 8b 75 0c mov 0xc(%ebp),%esi 109a83: 85 f6 test %esi,%esi 109a85: 75 03 jne 109a8a 109a87: 8d 75 e8 lea -0x18(%ebp),%esi the_thread = _Thread_Executing; 109a8a: 8b 15 f8 07 12 00 mov 0x1207f8,%edx api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 109a90: 8b ba f8 00 00 00 mov 0xf8(%edx),%edi * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 109a96: 9c pushf 109a97: fa cli 109a98: 8f 45 e0 popl -0x20(%ebp) if ( *set & api->signals_pending ) { 109a9b: 8b 45 08 mov 0x8(%ebp),%eax 109a9e: 8b 08 mov (%eax),%ecx 109aa0: 8b 87 c8 00 00 00 mov 0xc8(%edi),%eax 109aa6: 85 c1 test %eax,%ecx 109aa8: 74 2c je 109ad6 /* XXX real info later */ the_info->si_signo = _POSIX_signals_Get_highest( api->signals_pending ); 109aaa: 50 push %eax 109aab: e8 48 ff ff ff call 1099f8 <_POSIX_signals_Get_highest> 109ab0: 89 06 mov %eax,(%esi) _POSIX_signals_Clear_signals( 109ab2: 51 push %ecx 109ab3: 51 push %ecx 109ab4: 6a 00 push $0x0 109ab6: 6a 00 push $0x0 109ab8: 56 push %esi 109ab9: 50 push %eax 109aba: 57 push %edi 109abb: e8 38 50 00 00 call 10eaf8 <_POSIX_signals_Clear_signals> the_info->si_signo, the_info, false, false ); _ISR_Enable( level ); 109ac0: ff 75 e0 pushl -0x20(%ebp) 109ac3: 9d popf the_info->si_code = SI_USER; 109ac4: c7 46 04 01 00 00 00 movl $0x1,0x4(%esi) the_info->si_value.sival_int = 0; 109acb: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) return the_info->si_signo; 109ad2: 8b 1e mov (%esi),%ebx 109ad4: eb 33 jmp 109b09 } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 109ad6: a1 a8 0e 12 00 mov 0x120ea8,%eax 109adb: 85 c1 test %eax,%ecx 109add: 74 2f je 109b0e signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); 109adf: 50 push %eax 109ae0: e8 13 ff ff ff call 1099f8 <_POSIX_signals_Get_highest> 109ae5: 89 c3 mov %eax,%ebx _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 109ae7: 52 push %edx 109ae8: 52 push %edx 109ae9: 6a 00 push $0x0 109aeb: 6a 01 push $0x1 109aed: 56 push %esi 109aee: 50 push %eax 109aef: 57 push %edi 109af0: e8 03 50 00 00 call 10eaf8 <_POSIX_signals_Clear_signals> _ISR_Enable( level ); 109af5: ff 75 e0 pushl -0x20(%ebp) 109af8: 9d popf the_info->si_signo = signo; 109af9: 89 1e mov %ebx,(%esi) the_info->si_code = SI_USER; 109afb: c7 46 04 01 00 00 00 movl $0x1,0x4(%esi) the_info->si_value.sival_int = 0; 109b02: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) 109b09: 83 c4 20 add $0x20,%esp 109b0c: eb 75 jmp 109b83 return signo; } the_info->si_signo = -1; 109b0e: c7 06 ff ff ff ff movl $0xffffffff,(%esi) /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109b14: a1 38 07 12 00 mov 0x120738,%eax 109b19: 40 inc %eax 109b1a: a3 38 07 12 00 mov %eax,0x120738 _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 109b1f: c7 42 44 68 0e 12 00 movl $0x120e68,0x44(%edx) the_thread->Wait.return_code = EINTR; 109b26: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx) the_thread->Wait.option = *set; 109b2d: 8b 4d 08 mov 0x8(%ebp),%ecx 109b30: 8b 01 mov (%ecx),%eax 109b32: 89 42 30 mov %eax,0x30(%edx) the_thread->Wait.return_argument = the_info; 109b35: 89 72 28 mov %esi,0x28(%edx) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 109b38: c7 05 98 0e 12 00 01 movl $0x1,0x120e98 109b3f: 00 00 00 _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue ); _ISR_Enable( level ); 109b42: ff 75 e0 pushl -0x20(%ebp) 109b45: 9d popf _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 109b46: 50 push %eax 109b47: 68 e0 c7 10 00 push $0x10c7e0 109b4c: 53 push %ebx 109b4d: 68 68 0e 12 00 push $0x120e68 109b52: e8 85 29 00 00 call 10c4dc <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 109b57: e8 30 25 00 00 call 10c08c <_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 ); 109b5c: c7 04 24 00 00 00 00 movl $0x0,(%esp) 109b63: 6a 00 push $0x0 109b65: 56 push %esi 109b66: ff 36 pushl (%esi) 109b68: 57 push %edi 109b69: e8 8a 4f 00 00 call 10eaf8 <_POSIX_signals_Clear_signals> errno = _Thread_Executing->Wait.return_code; 109b6e: 83 c4 20 add $0x20,%esp 109b71: e8 0a 69 00 00 call 110480 <__errno> 109b76: 8b 15 f8 07 12 00 mov 0x1207f8,%edx 109b7c: 8b 52 34 mov 0x34(%edx),%edx 109b7f: 89 10 mov %edx,(%eax) return the_info->si_signo; 109b81: 8b 1e mov (%esi),%ebx } 109b83: 89 d8 mov %ebx,%eax 109b85: 8d 65 f4 lea -0xc(%ebp),%esp 109b88: 5b pop %ebx 109b89: 5e pop %esi 109b8a: 5f pop %edi 109b8b: c9 leave 109b8c: c3 ret =============================================================================== 0010b458 : int sigwait( const sigset_t *set, int *sig ) { 10b458: 55 push %ebp 10b459: 89 e5 mov %esp,%ebp 10b45b: 53 push %ebx 10b45c: 83 ec 08 sub $0x8,%esp 10b45f: 8b 5d 0c mov 0xc(%ebp),%ebx int status; status = sigtimedwait( set, NULL, NULL ); 10b462: 6a 00 push $0x0 10b464: 6a 00 push $0x0 10b466: ff 75 08 pushl 0x8(%ebp) 10b469: e8 7b fe ff ff call 10b2e9 10b46e: 89 c2 mov %eax,%edx if ( status != -1 ) { 10b470: 83 c4 10 add $0x10,%esp 10b473: 83 f8 ff cmp $0xffffffff,%eax 10b476: 74 0c je 10b484 <== NEVER TAKEN if ( sig ) 10b478: 31 c0 xor %eax,%eax 10b47a: 85 db test %ebx,%ebx 10b47c: 74 0d je 10b48b <== NEVER TAKEN *sig = status; 10b47e: 89 13 mov %edx,(%ebx) 10b480: 31 c0 xor %eax,%eax 10b482: eb 07 jmp 10b48b return 0; } return errno; 10b484: e8 87 69 00 00 call 111e10 <__errno> <== NOT EXECUTED 10b489: 8b 00 mov (%eax),%eax <== NOT EXECUTED } 10b48b: 8b 5d fc mov -0x4(%ebp),%ebx 10b48e: c9 leave 10b48f: c3 ret =============================================================================== 00107b8b : /* * Process input character, with semaphore. */ static int siproc (unsigned char c, struct rtems_termios_tty *tty) { 107b8b: 55 push %ebp <== NOT EXECUTED 107b8c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107b8e: 56 push %esi <== NOT EXECUTED 107b8f: 53 push %ebx <== NOT EXECUTED 107b90: 89 d6 mov %edx,%esi <== NOT EXECUTED 107b92: 88 c3 mov %al,%bl <== NOT EXECUTED int i; /* * Obtain output semaphore if character will be echoed */ if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) { 107b94: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx) <== NOT EXECUTED 107b9b: 74 2e je 107bcb <== NOT EXECUTED rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 107b9d: 51 push %ecx <== NOT EXECUTED 107b9e: 6a 00 push $0x0 <== NOT EXECUTED 107ba0: 6a 00 push $0x0 <== NOT EXECUTED 107ba2: ff 72 18 pushl 0x18(%edx) <== NOT EXECUTED 107ba5: e8 ca 15 00 00 call 109174 <== NOT EXECUTED i = iproc (c, tty); 107baa: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 107bad: 89 f2 mov %esi,%edx <== NOT EXECUTED 107baf: e8 c8 fe ff ff call 107a7c <== NOT EXECUTED 107bb4: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_semaphore_release (tty->osem); 107bb6: 5a pop %edx <== NOT EXECUTED 107bb7: ff 76 18 pushl 0x18(%esi) <== NOT EXECUTED 107bba: e8 9d 16 00 00 call 10925c <== NOT EXECUTED 107bbf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { i = iproc (c, tty); } return i; } 107bc2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 107bc4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 107bc7: 5b pop %ebx <== NOT EXECUTED 107bc8: 5e pop %esi <== NOT EXECUTED 107bc9: c9 leave <== NOT EXECUTED 107bca: c3 ret <== 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); 107bcb: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED } return i; } 107bce: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 107bd1: 5b pop %ebx <== NOT EXECUTED 107bd2: 5e pop %esi <== NOT EXECUTED 107bd3: 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); 107bd4: e9 a3 fe ff ff jmp 107a7c <== NOT EXECUTED =============================================================================== 00108380 : int _STAT_NAME( const char *path, struct stat *buf ) { 108380: 55 push %ebp 108381: 89 e5 mov %esp,%ebp 108383: 57 push %edi 108384: 56 push %esi 108385: 53 push %ebx 108386: 83 ec 1c sub $0x1c,%esp /* * Check to see if we were passed a valid pointer. */ if ( !buf ) 108389: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 10838d: 75 0d jne 10839c rtems_set_errno_and_return_minus_one( EFAULT ); 10838f: e8 4c 8c 00 00 call 110fe0 <__errno> 108394: c7 00 0e 00 00 00 movl $0xe,(%eax) 10839a: eb 45 jmp 1083e1 status = rtems_filesystem_evaluate_path( path, 0, &loc, _STAT_FOLLOW_LINKS ); 10839c: 6a 01 push $0x1 10839e: 8d 75 e4 lea -0x1c(%ebp),%esi 1083a1: 56 push %esi 1083a2: 6a 00 push $0x0 1083a4: ff 75 08 pushl 0x8(%ebp) 1083a7: e8 e2 eb ff ff call 106f8e if ( status != 0 ) 1083ac: 83 c4 10 add $0x10,%esp 1083af: 83 cb ff or $0xffffffff,%ebx 1083b2: 85 c0 test %eax,%eax 1083b4: 75 5f jne 108415 return -1; if ( !loc.handlers->fstat_h ){ 1083b6: 8b 55 e8 mov -0x18(%ebp),%edx 1083b9: 83 7a 18 00 cmpl $0x0,0x18(%edx) 1083bd: 75 27 jne 1083e6 <== ALWAYS TAKEN rtems_filesystem_freenode( &loc ); 1083bf: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1083c2: 85 c0 test %eax,%eax <== NOT EXECUTED 1083c4: 74 10 je 1083d6 <== NOT EXECUTED 1083c6: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1083c9: 85 c0 test %eax,%eax <== NOT EXECUTED 1083cb: 74 09 je 1083d6 <== NOT EXECUTED 1083cd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1083d0: 56 push %esi <== NOT EXECUTED 1083d1: ff d0 call *%eax <== NOT EXECUTED 1083d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1083d6: e8 05 8c 00 00 call 110fe0 <__errno> <== NOT EXECUTED 1083db: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1083e1: 83 cb ff or $0xffffffff,%ebx 1083e4: eb 2f jmp 108415 /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( buf, 0, sizeof(struct stat) ); 1083e6: b9 13 00 00 00 mov $0x13,%ecx 1083eb: 8b 7d 0c mov 0xc(%ebp),%edi 1083ee: f3 ab rep stos %eax,%es:(%edi) status = (*loc.handlers->fstat_h)( &loc, buf ); 1083f0: 50 push %eax 1083f1: 50 push %eax 1083f2: ff 75 0c pushl 0xc(%ebp) 1083f5: 56 push %esi 1083f6: ff 52 18 call *0x18(%edx) 1083f9: 89 c3 mov %eax,%ebx rtems_filesystem_freenode( &loc ); 1083fb: 8b 45 ec mov -0x14(%ebp),%eax 1083fe: 83 c4 10 add $0x10,%esp 108401: 85 c0 test %eax,%eax 108403: 74 10 je 108415 <== NEVER TAKEN 108405: 8b 40 1c mov 0x1c(%eax),%eax 108408: 85 c0 test %eax,%eax 10840a: 74 09 je 108415 <== NEVER TAKEN 10840c: 83 ec 0c sub $0xc,%esp 10840f: 56 push %esi 108410: ff d0 call *%eax 108412: 83 c4 10 add $0x10,%esp return status; } 108415: 89 d8 mov %ebx,%eax 108417: 8d 65 f4 lea -0xc(%ebp),%esp 10841a: 5b pop %ebx 10841b: 5e pop %esi 10841c: 5f pop %edi 10841d: c9 leave 10841e: c3 ret =============================================================================== 00108a54 : int symlink( const char *actualpath, const char *sympath ) { 108a54: 55 push %ebp 108a55: 89 e5 mov %esp,%ebp 108a57: 57 push %edi 108a58: 56 push %esi 108a59: 53 push %ebx 108a5a: 83 ec 2c sub $0x2c,%esp 108a5d: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_filesystem_location_info_t loc; int i; const char *name_start; int result; rtems_filesystem_get_start_loc( sympath, &i, &loc ); 108a60: 8a 03 mov (%ebx),%al 108a62: 3c 2f cmp $0x2f,%al 108a64: 74 08 je 108a6e 108a66: 3c 5c cmp $0x5c,%al 108a68: 74 04 je 108a6e <== NEVER TAKEN 108a6a: 84 c0 test %al,%al 108a6c: 75 19 jne 108a87 <== ALWAYS TAKEN 108a6e: 8d 7d e0 lea -0x20(%ebp),%edi 108a71: a1 4c 09 12 00 mov 0x12094c,%eax 108a76: 8d 70 14 lea 0x14(%eax),%esi 108a79: b9 04 00 00 00 mov $0x4,%ecx 108a7e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 108a80: ba 01 00 00 00 mov $0x1,%edx 108a85: eb 14 jmp 108a9b 108a87: 8d 7d e0 lea -0x20(%ebp),%edi 108a8a: a1 4c 09 12 00 mov 0x12094c,%eax 108a8f: 8d 70 04 lea 0x4(%eax),%esi 108a92: b9 04 00 00 00 mov $0x4,%ecx 108a97: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 108a99: 31 d2 xor %edx,%edx result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start ); 108a9b: 51 push %ecx 108a9c: 8d 45 f0 lea -0x10(%ebp),%eax 108a9f: 50 push %eax 108aa0: 8d 7d e0 lea -0x20(%ebp),%edi 108aa3: 57 push %edi 108aa4: 8d 04 13 lea (%ebx,%edx,1),%eax 108aa7: 50 push %eax 108aa8: 8b 45 e8 mov -0x18(%ebp),%eax 108aab: ff 50 04 call *0x4(%eax) if ( result != 0 ) 108aae: 83 c4 10 add $0x10,%esp 108ab1: 83 ce ff or $0xffffffff,%esi 108ab4: 85 c0 test %eax,%eax 108ab6: 75 50 jne 108b08 return -1; if ( !loc.ops->symlink_h ) { 108ab8: 8b 45 e8 mov -0x18(%ebp),%eax 108abb: 8b 50 38 mov 0x38(%eax),%edx 108abe: 85 d2 test %edx,%edx 108ac0: 75 20 jne 108ae2 <== ALWAYS TAKEN rtems_filesystem_freenode( &loc ); 108ac2: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 108ac5: 85 c0 test %eax,%eax <== NOT EXECUTED 108ac7: 74 09 je 108ad2 <== NOT EXECUTED 108ac9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108acc: 57 push %edi <== NOT EXECUTED 108acd: ff d0 call *%eax <== NOT EXECUTED 108acf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 108ad2: e8 d9 8a 00 00 call 1115b0 <__errno> <== NOT EXECUTED 108ad7: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 108add: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 108ae0: eb 26 jmp 108b08 <== NOT EXECUTED } result = (*loc.ops->symlink_h)( &loc, actualpath, name_start); 108ae2: 50 push %eax 108ae3: ff 75 f0 pushl -0x10(%ebp) 108ae6: ff 75 08 pushl 0x8(%ebp) 108ae9: 57 push %edi 108aea: ff d2 call *%edx 108aec: 89 c6 mov %eax,%esi rtems_filesystem_freenode( &loc ); 108aee: 8b 45 e8 mov -0x18(%ebp),%eax 108af1: 83 c4 10 add $0x10,%esp 108af4: 85 c0 test %eax,%eax 108af6: 74 10 je 108b08 <== NEVER TAKEN 108af8: 8b 40 1c mov 0x1c(%eax),%eax 108afb: 85 c0 test %eax,%eax 108afd: 74 09 je 108b08 <== NEVER TAKEN 108aff: 83 ec 0c sub $0xc,%esp 108b02: 57 push %edi 108b03: ff d0 call *%eax 108b05: 83 c4 10 add $0x10,%esp return result; } 108b08: 89 f0 mov %esi,%eax 108b0a: 8d 65 f4 lea -0xc(%ebp),%esp 108b0d: 5b pop %ebx 108b0e: 5e pop %esi 108b0f: 5f pop %edi 108b10: c9 leave 108b11: c3 ret =============================================================================== 00108434 : fdatasync(fn); } /* iterate over all FILE *'s for this thread */ static void sync_per_thread(Thread_Control *t) { 108434: 55 push %ebp 108435: 89 e5 mov %esp,%ebp 108437: 53 push %ebx 108438: 83 ec 04 sub $0x4,%esp 10843b: 8b 4d 08 mov 0x8(%ebp),%ecx /* * The sync_wrapper() function will operate on the current thread's * reent structure so we will temporarily use that. */ this_reent = t->libc_reent; 10843e: 8b 91 f0 00 00 00 mov 0xf0(%ecx),%edx if ( this_reent ) { 108444: 85 d2 test %edx,%edx 108446: 74 31 je 108479 <== NEVER TAKEN current_reent = _Thread_Executing->libc_reent; 108448: a1 88 15 12 00 mov 0x121588,%eax 10844d: 8b 98 f0 00 00 00 mov 0xf0(%eax),%ebx _Thread_Executing->libc_reent = this_reent; 108453: 89 90 f0 00 00 00 mov %edx,0xf0(%eax) _fwalk (t->libc_reent, sync_wrapper); 108459: 50 push %eax 10845a: 50 push %eax 10845b: 68 a4 84 10 00 push $0x1084a4 108460: ff b1 f0 00 00 00 pushl 0xf0(%ecx) 108466: e8 dd 97 00 00 call 111c48 <_fwalk> _Thread_Executing->libc_reent = current_reent; 10846b: a1 88 15 12 00 mov 0x121588,%eax 108470: 89 98 f0 00 00 00 mov %ebx,0xf0(%eax) 108476: 83 c4 10 add $0x10,%esp } } 108479: 8b 5d fc mov -0x4(%ebp),%ebx 10847c: c9 leave 10847d: c3 ret =============================================================================== 001090ec : #include long telldir( DIR *dirp ) { 1090ec: 55 push %ebp 1090ed: 89 e5 mov %esp,%ebp 1090ef: 83 ec 08 sub $0x8,%esp 1090f2: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_t *iop; if ( !dirp ) 1090f5: 85 c0 test %eax,%eax 1090f7: 75 10 jne 109109 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EBADF ); 1090f9: e8 e2 8c 00 00 call 111de0 <__errno> <== NOT EXECUTED 1090fe: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 109104: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 109107: eb 2e jmp 109137 <== NOT EXECUTED /* * Get the file control block structure associated with the * file descriptor */ iop = rtems_libio_iop( dirp->dd_fd ); 109109: 8b 00 mov (%eax),%eax 10910b: 3b 05 18 e2 11 00 cmp 0x11e218,%eax 109111: 73 0b jae 10911e <== NEVER TAKEN 109113: 6b c0 34 imul $0x34,%eax,%eax if (iop == NULL) 109116: 03 05 18 26 12 00 add 0x122618,%eax 10911c: 75 16 jne 109134 <== ALWAYS TAKEN assert(0); 10911e: 68 a7 b6 11 00 push $0x11b6a7 <== NOT EXECUTED 109123: 68 a8 be 11 00 push $0x11bea8 <== NOT EXECUTED 109128: 6a 2c push $0x2c <== NOT EXECUTED 10912a: 68 5b be 11 00 push $0x11be5b <== NOT EXECUTED 10912f: e8 00 e4 ff ff call 107534 <__assert_func> <== NOT EXECUTED return (long)( iop->offset ); 109134: 8b 40 08 mov 0x8(%eax),%eax } 109137: c9 leave 109138: c3 ret =============================================================================== 00107078 : #include int termios_baud_to_number( int termios_baud ) { 107078: 55 push %ebp <== NOT EXECUTED 107079: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10707b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED case B110: baud = 110; break; case B134: baud = 135; break; case B150: baud = 150; break; case B200: baud = 200; break; case B300: baud = 300; break; case B600: baud = 600; break; 10707e: b8 b0 04 00 00 mov $0x4b0,%eax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107083: 83 fa 09 cmp $0x9,%edx <== NOT EXECUTED 107086: 0f 84 d6 00 00 00 je 107162 <== NOT EXECUTED 10708c: 7f 65 jg 1070f3 <== NOT EXECUTED case B0: baud = 0; break; case B50: baud = 50; break; case B75: baud = 75; break; case B110: baud = 110; break; 10708e: 66 b8 87 00 mov $0x87,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107092: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 107095: 0f 84 c7 00 00 00 je 107162 <== NOT EXECUTED 10709b: 7f 2e jg 1070cb <== NOT EXECUTED 10709d: b0 32 mov $0x32,%al <== NOT EXECUTED 10709f: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 1070a2: 0f 84 ba 00 00 00 je 107162 <== NOT EXECUTED 1070a8: 7f 09 jg 1070b3 <== NOT EXECUTED 1070aa: 30 c0 xor %al,%al <== NOT EXECUTED 1070ac: 85 d2 test %edx,%edx <== NOT EXECUTED 1070ae: e9 aa 00 00 00 jmp 10715d <== NOT EXECUTED 1070b3: b8 4b 00 00 00 mov $0x4b,%eax <== NOT EXECUTED 1070b8: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 1070bb: 0f 84 a1 00 00 00 je 107162 <== NOT EXECUTED case B0: baud = 0; break; case B50: baud = 50; break; case B75: baud = 75; break; 1070c1: b0 6e mov $0x6e,%al <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 1070c3: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 1070c6: e9 92 00 00 00 jmp 10715d <== NOT EXECUTED case B0: baud = 0; break; case B50: baud = 50; break; case B75: baud = 75; break; case B110: baud = 110; break; case B134: baud = 135; break; case B150: baud = 150; break; 1070cb: b8 c8 00 00 00 mov $0xc8,%eax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 1070d0: 83 fa 06 cmp $0x6,%edx <== NOT EXECUTED 1070d3: 0f 84 89 00 00 00 je 107162 <== NOT EXECUTED case B0: baud = 0; break; case B50: baud = 50; break; case B75: baud = 75; break; case B110: baud = 110; break; case B134: baud = 135; break; 1070d9: b0 96 mov $0x96,%al <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 1070db: 0f 8c 81 00 00 00 jl 107162 <== NOT EXECUTED case B50: baud = 50; break; case B75: baud = 75; break; case B110: baud = 110; break; case B134: baud = 135; break; case B150: baud = 150; break; case B200: baud = 200; break; 1070e1: 66 b8 2c 01 mov $0x12c,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 1070e5: 83 fa 07 cmp $0x7,%edx <== NOT EXECUTED 1070e8: 74 78 je 107162 <== NOT EXECUTED case B75: baud = 75; break; case B110: baud = 110; break; case B134: baud = 135; break; case B150: baud = 150; break; case B200: baud = 200; break; case B300: baud = 300; break; 1070ea: 66 b8 58 02 mov $0x258,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 1070ee: 83 fa 08 cmp $0x8,%edx <== NOT EXECUTED 1070f1: eb 6a jmp 10715d <== NOT EXECUTED case B600: baud = 600; break; case B1200: baud = 1200; break; case B1800: baud = 1800; break; case B2400: baud = 2400; break; case B4800: baud = 4800; break; case B9600: baud = 9600; break; 1070f3: b8 00 4b 00 00 mov $0x4b00,%eax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 1070f8: 83 fa 0e cmp $0xe,%edx <== NOT EXECUTED 1070fb: 74 65 je 107162 <== NOT EXECUTED 1070fd: 7f 21 jg 107120 <== NOT EXECUTED case B150: baud = 150; break; case B200: baud = 200; break; case B300: baud = 300; break; case B600: baud = 600; break; case B1200: baud = 1200; break; case B1800: baud = 1800; break; 1070ff: 66 b8 60 09 mov $0x960,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107103: 83 fa 0b cmp $0xb,%edx <== NOT EXECUTED 107106: 74 5a je 107162 <== NOT EXECUTED case B134: baud = 135; break; case B150: baud = 150; break; case B200: baud = 200; break; case B300: baud = 300; break; case B600: baud = 600; break; case B1200: baud = 1200; break; 107108: 66 b8 08 07 mov $0x708,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 10710c: 7c 54 jl 107162 <== NOT EXECUTED case B200: baud = 200; break; case B300: baud = 300; break; case B600: baud = 600; break; case B1200: baud = 1200; break; case B1800: baud = 1800; break; case B2400: baud = 2400; break; 10710e: 66 b8 c0 12 mov $0x12c0,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107112: 83 fa 0c cmp $0xc,%edx <== NOT EXECUTED 107115: 74 4b je 107162 <== NOT EXECUTED case B300: baud = 300; break; case B600: baud = 600; break; case B1200: baud = 1200; break; case B1800: baud = 1800; break; case B2400: baud = 2400; break; case B4800: baud = 4800; break; 107117: 66 b8 80 25 mov $0x2580,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 10711b: 83 fa 0d cmp $0xd,%edx <== NOT EXECUTED 10711e: eb 3d jmp 10715d <== NOT EXECUTED case B2400: baud = 2400; break; case B4800: baud = 4800; break; case B9600: baud = 9600; break; case B19200: baud = 19200; break; case B38400: baud = 38400; break; case B57600: baud = 57600; break; 107120: b8 00 c2 01 00 mov $0x1c200,%eax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107125: 81 fa 02 10 00 00 cmp $0x1002,%edx <== NOT EXECUTED 10712b: 74 35 je 107162 <== NOT EXECUTED 10712d: 7f 16 jg 107145 <== NOT EXECUTED case B1200: baud = 1200; break; case B1800: baud = 1800; break; case B2400: baud = 2400; break; case B4800: baud = 4800; break; case B9600: baud = 9600; break; case B19200: baud = 19200; break; 10712f: b8 00 96 00 00 mov $0x9600,%eax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107134: 83 fa 0f cmp $0xf,%edx <== NOT EXECUTED 107137: 74 29 je 107162 <== NOT EXECUTED case B1800: baud = 1800; break; case B2400: baud = 2400; break; case B4800: baud = 4800; break; case B9600: baud = 9600; break; case B19200: baud = 19200; break; case B38400: baud = 38400; break; 107139: 66 b8 00 e1 mov $0xe100,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 10713d: 81 fa 01 10 00 00 cmp $0x1001,%edx <== NOT EXECUTED 107143: eb 18 jmp 10715d <== NOT EXECUTED case B4800: baud = 4800; break; case B9600: baud = 9600; break; case B19200: baud = 19200; break; case B38400: baud = 38400; break; case B57600: baud = 57600; break; case B115200: baud = 115200; break; 107145: b8 00 84 03 00 mov $0x38400,%eax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 10714a: 81 fa 03 10 00 00 cmp $0x1003,%edx <== NOT EXECUTED 107150: 74 10 je 107162 <== NOT EXECUTED case B9600: baud = 9600; break; case B19200: baud = 19200; break; case B38400: baud = 38400; break; case B57600: baud = 57600; break; case B115200: baud = 115200; break; case B230400: baud = 230400; break; 107152: b8 00 08 07 00 mov $0x70800,%eax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107157: 81 fa 04 10 00 00 cmp $0x1004,%edx <== NOT EXECUTED 10715d: 74 03 je 107162 <== NOT EXECUTED case B19200: baud = 19200; break; case B38400: baud = 38400; break; case B57600: baud = 57600; break; case B115200: baud = 115200; break; case B230400: baud = 230400; break; case B460800: baud = 460800; break; 10715f: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED default: baud = -1; break; } return baud; } 107162: c9 leave <== NOT EXECUTED 107163: c3 ret <== NOT EXECUTED =============================================================================== 0010d50c : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 10d50c: 55 push %ebp 10d50d: 89 e5 mov %esp,%ebp 10d50f: 57 push %edi 10d510: 56 push %esi 10d511: 53 push %ebx 10d512: 83 ec 0c sub $0xc,%esp 10d515: 8b 75 0c mov 0xc(%ebp),%esi 10d518: 8b 7d 10 mov 0x10(%ebp),%edi POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 10d51b: 83 7d 08 01 cmpl $0x1,0x8(%ebp) 10d51f: 75 1d jne 10d53e rtems_set_errno_and_return_minus_one( EINVAL ); if ( !timerid ) 10d521: 85 ff test %edi,%edi 10d523: 74 19 je 10d53e /* * The data of the structure evp are checked in order to verify if they * are coherent. */ if (evp != NULL) { 10d525: 85 f6 test %esi,%esi 10d527: 74 22 je 10d54b /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 10d529: 8b 06 mov (%esi),%eax 10d52b: 48 dec %eax 10d52c: 83 f8 01 cmp $0x1,%eax 10d52f: 77 0d ja 10d53e <== 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 ) 10d531: 8b 46 04 mov 0x4(%esi),%eax 10d534: 85 c0 test %eax,%eax 10d536: 74 06 je 10d53e <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 10d538: 48 dec %eax 10d539: 83 f8 1f cmp $0x1f,%eax 10d53c: 76 0d jbe 10d54b <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); 10d53e: e8 c9 6e 00 00 call 11440c <__errno> 10d543: c7 00 16 00 00 00 movl $0x16,(%eax) 10d549: eb 31 jmp 10d57c /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10d54b: a1 58 63 12 00 mov 0x126358,%eax 10d550: 40 inc %eax 10d551: a3 58 63 12 00 mov %eax,0x126358 #ifdef __cplusplus extern "C" { #endif /** * This routine initializes @a the_heap record to manage the 10d556: 83 ec 0c sub $0xc,%esp 10d559: 68 88 66 12 00 push $0x126688 10d55e: e8 81 1b 00 00 call 10f0e4 <_Objects_Allocate> 10d563: 89 c3 mov %eax,%ebx /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 10d565: 83 c4 10 add $0x10,%esp 10d568: 85 c0 test %eax,%eax 10d56a: 75 18 jne 10d584 _Thread_Enable_dispatch(); 10d56c: e8 c3 27 00 00 call 10fd34 <_Thread_Enable_dispatch> rtems_set_errno_and_return_minus_one( EAGAIN ); 10d571: e8 96 6e 00 00 call 11440c <__errno> 10d576: c7 00 0b 00 00 00 movl $0xb,(%eax) 10d57c: 83 c8 ff or $0xffffffff,%eax 10d57f: e9 81 00 00 00 jmp 10d605 } /* The data of the created timer are stored to use them later */ ptimer->state = POSIX_TIMER_STATE_CREATE_NEW; 10d584: c6 40 3c 02 movb $0x2,0x3c(%eax) ptimer->thread_id = _Thread_Executing->Object.id; 10d588: a1 18 64 12 00 mov 0x126418,%eax 10d58d: 8b 40 08 mov 0x8(%eax),%eax 10d590: 89 43 38 mov %eax,0x38(%ebx) if ( evp != NULL ) { 10d593: 85 f6 test %esi,%esi 10d595: 74 11 je 10d5a8 ptimer->inf.sigev_notify = evp->sigev_notify; 10d597: 8b 06 mov (%esi),%eax 10d599: 89 43 40 mov %eax,0x40(%ebx) ptimer->inf.sigev_signo = evp->sigev_signo; 10d59c: 8b 46 04 mov 0x4(%esi),%eax 10d59f: 89 43 44 mov %eax,0x44(%ebx) ptimer->inf.sigev_value = evp->sigev_value; 10d5a2: 8b 46 08 mov 0x8(%esi),%eax 10d5a5: 89 43 48 mov %eax,0x48(%ebx) } ptimer->overrun = 0; 10d5a8: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) ptimer->timer_data.it_value.tv_sec = 0; 10d5af: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) ptimer->timer_data.it_value.tv_nsec = 0; 10d5b6: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) ptimer->timer_data.it_interval.tv_sec = 0; 10d5bd: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) ptimer->timer_data.it_interval.tv_nsec = 0; 10d5c4: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10d5cb: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) * @param[in] the_heap is the heap to operate upon 10d5d2: c7 43 2c 00 00 00 00 movl $0x0,0x2c(%ebx) * @param[in] starting_address is the starting address of the memory for 10d5d9: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx) * the heap 10d5e0: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) 10d5e7: 8b 4b 08 mov 0x8(%ebx),%ecx 10d5ea: 0f b7 d1 movzwl %cx,%edx 10d5ed: a1 a4 66 12 00 mov 0x1266a4,%eax 10d5f2: 89 1c 90 mov %ebx,(%eax,%edx,4) 10d5f5: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) _Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL ); _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0); *timerid = ptimer->Object.id; 10d5fc: 89 0f mov %ecx,(%edi) _Thread_Enable_dispatch(); 10d5fe: e8 31 27 00 00 call 10fd34 <_Thread_Enable_dispatch> 10d603: 31 c0 xor %eax,%eax return 0; } 10d605: 8d 65 f4 lea -0xc(%ebp),%esp 10d608: 5b pop %ebx 10d609: 5e pop %esi 10d60a: 5f pop %edi 10d60b: c9 leave 10d60c: c3 ret =============================================================================== 0010a198 : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 10a198: 55 push %ebp 10a199: 89 e5 mov %esp,%ebp 10a19b: 57 push %edi 10a19c: 56 push %esi 10a19d: 53 push %ebx 10a19e: 83 ec 2c sub $0x2c,%esp 10a1a1: 8b 55 0c mov 0xc(%ebp),%edx Objects_Locations location; bool activated; uint32_t initial_period; struct itimerspec normalize; if ( !value ) 10a1a4: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10a1a8: 0f 84 4c 01 00 00 je 10a2fa <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EINVAL ); /* First, it verifies if the structure "value" is correct */ if ( ( value->it_value.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) || 10a1ae: 8b 45 10 mov 0x10(%ebp),%eax 10a1b1: 81 78 0c ff c9 9a 3b cmpl $0x3b9ac9ff,0xc(%eax) 10a1b8: 0f 87 3c 01 00 00 ja 10a2fa 10a1be: 8b 40 04 mov 0x4(%eax),%eax 10a1c1: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax 10a1c6: 0f 87 2e 01 00 00 ja 10a2fa <== NEVER TAKEN 10a1cc: 85 c0 test %eax,%eax 10a1ce: 0f 88 26 01 00 00 js 10a2fa <== NEVER TAKEN ( value->it_interval.tv_nsec < 0 )) { /* The number of nanoseconds is not correct */ rtems_set_errno_and_return_minus_one( EINVAL ); } if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 10a1d4: 83 fa 04 cmp $0x4,%edx 10a1d7: 74 08 je 10a1e1 10a1d9: 85 d2 test %edx,%edx 10a1db: 0f 85 19 01 00 00 jne 10a2fa rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 10a1e1: 8d 7d e0 lea -0x20(%ebp),%edi 10a1e4: b9 04 00 00 00 mov $0x4,%ecx 10a1e9: 8b 75 10 mov 0x10(%ebp),%esi 10a1ec: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { 10a1ee: 83 fa 04 cmp $0x4,%edx 10a1f1: 75 2b jne 10a21e /* Check for seconds in the past */ if ( _Timespec_Greater_than( &_TOD_Now, &normalize.it_value ) ) 10a1f3: 51 push %ecx 10a1f4: 51 push %ecx 10a1f5: 8d 5d e8 lea -0x18(%ebp),%ebx 10a1f8: 53 push %ebx 10a1f9: 68 e0 1a 12 00 push $0x121ae0 10a1fe: e8 4d 31 00 00 call 10d350 <_Timespec_Greater_than> 10a203: 83 c4 10 add $0x10,%esp 10a206: 84 c0 test %al,%al 10a208: 0f 85 ec 00 00 00 jne 10a2fa rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_Subtract( &_TOD_Now, &normalize.it_value, &normalize.it_value ); 10a20e: 52 push %edx 10a20f: 53 push %ebx 10a210: 53 push %ebx 10a211: 68 e0 1a 12 00 push $0x121ae0 10a216: e8 5d 31 00 00 call 10d378 <_Timespec_Subtract> 10a21b: 83 c4 10 add $0x10,%esp 10a21e: 50 push %eax 10a21f: 8d 45 f0 lea -0x10(%ebp),%eax 10a222: 50 push %eax 10a223: ff 75 08 pushl 0x8(%ebp) 10a226: 68 80 1d 12 00 push $0x121d80 10a22b: e8 dc 1d 00 00 call 10c00c <_Objects_Get> 10a230: 89 c3 mov %eax,%ebx * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 10a232: 83 c4 10 add $0x10,%esp 10a235: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) 10a239: 0f 85 bb 00 00 00 jne 10a2fa <== NEVER TAKEN 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 ) { 10a23f: 83 7d e8 00 cmpl $0x0,-0x18(%ebp) 10a243: 75 3b jne 10a280 10a245: 83 7d ec 00 cmpl $0x0,-0x14(%ebp) 10a249: 75 35 jne 10a280 <== NEVER TAKEN /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 10a24b: 83 ec 0c sub $0xc,%esp 10a24e: 8d 40 10 lea 0x10(%eax),%eax 10a251: 50 push %eax 10a252: e8 0d 35 00 00 call 10d764 <_Watchdog_Remove> /* The old data of the timer are returned */ if ( ovalue ) 10a257: 83 c4 10 add $0x10,%esp 10a25a: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10a25e: 74 0d je 10a26d <== ALWAYS TAKEN *ovalue = ptimer->timer_data; 10a260: 8d 73 54 lea 0x54(%ebx),%esi <== NOT EXECUTED 10a263: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10a268: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 10a26b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* The new data are set */ ptimer->timer_data = normalize; 10a26d: 8d 7b 54 lea 0x54(%ebx),%edi 10a270: 8d 75 e0 lea -0x20(%ebp),%esi 10a273: b9 04 00 00 00 mov $0x4,%ecx 10a278: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a27a: c6 43 3c 04 movb $0x4,0x3c(%ebx) 10a27e: eb 35 jmp 10a2b5 _Thread_Enable_dispatch(); return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); 10a280: 83 ec 0c sub $0xc,%esp 10a283: ff 75 10 pushl 0x10(%ebp) 10a286: e8 25 31 00 00 call 10d3b0 <_Timespec_To_ticks> 10a28b: 89 43 64 mov %eax,0x64(%ebx) initial_period = _Timespec_To_ticks( &normalize.it_value ); 10a28e: 8d 45 e8 lea -0x18(%ebp),%eax 10a291: 89 04 24 mov %eax,(%esp) 10a294: e8 17 31 00 00 call 10d3b0 <_Timespec_To_ticks> activated = _POSIX_Timer_Insert_helper( 10a299: 89 1c 24 mov %ebx,(%esp) 10a29c: 68 10 a3 10 00 push $0x10a310 10a2a1: ff 73 08 pushl 0x8(%ebx) 10a2a4: 50 push %eax 10a2a5: 8d 43 10 lea 0x10(%ebx),%eax 10a2a8: 50 push %eax 10a2a9: e8 5a 52 00 00 call 10f508 <_POSIX_Timer_Insert_helper> initial_period, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 10a2ae: 83 c4 20 add $0x20,%esp 10a2b1: 84 c0 test %al,%al 10a2b3: 75 09 jne 10a2be <== ALWAYS TAKEN _Thread_Enable_dispatch(); 10a2b5: e8 12 25 00 00 call 10c7cc <_Thread_Enable_dispatch> 10a2ba: 31 c0 xor %eax,%eax 10a2bc: eb 4a jmp 10a308 /* * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) 10a2be: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 10a2c2: 74 0d je 10a2d1 *ovalue = ptimer->timer_data; 10a2c4: 8d 73 54 lea 0x54(%ebx),%esi 10a2c7: b9 04 00 00 00 mov $0x4,%ecx 10a2cc: 8b 7d 14 mov 0x14(%ebp),%edi 10a2cf: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ptimer->timer_data = normalize; 10a2d1: 8d 7b 54 lea 0x54(%ebx),%edi 10a2d4: 8d 75 e0 lea -0x20(%ebp),%esi 10a2d7: b9 04 00 00 00 mov $0x4,%ecx 10a2dc: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a2de: c6 43 3c 03 movb $0x3,0x3c(%ebx) _TOD_Get( &ptimer->time ); 10a2e2: 83 ec 0c sub $0xc,%esp 10a2e5: 8d 43 6c lea 0x6c(%ebx),%eax 10a2e8: 50 push %eax 10a2e9: e8 8e 15 00 00 call 10b87c <_TOD_Get> _Thread_Enable_dispatch(); 10a2ee: e8 d9 24 00 00 call 10c7cc <_Thread_Enable_dispatch> 10a2f3: 31 c0 xor %eax,%eax 10a2f5: 83 c4 10 add $0x10,%esp 10a2f8: eb 0e jmp 10a308 #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10a2fa: e8 71 69 00 00 call 110c70 <__errno> 10a2ff: c7 00 16 00 00 00 movl $0x16,(%eax) 10a305: 83 c8 ff or $0xffffffff,%eax } 10a308: 8d 65 f4 lea -0xc(%ebp),%esp 10a30b: 5b pop %ebx 10a30c: 5e pop %esi 10a30d: 5f pop %edi 10a30e: c9 leave 10a30f: c3 ret =============================================================================== 00108da8 : useconds_t ualarm( useconds_t useconds, useconds_t interval ) { 108da8: 55 push %ebp 108da9: 89 e5 mov %esp,%ebp 108dab: 56 push %esi 108dac: 53 push %ebx 108dad: 83 ec 20 sub $0x20,%esp /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 108db0: 83 3d ec fe 11 00 00 cmpl $0x0,0x11feec 108db7: 75 2c jne 108de5 * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 108db9: c7 05 d8 fe 11 00 00 movl $0x0,0x11fed8 108dc0: 00 00 00 * @param[in] the_heap is the heap to operate upon 108dc3: c7 05 ec fe 11 00 88 movl $0x108e88,0x11feec 108dca: 8e 10 00 * @param[in] starting_address is the starting address of the memory for 108dcd: c7 05 f0 fe 11 00 00 movl $0x0,0x11fef0 108dd4: 00 00 00 * the heap 108dd7: c7 05 f4 fe 11 00 00 movl $0x0,0x11fef4 108dde: 00 00 00 108de1: 31 f6 xor %esi,%esi 108de3: eb 4f jmp 108e34 _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { switch ( _Watchdog_Remove( the_timer ) ) { 108de5: 83 ec 0c sub $0xc,%esp 108de8: 68 d0 fe 11 00 push $0x11fed0 108ded: e8 16 35 00 00 call 10c308 <_Watchdog_Remove> 108df2: 83 c4 10 add $0x10,%esp 108df5: 83 e8 02 sub $0x2,%eax 108df8: 31 f6 xor %esi,%esi 108dfa: 83 f8 01 cmp $0x1,%eax 108dfd: 77 35 ja 108e34 <== 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); 108dff: a1 e4 fe 11 00 mov 0x11fee4,%eax 108e04: 03 05 dc fe 11 00 add 0x11fedc,%eax /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 108e0a: 51 push %ecx 108e0b: 51 push %ecx 108e0c: 8d 55 f0 lea -0x10(%ebp),%edx 108e0f: 52 push %edx 108e10: 2b 05 e8 fe 11 00 sub 0x11fee8,%eax 108e16: 50 push %eax 108e17: e8 a4 30 00 00 call 10bec0 <_Timespec_From_ticks> remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 108e1c: 69 4d f0 40 42 0f 00 imul $0xf4240,-0x10(%ebp),%ecx remaining += tp.tv_nsec / 1000; 108e23: 8b 45 f4 mov -0xc(%ebp),%eax 108e26: bb e8 03 00 00 mov $0x3e8,%ebx 108e2b: 99 cltd 108e2c: f7 fb idiv %ebx 108e2e: 8d 34 08 lea (%eax,%ecx,1),%esi 108e31: 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 ) { 108e34: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 108e38: 74 45 je 108e7f Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 108e3a: b9 40 42 0f 00 mov $0xf4240,%ecx 108e3f: 8b 45 08 mov 0x8(%ebp),%eax 108e42: 31 d2 xor %edx,%edx 108e44: f7 f1 div %ecx 108e46: 89 45 f0 mov %eax,-0x10(%ebp) tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 108e49: 69 d2 e8 03 00 00 imul $0x3e8,%edx,%edx 108e4f: 89 55 f4 mov %edx,-0xc(%ebp) ticks = _Timespec_To_ticks( &tp ); 108e52: 83 ec 0c sub $0xc,%esp 108e55: 8d 5d f0 lea -0x10(%ebp),%ebx 108e58: 53 push %ebx 108e59: e8 c6 30 00 00 call 10bf24 <_Timespec_To_ticks> if ( ticks == 0 ) ticks = 1; _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) ); 108e5e: 89 1c 24 mov %ebx,(%esp) 108e61: e8 be 30 00 00 call 10bf24 <_Timespec_To_ticks> * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 108e66: a3 dc fe 11 00 mov %eax,0x11fedc void *starting_address, size_t *size 108e6b: 58 pop %eax 108e6c: 5a pop %edx 108e6d: 68 d0 fe 11 00 push $0x11fed0 108e72: 68 90 00 12 00 push $0x120090 108e77: e8 74 33 00 00 call 10c1f0 <_Watchdog_Insert> 108e7c: 83 c4 10 add $0x10,%esp } return remaining; } 108e7f: 89 f0 mov %esi,%eax 108e81: 8d 65 f8 lea -0x8(%ebp),%esp 108e84: 5b pop %ebx 108e85: 5e pop %esi 108e86: c9 leave 108e87: c3 ret =============================================================================== 0010b110 : #include int unlink( const char *path ) { 10b110: 55 push %ebp 10b111: 89 e5 mov %esp,%ebp 10b113: 56 push %esi 10b114: 53 push %ebx 10b115: 83 ec 10 sub $0x10,%esp /* * Get the node to be unlinked. */ result = rtems_filesystem_evaluate_path( path, 0, &loc, false ); 10b118: 6a 00 push $0x0 10b11a: 8d 5d e8 lea -0x18(%ebp),%ebx 10b11d: 53 push %ebx 10b11e: 6a 00 push $0x0 10b120: ff 75 08 pushl 0x8(%ebp) 10b123: e8 56 d1 ff ff call 10827e if ( result != 0 ) 10b128: 83 c4 10 add $0x10,%esp 10b12b: 85 c0 test %eax,%eax 10b12d: 0f 85 d9 00 00 00 jne 10b20c return -1; result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc ); 10b133: 50 push %eax 10b134: 50 push %eax 10b135: 53 push %ebx 10b136: 6a 02 push $0x2 10b138: e8 cb d0 ff ff call 108208 if (result != 0 && errno != ENOTSUP) { 10b13d: 83 c4 10 add $0x10,%esp 10b140: 85 c0 test %eax,%eax 10b142: 74 31 je 10b175 <== ALWAYS TAKEN 10b144: e8 af 71 00 00 call 1122f8 <__errno> <== NOT EXECUTED 10b149: 81 38 86 00 00 00 cmpl $0x86,(%eax) <== NOT EXECUTED 10b14f: 74 24 je 10b175 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 10b151: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10b154: 85 c0 test %eax,%eax <== NOT EXECUTED 10b156: 0f 84 b0 00 00 00 je 10b20c <== NOT EXECUTED 10b15c: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10b15f: 85 c0 test %eax,%eax <== NOT EXECUTED 10b161: 0f 84 a5 00 00 00 je 10b20c <== NOT EXECUTED 10b167: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b16a: 53 push %ebx <== NOT EXECUTED 10b16b: ff d0 call *%eax <== NOT EXECUTED 10b16d: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 10b170: e9 92 00 00 00 jmp 10b207 <== NOT EXECUTED return -1; } if ( !loc.ops->node_type_h ) { 10b175: 8b 45 f0 mov -0x10(%ebp),%eax 10b178: 8b 50 10 mov 0x10(%eax),%edx 10b17b: 85 d2 test %edx,%edx 10b17d: 75 12 jne 10b191 <== ALWAYS TAKEN rtems_filesystem_freenode( &loc ); 10b17f: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 10b182: 85 d2 test %edx,%edx <== NOT EXECUTED 10b184: 74 55 je 10b1db <== NOT EXECUTED 10b186: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b189: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10b18c: 50 push %eax <== NOT EXECUTED 10b18d: ff d2 call *%edx <== NOT EXECUTED 10b18f: eb 47 jmp 10b1d8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) { 10b191: 83 ec 0c sub $0xc,%esp 10b194: 8d 75 e8 lea -0x18(%ebp),%esi 10b197: 56 push %esi 10b198: ff d2 call *%edx 10b19a: 83 c4 10 add $0x10,%esp 10b19d: 48 dec %eax 10b19e: 8b 45 f0 mov -0x10(%ebp),%eax 10b1a1: 75 21 jne 10b1c4 rtems_filesystem_freenode( &loc ); 10b1a3: 85 c0 test %eax,%eax 10b1a5: 74 10 je 10b1b7 <== NEVER TAKEN 10b1a7: 8b 40 1c mov 0x1c(%eax),%eax 10b1aa: 85 c0 test %eax,%eax 10b1ac: 74 09 je 10b1b7 <== NEVER TAKEN 10b1ae: 83 ec 0c sub $0xc,%esp 10b1b1: 56 push %esi 10b1b2: ff d0 call *%eax 10b1b4: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EISDIR ); 10b1b7: e8 3c 71 00 00 call 1122f8 <__errno> 10b1bc: c7 00 15 00 00 00 movl $0x15,(%eax) 10b1c2: eb 48 jmp 10b20c } if ( !loc.ops->unlink_h ) { 10b1c4: 8b 50 0c mov 0xc(%eax),%edx 10b1c7: 85 d2 test %edx,%edx 10b1c9: 75 1d jne 10b1e8 <== ALWAYS TAKEN rtems_filesystem_freenode( &loc ); 10b1cb: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10b1ce: 85 c0 test %eax,%eax <== NOT EXECUTED 10b1d0: 74 09 je 10b1db <== NOT EXECUTED 10b1d2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b1d5: 56 push %esi <== NOT EXECUTED 10b1d6: ff d0 call *%eax <== NOT EXECUTED 10b1d8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 10b1db: e8 18 71 00 00 call 1122f8 <__errno> <== NOT EXECUTED 10b1e0: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10b1e6: eb 24 jmp 10b20c <== NOT EXECUTED } result = (*loc.ops->unlink_h)( &loc ); 10b1e8: 83 ec 0c sub $0xc,%esp 10b1eb: 56 push %esi 10b1ec: ff d2 call *%edx 10b1ee: 89 c3 mov %eax,%ebx rtems_filesystem_freenode( &loc ); 10b1f0: 8b 45 f0 mov -0x10(%ebp),%eax 10b1f3: 83 c4 10 add $0x10,%esp 10b1f6: 85 c0 test %eax,%eax 10b1f8: 74 15 je 10b20f <== NEVER TAKEN 10b1fa: 8b 40 1c mov 0x1c(%eax),%eax 10b1fd: 85 c0 test %eax,%eax 10b1ff: 74 0e je 10b20f <== NEVER TAKEN 10b201: 83 ec 0c sub $0xc,%esp 10b204: 56 push %esi 10b205: ff d0 call *%eax 10b207: 83 c4 10 add $0x10,%esp 10b20a: eb 03 jmp 10b20f 10b20c: 83 cb ff or $0xffffffff,%ebx return result; } 10b20f: 89 d8 mov %ebx,%eax 10b211: 8d 65 f8 lea -0x8(%ebp),%esp 10b214: 5b pop %ebx 10b215: 5e pop %esi 10b216: c9 leave 10b217: c3 ret =============================================================================== 0010a45a : */ int unmount( const char *path ) { 10a45a: 55 push %ebp 10a45b: 89 e5 mov %esp,%ebp 10a45d: 56 push %esi 10a45e: 53 push %ebx 10a45f: 83 ec 10 sub $0x10,%esp * 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, 0x0, &loc, true ) ) 10a462: 6a 01 push $0x1 10a464: 8d 75 e8 lea -0x18(%ebp),%esi 10a467: 56 push %esi 10a468: 6a 00 push $0x0 10a46a: ff 75 08 pushl 0x8(%ebp) 10a46d: e8 c0 d0 ff ff call 107532 10a472: 83 c4 10 add $0x10,%esp 10a475: 85 c0 test %eax,%eax 10a477: 0f 85 11 01 00 00 jne 10a58e return -1; mt_entry = loc.mt_entry; 10a47d: 8b 5d f4 mov -0xc(%ebp),%ebx /* * Verify this is the root node for the file system to be unmounted. */ if ( !rtems_filesystem_nodes_equal( fs_root_loc, &loc) ){ 10a480: 8b 43 18 mov 0x18(%ebx),%eax 10a483: 3b 45 e8 cmp -0x18(%ebp),%eax 10a486: 8b 45 f0 mov -0x10(%ebp),%eax 10a489: 74 24 je 10a4af rtems_filesystem_freenode( &loc ); 10a48b: 85 c0 test %eax,%eax 10a48d: 74 10 je 10a49f <== NEVER TAKEN 10a48f: 8b 40 1c mov 0x1c(%eax),%eax 10a492: 85 c0 test %eax,%eax 10a494: 74 09 je 10a49f <== NEVER TAKEN 10a496: 83 ec 0c sub $0xc,%esp 10a499: 56 push %esi 10a49a: ff d0 call *%eax 10a49c: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EACCES ); 10a49f: e8 0c 71 00 00 call 1115b0 <__errno> 10a4a4: c7 00 0d 00 00 00 movl $0xd,(%eax) 10a4aa: e9 df 00 00 00 jmp 10a58e /* * Free the loc node and just use the nodes from the mt_entry . */ rtems_filesystem_freenode( &loc ); 10a4af: 85 c0 test %eax,%eax 10a4b1: 74 10 je 10a4c3 <== NEVER TAKEN 10a4b3: 8b 40 1c mov 0x1c(%eax),%eax 10a4b6: 85 c0 test %eax,%eax 10a4b8: 74 09 je 10a4c3 <== NEVER TAKEN 10a4ba: 83 ec 0c sub $0xc,%esp 10a4bd: 56 push %esi 10a4be: ff d0 call *%eax 10a4c0: 83 c4 10 add $0x10,%esp /* * Verify Unmount is supported by both filesystems. */ if ( !fs_mount_loc->ops->unmount_h ) 10a4c3: 8b 43 10 mov 0x10(%ebx),%eax 10a4c6: 83 78 28 00 cmpl $0x0,0x28(%eax) 10a4ca: 74 09 je 10a4d5 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( !fs_root_loc->ops->fsunmount_me_h ) 10a4cc: 8b 43 20 mov 0x20(%ebx),%eax 10a4cf: 83 78 2c 00 cmpl $0x0,0x2c(%eax) 10a4d3: 75 10 jne 10a4e5 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); 10a4d5: e8 d6 70 00 00 call 1115b0 <__errno> <== NOT EXECUTED 10a4da: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10a4e0: e9 a9 00 00 00 jmp 10a58e <== NOT EXECUTED * 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 ) 10a4e5: a1 4c 09 12 00 mov 0x12094c,%eax 10a4ea: 39 58 10 cmp %ebx,0x10(%eax) 10a4ed: 74 1f je 10a50e /* * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; 10a4ef: 8b 15 94 29 12 00 mov 0x122994,%edx 10a4f5: eb 0a jmp 10a501 !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); the_node = the_node->next ) { the_mount_entry = ( rtems_filesystem_mount_table_entry_t * )the_node; if (the_mount_entry->mt_point_node.mt_entry == fs_root_loc->mt_entry ) { 10a4f7: 8b 42 14 mov 0x14(%edx),%eax 10a4fa: 3b 43 24 cmp 0x24(%ebx),%eax 10a4fd: 74 0f je 10a50e * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); the_node = the_node->next ) { 10a4ff: 8b 12 mov (%edx),%edx * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); 10a501: 81 fa 98 29 12 00 cmp $0x122998,%edx 10a507: 75 ee jne 10a4f7 10a509: e9 8a 00 00 00 jmp 10a598 * descriptors that are currently active and reference nodes in the * file system that we are trying to unmount */ if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 ) rtems_set_errno_and_return_minus_one( EBUSY ); 10a50e: e8 9d 70 00 00 call 1115b0 <__errno> 10a513: c7 00 10 00 00 00 movl $0x10,(%eax) 10a519: eb 73 jmp 10a58e * 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 ) 10a51b: 83 ec 0c sub $0xc,%esp 10a51e: 8b 43 10 mov 0x10(%ebx),%eax 10a521: 53 push %ebx 10a522: ff 50 28 call *0x28(%eax) 10a525: 83 c4 10 add $0x10,%esp 10a528: 85 c0 test %eax,%eax 10a52a: 75 62 jne 10a58e <== 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){ 10a52c: 83 ec 0c sub $0xc,%esp 10a52f: 8b 43 20 mov 0x20(%ebx),%eax 10a532: 53 push %ebx 10a533: ff 50 2c call *0x2c(%eax) 10a536: 83 c4 10 add $0x10,%esp 10a539: 85 c0 test %eax,%eax 10a53b: 74 1b je 10a558 <== ALWAYS TAKEN if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 ) 10a53d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a540: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10a543: 53 push %ebx <== NOT EXECUTED 10a544: ff 50 20 call *0x20(%eax) <== NOT EXECUTED 10a547: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a54a: 85 c0 test %eax,%eax <== NOT EXECUTED 10a54c: 74 40 je 10a58e <== NOT EXECUTED rtems_fatal_error_occurred( 0 ); 10a54e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a551: 6a 00 push $0x0 <== NOT EXECUTED 10a553: e8 24 0e 00 00 call 10b37c <== NOT EXECUTED 10a558: 83 ec 0c sub $0xc,%esp 10a55b: 53 push %ebx 10a55c: e8 97 11 00 00 call 10b6f8 <_Chain_Extract> /* * 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 ); 10a561: 8b 43 10 mov 0x10(%ebx),%eax 10a564: 83 c4 10 add $0x10,%esp 10a567: 85 c0 test %eax,%eax 10a569: 74 13 je 10a57e <== NEVER TAKEN 10a56b: 8b 50 1c mov 0x1c(%eax),%edx 10a56e: 85 d2 test %edx,%edx 10a570: 74 0c je 10a57e <== NEVER TAKEN 10a572: 83 ec 0c sub $0xc,%esp 10a575: 8d 43 08 lea 0x8(%ebx),%eax 10a578: 50 push %eax 10a579: ff d2 call *%edx 10a57b: 83 c4 10 add $0x10,%esp free( mt_entry ); 10a57e: 83 ec 0c sub $0xc,%esp 10a581: 53 push %ebx 10a582: e8 cd d0 ff ff call 107654 10a587: 31 c0 xor %eax,%eax 10a589: 83 c4 10 add $0x10,%esp 10a58c: eb 03 jmp 10a591 return 0; 10a58e: 83 c8 ff or $0xffffffff,%eax } 10a591: 8d 65 f8 lea -0x8(%ebp),%esp 10a594: 5b pop %ebx 10a595: 5e pop %esi 10a596: c9 leave 10a597: c3 ret * 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 ) 10a598: 83 ec 0c sub $0xc,%esp 10a59b: 53 push %ebx 10a59c: e8 bf d2 ff ff call 107860 10a5a1: 83 c4 10 add $0x10,%esp 10a5a4: 48 dec %eax 10a5a5: 0f 85 70 ff ff ff jne 10a51b 10a5ab: e9 5e ff ff ff jmp 10a50e =============================================================================== 00109dec : int utime( const char *path, const struct utimbuf *times ) { 109dec: 55 push %ebp 109ded: 89 e5 mov %esp,%ebp 109def: 57 push %edi 109df0: 56 push %esi 109df1: 53 push %ebx 109df2: 83 ec 1c sub $0x1c,%esp 109df5: 8b 7d 0c mov 0xc(%ebp),%edi rtems_filesystem_location_info_t temp_loc; int result; if ( rtems_filesystem_evaluate_path( path, 0x00, &temp_loc, true ) ) 109df8: 6a 01 push $0x1 109dfa: 8d 75 e4 lea -0x1c(%ebp),%esi 109dfd: 56 push %esi 109dfe: 6a 00 push $0x0 109e00: ff 75 08 pushl 0x8(%ebp) 109e03: e8 86 d1 ff ff call 106f8e 109e08: 83 c4 10 add $0x10,%esp 109e0b: 83 cb ff or $0xffffffff,%ebx 109e0e: 85 c0 test %eax,%eax 109e10: 75 4f jne 109e61 return -1; if ( !temp_loc.ops->utime_h ){ 109e12: 8b 45 ec mov -0x14(%ebp),%eax 109e15: 8b 50 30 mov 0x30(%eax),%edx 109e18: 85 d2 test %edx,%edx 109e1a: 75 20 jne 109e3c <== ALWAYS TAKEN rtems_filesystem_freenode( &temp_loc ); 109e1c: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 109e1f: 85 c0 test %eax,%eax <== NOT EXECUTED 109e21: 74 09 je 109e2c <== NOT EXECUTED 109e23: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109e26: 56 push %esi <== NOT EXECUTED 109e27: ff d0 call *%eax <== NOT EXECUTED 109e29: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 109e2c: e8 af 71 00 00 call 110fe0 <__errno> <== NOT EXECUTED 109e31: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 109e37: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 109e3a: eb 25 jmp 109e61 <== NOT EXECUTED } result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime ); 109e3c: 50 push %eax 109e3d: ff 77 04 pushl 0x4(%edi) 109e40: ff 37 pushl (%edi) 109e42: 56 push %esi 109e43: ff d2 call *%edx 109e45: 89 c3 mov %eax,%ebx rtems_filesystem_freenode( &temp_loc ); 109e47: 8b 45 ec mov -0x14(%ebp),%eax 109e4a: 83 c4 10 add $0x10,%esp 109e4d: 85 c0 test %eax,%eax 109e4f: 74 10 je 109e61 <== NEVER TAKEN 109e51: 8b 40 1c mov 0x1c(%eax),%eax 109e54: 85 c0 test %eax,%eax 109e56: 74 09 je 109e61 <== NEVER TAKEN 109e58: 83 ec 0c sub $0xc,%esp 109e5b: 56 push %esi 109e5c: ff d0 call *%eax 109e5e: 83 c4 10 add $0x10,%esp return result; } 109e61: 89 d8 mov %ebx,%eax 109e63: 8d 65 f4 lea -0xc(%ebp),%esp 109e66: 5b pop %ebx 109e67: 5e pop %esi 109e68: 5f pop %edi 109e69: c9 leave 109e6a: c3 ret =============================================================================== 00106dc4 : */ void vprintk( const char *fmt, va_list ap ) { 106dc4: 55 push %ebp 106dc5: 89 e5 mov %esp,%ebp 106dc7: 57 push %edi 106dc8: 56 push %esi 106dc9: 53 push %ebx 106dca: 83 ec 4c sub $0x4c,%esp 106dcd: 8b 7d 08 mov 0x8(%ebp),%edi 106dd0: e9 6d 02 00 00 jmp 107042 base = 0; sign = 0; width = 0; minus = 0; lead = ' '; if (*fmt == '%') { 106dd5: 3c 25 cmp $0x25,%al 106dd7: 0f 85 54 02 00 00 jne 107031 fmt++; 106ddd: 47 inc %edi if (*fmt == '0' ) { 106dde: c7 45 c8 20 00 00 00 movl $0x20,-0x38(%ebp) 106de5: 80 3f 30 cmpb $0x30,(%edi) 106de8: 75 08 jne 106df2 lead = '0'; fmt++; 106dea: 47 inc %edi 106deb: c7 45 c8 30 00 00 00 movl $0x30,-0x38(%ebp) } if (*fmt == '-' ) { 106df2: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) 106df9: 80 3f 2d cmpb $0x2d,(%edi) 106dfc: 75 08 jne 106e06 minus = 1; fmt++; 106dfe: 47 inc %edi 106dff: c7 45 cc 01 00 00 00 movl $0x1,-0x34(%ebp) 106e06: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) 106e0d: eb 0f jmp 106e1e } while (*fmt >= '0' && *fmt <= '9' ) { width *= 10; 106e0f: 6b 55 c4 0a imul $0xa,-0x3c(%ebp),%edx width += (*fmt - '0'); 106e13: 0f be c1 movsbl %cl,%eax 106e16: 8d 44 02 d0 lea -0x30(%edx,%eax,1),%eax 106e1a: 89 45 c4 mov %eax,-0x3c(%ebp) fmt++; 106e1d: 47 inc %edi } if (*fmt == '-' ) { minus = 1; fmt++; } while (*fmt >= '0' && *fmt <= '9' ) { 106e1e: 8a 0f mov (%edi),%cl 106e20: 8d 41 d0 lea -0x30(%ecx),%eax 106e23: 3c 09 cmp $0x9,%al 106e25: 76 e8 jbe 106e0f width *= 10; width += (*fmt - '0'); fmt++; } if ((c = *fmt) == 'l') { 106e27: 31 d2 xor %edx,%edx 106e29: 80 f9 6c cmp $0x6c,%cl 106e2c: 75 08 jne 106e36 lflag = 1; c = *++fmt; 106e2e: 47 inc %edi 106e2f: 8a 0f mov (%edi),%cl 106e31: ba 01 00 00 00 mov $0x1,%edx } switch (c) { 106e36: 80 f9 64 cmp $0x64,%cl 106e39: 74 71 je 106eac 106e3b: 7f 38 jg 106e75 106e3d: 80 f9 4f cmp $0x4f,%cl 106e40: 0f 84 32 01 00 00 je 106f78 <== NEVER TAKEN 106e46: 7f 10 jg 106e58 <== NEVER TAKEN 106e48: 80 f9 44 cmp $0x44,%cl 106e4b: 74 5f je 106eac <== NEVER TAKEN 106e4d: 80 f9 49 cmp $0x49,%cl 106e50: 0f 85 17 01 00 00 jne 106f6d <== ALWAYS TAKEN 106e56: eb 54 jmp 106eac <== NOT EXECUTED 106e58: 80 f9 58 cmp $0x58,%cl <== NOT EXECUTED 106e5b: 0f 84 20 01 00 00 je 106f81 <== NOT EXECUTED 106e61: 80 f9 63 cmp $0x63,%cl <== NOT EXECUTED 106e64: 0f 84 e5 00 00 00 je 106f4f <== NOT EXECUTED 106e6a: 80 f9 55 cmp $0x55,%cl <== NOT EXECUTED 106e6d: 0f 85 fa 00 00 00 jne 106f6d <== NOT EXECUTED 106e73: eb 3e jmp 106eb3 <== NOT EXECUTED 106e75: 80 f9 70 cmp $0x70,%cl 106e78: 0f 84 03 01 00 00 je 106f81 106e7e: 7f 13 jg 106e93 <== ALWAYS TAKEN 106e80: 80 f9 69 cmp $0x69,%cl <== NOT EXECUTED 106e83: 74 27 je 106eac <== NOT EXECUTED 106e85: 80 f9 6f cmp $0x6f,%cl <== NOT EXECUTED 106e88: 0f 85 df 00 00 00 jne 106f6d <== NOT EXECUTED 106e8e: e9 e5 00 00 00 jmp 106f78 <== NOT EXECUTED 106e93: 80 f9 75 cmp $0x75,%cl 106e96: 74 1b je 106eb3 106e98: 80 f9 78 cmp $0x78,%cl 106e9b: 0f 84 e0 00 00 00 je 106f81 106ea1: 80 f9 73 cmp $0x73,%cl 106ea4: 0f 85 c3 00 00 00 jne 106f6d <== NEVER TAKEN 106eaa: eb 13 jmp 106ebf 106eac: b8 01 00 00 00 mov $0x1,%eax 106eb1: eb 02 jmp 106eb5 106eb3: 31 c0 xor %eax,%eax 106eb5: be 0a 00 00 00 mov $0xa,%esi 106eba: e9 c9 00 00 00 jmp 106f88 case 'p': base = 16; sign = 0; break; case 's': { int i, len; char *s; str = va_arg(ap, char *); 106ebf: 8b 45 0c mov 0xc(%ebp),%eax 106ec2: 83 c0 04 add $0x4,%eax 106ec5: 89 45 d0 mov %eax,-0x30(%ebp) 106ec8: 8b 55 0c mov 0xc(%ebp),%edx 106ecb: 8b 12 mov (%edx),%edx 106ecd: 89 55 c0 mov %edx,-0x40(%ebp) 106ed0: 31 f6 xor %esi,%esi 106ed2: eb 01 jmp 106ed5 /* calculate length of string */ for ( len=0, s=str ; *s ; len++, s++ ) 106ed4: 46 inc %esi 106ed5: 8b 4d c0 mov -0x40(%ebp),%ecx 106ed8: 80 3c 31 00 cmpb $0x0,(%ecx,%esi,1) 106edc: 75 f6 jne 106ed4 ; /* leading spaces */ if ( !minus ) 106ede: 89 f3 mov %esi,%ebx 106ee0: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 106ee4: 74 11 je 106ef7 106ee6: eb 14 jmp 106efc for ( i=len ; i <== NEVER TAKEN BSP_output_char(' '); /* no width option */ if (width == 0) { 106efc: 83 7d c4 00 cmpl $0x0,-0x3c(%ebp) 106f00: 75 03 jne 106f05 106f02: 89 75 c4 mov %esi,-0x3c(%ebp) width = len; } /* output the string */ for ( i=0 ; i <== NEVER TAKEN 106f0b: eb 13 jmp 106f20 BSP_output_char(*str); 106f0d: 83 ec 0c sub $0xc,%esp 106f10: 0f be c0 movsbl %al,%eax 106f13: 50 push %eax 106f14: ff 15 fc 93 11 00 call *0x1193fc if (width == 0) { width = len; } /* output the string */ for ( i=0 ; i BSP_output_char(*str); /* trailing spaces */ if ( minus ) 106f29: 89 f3 mov %esi,%ebx 106f2b: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 106f2f: 75 14 jne 106f45 106f31: e9 18 01 00 00 jmp 10704e for ( i=len ; i 106f4a: e9 ff 00 00 00 jmp 10704e BSP_output_char(' '); } break; case 'c': BSP_output_char(va_arg(ap, int)); 106f4f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 106f52: 83 c3 04 add $0x4,%ebx <== NOT EXECUTED 106f55: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106f58: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 106f5b: 0f be 01 movsbl (%ecx),%eax <== NOT EXECUTED 106f5e: 50 push %eax <== NOT EXECUTED 106f5f: ff 15 fc 93 11 00 call *0x1193fc <== NOT EXECUTED 106f65: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 106f68: e9 d1 00 00 00 jmp 10703e <== NOT EXECUTED break; default: BSP_output_char(c); 106f6d: 83 ec 0c sub $0xc,%esp 106f70: 0f be c1 movsbl %cl,%eax 106f73: e9 bf 00 00 00 jmp 107037 106f78: 31 c0 xor %eax,%eax 106f7a: be 08 00 00 00 mov $0x8,%esi <== NOT EXECUTED 106f7f: eb 07 jmp 106f88 <== NOT EXECUTED 106f81: 31 c0 xor %eax,%eax 106f83: be 10 00 00 00 mov $0x10,%esi break; } /* switch*/ if (base) printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int), 106f88: 85 d2 test %edx,%edx 106f8a: 8b 4d 0c mov 0xc(%ebp),%ecx 106f8d: 8d 51 04 lea 0x4(%ecx),%edx 106f90: 75 03 jne 106f95 106f92: 8b 4d 0c mov 0xc(%ebp),%ecx 106f95: 8b 19 mov (%ecx),%ebx 106f97: 89 55 0c mov %edx,0xc(%ebp) { long unsigned int n; int count; char toPrint[20]; if ( (sign == 1) && ((long)num < 0) ) { 106f9a: 48 dec %eax 106f9b: 75 1c jne 106fb9 106f9d: 85 db test %ebx,%ebx 106f9f: 79 18 jns 106fb9 <== ALWAYS TAKEN BSP_output_char('-'); 106fa1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106fa4: 6a 2d push $0x2d <== NOT EXECUTED 106fa6: ff 15 fc 93 11 00 call *0x1193fc <== NOT EXECUTED num = -num; 106fac: f7 db neg %ebx <== NOT EXECUTED if (maxwidth) maxwidth--; 106fae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106fb1: 83 7d c4 01 cmpl $0x1,-0x3c(%ebp) <== NOT EXECUTED 106fb5: 83 55 c4 ff adcl $0xffffffff,-0x3c(%ebp) <== NOT EXECUTED 106fb9: 31 c9 xor %ecx,%ecx 106fbb: eb 12 jmp 106fcf } count = 0; while ((n = num / base) > 0) { toPrint[count++] = (num - (n*base)); 106fbd: 8b 45 b4 mov -0x4c(%ebp),%eax 106fc0: 0f af c6 imul %esi,%eax 106fc3: 28 c3 sub %al,%bl 106fc5: 88 5c 0d e0 mov %bl,-0x20(%ebp,%ecx,1) 106fc9: 8b 4d b8 mov -0x48(%ebp),%ecx 106fcc: 8b 5d b4 mov -0x4c(%ebp),%ebx num = -num; if (maxwidth) maxwidth--; } count = 0; while ((n = num / base) > 0) { 106fcf: 89 d8 mov %ebx,%eax 106fd1: 31 d2 xor %edx,%edx 106fd3: f7 f6 div %esi 106fd5: 89 45 b4 mov %eax,-0x4c(%ebp) 106fd8: 85 c0 test %eax,%eax 106fda: 8d 41 01 lea 0x1(%ecx),%eax 106fdd: 89 45 b8 mov %eax,-0x48(%ebp) 106fe0: 75 db jne 106fbd toPrint[count++] = (num - (n*base)); num = n; } toPrint[count++] = num; 106fe2: 88 5c 0d e0 mov %bl,-0x20(%ebp,%ecx,1) for (n=maxwidth ; n > count; n-- ) 106fe6: 8b 5d c4 mov -0x3c(%ebp),%ebx BSP_output_char(lead); 106fe9: 0f be 75 c8 movsbl -0x38(%ebp),%esi 106fed: eb 0e jmp 106ffd 106fef: 83 ec 0c sub $0xc,%esp 106ff2: 56 push %esi 106ff3: ff 15 fc 93 11 00 call *0x1193fc toPrint[count++] = (num - (n*base)); num = n; } toPrint[count++] = num; for (n=maxwidth ; n > count; n-- ) 106ff9: 4b dec %ebx 106ffa: 83 c4 10 add $0x10,%esp 106ffd: 3b 5d b8 cmp -0x48(%ebp),%ebx 107000: 77 ed ja 106fef 107002: 31 db xor %ebx,%ebx BSP_output_char(lead); for (n = 0; n < count; n++) { BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]); 107004: 8d 75 f4 lea -0xc(%ebp),%esi 107007: 03 75 b8 add -0x48(%ebp),%esi 10700a: eb 1e jmp 10702a 10700c: 83 ec 0c sub $0xc,%esp 10700f: 89 d8 mov %ebx,%eax 107011: f7 d0 not %eax 107013: 0f be 44 30 ec movsbl -0x14(%eax,%esi,1),%eax 107018: 0f be 80 36 72 11 00 movsbl 0x117236(%eax),%eax 10701f: 50 push %eax 107020: ff 15 fc 93 11 00 call *0x1193fc toPrint[count++] = num; for (n=maxwidth ; n > count; n-- ) BSP_output_char(lead); for (n = 0; n < count; n++) { 107026: 43 inc %ebx 107027: 83 c4 10 add $0x10,%esp 10702a: 3b 5d b8 cmp -0x48(%ebp),%ebx 10702d: 72 dd jb 10700c 10702f: eb 10 jmp 107041 if (base) printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int), base, sign, width, lead); } else { BSP_output_char(*fmt); 107031: 83 ec 0c sub $0xc,%esp 107034: 0f be c0 movsbl %al,%eax 107037: 50 push %eax 107038: ff 15 fc 93 11 00 call *0x1193fc 10703e: 83 c4 10 add $0x10,%esp ) { char c, *str; int lflag, base, sign, width, lead, minus; for (; *fmt != '\0'; fmt++) { 107041: 47 inc %edi 107042: 8a 07 mov (%edi),%al 107044: 84 c0 test %al,%al 107046: 0f 85 89 fd ff ff jne 106dd5 10704c: eb 08 jmp 107056 base, sign, width, lead); } else { BSP_output_char(*fmt); } } } 10704e: 8b 55 d0 mov -0x30(%ebp),%edx 107051: 89 55 0c mov %edx,0xc(%ebp) 107054: eb eb jmp 107041 107056: 8d 65 f4 lea -0xc(%ebp),%esp 107059: 5b pop %ebx 10705a: 5e pop %esi 10705b: 5f pop %edi 10705c: c9 leave 10705d: c3 ret =============================================================================== 00115950 : ssize_t write( int fd, const void *buffer, size_t count ) { 115950: 55 push %ebp 115951: 89 e5 mov %esp,%ebp 115953: 56 push %esi 115954: 53 push %ebx 115955: 8b 45 08 mov 0x8(%ebp),%eax 115958: 8b 75 0c mov 0xc(%ebp),%esi 11595b: 8b 4d 10 mov 0x10(%ebp),%ecx ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11595e: 3b 05 d8 92 11 00 cmp 0x1192d8,%eax 115964: 73 2d jae 115993 <== NEVER TAKEN iop = rtems_libio_iop( fd ); 115966: 6b d8 34 imul $0x34,%eax,%ebx 115969: 03 1d 38 d6 11 00 add 0x11d638,%ebx rtems_libio_check_is_open( iop ); 11596f: 8b 53 0c mov 0xc(%ebx),%edx 115972: f6 c6 01 test $0x1,%dh 115975: 74 1c je 115993 <== NEVER TAKEN rtems_libio_check_buffer( buffer ); 115977: 85 f6 test %esi,%esi 115979: 75 0d jne 115988 <== ALWAYS TAKEN 11597b: e8 a8 97 ff ff call 10f128 <__errno> <== NOT EXECUTED 115980: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 115986: eb 2d jmp 1159b5 <== NOT EXECUTED rtems_libio_check_count( count ); 115988: 31 c0 xor %eax,%eax 11598a: 85 c9 test %ecx,%ecx 11598c: 74 3c je 1159ca rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF ); 11598e: 80 e2 04 and $0x4,%dl 115991: 75 0d jne 1159a0 <== ALWAYS TAKEN 115993: e8 90 97 ff ff call 10f128 <__errno> <== NOT EXECUTED 115998: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 11599e: eb 15 jmp 1159b5 <== NOT EXECUTED /* * Now process the write() request. */ if ( !iop->handlers->write_h ) 1159a0: 8b 43 30 mov 0x30(%ebx),%eax 1159a3: 8b 40 0c mov 0xc(%eax),%eax 1159a6: 85 c0 test %eax,%eax 1159a8: 75 10 jne 1159ba <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); 1159aa: e8 79 97 ff ff call 10f128 <__errno> <== NOT EXECUTED 1159af: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1159b5: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1159b8: eb 10 jmp 1159ca <== NOT EXECUTED rc = (*iop->handlers->write_h)( iop, buffer, count ); 1159ba: 52 push %edx 1159bb: 51 push %ecx 1159bc: 56 push %esi 1159bd: 53 push %ebx 1159be: ff d0 call *%eax if ( rc > 0 ) 1159c0: 83 c4 10 add $0x10,%esp 1159c3: 85 c0 test %eax,%eax 1159c5: 7e 03 jle 1159ca <== NEVER TAKEN iop->offset += rc; 1159c7: 01 43 08 add %eax,0x8(%ebx) return rc; } 1159ca: 8d 65 f8 lea -0x8(%ebp),%esp 1159cd: 5b pop %ebx 1159ce: 5e pop %esi 1159cf: c9 leave 1159d0: c3 ret