00111200 : int IMFS_chown( rtems_filesystem_location_info_t *pathloc, /* IN */ uid_t owner, /* IN */ gid_t group /* IN */ ) { 111200: 55 push %ebp 111201: 89 e5 mov %esp,%ebp 111203: 57 push %edi 111204: 56 push %esi 111205: 53 push %ebx 111206: 83 ec 1c sub $0x1c,%esp 111209: 8b 7d 0c mov 0xc(%ebp),%edi 11120c: 8b 75 10 mov 0x10(%ebp),%esi IMFS_jnode_t *jnode; #if defined(RTEMS_POSIX_API) uid_t st_uid; #endif jnode = (IMFS_jnode_t *) pathloc->node_access; 11120f: 8b 45 08 mov 0x8(%ebp),%eax 111212: 8b 18 mov (%eax),%ebx /* * Verify I am the owner of the node or the super user. */ #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 111214: e8 07 0e 00 00 call 112020 if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) 111219: 66 85 c0 test %ax,%ax 11121c: 74 16 je 111234 11121e: 66 3b 43 3c cmp 0x3c(%ebx),%ax <== NOT EXECUTED 111222: 74 10 je 111234 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EPERM ); 111224: e8 27 4a 00 00 call 115c50 <__errno> <== NOT EXECUTED 111229: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 11122f: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 111232: eb 20 jmp 111254 <== NOT EXECUTED #endif jnode->st_uid = owner; 111234: 66 89 7b 3c mov %di,0x3c(%ebx) jnode->st_gid = group; 111238: 66 89 73 3e mov %si,0x3e(%ebx) IMFS_update_ctime( jnode ); 11123c: 50 push %eax 11123d: 50 push %eax 11123e: 6a 00 push $0x0 111240: 8d 45 e0 lea -0x20(%ebp),%eax 111243: 50 push %eax 111244: e8 1b 71 ff ff call 108364 111249: 8b 45 e0 mov -0x20(%ebp),%eax 11124c: 89 43 48 mov %eax,0x48(%ebx) 11124f: 31 c0 xor %eax,%eax return 0; 111251: 83 c4 10 add $0x10,%esp } 111254: 8d 65 f4 lea -0xc(%ebp),%esp 111257: 5b pop %ebx 111258: 5e pop %esi 111259: 5f pop %edi 11125a: c9 leave 11125b: c3 ret 001100e6 : IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) { 1100e6: 55 push %ebp 1100e7: 89 e5 mov %esp,%ebp 1100e9: 57 push %edi 1100ea: 56 push %esi 1100eb: 53 push %ebx 1100ec: 83 ec 1c sub $0x1c,%esp 1100ef: 8b 75 08 mov 0x8(%ebp),%esi 1100f2: 8b 7d 0c mov 0xc(%ebp),%edi 1100f5: 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 ) 1100f8: 31 c0 xor %eax,%eax 1100fa: 85 f6 test %esi,%esi 1100fc: 0f 84 da 00 00 00 je 1101dc return NULL; /* * Allocate filesystem node and fill in basic information */ node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask ); 110102: 50 push %eax 110103: a1 48 1f 12 00 mov 0x121f48,%eax 110108: 8b 40 2c mov 0x2c(%eax),%eax 11010b: f7 d0 not %eax 11010d: 23 45 14 and 0x14(%ebp),%eax 110110: 50 push %eax 110111: ff 75 10 pushl 0x10(%ebp) 110114: 57 push %edi 110115: e8 2a ff ff ff call 110044 if ( !node ) 11011a: 83 c4 10 add $0x10,%esp 11011d: 85 c0 test %eax,%eax 11011f: 0f 84 b7 00 00 00 je 1101dc return NULL; /* * Set the type specific information */ switch (type) { 110125: 4f dec %edi 110126: 83 ff 06 cmp $0x6,%edi 110129: 77 73 ja 11019e 11012b: ff 24 bd 04 f0 11 00 jmp *0x11f004(,%edi,4) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 110132: 8d 50 54 lea 0x54(%eax),%edx 110135: 89 50 50 mov %edx,0x50(%eax) the_chain->permanent_null = NULL; 110138: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) the_chain->last = _Chain_Head(the_chain); 11013f: 8d 50 50 lea 0x50(%eax),%edx 110142: 89 50 58 mov %edx,0x58(%eax) 110145: eb 6d jmp 1101b4 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; 110147: 8b 13 mov (%ebx),%edx 110149: 89 50 50 mov %edx,0x50(%eax) break; 11014c: eb 66 jmp 1101b4 case IMFS_DEVICE: node->info.device.major = info->device.major; 11014e: 8b 13 mov (%ebx),%edx 110150: 89 50 50 mov %edx,0x50(%eax) node->info.device.minor = info->device.minor; 110153: 8b 53 04 mov 0x4(%ebx),%edx 110156: 89 50 54 mov %edx,0x54(%eax) break; 110159: eb 59 jmp 1101b4 case IMFS_LINEAR_FILE: node->info.linearfile.size = 0; 11015b: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) <== NOT EXECUTED 110162: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) <== NOT EXECUTED node->info.linearfile.direct = 0; 110169: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) <== NOT EXECUTED case IMFS_MEMORY_FILE: node->info.file.size = 0; 110170: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) 110177: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) node->info.file.indirect = 0; 11017e: c7 40 58 00 00 00 00 movl $0x0,0x58(%eax) node->info.file.doubly_indirect = 0; 110185: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) node->info.file.triply_indirect = 0; 11018c: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) break; 110193: eb 1f jmp 1101b4 case IMFS_FIFO: node->info.fifo.pipe = NULL; 110195: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) break; 11019c: eb 16 jmp 1101b4 default: assert(0); 11019e: 68 0c e0 11 00 push $0x11e00c <== NOT EXECUTED 1101a3: 68 20 f0 11 00 push $0x11f020 <== NOT EXECUTED 1101a8: 6a 5c push $0x5c <== NOT EXECUTED 1101aa: 68 b8 ef 11 00 push $0x11efb8 <== NOT EXECUTED 1101af: e8 dc 6c 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; 1101b4: 8b 16 mov (%esi),%edx fs_info = parent_loc->mt_entry->fs_info; 1101b6: 8b 4e 10 mov 0x10(%esi),%ecx 1101b9: 8b 59 34 mov 0x34(%ecx),%ebx node->Parent = parent; 1101bc: 89 50 08 mov %edx,0x8(%eax) node->st_ino = ++fs_info->ino_count; 1101bf: 8b 0b mov (%ebx),%ecx 1101c1: 41 inc %ecx 1101c2: 89 0b mov %ecx,(%ebx) 1101c4: 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 ); 1101c7: 53 push %ebx 1101c8: 53 push %ebx 1101c9: 50 push %eax 1101ca: 83 c2 50 add $0x50,%edx 1101cd: 52 push %edx 1101ce: 89 45 e4 mov %eax,-0x1c(%ebp) 1101d1: e8 0a a6 ff ff call 10a7e0 <_Chain_Append> rtems_chain_append( &parent->info.directory.Entries, &node->Node ); return node; 1101d6: 83 c4 10 add $0x10,%esp 1101d9: 8b 45 e4 mov -0x1c(%ebp),%eax } 1101dc: 8d 65 f4 lea -0xc(%ebp),%esp 1101df: 5b pop %ebx 1101e0: 5e pop %esi 1101e1: 5f pop %edi 1101e2: c9 leave 1101e3: 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 9e 3c 12 00 push $0x123c9e <== NOT EXECUTED 108593: 68 88 3d 12 00 push $0x123d88 <== 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 ac 3c 12 00 push $0x123cac <== NOT EXECUTED 1085a8: 68 88 3d 12 00 push $0x123d88 <== NOT EXECUTED 1085ad: 68 86 00 00 00 push $0x86 <== NOT EXECUTED 1085b2: 68 f2 3b 12 00 push $0x123bf2 <== 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 b7 3c 12 00 push $0x123cb7 <== NOT EXECUTED 1085c7: 68 88 3d 12 00 push $0x123d88 <== 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 40 80 12 00 mov 0x128040,%eax 1085ed: ff 70 08 pushl 0x8(%eax) 1085f0: 68 dd 3c 12 00 push $0x123cdd 1085f5: e8 d6 cd 00 00 call 1153d0 !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 0010d20a : const char *pathname, /* IN */ int pathnamelen, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10d20a: 55 push %ebp 10d20b: 89 e5 mov %esp,%ebp 10d20d: 57 push %edi 10d20e: 56 push %esi 10d20f: 53 push %ebx 10d210: 83 ec 5c sub $0x5c,%esp 10d213: 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; 10d216: 8b 3b mov (%ebx),%edi 10d218: be 01 00 00 00 mov $0x1,%esi 10d21d: 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) ) { 10d224: e9 20 01 00 00 jmp 10d349 type = IMFS_get_token( &pathname[i], pathnamelen, token, &len ); 10d229: 8d 45 e4 lea -0x1c(%ebp),%eax 10d22c: 50 push %eax 10d22d: 8d 4d af lea -0x51(%ebp),%ecx 10d230: 51 push %ecx 10d231: ff 75 0c pushl 0xc(%ebp) 10d234: 8b 45 08 mov 0x8(%ebp),%eax 10d237: 03 45 a4 add -0x5c(%ebp),%eax 10d23a: 50 push %eax 10d23b: e8 a8 06 00 00 call 10d8e8 10d240: 89 c6 mov %eax,%esi pathnamelen -= len; 10d242: 8b 55 e4 mov -0x1c(%ebp),%edx i += len; if ( !pathloc->node_access ) 10d245: 83 c4 10 add $0x10,%esp 10d248: 83 3b 00 cmpl $0x0,(%ebx) 10d24b: 0f 84 d4 00 00 00 je 10d325 rtems_set_errno_and_return_minus_one( ENOENT ); /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10d251: 85 c0 test %eax,%eax 10d253: 74 21 je 10d276 if ( node->type == IMFS_DIRECTORY ) 10d255: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10d259: 75 1b jne 10d276 if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10d25b: 50 push %eax 10d25c: 50 push %eax 10d25d: 6a 01 push $0x1 10d25f: 53 push %ebx 10d260: 89 55 a0 mov %edx,-0x60(%ebp) 10d263: e8 50 fe ff ff call 10d0b8 10d268: 83 c4 10 add $0x10,%esp 10d26b: 85 c0 test %eax,%eax 10d26d: 8b 55 a0 mov -0x60(%ebp),%edx 10d270: 0f 84 44 01 00 00 je 10d3ba */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], pathnamelen, token, &len ); pathnamelen -= len; 10d276: 29 55 0c sub %edx,0xc(%ebp) i += len; 10d279: 01 55 a4 add %edx,-0x5c(%ebp) if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); node = pathloc->node_access; 10d27c: 8b 3b mov (%ebx),%edi switch( type ) { 10d27e: 83 fe 03 cmp $0x3,%esi 10d281: 74 34 je 10d2b7 10d283: 83 fe 04 cmp $0x4,%esi 10d286: 0f 84 b0 00 00 00 je 10d33c 10d28c: 83 fe 02 cmp $0x2,%esi 10d28f: 0f 85 b4 00 00 00 jne 10d349 case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10d295: a1 48 1f 12 00 mov 0x121f48,%eax 10d29a: 3b 78 18 cmp 0x18(%eax),%edi 10d29d: 74 8a je 10d229 /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access) { 10d29f: 8b 73 10 mov 0x10(%ebx),%esi /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == 10d2a2: 3b 7e 1c cmp 0x1c(%esi),%edi 10d2a5: 75 0b jne 10d2b2 */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; /* Throw out the .. in this case */ } else { newloc = pathloc->mt_entry->mt_point_node; 10d2a7: 8d 7d d0 lea -0x30(%ebp),%edi 10d2aa: 83 c6 08 add $0x8,%esi 10d2ad: e9 b7 00 00 00 jmp 10d369 pathnamelen+len, flags,pathloc); } } else { if ( !node->Parent ) 10d2b2: 8b 7f 08 mov 0x8(%edi),%edi 10d2b5: eb 6a jmp 10d321 case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { 10d2b7: 8b 47 4c mov 0x4c(%edi),%eax 10d2ba: 83 f8 03 cmp $0x3,%eax 10d2bd: 75 15 jne 10d2d4 IMFS_evaluate_hard_link( pathloc, 0 ); 10d2bf: 57 push %edi 10d2c0: 57 push %edi 10d2c1: 6a 00 push $0x0 10d2c3: 53 push %ebx 10d2c4: e8 3d fe ff ff call 10d106 node = pathloc->node_access; 10d2c9: 8b 3b mov (%ebx),%edi if ( !node ) 10d2cb: 83 c4 10 add $0x10,%esp 10d2ce: 85 ff test %edi,%edi 10d2d0: 75 21 jne 10d2f3 10d2d2: eb 25 jmp 10d2f9 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); } else if ( node->type == IMFS_SYM_LINK ) { 10d2d4: 83 f8 04 cmp $0x4,%eax 10d2d7: 75 1a jne 10d2f3 result = IMFS_evaluate_sym_link( pathloc, 0 ); 10d2d9: 56 push %esi 10d2da: 56 push %esi 10d2db: 6a 00 push $0x0 10d2dd: 53 push %ebx 10d2de: e8 79 fe ff ff call 10d15c 10d2e3: 89 c6 mov %eax,%esi node = pathloc->node_access; 10d2e5: 8b 3b mov (%ebx),%edi if ( result == -1 ) 10d2e7: 83 c4 10 add $0x10,%esp 10d2ea: 83 f8 ff cmp $0xffffffff,%eax 10d2ed: 0f 84 d5 00 00 00 je 10d3c8 /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10d2f3: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10d2f7: 74 10 je 10d309 rtems_set_errno_and_return_minus_one( ENOTDIR ); 10d2f9: e8 56 42 00 00 call 111554 <__errno> 10d2fe: c7 00 14 00 00 00 movl $0x14,(%eax) 10d304: e9 bc 00 00 00 jmp 10d3c5 /* * 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 ) { 10d309: 8b 77 5c mov 0x5c(%edi),%esi 10d30c: 85 f6 test %esi,%esi 10d30e: 75 53 jne 10d363 /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10d310: 51 push %ecx 10d311: 51 push %ecx 10d312: 8d 45 af lea -0x51(%ebp),%eax 10d315: 50 push %eax 10d316: 57 push %edi 10d317: e8 40 05 00 00 call 10d85c 10d31c: 89 c7 mov %eax,%edi if ( !node ) 10d31e: 83 c4 10 add $0x10,%esp 10d321: 85 ff test %edi,%edi 10d323: 75 10 jne 10d335 rtems_set_errno_and_return_minus_one( ENOENT ); 10d325: e8 2a 42 00 00 call 111554 <__errno> 10d32a: c7 00 02 00 00 00 movl $0x2,(%eax) 10d330: e9 90 00 00 00 jmp 10d3c5 /* * Set the node access to the point we have found. */ pathloc->node_access = node; 10d335: 89 3b mov %edi,(%ebx) 10d337: e9 ed fe ff ff jmp 10d229 case IMFS_NO_MORE_PATH: case IMFS_CURRENT_DIR: break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10d33c: e8 13 42 00 00 call 111554 <__errno> 10d341: c7 00 5b 00 00 00 movl $0x5b,(%eax) 10d347: eb 7c jmp 10d3c5 /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 10d349: 83 fe 04 cmp $0x4,%esi 10d34c: 74 08 je 10d356 10d34e: 85 f6 test %esi,%esi 10d350: 0f 85 d3 fe ff ff jne 10d229 * 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 ) { 10d356: 83 7f 4c 01 cmpl $0x1,0x4c(%edi) 10d35a: 75 41 jne 10d39d if ( node->info.directory.mt_fs != NULL ) { 10d35c: 8b 77 5c mov 0x5c(%edi),%esi 10d35f: 85 f6 test %esi,%esi 10d361: 74 3a je 10d39d newloc = node->info.directory.mt_fs->mt_fs_root; 10d363: 8d 7d d0 lea -0x30(%ebp),%edi 10d366: 83 c6 1c add $0x1c,%esi 10d369: b9 05 00 00 00 mov $0x5,%ecx 10d36e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10d370: 8d 75 d0 lea -0x30(%ebp),%esi 10d373: b1 05 mov $0x5,%cl 10d375: 89 df mov %ebx,%edi 10d377: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalpath_h)( &pathname[i-len], 10d379: 8b 45 e4 mov -0x1c(%ebp),%eax 10d37c: 8b 53 0c mov 0xc(%ebx),%edx 10d37f: 53 push %ebx 10d380: ff 75 10 pushl 0x10(%ebp) 10d383: 8b 4d 0c mov 0xc(%ebp),%ecx 10d386: 01 c1 add %eax,%ecx 10d388: 51 push %ecx 10d389: 8b 4d a4 mov -0x5c(%ebp),%ecx 10d38c: 29 c1 sub %eax,%ecx 10d38e: 8b 45 08 mov 0x8(%ebp),%eax 10d391: 01 c8 add %ecx,%eax 10d393: 50 push %eax 10d394: ff 12 call *(%edx) 10d396: 89 c6 mov %eax,%esi 10d398: 83 c4 10 add $0x10,%esp 10d39b: eb 2b jmp 10d3c8 flags, pathloc ); } else { result = IMFS_Set_handlers( pathloc ); } } else { result = IMFS_Set_handlers( pathloc ); 10d39d: 83 ec 0c sub $0xc,%esp 10d3a0: 53 push %ebx 10d3a1: e8 ca fc ff ff call 10d070 10d3a6: 89 c6 mov %eax,%esi 10d3a8: 58 pop %eax 10d3a9: 5a pop %edx /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) 10d3aa: ff 75 10 pushl 0x10(%ebp) 10d3ad: 53 push %ebx 10d3ae: e8 05 fd ff ff call 10d0b8 10d3b3: 83 c4 10 add $0x10,%esp 10d3b6: 85 c0 test %eax,%eax 10d3b8: 75 0e jne 10d3c8 rtems_set_errno_and_return_minus_one( EACCES ); 10d3ba: e8 95 41 00 00 call 111554 <__errno> 10d3bf: c7 00 0d 00 00 00 movl $0xd,(%eax) 10d3c5: 83 ce ff or $0xffffffff,%esi return result; } 10d3c8: 89 f0 mov %esi,%eax 10d3ca: 8d 65 f4 lea -0xc(%ebp),%esp 10d3cd: 5b pop %ebx 10d3ce: 5e pop %esi 10d3cf: 5f pop %edi 10d3d0: c9 leave 10d3d1: c3 ret 0010d455 : int IMFS_evaluate_for_make( const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) { 10d455: 55 push %ebp 10d456: 89 e5 mov %esp,%ebp 10d458: 57 push %edi 10d459: 56 push %esi 10d45a: 53 push %ebx 10d45b: 83 ec 5c sub $0x5c,%esp 10d45e: 8b 55 0c mov 0xc(%ebp),%edx /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10d461: 8b 1a mov (%edx),%ebx /* * Get the path length. */ pathlen = strlen( path ); 10d463: 31 c0 xor %eax,%eax 10d465: 83 c9 ff or $0xffffffff,%ecx 10d468: 8b 7d 08 mov 0x8(%ebp),%edi 10d46b: f2 ae repnz scas %es:(%edi),%al 10d46d: f7 d1 not %ecx 10d46f: 49 dec %ecx 10d470: 89 4d a0 mov %ecx,-0x60(%ebp) 10d473: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp) * Evaluate all tokens until we are done or an error occurs. */ while( !done ) { type = IMFS_get_token( &path[i], pathlen, token, &len ); 10d47a: 8d 7d af lea -0x51(%ebp),%edi 10d47d: 89 d6 mov %edx,%esi 10d47f: 8d 45 e4 lea -0x1c(%ebp),%eax 10d482: 50 push %eax 10d483: 57 push %edi 10d484: ff 75 a0 pushl -0x60(%ebp) 10d487: 8b 45 08 mov 0x8(%ebp),%eax 10d48a: 03 45 a4 add -0x5c(%ebp),%eax 10d48d: 50 push %eax 10d48e: e8 55 04 00 00 call 10d8e8 10d493: 89 c2 mov %eax,%edx pathlen -= len; 10d495: 8b 4d e4 mov -0x1c(%ebp),%ecx 10d498: 29 4d a0 sub %ecx,-0x60(%ebp) i += len; if ( !pathloc->node_access ) 10d49b: 83 c4 10 add $0x10,%esp 10d49e: 83 3e 00 cmpl $0x0,(%esi) 10d4a1: 0f 84 6a 01 00 00 je 10d611 /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10d4a7: 85 c0 test %eax,%eax 10d4a9: 74 36 je 10d4e1 if ( node->type == IMFS_DIRECTORY ) 10d4ab: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10d4af: 75 30 jne 10d4e1 if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10d4b1: 50 push %eax 10d4b2: 50 push %eax 10d4b3: 6a 01 push $0x1 10d4b5: 56 push %esi 10d4b6: 89 55 9c mov %edx,-0x64(%ebp) 10d4b9: 89 4d 98 mov %ecx,-0x68(%ebp) 10d4bc: e8 f7 fb ff ff call 10d0b8 10d4c1: 83 c4 10 add $0x10,%esp 10d4c4: 85 c0 test %eax,%eax 10d4c6: 8b 55 9c mov -0x64(%ebp),%edx 10d4c9: 8b 4d 98 mov -0x68(%ebp),%ecx 10d4cc: 75 13 jne 10d4e1 rtems_set_errno_and_return_minus_one( EACCES ); 10d4ce: e8 81 40 00 00 call 111554 <__errno> 10d4d3: c7 00 0d 00 00 00 movl $0xd,(%eax) 10d4d9: 83 cb ff or $0xffffffff,%ebx 10d4dc: e9 8a 01 00 00 jmp 10d66b while( !done ) { type = IMFS_get_token( &path[i], pathlen, token, &len ); pathlen -= len; i += len; 10d4e1: 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; 10d4e4: 8b 1e mov (%esi),%ebx switch( type ) { 10d4e6: 83 fa 02 cmp $0x2,%edx 10d4e9: 74 1f je 10d50a 10d4eb: 77 0a ja 10d4f7 10d4ed: 85 d2 test %edx,%edx 10d4ef: 0f 84 d9 00 00 00 je 10d5ce 10d4f5: eb 88 jmp 10d47f 10d4f7: 83 fa 03 cmp $0x3,%edx 10d4fa: 74 40 je 10d53c 10d4fc: 83 fa 04 cmp $0x4,%edx 10d4ff: 0f 85 7a ff ff ff jne 10d47f 10d505: e9 d4 00 00 00 jmp 10d5de case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10d50a: a1 48 1f 12 00 mov 0x121f48,%eax 10d50f: 3b 58 18 cmp 0x18(%eax),%ebx 10d512: 0f 84 67 ff ff ff je 10d47f /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){ 10d518: 8b 46 10 mov 0x10(%esi),%eax 10d51b: 3b 58 1c cmp 0x1c(%eax),%ebx 10d51e: 75 0c jne 10d52c 10d520: 89 f2 mov %esi,%edx 10d522: 89 c6 mov %eax,%esi if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; } else { newloc = pathloc->mt_entry->mt_point_node; 10d524: 8d 7d d0 lea -0x30(%ebp),%edi 10d527: 83 c6 08 add $0x8,%esi 10d52a: eb 5a jmp 10d586 *pathloc = newloc; return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); } } else { if ( !node->Parent ) 10d52c: 8b 5b 08 mov 0x8(%ebx),%ebx 10d52f: 85 db test %ebx,%ebx 10d531: 0f 85 90 00 00 00 jne 10d5c7 10d537: e9 d5 00 00 00 jmp 10d611 pathloc->node_access = node; break; case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { 10d53c: 8b 43 4c mov 0x4c(%ebx),%eax 10d53f: 83 f8 03 cmp $0x3,%eax 10d542: 74 05 je 10d549 result = IMFS_evaluate_link( pathloc, 0 ); if ( result == -1 ) return -1; } else if ( node->type == IMFS_SYM_LINK ) { 10d544: 83 f8 04 cmp $0x4,%eax 10d547: 75 16 jne 10d55f result = IMFS_evaluate_link( pathloc, 0 ); 10d549: 53 push %ebx 10d54a: 53 push %ebx 10d54b: 6a 00 push $0x0 10d54d: 56 push %esi 10d54e: e8 7f fe ff ff call 10d3d2 if ( result == -1 ) 10d553: 83 c4 10 add $0x10,%esp 10d556: 83 f8 ff cmp $0xffffffff,%eax 10d559: 0f 84 0a 01 00 00 je 10d669 return -1; } node = pathloc->node_access; 10d55f: 8b 06 mov (%esi),%eax if ( !node ) 10d561: 85 c0 test %eax,%eax 10d563: 0f 84 da 00 00 00 je 10d643 /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10d569: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 10d56d: 0f 85 d0 00 00 00 jne 10d643 /* * 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 ) { 10d573: 8b 50 5c mov 0x5c(%eax),%edx 10d576: 85 d2 test %edx,%edx 10d578: 74 3b je 10d5b5 10d57a: 89 f0 mov %esi,%eax 10d57c: 89 d6 mov %edx,%esi 10d57e: 89 c2 mov %eax,%edx newloc = node->info.directory.mt_fs->mt_fs_root; 10d580: 8d 7d d0 lea -0x30(%ebp),%edi 10d583: 83 c6 1c add $0x1c,%esi 10d586: b9 05 00 00 00 mov $0x5,%ecx 10d58b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *pathloc = newloc; 10d58d: 8d 75 d0 lea -0x30(%ebp),%esi 10d590: b1 05 mov $0x5,%cl 10d592: 89 d7 mov %edx,%edi 10d594: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10d596: 51 push %ecx 10d597: 8b 42 0c mov 0xc(%edx),%eax 10d59a: ff 75 10 pushl 0x10(%ebp) 10d59d: 52 push %edx 10d59e: 8b 55 a4 mov -0x5c(%ebp),%edx 10d5a1: 2b 55 e4 sub -0x1c(%ebp),%edx 10d5a4: 03 55 08 add 0x8(%ebp),%edx 10d5a7: 52 push %edx 10d5a8: ff 50 04 call *0x4(%eax) 10d5ab: 89 c3 mov %eax,%ebx 10d5ad: 83 c4 10 add $0x10,%esp 10d5b0: e9 b6 00 00 00 jmp 10d66b /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10d5b5: 52 push %edx 10d5b6: 52 push %edx 10d5b7: 57 push %edi 10d5b8: 50 push %eax 10d5b9: e8 9e 02 00 00 call 10d85c 10d5be: 89 c3 mov %eax,%ebx /* * If there is no node we have found the name of the node we * wish to create. */ if ( ! node ) 10d5c0: 83 c4 10 add $0x10,%esp 10d5c3: 85 c0 test %eax,%eax 10d5c5: 74 27 je 10d5ee done = true; else pathloc->node_access = node; 10d5c7: 89 1e mov %ebx,(%esi) 10d5c9: e9 b1 fe ff ff jmp 10d47f break; case IMFS_NO_MORE_PATH: rtems_set_errno_and_return_minus_one( EEXIST ); 10d5ce: e8 81 3f 00 00 call 111554 <__errno> 10d5d3: c7 00 11 00 00 00 movl $0x11,(%eax) 10d5d9: e9 fb fe ff ff jmp 10d4d9 break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10d5de: e8 71 3f 00 00 call 111554 <__errno> 10d5e3: c7 00 5b 00 00 00 movl $0x5b,(%eax) 10d5e9: e9 eb fe ff ff jmp 10d4d9 10d5ee: 89 f2 mov %esi,%edx case IMFS_CURRENT_DIR: break; } } *name = &path[ i - len ]; 10d5f0: 8b 45 a4 mov -0x5c(%ebp),%eax 10d5f3: 2b 45 e4 sub -0x1c(%ebp),%eax 10d5f6: 03 45 08 add 0x8(%ebp),%eax 10d5f9: 8b 4d 10 mov 0x10(%ebp),%ecx 10d5fc: 89 01 mov %eax,(%ecx) 10d5fe: 8b 45 08 mov 0x8(%ebp),%eax 10d601: 03 45 a4 add -0x5c(%ebp),%eax /* * We have evaluated the path as far as we can. * Verify there is not any invalid stuff at the end of the name. */ for( ; path[i] != '\0'; i++) { 10d604: eb 1b jmp 10d621 10d606: 40 inc %eax if ( !IMFS_is_separator( path[ i ] ) ) 10d607: 80 f9 5c cmp $0x5c,%cl 10d60a: 74 15 je 10d621 10d60c: 80 f9 2f cmp $0x2f,%cl 10d60f: 74 10 je 10d621 rtems_set_errno_and_return_minus_one( ENOENT ); 10d611: e8 3e 3f 00 00 call 111554 <__errno> 10d616: c7 00 02 00 00 00 movl $0x2,(%eax) 10d61c: e9 b8 fe ff ff jmp 10d4d9 /* * We have evaluated the path as far as we can. * Verify there is not any invalid stuff at the end of the name. */ for( ; path[i] != '\0'; i++) { 10d621: 8a 08 mov (%eax),%cl 10d623: 84 c9 test %cl,%cl 10d625: 75 df jne 10d606 /* * Verify we can execute and write to this directory. */ result = IMFS_Set_handlers( pathloc ); 10d627: 83 ec 0c sub $0xc,%esp 10d62a: 52 push %edx 10d62b: 89 55 9c mov %edx,-0x64(%ebp) 10d62e: e8 3d fa ff ff call 10d070 10d633: 89 c3 mov %eax,%ebx /* * The returned node must be a directory */ node = pathloc->node_access; 10d635: 8b 55 9c mov -0x64(%ebp),%edx 10d638: 8b 02 mov (%edx),%eax 10d63a: 83 c4 10 add $0x10,%esp 10d63d: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 10d641: 74 10 je 10d653 if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 10d643: e8 0c 3f 00 00 call 111554 <__errno> 10d648: c7 00 14 00 00 00 movl $0x14,(%eax) 10d64e: e9 86 fe ff ff jmp 10d4d9 /* * We must have Write and execute permission on the returned node. */ if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) 10d653: 56 push %esi 10d654: 56 push %esi 10d655: 6a 03 push $0x3 10d657: 52 push %edx 10d658: e8 5b fa ff ff call 10d0b8 10d65d: 83 c4 10 add $0x10,%esp 10d660: 85 c0 test %eax,%eax 10d662: 75 07 jne 10d66b 10d664: e9 65 fe ff ff jmp 10d4ce 10d669: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10d66b: 89 d8 mov %ebx,%eax 10d66d: 8d 65 f4 lea -0xc(%ebp),%esp 10d670: 5b pop %ebx 10d671: 5e pop %esi 10d672: 5f pop %edi 10d673: c9 leave 10d674: c3 ret 0010d106 : int IMFS_evaluate_hard_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10d106: 55 push %ebp 10d107: 89 e5 mov %esp,%ebp 10d109: 53 push %ebx 10d10a: 83 ec 04 sub $0x4,%esp 10d10d: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *jnode = node->node_access; 10d110: 8b 03 mov (%ebx),%eax /* * Check for things that should never happen. */ if ( jnode->type != IMFS_HARD_LINK ) 10d112: 83 78 4c 03 cmpl $0x3,0x4c(%eax) 10d116: 74 0d je 10d125 rtems_fatal_error_occurred (0xABCD0000); 10d118: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d11b: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED 10d120: e8 17 d4 ff ff call 10a53c <== NOT EXECUTED /* * Set the hard link value and the handlers. */ node->node_access = jnode->info.hard_link.link_node; 10d125: 8b 40 50 mov 0x50(%eax),%eax 10d128: 89 03 mov %eax,(%ebx) IMFS_Set_handlers( node ); 10d12a: 83 ec 0c sub $0xc,%esp 10d12d: 53 push %ebx 10d12e: e8 3d ff ff ff call 10d070 /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) 10d133: 58 pop %eax 10d134: 5a pop %edx 10d135: ff 75 0c pushl 0xc(%ebp) 10d138: 53 push %ebx 10d139: e8 7a ff ff ff call 10d0b8 10d13e: 89 c2 mov %eax,%edx 10d140: 83 c4 10 add $0x10,%esp 10d143: 31 c0 xor %eax,%eax 10d145: 85 d2 test %edx,%edx 10d147: 75 0e jne 10d157 rtems_set_errno_and_return_minus_one( EACCES ); 10d149: e8 06 44 00 00 call 111554 <__errno> <== NOT EXECUTED 10d14e: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10d154: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED return result; } 10d157: 8b 5d fc mov -0x4(%ebp),%ebx 10d15a: c9 leave 10d15b: c3 ret 0010d15c : int IMFS_evaluate_sym_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10d15c: 55 push %ebp 10d15d: 89 e5 mov %esp,%ebp 10d15f: 57 push %edi 10d160: 56 push %esi 10d161: 53 push %ebx 10d162: 83 ec 0c sub $0xc,%esp 10d165: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *jnode = node->node_access; 10d168: 8b 03 mov (%ebx),%eax /* * Check for things that should never happen. */ if ( jnode->type != IMFS_SYM_LINK ) 10d16a: 83 78 4c 04 cmpl $0x4,0x4c(%eax) 10d16e: 74 0a je 10d17a rtems_fatal_error_occurred (0xABCD0000); 10d170: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d173: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED 10d178: eb 0f jmp 10d189 <== NOT EXECUTED if ( !jnode->Parent ) 10d17a: 8b 50 08 mov 0x8(%eax),%edx 10d17d: 85 d2 test %edx,%edx 10d17f: 75 0d jne 10d18e rtems_fatal_error_occurred( 0xBAD00000 ); 10d181: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d184: 68 00 00 d0 ba push $0xbad00000 <== NOT EXECUTED 10d189: e8 ae d3 ff ff call 10a53c <== 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; 10d18e: 89 13 mov %edx,(%ebx) rtems_filesystem_get_sym_start_loc( 10d190: 8b 50 50 mov 0x50(%eax),%edx 10d193: 8a 0a mov (%edx),%cl 10d195: 80 f9 5c cmp $0x5c,%cl 10d198: 74 0b je 10d1a5 10d19a: 80 f9 2f cmp $0x2f,%cl 10d19d: 74 06 je 10d1a5 10d19f: 31 d2 xor %edx,%edx 10d1a1: 84 c9 test %cl,%cl 10d1a3: 75 17 jne 10d1bc 10d1a5: 8b 35 48 1f 12 00 mov 0x121f48,%esi 10d1ab: 83 c6 18 add $0x18,%esi 10d1ae: b9 05 00 00 00 mov $0x5,%ecx 10d1b3: 89 df mov %ebx,%edi 10d1b5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 10d1b7: 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] ), 10d1bc: 03 50 50 add 0x50(%eax),%edx 10d1bf: 31 c0 xor %eax,%eax 10d1c1: 83 c9 ff or $0xffffffff,%ecx 10d1c4: 89 d7 mov %edx,%edi 10d1c6: f2 ae repnz scas %es:(%edi),%al 10d1c8: f7 d1 not %ecx 10d1ca: 49 dec %ecx /* * Use eval path to evaluate the path of the symbolic link. */ result = IMFS_eval_path( 10d1cb: 53 push %ebx 10d1cc: ff 75 0c pushl 0xc(%ebp) 10d1cf: 51 push %ecx 10d1d0: 52 push %edx 10d1d1: e8 34 00 00 00 call 10d20a 10d1d6: 89 c6 mov %eax,%esi strlen( &jnode->info.sym_link.name[i] ), flags, node ); IMFS_Set_handlers( node ); 10d1d8: 89 1c 24 mov %ebx,(%esp) 10d1db: e8 90 fe ff ff call 10d070 /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) 10d1e0: 59 pop %ecx 10d1e1: 5f pop %edi 10d1e2: ff 75 0c pushl 0xc(%ebp) 10d1e5: 53 push %ebx 10d1e6: e8 cd fe ff ff call 10d0b8 10d1eb: 83 c4 10 add $0x10,%esp 10d1ee: 85 c0 test %eax,%eax 10d1f0: 75 0e jne 10d200 rtems_set_errno_and_return_minus_one( EACCES ); 10d1f2: e8 5d 43 00 00 call 111554 <__errno> <== NOT EXECUTED 10d1f7: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10d1fd: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED return result; } 10d200: 89 f0 mov %esi,%eax 10d202: 8d 65 f4 lea -0xc(%ebp),%esp 10d205: 5b pop %ebx 10d206: 5e pop %esi 10d207: 5f pop %edi 10d208: c9 leave 10d209: c3 ret 001101e4 : int IMFS_fchmod( rtems_filesystem_location_info_t *loc, mode_t mode ) { 1101e4: 55 push %ebp 1101e5: 89 e5 mov %esp,%ebp 1101e7: 53 push %ebx 1101e8: 83 ec 14 sub $0x14,%esp IMFS_jnode_t *jnode; #if defined(RTEMS_POSIX_API) uid_t st_uid; #endif jnode = loc->node_access; 1101eb: 8b 45 08 mov 0x8(%ebp),%eax 1101ee: 8b 18 mov (%eax),%ebx /* * Verify I am the owner of the node or the super user. */ #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 1101f0: e8 cb db ff ff call 10ddc0 if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) 1101f5: 66 85 c0 test %ax,%ax 1101f8: 74 16 je 110210 1101fa: 66 3b 43 3c cmp 0x3c(%ebx),%ax <== NOT EXECUTED 1101fe: 74 10 je 110210 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EPERM ); 110200: e8 4f 13 00 00 call 111554 <__errno> <== NOT EXECUTED 110205: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 11020b: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11020e: eb 2e jmp 11023e <== NOT EXECUTED /* * Change only the RWX permissions on the jnode to mode. */ jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX); jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX); 110210: 8b 45 0c mov 0xc(%ebp),%eax 110213: 25 ff 0f 00 00 and $0xfff,%eax 110218: 8b 53 30 mov 0x30(%ebx),%edx 11021b: 81 e2 00 f0 ff ff and $0xfffff000,%edx 110221: 09 d0 or %edx,%eax 110223: 89 43 30 mov %eax,0x30(%ebx) IMFS_update_ctime( jnode ); 110226: 50 push %eax 110227: 50 push %eax 110228: 6a 00 push $0x0 11022a: 8d 45 f0 lea -0x10(%ebp),%eax 11022d: 50 push %eax 11022e: e8 9d db ff ff call 10ddd0 110233: 8b 45 f0 mov -0x10(%ebp),%eax 110236: 89 43 48 mov %eax,0x48(%ebx) 110239: 31 c0 xor %eax,%eax return 0; 11023b: 83 c4 10 add $0x10,%esp } 11023e: 8b 5d fc mov -0x4(%ebp),%ebx 110241: c9 leave 110242: c3 ret 0010d7c1 : } int IMFS_fifo_close( rtems_libio_t *iop ) { 10d7c1: 55 push %ebp <== NOT EXECUTED 10d7c2: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d7c4: 57 push %edi <== NOT EXECUTED 10d7c5: 56 push %esi <== NOT EXECUTED 10d7c6: 53 push %ebx <== NOT EXECUTED 10d7c7: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10d7ca: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED IMFS_jnode_t *jnode = iop->file_info; 10d7cd: 8b 77 38 mov 0x38(%edi),%esi <== NOT EXECUTED int err = pipe_release(&JNODE2PIPE(jnode), iop); 10d7d0: 57 push %edi <== NOT EXECUTED 10d7d1: 8d 46 50 lea 0x50(%esi),%eax <== NOT EXECUTED 10d7d4: 50 push %eax <== NOT EXECUTED 10d7d5: e8 2d 24 00 00 call 10fc07 <== NOT EXECUTED 10d7da: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (! err) { 10d7dc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d7df: 83 f8 00 cmp $0x0,%eax <== NOT EXECUTED 10d7e2: 75 2c jne 10d810 <== NOT EXECUTED iop->flags &= ~LIBIO_FLAGS_OPEN; 10d7e4: 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) 10d7eb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d7ee: 56 push %esi <== NOT EXECUTED 10d7ef: e8 8e 06 00 00 call 10de82 <== NOT EXECUTED 10d7f4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d7f7: 85 c0 test %eax,%eax <== NOT EXECUTED 10d7f9: 75 23 jne 10d81e <== NOT EXECUTED 10d7fb: 66 83 7e 34 00 cmpw $0x0,0x34(%esi) <== NOT EXECUTED 10d800: 75 1c jne 10d81e <== NOT EXECUTED free(jnode); 10d802: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d805: 56 push %esi <== NOT EXECUTED 10d806: e8 75 99 ff ff call 107180 <== NOT EXECUTED 10d80b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d80e: eb 0e jmp 10d81e <== NOT EXECUTED } IMFS_FIFO_RETURN(err); 10d810: 7d 0c jge 10d81e <== NOT EXECUTED 10d812: e8 3d 3d 00 00 call 111554 <__errno> <== NOT EXECUTED 10d817: f7 db neg %ebx <== NOT EXECUTED 10d819: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10d81b: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED } 10d81e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d820: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d823: 5b pop %ebx <== NOT EXECUTED 10d824: 5e pop %esi <== NOT EXECUTED 10d825: 5f pop %edi <== NOT EXECUTED 10d826: c9 leave <== NOT EXECUTED 10d827: c3 ret <== NOT EXECUTED 0010d6b4 : int IMFS_fifo_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 10d6b4: 55 push %ebp <== NOT EXECUTED 10d6b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d6b7: 53 push %ebx <== NOT EXECUTED 10d6b8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d6bb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d6be: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10d6c1: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED int err; if (command == FIONBIO) { 10d6c4: 81 f9 7e 66 04 80 cmp $0x8004667e,%ecx <== NOT EXECUTED 10d6ca: 75 1c jne 10d6e8 <== NOT EXECUTED if (buffer == NULL) 10d6cc: bb f2 ff ff ff mov $0xfffffff2,%ebx <== NOT EXECUTED 10d6d1: 85 d2 test %edx,%edx <== NOT EXECUTED 10d6d3: 74 2a je 10d6ff <== NOT EXECUTED err = -EFAULT; else { if (*(int *)buffer) 10d6d5: 83 3a 00 cmpl $0x0,(%edx) <== NOT EXECUTED 10d6d8: 74 06 je 10d6e0 <== NOT EXECUTED iop->flags |= LIBIO_FLAGS_NO_DELAY; 10d6da: 83 48 14 01 orl $0x1,0x14(%eax) <== NOT EXECUTED 10d6de: eb 04 jmp 10d6e4 <== NOT EXECUTED else iop->flags &= ~LIBIO_FLAGS_NO_DELAY; 10d6e0: 83 60 14 fe andl $0xfffffffe,0x14(%eax) <== NOT EXECUTED 10d6e4: 31 db xor %ebx,%ebx <== NOT EXECUTED 10d6e6: eb 23 jmp 10d70b <== NOT EXECUTED return 0; } } else err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop); 10d6e8: 50 push %eax <== NOT EXECUTED 10d6e9: 52 push %edx <== NOT EXECUTED 10d6ea: 51 push %ecx <== NOT EXECUTED 10d6eb: 8b 40 38 mov 0x38(%eax),%eax <== NOT EXECUTED 10d6ee: ff 70 50 pushl 0x50(%eax) <== NOT EXECUTED 10d6f1: e8 75 21 00 00 call 10f86b <== NOT EXECUTED 10d6f6: 89 c3 mov %eax,%ebx <== NOT EXECUTED IMFS_FIFO_RETURN(err); 10d6f8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d6fb: 85 c0 test %eax,%eax <== NOT EXECUTED 10d6fd: 79 0c jns 10d70b <== NOT EXECUTED 10d6ff: e8 50 3e 00 00 call 111554 <__errno> <== NOT EXECUTED 10d704: f7 db neg %ebx <== NOT EXECUTED 10d706: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10d708: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED } 10d70b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d70d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d710: c9 leave <== NOT EXECUTED 10d711: c3 ret <== NOT EXECUTED 0010d678 : rtems_off64_t IMFS_fifo_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) { 10d678: 55 push %ebp <== NOT EXECUTED 10d679: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d67b: 53 push %ebx <== NOT EXECUTED 10d67c: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10d67f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop); 10d682: 50 push %eax <== NOT EXECUTED 10d683: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10d686: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10d689: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d68c: 8b 40 38 mov 0x38(%eax),%eax <== NOT EXECUTED 10d68f: ff 70 50 pushl 0x50(%eax) <== NOT EXECUTED 10d692: e8 7d 21 00 00 call 10f814 <== NOT EXECUTED 10d697: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10d699: 99 cltd <== NOT EXECUTED IMFS_FIFO_RETURN(err); 10d69a: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10d69d: 85 d2 test %edx,%edx <== NOT EXECUTED 10d69f: 79 0e jns 10d6af <== NOT EXECUTED 10d6a1: e8 ae 3e 00 00 call 111554 <__errno> <== NOT EXECUTED 10d6a6: f7 db neg %ebx <== NOT EXECUTED 10d6a8: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10d6aa: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10d6ad: 89 c2 mov %eax,%edx <== NOT EXECUTED } 10d6af: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d6b2: c9 leave <== NOT EXECUTED 10d6b3: c3 ret <== NOT EXECUTED 0010d76b : ssize_t IMFS_fifo_read( rtems_libio_t *iop, void *buffer, size_t count ) { 10d76b: 55 push %ebp <== NOT EXECUTED 10d76c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d76e: 56 push %esi <== NOT EXECUTED 10d76f: 53 push %ebx <== NOT EXECUTED 10d770: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10d773: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED IMFS_jnode_t *jnode = iop->file_info; 10d776: 8b 70 38 mov 0x38(%eax),%esi <== NOT EXECUTED int err = pipe_read(JNODE2PIPE(jnode), buffer, count, iop); 10d779: 50 push %eax <== NOT EXECUTED 10d77a: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10d77d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d780: ff 76 50 pushl 0x50(%esi) <== NOT EXECUTED 10d783: e8 39 21 00 00 call 10f8c1 <== NOT EXECUTED 10d788: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (err > 0) 10d78a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d78d: 83 f8 00 cmp $0x0,%eax <== NOT EXECUTED 10d790: 7e 18 jle 10d7aa <== NOT EXECUTED IMFS_update_atime(jnode); 10d792: 52 push %edx <== NOT EXECUTED 10d793: 52 push %edx <== NOT EXECUTED 10d794: 6a 00 push $0x0 <== NOT EXECUTED 10d796: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10d799: 50 push %eax <== NOT EXECUTED 10d79a: e8 31 06 00 00 call 10ddd0 <== NOT EXECUTED 10d79f: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10d7a2: 89 46 40 mov %eax,0x40(%esi) <== NOT EXECUTED 10d7a5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d7a8: eb 0e jmp 10d7b8 <== NOT EXECUTED IMFS_FIFO_RETURN(err); 10d7aa: 74 0c je 10d7b8 <== NOT EXECUTED 10d7ac: e8 a3 3d 00 00 call 111554 <__errno> <== NOT EXECUTED 10d7b1: f7 db neg %ebx <== NOT EXECUTED 10d7b3: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10d7b5: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED } 10d7b8: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d7ba: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d7bd: 5b pop %ebx <== NOT EXECUTED 10d7be: 5e pop %esi <== NOT EXECUTED 10d7bf: c9 leave <== NOT EXECUTED 10d7c0: c3 ret <== NOT EXECUTED 0010d712 : ssize_t IMFS_fifo_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 10d712: 55 push %ebp <== NOT EXECUTED 10d713: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d715: 56 push %esi <== NOT EXECUTED 10d716: 53 push %ebx <== NOT EXECUTED 10d717: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10d71a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED IMFS_jnode_t *jnode = iop->file_info; 10d71d: 8b 70 38 mov 0x38(%eax),%esi <== NOT EXECUTED int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop); 10d720: 50 push %eax <== NOT EXECUTED 10d721: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10d724: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d727: ff 76 50 pushl 0x50(%esi) <== NOT EXECUTED 10d72a: e8 f4 22 00 00 call 10fa23 <== NOT EXECUTED 10d72f: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (err > 0) { 10d731: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d734: 83 f8 00 cmp $0x0,%eax <== NOT EXECUTED 10d737: 7e 1b jle 10d754 <== NOT EXECUTED IMFS_mtime_ctime_update(jnode); 10d739: 50 push %eax <== NOT EXECUTED 10d73a: 50 push %eax <== NOT EXECUTED 10d73b: 6a 00 push $0x0 <== NOT EXECUTED 10d73d: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10d740: 50 push %eax <== NOT EXECUTED 10d741: e8 8a 06 00 00 call 10ddd0 <== NOT EXECUTED 10d746: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10d749: 89 46 44 mov %eax,0x44(%esi) <== NOT EXECUTED 10d74c: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED 10d74f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d752: eb 0e jmp 10d762 <== NOT EXECUTED } IMFS_FIFO_RETURN(err); 10d754: 74 0c je 10d762 <== NOT EXECUTED 10d756: e8 f9 3d 00 00 call 111554 <__errno> <== NOT EXECUTED 10d75b: f7 db neg %ebx <== NOT EXECUTED 10d75d: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10d75f: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED } 10d762: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d764: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d767: 5b pop %ebx <== NOT EXECUTED 10d768: 5e pop %esi <== NOT EXECUTED 10d769: c9 leave <== NOT EXECUTED 10d76a: c3 ret <== NOT EXECUTED 0010d85c : IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) { 10d85c: 55 push %ebp 10d85d: 89 e5 mov %esp,%ebp 10d85f: 57 push %edi 10d860: 56 push %esi 10d861: 53 push %ebx 10d862: 83 ec 0c sub $0xc,%esp 10d865: 8b 5d 08 mov 0x8(%ebp),%ebx 10d868: 8b 7d 0c mov 0xc(%ebp),%edi /* * Check for fatal errors. A NULL directory show a problem in the * the IMFS code. */ assert( directory ); 10d86b: 85 db test %ebx,%ebx 10d86d: 75 16 jne 10d885 10d86f: 68 f8 eb 11 00 push $0x11ebf8 <== NOT EXECUTED 10d874: 68 58 ec 11 00 push $0x11ec58 <== NOT EXECUTED 10d879: 6a 2a push $0x2a <== NOT EXECUTED 10d87b: 68 02 ec 11 00 push $0x11ec02 <== NOT EXECUTED 10d880: e8 0b 96 ff ff call 106e90 <__assert_func> <== NOT EXECUTED if ( !name ) 10d885: 85 ff test %edi,%edi 10d887: 74 52 je 10d8db /* * Check for "." and ".." */ if ( !strcmp( name, dotname ) ) 10d889: 56 push %esi 10d88a: 56 push %esi 10d88b: 68 50 ec 11 00 push $0x11ec50 10d890: 57 push %edi 10d891: e8 da 47 00 00 call 112070 10d896: 83 c4 10 add $0x10,%esp 10d899: 85 c0 test %eax,%eax 10d89b: 74 40 je 10d8dd return directory; if ( !strcmp( name, dotdotname ) ) 10d89d: 51 push %ecx 10d89e: 51 push %ecx 10d89f: 68 52 ec 11 00 push $0x11ec52 10d8a4: 57 push %edi 10d8a5: e8 c6 47 00 00 call 112070 10d8aa: 83 c4 10 add $0x10,%esp 10d8ad: 85 c0 test %eax,%eax 10d8af: 75 05 jne 10d8b6 return directory->Parent; 10d8b1: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10d8b4: eb 27 jmp 10d8dd <== NOT EXECUTED the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; 10d8b6: 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; 10d8b9: 83 c3 54 add $0x54,%ebx 10d8bc: eb 19 jmp 10d8d7 !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 ) ) 10d8be: 8d 46 0c lea 0xc(%esi),%eax 10d8c1: 52 push %edx 10d8c2: 52 push %edx 10d8c3: 50 push %eax 10d8c4: 57 push %edi 10d8c5: e8 a6 47 00 00 call 112070 10d8ca: 83 c4 10 add $0x10,%esp 10d8cd: 85 c0 test %eax,%eax 10d8cf: 75 04 jne 10d8d5 10d8d1: 89 f3 mov %esi,%ebx 10d8d3: eb 08 jmp 10d8dd 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 ) { 10d8d5: 8b 36 mov (%esi),%esi if ( !strcmp( name, dotdotname ) ) return directory->Parent; the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; 10d8d7: 39 de cmp %ebx,%esi 10d8d9: 75 e3 jne 10d8be 10d8db: 31 db xor %ebx,%ebx if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10d8dd: 89 d8 mov %ebx,%eax 10d8df: 8d 65 f4 lea -0xc(%ebp),%esp 10d8e2: 5b pop %ebx 10d8e3: 5e pop %esi 10d8e4: 5f pop %edi 10d8e5: c9 leave 10d8e6: c3 ret 00111bf0 : ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next)) int IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 111bf0: 55 push %ebp 111bf1: 89 e5 mov %esp,%ebp 111bf3: 57 push %edi 111bf4: 56 push %esi 111bf5: 53 push %ebx 111bf6: 83 ec 2c sub $0x2c,%esp 111bf9: 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; 111bfc: 8b 58 1c mov 0x1c(%eax),%ebx loc = temp_mt_entry->mt_fs_root; 111bff: 8d 7d d4 lea -0x2c(%ebp),%edi 111c02: 8d 70 1c lea 0x1c(%eax),%esi 111c05: b9 05 00 00 00 mov $0x5,%ecx 111c0a: 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; 111c0c: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) do { next = jnode->Parent; loc.node_access = (void *)jnode; IMFS_Set_handlers( &loc ); 111c13: 8d 75 d4 lea -0x2c(%ebp),%esi */ temp_mt_entry->mt_fs_root.node_access = NULL; do { next = jnode->Parent; 111c16: 8b 7b 08 mov 0x8(%ebx),%edi loc.node_access = (void *)jnode; 111c19: 89 5d d4 mov %ebx,-0x2c(%ebp) IMFS_Set_handlers( &loc ); 111c1c: 83 ec 0c sub $0xc,%esp 111c1f: 56 push %esi 111c20: e8 d7 f7 ff ff call 1113fc if ( jnode->type != IMFS_DIRECTORY ) { 111c25: 83 c4 10 add $0x10,%esp 111c28: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 111c2c: 75 08 jne 111c36 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 111c2e: 8d 43 54 lea 0x54(%ebx),%eax 111c31: 39 43 50 cmp %eax,0x50(%ebx) 111c34: 75 13 jne 111c49 result = IMFS_unlink( NULL, &loc ); if (result != 0) return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { result = IMFS_unlink( NULL, &loc ); 111c36: 50 push %eax 111c37: 50 push %eax 111c38: 56 push %esi 111c39: 6a 00 push $0x0 111c3b: e8 70 61 ff ff call 107db0 if (result != 0) 111c40: 83 c4 10 add $0x10,%esp 111c43: 85 c0 test %eax,%eax 111c45: 75 1d jne 111c64 111c47: 89 fb mov %edi,%ebx return -1; jnode = next; } if ( jnode != NULL ) { 111c49: 85 db test %ebx,%ebx 111c4b: 74 1c je 111c69 if ( jnode->type == IMFS_DIRECTORY ) { 111c4d: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 111c51: 75 c3 jne 111c16 111c53: 8d 43 54 lea 0x54(%ebx),%eax 111c56: 39 43 50 cmp %eax,0x50(%ebx) 111c59: 74 bb je 111c16 if ( jnode_has_children( jnode ) ) jnode = jnode_get_first_child( jnode ); 111c5b: 8b 5b 50 mov 0x50(%ebx),%ebx } } } while (jnode != NULL); 111c5e: 85 db test %ebx,%ebx 111c60: 75 b4 jne 111c16 111c62: eb 05 jmp 111c69 <== NOT EXECUTED 111c64: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 111c67: eb 02 jmp 111c6b <== NOT EXECUTED 111c69: 31 c0 xor %eax,%eax return 0; } 111c6b: 8d 65 f4 lea -0xc(%ebp),%esp 111c6e: 5b pop %ebx 111c6f: 5e pop %esi 111c70: 5f pop %edi 111c71: c9 leave 111c72: c3 ret 0010d990 : 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 ) { 10d990: 55 push %ebp 10d991: 89 e5 mov %esp,%ebp 10d993: 57 push %edi 10d994: 56 push %esi 10d995: 53 push %ebx 10d996: 83 ec 0c sub $0xc,%esp 10d999: 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, 10d99c: 8b 0d 48 01 12 00 mov 0x120148,%ecx 10d9a2: 31 d2 xor %edx,%edx 10d9a4: 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) { 10d9a9: 39 c8 cmp %ecx,%eax 10d9ab: 74 0d je 10d9ba 10d9ad: d1 e0 shl %eax 10d9af: 42 inc %edx 10d9b0: 83 fa 06 cmp $0x6,%edx 10d9b3: 75 f4 jne 10d9a9 10d9b5: 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) 10d9ba: a3 90 3e 12 00 mov %eax,0x123e90 /* * 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(); 10d9bf: e8 ef 26 00 00 call 1100b3 10d9c4: 89 43 1c mov %eax,0x1c(%ebx) temp_mt_entry->mt_fs_root.handlers = directory_handlers; 10d9c7: 8b 45 14 mov 0x14(%ebp),%eax 10d9ca: 89 43 24 mov %eax,0x24(%ebx) temp_mt_entry->mt_fs_root.ops = op_table; 10d9cd: 8b 45 0c mov 0xc(%ebp),%eax 10d9d0: 89 43 28 mov %eax,0x28(%ebx) temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS; 10d9d3: 8d 7b 38 lea 0x38(%ebx),%edi 10d9d6: be 88 ef 11 00 mov $0x11ef88,%esi 10d9db: b9 0c 00 00 00 mov $0xc,%ecx 10d9e0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Create custom file system data. */ fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) ); 10d9e2: 50 push %eax 10d9e3: 50 push %eax 10d9e4: 6a 0c push $0xc 10d9e6: 6a 01 push $0x1 10d9e8: e8 4b 02 00 00 call 10dc38 if ( !fs_info ) { 10d9ed: 83 c4 10 add $0x10,%esp 10d9f0: 85 c0 test %eax,%eax 10d9f2: 75 1e jne 10da12 free(temp_mt_entry->mt_fs_root.node_access); 10d9f4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d9f7: ff 73 1c pushl 0x1c(%ebx) <== NOT EXECUTED 10d9fa: e8 81 97 ff ff call 107180 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(ENOMEM); 10d9ff: e8 50 3b 00 00 call 111554 <__errno> <== NOT EXECUTED 10da04: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10da0a: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10da0d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10da10: eb 26 jmp 10da38 <== NOT EXECUTED } temp_mt_entry->fs_info = fs_info; 10da12: 89 43 34 mov %eax,0x34(%ebx) /* * Set st_ino for the root to 1. */ fs_info->ino_count = 1; 10da15: c7 00 01 00 00 00 movl $0x1,(%eax) fs_info->memfile_handlers = memfile_handlers; 10da1b: 8b 55 10 mov 0x10(%ebp),%edx 10da1e: 89 50 04 mov %edx,0x4(%eax) fs_info->directory_handlers = directory_handlers; 10da21: 8b 55 14 mov 0x14(%ebp),%edx 10da24: 89 50 08 mov %edx,0x8(%eax) jnode = temp_mt_entry->mt_fs_root.node_access; jnode->st_ino = fs_info->ino_count; 10da27: 8b 43 1c mov 0x1c(%ebx),%eax 10da2a: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax) /* Initialize POSIX FIFO/pipe module */ rtems_pipe_initialize(); 10da31: e8 e8 1d 00 00 call 10f81e 10da36: 31 c0 xor %eax,%eax return 0; } 10da38: 8d 65 f4 lea -0xc(%ebp),%esp 10da3b: 5b pop %ebx 10da3c: 5e pop %esi 10da3d: 5f pop %edi 10da3e: c9 leave 10da3f: 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 41 e1 00 00 call 115c50 <__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 ce a1 00 00 call 111d00 * 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 b6 97 00 00 call 1112fe 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 fc e0 00 00 call 115c50 <__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 001142cc : MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) { 1142cc: 55 push %ebp 1142cd: 89 e5 mov %esp,%ebp 1142cf: 53 push %ebx 1142d0: 83 ec 04 sub $0x4,%esp 1142d3: 8b 45 08 mov 0x8(%ebp),%eax block_p memory; block_p *block_entry_ptr; assert( the_jnode ); 1142d6: 85 c0 test %eax,%eax 1142d8: 75 11 jne 1142eb 1142da: 68 f4 38 12 00 push $0x1238f4 <== NOT EXECUTED 1142df: 68 98 3a 12 00 push $0x123a98 <== NOT EXECUTED 1142e4: 68 69 01 00 00 push $0x169 <== NOT EXECUTED 1142e9: eb 15 jmp 114300 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 1142eb: 83 78 4c 05 cmpl $0x5,0x4c(%eax) 1142ef: 74 19 je 11430a 1142f1: 68 44 39 12 00 push $0x123944 <== NOT EXECUTED 1142f6: 68 98 3a 12 00 push $0x123a98 <== NOT EXECUTED 1142fb: 68 6d 01 00 00 push $0x16d <== NOT EXECUTED 114300: 68 fe 38 12 00 push $0x1238fe <== NOT EXECUTED 114305: e8 b6 3c 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 ); 11430a: 52 push %edx 11430b: 6a 01 push $0x1 11430d: ff 75 0c pushl 0xc(%ebp) 114310: 50 push %eax 114311: e8 84 fb ff ff call 113e9a 114316: 89 c3 mov %eax,%ebx if ( *block_entry_ptr ) 114318: 83 c4 10 add $0x10,%esp 11431b: 31 c0 xor %eax,%eax 11431d: 83 3b 00 cmpl $0x0,(%ebx) 114320: 75 14 jne 114336 #if 0 fprintf(stdout, "%d %p", block, block_entry_ptr ); fflush(stdout); #endif memory = memfile_alloc_block(); 114322: e8 51 fb ff ff call 113e78 114327: 89 c2 mov %eax,%edx if ( !memory ) 114329: b8 01 00 00 00 mov $0x1,%eax 11432e: 85 d2 test %edx,%edx 114330: 74 04 je 114336 return 1; *block_entry_ptr = memory; 114332: 89 13 mov %edx,(%ebx) 114334: 30 c0 xor %al,%al return 0; } 114336: 8b 5d fc mov -0x4(%ebp),%ebx 114339: c9 leave 11433a: c3 ret 0011433b : MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) { 11433b: 55 push %ebp 11433c: 89 e5 mov %esp,%ebp 11433e: 57 push %edi 11433f: 56 push %esi 114340: 53 push %ebx 114341: 83 ec 2c sub $0x2c,%esp 114344: 8b 5d 08 mov 0x8(%ebp),%ebx 114347: 8b 75 0c mov 0xc(%ebp),%esi 11434a: 8b 7d 10 mov 0x10(%ebp),%edi /* * Perform internal consistency checks */ assert( the_jnode ); 11434d: 85 db test %ebx,%ebx 11434f: 75 11 jne 114362 114351: 68 f4 38 12 00 push $0x1238f4 <== NOT EXECUTED 114356: 68 b0 3a 12 00 push $0x123ab0 <== NOT EXECUTED 11435b: 68 31 01 00 00 push $0x131 <== NOT EXECUTED 114360: eb 15 jmp 114377 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 114362: 83 7b 4c 05 cmpl $0x5,0x4c(%ebx) 114366: 74 19 je 114381 114368: 68 44 39 12 00 push $0x123944 <== NOT EXECUTED 11436d: 68 b0 3a 12 00 push $0x123ab0 <== NOT EXECUTED 114372: 68 35 01 00 00 push $0x135 <== NOT EXECUTED 114377: 68 fe 38 12 00 push $0x1238fe <== NOT EXECUTED 11437c: e8 3f 3c 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 ) 114381: a1 b8 8d 12 00 mov 0x128db8,%eax 114386: 89 c1 mov %eax,%ecx 114388: c1 e9 02 shr $0x2,%ecx 11438b: 8d 51 01 lea 0x1(%ecx),%edx 11438e: 0f af d1 imul %ecx,%edx 114391: 42 inc %edx 114392: 0f af d1 imul %ecx,%edx 114395: 4a dec %edx 114396: 0f af d0 imul %eax,%edx 114399: 83 ff 00 cmp $0x0,%edi 11439c: 7c 16 jl 1143b4 11439e: 7f 04 jg 1143a4 1143a0: 39 d6 cmp %edx,%esi 1143a2: 72 10 jb 1143b4 rtems_set_errno_and_return_minus_one( EINVAL ); 1143a4: e8 a7 18 00 00 call 115c50 <__errno> <== NOT EXECUTED 1143a9: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1143af: e9 92 00 00 00 jmp 114446 <== NOT EXECUTED if ( new_length <= the_jnode->info.file.size ) 1143b4: 8b 53 50 mov 0x50(%ebx),%edx 1143b7: 8b 4b 54 mov 0x54(%ebx),%ecx 1143ba: 89 55 e0 mov %edx,-0x20(%ebp) 1143bd: 89 4d e4 mov %ecx,-0x1c(%ebp) 1143c0: 39 cf cmp %ecx,%edi 1143c2: 7f 0e jg 1143d2 1143c4: 0f 8c 8d 00 00 00 jl 114457 1143ca: 39 d6 cmp %edx,%esi 1143cc: 0f 86 85 00 00 00 jbe 114457 /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; 1143d2: 89 45 d8 mov %eax,-0x28(%ebp) 1143d5: 89 c1 mov %eax,%ecx 1143d7: c1 f9 1f sar $0x1f,%ecx 1143da: 89 4d dc mov %ecx,-0x24(%ebp) 1143dd: ff 75 dc pushl -0x24(%ebp) 1143e0: ff 75 d8 pushl -0x28(%ebp) 1143e3: 57 push %edi 1143e4: 56 push %esi 1143e5: e8 a2 c8 00 00 call 120c8c <__divdi3> 1143ea: 83 c4 10 add $0x10,%esp 1143ed: 89 45 d4 mov %eax,-0x2c(%ebp) old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; 1143f0: ff 75 dc pushl -0x24(%ebp) 1143f3: ff 75 d8 pushl -0x28(%ebp) 1143f6: ff 75 e4 pushl -0x1c(%ebp) 1143f9: ff 75 e0 pushl -0x20(%ebp) 1143fc: e8 8b c8 00 00 call 120c8c <__divdi3> 114401: 83 c4 10 add $0x10,%esp 114404: 89 45 e0 mov %eax,-0x20(%ebp) 114407: 89 c2 mov %eax,%edx /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 114409: eb 41 jmp 11444c if ( IMFS_memfile_addblock( the_jnode, block ) ) { 11440b: 50 push %eax 11440c: 50 push %eax 11440d: 52 push %edx 11440e: 53 push %ebx 11440f: 89 55 d0 mov %edx,-0x30(%ebp) 114412: e8 b5 fe ff ff call 1142cc 114417: 83 c4 10 add $0x10,%esp 11441a: 85 c0 test %eax,%eax 11441c: 8b 55 d0 mov -0x30(%ebp),%edx 11441f: 74 2a je 11444b 114421: eb 13 jmp 114436 <== NOT EXECUTED for ( ; block>=old_blocks ; block-- ) { IMFS_memfile_remove_block( the_jnode, block ); 114423: 51 push %ecx <== NOT EXECUTED 114424: 51 push %ecx <== NOT EXECUTED 114425: 52 push %edx <== NOT EXECUTED 114426: 53 push %ebx <== NOT EXECUTED 114427: 89 55 d0 mov %edx,-0x30(%ebp) <== NOT EXECUTED 11442a: e8 5c fc ff ff call 11408b <== 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-- ) { 11442f: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 114432: 4a dec %edx <== NOT EXECUTED 114433: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114436: 3b 55 e0 cmp -0x20(%ebp),%edx <== NOT EXECUTED 114439: 73 e8 jae 114423 <== NOT EXECUTED IMFS_memfile_remove_block( the_jnode, block ); } rtems_set_errno_and_return_minus_one( ENOSPC ); 11443b: e8 10 18 00 00 call 115c50 <__errno> <== NOT EXECUTED 114440: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 114446: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 114449: eb 0e jmp 114459 <== NOT EXECUTED /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 11444b: 42 inc %edx 11444c: 3b 55 d4 cmp -0x2c(%ebp),%edx 11444f: 76 ba jbe 11440b /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; 114451: 89 73 50 mov %esi,0x50(%ebx) 114454: 89 7b 54 mov %edi,0x54(%ebx) 114457: 31 c0 xor %eax,%eax return 0; } 114459: 8d 65 f4 lea -0xc(%ebp),%esp 11445c: 5b pop %ebx 11445d: 5e pop %esi 11445e: 5f pop %edi 11445f: c9 leave 114460: c3 ret 00113e9a : #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) { 113e9a: 55 push %ebp 113e9b: 89 e5 mov %esp,%ebp 113e9d: 57 push %edi 113e9e: 56 push %esi 113e9f: 53 push %ebx 113ea0: 83 ec 1c sub $0x1c,%esp 113ea3: 8b 5d 08 mov 0x8(%ebp),%ebx 113ea6: 8b 7d 0c mov 0xc(%ebp),%edi 113ea9: 8b 75 10 mov 0x10(%ebp),%esi /* * Perform internal consistency checks */ assert( the_jnode ); 113eac: 85 db test %ebx,%ebx 113eae: 75 11 jne 113ec1 113eb0: 68 f4 38 12 00 push $0x1238f4 <== NOT EXECUTED 113eb5: 68 00 3a 12 00 push $0x123a00 <== NOT EXECUTED 113eba: 68 88 03 00 00 push $0x388 <== NOT EXECUTED 113ebf: eb 15 jmp 113ed6 <== NOT EXECUTED if ( !the_jnode ) return NULL; assert( the_jnode->type == IMFS_MEMORY_FILE ); 113ec1: 83 7b 4c 05 cmpl $0x5,0x4c(%ebx) 113ec5: 74 19 je 113ee0 113ec7: 68 44 39 12 00 push $0x123944 <== NOT EXECUTED 113ecc: 68 00 3a 12 00 push $0x123a00 <== NOT EXECUTED 113ed1: 68 8c 03 00 00 push $0x38c <== NOT EXECUTED 113ed6: 68 fe 38 12 00 push $0x1238fe <== NOT EXECUTED 113edb: e8 e0 40 ff ff call 107fc0 <__assert_func> <== NOT EXECUTED /* * Is the block number in the simple indirect portion? */ if ( my_block <= LAST_INDIRECT ) { 113ee0: 8b 0d b8 8d 12 00 mov 0x128db8,%ecx 113ee6: c1 e9 02 shr $0x2,%ecx 113ee9: 8d 41 ff lea -0x1(%ecx),%eax 113eec: 39 c7 cmp %eax,%edi 113eee: 77 2f ja 113f1f #if 0 fprintf(stdout, "(s %d) ", block ); fflush(stdout); #endif p = info->indirect; 113ef0: 8b 53 58 mov 0x58(%ebx),%edx if ( malloc_it ) { 113ef3: 85 f6 test %esi,%esi 113ef5: 74 23 je 113f1a if ( !p ) { 113ef7: 85 d2 test %edx,%edx 113ef9: 75 10 jne 113f0b p = memfile_alloc_block(); 113efb: e8 78 ff ff ff call 113e78 if ( !p ) 113f00: 85 c0 test %eax,%eax 113f02: 0f 84 0f 01 00 00 je 114017 return 0; info->indirect = p; 113f08: 89 43 58 mov %eax,0x58(%ebx) } return &info->indirect[ my_block ]; 113f0b: 8d 04 bd 00 00 00 00 lea 0x0(,%edi,4),%eax 113f12: 03 43 58 add 0x58(%ebx),%eax 113f15: e9 ff 00 00 00 jmp 114019 } if ( !p ) return 0; return &info->indirect[ my_block ]; 113f1a: 8d 04 ba lea (%edx,%edi,4),%eax 113f1d: eb 69 jmp 113f88 /* * Is the block number in the doubly indirect portion? */ if ( my_block <= LAST_DOUBLY_INDIRECT ) { 113f1f: 8d 41 01 lea 0x1(%ecx),%eax <== NOT EXECUTED 113f22: 0f af c1 imul %ecx,%eax <== NOT EXECUTED 113f25: 8d 50 ff lea -0x1(%eax),%edx <== NOT EXECUTED 113f28: 39 d7 cmp %edx,%edi <== NOT EXECUTED 113f2a: 77 69 ja 113f95 <== NOT EXECUTED #if 0 fprintf(stdout, "(d %d) ", block ); fflush(stdout); #endif my_block -= FIRST_DOUBLY_INDIRECT; 113f2c: 29 cf sub %ecx,%edi <== NOT EXECUTED singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 113f2e: 89 f8 mov %edi,%eax <== NOT EXECUTED 113f30: 31 d2 xor %edx,%edx <== NOT EXECUTED 113f32: f7 f1 div %ecx <== NOT EXECUTED 113f34: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED 113f37: 89 c7 mov %eax,%edi <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; p = info->doubly_indirect; 113f39: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED if ( malloc_it ) { 113f3c: 85 f6 test %esi,%esi <== NOT EXECUTED 113f3e: 74 37 je 113f77 <== NOT EXECUTED if ( !p ) { 113f40: 85 c0 test %eax,%eax <== NOT EXECUTED 113f42: 75 10 jne 113f54 <== NOT EXECUTED p = memfile_alloc_block(); 113f44: e8 2f ff ff ff call 113e78 <== NOT EXECUTED if ( !p ) 113f49: 85 c0 test %eax,%eax <== NOT EXECUTED 113f4b: 0f 84 c6 00 00 00 je 114017 <== NOT EXECUTED return 0; info->doubly_indirect = p; 113f51: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED } p1 = (block_p *)p[ doubly ]; 113f54: 8d 1c b8 lea (%eax,%edi,4),%ebx <== NOT EXECUTED 113f57: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p1 ) { 113f59: 85 c0 test %eax,%eax <== NOT EXECUTED 113f5b: 75 0f jne 113f6c <== NOT EXECUTED p1 = memfile_alloc_block(); 113f5d: e8 16 ff ff ff call 113e78 <== NOT EXECUTED if ( !p1 ) 113f62: 85 c0 test %eax,%eax <== NOT EXECUTED 113f64: 0f 84 ad 00 00 00 je 114017 <== NOT EXECUTED return 0; p[ doubly ] = (block_p) p1; 113f6a: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } return (block_p *)&p1[ singly ]; 113f6c: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 113f6f: 8d 04 88 lea (%eax,%ecx,4),%eax <== NOT EXECUTED 113f72: e9 a2 00 00 00 jmp 114019 <== NOT EXECUTED } if ( !p ) 113f77: 85 c0 test %eax,%eax <== NOT EXECUTED 113f79: 0f 84 98 00 00 00 je 114017 <== NOT EXECUTED return 0; p = (block_p *)p[ doubly ]; 113f7f: 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 ]; 113f82: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 113f85: 8d 04 8a lea (%edx,%ecx,4),%eax <== NOT EXECUTED if ( !p ) return 0; p = (block_p *)p[ doubly ]; if ( !p ) 113f88: 85 d2 test %edx,%edx 113f8a: 0f 85 89 00 00 00 jne 114019 113f90: e9 82 00 00 00 jmp 114017 <== NOT EXECUTED #endif /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 113f95: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED 113f98: 0f af d1 imul %ecx,%edx <== NOT EXECUTED 113f9b: 4a dec %edx <== NOT EXECUTED 113f9c: 39 d7 cmp %edx,%edi <== NOT EXECUTED 113f9e: 77 77 ja 114017 <== NOT EXECUTED my_block -= FIRST_TRIPLY_INDIRECT; 113fa0: 29 c7 sub %eax,%edi <== NOT EXECUTED 113fa2: 89 f8 mov %edi,%eax <== NOT EXECUTED singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 113fa4: 31 d2 xor %edx,%edx <== NOT EXECUTED 113fa6: f7 f1 div %ecx <== NOT EXECUTED 113fa8: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; 113fab: 31 d2 xor %edx,%edx <== NOT EXECUTED 113fad: f7 f1 div %ecx <== NOT EXECUTED 113faf: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED 113fb2: 89 c7 mov %eax,%edi <== NOT EXECUTED doubly %= IMFS_MEMFILE_BLOCK_SLOTS; p = info->triply_indirect; 113fb4: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED if ( malloc_it ) { 113fb7: 85 f6 test %esi,%esi <== NOT EXECUTED 113fb9: 74 43 je 113ffe <== NOT EXECUTED if ( !p ) { 113fbb: 85 c0 test %eax,%eax <== NOT EXECUTED 113fbd: 75 0c jne 113fcb <== NOT EXECUTED p = memfile_alloc_block(); 113fbf: e8 b4 fe ff ff call 113e78 <== NOT EXECUTED if ( !p ) 113fc4: 85 c0 test %eax,%eax <== NOT EXECUTED 113fc6: 74 4f je 114017 <== NOT EXECUTED return 0; info->triply_indirect = p; 113fc8: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED } p1 = (block_p *) p[ triply ]; 113fcb: 8d 1c b8 lea (%eax,%edi,4),%ebx <== NOT EXECUTED 113fce: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p1 ) { 113fd0: 85 c0 test %eax,%eax <== NOT EXECUTED 113fd2: 75 0b jne 113fdf <== NOT EXECUTED p1 = memfile_alloc_block(); 113fd4: e8 9f fe ff ff call 113e78 <== NOT EXECUTED if ( !p1 ) 113fd9: 85 c0 test %eax,%eax <== NOT EXECUTED 113fdb: 74 3a je 114017 <== NOT EXECUTED return 0; p[ triply ] = (block_p) p1; 113fdd: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } p2 = (block_p *)p1[ doubly ]; 113fdf: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED 113fe2: 8d 1c 88 lea (%eax,%ecx,4),%ebx <== NOT EXECUTED 113fe5: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p2 ) { 113fe7: 85 c0 test %eax,%eax <== NOT EXECUTED 113fe9: 75 0b jne 113ff6 <== NOT EXECUTED p2 = memfile_alloc_block(); 113feb: e8 88 fe ff ff call 113e78 <== NOT EXECUTED if ( !p2 ) 113ff0: 85 c0 test %eax,%eax <== NOT EXECUTED 113ff2: 74 23 je 114017 <== NOT EXECUTED return 0; p1[ doubly ] = (block_p) p2; 113ff4: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } return (block_p *)&p2[ singly ]; 113ff6: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 113ff9: 8d 04 90 lea (%eax,%edx,4),%eax <== NOT EXECUTED 113ffc: eb 1b jmp 114019 <== NOT EXECUTED } if ( !p ) 113ffe: 85 c0 test %eax,%eax <== NOT EXECUTED 114000: 74 15 je 114017 <== 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 ]; 114002: 8b 14 b8 mov (%eax,%edi,4),%edx <== NOT EXECUTED if ( !p1 ) 114005: 85 d2 test %edx,%edx <== NOT EXECUTED 114007: 74 0e je 114017 <== NOT EXECUTED p2 = (block_p *)p1[ doubly ]; if ( !p ) return 0; return (block_p *)&p2[ singly ]; 114009: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 11400c: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 11400f: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED 114012: 03 04 8a add (%edx,%ecx,4),%eax <== NOT EXECUTED 114015: eb 02 jmp 114019 <== NOT EXECUTED 114017: 31 c0 xor %eax,%eax <== NOT EXECUTED /* * This means the requested block number is out of range. */ return 0; } 114019: 8d 65 f4 lea -0xc(%ebp),%esp 11401c: 5b pop %ebx 11401d: 5e pop %esi 11401e: 5f pop %edi 11401f: c9 leave 114020: c3 ret 001147d2 : IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) { 1147d2: 55 push %ebp 1147d3: 89 e5 mov %esp,%ebp 1147d5: 57 push %edi 1147d6: 56 push %esi 1147d7: 53 push %ebx 1147d8: 83 ec 3c sub $0x3c,%esp 1147db: 8b 75 0c mov 0xc(%ebp),%esi 1147de: 8b 7d 10 mov 0x10(%ebp),%edi /* * Perform internal consistency checks */ assert( the_jnode ); 1147e1: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 1147e5: 75 11 jne 1147f8 1147e7: 68 f4 38 12 00 push $0x1238f4 <== NOT EXECUTED 1147ec: 68 34 3a 12 00 push $0x123a34 <== NOT EXECUTED 1147f1: 68 4c 02 00 00 push $0x24c <== NOT EXECUTED 1147f6: eb 1d jmp 114815 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE || 1147f8: 8b 55 08 mov 0x8(%ebp),%edx 1147fb: 8b 42 4c mov 0x4c(%edx),%eax 1147fe: 8d 48 fb lea -0x5(%eax),%ecx 114801: 83 f9 01 cmp $0x1,%ecx 114804: 76 19 jbe 11481f 114806: 68 ae 39 12 00 push $0x1239ae <== NOT EXECUTED 11480b: 68 34 3a 12 00 push $0x123a34 <== NOT EXECUTED 114810: 68 51 02 00 00 push $0x251 <== NOT EXECUTED 114815: 68 fe 38 12 00 push $0x1238fe <== NOT EXECUTED 11481a: e8 a1 37 ff ff call 107fc0 <__assert_func> <== NOT EXECUTED /* * Error checks on arguments */ assert( dest ); 11481f: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 114823: 75 11 jne 114836 114825: 68 f9 39 12 00 push $0x1239f9 <== NOT EXECUTED 11482a: 68 34 3a 12 00 push $0x123a34 <== NOT EXECUTED 11482f: 68 5a 02 00 00 push $0x25a <== NOT EXECUTED 114834: eb df jmp 114815 <== NOT EXECUTED /* * If there is nothing to read, then quick exit. */ my_length = length; if ( !my_length ) 114836: 83 7d 18 00 cmpl $0x0,0x18(%ebp) 11483a: 75 13 jne 11484f rtems_set_errno_and_return_minus_one( EINVAL ); 11483c: e8 0f 14 00 00 call 115c50 <__errno> <== NOT EXECUTED 114841: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 114847: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 11484a: e9 d0 01 00 00 jmp 114a1f <== NOT EXECUTED /* * Linear files (as created from a tar file are easier to handle * than block files). */ if (the_jnode->type == IMFS_LINEAR_FILE) { 11484f: 83 f8 06 cmp $0x6,%eax 114852: 75 64 jne 1148b8 unsigned char *file_ptr; file_ptr = (unsigned char *)the_jnode->info.linearfile.direct; 114854: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 114857: 8b 49 58 mov 0x58(%ecx),%ecx <== NOT EXECUTED 11485a: 89 4d c8 mov %ecx,-0x38(%ebp) <== NOT EXECUTED if (my_length > (the_jnode->info.linearfile.size - start)) 11485d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 114860: 8b 48 50 mov 0x50(%eax),%ecx <== NOT EXECUTED 114863: 8b 58 54 mov 0x54(%eax),%ebx <== NOT EXECUTED 114866: 89 c8 mov %ecx,%eax <== NOT EXECUTED 114868: 89 da mov %ebx,%edx <== NOT EXECUTED 11486a: 29 f0 sub %esi,%eax <== NOT EXECUTED 11486c: 19 fa sbb %edi,%edx <== NOT EXECUTED 11486e: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 114871: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED 114874: 31 c0 xor %eax,%eax <== NOT EXECUTED 114876: 39 d0 cmp %edx,%eax <== NOT EXECUTED 114878: 7f 0f jg 114889 <== NOT EXECUTED 11487a: 7c 08 jl 114884 <== NOT EXECUTED 11487c: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 11487f: 39 55 18 cmp %edx,0x18(%ebp) <== NOT EXECUTED 114882: 77 05 ja 114889 <== NOT EXECUTED 114884: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 114887: eb 04 jmp 11488d <== NOT EXECUTED my_length = the_jnode->info.linearfile.size - start; 114889: 89 ca mov %ecx,%edx <== NOT EXECUTED 11488b: 29 f2 sub %esi,%edx <== NOT EXECUTED memcpy(dest, &file_ptr[start], my_length); 11488d: 03 75 c8 add -0x38(%ebp),%esi <== NOT EXECUTED 114890: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 114893: 89 d1 mov %edx,%ecx <== NOT EXECUTED 114895: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED IMFS_update_atime( the_jnode ); 114897: 51 push %ecx <== NOT EXECUTED 114898: 51 push %ecx <== NOT EXECUTED 114899: 6a 00 push $0x0 <== NOT EXECUTED 11489b: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 11489e: 50 push %eax <== NOT EXECUTED 11489f: 89 55 c0 mov %edx,-0x40(%ebp) <== NOT EXECUTED 1148a2: e8 bd 3a ff ff call 108364 <== NOT EXECUTED 1148a7: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 1148aa: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1148ad: 89 41 40 mov %eax,0x40(%ecx) <== NOT EXECUTED return my_length; 1148b0: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED 1148b3: e9 64 01 00 00 jmp 114a1c <== 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; 1148b8: 89 f0 mov %esi,%eax if ( last_byte > the_jnode->info.file.size ) 1148ba: 8b 55 08 mov 0x8(%ebp),%edx 1148bd: 8b 5a 50 mov 0x50(%edx),%ebx 1148c0: 8b 4d 18 mov 0x18(%ebp),%ecx 1148c3: 01 f1 add %esi,%ecx 1148c5: 89 4d d0 mov %ecx,-0x30(%ebp) 1148c8: 31 c9 xor %ecx,%ecx 1148ca: 3b 4a 54 cmp 0x54(%edx),%ecx 1148cd: 7f 0f jg 1148de 1148cf: 7c 05 jl 1148d6 1148d1: 39 5d d0 cmp %ebx,-0x30(%ebp) 1148d4: 77 08 ja 1148de 1148d6: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 1148d9: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 1148dc: eb 05 jmp 1148e3 <== NOT EXECUTED my_length = the_jnode->info.file.size - start; 1148de: 29 c3 sub %eax,%ebx 1148e0: 89 5d d0 mov %ebx,-0x30(%ebp) /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 1148e3: 8b 15 b8 8d 12 00 mov 0x128db8,%edx 1148e9: 89 55 c4 mov %edx,-0x3c(%ebp) 1148ec: 89 d0 mov %edx,%eax 1148ee: 99 cltd 1148ef: 89 d3 mov %edx,%ebx 1148f1: 52 push %edx 1148f2: 50 push %eax 1148f3: 57 push %edi 1148f4: 56 push %esi 1148f5: 89 45 c0 mov %eax,-0x40(%ebp) 1148f8: e8 df c4 00 00 call 120ddc <__moddi3> 1148fd: 83 c4 10 add $0x10,%esp 114900: 89 45 c8 mov %eax,-0x38(%ebp) block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 114903: 8b 4d c0 mov -0x40(%ebp),%ecx 114906: 53 push %ebx 114907: 51 push %ecx 114908: 57 push %edi 114909: 56 push %esi 11490a: e8 7d c3 00 00 call 120c8c <__divdi3> 11490f: 83 c4 10 add $0x10,%esp 114912: 89 c3 mov %eax,%ebx if ( start_offset ) { 114914: 83 7d c8 00 cmpl $0x0,-0x38(%ebp) 114918: 75 0f jne 114929 11491a: 8b 55 14 mov 0x14(%ebp),%edx 11491d: 89 55 c8 mov %edx,-0x38(%ebp) 114920: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) 114927: eb 4c jmp 114975 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 ); 114929: 50 push %eax 11492a: 6a 00 push $0x0 11492c: 53 push %ebx 11492d: ff 75 08 pushl 0x8(%ebp) 114930: e8 65 f5 ff ff call 113e9a assert( block_ptr ); 114935: 83 c4 10 add $0x10,%esp 114938: 85 c0 test %eax,%eax 11493a: 75 14 jne 114950 11493c: 68 74 39 12 00 push $0x123974 <== NOT EXECUTED 114941: 68 34 3a 12 00 push $0x123a34 <== NOT EXECUTED 114946: 68 96 02 00 00 push $0x296 <== NOT EXECUTED 11494b: e9 c5 fe ff ff jmp 114815 <== 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; 114950: 8b 4d c4 mov -0x3c(%ebp),%ecx 114953: 2b 4d c8 sub -0x38(%ebp),%ecx 114956: 8b 55 d0 mov -0x30(%ebp),%edx 114959: 39 ca cmp %ecx,%edx 11495b: 76 02 jbe 11495f 11495d: 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 ); 11495f: 8b 75 c8 mov -0x38(%ebp),%esi 114962: 03 30 add (%eax),%esi dest += to_copy; 114964: 8b 7d 14 mov 0x14(%ebp),%edi 114967: 89 d1 mov %edx,%ecx 114969: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 11496b: 89 7d c8 mov %edi,-0x38(%ebp) block++; 11496e: 43 inc %ebx my_length -= to_copy; 11496f: 29 55 d0 sub %edx,-0x30(%ebp) 114972: 89 55 cc mov %edx,-0x34(%ebp) /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 114975: 8b 15 b8 8d 12 00 mov 0x128db8,%edx while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 11497b: eb 40 jmp 1149bd block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 11497d: 57 push %edi 11497e: 6a 00 push $0x0 114980: 53 push %ebx 114981: ff 75 08 pushl 0x8(%ebp) 114984: 89 55 c0 mov %edx,-0x40(%ebp) 114987: e8 0e f5 ff ff call 113e9a assert( block_ptr ); 11498c: 83 c4 10 add $0x10,%esp 11498f: 85 c0 test %eax,%eax 114991: 8b 55 c0 mov -0x40(%ebp),%edx 114994: 75 14 jne 1149aa 114996: 68 74 39 12 00 push $0x123974 <== NOT EXECUTED 11499b: 68 34 3a 12 00 push $0x123a34 <== NOT EXECUTED 1149a0: 68 a7 02 00 00 push $0x2a7 <== NOT EXECUTED 1149a5: e9 6b fe ff ff jmp 114815 <== NOT EXECUTED if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); 1149aa: 8b 30 mov (%eax),%esi 1149ac: 8b 7d c8 mov -0x38(%ebp),%edi 1149af: 89 d1 mov %edx,%ecx 1149b1: f3 a4 rep movsb %ds:(%esi),%es:(%edi) dest += to_copy; 1149b3: 89 7d c8 mov %edi,-0x38(%ebp) block++; 1149b6: 43 inc %ebx my_length -= to_copy; 1149b7: 29 55 d0 sub %edx,-0x30(%ebp) copied += to_copy; 1149ba: 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 ) { 1149bd: 8b 45 d0 mov -0x30(%ebp),%eax 1149c0: 3b 05 b8 8d 12 00 cmp 0x128db8,%eax 1149c6: 73 b5 jae 11497d * Phase 3: possibly the first part of one block */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { 1149c8: 85 c0 test %eax,%eax 1149ca: 74 37 je 114a03 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 1149cc: 56 push %esi 1149cd: 6a 00 push $0x0 1149cf: 53 push %ebx 1149d0: ff 75 08 pushl 0x8(%ebp) 1149d3: e8 c2 f4 ff ff call 113e9a assert( block_ptr ); 1149d8: 83 c4 10 add $0x10,%esp 1149db: 85 c0 test %eax,%eax 1149dd: 75 14 jne 1149f3 1149df: 68 74 39 12 00 push $0x123974 <== NOT EXECUTED 1149e4: 68 34 3a 12 00 push $0x123a34 <== NOT EXECUTED 1149e9: 68 b9 02 00 00 push $0x2b9 <== NOT EXECUTED 1149ee: e9 22 fe ff ff jmp 114815 <== NOT EXECUTED if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); 1149f3: 8b 30 mov (%eax),%esi 1149f5: 8b 7d c8 mov -0x38(%ebp),%edi 1149f8: 8b 4d d0 mov -0x30(%ebp),%ecx 1149fb: f3 a4 rep movsb %ds:(%esi),%es:(%edi) copied += my_length; 1149fd: 8b 55 d0 mov -0x30(%ebp),%edx 114a00: 01 55 cc add %edx,-0x34(%ebp) } IMFS_update_atime( the_jnode ); 114a03: 53 push %ebx 114a04: 53 push %ebx 114a05: 6a 00 push $0x0 114a07: 8d 45 e0 lea -0x20(%ebp),%eax 114a0a: 50 push %eax 114a0b: e8 54 39 ff ff call 108364 114a10: 8b 45 e0 mov -0x20(%ebp),%eax 114a13: 8b 4d 08 mov 0x8(%ebp),%ecx 114a16: 89 41 40 mov %eax,0x40(%ecx) return copied; 114a19: 8b 55 cc mov -0x34(%ebp),%edx 114a1c: 83 c4 10 add $0x10,%esp } 114a1f: 89 d0 mov %edx,%eax 114a21: 8d 65 f4 lea -0xc(%ebp),%esp 114a24: 5b pop %ebx 114a25: 5e pop %esi 114a26: 5f pop %edi 114a27: c9 leave 114a28: c3 ret 001140d6 : */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) { 1140d6: 55 push %ebp 1140d7: 89 e5 mov %esp,%ebp 1140d9: 57 push %edi 1140da: 56 push %esi 1140db: 53 push %ebx 1140dc: 83 ec 1c sub $0x1c,%esp 1140df: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Perform internal consistency checks */ assert( the_jnode ); 1140e2: 85 db test %ebx,%ebx 1140e4: 75 11 jne 1140f7 1140e6: 68 f4 38 12 00 push $0x1238f4 <== NOT EXECUTED 1140eb: 68 48 3a 12 00 push $0x123a48 <== NOT EXECUTED 1140f0: 68 ee 01 00 00 push $0x1ee <== NOT EXECUTED 1140f5: eb 15 jmp 11410c <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 1140f7: 83 7b 4c 05 cmpl $0x5,0x4c(%ebx) 1140fb: 74 19 je 114116 1140fd: 68 44 39 12 00 push $0x123944 <== NOT EXECUTED 114102: 68 48 3a 12 00 push $0x123a48 <== NOT EXECUTED 114107: 68 f2 01 00 00 push $0x1f2 <== NOT EXECUTED 11410c: 68 fe 38 12 00 push $0x1238fe <== NOT EXECUTED 114111: e8 aa 3e 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; 114116: 8b 35 b8 8d 12 00 mov 0x128db8,%esi 11411c: c1 ee 02 shr $0x2,%esi * + indirect * + doubly indirect * + triply indirect */ info = &the_jnode->info.file; 11411f: 83 7b 58 00 cmpl $0x0,0x58(%ebx) 114123: 74 0f je 114134 if ( info->indirect ) { memfile_free_blocks_in_table( &info->indirect, to_free ); 114125: 57 push %edi 114126: 57 push %edi 114127: 56 push %esi 114128: 8d 43 58 lea 0x58(%ebx),%eax 11412b: 50 push %eax 11412c: e8 f0 fe ff ff call 114021 114131: 83 c4 10 add $0x10,%esp * + indirect * + doubly indirect * + triply indirect */ info = &the_jnode->info.file; 114134: 31 ff xor %edi,%edi 114136: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx) 11413a: 75 21 jne 11415d 11413c: eb 3a jmp 114178 } if ( info->doubly_indirect ) { for ( i=0 ; idoubly_indirect[i] ) { 11413e: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED 114141: 8d 14 bd 00 00 00 00 lea 0x0(,%edi,4),%edx <== NOT EXECUTED 114148: 83 3c b8 00 cmpl $0x0,(%eax,%edi,4) <== NOT EXECUTED 11414c: 74 0e je 11415c <== NOT EXECUTED memfile_free_blocks_in_table( 11414e: 51 push %ecx <== NOT EXECUTED 11414f: 51 push %ecx <== NOT EXECUTED 114150: 56 push %esi <== NOT EXECUTED 114151: 01 d0 add %edx,%eax <== NOT EXECUTED 114153: 50 push %eax <== NOT EXECUTED 114154: e8 c8 fe ff ff call 114021 <== NOT EXECUTED 114159: 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 ); 114169: 57 push %edi <== NOT EXECUTED 11416a: 57 push %edi <== NOT EXECUTED 11416b: 56 push %esi <== NOT EXECUTED 11416c: 8d 43 5c lea 0x5c(%ebx),%eax <== NOT EXECUTED 11416f: 50 push %eax <== NOT EXECUTED 114170: e8 ac fe ff ff call 114021 <== NOT EXECUTED 114175: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * + indirect * + doubly indirect * + triply indirect */ info = &the_jnode->info.file; 114178: 31 ff xor %edi,%edi 11417a: 83 7b 60 00 cmpl $0x0,0x60(%ebx) 11417e: 75 5b jne 1141db 114180: eb 74 jmp 1141f6 114182: 8d 04 bd 00 00 00 00 lea 0x0(,%edi,4),%eax <== NOT EXECUTED 114189: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED } if ( info->triply_indirect ) { for ( i=0 ; itriply_indirect[i]; 11418c: 8b 43 60 mov 0x60(%ebx),%eax <== NOT EXECUTED 11418f: 8b 04 b8 mov (%eax,%edi,4),%eax <== NOT EXECUTED if ( !p ) /* ensure we have a valid pointer */ 114192: 85 c0 test %eax,%eax <== NOT EXECUTED 114194: 74 51 je 1141e7 <== NOT EXECUTED 114196: 31 d2 xor %edx,%edx <== NOT EXECUTED 114198: eb 21 jmp 1141bb <== NOT EXECUTED break; for ( j=0 ; j <== NOT EXECUTED memfile_free_blocks_in_table( (block_p **)&p[j], to_free); 11419f: 51 push %ecx <== NOT EXECUTED 1141a0: 51 push %ecx <== NOT EXECUTED 1141a1: 56 push %esi <== NOT EXECUTED 1141a2: 50 push %eax <== NOT EXECUTED 1141a3: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 1141a6: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED 1141a9: e8 73 fe ff ff call 114021 <== NOT EXECUTED 1141ae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1141b1: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 1141b4: 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( 1141c8: 52 push %edx <== NOT EXECUTED 1141c9: 52 push %edx <== NOT EXECUTED 1141ca: 56 push %esi <== NOT EXECUTED 1141cb: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 1141ce: 03 43 60 add 0x60(%ebx),%eax <== NOT EXECUTED 1141d1: 50 push %eax <== NOT EXECUTED 1141d2: e8 4a fe ff ff call 114021 <== 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( 1141e7: 50 push %eax <== NOT EXECUTED 1141e8: 50 push %eax <== NOT EXECUTED 1141e9: 56 push %esi <== NOT EXECUTED 1141ea: 83 c3 60 add $0x60,%ebx <== NOT EXECUTED 1141ed: 53 push %ebx <== NOT EXECUTED 1141ee: e8 2e fe ff ff call 114021 <== NOT EXECUTED 1141f3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (block_p **)&info->triply_indirect, to_free ); } return 0; } 1141f6: 31 c0 xor %eax,%eax 1141f8: 8d 65 f4 lea -0xc(%ebp),%esp 1141fb: 5b pop %ebx 1141fc: 5e pop %esi 1141fd: 5f pop %edi 1141fe: c9 leave 1141ff: c3 ret 0011408b : MEMFILE_STATIC int IMFS_memfile_remove_block( IMFS_jnode_t *the_jnode, unsigned int block ) { 11408b: 55 push %ebp <== NOT EXECUTED 11408c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11408e: 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 ); 114091: 6a 00 push $0x0 <== NOT EXECUTED 114093: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 114096: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114099: e8 fc fd ff ff call 113e9a <== NOT EXECUTED assert( block_ptr ); 11409e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1140a1: 85 c0 test %eax,%eax <== NOT EXECUTED 1140a3: 75 19 jne 1140be <== NOT EXECUTED 1140a5: 68 74 39 12 00 push $0x123974 <== NOT EXECUTED 1140aa: 68 7c 3a 12 00 push $0x123a7c <== NOT EXECUTED 1140af: 68 96 01 00 00 push $0x196 <== NOT EXECUTED 1140b4: 68 fe 38 12 00 push $0x1238fe <== NOT EXECUTED 1140b9: e8 02 3f ff ff call 107fc0 <__assert_func> <== NOT EXECUTED if ( block_ptr ) { ptr = *block_ptr; 1140be: 8b 10 mov (%eax),%edx <== NOT EXECUTED *block_ptr = 0; 1140c0: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED memfile_free_block( ptr ); 1140c6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1140c9: 52 push %edx <== NOT EXECUTED 1140ca: e8 90 fd ff ff call 113e5f <== NOT EXECUTED } return 1; } 1140cf: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 1140d4: c9 leave <== NOT EXECUTED 1140d5: c3 ret <== NOT EXECUTED 0011451e : IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 11451e: 55 push %ebp 11451f: 89 e5 mov %esp,%ebp 114521: 57 push %edi 114522: 56 push %esi 114523: 53 push %ebx 114524: 83 ec 3c sub $0x3c,%esp 114527: 8b 75 0c mov 0xc(%ebp),%esi 11452a: 8b 7d 10 mov 0x10(%ebp),%edi /* * Perform internal consistency checks */ assert( the_jnode ); 11452d: 83 7d 08 00 cmpl $0x0,0x8(%ebp) 114531: 75 11 jne 114544 114533: 68 f4 38 12 00 push $0x1238f4 <== NOT EXECUTED 114538: 68 20 3a 12 00 push $0x123a20 <== NOT EXECUTED 11453d: 68 e3 02 00 00 push $0x2e3 <== NOT EXECUTED 114542: eb 18 jmp 11455c <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 114544: 8b 45 08 mov 0x8(%ebp),%eax 114547: 83 78 4c 05 cmpl $0x5,0x4c(%eax) 11454b: 74 19 je 114566 11454d: 68 44 39 12 00 push $0x123944 <== NOT EXECUTED 114552: 68 20 3a 12 00 push $0x123a20 <== NOT EXECUTED 114557: 68 e7 02 00 00 push $0x2e7 <== NOT EXECUTED 11455c: 68 fe 38 12 00 push $0x1238fe <== NOT EXECUTED 114561: e8 5a 3a ff ff call 107fc0 <__assert_func> <== NOT EXECUTED /* * Error check arguments */ assert( source ); 114566: 83 7d 14 00 cmpl $0x0,0x14(%ebp) 11456a: 75 11 jne 11457d 11456c: 68 7e 39 12 00 push $0x12397e <== NOT EXECUTED 114571: 68 20 3a 12 00 push $0x123a20 <== NOT EXECUTED 114576: 68 ef 02 00 00 push $0x2ef <== NOT EXECUTED 11457b: eb df jmp 11455c <== NOT EXECUTED /* * If there is nothing to write, then quick exit. */ my_length = length; if ( !my_length ) 11457d: 83 7d 18 00 cmpl $0x0,0x18(%ebp) 114581: 75 0d jne 114590 rtems_set_errno_and_return_minus_one( EINVAL ); 114583: e8 c8 16 00 00 call 115c50 <__errno> <== NOT EXECUTED 114588: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11458e: eb 33 jmp 1145c3 <== 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 ) { 114590: 8b 45 18 mov 0x18(%ebp),%eax 114593: 01 f0 add %esi,%eax 114595: 31 d2 xor %edx,%edx 114597: 8b 4d 08 mov 0x8(%ebp),%ecx 11459a: 3b 51 54 cmp 0x54(%ecx),%edx 11459d: 7c 2c jl 1145cb 11459f: 7f 05 jg 1145a6 1145a1: 3b 41 50 cmp 0x50(%ecx),%eax 1145a4: 76 25 jbe 1145cb status = IMFS_memfile_extend( the_jnode, last_byte ); 1145a6: 51 push %ecx 1145a7: 52 push %edx 1145a8: 50 push %eax 1145a9: ff 75 08 pushl 0x8(%ebp) 1145ac: e8 8a fd ff ff call 11433b if ( status ) 1145b1: 83 c4 10 add $0x10,%esp 1145b4: 85 c0 test %eax,%eax 1145b6: 74 13 je 1145cb rtems_set_errno_and_return_minus_one( ENOSPC ); 1145b8: e8 93 16 00 00 call 115c50 <__errno> <== NOT EXECUTED 1145bd: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 1145c3: 83 cb ff or $0xffffffff,%ebx <== NOT EXECUTED 1145c6: e9 3b 01 00 00 jmp 114706 <== NOT EXECUTED /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 1145cb: a1 b8 8d 12 00 mov 0x128db8,%eax 1145d0: 89 45 c8 mov %eax,-0x38(%ebp) 1145d3: 99 cltd 1145d4: 89 d3 mov %edx,%ebx 1145d6: 52 push %edx 1145d7: 50 push %eax 1145d8: 57 push %edi 1145d9: 56 push %esi 1145da: 89 45 c4 mov %eax,-0x3c(%ebp) 1145dd: e8 fa c7 00 00 call 120ddc <__moddi3> 1145e2: 83 c4 10 add $0x10,%esp 1145e5: 89 45 cc mov %eax,-0x34(%ebp) block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 1145e8: 8b 4d c4 mov -0x3c(%ebp),%ecx 1145eb: 53 push %ebx 1145ec: 51 push %ecx 1145ed: 57 push %edi 1145ee: 56 push %esi 1145ef: e8 98 c6 00 00 call 120c8c <__divdi3> 1145f4: 83 c4 10 add $0x10,%esp 1145f7: 89 45 d0 mov %eax,-0x30(%ebp) if ( start_offset ) { 1145fa: 83 7d cc 00 cmpl $0x0,-0x34(%ebp) 1145fe: 75 0d jne 11460d 114600: 8b 75 14 mov 0x14(%ebp),%esi 114603: 8b 55 18 mov 0x18(%ebp),%edx 114606: 89 55 d4 mov %edx,-0x2c(%ebp) 114609: 31 db xor %ebx,%ebx 11460b: eb 52 jmp 11465f 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 ); 11460d: 50 push %eax 11460e: 6a 00 push $0x0 114610: ff 75 d0 pushl -0x30(%ebp) 114613: ff 75 08 pushl 0x8(%ebp) 114616: e8 7f f8 ff ff call 113e9a assert( block_ptr ); 11461b: 83 c4 10 add $0x10,%esp 11461e: 85 c0 test %eax,%eax 114620: 75 14 jne 114636 114622: 68 74 39 12 00 push $0x123974 <== NOT EXECUTED 114627: 68 20 3a 12 00 push $0x123a20 <== NOT EXECUTED 11462c: 68 1c 03 00 00 push $0x31c <== NOT EXECUTED 114631: e9 26 ff ff ff jmp 11455c <== 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; 114636: 8b 55 c8 mov -0x38(%ebp),%edx 114639: 2b 55 cc sub -0x34(%ebp),%edx 11463c: 3b 55 18 cmp 0x18(%ebp),%edx 11463f: 76 03 jbe 114644 114641: 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 ); 114644: 8b 00 mov (%eax),%eax 114646: 03 45 cc add -0x34(%ebp),%eax src += to_copy; 114649: 89 c7 mov %eax,%edi 11464b: 8b 75 14 mov 0x14(%ebp),%esi 11464e: 89 d1 mov %edx,%ecx 114650: f3 a4 rep movsb %ds:(%esi),%es:(%edi) block++; 114652: ff 45 d0 incl -0x30(%ebp) my_length -= to_copy; 114655: 8b 4d 18 mov 0x18(%ebp),%ecx 114658: 29 d1 sub %edx,%ecx 11465a: 89 4d d4 mov %ecx,-0x2c(%ebp) copied += to_copy; 11465d: 89 d3 mov %edx,%ebx /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; 11465f: 8b 15 b8 8d 12 00 mov 0x128db8,%edx while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 114665: eb 3f jmp 1146a6 block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 114667: 57 push %edi 114668: 6a 00 push $0x0 11466a: ff 75 d0 pushl -0x30(%ebp) 11466d: ff 75 08 pushl 0x8(%ebp) 114670: 89 55 c4 mov %edx,-0x3c(%ebp) 114673: e8 22 f8 ff ff call 113e9a assert( block_ptr ); 114678: 83 c4 10 add $0x10,%esp 11467b: 85 c0 test %eax,%eax 11467d: 8b 55 c4 mov -0x3c(%ebp),%edx 114680: 75 14 jne 114696 114682: 68 74 39 12 00 push $0x123974 <== NOT EXECUTED 114687: 68 20 3a 12 00 push $0x123a20 <== NOT EXECUTED 11468c: 68 30 03 00 00 push $0x330 <== NOT EXECUTED 114691: e9 c6 fe ff ff jmp 11455c <== 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 ); 114696: 8b 00 mov (%eax),%eax src += to_copy; 114698: 89 c7 mov %eax,%edi 11469a: 89 d1 mov %edx,%ecx 11469c: f3 a4 rep movsb %ds:(%esi),%es:(%edi) block++; 11469e: ff 45 d0 incl -0x30(%ebp) my_length -= to_copy; 1146a1: 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( 1146a4: 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 ) { 1146a6: 8b 45 d4 mov -0x2c(%ebp),%eax 1146a9: 3b 05 b8 8d 12 00 cmp 0x128db8,%eax 1146af: 73 b6 jae 114667 */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); to_copy = my_length; if ( my_length ) { 1146b1: 85 c0 test %eax,%eax 1146b3: 74 35 je 1146ea block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 1146b5: 51 push %ecx 1146b6: 6a 00 push $0x0 1146b8: ff 75 d0 pushl -0x30(%ebp) 1146bb: ff 75 08 pushl 0x8(%ebp) 1146be: e8 d7 f7 ff ff call 113e9a assert( block_ptr ); 1146c3: 83 c4 10 add $0x10,%esp 1146c6: 85 c0 test %eax,%eax 1146c8: 75 14 jne 1146de 1146ca: 68 74 39 12 00 push $0x123974 <== NOT EXECUTED 1146cf: 68 20 3a 12 00 push $0x123a20 <== NOT EXECUTED 1146d4: 68 46 03 00 00 push $0x346 <== NOT EXECUTED 1146d9: e9 7e fe ff ff jmp 11455c <== 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 ); 1146de: 8b 00 mov (%eax),%eax 1146e0: 89 c7 mov %eax,%edi 1146e2: 8b 4d d4 mov -0x2c(%ebp),%ecx 1146e5: f3 a4 rep movsb %ds:(%esi),%es:(%edi) my_length = 0; copied += to_copy; 1146e7: 03 5d d4 add -0x2c(%ebp),%ebx } IMFS_mtime_ctime_update( the_jnode ); 1146ea: 52 push %edx 1146eb: 52 push %edx 1146ec: 6a 00 push $0x0 1146ee: 8d 45 e0 lea -0x20(%ebp),%eax 1146f1: 50 push %eax 1146f2: e8 6d 3c ff ff call 108364 1146f7: 8b 45 e0 mov -0x20(%ebp),%eax 1146fa: 8b 55 08 mov 0x8(%ebp),%edx 1146fd: 89 42 44 mov %eax,0x44(%edx) 114700: 89 42 48 mov %eax,0x48(%edx) return copied; 114703: 83 c4 10 add $0x10,%esp } 114706: 89 d8 mov %ebx,%eax 114708: 8d 65 f4 lea -0xc(%ebp),%esp 11470b: 5b pop %ebx 11470c: 5e pop %esi 11470d: 5f pop %edi 11470e: c9 leave 11470f: c3 ret 0010da40 : const char *token, /* IN */ mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10da40: 55 push %ebp 10da41: 89 e5 mov %esp,%ebp 10da43: 57 push %edi 10da44: 56 push %esi 10da45: 53 push %ebx 10da46: 83 ec 4c sub $0x4c,%esp 10da49: 8b 55 08 mov 0x8(%ebp),%edx 10da4c: 8b 5d 10 mov 0x10(%ebp),%ebx 10da4f: 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 ); 10da52: 31 c0 xor %eax,%eax 10da54: 83 c9 ff or $0xffffffff,%ecx 10da57: 89 d7 mov %edx,%edi 10da59: f2 ae repnz scas %es:(%edi),%al 10da5b: f7 d1 not %ecx 10da5d: 49 dec %ecx 10da5e: 8d 45 e4 lea -0x1c(%ebp),%eax 10da61: 50 push %eax 10da62: 8d 45 af lea -0x51(%ebp),%eax 10da65: 50 push %eax 10da66: 51 push %ecx 10da67: 52 push %edx 10da68: e8 7b fe ff ff call 10d8e8 /* * Figure out what type of IMFS node this is. */ if ( S_ISDIR(mode) ) 10da6d: 8b 45 0c mov 0xc(%ebp),%eax 10da70: 25 00 f0 00 00 and $0xf000,%eax 10da75: 83 c4 10 add $0x10,%esp 10da78: 3d 00 40 00 00 cmp $0x4000,%eax 10da7d: 74 40 je 10dabf type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) 10da7f: ba 05 00 00 00 mov $0x5,%edx 10da84: 3d 00 80 00 00 cmp $0x8000,%eax 10da89: 74 39 je 10dac4 type = IMFS_MEMORY_FILE; else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { 10da8b: 3d 00 20 00 00 cmp $0x2000,%eax 10da90: 74 07 je 10da99 10da92: 3d 00 60 00 00 cmp $0x6000,%eax 10da97: 75 0d jne 10daa6 type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor ); 10da99: 89 5d d0 mov %ebx,-0x30(%ebp) 10da9c: 89 75 d4 mov %esi,-0x2c(%ebp) 10da9f: ba 02 00 00 00 mov $0x2,%edx 10daa4: eb 1e jmp 10dac4 } else if (S_ISFIFO(mode)) 10daa6: ba 07 00 00 00 mov $0x7,%edx 10daab: 3d 00 10 00 00 cmp $0x1000,%eax 10dab0: 74 12 je 10dac4 type = IMFS_FIFO; else { rtems_set_errno_and_return_minus_one( EINVAL ); 10dab2: e8 9d 3a 00 00 call 111554 <__errno> <== NOT EXECUTED 10dab7: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10dabd: eb 32 jmp 10daf1 <== NOT EXECUTED 10dabf: 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( 10dac4: 83 ec 0c sub $0xc,%esp 10dac7: 8d 45 d0 lea -0x30(%ebp),%eax 10daca: 50 push %eax 10dacb: ff 75 0c pushl 0xc(%ebp) 10dace: 8d 45 af lea -0x51(%ebp),%eax 10dad1: 50 push %eax 10dad2: 52 push %edx 10dad3: ff 75 18 pushl 0x18(%ebp) 10dad6: e8 0b 26 00 00 call 1100e6 10dadb: 89 c2 mov %eax,%edx new_name, mode, &info ); if ( !new_node ) 10dadd: 83 c4 20 add $0x20,%esp 10dae0: 31 c0 xor %eax,%eax 10dae2: 85 d2 test %edx,%edx 10dae4: 75 0e jne 10daf4 rtems_set_errno_and_return_minus_one( ENOMEM ); 10dae6: e8 69 3a 00 00 call 111554 <__errno> <== NOT EXECUTED 10daeb: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10daf1: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED return 0; } 10daf4: 8d 65 f4 lea -0xc(%ebp),%esp 10daf7: 5b pop %ebx 10daf8: 5e pop %esi 10daf9: 5f pop %edi 10dafa: c9 leave 10dafb: 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 f5 df 00 00 call 115c50 <__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 e8 3b 12 00 push $0x123be8 <== NOT EXECUTED 108471: 68 9c 3d 12 00 push $0x123d9c <== 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 40 80 12 00 mov 0x128040,%eax 108484: ff 70 08 pushl 0x8(%eax) 108487: 8d 43 0c lea 0xc(%ebx),%eax 10848a: 50 push %eax 10848b: e8 40 cf 00 00 call 1153d0 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 40 80 12 00 mov 0x128040,%eax 1084a7: ff 24 95 6c 3d 12 00 jmp *0x123d6c(,%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 2a ce 00 00 call 1152e4 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 3b 3c 12 00 push $0x123c3b 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 4e 3c 12 00 push $0x123c4e <== 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 5d 3c 12 00 push $0x123c5d 1084df: ff 70 08 pushl 0x8(%eax) 1084e2: e8 c1 cd 00 00 call 1152a8 (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 f9 3e 12 00 movl $0x123ef9,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 16 e7 00 00 jmp 116c10 (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 69 3c 12 00 push $0x123c69 <== NOT EXECUTED 108504: e8 c7 ce 00 00 call 1153d0 <== NOT EXECUTED assert(0); 108509: 68 38 34 12 00 push $0x123438 <== NOT EXECUTED 10850e: 68 9c 3d 12 00 push $0x123d9c <== NOT EXECUTED 108513: 6a 5d push $0x5d <== NOT EXECUTED 108515: 68 f2 3b 12 00 push $0x123bf2 <== 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 69 3c 12 00 push $0x123c69 <== NOT EXECUTED 108529: e8 a2 ce 00 00 call 1153d0 <== NOT EXECUTED assert(0); 10852e: 68 38 34 12 00 push $0x123438 <== NOT EXECUTED 108533: 68 9c 3d 12 00 push $0x123d9c <== 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 7d 3c 12 00 push $0x123c7d <== NOT EXECUTED 108546: e8 85 ce 00 00 call 1153d0 <== NOT EXECUTED assert(0); 10854b: 68 38 34 12 00 push $0x123438 <== NOT EXECUTED 108550: 68 9c 3d 12 00 push $0x123d9c <== 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 90 3c 12 00 push $0x123c90 <== NOT EXECUTED 108560: a1 40 80 12 00 mov 0x128040,%eax <== NOT EXECUTED 108565: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 108568: e8 3b cd 00 00 call 1152a8 <== NOT EXECUTED assert(0); 10856d: 68 38 34 12 00 push $0x123438 <== NOT EXECUTED 108572: 68 9c 3d 12 00 push $0x123d9c <== 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 b3 df 00 00 call 115c50 <__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 fe eb 00 00 call 1168d8 <== 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 04 41 00 00 call 10bdf0 <_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 c9 40 00 00 call 10bdcc <_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 0010db0c : int IMFS_rmnod( rtems_filesystem_location_info_t *parent_pathloc, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN */ ) { 10db0c: 55 push %ebp 10db0d: 89 e5 mov %esp,%ebp 10db0f: 56 push %esi 10db10: 53 push %ebx 10db11: 83 ec 10 sub $0x10,%esp 10db14: 8b 75 0c mov 0xc(%ebp),%esi IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 10db17: 8b 1e mov (%esi),%ebx /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 10db19: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 10db1d: 74 13 je 10db32 */ RTEMS_INLINE_ROUTINE void rtems_chain_extract( rtems_chain_node *the_node ) { _Chain_Extract( the_node ); 10db1f: 83 ec 0c sub $0xc,%esp 10db22: 53 push %ebx 10db23: e8 10 11 00 00 call 10ec38 <_Chain_Extract> rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 10db28: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 10db2f: 83 c4 10 add $0x10,%esp /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 10db32: 66 ff 4b 34 decw 0x34(%ebx) IMFS_update_ctime( the_jnode ); 10db36: 50 push %eax 10db37: 50 push %eax 10db38: 6a 00 push $0x0 10db3a: 8d 45 f0 lea -0x10(%ebp),%eax 10db3d: 50 push %eax 10db3e: e8 8d 02 00 00 call 10ddd0 10db43: 8b 45 f0 mov -0x10(%ebp),%eax 10db46: 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) ) { 10db49: 89 1c 24 mov %ebx,(%esp) 10db4c: e8 31 03 00 00 call 10de82 10db51: 83 c4 10 add $0x10,%esp 10db54: 85 c0 test %eax,%eax 10db56: 75 3f jne 10db97 10db58: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) 10db5d: 75 38 jne 10db97 /* * Is rtems_filesystem_current this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 10db5f: a1 48 1f 12 00 mov 0x121f48,%eax 10db64: 8b 50 04 mov 0x4(%eax),%edx 10db67: 3b 16 cmp (%esi),%edx 10db69: 75 07 jne 10db72 rtems_filesystem_current.node_access = NULL; 10db6b: 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 ) { 10db72: 83 7b 4c 04 cmpl $0x4,0x4c(%ebx) 10db76: 75 13 jne 10db8b if ( the_jnode->info.sym_link.name ) 10db78: 8b 43 50 mov 0x50(%ebx),%eax 10db7b: 85 c0 test %eax,%eax 10db7d: 74 0c je 10db8b free( (void*) the_jnode->info.sym_link.name ); 10db7f: 83 ec 0c sub $0xc,%esp 10db82: 50 push %eax 10db83: e8 f8 95 ff ff call 107180 10db88: 83 c4 10 add $0x10,%esp } free( the_jnode ); 10db8b: 83 ec 0c sub $0xc,%esp 10db8e: 53 push %ebx 10db8f: e8 ec 95 ff ff call 107180 10db94: 83 c4 10 add $0x10,%esp } return 0; } 10db97: 31 c0 xor %eax,%eax 10db99: 8d 65 f8 lea -0x8(%ebp),%esp 10db9c: 5b pop %ebx 10db9d: 5e pop %esi 10db9e: c9 leave 10db9f: c3 ret 0010dba0 : int IMFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 10dba0: 55 push %ebp 10dba1: 89 e5 mov %esp,%ebp 10dba3: 53 push %ebx 10dba4: 83 ec 04 sub $0x4,%esp 10dba7: 8b 45 0c mov 0xc(%ebp),%eax IMFS_jnode_t *the_jnode; IMFS_device_t *io; the_jnode = loc->node_access; 10dbaa: 8b 55 08 mov 0x8(%ebp),%edx 10dbad: 8b 12 mov (%edx),%edx switch ( the_jnode->type ) { 10dbaf: 8b 4a 4c mov 0x4c(%edx),%ecx 10dbb2: 83 e9 02 sub $0x2,%ecx 10dbb5: 83 f9 05 cmp $0x5,%ecx 10dbb8: 77 33 ja 10dbed 10dbba: ff 24 8d e4 ec 11 00 jmp *0x11ece4(,%ecx,4) case IMFS_DEVICE: io = &the_jnode->info.device; buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor ); 10dbc1: 8b 4a 54 mov 0x54(%edx),%ecx rtems_device_minor_number _minor ) { union __rtems_dev_t temp; temp.__overlay.major = _major; 10dbc4: 8b 5a 50 mov 0x50(%edx),%ebx 10dbc7: 89 58 18 mov %ebx,0x18(%eax) 10dbca: 89 48 1c mov %ecx,0x1c(%eax) break; 10dbcd: eb 2e jmp 10dbfd case IMFS_LINEAR_FILE: case IMFS_MEMORY_FILE: buf->st_size = the_jnode->info.file.size; 10dbcf: 8b 4a 50 mov 0x50(%edx),%ecx 10dbd2: 8b 5a 54 mov 0x54(%edx),%ebx 10dbd5: 89 48 20 mov %ecx,0x20(%eax) 10dbd8: 89 58 24 mov %ebx,0x24(%eax) break; 10dbdb: eb 20 jmp 10dbfd case IMFS_SYM_LINK: buf->st_size = 0; break; case IMFS_FIFO: buf->st_size = 0; 10dbdd: c7 40 20 00 00 00 00 movl $0x0,0x20(%eax) <== NOT EXECUTED 10dbe4: c7 40 24 00 00 00 00 movl $0x0,0x24(%eax) <== NOT EXECUTED break; 10dbeb: eb 10 jmp 10dbfd <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 10dbed: e8 62 39 00 00 call 111554 <__errno> <== NOT EXECUTED 10dbf2: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10dbf8: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 10dbfb: eb 36 jmp 10dc33 <== NOT EXECUTED break; } buf->st_mode = the_jnode->st_mode; 10dbfd: 8b 4a 30 mov 0x30(%edx),%ecx 10dc00: 89 48 0c mov %ecx,0xc(%eax) buf->st_nlink = the_jnode->st_nlink; 10dc03: 8b 4a 34 mov 0x34(%edx),%ecx 10dc06: 66 89 48 10 mov %cx,0x10(%eax) buf->st_ino = the_jnode->st_ino; 10dc0a: 8b 4a 38 mov 0x38(%edx),%ecx 10dc0d: 89 48 08 mov %ecx,0x8(%eax) buf->st_uid = the_jnode->st_uid; 10dc10: 8b 4a 3c mov 0x3c(%edx),%ecx 10dc13: 66 89 48 12 mov %cx,0x12(%eax) buf->st_gid = the_jnode->st_gid; 10dc17: 66 8b 4a 3e mov 0x3e(%edx),%cx 10dc1b: 66 89 48 14 mov %cx,0x14(%eax) buf->st_atime = the_jnode->stat_atime; 10dc1f: 8b 4a 40 mov 0x40(%edx),%ecx 10dc22: 89 48 28 mov %ecx,0x28(%eax) buf->st_mtime = the_jnode->stat_mtime; 10dc25: 8b 4a 44 mov 0x44(%edx),%ecx 10dc28: 89 48 30 mov %ecx,0x30(%eax) buf->st_ctime = the_jnode->stat_ctime; 10dc2b: 8b 52 48 mov 0x48(%edx),%edx 10dc2e: 89 50 38 mov %edx,0x38(%eax) 10dc31: 31 c0 xor %eax,%eax return 0; } 10dc33: 5a pop %edx 10dc34: 5b pop %ebx 10dc35: c9 leave 10dc36: 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 ba 9f 00 00 call 111d00 /* * Duplicate link name */ info.sym_link.name = strdup(link_name); 107d46: 58 pop %eax 107d47: ff 75 0c pushl 0xc(%ebp) 107d4a: e8 2d ea 00 00 call 11677c 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 f2 de 00 00 call 115c50 <__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 7e 95 00 00 call 1112fe 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 b5 de 00 00 call 115c50 <__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 80 de 00 00 call 115c50 <__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 05 96 00 00 call 1113fc /* * 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 e1 dd 00 00 call 115c50 <__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 ce dd 00 00 call 115c50 <__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 25 12 00 mov 0x122510,%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 25 12 00 mov 0x122514,%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 25 12 00 00 cmpb $0x0,0x12250d 107345: 75 11 jne 107358 !rtems_unified_work_area && rtems_configuration_get_do_zero_of_workspace() 107347: 80 3d 20 02 12 00 00 cmpb $0x0,0x120220 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 25 12 00 00 cmpb $0x0,0x12250d 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 50 01 12 00 pushl 0x120150 10736b: e8 44 39 00 00 call 10acb4 <_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 bb 31 00 00 call 10a53c <== NOT EXECUTED } } MSBUMP( space_available, _Protected_heap_Get_size(RTEMS_Malloc_Heap) ); 107381: 8b 1d a8 40 12 00 mov 0x1240a8,%ebx 107387: 83 ec 0c sub $0xc,%esp 10738a: ff 35 50 01 12 00 pushl 0x120150 107390: e8 b7 43 00 00 call 10b74c <_Protected_heap_Get_size> 107395: 8d 1c 18 lea (%eax,%ebx,1),%ebx 107398: 89 1d a8 40 12 00 mov %ebx,0x1240a8 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 7c 23 16 00 mov 0x16237c,%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 2c 50 16 00 00 cmpl $0x0,0x16502c <== NOT EXECUTED 10a022: 0f 84 d8 00 00 00 je 10a100 <== NOT EXECUTED 10a028: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) <== NOT EXECUTED 10a02f: 31 db xor %ebx,%ebx <== NOT EXECUTED 10a031: be 28 50 16 00 mov $0x165028,%esi <== NOT EXECUTED 10a036: eb 0f jmp 10a047 <== NOT EXECUTED current = 0; } else return; } else { stack = &the_thread->Start.Initial_stack; 10a038: 8d b3 c4 00 00 00 lea 0xc4(%ebx),%esi <== NOT EXECUTED current = (void *)_CPU_Context_Get_SP( &the_thread->Registers ); 10a03e: 8b 8b d8 00 00 00 mov 0xd8(%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 40 20 15 00 push $0x152040 <== NOT EXECUTED 10a08e: ff 35 78 23 16 00 pushl 0x162378 <== 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 4d 20 15 00 push $0x15204d <== NOT EXECUTED 10a0a4: ff 35 78 23 16 00 pushl 0x162378 <== 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 5b 20 15 00 push $0x15205b <== NOT EXECUTED 10a0c8: ff 35 78 23 16 00 pushl 0x162378 <== NOT EXECUTED 10a0ce: ff 15 7c 23 16 00 call *0x16237c <== 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 74 23 16 00 00 cmpl $0x0,0x162374 <== NOT EXECUTED 10a0de: a1 7c 23 16 00 mov 0x16237c,%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 79 20 15 00 push $0x152079 <== 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 86 20 15 00 push $0x152086 <== NOT EXECUTED 10a0f5: ff 35 78 23 16 00 pushl 0x162378 <== 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 c8 00 00 00 mov 0xc8(%ebx),%esi <== NOT EXECUTED char name [32]; printk("BLOWN STACK!!!\n"); 10a194: 68 ed 20 15 00 push $0x1520ed <== 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 fd 20 15 00 push $0x1520fd <== 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 1a 21 15 00 push $0x15211a <== 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 2c 21 15 00 push $0x15212c <== 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 40 21 15 00 push $0x152140 <== 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 c8 00 00 00 mov 0xc8(%ebx),%ecx <== NOT EXECUTED 10a1f0: 8b 83 c4 00 00 00 mov 0xc4(%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 56 21 15 00 push $0x152156 <== 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 87 21 15 00 push $0x152187 <== 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 d8 57 00 00 call 10fa0c <== NOT EXECUTED 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 f4 00 00 00 mov 0xf4(%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 84 42 12 00 mov 0x124284,%ecx 109b90: 85 c9 test %ecx,%ecx 109b92: 74 49 je 109bdd <_Event_Surrender+0x81> 109b94: 3b 1d a8 42 12 00 cmp 0x1242a8,%ebx 109b9a: 75 41 jne 109bdd <_Event_Surrender+0x81> _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 109b9c: 8b 0d c4 4a 12 00 mov 0x124ac4,%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 c4 4a 12 00 mov 0x124ac4,%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 c4 4a 12 00 03 movl $0x3,0x124ac4 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 f2 2e 00 00 call 10cb18 <_Watchdog_Remove> 109c26: 58 pop %eax 109c27: 5a pop %edx 109c28: 68 f8 ff 03 10 push $0x1003fff8 109c2d: 53 push %ebx 109c2e: e8 91 1c 00 00 call 10b8c4 <_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 0010afa4 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, Internal_errors_t the_error ) { 10afa4: 55 push %ebp 10afa5: 89 e5 mov %esp,%ebp 10afa7: 53 push %ebx 10afa8: 83 ec 08 sub $0x8,%esp 10afab: 8b 45 08 mov 0x8(%ebp),%eax 10afae: 8b 55 0c mov 0xc(%ebp),%edx 10afb1: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10afb4: a3 90 42 12 00 mov %eax,0x124290 _Internal_errors_What_happened.is_internal = is_internal; 10afb9: 88 15 94 42 12 00 mov %dl,0x124294 _Internal_errors_What_happened.the_error = the_error; 10afbf: 89 1d 98 42 12 00 mov %ebx,0x124298 _User_extensions_Fatal( the_source, is_internal, the_error ); 10afc5: 53 push %ebx 10afc6: 0f b6 d2 movzbl %dl,%edx 10afc9: 52 push %edx 10afca: 50 push %eax 10afcb: e8 13 19 00 00 call 10c8e3 <_User_extensions_Fatal> RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 10afd0: c7 05 84 43 12 00 05 movl $0x5,0x124384 <== NOT EXECUTED 10afd7: 00 00 00 <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10afda: fa cli <== NOT EXECUTED 10afdb: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10afdd: f4 hlt <== NOT EXECUTED 10afde: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10afe1: eb fe jmp 10afe1 <_Internal_error_Occurred+0x3d> <== NOT EXECUTED 0010a08c <_POSIX_Timer_TSR>: * This is the operation that is run when a timer expires */ void _POSIX_Timer_TSR( Objects_Id timer __attribute__((unused)), void *data) { 10a08c: 55 push %ebp 10a08d: 89 e5 mov %esp,%ebp 10a08f: 53 push %ebx 10a090: 83 ec 04 sub $0x4,%esp 10a093: 8b 5d 0c mov 0xc(%ebp),%ebx bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 10a096: ff 43 68 incl 0x68(%ebx) /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10a099: 83 7b 54 00 cmpl $0x0,0x54(%ebx) 10a09d: 75 06 jne 10a0a5 <_POSIX_Timer_TSR+0x19> ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { 10a09f: 83 7b 58 00 cmpl $0x0,0x58(%ebx) 10a0a3: 74 34 je 10a0d9 <_POSIX_Timer_TSR+0x4d> activated = _POSIX_Timer_Insert_helper( 10a0a5: 83 ec 0c sub $0xc,%esp 10a0a8: 53 push %ebx 10a0a9: 68 8c a0 10 00 push $0x10a08c 10a0ae: ff 73 08 pushl 0x8(%ebx) 10a0b1: ff 73 64 pushl 0x64(%ebx) 10a0b4: 8d 43 10 lea 0x10(%ebx),%eax 10a0b7: 50 push %eax 10a0b8: e8 eb 50 00 00 call 10f1a8 <_POSIX_Timer_Insert_helper> ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 10a0bd: 83 c4 20 add $0x20,%esp 10a0c0: 84 c0 test %al,%al 10a0c2: 74 30 je 10a0f4 <_POSIX_Timer_TSR+0x68> return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 10a0c4: 83 ec 0c sub $0xc,%esp 10a0c7: 8d 43 6c lea 0x6c(%ebx),%eax 10a0ca: 50 push %eax 10a0cb: e8 34 14 00 00 call 10b504 <_TOD_Get> /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10a0d0: c6 43 3c 03 movb $0x3,0x3c(%ebx) /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10a0d4: 83 c4 10 add $0x10,%esp 10a0d7: eb 04 jmp 10a0dd <_POSIX_Timer_TSR+0x51> /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; } else { /* Indicates that the timer is stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10a0d9: c6 43 3c 04 movb $0x4,0x3c(%ebx) <== NOT EXECUTED /* * The sending of the signal to the process running the handling function * specified for that signal is simulated */ if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) { 10a0dd: 50 push %eax 10a0de: 50 push %eax 10a0df: ff 73 44 pushl 0x44(%ebx) 10a0e2: ff 73 38 pushl 0x38(%ebx) 10a0e5: e8 8e 4c 00 00 call 10ed78 } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 10a0ea: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) 10a0f1: 83 c4 10 add $0x10,%esp } 10a0f4: 8b 5d fc mov -0x4(%ebp),%ebx 10a0f7: c9 leave 10a0f8: c3 ret 0010c160 <_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 ) { 10c160: 55 push %ebp 10c161: 89 e5 mov %esp,%ebp 10c163: 57 push %edi 10c164: 56 push %esi 10c165: 53 push %ebx 10c166: 83 ec 10 sub $0x10,%esp 10c169: 8b 4d 08 mov 0x8(%ebp),%ecx 10c16c: 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); 10c16f: 8d 50 3c lea 0x3c(%eax),%edx 10c172: 89 50 38 mov %edx,0x38(%eax) the_chain->permanent_null = NULL; 10c175: c7 40 3c 00 00 00 00 movl $0x0,0x3c(%eax) the_chain->last = _Chain_Head(the_chain); 10c17c: 8d 50 38 lea 0x38(%eax),%edx 10c17f: 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; 10c182: 8b 58 14 mov 0x14(%eax),%ebx header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; 10c185: 89 de mov %ebx,%esi 10c187: c1 ee 06 shr $0x6,%esi 10c18a: 6b f6 0c imul $0xc,%esi,%esi 10c18d: 8d 34 31 lea (%ecx,%esi,1),%esi block_state = the_thread_queue->state; 10c190: 8b 79 38 mov 0x38(%ecx),%edi if ( _Thread_queue_Is_reverse_search( priority ) ) 10c193: f6 c3 20 test $0x20,%bl 10c196: 75 70 jne 10c208 <_Thread_queue_Enqueue_priority+0xa8> */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 10c198: 8d 56 04 lea 0x4(%esi),%edx 10c19b: 89 55 e8 mov %edx,-0x18(%ebp) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 10c19e: 9c pushf 10c19f: fa cli 10c1a0: 8f 45 f0 popl -0x10(%ebp) search_thread = (Thread_Control *) header->first; 10c1a3: 8b 16 mov (%esi),%edx 10c1a5: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp) 10c1ac: 89 75 e4 mov %esi,-0x1c(%ebp) while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c1af: eb 1f jmp 10c1d0 <_Thread_queue_Enqueue_priority+0x70> search_priority = search_thread->current_priority; 10c1b1: 8b 72 14 mov 0x14(%edx),%esi 10c1b4: 89 75 ec mov %esi,-0x14(%ebp) if ( priority <= search_priority ) 10c1b7: 39 f3 cmp %esi,%ebx 10c1b9: 76 1a jbe 10c1d5 <_Thread_queue_Enqueue_priority+0x75> break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10c1bb: ff 75 f0 pushl -0x10(%ebp) 10c1be: 9d popf 10c1bf: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c1c0: 85 7a 10 test %edi,0x10(%edx) 10c1c3: 75 09 jne 10c1ce <_Thread_queue_Enqueue_priority+0x6e> 10c1c5: 8b 75 e4 mov -0x1c(%ebp),%esi <== NOT EXECUTED _ISR_Enable( level ); 10c1c8: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10c1cb: 9d popf <== NOT EXECUTED goto restart_forward_search; 10c1cc: eb d0 jmp 10c19e <_Thread_queue_Enqueue_priority+0x3e> <== NOT EXECUTED } search_thread = (Thread_Control *)search_thread->Object.Node.next; 10c1ce: 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 ) ) { 10c1d0: 3b 55 e8 cmp -0x18(%ebp),%edx 10c1d3: 75 dc jne 10c1b1 <_Thread_queue_Enqueue_priority+0x51> 10c1d5: 8b 75 f0 mov -0x10(%ebp),%esi } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10c1d8: 83 79 30 01 cmpl $0x1,0x30(%ecx) 10c1dc: 0f 85 a9 00 00 00 jne 10c28b <_Thread_queue_Enqueue_priority+0x12b> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c1e2: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) if ( priority == search_priority ) 10c1e9: 3b 5d ec cmp -0x14(%ebp),%ebx 10c1ec: 0f 84 82 00 00 00 je 10c274 <_Thread_queue_Enqueue_priority+0x114> goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10c1f2: 8b 5a 04 mov 0x4(%edx),%ebx the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c1f5: 89 10 mov %edx,(%eax) the_node->previous = previous_node; 10c1f7: 89 58 04 mov %ebx,0x4(%eax) previous_node->next = the_node; 10c1fa: 89 03 mov %eax,(%ebx) search_node->previous = the_node; 10c1fc: 89 42 04 mov %eax,0x4(%edx) the_thread->Wait.queue = the_thread_queue; 10c1ff: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c202: ff 75 f0 pushl -0x10(%ebp) 10c205: 9d popf 10c206: eb 65 jmp 10c26d <_Thread_queue_Enqueue_priority+0x10d> return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 10c208: 0f b6 15 f4 01 12 00 movzbl 0x1201f4,%edx 10c20f: 42 inc %edx 10c210: 89 55 ec mov %edx,-0x14(%ebp) _ISR_Disable( level ); 10c213: 9c pushf 10c214: fa cli 10c215: 8f 45 f0 popl -0x10(%ebp) search_thread = (Thread_Control *) header->last; 10c218: 8b 56 08 mov 0x8(%esi),%edx 10c21b: 89 75 e8 mov %esi,-0x18(%ebp) while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c21e: eb 20 jmp 10c240 <_Thread_queue_Enqueue_priority+0xe0> search_priority = search_thread->current_priority; 10c220: 8b 72 14 mov 0x14(%edx),%esi 10c223: 89 75 ec mov %esi,-0x14(%ebp) if ( priority >= search_priority ) 10c226: 39 f3 cmp %esi,%ebx 10c228: 73 1b jae 10c245 <_Thread_queue_Enqueue_priority+0xe5> break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 10c22a: ff 75 f0 pushl -0x10(%ebp) 10c22d: 9d popf 10c22e: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c22f: 85 7a 10 test %edi,0x10(%edx) 10c232: 75 09 jne 10c23d <_Thread_queue_Enqueue_priority+0xdd> 10c234: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED _ISR_Enable( level ); 10c237: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10c23a: 9d popf <== NOT EXECUTED goto restart_reverse_search; 10c23b: eb cb jmp 10c208 <_Thread_queue_Enqueue_priority+0xa8> <== NOT EXECUTED } search_thread = (Thread_Control *) 10c23d: 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 ) ) { 10c240: 3b 55 e8 cmp -0x18(%ebp),%edx 10c243: 75 db jne 10c220 <_Thread_queue_Enqueue_priority+0xc0> 10c245: 8b 75 f0 mov -0x10(%ebp),%esi } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10c248: 83 79 30 01 cmpl $0x1,0x30(%ecx) 10c24c: 75 3d jne 10c28b <_Thread_queue_Enqueue_priority+0x12b> THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c24e: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) if ( priority == search_priority ) 10c255: 3b 5d ec cmp -0x14(%ebp),%ebx 10c258: 74 1a je 10c274 <_Thread_queue_Enqueue_priority+0x114> goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10c25a: 8b 1a mov (%edx),%ebx the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10c25c: 89 18 mov %ebx,(%eax) the_node->previous = search_node; 10c25e: 89 50 04 mov %edx,0x4(%eax) search_node->next = the_node; 10c261: 89 02 mov %eax,(%edx) next_node->previous = the_node; 10c263: 89 43 04 mov %eax,0x4(%ebx) the_thread->Wait.queue = the_thread_queue; 10c266: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c269: ff 75 f0 pushl -0x10(%ebp) 10c26c: 9d popf 10c26d: b8 01 00 00 00 mov $0x1,%eax return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10c272: eb 1f jmp 10c293 <_Thread_queue_Enqueue_priority+0x133> 10c274: 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; 10c277: 8b 5a 04 mov 0x4(%edx),%ebx the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c27a: 89 10 mov %edx,(%eax) the_node->previous = previous_node; 10c27c: 89 58 04 mov %ebx,0x4(%eax) previous_node->next = the_node; 10c27f: 89 03 mov %eax,(%ebx) search_node->previous = the_node; 10c281: 89 42 04 mov %eax,0x4(%edx) the_thread->Wait.queue = the_thread_queue; 10c284: 89 48 44 mov %ecx,0x44(%eax) _ISR_Enable( level ); 10c287: 56 push %esi 10c288: 9d popf 10c289: eb e2 jmp 10c26d <_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; 10c28b: 8b 45 10 mov 0x10(%ebp),%eax 10c28e: 89 30 mov %esi,(%eax) return the_thread_queue->sync_state; 10c290: 8b 41 30 mov 0x30(%ecx),%eax } 10c293: 83 c4 10 add $0x10,%esp 10c296: 5b pop %ebx 10c297: 5e pop %esi 10c298: 5f pop %edi 10c299: c9 leave 10c29a: c3 ret 001165c0 <_Timer_server_Body>: * @a arg points to the corresponding timer server control block. */ static rtems_task _Timer_server_Body( rtems_task_argument arg ) { 1165c0: 55 push %ebp 1165c1: 89 e5 mov %esp,%ebp 1165c3: 57 push %edi 1165c4: 56 push %esi 1165c5: 53 push %ebx 1165c6: 83 ec 4c sub $0x4c,%esp 1165c9: 8b 5d 08 mov 0x8(%ebp),%ebx 1165cc: 8d 45 dc lea -0x24(%ebp),%eax 1165cf: 8d 55 e0 lea -0x20(%ebp),%edx 1165d2: 89 55 b4 mov %edx,-0x4c(%ebp) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 1165d5: 89 55 dc mov %edx,-0x24(%ebp) the_chain->permanent_null = NULL; 1165d8: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) the_chain->last = _Chain_Head(the_chain); 1165df: 89 45 e4 mov %eax,-0x1c(%ebp) */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 1165e2: 8d 75 d0 lea -0x30(%ebp),%esi 1165e5: 8d 55 d4 lea -0x2c(%ebp),%edx 1165e8: 89 55 b0 mov %edx,-0x50(%ebp) */ RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty( Chain_Control *the_chain ) { the_chain->first = _Chain_Tail(the_chain); 1165eb: 89 55 d0 mov %edx,-0x30(%ebp) the_chain->permanent_null = NULL; 1165ee: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) the_chain->last = _Chain_Head(the_chain); 1165f5: 89 75 d8 mov %esi,-0x28(%ebp) */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; watchdogs->last_snapshot = snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1165f8: 8d 53 30 lea 0x30(%ebx),%edx 1165fb: 89 55 c0 mov %edx,-0x40(%ebp) /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ delta = snapshot - last_snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 1165fe: 8d 7b 68 lea 0x68(%ebx),%edi static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 116601: 8d 4b 08 lea 0x8(%ebx),%ecx 116604: 89 4d b8 mov %ecx,-0x48(%ebp) static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 116607: 8d 53 40 lea 0x40(%ebx),%edx 11660a: 89 55 bc mov %edx,-0x44(%ebp) { /* * Afterwards all timer inserts are directed to this chain and the interval * and TOD chains will be no more modified by other parties. */ ts->insert_chain = insert_chain; 11660d: 8d 4d dc lea -0x24(%ebp),%ecx 116610: 89 4b 78 mov %ecx,0x78(%ebx) static void _Timer_server_Process_interval_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot; 116613: a1 0c d7 13 00 mov 0x13d70c,%eax /* * We assume adequate unsigned arithmetic here. */ Watchdog_Interval delta = snapshot - watchdogs->last_snapshot; 116618: 8b 53 3c mov 0x3c(%ebx),%edx watchdogs->last_snapshot = snapshot; 11661b: 89 43 3c mov %eax,0x3c(%ebx) _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 11661e: 51 push %ecx 11661f: 8d 4d d0 lea -0x30(%ebp),%ecx 116622: 51 push %ecx 116623: 29 d0 sub %edx,%eax 116625: 50 push %eax 116626: ff 75 c0 pushl -0x40(%ebp) 116629: e8 ca 36 00 00 call 119cf8 <_Watchdog_Adjust_to_chain> static void _Timer_server_Process_tod_watchdogs( Timer_server_Watchdogs *watchdogs, Chain_Control *fire_chain ) { Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 11662e: a1 50 d6 13 00 mov 0x13d650,%eax 116633: 89 45 c4 mov %eax,-0x3c(%ebp) Watchdog_Interval last_snapshot = watchdogs->last_snapshot; 116636: 8b 43 74 mov 0x74(%ebx),%eax /* * Process the seconds chain. Start by checking that the Time * of Day (TOD) has not been set backwards. If it has then * we want to adjust the watchdogs->Chain to indicate this. */ if ( snapshot > last_snapshot ) { 116639: 83 c4 10 add $0x10,%esp 11663c: 39 45 c4 cmp %eax,-0x3c(%ebp) 11663f: 76 13 jbe 116654 <_Timer_server_Body+0x94> /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ delta = snapshot - last_snapshot; _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain ); 116641: 52 push %edx 116642: 8d 55 d0 lea -0x30(%ebp),%edx 116645: 52 push %edx 116646: 8b 4d c4 mov -0x3c(%ebp),%ecx 116649: 29 c1 sub %eax,%ecx 11664b: 51 push %ecx 11664c: 57 push %edi 11664d: e8 a6 36 00 00 call 119cf8 <_Watchdog_Adjust_to_chain> 116652: eb 0f jmp 116663 <_Timer_server_Body+0xa3> } else if ( snapshot < last_snapshot ) { 116654: 73 10 jae 116666 <_Timer_server_Body+0xa6> /* * The current TOD is before the last TOD which indicates that * TOD has been set backwards. */ delta = last_snapshot - snapshot; _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta ); 116656: 51 push %ecx 116657: 2b 45 c4 sub -0x3c(%ebp),%eax 11665a: 50 push %eax 11665b: 6a 01 push $0x1 11665d: 57 push %edi 11665e: e8 29 36 00 00 call 119c8c <_Watchdog_Adjust> 116663: 83 c4 10 add $0x10,%esp } watchdogs->last_snapshot = snapshot; 116666: 8b 45 c4 mov -0x3c(%ebp),%eax 116669: 89 43 74 mov %eax,0x74(%ebx) } static void _Timer_server_Process_insertions( Timer_server_Control *ts ) { while ( true ) { Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain ); 11666c: 8b 43 78 mov 0x78(%ebx),%eax 11666f: 83 ec 0c sub $0xc,%esp 116672: 50 push %eax 116673: e8 3c 07 00 00 call 116db4 <_Chain_Get> if ( timer == NULL ) { 116678: 83 c4 10 add $0x10,%esp 11667b: 85 c0 test %eax,%eax 11667d: 74 29 je 1166a8 <_Timer_server_Body+0xe8> static void _Timer_server_Insert_timer( Timer_server_Control *ts, Timer_Control *timer ) { if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 11667f: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 116682: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 116685: 75 0b jne 116692 <_Timer_server_Body+0xd2> <== NOT EXECUTED _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 116687: 52 push %edx <== NOT EXECUTED 116688: 52 push %edx <== NOT EXECUTED 116689: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 11668c: 50 push %eax <== NOT EXECUTED 11668d: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED 116690: eb 0c jmp 11669e <_Timer_server_Body+0xde> <== NOT EXECUTED } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 116692: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 116695: 75 d5 jne 11666c <_Timer_server_Body+0xac> <== NOT EXECUTED _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116697: 51 push %ecx <== NOT EXECUTED 116698: 51 push %ecx <== NOT EXECUTED 116699: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 11669c: 50 push %eax <== NOT EXECUTED 11669d: 57 push %edi <== NOT EXECUTED 11669e: e8 dd 36 00 00 call 119d80 <_Watchdog_Insert> <== NOT EXECUTED 1166a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1166a6: eb c4 jmp 11666c <_Timer_server_Body+0xac> <== NOT EXECUTED * of zero it will be processed in the next iteration of the timer server * body loop. */ _Timer_server_Process_insertions( ts ); _ISR_Disable( level ); 1166a8: 9c pushf 1166a9: fa cli 1166aa: 58 pop %eax if ( _Chain_Is_empty( insert_chain ) ) { 1166ab: 8b 55 b4 mov -0x4c(%ebp),%edx 1166ae: 39 55 dc cmp %edx,-0x24(%ebp) 1166b1: 75 13 jne 1166c6 <_Timer_server_Body+0x106> ts->insert_chain = NULL; 1166b3: c7 43 78 00 00 00 00 movl $0x0,0x78(%ebx) _ISR_Enable( level ); 1166ba: 50 push %eax 1166bb: 9d popf _Chain_Initialize_empty( &fire_chain ); while ( true ) { _Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain ); if ( !_Chain_Is_empty( &fire_chain ) ) { 1166bc: 8b 4d b0 mov -0x50(%ebp),%ecx 1166bf: 39 4d d0 cmp %ecx,-0x30(%ebp) 1166c2: 75 09 jne 1166cd <_Timer_server_Body+0x10d> 1166c4: eb 3e jmp 116704 <_Timer_server_Body+0x144> ts->insert_chain = NULL; _ISR_Enable( level ); break; } else { _ISR_Enable( level ); 1166c6: 50 push %eax <== NOT EXECUTED 1166c7: 9d popf <== NOT EXECUTED 1166c8: e9 46 ff ff ff jmp 116613 <_Timer_server_Body+0x53> <== NOT EXECUTED /* * It is essential that interrupts are disable here since an interrupt * service routine may remove a watchdog from the chain. */ _ISR_Disable( level ); 1166cd: 9c pushf 1166ce: fa cli 1166cf: 5a pop %edx */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 1166d0: 8b 45 d0 mov -0x30(%ebp),%eax */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected( Chain_Control *the_chain ) { if ( !_Chain_Is_empty(the_chain)) 1166d3: 3b 45 b0 cmp -0x50(%ebp),%eax 1166d6: 74 25 je 1166fd <_Timer_server_Body+0x13d> { Chain_Node *return_node; Chain_Node *new_first; return_node = the_chain->first; new_first = return_node->next; 1166d8: 8b 08 mov (%eax),%ecx the_chain->first = new_first; 1166da: 89 4d d0 mov %ecx,-0x30(%ebp) new_first->previous = _Chain_Head(the_chain); 1166dd: 89 71 04 mov %esi,0x4(%ecx) watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { 1166e0: 85 c0 test %eax,%eax 1166e2: 74 19 je 1166fd <_Timer_server_Body+0x13d> watchdog->state = WATCHDOG_INACTIVE; 1166e4: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) _ISR_Enable( level ); 1166eb: 52 push %edx 1166ec: 9d popf /* * The timer server may block here and wait for resources or time. * The system watchdogs are inactive and will remain inactive since * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); 1166ed: 52 push %edx 1166ee: 52 push %edx 1166ef: ff 70 24 pushl 0x24(%eax) 1166f2: ff 70 20 pushl 0x20(%eax) 1166f5: ff 50 1c call *0x1c(%eax) } 1166f8: 83 c4 10 add $0x10,%esp 1166fb: eb d0 jmp 1166cd <_Timer_server_Body+0x10d> watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain ); if ( watchdog != NULL ) { watchdog->state = WATCHDOG_INACTIVE; _ISR_Enable( level ); } else { _ISR_Enable( level ); 1166fd: 52 push %edx 1166fe: 9d popf 1166ff: e9 09 ff ff ff jmp 11660d <_Timer_server_Body+0x4d> * the active flag of the timer server is true. */ (*watchdog->routine)( watchdog->id, watchdog->user_data ); } } else { ts->active = false; 116704: c6 43 7c 00 movb $0x0,0x7c(%ebx) 116708: a1 c0 d5 13 00 mov 0x13d5c0,%eax 11670d: 40 inc %eax 11670e: a3 c0 d5 13 00 mov %eax,0x13d5c0 /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( ts->thread, STATES_DELAYING ); 116713: 50 push %eax 116714: 50 push %eax 116715: 6a 08 push $0x8 116717: ff 33 pushl (%ebx) 116719: e8 4a 2e 00 00 call 119568 <_Thread_Set_state> _Timer_server_Reset_interval_system_watchdog( ts ); 11671e: 89 d8 mov %ebx,%eax 116720: e8 0f fe ff ff call 116534 <_Timer_server_Reset_interval_system_watchdog> _Timer_server_Reset_tod_system_watchdog( ts ); 116725: 89 d8 mov %ebx,%eax 116727: e8 4e fe ff ff call 11657a <_Timer_server_Reset_tod_system_watchdog> _Thread_Enable_dispatch(); 11672c: e8 14 25 00 00 call 118c45 <_Thread_Enable_dispatch> ts->active = true; 116731: c6 43 7c 01 movb $0x1,0x7c(%ebx) static void _Timer_server_Stop_interval_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog ); 116735: 59 pop %ecx 116736: ff 75 b8 pushl -0x48(%ebp) 116739: e8 5a 37 00 00 call 119e98 <_Watchdog_Remove> static void _Timer_server_Stop_tod_system_watchdog( Timer_server_Control *ts ) { _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog ); 11673e: 5a pop %edx 11673f: ff 75 bc pushl -0x44(%ebp) 116742: e8 51 37 00 00 call 119e98 <_Watchdog_Remove> 116747: 83 c4 10 add $0x10,%esp 11674a: e9 be fe ff ff jmp 11660d <_Timer_server_Body+0x4d> 0011674f <_Timer_server_Schedule_operation_method>: static void _Timer_server_Schedule_operation_method( Timer_server_Control *ts, Timer_Control *timer ) { 11674f: 55 push %ebp 116750: 89 e5 mov %esp,%ebp 116752: 57 push %edi 116753: 56 push %esi 116754: 53 push %ebx 116755: 83 ec 2c sub $0x2c,%esp 116758: 8b 5d 08 mov 0x8(%ebp),%ebx 11675b: 8b 45 0c mov 0xc(%ebp),%eax if ( ts->insert_chain == NULL ) { 11675e: 8b 53 78 mov 0x78(%ebx),%edx 116761: 85 d2 test %edx,%edx 116763: 0f 85 e6 00 00 00 jne 11684f <_Timer_server_Schedule_operation_method+0x100> 116769: 8b 15 c0 d5 13 00 mov 0x13d5c0,%edx 11676f: 42 inc %edx 116770: 89 15 c0 d5 13 00 mov %edx,0x13d5c0 * being inserted. This could result in an integer overflow. */ _Thread_Disable_dispatch(); if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) { 116776: 8b 50 38 mov 0x38(%eax),%edx 116779: 83 fa 01 cmp $0x1,%edx 11677c: 75 5a jne 1167d8 <_Timer_server_Schedule_operation_method+0x89> /* * We have to advance the last known ticks value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 11677e: 9c pushf 11677f: fa cli 116780: 8f 45 e0 popl -0x20(%ebp) snapshot = _Watchdog_Ticks_since_boot; 116783: 8b 0d 0c d7 13 00 mov 0x13d70c,%ecx last_snapshot = ts->Interval_watchdogs.last_snapshot; 116789: 8b 73 3c mov 0x3c(%ebx),%esi */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 11678c: 8b 53 30 mov 0x30(%ebx),%edx */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 11678f: 8d 7b 34 lea 0x34(%ebx),%edi 116792: 39 fa cmp %edi,%edx 116794: 74 19 je 1167af <_Timer_server_Schedule_operation_method+0x60> first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain ); /* * We assume adequate unsigned arithmetic here. */ delta = snapshot - last_snapshot; 116796: 89 cf mov %ecx,%edi 116798: 29 f7 sub %esi,%edi 11679a: 89 7d e4 mov %edi,-0x1c(%ebp) delta_interval = first_watchdog->delta_interval; 11679d: 8b 7a 10 mov 0x10(%edx),%edi if (delta_interval > delta) { 1167a0: 31 f6 xor %esi,%esi 1167a2: 3b 7d e4 cmp -0x1c(%ebp),%edi 1167a5: 76 05 jbe 1167ac <_Timer_server_Schedule_operation_method+0x5d> delta_interval -= delta; 1167a7: 89 fe mov %edi,%esi 1167a9: 2b 75 e4 sub -0x1c(%ebp),%esi } else { delta_interval = 0; } first_watchdog->delta_interval = delta_interval; 1167ac: 89 72 10 mov %esi,0x10(%edx) } ts->Interval_watchdogs.last_snapshot = snapshot; 1167af: 89 4b 3c mov %ecx,0x3c(%ebx) _ISR_Enable( level ); 1167b2: ff 75 e0 pushl -0x20(%ebp) 1167b5: 9d popf _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker ); 1167b6: 57 push %edi 1167b7: 57 push %edi 1167b8: 83 c0 10 add $0x10,%eax 1167bb: 50 push %eax 1167bc: 8d 43 30 lea 0x30(%ebx),%eax 1167bf: 50 push %eax 1167c0: e8 bb 35 00 00 call 119d80 <_Watchdog_Insert> if ( !ts->active ) { 1167c5: 8a 43 7c mov 0x7c(%ebx),%al 1167c8: 83 c4 10 add $0x10,%esp 1167cb: 84 c0 test %al,%al 1167cd: 75 74 jne 116843 <_Timer_server_Schedule_operation_method+0xf4> _Timer_server_Reset_interval_system_watchdog( ts ); 1167cf: 89 d8 mov %ebx,%eax 1167d1: e8 5e fd ff ff call 116534 <_Timer_server_Reset_interval_system_watchdog> 1167d6: eb 6b jmp 116843 <_Timer_server_Schedule_operation_method+0xf4> } } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 1167d8: 83 fa 03 cmp $0x3,%edx 1167db: 75 66 jne 116843 <_Timer_server_Schedule_operation_method+0xf4> /* * We have to advance the last known seconds value of the server and update * the watchdog chain accordingly. */ _ISR_Disable( level ); 1167dd: 9c pushf 1167de: fa cli 1167df: 8f 45 e0 popl -0x20(%ebp) snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch(); 1167e2: 8b 0d 50 d6 13 00 mov 0x13d650,%ecx last_snapshot = ts->TOD_watchdogs.last_snapshot; 1167e8: 8b 53 74 mov 0x74(%ebx),%edx */ RTEMS_INLINE_ROUTINE bool _Chain_Is_empty( Chain_Control *the_chain ) { return (the_chain->first == _Chain_Tail(the_chain)); 1167eb: 8b 73 68 mov 0x68(%ebx),%esi */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail( Chain_Control *the_chain ) { return (Chain_Node *) &the_chain->permanent_null; 1167ee: 8d 7b 6c lea 0x6c(%ebx),%edi 1167f1: 39 fe cmp %edi,%esi 1167f3: 74 27 je 11681c <_Timer_server_Schedule_operation_method+0xcd> if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) { first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain ); delta_interval = first_watchdog->delta_interval; 1167f5: 8b 7e 10 mov 0x10(%esi),%edi 1167f8: 89 7d d4 mov %edi,-0x2c(%ebp) if ( snapshot > last_snapshot ) { 1167fb: 39 d1 cmp %edx,%ecx 1167fd: 76 15 jbe 116814 <_Timer_server_Schedule_operation_method+0xc5> /* * We advanced in time. */ delta = snapshot - last_snapshot; 1167ff: 89 cf mov %ecx,%edi 116801: 29 d7 sub %edx,%edi 116803: 89 7d e4 mov %edi,-0x1c(%ebp) if (delta_interval > delta) { 116806: 31 d2 xor %edx,%edx 116808: 39 7d d4 cmp %edi,-0x2c(%ebp) 11680b: 76 0c jbe 116819 <_Timer_server_Schedule_operation_method+0xca> delta_interval -= delta; 11680d: 8b 55 d4 mov -0x2c(%ebp),%edx 116810: 29 fa sub %edi,%edx 116812: eb 05 jmp 116819 <_Timer_server_Schedule_operation_method+0xca> } } else { /* * Someone put us in the past. */ delta = last_snapshot - snapshot; 116814: 03 55 d4 add -0x2c(%ebp),%edx delta_interval += delta; 116817: 29 ca sub %ecx,%edx } first_watchdog->delta_interval = delta_interval; 116819: 89 56 10 mov %edx,0x10(%esi) } ts->TOD_watchdogs.last_snapshot = snapshot; 11681c: 89 4b 74 mov %ecx,0x74(%ebx) _ISR_Enable( level ); 11681f: ff 75 e0 pushl -0x20(%ebp) 116822: 9d popf _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker ); 116823: 56 push %esi 116824: 56 push %esi 116825: 83 c0 10 add $0x10,%eax 116828: 50 push %eax 116829: 8d 43 68 lea 0x68(%ebx),%eax 11682c: 50 push %eax 11682d: e8 4e 35 00 00 call 119d80 <_Watchdog_Insert> if ( !ts->active ) { 116832: 8a 43 7c mov 0x7c(%ebx),%al 116835: 83 c4 10 add $0x10,%esp 116838: 84 c0 test %al,%al 11683a: 75 07 jne 116843 <_Timer_server_Schedule_operation_method+0xf4> _Timer_server_Reset_tod_system_watchdog( ts ); 11683c: 89 d8 mov %ebx,%eax 11683e: e8 37 fd ff ff call 11657a <_Timer_server_Reset_tod_system_watchdog> * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); } } 116843: 8d 65 f4 lea -0xc(%ebp),%esp 116846: 5b pop %ebx 116847: 5e pop %esi 116848: 5f pop %edi 116849: c9 leave if ( !ts->active ) { _Timer_server_Reset_tod_system_watchdog( ts ); } } _Thread_Enable_dispatch(); 11684a: e9 f6 23 00 00 jmp 118c45 <_Thread_Enable_dispatch> * server is not preemptible, so we must be in interrupt context here. No * thread dispatch will happen until the timer server finishes its * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); 11684f: 8b 53 78 mov 0x78(%ebx),%edx <== NOT EXECUTED 116852: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 116855: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } } 116858: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11685b: 5b pop %ebx <== NOT EXECUTED 11685c: 5e pop %esi <== NOT EXECUTED 11685d: 5f pop %edi <== NOT EXECUTED 11685e: c9 leave <== NOT EXECUTED * server is not preemptible, so we must be in interrupt context here. No * thread dispatch will happen until the timer server finishes its * critical section. We have to use the protected chain methods because * we may be interrupted by a higher priority interrupt. */ _Chain_Append( ts->insert_chain, &timer->Object.Node ); 11685f: e9 2c 05 00 00 jmp 116d90 <_Chain_Append> <== NOT EXECUTED 0011ca28 <_exit>: /* * If the toolset uses init/fini sections, then we need to * run the global destructors now. */ #if defined(__USE_INIT_FINI__) FINI_SYMBOL(); 11ca28: 55 push %ebp 11ca29: 89 e5 mov %esp,%ebp 11ca2b: 83 ec 08 sub $0x8,%esp 11ca2e: e8 6a 06 00 00 call 11d09d <_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(); 11ca33: e8 8c ff ff ff call 11c9c4 rtems_shutdown_executive(status); 11ca38: 83 ec 0c sub $0xc,%esp 11ca3b: ff 75 08 pushl 0x8(%ebp) 11ca3e: e8 e9 00 00 00 call 11cb2c 11ca43: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11ca46: eb fe jmp 11ca46 <_exit+0x1e> <== NOT EXECUTED 00134bca <_fcntl_r>: struct _reent *ptr __attribute__((unused)), int fd, int cmd, int arg ) { 134bca: 55 push %ebp <== NOT EXECUTED 134bcb: 89 e5 mov %esp,%ebp <== NOT EXECUTED 134bcd: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 134bd0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 134bd3: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return fcntl( fd, cmd, arg ); 134bd6: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 134bd9: 89 4d 10 mov %ecx,0x10(%ebp) <== NOT EXECUTED 134bdc: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 134bdf: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 134be2: c9 leave <== NOT EXECUTED int fd, int cmd, int arg ) { return fcntl( fd, cmd, arg ); 134be3: e9 98 fe ff ff jmp 134a80 <== NOT EXECUTED 001102fe <_getpid_r>: #include pid_t _getpid_r( struct _reent *ptr __attribute__((unused)) ) { 1102fe: 55 push %ebp <== NOT EXECUTED 1102ff: 89 e5 mov %esp,%ebp <== NOT EXECUTED return getpid(); } 110301: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 110306: c9 leave <== NOT EXECUTED 110307: c3 ret <== NOT EXECUTED 0010de1f <_gettimeofday>: int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { 10de1f: 55 push %ebp <== NOT EXECUTED 10de20: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10de22: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED return gettimeofday( tp, tzp ); } 10de25: c9 leave <== NOT EXECUTED int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp ); 10de26: e9 a5 ff ff ff jmp 10ddd0 <== NOT EXECUTED 0012646a <_link_r>: int _link_r( struct _reent *ptr __attribute__((unused)), const char *existing, const char *new ) { 12646a: 55 push %ebp <== NOT EXECUTED 12646b: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12646d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 126470: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED return link( existing, new ); 126473: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 126476: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 126479: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 12647c: c9 leave <== NOT EXECUTED struct _reent *ptr __attribute__((unused)), const char *existing, const char *new ) { return link( existing, new ); 12647d: e9 26 fe ff ff jmp 1262a8 <== NOT EXECUTED 00126626 <_lstat_r>: int _STAT_R_NAME( struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { 126626: 55 push %ebp <== NOT EXECUTED 126627: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126629: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12662c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED return _STAT_NAME( path, buf ); 12662f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 126632: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 126635: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 126638: c9 leave <== NOT EXECUTED struct _reent *ptr __attribute__((unused)), const char *path, struct stat *buf ) { return _STAT_NAME( path, buf ); 126639: e9 3a ff ff ff jmp 126578 <== NOT EXECUTED 0011caf4 <_realloc_r>: void *_realloc_r( struct _reent *ignored __attribute__((unused)), void *ptr, size_t size ) { 11caf4: 55 push %ebp <== NOT EXECUTED 11caf5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11caf7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11cafa: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED return realloc( ptr, size ); 11cafd: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 11cb00: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 11cb03: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 11cb06: c9 leave <== NOT EXECUTED struct _reent *ignored __attribute__((unused)), void *ptr, size_t size ) { return realloc( ptr, size ); 11cb07: e9 48 00 00 00 jmp 11cb54 <== NOT EXECUTED 0014f990 <_rename_r>: int _rename_r( struct _reent *ptr __attribute__((unused)), const char *old, const char *new ) { 14f990: 55 push %ebp <== NOT EXECUTED 14f991: 89 e5 mov %esp,%ebp <== NOT EXECUTED 14f993: 57 push %edi <== NOT EXECUTED 14f994: 56 push %esi <== NOT EXECUTED 14f995: 53 push %ebx <== NOT EXECUTED 14f996: 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 ); 14f999: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 14f99c: e8 3a bc fb ff call 10b5db <== NOT EXECUTED 14f9a1: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( old_parent_pathlen == 0 ) 14f9a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 14f9a6: 85 c0 test %eax,%eax <== NOT EXECUTED 14f9a8: 75 36 jne 14f9e0 <_rename_r+0x50> <== NOT EXECUTED rtems_filesystem_get_start_loc( old, &i, &old_parent_loc ); 14f9aa: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 14f9ad: 8a 01 mov (%ecx),%al <== NOT EXECUTED 14f9af: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 14f9b1: 74 08 je 14f9bb <_rename_r+0x2b> <== NOT EXECUTED 14f9b3: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 14f9b5: 74 04 je 14f9bb <_rename_r+0x2b> <== NOT EXECUTED 14f9b7: 84 c0 test %al,%al <== NOT EXECUTED 14f9b9: 75 0e jne 14f9c9 <_rename_r+0x39> <== NOT EXECUTED 14f9bb: 8d 7d bc lea -0x44(%ebp),%edi <== NOT EXECUTED 14f9be: 8b 35 3c f7 15 00 mov 0x15f73c,%esi <== NOT EXECUTED 14f9c4: 83 c6 18 add $0x18,%esi <== NOT EXECUTED 14f9c7: eb 0c jmp 14f9d5 <_rename_r+0x45> <== NOT EXECUTED 14f9c9: 8d 7d bc lea -0x44(%ebp),%edi <== NOT EXECUTED 14f9cc: 8b 35 3c f7 15 00 mov 0x15f73c,%esi <== NOT EXECUTED 14f9d2: 83 c6 04 add $0x4,%esi <== NOT EXECUTED 14f9d5: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 14f9da: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 14f9dc: 31 db xor %ebx,%ebx <== NOT EXECUTED 14f9de: eb 2a jmp 14fa0a <_rename_r+0x7a> <== NOT EXECUTED else { result = rtems_filesystem_evaluate_path( old, old_parent_pathlen, 14f9e0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14f9e3: 6a 00 push $0x0 <== NOT EXECUTED 14f9e5: 8d 45 bc lea -0x44(%ebp),%eax <== NOT EXECUTED 14f9e8: 50 push %eax <== NOT EXECUTED 14f9e9: 6a 02 push $0x2 <== NOT EXECUTED 14f9eb: 52 push %edx <== NOT EXECUTED 14f9ec: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 14f9ef: 89 55 a4 mov %edx,-0x5c(%ebp) <== NOT EXECUTED 14f9f2: e8 d1 bc fb ff call 10b6c8 <== NOT EXECUTED RTEMS_LIBIO_PERMS_WRITE, &old_parent_loc, false ); if ( result != 0 ) 14f9f7: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 14f9fa: b3 01 mov $0x1,%bl <== NOT EXECUTED 14f9fc: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 14f9ff: 85 c0 test %eax,%eax <== NOT EXECUTED 14fa01: 8b 55 a4 mov -0x5c(%ebp),%edx <== NOT EXECUTED 14fa04: 0f 85 6f 02 00 00 jne 14fc79 <_rename_r+0x2e9> <== NOT EXECUTED /* * Start from the parent to find the node that should be under it. */ old_loc = old_parent_loc; 14fa0a: 8d 7d d0 lea -0x30(%ebp),%edi <== NOT EXECUTED 14fa0d: 8d 75 bc lea -0x44(%ebp),%esi <== NOT EXECUTED 14fa10: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 14fa15: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED name = old + old_parent_pathlen; 14fa17: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 14fa1a: 01 d6 add %edx,%esi <== NOT EXECUTED 14fa1c: 89 75 e4 mov %esi,-0x1c(%ebp) <== NOT EXECUTED name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 14fa1f: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 14fa22: 89 f7 mov %esi,%edi <== NOT EXECUTED 14fa24: 31 c0 xor %eax,%eax <== NOT EXECUTED 14fa26: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 14fa28: f7 d1 not %ecx <== NOT EXECUTED 14fa2a: 49 dec %ecx <== NOT EXECUTED 14fa2b: 57 push %edi <== NOT EXECUTED 14fa2c: 57 push %edi <== NOT EXECUTED 14fa2d: 51 push %ecx <== NOT EXECUTED 14fa2e: 56 push %esi <== NOT EXECUTED 14fa2f: e8 80 bb fb ff call 10b5b4 <== NOT EXECUTED 14fa34: 01 c6 add %eax,%esi <== NOT EXECUTED 14fa36: 89 75 e4 mov %esi,-0x1c(%ebp) <== NOT EXECUTED result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 14fa39: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 14fa3c: 89 f7 mov %esi,%edi <== NOT EXECUTED 14fa3e: 31 c0 xor %eax,%eax <== NOT EXECUTED 14fa40: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 14fa42: f7 d1 not %ecx <== NOT EXECUTED 14fa44: 49 dec %ecx <== NOT EXECUTED 14fa45: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED 14fa4c: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 14fa4f: 50 push %eax <== NOT EXECUTED 14fa50: 6a 00 push $0x0 <== NOT EXECUTED 14fa52: 51 push %ecx <== NOT EXECUTED 14fa53: 56 push %esi <== NOT EXECUTED 14fa54: e8 b5 bb fb ff call 10b60e <== NOT EXECUTED 14fa59: 89 c6 mov %eax,%esi <== NOT EXECUTED 0, &old_loc, false ); if ( result != 0 ) { 14fa5b: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 14fa5e: 85 c0 test %eax,%eax <== NOT EXECUTED 14fa60: 74 29 je 14fa8b <_rename_r+0xfb> <== NOT EXECUTED if ( free_old_parentloc ) 14fa62: 84 db test %bl,%bl <== NOT EXECUTED 14fa64: 0f 84 1d 01 00 00 je 14fb87 <_rename_r+0x1f7> <== NOT EXECUTED rtems_filesystem_freenode( &old_parent_loc ); 14fa6a: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 14fa6d: 85 c0 test %eax,%eax <== NOT EXECUTED 14fa6f: 0f 84 12 01 00 00 je 14fb87 <_rename_r+0x1f7> <== NOT EXECUTED 14fa75: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14fa78: 85 c0 test %eax,%eax <== NOT EXECUTED 14fa7a: 0f 84 07 01 00 00 je 14fb87 <_rename_r+0x1f7> <== NOT EXECUTED 14fa80: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14fa83: 8d 55 bc lea -0x44(%ebp),%edx <== NOT EXECUTED 14fa86: e9 f6 00 00 00 jmp 14fb81 <_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 ); 14fa8b: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 14fa8e: 8a 02 mov (%edx),%al <== NOT EXECUTED 14fa90: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 14fa92: 74 08 je 14fa9c <_rename_r+0x10c> <== NOT EXECUTED 14fa94: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 14fa96: 74 04 je 14fa9c <_rename_r+0x10c> <== NOT EXECUTED 14fa98: 84 c0 test %al,%al <== NOT EXECUTED 14fa9a: 75 1a jne 14fab6 <_rename_r+0x126> <== NOT EXECUTED 14fa9c: 8d 7d a8 lea -0x58(%ebp),%edi <== NOT EXECUTED 14fa9f: 8b 35 3c f7 15 00 mov 0x15f73c,%esi <== NOT EXECUTED 14faa5: 83 c6 18 add $0x18,%esi <== NOT EXECUTED 14faa8: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 14faad: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 14faaf: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 14fab4: eb 15 jmp 14facb <_rename_r+0x13b> <== NOT EXECUTED 14fab6: 8d 7d a8 lea -0x58(%ebp),%edi <== NOT EXECUTED 14fab9: 8b 35 3c f7 15 00 mov 0x15f73c,%esi <== NOT EXECUTED 14fabf: 83 c6 04 add $0x4,%esi <== NOT EXECUTED 14fac2: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 14fac7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 14fac9: 31 d2 xor %edx,%edx <== NOT EXECUTED if ( !new_parent_loc.ops->evalformake_h ) { 14facb: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED 14face: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 14fad1: 85 c0 test %eax,%eax <== NOT EXECUTED 14fad3: 75 4b jne 14fb20 <_rename_r+0x190> <== NOT EXECUTED if ( free_old_parentloc ) 14fad5: 84 db test %bl,%bl <== NOT EXECUTED 14fad7: 74 1a je 14faf3 <_rename_r+0x163> <== NOT EXECUTED rtems_filesystem_freenode( &old_parent_loc ); 14fad9: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 14fadc: 85 c0 test %eax,%eax <== NOT EXECUTED 14fade: 74 13 je 14faf3 <_rename_r+0x163> <== NOT EXECUTED 14fae0: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14fae3: 85 c0 test %eax,%eax <== NOT EXECUTED 14fae5: 74 0c je 14faf3 <_rename_r+0x163> <== NOT EXECUTED 14fae7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14faea: 8d 55 bc lea -0x44(%ebp),%edx <== NOT EXECUTED 14faed: 52 push %edx <== NOT EXECUTED 14faee: ff d0 call *%eax <== NOT EXECUTED 14faf0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &old_loc ); 14faf3: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 14faf6: 85 c0 test %eax,%eax <== NOT EXECUTED 14faf8: 74 13 je 14fb0d <_rename_r+0x17d> <== NOT EXECUTED 14fafa: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14fafd: 85 c0 test %eax,%eax <== NOT EXECUTED 14faff: 74 0c je 14fb0d <_rename_r+0x17d> <== NOT EXECUTED 14fb01: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14fb04: 8d 55 d0 lea -0x30(%ebp),%edx <== NOT EXECUTED 14fb07: 52 push %edx <== NOT EXECUTED 14fb08: ff d0 call *%eax <== NOT EXECUTED 14fb0a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 14fb0d: e8 02 9f fe ff call 139a14 <__errno> <== NOT EXECUTED 14fb12: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 14fb18: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 14fb1b: e9 59 01 00 00 jmp 14fc79 <_rename_r+0x2e9> <== NOT EXECUTED } result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name ); 14fb20: 51 push %ecx <== NOT EXECUTED 14fb21: 8d 4d e4 lea -0x1c(%ebp),%ecx <== NOT EXECUTED 14fb24: 51 push %ecx <== NOT EXECUTED 14fb25: 8d 7d a8 lea -0x58(%ebp),%edi <== NOT EXECUTED 14fb28: 57 push %edi <== NOT EXECUTED 14fb29: 03 55 10 add 0x10(%ebp),%edx <== NOT EXECUTED 14fb2c: 52 push %edx <== NOT EXECUTED 14fb2d: ff d0 call *%eax <== NOT EXECUTED 14fb2f: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( result != 0 ) { 14fb31: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 14fb34: 85 c0 test %eax,%eax <== NOT EXECUTED 14fb36: 74 58 je 14fb90 <_rename_r+0x200> <== NOT EXECUTED rtems_filesystem_freenode( &new_parent_loc ); 14fb38: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED 14fb3b: 85 c0 test %eax,%eax <== NOT EXECUTED 14fb3d: 74 10 je 14fb4f <_rename_r+0x1bf> <== NOT EXECUTED 14fb3f: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14fb42: 85 c0 test %eax,%eax <== NOT EXECUTED 14fb44: 74 09 je 14fb4f <_rename_r+0x1bf> <== NOT EXECUTED 14fb46: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14fb49: 57 push %edi <== NOT EXECUTED 14fb4a: ff d0 call *%eax <== NOT EXECUTED 14fb4c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( free_old_parentloc ) 14fb4f: 84 db test %bl,%bl <== NOT EXECUTED 14fb51: 74 1a je 14fb6d <_rename_r+0x1dd> <== NOT EXECUTED rtems_filesystem_freenode( &old_parent_loc ); 14fb53: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 14fb56: 85 c0 test %eax,%eax <== NOT EXECUTED 14fb58: 74 13 je 14fb6d <_rename_r+0x1dd> <== NOT EXECUTED 14fb5a: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14fb5d: 85 c0 test %eax,%eax <== NOT EXECUTED 14fb5f: 74 0c je 14fb6d <_rename_r+0x1dd> <== NOT EXECUTED 14fb61: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14fb64: 8d 55 bc lea -0x44(%ebp),%edx <== NOT EXECUTED 14fb67: 52 push %edx <== NOT EXECUTED 14fb68: ff d0 call *%eax <== NOT EXECUTED 14fb6a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &old_loc ); 14fb6d: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 14fb70: 85 c0 test %eax,%eax <== NOT EXECUTED 14fb72: 74 13 je 14fb87 <_rename_r+0x1f7> <== NOT EXECUTED 14fb74: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14fb77: 85 c0 test %eax,%eax <== NOT EXECUTED 14fb79: 74 0c je 14fb87 <_rename_r+0x1f7> <== NOT EXECUTED 14fb7b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14fb7e: 8d 55 d0 lea -0x30(%ebp),%edx <== NOT EXECUTED 14fb81: 52 push %edx <== NOT EXECUTED 14fb82: ff d0 call *%eax <== NOT EXECUTED 14fb84: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( result ); 14fb87: e8 88 9e fe ff call 139a14 <__errno> <== NOT EXECUTED 14fb8c: 89 30 mov %esi,(%eax) <== NOT EXECUTED 14fb8e: eb 88 jmp 14fb18 <_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 ) { 14fb90: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 14fb93: 3b 45 b8 cmp -0x48(%ebp),%eax <== NOT EXECUTED 14fb96: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED 14fb99: 74 5c je 14fbf7 <_rename_r+0x267> <== NOT EXECUTED rtems_filesystem_freenode( &new_parent_loc ); 14fb9b: 85 c0 test %eax,%eax <== NOT EXECUTED 14fb9d: 74 10 je 14fbaf <_rename_r+0x21f> <== NOT EXECUTED 14fb9f: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14fba2: 85 c0 test %eax,%eax <== NOT EXECUTED 14fba4: 74 09 je 14fbaf <_rename_r+0x21f> <== NOT EXECUTED 14fba6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14fba9: 57 push %edi <== NOT EXECUTED 14fbaa: ff d0 call *%eax <== NOT EXECUTED 14fbac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( free_old_parentloc ) 14fbaf: 84 db test %bl,%bl <== NOT EXECUTED 14fbb1: 74 1a je 14fbcd <_rename_r+0x23d> <== NOT EXECUTED rtems_filesystem_freenode( &old_parent_loc ); 14fbb3: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 14fbb6: 85 c0 test %eax,%eax <== NOT EXECUTED 14fbb8: 74 13 je 14fbcd <_rename_r+0x23d> <== NOT EXECUTED 14fbba: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14fbbd: 85 c0 test %eax,%eax <== NOT EXECUTED 14fbbf: 74 0c je 14fbcd <_rename_r+0x23d> <== NOT EXECUTED 14fbc1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14fbc4: 8d 55 bc lea -0x44(%ebp),%edx <== NOT EXECUTED 14fbc7: 52 push %edx <== NOT EXECUTED 14fbc8: ff d0 call *%eax <== NOT EXECUTED 14fbca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &old_loc ); 14fbcd: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 14fbd0: 85 c0 test %eax,%eax <== NOT EXECUTED 14fbd2: 74 13 je 14fbe7 <_rename_r+0x257> <== NOT EXECUTED 14fbd4: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14fbd7: 85 c0 test %eax,%eax <== NOT EXECUTED 14fbd9: 74 0c je 14fbe7 <_rename_r+0x257> <== NOT EXECUTED 14fbdb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14fbde: 8d 55 d0 lea -0x30(%ebp),%edx <== NOT EXECUTED 14fbe1: 52 push %edx <== NOT EXECUTED 14fbe2: ff d0 call *%eax <== NOT EXECUTED 14fbe4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EXDEV ); 14fbe7: e8 28 9e fe ff call 139a14 <__errno> <== NOT EXECUTED 14fbec: c7 00 12 00 00 00 movl $0x12,(%eax) <== NOT EXECUTED 14fbf2: e9 21 ff ff ff jmp 14fb18 <_rename_r+0x188> <== NOT EXECUTED } if ( !new_parent_loc.ops->rename_h ) { 14fbf7: 8b 50 40 mov 0x40(%eax),%edx <== NOT EXECUTED 14fbfa: 85 d2 test %edx,%edx <== NOT EXECUTED 14fbfc: 75 19 jne 14fc17 <_rename_r+0x287> <== NOT EXECUTED rtems_filesystem_freenode( &new_parent_loc ); 14fbfe: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14fc01: 85 c0 test %eax,%eax <== NOT EXECUTED 14fc03: 0f 84 cc fe ff ff je 14fad5 <_rename_r+0x145> <== NOT EXECUTED 14fc09: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14fc0c: 57 push %edi <== NOT EXECUTED 14fc0d: ff d0 call *%eax <== NOT EXECUTED 14fc0f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 14fc12: e9 be fe ff ff jmp 14fad5 <_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 ); 14fc17: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 14fc1a: 57 push %edi <== NOT EXECUTED 14fc1b: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 14fc1e: 50 push %eax <== NOT EXECUTED 14fc1f: 8d 45 bc lea -0x44(%ebp),%eax <== NOT EXECUTED 14fc22: 50 push %eax <== NOT EXECUTED 14fc23: ff d2 call *%edx <== NOT EXECUTED 14fc25: 89 c6 mov %eax,%esi <== NOT EXECUTED rtems_filesystem_freenode( &new_parent_loc ); 14fc27: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED 14fc2a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 14fc2d: 85 c0 test %eax,%eax <== NOT EXECUTED 14fc2f: 74 10 je 14fc41 <_rename_r+0x2b1> <== NOT EXECUTED 14fc31: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14fc34: 85 c0 test %eax,%eax <== NOT EXECUTED 14fc36: 74 09 je 14fc41 <_rename_r+0x2b1> <== NOT EXECUTED 14fc38: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14fc3b: 57 push %edi <== NOT EXECUTED 14fc3c: ff d0 call *%eax <== NOT EXECUTED 14fc3e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( free_old_parentloc ) 14fc41: 84 db test %bl,%bl <== NOT EXECUTED 14fc43: 74 1a je 14fc5f <_rename_r+0x2cf> <== NOT EXECUTED rtems_filesystem_freenode( &old_parent_loc ); 14fc45: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 14fc48: 85 c0 test %eax,%eax <== NOT EXECUTED 14fc4a: 74 13 je 14fc5f <_rename_r+0x2cf> <== NOT EXECUTED 14fc4c: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14fc4f: 85 c0 test %eax,%eax <== NOT EXECUTED 14fc51: 74 0c je 14fc5f <_rename_r+0x2cf> <== NOT EXECUTED 14fc53: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14fc56: 8d 55 bc lea -0x44(%ebp),%edx <== NOT EXECUTED 14fc59: 52 push %edx <== NOT EXECUTED 14fc5a: ff d0 call *%eax <== NOT EXECUTED 14fc5c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &old_loc ); 14fc5f: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 14fc62: 85 c0 test %eax,%eax <== NOT EXECUTED 14fc64: 74 13 je 14fc79 <_rename_r+0x2e9> <== NOT EXECUTED 14fc66: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 14fc69: 85 c0 test %eax,%eax <== NOT EXECUTED 14fc6b: 74 0c je 14fc79 <_rename_r+0x2e9> <== NOT EXECUTED 14fc6d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 14fc70: 8d 55 d0 lea -0x30(%ebp),%edx <== NOT EXECUTED 14fc73: 52 push %edx <== NOT EXECUTED 14fc74: ff d0 call *%eax <== NOT EXECUTED 14fc76: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 14fc79: 89 f0 mov %esi,%eax <== NOT EXECUTED 14fc7b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 14fc7e: 5b pop %ebx <== NOT EXECUTED 14fc7f: 5e pop %esi <== NOT EXECUTED 14fc80: 5f pop %edi <== NOT EXECUTED 14fc81: c9 leave <== NOT EXECUTED 14fc82: 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 00111086 <_unlink_r>: int _unlink_r( struct _reent *ptr __attribute__((unused)), const char *path ) { 111086: 55 push %ebp <== NOT EXECUTED 111087: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111089: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED return unlink( path ); 11108c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11108f: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 111092: c9 leave <== NOT EXECUTED int _unlink_r( struct _reent *ptr __attribute__((unused)), const char *path ) { return unlink( path ); 111093: e9 04 fe ff ff jmp 110e9c <== NOT EXECUTED 00125388 : #include int chdir( const char *pathname ) { 125388: 55 push %ebp 125389: 89 e5 mov %esp,%ebp 12538b: 57 push %edi 12538c: 56 push %esi 12538d: 83 ec 2c sub $0x2c,%esp 125390: 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 ); 125393: 31 c0 xor %eax,%eax 125395: 83 c9 ff or $0xffffffff,%ecx 125398: 89 d7 mov %edx,%edi 12539a: f2 ae repnz scas %es:(%edi),%al 12539c: f7 d1 not %ecx 12539e: 49 dec %ecx /* * Get the node where we wish to go. */ result = rtems_filesystem_evaluate_path( 12539f: 6a 01 push $0x1 1253a1: 8d 75 e4 lea -0x1c(%ebp),%esi 1253a4: 56 push %esi 1253a5: 6a 01 push $0x1 1253a7: 51 push %ecx 1253a8: 52 push %edx 1253a9: e8 1a 63 fe ff call 10b6c8 1253ae: 89 c2 mov %eax,%edx pathname, strlen( pathname ), RTEMS_LIBIO_PERMS_SEARCH, &loc, true ); if ( result != 0 ) 1253b0: 83 c4 20 add $0x20,%esp 1253b3: 83 c8 ff or $0xffffffff,%eax 1253b6: 85 d2 test %edx,%edx 1253b8: 0f 85 8f 00 00 00 jne 12544d /* * Verify you can change directory into this node. */ if ( !loc.ops->node_type_h ) { 1253be: 8b 55 f0 mov -0x10(%ebp),%edx 1253c1: 8b 42 10 mov 0x10(%edx),%eax 1253c4: 85 c0 test %eax,%eax 1253c6: 75 1d jne 1253e5 rtems_filesystem_freenode( &loc ); 1253c8: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 1253cb: 85 c0 test %eax,%eax <== NOT EXECUTED 1253cd: 74 09 je 1253d8 <== NOT EXECUTED 1253cf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1253d2: 56 push %esi <== NOT EXECUTED 1253d3: ff d0 call *%eax <== NOT EXECUTED 1253d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1253d8: e8 37 46 01 00 call 139a14 <__errno> <== NOT EXECUTED 1253dd: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1253e3: eb 2e jmp 125413 <== NOT EXECUTED } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 1253e5: 83 ec 0c sub $0xc,%esp 1253e8: 56 push %esi 1253e9: ff d0 call *%eax 1253eb: 83 c4 10 add $0x10,%esp 1253ee: 48 dec %eax 1253ef: 74 27 je 125418 rtems_filesystem_freenode( &loc ); 1253f1: 8b 45 f0 mov -0x10(%ebp),%eax 1253f4: 85 c0 test %eax,%eax 1253f6: 74 10 je 125408 1253f8: 8b 40 1c mov 0x1c(%eax),%eax 1253fb: 85 c0 test %eax,%eax 1253fd: 74 09 je 125408 1253ff: 83 ec 0c sub $0xc,%esp 125402: 56 push %esi 125403: ff d0 call *%eax 125405: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( ENOTDIR ); 125408: e8 07 46 01 00 call 139a14 <__errno> 12540d: c7 00 14 00 00 00 movl $0x14,(%eax) 125413: 83 c8 ff or $0xffffffff,%eax 125416: eb 35 jmp 12544d } rtems_filesystem_freenode( &rtems_filesystem_current ); 125418: 8b 15 3c f7 15 00 mov 0x15f73c,%edx 12541e: 8b 42 10 mov 0x10(%edx),%eax 125421: 85 c0 test %eax,%eax 125423: 74 13 je 125438 125425: 8b 40 1c mov 0x1c(%eax),%eax 125428: 85 c0 test %eax,%eax 12542a: 74 0c je 125438 12542c: 83 ec 0c sub $0xc,%esp 12542f: 83 c2 04 add $0x4,%edx 125432: 52 push %edx 125433: ff d0 call *%eax 125435: 83 c4 10 add $0x10,%esp rtems_filesystem_current = loc; 125438: 8b 3d 3c f7 15 00 mov 0x15f73c,%edi 12543e: 83 c7 04 add $0x4,%edi 125441: 8d 75 e4 lea -0x1c(%ebp),%esi 125444: b9 05 00 00 00 mov $0x5,%ecx 125449: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 12544b: 31 c0 xor %eax,%eax return 0; } 12544d: 8d 65 f8 lea -0x8(%ebp),%esp 125450: 5e pop %esi 125451: 5f pop %edi 125452: c9 leave 125453: 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 4c e5 02 00 call 139a14 <__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 21 e5 02 00 call 139a14 <__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 00125454 : int chown( const char *path, uid_t owner, gid_t group ) { 125454: 55 push %ebp 125455: 89 e5 mov %esp,%ebp 125457: 57 push %edi 125458: 56 push %esi 125459: 53 push %ebx 12545a: 83 ec 48 sub $0x48,%esp 12545d: 8b 55 08 mov 0x8(%ebp),%edx 125460: 8b 75 0c mov 0xc(%ebp),%esi 125463: 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 ) ) 125466: 31 c0 xor %eax,%eax 125468: 83 c9 ff or $0xffffffff,%ecx 12546b: 89 d7 mov %edx,%edi 12546d: f2 ae repnz scas %es:(%edi),%al 12546f: f7 d1 not %ecx 125471: 49 dec %ecx 125472: 6a 01 push $0x1 125474: 8d 7d d4 lea -0x2c(%ebp),%edi 125477: 57 push %edi 125478: 6a 00 push $0x0 12547a: 51 push %ecx 12547b: 52 push %edx 12547c: e8 47 62 fe ff call 10b6c8 125481: 83 c4 20 add $0x20,%esp 125484: 83 ca ff or $0xffffffff,%edx 125487: 85 c0 test %eax,%eax 125489: 75 58 jne 1254e3 return -1; if ( !loc.ops->chown_h ) { 12548b: 8b 55 e0 mov -0x20(%ebp),%edx 12548e: 8b 42 18 mov 0x18(%edx),%eax 125491: 85 c0 test %eax,%eax 125493: 75 20 jne 1254b5 rtems_filesystem_freenode( &loc ); 125495: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 125498: 85 c0 test %eax,%eax <== NOT EXECUTED 12549a: 74 09 je 1254a5 <== NOT EXECUTED 12549c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12549f: 57 push %edi <== NOT EXECUTED 1254a0: ff d0 call *%eax <== NOT EXECUTED 1254a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1254a5: e8 6a 45 01 00 call 139a14 <__errno> <== NOT EXECUTED 1254aa: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1254b0: 83 ca ff or $0xffffffff,%edx <== NOT EXECUTED 1254b3: eb 2e jmp 1254e3 <== NOT EXECUTED } result = (*loc.ops->chown_h)( &loc, owner, group ); 1254b5: 52 push %edx 1254b6: 0f b7 db movzwl %bx,%ebx 1254b9: 53 push %ebx 1254ba: 0f b7 f6 movzwl %si,%esi 1254bd: 56 push %esi 1254be: 57 push %edi 1254bf: ff d0 call *%eax 1254c1: 89 c2 mov %eax,%edx rtems_filesystem_freenode( &loc ); 1254c3: 8b 45 e0 mov -0x20(%ebp),%eax 1254c6: 83 c4 10 add $0x10,%esp 1254c9: 85 c0 test %eax,%eax 1254cb: 74 16 je 1254e3 1254cd: 8b 40 1c mov 0x1c(%eax),%eax 1254d0: 85 c0 test %eax,%eax 1254d2: 74 0f je 1254e3 1254d4: 83 ec 0c sub $0xc,%esp 1254d7: 57 push %edi 1254d8: 89 55 c4 mov %edx,-0x3c(%ebp) 1254db: ff d0 call *%eax 1254dd: 83 c4 10 add $0x10,%esp 1254e0: 8b 55 c4 mov -0x3c(%ebp),%edx return result; } 1254e3: 89 d0 mov %edx,%eax 1254e5: 8d 65 f4 lea -0xc(%ebp),%esp 1254e8: 5b pop %ebx 1254e9: 5e pop %esi 1254ea: 5f pop %edi 1254eb: c9 leave 1254ec: c3 ret 001254f0 : #include int chroot( const char *pathname ) { 1254f0: 55 push %ebp 1254f1: 89 e5 mov %esp,%ebp 1254f3: 57 push %edi 1254f4: 56 push %esi 1254f5: 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) { 1254f8: 81 3d 3c f7 15 00 8c cmpl $0x16508c,0x15f73c 1254ff: 50 16 00 125502: 75 1e jne 125522 rtems_libio_set_private_env(); /* try to set a new private env*/ 125504: e8 d3 13 00 00 call 1268dc if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 125509: 81 3d 3c f7 15 00 8c cmpl $0x16508c,0x15f73c 125510: 50 16 00 125513: 75 0d jne 125522 rtems_set_errno_and_return_minus_one( ENOTSUP ); 125515: e8 fa 44 01 00 call 139a14 <__errno> <== NOT EXECUTED 12551a: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 125520: eb 22 jmp 125544 <== NOT EXECUTED } result = chdir(pathname); 125522: 83 ec 0c sub $0xc,%esp 125525: ff 75 08 pushl 0x8(%ebp) 125528: e8 5b fe ff ff call 125388 if (result) { 12552d: 83 c4 10 add $0x10,%esp 125530: 85 c0 test %eax,%eax 125532: 74 15 je 125549 rtems_set_errno_and_return_minus_one( errno ); 125534: e8 db 44 01 00 call 139a14 <__errno> <== NOT EXECUTED 125539: 89 c6 mov %eax,%esi <== NOT EXECUTED 12553b: e8 d4 44 01 00 call 139a14 <__errno> <== NOT EXECUTED 125540: 8b 00 mov (%eax),%eax <== NOT EXECUTED 125542: 89 06 mov %eax,(%esi) <== NOT EXECUTED 125544: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 125547: eb 53 jmp 12559c <== NOT EXECUTED } /* clone the new root location */ if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) { 125549: 83 ec 0c sub $0xc,%esp 12554c: 6a 00 push $0x0 12554e: 8d 45 e4 lea -0x1c(%ebp),%eax 125551: 50 push %eax 125552: 6a 00 push $0x0 125554: 6a 01 push $0x1 125556: 68 fe 38 15 00 push $0x1538fe 12555b: e8 68 61 fe ff call 10b6c8 125560: 83 c4 20 add $0x20,%esp 125563: 85 c0 test %eax,%eax 125565: 75 cd jne 125534 /* 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); 125567: 8b 15 3c f7 15 00 mov 0x15f73c,%edx 12556d: 8b 42 24 mov 0x24(%edx),%eax 125570: 85 c0 test %eax,%eax 125572: 74 13 je 125587 125574: 8b 40 1c mov 0x1c(%eax),%eax 125577: 85 c0 test %eax,%eax 125579: 74 0c je 125587 12557b: 83 ec 0c sub $0xc,%esp 12557e: 83 c2 18 add $0x18,%edx 125581: 52 push %edx 125582: ff d0 call *%eax 125584: 83 c4 10 add $0x10,%esp rtems_filesystem_root = loc; 125587: 8b 3d 3c f7 15 00 mov 0x15f73c,%edi 12558d: 83 c7 18 add $0x18,%edi 125590: 8d 75 e4 lea -0x1c(%ebp),%esi 125593: b9 05 00 00 00 mov $0x5,%ecx 125598: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 12559a: 31 c0 xor %eax,%eax return 0; } 12559c: 8d 65 f8 lea -0x8(%ebp),%esp 12559f: 5e pop %esi 1255a0: 5f pop %edi 1255a1: c9 leave 1255a2: c3 ret 0010d340 : #include "devfs.h" int devFS_close( rtems_libio_t *iop ) { 10d340: 55 push %ebp 10d341: 89 e5 mov %esp,%ebp 10d343: 83 ec 1c sub $0x1c,%esp 10d346: 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; 10d349: 8b 42 38 mov 0x38(%edx),%eax args.iop = iop; 10d34c: 89 55 ec mov %edx,-0x14(%ebp) args.flags = 0; 10d34f: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) args.mode = 0; 10d356: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) status = rtems_io_close( 10d35d: 8d 55 ec lea -0x14(%ebp),%edx 10d360: 52 push %edx 10d361: ff 70 0c pushl 0xc(%eax) 10d364: ff 70 08 pushl 0x8(%eax) 10d367: e8 48 10 00 00 call 10e3b4 10d36c: 89 c2 mov %eax,%edx np->major, np->minor, (void *) &args ); if ( status ) { 10d36e: 83 c4 10 add $0x10,%esp 10d371: 31 c0 xor %eax,%eax 10d373: 85 d2 test %edx,%edx 10d375: 74 0c je 10d383 return rtems_deviceio_errno(status); 10d377: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d37a: 52 push %edx <== NOT EXECUTED 10d37b: e8 a8 00 00 00 call 10d428 <== NOT EXECUTED 10d380: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 10d383: c9 leave 10d384: c3 ret 0010d397 : const char *pathname, int pathnamelen, int flags, rtems_filesystem_location_info_t *pathloc ) { 10d397: 55 push %ebp 10d398: 89 e5 mov %esp,%ebp 10d39a: 57 push %edi 10d39b: 56 push %esi 10d39c: 53 push %ebx 10d39d: 83 ec 1c sub $0x1c,%esp 10d3a0: 8b 4d 0c mov 0xc(%ebp),%ecx 10d3a3: 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; 10d3a6: 8b 33 mov (%ebx),%esi if (!device_name_table) 10d3a8: 85 f6 test %esi,%esi 10d3aa: 74 04 je 10d3b0 10d3ac: 31 ff xor %edi,%edi 10d3ae: eb 5a jmp 10d40a rtems_set_errno_and_return_minus_one( EFAULT ); 10d3b0: e8 db 25 00 00 call 10f990 <__errno> <== NOT EXECUTED 10d3b5: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 10d3bb: eb 60 jmp 10d41d <== NOT EXECUTED for (i = 0; i < rtems_device_table_size; i++) { if (!device_name_table[i].device_name) 10d3bd: 8b 16 mov (%esi),%edx 10d3bf: 85 d2 test %edx,%edx 10d3c1: 74 43 je 10d406 continue; if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0) 10d3c3: 50 push %eax 10d3c4: 51 push %ecx 10d3c5: 52 push %edx 10d3c6: ff 75 08 pushl 0x8(%ebp) 10d3c9: 89 55 e4 mov %edx,-0x1c(%ebp) 10d3cc: 89 4d e0 mov %ecx,-0x20(%ebp) 10d3cf: e8 c8 31 00 00 call 11059c 10d3d4: 83 c4 10 add $0x10,%esp 10d3d7: 85 c0 test %eax,%eax 10d3d9: 8b 55 e4 mov -0x1c(%ebp),%edx 10d3dc: 8b 4d e0 mov -0x20(%ebp),%ecx 10d3df: 75 25 jne 10d406 continue; if (device_name_table[i].device_name[pathnamelen] != '\0') 10d3e1: 80 3c 0a 00 cmpb $0x0,(%edx,%ecx,1) 10d3e5: 75 1f jne 10d406 continue; /* find the device, set proper values */ pathloc->node_access = (void *)&device_name_table[i]; 10d3e7: 89 33 mov %esi,(%ebx) pathloc->handlers = &devFS_file_handlers; 10d3e9: c7 43 08 68 ff 11 00 movl $0x11ff68,0x8(%ebx) pathloc->ops = &devFS_ops; 10d3f0: c7 43 0c 20 ff 11 00 movl $0x11ff20,0xc(%ebx) pathloc->mt_entry = rtems_filesystem_root.mt_entry; 10d3f7: a1 b4 ff 11 00 mov 0x11ffb4,%eax 10d3fc: 8b 40 28 mov 0x28(%eax),%eax 10d3ff: 89 43 10 mov %eax,0x10(%ebx) 10d402: 31 c0 xor %eax,%eax return 0; 10d404: eb 1a jmp 10d420 /* 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++) { 10d406: 47 inc %edi 10d407: 83 c6 14 add $0x14,%esi 10d40a: 3b 3d 48 e1 11 00 cmp 0x11e148,%edi 10d410: 72 ab jb 10d3bd pathloc->mt_entry = rtems_filesystem_root.mt_entry; return 0; } /* no such file or directory */ rtems_set_errno_and_return_minus_one( ENOENT ); 10d412: e8 79 25 00 00 call 10f990 <__errno> 10d417: c7 00 02 00 00 00 movl $0x2,(%eax) 10d41d: 83 c8 ff or $0xffffffff,%eax } 10d420: 8d 65 f4 lea -0xc(%ebp),%esp 10d423: 5b pop %ebx 10d424: 5e pop %esi 10d425: 5f pop %edi 10d426: c9 leave 10d427: 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 48 e1 11 00 14 imul $0x14,0x11e148,%eax 106d12: 50 push %eax 106d13: e8 e8 61 00 00 call 10cf00 <_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 6a 8c 00 00 call 10f990 <__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 48 e1 11 00 14 imul $0x14,0x11e148,%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 68 ff 11 00 movl $0x11ff68,0x24(%ebx) temp_mt_entry->mt_fs_root.ops = &devFS_ops; 106d45: c7 43 28 20 ff 11 00 movl $0x11ff20,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 ee 38 00 00 call 10a77c 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 8a 65 00 00 call 10d428 <== 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 ee 8b 00 00 call 10f990 <__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 c9 8b 00 00 call 10f990 <__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 88 96 00 00 call 110470 <== 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 96 8b 00 00 call 10f990 <__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 48 e1 11 00 cmp 0x11e148,%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 76 8b 00 00 call 10f990 <__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 82 39 00 00 call 10a854 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 42 65 00 00 call 10d428 <== 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 54 39 00 00 call 10a884 <== 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 e8 64 00 00 call 10d428 <== 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 28 8a 00 00 call 10f990 <__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 e4 38 00 00 call 10a8b4 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 48 64 00 00 call 10d428 <== 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 0010f78c : */ int device_close( rtems_libio_t *iop ) { 10f78c: 55 push %ebp 10f78d: 89 e5 mov %esp,%ebp 10f78f: 83 ec 1c sub $0x1c,%esp 10f792: 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; 10f795: 8b 42 38 mov 0x38(%edx),%eax args.iop = iop; 10f798: 89 55 ec mov %edx,-0x14(%ebp) args.flags = 0; 10f79b: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) args.mode = 0; 10f7a2: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) status = rtems_io_close( 10f7a9: 8d 55 ec lea -0x14(%ebp),%edx 10f7ac: 52 push %edx 10f7ad: ff 70 54 pushl 0x54(%eax) 10f7b0: ff 70 50 pushl 0x50(%eax) 10f7b3: e8 f8 11 00 00 call 1109b0 10f7b8: 89 c2 mov %eax,%edx the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) { 10f7ba: 83 c4 10 add $0x10,%esp 10f7bd: 31 c0 xor %eax,%eax 10f7bf: 85 d2 test %edx,%edx 10f7c1: 74 0c je 10f7cf return rtems_deviceio_errno(status); 10f7c3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f7c6: 52 push %edx <== NOT EXECUTED 10f7c7: e8 64 16 00 00 call 110e30 <== NOT EXECUTED 10f7cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 10f7cf: c9 leave 10f7d0: c3 ret 0010f686 : int device_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 10f686: 55 push %ebp 10f687: 89 e5 mov %esp,%ebp 10f689: 83 ec 1c sub $0x1c,%esp 10f68c: 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; 10f68f: 89 45 e8 mov %eax,-0x18(%ebp) args.command = command; 10f692: 8b 55 0c mov 0xc(%ebp),%edx 10f695: 89 55 ec mov %edx,-0x14(%ebp) args.buffer = buffer; 10f698: 8b 55 10 mov 0x10(%ebp),%edx 10f69b: 89 55 f0 mov %edx,-0x10(%ebp) the_jnode = iop->file_info; 10f69e: 8b 40 38 mov 0x38(%eax),%eax status = rtems_io_control( 10f6a1: 8d 55 e8 lea -0x18(%ebp),%edx 10f6a4: 52 push %edx 10f6a5: ff 70 54 pushl 0x54(%eax) 10f6a8: ff 70 50 pushl 0x50(%eax) 10f6ab: e8 30 13 00 00 call 1109e0 the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10f6b0: 83 c4 10 add $0x10,%esp 10f6b3: 85 c0 test %eax,%eax 10f6b5: 74 0e je 10f6c5 return rtems_deviceio_errno(status); 10f6b7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f6ba: 50 push %eax <== NOT EXECUTED 10f6bb: e8 70 17 00 00 call 110e30 <== NOT EXECUTED 10f6c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f6c3: eb 03 jmp 10f6c8 <== NOT EXECUTED return args.ioctl_return; 10f6c5: 8b 45 f4 mov -0xc(%ebp),%eax } 10f6c8: c9 leave 10f6c9: c3 ret 0010f7d1 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 10f7d1: 55 push %ebp 10f7d2: 89 e5 mov %esp,%ebp 10f7d4: 83 ec 1c sub $0x1c,%esp 10f7d7: 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; 10f7da: 8b 50 38 mov 0x38(%eax),%edx args.iop = iop; 10f7dd: 89 45 ec mov %eax,-0x14(%ebp) args.flags = iop->flags; 10f7e0: 8b 40 14 mov 0x14(%eax),%eax 10f7e3: 89 45 f0 mov %eax,-0x10(%ebp) args.mode = mode; 10f7e6: 8b 45 14 mov 0x14(%ebp),%eax 10f7e9: 89 45 f4 mov %eax,-0xc(%ebp) status = rtems_io_open( 10f7ec: 8d 45 ec lea -0x14(%ebp),%eax 10f7ef: 50 push %eax 10f7f0: ff 72 54 pushl 0x54(%edx) 10f7f3: ff 72 50 pushl 0x50(%edx) 10f7f6: e8 15 12 00 00 call 110a10 10f7fb: 89 c2 mov %eax,%edx the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10f7fd: 83 c4 10 add $0x10,%esp 10f800: 31 c0 xor %eax,%eax 10f802: 85 d2 test %edx,%edx 10f804: 74 0c je 10f812 return rtems_deviceio_errno(status); 10f806: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f809: 52 push %edx <== NOT EXECUTED 10f80a: e8 21 16 00 00 call 110e30 <== NOT EXECUTED 10f80f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10f812: c9 leave 10f813: c3 ret 0010f72b : ssize_t device_read( rtems_libio_t *iop, void *buffer, size_t count ) { 10f72b: 55 push %ebp <== NOT EXECUTED 10f72c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f72e: 53 push %ebx <== NOT EXECUTED 10f72f: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 10f732: 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; 10f735: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED args.iop = iop; 10f738: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED args.offset = iop->offset; 10f73b: 8b 48 0c mov 0xc(%eax),%ecx <== NOT EXECUTED 10f73e: 8b 58 10 mov 0x10(%eax),%ebx <== NOT EXECUTED 10f741: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED 10f744: 89 5d e4 mov %ebx,-0x1c(%ebp) <== NOT EXECUTED args.buffer = buffer; 10f747: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10f74a: 89 4d e8 mov %ecx,-0x18(%ebp) <== NOT EXECUTED args.count = count; 10f74d: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10f750: 89 4d ec mov %ecx,-0x14(%ebp) <== NOT EXECUTED args.flags = iop->flags; 10f753: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10f756: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED args.bytes_moved = 0; 10f759: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED status = rtems_io_read( 10f760: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 10f763: 50 push %eax <== NOT EXECUTED 10f764: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED 10f767: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED 10f76a: e8 d1 12 00 00 call 110a40 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10f76f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f772: 85 c0 test %eax,%eax <== NOT EXECUTED 10f774: 74 0e je 10f784 <== NOT EXECUTED return rtems_deviceio_errno(status); 10f776: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f779: 50 push %eax <== NOT EXECUTED 10f77a: e8 b1 16 00 00 call 110e30 <== NOT EXECUTED 10f77f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f782: eb 03 jmp 10f787 <== NOT EXECUTED return (ssize_t) args.bytes_moved; 10f784: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED } 10f787: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f78a: c9 leave <== NOT EXECUTED 10f78b: c3 ret <== NOT EXECUTED 0010f6ca : ssize_t device_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 10f6ca: 55 push %ebp 10f6cb: 89 e5 mov %esp,%ebp 10f6cd: 53 push %ebx 10f6ce: 83 ec 28 sub $0x28,%esp 10f6d1: 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; 10f6d4: 8b 50 38 mov 0x38(%eax),%edx args.iop = iop; 10f6d7: 89 45 dc mov %eax,-0x24(%ebp) args.offset = iop->offset; 10f6da: 8b 48 0c mov 0xc(%eax),%ecx 10f6dd: 8b 58 10 mov 0x10(%eax),%ebx 10f6e0: 89 4d e0 mov %ecx,-0x20(%ebp) 10f6e3: 89 5d e4 mov %ebx,-0x1c(%ebp) args.buffer = (void *) buffer; 10f6e6: 8b 4d 0c mov 0xc(%ebp),%ecx 10f6e9: 89 4d e8 mov %ecx,-0x18(%ebp) args.count = count; 10f6ec: 8b 4d 10 mov 0x10(%ebp),%ecx 10f6ef: 89 4d ec mov %ecx,-0x14(%ebp) args.flags = iop->flags; 10f6f2: 8b 40 14 mov 0x14(%eax),%eax 10f6f5: 89 45 f0 mov %eax,-0x10(%ebp) args.bytes_moved = 0; 10f6f8: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) status = rtems_io_write( 10f6ff: 8d 45 dc lea -0x24(%ebp),%eax 10f702: 50 push %eax 10f703: ff 72 54 pushl 0x54(%edx) 10f706: ff 72 50 pushl 0x50(%edx) 10f709: e8 62 13 00 00 call 110a70 the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10f70e: 83 c4 10 add $0x10,%esp 10f711: 85 c0 test %eax,%eax 10f713: 74 0e je 10f723 return rtems_deviceio_errno(status); 10f715: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f718: 50 push %eax <== NOT EXECUTED 10f719: e8 12 17 00 00 call 110e30 <== NOT EXECUTED 10f71e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f721: eb 03 jmp 10f726 <== NOT EXECUTED return (ssize_t) args.bytes_moved; 10f723: 8b 45 f4 mov -0xc(%ebp),%eax } 10f726: 8b 5d fc mov -0x4(%ebp),%ebx 10f729: c9 leave 10f72a: 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 27 1b 00 00 call 10a53c <== 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 08 20 12 00 mov 0x122008,%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 00125a50 : fclose(group_fp); group_fp = fopen("/etc/group", "r"); } void endgrent(void) { 125a50: 55 push %ebp <== NOT EXECUTED 125a51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125a53: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (group_fp != NULL) 125a56: a1 6c 4c 16 00 mov 0x164c6c,%eax <== NOT EXECUTED 125a5b: 85 c0 test %eax,%eax <== NOT EXECUTED 125a5d: 74 0c je 125a6b <== NOT EXECUTED fclose(group_fp); 125a5f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125a62: 50 push %eax <== NOT EXECUTED 125a63: e8 f8 40 01 00 call 139b60 <== NOT EXECUTED 125a68: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 125a6b: c9 leave <== NOT EXECUTED 125a6c: c3 ret <== NOT EXECUTED 00125a6d : fclose(passwd_fp); passwd_fp = fopen("/etc/passwd", "r"); } void endpwent(void) { 125a6d: 55 push %ebp <== NOT EXECUTED 125a6e: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125a70: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (passwd_fp != NULL) 125a73: a1 84 4b 16 00 mov 0x164b84,%eax <== NOT EXECUTED 125a78: 85 c0 test %eax,%eax <== NOT EXECUTED 125a7a: 74 0c je 125a88 <== NOT EXECUTED fclose(passwd_fp); 125a7c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125a7f: 50 push %eax <== NOT EXECUTED 125a80: e8 db 40 01 00 call 139b60 <== NOT EXECUTED 125a85: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 125a88: c9 leave <== NOT EXECUTED 125a89: 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 08 20 12 00 mov 0x122008,%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 45 e8 11 00 push $0x11e845 <== 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 43 e8 11 00 push $0x11e843 <== 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 08 20 12 00 mov 0x122008,%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 43 e8 11 00 push $0x11e843 <== 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 00134978 : #include int fchdir( int fd ) { 134978: 55 push %ebp <== NOT EXECUTED 134979: 89 e5 mov %esp,%ebp <== NOT EXECUTED 13497b: 57 push %edi <== NOT EXECUTED 13497c: 56 push %esi <== NOT EXECUTED 13497d: 53 push %ebx <== NOT EXECUTED 13497e: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 134981: 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 ); 134984: 3b 1d 04 d7 15 00 cmp 0x15d704,%ebx <== NOT EXECUTED 13498a: 73 11 jae 13499d <== NOT EXECUTED iop = rtems_libio_iop( fd ); 13498c: c1 e3 06 shl $0x6,%ebx <== NOT EXECUTED 13498f: 03 1d 30 50 16 00 add 0x165030,%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 134995: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 134998: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 13499b: 75 10 jne 1349ad <== NOT EXECUTED 13499d: e8 72 50 00 00 call 139a14 <__errno> <== NOT EXECUTED 1349a2: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 1349a8: e9 97 00 00 00 jmp 134a44 <== NOT EXECUTED /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 1349ad: a8 02 test $0x2,%al <== NOT EXECUTED 1349af: 75 10 jne 1349c1 <== NOT EXECUTED 1349b1: e8 5e 50 00 00 call 139a14 <__errno> <== NOT EXECUTED 1349b6: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1349bc: e9 83 00 00 00 jmp 134a44 <== NOT EXECUTED /* * Verify you can change directory into this node. */ if ( !iop->pathinfo.ops ) { 1349c1: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 1349c4: 85 c0 test %eax,%eax <== NOT EXECUTED 1349c6: 74 07 je 1349cf <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( !iop->pathinfo.ops->node_type_h ) { 1349c8: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 1349cb: 85 c0 test %eax,%eax <== NOT EXECUTED 1349cd: 75 0d jne 1349dc <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1349cf: e8 40 50 00 00 call 139a14 <__errno> <== NOT EXECUTED 1349d4: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1349da: eb 68 jmp 134a44 <== NOT EXECUTED } if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) != 1349dc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1349df: 83 c3 18 add $0x18,%ebx <== NOT EXECUTED 1349e2: 53 push %ebx <== NOT EXECUTED 1349e3: ff d0 call *%eax <== NOT EXECUTED 1349e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1349e8: 48 dec %eax <== NOT EXECUTED 1349e9: 74 0d je 1349f8 <== NOT EXECUTED RTEMS_FILESYSTEM_DIRECTORY ) { rtems_set_errno_and_return_minus_one( ENOTDIR ); 1349eb: e8 24 50 00 00 call 139a14 <__errno> <== NOT EXECUTED 1349f0: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 1349f6: eb 4c jmp 134a44 <== NOT EXECUTED * but note the race condition. Threads who * share their rtems_filesystem_current better * be synchronized! */ saved = rtems_filesystem_current; 1349f8: a1 3c f7 15 00 mov 0x15f73c,%eax <== NOT EXECUTED 1349fd: 8d 7d c0 lea -0x40(%ebp),%edi <== NOT EXECUTED 134a00: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 134a03: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 134a08: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED rtems_filesystem_current = iop->pathinfo; 134a0a: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 134a0d: b1 05 mov $0x5,%cl <== NOT EXECUTED 134a0f: 89 de mov %ebx,%esi <== NOT EXECUTED 134a11: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* clone the current node */ if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) { 134a13: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 134a16: 6a 00 push $0x0 <== NOT EXECUTED 134a18: 8d 45 d4 lea -0x2c(%ebp),%eax <== NOT EXECUTED 134a1b: 50 push %eax <== NOT EXECUTED 134a1c: 6a 00 push $0x0 <== NOT EXECUTED 134a1e: 6a 01 push $0x1 <== NOT EXECUTED 134a20: 68 fe 38 15 00 push $0x1538fe <== NOT EXECUTED 134a25: e8 9e 6c fd ff call 10b6c8 <== NOT EXECUTED 134a2a: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 134a2d: 85 c0 test %eax,%eax <== NOT EXECUTED 134a2f: 74 18 je 134a49 <== NOT EXECUTED /* cloning failed; restore original and bail out */ rtems_filesystem_current = saved; 134a31: 8b 3d 3c f7 15 00 mov 0x15f73c,%edi <== NOT EXECUTED 134a37: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 134a3a: 8d 75 c0 lea -0x40(%ebp),%esi <== NOT EXECUTED 134a3d: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 134a42: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 134a44: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED return -1; 134a47: eb 2f jmp 134a78 <== NOT EXECUTED } /* release the old one */ rtems_filesystem_freenode( &saved ); 134a49: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 134a4c: 85 c0 test %eax,%eax <== NOT EXECUTED 134a4e: 74 13 je 134a63 <== NOT EXECUTED 134a50: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 134a53: 85 c0 test %eax,%eax <== NOT EXECUTED 134a55: 74 0c je 134a63 <== NOT EXECUTED 134a57: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 134a5a: 8d 55 c0 lea -0x40(%ebp),%edx <== NOT EXECUTED 134a5d: 52 push %edx <== NOT EXECUTED 134a5e: ff d0 call *%eax <== NOT EXECUTED 134a60: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_current = loc; 134a63: 8b 3d 3c f7 15 00 mov 0x15f73c,%edi <== NOT EXECUTED 134a69: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 134a6c: 8d 75 d4 lea -0x2c(%ebp),%esi <== NOT EXECUTED 134a6f: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 134a74: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 134a76: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 134a78: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 134a7b: 5b pop %ebx <== NOT EXECUTED 134a7c: 5e pop %esi <== NOT EXECUTED 134a7d: 5f pop %edi <== NOT EXECUTED 134a7e: c9 leave <== NOT EXECUTED 134a7f: c3 ret <== NOT EXECUTED 00125754 : int fchmod( int fd, mode_t mode ) { 125754: 55 push %ebp <== NOT EXECUTED 125755: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125757: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12575a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 12575d: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 125760: 3b 05 04 d7 15 00 cmp 0x15d704,%eax <== NOT EXECUTED 125766: 73 11 jae 125779 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 125768: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 12576b: 03 05 30 50 16 00 add 0x165030,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 125771: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED 125774: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 125777: 75 0d jne 125786 <== NOT EXECUTED 125779: e8 96 42 01 00 call 139a14 <__errno> <== NOT EXECUTED 12577e: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 125784: eb 3a jmp 1257c0 <== NOT EXECUTED /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 125786: 80 e2 04 and $0x4,%dl <== NOT EXECUTED 125789: 75 0d jne 125798 <== NOT EXECUTED 12578b: e8 84 42 01 00 call 139a14 <__errno> <== NOT EXECUTED 125790: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 125796: eb 28 jmp 1257c0 <== NOT EXECUTED if ( !iop->handlers->fchmod_h ) 125798: 8b 50 3c mov 0x3c(%eax),%edx <== NOT EXECUTED 12579b: 83 7a 1c 00 cmpl $0x0,0x1c(%edx) <== NOT EXECUTED 12579f: 75 0d jne 1257ae <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1257a1: e8 6e 42 01 00 call 139a14 <__errno> <== NOT EXECUTED 1257a6: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1257ac: eb 12 jmp 1257c0 <== NOT EXECUTED return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode ); 1257ae: 8b 50 20 mov 0x20(%eax),%edx <== NOT EXECUTED 1257b1: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED 1257b4: 83 c0 18 add $0x18,%eax <== NOT EXECUTED 1257b7: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 1257ba: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED } 1257bd: 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 ); 1257be: ff e0 jmp *%eax <== NOT EXECUTED } 1257c0: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1257c3: c9 leave <== NOT EXECUTED 1257c4: c3 ret <== NOT EXECUTED 001257c8 : int fchown( int fd, uid_t owner, gid_t group ) { 1257c8: 55 push %ebp <== NOT EXECUTED 1257c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1257cb: 53 push %ebx <== NOT EXECUTED 1257cc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1257cf: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1257d2: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1257d5: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 1257d8: 3b 05 04 d7 15 00 cmp 0x15d704,%eax <== NOT EXECUTED 1257de: 73 11 jae 1257f1 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 1257e0: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 1257e3: 03 05 30 50 16 00 add 0x165030,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 1257e9: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED 1257ec: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 1257ef: 75 0d jne 1257fe <== NOT EXECUTED 1257f1: e8 1e 42 01 00 call 139a14 <__errno> <== NOT EXECUTED 1257f6: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 1257fc: eb 40 jmp 12583e <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 1257fe: 80 e2 04 and $0x4,%dl <== NOT EXECUTED 125801: 75 0d jne 125810 <== NOT EXECUTED 125803: e8 0c 42 01 00 call 139a14 <__errno> <== NOT EXECUTED 125808: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 12580e: eb 2e jmp 12583e <== NOT EXECUTED if ( !iop->pathinfo.ops->chown_h ) 125810: 8b 50 24 mov 0x24(%eax),%edx <== NOT EXECUTED 125813: 8b 52 18 mov 0x18(%edx),%edx <== NOT EXECUTED 125816: 85 d2 test %edx,%edx <== NOT EXECUTED 125818: 75 0d jne 125827 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 12581a: e8 f5 41 01 00 call 139a14 <__errno> <== NOT EXECUTED 12581f: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 125825: eb 17 jmp 12583e <== NOT EXECUTED return (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group ); 125827: 0f b7 db movzwl %bx,%ebx <== NOT EXECUTED 12582a: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 12582d: 0f b7 c9 movzwl %cx,%ecx <== NOT EXECUTED 125830: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED 125833: 83 c0 18 add $0x18,%eax <== NOT EXECUTED 125836: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 125839: 59 pop %ecx <== NOT EXECUTED 12583a: 5b pop %ebx <== NOT EXECUTED 12583b: 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 ); 12583c: ff e2 jmp *%edx <== NOT EXECUTED } 12583e: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 125841: 5a pop %edx <== NOT EXECUTED 125842: 5b pop %ebx <== NOT EXECUTED 125843: c9 leave <== NOT EXECUTED 125844: c3 ret <== NOT EXECUTED 00134a80 : int fcntl( int fd, int cmd, ... ) { 134a80: 55 push %ebp 134a81: 89 e5 mov %esp,%ebp 134a83: 57 push %edi 134a84: 56 push %esi 134a85: 53 push %ebx 134a86: 83 ec 0c sub $0xc,%esp 134a89: 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, ...)); 134a8c: 8d 55 10 lea 0x10(%ebp),%edx int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 134a8f: 8b 0d 04 d7 15 00 mov 0x15d704,%ecx 134a95: 39 cb cmp %ecx,%ebx 134a97: 73 16 jae 134aaf iop = rtems_libio_iop( fd ); 134a99: a1 30 50 16 00 mov 0x165030,%eax 134a9e: c1 e3 06 shl $0x6,%ebx 134aa1: 8d 1c 18 lea (%eax,%ebx,1),%ebx rtems_libio_check_is_open(iop); 134aa4: 8b 73 14 mov 0x14(%ebx),%esi 134aa7: f7 c6 00 01 00 00 test $0x100,%esi 134aad: 75 10 jne 134abf 134aaf: e8 60 4f 00 00 call 139a14 <__errno> <== NOT EXECUTED 134ab4: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 134aba: e9 fe 00 00 00 jmp 134bbd <== NOT EXECUTED /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 134abf: 83 7d 0c 09 cmpl $0x9,0xc(%ebp) 134ac3: 0f 87 c1 00 00 00 ja 134b8a 134ac9: 8b 7d 0c mov 0xc(%ebp),%edi 134acc: ff 24 bd a8 9d 15 00 jmp *0x159da8(,%edi,4) case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); 134ad3: 8b 32 mov (%edx),%esi if ( fd2 ) 134ad5: 85 f6 test %esi,%esi 134ad7: 74 10 je 134ae9 diop = rtems_libio_iop( fd2 ); 134ad9: 31 d2 xor %edx,%edx <== NOT EXECUTED 134adb: 39 ce cmp %ecx,%esi <== NOT EXECUTED 134add: 73 1c jae 134afb <== NOT EXECUTED 134adf: 89 f2 mov %esi,%edx <== NOT EXECUTED 134ae1: c1 e2 06 shl $0x6,%edx <== NOT EXECUTED 134ae4: 8d 14 10 lea (%eax,%edx,1),%edx <== NOT EXECUTED 134ae7: eb 12 jmp 134afb <== NOT EXECUTED else { /* allocate a file control block */ diop = rtems_libio_allocate(); 134ae9: e8 69 6f fd ff call 10ba57 134aee: 89 c2 mov %eax,%edx if ( diop == 0 ) { 134af0: 83 ce ff or $0xffffffff,%esi 134af3: 85 c0 test %eax,%eax 134af5: 0f 84 c5 00 00 00 je 134bc0 ret = -1; break; } } diop->handlers = iop->handlers; 134afb: 8b 43 3c mov 0x3c(%ebx),%eax 134afe: 89 42 3c mov %eax,0x3c(%edx) diop->file_info = iop->file_info; 134b01: 8b 43 38 mov 0x38(%ebx),%eax 134b04: 89 42 38 mov %eax,0x38(%edx) diop->flags = iop->flags; 134b07: 8b 43 14 mov 0x14(%ebx),%eax 134b0a: 89 42 14 mov %eax,0x14(%edx) diop->pathinfo = iop->pathinfo; 134b0d: 8d 7a 18 lea 0x18(%edx),%edi 134b10: 8d 73 18 lea 0x18(%ebx),%esi 134b13: b9 05 00 00 00 mov $0x5,%ecx 134b18: f3 a5 rep movsl %ds:(%esi),%es:(%edi) ret = (int) (diop - rtems_libio_iops); 134b1a: 89 d6 mov %edx,%esi 134b1c: 2b 35 30 50 16 00 sub 0x165030,%esi 134b22: c1 fe 06 sar $0x6,%esi 134b25: eb 70 jmp 134b97 break; case F_GETFD: /* get f_flags */ ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0); 134b27: c1 ee 0b shr $0xb,%esi 134b2a: 83 e6 01 and $0x1,%esi 134b2d: eb 6c jmp 134b9b * 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 ) ) 134b2f: 83 3a 00 cmpl $0x0,(%edx) 134b32: 74 08 je 134b3c iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; 134b34: 81 ce 00 08 00 00 or $0x800,%esi 134b3a: eb 06 jmp 134b42 else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; 134b3c: 81 e6 ff f7 ff ff and $0xfffff7ff,%esi <== NOT EXECUTED 134b42: 89 73 14 mov %esi,0x14(%ebx) 134b45: 31 f6 xor %esi,%esi 134b47: eb 52 jmp 134b9b break; case F_GETFL: /* more flags (cloexec) */ ret = rtems_libio_to_fcntl_flags( iop->flags ); 134b49: 83 ec 0c sub $0xc,%esp 134b4c: 56 push %esi 134b4d: e8 ba 6d fd ff call 10b90c 134b52: 89 c6 mov %eax,%esi 134b54: 83 c4 10 add $0x10,%esp 134b57: eb 3e jmp 134b97 break; case F_SETFL: flags = rtems_libio_fcntl_flags( va_arg( ap, int ) ); 134b59: 83 ec 0c sub $0xc,%esp 134b5c: ff 32 pushl (%edx) 134b5e: e8 7f 6f fd ff call 10bae2 /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = (iop->flags & ~mask) | (flags & mask); 134b63: 25 01 02 00 00 and $0x201,%eax 134b68: 8b 53 14 mov 0x14(%ebx),%edx 134b6b: 81 e2 fe fd ff ff and $0xfffffdfe,%edx 134b71: 09 d0 or %edx,%eax 134b73: 89 43 14 mov %eax,0x14(%ebx) 134b76: 31 f6 xor %esi,%esi 134b78: 83 c4 10 add $0x10,%esp 134b7b: eb 1e jmp 134b9b errno = ENOTSUP; ret = -1; break; case F_GETOWN: /* for sockets. */ errno = ENOTSUP; 134b7d: e8 92 4e 00 00 call 139a14 <__errno> 134b82: c7 00 86 00 00 00 movl $0x86,(%eax) 134b88: eb 33 jmp 134bbd ret = -1; break; default: errno = EINVAL; 134b8a: e8 85 4e 00 00 call 139a14 <__errno> 134b8f: c7 00 16 00 00 00 movl $0x16,(%eax) 134b95: eb 26 jmp 134bbd /* * If we got this far successfully, then we give the optional * filesystem specific handler a chance to process this. */ if (ret >= 0) { 134b97: 85 f6 test %esi,%esi 134b99: 78 25 js 134bc0 if (iop->handlers->fcntl_h) { 134b9b: 8b 43 3c mov 0x3c(%ebx),%eax 134b9e: 8b 40 30 mov 0x30(%eax),%eax 134ba1: 85 c0 test %eax,%eax 134ba3: 74 1b je 134bc0 int err = (*iop->handlers->fcntl_h)( cmd, iop ); 134ba5: 52 push %edx 134ba6: 52 push %edx 134ba7: 53 push %ebx 134ba8: ff 75 0c pushl 0xc(%ebp) 134bab: ff d0 call *%eax 134bad: 89 c3 mov %eax,%ebx if (err) { 134baf: 83 c4 10 add $0x10,%esp 134bb2: 85 c0 test %eax,%eax 134bb4: 74 0a je 134bc0 errno = err; 134bb6: e8 59 4e 00 00 call 139a14 <__errno> <== NOT EXECUTED 134bbb: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 134bbd: 83 ce ff or $0xffffffff,%esi va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; } 134bc0: 89 f0 mov %esi,%eax 134bc2: 8d 65 f4 lea -0xc(%ebp),%esp 134bc5: 5b pop %ebx 134bc6: 5e pop %esi 134bc7: 5f pop %edi 134bc8: c9 leave 134bc9: c3 ret 0010fcd7 : */ int fifo_open( pipe_control_t **pipep, rtems_libio_t *iop ) { 10fcd7: 55 push %ebp 10fcd8: 89 e5 mov %esp,%ebp 10fcda: 57 push %edi 10fcdb: 56 push %esi 10fcdc: 53 push %ebx 10fcdd: 83 ec 30 sub $0x30,%esp ) { pipe_control_t *pipe; int err = 0; if (rtems_semaphore_obtain(rtems_pipe_semaphore, 10fce0: 6a 00 push $0x0 10fce2: 6a 00 push $0x0 10fce4: ff 35 94 3e 12 00 pushl 0x123e94 10fcea: e8 8d a2 ff ff call 109f7c 10fcef: 89 c2 mov %eax,%edx 10fcf1: 83 c4 10 add $0x10,%esp 10fcf4: bf fc ff ff ff mov $0xfffffffc,%edi 10fcf9: 85 c0 test %eax,%eax 10fcfb: 0f 85 39 03 00 00 jne 11003a RTEMS_WAIT, RTEMS_NO_TIMEOUT) != RTEMS_SUCCESSFUL) return -EINTR; pipe = *pipep; 10fd01: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10fd04: 8b 18 mov (%eax),%ebx <== NOT EXECUTED if (pipe == NULL) { 10fd06: 85 db test %ebx,%ebx <== NOT EXECUTED 10fd08: 0f 85 59 01 00 00 jne 10fe67 <== NOT EXECUTED { static char c = 'a'; pipe_control_t *pipe; int err = -ENOMEM; pipe = malloc(sizeof(pipe_control_t)); 10fd0e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fd11: 6a 34 push $0x34 <== NOT EXECUTED 10fd13: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED 10fd16: e8 91 76 ff ff call 1073ac <== NOT EXECUTED 10fd1b: 89 c6 mov %eax,%esi <== NOT EXECUTED 10fd1d: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (pipe == NULL) 10fd1f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fd22: 66 bf f4 ff mov $0xfff4,%di <== NOT EXECUTED 10fd26: 85 c0 test %eax,%eax <== NOT EXECUTED 10fd28: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 10fd2b: 0f 84 6a 01 00 00 je 10fe9b <== NOT EXECUTED return err; memset(pipe, 0, sizeof(pipe_control_t)); 10fd31: b9 0d 00 00 00 mov $0xd,%ecx <== NOT EXECUTED 10fd36: 89 c7 mov %eax,%edi <== NOT EXECUTED 10fd38: 89 d0 mov %edx,%eax <== NOT EXECUTED 10fd3a: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED pipe->Size = PIPE_BUF; 10fd3c: c7 46 04 00 02 00 00 movl $0x200,0x4(%esi) <== NOT EXECUTED pipe->Buffer = malloc(pipe->Size); 10fd43: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fd46: 68 00 02 00 00 push $0x200 <== NOT EXECUTED 10fd4b: e8 5c 76 ff ff call 1073ac <== NOT EXECUTED 10fd50: 89 06 mov %eax,(%esi) <== NOT EXECUTED if (! pipe->Buffer) 10fd52: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fd55: bf f4 ff ff ff mov $0xfffffff4,%edi <== NOT EXECUTED 10fd5a: 85 c0 test %eax,%eax <== NOT EXECUTED 10fd5c: 0f 84 f7 00 00 00 je 10fe59 <== NOT EXECUTED goto err_buf; err = -EINTR; if (rtems_barrier_create( 10fd62: 8d 46 2c lea 0x2c(%esi),%eax <== NOT EXECUTED 10fd65: 50 push %eax <== NOT EXECUTED 10fd66: 6a 00 push $0x0 <== NOT EXECUTED 10fd68: 6a 00 push $0x0 <== NOT EXECUTED 10fd6a: 0f be 05 f4 1f 12 00 movsbl 0x121ff4,%eax <== NOT EXECUTED 10fd71: 0d 00 72 49 50 or $0x50497200,%eax <== NOT EXECUTED 10fd76: 50 push %eax <== NOT EXECUTED 10fd77: e8 4c 09 00 00 call 1106c8 <== NOT EXECUTED 10fd7c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fd7f: 85 c0 test %eax,%eax <== NOT EXECUTED 10fd81: 0f 85 c0 00 00 00 jne 10fe47 <== 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( 10fd87: 8d 46 30 lea 0x30(%esi),%eax <== NOT EXECUTED 10fd8a: 50 push %eax <== NOT EXECUTED 10fd8b: 6a 00 push $0x0 <== NOT EXECUTED 10fd8d: 6a 00 push $0x0 <== NOT EXECUTED 10fd8f: 0f be 05 f4 1f 12 00 movsbl 0x121ff4,%eax <== NOT EXECUTED 10fd96: 0d 00 77 49 50 or $0x50497700,%eax <== NOT EXECUTED 10fd9b: 50 push %eax <== NOT EXECUTED 10fd9c: e8 27 09 00 00 call 1106c8 <== NOT EXECUTED 10fda1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fda4: 85 c0 test %eax,%eax <== NOT EXECUTED 10fda6: 0f 85 8d 00 00 00 jne 10fe39 <== 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( 10fdac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fdaf: 8d 46 28 lea 0x28(%esi),%eax <== NOT EXECUTED 10fdb2: 50 push %eax <== NOT EXECUTED 10fdb3: 6a 00 push $0x0 <== NOT EXECUTED 10fdb5: 6a 10 push $0x10 <== NOT EXECUTED 10fdb7: 6a 01 push $0x1 <== NOT EXECUTED 10fdb9: 0f be 05 f4 1f 12 00 movsbl 0x121ff4,%eax <== NOT EXECUTED 10fdc0: 0d 00 73 49 50 or $0x50497300,%eax <== NOT EXECUTED 10fdc5: 50 push %eax <== NOT EXECUTED 10fdc6: e8 85 9f ff ff call 109d50 <== NOT EXECUTED 10fdcb: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10fdce: 85 c0 test %eax,%eax <== NOT EXECUTED 10fdd0: 75 59 jne 10fe2b <== NOT EXECUTED RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get ( Objects_Id id, Objects_Locations *location ) { return (Barrier_Control *) 10fdd2: 50 push %eax <== NOT EXECUTED 10fdd3: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED 10fdd6: 56 push %esi <== NOT EXECUTED 10fdd7: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10fdda: 68 78 4b 12 00 push $0x124b78 <== NOT EXECUTED 10fddf: e8 6c b6 ff ff call 10b450 <_Objects_Get> <== NOT EXECUTED /* Set barriers to be interruptible by signals. */ static void pipe_interruptible(pipe_control_t *pipe) { Objects_Locations location; _Barrier_Get(pipe->readBarrier, &location)->Barrier.Wait_queue.state 10fde4: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax) <== NOT EXECUTED |= STATES_INTERRUPTIBLE_BY_SIGNAL; _Thread_Enable_dispatch(); 10fdeb: e8 51 be ff ff call 10bc41 <_Thread_Enable_dispatch> <== NOT EXECUTED 10fdf0: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10fdf3: 56 push %esi <== NOT EXECUTED 10fdf4: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10fdf7: 68 78 4b 12 00 push $0x124b78 <== NOT EXECUTED 10fdfc: e8 4f b6 ff ff call 10b450 <_Objects_Get> <== NOT EXECUTED _Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state 10fe01: 81 48 4c 00 00 00 10 orl $0x10000000,0x4c(%eax) <== NOT EXECUTED |= STATES_INTERRUPTIBLE_BY_SIGNAL; _Thread_Enable_dispatch(); 10fe08: e8 34 be ff ff call 10bc41 <_Thread_Enable_dispatch> <== NOT EXECUTED #ifdef RTEMS_POSIX_API pipe_interruptible(pipe); #endif *pipep = pipe; if (c ++ == 'z') 10fe0d: a0 f4 1f 12 00 mov 0x121ff4,%al <== NOT EXECUTED 10fe12: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED 10fe15: 88 15 f4 1f 12 00 mov %dl,0x121ff4 <== NOT EXECUTED 10fe1b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fe1e: 3c 7a cmp $0x7a,%al <== NOT EXECUTED 10fe20: 75 45 jne 10fe67 <== NOT EXECUTED c = 'a'; 10fe22: c6 05 f4 1f 12 00 61 movb $0x61,0x121ff4 <== NOT EXECUTED 10fe29: eb 3c jmp 10fe67 <== NOT EXECUTED return 0; err_sem: rtems_barrier_delete(pipe->writeBarrier); 10fe2b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fe2e: ff 76 30 pushl 0x30(%esi) <== NOT EXECUTED 10fe31: e8 4a 09 00 00 call 110780 <== NOT EXECUTED 10fe36: 83 c4 10 add $0x10,%esp <== NOT EXECUTED err_wbar: rtems_barrier_delete(pipe->readBarrier); 10fe39: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fe3c: ff 76 2c pushl 0x2c(%esi) <== NOT EXECUTED 10fe3f: e8 3c 09 00 00 call 110780 <== NOT EXECUTED 10fe44: 83 c4 10 add $0x10,%esp <== NOT EXECUTED err_rbar: free(pipe->Buffer); 10fe47: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fe4a: ff 36 pushl (%esi) <== NOT EXECUTED 10fe4c: e8 2f 73 ff ff call 107180 <== NOT EXECUTED 10fe51: bf fc ff ff ff mov $0xfffffffc,%edi <== NOT EXECUTED 10fe56: 83 c4 10 add $0x10,%esp <== NOT EXECUTED err_buf: free(pipe); 10fe59: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fe5c: 56 push %esi <== NOT EXECUTED 10fe5d: e8 1e 73 ff ff call 107180 <== NOT EXECUTED 10fe62: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fe65: eb 34 jmp 10fe9b <== NOT EXECUTED err = pipe_alloc(&pipe); if (err) goto out; } if (! PIPE_LOCK(pipe)) 10fe67: 57 push %edi <== NOT EXECUTED 10fe68: 6a 00 push $0x0 <== NOT EXECUTED 10fe6a: 6a 00 push $0x0 <== NOT EXECUTED 10fe6c: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10fe6f: e8 08 a1 ff ff call 109f7c <== NOT EXECUTED 10fe74: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fe77: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10fe7a: 19 ff sbb %edi,%edi <== NOT EXECUTED 10fe7c: f7 d7 not %edi <== NOT EXECUTED 10fe7e: 83 e7 fc and $0xfffffffc,%edi <== NOT EXECUTED err = -EINTR; if (*pipep == NULL) { 10fe81: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10fe84: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 10fe87: 75 12 jne 10fe9b <== NOT EXECUTED if (err) 10fe89: 85 ff test %edi,%edi <== NOT EXECUTED 10fe8b: 74 09 je 10fe96 <== NOT EXECUTED pipe_free(pipe); 10fe8d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10fe8f: e8 38 fd ff ff call 10fbcc <== NOT EXECUTED 10fe94: eb 05 jmp 10fe9b <== NOT EXECUTED else *pipep = pipe; 10fe96: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10fe99: 89 18 mov %ebx,(%eax) <== NOT EXECUTED } out: rtems_semaphore_release(rtems_pipe_semaphore); 10fe9b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fe9e: ff 35 94 3e 12 00 pushl 0x123e94 <== NOT EXECUTED 10fea4: e8 bf a1 ff ff call 10a068 <== NOT EXECUTED pipe_control_t *pipe; uint prevCounter; int err; err = pipe_new(pipep); if (err) 10fea9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10feac: 85 ff test %edi,%edi <== NOT EXECUTED 10feae: 0f 85 86 01 00 00 jne 11003a <== NOT EXECUTED return err; pipe = *pipep; 10feb4: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10feb7: 8b 18 mov (%eax),%ebx <== NOT EXECUTED switch (LIBIO_ACCMODE(iop)) { 10feb9: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10febc: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED 10febf: 89 d0 mov %edx,%eax <== NOT EXECUTED 10fec1: 83 e0 06 and $0x6,%eax <== NOT EXECUTED 10fec4: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10fec7: 0f 84 91 00 00 00 je 10ff5e <== NOT EXECUTED 10fecd: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 10fed0: 0f 84 00 01 00 00 je 10ffd6 <== NOT EXECUTED 10fed6: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10fed9: 0f 85 39 01 00 00 jne 110018 <== NOT EXECUTED case LIBIO_FLAGS_READ: pipe->readerCounter ++; 10fedf: ff 43 20 incl 0x20(%ebx) <== NOT EXECUTED if (pipe->Readers ++ == 0) 10fee2: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10fee5: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED 10fee8: 89 53 10 mov %edx,0x10(%ebx) <== NOT EXECUTED 10feeb: 85 c0 test %eax,%eax <== NOT EXECUTED 10feed: 75 11 jne 10ff00 <== NOT EXECUTED PIPE_WAKEUPWRITERS(pipe); 10feef: 56 push %esi <== NOT EXECUTED 10fef0: 56 push %esi <== NOT EXECUTED 10fef1: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10fef4: 50 push %eax <== NOT EXECUTED 10fef5: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10fef8: e8 e3 08 00 00 call 1107e0 <== NOT EXECUTED 10fefd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (pipe->Writers == 0) { 10ff00: 83 7b 14 00 cmpl $0x0,0x14(%ebx) <== NOT EXECUTED 10ff04: 0f 85 0e 01 00 00 jne 110018 <== NOT EXECUTED /* Not an error */ if (LIBIO_NODELAY(iop)) 10ff0a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ff0d: f6 40 14 01 testb $0x1,0x14(%eax) <== NOT EXECUTED 10ff11: 0f 85 01 01 00 00 jne 110018 <== NOT EXECUTED break; prevCounter = pipe->writerCounter; 10ff17: 8b 73 24 mov 0x24(%ebx),%esi <== NOT EXECUTED err = -EINTR; /* Wait until a writer opens the pipe */ do { PIPE_UNLOCK(pipe); 10ff1a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ff1d: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10ff20: e8 43 a1 ff ff call 10a068 <== NOT EXECUTED if (! PIPE_READWAIT(pipe)) 10ff25: 5a pop %edx <== NOT EXECUTED 10ff26: 59 pop %ecx <== NOT EXECUTED 10ff27: 6a 00 push $0x0 <== NOT EXECUTED 10ff29: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10ff2c: e8 07 09 00 00 call 110838 <== NOT EXECUTED 10ff31: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ff34: 85 c0 test %eax,%eax <== NOT EXECUTED 10ff36: 0f 85 e9 00 00 00 jne 110025 <== NOT EXECUTED goto out_error; if (! PIPE_LOCK(pipe)) 10ff3c: 50 push %eax <== NOT EXECUTED 10ff3d: 6a 00 push $0x0 <== NOT EXECUTED 10ff3f: 6a 00 push $0x0 <== NOT EXECUTED 10ff41: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10ff44: e8 33 a0 ff ff call 109f7c <== NOT EXECUTED 10ff49: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ff4c: 85 c0 test %eax,%eax <== NOT EXECUTED 10ff4e: 0f 85 d1 00 00 00 jne 110025 <== NOT EXECUTED goto out_error; } while (prevCounter == pipe->writerCounter); 10ff54: 3b 73 24 cmp 0x24(%ebx),%esi <== NOT EXECUTED 10ff57: 74 c1 je 10ff1a <== NOT EXECUTED 10ff59: e9 ba 00 00 00 jmp 110018 <== NOT EXECUTED } break; case LIBIO_FLAGS_WRITE: if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) { 10ff5e: 83 7b 10 00 cmpl $0x0,0x10(%ebx) <== NOT EXECUTED 10ff62: 75 0f jne 10ff73 <== NOT EXECUTED 10ff64: 80 e2 01 and $0x1,%dl <== NOT EXECUTED 10ff67: 74 0a je 10ff73 <== NOT EXECUTED 10ff69: bf fa ff ff ff mov $0xfffffffa,%edi <== NOT EXECUTED 10ff6e: e9 b7 00 00 00 jmp 11002a <== NOT EXECUTED err = -ENXIO; goto out_error; } pipe->writerCounter ++; 10ff73: ff 43 24 incl 0x24(%ebx) <== NOT EXECUTED if (pipe->Writers ++ == 0) 10ff76: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10ff79: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED 10ff7c: 89 53 14 mov %edx,0x14(%ebx) <== NOT EXECUTED 10ff7f: 85 c0 test %eax,%eax <== NOT EXECUTED 10ff81: 75 11 jne 10ff94 <== NOT EXECUTED PIPE_WAKEUPREADERS(pipe); 10ff83: 56 push %esi <== NOT EXECUTED 10ff84: 56 push %esi <== NOT EXECUTED 10ff85: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10ff88: 50 push %eax <== NOT EXECUTED 10ff89: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10ff8c: e8 4f 08 00 00 call 1107e0 <== NOT EXECUTED 10ff91: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (pipe->Readers == 0) { 10ff94: 83 7b 10 00 cmpl $0x0,0x10(%ebx) <== NOT EXECUTED 10ff98: 75 7e jne 110018 <== NOT EXECUTED prevCounter = pipe->readerCounter; 10ff9a: 8b 73 20 mov 0x20(%ebx),%esi <== NOT EXECUTED err = -EINTR; do { PIPE_UNLOCK(pipe); 10ff9d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ffa0: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10ffa3: e8 c0 a0 ff ff call 10a068 <== NOT EXECUTED if (! PIPE_WRITEWAIT(pipe)) 10ffa8: 5a pop %edx <== NOT EXECUTED 10ffa9: 59 pop %ecx <== NOT EXECUTED 10ffaa: 6a 00 push $0x0 <== NOT EXECUTED 10ffac: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10ffaf: e8 84 08 00 00 call 110838 <== NOT EXECUTED 10ffb4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ffb7: 85 c0 test %eax,%eax <== NOT EXECUTED 10ffb9: 75 6a jne 110025 <== NOT EXECUTED goto out_error; if (! PIPE_LOCK(pipe)) 10ffbb: 50 push %eax <== NOT EXECUTED 10ffbc: 6a 00 push $0x0 <== NOT EXECUTED 10ffbe: 6a 00 push $0x0 <== NOT EXECUTED 10ffc0: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10ffc3: e8 b4 9f ff ff call 109f7c <== NOT EXECUTED 10ffc8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ffcb: 85 c0 test %eax,%eax <== NOT EXECUTED 10ffcd: 75 56 jne 110025 <== NOT EXECUTED goto out_error; } while (prevCounter == pipe->readerCounter); 10ffcf: 3b 73 20 cmp 0x20(%ebx),%esi <== NOT EXECUTED 10ffd2: 74 c9 je 10ff9d <== NOT EXECUTED 10ffd4: eb 42 jmp 110018 <== NOT EXECUTED } break; case LIBIO_FLAGS_READ_WRITE: pipe->readerCounter ++; 10ffd6: ff 43 20 incl 0x20(%ebx) <== NOT EXECUTED if (pipe->Readers ++ == 0) 10ffd9: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10ffdc: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED 10ffdf: 89 53 10 mov %edx,0x10(%ebx) <== NOT EXECUTED 10ffe2: 85 c0 test %eax,%eax <== NOT EXECUTED 10ffe4: 75 11 jne 10fff7 <== NOT EXECUTED PIPE_WAKEUPWRITERS(pipe); 10ffe6: 56 push %esi <== NOT EXECUTED 10ffe7: 56 push %esi <== NOT EXECUTED 10ffe8: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10ffeb: 50 push %eax <== NOT EXECUTED 10ffec: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10ffef: e8 ec 07 00 00 call 1107e0 <== NOT EXECUTED 10fff4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED pipe->writerCounter ++; 10fff7: ff 43 24 incl 0x24(%ebx) <== NOT EXECUTED if (pipe->Writers ++ == 0) 10fffa: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10fffd: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED 110000: 89 53 14 mov %edx,0x14(%ebx) <== NOT EXECUTED 110003: 85 c0 test %eax,%eax <== NOT EXECUTED 110005: 75 11 jne 110018 <== NOT EXECUTED PIPE_WAKEUPREADERS(pipe); 110007: 51 push %ecx <== NOT EXECUTED 110008: 51 push %ecx <== NOT EXECUTED 110009: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 11000c: 50 push %eax <== NOT EXECUTED 11000d: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 110010: e8 cb 07 00 00 call 1107e0 <== NOT EXECUTED 110015: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } PIPE_UNLOCK(pipe); 110018: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11001b: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 11001e: e8 45 a0 ff ff call 10a068 <== NOT EXECUTED 110023: eb 12 jmp 110037 <== NOT EXECUTED return 0; 110025: bf fc ff ff ff mov $0xfffffffc,%edi <== NOT EXECUTED out_error: pipe_release(pipep, iop); 11002a: 52 push %edx <== NOT EXECUTED 11002b: 52 push %edx <== NOT EXECUTED 11002c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11002f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 110032: e8 d0 fb ff ff call 10fc07 <== NOT EXECUTED return err; 110037: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 11003a: 89 f8 mov %edi,%eax 11003c: 8d 65 f4 lea -0xc(%ebp),%esp 11003f: 5b pop %ebx 110040: 5e pop %esi 110041: 5f pop %edi 110042: c9 leave 110043: 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 74 50 16 00 mov 0x165074,%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 78 50 16 00 cmp $0x165078,%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 b4 40 12 00 incl 0x1240b4 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 84 43 12 00 03 cmpl $0x3,0x124384 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 25 12 00 mov 0x122510,%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 50 01 12 00 pushl 0x120150 1071ce: e8 45 45 00 00 call 10b718 <_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 50 01 12 00 mov 0x120150,%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 09 e8 11 00 push $0x11e809 <== 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 001267f0 : * NOTE: this must be called with * thread dispatching disabled! */ static void free_user_env(void *venv) { 1267f0: 55 push %ebp <== NOT EXECUTED 1267f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1267f3: 53 push %ebx <== NOT EXECUTED 1267f4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1267f7: 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 1267fa: 81 fb 8c 50 16 00 cmp $0x16508c,%ebx <== NOT EXECUTED 126800: 74 40 je 126842 <== NOT EXECUTED #ifdef HAVE_USERENV_REFCNT && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); 126802: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 126805: 85 c0 test %eax,%eax <== NOT EXECUTED 126807: 74 13 je 12681c <== NOT EXECUTED 126809: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12680c: 85 c0 test %eax,%eax <== NOT EXECUTED 12680e: 74 0c je 12681c <== NOT EXECUTED 126810: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 126813: 8d 53 04 lea 0x4(%ebx),%edx <== NOT EXECUTED 126816: 52 push %edx <== NOT EXECUTED 126817: ff d0 call *%eax <== NOT EXECUTED 126819: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &env->root_directory); 12681c: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 12681f: 85 c0 test %eax,%eax <== NOT EXECUTED 126821: 74 13 je 126836 <== NOT EXECUTED 126823: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 126826: 85 c0 test %eax,%eax <== NOT EXECUTED 126828: 74 0c je 126836 <== NOT EXECUTED 12682a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12682d: 8d 53 18 lea 0x18(%ebx),%edx <== NOT EXECUTED 126830: 52 push %edx <== NOT EXECUTED 126831: ff d0 call *%eax <== NOT EXECUTED 126833: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free(env); 126836: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 126839: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 12683c: c9 leave <== NOT EXECUTED && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); rtems_filesystem_freenode( &env->root_directory); free(env); 12683d: e9 2e 4f fe ff jmp 10b770 <== NOT EXECUTED } } 126842: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 126845: c9 leave <== NOT EXECUTED 126846: c3 ret <== NOT EXECUTED 0011c810 : int fstat( int fd, struct stat *sbuf ) { 11c810: 55 push %ebp 11c811: 89 e5 mov %esp,%ebp 11c813: 57 push %edi 11c814: 53 push %ebx 11c815: 8b 55 08 mov 0x8(%ebp),%edx 11c818: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) 11c81b: 85 db test %ebx,%ebx 11c81d: 75 0d jne 11c82c rtems_set_errno_and_return_minus_one( EFAULT ); 11c81f: e8 30 4d ff ff call 111554 <__errno> 11c824: c7 00 0e 00 00 00 movl $0xe,(%eax) 11c82a: eb 5d jmp 11c889 /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); 11c82c: 3b 15 44 01 12 00 cmp 0x120144,%edx 11c832: 73 16 jae 11c84a 11c834: c1 e2 06 shl $0x6,%edx 11c837: 03 15 90 40 12 00 add 0x124090,%edx rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); 11c83d: f6 42 15 01 testb $0x1,0x15(%edx) 11c841: 74 07 je 11c84a if ( !iop->handlers ) 11c843: 8b 42 3c mov 0x3c(%edx),%eax 11c846: 85 c0 test %eax,%eax 11c848: 75 0d jne 11c857 rtems_set_errno_and_return_minus_one( EBADF ); 11c84a: e8 05 4d ff ff call 111554 <__errno> 11c84f: c7 00 09 00 00 00 movl $0x9,(%eax) 11c855: eb 32 jmp 11c889 if ( !iop->handlers->fstat_h ) 11c857: 83 78 18 00 cmpl $0x0,0x18(%eax) 11c85b: 75 0d jne 11c86a rtems_set_errno_and_return_minus_one( ENOTSUP ); 11c85d: e8 f2 4c ff ff call 111554 <__errno> <== NOT EXECUTED 11c862: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11c868: eb 1f jmp 11c889 <== NOT EXECUTED /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); 11c86a: b9 12 00 00 00 mov $0x12,%ecx 11c86f: 31 c0 xor %eax,%eax 11c871: 89 df mov %ebx,%edi 11c873: f3 ab rep stos %eax,%es:(%edi) return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf ); 11c875: 8b 42 3c mov 0x3c(%edx),%eax 11c878: 89 5d 0c mov %ebx,0xc(%ebp) 11c87b: 83 c2 18 add $0x18,%edx 11c87e: 89 55 08 mov %edx,0x8(%ebp) 11c881: 8b 40 18 mov 0x18(%eax),%eax } 11c884: 5b pop %ebx 11c885: 5f pop %edi 11c886: 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 ); 11c887: ff e0 jmp *%eax } 11c889: 83 c8 ff or $0xffffffff,%eax 11c88c: 5b pop %ebx 11c88d: 5f pop %edi 11c88e: c9 leave 11c88f: c3 ret 001258e0 : #include int fsync( int fd ) { 1258e0: 55 push %ebp 1258e1: 89 e5 mov %esp,%ebp 1258e3: 83 ec 08 sub $0x8,%esp 1258e6: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_t *iop; rtems_libio_check_fd( fd ); 1258e9: 3b 05 04 d7 15 00 cmp 0x15d704,%eax 1258ef: 73 2a jae 12591b iop = rtems_libio_iop( fd ); 1258f1: c1 e0 06 shl $0x6,%eax 1258f4: 03 05 30 50 16 00 add 0x165030,%eax rtems_libio_check_is_open(iop); 1258fa: 8b 50 14 mov 0x14(%eax),%edx 1258fd: f6 c6 01 test $0x1,%dh 125900: 74 19 je 12591b rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 125902: 80 e2 04 and $0x4,%dl 125905: 75 0d jne 125914 125907: e8 08 41 01 00 call 139a14 <__errno> 12590c: c7 00 16 00 00 00 movl $0x16,(%eax) 125912: eb 2e jmp 125942 /* * Now process the fsync(). */ if ( !iop->handlers ) 125914: 8b 50 3c mov 0x3c(%eax),%edx 125917: 85 d2 test %edx,%edx 125919: 75 0d jne 125928 rtems_set_errno_and_return_minus_one( EBADF ); 12591b: e8 f4 40 01 00 call 139a14 <__errno> <== NOT EXECUTED 125920: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 125926: eb 1a jmp 125942 <== NOT EXECUTED if ( !iop->handlers->fsync_h ) 125928: 8b 52 28 mov 0x28(%edx),%edx 12592b: 85 d2 test %edx,%edx 12592d: 75 0d jne 12593c rtems_set_errno_and_return_minus_one( ENOTSUP ); 12592f: e8 e0 40 01 00 call 139a14 <__errno> 125934: c7 00 86 00 00 00 movl $0x86,(%eax) 12593a: eb 06 jmp 125942 return (*iop->handlers->fsync_h)( iop ); 12593c: 89 45 08 mov %eax,0x8(%ebp) } 12593f: 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 ); 125940: ff e2 jmp *%edx } 125942: 83 c8 ff or $0xffffffff,%eax 125945: c9 leave 125946: c3 ret 0010dcfc : int ftruncate( int fd, off_t length ) { 10dcfc: 55 push %ebp 10dcfd: 89 e5 mov %esp,%ebp 10dcff: 57 push %edi 10dd00: 56 push %esi 10dd01: 53 push %ebx 10dd02: 83 ec 3c sub $0x3c,%esp 10dd05: 8b 5d 08 mov 0x8(%ebp),%ebx 10dd08: 8b 45 0c mov 0xc(%ebp),%eax 10dd0b: 8b 55 10 mov 0x10(%ebp),%edx 10dd0e: 89 45 c0 mov %eax,-0x40(%ebp) 10dd11: 89 55 c4 mov %edx,-0x3c(%ebp) rtems_libio_t *iop; rtems_filesystem_location_info_t loc; rtems_libio_check_fd( fd ); 10dd14: 3b 1d 44 01 12 00 cmp 0x120144,%ebx 10dd1a: 73 0f jae 10dd2b iop = rtems_libio_iop( fd ); 10dd1c: c1 e3 06 shl $0x6,%ebx 10dd1f: 03 1d 90 40 12 00 add 0x124090,%ebx rtems_libio_check_is_open(iop); 10dd25: f6 43 15 01 testb $0x1,0x15(%ebx) 10dd29: 75 0d jne 10dd38 10dd2b: e8 24 38 00 00 call 111554 <__errno> <== NOT EXECUTED 10dd30: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10dd36: eb 5b jmp 10dd93 <== NOT EXECUTED /* * Make sure we are not working on a directory */ loc = iop->pathinfo; 10dd38: 8d 7d d4 lea -0x2c(%ebp),%edi 10dd3b: 8d 73 18 lea 0x18(%ebx),%esi 10dd3e: b9 05 00 00 00 mov $0x5,%ecx 10dd43: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !loc.ops->node_type_h ) 10dd45: 8b 45 e0 mov -0x20(%ebp),%eax 10dd48: 8b 40 10 mov 0x10(%eax),%eax 10dd4b: 85 c0 test %eax,%eax 10dd4d: 74 39 je 10dd88 rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) 10dd4f: 83 ec 0c sub $0xc,%esp 10dd52: 8d 55 d4 lea -0x2c(%ebp),%edx 10dd55: 52 push %edx 10dd56: ff d0 call *%eax 10dd58: 83 c4 10 add $0x10,%esp 10dd5b: 48 dec %eax 10dd5c: 75 0d jne 10dd6b rtems_set_errno_and_return_minus_one( EISDIR ); 10dd5e: e8 f1 37 00 00 call 111554 <__errno> 10dd63: c7 00 15 00 00 00 movl $0x15,(%eax) 10dd69: eb 28 jmp 10dd93 rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 10dd6b: f6 43 14 04 testb $0x4,0x14(%ebx) 10dd6f: 75 0d jne 10dd7e 10dd71: e8 de 37 00 00 call 111554 <__errno> <== NOT EXECUTED 10dd76: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10dd7c: eb 15 jmp 10dd93 <== NOT EXECUTED if ( !iop->handlers->ftruncate_h ) 10dd7e: 8b 43 3c mov 0x3c(%ebx),%eax 10dd81: 8b 40 20 mov 0x20(%eax),%eax 10dd84: 85 c0 test %eax,%eax 10dd86: 75 10 jne 10dd98 rtems_set_errno_and_return_minus_one( ENOTSUP ); 10dd88: e8 c7 37 00 00 call 111554 <__errno> <== NOT EXECUTED 10dd8d: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10dd93: 83 c8 ff or $0xffffffff,%eax 10dd96: eb 0d jmp 10dda5 return (*iop->handlers->ftruncate_h)( iop, length ); 10dd98: 52 push %edx 10dd99: ff 75 c4 pushl -0x3c(%ebp) 10dd9c: ff 75 c0 pushl -0x40(%ebp) 10dd9f: 53 push %ebx 10dda0: ff d0 call *%eax 10dda2: 83 c4 10 add $0x10,%esp } 10dda5: 8d 65 f4 lea -0xc(%ebp),%esp 10dda8: 5b pop %ebx 10dda9: 5e pop %esi 10ddaa: 5f pop %edi 10ddab: c9 leave 10ddac: c3 ret 0014f8cc : int getdents( int dd_fd, char *dd_buf, int dd_len ) { 14f8cc: 55 push %ebp 14f8cd: 89 e5 mov %esp,%ebp 14f8cf: 57 push %edi 14f8d0: 56 push %esi 14f8d1: 53 push %ebx 14f8d2: 83 ec 2c sub $0x2c,%esp 14f8d5: 8b 45 08 mov 0x8(%ebp),%eax /* * Get the file control block structure associated with the file descriptor */ iop = rtems_libio_iop( dd_fd ); 14f8d8: 31 db xor %ebx,%ebx 14f8da: 3b 05 04 d7 15 00 cmp 0x15d704,%eax 14f8e0: 73 0b jae 14f8ed 14f8e2: 89 c3 mov %eax,%ebx 14f8e4: c1 e3 06 shl $0x6,%ebx 14f8e7: 03 1d 30 50 16 00 add 0x165030,%ebx /* * Make sure we are working on a directory */ loc = iop->pathinfo; 14f8ed: 8d 7d d4 lea -0x2c(%ebp),%edi 14f8f0: 8d 73 18 lea 0x18(%ebx),%esi 14f8f3: b9 05 00 00 00 mov $0x5,%ecx 14f8f8: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !loc.ops->node_type_h ) 14f8fa: 8b 45 e0 mov -0x20(%ebp),%eax 14f8fd: 8b 40 10 mov 0x10(%eax),%eax 14f900: 85 c0 test %eax,%eax 14f902: 74 29 je 14f92d rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) 14f904: 83 ec 0c sub $0xc,%esp 14f907: 8d 55 d4 lea -0x2c(%ebp),%edx 14f90a: 52 push %edx 14f90b: ff d0 call *%eax 14f90d: 83 c4 10 add $0x10,%esp 14f910: 48 dec %eax 14f911: 74 10 je 14f923 rtems_set_errno_and_return_minus_one( ENOTDIR ); 14f913: e8 fc a0 fe ff call 139a14 <__errno> 14f918: c7 00 14 00 00 00 movl $0x14,(%eax) 14f91e: 83 c8 ff or $0xffffffff,%eax 14f921: eb 24 jmp 14f947 /* * Return the number of bytes that were actually transfered as a result * of the read attempt. */ if ( !iop->handlers->read_h ) 14f923: 8b 43 3c mov 0x3c(%ebx),%eax 14f926: 8b 40 08 mov 0x8(%eax),%eax 14f929: 85 c0 test %eax,%eax 14f92b: 75 0d jne 14f93a rtems_set_errno_and_return_minus_one( ENOTSUP ); 14f92d: e8 e2 a0 fe ff call 139a14 <__errno> <== NOT EXECUTED 14f932: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 14f938: eb e4 jmp 14f91e <== NOT EXECUTED return (*iop->handlers->read_h)( iop, dd_buf, dd_len ); 14f93a: 52 push %edx 14f93b: ff 75 10 pushl 0x10(%ebp) 14f93e: ff 75 0c pushl 0xc(%ebp) 14f941: 53 push %ebx 14f942: ff d0 call *%eax 14f944: 83 c4 10 add $0x10,%esp } 14f947: 8d 65 f4 lea -0xc(%ebp),%esp 14f94a: 5b pop %ebx 14f94b: 5e pop %esi 14f94c: 5f pop %edi 14f94d: c9 leave 14f94e: c3 ret 00125a1c : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ gid_t getgid( void ) { 125a1c: 55 push %ebp <== NOT EXECUTED 125a1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125a1f: a1 3c f7 15 00 mov 0x15f73c,%eax <== NOT EXECUTED 125a24: 8b 40 34 mov 0x34(%eax),%eax <== NOT EXECUTED return _POSIX_types_Gid; } 125a27: c9 leave <== NOT EXECUTED 125a28: c3 ret <== NOT EXECUTED 00125f3a : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 125f3a: 55 push %ebp 125f3b: 89 e5 mov %esp,%ebp 125f3d: 57 push %edi 125f3e: 56 push %esi 125f3f: 53 push %ebx 125f40: 83 ec 1c sub $0x1c,%esp 125f43: 89 c7 mov %eax,%edi 125f45: 89 55 e4 mov %edx,-0x1c(%ebp) 125f48: 89 ce mov %ecx,%esi FILE *fp; int match; init_etc_passwd_group(); 125f4a: e8 df fe ff ff call 125e2e if ((fp = fopen("/etc/group", "r")) == NULL) { 125f4f: 53 push %ebx 125f50: 53 push %ebx 125f51: 68 0b 2f 15 00 push $0x152f0b 125f56: 68 65 05 15 00 push $0x150565 125f5b: e8 18 44 01 00 call 13a378 125f60: 89 c3 mov %eax,%ebx 125f62: 83 c4 10 add $0x10,%esp 125f65: 85 c0 test %eax,%eax 125f67: 75 10 jne 125f79 errno = EINVAL; 125f69: e8 a6 3a 01 00 call 139a14 <__errno> <== NOT EXECUTED 125f6e: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 125f74: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED return -1; 125f77: eb 6b jmp 125fe4 <== NOT EXECUTED } for(;;) { if (!scangr(fp, grp, buffer, bufsize)) { 125f79: 83 ec 0c sub $0xc,%esp 125f7c: ff 75 0c pushl 0xc(%ebp) 125f7f: 8b 4d 08 mov 0x8(%ebp),%ecx 125f82: 89 f2 mov %esi,%edx 125f84: 89 d8 mov %ebx,%eax 125f86: e8 39 fc ff ff call 125bc4 125f8b: 83 c4 10 add $0x10,%esp 125f8e: 85 c0 test %eax,%eax 125f90: 75 19 jne 125fab errno = EINVAL; 125f92: e8 7d 3a 01 00 call 139a14 <__errno> <== NOT EXECUTED 125f97: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED fclose(fp); 125f9d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125fa0: 53 push %ebx <== NOT EXECUTED 125fa1: e8 ba 3b 01 00 call 139b60 <== NOT EXECUTED 125fa6: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 125fa9: eb 36 jmp 125fe1 <== NOT EXECUTED return -1; } if (name) { 125fab: 85 ff test %edi,%edi 125fad: 74 11 je 125fc0 match = (strcmp(grp->gr_name, name) == 0); 125faf: 51 push %ecx 125fb0: 51 push %ecx 125fb1: 57 push %edi 125fb2: ff 36 pushl (%esi) 125fb4: e8 73 91 01 00 call 13f12c 125fb9: 83 c4 10 add $0x10,%esp 125fbc: 85 c0 test %eax,%eax 125fbe: eb 07 jmp 125fc7 } else { match = (grp->gr_gid == gid); 125fc0: 0f b7 46 08 movzwl 0x8(%esi),%eax <== NOT EXECUTED 125fc4: 3b 45 e4 cmp -0x1c(%ebp),%eax <== NOT EXECUTED 125fc7: 0f 94 c0 sete %al 125fca: 0f b6 c0 movzbl %al,%eax } if (match) { 125fcd: 85 c0 test %eax,%eax 125fcf: 74 a8 je 125f79 fclose(fp); 125fd1: 83 ec 0c sub $0xc,%esp 125fd4: 53 push %ebx 125fd5: e8 86 3b 01 00 call 139b60 *result = grp; 125fda: 8b 45 10 mov 0x10(%ebp),%eax 125fdd: 89 30 mov %esi,(%eax) 125fdf: 31 c0 xor %eax,%eax return 0; 125fe1: 83 c4 10 add $0x10,%esp } } fclose(fp); errno = EINVAL; return -1; } 125fe4: 8d 65 f4 lea -0xc(%ebp),%esp 125fe7: 5b pop %ebx 125fe8: 5e pop %esi 125fe9: 5f pop %edi 125fea: c9 leave 125feb: c3 ret 00125cc3 : return NULL; return p; } struct group *getgrent(void) { 125cc3: 55 push %ebp <== NOT EXECUTED 125cc4: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125cc6: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (group_fp == NULL) 125cc9: a1 6c 4c 16 00 mov 0x164c6c,%eax <== NOT EXECUTED 125cce: 85 c0 test %eax,%eax <== NOT EXECUTED 125cd0: 74 25 je 125cf7 <== NOT EXECUTED return NULL; if (!scangr(group_fp, &grent, grbuf, sizeof grbuf)) 125cd2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125cd5: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 125cda: b9 70 4c 16 00 mov $0x164c70,%ecx <== NOT EXECUTED 125cdf: ba 38 4d 16 00 mov $0x164d38,%edx <== NOT EXECUTED 125ce4: e8 db fe ff ff call 125bc4 <== NOT EXECUTED 125ce9: 89 c2 mov %eax,%edx <== NOT EXECUTED 125ceb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125cee: b8 38 4d 16 00 mov $0x164d38,%eax <== NOT EXECUTED 125cf3: 85 d2 test %edx,%edx <== NOT EXECUTED 125cf5: 75 02 jne 125cf9 <== NOT EXECUTED 125cf7: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; return &grent; } 125cf9: c9 leave <== NOT EXECUTED 125cfa: c3 ret <== NOT EXECUTED 00126016 : } struct group *getgrgid( gid_t gid ) { 126016: 55 push %ebp <== NOT EXECUTED 126017: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126019: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct group *p; if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p)) 12601c: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 12601f: 50 push %eax <== NOT EXECUTED 126020: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 126025: 68 70 4c 16 00 push $0x164c70 <== NOT EXECUTED 12602a: 68 38 4d 16 00 push $0x164d38 <== NOT EXECUTED 12602f: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED 126033: 50 push %eax <== NOT EXECUTED 126034: e8 b3 ff ff ff call 125fec <== NOT EXECUTED 126039: 89 c2 mov %eax,%edx <== NOT EXECUTED 12603b: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 12603e: 31 c0 xor %eax,%eax <== NOT EXECUTED 126040: 85 d2 test %edx,%edx <== NOT EXECUTED 126042: 75 03 jne 126047 <== NOT EXECUTED return NULL; return p; 126044: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED } 126047: c9 leave <== NOT EXECUTED 126048: c3 ret <== NOT EXECUTED 00125fec : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 125fec: 55 push %ebp <== NOT EXECUTED 125fed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125fef: 53 push %ebx <== NOT EXECUTED 125ff0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 125ff3: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 125ff6: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED return getgr_r(NULL, gid, grp, buffer, bufsize, result); 125ff9: 0f b7 55 08 movzwl 0x8(%ebp),%edx <== NOT EXECUTED 125ffd: 8b 5d 18 mov 0x18(%ebp),%ebx <== NOT EXECUTED 126000: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 126003: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 126006: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 126009: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 12600c: 31 c0 xor %eax,%eax <== NOT EXECUTED } 12600e: 5b pop %ebx <== NOT EXECUTED 12600f: 5b pop %ebx <== NOT EXECUTED 126010: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct group **result ) { return getgr_r(NULL, gid, grp, buffer, bufsize, result); 126011: e9 24 ff ff ff jmp 125f3a <== NOT EXECUTED 001260de : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 1260de: 55 push %ebp 1260df: 89 e5 mov %esp,%ebp 1260e1: 57 push %edi 1260e2: 56 push %esi 1260e3: 53 push %ebx 1260e4: 83 ec 1c sub $0x1c,%esp 1260e7: 89 c7 mov %eax,%edi 1260e9: 89 55 e4 mov %edx,-0x1c(%ebp) 1260ec: 89 ce mov %ecx,%esi FILE *fp; int match; init_etc_passwd_group(); 1260ee: e8 3b fd ff ff call 125e2e if ((fp = fopen("/etc/passwd", "r")) == NULL) { 1260f3: 51 push %ecx 1260f4: 51 push %ecx 1260f5: 68 0b 2f 15 00 push $0x152f0b 1260fa: 68 20 05 15 00 push $0x150520 1260ff: e8 74 42 01 00 call 13a378 126104: 89 c3 mov %eax,%ebx 126106: 83 c4 10 add $0x10,%esp 126109: 85 c0 test %eax,%eax 12610b: 75 10 jne 12611d errno = EINVAL; 12610d: e8 02 39 01 00 call 139a14 <__errno> <== NOT EXECUTED 126112: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 126118: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED return -1; 12611b: eb 6b jmp 126188 <== NOT EXECUTED } for(;;) { if (!scanpw(fp, pwd, buffer, bufsize)) { 12611d: 83 ec 0c sub $0xc,%esp 126120: ff 75 0c pushl 0xc(%ebp) 126123: 8b 4d 08 mov 0x8(%ebp),%ecx 126126: 89 f2 mov %esi,%edx 126128: 89 d8 mov %ebx,%eax 12612a: e8 cc fb ff ff call 125cfb 12612f: 83 c4 10 add $0x10,%esp 126132: 85 c0 test %eax,%eax 126134: 75 19 jne 12614f errno = EINVAL; 126136: e8 d9 38 01 00 call 139a14 <__errno> <== NOT EXECUTED 12613b: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED fclose(fp); 126141: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 126144: 53 push %ebx <== NOT EXECUTED 126145: e8 16 3a 01 00 call 139b60 <== NOT EXECUTED 12614a: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 12614d: eb 36 jmp 126185 <== NOT EXECUTED return -1; } if (name) { 12614f: 85 ff test %edi,%edi 126151: 74 11 je 126164 match = (strcmp(pwd->pw_name, name) == 0); 126153: 52 push %edx 126154: 52 push %edx 126155: 57 push %edi 126156: ff 36 pushl (%esi) 126158: e8 cf 8f 01 00 call 13f12c 12615d: 83 c4 10 add $0x10,%esp 126160: 85 c0 test %eax,%eax 126162: eb 07 jmp 12616b } else { match = (pwd->pw_uid == uid); 126164: 0f b7 46 08 movzwl 0x8(%esi),%eax <== NOT EXECUTED 126168: 3b 45 e4 cmp -0x1c(%ebp),%eax <== NOT EXECUTED 12616b: 0f 94 c0 sete %al 12616e: 0f b6 c0 movzbl %al,%eax } if (match) { 126171: 85 c0 test %eax,%eax 126173: 74 a8 je 12611d fclose(fp); 126175: 83 ec 0c sub $0xc,%esp 126178: 53 push %ebx 126179: e8 e2 39 01 00 call 139b60 *result = pwd; 12617e: 8b 45 10 mov 0x10(%ebp),%eax 126181: 89 30 mov %esi,(%eax) 126183: 31 c0 xor %eax,%eax return 0; 126185: 83 c4 10 add $0x10,%esp } } fclose(fp); errno = EINVAL; return -1; } 126188: 8d 65 f4 lea -0xc(%ebp),%esp 12618b: 5b pop %ebx 12618c: 5e pop %esi 12618d: 5f pop %edi 12618e: c9 leave 12618f: c3 ret 00125df6 : return NULL; return p; } struct passwd *getpwent(void) { 125df6: 55 push %ebp <== NOT EXECUTED 125df7: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125df9: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (passwd_fp == NULL) 125dfc: a1 84 4b 16 00 mov 0x164b84,%eax <== NOT EXECUTED 125e01: 85 c0 test %eax,%eax <== NOT EXECUTED 125e03: 74 25 je 125e2a <== NOT EXECUTED return NULL; if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf)) 125e05: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125e08: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 125e0d: b9 88 4b 16 00 mov $0x164b88,%ecx <== NOT EXECUTED 125e12: ba 50 4c 16 00 mov $0x164c50,%edx <== NOT EXECUTED 125e17: e8 df fe ff ff call 125cfb <== NOT EXECUTED 125e1c: 89 c2 mov %eax,%edx <== NOT EXECUTED 125e1e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125e21: b8 50 4c 16 00 mov $0x164c50,%eax <== NOT EXECUTED 125e26: 85 d2 test %edx,%edx <== NOT EXECUTED 125e28: 75 02 jne 125e2c <== NOT EXECUTED 125e2a: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; return &pwent; } 125e2c: c9 leave <== NOT EXECUTED 125e2d: c3 ret <== NOT EXECUTED 001261ba : } struct passwd *getpwuid( uid_t uid ) { 1261ba: 55 push %ebp <== NOT EXECUTED 1261bb: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1261bd: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct passwd *p; if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p)) 1261c0: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1261c3: 50 push %eax <== NOT EXECUTED 1261c4: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 1261c9: 68 88 4b 16 00 push $0x164b88 <== NOT EXECUTED 1261ce: 68 50 4c 16 00 push $0x164c50 <== NOT EXECUTED 1261d3: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED 1261d7: 50 push %eax <== NOT EXECUTED 1261d8: e8 b3 ff ff ff call 126190 <== NOT EXECUTED 1261dd: 89 c2 mov %eax,%edx <== NOT EXECUTED 1261df: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1261e2: 31 c0 xor %eax,%eax <== NOT EXECUTED 1261e4: 85 d2 test %edx,%edx <== NOT EXECUTED 1261e6: 75 03 jne 1261eb <== NOT EXECUTED return NULL; return p; 1261e8: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED } 1261eb: c9 leave <== NOT EXECUTED 1261ec: c3 ret <== NOT EXECUTED 00126190 : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 126190: 55 push %ebp <== NOT EXECUTED 126191: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126193: 53 push %ebx <== NOT EXECUTED 126194: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 126197: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 12619a: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED return getpw_r(NULL, uid, pwd, buffer, bufsize, result); 12619d: 0f b7 55 08 movzwl 0x8(%ebp),%edx <== NOT EXECUTED 1261a1: 8b 5d 18 mov 0x18(%ebp),%ebx <== NOT EXECUTED 1261a4: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 1261a7: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 1261aa: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 1261ad: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 1261b0: 31 c0 xor %eax,%eax <== NOT EXECUTED } 1261b2: 5b pop %ebx <== NOT EXECUTED 1261b3: 5b pop %ebx <== NOT EXECUTED 1261b4: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct passwd **result ) { return getpw_r(NULL, uid, pwd, buffer, bufsize, result); 1261b5: e9 24 ff ff ff jmp 1260de <== NOT EXECUTED 0010ddd0 : */ int gettimeofday( struct timeval *tp, void * __tz __attribute__((unused)) ) { 10ddd0: 55 push %ebp 10ddd1: 89 e5 mov %esp,%ebp 10ddd3: 56 push %esi 10ddd4: 53 push %ebx 10ddd5: 83 ec 10 sub $0x10,%esp 10ddd8: 8b 5d 08 mov 0x8(%ebp),%ebx /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) { 10dddb: 85 db test %ebx,%ebx 10dddd: 75 10 jne 10ddef errno = EFAULT; 10dddf: e8 70 37 00 00 call 111554 <__errno> <== NOT EXECUTED 10dde4: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 10ddea: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED return -1; 10dded: eb 29 jmp 10de18 <== NOT EXECUTED { ISR_Level level; struct timespec now; suseconds_t useconds; _ISR_Disable(level); 10ddef: 9c pushf 10ddf0: fa cli 10ddf1: 5e pop %esi _TOD_Get( &now ); 10ddf2: 83 ec 0c sub $0xc,%esp 10ddf5: 8d 45 f0 lea -0x10(%ebp),%eax 10ddf8: 50 push %eax 10ddf9: e8 02 10 00 00 call 10ee00 <_TOD_Get> _ISR_Enable(level); 10ddfe: 56 push %esi 10ddff: 9d popf useconds = (suseconds_t)now.tv_nsec; 10de00: 8b 45 f4 mov -0xc(%ebp),%eax useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND; time->tv_sec = now.tv_sec; 10de03: 8b 55 f0 mov -0x10(%ebp),%edx 10de06: 89 13 mov %edx,(%ebx) time->tv_usec = useconds; 10de08: b9 e8 03 00 00 mov $0x3e8,%ecx 10de0d: 99 cltd 10de0e: f7 f9 idiv %ecx 10de10: 89 43 04 mov %eax,0x4(%ebx) 10de13: 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; 10de15: 83 c4 10 add $0x10,%esp } 10de18: 8d 65 f8 lea -0x8(%ebp),%esp 10de1b: 5b pop %ebx 10de1c: 5e pop %esi 10de1d: c9 leave 10de1e: 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 3c f7 15 00 mov 0x15f73c,%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 00114e58 : int imfs_dir_rmnod( rtems_filesystem_location_info_t *parent_pathloc, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN */ ) { 114e58: 55 push %ebp 114e59: 89 e5 mov %esp,%ebp 114e5b: 56 push %esi 114e5c: 53 push %ebx 114e5d: 83 ec 10 sub $0x10,%esp 114e60: 8b 75 0c mov 0xc(%ebp),%esi IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 114e63: 8b 1e mov (%esi),%ebx 114e65: 8d 43 54 lea 0x54(%ebx),%eax 114e68: 39 43 50 cmp %eax,0x50(%ebx) 114e6b: 74 0d je 114e7a /* * 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 ); 114e6d: e8 de 0d 00 00 call 115c50 <__errno> 114e72: c7 00 5a 00 00 00 movl $0x5a,(%eax) 114e78: eb 19 jmp 114e93 /* * You cannot remove the file system root node. */ if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access ) 114e7a: 8b 46 10 mov 0x10(%esi),%eax 114e7d: 39 58 1c cmp %ebx,0x1c(%eax) 114e80: 74 06 je 114e88 /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) 114e82: 83 7b 5c 00 cmpl $0x0,0x5c(%ebx) 114e86: 74 10 je 114e98 rtems_set_errno_and_return_minus_one( EBUSY ); 114e88: e8 c3 0d 00 00 call 115c50 <__errno> 114e8d: c7 00 10 00 00 00 movl $0x10,(%eax) 114e93: 83 c8 ff or $0xffffffff,%eax 114e96: eb 6b jmp 114f03 /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 114e98: 83 7b 08 00 cmpl $0x0,0x8(%ebx) 114e9c: 74 13 je 114eb1 114e9e: 83 ec 0c sub $0xc,%esp 114ea1: 53 push %ebx 114ea2: e8 49 6f ff ff call 10bdf0 <_Chain_Extract> rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 114ea7: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) 114eae: 83 c4 10 add $0x10,%esp /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 114eb1: 66 ff 4b 34 decw 0x34(%ebx) IMFS_update_ctime( the_jnode ); 114eb5: 50 push %eax 114eb6: 50 push %eax 114eb7: 6a 00 push $0x0 114eb9: 8d 45 f0 lea -0x10(%ebp),%eax 114ebc: 50 push %eax 114ebd: e8 a2 34 ff ff call 108364 114ec2: 8b 45 f0 mov -0x10(%ebp),%eax 114ec5: 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) ) { 114ec8: 89 1c 24 mov %ebx,(%esp) 114ecb: e8 b2 d1 ff ff call 112082 114ed0: 83 c4 10 add $0x10,%esp 114ed3: 85 c0 test %eax,%eax 114ed5: 75 2a jne 114f01 114ed7: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) 114edc: 75 23 jne 114f01 /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 114ede: a1 34 6f 12 00 mov 0x126f34,%eax 114ee3: 8b 50 04 mov 0x4(%eax),%edx 114ee6: 3b 16 cmp (%esi),%edx 114ee8: 75 07 jne 114ef1 rtems_filesystem_current.node_access = NULL; 114eea: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED /* * Free memory associated with a memory file. */ free( the_jnode ); 114ef1: 83 ec 0c sub $0xc,%esp 114ef4: 53 push %ebx 114ef5: e8 f2 33 ff ff call 1082ec 114efa: 31 c0 xor %eax,%eax 114efc: 83 c4 10 add $0x10,%esp 114eff: eb 02 jmp 114f03 114f01: 31 c0 xor %eax,%eax } return 0; } 114f03: 8d 65 f8 lea -0x8(%ebp),%esp 114f06: 5b pop %ebx 114f07: 5e pop %esi 114f08: c9 leave 114f09: c3 ret 00125e2e : /* * Initialize useable but dummy databases */ void init_etc_passwd_group(void) { 125e2e: 55 push %ebp 125e2f: 89 e5 mov %esp,%ebp 125e31: 53 push %ebx 125e32: 83 ec 04 sub $0x4,%esp FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) 125e35: 80 3d 80 4b 16 00 00 cmpb $0x0,0x164b80 125e3c: 0f 85 b8 00 00 00 jne 125efa return; etc_passwd_initted = 1; 125e42: c6 05 80 4b 16 00 01 movb $0x1,0x164b80 mkdir("/etc", 0777); 125e49: 50 push %eax 125e4a: 50 push %eax 125e4b: 68 ff 01 00 00 push $0x1ff 125e50: 68 06 04 15 00 push $0x150406 125e55: e8 4a 5f fe ff call 10bda4 /* * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { 125e5a: 59 pop %ecx 125e5b: 5b pop %ebx 125e5c: 68 0b 2f 15 00 push $0x152f0b 125e61: 68 20 05 15 00 push $0x150520 125e66: e8 0d 45 01 00 call 13a378 125e6b: 83 c4 10 add $0x10,%esp 125e6e: 85 c0 test %eax,%eax 125e70: 74 06 je 125e78 fclose(fp); 125e72: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125e75: 50 push %eax <== NOT EXECUTED 125e76: eb 2a jmp 125ea2 <== NOT EXECUTED } else if ((fp = fopen("/etc/passwd", "w")) != NULL) { 125e78: 52 push %edx 125e79: 52 push %edx 125e7a: 68 7c 2b 15 00 push $0x152b7c 125e7f: 68 20 05 15 00 push $0x150520 125e84: e8 ef 44 01 00 call 13a378 125e89: 89 c3 mov %eax,%ebx 125e8b: 83 c4 10 add $0x10,%esp 125e8e: 85 c0 test %eax,%eax 125e90: 74 18 je 125eaa fprintf(fp, "root:*:0:0:root::/:/bin/sh\n" 125e92: 50 push %eax 125e93: 50 push %eax 125e94: 53 push %ebx 125e95: 68 e8 63 15 00 push $0x1563e8 125e9a: e8 1d 46 01 00 call 13a4bc "rtems:*:1:1:RTEMS Application::/:/bin/sh\n" "tty:!:2:2:tty owner::/:/bin/false\n" ); fclose(fp); 125e9f: 89 1c 24 mov %ebx,(%esp) 125ea2: e8 b9 3c 01 00 call 139b60 125ea7: 83 c4 10 add $0x10,%esp } /* * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { 125eaa: 51 push %ecx 125eab: 51 push %ecx 125eac: 68 0b 2f 15 00 push $0x152f0b 125eb1: 68 65 05 15 00 push $0x150565 125eb6: e8 bd 44 01 00 call 13a378 125ebb: 83 c4 10 add $0x10,%esp 125ebe: 85 c0 test %eax,%eax 125ec0: 74 06 je 125ec8 fclose(fp); 125ec2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125ec5: 50 push %eax <== NOT EXECUTED 125ec6: eb 2a jmp 125ef2 <== NOT EXECUTED } else if ((fp = fopen("/etc/group", "w")) != NULL) { 125ec8: 52 push %edx 125ec9: 52 push %edx 125eca: 68 7c 2b 15 00 push $0x152b7c 125ecf: 68 65 05 15 00 push $0x150565 125ed4: e8 9f 44 01 00 call 13a378 125ed9: 89 c3 mov %eax,%ebx 125edb: 83 c4 10 add $0x10,%esp 125ede: 85 c0 test %eax,%eax 125ee0: 74 18 je 125efa fprintf( fp, "root:x:0:root\n" 125ee2: 50 push %eax 125ee3: 50 push %eax 125ee4: 53 push %ebx 125ee5: 68 4f 64 15 00 push $0x15644f 125eea: e8 cd 45 01 00 call 13a4bc "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); 125eef: 89 1c 24 mov %ebx,(%esp) 125ef2: e8 69 3c 01 00 call 139b60 125ef7: 83 c4 10 add $0x10,%esp } } 125efa: 8b 5d fc mov -0x4(%ebp),%ebx 125efd: c9 leave 125efe: 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 44 51 12 00 cmp 0x125144,%eax 10a233: 73 19 jae 10a24e iop = rtems_libio_iop( fd ); 10a235: c1 e0 06 shl $0x6,%eax 10a238: 03 05 68 91 12 00 add 0x129168,%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 25 bc 00 00 call 115e78 <__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 11 bc 00 00 call 115e78 <__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 08 20 12 00 mov 0x122008,%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 38 1f 12 00 mov 0x121f38,%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 001262a8 : int link( const char *existing, const char *new ) { 1262a8: 55 push %ebp 1262a9: 89 e5 mov %esp,%ebp 1262ab: 57 push %edi 1262ac: 56 push %esi 1262ad: 53 push %ebx 1262ae: 83 ec 48 sub $0x48,%esp 1262b1: 8b 55 08 mov 0x8(%ebp),%edx 1262b4: 8b 5d 0c mov 0xc(%ebp),%ebx /* * Get the node we are linking to. */ result = rtems_filesystem_evaluate_path( existing, strlen( existing ), 1262b7: 31 c0 xor %eax,%eax 1262b9: 83 c9 ff or $0xffffffff,%ecx 1262bc: 89 d7 mov %edx,%edi 1262be: f2 ae repnz scas %es:(%edi),%al 1262c0: f7 d1 not %ecx 1262c2: 49 dec %ecx 1262c3: 6a 01 push $0x1 1262c5: 8d 45 d0 lea -0x30(%ebp),%eax 1262c8: 50 push %eax 1262c9: 6a 00 push $0x0 1262cb: 51 push %ecx 1262cc: 52 push %edx 1262cd: e8 f6 53 fe ff call 10b6c8 0, &existing_loc, true ); if ( result != 0 ) 1262d2: 83 c4 20 add $0x20,%esp 1262d5: 83 ce ff or $0xffffffff,%esi 1262d8: 85 c0 test %eax,%eax 1262da: 0f 85 80 01 00 00 jne 126460 /* * Get the parent of the node we are creating. */ rtems_filesystem_get_start_loc( new, &i, &parent_loc ); 1262e0: 8a 03 mov (%ebx),%al 1262e2: 3c 5c cmp $0x5c,%al 1262e4: 74 08 je 1262ee 1262e6: 3c 2f cmp $0x2f,%al 1262e8: 74 04 je 1262ee 1262ea: 84 c0 test %al,%al 1262ec: 75 1a jne 126308 1262ee: 8d 7d bc lea -0x44(%ebp),%edi 1262f1: 8b 35 3c f7 15 00 mov 0x15f73c,%esi 1262f7: 83 c6 18 add $0x18,%esi 1262fa: b9 05 00 00 00 mov $0x5,%ecx 1262ff: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 126301: ba 01 00 00 00 mov $0x1,%edx 126306: eb 15 jmp 12631d 126308: 8d 7d bc lea -0x44(%ebp),%edi 12630b: 8b 35 3c f7 15 00 mov 0x15f73c,%esi 126311: 83 c6 04 add $0x4,%esi 126314: b9 05 00 00 00 mov $0x5,%ecx 126319: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 12631b: 31 d2 xor %edx,%edx if ( !parent_loc.ops->evalformake_h ) { 12631d: 8b 45 c8 mov -0x38(%ebp),%eax 126320: 8b 40 04 mov 0x4(%eax),%eax 126323: 85 c0 test %eax,%eax 126325: 75 21 jne 126348 rtems_filesystem_freenode( &existing_loc ); 126327: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 12632a: 85 c0 test %eax,%eax <== NOT EXECUTED 12632c: 0f 84 dd 00 00 00 je 12640f <== NOT EXECUTED 126332: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 126335: 85 c0 test %eax,%eax <== NOT EXECUTED 126337: 0f 84 d2 00 00 00 je 12640f <== NOT EXECUTED 12633d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 126340: 8d 55 d0 lea -0x30(%ebp),%edx <== NOT EXECUTED 126343: e9 c1 00 00 00 jmp 126409 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start ); 126348: 51 push %ecx 126349: 8d 4d e4 lea -0x1c(%ebp),%ecx 12634c: 51 push %ecx 12634d: 8d 75 bc lea -0x44(%ebp),%esi 126350: 56 push %esi 126351: 01 d3 add %edx,%ebx 126353: 53 push %ebx 126354: ff d0 call *%eax 126356: 89 c3 mov %eax,%ebx if ( result != 0 ) { 126358: 83 c4 10 add $0x10,%esp 12635b: 85 c0 test %eax,%eax 12635d: 74 29 je 126388 rtems_filesystem_freenode( &existing_loc ); 12635f: 8b 45 dc mov -0x24(%ebp),%eax 126362: 85 c0 test %eax,%eax 126364: 74 13 je 126379 126366: 8b 40 1c mov 0x1c(%eax),%eax 126369: 85 c0 test %eax,%eax 12636b: 74 0c je 126379 12636d: 83 ec 0c sub $0xc,%esp 126370: 8d 55 d0 lea -0x30(%ebp),%edx 126373: 52 push %edx 126374: ff d0 call *%eax 126376: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( result ); 126379: e8 96 36 01 00 call 139a14 <__errno> 12637e: 89 18 mov %ebx,(%eax) 126380: 83 ce ff or $0xffffffff,%esi 126383: e9 d8 00 00 00 jmp 126460 /* * Check to see if the caller is trying to link across file system * boundaries. */ if ( parent_loc.mt_entry != existing_loc.mt_entry ) { 126388: 8b 45 cc mov -0x34(%ebp),%eax 12638b: 3b 45 e0 cmp -0x20(%ebp),%eax 12638e: 74 41 je 1263d1 rtems_filesystem_freenode( &existing_loc ); 126390: 8b 45 dc mov -0x24(%ebp),%eax 126393: 85 c0 test %eax,%eax 126395: 74 13 je 1263aa 126397: 8b 40 1c mov 0x1c(%eax),%eax 12639a: 85 c0 test %eax,%eax 12639c: 74 0c je 1263aa 12639e: 83 ec 0c sub $0xc,%esp 1263a1: 8d 55 d0 lea -0x30(%ebp),%edx 1263a4: 52 push %edx 1263a5: ff d0 call *%eax 1263a7: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &parent_loc ); 1263aa: 8b 45 c8 mov -0x38(%ebp),%eax 1263ad: 85 c0 test %eax,%eax 1263af: 74 13 je 1263c4 1263b1: 8b 40 1c mov 0x1c(%eax),%eax 1263b4: 85 c0 test %eax,%eax 1263b6: 74 0c je 1263c4 1263b8: 83 ec 0c sub $0xc,%esp 1263bb: 8d 55 bc lea -0x44(%ebp),%edx 1263be: 52 push %edx 1263bf: ff d0 call *%eax 1263c1: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EXDEV ); 1263c4: e8 4b 36 01 00 call 139a14 <__errno> 1263c9: c7 00 12 00 00 00 movl $0x12,(%eax) 1263cf: eb af jmp 126380 } if ( !parent_loc.ops->link_h ) { 1263d1: 8b 45 c8 mov -0x38(%ebp),%eax 1263d4: 8b 40 08 mov 0x8(%eax),%eax 1263d7: 85 c0 test %eax,%eax 1263d9: 75 44 jne 12641f rtems_filesystem_freenode( &existing_loc ); 1263db: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 1263de: 85 c0 test %eax,%eax <== NOT EXECUTED 1263e0: 74 13 je 1263f5 <== NOT EXECUTED 1263e2: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1263e5: 85 c0 test %eax,%eax <== NOT EXECUTED 1263e7: 74 0c je 1263f5 <== NOT EXECUTED 1263e9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1263ec: 8d 55 d0 lea -0x30(%ebp),%edx <== NOT EXECUTED 1263ef: 52 push %edx <== NOT EXECUTED 1263f0: ff d0 call *%eax <== NOT EXECUTED 1263f2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); 1263f5: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 1263f8: 85 c0 test %eax,%eax <== NOT EXECUTED 1263fa: 74 13 je 12640f <== NOT EXECUTED 1263fc: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1263ff: 85 c0 test %eax,%eax <== NOT EXECUTED 126401: 74 0c je 12640f <== NOT EXECUTED 126403: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 126406: 8d 55 bc lea -0x44(%ebp),%edx <== NOT EXECUTED 126409: 52 push %edx <== NOT EXECUTED 12640a: ff d0 call *%eax <== NOT EXECUTED 12640c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 12640f: e8 00 36 01 00 call 139a14 <__errno> <== NOT EXECUTED 126414: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12641a: e9 61 ff ff ff jmp 126380 <== NOT EXECUTED } result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start ); 12641f: 52 push %edx 126420: ff 75 e4 pushl -0x1c(%ebp) 126423: 56 push %esi 126424: 8d 5d d0 lea -0x30(%ebp),%ebx 126427: 53 push %ebx 126428: ff d0 call *%eax 12642a: 89 c6 mov %eax,%esi rtems_filesystem_freenode( &existing_loc ); 12642c: 8b 45 dc mov -0x24(%ebp),%eax 12642f: 83 c4 10 add $0x10,%esp 126432: 85 c0 test %eax,%eax 126434: 74 10 je 126446 126436: 8b 40 1c mov 0x1c(%eax),%eax 126439: 85 c0 test %eax,%eax 12643b: 74 09 je 126446 12643d: 83 ec 0c sub $0xc,%esp 126440: 53 push %ebx 126441: ff d0 call *%eax 126443: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &parent_loc ); 126446: 8b 45 c8 mov -0x38(%ebp),%eax 126449: 85 c0 test %eax,%eax 12644b: 74 13 je 126460 12644d: 8b 40 1c mov 0x1c(%eax),%eax 126450: 85 c0 test %eax,%eax 126452: 74 0c je 126460 126454: 83 ec 0c sub $0xc,%esp 126457: 8d 55 bc lea -0x44(%ebp),%edx 12645a: 52 push %edx 12645b: ff d0 call *%eax 12645d: 83 c4 10 add $0x10,%esp return result; } 126460: 89 f0 mov %esi,%eax 126462: 8d 65 f4 lea -0xc(%ebp),%esp 126465: 5b pop %ebx 126466: 5e pop %esi 126467: 5f pop %edi 126468: c9 leave 126469: c3 ret 0011c8bc : off_t lseek( int fd, off_t offset, int whence ) { 11c8bc: 55 push %ebp 11c8bd: 89 e5 mov %esp,%ebp 11c8bf: 57 push %edi 11c8c0: 56 push %esi 11c8c1: 53 push %ebx 11c8c2: 83 ec 1c sub $0x1c,%esp 11c8c5: 8b 5d 08 mov 0x8(%ebp),%ebx 11c8c8: 8b 45 0c mov 0xc(%ebp),%eax 11c8cb: 8b 55 10 mov 0x10(%ebp),%edx 11c8ce: 8b 4d 14 mov 0x14(%ebp),%ecx rtems_libio_t *iop; off_t old_offset; off_t status; rtems_libio_check_fd( fd ); 11c8d1: 3b 1d 44 01 12 00 cmp 0x120144,%ebx 11c8d7: 73 0f jae 11c8e8 iop = rtems_libio_iop( fd ); 11c8d9: c1 e3 06 shl $0x6,%ebx 11c8dc: 03 1d 90 40 12 00 add 0x124090,%ebx rtems_libio_check_is_open(iop); 11c8e2: f6 43 15 01 testb $0x1,0x15(%ebx) 11c8e6: 75 0d jne 11c8f5 11c8e8: e8 67 4c ff ff call 111554 <__errno> 11c8ed: c7 00 09 00 00 00 movl $0x9,(%eax) 11c8f3: eb 61 jmp 11c956 /* * Check as many errors as possible before touching iop->offset. */ if ( !iop->handlers->lseek_h ) 11c8f5: 8b 73 3c mov 0x3c(%ebx),%esi 11c8f8: 83 7e 14 00 cmpl $0x0,0x14(%esi) 11c8fc: 75 0d jne 11c90b rtems_set_errno_and_return_minus_one( ENOTSUP ); 11c8fe: e8 51 4c ff ff call 111554 <__errno> <== NOT EXECUTED 11c903: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11c909: eb 4b jmp 11c956 <== NOT EXECUTED /* * Now process the lseek(). */ old_offset = iop->offset; 11c90b: 8b 73 0c mov 0xc(%ebx),%esi 11c90e: 8b 7b 10 mov 0x10(%ebx),%edi 11c911: 89 75 e0 mov %esi,-0x20(%ebp) 11c914: 89 7d e4 mov %edi,-0x1c(%ebp) switch ( whence ) { 11c917: 83 f9 01 cmp $0x1,%ecx 11c91a: 74 11 je 11c92d 11c91c: 83 f9 02 cmp $0x2,%ecx 11c91f: 74 18 je 11c939 11c921: 85 c9 test %ecx,%ecx 11c923: 75 26 jne 11c94b case SEEK_SET: iop->offset = offset; 11c925: 89 43 0c mov %eax,0xc(%ebx) 11c928: 89 53 10 mov %edx,0x10(%ebx) break; 11c92b: eb 30 jmp 11c95d case SEEK_CUR: iop->offset += offset; 11c92d: 8b 75 e0 mov -0x20(%ebp),%esi 11c930: 8b 7d e4 mov -0x1c(%ebp),%edi 11c933: 01 c6 add %eax,%esi 11c935: 11 d7 adc %edx,%edi 11c937: eb 0a jmp 11c943 break; case SEEK_END: iop->offset = iop->size + offset; 11c939: 89 c6 mov %eax,%esi 11c93b: 89 d7 mov %edx,%edi 11c93d: 03 73 04 add 0x4(%ebx),%esi 11c940: 13 7b 08 adc 0x8(%ebx),%edi 11c943: 89 73 0c mov %esi,0xc(%ebx) 11c946: 89 7b 10 mov %edi,0x10(%ebx) break; 11c949: eb 12 jmp 11c95d default: rtems_set_errno_and_return_minus_one( EINVAL ); 11c94b: e8 04 4c ff ff call 111554 <__errno> 11c950: c7 00 16 00 00 00 movl $0x16,(%eax) 11c956: 83 c8 ff or $0xffffffff,%eax 11c959: 89 c2 mov %eax,%edx 11c95b: eb 23 jmp 11c980 /* * At this time, handlers assume iop->offset has the desired * new offset. */ status = (*iop->handlers->lseek_h)( iop, offset, whence ); 11c95d: 8b 73 3c mov 0x3c(%ebx),%esi 11c960: 51 push %ecx 11c961: 52 push %edx 11c962: 50 push %eax 11c963: 53 push %ebx 11c964: ff 56 14 call *0x14(%esi) if ( status == (off_t) -1 ) 11c967: 83 c4 10 add $0x10,%esp 11c96a: 83 fa ff cmp $0xffffffff,%edx 11c96d: 75 11 jne 11c980 11c96f: 83 f8 ff cmp $0xffffffff,%eax 11c972: 75 0c jne 11c980 iop->offset = old_offset; 11c974: 8b 75 e0 mov -0x20(%ebp),%esi 11c977: 8b 7d e4 mov -0x1c(%ebp),%edi 11c97a: 89 73 0c mov %esi,0xc(%ebx) 11c97d: 89 7b 10 mov %edi,0x10(%ebx) /* * So if the operation failed, we have to restore iop->offset. */ return status; } 11c980: 8d 65 f4 lea -0xc(%ebp),%esp 11c983: 5b pop %ebx 11c984: 5e pop %esi 11c985: 5f pop %edi 11c986: c9 leave 11c987: c3 ret 00126578 : int _STAT_NAME( const char *path, struct stat *buf ) { 126578: 55 push %ebp <== NOT EXECUTED 126579: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12657b: 57 push %edi <== NOT EXECUTED 12657c: 56 push %esi <== NOT EXECUTED 12657d: 53 push %ebx <== NOT EXECUTED 12657e: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 126581: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 126584: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !buf ) 126587: 85 f6 test %esi,%esi <== NOT EXECUTED 126589: 75 0d jne 126598 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); 12658b: e8 84 34 01 00 call 139a14 <__errno> <== NOT EXECUTED 126590: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 126596: eb 53 jmp 1265eb <== NOT EXECUTED status = rtems_filesystem_evaluate_path( path, strlen( path ), 126598: 31 c0 xor %eax,%eax <== NOT EXECUTED 12659a: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 12659d: 89 d7 mov %edx,%edi <== NOT EXECUTED 12659f: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 1265a1: f7 d1 not %ecx <== NOT EXECUTED 1265a3: 49 dec %ecx <== NOT EXECUTED 1265a4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1265a7: 6a 00 push $0x0 <== NOT EXECUTED 1265a9: 8d 5d d4 lea -0x2c(%ebp),%ebx <== NOT EXECUTED 1265ac: 53 push %ebx <== NOT EXECUTED 1265ad: 6a 00 push $0x0 <== NOT EXECUTED 1265af: 51 push %ecx <== NOT EXECUTED 1265b0: 52 push %edx <== NOT EXECUTED 1265b1: e8 12 51 fe ff call 10b6c8 <== NOT EXECUTED 0, &loc, _STAT_FOLLOW_LINKS ); if ( status != 0 ) 1265b6: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1265b9: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED 1265bc: 85 c0 test %eax,%eax <== NOT EXECUTED 1265be: 75 5c jne 12661c <== NOT EXECUTED return -1; if ( !loc.handlers->fstat_h ){ 1265c0: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 1265c3: 83 7a 18 00 cmpl $0x0,0x18(%edx) <== NOT EXECUTED 1265c7: 75 27 jne 1265f0 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1265c9: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 1265cc: 85 c0 test %eax,%eax <== NOT EXECUTED 1265ce: 74 10 je 1265e0 <== NOT EXECUTED 1265d0: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1265d3: 85 c0 test %eax,%eax <== NOT EXECUTED 1265d5: 74 09 je 1265e0 <== NOT EXECUTED 1265d7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1265da: 53 push %ebx <== NOT EXECUTED 1265db: ff d0 call *%eax <== NOT EXECUTED 1265dd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1265e0: e8 2f 34 01 00 call 139a14 <__errno> <== NOT EXECUTED 1265e5: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1265eb: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED 1265ee: eb 2c jmp 12661c <== NOT EXECUTED /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( buf, 0, sizeof(struct stat) ); 1265f0: b9 12 00 00 00 mov $0x12,%ecx <== NOT EXECUTED 1265f5: 89 f7 mov %esi,%edi <== NOT EXECUTED 1265f7: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED status = (*loc.handlers->fstat_h)( &loc, buf ); 1265f9: 50 push %eax <== NOT EXECUTED 1265fa: 50 push %eax <== NOT EXECUTED 1265fb: 56 push %esi <== NOT EXECUTED 1265fc: 53 push %ebx <== NOT EXECUTED 1265fd: ff 52 18 call *0x18(%edx) <== NOT EXECUTED 126600: 89 c7 mov %eax,%edi <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 126602: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 126605: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126608: 85 c0 test %eax,%eax <== NOT EXECUTED 12660a: 74 10 je 12661c <== NOT EXECUTED 12660c: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12660f: 85 c0 test %eax,%eax <== NOT EXECUTED 126611: 74 09 je 12661c <== NOT EXECUTED 126613: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 126616: 53 push %ebx <== NOT EXECUTED 126617: ff d0 call *%eax <== NOT EXECUTED 126619: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return status; } 12661c: 89 f8 mov %edi,%eax <== NOT EXECUTED 12661e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 126621: 5b pop %ebx <== NOT EXECUTED 126622: 5e pop %esi <== NOT EXECUTED 126623: 5f pop %edi <== NOT EXECUTED 126624: c9 leave <== NOT EXECUTED 126625: 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 ac 40 12 00 incl 0x1240ac /* * 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 84 43 12 00 03 cmpl $0x3,0x124384 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 50 01 12 00 pushl 0x120150 1073e4: e8 f7 42 00 00 call 10b6e0 <_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 25 12 00 mov 0x122514,%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 42 a1 00 00 call 111554 <__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 25 12 00 mov 0x122518,%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 25 12 00 mov 0x122510,%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 9c 40 12 00 push $0x12409c <== NOT EXECUTED 1072d0: e8 0b 35 00 00 call 10a7e0 <_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 9c 40 12 00 push $0x12409c 1072f6: e8 09 35 00 00 call 10a804 <_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 00114200 : return memfile_check_rmnod( the_jnode ); } int memfile_check_rmnod( IMFS_jnode_t *the_jnode ){ 114200: 55 push %ebp 114201: 89 e5 mov %esp,%ebp 114203: 53 push %ebx 114204: 83 ec 10 sub $0x10,%esp 114207: 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) ) { 11420a: 53 push %ebx 11420b: e8 72 de ff ff call 112082 114210: 83 c4 10 add $0x10,%esp 114213: 85 c0 test %eax,%eax 114215: 75 36 jne 11424d 114217: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) 11421c: 75 2f jne 11424d /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == the_jnode ) 11421e: a1 34 6f 12 00 mov 0x126f34,%eax 114223: 39 58 04 cmp %ebx,0x4(%eax) 114226: 75 07 jne 11422f rtems_filesystem_current.node_access = NULL; 114228: 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) 11422f: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) 114233: 74 0c je 114241 IMFS_memfile_remove( the_jnode ); 114235: 83 ec 0c sub $0xc,%esp 114238: 53 push %ebx 114239: e8 98 fe ff ff call 1140d6 11423e: 83 c4 10 add $0x10,%esp free( the_jnode ); 114241: 83 ec 0c sub $0xc,%esp 114244: 53 push %ebx 114245: e8 a2 40 ff ff call 1082ec 11424a: 83 c4 10 add $0x10,%esp } return 0; } 11424d: 31 c0 xor %eax,%eax 11424f: 8b 5d fc mov -0x4(%ebp),%ebx 114252: c9 leave 114253: c3 ret 00114021 : void memfile_free_blocks_in_table( block_p **block_table, int entries ) { 114021: 55 push %ebp 114022: 89 e5 mov %esp,%ebp 114024: 57 push %edi 114025: 56 push %esi 114026: 53 push %ebx 114027: 83 ec 0c sub $0xc,%esp 11402a: 8b 75 08 mov 0x8(%ebp),%esi /* * Perform internal consistency checks */ assert( block_table ); 11402d: 85 f6 test %esi,%esi 11402f: 75 19 jne 11404a 114031: 68 68 39 12 00 push $0x123968 <== NOT EXECUTED 114036: 68 5c 3a 12 00 push $0x123a5c <== NOT EXECUTED 11403b: 68 b3 01 00 00 push $0x1b3 <== NOT EXECUTED 114040: 68 fe 38 12 00 push $0x1238fe <== NOT EXECUTED 114045: e8 76 3f ff ff call 107fc0 <__assert_func> <== NOT EXECUTED /* * Now go through all the slots in the table and free the memory. */ b = *block_table; 11404a: 8b 3e mov (%esi),%edi 11404c: 31 db xor %ebx,%ebx for ( i=0 ; i if ( b[i] ) { 114050: 8b 04 9f mov (%edi,%ebx,4),%eax 114053: 85 c0 test %eax,%eax 114055: 74 13 je 11406a memfile_free_block( b[i] ); 114057: 83 ec 0c sub $0xc,%esp 11405a: 50 push %eax 11405b: e8 ff fd ff ff call 113e5f b[i] = 0; 114060: c7 04 9f 00 00 00 00 movl $0x0,(%edi,%ebx,4) 114067: 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 ); 114070: 83 ec 0c sub $0xc,%esp 114073: ff 36 pushl (%esi) 114075: e8 e5 fd ff ff call 113e5f *block_table = 0; 11407a: c7 06 00 00 00 00 movl $0x0,(%esi) 114080: 83 c4 10 add $0x10,%esp } 114083: 8d 65 f4 lea -0xc(%ebp),%esp 114086: 5b pop %ebx 114087: 5e pop %esi 114088: 5f pop %edi 114089: c9 leave 11408a: c3 ret 00114461 : int memfile_ftruncate( rtems_libio_t *iop, rtems_off64_t length ) { 114461: 55 push %ebp 114462: 89 e5 mov %esp,%ebp 114464: 53 push %ebx 114465: 83 ec 14 sub $0x14,%esp 114468: 8b 4d 08 mov 0x8(%ebp),%ecx 11446b: 8b 45 0c mov 0xc(%ebp),%eax 11446e: 8b 55 10 mov 0x10(%ebp),%edx IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 114471: 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 ) 114474: 3b 53 54 cmp 0x54(%ebx),%edx 114477: 7c 12 jl 11448b 114479: 7f 05 jg 114480 11447b: 3b 43 50 cmp 0x50(%ebx),%eax 11447e: 76 0b jbe 11448b return IMFS_memfile_extend( the_jnode, length ); 114480: 51 push %ecx <== NOT EXECUTED 114481: 52 push %edx <== NOT EXECUTED 114482: 50 push %eax <== NOT EXECUTED 114483: 53 push %ebx <== NOT EXECUTED 114484: e8 b2 fe ff ff call 11433b <== NOT EXECUTED 114489: eb 21 jmp 1144ac <== 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; 11448b: 89 43 50 mov %eax,0x50(%ebx) 11448e: 89 53 54 mov %edx,0x54(%ebx) iop->size = the_jnode->info.file.size; 114491: 89 41 04 mov %eax,0x4(%ecx) 114494: 89 51 08 mov %edx,0x8(%ecx) IMFS_update_atime( the_jnode ); 114497: 52 push %edx 114498: 52 push %edx 114499: 6a 00 push $0x0 11449b: 8d 45 f0 lea -0x10(%ebp),%eax 11449e: 50 push %eax 11449f: e8 c0 3e ff ff call 108364 1144a4: 8b 45 f0 mov -0x10(%ebp),%eax 1144a7: 89 43 40 mov %eax,0x40(%ebx) 1144aa: 31 c0 xor %eax,%eax return 0; 1144ac: 83 c4 10 add $0x10,%esp } 1144af: 8b 5d fc mov -0x4(%ebp),%ebx 1144b2: c9 leave 1144b3: c3 ret 001144b4 : rtems_off64_t memfile_lseek( rtems_libio_t *iop, rtems_off64_t offset, int whence ) { 1144b4: 55 push %ebp 1144b5: 89 e5 mov %esp,%ebp 1144b7: 56 push %esi 1144b8: 53 push %ebx 1144b9: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 1144bc: 8b 73 38 mov 0x38(%ebx),%esi if (the_jnode->type == IMFS_LINEAR_FILE) { 1144bf: 83 7e 4c 06 cmpl $0x6,0x4c(%esi) 1144c3: 75 1a jne 1144df if (iop->offset > the_jnode->info.linearfile.size) 1144c5: 8b 56 50 mov 0x50(%esi),%edx <== NOT EXECUTED 1144c8: 8b 46 54 mov 0x54(%esi),%eax <== NOT EXECUTED 1144cb: 39 43 10 cmp %eax,0x10(%ebx) <== NOT EXECUTED 1144ce: 7c 41 jl 114511 <== NOT EXECUTED 1144d0: 7f 05 jg 1144d7 <== NOT EXECUTED 1144d2: 39 53 0c cmp %edx,0xc(%ebx) <== NOT EXECUTED 1144d5: 76 3a jbe 114511 <== NOT EXECUTED iop->offset = the_jnode->info.linearfile.size; 1144d7: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED 1144da: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED 1144dd: eb 32 jmp 114511 <== NOT EXECUTED } else { /* Must be a block file (IMFS_MEMORY_FILE). */ if (IMFS_memfile_extend( the_jnode, iop->offset )) 1144df: 50 push %eax 1144e0: ff 73 10 pushl 0x10(%ebx) 1144e3: ff 73 0c pushl 0xc(%ebx) 1144e6: 56 push %esi 1144e7: e8 4f fe ff ff call 11433b 1144ec: 83 c4 10 add $0x10,%esp 1144ef: 85 c0 test %eax,%eax 1144f1: 74 12 je 114505 rtems_set_errno_and_return_minus_one( ENOSPC ); 1144f3: e8 58 17 00 00 call 115c50 <__errno> <== NOT EXECUTED 1144f8: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 1144fe: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 114501: 89 c2 mov %eax,%edx <== NOT EXECUTED 114503: eb 12 jmp 114517 <== NOT EXECUTED iop->size = the_jnode->info.file.size; 114505: 8b 46 50 mov 0x50(%esi),%eax 114508: 8b 56 54 mov 0x54(%esi),%edx 11450b: 89 43 04 mov %eax,0x4(%ebx) 11450e: 89 53 08 mov %edx,0x8(%ebx) } return iop->offset; 114511: 8b 43 0c mov 0xc(%ebx),%eax 114514: 8b 53 10 mov 0x10(%ebx),%edx } 114517: 8d 65 f8 lea -0x8(%ebp),%esp 11451a: 5b pop %ebx 11451b: 5e pop %esi 11451c: c9 leave 11451d: c3 ret 00114743 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 114743: 55 push %ebp 114744: 89 e5 mov %esp,%ebp 114746: 56 push %esi 114747: 53 push %ebx 114748: 8b 75 08 mov 0x8(%ebp),%esi IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 11474b: 8b 5e 38 mov 0x38(%esi),%ebx /* * Perform 'copy on write' for linear files */ if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND)) 11474e: f7 46 14 04 02 00 00 testl $0x204,0x14(%esi) 114755: 74 54 je 1147ab && (the_jnode->type == IMFS_LINEAR_FILE)) { 114757: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) 11475b: 75 4e jne 1147ab uint32_t count = the_jnode->info.linearfile.size; 11475d: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED const unsigned char *buffer = the_jnode->info.linearfile.direct; 114760: 8b 53 58 mov 0x58(%ebx),%edx <== NOT EXECUTED the_jnode->type = IMFS_MEMORY_FILE; 114763: c7 43 4c 05 00 00 00 movl $0x5,0x4c(%ebx) <== NOT EXECUTED the_jnode->info.file.size = 0; 11476a: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED 114771: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED the_jnode->info.file.indirect = 0; 114778: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED the_jnode->info.file.doubly_indirect = 0; 11477f: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED the_jnode->info.file.triply_indirect = 0; 114786: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED if ((count != 0) 11478d: 85 c0 test %eax,%eax <== NOT EXECUTED 11478f: 74 1a je 1147ab <== NOT EXECUTED && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) 114791: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114794: 50 push %eax <== NOT EXECUTED 114795: 52 push %edx <== NOT EXECUTED 114796: 6a 00 push $0x0 <== NOT EXECUTED 114798: 6a 00 push $0x0 <== NOT EXECUTED 11479a: 53 push %ebx <== NOT EXECUTED 11479b: e8 7e fd ff ff call 11451e <== NOT EXECUTED 1147a0: 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) 1147a2: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1147a5: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 1147a8: 42 inc %edx <== NOT EXECUTED 1147a9: 74 20 je 1147cb <== NOT EXECUTED && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) return -1; } if (iop->flags & LIBIO_FLAGS_APPEND) 1147ab: f6 46 15 02 testb $0x2,0x15(%esi) 1147af: 74 0c je 1147bd iop->offset = the_jnode->info.file.size; 1147b1: 8b 43 50 mov 0x50(%ebx),%eax 1147b4: 8b 53 54 mov 0x54(%ebx),%edx 1147b7: 89 46 0c mov %eax,0xc(%esi) 1147ba: 89 56 10 mov %edx,0x10(%esi) iop->size = the_jnode->info.file.size; 1147bd: 8b 43 50 mov 0x50(%ebx),%eax 1147c0: 8b 53 54 mov 0x54(%ebx),%edx 1147c3: 89 46 04 mov %eax,0x4(%esi) 1147c6: 89 56 08 mov %edx,0x8(%esi) 1147c9: 31 c0 xor %eax,%eax return 0; } 1147cb: 8d 65 f8 lea -0x8(%ebp),%esp 1147ce: 5b pop %ebx 1147cf: 5e pop %esi 1147d0: c9 leave 1147d1: 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 c1 a0 00 00 call 111554 <__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 48 1f 12 00 mov 0x121f48,%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 48 1f 12 00 mov 0x121f48,%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 70 a0 00 00 call 111554 <__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 b6 9f 00 00 call 111554 <__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 9d 9f 00 00 call 111554 <__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 58 9f 00 00 call 111554 <__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 a5 aa 00 00 call 1120c8 <== 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 e1 9e 00 00 call 111554 <__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 c5 9e 00 00 call 111554 <__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 d4 40 12 00 mov 0x1240d4,%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 d8 40 12 00 cmp $0x1240d8,%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 98 9e 00 00 call 111554 <__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 8b 9e 00 00 call 111554 <__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 d4 40 12 00 push $0x1240d4 10774a: e8 91 30 00 00 call 10a7e0 <_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 cb a0 00 00 call 11190c 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 28 9e 00 00 call 1116a0 <== 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 40 6e 12 00 00 cmpb $0x0,0x126e40 107801: 75 2b jne 10782e initialized = 1; 107803: c6 05 40 6e 12 00 01 movb $0x1,0x126e40 status = rtems_io_register_name( 10780a: 50 push %eax 10780b: 6a 00 push $0x0 10780d: 53 push %ebx 10780e: 68 c7 fe 11 00 push $0x11fec7 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 e4 39 00 00 call 10b20c <== NOT EXECUTED NULL_major = major; 107828: 89 1d 70 71 12 00 mov %ebx,0x127170 } 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 0a 64 00 00 call 10df8f 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 91 99 00 00 call 111554 <__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 58 99 00 00 call 111554 <__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 ac 63 00 00 call 10e01a 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 a4 98 00 00 call 111554 <__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 90 40 12 00 sub 0x124090,%eax 107cd1: c1 f8 06 sar $0x6,%eax 107cd4: 50 push %eax 107cd5: e8 22 60 00 00 call 10dcfc 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 6c 98 00 00 call 111554 <__errno> <== NOT EXECUTED 107ce8: 83 38 00 cmpl $0x0,(%eax) <== NOT EXECUTED 107ceb: 74 07 je 107cf4 <== NOT EXECUTED 107ced: e8 62 98 00 00 call 111554 <__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 90 40 12 00 sub 0x124090,%ebx <== NOT EXECUTED 107cfd: c1 fb 06 sar $0x6,%ebx <== NOT EXECUTED 107d00: 53 push %ebx <== NOT EXECUTED 107d01: e8 6e 5f 00 00 call 10dc74 <== 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 1c 62 00 00 call 10df3a 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 13 98 00 00 call 111554 <__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 90 40 12 00 sub 0x124090,%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 92 d2 11 00 push $0x11d292 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 92 d2 11 00 push $0x11d292 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 92 d2 11 00 push $0x11d292 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 e5 29 00 00 call 10a53c <== 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 41 e8 11 00 push $0x11e841 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 ec e4 11 00 push $0x11e4ec 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 08 20 12 00 mov 0x122008,%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 08 20 12 00 mov 0x122008,%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 00110ce4 : * Called by pipe() to create an anonymous pipe. */ int pipe_create( int filsdes[2] ) { 110ce4: 55 push %ebp 110ce5: 89 e5 mov %esp,%ebp 110ce7: 57 push %edi 110ce8: 56 push %esi 110ce9: 53 push %ebx 110cea: 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) 110ced: 6a 01 push $0x1 110cef: 8d 5d c4 lea -0x3c(%ebp),%ebx 110cf2: 53 push %ebx 110cf3: 6a 07 push $0x7 110cf5: 6a 03 push $0x3 110cf7: 68 3b f0 11 00 push $0x11f03b 110cfc: e8 d7 63 ff ff call 1070d8 110d01: 83 c4 20 add $0x20,%esp 110d04: 85 c0 test %eax,%eax 110d06: 74 2b je 110d33 != 0) { if (errno != ENOENT) 110d08: e8 47 08 00 00 call 111554 <__errno> 110d0d: 83 38 02 cmpl $0x2,(%eax) 110d10: 0f 85 0c 01 00 00 jne 110e22 return -1; if (mkdir("/tmp", S_IRWXU|S_IRWXG|S_IRWXO|S_ISVTX) != 0) 110d16: 50 push %eax 110d17: 50 push %eax 110d18: 68 ff 03 00 00 push $0x3ff 110d1d: 68 3b f0 11 00 push $0x11f03b 110d22: e8 29 67 ff ff call 107450 110d27: 83 c4 10 add $0x10,%esp 110d2a: 85 c0 test %eax,%eax 110d2c: 74 1c je 110d4a 110d2e: e9 ef 00 00 00 jmp 110e22 <== NOT EXECUTED return -1; } else rtems_filesystem_freenode(&loc); 110d33: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 110d36: 85 c0 test %eax,%eax <== NOT EXECUTED 110d38: 74 10 je 110d4a <== NOT EXECUTED 110d3a: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 110d3d: 85 c0 test %eax,%eax <== NOT EXECUTED 110d3f: 74 09 je 110d4a <== NOT EXECUTED 110d41: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110d44: 53 push %ebx <== NOT EXECUTED 110d45: ff d0 call *%eax <== NOT EXECUTED 110d47: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* /tmp/.fifoXXXX */ char fifopath[15]; memcpy(fifopath, "/tmp/.fifo", 10); 110d4a: 8d 5d d9 lea -0x27(%ebp),%ebx 110d4d: be 40 f0 11 00 mov $0x11f040,%esi 110d52: b9 0a 00 00 00 mov $0xa,%ecx 110d57: 89 df mov %ebx,%edi 110d59: f3 a4 rep movsb %ds:(%esi),%es:(%edi) sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); 110d5b: 0f b7 05 9c 3e 12 00 movzwl 0x123e9c,%eax 110d62: 8d 50 01 lea 0x1(%eax),%edx 110d65: 66 89 15 9c 3e 12 00 mov %dx,0x123e9c 110d6c: 57 push %edi 110d6d: 50 push %eax 110d6e: 68 4b f0 11 00 push $0x11f04b 110d73: 8d 45 e3 lea -0x1d(%ebp),%eax 110d76: 50 push %eax 110d77: e8 6c 11 00 00 call 111ee8 /* Try creating FIFO file until find an available file name */ while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) { 110d7c: 59 pop %ecx 110d7d: 5e pop %esi 110d7e: 68 80 01 00 00 push $0x180 110d83: 53 push %ebx 110d84: e8 f7 00 00 00 call 110e80 110d89: 83 c4 10 add $0x10,%esp 110d8c: 85 c0 test %eax,%eax 110d8e: 74 0a je 110d9a if (errno != EEXIST){ 110d90: e8 bf 07 00 00 call 111554 <__errno> <== NOT EXECUTED 110d95: e9 88 00 00 00 jmp 110e22 <== 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); 110d9a: 52 push %edx 110d9b: 52 push %edx 110d9c: 68 00 40 00 00 push $0x4000 110da1: 53 push %ebx 110da2: e8 b5 6d ff ff call 107b5c 110da7: 8b 55 08 mov 0x8(%ebp),%edx 110daa: 89 02 mov %eax,(%edx) if (filsdes[0] < 0) { 110dac: 83 c4 10 add $0x10,%esp 110daf: 85 c0 test %eax,%eax 110db1: 79 0d jns 110dc0 err = errno; 110db3: e8 9c 07 00 00 call 111554 <__errno> 110db8: 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); 110dba: 83 ec 0c sub $0xc,%esp 110dbd: 53 push %ebx 110dbe: eb 53 jmp 110e13 } else { /* Reset open file to blocking mode */ iop = rtems_libio_iop(filsdes[0]); 110dc0: 31 d2 xor %edx,%edx <== NOT EXECUTED 110dc2: 3b 05 44 01 12 00 cmp 0x120144,%eax <== NOT EXECUTED 110dc8: 73 0b jae 110dd5 <== NOT EXECUTED 110dca: 89 c2 mov %eax,%edx <== NOT EXECUTED 110dcc: c1 e2 06 shl $0x6,%edx <== NOT EXECUTED 110dcf: 03 15 90 40 12 00 add 0x124090,%edx <== NOT EXECUTED iop->flags &= ~LIBIO_FLAGS_NO_DELAY; 110dd5: 83 62 14 fe andl $0xfffffffe,0x14(%edx) <== NOT EXECUTED filsdes[1] = open(fifopath, O_WRONLY); 110dd9: 50 push %eax <== NOT EXECUTED 110dda: 50 push %eax <== NOT EXECUTED 110ddb: 6a 01 push $0x1 <== NOT EXECUTED 110ddd: 8d 45 d9 lea -0x27(%ebp),%eax <== NOT EXECUTED 110de0: 50 push %eax <== NOT EXECUTED 110de1: e8 76 6d ff ff call 107b5c <== NOT EXECUTED 110de6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 110de9: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED if (filsdes[1] < 0) { 110dec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110def: 31 f6 xor %esi,%esi <== NOT EXECUTED 110df1: 85 c0 test %eax,%eax <== NOT EXECUTED 110df3: 79 17 jns 110e0c <== NOT EXECUTED err = errno; 110df5: e8 5a 07 00 00 call 111554 <__errno> <== NOT EXECUTED 110dfa: 8b 30 mov (%eax),%esi <== NOT EXECUTED close(filsdes[0]); 110dfc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110dff: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 110e02: ff 30 pushl (%eax) <== NOT EXECUTED 110e04: e8 6b ce ff ff call 10dc74 <== NOT EXECUTED 110e09: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } unlink(fifopath); 110e0c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110e0f: 8d 45 d9 lea -0x27(%ebp),%eax <== NOT EXECUTED 110e12: 50 push %eax <== NOT EXECUTED 110e13: e8 84 00 00 00 call 110e9c 110e18: 83 c4 10 add $0x10,%esp } rtems_set_errno_and_return_minus_one(err); 110e1b: e8 34 07 00 00 call 111554 <__errno> 110e20: 89 30 mov %esi,(%eax) } 110e22: 83 c8 ff or $0xffffffff,%eax 110e25: 8d 65 f4 lea -0xc(%ebp),%esp 110e28: 5b pop %ebx 110e29: 5e pop %esi 110e2a: 5f pop %edi 110e2b: c9 leave 110e2c: c3 ret 0010fbcc : /* Called with rtems_pipe_semaphore held. */ static inline void pipe_free( pipe_control_t *pipe ) { 10fbcc: 55 push %ebp <== NOT EXECUTED 10fbcd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fbcf: 53 push %ebx <== NOT EXECUTED 10fbd0: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10fbd3: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_barrier_delete(pipe->readBarrier); 10fbd5: ff 70 2c pushl 0x2c(%eax) <== NOT EXECUTED 10fbd8: e8 a3 0b 00 00 call 110780 <== NOT EXECUTED rtems_barrier_delete(pipe->writeBarrier); 10fbdd: 59 pop %ecx <== NOT EXECUTED 10fbde: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10fbe1: e8 9a 0b 00 00 call 110780 <== NOT EXECUTED rtems_semaphore_delete(pipe->Semaphore); 10fbe6: 5a pop %edx <== NOT EXECUTED 10fbe7: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10fbea: e8 fd a2 ff ff call 109eec <== NOT EXECUTED free(pipe->Buffer); 10fbef: 58 pop %eax <== NOT EXECUTED 10fbf0: ff 33 pushl (%ebx) <== NOT EXECUTED 10fbf2: e8 89 75 ff ff call 107180 <== NOT EXECUTED free(pipe); 10fbf7: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10fbfa: e8 81 75 ff ff call 107180 <== NOT EXECUTED 10fbff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10fc02: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10fc05: c9 leave <== NOT EXECUTED 10fc06: c3 ret <== NOT EXECUTED 0010f86b : pipe_control_t *pipe, uint32_t cmd, void *buffer, rtems_libio_t *iop ) { 10f86b: 55 push %ebp <== NOT EXECUTED 10f86c: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f86e: 56 push %esi <== NOT EXECUTED 10f86f: 53 push %ebx <== NOT EXECUTED 10f870: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10f873: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED if (cmd == FIONREAD) { 10f876: b8 ea ff ff ff mov $0xffffffea,%eax <== NOT EXECUTED 10f87b: 81 7d 0c 7f 66 04 40 cmpl $0x4004667f,0xc(%ebp) <== NOT EXECUTED 10f882: 75 36 jne 10f8ba <== NOT EXECUTED if (buffer == NULL) 10f884: b0 f2 mov $0xf2,%al <== NOT EXECUTED 10f886: 85 f6 test %esi,%esi <== NOT EXECUTED 10f888: 74 30 je 10f8ba <== NOT EXECUTED return -EFAULT; if (! PIPE_LOCK(pipe)) 10f88a: 50 push %eax <== NOT EXECUTED 10f88b: 6a 00 push $0x0 <== NOT EXECUTED 10f88d: 6a 00 push $0x0 <== NOT EXECUTED 10f88f: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f892: e8 e5 a6 ff ff call 109f7c <== NOT EXECUTED 10f897: 89 c2 mov %eax,%edx <== NOT EXECUTED 10f899: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f89c: b8 fc ff ff ff mov $0xfffffffc,%eax <== NOT EXECUTED 10f8a1: 85 d2 test %edx,%edx <== NOT EXECUTED 10f8a3: 75 15 jne 10f8ba <== NOT EXECUTED return -EINTR; /* Return length of pipe */ *(uint *)buffer = pipe->Length; 10f8a5: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10f8a8: 89 06 mov %eax,(%esi) <== NOT EXECUTED PIPE_UNLOCK(pipe); 10f8aa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f8ad: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f8b0: e8 b3 a7 ff ff call 10a068 <== NOT EXECUTED 10f8b5: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; 10f8b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return -EINVAL; } 10f8ba: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f8bd: 5b pop %ebx <== NOT EXECUTED 10f8be: 5e pop %esi <== NOT EXECUTED 10f8bf: c9 leave <== NOT EXECUTED 10f8c0: c3 ret <== NOT EXECUTED 0010f814 : pipe_control_t *pipe, off_t offset, int whence, rtems_libio_t *iop ) { 10f814: 55 push %ebp <== NOT EXECUTED 10f815: 89 e5 mov %esp,%ebp <== NOT EXECUTED /* Seek on pipe is not supported */ return -ESPIPE; } 10f817: b8 e3 ff ff ff mov $0xffffffe3,%eax <== NOT EXECUTED 10f81c: c9 leave <== NOT EXECUTED 10f81d: c3 ret <== NOT EXECUTED 0010f8c1 : pipe_control_t *pipe, void *buffer, size_t count, rtems_libio_t *iop ) { 10f8c1: 55 push %ebp <== NOT EXECUTED 10f8c2: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f8c4: 57 push %edi <== NOT EXECUTED 10f8c5: 56 push %esi <== NOT EXECUTED 10f8c6: 53 push %ebx <== NOT EXECUTED 10f8c7: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED 10f8ca: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED int chunk, chunk1, read = 0, ret = 0; if (! PIPE_LOCK(pipe)) 10f8cd: 6a 00 push $0x0 <== NOT EXECUTED 10f8cf: 6a 00 push $0x0 <== NOT EXECUTED 10f8d1: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f8d4: e8 a3 a6 ff ff call 109f7c <== NOT EXECUTED 10f8d9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f8dc: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED 10f8e3: 85 c0 test %eax,%eax <== NOT EXECUTED 10f8e5: 0f 84 08 01 00 00 je 10f9f3 <== NOT EXECUTED 10f8eb: c7 45 d4 fc ff ff ff movl $0xfffffffc,-0x2c(%ebp) <== NOT EXECUTED 10f8f2: e9 21 01 00 00 jmp 10fa18 <== NOT EXECUTED return -EINTR; while (read < count) { while (PIPE_EMPTY(pipe)) { /* Not an error */ if (pipe->Writers == 0) 10f8f7: 83 7b 14 00 cmpl $0x0,0x14(%ebx) <== NOT EXECUTED 10f8fb: 0f 84 fe 00 00 00 je 10f9ff <== NOT EXECUTED goto out_locked; if (LIBIO_NODELAY(iop)) { 10f901: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10f904: f6 40 14 01 testb $0x1,0x14(%eax) <== NOT EXECUTED 10f908: 74 0a je 10f914 <== NOT EXECUTED 10f90a: be f5 ff ff ff mov $0xfffffff5,%esi <== NOT EXECUTED 10f90f: e9 ed 00 00 00 jmp 10fa01 <== NOT EXECUTED ret = -EAGAIN; goto out_locked; } /* Wait until pipe is no more empty or no writer exists */ pipe->waitingReaders ++; 10f914: ff 43 18 incl 0x18(%ebx) <== NOT EXECUTED PIPE_UNLOCK(pipe); 10f917: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f91a: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f91d: e8 46 a7 ff ff call 10a068 <== NOT EXECUTED if (! PIPE_READWAIT(pipe)) 10f922: 59 pop %ecx <== NOT EXECUTED 10f923: 5e pop %esi <== NOT EXECUTED 10f924: 6a 00 push $0x0 <== NOT EXECUTED 10f926: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10f929: e8 0a 0f 00 00 call 110838 <== NOT EXECUTED 10f92e: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10f931: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10f934: 19 f6 sbb %esi,%esi <== NOT EXECUTED 10f936: f7 d6 not %esi <== NOT EXECUTED 10f938: 83 e6 fc and $0xfffffffc,%esi <== NOT EXECUTED ret = -EINTR; if (! PIPE_LOCK(pipe)) { 10f93b: 6a 00 push $0x0 <== NOT EXECUTED 10f93d: 6a 00 push $0x0 <== NOT EXECUTED 10f93f: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10f942: e8 35 a6 ff ff call 109f7c <== NOT EXECUTED 10f947: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f94a: 85 c0 test %eax,%eax <== NOT EXECUTED 10f94c: 74 0a je 10f958 <== NOT EXECUTED 10f94e: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED 10f953: e9 b7 00 00 00 jmp 10fa0f <== NOT EXECUTED /* WARN waitingReaders not restored! */ ret = -EINTR; goto out_nolock; } pipe->waitingReaders --; 10f958: ff 4b 18 decl 0x18(%ebx) <== NOT EXECUTED if (ret != 0) 10f95b: 85 f6 test %esi,%esi <== NOT EXECUTED 10f95d: 0f 85 9e 00 00 00 jne 10fa01 <== NOT EXECUTED if (! PIPE_LOCK(pipe)) return -EINTR; while (read < count) { while (PIPE_EMPTY(pipe)) { 10f963: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED 10f966: 85 d2 test %edx,%edx <== NOT EXECUTED 10f968: 74 8d je 10f8f7 <== NOT EXECUTED if (ret != 0) goto out_locked; } /* Read chunk bytes */ chunk = MIN(count - read, pipe->Length); 10f96a: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10f96d: 2b 45 d4 sub -0x2c(%ebp),%eax <== NOT EXECUTED 10f970: 89 55 d0 mov %edx,-0x30(%ebp) <== NOT EXECUTED 10f973: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10f975: 76 03 jbe 10f97a <== NOT EXECUTED 10f977: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED chunk1 = pipe->Size - pipe->Start; 10f97a: 8b 73 08 mov 0x8(%ebx),%esi <== NOT EXECUTED 10f97d: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10f980: 29 f0 sub %esi,%eax <== NOT EXECUTED if (chunk > chunk1) { 10f982: 39 45 d0 cmp %eax,-0x30(%ebp) <== NOT EXECUTED 10f985: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10f988: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED 10f98b: 8d 14 0f lea (%edi,%ecx,1),%edx <== NOT EXECUTED 10f98e: 7e 1b jle 10f9ab <== NOT EXECUTED memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1); 10f990: 03 33 add (%ebx),%esi <== NOT EXECUTED 10f992: 89 d7 mov %edx,%edi <== NOT EXECUTED 10f994: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10f996: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1); 10f998: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 10f99b: 01 c2 add %eax,%edx <== NOT EXECUTED 10f99d: 03 55 0c add 0xc(%ebp),%edx <== NOT EXECUTED 10f9a0: 8b 4d d0 mov -0x30(%ebp),%ecx <== NOT EXECUTED 10f9a3: 29 c1 sub %eax,%ecx <== NOT EXECUTED 10f9a5: 8b 33 mov (%ebx),%esi <== NOT EXECUTED 10f9a7: 89 d7 mov %edx,%edi <== NOT EXECUTED 10f9a9: eb 07 jmp 10f9b2 <== NOT EXECUTED } else memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk); 10f9ab: 03 33 add (%ebx),%esi <== NOT EXECUTED 10f9ad: 89 d7 mov %edx,%edi <== NOT EXECUTED 10f9af: 8b 4d d0 mov -0x30(%ebp),%ecx <== NOT EXECUTED 10f9b2: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED pipe->Start += chunk; 10f9b4: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 10f9b7: 03 43 08 add 0x8(%ebx),%eax <== NOT EXECUTED pipe->Start %= pipe->Size; 10f9ba: 31 d2 xor %edx,%edx <== NOT EXECUTED 10f9bc: f7 73 04 divl 0x4(%ebx) <== NOT EXECUTED 10f9bf: 89 53 08 mov %edx,0x8(%ebx) <== NOT EXECUTED pipe->Length -= chunk; 10f9c2: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10f9c5: 2b 45 d0 sub -0x30(%ebp),%eax <== NOT EXECUTED 10f9c8: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED /* For buffering optimization */ if (PIPE_EMPTY(pipe)) 10f9cb: 85 c0 test %eax,%eax <== NOT EXECUTED 10f9cd: 75 07 jne 10f9d6 <== NOT EXECUTED pipe->Start = 0; 10f9cf: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED if (pipe->waitingWriters > 0) 10f9d6: 83 7b 1c 00 cmpl $0x0,0x1c(%ebx) <== NOT EXECUTED 10f9da: 74 11 je 10f9ed <== NOT EXECUTED PIPE_WAKEUPWRITERS(pipe); 10f9dc: 52 push %edx <== NOT EXECUTED 10f9dd: 52 push %edx <== NOT EXECUTED 10f9de: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10f9e1: 50 push %eax <== NOT EXECUTED 10f9e2: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10f9e5: e8 f6 0d 00 00 call 1107e0 <== NOT EXECUTED 10f9ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED read += chunk; 10f9ed: 8b 4d d0 mov -0x30(%ebp),%ecx <== NOT EXECUTED 10f9f0: 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) { 10f9f3: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10f9f6: 39 7d d4 cmp %edi,-0x2c(%ebp) <== NOT EXECUTED 10f9f9: 0f 82 64 ff ff ff jb 10f963 <== NOT EXECUTED 10f9ff: 31 f6 xor %esi,%esi <== NOT EXECUTED PIPE_WAKEUPWRITERS(pipe); read += chunk; } out_locked: PIPE_UNLOCK(pipe); 10fa01: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fa04: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10fa07: e8 5c a6 ff ff call 10a068 <== NOT EXECUTED 10fa0c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED out_nolock: if (read > 0) 10fa0f: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) <== NOT EXECUTED 10fa13: 7f 03 jg 10fa18 <== NOT EXECUTED 10fa15: 89 75 d4 mov %esi,-0x2c(%ebp) <== NOT EXECUTED return read; return ret; } 10fa18: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10fa1b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fa1e: 5b pop %ebx <== NOT EXECUTED 10fa1f: 5e pop %esi <== NOT EXECUTED 10fa20: 5f pop %edi <== NOT EXECUTED 10fa21: c9 leave <== NOT EXECUTED 10fa22: c3 ret <== NOT EXECUTED 0010fc07 : */ int pipe_release( pipe_control_t **pipep, rtems_libio_t *iop ) { 10fc07: 55 push %ebp <== NOT EXECUTED 10fc08: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fc0a: 57 push %edi <== NOT EXECUTED 10fc0b: 56 push %esi <== NOT EXECUTED 10fc0c: 53 push %ebx <== NOT EXECUTED 10fc0d: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 10fc10: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED pipe_control_t *pipe = *pipep; 10fc13: 8b 1f mov (%edi),%ebx <== NOT EXECUTED uint32_t mode; rtems_status_code sc; sc = rtems_semaphore_obtain(pipe->Semaphore, 10fc15: 6a 00 push $0x0 <== NOT EXECUTED 10fc17: 6a 00 push $0x0 <== NOT EXECUTED 10fc19: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10fc1c: e8 5b a3 ff ff call 109f7c <== NOT EXECUTED RTEMS_WAIT, RTEMS_NO_TIMEOUT); /* WARN pipe not released! */ if(sc != RTEMS_SUCCESSFUL) 10fc21: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fc24: 85 c0 test %eax,%eax <== NOT EXECUTED 10fc26: 75 34 jne 10fc5c <== NOT EXECUTED rtems_fatal_error_occurred(sc); mode = LIBIO_ACCMODE(iop); 10fc28: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10fc2b: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10fc2e: 89 c6 mov %eax,%esi <== NOT EXECUTED 10fc30: 83 e6 06 and $0x6,%esi <== NOT EXECUTED if (mode & LIBIO_FLAGS_READ) 10fc33: a8 02 test $0x2,%al <== NOT EXECUTED 10fc35: 74 03 je 10fc3a <== NOT EXECUTED pipe->Readers --; 10fc37: ff 4b 10 decl 0x10(%ebx) <== NOT EXECUTED if (mode & LIBIO_FLAGS_WRITE) 10fc3a: f7 c6 04 00 00 00 test $0x4,%esi <== NOT EXECUTED 10fc40: 74 03 je 10fc45 <== NOT EXECUTED pipe->Writers --; 10fc42: ff 4b 14 decl 0x14(%ebx) <== NOT EXECUTED sc = rtems_semaphore_obtain(rtems_pipe_semaphore, 10fc45: 50 push %eax <== NOT EXECUTED 10fc46: 6a 00 push $0x0 <== NOT EXECUTED 10fc48: 6a 00 push $0x0 <== NOT EXECUTED 10fc4a: ff 35 94 3e 12 00 pushl 0x123e94 <== NOT EXECUTED 10fc50: e8 27 a3 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) 10fc55: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fc58: 85 c0 test %eax,%eax <== NOT EXECUTED 10fc5a: 74 09 je 10fc65 <== NOT EXECUTED rtems_fatal_error_occurred(sc); 10fc5c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fc5f: 50 push %eax <== NOT EXECUTED 10fc60: e8 d7 a8 ff ff call 10a53c <== NOT EXECUTED PIPE_UNLOCK(pipe); 10fc65: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fc68: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10fc6b: e8 f8 a3 ff ff call 10a068 <== NOT EXECUTED if (pipe->Readers == 0 && pipe->Writers == 0) { 10fc70: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10fc73: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fc76: 85 c0 test %eax,%eax <== NOT EXECUTED 10fc78: 75 15 jne 10fc8f <== NOT EXECUTED 10fc7a: 83 7b 14 00 cmpl $0x0,0x14(%ebx) <== NOT EXECUTED 10fc7e: 75 0f jne 10fc8f <== NOT EXECUTED #if 0 /* To delete an anonymous pipe file when all users closed it */ if (pipe->Anonymous) delfile = TRUE; #endif pipe_free(pipe); 10fc80: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10fc82: e8 45 ff ff ff call 10fbcc <== NOT EXECUTED *pipep = NULL; 10fc87: 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) { 10fc8d: eb 30 jmp 10fcbf <== NOT EXECUTED delfile = TRUE; #endif pipe_free(pipe); *pipep = NULL; } else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE) 10fc8f: 83 fe 04 cmp $0x4,%esi <== NOT EXECUTED 10fc92: 74 0f je 10fca3 <== NOT EXECUTED 10fc94: 85 c0 test %eax,%eax <== NOT EXECUTED 10fc96: 75 0b jne 10fca3 <== NOT EXECUTED /* Notify waiting Writers that all their partners left */ PIPE_WAKEUPWRITERS(pipe); 10fc98: 57 push %edi <== NOT EXECUTED 10fc99: 57 push %edi <== NOT EXECUTED 10fc9a: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10fc9d: 50 push %eax <== NOT EXECUTED 10fc9e: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10fca1: eb 14 jmp 10fcb7 <== NOT EXECUTED else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ) 10fca3: 83 fe 02 cmp $0x2,%esi <== NOT EXECUTED 10fca6: 74 17 je 10fcbf <== NOT EXECUTED 10fca8: 83 7b 14 00 cmpl $0x0,0x14(%ebx) <== NOT EXECUTED 10fcac: 75 11 jne 10fcbf <== NOT EXECUTED PIPE_WAKEUPREADERS(pipe); 10fcae: 56 push %esi <== NOT EXECUTED 10fcaf: 56 push %esi <== NOT EXECUTED 10fcb0: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10fcb3: 50 push %eax <== NOT EXECUTED 10fcb4: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10fcb7: e8 24 0b 00 00 call 1107e0 <== NOT EXECUTED 10fcbc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_semaphore_release(rtems_pipe_semaphore); 10fcbf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fcc2: ff 35 94 3e 12 00 pushl 0x123e94 <== NOT EXECUTED 10fcc8: e8 9b a3 ff ff call 10a068 <== NOT EXECUTED if(iop->pathinfo.ops->unlink_h(&iop->pathinfo)) return -errno; #endif return 0; } 10fccd: 31 c0 xor %eax,%eax <== NOT EXECUTED 10fccf: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fcd2: 5b pop %ebx <== NOT EXECUTED 10fcd3: 5e pop %esi <== NOT EXECUTED 10fcd4: 5f pop %edi <== NOT EXECUTED 10fcd5: c9 leave <== NOT EXECUTED 10fcd6: c3 ret <== NOT EXECUTED 0010fa23 : pipe_control_t *pipe, const void *buffer, size_t count, rtems_libio_t *iop ) { 10fa23: 55 push %ebp <== NOT EXECUTED 10fa24: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fa26: 57 push %edi <== NOT EXECUTED 10fa27: 56 push %esi <== NOT EXECUTED 10fa28: 53 push %ebx <== NOT EXECUTED 10fa29: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10fa2c: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED int chunk, chunk1, written = 0, ret = 0; /* Write nothing */ if (count == 0) 10fa2f: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED 10fa36: 83 7d 10 00 cmpl $0x0,0x10(%ebp) <== NOT EXECUTED 10fa3a: 0f 84 81 01 00 00 je 10fbc1 <== NOT EXECUTED return 0; if (! PIPE_LOCK(pipe)) 10fa40: 56 push %esi <== NOT EXECUTED 10fa41: 6a 00 push $0x0 <== NOT EXECUTED 10fa43: 6a 00 push $0x0 <== NOT EXECUTED 10fa45: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10fa48: e8 2f a5 ff ff call 109f7c <== NOT EXECUTED 10fa4d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fa50: c7 45 d4 fc ff ff ff movl $0xfffffffc,-0x2c(%ebp) <== NOT EXECUTED 10fa57: 85 c0 test %eax,%eax <== NOT EXECUTED 10fa59: 0f 85 62 01 00 00 jne 10fbc1 <== NOT EXECUTED return -EINTR; if (pipe->Readers == 0) { 10fa5f: 83 7b 10 00 cmpl $0x0,0x10(%ebx) <== NOT EXECUTED 10fa63: 75 11 jne 10fa76 <== NOT EXECUTED 10fa65: be e0 ff ff ff mov $0xffffffe0,%esi <== NOT EXECUTED 10fa6a: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED 10fa71: e9 1d 01 00 00 jmp 10fb93 <== NOT EXECUTED ret = -EPIPE; goto out_locked; } /* Write of PIPE_BUF bytes or less shall not be interleaved */ chunk = count <= pipe->Size ? count : 1; 10fa76: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10fa79: 3b 7b 04 cmp 0x4(%ebx),%edi <== NOT EXECUTED 10fa7c: 76 05 jbe 10fa83 <== NOT EXECUTED 10fa7e: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED 10fa83: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED 10fa8a: e9 f6 00 00 00 jmp 10fb85 <== NOT EXECUTED while (written < count) { while (PIPE_SPACE(pipe) < chunk) { if (LIBIO_NODELAY(iop)) { 10fa8f: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10fa92: f6 40 14 01 testb $0x1,0x14(%eax) <== NOT EXECUTED 10fa96: 74 0a je 10faa2 <== NOT EXECUTED 10fa98: be f5 ff ff ff mov $0xfffffff5,%esi <== NOT EXECUTED 10fa9d: e9 f1 00 00 00 jmp 10fb93 <== NOT EXECUTED ret = -EAGAIN; goto out_locked; } /* Wait until there is chunk bytes space or no reader exists */ pipe->waitingWriters ++; 10faa2: ff 43 1c incl 0x1c(%ebx) <== NOT EXECUTED PIPE_UNLOCK(pipe); 10faa5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10faa8: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10faab: e8 b8 a5 ff ff call 10a068 <== NOT EXECUTED if (! PIPE_WRITEWAIT(pipe)) 10fab0: 5a pop %edx <== NOT EXECUTED 10fab1: 59 pop %ecx <== NOT EXECUTED 10fab2: 6a 00 push $0x0 <== NOT EXECUTED 10fab4: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10fab7: e8 7c 0d 00 00 call 110838 <== NOT EXECUTED 10fabc: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10fabf: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10fac2: 19 f6 sbb %esi,%esi <== NOT EXECUTED 10fac4: f7 d6 not %esi <== NOT EXECUTED 10fac6: 83 e6 fc and $0xfffffffc,%esi <== NOT EXECUTED ret = -EINTR; if (! PIPE_LOCK(pipe)) { 10fac9: 6a 00 push $0x0 <== NOT EXECUTED 10facb: 6a 00 push $0x0 <== NOT EXECUTED 10facd: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10fad0: e8 a7 a4 ff ff call 109f7c <== NOT EXECUTED 10fad5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fad8: 85 c0 test %eax,%eax <== NOT EXECUTED 10fada: 74 0a je 10fae6 <== NOT EXECUTED 10fadc: be fc ff ff ff mov $0xfffffffc,%esi <== NOT EXECUTED 10fae1: e9 d2 00 00 00 jmp 10fbb8 <== NOT EXECUTED /* WARN waitingWriters not restored! */ ret = -EINTR; goto out_nolock; } pipe->waitingWriters --; 10fae6: ff 4b 1c decl 0x1c(%ebx) <== NOT EXECUTED if (ret != 0) 10fae9: 85 f6 test %esi,%esi <== NOT EXECUTED 10faeb: 0f 85 a2 00 00 00 jne 10fb93 <== NOT EXECUTED goto out_locked; if (pipe->Readers == 0) { 10faf1: 83 7b 10 00 cmpl $0x0,0x10(%ebx) <== NOT EXECUTED 10faf5: 75 0a jne 10fb01 <== NOT EXECUTED 10faf7: be e0 ff ff ff mov $0xffffffe0,%esi <== NOT EXECUTED 10fafc: e9 92 00 00 00 jmp 10fb93 <== 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) { 10fb01: 8b 73 04 mov 0x4(%ebx),%esi <== NOT EXECUTED 10fb04: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10fb07: 89 f1 mov %esi,%ecx <== NOT EXECUTED 10fb09: 29 c1 sub %eax,%ecx <== NOT EXECUTED 10fb0b: 39 f9 cmp %edi,%ecx <== NOT EXECUTED 10fb0d: 72 80 jb 10fa8f <== NOT EXECUTED ret = -EPIPE; goto out_locked; } } chunk = MIN(count - written, PIPE_SPACE(pipe)); 10fb0f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10fb12: 2b 55 d4 sub -0x2c(%ebp),%edx <== NOT EXECUTED 10fb15: 89 4d d0 mov %ecx,-0x30(%ebp) <== NOT EXECUTED 10fb18: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 10fb1a: 76 03 jbe 10fb1f <== NOT EXECUTED 10fb1c: 89 55 d0 mov %edx,-0x30(%ebp) <== NOT EXECUTED chunk1 = pipe->Size - PIPE_WSTART(pipe); 10fb1f: 03 43 08 add 0x8(%ebx),%eax <== NOT EXECUTED 10fb22: 31 d2 xor %edx,%edx <== NOT EXECUTED 10fb24: f7 f6 div %esi <== NOT EXECUTED 10fb26: 89 f0 mov %esi,%eax <== NOT EXECUTED 10fb28: 29 d0 sub %edx,%eax <== NOT EXECUTED if (chunk > chunk1) { 10fb2a: 39 45 d0 cmp %eax,-0x30(%ebp) <== NOT EXECUTED 10fb2d: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10fb30: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED 10fb33: 8d 34 0f lea (%edi,%ecx,1),%esi <== NOT EXECUTED 10fb36: 7e 1c jle 10fb54 <== NOT EXECUTED memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1); 10fb38: 03 13 add (%ebx),%edx <== NOT EXECUTED 10fb3a: 89 d7 mov %edx,%edi <== NOT EXECUTED 10fb3c: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10fb3e: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1); 10fb40: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10fb42: 8b 4d d0 mov -0x30(%ebp),%ecx <== NOT EXECUTED 10fb45: 29 c1 sub %eax,%ecx <== NOT EXECUTED 10fb47: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED 10fb4a: 8d 34 38 lea (%eax,%edi,1),%esi <== NOT EXECUTED 10fb4d: 03 75 0c add 0xc(%ebp),%esi <== NOT EXECUTED 10fb50: 89 d7 mov %edx,%edi <== NOT EXECUTED 10fb52: eb 07 jmp 10fb5b <== NOT EXECUTED } else memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk); 10fb54: 03 13 add (%ebx),%edx <== NOT EXECUTED 10fb56: 89 d7 mov %edx,%edi <== NOT EXECUTED 10fb58: 8b 4d d0 mov -0x30(%ebp),%ecx <== NOT EXECUTED 10fb5b: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED pipe->Length += chunk; 10fb5d: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 10fb60: 01 43 0c add %eax,0xc(%ebx) <== NOT EXECUTED if (pipe->waitingReaders > 0) 10fb63: 83 7b 18 00 cmpl $0x0,0x18(%ebx) <== NOT EXECUTED 10fb67: 74 11 je 10fb7a <== NOT EXECUTED PIPE_WAKEUPREADERS(pipe); 10fb69: 50 push %eax <== NOT EXECUTED 10fb6a: 50 push %eax <== NOT EXECUTED 10fb6b: 8d 4d e4 lea -0x1c(%ebp),%ecx <== NOT EXECUTED 10fb6e: 51 push %ecx <== NOT EXECUTED 10fb6f: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10fb72: e8 69 0c 00 00 call 1107e0 <== NOT EXECUTED 10fb77: 83 c4 10 add $0x10,%esp <== NOT EXECUTED written += chunk; 10fb7a: 8b 7d d0 mov -0x30(%ebp),%edi <== NOT EXECUTED 10fb7d: 01 7d d4 add %edi,-0x2c(%ebp) <== NOT EXECUTED 10fb80: 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) { 10fb85: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10fb88: 39 45 d4 cmp %eax,-0x2c(%ebp) <== NOT EXECUTED 10fb8b: 0f 82 70 ff ff ff jb 10fb01 <== NOT EXECUTED 10fb91: 31 f6 xor %esi,%esi <== NOT EXECUTED /* Write of more than PIPE_BUF bytes can be interleaved */ chunk = 1; } out_locked: PIPE_UNLOCK(pipe); 10fb93: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fb96: ff 73 28 pushl 0x28(%ebx) <== NOT EXECUTED 10fb99: e8 ca a4 ff ff call 10a068 <== NOT EXECUTED 10fb9e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED out_nolock: #ifdef RTEMS_POSIX_API /* Signal SIGPIPE */ if (ret == -EPIPE) 10fba1: 83 fe e0 cmp $0xffffffe0,%esi <== NOT EXECUTED 10fba4: 75 12 jne 10fbb8 <== NOT EXECUTED kill(getpid(), SIGPIPE); 10fba6: e8 49 07 00 00 call 1102f4 <== NOT EXECUTED 10fbab: 57 push %edi <== NOT EXECUTED 10fbac: 57 push %edi <== NOT EXECUTED 10fbad: 6a 0d push $0xd <== NOT EXECUTED 10fbaf: 50 push %eax <== NOT EXECUTED 10fbb0: e8 13 09 00 00 call 1104c8 <== NOT EXECUTED 10fbb5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif if (written > 0) 10fbb8: 83 7d d4 00 cmpl $0x0,-0x2c(%ebp) <== NOT EXECUTED 10fbbc: 7f 03 jg 10fbc1 <== NOT EXECUTED 10fbbe: 89 75 d4 mov %esi,-0x2c(%ebp) <== NOT EXECUTED return written; return ret; } 10fbc1: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10fbc4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fbc7: 5b pop %ebx <== NOT EXECUTED 10fbc8: 5e pop %esi <== NOT EXECUTED 10fbc9: 5f pop %edi <== NOT EXECUTED 10fbca: c9 leave <== NOT EXECUTED 10fbcb: c3 ret <== NOT EXECUTED 001106ac : } void pthread_exit( void *value_ptr ) { 1106ac: 55 push %ebp 1106ad: 89 e5 mov %esp,%ebp 1106af: 83 ec 10 sub $0x10,%esp _POSIX_Thread_Exit( _Thread_Executing, value_ptr ); 1106b2: ff 75 08 pushl 0x8(%ebp) 1106b5: ff 35 a8 42 12 00 pushl 0x1242a8 1106bb: e8 88 ff ff ff call 110648 <_POSIX_Thread_Exit> 1106c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1106c3: c9 leave <== NOT EXECUTED 1106c4: c3 ret <== NOT EXECUTED 0010a434 : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 10a434: 55 push %ebp 10a435: 89 e5 mov %esp,%ebp 10a437: 53 push %ebx 10a438: 83 ec 04 sub $0x4,%esp * Don't even think about deleting a resource from an ISR. * Besides this request is supposed to be for _Thread_Executing * and the ISR context is not a thread. */ if ( _ISR_Is_in_progress() ) 10a43b: a1 74 62 12 00 mov 0x126274,%eax 10a440: 85 c0 test %eax,%eax 10a442: 75 48 jne 10a48c return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a444: a1 98 62 12 00 mov 0x126298,%eax 10a449: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax 10a44f: 8b 15 dc 61 12 00 mov 0x1261dc,%edx 10a455: 42 inc %edx 10a456: 89 15 dc 61 12 00 mov %edx,0x1261dc _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10a45c: 31 db xor %ebx,%ebx 10a45e: 83 b8 d4 00 00 00 00 cmpl $0x0,0xd4(%eax) 10a465: 75 0a jne 10a471 /* Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ int _EXFUN(pthread_setcancelstate, (int __state, int *__oldstate)); int _EXFUN(pthread_setcanceltype, (int __type, int *__oldtype)); void _EXFUN(pthread_testcancel, (void)); 10a467: 83 b8 dc 00 00 00 00 cmpl $0x0,0xdc(%eax) 10a46e: 0f 95 c3 setne %bl thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a471: e8 6f 22 00 00 call 10c6e5 <_Thread_Enable_dispatch> if ( cancel ) 10a476: 84 db test %bl,%bl 10a478: 74 12 je 10a48c _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10a47a: 50 push %eax 10a47b: 50 push %eax 10a47c: 6a ff push $0xffffffff 10a47e: ff 35 98 62 12 00 pushl 0x126298 10a484: e8 a7 4c 00 00 call 10f130 <_POSIX_Thread_Exit> 10a489: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10a48c: 8b 5d fc mov -0x4(%ebp),%ebx 10a48f: c9 leave 10a490: c3 ret 0011ca48 : ssize_t read( int fd, void *buffer, size_t count ) { 11ca48: 55 push %ebp 11ca49: 89 e5 mov %esp,%ebp 11ca4b: 56 push %esi 11ca4c: 53 push %ebx 11ca4d: 8b 5d 08 mov 0x8(%ebp),%ebx 11ca50: 8b 55 0c mov 0xc(%ebp),%edx 11ca53: 8b 4d 10 mov 0x10(%ebp),%ecx ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11ca56: 3b 1d 44 01 12 00 cmp 0x120144,%ebx 11ca5c: 73 14 jae 11ca72 iop = rtems_libio_iop( fd ); 11ca5e: c1 e3 06 shl $0x6,%ebx 11ca61: 03 1d 90 40 12 00 add 0x124090,%ebx rtems_libio_check_is_open( iop ); 11ca67: 8b 73 14 mov 0x14(%ebx),%esi 11ca6a: f7 c6 00 01 00 00 test $0x100,%esi 11ca70: 75 0d jne 11ca7f 11ca72: e8 dd 4a ff ff call 111554 <__errno> 11ca77: c7 00 09 00 00 00 movl $0x9,(%eax) 11ca7d: eb 31 jmp 11cab0 rtems_libio_check_buffer( buffer ); 11ca7f: 85 d2 test %edx,%edx 11ca81: 74 0b je 11ca8e rtems_libio_check_count( count ); 11ca83: 31 c0 xor %eax,%eax 11ca85: 85 c9 test %ecx,%ecx 11ca87: 74 44 je 11cacd rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 11ca89: 83 e6 02 and $0x2,%esi 11ca8c: 75 0d jne 11ca9b 11ca8e: e8 c1 4a ff ff call 111554 <__errno> <== NOT EXECUTED 11ca93: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11ca99: eb 15 jmp 11cab0 <== NOT EXECUTED /* * Now process the read(). */ if ( !iop->handlers->read_h ) 11ca9b: 8b 43 3c mov 0x3c(%ebx),%eax 11ca9e: 8b 40 08 mov 0x8(%eax),%eax 11caa1: 85 c0 test %eax,%eax 11caa3: 75 10 jne 11cab5 rtems_set_errno_and_return_minus_one( ENOTSUP ); 11caa5: e8 aa 4a ff ff call 111554 <__errno> <== NOT EXECUTED 11caaa: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11cab0: 83 c8 ff or $0xffffffff,%eax 11cab3: eb 18 jmp 11cacd rc = (*iop->handlers->read_h)( iop, buffer, count ); 11cab5: 56 push %esi 11cab6: 51 push %ecx 11cab7: 52 push %edx 11cab8: 53 push %ebx 11cab9: ff d0 call *%eax if ( rc > 0 ) 11cabb: 83 c4 10 add $0x10,%esp 11cabe: 85 c0 test %eax,%eax 11cac0: 7e 0b jle 11cacd iop->offset += rc; 11cac2: 89 c1 mov %eax,%ecx 11cac4: c1 f9 1f sar $0x1f,%ecx 11cac7: 01 43 0c add %eax,0xc(%ebx) 11caca: 11 4b 10 adc %ecx,0x10(%ebx) return rc; } 11cacd: 8d 65 f8 lea -0x8(%ebp),%esp 11cad0: 5b pop %ebx 11cad1: 5e pop %esi 11cad2: c9 leave 11cad3: c3 ret 001269e8 : ssize_t readlink( const char *pathname, char *buf, size_t bufsize ) { 1269e8: 55 push %ebp 1269e9: 89 e5 mov %esp,%ebp 1269eb: 57 push %edi 1269ec: 56 push %esi 1269ed: 53 push %ebx 1269ee: 83 ec 2c sub $0x2c,%esp 1269f1: 8b 55 08 mov 0x8(%ebp),%edx 1269f4: 8b 5d 0c mov 0xc(%ebp),%ebx rtems_filesystem_location_info_t loc; int result; if (!buf) 1269f7: 85 db test %ebx,%ebx 1269f9: 75 0d jne 126a08 rtems_set_errno_and_return_minus_one( EFAULT ); 1269fb: e8 14 30 01 00 call 139a14 <__errno> <== NOT EXECUTED 126a00: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 126a06: eb 51 jmp 126a59 <== NOT EXECUTED result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ), 126a08: 31 c0 xor %eax,%eax 126a0a: 83 c9 ff or $0xffffffff,%ecx 126a0d: 89 d7 mov %edx,%edi 126a0f: f2 ae repnz scas %es:(%edi),%al 126a11: f7 d1 not %ecx 126a13: 49 dec %ecx 126a14: 83 ec 0c sub $0xc,%esp 126a17: 6a 00 push $0x0 126a19: 8d 75 d4 lea -0x2c(%ebp),%esi 126a1c: 56 push %esi 126a1d: 6a 00 push $0x0 126a1f: 51 push %ecx 126a20: 52 push %edx 126a21: e8 a2 4c fe ff call 10b6c8 0, &loc, false ); if ( result != 0 ) 126a26: 83 c4 20 add $0x20,%esp 126a29: 83 cf ff or $0xffffffff,%edi 126a2c: 85 c0 test %eax,%eax 126a2e: 0f 85 8c 00 00 00 jne 126ac0 return -1; if ( !loc.ops->node_type_h ){ 126a34: 8b 55 e0 mov -0x20(%ebp),%edx 126a37: 8b 42 10 mov 0x10(%edx),%eax 126a3a: 85 c0 test %eax,%eax 126a3c: 75 20 jne 126a5e rtems_filesystem_freenode( &loc ); 126a3e: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 126a41: 85 c0 test %eax,%eax <== NOT EXECUTED 126a43: 74 09 je 126a4e <== NOT EXECUTED 126a45: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 126a48: 56 push %esi <== NOT EXECUTED 126a49: ff d0 call *%eax <== NOT EXECUTED 126a4b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 126a4e: e8 c1 2f 01 00 call 139a14 <__errno> <== NOT EXECUTED 126a53: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 126a59: 83 cf ff or $0xffffffff,%edi 126a5c: eb 62 jmp 126ac0 } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){ 126a5e: 83 ec 0c sub $0xc,%esp 126a61: 56 push %esi 126a62: ff d0 call *%eax 126a64: 83 c4 10 add $0x10,%esp 126a67: 83 f8 04 cmp $0x4,%eax 126a6a: 8b 45 e0 mov -0x20(%ebp),%eax 126a6d: 74 21 je 126a90 rtems_filesystem_freenode( &loc ); 126a6f: 85 c0 test %eax,%eax 126a71: 74 10 je 126a83 126a73: 8b 40 1c mov 0x1c(%eax),%eax 126a76: 85 c0 test %eax,%eax 126a78: 74 09 je 126a83 126a7a: 83 ec 0c sub $0xc,%esp 126a7d: 56 push %esi 126a7e: ff d0 call *%eax 126a80: 83 c4 10 add $0x10,%esp rtems_set_errno_and_return_minus_one( EINVAL ); 126a83: e8 8c 2f 01 00 call 139a14 <__errno> 126a88: c7 00 16 00 00 00 movl $0x16,(%eax) 126a8e: eb c9 jmp 126a59 } if ( !loc.ops->readlink_h ){ 126a90: 8b 50 3c mov 0x3c(%eax),%edx 126a93: 85 d2 test %edx,%edx 126a95: 75 05 jne 126a9c rtems_filesystem_freenode( &loc ); 126a97: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 126a9a: eb a5 jmp 126a41 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); 126a9c: 50 push %eax 126a9d: ff 75 10 pushl 0x10(%ebp) 126aa0: 53 push %ebx 126aa1: 56 push %esi 126aa2: ff d2 call *%edx 126aa4: 89 c7 mov %eax,%edi rtems_filesystem_freenode( &loc ); 126aa6: 8b 45 e0 mov -0x20(%ebp),%eax 126aa9: 83 c4 10 add $0x10,%esp 126aac: 85 c0 test %eax,%eax 126aae: 74 10 je 126ac0 126ab0: 8b 40 1c mov 0x1c(%eax),%eax 126ab3: 85 c0 test %eax,%eax 126ab5: 74 09 je 126ac0 126ab7: 83 ec 0c sub $0xc,%esp 126aba: 56 push %esi 126abb: ff d0 call *%eax 126abd: 83 c4 10 add $0x10,%esp return result; } 126ac0: 89 f8 mov %edi,%eax 126ac2: 8d 65 f4 lea -0xc(%ebp),%esp 126ac5: 5b pop %ebx 126ac6: 5e pop %esi 126ac7: 5f pop %edi 126ac8: c9 leave 126ac9: 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 48 12 00 cmp 0x124844,%esi 108ccd: 73 11 jae 108ce0 iop = rtems_libio_iop( fd ); 108ccf: c1 e6 06 shl $0x6,%esi 108cd2: 03 35 68 8f 12 00 add 0x128f68,%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 e7 a6 00 00 call 1133cc <__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 b7 a6 00 00 call 1133cc <__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 91 a6 00 00 call 1133cc <__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 0011cb54 : { uintptr_t old_size; char *new_area; uintptr_t resize; MSBUMP(realloc_calls, 1); 11cb54: 55 push %ebp 11cb55: 89 e5 mov %esp,%ebp 11cb57: 57 push %edi 11cb58: 56 push %esi 11cb59: 53 push %ebx 11cb5a: 83 ec 2c sub $0x2c,%esp 11cb5d: 8b 5d 08 mov 0x8(%ebp),%ebx 11cb60: 8b 75 0c mov 0xc(%ebp),%esi 11cb63: ff 05 b8 40 12 00 incl 0x1240b8 /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 11cb69: 83 3d 84 43 12 00 03 cmpl $0x3,0x124384 11cb70: 75 1a jne 11cb8c if (_Thread_Dispatch_disable_level > 0) 11cb72: a1 ec 41 12 00 mov 0x1241ec,%eax 11cb77: 85 c0 test %eax,%eax 11cb79: 0f 85 a7 00 00 00 jne 11cc26 return (void *) 0; if (_ISR_Nest_level > 0) 11cb7f: a1 84 42 12 00 mov 0x124284,%eax 11cb84: 85 c0 test %eax,%eax 11cb86: 0f 85 9a 00 00 00 jne 11cc26 } /* * Continue with realloc(). */ if ( !ptr ) 11cb8c: 85 db test %ebx,%ebx 11cb8e: 75 0e jne 11cb9e return malloc( size ); 11cb90: 83 ec 0c sub $0xc,%esp 11cb93: 56 push %esi 11cb94: e8 13 a8 fe ff call 1073ac 11cb99: e9 81 00 00 00 jmp 11cc1f if ( !size ) { 11cb9e: 85 f6 test %esi,%esi 11cba0: 75 0d jne 11cbaf free( ptr ); 11cba2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11cba5: 53 push %ebx <== NOT EXECUTED 11cba6: e8 d5 a5 fe ff call 107180 <== NOT EXECUTED 11cbab: 31 db xor %ebx,%ebx <== NOT EXECUTED 11cbad: eb 72 jmp 11cc21 <== NOT EXECUTED return (void *) 0; } if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) { 11cbaf: 52 push %edx 11cbb0: 8d 45 e4 lea -0x1c(%ebp),%eax 11cbb3: 50 push %eax 11cbb4: 53 push %ebx 11cbb5: ff 35 50 01 12 00 pushl 0x120150 11cbbb: e8 00 01 00 00 call 11ccc0 <_Protected_heap_Get_block_size> 11cbc0: 83 c4 10 add $0x10,%esp 11cbc3: 84 c0 test %al,%al 11cbc5: 75 0d jne 11cbd4 errno = EINVAL; 11cbc7: e8 88 49 ff ff call 111554 <__errno> 11cbcc: c7 00 16 00 00 00 movl $0x16,(%eax) 11cbd2: eb 52 jmp 11cc26 #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 ) ) { 11cbd4: 50 push %eax 11cbd5: 56 push %esi 11cbd6: 53 push %ebx 11cbd7: ff 35 50 01 12 00 pushl 0x120150 11cbdd: e8 16 01 00 00 call 11ccf8 <_Protected_heap_Resize_block> 11cbe2: 83 c4 10 add $0x10,%esp 11cbe5: 84 c0 test %al,%al 11cbe7: 75 3f jne 11cc28 * 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 ); 11cbe9: 83 ec 0c sub $0xc,%esp 11cbec: 56 push %esi 11cbed: e8 ba a7 fe ff call 1073ac MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */ 11cbf2: ff 0d ac 40 12 00 decl 0x1240ac if ( !new_area ) { 11cbf8: 83 c4 10 add $0x10,%esp 11cbfb: 85 c0 test %eax,%eax 11cbfd: 74 27 je 11cc26 return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 11cbff: 8b 55 e4 mov -0x1c(%ebp),%edx 11cc02: 89 f1 mov %esi,%ecx 11cc04: 39 d6 cmp %edx,%esi 11cc06: 76 02 jbe 11cc0a 11cc08: 89 d1 mov %edx,%ecx 11cc0a: 89 c7 mov %eax,%edi 11cc0c: 89 de mov %ebx,%esi 11cc0e: f3 a4 rep movsb %ds:(%esi),%es:(%edi) free( ptr ); 11cc10: 83 ec 0c sub $0xc,%esp 11cc13: 53 push %ebx 11cc14: 89 45 d4 mov %eax,-0x2c(%ebp) 11cc17: e8 64 a5 fe ff call 107180 11cc1c: 8b 45 d4 mov -0x2c(%ebp),%eax 11cc1f: 89 c3 mov %eax,%ebx return new_area; 11cc21: 83 c4 10 add $0x10,%esp 11cc24: eb 02 jmp 11cc28 11cc26: 31 db xor %ebx,%ebx } 11cc28: 89 d8 mov %ebx,%eax 11cc2a: 8d 65 f4 lea -0xc(%ebp),%esp 11cc2d: 5b pop %ebx 11cc2e: 5e pop %esi 11cc2f: 5f pop %edi 11cc30: c9 leave 11cc31: 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 3c f7 15 00 mov 0x15f73c,%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 3c f7 15 00 mov 0x15f73c,%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 35 d0 02 00 call 139a14 <__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 e6 cf 02 00 call 139a14 <__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 00116368 : uint32_t bad_value #else uint32_t bad_value __attribute((unused)) #endif ) { 116368: 55 push %ebp <== NOT EXECUTED 116369: 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; } 11636b: b8 6c a0 12 00 mov $0x12a06c,%eax <== NOT EXECUTED 116370: c9 leave <== NOT EXECUTED 116371: c3 ret <== NOT EXECUTED 001132e4 : const char *rtems_assoc_name_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 1132e4: 55 push %ebp 1132e5: 89 e5 mov %esp,%ebp 1132e7: 53 push %ebx 1132e8: 83 ec 0c sub $0xc,%esp 1132eb: 8b 5d 0c mov 0xc(%ebp),%ebx const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 1132ee: 53 push %ebx 1132ef: ff 75 08 pushl 0x8(%ebp) 1132f2: e8 1d 00 00 00 call 113314 if (nap) 1132f7: 83 c4 10 add $0x10,%esp 1132fa: 85 c0 test %eax,%eax 1132fc: 74 07 je 113305 return nap->name; 1132fe: 8b 00 mov (%eax),%eax return rtems_assoc_name_bad(local_value); } 113300: 8b 5d fc mov -0x4(%ebp),%ebx 113303: c9 leave 113304: c3 ret nap = rtems_assoc_ptr_by_local(ap, local_value); if (nap) return nap->name; return rtems_assoc_name_bad(local_value); 113305: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 113308: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11330b: 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); 11330c: e9 57 30 00 00 jmp 116368 <== NOT EXECUTED 001114f4 : const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 1114f4: 55 push %ebp 1114f5: 89 e5 mov %esp,%ebp 1114f7: 56 push %esi 1114f8: 53 push %ebx 1114f9: 8b 5d 08 mov 0x8(%ebp),%ebx 1114fc: 8b 75 0c mov 0xc(%ebp),%esi const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 1114ff: 8b 03 mov (%ebx),%eax 111501: 85 c0 test %eax,%eax 111503: 74 1b je 111520 111505: 52 push %edx 111506: 52 push %edx 111507: 68 31 f0 11 00 push $0x11f031 11150c: 50 push %eax 11150d: e8 5e 0b 00 00 call 112070 111512: 83 c4 10 add $0x10,%esp 111515: 85 c0 test %eax,%eax 111517: 75 07 jne 111520 default_ap = ap++; 111519: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11151b: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 11151e: eb 0c jmp 11152c <== NOT EXECUTED 111520: 31 c0 xor %eax,%eax 111522: eb 08 jmp 11152c for ( ; ap->name; ap++) if (ap->local_value == local_value) 111524: 39 73 04 cmp %esi,0x4(%ebx) 111527: 74 0a je 111533 const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 111529: 83 c3 0c add $0xc,%ebx 11152c: 83 3b 00 cmpl $0x0,(%ebx) 11152f: 75 f3 jne 111524 111531: 89 c3 mov %eax,%ebx if (ap->local_value == local_value) return ap; return default_ap; } 111533: 89 d8 mov %ebx,%eax 111535: 8d 65 f8 lea -0x8(%ebp),%esp 111538: 5b pop %ebx 111539: 5e pop %esi 11153a: c9 leave 11153b: c3 ret 001102ac : const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 1102ac: 55 push %ebp 1102ad: 89 e5 mov %esp,%ebp 1102af: 56 push %esi 1102b0: 53 push %ebx 1102b1: 8b 5d 08 mov 0x8(%ebp),%ebx 1102b4: 8b 75 0c mov 0xc(%ebp),%esi const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 1102b7: 8b 03 mov (%ebx),%eax 1102b9: 85 c0 test %eax,%eax 1102bb: 74 1b je 1102d8 1102bd: 52 push %edx 1102be: 52 push %edx 1102bf: 68 31 f0 11 00 push $0x11f031 1102c4: 50 push %eax 1102c5: e8 a6 1d 00 00 call 112070 1102ca: 83 c4 10 add $0x10,%esp 1102cd: 85 c0 test %eax,%eax 1102cf: 75 07 jne 1102d8 default_ap = ap++; 1102d1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1102d3: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 1102d6: eb 0c jmp 1102e4 <== NOT EXECUTED 1102d8: 31 c0 xor %eax,%eax 1102da: eb 08 jmp 1102e4 for ( ; ap->name; ap++) if (ap->remote_value == remote_value) 1102dc: 39 73 08 cmp %esi,0x8(%ebx) 1102df: 74 0a je 1102eb const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; for ( ; ap->name; ap++) 1102e1: 83 c3 0c add $0xc,%ebx 1102e4: 83 3b 00 cmpl $0x0,(%ebx) 1102e7: 75 f3 jne 1102dc 1102e9: 89 c3 mov %eax,%ebx if (ap->remote_value == remote_value) return ap; return default_ap; } 1102eb: 89 d8 mov %ebx,%eax 1102ed: 8d 65 f8 lea -0x8(%ebp),%esp 1102f0: 5b pop %ebx 1102f1: 5e pop %esi 1102f2: c9 leave 1102f3: c3 ret 00110e5c : uint32_t rtems_assoc_remote_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 110e5c: 55 push %ebp <== NOT EXECUTED 110e5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110e5f: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 110e62: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 110e65: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 110e68: e8 87 06 00 00 call 1114f4 <== NOT EXECUTED 110e6d: 89 c2 mov %eax,%edx <== NOT EXECUTED if (nap) 110e6f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110e72: 31 c0 xor %eax,%eax <== NOT EXECUTED 110e74: 85 d2 test %edx,%edx <== NOT EXECUTED 110e76: 74 03 je 110e7b <== NOT EXECUTED return nap->remote_value; 110e78: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED return 0; } 110e7b: c9 leave <== NOT EXECUTED 110e7c: 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 00110e30 : { 0, 0, 0 }, }; int rtems_deviceio_errno(rtems_status_code code) { 110e30: 55 push %ebp <== NOT EXECUTED 110e31: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110e33: 53 push %ebx <== NOT EXECUTED 110e34: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED int rc; if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t ) code))) 110e37: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 110e3a: 68 bc f0 11 00 push $0x11f0bc <== NOT EXECUTED 110e3f: e8 18 00 00 00 call 110e5c <== NOT EXECUTED 110e44: 89 c3 mov %eax,%ebx <== NOT EXECUTED 110e46: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110e49: 85 c0 test %eax,%eax <== NOT EXECUTED 110e4b: 74 07 je 110e54 <== NOT EXECUTED { errno = rc; 110e4d: e8 02 07 00 00 call 111554 <__errno> <== NOT EXECUTED 110e52: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return -1; } return -1; } 110e54: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 110e57: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110e5a: c9 leave <== NOT EXECUTED 110e5b: 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 55 a4 00 00 call 111554 <__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 44 a4 00 00 call 111554 <__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 48 1f 12 00 mov 0x121f48,%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 48 1f 12 00 mov 0x121f48,%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 15 a5 00 00 call 111554 <__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 04 a5 00 00 call 111554 <__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 9d a4 00 00 call 111554 <__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 48 1f 12 00 mov 0x121f48,%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 28 d1 11 00 00 cmpl $0x0,0x11d128 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 4c 01 12 00 mov 0x12014c,%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 14 36 00 00 call 10a53c <== NOT EXECUTED rtems_filesystem_link_counts = 0; 106f28: 8b 3d 48 1f 12 00 mov 0x121f48,%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 02 e8 11 00 push $0x11e802 106f56: e8 7d 01 00 00 call 1070d8 rtems_filesystem_root = loc; 106f5b: 8b 3d 48 1f 12 00 mov 0x121f48,%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 02 e8 11 00 push $0x11e802 106f7c: e8 57 01 00 00 call 1070d8 rtems_filesystem_current = loc; 106f81: 8b 3d 48 1f 12 00 mov 0x121f48,%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 04 e8 11 00 push $0x11e804 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 7d a7 00 00 call 111554 <__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 44 01 12 00 mov 0x120144,%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 26 6a 00 00 call 10dc38 107212: a3 90 40 12 00 mov %eax,0x124090 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 94 40 12 00 mov %eax,0x124094 for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++) 10722a: 8b 1d 44 01 12 00 mov 0x120144,%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 98 40 12 00 push $0x124098 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 cc 32 00 00 call 10a53c <== NOT EXECUTED /* * Initialize the base file system infrastructure. */ if (rtems_fs_init_helper) 107270: a1 40 01 12 00 mov 0x120140,%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 001268dc : rtems_filesystem_freenode( &env->root_directory); free(env); } } rtems_status_code rtems_libio_set_private_env(void) { 1268dc: 55 push %ebp 1268dd: 89 e5 mov %esp,%ebp 1268df: 57 push %edi 1268e0: 56 push %esi 1268e1: 53 push %ebx 1268e2: 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); 1268e5: 8d 45 e4 lea -0x1c(%ebp),%eax 1268e8: 50 push %eax 1268e9: 6a 00 push $0x0 1268eb: 6a 00 push $0x0 1268ed: e8 e2 14 00 00 call 127dd4 1268f2: 89 45 c4 mov %eax,-0x3c(%ebp) if (sc != RTEMS_SUCCESSFUL) return sc; 1268f5: 83 c4 10 add $0x10,%esp 1268f8: 85 c0 test %eax,%eax 1268fa: 0f 85 da 00 00 00 jne 1269da /* Only for the first time a malloc is necesary */ if (rtems_current_user_env==&rtems_global_user_env) { 126900: 81 3d 3c f7 15 00 8c cmpl $0x16508c,0x15f73c 126907: 50 16 00 12690a: 75 54 jne 126960 rtems_user_env_t *tmp = malloc(sizeof(rtems_user_env_t)); 12690c: 83 ec 0c sub $0xc,%esp 12690f: 6a 48 push $0x48 126911: e8 46 53 fe ff call 10bc5c 126916: 89 c3 mov %eax,%ebx if (!tmp) 126918: 83 c4 10 add $0x10,%esp 12691b: 85 c0 test %eax,%eax 12691d: 75 0c jne 12692b 12691f: c7 45 c4 1a 00 00 00 movl $0x1a,-0x3c(%ebp) <== NOT EXECUTED 126926: e9 af 00 00 00 jmp 1269da <== 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); 12692b: 56 push %esi 12692c: 68 f0 67 12 00 push $0x1267f0 126931: 68 3c f7 15 00 push $0x15f73c 126936: 6a 00 push $0x0 126938: e8 3b 18 00 00 call 128178 12693d: 89 c6 mov %eax,%esi if (sc != RTEMS_SUCCESSFUL) { 12693f: 83 c4 10 add $0x10,%esp 126942: 85 c0 test %eax,%eax 126944: 74 14 je 12695a /* don't use free_user_env because the pathlocs are * not initialized yet */ free(tmp); 126946: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 126949: 53 push %ebx <== NOT EXECUTED 12694a: e8 21 4e fe ff call 10b770 <== NOT EXECUTED 12694f: 89 75 c4 mov %esi,-0x3c(%ebp) <== NOT EXECUTED return sc; 126952: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126955: e9 80 00 00 00 jmp 1269da <== NOT EXECUTED } rtems_current_user_env = tmp; 12695a: 89 1d 3c f7 15 00 mov %ebx,0x15f73c }; *rtems_current_user_env = rtems_global_user_env; /* get the global values*/ 126960: a1 3c f7 15 00 mov 0x15f73c,%eax 126965: be 8c 50 16 00 mov $0x16508c,%esi 12696a: b9 12 00 00 00 mov $0x12,%ecx 12696f: 89 c7 mov %eax,%edi 126971: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_current_user_env->task_id=task_id; /* mark the local values*/ 126973: 8b 55 e4 mov -0x1c(%ebp),%edx 126976: 89 10 mov %edx,(%eax) /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 126978: 8d 78 18 lea 0x18(%eax),%edi 12697b: 8b 35 74 50 16 00 mov 0x165074,%esi 126981: 83 c6 1c add $0x1c,%esi 126984: b1 05 mov $0x5,%cl 126986: 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); 126988: 83 ec 0c sub $0xc,%esp 12698b: 6a 00 push $0x0 12698d: 8d 5d d0 lea -0x30(%ebp),%ebx 126990: 53 push %ebx 126991: 6a 00 push $0x0 126993: 6a 01 push $0x1 126995: 68 66 b9 15 00 push $0x15b966 12699a: e8 29 4d fe ff call 10b6c8 rtems_filesystem_root = loc; 12699f: 8b 3d 3c f7 15 00 mov 0x15f73c,%edi 1269a5: 83 c7 18 add $0x18,%edi 1269a8: b9 05 00 00 00 mov $0x5,%ecx 1269ad: 89 de mov %ebx,%esi 1269af: f3 a5 rep movsl %ds:(%esi),%es:(%edi) rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0); 1269b1: 83 c4 14 add $0x14,%esp 1269b4: 6a 00 push $0x0 1269b6: 53 push %ebx 1269b7: 6a 00 push $0x0 1269b9: 6a 01 push $0x1 1269bb: 68 66 b9 15 00 push $0x15b966 1269c0: e8 03 4d fe ff call 10b6c8 rtems_filesystem_current = loc; 1269c5: 8b 3d 3c f7 15 00 mov 0x15f73c,%edi 1269cb: 83 c7 04 add $0x4,%edi 1269ce: b9 05 00 00 00 mov $0x5,%ecx 1269d3: 89 de mov %ebx,%esi 1269d5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) return RTEMS_SUCCESSFUL; 1269d7: 83 c4 20 add $0x20,%esp } 1269da: 8b 45 c4 mov -0x3c(%ebp),%eax 1269dd: 8d 65 f4 lea -0xc(%ebp),%esp 1269e0: 5b pop %ebx 1269e1: 5e pop %esi 1269e2: 5f pop %edi 1269e3: c9 leave 1269e4: c3 ret 00126847 : * 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) { 126847: 55 push %ebp <== NOT EXECUTED 126848: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12684a: 53 push %ebx <== NOT EXECUTED 12684b: 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); 12684e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 126851: 50 push %eax <== NOT EXECUTED 126852: 6a 00 push $0x0 <== NOT EXECUTED 126854: 6a 00 push $0x0 <== NOT EXECUTED 126856: e8 79 15 00 00 call 127dd4 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 12685b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12685e: 85 c0 test %eax,%eax <== NOT EXECUTED 126860: 75 75 jne 1268d7 <== NOT EXECUTED if (rtems_current_user_env->task_id==current_task_id) { 126862: 8b 1d 3c f7 15 00 mov 0x15f73c,%ebx <== NOT EXECUTED 126868: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 12686a: 3b 45 f0 cmp -0x10(%ebp),%eax <== NOT EXECUTED 12686d: 75 21 jne 126890 <== 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); 12686f: 51 push %ecx <== NOT EXECUTED 126870: 51 push %ecx <== NOT EXECUTED 126871: 68 3c f7 15 00 push $0x15f73c <== NOT EXECUTED 126876: 6a 00 push $0x0 <== NOT EXECUTED 126878: e8 8f 19 00 00 call 12820c <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 12687d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126880: 85 c0 test %eax,%eax <== NOT EXECUTED 126882: 75 53 jne 1268d7 <== NOT EXECUTED free_user_env(tmp); 126884: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 126887: 53 push %ebx <== NOT EXECUTED 126888: e8 63 ff ff ff call 1267f0 <== NOT EXECUTED 12688d: 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, 126890: 52 push %edx <== NOT EXECUTED 126891: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 126894: 50 push %eax <== NOT EXECUTED 126895: 68 3c f7 15 00 push $0x15f73c <== NOT EXECUTED 12689a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12689d: e8 e6 19 00 00 call 128288 <== NOT EXECUTED (void*)&shared_user_env ); if (sc != RTEMS_SUCCESSFUL) 1268a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1268a5: 85 c0 test %eax,%eax <== NOT EXECUTED 1268a7: 75 24 jne 1268cd <== NOT EXECUTED goto bailout; sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,free_user_env); 1268a9: 50 push %eax <== NOT EXECUTED 1268aa: 68 f0 67 12 00 push $0x1267f0 <== NOT EXECUTED 1268af: 68 3c f7 15 00 push $0x15f73c <== NOT EXECUTED 1268b4: 6a 00 push $0x0 <== NOT EXECUTED 1268b6: e8 bd 18 00 00 call 128178 <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 1268bb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1268be: 85 c0 test %eax,%eax <== NOT EXECUTED 1268c0: 75 0b jne 1268cd <== NOT EXECUTED goto bailout; /* the current_user_env is the same pointer that remote env */ rtems_current_user_env = shared_user_env; 1268c2: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 1268c5: 89 15 3c f7 15 00 mov %edx,0x15f73c <== NOT EXECUTED /* increase the reference count */ #ifdef HAVE_USERENV_REFCNT rtems_current_user_env->refcnt++; #endif return RTEMS_SUCCESSFUL; 1268cb: eb 0a jmp 1268d7 <== NOT EXECUTED bailout: /* fallback to the global env */ rtems_current_user_env = &rtems_global_user_env; 1268cd: c7 05 3c f7 15 00 8c movl $0x16508c,0x15f73c <== NOT EXECUTED 1268d4: 50 16 00 <== NOT EXECUTED return sc; } 1268d7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1268da: c9 leave <== NOT EXECUTED 1268db: c3 ret <== NOT EXECUTED 0010de44 : */ uint32_t rtems_libio_to_fcntl_flags( uint32_t flags ) { 10de44: 55 push %ebp 10de45: 89 e5 mov %esp,%ebp 10de47: 8b 55 08 mov 0x8(%ebp),%edx uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10de4a: 89 d1 mov %edx,%ecx 10de4c: 83 e1 06 and $0x6,%ecx 10de4f: b8 02 00 00 00 mov $0x2,%eax 10de54: 83 f9 06 cmp $0x6,%ecx 10de57: 74 0f je 10de68 fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { 10de59: 30 c0 xor %al,%al 10de5b: f6 c2 02 test $0x2,%dl 10de5e: 75 08 jne 10de68 10de60: 89 d0 mov %edx,%eax <== NOT EXECUTED 10de62: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED 10de65: 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 ) { 10de68: f6 c2 01 test $0x1,%dl 10de6b: 74 03 je 10de70 fcntl_flags |= O_NONBLOCK; 10de6d: 80 cc 40 or $0x40,%ah } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 10de70: f6 c6 02 test $0x2,%dh 10de73: 74 03 je 10de78 fcntl_flags |= O_APPEND; 10de75: 83 c8 08 or $0x8,%eax } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 10de78: 80 e6 04 and $0x4,%dh 10de7b: 74 03 je 10de80 fcntl_flags |= O_CREAT; 10de7d: 80 cc 02 or $0x2,%ah } return fcntl_flags; } 10de80: c9 leave 10de81: 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 10 d7 15 00 pushl 0x15d710 <== NOT EXECUTED 10bd13: e8 00 53 00 00 call 111018 <_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 6c 50 16 00 add %eax,0x16506c <== NOT EXECUTED 10bd2a: 11 15 70 50 16 00 adc %edx,0x165070 <== 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 10 d7 15 00 pushl 0x15d710 <== NOT EXECUTED 10bd52: e8 c1 52 00 00 call 111018 <_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 64 50 16 00 add 0x165064,%eax <== NOT EXECUTED 10bd62: 13 15 68 50 16 00 adc 0x165068,%edx <== NOT EXECUTED 10bd68: a3 64 50 16 00 mov %eax,0x165064 <== NOT EXECUTED 10bd6d: 89 15 68 50 16 00 mov %edx,0x165068 <== NOT EXECUTED current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed); 10bd73: 2b 05 6c 50 16 00 sub 0x16506c,%eax <== NOT EXECUTED if (current_depth > s->max_depth) 10bd79: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bd7c: 3b 05 60 50 16 00 cmp 0x165060,%eax <== NOT EXECUTED 10bd82: 76 05 jbe 10bd89 <== NOT EXECUTED s->max_depth = current_depth; 10bd84: a3 60 50 16 00 mov %eax,0x165060 <== 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 48 50 16 00 mov $0x165048,%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 00112250 : int rtems_memalign( void **pointer, size_t alignment, size_t size ) { 112250: 55 push %ebp 112251: 89 e5 mov %esp,%ebp 112253: 56 push %esi 112254: 53 push %ebx 112255: 8b 5d 08 mov 0x8(%ebp),%ebx void *return_this; /* * Parameter error checks */ if ( !pointer ) 112258: 85 db test %ebx,%ebx 11225a: 74 57 je 1122b3 return EINVAL; *pointer = NULL; 11225c: 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()) && 112262: 83 3d 44 94 12 00 03 cmpl $0x3,0x129444 112269: 75 09 jne 112274 11226b: e8 f4 61 ff ff call 108464 112270: 84 c0 test %al,%al 112272: 74 3f je 1122b3 /* * * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 112274: e8 41 62 ff ff call 1084ba uintptr_t size, uintptr_t alignment ) { return _Protected_heap_Allocate_aligned_with_boundary( heap, size, alignment, 0 ); 112279: 6a 00 push $0x0 11227b: ff 75 0c pushl 0xc(%ebp) 11227e: ff 75 10 pushl 0x10(%ebp) 112281: ff 35 50 51 12 00 pushl 0x125150 112287: e8 b4 aa ff ff call 10cd40 <_Protected_heap_Allocate_aligned_with_boundary> 11228c: 89 c6 mov %eax,%esi return_this = _Protected_heap_Allocate_aligned( RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 11228e: 83 c4 10 add $0x10,%esp 112291: b8 0c 00 00 00 mov $0xc,%eax 112296: 85 f6 test %esi,%esi 112298: 74 1e je 1122b8 return ENOMEM; /* * If configured, update the more involved statistics */ if ( rtems_malloc_statistics_helpers ) 11229a: a1 30 75 12 00 mov 0x127530,%eax 11229f: 85 c0 test %eax,%eax 1122a1: 74 0a je 1122ad (*rtems_malloc_statistics_helpers->at_malloc)(pointer); 1122a3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1122a6: 53 push %ebx <== NOT EXECUTED 1122a7: ff 50 04 call *0x4(%eax) <== NOT EXECUTED 1122aa: 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; 1122ad: 89 33 mov %esi,(%ebx) 1122af: 31 c0 xor %eax,%eax return 0; 1122b1: eb 05 jmp 1122b8 1122b3: b8 16 00 00 00 mov $0x16,%eax } 1122b8: 8d 65 f8 lea -0x8(%ebp),%esp 1122bb: 5b pop %ebx 1122bc: 5e pop %esi 1122bd: c9 leave 1122be: 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 0010f81e : /* * Initialization of FIFO/pipe module. */ void rtems_pipe_initialize (void) { 10f81e: 55 push %ebp 10f81f: 89 e5 mov %esp,%ebp 10f821: 83 ec 08 sub $0x8,%esp if (!rtems_pipe_configured) 10f824: 80 3d 0c 25 12 00 00 cmpb $0x0,0x12250c 10f82b: 74 3c je 10f869 return; if (rtems_pipe_semaphore) 10f82d: 83 3d 94 3e 12 00 00 cmpl $0x0,0x123e94 <== NOT EXECUTED 10f834: 75 33 jne 10f869 <== NOT EXECUTED return; rtems_status_code sc; sc = rtems_semaphore_create( 10f836: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f839: 68 94 3e 12 00 push $0x123e94 <== NOT EXECUTED 10f83e: 6a 00 push $0x0 <== NOT EXECUTED 10f840: 6a 54 push $0x54 <== NOT EXECUTED 10f842: 6a 01 push $0x1 <== NOT EXECUTED 10f844: 68 45 50 49 50 push $0x50495045 <== NOT EXECUTED 10f849: e8 02 a5 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) 10f84e: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10f851: 85 c0 test %eax,%eax <== NOT EXECUTED 10f853: 74 09 je 10f85e <== NOT EXECUTED rtems_fatal_error_occurred (sc); 10f855: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f858: 50 push %eax <== NOT EXECUTED 10f859: e8 de ac ff ff call 10a53c <== NOT EXECUTED rtems_interval now; now = rtems_clock_get_ticks_since_boot(); 10f85e: e8 e9 a0 ff ff call 10994c <== NOT EXECUTED rtems_pipe_no = now; 10f863: 66 a3 9c 3e 12 00 mov %ax,0x123e9c <== NOT EXECUTED } 10f869: c9 leave 10f86a: 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 48 52 16 00 mov 0x165248,%edx ) { #if defined(__GNUC__) void *sp = __builtin_frame_address(0); if ( sp < the_stack->area ) { 10a241: 8b 82 c8 00 00 00 mov 0xc8(%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 c4 00 00 00 mov 0xc4(%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 74 23 16 00 00 cmpl $0x0,0x162374 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 18 50 16 00 push $0x165018 10a271: 50 push %eax 10a272: e8 11 26 03 00 call 13c888 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 48 52 16 00 pushl 0x165248 <== 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 78 23 16 00 mov %esi,0x162378 <== NOT EXECUTED print_handler = print; 10a119: 89 1d 7c 23 16 00 mov %ebx,0x16237c <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 10a11f: 51 push %ecx <== NOT EXECUTED 10a120: 51 push %ecx <== NOT EXECUTED 10a121: 68 8c 20 15 00 push $0x15208c <== 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 a3 20 15 00 push $0x1520a3 <== 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 91 66 00 00 call 1107d0 <== 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 78 23 16 00 00 movl $0x0,0x162378 <== NOT EXECUTED 10a152: 00 00 00 <== NOT EXECUTED print_handler = NULL; 10a155: c7 05 7c 23 16 00 00 movl $0x0,0x16237c <== 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 c8 00 00 00 mov 0xc8(%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 c4 00 00 00 mov 0xc4(%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 18 50 16 00 push $0x165018 10a2d2: 50 push %eax 10a2d3: 88 55 f4 mov %dl,-0xc(%ebp) 10a2d6: e8 ad 25 03 00 call 13c888 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 0011e3bc : #if defined(STRING_TO_INTEGER) && !defined(STRING_TO_POINTER) , int base #endif ) { 11e3bc: 55 push %ebp 11e3bd: 89 e5 mov %esp,%ebp 11e3bf: 57 push %edi 11e3c0: 56 push %esi 11e3c1: 53 push %ebx 11e3c2: 83 ec 2c sub $0x2c,%esp 11e3c5: 8b 7d 08 mov 0x8(%ebp),%edi 11e3c8: 8b 5d 0c mov 0xc(%ebp),%ebx 11e3cb: 8b 55 10 mov 0x10(%ebp),%edx STRING_TO_INPUT_TYPE result; char *end; if ( !n ) 11e3ce: b8 09 00 00 00 mov $0x9,%eax 11e3d3: 85 db test %ebx,%ebx 11e3d5: 74 56 je 11e42d return RTEMS_INVALID_ADDRESS; errno = 0; 11e3d7: 89 55 d4 mov %edx,-0x2c(%ebp) 11e3da: e8 35 b6 01 00 call 139a14 <__errno> 11e3df: c7 00 00 00 00 00 movl $0x0,(%eax) *n = 0; 11e3e5: 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 ); 11e3eb: 50 push %eax 11e3ec: 6a 10 push $0x10 11e3ee: 8d 45 e4 lea -0x1c(%ebp),%eax 11e3f1: 50 push %eax 11e3f2: 57 push %edi 11e3f3: e8 7c 28 02 00 call 140c74 11e3f8: 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 ) 11e3fa: 83 c4 10 add $0x10,%esp 11e3fd: 8b 55 d4 mov -0x2c(%ebp),%edx 11e400: 85 d2 test %edx,%edx 11e402: 74 05 je 11e409 *endptr = end; 11e404: 8b 45 e4 mov -0x1c(%ebp),%eax 11e407: 89 02 mov %eax,(%edx) /* nothing was converted */ if ( end == s ) 11e409: b8 0b 00 00 00 mov $0xb,%eax 11e40e: 39 7d e4 cmp %edi,-0x1c(%ebp) 11e411: 74 1a je 11e42d return RTEMS_INVALID_NUMBER; #endif #ifdef STRING_TO_MAX /* there was an overflow */ if ( (result == STRING_TO_MAX) && (errno == ERANGE)) 11e413: 83 fe ff cmp $0xffffffff,%esi 11e416: 75 11 jne 11e429 11e418: e8 f7 b5 01 00 call 139a14 <__errno> <== NOT EXECUTED 11e41d: 89 c2 mov %eax,%edx <== NOT EXECUTED 11e41f: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 11e424: 83 3a 22 cmpl $0x22,(%edx) <== NOT EXECUTED 11e427: 74 04 je 11e42d <== NOT EXECUTED /* there was an underflow */ if ( (result == STRING_TO_MIN) && (errno == ERANGE)) return RTEMS_INVALID_NUMBER; #endif *n = (STRING_TO_TYPE) result; 11e429: 89 33 mov %esi,(%ebx) 11e42b: 31 c0 xor %eax,%eax return RTEMS_SUCCESSFUL; } 11e42d: 8d 65 f4 lea -0xc(%ebp),%esp 11e430: 5b pop %ebx 11e431: 5e pop %esi 11e432: 5f pop %edi 11e433: c9 leave 11e434: 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 41 12 00 00 cmpb $0x0,0x1241c4 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 3c 85 12 00 mov 0x12853c,%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 3c 85 12 00 mov 0x12853c,%eax 10ba8f: 8b 80 f4 00 00 00 mov 0xf4(%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 7b 1c 00 00 call 10d724 <_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 f4 00 00 00 mov 0xf4(%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 37 1c 00 00 call 10d701 <_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 38 1f 12 00 mov %eax,0x121f38 <== NOT EXECUTED rtems_termios_raw_input_size = raw_input; 107ecf: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 107ed2: a3 3c 1f 12 00 mov %eax,0x121f3c <== NOT EXECUTED rtems_termios_raw_output_size = raw_output; 107ed7: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 107eda: a3 40 1f 12 00 mov %eax,0x121f40 <== 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 e0 40 12 00 pushl 0x1240e0 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 8c 3d 12 00 mov 0x123d8c(%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 44 14 00 00 call 10a53c <== 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 e4 40 12 00 mov %eax,0x1240e4 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 e8 40 12 00 mov %eax,0x1240e8 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 e0 40 12 00 pushl 0x1240e0 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 3c 24 00 00 call 10a53c <== 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 3c 3e 12 00 mov 0x123e3c,%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 98 3d 12 00 00 cmpl $0x0,0x123d98(%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 98 3d 12 00 call *0x123d98(%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 e0 40 12 00 00 cmpl $0x0,0x1240e0 107e95: 75 28 jne 107ebf sc = rtems_semaphore_create ( 107e97: 83 ec 0c sub $0xc,%esp 107e9a: 68 e0 40 12 00 push $0x1240e0 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 7d 26 00 00 call 10a53c <== 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 a0 3d 12 00 mov 0x123da0(%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 8c 3d 12 00 mov 0x123d8c(%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 88 3d 12 00 mov 0x123d88(%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 e0 40 12 00 pushl 0x1240e0 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 e8 40 12 00 mov 0x1240e8,%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 3c 1f 12 00 mov 0x121f3c,%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 40 1f 12 00 mov 0x121f40,%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 38 1f 12 00 pushl 0x121f38 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 e0 40 12 00 pushl 0x1240e0 <== 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 e8 40 12 00 mov 0x1240e8,%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 e8 40 12 00 mov %ebx,0x1240e8 if (rtems_termios_ttyTail == NULL) 10931f: 83 3d e4 40 12 00 00 cmpl $0x0,0x1240e4 109326: 75 06 jne 10932e rtems_termios_ttyTail = tty; 109328: 89 1d e4 40 12 00 mov %ebx,0x1240e4 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 44 1f 12 00 movsbl 0x121f44,%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 44 1f 12 00 movsbl 0x121f44,%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 44 1f 12 00 movsbl 0x121f44,%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 44 1f 12 00 movsbl 0x121f44,%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 44 1f 12 00 movsbl 0x121f44,%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 44 1f 12 00 movsbl 0x121f44,%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 44 1f 12 00 mov 0x121f44,%al 109520: 8d 48 01 lea 0x1(%eax),%ecx 109523: 88 0d 44 1f 12 00 mov %cl,0x121f44 109529: 3c 7a cmp $0x7a,%al 10952b: 75 07 jne 109534 c = 'a'; 10952d: c6 05 44 1f 12 00 61 movb $0x61,0x121f44 <== 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 8a 0f 00 00 call 10a53c <== NOT EXECUTED } } rtems_semaphore_release (rtems_termios_ttyMutex); 1095b2: 83 ec 0c sub $0xc,%esp 1095b5: ff 35 e0 40 12 00 pushl 0x1240e0 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 5c 46 00 00 call 10dc38 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 f2 20 00 00 call 10a53c <== 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 90 3d 12 00 mov 0x123d90(%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 38 1f 12 00 mov 0x121f38,%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 9c 3d 12 00 mov 0x123d9c(%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 94 3d 12 00 mov 0x123d94(%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 28 c2 12 00 mov 0x12c228,%eax <== NOT EXECUTED 10b355: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED 10b358: 89 15 28 c2 12 00 mov %edx,0x12c228 <== 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 88 c3 12 00 mov 0x12c388,%eax <== NOT EXECUTED 10b367: 40 inc %eax <== NOT EXECUTED 10b368: a3 88 c3 12 00 mov %eax,0x12c388 <== NOT EXECUTED _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) 10b36d: 83 3d 28 c2 12 00 02 cmpl $0x2,0x12c228 <== 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 c0 a0 12 00 mov 0x12a0c0,%eax <== NOT EXECUTED 10b382: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10b385: e8 72 be 00 00 call 1171fc <== 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 dc ba 00 00 call 116e80 <__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 c0 a0 12 00 mov 0x12a0c0,%eax <== NOT EXECUTED 10b3b2: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b3b5: e8 1e 1a 01 00 call 11cdd8 <== 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 1f 4d 12 00 push $0x124d1f <== NOT EXECUTED 10b3d6: a1 c0 a0 12 00 mov 0x12a0c0,%eax <== NOT EXECUTED 10b3db: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b3de: e8 61 c1 00 00 call 117544 <== 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 1b c9 00 00 call 117d14 <== 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 0a c9 00 00 call 117d14 <== NOT EXECUTED 10b40a: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10b40d: 50 push %eax <== NOT EXECUTED 10b40e: 68 2d 4d 12 00 push $0x124d2d <== 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 3a 4d 12 00 push $0x124d3a <== NOT EXECUTED 10b41c: a1 c0 a0 12 00 mov 0x12a0c0,%eax <== NOT EXECUTED 10b421: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b424: e8 1b c1 00 00 call 117544 <== 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 08 54 12 00 push $0x125408 <== NOT EXECUTED 10b436: a1 c0 a0 12 00 mov 0x12a0c0,%eax <== NOT EXECUTED 10b43b: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b43e: e8 01 c1 00 00 call 117544 <== NOT EXECUTED 10b443: 89 c7 mov %eax,%edi <== NOT EXECUTED (void) fflush(stderr); 10b445: 59 pop %ecx <== NOT EXECUTED 10b446: a1 c0 a0 12 00 mov 0x12a0c0,%eax <== NOT EXECUTED 10b44b: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b44e: e8 a9 bd 00 00 call 1171fc <== 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 4e 4d 12 00 push $0x124d4e <== 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 63 4d 12 00 push $0x124d63 <== NOT EXECUTED 10b489: 6a 00 push $0x0 <== NOT EXECUTED 10b48b: e8 27 00 00 00 call 10b4b7 <== NOT EXECUTED abort(); 10b490: e8 b7 b9 00 00 call 116e4c <== 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 00125a8a : /* * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) { 125a8a: 55 push %ebp 125a8b: 89 e5 mov %esp,%ebp 125a8d: 57 push %edi 125a8e: 56 push %esi 125a8f: 53 push %ebx 125a90: 83 ec 3c sub $0x3c,%esp 125a93: 89 c3 mov %eax,%ebx 125a95: 89 55 e0 mov %edx,-0x20(%ebp) 125a98: 31 f6 xor %esi,%esi 125a9a: c7 45 e4 ff ff ff 7f movl $0x7fffffff,-0x1c(%ebp) 125aa1: 31 ff xor %edi,%edi sign = 1; } if (!isdigit(c)) return 0; d = c - '0'; if ((i > (limit / 10)) 125aa3: 89 7d c4 mov %edi,-0x3c(%ebp) unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 125aa6: 8b 43 04 mov 0x4(%ebx),%eax 125aa9: 48 dec %eax 125aaa: 89 43 04 mov %eax,0x4(%ebx) 125aad: 85 c0 test %eax,%eax 125aaf: 79 15 jns 125ac6 125ab1: 50 push %eax <== NOT EXECUTED 125ab2: 50 push %eax <== NOT EXECUTED 125ab3: 53 push %ebx <== NOT EXECUTED 125ab4: ff 35 60 ff 15 00 pushl 0x15ff60 <== NOT EXECUTED 125aba: e8 b9 8b 01 00 call 13e678 <__srget_r> <== NOT EXECUTED 125abf: 89 c1 mov %eax,%ecx <== NOT EXECUTED 125ac1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125ac4: eb 08 jmp 125ace <== NOT EXECUTED 125ac6: 8b 03 mov (%ebx),%eax 125ac8: 0f b6 08 movzbl (%eax),%ecx 125acb: 40 inc %eax 125acc: 89 03 mov %eax,(%ebx) if (c == ':') 125ace: 83 f9 3a cmp $0x3a,%ecx 125ad1: 74 4a je 125b1d break; if (sign == 0) { 125ad3: 85 f6 test %esi,%esi 125ad5: 75 11 jne 125ae8 if (c == '-') { sign = -1; limit++; continue; 125ad7: 66 be 01 00 mov $0x1,%si for (;;) { c = getc(fp); if (c == ':') break; if (sign == 0) { if (c == '-') { 125adb: 83 f9 2d cmp $0x2d,%ecx 125ade: 75 08 jne 125ae8 sign = -1; limit++; 125ae0: ff 45 e4 incl -0x1c(%ebp) <== NOT EXECUTED 125ae3: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED continue; 125ae6: eb be jmp 125aa6 <== NOT EXECUTED } sign = 1; } if (!isdigit(c)) 125ae8: a1 40 ff 15 00 mov 0x15ff40,%eax 125aed: f6 44 08 01 04 testb $0x4,0x1(%eax,%ecx,1) 125af2: 74 3f je 125b33 return 0; d = c - '0'; if ((i > (limit / 10)) 125af4: 8b 45 e4 mov -0x1c(%ebp),%eax 125af7: bf 0a 00 00 00 mov $0xa,%edi 125afc: 31 d2 xor %edx,%edx 125afe: f7 f7 div %edi 125b00: 89 55 d4 mov %edx,-0x2c(%ebp) 125b03: 39 45 c4 cmp %eax,-0x3c(%ebp) 125b06: 77 2b ja 125b33 } sign = 1; } if (!isdigit(c)) return 0; d = c - '0'; 125b08: 83 e9 30 sub $0x30,%ecx if ((i > (limit / 10)) 125b0b: 39 45 c4 cmp %eax,-0x3c(%ebp) 125b0e: 75 04 jne 125b14 125b10: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 125b12: 77 1f ja 125b33 <== NOT EXECUTED || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; i = i * 10 + d; 125b14: 6b 7d c4 0a imul $0xa,-0x3c(%ebp),%edi 125b18: 8d 3c 39 lea (%ecx,%edi,1),%edi 125b1b: eb 86 jmp 125aa3 125b1d: 8b 7d c4 mov -0x3c(%ebp),%edi } if (sign == 0) 125b20: 85 f6 test %esi,%esi 125b22: 74 0f je 125b33 return 0; *val = i * sign; 125b24: 0f af f7 imul %edi,%esi 125b27: 8b 45 e0 mov -0x20(%ebp),%eax 125b2a: 89 30 mov %esi,(%eax) 125b2c: b8 01 00 00 00 mov $0x1,%eax return 1; 125b31: eb 02 jmp 125b35 125b33: 31 c0 xor %eax,%eax <== NOT EXECUTED } 125b35: 8d 65 f4 lea -0xc(%ebp),%esp 125b38: 5b pop %ebx 125b39: 5e pop %esi 125b3a: 5f pop %edi 125b3b: c9 leave 125b3c: c3 ret 00125b3d : /* * Extract a string value from the database */ static int scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag) { 125b3d: 55 push %ebp 125b3e: 89 e5 mov %esp,%ebp 125b40: 57 push %edi 125b41: 56 push %esi 125b42: 53 push %ebx 125b43: 83 ec 1c sub $0x1c,%esp 125b46: 89 c3 mov %eax,%ebx 125b48: 89 ce mov %ecx,%esi 125b4a: 8b 7d 08 mov 0x8(%ebp),%edi 125b4d: 8b 4d 0c mov 0xc(%ebp),%ecx int c; *name = *bufp; 125b50: 8b 06 mov (%esi),%eax 125b52: 89 02 mov %eax,(%edx) for (;;) { c = getc(fp); 125b54: 8b 43 04 mov 0x4(%ebx),%eax 125b57: 48 dec %eax 125b58: 89 43 04 mov %eax,0x4(%ebx) 125b5b: 85 c0 test %eax,%eax 125b5d: 79 19 jns 125b78 125b5f: 52 push %edx 125b60: 52 push %edx 125b61: 53 push %ebx 125b62: ff 35 60 ff 15 00 pushl 0x15ff60 125b68: 89 4d e4 mov %ecx,-0x1c(%ebp) 125b6b: e8 08 8b 01 00 call 13e678 <__srget_r> 125b70: 83 c4 10 add $0x10,%esp 125b73: 8b 4d e4 mov -0x1c(%ebp),%ecx 125b76: eb 08 jmp 125b80 125b78: 8b 13 mov (%ebx),%edx 125b7a: 0f b6 02 movzbl (%edx),%eax 125b7d: 42 inc %edx 125b7e: 89 13 mov %edx,(%ebx) if (c == ':') { 125b80: 83 f8 3a cmp $0x3a,%eax 125b83: 75 06 jne 125b8b if (nlFlag) 125b85: 85 c9 test %ecx,%ecx 125b87: 74 21 je 125baa 125b89: eb 2f jmp 125bba <== NOT EXECUTED return 0; break; } if (c == '\n') { 125b8b: 83 f8 0a cmp $0xa,%eax 125b8e: 75 06 jne 125b96 if (!nlFlag) 125b90: 85 c9 test %ecx,%ecx 125b92: 75 16 jne 125baa 125b94: eb 24 jmp 125bba <== NOT EXECUTED return 0; break; } if (c == EOF) 125b96: 83 f8 ff cmp $0xffffffff,%eax 125b99: 74 1f je 125bba return 0; if (*nleft < 2) 125b9b: 83 3f 01 cmpl $0x1,(%edi) 125b9e: 76 1a jbe 125bba return 0; **bufp = c; 125ba0: 8b 16 mov (%esi),%edx 125ba2: 88 02 mov %al,(%edx) ++(*bufp); 125ba4: ff 06 incl (%esi) --(*nleft); 125ba6: ff 0f decl (%edi) } 125ba8: eb aa jmp 125b54 **bufp = '\0'; 125baa: 8b 06 mov (%esi),%eax 125bac: c6 00 00 movb $0x0,(%eax) ++(*bufp); 125baf: ff 06 incl (%esi) --(*nleft); 125bb1: ff 0f decl (%edi) 125bb3: b8 01 00 00 00 mov $0x1,%eax return 1; 125bb8: eb 02 jmp 125bbc 125bba: 31 c0 xor %eax,%eax <== NOT EXECUTED } 125bbc: 8d 65 f4 lea -0xc(%ebp),%esp 125bbf: 5b pop %ebx 125bc0: 5e pop %esi 125bc1: 5f pop %edi 125bc2: c9 leave 125bc3: c3 ret 00125bc4 : FILE *fp, struct group *grp, char *buffer, size_t bufsize ) { 125bc4: 55 push %ebp 125bc5: 89 e5 mov %esp,%ebp 125bc7: 57 push %edi 125bc8: 56 push %esi 125bc9: 53 push %ebx 125bca: 83 ec 34 sub $0x34,%esp 125bcd: 89 c6 mov %eax,%esi 125bcf: 89 d3 mov %edx,%ebx 125bd1: 89 4d d4 mov %ecx,-0x2c(%ebp) int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 125bd4: 8d 7d d4 lea -0x2c(%ebp),%edi 125bd7: 6a 00 push $0x0 125bd9: 8d 45 08 lea 0x8(%ebp),%eax 125bdc: 50 push %eax 125bdd: 89 f9 mov %edi,%ecx 125bdf: 89 f0 mov %esi,%eax 125be1: e8 57 ff ff ff call 125b3d 125be6: 83 c4 10 add $0x10,%esp 125be9: 85 c0 test %eax,%eax 125beb: 0f 84 c8 00 00 00 je 125cb9 || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) 125bf1: 50 push %eax 125bf2: 50 push %eax 125bf3: 8d 53 04 lea 0x4(%ebx),%edx 125bf6: 6a 00 push $0x0 125bf8: 8d 45 08 lea 0x8(%ebp),%eax 125bfb: 50 push %eax 125bfc: 89 f9 mov %edi,%ecx 125bfe: 89 f0 mov %esi,%eax 125c00: e8 38 ff ff ff call 125b3d { int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 125c05: 83 c4 10 add $0x10,%esp 125c08: 85 c0 test %eax,%eax 125c0a: 0f 84 a9 00 00 00 je 125cb9 || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &grgid) 125c10: 8d 55 e4 lea -0x1c(%ebp),%edx 125c13: 89 f0 mov %esi,%eax 125c15: e8 70 fe ff ff call 125a8a { int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 125c1a: 85 c0 test %eax,%eax 125c1c: 0f 84 97 00 00 00 je 125cb9 || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &grgid) || !scanString(fp, &grmem, &buffer, &bufsize, 1)) 125c22: 51 push %ecx 125c23: 51 push %ecx 125c24: 8d 55 e0 lea -0x20(%ebp),%edx 125c27: 6a 01 push $0x1 125c29: 8d 45 08 lea 0x8(%ebp),%eax 125c2c: 50 push %eax 125c2d: 89 f9 mov %edi,%ecx 125c2f: 89 f0 mov %esi,%eax 125c31: e8 07 ff ff ff call 125b3d { int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 125c36: 83 c4 10 add $0x10,%esp 125c39: 85 c0 test %eax,%eax 125c3b: 74 7c je 125cb9 || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &grgid) || !scanString(fp, &grmem, &buffer, &bufsize, 1)) return 0; grp->gr_gid = grgid; 125c3d: 8b 45 e4 mov -0x1c(%ebp),%eax 125c40: 66 89 43 08 mov %ax,0x8(%ebx) /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 125c44: 8b 7d e0 mov -0x20(%ebp),%edi 125c47: 89 fa mov %edi,%edx 125c49: b8 01 00 00 00 mov $0x1,%eax 125c4e: eb 12 jmp 125c62 if(*cp == ',') memcount++; 125c50: 80 7d d3 2c cmpb $0x2c,-0x2d(%ebp) 125c54: 0f 94 c1 sete %cl 125c57: 89 ce mov %ecx,%esi 125c59: 81 e6 ff 00 00 00 and $0xff,%esi 125c5f: 01 f0 add %esi,%eax grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 125c61: 42 inc %edx 125c62: 8a 0a mov (%edx),%cl 125c64: 88 4d d3 mov %cl,-0x2d(%ebp) 125c67: 84 c9 test %cl,%cl 125c69: 75 e5 jne 125c50 } /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) 125c6b: 8d 04 85 13 00 00 00 lea 0x13(,%eax,4),%eax 125c72: 39 45 08 cmp %eax,0x8(%ebp) 125c75: 72 42 jb 125cb9 return 0; grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15); 125c77: 8b 45 d4 mov -0x2c(%ebp),%eax 125c7a: 83 c0 0f add $0xf,%eax 125c7d: 83 e0 f0 and $0xfffffff0,%eax 125c80: 89 43 0c mov %eax,0xc(%ebx) /* * Fill in pointer array */ grp->gr_mem[0] = grmem; 125c83: 89 38 mov %edi,(%eax) 125c85: 8b 45 e0 mov -0x20(%ebp),%eax 125c88: 40 inc %eax 125c89: ba 01 00 00 00 mov $0x1,%edx for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 125c8e: eb 11 jmp 125ca1 if(*cp == ',') { 125c90: 80 f9 2c cmp $0x2c,%cl 125c93: 75 0b jne 125ca0 *cp = '\0'; 125c95: c6 40 ff 00 movb $0x0,-0x1(%eax) <== NOT EXECUTED grp->gr_mem[memcount++] = cp + 1; 125c99: 8b 4b 0c mov 0xc(%ebx),%ecx <== NOT EXECUTED 125c9c: 89 04 91 mov %eax,(%ecx,%edx,4) <== NOT EXECUTED 125c9f: 42 inc %edx <== NOT EXECUTED 125ca0: 40 inc %eax /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 125ca1: 8a 48 ff mov -0x1(%eax),%cl 125ca4: 84 c9 test %cl,%cl 125ca6: 75 e8 jne 125c90 if(*cp == ',') { *cp = '\0'; grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; 125ca8: 8b 43 0c mov 0xc(%ebx),%eax 125cab: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) 125cb2: b8 01 00 00 00 mov $0x1,%eax return 1; 125cb7: eb 02 jmp 125cbb 125cb9: 31 c0 xor %eax,%eax <== NOT EXECUTED } 125cbb: 8d 65 f4 lea -0xc(%ebp),%esp 125cbe: 5b pop %ebx 125cbf: 5e pop %esi 125cc0: 5f pop %edi 125cc1: c9 leave 125cc2: c3 ret 00125cfb : FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) { 125cfb: 55 push %ebp 125cfc: 89 e5 mov %esp,%ebp 125cfe: 57 push %edi 125cff: 56 push %esi 125d00: 53 push %ebx 125d01: 83 ec 34 sub $0x34,%esp 125d04: 89 c6 mov %eax,%esi 125d06: 89 d3 mov %edx,%ebx 125d08: 89 4d d4 mov %ecx,-0x2c(%ebp) int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 125d0b: 8d 7d d4 lea -0x2c(%ebp),%edi 125d0e: 6a 00 push $0x0 125d10: 8d 45 08 lea 0x8(%ebp),%eax 125d13: 50 push %eax 125d14: 89 f9 mov %edi,%ecx 125d16: 89 f0 mov %esi,%eax 125d18: e8 20 fe ff ff call 125b3d 125d1d: 83 c4 10 add $0x10,%esp 125d20: 85 c0 test %eax,%eax 125d22: 0f 84 c4 00 00 00 je 125dec || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) 125d28: 51 push %ecx 125d29: 51 push %ecx 125d2a: 8d 53 04 lea 0x4(%ebx),%edx 125d2d: 6a 00 push $0x0 125d2f: 8d 45 08 lea 0x8(%ebp),%eax 125d32: 50 push %eax 125d33: 89 f9 mov %edi,%ecx 125d35: 89 f0 mov %esi,%eax 125d37: e8 01 fe ff ff call 125b3d size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 125d3c: 83 c4 10 add $0x10,%esp 125d3f: 85 c0 test %eax,%eax 125d41: 0f 84 a5 00 00 00 je 125dec || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &pwuid) 125d47: 8d 55 e4 lea -0x1c(%ebp),%edx 125d4a: 89 f0 mov %esi,%eax 125d4c: e8 39 fd ff ff call 125a8a size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 125d51: 85 c0 test %eax,%eax 125d53: 0f 84 93 00 00 00 je 125dec || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &pwuid) || !scanInt(fp, &pwgid) 125d59: 8d 55 e0 lea -0x20(%ebp),%edx 125d5c: 89 f0 mov %esi,%eax 125d5e: e8 27 fd ff ff call 125a8a size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 125d63: 85 c0 test %eax,%eax 125d65: 0f 84 81 00 00 00 je 125dec || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &pwuid) || !scanInt(fp, &pwgid) || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) 125d6b: 52 push %edx 125d6c: 52 push %edx 125d6d: 8d 53 0c lea 0xc(%ebx),%edx 125d70: 6a 00 push $0x0 125d72: 8d 45 08 lea 0x8(%ebp),%eax 125d75: 50 push %eax 125d76: 89 f9 mov %edi,%ecx 125d78: 89 f0 mov %esi,%eax 125d7a: e8 be fd ff ff call 125b3d size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 125d7f: 83 c4 10 add $0x10,%esp 125d82: 85 c0 test %eax,%eax 125d84: 74 66 je 125dec || !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) 125d86: 50 push %eax 125d87: 50 push %eax 125d88: 8d 53 10 lea 0x10(%ebx),%edx 125d8b: 6a 00 push $0x0 125d8d: 8d 45 08 lea 0x8(%ebp),%eax 125d90: 50 push %eax 125d91: 89 f9 mov %edi,%ecx 125d93: 89 f0 mov %esi,%eax 125d95: e8 a3 fd ff ff call 125b3d size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 125d9a: 83 c4 10 add $0x10,%esp 125d9d: 85 c0 test %eax,%eax 125d9f: 74 4b je 125dec || !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) 125da1: 51 push %ecx 125da2: 51 push %ecx 125da3: 8d 53 14 lea 0x14(%ebx),%edx 125da6: 6a 00 push $0x0 125da8: 8d 45 08 lea 0x8(%ebp),%eax 125dab: 50 push %eax 125dac: 89 f9 mov %edi,%ecx 125dae: 89 f0 mov %esi,%eax 125db0: e8 88 fd ff ff call 125b3d size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 125db5: 83 c4 10 add $0x10,%esp 125db8: 85 c0 test %eax,%eax 125dba: 74 30 je 125dec || !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)) 125dbc: 52 push %edx 125dbd: 52 push %edx 125dbe: 8d 53 18 lea 0x18(%ebx),%edx 125dc1: 6a 01 push $0x1 125dc3: 8d 45 08 lea 0x8(%ebp),%eax 125dc6: 50 push %eax 125dc7: 89 f9 mov %edi,%ecx 125dc9: 89 f0 mov %esi,%eax 125dcb: e8 6d fd ff ff call 125b3d size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 125dd0: 83 c4 10 add $0x10,%esp 125dd3: 85 c0 test %eax,%eax 125dd5: 74 15 je 125dec || !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; 125dd7: 8b 45 e4 mov -0x1c(%ebp),%eax 125dda: 66 89 43 08 mov %ax,0x8(%ebx) pwd->pw_gid = pwgid; 125dde: 8b 45 e0 mov -0x20(%ebp),%eax 125de1: 66 89 43 0a mov %ax,0xa(%ebx) 125de5: b8 01 00 00 00 mov $0x1,%eax return 1; 125dea: eb 02 jmp 125dee 125dec: 31 c0 xor %eax,%eax <== NOT EXECUTED } 125dee: 8d 65 f4 lea -0xc(%ebp),%esp 125df1: 5b pop %ebx 125df2: 5e pop %esi 125df3: 5f pop %edi 125df4: c9 leave 125df5: c3 ret 00125a29 : */ int setgid( gid_t gid ) { 125a29: 55 push %ebp <== NOT EXECUTED 125a2a: 89 e5 mov %esp,%ebp <== NOT EXECUTED _POSIX_types_Gid = gid; 125a2c: a1 3c f7 15 00 mov 0x15f73c,%eax <== NOT EXECUTED 125a31: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 125a34: 66 89 50 34 mov %dx,0x34(%eax) <== NOT EXECUTED return 0; } 125a38: 31 c0 xor %eax,%eax <== NOT EXECUTED 125a3a: c9 leave <== NOT EXECUTED 125a3b: c3 ret <== NOT EXECUTED 00125eff : return NULL; return &grent; } void setgrent(void) { 125eff: 55 push %ebp <== NOT EXECUTED 125f00: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125f02: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED init_etc_passwd_group(); 125f05: e8 24 ff ff ff call 125e2e <== NOT EXECUTED if (group_fp != NULL) 125f0a: a1 6c 4c 16 00 mov 0x164c6c,%eax <== NOT EXECUTED 125f0f: 85 c0 test %eax,%eax <== NOT EXECUTED 125f11: 74 0c je 125f1f <== NOT EXECUTED fclose(group_fp); 125f13: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125f16: 50 push %eax <== NOT EXECUTED 125f17: e8 44 3c 01 00 call 139b60 <== NOT EXECUTED 125f1c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED group_fp = fopen("/etc/group", "r"); 125f1f: 52 push %edx <== NOT EXECUTED 125f20: 52 push %edx <== NOT EXECUTED 125f21: 68 0b 2f 15 00 push $0x152f0b <== NOT EXECUTED 125f26: 68 65 05 15 00 push $0x150565 <== NOT EXECUTED 125f2b: e8 48 44 01 00 call 13a378 <== NOT EXECUTED 125f30: a3 6c 4c 16 00 mov %eax,0x164c6c <== NOT EXECUTED 125f35: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 125f38: c9 leave <== NOT EXECUTED 125f39: c3 ret <== NOT EXECUTED 001260a3 : return NULL; return &pwent; } void setpwent(void) { 1260a3: 55 push %ebp <== NOT EXECUTED 1260a4: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1260a6: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED init_etc_passwd_group(); 1260a9: e8 80 fd ff ff call 125e2e <== NOT EXECUTED if (passwd_fp != NULL) 1260ae: a1 84 4b 16 00 mov 0x164b84,%eax <== NOT EXECUTED 1260b3: 85 c0 test %eax,%eax <== NOT EXECUTED 1260b5: 74 0c je 1260c3 <== NOT EXECUTED fclose(passwd_fp); 1260b7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1260ba: 50 push %eax <== NOT EXECUTED 1260bb: e8 a0 3a 01 00 call 139b60 <== NOT EXECUTED 1260c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED passwd_fp = fopen("/etc/passwd", "r"); 1260c3: 50 push %eax <== NOT EXECUTED 1260c4: 50 push %eax <== NOT EXECUTED 1260c5: 68 0b 2f 15 00 push $0x152f0b <== NOT EXECUTED 1260ca: 68 20 05 15 00 push $0x150520 <== NOT EXECUTED 1260cf: e8 a4 42 01 00 call 13a378 <== NOT EXECUTED 1260d4: a3 84 4b 16 00 mov %eax,0x164b84 <== NOT EXECUTED 1260d9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1260dc: c9 leave <== NOT EXECUTED 1260dd: 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 3c f7 15 00 mov 0x15f73c,%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 74 cf 02 00 call 139a14 <__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 1f cf 02 00 call 139a14 <__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 00126b3c : */ extern rtems_chain_control rtems_filesystem_mount_table_control; int statvfs (const char *path, struct statvfs *sb) { 126b3c: 55 push %ebp <== NOT EXECUTED 126b3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126b3f: 57 push %edi <== NOT EXECUTED 126b40: 56 push %esi <== NOT EXECUTED 126b41: 53 push %ebx <== NOT EXECUTED 126b42: 83 ec 38 sub $0x38,%esp <== NOT EXECUTED 126b45: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 126b48: 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 ) ) 126b4b: 31 c0 xor %eax,%eax <== NOT EXECUTED 126b4d: 83 c9 ff or $0xffffffff,%ecx <== NOT EXECUTED 126b50: 89 d7 mov %edx,%edi <== NOT EXECUTED 126b52: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 126b54: f7 d1 not %ecx <== NOT EXECUTED 126b56: 49 dec %ecx <== NOT EXECUTED 126b57: 6a 01 push $0x1 <== NOT EXECUTED 126b59: 8d 5d d4 lea -0x2c(%ebp),%ebx <== NOT EXECUTED 126b5c: 53 push %ebx <== NOT EXECUTED 126b5d: 6a 00 push $0x0 <== NOT EXECUTED 126b5f: 51 push %ecx <== NOT EXECUTED 126b60: 52 push %edx <== NOT EXECUTED 126b61: e8 62 4b fe ff call 10b6c8 <== NOT EXECUTED 126b66: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 126b69: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED 126b6c: 85 c0 test %eax,%eax <== NOT EXECUTED 126b6e: 75 4b jne 126bbb <== NOT EXECUTED return -1; mt_entry = loc.mt_entry; 126b70: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED fs_mount_root = &mt_entry->mt_fs_root; 126b73: 8b 4a 28 mov 0x28(%edx),%ecx <== NOT EXECUTED 126b76: 83 79 44 00 cmpl $0x0,0x44(%ecx) <== NOT EXECUTED 126b7a: 75 0d jne 126b89 <== NOT EXECUTED if ( !fs_mount_root->ops->statvfs_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 126b7c: e8 93 2e 01 00 call 139a14 <__errno> <== NOT EXECUTED 126b81: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 126b87: eb 32 jmp 126bbb <== NOT EXECUTED memset (sb, 0, sizeof (struct statvfs)); 126b89: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 126b8e: 89 f7 mov %esi,%edi <== NOT EXECUTED 126b90: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb ); 126b92: 50 push %eax <== NOT EXECUTED 126b93: 50 push %eax <== NOT EXECUTED 126b94: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 126b97: 56 push %esi <== NOT EXECUTED 126b98: 83 c2 1c add $0x1c,%edx <== NOT EXECUTED 126b9b: 52 push %edx <== NOT EXECUTED 126b9c: ff 50 44 call *0x44(%eax) <== NOT EXECUTED 126b9f: 89 c7 mov %eax,%edi <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 126ba1: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 126ba4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126ba7: 85 c0 test %eax,%eax <== NOT EXECUTED 126ba9: 74 10 je 126bbb <== NOT EXECUTED 126bab: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 126bae: 85 c0 test %eax,%eax <== NOT EXECUTED 126bb0: 74 09 je 126bbb <== NOT EXECUTED 126bb2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 126bb5: 53 push %ebx <== NOT EXECUTED 126bb6: ff d0 call *%eax <== NOT EXECUTED 126bb8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 126bbb: 89 f8 mov %edi,%eax <== NOT EXECUTED 126bbd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 126bc0: 5b pop %ebx <== NOT EXECUTED 126bc1: 5e pop %esi <== NOT EXECUTED 126bc2: 5f pop %edi <== NOT EXECUTED 126bc3: c9 leave <== NOT EXECUTED 126bc4: c3 ret <== NOT EXECUTED 00126bc8 : int symlink( const char *actualpath, const char *sympath ) { 126bc8: 55 push %ebp 126bc9: 89 e5 mov %esp,%ebp 126bcb: 57 push %edi 126bcc: 56 push %esi 126bcd: 83 ec 20 sub $0x20,%esp 126bd0: 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 ); 126bd3: 8a 10 mov (%eax),%dl 126bd5: 80 fa 5c cmp $0x5c,%dl 126bd8: 74 09 je 126be3 126bda: 80 fa 2f cmp $0x2f,%dl 126bdd: 74 04 je 126be3 126bdf: 84 d2 test %dl,%dl 126be1: 75 17 jne 126bfa 126be3: 8d 7d e0 lea -0x20(%ebp),%edi 126be6: 8b 35 3c f7 15 00 mov 0x15f73c,%esi 126bec: 83 c6 18 add $0x18,%esi 126bef: b9 05 00 00 00 mov $0x5,%ecx 126bf4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 126bf6: b1 01 mov $0x1,%cl 126bf8: eb 13 jmp 126c0d 126bfa: 8d 7d e0 lea -0x20(%ebp),%edi 126bfd: 8b 35 3c f7 15 00 mov 0x15f73c,%esi 126c03: 83 c6 04 add $0x4,%esi 126c06: b9 05 00 00 00 mov $0x5,%ecx 126c0b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !loc.ops->evalformake_h ) { 126c0d: 8b 55 ec mov -0x14(%ebp),%edx 126c10: 8b 52 04 mov 0x4(%edx),%edx 126c13: 85 d2 test %edx,%edx 126c15: 74 32 je 126c49 rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start ); 126c17: 56 push %esi 126c18: 8d 75 f4 lea -0xc(%ebp),%esi 126c1b: 56 push %esi 126c1c: 8d 7d e0 lea -0x20(%ebp),%edi 126c1f: 57 push %edi 126c20: 01 c8 add %ecx,%eax 126c22: 50 push %eax 126c23: ff d2 call *%edx if ( result != 0 ) 126c25: 83 c4 10 add $0x10,%esp 126c28: 83 ce ff or $0xffffffff,%esi 126c2b: 85 c0 test %eax,%eax 126c2d: 75 50 jne 126c7f return -1; if ( !loc.ops->symlink_h ) { 126c2f: 8b 55 ec mov -0x14(%ebp),%edx 126c32: 8b 42 38 mov 0x38(%edx),%eax 126c35: 85 c0 test %eax,%eax 126c37: 75 20 jne 126c59 rtems_filesystem_freenode( &loc ); 126c39: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 126c3c: 85 c0 test %eax,%eax <== NOT EXECUTED 126c3e: 74 09 je 126c49 <== NOT EXECUTED 126c40: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 126c43: 57 push %edi <== NOT EXECUTED 126c44: ff d0 call *%eax <== NOT EXECUTED 126c46: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 126c49: e8 c6 2d 01 00 call 139a14 <__errno> <== NOT EXECUTED 126c4e: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 126c54: 83 ce ff or $0xffffffff,%esi <== NOT EXECUTED 126c57: eb 26 jmp 126c7f <== NOT EXECUTED } result = (*loc.ops->symlink_h)( &loc, actualpath, name_start); 126c59: 52 push %edx 126c5a: ff 75 f4 pushl -0xc(%ebp) 126c5d: ff 75 08 pushl 0x8(%ebp) 126c60: 57 push %edi 126c61: ff d0 call *%eax 126c63: 89 c6 mov %eax,%esi rtems_filesystem_freenode( &loc ); 126c65: 8b 45 ec mov -0x14(%ebp),%eax 126c68: 83 c4 10 add $0x10,%esp 126c6b: 85 c0 test %eax,%eax 126c6d: 74 10 je 126c7f 126c6f: 8b 40 1c mov 0x1c(%eax),%eax 126c72: 85 c0 test %eax,%eax 126c74: 74 09 je 126c7f 126c76: 83 ec 0c sub $0xc,%esp 126c79: 57 push %edi 126c7a: ff d0 call *%eax 126c7c: 83 c4 10 add $0x10,%esp return result; } 126c7f: 89 f0 mov %esi,%eax 126c81: 8d 65 f8 lea -0x8(%ebp),%esp 126c84: 5e pop %esi 126c85: 5f pop %edi 126c86: c9 leave 126c87: c3 ret 001138fc : int tcsetattr( int fd, int opt, struct termios *tp ) { 1138fc: 55 push %ebp 1138fd: 89 e5 mov %esp,%ebp 1138ff: 56 push %esi 113900: 53 push %ebx 113901: 8b 5d 08 mov 0x8(%ebp),%ebx 113904: 8b 45 0c mov 0xc(%ebp),%eax 113907: 8b 75 10 mov 0x10(%ebp),%esi switch (opt) { 11390a: 85 c0 test %eax,%eax 11390c: 74 22 je 113930 11390e: 48 dec %eax <== NOT EXECUTED 11390f: 74 0d je 11391e <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 113911: e8 f6 44 00 00 call 117e0c <__errno> <== NOT EXECUTED 113916: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11391c: eb 2a jmp 113948 <== NOT EXECUTED case TCSADRAIN: if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0) 11391e: 50 push %eax <== NOT EXECUTED 11391f: 6a 00 push $0x0 <== NOT EXECUTED 113921: 6a 03 push $0x3 <== NOT EXECUTED 113923: 53 push %ebx <== NOT EXECUTED 113924: e8 f3 31 00 00 call 116b1c <== NOT EXECUTED 113929: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11392c: 85 c0 test %eax,%eax <== NOT EXECUTED 11392e: 78 18 js 113948 <== NOT EXECUTED return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 113930: 89 75 10 mov %esi,0x10(%ebp) 113933: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp) 11393a: 89 5d 08 mov %ebx,0x8(%ebp) } } 11393d: 8d 65 f8 lea -0x8(%ebp),%esp 113940: 5b pop %ebx 113941: 5e pop %esi 113942: c9 leave return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 113943: e9 d4 31 00 00 jmp 116b1c } } 113948: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11394b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11394e: 5b pop %ebx <== NOT EXECUTED 11394f: 5e pop %esi <== NOT EXECUTED 113950: c9 leave <== NOT EXECUTED 113951: c3 ret <== NOT EXECUTED 00110e9c : #include int unlink( const char *path ) { 110e9c: 55 push %ebp 110e9d: 89 e5 mov %esp,%ebp 110e9f: 57 push %edi 110ea0: 56 push %esi 110ea1: 53 push %ebx 110ea2: 83 ec 58 sub $0x58,%esp /* * Get the node to be unlinked. Find the parent path first. */ parentpathlen = rtems_filesystem_dirname ( path ); 110ea5: ff 75 08 pushl 0x8(%ebp) 110ea8: e8 3e 61 ff ff call 106feb 110ead: 89 c2 mov %eax,%edx if ( parentpathlen == 0 ) 110eaf: 83 c4 10 add $0x10,%esp 110eb2: 85 c0 test %eax,%eax 110eb4: 75 36 jne 110eec rtems_filesystem_get_start_loc( path, &i, &parentloc ); 110eb6: 8b 4d 08 mov 0x8(%ebp),%ecx 110eb9: 8a 01 mov (%ecx),%al 110ebb: 3c 5c cmp $0x5c,%al 110ebd: 74 08 je 110ec7 110ebf: 3c 2f cmp $0x2f,%al 110ec1: 74 04 je 110ec7 110ec3: 84 c0 test %al,%al <== NOT EXECUTED 110ec5: 75 0e jne 110ed5 <== NOT EXECUTED 110ec7: 8d 7d d4 lea -0x2c(%ebp),%edi 110eca: 8b 35 48 1f 12 00 mov 0x121f48,%esi 110ed0: 83 c6 18 add $0x18,%esi 110ed3: eb 0c jmp 110ee1 110ed5: 8d 7d d4 lea -0x2c(%ebp),%edi <== NOT EXECUTED 110ed8: 8b 35 48 1f 12 00 mov 0x121f48,%esi <== NOT EXECUTED 110ede: 83 c6 04 add $0x4,%esi <== NOT EXECUTED 110ee1: b9 05 00 00 00 mov $0x5,%ecx 110ee6: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 110ee8: 31 db xor %ebx,%ebx 110eea: eb 27 jmp 110f13 else { result = rtems_filesystem_evaluate_path( path, parentpathlen, 110eec: 83 ec 0c sub $0xc,%esp 110eef: 6a 00 push $0x0 110ef1: 8d 45 d4 lea -0x2c(%ebp),%eax 110ef4: 50 push %eax 110ef5: 6a 02 push $0x2 110ef7: 52 push %edx 110ef8: ff 75 08 pushl 0x8(%ebp) 110efb: 89 55 b4 mov %edx,-0x4c(%ebp) 110efe: e8 d5 61 ff ff call 1070d8 RTEMS_LIBIO_PERMS_WRITE, &parentloc, false ); if ( result != 0 ) 110f03: 83 c4 20 add $0x20,%esp 110f06: 85 c0 test %eax,%eax 110f08: 8b 55 b4 mov -0x4c(%ebp),%edx 110f0b: 0f 85 68 01 00 00 jne 111079 110f11: b3 01 mov $0x1,%bl /* * Start from the parent to find the node that should be under it. */ loc = parentloc; 110f13: 8d 7d c0 lea -0x40(%ebp),%edi 110f16: 8d 75 d4 lea -0x2c(%ebp),%esi 110f19: b9 05 00 00 00 mov $0x5,%ecx 110f1e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) name = path + parentpathlen; 110f20: 8b 75 08 mov 0x8(%ebp),%esi 110f23: 01 d6 add %edx,%esi name += rtems_filesystem_prefix_separators( name, strlen( name ) ); 110f25: 83 c9 ff or $0xffffffff,%ecx 110f28: 89 f7 mov %esi,%edi 110f2a: 31 c0 xor %eax,%eax 110f2c: f2 ae repnz scas %es:(%edi),%al 110f2e: f7 d1 not %ecx 110f30: 49 dec %ecx 110f31: 52 push %edx 110f32: 52 push %edx 110f33: 51 push %ecx 110f34: 56 push %esi 110f35: e8 8a 60 ff ff call 106fc4 110f3a: 01 c6 add %eax,%esi result = rtems_filesystem_evaluate_relative_path( name , strlen( name ), 110f3c: 83 c9 ff or $0xffffffff,%ecx 110f3f: 89 f7 mov %esi,%edi 110f41: 31 c0 xor %eax,%eax 110f43: f2 ae repnz scas %es:(%edi),%al 110f45: f7 d1 not %ecx 110f47: 49 dec %ecx 110f48: c7 04 24 00 00 00 00 movl $0x0,(%esp) 110f4f: 8d 7d c0 lea -0x40(%ebp),%edi 110f52: 57 push %edi 110f53: 6a 00 push $0x0 110f55: 51 push %ecx 110f56: 56 push %esi 110f57: e8 c2 60 ff ff call 10701e 0, &loc, false ); if ( result != 0 ) { 110f5c: 83 c4 20 add $0x20,%esp 110f5f: 85 c0 test %eax,%eax 110f61: 74 2f je 110f92 if ( free_parentloc ) 110f63: 84 db test %bl,%bl 110f65: 0f 84 0e 01 00 00 je 111079 rtems_filesystem_freenode( &parentloc ); 110f6b: 8b 45 e0 mov -0x20(%ebp),%eax 110f6e: 85 c0 test %eax,%eax 110f70: 0f 84 03 01 00 00 je 111079 110f76: 8b 40 1c mov 0x1c(%eax),%eax 110f79: 85 c0 test %eax,%eax 110f7b: 0f 84 f8 00 00 00 je 111079 110f81: 83 ec 0c sub $0xc,%esp 110f84: 8d 55 d4 lea -0x2c(%ebp),%edx 110f87: 52 push %edx 110f88: ff d0 call *%eax 110f8a: 83 ce ff or $0xffffffff,%esi 110f8d: e9 e2 00 00 00 jmp 111074 return -1; } if ( !loc.ops->node_type_h ) { 110f92: 8b 55 cc mov -0x34(%ebp),%edx 110f95: 8b 42 10 mov 0x10(%edx),%eax 110f98: 85 c0 test %eax,%eax 110f9a: 75 05 jne 110fa1 rtems_filesystem_freenode( &loc ); 110f9c: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 110f9f: eb 5b jmp 110ffc <== 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 ) { 110fa1: 83 ec 0c sub $0xc,%esp 110fa4: 57 push %edi 110fa5: ff d0 call *%eax 110fa7: 83 c4 10 add $0x10,%esp 110faa: 48 dec %eax 110fab: 8b 45 cc mov -0x34(%ebp),%eax 110fae: 75 42 jne 110ff2 rtems_filesystem_freenode( &loc ); 110fb0: 85 c0 test %eax,%eax 110fb2: 74 10 je 110fc4 110fb4: 8b 40 1c mov 0x1c(%eax),%eax 110fb7: 85 c0 test %eax,%eax 110fb9: 74 09 je 110fc4 110fbb: 83 ec 0c sub $0xc,%esp 110fbe: 57 push %edi 110fbf: ff d0 call *%eax 110fc1: 83 c4 10 add $0x10,%esp if ( free_parentloc ) 110fc4: 84 db test %bl,%bl 110fc6: 74 1a je 110fe2 rtems_filesystem_freenode( &parentloc ); 110fc8: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 110fcb: 85 c0 test %eax,%eax <== NOT EXECUTED 110fcd: 74 13 je 110fe2 <== NOT EXECUTED 110fcf: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 110fd2: 85 c0 test %eax,%eax <== NOT EXECUTED 110fd4: 74 0c je 110fe2 <== NOT EXECUTED 110fd6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110fd9: 8d 55 d4 lea -0x2c(%ebp),%edx <== NOT EXECUTED 110fdc: 52 push %edx <== NOT EXECUTED 110fdd: ff d0 call *%eax <== NOT EXECUTED 110fdf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EISDIR ); 110fe2: e8 6d 05 00 00 call 111554 <__errno> 110fe7: c7 00 15 00 00 00 movl $0x15,(%eax) 110fed: e9 87 00 00 00 jmp 111079 } if ( !loc.ops->unlink_h ) { 110ff2: 8b 50 0c mov 0xc(%eax),%edx 110ff5: 85 d2 test %edx,%edx 110ff7: 75 3b jne 111034 rtems_filesystem_freenode( &loc ); 110ff9: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 110ffc: 85 c0 test %eax,%eax <== NOT EXECUTED 110ffe: 74 09 je 111009 <== NOT EXECUTED 111000: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111003: 57 push %edi <== NOT EXECUTED 111004: ff d0 call *%eax <== NOT EXECUTED 111006: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( free_parentloc ) 111009: 84 db test %bl,%bl <== NOT EXECUTED 11100b: 74 1a je 111027 <== NOT EXECUTED rtems_filesystem_freenode( &parentloc ); 11100d: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 111010: 85 c0 test %eax,%eax <== NOT EXECUTED 111012: 74 13 je 111027 <== NOT EXECUTED 111014: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 111017: 85 c0 test %eax,%eax <== NOT EXECUTED 111019: 74 0c je 111027 <== NOT EXECUTED 11101b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11101e: 8d 55 d4 lea -0x2c(%ebp),%edx <== NOT EXECUTED 111021: 52 push %edx <== NOT EXECUTED 111022: ff d0 call *%eax <== NOT EXECUTED 111024: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 111027: e8 28 05 00 00 call 111554 <__errno> <== NOT EXECUTED 11102c: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 111032: eb 45 jmp 111079 <== NOT EXECUTED } result = (*loc.ops->unlink_h)( &parentloc, &loc ); 111034: 50 push %eax 111035: 50 push %eax 111036: 57 push %edi 111037: 8d 45 d4 lea -0x2c(%ebp),%eax 11103a: 50 push %eax 11103b: ff d2 call *%edx 11103d: 89 c6 mov %eax,%esi rtems_filesystem_freenode( &loc ); 11103f: 8b 45 cc mov -0x34(%ebp),%eax 111042: 83 c4 10 add $0x10,%esp 111045: 85 c0 test %eax,%eax 111047: 74 10 je 111059 111049: 8b 40 1c mov 0x1c(%eax),%eax 11104c: 85 c0 test %eax,%eax 11104e: 74 09 je 111059 111050: 83 ec 0c sub $0xc,%esp 111053: 57 push %edi 111054: ff d0 call *%eax 111056: 83 c4 10 add $0x10,%esp if ( free_parentloc ) 111059: 84 db test %bl,%bl 11105b: 74 1f je 11107c rtems_filesystem_freenode( &parentloc ); 11105d: 8b 45 e0 mov -0x20(%ebp),%eax 111060: 85 c0 test %eax,%eax 111062: 74 18 je 11107c 111064: 8b 40 1c mov 0x1c(%eax),%eax 111067: 85 c0 test %eax,%eax 111069: 74 11 je 11107c 11106b: 83 ec 0c sub $0xc,%esp 11106e: 8d 55 d4 lea -0x2c(%ebp),%edx 111071: 52 push %edx 111072: ff d0 call *%eax 111074: 83 c4 10 add $0x10,%esp 111077: eb 03 jmp 11107c 111079: 83 ce ff or $0xffffffff,%esi return result; } 11107c: 89 f0 mov %esi,%eax 11107e: 8d 65 f4 lea -0xc(%ebp),%esp 111081: 5b pop %ebx 111082: 5e pop %esi 111083: 5f pop %edi 111084: c9 leave 111085: 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 1b b3 02 00 call 139a14 <__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 e5 b2 02 00 call 139a14 <__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 3c f7 15 00 mov 0x15f73c,%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 74 50 16 00 mov 0x165074,%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 78 50 16 00 cmp $0x165078,%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 ae b2 02 00 call 139a14 <__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 61 12 00 00 call 10fa0c <== 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 20 15 00 00 call 10fcd4 <_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 00126d20 : int utime( const char *path, const struct utimbuf *times ) { 126d20: 55 push %ebp 126d21: 89 e5 mov %esp,%ebp 126d23: 57 push %edi 126d24: 56 push %esi 126d25: 53 push %ebx 126d26: 83 ec 38 sub $0x38,%esp 126d29: 8b 55 08 mov 0x8(%ebp),%edx 126d2c: 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 ) ) 126d2f: 31 c0 xor %eax,%eax 126d31: 83 c9 ff or $0xffffffff,%ecx 126d34: 89 d7 mov %edx,%edi 126d36: f2 ae repnz scas %es:(%edi),%al 126d38: f7 d1 not %ecx 126d3a: 49 dec %ecx 126d3b: 6a 01 push $0x1 126d3d: 8d 75 d4 lea -0x2c(%ebp),%esi 126d40: 56 push %esi 126d41: 6a 00 push $0x0 126d43: 51 push %ecx 126d44: 52 push %edx 126d45: e8 7e 49 fe ff call 10b6c8 126d4a: 83 c4 20 add $0x20,%esp 126d4d: 83 cf ff or $0xffffffff,%edi 126d50: 85 c0 test %eax,%eax 126d52: 75 4f jne 126da3 return -1; if ( !temp_loc.ops->utime_h ){ 126d54: 8b 55 e0 mov -0x20(%ebp),%edx 126d57: 8b 42 30 mov 0x30(%edx),%eax 126d5a: 85 c0 test %eax,%eax 126d5c: 75 20 jne 126d7e rtems_filesystem_freenode( &temp_loc ); 126d5e: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 126d61: 85 c0 test %eax,%eax <== NOT EXECUTED 126d63: 74 09 je 126d6e <== NOT EXECUTED 126d65: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 126d68: 56 push %esi <== NOT EXECUTED 126d69: ff d0 call *%eax <== NOT EXECUTED 126d6b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 126d6e: e8 a1 2c 01 00 call 139a14 <__errno> <== NOT EXECUTED 126d73: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 126d79: 83 cf ff or $0xffffffff,%edi <== NOT EXECUTED 126d7c: eb 25 jmp 126da3 <== NOT EXECUTED } result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime ); 126d7e: 52 push %edx 126d7f: ff 73 04 pushl 0x4(%ebx) 126d82: ff 33 pushl (%ebx) 126d84: 56 push %esi 126d85: ff d0 call *%eax 126d87: 89 c7 mov %eax,%edi rtems_filesystem_freenode( &temp_loc ); 126d89: 8b 45 e0 mov -0x20(%ebp),%eax 126d8c: 83 c4 10 add $0x10,%esp 126d8f: 85 c0 test %eax,%eax 126d91: 74 10 je 126da3 126d93: 8b 40 1c mov 0x1c(%eax),%eax 126d96: 85 c0 test %eax,%eax 126d98: 74 09 je 126da3 126d9a: 83 ec 0c sub $0xc,%esp 126d9d: 56 push %esi 126d9e: ff d0 call *%eax 126da0: 83 c4 10 add $0x10,%esp return result; } 126da3: 89 f8 mov %edi,%eax 126da5: 8d 65 f4 lea -0xc(%ebp),%esp 126da8: 5b pop %ebx 126da9: 5e pop %esi 126daa: 5f pop %edi 126dab: c9 leave 126dac: c3 ret 0011cc34 : ssize_t write( int fd, const void *buffer, size_t count ) { 11cc34: 55 push %ebp 11cc35: 89 e5 mov %esp,%ebp 11cc37: 56 push %esi 11cc38: 53 push %ebx 11cc39: 8b 5d 08 mov 0x8(%ebp),%ebx 11cc3c: 8b 55 0c mov 0xc(%ebp),%edx 11cc3f: 8b 4d 10 mov 0x10(%ebp),%ecx ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 11cc42: 3b 1d 44 01 12 00 cmp 0x120144,%ebx 11cc48: 73 14 jae 11cc5e iop = rtems_libio_iop( fd ); 11cc4a: c1 e3 06 shl $0x6,%ebx 11cc4d: 03 1d 90 40 12 00 add 0x124090,%ebx rtems_libio_check_is_open( iop ); 11cc53: 8b 73 14 mov 0x14(%ebx),%esi 11cc56: f7 c6 00 01 00 00 test $0x100,%esi 11cc5c: 75 0d jne 11cc6b 11cc5e: e8 f1 48 ff ff call 111554 <__errno> <== NOT EXECUTED 11cc63: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 11cc69: eb 31 jmp 11cc9c <== NOT EXECUTED rtems_libio_check_buffer( buffer ); 11cc6b: 85 d2 test %edx,%edx 11cc6d: 74 0b je 11cc7a rtems_libio_check_count( count ); 11cc6f: 31 c0 xor %eax,%eax 11cc71: 85 c9 test %ecx,%ecx 11cc73: 74 44 je 11ccb9 rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 11cc75: 83 e6 04 and $0x4,%esi 11cc78: 75 0d jne 11cc87 11cc7a: e8 d5 48 ff ff call 111554 <__errno> <== NOT EXECUTED 11cc7f: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11cc85: eb 15 jmp 11cc9c <== NOT EXECUTED /* * Now process the write() request. */ if ( !iop->handlers->write_h ) 11cc87: 8b 43 3c mov 0x3c(%ebx),%eax 11cc8a: 8b 40 0c mov 0xc(%eax),%eax 11cc8d: 85 c0 test %eax,%eax 11cc8f: 75 10 jne 11cca1 rtems_set_errno_and_return_minus_one( ENOTSUP ); 11cc91: e8 be 48 ff ff call 111554 <__errno> <== NOT EXECUTED 11cc96: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11cc9c: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED 11cc9f: eb 18 jmp 11ccb9 <== NOT EXECUTED rc = (*iop->handlers->write_h)( iop, buffer, count ); 11cca1: 56 push %esi 11cca2: 51 push %ecx 11cca3: 52 push %edx 11cca4: 53 push %ebx 11cca5: ff d0 call *%eax if ( rc > 0 ) 11cca7: 83 c4 10 add $0x10,%esp 11ccaa: 85 c0 test %eax,%eax 11ccac: 7e 0b jle 11ccb9 iop->offset += rc; 11ccae: 89 c1 mov %eax,%ecx 11ccb0: c1 f9 1f sar $0x1f,%ecx 11ccb3: 01 43 0c add %eax,0xc(%ebx) 11ccb6: 11 4b 10 adc %ecx,0x10(%ebx) return rc; } 11ccb9: 8d 65 f8 lea -0x8(%ebp),%esp 11ccbc: 5b pop %ebx 11ccbd: 5e pop %esi 11ccbe: c9 leave 11ccbf: 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 48 12 00 cmp 0x124844,%esi 10ab51: 73 11 jae 10ab64 iop = rtems_libio_iop( fd ); 10ab53: c1 e6 06 shl $0x6,%esi 10ab56: 03 35 68 8f 12 00 add 0x128f68,%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 63 88 00 00 call 1133cc <__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 33 88 00 00 call 1133cc <__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 f8 87 00 00 call 1133cc <__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