0010f6ac : IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) { 10f6ac: 55 push %ebp 10f6ad: 89 e5 mov %esp,%ebp 10f6af: 57 push %edi 10f6b0: 56 push %esi 10f6b1: 53 push %ebx 10f6b2: 83 ec 1c sub $0x1c,%esp 10f6b5: 8b 75 08 mov 0x8(%ebp),%esi 10f6b8: 8b 7d 0c mov 0xc(%ebp),%edi 10f6bb: 8b 5d 18 mov 0x18(%ebp),%ebx IMFS_fs_info_t *fs_info; /* * MUST have a parent node to call this routine. */ if ( parent_loc == NULL ) 10f6be: 31 c0 xor %eax,%eax 10f6c0: 85 f6 test %esi,%esi 10f6c2: 0f 84 da 00 00 00 je 10f7a2 return NULL; /* * Allocate filesystem node and fill in basic information */ node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask ); 10f6c8: 50 push %eax 10f6c9: a1 88 17 12 00 mov 0x121788,%eax 10f6ce: 8b 40 2c mov 0x2c(%eax),%eax 10f6d1: f7 d0 not %eax 10f6d3: 23 45 14 and 0x14(%ebp),%eax 10f6d6: 50 push %eax 10f6d7: ff 75 10 pushl 0x10(%ebp) 10f6da: 57 push %edi 10f6db: e8 30 ff ff ff call 10f610 if ( !node ) 10f6e0: 83 c4 10 add $0x10,%esp 10f6e3: 85 c0 test %eax,%eax 10f6e5: 0f 84 b7 00 00 00 je 10f7a2 return NULL; /* * Set the type specific information */ switch (type) { 10f6eb: 4f dec %edi 10f6ec: 83 ff 06 cmp $0x6,%edi 10f6ef: 77 73 ja 10f764 10f6f1: ff 24 bd a8 db 11 00 jmp *0x11dba8(,%edi,4) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 10f6f8: 8d 50 54 lea 0x54(%eax),%edx 10f6fb: 89 50 50 mov %edx,0x50(%eax) the_chain->permanent_null = NULL; 10f6fe: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) the_chain->last = _Chain_Head(the_chain); 10f705: 8d 50 50 lea 0x50(%eax),%edx 10f708: 89 50 58 mov %edx,0x58(%eax) 10f70b: eb 6d jmp 10f77a 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; 10f70d: 8b 13 mov (%ebx),%edx 10f70f: 89 50 50 mov %edx,0x50(%eax) break; 10f712: eb 66 jmp 10f77a case IMFS_DEVICE: node->info.device.major = info->device.major; 10f714: 8b 13 mov (%ebx),%edx 10f716: 89 50 50 mov %edx,0x50(%eax) node->info.device.minor = info->device.minor; 10f719: 8b 53 04 mov 0x4(%ebx),%edx 10f71c: 89 50 54 mov %edx,0x54(%eax) break; 10f71f: eb 59 jmp 10f77a case IMFS_LINEAR_FILE: node->info.linearfile.size = 0; 10f721: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) <== NOT EXECUTED 10f728: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) <== NOT EXECUTED node->info.linearfile.direct = 0; 10f72f: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) <== NOT EXECUTED case IMFS_MEMORY_FILE: node->info.file.size = 0; 10f736: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 10f73d: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.file.indirect = 0; 10f744: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) node->info.file.doubly_indirect = 0; 10f74b: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) node->info.file.triply_indirect = 0; 10f752: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) break; 10f759: eb 1f jmp 10f77a case IMFS_FIFO: node->info.fifo.pipe = NULL; 10f75b: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) break; 10f762: eb 16 jmp 10f77a default: assert(0); 10f764: 68 6c cd 11 00 push $0x11cd6c <== NOT EXECUTED 10f769: 68 c4 db 11 00 push $0x11dbc4 <== NOT EXECUTED 10f76e: 6a 5c push $0x5c <== NOT EXECUTED 10f770: 68 5c db 11 00 push $0x11db5c <== NOT EXECUTED 10f775: e8 16 77 ff ff call 106e90 <__assert_func> <== NOT EXECUTED } /* * This node MUST have a parent, so put it in that directory list. */ parent = parent_loc->node_access; 10f77a: 8b 16 mov (%esi),%edx fs_info = parent_loc->mt_entry->fs_info; 10f77c: 8b 4e 10 mov 0x10(%esi),%ecx 10f77f: 8b 59 34 mov 0x34(%ecx),%ebx node->Parent = parent; 10f782: 89 50 08 mov %edx,0x8(%eax) node->st_ino = ++fs_info->ino_count; 10f785: 8b 0b mov (%ebx),%ecx 10f787: 41 inc %ecx 10f788: 89 0b mov %ecx,(%ebx) 10f78a: 89 48 38 mov %ecx,0x38(%eax) RTEMS_INLINE_ROUTINE void rtems_chain_append( rtems_chain_control *the_chain, rtems_chain_node *the_node ) { _Chain_Append( the_chain, the_node ); 10f78d: 53 push %ebx 10f78e: 53 push %ebx 10f78f: 50 push %eax 10f790: 83 c2 50 add $0x50,%edx 10f793: 52 push %edx 10f794: 89 45 e4 mov %eax,-0x1c(%ebp) 10f797: e8 f4 af ff ff call 10a790 <_Chain_Append> rtems_chain_append( &parent->info.directory.Entries, &node->Node ); return node; 10f79c: 83 c4 10 add $0x10,%esp 10f79f: 8b 45 e4 mov -0x1c(%ebp),%eax } 10f7a2: 8d 65 f4 lea -0xc(%ebp),%esp 10f7a5: 5b pop %ebx 10f7a6: 5e pop %esi 10f7a7: 5f pop %edi 10f7a8: c9 leave 10f7a9: c3 ret 0010857b : void IMFS_dump_directory( IMFS_jnode_t *the_directory, int level ) { 10857b: 55 push %ebp 10857c: 89 e5 mov %esp,%ebp 10857e: 57 push %edi 10857f: 56 push %esi 108580: 53 push %ebx 108581: 83 ec 1c sub $0x1c,%esp 108584: 8b 45 08 mov 0x8(%ebp),%eax 108587: 8b 75 0c mov 0xc(%ebp),%esi rtems_chain_node *the_node; rtems_chain_control *the_chain; IMFS_jnode_t *the_jnode; int i; assert( the_directory ); 10858a: 85 c0 test %eax,%eax 10858c: 75 11 jne 10859f 10858e: 68 be 29 12 00 push $0x1229be <== NOT EXECUTED 108593: 68 a8 2a 12 00 push $0x122aa8 <== NOT EXECUTED 108598: 68 84 00 00 00 push $0x84 <== NOT EXECUTED 10859d: eb 13 jmp 1085b2 <== NOT EXECUTED assert( level >= 0 ); 10859f: 85 f6 test %esi,%esi 1085a1: 79 19 jns 1085bc 1085a3: 68 cc 29 12 00 push $0x1229cc <== NOT EXECUTED 1085a8: 68 a8 2a 12 00 push $0x122aa8 <== NOT EXECUTED 1085ad: 68 86 00 00 00 push $0x86 <== NOT EXECUTED 1085b2: 68 12 29 12 00 push $0x122912 <== NOT EXECUTED 1085b7: e8 6c 06 00 00 call 108c28 <__assert_func> <== NOT EXECUTED assert( the_directory->type == IMFS_DIRECTORY ); 1085bc: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 1085c0: 74 11 je 1085d3 1085c2: 68 d7 29 12 00 push $0x1229d7 <== NOT EXECUTED 1085c7: 68 a8 2a 12 00 push $0x122aa8 <== NOT EXECUTED 1085cc: 68 88 00 00 00 push $0x88 <== NOT EXECUTED 1085d1: eb df jmp 1085b2 <== NOT EXECUTED the_chain = &the_directory->info.directory.Entries; for ( the_node = the_chain->first; 1085d3: 8b 58 50 mov 0x50(%eax),%ebx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 1085d6: 83 c0 54 add $0x54,%eax 1085d9: 89 45 e4 mov %eax,-0x1c(%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 ); 1085dc: 8d 46 01 lea 0x1(%esi),%eax 1085df: 89 45 e0 mov %eax,-0x20(%ebp) assert( the_directory->type == IMFS_DIRECTORY ); the_chain = &the_directory->info.directory.Entries; for ( the_node = the_chain->first; 1085e2: eb 40 jmp 108624 !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; 1085e4: 31 ff xor %edi,%edi for ( i=0 ; i<=level ; i++ ) fprintf(stdout, "...." ); 1085e6: 51 push %ecx 1085e7: 51 push %ecx 1085e8: a1 00 70 12 00 mov 0x127000,%eax 1085ed: ff 70 08 pushl 0x8(%eax) 1085f0: 68 fd 29 12 00 push $0x1229fd 1085f5: e8 fe ba 00 00 call 1140f8 !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++ ) 1085fa: 47 inc %edi 1085fb: 83 c4 10 add $0x10,%esp 1085fe: 39 f7 cmp %esi,%edi 108600: 7e e4 jle 1085e6 fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); 108602: 83 ec 0c sub $0xc,%esp 108605: 53 push %ebx 108606: e8 53 fe ff ff call 10845e if ( the_jnode->type == IMFS_DIRECTORY ) 10860b: 83 c4 10 add $0x10,%esp 10860e: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 108612: 75 0e jne 108622 IMFS_dump_directory( the_jnode, level + 1 ); 108614: 52 push %edx 108615: 52 push %edx 108616: ff 75 e0 pushl -0x20(%ebp) 108619: 53 push %ebx 10861a: e8 5c ff ff ff call 10857b 10861f: 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 ) { 108622: 8b 1b mov (%ebx),%ebx assert( the_directory->type == IMFS_DIRECTORY ); the_chain = &the_directory->info.directory.Entries; for ( the_node = the_chain->first; 108624: 3b 5d e4 cmp -0x1c(%ebp),%ebx 108627: 75 bb jne 1085e4 fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); if ( the_jnode->type == IMFS_DIRECTORY ) IMFS_dump_directory( the_jnode, level + 1 ); } } 108629: 8d 65 f4 lea -0xc(%ebp),%esp 10862c: 5b pop %ebx 10862d: 5e pop %esi 10862e: 5f pop %edi 10862f: c9 leave 108630: c3 ret 0010d0af : const char *pathname, /* IN */ int pathnamelen, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10d0af: 55 push %ebp 10d0b0: 89 e5 mov %esp,%ebp 10d0b2: 57 push %edi 10d0b3: 56 push %esi 10d0b4: 53 push %ebx 10d0b5: 83 ec 5c sub $0x5c,%esp 10d0b8: 8b 5d 14 mov 0x14(%ebp),%ebx /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10d0bb: 8b 3b mov (%ebx),%edi 10d0bd: b8 01 00 00 00 mov $0x1,%eax 10d0c2: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp) * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], pathnamelen, token, &len ); 10d0c9: 8d 75 af lea -0x51(%ebp),%esi /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 10d0cc: e9 38 01 00 00 jmp 10d209 type = IMFS_get_token( &pathname[i], pathnamelen, token, &len ); 10d0d1: 8d 45 e4 lea -0x1c(%ebp),%eax 10d0d4: 50 push %eax 10d0d5: 56 push %esi 10d0d6: ff 75 0c pushl 0xc(%ebp) 10d0d9: 8b 45 08 mov 0x8(%ebp),%eax 10d0dc: 03 45 a4 add -0x5c(%ebp),%eax 10d0df: 50 push %eax 10d0e0: e8 a7 06 00 00 call 10d78c pathnamelen -= len; 10d0e5: 8b 4d e4 mov -0x1c(%ebp),%ecx i += len; if ( !pathloc->node_access ) 10d0e8: 8b 13 mov (%ebx),%edx 10d0ea: 83 c4 10 add $0x10,%esp 10d0ed: 85 d2 test %edx,%edx 10d0ef: 0f 84 ed 00 00 00 je 10d1e2 rtems_set_errno_and_return_minus_one( ENOENT ); /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10d0f5: 85 c0 test %eax,%eax 10d0f7: 74 10 je 10d109 if ( node->type == IMFS_DIRECTORY ) 10d0f9: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10d0fd: 75 0a jne 10d109 /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10d0ff: f6 42 30 40 testb $0x40,0x30(%edx) 10d103: 0f 84 77 01 00 00 je 10d280 */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], pathnamelen, token, &len ); pathnamelen -= len; 10d109: 29 4d 0c sub %ecx,0xc(%ebp) i += len; 10d10c: 01 4d a4 add %ecx,-0x5c(%ebp) if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); node = pathloc->node_access; 10d10f: 89 d7 mov %edx,%edi switch( type ) { 10d111: 83 f8 03 cmp $0x3,%eax 10d114: 74 5b je 10d171 10d116: 83 f8 04 cmp $0x4,%eax 10d119: 0f 84 da 00 00 00 je 10d1f9 10d11f: 83 f8 02 cmp $0x2,%eax 10d122: 0f 85 e1 00 00 00 jne 10d209 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10d128: a1 88 17 12 00 mov 0x121788,%eax 10d12d: 3b 50 18 cmp 0x18(%eax),%edx 10d130: 74 9f je 10d0d1 /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access) { 10d132: 8b 43 10 mov 0x10(%ebx),%eax /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == 10d135: 3b 50 1c cmp 0x1c(%eax),%edx 10d138: 75 32 jne 10d16c 10d13a: 89 4d a0 mov %ecx,-0x60(%ebp) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; /* Throw out the .. in this case */ } else { newloc = pathloc->mt_entry->mt_point_node; 10d13d: 8d 7d d0 lea -0x30(%ebp),%edi 10d140: 8d 70 08 lea 0x8(%eax),%esi 10d143: b9 05 00 00 00 mov $0x5,%ecx 10d148: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10d14a: 8d 75 d0 lea -0x30(%ebp),%esi 10d14d: b1 05 mov $0x5,%cl 10d14f: 89 df mov %ebx,%edi 10d151: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalpath_h)(&(pathname[i-len]), 10d153: 8b 53 0c mov 0xc(%ebx),%edx 10d156: 53 push %ebx 10d157: ff 75 10 pushl 0x10(%ebp) 10d15a: 8b 45 a0 mov -0x60(%ebp),%eax 10d15d: 03 45 0c add 0xc(%ebp),%eax 10d160: 50 push %eax 10d161: 8b 45 a4 mov -0x5c(%ebp),%eax 10d164: 2b 45 a0 sub -0x60(%ebp),%eax 10d167: e9 e4 00 00 00 jmp 10d250 pathnamelen+len, flags,pathloc); } } else { if ( !node->Parent ) 10d16c: 8b 7a 08 mov 0x8(%edx),%edi 10d16f: eb 6d jmp 10d1de case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { 10d171: 8b 42 4c mov 0x4c(%edx),%eax 10d174: 83 f8 03 cmp $0x3,%eax 10d177: 75 15 jne 10d18e IMFS_evaluate_hard_link( pathloc, 0 ); 10d179: 51 push %ecx 10d17a: 51 push %ecx 10d17b: 6a 00 push $0x0 10d17d: 53 push %ebx 10d17e: e8 22 fe ff ff call 10cfa5 node = pathloc->node_access; 10d183: 8b 3b mov (%ebx),%edi if ( !node ) 10d185: 83 c4 10 add $0x10,%esp 10d188: 85 ff test %edi,%edi 10d18a: 75 1f jne 10d1ab 10d18c: eb 23 jmp 10d1b1 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); } else if ( node->type == IMFS_SYM_LINK ) { 10d18e: 83 f8 04 cmp $0x4,%eax 10d191: 75 18 jne 10d1ab result = IMFS_evaluate_sym_link( pathloc, 0 ); 10d193: 52 push %edx 10d194: 52 push %edx 10d195: 6a 00 push $0x0 10d197: 53 push %ebx 10d198: e8 60 fe ff ff call 10cffd node = pathloc->node_access; 10d19d: 8b 3b mov (%ebx),%edi if ( result == -1 ) 10d19f: 83 c4 10 add $0x10,%esp 10d1a2: 83 f8 ff cmp $0xffffffff,%eax 10d1a5: 0f 84 cd 00 00 00 je 10d278 /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10d1ab: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10d1af: 74 10 je 10d1c1 rtems_set_errno_and_return_minus_one( ENOTDIR ); 10d1b1: e8 fe 30 00 00 call 1102b4 <__errno> 10d1b6: c7 00 14 00 00 00 movl $0x14,(%eax) 10d1bc: e9 ca 00 00 00 jmp 10d28b /* * 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 ) { 10d1c1: 8b 47 5c mov 0x5c(%edi),%eax 10d1c4: 85 c0 test %eax,%eax 10d1c6: 74 08 je 10d1d0 newloc = node->info.directory.mt_fs->mt_fs_root; 10d1c8: 8d 7d d0 lea -0x30(%ebp),%edi 10d1cb: 8d 70 1c lea 0x1c(%eax),%esi 10d1ce: eb 59 jmp 10d229 /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10d1d0: 50 push %eax 10d1d1: 50 push %eax 10d1d2: 56 push %esi 10d1d3: 57 push %edi 10d1d4: e8 27 05 00 00 call 10d700 10d1d9: 89 c7 mov %eax,%edi if ( !node ) 10d1db: 83 c4 10 add $0x10,%esp 10d1de: 85 ff test %edi,%edi 10d1e0: 75 10 jne 10d1f2 rtems_set_errno_and_return_minus_one( ENOENT ); 10d1e2: e8 cd 30 00 00 call 1102b4 <__errno> 10d1e7: c7 00 02 00 00 00 movl $0x2,(%eax) 10d1ed: e9 99 00 00 00 jmp 10d28b /* * Set the node access to the point we have found. */ pathloc->node_access = node; 10d1f2: 89 3b mov %edi,(%ebx) 10d1f4: e9 d8 fe ff ff jmp 10d0d1 case IMFS_NO_MORE_PATH: case IMFS_CURRENT_DIR: break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10d1f9: e8 b6 30 00 00 call 1102b4 <__errno> 10d1fe: c7 00 5b 00 00 00 movl $0x5b,(%eax) 10d204: e9 82 00 00 00 jmp 10d28b /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 10d209: 83 f8 04 cmp $0x4,%eax 10d20c: 74 08 je 10d216 10d20e: 85 c0 test %eax,%eax 10d210: 0f 85 bb fe ff ff jne 10d0d1 * 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 ) { 10d216: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10d21a: 75 3f jne 10d25b if ( node->info.directory.mt_fs != NULL ) { 10d21c: 8b 77 5c mov 0x5c(%edi),%esi 10d21f: 85 f6 test %esi,%esi 10d221: 74 38 je 10d25b newloc = node->info.directory.mt_fs->mt_fs_root; 10d223: 8d 7d d0 lea -0x30(%ebp),%edi 10d226: 83 c6 1c add $0x1c,%esi 10d229: b9 05 00 00 00 mov $0x5,%ecx 10d22e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10d230: 8d 75 d0 lea -0x30(%ebp),%esi 10d233: b1 05 mov $0x5,%cl 10d235: 89 df mov %ebx,%edi 10d237: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalpath_h)( &pathname[i-len], 10d239: 8b 45 e4 mov -0x1c(%ebp),%eax 10d23c: 8b 53 0c mov 0xc(%ebx),%edx 10d23f: 53 push %ebx 10d240: ff 75 10 pushl 0x10(%ebp) 10d243: 8b 4d 0c mov 0xc(%ebp),%ecx 10d246: 01 c1 add %eax,%ecx 10d248: 51 push %ecx 10d249: 8b 4d a4 mov -0x5c(%ebp),%ecx 10d24c: 29 c1 sub %eax,%ecx 10d24e: 89 c8 mov %ecx,%eax 10d250: 03 45 08 add 0x8(%ebp),%eax 10d253: 50 push %eax 10d254: ff 12 call *(%edx) 10d256: 83 c4 10 add $0x10,%esp 10d259: eb 1d jmp 10d278 flags, pathloc ); } else { result = IMFS_Set_handlers( pathloc ); } } else { result = IMFS_Set_handlers( pathloc ); 10d25b: 83 ec 0c sub $0xc,%esp 10d25e: 53 push %ebx 10d25f: e8 dc fc ff ff call 10cf40 10d264: 83 c4 10 add $0x10,%esp /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10d267: 8b 55 10 mov 0x10(%ebp),%edx 10d26a: c1 e2 06 shl $0x6,%edx if ( !rtems_libio_is_valid_perms( flags ) ) { assert( 0 ); rtems_set_errno_and_return_minus_one( EIO ); } jnode = node->node_access; 10d26d: 8b 0b mov (%ebx),%ecx 10d26f: 8b 49 30 mov 0x30(%ecx),%ecx 10d272: 21 d1 and %edx,%ecx 10d274: 39 d1 cmp %edx,%ecx 10d276: 75 08 jne 10d280 if ( !IMFS_evaluate_permission( pathloc, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10d278: 8d 65 f4 lea -0xc(%ebp),%esp 10d27b: 5b pop %ebx 10d27c: 5e pop %esi 10d27d: 5f pop %edi 10d27e: c9 leave 10d27f: c3 ret /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); 10d280: e8 2f 30 00 00 call 1102b4 <__errno> 10d285: c7 00 0d 00 00 00 movl $0xd,(%eax) 10d28b: 83 c8 ff or $0xffffffff,%eax 10d28e: eb e8 jmp 10d278 0010cfa5 : int IMFS_evaluate_hard_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10cfa5: 55 push %ebp 10cfa6: 89 e5 mov %esp,%ebp 10cfa8: 53 push %ebx 10cfa9: 83 ec 04 sub $0x4,%esp 10cfac: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *jnode = node->node_access; 10cfaf: 8b 03 mov (%ebx),%eax /* * Check for things that should never happen. */ if ( jnode->type != IMFS_HARD_LINK ) 10cfb1: 83 78 4c 03 cmpl $0x3,0x4c(%eax) 10cfb5: 74 0d je 10cfc4 rtems_fatal_error_occurred (0xABCD0000); 10cfb7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cfba: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED 10cfbf: e8 70 d5 ff ff call 10a534 <== NOT EXECUTED /* * Set the hard link value and the handlers. */ node->node_access = jnode->info.hard_link.link_node; 10cfc4: 8b 40 50 mov 0x50(%eax),%eax 10cfc7: 89 03 mov %eax,(%ebx) IMFS_Set_handlers( node ); 10cfc9: 83 ec 0c sub $0xc,%esp 10cfcc: 53 push %ebx 10cfcd: e8 6e ff ff ff call 10cf40 /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10cfd2: 8b 45 0c mov 0xc(%ebp),%eax 10cfd5: c1 e0 06 shl $0x6,%eax if ( !rtems_libio_is_valid_perms( flags ) ) { assert( 0 ); rtems_set_errno_and_return_minus_one( EIO ); } jnode = node->node_access; 10cfd8: 8b 13 mov (%ebx),%edx 10cfda: 8b 52 30 mov 0x30(%edx),%edx 10cfdd: 21 c2 and %eax,%edx 10cfdf: 83 c4 10 add $0x10,%esp 10cfe2: 39 c2 cmp %eax,%edx 10cfe4: 75 07 jne 10cfed 10cfe6: 31 c0 xor %eax,%eax if ( !IMFS_evaluate_permission( node, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10cfe8: 8b 5d fc mov -0x4(%ebp),%ebx 10cfeb: c9 leave 10cfec: c3 ret /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); 10cfed: e8 c2 32 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10cff2: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10cff8: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10cffb: eb eb jmp 10cfe8 <== NOT EXECUTED 0010cf88 : int IMFS_evaluate_permission( rtems_filesystem_location_info_t *node, int flags ) { 10cf88: 55 push %ebp <== NOT EXECUTED 10cf89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cf8b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10cf8e: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 10cf91: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10cf94: 8b 12 mov (%edx),%edx <== NOT EXECUTED 10cf96: 8b 52 30 mov 0x30(%edx),%edx <== NOT EXECUTED 10cf99: 21 c2 and %eax,%edx <== NOT EXECUTED 10cf9b: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10cf9d: 0f 94 c0 sete %al <== NOT EXECUTED 10cfa0: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED return 1; return 0; } 10cfa3: c9 leave <== NOT EXECUTED 10cfa4: c3 ret <== NOT EXECUTED 0010cffd : int IMFS_evaluate_sym_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10cffd: 55 push %ebp 10cffe: 89 e5 mov %esp,%ebp 10d000: 57 push %edi 10d001: 56 push %esi 10d002: 53 push %ebx 10d003: 83 ec 0c sub $0xc,%esp 10d006: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *jnode = node->node_access; 10d009: 8b 03 mov (%ebx),%eax /* * Check for things that should never happen. */ if ( jnode->type != IMFS_SYM_LINK ) 10d00b: 83 78 4c 04 cmpl $0x4,0x4c(%eax) 10d00f: 74 0a je 10d01b rtems_fatal_error_occurred (0xABCD0000); 10d011: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d014: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED 10d019: eb 0f jmp 10d02a <== NOT EXECUTED if ( !jnode->Parent ) 10d01b: 8b 50 08 mov 0x8(%eax),%edx 10d01e: 85 d2 test %edx,%edx 10d020: 75 0d jne 10d02f rtems_fatal_error_occurred( 0xBAD00000 ); 10d022: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d025: 68 00 00 d0 ba push $0xbad00000 <== NOT EXECUTED 10d02a: e8 05 d5 ff ff call 10a534 <== 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; 10d02f: 89 13 mov %edx,(%ebx) rtems_filesystem_get_sym_start_loc( 10d031: 8b 50 50 mov 0x50(%eax),%edx 10d034: 8a 0a mov (%edx),%cl 10d036: 80 f9 5c cmp $0x5c,%cl 10d039: 74 0b je 10d046 10d03b: 80 f9 2f cmp $0x2f,%cl 10d03e: 74 06 je 10d046 10d040: 31 d2 xor %edx,%edx 10d042: 84 c9 test %cl,%cl 10d044: 75 17 jne 10d05d 10d046: 8b 35 88 17 12 00 mov 0x121788,%esi 10d04c: 83 c6 18 add $0x18,%esi 10d04f: b9 05 00 00 00 mov $0x5,%ecx 10d054: 89 df mov %ebx,%edi 10d056: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10d058: ba 01 00 00 00 mov $0x1,%edx * Use eval path to evaluate the path of the symbolic link. */ result = IMFS_eval_path( &jnode->info.sym_link.name[i], strlen( &jnode->info.sym_link.name[i] ), 10d05d: 03 50 50 add 0x50(%eax),%edx 10d060: 31 c0 xor %eax,%eax 10d062: 83 c9 ff or $0xffffffff,%ecx 10d065: 89 d7 mov %edx,%edi 10d067: f2 ae repnz scas %es:(%edi),%al 10d069: f7 d1 not %ecx 10d06b: 49 dec %ecx /* * Use eval path to evaluate the path of the symbolic link. */ result = IMFS_eval_path( 10d06c: 53 push %ebx 10d06d: ff 75 0c pushl 0xc(%ebp) 10d070: 51 push %ecx 10d071: 52 push %edx 10d072: e8 38 00 00 00 call 10d0af 10d077: 89 c6 mov %eax,%esi strlen( &jnode->info.sym_link.name[i] ), flags, node ); IMFS_Set_handlers( node ); 10d079: 89 1c 24 mov %ebx,(%esp) 10d07c: e8 bf fe ff ff call 10cf40 /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10d081: 8b 45 0c mov 0xc(%ebp),%eax 10d084: c1 e0 06 shl $0x6,%eax if ( !rtems_libio_is_valid_perms( flags ) ) { assert( 0 ); rtems_set_errno_and_return_minus_one( EIO ); } jnode = node->node_access; 10d087: 8b 13 mov (%ebx),%edx 10d089: 8b 52 30 mov 0x30(%edx),%edx 10d08c: 21 c2 and %eax,%edx 10d08e: 83 c4 10 add $0x10,%esp 10d091: 39 c2 cmp %eax,%edx 10d093: 75 0a jne 10d09f if ( !IMFS_evaluate_permission( node, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10d095: 89 f0 mov %esi,%eax 10d097: 8d 65 f4 lea -0xc(%ebp),%esp 10d09a: 5b pop %ebx 10d09b: 5e pop %esi 10d09c: 5f pop %edi 10d09d: c9 leave 10d09e: c3 ret /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); 10d09f: e8 10 32 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10d0a4: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10d0aa: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 10d0ad: eb e6 jmp 10d095 <== NOT EXECUTED 0010d665 : } int IMFS_fifo_close( rtems_libio_t *iop ) { 10d665: 55 push %ebp <== NOT EXECUTED 10d666: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d668: 57 push %edi <== NOT EXECUTED 10d669: 56 push %esi <== NOT EXECUTED 10d66a: 53 push %ebx <== NOT EXECUTED 10d66b: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10d66e: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED IMFS_jnode_t *jnode = iop->file_info; 10d671: 8b 77 38 mov 0x38(%edi),%esi <== NOT EXECUTED int err = pipe_release(&JNODE2PIPE(jnode), iop); 10d674: 57 push %edi <== NOT EXECUTED 10d675: 8d 46 50 lea 0x50(%esi),%eax <== NOT EXECUTED 10d678: 50 push %eax <== NOT EXECUTED 10d679: e8 9a 1b 00 00 call 10f218 <== NOT EXECUTED 10d67e: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (! err) { 10d680: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d683: 83 f8 00 cmp $0x0,%eax <== NOT EXECUTED 10d686: 75 2c jne 10d6b4 <== NOT EXECUTED iop->flags &= ~LIBIO_FLAGS_OPEN; 10d688: 81 67 14 ff fe ff ff andl $0xfffffeff,0x14(%edi) <== NOT EXECUTED /* Free jnode if file is already unlinked and no one opens it */ if (! rtems_libio_is_file_open(jnode) && jnode->st_nlink < 1) 10d68f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d692: 56 push %esi <== NOT EXECUTED 10d693: e8 6e 06 00 00 call 10dd06 <== NOT EXECUTED 10d698: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d69b: 85 c0 test %eax,%eax <== NOT EXECUTED 10d69d: 75 23 jne 10d6c2 <== NOT EXECUTED 10d69f: 66 83 7e 34 00 cmpw $0x0,0x34(%esi) <== NOT EXECUTED 10d6a4: 75 1c jne 10d6c2 <== NOT EXECUTED free(jnode); 10d6a6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d6a9: 56 push %esi <== NOT EXECUTED 10d6aa: e8 d1 9a ff ff call 107180 <== NOT EXECUTED 10d6af: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d6b2: eb 0e jmp 10d6c2 <== NOT EXECUTED } IMFS_FIFO_RETURN(err); 10d6b4: 7d 0c jge 10d6c2 <== NOT EXECUTED 10d6b6: e8 f9 2b 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10d6bb: f7 db neg %ebx <== NOT EXECUTED 10d6bd: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10d6bf: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED } 10d6c2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d6c4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d6c7: 5b pop %ebx <== NOT EXECUTED 10d6c8: 5e pop %esi <== NOT EXECUTED 10d6c9: 5f pop %edi <== NOT EXECUTED 10d6ca: c9 leave <== NOT EXECUTED 10d6cb: c3 ret <== NOT EXECUTED 0010d558 : int IMFS_fifo_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 10d558: 55 push %ebp <== NOT EXECUTED 10d559: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d55b: 53 push %ebx <== NOT EXECUTED 10d55c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d55f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d562: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10d565: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED int err; if (command == FIONBIO) { 10d568: 81 f9 7e 66 04 80 cmp $0x8004667e,%ecx <== NOT EXECUTED 10d56e: 75 1c jne 10d58c <== NOT EXECUTED if (buffer == NULL) 10d570: bb f2 ff ff ff mov $0xfffffff2,%ebx <== NOT EXECUTED 10d575: 85 d2 test %edx,%edx <== NOT EXECUTED 10d577: 74 2a je 10d5a3 <== NOT EXECUTED err = -EFAULT; else { if (*(int *)buffer) 10d579: 83 3a 00 cmpl $0x0,(%edx) <== NOT EXECUTED 10d57c: 74 06 je 10d584 <== NOT EXECUTED iop->flags |= LIBIO_FLAGS_NO_DELAY; 10d57e: 83 48 14 01 orl $0x1,0x14(%eax) <== NOT EXECUTED 10d582: eb 04 jmp 10d588 <== NOT EXECUTED else iop->flags &= ~LIBIO_FLAGS_NO_DELAY; 10d584: 83 60 14 fe andl $0xfffffffe,0x14(%eax) <== NOT EXECUTED 10d588: 31 db xor %ebx,%ebx <== NOT EXECUTED 10d58a: eb 23 jmp 10d5af <== NOT EXECUTED return 0; } } else err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop); 10d58c: 50 push %eax <== NOT EXECUTED 10d58d: 52 push %edx <== NOT EXECUTED 10d58e: 51 push %ecx <== NOT EXECUTED 10d58f: 8b 40 38 mov 0x38(%eax),%eax <== NOT EXECUTED 10d592: ff 70 50 pushl 0x50(%eax) <== NOT EXECUTED 10d595: e8 f9 18 00 00 call 10ee93 <== NOT EXECUTED 10d59a: 89 c3 mov %eax,%ebx <== NOT EXECUTED IMFS_FIFO_RETURN(err); 10d59c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d59f: 85 c0 test %eax,%eax <== NOT EXECUTED 10d5a1: 79 0c jns 10d5af <== NOT EXECUTED 10d5a3: e8 0c 2d 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10d5a8: f7 db neg %ebx <== NOT EXECUTED 10d5aa: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10d5ac: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED } 10d5af: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d5b1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d5b4: c9 leave <== NOT EXECUTED 10d5b5: c3 ret <== NOT EXECUTED 0010d51c : rtems_off64_t IMFS_fifo_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) { 10d51c: 55 push %ebp <== NOT EXECUTED 10d51d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d51f: 53 push %ebx <== NOT EXECUTED 10d520: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10d523: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop); 10d526: 50 push %eax <== NOT EXECUTED 10d527: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10d52a: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10d52d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d530: 8b 40 38 mov 0x38(%eax),%eax <== NOT EXECUTED 10d533: ff 70 50 pushl 0x50(%eax) <== NOT EXECUTED 10d536: e8 01 19 00 00 call 10ee3c <== NOT EXECUTED 10d53b: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10d53d: 99 cltd <== NOT EXECUTED IMFS_FIFO_RETURN(err); 10d53e: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10d541: 85 d2 test %edx,%edx <== NOT EXECUTED 10d543: 79 0e jns 10d553 <== NOT EXECUTED 10d545: e8 6a 2d 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10d54a: f7 db neg %ebx <== NOT EXECUTED 10d54c: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10d54e: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10d551: 89 c2 mov %eax,%edx <== NOT EXECUTED } 10d553: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d556: c9 leave <== NOT EXECUTED 10d557: c3 ret <== NOT EXECUTED 0010d60f : ssize_t IMFS_fifo_read( rtems_libio_t *iop, void *buffer, size_t count ) { 10d60f: 55 push %ebp <== NOT EXECUTED 10d610: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d612: 56 push %esi <== NOT EXECUTED 10d613: 53 push %ebx <== NOT EXECUTED 10d614: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10d617: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED IMFS_jnode_t *jnode = iop->file_info; 10d61a: 8b 70 38 mov 0x38(%eax),%esi <== NOT EXECUTED int err = pipe_read(JNODE2PIPE(jnode), buffer, count, iop); 10d61d: 50 push %eax <== NOT EXECUTED 10d61e: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10d621: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d624: ff 76 50 pushl 0x50(%esi) <== NOT EXECUTED 10d627: e8 4f 1a 00 00 call 10f07b <== NOT EXECUTED 10d62c: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (err > 0) 10d62e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d631: 83 f8 00 cmp $0x0,%eax <== NOT EXECUTED 10d634: 7e 18 jle 10d64e <== NOT EXECUTED IMFS_update_atime(jnode); 10d636: 52 push %edx <== NOT EXECUTED 10d637: 52 push %edx <== NOT EXECUTED 10d638: 6a 00 push $0x0 <== NOT EXECUTED 10d63a: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10d63d: 50 push %eax <== NOT EXECUTED 10d63e: e8 11 06 00 00 call 10dc54 <== NOT EXECUTED 10d643: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10d646: 89 46 40 mov %eax,0x40(%esi) <== NOT EXECUTED 10d649: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d64c: eb 0e jmp 10d65c <== NOT EXECUTED IMFS_FIFO_RETURN(err); 10d64e: 74 0c je 10d65c <== NOT EXECUTED 10d650: e8 5f 2c 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10d655: f7 db neg %ebx <== NOT EXECUTED 10d657: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10d659: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED } 10d65c: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d65e: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d661: 5b pop %ebx <== NOT EXECUTED 10d662: 5e pop %esi <== NOT EXECUTED 10d663: c9 leave <== NOT EXECUTED 10d664: c3 ret <== NOT EXECUTED 0010d5b6 : ssize_t IMFS_fifo_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 10d5b6: 55 push %ebp <== NOT EXECUTED 10d5b7: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d5b9: 56 push %esi <== NOT EXECUTED 10d5ba: 53 push %ebx <== NOT EXECUTED 10d5bb: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10d5be: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED IMFS_jnode_t *jnode = iop->file_info; 10d5c1: 8b 70 38 mov 0x38(%eax),%esi <== NOT EXECUTED int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop); 10d5c4: 50 push %eax <== NOT EXECUTED 10d5c5: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10d5c8: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d5cb: ff 76 50 pushl 0x50(%esi) <== NOT EXECUTED 10d5ce: e8 16 19 00 00 call 10eee9 <== NOT EXECUTED 10d5d3: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (err > 0) { 10d5d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d5d8: 83 f8 00 cmp $0x0,%eax <== NOT EXECUTED 10d5db: 7e 1b jle 10d5f8 <== NOT EXECUTED IMFS_mtime_ctime_update(jnode); 10d5dd: 50 push %eax <== NOT EXECUTED 10d5de: 50 push %eax <== NOT EXECUTED 10d5df: 6a 00 push $0x0 <== NOT EXECUTED 10d5e1: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10d5e4: 50 push %eax <== NOT EXECUTED 10d5e5: e8 6a 06 00 00 call 10dc54 <== NOT EXECUTED 10d5ea: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10d5ed: 89 46 44 mov %eax,0x44(%esi) <== NOT EXECUTED 10d5f0: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED 10d5f3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d5f6: eb 0e jmp 10d606 <== NOT EXECUTED } IMFS_FIFO_RETURN(err); 10d5f8: 74 0c je 10d606 <== NOT EXECUTED 10d5fa: e8 b5 2c 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10d5ff: f7 db neg %ebx <== NOT EXECUTED 10d601: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10d603: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED } 10d606: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d608: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d60b: 5b pop %ebx <== NOT EXECUTED 10d60c: 5e pop %esi <== NOT EXECUTED 10d60d: c9 leave <== NOT EXECUTED 10d60e: c3 ret <== NOT EXECUTED 0010d700 : IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) { 10d700: 55 push %ebp 10d701: 89 e5 mov %esp,%ebp 10d703: 57 push %edi 10d704: 56 push %esi 10d705: 53 push %ebx 10d706: 83 ec 0c sub $0xc,%esp 10d709: 8b 5d 08 mov 0x8(%ebp),%ebx 10d70c: 8b 7d 0c mov 0xc(%ebp),%edi /* * Check for fatal errors. A NULL directory show a problem in the * the IMFS code. */ assert( directory ); 10d70f: 85 db test %ebx,%ebx 10d711: 75 16 jne 10d729 10d713: 68 58 d9 11 00 push $0x11d958 <== NOT EXECUTED 10d718: 68 b8 d9 11 00 push $0x11d9b8 <== NOT EXECUTED 10d71d: 6a 2a push $0x2a <== NOT EXECUTED 10d71f: 68 62 d9 11 00 push $0x11d962 <== NOT EXECUTED 10d724: e8 67 97 ff ff call 106e90 <__assert_func> <== NOT EXECUTED if ( !name ) 10d729: 85 ff test %edi,%edi 10d72b: 74 52 je 10d77f /* * Check for "." and ".." */ if ( !strcmp( name, dotname ) ) 10d72d: 56 push %esi 10d72e: 56 push %esi 10d72f: 68 b0 d9 11 00 push $0x11d9b0 10d734: 57 push %edi 10d735: e8 96 36 00 00 call 110dd0 10d73a: 83 c4 10 add $0x10,%esp 10d73d: 85 c0 test %eax,%eax 10d73f: 74 40 je 10d781 return directory; if ( !strcmp( name, dotdotname ) ) 10d741: 51 push %ecx 10d742: 51 push %ecx 10d743: 68 b2 d9 11 00 push $0x11d9b2 10d748: 57 push %edi 10d749: e8 82 36 00 00 call 110dd0 10d74e: 83 c4 10 add $0x10,%esp 10d751: 85 c0 test %eax,%eax 10d753: 75 05 jne 10d75a return directory->Parent; 10d755: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10d758: eb 27 jmp 10d781 <== NOT EXECUTED the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; 10d75a: 8b 73 50 mov 0x50(%ebx),%esi */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10d75d: 83 c3 54 add $0x54,%ebx 10d760: eb 19 jmp 10d77b !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 ) ) 10d762: 8d 46 0c lea 0xc(%esi),%eax 10d765: 52 push %edx 10d766: 52 push %edx 10d767: 50 push %eax 10d768: 57 push %edi 10d769: e8 62 36 00 00 call 110dd0 10d76e: 83 c4 10 add $0x10,%esp 10d771: 85 c0 test %eax,%eax 10d773: 75 04 jne 10d779 10d775: 89 f3 mov %esi,%ebx 10d777: eb 08 jmp 10d781 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 ) { 10d779: 8b 36 mov (%esi),%esi if ( !strcmp( name, dotdotname ) ) return directory->Parent; the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; 10d77b: 39 de cmp %ebx,%esi 10d77d: 75 e3 jne 10d762 10d77f: 31 db xor %ebx,%ebx if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10d781: 89 d8 mov %ebx,%eax 10d783: 8d 65 f4 lea -0xc(%ebp),%esp 10d786: 5b pop %ebx 10d787: 5e pop %esi 10d788: 5f pop %edi 10d789: c9 leave 10d78a: c3 ret 00111a0c : ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next)) int IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 111a0c: 55 push %ebp 111a0d: 89 e5 mov %esp,%ebp 111a0f: 57 push %edi 111a10: 56 push %esi 111a11: 53 push %ebx 111a12: 83 ec 2c sub $0x2c,%esp 111a15: 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; 111a18: 8b 58 1c mov 0x1c(%eax),%ebx loc = temp_mt_entry->mt_fs_root; 111a1b: 8d 7d d4 lea -0x2c(%ebp),%edi 111a1e: 8d 70 1c lea 0x1c(%eax),%esi 111a21: b9 05 00 00 00 mov $0x5,%ecx 111a26: 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; 111a28: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) do { next = jnode->Parent; loc.node_access = (void *)jnode; IMFS_Set_handlers( &loc ); 111a2f: 8d 75 d4 lea -0x2c(%ebp),%esi */ temp_mt_entry->mt_fs_root.node_access = NULL; do { next = jnode->Parent; 111a32: 8b 7b 08 mov 0x8(%ebx),%edi loc.node_access = (void *)jnode; 111a35: 89 5d d4 mov %ebx,-0x2c(%ebp) IMFS_Set_handlers( &loc ); 111a38: 83 ec 0c sub $0xc,%esp 111a3b: 56 push %esi 111a3c: e8 03 f8 ff ff call 111244 if ( jnode->type != IMFS_DIRECTORY ) { 111a41: 83 c4 10 add $0x10,%esp 111a44: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 111a48: 75 08 jne 111a52 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 111a4a: 8d 43 54 lea 0x54(%ebx),%eax 111a4d: 39 43 50 cmp %eax,0x50(%ebx) 111a50: 75 13 jne 111a65 result = IMFS_unlink( NULL, &loc ); if (result != 0) return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { result = IMFS_unlink( NULL, &loc ); 111a52: 50 push %eax 111a53: 50 push %eax 111a54: 56 push %esi 111a55: 6a 00 push $0x0 111a57: e8 54 63 ff ff call 107db0 if (result != 0) 111a5c: 83 c4 10 add $0x10,%esp 111a5f: 85 c0 test %eax,%eax 111a61: 75 1d jne 111a80 111a63: 89 fb mov %edi,%ebx return -1; jnode = next; } if ( jnode != NULL ) { 111a65: 85 db test %ebx,%ebx 111a67: 74 1c je 111a85 if ( jnode->type == IMFS_DIRECTORY ) { 111a69: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 111a6d: 75 c3 jne 111a32 111a6f: 8d 43 54 lea 0x54(%ebx),%eax 111a72: 39 43 50 cmp %eax,0x50(%ebx) 111a75: 74 bb je 111a32 if ( jnode_has_children( jnode ) ) jnode = jnode_get_first_child( jnode ); 111a77: 8b 5b 50 mov 0x50(%ebx),%ebx } } } while (jnode != NULL); 111a7a: 85 db test %ebx,%ebx 111a7c: 75 b4 jne 111a32 111a7e: eb 05 jmp 111a85 <== NOT EXECUTED 111a80: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 111a83: eb 02 jmp 111a87 <== NOT EXECUTED 111a85: 31 c0 xor %eax,%eax return 0; } 111a87: 8d 65 f4 lea -0xc(%ebp),%esp 111a8a: 5b pop %ebx 111a8b: 5e pop %esi 111a8c: 5f pop %edi 111a8d: c9 leave 111a8e: c3 ret 0010d834 : 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 ) { 10d834: 55 push %ebp 10d835: 89 e5 mov %esp,%ebp 10d837: 57 push %edi 10d838: 56 push %esi 10d839: 53 push %ebx 10d83a: 83 ec 0c sub $0xc,%esp 10d83d: 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, 10d840: 8b 0d 88 f9 11 00 mov 0x11f988,%ecx 10d846: 31 d2 xor %edx,%edx 10d848: b8 10 00 00 00 mov $0x10,%eax int bit_mask; /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) { 10d84d: 39 c8 cmp %ecx,%eax 10d84f: 74 0d je 10d85e 10d851: d1 e0 shl %eax 10d853: 42 inc %edx 10d854: 83 fa 06 cmp $0x6,%edx 10d857: 75 f4 jne 10d84d 10d859: b8 80 00 00 00 mov $0x80,%eax <== NOT EXECUTED if (bit_mask == requested_bytes_per_block) { is_valid = true; } } *dest_bytes_per_block = ((is_valid) 10d85e: a3 54 36 12 00 mov %eax,0x123654 /* * Create the root node * * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node(); 10d863: e8 11 1e 00 00 call 10f679 10d868: 89 43 1c mov %eax,0x1c(%ebx) temp_mt_entry->mt_fs_root.handlers = directory_handlers; 10d86b: 8b 45 14 mov 0x14(%ebp),%eax 10d86e: 89 43 24 mov %eax,0x24(%ebx) temp_mt_entry->mt_fs_root.ops = op_table; 10d871: 8b 45 0c mov 0xc(%ebp),%eax 10d874: 89 43 28 mov %eax,0x28(%ebx) temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS; 10d877: 8d 7b 38 lea 0x38(%ebx),%edi 10d87a: be 2c db 11 00 mov $0x11db2c,%esi 10d87f: b9 0c 00 00 00 mov $0xc,%ecx 10d884: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Create custom file system data. */ fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) ); 10d886: 50 push %eax 10d887: 50 push %eax 10d888: 6a 0c push $0xc 10d88a: 6a 01 push $0x1 10d88c: e8 4b 02 00 00 call 10dadc if ( !fs_info ) { 10d891: 83 c4 10 add $0x10,%esp 10d894: 85 c0 test %eax,%eax 10d896: 75 1e jne 10d8b6 free(temp_mt_entry->mt_fs_root.node_access); 10d898: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d89b: ff 73 1c pushl 0x1c(%ebx) <== NOT EXECUTED 10d89e: e8 dd 98 ff ff call 107180 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(ENOMEM); 10d8a3: e8 0c 2a 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10d8a8: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10d8ae: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10d8b1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d8b4: eb 26 jmp 10d8dc <== NOT EXECUTED } temp_mt_entry->fs_info = fs_info; 10d8b6: 89 43 34 mov %eax,0x34(%ebx) /* * Set st_ino for the root to 1. */ fs_info->ino_count = 1; 10d8b9: c7 00 01 00 00 00 movl $0x1,(%eax) fs_info->memfile_handlers = memfile_handlers; 10d8bf: 8b 55 10 mov 0x10(%ebp),%edx 10d8c2: 89 50 04 mov %edx,0x4(%eax) fs_info->directory_handlers = directory_handlers; 10d8c5: 8b 55 14 mov 0x14(%ebp),%edx 10d8c8: 89 50 08 mov %edx,0x8(%eax) jnode = temp_mt_entry->mt_fs_root.node_access; jnode->st_ino = fs_info->ino_count; 10d8cb: 8b 43 1c mov 0x1c(%ebx),%eax 10d8ce: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax) /* Initialize POSIX FIFO/pipe module */ rtems_pipe_initialize(); 10d8d5: e8 6c 15 00 00 call 10ee46 10d8da: 31 c0 xor %eax,%eax return 0; } 10d8dc: 8d 65 f4 lea -0xc(%ebp),%esp 10d8df: 5b pop %ebx 10d8e0: 5e pop %esi 10d8e1: 5f pop %edi 10d8e2: c9 leave 10d8e3: c3 ret 00107af0 : int IMFS_link( rtems_filesystem_location_info_t *to_loc, /* IN */ rtems_filesystem_location_info_t *parent_loc, /* IN */ const char *token /* IN */ ) { 107af0: 55 push %ebp 107af1: 89 e5 mov %esp,%ebp 107af3: 57 push %edi 107af4: 53 push %ebx 107af5: 83 ec 50 sub $0x50,%esp 107af8: 8b 55 10 mov 0x10(%ebp),%edx int i; /* * Verify this node can be linked to. */ info.hard_link.link_node = to_loc->node_access; 107afb: 8b 45 08 mov 0x8(%ebp),%eax 107afe: 8b 00 mov (%eax),%eax 107b00: 89 45 d8 mov %eax,-0x28(%ebp) if ( info.hard_link.link_node->st_nlink >= LINK_MAX ) 107b03: 66 83 78 34 07 cmpw $0x7,0x34(%eax) 107b08: 76 0d jbe 107b17 rtems_set_errno_and_return_minus_one( EMLINK ); 107b0a: e8 79 ce 00 00 call 114988 <__errno> 107b0f: c7 00 1f 00 00 00 movl $0x1f,(%eax) 107b15: eb 43 jmp 107b5a /* * Remove any separators at the end of the string. */ IMFS_get_token( token, strlen( token ), new_name, &i ); 107b17: 31 c0 xor %eax,%eax 107b19: 83 c9 ff or $0xffffffff,%ecx 107b1c: 89 d7 mov %edx,%edi 107b1e: f2 ae repnz scas %es:(%edi),%al 107b20: f7 d1 not %ecx 107b22: 49 dec %ecx 107b23: 8d 45 f4 lea -0xc(%ebp),%eax 107b26: 50 push %eax 107b27: 8d 5d b7 lea -0x49(%ebp),%ebx 107b2a: 53 push %ebx 107b2b: 51 push %ecx 107b2c: 52 push %edx 107b2d: e8 ea 9f 00 00 call 111b1c * was ONLY passed a NULL when we created the root node. We * added a new IMFS_create_root_node() so this path no longer * existed. The result was simpler code which should not have * this path. */ new_node = IMFS_create_node( 107b32: 8d 45 d8 lea -0x28(%ebp),%eax 107b35: 89 04 24 mov %eax,(%esp) 107b38: 68 ff a1 00 00 push $0xa1ff 107b3d: 53 push %ebx 107b3e: 6a 03 push $0x3 107b40: ff 75 0c pushl 0xc(%ebp) 107b43: e8 fc 95 00 00 call 111144 new_name, ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if ( !new_node ) 107b48: 83 c4 20 add $0x20,%esp 107b4b: 85 c0 test %eax,%eax 107b4d: 75 10 jne 107b5f rtems_set_errno_and_return_minus_one( ENOMEM ); 107b4f: e8 34 ce 00 00 call 114988 <__errno> <== NOT EXECUTED 107b54: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 107b5a: 83 c8 ff or $0xffffffff,%eax 107b5d: eb 22 jmp 107b81 /* * Increment the link count of the node being pointed to. */ info.hard_link.link_node->st_nlink++; 107b5f: 8b 45 d8 mov -0x28(%ebp),%eax 107b62: 66 ff 40 34 incw 0x34(%eax) IMFS_update_ctime( info.hard_link.link_node ); 107b66: 50 push %eax 107b67: 50 push %eax 107b68: 6a 00 push $0x0 107b6a: 8d 45 ec lea -0x14(%ebp),%eax 107b6d: 50 push %eax 107b6e: e8 f1 07 00 00 call 108364 107b73: 8b 55 ec mov -0x14(%ebp),%edx 107b76: 8b 45 d8 mov -0x28(%ebp),%eax 107b79: 89 50 48 mov %edx,0x48(%eax) 107b7c: 31 c0 xor %eax,%eax return 0; 107b7e: 83 c4 10 add $0x10,%esp } 107b81: 8d 65 f8 lea -0x8(%ebp),%esp 107b84: 5b pop %ebx 107b85: 5f pop %edi 107b86: c9 leave 107b87: c3 ret 00113840 : MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) { 113840: 55 push %ebp 113841: 89 e5 mov %esp,%ebp 113843: 53 push %ebx 113844: 83 ec 04 sub $0x4,%esp 113847: 8b 45 08 mov 0x8(%ebp),%eax block_p memory; block_p *block_entry_ptr; assert( the_jnode ); 11384a: 85 c0 test %eax,%eax 11384c: 75 11 jne 11385f 11384e: 68 78 24 12 00 push $0x122478 <== NOT EXECUTED 113853: 68 1c 26 12 00 push $0x12261c <== NOT EXECUTED 113858: 68 69 01 00 00 push $0x169 <== NOT EXECUTED 11385d: eb 15 jmp 113874 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 11385f: 83 78 4c 05 cmpl $0x5,0x4c(%eax) 113863: 74 19 je 11387e 113865: 68 c8 24 12 00 push $0x1224c8 <== NOT EXECUTED 11386a: 68 1c 26 12 00 push $0x12261c <== NOT EXECUTED 11386f: 68 6d 01 00 00 push $0x16d <== NOT EXECUTED 113874: 68 82 24 12 00 push $0x122482 <== NOT EXECUTED 113879: e8 42 47 ff ff call 107fc0 <__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 ); 11387e: 52 push %edx 11387f: 6a 01 push $0x1 113881: ff 75 0c pushl 0xc(%ebp) 113884: 50 push %eax 113885: e8 84 fb ff ff call 11340e 11388a: 89 c3 mov %eax,%ebx if ( *block_entry_ptr ) 11388c: 83 c4 10 add $0x10,%esp 11388f: 31 c0 xor %eax,%eax 113891: 83 3b 00 cmpl $0x0,(%ebx) 113894: 75 14 jne 1138aa #if 0 fprintf(stdout, "%d %p", block, block_entry_ptr ); fflush(stdout); #endif memory = memfile_alloc_block(); 113896: e8 51 fb ff ff call 1133ec 11389b: 89 c2 mov %eax,%edx if ( !memory ) 11389d: b8 01 00 00 00 mov $0x1,%eax 1138a2: 85 d2 test %edx,%edx 1138a4: 74 04 je 1138aa return 1; *block_entry_ptr = memory; 1138a6: 89 13 mov %edx,(%ebx) 1138a8: 30 c0 xor %al,%al return 0; } 1138aa: 8b 5d fc mov -0x4(%ebp),%ebx 1138ad: c9 leave 1138ae: c3 ret 001138af : MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) { 1138af: 55 push %ebp 1138b0: 89 e5 mov %esp,%ebp 1138b2: 57 push %edi 1138b3: 56 push %esi 1138b4: 53 push %ebx 1138b5: 83 ec 2c sub $0x2c,%esp 1138b8: 8b 5d 08 mov 0x8(%ebp),%ebx 1138bb: 8b 75 0c mov 0xc(%ebp),%esi 1138be: 8b 7d 10 mov 0x10(%ebp),%edi /* * Perform internal consistency checks */ assert( the_jnode ); 1138c1: 85 db test %ebx,%ebx 1138c3: 75 11 jne 1138d6 1138c5: 68 78 24 12 00 push $0x122478 <== NOT EXECUTED 1138ca: 68 34 26 12 00 push $0x122634 <== NOT EXECUTED 1138cf: 68 31 01 00 00 push $0x131 <== NOT EXECUTED 1138d4: eb 15 jmp 1138eb <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 1138d6: 83 7b 4c 05 cmpl $0x5,0x4c(%ebx) 1138da: 74 19 je 1138f5 1138dc: 68 c8 24 12 00 push $0x1224c8 <== NOT EXECUTED 1138e1: 68 34 26 12 00 push $0x122634 <== NOT EXECUTED 1138e6: 68 35 01 00 00 push $0x135 <== NOT EXECUTED 1138eb: 68 82 24 12 00 push $0x122482 <== NOT EXECUTED 1138f0: e8 cb 46 ff ff call 107fc0 <__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 ) 1138f5: a1 1c 80 12 00 mov 0x12801c,%eax 1138fa: 89 c1 mov %eax,%ecx 1138fc: c1 e9 02 shr $0x2,%ecx 1138ff: 8d 51 01 lea 0x1(%ecx),%edx 113902: 0f af d1 imul %ecx,%edx 113905: 42 inc %edx 113906: 0f af d1 imul %ecx,%edx 113909: 4a dec %edx 11390a: 0f af d0 imul %eax,%edx 11390d: 83 ff 00 cmp $0x0,%edi 113910: 7c 16 jl 113928 113912: 7f 04 jg 113918 113914: 39 d6 cmp %edx,%esi 113916: 72 10 jb 113928 rtems_set_errno_and_return_minus_one( EINVAL ); 113918: e8 6b 10 00 00 call 114988 <__errno> <== NOT EXECUTED 11391d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 113923: e9 92 00 00 00 jmp 1139ba <== NOT EXECUTED if ( new_length <= the_jnode->info.file.size ) 113928: 8b 53 50 mov 0x50(%ebx),%edx 11392b: 8b 4b 54 mov 0x54(%ebx),%ecx 11392e: 89 55 e0 mov %edx,-0x20(%ebp) 113931: 89 4d e4 mov %ecx,-0x1c(%ebp) 113934: 39 cf cmp %ecx,%edi 113936: 7f 0e jg 113946 113938: 0f 8c 8d 00 00 00 jl 1139cb 11393e: 39 d6 cmp %edx,%esi 113940: 0f 86 85 00 00 00 jbe 1139cb /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; 113946: 89 45 d8 mov %eax,-0x28(%ebp) 113949: 89 c1 mov %eax,%ecx 11394b: c1 f9 1f sar $0x1f,%ecx 11394e: 89 4d dc mov %ecx,-0x24(%ebp) 113951: ff 75 dc pushl -0x24(%ebp) 113954: ff 75 d8 pushl -0x28(%ebp) 113957: 57 push %edi 113958: 56 push %esi 113959: e8 5e c0 00 00 call 11f9bc <__divdi3> 11395e: 83 c4 10 add $0x10,%esp 113961: 89 45 d4 mov %eax,-0x2c(%ebp) old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; 113964: ff 75 dc pushl -0x24(%ebp) 113967: ff 75 d8 pushl -0x28(%ebp) 11396a: ff 75 e4 pushl -0x1c(%ebp) 11396d: ff 75 e0 pushl -0x20(%ebp) 113970: e8 47 c0 00 00 call 11f9bc <__divdi3> 113975: 83 c4 10 add $0x10,%esp 113978: 89 45 e0 mov %eax,-0x20(%ebp) 11397b: 89 c2 mov %eax,%edx /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 11397d: eb 41 jmp 1139c0 if ( IMFS_memfile_addblock( the_jnode, block ) ) { 11397f: 50 push %eax 113980: 50 push %eax 113981: 52 push %edx 113982: 53 push %ebx 113983: 89 55 d0 mov %edx,-0x30(%ebp) 113986: e8 b5 fe ff ff call 113840 11398b: 83 c4 10 add $0x10,%esp 11398e: 85 c0 test %eax,%eax 113990: 8b 55 d0 mov -0x30(%ebp),%edx 113993: 74 2a je 1139bf 113995: eb 13 jmp 1139aa <== NOT EXECUTED for ( ; block>=old_blocks ; block-- ) { IMFS_memfile_remove_block( the_jnode, block ); 113997: 51 push %ecx <== NOT EXECUTED 113998: 51 push %ecx <== NOT EXECUTED 113999: 52 push %edx <== NOT EXECUTED 11399a: 53 push %ebx <== NOT EXECUTED 11399b: 89 55 d0 mov %edx,-0x30(%ebp) <== NOT EXECUTED 11399e: e8 5c fc ff ff call 1135ff <== 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-- ) { 1139a3: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 1139a6: 4a dec %edx <== NOT EXECUTED 1139a7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1139aa: 3b 55 e0 cmp -0x20(%ebp),%edx <== NOT EXECUTED 1139ad: 73 e8 jae 113997 <== NOT EXECUTED IMFS_memfile_remove_block( the_jnode, block ); } rtems_set_errno_and_return_minus_one( ENOSPC ); 1139af: e8 d4 0f 00 00 call 114988 <__errno> <== NOT EXECUTED 1139b4: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 1139ba: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1139bd: eb 0e jmp 1139cd <== NOT EXECUTED /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 1139bf: 42 inc %edx 1139c0: 3b 55 d4 cmp -0x2c(%ebp),%edx 1139c3: 76 ba jbe 11397f /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; 1139c5: 89 73 50 mov %esi,0x50(%ebx) 1139c8: 89 7b 54 mov %edi,0x54(%ebx) 1139cb: 31 c0 xor %eax,%eax return 0; } 1139cd: 8d 65 f4 lea -0xc(%ebp),%esp 1139d0: 5b pop %ebx 1139d1: 5e pop %esi 1139d2: 5f pop %edi 1139d3: c9 leave 1139d4: c3 ret 0011340e : #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) { 11340e: 55 push %ebp 11340f: 89 e5 mov %esp,%ebp 113411: 57 push %edi 113412: 56 push %esi 113413: 53 push %ebx 113414: 83 ec 1c sub $0x1c,%esp 113417: 8b 5d 08 mov 0x8(%ebp),%ebx 11341a: 8b 7d 0c mov 0xc(%ebp),%edi 11341d: 8b 75 10 mov 0x10(%ebp),%esi /* * Perform internal consistency checks */ assert( the_jnode ); 113420: 85 db test %ebx,%ebx 113422: 75 11 jne 113435 113424: 68 78 24 12 00 push $0x122478 <== NOT EXECUTED 113429: 68 84 25 12 00 push $0x122584 <== NOT EXECUTED 11342e: 68 88 03 00 00 push $0x388 <== NOT EXECUTED 113433: eb 15 jmp 11344a <== NOT EXECUTED if ( !the_jnode ) return NULL; assert( the_jnode->type == IMFS_MEMORY_FILE ); 113435: 83 7b 4c 05 cmpl $0x5,0x4c(%ebx) 113439: 74 19 je 113454 11343b: 68 c8 24 12 00 push $0x1224c8 <== NOT EXECUTED 113440: 68 84 25 12 00 push $0x122584 <== NOT EXECUTED 113445: 68 8c 03 00 00 push $0x38c <== NOT EXECUTED 11344a: 68 82 24 12 00 push $0x122482 <== NOT EXECUTED 11344f: e8 6c 4b ff ff call 107fc0 <__assert_func> <== NOT EXECUTED /* * Is the block number in the simple indirect portion? */ if ( my_block <= LAST_INDIRECT ) { 113454: 8b 0d 1c 80 12 00 mov 0x12801c,%ecx 11345a: c1 e9 02 shr $0x2,%ecx 11345d: 8d 41 ff lea -0x1(%ecx),%eax 113460: 39 c7 cmp %eax,%edi 113462: 77 2f ja 113493 #if 0 fprintf(stdout, "(s %d) ", block ); fflush(stdout); #endif p = info->indirect; 113464: 8b 53 58 mov 0x58(%ebx),%edx if ( malloc_it ) { 113467: 85 f6 test %esi,%esi 113469: 74 23 je 11348e if ( !p ) { 11346b: 85 d2 test %edx,%edx 11346d: 75 10 jne 11347f p = memfile_alloc_block(); 11346f: e8 78 ff ff ff call 1133ec if ( !p ) 113474: 85 c0 test %eax,%eax 113476: 0f 84 0f 01 00 00 je 11358b return 0; info->indirect = p; 11347c: 89 43 58 mov %eax,0x58(%ebx) } return &info->indirect[ my_block ]; 11347f: 8d 04 bd 00 00 00 00 lea 0x0(,%edi,4),%eax 113486: 03 43 58 add 0x58(%ebx),%eax 113489: e9 ff 00 00 00 jmp 11358d } if ( !p ) return 0; return &info->indirect[ my_block ]; 11348e: 8d 04 ba lea (%edx,%edi,4),%eax 113491: eb 69 jmp 1134fc /* * Is the block number in the doubly indirect portion? */ if ( my_block <= LAST_DOUBLY_INDIRECT ) { 113493: 8d 41 01 lea 0x1(%ecx),%eax <== NOT EXECUTED 113496: 0f af c1 imul %ecx,%eax <== NOT EXECUTED 113499: 8d 50 ff lea -0x1(%eax),%edx <== NOT EXECUTED 11349c: 39 d7 cmp %edx,%edi <== NOT EXECUTED 11349e: 77 69 ja 113509 <== NOT EXECUTED #if 0 fprintf(stdout, "(d %d) ", block ); fflush(stdout); #endif my_block -= FIRST_DOUBLY_INDIRECT; 1134a0: 29 cf sub %ecx,%edi <== NOT EXECUTED singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 1134a2: 89 f8 mov %edi,%eax <== NOT EXECUTED 1134a4: 31 d2 xor %edx,%edx <== NOT EXECUTED 1134a6: f7 f1 div %ecx <== NOT EXECUTED 1134a8: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED 1134ab: 89 c7 mov %eax,%edi <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; p = info->doubly_indirect; 1134ad: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED if ( malloc_it ) { 1134b0: 85 f6 test %esi,%esi <== NOT EXECUTED 1134b2: 74 37 je 1134eb <== NOT EXECUTED if ( !p ) { 1134b4: 85 c0 test %eax,%eax <== NOT EXECUTED 1134b6: 75 10 jne 1134c8 <== NOT EXECUTED p = memfile_alloc_block(); 1134b8: e8 2f ff ff ff call 1133ec <== NOT EXECUTED if ( !p ) 1134bd: 85 c0 test %eax,%eax <== NOT EXECUTED 1134bf: 0f 84 c6 00 00 00 je 11358b <== NOT EXECUTED return 0; info->doubly_indirect = p; 1134c5: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED } p1 = (block_p *)p[ doubly ]; 1134c8: 8d 1c b8 lea (%eax,%edi,4),%ebx <== NOT EXECUTED 1134cb: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p1 ) { 1134cd: 85 c0 test %eax,%eax <== NOT EXECUTED 1134cf: 75 0f jne 1134e0 <== NOT EXECUTED p1 = memfile_alloc_block(); 1134d1: e8 16 ff ff ff call 1133ec <== NOT EXECUTED if ( !p1 ) 1134d6: 85 c0 test %eax,%eax <== NOT EXECUTED 1134d8: 0f 84 ad 00 00 00 je 11358b <== NOT EXECUTED return 0; p[ doubly ] = (block_p) p1; 1134de: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } return (block_p *)&p1[ singly ]; 1134e0: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 1134e3: 8d 04 88 lea (%eax,%ecx,4),%eax <== NOT EXECUTED 1134e6: e9 a2 00 00 00 jmp 11358d <== NOT EXECUTED } if ( !p ) 1134eb: 85 c0 test %eax,%eax <== NOT EXECUTED 1134ed: 0f 84 98 00 00 00 je 11358b <== NOT EXECUTED return 0; p = (block_p *)p[ doubly ]; 1134f3: 8b 14 b8 mov (%eax,%edi,4),%edx <== 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 ]; 1134f6: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 1134f9: 8d 04 8a lea (%edx,%ecx,4),%eax <== NOT EXECUTED if ( !p ) return 0; p = (block_p *)p[ doubly ]; if ( !p ) 1134fc: 85 d2 test %edx,%edx 1134fe: 0f 85 89 00 00 00 jne 11358d 113504: e9 82 00 00 00 jmp 11358b <== NOT EXECUTED #endif /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 113509: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED 11350c: 0f af d1 imul %ecx,%edx <== NOT EXECUTED 11350f: 4a dec %edx <== NOT EXECUTED 113510: 39 d7 cmp %edx,%edi <== NOT EXECUTED 113512: 77 77 ja 11358b <== NOT EXECUTED my_block -= FIRST_TRIPLY_INDIRECT; 113514: 29 c7 sub %eax,%edi <== NOT EXECUTED 113516: 89 f8 mov %edi,%eax <== NOT EXECUTED singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 113518: 31 d2 xor %edx,%edx <== NOT EXECUTED 11351a: f7 f1 div %ecx <== NOT EXECUTED 11351c: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; 11351f: 31 d2 xor %edx,%edx <== NOT EXECUTED 113521: f7 f1 div %ecx <== NOT EXECUTED 113523: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED 113526: 89 c7 mov %eax,%edi <== NOT EXECUTED doubly %= IMFS_MEMFILE_BLOCK_SLOTS; p = info->triply_indirect; 113528: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED if ( malloc_it ) { 11352b: 85 f6 test %esi,%esi <== NOT EXECUTED 11352d: 74 43 je 113572 <== NOT EXECUTED if ( !p ) { 11352f: 85 c0 test %eax,%eax <== NOT EXECUTED 113531: 75 0c jne 11353f <== NOT EXECUTED p = memfile_alloc_block(); 113533: e8 b4 fe ff ff call 1133ec <== NOT EXECUTED if ( !p ) 113538: 85 c0 test %eax,%eax <== NOT EXECUTED 11353a: 74 4f je 11358b <== NOT EXECUTED return 0; info->triply_indirect = p; 11353c: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED } p1 = (block_p *) p[ triply ]; 11353f: 8d 1c b8 lea (%eax,%edi,4),%ebx <== NOT EXECUTED 113542: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p1 ) { 113544: 85 c0 test %eax,%eax <== NOT EXECUTED 113546: 75 0b jne 113553 <== NOT EXECUTED p1 = memfile_alloc_block(); 113548: e8 9f fe ff ff call 1133ec <== NOT EXECUTED if ( !p1 ) 11354d: 85 c0 test %eax,%eax <== NOT EXECUTED 11354f: 74 3a je 11358b <== NOT EXECUTED return 0; p[ triply ] = (block_p) p1; 113551: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } p2 = (block_p *)p1[ doubly ]; 113553: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED 113556: 8d 1c 88 lea (%eax,%ecx,4),%ebx <== NOT EXECUTED 113559: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p2 ) { 11355b: 85 c0 test %eax,%eax <== NOT EXECUTED 11355d: 75 0b jne 11356a <== NOT EXECUTED p2 = memfile_alloc_block(); 11355f: e8 88 fe ff ff call 1133ec <== NOT EXECUTED if ( !p2 ) 113564: 85 c0 test %eax,%eax <== NOT EXECUTED 113566: 74 23 je 11358b <== NOT EXECUTED return 0; p1[ doubly ] = (block_p) p2; 113568: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } return (block_p *)&p2[ singly ]; 11356a: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 11356d: 8d 04 90 lea (%eax,%edx,4),%eax <== NOT EXECUTED 113570: eb 1b jmp 11358d <== NOT EXECUTED } if ( !p ) 113572: 85 c0 test %eax,%eax <== NOT EXECUTED 113574: 74 15 je 11358b <== 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 ]; 113576: 8b 14 b8 mov (%eax,%edi,4),%edx <== NOT EXECUTED if ( !p1 ) 113579: 85 d2 test %edx,%edx <== NOT EXECUTED 11357b: 74 0e je 11358b <== NOT EXECUTED p2 = (block_p *)p1[ doubly ]; if ( !p ) return 0; return (block_p *)&p2[ singly ]; 11357d: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 113580: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 113583: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED 113586: 03 04 8a add (%edx,%ecx,4),%eax <== NOT EXECUTED 113589: eb 02 jmp 11358d <== NOT EXECUTED 11358b: 31 c0 xor %eax,%eax <== NOT EXECUTED /* * This means the requested block number is out of range. */ return 0; } 11358d: 8d 65 f4 lea -0xc(%ebp),%esp 113590: 5b pop %ebx 113591: 5e pop %esi 113592: 5f pop %edi 113593: c9 leave 113594: c3 ret 00113d46 : IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) { 113d46: 55 push %ebp 113d47: 89 e5 mov %esp,%ebp 113d49: 57 push %edi 113d4a: 56 push %esi 113d4b: 53 push %ebx 113d4c: 83 ec 3c sub $0x3c,%esp 113d4f: 8b 75 0c mov 0xc(%ebp),%esi 113d52: 8b 7d 10 mov 0x10(%ebp),%edi /* * Perform internal consistency checks */ assert( the_jnode ); 113d55: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 113d59: 75 11 jne 113d6c 113d5b: 68 78 24 12 00 push $0x122478 <== NOT EXECUTED 113d60: 68 b8 25 12 00 push $0x1225b8 <== NOT EXECUTED 113d65: 68 4c 02 00 00 push $0x24c <== NOT EXECUTED 113d6a: eb 1d jmp 113d89 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE || 113d6c: 8b 55 08 mov 0x8(%ebp),%edx 113d6f: 8b 42 4c mov 0x4c(%edx),%eax 113d72: 8d 48 fb lea -0x5(%eax),%ecx 113d75: 83 f9 01 cmp $0x1,%ecx 113d78: 76 19 jbe 113d93 113d7a: 68 32 25 12 00 push $0x122532 <== NOT EXECUTED 113d7f: 68 b8 25 12 00 push $0x1225b8 <== NOT EXECUTED 113d84: 68 51 02 00 00 push $0x251 <== NOT EXECUTED 113d89: 68 82 24 12 00 push $0x122482 <== NOT EXECUTED 113d8e: e8 2d 42 ff ff call 107fc0 <__assert_func> <== NOT EXECUTED /* * Error checks on arguments */ assert( dest ); 113d93: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 113d97: 75 11 jne 113daa 113d99: 68 7d 25 12 00 push $0x12257d <== NOT EXECUTED 113d9e: 68 b8 25 12 00 push $0x1225b8 <== NOT EXECUTED 113da3: 68 5a 02 00 00 push $0x25a <== NOT EXECUTED 113da8: eb df jmp 113d89 <== NOT EXECUTED /* * If there is nothing to read, then quick exit. */ my_length = length; if ( !my_length ) 113daa: 83 7d 18 00 cmpl $0x0,0x18(%ebp) 113dae: 75 13 jne 113dc3 rtems_set_errno_and_return_minus_one( EINVAL ); 113db0: e8 d3 0b 00 00 call 114988 <__errno> <== NOT EXECUTED 113db5: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 113dbb: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 113dbe: e9 d0 01 00 00 jmp 113f93 <== NOT EXECUTED /* * Linear files (as created from a tar file are easier to handle * than block files). */ if (the_jnode->type == IMFS_LINEAR_FILE) { 113dc3: 83 f8 06 cmp $0x6,%eax 113dc6: 75 64 jne 113e2c unsigned char *file_ptr; file_ptr = (unsigned char *)the_jnode->info.linearfile.direct; 113dc8: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 113dcb: 8b 49 58 mov 0x58(%ecx),%ecx <== NOT EXECUTED 113dce: 89 4d c8 mov %ecx,-0x38(%ebp) <== NOT EXECUTED if (my_length > (the_jnode->info.linearfile.size - start)) 113dd1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 113dd4: 8b 48 50 mov 0x50(%eax),%ecx <== NOT EXECUTED 113dd7: 8b 58 54 mov 0x54(%eax),%ebx <== NOT EXECUTED 113dda: 89 c8 mov %ecx,%eax <== NOT EXECUTED 113ddc: 89 da mov %ebx,%edx <== NOT EXECUTED 113dde: 29 f0 sub %esi,%eax <== NOT EXECUTED 113de0: 19 fa sbb %edi,%edx <== NOT EXECUTED 113de2: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 113de5: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED 113de8: 31 c0 xor %eax,%eax <== NOT EXECUTED 113dea: 39 d0 cmp %edx,%eax <== NOT EXECUTED 113dec: 7f 0f jg 113dfd <== NOT EXECUTED 113dee: 7c 08 jl 113df8 <== NOT EXECUTED 113df0: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 113df3: 39 55 18 cmp %edx,0x18(%ebp) <== NOT EXECUTED 113df6: 77 05 ja 113dfd <== NOT EXECUTED 113df8: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 113dfb: eb 04 jmp 113e01 <== NOT EXECUTED my_length = the_jnode->info.linearfile.size - start; 113dfd: 89 ca mov %ecx,%edx <== NOT EXECUTED 113dff: 29 f2 sub %esi,%edx <== NOT EXECUTED memcpy(dest, &file_ptr[start], my_length); 113e01: 03 75 c8 add -0x38(%ebp),%esi <== NOT EXECUTED 113e04: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 113e07: 89 d1 mov %edx,%ecx <== NOT EXECUTED 113e09: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED IMFS_update_atime( the_jnode ); 113e0b: 51 push %ecx <== NOT EXECUTED 113e0c: 51 push %ecx <== NOT EXECUTED 113e0d: 6a 00 push $0x0 <== NOT EXECUTED 113e0f: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 113e12: 50 push %eax <== NOT EXECUTED 113e13: 89 55 c0 mov %edx,-0x40(%ebp) <== NOT EXECUTED 113e16: e8 49 45 ff ff call 108364 <== NOT EXECUTED 113e1b: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 113e1e: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 113e21: 89 41 40 mov %eax,0x40(%ecx) <== NOT EXECUTED return my_length; 113e24: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED 113e27: e9 64 01 00 00 jmp 113f90 <== 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; 113e2c: 89 f0 mov %esi,%eax if ( last_byte > the_jnode->info.file.size ) 113e2e: 8b 55 08 mov 0x8(%ebp),%edx 113e31: 8b 5a 50 mov 0x50(%edx),%ebx 113e34: 8b 4d 18 mov 0x18(%ebp),%ecx 113e37: 01 f1 add %esi,%ecx 113e39: 89 4d d0 mov %ecx,-0x30(%ebp) 113e3c: 31 c9 xor %ecx,%ecx 113e3e: 3b 4a 54 cmp 0x54(%edx),%ecx 113e41: 7f 0f jg 113e52 113e43: 7c 05 jl 113e4a 113e45: 39 5d d0 cmp %ebx,-0x30(%ebp) 113e48: 77 08 ja 113e52 113e4a: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 113e4d: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 113e50: eb 05 jmp 113e57 <== NOT EXECUTED my_length = the_jnode->info.file.size - start; 113e52: 29 c3 sub %eax,%ebx 113e54: 89 5d d0 mov %ebx,-0x30(%ebp) /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 113e57: 8b 15 1c 80 12 00 mov 0x12801c,%edx 113e5d: 89 55 c4 mov %edx,-0x3c(%ebp) 113e60: 89 d0 mov %edx,%eax 113e62: 99 cltd 113e63: 89 d3 mov %edx,%ebx 113e65: 52 push %edx 113e66: 50 push %eax 113e67: 57 push %edi 113e68: 56 push %esi 113e69: 89 45 c0 mov %eax,-0x40(%ebp) 113e6c: e8 9b bc 00 00 call 11fb0c <__moddi3> 113e71: 83 c4 10 add $0x10,%esp 113e74: 89 45 c8 mov %eax,-0x38(%ebp) block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 113e77: 8b 4d c0 mov -0x40(%ebp),%ecx 113e7a: 53 push %ebx 113e7b: 51 push %ecx 113e7c: 57 push %edi 113e7d: 56 push %esi 113e7e: e8 39 bb 00 00 call 11f9bc <__divdi3> 113e83: 83 c4 10 add $0x10,%esp 113e86: 89 c3 mov %eax,%ebx if ( start_offset ) { 113e88: 83 7d c8 00 cmpl $0x0,-0x38(%ebp) 113e8c: 75 0f jne 113e9d 113e8e: 8b 55 14 mov 0x14(%ebp),%edx 113e91: 89 55 c8 mov %edx,-0x38(%ebp) 113e94: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) 113e9b: eb 4c jmp 113ee9 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 ); 113e9d: 50 push %eax 113e9e: 6a 00 push $0x0 113ea0: 53 push %ebx 113ea1: ff 75 08 pushl 0x8(%ebp) 113ea4: e8 65 f5 ff ff call 11340e assert( block_ptr ); 113ea9: 83 c4 10 add $0x10,%esp 113eac: 85 c0 test %eax,%eax 113eae: 75 14 jne 113ec4 113eb0: 68 f8 24 12 00 push $0x1224f8 <== NOT EXECUTED 113eb5: 68 b8 25 12 00 push $0x1225b8 <== NOT EXECUTED 113eba: 68 96 02 00 00 push $0x296 <== NOT EXECUTED 113ebf: e9 c5 fe ff ff jmp 113d89 <== 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; 113ec4: 8b 4d c4 mov -0x3c(%ebp),%ecx 113ec7: 2b 4d c8 sub -0x38(%ebp),%ecx 113eca: 8b 55 d0 mov -0x30(%ebp),%edx 113ecd: 39 ca cmp %ecx,%edx 113ecf: 76 02 jbe 113ed3 113ed1: 89 ca mov %ecx,%edx 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 ); 113ed3: 8b 75 c8 mov -0x38(%ebp),%esi 113ed6: 03 30 add (%eax),%esi dest += to_copy; 113ed8: 8b 7d 14 mov 0x14(%ebp),%edi 113edb: 89 d1 mov %edx,%ecx 113edd: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 113edf: 89 7d c8 mov %edi,-0x38(%ebp) block++; 113ee2: 43 inc %ebx my_length -= to_copy; 113ee3: 29 55 d0 sub %edx,-0x30(%ebp) 113ee6: 89 55 cc mov %edx,-0x34(%ebp) /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 113ee9: 8b 15 1c 80 12 00 mov 0x12801c,%edx while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 113eef: eb 40 jmp 113f31 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 113ef1: 57 push %edi 113ef2: 6a 00 push $0x0 113ef4: 53 push %ebx 113ef5: ff 75 08 pushl 0x8(%ebp) 113ef8: 89 55 c0 mov %edx,-0x40(%ebp) 113efb: e8 0e f5 ff ff call 11340e assert( block_ptr ); 113f00: 83 c4 10 add $0x10,%esp 113f03: 85 c0 test %eax,%eax 113f05: 8b 55 c0 mov -0x40(%ebp),%edx 113f08: 75 14 jne 113f1e 113f0a: 68 f8 24 12 00 push $0x1224f8 <== NOT EXECUTED 113f0f: 68 b8 25 12 00 push $0x1225b8 <== NOT EXECUTED 113f14: 68 a7 02 00 00 push $0x2a7 <== NOT EXECUTED 113f19: e9 6b fe ff ff jmp 113d89 <== NOT EXECUTED if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); 113f1e: 8b 30 mov (%eax),%esi 113f20: 8b 7d c8 mov -0x38(%ebp),%edi 113f23: 89 d1 mov %edx,%ecx 113f25: f3 a4 rep movsb %ds:(%esi),%es:(%edi) dest += to_copy; 113f27: 89 7d c8 mov %edi,-0x38(%ebp) block++; 113f2a: 43 inc %ebx my_length -= to_copy; 113f2b: 29 55 d0 sub %edx,-0x30(%ebp) copied += to_copy; 113f2e: 01 55 cc add %edx,-0x34(%ebp) /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 113f31: 8b 45 d0 mov -0x30(%ebp),%eax 113f34: 3b 05 1c 80 12 00 cmp 0x12801c,%eax 113f3a: 73 b5 jae 113ef1 * Phase 3: possibly the first part of one block */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { 113f3c: 85 c0 test %eax,%eax 113f3e: 74 37 je 113f77 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 113f40: 56 push %esi 113f41: 6a 00 push $0x0 113f43: 53 push %ebx 113f44: ff 75 08 pushl 0x8(%ebp) 113f47: e8 c2 f4 ff ff call 11340e assert( block_ptr ); 113f4c: 83 c4 10 add $0x10,%esp 113f4f: 85 c0 test %eax,%eax 113f51: 75 14 jne 113f67 113f53: 68 f8 24 12 00 push $0x1224f8 <== NOT EXECUTED 113f58: 68 b8 25 12 00 push $0x1225b8 <== NOT EXECUTED 113f5d: 68 b9 02 00 00 push $0x2b9 <== NOT EXECUTED 113f62: e9 22 fe ff ff jmp 113d89 <== NOT EXECUTED if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); 113f67: 8b 30 mov (%eax),%esi 113f69: 8b 7d c8 mov -0x38(%ebp),%edi 113f6c: 8b 4d d0 mov -0x30(%ebp),%ecx 113f6f: f3 a4 rep movsb %ds:(%esi),%es:(%edi) copied += my_length; 113f71: 8b 55 d0 mov -0x30(%ebp),%edx 113f74: 01 55 cc add %edx,-0x34(%ebp) } IMFS_update_atime( the_jnode ); 113f77: 53 push %ebx 113f78: 53 push %ebx 113f79: 6a 00 push $0x0 113f7b: 8d 45 e0 lea -0x20(%ebp),%eax 113f7e: 50 push %eax 113f7f: e8 e0 43 ff ff call 108364 113f84: 8b 45 e0 mov -0x20(%ebp),%eax 113f87: 8b 4d 08 mov 0x8(%ebp),%ecx 113f8a: 89 41 40 mov %eax,0x40(%ecx) return copied; 113f8d: 8b 55 cc mov -0x34(%ebp),%edx 113f90: 83 c4 10 add $0x10,%esp } 113f93: 89 d0 mov %edx,%eax 113f95: 8d 65 f4 lea -0xc(%ebp),%esp 113f98: 5b pop %ebx 113f99: 5e pop %esi 113f9a: 5f pop %edi 113f9b: c9 leave 113f9c: c3 ret 0011364a : */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) { 11364a: 55 push %ebp 11364b: 89 e5 mov %esp,%ebp 11364d: 57 push %edi 11364e: 56 push %esi 11364f: 53 push %ebx 113650: 83 ec 1c sub $0x1c,%esp 113653: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Perform internal consistency checks */ assert( the_jnode ); 113656: 85 db test %ebx,%ebx 113658: 75 11 jne 11366b 11365a: 68 78 24 12 00 push $0x122478 <== NOT EXECUTED 11365f: 68 cc 25 12 00 push $0x1225cc <== NOT EXECUTED 113664: 68 ee 01 00 00 push $0x1ee <== NOT EXECUTED 113669: eb 15 jmp 113680 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 11366b: 83 7b 4c 05 cmpl $0x5,0x4c(%ebx) 11366f: 74 19 je 11368a 113671: 68 c8 24 12 00 push $0x1224c8 <== NOT EXECUTED 113676: 68 cc 25 12 00 push $0x1225cc <== NOT EXECUTED 11367b: 68 f2 01 00 00 push $0x1f2 <== NOT EXECUTED 113680: 68 82 24 12 00 push $0x122482 <== NOT EXECUTED 113685: e8 36 49 ff ff call 107fc0 <__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; 11368a: 8b 35 1c 80 12 00 mov 0x12801c,%esi 113690: c1 ee 02 shr $0x2,%esi * + indirect * + doubly indirect * + triply indirect */ info = &the_jnode->info.file; 113693: 83 7b 58 00 cmpl $0x0,0x58(%ebx) 113697: 74 0f je 1136a8 if ( info->indirect ) { memfile_free_blocks_in_table( &info->indirect, to_free ); 113699: 57 push %edi 11369a: 57 push %edi 11369b: 56 push %esi 11369c: 8d 43 58 lea 0x58(%ebx),%eax 11369f: 50 push %eax 1136a0: e8 f0 fe ff ff call 113595 1136a5: 83 c4 10 add $0x10,%esp * + indirect * + doubly indirect * + triply indirect */ info = &the_jnode->info.file; 1136a8: 31 ff xor %edi,%edi 1136aa: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx) 1136ae: 75 21 jne 1136d1 1136b0: eb 3a jmp 1136ec } if ( info->doubly_indirect ) { for ( i=0 ; idoubly_indirect[i] ) { 1136b2: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED 1136b5: 8d 14 bd 00 00 00 00 lea 0x0(,%edi,4),%edx <== NOT EXECUTED 1136bc: 83 3c b8 00 cmpl $0x0,(%eax,%edi,4) <== NOT EXECUTED 1136c0: 74 0e je 1136d0 <== NOT EXECUTED memfile_free_blocks_in_table( 1136c2: 51 push %ecx <== NOT EXECUTED 1136c3: 51 push %ecx <== NOT EXECUTED 1136c4: 56 push %esi <== NOT EXECUTED 1136c5: 01 d0 add %edx,%eax <== NOT EXECUTED 1136c7: 50 push %eax <== NOT EXECUTED 1136c8: e8 c8 fe ff ff call 113595 <== NOT EXECUTED 1136cd: 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 ); 1136dd: 57 push %edi <== NOT EXECUTED 1136de: 57 push %edi <== NOT EXECUTED 1136df: 56 push %esi <== NOT EXECUTED 1136e0: 8d 43 5c lea 0x5c(%ebx),%eax <== NOT EXECUTED 1136e3: 50 push %eax <== NOT EXECUTED 1136e4: e8 ac fe ff ff call 113595 <== NOT EXECUTED 1136e9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * + indirect * + doubly indirect * + triply indirect */ info = &the_jnode->info.file; 1136ec: 31 ff xor %edi,%edi 1136ee: 83 7b 60 00 cmpl $0x0,0x60(%ebx) 1136f2: 75 5b jne 11374f 1136f4: eb 74 jmp 11376a 1136f6: 8d 04 bd 00 00 00 00 lea 0x0(,%edi,4),%eax <== NOT EXECUTED 1136fd: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED } if ( info->triply_indirect ) { for ( i=0 ; itriply_indirect[i]; 113700: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED 113703: 8b 04 b8 mov (%eax,%edi,4),%eax <== NOT EXECUTED if ( !p ) /* ensure we have a valid pointer */ 113706: 85 c0 test %eax,%eax <== NOT EXECUTED 113708: 74 51 je 11375b <== NOT EXECUTED 11370a: 31 d2 xor %edx,%edx <== NOT EXECUTED 11370c: eb 21 jmp 11372f <== NOT EXECUTED break; for ( j=0 ; j <== NOT EXECUTED memfile_free_blocks_in_table( (block_p **)&p[j], to_free); 113713: 51 push %ecx <== NOT EXECUTED 113714: 51 push %ecx <== NOT EXECUTED 113715: 56 push %esi <== NOT EXECUTED 113716: 50 push %eax <== NOT EXECUTED 113717: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 11371a: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED 11371d: e8 73 fe ff ff call 113595 <== NOT EXECUTED 113722: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113725: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 113728: 8b 45 e0 mov -0x20(%ebp),%eax <== 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( 11373c: 52 push %edx <== NOT EXECUTED 11373d: 52 push %edx <== NOT EXECUTED 11373e: 56 push %esi <== NOT EXECUTED 11373f: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 113742: 03 43 60 add 0x60(%ebx),%eax <== NOT EXECUTED 113745: 50 push %eax <== NOT EXECUTED 113746: e8 4a fe ff ff call 113595 <== 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( 11375b: 50 push %eax <== NOT EXECUTED 11375c: 50 push %eax <== NOT EXECUTED 11375d: 56 push %esi <== NOT EXECUTED 11375e: 83 c3 60 add $0x60,%ebx <== NOT EXECUTED 113761: 53 push %ebx <== NOT EXECUTED 113762: e8 2e fe ff ff call 113595 <== NOT EXECUTED 113767: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (block_p **)&info->triply_indirect, to_free ); } return 0; } 11376a: 31 c0 xor %eax,%eax 11376c: 8d 65 f4 lea -0xc(%ebp),%esp 11376f: 5b pop %ebx 113770: 5e pop %esi 113771: 5f pop %edi 113772: c9 leave 113773: c3 ret 001135ff : MEMFILE_STATIC int IMFS_memfile_remove_block( IMFS_jnode_t *the_jnode, unsigned int block ) { 1135ff: 55 push %ebp <== NOT EXECUTED 113600: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113602: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED block_p *block_ptr; block_p ptr; block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 113605: 6a 00 push $0x0 <== NOT EXECUTED 113607: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11360a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11360d: e8 fc fd ff ff call 11340e <== NOT EXECUTED assert( block_ptr ); 113612: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113615: 85 c0 test %eax,%eax <== NOT EXECUTED 113617: 75 19 jne 113632 <== NOT EXECUTED 113619: 68 f8 24 12 00 push $0x1224f8 <== NOT EXECUTED 11361e: 68 00 26 12 00 push $0x122600 <== NOT EXECUTED 113623: 68 96 01 00 00 push $0x196 <== NOT EXECUTED 113628: 68 82 24 12 00 push $0x122482 <== NOT EXECUTED 11362d: e8 8e 49 ff ff call 107fc0 <__assert_func> <== NOT EXECUTED if ( block_ptr ) { ptr = *block_ptr; 113632: 8b 10 mov (%eax),%edx <== NOT EXECUTED *block_ptr = 0; 113634: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED memfile_free_block( ptr ); 11363a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11363d: 52 push %edx <== NOT EXECUTED 11363e: e8 90 fd ff ff call 1133d3 <== NOT EXECUTED } return 1; } 113643: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 113648: c9 leave <== NOT EXECUTED 113649: c3 ret <== NOT EXECUTED 00113a92 : IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 113a92: 55 push %ebp 113a93: 89 e5 mov %esp,%ebp 113a95: 57 push %edi 113a96: 56 push %esi 113a97: 53 push %ebx 113a98: 83 ec 3c sub $0x3c,%esp 113a9b: 8b 75 0c mov 0xc(%ebp),%esi 113a9e: 8b 7d 10 mov 0x10(%ebp),%edi /* * Perform internal consistency checks */ assert( the_jnode ); 113aa1: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 113aa5: 75 11 jne 113ab8 113aa7: 68 78 24 12 00 push $0x122478 <== NOT EXECUTED 113aac: 68 a4 25 12 00 push $0x1225a4 <== NOT EXECUTED 113ab1: 68 e3 02 00 00 push $0x2e3 <== NOT EXECUTED 113ab6: eb 18 jmp 113ad0 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 113ab8: 8b 45 08 mov 0x8(%ebp),%eax 113abb: 83 78 4c 05 cmpl $0x5,0x4c(%eax) 113abf: 74 19 je 113ada 113ac1: 68 c8 24 12 00 push $0x1224c8 <== NOT EXECUTED 113ac6: 68 a4 25 12 00 push $0x1225a4 <== NOT EXECUTED 113acb: 68 e7 02 00 00 push $0x2e7 <== NOT EXECUTED 113ad0: 68 82 24 12 00 push $0x122482 <== NOT EXECUTED 113ad5: e8 e6 44 ff ff call 107fc0 <__assert_func> <== NOT EXECUTED /* * Error check arguments */ assert( source ); 113ada: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 113ade: 75 11 jne 113af1 113ae0: 68 02 25 12 00 push $0x122502 <== NOT EXECUTED 113ae5: 68 a4 25 12 00 push $0x1225a4 <== NOT EXECUTED 113aea: 68 ef 02 00 00 push $0x2ef <== NOT EXECUTED 113aef: eb df jmp 113ad0 <== NOT EXECUTED /* * If there is nothing to write, then quick exit. */ my_length = length; if ( !my_length ) 113af1: 83 7d 18 00 cmpl $0x0,0x18(%ebp) 113af5: 75 0d jne 113b04 rtems_set_errno_and_return_minus_one( EINVAL ); 113af7: e8 8c 0e 00 00 call 114988 <__errno> <== NOT EXECUTED 113afc: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 113b02: eb 33 jmp 113b37 <== 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; if ( last_byte > the_jnode->info.file.size ) { 113b04: 8b 45 18 mov 0x18(%ebp),%eax 113b07: 01 f0 add %esi,%eax 113b09: 31 d2 xor %edx,%edx 113b0b: 8b 4d 08 mov 0x8(%ebp),%ecx 113b0e: 3b 51 54 cmp 0x54(%ecx),%edx 113b11: 7c 2c jl 113b3f 113b13: 7f 05 jg 113b1a 113b15: 3b 41 50 cmp 0x50(%ecx),%eax 113b18: 76 25 jbe 113b3f status = IMFS_memfile_extend( the_jnode, last_byte ); 113b1a: 51 push %ecx 113b1b: 52 push %edx 113b1c: 50 push %eax 113b1d: ff 75 08 pushl 0x8(%ebp) 113b20: e8 8a fd ff ff call 1138af if ( status ) 113b25: 83 c4 10 add $0x10,%esp 113b28: 85 c0 test %eax,%eax 113b2a: 74 13 je 113b3f rtems_set_errno_and_return_minus_one( ENOSPC ); 113b2c: e8 57 0e 00 00 call 114988 <__errno> <== NOT EXECUTED 113b31: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 113b37: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 113b3a: e9 3b 01 00 00 jmp 113c7a <== NOT EXECUTED /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 113b3f: a1 1c 80 12 00 mov 0x12801c,%eax 113b44: 89 45 c8 mov %eax,-0x38(%ebp) 113b47: 99 cltd 113b48: 89 d3 mov %edx,%ebx 113b4a: 52 push %edx 113b4b: 50 push %eax 113b4c: 57 push %edi 113b4d: 56 push %esi 113b4e: 89 45 c4 mov %eax,-0x3c(%ebp) 113b51: e8 b6 bf 00 00 call 11fb0c <__moddi3> 113b56: 83 c4 10 add $0x10,%esp 113b59: 89 45 cc mov %eax,-0x34(%ebp) block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 113b5c: 8b 4d c4 mov -0x3c(%ebp),%ecx 113b5f: 53 push %ebx 113b60: 51 push %ecx 113b61: 57 push %edi 113b62: 56 push %esi 113b63: e8 54 be 00 00 call 11f9bc <__divdi3> 113b68: 83 c4 10 add $0x10,%esp 113b6b: 89 45 d0 mov %eax,-0x30(%ebp) if ( start_offset ) { 113b6e: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 113b72: 75 0d jne 113b81 113b74: 8b 75 14 mov 0x14(%ebp),%esi 113b77: 8b 55 18 mov 0x18(%ebp),%edx 113b7a: 89 55 d4 mov %edx,-0x2c(%ebp) 113b7d: 31 db xor %ebx,%ebx 113b7f: eb 52 jmp 113bd3 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 ); 113b81: 50 push %eax 113b82: 6a 00 push $0x0 113b84: ff 75 d0 pushl -0x30(%ebp) 113b87: ff 75 08 pushl 0x8(%ebp) 113b8a: e8 7f f8 ff ff call 11340e assert( block_ptr ); 113b8f: 83 c4 10 add $0x10,%esp 113b92: 85 c0 test %eax,%eax 113b94: 75 14 jne 113baa 113b96: 68 f8 24 12 00 push $0x1224f8 <== NOT EXECUTED 113b9b: 68 a4 25 12 00 push $0x1225a4 <== NOT EXECUTED 113ba0: 68 1c 03 00 00 push $0x31c <== NOT EXECUTED 113ba5: e9 26 ff ff ff jmp 113ad0 <== 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; 113baa: 8b 55 c8 mov -0x38(%ebp),%edx 113bad: 2b 55 cc sub -0x34(%ebp),%edx 113bb0: 3b 55 18 cmp 0x18(%ebp),%edx 113bb3: 76 03 jbe 113bb8 113bb5: 8b 55 18 mov 0x18(%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 ); 113bb8: 8b 00 mov (%eax),%eax 113bba: 03 45 cc add -0x34(%ebp),%eax src += to_copy; 113bbd: 89 c7 mov %eax,%edi 113bbf: 8b 75 14 mov 0x14(%ebp),%esi 113bc2: 89 d1 mov %edx,%ecx 113bc4: f3 a4 rep movsb %ds:(%esi),%es:(%edi) block++; 113bc6: ff 45 d0 incl -0x30(%ebp) my_length -= to_copy; 113bc9: 8b 4d 18 mov 0x18(%ebp),%ecx 113bcc: 29 d1 sub %edx,%ecx 113bce: 89 4d d4 mov %ecx,-0x2c(%ebp) copied += to_copy; 113bd1: 89 d3 mov %edx,%ebx /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 113bd3: 8b 15 1c 80 12 00 mov 0x12801c,%edx while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 113bd9: eb 3f jmp 113c1a block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 113bdb: 57 push %edi 113bdc: 6a 00 push $0x0 113bde: ff 75 d0 pushl -0x30(%ebp) 113be1: ff 75 08 pushl 0x8(%ebp) 113be4: 89 55 c4 mov %edx,-0x3c(%ebp) 113be7: e8 22 f8 ff ff call 11340e assert( block_ptr ); 113bec: 83 c4 10 add $0x10,%esp 113bef: 85 c0 test %eax,%eax 113bf1: 8b 55 c4 mov -0x3c(%ebp),%edx 113bf4: 75 14 jne 113c0a 113bf6: 68 f8 24 12 00 push $0x1224f8 <== NOT EXECUTED 113bfb: 68 a4 25 12 00 push $0x1225a4 <== NOT EXECUTED 113c00: 68 30 03 00 00 push $0x330 <== NOT EXECUTED 113c05: e9 c6 fe ff ff jmp 113ad0 <== 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 ); 113c0a: 8b 00 mov (%eax),%eax src += to_copy; 113c0c: 89 c7 mov %eax,%edi 113c0e: 89 d1 mov %edx,%ecx 113c10: f3 a4 rep movsb %ds:(%esi),%es:(%edi) block++; 113c12: ff 45 d0 incl -0x30(%ebp) my_length -= to_copy; 113c15: 29 55 d4 sub %edx,-0x2c(%ebp) * * This routine writes the specified data buffer into the in memory * file pointed to by the_jnode. The file is extended as needed. */ MEMFILE_STATIC ssize_t IMFS_memfile_write( 113c18: 01 d3 add %edx,%ebx /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 113c1a: 8b 45 d4 mov -0x2c(%ebp),%eax 113c1d: 3b 05 1c 80 12 00 cmp 0x12801c,%eax 113c23: 73 b6 jae 113bdb */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); to_copy = my_length; if ( my_length ) { 113c25: 85 c0 test %eax,%eax 113c27: 74 35 je 113c5e block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 113c29: 51 push %ecx 113c2a: 6a 00 push $0x0 113c2c: ff 75 d0 pushl -0x30(%ebp) 113c2f: ff 75 08 pushl 0x8(%ebp) 113c32: e8 d7 f7 ff ff call 11340e assert( block_ptr ); 113c37: 83 c4 10 add $0x10,%esp 113c3a: 85 c0 test %eax,%eax 113c3c: 75 14 jne 113c52 113c3e: 68 f8 24 12 00 push $0x1224f8 <== NOT EXECUTED 113c43: 68 a4 25 12 00 push $0x1225a4 <== NOT EXECUTED 113c48: 68 46 03 00 00 push $0x346 <== NOT EXECUTED 113c4d: e9 7e fe ff ff jmp 113ad0 <== 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 ); 113c52: 8b 00 mov (%eax),%eax 113c54: 89 c7 mov %eax,%edi 113c56: 8b 4d d4 mov -0x2c(%ebp),%ecx 113c59: f3 a4 rep movsb %ds:(%esi),%es:(%edi) my_length = 0; copied += to_copy; 113c5b: 03 5d d4 add -0x2c(%ebp),%ebx } IMFS_mtime_ctime_update( the_jnode ); 113c5e: 52 push %edx 113c5f: 52 push %edx 113c60: 6a 00 push $0x0 113c62: 8d 45 e0 lea -0x20(%ebp),%eax 113c65: 50 push %eax 113c66: e8 f9 46 ff ff call 108364 113c6b: 8b 45 e0 mov -0x20(%ebp),%eax 113c6e: 8b 55 08 mov 0x8(%ebp),%edx 113c71: 89 42 44 mov %eax,0x44(%edx) 113c74: 89 42 48 mov %eax,0x48(%edx) return copied; 113c77: 83 c4 10 add $0x10,%esp } 113c7a: 89 d8 mov %ebx,%eax 113c7c: 8d 65 f4 lea -0xc(%ebp),%esp 113c7f: 5b pop %ebx 113c80: 5e pop %esi 113c81: 5f pop %edi 113c82: c9 leave 113c83: c3 ret 0010d8e4 : const char *token, /* IN */ mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10d8e4: 55 push %ebp 10d8e5: 89 e5 mov %esp,%ebp 10d8e7: 57 push %edi 10d8e8: 56 push %esi 10d8e9: 53 push %ebx 10d8ea: 83 ec 4c sub $0x4c,%esp 10d8ed: 8b 55 08 mov 0x8(%ebp),%edx 10d8f0: 8b 5d 10 mov 0x10(%ebp),%ebx 10d8f3: 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, strlen( token ), new_name, &result ); 10d8f6: 31 c0 xor %eax,%eax 10d8f8: 83 c9 ff or $0xffffffff,%ecx 10d8fb: 89 d7 mov %edx,%edi 10d8fd: f2 ae repnz scas %es:(%edi),%al 10d8ff: f7 d1 not %ecx 10d901: 49 dec %ecx 10d902: 8d 45 e4 lea -0x1c(%ebp),%eax 10d905: 50 push %eax 10d906: 8d 45 af lea -0x51(%ebp),%eax 10d909: 50 push %eax 10d90a: 51 push %ecx 10d90b: 52 push %edx 10d90c: e8 7b fe ff ff call 10d78c /* * Figure out what type of IMFS node this is. */ if ( S_ISDIR(mode) ) 10d911: 8b 45 0c mov 0xc(%ebp),%eax 10d914: 25 00 f0 00 00 and $0xf000,%eax 10d919: 83 c4 10 add $0x10,%esp 10d91c: 3d 00 40 00 00 cmp $0x4000,%eax 10d921: 74 40 je 10d963 type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) 10d923: ba 05 00 00 00 mov $0x5,%edx 10d928: 3d 00 80 00 00 cmp $0x8000,%eax 10d92d: 74 39 je 10d968 type = IMFS_MEMORY_FILE; else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { 10d92f: 3d 00 20 00 00 cmp $0x2000,%eax 10d934: 74 07 je 10d93d 10d936: 3d 00 60 00 00 cmp $0x6000,%eax 10d93b: 75 0d jne 10d94a type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor ); 10d93d: 89 5d d0 mov %ebx,-0x30(%ebp) 10d940: 89 75 d4 mov %esi,-0x2c(%ebp) 10d943: ba 02 00 00 00 mov $0x2,%edx 10d948: eb 1e jmp 10d968 } else if (S_ISFIFO(mode)) 10d94a: ba 07 00 00 00 mov $0x7,%edx 10d94f: 3d 00 10 00 00 cmp $0x1000,%eax 10d954: 74 12 je 10d968 type = IMFS_FIFO; else { rtems_set_errno_and_return_minus_one( EINVAL ); 10d956: e8 59 29 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10d95b: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10d961: eb 32 jmp 10d995 <== NOT EXECUTED 10d963: ba 01 00 00 00 mov $0x1,%edx * was ONLY passed a NULL when we created the root node. We * added a new IMFS_create_root_node() so this path no longer * existed. The result was simpler code which should not have * this path. */ new_node = IMFS_create_node( 10d968: 83 ec 0c sub $0xc,%esp 10d96b: 8d 45 d0 lea -0x30(%ebp),%eax 10d96e: 50 push %eax 10d96f: ff 75 0c pushl 0xc(%ebp) 10d972: 8d 45 af lea -0x51(%ebp),%eax 10d975: 50 push %eax 10d976: 52 push %edx 10d977: ff 75 18 pushl 0x18(%ebp) 10d97a: e8 2d 1d 00 00 call 10f6ac 10d97f: 89 c2 mov %eax,%edx new_name, mode, &info ); if ( !new_node ) 10d981: 83 c4 20 add $0x20,%esp 10d984: 31 c0 xor %eax,%eax 10d986: 85 d2 test %edx,%edx 10d988: 75 0e jne 10d998 rtems_set_errno_and_return_minus_one( ENOMEM ); 10d98a: e8 25 29 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10d98f: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10d995: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED return 0; } 10d998: 8d 65 f4 lea -0xc(%ebp),%esp 10d99b: 5b pop %ebx 10d99c: 5e pop %esi 10d99d: 5f pop %edi 10d99e: c9 leave 10d99f: c3 ret 00107c44 : #include int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 107c44: 55 push %ebp 107c45: 89 e5 mov %esp,%ebp 107c47: 83 ec 08 sub $0x8,%esp 107c4a: 8b 55 08 mov 0x8(%ebp),%edx IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 107c4d: 8b 42 08 mov 0x8(%edx),%eax /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 107c50: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 107c54: 74 10 je 107c66 rtems_set_errno_and_return_minus_one( ENOTDIR ); 107c56: e8 2d cd 00 00 call 114988 <__errno> <== NOT EXECUTED 107c5b: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 107c61: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 107c64: eb 05 jmp 107c6b <== 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; 107c66: 89 50 5c mov %edx,0x5c(%eax) 107c69: 31 c0 xor %eax,%eax return 0; } 107c6b: c9 leave 107c6c: c3 ret 0010845e : */ void IMFS_print_jnode( IMFS_jnode_t *the_jnode ) { 10845e: 55 push %ebp 10845f: 89 e5 mov %esp,%ebp 108461: 53 push %ebx 108462: 83 ec 04 sub $0x4,%esp 108465: 8b 5d 08 mov 0x8(%ebp),%ebx assert( the_jnode ); 108468: 85 db test %ebx,%ebx 10846a: 75 11 jne 10847d 10846c: 68 08 29 12 00 push $0x122908 <== NOT EXECUTED 108471: 68 bc 2a 12 00 push $0x122abc <== NOT EXECUTED 108476: 6a 38 push $0x38 <== NOT EXECUTED 108478: e9 98 00 00 00 jmp 108515 <== NOT EXECUTED fprintf(stdout, "%s", the_jnode->name ); 10847d: 50 push %eax 10847e: 50 push %eax 10847f: a1 00 70 12 00 mov 0x127000,%eax 108484: ff 70 08 pushl 0x8(%eax) 108487: 8d 43 0c lea 0xc(%ebx),%eax 10848a: 50 push %eax 10848b: e8 68 bc 00 00 call 1140f8 switch( the_jnode->type ) { 108490: 8b 43 4c mov 0x4c(%ebx),%eax 108493: 83 c4 10 add $0x10,%esp 108496: 8d 50 ff lea -0x1(%eax),%edx 108499: 83 fa 06 cmp $0x6,%edx 10849c: 0f 87 b7 00 00 00 ja 108559 1084a2: a1 00 70 12 00 mov 0x127000,%eax 1084a7: ff 24 95 8c 2a 12 00 jmp *0x122a8c(,%edx,4) case IMFS_DIRECTORY: fprintf(stdout, "/" ); 1084ae: 53 push %ebx 1084af: 53 push %ebx 1084b0: ff 70 08 pushl 0x8(%eax) 1084b3: 6a 2f push $0x2f 1084b5: e8 52 bb 00 00 call 11400c 1084ba: eb 2b jmp 1084e7 break; case IMFS_DEVICE: fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")", 1084bc: ff 73 54 pushl 0x54(%ebx) 1084bf: ff 73 50 pushl 0x50(%ebx) 1084c2: 68 5b 29 12 00 push $0x12295b 1084c7: eb 16 jmp 1084df the_jnode->info.device.major, the_jnode->info.device.minor ); break; case IMFS_LINEAR_FILE: fprintf(stdout, " (file %" PRId32 " %p)", 1084c9: ff 73 58 pushl 0x58(%ebx) <== NOT EXECUTED 1084cc: ff 73 50 pushl 0x50(%ebx) <== NOT EXECUTED 1084cf: 68 6e 29 12 00 push $0x12296e <== NOT EXECUTED 1084d4: eb 09 jmp 1084df <== NOT EXECUTED the_jnode->info.file.indirect, the_jnode->info.file.doubly_indirect, the_jnode->info.file.triply_indirect ); #else fprintf(stdout, " (file %" PRId32 ")", 1084d6: 51 push %ecx 1084d7: ff 73 50 pushl 0x50(%ebx) 1084da: 68 7d 29 12 00 push $0x12297d 1084df: ff 70 08 pushl 0x8(%eax) 1084e2: e8 e9 ba 00 00 call 113fd0 (uint32_t)the_jnode->info.file.size ); #endif break; 1084e7: 83 c4 10 add $0x10,%esp default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 1084ea: c7 45 08 19 2c 12 00 movl $0x122c19,0x8(%ebp) } 1084f1: 8b 5d fc mov -0x4(%ebp),%ebx 1084f4: c9 leave default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 1084f5: e9 36 d4 00 00 jmp 115930 (uint32_t)the_jnode->info.file.size ); #endif break; case IMFS_HARD_LINK: fprintf(stdout, " links not printed\n" ); 1084fa: 52 push %edx <== NOT EXECUTED 1084fb: 52 push %edx <== NOT EXECUTED 1084fc: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1084ff: 68 89 29 12 00 push $0x122989 <== NOT EXECUTED 108504: e8 ef bb 00 00 call 1140f8 <== NOT EXECUTED assert(0); 108509: 68 58 21 12 00 push $0x122158 <== NOT EXECUTED 10850e: 68 bc 2a 12 00 push $0x122abc <== NOT EXECUTED 108513: 6a 5d push $0x5d <== NOT EXECUTED 108515: 68 12 29 12 00 push $0x122912 <== NOT EXECUTED 10851a: e8 09 07 00 00 call 108c28 <__assert_func> <== NOT EXECUTED break; case IMFS_SYM_LINK: fprintf(stdout, " links not printed\n" ); 10851f: 53 push %ebx <== NOT EXECUTED 108520: 53 push %ebx <== NOT EXECUTED 108521: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 108524: 68 89 29 12 00 push $0x122989 <== NOT EXECUTED 108529: e8 ca bb 00 00 call 1140f8 <== NOT EXECUTED assert(0); 10852e: 68 58 21 12 00 push $0x122158 <== NOT EXECUTED 108533: 68 bc 2a 12 00 push $0x122abc <== NOT EXECUTED 108538: 6a 62 push $0x62 <== NOT EXECUTED 10853a: eb d9 jmp 108515 <== NOT EXECUTED break; case IMFS_FIFO: fprintf(stdout, " FIFO not printed\n" ); 10853c: 51 push %ecx <== NOT EXECUTED 10853d: 51 push %ecx <== NOT EXECUTED 10853e: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 108541: 68 9d 29 12 00 push $0x12299d <== NOT EXECUTED 108546: e8 ad bb 00 00 call 1140f8 <== NOT EXECUTED assert(0); 10854b: 68 58 21 12 00 push $0x122158 <== NOT EXECUTED 108550: 68 bc 2a 12 00 push $0x122abc <== NOT EXECUTED 108555: 6a 67 push $0x67 <== NOT EXECUTED 108557: eb bc jmp 108515 <== NOT EXECUTED break; default: fprintf(stdout, " bad type %d\n", the_jnode->type ); 108559: 52 push %edx <== NOT EXECUTED 10855a: 50 push %eax <== NOT EXECUTED 10855b: 68 b0 29 12 00 push $0x1229b0 <== NOT EXECUTED 108560: a1 00 70 12 00 mov 0x127000,%eax <== NOT EXECUTED 108565: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 108568: e8 63 ba 00 00 call 113fd0 <== NOT EXECUTED assert(0); 10856d: 68 58 21 12 00 push $0x122158 <== NOT EXECUTED 108572: 68 bc 2a 12 00 push $0x122abc <== NOT EXECUTED 108577: 6a 6c push $0x6c <== NOT EXECUTED 108579: eb 9a jmp 108515 <== NOT EXECUTED 00107c80 : int IMFS_readlink( rtems_filesystem_location_info_t *loc, char *buf, /* OUT */ size_t bufsize ) { 107c80: 55 push %ebp 107c81: 89 e5 mov %esp,%ebp 107c83: 56 push %esi 107c84: 53 push %ebx 107c85: 8b 75 0c mov 0xc(%ebp),%esi 107c88: 8b 5d 10 mov 0x10(%ebp),%ebx IMFS_jnode_t *node; int i; node = loc->node_access; 107c8b: 8b 45 08 mov 0x8(%ebp),%eax 107c8e: 8b 10 mov (%eax),%edx if ( node->type != IMFS_SYM_LINK ) 107c90: 31 c0 xor %eax,%eax 107c92: 83 7a 4c 04 cmpl $0x4,0x4c(%edx) 107c96: 74 14 je 107cac rtems_set_errno_and_return_minus_one( EINVAL ); 107c98: e8 eb cc 00 00 call 114988 <__errno> <== NOT EXECUTED 107c9d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 107ca3: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 107ca6: eb 12 jmp 107cba <== NOT EXECUTED for( i=0; ((iinfo.sym_link.name[i] != '\0')); i++ ) buf[i] = node->info.sym_link.name[i]; 107ca8: 88 0c 06 mov %cl,(%esi,%eax,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++ ) 107cab: 40 inc %eax 107cac: 39 d8 cmp %ebx,%eax 107cae: 73 0a jae 107cba 107cb0: 8b 4a 50 mov 0x50(%edx),%ecx 107cb3: 8a 0c 01 mov (%ecx,%eax,1),%cl 107cb6: 84 c9 test %cl,%cl 107cb8: 75 ee jne 107ca8 buf[i] = node->info.sym_link.name[i]; return i; } 107cba: 5b pop %ebx 107cbb: 5e pop %esi 107cbc: c9 leave 107cbd: c3 ret 00107cc0 : rtems_filesystem_location_info_t *old_parent_loc, /* IN */ rtems_filesystem_location_info_t *old_loc, /* IN */ rtems_filesystem_location_info_t *new_parent_loc, /* IN */ const char *new_name /* IN */ ) { 107cc0: 55 push %ebp <== NOT EXECUTED 107cc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107cc3: 53 push %ebx <== NOT EXECUTED 107cc4: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED IMFS_jnode_t *the_jnode; IMFS_jnode_t *new_parent; the_jnode = old_loc->node_access; 107cc7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 107cca: 8b 18 mov (%eax),%ebx <== NOT EXECUTED strncpy( the_jnode->name, new_name, IMFS_NAME_MAX ); 107ccc: 6a 20 push $0x20 <== NOT EXECUTED 107cce: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 107cd1: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED 107cd4: 50 push %eax <== NOT EXECUTED 107cd5: e8 2e d9 00 00 call 115608 <== NOT EXECUTED if ( the_jnode->Parent != NULL ) 107cda: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107cdd: 83 7b 08 00 cmpl $0x0,0x8(%ebx) <== NOT EXECUTED 107ce1: 74 0c je 107cef <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 107ce3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107ce6: 53 push %ebx <== NOT EXECUTED 107ce7: e8 b4 40 00 00 call 10bda0 <_Chain_Extract> <== NOT EXECUTED 107cec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_chain_extract( (rtems_chain_node *) the_jnode ); new_parent = new_parent_loc->node_access; 107cef: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 107cf2: 8b 00 mov (%eax),%eax <== NOT EXECUTED the_jnode->Parent = new_parent; 107cf4: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED RTEMS_INLINE_ROUTINE void rtems_chain_append( rtems_chain_control *the_chain, rtems_chain_node *the_node ) { _Chain_Append( the_chain, the_node ); 107cf7: 51 push %ecx <== NOT EXECUTED 107cf8: 51 push %ecx <== NOT EXECUTED 107cf9: 53 push %ebx <== NOT EXECUTED 107cfa: 83 c0 50 add $0x50,%eax <== NOT EXECUTED 107cfd: 50 push %eax <== NOT EXECUTED 107cfe: e8 79 40 00 00 call 10bd7c <_Chain_Append> <== NOT EXECUTED rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node ); /* * Update the time. */ IMFS_update_ctime( the_jnode ); 107d03: 58 pop %eax <== NOT EXECUTED 107d04: 5a pop %edx <== NOT EXECUTED 107d05: 6a 00 push $0x0 <== NOT EXECUTED 107d07: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 107d0a: 50 push %eax <== NOT EXECUTED 107d0b: e8 54 06 00 00 call 108364 <== NOT EXECUTED 107d10: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 107d13: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED return 0; } 107d16: 31 c0 xor %eax,%eax <== NOT EXECUTED 107d18: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 107d1b: c9 leave <== NOT EXECUTED 107d1c: c3 ret <== NOT EXECUTED 0010d9b0 : int IMFS_rmnod( rtems_filesystem_location_info_t *parent_pathloc, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN */ ) { 10d9b0: 55 push %ebp 10d9b1: 89 e5 mov %esp,%ebp 10d9b3: 56 push %esi 10d9b4: 53 push %ebx 10d9b5: 83 ec 10 sub $0x10,%esp 10d9b8: 8b 75 0c mov 0xc(%ebp),%esi IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 10d9bb: 8b 1e mov (%esi),%ebx /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 10d9bd: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10d9c1: 74 13 je 10d9d6 */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10d9c3: 83 ec 0c sub $0xc,%esp 10d9c6: 53 push %ebx 10d9c7: e8 50 09 00 00 call 10e31c <_Chain_Extract> rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 10d9cc: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 10d9d3: 83 c4 10 add $0x10,%esp /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 10d9d6: 66 ff 4b 34 decw 0x34(%ebx) IMFS_update_ctime( the_jnode ); 10d9da: 50 push %eax 10d9db: 50 push %eax 10d9dc: 6a 00 push $0x0 10d9de: 8d 45 f0 lea -0x10(%ebp),%eax 10d9e1: 50 push %eax 10d9e2: e8 6d 02 00 00 call 10dc54 10d9e7: 8b 45 f0 mov -0x10(%ebp),%eax 10d9ea: 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) ) { 10d9ed: 89 1c 24 mov %ebx,(%esp) 10d9f0: e8 11 03 00 00 call 10dd06 10d9f5: 83 c4 10 add $0x10,%esp 10d9f8: 85 c0 test %eax,%eax 10d9fa: 75 3f jne 10da3b 10d9fc: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) 10da01: 75 38 jne 10da3b /* * Is rtems_filesystem_current this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 10da03: a1 88 17 12 00 mov 0x121788,%eax 10da08: 8b 50 04 mov 0x4(%eax),%edx 10da0b: 3b 16 cmp (%esi),%edx 10da0d: 75 07 jne 10da16 rtems_filesystem_current.node_access = NULL; 10da0f: 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_SYM_LINK ) { 10da16: 83 7b 4c 04 cmpl $0x4,0x4c(%ebx) 10da1a: 75 13 jne 10da2f if ( the_jnode->info.sym_link.name ) 10da1c: 8b 43 50 mov 0x50(%ebx),%eax 10da1f: 85 c0 test %eax,%eax 10da21: 74 0c je 10da2f free( (void*) the_jnode->info.sym_link.name ); 10da23: 83 ec 0c sub $0xc,%esp 10da26: 50 push %eax 10da27: e8 54 97 ff ff call 107180 10da2c: 83 c4 10 add $0x10,%esp } free( the_jnode ); 10da2f: 83 ec 0c sub $0xc,%esp 10da32: 53 push %ebx 10da33: e8 48 97 ff ff call 107180 10da38: 83 c4 10 add $0x10,%esp } return 0; } 10da3b: 31 c0 xor %eax,%eax 10da3d: 8d 65 f8 lea -0x8(%ebp),%esp 10da40: 5b pop %ebx 10da41: 5e pop %esi 10da42: c9 leave 10da43: c3 ret 0010da44 : int IMFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 10da44: 55 push %ebp 10da45: 89 e5 mov %esp,%ebp 10da47: 53 push %ebx 10da48: 83 ec 04 sub $0x4,%esp 10da4b: 8b 45 0c mov 0xc(%ebp),%eax IMFS_jnode_t *the_jnode; IMFS_device_t *io; the_jnode = loc->node_access; 10da4e: 8b 55 08 mov 0x8(%ebp),%edx 10da51: 8b 12 mov (%edx),%edx switch ( the_jnode->type ) { 10da53: 8b 4a 4c mov 0x4c(%edx),%ecx 10da56: 83 e9 02 sub $0x2,%ecx 10da59: 83 f9 05 cmp $0x5,%ecx 10da5c: 77 33 ja 10da91 10da5e: ff 24 8d 44 da 11 00 jmp *0x11da44(,%ecx,4) case IMFS_DEVICE: io = &the_jnode->info.device; buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor ); 10da65: 8b 4a 54 mov 0x54(%edx),%ecx rtems_device_minor_number _minor ) { union __rtems_dev_t temp; temp.__overlay.major = _major; 10da68: 8b 5a 50 mov 0x50(%edx),%ebx 10da6b: 89 58 18 mov %ebx,0x18(%eax) 10da6e: 89 48 1c mov %ecx,0x1c(%eax) break; 10da71: eb 2e jmp 10daa1 case IMFS_LINEAR_FILE: case IMFS_MEMORY_FILE: buf->st_size = the_jnode->info.file.size; 10da73: 8b 4a 50 mov 0x50(%edx),%ecx 10da76: 8b 5a 54 mov 0x54(%edx),%ebx 10da79: 89 48 20 mov %ecx,0x20(%eax) 10da7c: 89 58 24 mov %ebx,0x24(%eax) break; 10da7f: eb 20 jmp 10daa1 case IMFS_SYM_LINK: buf->st_size = 0; break; case IMFS_FIFO: buf->st_size = 0; 10da81: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) <== NOT EXECUTED 10da88: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) <== NOT EXECUTED break; 10da8f: eb 10 jmp 10daa1 <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 10da91: e8 1e 28 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10da96: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10da9c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10da9f: eb 36 jmp 10dad7 <== NOT EXECUTED break; } buf->st_mode = the_jnode->st_mode; 10daa1: 8b 4a 30 mov 0x30(%edx),%ecx 10daa4: 89 48 0c mov %ecx,0xc(%eax) buf->st_nlink = the_jnode->st_nlink; 10daa7: 8b 4a 34 mov 0x34(%edx),%ecx 10daaa: 66 89 48 10 mov %cx,0x10(%eax) buf->st_ino = the_jnode->st_ino; 10daae: 8b 4a 38 mov 0x38(%edx),%ecx 10dab1: 89 48 08 mov %ecx,0x8(%eax) buf->st_uid = the_jnode->st_uid; 10dab4: 8b 4a 3c mov 0x3c(%edx),%ecx 10dab7: 66 89 48 12 mov %cx,0x12(%eax) buf->st_gid = the_jnode->st_gid; 10dabb: 66 8b 4a 3e mov 0x3e(%edx),%cx 10dabf: 66 89 48 14 mov %cx,0x14(%eax) buf->st_atime = the_jnode->stat_atime; 10dac3: 8b 4a 40 mov 0x40(%edx),%ecx 10dac6: 89 48 28 mov %ecx,0x28(%eax) buf->st_mtime = the_jnode->stat_mtime; 10dac9: 8b 4a 44 mov 0x44(%edx),%ecx 10dacc: 89 48 30 mov %ecx,0x30(%eax) buf->st_ctime = the_jnode->stat_ctime; 10dacf: 8b 52 48 mov 0x48(%edx),%edx 10dad2: 89 50 38 mov %edx,0x38(%eax) 10dad5: 31 c0 xor %eax,%eax return 0; } 10dad7: 5a pop %edx 10dad8: 5b pop %ebx 10dad9: c9 leave 10dada: c3 ret 00107d20 : int IMFS_symlink( rtems_filesystem_location_info_t *parent_loc, const char *link_name, const char *node_name ) { 107d20: 55 push %ebp 107d21: 89 e5 mov %esp,%ebp 107d23: 57 push %edi 107d24: 53 push %ebx 107d25: 83 ec 40 sub $0x40,%esp 107d28: 8b 55 10 mov 0x10(%ebp),%edx int i; /* * Remove any separators at the end of the string. */ IMFS_get_token( node_name, strlen( node_name ), new_name, &i ); 107d2b: 31 c0 xor %eax,%eax 107d2d: 83 c9 ff or $0xffffffff,%ecx 107d30: 89 d7 mov %edx,%edi 107d32: f2 ae repnz scas %es:(%edi),%al 107d34: f7 d1 not %ecx 107d36: 49 dec %ecx 107d37: 8d 45 f4 lea -0xc(%ebp),%eax 107d3a: 50 push %eax 107d3b: 8d 5d bf lea -0x41(%ebp),%ebx 107d3e: 53 push %ebx 107d3f: 51 push %ecx 107d40: 52 push %edx 107d41: e8 d6 9d 00 00 call 111b1c /* * Duplicate link name */ info.sym_link.name = strdup(link_name); 107d46: 58 pop %eax 107d47: ff 75 0c pushl 0xc(%ebp) 107d4a: e8 65 d7 00 00 call 1154b4 107d4f: 89 45 e0 mov %eax,-0x20(%ebp) if (info.sym_link.name == NULL) { 107d52: 83 c4 10 add $0x10,%esp 107d55: 85 c0 test %eax,%eax 107d57: 75 10 jne 107d69 rtems_set_errno_and_return_minus_one(ENOMEM); 107d59: e8 2a cc 00 00 call 114988 <__errno> <== NOT EXECUTED 107d5e: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 107d64: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 107d67: eb 3e jmp 107da7 <== NOT EXECUTED * was ONLY passed a NULL when we created the root node. We * added a new IMFS_create_root_node() so this path no longer * existed. The result was simpler code which should not have * this path. */ new_node = IMFS_create_node( 107d69: 83 ec 0c sub $0xc,%esp 107d6c: 8d 45 e0 lea -0x20(%ebp),%eax 107d6f: 50 push %eax 107d70: 68 ff a1 00 00 push $0xa1ff 107d75: 53 push %ebx 107d76: 6a 04 push $0x4 107d78: ff 75 08 pushl 0x8(%ebp) 107d7b: e8 c4 93 00 00 call 111144 107d80: 89 c2 mov %eax,%edx new_name, ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if (new_node == NULL) { 107d82: 83 c4 20 add $0x20,%esp 107d85: 31 c0 xor %eax,%eax 107d87: 85 d2 test %edx,%edx 107d89: 75 1c jne 107da7 free(info.sym_link.name); 107d8b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107d8e: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 107d91: e8 56 05 00 00 call 1082ec <== NOT EXECUTED rtems_set_errno_and_return_minus_one(ENOMEM); 107d96: e8 ed cb 00 00 call 114988 <__errno> <== NOT EXECUTED 107d9b: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 107da1: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 107da4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 107da7: 8d 65 f8 lea -0x8(%ebp),%esp 107daa: 5b pop %ebx 107dab: 5f pop %edi 107dac: c9 leave 107dad: c3 ret 00107db0 : int IMFS_unlink( rtems_filesystem_location_info_t *parentloc, /* IN */ rtems_filesystem_location_info_t *loc /* IN */ ) { 107db0: 55 push %ebp 107db1: 89 e5 mov %esp,%ebp 107db3: 57 push %edi 107db4: 56 push %esi 107db5: 53 push %ebx 107db6: 83 ec 2c sub $0x2c,%esp IMFS_jnode_t *node; rtems_filesystem_location_info_t the_link; int result = 0; node = loc->node_access; 107db9: 8b 45 0c mov 0xc(%ebp),%eax 107dbc: 8b 18 mov (%eax),%ebx /* * If this is the last last pointer to the node * free the node. */ if ( node->type == IMFS_HARD_LINK ) { 107dbe: 83 7b 4c 03 cmpl $0x3,0x4c(%ebx) 107dc2: 75 7a jne 107e3e if ( !node->info.hard_link.link_node ) 107dc4: 8b 43 50 mov 0x50(%ebx),%eax 107dc7: 85 c0 test %eax,%eax 107dc9: 75 10 jne 107ddb rtems_set_errno_and_return_minus_one( EINVAL ); 107dcb: e8 b8 cb 00 00 call 114988 <__errno> <== NOT EXECUTED 107dd0: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 107dd6: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 107dd9: eb 75 jmp 107e50 <== NOT EXECUTED the_link = *loc; 107ddb: 8d 7d cc lea -0x34(%ebp),%edi 107dde: b9 05 00 00 00 mov $0x5,%ecx 107de3: 8b 75 0c mov 0xc(%ebp),%esi 107de6: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_link.node_access = node->info.hard_link.link_node; 107de8: 89 45 cc mov %eax,-0x34(%ebp) IMFS_Set_handlers( &the_link ); 107deb: 83 ec 0c sub $0xc,%esp 107dee: 8d 75 cc lea -0x34(%ebp),%esi 107df1: 56 push %esi 107df2: e8 4d 94 00 00 call 111244 /* * 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) 107df7: 8b 43 50 mov 0x50(%ebx),%eax 107dfa: 8b 50 34 mov 0x34(%eax),%edx 107dfd: 83 c4 10 add $0x10,%esp 107e00: 66 83 fa 01 cmp $0x1,%dx 107e04: 75 1a jne 107e20 { result = (*the_link.handlers->rmnod_h)( parentloc, &the_link ); 107e06: 51 push %ecx 107e07: 51 push %ecx 107e08: 56 push %esi 107e09: ff 75 08 pushl 0x8(%ebp) 107e0c: 8b 45 d4 mov -0x2c(%ebp),%eax 107e0f: ff 50 34 call *0x34(%eax) 107e12: 89 c2 mov %eax,%edx if ( result != 0 ) 107e14: 83 c4 10 add $0x10,%esp 107e17: 83 c8 ff or $0xffffffff,%eax 107e1a: 85 d2 test %edx,%edx 107e1c: 74 20 je 107e3e 107e1e: eb 30 jmp 107e50 return -1; } else { node->info.hard_link.link_node->st_nlink --; 107e20: 4a dec %edx 107e21: 66 89 50 34 mov %dx,0x34(%eax) IMFS_update_ctime( node->info.hard_link.link_node ); 107e25: 52 push %edx 107e26: 52 push %edx 107e27: 6a 00 push $0x0 107e29: 8d 45 e0 lea -0x20(%ebp),%eax 107e2c: 50 push %eax 107e2d: e8 32 05 00 00 call 108364 107e32: 8b 43 50 mov 0x50(%ebx),%eax 107e35: 8b 55 e0 mov -0x20(%ebp),%edx 107e38: 89 50 48 mov %edx,0x48(%eax) 107e3b: 83 c4 10 add $0x10,%esp /* * Now actually free the node we were asked to free. */ result = (*loc->handlers->rmnod_h)( parentloc, loc ); 107e3e: 50 push %eax 107e3f: 50 push %eax 107e40: 8b 55 0c mov 0xc(%ebp),%edx 107e43: 8b 42 08 mov 0x8(%edx),%eax 107e46: 52 push %edx 107e47: ff 75 08 pushl 0x8(%ebp) 107e4a: ff 50 34 call *0x34(%eax) return result; 107e4d: 83 c4 10 add $0x10,%esp } 107e50: 8d 65 f4 lea -0xc(%ebp),%esp 107e53: 5b pop %ebx 107e54: 5e pop %esi 107e55: 5f pop %edi 107e56: c9 leave 107e57: c3 ret 00107e58 : #include int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 107e58: 55 push %ebp 107e59: 89 e5 mov %esp,%ebp 107e5b: 83 ec 08 sub $0x8,%esp IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 107e5e: 8b 45 08 mov 0x8(%ebp),%eax 107e61: 8b 40 08 mov 0x8(%eax),%eax /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 107e64: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 107e68: 74 0d je 107e77 rtems_set_errno_and_return_minus_one( ENOTDIR ); 107e6a: e8 19 cb 00 00 call 114988 <__errno> <== NOT EXECUTED 107e6f: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 107e75: eb 11 jmp 107e88 <== NOT EXECUTED /* * Did the node indicate that there was a directory mounted here? */ if ( node->info.directory.mt_fs == NULL ) 107e77: 83 78 5c 00 cmpl $0x0,0x5c(%eax) 107e7b: 75 10 jne 107e8d rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */ 107e7d: e8 06 cb 00 00 call 114988 <__errno> <== NOT EXECUTED 107e82: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 107e88: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 107e8b: eb 09 jmp 107e96 <== 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; 107e8d: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) 107e94: 31 c0 xor %eax,%eax return 0; } 107e96: c9 leave 107e97: c3 ret 00107304 : void RTEMS_Malloc_Initialize( void *heap_begin, uintptr_t heap_size, size_t sbrk_amount ) { 107304: 55 push %ebp 107305: 89 e5 mov %esp,%ebp 107307: 57 push %edi 107308: 56 push %esi 107309: 53 push %ebx 10730a: 83 ec 0c sub $0xc,%esp 10730d: 8b 5d 08 mov 0x8(%ebp),%ebx 107310: 8b 75 0c mov 0xc(%ebp),%esi #endif /* * If configured, initialize the statistics support */ if ( rtems_malloc_statistics_helpers != NULL ) { 107313: a1 10 1d 12 00 mov 0x121d10,%eax 107318: 85 c0 test %eax,%eax 10731a: 74 02 je 10731e (*rtems_malloc_statistics_helpers->initialize)(); 10731c: ff 10 call *(%eax) <== NOT EXECUTED } /* * Initialize the garbage collection list to start with nothing on it. */ malloc_deferred_frees_initialize(); 10731e: e8 7c ff ff ff call 10729f /* * Initialize the optional sbrk support for extending the heap */ if ( rtems_malloc_sbrk_helpers != NULL ) { 107323: a1 14 1d 12 00 mov 0x121d14,%eax 107328: 85 c0 test %eax,%eax 10732a: 74 12 je 10733e void *new_heap_begin = (*rtems_malloc_sbrk_helpers->initialize)( 10732c: 52 push %edx <== NOT EXECUTED 10732d: 52 push %edx <== NOT EXECUTED 10732e: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 107331: 53 push %ebx <== NOT EXECUTED 107332: ff 10 call *(%eax) <== NOT EXECUTED heap_begin, sbrk_amount ); heap_size -= (uintptr_t) new_heap_begin - (uintptr_t) heap_begin; 107334: 8d 34 33 lea (%ebx,%esi,1),%esi <== NOT EXECUTED 107337: 29 c6 sub %eax,%esi <== NOT EXECUTED 107339: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10733b: 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 ( 10733e: 80 3d 0d 1d 12 00 00 cmpb $0x0,0x121d0d 107345: 75 11 jne 107358 !rtems_unified_work_area && rtems_configuration_get_do_zero_of_workspace() 107347: 80 3d 60 fa 11 00 00 cmpb $0x0,0x11fa60 10734e: 74 08 je 107358 ) { memset( heap_begin, 0, heap_size ); 107350: 31 c0 xor %eax,%eax 107352: 89 df mov %ebx,%edi 107354: 89 f1 mov %esi,%ecx 107356: f3 aa rep stos %al,%es:(%edi) * Unfortunately we cannot use assert if this fails because if this * has failed we do not have a heap and if we do not have a heap * STDIO cannot work because there will be no buffers. */ if ( !rtems_unified_work_area ) { 107358: 80 3d 0d 1d 12 00 00 cmpb $0x0,0x121d0d 10735f: 75 20 jne 107381 void *area_begin, uintptr_t area_size, uintptr_t page_size ) { return _Heap_Initialize( heap, area_begin, area_size, page_size ); 107361: 6a 04 push $0x4 107363: 56 push %esi 107364: 53 push %ebx 107365: ff 35 90 f9 11 00 pushl 0x11f990 10736b: e8 94 38 00 00 call 10ac04 <_Heap_Initialize> RTEMS_Malloc_Heap, heap_begin, heap_size, CPU_HEAP_ALIGNMENT ); if ( status == 0 ) { 107370: 83 c4 10 add $0x10,%esp 107373: 85 c0 test %eax,%eax 107375: 75 0a jne 107381 rtems_fatal_error_occurred( RTEMS_NO_MEMORY ); 107377: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10737a: 6a 1a push $0x1a <== NOT EXECUTED 10737c: e8 b3 31 00 00 call 10a534 <== NOT EXECUTED } } MSBUMP( space_available, _Protected_heap_Get_size(RTEMS_Malloc_Heap) ); 107381: 8b 1d 70 38 12 00 mov 0x123870,%ebx 107387: 83 ec 0c sub $0xc,%esp 10738a: ff 35 90 f9 11 00 pushl 0x11f990 107390: e8 db 42 00 00 call 10b670 <_Protected_heap_Get_size> 107395: 8d 1c 18 lea (%eax,%ebx,1),%ebx 107398: 89 1d 70 38 12 00 mov %ebx,0x123870 10739e: 83 c4 10 add $0x10,%esp printk( "\n" ); rtems_print_buffer( (heap_begin + heap_size) - 48, 48 ); rtems_fatal_error_occurred( RTEMS_NO_MEMORY ); } #endif } 1073a1: 8d 65 f4 lea -0xc(%ebp),%esp 1073a4: 5b pop %ebx 1073a5: 5e pop %esi 1073a6: 5f pop %edi 1073a7: c9 leave 1073a8: c3 ret 00109ff2 : static rtems_printk_plugin_t print_handler; void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) { 109ff2: 55 push %ebp <== NOT EXECUTED 109ff3: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109ff5: 57 push %edi <== NOT EXECUTED 109ff6: 56 push %esi <== NOT EXECUTED 109ff7: 53 push %ebx <== NOT EXECUTED 109ff8: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 109ffb: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED void *high_water_mark; void *current; Stack_Control *stack; char name[5]; if ( !the_thread ) 109ffe: 85 db test %ebx,%ebx <== NOT EXECUTED 10a000: 0f 84 fa 00 00 00 je 10a100 <== NOT EXECUTED return; if ( !print_handler ) 10a006: a1 a0 0d 16 00 mov 0x160da0,%eax <== NOT EXECUTED 10a00b: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 10a00e: 85 c0 test %eax,%eax <== NOT EXECUTED 10a010: 0f 84 ea 00 00 00 je 10a100 <== NOT EXECUTED /* * Obtain interrupt stack information */ if (the_thread == (Thread_Control *) -1) { 10a016: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED 10a019: 75 1d jne 10a038 <== NOT EXECUTED if (Stack_check_Interrupt_stack.area) { 10a01b: 83 3d 4c 3a 16 00 00 cmpl $0x0,0x163a4c <== NOT EXECUTED 10a022: 0f 84 d8 00 00 00 je 10a100 <== NOT EXECUTED 10a028: be 48 3a 16 00 mov $0x163a48,%esi <== NOT EXECUTED 10a02d: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) <== NOT EXECUTED 10a034: 31 db xor %ebx,%ebx <== NOT EXECUTED 10a036: eb 0f jmp 10a047 <== NOT EXECUTED current = 0; } else return; } else { stack = &the_thread->Start.Initial_stack; 10a038: 8d b3 c0 00 00 00 lea 0xc0(%ebx),%esi <== NOT EXECUTED current = (void *)_CPU_Context_Get_SP( &the_thread->Registers ); 10a03e: 8b 8b d4 00 00 00 mov 0xd4(%ebx),%ecx <== NOT EXECUTED 10a044: 89 4d cc mov %ecx,-0x34(%ebp) <== NOT EXECUTED } low = Stack_check_usable_stack_start(stack); 10a047: 8b 56 04 mov 0x4(%esi),%edx <== NOT EXECUTED 10a04a: 83 c2 10 add $0x10,%edx <== NOT EXECUTED size = Stack_check_usable_stack_size(stack); 10a04d: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10a04f: 83 e8 10 sub $0x10,%eax <== NOT EXECUTED 10a052: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED high_water_mark = Stack_check_find_high_water_mark(low, size); 10a055: 50 push %eax <== NOT EXECUTED 10a056: 52 push %edx <== NOT EXECUTED 10a057: 89 55 c8 mov %edx,-0x38(%ebp) <== NOT EXECUTED 10a05a: e8 6c ff ff ff call 109fcb <== NOT EXECUTED if ( high_water_mark ) 10a05f: 59 pop %ecx <== NOT EXECUTED 10a060: 5f pop %edi <== NOT EXECUTED 10a061: 31 ff xor %edi,%edi <== NOT EXECUTED 10a063: 85 c0 test %eax,%eax <== NOT EXECUTED 10a065: 8b 55 c8 mov -0x38(%ebp),%edx <== NOT EXECUTED 10a068: 74 08 je 10a072 <== NOT EXECUTED used = Stack_check_Calculate_used( low, size, high_water_mark ); 10a06a: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED 10a06d: 8d 3c 0a lea (%edx,%ecx,1),%edi <== NOT EXECUTED 10a070: 29 c7 sub %eax,%edi <== NOT EXECUTED else used = 0; if ( the_thread ) { 10a072: 85 db test %ebx,%ebx <== NOT EXECUTED 10a074: 74 26 je 10a09c <== NOT EXECUTED (*print_handler)( 10a076: 52 push %edx <== NOT EXECUTED 10a077: 8d 45 e3 lea -0x1d(%ebp),%eax <== NOT EXECUTED 10a07a: 50 push %eax <== NOT EXECUTED 10a07b: 6a 05 push $0x5 <== NOT EXECUTED 10a07d: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a080: e8 d3 51 00 00 call 10f258 <== NOT EXECUTED 10a085: 50 push %eax <== NOT EXECUTED 10a086: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a089: 68 60 0d 15 00 push $0x150d60 <== NOT EXECUTED 10a08e: ff 35 9c 0d 16 00 pushl 0x160d9c <== NOT EXECUTED 10a094: ff 55 d0 call *-0x30(%ebp) <== NOT EXECUTED 10a097: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10a09a: eb 14 jmp 10a0b0 <== 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 ); 10a09c: 50 push %eax <== NOT EXECUTED 10a09d: 6a ff push $0xffffffff <== NOT EXECUTED 10a09f: 68 6d 0d 15 00 push $0x150d6d <== NOT EXECUTED 10a0a4: ff 35 9c 0d 16 00 pushl 0x160d9c <== NOT EXECUTED 10a0aa: ff 55 d0 call *-0x30(%ebp) <== NOT EXECUTED 10a0ad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } (*print_handler)( 10a0b0: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10a0b3: 53 push %ebx <== NOT EXECUTED 10a0b4: 53 push %ebx <== NOT EXECUTED 10a0b5: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 10a0b8: ff 75 cc pushl -0x34(%ebp) <== NOT EXECUTED 10a0bb: 8b 16 mov (%esi),%edx <== NOT EXECUTED 10a0bd: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED 10a0c1: 52 push %edx <== NOT EXECUTED 10a0c2: 50 push %eax <== NOT EXECUTED 10a0c3: 68 7b 0d 15 00 push $0x150d7b <== NOT EXECUTED 10a0c8: ff 35 9c 0d 16 00 pushl 0x160d9c <== NOT EXECUTED 10a0ce: ff 15 a0 0d 16 00 call *0x160da0 <== NOT EXECUTED stack->area + stack->size - 1, current, size ); if (Stack_check_Initialized == 0) { 10a0d4: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10a0d7: 83 3d 98 0d 16 00 00 cmpl $0x0,0x160d98 <== NOT EXECUTED 10a0de: a1 a0 0d 16 00 mov 0x160da0,%eax <== NOT EXECUTED 10a0e3: 75 09 jne 10a0ee <== NOT EXECUTED (*print_handler)( print_context, "Unavailable\n" ); 10a0e5: 51 push %ecx <== NOT EXECUTED 10a0e6: 51 push %ecx <== NOT EXECUTED 10a0e7: 68 99 0d 15 00 push $0x150d99 <== NOT EXECUTED 10a0ec: eb 07 jmp 10a0f5 <== NOT EXECUTED } else { (*print_handler)( print_context, "%8" PRId32 "\n", used ); 10a0ee: 52 push %edx <== NOT EXECUTED 10a0ef: 57 push %edi <== NOT EXECUTED 10a0f0: 68 a6 0d 15 00 push $0x150da6 <== NOT EXECUTED 10a0f5: ff 35 9c 0d 16 00 pushl 0x160d9c <== NOT EXECUTED 10a0fb: ff d0 call *%eax <== NOT EXECUTED 10a0fd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 10a100: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a103: 5b pop %ebx <== NOT EXECUTED 10a104: 5e pop %esi <== NOT EXECUTED 10a105: 5f pop %edi <== NOT EXECUTED 10a106: c9 leave <== NOT EXECUTED 10a107: c3 ret <== NOT EXECUTED 00109fcb : */ void *Stack_check_find_high_water_mark( const void *s, size_t n ) { 109fcb: 55 push %ebp <== NOT EXECUTED 109fcc: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109fce: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED /* * start at lower memory and find first word that does not * match pattern */ base += PATTERN_SIZE_WORDS; 109fd1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109fd4: 83 c0 10 add $0x10,%eax <== NOT EXECUTED for (ebase = base + length; base < ebase; base++) 109fd7: 83 e2 fc and $0xfffffffc,%edx <== NOT EXECUTED 109fda: 8d 14 10 lea (%eax,%edx,1),%edx <== NOT EXECUTED 109fdd: eb 0b jmp 109fea <== NOT EXECUTED if (*base != U32_PATTERN) 109fdf: 81 38 a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%eax) <== NOT EXECUTED 109fe5: 75 09 jne 109ff0 <== 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++) 109fe7: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 109fea: 39 d0 cmp %edx,%eax <== NOT EXECUTED 109fec: 72 f1 jb 109fdf <== NOT EXECUTED 109fee: 31 c0 xor %eax,%eax <== NOT EXECUTED if (*base != U32_PATTERN) return (void *) base; #endif return (void *)0; } 109ff0: c9 leave <== NOT EXECUTED 109ff1: c3 ret <== NOT EXECUTED 0010a180 : * * NOTE: The system is in a questionable state... we may not get * the following message out. */ void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok) { 10a180: 55 push %ebp <== NOT EXECUTED 10a181: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a183: 56 push %esi <== NOT EXECUTED 10a184: 53 push %ebx <== NOT EXECUTED 10a185: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 10a188: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a18b: 8a 55 0c mov 0xc(%ebp),%dl <== NOT EXECUTED Stack_Control *stack = &running->Start.Initial_stack; void *pattern_area = Stack_check_Get_pattern_area(stack); 10a18e: 8b b3 c4 00 00 00 mov 0xc4(%ebx),%esi <== NOT EXECUTED char name [32]; printk("BLOWN STACK!!!\n"); 10a194: 68 0d 0e 15 00 push $0x150e0d <== NOT EXECUTED 10a199: 88 55 d4 mov %dl,-0x2c(%ebp) <== NOT EXECUTED 10a19c: e8 37 25 00 00 call 10c6d8 <== NOT EXECUTED printk("task control block: 0x%08" PRIxPTR "\n", running); 10a1a1: 5a pop %edx <== NOT EXECUTED 10a1a2: 59 pop %ecx <== NOT EXECUTED 10a1a3: 53 push %ebx <== NOT EXECUTED 10a1a4: 68 1d 0e 15 00 push $0x150e1d <== NOT EXECUTED 10a1a9: e8 2a 25 00 00 call 10c6d8 <== NOT EXECUTED printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id); 10a1ae: 59 pop %ecx <== NOT EXECUTED 10a1af: 58 pop %eax <== NOT EXECUTED 10a1b0: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a1b3: 68 3a 0e 15 00 push $0x150e3a <== NOT EXECUTED 10a1b8: e8 1b 25 00 00 call 10c6d8 <== NOT EXECUTED printk( 10a1bd: 58 pop %eax <== NOT EXECUTED 10a1be: 5a pop %edx <== NOT EXECUTED 10a1bf: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10a1c2: 68 4c 0e 15 00 push $0x150e4c <== NOT EXECUTED 10a1c7: e8 0c 25 00 00 call 10c6d8 <== NOT EXECUTED "task name: 0x%08" PRIx32 "\n", running->Object.name.name_u32 ); printk( 10a1cc: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10a1cf: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED 10a1d2: 50 push %eax <== NOT EXECUTED 10a1d3: 6a 20 push $0x20 <== NOT EXECUTED 10a1d5: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a1d8: e8 7b 50 00 00 call 10f258 <== NOT EXECUTED 10a1dd: 5a pop %edx <== NOT EXECUTED 10a1de: 59 pop %ecx <== NOT EXECUTED 10a1df: 50 push %eax <== NOT EXECUTED 10a1e0: 68 60 0e 15 00 push $0x150e60 <== NOT EXECUTED 10a1e5: e8 ee 24 00 00 call 10c6d8 <== NOT EXECUTED "task name string: %s\n", rtems_object_get_name(running->Object.id, sizeof(name), name) ); printk( 10a1ea: 8b 8b c4 00 00 00 mov 0xc4(%ebx),%ecx <== NOT EXECUTED 10a1f0: 8b 83 c0 00 00 00 mov 0xc0(%ebx),%eax <== NOT EXECUTED 10a1f6: 8d 1c 01 lea (%ecx,%eax,1),%ebx <== NOT EXECUTED 10a1f9: 53 push %ebx <== NOT EXECUTED 10a1fa: 51 push %ecx <== NOT EXECUTED 10a1fb: 50 push %eax <== NOT EXECUTED 10a1fc: 68 76 0e 15 00 push $0x150e76 <== NOT EXECUTED 10a201: e8 d2 24 00 00 call 10c6d8 <== NOT EXECUTED "task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n", (unsigned long) stack->size, stack->area, ((char *) stack->area + stack->size) ); if (!pattern_ok) { 10a206: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10a209: 8a 55 d4 mov -0x2c(%ebp),%dl <== NOT EXECUTED 10a20c: 84 d2 test %dl,%dl <== NOT EXECUTED 10a20e: 75 17 jne 10a227 <== NOT EXECUTED * the following message out. */ void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok) { Stack_Control *stack = &running->Start.Initial_stack; void *pattern_area = Stack_check_Get_pattern_area(stack); 10a210: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED (unsigned long) stack->size, stack->area, ((char *) stack->area + stack->size) ); if (!pattern_ok) { printk( 10a213: 83 c6 18 add $0x18,%esi <== NOT EXECUTED 10a216: 56 push %esi <== NOT EXECUTED 10a217: 50 push %eax <== NOT EXECUTED 10a218: 6a 10 push $0x10 <== NOT EXECUTED 10a21a: 68 a7 0e 15 00 push $0x150ea7 <== NOT EXECUTED 10a21f: e8 b4 24 00 00 call 10c6d8 <== NOT EXECUTED 10a224: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_configuration_get_user_multiprocessing_table()->node ); } #endif rtems_fatal_error_occurred(0x81); 10a227: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a22a: 68 81 00 00 00 push $0x81 <== NOT EXECUTED 10a22f: e8 d0 57 00 00 call 10fa04 <== NOT EXECUTED 0010e3b0 <_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 ) { 10e3b0: 55 push %ebp 10e3b1: 89 e5 mov %esp,%ebp 10e3b3: 53 push %ebx 10e3b4: 83 ec 04 sub $0x4,%esp 10e3b7: 8b 45 08 mov 0x8(%ebp),%eax 10e3ba: 8b 4d 0c mov 0xc(%ebp),%ecx { Thread_Control *executing; /* disabled when you get here */ executing = _Thread_Executing; 10e3bd: 8b 15 70 3a 12 00 mov 0x123a70,%edx executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL; 10e3c3: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) if ( !_CORE_mutex_Is_locked( the_mutex ) ) { 10e3ca: 83 78 50 00 cmpl $0x0,0x50(%eax) 10e3ce: 0f 84 87 00 00 00 je 10e45b <_CORE_mutex_Seize_interrupt_trylock+0xab> the_mutex->lock = CORE_MUTEX_LOCKED; 10e3d4: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) the_mutex->holder = executing; 10e3db: 89 50 5c mov %edx,0x5c(%eax) the_mutex->holder_id = executing->Object.id; 10e3de: 8b 5a 08 mov 0x8(%edx),%ebx 10e3e1: 89 58 60 mov %ebx,0x60(%eax) the_mutex->nest_count = 1; 10e3e4: c7 40 54 01 00 00 00 movl $0x1,0x54(%eax) */ RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority( CORE_mutex_Attributes *the_attribute ) { return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 10e3eb: 8b 58 48 mov 0x48(%eax),%ebx if ( !_CORE_mutex_Is_locked( the_mutex ) ) { the_mutex->lock = CORE_MUTEX_LOCKED; the_mutex->holder = executing; the_mutex->holder_id = executing->Object.id; the_mutex->nest_count = 1; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 10e3ee: 83 fb 02 cmp $0x2,%ebx 10e3f1: 74 05 je 10e3f8 <_CORE_mutex_Seize_interrupt_trylock+0x48> 10e3f3: 83 fb 03 cmp $0x3,%ebx 10e3f6: 75 08 jne 10e400 <_CORE_mutex_Seize_interrupt_trylock+0x50> _Chain_Prepend_unprotected( &executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = executing->current_priority; #endif executing->resource_count++; 10e3f8: ff 42 1c incl 0x1c(%edx) } if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { 10e3fb: 83 fb 03 cmp $0x3,%ebx 10e3fe: 74 05 je 10e405 <_CORE_mutex_Seize_interrupt_trylock+0x55> _ISR_Enable( *level_p ); 10e400: ff 31 pushl (%ecx) 10e402: 9d popf 10e403: eb 7b jmp 10e480 <_CORE_mutex_Seize_interrupt_trylock+0xd0> { Priority_Control ceiling; Priority_Control current; ceiling = the_mutex->Attributes.priority_ceiling; current = executing->current_priority; 10e405: 8b 5a 14 mov 0x14(%edx),%ebx if ( current == ceiling ) { 10e408: 3b 58 4c cmp 0x4c(%eax),%ebx 10e40b: 75 05 jne 10e412 <_CORE_mutex_Seize_interrupt_trylock+0x62> _ISR_Enable( *level_p ); 10e40d: ff 31 pushl (%ecx) 10e40f: 9d popf 10e410: eb 6e jmp 10e480 <_CORE_mutex_Seize_interrupt_trylock+0xd0> return 0; } if ( current > ceiling ) { 10e412: 76 2a jbe 10e43e <_CORE_mutex_Seize_interrupt_trylock+0x8e> rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10e414: 8b 15 b4 39 12 00 mov 0x1239b4,%edx 10e41a: 42 inc %edx 10e41b: 89 15 b4 39 12 00 mov %edx,0x1239b4 _Thread_Disable_dispatch(); _ISR_Enable( *level_p ); 10e421: ff 31 pushl (%ecx) 10e423: 9d popf _Thread_Change_priority( 10e424: 52 push %edx 10e425: 6a 00 push $0x0 10e427: ff 70 4c pushl 0x4c(%eax) 10e42a: ff 70 5c pushl 0x5c(%eax) 10e42d: e8 96 d2 ff ff call 10b6c8 <_Thread_Change_priority> the_mutex->holder, the_mutex->Attributes.priority_ceiling, false ); _Thread_Enable_dispatch(); 10e432: e8 2e d7 ff ff call 10bb65 <_Thread_Enable_dispatch> 10e437: 31 c0 xor %eax,%eax 10e439: 83 c4 10 add $0x10,%esp 10e43c: eb 4b jmp 10e489 <_CORE_mutex_Seize_interrupt_trylock+0xd9> return 0; } /* if ( current < ceiling ) */ { executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED; 10e43e: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) the_mutex->lock = CORE_MUTEX_UNLOCKED; 10e445: c7 40 50 01 00 00 00 movl $0x1,0x50(%eax) the_mutex->nest_count = 0; /* undo locking above */ 10e44c: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) executing->resource_count--; /* undo locking above */ 10e453: ff 4a 1c decl 0x1c(%edx) _ISR_Enable( *level_p ); 10e456: ff 31 pushl (%ecx) 10e458: 9d popf 10e459: eb 25 jmp 10e480 <_CORE_mutex_Seize_interrupt_trylock+0xd0> /* * At this point, we know the mutex was not available. If this thread * is the thread that has locked the mutex, let's see if we are allowed * to nest access. */ if ( _Thread_Is_executing( the_mutex->holder ) ) { 10e45b: 8b 58 5c mov 0x5c(%eax),%ebx 10e45e: 39 d3 cmp %edx,%ebx 10e460: 75 22 jne 10e484 <_CORE_mutex_Seize_interrupt_trylock+0xd4> switch ( the_mutex->Attributes.lock_nesting_behavior ) { 10e462: 8b 50 40 mov 0x40(%eax),%edx 10e465: 85 d2 test %edx,%edx 10e467: 74 05 je 10e46e <_CORE_mutex_Seize_interrupt_trylock+0xbe> 10e469: 4a dec %edx 10e46a: 75 18 jne 10e484 <_CORE_mutex_Seize_interrupt_trylock+0xd4> 10e46c: eb 08 jmp 10e476 <_CORE_mutex_Seize_interrupt_trylock+0xc6> <== NOT EXECUTED case CORE_MUTEX_NESTING_ACQUIRES: the_mutex->nest_count++; 10e46e: ff 40 54 incl 0x54(%eax) _ISR_Enable( *level_p ); 10e471: ff 31 pushl (%ecx) 10e473: 9d popf 10e474: eb 0a jmp 10e480 <_CORE_mutex_Seize_interrupt_trylock+0xd0> return 0; case CORE_MUTEX_NESTING_IS_ERROR: executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED; 10e476: c7 43 34 02 00 00 00 movl $0x2,0x34(%ebx) <== NOT EXECUTED _ISR_Enable( *level_p ); 10e47d: ff 31 pushl (%ecx) <== NOT EXECUTED 10e47f: 9d popf <== NOT EXECUTED 10e480: 31 c0 xor %eax,%eax 10e482: eb 05 jmp 10e489 <_CORE_mutex_Seize_interrupt_trylock+0xd9> 10e484: b8 01 00 00 00 mov $0x1,%eax return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); } 10e489: 8b 5d fc mov -0x4(%ebp),%ebx 10e48c: c9 leave 10e48d: c3 ret 00109b5c <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 109b5c: 55 push %ebp 109b5d: 89 e5 mov %esp,%ebp 109b5f: 57 push %edi 109b60: 56 push %esi 109b61: 53 push %ebx 109b62: 83 ec 2c sub $0x2c,%esp 109b65: 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 ]; 109b68: 8b bb f0 00 00 00 mov 0xf0(%ebx),%edi option_set = (rtems_option) the_thread->Wait.option; 109b6e: 8b 43 30 mov 0x30(%ebx),%eax 109b71: 89 45 e0 mov %eax,-0x20(%ebp) _ISR_Disable( level ); 109b74: 9c pushf 109b75: fa cli 109b76: 58 pop %eax pending_events = api->pending_events; 109b77: 8b 17 mov (%edi),%edx 109b79: 89 55 d4 mov %edx,-0x2c(%ebp) event_condition = (rtems_event_set) the_thread->Wait.count; 109b7c: 8b 73 24 mov 0x24(%ebx),%esi seized_events = _Event_sets_Get( pending_events, event_condition ); /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { 109b7f: 21 f2 and %esi,%edx 109b81: 75 07 jne 109b8a <_Event_Surrender+0x2e> _ISR_Enable( level ); 109b83: 50 push %eax 109b84: 9d popf return; 109b85: e9 b0 00 00 00 jmp 109c3a <_Event_Surrender+0xde> /* * 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() && 109b8a: 8b 0d 4c 3a 12 00 mov 0x123a4c,%ecx 109b90: 85 c9 test %ecx,%ecx 109b92: 74 49 je 109bdd <_Event_Surrender+0x81> 109b94: 3b 1d 70 3a 12 00 cmp 0x123a70,%ebx 109b9a: 75 41 jne 109bdd <_Event_Surrender+0x81> _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 109b9c: 8b 0d 08 3c 12 00 mov 0x123c08,%ecx /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && 109ba2: 83 f9 02 cmp $0x2,%ecx 109ba5: 74 09 je 109bb0 <_Event_Surrender+0x54> _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { 109ba7: 8b 0d 08 3c 12 00 mov 0x123c08,%ecx /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && 109bad: 49 dec %ecx 109bae: 75 2d jne 109bdd <_Event_Surrender+0x81> _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 109bb0: 39 f2 cmp %esi,%edx 109bb2: 74 06 je 109bba <_Event_Surrender+0x5e> 109bb4: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109bb8: 74 1f je 109bd9 <_Event_Surrender+0x7d> api->pending_events = _Event_sets_Clear( pending_events,seized_events ); 109bba: 89 d6 mov %edx,%esi 109bbc: f7 d6 not %esi 109bbe: 23 75 d4 and -0x2c(%ebp),%esi 109bc1: 89 37 mov %esi,(%edi) the_thread->Wait.count = 0; 109bc3: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109bca: 8b 4b 28 mov 0x28(%ebx),%ecx 109bcd: 89 11 mov %edx,(%ecx) _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 109bcf: c7 05 08 3c 12 00 03 movl $0x3,0x123c08 109bd6: 00 00 00 } _ISR_Enable( level ); 109bd9: 50 push %eax 109bda: 9d popf return; 109bdb: eb 5d jmp 109c3a <_Event_Surrender+0xde> } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 109bdd: f6 43 11 01 testb $0x1,0x11(%ebx) 109be1: 74 55 je 109c38 <_Event_Surrender+0xdc> if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 109be3: 39 f2 cmp %esi,%edx 109be5: 74 06 je 109bed <_Event_Surrender+0x91> 109be7: f6 45 e0 02 testb $0x2,-0x20(%ebp) 109beb: 74 4b je 109c38 <_Event_Surrender+0xdc> api->pending_events = _Event_sets_Clear( pending_events, seized_events ); 109bed: 89 d6 mov %edx,%esi 109bef: f7 d6 not %esi 109bf1: 23 75 d4 and -0x2c(%ebp),%esi 109bf4: 89 37 mov %esi,(%edi) the_thread->Wait.count = 0; 109bf6: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109bfd: 8b 4b 28 mov 0x28(%ebx),%ecx 109c00: 89 11 mov %edx,(%ecx) _ISR_Flash( level ); 109c02: 50 push %eax 109c03: 9d popf 109c04: fa cli if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 109c05: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 109c09: 74 06 je 109c11 <_Event_Surrender+0xb5> _ISR_Enable( level ); 109c0b: 50 push %eax 109c0c: 9d popf RTEMS_INLINE_ROUTINE void _Thread_Unblock ( Thread_Control *the_thread ) { _Thread_Clear_state( the_thread, STATES_BLOCKED ); 109c0d: 51 push %ecx 109c0e: 51 push %ecx 109c0f: eb 17 jmp 109c28 <_Event_Surrender+0xcc> RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate( Watchdog_Control *the_watchdog ) { the_watchdog->state = WATCHDOG_REMOVE_IT; 109c11: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 109c18: 50 push %eax 109c19: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 109c1a: 83 ec 0c sub $0xc,%esp 109c1d: 8d 43 48 lea 0x48(%ebx),%eax 109c20: 50 push %eax 109c21: e8 ba 2d 00 00 call 10c9e0 <_Watchdog_Remove> 109c26: 58 pop %eax 109c27: 5a pop %edx 109c28: 68 f8 ff 03 10 push $0x1003fff8 109c2d: 53 push %ebx 109c2e: e8 b5 1b 00 00 call 10b7e8 <_Thread_Clear_state> 109c33: 83 c4 10 add $0x10,%esp 109c36: eb 02 jmp 109c3a <_Event_Surrender+0xde> _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 109c38: 50 push %eax <== NOT EXECUTED 109c39: 9d popf <== NOT EXECUTED } 109c3a: 8d 65 f4 lea -0xc(%ebp),%esp 109c3d: 5b pop %ebx 109c3e: 5e pop %esi 109c3f: 5f pop %edi 109c40: c9 leave 109c41: c3 ret 0010aef4 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10aef4: 55 push %ebp 10aef5: 89 e5 mov %esp,%ebp 10aef7: 53 push %ebx 10aef8: 83 ec 08 sub $0x8,%esp 10aefb: 8b 45 08 mov 0x8(%ebp),%eax 10aefe: 8b 55 0c mov 0xc(%ebp),%edx 10af01: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10af04: a3 58 3a 12 00 mov %eax,0x123a58 _Internal_errors_What_happened.is_internal = is_internal; 10af09: 88 15 5c 3a 12 00 mov %dl,0x123a5c _Internal_errors_What_happened.the_error = the_error; 10af0f: 89 1d 60 3a 12 00 mov %ebx,0x123a60 _User_extensions_Fatal( the_source, is_internal, the_error ); 10af15: 53 push %ebx 10af16: 0f b6 d2 movzbl %dl,%edx 10af19: 52 push %edx 10af1a: 50 push %eax 10af1b: e8 8b 18 00 00 call 10c7ab <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 10af20: c7 05 4c 3b 12 00 05 movl $0x5,0x123b4c <== NOT EXECUTED 10af27: 00 00 00 <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10af2a: fa cli <== NOT EXECUTED 10af2b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10af2d: f4 hlt <== NOT EXECUTED 10af2e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af31: eb fe jmp 10af31 <_Internal_error_Occurred+0x3d> <== NOT EXECUTED 0010b3f8 <_Objects_Initialize_information>: , bool supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 10b3f8: 55 push %ebp 10b3f9: 89 e5 mov %esp,%ebp 10b3fb: 57 push %edi 10b3fc: 56 push %esi 10b3fd: 53 push %ebx 10b3fe: 83 ec 1c sub $0x1c,%esp 10b401: 8b 45 08 mov 0x8(%ebp),%eax 10b404: 8b 55 0c mov 0xc(%ebp),%edx 10b407: 8b 75 10 mov 0x10(%ebp),%esi 10b40a: 8b 5d 14 mov 0x14(%ebp),%ebx 10b40d: 8b 4d 20 mov 0x20(%ebp),%ecx 10b410: 89 4d e4 mov %ecx,-0x1c(%ebp) 10b413: 0f b7 7d 18 movzwl 0x18(%ebp),%edi uint32_t maximum_per_allocation; #if defined(RTEMS_MULTIPROCESSING) uint32_t index; #endif information->the_api = the_api; 10b417: 89 10 mov %edx,(%eax) information->the_class = the_class; 10b419: 66 89 70 04 mov %si,0x4(%eax) information->size = size; 10b41d: 89 78 18 mov %edi,0x18(%eax) information->local_table = 0; 10b420: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) information->inactive_per_block = 0; 10b427: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) information->object_blocks = 0; 10b42e: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) information->inactive = 0; 10b435: 66 c7 40 2c 00 00 movw $0x0,0x2c(%eax) /* * Set the maximum value to 0. It will be updated when objects are * added to the inactive set from _Objects_Extend_information() */ information->maximum = 0; 10b43b: 66 c7 40 10 00 00 movw $0x0,0x10(%eax) /* * Register this Object Class in the Object Information Table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 10b441: 8b 3c 95 88 39 12 00 mov 0x123988(,%edx,4),%edi 10b448: 89 04 b7 mov %eax,(%edi,%esi,4) /* * Are we operating in limited or unlimited (e.g. auto-extend) mode. */ information->auto_extend = (maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false; 10b44b: 89 df mov %ebx,%edi 10b44d: c1 ef 1f shr $0x1f,%edi _Objects_Information_table[ the_api ][ the_class ] = information; /* * Are we operating in limited or unlimited (e.g. auto-extend) mode. */ information->auto_extend = 10b450: 89 f9 mov %edi,%ecx 10b452: 88 48 12 mov %cl,0x12(%eax) (maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false; maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS; 10b455: 89 d9 mov %ebx,%ecx 10b457: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx /* * Unlimited and maximum of zero is illogical. */ if ( information->auto_extend && maximum_per_allocation == 0) { 10b45d: 85 ff test %edi,%edi 10b45f: 74 10 je 10b471 <_Objects_Initialize_information+0x79> 10b461: 85 c9 test %ecx,%ecx 10b463: 75 0c jne 10b471 <_Objects_Initialize_information+0x79> _Internal_error_Occurred( 10b465: 50 push %eax 10b466: 6a 14 push $0x14 10b468: 6a 01 push $0x1 10b46a: 6a 00 push $0x0 10b46c: e8 83 fa ff ff call 10aef4 <_Internal_error_Occurred> } /* * The allocation unit is the maximum value */ information->allocation_size = maximum_per_allocation; 10b471: 66 89 48 14 mov %cx,0x14(%eax) /* * Provide a null local table entry for the case of any empty table. */ information->local_table = &null_local_table; 10b475: c7 40 1c 50 36 12 00 movl $0x123650,0x1c(%eax) /* * Calculate minimum and maximum Id's */ minimum_index = (maximum_per_allocation == 0) ? 0 : 1; information->minimum_id = 10b47c: c1 e2 18 shl $0x18,%edx 10b47f: 81 ca 00 00 01 00 or $0x10000,%edx 10b485: c1 e6 1b shl $0x1b,%esi 10b488: 09 f2 or %esi,%edx 10b48a: 85 c9 test %ecx,%ecx 10b48c: 0f 95 c3 setne %bl 10b48f: 89 de mov %ebx,%esi 10b491: 81 e6 ff 00 00 00 and $0xff,%esi 10b497: 09 f2 or %esi,%edx 10b499: 89 50 08 mov %edx,0x8(%eax) /* * Calculate the maximum name length */ name_length = maximum_name_length; if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) 10b49c: 8b 55 e4 mov -0x1c(%ebp),%edx 10b49f: f6 c2 03 test $0x3,%dl 10b4a2: 74 06 je 10b4aa <_Objects_Initialize_information+0xb2> name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & 10b4a4: 83 c2 04 add $0x4,%edx <== NOT EXECUTED 10b4a7: 83 e2 fc and $0xfffffffc,%edx <== NOT EXECUTED ~(OBJECTS_NAME_ALIGNMENT-1); information->name_length = name_length; 10b4aa: 66 89 50 38 mov %dx,0x38(%eax) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 10b4ae: 8d 50 24 lea 0x24(%eax),%edx 10b4b1: 89 50 20 mov %edx,0x20(%eax) the_chain->permanent_null = NULL; 10b4b4: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) the_chain->last = _Chain_Head(the_chain); 10b4bb: 8d 50 20 lea 0x20(%eax),%edx 10b4be: 89 50 28 mov %edx,0x28(%eax) _Chain_Initialize_empty( &information->Inactive ); /* * Initialize objects .. if there are any */ if ( maximum_per_allocation ) { 10b4c1: 85 c9 test %ecx,%ecx 10b4c3: 74 0f je 10b4d4 <_Objects_Initialize_information+0xdc> /* * Always have the maximum size available so the current performance * figures are create are met. If the user moves past the maximum * number then a performance hit is taken. */ _Objects_Extend_information( information ); 10b4c5: 89 45 08 mov %eax,0x8(%ebp) _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10b4c8: 8d 65 f4 lea -0xc(%ebp),%esp 10b4cb: 5b pop %ebx 10b4cc: 5e pop %esi 10b4cd: 5f pop %edi 10b4ce: c9 leave /* * Always have the maximum size available so the current performance * figures are create are met. If the user moves past the maximum * number then a performance hit is taken. */ _Objects_Extend_information( information ); 10b4cf: e9 4c fb ff ff jmp 10b020 <_Objects_Extend_information> _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10b4d4: 8d 65 f4 lea -0xc(%ebp),%esp 10b4d7: 5b pop %ebx 10b4d8: 5e pop %esi 10b4d9: 5f pop %edi 10b4da: c9 leave 10b4db: c3 ret 0010c05c <_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 ) { 10c05c: 55 push %ebp 10c05d: 89 e5 mov %esp,%ebp 10c05f: 57 push %edi 10c060: 56 push %esi 10c061: 53 push %ebx 10c062: 83 ec 10 sub $0x10,%esp 10c065: 8b 4d 08 mov 0x8(%ebp),%ecx 10c068: 8b 45 0c mov 0xc(%ebp),%eax */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 10c06b: 8d 50 3c lea 0x3c(%eax),%edx 10c06e: 89 50 38 mov %edx,0x38(%eax) the_chain->permanent_null = NULL; 10c071: c7 40 3c 00 00 00 00 movl $0x0,0x3c(%eax) the_chain->last = _Chain_Head(the_chain); 10c078: 8d 50 38 lea 0x38(%eax),%edx 10c07b: 89 50 40 mov %edx,0x40(%eax) Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 10c07e: 8b 58 14 mov 0x14(%eax),%ebx header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 10c081: 89 de mov %ebx,%esi 10c083: c1 ee 06 shr $0x6,%esi 10c086: 6b f6 0c imul $0xc,%esi,%esi 10c089: 8d 34 31 lea (%ecx,%esi,1),%esi block_state = the_thread_queue->state; 10c08c: 8b 79 38 mov 0x38(%ecx),%edi if ( _Thread_queue_Is_reverse_search( priority ) ) 10c08f: f6 c3 20 test $0x20,%bl 10c092: 75 70 jne 10c104 <_Thread_queue_Enqueue_priority+0xa8> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10c094: 8d 56 04 lea 0x4(%esi),%edx 10c097: 89 55 e8 mov %edx,-0x18(%ebp) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 10c09a: 9c pushf 10c09b: fa cli 10c09c: 8f 45 f0 popl -0x10(%ebp) search_thread = (Thread_Control *) header->first; 10c09f: 8b 16 mov (%esi),%edx 10c0a1: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp) 10c0a8: 89 75 e4 mov %esi,-0x1c(%ebp) while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c0ab: eb 1f jmp 10c0cc <_Thread_queue_Enqueue_priority+0x70> search_priority = search_thread->current_priority; 10c0ad: 8b 72 14 mov 0x14(%edx),%esi 10c0b0: 89 75 ec mov %esi,-0x14(%ebp) if ( priority <= search_priority ) 10c0b3: 39 f3 cmp %esi,%ebx 10c0b5: 76 1a jbe 10c0d1 <_Thread_queue_Enqueue_priority+0x75> break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10c0b7: ff 75 f0 pushl -0x10(%ebp) 10c0ba: 9d popf 10c0bb: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c0bc: 85 7a 10 test %edi,0x10(%edx) 10c0bf: 75 09 jne 10c0ca <_Thread_queue_Enqueue_priority+0x6e> 10c0c1: 8b 75 e4 mov -0x1c(%ebp),%esi <== NOT EXECUTED _ISR_Enable( level ); 10c0c4: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10c0c7: 9d popf <== NOT EXECUTED goto restart_forward_search; 10c0c8: eb d0 jmp 10c09a <_Thread_queue_Enqueue_priority+0x3e> <== NOT EXECUTED } search_thread = (Thread_Control *)search_thread->Object.Node.next; 10c0ca: 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 ) ) { 10c0cc: 3b 55 e8 cmp -0x18(%ebp),%edx 10c0cf: 75 dc jne 10c0ad <_Thread_queue_Enqueue_priority+0x51> 10c0d1: 8b 75 f0 mov -0x10(%ebp),%esi } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10c0d4: 83 79 30 01 cmpl $0x1,0x30(%ecx) 10c0d8: 0f 85 a9 00 00 00 jne 10c187 <_Thread_queue_Enqueue_priority+0x12b> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c0de: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) if ( priority == search_priority ) 10c0e5: 3b 5d ec cmp -0x14(%ebp),%ebx 10c0e8: 0f 84 82 00 00 00 je 10c170 <_Thread_queue_Enqueue_priority+0x114> goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10c0ee: 8b 5a 04 mov 0x4(%edx),%ebx the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c0f1: 89 10 mov %edx,(%eax) the_node->previous = previous_node; 10c0f3: 89 58 04 mov %ebx,0x4(%eax) previous_node->next = the_node; 10c0f6: 89 03 mov %eax,(%ebx) search_node->previous = the_node; 10c0f8: 89 42 04 mov %eax,0x4(%edx) the_thread->Wait.queue = the_thread_queue; 10c0fb: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c0fe: ff 75 f0 pushl -0x10(%ebp) 10c101: 9d popf 10c102: eb 65 jmp 10c169 <_Thread_queue_Enqueue_priority+0x10d> return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 10c104: 0f b6 15 34 fa 11 00 movzbl 0x11fa34,%edx 10c10b: 42 inc %edx 10c10c: 89 55 ec mov %edx,-0x14(%ebp) _ISR_Disable( level ); 10c10f: 9c pushf 10c110: fa cli 10c111: 8f 45 f0 popl -0x10(%ebp) search_thread = (Thread_Control *) header->last; 10c114: 8b 56 08 mov 0x8(%esi),%edx 10c117: 89 75 e8 mov %esi,-0x18(%ebp) while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c11a: eb 20 jmp 10c13c <_Thread_queue_Enqueue_priority+0xe0> search_priority = search_thread->current_priority; 10c11c: 8b 72 14 mov 0x14(%edx),%esi 10c11f: 89 75 ec mov %esi,-0x14(%ebp) if ( priority >= search_priority ) 10c122: 39 f3 cmp %esi,%ebx 10c124: 73 1b jae 10c141 <_Thread_queue_Enqueue_priority+0xe5> break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 10c126: ff 75 f0 pushl -0x10(%ebp) 10c129: 9d popf 10c12a: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c12b: 85 7a 10 test %edi,0x10(%edx) 10c12e: 75 09 jne 10c139 <_Thread_queue_Enqueue_priority+0xdd> 10c130: 8b 75 e8 mov -0x18(%ebp),%esi _ISR_Enable( level ); 10c133: ff 75 f0 pushl -0x10(%ebp) 10c136: 9d popf goto restart_reverse_search; 10c137: eb cb jmp 10c104 <_Thread_queue_Enqueue_priority+0xa8> } search_thread = (Thread_Control *) 10c139: 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 ) ) { 10c13c: 3b 55 e8 cmp -0x18(%ebp),%edx 10c13f: 75 db jne 10c11c <_Thread_queue_Enqueue_priority+0xc0> 10c141: 8b 75 f0 mov -0x10(%ebp),%esi } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10c144: 83 79 30 01 cmpl $0x1,0x30(%ecx) 10c148: 75 3d jne 10c187 <_Thread_queue_Enqueue_priority+0x12b> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c14a: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) if ( priority == search_priority ) 10c151: 3b 5d ec cmp -0x14(%ebp),%ebx 10c154: 74 1a je 10c170 <_Thread_queue_Enqueue_priority+0x114> goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10c156: 8b 1a mov (%edx),%ebx the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10c158: 89 18 mov %ebx,(%eax) the_node->previous = search_node; 10c15a: 89 50 04 mov %edx,0x4(%eax) search_node->next = the_node; 10c15d: 89 02 mov %eax,(%edx) next_node->previous = the_node; 10c15f: 89 43 04 mov %eax,0x4(%ebx) the_thread->Wait.queue = the_thread_queue; 10c162: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c165: ff 75 f0 pushl -0x10(%ebp) 10c168: 9d popf 10c169: b8 01 00 00 00 mov $0x1,%eax return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10c16e: eb 1f jmp 10c18f <_Thread_queue_Enqueue_priority+0x133> 10c170: 83 c2 3c add $0x3c,%edx equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 10c173: 8b 5a 04 mov 0x4(%edx),%ebx the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c176: 89 10 mov %edx,(%eax) the_node->previous = previous_node; 10c178: 89 58 04 mov %ebx,0x4(%eax) previous_node->next = the_node; 10c17b: 89 03 mov %eax,(%ebx) search_node->previous = the_node; 10c17d: 89 42 04 mov %eax,0x4(%edx) the_thread->Wait.queue = the_thread_queue; 10c180: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c183: 56 push %esi 10c184: 9d popf 10c185: eb e2 jmp 10c169 <_Thread_queue_Enqueue_priority+0x10d> * 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; 10c187: 8b 45 10 mov 0x10(%ebp),%eax 10c18a: 89 30 mov %esi,(%eax) return the_thread_queue->sync_state; 10c18c: 8b 41 30 mov 0x30(%ecx),%eax } 10c18f: 83 c4 10 add $0x10,%esp 10c192: 5b pop %ebx 10c193: 5e pop %esi 10c194: 5f pop %edi 10c195: c9 leave 10c196: c3 ret 0010c779 <_User_extensions_Thread_exitted>: void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 10c779: 55 push %ebp 10c77a: 89 e5 mov %esp,%ebp 10c77c: 56 push %esi 10c77d: 53 push %ebx 10c77e: 8b 75 08 mov 0x8(%ebp),%esi Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10c781: 8b 1d cc 3b 12 00 mov 0x123bcc,%ebx 10c787: eb 13 jmp 10c79c <_User_extensions_Thread_exitted+0x23> !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) 10c789: 8b 43 2c mov 0x2c(%ebx),%eax 10c78c: 85 c0 test %eax,%eax 10c78e: 74 09 je 10c799 <_User_extensions_Thread_exitted+0x20> (*the_extension->Callouts.thread_exitted)( executing ); 10c790: 83 ec 0c sub $0xc,%esp 10c793: 56 push %esi 10c794: ff d0 call *%eax 10c796: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { 10c799: 8b 5b 04 mov 0x4(%ebx),%ebx { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10c79c: 81 fb c4 3b 12 00 cmp $0x123bc4,%ebx 10c7a2: 75 e5 jne 10c789 <_User_extensions_Thread_exitted+0x10> the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) (*the_extension->Callouts.thread_exitted)( executing ); } } 10c7a4: 8d 65 f8 lea -0x8(%ebp),%esp 10c7a7: 5b pop %ebx 10c7a8: 5e pop %esi 10c7a9: c9 leave 10c7aa: c3 ret 0012172e <__kill>: #endif int __kill( pid_t pid, int sig ) { 12172e: 55 push %ebp <== NOT EXECUTED 12172f: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 121731: 31 c0 xor %eax,%eax <== NOT EXECUTED 121733: c9 leave <== NOT EXECUTED 121734: c3 ret <== NOT EXECUTED 0011b788 <_exit>: /* * If the toolset uses init/fini sections, then we need to * run the global destructors now. */ #if defined(__USE_INIT_FINI__) FINI_SYMBOL(); 11b788: 55 push %ebp 11b789: 89 e5 mov %esp,%ebp 11b78b: 83 ec 08 sub $0x8,%esp 11b78e: e8 6a 06 00 00 call 11bdfd <_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(); 11b793: e8 8c ff ff ff call 11b724 rtems_shutdown_executive(status); 11b798: 83 ec 0c sub $0xc,%esp 11b79b: ff 75 08 pushl 0x8(%ebp) 11b79e: e8 e9 00 00 00 call 11b88c 11b7a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11b7a6: eb fe jmp 11b7a6 <_exit+0x1e> <== NOT EXECUTED 00134116 <_fcntl_r>: struct _reent *ptr __attribute__((unused)), int fd, int cmd, int arg ) { 134116: 55 push %ebp <== NOT EXECUTED 134117: 89 e5 mov %esp,%ebp <== NOT EXECUTED 134119: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 13411c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 13411f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return fcntl( fd, cmd, arg ); 134122: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 134125: 89 4d 10 mov %ecx,0x10(%ebp) <== NOT EXECUTED 134128: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 13412b: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 13412e: c9 leave <== NOT EXECUTED int fd, int cmd, int arg ) { return fcntl( fd, cmd, arg ); 13412f: e9 98 fe ff ff jmp 133fcc <== NOT EXECUTED 00121702 <_getpid_r>: #include pid_t _getpid_r( struct _reent *ptr __attribute__((unused)) ) { 121702: 55 push %ebp <== NOT EXECUTED 121703: 89 e5 mov %esp,%ebp <== NOT EXECUTED return getpid(); } 121705: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 12170a: c9 leave <== NOT EXECUTED 12170b: c3 ret <== NOT EXECUTED 0010dca3 <_gettimeofday>: int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { 10dca3: 55 push %ebp <== NOT EXECUTED 10dca4: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dca6: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED return gettimeofday( tp, tzp ); } 10dca9: c9 leave <== NOT EXECUTED int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp ); 10dcaa: e9 a5 ff ff ff jmp 10dc54 <== NOT EXECUTED 00121727 <_kill_r>: #if defined(RTEMS_NEWLIB) #include int _kill_r( struct _reent *ptr, pid_t pid, int sig ) { 121727: 55 push %ebp <== NOT EXECUTED 121728: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 12172a: 31 c0 xor %eax,%eax <== NOT EXECUTED 12172c: c9 leave <== NOT EXECUTED 12172d: c3 ret <== NOT EXECUTED 001261f2 <_link_r>: int _link_r( struct _reent *ptr __attribute__((unused)), const char *existing, const char *new ) { 1261f2: 55 push %ebp <== NOT EXECUTED 1261f3: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1261f5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1261f8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED return link( existing, new ); 1261fb: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 1261fe: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 126201: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 126204: c9 leave <== NOT EXECUTED struct _reent *ptr __attribute__((unused)), const char *existing, const char *new ) { return link( existing, new ); 126205: e9 26 fe ff ff jmp 126030 <== NOT EXECUTED 001263ae <_lstat_r>: int _STAT_R_NAME( struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { 1263ae: 55 push %ebp <== NOT EXECUTED 1263af: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1263b1: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1263b4: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED return _STAT_NAME( path, buf ); 1263b7: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 1263ba: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 1263bd: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 1263c0: c9 leave <== NOT EXECUTED struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { return _STAT_NAME( path, buf ); 1263c1: e9 3a ff ff ff jmp 126300 <== NOT EXECUTED 0011b854 <_realloc_r>: void *_realloc_r( struct _reent *ignored __attribute__((unused)), void *ptr, size_t size ) { 11b854: 55 push %ebp <== NOT EXECUTED 11b855: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11b857: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11b85a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED return realloc( ptr, size ); 11b85d: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 11b860: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 11b863: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 11b866: c9 leave <== NOT EXECUTED struct _reent *ignored __attribute__((unused)), void *ptr, size_t size ) { return realloc( ptr, size ); 11b867: e9 48 00 00 00 jmp 11b8b4 <== NOT EXECUTED 0014e6cc <_rename_r>: int _rename_r( struct _reent *ptr __attribute__((unused)), const char *old, const char *new ) { 14e6cc: 55 push %ebp <== NOT EXECUTED 14e6cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 14e6cf: 57 push %edi <== NOT EXECUTED 14e6d0: 56 push %esi <== NOT EXECUTED 14e6d1: 53 push %ebx <== NOT EXECUTED 14e6d2: 83 ec 68 sub $0x68,%esp <== NOT EXECUTED /* * Get the parent node of the old path to be renamed. Find the parent path. */ old_parent_pathlen = rtems_filesystem_dirname ( old ); 14e6d5: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 14e6d8: e8 fe ce fb ff call 10b5db <== NOT EXECUTED 14e6dd: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( old_parent_pathlen == 0 ) 14e6df: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 14e6e2: 85 c0 test %eax,%eax <== NOT EXECUTED 14e6e4: 75 36 jne 14e71c <_rename_r+0x50> <== NOT EXECUTED rtems_filesystem_get_start_loc( old, &i, &old_parent_loc ); 14e6e6: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 14e6e9: 8a 01 mov (%ecx),%al <== NOT EXECUTED 14e6eb: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 14e6ed: 74 08 je 14e6f7 <_rename_r+0x2b> <== NOT EXECUTED 14e6ef: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 14e6f1: 74 04 je 14e6f7 <_rename_r+0x2b> <== NOT EXECUTED 14e6f3: 84 c0 test %al,%al <== NOT EXECUTED 14e6f5: 75 0e jne 14e705 <_rename_r+0x39> <== NOT EXECUTED 14e6f7: 8d 7d bc lea -0x44(%ebp),%edi <== NOT EXECUTED 14e6fa: 8b 35 dc e1 15 00 mov 0x15e1dc,%esi <== NOT EXECUTED 14e700: 83 c6 18 add $0x18,%esi <== NOT EXECUTED 14e703: eb 0c jmp 14e711 <_rename_r+0x45> <== NOT EXECUTED 14e705: 8d 7d bc lea -0x44(%ebp),%edi <== NOT EXECUTED 14e708: 8b 35 dc e1 15 00 mov 0x15e1dc,%esi <== NOT EXECUTED 14e70e: 83 c6 04 add $0x4,%esi <== NOT EXECUTED 14e711: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 14e716: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 14e718: 31 db xor %ebx,%ebx <== NOT EXECUTED 14e71a: eb 2a jmp 14e746 <_rename_r+0x7a> <== NOT EXECUTED else { result = rtems_filesystem_evaluate_path( old, old_parent_pathlen, 14e71c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14e71f: 6a 00 push $0x0 <== NOT EXECUTED 14e721: 8d 45 bc lea -0x44(%ebp),%eax <== NOT EXECUTED 14e724: 50 push %eax <== NOT EXECUTED 14e725: 6a 02 push $0x2 <== NOT EXECUTED 14e727: 52 push %edx <== NOT EXECUTED 14e728: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 14e72b: 89 55 a4 mov %edx,-0x5c(%ebp) <== NOT EXECUTED 14e72e: e8 95 cf fb ff call 10b6c8 <== NOT EXECUTED RTEMS_LIBIO_PERMS_WRITE, &old_parent_loc, false ); if ( result != 0 ) 14e733: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 14e736: b3 01 mov $0x1,%bl <== NOT EXECUTED 14e738: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 14e73b: 85 c0 test %eax,%eax <== NOT EXECUTED 14e73d: 8b 55 a4 mov -0x5c(%ebp),%edx <== NOT EXECUTED 14e740: 0f 85 6f 02 00 00 jne 14e9b5 <_rename_r+0x2e9> <== NOT EXECUTED /* * Start from the parent to find the node that should be under it. */ old_loc = old_parent_loc; 14e746: 8d 7d d0 lea -0x30(%ebp),%edi <== NOT EXECUTED 14e749: 8d 75 bc lea -0x44(%ebp),%esi <== NOT EXECUTED 14e74c: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 14e751: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED name = old + old_parent_pathlen; 14e753: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 14e756: 01 d6 add %edx,%esi <== NOT EXECUTED 14e758: 89 75 e4 mov %esi,-0x1c(%ebp) <== NOT EXECUTED name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 14e75b: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 14e75e: 89 f7 mov %esi,%edi <== NOT EXECUTED 14e760: 31 c0 xor %eax,%eax <== NOT EXECUTED 14e762: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 14e764: f7 d1 not %ecx <== NOT EXECUTED 14e766: 49 dec %ecx <== NOT EXECUTED 14e767: 57 push %edi <== NOT EXECUTED 14e768: 57 push %edi <== NOT EXECUTED 14e769: 51 push %ecx <== NOT EXECUTED 14e76a: 56 push %esi <== NOT EXECUTED 14e76b: e8 44 ce fb ff call 10b5b4 <== NOT EXECUTED 14e770: 01 c6 add %eax,%esi <== NOT EXECUTED 14e772: 89 75 e4 mov %esi,-0x1c(%ebp) <== NOT EXECUTED result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 14e775: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 14e778: 89 f7 mov %esi,%edi <== NOT EXECUTED 14e77a: 31 c0 xor %eax,%eax <== NOT EXECUTED 14e77c: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 14e77e: f7 d1 not %ecx <== NOT EXECUTED 14e780: 49 dec %ecx <== NOT EXECUTED 14e781: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED 14e788: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 14e78b: 50 push %eax <== NOT EXECUTED 14e78c: 6a 00 push $0x0 <== NOT EXECUTED 14e78e: 51 push %ecx <== NOT EXECUTED 14e78f: 56 push %esi <== NOT EXECUTED 14e790: e8 79 ce fb ff call 10b60e <== NOT EXECUTED 14e795: 89 c6 mov %eax,%esi <== NOT EXECUTED 0, &old_loc, false ); if ( result != 0 ) { 14e797: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 14e79a: 85 c0 test %eax,%eax <== NOT EXECUTED 14e79c: 74 29 je 14e7c7 <_rename_r+0xfb> <== NOT EXECUTED if ( free_old_parentloc ) 14e79e: 84 db test %bl,%bl <== NOT EXECUTED 14e7a0: 0f 84 1d 01 00 00 je 14e8c3 <_rename_r+0x1f7> <== NOT EXECUTED rtems_filesystem_freenode( &old_parent_loc ); 14e7a6: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 14e7a9: 85 c0 test %eax,%eax <== NOT EXECUTED 14e7ab: 0f 84 12 01 00 00 je 14e8c3 <_rename_r+0x1f7> <== NOT EXECUTED 14e7b1: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14e7b4: 85 c0 test %eax,%eax <== NOT EXECUTED 14e7b6: 0f 84 07 01 00 00 je 14e8c3 <_rename_r+0x1f7> <== NOT EXECUTED 14e7bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14e7bf: 8d 55 bc lea -0x44(%ebp),%edx <== NOT EXECUTED 14e7c2: e9 f6 00 00 00 jmp 14e8bd <_rename_r+0x1f1> <== NOT EXECUTED /* * Get the parent of the new node we are renaming to. */ rtems_filesystem_get_start_loc( new, &i, &new_parent_loc ); 14e7c7: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 14e7ca: 8a 02 mov (%edx),%al <== NOT EXECUTED 14e7cc: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 14e7ce: 74 08 je 14e7d8 <_rename_r+0x10c> <== NOT EXECUTED 14e7d0: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 14e7d2: 74 04 je 14e7d8 <_rename_r+0x10c> <== NOT EXECUTED 14e7d4: 84 c0 test %al,%al <== NOT EXECUTED 14e7d6: 75 1a jne 14e7f2 <_rename_r+0x126> <== NOT EXECUTED 14e7d8: 8d 7d a8 lea -0x58(%ebp),%edi <== NOT EXECUTED 14e7db: 8b 35 dc e1 15 00 mov 0x15e1dc,%esi <== NOT EXECUTED 14e7e1: 83 c6 18 add $0x18,%esi <== NOT EXECUTED 14e7e4: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 14e7e9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 14e7eb: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 14e7f0: eb 15 jmp 14e807 <_rename_r+0x13b> <== NOT EXECUTED 14e7f2: 8d 7d a8 lea -0x58(%ebp),%edi <== NOT EXECUTED 14e7f5: 8b 35 dc e1 15 00 mov 0x15e1dc,%esi <== NOT EXECUTED 14e7fb: 83 c6 04 add $0x4,%esi <== NOT EXECUTED 14e7fe: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 14e803: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 14e805: 31 d2 xor %edx,%edx <== NOT EXECUTED if ( !new_parent_loc.ops->evalformake_h ) { 14e807: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED 14e80a: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 14e80d: 85 c0 test %eax,%eax <== NOT EXECUTED 14e80f: 75 4b jne 14e85c <_rename_r+0x190> <== NOT EXECUTED if ( free_old_parentloc ) 14e811: 84 db test %bl,%bl <== NOT EXECUTED 14e813: 74 1a je 14e82f <_rename_r+0x163> <== NOT EXECUTED rtems_filesystem_freenode( &old_parent_loc ); 14e815: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 14e818: 85 c0 test %eax,%eax <== NOT EXECUTED 14e81a: 74 13 je 14e82f <_rename_r+0x163> <== NOT EXECUTED 14e81c: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14e81f: 85 c0 test %eax,%eax <== NOT EXECUTED 14e821: 74 0c je 14e82f <_rename_r+0x163> <== NOT EXECUTED 14e823: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14e826: 8d 55 bc lea -0x44(%ebp),%edx <== NOT EXECUTED 14e829: 52 push %edx <== NOT EXECUTED 14e82a: ff d0 call *%eax <== NOT EXECUTED 14e82c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &old_loc ); 14e82f: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 14e832: 85 c0 test %eax,%eax <== NOT EXECUTED 14e834: 74 13 je 14e849 <_rename_r+0x17d> <== NOT EXECUTED 14e836: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14e839: 85 c0 test %eax,%eax <== NOT EXECUTED 14e83b: 74 0c je 14e849 <_rename_r+0x17d> <== NOT EXECUTED 14e83d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14e840: 8d 55 d0 lea -0x30(%ebp),%edx <== NOT EXECUTED 14e843: 52 push %edx <== NOT EXECUTED 14e844: ff d0 call *%eax <== NOT EXECUTED 14e846: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 14e849: e8 2a 9f fe ff call 138778 <__errno> <== NOT EXECUTED 14e84e: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 14e854: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 14e857: e9 59 01 00 00 jmp 14e9b5 <_rename_r+0x2e9> <== NOT EXECUTED } result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name ); 14e85c: 51 push %ecx <== NOT EXECUTED 14e85d: 8d 4d e4 lea -0x1c(%ebp),%ecx <== NOT EXECUTED 14e860: 51 push %ecx <== NOT EXECUTED 14e861: 8d 7d a8 lea -0x58(%ebp),%edi <== NOT EXECUTED 14e864: 57 push %edi <== NOT EXECUTED 14e865: 03 55 10 add 0x10(%ebp),%edx <== NOT EXECUTED 14e868: 52 push %edx <== NOT EXECUTED 14e869: ff d0 call *%eax <== NOT EXECUTED 14e86b: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( result != 0 ) { 14e86d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 14e870: 85 c0 test %eax,%eax <== NOT EXECUTED 14e872: 74 58 je 14e8cc <_rename_r+0x200> <== NOT EXECUTED rtems_filesystem_freenode( &new_parent_loc ); 14e874: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED 14e877: 85 c0 test %eax,%eax <== NOT EXECUTED 14e879: 74 10 je 14e88b <_rename_r+0x1bf> <== NOT EXECUTED 14e87b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14e87e: 85 c0 test %eax,%eax <== NOT EXECUTED 14e880: 74 09 je 14e88b <_rename_r+0x1bf> <== NOT EXECUTED 14e882: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14e885: 57 push %edi <== NOT EXECUTED 14e886: ff d0 call *%eax <== NOT EXECUTED 14e888: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( free_old_parentloc ) 14e88b: 84 db test %bl,%bl <== NOT EXECUTED 14e88d: 74 1a je 14e8a9 <_rename_r+0x1dd> <== NOT EXECUTED rtems_filesystem_freenode( &old_parent_loc ); 14e88f: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 14e892: 85 c0 test %eax,%eax <== NOT EXECUTED 14e894: 74 13 je 14e8a9 <_rename_r+0x1dd> <== NOT EXECUTED 14e896: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14e899: 85 c0 test %eax,%eax <== NOT EXECUTED 14e89b: 74 0c je 14e8a9 <_rename_r+0x1dd> <== NOT EXECUTED 14e89d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14e8a0: 8d 55 bc lea -0x44(%ebp),%edx <== NOT EXECUTED 14e8a3: 52 push %edx <== NOT EXECUTED 14e8a4: ff d0 call *%eax <== NOT EXECUTED 14e8a6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &old_loc ); 14e8a9: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 14e8ac: 85 c0 test %eax,%eax <== NOT EXECUTED 14e8ae: 74 13 je 14e8c3 <_rename_r+0x1f7> <== NOT EXECUTED 14e8b0: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14e8b3: 85 c0 test %eax,%eax <== NOT EXECUTED 14e8b5: 74 0c je 14e8c3 <_rename_r+0x1f7> <== NOT EXECUTED 14e8b7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14e8ba: 8d 55 d0 lea -0x30(%ebp),%edx <== NOT EXECUTED 14e8bd: 52 push %edx <== NOT EXECUTED 14e8be: ff d0 call *%eax <== NOT EXECUTED 14e8c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( result ); 14e8c3: e8 b0 9e fe ff call 138778 <__errno> <== NOT EXECUTED 14e8c8: 89 30 mov %esi,(%eax) <== NOT EXECUTED 14e8ca: eb 88 jmp 14e854 <_rename_r+0x188> <== NOT EXECUTED /* * Check to see if the caller is trying to rename across file system * boundaries. */ if ( old_parent_loc.mt_entry != new_parent_loc.mt_entry ) { 14e8cc: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 14e8cf: 3b 45 b8 cmp -0x48(%ebp),%eax <== NOT EXECUTED 14e8d2: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED 14e8d5: 74 5c je 14e933 <_rename_r+0x267> <== NOT EXECUTED rtems_filesystem_freenode( &new_parent_loc ); 14e8d7: 85 c0 test %eax,%eax <== NOT EXECUTED 14e8d9: 74 10 je 14e8eb <_rename_r+0x21f> <== NOT EXECUTED 14e8db: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14e8de: 85 c0 test %eax,%eax <== NOT EXECUTED 14e8e0: 74 09 je 14e8eb <_rename_r+0x21f> <== NOT EXECUTED 14e8e2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14e8e5: 57 push %edi <== NOT EXECUTED 14e8e6: ff d0 call *%eax <== NOT EXECUTED 14e8e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( free_old_parentloc ) 14e8eb: 84 db test %bl,%bl <== NOT EXECUTED 14e8ed: 74 1a je 14e909 <_rename_r+0x23d> <== NOT EXECUTED rtems_filesystem_freenode( &old_parent_loc ); 14e8ef: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 14e8f2: 85 c0 test %eax,%eax <== NOT EXECUTED 14e8f4: 74 13 je 14e909 <_rename_r+0x23d> <== NOT EXECUTED 14e8f6: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14e8f9: 85 c0 test %eax,%eax <== NOT EXECUTED 14e8fb: 74 0c je 14e909 <_rename_r+0x23d> <== NOT EXECUTED 14e8fd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14e900: 8d 55 bc lea -0x44(%ebp),%edx <== NOT EXECUTED 14e903: 52 push %edx <== NOT EXECUTED 14e904: ff d0 call *%eax <== NOT EXECUTED 14e906: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &old_loc ); 14e909: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 14e90c: 85 c0 test %eax,%eax <== NOT EXECUTED 14e90e: 74 13 je 14e923 <_rename_r+0x257> <== NOT EXECUTED 14e910: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14e913: 85 c0 test %eax,%eax <== NOT EXECUTED 14e915: 74 0c je 14e923 <_rename_r+0x257> <== NOT EXECUTED 14e917: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14e91a: 8d 55 d0 lea -0x30(%ebp),%edx <== NOT EXECUTED 14e91d: 52 push %edx <== NOT EXECUTED 14e91e: ff d0 call *%eax <== NOT EXECUTED 14e920: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EXDEV ); 14e923: e8 50 9e fe ff call 138778 <__errno> <== NOT EXECUTED 14e928: c7 00 12 00 00 00 movl $0x12,(%eax) <== NOT EXECUTED 14e92e: e9 21 ff ff ff jmp 14e854 <_rename_r+0x188> <== NOT EXECUTED } if ( !new_parent_loc.ops->rename_h ) { 14e933: 8b 50 40 mov 0x40(%eax),%edx <== NOT EXECUTED 14e936: 85 d2 test %edx,%edx <== NOT EXECUTED 14e938: 75 19 jne 14e953 <_rename_r+0x287> <== NOT EXECUTED rtems_filesystem_freenode( &new_parent_loc ); 14e93a: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14e93d: 85 c0 test %eax,%eax <== NOT EXECUTED 14e93f: 0f 84 cc fe ff ff je 14e811 <_rename_r+0x145> <== NOT EXECUTED 14e945: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14e948: 57 push %edi <== NOT EXECUTED 14e949: ff d0 call *%eax <== NOT EXECUTED 14e94b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 14e94e: e9 be fe ff ff jmp 14e811 <_rename_r+0x145> <== NOT EXECUTED rtems_filesystem_freenode( &old_parent_loc ); rtems_filesystem_freenode( &old_loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name ); 14e953: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 14e956: 57 push %edi <== NOT EXECUTED 14e957: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 14e95a: 50 push %eax <== NOT EXECUTED 14e95b: 8d 45 bc lea -0x44(%ebp),%eax <== NOT EXECUTED 14e95e: 50 push %eax <== NOT EXECUTED 14e95f: ff d2 call *%edx <== NOT EXECUTED 14e961: 89 c6 mov %eax,%esi <== NOT EXECUTED rtems_filesystem_freenode( &new_parent_loc ); 14e963: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED 14e966: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 14e969: 85 c0 test %eax,%eax <== NOT EXECUTED 14e96b: 74 10 je 14e97d <_rename_r+0x2b1> <== NOT EXECUTED 14e96d: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14e970: 85 c0 test %eax,%eax <== NOT EXECUTED 14e972: 74 09 je 14e97d <_rename_r+0x2b1> <== NOT EXECUTED 14e974: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14e977: 57 push %edi <== NOT EXECUTED 14e978: ff d0 call *%eax <== NOT EXECUTED 14e97a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( free_old_parentloc ) 14e97d: 84 db test %bl,%bl <== NOT EXECUTED 14e97f: 74 1a je 14e99b <_rename_r+0x2cf> <== NOT EXECUTED rtems_filesystem_freenode( &old_parent_loc ); 14e981: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 14e984: 85 c0 test %eax,%eax <== NOT EXECUTED 14e986: 74 13 je 14e99b <_rename_r+0x2cf> <== NOT EXECUTED 14e988: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14e98b: 85 c0 test %eax,%eax <== NOT EXECUTED 14e98d: 74 0c je 14e99b <_rename_r+0x2cf> <== NOT EXECUTED 14e98f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14e992: 8d 55 bc lea -0x44(%ebp),%edx <== NOT EXECUTED 14e995: 52 push %edx <== NOT EXECUTED 14e996: ff d0 call *%eax <== NOT EXECUTED 14e998: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &old_loc ); 14e99b: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 14e99e: 85 c0 test %eax,%eax <== NOT EXECUTED 14e9a0: 74 13 je 14e9b5 <_rename_r+0x2e9> <== NOT EXECUTED 14e9a2: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14e9a5: 85 c0 test %eax,%eax <== NOT EXECUTED 14e9a7: 74 0c je 14e9b5 <_rename_r+0x2e9> <== NOT EXECUTED 14e9a9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14e9ac: 8d 55 d0 lea -0x30(%ebp),%edx <== NOT EXECUTED 14e9af: 52 push %edx <== NOT EXECUTED 14e9b0: ff d0 call *%eax <== NOT EXECUTED 14e9b2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 14e9b5: 89 f0 mov %esi,%eax <== NOT EXECUTED 14e9b7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 14e9ba: 5b pop %ebx <== NOT EXECUTED 14e9bb: 5e pop %esi <== NOT EXECUTED 14e9bc: 5f pop %edi <== NOT EXECUTED 14e9bd: c9 leave <== NOT EXECUTED 14e9be: c3 ret <== NOT EXECUTED 0010cb36 <_stat_r>: int _STAT_R_NAME( struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { 10cb36: 55 push %ebp <== NOT EXECUTED 10cb37: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb39: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10cb3c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED return _STAT_NAME( path, buf ); 10cb3f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10cb42: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 10cb45: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10cb48: c9 leave <== NOT EXECUTED struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { return _STAT_NAME( path, buf ); 10cb49: e9 3a ff ff ff jmp 10ca88 <== NOT EXECUTED 00110232 <_unlink_r>: int _unlink_r( struct _reent *ptr __attribute__((unused)), const char *path ) { 110232: 55 push %ebp <== NOT EXECUTED 110233: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110235: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED return unlink( path ); 110238: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11023b: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 11023e: c9 leave <== NOT EXECUTED int _unlink_r( struct _reent *ptr __attribute__((unused)), const char *path ) { return unlink( path ); 11023f: e9 04 fe ff ff jmp 110048 <== NOT EXECUTED 00125124 : #include int chdir( const char *pathname ) { 125124: 55 push %ebp 125125: 89 e5 mov %esp,%ebp 125127: 57 push %edi 125128: 56 push %esi 125129: 83 ec 2c sub $0x2c,%esp 12512c: 8b 55 08 mov 0x8(%ebp),%edx /* * Get the node where we wish to go. */ result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ), RTEMS_LIBIO_PERMS_SEARCH, &loc, true ); 12512f: 31 c0 xor %eax,%eax 125131: 83 c9 ff or $0xffffffff,%ecx 125134: 89 d7 mov %edx,%edi 125136: f2 ae repnz scas %es:(%edi),%al 125138: f7 d1 not %ecx 12513a: 49 dec %ecx /* * Get the node where we wish to go. */ result = rtems_filesystem_evaluate_path( 12513b: 6a 01 push $0x1 12513d: 8d 75 e4 lea -0x1c(%ebp),%esi 125140: 56 push %esi 125141: 6a 01 push $0x1 125143: 51 push %ecx 125144: 52 push %edx 125145: e8 7e 65 fe ff call 10b6c8 12514a: 89 c2 mov %eax,%edx pathname, strlen( pathname ), RTEMS_LIBIO_PERMS_SEARCH, &loc, true ); if ( result != 0 ) 12514c: 83 c4 20 add $0x20,%esp 12514f: 83 c8 ff or $0xffffffff,%eax 125152: 85 d2 test %edx,%edx 125154: 0f 85 8f 00 00 00 jne 1251e9 /* * Verify you can change directory into this node. */ if ( !loc.ops->node_type_h ) { 12515a: 8b 55 f0 mov -0x10(%ebp),%edx 12515d: 8b 42 10 mov 0x10(%edx),%eax 125160: 85 c0 test %eax,%eax 125162: 75 1d jne 125181 rtems_filesystem_freenode( &loc ); 125164: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 125167: 85 c0 test %eax,%eax <== NOT EXECUTED 125169: 74 09 je 125174 <== NOT EXECUTED 12516b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12516e: 56 push %esi <== NOT EXECUTED 12516f: ff d0 call *%eax <== NOT EXECUTED 125171: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 125174: e8 ff 35 01 00 call 138778 <__errno> <== NOT EXECUTED 125179: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12517f: eb 2e jmp 1251af <== NOT EXECUTED } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 125181: 83 ec 0c sub $0xc,%esp 125184: 56 push %esi 125185: ff d0 call *%eax 125187: 83 c4 10 add $0x10,%esp 12518a: 48 dec %eax 12518b: 74 27 je 1251b4 rtems_filesystem_freenode( &loc ); 12518d: 8b 45 f0 mov -0x10(%ebp),%eax 125190: 85 c0 test %eax,%eax 125192: 74 10 je 1251a4 125194: 8b 40 1c mov 0x1c(%eax),%eax 125197: 85 c0 test %eax,%eax 125199: 74 09 je 1251a4 12519b: 83 ec 0c sub $0xc,%esp 12519e: 56 push %esi 12519f: ff d0 call *%eax 1251a1: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( ENOTDIR ); 1251a4: e8 cf 35 01 00 call 138778 <__errno> 1251a9: c7 00 14 00 00 00 movl $0x14,(%eax) 1251af: 83 c8 ff or $0xffffffff,%eax 1251b2: eb 35 jmp 1251e9 } rtems_filesystem_freenode( &rtems_filesystem_current ); 1251b4: 8b 15 dc e1 15 00 mov 0x15e1dc,%edx 1251ba: 8b 42 10 mov 0x10(%edx),%eax 1251bd: 85 c0 test %eax,%eax 1251bf: 74 13 je 1251d4 1251c1: 8b 40 1c mov 0x1c(%eax),%eax 1251c4: 85 c0 test %eax,%eax 1251c6: 74 0c je 1251d4 1251c8: 83 ec 0c sub $0xc,%esp 1251cb: 83 c2 04 add $0x4,%edx 1251ce: 52 push %edx 1251cf: ff d0 call *%eax 1251d1: 83 c4 10 add $0x10,%esp rtems_filesystem_current = loc; 1251d4: 8b 3d dc e1 15 00 mov 0x15e1dc,%edi 1251da: 83 c7 04 add $0x4,%edi 1251dd: 8d 75 e4 lea -0x1c(%ebp),%esi 1251e0: b9 05 00 00 00 mov $0x5,%ecx 1251e5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 1251e7: 31 c0 xor %eax,%eax return 0; } 1251e9: 8d 65 f8 lea -0x8(%ebp),%esp 1251ec: 5e pop %esi 1251ed: 5f pop %edi 1251ee: c9 leave 1251ef: c3 ret 0010b474 : int chmod( const char *path, mode_t mode ) { 10b474: 55 push %ebp 10b475: 89 e5 mov %esp,%ebp 10b477: 57 push %edi 10b478: 56 push %esi 10b479: 53 push %ebx 10b47a: 83 ec 38 sub $0x38,%esp 10b47d: 8b 55 08 mov 0x8(%ebp),%edx int status; rtems_filesystem_location_info_t loc; int result; status = rtems_filesystem_evaluate_path( path, strlen( path ), 0, &loc, true ); 10b480: 31 c0 xor %eax,%eax 10b482: 83 c9 ff or $0xffffffff,%ecx 10b485: 89 d7 mov %edx,%edi 10b487: f2 ae repnz scas %es:(%edi),%al 10b489: f7 d1 not %ecx 10b48b: 49 dec %ecx 10b48c: 6a 01 push $0x1 10b48e: 8d 5d d4 lea -0x2c(%ebp),%ebx 10b491: 53 push %ebx 10b492: 6a 00 push $0x0 10b494: 51 push %ecx 10b495: 52 push %edx 10b496: e8 2d 02 00 00 call 10b6c8 if ( status != 0 ) 10b49b: 83 c4 20 add $0x20,%esp 10b49e: 83 ce ff or $0xffffffff,%esi 10b4a1: 85 c0 test %eax,%eax 10b4a3: 75 7d jne 10b522 return -1; if ( !loc.handlers ){ 10b4a5: 8b 45 dc mov -0x24(%ebp),%eax 10b4a8: 85 c0 test %eax,%eax 10b4aa: 75 24 jne 10b4d0 rtems_filesystem_freenode( &loc ); 10b4ac: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10b4af: 85 c0 test %eax,%eax <== NOT EXECUTED 10b4b1: 74 10 je 10b4c3 <== NOT EXECUTED 10b4b3: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10b4b6: 85 c0 test %eax,%eax <== NOT EXECUTED 10b4b8: 74 09 je 10b4c3 <== NOT EXECUTED 10b4ba: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b4bd: 53 push %ebx <== NOT EXECUTED 10b4be: ff d0 call *%eax <== NOT EXECUTED 10b4c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); 10b4c3: e8 b0 d2 02 00 call 138778 <__errno> <== NOT EXECUTED 10b4c8: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10b4ce: eb 29 jmp 10b4f9 <== NOT EXECUTED } if ( !loc.handlers->fchmod_h ){ 10b4d0: 8b 40 1c mov 0x1c(%eax),%eax 10b4d3: 85 c0 test %eax,%eax 10b4d5: 75 27 jne 10b4fe rtems_filesystem_freenode( &loc ); 10b4d7: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10b4da: 85 c0 test %eax,%eax <== NOT EXECUTED 10b4dc: 74 10 je 10b4ee <== NOT EXECUTED 10b4de: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10b4e1: 85 c0 test %eax,%eax <== NOT EXECUTED 10b4e3: 74 09 je 10b4ee <== NOT EXECUTED 10b4e5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b4e8: 53 push %ebx <== NOT EXECUTED 10b4e9: ff d0 call *%eax <== NOT EXECUTED 10b4eb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 10b4ee: e8 85 d2 02 00 call 138778 <__errno> <== NOT EXECUTED 10b4f3: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10b4f9: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 10b4fc: eb 24 jmp 10b522 <== NOT EXECUTED } result = (*loc.handlers->fchmod_h)( &loc, mode ); 10b4fe: 52 push %edx 10b4ff: 52 push %edx 10b500: ff 75 0c pushl 0xc(%ebp) 10b503: 53 push %ebx 10b504: ff d0 call *%eax 10b506: 89 c6 mov %eax,%esi rtems_filesystem_freenode( &loc ); 10b508: 8b 45 e0 mov -0x20(%ebp),%eax 10b50b: 83 c4 10 add $0x10,%esp 10b50e: 85 c0 test %eax,%eax 10b510: 74 10 je 10b522 10b512: 8b 40 1c mov 0x1c(%eax),%eax 10b515: 85 c0 test %eax,%eax 10b517: 74 09 je 10b522 10b519: 83 ec 0c sub $0xc,%esp 10b51c: 53 push %ebx 10b51d: ff d0 call *%eax 10b51f: 83 c4 10 add $0x10,%esp return result; } 10b522: 89 f0 mov %esi,%eax 10b524: 8d 65 f4 lea -0xc(%ebp),%esp 10b527: 5b pop %ebx 10b528: 5e pop %esi 10b529: 5f pop %edi 10b52a: c9 leave 10b52b: c3 ret 001251f0 : int chown( const char *path, uid_t owner, gid_t group ) { 1251f0: 55 push %ebp 1251f1: 89 e5 mov %esp,%ebp 1251f3: 57 push %edi 1251f4: 56 push %esi 1251f5: 53 push %ebx 1251f6: 83 ec 48 sub $0x48,%esp 1251f9: 8b 55 08 mov 0x8(%ebp),%edx 1251fc: 8b 75 0c mov 0xc(%ebp),%esi 1251ff: 8b 5d 10 mov 0x10(%ebp),%ebx rtems_filesystem_location_info_t loc; int result; if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &loc, true ) ) 125202: 31 c0 xor %eax,%eax 125204: 83 c9 ff or $0xffffffff,%ecx 125207: 89 d7 mov %edx,%edi 125209: f2 ae repnz scas %es:(%edi),%al 12520b: f7 d1 not %ecx 12520d: 49 dec %ecx 12520e: 6a 01 push $0x1 125210: 8d 7d d4 lea -0x2c(%ebp),%edi 125213: 57 push %edi 125214: 6a 00 push $0x0 125216: 51 push %ecx 125217: 52 push %edx 125218: e8 ab 64 fe ff call 10b6c8 12521d: 83 c4 20 add $0x20,%esp 125220: 83 ca ff or $0xffffffff,%edx 125223: 85 c0 test %eax,%eax 125225: 75 58 jne 12527f return -1; if ( !loc.ops->chown_h ) { 125227: 8b 55 e0 mov -0x20(%ebp),%edx 12522a: 8b 42 18 mov 0x18(%edx),%eax 12522d: 85 c0 test %eax,%eax 12522f: 75 20 jne 125251 rtems_filesystem_freenode( &loc ); 125231: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 125234: 85 c0 test %eax,%eax <== NOT EXECUTED 125236: 74 09 je 125241 <== NOT EXECUTED 125238: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12523b: 57 push %edi <== NOT EXECUTED 12523c: ff d0 call *%eax <== NOT EXECUTED 12523e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 125241: e8 32 35 01 00 call 138778 <__errno> <== NOT EXECUTED 125246: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12524c: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 12524f: eb 2e jmp 12527f <== NOT EXECUTED } result = (*loc.ops->chown_h)( &loc, owner, group ); 125251: 52 push %edx 125252: 0f b7 db movzwl %bx,%ebx 125255: 53 push %ebx 125256: 0f b7 f6 movzwl %si,%esi 125259: 56 push %esi 12525a: 57 push %edi 12525b: ff d0 call *%eax 12525d: 89 c2 mov %eax,%edx rtems_filesystem_freenode( &loc ); 12525f: 8b 45 e0 mov -0x20(%ebp),%eax 125262: 83 c4 10 add $0x10,%esp 125265: 85 c0 test %eax,%eax 125267: 74 16 je 12527f 125269: 8b 40 1c mov 0x1c(%eax),%eax 12526c: 85 c0 test %eax,%eax 12526e: 74 0f je 12527f 125270: 83 ec 0c sub $0xc,%esp 125273: 57 push %edi 125274: 89 55 c4 mov %edx,-0x3c(%ebp) 125277: ff d0 call *%eax 125279: 83 c4 10 add $0x10,%esp 12527c: 8b 55 c4 mov -0x3c(%ebp),%edx return result; } 12527f: 89 d0 mov %edx,%eax 125281: 8d 65 f4 lea -0xc(%ebp),%esp 125284: 5b pop %ebx 125285: 5e pop %esi 125286: 5f pop %edi 125287: c9 leave 125288: c3 ret 0012528c : #include int chroot( const char *pathname ) { 12528c: 55 push %ebp 12528d: 89 e5 mov %esp,%ebp 12528f: 57 push %edi 125290: 56 push %esi 125291: 83 ec 20 sub $0x20,%esp int result; rtems_filesystem_location_info_t loc; /* an automatic call to new private env the first time */ if (rtems_current_user_env == &rtems_global_user_env) { 125294: 81 3d dc e1 15 00 ac cmpl $0x163aac,0x15e1dc 12529b: 3a 16 00 12529e: 75 1e jne 1252be rtems_libio_set_private_env(); /* try to set a new private env*/ 1252a0: e8 bf 13 00 00 call 126664 if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 1252a5: 81 3d dc e1 15 00 ac cmpl $0x163aac,0x15e1dc 1252ac: 3a 16 00 1252af: 75 0d jne 1252be rtems_set_errno_and_return_minus_one( ENOTSUP ); 1252b1: e8 c2 34 01 00 call 138778 <__errno> <== NOT EXECUTED 1252b6: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1252bc: eb 22 jmp 1252e0 <== NOT EXECUTED } result = chdir(pathname); 1252be: 83 ec 0c sub $0xc,%esp 1252c1: ff 75 08 pushl 0x8(%ebp) 1252c4: e8 5b fe ff ff call 125124 if (result) { 1252c9: 83 c4 10 add $0x10,%esp 1252cc: 85 c0 test %eax,%eax 1252ce: 74 15 je 1252e5 rtems_set_errno_and_return_minus_one( errno ); 1252d0: e8 a3 34 01 00 call 138778 <__errno> <== NOT EXECUTED 1252d5: 89 c6 mov %eax,%esi <== NOT EXECUTED 1252d7: e8 9c 34 01 00 call 138778 <__errno> <== NOT EXECUTED 1252dc: 8b 00 mov (%eax),%eax <== NOT EXECUTED 1252de: 89 06 mov %eax,(%esi) <== NOT EXECUTED 1252e0: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1252e3: eb 53 jmp 125338 <== NOT EXECUTED } /* clone the new root location */ if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) { 1252e5: 83 ec 0c sub $0xc,%esp 1252e8: 6a 00 push $0x0 1252ea: 8d 45 e4 lea -0x1c(%ebp),%eax 1252ed: 50 push %eax 1252ee: 6a 00 push $0x0 1252f0: 6a 01 push $0x1 1252f2: 68 1e 26 15 00 push $0x15261e 1252f7: e8 cc 63 fe ff call 10b6c8 1252fc: 83 c4 20 add $0x20,%esp 1252ff: 85 c0 test %eax,%eax 125301: 75 cd jne 1252d0 /* 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); 125303: 8b 15 dc e1 15 00 mov 0x15e1dc,%edx 125309: 8b 42 24 mov 0x24(%edx),%eax 12530c: 85 c0 test %eax,%eax 12530e: 74 13 je 125323 125310: 8b 40 1c mov 0x1c(%eax),%eax 125313: 85 c0 test %eax,%eax 125315: 74 0c je 125323 125317: 83 ec 0c sub $0xc,%esp 12531a: 83 c2 18 add $0x18,%edx 12531d: 52 push %edx 12531e: ff d0 call *%eax 125320: 83 c4 10 add $0x10,%esp rtems_filesystem_root = loc; 125323: 8b 3d dc e1 15 00 mov 0x15e1dc,%edi 125329: 83 c7 18 add $0x18,%edi 12532c: 8d 75 e4 lea -0x1c(%ebp),%esi 12532f: b9 05 00 00 00 mov $0x5,%ecx 125334: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 125336: 31 c0 xor %eax,%eax return 0; } 125338: 8d 65 f8 lea -0x8(%ebp),%esp 12533b: 5e pop %esi 12533c: 5f pop %edi 12533d: c9 leave 12533e: c3 ret 0010d200 : #include "devfs.h" int devFS_close( rtems_libio_t *iop ) { 10d200: 55 push %ebp 10d201: 89 e5 mov %esp,%ebp 10d203: 83 ec 1c sub $0x1c,%esp 10d206: 8b 55 08 mov 0x8(%ebp),%edx rtems_libio_open_close_args_t args; rtems_status_code status; rtems_device_name_t *np; np = (rtems_device_name_t *)iop->file_info; 10d209: 8b 42 38 mov 0x38(%edx),%eax args.iop = iop; 10d20c: 89 55 ec mov %edx,-0x14(%ebp) args.flags = 0; 10d20f: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) args.mode = 0; 10d216: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) status = rtems_io_close( 10d21d: 8d 55 ec lea -0x14(%ebp),%edx 10d220: 52 push %edx 10d221: ff 70 0c pushl 0xc(%eax) 10d224: ff 70 08 pushl 0x8(%eax) 10d227: e8 a8 08 00 00 call 10dad4 10d22c: 89 c2 mov %eax,%edx np->major, np->minor, (void *) &args ); if ( status ) { 10d22e: 83 c4 10 add $0x10,%esp 10d231: 31 c0 xor %eax,%eax 10d233: 85 d2 test %edx,%edx 10d235: 74 0c je 10d243 return rtems_deviceio_errno(status); 10d237: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d23a: 52 push %edx <== NOT EXECUTED 10d23b: e8 a8 00 00 00 call 10d2e8 <== NOT EXECUTED 10d240: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 10d243: c9 leave 10d244: c3 ret 0010d257 : const char *pathname, int pathnamelen, int flags, rtems_filesystem_location_info_t *pathloc ) { 10d257: 55 push %ebp 10d258: 89 e5 mov %esp,%ebp 10d25a: 57 push %edi 10d25b: 56 push %esi 10d25c: 53 push %ebx 10d25d: 83 ec 1c sub $0x1c,%esp 10d260: 8b 4d 0c mov 0xc(%ebp),%ecx 10d263: 8b 5d 14 mov 0x14(%ebp),%ebx assert( 0 ); rtems_set_errno_and_return_minus_one( EIO ); } /* get the device name table */ device_name_table = (rtems_device_name_t *)pathloc->node_access; 10d266: 8b 33 mov (%ebx),%esi if (!device_name_table) 10d268: 85 f6 test %esi,%esi 10d26a: 74 04 je 10d270 10d26c: 31 ff xor %edi,%edi 10d26e: eb 5a jmp 10d2ca rtems_set_errno_and_return_minus_one( EFAULT ); 10d270: e8 3b 15 00 00 call 10e7b0 <__errno> <== NOT EXECUTED 10d275: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 10d27b: eb 60 jmp 10d2dd <== NOT EXECUTED for (i = 0; i < rtems_device_table_size; i++) { if (!device_name_table[i].device_name) 10d27d: 8b 16 mov (%esi),%edx 10d27f: 85 d2 test %edx,%edx 10d281: 74 43 je 10d2c6 continue; if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0) 10d283: 50 push %eax 10d284: 51 push %ecx 10d285: 52 push %edx 10d286: ff 75 08 pushl 0x8(%ebp) 10d289: 89 55 e4 mov %edx,-0x1c(%ebp) 10d28c: 89 4d e0 mov %ecx,-0x20(%ebp) 10d28f: e8 28 21 00 00 call 10f3bc 10d294: 83 c4 10 add $0x10,%esp 10d297: 85 c0 test %eax,%eax 10d299: 8b 55 e4 mov -0x1c(%ebp),%edx 10d29c: 8b 4d e0 mov -0x20(%ebp),%ecx 10d29f: 75 25 jne 10d2c6 continue; if (device_name_table[i].device_name[pathnamelen] != '\0') 10d2a1: 80 3c 0a 00 cmpb $0x0,(%edx,%ecx,1) 10d2a5: 75 1f jne 10d2c6 continue; /* find the device, set proper values */ pathloc->node_access = (void *)&device_name_table[i]; 10d2a7: 89 33 mov %esi,(%ebx) pathloc->handlers = &devFS_file_handlers; 10d2a9: c7 43 08 c8 f8 11 00 movl $0x11f8c8,0x8(%ebx) pathloc->ops = &devFS_ops; 10d2b0: c7 43 0c 80 f8 11 00 movl $0x11f880,0xc(%ebx) pathloc->mt_entry = rtems_filesystem_root.mt_entry; 10d2b7: a1 14 f9 11 00 mov 0x11f914,%eax 10d2bc: 8b 40 28 mov 0x28(%eax),%eax 10d2bf: 89 43 10 mov %eax,0x10(%ebx) 10d2c2: 31 c0 xor %eax,%eax return 0; 10d2c4: eb 1a jmp 10d2e0 /* get the device name table */ device_name_table = (rtems_device_name_t *)pathloc->node_access; if (!device_name_table) rtems_set_errno_and_return_minus_one( EFAULT ); for (i = 0; i < rtems_device_table_size; i++) { 10d2c6: 47 inc %edi 10d2c7: 83 c6 14 add $0x14,%esi 10d2ca: 3b 3d a8 da 11 00 cmp 0x11daa8,%edi 10d2d0: 72 ab jb 10d27d pathloc->mt_entry = rtems_filesystem_root.mt_entry; return 0; } /* no such file or directory */ rtems_set_errno_and_return_minus_one( ENOENT ); 10d2d2: e8 d9 14 00 00 call 10e7b0 <__errno> 10d2d7: c7 00 02 00 00 00 movl $0x2,(%eax) 10d2dd: 83 c8 ff or $0xffffffff,%eax } 10d2e0: 8d 65 f4 lea -0xc(%ebp),%esp 10d2e3: 5b pop %ebx 10d2e4: 5e pop %esi 10d2e5: 5f pop %edi 10d2e6: c9 leave 10d2e7: c3 ret 00106d00 : int devFS_initialize( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 106d00: 55 push %ebp 106d01: 89 e5 mov %esp,%ebp 106d03: 57 push %edi 106d04: 53 push %ebx 106d05: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_device_name_t *device_name_table; /* allocate device only filesystem name table */ device_name_table = (rtems_device_name_t *)_Workspace_Allocate( 106d08: 83 ec 0c sub $0xc,%esp 106d0b: 6b 05 a8 da 11 00 14 imul $0x14,0x11daa8,%eax 106d12: 50 push %eax 106d13: e8 b0 60 00 00 call 10cdc8 <_Workspace_Allocate> 106d18: 89 c2 mov %eax,%edx sizeof( rtems_device_name_t ) * ( rtems_device_table_size ) ); /* no memory for device filesystem */ if (!device_name_table) 106d1a: 83 c4 10 add $0x10,%esp 106d1d: 85 c0 test %eax,%eax 106d1f: 75 10 jne 106d31 rtems_set_errno_and_return_minus_one( ENOMEM ); 106d21: e8 8a 7a 00 00 call 10e7b0 <__errno> <== NOT EXECUTED 106d26: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 106d2c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 106d2f: eb 20 jmp 106d51 <== NOT EXECUTED memset( 106d31: 6b 0d a8 da 11 00 14 imul $0x14,0x11daa8,%ecx 106d38: 31 c0 xor %eax,%eax 106d3a: 89 d7 mov %edx,%edi 106d3c: f3 aa rep stos %al,%es:(%edi) device_name_table, 0, sizeof( rtems_device_name_t ) * ( rtems_device_table_size ) ); /* set file handlers */ temp_mt_entry->mt_fs_root.handlers = &devFS_file_handlers; 106d3e: c7 43 24 c8 f8 11 00 movl $0x11f8c8,0x24(%ebx) temp_mt_entry->mt_fs_root.ops = &devFS_ops; 106d45: c7 43 28 80 f8 11 00 movl $0x11f880,0x28(%ebx) /* Set the node_access to device name table */ temp_mt_entry->mt_fs_root.node_access = (void *)device_name_table; 106d4c: 89 53 1c mov %edx,0x1c(%ebx) 106d4f: 31 c0 xor %eax,%eax return 0; } 106d51: 8d 65 f8 lea -0x8(%ebp),%esp 106d54: 5b pop %ebx 106d55: 5f pop %edi 106d56: c9 leave 106d57: c3 ret 00106e64 : int devFS_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 106e64: 55 push %ebp 106e65: 89 e5 mov %esp,%ebp 106e67: 83 ec 1c sub $0x1c,%esp 106e6a: 8b 55 08 mov 0x8(%ebp),%edx rtems_libio_ioctl_args_t args; rtems_status_code status; rtems_device_name_t *np; np = (rtems_device_name_t *)iop->file_info; 106e6d: 8b 42 38 mov 0x38(%edx),%eax args.iop = iop; 106e70: 89 55 e8 mov %edx,-0x18(%ebp) args.command = command; 106e73: 8b 55 0c mov 0xc(%ebp),%edx 106e76: 89 55 ec mov %edx,-0x14(%ebp) args.buffer = buffer; 106e79: 8b 55 10 mov 0x10(%ebp),%edx 106e7c: 89 55 f0 mov %edx,-0x10(%ebp) status = rtems_io_control( 106e7f: 8d 55 e8 lea -0x18(%ebp),%edx 106e82: 52 push %edx 106e83: ff 70 0c pushl 0xc(%eax) 106e86: ff 70 08 pushl 0x8(%eax) 106e89: e8 e6 38 00 00 call 10a774 np->major, np->minor, (void *) &args ); if ( status ) 106e8e: 83 c4 10 add $0x10,%esp 106e91: 85 c0 test %eax,%eax 106e93: 74 0e je 106ea3 return rtems_deviceio_errno(status); 106e95: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106e98: 50 push %eax <== NOT EXECUTED 106e99: e8 4a 64 00 00 call 10d2e8 <== NOT EXECUTED 106e9e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106ea1: eb 03 jmp 106ea6 <== NOT EXECUTED return args.ioctl_return; 106ea3: 8b 45 f4 mov -0xc(%ebp),%eax } 106ea6: c9 leave 106ea7: c3 ret 00106d58 : const char *path, mode_t mode, dev_t dev, rtems_filesystem_location_info_t *pathloc ) { 106d58: 55 push %ebp 106d59: 89 e5 mov %esp,%ebp 106d5b: 57 push %edi 106d5c: 56 push %esi 106d5d: 53 push %ebx 106d5e: 83 ec 1c sub $0x1c,%esp 106d61: 8b 7d 08 mov 0x8(%ebp),%edi 106d64: 8b 4d 10 mov 0x10(%ebp),%ecx 106d67: 8b 55 14 mov 0x14(%ebp),%edx * condition and do not create the '/dev' and the 'path' * actually passed in is 'dev', not '/dev'. Just return 0 to * indicate we are OK. */ if ((path[0] == 'd') && (path[1] == 'e') && 106d6a: 80 3f 64 cmpb $0x64,(%edi) 106d6d: 75 18 jne 106d87 106d6f: 80 7f 01 65 cmpb $0x65,0x1(%edi) 106d73: 75 12 jne 106d87 (path[2] == 'v') && (path[3] == '\0')) 106d75: 80 7f 02 76 cmpb $0x76,0x2(%edi) 106d79: 75 0c jne 106d87 106d7b: 31 c0 xor %eax,%eax 106d7d: 80 7f 03 00 cmpb $0x0,0x3(%edi) 106d81: 0f 84 c9 00 00 00 je 106e50 return 0; /* must be a character device or a block device */ if (!S_ISBLK(mode) && !S_ISCHR(mode)) 106d87: 8b 45 0c mov 0xc(%ebp),%eax 106d8a: 25 00 f0 00 00 and $0xf000,%eax 106d8f: 3d 00 20 00 00 cmp $0x2000,%eax 106d94: 74 14 je 106daa 106d96: 3d 00 60 00 00 cmp $0x6000,%eax <== NOT EXECUTED 106d9b: 74 0d je 106daa <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 106d9d: e8 0e 7a 00 00 call 10e7b0 <__errno> <== NOT EXECUTED 106da2: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 106da8: eb 23 jmp 106dcd <== NOT EXECUTED ) { union __rtems_dev_t temp; temp.device = device; return temp.__overlay.major; 106daa: 89 4d e0 mov %ecx,-0x20(%ebp) dev_t device ) { union __rtems_dev_t temp; temp.device = device; 106dad: 89 55 e4 mov %edx,-0x1c(%ebp) else rtems_filesystem_split_dev_t(dev, major, minor); /* Find an empty slot in device name table */ device_name_table = (rtems_device_name_t *)pathloc->node_access; 106db0: 8b 45 18 mov 0x18(%ebp),%eax 106db3: 8b 08 mov (%eax),%ecx if (!device_name_table) 106db5: 85 c9 test %ecx,%ecx 106db7: 74 09 je 106dc2 106db9: 89 ca mov %ecx,%edx 106dbb: 83 ce ff or $0xffffffff,%esi 106dbe: 31 db xor %ebx,%ebx 106dc0: eb 46 jmp 106e08 rtems_set_errno_and_return_minus_one( EFAULT ); 106dc2: e8 e9 79 00 00 call 10e7b0 <__errno> <== NOT EXECUTED 106dc7: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 106dcd: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 106dd0: eb 7e jmp 106e50 <== NOT EXECUTED for (slot = -1, i = 0; i < rtems_device_table_size; i++){ if (device_name_table[i].device_name == NULL) 106dd2: 8b 02 mov (%edx),%eax 106dd4: 85 c0 test %eax,%eax 106dd6: 74 2a je 106e02 slot = i; else if (strcmp(path, device_name_table[i].device_name) == 0) 106dd8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 106ddb: 50 push %eax <== NOT EXECUTED 106ddc: 57 push %edi <== NOT EXECUTED 106ddd: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED 106de0: 89 4d d8 mov %ecx,-0x28(%ebp) <== NOT EXECUTED 106de3: e8 a8 84 00 00 call 10f290 <== NOT EXECUTED 106de8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106deb: 85 c0 test %eax,%eax <== NOT EXECUTED 106ded: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 106df0: 8b 4d d8 mov -0x28(%ebp),%ecx <== NOT EXECUTED 106df3: 75 0f jne 106e04 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EEXIST ); 106df5: e8 b6 79 00 00 call 10e7b0 <__errno> <== NOT EXECUTED 106dfa: c7 00 11 00 00 00 movl $0x11,(%eax) <== NOT EXECUTED 106e00: eb cb jmp 106dcd <== NOT EXECUTED 106e02: 89 de mov %ebx,%esi /* Find an empty slot in device name table */ device_name_table = (rtems_device_name_t *)pathloc->node_access; if (!device_name_table) rtems_set_errno_and_return_minus_one( EFAULT ); for (slot = -1, i = 0; i < rtems_device_table_size; i++){ 106e04: 43 inc %ebx 106e05: 83 c2 14 add $0x14,%edx 106e08: 3b 1d a8 da 11 00 cmp 0x11daa8,%ebx 106e0e: 72 c2 jb 106dd2 else if (strcmp(path, device_name_table[i].device_name) == 0) rtems_set_errno_and_return_minus_one( EEXIST ); } if (slot == -1) 106e10: 83 fe ff cmp $0xffffffff,%esi 106e13: 75 0d jne 106e22 rtems_set_errno_and_return_minus_one( ENOMEM ); 106e15: e8 96 79 00 00 call 10e7b0 <__errno> <== NOT EXECUTED 106e1a: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 106e20: eb ab jmp 106dcd <== NOT EXECUTED _ISR_Disable(level); 106e22: 9c pushf 106e23: fa cli 106e24: 5b pop %ebx device_name_table[slot].device_name = (char *)path; 106e25: 6b d6 14 imul $0x14,%esi,%edx 106e28: 8d 14 11 lea (%ecx,%edx,1),%edx 106e2b: 89 3a mov %edi,(%edx) device_name_table[slot].device_name_length = strlen(path); 106e2d: 31 c0 xor %eax,%eax 106e2f: 83 c9 ff or $0xffffffff,%ecx 106e32: f2 ae repnz scas %es:(%edi),%al 106e34: f7 d1 not %ecx 106e36: 49 dec %ecx 106e37: 89 4a 04 mov %ecx,0x4(%edx) device_name_table[slot].major = major; 106e3a: 8b 45 e0 mov -0x20(%ebp),%eax 106e3d: 89 42 08 mov %eax,0x8(%edx) device_name_table[slot].minor = minor; 106e40: 8b 45 e4 mov -0x1c(%ebp),%eax 106e43: 89 42 0c mov %eax,0xc(%edx) device_name_table[slot].mode = mode; 106e46: 8b 45 0c mov 0xc(%ebp),%eax 106e49: 89 42 10 mov %eax,0x10(%edx) _ISR_Enable(level); 106e4c: 53 push %ebx 106e4d: 9d popf 106e4e: 31 c0 xor %eax,%eax return 0; } 106e50: 8d 65 f4 lea -0xc(%ebp),%esp 106e53: 5b pop %ebx 106e54: 5e pop %esi 106e55: 5f pop %edi 106e56: c9 leave 106e57: c3 ret 00106ea8 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 106ea8: 55 push %ebp 106ea9: 89 e5 mov %esp,%ebp 106eab: 83 ec 1c sub $0x1c,%esp 106eae: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_open_close_args_t args; rtems_status_code status; rtems_device_name_t *np; np = (rtems_device_name_t *)iop->file_info; 106eb1: 8b 50 38 mov 0x38(%eax),%edx args.iop = iop; 106eb4: 89 45 ec mov %eax,-0x14(%ebp) args.flags = iop->flags; 106eb7: 8b 40 14 mov 0x14(%eax),%eax 106eba: 89 45 f0 mov %eax,-0x10(%ebp) args.mode = mode; 106ebd: 8b 45 14 mov 0x14(%ebp),%eax 106ec0: 89 45 f4 mov %eax,-0xc(%ebp) status = rtems_io_open( 106ec3: 8d 45 ec lea -0x14(%ebp),%eax 106ec6: 50 push %eax 106ec7: ff 72 0c pushl 0xc(%edx) 106eca: ff 72 08 pushl 0x8(%edx) 106ecd: e8 7a 39 00 00 call 10a84c 106ed2: 89 c2 mov %eax,%edx np->major, np->minor, (void *) &args ); if ( status ) 106ed4: 83 c4 10 add $0x10,%esp 106ed7: 31 c0 xor %eax,%eax 106ed9: 85 d2 test %edx,%edx 106edb: 74 0c je 106ee9 return rtems_deviceio_errno(status); 106edd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106ee0: 52 push %edx <== NOT EXECUTED 106ee1: e8 02 64 00 00 call 10d2e8 <== NOT EXECUTED 106ee6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 106ee9: c9 leave 106eea: c3 ret 00106eec : ssize_t devFS_read( rtems_libio_t *iop, void *buffer, size_t count ) { 106eec: 55 push %ebp <== NOT EXECUTED 106eed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106eef: 53 push %ebx <== NOT EXECUTED 106ef0: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 106ef3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED rtems_libio_rw_args_t args; rtems_status_code status; rtems_device_name_t *np; np = (rtems_device_name_t *)iop->file_info; 106ef6: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED args.iop = iop; 106ef9: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED args.offset = iop->offset; 106efc: 8b 48 0c mov 0xc(%eax),%ecx <== NOT EXECUTED 106eff: 8b 58 10 mov 0x10(%eax),%ebx <== NOT EXECUTED 106f02: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED 106f05: 89 5d e4 mov %ebx,-0x1c(%ebp) <== NOT EXECUTED args.buffer = buffer; 106f08: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 106f0b: 89 4d e8 mov %ecx,-0x18(%ebp) <== NOT EXECUTED args.count = count; 106f0e: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 106f11: 89 4d ec mov %ecx,-0x14(%ebp) <== NOT EXECUTED args.flags = iop->flags; 106f14: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 106f17: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED args.bytes_moved = 0; 106f1a: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED status = rtems_io_read( 106f21: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 106f24: 50 push %eax <== NOT EXECUTED 106f25: ff 72 0c pushl 0xc(%edx) <== NOT EXECUTED 106f28: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 106f2b: e8 4c 39 00 00 call 10a87c <== NOT EXECUTED np->major, np->minor, (void *) &args ); if ( status ) 106f30: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106f33: 85 c0 test %eax,%eax <== NOT EXECUTED 106f35: 74 0e je 106f45 <== NOT EXECUTED return rtems_deviceio_errno(status); 106f37: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106f3a: 50 push %eax <== NOT EXECUTED 106f3b: e8 a8 63 00 00 call 10d2e8 <== NOT EXECUTED 106f40: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106f43: eb 03 jmp 106f48 <== NOT EXECUTED return (ssize_t) args.bytes_moved; 106f45: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED } 106f48: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 106f4b: c9 leave <== NOT EXECUTED 106f4c: c3 ret <== NOT EXECUTED 00106f50 : int devFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 106f50: 55 push %ebp 106f51: 89 e5 mov %esp,%ebp 106f53: 53 push %ebx 106f54: 83 ec 04 sub $0x4,%esp 106f57: 8b 55 0c mov 0xc(%ebp),%edx rtems_device_name_t *the_dev; the_dev = (rtems_device_name_t *)loc->node_access; 106f5a: 8b 45 08 mov 0x8(%ebp),%eax 106f5d: 8b 00 mov (%eax),%eax if (!the_dev) 106f5f: 85 c0 test %eax,%eax 106f61: 75 10 jne 106f73 rtems_set_errno_and_return_minus_one( EFAULT ); 106f63: e8 48 78 00 00 call 10e7b0 <__errno> <== NOT EXECUTED 106f68: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 106f6e: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 106f71: eb 14 jmp 106f87 <== NOT EXECUTED buf->st_rdev = rtems_filesystem_make_dev_t( the_dev->major, the_dev->minor ); 106f73: 8b 48 0c mov 0xc(%eax),%ecx rtems_device_minor_number _minor ) { union __rtems_dev_t temp; temp.__overlay.major = _major; 106f76: 8b 58 08 mov 0x8(%eax),%ebx 106f79: 89 5a 18 mov %ebx,0x18(%edx) 106f7c: 89 4a 1c mov %ecx,0x1c(%edx) buf->st_mode = the_dev->mode; 106f7f: 8b 40 10 mov 0x10(%eax),%eax 106f82: 89 42 0c mov %eax,0xc(%edx) 106f85: 31 c0 xor %eax,%eax return 0; } 106f87: 5a pop %edx 106f88: 5b pop %ebx 106f89: c9 leave 106f8a: c3 ret 00106f8c : ssize_t devFS_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 106f8c: 55 push %ebp 106f8d: 89 e5 mov %esp,%ebp 106f8f: 53 push %ebx 106f90: 83 ec 28 sub $0x28,%esp 106f93: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_rw_args_t args; rtems_status_code status; rtems_device_name_t *np; np = (rtems_device_name_t *)iop->file_info; 106f96: 8b 50 38 mov 0x38(%eax),%edx args.iop = iop; 106f99: 89 45 dc mov %eax,-0x24(%ebp) args.offset = iop->offset; 106f9c: 8b 48 0c mov 0xc(%eax),%ecx 106f9f: 8b 58 10 mov 0x10(%eax),%ebx 106fa2: 89 4d e0 mov %ecx,-0x20(%ebp) 106fa5: 89 5d e4 mov %ebx,-0x1c(%ebp) args.buffer = (void *) buffer; 106fa8: 8b 4d 0c mov 0xc(%ebp),%ecx 106fab: 89 4d e8 mov %ecx,-0x18(%ebp) args.count = count; 106fae: 8b 4d 10 mov 0x10(%ebp),%ecx 106fb1: 89 4d ec mov %ecx,-0x14(%ebp) args.flags = iop->flags; 106fb4: 8b 40 14 mov 0x14(%eax),%eax 106fb7: 89 45 f0 mov %eax,-0x10(%ebp) args.bytes_moved = 0; 106fba: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) status = rtems_io_write( 106fc1: 8d 45 dc lea -0x24(%ebp),%eax 106fc4: 50 push %eax 106fc5: ff 72 0c pushl 0xc(%edx) 106fc8: ff 72 08 pushl 0x8(%edx) 106fcb: e8 dc 38 00 00 call 10a8ac np->major, np->minor, (void *) &args ); if ( status ) 106fd0: 83 c4 10 add $0x10,%esp 106fd3: 85 c0 test %eax,%eax 106fd5: 74 0e je 106fe5 return rtems_deviceio_errno(status); 106fd7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106fda: 50 push %eax <== NOT EXECUTED 106fdb: e8 08 63 00 00 call 10d2e8 <== NOT EXECUTED 106fe0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106fe3: eb 03 jmp 106fe8 <== NOT EXECUTED return (ssize_t) args.bytes_moved; 106fe5: 8b 45 f4 mov -0xc(%ebp),%eax } 106fe8: 8b 5d fc mov -0x4(%ebp),%ebx 106feb: c9 leave 106fec: c3 ret 0010edb4 : */ int device_close( rtems_libio_t *iop ) { 10edb4: 55 push %ebp 10edb5: 89 e5 mov %esp,%ebp 10edb7: 83 ec 1c sub $0x1c,%esp 10edba: 8b 55 08 mov 0x8(%ebp),%edx rtems_libio_open_close_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 10edbd: 8b 42 38 mov 0x38(%edx),%eax args.iop = iop; 10edc0: 89 55 ec mov %edx,-0x14(%ebp) args.flags = 0; 10edc3: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) args.mode = 0; 10edca: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) status = rtems_io_close( 10edd1: 8d 55 ec lea -0x14(%ebp),%edx 10edd4: 52 push %edx 10edd5: ff 70 54 pushl 0x54(%eax) 10edd8: ff 70 50 pushl 0x50(%eax) 10eddb: e8 a0 0d 00 00 call 10fb80 10ede0: 89 c2 mov %eax,%edx the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) { 10ede2: 83 c4 10 add $0x10,%esp 10ede5: 31 c0 xor %eax,%eax 10ede7: 85 d2 test %edx,%edx 10ede9: 74 0c je 10edf7 return rtems_deviceio_errno(status); 10edeb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10edee: 52 push %edx <== NOT EXECUTED 10edef: e8 e8 11 00 00 call 10ffdc <== NOT EXECUTED 10edf4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 10edf7: c9 leave 10edf8: c3 ret 0010ecae : int device_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 10ecae: 55 push %ebp 10ecaf: 89 e5 mov %esp,%ebp 10ecb1: 83 ec 1c sub $0x1c,%esp 10ecb4: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_ioctl_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; args.iop = iop; 10ecb7: 89 45 e8 mov %eax,-0x18(%ebp) args.command = command; 10ecba: 8b 55 0c mov 0xc(%ebp),%edx 10ecbd: 89 55 ec mov %edx,-0x14(%ebp) args.buffer = buffer; 10ecc0: 8b 55 10 mov 0x10(%ebp),%edx 10ecc3: 89 55 f0 mov %edx,-0x10(%ebp) the_jnode = iop->file_info; 10ecc6: 8b 40 38 mov 0x38(%eax),%eax status = rtems_io_control( 10ecc9: 8d 55 e8 lea -0x18(%ebp),%edx 10eccc: 52 push %edx 10eccd: ff 70 54 pushl 0x54(%eax) 10ecd0: ff 70 50 pushl 0x50(%eax) 10ecd3: e8 d8 0e 00 00 call 10fbb0 the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10ecd8: 83 c4 10 add $0x10,%esp 10ecdb: 85 c0 test %eax,%eax 10ecdd: 74 0e je 10eced return rtems_deviceio_errno(status); 10ecdf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ece2: 50 push %eax <== NOT EXECUTED 10ece3: e8 f4 12 00 00 call 10ffdc <== NOT EXECUTED 10ece8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eceb: eb 03 jmp 10ecf0 <== NOT EXECUTED return args.ioctl_return; 10eced: 8b 45 f4 mov -0xc(%ebp),%eax } 10ecf0: c9 leave 10ecf1: c3 ret 0010edf9 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 10edf9: 55 push %ebp 10edfa: 89 e5 mov %esp,%ebp 10edfc: 83 ec 1c sub $0x1c,%esp 10edff: 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; 10ee02: 8b 50 38 mov 0x38(%eax),%edx args.iop = iop; 10ee05: 89 45 ec mov %eax,-0x14(%ebp) args.flags = iop->flags; 10ee08: 8b 40 14 mov 0x14(%eax),%eax 10ee0b: 89 45 f0 mov %eax,-0x10(%ebp) args.mode = mode; 10ee0e: 8b 45 14 mov 0x14(%ebp),%eax 10ee11: 89 45 f4 mov %eax,-0xc(%ebp) status = rtems_io_open( 10ee14: 8d 45 ec lea -0x14(%ebp),%eax 10ee17: 50 push %eax 10ee18: ff 72 54 pushl 0x54(%edx) 10ee1b: ff 72 50 pushl 0x50(%edx) 10ee1e: e8 bd 0d 00 00 call 10fbe0 10ee23: 89 c2 mov %eax,%edx the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10ee25: 83 c4 10 add $0x10,%esp 10ee28: 31 c0 xor %eax,%eax 10ee2a: 85 d2 test %edx,%edx 10ee2c: 74 0c je 10ee3a return rtems_deviceio_errno(status); 10ee2e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ee31: 52 push %edx <== NOT EXECUTED 10ee32: e8 a5 11 00 00 call 10ffdc <== NOT EXECUTED 10ee37: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10ee3a: c9 leave 10ee3b: c3 ret 0010ed53 : ssize_t device_read( rtems_libio_t *iop, void *buffer, size_t count ) { 10ed53: 55 push %ebp <== NOT EXECUTED 10ed54: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ed56: 53 push %ebx <== NOT EXECUTED 10ed57: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 10ed5a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED rtems_libio_rw_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 10ed5d: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED args.iop = iop; 10ed60: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED args.offset = iop->offset; 10ed63: 8b 48 0c mov 0xc(%eax),%ecx <== NOT EXECUTED 10ed66: 8b 58 10 mov 0x10(%eax),%ebx <== NOT EXECUTED 10ed69: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED 10ed6c: 89 5d e4 mov %ebx,-0x1c(%ebp) <== NOT EXECUTED args.buffer = buffer; 10ed6f: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10ed72: 89 4d e8 mov %ecx,-0x18(%ebp) <== NOT EXECUTED args.count = count; 10ed75: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10ed78: 89 4d ec mov %ecx,-0x14(%ebp) <== NOT EXECUTED args.flags = iop->flags; 10ed7b: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10ed7e: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED args.bytes_moved = 0; 10ed81: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED status = rtems_io_read( 10ed88: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 10ed8b: 50 push %eax <== NOT EXECUTED 10ed8c: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED 10ed8f: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED 10ed92: e8 79 0e 00 00 call 10fc10 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10ed97: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ed9a: 85 c0 test %eax,%eax <== NOT EXECUTED 10ed9c: 74 0e je 10edac <== NOT EXECUTED return rtems_deviceio_errno(status); 10ed9e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10eda1: 50 push %eax <== NOT EXECUTED 10eda2: e8 35 12 00 00 call 10ffdc <== NOT EXECUTED 10eda7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10edaa: eb 03 jmp 10edaf <== NOT EXECUTED return (ssize_t) args.bytes_moved; 10edac: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED } 10edaf: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10edb2: c9 leave <== NOT EXECUTED 10edb3: c3 ret <== NOT EXECUTED 0010ecf2 : ssize_t device_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 10ecf2: 55 push %ebp 10ecf3: 89 e5 mov %esp,%ebp 10ecf5: 53 push %ebx 10ecf6: 83 ec 28 sub $0x28,%esp 10ecf9: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_rw_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 10ecfc: 8b 50 38 mov 0x38(%eax),%edx args.iop = iop; 10ecff: 89 45 dc mov %eax,-0x24(%ebp) args.offset = iop->offset; 10ed02: 8b 48 0c mov 0xc(%eax),%ecx 10ed05: 8b 58 10 mov 0x10(%eax),%ebx 10ed08: 89 4d e0 mov %ecx,-0x20(%ebp) 10ed0b: 89 5d e4 mov %ebx,-0x1c(%ebp) args.buffer = (void *) buffer; 10ed0e: 8b 4d 0c mov 0xc(%ebp),%ecx 10ed11: 89 4d e8 mov %ecx,-0x18(%ebp) args.count = count; 10ed14: 8b 4d 10 mov 0x10(%ebp),%ecx 10ed17: 89 4d ec mov %ecx,-0x14(%ebp) args.flags = iop->flags; 10ed1a: 8b 40 14 mov 0x14(%eax),%eax 10ed1d: 89 45 f0 mov %eax,-0x10(%ebp) args.bytes_moved = 0; 10ed20: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) status = rtems_io_write( 10ed27: 8d 45 dc lea -0x24(%ebp),%eax 10ed2a: 50 push %eax 10ed2b: ff 72 54 pushl 0x54(%edx) 10ed2e: ff 72 50 pushl 0x50(%edx) 10ed31: e8 0a 0f 00 00 call 10fc40 the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10ed36: 83 c4 10 add $0x10,%esp 10ed39: 85 c0 test %eax,%eax 10ed3b: 74 0e je 10ed4b return rtems_deviceio_errno(status); 10ed3d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ed40: 50 push %eax <== NOT EXECUTED 10ed41: e8 96 12 00 00 call 10ffdc <== NOT EXECUTED 10ed46: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ed49: eb 03 jmp 10ed4e <== NOT EXECUTED return (ssize_t) args.bytes_moved; 10ed4b: 8b 45 f4 mov -0xc(%ebp),%eax } 10ed4e: 8b 5d fc mov -0x4(%ebp),%ebx 10ed51: c9 leave 10ed52: c3 ret 001089d2 : /* * Drain output queue */ static void drainOutput (struct rtems_termios_tty *tty) { 1089d2: 55 push %ebp 1089d3: 89 e5 mov %esp,%ebp 1089d5: 53 push %ebx 1089d6: 83 ec 04 sub $0x4,%esp 1089d9: 89 c3 mov %eax,%ebx rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { 1089db: 83 b8 b4 00 00 00 00 cmpl $0x0,0xb4(%eax) 1089e2: 74 46 je 108a2a rtems_interrupt_disable (level); 1089e4: 9c pushf 1089e5: fa cli 1089e6: 58 pop %eax while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) { 1089e7: eb 2f jmp 108a18 tty->rawOutBufState = rob_wait; 1089e9: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) 1089f0: 00 00 00 rtems_interrupt_enable (level); 1089f3: 50 push %eax 1089f4: 9d popf sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, 1089f5: 50 push %eax 1089f6: 6a 00 push $0x0 1089f8: 6a 00 push $0x0 1089fa: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 108a00: e8 77 15 00 00 call 109f7c RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 108a05: 83 c4 10 add $0x10,%esp 108a08: 85 c0 test %eax,%eax 108a0a: 74 09 je 108a15 rtems_fatal_error_occurred (sc); 108a0c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108a0f: 50 push %eax <== NOT EXECUTED 108a10: e8 1f 1b 00 00 call 10a534 <== NOT EXECUTED rtems_interrupt_disable (level); 108a15: 9c pushf 108a16: fa cli 108a17: 58 pop %eax rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { rtems_interrupt_disable (level); while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) { 108a18: 8b 8b 84 00 00 00 mov 0x84(%ebx),%ecx 108a1e: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 108a24: 39 d1 cmp %edx,%ecx 108a26: 75 c1 jne 1089e9 RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } rtems_interrupt_enable (level); 108a28: 50 push %eax 108a29: 9d popf } } 108a2a: 8b 5d fc mov -0x4(%ebp),%ebx 108a2d: c9 leave 108a2e: c3 ret 00107c88 : int dup2( int fildes, int fildes2 ) { 107c88: 55 push %ebp 107c89: 89 e5 mov %esp,%ebp 107c8b: 57 push %edi 107c8c: 56 push %esi 107c8d: 53 push %ebx 107c8e: 83 ec 64 sub $0x64,%esp 107c91: 8b 5d 08 mov 0x8(%ebp),%ebx 107c94: 8b 75 0c mov 0xc(%ebp),%esi /* * If fildes is not valid, then fildes2 should not be closed. */ status = fstat( fildes, &buf ); 107c97: 8d 7d a0 lea -0x60(%ebp),%edi 107c9a: 57 push %edi 107c9b: 53 push %ebx 107c9c: e8 d7 04 00 00 call 108178 if ( status == -1 ) 107ca1: 83 c4 10 add $0x10,%esp 107ca4: 40 inc %eax 107ca5: 74 1e je 107cc5 /* * If fildes2 is not valid, then we should not do anything either. */ status = fstat( fildes2, &buf ); 107ca7: 52 push %edx 107ca8: 52 push %edx 107ca9: 57 push %edi 107caa: 56 push %esi 107cab: e8 c8 04 00 00 call 108178 if ( status == -1 ) 107cb0: 83 c4 10 add $0x10,%esp 107cb3: 40 inc %eax 107cb4: 74 0f je 107cc5 /* * This fcntl handles everything else. */ return fcntl( fildes, F_DUPFD, fildes2 ); 107cb6: 50 push %eax <== NOT EXECUTED 107cb7: 56 push %esi <== NOT EXECUTED 107cb8: 6a 00 push $0x0 <== NOT EXECUTED 107cba: 53 push %ebx <== NOT EXECUTED 107cbb: e8 e0 01 00 00 call 107ea0 <== NOT EXECUTED 107cc0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107cc3: eb 03 jmp 107cc8 <== NOT EXECUTED 107cc5: 83 c8 ff or $0xffffffff,%eax } 107cc8: 8d 65 f4 lea -0xc(%ebp),%esp 107ccb: 5b pop %ebx 107ccc: 5e pop %esi 107ccd: 5f pop %edi 107cce: c9 leave 107ccf: c3 ret 001085ef : /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { 1085ef: 55 push %ebp <== NOT EXECUTED 1085f0: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1085f2: 53 push %ebx <== NOT EXECUTED 1085f3: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) { 1085f6: f6 42 3d 02 testb $0x2,0x3d(%edx) <== NOT EXECUTED 1085fa: 74 3e je 10863a <== NOT EXECUTED 1085fc: 0f b6 c8 movzbl %al,%ecx <== NOT EXECUTED 1085ff: 8b 1d 04 18 12 00 mov 0x121804,%ebx <== NOT EXECUTED 108605: f6 44 0b 01 20 testb $0x20,0x1(%ebx,%ecx,1) <== NOT EXECUTED 10860a: 74 2e je 10863a <== NOT EXECUTED 10860c: 3c 09 cmp $0x9,%al <== NOT EXECUTED 10860e: 74 2a je 10863a <== NOT EXECUTED 108610: 3c 0a cmp $0xa,%al <== NOT EXECUTED 108612: 74 26 je 10863a <== NOT EXECUTED char echobuf[2]; echobuf[0] = '^'; 108614: c6 45 f6 5e movb $0x5e,-0xa(%ebp) <== NOT EXECUTED echobuf[1] = c ^ 0x40; 108618: 83 f0 40 xor $0x40,%eax <== NOT EXECUTED 10861b: 88 45 f7 mov %al,-0x9(%ebp) <== NOT EXECUTED rtems_termios_puts (echobuf, 2, tty); 10861e: 50 push %eax <== NOT EXECUTED 10861f: 52 push %edx <== NOT EXECUTED 108620: 6a 02 push $0x2 <== NOT EXECUTED 108622: 8d 45 f6 lea -0xa(%ebp),%eax <== NOT EXECUTED 108625: 50 push %eax <== NOT EXECUTED 108626: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED 108629: e8 83 fd ff ff call 1083b1 <== NOT EXECUTED tty->column += 2; 10862e: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 108631: 83 42 28 02 addl $0x2,0x28(%edx) <== NOT EXECUTED * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) { 108635: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108638: eb 08 jmp 108642 <== NOT EXECUTED echobuf[1] = c ^ 0x40; rtems_termios_puts (echobuf, 2, tty); tty->column += 2; } else { oproc (c, tty); 10863a: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10863d: e8 8f fe ff ff call 1084d1 <== NOT EXECUTED } } 108642: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 108645: c9 leave <== NOT EXECUTED 108646: c3 ret <== NOT EXECUTED 001257d8 : fclose(group_fp); group_fp = fopen("/etc/group", "r"); } void endgrent(void) { 1257d8: 55 push %ebp <== NOT EXECUTED 1257d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1257db: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (group_fp != NULL) 1257de: a1 8c 36 16 00 mov 0x16368c,%eax <== NOT EXECUTED 1257e3: 85 c0 test %eax,%eax <== NOT EXECUTED 1257e5: 74 0c je 1257f3 <== NOT EXECUTED fclose(group_fp); 1257e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1257ea: 50 push %eax <== NOT EXECUTED 1257eb: e8 d4 30 01 00 call 1388c4 <== NOT EXECUTED 1257f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1257f3: c9 leave <== NOT EXECUTED 1257f4: c3 ret <== NOT EXECUTED 001257f5 : fclose(passwd_fp); passwd_fp = fopen("/etc/passwd", "r"); } void endpwent(void) { 1257f5: 55 push %ebp <== NOT EXECUTED 1257f6: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1257f8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (passwd_fp != NULL) 1257fb: a1 a4 35 16 00 mov 0x1635a4,%eax <== NOT EXECUTED 125800: 85 c0 test %eax,%eax <== NOT EXECUTED 125802: 74 0c je 125810 <== NOT EXECUTED fclose(passwd_fp); 125804: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125807: 50 push %eax <== NOT EXECUTED 125808: e8 b7 30 01 00 call 1388c4 <== NOT EXECUTED 12580d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 125810: c9 leave <== NOT EXECUTED 125811: c3 ret <== NOT EXECUTED 00108647 : * 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) { 108647: 55 push %ebp <== NOT EXECUTED 108648: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10864a: 57 push %edi <== NOT EXECUTED 10864b: 56 push %esi <== NOT EXECUTED 10864c: 53 push %ebx <== NOT EXECUTED 10864d: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 108650: 89 c3 mov %eax,%ebx <== NOT EXECUTED 108652: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED if (tty->ccount == 0) 108655: 83 78 20 00 cmpl $0x0,0x20(%eax) <== NOT EXECUTED 108659: 0f 84 59 01 00 00 je 1087b8 <== NOT EXECUTED return; if (lineFlag) { 10865f: 85 d2 test %edx,%edx <== NOT EXECUTED 108661: 0f 84 46 01 00 00 je 1087ad <== NOT EXECUTED if (!(tty->termios.c_lflag & ECHO)) { 108667: 8b 40 3c mov 0x3c(%eax),%eax <== NOT EXECUTED 10866a: a8 08 test $0x8,%al <== NOT EXECUTED 10866c: 75 0c jne 10867a <== NOT EXECUTED tty->ccount = 0; 10866e: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED return; 108675: e9 3e 01 00 00 jmp 1087b8 <== NOT EXECUTED } if (!(tty->termios.c_lflag & ECHOE)) { 10867a: a8 10 test $0x10,%al <== NOT EXECUTED 10867c: 0f 85 2b 01 00 00 jne 1087ad <== NOT EXECUTED tty->ccount = 0; 108682: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED echo (tty->termios.c_cc[VKILL], tty); 108689: 0f b6 43 44 movzbl 0x44(%ebx),%eax <== NOT EXECUTED 10868d: 89 da mov %ebx,%edx <== NOT EXECUTED 10868f: e8 5b ff ff ff call 1085ef <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) 108694: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED 108698: 0f 84 1a 01 00 00 je 1087b8 <== NOT EXECUTED echo ('\n', tty); 10869e: 89 da mov %ebx,%edx <== NOT EXECUTED 1086a0: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 1086a5: eb 30 jmp 1086d7 <== NOT EXECUTED return; } } while (tty->ccount) { unsigned char c = tty->cbuf[--tty->ccount]; 1086a7: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED 1086aa: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED 1086ad: 89 4b 20 mov %ecx,0x20(%ebx) <== NOT EXECUTED 1086b0: 8a 54 02 ff mov -0x1(%edx,%eax,1),%dl <== NOT EXECUTED if (tty->termios.c_lflag & ECHO) { 1086b4: 8b 7b 3c mov 0x3c(%ebx),%edi <== NOT EXECUTED 1086b7: f7 c7 08 00 00 00 test $0x8,%edi <== NOT EXECUTED 1086bd: 0f 84 e4 00 00 00 je 1087a7 <== NOT EXECUTED if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { 1086c3: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) <== NOT EXECUTED 1086c7: 75 1a jne 1086e3 <== NOT EXECUTED 1086c9: f7 c7 10 00 00 00 test $0x10,%edi <== NOT EXECUTED 1086cf: 75 12 jne 1086e3 <== NOT EXECUTED echo (tty->termios.c_cc[VERASE], tty); 1086d1: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED 1086d5: 89 da mov %ebx,%edx <== NOT EXECUTED } } if (!lineFlag) break; } } 1086d7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1086da: 5b pop %ebx <== NOT EXECUTED 1086db: 5e pop %esi <== NOT EXECUTED 1086dc: 5f pop %edi <== NOT EXECUTED 1086dd: 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); 1086de: e9 0c ff ff ff jmp 1085ef <== NOT EXECUTED } else if (c == '\t') { 1086e3: 80 fa 09 cmp $0x9,%dl <== NOT EXECUTED 1086e6: 8b 0d 04 18 12 00 mov 0x121804,%ecx <== NOT EXECUTED 1086ec: 75 5d jne 10874b <== NOT EXECUTED int col = tty->read_start_column; 1086ee: 8b 73 2c mov 0x2c(%ebx),%esi <== NOT EXECUTED * Erase a character or line * 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) 1086f1: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; } else if (iscntrl (c)) { if (tty->termios.c_lflag & ECHOCTL) 1086f6: 81 e7 00 02 00 00 and $0x200,%edi <== NOT EXECUTED 1086fc: 89 7d e0 mov %edi,-0x20(%ebp) <== NOT EXECUTED 1086ff: 89 c7 mov %eax,%edi <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 108701: eb 27 jmp 10872a <== NOT EXECUTED c = tty->cbuf[i++]; 108703: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 108706: 8a 44 10 ff mov -0x1(%eax,%edx,1),%al <== NOT EXECUTED if (c == '\t') { 10870a: 3c 09 cmp $0x9,%al <== NOT EXECUTED 10870c: 75 05 jne 108713 <== NOT EXECUTED col = (col | 7) + 1; 10870e: 83 ce 07 or $0x7,%esi <== NOT EXECUTED 108711: eb 15 jmp 108728 <== NOT EXECUTED } else if (iscntrl (c)) { 108713: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 108716: f6 44 01 01 20 testb $0x20,0x1(%ecx,%eax,1) <== NOT EXECUTED 10871b: 74 0b je 108728 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOCTL) 10871d: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) <== NOT EXECUTED 108721: 74 06 je 108729 <== NOT EXECUTED col += 2; 108723: 83 c6 02 add $0x2,%esi <== NOT EXECUTED 108726: eb 01 jmp 108729 <== NOT EXECUTED } else { col++; 108728: 46 inc %esi <== NOT EXECUTED 108729: 42 inc %edx <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 10872a: 39 fa cmp %edi,%edx <== NOT EXECUTED 10872c: 75 d5 jne 108703 <== NOT EXECUTED 10872e: eb 14 jmp 108744 <== NOT EXECUTED /* * Back up over the tab */ while (tty->column > col) { rtems_termios_puts ("\b", 1, tty); 108730: 57 push %edi <== NOT EXECUTED 108731: 53 push %ebx <== NOT EXECUTED 108732: 6a 01 push $0x1 <== NOT EXECUTED 108734: 68 a5 d5 11 00 push $0x11d5a5 <== NOT EXECUTED 108739: e8 73 fc ff ff call 1083b1 <== NOT EXECUTED tty->column--; 10873e: ff 4b 28 decl 0x28(%ebx) <== NOT EXECUTED 108741: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Back up over the tab */ while (tty->column > col) { 108744: 39 73 28 cmp %esi,0x28(%ebx) <== NOT EXECUTED 108747: 7f e7 jg 108730 <== NOT EXECUTED 108749: eb 5c jmp 1087a7 <== NOT EXECUTED rtems_termios_puts ("\b", 1, tty); tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { 10874b: 0f b6 f2 movzbl %dl,%esi <== NOT EXECUTED 10874e: f6 44 31 01 20 testb $0x20,0x1(%ecx,%esi,1) <== NOT EXECUTED 108753: 74 24 je 108779 <== NOT EXECUTED 108755: 81 e7 00 02 00 00 and $0x200,%edi <== NOT EXECUTED 10875b: 74 1c je 108779 <== NOT EXECUTED rtems_termios_puts ("\b \b", 3, tty); 10875d: 51 push %ecx <== NOT EXECUTED 10875e: 53 push %ebx <== NOT EXECUTED 10875f: 6a 03 push $0x3 <== NOT EXECUTED 108761: 68 a3 d5 11 00 push $0x11d5a3 <== NOT EXECUTED 108766: e8 46 fc ff ff call 1083b1 <== NOT EXECUTED if (tty->column) 10876b: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10876e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108771: 85 c0 test %eax,%eax <== NOT EXECUTED 108773: 74 04 je 108779 <== NOT EXECUTED tty->column--; 108775: 48 dec %eax <== NOT EXECUTED 108776: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED } if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) { 108779: a1 04 18 12 00 mov 0x121804,%eax <== NOT EXECUTED 10877e: f6 44 30 01 20 testb $0x20,0x1(%eax,%esi,1) <== NOT EXECUTED 108783: 74 06 je 10878b <== NOT EXECUTED 108785: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED 108789: 74 1c je 1087a7 <== NOT EXECUTED rtems_termios_puts ("\b \b", 3, tty); 10878b: 52 push %edx <== NOT EXECUTED 10878c: 53 push %ebx <== NOT EXECUTED 10878d: 6a 03 push $0x3 <== NOT EXECUTED 10878f: 68 a3 d5 11 00 push $0x11d5a3 <== NOT EXECUTED 108794: e8 18 fc ff ff call 1083b1 <== NOT EXECUTED if (tty->column) 108799: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10879c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10879f: 85 c0 test %eax,%eax <== NOT EXECUTED 1087a1: 74 04 je 1087a7 <== NOT EXECUTED tty->column--; 1087a3: 48 dec %eax <== NOT EXECUTED 1087a4: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED } } } if (!lineFlag) 1087a7: 83 7d e4 00 cmpl $0x0,-0x1c(%ebp) <== NOT EXECUTED 1087ab: 74 0b je 1087b8 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) echo ('\n', tty); return; } } while (tty->ccount) { 1087ad: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 1087b0: 85 c0 test %eax,%eax <== NOT EXECUTED 1087b2: 0f 85 ef fe ff ff jne 1086a7 <== NOT EXECUTED } } if (!lineFlag) break; } } 1087b8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1087bb: 5b pop %ebx <== NOT EXECUTED 1087bc: 5e pop %esi <== NOT EXECUTED 1087bd: 5f pop %edi <== NOT EXECUTED 1087be: c9 leave <== NOT EXECUTED 1087bf: c3 ret <== NOT EXECUTED 00133ec4 : #include int fchdir( int fd ) { 133ec4: 55 push %ebp <== NOT EXECUTED 133ec5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 133ec7: 57 push %edi <== NOT EXECUTED 133ec8: 56 push %esi <== NOT EXECUTED 133ec9: 53 push %ebx <== NOT EXECUTED 133eca: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 133ecd: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED rtems_libio_t *iop; rtems_filesystem_location_info_t loc, saved; rtems_libio_check_fd( fd ); 133ed0: 3b 1d a4 c1 15 00 cmp 0x15c1a4,%ebx <== NOT EXECUTED 133ed6: 73 11 jae 133ee9 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 133ed8: c1 e3 06 shl $0x6,%ebx <== NOT EXECUTED 133edb: 03 1d 50 3a 16 00 add 0x163a50,%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 133ee1: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 133ee4: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 133ee7: 75 10 jne 133ef9 <== NOT EXECUTED 133ee9: e8 8a 48 00 00 call 138778 <__errno> <== NOT EXECUTED 133eee: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 133ef4: e9 97 00 00 00 jmp 133f90 <== NOT EXECUTED /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 133ef9: a8 02 test $0x2,%al <== NOT EXECUTED 133efb: 75 10 jne 133f0d <== NOT EXECUTED 133efd: e8 76 48 00 00 call 138778 <__errno> <== NOT EXECUTED 133f02: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 133f08: e9 83 00 00 00 jmp 133f90 <== NOT EXECUTED /* * Verify you can change directory into this node. */ if ( !iop->pathinfo.ops ) { 133f0d: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 133f10: 85 c0 test %eax,%eax <== NOT EXECUTED 133f12: 74 07 je 133f1b <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( !iop->pathinfo.ops->node_type_h ) { 133f14: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 133f17: 85 c0 test %eax,%eax <== NOT EXECUTED 133f19: 75 0d jne 133f28 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 133f1b: e8 58 48 00 00 call 138778 <__errno> <== NOT EXECUTED 133f20: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 133f26: eb 68 jmp 133f90 <== NOT EXECUTED } if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) != 133f28: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 133f2b: 83 c3 18 add $0x18,%ebx <== NOT EXECUTED 133f2e: 53 push %ebx <== NOT EXECUTED 133f2f: ff d0 call *%eax <== NOT EXECUTED 133f31: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 133f34: 48 dec %eax <== NOT EXECUTED 133f35: 74 0d je 133f44 <== NOT EXECUTED RTEMS_FILESYSTEM_DIRECTORY ) { rtems_set_errno_and_return_minus_one( ENOTDIR ); 133f37: e8 3c 48 00 00 call 138778 <__errno> <== NOT EXECUTED 133f3c: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 133f42: eb 4c jmp 133f90 <== NOT EXECUTED * but note the race condition. Threads who * share their rtems_filesystem_current better * be synchronized! */ saved = rtems_filesystem_current; 133f44: a1 dc e1 15 00 mov 0x15e1dc,%eax <== NOT EXECUTED 133f49: 8d 7d c0 lea -0x40(%ebp),%edi <== NOT EXECUTED 133f4c: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 133f4f: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 133f54: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED rtems_filesystem_current = iop->pathinfo; 133f56: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 133f59: b1 05 mov $0x5,%cl <== NOT EXECUTED 133f5b: 89 de mov %ebx,%esi <== NOT EXECUTED 133f5d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* clone the current node */ if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) { 133f5f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 133f62: 6a 00 push $0x0 <== NOT EXECUTED 133f64: 8d 45 d4 lea -0x2c(%ebp),%eax <== NOT EXECUTED 133f67: 50 push %eax <== NOT EXECUTED 133f68: 6a 00 push $0x0 <== NOT EXECUTED 133f6a: 6a 01 push $0x1 <== NOT EXECUTED 133f6c: 68 1e 26 15 00 push $0x15261e <== NOT EXECUTED 133f71: e8 52 77 fd ff call 10b6c8 <== NOT EXECUTED 133f76: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 133f79: 85 c0 test %eax,%eax <== NOT EXECUTED 133f7b: 74 18 je 133f95 <== NOT EXECUTED /* cloning failed; restore original and bail out */ rtems_filesystem_current = saved; 133f7d: 8b 3d dc e1 15 00 mov 0x15e1dc,%edi <== NOT EXECUTED 133f83: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 133f86: 8d 75 c0 lea -0x40(%ebp),%esi <== NOT EXECUTED 133f89: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 133f8e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 133f90: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED return -1; 133f93: eb 2f jmp 133fc4 <== NOT EXECUTED } /* release the old one */ rtems_filesystem_freenode( &saved ); 133f95: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 133f98: 85 c0 test %eax,%eax <== NOT EXECUTED 133f9a: 74 13 je 133faf <== NOT EXECUTED 133f9c: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 133f9f: 85 c0 test %eax,%eax <== NOT EXECUTED 133fa1: 74 0c je 133faf <== NOT EXECUTED 133fa3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 133fa6: 8d 55 c0 lea -0x40(%ebp),%edx <== NOT EXECUTED 133fa9: 52 push %edx <== NOT EXECUTED 133faa: ff d0 call *%eax <== NOT EXECUTED 133fac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_current = loc; 133faf: 8b 3d dc e1 15 00 mov 0x15e1dc,%edi <== NOT EXECUTED 133fb5: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 133fb8: 8d 75 d4 lea -0x2c(%ebp),%esi <== NOT EXECUTED 133fbb: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 133fc0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 133fc2: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 133fc4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 133fc7: 5b pop %ebx <== NOT EXECUTED 133fc8: 5e pop %esi <== NOT EXECUTED 133fc9: 5f pop %edi <== NOT EXECUTED 133fca: c9 leave <== NOT EXECUTED 133fcb: c3 ret <== NOT EXECUTED 001254f0 : int fchmod( int fd, mode_t mode ) { 1254f0: 55 push %ebp <== NOT EXECUTED 1254f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1254f3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1254f6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1254f9: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 1254fc: 3b 05 a4 c1 15 00 cmp 0x15c1a4,%eax <== NOT EXECUTED 125502: 73 11 jae 125515 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 125504: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 125507: 03 05 50 3a 16 00 add 0x163a50,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 12550d: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED 125510: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 125513: 75 0d jne 125522 <== NOT EXECUTED 125515: e8 5e 32 01 00 call 138778 <__errno> <== NOT EXECUTED 12551a: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 125520: eb 3a jmp 12555c <== NOT EXECUTED /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 125522: 80 e2 04 and $0x4,%dl <== NOT EXECUTED 125525: 75 0d jne 125534 <== NOT EXECUTED 125527: e8 4c 32 01 00 call 138778 <__errno> <== NOT EXECUTED 12552c: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 125532: eb 28 jmp 12555c <== NOT EXECUTED if ( !iop->handlers->fchmod_h ) 125534: 8b 50 3c mov 0x3c(%eax),%edx <== NOT EXECUTED 125537: 83 7a 1c 00 cmpl $0x0,0x1c(%edx) <== NOT EXECUTED 12553b: 75 0d jne 12554a <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 12553d: e8 36 32 01 00 call 138778 <__errno> <== NOT EXECUTED 125542: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 125548: eb 12 jmp 12555c <== NOT EXECUTED return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode ); 12554a: 8b 50 20 mov 0x20(%eax),%edx <== NOT EXECUTED 12554d: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED 125550: 83 c0 18 add $0x18,%eax <== NOT EXECUTED 125553: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 125556: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED } 125559: c9 leave <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); if ( !iop->handlers->fchmod_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode ); 12555a: ff e0 jmp *%eax <== NOT EXECUTED } 12555c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 12555f: c9 leave <== NOT EXECUTED 125560: c3 ret <== NOT EXECUTED 00125564 : int fchown( int fd, uid_t owner, gid_t group ) { 125564: 55 push %ebp <== NOT EXECUTED 125565: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125567: 53 push %ebx <== NOT EXECUTED 125568: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 12556b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 12556e: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 125571: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 125574: 3b 05 a4 c1 15 00 cmp 0x15c1a4,%eax <== NOT EXECUTED 12557a: 73 11 jae 12558d <== NOT EXECUTED iop = rtems_libio_iop( fd ); 12557c: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 12557f: 03 05 50 3a 16 00 add 0x163a50,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 125585: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED 125588: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 12558b: 75 0d jne 12559a <== NOT EXECUTED 12558d: e8 e6 31 01 00 call 138778 <__errno> <== NOT EXECUTED 125592: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 125598: eb 40 jmp 1255da <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 12559a: 80 e2 04 and $0x4,%dl <== NOT EXECUTED 12559d: 75 0d jne 1255ac <== NOT EXECUTED 12559f: e8 d4 31 01 00 call 138778 <__errno> <== NOT EXECUTED 1255a4: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1255aa: eb 2e jmp 1255da <== NOT EXECUTED if ( !iop->pathinfo.ops->chown_h ) 1255ac: 8b 50 24 mov 0x24(%eax),%edx <== NOT EXECUTED 1255af: 8b 52 18 mov 0x18(%edx),%edx <== NOT EXECUTED 1255b2: 85 d2 test %edx,%edx <== NOT EXECUTED 1255b4: 75 0d jne 1255c3 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1255b6: e8 bd 31 01 00 call 138778 <__errno> <== NOT EXECUTED 1255bb: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1255c1: eb 17 jmp 1255da <== NOT EXECUTED return (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group ); 1255c3: 0f b7 db movzwl %bx,%ebx <== NOT EXECUTED 1255c6: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 1255c9: 0f b7 c9 movzwl %cx,%ecx <== NOT EXECUTED 1255cc: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED 1255cf: 83 c0 18 add $0x18,%eax <== NOT EXECUTED 1255d2: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 1255d5: 59 pop %ecx <== NOT EXECUTED 1255d6: 5b pop %ebx <== NOT EXECUTED 1255d7: c9 leave <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); if ( !iop->pathinfo.ops->chown_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group ); 1255d8: ff e2 jmp *%edx <== NOT EXECUTED } 1255da: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1255dd: 5a pop %edx <== NOT EXECUTED 1255de: 5b pop %ebx <== NOT EXECUTED 1255df: c9 leave <== NOT EXECUTED 1255e0: c3 ret <== NOT EXECUTED 00133fcc : int fcntl( int fd, int cmd, ... ) { 133fcc: 55 push %ebp 133fcd: 89 e5 mov %esp,%ebp 133fcf: 57 push %edi 133fd0: 56 push %esi 133fd1: 53 push %ebx 133fd2: 83 ec 0c sub $0xc,%esp 133fd5: 8b 5d 08 mov 0x8(%ebp),%ebx #include #include /* sigh. for the mode bits for open/creat */ extern int open _PARAMS ((const char *, int, ...)); extern int creat _PARAMS ((const char *, mode_t)); extern int fcntl _PARAMS ((int, int, ...)); 133fd8: 8d 55 10 lea 0x10(%ebp),%edx int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 133fdb: 8b 0d a4 c1 15 00 mov 0x15c1a4,%ecx 133fe1: 39 cb cmp %ecx,%ebx 133fe3: 73 16 jae 133ffb iop = rtems_libio_iop( fd ); 133fe5: a1 50 3a 16 00 mov 0x163a50,%eax 133fea: c1 e3 06 shl $0x6,%ebx 133fed: 8d 1c 18 lea (%eax,%ebx,1),%ebx rtems_libio_check_is_open(iop); 133ff0: 8b 73 14 mov 0x14(%ebx),%esi 133ff3: f7 c6 00 01 00 00 test $0x100,%esi 133ff9: 75 10 jne 13400b 133ffb: e8 78 47 00 00 call 138778 <__errno> <== NOT EXECUTED 134000: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 134006: e9 fe 00 00 00 jmp 134109 <== NOT EXECUTED /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 13400b: 83 7d 0c 09 cmpl $0x9,0xc(%ebp) 13400f: 0f 87 c1 00 00 00 ja 1340d6 134015: 8b 7d 0c mov 0xc(%ebp),%edi 134018: ff 24 bd 40 88 15 00 jmp *0x158840(,%edi,4) case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); 13401f: 8b 32 mov (%edx),%esi if ( fd2 ) 134021: 85 f6 test %esi,%esi 134023: 74 10 je 134035 diop = rtems_libio_iop( fd2 ); 134025: 31 d2 xor %edx,%edx <== NOT EXECUTED 134027: 39 ce cmp %ecx,%esi <== NOT EXECUTED 134029: 73 1c jae 134047 <== NOT EXECUTED 13402b: 89 f2 mov %esi,%edx <== NOT EXECUTED 13402d: c1 e2 06 shl $0x6,%edx <== NOT EXECUTED 134030: 8d 14 10 lea (%eax,%edx,1),%edx <== NOT EXECUTED 134033: eb 12 jmp 134047 <== NOT EXECUTED else { /* allocate a file control block */ diop = rtems_libio_allocate(); 134035: e8 1d 7a fd ff call 10ba57 13403a: 89 c2 mov %eax,%edx if ( diop == 0 ) { 13403c: 83 ce ff or $0xffffffff,%esi 13403f: 85 c0 test %eax,%eax 134041: 0f 84 c5 00 00 00 je 13410c ret = -1; break; } } diop->handlers = iop->handlers; 134047: 8b 43 3c mov 0x3c(%ebx),%eax 13404a: 89 42 3c mov %eax,0x3c(%edx) diop->file_info = iop->file_info; 13404d: 8b 43 38 mov 0x38(%ebx),%eax 134050: 89 42 38 mov %eax,0x38(%edx) diop->flags = iop->flags; 134053: 8b 43 14 mov 0x14(%ebx),%eax 134056: 89 42 14 mov %eax,0x14(%edx) diop->pathinfo = iop->pathinfo; 134059: 8d 7a 18 lea 0x18(%edx),%edi 13405c: 8d 73 18 lea 0x18(%ebx),%esi 13405f: b9 05 00 00 00 mov $0x5,%ecx 134064: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ret = (int) (diop - rtems_libio_iops); 134066: 89 d6 mov %edx,%esi 134068: 2b 35 50 3a 16 00 sub 0x163a50,%esi 13406e: c1 fe 06 sar $0x6,%esi 134071: eb 70 jmp 1340e3 break; case F_GETFD: /* get f_flags */ ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0); 134073: c1 ee 0b shr $0xb,%esi 134076: 83 e6 01 and $0x1,%esi 134079: eb 6c jmp 1340e7 * 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 ) ) 13407b: 83 3a 00 cmpl $0x0,(%edx) 13407e: 74 08 je 134088 iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; 134080: 81 ce 00 08 00 00 or $0x800,%esi 134086: eb 06 jmp 13408e else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; 134088: 81 e6 ff f7 ff ff and $0xfffff7ff,%esi <== NOT EXECUTED 13408e: 89 73 14 mov %esi,0x14(%ebx) 134091: 31 f6 xor %esi,%esi 134093: eb 52 jmp 1340e7 break; case F_GETFL: /* more flags (cloexec) */ ret = rtems_libio_to_fcntl_flags( iop->flags ); 134095: 83 ec 0c sub $0xc,%esp 134098: 56 push %esi 134099: e8 6e 78 fd ff call 10b90c 13409e: 89 c6 mov %eax,%esi 1340a0: 83 c4 10 add $0x10,%esp 1340a3: eb 3e jmp 1340e3 break; case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); 1340a5: 83 ec 0c sub $0xc,%esp 1340a8: ff 32 pushl (%edx) 1340aa: e8 33 7a fd ff call 10bae2 /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = (iop->flags & ~mask) | (flags & mask); 1340af: 25 01 02 00 00 and $0x201,%eax 1340b4: 8b 53 14 mov 0x14(%ebx),%edx 1340b7: 81 e2 fe fd ff ff and $0xfffffdfe,%edx 1340bd: 09 d0 or %edx,%eax 1340bf: 89 43 14 mov %eax,0x14(%ebx) 1340c2: 31 f6 xor %esi,%esi 1340c4: 83 c4 10 add $0x10,%esp 1340c7: eb 1e jmp 1340e7 errno = ENOTSUP; ret = -1; break; case F_GETOWN: /* for sockets. */ errno = ENOTSUP; 1340c9: e8 aa 46 00 00 call 138778 <__errno> 1340ce: c7 00 86 00 00 00 movl $0x86,(%eax) 1340d4: eb 33 jmp 134109 ret = -1; break; default: errno = EINVAL; 1340d6: e8 9d 46 00 00 call 138778 <__errno> 1340db: c7 00 16 00 00 00 movl $0x16,(%eax) 1340e1: eb 26 jmp 134109 /* * If we got this far successfully, then we give the optional * filesystem specific handler a chance to process this. */ if (ret >= 0) { 1340e3: 85 f6 test %esi,%esi 1340e5: 78 25 js 13410c if (iop->handlers->fcntl_h) { 1340e7: 8b 43 3c mov 0x3c(%ebx),%eax 1340ea: 8b 40 30 mov 0x30(%eax),%eax 1340ed: 85 c0 test %eax,%eax 1340ef: 74 1b je 13410c int err = (*iop->handlers->fcntl_h)( cmd, iop ); 1340f1: 52 push %edx 1340f2: 52 push %edx 1340f3: 53 push %ebx 1340f4: ff 75 0c pushl 0xc(%ebp) 1340f7: ff d0 call *%eax 1340f9: 89 c3 mov %eax,%ebx if (err) { 1340fb: 83 c4 10 add $0x10,%esp 1340fe: 85 c0 test %eax,%eax 134100: 74 0a je 13410c errno = err; 134102: e8 71 46 00 00 call 138778 <__errno> <== NOT EXECUTED 134107: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 134109: 83 ce ff or $0xffffffff,%esi va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; } 13410c: 89 f0 mov %esi,%eax 13410e: 8d 65 f4 lea -0xc(%ebp),%esp 134111: 5b pop %ebx 134112: 5e pop %esi 134113: 5f pop %edi 134114: c9 leave 134115: c3 ret 0010f2e8 : */ int fifo_open( pipe_control_t **pipep, rtems_libio_t *iop ) { 10f2e8: 55 push %ebp 10f2e9: 89 e5 mov %esp,%ebp 10f2eb: 57 push %edi 10f2ec: 56 push %esi 10f2ed: 53 push %ebx 10f2ee: 83 ec 30 sub $0x30,%esp ) { pipe_control_t *pipe; int err = 0; if (rtems_semaphore_obtain(rtems_pipe_semaphore, 10f2f1: 6a 00 push $0x0 10f2f3: 6a 00 push $0x0 10f2f5: ff 35 58 36 12 00 pushl 0x123658 10f2fb: e8 7c ac ff ff call 109f7c 10f300: 89 c2 mov %eax,%edx 10f302: 83 c4 10 add $0x10,%esp 10f305: bf fc ff ff ff mov $0xfffffffc,%edi 10f30a: 85 c0 test %eax,%eax 10f30c: 0f 85 f3 02 00 00 jne 10f605 RTEMS_WAIT, RTEMS_NO_TIMEOUT) != RTEMS_SUCCESSFUL) return -EINTR; pipe = *pipep; 10f312: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10f315: 8b 30 mov (%eax),%esi <== NOT EXECUTED if (pipe == NULL) { 10f317: 85 f6 test %esi,%esi <== NOT EXECUTED 10f319: 0f 85 13 01 00 00 jne 10f432 <== NOT EXECUTED { static char c = 'a'; pipe_control_t *pipe; int err = -ENOMEM; pipe = malloc(sizeof(pipe_control_t)); 10f31f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f322: 6a 34 push $0x34 <== NOT EXECUTED 10f324: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED 10f327: e8 80 80 ff ff call 1073ac <== NOT EXECUTED 10f32c: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10f32e: 89 c6 mov %eax,%esi <== NOT EXECUTED if (pipe == NULL) 10f330: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f333: 66 bf f4 ff mov $0xfff4,%di <== NOT EXECUTED 10f337: 85 c0 test %eax,%eax <== NOT EXECUTED 10f339: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 10f33c: 0f 84 24 01 00 00 je 10f466 <== NOT EXECUTED return err; memset(pipe, 0, sizeof(pipe_control_t)); 10f342: b9 0d 00 00 00 mov $0xd,%ecx <== NOT EXECUTED 10f347: 89 c7 mov %eax,%edi <== NOT EXECUTED 10f349: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f34b: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED pipe->Size = PIPE_BUF; 10f34d: c7 43 04 00 02 00 00 movl $0x200,0x4(%ebx) <== NOT EXECUTED pipe->Buffer = malloc(pipe->Size); 10f354: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f357: 68 00 02 00 00 push $0x200 <== NOT EXECUTED 10f35c: e8 4b 80 ff ff call 1073ac <== NOT EXECUTED 10f361: 89 03 mov %eax,(%ebx) <== NOT EXECUTED if (! pipe->Buffer) 10f363: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f366: bf f4 ff ff ff mov $0xfffffff4,%edi <== NOT EXECUTED 10f36b: 85 c0 test %eax,%eax <== NOT EXECUTED 10f36d: 0f 84 b1 00 00 00 je 10f424 <== NOT EXECUTED goto err_buf; err = -EINTR; if (rtems_barrier_create( 10f373: 8d 43 2c lea 0x2c(%ebx),%eax <== NOT EXECUTED 10f376: 50 push %eax <== NOT EXECUTED 10f377: 6a 00 push $0x0 <== NOT EXECUTED 10f379: 6a 00 push $0x0 <== NOT EXECUTED 10f37b: 0f be 05 f0 17 12 00 movsbl 0x1217f0,%eax <== NOT EXECUTED 10f382: 0d 00 72 49 50 or $0x50497200,%eax <== NOT EXECUTED 10f387: 50 push %eax <== NOT EXECUTED 10f388: e8 0b 05 00 00 call 10f898 <== NOT EXECUTED 10f38d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f390: 85 c0 test %eax,%eax <== NOT EXECUTED 10f392: 75 7e jne 10f412 <== NOT EXECUTED rtems_build_name ('P', 'I', 'r', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->readBarrier) != RTEMS_SUCCESSFUL) goto err_rbar; if (rtems_barrier_create( 10f394: 8d 43 30 lea 0x30(%ebx),%eax <== NOT EXECUTED 10f397: 50 push %eax <== NOT EXECUTED 10f398: 6a 00 push $0x0 <== NOT EXECUTED 10f39a: 6a 00 push $0x0 <== NOT EXECUTED 10f39c: 0f be 05 f0 17 12 00 movsbl 0x1217f0,%eax <== NOT EXECUTED 10f3a3: 0d 00 77 49 50 or $0x50497700,%eax <== NOT EXECUTED 10f3a8: 50 push %eax <== NOT EXECUTED 10f3a9: e8 ea 04 00 00 call 10f898 <== NOT EXECUTED 10f3ae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f3b1: 85 c0 test %eax,%eax <== NOT EXECUTED 10f3b3: 75 4f jne 10f404 <== NOT EXECUTED rtems_build_name ('P', 'I', 'w', c), RTEMS_BARRIER_MANUAL_RELEASE, 0, &pipe->writeBarrier) != RTEMS_SUCCESSFUL) goto err_wbar; if (rtems_semaphore_create( 10f3b5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f3b8: 8d 43 28 lea 0x28(%ebx),%eax <== NOT EXECUTED 10f3bb: 50 push %eax <== NOT EXECUTED 10f3bc: 6a 00 push $0x0 <== NOT EXECUTED 10f3be: 6a 10 push $0x10 <== NOT EXECUTED 10f3c0: 6a 01 push $0x1 <== NOT EXECUTED 10f3c2: 0f be 05 f0 17 12 00 movsbl 0x1217f0,%eax <== NOT EXECUTED 10f3c9: 0d 00 73 49 50 or $0x50497300,%eax <== NOT EXECUTED 10f3ce: 50 push %eax <== NOT EXECUTED 10f3cf: e8 7c a9 ff ff call 109d50 <== NOT EXECUTED 10f3d4: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10f3d7: 85 c0 test %eax,%eax <== NOT EXECUTED 10f3d9: 75 1b jne 10f3f6 <== NOT EXECUTED #ifdef RTEMS_POSIX_API pipe_interruptible(pipe); #endif *pipep = pipe; if (c ++ == 'z') 10f3db: a0 f0 17 12 00 mov 0x1217f0,%al <== NOT EXECUTED 10f3e0: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED 10f3e3: 88 15 f0 17 12 00 mov %dl,0x1217f0 <== NOT EXECUTED 10f3e9: 3c 7a cmp $0x7a,%al <== NOT EXECUTED 10f3eb: 75 45 jne 10f432 <== NOT EXECUTED c = 'a'; 10f3ed: c6 05 f0 17 12 00 61 movb $0x61,0x1217f0 <== NOT EXECUTED 10f3f4: eb 3c jmp 10f432 <== NOT EXECUTED return 0; err_sem: rtems_barrier_delete(pipe->writeBarrier); 10f3f6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f3f9: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10f3fc: e8 4f 05 00 00 call 10f950 <== NOT EXECUTED 10f401: 83 c4 10 add $0x10,%esp <== NOT EXECUTED err_wbar: rtems_barrier_delete(pipe->readBarrier); 10f404: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f407: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10f40a: e8 41 05 00 00 call 10f950 <== NOT EXECUTED 10f40f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED err_rbar: free(pipe->Buffer); 10f412: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f415: ff 33 pushl (%ebx) <== NOT EXECUTED 10f417: e8 64 7d ff ff call 107180 <== NOT EXECUTED 10f41c: bf fc ff ff ff mov $0xfffffffc,%edi <== NOT EXECUTED 10f421: 83 c4 10 add $0x10,%esp <== NOT EXECUTED err_buf: free(pipe); 10f424: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f427: 53 push %ebx <== NOT EXECUTED 10f428: e8 53 7d ff ff call 107180 <== NOT EXECUTED 10f42d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f430: eb 34 jmp 10f466 <== NOT EXECUTED err = pipe_alloc(&pipe); if (err) goto out; } if (! PIPE_LOCK(pipe)) 10f432: 57 push %edi <== NOT EXECUTED 10f433: 6a 00 push $0x0 <== NOT EXECUTED 10f435: 6a 00 push $0x0 <== NOT EXECUTED 10f437: ff 76 28 pushl 0x28(%esi) <== NOT EXECUTED 10f43a: e8 3d ab ff ff call 109f7c <== NOT EXECUTED 10f43f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f442: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10f445: 19 ff sbb %edi,%edi <== NOT EXECUTED 10f447: f7 d7 not %edi <== NOT EXECUTED 10f449: 83 e7 fc and $0xfffffffc,%edi <== NOT EXECUTED err = -EINTR; if (*pipep == NULL) { 10f44c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10f44f: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10f452: 75 12 jne 10f466 <== NOT EXECUTED if (err) 10f454: 85 ff test %edi,%edi <== NOT EXECUTED 10f456: 74 09 je 10f461 <== NOT EXECUTED pipe_free(pipe); 10f458: 89 f0 mov %esi,%eax <== NOT EXECUTED 10f45a: e8 7e fd ff ff call 10f1dd <== NOT EXECUTED 10f45f: eb 05 jmp 10f466 <== NOT EXECUTED else *pipep = pipe; 10f461: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10f464: 89 30 mov %esi,(%eax) <== NOT EXECUTED } out: rtems_semaphore_release(rtems_pipe_semaphore); 10f466: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f469: ff 35 58 36 12 00 pushl 0x123658 <== NOT EXECUTED 10f46f: e8 f4 ab ff ff call 10a068 <== NOT EXECUTED pipe_control_t *pipe; uint prevCounter; int err; err = pipe_new(pipep); if (err) 10f474: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f477: 85 ff test %edi,%edi <== NOT EXECUTED 10f479: 0f 85 86 01 00 00 jne 10f605 <== NOT EXECUTED return err; pipe = *pipep; 10f47f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10f482: 8b 18 mov (%eax),%ebx <== NOT EXECUTED switch (LIBIO_ACCMODE(iop)) { 10f484: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f487: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED 10f48a: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f48c: 83 e0 06 and $0x6,%eax <== NOT EXECUTED 10f48f: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10f492: 0f 84 91 00 00 00 je 10f529 <== NOT EXECUTED 10f498: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 10f49b: 0f 84 00 01 00 00 je 10f5a1 <== NOT EXECUTED 10f4a1: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10f4a4: 0f 85 39 01 00 00 jne 10f5e3 <== NOT EXECUTED case LIBIO_FLAGS_READ: pipe->readerCounter ++; 10f4aa: ff 43 20 incl 0x20(%ebx) <== NOT EXECUTED if (pipe->Readers ++ == 0) 10f4ad: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10f4b0: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED 10f4b3: 89 53 10 mov %edx,0x10(%ebx) <== NOT EXECUTED 10f4b6: 85 c0 test %eax,%eax <== NOT EXECUTED 10f4b8: 75 11 jne 10f4cb <== NOT EXECUTED PIPE_WAKEUPWRITERS(pipe); 10f4ba: 56 push %esi <== NOT EXECUTED 10f4bb: 56 push %esi <== NOT EXECUTED 10f4bc: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10f4bf: 50 push %eax <== NOT EXECUTED 10f4c0: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10f4c3: e8 e8 04 00 00 call 10f9b0 <== NOT EXECUTED 10f4c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (pipe->Writers == 0) { 10f4cb: 83 7b 14 00 cmpl $0x0,0x14(%ebx) <== NOT EXECUTED 10f4cf: 0f 85 0e 01 00 00 jne 10f5e3 <== NOT EXECUTED /* Not an error */ if (LIBIO_NODELAY(iop)) 10f4d5: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f4d8: f6 40 14 01 testb $0x1,0x14(%eax) <== NOT EXECUTED 10f4dc: 0f 85 01 01 00 00 jne 10f5e3 <== NOT EXECUTED break; prevCounter = pipe->writerCounter; 10f4e2: 8b 73 24 mov 0x24(%ebx),%esi <== NOT EXECUTED err = -EINTR; /* Wait until a writer opens the pipe */ do { PIPE_UNLOCK(pipe); 10f4e5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f4e8: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f4eb: e8 78 ab ff ff call 10a068 <== NOT EXECUTED if (! PIPE_READWAIT(pipe)) 10f4f0: 5a pop %edx <== NOT EXECUTED 10f4f1: 59 pop %ecx <== NOT EXECUTED 10f4f2: 6a 00 push $0x0 <== NOT EXECUTED 10f4f4: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10f4f7: e8 0c 05 00 00 call 10fa08 <== NOT EXECUTED 10f4fc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f4ff: 85 c0 test %eax,%eax <== NOT EXECUTED 10f501: 0f 85 e9 00 00 00 jne 10f5f0 <== NOT EXECUTED goto out_error; if (! PIPE_LOCK(pipe)) 10f507: 50 push %eax <== NOT EXECUTED 10f508: 6a 00 push $0x0 <== NOT EXECUTED 10f50a: 6a 00 push $0x0 <== NOT EXECUTED 10f50c: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f50f: e8 68 aa ff ff call 109f7c <== NOT EXECUTED 10f514: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f517: 85 c0 test %eax,%eax <== NOT EXECUTED 10f519: 0f 85 d1 00 00 00 jne 10f5f0 <== NOT EXECUTED goto out_error; } while (prevCounter == pipe->writerCounter); 10f51f: 3b 73 24 cmp 0x24(%ebx),%esi <== NOT EXECUTED 10f522: 74 c1 je 10f4e5 <== NOT EXECUTED 10f524: e9 ba 00 00 00 jmp 10f5e3 <== NOT EXECUTED } break; case LIBIO_FLAGS_WRITE: if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) { 10f529: 83 7b 10 00 cmpl $0x0,0x10(%ebx) <== NOT EXECUTED 10f52d: 75 0f jne 10f53e <== NOT EXECUTED 10f52f: 80 e2 01 and $0x1,%dl <== NOT EXECUTED 10f532: 74 0a je 10f53e <== NOT EXECUTED 10f534: bf fa ff ff ff mov $0xfffffffa,%edi <== NOT EXECUTED 10f539: e9 b7 00 00 00 jmp 10f5f5 <== NOT EXECUTED err = -ENXIO; goto out_error; } pipe->writerCounter ++; 10f53e: ff 43 24 incl 0x24(%ebx) <== NOT EXECUTED if (pipe->Writers ++ == 0) 10f541: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10f544: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED 10f547: 89 53 14 mov %edx,0x14(%ebx) <== NOT EXECUTED 10f54a: 85 c0 test %eax,%eax <== NOT EXECUTED 10f54c: 75 11 jne 10f55f <== NOT EXECUTED PIPE_WAKEUPREADERS(pipe); 10f54e: 56 push %esi <== NOT EXECUTED 10f54f: 56 push %esi <== NOT EXECUTED 10f550: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10f553: 50 push %eax <== NOT EXECUTED 10f554: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10f557: e8 54 04 00 00 call 10f9b0 <== NOT EXECUTED 10f55c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (pipe->Readers == 0) { 10f55f: 83 7b 10 00 cmpl $0x0,0x10(%ebx) <== NOT EXECUTED 10f563: 75 7e jne 10f5e3 <== NOT EXECUTED prevCounter = pipe->readerCounter; 10f565: 8b 73 20 mov 0x20(%ebx),%esi <== NOT EXECUTED err = -EINTR; do { PIPE_UNLOCK(pipe); 10f568: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f56b: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f56e: e8 f5 aa ff ff call 10a068 <== NOT EXECUTED if (! PIPE_WRITEWAIT(pipe)) 10f573: 5a pop %edx <== NOT EXECUTED 10f574: 59 pop %ecx <== NOT EXECUTED 10f575: 6a 00 push $0x0 <== NOT EXECUTED 10f577: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10f57a: e8 89 04 00 00 call 10fa08 <== NOT EXECUTED 10f57f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f582: 85 c0 test %eax,%eax <== NOT EXECUTED 10f584: 75 6a jne 10f5f0 <== NOT EXECUTED goto out_error; if (! PIPE_LOCK(pipe)) 10f586: 50 push %eax <== NOT EXECUTED 10f587: 6a 00 push $0x0 <== NOT EXECUTED 10f589: 6a 00 push $0x0 <== NOT EXECUTED 10f58b: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f58e: e8 e9 a9 ff ff call 109f7c <== NOT EXECUTED 10f593: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f596: 85 c0 test %eax,%eax <== NOT EXECUTED 10f598: 75 56 jne 10f5f0 <== NOT EXECUTED goto out_error; } while (prevCounter == pipe->readerCounter); 10f59a: 3b 73 20 cmp 0x20(%ebx),%esi <== NOT EXECUTED 10f59d: 74 c9 je 10f568 <== NOT EXECUTED 10f59f: eb 42 jmp 10f5e3 <== NOT EXECUTED } break; case LIBIO_FLAGS_READ_WRITE: pipe->readerCounter ++; 10f5a1: ff 43 20 incl 0x20(%ebx) <== NOT EXECUTED if (pipe->Readers ++ == 0) 10f5a4: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10f5a7: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED 10f5aa: 89 53 10 mov %edx,0x10(%ebx) <== NOT EXECUTED 10f5ad: 85 c0 test %eax,%eax <== NOT EXECUTED 10f5af: 75 11 jne 10f5c2 <== NOT EXECUTED PIPE_WAKEUPWRITERS(pipe); 10f5b1: 56 push %esi <== NOT EXECUTED 10f5b2: 56 push %esi <== NOT EXECUTED 10f5b3: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10f5b6: 50 push %eax <== NOT EXECUTED 10f5b7: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10f5ba: e8 f1 03 00 00 call 10f9b0 <== NOT EXECUTED 10f5bf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED pipe->writerCounter ++; 10f5c2: ff 43 24 incl 0x24(%ebx) <== NOT EXECUTED if (pipe->Writers ++ == 0) 10f5c5: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10f5c8: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED 10f5cb: 89 53 14 mov %edx,0x14(%ebx) <== NOT EXECUTED 10f5ce: 85 c0 test %eax,%eax <== NOT EXECUTED 10f5d0: 75 11 jne 10f5e3 <== NOT EXECUTED PIPE_WAKEUPREADERS(pipe); 10f5d2: 51 push %ecx <== NOT EXECUTED 10f5d3: 51 push %ecx <== NOT EXECUTED 10f5d4: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10f5d7: 50 push %eax <== NOT EXECUTED 10f5d8: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10f5db: e8 d0 03 00 00 call 10f9b0 <== NOT EXECUTED 10f5e0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } PIPE_UNLOCK(pipe); 10f5e3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f5e6: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f5e9: e8 7a aa ff ff call 10a068 <== NOT EXECUTED 10f5ee: eb 12 jmp 10f602 <== NOT EXECUTED return 0; 10f5f0: bf fc ff ff ff mov $0xfffffffc,%edi <== NOT EXECUTED out_error: pipe_release(pipep, iop); 10f5f5: 52 push %edx <== NOT EXECUTED 10f5f6: 52 push %edx <== NOT EXECUTED 10f5f7: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10f5fa: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f5fd: e8 16 fc ff ff call 10f218 <== NOT EXECUTED return err; 10f602: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10f605: 89 f8 mov %edi,%eax 10f607: 8d 65 f4 lea -0xc(%ebp),%esp 10f60a: 5b pop %ebx 10f60b: 5e pop %esi 10f60c: 5f pop %edi 10f60d: c9 leave 10f60e: c3 ret 0010e67a : bool file_systems_below_this_mountpoint( const char *path __attribute__((unused)), rtems_filesystem_location_info_t *fs_root_loc, rtems_filesystem_mount_table_entry_t *fs_to_unmount __attribute__((unused)) ) { 10e67a: 55 push %ebp <== NOT EXECUTED 10e67b: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e67d: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED /* * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; 10e680: a1 94 3a 16 00 mov 0x163a94,%eax <== NOT EXECUTED 10e685: eb 0e jmp 10e695 <== 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 ) { 10e687: 8b 48 18 mov 0x18(%eax),%ecx <== NOT EXECUTED 10e68a: 3b 4a 10 cmp 0x10(%edx),%ecx <== NOT EXECUTED 10e68d: 75 04 jne 10e693 <== NOT EXECUTED 10e68f: b0 01 mov $0x1,%al <== NOT EXECUTED 10e691: eb 0b jmp 10e69e <== 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 ) { 10e693: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10e695: 3d 98 3a 16 00 cmp $0x163a98,%eax <== NOT EXECUTED 10e69a: 75 eb jne 10e687 <== NOT EXECUTED 10e69c: 31 c0 xor %eax,%eax <== NOT EXECUTED return true; } } return false; } 10e69e: c9 leave <== NOT EXECUTED 10e69f: c3 ret <== NOT EXECUTED 00107180 : void free( void *ptr ) { MSBUMP(free_calls, 1); 107180: 55 push %ebp 107181: 89 e5 mov %esp,%ebp 107183: 53 push %ebx 107184: 83 ec 04 sub $0x4,%esp 107187: 8b 5d 08 mov 0x8(%ebp),%ebx 10718a: ff 05 7c 38 12 00 incl 0x12387c if ( !ptr ) 107190: 85 db test %ebx,%ebx 107192: 74 5f je 1071f3 /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 107194: 83 3d 4c 3b 12 00 03 cmpl $0x3,0x123b4c 10719b: 75 15 jne 1071b2 10719d: e8 e2 00 00 00 call 107284 1071a2: 84 c0 test %al,%al 1071a4: 75 0c jne 1071b2 !malloc_is_system_state_OK() ) { malloc_deferred_free(ptr); 1071a6: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end ); } } 1071a9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1071ac: 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); 1071ad: e9 10 01 00 00 jmp 1072c2 <== NOT EXECUTED #endif /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 1071b2: a1 10 1d 12 00 mov 0x121d10,%eax 1071b7: 85 c0 test %eax,%eax 1071b9: 74 0a je 1071c5 (*rtems_malloc_statistics_helpers->at_free)(ptr); 1071bb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1071be: 53 push %ebx <== NOT EXECUTED 1071bf: ff 50 08 call *0x8(%eax) <== NOT EXECUTED 1071c2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) { 1071c5: 50 push %eax 1071c6: 50 push %eax 1071c7: 53 push %ebx 1071c8: ff 35 90 f9 11 00 pushl 0x11f990 1071ce: e8 69 44 00 00 call 10b63c <_Protected_heap_Free> 1071d3: 83 c4 10 add $0x10,%esp 1071d6: 84 c0 test %al,%al 1071d8: 75 19 jne 1071f3 printk( "Program heap: free of bad pointer %p -- range %p - %p \n", ptr, RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end 1071da: a1 90 f9 11 00 mov 0x11f990,%eax <== NOT EXECUTED */ if ( rtems_malloc_statistics_helpers ) (*rtems_malloc_statistics_helpers->at_free)(ptr); if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) { printk( "Program heap: free of bad pointer %p -- range %p - %p \n", 1071df: ff 70 1c pushl 0x1c(%eax) <== NOT EXECUTED 1071e2: ff 70 18 pushl 0x18(%eax) <== NOT EXECUTED 1071e5: 53 push %ebx <== NOT EXECUTED 1071e6: 68 69 d5 11 00 push $0x11d569 <== NOT EXECUTED 1071eb: e8 94 0b 00 00 call 107d84 <== NOT EXECUTED 1071f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED RTEMS_Malloc_Heap->area_begin, RTEMS_Malloc_Heap->area_end ); } } 1071f3: 8b 5d fc mov -0x4(%ebp),%ebx 1071f6: c9 leave 1071f7: c3 ret 00126578 : * NOTE: this must be called with * thread dispatching disabled! */ static void free_user_env(void *venv) { 126578: 55 push %ebp <== NOT EXECUTED 126579: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12657b: 53 push %ebx <== NOT EXECUTED 12657c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 12657f: 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 126582: 81 fb ac 3a 16 00 cmp $0x163aac,%ebx <== NOT EXECUTED 126588: 74 40 je 1265ca <== NOT EXECUTED #ifdef HAVE_USERENV_REFCNT && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); 12658a: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 12658d: 85 c0 test %eax,%eax <== NOT EXECUTED 12658f: 74 13 je 1265a4 <== NOT EXECUTED 126591: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 126594: 85 c0 test %eax,%eax <== NOT EXECUTED 126596: 74 0c je 1265a4 <== NOT EXECUTED 126598: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12659b: 8d 53 04 lea 0x4(%ebx),%edx <== NOT EXECUTED 12659e: 52 push %edx <== NOT EXECUTED 12659f: ff d0 call *%eax <== NOT EXECUTED 1265a1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &env->root_directory); 1265a4: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 1265a7: 85 c0 test %eax,%eax <== NOT EXECUTED 1265a9: 74 13 je 1265be <== NOT EXECUTED 1265ab: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1265ae: 85 c0 test %eax,%eax <== NOT EXECUTED 1265b0: 74 0c je 1265be <== NOT EXECUTED 1265b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1265b5: 8d 53 18 lea 0x18(%ebx),%edx <== NOT EXECUTED 1265b8: 52 push %edx <== NOT EXECUTED 1265b9: ff d0 call *%eax <== NOT EXECUTED 1265bb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free(env); 1265be: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 1265c1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1265c4: c9 leave <== NOT EXECUTED && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); rtems_filesystem_freenode( &env->root_directory); free(env); 1265c5: e9 a6 51 fe ff jmp 10b770 <== NOT EXECUTED } } 1265ca: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1265cd: c9 leave <== NOT EXECUTED 1265ce: c3 ret <== NOT EXECUTED 0011b570 : int fstat( int fd, struct stat *sbuf ) { 11b570: 55 push %ebp 11b571: 89 e5 mov %esp,%ebp 11b573: 57 push %edi 11b574: 53 push %ebx 11b575: 8b 55 08 mov 0x8(%ebp),%edx 11b578: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) 11b57b: 85 db test %ebx,%ebx 11b57d: 75 0d jne 11b58c rtems_set_errno_and_return_minus_one( EFAULT ); 11b57f: e8 30 4d ff ff call 1102b4 <__errno> 11b584: c7 00 0e 00 00 00 movl $0xe,(%eax) 11b58a: eb 5d jmp 11b5e9 /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); 11b58c: 3b 15 84 f9 11 00 cmp 0x11f984,%edx 11b592: 73 16 jae 11b5aa 11b594: c1 e2 06 shl $0x6,%edx 11b597: 03 15 58 38 12 00 add 0x123858,%edx rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); 11b59d: f6 42 15 01 testb $0x1,0x15(%edx) 11b5a1: 74 07 je 11b5aa if ( !iop->handlers ) 11b5a3: 8b 42 3c mov 0x3c(%edx),%eax 11b5a6: 85 c0 test %eax,%eax 11b5a8: 75 0d jne 11b5b7 rtems_set_errno_and_return_minus_one( EBADF ); 11b5aa: e8 05 4d ff ff call 1102b4 <__errno> 11b5af: c7 00 09 00 00 00 movl $0x9,(%eax) 11b5b5: eb 32 jmp 11b5e9 if ( !iop->handlers->fstat_h ) 11b5b7: 83 78 18 00 cmpl $0x0,0x18(%eax) 11b5bb: 75 0d jne 11b5ca rtems_set_errno_and_return_minus_one( ENOTSUP ); 11b5bd: e8 f2 4c ff ff call 1102b4 <__errno> <== NOT EXECUTED 11b5c2: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11b5c8: eb 1f jmp 11b5e9 <== NOT EXECUTED /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); 11b5ca: b9 12 00 00 00 mov $0x12,%ecx 11b5cf: 31 c0 xor %eax,%eax 11b5d1: 89 df mov %ebx,%edi 11b5d3: f3 ab rep stos %eax,%es:(%edi) return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf ); 11b5d5: 8b 42 3c mov 0x3c(%edx),%eax 11b5d8: 89 5d 0c mov %ebx,0xc(%ebp) 11b5db: 83 c2 18 add $0x18,%edx 11b5de: 89 55 08 mov %edx,0x8(%ebp) 11b5e1: 8b 40 18 mov 0x18(%eax),%eax } 11b5e4: 5b pop %ebx 11b5e5: 5f pop %edi 11b5e6: 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 ); 11b5e7: ff e0 jmp *%eax } 11b5e9: 83 c8 ff or $0xffffffff,%eax 11b5ec: 5b pop %ebx 11b5ed: 5f pop %edi 11b5ee: c9 leave 11b5ef: c3 ret 0012567c : #include int fsync( int fd ) { 12567c: 55 push %ebp 12567d: 89 e5 mov %esp,%ebp 12567f: 83 ec 08 sub $0x8,%esp 125682: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_t *iop; rtems_libio_check_fd( fd ); 125685: 3b 05 a4 c1 15 00 cmp 0x15c1a4,%eax 12568b: 73 2a jae 1256b7 iop = rtems_libio_iop( fd ); 12568d: c1 e0 06 shl $0x6,%eax 125690: 03 05 50 3a 16 00 add 0x163a50,%eax rtems_libio_check_is_open(iop); 125696: 8b 50 14 mov 0x14(%eax),%edx 125699: f6 c6 01 test $0x1,%dh 12569c: 74 19 je 1256b7 rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 12569e: 80 e2 04 and $0x4,%dl 1256a1: 75 0d jne 1256b0 1256a3: e8 d0 30 01 00 call 138778 <__errno> 1256a8: c7 00 16 00 00 00 movl $0x16,(%eax) 1256ae: eb 2e jmp 1256de /* * Now process the fsync(). */ if ( !iop->handlers ) 1256b0: 8b 50 3c mov 0x3c(%eax),%edx 1256b3: 85 d2 test %edx,%edx 1256b5: 75 0d jne 1256c4 rtems_set_errno_and_return_minus_one( EBADF ); 1256b7: e8 bc 30 01 00 call 138778 <__errno> <== NOT EXECUTED 1256bc: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 1256c2: eb 1a jmp 1256de <== NOT EXECUTED if ( !iop->handlers->fsync_h ) 1256c4: 8b 52 28 mov 0x28(%edx),%edx 1256c7: 85 d2 test %edx,%edx 1256c9: 75 0d jne 1256d8 rtems_set_errno_and_return_minus_one( ENOTSUP ); 1256cb: e8 a8 30 01 00 call 138778 <__errno> 1256d0: c7 00 86 00 00 00 movl $0x86,(%eax) 1256d6: eb 06 jmp 1256de return (*iop->handlers->fsync_h)( iop ); 1256d8: 89 45 08 mov %eax,0x8(%ebp) } 1256db: 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 ); 1256dc: ff e2 jmp *%edx } 1256de: 83 c8 ff or $0xffffffff,%eax 1256e1: c9 leave 1256e2: c3 ret 0010dba0 : int ftruncate( int fd, off_t length ) { 10dba0: 55 push %ebp 10dba1: 89 e5 mov %esp,%ebp 10dba3: 57 push %edi 10dba4: 56 push %esi 10dba5: 53 push %ebx 10dba6: 83 ec 3c sub $0x3c,%esp 10dba9: 8b 5d 08 mov 0x8(%ebp),%ebx 10dbac: 8b 45 0c mov 0xc(%ebp),%eax 10dbaf: 8b 55 10 mov 0x10(%ebp),%edx 10dbb2: 89 45 c0 mov %eax,-0x40(%ebp) 10dbb5: 89 55 c4 mov %edx,-0x3c(%ebp) rtems_libio_t *iop; rtems_filesystem_location_info_t loc; rtems_libio_check_fd( fd ); 10dbb8: 3b 1d 84 f9 11 00 cmp 0x11f984,%ebx 10dbbe: 73 0f jae 10dbcf iop = rtems_libio_iop( fd ); 10dbc0: c1 e3 06 shl $0x6,%ebx 10dbc3: 03 1d 58 38 12 00 add 0x123858,%ebx rtems_libio_check_is_open(iop); 10dbc9: f6 43 15 01 testb $0x1,0x15(%ebx) 10dbcd: 75 0d jne 10dbdc 10dbcf: e8 e0 26 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10dbd4: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10dbda: eb 5b jmp 10dc37 <== NOT EXECUTED /* * Make sure we are not working on a directory */ loc = iop->pathinfo; 10dbdc: 8d 7d d4 lea -0x2c(%ebp),%edi 10dbdf: 8d 73 18 lea 0x18(%ebx),%esi 10dbe2: b9 05 00 00 00 mov $0x5,%ecx 10dbe7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !loc.ops->node_type_h ) 10dbe9: 8b 45 e0 mov -0x20(%ebp),%eax 10dbec: 8b 40 10 mov 0x10(%eax),%eax 10dbef: 85 c0 test %eax,%eax 10dbf1: 74 39 je 10dc2c rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) 10dbf3: 83 ec 0c sub $0xc,%esp 10dbf6: 8d 55 d4 lea -0x2c(%ebp),%edx 10dbf9: 52 push %edx 10dbfa: ff d0 call *%eax 10dbfc: 83 c4 10 add $0x10,%esp 10dbff: 48 dec %eax 10dc00: 75 0d jne 10dc0f rtems_set_errno_and_return_minus_one( EISDIR ); 10dc02: e8 ad 26 00 00 call 1102b4 <__errno> 10dc07: c7 00 15 00 00 00 movl $0x15,(%eax) 10dc0d: eb 28 jmp 10dc37 rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 10dc0f: f6 43 14 04 testb $0x4,0x14(%ebx) 10dc13: 75 0d jne 10dc22 10dc15: e8 9a 26 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10dc1a: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10dc20: eb 15 jmp 10dc37 <== NOT EXECUTED if ( !iop->handlers->ftruncate_h ) 10dc22: 8b 43 3c mov 0x3c(%ebx),%eax 10dc25: 8b 40 20 mov 0x20(%eax),%eax 10dc28: 85 c0 test %eax,%eax 10dc2a: 75 10 jne 10dc3c rtems_set_errno_and_return_minus_one( ENOTSUP ); 10dc2c: e8 83 26 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10dc31: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10dc37: 83 c8 ff or $0xffffffff,%eax 10dc3a: eb 0d jmp 10dc49 return (*iop->handlers->ftruncate_h)( iop, length ); 10dc3c: 52 push %edx 10dc3d: ff 75 c4 pushl -0x3c(%ebp) 10dc40: ff 75 c0 pushl -0x40(%ebp) 10dc43: 53 push %ebx 10dc44: ff d0 call *%eax 10dc46: 83 c4 10 add $0x10,%esp } 10dc49: 8d 65 f4 lea -0xc(%ebp),%esp 10dc4c: 5b pop %ebx 10dc4d: 5e pop %esi 10dc4e: 5f pop %edi 10dc4f: c9 leave 10dc50: c3 ret 0014e5dc : int getdents( int dd_fd, char *dd_buf, int dd_len ) { 14e5dc: 55 push %ebp 14e5dd: 89 e5 mov %esp,%ebp 14e5df: 57 push %edi 14e5e0: 56 push %esi 14e5e1: 53 push %ebx 14e5e2: 83 ec 2c sub $0x2c,%esp 14e5e5: 8b 45 08 mov 0x8(%ebp),%eax /* * Get the file control block structure associated with the file descriptor */ iop = rtems_libio_iop( dd_fd ); 14e5e8: 31 db xor %ebx,%ebx 14e5ea: 3b 05 a4 c1 15 00 cmp 0x15c1a4,%eax 14e5f0: 73 0b jae 14e5fd 14e5f2: 89 c3 mov %eax,%ebx 14e5f4: c1 e3 06 shl $0x6,%ebx 14e5f7: 03 1d 50 3a 16 00 add 0x163a50,%ebx /* * Make sure we are working on a directory */ loc = iop->pathinfo; 14e5fd: 8d 7d d4 lea -0x2c(%ebp),%edi 14e600: 8d 73 18 lea 0x18(%ebx),%esi 14e603: b9 05 00 00 00 mov $0x5,%ecx 14e608: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !loc.ops->node_type_h ) 14e60a: 8b 45 e0 mov -0x20(%ebp),%eax 14e60d: 8b 40 10 mov 0x10(%eax),%eax 14e610: 85 c0 test %eax,%eax 14e612: 74 29 je 14e63d rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) 14e614: 83 ec 0c sub $0xc,%esp 14e617: 8d 55 d4 lea -0x2c(%ebp),%edx 14e61a: 52 push %edx 14e61b: ff d0 call *%eax 14e61d: 83 c4 10 add $0x10,%esp 14e620: 48 dec %eax 14e621: 74 10 je 14e633 rtems_set_errno_and_return_minus_one( ENOTDIR ); 14e623: e8 50 a1 fe ff call 138778 <__errno> 14e628: c7 00 14 00 00 00 movl $0x14,(%eax) 14e62e: 83 c8 ff or $0xffffffff,%eax 14e631: eb 24 jmp 14e657 /* * Return the number of bytes that were actually transfered as a result * of the read attempt. */ if ( !iop->handlers->read_h ) 14e633: 8b 43 3c mov 0x3c(%ebx),%eax 14e636: 8b 40 08 mov 0x8(%eax),%eax 14e639: 85 c0 test %eax,%eax 14e63b: 75 0d jne 14e64a rtems_set_errno_and_return_minus_one( ENOTSUP ); 14e63d: e8 36 a1 fe ff call 138778 <__errno> <== NOT EXECUTED 14e642: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 14e648: eb e4 jmp 14e62e <== NOT EXECUTED return (*iop->handlers->read_h)( iop, dd_buf, dd_len ); 14e64a: 52 push %edx 14e64b: ff 75 10 pushl 0x10(%ebp) 14e64e: ff 75 0c pushl 0xc(%ebp) 14e651: 53 push %ebx 14e652: ff d0 call *%eax 14e654: 83 c4 10 add $0x10,%esp } 14e657: 8d 65 f4 lea -0xc(%ebp),%esp 14e65a: 5b pop %ebx 14e65b: 5e pop %esi 14e65c: 5f pop %edi 14e65d: c9 leave 14e65e: c3 ret 001257b8 : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ gid_t getgid( void ) { 1257b8: 55 push %ebp <== NOT EXECUTED 1257b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1257bb: a1 dc e1 15 00 mov 0x15e1dc,%eax <== NOT EXECUTED 1257c0: 8b 40 34 mov 0x34(%eax),%eax <== NOT EXECUTED return _POSIX_types_Gid; } 1257c3: c9 leave <== NOT EXECUTED 1257c4: c3 ret <== NOT EXECUTED 00125cc2 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 125cc2: 55 push %ebp 125cc3: 89 e5 mov %esp,%ebp 125cc5: 57 push %edi 125cc6: 56 push %esi 125cc7: 53 push %ebx 125cc8: 83 ec 1c sub $0x1c,%esp 125ccb: 89 c7 mov %eax,%edi 125ccd: 89 55 e4 mov %edx,-0x1c(%ebp) 125cd0: 89 ce mov %ecx,%esi FILE *fp; int match; init_etc_passwd_group(); 125cd2: e8 df fe ff ff call 125bb6 if ((fp = fopen("/etc/group", "r")) == NULL) { 125cd7: 53 push %ebx 125cd8: 53 push %ebx 125cd9: 68 2b 1c 15 00 push $0x151c2b 125cde: 68 85 f2 14 00 push $0x14f285 125ce3: e8 f4 33 01 00 call 1390dc 125ce8: 89 c3 mov %eax,%ebx 125cea: 83 c4 10 add $0x10,%esp 125ced: 85 c0 test %eax,%eax 125cef: 75 10 jne 125d01 errno = EINVAL; 125cf1: e8 82 2a 01 00 call 138778 <__errno> <== NOT EXECUTED 125cf6: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 125cfc: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED return -1; 125cff: eb 6b jmp 125d6c <== NOT EXECUTED } for(;;) { if (!scangr(fp, grp, buffer, bufsize)) { 125d01: 83 ec 0c sub $0xc,%esp 125d04: ff 75 0c pushl 0xc(%ebp) 125d07: 8b 4d 08 mov 0x8(%ebp),%ecx 125d0a: 89 f2 mov %esi,%edx 125d0c: 89 d8 mov %ebx,%eax 125d0e: e8 39 fc ff ff call 12594c 125d13: 83 c4 10 add $0x10,%esp 125d16: 85 c0 test %eax,%eax 125d18: 75 19 jne 125d33 errno = EINVAL; 125d1a: e8 59 2a 01 00 call 138778 <__errno> <== NOT EXECUTED 125d1f: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED fclose(fp); 125d25: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125d28: 53 push %ebx <== NOT EXECUTED 125d29: e8 96 2b 01 00 call 1388c4 <== NOT EXECUTED 125d2e: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 125d31: eb 36 jmp 125d69 <== NOT EXECUTED return -1; } if (name) { 125d33: 85 ff test %edi,%edi 125d35: 74 11 je 125d48 match = (strcmp(grp->gr_name, name) == 0); 125d37: 51 push %ecx 125d38: 51 push %ecx 125d39: 57 push %edi 125d3a: ff 36 pushl (%esi) 125d3c: e8 fb 80 01 00 call 13de3c 125d41: 83 c4 10 add $0x10,%esp 125d44: 85 c0 test %eax,%eax 125d46: eb 07 jmp 125d4f } else { match = (grp->gr_gid == gid); 125d48: 0f b7 46 08 movzwl 0x8(%esi),%eax <== NOT EXECUTED 125d4c: 3b 45 e4 cmp -0x1c(%ebp),%eax <== NOT EXECUTED 125d4f: 0f 94 c0 sete %al 125d52: 0f b6 c0 movzbl %al,%eax } if (match) { 125d55: 85 c0 test %eax,%eax 125d57: 74 a8 je 125d01 fclose(fp); 125d59: 83 ec 0c sub $0xc,%esp 125d5c: 53 push %ebx 125d5d: e8 62 2b 01 00 call 1388c4 *result = grp; 125d62: 8b 45 10 mov 0x10(%ebp),%eax 125d65: 89 30 mov %esi,(%eax) 125d67: 31 c0 xor %eax,%eax return 0; 125d69: 83 c4 10 add $0x10,%esp } } fclose(fp); errno = EINVAL; return -1; } 125d6c: 8d 65 f4 lea -0xc(%ebp),%esp 125d6f: 5b pop %ebx 125d70: 5e pop %esi 125d71: 5f pop %edi 125d72: c9 leave 125d73: c3 ret 00125a4b : return NULL; return p; } struct group *getgrent(void) { 125a4b: 55 push %ebp <== NOT EXECUTED 125a4c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125a4e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (group_fp == NULL) 125a51: a1 8c 36 16 00 mov 0x16368c,%eax <== NOT EXECUTED 125a56: 85 c0 test %eax,%eax <== NOT EXECUTED 125a58: 74 25 je 125a7f <== NOT EXECUTED return NULL; if (!scangr(group_fp, &grent, grbuf, sizeof grbuf)) 125a5a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125a5d: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 125a62: b9 90 36 16 00 mov $0x163690,%ecx <== NOT EXECUTED 125a67: ba 58 37 16 00 mov $0x163758,%edx <== NOT EXECUTED 125a6c: e8 db fe ff ff call 12594c <== NOT EXECUTED 125a71: 89 c2 mov %eax,%edx <== NOT EXECUTED 125a73: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125a76: b8 58 37 16 00 mov $0x163758,%eax <== NOT EXECUTED 125a7b: 85 d2 test %edx,%edx <== NOT EXECUTED 125a7d: 75 02 jne 125a81 <== NOT EXECUTED 125a7f: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; return &grent; } 125a81: c9 leave <== NOT EXECUTED 125a82: c3 ret <== NOT EXECUTED 00125d9e : } struct group *getgrgid( gid_t gid ) { 125d9e: 55 push %ebp <== NOT EXECUTED 125d9f: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125da1: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct group *p; if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p)) 125da4: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 125da7: 50 push %eax <== NOT EXECUTED 125da8: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 125dad: 68 90 36 16 00 push $0x163690 <== NOT EXECUTED 125db2: 68 58 37 16 00 push $0x163758 <== NOT EXECUTED 125db7: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED 125dbb: 50 push %eax <== NOT EXECUTED 125dbc: e8 b3 ff ff ff call 125d74 <== NOT EXECUTED 125dc1: 89 c2 mov %eax,%edx <== NOT EXECUTED 125dc3: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 125dc6: 31 c0 xor %eax,%eax <== NOT EXECUTED 125dc8: 85 d2 test %edx,%edx <== NOT EXECUTED 125dca: 75 03 jne 125dcf <== NOT EXECUTED return NULL; return p; 125dcc: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED } 125dcf: c9 leave <== NOT EXECUTED 125dd0: c3 ret <== NOT EXECUTED 00125d74 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 125d74: 55 push %ebp <== NOT EXECUTED 125d75: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125d77: 53 push %ebx <== NOT EXECUTED 125d78: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 125d7b: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 125d7e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED return getgr_r(NULL, gid, grp, buffer, bufsize, result); 125d81: 0f b7 55 08 movzwl 0x8(%ebp),%edx <== NOT EXECUTED 125d85: 8b 5d 18 mov 0x18(%ebp),%ebx <== NOT EXECUTED 125d88: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 125d8b: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 125d8e: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 125d91: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 125d94: 31 c0 xor %eax,%eax <== NOT EXECUTED } 125d96: 5b pop %ebx <== NOT EXECUTED 125d97: 5b pop %ebx <== NOT EXECUTED 125d98: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct group **result ) { return getgr_r(NULL, gid, grp, buffer, bufsize, result); 125d99: e9 24 ff ff ff jmp 125cc2 <== NOT EXECUTED 001216f8 : * * 4.1.1 Get Process and Parent Process IDs, P1003.1b-1993, p. 83 */ pid_t getpid( void ) { 1216f8: 55 push %ebp <== NOT EXECUTED 1216f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_Local_node; } 1216fb: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 121700: c9 leave <== NOT EXECUTED 121701: c3 ret <== NOT EXECUTED 00125e66 : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 125e66: 55 push %ebp 125e67: 89 e5 mov %esp,%ebp 125e69: 57 push %edi 125e6a: 56 push %esi 125e6b: 53 push %ebx 125e6c: 83 ec 1c sub $0x1c,%esp 125e6f: 89 c7 mov %eax,%edi 125e71: 89 55 e4 mov %edx,-0x1c(%ebp) 125e74: 89 ce mov %ecx,%esi FILE *fp; int match; init_etc_passwd_group(); 125e76: e8 3b fd ff ff call 125bb6 if ((fp = fopen("/etc/passwd", "r")) == NULL) { 125e7b: 51 push %ecx 125e7c: 51 push %ecx 125e7d: 68 2b 1c 15 00 push $0x151c2b 125e82: 68 40 f2 14 00 push $0x14f240 125e87: e8 50 32 01 00 call 1390dc 125e8c: 89 c3 mov %eax,%ebx 125e8e: 83 c4 10 add $0x10,%esp 125e91: 85 c0 test %eax,%eax 125e93: 75 10 jne 125ea5 errno = EINVAL; 125e95: e8 de 28 01 00 call 138778 <__errno> <== NOT EXECUTED 125e9a: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 125ea0: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED return -1; 125ea3: eb 6b jmp 125f10 <== NOT EXECUTED } for(;;) { if (!scanpw(fp, pwd, buffer, bufsize)) { 125ea5: 83 ec 0c sub $0xc,%esp 125ea8: ff 75 0c pushl 0xc(%ebp) 125eab: 8b 4d 08 mov 0x8(%ebp),%ecx 125eae: 89 f2 mov %esi,%edx 125eb0: 89 d8 mov %ebx,%eax 125eb2: e8 cc fb ff ff call 125a83 125eb7: 83 c4 10 add $0x10,%esp 125eba: 85 c0 test %eax,%eax 125ebc: 75 19 jne 125ed7 errno = EINVAL; 125ebe: e8 b5 28 01 00 call 138778 <__errno> <== NOT EXECUTED 125ec3: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED fclose(fp); 125ec9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125ecc: 53 push %ebx <== NOT EXECUTED 125ecd: e8 f2 29 01 00 call 1388c4 <== NOT EXECUTED 125ed2: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 125ed5: eb 36 jmp 125f0d <== NOT EXECUTED return -1; } if (name) { 125ed7: 85 ff test %edi,%edi 125ed9: 74 11 je 125eec match = (strcmp(pwd->pw_name, name) == 0); 125edb: 52 push %edx 125edc: 52 push %edx 125edd: 57 push %edi 125ede: ff 36 pushl (%esi) 125ee0: e8 57 7f 01 00 call 13de3c 125ee5: 83 c4 10 add $0x10,%esp 125ee8: 85 c0 test %eax,%eax 125eea: eb 07 jmp 125ef3 } else { match = (pwd->pw_uid == uid); 125eec: 0f b7 46 08 movzwl 0x8(%esi),%eax <== NOT EXECUTED 125ef0: 3b 45 e4 cmp -0x1c(%ebp),%eax <== NOT EXECUTED 125ef3: 0f 94 c0 sete %al 125ef6: 0f b6 c0 movzbl %al,%eax } if (match) { 125ef9: 85 c0 test %eax,%eax 125efb: 74 a8 je 125ea5 fclose(fp); 125efd: 83 ec 0c sub $0xc,%esp 125f00: 53 push %ebx 125f01: e8 be 29 01 00 call 1388c4 *result = pwd; 125f06: 8b 45 10 mov 0x10(%ebp),%eax 125f09: 89 30 mov %esi,(%eax) 125f0b: 31 c0 xor %eax,%eax return 0; 125f0d: 83 c4 10 add $0x10,%esp } } fclose(fp); errno = EINVAL; return -1; } 125f10: 8d 65 f4 lea -0xc(%ebp),%esp 125f13: 5b pop %ebx 125f14: 5e pop %esi 125f15: 5f pop %edi 125f16: c9 leave 125f17: c3 ret 00125b7e : return NULL; return p; } struct passwd *getpwent(void) { 125b7e: 55 push %ebp <== NOT EXECUTED 125b7f: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125b81: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (passwd_fp == NULL) 125b84: a1 a4 35 16 00 mov 0x1635a4,%eax <== NOT EXECUTED 125b89: 85 c0 test %eax,%eax <== NOT EXECUTED 125b8b: 74 25 je 125bb2 <== NOT EXECUTED return NULL; if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf)) 125b8d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125b90: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 125b95: b9 a8 35 16 00 mov $0x1635a8,%ecx <== NOT EXECUTED 125b9a: ba 70 36 16 00 mov $0x163670,%edx <== NOT EXECUTED 125b9f: e8 df fe ff ff call 125a83 <== NOT EXECUTED 125ba4: 89 c2 mov %eax,%edx <== NOT EXECUTED 125ba6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125ba9: b8 70 36 16 00 mov $0x163670,%eax <== NOT EXECUTED 125bae: 85 d2 test %edx,%edx <== NOT EXECUTED 125bb0: 75 02 jne 125bb4 <== NOT EXECUTED 125bb2: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; return &pwent; } 125bb4: c9 leave <== NOT EXECUTED 125bb5: c3 ret <== NOT EXECUTED 00125f42 : } struct passwd *getpwuid( uid_t uid ) { 125f42: 55 push %ebp <== NOT EXECUTED 125f43: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125f45: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct passwd *p; if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p)) 125f48: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 125f4b: 50 push %eax <== NOT EXECUTED 125f4c: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 125f51: 68 a8 35 16 00 push $0x1635a8 <== NOT EXECUTED 125f56: 68 70 36 16 00 push $0x163670 <== NOT EXECUTED 125f5b: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED 125f5f: 50 push %eax <== NOT EXECUTED 125f60: e8 b3 ff ff ff call 125f18 <== NOT EXECUTED 125f65: 89 c2 mov %eax,%edx <== NOT EXECUTED 125f67: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 125f6a: 31 c0 xor %eax,%eax <== NOT EXECUTED 125f6c: 85 d2 test %edx,%edx <== NOT EXECUTED 125f6e: 75 03 jne 125f73 <== NOT EXECUTED return NULL; return p; 125f70: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED } 125f73: c9 leave <== NOT EXECUTED 125f74: c3 ret <== NOT EXECUTED 00125f18 : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 125f18: 55 push %ebp <== NOT EXECUTED 125f19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125f1b: 53 push %ebx <== NOT EXECUTED 125f1c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 125f1f: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 125f22: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED return getpw_r(NULL, uid, pwd, buffer, bufsize, result); 125f25: 0f b7 55 08 movzwl 0x8(%ebp),%edx <== NOT EXECUTED 125f29: 8b 5d 18 mov 0x18(%ebp),%ebx <== NOT EXECUTED 125f2c: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 125f2f: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 125f32: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 125f35: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 125f38: 31 c0 xor %eax,%eax <== NOT EXECUTED } 125f3a: 5b pop %ebx <== NOT EXECUTED 125f3b: 5b pop %ebx <== NOT EXECUTED 125f3c: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct passwd **result ) { return getpw_r(NULL, uid, pwd, buffer, bufsize, result); 125f3d: e9 24 ff ff ff jmp 125e66 <== NOT EXECUTED 0010dc54 : */ int gettimeofday( struct timeval *tp, void * __tz __attribute__((unused)) ) { 10dc54: 55 push %ebp 10dc55: 89 e5 mov %esp,%ebp 10dc57: 56 push %esi 10dc58: 53 push %ebx 10dc59: 83 ec 10 sub $0x10,%esp 10dc5c: 8b 5d 08 mov 0x8(%ebp),%ebx /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) { 10dc5f: 85 db test %ebx,%ebx 10dc61: 75 10 jne 10dc73 errno = EFAULT; 10dc63: e8 4c 26 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10dc68: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 10dc6e: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED return -1; 10dc71: eb 29 jmp 10dc9c <== NOT EXECUTED { ISR_Level level; struct timespec now; suseconds_t useconds; _ISR_Disable(level); 10dc73: 9c pushf 10dc74: fa cli 10dc75: 5e pop %esi _TOD_Get( &now ); 10dc76: 83 ec 0c sub $0xc,%esp 10dc79: 8d 45 f0 lea -0x10(%ebp),%eax 10dc7c: 50 push %eax 10dc7d: e8 0e 08 00 00 call 10e490 <_TOD_Get> _ISR_Enable(level); 10dc82: 56 push %esi 10dc83: 9d popf useconds = (suseconds_t)now.tv_nsec; 10dc84: 8b 45 f4 mov -0xc(%ebp),%eax useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND; time->tv_sec = now.tv_sec; 10dc87: 8b 55 f0 mov -0x10(%ebp),%edx 10dc8a: 89 13 mov %edx,(%ebx) time->tv_usec = useconds; 10dc8c: b9 e8 03 00 00 mov $0x3e8,%ecx 10dc91: 99 cltd 10dc92: f7 f9 idiv %ecx 10dc94: 89 43 04 mov %eax,0x4(%ebx) 10dc97: 31 c0 xor %eax,%eax * Timezone information ignored by the OS proper. Per email * with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X * do it. This puts us in good company. */ return 0; 10dc99: 83 c4 10 add $0x10,%esp } 10dc9c: 8d 65 f8 lea -0x8(%ebp),%esp 10dc9f: 5b pop %ebx 10dca0: 5e pop %esi 10dca1: c9 leave 10dca2: c3 ret 0010b85c : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ uid_t getuid( void ) { 10b85c: 55 push %ebp <== NOT EXECUTED 10b85d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b85f: a1 dc e1 15 00 mov 0x15e1dc,%eax <== NOT EXECUTED 10b864: 66 8b 40 32 mov 0x32(%eax),%ax <== NOT EXECUTED return _POSIX_types_Uid; } 10b868: c9 leave <== NOT EXECUTED 10b869: c3 ret <== NOT EXECUTED 001143cc : int imfs_dir_rmnod( rtems_filesystem_location_info_t *parent_pathloc, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN */ ) { 1143cc: 55 push %ebp 1143cd: 89 e5 mov %esp,%ebp 1143cf: 56 push %esi 1143d0: 53 push %ebx 1143d1: 83 ec 10 sub $0x10,%esp 1143d4: 8b 75 0c mov 0xc(%ebp),%esi IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 1143d7: 8b 1e mov (%esi),%ebx 1143d9: 8d 43 54 lea 0x54(%ebx),%eax 1143dc: 39 43 50 cmp %eax,0x50(%ebx) 1143df: 74 0d je 1143ee /* * You cannot remove a node that still has children */ if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) ) rtems_set_errno_and_return_minus_one( ENOTEMPTY ); 1143e1: e8 a2 05 00 00 call 114988 <__errno> 1143e6: c7 00 5a 00 00 00 movl $0x5a,(%eax) 1143ec: eb 19 jmp 114407 /* * You cannot remove the file system root node. */ if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access ) 1143ee: 8b 46 10 mov 0x10(%esi),%eax 1143f1: 39 58 1c cmp %ebx,0x1c(%eax) 1143f4: 74 06 je 1143fc /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) 1143f6: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx) 1143fa: 74 10 je 11440c rtems_set_errno_and_return_minus_one( EBUSY ); 1143fc: e8 87 05 00 00 call 114988 <__errno> 114401: c7 00 10 00 00 00 movl $0x10,(%eax) 114407: 83 c8 ff or $0xffffffff,%eax 11440a: eb 6b jmp 114477 /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 11440c: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 114410: 74 13 je 114425 114412: 83 ec 0c sub $0xc,%esp 114415: 53 push %ebx 114416: e8 85 79 ff ff call 10bda0 <_Chain_Extract> rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 11441b: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 114422: 83 c4 10 add $0x10,%esp /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 114425: 66 ff 4b 34 decw 0x34(%ebx) IMFS_update_ctime( the_jnode ); 114429: 50 push %eax 11442a: 50 push %eax 11442b: 6a 00 push $0x0 11442d: 8d 45 f0 lea -0x10(%ebp),%eax 114430: 50 push %eax 114431: e8 2e 3f ff ff call 108364 114436: 8b 45 f0 mov -0x10(%ebp),%eax 114439: 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) ) { 11443c: 89 1c 24 mov %ebx,(%esp) 11443f: e8 26 da ff ff call 111e6a 114444: 83 c4 10 add $0x10,%esp 114447: 85 c0 test %eax,%eax 114449: 75 2a jne 114475 11444b: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) 114450: 75 23 jne 114475 /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 114452: a1 14 62 12 00 mov 0x126214,%eax 114457: 8b 50 04 mov 0x4(%eax),%edx 11445a: 3b 16 cmp (%esi),%edx 11445c: 75 07 jne 114465 rtems_filesystem_current.node_access = NULL; 11445e: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED /* * Free memory associated with a memory file. */ free( the_jnode ); 114465: 83 ec 0c sub $0xc,%esp 114468: 53 push %ebx 114469: e8 7e 3e ff ff call 1082ec 11446e: 31 c0 xor %eax,%eax 114470: 83 c4 10 add $0x10,%esp 114473: eb 02 jmp 114477 114475: 31 c0 xor %eax,%eax } return 0; } 114477: 8d 65 f8 lea -0x8(%ebp),%esp 11447a: 5b pop %ebx 11447b: 5e pop %esi 11447c: c9 leave 11447d: c3 ret 00125bb6 : /* * Initialize useable but dummy databases */ void init_etc_passwd_group(void) { 125bb6: 55 push %ebp 125bb7: 89 e5 mov %esp,%ebp 125bb9: 53 push %ebx 125bba: 83 ec 04 sub $0x4,%esp FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) 125bbd: 80 3d a0 35 16 00 00 cmpb $0x0,0x1635a0 125bc4: 0f 85 b8 00 00 00 jne 125c82 return; etc_passwd_initted = 1; 125bca: c6 05 a0 35 16 00 01 movb $0x1,0x1635a0 mkdir("/etc", 0777); 125bd1: 50 push %eax 125bd2: 50 push %eax 125bd3: 68 ff 01 00 00 push $0x1ff 125bd8: 68 26 f1 14 00 push $0x14f126 125bdd: e8 c2 61 fe ff call 10bda4 /* * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { 125be2: 59 pop %ecx 125be3: 5b pop %ebx 125be4: 68 2b 1c 15 00 push $0x151c2b 125be9: 68 40 f2 14 00 push $0x14f240 125bee: e8 e9 34 01 00 call 1390dc 125bf3: 83 c4 10 add $0x10,%esp 125bf6: 85 c0 test %eax,%eax 125bf8: 74 06 je 125c00 fclose(fp); 125bfa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125bfd: 50 push %eax <== NOT EXECUTED 125bfe: eb 2a jmp 125c2a <== NOT EXECUTED } else if ((fp = fopen("/etc/passwd", "w")) != NULL) { 125c00: 52 push %edx 125c01: 52 push %edx 125c02: 68 9c 18 15 00 push $0x15189c 125c07: 68 40 f2 14 00 push $0x14f240 125c0c: e8 cb 34 01 00 call 1390dc 125c11: 89 c3 mov %eax,%ebx 125c13: 83 c4 10 add $0x10,%esp 125c16: 85 c0 test %eax,%eax 125c18: 74 18 je 125c32 fprintf(fp, "root:*:0:0:root::/:/bin/sh\n" 125c1a: 50 push %eax 125c1b: 50 push %eax 125c1c: 53 push %ebx 125c1d: 68 08 51 15 00 push $0x155108 125c22: e8 f9 35 01 00 call 139220 "rtems:*:1:1:RTEMS Application::/:/bin/sh\n" "tty:!:2:2:tty owner::/:/bin/false\n" ); fclose(fp); 125c27: 89 1c 24 mov %ebx,(%esp) 125c2a: e8 95 2c 01 00 call 1388c4 125c2f: 83 c4 10 add $0x10,%esp } /* * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { 125c32: 51 push %ecx 125c33: 51 push %ecx 125c34: 68 2b 1c 15 00 push $0x151c2b 125c39: 68 85 f2 14 00 push $0x14f285 125c3e: e8 99 34 01 00 call 1390dc 125c43: 83 c4 10 add $0x10,%esp 125c46: 85 c0 test %eax,%eax 125c48: 74 06 je 125c50 fclose(fp); 125c4a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125c4d: 50 push %eax <== NOT EXECUTED 125c4e: eb 2a jmp 125c7a <== NOT EXECUTED } else if ((fp = fopen("/etc/group", "w")) != NULL) { 125c50: 52 push %edx 125c51: 52 push %edx 125c52: 68 9c 18 15 00 push $0x15189c 125c57: 68 85 f2 14 00 push $0x14f285 125c5c: e8 7b 34 01 00 call 1390dc 125c61: 89 c3 mov %eax,%ebx 125c63: 83 c4 10 add $0x10,%esp 125c66: 85 c0 test %eax,%eax 125c68: 74 18 je 125c82 fprintf( fp, "root:x:0:root\n" 125c6a: 50 push %eax 125c6b: 50 push %eax 125c6c: 53 push %ebx 125c6d: 68 6f 51 15 00 push $0x15516f 125c72: e8 a9 35 01 00 call 139220 "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); 125c77: 89 1c 24 mov %ebx,(%esp) 125c7a: e8 45 2c 01 00 call 1388c4 125c7f: 83 c4 10 add $0x10,%esp } } 125c82: 8b 5d fc mov -0x4(%ebp),%ebx 125c85: c9 leave 125c86: c3 ret 0010a224 : int ioctl( int fd, ioctl_command_t command, ... ) { 10a224: 55 push %ebp 10a225: 89 e5 mov %esp,%ebp 10a227: 83 ec 08 sub $0x8,%esp 10a22a: 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 ); 10a22d: 3b 05 a4 46 12 00 cmp 0x1246a4,%eax 10a233: 73 19 jae 10a24e iop = rtems_libio_iop( fd ); 10a235: c1 e0 06 shl $0x6,%eax 10a238: 03 05 50 86 12 00 add 0x128650,%eax rtems_libio_check_is_open(iop); 10a23e: f6 40 15 01 testb $0x1,0x15(%eax) 10a242: 74 0a je 10a24e va_start(ap, command); buffer = va_arg(ap, void *); 10a244: 8b 4d 10 mov 0x10(%ebp),%ecx /* * Now process the ioctl(). */ if ( !iop->handlers ) 10a247: 8b 50 3c mov 0x3c(%eax),%edx 10a24a: 85 d2 test %edx,%edx 10a24c: 75 0d jne 10a25b rtems_set_errno_and_return_minus_one( EBADF ); 10a24e: e8 4d a9 00 00 call 114ba0 <__errno> 10a253: c7 00 09 00 00 00 movl $0x9,(%eax) 10a259: eb 12 jmp 10a26d if ( !iop->handlers->ioctl_h ) 10a25b: 8b 52 10 mov 0x10(%edx),%edx 10a25e: 85 d2 test %edx,%edx 10a260: 75 10 jne 10a272 rtems_set_errno_and_return_minus_one( ENOTSUP ); 10a262: e8 39 a9 00 00 call 114ba0 <__errno> <== NOT EXECUTED 10a267: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10a26d: 83 c8 ff or $0xffffffff,%eax 10a270: eb 0d jmp 10a27f rc = (*iop->handlers->ioctl_h)( iop, command, buffer ); 10a272: 83 ec 04 sub $0x4,%esp 10a275: 51 push %ecx 10a276: ff 75 0c pushl 0xc(%ebp) 10a279: 50 push %eax 10a27a: ff d2 call *%edx return rc; 10a27c: 83 c4 10 add $0x10,%esp } 10a27f: c9 leave 10a280: c3 ret 001087c0 : /* * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) { 1087c0: 55 push %ebp <== NOT EXECUTED 1087c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1087c3: 53 push %ebx <== NOT EXECUTED 1087c4: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 1087c7: 89 d3 mov %edx,%ebx <== NOT EXECUTED 1087c9: 88 c1 mov %al,%cl <== NOT EXECUTED if (tty->termios.c_iflag & ISTRIP) 1087cb: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 1087ce: a8 20 test $0x20,%al <== NOT EXECUTED 1087d0: 74 03 je 1087d5 <== NOT EXECUTED c &= 0x7f; 1087d2: 83 e1 7f and $0x7f,%ecx <== NOT EXECUTED if (tty->termios.c_iflag & IUCLC) 1087d5: f6 c4 02 test $0x2,%ah <== NOT EXECUTED 1087d8: 74 17 je 1087f1 <== NOT EXECUTED c = tolower (c); 1087da: 0f b6 c9 movzbl %cl,%ecx <== NOT EXECUTED 1087dd: 8b 15 04 18 12 00 mov 0x121804,%edx <== NOT EXECUTED 1087e3: 0f be 54 0a 01 movsbl 0x1(%edx,%ecx,1),%edx <== NOT EXECUTED 1087e8: 83 e2 03 and $0x3,%edx <== NOT EXECUTED 1087eb: 4a dec %edx <== NOT EXECUTED 1087ec: 75 03 jne 1087f1 <== NOT EXECUTED 1087ee: 83 c1 20 add $0x20,%ecx <== NOT EXECUTED if (c == '\r') { 1087f1: 80 f9 0d cmp $0xd,%cl <== NOT EXECUTED 1087f4: 75 11 jne 108807 <== NOT EXECUTED if (tty->termios.c_iflag & IGNCR) 1087f6: 84 c0 test %al,%al <== NOT EXECUTED 1087f8: 0f 88 d3 00 00 00 js 1088d1 <== NOT EXECUTED return 0; if (tty->termios.c_iflag & ICRNL) 1087fe: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 108801: 74 19 je 10881c <== NOT EXECUTED 108803: b1 0a mov $0xa,%cl <== NOT EXECUTED 108805: eb 15 jmp 10881c <== NOT EXECUTED c = '\n'; } else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) { 108807: 80 f9 0a cmp $0xa,%cl <== NOT EXECUTED 10880a: 75 08 jne 108814 <== NOT EXECUTED 10880c: a8 40 test $0x40,%al <== NOT EXECUTED 10880e: 74 0c je 10881c <== NOT EXECUTED 108810: b1 0d mov $0xd,%cl <== NOT EXECUTED 108812: eb 08 jmp 10881c <== NOT EXECUTED c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 108814: 84 c9 test %cl,%cl <== NOT EXECUTED 108816: 0f 84 87 00 00 00 je 1088a3 <== NOT EXECUTED 10881c: 8b 53 3c mov 0x3c(%ebx),%edx <== NOT EXECUTED 10881f: f6 c2 02 test $0x2,%dl <== NOT EXECUTED 108822: 74 7f je 1088a3 <== NOT EXECUTED if (c == tty->termios.c_cc[VERASE]) { 108824: 3a 4b 43 cmp 0x43(%ebx),%cl <== NOT EXECUTED 108827: 75 04 jne 10882d <== NOT EXECUTED erase (tty, 0); 108829: 31 d2 xor %edx,%edx <== NOT EXECUTED 10882b: eb 0a jmp 108837 <== NOT EXECUTED return 0; } else if (c == tty->termios.c_cc[VKILL]) { 10882d: 3a 4b 44 cmp 0x44(%ebx),%cl <== NOT EXECUTED 108830: 75 11 jne 108843 <== NOT EXECUTED erase (tty, 1); 108832: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 108837: 89 d8 mov %ebx,%eax <== NOT EXECUTED 108839: e8 09 fe ff ff call 108647 <== NOT EXECUTED 10883e: e9 8e 00 00 00 jmp 1088d1 <== NOT EXECUTED return 0; } else if (c == tty->termios.c_cc[VEOF]) { 108843: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 108848: 3a 4b 45 cmp 0x45(%ebx),%cl <== NOT EXECUTED 10884b: 0f 84 82 00 00 00 je 1088d3 <== NOT EXECUTED return 1; } else if (c == '\n') { 108851: 80 f9 0a cmp $0xa,%cl <== NOT EXECUTED 108854: 75 1a jne 108870 <== NOT EXECUTED if (tty->termios.c_lflag & (ECHO | ECHONL)) 108856: 80 e2 48 and $0x48,%dl <== NOT EXECUTED 108859: 74 09 je 108864 <== NOT EXECUTED echo (c, tty); 10885b: 89 da mov %ebx,%edx <== NOT EXECUTED 10885d: b0 0a mov $0xa,%al <== NOT EXECUTED 10885f: e8 8b fd ff ff call 1085ef <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 108864: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 108867: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED 10886a: c6 04 02 0a movb $0xa,(%edx,%eax,1) <== NOT EXECUTED 10886e: eb 28 jmp 108898 <== NOT EXECUTED return 1; } else if ((c == tty->termios.c_cc[VEOL]) 108870: 3a 4b 4c cmp 0x4c(%ebx),%cl <== NOT EXECUTED 108873: 74 05 je 10887a <== NOT EXECUTED || (c == tty->termios.c_cc[VEOL2])) { 108875: 3a 4b 51 cmp 0x51(%ebx),%cl <== NOT EXECUTED 108878: 75 29 jne 1088a3 <== NOT EXECUTED if (tty->termios.c_lflag & ECHO) 10887a: 80 e2 08 and $0x8,%dl <== NOT EXECUTED 10887d: 74 10 je 10888f <== NOT EXECUTED echo (c, tty); 10887f: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 108882: 89 da mov %ebx,%edx <== NOT EXECUTED 108884: 88 4d f4 mov %cl,-0xc(%ebp) <== NOT EXECUTED 108887: e8 63 fd ff ff call 1085ef <== NOT EXECUTED 10888c: 8a 4d f4 mov -0xc(%ebp),%cl <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 10888f: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 108892: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED 108895: 88 0c 02 mov %cl,(%edx,%eax,1) <== NOT EXECUTED 108898: 40 inc %eax <== NOT EXECUTED 108899: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED 10889c: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED return 1; 1088a1: eb 30 jmp 1088d3 <== NOT EXECUTED } /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { 1088a3: a1 78 17 12 00 mov 0x121778,%eax <== NOT EXECUTED 1088a8: 48 dec %eax <== NOT EXECUTED 1088a9: 39 43 20 cmp %eax,0x20(%ebx) <== NOT EXECUTED 1088ac: 7d 23 jge 1088d1 <== NOT EXECUTED if (tty->termios.c_lflag & ECHO) 1088ae: f6 43 3c 08 testb $0x8,0x3c(%ebx) <== NOT EXECUTED 1088b2: 74 10 je 1088c4 <== NOT EXECUTED echo (c, tty); 1088b4: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 1088b7: 89 da mov %ebx,%edx <== NOT EXECUTED 1088b9: 88 4d f4 mov %cl,-0xc(%ebp) <== NOT EXECUTED 1088bc: e8 2e fd ff ff call 1085ef <== NOT EXECUTED 1088c1: 8a 4d f4 mov -0xc(%ebp),%cl <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 1088c4: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 1088c7: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED 1088ca: 88 0c 02 mov %cl,(%edx,%eax,1) <== NOT EXECUTED 1088cd: 40 inc %eax <== NOT EXECUTED 1088ce: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED 1088d1: 31 c0 xor %eax,%eax <== NOT EXECUTED } return 0; } 1088d3: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 1088d6: 5b pop %ebx <== NOT EXECUTED 1088d7: c9 leave <== NOT EXECUTED 1088d8: c3 ret <== NOT EXECUTED 00121720 : * These are directly supported (and completely correct) in the posix api. */ #if !defined(RTEMS_POSIX_API) int kill( pid_t pid, int sig ) { 121720: 55 push %ebp <== NOT EXECUTED 121721: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 121723: 31 c0 xor %eax,%eax <== NOT EXECUTED 121725: c9 leave <== NOT EXECUTED 121726: c3 ret <== NOT EXECUTED 00126030 : int link( const char *existing, const char *new ) { 126030: 55 push %ebp 126031: 89 e5 mov %esp,%ebp 126033: 57 push %edi 126034: 56 push %esi 126035: 53 push %ebx 126036: 83 ec 48 sub $0x48,%esp 126039: 8b 55 08 mov 0x8(%ebp),%edx 12603c: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Get the node we are linking to. */ result = rtems_filesystem_evaluate_path( existing, strlen( existing ), 12603f: 31 c0 xor %eax,%eax 126041: 83 c9 ff or $0xffffffff,%ecx 126044: 89 d7 mov %edx,%edi 126046: f2 ae repnz scas %es:(%edi),%al 126048: f7 d1 not %ecx 12604a: 49 dec %ecx 12604b: 6a 01 push $0x1 12604d: 8d 45 d0 lea -0x30(%ebp),%eax 126050: 50 push %eax 126051: 6a 00 push $0x0 126053: 51 push %ecx 126054: 52 push %edx 126055: e8 6e 56 fe ff call 10b6c8 0, &existing_loc, true ); if ( result != 0 ) 12605a: 83 c4 20 add $0x20,%esp 12605d: 83 ce ff or $0xffffffff,%esi 126060: 85 c0 test %eax,%eax 126062: 0f 85 80 01 00 00 jne 1261e8 /* * Get the parent of the node we are creating. */ rtems_filesystem_get_start_loc( new, &i, &parent_loc ); 126068: 8a 03 mov (%ebx),%al 12606a: 3c 5c cmp $0x5c,%al 12606c: 74 08 je 126076 12606e: 3c 2f cmp $0x2f,%al 126070: 74 04 je 126076 126072: 84 c0 test %al,%al 126074: 75 1a jne 126090 126076: 8d 7d bc lea -0x44(%ebp),%edi 126079: 8b 35 dc e1 15 00 mov 0x15e1dc,%esi 12607f: 83 c6 18 add $0x18,%esi 126082: b9 05 00 00 00 mov $0x5,%ecx 126087: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 126089: ba 01 00 00 00 mov $0x1,%edx 12608e: eb 15 jmp 1260a5 126090: 8d 7d bc lea -0x44(%ebp),%edi 126093: 8b 35 dc e1 15 00 mov 0x15e1dc,%esi 126099: 83 c6 04 add $0x4,%esi 12609c: b9 05 00 00 00 mov $0x5,%ecx 1260a1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 1260a3: 31 d2 xor %edx,%edx if ( !parent_loc.ops->evalformake_h ) { 1260a5: 8b 45 c8 mov -0x38(%ebp),%eax 1260a8: 8b 40 04 mov 0x4(%eax),%eax 1260ab: 85 c0 test %eax,%eax 1260ad: 75 21 jne 1260d0 rtems_filesystem_freenode( &existing_loc ); 1260af: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 1260b2: 85 c0 test %eax,%eax <== NOT EXECUTED 1260b4: 0f 84 dd 00 00 00 je 126197 <== NOT EXECUTED 1260ba: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1260bd: 85 c0 test %eax,%eax <== NOT EXECUTED 1260bf: 0f 84 d2 00 00 00 je 126197 <== NOT EXECUTED 1260c5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1260c8: 8d 55 d0 lea -0x30(%ebp),%edx <== NOT EXECUTED 1260cb: e9 c1 00 00 00 jmp 126191 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start ); 1260d0: 51 push %ecx 1260d1: 8d 4d e4 lea -0x1c(%ebp),%ecx 1260d4: 51 push %ecx 1260d5: 8d 75 bc lea -0x44(%ebp),%esi 1260d8: 56 push %esi 1260d9: 01 d3 add %edx,%ebx 1260db: 53 push %ebx 1260dc: ff d0 call *%eax 1260de: 89 c3 mov %eax,%ebx if ( result != 0 ) { 1260e0: 83 c4 10 add $0x10,%esp 1260e3: 85 c0 test %eax,%eax 1260e5: 74 29 je 126110 rtems_filesystem_freenode( &existing_loc ); 1260e7: 8b 45 dc mov -0x24(%ebp),%eax 1260ea: 85 c0 test %eax,%eax 1260ec: 74 13 je 126101 1260ee: 8b 40 1c mov 0x1c(%eax),%eax 1260f1: 85 c0 test %eax,%eax 1260f3: 74 0c je 126101 1260f5: 83 ec 0c sub $0xc,%esp 1260f8: 8d 55 d0 lea -0x30(%ebp),%edx 1260fb: 52 push %edx 1260fc: ff d0 call *%eax 1260fe: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( result ); 126101: e8 72 26 01 00 call 138778 <__errno> 126106: 89 18 mov %ebx,(%eax) 126108: 83 ce ff or $0xffffffff,%esi 12610b: e9 d8 00 00 00 jmp 1261e8 /* * Check to see if the caller is trying to link across file system * boundaries. */ if ( parent_loc.mt_entry != existing_loc.mt_entry ) { 126110: 8b 45 cc mov -0x34(%ebp),%eax 126113: 3b 45 e0 cmp -0x20(%ebp),%eax 126116: 74 41 je 126159 rtems_filesystem_freenode( &existing_loc ); 126118: 8b 45 dc mov -0x24(%ebp),%eax 12611b: 85 c0 test %eax,%eax 12611d: 74 13 je 126132 12611f: 8b 40 1c mov 0x1c(%eax),%eax 126122: 85 c0 test %eax,%eax 126124: 74 0c je 126132 126126: 83 ec 0c sub $0xc,%esp 126129: 8d 55 d0 lea -0x30(%ebp),%edx 12612c: 52 push %edx 12612d: ff d0 call *%eax 12612f: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &parent_loc ); 126132: 8b 45 c8 mov -0x38(%ebp),%eax 126135: 85 c0 test %eax,%eax 126137: 74 13 je 12614c 126139: 8b 40 1c mov 0x1c(%eax),%eax 12613c: 85 c0 test %eax,%eax 12613e: 74 0c je 12614c 126140: 83 ec 0c sub $0xc,%esp 126143: 8d 55 bc lea -0x44(%ebp),%edx 126146: 52 push %edx 126147: ff d0 call *%eax 126149: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EXDEV ); 12614c: e8 27 26 01 00 call 138778 <__errno> 126151: c7 00 12 00 00 00 movl $0x12,(%eax) 126157: eb af jmp 126108 } if ( !parent_loc.ops->link_h ) { 126159: 8b 45 c8 mov -0x38(%ebp),%eax 12615c: 8b 40 08 mov 0x8(%eax),%eax 12615f: 85 c0 test %eax,%eax 126161: 75 44 jne 1261a7 rtems_filesystem_freenode( &existing_loc ); 126163: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 126166: 85 c0 test %eax,%eax <== NOT EXECUTED 126168: 74 13 je 12617d <== NOT EXECUTED 12616a: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12616d: 85 c0 test %eax,%eax <== NOT EXECUTED 12616f: 74 0c je 12617d <== NOT EXECUTED 126171: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 126174: 8d 55 d0 lea -0x30(%ebp),%edx <== NOT EXECUTED 126177: 52 push %edx <== NOT EXECUTED 126178: ff d0 call *%eax <== NOT EXECUTED 12617a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); 12617d: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 126180: 85 c0 test %eax,%eax <== NOT EXECUTED 126182: 74 13 je 126197 <== NOT EXECUTED 126184: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 126187: 85 c0 test %eax,%eax <== NOT EXECUTED 126189: 74 0c je 126197 <== NOT EXECUTED 12618b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12618e: 8d 55 bc lea -0x44(%ebp),%edx <== NOT EXECUTED 126191: 52 push %edx <== NOT EXECUTED 126192: ff d0 call *%eax <== NOT EXECUTED 126194: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 126197: e8 dc 25 01 00 call 138778 <__errno> <== NOT EXECUTED 12619c: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1261a2: e9 61 ff ff ff jmp 126108 <== NOT EXECUTED } result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start ); 1261a7: 52 push %edx 1261a8: ff 75 e4 pushl -0x1c(%ebp) 1261ab: 56 push %esi 1261ac: 8d 5d d0 lea -0x30(%ebp),%ebx 1261af: 53 push %ebx 1261b0: ff d0 call *%eax 1261b2: 89 c6 mov %eax,%esi rtems_filesystem_freenode( &existing_loc ); 1261b4: 8b 45 dc mov -0x24(%ebp),%eax 1261b7: 83 c4 10 add $0x10,%esp 1261ba: 85 c0 test %eax,%eax 1261bc: 74 10 je 1261ce 1261be: 8b 40 1c mov 0x1c(%eax),%eax 1261c1: 85 c0 test %eax,%eax 1261c3: 74 09 je 1261ce 1261c5: 83 ec 0c sub $0xc,%esp 1261c8: 53 push %ebx 1261c9: ff d0 call *%eax 1261cb: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &parent_loc ); 1261ce: 8b 45 c8 mov -0x38(%ebp),%eax 1261d1: 85 c0 test %eax,%eax 1261d3: 74 13 je 1261e8 1261d5: 8b 40 1c mov 0x1c(%eax),%eax 1261d8: 85 c0 test %eax,%eax 1261da: 74 0c je 1261e8 1261dc: 83 ec 0c sub $0xc,%esp 1261df: 8d 55 bc lea -0x44(%ebp),%edx 1261e2: 52 push %edx 1261e3: ff d0 call *%eax 1261e5: 83 c4 10 add $0x10,%esp return result; } 1261e8: 89 f0 mov %esi,%eax 1261ea: 8d 65 f4 lea -0xc(%ebp),%esp 1261ed: 5b pop %ebx 1261ee: 5e pop %esi 1261ef: 5f pop %edi 1261f0: c9 leave 1261f1: c3 ret 0011b61c : off_t lseek( int fd, off_t offset, int whence ) { 11b61c: 55 push %ebp 11b61d: 89 e5 mov %esp,%ebp 11b61f: 57 push %edi 11b620: 56 push %esi 11b621: 53 push %ebx 11b622: 83 ec 1c sub $0x1c,%esp 11b625: 8b 5d 08 mov 0x8(%ebp),%ebx 11b628: 8b 45 0c mov 0xc(%ebp),%eax 11b62b: 8b 55 10 mov 0x10(%ebp),%edx 11b62e: 8b 4d 14 mov 0x14(%ebp),%ecx rtems_libio_t *iop; off_t old_offset; off_t status; rtems_libio_check_fd( fd ); 11b631: 3b 1d 84 f9 11 00 cmp 0x11f984,%ebx 11b637: 73 0f jae 11b648 iop = rtems_libio_iop( fd ); 11b639: c1 e3 06 shl $0x6,%ebx 11b63c: 03 1d 58 38 12 00 add 0x123858,%ebx rtems_libio_check_is_open(iop); 11b642: f6 43 15 01 testb $0x1,0x15(%ebx) 11b646: 75 0d jne 11b655 11b648: e8 67 4c ff ff call 1102b4 <__errno> 11b64d: c7 00 09 00 00 00 movl $0x9,(%eax) 11b653: eb 61 jmp 11b6b6 /* * Check as many errors as possible before touching iop->offset. */ if ( !iop->handlers->lseek_h ) 11b655: 8b 73 3c mov 0x3c(%ebx),%esi 11b658: 83 7e 14 00 cmpl $0x0,0x14(%esi) 11b65c: 75 0d jne 11b66b rtems_set_errno_and_return_minus_one( ENOTSUP ); 11b65e: e8 51 4c ff ff call 1102b4 <__errno> <== NOT EXECUTED 11b663: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11b669: eb 4b jmp 11b6b6 <== NOT EXECUTED /* * Now process the lseek(). */ old_offset = iop->offset; 11b66b: 8b 73 0c mov 0xc(%ebx),%esi 11b66e: 8b 7b 10 mov 0x10(%ebx),%edi 11b671: 89 75 e0 mov %esi,-0x20(%ebp) 11b674: 89 7d e4 mov %edi,-0x1c(%ebp) switch ( whence ) { 11b677: 83 f9 01 cmp $0x1,%ecx 11b67a: 74 11 je 11b68d 11b67c: 83 f9 02 cmp $0x2,%ecx 11b67f: 74 18 je 11b699 11b681: 85 c9 test %ecx,%ecx 11b683: 75 26 jne 11b6ab case SEEK_SET: iop->offset = offset; 11b685: 89 43 0c mov %eax,0xc(%ebx) 11b688: 89 53 10 mov %edx,0x10(%ebx) break; 11b68b: eb 30 jmp 11b6bd case SEEK_CUR: iop->offset += offset; 11b68d: 8b 75 e0 mov -0x20(%ebp),%esi 11b690: 8b 7d e4 mov -0x1c(%ebp),%edi 11b693: 01 c6 add %eax,%esi 11b695: 11 d7 adc %edx,%edi 11b697: eb 0a jmp 11b6a3 break; case SEEK_END: iop->offset = iop->size + offset; 11b699: 89 c6 mov %eax,%esi 11b69b: 89 d7 mov %edx,%edi 11b69d: 03 73 04 add 0x4(%ebx),%esi 11b6a0: 13 7b 08 adc 0x8(%ebx),%edi 11b6a3: 89 73 0c mov %esi,0xc(%ebx) 11b6a6: 89 7b 10 mov %edi,0x10(%ebx) break; 11b6a9: eb 12 jmp 11b6bd default: rtems_set_errno_and_return_minus_one( EINVAL ); 11b6ab: e8 04 4c ff ff call 1102b4 <__errno> 11b6b0: c7 00 16 00 00 00 movl $0x16,(%eax) 11b6b6: 83 c8 ff or $0xffffffff,%eax 11b6b9: 89 c2 mov %eax,%edx 11b6bb: eb 23 jmp 11b6e0 /* * At this time, handlers assume iop->offset has the desired * new offset. */ status = (*iop->handlers->lseek_h)( iop, offset, whence ); 11b6bd: 8b 73 3c mov 0x3c(%ebx),%esi 11b6c0: 51 push %ecx 11b6c1: 52 push %edx 11b6c2: 50 push %eax 11b6c3: 53 push %ebx 11b6c4: ff 56 14 call *0x14(%esi) if ( status == (off_t) -1 ) 11b6c7: 83 c4 10 add $0x10,%esp 11b6ca: 83 fa ff cmp $0xffffffff,%edx 11b6cd: 75 11 jne 11b6e0 11b6cf: 83 f8 ff cmp $0xffffffff,%eax 11b6d2: 75 0c jne 11b6e0 iop->offset = old_offset; 11b6d4: 8b 75 e0 mov -0x20(%ebp),%esi 11b6d7: 8b 7d e4 mov -0x1c(%ebp),%edi 11b6da: 89 73 0c mov %esi,0xc(%ebx) 11b6dd: 89 7b 10 mov %edi,0x10(%ebx) /* * So if the operation failed, we have to restore iop->offset. */ return status; } 11b6e0: 8d 65 f4 lea -0xc(%ebp),%esp 11b6e3: 5b pop %ebx 11b6e4: 5e pop %esi 11b6e5: 5f pop %edi 11b6e6: c9 leave 11b6e7: c3 ret 00126300 : int _STAT_NAME( const char *path, struct stat *buf ) { 126300: 55 push %ebp <== NOT EXECUTED 126301: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126303: 57 push %edi <== NOT EXECUTED 126304: 56 push %esi <== NOT EXECUTED 126305: 53 push %ebx <== NOT EXECUTED 126306: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 126309: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 12630c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !buf ) 12630f: 85 f6 test %esi,%esi <== NOT EXECUTED 126311: 75 0d jne 126320 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); 126313: e8 60 24 01 00 call 138778 <__errno> <== NOT EXECUTED 126318: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 12631e: eb 53 jmp 126373 <== NOT EXECUTED status = rtems_filesystem_evaluate_path( path, strlen( path ), 126320: 31 c0 xor %eax,%eax <== NOT EXECUTED 126322: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 126325: 89 d7 mov %edx,%edi <== NOT EXECUTED 126327: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 126329: f7 d1 not %ecx <== NOT EXECUTED 12632b: 49 dec %ecx <== NOT EXECUTED 12632c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12632f: 6a 00 push $0x0 <== NOT EXECUTED 126331: 8d 5d d4 lea -0x2c(%ebp),%ebx <== NOT EXECUTED 126334: 53 push %ebx <== NOT EXECUTED 126335: 6a 00 push $0x0 <== NOT EXECUTED 126337: 51 push %ecx <== NOT EXECUTED 126338: 52 push %edx <== NOT EXECUTED 126339: e8 8a 53 fe ff call 10b6c8 <== NOT EXECUTED 0, &loc, _STAT_FOLLOW_LINKS ); if ( status != 0 ) 12633e: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 126341: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED 126344: 85 c0 test %eax,%eax <== NOT EXECUTED 126346: 75 5c jne 1263a4 <== NOT EXECUTED return -1; if ( !loc.handlers->fstat_h ){ 126348: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 12634b: 83 7a 18 00 cmpl $0x0,0x18(%edx) <== NOT EXECUTED 12634f: 75 27 jne 126378 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 126351: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 126354: 85 c0 test %eax,%eax <== NOT EXECUTED 126356: 74 10 je 126368 <== NOT EXECUTED 126358: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12635b: 85 c0 test %eax,%eax <== NOT EXECUTED 12635d: 74 09 je 126368 <== NOT EXECUTED 12635f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 126362: 53 push %ebx <== NOT EXECUTED 126363: ff d0 call *%eax <== NOT EXECUTED 126365: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 126368: e8 0b 24 01 00 call 138778 <__errno> <== NOT EXECUTED 12636d: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 126373: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED 126376: eb 2c jmp 1263a4 <== NOT EXECUTED /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( buf, 0, sizeof(struct stat) ); 126378: b9 12 00 00 00 mov $0x12,%ecx <== NOT EXECUTED 12637d: 89 f7 mov %esi,%edi <== NOT EXECUTED 12637f: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED status = (*loc.handlers->fstat_h)( &loc, buf ); 126381: 50 push %eax <== NOT EXECUTED 126382: 50 push %eax <== NOT EXECUTED 126383: 56 push %esi <== NOT EXECUTED 126384: 53 push %ebx <== NOT EXECUTED 126385: ff 52 18 call *0x18(%edx) <== NOT EXECUTED 126388: 89 c7 mov %eax,%edi <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 12638a: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 12638d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126390: 85 c0 test %eax,%eax <== NOT EXECUTED 126392: 74 10 je 1263a4 <== NOT EXECUTED 126394: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 126397: 85 c0 test %eax,%eax <== NOT EXECUTED 126399: 74 09 je 1263a4 <== NOT EXECUTED 12639b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12639e: 53 push %ebx <== NOT EXECUTED 12639f: ff d0 call *%eax <== NOT EXECUTED 1263a1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return status; } 1263a4: 89 f8 mov %edi,%eax <== NOT EXECUTED 1263a6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1263a9: 5b pop %ebx <== NOT EXECUTED 1263aa: 5e pop %esi <== NOT EXECUTED 1263ab: 5f pop %edi <== NOT EXECUTED 1263ac: c9 leave <== NOT EXECUTED 1263ad: c3 ret <== NOT EXECUTED 001073ac : size_t size ) { void *return_this; MSBUMP(malloc_calls, 1); 1073ac: 55 push %ebp 1073ad: 89 e5 mov %esp,%ebp 1073af: 57 push %edi 1073b0: 56 push %esi 1073b1: 53 push %ebx 1073b2: 83 ec 0c sub $0xc,%esp 1073b5: 8b 75 08 mov 0x8(%ebp),%esi 1073b8: ff 05 74 38 12 00 incl 0x123874 /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 1073be: e8 17 ff ff ff call 1072da /* * Validate the parameters */ if ( !size ) 1073c3: 85 f6 test %esi,%esi 1073c5: 74 7c je 107443 return (void *) 0; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 1073c7: 83 3d 4c 3b 12 00 03 cmpl $0x3,0x123b4c 1073ce: 75 09 jne 1073d9 1073d0: e8 af fe ff ff call 107284 1073d5: 84 c0 test %al,%al 1073d7: 74 6a je 107443 RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate( Heap_Control *heap, uintptr_t size ) { return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 ); 1073d9: 6a 00 push $0x0 1073db: 6a 00 push $0x0 1073dd: 56 push %esi 1073de: ff 35 90 f9 11 00 pushl 0x11f990 1073e4: e8 1b 42 00 00 call 10b604 <_Protected_heap_Allocate_aligned_with_boundary> 1073e9: 89 c3 mov %eax,%ebx * If this fails then return a NULL pointer. */ return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); if ( !return_this ) { 1073eb: 83 c4 10 add $0x10,%esp if (rtems_malloc_sbrk_helpers) return_this = (*rtems_malloc_sbrk_helpers->extend)( size ); if ( !return_this ) { errno = ENOMEM; return (void *) 0; 1073ee: 89 c7 mov %eax,%edi * If this fails then return a NULL pointer. */ return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size ); if ( !return_this ) { 1073f0: 85 c0 test %eax,%eax 1073f2: 75 26 jne 10741a if (rtems_malloc_sbrk_helpers) 1073f4: a1 14 1d 12 00 mov 0x121d14,%eax 1073f9: 85 c0 test %eax,%eax 1073fb: 74 10 je 10740d return_this = (*rtems_malloc_sbrk_helpers->extend)( size ); 1073fd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107400: 56 push %esi <== NOT EXECUTED 107401: ff 50 04 call *0x4(%eax) <== NOT EXECUTED 107404: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( !return_this ) { 107406: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107409: 85 c0 test %eax,%eax <== NOT EXECUTED 10740b: 75 0d jne 10741a <== NOT EXECUTED errno = ENOMEM; 10740d: e8 a2 8e 00 00 call 1102b4 <__errno> 107412: c7 00 0c 00 00 00 movl $0xc,(%eax) return (void *) 0; 107418: eb 2b jmp 107445 } /* * If the user wants us to dirty the allocated memory, then do it. */ if ( rtems_malloc_dirty_helper ) 10741a: a1 18 1d 12 00 mov 0x121d18,%eax 10741f: 85 c0 test %eax,%eax 107421: 74 09 je 10742c (*rtems_malloc_dirty_helper)( return_this, size ); 107423: 52 push %edx <== NOT EXECUTED 107424: 52 push %edx <== NOT EXECUTED 107425: 56 push %esi <== NOT EXECUTED 107426: 57 push %edi <== NOT EXECUTED 107427: ff 10 call *(%eax) <== NOT EXECUTED 107429: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 10742c: a1 10 1d 12 00 mov 0x121d10,%eax 107431: 89 fb mov %edi,%ebx 107433: 85 c0 test %eax,%eax 107435: 74 0e je 107445 (*rtems_malloc_statistics_helpers->at_malloc)(return_this); 107437: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10743a: 57 push %edi <== NOT EXECUTED 10743b: ff 50 04 call *0x4(%eax) <== NOT EXECUTED 10743e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107441: eb 02 jmp 107445 <== NOT EXECUTED 107443: 31 db xor %ebx,%ebx <== NOT EXECUTED if (rtems_malloc_boundary_helpers) (*rtems_malloc_boundary_helpers->at_malloc)(return_this, size); #endif return return_this; } 107445: 89 d8 mov %ebx,%eax 107447: 8d 65 f4 lea -0xc(%ebp),%esp 10744a: 5b pop %ebx 10744b: 5e pop %esi 10744c: 5f pop %edi 10744d: c9 leave 10744e: c3 ret 001072c2 : } void malloc_deferred_free( void *pointer ) { 1072c2: 55 push %ebp <== NOT EXECUTED 1072c3: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1072c5: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED RTEMS_INLINE_ROUTINE void rtems_chain_append( rtems_chain_control *the_chain, rtems_chain_node *the_node ) { _Chain_Append( the_chain, the_node ); 1072c8: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1072cb: 68 64 38 12 00 push $0x123864 <== NOT EXECUTED 1072d0: e8 bb 34 00 00 call 10a790 <_Chain_Append> <== NOT EXECUTED 1072d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_chain_append(&RTEMS_Malloc_GC_list, (rtems_chain_node *)pointer); } 1072d8: c9 leave <== NOT EXECUTED 1072d9: c3 ret <== NOT EXECUTED 001072da : { rtems_chain_initialize_empty(&RTEMS_Malloc_GC_list); } void malloc_deferred_frees_process(void) { 1072da: 55 push %ebp 1072db: 89 e5 mov %esp,%ebp 1072dd: 83 ec 08 sub $0x8,%esp 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) 1072e0: eb 0c jmp 1072ee free(to_be_freed); 1072e2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1072e5: 50 push %eax <== NOT EXECUTED 1072e6: e8 95 fe ff ff call 107180 <== NOT EXECUTED 1072eb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get( rtems_chain_control *the_chain ) { return _Chain_Get( the_chain ); 1072ee: 83 ec 0c sub $0xc,%esp 1072f1: 68 64 38 12 00 push $0x123864 1072f6: e8 b9 34 00 00 call 10a7b4 <_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) 1072fb: 83 c4 10 add $0x10,%esp 1072fe: 85 c0 test %eax,%eax 107300: 75 e0 jne 1072e2 free(to_be_freed); } 107302: c9 leave 107303: c3 ret 00113774 : return memfile_check_rmnod( the_jnode ); } int memfile_check_rmnod( IMFS_jnode_t *the_jnode ){ 113774: 55 push %ebp 113775: 89 e5 mov %esp,%ebp 113777: 53 push %ebx 113778: 83 ec 10 sub $0x10,%esp 11377b: 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) ) { 11377e: 53 push %ebx 11377f: e8 e6 e6 ff ff call 111e6a 113784: 83 c4 10 add $0x10,%esp 113787: 85 c0 test %eax,%eax 113789: 75 36 jne 1137c1 11378b: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) 113790: 75 2f jne 1137c1 /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == the_jnode ) 113792: a1 14 62 12 00 mov 0x126214,%eax 113797: 39 58 04 cmp %ebx,0x4(%eax) 11379a: 75 07 jne 1137a3 rtems_filesystem_current.node_access = NULL; 11379c: 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) 1137a3: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) 1137a7: 74 0c je 1137b5 IMFS_memfile_remove( the_jnode ); 1137a9: 83 ec 0c sub $0xc,%esp 1137ac: 53 push %ebx 1137ad: e8 98 fe ff ff call 11364a 1137b2: 83 c4 10 add $0x10,%esp free( the_jnode ); 1137b5: 83 ec 0c sub $0xc,%esp 1137b8: 53 push %ebx 1137b9: e8 2e 4b ff ff call 1082ec 1137be: 83 c4 10 add $0x10,%esp } return 0; } 1137c1: 31 c0 xor %eax,%eax 1137c3: 8b 5d fc mov -0x4(%ebp),%ebx 1137c6: c9 leave 1137c7: c3 ret 00113595 : void memfile_free_blocks_in_table( block_p **block_table, int entries ) { 113595: 55 push %ebp 113596: 89 e5 mov %esp,%ebp 113598: 57 push %edi 113599: 56 push %esi 11359a: 53 push %ebx 11359b: 83 ec 0c sub $0xc,%esp 11359e: 8b 75 08 mov 0x8(%ebp),%esi /* * Perform internal consistency checks */ assert( block_table ); 1135a1: 85 f6 test %esi,%esi 1135a3: 75 19 jne 1135be 1135a5: 68 ec 24 12 00 push $0x1224ec <== NOT EXECUTED 1135aa: 68 e0 25 12 00 push $0x1225e0 <== NOT EXECUTED 1135af: 68 b3 01 00 00 push $0x1b3 <== NOT EXECUTED 1135b4: 68 82 24 12 00 push $0x122482 <== NOT EXECUTED 1135b9: e8 02 4a ff ff call 107fc0 <__assert_func> <== NOT EXECUTED /* * Now go through all the slots in the table and free the memory. */ b = *block_table; 1135be: 8b 3e mov (%esi),%edi 1135c0: 31 db xor %ebx,%ebx for ( i=0 ; i if ( b[i] ) { 1135c4: 8b 04 9f mov (%edi,%ebx,4),%eax 1135c7: 85 c0 test %eax,%eax 1135c9: 74 13 je 1135de memfile_free_block( b[i] ); 1135cb: 83 ec 0c sub $0xc,%esp 1135ce: 50 push %eax 1135cf: e8 ff fd ff ff call 1133d3 b[i] = 0; 1135d4: c7 04 9f 00 00 00 00 movl $0x0,(%edi,%ebx,4) 1135db: 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 ); 1135e4: 83 ec 0c sub $0xc,%esp 1135e7: ff 36 pushl (%esi) 1135e9: e8 e5 fd ff ff call 1133d3 *block_table = 0; 1135ee: c7 06 00 00 00 00 movl $0x0,(%esi) 1135f4: 83 c4 10 add $0x10,%esp } 1135f7: 8d 65 f4 lea -0xc(%ebp),%esp 1135fa: 5b pop %ebx 1135fb: 5e pop %esi 1135fc: 5f pop %edi 1135fd: c9 leave 1135fe: c3 ret 001139d5 : int memfile_ftruncate( rtems_libio_t *iop, rtems_off64_t length ) { 1139d5: 55 push %ebp 1139d6: 89 e5 mov %esp,%ebp 1139d8: 53 push %ebx 1139d9: 83 ec 14 sub $0x14,%esp 1139dc: 8b 4d 08 mov 0x8(%ebp),%ecx 1139df: 8b 45 0c mov 0xc(%ebp),%eax 1139e2: 8b 55 10 mov 0x10(%ebp),%edx IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 1139e5: 8b 59 38 mov 0x38(%ecx),%ebx * POSIX 1003.1b does not specify what happens if you truncate a file * and the new length is greater than the current size. We treat this * as an extend operation. */ if ( length > the_jnode->info.file.size ) 1139e8: 3b 53 54 cmp 0x54(%ebx),%edx 1139eb: 7c 12 jl 1139ff 1139ed: 7f 05 jg 1139f4 1139ef: 3b 43 50 cmp 0x50(%ebx),%eax 1139f2: 76 0b jbe 1139ff return IMFS_memfile_extend( the_jnode, length ); 1139f4: 51 push %ecx <== NOT EXECUTED 1139f5: 52 push %edx <== NOT EXECUTED 1139f6: 50 push %eax <== NOT EXECUTED 1139f7: 53 push %ebx <== NOT EXECUTED 1139f8: e8 b2 fe ff ff call 1138af <== NOT EXECUTED 1139fd: eb 21 jmp 113a20 <== 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; 1139ff: 89 43 50 mov %eax,0x50(%ebx) 113a02: 89 53 54 mov %edx,0x54(%ebx) iop->size = the_jnode->info.file.size; 113a05: 89 41 04 mov %eax,0x4(%ecx) 113a08: 89 51 08 mov %edx,0x8(%ecx) IMFS_update_atime( the_jnode ); 113a0b: 52 push %edx 113a0c: 52 push %edx 113a0d: 6a 00 push $0x0 113a0f: 8d 45 f0 lea -0x10(%ebp),%eax 113a12: 50 push %eax 113a13: e8 4c 49 ff ff call 108364 113a18: 8b 45 f0 mov -0x10(%ebp),%eax 113a1b: 89 43 40 mov %eax,0x40(%ebx) 113a1e: 31 c0 xor %eax,%eax return 0; 113a20: 83 c4 10 add $0x10,%esp } 113a23: 8b 5d fc mov -0x4(%ebp),%ebx 113a26: c9 leave 113a27: c3 ret 00113a28 : rtems_off64_t memfile_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) { 113a28: 55 push %ebp 113a29: 89 e5 mov %esp,%ebp 113a2b: 56 push %esi 113a2c: 53 push %ebx 113a2d: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 113a30: 8b 73 38 mov 0x38(%ebx),%esi if (the_jnode->type == IMFS_LINEAR_FILE) { 113a33: 83 7e 4c 06 cmpl $0x6,0x4c(%esi) 113a37: 75 1a jne 113a53 if (iop->offset > the_jnode->info.linearfile.size) 113a39: 8b 56 50 mov 0x50(%esi),%edx <== NOT EXECUTED 113a3c: 8b 46 54 mov 0x54(%esi),%eax <== NOT EXECUTED 113a3f: 39 43 10 cmp %eax,0x10(%ebx) <== NOT EXECUTED 113a42: 7c 41 jl 113a85 <== NOT EXECUTED 113a44: 7f 05 jg 113a4b <== NOT EXECUTED 113a46: 39 53 0c cmp %edx,0xc(%ebx) <== NOT EXECUTED 113a49: 76 3a jbe 113a85 <== NOT EXECUTED iop->offset = the_jnode->info.linearfile.size; 113a4b: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED 113a4e: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED 113a51: eb 32 jmp 113a85 <== NOT EXECUTED } else { /* Must be a block file (IMFS_MEMORY_FILE). */ if (IMFS_memfile_extend( the_jnode, iop->offset )) 113a53: 50 push %eax 113a54: ff 73 10 pushl 0x10(%ebx) 113a57: ff 73 0c pushl 0xc(%ebx) 113a5a: 56 push %esi 113a5b: e8 4f fe ff ff call 1138af 113a60: 83 c4 10 add $0x10,%esp 113a63: 85 c0 test %eax,%eax 113a65: 74 12 je 113a79 rtems_set_errno_and_return_minus_one( ENOSPC ); 113a67: e8 1c 0f 00 00 call 114988 <__errno> <== NOT EXECUTED 113a6c: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 113a72: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 113a75: 89 c2 mov %eax,%edx <== NOT EXECUTED 113a77: eb 12 jmp 113a8b <== NOT EXECUTED iop->size = the_jnode->info.file.size; 113a79: 8b 46 50 mov 0x50(%esi),%eax 113a7c: 8b 56 54 mov 0x54(%esi),%edx 113a7f: 89 43 04 mov %eax,0x4(%ebx) 113a82: 89 53 08 mov %edx,0x8(%ebx) } return iop->offset; 113a85: 8b 43 0c mov 0xc(%ebx),%eax 113a88: 8b 53 10 mov 0x10(%ebx),%edx } 113a8b: 8d 65 f8 lea -0x8(%ebp),%esp 113a8e: 5b pop %ebx 113a8f: 5e pop %esi 113a90: c9 leave 113a91: c3 ret 00113cb7 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 113cb7: 55 push %ebp 113cb8: 89 e5 mov %esp,%ebp 113cba: 56 push %esi 113cbb: 53 push %ebx 113cbc: 8b 75 08 mov 0x8(%ebp),%esi IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 113cbf: 8b 5e 38 mov 0x38(%esi),%ebx /* * Perform 'copy on write' for linear files */ if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND)) 113cc2: f7 46 14 04 02 00 00 testl $0x204,0x14(%esi) 113cc9: 74 54 je 113d1f && (the_jnode->type == IMFS_LINEAR_FILE)) { 113ccb: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) 113ccf: 75 4e jne 113d1f uint32_t count = the_jnode->info.linearfile.size; 113cd1: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED const unsigned char *buffer = the_jnode->info.linearfile.direct; 113cd4: 8b 53 58 mov 0x58(%ebx),%edx <== NOT EXECUTED the_jnode->type = IMFS_MEMORY_FILE; 113cd7: c7 43 4c 05 00 00 00 movl $0x5,0x4c(%ebx) <== NOT EXECUTED the_jnode->info.file.size = 0; 113cde: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED 113ce5: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED the_jnode->info.file.indirect = 0; 113cec: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED the_jnode->info.file.doubly_indirect = 0; 113cf3: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED the_jnode->info.file.triply_indirect = 0; 113cfa: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED if ((count != 0) 113d01: 85 c0 test %eax,%eax <== NOT EXECUTED 113d03: 74 1a je 113d1f <== NOT EXECUTED && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) 113d05: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113d08: 50 push %eax <== NOT EXECUTED 113d09: 52 push %edx <== NOT EXECUTED 113d0a: 6a 00 push $0x0 <== NOT EXECUTED 113d0c: 6a 00 push $0x0 <== NOT EXECUTED 113d0e: 53 push %ebx <== NOT EXECUTED 113d0f: e8 7e fd ff ff call 113a92 <== NOT EXECUTED 113d14: 89 c2 mov %eax,%edx <== NOT EXECUTED the_jnode->type = IMFS_MEMORY_FILE; the_jnode->info.file.size = 0; the_jnode->info.file.indirect = 0; the_jnode->info.file.doubly_indirect = 0; the_jnode->info.file.triply_indirect = 0; if ((count != 0) 113d16: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 113d19: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 113d1c: 42 inc %edx <== NOT EXECUTED 113d1d: 74 20 je 113d3f <== NOT EXECUTED && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) return -1; } if (iop->flags & LIBIO_FLAGS_APPEND) 113d1f: f6 46 15 02 testb $0x2,0x15(%esi) 113d23: 74 0c je 113d31 iop->offset = the_jnode->info.file.size; 113d25: 8b 43 50 mov 0x50(%ebx),%eax 113d28: 8b 53 54 mov 0x54(%ebx),%edx 113d2b: 89 46 0c mov %eax,0xc(%esi) 113d2e: 89 56 10 mov %edx,0x10(%esi) iop->size = the_jnode->info.file.size; 113d31: 8b 43 50 mov 0x50(%ebx),%eax 113d34: 8b 53 54 mov 0x54(%ebx),%edx 113d37: 89 46 04 mov %eax,0x4(%esi) 113d3a: 89 56 08 mov %edx,0x8(%esi) 113d3d: 31 c0 xor %eax,%eax return 0; } 113d3f: 8d 65 f8 lea -0x8(%ebp),%esp 113d42: 5b pop %ebx 113d43: 5e pop %esi 113d44: c9 leave 113d45: c3 ret 0010746c : int mknod( const char *pathname, mode_t mode, dev_t dev ) { 10746c: 55 push %ebp 10746d: 89 e5 mov %esp,%ebp 10746f: 57 push %edi 107470: 56 push %esi 107471: 53 push %ebx 107472: 83 ec 3c sub $0x3c,%esp 107475: 8b 45 08 mov 0x8(%ebp),%eax 107478: 8b 5d 0c mov 0xc(%ebp),%ebx 10747b: 8b 55 10 mov 0x10(%ebp),%edx 10747e: 8b 4d 14 mov 0x14(%ebp),%ecx 107481: 89 55 c0 mov %edx,-0x40(%ebp) 107484: 89 4d c4 mov %ecx,-0x3c(%ebp) rtems_filesystem_location_info_t temp_loc; int i; const char *name_start; int result; if ( !(mode & (S_IFREG|S_IFCHR|S_IFBLK|S_IFIFO) ) ) 107487: 66 f7 c3 00 f0 test $0xf000,%bx 10748c: 75 0d jne 10749b rtems_set_errno_and_return_minus_one( EINVAL ); 10748e: e8 21 8e 00 00 call 1102b4 <__errno> <== NOT EXECUTED 107493: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 107499: eb 4f jmp 1074ea <== NOT EXECUTED rtems_filesystem_get_start_loc( pathname, &i, &temp_loc ); 10749b: 8a 10 mov (%eax),%dl 10749d: 80 fa 5c cmp $0x5c,%dl 1074a0: 74 09 je 1074ab 1074a2: 80 fa 2f cmp $0x2f,%dl 1074a5: 74 04 je 1074ab 1074a7: 84 d2 test %dl,%dl 1074a9: 75 17 jne 1074c2 1074ab: 8d 7d d0 lea -0x30(%ebp),%edi 1074ae: 8b 35 88 17 12 00 mov 0x121788,%esi 1074b4: 83 c6 18 add $0x18,%esi 1074b7: b9 05 00 00 00 mov $0x5,%ecx 1074bc: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 1074be: b1 01 mov $0x1,%cl 1074c0: eb 13 jmp 1074d5 1074c2: 8d 7d d0 lea -0x30(%ebp),%edi 1074c5: 8b 35 88 17 12 00 mov 0x121788,%esi 1074cb: 83 c6 04 add $0x4,%esi 1074ce: b9 05 00 00 00 mov $0x5,%ecx 1074d3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !temp_loc.ops->evalformake_h ) { 1074d5: 8b 55 dc mov -0x24(%ebp),%edx 1074d8: 8b 52 04 mov 0x4(%edx),%edx 1074db: 85 d2 test %edx,%edx 1074dd: 75 10 jne 1074ef rtems_set_errno_and_return_minus_one( ENOTSUP ); 1074df: e8 d0 8d 00 00 call 1102b4 <__errno> <== NOT EXECUTED 1074e4: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1074ea: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED 1074ed: eb 60 jmp 10754f <== NOT EXECUTED } result = (*temp_loc.ops->evalformake_h)( 1074ef: 56 push %esi 1074f0: 8d 75 e4 lea -0x1c(%ebp),%esi 1074f3: 56 push %esi 1074f4: 8d 75 d0 lea -0x30(%ebp),%esi 1074f7: 56 push %esi 1074f8: 01 c8 add %ecx,%eax 1074fa: 50 push %eax 1074fb: ff d2 call *%edx &pathname[i], &temp_loc, &name_start ); if ( result != 0 ) 1074fd: 83 c4 10 add $0x10,%esp 107500: 83 cf ff or $0xffffffff,%edi 107503: 85 c0 test %eax,%eax 107505: 75 48 jne 10754f return -1; if ( !temp_loc.ops->mknod_h ) { 107507: 8b 55 dc mov -0x24(%ebp),%edx 10750a: 8b 42 14 mov 0x14(%edx),%eax 10750d: 85 c0 test %eax,%eax 10750f: 75 12 jne 107523 rtems_filesystem_freenode( &temp_loc ); 107511: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 107514: 85 c0 test %eax,%eax <== NOT EXECUTED 107516: 74 c7 je 1074df <== NOT EXECUTED 107518: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10751b: 56 push %esi <== NOT EXECUTED 10751c: ff d0 call *%eax <== NOT EXECUTED 10751e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107521: eb bc jmp 1074df <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc ); 107523: 83 ec 0c sub $0xc,%esp 107526: 56 push %esi 107527: ff 75 c4 pushl -0x3c(%ebp) 10752a: ff 75 c0 pushl -0x40(%ebp) 10752d: 53 push %ebx 10752e: ff 75 e4 pushl -0x1c(%ebp) 107531: ff d0 call *%eax 107533: 89 c7 mov %eax,%edi rtems_filesystem_freenode( &temp_loc ); 107535: 8b 45 dc mov -0x24(%ebp),%eax 107538: 83 c4 20 add $0x20,%esp 10753b: 85 c0 test %eax,%eax 10753d: 74 10 je 10754f 10753f: 8b 40 1c mov 0x1c(%eax),%eax 107542: 85 c0 test %eax,%eax 107544: 74 09 je 10754f 107546: 83 ec 0c sub $0xc,%esp 107549: 56 push %esi 10754a: ff d0 call *%eax 10754c: 83 c4 10 add $0x10,%esp return result; } 10754f: 89 f8 mov %edi,%eax 107551: 8d 65 f4 lea -0xc(%ebp),%esp 107554: 5b pop %ebx 107555: 5e pop %esi 107556: 5f pop %edi 107557: c9 leave 107558: c3 ret 00107581 : const rtems_filesystem_operations_table *fs_ops, rtems_filesystem_options_t options, const char *device, const char *mount_point ) { 107581: 55 push %ebp 107582: 89 e5 mov %esp,%ebp 107584: 57 push %edi 107585: 56 push %esi 107586: 53 push %ebx 107587: 83 ec 3c sub $0x3c,%esp 10758a: 8b 75 14 mov 0x14(%ebp),%esi /* * Is there a file system operations table? */ if ( fs_ops == NULL ) { 10758d: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) 107591: 74 06 je 107599 /* * Are the file system options valid? */ if ( options != RTEMS_FILESYSTEM_READ_ONLY && 107593: 83 7d 10 01 cmpl $0x1,0x10(%ebp) 107597: 76 10 jbe 1075a9 options != RTEMS_FILESYSTEM_READ_WRITE ) { errno = EINVAL; 107599: e8 16 8d 00 00 call 1102b4 <__errno> 10759e: c7 00 16 00 00 00 movl $0x16,(%eax) 1075a4: e9 ea 01 00 00 jmp 107793 return -1; } /* Do they support being mounted at all ? */ if ( !fs_ops->fsmount_me_h ) { 1075a9: 8b 45 0c mov 0xc(%ebp),%eax 1075ac: 83 78 24 00 cmpl $0x0,0x24(%eax) 1075b0: 75 19 jne 1075cb errno = ENOTSUP; 1075b2: e8 fd 8c 00 00 call 1102b4 <__errno> <== NOT EXECUTED 1075b7: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1075bd: 31 f6 xor %esi,%esi <== NOT EXECUTED 1075bf: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) <== NOT EXECUTED goto cleanup_and_bail; 1075c6: e9 9a 01 00 00 jmp 107765 <== NOT EXECUTED /* * Allocate a mount table entry */ size = sizeof(rtems_filesystem_mount_table_entry_t); if ( device ) 1075cb: b9 6c 00 00 00 mov $0x6c,%ecx 1075d0: 85 f6 test %esi,%esi 1075d2: 74 0e je 1075e2 size += strlen( device ) + 1; 1075d4: 31 c0 xor %eax,%eax <== NOT EXECUTED 1075d6: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 1075d9: 89 f7 mov %esi,%edi <== NOT EXECUTED 1075db: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 1075dd: f7 d1 not %ecx <== NOT EXECUTED 1075df: 83 c1 6c add $0x6c,%ecx <== NOT EXECUTED temp_mt_entry = malloc( size ); 1075e2: 83 ec 0c sub $0xc,%esp 1075e5: 51 push %ecx 1075e6: e8 c1 fd ff ff call 1073ac 1075eb: 89 c3 mov %eax,%ebx 1075ed: 89 45 c4 mov %eax,-0x3c(%ebp) if ( !temp_mt_entry ) { 1075f0: 83 c4 10 add $0x10,%esp 1075f3: 85 c0 test %eax,%eax 1075f5: 75 10 jne 107607 errno = ENOMEM; 1075f7: e8 b8 8c 00 00 call 1102b4 <__errno> <== NOT EXECUTED 1075fc: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 107602: e9 8c 01 00 00 jmp 107793 <== NOT EXECUTED return -1; } temp_mt_entry->mt_fs_root.mt_entry = temp_mt_entry; 107607: 89 43 2c mov %eax,0x2c(%ebx) temp_mt_entry->options = options; 10760a: 8b 55 10 mov 0x10(%ebp),%edx 10760d: 89 50 30 mov %edx,0x30(%eax) if ( device ) { 107610: 85 f6 test %esi,%esi 107612: 74 14 je 107628 temp_mt_entry->dev = (char *)temp_mt_entry + sizeof( rtems_filesystem_mount_table_entry_t ); 107614: 8d 40 6c lea 0x6c(%eax),%eax <== NOT EXECUTED } temp_mt_entry->mt_fs_root.mt_entry = temp_mt_entry; temp_mt_entry->options = options; if ( device ) { temp_mt_entry->dev = 107617: 89 43 68 mov %eax,0x68(%ebx) <== NOT EXECUTED (char *)temp_mt_entry + sizeof( rtems_filesystem_mount_table_entry_t ); strcpy( temp_mt_entry->dev, device ); 10761a: 52 push %edx <== NOT EXECUTED 10761b: 52 push %edx <== NOT EXECUTED 10761c: 56 push %esi <== NOT EXECUTED 10761d: 50 push %eax <== NOT EXECUTED 10761e: e8 05 98 00 00 call 110e28 <== NOT EXECUTED 107623: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107626: eb 07 jmp 10762f <== NOT EXECUTED } else temp_mt_entry->dev = 0; 107628: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax) /* * The mount_point should be a directory with read/write/execute * permissions in the existing tree. */ if ( mount_point ) { 10762f: 83 7d 18 00 cmpl $0x0,0x18(%ebp) 107633: 0f 84 b0 00 00 00 je 1076e9 if ( rtems_filesystem_evaluate_path( mount_point, strlen( mount_point ), RTEMS_LIBIO_PERMS_RWX, &loc, true ) == -1 ) 107639: 31 c0 xor %eax,%eax 10763b: 83 c9 ff or $0xffffffff,%ecx 10763e: 8b 7d 18 mov 0x18(%ebp),%edi 107641: f2 ae repnz scas %es:(%edi),%al 107643: f7 d1 not %ecx 107645: 49 dec %ecx * permissions in the existing tree. */ if ( mount_point ) { if ( rtems_filesystem_evaluate_path( 107646: 83 ec 0c sub $0xc,%esp 107649: 6a 01 push $0x1 10764b: 8d 75 d4 lea -0x2c(%ebp),%esi 10764e: 56 push %esi 10764f: 6a 07 push $0x7 107651: 51 push %ecx 107652: ff 75 18 pushl 0x18(%ebp) 107655: e8 7e fa ff ff call 1070d8 10765a: 83 c4 20 add $0x20,%esp 10765d: 40 inc %eax 10765e: 0f 84 ff 00 00 00 je 107763 /* * Test for node_type_h */ if (!loc.ops->node_type_h) { 107664: 8b 45 e0 mov -0x20(%ebp),%eax 107667: 8b 40 10 mov 0x10(%eax),%eax 10766a: 85 c0 test %eax,%eax 10766c: 75 10 jne 10767e errno = ENOTSUP; 10766e: e8 41 8c 00 00 call 1102b4 <__errno> <== NOT EXECUTED 107673: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED goto cleanup_and_bail; 107679: e9 e7 00 00 00 jmp 107765 <== NOT EXECUTED /* * Test to see if it is a directory */ if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 10767e: 83 ec 0c sub $0xc,%esp 107681: 56 push %esi 107682: ff d0 call *%eax 107684: 83 c4 10 add $0x10,%esp 107687: 48 dec %eax 107688: 74 10 je 10769a errno = ENOTDIR; 10768a: e8 25 8c 00 00 call 1102b4 <__errno> 10768f: c7 00 14 00 00 00 movl $0x14,(%eax) goto cleanup_and_bail; 107695: e9 cb 00 00 00 jmp 107765 /* * For each mount table entry */ for ( the_node = rtems_filesystem_mount_table_control.first; 10769a: a1 9c 38 12 00 mov 0x12389c,%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 ) 10769f: 8b 55 d4 mov -0x2c(%ebp),%edx 1076a2: eb 07 jmp 1076ab 1076a4: 39 50 1c cmp %edx,0x1c(%eax) 1076a7: 74 0e je 1076b7 * 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 ) { 1076a9: 8b 00 mov (%eax),%eax */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 1076ab: 3d a0 38 12 00 cmp $0x1238a0,%eax 1076b0: 75 f2 jne 1076a4 1076b2: e9 e7 00 00 00 jmp 10779e /* * You can only mount one file system onto a single mount point. */ if ( Is_node_fs_root( &loc ) ){ errno = EBUSY; 1076b7: e8 f8 8b 00 00 call 1102b4 <__errno> 1076bc: c7 00 10 00 00 00 movl $0x10,(%eax) 1076c2: eb 0b jmp 1076cf * 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; 1076c4: e8 eb 8b 00 00 call 1102b4 <__errno> <== NOT EXECUTED 1076c9: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1076cf: 8d 75 d4 lea -0x2c(%ebp),%esi goto cleanup_and_bail; 1076d2: e9 8e 00 00 00 jmp 107765 } if ( loc.ops->mount_h( temp_mt_entry ) ) { 1076d7: 83 ec 0c sub $0xc,%esp 1076da: 53 push %ebx 1076db: ff d0 call *%eax 1076dd: 83 c4 10 add $0x10,%esp 1076e0: 85 c0 test %eax,%eax 1076e2: 8d 75 d4 lea -0x2c(%ebp),%esi 1076e5: 74 35 je 10771c 1076e7: eb 7c jmp 107765 <== NOT EXECUTED * 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; 1076e9: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) temp_mt_entry->mt_fs_root.handlers = NULL; 1076f0: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) temp_mt_entry->mt_fs_root.ops = NULL; 1076f7: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) temp_mt_entry->mt_point_node.node_access = NULL; 1076fe: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) temp_mt_entry->mt_point_node.handlers = NULL; 107705: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) temp_mt_entry->mt_point_node.ops = NULL; 10770c: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) temp_mt_entry->mt_point_node.mt_entry = NULL; 107713: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) 10771a: 31 f6 xor %esi,%esi } if ( fs_ops->fsmount_me_h( temp_mt_entry ) ) { 10771c: 83 ec 0c sub $0xc,%esp 10771f: 53 push %ebx 107720: 8b 55 0c mov 0xc(%ebp),%edx 107723: ff 52 24 call *0x24(%edx) 107726: 83 c4 10 add $0x10,%esp 107729: 85 c0 test %eax,%eax 10772b: 74 15 je 107742 /* try to undo the mount operation */ if ( loc.ops->unmount_h ) { 10772d: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 107730: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 107733: 85 c0 test %eax,%eax <== NOT EXECUTED 107735: 74 2e je 107765 <== NOT EXECUTED loc.ops->unmount_h( temp_mt_entry ); 107737: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10773a: 53 push %ebx <== NOT EXECUTED 10773b: ff d0 call *%eax <== NOT EXECUTED 10773d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107740: eb 23 jmp 107765 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void rtems_chain_append( rtems_chain_control *the_chain, rtems_chain_node *the_node ) { _Chain_Append( the_chain, the_node ); 107742: 50 push %eax 107743: 50 push %eax 107744: 53 push %ebx 107745: 68 9c 38 12 00 push $0x12389c 10774a: e8 41 30 00 00 call 10a790 <_Chain_Append> */ rtems_chain_append( &rtems_filesystem_mount_table_control, &temp_mt_entry->Node ); if ( mt_entry ) 10774f: 83 c4 10 add $0x10,%esp 107752: 31 c0 xor %eax,%eax 107754: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 107758: 74 3c je 107796 *mt_entry = temp_mt_entry; 10775a: 8b 45 08 mov 0x8(%ebp),%eax 10775d: 89 18 mov %ebx,(%eax) 10775f: 31 c0 xor %eax,%eax 107761: eb 33 jmp 107796 107763: 31 f6 xor %esi,%esi <== NOT EXECUTED return 0; cleanup_and_bail: free( temp_mt_entry ); 107765: 83 ec 0c sub $0xc,%esp 107768: ff 75 c4 pushl -0x3c(%ebp) 10776b: e8 10 fa ff ff call 107180 if ( loc_to_free ) 107770: 83 c4 10 add $0x10,%esp 107773: 85 f6 test %esi,%esi 107775: 74 1c je 107793 rtems_filesystem_freenode( loc_to_free ); 107777: 8b 46 0c mov 0xc(%esi),%eax 10777a: 85 c0 test %eax,%eax 10777c: 74 15 je 107793 10777e: 8b 40 1c mov 0x1c(%eax),%eax 107781: 85 c0 test %eax,%eax 107783: 74 0e je 107793 107785: 83 ec 0c sub $0xc,%esp 107788: 56 push %esi 107789: ff d0 call *%eax 10778b: 83 c8 ff or $0xffffffff,%eax 10778e: 83 c4 10 add $0x10,%esp 107791: eb 03 jmp 107796 107793: 83 c8 ff or $0xffffffff,%eax return -1; } 107796: 8d 65 f4 lea -0xc(%ebp),%esp 107799: 5b pop %ebx 10779a: 5e pop %esi 10779b: 5f pop %edi 10779c: c9 leave 10779d: 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; 10779e: 89 53 08 mov %edx,0x8(%ebx) temp_mt_entry->mt_point_node.handlers = loc.handlers; 1077a1: 8b 45 dc mov -0x24(%ebp),%eax 1077a4: 89 43 10 mov %eax,0x10(%ebx) temp_mt_entry->mt_point_node.ops = loc.ops; 1077a7: 8b 45 e0 mov -0x20(%ebp),%eax 1077aa: 89 43 14 mov %eax,0x14(%ebx) temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry; 1077ad: 8b 55 e4 mov -0x1c(%ebp),%edx 1077b0: 89 53 18 mov %edx,0x18(%ebx) /* * This link to the parent is only done when we are dealing with system * below the base file system */ if ( !loc.ops->mount_h ){ 1077b3: 8b 40 20 mov 0x20(%eax),%eax 1077b6: 85 c0 test %eax,%eax 1077b8: 0f 85 19 ff ff ff jne 1076d7 1077be: e9 01 ff ff ff jmp 1076c4 <== NOT EXECUTED 00107831 : */ int newlib_free_buffers( FILE *fp ) { 107831: 55 push %ebp 107832: 89 e5 mov %esp,%ebp 107834: 53 push %ebx 107835: 83 ec 10 sub $0x10,%esp 107838: 8b 5d 08 mov 0x8(%ebp),%ebx switch ( fileno(fp) ) { 10783b: 53 push %ebx 10783c: e8 2b 8e 00 00 call 11066c 107841: 83 c4 10 add $0x10,%esp 107844: 83 f8 02 cmp $0x2,%eax 107847: 77 26 ja 10786f case 0: case 1: case 2: if (fp->_flags & __SMBF) { 107849: 80 7b 0c 00 cmpb $0x0,0xc(%ebx) 10784d: 79 2c jns 10787b free( fp->_bf._base ); 10784f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107852: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 107855: e8 26 f9 ff ff call 107180 <== NOT EXECUTED fp->_flags &= ~__SMBF; 10785a: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) <== NOT EXECUTED fp->_bf._base = fp->_p = (unsigned char *) NULL; 107860: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED 107866: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED 10786d: eb 09 jmp 107878 <== NOT EXECUTED } break; default: fclose(fp); 10786f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107872: 53 push %ebx <== NOT EXECUTED 107873: e8 88 8b 00 00 call 110400 <== NOT EXECUTED 107878: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 10787b: 31 c0 xor %eax,%eax 10787d: 8b 5d fc mov -0x4(%ebp),%ebx 107880: c9 leave 107881: c3 ret 001077f0 : rtems_device_driver null_initialize( rtems_device_major_number major, rtems_device_minor_number minor __attribute__((unused)), void *pargp __attribute__((unused)) ) { 1077f0: 55 push %ebp 1077f1: 89 e5 mov %esp,%ebp 1077f3: 53 push %ebx 1077f4: 83 ec 04 sub $0x4,%esp 1077f7: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_device_driver status; if ( !initialized ) { 1077fa: 80 3d 84 4d 12 00 00 cmpb $0x0,0x124d84 107801: 75 2b jne 10782e initialized = 1; 107803: c6 05 84 4d 12 00 01 movb $0x1,0x124d84 status = rtems_io_register_name( 10780a: 50 push %eax 10780b: 6a 00 push $0x0 10780d: 53 push %ebx 10780e: 68 47 ec 11 00 push $0x11ec47 107813: e8 05 01 00 00 call 10791d "/dev/null", major, (rtems_device_minor_number) 0 ); if (status != RTEMS_SUCCESSFUL) 107818: 83 c4 10 add $0x10,%esp 10781b: 85 c0 test %eax,%eax 10781d: 74 09 je 107828 rtems_fatal_error_occurred(status); 10781f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107822: 50 push %eax <== NOT EXECUTED 107823: e8 dc 39 00 00 call 10b204 <== NOT EXECUTED NULL_major = major; 107828: 89 1d b0 50 12 00 mov %ebx,0x1250b0 } return RTEMS_SUCCESSFUL; } 10782e: 31 c0 xor %eax,%eax 107830: 8b 5d fc mov -0x4(%ebp),%ebx 107833: c9 leave 107834: c3 ret 001077d5 : rtems_device_driver null_write( rtems_device_major_number major __attribute__((unused)), rtems_device_minor_number minor __attribute__((unused)), void *pargp ) { 1077d5: 55 push %ebp 1077d6: 89 e5 mov %esp,%ebp 1077d8: 8b 45 10 mov 0x10(%ebp),%eax rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) pargp; if ( rw_args ) 1077db: 85 c0 test %eax,%eax 1077dd: 74 06 je 1077e5 rw_args->bytes_moved = rw_args->count; 1077df: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 1077e2: 89 50 18 mov %edx,0x18(%eax) <== NOT EXECUTED return NULL_SUCCESSFUL; } 1077e5: 31 c0 xor %eax,%eax 1077e7: c9 leave 1077e8: c3 ret 00107b5c : int open( const char *pathname, int flags, ... ) { 107b5c: 55 push %ebp 107b5d: 89 e5 mov %esp,%ebp 107b5f: 57 push %edi 107b60: 56 push %esi 107b61: 53 push %ebx 107b62: 83 ec 3c sub $0x3c,%esp /* * Set the Evaluation flags */ eval_flags = 0; status = flags + 1; 107b65: 8b 45 0c mov 0xc(%ebp),%eax 107b68: 40 inc %eax if ( ( status & _FREAD ) == _FREAD ) 107b69: 89 c6 mov %eax,%esi 107b6b: 83 e6 01 and $0x1,%esi 107b6e: f7 de neg %esi 107b70: 83 e6 04 and $0x4,%esi eval_flags |= RTEMS_LIBIO_PERMS_READ; if ( ( status & _FWRITE ) == _FWRITE ) 107b73: a8 02 test $0x2,%al 107b75: 74 03 je 107b7a eval_flags |= RTEMS_LIBIO_PERMS_WRITE; 107b77: 83 ce 02 or $0x2,%esi va_start(ap, flags); mode = va_arg( ap, int ); 107b7a: 8b 45 10 mov 0x10(%ebp),%eax 107b7d: 89 45 c4 mov %eax,-0x3c(%ebp) * code does not require changes here since network file * descriptors are obtained using socket(), not open(). */ /* allocate a file control block */ iop = rtems_libio_allocate(); 107b80: e8 8e 62 00 00 call 10de13 107b85: 89 c3 mov %eax,%ebx if ( iop == 0 ) { 107b87: bf 17 00 00 00 mov $0x17,%edi 107b8c: 85 c0 test %eax,%eax 107b8e: 0f 84 a8 01 00 00 je 107d3c /* * See if the file exists. */ status = rtems_filesystem_evaluate_path( pathname, strlen( pathname ), eval_flags, &loc, true ); 107b94: 83 c9 ff or $0xffffffff,%ecx 107b97: 8b 7d 08 mov 0x8(%ebp),%edi 107b9a: 31 c0 xor %eax,%eax 107b9c: f2 ae repnz scas %es:(%edi),%al 107b9e: f7 d1 not %ecx 107ba0: 49 dec %ecx /* * See if the file exists. */ status = rtems_filesystem_evaluate_path( 107ba1: 83 ec 0c sub $0xc,%esp 107ba4: 6a 01 push $0x1 107ba6: 8d 45 d4 lea -0x2c(%ebp),%eax 107ba9: 50 push %eax 107baa: 56 push %esi 107bab: 51 push %ecx 107bac: ff 75 08 pushl 0x8(%ebp) 107baf: e8 24 f5 ff ff call 1070d8 107bb4: 89 c6 mov %eax,%esi pathname, strlen( pathname ), eval_flags, &loc, true ); if ( status == -1 ) { 107bb6: 83 c4 20 add $0x20,%esp 107bb9: 83 f8 ff cmp $0xffffffff,%eax 107bbc: 75 7a jne 107c38 if ( errno != ENOENT ) { 107bbe: e8 f1 86 00 00 call 1102b4 <__errno> 107bc3: 83 38 02 cmpl $0x2,(%eax) 107bc6: 75 2f jne 107bf7 rc = errno; goto done; } /* If the file does not exist and we are not trying to create it--> error */ if ( !(flags & O_CREAT) ) { 107bc8: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 107bcf: 75 0c jne 107bdd 107bd1: 31 f6 xor %esi,%esi 107bd3: bf 02 00 00 00 mov $0x2,%edi 107bd8: e9 34 01 00 00 jmp 107d11 rc = ENOENT; goto done; } /* Create the node for the new regular file */ rc = mknod( pathname, S_IFREG | mode, 0LL ); 107bdd: 6a 00 push $0x0 107bdf: 6a 00 push $0x0 107be1: 8b 45 c4 mov -0x3c(%ebp),%eax 107be4: 80 cc 80 or $0x80,%ah 107be7: 50 push %eax 107be8: ff 75 08 pushl 0x8(%ebp) 107beb: e8 7c f8 ff ff call 10746c if ( rc ) { 107bf0: 83 c4 10 add $0x10,%esp 107bf3: 85 c0 test %eax,%eax 107bf5: 74 0e je 107c05 rc = errno; 107bf7: e8 b8 86 00 00 call 1102b4 <__errno> 107bfc: 8b 38 mov (%eax),%edi 107bfe: 31 f6 xor %esi,%esi goto done; 107c00: e9 08 01 00 00 jmp 107d0d } /* Sanity check to see if the file name exists after the mknod() */ status = rtems_filesystem_evaluate_path( pathname, strlen( pathname ), 0x0, &loc, true ); 107c05: 89 f1 mov %esi,%ecx 107c07: 8b 7d 08 mov 0x8(%ebp),%edi 107c0a: 31 c0 xor %eax,%eax 107c0c: f2 ae repnz scas %es:(%edi),%al 107c0e: f7 d1 not %ecx 107c10: 49 dec %ecx 107c11: 83 ec 0c sub $0xc,%esp 107c14: 6a 01 push $0x1 107c16: 8d 45 d4 lea -0x2c(%ebp),%eax 107c19: 50 push %eax 107c1a: 6a 00 push $0x0 107c1c: 51 push %ecx 107c1d: ff 75 08 pushl 0x8(%ebp) 107c20: e8 b3 f4 ff ff call 1070d8 if ( status != 0 ) { /* The file did not exist */ 107c25: 83 c4 20 add $0x20,%esp 107c28: 85 c0 test %eax,%eax 107c2a: 74 28 je 107c54 107c2c: 31 f6 xor %esi,%esi <== NOT EXECUTED 107c2e: bf 0d 00 00 00 mov $0xd,%edi <== NOT EXECUTED 107c33: e9 d9 00 00 00 jmp 107d11 <== NOT EXECUTED rc = EACCES; goto done; } } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) { 107c38: 8b 45 0c mov 0xc(%ebp),%eax 107c3b: 25 00 0a 00 00 and $0xa00,%eax 107c40: 3d 00 0a 00 00 cmp $0xa00,%eax 107c45: 75 0d jne 107c54 107c47: 8d 75 d4 lea -0x2c(%ebp),%esi 107c4a: bf 11 00 00 00 mov $0x11,%edi 107c4f: e9 bd 00 00 00 jmp 107d11 /* * Fill in the file control block based on the loc structure * returned by successful path evaluation. */ iop->handlers = loc.handlers; 107c54: 8b 45 dc mov -0x24(%ebp),%eax 107c57: 89 43 3c mov %eax,0x3c(%ebx) iop->file_info = loc.node_access; 107c5a: 8b 45 d4 mov -0x2c(%ebp),%eax 107c5d: 89 43 38 mov %eax,0x38(%ebx) iop->flags |= rtems_libio_fcntl_flags( flags ); 107c60: 8b 73 14 mov 0x14(%ebx),%esi 107c63: 83 ec 0c sub $0xc,%esp 107c66: ff 75 0c pushl 0xc(%ebp) 107c69: e8 30 62 00 00 call 10de9e 107c6e: 09 f0 or %esi,%eax 107c70: 89 43 14 mov %eax,0x14(%ebx) iop->pathinfo = loc; 107c73: 8d 7b 18 lea 0x18(%ebx),%edi 107c76: 8d 75 d4 lea -0x2c(%ebp),%esi 107c79: b9 05 00 00 00 mov $0x5,%ecx 107c7e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !iop->handlers || !iop->handlers->open_h ) { 107c80: 8b 43 3c mov 0x3c(%ebx),%eax 107c83: 83 c4 10 add $0x10,%esp 107c86: 85 c0 test %eax,%eax 107c88: 0f 84 cd 00 00 00 je 107d5b 107c8e: 8b 00 mov (%eax),%eax 107c90: 85 c0 test %eax,%eax 107c92: 0f 84 c3 00 00 00 je 107d5b rc = ENOTSUP; goto done; } rc = (*iop->handlers->open_h)( iop, pathname, flags, mode ); 107c98: ff 75 c4 pushl -0x3c(%ebp) 107c9b: ff 75 0c pushl 0xc(%ebp) 107c9e: ff 75 08 pushl 0x8(%ebp) 107ca1: 53 push %ebx 107ca2: ff d0 call *%eax if ( rc ) { 107ca4: 83 c4 10 add $0x10,%esp 107ca7: 85 c0 test %eax,%eax 107ca9: 74 0c je 107cb7 rc = errno; 107cab: e8 04 86 00 00 call 1102b4 <__errno> 107cb0: 8b 38 mov (%eax),%edi 107cb2: 8d 75 d4 lea -0x2c(%ebp),%esi goto done; 107cb5: eb 56 jmp 107d0d /* * Optionally truncate the file. */ if ( (flags & O_TRUNC) == O_TRUNC ) { 107cb7: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 107cbe: 0f 84 84 00 00 00 je 107d48 rc = ftruncate( iop - rtems_libio_iops, 0 ); 107cc4: 50 push %eax 107cc5: 6a 00 push $0x0 107cc7: 6a 00 push $0x0 107cc9: 89 d8 mov %ebx,%eax 107ccb: 2b 05 58 38 12 00 sub 0x123858,%eax 107cd1: c1 f8 06 sar $0x6,%eax 107cd4: 50 push %eax 107cd5: e8 c6 5e 00 00 call 10dba0 107cda: 89 c7 mov %eax,%edi if ( rc ) { 107cdc: 83 c4 10 add $0x10,%esp 107cdf: 85 c0 test %eax,%eax 107ce1: 74 65 je 107d48 if(errno) rc = errno; 107ce3: e8 cc 85 00 00 call 1102b4 <__errno> <== NOT EXECUTED 107ce8: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 107ceb: 74 07 je 107cf4 <== NOT EXECUTED 107ced: e8 c2 85 00 00 call 1102b4 <__errno> <== NOT EXECUTED 107cf2: 8b 38 mov (%eax),%edi <== NOT EXECUTED close( iop - rtems_libio_iops ); 107cf4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107cf7: 2b 1d 58 38 12 00 sub 0x123858,%ebx <== NOT EXECUTED 107cfd: c1 fb 06 sar $0x6,%ebx <== NOT EXECUTED 107d00: 53 push %ebx <== NOT EXECUTED 107d01: e8 12 5e 00 00 call 10db18 <== NOT EXECUTED 107d06: 31 f6 xor %esi,%esi <== NOT EXECUTED 107d08: 31 db xor %ebx,%ebx <== NOT EXECUTED 107d0a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED */ done: va_end(ap); if ( rc ) { 107d0d: 85 ff test %edi,%edi 107d0f: 74 37 je 107d48 if ( iop ) 107d11: 85 db test %ebx,%ebx 107d13: 74 0c je 107d21 rtems_libio_free( iop ); 107d15: 83 ec 0c sub $0xc,%esp 107d18: 53 push %ebx 107d19: e8 a0 60 00 00 call 10ddbe 107d1e: 83 c4 10 add $0x10,%esp if ( loc_to_free ) 107d21: 85 f6 test %esi,%esi 107d23: 74 17 je 107d3c rtems_filesystem_freenode( loc_to_free ); 107d25: 8b 46 0c mov 0xc(%esi),%eax 107d28: 85 c0 test %eax,%eax 107d2a: 74 10 je 107d3c 107d2c: 8b 40 1c mov 0x1c(%eax),%eax 107d2f: 85 c0 test %eax,%eax 107d31: 74 09 je 107d3c 107d33: 83 ec 0c sub $0xc,%esp 107d36: 56 push %esi 107d37: ff d0 call *%eax 107d39: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( rc ); 107d3c: e8 73 85 00 00 call 1102b4 <__errno> 107d41: 89 38 mov %edi,(%eax) 107d43: 83 c8 ff or $0xffffffff,%eax 107d46: eb 0b jmp 107d53 } return iop - rtems_libio_iops; 107d48: 89 d8 mov %ebx,%eax 107d4a: 2b 05 58 38 12 00 sub 0x123858,%eax 107d50: c1 f8 06 sar $0x6,%eax } 107d53: 8d 65 f4 lea -0xc(%ebp),%esp 107d56: 5b pop %ebx 107d57: 5e pop %esi 107d58: 5f pop %edi 107d59: c9 leave 107d5a: 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; 107d5b: 8d 75 d4 lea -0x2c(%ebp),%esi <== NOT EXECUTED 107d5e: bf 86 00 00 00 mov $0x86,%edi <== NOT EXECUTED 107d63: eb ac jmp 107d11 <== NOT EXECUTED 00107afc : /* * This is a replaceable stub which opens the console, if present. */ void open_dev_console(void) { 107afc: 55 push %ebp 107afd: 89 e5 mov %esp,%ebp 107aff: 83 ec 0c sub $0xc,%esp int stderr_fd; /* * Attempt to open /dev/console. */ if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) { 107b02: 6a 00 push $0x0 107b04: 6a 00 push $0x0 107b06: 68 f2 bf 11 00 push $0x11bff2 107b0b: e8 4c 00 00 00 call 107b5c 107b10: 83 c4 10 add $0x10,%esp 107b13: 40 inc %eax 107b14: 74 41 je 107b57 /* * 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) 107b16: 52 push %edx 107b17: 6a 00 push $0x0 107b19: 6a 01 push $0x1 107b1b: 68 f2 bf 11 00 push $0x11bff2 107b20: e8 37 00 00 00 call 107b5c 107b25: 83 c4 10 add $0x10,%esp 107b28: 40 inc %eax 107b29: 75 0a jne 107b35 rtems_fatal_error_occurred( 0x55544431 ); /* error STD1 */ 107b2b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107b2e: 68 31 44 54 55 push $0x55544431 <== NOT EXECUTED 107b33: eb 1d jmp 107b52 <== NOT EXECUTED if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1) 107b35: 50 push %eax 107b36: 6a 00 push $0x0 107b38: 6a 01 push $0x1 107b3a: 68 f2 bf 11 00 push $0x11bff2 107b3f: e8 18 00 00 00 call 107b5c 107b44: 83 c4 10 add $0x10,%esp 107b47: 40 inc %eax 107b48: 75 0d jne 107b57 rtems_fatal_error_occurred( 0x55544432 ); /* error STD2 */ 107b4a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107b4d: 68 32 44 54 55 push $0x55544432 <== NOT EXECUTED 107b52: e8 dd 29 00 00 call 10a534 <== NOT EXECUTED } 107b57: c9 leave 107b58: c3 ret 001084d1 : /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) { 1084d1: 55 push %ebp 1084d2: 89 e5 mov %esp,%ebp 1084d4: 56 push %esi 1084d5: 53 push %ebx 1084d6: 83 ec 10 sub $0x10,%esp 1084d9: 89 d3 mov %edx,%ebx 1084db: 88 45 f4 mov %al,-0xc(%ebp) int i; if (tty->termios.c_oflag & OPOST) { 1084de: 8b 52 34 mov 0x34(%edx),%edx 1084e1: f6 c2 01 test $0x1,%dl 1084e4: 0f 84 ee 00 00 00 je 1085d8 switch (c) { 1084ea: 3c 09 cmp $0x9,%al 1084ec: 74 76 je 108564 1084ee: 77 0d ja 1084fd 1084f0: 3c 08 cmp $0x8,%al <== NOT EXECUTED 1084f2: 0f 85 ab 00 00 00 jne 1085a3 <== NOT EXECUTED 1084f8: e9 99 00 00 00 jmp 108596 <== NOT EXECUTED 1084fd: 3c 0a cmp $0xa,%al 1084ff: 74 0a je 10850b 108501: 3c 0d cmp $0xd,%al 108503: 0f 85 9a 00 00 00 jne 1085a3 108509: eb 33 jmp 10853e <== NOT EXECUTED case '\n': if (tty->termios.c_oflag & ONLRET) 10850b: 80 e2 20 and $0x20,%dl 10850e: 74 07 je 108517 tty->column = 0; 108510: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED if (tty->termios.c_oflag & ONLCR) { 108517: f6 43 34 04 testb $0x4,0x34(%ebx) 10851b: 0f 84 b7 00 00 00 je 1085d8 rtems_termios_puts ("\r", 1, tty); 108521: 56 push %esi 108522: 53 push %ebx 108523: 6a 01 push $0x1 108525: 68 a1 d5 11 00 push $0x11d5a1 10852a: e8 82 fe ff ff call 1083b1 tty->column = 0; 10852f: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) 108536: 83 c4 10 add $0x10,%esp 108539: e9 9a 00 00 00 jmp 1085d8 } break; case '\r': if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0)) 10853e: f6 c2 10 test $0x10,%dl <== NOT EXECUTED 108541: 74 0a je 10854d <== NOT EXECUTED 108543: 83 7b 28 00 cmpl $0x0,0x28(%ebx) <== NOT EXECUTED 108547: 0f 84 9b 00 00 00 je 1085e8 <== NOT EXECUTED return; if (tty->termios.c_oflag & OCRNL) { 10854d: f6 c2 08 test $0x8,%dl <== NOT EXECUTED 108550: 74 09 je 10855b <== NOT EXECUTED c = '\n'; 108552: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED if (tty->termios.c_oflag & ONLRET) 108556: 80 e2 20 and $0x20,%dl <== NOT EXECUTED 108559: 74 7d je 1085d8 <== NOT EXECUTED tty->column = 0; break; } tty->column = 0; 10855b: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED break; 108562: eb 74 jmp 1085d8 <== NOT EXECUTED case '\t': i = 8 - (tty->column & 7); 108564: 8b 4b 28 mov 0x28(%ebx),%ecx 108567: 89 ce mov %ecx,%esi 108569: 83 e6 07 and $0x7,%esi 10856c: b8 08 00 00 00 mov $0x8,%eax 108571: 29 f0 sub %esi,%eax if ((tty->termios.c_oflag & TABDLY) == XTABS) { 108573: 81 e2 00 18 00 00 and $0x1800,%edx 108579: 81 fa 00 18 00 00 cmp $0x1800,%edx 10857f: 8d 14 08 lea (%eax,%ecx,1),%edx 108582: 75 0d jne 108591 tty->column += i; 108584: 89 53 28 mov %edx,0x28(%ebx) rtems_termios_puts ( " ", i, tty); 108587: 51 push %ecx 108588: 53 push %ebx 108589: 50 push %eax 10858a: 68 4c d2 11 00 push $0x11d24c 10858f: eb 4f jmp 1085e0 return; } tty->column += i; 108591: 89 53 28 mov %edx,0x28(%ebx) <== NOT EXECUTED break; 108594: eb 42 jmp 1085d8 <== NOT EXECUTED case '\b': if (tty->column > 0) 108596: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 108599: 85 c0 test %eax,%eax <== NOT EXECUTED 10859b: 7e 3b jle 1085d8 <== NOT EXECUTED tty->column--; 10859d: 48 dec %eax <== NOT EXECUTED 10859e: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 1085a1: eb 35 jmp 1085d8 <== NOT EXECUTED break; default: if (tty->termios.c_oflag & OLCUC) 1085a3: 80 e2 02 and $0x2,%dl 1085a6: 74 1c je 1085c4 c = toupper(c); 1085a8: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 1085ab: 8b 15 04 18 12 00 mov 0x121804,%edx <== NOT EXECUTED 1085b1: 0f be 54 02 01 movsbl 0x1(%edx,%eax,1),%edx <== NOT EXECUTED 1085b6: 83 e2 03 and $0x3,%edx <== NOT EXECUTED 1085b9: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 1085bc: 75 03 jne 1085c1 <== NOT EXECUTED 1085be: 83 e8 20 sub $0x20,%eax <== NOT EXECUTED 1085c1: 88 45 f4 mov %al,-0xc(%ebp) <== NOT EXECUTED if (!iscntrl(c)) 1085c4: 0f b6 45 f4 movzbl -0xc(%ebp),%eax 1085c8: 8b 15 04 18 12 00 mov 0x121804,%edx 1085ce: f6 44 02 01 20 testb $0x20,0x1(%edx,%eax,1) 1085d3: 75 03 jne 1085d8 tty->column++; 1085d5: ff 43 28 incl 0x28(%ebx) break; } } rtems_termios_puts (&c, 1, tty); 1085d8: 52 push %edx 1085d9: 53 push %ebx 1085da: 6a 01 push $0x1 1085dc: 8d 45 f4 lea -0xc(%ebp),%eax 1085df: 50 push %eax 1085e0: e8 cc fd ff ff call 1083b1 1085e5: 83 c4 10 add $0x10,%esp } 1085e8: 8d 65 f8 lea -0x8(%ebp),%esp 1085eb: 5b pop %ebx 1085ec: 5e pop %esi 1085ed: c9 leave 1085ee: c3 ret 0010fe90 : * Called by pipe() to create an anonymous pipe. */ int pipe_create( int filsdes[2] ) { 10fe90: 55 push %ebp 10fe91: 89 e5 mov %esp,%ebp 10fe93: 57 push %edi 10fe94: 56 push %esi 10fe95: 53 push %ebx 10fe96: 83 ec 48 sub $0x48,%esp rtems_filesystem_location_info_t loc; rtems_libio_t *iop; int err = 0; /* Create /tmp if not exists */ if (rtems_filesystem_evaluate_path("/tmp", 3, RTEMS_LIBIO_PERMS_RWX, &loc, TRUE) 10fe99: 6a 01 push $0x1 10fe9b: 8d 5d c4 lea -0x3c(%ebp),%ebx 10fe9e: 53 push %ebx 10fe9f: 6a 07 push $0x7 10fea1: 6a 03 push $0x3 10fea3: 68 df db 11 00 push $0x11dbdf 10fea8: e8 2b 72 ff ff call 1070d8 10fead: 83 c4 20 add $0x20,%esp 10feb0: 85 c0 test %eax,%eax 10feb2: 74 2b je 10fedf != 0) { if (errno != ENOENT) 10feb4: e8 fb 03 00 00 call 1102b4 <__errno> 10feb9: 83 38 02 cmpl $0x2,(%eax) 10febc: 0f 85 0c 01 00 00 jne 10ffce return -1; if (mkdir("/tmp", S_IRWXU|S_IRWXG|S_IRWXO|S_ISVTX) != 0) 10fec2: 50 push %eax 10fec3: 50 push %eax 10fec4: 68 ff 03 00 00 push $0x3ff 10fec9: 68 df db 11 00 push $0x11dbdf 10fece: e8 7d 75 ff ff call 107450 10fed3: 83 c4 10 add $0x10,%esp 10fed6: 85 c0 test %eax,%eax 10fed8: 74 1c je 10fef6 10feda: e9 ef 00 00 00 jmp 10ffce <== NOT EXECUTED return -1; } else rtems_filesystem_freenode(&loc); 10fedf: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 10fee2: 85 c0 test %eax,%eax <== NOT EXECUTED 10fee4: 74 10 je 10fef6 <== NOT EXECUTED 10fee6: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10fee9: 85 c0 test %eax,%eax <== NOT EXECUTED 10feeb: 74 09 je 10fef6 <== NOT EXECUTED 10feed: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fef0: 53 push %ebx <== NOT EXECUTED 10fef1: ff d0 call *%eax <== NOT EXECUTED 10fef3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* /tmp/.fifoXXXX */ char fifopath[15]; memcpy(fifopath, "/tmp/.fifo", 10); 10fef6: 8d 5d d9 lea -0x27(%ebp),%ebx 10fef9: be e4 db 11 00 mov $0x11dbe4,%esi 10fefe: b9 0a 00 00 00 mov $0xa,%ecx 10ff03: 89 df mov %ebx,%edi 10ff05: f3 a4 rep movsb %ds:(%esi),%es:(%edi) sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); 10ff07: 0f b7 05 60 36 12 00 movzwl 0x123660,%eax 10ff0e: 8d 50 01 lea 0x1(%eax),%edx 10ff11: 66 89 15 60 36 12 00 mov %dx,0x123660 10ff18: 57 push %edi 10ff19: 50 push %eax 10ff1a: 68 ef db 11 00 push $0x11dbef 10ff1f: 8d 45 e3 lea -0x1d(%ebp),%eax 10ff22: 50 push %eax 10ff23: e8 20 0d 00 00 call 110c48 /* Try creating FIFO file until find an available file name */ while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) { 10ff28: 59 pop %ecx 10ff29: 5e pop %esi 10ff2a: 68 80 01 00 00 push $0x180 10ff2f: 53 push %ebx 10ff30: e8 f7 00 00 00 call 11002c 10ff35: 83 c4 10 add $0x10,%esp 10ff38: 85 c0 test %eax,%eax 10ff3a: 74 0a je 10ff46 if (errno != EEXIST){ 10ff3c: e8 73 03 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10ff41: e9 88 00 00 00 jmp 10ffce <== NOT EXECUTED return -1; sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); } /* Non-blocking open to avoid waiting for writers */ filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK); 10ff46: 52 push %edx 10ff47: 52 push %edx 10ff48: 68 00 40 00 00 push $0x4000 10ff4d: 53 push %ebx 10ff4e: e8 09 7c ff ff call 107b5c 10ff53: 8b 55 08 mov 0x8(%ebp),%edx 10ff56: 89 02 mov %eax,(%edx) if (filsdes[0] < 0) { 10ff58: 83 c4 10 add $0x10,%esp 10ff5b: 85 c0 test %eax,%eax 10ff5d: 79 0d jns 10ff6c err = errno; 10ff5f: e8 50 03 00 00 call 1102b4 <__errno> 10ff64: 8b 30 mov (%eax),%esi /* Delete file at errors, or else if pipe is successfully created the file node will be deleted after it is closed by all. */ unlink(fifopath); 10ff66: 83 ec 0c sub $0xc,%esp 10ff69: 53 push %ebx 10ff6a: eb 53 jmp 10ffbf } else { /* Reset open file to blocking mode */ iop = rtems_libio_iop(filsdes[0]); 10ff6c: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ff6e: 3b 05 84 f9 11 00 cmp 0x11f984,%eax <== NOT EXECUTED 10ff74: 73 0b jae 10ff81 <== NOT EXECUTED 10ff76: 89 c2 mov %eax,%edx <== NOT EXECUTED 10ff78: c1 e2 06 shl $0x6,%edx <== NOT EXECUTED 10ff7b: 03 15 58 38 12 00 add 0x123858,%edx <== NOT EXECUTED iop->flags &= ~LIBIO_FLAGS_NO_DELAY; 10ff81: 83 62 14 fe andl $0xfffffffe,0x14(%edx) <== NOT EXECUTED filsdes[1] = open(fifopath, O_WRONLY); 10ff85: 50 push %eax <== NOT EXECUTED 10ff86: 50 push %eax <== NOT EXECUTED 10ff87: 6a 01 push $0x1 <== NOT EXECUTED 10ff89: 8d 45 d9 lea -0x27(%ebp),%eax <== NOT EXECUTED 10ff8c: 50 push %eax <== NOT EXECUTED 10ff8d: e8 ca 7b ff ff call 107b5c <== NOT EXECUTED 10ff92: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10ff95: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED if (filsdes[1] < 0) { 10ff98: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ff9b: 31 f6 xor %esi,%esi <== NOT EXECUTED 10ff9d: 85 c0 test %eax,%eax <== NOT EXECUTED 10ff9f: 79 17 jns 10ffb8 <== NOT EXECUTED err = errno; 10ffa1: e8 0e 03 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10ffa6: 8b 30 mov (%eax),%esi <== NOT EXECUTED close(filsdes[0]); 10ffa8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ffab: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ffae: ff 30 pushl (%eax) <== NOT EXECUTED 10ffb0: e8 63 db ff ff call 10db18 <== NOT EXECUTED 10ffb5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } unlink(fifopath); 10ffb8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ffbb: 8d 45 d9 lea -0x27(%ebp),%eax <== NOT EXECUTED 10ffbe: 50 push %eax <== NOT EXECUTED 10ffbf: e8 84 00 00 00 call 110048 10ffc4: 83 c4 10 add $0x10,%esp } rtems_set_errno_and_return_minus_one(err); 10ffc7: e8 e8 02 00 00 call 1102b4 <__errno> 10ffcc: 89 30 mov %esi,(%eax) } 10ffce: 83 c8 ff or $0xffffffff,%eax 10ffd1: 8d 65 f4 lea -0xc(%ebp),%esp 10ffd4: 5b pop %ebx 10ffd5: 5e pop %esi 10ffd6: 5f pop %edi 10ffd7: c9 leave 10ffd8: c3 ret 0010f1dd : /* Called with rtems_pipe_semaphore held. */ static inline void pipe_free( pipe_control_t *pipe ) { 10f1dd: 55 push %ebp <== NOT EXECUTED 10f1de: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f1e0: 53 push %ebx <== NOT EXECUTED 10f1e1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10f1e4: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_barrier_delete(pipe->readBarrier); 10f1e6: ff 70 2c pushl 0x2c(%eax) <== NOT EXECUTED 10f1e9: e8 62 07 00 00 call 10f950 <== NOT EXECUTED rtems_barrier_delete(pipe->writeBarrier); 10f1ee: 59 pop %ecx <== NOT EXECUTED 10f1ef: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10f1f2: e8 59 07 00 00 call 10f950 <== NOT EXECUTED rtems_semaphore_delete(pipe->Semaphore); 10f1f7: 5a pop %edx <== NOT EXECUTED 10f1f8: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f1fb: e8 ec ac ff ff call 109eec <== NOT EXECUTED free(pipe->Buffer); 10f200: 58 pop %eax <== NOT EXECUTED 10f201: ff 33 pushl (%ebx) <== NOT EXECUTED 10f203: e8 78 7f ff ff call 107180 <== NOT EXECUTED free(pipe); 10f208: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10f20b: e8 70 7f ff ff call 107180 <== NOT EXECUTED 10f210: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10f213: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f216: c9 leave <== NOT EXECUTED 10f217: c3 ret <== NOT EXECUTED 0010ee93 : pipe_control_t *pipe, uint32_t cmd, void *buffer, rtems_libio_t *iop ) { 10ee93: 55 push %ebp <== NOT EXECUTED 10ee94: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ee96: 56 push %esi <== NOT EXECUTED 10ee97: 53 push %ebx <== NOT EXECUTED 10ee98: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10ee9b: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED if (cmd == FIONREAD) { 10ee9e: b8 ea ff ff ff mov $0xffffffea,%eax <== NOT EXECUTED 10eea3: 81 7d 0c 7f 66 04 40 cmpl $0x4004667f,0xc(%ebp) <== NOT EXECUTED 10eeaa: 75 36 jne 10eee2 <== NOT EXECUTED if (buffer == NULL) 10eeac: b0 f2 mov $0xf2,%al <== NOT EXECUTED 10eeae: 85 f6 test %esi,%esi <== NOT EXECUTED 10eeb0: 74 30 je 10eee2 <== NOT EXECUTED return -EFAULT; if (! PIPE_LOCK(pipe)) 10eeb2: 50 push %eax <== NOT EXECUTED 10eeb3: 6a 00 push $0x0 <== NOT EXECUTED 10eeb5: 6a 00 push $0x0 <== NOT EXECUTED 10eeb7: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10eeba: e8 bd b0 ff ff call 109f7c <== NOT EXECUTED 10eebf: 89 c2 mov %eax,%edx <== NOT EXECUTED 10eec1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eec4: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED 10eec9: 85 d2 test %edx,%edx <== NOT EXECUTED 10eecb: 75 15 jne 10eee2 <== NOT EXECUTED return -EINTR; /* Return length of pipe */ *(uint *)buffer = pipe->Length; 10eecd: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10eed0: 89 06 mov %eax,(%esi) <== NOT EXECUTED PIPE_UNLOCK(pipe); 10eed2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10eed5: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10eed8: e8 8b b1 ff ff call 10a068 <== NOT EXECUTED 10eedd: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; 10eedf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return -EINVAL; } 10eee2: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10eee5: 5b pop %ebx <== NOT EXECUTED 10eee6: 5e pop %esi <== NOT EXECUTED 10eee7: c9 leave <== NOT EXECUTED 10eee8: c3 ret <== NOT EXECUTED 0010ee3c : pipe_control_t *pipe, off_t offset, int whence, rtems_libio_t *iop ) { 10ee3c: 55 push %ebp <== NOT EXECUTED 10ee3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED /* Seek on pipe is not supported */ return -ESPIPE; } 10ee3f: b8 e3 ff ff ff mov $0xffffffe3,%eax <== NOT EXECUTED 10ee44: c9 leave <== NOT EXECUTED 10ee45: c3 ret <== NOT EXECUTED 0010f07b : pipe_control_t *pipe, void *buffer, size_t count, rtems_libio_t *iop ) { 10f07b: 55 push %ebp <== NOT EXECUTED 10f07c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f07e: 57 push %edi <== NOT EXECUTED 10f07f: 56 push %esi <== NOT EXECUTED 10f080: 53 push %ebx <== NOT EXECUTED 10f081: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED 10f084: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) 10f087: 6a 00 push $0x0 <== NOT EXECUTED 10f089: 6a 00 push $0x0 <== NOT EXECUTED 10f08b: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f08e: e8 e9 ae ff ff call 109f7c <== NOT EXECUTED 10f093: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f096: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED 10f09d: 85 c0 test %eax,%eax <== NOT EXECUTED 10f09f: 0f 84 08 01 00 00 je 10f1ad <== NOT EXECUTED 10f0a5: c7 45 d4 fc ff ff ff movl $0xfffffffc,-0x2c(%ebp) <== NOT EXECUTED 10f0ac: e9 21 01 00 00 jmp 10f1d2 <== NOT EXECUTED return -EINTR; while (read < count) { while (PIPE_EMPTY(pipe)) { /* Not an error */ if (pipe->Writers == 0) 10f0b1: 83 7b 14 00 cmpl $0x0,0x14(%ebx) <== NOT EXECUTED 10f0b5: 0f 84 fe 00 00 00 je 10f1b9 <== NOT EXECUTED goto out_locked; if (LIBIO_NODELAY(iop)) { 10f0bb: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10f0be: f6 40 14 01 testb $0x1,0x14(%eax) <== NOT EXECUTED 10f0c2: 74 0a je 10f0ce <== NOT EXECUTED 10f0c4: be f5 ff ff ff mov $0xfffffff5,%esi <== NOT EXECUTED 10f0c9: e9 ed 00 00 00 jmp 10f1bb <== NOT EXECUTED ret = -EAGAIN; goto out_locked; } /* Wait until pipe is no more empty or no writer exists */ pipe->waitingReaders ++; 10f0ce: ff 43 18 incl 0x18(%ebx) <== NOT EXECUTED PIPE_UNLOCK(pipe); 10f0d1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f0d4: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f0d7: e8 8c af ff ff call 10a068 <== NOT EXECUTED if (! PIPE_READWAIT(pipe)) 10f0dc: 5a pop %edx <== NOT EXECUTED 10f0dd: 59 pop %ecx <== NOT EXECUTED 10f0de: 6a 00 push $0x0 <== NOT EXECUTED 10f0e0: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10f0e3: e8 20 09 00 00 call 10fa08 <== NOT EXECUTED 10f0e8: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10f0eb: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10f0ee: 19 f6 sbb %esi,%esi <== NOT EXECUTED 10f0f0: f7 d6 not %esi <== NOT EXECUTED 10f0f2: 83 e6 fc and $0xfffffffc,%esi <== NOT EXECUTED ret = -EINTR; if (! PIPE_LOCK(pipe)) { 10f0f5: 6a 00 push $0x0 <== NOT EXECUTED 10f0f7: 6a 00 push $0x0 <== NOT EXECUTED 10f0f9: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f0fc: e8 7b ae ff ff call 109f7c <== NOT EXECUTED 10f101: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f104: 85 c0 test %eax,%eax <== NOT EXECUTED 10f106: 74 0a je 10f112 <== NOT EXECUTED 10f108: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED 10f10d: e9 b7 00 00 00 jmp 10f1c9 <== NOT EXECUTED /* WARN waitingReaders not restored! */ ret = -EINTR; goto out_nolock; } pipe->waitingReaders --; 10f112: ff 4b 18 decl 0x18(%ebx) <== NOT EXECUTED if (ret != 0) 10f115: 85 f6 test %esi,%esi <== NOT EXECUTED 10f117: 0f 85 9e 00 00 00 jne 10f1bb <== NOT EXECUTED if (! PIPE_LOCK(pipe)) return -EINTR; while (read < count) { while (PIPE_EMPTY(pipe)) { 10f11d: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED 10f120: 85 d2 test %edx,%edx <== NOT EXECUTED 10f122: 74 8d je 10f0b1 <== NOT EXECUTED if (ret != 0) goto out_locked; } /* Read chunk bytes */ chunk = MIN(count - read, pipe->Length); 10f124: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10f127: 2b 45 d4 sub -0x2c(%ebp),%eax <== NOT EXECUTED 10f12a: 89 55 d0 mov %edx,-0x30(%ebp) <== NOT EXECUTED 10f12d: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10f12f: 76 03 jbe 10f134 <== NOT EXECUTED 10f131: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED chunk1 = pipe->Size - pipe->Start; 10f134: 8b 73 08 mov 0x8(%ebx),%esi <== NOT EXECUTED 10f137: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10f13a: 29 f0 sub %esi,%eax <== NOT EXECUTED if (chunk > chunk1) { 10f13c: 39 45 d0 cmp %eax,-0x30(%ebp) <== NOT EXECUTED 10f13f: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10f142: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED 10f145: 8d 14 0f lea (%edi,%ecx,1),%edx <== NOT EXECUTED 10f148: 7e 1b jle 10f165 <== NOT EXECUTED memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1); 10f14a: 03 33 add (%ebx),%esi <== NOT EXECUTED 10f14c: 89 d7 mov %edx,%edi <== NOT EXECUTED 10f14e: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10f150: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1); 10f152: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 10f155: 01 c2 add %eax,%edx <== NOT EXECUTED 10f157: 03 55 0c add 0xc(%ebp),%edx <== NOT EXECUTED 10f15a: 8b 4d d0 mov -0x30(%ebp),%ecx <== NOT EXECUTED 10f15d: 29 c1 sub %eax,%ecx <== NOT EXECUTED 10f15f: 8b 33 mov (%ebx),%esi <== NOT EXECUTED 10f161: 89 d7 mov %edx,%edi <== NOT EXECUTED 10f163: eb 07 jmp 10f16c <== NOT EXECUTED } else memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk); 10f165: 03 33 add (%ebx),%esi <== NOT EXECUTED 10f167: 89 d7 mov %edx,%edi <== NOT EXECUTED 10f169: 8b 4d d0 mov -0x30(%ebp),%ecx <== NOT EXECUTED 10f16c: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED pipe->Start += chunk; 10f16e: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 10f171: 03 43 08 add 0x8(%ebx),%eax <== NOT EXECUTED pipe->Start %= pipe->Size; 10f174: 31 d2 xor %edx,%edx <== NOT EXECUTED 10f176: f7 73 04 divl 0x4(%ebx) <== NOT EXECUTED 10f179: 89 53 08 mov %edx,0x8(%ebx) <== NOT EXECUTED pipe->Length -= chunk; 10f17c: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10f17f: 2b 45 d0 sub -0x30(%ebp),%eax <== NOT EXECUTED 10f182: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED /* For buffering optimization */ if (PIPE_EMPTY(pipe)) 10f185: 85 c0 test %eax,%eax <== NOT EXECUTED 10f187: 75 07 jne 10f190 <== NOT EXECUTED pipe->Start = 0; 10f189: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED if (pipe->waitingWriters > 0) 10f190: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx) <== NOT EXECUTED 10f194: 74 11 je 10f1a7 <== NOT EXECUTED PIPE_WAKEUPWRITERS(pipe); 10f196: 50 push %eax <== NOT EXECUTED 10f197: 50 push %eax <== NOT EXECUTED 10f198: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10f19b: 50 push %eax <== NOT EXECUTED 10f19c: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10f19f: e8 0c 08 00 00 call 10f9b0 <== NOT EXECUTED 10f1a4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED read += chunk; 10f1a7: 8b 4d d0 mov -0x30(%ebp),%ecx <== NOT EXECUTED 10f1aa: 01 4d d4 add %ecx,-0x2c(%ebp) <== NOT EXECUTED int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) return -EINTR; while (read < count) { 10f1ad: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10f1b0: 39 7d d4 cmp %edi,-0x2c(%ebp) <== NOT EXECUTED 10f1b3: 0f 82 64 ff ff ff jb 10f11d <== NOT EXECUTED 10f1b9: 31 f6 xor %esi,%esi <== NOT EXECUTED PIPE_WAKEUPWRITERS(pipe); read += chunk; } out_locked: PIPE_UNLOCK(pipe); 10f1bb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f1be: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f1c1: e8 a2 ae ff ff call 10a068 <== NOT EXECUTED 10f1c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED out_nolock: if (read > 0) 10f1c9: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) <== NOT EXECUTED 10f1cd: 7f 03 jg 10f1d2 <== NOT EXECUTED 10f1cf: 89 75 d4 mov %esi,-0x2c(%ebp) <== NOT EXECUTED return read; return ret; } 10f1d2: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10f1d5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f1d8: 5b pop %ebx <== NOT EXECUTED 10f1d9: 5e pop %esi <== NOT EXECUTED 10f1da: 5f pop %edi <== NOT EXECUTED 10f1db: c9 leave <== NOT EXECUTED 10f1dc: c3 ret <== NOT EXECUTED 0010f218 : */ int pipe_release( pipe_control_t **pipep, rtems_libio_t *iop ) { 10f218: 55 push %ebp <== NOT EXECUTED 10f219: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f21b: 57 push %edi <== NOT EXECUTED 10f21c: 56 push %esi <== NOT EXECUTED 10f21d: 53 push %ebx <== NOT EXECUTED 10f21e: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 10f221: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED pipe_control_t *pipe = *pipep; 10f224: 8b 1f mov (%edi),%ebx <== NOT EXECUTED uint32_t mode; rtems_status_code sc; sc = rtems_semaphore_obtain(pipe->Semaphore, 10f226: 6a 00 push $0x0 <== NOT EXECUTED 10f228: 6a 00 push $0x0 <== NOT EXECUTED 10f22a: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f22d: e8 4a ad ff ff call 109f7c <== NOT EXECUTED RTEMS_WAIT, RTEMS_NO_TIMEOUT); /* WARN pipe not released! */ if(sc != RTEMS_SUCCESSFUL) 10f232: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f235: 85 c0 test %eax,%eax <== NOT EXECUTED 10f237: 75 34 jne 10f26d <== NOT EXECUTED rtems_fatal_error_occurred(sc); mode = LIBIO_ACCMODE(iop); 10f239: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f23c: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10f23f: 89 c6 mov %eax,%esi <== NOT EXECUTED 10f241: 83 e6 06 and $0x6,%esi <== NOT EXECUTED if (mode & LIBIO_FLAGS_READ) 10f244: a8 02 test $0x2,%al <== NOT EXECUTED 10f246: 74 03 je 10f24b <== NOT EXECUTED pipe->Readers --; 10f248: ff 4b 10 decl 0x10(%ebx) <== NOT EXECUTED if (mode & LIBIO_FLAGS_WRITE) 10f24b: f7 c6 04 00 00 00 test $0x4,%esi <== NOT EXECUTED 10f251: 74 03 je 10f256 <== NOT EXECUTED pipe->Writers --; 10f253: ff 4b 14 decl 0x14(%ebx) <== NOT EXECUTED sc = rtems_semaphore_obtain(rtems_pipe_semaphore, 10f256: 50 push %eax <== NOT EXECUTED 10f257: 6a 00 push $0x0 <== NOT EXECUTED 10f259: 6a 00 push $0x0 <== NOT EXECUTED 10f25b: ff 35 58 36 12 00 pushl 0x123658 <== NOT EXECUTED 10f261: e8 16 ad ff ff call 109f7c <== NOT EXECUTED RTEMS_WAIT, RTEMS_NO_TIMEOUT); /* WARN pipe not freed and pipep not set to NULL! */ if(sc != RTEMS_SUCCESSFUL) 10f266: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f269: 85 c0 test %eax,%eax <== NOT EXECUTED 10f26b: 74 09 je 10f276 <== NOT EXECUTED rtems_fatal_error_occurred(sc); 10f26d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f270: 50 push %eax <== NOT EXECUTED 10f271: e8 be b2 ff ff call 10a534 <== NOT EXECUTED PIPE_UNLOCK(pipe); 10f276: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f279: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f27c: e8 e7 ad ff ff call 10a068 <== NOT EXECUTED if (pipe->Readers == 0 && pipe->Writers == 0) { 10f281: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10f284: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f287: 85 c0 test %eax,%eax <== NOT EXECUTED 10f289: 75 15 jne 10f2a0 <== NOT EXECUTED 10f28b: 83 7b 14 00 cmpl $0x0,0x14(%ebx) <== NOT EXECUTED 10f28f: 75 0f jne 10f2a0 <== NOT EXECUTED #if 0 /* To delete an anonymous pipe file when all users closed it */ if (pipe->Anonymous) delfile = TRUE; #endif pipe_free(pipe); 10f291: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10f293: e8 45 ff ff ff call 10f1dd <== NOT EXECUTED *pipep = NULL; 10f298: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED if(sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred(sc); PIPE_UNLOCK(pipe); if (pipe->Readers == 0 && pipe->Writers == 0) { 10f29e: eb 30 jmp 10f2d0 <== NOT EXECUTED delfile = TRUE; #endif pipe_free(pipe); *pipep = NULL; } else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE) 10f2a0: 83 fe 04 cmp $0x4,%esi <== NOT EXECUTED 10f2a3: 74 0f je 10f2b4 <== NOT EXECUTED 10f2a5: 85 c0 test %eax,%eax <== NOT EXECUTED 10f2a7: 75 0b jne 10f2b4 <== NOT EXECUTED /* Notify waiting Writers that all their partners left */ PIPE_WAKEUPWRITERS(pipe); 10f2a9: 57 push %edi <== NOT EXECUTED 10f2aa: 57 push %edi <== NOT EXECUTED 10f2ab: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10f2ae: 50 push %eax <== NOT EXECUTED 10f2af: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10f2b2: eb 14 jmp 10f2c8 <== NOT EXECUTED else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ) 10f2b4: 83 fe 02 cmp $0x2,%esi <== NOT EXECUTED 10f2b7: 74 17 je 10f2d0 <== NOT EXECUTED 10f2b9: 83 7b 14 00 cmpl $0x0,0x14(%ebx) <== NOT EXECUTED 10f2bd: 75 11 jne 10f2d0 <== NOT EXECUTED PIPE_WAKEUPREADERS(pipe); 10f2bf: 56 push %esi <== NOT EXECUTED 10f2c0: 56 push %esi <== NOT EXECUTED 10f2c1: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10f2c4: 50 push %eax <== NOT EXECUTED 10f2c5: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10f2c8: e8 e3 06 00 00 call 10f9b0 <== NOT EXECUTED 10f2cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_semaphore_release(rtems_pipe_semaphore); 10f2d0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f2d3: ff 35 58 36 12 00 pushl 0x123658 <== NOT EXECUTED 10f2d9: e8 8a ad ff ff call 10a068 <== NOT EXECUTED if(iop->pathinfo.ops->unlink_h(&iop->pathinfo)) return -errno; #endif return 0; } 10f2de: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f2e0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f2e3: 5b pop %ebx <== NOT EXECUTED 10f2e4: 5e pop %esi <== NOT EXECUTED 10f2e5: 5f pop %edi <== NOT EXECUTED 10f2e6: c9 leave <== NOT EXECUTED 10f2e7: c3 ret <== NOT EXECUTED 0010eee9 : pipe_control_t *pipe, const void *buffer, size_t count, rtems_libio_t *iop ) { 10eee9: 55 push %ebp <== NOT EXECUTED 10eeea: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eeec: 57 push %edi <== NOT EXECUTED 10eeed: 56 push %esi <== NOT EXECUTED 10eeee: 53 push %ebx <== NOT EXECUTED 10eeef: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10eef2: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED int chunk, chunk1, written = 0, ret = 0; /* Write nothing */ if (count == 0) 10eef5: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED 10eefc: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 10ef00: 0f 84 6a 01 00 00 je 10f070 <== NOT EXECUTED return 0; if (! PIPE_LOCK(pipe)) 10ef06: 57 push %edi <== NOT EXECUTED 10ef07: 6a 00 push $0x0 <== NOT EXECUTED 10ef09: 6a 00 push $0x0 <== NOT EXECUTED 10ef0b: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10ef0e: e8 69 b0 ff ff call 109f7c <== NOT EXECUTED 10ef13: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ef16: c7 45 d4 fc ff ff ff movl $0xfffffffc,-0x2c(%ebp) <== NOT EXECUTED 10ef1d: 85 c0 test %eax,%eax <== NOT EXECUTED 10ef1f: 0f 85 4b 01 00 00 jne 10f070 <== NOT EXECUTED return -EINTR; if (pipe->Readers == 0) { 10ef25: 83 7b 10 00 cmpl $0x0,0x10(%ebx) <== NOT EXECUTED 10ef29: 75 11 jne 10ef3c <== NOT EXECUTED 10ef2b: be e0 ff ff ff mov $0xffffffe0,%esi <== NOT EXECUTED 10ef30: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED 10ef37: e9 1d 01 00 00 jmp 10f059 <== NOT EXECUTED ret = -EPIPE; goto out_locked; } /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; 10ef3c: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10ef3f: 3b 7b 04 cmp 0x4(%ebx),%edi <== NOT EXECUTED 10ef42: 76 05 jbe 10ef49 <== NOT EXECUTED 10ef44: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED 10ef49: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED 10ef50: e9 f6 00 00 00 jmp 10f04b <== NOT EXECUTED while (written < count) { while (PIPE_SPACE(pipe) < chunk) { if (LIBIO_NODELAY(iop)) { 10ef55: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10ef58: f6 40 14 01 testb $0x1,0x14(%eax) <== NOT EXECUTED 10ef5c: 74 0a je 10ef68 <== NOT EXECUTED 10ef5e: be f5 ff ff ff mov $0xfffffff5,%esi <== NOT EXECUTED 10ef63: e9 f1 00 00 00 jmp 10f059 <== NOT EXECUTED ret = -EAGAIN; goto out_locked; } /* Wait until there is chunk bytes space or no reader exists */ pipe->waitingWriters ++; 10ef68: ff 43 1c incl 0x1c(%ebx) <== NOT EXECUTED PIPE_UNLOCK(pipe); 10ef6b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ef6e: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10ef71: e8 f2 b0 ff ff call 10a068 <== NOT EXECUTED if (! PIPE_WRITEWAIT(pipe)) 10ef76: 59 pop %ecx <== NOT EXECUTED 10ef77: 5e pop %esi <== NOT EXECUTED 10ef78: 6a 00 push $0x0 <== NOT EXECUTED 10ef7a: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10ef7d: e8 86 0a 00 00 call 10fa08 <== NOT EXECUTED 10ef82: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ef85: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10ef88: 19 f6 sbb %esi,%esi <== NOT EXECUTED 10ef8a: f7 d6 not %esi <== NOT EXECUTED 10ef8c: 83 e6 fc and $0xfffffffc,%esi <== NOT EXECUTED ret = -EINTR; if (! PIPE_LOCK(pipe)) { 10ef8f: 6a 00 push $0x0 <== NOT EXECUTED 10ef91: 6a 00 push $0x0 <== NOT EXECUTED 10ef93: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10ef96: e8 e1 af ff ff call 109f7c <== NOT EXECUTED 10ef9b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ef9e: 85 c0 test %eax,%eax <== NOT EXECUTED 10efa0: 74 0a je 10efac <== NOT EXECUTED 10efa2: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED 10efa7: e9 bb 00 00 00 jmp 10f067 <== NOT EXECUTED /* WARN waitingWriters not restored! */ ret = -EINTR; goto out_nolock; } pipe->waitingWriters --; 10efac: ff 4b 1c decl 0x1c(%ebx) <== NOT EXECUTED if (ret != 0) 10efaf: 85 f6 test %esi,%esi <== NOT EXECUTED 10efb1: 0f 85 a2 00 00 00 jne 10f059 <== NOT EXECUTED goto out_locked; if (pipe->Readers == 0) { 10efb7: 83 7b 10 00 cmpl $0x0,0x10(%ebx) <== NOT EXECUTED 10efbb: 75 0a jne 10efc7 <== NOT EXECUTED 10efbd: be e0 ff ff ff mov $0xffffffe0,%esi <== NOT EXECUTED 10efc2: e9 92 00 00 00 jmp 10f059 <== NOT EXECUTED /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; while (written < count) { while (PIPE_SPACE(pipe) < chunk) { 10efc7: 8b 73 04 mov 0x4(%ebx),%esi <== NOT EXECUTED 10efca: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10efcd: 89 f1 mov %esi,%ecx <== NOT EXECUTED 10efcf: 29 c1 sub %eax,%ecx <== NOT EXECUTED 10efd1: 39 f9 cmp %edi,%ecx <== NOT EXECUTED 10efd3: 72 80 jb 10ef55 <== NOT EXECUTED ret = -EPIPE; goto out_locked; } } chunk = MIN(count - written, PIPE_SPACE(pipe)); 10efd5: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10efd8: 2b 55 d4 sub -0x2c(%ebp),%edx <== NOT EXECUTED 10efdb: 89 4d d0 mov %ecx,-0x30(%ebp) <== NOT EXECUTED 10efde: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 10efe0: 76 03 jbe 10efe5 <== NOT EXECUTED 10efe2: 89 55 d0 mov %edx,-0x30(%ebp) <== NOT EXECUTED chunk1 = pipe->Size - PIPE_WSTART(pipe); 10efe5: 03 43 08 add 0x8(%ebx),%eax <== NOT EXECUTED 10efe8: 31 d2 xor %edx,%edx <== NOT EXECUTED 10efea: f7 f6 div %esi <== NOT EXECUTED 10efec: 89 f0 mov %esi,%eax <== NOT EXECUTED 10efee: 29 d0 sub %edx,%eax <== NOT EXECUTED if (chunk > chunk1) { 10eff0: 39 45 d0 cmp %eax,-0x30(%ebp) <== NOT EXECUTED 10eff3: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10eff6: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED 10eff9: 8d 34 0f lea (%edi,%ecx,1),%esi <== NOT EXECUTED 10effc: 7e 1c jle 10f01a <== NOT EXECUTED memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1); 10effe: 03 13 add (%ebx),%edx <== NOT EXECUTED 10f000: 89 d7 mov %edx,%edi <== NOT EXECUTED 10f002: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10f004: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1); 10f006: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10f008: 8b 4d d0 mov -0x30(%ebp),%ecx <== NOT EXECUTED 10f00b: 29 c1 sub %eax,%ecx <== NOT EXECUTED 10f00d: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED 10f010: 8d 34 38 lea (%eax,%edi,1),%esi <== NOT EXECUTED 10f013: 03 75 0c add 0xc(%ebp),%esi <== NOT EXECUTED 10f016: 89 d7 mov %edx,%edi <== NOT EXECUTED 10f018: eb 07 jmp 10f021 <== NOT EXECUTED } else memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk); 10f01a: 03 13 add (%ebx),%edx <== NOT EXECUTED 10f01c: 89 d7 mov %edx,%edi <== NOT EXECUTED 10f01e: 8b 4d d0 mov -0x30(%ebp),%ecx <== NOT EXECUTED 10f021: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED pipe->Length += chunk; 10f023: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 10f026: 01 43 0c add %eax,0xc(%ebx) <== NOT EXECUTED if (pipe->waitingReaders > 0) 10f029: 83 7b 18 00 cmpl $0x0,0x18(%ebx) <== NOT EXECUTED 10f02d: 74 11 je 10f040 <== NOT EXECUTED PIPE_WAKEUPREADERS(pipe); 10f02f: 52 push %edx <== NOT EXECUTED 10f030: 52 push %edx <== NOT EXECUTED 10f031: 8d 4d e4 lea -0x1c(%ebp),%ecx <== NOT EXECUTED 10f034: 51 push %ecx <== NOT EXECUTED 10f035: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10f038: e8 73 09 00 00 call 10f9b0 <== NOT EXECUTED 10f03d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED written += chunk; 10f040: 8b 7d d0 mov -0x30(%ebp),%edi <== NOT EXECUTED 10f043: 01 7d d4 add %edi,-0x2c(%ebp) <== NOT EXECUTED 10f046: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED } /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; while (written < count) { 10f04b: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10f04e: 39 45 d4 cmp %eax,-0x2c(%ebp) <== NOT EXECUTED 10f051: 0f 82 70 ff ff ff jb 10efc7 <== NOT EXECUTED 10f057: 31 f6 xor %esi,%esi <== NOT EXECUTED /* Write of more than PIPE_BUF bytes can be interleaved */ chunk = 1; } out_locked: PIPE_UNLOCK(pipe); 10f059: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f05c: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f05f: e8 04 b0 ff ff call 10a068 <== NOT EXECUTED 10f064: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* Signal SIGPIPE */ if (ret == -EPIPE) kill(getpid(), SIGPIPE); #endif if (written > 0) 10f067: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) <== NOT EXECUTED 10f06b: 7f 03 jg 10f070 <== NOT EXECUTED 10f06d: 89 75 d4 mov %esi,-0x2c(%ebp) <== NOT EXECUTED return written; return ret; } 10f070: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10f073: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f076: 5b pop %ebx <== NOT EXECUTED 10f077: 5e pop %esi <== NOT EXECUTED 10f078: 5f pop %edi <== NOT EXECUTED 10f079: c9 leave <== NOT EXECUTED 10f07a: c3 ret <== NOT EXECUTED 0011b7a8 : ssize_t read( int fd, void *buffer, size_t count ) { 11b7a8: 55 push %ebp 11b7a9: 89 e5 mov %esp,%ebp 11b7ab: 56 push %esi 11b7ac: 53 push %ebx 11b7ad: 8b 5d 08 mov 0x8(%ebp),%ebx 11b7b0: 8b 55 0c mov 0xc(%ebp),%edx 11b7b3: 8b 4d 10 mov 0x10(%ebp),%ecx ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11b7b6: 3b 1d 84 f9 11 00 cmp 0x11f984,%ebx 11b7bc: 73 14 jae 11b7d2 iop = rtems_libio_iop( fd ); 11b7be: c1 e3 06 shl $0x6,%ebx 11b7c1: 03 1d 58 38 12 00 add 0x123858,%ebx rtems_libio_check_is_open( iop ); 11b7c7: 8b 73 14 mov 0x14(%ebx),%esi 11b7ca: f7 c6 00 01 00 00 test $0x100,%esi 11b7d0: 75 0d jne 11b7df 11b7d2: e8 dd 4a ff ff call 1102b4 <__errno> 11b7d7: c7 00 09 00 00 00 movl $0x9,(%eax) 11b7dd: eb 31 jmp 11b810 rtems_libio_check_buffer( buffer ); 11b7df: 85 d2 test %edx,%edx 11b7e1: 74 0b je 11b7ee rtems_libio_check_count( count ); 11b7e3: 31 c0 xor %eax,%eax 11b7e5: 85 c9 test %ecx,%ecx 11b7e7: 74 44 je 11b82d rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 11b7e9: 83 e6 02 and $0x2,%esi 11b7ec: 75 0d jne 11b7fb 11b7ee: e8 c1 4a ff ff call 1102b4 <__errno> <== NOT EXECUTED 11b7f3: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11b7f9: eb 15 jmp 11b810 <== NOT EXECUTED /* * Now process the read(). */ if ( !iop->handlers->read_h ) 11b7fb: 8b 43 3c mov 0x3c(%ebx),%eax 11b7fe: 8b 40 08 mov 0x8(%eax),%eax 11b801: 85 c0 test %eax,%eax 11b803: 75 10 jne 11b815 rtems_set_errno_and_return_minus_one( ENOTSUP ); 11b805: e8 aa 4a ff ff call 1102b4 <__errno> <== NOT EXECUTED 11b80a: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11b810: 83 c8 ff or $0xffffffff,%eax 11b813: eb 18 jmp 11b82d rc = (*iop->handlers->read_h)( iop, buffer, count ); 11b815: 56 push %esi 11b816: 51 push %ecx 11b817: 52 push %edx 11b818: 53 push %ebx 11b819: ff d0 call *%eax if ( rc > 0 ) 11b81b: 83 c4 10 add $0x10,%esp 11b81e: 85 c0 test %eax,%eax 11b820: 7e 0b jle 11b82d iop->offset += rc; 11b822: 89 c1 mov %eax,%ecx 11b824: c1 f9 1f sar $0x1f,%ecx 11b827: 01 43 0c add %eax,0xc(%ebx) 11b82a: 11 4b 10 adc %ecx,0x10(%ebx) return rc; } 11b82d: 8d 65 f8 lea -0x8(%ebp),%esp 11b830: 5b pop %ebx 11b831: 5e pop %esi 11b832: c9 leave 11b833: c3 ret 00126770 : ssize_t readlink( const char *pathname, char *buf, size_t bufsize ) { 126770: 55 push %ebp 126771: 89 e5 mov %esp,%ebp 126773: 57 push %edi 126774: 56 push %esi 126775: 53 push %ebx 126776: 83 ec 2c sub $0x2c,%esp 126779: 8b 55 08 mov 0x8(%ebp),%edx 12677c: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_filesystem_location_info_t loc; int result; if (!buf) 12677f: 85 db test %ebx,%ebx 126781: 75 0d jne 126790 rtems_set_errno_and_return_minus_one( EFAULT ); 126783: e8 f0 1f 01 00 call 138778 <__errno> <== NOT EXECUTED 126788: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 12678e: eb 51 jmp 1267e1 <== NOT EXECUTED result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ), 126790: 31 c0 xor %eax,%eax 126792: 83 c9 ff or $0xffffffff,%ecx 126795: 89 d7 mov %edx,%edi 126797: f2 ae repnz scas %es:(%edi),%al 126799: f7 d1 not %ecx 12679b: 49 dec %ecx 12679c: 83 ec 0c sub $0xc,%esp 12679f: 6a 00 push $0x0 1267a1: 8d 75 d4 lea -0x2c(%ebp),%esi 1267a4: 56 push %esi 1267a5: 6a 00 push $0x0 1267a7: 51 push %ecx 1267a8: 52 push %edx 1267a9: e8 1a 4f fe ff call 10b6c8 0, &loc, false ); if ( result != 0 ) 1267ae: 83 c4 20 add $0x20,%esp 1267b1: 83 cf ff or $0xffffffff,%edi 1267b4: 85 c0 test %eax,%eax 1267b6: 0f 85 8c 00 00 00 jne 126848 return -1; if ( !loc.ops->node_type_h ){ 1267bc: 8b 55 e0 mov -0x20(%ebp),%edx 1267bf: 8b 42 10 mov 0x10(%edx),%eax 1267c2: 85 c0 test %eax,%eax 1267c4: 75 20 jne 1267e6 rtems_filesystem_freenode( &loc ); 1267c6: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 1267c9: 85 c0 test %eax,%eax <== NOT EXECUTED 1267cb: 74 09 je 1267d6 <== NOT EXECUTED 1267cd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1267d0: 56 push %esi <== NOT EXECUTED 1267d1: ff d0 call *%eax <== NOT EXECUTED 1267d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1267d6: e8 9d 1f 01 00 call 138778 <__errno> <== NOT EXECUTED 1267db: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1267e1: 83 cf ff or $0xffffffff,%edi 1267e4: eb 62 jmp 126848 } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){ 1267e6: 83 ec 0c sub $0xc,%esp 1267e9: 56 push %esi 1267ea: ff d0 call *%eax 1267ec: 83 c4 10 add $0x10,%esp 1267ef: 83 f8 04 cmp $0x4,%eax 1267f2: 8b 45 e0 mov -0x20(%ebp),%eax 1267f5: 74 21 je 126818 rtems_filesystem_freenode( &loc ); 1267f7: 85 c0 test %eax,%eax 1267f9: 74 10 je 12680b 1267fb: 8b 40 1c mov 0x1c(%eax),%eax 1267fe: 85 c0 test %eax,%eax 126800: 74 09 je 12680b 126802: 83 ec 0c sub $0xc,%esp 126805: 56 push %esi 126806: ff d0 call *%eax 126808: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EINVAL ); 12680b: e8 68 1f 01 00 call 138778 <__errno> 126810: c7 00 16 00 00 00 movl $0x16,(%eax) 126816: eb c9 jmp 1267e1 } if ( !loc.ops->readlink_h ){ 126818: 8b 50 3c mov 0x3c(%eax),%edx 12681b: 85 d2 test %edx,%edx 12681d: 75 05 jne 126824 rtems_filesystem_freenode( &loc ); 12681f: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 126822: eb a5 jmp 1267c9 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); 126824: 50 push %eax 126825: ff 75 10 pushl 0x10(%ebp) 126828: 53 push %ebx 126829: 56 push %esi 12682a: ff d2 call *%edx 12682c: 89 c7 mov %eax,%edi rtems_filesystem_freenode( &loc ); 12682e: 8b 45 e0 mov -0x20(%ebp),%eax 126831: 83 c4 10 add $0x10,%esp 126834: 85 c0 test %eax,%eax 126836: 74 10 je 126848 126838: 8b 40 1c mov 0x1c(%eax),%eax 12683b: 85 c0 test %eax,%eax 12683d: 74 09 je 126848 12683f: 83 ec 0c sub $0xc,%esp 126842: 56 push %esi 126843: ff d0 call *%eax 126845: 83 c4 10 add $0x10,%esp return result; } 126848: 89 f8 mov %edi,%eax 12684a: 8d 65 f4 lea -0xc(%ebp),%esp 12684d: 5b pop %ebx 12684e: 5e pop %esi 12684f: 5f pop %edi 126850: c9 leave 126851: c3 ret 00108cb8 : ssize_t readv( int fd, const struct iovec *iov, int iovcnt ) { 108cb8: 55 push %ebp 108cb9: 89 e5 mov %esp,%ebp 108cbb: 57 push %edi 108cbc: 56 push %esi 108cbd: 53 push %ebx 108cbe: 83 ec 1c sub $0x1c,%esp 108cc1: 8b 75 08 mov 0x8(%ebp),%esi 108cc4: 8b 7d 0c mov 0xc(%ebp),%edi int v; int bytes; rtems_libio_t *iop; bool all_zeros; rtems_libio_check_fd( fd ); 108cc7: 3b 35 44 31 12 00 cmp 0x123144,%esi 108ccd: 73 11 jae 108ce0 iop = rtems_libio_iop( fd ); 108ccf: c1 e6 06 shl $0x6,%esi 108cd2: 03 35 e8 77 12 00 add 0x1277e8,%esi rtems_libio_check_is_open( iop ); 108cd8: 8b 46 14 mov 0x14(%esi),%eax 108cdb: f6 c4 01 test $0x1,%ah 108cde: 75 10 jne 108cf0 108ce0: e8 1f 94 00 00 call 112104 <__errno> <== NOT EXECUTED 108ce5: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 108ceb: e9 80 00 00 00 jmp 108d70 <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 108cf0: a8 02 test $0x2,%al 108cf2: 74 42 je 108d36 /* * Argument validation on IO vector */ if ( !iov ) 108cf4: 85 ff test %edi,%edi 108cf6: 74 3e je 108d36 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt <= 0 ) 108cf8: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 108cfc: 7e 38 jle 108d36 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt > IOV_MAX ) 108cfe: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp) 108d05: 7f 2f jg 108d36 rtems_set_errno_and_return_minus_one( EINVAL ); if ( !iop->handlers->read_h ) 108d07: 8b 46 3c mov 0x3c(%esi),%eax 108d0a: 83 78 08 00 cmpl $0x0,0x8(%eax) 108d0e: 75 0d jne 108d1d rtems_set_errno_and_return_minus_one( ENOTSUP ); 108d10: e8 ef 93 00 00 call 112104 <__errno> <== NOT EXECUTED 108d15: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 108d1b: eb 53 jmp 108d70 <== NOT EXECUTED 108d1d: 31 c0 xor %eax,%eax 108d1f: 31 d2 xor %edx,%edx all_zeros = true; for ( total=0, v=0 ; v < iovcnt ; v++ ) { ssize_t old; if ( !iov[v].iov_base ) 108d21: 83 3c c7 00 cmpl $0x0,(%edi,%eax,8) 108d25: 74 0f je 108d36 rtems_set_errno_and_return_minus_one( EINVAL ); if ( iov[v].iov_len <= 0 ) 108d27: 8b 4c c7 04 mov 0x4(%edi,%eax,8),%ecx 108d2b: 85 c9 test %ecx,%ecx 108d2d: 74 07 je 108d36 rtems_set_errno_and_return_minus_one( EINVAL ); /* check for wrap */ old = total; total += iov[v].iov_len; 108d2f: 8d 0c 0a lea (%edx,%ecx,1),%ecx if ( total < old ) 108d32: 39 d1 cmp %edx,%ecx 108d34: 7d 0d jge 108d43 rtems_set_errno_and_return_minus_one( EINVAL ); 108d36: e8 c9 93 00 00 call 112104 <__errno> 108d3b: c7 00 16 00 00 00 movl $0x16,(%eax) 108d41: eb 2d jmp 108d70 * are obvious errors in the iovec. So this extra loop ensures * that we do not do anything if there is an argument error. */ all_zeros = true; for ( total=0, v=0 ; v < iovcnt ; v++ ) { 108d43: 40 inc %eax 108d44: 3b 45 10 cmp 0x10(%ebp),%eax 108d47: 7d 04 jge 108d4d 108d49: 89 ca mov %ecx,%edx 108d4b: eb d4 jmp 108d21 108d4d: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) 108d54: 31 db xor %ebx,%ebx /* * Now process the readv(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { bytes = (*iop->handlers->read_h)( iop, iov[v].iov_base, iov[v].iov_len ); 108d56: 50 push %eax 108d57: 8b 46 3c mov 0x3c(%esi),%eax 108d5a: 8b 55 e4 mov -0x1c(%ebp),%edx 108d5d: ff 74 d7 04 pushl 0x4(%edi,%edx,8) 108d61: ff 34 d7 pushl (%edi,%edx,8) 108d64: 56 push %esi 108d65: ff 50 08 call *0x8(%eax) if ( bytes < 0 ) 108d68: 83 c4 10 add $0x10,%esp 108d6b: 83 f8 00 cmp $0x0,%eax 108d6e: 7d 05 jge 108d75 108d70: 83 cb ff or $0xffffffff,%ebx 108d73: eb 23 jmp 108d98 return -1; if ( bytes > 0 ) { 108d75: 74 0d je 108d84 iop->offset += bytes; 108d77: 89 c1 mov %eax,%ecx <== NOT EXECUTED 108d79: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 108d7c: 01 46 0c add %eax,0xc(%esi) <== NOT EXECUTED 108d7f: 11 4e 10 adc %ecx,0x10(%esi) <== NOT EXECUTED total += bytes; 108d82: 01 c3 add %eax,%ebx <== NOT EXECUTED } if (bytes != iov[ v ].iov_len) 108d84: 8b 55 e4 mov -0x1c(%ebp),%edx 108d87: 3b 44 d7 04 cmp 0x4(%edi,%edx,8),%eax 108d8b: 75 0b jne 108d98 } /* * Now process the readv(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { 108d8d: 42 inc %edx <== NOT EXECUTED 108d8e: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED 108d91: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 108d94: 39 c2 cmp %eax,%edx <== NOT EXECUTED 108d96: 7c be jl 108d56 <== NOT EXECUTED if (bytes != iov[ v ].iov_len) break; } return total; } 108d98: 89 d8 mov %ebx,%eax 108d9a: 8d 65 f4 lea -0xc(%ebp),%esp 108d9d: 5b pop %ebx 108d9e: 5e pop %esi 108d9f: 5f pop %edi 108da0: c9 leave 108da1: c3 ret 0011b8b4 : { uintptr_t old_size; char *new_area; uintptr_t resize; MSBUMP(realloc_calls, 1); 11b8b4: 55 push %ebp 11b8b5: 89 e5 mov %esp,%ebp 11b8b7: 57 push %edi 11b8b8: 56 push %esi 11b8b9: 53 push %ebx 11b8ba: 83 ec 2c sub $0x2c,%esp 11b8bd: 8b 5d 08 mov 0x8(%ebp),%ebx 11b8c0: 8b 75 0c mov 0xc(%ebp),%esi 11b8c3: ff 05 80 38 12 00 incl 0x123880 /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 11b8c9: 83 3d 4c 3b 12 00 03 cmpl $0x3,0x123b4c 11b8d0: 75 1a jne 11b8ec if (_Thread_Dispatch_disable_level > 0) 11b8d2: a1 b4 39 12 00 mov 0x1239b4,%eax 11b8d7: 85 c0 test %eax,%eax 11b8d9: 0f 85 a7 00 00 00 jne 11b986 return (void *) 0; if (_ISR_Nest_level > 0) 11b8df: a1 4c 3a 12 00 mov 0x123a4c,%eax 11b8e4: 85 c0 test %eax,%eax 11b8e6: 0f 85 9a 00 00 00 jne 11b986 } /* * Continue with realloc(). */ if ( !ptr ) 11b8ec: 85 db test %ebx,%ebx 11b8ee: 75 0e jne 11b8fe return malloc( size ); 11b8f0: 83 ec 0c sub $0xc,%esp 11b8f3: 56 push %esi 11b8f4: e8 b3 ba fe ff call 1073ac 11b8f9: e9 81 00 00 00 jmp 11b97f if ( !size ) { 11b8fe: 85 f6 test %esi,%esi 11b900: 75 0d jne 11b90f free( ptr ); 11b902: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11b905: 53 push %ebx <== NOT EXECUTED 11b906: e8 75 b8 fe ff call 107180 <== NOT EXECUTED 11b90b: 31 db xor %ebx,%ebx <== NOT EXECUTED 11b90d: eb 72 jmp 11b981 <== NOT EXECUTED return (void *) 0; } if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) { 11b90f: 52 push %edx 11b910: 8d 45 e4 lea -0x1c(%ebp),%eax 11b913: 50 push %eax 11b914: 53 push %ebx 11b915: ff 35 90 f9 11 00 pushl 0x11f990 11b91b: e8 00 01 00 00 call 11ba20 <_Protected_heap_Get_block_size> 11b920: 83 c4 10 add $0x10,%esp 11b923: 84 c0 test %al,%al 11b925: 75 0d jne 11b934 errno = EINVAL; 11b927: e8 88 49 ff ff call 1102b4 <__errno> 11b92c: c7 00 16 00 00 00 movl $0x16,(%eax) 11b932: eb 52 jmp 11b986 #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 ) ) { 11b934: 50 push %eax 11b935: 56 push %esi 11b936: 53 push %ebx 11b937: ff 35 90 f9 11 00 pushl 0x11f990 11b93d: e8 16 01 00 00 call 11ba58 <_Protected_heap_Resize_block> 11b942: 83 c4 10 add $0x10,%esp 11b945: 84 c0 test %al,%al 11b947: 75 3f jne 11b988 * 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 ); 11b949: 83 ec 0c sub $0xc,%esp 11b94c: 56 push %esi 11b94d: e8 5a ba fe ff call 1073ac MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ 11b952: ff 0d 74 38 12 00 decl 0x123874 if ( !new_area ) { 11b958: 83 c4 10 add $0x10,%esp 11b95b: 85 c0 test %eax,%eax 11b95d: 74 27 je 11b986 return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 11b95f: 8b 55 e4 mov -0x1c(%ebp),%edx 11b962: 89 f1 mov %esi,%ecx 11b964: 39 d6 cmp %edx,%esi 11b966: 76 02 jbe 11b96a 11b968: 89 d1 mov %edx,%ecx 11b96a: 89 c7 mov %eax,%edi 11b96c: 89 de mov %ebx,%esi 11b96e: f3 a4 rep movsb %ds:(%esi),%es:(%edi) free( ptr ); 11b970: 83 ec 0c sub $0xc,%esp 11b973: 53 push %ebx 11b974: 89 45 d4 mov %eax,-0x2c(%ebp) 11b977: e8 04 b8 fe ff call 107180 11b97c: 8b 45 d4 mov -0x2c(%ebp),%eax 11b97f: 89 c3 mov %eax,%ebx return new_area; 11b981: 83 c4 10 add $0x10,%esp 11b984: eb 02 jmp 11b988 11b986: 31 db xor %ebx,%ebx } 11b988: 89 d8 mov %ebx,%eax 11b98a: 8d 65 f4 lea -0xc(%ebp),%esp 11b98d: 5b pop %ebx 11b98e: 5e pop %esi 11b98f: 5f pop %edi 11b990: c9 leave 11b991: c3 ret 0010c894 : #include int rmdir( const char *pathname ) { 10c894: 55 push %ebp 10c895: 89 e5 mov %esp,%ebp 10c897: 57 push %edi 10c898: 56 push %esi 10c899: 53 push %ebx 10c89a: 83 ec 58 sub $0x58,%esp /* * Get the parent node of the node we wish to remove. Find the parent path. */ parentpathlen = rtems_filesystem_dirname ( pathname ); 10c89d: ff 75 08 pushl 0x8(%ebp) 10c8a0: e8 36 ed ff ff call 10b5db 10c8a5: 89 c2 mov %eax,%edx if ( parentpathlen == 0 ) 10c8a7: 83 c4 10 add $0x10,%esp 10c8aa: 85 c0 test %eax,%eax 10c8ac: 75 36 jne 10c8e4 rtems_filesystem_get_start_loc( pathname, &i, &parentloc ); 10c8ae: 8b 4d 08 mov 0x8(%ebp),%ecx 10c8b1: 8a 01 mov (%ecx),%al 10c8b3: 3c 5c cmp $0x5c,%al 10c8b5: 74 08 je 10c8bf 10c8b7: 3c 2f cmp $0x2f,%al 10c8b9: 74 04 je 10c8bf 10c8bb: 84 c0 test %al,%al <== NOT EXECUTED 10c8bd: 75 0e jne 10c8cd <== NOT EXECUTED 10c8bf: 8d 7d d4 lea -0x2c(%ebp),%edi 10c8c2: 8b 35 dc e1 15 00 mov 0x15e1dc,%esi 10c8c8: 83 c6 18 add $0x18,%esi 10c8cb: eb 0c jmp 10c8d9 10c8cd: 8d 7d d4 lea -0x2c(%ebp),%edi <== NOT EXECUTED 10c8d0: 8b 35 dc e1 15 00 mov 0x15e1dc,%esi <== NOT EXECUTED 10c8d6: 83 c6 04 add $0x4,%esi <== NOT EXECUTED 10c8d9: b9 05 00 00 00 mov $0x5,%ecx 10c8de: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10c8e0: 31 db xor %ebx,%ebx 10c8e2: eb 27 jmp 10c90b else { result = rtems_filesystem_evaluate_path(pathname, parentpathlen, 10c8e4: 83 ec 0c sub $0xc,%esp 10c8e7: 6a 00 push $0x0 10c8e9: 8d 45 d4 lea -0x2c(%ebp),%eax 10c8ec: 50 push %eax 10c8ed: 6a 02 push $0x2 10c8ef: 52 push %edx 10c8f0: ff 75 08 pushl 0x8(%ebp) 10c8f3: 89 55 b4 mov %edx,-0x4c(%ebp) 10c8f6: e8 cd ed ff ff call 10b6c8 RTEMS_LIBIO_PERMS_WRITE, &parentloc, false ); if ( result != 0 ) 10c8fb: 83 c4 20 add $0x20,%esp 10c8fe: 85 c0 test %eax,%eax 10c900: 8b 55 b4 mov -0x4c(%ebp),%edx 10c903: 0f 85 72 01 00 00 jne 10ca7b 10c909: b3 01 mov $0x1,%bl /* * Start from the parent to find the node that should be under it. */ loc = parentloc; 10c90b: 8d 7d c0 lea -0x40(%ebp),%edi 10c90e: 8d 75 d4 lea -0x2c(%ebp),%esi 10c911: b9 05 00 00 00 mov $0x5,%ecx 10c916: f3 a5 rep movsl %ds:(%esi),%es:(%edi) name = pathname + parentpathlen; 10c918: 8b 75 08 mov 0x8(%ebp),%esi 10c91b: 01 d6 add %edx,%esi name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 10c91d: 83 c9 ff or $0xffffffff,%ecx 10c920: 89 f7 mov %esi,%edi 10c922: 31 c0 xor %eax,%eax 10c924: f2 ae repnz scas %es:(%edi),%al 10c926: f7 d1 not %ecx 10c928: 49 dec %ecx 10c929: 57 push %edi 10c92a: 57 push %edi 10c92b: 51 push %ecx 10c92c: 56 push %esi 10c92d: e8 82 ec ff ff call 10b5b4 10c932: 01 c6 add %eax,%esi result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 10c934: 83 c9 ff or $0xffffffff,%ecx 10c937: 89 f7 mov %esi,%edi 10c939: 31 c0 xor %eax,%eax 10c93b: f2 ae repnz scas %es:(%edi),%al 10c93d: f7 d1 not %ecx 10c93f: 49 dec %ecx 10c940: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10c947: 8d 7d c0 lea -0x40(%ebp),%edi 10c94a: 57 push %edi 10c94b: 6a 00 push $0x0 10c94d: 51 push %ecx 10c94e: 56 push %esi 10c94f: e8 ba ec ff ff call 10b60e 0, &loc, false ); if ( result != 0 ) { 10c954: 83 c4 20 add $0x20,%esp 10c957: 85 c0 test %eax,%eax 10c959: 74 2f je 10c98a if ( free_parentloc ) 10c95b: 84 db test %bl,%bl 10c95d: 0f 84 18 01 00 00 je 10ca7b rtems_filesystem_freenode( &parentloc ); 10c963: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10c966: 85 c0 test %eax,%eax <== NOT EXECUTED 10c968: 0f 84 0d 01 00 00 je 10ca7b <== NOT EXECUTED 10c96e: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10c971: 85 c0 test %eax,%eax <== NOT EXECUTED 10c973: 0f 84 02 01 00 00 je 10ca7b <== NOT EXECUTED 10c979: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c97c: 8d 55 d4 lea -0x2c(%ebp),%edx <== NOT EXECUTED 10c97f: 52 push %edx <== NOT EXECUTED 10c980: ff d0 call *%eax <== NOT EXECUTED 10c982: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 10c985: e9 ec 00 00 00 jmp 10ca76 <== NOT EXECUTED /* * Verify you can remove this node as a directory. */ if ( !loc.ops->node_type_h ){ 10c98a: 8b 55 cc mov -0x34(%ebp),%edx 10c98d: 8b 42 10 mov 0x10(%edx),%eax 10c990: 85 c0 test %eax,%eax 10c992: 75 05 jne 10c999 rtems_filesystem_freenode( &loc ); 10c994: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 10c997: eb 65 jmp 10c9fe <== NOT EXECUTED if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ){ 10c999: 83 ec 0c sub $0xc,%esp 10c99c: 57 push %edi 10c99d: ff d0 call *%eax 10c99f: 83 c4 10 add $0x10,%esp 10c9a2: 48 dec %eax 10c9a3: 74 45 je 10c9ea rtems_filesystem_freenode( &loc ); 10c9a5: 8b 45 cc mov -0x34(%ebp),%eax 10c9a8: 85 c0 test %eax,%eax 10c9aa: 74 10 je 10c9bc 10c9ac: 8b 40 1c mov 0x1c(%eax),%eax 10c9af: 85 c0 test %eax,%eax 10c9b1: 74 09 je 10c9bc 10c9b3: 83 ec 0c sub $0xc,%esp 10c9b6: 57 push %edi 10c9b7: ff d0 call *%eax 10c9b9: 83 c4 10 add $0x10,%esp if ( free_parentloc ) 10c9bc: 84 db test %bl,%bl 10c9be: 74 1a je 10c9da rtems_filesystem_freenode( &parentloc ); 10c9c0: 8b 45 e0 mov -0x20(%ebp),%eax 10c9c3: 85 c0 test %eax,%eax 10c9c5: 74 13 je 10c9da 10c9c7: 8b 40 1c mov 0x1c(%eax),%eax 10c9ca: 85 c0 test %eax,%eax 10c9cc: 74 0c je 10c9da 10c9ce: 83 ec 0c sub $0xc,%esp 10c9d1: 8d 55 d4 lea -0x2c(%ebp),%edx 10c9d4: 52 push %edx 10c9d5: ff d0 call *%eax 10c9d7: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( ENOTDIR ); 10c9da: e8 99 bd 02 00 call 138778 <__errno> 10c9df: c7 00 14 00 00 00 movl $0x14,(%eax) 10c9e5: e9 91 00 00 00 jmp 10ca7b /* * Use the filesystems rmnod to remove the node. */ if ( !loc.handlers->rmnod_h ){ 10c9ea: 8b 45 c8 mov -0x38(%ebp),%eax 10c9ed: 8b 40 34 mov 0x34(%eax),%eax 10c9f0: 85 c0 test %eax,%eax 10c9f2: 75 42 jne 10ca36 rtems_filesystem_freenode( &loc ); 10c9f4: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10c9f7: 85 c0 test %eax,%eax <== NOT EXECUTED 10c9f9: 74 10 je 10ca0b <== NOT EXECUTED 10c9fb: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10c9fe: 85 c0 test %eax,%eax <== NOT EXECUTED 10ca00: 74 09 je 10ca0b <== NOT EXECUTED 10ca02: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ca05: 57 push %edi <== NOT EXECUTED 10ca06: ff d0 call *%eax <== NOT EXECUTED 10ca08: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( free_parentloc ) 10ca0b: 84 db test %bl,%bl <== NOT EXECUTED 10ca0d: 74 1a je 10ca29 <== NOT EXECUTED rtems_filesystem_freenode( &parentloc ); 10ca0f: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10ca12: 85 c0 test %eax,%eax <== NOT EXECUTED 10ca14: 74 13 je 10ca29 <== NOT EXECUTED 10ca16: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10ca19: 85 c0 test %eax,%eax <== NOT EXECUTED 10ca1b: 74 0c je 10ca29 <== NOT EXECUTED 10ca1d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ca20: 8d 55 d4 lea -0x2c(%ebp),%edx <== NOT EXECUTED 10ca23: 52 push %edx <== NOT EXECUTED 10ca24: ff d0 call *%eax <== NOT EXECUTED 10ca26: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 10ca29: e8 4a bd 02 00 call 138778 <__errno> <== NOT EXECUTED 10ca2e: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10ca34: eb 45 jmp 10ca7b <== NOT EXECUTED } result = (*loc.handlers->rmnod_h)( &parentloc, &loc ); 10ca36: 52 push %edx 10ca37: 52 push %edx 10ca38: 57 push %edi 10ca39: 8d 55 d4 lea -0x2c(%ebp),%edx 10ca3c: 52 push %edx 10ca3d: ff d0 call *%eax 10ca3f: 89 c6 mov %eax,%esi rtems_filesystem_freenode( &loc ); 10ca41: 8b 45 cc mov -0x34(%ebp),%eax 10ca44: 83 c4 10 add $0x10,%esp 10ca47: 85 c0 test %eax,%eax 10ca49: 74 10 je 10ca5b 10ca4b: 8b 40 1c mov 0x1c(%eax),%eax 10ca4e: 85 c0 test %eax,%eax 10ca50: 74 09 je 10ca5b 10ca52: 83 ec 0c sub $0xc,%esp 10ca55: 57 push %edi 10ca56: ff d0 call *%eax 10ca58: 83 c4 10 add $0x10,%esp if ( free_parentloc ) 10ca5b: 84 db test %bl,%bl 10ca5d: 74 1f je 10ca7e rtems_filesystem_freenode( &parentloc ); 10ca5f: 8b 45 e0 mov -0x20(%ebp),%eax 10ca62: 85 c0 test %eax,%eax 10ca64: 74 18 je 10ca7e 10ca66: 8b 40 1c mov 0x1c(%eax),%eax 10ca69: 85 c0 test %eax,%eax 10ca6b: 74 11 je 10ca7e 10ca6d: 83 ec 0c sub $0xc,%esp 10ca70: 8d 55 d4 lea -0x2c(%ebp),%edx 10ca73: 52 push %edx 10ca74: ff d0 call *%eax 10ca76: 83 c4 10 add $0x10,%esp 10ca79: eb 03 jmp 10ca7e 10ca7b: 83 ce ff or $0xffffffff,%esi return result; } 10ca7e: 89 f0 mov %esi,%eax 10ca80: 8d 65 f4 lea -0xc(%ebp),%esp 10ca83: 5b pop %ebx 10ca84: 5e pop %esi 10ca85: 5f pop %edi 10ca86: c9 leave 10ca87: c3 ret 001158b8 : uint32_t bad_value #else uint32_t bad_value __attribute((unused)) #endif ) { 1158b8: 55 push %ebp <== NOT EXECUTED 1158b9: 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; } 1158bb: b8 08 80 12 00 mov $0x128008,%eax <== NOT EXECUTED 1158c0: c9 leave <== NOT EXECUTED 1158c1: c3 ret <== NOT EXECUTED 00113100 : const char *rtems_assoc_name_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 113100: 55 push %ebp 113101: 89 e5 mov %esp,%ebp 113103: 53 push %ebx 113104: 83 ec 0c sub $0xc,%esp 113107: 8b 5d 0c mov 0xc(%ebp),%ebx const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 11310a: 53 push %ebx 11310b: ff 75 08 pushl 0x8(%ebp) 11310e: e8 1d 00 00 00 call 113130 if (nap) 113113: 83 c4 10 add $0x10,%esp 113116: 85 c0 test %eax,%eax 113118: 74 07 je 113121 return nap->name; 11311a: 8b 00 mov (%eax),%eax return rtems_assoc_name_bad(local_value); } 11311c: 8b 5d fc mov -0x4(%ebp),%ebx 11311f: c9 leave 113120: c3 ret nap = rtems_assoc_ptr_by_local(ap, local_value); if (nap) return nap->name; return rtems_assoc_name_bad(local_value); 113121: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 113124: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 113127: 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); 113128: e9 8b 27 00 00 jmp 1158b8 <== NOT EXECUTED 00110254 : const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 110254: 55 push %ebp 110255: 89 e5 mov %esp,%ebp 110257: 56 push %esi 110258: 53 push %ebx 110259: 8b 5d 08 mov 0x8(%ebp),%ebx 11025c: 8b 75 0c mov 0xc(%ebp),%esi const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 11025f: 8b 03 mov (%ebx),%eax 110261: 85 c0 test %eax,%eax 110263: 74 1b je 110280 110265: 52 push %edx 110266: 52 push %edx 110267: 68 d5 db 11 00 push $0x11dbd5 11026c: 50 push %eax 11026d: e8 5e 0b 00 00 call 110dd0 110272: 83 c4 10 add $0x10,%esp 110275: 85 c0 test %eax,%eax 110277: 75 07 jne 110280 default_ap = ap++; 110279: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11027b: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 11027e: eb 0c jmp 11028c <== NOT EXECUTED 110280: 31 c0 xor %eax,%eax 110282: eb 08 jmp 11028c for ( ; ap->name; ap++) if (ap->local_value == local_value) 110284: 39 73 04 cmp %esi,0x4(%ebx) 110287: 74 0a je 110293 const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 110289: 83 c3 0c add $0xc,%ebx 11028c: 83 3b 00 cmpl $0x0,(%ebx) 11028f: 75 f3 jne 110284 110291: 89 c3 mov %eax,%ebx if (ap->local_value == local_value) return ap; return default_ap; } 110293: 89 d8 mov %ebx,%eax 110295: 8d 65 f8 lea -0x8(%ebp),%esp 110298: 5b pop %ebx 110299: 5e pop %esi 11029a: c9 leave 11029b: c3 ret 0010f850 : const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 10f850: 55 push %ebp 10f851: 89 e5 mov %esp,%ebp 10f853: 56 push %esi 10f854: 53 push %ebx 10f855: 8b 5d 08 mov 0x8(%ebp),%ebx 10f858: 8b 75 0c mov 0xc(%ebp),%esi const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 10f85b: 8b 03 mov (%ebx),%eax 10f85d: 85 c0 test %eax,%eax 10f85f: 74 1b je 10f87c 10f861: 52 push %edx 10f862: 52 push %edx 10f863: 68 d5 db 11 00 push $0x11dbd5 10f868: 50 push %eax 10f869: e8 62 15 00 00 call 110dd0 10f86e: 83 c4 10 add $0x10,%esp 10f871: 85 c0 test %eax,%eax 10f873: 75 07 jne 10f87c default_ap = ap++; 10f875: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10f877: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 10f87a: eb 0c jmp 10f888 <== NOT EXECUTED 10f87c: 31 c0 xor %eax,%eax 10f87e: eb 08 jmp 10f888 for ( ; ap->name; ap++) if (ap->remote_value == remote_value) 10f880: 39 73 08 cmp %esi,0x8(%ebx) 10f883: 74 0a je 10f88f const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 10f885: 83 c3 0c add $0xc,%ebx 10f888: 83 3b 00 cmpl $0x0,(%ebx) 10f88b: 75 f3 jne 10f880 10f88d: 89 c3 mov %eax,%ebx if (ap->remote_value == remote_value) return ap; return default_ap; } 10f88f: 89 d8 mov %ebx,%eax 10f891: 8d 65 f8 lea -0x8(%ebp),%esp 10f894: 5b pop %ebx 10f895: 5e pop %esi 10f896: c9 leave 10f897: c3 ret 00110008 : uint32_t rtems_assoc_remote_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 110008: 55 push %ebp <== NOT EXECUTED 110009: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11000b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 11000e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 110011: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 110014: e8 3b 02 00 00 call 110254 <== NOT EXECUTED 110019: 89 c2 mov %eax,%edx <== NOT EXECUTED if (nap) 11001b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11001e: 31 c0 xor %eax,%eax <== NOT EXECUTED 110020: 85 d2 test %edx,%edx <== NOT EXECUTED 110022: 74 03 je 110027 <== NOT EXECUTED return nap->remote_value; 110024: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED return 0; } 110027: c9 leave <== NOT EXECUTED 110028: c3 ret <== NOT EXECUTED 0010717c : const char *rtems_bsp_cmdline_get_param( const char *name, char *value, size_t length ) { 10717c: 55 push %ebp 10717d: 89 e5 mov %esp,%ebp 10717f: 57 push %edi 107180: 56 push %esi 107181: 53 push %ebx 107182: 83 ec 0c sub $0xc,%esp 107185: 8b 45 08 mov 0x8(%ebp),%eax 107188: 8b 5d 0c mov 0xc(%ebp),%ebx 10718b: 8b 75 10 mov 0x10(%ebp),%esi const char *p; if ( !name ) 10718e: 85 c0 test %eax,%eax 107190: 74 4c je 1071de return NULL; if ( !value ) 107192: 85 db test %ebx,%ebx 107194: 74 4a je 1071e0 return NULL; if ( !length ) 107196: 85 f6 test %esi,%esi 107198: 74 44 je 1071de return NULL; value[0] = '\0'; 10719a: c6 03 00 movb $0x0,(%ebx) p = rtems_bsp_cmdline_get_param_raw( name ); 10719d: 83 ec 0c sub $0xc,%esp 1071a0: 50 push %eax 1071a1: e8 46 00 00 00 call 1071ec if ( !p ) 1071a6: 83 c4 10 add $0x10,%esp 1071a9: 85 c0 test %eax,%eax 1071ab: 74 31 je 1071de 1071ad: 31 ff xor %edi,%edi 1071af: 31 d2 xor %edx,%edx int i; int quotes; const char *p = start; quotes=0; for (i=0 ; *p && i if ( *p == '\"' ) { 1071b4: 80 f9 22 cmp $0x22,%cl 1071b7: 75 03 jne 1071bc quotes++; 1071b9: 47 inc %edi <== NOT EXECUTED 1071ba: eb 0d jmp 1071c9 <== NOT EXECUTED } else if ( ((quotes % 2) == 0) && *p == ' ' ) 1071bc: f7 c7 01 00 00 00 test $0x1,%edi 1071c2: 75 05 jne 1071c9 1071c4: 80 f9 20 cmp $0x20,%cl 1071c7: 74 17 je 1071e0 break; value[i++] = *p++; 1071c9: 88 0c 13 mov %cl,(%ebx,%edx,1) 1071cc: 42 inc %edx value[i] = '\0'; 1071cd: c6 04 13 00 movb $0x0,(%ebx,%edx,1) int i; int quotes; const char *p = start; quotes=0; for (i=0 ; *p && i 1071d8: 39 f2 cmp %esi,%edx 1071da: 72 d8 jb 1071b4 1071dc: eb 02 jmp 1071e0 <== NOT EXECUTED 1071de: 31 db xor %ebx,%ebx return NULL; copy_string( p, value, length ); return value; } 1071e0: 89 d8 mov %ebx,%eax 1071e2: 8d 65 f4 lea -0xc(%ebp),%esp 1071e5: 5b pop %ebx 1071e6: 5e pop %esi 1071e7: 5f pop %edi 1071e8: c9 leave 1071e9: c3 ret 00107214 : const char *rtems_bsp_cmdline_get_param_rhs( const char *name, char *value, size_t length ) { 107214: 55 push %ebp <== NOT EXECUTED 107215: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107217: 57 push %edi <== NOT EXECUTED 107218: 53 push %ebx <== NOT EXECUTED 107219: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10721c: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED const char *p; const char *rhs; char *d; p = rtems_bsp_cmdline_get_param( name, value, length ); 10721f: 50 push %eax <== NOT EXECUTED 107220: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 107223: 53 push %ebx <== NOT EXECUTED 107224: 57 push %edi <== NOT EXECUTED 107225: e8 52 ff ff ff call 10717c <== NOT EXECUTED 10722a: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !p ) 10722c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10722f: 85 c0 test %eax,%eax <== NOT EXECUTED 107231: 74 3c je 10726f <== NOT EXECUTED return NULL; rhs = &p[strlen(name)]; 107233: 31 c0 xor %eax,%eax <== NOT EXECUTED 107235: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 107238: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 10723a: f7 d1 not %ecx <== NOT EXECUTED 10723c: 8d 44 0a ff lea -0x1(%edx,%ecx,1),%eax <== NOT EXECUTED if ( *rhs != '=' ) 107240: 80 38 3d cmpb $0x3d,(%eax) <== NOT EXECUTED 107243: 75 2a jne 10726f <== NOT EXECUTED return NULL; rhs++; 107245: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED if ( *rhs == '\"' ) 107248: 80 78 01 22 cmpb $0x22,0x1(%eax) <== NOT EXECUTED 10724c: 75 03 jne 107251 <== NOT EXECUTED rhs++; 10724e: 8d 50 02 lea 0x2(%eax),%edx <== NOT EXECUTED 107251: 89 d8 mov %ebx,%eax <== NOT EXECUTED 107253: eb 04 jmp 107259 <== NOT EXECUTED for ( d=value ; *rhs ; ) *d++ = *rhs++; 107255: 88 08 mov %cl,(%eax) <== NOT EXECUTED 107257: 40 inc %eax <== NOT EXECUTED 107258: 42 inc %edx <== NOT EXECUTED return NULL; rhs++; if ( *rhs == '\"' ) rhs++; for ( d=value ; *rhs ; ) 107259: 8a 0a mov (%edx),%cl <== NOT EXECUTED 10725b: 84 c9 test %cl,%cl <== NOT EXECUTED 10725d: 75 f6 jne 107255 <== NOT EXECUTED *d++ = *rhs++; if ( *(d-1) == '\"' ) 10725f: 8d 50 ff lea -0x1(%eax),%edx <== NOT EXECUTED 107262: 80 78 ff 22 cmpb $0x22,-0x1(%eax) <== NOT EXECUTED 107266: 75 02 jne 10726a <== NOT EXECUTED 107268: 89 d0 mov %edx,%eax <== NOT EXECUTED d--; *d = '\0'; 10726a: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED return value; 10726d: eb 02 jmp 107271 <== NOT EXECUTED 10726f: 31 db xor %ebx,%ebx <== NOT EXECUTED } 107271: 89 d8 mov %ebx,%eax <== NOT EXECUTED 107273: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 107276: 5b pop %ebx <== NOT EXECUTED 107277: 5f pop %edi <== NOT EXECUTED 107278: c9 leave <== NOT EXECUTED 107279: c3 ret <== NOT EXECUTED 0010ffdc : { 0, 0, 0 }, }; int rtems_deviceio_errno(rtems_status_code code) { 10ffdc: 55 push %ebp <== NOT EXECUTED 10ffdd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ffdf: 53 push %ebx <== NOT EXECUTED 10ffe0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED int rc; if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t ) code))) 10ffe3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ffe6: 68 60 dc 11 00 push $0x11dc60 <== NOT EXECUTED 10ffeb: e8 18 00 00 00 call 110008 <== NOT EXECUTED 10fff0: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10fff2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fff5: 85 c0 test %eax,%eax <== NOT EXECUTED 10fff7: 74 07 je 110000 <== NOT EXECUTED { errno = rc; 10fff9: e8 b6 02 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10fffe: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return -1; } return -1; } 110000: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 110003: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110006: c9 leave <== NOT EXECUTED 110007: c3 ret <== NOT EXECUTED 0010b4b7 : int rtems_error( rtems_error_code_t error_flag, const char *printf_format, ... ) { 10b4b7: 55 push %ebp <== NOT EXECUTED 10b4b8: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4ba: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED * printf(3) format string, with its concommitant arguments. * * Returns the number of characters written. */ int rtems_error( 10b4bd: 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); 10b4c0: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10b4c3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b4c6: e8 6a fe ff ff call 10b335 <== NOT EXECUTED va_end(arglist); return chars_written; } 10b4cb: c9 leave <== NOT EXECUTED 10b4cc: c3 ret <== NOT EXECUTED 001070d8 : int pathnamelen, int flags, rtems_filesystem_location_info_t *pathloc, int follow_link ) { 1070d8: 55 push %ebp 1070d9: 89 e5 mov %esp,%ebp 1070db: 57 push %edi 1070dc: 56 push %esi 1070dd: 53 push %ebx 1070de: 83 ec 1c sub $0x1c,%esp 1070e1: 8b 55 08 mov 0x8(%ebp),%edx 1070e4: 8b 45 0c mov 0xc(%ebp),%eax 1070e7: 89 45 e4 mov %eax,-0x1c(%ebp) 1070ea: 8b 45 10 mov 0x10(%ebp),%eax 1070ed: 89 45 e0 mov %eax,-0x20(%ebp) 1070f0: 8b 45 14 mov 0x14(%ebp),%eax 1070f3: 8b 5d 18 mov 0x18(%ebp),%ebx /* * Verify Input parameters. */ if ( !pathname ) 1070f6: 85 d2 test %edx,%edx 1070f8: 75 0d jne 107107 rtems_set_errno_and_return_minus_one( EFAULT ); 1070fa: e8 b5 91 00 00 call 1102b4 <__errno> 1070ff: c7 00 0e 00 00 00 movl $0xe,(%eax) 107105: eb 6e jmp 107175 if ( !pathloc ) 107107: 85 c0 test %eax,%eax 107109: 75 0d jne 107118 rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */ 10710b: e8 a4 91 00 00 call 1102b4 <__errno> <== NOT EXECUTED 107110: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 107116: eb 5d jmp 107175 <== NOT EXECUTED /* * Evaluate the path using the optable evalpath. */ rtems_filesystem_get_start_loc( pathname, &i, pathloc ); 107118: 8a 0a mov (%edx),%cl 10711a: 80 f9 5c cmp $0x5c,%cl 10711d: 74 09 je 107128 10711f: 80 f9 2f cmp $0x2f,%cl 107122: 74 04 je 107128 107124: 84 c9 test %cl,%cl 107126: 75 16 jne 10713e 107128: 8b 35 88 17 12 00 mov 0x121788,%esi 10712e: 83 c6 18 add $0x18,%esi 107131: b9 05 00 00 00 mov $0x5,%ecx 107136: 89 c7 mov %eax,%edi 107138: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10713a: b1 01 mov $0x1,%cl 10713c: eb 12 jmp 107150 10713e: 8b 35 88 17 12 00 mov 0x121788,%esi 107144: 83 c6 04 add $0x4,%esi 107147: b9 05 00 00 00 mov $0x5,%ecx 10714c: 89 c7 mov %eax,%edi 10714e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * We evaluation the path relative to the start location we get got. */ return rtems_filesystem_evaluate_relative_path( &pathname[i], 107150: 89 5d 18 mov %ebx,0x18(%ebp) 107153: 89 45 14 mov %eax,0x14(%ebp) 107156: 8b 45 e0 mov -0x20(%ebp),%eax 107159: 89 45 10 mov %eax,0x10(%ebp) 10715c: 8b 45 e4 mov -0x1c(%ebp),%eax 10715f: 29 c8 sub %ecx,%eax 107161: 89 45 0c mov %eax,0xc(%ebp) 107164: 01 ca add %ecx,%edx 107166: 89 55 08 mov %edx,0x8(%ebp) pathnamelen - i, flags, pathloc, follow_link ); } 107169: 83 c4 1c add $0x1c,%esp 10716c: 5b pop %ebx 10716d: 5e pop %esi 10716e: 5f pop %edi 10716f: c9 leave rtems_filesystem_get_start_loc( pathname, &i, pathloc ); /* * We evaluation the path relative to the start location we get got. */ return rtems_filesystem_evaluate_relative_path( &pathname[i], 107170: e9 a9 fe ff ff jmp 10701e pathnamelen - i, flags, pathloc, follow_link ); } 107175: 83 c8 ff or $0xffffffff,%eax 107178: 83 c4 1c add $0x1c,%esp 10717b: 5b pop %ebx 10717c: 5e pop %esi 10717d: 5f pop %edi 10717e: c9 leave 10717f: c3 ret 0010701e : int pathnamelen, int flags, rtems_filesystem_location_info_t *pathloc, int follow_link ) { 10701e: 55 push %ebp 10701f: 89 e5 mov %esp,%ebp 107021: 57 push %edi 107022: 56 push %esi 107023: 53 push %ebx 107024: 83 ec 1c sub $0x1c,%esp 107027: 8b 4d 08 mov 0x8(%ebp),%ecx 10702a: 8b 75 0c mov 0xc(%ebp),%esi 10702d: 8b 7d 10 mov 0x10(%ebp),%edi 107030: 8b 5d 14 mov 0x14(%ebp),%ebx 107033: 8b 55 18 mov 0x18(%ebp),%edx /* * Verify Input parameters. */ if ( !pathname ) 107036: 85 c9 test %ecx,%ecx 107038: 75 0d jne 107047 rtems_set_errno_and_return_minus_one( EFAULT ); 10703a: e8 75 92 00 00 call 1102b4 <__errno> <== NOT EXECUTED 10703f: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 107045: eb 0f jmp 107056 <== NOT EXECUTED if ( !pathloc ) 107047: 85 db test %ebx,%ebx 107049: 75 10 jne 10705b rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */ 10704b: e8 64 92 00 00 call 1102b4 <__errno> <== NOT EXECUTED 107050: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 107056: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 107059: eb 73 jmp 1070ce <== NOT EXECUTED if ( !pathloc->ops->evalpath_h ) 10705b: 8b 43 0c mov 0xc(%ebx),%eax 10705e: 8b 00 mov (%eax),%eax 107060: 85 c0 test %eax,%eax 107062: 74 4e je 1070b2 rtems_set_errno_and_return_minus_one( ENOTSUP ); result = (*pathloc->ops->evalpath_h)( pathname, pathnamelen, flags, pathloc ); 107064: 53 push %ebx 107065: 57 push %edi 107066: 56 push %esi 107067: 51 push %ecx 107068: 89 55 e4 mov %edx,-0x1c(%ebp) 10706b: ff d0 call *%eax 10706d: 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 ) { 10706f: 83 c4 10 add $0x10,%esp 107072: 85 c0 test %eax,%eax 107074: 8b 55 e4 mov -0x1c(%ebp),%edx 107077: 75 55 jne 1070ce 107079: 85 d2 test %edx,%edx 10707b: 74 51 je 1070ce if ( !pathloc->ops->node_type_h ){ 10707d: 8b 53 0c mov 0xc(%ebx),%edx 107080: 8b 42 10 mov 0x10(%edx),%eax 107083: 85 c0 test %eax,%eax 107085: 74 1b je 1070a2 rtems_filesystem_freenode( pathloc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } type = (*pathloc->ops->node_type_h)( pathloc ); 107087: 83 ec 0c sub $0xc,%esp 10708a: 53 push %ebx 10708b: ff d0 call *%eax if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) || 10708d: 83 e8 03 sub $0x3,%eax 107090: 83 c4 10 add $0x10,%esp 107093: 83 f8 01 cmp $0x1,%eax 107096: 77 36 ja 1070ce ( type == RTEMS_FILESYSTEM_SYM_LINK ) ) { if ( !pathloc->ops->eval_link_h ){ 107098: 8b 53 0c mov 0xc(%ebx),%edx 10709b: 8b 42 34 mov 0x34(%edx),%eax 10709e: 85 c0 test %eax,%eax 1070a0: 75 1d jne 1070bf rtems_filesystem_freenode( pathloc ); 1070a2: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 1070a5: 85 c0 test %eax,%eax <== NOT EXECUTED 1070a7: 74 09 je 1070b2 <== NOT EXECUTED 1070a9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1070ac: 53 push %ebx <== NOT EXECUTED 1070ad: ff d0 call *%eax <== NOT EXECUTED 1070af: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1070b2: e8 fd 91 00 00 call 1102b4 <__errno> <== NOT EXECUTED 1070b7: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1070bd: eb 97 jmp 107056 <== 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 ); 1070bf: 89 7d 0c mov %edi,0xc(%ebp) 1070c2: 89 5d 08 mov %ebx,0x8(%ebp) } } return result; } 1070c5: 8d 65 f4 lea -0xc(%ebp),%esp 1070c8: 5b pop %ebx 1070c9: 5e pop %esi 1070ca: 5f pop %edi 1070cb: 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 ); 1070cc: ff e0 jmp *%eax } } return result; } 1070ce: 89 f0 mov %esi,%eax 1070d0: 8d 65 f4 lea -0xc(%ebp),%esp 1070d3: 5b pop %ebx 1070d4: 5e pop %esi 1070d5: 5f pop %edi 1070d6: c9 leave 1070d7: c3 ret 00106ecc : * configuration is a single instantiation of the IMFS or miniIMFS with * a single "/dev" directory in it. */ void rtems_filesystem_initialize( void ) { 106ecc: 55 push %ebp 106ecd: 89 e5 mov %esp,%ebp 106ecf: 57 push %edi 106ed0: 56 push %esi 106ed1: 53 push %ebx 106ed2: 83 ec 2c sub $0x2c,%esp /* * Set the default umask to "022". */ rtems_filesystem_umask = 022; 106ed5: a1 88 17 12 00 mov 0x121788,%eax 106eda: c7 40 2c 12 00 00 00 movl $0x12,0x2c(%eax) init_fs_mount_table(); 106ee1: e8 76 06 00 00 call 10755c /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) 106ee6: 83 3d 88 be 11 00 00 cmpl $0x0,0x11be88 106eed: 75 0a jne 106ef9 rtems_fatal_error_occurred( 0xABCD0001 ); 106eef: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106ef2: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED 106ef7: eb 2a jmp 106f23 <== NOT EXECUTED mt = &rtems_filesystem_mount_table[0]; 106ef9: a1 8c f9 11 00 mov 0x11f98c,%eax status = mount( 106efe: 83 ec 0c sub $0xc,%esp 106f01: ff 70 0c pushl 0xc(%eax) 106f04: ff 70 08 pushl 0x8(%eax) 106f07: ff 70 04 pushl 0x4(%eax) 106f0a: ff 30 pushl (%eax) 106f0c: 8d 45 e4 lea -0x1c(%ebp),%eax 106f0f: 50 push %eax 106f10: e8 6c 06 00 00 call 107581 &entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point ); if ( status == -1 ) 106f15: 83 c4 20 add $0x20,%esp 106f18: 40 inc %eax 106f19: 75 0d jne 106f28 rtems_fatal_error_occurred( 0xABCD0002 ); 106f1b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106f1e: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED 106f23: e8 0c 36 00 00 call 10a534 <== NOT EXECUTED rtems_filesystem_link_counts = 0; 106f28: 8b 3d 88 17 12 00 mov 0x121788,%edi 106f2e: 66 c7 47 30 00 00 movw $0x0,0x30(%edi) * set_private_env() - but then: that's * gonna hit performance. * * Till Straumann, 10/25/2002 */ rtems_filesystem_root = entry->mt_fs_root; 106f34: 83 c7 18 add $0x18,%edi 106f37: 8b 75 e4 mov -0x1c(%ebp),%esi 106f3a: 83 c6 1c add $0x1c,%esi 106f3d: b9 05 00 00 00 mov $0x5,%ecx 106f42: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0); 106f44: 83 ec 0c sub $0xc,%esp 106f47: 6a 00 push $0x0 106f49: 8d 5d d0 lea -0x30(%ebp),%ebx 106f4c: 53 push %ebx 106f4d: 6a 00 push $0x0 106f4f: 6a 01 push $0x1 106f51: 68 62 d5 11 00 push $0x11d562 106f56: e8 7d 01 00 00 call 1070d8 rtems_filesystem_root = loc; 106f5b: 8b 3d 88 17 12 00 mov 0x121788,%edi 106f61: 83 c7 18 add $0x18,%edi 106f64: b9 05 00 00 00 mov $0x5,%ecx 106f69: 89 de mov %ebx,%esi 106f6b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0); 106f6d: 83 c4 14 add $0x14,%esp 106f70: 6a 00 push $0x0 106f72: 53 push %ebx 106f73: 6a 00 push $0x0 106f75: 6a 01 push $0x1 106f77: 68 62 d5 11 00 push $0x11d562 106f7c: e8 57 01 00 00 call 1070d8 rtems_filesystem_current = loc; 106f81: 8b 3d 88 17 12 00 mov 0x121788,%edi 106f87: 83 c7 04 add $0x4,%edi 106f8a: b9 05 00 00 00 mov $0x5,%ecx 106f8f: 89 de mov %ebx,%esi 106f91: 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); 106f93: 83 c4 18 add $0x18,%esp 106f96: 68 ff 01 00 00 push $0x1ff 106f9b: 68 64 d5 11 00 push $0x11d564 106fa0: e8 ab 04 00 00 call 107450 if ( status != 0 ) 106fa5: 83 c4 10 add $0x10,%esp 106fa8: 85 c0 test %eax,%eax 106faa: 74 0d je 106fb9 rtems_fatal_error_occurred( 0xABCD0003 ); 106fac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106faf: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED 106fb4: e9 6a ff ff ff jmp 106f23 <== NOT EXECUTED * it will be mounted onto is created. Moreover, if it is going to * use a device, then it is REALLY unfair to attempt this * before device drivers are initialized. So we return via a base * filesystem image and nothing auto-mounted at this point. */ } 106fb9: 8d 65 f4 lea -0xc(%ebp),%esp 106fbc: 5b pop %ebx 106fbd: 5e pop %esi 106fbe: 5f pop %edi 106fbf: c9 leave 106fc0: c3 ret 0010e668 : ); bool rtems_filesystem_nodes_equal( const rtems_filesystem_location_info_t *loc1, const rtems_filesystem_location_info_t *loc2 ){ 10e668: 55 push %ebp <== NOT EXECUTED 10e669: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e66b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e66e: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10e670: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e673: 3b 10 cmp (%eax),%edx <== NOT EXECUTED 10e675: 0f 94 c0 sete %al <== NOT EXECUTED return ( loc1->node_access == loc2->node_access ); } 10e678: c9 leave <== NOT EXECUTED 10e679: c3 ret <== NOT EXECUTED 00106d80 : rtems_status_code rtems_io_lookup_name( const char *name, rtems_driver_name_t *device_info ) { 106d80: 55 push %ebp <== NOT EXECUTED 106d81: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106d83: 57 push %edi <== NOT EXECUTED 106d84: 56 push %esi <== NOT EXECUTED 106d85: 53 push %ebx <== NOT EXECUTED 106d86: 83 ec 48 sub $0x48,%esp <== NOT EXECUTED 106d89: 8b 55 0c mov 0xc(%ebp),%edx <== 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, strlen( name ), 0x00, &loc, true ); 106d8c: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 106d8f: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 106d92: 31 c0 xor %eax,%eax <== NOT EXECUTED 106d94: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 106d96: f7 d1 not %ecx <== NOT EXECUTED 106d98: 49 dec %ecx <== NOT EXECUTED 106d99: 6a 01 push $0x1 <== NOT EXECUTED 106d9b: 8d 75 d4 lea -0x2c(%ebp),%esi <== NOT EXECUTED 106d9e: 56 push %esi <== NOT EXECUTED 106d9f: 6a 00 push $0x0 <== NOT EXECUTED 106da1: 51 push %ecx <== NOT EXECUTED 106da2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106da5: 89 55 c4 mov %edx,-0x3c(%ebp) <== NOT EXECUTED 106da8: e8 2b 03 00 00 call 1070d8 <== NOT EXECUTED 106dad: 89 c7 mov %eax,%edi <== NOT EXECUTED the_jnode = loc.node_access; 106daf: 8b 5d d4 mov -0x2c(%ebp),%ebx <== NOT EXECUTED if ( !loc.ops->node_type_h ) { 106db2: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED 106db5: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED 106db8: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 106dbb: 85 c0 test %eax,%eax <== NOT EXECUTED 106dbd: 8b 55 c4 mov -0x3c(%ebp),%edx <== NOT EXECUTED 106dc0: 75 20 jne 106de2 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 106dc2: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 106dc5: 85 c0 test %eax,%eax <== NOT EXECUTED 106dc7: 74 09 je 106dd2 <== NOT EXECUTED 106dc9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106dcc: 56 push %esi <== NOT EXECUTED 106dcd: ff d0 call *%eax <== NOT EXECUTED 106dcf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 106dd2: e8 dd 94 00 00 call 1102b4 <__errno> <== NOT EXECUTED 106dd7: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 106ddd: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 106de0: eb 7b jmp 106e5d <== NOT EXECUTED } node_type = (*loc.ops->node_type_h)( &loc ); 106de2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106de5: 56 push %esi <== NOT EXECUTED 106de6: 89 55 c4 mov %edx,-0x3c(%ebp) <== NOT EXECUTED 106de9: ff d0 call *%eax <== NOT EXECUTED if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) { 106deb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106dee: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 106df1: 8b 55 c4 mov -0x3c(%ebp),%edx <== NOT EXECUTED 106df4: 75 04 jne 106dfa <== NOT EXECUTED 106df6: 85 ff test %edi,%edi <== NOT EXECUTED 106df8: 74 1e je 106e18 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 106dfa: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 106dfd: 85 c0 test %eax,%eax <== NOT EXECUTED 106dff: 74 53 je 106e54 <== NOT EXECUTED 106e01: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 106e04: 85 c0 test %eax,%eax <== NOT EXECUTED 106e06: 74 4c je 106e54 <== NOT EXECUTED 106e08: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106e0b: 8d 55 d4 lea -0x2c(%ebp),%edx <== NOT EXECUTED 106e0e: 52 push %edx <== NOT EXECUTED 106e0f: ff d0 call *%eax <== NOT EXECUTED 106e11: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 106e16: eb 37 jmp 106e4f <== NOT EXECUTED return RTEMS_UNSATISFIED; } device_info->device_name = (char *) name; 106e18: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 106e1b: 89 02 mov %eax,(%edx) <== NOT EXECUTED device_info->device_name_length = strlen( name ); 106e1d: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 106e20: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 106e23: 31 c0 xor %eax,%eax <== NOT EXECUTED 106e25: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 106e27: f7 d1 not %ecx <== NOT EXECUTED 106e29: 49 dec %ecx <== NOT EXECUTED 106e2a: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED device_info->major = the_jnode->info.device.major; 106e2d: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 106e30: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED device_info->minor = the_jnode->info.device.minor; 106e33: 8b 43 54 mov 0x54(%ebx),%eax <== NOT EXECUTED 106e36: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 106e39: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 106e3c: 85 c0 test %eax,%eax <== NOT EXECUTED 106e3e: 74 1b je 106e5b <== NOT EXECUTED 106e40: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 106e43: 85 c0 test %eax,%eax <== NOT EXECUTED 106e45: 74 14 je 106e5b <== NOT EXECUTED 106e47: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106e4a: 56 push %esi <== NOT EXECUTED 106e4b: ff d0 call *%eax <== NOT EXECUTED 106e4d: 31 c0 xor %eax,%eax <== NOT EXECUTED 106e4f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106e52: eb 09 jmp 106e5d <== NOT EXECUTED 106e54: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 106e59: eb 02 jmp 106e5d <== NOT EXECUTED 106e5b: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 106e5d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106e60: 5b pop %ebx <== NOT EXECUTED 106e61: 5e pop %esi <== NOT EXECUTED 106e62: 5f pop %edi <== NOT EXECUTED 106e63: c9 leave <== NOT EXECUTED 106e64: c3 ret <== NOT EXECUTED 001071f8 : * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) { 1071f8: 55 push %ebp 1071f9: 89 e5 mov %esp,%ebp 1071fb: 53 push %ebx 1071fc: 83 ec 04 sub $0x4,%esp rtems_status_code rc; uint32_t i; rtems_libio_t *iop; if (rtems_libio_number_iops > 0) 1071ff: a1 84 f9 11 00 mov 0x11f984,%eax 107204: 85 c0 test %eax,%eax 107206: 74 40 je 107248 { rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, 107208: 52 push %edx 107209: 52 push %edx 10720a: 6a 40 push $0x40 10720c: 50 push %eax 10720d: e8 ca 68 00 00 call 10dadc 107212: a3 58 38 12 00 mov %eax,0x123858 sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) 107217: 83 c4 10 add $0x10,%esp 10721a: 85 c0 test %eax,%eax 10721c: 75 07 jne 107225 rtems_fatal_error_occurred(RTEMS_NO_MEMORY); 10721e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107221: 6a 1a push $0x1a <== NOT EXECUTED 107223: eb 46 jmp 10726b <== NOT EXECUTED iop = rtems_libio_iop_freelist = rtems_libio_iops; 107225: a3 5c 38 12 00 mov %eax,0x12385c for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++) 10722a: 8b 1d 84 f9 11 00 mov 0x11f984,%ebx 107230: 31 d2 xor %edx,%edx 107232: eb 03 jmp 107237 iop->data1 = iop + 1; 107234: 89 40 f4 mov %eax,-0xc(%eax) 107237: 89 c1 mov %eax,%ecx sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) rtems_fatal_error_occurred(RTEMS_NO_MEMORY); iop = rtems_libio_iop_freelist = rtems_libio_iops; for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++) 107239: 42 inc %edx 10723a: 83 c0 40 add $0x40,%eax 10723d: 39 da cmp %ebx,%edx 10723f: 72 f3 jb 107234 iop->data1 = iop + 1; iop->data1 = NULL; 107241: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) /* * Create the binary semaphore used to provide mutual exclusion * on the IOP Table. */ rc = rtems_semaphore_create( 107248: 83 ec 0c sub $0xc,%esp 10724b: 68 60 38 12 00 push $0x123860 107250: 6a 00 push $0x0 107252: 6a 54 push $0x54 107254: 6a 01 push $0x1 107256: 68 4f 49 42 4c push $0x4c42494f 10725b: e8 f0 2a 00 00 call 109d50 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_libio_semaphore ); if ( rc != RTEMS_SUCCESSFUL ) 107260: 83 c4 20 add $0x20,%esp 107263: 85 c0 test %eax,%eax 107265: 74 09 je 107270 rtems_fatal_error_occurred( rc ); 107267: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10726a: 50 push %eax <== NOT EXECUTED 10726b: e8 c4 32 00 00 call 10a534 <== NOT EXECUTED /* * Initialize the base file system infrastructure. */ if (rtems_fs_init_helper) 107270: a1 80 f9 11 00 mov 0x11f980,%eax 107275: 85 c0 test %eax,%eax 107277: 74 06 je 10727f (* rtems_fs_init_helper)(); } 107279: 8b 5d fc mov -0x4(%ebp),%ebx 10727c: c9 leave /* * Initialize the base file system infrastructure. */ if (rtems_fs_init_helper) (* rtems_fs_init_helper)(); 10727d: ff e0 jmp *%eax } 10727f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 107282: c9 leave <== NOT EXECUTED 107283: c3 ret <== NOT EXECUTED 00126664 : rtems_filesystem_freenode( &env->root_directory); free(env); } } rtems_status_code rtems_libio_set_private_env(void) { 126664: 55 push %ebp 126665: 89 e5 mov %esp,%ebp 126667: 57 push %edi 126668: 56 push %esi 126669: 53 push %ebx 12666a: 83 ec 40 sub $0x40,%esp rtems_status_code sc; rtems_id task_id; rtems_filesystem_location_info_t loc; sc=rtems_task_ident(RTEMS_SELF,0,&task_id); 12666d: 8d 45 e4 lea -0x1c(%ebp),%eax 126670: 50 push %eax 126671: 6a 00 push $0x0 126673: 6a 00 push $0x0 126675: e8 1e 0d 00 00 call 127398 12667a: 89 45 c4 mov %eax,-0x3c(%ebp) if (sc != RTEMS_SUCCESSFUL) return sc; 12667d: 83 c4 10 add $0x10,%esp 126680: 85 c0 test %eax,%eax 126682: 0f 85 da 00 00 00 jne 126762 /* Only for the first time a malloc is necesary */ if (rtems_current_user_env==&rtems_global_user_env) { 126688: 81 3d dc e1 15 00 ac cmpl $0x163aac,0x15e1dc 12668f: 3a 16 00 126692: 75 54 jne 1266e8 rtems_user_env_t *tmp = malloc(sizeof(rtems_user_env_t)); 126694: 83 ec 0c sub $0xc,%esp 126697: 6a 48 push $0x48 126699: e8 be 55 fe ff call 10bc5c 12669e: 89 c3 mov %eax,%ebx if (!tmp) 1266a0: 83 c4 10 add $0x10,%esp 1266a3: 85 c0 test %eax,%eax 1266a5: 75 0c jne 1266b3 1266a7: c7 45 c4 1a 00 00 00 movl $0x1a,-0x3c(%ebp) <== NOT EXECUTED 1266ae: e9 af 00 00 00 jmp 126762 <== 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); 1266b3: 56 push %esi 1266b4: 68 78 65 12 00 push $0x126578 1266b9: 68 dc e1 15 00 push $0x15e1dc 1266be: 6a 00 push $0x0 1266c0: e8 77 10 00 00 call 12773c 1266c5: 89 c6 mov %eax,%esi if (sc != RTEMS_SUCCESSFUL) { 1266c7: 83 c4 10 add $0x10,%esp 1266ca: 85 c0 test %eax,%eax 1266cc: 74 14 je 1266e2 /* don't use free_user_env because the pathlocs are * not initialized yet */ free(tmp); 1266ce: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1266d1: 53 push %ebx <== NOT EXECUTED 1266d2: e8 99 50 fe ff call 10b770 <== NOT EXECUTED 1266d7: 89 75 c4 mov %esi,-0x3c(%ebp) <== NOT EXECUTED return sc; 1266da: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1266dd: e9 80 00 00 00 jmp 126762 <== NOT EXECUTED } rtems_current_user_env = tmp; 1266e2: 89 1d dc e1 15 00 mov %ebx,0x15e1dc }; *rtems_current_user_env = rtems_global_user_env; /* get the global values*/ 1266e8: a1 dc e1 15 00 mov 0x15e1dc,%eax 1266ed: be ac 3a 16 00 mov $0x163aac,%esi 1266f2: b9 12 00 00 00 mov $0x12,%ecx 1266f7: 89 c7 mov %eax,%edi 1266f9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_current_user_env->task_id=task_id; /* mark the local values*/ 1266fb: 8b 55 e4 mov -0x1c(%ebp),%edx 1266fe: 89 10 mov %edx,(%eax) /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 126700: 8d 78 18 lea 0x18(%eax),%edi 126703: 8b 35 94 3a 16 00 mov 0x163a94,%esi 126709: 83 c6 1c add $0x1c,%esi 12670c: b1 05 mov $0x5,%cl 12670e: 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("/", 1, 0, &loc, 0); 126710: 83 ec 0c sub $0xc,%esp 126713: 6a 00 push $0x0 126715: 8d 5d d0 lea -0x30(%ebp),%ebx 126718: 53 push %ebx 126719: 6a 00 push $0x0 12671b: 6a 01 push $0x1 12671d: 68 06 a4 15 00 push $0x15a406 126722: e8 a1 4f fe ff call 10b6c8 rtems_filesystem_root = loc; 126727: 8b 3d dc e1 15 00 mov 0x15e1dc,%edi 12672d: 83 c7 18 add $0x18,%edi 126730: b9 05 00 00 00 mov $0x5,%ecx 126735: 89 de mov %ebx,%esi 126737: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0); 126739: 83 c4 14 add $0x14,%esp 12673c: 6a 00 push $0x0 12673e: 53 push %ebx 12673f: 6a 00 push $0x0 126741: 6a 01 push $0x1 126743: 68 06 a4 15 00 push $0x15a406 126748: e8 7b 4f fe ff call 10b6c8 rtems_filesystem_current = loc; 12674d: 8b 3d dc e1 15 00 mov 0x15e1dc,%edi 126753: 83 c7 04 add $0x4,%edi 126756: b9 05 00 00 00 mov $0x5,%ecx 12675b: 89 de mov %ebx,%esi 12675d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return RTEMS_SUCCESSFUL; 12675f: 83 c4 20 add $0x20,%esp } 126762: 8b 45 c4 mov -0x3c(%ebp),%eax 126765: 8d 65 f4 lea -0xc(%ebp),%esp 126768: 5b pop %ebx 126769: 5e pop %esi 12676a: 5f pop %edi 12676b: c9 leave 12676c: c3 ret 001265cf : * 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) { 1265cf: 55 push %ebp <== NOT EXECUTED 1265d0: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1265d2: 53 push %ebx <== NOT EXECUTED 1265d3: 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); 1265d6: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 1265d9: 50 push %eax <== NOT EXECUTED 1265da: 6a 00 push $0x0 <== NOT EXECUTED 1265dc: 6a 00 push $0x0 <== NOT EXECUTED 1265de: e8 b5 0d 00 00 call 127398 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 1265e3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1265e6: 85 c0 test %eax,%eax <== NOT EXECUTED 1265e8: 75 75 jne 12665f <== NOT EXECUTED if (rtems_current_user_env->task_id==current_task_id) { 1265ea: 8b 1d dc e1 15 00 mov 0x15e1dc,%ebx <== NOT EXECUTED 1265f0: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 1265f2: 3b 45 f0 cmp -0x10(%ebp),%eax <== NOT EXECUTED 1265f5: 75 21 jne 126618 <== 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); 1265f7: 51 push %ecx <== NOT EXECUTED 1265f8: 51 push %ecx <== NOT EXECUTED 1265f9: 68 dc e1 15 00 push $0x15e1dc <== NOT EXECUTED 1265fe: 6a 00 push $0x0 <== NOT EXECUTED 126600: e8 cb 11 00 00 call 1277d0 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 126605: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126608: 85 c0 test %eax,%eax <== NOT EXECUTED 12660a: 75 53 jne 12665f <== NOT EXECUTED free_user_env(tmp); 12660c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12660f: 53 push %ebx <== NOT EXECUTED 126610: e8 63 ff ff ff call 126578 <== NOT EXECUTED 126615: 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, 126618: 52 push %edx <== NOT EXECUTED 126619: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 12661c: 50 push %eax <== NOT EXECUTED 12661d: 68 dc e1 15 00 push $0x15e1dc <== NOT EXECUTED 126622: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 126625: e8 22 12 00 00 call 12784c <== NOT EXECUTED (void*)&shared_user_env ); if (sc != RTEMS_SUCCESSFUL) 12662a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12662d: 85 c0 test %eax,%eax <== NOT EXECUTED 12662f: 75 24 jne 126655 <== NOT EXECUTED goto bailout; sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,free_user_env); 126631: 50 push %eax <== NOT EXECUTED 126632: 68 78 65 12 00 push $0x126578 <== NOT EXECUTED 126637: 68 dc e1 15 00 push $0x15e1dc <== NOT EXECUTED 12663c: 6a 00 push $0x0 <== NOT EXECUTED 12663e: e8 f9 10 00 00 call 12773c <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 126643: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126646: 85 c0 test %eax,%eax <== NOT EXECUTED 126648: 75 0b jne 126655 <== NOT EXECUTED goto bailout; /* the current_user_env is the same pointer that remote env */ rtems_current_user_env = shared_user_env; 12664a: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 12664d: 89 15 dc e1 15 00 mov %edx,0x15e1dc <== NOT EXECUTED /* increase the reference count */ #ifdef HAVE_USERENV_REFCNT rtems_current_user_env->refcnt++; #endif return RTEMS_SUCCESSFUL; 126653: eb 0a jmp 12665f <== NOT EXECUTED bailout: /* fallback to the global env */ rtems_current_user_env = &rtems_global_user_env; 126655: c7 05 dc e1 15 00 ac movl $0x163aac,0x15e1dc <== NOT EXECUTED 12665c: 3a 16 00 <== NOT EXECUTED return sc; } 12665f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 126662: c9 leave <== NOT EXECUTED 126663: c3 ret <== NOT EXECUTED 0010dcc8 : */ uint32_t rtems_libio_to_fcntl_flags( uint32_t flags ) { 10dcc8: 55 push %ebp 10dcc9: 89 e5 mov %esp,%ebp 10dccb: 8b 55 08 mov 0x8(%ebp),%edx uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10dcce: 89 d1 mov %edx,%ecx 10dcd0: 83 e1 06 and $0x6,%ecx 10dcd3: b8 02 00 00 00 mov $0x2,%eax 10dcd8: 83 f9 06 cmp $0x6,%ecx 10dcdb: 74 0f je 10dcec fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { 10dcdd: 30 c0 xor %al,%al 10dcdf: f6 c2 02 test $0x2,%dl 10dce2: 75 08 jne 10dcec 10dce4: 89 d0 mov %edx,%eax <== NOT EXECUTED 10dce6: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED 10dce9: 83 e0 01 and $0x1,%eax <== 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 ) { 10dcec: f6 c2 01 test $0x1,%dl 10dcef: 74 03 je 10dcf4 fcntl_flags |= O_NONBLOCK; 10dcf1: 80 cc 40 or $0x40,%ah } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 10dcf4: f6 c6 02 test $0x2,%dh 10dcf7: 74 03 je 10dcfc fcntl_flags |= O_APPEND; 10dcf9: 83 c8 08 or $0x8,%eax } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 10dcfc: 80 e6 04 and $0x4,%dh 10dcff: 74 03 je 10dd04 fcntl_flags |= O_CREAT; 10dd01: 80 cc 02 or $0x2,%ah } return fcntl_flags; } 10dd04: c9 leave 10dd05: c3 ret 0010bd00 : * size and thus we skip updating the statistics. */ static void rtems_malloc_statistics_at_free( void *pointer ) { 10bd00: 55 push %ebp <== NOT EXECUTED 10bd01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd03: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED uintptr_t size; if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) { 10bd06: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10bd09: 50 push %eax <== NOT EXECUTED 10bd0a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bd0d: ff 35 b0 c1 15 00 pushl 0x15c1b0 <== NOT EXECUTED 10bd13: e8 a8 51 00 00 call 110ec0 <_Protected_heap_Get_block_size> <== NOT EXECUTED 10bd18: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bd1b: 84 c0 test %al,%al <== NOT EXECUTED 10bd1d: 74 11 je 10bd30 <== NOT EXECUTED MSBUMP(lifetime_freed, size); 10bd1f: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 10bd22: 31 d2 xor %edx,%edx <== NOT EXECUTED 10bd24: 01 05 8c 3a 16 00 add %eax,0x163a8c <== NOT EXECUTED 10bd2a: 11 15 90 3a 16 00 adc %edx,0x163a90 <== NOT EXECUTED } } 10bd30: c9 leave <== NOT EXECUTED 10bd31: c3 ret <== NOT EXECUTED 0010bd32 : } static void rtems_malloc_statistics_at_malloc( void *pointer ) { 10bd32: 55 push %ebp <== NOT EXECUTED 10bd33: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd35: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10bd38: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED uintptr_t actual_size = 0; uint32_t current_depth; rtems_malloc_statistics_t *s = &rtems_malloc_statistics; if ( !pointer ) 10bd3b: 85 c0 test %eax,%eax <== NOT EXECUTED 10bd3d: 74 4a je 10bd89 <== NOT EXECUTED static void rtems_malloc_statistics_at_malloc( void *pointer ) { uintptr_t actual_size = 0; 10bd3f: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED rtems_malloc_statistics_t *s = &rtems_malloc_statistics; if ( !pointer ) return; _Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size); 10bd46: 52 push %edx <== NOT EXECUTED 10bd47: 8d 55 f4 lea -0xc(%ebp),%edx <== NOT EXECUTED 10bd4a: 52 push %edx <== NOT EXECUTED 10bd4b: 50 push %eax <== NOT EXECUTED 10bd4c: ff 35 b0 c1 15 00 pushl 0x15c1b0 <== NOT EXECUTED 10bd52: e8 69 51 00 00 call 110ec0 <_Protected_heap_Get_block_size> <== NOT EXECUTED MSBUMP(lifetime_allocated, actual_size); 10bd57: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 10bd5a: 31 d2 xor %edx,%edx <== NOT EXECUTED 10bd5c: 03 05 84 3a 16 00 add 0x163a84,%eax <== NOT EXECUTED 10bd62: 13 15 88 3a 16 00 adc 0x163a88,%edx <== NOT EXECUTED 10bd68: a3 84 3a 16 00 mov %eax,0x163a84 <== NOT EXECUTED 10bd6d: 89 15 88 3a 16 00 mov %edx,0x163a88 <== NOT EXECUTED current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed); 10bd73: 2b 05 8c 3a 16 00 sub 0x163a8c,%eax <== NOT EXECUTED if (current_depth > s->max_depth) 10bd79: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bd7c: 3b 05 80 3a 16 00 cmp 0x163a80,%eax <== NOT EXECUTED 10bd82: 76 05 jbe 10bd89 <== NOT EXECUTED s->max_depth = current_depth; 10bd84: a3 80 3a 16 00 mov %eax,0x163a80 <== NOT EXECUTED } 10bd89: c9 leave <== NOT EXECUTED 10bd8a: c3 ret <== NOT EXECUTED 0010bd8b : #include #include static void rtems_malloc_statistics_initialize( void ) { 10bd8b: 55 push %ebp <== NOT EXECUTED 10bd8c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd8e: 57 push %edi <== NOT EXECUTED /* * Zero all the statistics */ (void) memset(&rtems_malloc_statistics, 0, sizeof(rtems_malloc_statistics)); 10bd8f: ba 68 3a 16 00 mov $0x163a68,%edx <== NOT EXECUTED 10bd94: b9 0b 00 00 00 mov $0xb,%ecx <== NOT EXECUTED 10bd99: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bd9b: 89 d7 mov %edx,%edi <== NOT EXECUTED 10bd9d: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED } 10bd9f: 5f pop %edi <== NOT EXECUTED 10bda0: c9 leave <== NOT EXECUTED 10bda1: c3 ret <== NOT EXECUTED 00112038 : int rtems_memalign( void **pointer, size_t alignment, size_t size ) { 112038: 55 push %ebp 112039: 89 e5 mov %esp,%ebp 11203b: 56 push %esi 11203c: 53 push %ebx 11203d: 8b 5d 08 mov 0x8(%ebp),%ebx void *return_this; /* * Parameter error checks */ if ( !pointer ) 112040: 85 db test %ebx,%ebx 112042: 74 57 je 11209b return EINVAL; *pointer = NULL; 112044: c7 03 00 00 00 00 movl $0x0,(%ebx) /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 11204a: 83 3d ac 86 12 00 03 cmpl $0x3,0x1286ac 112051: 75 09 jne 11205c 112053: e8 0c 64 ff ff call 108464 112058: 84 c0 test %al,%al 11205a: 74 3f je 11209b /* * * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 11205c: e8 59 64 ff ff call 1084ba uintptr_t size, uintptr_t alignment ) { return _Protected_heap_Allocate_aligned_with_boundary( heap, size, alignment, 0 ); 112061: 6a 00 push $0x0 112063: ff 75 0c pushl 0xc(%ebp) 112066: ff 75 10 pushl 0x10(%ebp) 112069: ff 35 30 44 12 00 pushl 0x124430 11206f: e8 f0 ab ff ff call 10cc64 <_Protected_heap_Allocate_aligned_with_boundary> 112074: 89 c6 mov %eax,%esi return_this = _Protected_heap_Allocate_aligned( RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 112076: 83 c4 10 add $0x10,%esp 112079: b8 0c 00 00 00 mov $0xc,%eax 11207e: 85 f6 test %esi,%esi 112080: 74 1e je 1120a0 return ENOMEM; /* * If configured, update the more involved statistics */ if ( rtems_malloc_statistics_helpers ) 112082: a1 d0 67 12 00 mov 0x1267d0,%eax 112087: 85 c0 test %eax,%eax 112089: 74 0a je 112095 (*rtems_malloc_statistics_helpers->at_malloc)(pointer); 11208b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11208e: 53 push %ebx <== NOT EXECUTED 11208f: ff 50 04 call *0x4(%eax) <== NOT EXECUTED 112092: 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; 112095: 89 33 mov %esi,(%ebx) 112097: 31 c0 xor %eax,%eax return 0; 112099: eb 05 jmp 1120a0 11209b: b8 16 00 00 00 mov $0x16,%eax } 1120a0: 8d 65 f8 lea -0x8(%ebp),%esp 1120a3: 5b pop %ebx 1120a4: 5e pop %esi 1120a5: c9 leave 1120a6: c3 ret 0010b49f : void rtems_panic( const char *printf_format, ... ) { 10b49f: 55 push %ebp <== NOT EXECUTED 10b4a0: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4a2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED /* * rtems_panic is shorthand for rtems_error(RTEMS_ERROR_PANIC, ...) */ void rtems_panic( 10b4a5: 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); 10b4a8: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b4ab: b8 00 00 00 20 mov $0x20000000,%eax <== NOT EXECUTED 10b4b0: e8 80 fe ff ff call 10b335 <== NOT EXECUTED va_end(arglist); } 10b4b5: c9 leave <== NOT EXECUTED 10b4b6: c3 ret <== NOT EXECUTED 0010ee46 : /* * Initialization of FIFO/pipe module. */ void rtems_pipe_initialize (void) { 10ee46: 55 push %ebp 10ee47: 89 e5 mov %esp,%ebp 10ee49: 83 ec 08 sub $0x8,%esp if (!rtems_pipe_configured) 10ee4c: 80 3d 0c 1d 12 00 00 cmpb $0x0,0x121d0c 10ee53: 74 3c je 10ee91 return; if (rtems_pipe_semaphore) 10ee55: 83 3d 58 36 12 00 00 cmpl $0x0,0x123658 <== NOT EXECUTED 10ee5c: 75 33 jne 10ee91 <== NOT EXECUTED return; rtems_status_code sc; sc = rtems_semaphore_create( 10ee5e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ee61: 68 58 36 12 00 push $0x123658 <== NOT EXECUTED 10ee66: 6a 00 push $0x0 <== NOT EXECUTED 10ee68: 6a 54 push $0x54 <== NOT EXECUTED 10ee6a: 6a 01 push $0x1 <== NOT EXECUTED 10ee6c: 68 45 50 49 50 push $0x50495045 <== NOT EXECUTED 10ee71: e8 da ae ff ff call 109d50 <== NOT EXECUTED rtems_build_name ('P', 'I', 'P', 'E'), 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_pipe_semaphore); if (sc != RTEMS_SUCCESSFUL) 10ee76: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10ee79: 85 c0 test %eax,%eax <== NOT EXECUTED 10ee7b: 74 09 je 10ee86 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 10ee7d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ee80: 50 push %eax <== NOT EXECUTED 10ee81: e8 ae b6 ff ff call 10a534 <== NOT EXECUTED rtems_interval now; now = rtems_clock_get_ticks_since_boot(); 10ee86: e8 c1 aa ff ff call 10994c <== NOT EXECUTED rtems_pipe_no = now; 10ee8b: 66 a3 60 36 12 00 mov %ax,0x123660 <== NOT EXECUTED } 10ee91: c9 leave 10ee92: c3 ret 0010a234 : /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) { 10a234: 55 push %ebp 10a235: 89 e5 mov %esp,%ebp 10a237: 53 push %ebx 10a238: 83 ec 04 sub $0x4,%esp Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 10a23b: 8b 15 68 3c 16 00 mov 0x163c68,%edx ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 10a241: 8b 82 c4 00 00 00 mov 0xc4(%edx),%eax 10a247: 31 db xor %ebx,%ebx 10a249: 39 c5 cmp %eax,%ebp 10a24b: 72 0e jb 10a25b } /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) 10a24d: 8b 8a c0 00 00 00 mov 0xc0(%edx),%ecx 10a253: 8d 14 08 lea (%eax,%ecx,1),%edx 10a256: 39 d5 cmp %edx,%ebp 10a258: 0f 96 c3 setbe %bl /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 10a25b: b2 01 mov $0x1,%dl 10a25d: 83 3d 98 0d 16 00 00 cmpl $0x0,0x160d98 10a264: 74 19 je 10a27f pattern_ok = (!memcmp( 10a266: 83 c0 08 add $0x8,%eax 10a269: 52 push %edx 10a26a: 6a 10 push $0x10 10a26c: 68 38 3a 16 00 push $0x163a38 10a271: 50 push %eax 10a272: e8 71 13 03 00 call 13b5e8 10a277: 83 c4 10 add $0x10,%esp 10a27a: 85 c0 test %eax,%eax 10a27c: 0f 94 c2 sete %dl } /* * The Stack Pointer and the Pattern Area are OK so return false. */ if ( sp_ok && pattern_ok ) 10a27f: 84 db test %bl,%bl 10a281: 74 06 je 10a289 10a283: 31 c0 xor %eax,%eax 10a285: 84 d2 test %dl,%dl 10a287: 75 16 jne 10a29f return false; /* * Let's report as much as we can. */ Stack_check_report_blown_task( _Thread_Executing, pattern_ok ); 10a289: 53 push %ebx <== NOT EXECUTED 10a28a: 53 push %ebx <== NOT EXECUTED 10a28b: 0f b6 d2 movzbl %dl,%edx <== NOT EXECUTED 10a28e: 52 push %edx <== NOT EXECUTED 10a28f: ff 35 68 3c 16 00 pushl 0x163c68 <== NOT EXECUTED 10a295: e8 e6 fe ff ff call 10a180 <== NOT EXECUTED 10a29a: b0 01 mov $0x1,%al <== NOT EXECUTED return true; 10a29c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10a29f: 8b 5d fc mov -0x4(%ebp),%ebx 10a2a2: c9 leave 10a2a3: c3 ret 0010a169 : void rtems_stack_checker_report_usage( void ) { 10a169: 55 push %ebp <== NOT EXECUTED 10a16a: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a16c: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin ); 10a16f: 68 f0 c6 10 00 push $0x10c6f0 <== NOT EXECUTED 10a174: 6a 00 push $0x0 <== NOT EXECUTED 10a176: e8 8d ff ff ff call 10a108 <== NOT EXECUTED 10a17b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10a17e: c9 leave <== NOT EXECUTED 10a17f: c3 ret <== NOT EXECUTED 0010a108 : void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) { 10a108: 55 push %ebp <== NOT EXECUTED 10a109: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a10b: 56 push %esi <== NOT EXECUTED 10a10c: 53 push %ebx <== NOT EXECUTED 10a10d: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10a110: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED print_context = context; 10a113: 89 35 9c 0d 16 00 mov %esi,0x160d9c <== NOT EXECUTED print_handler = print; 10a119: 89 1d a0 0d 16 00 mov %ebx,0x160da0 <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 10a11f: 51 push %ecx <== NOT EXECUTED 10a120: 51 push %ecx <== NOT EXECUTED 10a121: 68 ac 0d 15 00 push $0x150dac <== NOT EXECUTED 10a126: 56 push %esi <== NOT EXECUTED 10a127: ff d3 call *%ebx <== NOT EXECUTED (*print)( context, 10a129: 58 pop %eax <== NOT EXECUTED 10a12a: 5a pop %edx <== NOT EXECUTED 10a12b: 68 c3 0d 15 00 push $0x150dc3 <== NOT EXECUTED 10a130: 56 push %esi <== NOT EXECUTED 10a131: ff d3 call *%ebx <== NOT EXECUTED " ID NAME LOW HIGH CURRENT AVAILABLE USED\n" ); /* iterate over all threads and dump the usage */ rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage ); 10a133: c7 04 24 f2 9f 10 00 movl $0x109ff2,(%esp) <== NOT EXECUTED 10a13a: e8 8d 65 00 00 call 1106cc <== NOT EXECUTED /* dump interrupt stack info if any */ Stack_check_Dump_threads_usage((Thread_Control *) -1); 10a13f: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED 10a146: e8 a7 fe ff ff call 109ff2 <== NOT EXECUTED print_context = NULL; 10a14b: c7 05 9c 0d 16 00 00 movl $0x0,0x160d9c <== NOT EXECUTED 10a152: 00 00 00 <== NOT EXECUTED print_handler = NULL; 10a155: c7 05 a0 0d 16 00 00 movl $0x0,0x160da0 <== NOT EXECUTED 10a15c: 00 00 00 <== NOT EXECUTED 10a15f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10a162: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a165: 5b pop %ebx <== NOT EXECUTED 10a166: 5e pop %esi <== NOT EXECUTED 10a167: c9 leave <== NOT EXECUTED 10a168: c3 ret <== NOT EXECUTED 0010a2a4 : */ void rtems_stack_checker_switch_extension( Thread_Control *running __attribute__((unused)), Thread_Control *heir __attribute__((unused)) ) { 10a2a4: 55 push %ebp 10a2a5: 89 e5 mov %esp,%ebp 10a2a7: 53 push %ebx 10a2a8: 83 ec 14 sub $0x14,%esp 10a2ab: 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; 10a2ae: 8b 83 c4 00 00 00 mov 0xc4(%ebx),%eax ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 10a2b4: 31 d2 xor %edx,%edx 10a2b6: 39 c5 cmp %eax,%ebp 10a2b8: 72 0d jb 10a2c7 } /* * rtems_stack_checker_switch_extension */ void rtems_stack_checker_switch_extension( 10a2ba: 8b 93 c0 00 00 00 mov 0xc0(%ebx),%edx 10a2c0: 01 c2 add %eax,%edx 10a2c2: 39 d5 cmp %edx,%ebp 10a2c4: 0f 96 c2 setbe %dl /* * Check for an out of bounds stack pointer or an overwrite */ sp_ok = Stack_check_Frame_pointer_in_range( the_stack ); pattern_ok = (!memcmp( pattern, 10a2c7: 83 c0 08 add $0x8,%eax 10a2ca: 51 push %ecx 10a2cb: 6a 10 push $0x10 10a2cd: 68 38 3a 16 00 push $0x163a38 10a2d2: 50 push %eax 10a2d3: 88 55 f4 mov %dl,-0xc(%ebp) 10a2d6: e8 0d 13 03 00 call 13b5e8 10a2db: 83 c4 10 add $0x10,%esp 10a2de: 85 c0 test %eax,%eax 10a2e0: 0f 94 c0 sete %al (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { 10a2e3: 8a 55 f4 mov -0xc(%ebp),%dl 10a2e6: 84 d2 test %dl,%dl 10a2e8: 74 04 je 10a2ee 10a2ea: 84 c0 test %al,%al 10a2ec: 75 12 jne 10a300 Stack_check_report_blown_task( running, pattern_ok ); 10a2ee: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10a2f1: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10a2f4: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 10a2f7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a2fa: c9 leave <== NOT EXECUTED 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 ); 10a2fb: e9 80 fe ff ff jmp 10a180 <== NOT EXECUTED } } 10a300: 8b 5d fc mov -0x4(%ebp),%ebx 10a303: c9 leave 10a304: c3 ret 0011e20c : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 11e20c: 55 push %ebp 11e20d: 89 e5 mov %esp,%ebp 11e20f: 57 push %edi 11e210: 56 push %esi 11e211: 53 push %ebx 11e212: 83 ec 2c sub $0x2c,%esp 11e215: 8b 7d 08 mov 0x8(%ebp),%edi 11e218: 8b 5d 0c mov 0xc(%ebp),%ebx 11e21b: 8b 55 10 mov 0x10(%ebp),%edx STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 11e21e: b8 09 00 00 00 mov $0x9,%eax 11e223: 85 db test %ebx,%ebx 11e225: 74 56 je 11e27d return RTEMS_INVALID_ADDRESS; errno = 0; 11e227: 89 55 d4 mov %edx,-0x2c(%ebp) 11e22a: e8 49 a5 01 00 call 138778 <__errno> 11e22f: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 11e235: c7 03 00 00 00 00 movl $0x0,(%ebx) #ifdef STRING_TO_FLOAT result = STRING_TO_METHOD( s, &end ); #elif defined(STRING_TO_POINTER) result = STRING_TO_METHOD( s, &end, 16 ); 11e23b: 50 push %eax 11e23c: 6a 10 push $0x10 11e23e: 8d 45 e4 lea -0x1c(%ebp),%eax 11e241: 50 push %eax 11e242: 57 push %edi 11e243: e8 3c 17 02 00 call 13f984 11e248: 89 c6 mov %eax,%esi #elif defined(STRING_TO_INTEGER) result = STRING_TO_METHOD( s, &end, base ); #endif /* If the user wants the end pointer back, then return it. */ if ( endptr ) 11e24a: 83 c4 10 add $0x10,%esp 11e24d: 8b 55 d4 mov -0x2c(%ebp),%edx 11e250: 85 d2 test %edx,%edx 11e252: 74 05 je 11e259 *endptr = end; 11e254: 8b 45 e4 mov -0x1c(%ebp),%eax 11e257: 89 02 mov %eax,(%edx) /* nothing was converted */ if ( end == s ) 11e259: b8 0b 00 00 00 mov $0xb,%eax 11e25e: 39 7d e4 cmp %edi,-0x1c(%ebp) 11e261: 74 1a je 11e27d return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 11e263: 83 fe ff cmp $0xffffffff,%esi 11e266: 75 11 jne 11e279 11e268: e8 0b a5 01 00 call 138778 <__errno> <== NOT EXECUTED 11e26d: 89 c2 mov %eax,%edx <== NOT EXECUTED 11e26f: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 11e274: 83 3a 22 cmpl $0x22,(%edx) <== NOT EXECUTED 11e277: 74 04 je 11e27d <== NOT EXECUTED /* there was an underflow */ if ( (result == STRING_TO_MIN) && (errno == ERANGE)) return RTEMS_INVALID_NUMBER; #endif *n = (STRING_TO_TYPE) result; 11e279: 89 33 mov %esi,(%ebx) 11e27b: 31 c0 xor %eax,%eax return RTEMS_SUCCESSFUL; } 11e27d: 8d 65 f4 lea -0xc(%ebp),%esp 11e280: 5b pop %ebx 11e281: 5e pop %esi 11e282: 5f pop %edi 11e283: c9 leave 11e284: c3 ret 0010ba50 : rtems_status_code rtems_task_get_note( rtems_id id, uint32_t notepad, uint32_t *note ) { 10ba50: 55 push %ebp 10ba51: 89 e5 mov %esp,%ebp 10ba53: 56 push %esi 10ba54: 53 push %ebx 10ba55: 83 ec 10 sub $0x10,%esp 10ba58: 8b 55 08 mov 0x8(%ebp),%edx 10ba5b: 8b 75 0c mov 0xc(%ebp),%esi 10ba5e: 8b 5d 10 mov 0x10(%ebp),%ebx register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10ba61: b8 16 00 00 00 mov $0x16,%eax 10ba66: 80 3d c4 21 12 00 00 cmpb $0x0,0x1221c4 10ba6d: 74 5d je 10bacc return RTEMS_NOT_CONFIGURED; if ( !note ) 10ba6f: b0 09 mov $0x9,%al 10ba71: 85 db test %ebx,%ebx 10ba73: 74 57 je 10bacc /* * 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 ) 10ba75: b0 0a mov $0xa,%al 10ba77: 83 fe 0f cmp $0xf,%esi 10ba7a: 77 50 ja 10bacc /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10ba7c: 85 d2 test %edx,%edx 10ba7e: 74 0a je 10ba8a _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { 10ba80: a1 c4 64 12 00 mov 0x1264c4,%eax 10ba85: 3b 50 08 cmp 0x8(%eax),%edx 10ba88: 75 13 jne 10ba9d api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10ba8a: a1 c4 64 12 00 mov 0x1264c4,%eax 10ba8f: 8b 80 f0 00 00 00 mov 0xf0(%eax),%eax 10ba95: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax 10ba99: 89 03 mov %eax,(%ebx) 10ba9b: eb 2d jmp 10baca return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10ba9d: 50 push %eax 10ba9e: 50 push %eax 10ba9f: 8d 45 f4 lea -0xc(%ebp),%eax 10baa2: 50 push %eax 10baa3: 52 push %edx 10baa4: e8 9f 1b 00 00 call 10d648 <_Thread_Get> 10baa9: 89 c2 mov %eax,%edx switch ( location ) { 10baab: 83 c4 10 add $0x10,%esp 10baae: b8 04 00 00 00 mov $0x4,%eax 10bab3: 83 7d f4 00 cmpl $0x0,-0xc(%ebp) 10bab7: 75 13 jne 10bacc case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10bab9: 8b 82 f0 00 00 00 mov 0xf0(%edx),%eax <== NOT EXECUTED 10babf: 8b 44 b0 20 mov 0x20(%eax,%esi,4),%eax <== NOT EXECUTED 10bac3: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10bac5: e8 5b 1b 00 00 call 10d625 <_Thread_Enable_dispatch> <== NOT EXECUTED 10baca: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bacc: 8d 65 f8 lea -0x8(%ebp),%esp 10bacf: 5b pop %ebx 10bad0: 5e pop %esi 10bad1: c9 leave 10bad2: c3 ret 00108f94 : #include int rtems_termios_baud_to_index( rtems_termios_baud_t termios_baud ) { 108f94: 55 push %ebp 108f95: 89 e5 mov %esp,%ebp 108f97: 8b 55 08 mov 0x8(%ebp),%edx case B110: baud_index = 3; break; case B134: baud_index = 4; break; case B150: baud_index = 5; break; case B200: baud_index = 6; break; case B300: baud_index = 7; break; case B600: baud_index = 8; break; 108f9a: b8 09 00 00 00 mov $0x9,%eax rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 108f9f: 83 fa 09 cmp $0x9,%edx 108fa2: 0f 84 b5 00 00 00 je 10905d 108fa8: 7f 54 jg 108ffe case B0: baud_index = 0; break; case B50: baud_index = 1; break; case B75: baud_index = 2; break; case B110: baud_index = 3; break; 108faa: b0 04 mov $0x4,%al rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 108fac: 83 fa 04 cmp $0x4,%edx 108faf: 0f 84 a8 00 00 00 je 10905d 108fb5: 7f 2b jg 108fe2 108fb7: b0 01 mov $0x1,%al 108fb9: 83 fa 01 cmp $0x1,%edx 108fbc: 0f 84 9b 00 00 00 je 10905d 108fc2: 7f 09 jg 108fcd 108fc4: 30 c0 xor %al,%al 108fc6: 85 d2 test %edx,%edx 108fc8: e9 8b 00 00 00 jmp 109058 108fcd: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 108fd2: 83 fa 02 cmp $0x2,%edx <== NOT EXECUTED 108fd5: 0f 84 82 00 00 00 je 10905d <== NOT EXECUTED case B0: baud_index = 0; break; case B50: baud_index = 1; break; case B75: baud_index = 2; break; 108fdb: b0 03 mov $0x3,%al <== NOT EXECUTED rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 108fdd: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 108fe0: eb 76 jmp 109058 <== NOT EXECUTED case B0: baud_index = 0; break; case B50: baud_index = 1; break; case B75: baud_index = 2; break; case B110: baud_index = 3; break; case B134: baud_index = 4; break; case B150: baud_index = 5; break; 108fe2: b8 06 00 00 00 mov $0x6,%eax <== NOT EXECUTED rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 108fe7: 83 fa 06 cmp $0x6,%edx <== NOT EXECUTED 108fea: 74 71 je 10905d <== NOT EXECUTED case B0: baud_index = 0; break; case B50: baud_index = 1; break; case B75: baud_index = 2; break; case B110: baud_index = 3; break; case B134: baud_index = 4; break; 108fec: b0 05 mov $0x5,%al <== NOT EXECUTED rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 108fee: 7c 6d jl 10905d <== NOT EXECUTED case B50: baud_index = 1; break; case B75: baud_index = 2; break; case B110: baud_index = 3; break; case B134: baud_index = 4; break; case B150: baud_index = 5; break; case B200: baud_index = 6; break; 108ff0: b0 07 mov $0x7,%al <== NOT EXECUTED rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 108ff2: 83 fa 07 cmp $0x7,%edx <== NOT EXECUTED 108ff5: 74 66 je 10905d <== NOT EXECUTED case B75: baud_index = 2; break; case B110: baud_index = 3; break; case B134: baud_index = 4; break; case B150: baud_index = 5; break; case B200: baud_index = 6; break; case B300: baud_index = 7; break; 108ff7: b0 08 mov $0x8,%al <== NOT EXECUTED rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 108ff9: 83 fa 08 cmp $0x8,%edx <== NOT EXECUTED 108ffc: eb 5a jmp 109058 <== NOT EXECUTED case B600: baud_index = 8; break; case B1200: baud_index = 9; break; case B1800: baud_index = 10; break; case B2400: baud_index = 11; break; case B4800: baud_index = 12; break; case B9600: baud_index = 13; break; 108ffe: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 109003: 83 fa 0e cmp $0xe,%edx <== NOT EXECUTED 109006: 74 55 je 10905d <== NOT EXECUTED 109008: 7f 19 jg 109023 <== NOT EXECUTED case B150: baud_index = 5; break; case B200: baud_index = 6; break; case B300: baud_index = 7; break; case B600: baud_index = 8; break; case B1200: baud_index = 9; break; case B1800: baud_index = 10; break; 10900a: b0 0b mov $0xb,%al <== NOT EXECUTED rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 10900c: 83 fa 0b cmp $0xb,%edx <== NOT EXECUTED 10900f: 74 4c je 10905d <== NOT EXECUTED case B134: baud_index = 4; break; case B150: baud_index = 5; break; case B200: baud_index = 6; break; case B300: baud_index = 7; break; case B600: baud_index = 8; break; case B1200: baud_index = 9; break; 109011: b0 0a mov $0xa,%al <== NOT EXECUTED rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 109013: 7c 48 jl 10905d <== NOT EXECUTED case B200: baud_index = 6; break; case B300: baud_index = 7; break; case B600: baud_index = 8; break; case B1200: baud_index = 9; break; case B1800: baud_index = 10; break; case B2400: baud_index = 11; break; 109015: b0 0c mov $0xc,%al <== NOT EXECUTED rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 109017: 83 fa 0c cmp $0xc,%edx <== NOT EXECUTED 10901a: 74 41 je 10905d <== NOT EXECUTED case B300: baud_index = 7; break; case B600: baud_index = 8; break; case B1200: baud_index = 9; break; case B1800: baud_index = 10; break; case B2400: baud_index = 11; break; case B4800: baud_index = 12; break; 10901c: b0 0d mov $0xd,%al <== NOT EXECUTED rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 10901e: 83 fa 0d cmp $0xd,%edx <== NOT EXECUTED 109021: eb 35 jmp 109058 <== NOT EXECUTED case B2400: baud_index = 11; break; case B4800: baud_index = 12; break; case B9600: baud_index = 13; break; case B19200: baud_index = 14; break; case B38400: baud_index = 15; break; case B57600: baud_index = 16; break; 109023: b8 11 00 00 00 mov $0x11,%eax <== NOT EXECUTED rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 109028: 81 fa 02 10 00 00 cmp $0x1002,%edx <== NOT EXECUTED 10902e: 74 2d je 10905d <== NOT EXECUTED 109030: 7f 11 jg 109043 <== NOT EXECUTED case B1200: baud_index = 9; break; case B1800: baud_index = 10; break; case B2400: baud_index = 11; break; case B4800: baud_index = 12; break; case B9600: baud_index = 13; break; case B19200: baud_index = 14; break; 109032: b0 0f mov $0xf,%al <== NOT EXECUTED rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 109034: 83 fa 0f cmp $0xf,%edx <== NOT EXECUTED 109037: 74 24 je 10905d <== NOT EXECUTED case B1800: baud_index = 10; break; case B2400: baud_index = 11; break; case B4800: baud_index = 12; break; case B9600: baud_index = 13; break; case B19200: baud_index = 14; break; case B38400: baud_index = 15; break; 109039: b0 10 mov $0x10,%al <== NOT EXECUTED rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 10903b: 81 fa 01 10 00 00 cmp $0x1001,%edx <== NOT EXECUTED 109041: eb 15 jmp 109058 <== NOT EXECUTED case B4800: baud_index = 12; break; case B9600: baud_index = 13; break; case B19200: baud_index = 14; break; case B38400: baud_index = 15; break; case B57600: baud_index = 16; break; case B115200: baud_index = 17; break; 109043: b8 12 00 00 00 mov $0x12,%eax <== NOT EXECUTED rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 109048: 81 fa 03 10 00 00 cmp $0x1003,%edx <== NOT EXECUTED 10904e: 74 0d je 10905d <== NOT EXECUTED case B9600: baud_index = 13; break; case B19200: baud_index = 14; break; case B38400: baud_index = 15; break; case B57600: baud_index = 16; break; case B115200: baud_index = 17; break; case B230400: baud_index = 18; break; 109050: b0 13 mov $0x13,%al <== NOT EXECUTED rtems_termios_baud_t termios_baud ) { int baud_index; switch (termios_baud) { 109052: 81 fa 04 10 00 00 cmp $0x1004,%edx <== NOT EXECUTED 109058: 74 03 je 10905d case B19200: baud_index = 14; break; case B38400: baud_index = 15; break; case B57600: baud_index = 16; break; case B115200: baud_index = 17; break; case B230400: baud_index = 18; break; case B460800: baud_index = 19; break; 10905a: 83 c8 ff or $0xffffffff,%eax default: baud_index = -1; break; } return baud_index; } 10905d: c9 leave 10905e: c3 ret 00107ec4 : rtems_status_code rtems_termios_bufsize ( int cbufsize, int raw_input, int raw_output ) { 107ec4: 55 push %ebp <== NOT EXECUTED 107ec5: 89 e5 mov %esp,%ebp <== NOT EXECUTED rtems_termios_cbufsize = cbufsize; 107ec7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 107eca: a3 78 17 12 00 mov %eax,0x121778 <== NOT EXECUTED rtems_termios_raw_input_size = raw_input; 107ecf: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 107ed2: a3 7c 17 12 00 mov %eax,0x12177c <== NOT EXECUTED rtems_termios_raw_output_size = raw_output; 107ed7: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 107eda: a3 80 17 12 00 mov %eax,0x121780 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 107edf: 31 c0 xor %eax,%eax <== NOT EXECUTED 107ee1: c9 leave <== NOT EXECUTED 107ee2: c3 ret <== NOT EXECUTED 0010904e : } } rtems_status_code rtems_termios_close (void *arg) { 10904e: 55 push %ebp 10904f: 89 e5 mov %esp,%ebp 109051: 56 push %esi 109052: 53 push %ebx 109053: 8b 75 08 mov 0x8(%ebp),%esi rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 109056: 8b 06 mov (%esi),%eax 109058: 8b 58 34 mov 0x34(%eax),%ebx rtems_status_code sc; sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 10905b: 50 push %eax 10905c: 6a 00 push $0x0 10905e: 6a 00 push $0x0 109060: ff 35 a8 38 12 00 pushl 0x1238a8 109066: e8 11 0f 00 00 call 109f7c if (sc != RTEMS_SUCCESSFUL) 10906b: 83 c4 10 add $0x10,%esp 10906e: 85 c0 test %eax,%eax 109070: 75 7d jne 1090ef rtems_fatal_error_occurred (sc); if (--tty->refcount == 0) { 109072: 8b 43 08 mov 0x8(%ebx),%eax 109075: 48 dec %eax 109076: 89 43 08 mov %eax,0x8(%ebx) 109079: 85 c0 test %eax,%eax 10907b: 0f 85 33 01 00 00 jne 1091b4 if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 109081: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 109087: c1 e0 05 shl $0x5,%eax 10908a: 8b 80 50 35 12 00 mov 0x123550(%eax),%eax 109090: 85 c0 test %eax,%eax 109092: 74 0b je 10909f /* * call discipline-specific close */ sc = rtems_termios_linesw[tty->t_line].l_close(tty); 109094: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109097: 53 push %ebx <== NOT EXECUTED 109098: ff d0 call *%eax <== NOT EXECUTED 10909a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10909d: eb 1b jmp 1090ba <== NOT EXECUTED } else { /* * default: just flush output buffer */ sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 10909f: 51 push %ecx 1090a0: 6a 00 push $0x0 1090a2: 6a 00 push $0x0 1090a4: ff 73 18 pushl 0x18(%ebx) 1090a7: e8 d0 0e 00 00 call 109f7c if (sc != RTEMS_SUCCESSFUL) { 1090ac: 83 c4 10 add $0x10,%esp 1090af: 85 c0 test %eax,%eax 1090b1: 75 3c jne 1090ef rtems_fatal_error_occurred (sc); } drainOutput (tty); 1090b3: 89 d8 mov %ebx,%eax 1090b5: e8 18 f9 ff ff call 1089d2 } if (tty->device.outputUsesInterrupts 1090ba: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 1090c1: 75 35 jne 1090f8 == TERMIOS_TASK_DRIVEN) { /* * send "terminate" to I/O tasks */ sc = rtems_event_send( 1090c3: 52 push %edx <== NOT EXECUTED 1090c4: 52 push %edx <== NOT EXECUTED 1090c5: 6a 01 push $0x1 <== NOT EXECUTED 1090c7: ff b3 c4 00 00 00 pushl 0xc4(%ebx) <== NOT EXECUTED 1090cd: e8 3e 0a 00 00 call 109b10 <== NOT EXECUTED tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) 1090d2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1090d5: 85 c0 test %eax,%eax <== NOT EXECUTED 1090d7: 75 16 jne 1090ef <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_event_send( 1090d9: 50 push %eax <== NOT EXECUTED 1090da: 50 push %eax <== NOT EXECUTED 1090db: 6a 01 push $0x1 <== NOT EXECUTED 1090dd: ff b3 c8 00 00 00 pushl 0xc8(%ebx) <== NOT EXECUTED 1090e3: e8 28 0a 00 00 call 109b10 <== NOT EXECUTED tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) 1090e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1090eb: 85 c0 test %eax,%eax <== NOT EXECUTED 1090ed: 74 09 je 1090f8 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 1090ef: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1090f2: 50 push %eax <== NOT EXECUTED 1090f3: e8 3c 14 00 00 call 10a534 <== NOT EXECUTED } if (tty->device.lastClose) 1090f8: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax 1090fe: 85 c0 test %eax,%eax 109100: 74 0d je 10910f (*tty->device.lastClose)(tty->major, tty->minor, arg); 109102: 51 push %ecx 109103: 56 push %esi 109104: ff 73 10 pushl 0x10(%ebx) 109107: ff 73 0c pushl 0xc(%ebx) 10910a: ff d0 call *%eax 10910c: 83 c4 10 add $0x10,%esp if (tty->forw == NULL) { 10910f: 8b 13 mov (%ebx),%edx 109111: 85 d2 test %edx,%edx 109113: 8b 43 04 mov 0x4(%ebx),%eax 109116: 75 11 jne 109129 rtems_termios_ttyTail = tty->back; 109118: a3 ac 38 12 00 mov %eax,0x1238ac if ( rtems_termios_ttyTail != NULL ) { 10911d: 85 c0 test %eax,%eax 10911f: 74 0b je 10912c rtems_termios_ttyTail->forw = NULL; 109121: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 109127: eb 03 jmp 10912c <== NOT EXECUTED } } else { tty->forw->back = tty->back; 109129: 89 42 04 mov %eax,0x4(%edx) } if (tty->back == NULL) { 10912c: 8b 53 04 mov 0x4(%ebx),%edx 10912f: 85 d2 test %edx,%edx 109131: 8b 03 mov (%ebx),%eax 109133: 75 12 jne 109147 rtems_termios_ttyHead = tty->forw; 109135: a3 b0 38 12 00 mov %eax,0x1238b0 if ( rtems_termios_ttyHead != NULL ) { 10913a: 85 c0 test %eax,%eax 10913c: 74 0b je 109149 rtems_termios_ttyHead->back = NULL; 10913e: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) 109145: eb 02 jmp 109149 } } else { tty->back->forw = tty->forw; 109147: 89 02 mov %eax,(%edx) <== NOT EXECUTED } rtems_semaphore_delete (tty->isem); 109149: 83 ec 0c sub $0xc,%esp 10914c: ff 73 14 pushl 0x14(%ebx) 10914f: e8 98 0d 00 00 call 109eec rtems_semaphore_delete (tty->osem); 109154: 5a pop %edx 109155: ff 73 18 pushl 0x18(%ebx) 109158: e8 8f 0d 00 00 call 109eec rtems_semaphore_delete (tty->rawOutBuf.Semaphore); 10915d: 58 pop %eax 10915e: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 109164: e8 83 0d 00 00 call 109eec if ((tty->device.pollRead == NULL) || 109169: 83 c4 10 add $0x10,%esp 10916c: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx) 109173: 74 09 je 10917e (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)) 109175: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 10917c: 75 0e jne 10918c rtems_semaphore_delete (tty->rawInBuf.Semaphore); 10917e: 83 ec 0c sub $0xc,%esp 109181: ff 73 68 pushl 0x68(%ebx) 109184: e8 63 0d 00 00 call 109eec 109189: 83 c4 10 add $0x10,%esp free (tty->rawInBuf.theBuf); 10918c: 83 ec 0c sub $0xc,%esp 10918f: ff 73 58 pushl 0x58(%ebx) 109192: e8 e9 df ff ff call 107180 free (tty->rawOutBuf.theBuf); 109197: 5e pop %esi 109198: ff 73 7c pushl 0x7c(%ebx) 10919b: e8 e0 df ff ff call 107180 free (tty->cbuf); 1091a0: 59 pop %ecx 1091a1: ff 73 1c pushl 0x1c(%ebx) 1091a4: e8 d7 df ff ff call 107180 free (tty); 1091a9: 89 1c 24 mov %ebx,(%esp) 1091ac: e8 cf df ff ff call 107180 1091b1: 83 c4 10 add $0x10,%esp } rtems_semaphore_release (rtems_termios_ttyMutex); 1091b4: 83 ec 0c sub $0xc,%esp 1091b7: ff 35 a8 38 12 00 pushl 0x1238a8 1091bd: e8 a6 0e 00 00 call 10a068 return RTEMS_SUCCESSFUL; } 1091c2: 31 c0 xor %eax,%eax 1091c4: 8d 65 f8 lea -0x8(%ebp),%esp 1091c7: 5b pop %ebx 1091c8: 5e pop %esi 1091c9: c9 leave 1091ca: c3 ret 001080c6 : * for each transmitted character. * It returns number of characters left to transmit */ int rtems_termios_dequeue_characters (void *ttyp, int len) { 1080c6: 55 push %ebp 1080c7: 89 e5 mov %esp,%ebp 1080c9: 83 ec 08 sub $0x8,%esp 1080cc: 8b 45 08 mov 0x8(%ebp),%eax rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len; 1080cf: 8b 55 0c mov 0xc(%ebp),%edx 1080d2: 01 90 90 00 00 00 add %edx,0x90(%eax) if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 1080d8: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax) 1080df: 75 1f jne 108100 /* * send wake up to transmitter task */ sc = rtems_event_send(tty->txTaskId, 1080e1: 52 push %edx <== NOT EXECUTED 1080e2: 52 push %edx <== NOT EXECUTED 1080e3: 6a 02 push $0x2 <== NOT EXECUTED 1080e5: ff b0 c8 00 00 00 pushl 0xc8(%eax) <== NOT EXECUTED 1080eb: e8 20 1a 00 00 call 109b10 <== NOT EXECUTED TERMIOS_TX_START_EVENT); if (sc != RTEMS_SUCCESSFUL) 1080f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1080f3: 85 c0 test %eax,%eax <== NOT EXECUTED 1080f5: 74 30 je 108127 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 1080f7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1080fa: 50 push %eax <== NOT EXECUTED 1080fb: e8 34 24 00 00 call 10a534 <== NOT EXECUTED return 0; /* nothing to output in IRQ... */ } else if (tty->t_line == PPPDISC ) { 108100: 83 b8 cc 00 00 00 05 cmpl $0x5,0xcc(%eax) 108107: 75 15 jne 10811e /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 108109: 8b 15 00 36 12 00 mov 0x123600,%edx <== NOT EXECUTED 10810f: 85 d2 test %edx,%edx <== NOT EXECUTED 108111: 74 14 je 108127 <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_start(tty); 108113: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108116: 50 push %eax <== NOT EXECUTED 108117: ff d2 call *%edx <== NOT EXECUTED 108119: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10811c: eb 09 jmp 108127 <== NOT EXECUTED } return 0; /* nothing to output in IRQ... */ } else { return rtems_termios_refill_transmitter(tty); 10811e: 89 45 08 mov %eax,0x8(%ebp) } } 108121: 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); 108122: e9 d7 fd ff ff jmp 107efe } } 108127: 31 c0 xor %eax,%eax <== NOT EXECUTED 108129: c9 leave <== NOT EXECUTED 10812a: c3 ret <== NOT EXECUTED 0010812b : * 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) { 10812b: 55 push %ebp <== NOT EXECUTED 10812c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10812e: 57 push %edi <== NOT EXECUTED 10812f: 56 push %esi <== NOT EXECUTED 108130: 53 push %ebx <== NOT EXECUTED 108131: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 108134: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 108137: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10813a: 8b 45 10 mov 0x10(%ebp),%eax <== 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) { 10813d: 8b 93 cc 00 00 00 mov 0xcc(%ebx),%edx <== NOT EXECUTED 108143: c1 e2 05 shl $0x5,%edx <== 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); 108146: 89 c6 mov %eax,%esi <== 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) { 108148: 83 ba 5c 35 12 00 00 cmpl $0x0,0x12355c(%edx) <== NOT EXECUTED 10814f: 75 35 jne 108186 <== 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, 108151: 8d 53 4a lea 0x4a(%ebx),%edx <== NOT EXECUTED 108154: 89 55 d0 mov %edx,-0x30(%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); 108157: 8d 4b 30 lea 0x30(%ebx),%ecx <== NOT EXECUTED 10815a: 89 4d d8 mov %ecx,-0x28(%ebp) <== NOT EXECUTED 10815d: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 108160: c6 45 de 00 movb $0x0,-0x22(%ebp) <== NOT EXECUTED 108164: 31 f6 xor %esi,%esi <== NOT EXECUTED 108166: e9 1d 02 00 00 jmp 108388 <== 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++; 10816b: 0f be 17 movsbl (%edi),%edx <== NOT EXECUTED 10816e: 47 inc %edi <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_rint(c,tty); 10816f: 50 push %eax <== NOT EXECUTED 108170: 50 push %eax <== NOT EXECUTED 108171: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 108177: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 10817a: 53 push %ebx <== NOT EXECUTED 10817b: 52 push %edx <== NOT EXECUTED 10817c: ff 90 5c 35 12 00 call *0x12355c(%eax) <== NOT EXECUTED 108182: 4e dec %esi <== NOT EXECUTED 108183: 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--) { 108186: 85 f6 test %esi,%esi <== NOT EXECUTED 108188: 75 e1 jne 10816b <== NOT EXECUTED } /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 10818a: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx) <== NOT EXECUTED 108191: 0f 85 0e 02 00 00 jne 1083a5 <== NOT EXECUTED 108197: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax <== NOT EXECUTED 10819d: 85 c0 test %eax,%eax <== NOT EXECUTED 10819f: 0f 84 00 02 00 00 je 1083a5 <== NOT EXECUTED (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 1081a5: 51 push %ecx <== NOT EXECUTED 1081a6: 51 push %ecx <== NOT EXECUTED 1081a7: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED 1081ad: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED 1081b0: 52 push %edx <== NOT EXECUTED 1081b1: ff d0 call *%eax <== NOT EXECUTED tty->tty_rcvwakeup = 1; 1081b3: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED 1081ba: 00 00 00 <== NOT EXECUTED 1081bd: e9 de 01 00 00 jmp 1083a0 <== NOT EXECUTED } return 0; } while (len--) { c = *buf++; 1081c2: 8a 07 mov (%edi),%al <== NOT EXECUTED 1081c4: 88 45 df mov %al,-0x21(%ebp) <== NOT EXECUTED /* FIXME: implement IXANY: any character restarts output */ /* if incoming XON/XOFF controls outgoing stream: */ if (tty->flow_ctrl & FL_MDXON) { 1081c7: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1081cd: f6 c4 02 test $0x2,%ah <== NOT EXECUTED 1081d0: 74 47 je 108219 <== NOT EXECUTED /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { 1081d2: 0f be 45 df movsbl -0x21(%ebp),%eax <== NOT EXECUTED 1081d6: 0f b6 53 4a movzbl 0x4a(%ebx),%edx <== NOT EXECUTED 1081da: 39 d0 cmp %edx,%eax <== NOT EXECUTED 1081dc: 75 28 jne 108206 <== NOT EXECUTED if (c == tty->termios.c_cc[VSTART]) { 1081de: 0f b6 53 49 movzbl 0x49(%ebx),%edx <== NOT EXECUTED 1081e2: 39 d0 cmp %edx,%eax <== NOT EXECUTED 1081e4: 75 0b jne 1081f1 <== NOT EXECUTED /* received VSTOP and VSTART==VSTOP? */ /* then toggle "stop output" status */ tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; 1081e6: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1081ec: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED 1081ef: eb 09 jmp 1081fa <== NOT EXECUTED } else { /* VSTOP received (other code than VSTART) */ /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; 1081f1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1081f7: 83 c8 10 or $0x10,%eax <== NOT EXECUTED 1081fa: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } } } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped; 108200: c6 45 de 01 movb $0x1,-0x22(%ebp) <== NOT EXECUTED 108204: eb 19 jmp 10821f <== NOT EXECUTED /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; } flow_rcv = true; } else if (c == tty->termios.c_cc[VSTART]) { 108206: 0f b6 53 49 movzbl 0x49(%ebx),%edx <== NOT EXECUTED 10820a: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10820c: 75 0b jne 108219 <== NOT EXECUTED /* VSTART received */ /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; 10820e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108214: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED 108217: eb e1 jmp 1081fa <== NOT EXECUTED flow_rcv = true; } } if (flow_rcv) { 108219: 80 7d de 00 cmpb $0x0,-0x22(%ebp) <== NOT EXECUTED 10821d: 74 51 je 108270 <== NOT EXECUTED /* restart output according to FL_ORCVXOF flag */ if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) { 10821f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108225: 83 e0 30 and $0x30,%eax <== NOT EXECUTED 108228: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED 10822b: 0f 85 53 01 00 00 jne 108384 <== NOT EXECUTED /* disable interrupts */ rtems_interrupt_disable(level); 108231: 9c pushf <== NOT EXECUTED 108232: fa cli <== NOT EXECUTED 108233: 8f 45 e4 popl -0x1c(%ebp) <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 108236: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10823c: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 10823f: 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) { 108245: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 10824c: 74 19 je 108267 <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)(tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1); 10824e: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED rtems_interrupt_disable(level); tty->flow_ctrl &= ~FL_OSTOP; /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { /* if chars available, call write function... */ (*tty->device.write)(tty->minor, 108254: 52 push %edx <== NOT EXECUTED 108255: 6a 01 push $0x1 <== NOT EXECUTED 108257: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 10825a: 50 push %eax <== NOT EXECUTED 10825b: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10825e: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 108264: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1); } /* reenable interrupts */ rtems_interrupt_enable(level); 108267: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 10826a: 9d popf <== NOT EXECUTED 10826b: e9 14 01 00 00 jmp 108384 <== NOT EXECUTED } } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; 108270: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED 108273: 8b 4b 64 mov 0x64(%ebx),%ecx <== NOT EXECUTED 108276: 40 inc %eax <== NOT EXECUTED 108277: 31 d2 xor %edx,%edx <== NOT EXECUTED 108279: f7 f1 div %ecx <== NOT EXECUTED 10827b: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); 10827e: 9c pushf <== NOT EXECUTED 10827f: fa cli <== NOT EXECUTED 108280: 8f 45 d4 popl -0x2c(%ebp) <== NOT EXECUTED if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 108283: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED 108286: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED 108289: 8b 4b 64 mov 0x64(%ebx),%ecx <== NOT EXECUTED 10828c: 29 d0 sub %edx,%eax <== NOT EXECUTED 10828e: 03 45 e4 add -0x1c(%ebp),%eax <== NOT EXECUTED 108291: 31 d2 xor %edx,%edx <== NOT EXECUTED 108293: f7 f1 div %ecx <== NOT EXECUTED % tty->rawInBuf.Size) > tty->highwater) && 108295: 3b 93 c0 00 00 00 cmp 0xc0(%ebx),%edx <== NOT EXECUTED 10829b: 0f 86 98 00 00 00 jbe 108339 <== NOT EXECUTED !(tty->flow_ctrl & FL_IREQXOF)) { 1082a1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 1082a7: a8 01 test $0x1,%al <== NOT EXECUTED 1082a9: 0f 85 8a 00 00 00 jne 108339 <== NOT EXECUTED % tty->rawInBuf.Size) > tty->highwater) && !(tty->flow_ctrl & FL_IREQXOF)) { /* incoming data stream should be stopped */ tty->flow_ctrl |= FL_IREQXOF; 1082af: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1082b5: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 1082b8: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF)) 1082be: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1082c4: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED 1082c9: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED 1082ce: 75 33 jne 108303 <== NOT EXECUTED == (FL_MDXOF ) ){ if ((tty->flow_ctrl & FL_OSTOP) || 1082d0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1082d6: a8 20 test $0x20,%al <== NOT EXECUTED 1082d8: 75 09 jne 1082e3 <== NOT EXECUTED (tty->rawOutBufState == rob_idle)) { 1082da: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 1082e1: 75 56 jne 108339 <== NOT EXECUTED /* if tx is stopped due to XOFF or out of data */ /* call write function here */ tty->flow_ctrl |= FL_ISNTXOF; 1082e3: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1082e9: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 1082ec: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED (*tty->device.write)(tty->minor, 1082f2: 50 push %eax <== NOT EXECUTED 1082f3: 6a 01 push $0x1 <== NOT EXECUTED 1082f5: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED 1082f8: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1082fb: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 108301: eb 33 jmp 108336 <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTOP]), 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) 108303: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108309: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED 10830e: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED 108313: 75 24 jne 108339 <== NOT EXECUTED == (FL_MDRTS ) ) { tty->flow_ctrl |= FL_IRTSOFF; 108315: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10831b: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 10831e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* deactivate RTS line */ if (tty->device.stopRemoteTx != NULL) { 108324: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED 10832a: 85 c0 test %eax,%eax <== NOT EXECUTED 10832c: 74 0b je 108339 <== NOT EXECUTED tty->device.stopRemoteTx(tty->minor); 10832e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108331: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108334: ff d0 call *%eax <== NOT EXECUTED 108336: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } } /* reenable interrupts */ rtems_interrupt_enable(level); 108339: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 10833c: 9d popf <== NOT EXECUTED if (newTail == tty->rawInBuf.Head) { 10833d: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED 108340: 39 45 e4 cmp %eax,-0x1c(%ebp) <== NOT EXECUTED 108343: 75 03 jne 108348 <== NOT EXECUTED dropped++; 108345: 46 inc %esi <== NOT EXECUTED 108346: eb 3c jmp 108384 <== NOT EXECUTED } else { tty->rawInBuf.theBuf[newTail] = c; 108348: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED 10834b: 8a 4d df mov -0x21(%ebp),%cl <== NOT EXECUTED 10834e: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 108351: 88 0c 10 mov %cl,(%eax,%edx,1) <== NOT EXECUTED tty->rawInBuf.Tail = newTail; 108354: 89 53 60 mov %edx,0x60(%ebx) <== NOT EXECUTED /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 108357: 83 bb e4 00 00 00 00 cmpl $0x0,0xe4(%ebx) <== NOT EXECUTED 10835e: 75 24 jne 108384 <== NOT EXECUTED 108360: 8b 83 dc 00 00 00 mov 0xdc(%ebx),%eax <== NOT EXECUTED 108366: 85 c0 test %eax,%eax <== NOT EXECUTED 108368: 74 1a je 108384 <== NOT EXECUTED (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 10836a: 51 push %ecx <== NOT EXECUTED 10836b: 51 push %ecx <== NOT EXECUTED 10836c: ff b3 e0 00 00 00 pushl 0xe0(%ebx) <== NOT EXECUTED 108372: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 108375: ff d0 call *%eax <== NOT EXECUTED tty->tty_rcvwakeup = 1; 108377: c7 83 e4 00 00 00 01 movl $0x1,0xe4(%ebx) <== NOT EXECUTED 10837e: 00 00 00 <== NOT EXECUTED 108381: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } while (len--) { c = *buf++; 108384: 47 inc %edi <== NOT EXECUTED 108385: ff 4d e0 decl -0x20(%ebp) <== NOT EXECUTED tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 108388: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) <== NOT EXECUTED 10838c: 0f 85 30 fe ff ff jne 1081c2 <== NOT EXECUTED tty->tty_rcvwakeup = 1; } } } } tty->rawInBufDropped += dropped; 108392: 01 73 78 add %esi,0x78(%ebx) <== NOT EXECUTED rtems_semaphore_release (tty->rawInBuf.Semaphore); 108395: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108398: ff 73 68 pushl 0x68(%ebx) <== NOT EXECUTED 10839b: e8 c8 1c 00 00 call 10a068 <== NOT EXECUTED return dropped; 1083a0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1083a3: eb 02 jmp 1083a7 <== NOT EXECUTED 1083a5: 31 f6 xor %esi,%esi <== NOT EXECUTED } 1083a7: 89 f0 mov %esi,%eax <== NOT EXECUTED 1083a9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1083ac: 5b pop %ebx <== NOT EXECUTED 1083ad: 5e pop %esi <== NOT EXECUTED 1083ae: 5f pop %edi <== NOT EXECUTED 1083af: c9 leave <== NOT EXECUTED 1083b0: c3 ret <== NOT EXECUTED 00107e88 : struct rtems_termios_tty *rtems_termios_ttyTail; rtems_id rtems_termios_ttyMutex; void rtems_termios_initialize (void) { 107e88: 55 push %ebp 107e89: 89 e5 mov %esp,%ebp 107e8b: 83 ec 08 sub $0x8,%esp rtems_status_code sc; /* * Create the mutex semaphore for the tty list */ if (!rtems_termios_ttyMutex) { 107e8e: 83 3d a8 38 12 00 00 cmpl $0x0,0x1238a8 107e95: 75 28 jne 107ebf sc = rtems_semaphore_create ( 107e97: 83 ec 0c sub $0xc,%esp 107e9a: 68 a8 38 12 00 push $0x1238a8 107e9f: 6a 00 push $0x0 107ea1: 6a 54 push $0x54 107ea3: 6a 01 push $0x1 107ea5: 68 69 6d 52 54 push $0x54526d69 107eaa: e8 a1 1e 00 00 call 109d50 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) 107eaf: 83 c4 20 add $0x20,%esp 107eb2: 85 c0 test %eax,%eax 107eb4: 74 09 je 107ebf rtems_fatal_error_occurred (sc); 107eb6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107eb9: 50 push %eax <== NOT EXECUTED 107eba: e8 75 26 00 00 call 10a534 <== NOT EXECUTED } } 107ebf: c9 leave 107ec0: c3 ret 00108d03 : } } rtems_status_code rtems_termios_ioctl (void *arg) { 108d03: 55 push %ebp 108d04: 89 e5 mov %esp,%ebp 108d06: 57 push %edi 108d07: 56 push %esi 108d08: 53 push %ebx 108d09: 83 ec 20 sub $0x20,%esp rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 108d0c: 8b 55 08 mov 0x8(%ebp),%edx 108d0f: 8b 02 mov (%edx),%eax 108d11: 8b 58 34 mov 0x34(%eax),%ebx struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer; 108d14: 8b 72 08 mov 0x8(%edx),%esi rtems_status_code sc; args->ioctl_return = 0; 108d17: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 108d1e: 6a 00 push $0x0 108d20: 6a 00 push $0x0 108d22: ff 73 18 pushl 0x18(%ebx) 108d25: e8 52 12 00 00 call 109f7c 108d2a: 89 45 e4 mov %eax,-0x1c(%ebp) if (sc != RTEMS_SUCCESSFUL) { 108d2d: 83 c4 10 add $0x10,%esp 108d30: 85 c0 test %eax,%eax 108d32: 74 0b je 108d3f args->ioctl_return = sc; 108d34: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 108d37: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED return sc; 108d3a: e9 04 03 00 00 jmp 109043 <== NOT EXECUTED } switch (args->command) { 108d3f: 8b 55 08 mov 0x8(%ebp),%edx 108d42: 8b 42 04 mov 0x4(%edx),%eax 108d45: 83 f8 04 cmp $0x4,%eax 108d48: 0f 84 4c 02 00 00 je 108f9a 108d4e: 77 10 ja 108d60 108d50: 83 f8 02 cmp $0x2,%eax 108d53: 74 77 je 108dcc 108d55: 0f 87 1d 02 00 00 ja 108f78 108d5b: 48 dec %eax 108d5c: 75 2f jne 108d8d 108d5e: eb 55 jmp 108db5 108d60: 3d 7f 66 04 40 cmp $0x4004667f,%eax <== NOT EXECUTED 108d65: 0f 84 a4 02 00 00 je 10900f <== NOT EXECUTED 108d6b: 77 0a ja 108d77 <== NOT EXECUTED 108d6d: 83 f8 05 cmp $0x5,%eax <== NOT EXECUTED 108d70: 75 1b jne 108d8d <== NOT EXECUTED 108d72: e9 0d 02 00 00 jmp 108f84 <== NOT EXECUTED 108d77: 3d 1a 74 04 40 cmp $0x4004741a,%eax <== NOT EXECUTED 108d7c: 0f 84 7d 02 00 00 je 108fff <== NOT EXECUTED 108d82: 3d 1b 74 04 80 cmp $0x8004741b,%eax <== NOT EXECUTED 108d87: 0f 84 20 02 00 00 je 108fad <== NOT EXECUTED default: if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) { 108d8d: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 108d93: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 108d96: 8b 80 64 35 12 00 mov 0x123564(%eax),%eax <== NOT EXECUTED 108d9c: c7 45 e4 0a 00 00 00 movl $0xa,-0x1c(%ebp) <== NOT EXECUTED 108da3: 85 c0 test %eax,%eax <== NOT EXECUTED 108da5: 0f 84 81 02 00 00 je 10902c <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args); 108dab: 52 push %edx <== NOT EXECUTED 108dac: 52 push %edx <== NOT EXECUTED 108dad: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 108db0: e9 3f 02 00 00 jmp 108ff4 <== NOT EXECUTED sc = RTEMS_INVALID_NUMBER; } break; case RTEMS_IO_GET_ATTRIBUTES: *(struct termios *)args->buffer = tty->termios; 108db5: 8b 4d 08 mov 0x8(%ebp),%ecx 108db8: 8b 41 08 mov 0x8(%ecx),%eax 108dbb: 8d 73 30 lea 0x30(%ebx),%esi 108dbe: b9 09 00 00 00 mov $0x9,%ecx 108dc3: 89 c7 mov %eax,%edi 108dc5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) break; 108dc7: e9 60 02 00 00 jmp 10902c case RTEMS_IO_SET_ATTRIBUTES: tty->termios = *(struct termios *)args->buffer; 108dcc: 8b 45 08 mov 0x8(%ebp),%eax 108dcf: 8b 70 08 mov 0x8(%eax),%esi 108dd2: 8d 7b 30 lea 0x30(%ebx),%edi 108dd5: b9 09 00 00 00 mov $0x9,%ecx 108dda: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * check for flow control options to be switched off */ /* check for outgoing XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXON) && 108ddc: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108de2: f6 c4 02 test $0x2,%ah 108de5: 74 57 je 108e3e 108de7: f6 43 31 04 testb $0x4,0x31(%ebx) 108deb: 75 51 jne 108e3e !(tty->termios.c_iflag & IXON)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF); 108ded: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108df3: 25 ef fd ff ff and $0xfffffdef,%eax <== NOT EXECUTED 108df8: 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) { 108dfe: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108e04: a8 20 test $0x20,%al <== NOT EXECUTED 108e06: 74 36 je 108e3e <== NOT EXECUTED /* disable interrupts */ rtems_interrupt_disable(level); 108e08: 9c pushf <== NOT EXECUTED 108e09: fa cli <== NOT EXECUTED 108e0a: 5e pop %esi <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 108e0b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108e11: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 108e14: 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) { 108e1a: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 108e21: 74 19 je 108e3c <== NOT EXECUTED /* if chars available, call write function... */ (*tty->device.write)(tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 108e23: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED rtems_interrupt_disable(level); tty->flow_ctrl &= ~FL_OSTOP; /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { /* if chars available, call write function... */ (*tty->device.write)(tty->minor, 108e29: 57 push %edi <== NOT EXECUTED 108e2a: 6a 01 push $0x1 <== NOT EXECUTED 108e2c: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 108e2f: 50 push %eax <== NOT EXECUTED 108e30: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108e33: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 108e39: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } /* reenable interrupts */ rtems_interrupt_enable(level); 108e3c: 56 push %esi <== NOT EXECUTED 108e3d: 9d popf <== NOT EXECUTED } } /* check for incoming XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXOF) && 108e3e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108e44: f6 c4 04 test $0x4,%ah 108e47: 74 24 je 108e6d 108e49: f6 43 31 10 testb $0x10,0x31(%ebx) <== NOT EXECUTED 108e4d: 75 1e jne 108e6d <== NOT EXECUTED !(tty->termios.c_iflag & IXOFF)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXOF); 108e4f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108e55: 80 e4 fb and $0xfb,%ah <== NOT EXECUTED 108e58: 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); 108e5e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108e64: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 108e67: 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) && 108e6d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108e73: f6 c4 01 test $0x1,%ah 108e76: 74 43 je 108ebb 108e78: 83 7b 38 00 cmpl $0x0,0x38(%ebx) <== NOT EXECUTED 108e7c: 78 3d js 108ebb <== NOT EXECUTED !(tty->termios.c_cflag & CRTSCTS)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDRTS); 108e7e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108e84: 80 e4 fe and $0xfe,%ah <== NOT EXECUTED 108e87: 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) && 108e8d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108e93: a8 04 test $0x4,%al <== NOT EXECUTED 108e95: 74 15 je 108eac <== NOT EXECUTED (tty->device.startRemoteTx != NULL)) { 108e97: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED !(tty->termios.c_cflag & CRTSCTS)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDRTS); /* restart remote Tx, if it was stopped */ if ((tty->flow_ctrl & FL_IRTSOFF) && 108e9d: 85 c0 test %eax,%eax <== NOT EXECUTED 108e9f: 74 0b je 108eac <== NOT EXECUTED (tty->device.startRemoteTx != NULL)) { tty->device.startRemoteTx(tty->minor); 108ea1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108ea4: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108ea7: ff d0 call *%eax <== NOT EXECUTED 108ea9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } tty->flow_ctrl &= ~(FL_IRTSOFF); 108eac: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108eb2: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 108eb5: 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) { 108ebb: 83 7b 38 00 cmpl $0x0,0x38(%ebx) 108ebf: 79 0f jns 108ed0 tty->flow_ctrl |= FL_MDRTS; 108ec1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108ec7: 80 cc 01 or $0x1,%ah <== NOT EXECUTED 108eca: 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) { 108ed0: f6 43 31 10 testb $0x10,0x31(%ebx) 108ed4: 74 0f je 108ee5 tty->flow_ctrl |= FL_MDXOF; 108ed6: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108edc: 80 cc 04 or $0x4,%ah <== NOT EXECUTED 108edf: 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) { 108ee5: f6 43 31 04 testb $0x4,0x31(%ebx) 108ee9: 74 0f je 108efa tty->flow_ctrl |= FL_MDXON; 108eeb: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108ef1: 80 cc 02 or $0x2,%ah 108ef4: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) tty->termios = *(struct termios *)args->buffer; /* check for and process change in flow control options */ termios_set_flowctrl(tty); if (tty->termios.c_lflag & ICANON) { 108efa: f6 43 3c 02 testb $0x2,0x3c(%ebx) 108efe: 75 39 jne 108f39 tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { tty->vtimeTicks = tty->termios.c_cc[VTIME] * rtems_clock_get_ticks_per_second() / 10; 108f00: 0f b6 73 46 movzbl 0x46(%ebx),%esi <== NOT EXECUTED 108f04: e8 2f 0a 00 00 call 109938 <== NOT EXECUTED tty->rawInBufSemaphoreOptions = RTEMS_WAIT; tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { tty->vtimeTicks = tty->termios.c_cc[VTIME] * 108f09: 0f af c6 imul %esi,%eax <== NOT EXECUTED 108f0c: b9 0a 00 00 00 mov $0xa,%ecx <== NOT EXECUTED 108f11: 31 d2 xor %edx,%edx <== NOT EXECUTED 108f13: f7 f1 div %ecx <== NOT EXECUTED 108f15: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED rtems_clock_get_ticks_per_second() / 10; if (tty->termios.c_cc[VTIME]) { 108f18: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED 108f1c: 74 15 je 108f33 <== NOT EXECUTED tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 108f1e: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = tty->vtimeTicks; 108f25: 89 43 70 mov %eax,0x70(%ebx) <== NOT EXECUTED if (tty->termios.c_cc[VMIN]) 108f28: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED 108f2c: 75 19 jne 108f47 <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; 108f2e: 89 43 74 mov %eax,0x74(%ebx) <== NOT EXECUTED 108f31: eb 24 jmp 108f57 <== NOT EXECUTED } else { if (tty->termios.c_cc[VMIN]) { 108f33: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED 108f37: 74 17 je 108f50 <== NOT EXECUTED tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 108f39: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; 108f40: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; 108f47: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx) 108f4e: eb 07 jmp 108f57 } else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; 108f50: c7 43 6c 01 00 00 00 movl $0x1,0x6c(%ebx) <== NOT EXECUTED } } } if (tty->device.setAttributes) 108f57: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax 108f5d: 85 c0 test %eax,%eax 108f5f: 0f 84 c7 00 00 00 je 10902c (*tty->device.setAttributes)(tty->minor, &tty->termios); 108f65: 56 push %esi 108f66: 56 push %esi 108f67: 8d 53 30 lea 0x30(%ebx),%edx 108f6a: 52 push %edx 108f6b: ff 73 10 pushl 0x10(%ebx) 108f6e: ff d0 call *%eax 108f70: 83 c4 10 add $0x10,%esp 108f73: e9 b4 00 00 00 jmp 10902c break; case RTEMS_IO_TCDRAIN: drainOutput (tty); 108f78: 89 d8 mov %ebx,%eax 108f7a: e8 53 fa ff ff call 1089d2 break; 108f7f: e9 a8 00 00 00 jmp 10902c case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; 108f84: 8b 06 mov (%esi),%eax <== NOT EXECUTED 108f86: 8b 56 04 mov 0x4(%esi),%edx <== NOT EXECUTED 108f89: 89 83 d4 00 00 00 mov %eax,0xd4(%ebx) <== NOT EXECUTED 108f8f: 89 93 d8 00 00 00 mov %edx,0xd8(%ebx) <== NOT EXECUTED break; 108f95: e9 92 00 00 00 jmp 10902c <== NOT EXECUTED case RTEMS_IO_RCVWAKEUP: tty->tty_rcv = *wakeup; 108f9a: 8b 06 mov (%esi),%eax <== NOT EXECUTED 108f9c: 8b 56 04 mov 0x4(%esi),%edx <== NOT EXECUTED 108f9f: 89 83 dc 00 00 00 mov %eax,0xdc(%ebx) <== NOT EXECUTED 108fa5: 89 93 e0 00 00 00 mov %edx,0xe0(%ebx) <== NOT EXECUTED break; 108fab: eb 7f jmp 10902c <== NOT EXECUTED #if 1 /* FIXME */ case TIOCSETD: /* * close old line discipline */ if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 108fad: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 108fb3: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 108fb6: 8b 80 50 35 12 00 mov 0x123550(%eax),%eax <== NOT EXECUTED 108fbc: 85 c0 test %eax,%eax <== NOT EXECUTED 108fbe: 74 0c je 108fcc <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_close(tty); 108fc0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108fc3: 53 push %ebx <== NOT EXECUTED 108fc4: ff d0 call *%eax <== NOT EXECUTED 108fc6: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED 108fc9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } tty->t_line=*(int*)(args->buffer); 108fcc: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 108fcf: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 108fd2: 8b 00 mov (%eax),%eax <== NOT EXECUTED 108fd4: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx) <== NOT EXECUTED tty->t_sc = NULL; /* ensure that no more valid data */ 108fda: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx) <== NOT EXECUTED 108fe1: 00 00 00 <== NOT EXECUTED /* * open new line discipline */ if (rtems_termios_linesw[tty->t_line].l_open != NULL) { 108fe4: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 108fe7: 8b 80 4c 35 12 00 mov 0x12354c(%eax),%eax <== NOT EXECUTED 108fed: 85 c0 test %eax,%eax <== NOT EXECUTED 108fef: 74 3b je 10902c <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_open(tty); 108ff1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108ff4: 53 push %ebx <== NOT EXECUTED 108ff5: ff d0 call *%eax <== NOT EXECUTED 108ff7: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED 108ffa: e9 71 ff ff ff jmp 108f70 <== NOT EXECUTED } break; case TIOCGETD: *(int*)(args->buffer)=tty->t_line; 108fff: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 109002: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 109005: 8b 93 cc 00 00 00 mov 0xcc(%ebx),%edx <== NOT EXECUTED 10900b: 89 10 mov %edx,(%eax) <== NOT EXECUTED break; 10900d: eb 1d jmp 10902c <== NOT EXECUTED #endif case FIONREAD: { int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head; 10900f: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED 109012: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED if ( rawnc < 0 ) 109015: 29 d0 sub %edx,%eax <== NOT EXECUTED 109017: 79 05 jns 10901e <== NOT EXECUTED rawnc += tty->rawInBuf.Size; 109019: 8b 53 64 mov 0x64(%ebx),%edx <== NOT EXECUTED 10901c: 01 d0 add %edx,%eax <== NOT EXECUTED /* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; 10901e: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 109021: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED 109024: 03 43 20 add 0x20(%ebx),%eax <== NOT EXECUTED 109027: 2b 43 24 sub 0x24(%ebx),%eax <== NOT EXECUTED 10902a: 89 02 mov %eax,(%edx) <== NOT EXECUTED } break; } rtems_semaphore_release (tty->osem); 10902c: 83 ec 0c sub $0xc,%esp 10902f: ff 73 18 pushl 0x18(%ebx) 109032: e8 31 10 00 00 call 10a068 args->ioctl_return = sc; 109037: 8b 55 e4 mov -0x1c(%ebp),%edx 10903a: 8b 45 08 mov 0x8(%ebp),%eax 10903d: 89 50 0c mov %edx,0xc(%eax) return sc; 109040: 83 c4 10 add $0x10,%esp } 109043: 8b 45 e4 mov -0x1c(%ebp),%eax 109046: 8d 65 f4 lea -0xc(%ebp),%esp 109049: 5b pop %ebx 10904a: 5e pop %esi 10904b: 5f pop %edi 10904c: c9 leave 10904d: c3 ret 001091cb : rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) { 1091cb: 55 push %ebp 1091cc: 89 e5 mov %esp,%ebp 1091ce: 57 push %edi 1091cf: 56 push %esi 1091d0: 53 push %ebx 1091d1: 83 ec 20 sub $0x20,%esp 1091d4: 8b 75 14 mov 0x14(%ebp),%esi struct rtems_termios_tty *tty; /* * See if the device has already been opened */ sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, 1091d7: 6a 00 push $0x0 1091d9: 6a 00 push $0x0 1091db: ff 35 a8 38 12 00 pushl 0x1238a8 1091e1: e8 96 0d 00 00 call 109f7c 1091e6: 89 45 e4 mov %eax,-0x1c(%ebp) RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 1091e9: 83 c4 10 add $0x10,%esp 1091ec: 85 c0 test %eax,%eax 1091ee: 0f 85 cf 03 00 00 jne 1095c3 return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 1091f4: 8b 15 b0 38 12 00 mov 0x1238b0,%edx 1091fa: eb 16 jmp 109212 if ((tty->major == major) && (tty->minor == minor)) 1091fc: 8b 45 08 mov 0x8(%ebp),%eax 1091ff: 39 42 0c cmp %eax,0xc(%edx) 109202: 75 0c jne 109210 109204: 8b 4d 0c mov 0xc(%ebp),%ecx 109207: 39 4a 10 cmp %ecx,0x10(%edx) 10920a: 0f 84 24 03 00 00 je 109534 */ 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) { 109210: 8b 12 mov (%edx),%edx 109212: 85 d2 test %edx,%edx 109214: 75 e6 jne 1091fc 109216: e9 b3 03 00 00 jmp 1095ce /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); if (tty == NULL) { rtems_semaphore_release (rtems_termios_ttyMutex); 10921b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10921e: e9 98 00 00 00 jmp 1092bb <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; 109223: a1 7c 17 12 00 mov 0x12177c,%eax 109228: 89 42 64 mov %eax,0x64(%edx) tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size); 10922b: 8b 42 64 mov 0x64(%edx),%eax 10922e: 83 ec 0c sub $0xc,%esp 109231: 50 push %eax 109232: 89 55 e0 mov %edx,-0x20(%ebp) 109235: e8 72 e1 ff ff call 1073ac 10923a: 8b 55 e0 mov -0x20(%ebp),%edx 10923d: 89 42 58 mov %eax,0x58(%edx) if (tty->rawInBuf.theBuf == NULL) { 109240: 83 c4 10 add $0x10,%esp 109243: 85 c0 test %eax,%eax 109245: 75 05 jne 10924c free(tty); 109247: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10924a: eb 68 jmp 1092b4 <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate raw output buffer */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; 10924c: a1 80 17 12 00 mov 0x121780,%eax 109251: 89 82 88 00 00 00 mov %eax,0x88(%edx) tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size); 109257: 8b 82 88 00 00 00 mov 0x88(%edx),%eax 10925d: 83 ec 0c sub $0xc,%esp 109260: 50 push %eax 109261: 89 55 e0 mov %edx,-0x20(%ebp) 109264: e8 43 e1 ff ff call 1073ac 109269: 8b 55 e0 mov -0x20(%ebp),%edx 10926c: 89 42 7c mov %eax,0x7c(%edx) if (tty->rawOutBuf.theBuf == NULL) { 10926f: 83 c4 10 add $0x10,%esp 109272: 85 c0 test %eax,%eax 109274: 75 05 jne 10927b free((void *)(tty->rawInBuf.theBuf)); 109276: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109279: eb 2d jmp 1092a8 <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); 10927b: 83 ec 0c sub $0xc,%esp 10927e: ff 35 78 17 12 00 pushl 0x121778 109284: 89 55 e0 mov %edx,-0x20(%ebp) 109287: e8 20 e1 ff ff call 1073ac 10928c: 8b 55 e0 mov -0x20(%ebp),%edx 10928f: 89 42 1c mov %eax,0x1c(%edx) if (tty->cbuf == NULL) { 109292: 83 c4 10 add $0x10,%esp 109295: 85 c0 test %eax,%eax 109297: 75 39 jne 1092d2 free((void *)(tty->rawOutBuf.theBuf)); 109299: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10929c: ff 72 7c pushl 0x7c(%edx) <== NOT EXECUTED 10929f: e8 dc de ff ff call 107180 <== NOT EXECUTED free((void *)(tty->rawInBuf.theBuf)); 1092a4: 5b pop %ebx <== NOT EXECUTED 1092a5: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 1092a8: ff 72 58 pushl 0x58(%edx) <== NOT EXECUTED 1092ab: e8 d0 de ff ff call 107180 <== NOT EXECUTED free(tty); 1092b0: 59 pop %ecx <== NOT EXECUTED 1092b1: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 1092b4: 52 push %edx <== NOT EXECUTED 1092b5: e8 c6 de ff ff call 107180 <== NOT EXECUTED rtems_semaphore_release (rtems_termios_ttyMutex); 1092ba: 5a pop %edx <== NOT EXECUTED 1092bb: ff 35 a8 38 12 00 pushl 0x1238a8 <== NOT EXECUTED 1092c1: e8 a2 0d 00 00 call 10a068 <== NOT EXECUTED 1092c6: c7 45 e4 1a 00 00 00 movl $0x1a,-0x1c(%ebp) <== NOT EXECUTED 1092cd: e9 ee 02 00 00 jmp 1095c0 <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * Initialize wakeup callbacks */ tty->tty_snd.sw_pfn = NULL; 1092d2: c7 82 d4 00 00 00 00 movl $0x0,0xd4(%edx) 1092d9: 00 00 00 tty->tty_snd.sw_arg = NULL; 1092dc: c7 82 d8 00 00 00 00 movl $0x0,0xd8(%edx) 1092e3: 00 00 00 tty->tty_rcv.sw_pfn = NULL; 1092e6: c7 82 dc 00 00 00 00 movl $0x0,0xdc(%edx) 1092ed: 00 00 00 tty->tty_rcv.sw_arg = NULL; 1092f0: c7 82 e0 00 00 00 00 movl $0x0,0xe0(%edx) 1092f7: 00 00 00 tty->tty_rcvwakeup = 0; 1092fa: c7 82 e4 00 00 00 00 movl $0x0,0xe4(%edx) 109301: 00 00 00 /* * link tty */ tty->forw = rtems_termios_ttyHead; 109304: a1 b0 38 12 00 mov 0x1238b0,%eax 109309: 89 02 mov %eax,(%edx) tty->back = NULL; 10930b: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) if (rtems_termios_ttyHead != NULL) 109312: 85 c0 test %eax,%eax 109314: 74 03 je 109319 rtems_termios_ttyHead->back = tty; 109316: 89 50 04 mov %edx,0x4(%eax) rtems_termios_ttyHead = tty; 109319: 89 1d b0 38 12 00 mov %ebx,0x1238b0 if (rtems_termios_ttyTail == NULL) 10931f: 83 3d ac 38 12 00 00 cmpl $0x0,0x1238ac 109326: 75 06 jne 10932e rtems_termios_ttyTail = tty; 109328: 89 1d ac 38 12 00 mov %ebx,0x1238ac tty->minor = minor; 10932e: 8b 45 0c mov 0xc(%ebp),%eax 109331: 89 43 10 mov %eax,0x10(%ebx) tty->major = major; 109334: 8b 4d 08 mov 0x8(%ebp),%ecx 109337: 89 4b 0c mov %ecx,0xc(%ebx) /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 10933a: 83 ec 0c sub $0xc,%esp 10933d: 8d 43 14 lea 0x14(%ebx),%eax 109340: 50 push %eax 109341: 6a 00 push $0x0 109343: 6a 54 push $0x54 109345: 6a 01 push $0x1 109347: 0f be 05 84 17 12 00 movsbl 0x121784,%eax 10934e: 0d 00 69 52 54 or $0x54526900,%eax 109353: 50 push %eax 109354: 89 55 e0 mov %edx,-0x20(%ebp) 109357: e8 f4 09 00 00 call 109d50 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) 10935c: 83 c4 20 add $0x20,%esp 10935f: 85 c0 test %eax,%eax 109361: 8b 55 e0 mov -0x20(%ebp),%edx 109364: 0f 85 3f 02 00 00 jne 1095a9 rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 10936a: 83 ec 0c sub $0xc,%esp 10936d: 8d 43 18 lea 0x18(%ebx),%eax 109370: 50 push %eax 109371: 6a 00 push $0x0 109373: 6a 54 push $0x54 109375: 6a 01 push $0x1 109377: 0f be 05 84 17 12 00 movsbl 0x121784,%eax 10937e: 0d 00 6f 52 54 or $0x54526f00,%eax 109383: 50 push %eax 109384: 89 55 e0 mov %edx,-0x20(%ebp) 109387: e8 c4 09 00 00 call 109d50 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) 10938c: 83 c4 20 add $0x20,%esp 10938f: 85 c0 test %eax,%eax 109391: 8b 55 e0 mov -0x20(%ebp),%edx 109394: 0f 85 0f 02 00 00 jne 1095a9 rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 10939a: 83 ec 0c sub $0xc,%esp 10939d: 8d 83 8c 00 00 00 lea 0x8c(%ebx),%eax 1093a3: 50 push %eax 1093a4: 6a 00 push $0x0 1093a6: 6a 20 push $0x20 1093a8: 6a 00 push $0x0 1093aa: 0f be 05 84 17 12 00 movsbl 0x121784,%eax 1093b1: 0d 00 78 52 54 or $0x54527800,%eax 1093b6: 50 push %eax 1093b7: 89 55 e0 mov %edx,-0x20(%ebp) 1093ba: e8 91 09 00 00 call 109d50 rtems_build_name ('T', 'R', 'x', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO, RTEMS_NO_PRIORITY, &tty->rawOutBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 1093bf: 83 c4 20 add $0x20,%esp 1093c2: 85 c0 test %eax,%eax 1093c4: 8b 55 e0 mov -0x20(%ebp),%edx 1093c7: 0f 85 dc 01 00 00 jne 1095a9 rtems_fatal_error_occurred (sc); tty->rawOutBufState = rob_idle; 1093cd: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx) 1093d4: 00 00 00 /* * Set callbacks */ tty->device = *callbacks; 1093d7: 8d bb 98 00 00 00 lea 0x98(%ebx),%edi 1093dd: b9 08 00 00 00 mov $0x8,%ecx 1093e2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 1093e4: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 1093eb: 75 74 jne 109461 sc = rtems_task_create ( 1093ed: 50 push %eax <== NOT EXECUTED 1093ee: 50 push %eax <== NOT EXECUTED 1093ef: 8d 83 c8 00 00 00 lea 0xc8(%ebx),%eax <== NOT EXECUTED 1093f5: 50 push %eax <== NOT EXECUTED 1093f6: 6a 00 push $0x0 <== NOT EXECUTED 1093f8: 68 00 05 00 00 push $0x500 <== NOT EXECUTED 1093fd: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 109402: 6a 0a push $0xa <== NOT EXECUTED 109404: 0f be 05 84 17 12 00 movsbl 0x121784,%eax <== NOT EXECUTED 10940b: 0d 00 54 78 54 or $0x54785400,%eax <== NOT EXECUTED 109410: 50 push %eax <== NOT EXECUTED 109411: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED 109414: e8 df 0c 00 00 call 10a0f8 <== 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) 109419: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10941c: 85 c0 test %eax,%eax <== NOT EXECUTED 10941e: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 109421: 0f 85 82 01 00 00 jne 1095a9 <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_task_create ( 109427: 57 push %edi <== NOT EXECUTED 109428: 57 push %edi <== NOT EXECUTED 109429: 8d 83 c4 00 00 00 lea 0xc4(%ebx),%eax <== NOT EXECUTED 10942f: 50 push %eax <== NOT EXECUTED 109430: 6a 00 push $0x0 <== NOT EXECUTED 109432: 68 00 05 00 00 push $0x500 <== NOT EXECUTED 109437: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 10943c: 6a 09 push $0x9 <== NOT EXECUTED 10943e: 0f be 05 84 17 12 00 movsbl 0x121784,%eax <== NOT EXECUTED 109445: 0d 00 54 78 52 or $0x52785400,%eax <== NOT EXECUTED 10944a: 50 push %eax <== NOT EXECUTED 10944b: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED 10944e: e8 a5 0c 00 00 call 10a0f8 <== 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) 109453: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109456: 85 c0 test %eax,%eax <== NOT EXECUTED 109458: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 10945b: 0f 85 48 01 00 00 jne 1095a9 <== NOT EXECUTED rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || 109461: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx) 109468: 74 09 je 109473 (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ 10946a: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 109471: 75 30 jne 1094a3 sc = rtems_semaphore_create ( 109473: 83 ec 0c sub $0xc,%esp 109476: 8d 43 68 lea 0x68(%ebx),%eax 109479: 50 push %eax 10947a: 6a 00 push $0x0 10947c: 6a 24 push $0x24 10947e: 6a 00 push $0x0 109480: 0f be 05 84 17 12 00 movsbl 0x121784,%eax 109487: 0d 00 72 52 54 or $0x54527200,%eax 10948c: 50 push %eax 10948d: 89 55 e0 mov %edx,-0x20(%ebp) 109490: e8 bb 08 00 00 call 109d50 rtems_build_name ('T', 'R', 'r', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->rawInBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 109495: 83 c4 20 add $0x20,%esp 109498: 85 c0 test %eax,%eax 10949a: 8b 55 e0 mov -0x20(%ebp),%edx 10949d: 0f 85 06 01 00 00 jne 1095a9 } /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; 1094a3: c7 43 30 02 25 00 00 movl $0x2502,0x30(%ebx) tty->termios.c_oflag = OPOST | ONLCR | XTABS; 1094aa: c7 43 34 05 18 00 00 movl $0x1805,0x34(%ebx) tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; 1094b1: c7 43 38 bd 08 00 00 movl $0x8bd,0x38(%ebx) tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL; 1094b8: c7 43 3c 3b 82 00 00 movl $0x823b,0x3c(%ebx) tty->termios.c_cc[VINTR] = '\003'; 1094bf: c6 43 41 03 movb $0x3,0x41(%ebx) tty->termios.c_cc[VQUIT] = '\034'; 1094c3: c6 43 42 1c movb $0x1c,0x42(%ebx) tty->termios.c_cc[VERASE] = '\177'; 1094c7: c6 43 43 7f movb $0x7f,0x43(%ebx) tty->termios.c_cc[VKILL] = '\025'; 1094cb: c6 43 44 15 movb $0x15,0x44(%ebx) tty->termios.c_cc[VEOF] = '\004'; 1094cf: c6 43 45 04 movb $0x4,0x45(%ebx) tty->termios.c_cc[VEOL] = '\000'; 1094d3: c6 43 4c 00 movb $0x0,0x4c(%ebx) tty->termios.c_cc[VEOL2] = '\000'; 1094d7: c6 43 51 00 movb $0x0,0x51(%ebx) tty->termios.c_cc[VSTART] = '\021'; 1094db: c6 43 49 11 movb $0x11,0x49(%ebx) tty->termios.c_cc[VSTOP] = '\023'; 1094df: c6 43 4a 13 movb $0x13,0x4a(%ebx) tty->termios.c_cc[VSUSP] = '\032'; 1094e3: c6 43 4b 1a movb $0x1a,0x4b(%ebx) tty->termios.c_cc[VREPRINT] = '\022'; 1094e7: c6 43 4d 12 movb $0x12,0x4d(%ebx) tty->termios.c_cc[VDISCARD] = '\017'; 1094eb: c6 43 4e 0f movb $0xf,0x4e(%ebx) tty->termios.c_cc[VWERASE] = '\027'; 1094ef: c6 43 4f 17 movb $0x17,0x4f(%ebx) tty->termios.c_cc[VLNEXT] = '\026'; 1094f3: c6 43 50 16 movb $0x16,0x50(%ebx) /* start with no flow control, clear flow control flags */ tty->flow_ctrl = 0; 1094f7: c7 83 b8 00 00 00 00 movl $0x0,0xb8(%ebx) 1094fe: 00 00 00 /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2; 109501: 8b 43 64 mov 0x64(%ebx),%eax 109504: d1 e8 shr %eax 109506: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) tty->highwater = tty->rawInBuf.Size * 3/4; 10950c: 8b 43 64 mov 0x64(%ebx),%eax 10950f: 8d 04 40 lea (%eax,%eax,2),%eax 109512: c1 e8 02 shr $0x2,%eax 109515: 89 83 c0 00 00 00 mov %eax,0xc0(%ebx) /* * Bump name characer */ if (c++ == 'z') 10951b: a0 84 17 12 00 mov 0x121784,%al 109520: 8d 48 01 lea 0x1(%eax),%ecx 109523: 88 0d 84 17 12 00 mov %cl,0x121784 109529: 3c 7a cmp $0x7a,%al 10952b: 75 07 jne 109534 c = 'a'; 10952d: c6 05 84 17 12 00 61 movb $0x61,0x121784 <== NOT EXECUTED } args->iop->data1 = tty; 109534: 8b 4d 10 mov 0x10(%ebp),%ecx 109537: 8b 01 mov (%ecx),%eax 109539: 89 50 34 mov %edx,0x34(%eax) if (!tty->refcount++) { 10953c: 8b 42 08 mov 0x8(%edx),%eax 10953f: 8d 48 01 lea 0x1(%eax),%ecx 109542: 89 4a 08 mov %ecx,0x8(%edx) 109545: 85 c0 test %eax,%eax 109547: 75 69 jne 1095b2 if (tty->device.firstOpen) 109549: 8b 82 98 00 00 00 mov 0x98(%edx),%eax 10954f: 85 c0 test %eax,%eax 109551: 74 15 je 109568 (*tty->device.firstOpen)(major, minor, arg); 109553: 56 push %esi 109554: ff 75 10 pushl 0x10(%ebp) 109557: ff 75 0c pushl 0xc(%ebp) 10955a: ff 75 08 pushl 0x8(%ebp) 10955d: 89 55 e0 mov %edx,-0x20(%ebp) 109560: ff d0 call *%eax 109562: 83 c4 10 add $0x10,%esp 109565: 8b 55 e0 mov -0x20(%ebp),%edx /* * start I/O tasks, if needed */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 109568: 83 ba b4 00 00 00 02 cmpl $0x2,0xb4(%edx) 10956f: 75 41 jne 1095b2 sc = rtems_task_start(tty->rxTaskId, 109571: 53 push %ebx <== NOT EXECUTED 109572: 52 push %edx <== NOT EXECUTED 109573: 68 53 96 10 00 push $0x109653 <== NOT EXECUTED 109578: ff b2 c4 00 00 00 pushl 0xc4(%edx) <== NOT EXECUTED 10957e: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED 109581: e8 de 0d 00 00 call 10a364 <== NOT EXECUTED rtems_termios_rxdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 109586: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109589: 85 c0 test %eax,%eax <== NOT EXECUTED 10958b: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 10958e: 75 19 jne 1095a9 <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_task_start(tty->txTaskId, 109590: 51 push %ecx <== NOT EXECUTED 109591: 52 push %edx <== NOT EXECUTED 109592: 68 f0 95 10 00 push $0x1095f0 <== NOT EXECUTED 109597: ff b2 c8 00 00 00 pushl 0xc8(%edx) <== NOT EXECUTED 10959d: e8 c2 0d 00 00 call 10a364 <== NOT EXECUTED rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 1095a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1095a5: 85 c0 test %eax,%eax <== NOT EXECUTED 1095a7: 74 09 je 1095b2 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 1095a9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1095ac: 50 push %eax <== NOT EXECUTED 1095ad: e8 82 0f 00 00 call 10a534 <== NOT EXECUTED } } rtems_semaphore_release (rtems_termios_ttyMutex); 1095b2: 83 ec 0c sub $0xc,%esp 1095b5: ff 35 a8 38 12 00 pushl 0x1238a8 1095bb: e8 a8 0a 00 00 call 10a068 return RTEMS_SUCCESSFUL; 1095c0: 83 c4 10 add $0x10,%esp } 1095c3: 8b 45 e4 mov -0x1c(%ebp),%eax 1095c6: 8d 65 f4 lea -0xc(%ebp),%esp 1095c9: 5b pop %ebx 1095ca: 5e pop %esi 1095cb: 5f pop %edi 1095cc: c9 leave 1095cd: c3 ret static char c = 'a'; /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); 1095ce: 52 push %edx 1095cf: 52 push %edx 1095d0: 68 e8 00 00 00 push $0xe8 1095d5: 6a 01 push $0x1 1095d7: e8 00 45 00 00 call 10dadc 1095dc: 89 c2 mov %eax,%edx 1095de: 89 c3 mov %eax,%ebx if (tty == NULL) { 1095e0: 83 c4 10 add $0x10,%esp 1095e3: 85 c0 test %eax,%eax 1095e5: 0f 85 38 fc ff ff jne 109223 1095eb: e9 2b fc ff ff jmp 10921b <== NOT EXECUTED 001083b1 : * Send characters to device-specific code */ void rtems_termios_puts ( const void *_buf, int len, struct rtems_termios_tty *tty) { 1083b1: 55 push %ebp 1083b2: 89 e5 mov %esp,%ebp 1083b4: 57 push %edi 1083b5: 56 push %esi 1083b6: 53 push %ebx 1083b7: 83 ec 3c sub $0x3c,%esp 1083ba: 8b 45 08 mov 0x8(%ebp),%eax 1083bd: 8b 75 0c mov 0xc(%ebp),%esi 1083c0: 8b 5d 10 mov 0x10(%ebp),%ebx const unsigned char *buf = _buf; 1083c3: 89 c7 mov %eax,%edi unsigned int newHead; rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { 1083c5: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx) 1083cc: 75 1b jne 1083e9 (*tty->device.write)(tty->minor, (void *)buf, len); 1083ce: 89 75 10 mov %esi,0x10(%ebp) <== NOT EXECUTED 1083d1: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1083d4: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 1083d7: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 1083da: 8b 83 a4 00 00 00 mov 0xa4(%ebx),%eax <== NOT EXECUTED tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 1083e0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1083e3: 5b pop %ebx <== NOT EXECUTED 1083e4: 5e pop %esi <== NOT EXECUTED 1083e5: 5f pop %edi <== NOT EXECUTED 1083e6: 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); 1083e7: ff e0 jmp *%eax <== NOT EXECUTED return; } newHead = tty->rawOutBuf.Head; 1083e9: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 1083ef: 89 45 e4 mov %eax,-0x1c(%ebp) while (len) { 1083f2: e9 ca 00 00 00 jmp 1084c1 * len -= ncopy * * To minimize latency, the memcpy should be done * with interrupts enabled. */ newHead = (newHead + 1) % tty->rawOutBuf.Size; 1083f7: 8b 45 e4 mov -0x1c(%ebp),%eax 1083fa: 40 inc %eax 1083fb: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx 108401: 31 d2 xor %edx,%edx 108403: f7 f1 div %ecx 108405: 89 55 c4 mov %edx,-0x3c(%ebp) 108408: 89 55 e4 mov %edx,-0x1c(%ebp) rtems_interrupt_disable (level); 10840b: 9c pushf 10840c: fa cli 10840d: 8f 45 d4 popl -0x2c(%ebp) 108410: 8b 55 d4 mov -0x2c(%ebp),%edx 108413: 8b 4d c4 mov -0x3c(%ebp),%ecx while (newHead == tty->rawOutBuf.Tail) { 108416: eb 35 jmp 10844d tty->rawOutBufState = rob_wait; 108418: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) 10841f: 00 00 00 rtems_interrupt_enable (level); 108422: 52 push %edx 108423: 9d popf sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, 108424: 50 push %eax 108425: 6a 00 push $0x0 108427: 6a 00 push $0x0 108429: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 10842f: 89 4d e0 mov %ecx,-0x20(%ebp) 108432: e8 45 1b 00 00 call 109f7c RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 108437: 83 c4 10 add $0x10,%esp 10843a: 85 c0 test %eax,%eax 10843c: 8b 4d e0 mov -0x20(%ebp),%ecx 10843f: 74 09 je 10844a rtems_fatal_error_occurred (sc); 108441: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108444: 50 push %eax <== NOT EXECUTED 108445: e8 ea 20 00 00 call 10a534 <== NOT EXECUTED rtems_interrupt_disable (level); 10844a: 9c pushf 10844b: fa cli 10844c: 5a pop %edx * To minimize latency, the memcpy should be done * with interrupts enabled. */ newHead = (newHead + 1) % tty->rawOutBuf.Size; rtems_interrupt_disable (level); while (newHead == tty->rawOutBuf.Tail) { 10844d: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 108453: 39 c1 cmp %eax,%ecx 108455: 74 c1 je 108418 108457: 89 55 d4 mov %edx,-0x2c(%ebp) 10845a: 89 4d c4 mov %ecx,-0x3c(%ebp) RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++; 10845d: 8b 8b 80 00 00 00 mov 0x80(%ebx),%ecx 108463: 8a 07 mov (%edi),%al 108465: 8b 53 7c mov 0x7c(%ebx),%edx 108468: 88 04 0a mov %al,(%edx,%ecx,1) tty->rawOutBuf.Head = newHead; 10846b: 8b 4d c4 mov -0x3c(%ebp),%ecx 10846e: 89 8b 80 00 00 00 mov %ecx,0x80(%ebx) if (tty->rawOutBufState == rob_idle) { 108474: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) 10847b: 75 3e jne 1084bb /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { 10847d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108483: a8 10 test $0x10,%al 108485: 75 1b jne 1084a2 (*tty->device.write)(tty->minor, (char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); 108487: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++; tty->rawOutBuf.Head = newHead; if (tty->rawOutBufState == rob_idle) { /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { (*tty->device.write)(tty->minor, 10848d: 52 push %edx 10848e: 6a 01 push $0x1 108490: 03 43 7c add 0x7c(%ebx),%eax 108493: 50 push %eax 108494: ff 73 10 pushl 0x10(%ebx) 108497: ff 93 a4 00 00 00 call *0xa4(%ebx) 10849d: 83 c4 10 add $0x10,%esp 1084a0: eb 0f jmp 1084b1 (char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1); } else { /* remember that output has been stopped due to flow ctrl*/ tty->flow_ctrl |= FL_OSTOP; 1084a2: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1084a8: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 1084ab: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } tty->rawOutBufState = rob_busy; 1084b1: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) 1084b8: 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++; 1084bb: 47 inc %edi /* remember that output has been stopped due to flow ctrl*/ tty->flow_ctrl |= FL_OSTOP; } tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); 1084bc: ff 75 d4 pushl -0x2c(%ebp) 1084bf: 9d popf len--; 1084c0: 4e dec %esi if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, (void *)buf, len); return; } newHead = tty->rawOutBuf.Head; while (len) { 1084c1: 85 f6 test %esi,%esi 1084c3: 0f 85 2e ff ff ff jne 1083f7 tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 1084c9: 8d 65 f4 lea -0xc(%ebp),%esp 1084cc: 5b pop %ebx 1084cd: 5e pop %esi 1084ce: 5f pop %edi 1084cf: c9 leave 1084d0: c3 ret 00108a2f : return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) { 108a2f: 55 push %ebp <== NOT EXECUTED 108a30: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108a32: 57 push %edi <== NOT EXECUTED 108a33: 56 push %esi <== NOT EXECUTED 108a34: 53 push %ebx <== NOT EXECUTED 108a35: 83 ec 50 sub $0x50,%esp <== NOT EXECUTED 108a38: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 108a3b: 8b 06 mov (%esi),%eax <== NOT EXECUTED 108a3d: 8b 58 34 mov 0x34(%eax),%ebx <== NOT EXECUTED uint32_t count = args->count; 108a40: 8b 46 10 mov 0x10(%esi),%eax <== NOT EXECUTED 108a43: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED char *buffer = args->buffer; 108a46: 8b 4e 0c mov 0xc(%esi),%ecx <== NOT EXECUTED 108a49: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED rtems_status_code sc; sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 108a4c: 6a 00 push $0x0 <== NOT EXECUTED 108a4e: 6a 00 push $0x0 <== NOT EXECUTED 108a50: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 108a53: e8 24 15 00 00 call 109f7c <== NOT EXECUTED 108a58: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 108a5b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108a5e: 85 c0 test %eax,%eax <== NOT EXECUTED 108a60: 0f 85 92 02 00 00 jne 108cf8 <== NOT EXECUTED return sc; if (rtems_termios_linesw[tty->t_line].l_read != NULL) { 108a66: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 108a6c: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 108a6f: 8b 80 54 35 12 00 mov 0x123554(%eax),%eax <== NOT EXECUTED 108a75: 85 c0 test %eax,%eax <== NOT EXECUTED 108a77: 74 19 je 108a92 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_read(tty,args); 108a79: 51 push %ecx <== NOT EXECUTED 108a7a: 51 push %ecx <== NOT EXECUTED 108a7b: 56 push %esi <== NOT EXECUTED 108a7c: 53 push %ebx <== NOT EXECUTED 108a7d: ff d0 call *%eax <== NOT EXECUTED 108a7f: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED tty->tty_rcvwakeup = 0; 108a82: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) <== NOT EXECUTED 108a89: 00 00 00 <== NOT EXECUTED rtems_semaphore_release (tty->isem); 108a8c: 5a pop %edx <== NOT EXECUTED 108a8d: e9 5b 02 00 00 jmp 108ced <== NOT EXECUTED return sc; } if (tty->cindex == tty->ccount) { 108a92: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 108a95: 3b 43 20 cmp 0x20(%ebx),%eax <== NOT EXECUTED 108a98: 0f 85 25 02 00 00 jne 108cc3 <== NOT EXECUTED tty->cindex = tty->ccount = 0; 108a9e: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED 108aa5: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) <== NOT EXECUTED tty->read_start_column = tty->column; 108aac: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 108aaf: 89 43 2c mov %eax,0x2c(%ebx) <== NOT EXECUTED if (tty->device.pollRead != NULL 108ab2: 83 bb a0 00 00 00 00 cmpl $0x0,0xa0(%ebx) <== NOT EXECUTED 108ab9: 0f 84 c4 00 00 00 je 108b83 <== NOT EXECUTED && tty->device.outputUsesInterrupts == TERMIOS_POLLED) 108abf: 83 bb b4 00 00 00 00 cmpl $0x0,0xb4(%ebx) <== NOT EXECUTED 108ac6: 0f 85 b7 00 00 00 jne 108b83 <== NOT EXECUTED static rtems_status_code fillBufferPoll (struct rtems_termios_tty *tty) { int n; if (tty->termios.c_lflag & ICANON) { 108acc: f6 43 3c 02 testb $0x2,0x3c(%ebx) <== NOT EXECUTED 108ad0: 74 35 je 108b07 <== NOT EXECUTED for (;;) { n = (*tty->device.pollRead)(tty->minor); 108ad2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108ad5: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108ad8: ff 93 a0 00 00 00 call *0xa0(%ebx) <== NOT EXECUTED if (n < 0) { 108ade: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108ae1: 85 c0 test %eax,%eax <== NOT EXECUTED 108ae3: 79 0f jns 108af4 <== NOT EXECUTED rtems_task_wake_after (1); 108ae5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108ae8: 6a 01 push $0x1 <== NOT EXECUTED 108aea: e8 d9 18 00 00 call 10a3c8 <== NOT EXECUTED 108aef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108af2: eb de jmp 108ad2 <== NOT EXECUTED } else { if (siproc (n, tty)) 108af4: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 108af7: 89 da mov %ebx,%edx <== NOT EXECUTED 108af9: e8 db fd ff ff call 1088d9 <== NOT EXECUTED 108afe: 85 c0 test %eax,%eax <== NOT EXECUTED 108b00: 74 d0 je 108ad2 <== NOT EXECUTED 108b02: e9 bc 01 00 00 jmp 108cc3 <== NOT EXECUTED } } } else { rtems_interval then, now; then = rtems_clock_get_ticks_since_boot(); 108b07: e8 40 0e 00 00 call 10994c <== NOT EXECUTED 108b0c: 89 c7 mov %eax,%edi <== NOT EXECUTED for (;;) { n = (*tty->device.pollRead)(tty->minor); 108b0e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108b11: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108b14: ff 93 a0 00 00 00 call *0xa0(%ebx) <== NOT EXECUTED if (n < 0) { 108b1a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108b1d: 85 c0 test %eax,%eax <== NOT EXECUTED 108b1f: 79 3d jns 108b5e <== NOT EXECUTED if (tty->termios.c_cc[VMIN]) { 108b21: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED 108b25: 74 0e je 108b35 <== NOT EXECUTED if (tty->termios.c_cc[VTIME] && tty->ccount) { 108b27: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED 108b2b: 74 22 je 108b4f <== NOT EXECUTED 108b2d: 83 7b 20 00 cmpl $0x0,0x20(%ebx) <== NOT EXECUTED 108b31: 74 1c je 108b4f <== NOT EXECUTED 108b33: eb 0a jmp 108b3f <== NOT EXECUTED break; } } } else { if (!tty->termios.c_cc[VTIME]) 108b35: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED 108b39: 0f 84 84 01 00 00 je 108cc3 <== NOT EXECUTED break; now = rtems_clock_get_ticks_since_boot(); 108b3f: e8 08 0e 00 00 call 10994c <== NOT EXECUTED if ((now - then) > tty->vtimeTicks) { 108b44: 29 f8 sub %edi,%eax <== NOT EXECUTED 108b46: 3b 43 54 cmp 0x54(%ebx),%eax <== NOT EXECUTED 108b49: 0f 87 74 01 00 00 ja 108cc3 <== NOT EXECUTED break; } } rtems_task_wake_after (1); 108b4f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108b52: 6a 01 push $0x1 <== NOT EXECUTED 108b54: e8 6f 18 00 00 call 10a3c8 <== NOT EXECUTED 108b59: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108b5c: eb b0 jmp 108b0e <== NOT EXECUTED } else { siproc (n, tty); 108b5e: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 108b61: 89 da mov %ebx,%edx <== NOT EXECUTED 108b63: e8 71 fd ff ff call 1088d9 <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 108b68: 8a 43 47 mov 0x47(%ebx),%al <== NOT EXECUTED 108b6b: 0f b6 d0 movzbl %al,%edx <== NOT EXECUTED 108b6e: 39 53 20 cmp %edx,0x20(%ebx) <== NOT EXECUTED 108b71: 0f 8d 4c 01 00 00 jge 108cc3 <== NOT EXECUTED break; if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 108b77: 84 c0 test %al,%al <== NOT EXECUTED 108b79: 74 93 je 108b0e <== NOT EXECUTED 108b7b: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED 108b7f: 74 8d je 108b0e <== NOT EXECUTED 108b81: eb 84 jmp 108b07 <== 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; 108b83: 8b 53 74 mov 0x74(%ebx),%edx <== 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, 108b86: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED 108b89: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 108b8c: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED 108b91: e9 de 00 00 00 jmp 108c74 <== 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; 108b96: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED 108b99: 8b 4b 64 mov 0x64(%ebx),%ecx <== NOT EXECUTED 108b9c: 40 inc %eax <== NOT EXECUTED 108b9d: 31 d2 xor %edx,%edx <== NOT EXECUTED 108b9f: f7 f1 div %ecx <== NOT EXECUTED c = tty->rawInBuf.theBuf[newHead]; 108ba1: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED 108ba4: 8a 04 10 mov (%eax,%edx,1),%al <== NOT EXECUTED 108ba7: 88 45 d7 mov %al,-0x29(%ebp) <== NOT EXECUTED tty->rawInBuf.Head = newHead; 108baa: 89 53 5c mov %edx,0x5c(%ebx) <== NOT EXECUTED if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) 108bad: 8b 4b 60 mov 0x60(%ebx),%ecx <== NOT EXECUTED 108bb0: 89 4d c4 mov %ecx,-0x3c(%ebp) <== NOT EXECUTED 108bb3: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED 108bb6: 89 45 b4 mov %eax,-0x4c(%ebp) <== NOT EXECUTED 108bb9: 8b 4b 64 mov 0x64(%ebx),%ecx <== NOT EXECUTED 108bbc: 89 4d d8 mov %ecx,-0x28(%ebp) <== NOT EXECUTED 108bbf: 03 45 c4 add -0x3c(%ebp),%eax <== NOT EXECUTED 108bc2: 29 d0 sub %edx,%eax <== NOT EXECUTED 108bc4: 31 d2 xor %edx,%edx <== NOT EXECUTED 108bc6: f7 f1 div %ecx <== NOT EXECUTED 108bc8: 3b 93 bc 00 00 00 cmp 0xbc(%ebx),%edx <== NOT EXECUTED 108bce: 73 74 jae 108c44 <== NOT EXECUTED % tty->rawInBuf.Size) < tty->lowwater) { tty->flow_ctrl &= ~FL_IREQXOF; 108bd0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108bd6: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 108bd9: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* if tx stopped and XON should be sent... */ if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF)) 108bdf: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108be5: 25 02 02 00 00 and $0x202,%eax <== NOT EXECUTED 108bea: 3d 02 02 00 00 cmp $0x202,%eax <== NOT EXECUTED 108bef: 75 24 jne 108c15 <== NOT EXECUTED 108bf1: 83 bb 94 00 00 00 00 cmpl $0x0,0x94(%ebx) <== NOT EXECUTED 108bf8: 74 0a je 108c04 <== NOT EXECUTED == (FL_MDXON | FL_ISNTXOF)) && ((tty->rawOutBufState == rob_idle) || (tty->flow_ctrl & FL_OSTOP))) { 108bfa: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) % tty->rawInBuf.Size) < tty->lowwater) { tty->flow_ctrl &= ~FL_IREQXOF; /* if tx stopped and XON should be sent... */ if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF)) 108c00: a8 20 test $0x20,%al <== NOT EXECUTED 108c02: 74 11 je 108c15 <== 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, 108c04: 50 push %eax <== NOT EXECUTED 108c05: 6a 01 push $0x1 <== NOT EXECUTED 108c07: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED 108c0a: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108c0d: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 108c13: eb 2c jmp 108c41 <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTART]), 1); } else if (tty->flow_ctrl & FL_MDRTS) { 108c15: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108c1b: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 108c1e: 74 24 je 108c44 <== NOT EXECUTED tty->flow_ctrl &= ~FL_IRTSOFF; 108c20: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108c26: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 108c29: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* activate RTS line */ if (tty->device.startRemoteTx != NULL) { 108c2f: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 108c35: 85 c0 test %eax,%eax <== NOT EXECUTED 108c37: 74 0b je 108c44 <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 108c39: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108c3c: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108c3f: ff d0 call *%eax <== NOT EXECUTED 108c41: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { 108c44: f6 43 3c 02 testb $0x2,0x3c(%ebx) <== NOT EXECUTED 108c48: 74 11 je 108c5b <== NOT EXECUTED if (siproc (c, tty)) 108c4a: 0f b6 45 d7 movzbl -0x29(%ebp),%eax <== NOT EXECUTED 108c4e: 89 da mov %ebx,%edx <== NOT EXECUTED 108c50: e8 84 fc ff ff call 1088d9 <== NOT EXECUTED 108c55: 85 c0 test %eax,%eax <== NOT EXECUTED 108c57: 75 16 jne 108c6f <== NOT EXECUTED 108c59: eb 16 jmp 108c71 <== NOT EXECUTED wait = 0; } else { siproc (c, tty); 108c5b: 0f b6 45 d7 movzbl -0x29(%ebp),%eax <== NOT EXECUTED 108c5f: 89 da mov %ebx,%edx <== NOT EXECUTED 108c61: e8 73 fc ff ff call 1088d9 <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 108c66: 0f b6 43 47 movzbl 0x47(%ebx),%eax <== NOT EXECUTED 108c6a: 39 43 20 cmp %eax,0x20(%ebx) <== NOT EXECUTED 108c6d: 7c 02 jl 108c71 <== NOT EXECUTED 108c6f: 31 ff xor %edi,%edi <== NOT EXECUTED wait = 0; } timeout = tty->rawInBufSemaphoreTimeout; 108c71: 8b 53 70 mov 0x70(%ebx),%edx <== NOT EXECUTED while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 108c74: 8b 4b 5c mov 0x5c(%ebx),%ecx <== NOT EXECUTED 108c77: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED 108c7a: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 108c7c: 74 0f je 108c8d <== NOT EXECUTED 108c7e: a1 78 17 12 00 mov 0x121778,%eax <== NOT EXECUTED 108c83: 48 dec %eax <== NOT EXECUTED 108c84: 39 43 20 cmp %eax,0x20(%ebx) <== NOT EXECUTED 108c87: 0f 8c 09 ff ff ff jl 108b96 <== NOT EXECUTED } /* * Wait for characters */ if ( wait ) { 108c8d: 85 ff test %edi,%edi <== NOT EXECUTED 108c8f: 74 32 je 108cc3 <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->rawInBuf.Semaphore, 108c91: 51 push %ecx <== NOT EXECUTED 108c92: 52 push %edx <== NOT EXECUTED 108c93: ff 73 6c pushl 0x6c(%ebx) <== NOT EXECUTED 108c96: ff 73 68 pushl 0x68(%ebx) <== NOT EXECUTED 108c99: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED 108c9c: e8 db 12 00 00 call 109f7c <== NOT EXECUTED tty->rawInBufSemaphoreOptions, timeout); if (sc != RTEMS_SUCCESSFUL) 108ca1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108ca4: 85 c0 test %eax,%eax <== NOT EXECUTED 108ca6: 8b 55 cc mov -0x34(%ebp),%edx <== NOT EXECUTED 108ca9: 74 c9 je 108c74 <== NOT EXECUTED 108cab: eb 16 jmp 108cc3 <== 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++]; 108cad: 8b 7b 1c mov 0x1c(%ebx),%edi <== NOT EXECUTED 108cb0: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 108cb3: 8a 04 07 mov (%edi,%eax,1),%al <== NOT EXECUTED 108cb6: 88 02 mov %al,(%edx) <== NOT EXECUTED 108cb8: 42 inc %edx <== NOT EXECUTED 108cb9: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 108cbc: 40 inc %eax <== NOT EXECUTED 108cbd: 89 43 24 mov %eax,0x24(%ebx) <== NOT EXECUTED count--; 108cc0: 49 dec %ecx <== NOT EXECUTED 108cc1: eb 06 jmp 108cc9 <== NOT EXECUTED 108cc3: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 108cc6: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED else sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 108cc9: 85 c9 test %ecx,%ecx <== NOT EXECUTED 108ccb: 74 0b je 108cd8 <== NOT EXECUTED 108ccd: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 108cd0: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED 108cd3: 3b 43 20 cmp 0x20(%ebx),%eax <== NOT EXECUTED 108cd6: 7c d5 jl 108cad <== NOT EXECUTED *buffer++ = tty->cbuf[tty->cindex++]; count--; } args->bytes_moved = args->count - count; 108cd8: 8b 46 10 mov 0x10(%esi),%eax <== NOT EXECUTED 108cdb: 29 c8 sub %ecx,%eax <== NOT EXECUTED 108cdd: 89 46 18 mov %eax,0x18(%esi) <== NOT EXECUTED tty->tty_rcvwakeup = 0; 108ce0: c7 83 e4 00 00 00 00 movl $0x0,0xe4(%ebx) <== NOT EXECUTED 108ce7: 00 00 00 <== NOT EXECUTED rtems_semaphore_release (tty->isem); 108cea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108ced: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 108cf0: e8 73 13 00 00 call 10a068 <== NOT EXECUTED return sc; 108cf5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 108cf8: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 108cfb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108cfe: 5b pop %ebx <== NOT EXECUTED 108cff: 5e pop %esi <== NOT EXECUTED 108d00: 5f pop %edi <== NOT EXECUTED 108d01: c9 leave <== NOT EXECUTED 108d02: c3 ret <== NOT EXECUTED 00107efe : * 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) { 107efe: 55 push %ebp 107eff: 89 e5 mov %esp,%ebp 107f01: 57 push %edi 107f02: 56 push %esi 107f03: 53 push %ebx 107f04: 83 ec 0c sub $0xc,%esp 107f07: 8b 5d 08 mov 0x8(%ebp),%ebx int nToSend; rtems_interrupt_level level; int len; /* check for XOF/XON to send */ if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF)) 107f0a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 107f10: 25 03 04 00 00 and $0x403,%eax 107f15: 3d 01 04 00 00 cmp $0x401,%eax 107f1a: 75 2c jne 107f48 == (FL_MDXOF | FL_IREQXOF)) { /* XOFF should be sent now... */ (*tty->device.write)(tty->minor, 107f1c: 56 push %esi <== NOT EXECUTED 107f1d: 6a 01 push $0x1 <== NOT EXECUTED 107f1f: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED 107f22: 50 push %eax <== NOT EXECUTED 107f23: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 107f26: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTOP]), 1); rtems_interrupt_disable(level); 107f2c: 9c pushf <== NOT EXECUTED 107f2d: fa cli <== NOT EXECUTED 107f2e: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 107f2f: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; 107f35: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 107f3b: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 107f3e: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED rtems_interrupt_enable(level); 107f44: 52 push %edx <== NOT EXECUTED 107f45: 9d popf <== NOT EXECUTED 107f46: eb 38 jmp 107f80 <== NOT EXECUTED nToSend = 1; } else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) 107f48: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 107f4e: 83 e0 03 and $0x3,%eax 107f51: 83 f8 02 cmp $0x2,%eax 107f54: 75 37 jne 107f8d * 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, 107f56: 51 push %ecx <== NOT EXECUTED 107f57: 6a 01 push $0x1 <== NOT EXECUTED 107f59: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED 107f5c: 50 push %eax <== NOT EXECUTED 107f5d: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 107f60: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTART]), 1); rtems_interrupt_disable(level); 107f66: 9c pushf <== NOT EXECUTED 107f67: fa cli <== NOT EXECUTED 107f68: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 107f69: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl &= ~FL_ISNTXOF; 107f6f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 107f75: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 107f78: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED rtems_interrupt_enable(level); 107f7e: 52 push %edx <== NOT EXECUTED 107f7f: 9d popf <== NOT EXECUTED 107f80: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 107f85: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107f88: e9 2f 01 00 00 jmp 1080bc <== NOT EXECUTED nToSend = 1; } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { 107f8d: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 107f93: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 107f99: 39 c2 cmp %eax,%edx 107f9b: 75 1f jne 107fbc /* * buffer was empty */ if (tty->rawOutBufState == rob_wait) { 107f9d: 31 f6 xor %esi,%esi <== NOT EXECUTED 107f9f: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) <== NOT EXECUTED 107fa6: 0f 85 10 01 00 00 jne 1080bc <== NOT EXECUTED /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 107fac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107faf: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED 107fb5: e8 ae 20 00 00 call 10a068 <== NOT EXECUTED 107fba: eb c9 jmp 107f85 <== NOT EXECUTED } return 0; } rtems_interrupt_disable(level); 107fbc: 9c pushf 107fbd: fa cli 107fbe: 58 pop %eax len = tty->t_dqlen; 107fbf: 8b 8b 90 00 00 00 mov 0x90(%ebx),%ecx tty->t_dqlen = 0; 107fc5: c7 83 90 00 00 00 00 movl $0x0,0x90(%ebx) 107fcc: 00 00 00 rtems_interrupt_enable(level); 107fcf: 50 push %eax 107fd0: 9d popf newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size; 107fd1: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 107fd7: 8b b3 88 00 00 00 mov 0x88(%ebx),%esi 107fdd: 8d 04 01 lea (%ecx,%eax,1),%eax 107fe0: 31 d2 xor %edx,%edx 107fe2: f7 f6 div %esi 107fe4: 89 d7 mov %edx,%edi tty->rawOutBuf.Tail = newTail; 107fe6: 89 93 84 00 00 00 mov %edx,0x84(%ebx) if (tty->rawOutBufState == rob_wait) { 107fec: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) 107ff3: 75 11 jne 108006 /* * wake up any pending writer task */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 107ff5: 83 ec 0c sub $0xc,%esp 107ff8: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 107ffe: e8 65 20 00 00 call 10a068 108003: 83 c4 10 add $0x10,%esp } if (newTail == tty->rawOutBuf.Head) { 108006: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 10800c: 39 c7 cmp %eax,%edi 10800e: 75 2a jne 10803a /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; 108010: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx) 108017: 00 00 00 nToSend = 0; /* * check to see if snd wakeup callback was set */ if ( tty->tty_snd.sw_pfn != NULL) { 10801a: 8b 83 d4 00 00 00 mov 0xd4(%ebx),%eax 108020: 31 f6 xor %esi,%esi 108022: 85 c0 test %eax,%eax 108024: 0f 84 8c 00 00 00 je 1080b6 (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg); 10802a: 52 push %edx <== NOT EXECUTED 10802b: 52 push %edx <== NOT EXECUTED 10802c: ff b3 d8 00 00 00 pushl 0xd8(%ebx) <== NOT EXECUTED 108032: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED 108035: 52 push %edx <== NOT EXECUTED 108036: ff d0 call *%eax <== NOT EXECUTED 108038: eb 79 jmp 1080b3 <== NOT EXECUTED } } /* check, whether output should stop due to received XOFF */ else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF)) 10803a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108040: 25 10 02 00 00 and $0x210,%eax 108045: 3d 10 02 00 00 cmp $0x210,%eax 10804a: 75 22 jne 10806e == (FL_MDXON | FL_ORCVXOF)) { /* Buffer not empty, but output stops due to XOFF */ /* set flag, that output has been stopped */ rtems_interrupt_disable(level); 10804c: 9c pushf <== NOT EXECUTED 10804d: fa cli <== NOT EXECUTED 10804e: 5a pop %edx <== NOT EXECUTED tty->flow_ctrl |= FL_OSTOP; 10804f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108055: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 108058: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ 10805e: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED 108065: 00 00 00 <== NOT EXECUTED rtems_interrupt_enable(level); 108068: 52 push %edx <== NOT EXECUTED 108069: 9d popf <== NOT EXECUTED 10806a: 31 f6 xor %esi,%esi <== NOT EXECUTED 10806c: eb 48 jmp 1080b6 <== NOT EXECUTED } else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) 10806e: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 108074: 39 c7 cmp %eax,%edi 108076: 76 08 jbe 108080 nToSend = tty->rawOutBuf.Size - newTail; 108078: 8b b3 88 00 00 00 mov 0x88(%ebx),%esi 10807e: eb 06 jmp 108086 else nToSend = tty->rawOutBuf.Head - newTail; 108080: 8b b3 80 00 00 00 mov 0x80(%ebx),%esi 108086: 29 fe sub %edi,%esi /* when flow control XON or XOF, don't send blocks of data */ /* to allow fast reaction on incoming flow ctrl and low latency*/ /* for outgoing flow control */ if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) { 108088: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10808e: f6 c4 06 test $0x6,%ah 108091: 74 05 je 108098 108093: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED nToSend = 1; } tty->rawOutBufState = rob_busy; /*apm*/ 108098: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) 10809f: 00 00 00 (*tty->device.write)(tty->minor, 1080a2: 50 push %eax 1080a3: 56 push %esi 1080a4: 8b 43 7c mov 0x7c(%ebx),%eax 1080a7: 01 f8 add %edi,%eax 1080a9: 50 push %eax 1080aa: ff 73 10 pushl 0x10(%ebx) 1080ad: ff 93 a4 00 00 00 call *0xa4(%ebx) 1080b3: 83 c4 10 add $0x10,%esp &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ 1080b6: 89 bb 84 00 00 00 mov %edi,0x84(%ebx) } return nToSend; } 1080bc: 89 f0 mov %esi,%eax 1080be: 8d 65 f4 lea -0xc(%ebp),%esp 1080c1: 5b pop %ebx 1080c2: 5e pop %esi 1080c3: 5f pop %edi 1080c4: c9 leave 1080c5: c3 ret 00109653 : /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) { 109653: 55 push %ebp <== NOT EXECUTED 109654: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109656: 57 push %edi <== NOT EXECUTED 109657: 56 push %esi <== NOT EXECUTED 109658: 53 push %ebx <== NOT EXECUTED 109659: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10965c: 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 | 10965f: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED if (c != EOF) { /* * pollRead did call enqueue on its own */ c_buf = c; rtems_termios_enqueue_raw_characters ( 109662: 8d 75 e7 lea -0x19(%ebp),%esi <== NOT EXECUTED char c_buf; while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_RX_PROC_EVENT | 109665: 57 push %edi <== NOT EXECUTED 109666: 6a 00 push $0x0 <== NOT EXECUTED 109668: 6a 02 push $0x2 <== NOT EXECUTED 10966a: 6a 03 push $0x3 <== NOT EXECUTED 10966c: e8 3f 03 00 00 call 1099b0 <== NOT EXECUTED TERMIOS_RX_TERMINATE_EVENT), RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &the_event); if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) { 109671: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109674: f6 45 e0 01 testb $0x1,-0x20(%ebp) <== NOT EXECUTED 109678: 74 16 je 109690 <== NOT EXECUTED tty->rxTaskId = 0; 10967a: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED 109681: 00 00 00 <== NOT EXECUTED rtems_task_delete(RTEMS_SELF); 109684: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109687: 6a 00 push $0x0 <== NOT EXECUTED 109689: e8 9a 0b 00 00 call 10a228 <== NOT EXECUTED 10968e: eb 21 jmp 1096b1 <== NOT EXECUTED } else { /* * do something */ c = tty->device.pollRead(tty->minor); 109690: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109693: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109696: ff 93 a0 00 00 00 call *0xa0(%ebx) <== NOT EXECUTED if (c != EOF) { 10969c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10969f: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 1096a2: 74 c1 je 109665 <== NOT EXECUTED /* * pollRead did call enqueue on its own */ c_buf = c; 1096a4: 88 45 e7 mov %al,-0x19(%ebp) <== NOT EXECUTED rtems_termios_enqueue_raw_characters ( 1096a7: 50 push %eax <== NOT EXECUTED 1096a8: 6a 01 push $0x1 <== NOT EXECUTED 1096aa: 56 push %esi <== NOT EXECUTED 1096ab: 53 push %ebx <== NOT EXECUTED 1096ac: e8 7a ea ff ff call 10812b <== NOT EXECUTED 1096b1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1096b4: eb af jmp 109665 <== NOT EXECUTED 00107ee3 : * 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) { 107ee3: 55 push %ebp <== NOT EXECUTED 107ee4: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107ee6: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED /* * send event to rx daemon task */ rtems_event_send(tty->rxTaskId,TERMIOS_RX_PROC_EVENT); 107ee9: 6a 02 push $0x2 <== NOT EXECUTED 107eeb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 107eee: ff b0 c4 00 00 00 pushl 0xc4(%eax) <== NOT EXECUTED 107ef4: e8 17 1c 00 00 call 109b10 <== NOT EXECUTED 107ef9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 107efc: c9 leave <== NOT EXECUTED 107efd: c3 ret <== NOT EXECUTED 001095f0 : /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) { 1095f0: 55 push %ebp <== NOT EXECUTED 1095f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1095f3: 56 push %esi <== NOT EXECUTED 1095f4: 53 push %ebx <== NOT EXECUTED 1095f5: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 1095f8: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_TX_START_EVENT | 1095fb: 8d 75 f4 lea -0xc(%ebp),%esi <== NOT EXECUTED 1095fe: 56 push %esi <== NOT EXECUTED 1095ff: 6a 00 push $0x0 <== NOT EXECUTED 109601: 6a 02 push $0x2 <== NOT EXECUTED 109603: 6a 03 push $0x3 <== NOT EXECUTED 109605: e8 a6 03 00 00 call 1099b0 <== NOT EXECUTED TERMIOS_TX_TERMINATE_EVENT), RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &the_event); if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) { 10960a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10960d: f6 45 f4 01 testb $0x1,-0xc(%ebp) <== NOT EXECUTED 109611: 74 16 je 109629 <== NOT EXECUTED tty->txTaskId = 0; 109613: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED 10961a: 00 00 00 <== NOT EXECUTED rtems_task_delete(RTEMS_SELF); 10961d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109620: 6a 00 push $0x0 <== NOT EXECUTED 109622: e8 01 0c 00 00 call 10a228 <== NOT EXECUTED 109627: eb 25 jmp 10964e <== NOT EXECUTED } else { /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 109629: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 10962f: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 109632: 8b 80 60 35 12 00 mov 0x123560(%eax),%eax <== NOT EXECUTED 109638: 85 c0 test %eax,%eax <== NOT EXECUTED 10963a: 74 09 je 109645 <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_start(tty); 10963c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10963f: 53 push %ebx <== NOT EXECUTED 109640: ff d0 call *%eax <== NOT EXECUTED 109642: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * try to push further characters to device */ rtems_termios_refill_transmitter(tty); 109645: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109648: 53 push %ebx <== NOT EXECUTED 109649: e8 b0 e8 ff ff call 107efe <== NOT EXECUTED 10964e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109651: eb ab jmp 1095fe <== NOT EXECUTED 0010892b : rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) { 10892b: 55 push %ebp 10892c: 89 e5 mov %esp,%ebp 10892e: 57 push %edi 10892f: 56 push %esi 108930: 53 push %ebx 108931: 83 ec 20 sub $0x20,%esp 108934: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 108937: 8b 03 mov (%ebx),%eax 108939: 8b 70 34 mov 0x34(%eax),%esi rtems_status_code sc; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 10893c: 6a 00 push $0x0 10893e: 6a 00 push $0x0 108940: ff 76 18 pushl 0x18(%esi) 108943: e8 34 16 00 00 call 109f7c 108948: 89 c7 mov %eax,%edi if (sc != RTEMS_SUCCESSFUL) 10894a: 83 c4 10 add $0x10,%esp 10894d: 85 c0 test %eax,%eax 10894f: 75 77 jne 1089c8 return sc; if (rtems_termios_linesw[tty->t_line].l_write != NULL) { 108951: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax 108957: c1 e0 05 shl $0x5,%eax 10895a: 8b 80 58 35 12 00 mov 0x123558(%eax),%eax 108960: 85 c0 test %eax,%eax 108962: 74 0b je 10896f sc = rtems_termios_linesw[tty->t_line].l_write(tty,args); 108964: 57 push %edi <== NOT EXECUTED 108965: 57 push %edi <== NOT EXECUTED 108966: 53 push %ebx <== NOT EXECUTED 108967: 56 push %esi <== NOT EXECUTED 108968: ff d0 call *%eax <== NOT EXECUTED 10896a: 89 c7 mov %eax,%edi <== NOT EXECUTED rtems_semaphore_release (tty->osem); 10896c: 5b pop %ebx <== NOT EXECUTED 10896d: eb 4e jmp 1089bd <== NOT EXECUTED return sc; } if (tty->termios.c_oflag & OPOST) { 10896f: f6 46 34 01 testb $0x1,0x34(%esi) 108973: 74 2f je 1089a4 uint32_t count = args->count; 108975: 8b 4b 10 mov 0x10(%ebx),%ecx char *buffer = args->buffer; 108978: 8b 43 0c mov 0xc(%ebx),%eax 10897b: 89 45 e4 mov %eax,-0x1c(%ebp) while (count--) 10897e: eb 18 jmp 108998 oproc (*buffer++, tty); 108980: 8b 55 e4 mov -0x1c(%ebp),%edx 108983: 0f b6 02 movzbl (%edx),%eax 108986: 42 inc %edx 108987: 89 55 e4 mov %edx,-0x1c(%ebp) 10898a: 89 f2 mov %esi,%edx 10898c: 89 4d e0 mov %ecx,-0x20(%ebp) 10898f: e8 3d fb ff ff call 1084d1 108994: 8b 4d e0 mov -0x20(%ebp),%ecx 108997: 49 dec %ecx return sc; } if (tty->termios.c_oflag & OPOST) { uint32_t count = args->count; char *buffer = args->buffer; while (count--) 108998: 85 c9 test %ecx,%ecx 10899a: 75 e4 jne 108980 oproc (*buffer++, tty); args->bytes_moved = args->count; 10899c: 8b 43 10 mov 0x10(%ebx),%eax 10899f: 89 43 18 mov %eax,0x18(%ebx) 1089a2: eb 16 jmp 1089ba } else { rtems_termios_puts (args->buffer, args->count, tty); 1089a4: 51 push %ecx <== NOT EXECUTED 1089a5: 56 push %esi <== NOT EXECUTED 1089a6: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1089a9: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 1089ac: e8 00 fa ff ff call 1083b1 <== NOT EXECUTED args->bytes_moved = args->count; 1089b1: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 1089b4: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED 1089b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } rtems_semaphore_release (tty->osem); 1089ba: 83 ec 0c sub $0xc,%esp 1089bd: ff 76 18 pushl 0x18(%esi) 1089c0: e8 a3 16 00 00 call 10a068 return sc; 1089c5: 83 c4 10 add $0x10,%esp } 1089c8: 89 f8 mov %edi,%eax 1089ca: 8d 65 f4 lea -0xc(%ebp),%esp 1089cd: 5b pop %ebx 1089ce: 5e pop %esi 1089cf: 5f pop %edi 1089d0: c9 leave 1089d1: c3 ret 0010b335 : static int rtems_verror( rtems_error_code_t error_flag, const char *printf_format, va_list arglist ) { 10b335: 55 push %ebp <== NOT EXECUTED 10b336: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b338: 57 push %edi <== NOT EXECUTED 10b339: 56 push %esi <== NOT EXECUTED 10b33a: 53 push %ebx <== NOT EXECUTED 10b33b: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10b33e: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10b340: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED 10b343: 89 4d dc mov %ecx,-0x24(%ebp) <== NOT EXECUTED int local_errno = 0; int chars_written = 0; rtems_status_code status; if (error_flag & RTEMS_ERROR_PANIC) 10b346: 25 00 00 00 20 and $0x20000000,%eax <== NOT EXECUTED 10b34b: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10b34e: 74 2a je 10b37a <== NOT EXECUTED { if (rtems_panic_in_progress++) 10b350: a1 90 a1 12 00 mov 0x12a190,%eax <== NOT EXECUTED 10b355: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED 10b358: 89 15 90 a1 12 00 mov %edx,0x12a190 <== NOT EXECUTED 10b35e: 85 c0 test %eax,%eax <== NOT EXECUTED 10b360: 74 0b je 10b36d <== NOT EXECUTED rtems_fatal_error_occurred( 99 ); } } #endif _Thread_Dispatch_disable_level += 1; 10b362: a1 f0 a2 12 00 mov 0x12a2f0,%eax <== NOT EXECUTED 10b367: 40 inc %eax <== NOT EXECUTED 10b368: a3 f0 a2 12 00 mov %eax,0x12a2f0 <== NOT EXECUTED _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) 10b36d: 83 3d 90 a1 12 00 02 cmpl $0x2,0x12a190 <== NOT EXECUTED 10b374: 0f 8f 1b 01 00 00 jg 10b495 <== NOT EXECUTED return 0; } (void) fflush(stdout); /* in case stdout/stderr same */ 10b37a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b37d: a1 60 80 12 00 mov 0x128060,%eax <== NOT EXECUTED 10b382: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10b385: e8 aa ab 00 00 call 115f34 <== NOT EXECUTED status = error_flag & ~RTEMS_ERROR_MASK; 10b38a: 89 df mov %ebx,%edi <== NOT EXECUTED 10b38c: 81 e7 ff ff ff 8f and $0x8fffffff,%edi <== NOT EXECUTED if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 10b392: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b395: 31 f6 xor %esi,%esi <== NOT EXECUTED 10b397: f7 c3 00 00 00 40 test $0x40000000,%ebx <== NOT EXECUTED 10b39d: 74 07 je 10b3a6 <== NOT EXECUTED local_errno = errno; 10b39f: e8 14 a8 00 00 call 115bb8 <__errno> <== NOT EXECUTED 10b3a4: 8b 30 mov (%eax),%esi <== 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); 10b3a6: 52 push %edx <== NOT EXECUTED 10b3a7: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED 10b3aa: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 10b3ad: a1 60 80 12 00 mov 0x128060,%eax <== NOT EXECUTED 10b3b2: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b3b5: e8 5e 07 01 00 call 11bb18 <== NOT EXECUTED 10b3ba: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED if (status) 10b3bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b3c0: 85 ff test %edi,%edi <== NOT EXECUTED 10b3c2: 74 25 je 10b3e9 <== NOT EXECUTED chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); 10b3c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b3c7: 57 push %edi <== NOT EXECUTED 10b3c8: e8 53 ff ff ff call 10b320 <== NOT EXECUTED 10b3cd: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10b3d0: 50 push %eax <== NOT EXECUTED 10b3d1: 68 5f 3a 12 00 push $0x123a5f <== NOT EXECUTED 10b3d6: a1 60 80 12 00 mov 0x128060,%eax <== NOT EXECUTED 10b3db: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b3de: e8 99 ae 00 00 call 11627c <== NOT EXECUTED 10b3e3: 01 45 e4 add %eax,-0x1c(%ebp) <== NOT EXECUTED 10b3e6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (local_errno) 10b3e9: 83 fe 00 cmp $0x0,%esi <== NOT EXECUTED 10b3ec: 74 41 je 10b42f <== NOT EXECUTED { if ((local_errno > 0) && *strerror(local_errno)) 10b3ee: 7e 25 jle 10b415 <== NOT EXECUTED 10b3f0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b3f3: 56 push %esi <== NOT EXECUTED 10b3f4: e8 53 b6 00 00 call 116a4c <== NOT EXECUTED 10b3f9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b3fc: 80 38 00 cmpb $0x0,(%eax) <== NOT EXECUTED 10b3ff: 74 14 je 10b415 <== NOT EXECUTED chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); 10b401: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b404: 56 push %esi <== NOT EXECUTED 10b405: e8 42 b6 00 00 call 116a4c <== NOT EXECUTED 10b40a: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10b40d: 50 push %eax <== NOT EXECUTED 10b40e: 68 6d 3a 12 00 push $0x123a6d <== NOT EXECUTED 10b413: eb 07 jmp 10b41c <== NOT EXECUTED else chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno); 10b415: 50 push %eax <== NOT EXECUTED 10b416: 56 push %esi <== NOT EXECUTED 10b417: 68 7a 3a 12 00 push $0x123a7a <== NOT EXECUTED 10b41c: a1 60 80 12 00 mov 0x128060,%eax <== NOT EXECUTED 10b421: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b424: e8 53 ae 00 00 call 11627c <== NOT EXECUTED 10b429: 01 45 e4 add %eax,-0x1c(%ebp) <== NOT EXECUTED 10b42c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } chars_written += fprintf(stderr, "\n"); 10b42f: 57 push %edi <== NOT EXECUTED 10b430: 57 push %edi <== NOT EXECUTED 10b431: 68 48 41 12 00 push $0x124148 <== NOT EXECUTED 10b436: a1 60 80 12 00 mov 0x128060,%eax <== NOT EXECUTED 10b43b: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b43e: e8 39 ae 00 00 call 11627c <== NOT EXECUTED 10b443: 89 c7 mov %eax,%edi <== NOT EXECUTED (void) fflush(stderr); 10b445: 59 pop %ecx <== NOT EXECUTED 10b446: a1 60 80 12 00 mov 0x128060,%eax <== NOT EXECUTED 10b44b: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b44e: e8 e1 aa 00 00 call 115f34 <== NOT EXECUTED if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT)) 10b453: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b456: 81 e3 00 00 00 30 and $0x30000000,%ebx <== NOT EXECUTED 10b45c: 75 08 jne 10b466 <== 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"); 10b45e: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10b461: 8d 04 17 lea (%edi,%edx,1),%eax <== NOT EXECUTED 10b464: eb 31 jmp 10b497 <== NOT EXECUTED (void) fflush(stderr); if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT)) { if (error_flag & RTEMS_ERROR_PANIC) 10b466: 83 7d e0 00 cmpl $0x0,-0x20(%ebp) <== NOT EXECUTED 10b46a: 74 16 je 10b482 <== NOT EXECUTED { rtems_error(0, "fatal error, exiting"); 10b46c: 52 push %edx <== NOT EXECUTED 10b46d: 52 push %edx <== NOT EXECUTED 10b46e: 68 8e 3a 12 00 push $0x123a8e <== NOT EXECUTED 10b473: 6a 00 push $0x0 <== NOT EXECUTED 10b475: e8 3d 00 00 00 call 10b4b7 <== NOT EXECUTED _exit(local_errno); 10b47a: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10b47d: e8 26 09 00 00 call 10bda8 <_exit> <== NOT EXECUTED } else { rtems_error(0, "fatal error, aborting"); 10b482: 50 push %eax <== NOT EXECUTED 10b483: 50 push %eax <== NOT EXECUTED 10b484: 68 a3 3a 12 00 push $0x123aa3 <== NOT EXECUTED 10b489: 6a 00 push $0x0 <== NOT EXECUTED 10b48b: e8 27 00 00 00 call 10b4b7 <== NOT EXECUTED abort(); 10b490: e8 ef a6 00 00 call 115b84 <== NOT EXECUTED 10b495: 31 c0 xor %eax,%eax <== NOT EXECUTED } } return chars_written; } 10b497: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b49a: 5b pop %ebx <== NOT EXECUTED 10b49b: 5e pop %esi <== NOT EXECUTED 10b49c: 5f pop %edi <== NOT EXECUTED 10b49d: c9 leave <== NOT EXECUTED 10b49e: c3 ret <== NOT EXECUTED 00125812 : /* * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) { 125812: 55 push %ebp 125813: 89 e5 mov %esp,%ebp 125815: 57 push %edi 125816: 56 push %esi 125817: 53 push %ebx 125818: 83 ec 3c sub $0x3c,%esp 12581b: 89 c3 mov %eax,%ebx 12581d: 89 55 e0 mov %edx,-0x20(%ebp) 125820: 31 f6 xor %esi,%esi 125822: c7 45 e4 ff ff ff 7f movl $0x7fffffff,-0x1c(%ebp) 125829: 31 ff xor %edi,%edi sign = 1; } if (!isdigit(c)) return 0; d = c - '0'; if ((i > (limit / 10)) 12582b: 89 7d c4 mov %edi,-0x3c(%ebp) unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 12582e: 8b 43 04 mov 0x4(%ebx),%eax 125831: 48 dec %eax 125832: 89 43 04 mov %eax,0x4(%ebx) 125835: 85 c0 test %eax,%eax 125837: 79 15 jns 12584e 125839: 50 push %eax <== NOT EXECUTED 12583a: 50 push %eax <== NOT EXECUTED 12583b: 53 push %ebx <== NOT EXECUTED 12583c: ff 35 c0 e9 15 00 pushl 0x15e9c0 <== NOT EXECUTED 125842: e8 91 7b 01 00 call 13d3d8 <__srget_r> <== NOT EXECUTED 125847: 89 c1 mov %eax,%ecx <== NOT EXECUTED 125849: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12584c: eb 08 jmp 125856 <== NOT EXECUTED 12584e: 8b 03 mov (%ebx),%eax 125850: 0f b6 08 movzbl (%eax),%ecx 125853: 40 inc %eax 125854: 89 03 mov %eax,(%ebx) if (c == ':') 125856: 83 f9 3a cmp $0x3a,%ecx 125859: 74 4a je 1258a5 break; if (sign == 0) { 12585b: 85 f6 test %esi,%esi 12585d: 75 11 jne 125870 if (c == '-') { sign = -1; limit++; continue; 12585f: 66 be 01 00 mov $0x1,%si for (;;) { c = getc(fp); if (c == ':') break; if (sign == 0) { if (c == '-') { 125863: 83 f9 2d cmp $0x2d,%ecx 125866: 75 08 jne 125870 sign = -1; limit++; 125868: ff 45 e4 incl -0x1c(%ebp) <== NOT EXECUTED 12586b: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED continue; 12586e: eb be jmp 12582e <== NOT EXECUTED } sign = 1; } if (!isdigit(c)) 125870: a1 9c e9 15 00 mov 0x15e99c,%eax 125875: f6 44 08 01 04 testb $0x4,0x1(%eax,%ecx,1) 12587a: 74 3f je 1258bb return 0; d = c - '0'; if ((i > (limit / 10)) 12587c: 8b 45 e4 mov -0x1c(%ebp),%eax 12587f: bf 0a 00 00 00 mov $0xa,%edi 125884: 31 d2 xor %edx,%edx 125886: f7 f7 div %edi 125888: 89 55 d4 mov %edx,-0x2c(%ebp) 12588b: 39 45 c4 cmp %eax,-0x3c(%ebp) 12588e: 77 2b ja 1258bb } sign = 1; } if (!isdigit(c)) return 0; d = c - '0'; 125890: 83 e9 30 sub $0x30,%ecx if ((i > (limit / 10)) 125893: 39 45 c4 cmp %eax,-0x3c(%ebp) 125896: 75 04 jne 12589c 125898: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 12589a: 77 1f ja 1258bb <== NOT EXECUTED || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; i = i * 10 + d; 12589c: 6b 7d c4 0a imul $0xa,-0x3c(%ebp),%edi 1258a0: 8d 3c 39 lea (%ecx,%edi,1),%edi 1258a3: eb 86 jmp 12582b 1258a5: 8b 7d c4 mov -0x3c(%ebp),%edi } if (sign == 0) 1258a8: 85 f6 test %esi,%esi 1258aa: 74 0f je 1258bb return 0; *val = i * sign; 1258ac: 0f af f7 imul %edi,%esi 1258af: 8b 45 e0 mov -0x20(%ebp),%eax 1258b2: 89 30 mov %esi,(%eax) 1258b4: b8 01 00 00 00 mov $0x1,%eax return 1; 1258b9: eb 02 jmp 1258bd 1258bb: 31 c0 xor %eax,%eax <== NOT EXECUTED } 1258bd: 8d 65 f4 lea -0xc(%ebp),%esp 1258c0: 5b pop %ebx 1258c1: 5e pop %esi 1258c2: 5f pop %edi 1258c3: c9 leave 1258c4: c3 ret 001258c5 : /* * Extract a string value from the database */ static int scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag) { 1258c5: 55 push %ebp 1258c6: 89 e5 mov %esp,%ebp 1258c8: 57 push %edi 1258c9: 56 push %esi 1258ca: 53 push %ebx 1258cb: 83 ec 1c sub $0x1c,%esp 1258ce: 89 c3 mov %eax,%ebx 1258d0: 89 ce mov %ecx,%esi 1258d2: 8b 7d 08 mov 0x8(%ebp),%edi 1258d5: 8b 4d 0c mov 0xc(%ebp),%ecx int c; *name = *bufp; 1258d8: 8b 06 mov (%esi),%eax 1258da: 89 02 mov %eax,(%edx) for (;;) { c = getc(fp); 1258dc: 8b 43 04 mov 0x4(%ebx),%eax 1258df: 48 dec %eax 1258e0: 89 43 04 mov %eax,0x4(%ebx) 1258e3: 85 c0 test %eax,%eax 1258e5: 79 19 jns 125900 1258e7: 52 push %edx 1258e8: 52 push %edx 1258e9: 53 push %ebx 1258ea: ff 35 c0 e9 15 00 pushl 0x15e9c0 1258f0: 89 4d e4 mov %ecx,-0x1c(%ebp) 1258f3: e8 e0 7a 01 00 call 13d3d8 <__srget_r> 1258f8: 83 c4 10 add $0x10,%esp 1258fb: 8b 4d e4 mov -0x1c(%ebp),%ecx 1258fe: eb 08 jmp 125908 125900: 8b 13 mov (%ebx),%edx 125902: 0f b6 02 movzbl (%edx),%eax 125905: 42 inc %edx 125906: 89 13 mov %edx,(%ebx) if (c == ':') { 125908: 83 f8 3a cmp $0x3a,%eax 12590b: 75 06 jne 125913 if (nlFlag) 12590d: 85 c9 test %ecx,%ecx 12590f: 74 21 je 125932 125911: eb 2f jmp 125942 <== NOT EXECUTED return 0; break; } if (c == '\n') { 125913: 83 f8 0a cmp $0xa,%eax 125916: 75 06 jne 12591e if (!nlFlag) 125918: 85 c9 test %ecx,%ecx 12591a: 75 16 jne 125932 12591c: eb 24 jmp 125942 <== NOT EXECUTED return 0; break; } if (c == EOF) 12591e: 83 f8 ff cmp $0xffffffff,%eax 125921: 74 1f je 125942 return 0; if (*nleft < 2) 125923: 83 3f 01 cmpl $0x1,(%edi) 125926: 76 1a jbe 125942 return 0; **bufp = c; 125928: 8b 16 mov (%esi),%edx 12592a: 88 02 mov %al,(%edx) ++(*bufp); 12592c: ff 06 incl (%esi) --(*nleft); 12592e: ff 0f decl (%edi) } 125930: eb aa jmp 1258dc **bufp = '\0'; 125932: 8b 06 mov (%esi),%eax 125934: c6 00 00 movb $0x0,(%eax) ++(*bufp); 125937: ff 06 incl (%esi) --(*nleft); 125939: ff 0f decl (%edi) 12593b: b8 01 00 00 00 mov $0x1,%eax return 1; 125940: eb 02 jmp 125944 125942: 31 c0 xor %eax,%eax <== NOT EXECUTED } 125944: 8d 65 f4 lea -0xc(%ebp),%esp 125947: 5b pop %ebx 125948: 5e pop %esi 125949: 5f pop %edi 12594a: c9 leave 12594b: c3 ret 0012594c : FILE *fp, struct group *grp, char *buffer, size_t bufsize ) { 12594c: 55 push %ebp 12594d: 89 e5 mov %esp,%ebp 12594f: 57 push %edi 125950: 56 push %esi 125951: 53 push %ebx 125952: 83 ec 34 sub $0x34,%esp 125955: 89 c6 mov %eax,%esi 125957: 89 d3 mov %edx,%ebx 125959: 89 4d d4 mov %ecx,-0x2c(%ebp) int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 12595c: 8d 7d d4 lea -0x2c(%ebp),%edi 12595f: 6a 00 push $0x0 125961: 8d 45 08 lea 0x8(%ebp),%eax 125964: 50 push %eax 125965: 89 f9 mov %edi,%ecx 125967: 89 f0 mov %esi,%eax 125969: e8 57 ff ff ff call 1258c5 12596e: 83 c4 10 add $0x10,%esp 125971: 85 c0 test %eax,%eax 125973: 0f 84 c8 00 00 00 je 125a41 || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) 125979: 50 push %eax 12597a: 50 push %eax 12597b: 8d 53 04 lea 0x4(%ebx),%edx 12597e: 6a 00 push $0x0 125980: 8d 45 08 lea 0x8(%ebp),%eax 125983: 50 push %eax 125984: 89 f9 mov %edi,%ecx 125986: 89 f0 mov %esi,%eax 125988: e8 38 ff ff ff call 1258c5 { int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 12598d: 83 c4 10 add $0x10,%esp 125990: 85 c0 test %eax,%eax 125992: 0f 84 a9 00 00 00 je 125a41 || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &grgid) 125998: 8d 55 e4 lea -0x1c(%ebp),%edx 12599b: 89 f0 mov %esi,%eax 12599d: e8 70 fe ff ff call 125812 { int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 1259a2: 85 c0 test %eax,%eax 1259a4: 0f 84 97 00 00 00 je 125a41 || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &grgid) || !scanString(fp, &grmem, &buffer, &bufsize, 1)) 1259aa: 51 push %ecx 1259ab: 51 push %ecx 1259ac: 8d 55 e0 lea -0x20(%ebp),%edx 1259af: 6a 01 push $0x1 1259b1: 8d 45 08 lea 0x8(%ebp),%eax 1259b4: 50 push %eax 1259b5: 89 f9 mov %edi,%ecx 1259b7: 89 f0 mov %esi,%eax 1259b9: e8 07 ff ff ff call 1258c5 { int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 1259be: 83 c4 10 add $0x10,%esp 1259c1: 85 c0 test %eax,%eax 1259c3: 74 7c je 125a41 || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &grgid) || !scanString(fp, &grmem, &buffer, &bufsize, 1)) return 0; grp->gr_gid = grgid; 1259c5: 8b 45 e4 mov -0x1c(%ebp),%eax 1259c8: 66 89 43 08 mov %ax,0x8(%ebx) /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 1259cc: 8b 7d e0 mov -0x20(%ebp),%edi 1259cf: 89 fa mov %edi,%edx 1259d1: b8 01 00 00 00 mov $0x1,%eax 1259d6: eb 12 jmp 1259ea if(*cp == ',') memcount++; 1259d8: 80 7d d3 2c cmpb $0x2c,-0x2d(%ebp) 1259dc: 0f 94 c1 sete %cl 1259df: 89 ce mov %ecx,%esi 1259e1: 81 e6 ff 00 00 00 and $0xff,%esi 1259e7: 01 f0 add %esi,%eax grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 1259e9: 42 inc %edx 1259ea: 8a 0a mov (%edx),%cl 1259ec: 88 4d d3 mov %cl,-0x2d(%ebp) 1259ef: 84 c9 test %cl,%cl 1259f1: 75 e5 jne 1259d8 } /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) 1259f3: 8d 04 85 13 00 00 00 lea 0x13(,%eax,4),%eax 1259fa: 39 45 08 cmp %eax,0x8(%ebp) 1259fd: 72 42 jb 125a41 return 0; grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15); 1259ff: 8b 45 d4 mov -0x2c(%ebp),%eax 125a02: 83 c0 0f add $0xf,%eax 125a05: 83 e0 f0 and $0xfffffff0,%eax 125a08: 89 43 0c mov %eax,0xc(%ebx) /* * Fill in pointer array */ grp->gr_mem[0] = grmem; 125a0b: 89 38 mov %edi,(%eax) 125a0d: 8b 45 e0 mov -0x20(%ebp),%eax 125a10: 40 inc %eax 125a11: ba 01 00 00 00 mov $0x1,%edx for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 125a16: eb 11 jmp 125a29 if(*cp == ',') { 125a18: 80 f9 2c cmp $0x2c,%cl 125a1b: 75 0b jne 125a28 *cp = '\0'; 125a1d: c6 40 ff 00 movb $0x0,-0x1(%eax) <== NOT EXECUTED grp->gr_mem[memcount++] = cp + 1; 125a21: 8b 4b 0c mov 0xc(%ebx),%ecx <== NOT EXECUTED 125a24: 89 04 91 mov %eax,(%ecx,%edx,4) <== NOT EXECUTED 125a27: 42 inc %edx <== NOT EXECUTED 125a28: 40 inc %eax /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 125a29: 8a 48 ff mov -0x1(%eax),%cl 125a2c: 84 c9 test %cl,%cl 125a2e: 75 e8 jne 125a18 if(*cp == ',') { *cp = '\0'; grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; 125a30: 8b 43 0c mov 0xc(%ebx),%eax 125a33: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) 125a3a: b8 01 00 00 00 mov $0x1,%eax return 1; 125a3f: eb 02 jmp 125a43 125a41: 31 c0 xor %eax,%eax <== NOT EXECUTED } 125a43: 8d 65 f4 lea -0xc(%ebp),%esp 125a46: 5b pop %ebx 125a47: 5e pop %esi 125a48: 5f pop %edi 125a49: c9 leave 125a4a: c3 ret 00125a83 : FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) { 125a83: 55 push %ebp 125a84: 89 e5 mov %esp,%ebp 125a86: 57 push %edi 125a87: 56 push %esi 125a88: 53 push %ebx 125a89: 83 ec 34 sub $0x34,%esp 125a8c: 89 c6 mov %eax,%esi 125a8e: 89 d3 mov %edx,%ebx 125a90: 89 4d d4 mov %ecx,-0x2c(%ebp) int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 125a93: 8d 7d d4 lea -0x2c(%ebp),%edi 125a96: 6a 00 push $0x0 125a98: 8d 45 08 lea 0x8(%ebp),%eax 125a9b: 50 push %eax 125a9c: 89 f9 mov %edi,%ecx 125a9e: 89 f0 mov %esi,%eax 125aa0: e8 20 fe ff ff call 1258c5 125aa5: 83 c4 10 add $0x10,%esp 125aa8: 85 c0 test %eax,%eax 125aaa: 0f 84 c4 00 00 00 je 125b74 || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) 125ab0: 51 push %ecx 125ab1: 51 push %ecx 125ab2: 8d 53 04 lea 0x4(%ebx),%edx 125ab5: 6a 00 push $0x0 125ab7: 8d 45 08 lea 0x8(%ebp),%eax 125aba: 50 push %eax 125abb: 89 f9 mov %edi,%ecx 125abd: 89 f0 mov %esi,%eax 125abf: e8 01 fe ff ff call 1258c5 size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 125ac4: 83 c4 10 add $0x10,%esp 125ac7: 85 c0 test %eax,%eax 125ac9: 0f 84 a5 00 00 00 je 125b74 || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &pwuid) 125acf: 8d 55 e4 lea -0x1c(%ebp),%edx 125ad2: 89 f0 mov %esi,%eax 125ad4: e8 39 fd ff ff call 125812 size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 125ad9: 85 c0 test %eax,%eax 125adb: 0f 84 93 00 00 00 je 125b74 || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &pwuid) || !scanInt(fp, &pwgid) 125ae1: 8d 55 e0 lea -0x20(%ebp),%edx 125ae4: 89 f0 mov %esi,%eax 125ae6: e8 27 fd ff ff call 125812 size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 125aeb: 85 c0 test %eax,%eax 125aed: 0f 84 81 00 00 00 je 125b74 || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &pwuid) || !scanInt(fp, &pwgid) || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) 125af3: 52 push %edx 125af4: 52 push %edx 125af5: 8d 53 0c lea 0xc(%ebx),%edx 125af8: 6a 00 push $0x0 125afa: 8d 45 08 lea 0x8(%ebp),%eax 125afd: 50 push %eax 125afe: 89 f9 mov %edi,%ecx 125b00: 89 f0 mov %esi,%eax 125b02: e8 be fd ff ff call 1258c5 size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 125b07: 83 c4 10 add $0x10,%esp 125b0a: 85 c0 test %eax,%eax 125b0c: 74 66 je 125b74 || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &pwuid) || !scanInt(fp, &pwgid) || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0) 125b0e: 50 push %eax 125b0f: 50 push %eax 125b10: 8d 53 10 lea 0x10(%ebx),%edx 125b13: 6a 00 push $0x0 125b15: 8d 45 08 lea 0x8(%ebp),%eax 125b18: 50 push %eax 125b19: 89 f9 mov %edi,%ecx 125b1b: 89 f0 mov %esi,%eax 125b1d: e8 a3 fd ff ff call 1258c5 size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 125b22: 83 c4 10 add $0x10,%esp 125b25: 85 c0 test %eax,%eax 125b27: 74 4b je 125b74 || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &pwuid) || !scanInt(fp, &pwgid) || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0) 125b29: 51 push %ecx 125b2a: 51 push %ecx 125b2b: 8d 53 14 lea 0x14(%ebx),%edx 125b2e: 6a 00 push $0x0 125b30: 8d 45 08 lea 0x8(%ebp),%eax 125b33: 50 push %eax 125b34: 89 f9 mov %edi,%ecx 125b36: 89 f0 mov %esi,%eax 125b38: e8 88 fd ff ff call 1258c5 size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 125b3d: 83 c4 10 add $0x10,%esp 125b40: 85 c0 test %eax,%eax 125b42: 74 30 je 125b74 || !scanInt(fp, &pwuid) || !scanInt(fp, &pwgid) || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1)) 125b44: 52 push %edx 125b45: 52 push %edx 125b46: 8d 53 18 lea 0x18(%ebx),%edx 125b49: 6a 01 push $0x1 125b4b: 8d 45 08 lea 0x8(%ebp),%eax 125b4e: 50 push %eax 125b4f: 89 f9 mov %edi,%ecx 125b51: 89 f0 mov %esi,%eax 125b53: e8 6d fd ff ff call 1258c5 size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 125b58: 83 c4 10 add $0x10,%esp 125b5b: 85 c0 test %eax,%eax 125b5d: 74 15 je 125b74 || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1)) return 0; pwd->pw_uid = pwuid; 125b5f: 8b 45 e4 mov -0x1c(%ebp),%eax 125b62: 66 89 43 08 mov %ax,0x8(%ebx) pwd->pw_gid = pwgid; 125b66: 8b 45 e0 mov -0x20(%ebp),%eax 125b69: 66 89 43 0a mov %ax,0xa(%ebx) 125b6d: b8 01 00 00 00 mov $0x1,%eax return 1; 125b72: eb 02 jmp 125b76 125b74: 31 c0 xor %eax,%eax <== NOT EXECUTED } 125b76: 8d 65 f4 lea -0xc(%ebp),%esp 125b79: 5b pop %ebx 125b7a: 5e pop %esi 125b7b: 5f pop %edi 125b7c: c9 leave 125b7d: c3 ret 001257c5 : */ int setgid( gid_t gid ) { 1257c5: 55 push %ebp <== NOT EXECUTED 1257c6: 89 e5 mov %esp,%ebp <== NOT EXECUTED _POSIX_types_Gid = gid; 1257c8: a1 dc e1 15 00 mov 0x15e1dc,%eax <== NOT EXECUTED 1257cd: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1257d0: 66 89 50 34 mov %dx,0x34(%eax) <== NOT EXECUTED return 0; } 1257d4: 31 c0 xor %eax,%eax <== NOT EXECUTED 1257d6: c9 leave <== NOT EXECUTED 1257d7: c3 ret <== NOT EXECUTED 00125c87 : return NULL; return &grent; } void setgrent(void) { 125c87: 55 push %ebp <== NOT EXECUTED 125c88: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125c8a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED init_etc_passwd_group(); 125c8d: e8 24 ff ff ff call 125bb6 <== NOT EXECUTED if (group_fp != NULL) 125c92: a1 8c 36 16 00 mov 0x16368c,%eax <== NOT EXECUTED 125c97: 85 c0 test %eax,%eax <== NOT EXECUTED 125c99: 74 0c je 125ca7 <== NOT EXECUTED fclose(group_fp); 125c9b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125c9e: 50 push %eax <== NOT EXECUTED 125c9f: e8 20 2c 01 00 call 1388c4 <== NOT EXECUTED 125ca4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED group_fp = fopen("/etc/group", "r"); 125ca7: 52 push %edx <== NOT EXECUTED 125ca8: 52 push %edx <== NOT EXECUTED 125ca9: 68 2b 1c 15 00 push $0x151c2b <== NOT EXECUTED 125cae: 68 85 f2 14 00 push $0x14f285 <== NOT EXECUTED 125cb3: e8 24 34 01 00 call 1390dc <== NOT EXECUTED 125cb8: a3 8c 36 16 00 mov %eax,0x16368c <== NOT EXECUTED 125cbd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 125cc0: c9 leave <== NOT EXECUTED 125cc1: c3 ret <== NOT EXECUTED 00125e2b : return NULL; return &pwent; } void setpwent(void) { 125e2b: 55 push %ebp <== NOT EXECUTED 125e2c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125e2e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED init_etc_passwd_group(); 125e31: e8 80 fd ff ff call 125bb6 <== NOT EXECUTED if (passwd_fp != NULL) 125e36: a1 a4 35 16 00 mov 0x1635a4,%eax <== NOT EXECUTED 125e3b: 85 c0 test %eax,%eax <== NOT EXECUTED 125e3d: 74 0c je 125e4b <== NOT EXECUTED fclose(passwd_fp); 125e3f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125e42: 50 push %eax <== NOT EXECUTED 125e43: e8 7c 2a 01 00 call 1388c4 <== NOT EXECUTED 125e48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED passwd_fp = fopen("/etc/passwd", "r"); 125e4b: 50 push %eax <== NOT EXECUTED 125e4c: 50 push %eax <== NOT EXECUTED 125e4d: 68 2b 1c 15 00 push $0x151c2b <== NOT EXECUTED 125e52: 68 40 f2 14 00 push $0x14f240 <== NOT EXECUTED 125e57: e8 80 32 01 00 call 1390dc <== NOT EXECUTED 125e5c: a3 a4 35 16 00 mov %eax,0x1635a4 <== NOT EXECUTED 125e61: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 125e64: c9 leave <== NOT EXECUTED 125e65: c3 ret <== NOT EXECUTED 0010b86a : */ int setuid( uid_t uid ) { 10b86a: 55 push %ebp <== NOT EXECUTED 10b86b: 89 e5 mov %esp,%ebp <== NOT EXECUTED _POSIX_types_Uid = uid; 10b86d: a1 dc e1 15 00 mov 0x15e1dc,%eax <== NOT EXECUTED 10b872: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b875: 66 89 50 32 mov %dx,0x32(%eax) <== NOT EXECUTED return 0; } 10b879: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b87b: c9 leave <== NOT EXECUTED 10b87c: c3 ret <== NOT EXECUTED 001088d9 : /* * Process input character, with semaphore. */ static int siproc (unsigned char c, struct rtems_termios_tty *tty) { 1088d9: 55 push %ebp <== NOT EXECUTED 1088da: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1088dc: 56 push %esi <== NOT EXECUTED 1088dd: 53 push %ebx <== NOT EXECUTED 1088de: 89 d3 mov %edx,%ebx <== NOT EXECUTED 1088e0: 89 c6 mov %eax,%esi <== NOT EXECUTED int i; /* * Obtain output semaphore if character will be echoed */ if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) { 1088e2: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx) <== NOT EXECUTED 1088e9: 74 30 je 10891b <== NOT EXECUTED rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 1088eb: 52 push %edx <== NOT EXECUTED 1088ec: 6a 00 push $0x0 <== NOT EXECUTED 1088ee: 6a 00 push $0x0 <== NOT EXECUTED 1088f0: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 1088f3: e8 84 16 00 00 call 109f7c <== NOT EXECUTED i = iproc (c, tty); 1088f8: 89 f2 mov %esi,%edx <== NOT EXECUTED 1088fa: 0f b6 c2 movzbl %dl,%eax <== NOT EXECUTED 1088fd: 89 da mov %ebx,%edx <== NOT EXECUTED 1088ff: e8 bc fe ff ff call 1087c0 <== NOT EXECUTED 108904: 89 c6 mov %eax,%esi <== NOT EXECUTED rtems_semaphore_release (tty->osem); 108906: 58 pop %eax <== NOT EXECUTED 108907: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10890a: e8 59 17 00 00 call 10a068 <== NOT EXECUTED 10890f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { i = iproc (c, tty); } return i; } 108912: 89 f0 mov %esi,%eax <== NOT EXECUTED 108914: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108917: 5b pop %ebx <== NOT EXECUTED 108918: 5e pop %esi <== NOT EXECUTED 108919: c9 leave <== NOT EXECUTED 10891a: 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); 10891b: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10891e: 89 da mov %ebx,%edx <== NOT EXECUTED } return i; } 108920: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108923: 5b pop %ebx <== NOT EXECUTED 108924: 5e pop %esi <== NOT EXECUTED 108925: 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); 108926: e9 95 fe ff ff jmp 1087c0 <== NOT EXECUTED 0010ca88 : int _STAT_NAME( const char *path, struct stat *buf ) { 10ca88: 55 push %ebp 10ca89: 89 e5 mov %esp,%ebp 10ca8b: 57 push %edi 10ca8c: 56 push %esi 10ca8d: 53 push %ebx 10ca8e: 83 ec 2c sub $0x2c,%esp 10ca91: 8b 55 08 mov 0x8(%ebp),%edx 10ca94: 8b 75 0c mov 0xc(%ebp),%esi /* * Check to see if we were passed a valid pointer. */ if ( !buf ) 10ca97: 85 f6 test %esi,%esi 10ca99: 75 0d jne 10caa8 rtems_set_errno_and_return_minus_one( EFAULT ); 10ca9b: e8 d8 bc 02 00 call 138778 <__errno> 10caa0: c7 00 0e 00 00 00 movl $0xe,(%eax) 10caa6: eb 53 jmp 10cafb status = rtems_filesystem_evaluate_path( path, strlen( path ), 10caa8: 31 c0 xor %eax,%eax 10caaa: 83 c9 ff or $0xffffffff,%ecx 10caad: 89 d7 mov %edx,%edi 10caaf: f2 ae repnz scas %es:(%edi),%al 10cab1: f7 d1 not %ecx 10cab3: 49 dec %ecx 10cab4: 83 ec 0c sub $0xc,%esp 10cab7: 6a 01 push $0x1 10cab9: 8d 5d d4 lea -0x2c(%ebp),%ebx 10cabc: 53 push %ebx 10cabd: 6a 00 push $0x0 10cabf: 51 push %ecx 10cac0: 52 push %edx 10cac1: e8 02 ec ff ff call 10b6c8 0, &loc, _STAT_FOLLOW_LINKS ); if ( status != 0 ) 10cac6: 83 c4 20 add $0x20,%esp 10cac9: 83 cf ff or $0xffffffff,%edi 10cacc: 85 c0 test %eax,%eax 10cace: 75 5c jne 10cb2c return -1; if ( !loc.handlers->fstat_h ){ 10cad0: 8b 55 dc mov -0x24(%ebp),%edx 10cad3: 83 7a 18 00 cmpl $0x0,0x18(%edx) 10cad7: 75 27 jne 10cb00 rtems_filesystem_freenode( &loc ); 10cad9: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10cadc: 85 c0 test %eax,%eax <== NOT EXECUTED 10cade: 74 10 je 10caf0 <== NOT EXECUTED 10cae0: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10cae3: 85 c0 test %eax,%eax <== NOT EXECUTED 10cae5: 74 09 je 10caf0 <== NOT EXECUTED 10cae7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10caea: 53 push %ebx <== NOT EXECUTED 10caeb: ff d0 call *%eax <== NOT EXECUTED 10caed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 10caf0: e8 83 bc 02 00 call 138778 <__errno> <== NOT EXECUTED 10caf5: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10cafb: 83 cf ff or $0xffffffff,%edi 10cafe: eb 2c jmp 10cb2c /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( buf, 0, sizeof(struct stat) ); 10cb00: b9 12 00 00 00 mov $0x12,%ecx 10cb05: 89 f7 mov %esi,%edi 10cb07: f3 ab rep stos %eax,%es:(%edi) status = (*loc.handlers->fstat_h)( &loc, buf ); 10cb09: 50 push %eax 10cb0a: 50 push %eax 10cb0b: 56 push %esi 10cb0c: 53 push %ebx 10cb0d: ff 52 18 call *0x18(%edx) 10cb10: 89 c7 mov %eax,%edi rtems_filesystem_freenode( &loc ); 10cb12: 8b 45 e0 mov -0x20(%ebp),%eax 10cb15: 83 c4 10 add $0x10,%esp 10cb18: 85 c0 test %eax,%eax 10cb1a: 74 10 je 10cb2c 10cb1c: 8b 40 1c mov 0x1c(%eax),%eax 10cb1f: 85 c0 test %eax,%eax 10cb21: 74 09 je 10cb2c 10cb23: 83 ec 0c sub $0xc,%esp 10cb26: 53 push %ebx 10cb27: ff d0 call *%eax 10cb29: 83 c4 10 add $0x10,%esp return status; } 10cb2c: 89 f8 mov %edi,%eax 10cb2e: 8d 65 f4 lea -0xc(%ebp),%esp 10cb31: 5b pop %ebx 10cb32: 5e pop %esi 10cb33: 5f pop %edi 10cb34: c9 leave 10cb35: c3 ret 001268c4 : */ extern rtems_chain_control rtems_filesystem_mount_table_control; int statvfs (const char *path, struct statvfs *sb) { 1268c4: 55 push %ebp <== NOT EXECUTED 1268c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1268c7: 57 push %edi <== NOT EXECUTED 1268c8: 56 push %esi <== NOT EXECUTED 1268c9: 53 push %ebx <== NOT EXECUTED 1268ca: 83 ec 38 sub $0x38,%esp <== NOT EXECUTED 1268cd: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1268d0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED * The root node of the mounted filesytem. * The node for the directory that the fileystem is mounted on. * The mount entry that is being refered to. */ if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) ) 1268d3: 31 c0 xor %eax,%eax <== NOT EXECUTED 1268d5: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 1268d8: 89 d7 mov %edx,%edi <== NOT EXECUTED 1268da: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 1268dc: f7 d1 not %ecx <== NOT EXECUTED 1268de: 49 dec %ecx <== NOT EXECUTED 1268df: 6a 01 push $0x1 <== NOT EXECUTED 1268e1: 8d 5d d4 lea -0x2c(%ebp),%ebx <== NOT EXECUTED 1268e4: 53 push %ebx <== NOT EXECUTED 1268e5: 6a 00 push $0x0 <== NOT EXECUTED 1268e7: 51 push %ecx <== NOT EXECUTED 1268e8: 52 push %edx <== NOT EXECUTED 1268e9: e8 da 4d fe ff call 10b6c8 <== NOT EXECUTED 1268ee: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1268f1: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED 1268f4: 85 c0 test %eax,%eax <== NOT EXECUTED 1268f6: 75 4b jne 126943 <== NOT EXECUTED return -1; mt_entry = loc.mt_entry; 1268f8: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED fs_mount_root = &mt_entry->mt_fs_root; 1268fb: 8b 4a 28 mov 0x28(%edx),%ecx <== NOT EXECUTED 1268fe: 83 79 44 00 cmpl $0x0,0x44(%ecx) <== NOT EXECUTED 126902: 75 0d jne 126911 <== NOT EXECUTED if ( !fs_mount_root->ops->statvfs_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 126904: e8 6f 1e 01 00 call 138778 <__errno> <== NOT EXECUTED 126909: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12690f: eb 32 jmp 126943 <== NOT EXECUTED memset (sb, 0, sizeof (struct statvfs)); 126911: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 126916: 89 f7 mov %esi,%edi <== NOT EXECUTED 126918: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb ); 12691a: 50 push %eax <== NOT EXECUTED 12691b: 50 push %eax <== NOT EXECUTED 12691c: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 12691f: 56 push %esi <== NOT EXECUTED 126920: 83 c2 1c add $0x1c,%edx <== NOT EXECUTED 126923: 52 push %edx <== NOT EXECUTED 126924: ff 50 44 call *0x44(%eax) <== NOT EXECUTED 126927: 89 c7 mov %eax,%edi <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 126929: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 12692c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12692f: 85 c0 test %eax,%eax <== NOT EXECUTED 126931: 74 10 je 126943 <== NOT EXECUTED 126933: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 126936: 85 c0 test %eax,%eax <== NOT EXECUTED 126938: 74 09 je 126943 <== NOT EXECUTED 12693a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12693d: 53 push %ebx <== NOT EXECUTED 12693e: ff d0 call *%eax <== NOT EXECUTED 126940: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 126943: 89 f8 mov %edi,%eax <== NOT EXECUTED 126945: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 126948: 5b pop %ebx <== NOT EXECUTED 126949: 5e pop %esi <== NOT EXECUTED 12694a: 5f pop %edi <== NOT EXECUTED 12694b: c9 leave <== NOT EXECUTED 12694c: c3 ret <== NOT EXECUTED 00126950 : int symlink( const char *actualpath, const char *sympath ) { 126950: 55 push %ebp 126951: 89 e5 mov %esp,%ebp 126953: 57 push %edi 126954: 56 push %esi 126955: 83 ec 20 sub $0x20,%esp 126958: 8b 45 0c mov 0xc(%ebp),%eax rtems_filesystem_location_info_t loc; int i; const char *name_start; int result; rtems_filesystem_get_start_loc( sympath, &i, &loc ); 12695b: 8a 10 mov (%eax),%dl 12695d: 80 fa 5c cmp $0x5c,%dl 126960: 74 09 je 12696b 126962: 80 fa 2f cmp $0x2f,%dl 126965: 74 04 je 12696b 126967: 84 d2 test %dl,%dl 126969: 75 17 jne 126982 12696b: 8d 7d e0 lea -0x20(%ebp),%edi 12696e: 8b 35 dc e1 15 00 mov 0x15e1dc,%esi 126974: 83 c6 18 add $0x18,%esi 126977: b9 05 00 00 00 mov $0x5,%ecx 12697c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 12697e: b1 01 mov $0x1,%cl 126980: eb 13 jmp 126995 126982: 8d 7d e0 lea -0x20(%ebp),%edi 126985: 8b 35 dc e1 15 00 mov 0x15e1dc,%esi 12698b: 83 c6 04 add $0x4,%esi 12698e: b9 05 00 00 00 mov $0x5,%ecx 126993: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !loc.ops->evalformake_h ) { 126995: 8b 55 ec mov -0x14(%ebp),%edx 126998: 8b 52 04 mov 0x4(%edx),%edx 12699b: 85 d2 test %edx,%edx 12699d: 74 32 je 1269d1 rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start ); 12699f: 56 push %esi 1269a0: 8d 75 f4 lea -0xc(%ebp),%esi 1269a3: 56 push %esi 1269a4: 8d 7d e0 lea -0x20(%ebp),%edi 1269a7: 57 push %edi 1269a8: 01 c8 add %ecx,%eax 1269aa: 50 push %eax 1269ab: ff d2 call *%edx if ( result != 0 ) 1269ad: 83 c4 10 add $0x10,%esp 1269b0: 83 ce ff or $0xffffffff,%esi 1269b3: 85 c0 test %eax,%eax 1269b5: 75 50 jne 126a07 return -1; if ( !loc.ops->symlink_h ) { 1269b7: 8b 55 ec mov -0x14(%ebp),%edx 1269ba: 8b 42 38 mov 0x38(%edx),%eax 1269bd: 85 c0 test %eax,%eax 1269bf: 75 20 jne 1269e1 rtems_filesystem_freenode( &loc ); 1269c1: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 1269c4: 85 c0 test %eax,%eax <== NOT EXECUTED 1269c6: 74 09 je 1269d1 <== NOT EXECUTED 1269c8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1269cb: 57 push %edi <== NOT EXECUTED 1269cc: ff d0 call *%eax <== NOT EXECUTED 1269ce: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1269d1: e8 a2 1d 01 00 call 138778 <__errno> <== NOT EXECUTED 1269d6: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1269dc: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 1269df: eb 26 jmp 126a07 <== NOT EXECUTED } result = (*loc.ops->symlink_h)( &loc, actualpath, name_start); 1269e1: 52 push %edx 1269e2: ff 75 f4 pushl -0xc(%ebp) 1269e5: ff 75 08 pushl 0x8(%ebp) 1269e8: 57 push %edi 1269e9: ff d0 call *%eax 1269eb: 89 c6 mov %eax,%esi rtems_filesystem_freenode( &loc ); 1269ed: 8b 45 ec mov -0x14(%ebp),%eax 1269f0: 83 c4 10 add $0x10,%esp 1269f3: 85 c0 test %eax,%eax 1269f5: 74 10 je 126a07 1269f7: 8b 40 1c mov 0x1c(%eax),%eax 1269fa: 85 c0 test %eax,%eax 1269fc: 74 09 je 126a07 1269fe: 83 ec 0c sub $0xc,%esp 126a01: 57 push %edi 126a02: ff d0 call *%eax 126a04: 83 c4 10 add $0x10,%esp return result; } 126a07: 89 f0 mov %esi,%eax 126a09: 8d 65 f8 lea -0x8(%ebp),%esp 126a0c: 5e pop %esi 126a0d: 5f pop %edi 126a0e: c9 leave 126a0f: c3 ret 00113770 : int tcsetattr( int fd, int opt, struct termios *tp ) { 113770: 55 push %ebp 113771: 89 e5 mov %esp,%ebp 113773: 56 push %esi 113774: 53 push %ebx 113775: 8b 5d 08 mov 0x8(%ebp),%ebx 113778: 8b 45 0c mov 0xc(%ebp),%eax 11377b: 8b 75 10 mov 0x10(%ebp),%esi switch (opt) { 11377e: 85 c0 test %eax,%eax 113780: 74 22 je 1137a4 113782: 48 dec %eax <== NOT EXECUTED 113783: 74 0d je 113792 <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 113785: e8 62 33 00 00 call 116aec <__errno> <== NOT EXECUTED 11378a: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 113790: eb 2a jmp 1137bc <== NOT EXECUTED case TCSADRAIN: if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0) 113792: 50 push %eax <== NOT EXECUTED 113793: 6a 00 push $0x0 <== NOT EXECUTED 113795: 6a 03 push $0x3 <== NOT EXECUTED 113797: 53 push %ebx <== NOT EXECUTED 113798: e8 8f 28 00 00 call 11602c <== NOT EXECUTED 11379d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1137a0: 85 c0 test %eax,%eax <== NOT EXECUTED 1137a2: 78 18 js 1137bc <== NOT EXECUTED return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 1137a4: 89 75 10 mov %esi,0x10(%ebp) 1137a7: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp) 1137ae: 89 5d 08 mov %ebx,0x8(%ebp) } } 1137b1: 8d 65 f8 lea -0x8(%ebp),%esp 1137b4: 5b pop %ebx 1137b5: 5e pop %esi 1137b6: c9 leave return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 1137b7: e9 70 28 00 00 jmp 11602c } } 1137bc: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1137bf: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1137c2: 5b pop %ebx <== NOT EXECUTED 1137c3: 5e pop %esi <== NOT EXECUTED 1137c4: c9 leave <== NOT EXECUTED 1137c5: c3 ret <== NOT EXECUTED 00110048 : #include int unlink( const char *path ) { 110048: 55 push %ebp 110049: 89 e5 mov %esp,%ebp 11004b: 57 push %edi 11004c: 56 push %esi 11004d: 53 push %ebx 11004e: 83 ec 58 sub $0x58,%esp /* * Get the node to be unlinked. Find the parent path first. */ parentpathlen = rtems_filesystem_dirname ( path ); 110051: ff 75 08 pushl 0x8(%ebp) 110054: e8 92 6f ff ff call 106feb 110059: 89 c2 mov %eax,%edx if ( parentpathlen == 0 ) 11005b: 83 c4 10 add $0x10,%esp 11005e: 85 c0 test %eax,%eax 110060: 75 36 jne 110098 rtems_filesystem_get_start_loc( path, &i, &parentloc ); 110062: 8b 4d 08 mov 0x8(%ebp),%ecx 110065: 8a 01 mov (%ecx),%al 110067: 3c 5c cmp $0x5c,%al 110069: 74 08 je 110073 11006b: 3c 2f cmp $0x2f,%al 11006d: 74 04 je 110073 11006f: 84 c0 test %al,%al <== NOT EXECUTED 110071: 75 0e jne 110081 <== NOT EXECUTED 110073: 8d 7d d4 lea -0x2c(%ebp),%edi 110076: 8b 35 88 17 12 00 mov 0x121788,%esi 11007c: 83 c6 18 add $0x18,%esi 11007f: eb 0c jmp 11008d 110081: 8d 7d d4 lea -0x2c(%ebp),%edi <== NOT EXECUTED 110084: 8b 35 88 17 12 00 mov 0x121788,%esi <== NOT EXECUTED 11008a: 83 c6 04 add $0x4,%esi <== NOT EXECUTED 11008d: b9 05 00 00 00 mov $0x5,%ecx 110092: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 110094: 31 db xor %ebx,%ebx 110096: eb 27 jmp 1100bf else { result = rtems_filesystem_evaluate_path( path, parentpathlen, 110098: 83 ec 0c sub $0xc,%esp 11009b: 6a 00 push $0x0 11009d: 8d 45 d4 lea -0x2c(%ebp),%eax 1100a0: 50 push %eax 1100a1: 6a 02 push $0x2 1100a3: 52 push %edx 1100a4: ff 75 08 pushl 0x8(%ebp) 1100a7: 89 55 b4 mov %edx,-0x4c(%ebp) 1100aa: e8 29 70 ff ff call 1070d8 RTEMS_LIBIO_PERMS_WRITE, &parentloc, false ); if ( result != 0 ) 1100af: 83 c4 20 add $0x20,%esp 1100b2: 85 c0 test %eax,%eax 1100b4: 8b 55 b4 mov -0x4c(%ebp),%edx 1100b7: 0f 85 68 01 00 00 jne 110225 1100bd: b3 01 mov $0x1,%bl /* * Start from the parent to find the node that should be under it. */ loc = parentloc; 1100bf: 8d 7d c0 lea -0x40(%ebp),%edi 1100c2: 8d 75 d4 lea -0x2c(%ebp),%esi 1100c5: b9 05 00 00 00 mov $0x5,%ecx 1100ca: f3 a5 rep movsl %ds:(%esi),%es:(%edi) name = path + parentpathlen; 1100cc: 8b 75 08 mov 0x8(%ebp),%esi 1100cf: 01 d6 add %edx,%esi name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 1100d1: 83 c9 ff or $0xffffffff,%ecx 1100d4: 89 f7 mov %esi,%edi 1100d6: 31 c0 xor %eax,%eax 1100d8: f2 ae repnz scas %es:(%edi),%al 1100da: f7 d1 not %ecx 1100dc: 49 dec %ecx 1100dd: 52 push %edx 1100de: 52 push %edx 1100df: 51 push %ecx 1100e0: 56 push %esi 1100e1: e8 de 6e ff ff call 106fc4 1100e6: 01 c6 add %eax,%esi result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 1100e8: 83 c9 ff or $0xffffffff,%ecx 1100eb: 89 f7 mov %esi,%edi 1100ed: 31 c0 xor %eax,%eax 1100ef: f2 ae repnz scas %es:(%edi),%al 1100f1: f7 d1 not %ecx 1100f3: 49 dec %ecx 1100f4: c7 04 24 00 00 00 00 movl $0x0,(%esp) 1100fb: 8d 7d c0 lea -0x40(%ebp),%edi 1100fe: 57 push %edi 1100ff: 6a 00 push $0x0 110101: 51 push %ecx 110102: 56 push %esi 110103: e8 16 6f ff ff call 10701e 0, &loc, false ); if ( result != 0 ) { 110108: 83 c4 20 add $0x20,%esp 11010b: 85 c0 test %eax,%eax 11010d: 74 2f je 11013e if ( free_parentloc ) 11010f: 84 db test %bl,%bl 110111: 0f 84 0e 01 00 00 je 110225 rtems_filesystem_freenode( &parentloc ); 110117: 8b 45 e0 mov -0x20(%ebp),%eax 11011a: 85 c0 test %eax,%eax 11011c: 0f 84 03 01 00 00 je 110225 110122: 8b 40 1c mov 0x1c(%eax),%eax 110125: 85 c0 test %eax,%eax 110127: 0f 84 f8 00 00 00 je 110225 11012d: 83 ec 0c sub $0xc,%esp 110130: 8d 55 d4 lea -0x2c(%ebp),%edx 110133: 52 push %edx 110134: ff d0 call *%eax 110136: 83 ce ff or $0xffffffff,%esi 110139: e9 e2 00 00 00 jmp 110220 return -1; } if ( !loc.ops->node_type_h ) { 11013e: 8b 55 cc mov -0x34(%ebp),%edx 110141: 8b 42 10 mov 0x10(%edx),%eax 110144: 85 c0 test %eax,%eax 110146: 75 05 jne 11014d rtems_filesystem_freenode( &loc ); 110148: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 11014b: eb 5b jmp 1101a8 <== NOT EXECUTED if ( free_parentloc ) rtems_filesystem_freenode( &parentloc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) { 11014d: 83 ec 0c sub $0xc,%esp 110150: 57 push %edi 110151: ff d0 call *%eax 110153: 83 c4 10 add $0x10,%esp 110156: 48 dec %eax 110157: 8b 45 cc mov -0x34(%ebp),%eax 11015a: 75 42 jne 11019e rtems_filesystem_freenode( &loc ); 11015c: 85 c0 test %eax,%eax 11015e: 74 10 je 110170 110160: 8b 40 1c mov 0x1c(%eax),%eax 110163: 85 c0 test %eax,%eax 110165: 74 09 je 110170 110167: 83 ec 0c sub $0xc,%esp 11016a: 57 push %edi 11016b: ff d0 call *%eax 11016d: 83 c4 10 add $0x10,%esp if ( free_parentloc ) 110170: 84 db test %bl,%bl 110172: 74 1a je 11018e rtems_filesystem_freenode( &parentloc ); 110174: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 110177: 85 c0 test %eax,%eax <== NOT EXECUTED 110179: 74 13 je 11018e <== NOT EXECUTED 11017b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 11017e: 85 c0 test %eax,%eax <== NOT EXECUTED 110180: 74 0c je 11018e <== NOT EXECUTED 110182: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110185: 8d 55 d4 lea -0x2c(%ebp),%edx <== NOT EXECUTED 110188: 52 push %edx <== NOT EXECUTED 110189: ff d0 call *%eax <== NOT EXECUTED 11018b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EISDIR ); 11018e: e8 21 01 00 00 call 1102b4 <__errno> 110193: c7 00 15 00 00 00 movl $0x15,(%eax) 110199: e9 87 00 00 00 jmp 110225 } if ( !loc.ops->unlink_h ) { 11019e: 8b 50 0c mov 0xc(%eax),%edx 1101a1: 85 d2 test %edx,%edx 1101a3: 75 3b jne 1101e0 rtems_filesystem_freenode( &loc ); 1101a5: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1101a8: 85 c0 test %eax,%eax <== NOT EXECUTED 1101aa: 74 09 je 1101b5 <== NOT EXECUTED 1101ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1101af: 57 push %edi <== NOT EXECUTED 1101b0: ff d0 call *%eax <== NOT EXECUTED 1101b2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( free_parentloc ) 1101b5: 84 db test %bl,%bl <== NOT EXECUTED 1101b7: 74 1a je 1101d3 <== NOT EXECUTED rtems_filesystem_freenode( &parentloc ); 1101b9: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 1101bc: 85 c0 test %eax,%eax <== NOT EXECUTED 1101be: 74 13 je 1101d3 <== NOT EXECUTED 1101c0: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1101c3: 85 c0 test %eax,%eax <== NOT EXECUTED 1101c5: 74 0c je 1101d3 <== NOT EXECUTED 1101c7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1101ca: 8d 55 d4 lea -0x2c(%ebp),%edx <== NOT EXECUTED 1101cd: 52 push %edx <== NOT EXECUTED 1101ce: ff d0 call *%eax <== NOT EXECUTED 1101d0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1101d3: e8 dc 00 00 00 call 1102b4 <__errno> <== NOT EXECUTED 1101d8: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1101de: eb 45 jmp 110225 <== NOT EXECUTED } result = (*loc.ops->unlink_h)( &parentloc, &loc ); 1101e0: 50 push %eax 1101e1: 50 push %eax 1101e2: 57 push %edi 1101e3: 8d 45 d4 lea -0x2c(%ebp),%eax 1101e6: 50 push %eax 1101e7: ff d2 call *%edx 1101e9: 89 c6 mov %eax,%esi rtems_filesystem_freenode( &loc ); 1101eb: 8b 45 cc mov -0x34(%ebp),%eax 1101ee: 83 c4 10 add $0x10,%esp 1101f1: 85 c0 test %eax,%eax 1101f3: 74 10 je 110205 1101f5: 8b 40 1c mov 0x1c(%eax),%eax 1101f8: 85 c0 test %eax,%eax 1101fa: 74 09 je 110205 1101fc: 83 ec 0c sub $0xc,%esp 1101ff: 57 push %edi 110200: ff d0 call *%eax 110202: 83 c4 10 add $0x10,%esp if ( free_parentloc ) 110205: 84 db test %bl,%bl 110207: 74 1f je 110228 rtems_filesystem_freenode( &parentloc ); 110209: 8b 45 e0 mov -0x20(%ebp),%eax 11020c: 85 c0 test %eax,%eax 11020e: 74 18 je 110228 110210: 8b 40 1c mov 0x1c(%eax),%eax 110213: 85 c0 test %eax,%eax 110215: 74 11 je 110228 110217: 83 ec 0c sub $0xc,%esp 11021a: 8d 55 d4 lea -0x2c(%ebp),%edx 11021d: 52 push %edx 11021e: ff d0 call *%eax 110220: 83 c4 10 add $0x10,%esp 110223: eb 03 jmp 110228 110225: 83 ce ff or $0xffffffff,%esi return result; } 110228: 89 f0 mov %esi,%eax 11022a: 8d 65 f4 lea -0xc(%ebp),%esp 11022d: 5b pop %ebx 11022e: 5e pop %esi 11022f: 5f pop %edi 110230: c9 leave 110231: c3 ret 0010e6a0 : */ int unmount( const char *path ) { 10e6a0: 55 push %ebp 10e6a1: 89 e5 mov %esp,%ebp 10e6a3: 57 push %edi 10e6a4: 56 push %esi 10e6a5: 53 push %ebx 10e6a6: 83 ec 38 sub $0x38,%esp 10e6a9: 8b 55 08 mov 0x8(%ebp),%edx * The root node of the mounted filesytem. * The node for the directory that the fileystem is mounted on. * The mount entry that is being refered to. */ if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) ) 10e6ac: 31 c0 xor %eax,%eax 10e6ae: 83 c9 ff or $0xffffffff,%ecx 10e6b1: 89 d7 mov %edx,%edi 10e6b3: f2 ae repnz scas %es:(%edi),%al 10e6b5: f7 d1 not %ecx 10e6b7: 49 dec %ecx 10e6b8: 6a 01 push $0x1 10e6ba: 8d 75 d4 lea -0x2c(%ebp),%esi 10e6bd: 56 push %esi 10e6be: 6a 00 push $0x0 10e6c0: 51 push %ecx 10e6c1: 52 push %edx 10e6c2: e8 01 d0 ff ff call 10b6c8 10e6c7: 83 c4 20 add $0x20,%esp 10e6ca: 85 c0 test %eax,%eax 10e6cc: 0f 85 0f 01 00 00 jne 10e7e1 return -1; mt_entry = loc.mt_entry; 10e6d2: 8b 5d e4 mov -0x1c(%ebp),%ebx fs_mount_loc = &mt_entry->mt_point_node; fs_root_loc = &mt_entry->mt_fs_root; 10e6d5: 8b 43 1c mov 0x1c(%ebx),%eax 10e6d8: 3b 45 d4 cmp -0x2c(%ebp),%eax 10e6db: 8b 45 e0 mov -0x20(%ebp),%eax 10e6de: 74 24 je 10e704 /* * Verify this is the root node for the file system to be unmounted. */ if ( !rtems_filesystem_nodes_equal( fs_root_loc, &loc) ){ rtems_filesystem_freenode( &loc ); 10e6e0: 85 c0 test %eax,%eax 10e6e2: 74 10 je 10e6f4 10e6e4: 8b 40 1c mov 0x1c(%eax),%eax 10e6e7: 85 c0 test %eax,%eax 10e6e9: 74 09 je 10e6f4 10e6eb: 83 ec 0c sub $0xc,%esp 10e6ee: 56 push %esi 10e6ef: ff d0 call *%eax 10e6f1: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EACCES ); 10e6f4: e8 7f a0 02 00 call 138778 <__errno> 10e6f9: c7 00 0d 00 00 00 movl $0xd,(%eax) 10e6ff: e9 dd 00 00 00 jmp 10e7e1 /* * Free the loc node and just use the nodes from the mt_entry . */ rtems_filesystem_freenode( &loc ); 10e704: 85 c0 test %eax,%eax 10e706: 74 10 je 10e718 10e708: 8b 40 1c mov 0x1c(%eax),%eax 10e70b: 85 c0 test %eax,%eax 10e70d: 74 09 je 10e718 10e70f: 83 ec 0c sub $0xc,%esp 10e712: 56 push %esi 10e713: ff d0 call *%eax 10e715: 83 c4 10 add $0x10,%esp if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) ) return -1; mt_entry = loc.mt_entry; fs_mount_loc = &mt_entry->mt_point_node; 10e718: 8b 43 14 mov 0x14(%ebx),%eax 10e71b: 83 78 28 00 cmpl $0x0,0x28(%eax) 10e71f: 74 09 je 10e72a fs_root_loc = &mt_entry->mt_fs_root; 10e721: 8b 43 28 mov 0x28(%ebx),%eax 10e724: 83 78 2c 00 cmpl $0x0,0x2c(%eax) 10e728: 75 10 jne 10e73a if ( !fs_mount_loc->ops->unmount_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( !fs_root_loc->ops->fsunmount_me_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 10e72a: e8 49 a0 02 00 call 138778 <__errno> <== NOT EXECUTED 10e72f: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10e735: e9 a7 00 00 00 jmp 10e7e1 <== 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 ) 10e73a: a1 dc e1 15 00 mov 0x15e1dc,%eax 10e73f: 39 58 14 cmp %ebx,0x14(%eax) 10e742: 74 1d je 10e761 /* * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; 10e744: a1 94 3a 16 00 mov 0x163a94,%eax 10e749: eb 0a jmp 10e755 if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) ) return -1; mt_entry = loc.mt_entry; fs_mount_loc = &mt_entry->mt_point_node; fs_root_loc = &mt_entry->mt_fs_root; 10e74b: 8b 50 18 mov 0x18(%eax),%edx 10e74e: 3b 53 2c cmp 0x2c(%ebx),%edx 10e751: 74 0e je 10e761 * 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 ) { 10e753: 8b 00 mov (%eax),%eax 10e755: 3d 98 3a 16 00 cmp $0x163a98,%eax 10e75a: 75 ef jne 10e74b 10e75c: e9 8b 00 00 00 jmp 10e7ec * 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 ); 10e761: e8 12 a0 02 00 call 138778 <__errno> 10e766: c7 00 10 00 00 00 movl $0x10,(%eax) 10e76c: eb 73 jmp 10e7e1 * 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 ) 10e76e: 83 ec 0c sub $0xc,%esp 10e771: 8b 43 14 mov 0x14(%ebx),%eax 10e774: 53 push %ebx 10e775: ff 50 28 call *0x28(%eax) 10e778: 83 c4 10 add $0x10,%esp 10e77b: 85 c0 test %eax,%eax 10e77d: 75 62 jne 10e7e1 * 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){ 10e77f: 83 ec 0c sub $0xc,%esp 10e782: 8b 43 28 mov 0x28(%ebx),%eax 10e785: 53 push %ebx 10e786: ff 50 2c call *0x2c(%eax) 10e789: 83 c4 10 add $0x10,%esp 10e78c: 85 c0 test %eax,%eax 10e78e: 74 1b je 10e7ab if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 ) 10e790: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e793: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10e796: 53 push %ebx <== NOT EXECUTED 10e797: ff 50 20 call *0x20(%eax) <== NOT EXECUTED 10e79a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e79d: 85 c0 test %eax,%eax <== NOT EXECUTED 10e79f: 74 40 je 10e7e1 <== NOT EXECUTED rtems_fatal_error_occurred( 0 ); 10e7a1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e7a4: 6a 00 push $0x0 <== NOT EXECUTED 10e7a6: e8 59 12 00 00 call 10fa04 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10e7ab: 83 ec 0c sub $0xc,%esp 10e7ae: 53 push %ebx 10e7af: e8 d0 14 00 00 call 10fc84 <_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 ); 10e7b4: 8b 43 14 mov 0x14(%ebx),%eax 10e7b7: 83 c4 10 add $0x10,%esp 10e7ba: 85 c0 test %eax,%eax 10e7bc: 74 13 je 10e7d1 10e7be: 8b 40 1c mov 0x1c(%eax),%eax 10e7c1: 85 c0 test %eax,%eax 10e7c3: 74 0c je 10e7d1 10e7c5: 83 ec 0c sub $0xc,%esp 10e7c8: 8d 53 08 lea 0x8(%ebx),%edx 10e7cb: 52 push %edx 10e7cc: ff d0 call *%eax 10e7ce: 83 c4 10 add $0x10,%esp free( mt_entry ); 10e7d1: 83 ec 0c sub $0xc,%esp 10e7d4: 53 push %ebx 10e7d5: e8 96 cf ff ff call 10b770 10e7da: 31 c0 xor %eax,%eax return 0; 10e7dc: 83 c4 10 add $0x10,%esp 10e7df: eb 03 jmp 10e7e4 10e7e1: 83 c8 ff or $0xffffffff,%eax } 10e7e4: 8d 65 f4 lea -0xc(%ebp),%esp 10e7e7: 5b pop %ebx 10e7e8: 5e pop %esi 10e7e9: 5f pop %edi 10e7ea: c9 leave 10e7eb: 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 ) 10e7ec: 83 ec 0c sub $0xc,%esp 10e7ef: 53 push %ebx 10e7f0: e8 b1 d1 ff ff call 10b9a6 10e7f5: 83 c4 10 add $0x10,%esp 10e7f8: 48 dec %eax 10e7f9: 0f 85 6f ff ff ff jne 10e76e 10e7ff: e9 5d ff ff ff jmp 10e761 00126aa8 : int utime( const char *path, const struct utimbuf *times ) { 126aa8: 55 push %ebp 126aa9: 89 e5 mov %esp,%ebp 126aab: 57 push %edi 126aac: 56 push %esi 126aad: 53 push %ebx 126aae: 83 ec 38 sub $0x38,%esp 126ab1: 8b 55 08 mov 0x8(%ebp),%edx 126ab4: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_filesystem_location_info_t temp_loc; int result; if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) ) 126ab7: 31 c0 xor %eax,%eax 126ab9: 83 c9 ff or $0xffffffff,%ecx 126abc: 89 d7 mov %edx,%edi 126abe: f2 ae repnz scas %es:(%edi),%al 126ac0: f7 d1 not %ecx 126ac2: 49 dec %ecx 126ac3: 6a 01 push $0x1 126ac5: 8d 75 d4 lea -0x2c(%ebp),%esi 126ac8: 56 push %esi 126ac9: 6a 00 push $0x0 126acb: 51 push %ecx 126acc: 52 push %edx 126acd: e8 f6 4b fe ff call 10b6c8 126ad2: 83 c4 20 add $0x20,%esp 126ad5: 83 cf ff or $0xffffffff,%edi 126ad8: 85 c0 test %eax,%eax 126ada: 75 4f jne 126b2b return -1; if ( !temp_loc.ops->utime_h ){ 126adc: 8b 55 e0 mov -0x20(%ebp),%edx 126adf: 8b 42 30 mov 0x30(%edx),%eax 126ae2: 85 c0 test %eax,%eax 126ae4: 75 20 jne 126b06 rtems_filesystem_freenode( &temp_loc ); 126ae6: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 126ae9: 85 c0 test %eax,%eax <== NOT EXECUTED 126aeb: 74 09 je 126af6 <== NOT EXECUTED 126aed: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 126af0: 56 push %esi <== NOT EXECUTED 126af1: ff d0 call *%eax <== NOT EXECUTED 126af3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 126af6: e8 7d 1c 01 00 call 138778 <__errno> <== NOT EXECUTED 126afb: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 126b01: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED 126b04: eb 25 jmp 126b2b <== NOT EXECUTED } result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime ); 126b06: 52 push %edx 126b07: ff 73 04 pushl 0x4(%ebx) 126b0a: ff 33 pushl (%ebx) 126b0c: 56 push %esi 126b0d: ff d0 call *%eax 126b0f: 89 c7 mov %eax,%edi rtems_filesystem_freenode( &temp_loc ); 126b11: 8b 45 e0 mov -0x20(%ebp),%eax 126b14: 83 c4 10 add $0x10,%esp 126b17: 85 c0 test %eax,%eax 126b19: 74 10 je 126b2b 126b1b: 8b 40 1c mov 0x1c(%eax),%eax 126b1e: 85 c0 test %eax,%eax 126b20: 74 09 je 126b2b 126b22: 83 ec 0c sub $0xc,%esp 126b25: 56 push %esi 126b26: ff d0 call *%eax 126b28: 83 c4 10 add $0x10,%esp return result; } 126b2b: 89 f8 mov %edi,%eax 126b2d: 8d 65 f4 lea -0xc(%ebp),%esp 126b30: 5b pop %ebx 126b31: 5e pop %esi 126b32: 5f pop %edi 126b33: c9 leave 126b34: c3 ret 0011b994 : ssize_t write( int fd, const void *buffer, size_t count ) { 11b994: 55 push %ebp 11b995: 89 e5 mov %esp,%ebp 11b997: 56 push %esi 11b998: 53 push %ebx 11b999: 8b 5d 08 mov 0x8(%ebp),%ebx 11b99c: 8b 55 0c mov 0xc(%ebp),%edx 11b99f: 8b 4d 10 mov 0x10(%ebp),%ecx ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11b9a2: 3b 1d 84 f9 11 00 cmp 0x11f984,%ebx 11b9a8: 73 14 jae 11b9be iop = rtems_libio_iop( fd ); 11b9aa: c1 e3 06 shl $0x6,%ebx 11b9ad: 03 1d 58 38 12 00 add 0x123858,%ebx rtems_libio_check_is_open( iop ); 11b9b3: 8b 73 14 mov 0x14(%ebx),%esi 11b9b6: f7 c6 00 01 00 00 test $0x100,%esi 11b9bc: 75 0d jne 11b9cb 11b9be: e8 f1 48 ff ff call 1102b4 <__errno> <== NOT EXECUTED 11b9c3: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 11b9c9: eb 31 jmp 11b9fc <== NOT EXECUTED rtems_libio_check_buffer( buffer ); 11b9cb: 85 d2 test %edx,%edx 11b9cd: 74 0b je 11b9da rtems_libio_check_count( count ); 11b9cf: 31 c0 xor %eax,%eax 11b9d1: 85 c9 test %ecx,%ecx 11b9d3: 74 44 je 11ba19 rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 11b9d5: 83 e6 04 and $0x4,%esi 11b9d8: 75 0d jne 11b9e7 11b9da: e8 d5 48 ff ff call 1102b4 <__errno> <== NOT EXECUTED 11b9df: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11b9e5: eb 15 jmp 11b9fc <== NOT EXECUTED /* * Now process the write() request. */ if ( !iop->handlers->write_h ) 11b9e7: 8b 43 3c mov 0x3c(%ebx),%eax 11b9ea: 8b 40 0c mov 0xc(%eax),%eax 11b9ed: 85 c0 test %eax,%eax 11b9ef: 75 10 jne 11ba01 rtems_set_errno_and_return_minus_one( ENOTSUP ); 11b9f1: e8 be 48 ff ff call 1102b4 <__errno> <== NOT EXECUTED 11b9f6: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11b9fc: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11b9ff: eb 18 jmp 11ba19 <== NOT EXECUTED rc = (*iop->handlers->write_h)( iop, buffer, count ); 11ba01: 56 push %esi 11ba02: 51 push %ecx 11ba03: 52 push %edx 11ba04: 53 push %ebx 11ba05: ff d0 call *%eax if ( rc > 0 ) 11ba07: 83 c4 10 add $0x10,%esp 11ba0a: 85 c0 test %eax,%eax 11ba0c: 7e 0b jle 11ba19 iop->offset += rc; 11ba0e: 89 c1 mov %eax,%ecx 11ba10: c1 f9 1f sar $0x1f,%ecx 11ba13: 01 43 0c add %eax,0xc(%ebx) 11ba16: 11 4b 10 adc %ecx,0x10(%ebx) return rc; } 11ba19: 8d 65 f8 lea -0x8(%ebp),%esp 11ba1c: 5b pop %ebx 11ba1d: 5e pop %esi 11ba1e: c9 leave 11ba1f: c3 ret 0010ab3c : ssize_t writev( int fd, const struct iovec *iov, int iovcnt ) { 10ab3c: 55 push %ebp 10ab3d: 89 e5 mov %esp,%ebp 10ab3f: 57 push %edi 10ab40: 56 push %esi 10ab41: 53 push %ebx 10ab42: 83 ec 1c sub $0x1c,%esp 10ab45: 8b 75 08 mov 0x8(%ebp),%esi 10ab48: 8b 7d 0c mov 0xc(%ebp),%edi int bytes; rtems_libio_t *iop; ssize_t old; bool all_zeros; rtems_libio_check_fd( fd ); 10ab4b: 3b 35 44 31 12 00 cmp 0x123144,%esi 10ab51: 73 11 jae 10ab64 iop = rtems_libio_iop( fd ); 10ab53: c1 e6 06 shl $0x6,%esi 10ab56: 03 35 e8 77 12 00 add 0x1277e8,%esi rtems_libio_check_is_open( iop ); 10ab5c: 8b 46 14 mov 0x14(%esi),%eax 10ab5f: f6 c4 01 test $0x1,%ah 10ab62: 75 10 jne 10ab74 10ab64: e8 9b 75 00 00 call 112104 <__errno> 10ab69: c7 00 09 00 00 00 movl $0x9,(%eax) 10ab6f: e9 a4 00 00 00 jmp 10ac18 rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 10ab74: a8 04 test $0x4,%al 10ab76: 74 57 je 10abcf /* * Argument validation on IO vector */ if ( !iov ) 10ab78: 85 ff test %edi,%edi 10ab7a: 74 53 je 10abcf rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt <= 0 ) 10ab7c: 83 7d 10 00 cmpl $0x0,0x10(%ebp) 10ab80: 7e 4d jle 10abcf rtems_set_errno_and_return_minus_one( EINVAL ); if ( iovcnt > IOV_MAX ) 10ab82: 81 7d 10 00 04 00 00 cmpl $0x400,0x10(%ebp) 10ab89: 7f 44 jg 10abcf rtems_set_errno_and_return_minus_one( EINVAL ); if ( !iop->handlers->write_h ) 10ab8b: 8b 46 3c mov 0x3c(%esi),%eax 10ab8e: 83 78 0c 00 cmpl $0x0,0xc(%eax) 10ab92: 75 0d jne 10aba1 rtems_set_errno_and_return_minus_one( ENOTSUP ); 10ab94: e8 6b 75 00 00 call 112104 <__errno> <== NOT EXECUTED 10ab99: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10ab9f: eb 77 jmp 10ac18 <== NOT EXECUTED 10aba1: b2 01 mov $0x1,%dl 10aba3: 31 c0 xor %eax,%eax 10aba5: 31 c9 xor %ecx,%ecx 10aba7: 89 75 e4 mov %esi,-0x1c(%ebp) * entering the write loop. */ all_zeros = true; for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) { if ( !iov[v].iov_base ) 10abaa: 83 3c c7 00 cmpl $0x0,(%edi,%eax,8) 10abae: 74 1f je 10abcf rtems_set_errno_and_return_minus_one( EINVAL ); if ( iov[v].iov_len < 0 ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( iov[v].iov_len ) 10abb0: 83 7c c7 04 00 cmpl $0x0,0x4(%edi,%eax,8) 10abb5: 0f 94 c3 sete %bl 10abb8: f7 db neg %ebx 10abba: 21 da and %ebx,%edx all_zeros = false; /* check for wrap */ old = total; total += iov[v].iov_len; 10abbc: 8b 74 c7 04 mov 0x4(%edi,%eax,8),%esi 10abc0: 8d 1c 31 lea (%ecx,%esi,1),%ebx if ( total < old || total > SSIZE_MAX ) 10abc3: 81 fb ff 7f 00 00 cmp $0x7fff,%ebx 10abc9: 7f 04 jg 10abcf 10abcb: 39 cb cmp %ecx,%ebx 10abcd: 7d 0d jge 10abdc rtems_set_errno_and_return_minus_one( EINVAL ); 10abcf: e8 30 75 00 00 call 112104 <__errno> 10abd4: c7 00 16 00 00 00 movl $0x16,(%eax) 10abda: eb 3c jmp 10ac18 * this loop does that check as well and sets "all-zero" appropriately. * The variable "all_zero" is used as an early exit point before * entering the write loop. */ all_zeros = true; for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) { 10abdc: 40 inc %eax 10abdd: 3b 45 10 cmp 0x10(%ebp),%eax 10abe0: 7d 04 jge 10abe6 10abe2: 89 d9 mov %ebx,%ecx 10abe4: eb c4 jmp 10abaa 10abe6: 8b 75 e4 mov -0x1c(%ebp),%esi <== NOT EXECUTED } /* * A writev with all zeros is supposed to have no effect per OpenGroup. */ if ( all_zeros == true ) { 10abe9: 31 db xor %ebx,%ebx <== NOT EXECUTED 10abeb: 84 d2 test %dl,%dl <== NOT EXECUTED 10abed: 75 51 jne 10ac40 <== NOT EXECUTED 10abef: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) <== NOT EXECUTED /* * Now process the writev(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { /* all zero lengths has no effect */ if ( iov[v].iov_len == 0 ) 10abf6: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10abf9: 8b 44 d7 04 mov 0x4(%edi,%edx,8),%eax <== NOT EXECUTED 10abfd: 85 c0 test %eax,%eax <== NOT EXECUTED 10abff: 74 34 je 10ac35 <== NOT EXECUTED continue; bytes = (*iop->handlers->write_h)( iop, iov[v].iov_base, iov[v].iov_len ); 10ac01: 52 push %edx <== NOT EXECUTED 10ac02: 8b 56 3c mov 0x3c(%esi),%edx <== NOT EXECUTED 10ac05: 50 push %eax <== NOT EXECUTED 10ac06: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10ac09: ff 34 c7 pushl (%edi,%eax,8) <== NOT EXECUTED 10ac0c: 56 push %esi <== NOT EXECUTED 10ac0d: ff 52 0c call *0xc(%edx) <== NOT EXECUTED if ( bytes < 0 ) 10ac10: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac13: 83 f8 00 cmp $0x0,%eax <== NOT EXECUTED 10ac16: 7d 05 jge 10ac1d <== NOT EXECUTED 10ac18: 83 cb ff or $0xffffffff,%ebx 10ac1b: eb 23 jmp 10ac40 return -1; if ( bytes > 0 ) { 10ac1d: 74 0d je 10ac2c <== NOT EXECUTED iop->offset += bytes; 10ac1f: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10ac21: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 10ac24: 01 46 0c add %eax,0xc(%esi) <== NOT EXECUTED 10ac27: 11 4e 10 adc %ecx,0x10(%esi) <== NOT EXECUTED total += bytes; 10ac2a: 01 c3 add %eax,%ebx <== NOT EXECUTED } if (bytes != iov[ v ].iov_len) 10ac2c: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10ac2f: 3b 44 d7 04 cmp 0x4(%edi,%edx,8),%eax <== NOT EXECUTED 10ac33: 75 0b jne 10ac40 <== NOT EXECUTED } /* * Now process the writev(). */ for ( total=0, v=0 ; v < iovcnt ; v++ ) { 10ac35: ff 45 e4 incl -0x1c(%ebp) <== NOT EXECUTED 10ac38: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10ac3b: 39 45 e4 cmp %eax,-0x1c(%ebp) <== NOT EXECUTED 10ac3e: 7c b6 jl 10abf6 <== NOT EXECUTED if (bytes != iov[ v ].iov_len) break; } return total; } 10ac40: 89 d8 mov %ebx,%eax 10ac42: 8d 65 f4 lea -0xc(%ebp),%esp 10ac45: 5b pop %ebx 10ac46: 5e pop %esi 10ac47: 5f pop %edi 10ac48: c9 leave 10ac49: c3 ret