=============================================================================== 0010b2d0 <__jffs2_dbg_acct_sanity_check>: void __jffs2_dbg_acct_sanity_check(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) { spin_lock(&c->erase_completion_lock); jffs2_dbg_acct_sanity_check_nolock(c, jeb); 10b2d0: e9 8b fe ff ff jmp 10b160 <__jffs2_dbg_acct_sanity_check_nolock> <== NOT EXECUTED 10b2d5: 90 nop 10b2d6: 90 nop 10b2d7: 90 nop 10b2d8: 90 nop 10b2d9: 90 nop 10b2da: 90 nop 10b2db: 90 nop 10b2dc: 90 nop 10b2dd: 90 nop 10b2de: 90 nop 10b2df: 90 nop =============================================================================== 0010b160 <__jffs2_dbg_acct_sanity_check_nolock>: #ifdef JFFS2_DBG_SANITY_CHECKS void __jffs2_dbg_acct_sanity_check_nolock(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) { 10b160: 55 push %ebp 10b161: 89 e5 mov %esp,%ebp 10b163: 83 ec 38 sub $0x38,%esp 10b166: 89 75 fc mov %esi,-0x4(%ebp) 10b169: 8b 75 0c mov 0xc(%ebp),%esi 10b16c: 89 5d f8 mov %ebx,-0x8(%ebp) 10b16f: 8b 5d 08 mov 0x8(%ebp),%ebx if (unlikely(jeb && jeb->used_size + jeb->dirty_size + 10b172: 85 f6 test %esi,%esi 10b174: 74 20 je 10b196 <__jffs2_dbg_acct_sanity_check_nolock+0x36><== NEVER TAKEN 10b176: 8b 56 14 mov 0x14(%esi),%edx 10b179: 8b 46 18 mov 0x18(%esi),%eax 10b17c: 8b 4e 20 mov 0x20(%esi),%ecx 10b17f: 01 d0 add %edx,%eax 10b181: 8b 56 1c mov 0x1c(%esi),%edx 10b184: 01 c8 add %ecx,%eax 10b186: 8b 4e 10 mov 0x10(%esi),%ecx 10b189: 01 d0 add %edx,%eax 10b18b: 01 c8 add %ecx,%eax 10b18d: 3b 43 34 cmp 0x34(%ebx),%eax 10b190: 0f 85 b4 00 00 00 jne 10b24a <__jffs2_dbg_acct_sanity_check_nolock+0xea><== NEVER TAKEN jeb->free_size, jeb->dirty_size, jeb->used_size, jeb->wasted_size, jeb->unchecked_size, c->sector_size); BUG(); } if (unlikely(c->used_size + c->dirty_size + c->free_size + c->erasing_size + c->bad_size 10b196: 8b 53 1c mov 0x1c(%ebx),%edx 10b199: 8b 43 20 mov 0x20(%ebx),%eax 10b19c: 8b 4b 28 mov 0x28(%ebx),%ecx 10b19f: 8b 73 2c mov 0x2c(%ebx),%esi 10b1a2: 01 d0 add %edx,%eax 10b1a4: 8b 53 30 mov 0x30(%ebx),%edx 10b1a7: 01 c8 add %ecx,%eax 10b1a9: 8b 4b 24 mov 0x24(%ebx),%ecx 10b1ac: 01 f0 add %esi,%eax 10b1ae: 8b 73 38 mov 0x38(%ebx),%esi 10b1b1: 01 d0 add %edx,%eax 10b1b3: 01 c8 add %ecx,%eax 10b1b5: 01 f0 add %esi,%eax 10b1b7: 3b 43 18 cmp 0x18(%ebx),%eax 10b1ba: 75 0a jne 10b1c6 <__jffs2_dbg_acct_sanity_check_nolock+0x66><== NEVER TAKEN JFFS2_ERROR("free %#08x + dirty %#08x + used %#08x + erasing %#08x + bad %#08x + wasted %#08x + unchecked %#08x != total %#08x.\n", c->free_size, c->dirty_size, c->used_size, c->erasing_size, c->bad_size, c->wasted_size, c->unchecked_size, c->flash_size); BUG(); } } 10b1bc: 8b 5d f8 mov -0x8(%ebp),%ebx 10b1bf: 8b 75 fc mov -0x4(%ebp),%esi 10b1c2: 89 ec mov %ebp,%esp 10b1c4: 5d pop %ebp 10b1c5: c3 ret JFFS2_ERROR("eeep, space accounting superblock info is screwed.\n"); 10b1c6: c7 44 24 04 00 06 13 movl $0x130600,0x4(%esp) <== NOT EXECUTED 10b1cd: 00 10b1ce: c7 04 24 0c 05 13 00 movl $0x13050c,(%esp) <== NOT EXECUTED 10b1d5: e8 66 ff ff ff call 10b140 <== NOT EXECUTED JFFS2_ERROR("free %#08x + dirty %#08x + used %#08x + erasing %#08x + bad %#08x + wasted %#08x + unchecked %#08x != total %#08x.\n", 10b1da: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10b1dd: 89 44 24 24 mov %eax,0x24(%esp) <== NOT EXECUTED 10b1e1: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10b1e4: 89 44 24 20 mov %eax,0x20(%esp) <== NOT EXECUTED 10b1e8: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 10b1eb: 89 44 24 1c mov %eax,0x1c(%esp) <== NOT EXECUTED 10b1ef: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10b1f2: 89 44 24 18 mov %eax,0x18(%esp) <== NOT EXECUTED 10b1f6: 8b 43 2c mov 0x2c(%ebx),%eax <== NOT EXECUTED 10b1f9: 89 44 24 14 mov %eax,0x14(%esp) <== NOT EXECUTED 10b1fd: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10b200: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED 10b204: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 10b207: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 10b20b: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10b20e: c7 44 24 04 00 06 13 movl $0x130600,0x4(%esp) <== NOT EXECUTED 10b215: 00 10b216: c7 04 24 58 05 13 00 movl $0x130558,(%esp) <== NOT EXECUTED 10b21d: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 10b221: e8 1a ff ff ff call 10b140 <== NOT EXECUTED BUG(); 10b226: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED 10b22d: 00 10b22e: c7 44 24 08 00 06 13 movl $0x130600,0x8(%esp) <== NOT EXECUTED 10b235: 00 10b236: c7 44 24 04 31 00 00 movl $0x31,0x4(%esp) <== NOT EXECUTED 10b23d: 00 10b23e: c7 04 24 e0 04 13 00 movl $0x1304e0,(%esp) <== NOT EXECUTED 10b245: e8 26 2a 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED JFFS2_ERROR("eeep, space accounting for block at 0x%08x is screwed.\n", jeb->offset); 10b24a: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 10b24d: c7 44 24 04 00 06 13 movl $0x130600,0x4(%esp) <== NOT EXECUTED 10b254: 00 10b255: c7 04 24 20 04 13 00 movl $0x130420,(%esp) <== NOT EXECUTED 10b25c: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 10b260: e8 db fe ff ff call 10b140 <== NOT EXECUTED JFFS2_ERROR("free %#08x + dirty %#08x + used %#08x + wasted %#08x + unchecked %#08x != total %#08x.\n", 10b265: 8b 43 34 mov 0x34(%ebx),%eax <== NOT EXECUTED 10b268: 89 44 24 1c mov %eax,0x1c(%esp) <== NOT EXECUTED 10b26c: 8b 46 10 mov 0x10(%esi),%eax <== NOT EXECUTED 10b26f: 89 44 24 18 mov %eax,0x18(%esp) <== NOT EXECUTED 10b273: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED 10b276: 89 44 24 14 mov %eax,0x14(%esp) <== NOT EXECUTED 10b27a: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED 10b27d: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED 10b281: 8b 46 18 mov 0x18(%esi),%eax <== NOT EXECUTED 10b284: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 10b288: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED 10b28b: c7 44 24 04 00 06 13 movl $0x130600,0x4(%esp) <== NOT EXECUTED 10b292: 00 10b293: c7 04 24 70 04 13 00 movl $0x130470,(%esp) <== NOT EXECUTED 10b29a: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 10b29e: e8 9d fe ff ff call 10b140 <== NOT EXECUTED BUG(); 10b2a3: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED 10b2aa: 00 10b2ab: c7 44 24 08 00 06 13 movl $0x130600,0x8(%esp) <== NOT EXECUTED 10b2b2: 00 10b2b3: c7 44 24 04 28 00 00 movl $0x28,0x4(%esp) <== NOT EXECUTED 10b2ba: 00 10b2bb: c7 04 24 e0 04 13 00 movl $0x1304e0,(%esp) <== NOT EXECUTED 10b2c2: e8 a9 29 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED 10b2c7: 90 nop 10b2c8: 90 nop 10b2c9: 90 nop 10b2ca: 90 nop 10b2cb: 90 nop 10b2cc: 90 nop 10b2cd: 90 nop 10b2ce: 90 nop 10b2cf: 90 nop =============================================================================== 00106120 <__jffs2_ref_totlen>: } uint32_t __jffs2_ref_totlen(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb, struct jffs2_raw_node_ref *ref) { 106120: 55 push %ebp 106121: 89 e5 mov %esp,%ebp 106123: 83 ec 28 sub $0x28,%esp 106126: 89 5d f8 mov %ebx,-0x8(%ebp) 106129: 8b 5d 10 mov 0x10(%ebp),%ebx 10612c: 89 75 fc mov %esi,-0x4(%ebp) if (ref->flash_offset == REF_LINK_NODE) { 10612f: 8b 43 0c mov 0xc(%ebx),%eax jeb = &c->blocks[ref->flash_offset / c->sector_size]; 106132: 8b 4b 04 mov 0x4(%ebx),%ecx 106135: 83 f8 ff cmp $0xffffffff,%eax 106138: 74 26 je 106160 <__jffs2_ref_totlen+0x40> if (ref->flash_offset == REF_EMPTY_NODE) 10613a: 83 f8 fe cmp $0xfffffffe,%eax 10613d: 74 31 je 106170 <__jffs2_ref_totlen+0x50> ret = ref->__totlen; } #endif /* TEST_TOTLEN */ return ret; } 10613f: 8b 5d f8 mov -0x8(%ebp),%ebx ref_end = ref_offset(next_ref); 106142: 83 e0 fc and $0xfffffffc,%eax return ref_end - ref_offset(ref); 106145: 83 e1 fc and $0xfffffffc,%ecx } 106148: 8b 75 fc mov -0x4(%ebp),%esi 10614b: 89 ec mov %ebp,%esp return ref_end - ref_offset(ref); 10614d: 29 c8 sub %ecx,%eax } 10614f: 5d pop %ebp 106150: c3 ret 106151: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 106158: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10615f: 90 nop ref = ref->next_in_ino; 106160: 8b 43 08 mov 0x8(%ebx),%eax if (!ref) 106163: 85 c0 test %eax,%eax 106165: 74 09 je 106170 <__jffs2_ref_totlen+0x50> <== NEVER TAKEN if (ref->flash_offset == REF_EMPTY_NODE) 106167: 8b 40 04 mov 0x4(%eax),%eax 10616a: eb ce jmp 10613a <__jffs2_ref_totlen+0x1a> 10616c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi if (!jeb) 106170: 8b 45 0c mov 0xc(%ebp),%eax 106173: 85 c0 test %eax,%eax 106175: 74 39 je 1061b0 <__jffs2_ref_totlen+0x90> <== NEVER TAKEN if (unlikely(ref != jeb->last_node)) { 106177: 8b 45 0c mov 0xc(%ebp),%eax 10617a: 8b 40 2c mov 0x2c(%eax),%eax 10617d: 39 c3 cmp %eax,%ebx 10617f: 75 4a jne 1061cb <__jffs2_ref_totlen+0xab> <== NEVER TAKEN ref_end = jeb->offset + c->sector_size - jeb->free_size; 106181: 8b 55 0c mov 0xc(%ebp),%edx return ref_end - ref_offset(ref); 106184: 83 e1 fc and $0xfffffffc,%ecx ref_end = jeb->offset + c->sector_size - jeb->free_size; 106187: 8b 45 08 mov 0x8(%ebp),%eax 10618a: 8b 5a 0c mov 0xc(%edx),%ebx 10618d: 8b 40 34 mov 0x34(%eax),%eax 106190: 8b 72 20 mov 0x20(%edx),%esi 106193: 01 d8 add %ebx,%eax } 106195: 8b 5d f8 mov -0x8(%ebp),%ebx ref_end = jeb->offset + c->sector_size - jeb->free_size; 106198: 29 f0 sub %esi,%eax } 10619a: 8b 75 fc mov -0x4(%ebp),%esi 10619d: 89 ec mov %ebp,%esp 10619f: 5d pop %ebp return ref_end - ref_offset(ref); 1061a0: 29 c8 sub %ecx,%eax } 1061a2: c3 ret 1061a3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1061aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi jeb = &c->blocks[ref->flash_offset / c->sector_size]; 1061b0: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 1061b3: 89 c8 mov %ecx,%eax <== NOT EXECUTED 1061b5: 31 d2 xor %edx,%edx <== NOT EXECUTED 1061b7: f7 76 34 divl 0x34(%esi) <== NOT EXECUTED 1061ba: 8d 14 40 lea (%eax,%eax,2),%edx <== NOT EXECUTED 1061bd: 8d 14 90 lea (%eax,%edx,4),%edx <== NOT EXECUTED 1061c0: 8b 46 54 mov 0x54(%esi),%eax <== NOT EXECUTED 1061c3: 8d 04 90 lea (%eax,%edx,4),%eax <== NOT EXECUTED 1061c6: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1061c9: eb ac jmp 106177 <__jffs2_ref_totlen+0x57> <== NOT EXECUTED pr_crit("ref %p @0x%08x is not jeb->last_node (%p @0x%08x)\n", 1061cb: 85 c0 test %eax,%eax <== NOT EXECUTED 1061cd: 74 49 je 106218 <__jffs2_ref_totlen+0xf8> <== NOT EXECUTED 1061cf: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 1061d2: 83 e2 fc and $0xfffffffc,%edx <== NOT EXECUTED 1061d5: 89 54 24 10 mov %edx,0x10(%esp) <== NOT EXECUTED 1061d9: 83 e1 fc and $0xfffffffc,%ecx <== NOT EXECUTED 1061dc: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 1061e0: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED 1061e4: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED 1061e8: c7 04 24 68 ec 12 00 movl $0x12ec68,(%esp) <== NOT EXECUTED 1061ef: e8 8c f1 ff ff call 105380 <== NOT EXECUTED BUG(); 1061f4: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED 1061fb: 00 1061fc: c7 44 24 08 a8 ec 12 movl $0x12eca8,0x8(%esp) <== NOT EXECUTED 106203: 00 106204: c7 44 24 04 c9 02 00 movl $0x2c9,0x4(%esp) <== NOT EXECUTED 10620b: 00 10620c: c7 04 24 44 eb 12 00 movl $0x12eb44,(%esp) <== NOT EXECUTED 106213: e8 58 7a 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED pr_crit("ref %p @0x%08x is not jeb->last_node (%p @0x%08x)\n", 106218: 31 d2 xor %edx,%edx <== NOT EXECUTED 10621a: eb b9 jmp 1061d5 <__jffs2_ref_totlen+0xb5> <== NOT EXECUTED 10621c: 90 nop 10621d: 90 nop 10621e: 90 nop 10621f: 90 nop =============================================================================== 00105450 : { 105450: 55 push %ebp 105451: 89 e5 mov %esp,%ebp 105453: 57 push %edi 105454: 56 push %esi 105455: 53 push %ebx 105456: 83 ec 2c sub $0x2c,%esp 105459: 8b 7d 10 mov 0x10(%ebp),%edi 10545c: 8b 45 08 mov 0x8(%ebp),%eax while ((*prev) && (*prev)->nhash <= new->nhash) { 10545f: 8b 1f mov (%edi),%ebx { 105461: 89 45 dc mov %eax,-0x24(%ebp) 105464: 8b 45 0c mov 0xc(%ebp),%eax while ((*prev) && (*prev)->nhash <= new->nhash) { 105467: 85 db test %ebx,%ebx { 105469: 89 45 e0 mov %eax,-0x20(%ebp) while ((*prev) && (*prev)->nhash <= new->nhash) { 10546c: 0f 84 7e 00 00 00 je 1054f0 105472: 8b 70 10 mov 0x10(%eax),%esi if ((*prev)->nhash == new->nhash && !strcmp((*prev)->name, new->name)) { 105475: 83 c0 15 add $0x15,%eax 105478: 89 45 e4 mov %eax,-0x1c(%ebp) 10547b: eb 0d jmp 10548a 10547d: 8d 76 00 lea 0x0(%esi),%esi prev = &((*prev)->next); 105480: 8d 7b 04 lea 0x4(%ebx),%edi while ((*prev) && (*prev)->nhash <= new->nhash) { 105483: 8b 5b 04 mov 0x4(%ebx),%ebx 105486: 85 db test %ebx,%ebx 105488: 74 66 je 1054f0 10548a: 39 73 10 cmp %esi,0x10(%ebx) 10548d: 77 61 ja 1054f0 if ((*prev)->nhash == new->nhash && !strcmp((*prev)->name, new->name)) { 10548f: 75 ef jne 105480 105491: 8b 55 e4 mov -0x1c(%ebp),%edx 105494: 8d 43 15 lea 0x15(%ebx),%eax 105497: 89 04 24 mov %eax,(%esp) 10549a: 89 54 24 04 mov %edx,0x4(%esp) 10549e: e8 bd 19 02 00 call 126e60 1054a3: 85 c0 test %eax,%eax 1054a5: 75 d9 jne 105480 <== NEVER TAKEN if (new->version < (*prev)->version) { 1054a7: 8b 45 e0 mov -0x20(%ebp),%eax 1054aa: 8b 4b 08 mov 0x8(%ebx),%ecx 1054ad: 39 48 08 cmp %ecx,0x8(%eax) 1054b0: 72 4e jb 105500 <== NEVER TAKEN new->next = (*prev)->next; 1054b2: 8b 43 04 mov 0x4(%ebx),%eax 1054b5: 8b 4d e0 mov -0x20(%ebp),%ecx 1054b8: 89 41 04 mov %eax,0x4(%ecx) if ((*prev)->raw) 1054bb: 8b 07 mov (%edi),%eax 1054bd: 8b 08 mov (%eax),%ecx 1054bf: 85 c9 test %ecx,%ecx 1054c1: 74 11 je 1054d4 jffs2_mark_node_obsolete(c, ((*prev)->raw)); 1054c3: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED 1054c7: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 1054ca: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1054cd: e8 ee 0e 00 00 call 1063c0 <== NOT EXECUTED jffs2_free_full_dirent(*prev); 1054d2: 8b 07 mov (%edi),%eax 1054d4: 89 04 24 mov %eax,(%esp) 1054d7: e8 54 fc ff ff call 105130 *prev = new; 1054dc: 8b 45 e0 mov -0x20(%ebp),%eax 1054df: 89 07 mov %eax,(%edi) 1054e1: eb 15 jmp 1054f8 1054e3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1054ea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi new->next = *prev; 1054f0: 8b 45 e0 mov -0x20(%ebp),%eax 1054f3: 89 58 04 mov %ebx,0x4(%eax) *prev = new; 1054f6: 89 07 mov %eax,(%edi) } 1054f8: 83 c4 2c add $0x2c,%esp 1054fb: 5b pop %ebx 1054fc: 5e pop %esi 1054fd: 5f pop %edi 1054fe: 5d pop %ebp 1054ff: c3 ret jffs2_mark_node_obsolete(c, new->raw); 105500: 89 c6 mov %eax,%esi <== NOT EXECUTED 105502: 8b 00 mov (%eax),%eax <== NOT EXECUTED 105504: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 105508: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 10550b: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10550e: e8 ad 0e 00 00 call 1063c0 <== NOT EXECUTED jffs2_free_full_dirent(new); 105513: 89 75 08 mov %esi,0x8(%ebp) <== NOT EXECUTED } 105516: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED 105519: 5b pop %ebx <== NOT EXECUTED 10551a: 5e pop %esi <== NOT EXECUTED 10551b: 5f pop %edi <== NOT EXECUTED 10551c: 5d pop %ebp <== NOT EXECUTED jffs2_free_full_dirent(new); 10551d: e9 0e fc ff ff jmp 105130 <== NOT EXECUTED 105522: 90 nop 105523: 90 nop 105524: 90 nop 105525: 90 nop 105526: 90 nop 105527: 90 nop 105528: 90 nop 105529: 90 nop 10552a: 90 nop 10552b: 90 nop 10552c: 90 nop 10552d: 90 nop 10552e: 90 nop 10552f: 90 nop =============================================================================== 001056b0 : { 1056b0: 55 push %ebp 1056b1: 89 e5 mov %esp,%ebp 1056b3: 57 push %edi 1056b4: 56 push %esi 1056b5: 53 push %ebx 1056b6: 83 ec 2c sub $0x2c,%esp if (unlikely(!fn->size)) 1056b9: 8b 45 10 mov 0x10(%ebp),%eax 1056bc: 8b 40 08 mov 0x8(%eax),%eax 1056bf: 89 45 e0 mov %eax,-0x20(%ebp) 1056c2: 85 c0 test %eax,%eax 1056c4: 75 0a jne 1056d0 <== ALWAYS TAKEN return 0; 1056c6: 31 c0 xor %eax,%eax } 1056c8: 83 c4 2c add $0x2c,%esp 1056cb: 5b pop %ebx 1056cc: 5e pop %esi 1056cd: 5f pop %edi 1056ce: 5d pop %ebp 1056cf: c3 ret newfrag = new_fragment(fn, fn->ofs, fn->size); 1056d0: 8b 45 10 mov 0x10(%ebp),%eax 1056d3: 8b 70 04 mov 0x4(%eax),%esi 1056d6: 89 75 dc mov %esi,-0x24(%ebp) newfrag = jffs2_alloc_node_frag(); 1056d9: e8 e2 fb ff ff call 1052c0 if (likely(newfrag)) { 1056de: 85 c0 test %eax,%eax newfrag = jffs2_alloc_node_frag(); 1056e0: 89 c7 mov %eax,%edi if (likely(newfrag)) { 1056e2: 0f 84 58 03 00 00 je 105a40 <== NEVER TAKEN newfrag->ofs = ofs; 1056e8: 89 70 18 mov %esi,0x18(%eax) newfrag->size = size; 1056eb: 8b 45 e0 mov -0x20(%ebp),%eax struct jffs2_node_frag *prev = NULL; 1056ee: 31 c9 xor %ecx,%ecx newfrag->size = size; 1056f0: 89 47 14 mov %eax,0x14(%edi) newfrag->node = fn; 1056f3: 8b 45 10 mov 0x10(%ebp),%eax 1056f6: 89 47 10 mov %eax,0x10(%edi) newfrag->node->frags = 1; 1056f9: c7 40 0c 01 00 00 00 movl $0x1,0xc(%eax) ret = jffs2_add_frag_to_fragtree(c, &f->fragtree, newfrag); 105700: 8b 45 0c mov 0xc(%ebp),%eax 105703: 83 c0 04 add $0x4,%eax 105706: 89 45 e4 mov %eax,-0x1c(%ebp) this = jffs2_lookup_node_frag(root, newfrag->node->ofs); 105709: 8b 45 10 mov 0x10(%ebp),%eax 10570c: 8b 50 04 mov 0x4(%eax),%edx next = fragtree->rb_node; 10570f: 8b 45 0c mov 0xc(%ebp),%eax 105712: 8b 58 04 mov 0x4(%eax),%ebx while(next) { 105715: 85 db test %ebx,%ebx 105717: 0f 84 53 01 00 00 je 105870 10571d: 8d 76 00 lea 0x0(%esi),%esi if (frag->ofs + frag->size <= offset) { 105720: 8b 43 18 mov 0x18(%ebx),%eax 105723: 8b 73 14 mov 0x14(%ebx),%esi 105726: 01 c6 add %eax,%esi 105728: 39 f2 cmp %esi,%edx 10572a: 0f 82 30 01 00 00 jb 105860 if (!prev || frag->ofs > prev->ofs) 105730: 85 c9 test %ecx,%ecx 105732: 0f 84 18 01 00 00 je 105850 105738: 3b 41 18 cmp 0x18(%ecx),%eax 10573b: 0f 87 0f 01 00 00 ja 105850 <== ALWAYS TAKEN next = frag->rb.rb_right; 105741: 8b 5b 04 mov 0x4(%ebx),%ebx while(next) { 105744: 85 db test %ebx,%ebx 105746: 75 d8 jne 105720 if (this) { 105748: 85 c9 test %ecx,%ecx 10574a: 0f 84 20 01 00 00 je 105870 <== NEVER TAKEN lastend = this->ofs + this->size; 105750: 8b 41 18 mov 0x18(%ecx),%eax 105753: 89 cb mov %ecx,%ebx 105755: 8b 71 14 mov 0x14(%ecx),%esi 105758: 01 c6 add %eax,%esi if (lastend <= newfrag->ofs) { 10575a: 39 75 dc cmp %esi,-0x24(%ebp) 10575d: 0f 83 2d 02 00 00 jae 105990 if (newfrag->ofs > this->ofs) { 105763: 39 45 dc cmp %eax,-0x24(%ebp) 105766: 0f 86 74 02 00 00 jbe 1059e0 mark_ref_normal(newfrag->node->raw); 10576c: 8b 55 10 mov 0x10(%ebp),%edx if (this->node) 10576f: 8b 4b 10 mov 0x10(%ebx),%ecx mark_ref_normal(newfrag->node->raw); 105772: 8b 12 mov (%edx),%edx 105774: 83 4a 04 03 orl $0x3,0x4(%edx) if (this->node) 105778: 85 c9 test %ecx,%ecx 10577a: 74 06 je 105782 mark_ref_normal(this->node->raw); 10577c: 8b 11 mov (%ecx),%edx 10577e: 83 4a 04 03 orl $0x3,0x4(%edx) if (this->ofs + this->size > newfrag->ofs + newfrag->size) { 105782: 8b 55 e0 mov -0x20(%ebp),%edx 105785: 89 4d d8 mov %ecx,-0x28(%ebp) 105788: 8b 4d dc mov -0x24(%ebp),%ecx 10578b: 01 ca add %ecx,%edx 10578d: 39 f2 cmp %esi,%edx 10578f: 0f 83 4b 01 00 00 jae 1058e0 <== ALWAYS TAKEN newfrag2 = new_fragment(this->node, newfrag->ofs + newfrag->size, 105795: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED 105798: 29 d6 sub %edx,%esi <== NOT EXECUTED 10579a: 89 75 e0 mov %esi,-0x20(%ebp) <== NOT EXECUTED newfrag = jffs2_alloc_node_frag(); 10579d: e8 1e fb ff ff call 1052c0 <== NOT EXECUTED if (likely(newfrag)) { 1057a2: 85 c0 test %eax,%eax <== NOT EXECUTED newfrag = jffs2_alloc_node_frag(); 1057a4: 89 c6 mov %eax,%esi <== NOT EXECUTED if (likely(newfrag)) { 1057a6: 0f 84 94 02 00 00 je 105a40 <== NOT EXECUTED newfrag->ofs = ofs; 1057ac: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED newfrag->node = fn; 1057af: 8b 4d d8 mov -0x28(%ebp),%ecx <== NOT EXECUTED newfrag->ofs = ofs; 1057b2: 89 50 18 mov %edx,0x18(%eax) <== NOT EXECUTED newfrag->size = size; 1057b5: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED newfrag->node = fn; 1057b8: 89 4e 10 mov %ecx,0x10(%esi) <== NOT EXECUTED newfrag->size = size; 1057bb: 89 46 14 mov %eax,0x14(%esi) <== NOT EXECUTED if (this->node) 1057be: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 1057c1: 85 c0 test %eax,%eax <== NOT EXECUTED 1057c3: 74 03 je 1057c8 <== NOT EXECUTED this->node->frags++; 1057c5: ff 40 0c incl 0xc(%eax) <== NOT EXECUTED this->size = newfrag->ofs - this->ofs; 1057c8: 8b 53 18 mov 0x18(%ebx),%edx <== NOT EXECUTED 1057cb: 8b 47 18 mov 0x18(%edi),%eax <== NOT EXECUTED 1057ce: 29 d0 sub %edx,%eax <== NOT EXECUTED jffs2_fragtree_insert(newfrag, this); 1057d0: 89 da mov %ebx,%edx <== NOT EXECUTED this->size = newfrag->ofs - this->ofs; 1057d2: 89 43 14 mov %eax,0x14(%ebx) <== NOT EXECUTED jffs2_fragtree_insert(newfrag, this); 1057d5: 89 f8 mov %edi,%eax <== NOT EXECUTED 1057d7: e8 c4 fb ff ff call 1053a0 <== NOT EXECUTED _RBTree_Insert_color( (RBTree_Control *) root, node ); 1057dc: 8b 5d e4 mov -0x1c(%ebp),%ebx <== NOT EXECUTED 1057df: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED 1057e3: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1057e6: e8 65 00 01 00 call 115850 <_RBTree_Insert_color> <== NOT EXECUTED jffs2_fragtree_insert(newfrag2, newfrag); 1057eb: 89 f0 mov %esi,%eax <== NOT EXECUTED 1057ed: 89 fa mov %edi,%edx <== NOT EXECUTED 1057ef: e8 ac fb ff ff call 1053a0 <== NOT EXECUTED 1057f4: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED 1057f8: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1057fb: e8 50 00 01 00 call 115850 <_RBTree_Insert_color> <== NOT EXECUTED if (newfrag->ofs & (PAGE_SIZE-1)) { 105800: 8b 47 18 mov 0x18(%edi),%eax <== NOT EXECUTED 105803: a9 ff 0f 00 00 test $0xfff,%eax 105808: 0f 85 a8 00 00 00 jne 1058b6 if ((newfrag->ofs+newfrag->size) & (PAGE_SIZE-1)) { 10580e: 8b 57 14 mov 0x14(%edi),%edx 105811: 01 d0 add %edx,%eax 105813: a9 ff 0f 00 00 test $0xfff,%eax 105818: 0f 84 a8 fe ff ff je 1056c6 return _RBTree_Successor( node ); 10581e: 89 3c 24 mov %edi,(%esp) 105821: e8 9a 02 01 00 call 115ac0 <_RBTree_Successor> if (next) { 105826: 85 c0 test %eax,%eax 105828: 0f 84 98 fe ff ff je 1056c6 mark_ref_normal(fn->raw); 10582e: 8b 7d 10 mov 0x10(%ebp),%edi if (next->node) 105831: 8b 40 10 mov 0x10(%eax),%eax mark_ref_normal(fn->raw); 105834: 8b 17 mov (%edi),%edx 105836: 83 4a 04 03 orl $0x3,0x4(%edx) if (next->node) 10583a: 85 c0 test %eax,%eax 10583c: 0f 84 84 fe ff ff je 1056c6 <== NEVER TAKEN mark_ref_normal(next->node->raw); 105842: 8b 00 mov (%eax),%eax 105844: 83 48 04 03 orl $0x3,0x4(%eax) 105848: e9 79 fe ff ff jmp 1056c6 10584d: 8d 76 00 lea 0x0(%esi),%esi 105850: 89 d9 mov %ebx,%ecx 105852: e9 ea fe ff ff jmp 105741 105857: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10585e: 66 90 xchg %ax,%ax } else if (frag->ofs > offset) { 105860: 39 c2 cmp %eax,%edx 105862: 0f 83 f2 fe ff ff jae 10575a next = frag->rb.rb_left; 105868: 8b 1b mov (%ebx),%ebx 10586a: e9 d5 fe ff ff jmp 105744 10586f: 90 nop if (lastend < newfrag->node->ofs) { 105870: 85 d2 test %edx,%edx 105872: 0f 85 59 02 00 00 jne 105ad1 RB_SET( child, parent, Node ); 105878: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) *link = child; 10587f: 8b 45 0c mov 0xc(%ebp),%eax RB_SET( child, parent, Node ); 105882: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) 105889: c7 07 00 00 00 00 movl $0x0,(%edi) 10588f: c7 47 0c 01 00 00 00 movl $0x1,0xc(%edi) *link = child; 105896: 89 78 04 mov %edi,0x4(%eax) _RBTree_Insert_color( (RBTree_Control *) root, node ); 105899: 89 7c 24 04 mov %edi,0x4(%esp) 10589d: 8b 45 e4 mov -0x1c(%ebp),%eax 1058a0: 89 04 24 mov %eax,(%esp) 1058a3: e8 a8 ff 00 00 call 115850 <_RBTree_Insert_color> if (newfrag->ofs & (PAGE_SIZE-1)) { 1058a8: 8b 47 18 mov 0x18(%edi),%eax 1058ab: a9 ff 0f 00 00 test $0xfff,%eax 1058b0: 0f 84 58 ff ff ff je 10580e return _RBTree_Predecessor( node ); 1058b6: 89 3c 24 mov %edi,(%esp) 1058b9: e8 52 02 01 00 call 115b10 <_RBTree_Predecessor> mark_ref_normal(fn->raw); 1058be: 8b 4d 10 mov 0x10(%ebp),%ecx 1058c1: 8b 11 mov (%ecx),%edx if (prev->node) 1058c3: 8b 40 10 mov 0x10(%eax),%eax mark_ref_normal(fn->raw); 1058c6: 83 4a 04 03 orl $0x3,0x4(%edx) if (prev->node) 1058ca: 85 c0 test %eax,%eax 1058cc: 74 06 je 1058d4 mark_ref_normal(prev->node->raw); 1058ce: 8b 00 mov (%eax),%eax 1058d0: 83 48 04 03 orl $0x3,0x4(%eax) if ((newfrag->ofs+newfrag->size) & (PAGE_SIZE-1)) { 1058d4: 8b 47 18 mov 0x18(%edi),%eax 1058d7: e9 32 ff ff ff jmp 10580e 1058dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi this->size = newfrag->ofs - this->ofs; 1058e0: 8b 4d dc mov -0x24(%ebp),%ecx jffs2_fragtree_insert(newfrag, this); 1058e3: 89 da mov %ebx,%edx this->size = newfrag->ofs - this->ofs; 1058e5: 29 c1 sub %eax,%ecx jffs2_fragtree_insert(newfrag, this); 1058e7: 89 f8 mov %edi,%eax this->size = newfrag->ofs - this->ofs; 1058e9: 89 4b 14 mov %ecx,0x14(%ebx) jffs2_fragtree_insert(newfrag, this); 1058ec: e8 af fa ff ff call 1053a0 _RBTree_Insert_color( (RBTree_Control *) root, node ); 1058f1: 8b 45 e4 mov -0x1c(%ebp),%eax 1058f4: 89 7c 24 04 mov %edi,0x4(%esp) 1058f8: 89 04 24 mov %eax,(%esp) 1058fb: e8 50 ff 00 00 call 115850 <_RBTree_Insert_color> } 105900: eb 27 jmp 105929 105902: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105909: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi _RBTree_Extract( (RBTree_Control *) root, node ); 105910: 89 5c 24 04 mov %ebx,0x4(%esp) 105914: 8b 45 e4 mov -0x1c(%ebp),%eax 105917: 89 04 24 mov %eax,(%esp) 10591a: e8 a1 fa 00 00 call 1153c0 <_RBTree_Extract> jffs2_obsolete_node_frag(c, this); 10591f: 8b 45 08 mov 0x8(%ebp),%eax 105922: 89 da mov %ebx,%edx 105924: e8 f7 f9 ff ff call 105320 return _RBTree_Successor( node ); 105929: 89 3c 24 mov %edi,(%esp) 10592c: e8 8f 01 01 00 call 115ac0 <_RBTree_Successor> 105931: 89 c3 mov %eax,%ebx while ((this = frag_next(newfrag)) && newfrag->ofs + newfrag->size >= this->ofs + this->size) { 105933: 8b 47 18 mov 0x18(%edi),%eax 105936: 85 db test %ebx,%ebx 105938: 0f 84 c5 fe ff ff je 105803 10593e: 8b 4f 14 mov 0x14(%edi),%ecx 105941: 8b 73 18 mov 0x18(%ebx),%esi 105944: 8b 53 14 mov 0x14(%ebx),%edx 105947: 01 c1 add %eax,%ecx 105949: 01 f2 add %esi,%edx 10594b: 39 d1 cmp %edx,%ecx 10594d: 73 c1 jae 105910 if (!this || newfrag->ofs + newfrag->size == this->ofs) 10594f: 39 f1 cmp %esi,%ecx 105951: 0f 84 ac fe ff ff je 105803 this->size = (this->ofs + this->size) - (newfrag->ofs + newfrag->size); 105957: 29 ca sub %ecx,%edx 105959: 89 53 14 mov %edx,0x14(%ebx) this->ofs = newfrag->ofs + newfrag->size; 10595c: 8b 4f 14 mov 0x14(%edi),%ecx 10595f: 01 c8 add %ecx,%eax 105961: 89 43 18 mov %eax,0x18(%ebx) if (this->node) 105964: 8b 43 10 mov 0x10(%ebx),%eax 105967: 85 c0 test %eax,%eax 105969: 74 06 je 105971 <== NEVER TAKEN mark_ref_normal(this->node->raw); 10596b: 8b 00 mov (%eax),%eax 10596d: 83 48 04 03 orl $0x3,0x4(%eax) mark_ref_normal(newfrag->node->raw); 105971: 8b 47 10 mov 0x10(%edi),%eax 105974: 8b 00 mov (%eax),%eax 105976: 83 48 04 03 orl $0x3,0x4(%eax) if (newfrag->ofs & (PAGE_SIZE-1)) { 10597a: 8b 47 18 mov 0x18(%edi),%eax 10597d: e9 81 fe ff ff jmp 105803 105982: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105989: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi if (lastend && (lastend-1) >> PAGE_SHIFT == newfrag->ofs >> PAGE_SHIFT) { 105990: 85 f6 test %esi,%esi 105992: 74 14 je 1059a8 <== NEVER TAKEN 105994: 8b 4d dc mov -0x24(%ebp),%ecx 105997: 8d 46 ff lea -0x1(%esi),%eax 10599a: c1 e8 0c shr $0xc,%eax 10599d: c1 e9 0c shr $0xc,%ecx 1059a0: 39 c8 cmp %ecx,%eax 1059a2: 0f 84 0e 01 00 00 je 105ab6 if (lastend < newfrag->node->ofs) { 1059a8: 39 f2 cmp %esi,%edx 1059aa: 0f 87 b2 00 00 00 ja 105a62 <== NEVER TAKEN rb_link_node(&newfrag->rb, &this->rb, &this->rb.rb_right); 1059b0: 89 de mov %ebx,%esi RB_SET( child, parent, Node ); 1059b2: 89 77 08 mov %esi,0x8(%edi) 1059b5: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) 1059bc: c7 07 00 00 00 00 movl $0x0,(%edi) 1059c2: c7 47 0c 01 00 00 00 movl $0x1,0xc(%edi) *link = child; 1059c9: 89 7b 04 mov %edi,0x4(%ebx) struct rb_node **link ) { _RBTree_Initialize_node( node ); _RBTree_Add_child( node, parent, link ); } 1059cc: e9 c8 fe ff ff jmp 105899 1059d1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1059d8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1059df: 90 nop _RBTree_Replace_node( 1059e0: 89 7c 24 08 mov %edi,0x8(%esp) 1059e4: 8b 45 e4 mov -0x1c(%ebp),%eax 1059e7: 89 5c 24 04 mov %ebx,0x4(%esp) 1059eb: 89 04 24 mov %eax,(%esp) 1059ee: e8 dd 01 01 00 call 115bd0 <_RBTree_Replace_node> if (newfrag->ofs + newfrag->size >= this->ofs+this->size) { 1059f3: 8b 77 14 mov 0x14(%edi),%esi 1059f6: 8b 4f 18 mov 0x18(%edi),%ecx 1059f9: 8b 43 18 mov 0x18(%ebx),%eax 1059fc: 8b 53 14 mov 0x14(%ebx),%edx 1059ff: 01 f1 add %esi,%ecx 105a01: 89 4d e0 mov %ecx,-0x20(%ebp) 105a04: 8d 0c 10 lea (%eax,%edx,1),%ecx 105a07: 39 4d e0 cmp %ecx,-0x20(%ebp) 105a0a: 0f 83 0f ff ff ff jae 10591f <== ALWAYS TAKEN this->ofs += newfrag->size; 105a10: 01 f0 add %esi,%eax <== NOT EXECUTED 105a12: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED this->size -= newfrag->size; 105a15: 89 d0 mov %edx,%eax <== NOT EXECUTED jffs2_fragtree_insert(this, newfrag); 105a17: 89 fa mov %edi,%edx <== NOT EXECUTED this->size -= newfrag->size; 105a19: 29 f0 sub %esi,%eax <== NOT EXECUTED 105a1b: 89 43 14 mov %eax,0x14(%ebx) <== NOT EXECUTED jffs2_fragtree_insert(this, newfrag); 105a1e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 105a20: e8 7b f9 ff ff call 1053a0 <== NOT EXECUTED _RBTree_Insert_color( (RBTree_Control *) root, node ); 105a25: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 105a28: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED 105a2c: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 105a2f: e8 1c fe 00 00 call 115850 <_RBTree_Insert_color> <== NOT EXECUTED if (newfrag->ofs & (PAGE_SIZE-1)) { 105a34: 8b 47 18 mov 0x18(%edi),%eax <== NOT EXECUTED 105a37: e9 c7 fd ff ff jmp 105803 <== NOT EXECUTED 105a3c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED JFFS2_ERROR("cannot allocate a jffs2_node_frag object\n"); 105a40: c7 04 24 74 eb 12 00 movl $0x12eb74,(%esp) <== NOT EXECUTED 105a47: be fc ec 12 00 mov $0x12ecfc,%esi <== NOT EXECUTED 105a4c: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED 105a50: e8 2b f9 ff ff call 105380 <== NOT EXECUTED } 105a55: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED return -ENOMEM; 105a58: b8 f4 ff ff ff mov $0xfffffff4,%eax <== NOT EXECUTED } 105a5d: 5b pop %ebx <== NOT EXECUTED 105a5e: 5e pop %esi <== NOT EXECUTED 105a5f: 5f pop %edi <== NOT EXECUTED 105a60: 5d pop %ebp <== NOT EXECUTED 105a61: c3 ret <== NOT EXECUTED holefrag= new_fragment(NULL, lastend, newfrag->node->ofs - lastend); 105a62: 29 f2 sub %esi,%edx <== NOT EXECUTED 105a64: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED newfrag = jffs2_alloc_node_frag(); 105a67: e8 54 f8 ff ff call 1052c0 <== NOT EXECUTED if (likely(newfrag)) { 105a6c: 85 c0 test %eax,%eax <== NOT EXECUTED 105a6e: 0f 84 a4 00 00 00 je 105b18 <== NOT EXECUTED newfrag->ofs = ofs; 105a74: 89 70 18 mov %esi,0x18(%eax) <== NOT EXECUTED newfrag->size = size; 105a77: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED rb_link_node(&holefrag->rb, &this->rb, &this->rb.rb_right); 105a7a: 89 c6 mov %eax,%esi <== NOT EXECUTED RB_SET( child, parent, Node ); 105a7c: 89 58 08 mov %ebx,0x8(%eax) <== NOT EXECUTED newfrag->node = fn; 105a7f: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) <== NOT EXECUTED 105a86: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED newfrag->size = size; 105a8d: 89 48 14 mov %ecx,0x14(%eax) <== NOT EXECUTED 105a90: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 105a96: c7 40 0c 01 00 00 00 movl $0x1,0xc(%eax) <== NOT EXECUTED *link = child; 105a9d: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED } 105aa0: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RBTree_Insert_color( (RBTree_Control *) root, node ); 105aa2: 89 74 24 04 mov %esi,0x4(%esp) 105aa6: 8b 45 e4 mov -0x1c(%ebp),%eax 105aa9: 89 04 24 mov %eax,(%esp) 105aac: e8 9f fd 00 00 call 115850 <_RBTree_Insert_color> if (this) { 105ab1: e9 fc fe ff ff jmp 1059b2 if (this->node) 105ab6: 8b 43 10 mov 0x10(%ebx),%eax 105ab9: 85 c0 test %eax,%eax 105abb: 74 06 je 105ac3 <== NEVER TAKEN mark_ref_normal(this->node->raw); 105abd: 8b 00 mov (%eax),%eax 105abf: 83 48 04 03 orl $0x3,0x4(%eax) mark_ref_normal(newfrag->node->raw); 105ac3: 8b 45 10 mov 0x10(%ebp),%eax 105ac6: 8b 00 mov (%eax),%eax 105ac8: 83 48 04 03 orl $0x3,0x4(%eax) 105acc: e9 d7 fe ff ff jmp 1059a8 105ad1: 89 55 e0 mov %edx,-0x20(%ebp) newfrag = jffs2_alloc_node_frag(); 105ad4: e8 e7 f7 ff ff call 1052c0 if (likely(newfrag)) { 105ad9: 85 c0 test %eax,%eax newfrag = jffs2_alloc_node_frag(); 105adb: 89 c3 mov %eax,%ebx if (likely(newfrag)) { 105add: 74 39 je 105b18 <== NEVER TAKEN RB_SET( child, parent, Node ); 105adf: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) newfrag->size = size; 105ae6: 8b 55 e0 mov -0x20(%ebp),%edx rb_link_node(&holefrag->rb, NULL, &root->rb_node); 105ae9: 89 c6 mov %eax,%esi newfrag->ofs = ofs; 105aeb: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) newfrag->node = fn; 105af2: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) 105af9: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) newfrag->size = size; 105b00: 89 50 14 mov %edx,0x14(%eax) 105b03: c7 00 00 00 00 00 movl $0x0,(%eax) 105b09: c7 40 0c 01 00 00 00 movl $0x1,0xc(%eax) *link = child; 105b10: 8b 45 0c mov 0xc(%ebp),%eax 105b13: 89 58 04 mov %ebx,0x4(%eax) } 105b16: eb 8a jmp 105aa2 JFFS2_ERROR("cannot allocate a jffs2_node_frag object\n"); 105b18: c7 04 24 74 eb 12 00 movl $0x12eb74,(%esp) <== NOT EXECUTED 105b1f: bb fc ec 12 00 mov $0x12ecfc,%ebx <== NOT EXECUTED 105b24: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED 105b28: e8 53 f8 ff ff call 105380 <== NOT EXECUTED jffs2_free_node_frag(newfrag); 105b2d: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 105b30: e8 ab f7 ff ff call 1052e0 <== NOT EXECUTED return -ENOMEM; 105b35: b8 f4 ff ff ff mov $0xfffffff4,%eax <== NOT EXECUTED 105b3a: e9 89 fb ff ff jmp 1056c8 <== NOT EXECUTED 105b3f: 90 nop =============================================================================== 00105bb0 : { 105bb0: 55 push %ebp 105bb1: 89 e5 mov %esp,%ebp 105bb3: 56 push %esi 105bb4: 8b 75 08 mov 0x8(%ebp),%esi 105bb7: 53 push %ebx 105bb8: 8b 5d 0c mov 0xc(%ebp),%ebx if (!new->ino) 105bbb: 8b 4b 0c mov 0xc(%ebx),%ecx 105bbe: 85 c9 test %ecx,%ecx 105bc0: 75 0c jne 105bce new->ino = ++c->highest_ino; 105bc2: 8b 46 04 mov 0x4(%esi),%eax 105bc5: 8d 48 01 lea 0x1(%eax),%ecx 105bc8: 89 4e 04 mov %ecx,0x4(%esi) 105bcb: 89 4b 0c mov %ecx,0xc(%ebx) prev = &c->inocache_list[new->ino % c->inocache_hashsize]; 105bce: 31 d2 xor %edx,%edx 105bd0: 89 c8 mov %ecx,%eax 105bd2: f7 b6 c0 00 00 00 divl 0xc0(%esi) 105bd8: 8b 86 c4 00 00 00 mov 0xc4(%esi),%eax 105bde: 8d 14 90 lea (%eax,%edx,4),%edx while ((*prev) && (*prev)->ino < new->ino) { 105be1: 8b 02 mov (%edx),%eax 105be3: 85 c0 test %eax,%eax 105be5: 75 13 jne 105bfa <== NEVER TAKEN 105be7: eb 16 jmp 105bff 105be9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi prev = &(*prev)->next; 105bf0: 8d 50 10 lea 0x10(%eax),%edx <== NOT EXECUTED while ((*prev) && (*prev)->ino < new->ino) { 105bf3: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 105bf6: 85 c0 test %eax,%eax <== NOT EXECUTED 105bf8: 74 05 je 105bff <== NOT EXECUTED 105bfa: 39 48 0c cmp %ecx,0xc(%eax) <== NOT EXECUTED 105bfd: 72 f1 jb 105bf0 <== NOT EXECUTED new->next = *prev; 105bff: 89 43 10 mov %eax,0x10(%ebx) *prev = new; 105c02: 89 1a mov %ebx,(%edx) } 105c04: 5b pop %ebx 105c05: 5e pop %esi 105c06: 5d pop %ebp 105c07: c3 ret 105c08: 90 nop 105c09: 90 nop 105c0a: 90 nop 105c0b: 90 nop 105c0c: 90 nop 105c0d: 90 nop 105c0e: 90 nop 105c0f: 90 nop =============================================================================== 00106240 : */ struct jffs2_raw_node_ref *jffs2_add_physical_node_ref(struct jffs2_sb_info *c, uint32_t ofs, uint32_t len, struct jffs2_inode_cache *ic) { 106240: 55 push %ebp struct jffs2_eraseblock *jeb; struct jffs2_raw_node_ref *new; jeb = &c->blocks[ofs / c->sector_size]; 106241: 31 d2 xor %edx,%edx { 106243: 89 e5 mov %esp,%ebp 106245: 83 ec 48 sub $0x48,%esp 106248: 89 5d f4 mov %ebx,-0xc(%ebp) 10624b: 8b 5d 08 mov 0x8(%ebp),%ebx 10624e: 89 7d fc mov %edi,-0x4(%ebp) 106251: 8b 4d 0c mov 0xc(%ebp),%ecx 106254: 89 75 f8 mov %esi,-0x8(%ebp) jeb = &c->blocks[ofs / c->sector_size]; 106257: 8b 7b 34 mov 0x34(%ebx),%edi 10625a: 89 c8 mov %ecx,%eax 10625c: f7 f7 div %edi 10625e: 8d 14 40 lea (%eax,%eax,2),%edx 106261: 8d 14 90 lea (%eax,%edx,4),%edx 106264: 8b 43 54 mov 0x54(%ebx),%eax 106267: 8d 34 90 lea (%eax,%edx,4),%esi __func__, ofs & ~3, ofs & 3, len); #if 1 /* Allow non-obsolete nodes only to be added at the end of c->nextblock, if c->nextblock is set. Note that wbuf.c will file obsolete nodes even after refiling c->nextblock */ if ((c->nextblock || ((ofs & 3) != REF_OBSOLETE)) 10626a: 8b 53 58 mov 0x58(%ebx),%edx 10626d: 85 d2 test %edx,%edx 10626f: 74 7f je 1062f0 <== NEVER TAKEN && (jeb != c->nextblock || (ofs & ~3) != jeb->offset + (c->sector_size - jeb->free_size))) { 106271: 89 c8 mov %ecx,%eax 106273: 83 e0 fc and $0xfffffffc,%eax 106276: 39 f2 cmp %esi,%edx 106278: 75 0e jne 106288 <== NEVER TAKEN 10627a: 8b 56 0c mov 0xc(%esi),%edx 10627d: 01 d7 add %edx,%edi 10627f: 8b 56 20 mov 0x20(%esi),%edx 106282: 29 d7 sub %edx,%edi 106284: 39 c7 cmp %eax,%edi 106286: 74 74 je 1062fc <== ALWAYS TAKEN pr_warn("argh. node added in wrong place at 0x%08x(%d)\n", 106288: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10628c: 83 e1 03 and $0x3,%ecx <== NOT EXECUTED 10628f: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED 106293: c7 04 24 0c ed 12 00 movl $0x12ed0c,(%esp) <== NOT EXECUTED 10629a: e8 81 ff ff ff call 106220 <== NOT EXECUTED ofs & ~3, ofs & 3); if (c->nextblock) 10629f: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED 1062a2: 85 c0 test %eax,%eax <== NOT EXECUTED 1062a4: 0f 84 c6 00 00 00 je 106370 <== NOT EXECUTED pr_warn("nextblock 0x%08x", c->nextblock->offset); 1062aa: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 1062ad: c7 04 24 45 ed 12 00 movl $0x12ed45,(%esp) <== NOT EXECUTED 1062b4: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 1062b8: e8 63 ff ff ff call 106220 <== NOT EXECUTED else pr_warn("No nextblock"); pr_cont(", expected at %08x\n", 1062bd: 8b 43 34 mov 0x34(%ebx),%eax <== NOT EXECUTED 1062c0: 8b 5e 0c mov 0xc(%esi),%ebx <== NOT EXECUTED 1062c3: 8b 7e 20 mov 0x20(%esi),%edi <== NOT EXECUTED 1062c6: c7 04 24 77 ed 12 00 movl $0x12ed77,(%esp) <== NOT EXECUTED 1062cd: 01 d8 add %ebx,%eax <== NOT EXECUTED 1062cf: 29 f8 sub %edi,%eax <== NOT EXECUTED 1062d1: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 1062d5: e8 46 ff ff ff call 106220 <== NOT EXECUTED jffs2_dbg_acct_paranoia_check_nolock(c, jeb); spin_unlock(&c->erase_completion_lock); return new; } 1062da: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED return ERR_PTR(-EINVAL); 1062dd: b8 ea ff ff ff mov $0xffffffea,%eax <== NOT EXECUTED } 1062e2: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED 1062e5: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 1062e8: 89 ec mov %ebp,%esp <== NOT EXECUTED 1062ea: 5d pop %ebp <== NOT EXECUTED 1062eb: c3 ret <== NOT EXECUTED 1062ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED if ((c->nextblock || ((ofs & 3) != REF_OBSOLETE)) 1062f0: 89 c8 mov %ecx,%eax <== NOT EXECUTED 1062f2: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 1062f5: 48 dec %eax <== NOT EXECUTED 1062f6: 0f 85 75 ff ff ff jne 106271 <== NOT EXECUTED new = jffs2_link_node_ref(c, jeb, ofs, len, ic); 1062fc: 89 4c 24 08 mov %ecx,0x8(%esp) 106300: 8b 45 14 mov 0x14(%ebp),%eax 106303: 89 74 24 04 mov %esi,0x4(%esp) 106307: 89 1c 24 mov %ebx,(%esp) 10630a: 89 44 24 10 mov %eax,0x10(%esp) 10630e: 8b 45 10 mov 0x10(%ebp),%eax 106311: 89 44 24 0c mov %eax,0xc(%esp) 106315: e8 46 fb ff ff call 105e60 if (!jeb->free_size && !jeb->dirty_size && !ISDIRTY(jeb->wasted_size)) { 10631a: 8b 4e 20 mov 0x20(%esi),%ecx 10631d: 85 c9 test %ecx,%ecx 10631f: 75 27 jne 106348 106321: 8b 56 18 mov 0x18(%esi),%edx 106324: 85 d2 test %edx,%edx 106326: 75 20 jne 106348 <== NEVER TAKEN 106328: 81 7e 1c c4 00 00 00 cmpl $0xc4,0x1c(%esi) 10632f: 77 17 ja 106348 struct list_head *prev = beforethisent->prev; 106331: 8b 53 64 mov 0x64(%ebx),%edx list_add_tail(&jeb->list, &c->clean_list); 106334: 8d 4b 60 lea 0x60(%ebx),%ecx 106337: 89 0e mov %ecx,(%esi) newent->prev = prev; 106339: 89 56 04 mov %edx,0x4(%esi) beforethisent->prev = newent; 10633c: 89 73 64 mov %esi,0x64(%ebx) prev->next = newent; 10633f: 89 32 mov %esi,(%edx) c->nextblock = NULL; 106341: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) jffs2_dbg_acct_sanity_check_nolock(c,jeb); 106348: 89 74 24 04 mov %esi,0x4(%esp) 10634c: 89 1c 24 mov %ebx,(%esp) 10634f: 89 45 e4 mov %eax,-0x1c(%ebp) 106352: e8 09 4e 00 00 call 10b160 <__jffs2_dbg_acct_sanity_check_nolock> 106357: 8b 45 e4 mov -0x1c(%ebp),%eax } 10635a: 8b 5d f4 mov -0xc(%ebp),%ebx 10635d: 8b 75 f8 mov -0x8(%ebp),%esi 106360: 8b 7d fc mov -0x4(%ebp),%edi 106363: 89 ec mov %ebp,%esp 106365: 5d pop %ebp 106366: c3 ret 106367: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10636e: 66 90 xchg %ax,%ax pr_warn("No nextblock"); 106370: c7 04 24 60 ed 12 00 movl $0x12ed60,(%esp) <== NOT EXECUTED 106377: e8 a4 fe ff ff call 106220 <== NOT EXECUTED 10637c: e9 3c ff ff ff jmp 1062bd <== NOT EXECUTED 106381: 90 nop 106382: 90 nop 106383: 90 nop 106384: 90 nop 106385: 90 nop 106386: 90 nop 106387: 90 nop 106388: 90 nop 106389: 90 nop 10638a: 90 nop 10638b: 90 nop 10638c: 90 nop 10638d: 90 nop 10638e: 90 nop 10638f: 90 nop =============================================================================== 00106390 : void jffs2_complete_reservation(struct jffs2_sb_info *c) { 106390: 55 push %ebp 106391: 89 e5 mov %esp,%ebp rtems_jffs2_flash_control *fc = sb->s_flash_control; 106393: 8b 45 08 mov 0x8(%ebp),%eax 106396: 8b 90 e4 00 00 00 mov 0xe4(%eax),%edx if (fc->trigger_garbage_collection != NULL) { 10639c: 8b 42 20 mov 0x20(%edx),%eax 10639f: 85 c0 test %eax,%eax 1063a1: 74 0d je 1063b0 <== ALWAYS TAKEN (*fc->trigger_garbage_collection)(fc); 1063a3: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED jffs2_dbg(1, "jffs2_complete_reservation()\n"); spin_lock(&c->erase_completion_lock); jffs2_garbage_collect_trigger(c); spin_unlock(&c->erase_completion_lock); mutex_unlock(&c->alloc_sem); } 1063a6: 5d pop %ebp <== NOT EXECUTED 1063a7: ff e0 jmp *%eax <== NOT EXECUTED 1063a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 1063b0: 5d pop %ebp 1063b1: c3 ret 1063b2: 90 nop 1063b3: 90 nop 1063b4: 90 nop 1063b5: 90 nop 1063b6: 90 nop 1063b7: 90 nop 1063b8: 90 nop 1063b9: 90 nop 1063ba: 90 nop 1063bb: 90 nop 1063bc: 90 nop 1063bd: 90 nop 1063be: 90 nop 1063bf: 90 nop =============================================================================== 0010aee0 : * *datalen accordingly to show the amount of data which were compressed. */ uint16_t jffs2_compress(struct jffs2_sb_info *c, struct jffs2_inode_info *f, unsigned char *data_in, unsigned char **cpage_out, uint32_t *datalen, uint32_t *cdatalen) { 10aee0: 55 push %ebp 10aee1: 89 e5 mov %esp,%ebp 10aee3: 83 ec 38 sub $0x38,%esp 10aee6: 89 5d f4 mov %ebx,-0xc(%ebp) struct super_block *sb = OFNI_BS_2SFFJ(c); rtems_jffs2_compressor_control *cc = sb->s_compressor_control; 10aee9: 8b 45 08 mov 0x8(%ebp),%eax { 10aeec: 89 75 f8 mov %esi,-0x8(%ebp) 10aeef: 8b 5d 18 mov 0x18(%ebp),%ebx 10aef2: 89 7d fc mov %edi,-0x4(%ebp) 10aef5: 8b 75 1c mov 0x1c(%ebp),%esi 10aef8: 8b 7d 14 mov 0x14(%ebp),%edi rtems_jffs2_compressor_control *cc = sb->s_compressor_control; 10aefb: 8b 80 e8 00 00 00 mov 0xe8(%eax),%eax int ret; if (cc != NULL) { 10af01: 85 c0 test %eax,%eax 10af03: 74 24 je 10af29 <== NEVER TAKEN *cpage_out = &cc->buffer[0]; ret = (*cc->compress)(cc, data_in, *cpage_out, datalen, cdatalen); 10af05: 8b 4d 10 mov 0x10(%ebp),%ecx *cpage_out = &cc->buffer[0]; 10af08: 8d 50 0c lea 0xc(%eax),%edx 10af0b: 89 17 mov %edx,(%edi) ret = (*cc->compress)(cc, data_in, *cpage_out, datalen, cdatalen); 10af0d: 89 74 24 10 mov %esi,0x10(%esp) 10af11: 89 5c 24 0c mov %ebx,0xc(%esp) 10af15: 89 54 24 08 mov %edx,0x8(%esp) 10af19: 89 4c 24 04 mov %ecx,0x4(%esp) 10af1d: 89 04 24 mov %eax,(%esp) 10af20: ff 10 call *(%eax) 10af22: 0f b7 c0 movzwl %ax,%eax } else { ret = JFFS2_COMPR_NONE; } if (ret == JFFS2_COMPR_NONE) { 10af25: 85 c0 test %eax,%eax 10af27: 75 0b jne 10af34 *cpage_out = data_in; 10af29: 8b 45 10 mov 0x10(%ebp),%eax 10af2c: 89 07 mov %eax,(%edi) *datalen = *cdatalen; 10af2e: 8b 06 mov (%esi),%eax 10af30: 89 03 mov %eax,(%ebx) 10af32: 31 c0 xor %eax,%eax } return ret; } 10af34: 8b 5d f4 mov -0xc(%ebp),%ebx 10af37: 8b 75 f8 mov -0x8(%ebp),%esi 10af3a: 8b 7d fc mov -0x4(%ebp),%edi 10af3d: 89 ec mov %ebp,%esp 10af3f: 5d pop %ebp 10af40: c3 ret 10af41: 90 nop 10af42: 90 nop 10af43: 90 nop 10af44: 90 nop 10af45: 90 nop 10af46: 90 nop 10af47: 90 nop 10af48: 90 nop 10af49: 90 nop 10af4a: 90 nop 10af4b: 90 nop 10af4c: 90 nop 10af4d: 90 nop 10af4e: 90 nop 10af4f: 90 nop =============================================================================== 0010b420 : /***********************************************************************/ int jffs2_create(struct _inode *dir_i, const char *d_name, size_t d_namelen, int mode) { 10b420: 55 push %ebp 10b421: 89 e5 mov %esp,%ebp 10b423: 83 ec 58 sub $0x58,%esp 10b426: 89 75 f8 mov %esi,-0x8(%ebp) struct jffs2_sb_info *c; struct _inode *inode; int ret; struct qstr qstr; qstr.name = d_name; 10b429: 8b 45 0c mov 0xc(%ebp),%eax { 10b42c: 89 5d f4 mov %ebx,-0xc(%ebp) 10b42f: 8b 75 08 mov 0x8(%ebp),%esi 10b432: 89 7d fc mov %edi,-0x4(%ebp) qstr.name = d_name; 10b435: 89 45 e0 mov %eax,-0x20(%ebp) qstr.len = d_namelen; 10b438: 8b 45 10 mov 0x10(%ebp),%eax 10b43b: 89 45 e4 mov %eax,-0x1c(%ebp) ri = jffs2_alloc_raw_inode(); 10b43e: e8 5d 9d ff ff call 1051a0 if (!ri) 10b443: 85 c0 test %eax,%eax 10b445: 0f 84 de 00 00 00 je 10b529 <== NEVER TAKEN 10b44b: 89 c3 mov %eax,%ebx return -ENOMEM; c = JFFS2_SB_INFO(dir_i->i_sb); 10b44d: 8b 46 3c mov 0x3c(%esi),%eax D1(printk(KERN_DEBUG "jffs2_create()\n")); inode = jffs2_new_inode(dir_i, mode, ri); 10b450: 89 5c 24 08 mov %ebx,0x8(%esp) 10b454: 89 34 24 mov %esi,(%esp) c = JFFS2_SB_INFO(dir_i->i_sb); 10b457: 89 45 d4 mov %eax,-0x2c(%ebp) inode = jffs2_new_inode(dir_i, mode, ri); 10b45a: 8b 45 14 mov 0x14(%ebp),%eax 10b45d: 89 44 24 04 mov %eax,0x4(%esp) 10b461: e8 6a 7f ff ff call 1033d0 if (IS_ERR(inode)) { 10b466: 3d 18 fc ff ff cmp $0xfffffc18,%eax inode = jffs2_new_inode(dir_i, mode, ri); 10b46b: 89 c7 mov %eax,%edi if (IS_ERR(inode)) { 10b46d: 0f 87 9d 00 00 00 ja 10b510 <== NEVER TAKEN } f = JFFS2_INODE_INFO(inode); dir_f = JFFS2_INODE_INFO(dir_i); ret = jffs2_do_create(c, dir_f, f, ri, &qstr); 10b473: 89 5c 24 0c mov %ebx,0xc(%esp) 10b477: 8d 45 e0 lea -0x20(%ebp),%eax 10b47a: 89 44 24 10 mov %eax,0x10(%esp) f = JFFS2_INODE_INFO(inode); 10b47e: 8d 47 44 lea 0x44(%edi),%eax 10b481: 89 44 24 08 mov %eax,0x8(%esp) dir_f = JFFS2_INODE_INFO(dir_i); 10b485: 8d 46 44 lea 0x44(%esi),%eax 10b488: 89 44 24 04 mov %eax,0x4(%esp) ret = jffs2_do_create(c, dir_f, f, ri, &qstr); 10b48c: 8b 45 d4 mov -0x2c(%ebp),%eax 10b48f: 89 04 24 mov %eax,(%esp) 10b492: e8 49 ed ff ff call 10a1e0 if (ret) { 10b497: 89 45 d4 mov %eax,-0x2c(%ebp) 10b49a: 85 c0 test %eax,%eax 10b49c: 75 42 jne 10b4e0 <== NEVER TAKEN jffs2_iput(inode); jffs2_free_raw_inode(ri); return ret; } dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(ri->ctime)); 10b49e: 8b 43 28 mov 0x28(%ebx),%eax 10b4a1: 31 d2 xor %edx,%edx 10b4a3: 89 56 28 mov %edx,0x28(%esi) 10b4a6: 89 56 20 mov %edx,0x20(%esi) 10b4a9: 89 46 24 mov %eax,0x24(%esi) 10b4ac: 89 46 1c mov %eax,0x1c(%esi) jffs2_free_raw_inode(ri); 10b4af: 89 1c 24 mov %ebx,(%esp) 10b4b2: e8 09 9d ff ff call 1051c0 D1(printk(KERN_DEBUG "jffs2_create: Created ino #%lu with mode %o, nlink %d(%d)\n", inode->i_ino, inode->i_mode, inode->i_nlink, f->inocache->pino_nlink)); jffs2_iput(inode); 10b4b7: 89 3c 24 mov %edi,(%esp) 10b4ba: e8 41 77 ff ff call 102c00 return 0; 10b4bf: 8b 4d d4 mov -0x2c(%ebp),%ecx } 10b4c2: 8b 5d f4 mov -0xc(%ebp),%ebx 10b4c5: 89 c8 mov %ecx,%eax 10b4c7: 8b 75 f8 mov -0x8(%ebp),%esi 10b4ca: 8b 7d fc mov -0x4(%ebp),%edi 10b4cd: 89 ec mov %ebp,%esp 10b4cf: 5d pop %ebp 10b4d0: c3 ret 10b4d1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10b4d8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10b4df: 90 nop inode->i_nlink = 0; 10b4e0: 66 c7 47 0c 00 00 movw $0x0,0xc(%edi) <== NOT EXECUTED jffs2_iput(inode); 10b4e6: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10b4e9: e8 12 77 ff ff call 102c00 <== NOT EXECUTED jffs2_free_raw_inode(ri); 10b4ee: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10b4f1: e8 ca 9c ff ff call 1051c0 <== NOT EXECUTED return ret; 10b4f6: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED } 10b4f9: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED 10b4fc: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED 10b4ff: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 10b502: 89 ec mov %ebp,%esp <== NOT EXECUTED 10b504: 5d pop %ebp <== NOT EXECUTED 10b505: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b507: c3 ret <== NOT EXECUTED 10b508: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10b50f: 90 nop <== NOT EXECUTED jffs2_free_raw_inode(ri); 10b510: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10b513: e8 a8 9c ff ff call 1051c0 <== NOT EXECUTED } 10b518: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED return PTR_ERR(inode); 10b51b: 89 f9 mov %edi,%ecx <== NOT EXECUTED } 10b51d: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED 10b520: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b522: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 10b525: 89 ec mov %ebp,%esp <== NOT EXECUTED 10b527: 5d pop %ebp <== NOT EXECUTED 10b528: c3 ret <== NOT EXECUTED return -ENOMEM; 10b529: b9 f4 ff ff ff mov $0xfffffff4,%ecx <== NOT EXECUTED 10b52e: eb 92 jmp 10b4c2 <== NOT EXECUTED =============================================================================== 0010af50 : int jffs2_decompress(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint16_t comprtype, unsigned char *cdata_in, unsigned char *data_out, uint32_t cdatalen, uint32_t datalen) { 10af50: 55 push %ebp 10af51: 89 e5 mov %esp,%ebp 10af53: 83 ec 28 sub $0x28,%esp 10af56: 8b 45 1c mov 0x1c(%ebp),%eax 10af59: 89 5d f4 mov %ebx,-0xc(%ebp) 10af5c: 8b 4d 20 mov 0x20(%ebp),%ecx 10af5f: 89 75 f8 mov %esi,-0x8(%ebp) 10af62: 8b 5d 08 mov 0x8(%ebp),%ebx 10af65: 89 7d fc mov %edi,-0x4(%ebp) 10af68: 8b 75 14 mov 0x14(%ebp),%esi 10af6b: 89 45 e4 mov %eax,-0x1c(%ebp) 10af6e: 0f b6 45 10 movzbl 0x10(%ebp),%eax 10af72: 8b 7d 18 mov 0x18(%ebp),%edi 10af75: 0f b7 55 10 movzwl 0x10(%ebp),%edx struct super_block *sb = OFNI_BS_2SFFJ(c); rtems_jffs2_compressor_control *cc = sb->s_compressor_control; /* Older code had a bug where it would write non-zero 'usercompr' fields. Deal with it. */ if ((comprtype & 0xff) <= JFFS2_COMPR_ZLIB) 10af79: 83 f8 06 cmp $0x6,%eax 10af7c: 76 42 jbe 10afc0 <== ALWAYS TAKEN rtems_jffs2_compressor_control *cc = sb->s_compressor_control; 10af7e: 8b 83 e8 00 00 00 mov 0xe8(%ebx),%eax break; case JFFS2_COMPR_ZERO: memset(data_out, 0, datalen); break; default: if (cc != NULL) { 10af84: 85 c0 test %eax,%eax 10af86: 0f 84 23 01 00 00 je 10b0af <== NEVER TAKEN return (*cc->decompress)(cc, comprtype, cdata_in, data_out, cdatalen, datalen); 10af8c: 89 7d 14 mov %edi,0x14(%ebp) 10af8f: 8b 5d e4 mov -0x1c(%ebp),%ebx 10af92: 89 75 10 mov %esi,0x10(%ebp) } else { return -EIO; } } return 0; } 10af95: 8b 7d fc mov -0x4(%ebp),%edi return (*cc->decompress)(cc, comprtype, cdata_in, data_out, cdatalen, datalen); 10af98: 89 4d 1c mov %ecx,0x1c(%ebp) } 10af9b: 8b 75 f8 mov -0x8(%ebp),%esi return (*cc->decompress)(cc, comprtype, cdata_in, data_out, cdatalen, datalen); 10af9e: 89 55 0c mov %edx,0xc(%ebp) 10afa1: 89 5d 18 mov %ebx,0x18(%ebp) } 10afa4: 8b 5d f4 mov -0xc(%ebp),%ebx return (*cc->decompress)(cc, comprtype, cdata_in, data_out, cdatalen, datalen); 10afa7: 89 45 08 mov %eax,0x8(%ebp) 10afaa: 8b 40 04 mov 0x4(%eax),%eax } 10afad: 89 ec mov %ebp,%esp 10afaf: 5d pop %ebp return (*cc->decompress)(cc, comprtype, cdata_in, data_out, cdatalen, datalen); 10afb0: ff e0 jmp *%eax 10afb2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10afb9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi switch (comprtype & 0xff) { 10afc0: 85 c0 test %eax,%eax 10afc2: 75 1c jne 10afe0 <== ALWAYS TAKEN memcpy(data_out, cdata_in, datalen); 10afc4: 83 f9 08 cmp $0x8,%ecx <== NOT EXECUTED 10afc7: 0f 83 b3 00 00 00 jae 10b080 <== NOT EXECUTED 10afcd: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED return 0; 10afcf: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10afd1: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED 10afd4: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED 10afd7: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 10afda: 89 ec mov %ebp,%esp <== NOT EXECUTED 10afdc: 5d pop %ebp <== NOT EXECUTED 10afdd: c3 ret <== NOT EXECUTED 10afde: 66 90 xchg %ax,%ax <== NOT EXECUTED switch (comprtype & 0xff) { 10afe0: 83 f8 01 cmp $0x1,%eax 10afe3: 0f 85 41 01 00 00 jne 10b12a <== ALWAYS TAKEN memset(data_out, 0, datalen); 10afe9: 83 f9 08 cmp $0x8,%ecx <== NOT EXECUTED 10afec: 89 ca mov %ecx,%edx <== NOT EXECUTED 10afee: 73 50 jae 10b040 <== NOT EXECUTED 10aff0: f6 c2 04 test $0x4,%dl <== NOT EXECUTED 10aff3: 75 3b jne 10b030 <== NOT EXECUTED 10aff5: f6 c2 02 test $0x2,%dl <== NOT EXECUTED 10aff8: 75 26 jne 10b020 <== NOT EXECUTED 10affa: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 10affd: 75 11 jne 10b010 <== NOT EXECUTED return 0; 10afff: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10b001: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED 10b004: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED 10b007: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 10b00a: 89 ec mov %ebp,%esp <== NOT EXECUTED 10b00c: 5d pop %ebp <== NOT EXECUTED 10b00d: c3 ret <== NOT EXECUTED 10b00e: 66 90 xchg %ax,%ax <== NOT EXECUTED memset(data_out, 0, datalen); 10b010: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED return 0; 10b013: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b015: eb ea jmp 10b001 <== NOT EXECUTED 10b017: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10b01e: 66 90 xchg %ax,%ax <== NOT EXECUTED memset(data_out, 0, datalen); 10b020: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED 10b025: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 10b028: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 10b02b: 74 d2 je 10afff <== NOT EXECUTED 10b02d: eb e1 jmp 10b010 <== NOT EXECUTED 10b02f: 90 nop <== NOT EXECUTED 10b030: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED 10b036: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 10b039: f6 c2 02 test $0x2,%dl <== NOT EXECUTED 10b03c: 74 bc je 10affa <== NOT EXECUTED 10b03e: eb e0 jmp 10b020 <== NOT EXECUTED 10b040: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED 10b046: 0f 85 d4 00 00 00 jne 10b120 <== NOT EXECUTED 10b04c: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED 10b052: 0f 85 b8 00 00 00 jne 10b110 <== NOT EXECUTED 10b058: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED 10b05e: 0f 85 8c 00 00 00 jne 10b0f0 <== NOT EXECUTED 10b064: 89 d1 mov %edx,%ecx <== NOT EXECUTED 10b066: 83 e2 03 and $0x3,%edx <== NOT EXECUTED 10b069: c1 e9 02 shr $0x2,%ecx <== NOT EXECUTED 10b06c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b06e: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED 10b070: f6 c2 04 test $0x4,%dl <== NOT EXECUTED 10b073: 74 80 je 10aff5 <== NOT EXECUTED 10b075: eb b9 jmp 10b030 <== NOT EXECUTED 10b077: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10b07e: 66 90 xchg %ax,%ax <== NOT EXECUTED memcpy(data_out, cdata_in, datalen); 10b080: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED 10b086: 75 58 jne 10b0e0 <== NOT EXECUTED 10b088: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED 10b08e: 75 30 jne 10b0c0 <== NOT EXECUTED 10b090: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED 10b096: 0f 84 31 ff ff ff je 10afcd <== NOT EXECUTED 10b09c: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10b09e: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 10b0a1: 83 c6 04 add $0x4,%esi <== NOT EXECUTED 10b0a4: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED 10b0a7: 89 47 fc mov %eax,-0x4(%edi) <== NOT EXECUTED 10b0aa: e9 1e ff ff ff jmp 10afcd <== NOT EXECUTED return -EIO; 10b0af: b8 fb ff ff ff mov $0xfffffffb,%eax <== NOT EXECUTED 10b0b4: e9 18 ff ff ff jmp 10afd1 <== NOT EXECUTED 10b0b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED memcpy(data_out, cdata_in, datalen); 10b0c0: 0f b7 06 movzwl (%esi),%eax <== NOT EXECUTED 10b0c3: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 10b0c6: 83 c6 02 add $0x2,%esi <== NOT EXECUTED 10b0c9: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED 10b0cc: 66 89 47 fe mov %ax,-0x2(%edi) <== NOT EXECUTED 10b0d0: eb be jmp 10b090 <== NOT EXECUTED 10b0d2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10b0d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10b0e0: 0f b6 06 movzbl (%esi),%eax <== NOT EXECUTED 10b0e3: 47 inc %edi <== NOT EXECUTED 10b0e4: 46 inc %esi <== NOT EXECUTED 10b0e5: 49 dec %ecx <== NOT EXECUTED 10b0e6: 88 47 ff mov %al,-0x1(%edi) <== NOT EXECUTED 10b0e9: eb 9d jmp 10b088 <== NOT EXECUTED 10b0eb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10b0ef: 90 nop <== NOT EXECUTED memset(data_out, 0, datalen); 10b0f0: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED 10b0f6: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED 10b0f9: 83 c7 04 add $0x4,%edi <== NOT EXECUTED 10b0fc: e9 63 ff ff ff jmp 10b064 <== NOT EXECUTED 10b101: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10b108: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10b10f: 90 nop <== NOT EXECUTED 10b110: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED 10b115: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED 10b118: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 10b11b: e9 38 ff ff ff jmp 10b058 <== NOT EXECUTED 10b120: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED 10b123: 4a dec %edx <== NOT EXECUTED 10b124: 47 inc %edi <== NOT EXECUTED 10b125: e9 22 ff ff ff jmp 10b04c <== NOT EXECUTED switch (comprtype & 0xff) { 10b12a: 89 c2 mov %eax,%edx 10b12c: e9 4d fe ff ff jmp 10af7e 10b131: 90 nop 10b132: 90 nop 10b133: 90 nop 10b134: 90 nop 10b135: 90 nop 10b136: 90 nop 10b137: 90 nop 10b138: 90 nop 10b139: 90 nop 10b13a: 90 nop 10b13b: 90 nop 10b13c: 90 nop 10b13d: 90 nop 10b13e: 90 nop 10b13f: 90 nop =============================================================================== 00105c10 : { 105c10: 55 push %ebp prev = &c->inocache_list[old->ino % c->inocache_hashsize]; 105c11: 31 d2 xor %edx,%edx { 105c13: 89 e5 mov %esp,%ebp 105c15: 56 push %esi 105c16: 8b 75 08 mov 0x8(%ebp),%esi 105c19: 53 push %ebx 105c1a: 8b 5d 0c mov 0xc(%ebp),%ebx prev = &c->inocache_list[old->ino % c->inocache_hashsize]; 105c1d: 8b 4b 0c mov 0xc(%ebx),%ecx 105c20: 89 c8 mov %ecx,%eax 105c22: f7 b6 c0 00 00 00 divl 0xc0(%esi) 105c28: 8b 86 c4 00 00 00 mov 0xc4(%esi),%eax 105c2e: 8d 14 90 lea (%eax,%edx,4),%edx while ((*prev) && (*prev)->ino < old->ino) { 105c31: 8b 02 mov (%edx),%eax 105c33: 85 c0 test %eax,%eax 105c35: 75 13 jne 105c4a 105c37: eb 1f jmp 105c58 105c39: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi prev = &(*prev)->next; 105c40: 8d 50 10 lea 0x10(%eax),%edx <== NOT EXECUTED while ((*prev) && (*prev)->ino < old->ino) { 105c43: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 105c46: 85 c0 test %eax,%eax <== NOT EXECUTED 105c48: 74 0e je 105c58 <== NOT EXECUTED 105c4a: 3b 48 0c cmp 0xc(%eax),%ecx 105c4d: 77 f1 ja 105c40 <== NEVER TAKEN if ((*prev) == old) { 105c4f: 39 c3 cmp %eax,%ebx 105c51: 75 05 jne 105c58 <== NEVER TAKEN *prev = old->next; 105c53: 8b 43 10 mov 0x10(%ebx),%eax 105c56: 89 02 mov %eax,(%edx) if (old->state != INO_STATE_READING && old->state != INO_STATE_CLEARING) 105c58: 0f b7 43 0a movzwl 0xa(%ebx),%eax 105c5c: 83 e8 05 sub $0x5,%eax 105c5f: 66 83 f8 01 cmp $0x1,%ax 105c63: 77 0b ja 105c70 } 105c65: 5b pop %ebx 105c66: 5e pop %esi 105c67: 5d pop %ebp 105c68: c3 ret 105c69: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi jffs2_free_inode_cache(old); 105c70: 89 5d 08 mov %ebx,0x8(%ebp) } 105c73: 5b pop %ebx 105c74: 5e pop %esi 105c75: 5d pop %ebp jffs2_free_inode_cache(old); 105c76: e9 95 f6 ff ff jmp 105310 105c7b: 90 nop 105c7c: 90 nop 105c7d: 90 nop 105c7e: 90 nop 105c7f: 90 nop =============================================================================== 00109410 : kfree (f); return ret; } void jffs2_do_clear_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f) { 109410: 55 push %ebp 109411: 89 e5 mov %esp,%ebp 109413: 57 push %edi 109414: 56 push %esi 109415: 53 push %ebx 109416: 83 ec 1c sub $0x1c,%esp 109419: 8b 75 0c mov 0xc(%ebp),%esi 10941c: 8b 7d 08 mov 0x8(%ebp),%edi struct jffs2_full_dirent *fd, *fds; int deleted; jffs2_xattr_delete_inode(c, f->inocache); mutex_lock(&f->sem); deleted = f->inocache && !f->inocache->pino_nlink; 10941f: 8b 46 14 mov 0x14(%esi),%eax 109422: 85 c0 test %eax,%eax 109424: 74 41 je 109467 <== NEVER TAKEN 109426: 8b 48 14 mov 0x14(%eax),%ecx if (f->inocache && f->inocache->state != INO_STATE_CHECKING) 109429: 0f b7 50 0a movzwl 0xa(%eax),%edx deleted = f->inocache && !f->inocache->pino_nlink; 10942d: 85 c9 test %ecx,%ecx 10942f: 75 2f jne 109460 if (f->inocache && f->inocache->state != INO_STATE_CHECKING) 109431: 4a dec %edx 109432: 0f 85 c8 00 00 00 jne 109500 <== ALWAYS TAKEN jffs2_set_inocache_state(c, f->inocache, INO_STATE_CLEARING); if (f->metadata) { 109438: 8b 46 08 mov 0x8(%esi),%eax 10943b: 85 c0 test %eax,%eax 10943d: 74 19 je 109458 if (deleted) jffs2_mark_node_obsolete(c, f->metadata->raw); 10943f: 8b 00 mov (%eax),%eax <== NOT EXECUTED 109441: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 109444: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 109448: e8 73 cf ff ff call 1063c0 <== NOT EXECUTED jffs2_free_full_dnode(f->metadata); 10944d: 8b 46 08 mov 0x8(%esi),%eax 109450: 89 04 24 mov %eax,(%esp) 109453: e8 08 bd ff ff call 105160 } jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL); 109458: 89 f8 mov %edi,%eax 10945a: eb 1c jmp 109478 10945c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi if (f->inocache && f->inocache->state != INO_STATE_CHECKING) 109460: 4a dec %edx 109461: 0f 85 b9 00 00 00 jne 109520 <== ALWAYS TAKEN if (f->metadata) { 109467: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10946a: 85 c0 test %eax,%eax <== NOT EXECUTED 10946c: 74 08 je 109476 <== NOT EXECUTED jffs2_free_full_dnode(f->metadata); 10946e: 89 04 24 mov %eax,(%esp) 109471: e8 ea bc ff ff call 105160 jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL); 109476: 31 c0 xor %eax,%eax 109478: 89 44 24 04 mov %eax,0x4(%esp) 10947c: 8d 46 04 lea 0x4(%esi),%eax 10947f: 89 04 24 mov %eax,(%esp) 109482: e8 59 c9 ff ff call 105de0 if (f->target) { 109487: 8b 46 10 mov 0x10(%esi),%eax 10948a: 85 c0 test %eax,%eax 10948c: 74 0f je 10949d kfree(f->target); 10948e: 89 04 24 mov %eax,(%esp) 109491: e8 9a 4c 00 00 call 10e130 f->target = NULL; 109496: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi) } fds = f->dents; 10949d: 8b 5e 0c mov 0xc(%esi),%ebx while(fds) { 1094a0: 85 db test %ebx,%ebx 1094a2: 74 1d je 1094c1 1094a4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1094ab: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 1094af: 90 nop fd = fds; fds = fd->next; 1094b0: 89 d8 mov %ebx,%eax 1094b2: 8b 5b 04 mov 0x4(%ebx),%ebx jffs2_free_full_dirent(fd); 1094b5: 89 04 24 mov %eax,(%esp) 1094b8: e8 73 bc ff ff call 105130 while(fds) { 1094bd: 85 db test %ebx,%ebx 1094bf: 75 ef jne 1094b0 } if (f->inocache && f->inocache->state != INO_STATE_CHECKING) { 1094c1: 8b 46 14 mov 0x14(%esi),%eax 1094c4: 85 c0 test %eax,%eax 1094c6: 74 24 je 1094ec <== NEVER TAKEN 1094c8: 66 83 78 0a 01 cmpw $0x1,0xa(%eax) 1094cd: 74 1d je 1094ec <== NEVER TAKEN jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT); 1094cf: 89 44 24 04 mov %eax,0x4(%esp) 1094d3: bb 03 00 00 00 mov $0x3,%ebx 1094d8: 89 5c 24 08 mov %ebx,0x8(%esp) 1094dc: 89 3c 24 mov %edi,(%esp) 1094df: e8 5c c6 ff ff call 105b40 if (f->inocache->nodes == (void *)f->inocache) 1094e4: 8b 46 14 mov 0x14(%esi),%eax 1094e7: 3b 40 04 cmp 0x4(%eax),%eax 1094ea: 74 59 je 109545 jffs2_del_ino_cache(c, f->inocache); } mutex_unlock(&f->sem); } 1094ec: 83 c4 1c add $0x1c,%esp 1094ef: 5b pop %ebx 1094f0: 5e pop %esi 1094f1: 5f pop %edi 1094f2: 5d pop %ebp 1094f3: c3 ret 1094f4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1094fb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 1094ff: 90 nop jffs2_set_inocache_state(c, f->inocache, INO_STATE_CLEARING); 109500: 89 44 24 04 mov %eax,0x4(%esp) 109504: b9 06 00 00 00 mov $0x6,%ecx 109509: 89 4c 24 08 mov %ecx,0x8(%esp) 10950d: 89 3c 24 mov %edi,(%esp) 109510: e8 2b c6 ff ff call 105b40 109515: e9 1e ff ff ff jmp 109438 10951a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 109520: 89 44 24 04 mov %eax,0x4(%esp) 109524: ba 06 00 00 00 mov $0x6,%edx 109529: 89 54 24 08 mov %edx,0x8(%esp) 10952d: 89 3c 24 mov %edi,(%esp) 109530: e8 0b c6 ff ff call 105b40 if (f->metadata) { 109535: 8b 46 08 mov 0x8(%esi),%eax 109538: 85 c0 test %eax,%eax 10953a: 0f 84 36 ff ff ff je 109476 109540: e9 29 ff ff ff jmp 10946e jffs2_del_ino_cache(c, f->inocache); 109545: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED 109548: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED } 10954b: 83 c4 1c add $0x1c,%esp <== NOT EXECUTED 10954e: 5b pop %ebx <== NOT EXECUTED 10954f: 5e pop %esi <== NOT EXECUTED 109550: 5f pop %edi <== NOT EXECUTED 109551: 5d pop %ebp <== NOT EXECUTED jffs2_del_ino_cache(c, f->inocache); 109552: e9 b9 c6 ff ff jmp 105c10 <== NOT EXECUTED 109557: 90 nop 109558: 90 nop 109559: 90 nop 10955a: 90 nop 10955b: 90 nop 10955c: 90 nop 10955d: 90 nop 10955e: 90 nop 10955f: 90 nop =============================================================================== 00109560 : { 109560: 55 push %ebp <== NOT EXECUTED struct jffs2_inode_info *f = kzalloc(sizeof(*f), GFP_KERNEL); 109561: b8 1c 00 00 00 mov $0x1c,%eax <== NOT EXECUTED { 109566: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109568: 57 push %edi <== NOT EXECUTED 109569: 53 push %ebx <== NOT EXECUTED 10956a: 83 ec 70 sub $0x70,%esp <== NOT EXECUTED struct jffs2_inode_info *f = kzalloc(sizeof(*f), GFP_KERNEL); 10956d: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED { 109571: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED struct jffs2_inode_info *f = kzalloc(sizeof(*f), GFP_KERNEL); 109574: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED 10957b: e8 d0 47 00 00 call 10dd50 <== NOT EXECUTED if (!f) 109580: 85 c0 test %eax,%eax <== NOT EXECUTED 109582: 74 35 je 1095b9 <== NOT EXECUTED ret = jffs2_do_read_inode_internal(c, f, &n); 109584: 8d 4d b4 lea -0x4c(%ebp),%ecx <== NOT EXECUTED 109587: 89 c3 mov %eax,%ebx <== NOT EXECUTED f->inocache = ic; 109589: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED ret = jffs2_do_read_inode_internal(c, f, &n); 10958c: 89 da mov %ebx,%edx <== NOT EXECUTED f->inocache = ic; 10958e: 89 43 14 mov %eax,0x14(%ebx) <== NOT EXECUTED ret = jffs2_do_read_inode_internal(c, f, &n); 109591: 89 f8 mov %edi,%eax <== NOT EXECUTED 109593: e8 88 e3 ff ff call 107920 <== NOT EXECUTED jffs2_do_clear_inode(c, f); 109598: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED 10959c: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED ret = jffs2_do_read_inode_internal(c, f, &n); 10959f: 89 45 a4 mov %eax,-0x5c(%ebp) <== NOT EXECUTED jffs2_do_clear_inode(c, f); 1095a2: e8 69 fe ff ff call 109410 <== NOT EXECUTED kfree (f); 1095a7: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1095aa: e8 81 4b 00 00 call 10e130 <== NOT EXECUTED return ret; 1095af: 8b 45 a4 mov -0x5c(%ebp),%eax <== NOT EXECUTED } 1095b2: 83 c4 70 add $0x70,%esp <== NOT EXECUTED 1095b5: 5b pop %ebx <== NOT EXECUTED 1095b6: 5f pop %edi <== NOT EXECUTED 1095b7: 5d pop %ebp <== NOT EXECUTED 1095b8: c3 ret <== NOT EXECUTED return -ENOMEM; 1095b9: b8 f4 ff ff ff mov $0xfffffff4,%eax <== NOT EXECUTED 1095be: eb f2 jmp 1095b2 <== NOT EXECUTED =============================================================================== 0010a1e0 : int jffs2_do_create(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, struct jffs2_inode_info *f, struct jffs2_raw_inode *ri, const struct qstr *qstr) { 10a1e0: 55 push %ebp int ret; /* Try to reserve enough space for both node and dirent. * Just the node will do for now, though */ ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL, 10a1e1: b8 12 00 00 00 mov $0x12,%eax { 10a1e6: 89 e5 mov %esp,%ebp ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL, 10a1e8: ba 44 00 00 00 mov $0x44,%edx { 10a1ed: 57 push %edi 10a1ee: 56 push %esi 10a1ef: 53 push %ebx ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL, 10a1f0: 8d 7d e4 lea -0x1c(%ebp),%edi { 10a1f3: 83 ec 4c sub $0x4c,%esp ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL, 10a1f6: 89 44 24 10 mov %eax,0x10(%esp) { 10a1fa: 8b 5d 08 mov 0x8(%ebp),%ebx ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL, 10a1fd: 31 c0 xor %eax,%eax 10a1ff: 89 54 24 04 mov %edx,0x4(%esp) { 10a203: 8b 75 14 mov 0x14(%ebp),%esi ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL, 10a206: 89 44 24 0c mov %eax,0xc(%esp) 10a20a: 89 7c 24 08 mov %edi,0x8(%esp) 10a20e: 89 1c 24 mov %ebx,(%esp) 10a211: e8 da c9 ff ff call 106bf0 JFFS2_SUMMARY_INODE_SIZE); jffs2_dbg(1, "%s(): reserved 0x%x bytes\n", __func__, alloclen); if (ret) 10a216: 85 c0 test %eax,%eax ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL, 10a218: 89 c2 mov %eax,%edx if (ret) 10a21a: 74 14 je 10a230 <== ALWAYS TAKEN jffs2_complete_reservation(c); mutex_unlock(&dir_f->sem); return 0; } 10a21c: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED 10a21f: 89 d0 mov %edx,%eax <== NOT EXECUTED 10a221: 5b pop %ebx <== NOT EXECUTED 10a222: 5e pop %esi <== NOT EXECUTED 10a223: 5f pop %edi <== NOT EXECUTED 10a224: 5d pop %ebp <== NOT EXECUTED 10a225: c3 ret <== NOT EXECUTED 10a226: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10a22d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ri->data_crc = cpu_to_je32(0); 10a230: c7 46 3c 00 00 00 00 movl $0x0,0x3c(%esi) ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8)); 10a237: b9 3c 00 00 00 mov $0x3c,%ecx 10a23c: 89 4c 24 08 mov %ecx,0x8(%esp) 10a240: 89 74 24 04 mov %esi,0x4(%esp) 10a244: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10a24b: e8 40 0c 00 00 call 10ae90 10a250: 89 46 40 mov %eax,0x40(%esi) fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL); 10a253: 31 c0 xor %eax,%eax 10a255: 89 44 24 14 mov %eax,0x14(%esp) 10a259: 31 c0 xor %eax,%eax 10a25b: 89 44 24 10 mov %eax,0x10(%esp) 10a25f: 31 c0 xor %eax,%eax 10a261: 89 44 24 0c mov %eax,0xc(%esp) 10a265: 8b 45 10 mov 0x10(%ebp),%eax 10a268: 89 74 24 08 mov %esi,0x8(%esp) 10a26c: 89 1c 24 mov %ebx,(%esp) 10a26f: 89 44 24 04 mov %eax,0x4(%esp) 10a273: e8 d8 f4 ff ff call 109750 if (IS_ERR(fn)) { 10a278: 3d 18 fc ff ff cmp $0xfffffc18,%eax 10a27d: 0f 87 7d 01 00 00 ja 10a400 <== NEVER TAKEN f->metadata = fn; 10a283: 8b 4d 10 mov 0x10(%ebp),%ecx 10a286: 89 41 08 mov %eax,0x8(%ecx) jffs2_complete_reservation(c); 10a289: 89 1c 24 mov %ebx,(%esp) 10a28c: e8 ff c0 ff ff call 106390 ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(qstr->len)); 10a291: 8b 45 18 mov 0x18(%ebp),%eax 10a294: 8b 40 04 mov 0x4(%eax),%eax ret = jffs2_reserve_space(c, sizeof(*rd)+qstr->len, &alloclen, 10a297: 89 7c 24 08 mov %edi,0x8(%esp) 10a29b: 89 1c 24 mov %ebx,(%esp) ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(qstr->len)); 10a29e: 8d 50 18 lea 0x18(%eax),%edx ret = jffs2_reserve_space(c, sizeof(*rd)+qstr->len, &alloclen, 10a2a1: 83 c0 28 add $0x28,%eax 10a2a4: 89 54 24 10 mov %edx,0x10(%esp) 10a2a8: 31 d2 xor %edx,%edx 10a2aa: 89 54 24 0c mov %edx,0xc(%esp) 10a2ae: 89 44 24 04 mov %eax,0x4(%esp) 10a2b2: e8 39 c9 ff ff call 106bf0 if (ret) { 10a2b7: 85 c0 test %eax,%eax ret = jffs2_reserve_space(c, sizeof(*rd)+qstr->len, &alloclen, 10a2b9: 89 c2 mov %eax,%edx if (ret) { 10a2bb: 0f 85 5b ff ff ff jne 10a21c <== NEVER TAKEN 10a2c1: 89 45 d4 mov %eax,-0x2c(%ebp) rd = jffs2_alloc_raw_dirent(); 10a2c4: e8 a7 ae ff ff call 105170 if (!rd) { 10a2c9: 8b 55 d4 mov -0x2c(%ebp),%edx 10a2cc: 85 c0 test %eax,%eax rd = jffs2_alloc_raw_dirent(); 10a2ce: 89 c7 mov %eax,%edi if (!rd) { 10a2d0: 0f 84 59 01 00 00 je 10a42f <== NEVER TAKEN rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 10a2d6: c7 00 85 19 01 e0 movl $0xe0011985,(%eax) rd->totlen = cpu_to_je32(sizeof(*rd) + qstr->len); 10a2dc: 8b 45 18 mov 0x18(%ebp),%eax 10a2df: 89 55 d0 mov %edx,-0x30(%ebp) 10a2e2: 8b 40 04 mov 0x4(%eax),%eax 10a2e5: 89 45 d4 mov %eax,-0x2c(%ebp) 10a2e8: 83 c0 28 add $0x28,%eax 10a2eb: 89 47 04 mov %eax,0x4(%edi) rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 10a2ee: b8 08 00 00 00 mov $0x8,%eax 10a2f3: 89 44 24 08 mov %eax,0x8(%esp) 10a2f7: 89 7c 24 04 mov %edi,0x4(%esp) 10a2fb: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10a302: e8 89 0b 00 00 call 10ae90 rd->version = cpu_to_je32(++dir_f->highest_version); 10a307: 8b 4d 0c mov 0xc(%ebp),%ecx rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 10a30a: ba 20 00 00 00 mov $0x20,%edx rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 10a30f: 89 47 08 mov %eax,0x8(%edi) rd->pino = cpu_to_je32(dir_f->inocache->ino); 10a312: 8b 45 0c mov 0xc(%ebp),%eax 10a315: 8b 40 14 mov 0x14(%eax),%eax 10a318: 8b 40 0c mov 0xc(%eax),%eax 10a31b: 89 47 0c mov %eax,0xc(%edi) rd->version = cpu_to_je32(++dir_f->highest_version); 10a31e: 8b 45 0c mov 0xc(%ebp),%eax 10a321: 8b 00 mov (%eax),%eax 10a323: 40 inc %eax 10a324: 89 01 mov %eax,(%ecx) 10a326: 89 47 10 mov %eax,0x10(%edi) rd->ino = ri->ino; 10a329: 8b 46 0c mov 0xc(%esi),%eax 10a32c: 89 47 14 mov %eax,0x14(%edi) rd->mctime = ri->ctime; 10a32f: 8b 46 28 mov 0x28(%esi),%eax 10a332: 89 47 18 mov %eax,0x18(%edi) rd->nsize = qstr->len; 10a335: 8b 45 18 mov 0x18(%ebp),%eax 10a338: 8b 40 04 mov 0x4(%eax),%eax rd->type = DT_REG; 10a33b: c6 47 1d 08 movb $0x8,0x1d(%edi) rd->nsize = qstr->len; 10a33f: 89 45 d4 mov %eax,-0x2c(%ebp) 10a342: 0f b6 45 d4 movzbl -0x2c(%ebp),%eax 10a346: 88 47 1c mov %al,0x1c(%edi) rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 10a349: 89 54 24 08 mov %edx,0x8(%esp) 10a34d: 89 7c 24 04 mov %edi,0x4(%esp) 10a351: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10a358: e8 33 0b 00 00 call 10ae90 10a35d: 89 47 20 mov %eax,0x20(%edi) rd->name_crc = cpu_to_je32(crc32(0, qstr->name, qstr->len)); 10a360: 8b 45 18 mov 0x18(%ebp),%eax 10a363: 8b 40 04 mov 0x4(%eax),%eax 10a366: 89 44 24 08 mov %eax,0x8(%esp) 10a36a: 8b 45 18 mov 0x18(%ebp),%eax 10a36d: 8b 00 mov (%eax),%eax 10a36f: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10a376: 89 44 24 04 mov %eax,0x4(%esp) 10a37a: e8 11 0b 00 00 call 10ae90 fd = jffs2_write_dirent(c, dir_f, rd, qstr->name, qstr->len, ALLOC_NORMAL); 10a37f: 31 c9 xor %ecx,%ecx rd->name_crc = cpu_to_je32(crc32(0, qstr->name, qstr->len)); 10a381: 89 47 24 mov %eax,0x24(%edi) fd = jffs2_write_dirent(c, dir_f, rd, qstr->name, qstr->len, ALLOC_NORMAL); 10a384: 8b 45 18 mov 0x18(%ebp),%eax 10a387: 89 4c 24 14 mov %ecx,0x14(%esp) 10a38b: 8b 40 04 mov 0x4(%eax),%eax 10a38e: 89 44 24 10 mov %eax,0x10(%esp) 10a392: 8b 45 18 mov 0x18(%ebp),%eax 10a395: 8b 00 mov (%eax),%eax 10a397: 89 7c 24 08 mov %edi,0x8(%esp) 10a39b: 89 1c 24 mov %ebx,(%esp) 10a39e: 89 44 24 0c mov %eax,0xc(%esp) 10a3a2: 8b 45 0c mov 0xc(%ebp),%eax 10a3a5: 89 44 24 04 mov %eax,0x4(%esp) 10a3a9: e8 42 f7 ff ff call 109af0 jffs2_free_raw_dirent(rd); 10a3ae: 89 3c 24 mov %edi,(%esp) fd = jffs2_write_dirent(c, dir_f, rd, qstr->name, qstr->len, ALLOC_NORMAL); 10a3b1: 89 c6 mov %eax,%esi jffs2_free_raw_dirent(rd); 10a3b3: e8 d8 ad ff ff call 105190 if (IS_ERR(fd)) { 10a3b8: 81 fe 18 fc ff ff cmp $0xfffffc18,%esi 10a3be: 8b 55 d0 mov -0x30(%ebp),%edx 10a3c1: 77 5d ja 10a420 <== NEVER TAKEN jffs2_add_fd_to_list(c, fd, &dir_f->dents); 10a3c3: 89 74 24 04 mov %esi,0x4(%esp) 10a3c7: 8b 45 0c mov 0xc(%ebp),%eax 10a3ca: 89 1c 24 mov %ebx,(%esp) 10a3cd: 89 55 d4 mov %edx,-0x2c(%ebp) 10a3d0: 83 c0 0c add $0xc,%eax 10a3d3: 89 44 24 08 mov %eax,0x8(%esp) 10a3d7: e8 74 b0 ff ff call 105450 jffs2_complete_reservation(c); 10a3dc: 89 1c 24 mov %ebx,(%esp) 10a3df: e8 ac bf ff ff call 106390 10a3e4: 8b 55 d4 mov -0x2c(%ebp),%edx } 10a3e7: 83 c4 4c add $0x4c,%esp 10a3ea: 5b pop %ebx 10a3eb: 5e pop %esi 10a3ec: 89 d0 mov %edx,%eax 10a3ee: 5f pop %edi 10a3ef: 5d pop %ebp 10a3f0: c3 ret 10a3f1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10a3f8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10a3ff: 90 nop jffs2_complete_reservation(c); 10a400: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a403: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED 10a406: e8 85 bf ff ff call 106390 <== NOT EXECUTED return PTR_ERR(fn); 10a40b: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED } 10a40e: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED 10a411: 5b pop %ebx <== NOT EXECUTED 10a412: 5e pop %esi <== NOT EXECUTED return PTR_ERR(fn); 10a413: 89 c2 mov %eax,%edx <== NOT EXECUTED } 10a415: 89 d0 mov %edx,%eax <== NOT EXECUTED 10a417: 5f pop %edi <== NOT EXECUTED 10a418: 5d pop %ebp <== NOT EXECUTED 10a419: c3 ret <== NOT EXECUTED 10a41a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED jffs2_complete_reservation(c); 10a420: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a423: e8 68 bf ff ff call 106390 <== NOT EXECUTED return PTR_ERR(fd); 10a428: 89 f2 mov %esi,%edx <== NOT EXECUTED 10a42a: e9 ed fd ff ff jmp 10a21c <== NOT EXECUTED jffs2_complete_reservation(c); 10a42f: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a432: e8 59 bf ff ff call 106390 <== NOT EXECUTED return -ENOMEM; 10a437: ba f4 ff ff ff mov $0xfffffff4,%edx <== NOT EXECUTED 10a43c: e9 db fd ff ff jmp 10a21c <== NOT EXECUTED 10a441: 90 nop 10a442: 90 nop 10a443: 90 nop 10a444: 90 nop 10a445: 90 nop 10a446: 90 nop 10a447: 90 nop 10a448: 90 nop 10a449: 90 nop 10a44a: 90 nop 10a44b: 90 nop 10a44c: 90 nop 10a44d: 90 nop 10a44e: 90 nop 10a44f: 90 nop =============================================================================== 0010a5c0 : int jffs2_do_link (struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, uint32_t ino, uint8_t type, const char *name, int namelen, uint32_t time) { 10a5c0: 55 push %ebp 10a5c1: 89 e5 mov %esp,%ebp 10a5c3: 57 push %edi 10a5c4: 56 push %esi 10a5c5: 53 push %ebx 10a5c6: 83 ec 4c sub $0x4c,%esp 10a5c9: 8b 45 14 mov 0x14(%ebp),%eax 10a5cc: 8b 7d 0c mov 0xc(%ebp),%edi 10a5cf: 8b 5d 1c mov 0x1c(%ebp),%ebx 10a5d2: 89 45 d0 mov %eax,-0x30(%ebp) struct jffs2_raw_dirent *rd; struct jffs2_full_dirent *fd; uint32_t alloclen; int ret; rd = jffs2_alloc_raw_dirent(); 10a5d5: e8 96 ab ff ff call 105170 if (!rd) 10a5da: 85 c0 test %eax,%eax 10a5dc: 0f 84 63 01 00 00 je 10a745 <== NEVER TAKEN return -ENOMEM; ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 10a5e2: 8d 4b 28 lea 0x28(%ebx),%ecx 10a5e5: 89 c6 mov %eax,%esi 10a5e7: 89 4c 24 04 mov %ecx,0x4(%esp) ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen)); 10a5eb: 8d 43 18 lea 0x18(%ebx),%eax ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen, 10a5ee: 89 44 24 10 mov %eax,0x10(%esp) 10a5f2: 31 c0 xor %eax,%eax 10a5f4: 89 44 24 0c mov %eax,0xc(%esp) 10a5f8: 8d 45 e4 lea -0x1c(%ebp),%eax 10a5fb: 89 44 24 08 mov %eax,0x8(%esp) 10a5ff: 8b 45 08 mov 0x8(%ebp),%eax 10a602: 89 4d d4 mov %ecx,-0x2c(%ebp) 10a605: 89 04 24 mov %eax,(%esp) 10a608: e8 e3 c5 ff ff call 106bf0 if (ret) { 10a60d: 8b 4d d4 mov -0x2c(%ebp),%ecx 10a610: 89 45 d4 mov %eax,-0x2c(%ebp) 10a613: 85 c0 test %eax,%eax 10a615: 0f 85 15 01 00 00 jne 10a730 <== NEVER TAKEN mutex_lock(&dir_f->sem); /* Build a deletion node */ rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT); rd->totlen = cpu_to_je32(sizeof(*rd) + namelen); 10a61b: 89 4e 04 mov %ecx,0x4(%esi) rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 10a61e: b8 08 00 00 00 mov $0x8,%eax rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 10a623: c7 06 85 19 01 e0 movl $0xe0011985,(%esi) rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 10a629: 89 44 24 08 mov %eax,0x8(%esp) 10a62d: 89 74 24 04 mov %esi,0x4(%esp) 10a631: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10a638: e8 53 08 00 00 call 10ae90 rd->mctime = cpu_to_je32(time); rd->nsize = namelen; rd->type = type; rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 10a63d: ba 20 00 00 00 mov $0x20,%edx rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)); 10a642: 89 46 08 mov %eax,0x8(%esi) rd->pino = cpu_to_je32(dir_f->inocache->ino); 10a645: 8b 47 14 mov 0x14(%edi),%eax 10a648: 8b 40 0c mov 0xc(%eax),%eax 10a64b: 89 46 0c mov %eax,0xc(%esi) rd->version = cpu_to_je32(++dir_f->highest_version); 10a64e: 8b 07 mov (%edi),%eax 10a650: 40 inc %eax 10a651: 89 07 mov %eax,(%edi) 10a653: 89 46 10 mov %eax,0x10(%esi) rd->ino = cpu_to_je32(ino); 10a656: 8b 45 10 mov 0x10(%ebp),%eax rd->nsize = namelen; 10a659: 88 5e 1c mov %bl,0x1c(%esi) rd->ino = cpu_to_je32(ino); 10a65c: 89 46 14 mov %eax,0x14(%esi) rd->mctime = cpu_to_je32(time); 10a65f: 8b 45 20 mov 0x20(%ebp),%eax 10a662: 89 46 18 mov %eax,0x18(%esi) rd->type = type; 10a665: 0f b6 45 d0 movzbl -0x30(%ebp),%eax 10a669: 88 46 1d mov %al,0x1d(%esi) rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8)); 10a66c: 89 54 24 08 mov %edx,0x8(%esp) 10a670: 89 74 24 04 mov %esi,0x4(%esp) 10a674: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10a67b: e8 10 08 00 00 call 10ae90 10a680: 89 46 20 mov %eax,0x20(%esi) rd->name_crc = cpu_to_je32(crc32(0, name, namelen)); 10a683: 8b 45 18 mov 0x18(%ebp),%eax 10a686: 89 5c 24 08 mov %ebx,0x8(%esp) 10a68a: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10a691: 89 44 24 04 mov %eax,0x4(%esp) 10a695: e8 f6 07 00 00 call 10ae90 fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL); 10a69a: 31 c9 xor %ecx,%ecx rd->name_crc = cpu_to_je32(crc32(0, name, namelen)); 10a69c: 89 46 24 mov %eax,0x24(%esi) fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL); 10a69f: 8b 45 18 mov 0x18(%ebp),%eax 10a6a2: 89 4c 24 14 mov %ecx,0x14(%esp) 10a6a6: 89 5c 24 10 mov %ebx,0x10(%esp) 10a6aa: 89 74 24 08 mov %esi,0x8(%esp) 10a6ae: 89 44 24 0c mov %eax,0xc(%esp) 10a6b2: 8b 45 08 mov 0x8(%ebp),%eax 10a6b5: 89 7c 24 04 mov %edi,0x4(%esp) 10a6b9: 89 04 24 mov %eax,(%esp) 10a6bc: e8 2f f4 ff ff call 109af0 jffs2_free_raw_dirent(rd); 10a6c1: 89 34 24 mov %esi,(%esp) fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL); 10a6c4: 89 c3 mov %eax,%ebx jffs2_free_raw_dirent(rd); 10a6c6: e8 c5 aa ff ff call 105190 if (IS_ERR(fd)) { 10a6cb: 81 fb 18 fc ff ff cmp $0xfffffc18,%ebx 10a6d1: 8b 55 d4 mov -0x2c(%ebp),%edx 10a6d4: 77 3a ja 10a710 <== NEVER TAKEN mutex_unlock(&dir_f->sem); return PTR_ERR(fd); } /* File it. This will mark the old one obsolete. */ jffs2_add_fd_to_list(c, fd, &dir_f->dents); 10a6d6: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED 10a6da: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a6dd: 83 c7 0c add $0xc,%edi <== NOT EXECUTED 10a6e0: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED 10a6e4: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED 10a6e7: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10a6ea: e8 61 ad ff ff call 105450 <== NOT EXECUTED jffs2_complete_reservation(c); 10a6ef: 8b 45 08 mov 0x8(%ebp),%eax 10a6f2: 89 04 24 mov %eax,(%esp) 10a6f5: e8 96 bc ff ff call 106390 mutex_unlock(&dir_f->sem); return 0; 10a6fa: 8b 55 d4 mov -0x2c(%ebp),%edx } 10a6fd: 83 c4 4c add $0x4c,%esp 10a700: 89 d0 mov %edx,%eax 10a702: 5b pop %ebx 10a703: 5e pop %esi 10a704: 5f pop %edi 10a705: 5d pop %ebp 10a706: c3 ret 10a707: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10a70e: 66 90 xchg %ax,%ax jffs2_complete_reservation(c); 10a710: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a713: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10a716: e8 75 bc ff ff call 106390 <== NOT EXECUTED } 10a71b: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED return PTR_ERR(fd); 10a71e: 89 da mov %ebx,%edx <== NOT EXECUTED } 10a720: 5b pop %ebx <== NOT EXECUTED 10a721: 89 d0 mov %edx,%eax <== NOT EXECUTED 10a723: 5e pop %esi <== NOT EXECUTED 10a724: 5f pop %edi <== NOT EXECUTED 10a725: 5d pop %ebp <== NOT EXECUTED 10a726: c3 ret <== NOT EXECUTED 10a727: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10a72e: 66 90 xchg %ax,%ax <== NOT EXECUTED jffs2_free_raw_dirent(rd); 10a730: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10a733: e8 58 aa ff ff call 105190 <== NOT EXECUTED return ret; 10a738: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED } 10a73b: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED 10a73e: 5b pop %ebx <== NOT EXECUTED 10a73f: 5e pop %esi <== NOT EXECUTED 10a740: 89 d0 mov %edx,%eax <== NOT EXECUTED 10a742: 5f pop %edi <== NOT EXECUTED 10a743: 5d pop %ebp <== NOT EXECUTED 10a744: c3 ret <== NOT EXECUTED return -ENOMEM; 10a745: ba f4 ff ff ff mov $0xfffffff4,%edx <== NOT EXECUTED 10a74a: eb b1 jmp 10a6fd <== NOT EXECUTED 10a74c: 90 nop 10a74d: 90 nop 10a74e: 90 nop 10a74f: 90 nop =============================================================================== 0010a800 : dbg_fsbuild("Very dirty blocks before GC triggered: %d\n", c->vdirty_blocks_gctrigger); } int jffs2_do_mount_fs(struct jffs2_sb_info *c) { 10a800: 55 push %ebp int ret; int i; int size; c->free_size = c->flash_size; c->nr_blocks = c->flash_size / c->sector_size; 10a801: 31 d2 xor %edx,%edx { 10a803: 89 e5 mov %esp,%ebp 10a805: 57 push %edi 10a806: 56 push %esi 10a807: 53 push %ebx 10a808: 83 ec 4c sub $0x4c,%esp c->free_size = c->flash_size; 10a80b: 8b 45 08 mov 0x8(%ebp),%eax 10a80e: 8b 78 18 mov 0x18(%eax),%edi c->nr_blocks = c->flash_size / c->sector_size; 10a811: 8b 58 34 mov 0x34(%eax),%ebx c->free_size = c->flash_size; 10a814: 89 78 28 mov %edi,0x28(%eax) c->nr_blocks = c->flash_size / c->sector_size; 10a817: 89 f8 mov %edi,%eax 10a819: f7 f3 div %ebx 10a81b: 89 c6 mov %eax,%esi 10a81d: 8b 45 08 mov 0x8(%ebp),%eax 10a820: 89 70 50 mov %esi,0x50(%eax) size = sizeof(struct jffs2_eraseblock) * c->nr_blocks; 10a823: 8d 04 76 lea (%esi,%esi,2),%eax #ifndef __ECOS if (jffs2_blocks_use_vmalloc(c)) c->blocks = vzalloc(size); else #endif c->blocks = kzalloc(size, GFP_KERNEL); 10a826: c7 04 24 01 00 00 00 movl $0x1,(%esp) size = sizeof(struct jffs2_eraseblock) * c->nr_blocks; 10a82d: 8d 04 86 lea (%esi,%eax,4),%eax 10a830: c1 e0 02 shl $0x2,%eax c->blocks = kzalloc(size, GFP_KERNEL); 10a833: 89 44 24 04 mov %eax,0x4(%esp) 10a837: e8 14 35 00 00 call 10dd50 10a83c: 8b 4d 08 mov 0x8(%ebp),%ecx 10a83f: 89 41 54 mov %eax,0x54(%ecx) if (!c->blocks) 10a842: 85 c0 test %eax,%eax 10a844: 0f 84 2f 06 00 00 je 10ae79 <== NEVER TAKEN return -ENOMEM; for (i=0; inr_blocks; i++) { 10a84a: 31 c9 xor %ecx,%ecx 10a84c: 31 d2 xor %edx,%edx 10a84e: 39 df cmp %ebx,%edi 10a850: 72 23 jb 10a875 <== NEVER TAKEN 10a852: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10a859: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi INIT_LIST_HEAD(&c->blocks[i].list); c->blocks[i].offset = i * c->sector_size; 10a860: 89 48 0c mov %ecx,0xc(%eax) for (i=0; inr_blocks; i++) { 10a863: 42 inc %edx 10a864: 01 d9 add %ebx,%ecx c->blocks[i].free_size = c->sector_size; 10a866: 89 58 20 mov %ebx,0x20(%eax) INIT_LIST_HEAD(&c->blocks[i].list); 10a869: 89 40 04 mov %eax,0x4(%eax) 10a86c: 89 00 mov %eax,(%eax) for (i=0; inr_blocks; i++) { 10a86e: 83 c0 34 add $0x34,%eax 10a871: 39 d6 cmp %edx,%esi 10a873: 77 eb ja 10a860 } INIT_LIST_HEAD(&c->clean_list); 10a875: 8b 45 08 mov 0x8(%ebp),%eax INIT_LIST_HEAD(&c->erase_complete_list); INIT_LIST_HEAD(&c->free_list); INIT_LIST_HEAD(&c->bad_list); INIT_LIST_HEAD(&c->bad_used_list); c->highest_ino = 1; c->summary = NULL; 10a878: 31 d2 xor %edx,%edx struct jffs2_full_dirent *dead_fds = NULL; 10a87a: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) INIT_LIST_HEAD(&c->clean_list); 10a881: 8b 4d 08 mov 0x8(%ebp),%ecx 10a884: 83 c0 60 add $0x60,%eax 10a887: 89 41 64 mov %eax,0x64(%ecx) 10a88a: 89 41 60 mov %eax,0x60(%ecx) INIT_LIST_HEAD(&c->very_dirty_list); 10a88d: 89 c8 mov %ecx,%eax c->flags |= JFFS2_SB_FLAG_SCANNING; 10a88f: 83 49 0c 02 orl $0x2,0xc(%ecx) INIT_LIST_HEAD(&c->very_dirty_list); 10a893: 83 c0 68 add $0x68,%eax 10a896: 89 41 6c mov %eax,0x6c(%ecx) 10a899: 89 41 68 mov %eax,0x68(%ecx) INIT_LIST_HEAD(&c->dirty_list); 10a89c: 89 c8 mov %ecx,%eax c->highest_ino = 1; 10a89e: c7 41 04 01 00 00 00 movl $0x1,0x4(%ecx) INIT_LIST_HEAD(&c->dirty_list); 10a8a5: 83 c0 70 add $0x70,%eax 10a8a8: 89 41 74 mov %eax,0x74(%ecx) 10a8ab: 89 41 70 mov %eax,0x70(%ecx) INIT_LIST_HEAD(&c->erasable_list); 10a8ae: 89 c8 mov %ecx,%eax c->summary = NULL; 10a8b0: 89 91 cc 00 00 00 mov %edx,0xcc(%ecx) INIT_LIST_HEAD(&c->erasable_list); 10a8b6: 83 c0 78 add $0x78,%eax 10a8b9: 89 41 7c mov %eax,0x7c(%ecx) 10a8bc: 89 41 78 mov %eax,0x78(%ecx) INIT_LIST_HEAD(&c->erasing_list); 10a8bf: 89 c8 mov %ecx,%eax 10a8c1: 05 88 00 00 00 add $0x88,%eax 10a8c6: 89 81 8c 00 00 00 mov %eax,0x8c(%ecx) 10a8cc: 89 81 88 00 00 00 mov %eax,0x88(%ecx) INIT_LIST_HEAD(&c->erase_checking_list); 10a8d2: 89 c8 mov %ecx,%eax 10a8d4: 05 90 00 00 00 add $0x90,%eax 10a8d9: 89 81 94 00 00 00 mov %eax,0x94(%ecx) 10a8df: 89 81 90 00 00 00 mov %eax,0x90(%ecx) INIT_LIST_HEAD(&c->erase_pending_list); 10a8e5: 89 c8 mov %ecx,%eax 10a8e7: 05 98 00 00 00 add $0x98,%eax 10a8ec: 89 81 9c 00 00 00 mov %eax,0x9c(%ecx) 10a8f2: 89 81 98 00 00 00 mov %eax,0x98(%ecx) INIT_LIST_HEAD(&c->erasable_pending_wbuf_list); 10a8f8: 89 c8 mov %ecx,%eax 10a8fa: 83 e8 80 sub $0xffffff80,%eax 10a8fd: 89 81 84 00 00 00 mov %eax,0x84(%ecx) 10a903: 89 81 80 00 00 00 mov %eax,0x80(%ecx) INIT_LIST_HEAD(&c->erase_complete_list); 10a909: 89 c8 mov %ecx,%eax 10a90b: 05 a0 00 00 00 add $0xa0,%eax 10a910: 89 81 a4 00 00 00 mov %eax,0xa4(%ecx) 10a916: 89 81 a0 00 00 00 mov %eax,0xa0(%ecx) INIT_LIST_HEAD(&c->free_list); 10a91c: 89 c8 mov %ecx,%eax 10a91e: 05 a8 00 00 00 add $0xa8,%eax 10a923: 89 81 ac 00 00 00 mov %eax,0xac(%ecx) 10a929: 89 81 a8 00 00 00 mov %eax,0xa8(%ecx) INIT_LIST_HEAD(&c->bad_list); 10a92f: 89 c8 mov %ecx,%eax 10a931: 05 b0 00 00 00 add $0xb0,%eax 10a936: 89 81 b4 00 00 00 mov %eax,0xb4(%ecx) 10a93c: 89 81 b0 00 00 00 mov %eax,0xb0(%ecx) INIT_LIST_HEAD(&c->bad_used_list); 10a942: 89 c8 mov %ecx,%eax 10a944: 05 b8 00 00 00 add $0xb8,%eax 10a949: 89 81 bc 00 00 00 mov %eax,0xbc(%ecx) 10a94f: 89 81 b8 00 00 00 mov %eax,0xb8(%ecx) ret = jffs2_scan_medium(c); 10a955: 89 0c 24 mov %ecx,(%esp) 10a958: e8 53 1f 00 00 call 10c8b0 c->flags &= ~JFFS2_SB_FLAG_SCANNING; 10a95d: 8b 7d 08 mov 0x8(%ebp),%edi ret = jffs2_scan_medium(c); 10a960: 89 45 cc mov %eax,-0x34(%ebp) 10a963: 89 c1 mov %eax,%ecx c->flags &= ~JFFS2_SB_FLAG_SCANNING; 10a965: 8b 45 08 mov 0x8(%ebp),%eax 10a968: 8b 40 0c mov 0xc(%eax),%eax 10a96b: 89 45 d4 mov %eax,-0x2c(%ebp) 10a96e: 83 e0 fd and $0xfffffffd,%eax if (ret) 10a971: 85 c9 test %ecx,%ecx c->flags &= ~JFFS2_SB_FLAG_SCANNING; 10a973: 89 47 0c mov %eax,0xc(%edi) if (ret) 10a976: 0f 85 aa 03 00 00 jne 10ad26 <== NEVER TAKEN c->flags |= JFFS2_SB_FLAG_BUILDING; 10a97c: 8b 4d 08 mov 0x8(%ebp),%ecx 10a97f: 83 c8 04 or $0x4,%eax 10a982: 89 41 0c mov %eax,0xc(%ecx) for (; *i < c->inocache_hashsize; (*i)++) { 10a985: 8b 81 c0 00 00 00 mov 0xc0(%ecx),%eax 10a98b: 85 c0 test %eax,%eax 10a98d: 0f 8e dd 04 00 00 jle 10ae70 <== NEVER TAKEN if (c->inocache_list[*i]) 10a993: 8b 91 c4 00 00 00 mov 0xc4(%ecx),%edx for_each_inode(i, c, ic) { 10a999: 31 ff xor %edi,%edi 10a99b: eb 08 jmp 10a9a5 10a99d: 8d 76 00 lea 0x0(%esi),%esi for (; *i < c->inocache_hashsize; (*i)++) { 10a9a0: 47 inc %edi 10a9a1: 39 c7 cmp %eax,%edi 10a9a3: 74 07 je 10a9ac if (c->inocache_list[*i]) 10a9a5: 8b 34 ba mov (%edx,%edi,4),%esi 10a9a8: 85 f6 test %esi,%esi 10a9aa: 74 f4 je 10a9a0 <== ALWAYS TAKEN 10a9ac: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) for_each_inode(i, c, ic) { 10a9b3: 85 f6 test %esi,%esi 10a9b5: 0f 85 65 01 00 00 jne 10ab20 <== NEVER TAKEN 10a9bb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10a9bf: 90 nop for (; *i < c->inocache_hashsize; (*i)++) { 10a9c0: 85 c0 test %eax,%eax 10a9c2: 0f 8e a1 04 00 00 jle 10ae69 <== NEVER TAKEN if (c->inocache_list[*i]) 10a9c8: 8b 4d 08 mov 0x8(%ebp),%ecx for_each_inode(i, c, ic) { 10a9cb: 31 db xor %ebx,%ebx if (c->inocache_list[*i]) 10a9cd: 8b 91 c4 00 00 00 mov 0xc4(%ecx),%edx 10a9d3: eb 10 jmp 10a9e5 10a9d5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10a9dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi for (; *i < c->inocache_hashsize; (*i)++) { 10a9e0: 43 inc %ebx 10a9e1: 39 c3 cmp %eax,%ebx 10a9e3: 74 07 je 10a9ec if (c->inocache_list[*i]) 10a9e5: 8b 34 9a mov (%edx,%ebx,4),%esi 10a9e8: 85 f6 test %esi,%esi 10a9ea: 74 f4 je 10a9e0 <== ALWAYS TAKEN for_each_inode(i, c, ic) { 10a9ec: 85 f6 test %esi,%esi 10a9ee: 0f 85 f4 03 00 00 jne 10ade8 <== NEVER TAKEN 10a9f4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10a9fb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10a9ff: 90 nop while (dead_fds) { 10aa00: 8b 5d e4 mov -0x1c(%ebp),%ebx 10aa03: 8b 7d 08 mov 0x8(%ebp),%edi 10aa06: 85 db test %ebx,%ebx 10aa08: 74 43 je 10aa4d <== ALWAYS TAKEN 10aa0a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi dead_fds = fd->next; 10aa10: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10aa13: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED ic = jffs2_get_ino_cache(c, fd->ino); 10aa16: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10aa19: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10aa1c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10aa20: e8 2b b1 ff ff call 105b50 <== NOT EXECUTED if (ic) 10aa25: 85 c0 test %eax,%eax <== NOT EXECUTED ic = jffs2_get_ino_cache(c, fd->ino); 10aa27: 89 c2 mov %eax,%edx <== NOT EXECUTED if (ic) 10aa29: 74 0a je 10aa35 <== NOT EXECUTED jffs2_build_remove_unlinked_inode(c, ic, &dead_fds); 10aa2b: 8d 4d e4 lea -0x1c(%ebp),%ecx <== NOT EXECUTED 10aa2e: 89 f8 mov %edi,%eax <== NOT EXECUTED 10aa30: e8 1b fd ff ff call 10a750 <== NOT EXECUTED jffs2_free_full_dirent(fd); 10aa35: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10aa38: e8 f3 a6 ff ff call 105130 <== NOT EXECUTED while (dead_fds) { 10aa3d: 8b 5d e4 mov -0x1c(%ebp),%ebx <== NOT EXECUTED 10aa40: 85 db test %ebx,%ebx <== NOT EXECUTED 10aa42: 75 cc jne 10aa10 <== NOT EXECUTED 10aa44: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10aa47: 8b 80 c0 00 00 00 mov 0xc0(%eax),%eax <== NOT EXECUTED if (dir_hardlinks) { 10aa4d: 8b 7d d0 mov -0x30(%ebp),%edi 10aa50: 85 ff test %edi,%edi 10aa52: 0f 84 23 01 00 00 je 10ab7b <== ALWAYS TAKEN for_each_inode(i, c, ic) { 10aa58: 31 d2 xor %edx,%edx <== NOT EXECUTED return NULL; 10aa5a: 31 c9 xor %ecx,%ecx <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10aa5c: 85 c0 test %eax,%eax <== NOT EXECUTED 10aa5e: 0f 8e 0f 01 00 00 jle 10ab73 <== NOT EXECUTED if (c->inocache_list[*i]) 10aa64: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED for_each_inode(i, c, ic) { 10aa67: 31 d2 xor %edx,%edx <== NOT EXECUTED if (c->inocache_list[*i]) 10aa69: 8b 99 c4 00 00 00 mov 0xc4(%ecx),%ebx <== NOT EXECUTED 10aa6f: eb 09 jmp 10aa7a <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10aa71: 42 inc %edx <== NOT EXECUTED 10aa72: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10aa74: 0f 84 f9 00 00 00 je 10ab73 <== NOT EXECUTED if (c->inocache_list[*i]) 10aa7a: 8b 0c 93 mov (%ebx,%edx,4),%ecx <== NOT EXECUTED 10aa7d: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10aa7f: 74 f0 je 10aa71 <== NOT EXECUTED 10aa81: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10aa88: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10aa8f: 90 nop <== NOT EXECUTED if (ic->flags & INO_FLAGS_IS_DIR) 10aa90: f6 41 09 02 testb $0x2,0x9(%ecx) <== NOT EXECUTED 10aa94: 74 07 je 10aa9d <== NOT EXECUTED ic->pino_nlink = 0; 10aa96: c7 41 14 00 00 00 00 movl $0x0,0x14(%ecx) <== NOT EXECUTED if (ic->next) 10aa9d: 8b 49 10 mov 0x10(%ecx),%ecx <== NOT EXECUTED 10aaa0: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10aaa2: 75 ec jne 10aa90 <== NOT EXECUTED (*i)++; 10aaa4: 42 inc %edx <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10aaa5: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10aaa7: 0f 8d ce 00 00 00 jge 10ab7b <== NOT EXECUTED if (c->inocache_list[*i]) 10aaad: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10aab0: 8b 99 c4 00 00 00 mov 0xc4(%ecx),%ebx <== NOT EXECUTED 10aab6: eb 11 jmp 10aac9 <== NOT EXECUTED 10aab8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10aabf: 90 nop <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10aac0: 42 inc %edx <== NOT EXECUTED 10aac1: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10aac3: 0f 84 b2 00 00 00 je 10ab7b <== NOT EXECUTED if (c->inocache_list[*i]) 10aac9: 8b 0c 93 mov (%ebx,%edx,4),%ecx <== NOT EXECUTED 10aacc: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10aace: 74 f0 je 10aac0 <== NOT EXECUTED 10aad0: eb be jmp 10aa90 <== NOT EXECUTED 10aad2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10aad9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10aae0: 8b 75 d4 mov -0x2c(%ebp),%esi <== NOT EXECUTED if (ic->next) 10aae3: 8b 76 10 mov 0x10(%esi),%esi <== NOT EXECUTED 10aae6: 85 f6 test %esi,%esi <== NOT EXECUTED 10aae8: 75 36 jne 10ab20 <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10aaea: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED (*i)++; 10aaed: 47 inc %edi <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10aaee: 8b 80 c0 00 00 00 mov 0xc0(%eax),%eax <== NOT EXECUTED 10aaf4: 39 c7 cmp %eax,%edi <== NOT EXECUTED 10aaf6: 0f 8d c4 fe ff ff jge 10a9c0 <== NOT EXECUTED if (c->inocache_list[*i]) 10aafc: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10aaff: 8b 89 c4 00 00 00 mov 0xc4(%ecx),%ecx <== NOT EXECUTED 10ab05: eb 12 jmp 10ab19 <== NOT EXECUTED 10ab07: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10ab0e: 66 90 xchg %ax,%ax <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10ab10: 47 inc %edi <== NOT EXECUTED 10ab11: 39 c7 cmp %eax,%edi <== NOT EXECUTED 10ab13: 0f 84 a7 fe ff ff je 10a9c0 <== NOT EXECUTED if (c->inocache_list[*i]) 10ab19: 8b 34 b9 mov (%ecx,%edi,4),%esi <== NOT EXECUTED 10ab1c: 85 f6 test %esi,%esi <== NOT EXECUTED 10ab1e: 74 f0 je 10ab10 <== NOT EXECUTED if (ic->scan_dents) { 10ab20: 8b 1e mov (%esi),%ebx <== NOT EXECUTED 10ab22: 85 db test %ebx,%ebx <== NOT EXECUTED 10ab24: 74 bd je 10aae3 <== NOT EXECUTED 10ab26: 89 75 d4 mov %esi,-0x2c(%ebp) <== NOT EXECUTED 10ab29: 89 de mov %ebx,%esi <== NOT EXECUTED 10ab2b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10ab2e: eb 07 jmp 10ab37 <== NOT EXECUTED for(fd = ic->scan_dents; fd; fd = fd->next) { 10ab30: 8b 76 04 mov 0x4(%esi),%esi <== NOT EXECUTED 10ab33: 85 f6 test %esi,%esi <== NOT EXECUTED 10ab35: 74 a9 je 10aae0 <== NOT EXECUTED if (!fd->ino) 10ab37: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 10ab3a: 85 c0 test %eax,%eax <== NOT EXECUTED 10ab3c: 74 f2 je 10ab30 <== NOT EXECUTED child_ic = jffs2_get_ino_cache(c, fd->ino); 10ab3e: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10ab42: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10ab45: e8 06 b0 ff ff call 105b50 <== NOT EXECUTED if (!child_ic) { 10ab4a: 85 c0 test %eax,%eax <== NOT EXECUTED 10ab4c: 0f 84 bb 01 00 00 je 10ad0d <== NOT EXECUTED fd->ic = child_ic; 10ab52: 89 06 mov %eax,(%esi) <== NOT EXECUTED child_ic->pino_nlink++; 10ab54: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED 10ab57: 41 inc %ecx <== NOT EXECUTED 10ab58: 89 48 14 mov %ecx,0x14(%eax) <== NOT EXECUTED if (fd->type == DT_DIR) { 10ab5b: 80 7e 14 04 cmpb $0x4,0x14(%esi) <== NOT EXECUTED 10ab5f: 75 cf jne 10ab30 <== NOT EXECUTED child_ic->flags |= INO_FLAGS_IS_DIR; 10ab61: 80 48 09 02 orb $0x2,0x9(%eax) <== NOT EXECUTED if (child_ic->pino_nlink > 1) 10ab65: 83 f9 01 cmp $0x1,%ecx <== NOT EXECUTED 10ab68: 76 c6 jbe 10ab30 <== NOT EXECUTED *dir_hardlinks = 1; 10ab6a: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp) <== NOT EXECUTED 10ab71: eb bd jmp 10ab30 <== NOT EXECUTED for_each_inode(i, c, ic) { 10ab73: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ab75: 0f 85 15 ff ff ff jne 10aa90 <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10ab7b: 31 ff xor %edi,%edi 10ab7d: 85 c0 test %eax,%eax 10ab7f: 0f 8e 00 01 00 00 jle 10ac85 <== NEVER TAKEN if (c->inocache_list[*i]) 10ab85: 8b 4d 08 mov 0x8(%ebp),%ecx 10ab88: 31 ff xor %edi,%edi 10ab8a: 8b 91 c4 00 00 00 mov 0xc4(%ecx),%edx 10ab90: eb 17 jmp 10aba9 10ab92: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10ab99: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi for (; *i < c->inocache_hashsize; (*i)++) { 10aba0: 47 inc %edi 10aba1: 39 c7 cmp %eax,%edi 10aba3: 0f 84 dc 00 00 00 je 10ac85 if (c->inocache_list[*i]) 10aba9: 8b 34 ba mov (%edx,%edi,4),%esi 10abac: 85 f6 test %esi,%esi 10abae: 74 f0 je 10aba0 <== ALWAYS TAKEN while(ic->scan_dents) { 10abb0: 8b 1e mov (%esi),%ebx <== NOT EXECUTED 10abb2: 85 db test %ebx,%ebx <== NOT EXECUTED 10abb4: 74 4d je 10ac03 <== NOT EXECUTED 10abb6: 89 7d d4 mov %edi,-0x2c(%ebp) <== NOT EXECUTED 10abb9: 8b 7d d0 mov -0x30(%ebp),%edi <== NOT EXECUTED 10abbc: eb 2b jmp 10abe9 <== NOT EXECUTED 10abbe: 66 90 xchg %ax,%ax <== NOT EXECUTED BUG_ON(!(fd->ic->flags & INO_FLAGS_IS_DIR)); 10abc0: f6 40 09 02 testb $0x2,0x9(%eax) <== NOT EXECUTED 10abc4: 0f 84 78 02 00 00 je 10ae42 <== NOT EXECUTED if (dir_hardlinks && fd->ic->pino_nlink) { 10abca: 85 ff test %edi,%edi <== NOT EXECUTED JFFS2_ERROR("child dir \"%s\" (ino #%u) of dir ino #%u is also hard linked from dir ino #%u\n", 10abcc: 8b 56 0c mov 0xc(%esi),%edx <== NOT EXECUTED if (dir_hardlinks && fd->ic->pino_nlink) { 10abcf: 74 07 je 10abd8 <== NOT EXECUTED 10abd1: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED 10abd4: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10abd6: 75 78 jne 10ac50 <== NOT EXECUTED fd->ic->pino_nlink = ic->ino; 10abd8: 89 50 14 mov %edx,0x14(%eax) <== NOT EXECUTED jffs2_free_full_dirent(fd); 10abdb: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10abde: e8 4d a5 ff ff call 105130 <== NOT EXECUTED while(ic->scan_dents) { 10abe3: 8b 1e mov (%esi),%ebx <== NOT EXECUTED 10abe5: 85 db test %ebx,%ebx <== NOT EXECUTED 10abe7: 74 17 je 10ac00 <== NOT EXECUTED ic->scan_dents = fd->next; 10abe9: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 10abec: 89 16 mov %edx,(%esi) <== NOT EXECUTED if (fd->type == DT_DIR) { 10abee: 80 7b 14 04 cmpb $0x4,0x14(%ebx) <== NOT EXECUTED 10abf2: 75 e7 jne 10abdb <== NOT EXECUTED if (!fd->ic) { 10abf4: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10abf6: 85 c0 test %eax,%eax <== NOT EXECUTED 10abf8: 75 c6 jne 10abc0 <== NOT EXECUTED 10abfa: 89 d3 mov %edx,%ebx <== NOT EXECUTED while(ic->scan_dents) { 10abfc: 85 db test %ebx,%ebx <== NOT EXECUTED 10abfe: 75 e9 jne 10abe9 <== NOT EXECUTED 10ac00: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED ic->scan_dents = NULL; 10ac03: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED if (ic->next) 10ac09: 8b 76 10 mov 0x10(%esi),%esi <== NOT EXECUTED 10ac0c: 85 f6 test %esi,%esi <== NOT EXECUTED 10ac0e: 75 a0 jne 10abb0 <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10ac10: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED (*i)++; 10ac13: 47 inc %edi <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10ac14: 8b 80 c0 00 00 00 mov 0xc0(%eax),%eax <== NOT EXECUTED 10ac1a: 39 c7 cmp %eax,%edi <== NOT EXECUTED 10ac1c: 7d 6f jge 10ac8d <== NOT EXECUTED if (c->inocache_list[*i]) 10ac1e: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ac21: 8b 91 c4 00 00 00 mov 0xc4(%ecx),%edx <== NOT EXECUTED 10ac27: eb 0c jmp 10ac35 <== NOT EXECUTED 10ac29: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10ac30: 47 inc %edi <== NOT EXECUTED 10ac31: 39 c7 cmp %eax,%edi <== NOT EXECUTED 10ac33: 74 58 je 10ac8d <== NOT EXECUTED if (c->inocache_list[*i]) 10ac35: 8b 34 ba mov (%edx,%edi,4),%esi <== NOT EXECUTED 10ac38: 85 f6 test %esi,%esi <== NOT EXECUTED 10ac3a: 74 f4 je 10ac30 <== NOT EXECUTED 10ac3c: e9 6f ff ff ff jmp 10abb0 <== NOT EXECUTED 10ac41: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10ac48: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10ac4f: 90 nop <== NOT EXECUTED JFFS2_ERROR("child dir \"%s\" (ino #%u) of dir ino #%u is also hard linked from dir ino #%u\n", 10ac50: 89 54 24 10 mov %edx,0x10(%esp) <== NOT EXECUTED 10ac54: 89 4c 24 14 mov %ecx,0x14(%esp) <== NOT EXECUTED 10ac58: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10ac5b: c7 04 24 74 ff 12 00 movl $0x12ff74,(%esp) <== NOT EXECUTED 10ac62: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 10ac66: 8d 43 15 lea 0x15(%ebx),%eax <== NOT EXECUTED 10ac69: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 10ac6d: b8 04 00 13 00 mov $0x130004,%eax <== NOT EXECUTED 10ac72: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10ac76: e8 65 fb ff ff call 10a7e0 <== NOT EXECUTED fd->ic->pino_nlink = ic->ino; 10ac7b: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10ac7d: 8b 56 0c mov 0xc(%esi),%edx <== NOT EXECUTED 10ac80: e9 53 ff ff ff jmp 10abd8 <== NOT EXECUTED for_each_inode(i, c, ic) { 10ac85: 85 f6 test %esi,%esi 10ac87: 0f 85 23 ff ff ff jne 10abb0 <== NEVER TAKEN c->flags &= ~JFFS2_SB_FLAG_BUILDING; 10ac8d: 8b 45 08 mov 0x8(%ebp),%eax 10ac90: 83 60 0c fb andl $0xfffffffb,0xc(%eax) jffs2_rotate_lists(c); 10ac94: 89 04 24 mov %eax,(%esp) 10ac97: e8 54 2c 00 00 call 10d8f0 c->resv_blocks_deletion = 2; 10ac9c: 8b 45 08 mov 0x8(%ebp),%eax size = c->flash_size / 50; /* 2% of flash size */ 10ac9f: b9 1f 85 eb 51 mov $0x51eb851f,%ecx c->resv_blocks_write = c->resv_blocks_deletion + (size / c->sector_size); 10aca4: 8b 7d 08 mov 0x8(%ebp),%edi c->resv_blocks_deletion = 2; 10aca7: c6 40 45 02 movb $0x2,0x45(%eax) size = c->flash_size / 50; /* 2% of flash size */ 10acab: 8b 40 18 mov 0x18(%eax),%eax 10acae: 89 45 d4 mov %eax,-0x2c(%ebp) size += c->sector_size - 1; /* ... and round up */ 10acb1: 8b 45 08 mov 0x8(%ebp),%eax 10acb4: 8b 58 34 mov 0x34(%eax),%ebx size = c->flash_size / 50; /* 2% of flash size */ 10acb7: 8b 45 d4 mov -0x2c(%ebp),%eax 10acba: f7 e1 mul %ecx 10acbc: 89 d0 mov %edx,%eax 10acbe: 89 d1 mov %edx,%ecx 10acc0: c1 e8 04 shr $0x4,%eax 10acc3: 8d 54 03 ff lea -0x1(%ebx,%eax,1),%edx size += c->nr_blocks * 100; /* And 100 bytes per eraseblock */ 10acc7: 8b 45 08 mov 0x8(%ebp),%eax c->nospc_dirty_size = c->sector_size + (c->flash_size / 100); 10acca: c1 e9 05 shr $0x5,%ecx size += c->nr_blocks * 100; /* And 100 bytes per eraseblock */ 10accd: 8b 40 50 mov 0x50(%eax),%eax c->resv_blocks_gcbad = 0;//c->resv_blocks_deletion + 2; 10acd0: 66 c7 47 47 00 03 movw $0x300,0x47(%edi) size += c->nr_blocks * 100; /* And 100 bytes per eraseblock */ 10acd6: 8d 04 80 lea (%eax,%eax,4),%eax 10acd9: 8d 04 80 lea (%eax,%eax,4),%eax size += c->sector_size - 1; /* ... and round up */ 10acdc: 8d 04 82 lea (%edx,%eax,4),%eax c->resv_blocks_write = c->resv_blocks_deletion + (size / c->sector_size); 10acdf: 31 d2 xor %edx,%edx 10ace1: f7 f3 div %ebx 10ace3: 88 c2 mov %al,%dl c->resv_blocks_gctrigger = c->resv_blocks_write + 1; 10ace5: 04 03 add $0x3,%al 10ace7: 88 47 46 mov %al,0x46(%edi) c->resv_blocks_write = c->resv_blocks_deletion + (size / c->sector_size); 10acea: 80 c2 02 add $0x2,%dl 10aced: 88 57 44 mov %dl,0x44(%edi) c->vdirty_blocks_gctrigger *= 10; 10acf0: 88 c2 mov %al,%dl 10acf2: c0 e2 02 shl $0x2,%dl 10acf5: 00 d0 add %dl,%al 10acf7: 00 c0 add %al,%al 10acf9: 88 47 49 mov %al,0x49(%edi) c->nospc_dirty_size = c->sector_size + (c->flash_size / 100); 10acfc: 8d 04 19 lea (%ecx,%ebx,1),%eax 10acff: 89 47 4c mov %eax,0x4c(%edi) out_free: kvfree(c->blocks); return ret; } 10ad02: 8b 45 cc mov -0x34(%ebp),%eax 10ad05: 83 c4 4c add $0x4c,%esp 10ad08: 5b pop %ebx 10ad09: 5e pop %esi 10ad0a: 5f pop %edi 10ad0b: 5d pop %ebp 10ad0c: c3 ret jffs2_mark_node_obsolete(c, fd->raw); 10ad0d: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10ad0f: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10ad12: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10ad16: e8 a5 b6 ff ff call 1063c0 <== NOT EXECUTED fd->ic = NULL; 10ad1b: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED continue; 10ad21: e9 0a fe ff ff jmp 10ab30 <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10ad26: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED for_each_inode(i, c, ic) { 10ad29: 31 f6 xor %esi,%esi <== NOT EXECUTED return NULL; 10ad2b: 31 db xor %ebx,%ebx <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10ad2d: 8b 90 c0 00 00 00 mov 0xc0(%eax),%edx <== NOT EXECUTED 10ad33: 85 d2 test %edx,%edx <== NOT EXECUTED 10ad35: 0f 8e a7 00 00 00 jle 10ade2 <== NOT EXECUTED if (c->inocache_list[*i]) 10ad3b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED for_each_inode(i, c, ic) { 10ad3e: 31 f6 xor %esi,%esi <== NOT EXECUTED if (c->inocache_list[*i]) 10ad40: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED 10ad46: eb 09 jmp 10ad51 <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10ad48: 46 inc %esi <== NOT EXECUTED 10ad49: 39 d6 cmp %edx,%esi <== NOT EXECUTED 10ad4b: 0f 84 91 00 00 00 je 10ade2 <== NOT EXECUTED if (c->inocache_list[*i]) 10ad51: 8b 1c b0 mov (%eax,%esi,4),%ebx <== NOT EXECUTED 10ad54: 85 db test %ebx,%ebx <== NOT EXECUTED 10ad56: 74 f0 je 10ad48 <== NOT EXECUTED 10ad58: eb 13 jmp 10ad6d <== NOT EXECUTED 10ad5a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED ic->scan_dents = fd->next; 10ad60: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 10ad63: 89 13 mov %edx,(%ebx) <== NOT EXECUTED jffs2_free_full_dirent(fd); 10ad65: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10ad68: e8 c3 a3 ff ff call 105130 <== NOT EXECUTED while(ic->scan_dents) { 10ad6d: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10ad6f: 85 c0 test %eax,%eax <== NOT EXECUTED 10ad71: 75 ed jne 10ad60 <== NOT EXECUTED if (ic->next) 10ad73: 8b 5b 10 mov 0x10(%ebx),%ebx <== NOT EXECUTED 10ad76: 85 db test %ebx,%ebx <== NOT EXECUTED 10ad78: 75 f3 jne 10ad6d <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10ad7a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED (*i)++; 10ad7d: 46 inc %esi <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10ad7e: 8b 80 c0 00 00 00 mov 0xc0(%eax),%eax <== NOT EXECUTED 10ad84: 39 f0 cmp %esi,%eax <== NOT EXECUTED 10ad86: 7e 24 jle 10adac <== NOT EXECUTED if (c->inocache_list[*i]) 10ad88: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ad8b: 8b 91 c4 00 00 00 mov 0xc4(%ecx),%edx <== NOT EXECUTED 10ad91: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10ad98: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10ad9f: 90 nop <== NOT EXECUTED 10ada0: 8b 1c b2 mov (%edx,%esi,4),%ebx <== NOT EXECUTED 10ada3: 85 db test %ebx,%ebx <== NOT EXECUTED 10ada5: 75 c6 jne 10ad6d <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10ada7: 46 inc %esi <== NOT EXECUTED 10ada8: 39 f0 cmp %esi,%eax <== NOT EXECUTED 10adaa: 75 f4 jne 10ada0 <== NOT EXECUTED jffs2_free_ino_caches(c); 10adac: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10adaf: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10adb2: e8 c9 ae ff ff call 105c80 <== NOT EXECUTED jffs2_free_raw_node_refs(c); 10adb7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10adba: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10adbd: e8 2e af ff ff call 105cf0 <== NOT EXECUTED kvfree(c->blocks); 10adc2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10adc5: 8b 40 54 mov 0x54(%eax),%eax <== NOT EXECUTED 10adc8: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10adcb: e8 60 33 00 00 call 10e130 <== NOT EXECUTED return ret; 10add0: c7 45 cc fb ff ff ff movl $0xfffffffb,-0x34(%ebp) <== NOT EXECUTED } 10add7: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10adda: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED 10addd: 5b pop %ebx <== NOT EXECUTED 10adde: 5e pop %esi <== NOT EXECUTED 10addf: 5f pop %edi <== NOT EXECUTED 10ade0: 5d pop %ebp <== NOT EXECUTED 10ade1: c3 ret <== NOT EXECUTED for_each_inode(i, c, ic) { 10ade2: 85 db test %ebx,%ebx <== NOT EXECUTED 10ade4: 74 c6 je 10adac <== NOT EXECUTED 10ade6: eb 85 jmp 10ad6d <== NOT EXECUTED 10ade8: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10adeb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10adef: 90 nop <== NOT EXECUTED if (ic->pino_nlink) 10adf0: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED 10adf3: 85 c0 test %eax,%eax <== NOT EXECUTED 10adf5: 75 0c jne 10ae03 <== NOT EXECUTED jffs2_build_remove_unlinked_inode(c, ic, &dead_fds); 10adf7: 8d 4d e4 lea -0x1c(%ebp),%ecx <== NOT EXECUTED 10adfa: 89 f2 mov %esi,%edx <== NOT EXECUTED 10adfc: 89 f8 mov %edi,%eax <== NOT EXECUTED 10adfe: e8 4d f9 ff ff call 10a750 <== NOT EXECUTED if (ic->next) 10ae03: 8b 76 10 mov 0x10(%esi),%esi <== NOT EXECUTED 10ae06: 85 f6 test %esi,%esi <== NOT EXECUTED 10ae08: 75 e6 jne 10adf0 <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10ae0a: 8b 87 c0 00 00 00 mov 0xc0(%edi),%eax <== NOT EXECUTED (*i)++; 10ae10: 43 inc %ebx <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10ae11: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10ae13: 0f 8d e7 fb ff ff jge 10aa00 <== NOT EXECUTED if (c->inocache_list[*i]) 10ae19: 8b 97 c4 00 00 00 mov 0xc4(%edi),%edx <== NOT EXECUTED 10ae1f: eb 18 jmp 10ae39 <== NOT EXECUTED 10ae21: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10ae28: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10ae2f: 90 nop <== NOT EXECUTED for (; *i < c->inocache_hashsize; (*i)++) { 10ae30: 43 inc %ebx <== NOT EXECUTED 10ae31: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10ae33: 0f 84 c7 fb ff ff je 10aa00 <== NOT EXECUTED if (c->inocache_list[*i]) 10ae39: 8b 34 9a mov (%edx,%ebx,4),%esi <== NOT EXECUTED 10ae3c: 85 f6 test %esi,%esi <== NOT EXECUTED 10ae3e: 74 f0 je 10ae30 <== NOT EXECUTED 10ae40: eb ae jmp 10adf0 <== NOT EXECUTED BUG_ON(!(fd->ic->flags & INO_FLAGS_IS_DIR)); 10ae42: ba 3b d6 12 00 mov $0x12d63b,%edx <== NOT EXECUTED 10ae47: b9 04 00 13 00 mov $0x130004,%ecx <== NOT EXECUTED 10ae4c: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED 10ae50: bb c4 00 00 00 mov $0xc4,%ebx <== NOT EXECUTED 10ae55: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED 10ae59: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED 10ae5d: c7 04 24 d8 ff 12 00 movl $0x12ffd8,(%esp) <== NOT EXECUTED 10ae64: e8 07 2e 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED for_each_inode(i, c, ic) { 10ae69: 31 db xor %ebx,%ebx <== NOT EXECUTED 10ae6b: e9 7c fb ff ff jmp 10a9ec <== NOT EXECUTED for_each_inode(i, c, ic) { 10ae70: 31 ff xor %edi,%edi <== NOT EXECUTED return NULL; 10ae72: 31 f6 xor %esi,%esi <== NOT EXECUTED 10ae74: e9 33 fb ff ff jmp 10a9ac <== NOT EXECUTED return -ENOMEM; 10ae79: c7 45 cc f4 ff ff ff movl $0xfffffff4,-0x34(%ebp) <== NOT EXECUTED 10ae80: e9 7d fe ff ff jmp 10ad02 <== NOT EXECUTED 10ae85: 90 nop 10ae86: 90 nop 10ae87: 90 nop 10ae88: 90 nop 10ae89: 90 nop 10ae8a: 90 nop 10ae8b: 90 nop 10ae8c: 90 nop 10ae8d: 90 nop 10ae8e: 90 nop 10ae8f: 90 nop =============================================================================== 001095e0 : #include "compr.h" int jffs2_do_new_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint32_t mode, struct jffs2_raw_inode *ri) { 1095e0: 55 push %ebp 1095e1: 89 e5 mov %esp,%ebp 1095e3: 57 push %edi 1095e4: 56 push %esi 1095e5: 53 push %ebx 1095e6: 83 ec 2c sub $0x2c,%esp 1095e9: 8b 5d 0c mov 0xc(%ebp),%ebx 1095ec: 8b 75 14 mov 0x14(%ebp),%esi struct jffs2_inode_cache *ic; ic = jffs2_alloc_inode_cache(); 1095ef: e8 fc bc ff ff call 1052f0 if (!ic) { 1095f4: 85 c0 test %eax,%eax 1095f6: 0f 84 44 01 00 00 je 109740 <== NEVER TAKEN return -ENOMEM; } memset(ic, 0, sizeof(*ic)); 1095fc: a8 01 test $0x1,%al 1095fe: 89 c2 mov %eax,%edx 109600: bf 18 00 00 00 mov $0x18,%edi 109605: 0f 85 25 01 00 00 jne 109730 <== NEVER TAKEN 10960b: f6 c2 02 test $0x2,%dl 10960e: 0f 85 0c 01 00 00 jne 109720 <== NEVER TAKEN 109614: 89 f9 mov %edi,%ecx 109616: 83 e1 f8 and $0xfffffff8,%ecx 109619: 89 4d e4 mov %ecx,-0x1c(%ebp) 10961c: 31 c9 xor %ecx,%ecx 10961e: c7 04 0a 00 00 00 00 movl $0x0,(%edx,%ecx,1) 109625: c7 44 0a 04 00 00 00 movl $0x0,0x4(%edx,%ecx,1) 10962c: 00 10962d: 83 c1 08 add $0x8,%ecx 109630: 3b 4d e4 cmp -0x1c(%ebp),%ecx 109633: 72 e9 jb 10961e 109635: 01 ca add %ecx,%edx 109637: f7 c7 04 00 00 00 test $0x4,%edi 10963d: 0f 85 bd 00 00 00 jne 109700 <== NEVER TAKEN 109643: f7 c7 02 00 00 00 test $0x2,%edi 109649: 0f 85 91 00 00 00 jne 1096e0 <== NEVER TAKEN 10964f: 83 e7 01 and $0x1,%edi 109652: 75 7c jne 1096d0 <== NEVER TAKEN f->inocache = ic; 109654: 89 43 14 mov %eax,0x14(%ebx) <== NOT EXECUTED f->inocache->pino_nlink = 1; /* Will be overwritten shortly for directories */ 109657: c7 40 14 01 00 00 00 movl $0x1,0x14(%eax) <== NOT EXECUTED f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache; 10965e: 89 40 04 mov %eax,0x4(%eax) <== NOT EXECUTED f->inocache->state = INO_STATE_PRESENT; 109661: 66 c7 40 0a 02 00 movw $0x2,0xa(%eax) <== NOT EXECUTED jffs2_add_ino_cache(c, f->inocache); 109667: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10966b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10966e: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 109671: e8 3a c5 ff ff call 105bb0 <== NOT EXECUTED jffs2_dbg(1, "%s(): Assigned ino# %d\n", __func__, f->inocache->ino); ri->ino = cpu_to_je32(f->inocache->ino); 109676: 8b 43 14 mov 0x14(%ebx),%eax 109679: 8b 40 0c mov 0xc(%eax),%eax ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 10967c: c7 06 85 19 02 e0 movl $0xe0021985,(%esi) ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); ri->totlen = cpu_to_je32(PAD(sizeof(*ri))); 109682: c7 46 04 44 00 00 00 movl $0x44,0x4(%esi) ri->ino = cpu_to_je32(f->inocache->ino); 109689: 89 46 0c mov %eax,0xc(%esi) ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)); 10968c: b8 08 00 00 00 mov $0x8,%eax 109691: 89 44 24 08 mov %eax,0x8(%esp) 109695: 89 74 24 04 mov %esi,0x4(%esp) 109699: c7 04 24 00 00 00 00 movl $0x0,(%esp) 1096a0: e8 eb 17 00 00 call 10ae90 1096a5: 89 46 08 mov %eax,0x8(%esi) return osmode & (S_IFMT | S_IRWXU | S_IRWXG | S_IRWXO); 1096a8: 8b 45 10 mov 0x10(%ebp),%eax 1096ab: 25 ff f1 00 00 and $0xf1ff,%eax 1096b0: 89 46 14 mov %eax,0x14(%esi) ri->mode = cpu_to_jemode(mode); f->highest_version = 1; ri->version = cpu_to_je32(f->highest_version); return 0; 1096b3: 31 c0 xor %eax,%eax f->highest_version = 1; 1096b5: c7 03 01 00 00 00 movl $0x1,(%ebx) ri->version = cpu_to_je32(f->highest_version); 1096bb: c7 46 10 01 00 00 00 movl $0x1,0x10(%esi) } 1096c2: 83 c4 2c add $0x2c,%esp 1096c5: 5b pop %ebx 1096c6: 5e pop %esi 1096c7: 5f pop %edi 1096c8: 5d pop %ebp 1096c9: c3 ret 1096ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi memset(ic, 0, sizeof(*ic)); 1096d0: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED 1096d3: e9 7c ff ff ff jmp 109654 <== NOT EXECUTED 1096d8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 1096df: 90 nop <== NOT EXECUTED 1096e0: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED 1096e5: 83 c2 02 add $0x2,%edx <== NOT EXECUTED 1096e8: 83 e7 01 and $0x1,%edi <== NOT EXECUTED 1096eb: 0f 84 63 ff ff ff je 109654 <== NOT EXECUTED 1096f1: eb dd jmp 1096d0 <== NOT EXECUTED 1096f3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 1096fa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED 109700: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED 109706: 83 c2 04 add $0x4,%edx <== NOT EXECUTED 109709: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED 10970f: 0f 84 3a ff ff ff je 10964f <== NOT EXECUTED 109715: eb c9 jmp 1096e0 <== NOT EXECUTED 109717: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10971e: 66 90 xchg %ax,%ax <== NOT EXECUTED 109720: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED 109725: 83 ef 02 sub $0x2,%edi <== NOT EXECUTED 109728: 83 c2 02 add $0x2,%edx <== NOT EXECUTED 10972b: e9 e4 fe ff ff jmp 109614 <== NOT EXECUTED 109730: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED 109733: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED 109736: bf 17 00 00 00 mov $0x17,%edi <== NOT EXECUTED 10973b: e9 cb fe ff ff jmp 10960b <== NOT EXECUTED return -ENOMEM; 109740: b8 f4 ff ff ff mov $0xfffffff4,%eax <== NOT EXECUTED 109745: e9 78 ff ff ff jmp 1096c2 <== NOT EXECUTED 10974a: 90 nop 10974b: 90 nop 10974c: 90 nop 10974d: 90 nop 10974e: 90 nop 10974f: 90 nop =============================================================================== 00109210 : /* Scan the list of all nodes present for this ino, build map of versions, etc. */ int jffs2_do_read_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f, uint32_t ino, struct jffs2_raw_inode *latest_node) { 109210: 55 push %ebp 109211: 89 e5 mov %esp,%ebp 109213: 57 push %edi 109214: 56 push %esi 109215: 53 push %ebx 109216: 83 ec 2c sub $0x2c,%esp 109219: 8b 45 14 mov 0x14(%ebp),%eax 10921c: 8b 5d 08 mov 0x8(%ebp),%ebx 10921f: 8b 75 0c mov 0xc(%ebp),%esi 109222: 8b 7d 10 mov 0x10(%ebp),%edi 109225: 89 45 e0 mov %eax,-0x20(%ebp) dbg_readinode("read inode #%u\n", ino); retry_inocache: spin_lock(&c->inocache_lock); f->inocache = jffs2_get_ino_cache(c, ino); 109228: 89 7c 24 04 mov %edi,0x4(%esp) 10922c: 89 1c 24 mov %ebx,(%esp) 10922f: e8 1c c9 ff ff call 105b50 109234: 89 46 14 mov %eax,0x14(%esi) if (f->inocache) { 109237: 85 c0 test %eax,%eax 109239: 74 39 je 109274 /* Check its state. We may need to wait before we can use it */ switch(f->inocache->state) { 10923b: 0f b7 50 0a movzwl 0xa(%eax),%edx 10923f: 83 fa 05 cmp $0x5,%edx 109242: 0f 87 99 01 00 00 ja 1093e1 <== NEVER TAKEN 109248: ff 24 95 78 fc 12 00 jmp *0x12fc78(,%edx,4) 10924f: 90 nop 109250: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED case INO_STATE_READING: case INO_STATE_PRESENT: /* Eep. This should never happen. It can happen if Linux calls read_inode() again before clear_inode() has finished though. */ JFFS2_ERROR("Eep. Trying to read_inode #%u when it's already in state %d!\n", ino, f->inocache->state); 109254: b9 48 fd 12 00 mov $0x12fd48,%ecx <== NOT EXECUTED 109259: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED 10925d: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED 109261: c7 04 24 a4 fb 12 00 movl $0x12fba4,(%esp) <== NOT EXECUTED 109268: e8 23 e4 ff ff call 107690 <== NOT EXECUTED /* Fail. That's probably better than allowing it to succeed */ f->inocache = NULL; 10926d: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED BUG(); } } spin_unlock(&c->inocache_lock); if (!f->inocache && ino == 1) { 109274: 83 ff 01 cmp $0x1,%edi 109277: 0f 85 44 01 00 00 jne 1093c1 <== NEVER TAKEN /* Special case - no root inode on medium */ f->inocache = jffs2_alloc_inode_cache(); 10927d: e8 6e c0 ff ff call 1052f0 109282: 89 46 14 mov %eax,0x14(%esi) if (!f->inocache) { 109285: 85 c0 test %eax,%eax 109287: 0f 84 13 01 00 00 je 1093a0 <== NEVER TAKEN JFFS2_ERROR("cannot allocate inocache for root inode\n"); return -ENOMEM; } dbg_readinode("creating inocache for root inode\n"); memset(f->inocache, 0, sizeof(struct jffs2_inode_cache)); 10928d: c7 45 e4 18 00 00 00 movl $0x18,-0x1c(%ebp) 109294: 31 c9 xor %ecx,%ecx 109296: a8 01 test $0x1,%al 109298: 0f 85 f2 00 00 00 jne 109390 <== NEVER TAKEN 10929e: a8 02 test $0x2,%al 1092a0: 0f 85 ca 00 00 00 jne 109370 <== NEVER TAKEN 1092a6: 8b 55 e4 mov -0x1c(%ebp),%edx 1092a9: 83 e2 f8 and $0xfffffff8,%edx 1092ac: 89 55 dc mov %edx,-0x24(%ebp) 1092af: 31 d2 xor %edx,%edx 1092b1: 89 0c 10 mov %ecx,(%eax,%edx,1) 1092b4: 89 4c 10 04 mov %ecx,0x4(%eax,%edx,1) 1092b8: 83 c2 08 add $0x8,%edx 1092bb: 3b 55 dc cmp -0x24(%ebp),%edx 1092be: 72 f1 jb 1092b1 1092c0: 01 d0 add %edx,%eax 1092c2: f6 45 e4 04 testb $0x4,-0x1c(%ebp) 1092c6: 0f 85 84 00 00 00 jne 109350 <== NEVER TAKEN 1092cc: f6 45 e4 02 testb $0x2,-0x1c(%ebp) 1092d0: 75 6e jne 109340 <== NEVER TAKEN 1092d2: f6 45 e4 01 testb $0x1,-0x1c(%ebp) 1092d6: 75 58 jne 109330 <== NEVER TAKEN f->inocache->ino = f->inocache->pino_nlink = 1; 1092d8: 8b 46 14 mov 0x14(%esi),%eax 1092db: c7 40 14 01 00 00 00 movl $0x1,0x14(%eax) 1092e2: c7 40 0c 01 00 00 00 movl $0x1,0xc(%eax) f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache; 1092e9: 89 40 04 mov %eax,0x4(%eax) f->inocache->state = INO_STATE_READING; 1092ec: 66 c7 40 0a 05 00 movw $0x5,0xa(%eax) jffs2_add_ino_cache(c, f->inocache); 1092f2: 89 44 24 04 mov %eax,0x4(%esp) 1092f6: 89 1c 24 mov %ebx,(%esp) 1092f9: e8 b2 c8 ff ff call 105bb0 } if (!f->inocache) { 1092fe: 8b 56 14 mov 0x14(%esi),%edx 109301: 85 d2 test %edx,%edx 109303: 0f 84 b8 00 00 00 je 1093c1 <== NEVER TAKEN JFFS2_ERROR("requested to read a nonexistent ino %u\n", ino); return -ENOENT; } return jffs2_do_read_inode_internal(c, f, latest_node); 109309: 8b 4d e0 mov -0x20(%ebp),%ecx } 10930c: 83 c4 2c add $0x2c,%esp return jffs2_do_read_inode_internal(c, f, latest_node); 10930f: 89 d8 mov %ebx,%eax } 109311: 5b pop %ebx return jffs2_do_read_inode_internal(c, f, latest_node); 109312: 89 f2 mov %esi,%edx } 109314: 5e pop %esi 109315: 5f pop %edi 109316: 5d pop %ebp return jffs2_do_read_inode_internal(c, f, latest_node); 109317: e9 04 e6 ff ff jmp 107920 10931c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi f->inocache->state = INO_STATE_READING; 109320: 66 c7 40 0a 05 00 movw $0x5,0xa(%eax) if (!f->inocache) { 109326: eb e1 jmp 109309 109328: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10932f: 90 nop memset(f->inocache, 0, sizeof(struct jffs2_inode_cache)); 109330: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED 109333: eb a3 jmp 1092d8 <== NOT EXECUTED 109335: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10933c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 109340: 66 c7 00 00 00 movw $0x0,(%eax) <== NOT EXECUTED 109345: 83 c0 02 add $0x2,%eax <== NOT EXECUTED 109348: f6 45 e4 01 testb $0x1,-0x1c(%ebp) <== NOT EXECUTED 10934c: 74 8a je 1092d8 <== NOT EXECUTED 10934e: eb e0 jmp 109330 <== NOT EXECUTED 109350: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 109356: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 109359: f6 45 e4 02 testb $0x2,-0x1c(%ebp) <== NOT EXECUTED 10935d: 0f 84 6f ff ff ff je 1092d2 <== NOT EXECUTED 109363: eb db jmp 109340 <== NOT EXECUTED 109365: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10936c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 109370: 66 c7 00 00 00 movw $0x0,(%eax) <== NOT EXECUTED 109375: 83 c0 02 add $0x2,%eax <== NOT EXECUTED 109378: 83 6d e4 02 subl $0x2,-0x1c(%ebp) <== NOT EXECUTED 10937c: e9 25 ff ff ff jmp 1092a6 <== NOT EXECUTED 109381: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 109388: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10938f: 90 nop <== NOT EXECUTED 109390: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED 109393: 40 inc %eax <== NOT EXECUTED 109394: c7 45 e4 17 00 00 00 movl $0x17,-0x1c(%ebp) <== NOT EXECUTED 10939b: e9 fe fe ff ff jmp 10929e <== NOT EXECUTED JFFS2_ERROR("cannot allocate inocache for root inode\n"); 1093a0: c7 44 24 04 48 fd 12 movl $0x12fd48,0x4(%esp) <== NOT EXECUTED 1093a7: 00 1093a8: c7 04 24 f8 fb 12 00 movl $0x12fbf8,(%esp) <== NOT EXECUTED 1093af: e8 dc e2 ff ff call 107690 <== NOT EXECUTED return -ENOMEM; 1093b4: b8 f4 ff ff ff mov $0xfffffff4,%eax <== NOT EXECUTED } 1093b9: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED 1093bc: 5b pop %ebx <== NOT EXECUTED 1093bd: 5e pop %esi <== NOT EXECUTED 1093be: 5f pop %edi <== NOT EXECUTED 1093bf: 5d pop %ebp <== NOT EXECUTED 1093c0: c3 ret <== NOT EXECUTED JFFS2_ERROR("requested to read a nonexistent ino %u\n", ino); 1093c1: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED 1093c5: b8 48 fd 12 00 mov $0x12fd48,%eax <== NOT EXECUTED 1093ca: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 1093ce: c7 04 24 38 fc 12 00 movl $0x12fc38,(%esp) <== NOT EXECUTED 1093d5: e8 b6 e2 ff ff call 107690 <== NOT EXECUTED return -ENOENT; 1093da: b8 fe ff ff ff mov $0xfffffffe,%eax <== NOT EXECUTED 1093df: eb d8 jmp 1093b9 <== NOT EXECUTED BUG(); 1093e1: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED 1093e8: 00 1093e9: c7 44 24 08 48 fd 12 movl $0x12fd48,0x8(%esp) <== NOT EXECUTED 1093f0: 00 1093f1: c7 44 24 04 5a 05 00 movl $0x55a,0x4(%esp) <== NOT EXECUTED 1093f8: 00 1093f9: c7 04 24 bc f1 12 00 movl $0x12f1bc,(%esp) <== NOT EXECUTED 109400: e8 6b 48 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED 109405: 90 nop 109406: 90 nop 109407: 90 nop 109408: 90 nop 109409: 90 nop 10940a: 90 nop 10940b: 90 nop 10940c: 90 nop 10940d: 90 nop 10940e: 90 nop 10940f: 90 nop =============================================================================== 0010a450 : int jffs2_do_unlink(struct jffs2_sb_info *c, struct jffs2_inode_info *dir_f, const char *name, int namelen, struct jffs2_inode_info *dead_f, uint32_t time) { 10a450: 55 push %ebp 10a451: 89 e5 mov %esp,%ebp 10a453: 57 push %edi 10a454: 56 push %esi 10a455: 53 push %ebx 10a456: 83 ec 2c sub $0x2c,%esp 10a459: 8b 7d 14 mov 0x14(%ebp),%edi while (len--) { 10a45c: 85 ff test %edi,%edi 10a45e: 0f 84 4f 01 00 00 je 10a5b3 <== NEVER TAKEN 10a464: 8b 55 10 mov 0x10(%ebp),%edx uint32_t hash = 0; 10a467: 31 db xor %ebx,%ebx while (len--) { 10a469: 8b 45 10 mov 0x10(%ebp),%eax 10a46c: 01 fa add %edi,%edx 10a46e: 66 90 xchg %ax,%ax hash ^= *(name++); 10a470: 0f b6 08 movzbl (%eax),%ecx hash = (hash << 4) | (hash >> 28); 10a473: c1 c3 04 rol $0x4,%ebx hash ^= *(name++); 10a476: 40 inc %eax 10a477: 31 cb xor %ecx,%ebx while (len--) { 10a479: 39 d0 cmp %edx,%eax 10a47b: 75 f3 jne 10a470 jffs2_add_fd_to_list(c, fd, &dir_f->dents); mutex_unlock(&dir_f->sem); } else { uint32_t nhash = full_name_hash(NULL, name, namelen); fd = dir_f->dents; 10a47d: 8b 45 0c mov 0xc(%ebp),%eax 10a480: 8b 70 0c mov 0xc(%eax),%esi /* We don't actually want to reserve any space, but we do want to be holding the alloc_sem when we write to flash */ mutex_lock(&c->alloc_sem); mutex_lock(&dir_f->sem); for (fd = dir_f->dents; fd; fd = fd->next) { 10a483: 85 f6 test %esi,%esi 10a485: 75 10 jne 10a497 <== ALWAYS TAKEN 10a487: eb 57 jmp 10a4e0 <== NOT EXECUTED 10a489: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10a490: 8b 76 04 mov 0x4(%esi),%esi 10a493: 85 f6 test %esi,%esi 10a495: 74 49 je 10a4e0 <== NEVER TAKEN if (fd->nhash == nhash && 10a497: 39 5e 10 cmp %ebx,0x10(%esi) 10a49a: 75 f4 jne 10a490 !memcmp(fd->name, name, namelen) && 10a49c: 89 7c 24 08 mov %edi,0x8(%esp) 10a4a0: 8b 45 10 mov 0x10(%ebp),%eax 10a4a3: 89 44 24 04 mov %eax,0x4(%esp) 10a4a7: 8d 46 15 lea 0x15(%esi),%eax 10a4aa: 89 04 24 mov %eax,(%esp) 10a4ad: e8 6d c6 01 00 call 126b1f if (fd->nhash == nhash && 10a4b2: 85 c0 test %eax,%eax 10a4b4: 75 da jne 10a490 <== NEVER TAKEN !memcmp(fd->name, name, namelen) && 10a4b6: 80 7c 3e 15 00 cmpb $0x0,0x15(%esi,%edi,1) 10a4bb: 75 d3 jne 10a490 <== NEVER TAKEN !fd->name[namelen]) { jffs2_dbg(1, "Marking old dirent node (ino #%u) @%08x obsolete\n", fd->ino, ref_offset(fd->raw)); jffs2_mark_node_obsolete(c, fd->raw); 10a4bd: 8b 06 mov (%esi),%eax 10a4bf: 89 44 24 04 mov %eax,0x4(%esp) 10a4c3: 8b 45 08 mov 0x8(%ebp),%eax 10a4c6: 89 04 24 mov %eax,(%esp) 10a4c9: e8 f2 be ff ff call 1063c0 /* We don't want to remove it from the list immediately, because that screws up getdents()/seek() semantics even more than they're screwed already. Turn it into a node-less deletion dirent instead -- a placeholder */ fd->raw = NULL; 10a4ce: c7 06 00 00 00 00 movl $0x0,(%esi) fd->ino = 0; 10a4d4: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) break; 10a4db: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10a4df: 90 nop } /* dead_f is NULL if this was a rename not a real unlink */ /* Also catch the !f->inocache case, where there was a dirent pointing to an inode which didn't exist. */ if (dead_f && dead_f->inocache) { 10a4e0: 8b 45 18 mov 0x18(%ebp),%eax 10a4e3: 85 c0 test %eax,%eax 10a4e5: 74 26 je 10a50d <== NEVER TAKEN 10a4e7: 8b 45 18 mov 0x18(%ebp),%eax 10a4ea: 8b 40 14 mov 0x14(%eax),%eax 10a4ed: 85 c0 test %eax,%eax 10a4ef: 74 1c je 10a50d <== NEVER TAKEN mutex_lock(&dead_f->sem); if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) { 10a4f1: 8b 55 18 mov 0x18(%ebp),%edx 10a4f4: 8b 4a c4 mov -0x3c(%edx),%ecx 10a4f7: 89 4d e4 mov %ecx,-0x1c(%ebp) 10a4fa: 89 ca mov %ecx,%edx 10a4fc: 81 e2 00 f0 00 00 and $0xf000,%edx 10a502: 81 fa 00 40 00 00 cmp $0x4000,%edx 10a508: 74 26 je 10a530 jffs2_mark_node_obsolete(c, fd->raw); jffs2_free_full_dirent(fd); } dead_f->inocache->pino_nlink = 0; } else dead_f->inocache->pino_nlink--; 10a50a: ff 48 14 decl 0x14(%eax) /* NB: Caller must set inode nlink if appropriate */ mutex_unlock(&dead_f->sem); } jffs2_complete_reservation(c); 10a50d: 8b 45 08 mov 0x8(%ebp),%eax 10a510: 89 04 24 mov %eax,(%esp) 10a513: e8 78 be ff ff call 106390 return 0; } 10a518: 83 c4 2c add $0x2c,%esp 10a51b: 31 c0 xor %eax,%eax 10a51d: 5b pop %ebx 10a51e: 5e pop %esi 10a51f: 5f pop %edi 10a520: 5d pop %ebp 10a521: c3 ret 10a522: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10a529: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi while (dead_f->dents) { 10a530: 8b 7d 18 mov 0x18(%ebp),%edi 10a533: 8b 5f 0c mov 0xc(%edi),%ebx 10a536: 85 db test %ebx,%ebx 10a538: 74 6d je 10a5a7 <== ALWAYS TAKEN 10a53a: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10a53d: 8b 75 18 mov 0x18(%ebp),%esi <== NOT EXECUTED 10a540: eb 2f jmp 10a571 <== NOT EXECUTED 10a542: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10a549: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED if (fd->raw) 10a550: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10a552: 85 c0 test %eax,%eax <== NOT EXECUTED 10a554: 74 0c je 10a562 <== NOT EXECUTED jffs2_mark_node_obsolete(c, fd->raw); 10a556: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10a55a: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10a55d: e8 5e be ff ff call 1063c0 <== NOT EXECUTED jffs2_free_full_dirent(fd); 10a562: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a565: e8 c6 ab ff ff call 105130 <== NOT EXECUTED while (dead_f->dents) { 10a56a: 8b 5e 0c mov 0xc(%esi),%ebx <== NOT EXECUTED 10a56d: 85 db test %ebx,%ebx <== NOT EXECUTED 10a56f: 74 30 je 10a5a1 <== NOT EXECUTED dead_f->dents = fd->next; 10a571: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10a574: 89 46 0c mov %eax,0xc(%esi) <== NOT EXECUTED if (fd->ino) { 10a577: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10a57a: 85 c0 test %eax,%eax <== NOT EXECUTED 10a57c: 74 d2 je 10a550 <== NOT EXECUTED pr_warn("Deleting inode #%u with active dentry \"%s\"->ino #%u\n", 10a57e: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 10a582: 8d 43 15 lea 0x15(%ebx),%eax <== NOT EXECUTED 10a585: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 10a589: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED 10a58c: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10a58f: c7 04 24 0c ff 12 00 movl $0x12ff0c,(%esp) <== NOT EXECUTED 10a596: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10a59a: e8 21 f0 ff ff call 1095c0 <== NOT EXECUTED 10a59f: eb af jmp 10a550 <== NOT EXECUTED dead_f->inocache->pino_nlink = 0; 10a5a1: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10a5a4: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10a5a7: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax) 10a5ae: e9 5a ff ff ff jmp 10a50d uint32_t hash = 0; 10a5b3: 31 db xor %ebx,%ebx 10a5b5: e9 c3 fe ff ff jmp 10a47d <== NOT EXECUTED 10a5ba: 90 nop 10a5bb: 90 nop 10a5bc: 90 nop 10a5bd: 90 nop 10a5be: 90 nop 10a5bf: 90 nop =============================================================================== 0010bd30 : { 10bd30: 55 push %ebp 10bd31: 89 e5 mov %esp,%ebp 10bd33: 57 push %edi 10bd34: 56 push %esi 10bd35: 53 push %ebx 10bd36: 83 ec 6c sub $0x6c,%esp int work_done = 0; 10bd39: c7 45 b8 00 00 00 00 movl $0x0,-0x48(%ebp) { 10bd40: 8b 7d 08 mov 0x8(%ebp),%edi while (!list_empty(&c->erase_complete_list) || 10bd43: 8d 87 a0 00 00 00 lea 0xa0(%edi),%eax 10bd49: 89 45 bc mov %eax,-0x44(%ebp) !list_empty(&c->erase_pending_list)) { 10bd4c: 8d 87 98 00 00 00 lea 0x98(%edi),%eax 10bd52: 89 45 b0 mov %eax,-0x50(%ebp) list_add(&jeb->list, &c->erasing_list); 10bd55: 8d 87 88 00 00 00 lea 0x88(%edi),%eax 10bd5b: 89 45 b4 mov %eax,-0x4c(%ebp) 10bd5e: 66 90 xchg %ax,%ax return ( list->next == list ); 10bd60: 8b 87 a0 00 00 00 mov 0xa0(%edi),%eax while (!list_empty(&c->erase_complete_list) || 10bd66: 3b 45 bc cmp -0x44(%ebp),%eax 10bd69: 89 45 c4 mov %eax,-0x3c(%ebp) 10bd6c: 0f 84 ae 01 00 00 je 10bf20 ent->prev->next = ent->next; 10bd72: 8b 5d c4 mov -0x3c(%ebp),%ebx 10bd75: 8b 53 04 mov 0x4(%ebx),%edx 10bd78: 8b 03 mov (%ebx),%eax 10bd7a: 89 02 mov %eax,(%edx) ent->next->prev = ent->prev; 10bd7c: 89 50 04 mov %edx,0x4(%eax) struct list_head *next = afterthisent->next; 10bd7f: 8b 87 90 00 00 00 mov 0x90(%edi),%eax list_move(&jeb->list, &c->erase_checking_list); 10bd85: 8d 97 90 00 00 00 lea 0x90(%edi),%edx 10bd8b: 89 53 04 mov %edx,0x4(%ebx) newent->next = next; 10bd8e: 89 03 mov %eax,(%ebx) afterthisent->next = newent; 10bd90: 89 9f 90 00 00 00 mov %ebx,0x90(%edi) next->prev = newent; 10bd96: 89 58 04 mov %ebx,0x4(%eax) return -EIO; } return 0; } do_flash_read: ebuf = kmalloc(PAGE_SIZE, GFP_KERNEL); 10bd99: c7 04 24 00 10 00 00 movl $0x1000,(%esp) #define MTD_FAIL_ADDR_UNKNOWN -1LL static inline int do_mtd_point(size_t *retlen, void **ebuf) { *retlen = 0; 10bda0: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) 10bda7: e8 74 27 00 00 call 10e520 if (!ebuf) { pr_warn("Failed to allocate page buffer for verifying erase at 0x%08x. Refiling\n", 10bdac: 8b 53 0c mov 0xc(%ebx),%edx if (!ebuf) { 10bdaf: 85 c0 test %eax,%eax ebuf = kmalloc(PAGE_SIZE, GFP_KERNEL); 10bdb1: 89 c6 mov %eax,%esi if (!ebuf) { 10bdb3: 0f 84 52 02 00 00 je 10c00b <== NEVER TAKEN return -EAGAIN; } jffs2_dbg(1, "Verifying erase at 0x%08x\n", jeb->offset); for (ofs = jeb->offset; ofs < jeb->offset + c->sector_size; ) { 10bdb9: 8b 5f 34 mov 0x34(%edi),%ebx 10bdbc: 8d 45 dc lea -0x24(%ebp),%eax 10bdbf: 89 45 c0 mov %eax,-0x40(%ebp) 10bdc2: 01 d3 add %edx,%ebx 10bdc4: 39 d3 cmp %edx,%ebx 10bdc6: 0f 86 eb 00 00 00 jbe 10beb7 <== NEVER TAKEN 10bdcc: 89 7d 08 mov %edi,0x8(%ebp) 10bdcf: 89 d7 mov %edx,%edi 10bdd1: 8b 55 08 mov 0x8(%ebp),%edx uint32_t readlen = min((uint32_t)PAGE_SIZE, jeb->offset + c->sector_size - ofs); 10bdd4: 29 fb sub %edi,%ebx 10bdd6: 81 fb 00 10 00 00 cmp $0x1000,%ebx 10bddc: 76 05 jbe 10bde3 10bdde: bb 00 10 00 00 mov $0x1000,%ebx int i; *bad_offset = ofs; ret = jffs2_flash_read(c, ofs, readlen, &retlen, ebuf); 10bde3: 89 14 24 mov %edx,(%esp) 10bde6: 8b 45 c0 mov -0x40(%ebp),%eax 10bde9: 89 74 24 10 mov %esi,0x10(%esp) 10bded: 89 5c 24 08 mov %ebx,0x8(%esp) 10bdf1: 89 7c 24 04 mov %edi,0x4(%esp) 10bdf5: 89 44 24 0c mov %eax,0xc(%esp) 10bdf9: 89 55 08 mov %edx,0x8(%ebp) 10bdfc: e8 5f 04 00 00 call 10c260 if (ret) { 10be01: 8b 55 08 mov 0x8(%ebp),%edx 10be04: 85 c0 test %eax,%eax 10be06: 0f 85 e1 03 00 00 jne 10c1ed <== NEVER TAKEN pr_warn("Read of newly-erased block at 0x%08x failed: %d. Putting on bad_list\n", ofs, ret); ret = -EIO; goto fail; } if (retlen != readlen) { 10be0c: 8b 45 dc mov -0x24(%ebp),%eax 10be0f: 39 c3 cmp %eax,%ebx 10be11: 0f 85 fc 03 00 00 jne 10c213 <== NEVER TAKEN 10be17: 31 c0 xor %eax,%eax 10be19: eb 0c jmp 10be27 10be1b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10be1f: 90 nop pr_warn("Short read from newly-erased block at 0x%08x. Wanted %d, got %zd\n", ofs, readlen, retlen); ret = -EIO; goto fail; } for (i=0; i /* It's OK. We know it's properly aligned */ unsigned long *datum = ebuf + i; if (*datum + 1) { 10be27: 8b 0c 06 mov (%esi,%eax,1),%ecx 10be2a: 83 f9 ff cmp $0xffffffff,%ecx 10be2d: 74 f1 je 10be20 <== ALWAYS TAKEN *bad_offset += i; 10be2f: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED 10be32: 89 fa mov %edi,%edx <== NOT EXECUTED pr_warn("Newly-erased block contained word 0x%lx at offset 0x%08x\n", 10be34: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED *bad_offset += i; 10be38: 01 d0 add %edx,%eax <== NOT EXECUTED 10be3a: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED pr_warn("Newly-erased block contained word 0x%lx at offset 0x%08x\n", 10be3d: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 10be41: c7 04 24 18 08 13 00 movl $0x130818,(%esp) <== NOT EXECUTED 10be48: e8 93 fd ff ff call 10bbe0 <== NOT EXECUTED ofs += readlen; cond_resched(); } ret = 0; fail: kfree(ebuf); 10be4d: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10be50: e8 db 22 00 00 call 10e130 <== NOT EXECUTED ent->prev->next = ent->next; 10be55: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED c->erasing_size -= c->sector_size; 10be58: 8b 47 34 mov 0x34(%edi),%eax <== NOT EXECUTED 10be5b: 29 47 2c sub %eax,0x2c(%edi) <== NOT EXECUTED c->bad_size += c->sector_size; 10be5e: 01 47 30 add %eax,0x30(%edi) <== NOT EXECUTED 10be61: 8b 51 04 mov 0x4(%ecx),%edx <== NOT EXECUTED 10be64: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10be66: 89 02 mov %eax,(%edx) <== NOT EXECUTED ent->next->prev = ent->prev; 10be68: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED struct list_head *next = afterthisent->next; 10be6b: 8b 87 b0 00 00 00 mov 0xb0(%edi),%eax <== NOT EXECUTED list_move(&jeb->list, &c->bad_list); 10be71: 8d 97 b0 00 00 00 lea 0xb0(%edi),%edx <== NOT EXECUTED 10be77: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED newent->next = next; 10be7a: 89 01 mov %eax,(%ecx) <== NOT EXECUTED afterthisent->next = newent; 10be7c: 89 8f b0 00 00 00 mov %ecx,0xb0(%edi) <== NOT EXECUTED next->prev = newent; 10be82: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED c->nr_erasing_blocks--; 10be85: ff 4f 40 decl 0x40(%edi) <== NOT EXECUTED work_done++; 10be88: ff 45 b8 incl -0x48(%ebp) if (!--count) { 10be8b: ff 4d 0c decl 0xc(%ebp) 10be8e: 0f 85 cc fe ff ff jne 10bd60 } 10be94: 8b 45 b8 mov -0x48(%ebp),%eax 10be97: 83 c4 6c add $0x6c,%esp 10be9a: 5b pop %ebx 10be9b: 5e pop %esi 10be9c: 5f pop %edi 10be9d: 5d pop %ebp 10be9e: c3 ret 10be9f: 90 nop for (ofs = jeb->offset; ofs < jeb->offset + c->sector_size; ) { 10bea0: 8b 45 c4 mov -0x3c(%ebp),%eax ofs += readlen; 10bea3: 01 df add %ebx,%edi for (ofs = jeb->offset; ofs < jeb->offset + c->sector_size; ) { 10bea5: 8b 5a 34 mov 0x34(%edx),%ebx 10bea8: 8b 48 0c mov 0xc(%eax),%ecx 10beab: 01 cb add %ecx,%ebx 10bead: 39 fb cmp %edi,%ebx 10beaf: 0f 87 1f ff ff ff ja 10bdd4 10beb5: 89 d7 mov %edx,%edi kfree(ebuf); 10beb7: 89 34 24 mov %esi,(%esp) 10beba: e8 71 22 00 00 call 10e130 /* Write the erase complete marker */ jffs2_dbg(1, "Writing erased marker to block at 0x%08x\n", jeb->offset); bad_offset = jeb->offset; /* Cleanmarker in oob area or no cleanmarker at all ? */ if (jffs2_cleanmarker_oob(c) || c->cleanmarker_size == 0) { 10bebf: 8b 47 14 mov 0x14(%edi),%eax 10bec2: 85 c0 test %eax,%eax 10bec4: 0f 85 2b 02 00 00 jne 10c0f5 <== ALWAYS TAKEN goto filebad; } } /* Everything else got zeroed before the erase */ jeb->free_size = c->sector_size; 10beca: 8b 47 34 mov 0x34(%edi),%eax <== NOT EXECUTED 10becd: 8b 55 c4 mov -0x3c(%ebp),%edx <== NOT EXECUTED 10bed0: 89 42 20 mov %eax,0x20(%edx) <== NOT EXECUTED mutex_lock(&c->erase_free_sem); spin_lock(&c->erase_completion_lock); c->erasing_size -= c->sector_size; 10bed3: 29 47 2c sub %eax,0x2c(%edi) <== NOT EXECUTED c->free_size += c->sector_size; 10bed6: 01 47 28 add %eax,0x28(%edi) <== NOT EXECUTED ent->prev->next = ent->next; 10bed9: 8b 75 c4 mov -0x3c(%ebp),%esi 10bedc: 8b 56 04 mov 0x4(%esi),%edx 10bedf: 8b 06 mov (%esi),%eax 10bee1: 89 02 mov %eax,(%edx) ent->next->prev = ent->prev; 10bee3: 89 50 04 mov %edx,0x4(%eax) /* Account for cleanmarker now, if it's in-band */ if (c->cleanmarker_size && !jffs2_cleanmarker_oob(c)) jffs2_link_node_ref(c, jeb, jeb->offset | REF_NORMAL, c->cleanmarker_size, NULL); list_move_tail(&jeb->list, &c->free_list); 10bee6: 8d 97 a8 00 00 00 lea 0xa8(%edi),%edx struct list_head *prev = beforethisent->prev; 10beec: 8b 87 ac 00 00 00 mov 0xac(%edi),%eax 10bef2: 89 16 mov %edx,(%esi) newent->prev = prev; 10bef4: 89 46 04 mov %eax,0x4(%esi) beforethisent->prev = newent; 10bef7: 89 b7 ac 00 00 00 mov %esi,0xac(%edi) prev->next = newent; 10befd: 89 30 mov %esi,(%eax) c->nr_erasing_blocks--; 10beff: ff 4f 40 decl 0x40(%edi) c->nr_free_blocks++; 10bf02: ff 47 3c incl 0x3c(%edi) jffs2_dbg_acct_sanity_check_nolock(c, jeb); 10bf05: 89 74 24 04 mov %esi,0x4(%esp) 10bf09: 89 3c 24 mov %edi,(%esp) 10bf0c: e8 4f f2 ff ff call 10b160 <__jffs2_dbg_acct_sanity_check_nolock> jffs2_dbg_acct_paranoia_check_nolock(c, jeb); spin_unlock(&c->erase_completion_lock); mutex_unlock(&c->erase_free_sem); wake_up(&c->erase_wait); 10bf11: e9 72 ff ff ff jmp 10be88 10bf16: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10bf1d: 8d 76 00 lea 0x0(%esi),%esi return ( list->next == list ); 10bf20: 8b 9f 98 00 00 00 mov 0x98(%edi),%ebx while (!list_empty(&c->erase_complete_list) || 10bf26: 39 5d b0 cmp %ebx,-0x50(%ebp) 10bf29: 0f 84 65 ff ff ff je 10be94 ent->prev->next = ent->next; 10bf2f: 8b 53 04 mov 0x4(%ebx),%edx 10bf32: 8b 03 mov (%ebx),%eax 10bf34: 89 02 mov %eax,(%edx) ent->next->prev = ent->prev; 10bf36: 89 50 04 mov %edx,0x4(%eax) c->erasing_size += c->sector_size; 10bf39: 8b 47 34 mov 0x34(%edi),%eax 10bf3c: 01 47 2c add %eax,0x2c(%edi) c->wasted_size -= jeb->wasted_size; 10bf3f: 8b 43 1c mov 0x1c(%ebx),%eax 10bf42: 29 47 24 sub %eax,0x24(%edi) c->free_size -= jeb->free_size; 10bf45: 8b 43 20 mov 0x20(%ebx),%eax 10bf48: 29 47 28 sub %eax,0x28(%edi) c->used_size -= jeb->used_size; 10bf4b: 8b 43 14 mov 0x14(%ebx),%eax 10bf4e: 29 47 1c sub %eax,0x1c(%edi) c->dirty_size -= jeb->dirty_size; 10bf51: 8b 43 18 mov 0x18(%ebx),%eax 10bf54: 29 47 20 sub %eax,0x20(%edi) jeb->wasted_size = jeb->used_size = jeb->dirty_size = jeb->free_size = 0; 10bf57: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) 10bf5e: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) 10bf65: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) 10bf6c: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) jffs2_free_jeb_node_refs(c, jeb); 10bf73: 89 5c 24 04 mov %ebx,0x4(%esp) 10bf77: 89 3c 24 mov %edi,(%esp) 10bf7a: e8 81 fc ff ff call 10bc00 struct list_head *next = afterthisent->next; 10bf7f: 8b 87 88 00 00 00 mov 0x88(%edi),%eax list_add(&jeb->list, &c->erasing_list); 10bf85: 8b 55 b4 mov -0x4c(%ebp),%edx newent->next = next; 10bf88: 89 03 mov %eax,(%ebx) 10bf8a: 89 53 04 mov %edx,0x4(%ebx) afterthisent->next = newent; 10bf8d: 89 9f 88 00 00 00 mov %ebx,0x88(%edi) next->prev = newent; 10bf93: 89 58 04 mov %ebx,0x4(%eax) ret = jffs2_flash_erase(c, jeb); 10bf96: 89 5c 24 04 mov %ebx,0x4(%esp) 10bf9a: 89 3c 24 mov %edi,(%esp) 10bf9d: e8 2e 06 00 00 call 10c5d0 if (!ret) { 10bfa2: 85 c0 test %eax,%eax 10bfa4: 0f 84 f6 00 00 00 je 10c0a0 <== ALWAYS TAKEN if (ret == -ENOMEM || ret == -EAGAIN) { 10bfaa: 8d 50 0c lea 0xc(%eax),%edx <== NOT EXECUTED 10bfad: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 10bfb0: 0f 86 aa 00 00 00 jbe 10c060 <== NOT EXECUTED if (ret == -EROFS) 10bfb6: 83 f8 e2 cmp $0xffffffe2,%eax <== NOT EXECUTED bad_offset = jeb->offset; 10bfb9: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED if (ret == -EROFS) 10bfbc: 0f 84 1e 01 00 00 je 10c0e0 <== NOT EXECUTED pr_warn("Erase at 0x%08x failed immediately: errno %d\n", 10bfc2: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 10bfc6: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED 10bfca: c7 04 24 34 09 13 00 movl $0x130934,(%esp) <== NOT EXECUTED 10bfd1: e8 0a fc ff ff call 10bbe0 <== NOT EXECUTED c->erasing_size -= c->sector_size; 10bfd6: 8b 47 34 mov 0x34(%edi),%eax <== NOT EXECUTED ent->prev->next = ent->next; 10bfd9: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 10bfdc: 29 47 2c sub %eax,0x2c(%edi) <== NOT EXECUTED c->bad_size += c->sector_size; 10bfdf: 01 47 30 add %eax,0x30(%edi) <== NOT EXECUTED 10bfe2: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10bfe4: 89 02 mov %eax,(%edx) <== NOT EXECUTED ent->next->prev = ent->prev; 10bfe6: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED struct list_head *next = afterthisent->next; 10bfe9: 8b 87 b0 00 00 00 mov 0xb0(%edi),%eax <== NOT EXECUTED list_move(&jeb->list, &c->bad_list); 10bfef: 8d 97 b0 00 00 00 lea 0xb0(%edi),%edx <== NOT EXECUTED 10bff5: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED newent->next = next; 10bff8: 89 03 mov %eax,(%ebx) <== NOT EXECUTED afterthisent->next = newent; 10bffa: 89 9f b0 00 00 00 mov %ebx,0xb0(%edi) <== NOT EXECUTED next->prev = newent; 10c000: 89 58 04 mov %ebx,0x4(%eax) <== NOT EXECUTED c->nr_erasing_blocks--; 10c003: ff 4f 40 decl 0x40(%edi) <== NOT EXECUTED #define init_waitqueue_head(wait) do{} while (0) #define add_wait_queue(wait,new_wait) do{} while (0) #define remove_wait_queue(wait,old_wait) do{} while (0) #define DECLARE_WAITQUEUE(wait,current) do{} while (0) static inline void wake_up(wait_queue_head_t *erase_wait) { } 10c006: e9 55 fd ff ff jmp 10bd60 <== NOT EXECUTED pr_warn("Failed to allocate page buffer for verifying erase at 0x%08x. Refiling\n", 10c00b: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED 10c00f: c7 04 24 28 07 13 00 movl $0x130728,(%esp) <== NOT EXECUTED 10c016: e8 c5 fb ff ff call 10bbe0 <== NOT EXECUTED rtems_jffs2_flash_control *fc = sb->s_flash_control; 10c01b: 8b 97 e4 00 00 00 mov 0xe4(%edi),%edx <== NOT EXECUTED if (fc->trigger_garbage_collection != NULL) { 10c021: 8b 42 20 mov 0x20(%edx),%eax <== NOT EXECUTED 10c024: 85 c0 test %eax,%eax <== NOT EXECUTED 10c026: 74 05 je 10c02d <== NOT EXECUTED (*fc->trigger_garbage_collection)(fc); 10c028: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 10c02b: ff d0 call *%eax <== NOT EXECUTED ent->prev->next = ent->next; 10c02d: 8b 75 c4 mov -0x3c(%ebp),%esi <== NOT EXECUTED 10c030: 8b 56 04 mov 0x4(%esi),%edx <== NOT EXECUTED 10c033: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10c035: 89 02 mov %eax,(%edx) <== NOT EXECUTED ent->next->prev = ent->prev; 10c037: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED struct list_head *next = afterthisent->next; 10c03a: 8b 87 a0 00 00 00 mov 0xa0(%edi),%eax <== NOT EXECUTED newent->prev = afterthisent; 10c040: 8b 55 bc mov -0x44(%ebp),%edx <== NOT EXECUTED newent->next = next; 10c043: 89 06 mov %eax,(%esi) <== NOT EXECUTED newent->prev = afterthisent; 10c045: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED afterthisent->next = newent; 10c048: 89 b7 a0 00 00 00 mov %esi,0xa0(%edi) <== NOT EXECUTED next->prev = newent; 10c04e: 89 70 04 mov %esi,0x4(%eax) <== NOT EXECUTED mutex_lock(&c->erase_free_sem); spin_lock(&c->erase_completion_lock); jffs2_garbage_collect_trigger(c); list_move(&jeb->list, &c->erase_complete_list); spin_unlock(&c->erase_completion_lock); mutex_unlock(&c->erase_free_sem); 10c051: e9 32 fe ff ff jmp 10be88 <== NOT EXECUTED 10c056: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10c05d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ent->prev->next = ent->next; 10c060: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 10c063: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10c065: 89 02 mov %eax,(%edx) <== NOT EXECUTED ent->next->prev = ent->prev; 10c067: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED struct list_head *next = afterthisent->next; 10c06a: 8b 87 98 00 00 00 mov 0x98(%edi),%eax <== NOT EXECUTED newent->prev = afterthisent; 10c070: 8b 55 b0 mov -0x50(%ebp),%edx <== NOT EXECUTED newent->next = next; 10c073: 89 03 mov %eax,(%ebx) <== NOT EXECUTED newent->prev = afterthisent; 10c075: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED afterthisent->next = newent; 10c078: 89 9f 98 00 00 00 mov %ebx,0x98(%edi) <== NOT EXECUTED next->prev = newent; 10c07e: 89 58 04 mov %ebx,0x4(%eax) <== NOT EXECUTED c->erasing_size -= c->sector_size; 10c081: 8b 47 34 mov 0x34(%edi),%eax <== NOT EXECUTED 10c084: 29 47 2c sub %eax,0x2c(%edi) <== NOT EXECUTED c->dirty_size += c->sector_size; 10c087: 01 47 20 add %eax,0x20(%edi) <== NOT EXECUTED jeb->dirty_size = c->sector_size; 10c08a: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED return; 10c08d: e9 ce fc ff ff jmp 10bd60 <== NOT EXECUTED 10c092: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10c099: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED ent->prev->next = ent->next; 10c0a0: 8b 53 04 mov 0x4(%ebx),%edx 10c0a3: 8b 03 mov (%ebx),%eax 10c0a5: 89 02 mov %eax,(%edx) ent->next->prev = ent->prev; 10c0a7: 89 50 04 mov %edx,0x4(%eax) newent->next = beforethisent; 10c0aa: 8b 55 bc mov -0x44(%ebp),%edx struct list_head *prev = beforethisent->prev; 10c0ad: 8b 87 a4 00 00 00 mov 0xa4(%edi),%eax newent->next = beforethisent; 10c0b3: 89 13 mov %edx,(%ebx) rtems_jffs2_flash_control *fc = sb->s_flash_control; 10c0b5: 8b 97 e4 00 00 00 mov 0xe4(%edi),%edx newent->prev = prev; 10c0bb: 89 43 04 mov %eax,0x4(%ebx) beforethisent->prev = newent; 10c0be: 89 9f a4 00 00 00 mov %ebx,0xa4(%edi) prev->next = newent; 10c0c4: 89 18 mov %ebx,(%eax) if (fc->trigger_garbage_collection != NULL) { 10c0c6: 8b 42 20 mov 0x20(%edx),%eax 10c0c9: 85 c0 test %eax,%eax 10c0cb: 0f 84 8f fc ff ff je 10bd60 <== ALWAYS TAKEN (*fc->trigger_garbage_collection)(fc); 10c0d1: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 10c0d4: ff d0 call *%eax <== NOT EXECUTED 10c0d6: e9 85 fc ff ff jmp 10bd60 <== NOT EXECUTED 10c0db: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10c0df: 90 nop <== NOT EXECUTED pr_warn("Erase at 0x%08x failed immediately: -EROFS. Is the sector locked?\n", 10c0e0: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED 10c0e4: c7 04 24 e4 08 13 00 movl $0x1308e4,(%esp) <== NOT EXECUTED 10c0eb: e8 f0 fa ff ff call 10bbe0 <== NOT EXECUTED 10c0f0: e9 e1 fe ff ff jmp 10bfd6 <== NOT EXECUTED jffs2_prealloc_raw_node_refs(c, jeb, 1); 10c0f5: 8b 75 c4 mov -0x3c(%ebp),%esi 10c0f8: b9 01 00 00 00 mov $0x1,%ecx marker.hdr_crc = cpu_to_je32(crc32(0, &marker, sizeof(struct jffs2_unknown_node)-4)); 10c0fd: bb 08 00 00 00 mov $0x8,%ebx jffs2_prealloc_raw_node_refs(c, jeb, 1); 10c102: 89 4c 24 08 mov %ecx,0x8(%esp) 10c106: 89 3c 24 mov %edi,(%esp) struct jffs2_unknown_node marker = { 10c109: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) jffs2_prealloc_raw_node_refs(c, jeb, 1); 10c110: 89 74 24 04 mov %esi,0x4(%esp) struct jffs2_unknown_node marker = { 10c114: c7 45 dc 85 19 03 20 movl $0x20031985,-0x24(%ebp) 10c11b: 89 45 e0 mov %eax,-0x20(%ebp) jffs2_prealloc_raw_node_refs(c, jeb, 1); 10c11e: e8 dd 90 ff ff call 105200 marker.hdr_crc = cpu_to_je32(crc32(0, &marker, sizeof(struct jffs2_unknown_node)-4)); 10c123: 89 5c 24 08 mov %ebx,0x8(%esp) 10c127: 8d 5d dc lea -0x24(%ebp),%ebx 10c12a: 89 5c 24 04 mov %ebx,0x4(%esp) 10c12e: c7 04 24 00 00 00 00 movl $0x0,(%esp) 10c135: e8 56 ed ff ff call 10ae90 vecs[0].iov_base = (unsigned char *) ▮ 10c13a: 89 5d d4 mov %ebx,-0x2c(%ebp) vecs[0].iov_len = sizeof(marker); 10c13d: c7 45 d8 0c 00 00 00 movl $0xc,-0x28(%ebp) marker.hdr_crc = cpu_to_je32(crc32(0, &marker, sizeof(struct jffs2_unknown_node)-4)); 10c144: 89 45 e4 mov %eax,-0x1c(%ebp) ret = jffs2_flash_direct_writev(c, vecs, 1, jeb->offset, &retlen); 10c147: 8d 45 d0 lea -0x30(%ebp),%eax 10c14a: 89 44 24 14 mov %eax,0x14(%esp) 10c14e: 8b 46 0c mov 0xc(%esi),%eax 10c151: 31 f6 xor %esi,%esi 10c153: 89 74 24 10 mov %esi,0x10(%esp) 10c157: 89 3c 24 mov %edi,(%esp) 10c15a: 89 44 24 0c mov %eax,0xc(%esp) 10c15e: b8 01 00 00 00 mov $0x1,%eax 10c163: 89 44 24 08 mov %eax,0x8(%esp) 10c167: 8d 45 d4 lea -0x2c(%ebp),%eax 10c16a: 89 44 24 04 mov %eax,0x4(%esp) 10c16e: e8 4d 01 00 00 call 10c2c0 if (ret || retlen != sizeof(marker)) { 10c173: 85 c0 test %eax,%eax 10c175: 0f 85 c5 00 00 00 jne 10c240 <== NEVER TAKEN 10c17b: 8b 45 d0 mov -0x30(%ebp),%eax 10c17e: 83 f8 0c cmp $0xc,%eax 10c181: 74 28 je 10c1ab <== ALWAYS TAKEN pr_warn("Short write to newly-erased block at 0x%08x: Wanted %zd, got %zd\n", 10c183: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 10c187: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED 10c18a: ba 0c 00 00 00 mov $0xc,%edx <== NOT EXECUTED 10c18f: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED 10c193: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10c196: c7 04 24 98 08 13 00 movl $0x130898,(%esp) <== NOT EXECUTED 10c19d: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10c1a1: e8 3a fa ff ff call 10bbe0 <== NOT EXECUTED goto filebad; 10c1a6: e9 aa fc ff ff jmp 10be55 <== NOT EXECUTED jeb->free_size = c->sector_size; 10c1ab: 8b 47 34 mov 0x34(%edi),%eax if (c->cleanmarker_size && !jffs2_cleanmarker_oob(c)) 10c1ae: 8b 57 14 mov 0x14(%edi),%edx jeb->free_size = c->sector_size; 10c1b1: 8b 4d c4 mov -0x3c(%ebp),%ecx 10c1b4: 89 41 20 mov %eax,0x20(%ecx) c->erasing_size -= c->sector_size; 10c1b7: 29 47 2c sub %eax,0x2c(%edi) c->free_size += c->sector_size; 10c1ba: 01 47 28 add %eax,0x28(%edi) if (c->cleanmarker_size && !jffs2_cleanmarker_oob(c)) 10c1bd: 85 d2 test %edx,%edx 10c1bf: 0f 84 14 fd ff ff je 10bed9 <== NEVER TAKEN jffs2_link_node_ref(c, jeb, jeb->offset | REF_NORMAL, c->cleanmarker_size, NULL); 10c1c5: 89 54 24 0c mov %edx,0xc(%esp) 10c1c9: 31 c0 xor %eax,%eax 10c1cb: 89 44 24 10 mov %eax,0x10(%esp) 10c1cf: 8b 41 0c mov 0xc(%ecx),%eax 10c1d2: 89 4c 24 04 mov %ecx,0x4(%esp) 10c1d6: 89 3c 24 mov %edi,(%esp) 10c1d9: 89 45 c0 mov %eax,-0x40(%ebp) 10c1dc: 83 c8 03 or $0x3,%eax 10c1df: 89 44 24 08 mov %eax,0x8(%esp) 10c1e3: e8 78 9c ff ff call 105e60 10c1e8: e9 ec fc ff ff jmp 10bed9 pr_warn("Read of newly-erased block at 0x%08x failed: %d. Putting on bad_list\n", 10c1ed: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 10c1f1: 89 fa mov %edi,%edx <== NOT EXECUTED 10c1f3: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10c1f6: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED 10c1fa: c7 04 24 7c 07 13 00 movl $0x13077c,(%esp) <== NOT EXECUTED 10c201: e8 da f9 ff ff call 10bbe0 <== NOT EXECUTED kfree(ebuf); 10c206: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10c209: e8 22 1f 00 00 call 10e130 <== NOT EXECUTED return ret; 10c20e: e9 42 fc ff ff jmp 10be55 <== NOT EXECUTED pr_warn("Short read from newly-erased block at 0x%08x. Wanted %d, got %zd\n", 10c213: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED 10c216: 89 fa mov %edi,%edx <== NOT EXECUTED 10c218: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 10c21c: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10c21f: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED 10c223: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED 10c227: c7 04 24 cc 07 13 00 movl $0x1307cc,(%esp) <== NOT EXECUTED 10c22e: e8 ad f9 ff ff call 10bbe0 <== NOT EXECUTED kfree(ebuf); 10c233: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10c236: e8 f5 1e 00 00 call 10e130 <== NOT EXECUTED return ret; 10c23b: e9 15 fc ff ff jmp 10be55 <== NOT EXECUTED pr_warn("Write clean marker to block at 0x%08x failed: %d\n", 10c240: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 10c244: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED 10c247: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10c24a: c7 04 24 5c 08 13 00 movl $0x13085c,(%esp) <== NOT EXECUTED 10c251: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10c255: e8 86 f9 ff ff call 10bbe0 <== NOT EXECUTED 10c25a: e9 f6 fb ff ff jmp 10be55 <== NOT EXECUTED 10c25f: 90 nop =============================================================================== 0010c2c0 : int jffs2_flash_direct_writev(struct jffs2_sb_info *c, const struct iovec *vecs, unsigned long count, loff_t to, size_t * retlen) { 10c2c0: 55 push %ebp 10c2c1: 89 e5 mov %esp,%ebp 10c2c3: 57 push %edi 10c2c4: 56 push %esi 10c2c5: 53 push %ebx unsigned long i; size_t totlen = 0, thislen; 10c2c6: bb 00 00 00 00 mov $0x0,%ebx { 10c2cb: 81 ec 3c 01 00 00 sub $0x13c,%esp int ret = 0; for (i = 0; i < count; i++) { 10c2d1: 8b 4d 10 mov 0x10(%ebp),%ecx { 10c2d4: 8b 45 14 mov 0x14(%ebp),%eax size_t totlen = 0, thislen; 10c2d7: 89 9d d8 fe ff ff mov %ebx,-0x128(%ebp) { 10c2dd: 8b 55 18 mov 0x18(%ebp),%edx 10c2e0: 8b 7d 0c mov 0xc(%ebp),%edi for (i = 0; i < count; i++) { 10c2e3: 85 c9 test %ecx,%ecx { 10c2e5: 89 85 e0 fe ff ff mov %eax,-0x120(%ebp) 10c2eb: 89 95 e4 fe ff ff mov %edx,-0x11c(%ebp) for (i = 0; i < count; i++) { 10c2f1: 0f 84 c3 02 00 00 je 10c5ba <== NEVER TAKEN 10c2f7: 31 f6 xor %esi,%esi 10c2f9: eb 5f jmp 10c35a 10c2fb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10c2ff: 90 nop // writes need to be aligned but the data we're passed may not be // Observation suggests most unaligned writes are small, so we // optimize for that case. if (((vecs[i].iov_len & (sizeof (int) - 1))) || (((unsigned long) vecs[i]. 10c300: 8b 04 f7 mov (%edi,%esi,8),%eax if (((vecs[i].iov_len & (sizeof (int) - 1))) || 10c303: a8 03 test $0x3,%al 10c305: 75 5c jne 10c363 rtems_jffs2_flash_control *fc = sb->s_flash_control; 10c307: 8b 4d 08 mov 0x8(%ebp),%ecx 10c30a: 8b 91 e4 00 00 00 mov 0xe4(%ecx),%edx return (*fc->write)(fc, write_buffer_offset, read_buffer, size); 10c310: 89 44 24 08 mov %eax,0x8(%esp) if (thislen > vecs[i].iov_len) thislen = vecs[i].iov_len; } // else } else ret = jffs2_flash_write(c, to, vecs[i].iov_len, &thislen, 10c314: 8b 85 e0 fe ff ff mov -0x120(%ebp),%eax return (*fc->write)(fc, write_buffer_offset, read_buffer, size); 10c31a: 89 5c 24 0c mov %ebx,0xc(%esp) 10c31e: 89 14 24 mov %edx,(%esp) jffs2_flash_write(c, to, vecs[i].iov_len, &thislen, 10c321: 89 44 24 04 mov %eax,0x4(%esp) return (*fc->write)(fc, write_buffer_offset, read_buffer, size); 10c325: ff 52 0c call *0xc(%edx) 10c328: 89 c1 mov %eax,%ecx vecs[i].iov_base); totlen += thislen; 10c32a: 01 9d d8 fe ff ff add %ebx,-0x128(%ebp) if (ret || thislen != vecs[i].iov_len) 10c330: 85 c9 test %ecx,%ecx 10c332: 0f 85 a8 00 00 00 jne 10c3e0 <== NEVER TAKEN 10c338: 39 5c f7 04 cmp %ebx,0x4(%edi,%esi,8) 10c33c: 0f 85 9e 00 00 00 jne 10c3e0 <== NEVER TAKEN break; to += vecs[i].iov_len; 10c342: 31 d2 xor %edx,%edx 10c344: 01 9d e0 fe ff ff add %ebx,-0x120(%ebp) 10c34a: 11 95 e4 fe ff ff adc %edx,-0x11c(%ebp) for (i = 0; i < count; i++) { 10c350: 46 inc %esi 10c351: 39 75 10 cmp %esi,0x10(%ebp) 10c354: 0f 84 86 00 00 00 je 10c3e0 if (((vecs[i].iov_len & (sizeof (int) - 1))) || 10c35a: 8b 5c f7 04 mov 0x4(%edi,%esi,8),%ebx 10c35e: f6 c3 03 test $0x3,%bl 10c361: 74 9d je 10c300 if ((i + 1) < count || vecs[i].iov_len > 256) { 10c363: 8d 46 01 lea 0x1(%esi),%eax 10c366: 39 45 10 cmp %eax,0x10(%ebp) 10c369: 0f 87 b1 00 00 00 ja 10c420 <== NEVER TAKEN 10c36f: 81 fb 00 01 00 00 cmp $0x100,%ebx 10c375: 0f 87 a5 00 00 00 ja 10c420 lentowrite += sizeof (int) - 1; 10c37b: 8d 53 03 lea 0x3(%ebx),%edx memcpy(buf, vecs[i].iov_base, lentowrite); 10c37e: 8b 0c f7 mov (%edi,%esi,8),%ecx lentowrite &= ~(sizeof (int) - 1); 10c381: 83 e2 fc and $0xfffffffc,%edx memcpy(buf, vecs[i].iov_base, lentowrite); 10c384: 83 fa 04 cmp $0x4,%edx 10c387: 73 77 jae 10c400 <== ALWAYS TAKEN return (*fc->write)(fc, write_buffer_offset, read_buffer, size); 10c389: 89 95 dc fe ff ff mov %edx,-0x124(%ebp) rtems_jffs2_flash_control *fc = sb->s_flash_control; 10c38f: 8b 45 08 mov 0x8(%ebp),%eax return (*fc->write)(fc, write_buffer_offset, read_buffer, size); 10c392: 8d 8d e8 fe ff ff lea -0x118(%ebp),%ecx rtems_jffs2_flash_control *fc = sb->s_flash_control; 10c398: 8b 80 e4 00 00 00 mov 0xe4(%eax),%eax return (*fc->write)(fc, write_buffer_offset, read_buffer, size); 10c39e: 89 4c 24 08 mov %ecx,0x8(%esp) jffs2_flash_write(c, to, lentowrite, 10c3a2: 8b 8d e0 fe ff ff mov -0x120(%ebp),%ecx return (*fc->write)(fc, write_buffer_offset, read_buffer, size); 10c3a8: 89 54 24 0c mov %edx,0xc(%esp) 10c3ac: 89 04 24 mov %eax,(%esp) jffs2_flash_write(c, to, lentowrite, 10c3af: 89 4c 24 04 mov %ecx,0x4(%esp) return (*fc->write)(fc, write_buffer_offset, read_buffer, size); 10c3b3: ff 50 0c call *0xc(%eax) 10c3b6: 8b 5c f7 04 mov 0x4(%edi,%esi,8),%ebx 10c3ba: 8b 95 dc fe ff ff mov -0x124(%ebp),%edx 10c3c0: 39 d3 cmp %edx,%ebx 10c3c2: 89 c1 mov %eax,%ecx if (thislen > vecs[i].iov_len) 10c3c4: 0f 86 60 ff ff ff jbe 10c32a <== ALWAYS TAKEN 10c3ca: 89 d3 mov %edx,%ebx <== NOT EXECUTED totlen += thislen; 10c3cc: 01 9d d8 fe ff ff add %ebx,-0x128(%ebp) <== NOT EXECUTED if (ret || thislen != vecs[i].iov_len) 10c3d2: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10c3d4: 0f 84 5e ff ff ff je 10c338 <== NOT EXECUTED 10c3da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED } writev_out: if (retlen) 10c3e0: 8b 55 1c mov 0x1c(%ebp),%edx 10c3e3: 85 d2 test %edx,%edx 10c3e5: 74 0b je 10c3f2 <== NEVER TAKEN *retlen = totlen; 10c3e7: 8b 45 1c mov 0x1c(%ebp),%eax 10c3ea: 8b bd d8 fe ff ff mov -0x128(%ebp),%edi 10c3f0: 89 38 mov %edi,(%eax) return ret; } 10c3f2: 81 c4 3c 01 00 00 add $0x13c,%esp 10c3f8: 89 c8 mov %ecx,%eax 10c3fa: 5b pop %ebx 10c3fb: 5e pop %esi 10c3fc: 5f pop %edi 10c3fd: 5d pop %ebp 10c3fe: c3 ret 10c3ff: 90 nop memcpy(buf, vecs[i].iov_base, lentowrite); 10c400: 31 c0 xor %eax,%eax 10c402: 8b 1c 01 mov (%ecx,%eax,1),%ebx 10c405: 89 9c 05 e8 fe ff ff mov %ebx,-0x118(%ebp,%eax,1) 10c40c: 83 c0 04 add $0x4,%eax 10c40f: 39 d0 cmp %edx,%eax 10c411: 72 ef jb 10c402 10c413: e9 71 ff ff ff jmp 10c389 10c418: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10c41f: 90 nop for (j = i; j < count; j++) 10c420: 39 75 10 cmp %esi,0x10(%ebp) 10c423: 0f 86 6e 01 00 00 jbe 10c597 <== NEVER TAKEN 10c429: 89 9d dc fe ff ff mov %ebx,-0x124(%ebp) if (((vecs[i].iov_len & (sizeof (int) - 1))) || 10c42f: 89 d9 mov %ebx,%ecx for (j = i; j < count; j++) 10c431: 89 f0 mov %esi,%eax 10c433: 8b 5d 10 mov 0x10(%ebp),%ebx 10c436: 31 d2 xor %edx,%edx 10c438: eb 0a jmp 10c444 10c43a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi totvecsize += vecs[j].iov_len; 10c440: 8b 4c c7 04 mov 0x4(%edi,%eax,8),%ecx <== NOT EXECUTED for (j = i; j < count; j++) 10c444: 40 inc %eax totvecsize += vecs[j].iov_len; 10c445: 01 d1 add %edx,%ecx for (j = i; j < count; j++) 10c447: 39 c3 cmp %eax,%ebx totvecsize += vecs[j].iov_len; 10c449: 89 ca mov %ecx,%edx for (j = i; j < count; j++) 10c44b: 75 f3 jne 10c440 <== NEVER TAKEN sizetomalloc = totvecsize + sizeof (int) - 1; 10c44d: 89 8d c8 fe ff ff mov %ecx,-0x138(%ebp) 10c453: 83 c2 03 add $0x3,%edx 10c456: 8b 9d dc fe ff ff mov -0x124(%ebp),%ebx sizetomalloc &= ~(sizeof (int) - 1); 10c45c: 83 e2 fc and $0xfffffffc,%edx cbuf = (char *) malloc(sizetomalloc); 10c45f: 89 14 24 mov %edx,(%esp) sizetomalloc &= ~(sizeof (int) - 1); 10c462: 89 95 d0 fe ff ff mov %edx,-0x130(%ebp) cbuf = (char *) malloc(sizetomalloc); 10c468: e8 b3 20 00 00 call 10e520 10c46d: 89 85 cc fe ff ff mov %eax,-0x134(%ebp) if (!cbuf) { 10c473: 85 c0 test %eax,%eax cbuf = (char *) malloc(sizetomalloc); 10c475: 89 c2 mov %eax,%edx if (!cbuf) { 10c477: 0f 84 44 01 00 00 je 10c5c1 <== NEVER TAKEN 10c47d: 8b 4d 10 mov 0x10(%ebp),%ecx 10c480: 8d 04 f7 lea (%edi,%esi,8),%eax 10c483: 8d 3c cf lea (%edi,%ecx,8),%edi 10c486: 89 bd d4 fe ff ff mov %edi,-0x12c(%ebp) 10c48c: eb 1a jmp 10c4a8 10c48e: 66 90 xchg %ax,%ax memcpy(cbufptr, vecs[j].iov_base, 10c490: 8b 8d dc fe ff ff mov -0x124(%ebp),%ecx for (j = i; j < count; j++) { 10c496: 83 c0 08 add $0x8,%eax cbufptr += vecs[j].iov_len; 10c499: 01 da add %ebx,%edx memcpy(cbufptr, vecs[j].iov_base, 10c49b: f3 a4 rep movsb %ds:(%esi),%es:(%edi) for (j = i; j < count; j++) { 10c49d: 39 85 d4 fe ff ff cmp %eax,-0x12c(%ebp) 10c4a3: 74 4b je 10c4f0 <== ALWAYS TAKEN memcpy(cbufptr, vecs[j].iov_base, 10c4a5: 8b 58 04 mov 0x4(%eax),%ebx <== NOT EXECUTED 10c4a8: 89 9d dc fe ff ff mov %ebx,-0x124(%ebp) 10c4ae: 8b 38 mov (%eax),%edi 10c4b0: 83 fb 08 cmp $0x8,%ebx 10c4b3: 89 fe mov %edi,%esi 10c4b5: 89 d7 mov %edx,%edi 10c4b7: 72 d7 jb 10c490 <== NEVER TAKEN 10c4b9: f6 c2 01 test $0x1,%dl 10c4bc: 0f 85 be 00 00 00 jne 10c580 <== NEVER TAKEN 10c4c2: f7 c7 02 00 00 00 test $0x2,%edi 10c4c8: 0f 85 92 00 00 00 jne 10c560 <== NEVER TAKEN 10c4ce: f7 c7 04 00 00 00 test $0x4,%edi 10c4d4: 74 ba je 10c490 10c4d6: 8b 0e mov (%esi),%ecx 10c4d8: 83 c7 04 add $0x4,%edi 10c4db: 83 c6 04 add $0x4,%esi 10c4de: 89 4f fc mov %ecx,-0x4(%edi) 10c4e1: 83 ad dc fe ff ff 04 subl $0x4,-0x124(%ebp) 10c4e8: eb a6 jmp 10c490 10c4ea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi totlen += thislen; 10c4f0: 8b 8d c8 fe ff ff mov -0x138(%ebp),%ecx 10c4f6: 8b 85 d0 fe ff ff mov -0x130(%ebp),%eax 10c4fc: 39 c1 cmp %eax,%ecx 10c4fe: 77 50 ja 10c550 <== NEVER TAKEN 10c500: 01 8d d8 fe ff ff add %ecx,-0x128(%ebp) return (*fc->write)(fc, write_buffer_offset, read_buffer, size); 10c506: 8b bd d0 fe ff ff mov -0x130(%ebp),%edi rtems_jffs2_flash_control *fc = sb->s_flash_control; 10c50c: 8b 45 08 mov 0x8(%ebp),%eax jffs2_flash_write(c, to, sizetomalloc, 10c50f: 8b 8d e0 fe ff ff mov -0x120(%ebp),%ecx rtems_jffs2_flash_control *fc = sb->s_flash_control; 10c515: 8b 80 e4 00 00 00 mov 0xe4(%eax),%eax return (*fc->write)(fc, write_buffer_offset, read_buffer, size); 10c51b: 89 7c 24 0c mov %edi,0xc(%esp) 10c51f: 8b bd cc fe ff ff mov -0x134(%ebp),%edi jffs2_flash_write(c, to, sizetomalloc, 10c525: 89 4c 24 04 mov %ecx,0x4(%esp) return (*fc->write)(fc, write_buffer_offset, read_buffer, size); 10c529: 89 04 24 mov %eax,(%esp) 10c52c: 89 7c 24 08 mov %edi,0x8(%esp) 10c530: ff 50 0c call *0xc(%eax) free(cbuf); 10c533: 89 3c 24 mov %edi,(%esp) return (*fc->write)(fc, write_buffer_offset, read_buffer, size); 10c536: 89 85 e0 fe ff ff mov %eax,-0x120(%ebp) free(cbuf); 10c53c: e8 ef 1b 00 00 call 10e130 goto writev_out; 10c541: 8b 8d e0 fe ff ff mov -0x120(%ebp),%ecx 10c547: e9 94 fe ff ff jmp 10c3e0 10c54c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi totlen += thislen; 10c550: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10c552: eb ac jmp 10c500 <== NOT EXECUTED 10c554: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10c55b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10c55f: 90 nop <== NOT EXECUTED memcpy(cbufptr, vecs[j].iov_base, 10c560: 0f b7 0e movzwl (%esi),%ecx <== NOT EXECUTED 10c563: 83 c7 02 add $0x2,%edi <== NOT EXECUTED 10c566: 83 c6 02 add $0x2,%esi <== NOT EXECUTED 10c569: 66 89 4f fe mov %cx,-0x2(%edi) <== NOT EXECUTED 10c56d: 83 ad dc fe ff ff 02 subl $0x2,-0x124(%ebp) <== NOT EXECUTED 10c574: e9 55 ff ff ff jmp 10c4ce <== NOT EXECUTED 10c579: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10c580: 0f b6 0e movzbl (%esi),%ecx <== NOT EXECUTED 10c583: 8d 7a 01 lea 0x1(%edx),%edi <== NOT EXECUTED 10c586: 46 inc %esi <== NOT EXECUTED 10c587: 88 0a mov %cl,(%edx) <== NOT EXECUTED 10c589: 8d 4b ff lea -0x1(%ebx),%ecx <== NOT EXECUTED 10c58c: 89 8d dc fe ff ff mov %ecx,-0x124(%ebp) <== NOT EXECUTED 10c592: e9 2b ff ff ff jmp 10c4c2 <== NOT EXECUTED cbuf = (char *) malloc(sizetomalloc); 10c597: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED 10c59e: e8 7d 1f 00 00 call 10e520 <== NOT EXECUTED 10c5a3: 89 85 cc fe ff ff mov %eax,-0x134(%ebp) <== NOT EXECUTED if (!cbuf) { 10c5a9: 85 c0 test %eax,%eax <== NOT EXECUTED 10c5ab: 74 14 je 10c5c1 <== NOT EXECUTED cbuf = (char *) malloc(sizetomalloc); 10c5ad: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c5af: 89 85 d0 fe ff ff mov %eax,-0x130(%ebp) <== NOT EXECUTED 10c5b5: e9 4c ff ff ff jmp 10c506 <== NOT EXECUTED for (i = 0; i < count; i++) { 10c5ba: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10c5bc: e9 1f fe ff ff jmp 10c3e0 <== NOT EXECUTED ret = -ENOMEM; 10c5c1: b9 f4 ff ff ff mov $0xfffffff4,%ecx <== NOT EXECUTED 10c5c6: e9 15 fe ff ff jmp 10c3e0 <== NOT EXECUTED 10c5cb: 90 nop 10c5cc: 90 nop 10c5cd: 90 nop 10c5ce: 90 nop 10c5cf: 90 nop =============================================================================== 00105c80 : { 105c80: 55 push %ebp 105c81: 89 e5 mov %esp,%ebp 105c83: 57 push %edi 105c84: 56 push %esi 105c85: 53 push %ebx 105c86: 83 ec 1c sub $0x1c,%esp for (i=0; i < c->inocache_hashsize; i++) { 105c89: 8b 45 08 mov 0x8(%ebp),%eax 105c8c: 8b 90 c0 00 00 00 mov 0xc0(%eax),%edx 105c92: 85 d2 test %edx,%edx 105c94: 7e 49 jle 105cdf <== NEVER TAKEN this = c->inocache_list[i]; 105c96: 8b 88 c4 00 00 00 mov 0xc4(%eax),%ecx for (i=0; i < c->inocache_hashsize; i++) { 105c9c: 31 db xor %ebx,%ebx 105c9e: 66 90 xchg %ax,%ax this = c->inocache_list[i]; 105ca0: 8d 34 9d 00 00 00 00 lea 0x0(,%ebx,4),%esi 105ca7: 8d 14 31 lea (%ecx,%esi,1),%edx 105caa: 8b 3a mov (%edx),%edi while (this) { 105cac: 85 ff test %edi,%edi 105cae: 74 1d je 105ccd next = this->next; 105cb0: 89 fa mov %edi,%edx 105cb2: 8b 7f 10 mov 0x10(%edi),%edi jffs2_free_inode_cache(this); 105cb5: 89 14 24 mov %edx,(%esp) 105cb8: e8 53 f6 ff ff call 105310 while (this) { 105cbd: 85 ff test %edi,%edi 105cbf: 75 ef jne 105cb0 <== NEVER TAKEN c->inocache_list[i] = NULL; 105cc1: 8b 45 08 mov 0x8(%ebp),%eax 105cc4: 8b 88 c4 00 00 00 mov 0xc4(%eax),%ecx 105cca: 8d 14 31 lea (%ecx,%esi,1),%edx 105ccd: c7 02 00 00 00 00 movl $0x0,(%edx) for (i=0; i < c->inocache_hashsize; i++) { 105cd3: 8b 45 08 mov 0x8(%ebp),%eax 105cd6: 43 inc %ebx 105cd7: 39 98 c0 00 00 00 cmp %ebx,0xc0(%eax) 105cdd: 7f c1 jg 105ca0 } 105cdf: 83 c4 1c add $0x1c,%esp 105ce2: 5b pop %ebx 105ce3: 5e pop %esi 105ce4: 5f pop %edi 105ce5: 5d pop %ebp 105ce6: c3 ret 105ce7: 90 nop 105ce8: 90 nop 105ce9: 90 nop 105cea: 90 nop 105ceb: 90 nop 105cec: 90 nop 105ced: 90 nop 105cee: 90 nop 105cef: 90 nop =============================================================================== 0010bc00 : jffs2_del_ino_cache(c, ic); } } void jffs2_free_jeb_node_refs(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb) { 10bc00: 55 push %ebp 10bc01: 89 e5 mov %esp,%ebp 10bc03: 57 push %edi 10bc04: 56 push %esi 10bc05: 53 push %ebx 10bc06: 83 ec 2c sub $0x2c,%esp struct jffs2_raw_node_ref *block, *ref; jffs2_dbg(1, "Freeing all node refs for eraseblock offset 0x%08x\n", jeb->offset); block = ref = jeb->first_node; 10bc09: 8b 45 0c mov 0xc(%ebp),%eax 10bc0c: 8b 78 28 mov 0x28(%eax),%edi while (ref) { 10bc0f: 85 ff test %edi,%edi 10bc11: 0f 84 9c 00 00 00 je 10bcb3 10bc17: 89 7d dc mov %edi,-0x24(%ebp) if (ref->flash_offset == REF_LINK_NODE) { 10bc1a: 8b 47 04 mov 0x4(%edi),%eax 10bc1d: 83 f8 ff cmp $0xffffffff,%eax 10bc20: 74 7c je 10bc9e <== NEVER TAKEN 10bc22: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 10bc29: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi ref = ref->next_in_ino; jffs2_free_refblock(block); block = ref; continue; } if (ref->flash_offset != REF_EMPTY_NODE && ref->next_in_ino) 10bc30: 83 f8 fe cmp $0xfffffffe,%eax 10bc33: 74 5e je 10bc93 10bc35: 8b 07 mov (%edi),%eax 10bc37: 85 c0 test %eax,%eax 10bc39: 74 58 je 10bc93 <== ALWAYS TAKEN if (SECTOR_ADDR((*prev)->flash_offset) == jeb->offset) { 10bc3b: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED prev = &ref->next_in_ino; 10bc3e: 89 fb mov %edi,%ebx <== NOT EXECUTED struct jffs2_inode_cache *ic = NULL; 10bc40: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED if (SECTOR_ADDR((*prev)->flash_offset) == jeb->offset) { 10bc47: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10bc4a: 8b 76 34 mov 0x34(%esi),%esi <== NOT EXECUTED 10bc4d: 8b 52 0c mov 0xc(%edx),%edx <== NOT EXECUTED 10bc50: f7 de neg %esi <== NOT EXECUTED 10bc52: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED if (!(*prev)->next_in_ino) { 10bc55: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10bc57: 85 d2 test %edx,%edx <== NOT EXECUTED 10bc59: 74 14 je 10bc6f <== NOT EXECUTED if (SECTOR_ADDR((*prev)->flash_offset) == jeb->offset) { 10bc5b: 8b 48 04 mov 0x4(%eax),%ecx <== NOT EXECUTED 10bc5e: 21 f1 and %esi,%ecx <== NOT EXECUTED 10bc60: 3b 4d e4 cmp -0x1c(%ebp),%ecx <== NOT EXECUTED 10bc63: 74 6b je 10bcd0 <== NOT EXECUTED prev = &((*prev)->next_in_ino); 10bc65: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10bc67: 89 d0 mov %edx,%eax <== NOT EXECUTED if (!(*prev)->next_in_ino) { 10bc69: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10bc6b: 85 d2 test %edx,%edx <== NOT EXECUTED 10bc6d: 75 ec jne 10bc5b <== NOT EXECUTED continue; 10bc6f: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED prev = &ic->nodes; 10bc72: 8d 58 04 lea 0x4(%eax),%ebx <== NOT EXECUTED continue; 10bc75: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10bc78: eb db jmp 10bc55 <== NOT EXECUTED 10bc7a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (!ic) { 10bc80: 8b 5d e0 mov -0x20(%ebp),%ebx <== NOT EXECUTED 10bc83: 85 db test %ebx,%ebx <== NOT EXECUTED 10bc85: 0f 84 85 00 00 00 je 10bd10 <== NOT EXECUTED if (ic->nodes == (void *)ic && ic->pino_nlink == 0) 10bc8b: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10bc8e: 39 40 04 cmp %eax,0x4(%eax) <== NOT EXECUTED 10bc91: 74 5d je 10bcf0 <== NOT EXECUTED jffs2_remove_node_refs_from_ino_list(c, ref, jeb); /* else it was a non-inode node or already removed, so don't bother */ ref++; 10bc93: 83 c7 08 add $0x8,%edi if (ref->flash_offset == REF_LINK_NODE) { 10bc96: 8b 47 04 mov 0x4(%edi),%eax 10bc99: 83 f8 ff cmp $0xffffffff,%eax 10bc9c: 75 92 jne 10bc30 jffs2_free_refblock(block); 10bc9e: 8b 45 dc mov -0x24(%ebp),%eax ref = ref->next_in_ino; 10bca1: 8b 3f mov (%edi),%edi jffs2_free_refblock(block); 10bca3: 89 04 24 mov %eax,(%esp) 10bca6: e8 05 96 ff ff call 1052b0 while (ref) { 10bcab: 85 ff test %edi,%edi 10bcad: 0f 85 64 ff ff ff jne 10bc17 } jeb->first_node = jeb->last_node = NULL; 10bcb3: 8b 45 0c mov 0xc(%ebp),%eax 10bcb6: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) 10bcbd: c7 40 28 00 00 00 00 movl $0x0,0x28(%eax) } 10bcc4: 83 c4 2c add $0x2c,%esp 10bcc7: 5b pop %ebx 10bcc8: 5e pop %esi 10bcc9: 5f pop %edi 10bcca: 5d pop %ebp 10bccb: c3 ret 10bccc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi *prev = this->next_in_ino; 10bcd0: 89 13 mov %edx,(%ebx) <== NOT EXECUTED if (this == ref) 10bcd2: 39 f8 cmp %edi,%eax <== NOT EXECUTED this->next_in_ino = NULL; 10bcd4: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED if (this == ref) 10bcda: 74 a4 je 10bc80 <== NOT EXECUTED if (!(*prev)->next_in_ino) { 10bcdc: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10bcde: e9 72 ff ff ff jmp 10bc55 <== NOT EXECUTED 10bce3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10bcea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (ic->nodes == (void *)ic && ic->pino_nlink == 0) 10bcf0: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED 10bcf3: 85 d2 test %edx,%edx <== NOT EXECUTED 10bcf5: 75 9c jne 10bc93 <== NOT EXECUTED jffs2_del_ino_cache(c, ic); 10bcf7: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10bcfb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ref++; 10bcfe: 83 c7 08 add $0x8,%edi <== NOT EXECUTED jffs2_del_ino_cache(c, ic); 10bd01: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10bd04: e8 07 9f ff ff call 105c10 <== NOT EXECUTED while (ref) { 10bd09: eb 8b jmp 10bc96 <== NOT EXECUTED 10bd0b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10bd0f: 90 nop <== NOT EXECUTED JFFS2_WARNING("inode_cache/xattr_datum/xattr_ref" 10bd10: c7 04 24 cc 06 13 00 movl $0x1306cc,(%esp) <== NOT EXECUTED 10bd17: b9 80 09 13 00 mov $0x130980,%ecx <== NOT EXECUTED ref++; 10bd1c: 83 c7 08 add $0x8,%edi <== NOT EXECUTED JFFS2_WARNING("inode_cache/xattr_datum/xattr_ref" 10bd1f: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED 10bd23: e8 b8 fe ff ff call 10bbe0 <== NOT EXECUTED while (ref) { 10bd28: e9 69 ff ff ff jmp 10bc96 <== NOT EXECUTED 10bd2d: 90 nop 10bd2e: 90 nop 10bd2f: 90 nop =============================================================================== 00105cf0 : { 105cf0: 55 push %ebp 105cf1: 89 e5 mov %esp,%ebp 105cf3: 57 push %edi 105cf4: 56 push %esi 105cf5: 53 push %ebx 105cf6: 83 ec 2c sub $0x2c,%esp 105cf9: 8b 75 08 mov 0x8(%ebp),%esi for (i=0; inr_blocks; i++) { 105cfc: 8b 46 50 mov 0x50(%esi),%eax 105cff: 85 c0 test %eax,%eax 105d01: 74 6d je 105d70 <== NEVER TAKEN this = c->blocks[i].first_node; 105d03: 8b 56 54 mov 0x54(%esi),%edx for (i=0; inr_blocks; i++) { 105d06: 31 ff xor %edi,%edi 105d08: eb 28 jmp 105d32 105d0a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi jffs2_free_refblock(this); 105d10: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 105d13: e8 98 f5 ff ff call 1052b0 <== NOT EXECUTED c->blocks[i].first_node = c->blocks[i].last_node = NULL; 105d18: 8b 56 54 mov 0x54(%esi),%edx <== NOT EXECUTED 105d1b: 8d 0c 1a lea (%edx,%ebx,1),%ecx <== NOT EXECUTED 105d1e: c7 41 2c 00 00 00 00 movl $0x0,0x2c(%ecx) for (i=0; inr_blocks; i++) { 105d25: 47 inc %edi 105d26: 39 7e 50 cmp %edi,0x50(%esi) c->blocks[i].first_node = c->blocks[i].last_node = NULL; 105d29: c7 41 28 00 00 00 00 movl $0x0,0x28(%ecx) for (i=0; inr_blocks; i++) { 105d30: 76 3e jbe 105d70 this = c->blocks[i].first_node; 105d32: 8d 04 7f lea (%edi,%edi,2),%eax 105d35: 8d 1c 87 lea (%edi,%eax,4),%ebx 105d38: c1 e3 02 shl $0x2,%ebx 105d3b: 8d 0c 1a lea (%edx,%ebx,1),%ecx 105d3e: 8b 41 28 mov 0x28(%ecx),%eax while (this) { 105d41: 85 c0 test %eax,%eax 105d43: 74 d9 je 105d1e <== NEVER TAKEN if (this[REFS_PER_BLOCK].flash_offset == REF_LINK_NODE) 105d45: 83 b8 f4 00 00 00 ff cmpl $0xffffffff,0xf4(%eax) 105d4c: 75 c2 jne 105d10 <== NEVER TAKEN next = this[REFS_PER_BLOCK].next_in_ino; 105d4e: 8b 90 f0 00 00 00 mov 0xf0(%eax),%edx jffs2_free_refblock(this); 105d54: 89 04 24 mov %eax,(%esp) next = this[REFS_PER_BLOCK].next_in_ino; 105d57: 89 55 e4 mov %edx,-0x1c(%ebp) jffs2_free_refblock(this); 105d5a: e8 51 f5 ff ff call 1052b0 while (this) { 105d5f: 8b 55 e4 mov -0x1c(%ebp),%edx 105d62: 85 d2 test %edx,%edx 105d64: 74 12 je 105d78 105d66: 89 d0 mov %edx,%eax 105d68: eb db jmp 105d45 105d6a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi } 105d70: 83 c4 2c add $0x2c,%esp 105d73: 5b pop %ebx 105d74: 5e pop %esi 105d75: 5f pop %edi 105d76: 5d pop %ebp 105d77: c3 ret c->blocks[i].first_node = c->blocks[i].last_node = NULL; 105d78: 8b 56 54 mov 0x54(%esi),%edx 105d7b: 8d 0c 1a lea (%edx,%ebx,1),%ecx 105d7e: eb 9e jmp 105d1e =============================================================================== 00103c50 : { 103c50: 55 push %ebp 103c51: 89 e5 mov %esp,%ebp 103c53: 57 push %edi 103c54: 56 push %esi 103c55: 53 push %ebx 103c56: 81 ec ac 00 00 00 sub $0xac,%esp if (!c->unchecked_size) 103c5c: 8b 45 08 mov 0x8(%ebp),%eax 103c5f: 8b 40 38 mov 0x38(%eax),%eax 103c62: 89 85 7c ff ff ff mov %eax,-0x84(%ebp) 103c68: 8b 8d 7c ff ff ff mov -0x84(%ebp),%ecx if (!list_empty(&c->erase_complete_list) || 103c6e: 8b 45 08 mov 0x8(%ebp),%eax if (!c->unchecked_size) 103c71: 85 c9 test %ecx,%ecx 103c73: 0f 84 4a 01 00 00 je 103dc3 <== ALWAYS TAKEN want_ino = c->check_ino; 103c79: 8b 48 08 mov 0x8(%eax),%ecx <== NOT EXECUTED for (bucket = c->check_ino % c->inocache_hashsize ; bucket < c->inocache_hashsize; bucket++) { 103c7c: 31 d2 xor %edx,%edx <== NOT EXECUTED 103c7e: 8b b0 c0 00 00 00 mov 0xc0(%eax),%esi <== NOT EXECUTED 103c84: 89 c8 mov %ecx,%eax <== NOT EXECUTED 103c86: f7 f6 div %esi <== NOT EXECUTED 103c88: 89 75 84 mov %esi,-0x7c(%ebp) <== NOT EXECUTED 103c8b: 39 d6 cmp %edx,%esi <== NOT EXECUTED 103c8d: 7e 44 jle 103cd3 <== NOT EXECUTED for (ic = c->inocache_list[bucket]; ic; ic = ic->next) { 103c8f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 103c92: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED 103c98: 89 45 80 mov %eax,-0x80(%ebp) <== NOT EXECUTED 103c9b: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 103c9e: 8b 1c 90 mov (%eax,%edx,4),%ebx <== NOT EXECUTED 103ca1: 85 db test %ebx,%ebx <== NOT EXECUTED 103ca3: 74 26 je 103ccb <== NOT EXECUTED 103ca5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 103cac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED if (ic->ino < want_ino) 103cb0: 8b 7b 0c mov 0xc(%ebx),%edi <== NOT EXECUTED 103cb3: 39 cf cmp %ecx,%edi <== NOT EXECUTED 103cb5: 72 0d jb 103cc4 <== NOT EXECUTED if (ic->state != INO_STATE_CHECKEDABSENT && 103cb7: 0f b7 43 0a movzwl 0xa(%ebx),%eax <== NOT EXECUTED 103cbb: 8d 70 fe lea -0x2(%eax),%esi <== NOT EXECUTED 103cbe: 66 83 fe 01 cmp $0x1,%si <== NOT EXECUTED 103cc2: 77 5c ja 103d20 <== NOT EXECUTED for (ic = c->inocache_list[bucket]; ic; ic = ic->next) { 103cc4: 8b 5b 10 mov 0x10(%ebx),%ebx <== NOT EXECUTED 103cc7: 85 db test %ebx,%ebx <== NOT EXECUTED 103cc9: 75 e5 jne 103cb0 <== NOT EXECUTED for (bucket = c->check_ino % c->inocache_hashsize ; bucket < c->inocache_hashsize; bucket++) { 103ccb: 42 inc %edx <== NOT EXECUTED want_ino = 0; 103ccc: 31 c9 xor %ecx,%ecx <== NOT EXECUTED for (bucket = c->check_ino % c->inocache_hashsize ; bucket < c->inocache_hashsize; bucket++) { 103cce: 39 55 84 cmp %edx,-0x7c(%ebp) <== NOT EXECUTED 103cd1: 75 c8 jne 103c9b <== NOT EXECUTED c->check_ino = ((c->highest_ino + c->inocache_hashsize + 1) & 103cd3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED return -ENOSPC; 103cd6: be e4 ff ff ff mov $0xffffffe4,%esi <== NOT EXECUTED c->check_ino = ((c->highest_ino + c->inocache_hashsize + 1) & 103cdb: 8b 4d 84 mov -0x7c(%ebp),%ecx <== NOT EXECUTED 103cde: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 103ce1: 8d 54 01 01 lea 0x1(%ecx,%eax,1),%edx <== NOT EXECUTED ~c->inocache_hashsize) - 1; 103ce5: 89 c8 mov %ecx,%eax <== NOT EXECUTED 103ce7: f7 d0 not %eax <== NOT EXECUTED c->check_ino = ((c->highest_ino + c->inocache_hashsize + 1) & 103ce9: 21 d0 and %edx,%eax <== NOT EXECUTED ~c->inocache_hashsize) - 1; 103ceb: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 103cee: 48 dec %eax <== NOT EXECUTED 103cef: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED pr_crit("Checked all inodes but still 0x%x bytes of unchecked space?\n", 103cf2: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax <== NOT EXECUTED 103cf8: c7 04 24 74 e2 12 00 movl $0x12e274,(%esp) <== NOT EXECUTED 103cff: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 103d03: e8 28 fa ff ff call 103730 <== NOT EXECUTED } 103d08: 81 c4 ac 00 00 00 add $0xac,%esp 103d0e: 89 f0 mov %esi,%eax 103d10: 5b pop %ebx 103d11: 5e pop %esi 103d12: 5f pop %edi 103d13: 5d pop %ebp 103d14: c3 ret 103d15: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 103d1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi c->check_ino = ic->ino + c->inocache_hashsize; 103d20: 8b 55 84 mov -0x7c(%ebp),%edx <== NOT EXECUTED 103d23: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 103d26: 01 fa add %edi,%edx <== NOT EXECUTED 103d28: 89 51 08 mov %edx,0x8(%ecx) <== NOT EXECUTED if (!ic->pino_nlink) { 103d2b: 8b 53 14 mov 0x14(%ebx),%edx <== NOT EXECUTED 103d2e: 85 d2 test %edx,%edx <== NOT EXECUTED 103d30: 0f 84 32 ff ff ff je 103c68 <== NOT EXECUTED switch(ic->state) { 103d36: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 103d39: 0f 84 dd 12 00 00 je 10501c <== NOT EXECUTED 103d3f: 77 4f ja 103d90 <== NOT EXECUTED 103d41: 85 c0 test %eax,%eax <== NOT EXECUTED 103d43: 0f 85 d3 12 00 00 jne 10501c <== NOT EXECUTED ic->state = INO_STATE_CHECKING; 103d49: 66 c7 43 0a 01 00 movw $0x1,0xa(%ebx) <== NOT EXECUTED ret = jffs2_do_crccheck_inode(c, ic); 103d4f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 103d52: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED 103d56: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 103d59: e8 02 58 00 00 call 109560 <== NOT EXECUTED if (ret) 103d5e: 85 c0 test %eax,%eax <== NOT EXECUTED ret = jffs2_do_crccheck_inode(c, ic); 103d60: 89 c6 mov %eax,%esi <== NOT EXECUTED if (ret) 103d62: 75 4a jne 103dae <== NOT EXECUTED jffs2_set_inocache_state(c, ic, INO_STATE_CHECKEDABSENT); 103d64: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED 103d68: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 103d6d: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 103d71: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 103d74: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 103d77: e8 c4 1d 00 00 call 105b40 <== NOT EXECUTED } 103d7c: 81 c4 ac 00 00 00 add $0xac,%esp <== NOT EXECUTED 103d82: 89 f0 mov %esi,%eax <== NOT EXECUTED 103d84: 5b pop %ebx <== NOT EXECUTED 103d85: 5e pop %esi <== NOT EXECUTED 103d86: 5f pop %edi <== NOT EXECUTED 103d87: 5d pop %ebp <== NOT EXECUTED 103d88: c3 ret <== NOT EXECUTED 103d89: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED switch(ic->state) { 103d90: 83 f8 05 cmp $0x5,%eax <== NOT EXECUTED 103d93: 0f 85 bb 12 00 00 jne 105054 <== NOT EXECUTED c->check_ino = ic->ino; 103d99: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED return 0; 103d9c: 31 f6 xor %esi,%esi <== NOT EXECUTED c->check_ino = ic->ino; 103d9e: 89 78 08 mov %edi,0x8(%eax) <== NOT EXECUTED } 103da1: 81 c4 ac 00 00 00 add $0xac,%esp <== NOT EXECUTED 103da7: 89 f0 mov %esi,%eax <== NOT EXECUTED 103da9: 5b pop %ebx <== NOT EXECUTED 103daa: 5e pop %esi <== NOT EXECUTED 103dab: 5f pop %edi <== NOT EXECUTED 103dac: 5d pop %ebp <== NOT EXECUTED 103dad: c3 ret <== NOT EXECUTED pr_warn("Returned error for crccheck of ino #%u. Expect badness...\n", 103dae: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 103db1: c7 04 24 24 e3 12 00 movl $0x12e324,(%esp) <== NOT EXECUTED 103db8: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 103dbc: e8 6f f9 ff ff call 103730 <== NOT EXECUTED 103dc1: eb a1 jmp 103d64 <== NOT EXECUTED if (!list_empty(&c->erase_complete_list) || 103dc3: 8b 55 08 mov 0x8(%ebp),%edx 103dc6: 05 a0 00 00 00 add $0xa0,%eax 103dcb: 39 82 a0 00 00 00 cmp %eax,0xa0(%edx) 103dd1: 74 77 je 103e4a <== ALWAYS TAKEN if (jffs2_erase_pending_blocks(c, 1)) 103dd3: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 103dd8: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 103ddc: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 103ddf: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 103de2: e8 49 7f 00 00 call 10bd30 <== NOT EXECUTED 103de7: 85 c0 test %eax,%eax 103de9: 0f 85 d8 00 00 00 jne 103ec7 <== ALWAYS TAKEN jeb = c->gcblock; 103def: 8b 45 08 mov 0x8(%ebp),%eax 103df2: 8b 40 5c mov 0x5c(%eax),%eax 103df5: 89 85 78 ff ff ff mov %eax,-0x88(%ebp) if (!jeb) 103dfb: 85 c0 test %eax,%eax 103dfd: 0f 84 cb 00 00 00 je 103ece if (!jeb->used_size) { 103e03: 8b 85 78 ff ff ff mov -0x88(%ebp),%eax 103e09: 8b 40 14 mov 0x14(%eax),%eax 103e0c: 85 c0 test %eax,%eax 103e0e: 0f 84 b1 01 00 00 je 103fc5 <== NEVER TAKEN raw = jeb->gc_node; 103e14: 8b 85 78 ff ff ff mov -0x88(%ebp),%eax 103e1a: 8b 78 30 mov 0x30(%eax),%edi while(ref_obsolete(raw)) { 103e1d: 8b 47 04 mov 0x4(%edi),%eax 103e20: eb 08 jmp 103e2a /* Use blocks of about 256 bytes */ #define REFS_PER_BLOCK ((255/sizeof(struct jffs2_raw_node_ref))-1) static inline struct jffs2_raw_node_ref *ref_next(struct jffs2_raw_node_ref *ref) { ref++; 103e22: 83 c7 08 add $0x8,%edi if (!ref) return ref; } /* End of chain */ if (ref->flash_offset == REF_EMPTY_NODE) 103e25: 83 f8 fe cmp $0xfffffffe,%eax 103e28: 74 35 je 103e5f <== NEVER TAKEN 103e2a: 83 e0 03 and $0x3,%eax 103e2d: 83 f8 01 cmp $0x1,%eax 103e30: 0f 85 e9 01 00 00 jne 10401f if (ref->flash_offset == REF_LINK_NODE) { 103e36: 8b 47 0c mov 0xc(%edi),%eax 103e39: 83 f8 ff cmp $0xffffffff,%eax 103e3c: 75 e4 jne 103e22 ref = ref->next_in_ino; 103e3e: 8b 7f 08 mov 0x8(%edi),%edi if (!ref) 103e41: 85 ff test %edi,%edi 103e43: 74 1a je 103e5f <== NEVER TAKEN if (ref->flash_offset == REF_EMPTY_NODE) 103e45: 8b 47 04 mov 0x4(%edi),%eax 103e48: eb db jmp 103e25 !list_empty(&c->erase_pending_list)) { 103e4a: 89 d0 mov %edx,%eax 103e4c: 05 98 00 00 00 add $0x98,%eax if (!list_empty(&c->erase_complete_list) || 103e51: 39 82 98 00 00 00 cmp %eax,0x98(%edx) 103e57: 0f 85 76 ff ff ff jne 103dd3 103e5d: eb 90 jmp 103def pr_warn("eep. End of raw list while still supposedly nodes to GC\n"); 103e5f: c7 04 24 a8 e3 12 00 movl $0x12e3a8,(%esp) <== NOT EXECUTED BUG(); 103e66: bb 3b d6 12 00 mov $0x12d63b,%ebx <== NOT EXECUTED 103e6b: bf 33 01 00 00 mov $0x133,%edi <== NOT EXECUTED pr_warn("eep. End of raw list while still supposedly nodes to GC\n"); 103e70: e8 bb f8 ff ff call 103730 <== NOT EXECUTED pr_warn("erase block at 0x%08x. free_size 0x%08x, dirty_size 0x%08x, used_size 0x%08x\n", 103e75: 8b b5 78 ff ff ff mov -0x88(%ebp),%esi <== NOT EXECUTED 103e7b: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED 103e7e: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED 103e82: 8b 46 18 mov 0x18(%esi),%eax <== NOT EXECUTED 103e85: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 103e89: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED 103e8c: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 103e90: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 103e93: c7 04 24 ec e3 12 00 movl $0x12e3ec,(%esp) <== NOT EXECUTED 103e9a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 103e9e: e8 8d f8 ff ff call 103730 <== NOT EXECUTED jeb->gc_node = raw; 103ea3: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi) <== NOT EXECUTED BUG(); 103eaa: be f0 ea 12 00 mov $0x12eaf0,%esi <== NOT EXECUTED 103eaf: 89 5c 24 0c mov %ebx,0xc(%esp) <== NOT EXECUTED 103eb3: 89 74 24 08 mov %esi,0x8(%esp) <== NOT EXECUTED 103eb7: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED 103ebb: c7 04 24 f8 e2 12 00 movl $0x12e2f8,(%esp) <== NOT EXECUTED 103ec2: e8 a9 9d 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED return 0; 103ec7: 31 f6 xor %esi,%esi 103ec9: e9 3a fe ff ff jmp 103d08 /* Is this list empty? */ static __inline__ int list_empty( struct list_head *list ) { return ( list->next == list ); 103ece: 8b 45 08 mov 0x8(%ebp),%eax 103ed1: 8b 15 34 b8 15 00 mov 0x15b834,%edx 103ed7: 8b b8 b8 00 00 00 mov 0xb8(%eax),%edi if (!list_empty(&c->bad_used_list) && c->nr_free_blocks > c->resv_blocks_gcbad) { 103edd: 8d b0 b8 00 00 00 lea 0xb8(%eax),%esi } else if (n < 126 && !list_empty(&c->dirty_list)) { 103ee3: 8d 58 70 lea 0x70(%eax),%ebx int n = jiffies % 128; 103ee6: 83 e2 7f and $0x7f,%edx } else if (!list_empty(&c->clean_list)) { 103ee9: 8d 48 60 lea 0x60(%eax),%ecx 103eec: 89 7d 84 mov %edi,-0x7c(%ebp) 103eef: 89 c7 mov %eax,%edi 103ef1: eb 40 jmp 103f33 } else if (n < 50 && !list_empty(&c->erasable_list)) { 103ef3: 8d 47 78 lea 0x78(%edi),%eax 103ef6: 3b 47 78 cmp 0x78(%edi),%eax 103ef9: 75 67 jne 103f62 <== NEVER TAKEN } else if (n < 110 && !list_empty(&c->very_dirty_list)) { 103efb: 8d 47 68 lea 0x68(%edi),%eax 103efe: 3b 47 68 cmp 0x68(%edi),%eax 103f01: 75 5f jne 103f62 } else if (n < 126 && !list_empty(&c->dirty_list)) { 103f03: 3b 5f 70 cmp 0x70(%edi),%ebx 103f06: 89 d8 mov %ebx,%eax 103f08: 75 58 jne 103f62 <== NEVER TAKEN } else if (!list_empty(&c->clean_list)) { 103f0a: 39 4f 60 cmp %ecx,0x60(%edi) 103f0d: 89 c8 mov %ecx,%eax 103f0f: 75 51 jne 103f62 <== NEVER TAKEN } else if (!list_empty(&c->very_dirty_list)) { 103f11: 8d 47 68 lea 0x68(%edi),%eax 103f14: 3b 47 68 cmp 0x68(%edi),%eax 103f17: 75 49 jne 103f62 <== NEVER TAKEN } else if (!list_empty(&c->erasable_list)) { 103f19: 8d 47 78 lea 0x78(%edi),%eax 103f1c: 3b 47 78 cmp 0x78(%edi),%eax 103f1f: 75 41 jne 103f62 <== NEVER TAKEN } else if (!list_empty(&c->erasable_pending_wbuf_list)) { 103f21: 8d 87 80 00 00 00 lea 0x80(%edi),%eax 103f27: 39 87 80 00 00 00 cmp %eax,0x80(%edi) 103f2d: 0f 84 7e 00 00 00 je 103fb1 <== ALWAYS TAKEN if (!list_empty(&c->bad_used_list) && c->nr_free_blocks > c->resv_blocks_gcbad) { 103f33: 39 75 84 cmp %esi,-0x7c(%ebp) 103f36: 74 0d je 103f45 <== ALWAYS TAKEN 103f38: 0f b6 47 47 movzbl 0x47(%edi),%eax <== NOT EXECUTED 103f3c: 39 47 3c cmp %eax,0x3c(%edi) <== NOT EXECUTED 103f3f: 0f 87 99 10 00 00 ja 104fde <== NOT EXECUTED } else if (n < 50 && !list_empty(&c->erasable_list)) { 103f45: 83 fa 31 cmp $0x31,%edx 103f48: 7e a9 jle 103ef3 <== ALWAYS TAKEN } else if (n < 110 && !list_empty(&c->very_dirty_list)) { 103f4a: 83 fa 6d cmp $0x6d,%edx <== NOT EXECUTED 103f4d: 7e ac jle 103efb <== NOT EXECUTED } else if (n < 126 && !list_empty(&c->dirty_list)) { 103f4f: 83 fa 7d cmp $0x7d,%edx <== NOT EXECUTED 103f52: 7e af jle 103f03 <== NOT EXECUTED } else if (!list_empty(&c->clean_list)) { 103f54: 3b 4f 60 cmp 0x60(%edi),%ecx <== NOT EXECUTED 103f57: 89 c8 mov %ecx,%eax <== NOT EXECUTED 103f59: 75 07 jne 103f62 <== NOT EXECUTED } else if (!list_empty(&c->dirty_list)) { 103f5b: 3b 5f 70 cmp 0x70(%edi),%ebx <== NOT EXECUTED 103f5e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 103f60: 74 af je 103f11 <== NOT EXECUTED ret = list_entry(nextlist->next, struct jffs2_eraseblock, list); 103f62: 8b 08 mov (%eax),%ecx 103f64: 89 8d 78 ff ff ff mov %ecx,-0x88(%ebp) ent->prev->next = ent->next; 103f6a: 8b 01 mov (%ecx),%eax 103f6c: 8b 51 04 mov 0x4(%ecx),%edx 103f6f: 89 02 mov %eax,(%edx) ent->next->prev = ent->prev; 103f71: 89 50 04 mov %edx,0x4(%eax) c->gcblock = ret; 103f74: 8b 45 08 mov 0x8(%ebp),%eax 103f77: 89 48 5c mov %ecx,0x5c(%eax) ret->gc_node = ret->first_node; 103f7a: 8b 41 28 mov 0x28(%ecx),%eax 103f7d: 89 41 30 mov %eax,0x30(%ecx) if (!ret->gc_node) { 103f80: 85 c0 test %eax,%eax 103f82: 0f 84 5d 10 00 00 je 104fe5 <== NEVER TAKEN if (ret->wasted_size) { 103f88: 8b 95 78 ff ff ff mov -0x88(%ebp),%edx 103f8e: 8b 42 1c mov 0x1c(%edx),%eax 103f91: 85 c0 test %eax,%eax 103f93: 0f 84 6a fe ff ff je 103e03 <== ALWAYS TAKEN c->wasted_size -= ret->wasted_size; 103f99: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ret->dirty_size += ret->wasted_size; 103f9c: 01 42 18 add %eax,0x18(%edx) <== NOT EXECUTED c->wasted_size -= ret->wasted_size; 103f9f: 29 41 24 sub %eax,0x24(%ecx) <== NOT EXECUTED c->dirty_size += ret->wasted_size; 103fa2: 01 41 20 add %eax,0x20(%ecx) <== NOT EXECUTED ret->wasted_size = 0; 103fa5: c7 42 1c 00 00 00 00 movl $0x0,0x1c(%edx) <== NOT EXECUTED 103fac: e9 52 fe ff ff jmp 103e03 <== NOT EXECUTED return -EIO; 103fb1: 8b 45 08 mov 0x8(%ebp),%eax 103fb4: 83 78 40 01 cmpl $0x1,0x40(%eax) 103fb8: 19 f6 sbb %esi,%esi 103fba: 83 e6 06 and $0x6,%esi 103fbd: 83 ee 0b sub $0xb,%esi 103fc0: e9 43 fd ff ff jmp 103d08 if (c->gcblock && !c->gcblock->used_size) { 103fc5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED int ret = 0, inum, nlink; 103fc8: 31 f6 xor %esi,%esi <== NOT EXECUTED if (c->gcblock && !c->gcblock->used_size) { 103fca: 8b 40 5c mov 0x5c(%eax),%eax <== NOT EXECUTED 103fcd: 8b 50 14 mov 0x14(%eax),%edx 103fd0: 85 d2 test %edx,%edx 103fd2: 0f 85 30 fd ff ff jne 103d08 <== ALWAYS TAKEN list_add_tail(&c->gcblock->list, &c->erase_pending_list); 103fd8: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED struct list_head *prev = beforethisent->prev; 103fdb: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 103fde: 81 c1 98 00 00 00 add $0x98,%ecx <== NOT EXECUTED 103fe4: 8b 92 9c 00 00 00 mov 0x9c(%edx),%edx <== NOT EXECUTED 103fea: 89 08 mov %ecx,(%eax) <== NOT EXECUTED beforethisent->prev = newent; 103fec: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED newent->prev = prev; 103fef: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED beforethisent->prev = newent; 103ff2: 89 81 9c 00 00 00 mov %eax,0x9c(%ecx) <== NOT EXECUTED prev->next = newent; 103ff8: 89 02 mov %eax,(%edx) <== NOT EXECUTED rtems_jffs2_flash_control *fc = sb->s_flash_control; 103ffa: 8b 91 e4 00 00 00 mov 0xe4(%ecx),%edx <== NOT EXECUTED c->nr_erasing_blocks++; 104000: ff 41 40 incl 0x40(%ecx) <== NOT EXECUTED c->gcblock = NULL; 104003: c7 41 5c 00 00 00 00 movl $0x0,0x5c(%ecx) <== NOT EXECUTED if (fc->trigger_garbage_collection != NULL) { 10400a: 8b 42 20 mov 0x20(%edx),%eax <== NOT EXECUTED 10400d: 85 c0 test %eax,%eax <== NOT EXECUTED 10400f: 0f 84 f3 fc ff ff je 103d08 <== NOT EXECUTED (*fc->trigger_garbage_collection)(fc); 104015: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 104018: ff d0 call *%eax <== NOT EXECUTED 10401a: e9 e9 fc ff ff jmp 103d08 <== NOT EXECUTED gcblock_dirty = jeb->dirty_size; 10401f: 8b 95 78 ff ff ff mov -0x88(%ebp),%edx jeb->gc_node = raw; 104025: 89 7a 30 mov %edi,0x30(%edx) gcblock_dirty = jeb->dirty_size; 104028: 8b 4a 18 mov 0x18(%edx),%ecx if (!raw->next_in_ino) { 10402b: 8b 17 mov (%edi),%edx gcblock_dirty = jeb->dirty_size; 10402d: 89 8d 6c ff ff ff mov %ecx,-0x94(%ebp) if (!raw->next_in_ino) { 104033: 89 55 84 mov %edx,-0x7c(%ebp) 104036: 85 d2 test %edx,%edx 104038: 0f 84 3a 10 00 00 je 105078 <== NEVER TAKEN 10403e: 8b 55 84 mov -0x7c(%ebp),%edx 104041: 89 d3 mov %edx,%ebx return ref; } static inline struct jffs2_inode_cache *jffs2_raw_ref_to_ic(struct jffs2_raw_node_ref *raw) { while(raw->next_in_ino) 104043: 8b 12 mov (%edx),%edx 104045: 85 d2 test %edx,%edx 104047: 75 f8 jne 104041 <== NEVER TAKEN switch(ic->state) { 104049: 89 55 84 mov %edx,-0x7c(%ebp) 10404c: 0f b7 53 0a movzwl 0xa(%ebx),%edx 104050: 83 fa 04 cmp $0x4,%edx 104053: 0f 84 75 10 00 00 je 1050ce <== NEVER TAKEN 104059: 0f 87 91 00 00 00 ja 1040f0 <== NEVER TAKEN 10405f: 83 fa 01 cmp $0x1,%edx 104062: 0f 86 66 10 00 00 jbe 1050ce <== NEVER TAKEN 104068: 83 fa 03 cmp $0x3,%edx 10406b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 10406f: 90 nop 104070: 75 09 jne 10407b if (ref_flags(raw) == REF_PRISTINE) 104072: 83 f8 02 cmp $0x2,%eax 104075: 0f 84 18 10 00 00 je 105093 <== NEVER TAKEN f = jffs2_gc_fetch_inode(c, inum, !nlink); 10407b: 8b 4b 14 mov 0x14(%ebx),%ecx 10407e: 31 c0 xor %eax,%eax 104080: 85 c9 test %ecx,%ecx 104082: 0f 94 c0 sete %al 104085: 89 44 24 08 mov %eax,0x8(%esp) 104089: 8b 43 0c mov 0xc(%ebx),%eax 10408c: 89 44 24 04 mov %eax,0x4(%esp) 104090: 8b 45 08 mov 0x8(%ebp),%eax 104093: 89 04 24 mov %eax,(%esp) 104096: e8 15 f6 ff ff call 1036b0 if (IS_ERR(f)) { 10409b: 3d 18 fc ff ff cmp $0xfffffc18,%eax f = jffs2_gc_fetch_inode(c, inum, !nlink); 1040a0: 89 c3 mov %eax,%ebx if (IS_ERR(f)) { 1040a2: 0f 87 2f 0f 00 00 ja 104fd7 <== NEVER TAKEN ret = 0; 1040a8: 31 f6 xor %esi,%esi if (!f) { 1040aa: 85 c0 test %eax,%eax 1040ac: 74 2e je 1040dc <== NEVER TAKEN if (c->gcblock != jeb) { 1040ae: 8b 45 08 mov 0x8(%ebp),%eax 1040b1: 8b 95 78 ff ff ff mov -0x88(%ebp),%edx 1040b7: 3b 50 5c cmp 0x5c(%eax),%edx 1040ba: 74 71 je 10412d <== ALWAYS TAKEN jffs2_gc_release_inode(c, f); 1040bc: 89 5c 24 04 mov %ebx,0x4(%esp) 1040c0: 8b 45 08 mov 0x8(%ebp),%eax 1040c3: 89 04 24 mov %eax,(%esp) 1040c6: e8 c5 f5 ff ff call 103690 if (jeb->dirty_size == gcblock_dirty && !ref_obsolete(jeb->gc_node)) { 1040cb: 8b 85 78 ff ff ff mov -0x88(%ebp),%eax 1040d1: 8b 95 6c ff ff ff mov -0x94(%ebp),%edx 1040d7: 39 50 18 cmp %edx,0x18(%eax) 1040da: 74 29 je 104105 <== NEVER TAKEN if (c->gcblock && !c->gcblock->used_size) { 1040dc: 8b 45 08 mov 0x8(%ebp),%eax 1040df: 8b 40 5c mov 0x5c(%eax),%eax 1040e2: 85 c0 test %eax,%eax 1040e4: 0f 84 1e fc ff ff je 103d08 1040ea: e9 de fe ff ff jmp 103fcd 1040ef: 90 nop switch(ic->state) { 1040f0: 31 f6 xor %esi,%esi 1040f2: 83 fa 05 cmp $0x5,%edx <== NOT EXECUTED 1040f5: 0f 84 0d fc ff ff je 103d08 <== NOT EXECUTED 1040fb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 1040ff: 90 nop <== NOT EXECUTED 104100: e9 76 ff ff ff jmp 10407b <== NOT EXECUTED if (jeb->dirty_size == gcblock_dirty && !ref_obsolete(jeb->gc_node)) { 104105: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED 104108: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10410b: 89 c2 mov %eax,%edx <== NOT EXECUTED 10410d: 83 e2 03 and $0x3,%edx <== NOT EXECUTED 104110: 4a dec %edx <== NOT EXECUTED 104111: 74 c9 je 1040dc <== NOT EXECUTED pr_err("Error garbage collecting node at %08x!\n", 104113: c7 04 24 14 ea 12 00 movl $0x12ea14,(%esp) <== NOT EXECUTED 10411a: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED ret = -ENOSPC; 10411d: be e4 ff ff ff mov $0xffffffe4,%esi <== NOT EXECUTED pr_err("Error garbage collecting node at %08x!\n", 104122: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 104126: e8 05 f6 ff ff call 103730 <== NOT EXECUTED ret = -ENOSPC; 10412b: eb af jmp 1040dc <== NOT EXECUTED if (ref_obsolete(raw)) { 10412d: 8b 47 04 mov 0x4(%edi),%eax 104130: 83 e0 03 and $0x3,%eax 104133: 48 dec %eax 104134: 0f 84 82 ff ff ff je 1040bc <== NEVER TAKEN if (f->metadata && f->metadata->raw == raw) { 10413a: 8b 43 08 mov 0x8(%ebx),%eax 10413d: 89 45 80 mov %eax,-0x80(%ebp) 104140: 85 c0 test %eax,%eax 104142: 74 08 je 10414c 104144: 3b 38 cmp (%eax),%edi 104146: 0f 84 9c 04 00 00 je 1045e8 <== ALWAYS TAKEN for (frag = frag_first(&f->fragtree); frag; frag = frag_next(frag)) { 10414c: 8d 43 04 lea 0x4(%ebx),%eax return _RBTree_Predecessor( node ); } static inline struct rb_node *rb_first( struct rb_root *root ) { return _RBTree_Minimum( (RBTree_Control *) root ); 10414f: 89 04 24 mov %eax,(%esp) 104152: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) 104158: e8 03 19 01 00 call 115a60 <_RBTree_Minimum> static inline struct jffs2_node_frag *frag_first(struct rb_root *root) { struct rb_node *node = rb_first(root); if (!node) 10415d: 85 c0 test %eax,%eax 10415f: 74 65 je 1041c6 104161: c7 85 74 ff ff ff 00 movl $0x0,-0x8c(%ebp) 104168: 00 00 00 10416b: 31 f6 xor %esi,%esi 10416d: 89 5d 80 mov %ebx,-0x80(%ebp) 104170: eb 1e jmp 104190 104172: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 104179: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi return _RBTree_Successor( node ); 104180: 89 04 24 mov %eax,(%esp) 104183: e8 38 19 01 00 call 115ac0 <_RBTree_Successor> 104188: 85 c0 test %eax,%eax 10418a: 0f 84 8c 00 00 00 je 10421c <== NEVER TAKEN if (frag->node && frag->node->raw == raw) { 104190: 8b 48 10 mov 0x10(%eax),%ecx 104193: 85 c9 test %ecx,%ecx 104195: 74 e9 je 104180 <== NEVER TAKEN 104197: 3b 39 cmp (%ecx),%edi 104199: 75 e5 jne 104180 end = frag->ofs + frag->size; 10419b: 8b 50 18 mov 0x18(%eax),%edx 10419e: 8b 58 14 mov 0x14(%eax),%ebx 1041a1: 01 d3 add %edx,%ebx if (!nrfrags++) 1041a3: 85 f6 test %esi,%esi end = frag->ofs + frag->size; 1041a5: 89 9d 7c ff ff ff mov %ebx,-0x84(%ebp) if (!nrfrags++) 1041ab: 8d 5e 01 lea 0x1(%esi),%ebx 1041ae: 75 06 jne 1041b6 <== NEVER TAKEN start = frag->ofs; 1041b0: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) if (nrfrags == frag->node->frags) 1041b6: 3b 59 0c cmp 0xc(%ecx),%ebx 1041b9: 0f 84 0e 06 00 00 je 1047cd <== ALWAYS TAKEN 1041bf: 89 4d 84 mov %ecx,-0x7c(%ebp) <== NOT EXECUTED 1041c2: 89 de mov %ebx,%esi <== NOT EXECUTED 1041c4: eb ba jmp 104180 <== NOT EXECUTED for (fd = f->dents; fd; fd=fd->next) { 1041c6: 8b 43 0c mov 0xc(%ebx),%eax 1041c9: 89 c6 mov %eax,%esi 1041cb: eb 0b jmp 1041d8 if (fd->raw == raw) 1041cd: 3b 3e cmp (%esi),%edi 1041cf: 0f 84 68 02 00 00 je 10443d for (fd = f->dents; fd; fd=fd->next) { 1041d5: 8b 76 04 mov 0x4(%esi),%esi 1041d8: 85 f6 test %esi,%esi 1041da: 75 f1 jne 1041cd <== ALWAYS TAKEN pr_warn("Raw node at 0x%08x wasn't in node lists for ino #%u\n", 1041dc: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 1041df: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 1041e2: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 1041e6: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 1041e9: c7 04 24 48 ea 12 00 movl $0x12ea48,(%esp) <== NOT EXECUTED 1041f0: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 1041f3: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 1041f7: e8 34 f5 ff ff call 103730 <== NOT EXECUTED if (ref_obsolete(raw)) { 1041fc: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 1041ff: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 104202: 48 dec %eax <== NOT EXECUTED 104203: 0f 85 91 02 00 00 jne 10449a <== NOT EXECUTED pr_warn("But it's obsolete so we don't mind too much\n"); 104209: c7 04 24 dc e9 12 00 movl $0x12e9dc,(%esp) <== NOT EXECUTED int ret = 0; 104210: 31 f6 xor %esi,%esi <== NOT EXECUTED pr_warn("But it's obsolete so we don't mind too much\n"); 104212: e8 19 f5 ff ff call 103730 <== NOT EXECUTED 104217: e9 a0 fe ff ff jmp 1040bc <== NOT EXECUTED if (fn) { 10421c: 83 7d 84 00 cmpl $0x0,-0x7c(%ebp) <== NOT EXECUTED 104220: 8b 5d 80 mov -0x80(%ebp),%ebx <== NOT EXECUTED 104223: 89 45 80 mov %eax,-0x80(%ebp) <== NOT EXECUTED 104226: 74 9e je 1041c6 <== NOT EXECUTED if (ref_flags(raw) == REF_PRISTINE) { 104228: 8b 47 04 mov 0x4(%edi),%eax 10422b: 83 e0 03 and $0x3,%eax 10422e: 83 f8 02 cmp $0x2,%eax 104231: 0f 84 76 0d 00 00 je 104fad <== NEVER TAKEN if((start >> PAGE_SHIFT) < ((end-1) >> PAGE_SHIFT)) { 104237: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax 10423d: 8b 95 74 ff ff ff mov -0x8c(%ebp),%edx 104243: 8d 70 ff lea -0x1(%eax),%esi 104246: c1 ea 0c shr $0xc,%edx 104249: 89 f0 mov %esi,%eax 10424b: c1 e8 0c shr $0xc,%eax 10424e: 39 c2 cmp %eax,%edx 104250: 0f 83 11 09 00 00 jae 104b67 <== ALWAYS TAKEN int ret; jffs2_dbg(1, "Writing replacement hole node for ino #%u from offset 0x%x to 0x%x\n", f->inocache->ino, start, end); memset(&ri, 0, sizeof(ri)); 104256: 31 c0 xor %eax,%eax 104258: b9 11 00 00 00 mov $0x11,%ecx <== NOT EXECUTED 10425d: 8d 7d a4 lea -0x5c(%ebp),%edi <== NOT EXECUTED 104260: 89 7d 80 mov %edi,-0x80(%ebp) <== NOT EXECUTED 104263: 8d 75 a0 lea -0x60(%ebp),%esi <== NOT EXECUTED 104266: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED if(fn->frags > 1) { 104268: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 10426b: 83 78 0c 01 cmpl $0x1,0xc(%eax) <== NOT EXECUTED 10426f: 0f 86 14 08 00 00 jbe 104a89 <== NOT EXECUTED size_t readlen; uint32_t crc; /* It's partially obsoleted by a later write. So we have to write it out again with the _same_ version as before */ ret = jffs2_flash_read(c, ref_offset(fn->raw), sizeof(ri), &readlen, (char *)&ri); 104275: c7 44 24 08 44 00 00 movl $0x44,0x8(%esp) <== NOT EXECUTED 10427c: 00 10427d: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 104280: 8d 75 a0 lea -0x60(%ebp),%esi <== NOT EXECUTED 104283: 89 74 24 0c mov %esi,0xc(%esp) <== NOT EXECUTED 104287: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED 10428b: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 10428e: 8b 00 mov (%eax),%eax <== NOT EXECUTED 104290: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 104293: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 104296: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10429a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10429d: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1042a0: e8 bb 7f 00 00 call 10c260 <== NOT EXECUTED if (readlen != sizeof(ri) || ret) { 1042a5: 8b 55 a0 mov -0x60(%ebp),%edx <== NOT EXECUTED 1042a8: 83 fa 44 cmp $0x44,%edx <== NOT EXECUTED 1042ab: 0f 85 69 08 00 00 jne 104b1a <== NOT EXECUTED 1042b1: 85 c0 test %eax,%eax <== NOT EXECUTED 1042b3: 0f 85 61 08 00 00 jne 104b1a <== NOT EXECUTED pr_warn("Node read failed in jffs2_garbage_collect_hole. Ret %d, retlen %zd. Data will be lost by writing new hole node\n", ret, readlen); goto fill; } if (je16_to_cpu(ri.nodetype) != JFFS2_NODETYPE_INODE) { 1042b9: 0f b7 45 a6 movzwl -0x5a(%ebp),%eax <== NOT EXECUTED 1042bd: 3d 02 e0 00 00 cmp $0xe002,%eax <== NOT EXECUTED 1042c2: 0f 85 6b 08 00 00 jne 104b33 <== NOT EXECUTED pr_warn("%s(): Node at 0x%08x had node type 0x%04x instead of JFFS2_NODETYPE_INODE(0x%04x)\n", __func__, ref_offset(fn->raw), je16_to_cpu(ri.nodetype), JFFS2_NODETYPE_INODE); return -EIO; } if (je32_to_cpu(ri.totlen) != sizeof(ri)) { 1042c8: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED 1042cb: 83 f8 44 cmp $0x44,%eax <== NOT EXECUTED 1042ce: 0f 85 a9 05 00 00 jne 10487d <== NOT EXECUTED pr_warn("%s(): Node at 0x%08x had totlen 0x%x instead of expected 0x%zx\n", __func__, ref_offset(fn->raw), je32_to_cpu(ri.totlen), sizeof(ri)); return -EIO; } crc = crc32(0, &ri, sizeof(ri)-8); 1042d4: c7 44 24 08 3c 00 00 movl $0x3c,0x8(%esp) <== NOT EXECUTED 1042db: 00 1042dc: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 1042df: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED 1042e6: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 1042ea: e8 a1 6b 00 00 call 10ae90 <== NOT EXECUTED if (crc != je32_to_cpu(ri.node_crc)) { 1042ef: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 1042f2: 39 d0 cmp %edx,%eax <== NOT EXECUTED 1042f4: 0f 85 f0 07 00 00 jne 104aea <== NOT EXECUTED /* FIXME: We could possibly deal with this by writing new holes for each frag */ pr_warn("Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n", start, end, f->inocache->ino); goto fill; } if (ri.compr != JFFS2_COMPR_ZERO) { 1042fa: 80 7d dc 01 cmpb $0x1,-0x24(%ebp) <== NOT EXECUTED 1042fe: 0f 85 38 07 00 00 jne 104a3c <== NOT EXECUTED } static inline struct rb_node *rb_last( struct rb_root *root ) { return _RBTree_Maximum( (RBTree_Control *) root ); 104304: 8b 85 70 ff ff ff mov -0x90(%ebp),%eax <== NOT EXECUTED 10430a: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10430d: e8 7e 17 01 00 call 115a90 <_RBTree_Maximum> <== NOT EXECUTED static inline struct jffs2_node_frag *frag_last(struct rb_root *root) { struct rb_node *node = rb_last(root); if (!node) 104312: 85 c0 test %eax,%eax <== NOT EXECUTED 104314: 0f 84 2c 06 00 00 je 104946 <== NOT EXECUTED frag = frag_last(&f->fragtree); if (frag) /* Fetch the inode length from the fragtree rather then * from i_size since i_size may have not been updated yet */ ilen = frag->ofs + frag->size; 10431a: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED 10431d: 03 50 18 add 0x18(%eax),%edx <== NOT EXECUTED 104320: 89 d0 mov %edx,%eax <== NOT EXECUTED return osmode & (S_IFMT | S_IRWXU | S_IRWXG | S_IRWXO); 104322: 8b 53 c4 mov -0x3c(%ebx),%edx <== NOT EXECUTED 104325: 81 e2 ff f1 00 00 and $0xf1ff,%edx <== NOT EXECUTED else ilen = JFFS2_F_I_SIZE(f); ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f)); 10432b: 89 55 b8 mov %edx,-0x48(%ebp) <== NOT EXECUTED ri.uid = cpu_to_je16(JFFS2_F_I_UID(f)); 10432e: 0f b7 53 ca movzwl -0x36(%ebx),%edx <== NOT EXECUTED 104332: 66 89 55 bc mov %dx,-0x44(%ebp) <== NOT EXECUTED ri.gid = cpu_to_je16(JFFS2_F_I_GID(f)); 104336: 8b 53 cc mov -0x34(%ebx),%edx <== NOT EXECUTED ri.isize = cpu_to_je32(ilen); 104339: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f)); 10433c: 8b 43 d0 mov -0x30(%ebx),%eax <== NOT EXECUTED ri.gid = cpu_to_je16(JFFS2_F_I_GID(f)); 10433f: 66 89 55 be mov %dx,-0x42(%ebp) <== NOT EXECUTED ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f)); 104343: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f)); 104346: 8b 43 e0 mov -0x20(%ebx),%eax <== NOT EXECUTED 104349: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f)); 10434c: 8b 43 d8 mov -0x28(%ebx),%eax <== NOT EXECUTED ri.data_crc = cpu_to_je32(0); ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8)); 10434f: c7 44 24 08 3c 00 00 movl $0x3c,0x8(%esp) <== NOT EXECUTED 104356: 00 104357: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED ri.data_crc = cpu_to_je32(0); 10435e: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f)); 104365: 89 45 c8 mov %eax,-0x38(%ebp) <== NOT EXECUTED ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8)); 104368: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 10436b: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10436f: e8 1c 6b 00 00 call 10ae90 <== NOT EXECUTED ret = jffs2_reserve_space_gc(c, sizeof(ri), &alloclen, 104374: 89 74 24 08 mov %esi,0x8(%esp) <== NOT EXECUTED 104378: c7 44 24 0c 12 00 00 movl $0x12,0xc(%esp) <== NOT EXECUTED 10437f: 00 104380: c7 44 24 04 44 00 00 movl $0x44,0x4(%esp) <== NOT EXECUTED 104387: 00 ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8)); 104388: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED ret = jffs2_reserve_space_gc(c, sizeof(ri), &alloclen, 10438b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10438e: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 104391: e8 fa 27 00 00 call 106b90 <== NOT EXECUTED JFFS2_SUMMARY_INODE_SIZE); if (ret) { 104396: 85 c0 test %eax,%eax <== NOT EXECUTED ret = jffs2_reserve_space_gc(c, sizeof(ri), &alloclen, 104398: 89 c6 mov %eax,%esi <== NOT EXECUTED if (ret) { 10439a: 0f 85 89 05 00 00 jne 104929 <== NOT EXECUTED pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_hole failed: %d\n", sizeof(ri), ret); return ret; } new_fn = jffs2_write_dnode(c, f, &ri, NULL, 0, ALLOC_GC); 1043a0: c7 44 24 14 02 00 00 movl $0x2,0x14(%esp) <== NOT EXECUTED 1043a7: 00 1043a8: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 1043ab: c7 44 24 10 00 00 00 movl $0x0,0x10(%esp) <== NOT EXECUTED 1043b2: 00 1043b3: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp) <== NOT EXECUTED 1043ba: 00 1043bb: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED 1043bf: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 1043c3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1043c6: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1043c9: e8 82 53 00 00 call 109750 <== NOT EXECUTED if (IS_ERR(new_fn)) { 1043ce: 3d 18 fc ff ff cmp $0xfffffc18,%eax <== NOT EXECUTED new_fn = jffs2_write_dnode(c, f, &ri, NULL, 0, ALLOC_GC); 1043d3: 89 c7 mov %eax,%edi <== NOT EXECUTED if (IS_ERR(new_fn)) { 1043d5: 0f 87 37 05 00 00 ja 104912 <== NOT EXECUTED pr_warn("Error writing new hole node: %ld\n", PTR_ERR(new_fn)); return PTR_ERR(new_fn); } if (je32_to_cpu(ri.version) == f->highest_version) { 1043db: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 1043dd: 39 45 b4 cmp %eax,-0x4c(%ebp) <== NOT EXECUTED 1043e0: 0f 84 e6 04 00 00 je 1048cc <== NOT EXECUTED __func__, fn->frags, je32_to_cpu(ri.version), f->highest_version, je32_to_cpu(ri.ino)); }); /* This is a partially-overlapped hole node. Mark it REF_NORMAL not REF_PRISTINE */ mark_ref_normal(new_fn->raw); 1043e6: 8b 07 mov (%edi),%eax <== NOT EXECUTED for (frag = jffs2_lookup_node_frag(&f->fragtree, fn->ofs); 1043e8: 8b 95 70 ff ff ff mov -0x90(%ebp),%edx <== NOT EXECUTED mark_ref_normal(new_fn->raw); 1043ee: 83 48 04 03 orl $0x3,0x4(%eax) <== NOT EXECUTED for (frag = jffs2_lookup_node_frag(&f->fragtree, fn->ofs); 1043f2: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 1043f5: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 1043f8: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 1043fb: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 1043ff: e8 7c 19 00 00 call 105d80 <== NOT EXECUTED 104404: 89 75 80 mov %esi,-0x80(%ebp) <== NOT EXECUTED 104407: 89 de mov %ebx,%esi <== NOT EXECUTED 104409: 8b 5d 84 mov -0x7c(%ebp),%ebx <== NOT EXECUTED 10440c: eb 08 jmp 104416 <== NOT EXECUTED return _RBTree_Successor( node ); 10440e: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 104411: e8 aa 16 01 00 call 115ac0 <_RBTree_Successor> <== NOT EXECUTED 104416: 85 c0 test %eax,%eax <== NOT EXECUTED 104418: 0f 84 30 05 00 00 je 10494e <== NOT EXECUTED frag; frag = frag_next(frag)) { if (frag->ofs > fn->size + fn->ofs) 10441e: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED 104421: 03 4b 08 add 0x8(%ebx),%ecx <== NOT EXECUTED 104424: 39 48 18 cmp %ecx,0x18(%eax) <== NOT EXECUTED 104427: 0f 87 21 05 00 00 ja 10494e <== NOT EXECUTED break; if (frag->node == fn) { 10442d: 39 58 10 cmp %ebx,0x10(%eax) <== NOT EXECUTED 104430: 75 dc jne 10440e <== NOT EXECUTED frag->node = new_fn; 104432: 89 78 10 mov %edi,0x10(%eax) <== NOT EXECUTED new_fn->frags++; 104435: ff 47 0c incl 0xc(%edi) <== NOT EXECUTED fn->frags--; 104438: ff 4b 0c decl 0xc(%ebx) <== NOT EXECUTED 10443b: eb d1 jmp 10440e <== NOT EXECUTED if (fd && fd->ino) { 10443d: 83 7e 0c 00 cmpl $0x0,0xc(%esi) struct jffs2_full_dirent **fdp = &f->dents; 104441: 8d 53 0c lea 0xc(%ebx),%edx if (fd && fd->ino) { 104444: 74 0c je 104452 <== NEVER TAKEN 104446: eb 76 jmp 1044be if ((*fdp) == fd) { 104448: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10444a: 74 29 je 104475 <== NOT EXECUTED fdp = &(*fdp)->next; 10444c: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10444f: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED while (*fdp) { 104452: 85 c0 test %eax,%eax <== NOT EXECUTED 104454: 75 f2 jne 104448 <== NOT EXECUTED pr_warn("Deletion dirent \"%s\" not found in list for ino #%u\n", 104456: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 104459: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10445c: c7 04 24 9c e9 12 00 movl $0x12e99c,(%esp) <== NOT EXECUTED 104463: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 104467: 8d 46 15 lea 0x15(%esi),%eax <== NOT EXECUTED 10446a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10446e: e8 bd f2 ff ff call 103730 <== NOT EXECUTED 104473: eb 05 jmp 10447a <== NOT EXECUTED *fdp = fd->next; 104475: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 104478: 89 02 mov %eax,(%edx) <== NOT EXECUTED jffs2_mark_node_obsolete(c, fd->raw); 10447a: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10447c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 104480: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 104483: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 104486: e8 35 1f 00 00 call 1063c0 <== NOT EXECUTED jffs2_free_full_dirent(fd); 10448b: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED ret = jffs2_garbage_collect_deletion_dirent(c, jeb, f, fd); 10448e: 31 f6 xor %esi,%esi <== NOT EXECUTED jffs2_free_full_dirent(fd); 104490: e8 9b 0c 00 00 call 105130 <== NOT EXECUTED return 0; 104495: e9 22 fc ff ff jmp 1040bc <== NOT EXECUTED BUG(); 10449a: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED 1044a1: 00 1044a2: c7 44 24 08 c0 ea 12 movl $0x12eac0,0x8(%esp) <== NOT EXECUTED 1044a9: 00 1044aa: c7 44 24 04 48 02 00 movl $0x248,0x4(%esp) <== NOT EXECUTED 1044b1: 00 1044b2: c7 04 24 f8 e2 12 00 movl $0x12e2f8,(%esp) <== NOT EXECUTED 1044b9: e8 b2 97 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED rd.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 1044be: c7 45 a4 85 19 01 e0 movl $0xe0011985,-0x5c(%ebp) rd.nsize = strlen(fd->name); 1044c5: 8d 7e 15 lea 0x15(%esi),%edi 1044c8: 89 3c 24 mov %edi,(%esp) 1044cb: e8 70 2b 02 00 call 127040 rd.hdr_crc = cpu_to_je32(crc32(0, &rd, sizeof(struct jffs2_unknown_node)-4)); 1044d0: c7 44 24 08 08 00 00 movl $0x8,0x8(%esp) 1044d7: 00 1044d8: c7 04 24 00 00 00 00 movl $0x0,(%esp) rd.nsize = strlen(fd->name); 1044df: 88 45 c0 mov %al,-0x40(%ebp) rd.totlen = cpu_to_je32(sizeof(rd) + rd.nsize); 1044e2: 0f b6 c0 movzbl %al,%eax 1044e5: 83 c0 28 add $0x28,%eax 1044e8: 89 45 a8 mov %eax,-0x58(%ebp) rd.hdr_crc = cpu_to_je32(crc32(0, &rd, sizeof(struct jffs2_unknown_node)-4)); 1044eb: 8d 45 a4 lea -0x5c(%ebp),%eax 1044ee: 89 44 24 04 mov %eax,0x4(%esp) 1044f2: 89 45 80 mov %eax,-0x80(%ebp) 1044f5: e8 96 69 00 00 call 10ae90 if (JFFS2_F_I_MTIME(f) == JFFS2_F_I_CTIME(f)) 1044fa: 8b 53 e4 mov -0x1c(%ebx),%edx rd.hdr_crc = cpu_to_je32(crc32(0, &rd, sizeof(struct jffs2_unknown_node)-4)); 1044fd: 89 45 ac mov %eax,-0x54(%ebp) rd.pino = cpu_to_je32(f->inocache->ino); 104500: 8b 43 14 mov 0x14(%ebx),%eax 104503: 8b 40 0c mov 0xc(%eax),%eax 104506: 89 45 b0 mov %eax,-0x50(%ebp) rd.version = cpu_to_je32(++f->highest_version); 104509: 8b 03 mov (%ebx),%eax 10450b: 40 inc %eax 10450c: 89 03 mov %eax,(%ebx) 10450e: 89 45 b4 mov %eax,-0x4c(%ebp) rd.ino = cpu_to_je32(fd->ino); 104511: 8b 46 0c mov 0xc(%esi),%eax if (JFFS2_F_I_MTIME(f) == JFFS2_F_I_CTIME(f)) 104514: 39 53 dc cmp %edx,-0x24(%ebx) rd.ino = cpu_to_je32(fd->ino); 104517: 89 45 b8 mov %eax,-0x48(%ebp) if (JFFS2_F_I_MTIME(f) == JFFS2_F_I_CTIME(f)) 10451a: 8b 43 e0 mov -0x20(%ebx),%eax 10451d: 0f 84 60 04 00 00 je 104983 <== ALWAYS TAKEN 104523: 31 c0 xor %eax,%eax 104525: 89 45 bc mov %eax,-0x44(%ebp) rd.type = fd->type; 104528: 0f b6 46 14 movzbl 0x14(%esi),%eax rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8)); 10452c: c7 44 24 08 20 00 00 movl $0x20,0x8(%esp) 104533: 00 104534: c7 04 24 00 00 00 00 movl $0x0,(%esp) rd.type = fd->type; 10453b: 88 45 c1 mov %al,-0x3f(%ebp) rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8)); 10453e: 8b 45 80 mov -0x80(%ebp),%eax 104541: 89 44 24 04 mov %eax,0x4(%esp) 104545: e8 46 69 00 00 call 10ae90 rd.name_crc = cpu_to_je32(crc32(0, fd->name, rd.nsize)); 10454a: 89 7c 24 04 mov %edi,0x4(%esp) 10454e: c7 04 24 00 00 00 00 movl $0x0,(%esp) rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8)); 104555: 89 45 c4 mov %eax,-0x3c(%ebp) rd.name_crc = cpu_to_je32(crc32(0, fd->name, rd.nsize)); 104558: 0f b6 45 c0 movzbl -0x40(%ebp),%eax 10455c: 89 44 24 08 mov %eax,0x8(%esp) 104560: e8 2b 69 00 00 call 10ae90 104565: 89 45 c8 mov %eax,-0x38(%ebp) JFFS2_SUMMARY_DIRENT_SIZE(rd.nsize)); 104568: 0f b6 45 c0 movzbl -0x40(%ebp),%eax 10456c: 8d 50 18 lea 0x18(%eax),%edx ret = jffs2_reserve_space_gc(c, sizeof(rd)+rd.nsize, &alloclen, 10456f: 83 c0 28 add $0x28,%eax 104572: 89 44 24 04 mov %eax,0x4(%esp) 104576: 8b 45 08 mov 0x8(%ebp),%eax 104579: 89 54 24 0c mov %edx,0xc(%esp) 10457d: 8d 55 a0 lea -0x60(%ebp),%edx 104580: 89 54 24 08 mov %edx,0x8(%esp) 104584: 89 04 24 mov %eax,(%esp) 104587: e8 04 26 00 00 call 106b90 if (ret) { 10458c: 85 c0 test %eax,%eax ret = jffs2_reserve_space_gc(c, sizeof(rd)+rd.nsize, &alloclen, 10458e: 89 c6 mov %eax,%esi if (ret) { 104590: 0f 85 86 04 00 00 jne 104a1c <== NEVER TAKEN new_fd = jffs2_write_dirent(c, f, &rd, fd->name, rd.nsize, ALLOC_GC); 104596: 89 7c 24 0c mov %edi,0xc(%esp) 10459a: 0f b6 45 c0 movzbl -0x40(%ebp),%eax 10459e: c7 44 24 14 02 00 00 movl $0x2,0x14(%esp) 1045a5: 00 1045a6: 89 5c 24 04 mov %ebx,0x4(%esp) 1045aa: 89 44 24 10 mov %eax,0x10(%esp) 1045ae: 8b 45 80 mov -0x80(%ebp),%eax 1045b1: 89 44 24 08 mov %eax,0x8(%esp) 1045b5: 8b 45 08 mov 0x8(%ebp),%eax 1045b8: 89 04 24 mov %eax,(%esp) 1045bb: e8 30 55 00 00 call 109af0 if (IS_ERR(new_fd)) { 1045c0: 3d 18 fc ff ff cmp $0xfffffc18,%eax new_fd = jffs2_write_dirent(c, f, &rd, fd->name, rd.nsize, ALLOC_GC); 1045c5: 89 c7 mov %eax,%edi if (IS_ERR(new_fd)) { 1045c7: 0f 87 38 04 00 00 ja 104a05 <== NEVER TAKEN jffs2_add_fd_to_list(c, new_fd, &f->dents); 1045cd: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED 1045d1: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED 1045d4: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 1045d8: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1045db: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1045de: e8 6d 0e 00 00 call 105450 <== NOT EXECUTED ret = jffs2_garbage_collect_dirent(c, jeb, f, fd); 1045e3: e9 d4 fa ff ff jmp 1040bc if (S_ISBLK(JFFS2_F_I_MODE(f)) || 1045e8: 8b 43 c4 mov -0x3c(%ebx),%eax 1045eb: 89 c2 mov %eax,%edx 1045ed: 25 00 b0 00 00 and $0xb000,%eax 1045f2: 81 e2 00 f0 00 00 and $0xf000,%edx 1045f8: 3d 00 20 00 00 cmp $0x2000,%eax 1045fd: 0f 84 a9 02 00 00 je 1048ac <== NEVER TAKEN int mdatalen = 0; 104603: c7 85 7c ff ff ff 00 movl $0x0,-0x84(%ebp) 10460a: 00 00 00 } else if (S_ISLNK(JFFS2_F_I_MODE(f))) { 10460d: 81 fa 00 a0 00 00 cmp $0xa000,%edx 104613: 0f 84 ec 01 00 00 je 104805 <== NEVER TAKEN ret = jffs2_reserve_space_gc(c, sizeof(ri) + mdatalen, &alloclen, 104619: c7 44 24 0c 12 00 00 movl $0x12,0xc(%esp) 104620: 00 104621: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax 104627: 83 c0 44 add $0x44,%eax 10462a: 89 85 74 ff ff ff mov %eax,-0x8c(%ebp) 104630: 89 c2 mov %eax,%edx 104632: 89 54 24 04 mov %edx,0x4(%esp) 104636: 8d 45 a0 lea -0x60(%ebp),%eax 104639: 89 44 24 08 mov %eax,0x8(%esp) 10463d: 8b 45 08 mov 0x8(%ebp),%eax 104640: 89 04 24 mov %eax,(%esp) 104643: e8 48 25 00 00 call 106b90 if (ret) { 104648: 85 c0 test %eax,%eax ret = jffs2_reserve_space_gc(c, sizeof(ri) + mdatalen, &alloclen, 10464a: 89 c6 mov %eax,%esi if (ret) { 10464c: 0f 85 97 01 00 00 jne 1047e9 <== NEVER TAKEN last_frag = frag_last(&f->fragtree); 104652: 8d 43 04 lea 0x4(%ebx),%eax 104655: 89 04 24 mov %eax,(%esp) return _RBTree_Maximum( (RBTree_Control *) root ); 104658: e8 33 14 01 00 call 115a90 <_RBTree_Maximum> 10465d: 85 c0 test %eax,%eax 10465f: 0f 84 76 01 00 00 je 1047db <== NEVER TAKEN ilen = last_frag->ofs + last_frag->size; 104665: 8b 50 14 mov 0x14(%eax),%edx 104668: 03 50 18 add 0x18(%eax),%edx 10466b: 89 95 70 ff ff ff mov %edx,-0x90(%ebp) memset(&ri, 0, sizeof(ri)); 104671: 8d 55 ac lea -0x54(%ebp),%edx 104674: 31 c0 xor %eax,%eax 104676: 89 d7 mov %edx,%edi 104678: b9 0f 00 00 00 mov $0xf,%ecx 10467d: f3 ab rep stos %eax,%es:(%edi) ri.totlen = cpu_to_je32(sizeof(ri) + mdatalen); 10467f: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4)); 104685: c7 44 24 08 08 00 00 movl $0x8,0x8(%esp) 10468c: 00 10468d: c7 04 24 00 00 00 00 movl $0x0,(%esp) ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 104694: c7 45 a4 85 19 02 e0 movl $0xe0021985,-0x5c(%ebp) ri.totlen = cpu_to_je32(sizeof(ri) + mdatalen); 10469b: 89 45 a8 mov %eax,-0x58(%ebp) ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4)); 10469e: 8d 45 a4 lea -0x5c(%ebp),%eax 1046a1: 89 44 24 04 mov %eax,0x4(%esp) 1046a5: e8 e6 67 00 00 call 10ae90 ri.csize = cpu_to_je32(mdatalen); 1046aa: 8b bd 7c ff ff ff mov -0x84(%ebp),%edi ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4)); 1046b0: 89 45 ac mov %eax,-0x54(%ebp) ri.ino = cpu_to_je32(f->inocache->ino); 1046b3: 8b 43 14 mov 0x14(%ebx),%eax 1046b6: 8b 40 0c mov 0xc(%eax),%eax 1046b9: 89 45 b0 mov %eax,-0x50(%ebp) ri.version = cpu_to_je32(++f->highest_version); 1046bc: 8b 03 mov (%ebx),%eax 1046be: 40 inc %eax 1046bf: 89 03 mov %eax,(%ebx) 1046c1: 89 45 b4 mov %eax,-0x4c(%ebp) 1046c4: 8b 43 c4 mov -0x3c(%ebx),%eax 1046c7: 25 ff f1 00 00 and $0xf1ff,%eax ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f)); 1046cc: 89 45 b8 mov %eax,-0x48(%ebp) ri.uid = cpu_to_je16(JFFS2_F_I_UID(f)); 1046cf: 0f b7 43 ca movzwl -0x36(%ebx),%eax 1046d3: 66 89 45 bc mov %ax,-0x44(%ebp) ri.gid = cpu_to_je16(JFFS2_F_I_GID(f)); 1046d7: 8b 43 cc mov -0x34(%ebx),%eax 1046da: 66 89 45 be mov %ax,-0x42(%ebp) ri.isize = cpu_to_je32(ilen); 1046de: 8b 85 70 ff ff ff mov -0x90(%ebp),%eax 1046e4: 89 45 c0 mov %eax,-0x40(%ebp) ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f)); 1046e7: 8b 43 d0 mov -0x30(%ebx),%eax 1046ea: 89 45 c4 mov %eax,-0x3c(%ebp) ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f)); 1046ed: 8b 43 e0 mov -0x20(%ebx),%eax 1046f0: 89 45 cc mov %eax,-0x34(%ebp) ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f)); 1046f3: 8b 43 d8 mov -0x28(%ebx),%eax ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8)); 1046f6: c7 44 24 08 3c 00 00 movl $0x3c,0x8(%esp) 1046fd: 00 1046fe: c7 04 24 00 00 00 00 movl $0x0,(%esp) ri.csize = cpu_to_je32(mdatalen); 104705: 89 7d d4 mov %edi,-0x2c(%ebp) ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f)); 104708: 89 45 c8 mov %eax,-0x38(%ebp) ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8)); 10470b: 8d 45 a4 lea -0x5c(%ebp),%eax 10470e: 89 44 24 04 mov %eax,0x4(%esp) ri.dsize = cpu_to_je32(mdatalen); 104712: 89 7d d8 mov %edi,-0x28(%ebp) ri.offset = cpu_to_je32(0); 104715: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) ri.compr = JFFS2_COMPR_NONE; 10471c: c6 45 dc 00 movb $0x0,-0x24(%ebp) ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8)); 104720: e8 6b 67 00 00 call 10ae90 ri.data_crc = cpu_to_je32(crc32(0, mdata, mdatalen)); 104725: 89 7c 24 08 mov %edi,0x8(%esp) 104729: c7 04 24 00 00 00 00 movl $0x0,(%esp) ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8)); 104730: 89 45 e4 mov %eax,-0x1c(%ebp) ri.data_crc = cpu_to_je32(crc32(0, mdata, mdatalen)); 104733: 8b 45 84 mov -0x7c(%ebp),%eax 104736: 89 44 24 04 mov %eax,0x4(%esp) 10473a: e8 51 67 00 00 call 10ae90 new_fn = jffs2_write_dnode(c, f, &ri, mdata, mdatalen, ALLOC_GC); 10473f: 89 7c 24 10 mov %edi,0x10(%esp) 104743: c7 44 24 14 02 00 00 movl $0x2,0x14(%esp) 10474a: 00 10474b: 89 5c 24 04 mov %ebx,0x4(%esp) ri.data_crc = cpu_to_je32(crc32(0, mdata, mdatalen)); 10474f: 89 45 e0 mov %eax,-0x20(%ebp) new_fn = jffs2_write_dnode(c, f, &ri, mdata, mdatalen, ALLOC_GC); 104752: 8b 45 84 mov -0x7c(%ebp),%eax 104755: 89 44 24 0c mov %eax,0xc(%esp) 104759: 8d 45 a4 lea -0x5c(%ebp),%eax 10475c: 89 44 24 08 mov %eax,0x8(%esp) 104760: 8b 45 08 mov 0x8(%ebp),%eax 104763: 89 04 24 mov %eax,(%esp) 104766: e8 e5 4f 00 00 call 109750 if (IS_ERR(new_fn)) { 10476b: 3d 18 fc ff ff cmp $0xfffffc18,%eax new_fn = jffs2_write_dnode(c, f, &ri, mdata, mdatalen, ALLOC_GC); 104770: 89 c7 mov %eax,%edi if (IS_ERR(new_fn)) { 104772: 77 45 ja 1047b9 <== NEVER TAKEN jffs2_mark_node_obsolete(c, fn->raw); 104774: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 104777: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10477a: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10477c: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 10477f: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 104783: e8 38 1c 00 00 call 1063c0 <== NOT EXECUTED jffs2_free_full_dnode(fn); 104788: 8b 45 80 mov -0x80(%ebp),%eax 10478b: 89 04 24 mov %eax,(%esp) 10478e: e8 cd 09 00 00 call 105160 f->metadata = new_fn; 104793: 89 7b 08 mov %edi,0x8(%ebx) <== NOT EXECUTED if (S_ISLNK(JFFS2_F_I_MODE(f))) 104796: 8b 43 c4 mov -0x3c(%ebx),%eax <== NOT EXECUTED 104799: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 10479e: 3d 00 a0 00 00 cmp $0xa000,%eax <== NOT EXECUTED 1047a3: 0f 85 13 f9 ff ff jne 1040bc <== NOT EXECUTED kfree(mdata); 1047a9: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 1047ac: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1047af: e8 7c 99 00 00 call 10e130 <== NOT EXECUTED 1047b4: e9 03 f9 ff ff jmp 1040bc <== NOT EXECUTED pr_warn("Error writing new dnode: %ld\n", PTR_ERR(new_fn)); 1047b9: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED ret = PTR_ERR(new_fn); 1047bd: 89 fe mov %edi,%esi <== NOT EXECUTED pr_warn("Error writing new dnode: %ld\n", PTR_ERR(new_fn)); 1047bf: c7 04 24 80 e5 12 00 movl $0x12e580,(%esp) <== NOT EXECUTED 1047c6: e8 65 ef ff ff call 103730 <== NOT EXECUTED goto out; 1047cb: eb c9 jmp 104796 <== NOT EXECUTED 1047cd: 89 4d 84 mov %ecx,-0x7c(%ebp) 1047d0: 8b 5d 80 mov -0x80(%ebp),%ebx 1047d3: 89 45 80 mov %eax,-0x80(%ebp) 1047d6: e9 4d fa ff ff jmp 104228 ilen = JFFS2_F_I_SIZE(f); 1047db: 8b 43 f0 mov -0x10(%ebx),%eax <== NOT EXECUTED 1047de: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) <== NOT EXECUTED 1047e4: e9 88 fe ff ff jmp 104671 <== NOT EXECUTED pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_metadata failed: %d\n", 1047e9: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 1047ed: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax <== NOT EXECUTED 1047f3: c7 04 24 28 e5 12 00 movl $0x12e528,(%esp) <== NOT EXECUTED 1047fa: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 1047fe: e8 2d ef ff ff call 103730 <== NOT EXECUTED goto out; 104803: eb 91 jmp 104796 <== NOT EXECUTED mdatalen = fn->size; 104805: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 104808: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED mdata = kmalloc(fn->size, GFP_KERNEL); 10480b: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED mdatalen = fn->size; 10480e: 89 85 7c ff ff ff mov %eax,-0x84(%ebp) <== NOT EXECUTED mdata = kmalloc(fn->size, GFP_KERNEL); 104814: e8 07 9d 00 00 call 10e520 <== NOT EXECUTED 104819: 89 45 84 mov %eax,-0x7c(%ebp) <== NOT EXECUTED if (!mdata) { 10481c: 85 c0 test %eax,%eax <== NOT EXECUTED 10481e: 0f 84 92 00 00 00 je 1048b6 <== NOT EXECUTED ret = jffs2_read_dnode(c, f, fn, mdata, 0, mdatalen); 104824: c7 44 24 10 00 00 00 movl $0x0,0x10(%esp) <== NOT EXECUTED 10482b: 00 10482c: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax <== NOT EXECUTED 104832: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED 104836: 89 44 24 14 mov %eax,0x14(%esp) <== NOT EXECUTED 10483a: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 10483d: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 104841: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 104844: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 104848: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10484b: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10484e: e8 9d 25 00 00 call 106df0 <== NOT EXECUTED if (ret) { 104853: 85 c0 test %eax,%eax <== NOT EXECUTED ret = jffs2_read_dnode(c, f, fn, mdata, 0, mdatalen); 104855: 89 c6 mov %eax,%esi <== NOT EXECUTED if (ret) { 104857: 0f 84 bc fd ff ff je 104619 <== NOT EXECUTED pr_warn("read of old metadata failed in jffs2_garbage_collect_metadata(): %d\n", 10485d: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 104861: c7 04 24 d8 e4 12 00 movl $0x12e4d8,(%esp) <== NOT EXECUTED 104868: e8 c3 ee ff ff call 103730 <== NOT EXECUTED kfree(mdata); 10486d: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 104870: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 104873: e8 b8 98 00 00 call 10e130 <== NOT EXECUTED return ret; 104878: e9 3f f8 ff ff jmp 1040bc <== NOT EXECUTED pr_warn("%s(): Node at 0x%08x had totlen 0x%x instead of expected 0x%zx\n", 10487d: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 104881: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 104884: c7 44 24 10 44 00 00 movl $0x44,0x10(%esp) <== NOT EXECUTED 10488b: 00 10488c: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10488e: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 104891: c7 44 24 04 a4 ea 12 movl $0x12eaa4,0x4(%esp) <== NOT EXECUTED 104898: 00 104899: c7 04 24 84 e6 12 00 movl $0x12e684,(%esp) <== NOT EXECUTED 1048a0: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 1048a3: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 1048a7: e8 84 ee ff ff call 103730 <== NOT EXECUTED return -EIO; 1048ac: be fb ff ff ff mov $0xfffffffb,%esi <== NOT EXECUTED 1048b1: e9 06 f8 ff ff jmp 1040bc <== NOT EXECUTED pr_warn("kmalloc of mdata failed in jffs2_garbage_collect_metadata()\n"); 1048b6: c7 04 24 90 e4 12 00 movl $0x12e490,(%esp) <== NOT EXECUTED return -ENOMEM; 1048bd: be f4 ff ff ff mov $0xfffffff4,%esi <== NOT EXECUTED pr_warn("kmalloc of mdata failed in jffs2_garbage_collect_metadata()\n"); 1048c2: e8 69 ee ff ff call 103730 <== NOT EXECUTED return -ENOMEM; 1048c7: e9 f0 f7 ff ff jmp 1040bc <== NOT EXECUTED jffs2_add_full_dnode_to_inode(c, f, new_fn); 1048cc: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED 1048d0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1048d3: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED 1048d7: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1048da: e8 d1 0d 00 00 call 1056b0 <== NOT EXECUTED if (f->metadata) { 1048df: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 1048e2: 85 c0 test %eax,%eax <== NOT EXECUTED 1048e4: 0f 84 d2 f7 ff ff je 1040bc <== NOT EXECUTED jffs2_mark_node_obsolete(c, f->metadata->raw); 1048ea: 8b 00 mov (%eax),%eax <== NOT EXECUTED 1048ec: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 1048f0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1048f3: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1048f6: e8 c5 1a 00 00 call 1063c0 <== NOT EXECUTED jffs2_free_full_dnode(f->metadata); 1048fb: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 1048fe: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 104901: e8 5a 08 00 00 call 105160 <== NOT EXECUTED f->metadata = NULL; 104906: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED 10490d: e9 aa f7 ff ff jmp 1040bc <== NOT EXECUTED pr_warn("Error writing new hole node: %ld\n", PTR_ERR(new_fn)); 104912: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED return PTR_ERR(new_fn); 104916: 89 fe mov %edi,%esi <== NOT EXECUTED pr_warn("Error writing new hole node: %ld\n", PTR_ERR(new_fn)); 104918: c7 04 24 f8 e7 12 00 movl $0x12e7f8,(%esp) <== NOT EXECUTED 10491f: e8 0c ee ff ff call 103730 <== NOT EXECUTED return PTR_ERR(new_fn); 104924: e9 93 f7 ff ff jmp 1040bc <== NOT EXECUTED pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_hole failed: %d\n", 104929: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 10492d: c7 44 24 04 44 00 00 movl $0x44,0x4(%esp) <== NOT EXECUTED 104934: 00 104935: c7 04 24 a4 e7 12 00 movl $0x12e7a4,(%esp) <== NOT EXECUTED 10493c: e8 ef ed ff ff call 103730 <== NOT EXECUTED return ret; 104941: e9 76 f7 ff ff jmp 1040bc <== NOT EXECUTED ilen = JFFS2_F_I_SIZE(f); 104946: 8b 43 f0 mov -0x10(%ebx),%eax <== NOT EXECUTED 104949: e9 d4 f9 ff ff jmp 104322 <== NOT EXECUTED } } if (fn->frags) { 10494e: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 104951: 89 f3 mov %esi,%ebx <== NOT EXECUTED 104953: 8b 75 80 mov -0x80(%ebp),%esi <== NOT EXECUTED 104956: 83 78 0c 00 cmpl $0x0,0xc(%eax) <== NOT EXECUTED 10495a: 75 71 jne 1049cd <== NOT EXECUTED pr_warn("%s(): Old node still has frags!\n", __func__); BUG(); } if (!new_fn->frags) { 10495c: 83 7f 0c 00 cmpl $0x0,0xc(%edi) <== NOT EXECUTED 104960: 74 33 je 104995 <== NOT EXECUTED pr_warn("%s(): New node has no frags!\n", __func__); BUG(); } jffs2_mark_node_obsolete(c, fn->raw); 104962: 8b 7d 84 mov -0x7c(%ebp),%edi <== NOT EXECUTED 104965: 8b 07 mov (%edi),%eax <== NOT EXECUTED 104967: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 10496b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10496e: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 104971: e8 4a 1a 00 00 call 1063c0 <== NOT EXECUTED jffs2_free_full_dnode(fn); 104976: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 104979: e8 e2 07 00 00 call 105160 <== NOT EXECUTED return 0; 10497e: e9 39 f7 ff ff jmp 1040bc <== NOT EXECUTED if (JFFS2_F_I_MTIME(f) == JFFS2_F_I_CTIME(f)) 104983: 39 43 d8 cmp %eax,-0x28(%ebx) 104986: 0f 85 97 fb ff ff jne 104523 <== NEVER TAKEN 10498c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 104990: e9 90 fb ff ff jmp 104525 pr_warn("%s(): New node has no frags!\n", __func__); 104995: c7 44 24 04 a4 ea 12 movl $0x12eaa4,0x4(%esp) <== NOT EXECUTED 10499c: 00 10499d: c7 04 24 50 e8 12 00 movl $0x12e850,(%esp) <== NOT EXECUTED 1049a4: e8 87 ed ff ff call 103730 <== NOT EXECUTED BUG(); 1049a9: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED 1049b0: 00 1049b1: c7 44 24 08 a4 ea 12 movl $0x12eaa4,0x8(%esp) <== NOT EXECUTED 1049b8: 00 1049b9: c7 44 24 04 8b 04 00 movl $0x48b,0x4(%esp) <== NOT EXECUTED 1049c0: 00 1049c1: c7 04 24 f8 e2 12 00 movl $0x12e2f8,(%esp) <== NOT EXECUTED 1049c8: e8 a3 92 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED pr_warn("%s(): Old node still has frags!\n", __func__); 1049cd: c7 44 24 04 a4 ea 12 movl $0x12eaa4,0x4(%esp) <== NOT EXECUTED 1049d4: 00 1049d5: c7 04 24 24 e8 12 00 movl $0x12e824,(%esp) <== NOT EXECUTED 1049dc: e8 4f ed ff ff call 103730 <== NOT EXECUTED BUG(); 1049e1: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED 1049e8: 00 1049e9: c7 44 24 08 a4 ea 12 movl $0x12eaa4,0x8(%esp) <== NOT EXECUTED 1049f0: 00 1049f1: c7 44 24 04 87 04 00 movl $0x487,0x4(%esp) <== NOT EXECUTED 1049f8: 00 1049f9: c7 04 24 f8 e2 12 00 movl $0x12e2f8,(%esp) <== NOT EXECUTED 104a00: e8 6b 92 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED pr_warn("jffs2_write_dirent in garbage_collect_dirent failed: %ld\n", 104a05: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED return PTR_ERR(new_fd); 104a09: 89 fe mov %edi,%esi <== NOT EXECUTED pr_warn("jffs2_write_dirent in garbage_collect_dirent failed: %ld\n", 104a0b: c7 04 24 58 e9 12 00 movl $0x12e958,(%esp) <== NOT EXECUTED 104a12: e8 19 ed ff ff call 103730 <== NOT EXECUTED return PTR_ERR(new_fd); 104a17: e9 a0 f6 ff ff jmp 1040bc <== NOT EXECUTED pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_dirent failed: %d\n", 104a1c: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 104a20: 0f b6 45 c0 movzbl -0x40(%ebp),%eax <== NOT EXECUTED 104a24: c7 04 24 00 e9 12 00 movl $0x12e900,(%esp) <== NOT EXECUTED 104a2b: 83 c0 28 add $0x28,%eax <== NOT EXECUTED 104a2e: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 104a32: e8 f9 ec ff ff call 103730 <== NOT EXECUTED return ret; 104a37: e9 80 f6 ff ff jmp 1040bc <== NOT EXECUTED pr_warn("%s(): Node 0x%08x wasn't a hole node!\n", 104a3c: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 104a3f: 8b 00 mov (%eax),%eax <== NOT EXECUTED 104a41: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 104a44: c7 44 24 04 a4 ea 12 movl $0x12eaa4,0x4(%esp) <== NOT EXECUTED 104a4b: 00 104a4c: c7 04 24 70 e7 12 00 movl $0x12e770,(%esp) <== NOT EXECUTED 104a53: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 104a56: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 104a5a: e8 d1 ec ff ff call 103730 <== NOT EXECUTED pr_warn("Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n", 104a5f: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 104a62: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 104a65: c7 04 24 28 e7 12 00 movl $0x12e728,(%esp) <== NOT EXECUTED 104a6c: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 104a70: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax <== NOT EXECUTED 104a76: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 104a7a: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax <== NOT EXECUTED 104a80: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 104a84: e8 a7 ec ff ff call 103730 <== NOT EXECUTED ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4)); 104a89: c7 44 24 08 08 00 00 movl $0x8,0x8(%esp) <== NOT EXECUTED 104a90: 00 104a91: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 104a94: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 104a9b: c7 45 a4 85 19 02 e0 movl $0xe0021985,-0x5c(%ebp) <== NOT EXECUTED ri.totlen = cpu_to_je32(sizeof(ri)); 104aa2: c7 45 a8 44 00 00 00 movl $0x44,-0x58(%ebp) <== NOT EXECUTED ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4)); 104aa9: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 104aad: e8 de 63 00 00 call 10ae90 <== NOT EXECUTED ri.offset = cpu_to_je32(start); 104ab2: 8b 95 74 ff ff ff mov -0x8c(%ebp),%edx <== NOT EXECUTED ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4)); 104ab8: 89 45 ac mov %eax,-0x54(%ebp) <== NOT EXECUTED ri.ino = cpu_to_je32(f->inocache->ino); 104abb: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 104abe: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 104ac1: 89 45 b0 mov %eax,-0x50(%ebp) <== NOT EXECUTED ri.version = cpu_to_je32(++f->highest_version); 104ac4: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 104ac6: 40 inc %eax <== NOT EXECUTED 104ac7: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 104ac9: 89 45 b4 mov %eax,-0x4c(%ebp) <== NOT EXECUTED ri.dsize = cpu_to_je32(end - start); 104acc: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax <== NOT EXECUTED ri.offset = cpu_to_je32(start); 104ad2: 89 55 d0 mov %edx,-0x30(%ebp) <== NOT EXECUTED ri.csize = cpu_to_je32(0); 104ad5: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED ri.compr = JFFS2_COMPR_ZERO; 104adc: c6 45 dc 01 movb $0x1,-0x24(%ebp) <== NOT EXECUTED ri.dsize = cpu_to_je32(end - start); 104ae0: 29 d0 sub %edx,%eax <== NOT EXECUTED 104ae2: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED ri.compr = JFFS2_COMPR_ZERO; 104ae5: e9 1a f8 ff ff jmp 104304 <== NOT EXECUTED pr_warn("%s: Node at 0x%08x had CRC 0x%08x which doesn't match calculated CRC 0x%08x\n", 104aea: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED 104aee: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 104af1: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED 104af5: 8b 00 mov (%eax),%eax <== NOT EXECUTED 104af7: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 104afa: c7 44 24 04 a4 ea 12 movl $0x12eaa4,0x4(%esp) <== NOT EXECUTED 104b01: 00 104b02: c7 04 24 d0 e6 12 00 movl $0x12e6d0,(%esp) <== NOT EXECUTED 104b09: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 104b0c: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 104b10: e8 1b ec ff ff call 103730 <== NOT EXECUTED pr_warn("Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n", 104b15: e9 45 ff ff ff jmp 104a5f <== NOT EXECUTED pr_warn("Node read failed in jffs2_garbage_collect_hole. Ret %d, retlen %zd. Data will be lost by writing new hole node\n", 104b1a: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED 104b1e: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 104b22: c7 04 24 a8 e5 12 00 movl $0x12e5a8,(%esp) <== NOT EXECUTED 104b29: e8 02 ec ff ff call 103730 <== NOT EXECUTED goto fill; 104b2e: e9 56 ff ff ff jmp 104a89 <== NOT EXECUTED pr_warn("%s(): Node at 0x%08x had node type 0x%04x instead of JFFS2_NODETYPE_INODE(0x%04x)\n", 104b33: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 104b37: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 104b3a: c7 44 24 10 02 e0 00 movl $0xe002,0x10(%esp) <== NOT EXECUTED 104b41: 00 104b42: 8b 00 mov (%eax),%eax <== NOT EXECUTED 104b44: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 104b47: c7 44 24 04 a4 ea 12 movl $0x12eaa4,0x4(%esp) <== NOT EXECUTED 104b4e: 00 104b4f: c7 04 24 24 e6 12 00 movl $0x12e624,(%esp) <== NOT EXECUTED 104b56: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 104b59: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 104b5d: e8 ce eb ff ff call 103730 <== NOT EXECUTED return -EIO; 104b62: e9 45 fd ff ff jmp 1048ac <== NOT EXECUTED int ret = 0; unsigned char *comprbuf = NULL, *writebuf; unsigned long pg; unsigned char *pg_ptr; memset(&ri, 0, sizeof(ri)); 104b67: 31 c0 xor %eax,%eax 104b69: b9 11 00 00 00 mov $0x11,%ecx f->inocache->ino, start, end); orig_end = end; orig_start = start; if (c->nr_free_blocks + c->nr_erasing_blocks > c->resv_blocks_gcmerge) { 104b6e: 8b 55 08 mov 0x8(%ebp),%edx unsigned char *comprbuf = NULL, *writebuf; 104b71: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) memset(&ri, 0, sizeof(ri)); 104b78: 8d 7d a4 lea -0x5c(%ebp),%edi 104b7b: 89 7d 80 mov %edi,-0x80(%ebp) 104b7e: f3 ab rep stos %eax,%es:(%edi) if (c->nr_free_blocks + c->nr_erasing_blocks > c->resv_blocks_gcmerge) { 104b80: 8b 45 08 mov 0x8(%ebp),%eax 104b83: 8b 40 40 mov 0x40(%eax),%eax 104b86: 03 42 3c add 0x3c(%edx),%eax 104b89: 0f b6 52 48 movzbl 0x48(%edx),%edx 104b8d: 39 d0 cmp %edx,%eax 104b8f: 0f 86 04 04 00 00 jbe 104f99 chance of nodes having to be split to cross boundaries. */ struct jffs2_node_frag *frag; uint32_t min, max; min = start & ~(PAGE_SIZE-1); 104b95: 8b bd 74 ff ff ff mov -0x8c(%ebp),%edi max = min + PAGE_SIZE; frag = jffs2_lookup_node_frag(&f->fragtree, start); 104b9b: 8b 85 70 ff ff ff mov -0x90(%ebp),%eax 104ba1: 89 7c 24 04 mov %edi,0x4(%esp) min = start & ~(PAGE_SIZE-1); 104ba5: 89 fa mov %edi,%edx frag = jffs2_lookup_node_frag(&f->fragtree, start); 104ba7: 89 04 24 mov %eax,(%esp) min = start & ~(PAGE_SIZE-1); 104baa: 81 e2 00 f0 ff ff and $0xfffff000,%edx 104bb0: 89 55 84 mov %edx,-0x7c(%ebp) max = min + PAGE_SIZE; 104bb3: 81 c2 00 10 00 00 add $0x1000,%edx 104bb9: 89 95 68 ff ff ff mov %edx,-0x98(%ebp) frag = jffs2_lookup_node_frag(&f->fragtree, start); 104bbf: e8 bc 11 00 00 call 105d80 /* BUG_ON(!frag) but that'll happen anyway... */ BUG_ON(frag->ofs != start); 104bc4: 39 78 18 cmp %edi,0x18(%eax) 104bc7: 0f 85 a8 03 00 00 jne 104f75 <== NEVER TAKEN return _RBTree_Predecessor( node ); 104bcd: 89 04 24 mov %eax,(%esp) 104bd0: e8 3b 0f 01 00 call 115b10 <_RBTree_Predecessor> /* First grow down... */ while((frag = frag_prev(frag)) && frag->ofs >= min) { 104bd5: 85 c0 test %eax,%eax 104bd7: 74 45 je 104c1e 104bd9: 8b 48 18 mov 0x18(%eax),%ecx 104bdc: 39 4d 84 cmp %ecx,-0x7c(%ebp) 104bdf: 77 3d ja 104c1e /* If the previous frag doesn't even reach the beginning, there's excessive fragmentation. Just merge. */ if (frag->ofs > min) { 104be1: 0f 82 87 03 00 00 jb 104f6e <== NEVER TAKEN frag->ofs, frag->ofs+frag->size); start = frag->ofs; continue; } /* OK. This frag holds the first byte of the page. */ if (!frag->node || !frag->node->raw) { 104be7: 89 4d 84 mov %ecx,-0x7c(%ebp) 104bea: 8b 40 10 mov 0x10(%eax),%eax 104bed: 85 c0 test %eax,%eax 104bef: 74 2d je 104c1e <== NEVER TAKEN 104bf1: 8b 00 mov (%eax),%eax 104bf3: 85 c0 test %eax,%eax 104bf5: 74 27 je 104c1e <== NEVER TAKEN If not, cover it anyway. */ struct jffs2_raw_node_ref *raw = frag->node->raw; struct jffs2_eraseblock *jeb; jeb = &c->blocks[raw->flash_offset / c->sector_size]; 104bf7: 8b 4d 08 mov 0x8(%ebp),%ecx 104bfa: 31 d2 xor %edx,%edx 104bfc: 8b 40 04 mov 0x4(%eax),%eax 104bff: f7 71 34 divl 0x34(%ecx) 104c02: 6b c0 34 imul $0x34,%eax,%eax 104c05: 03 41 54 add 0x54(%ecx),%eax if (jeb == c->gcblock) { 104c08: 3b 41 5c cmp 0x5c(%ecx),%eax 104c0b: 74 0e je 104c1b <== NEVER TAKEN frag->ofs + frag->size, ref_offset(raw)); start = frag->ofs; break; } if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) { 104c0d: 8b 50 1c mov 0x1c(%eax),%edx 104c10: 03 50 18 add 0x18(%eax),%edx 104c13: 81 fa c4 00 00 00 cmp $0xc4,%edx 104c19: 76 03 jbe 104c1e <== NEVER TAKEN while((frag = frag_prev(frag)) && frag->ofs >= min) { 104c1b: 8b 7d 84 mov -0x7c(%ebp),%edi <== NOT EXECUTED } /* ... then up */ /* Find last frag which is actually part of the node we're to GC. */ frag = jffs2_lookup_node_frag(&f->fragtree, end-1); 104c1e: 89 74 24 04 mov %esi,0x4(%esp) 104c22: 8b 85 70 ff ff ff mov -0x90(%ebp),%eax 104c28: 89 04 24 mov %eax,(%esp) 104c2b: e8 50 11 00 00 call 105d80 while((frag = frag_next(frag)) && frag->ofs+frag->size <= max) { 104c30: 8b 95 7c ff ff ff mov -0x84(%ebp),%edx 104c36: 89 55 84 mov %edx,-0x7c(%ebp) return _RBTree_Successor( node ); 104c39: 89 04 24 mov %eax,(%esp) 104c3c: e8 7f 0e 01 00 call 115ac0 <_RBTree_Successor> 104c41: 85 c0 test %eax,%eax 104c43: 74 48 je 104c8d 104c45: 8b 48 14 mov 0x14(%eax),%ecx 104c48: 03 48 18 add 0x18(%eax),%ecx 104c4b: 39 8d 68 ff ff ff cmp %ecx,-0x98(%ebp) 104c51: 72 3a jb 104c8d /* If the previous frag doesn't even reach the beginning, there's lots of fragmentation. Just merge. */ if (frag->ofs+frag->size < max) { 104c53: 0f 87 0d 03 00 00 ja 104f66 frag->ofs, frag->ofs+frag->size); end = frag->ofs + frag->size; continue; } if (!frag->node || !frag->node->raw) { 104c59: 8b 40 10 mov 0x10(%eax),%eax 104c5c: 85 c0 test %eax,%eax 104c5e: 74 2d je 104c8d <== NEVER TAKEN 104c60: 8b 00 mov (%eax),%eax 104c62: 85 c0 test %eax,%eax 104c64: 74 27 je 104c8d <== NEVER TAKEN If not, cover it anyway. */ struct jffs2_raw_node_ref *raw = frag->node->raw; struct jffs2_eraseblock *jeb; jeb = &c->blocks[raw->flash_offset / c->sector_size]; 104c66: 8b 75 08 mov 0x8(%ebp),%esi 104c69: 31 d2 xor %edx,%edx 104c6b: 8b 40 04 mov 0x4(%eax),%eax 104c6e: f7 76 34 divl 0x34(%esi) 104c71: 6b c0 34 imul $0x34,%eax,%eax 104c74: 03 46 54 add 0x54(%esi),%eax if (jeb == c->gcblock) { 104c77: 3b 46 5c cmp 0x5c(%esi),%eax 104c7a: 74 0e je 104c8a <== NEVER TAKEN frag->ofs + frag->size, ref_offset(raw)); end = frag->ofs + frag->size; break; } if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) { 104c7c: 8b 50 1c mov 0x1c(%eax),%edx 104c7f: 03 50 18 add 0x18(%eax),%edx 104c82: 81 fa c4 00 00 00 cmp $0xc4,%edx 104c88: 76 03 jbe 104c8d <== NEVER TAKEN while((frag = frag_next(frag)) && frag->ofs+frag->size <= max) { 104c8a: 89 4d 84 mov %ecx,-0x7c(%ebp) } jffs2_dbg(1, "Expanded dnode to write from (0x%x-0x%x) to (0x%x-0x%x)\n", orig_start, orig_end, start, end); D1(BUG_ON(end > frag_last(&f->fragtree)->ofs + frag_last(&f->fragtree)->size)); BUG_ON(end < orig_end); 104c8d: 8b 95 7c ff ff ff mov -0x84(%ebp),%edx 104c93: 39 55 84 cmp %edx,-0x7c(%ebp) 104c96: 0f 82 a6 02 00 00 jb 104f42 <== NEVER TAKEN BUG_ON(start > orig_start); 104c9c: 3b bd 74 ff ff ff cmp -0x8c(%ebp),%edi 104ca2: 0f 87 76 02 00 00 ja 104f1e <== NEVER TAKEN * It is important to note that jffs2_write_begin() will ensure that its * page is marked Uptodate before allocating space. That means that if we * end up here trying to GC the *same* page that jffs2_write_begin() is * trying to write out, read_cache_page() will not deadlock. */ mutex_unlock(&f->sem); pg_ptr = jffs2_gc_fetch_page(c, f, start, &pg); 104ca8: 89 7c 24 08 mov %edi,0x8(%esp) 104cac: 8d 45 98 lea -0x68(%ebp),%eax int ret = 0; 104caf: 31 f6 xor %esi,%esi pg_ptr = jffs2_gc_fetch_page(c, f, start, &pg); 104cb1: 89 44 24 0c mov %eax,0xc(%esp) 104cb5: 8b 45 08 mov 0x8(%ebp),%eax 104cb8: 89 5c 24 04 mov %ebx,0x4(%esp) 104cbc: 89 04 24 mov %eax,(%esp) 104cbf: e8 dc de ff ff call 102ba0 104cc4: 89 85 74 ff ff ff mov %eax,-0x8c(%ebp) mutex_lock(&f->sem); if (IS_ERR(pg_ptr)) { 104cca: 3d 18 fc ff ff cmp $0xfffffc18,%eax 104ccf: 0f 87 2e 02 00 00 ja 104f03 <== NEVER TAKEN 104cd5: 89 f0 mov %esi,%eax 104cd7: 89 de mov %ebx,%esi 104cd9: 8b 5d 08 mov 0x8(%ebp),%ebx PTR_ERR(pg_ptr)); return PTR_ERR(pg_ptr); } offset = start; while(offset < orig_end) { 104cdc: 3b bd 7c ff ff ff cmp -0x84(%ebp),%edi 104ce2: 0f 83 ff 01 00 00 jae 104ee7 uint32_t datalen; uint32_t cdatalen; uint16_t comprtype = JFFS2_COMPR_NONE; ret = jffs2_reserve_space_gc(c, sizeof(ri) + JFFS2_MIN_DATA_LEN, 104ce8: c7 44 24 0c 12 00 00 movl $0x12,0xc(%esp) 104cef: 00 104cf0: 8d 45 90 lea -0x70(%ebp),%eax 104cf3: 89 44 24 08 mov %eax,0x8(%esp) 104cf7: c7 44 24 04 c4 00 00 movl $0xc4,0x4(%esp) 104cfe: 00 104cff: 89 1c 24 mov %ebx,(%esp) 104d02: e8 89 1e 00 00 call 106b90 &alloclen, JFFS2_SUMMARY_INODE_SIZE); if (ret) { 104d07: 85 c0 test %eax,%eax 104d09: 0f 85 9b 01 00 00 jne 104eaa <== NEVER TAKEN pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_dnode failed: %d\n", sizeof(ri) + JFFS2_MIN_DATA_LEN, ret); break; } cdatalen = min_t(uint32_t, alloclen - sizeof(ri), end - offset); 104d0f: 8b 55 84 mov -0x7c(%ebp),%edx 104d12: 8b 45 90 mov -0x70(%ebp),%eax 104d15: 29 fa sub %edi,%edx 104d17: 83 e8 44 sub $0x44,%eax 104d1a: 39 d0 cmp %edx,%eax 104d1c: 76 02 jbe 104d20 104d1e: 89 d0 mov %edx,%eax 104d20: 89 45 a0 mov %eax,-0x60(%ebp) datalen = end - offset; writebuf = pg_ptr + (offset & (PAGE_SIZE -1)); comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen); 104d23: 8d 45 a0 lea -0x60(%ebp),%eax 104d26: 89 44 24 14 mov %eax,0x14(%esp) 104d2a: 8d 45 9c lea -0x64(%ebp),%eax 104d2d: 89 44 24 10 mov %eax,0x10(%esp) 104d31: 8d 45 94 lea -0x6c(%ebp),%eax 104d34: 89 44 24 0c mov %eax,0xc(%esp) writebuf = pg_ptr + (offset & (PAGE_SIZE -1)); 104d38: 89 f8 mov %edi,%eax comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen); 104d3a: 89 74 24 04 mov %esi,0x4(%esp) writebuf = pg_ptr + (offset & (PAGE_SIZE -1)); 104d3e: 25 ff 0f 00 00 and $0xfff,%eax 104d43: 03 85 74 ff ff ff add -0x8c(%ebp),%eax comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen); 104d49: 89 1c 24 mov %ebx,(%esp) datalen = end - offset; 104d4c: 89 55 9c mov %edx,-0x64(%ebp) comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen); 104d4f: 89 44 24 08 mov %eax,0x8(%esp) 104d53: e8 88 61 00 00 call 10aee0 ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE); ri.totlen = cpu_to_je32(sizeof(ri) + cdatalen); ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4)); 104d58: c7 44 24 08 08 00 00 movl $0x8,0x8(%esp) 104d5f: 00 104d60: c7 04 24 00 00 00 00 movl $0x0,(%esp) ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK); 104d67: c7 45 a4 85 19 02 e0 movl $0xe0021985,-0x5c(%ebp) comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen); 104d6e: 66 89 85 70 ff ff ff mov %ax,-0x90(%ebp) ri.totlen = cpu_to_je32(sizeof(ri) + cdatalen); 104d75: 8b 45 a0 mov -0x60(%ebp),%eax 104d78: 83 c0 44 add $0x44,%eax 104d7b: 89 45 a8 mov %eax,-0x58(%ebp) ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4)); 104d7e: 8b 45 80 mov -0x80(%ebp),%eax 104d81: 89 44 24 04 mov %eax,0x4(%esp) 104d85: e8 06 61 00 00 call 10ae90 ri.ino = cpu_to_je32(f->inocache->ino); ri.version = cpu_to_je32(++f->highest_version); 104d8a: 8b 16 mov (%esi),%edx ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4)); 104d8c: 89 45 ac mov %eax,-0x54(%ebp) ri.ino = cpu_to_je32(f->inocache->ino); 104d8f: 8b 46 14 mov 0x14(%esi),%eax 104d92: 8b 40 0c mov 0xc(%eax),%eax 104d95: 89 45 b0 mov %eax,-0x50(%ebp) ri.version = cpu_to_je32(++f->highest_version); 104d98: 8d 42 01 lea 0x1(%edx),%eax 104d9b: 8b 56 c4 mov -0x3c(%esi),%edx 104d9e: 89 06 mov %eax,(%esi) 104da0: 89 45 b4 mov %eax,-0x4c(%ebp) ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f)); ri.uid = cpu_to_je16(JFFS2_F_I_UID(f)); 104da3: 0f b7 46 ca movzwl -0x36(%esi),%eax 104da7: 81 e2 ff f1 00 00 and $0xf1ff,%edx ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f)); 104dad: 89 55 b8 mov %edx,-0x48(%ebp) ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f)); ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f)); ri.offset = cpu_to_je32(offset); ri.csize = cpu_to_je32(cdatalen); ri.dsize = cpu_to_je32(datalen); ri.compr = comprtype & 0xff; 104db0: 8b 95 70 ff ff ff mov -0x90(%ebp),%edx ri.uid = cpu_to_je16(JFFS2_F_I_UID(f)); 104db6: 66 89 45 bc mov %ax,-0x44(%ebp) ri.gid = cpu_to_je16(JFFS2_F_I_GID(f)); 104dba: 8b 46 cc mov -0x34(%esi),%eax 104dbd: 66 89 45 be mov %ax,-0x42(%ebp) ri.isize = cpu_to_je32(JFFS2_F_I_SIZE(f)); 104dc1: 8b 46 f0 mov -0x10(%esi),%eax 104dc4: 89 45 c0 mov %eax,-0x40(%ebp) ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f)); 104dc7: 8b 46 d0 mov -0x30(%esi),%eax 104dca: 89 45 c4 mov %eax,-0x3c(%ebp) ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f)); 104dcd: 8b 46 e0 mov -0x20(%esi),%eax 104dd0: 89 45 cc mov %eax,-0x34(%ebp) ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f)); 104dd3: 8b 46 d8 mov -0x28(%esi),%eax ri.compr = comprtype & 0xff; 104dd6: 66 89 55 dc mov %dx,-0x24(%ebp) ri.offset = cpu_to_je32(offset); 104dda: 89 7d d0 mov %edi,-0x30(%ebp) ri.usercompr = (comprtype >> 8) & 0xff; ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8)); 104ddd: c7 44 24 08 3c 00 00 movl $0x3c,0x8(%esp) 104de4: 00 ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f)); 104de5: 89 45 c8 mov %eax,-0x38(%ebp) ri.csize = cpu_to_je32(cdatalen); 104de8: 8b 45 a0 mov -0x60(%ebp),%eax ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8)); 104deb: c7 04 24 00 00 00 00 movl $0x0,(%esp) ri.csize = cpu_to_je32(cdatalen); 104df2: 89 45 d4 mov %eax,-0x2c(%ebp) ri.dsize = cpu_to_je32(datalen); 104df5: 8b 45 9c mov -0x64(%ebp),%eax 104df8: 89 45 d8 mov %eax,-0x28(%ebp) ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8)); 104dfb: 8b 45 80 mov -0x80(%ebp),%eax 104dfe: 89 44 24 04 mov %eax,0x4(%esp) 104e02: e8 89 60 00 00 call 10ae90 ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen)); 104e07: c7 04 24 00 00 00 00 movl $0x0,(%esp) ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8)); 104e0e: 89 45 e4 mov %eax,-0x1c(%ebp) ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen)); 104e11: 8b 45 a0 mov -0x60(%ebp),%eax 104e14: 89 44 24 08 mov %eax,0x8(%esp) 104e18: 8b 45 94 mov -0x6c(%ebp),%eax 104e1b: 89 44 24 04 mov %eax,0x4(%esp) 104e1f: e8 6c 60 00 00 call 10ae90 new_fn = jffs2_write_dnode(c, f, &ri, comprbuf, cdatalen, ALLOC_GC); 104e24: c7 44 24 14 02 00 00 movl $0x2,0x14(%esp) 104e2b: 00 104e2c: 89 74 24 04 mov %esi,0x4(%esp) 104e30: 89 1c 24 mov %ebx,(%esp) ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen)); 104e33: 89 45 e0 mov %eax,-0x20(%ebp) new_fn = jffs2_write_dnode(c, f, &ri, comprbuf, cdatalen, ALLOC_GC); 104e36: 8b 45 a0 mov -0x60(%ebp),%eax 104e39: 89 44 24 10 mov %eax,0x10(%esp) 104e3d: 8b 45 94 mov -0x6c(%ebp),%eax 104e40: 89 44 24 0c mov %eax,0xc(%esp) 104e44: 8b 45 80 mov -0x80(%ebp),%eax 104e47: 89 44 24 08 mov %eax,0x8(%esp) 104e4b: e8 00 49 00 00 call 109750 jffs2_free_comprbuf(comprbuf, writebuf); if (IS_ERR(new_fn)) { 104e50: 3d 18 fc ff ff cmp $0xfffffc18,%eax 104e55: 0f 87 92 00 00 00 ja 104eed <== NEVER TAKEN pr_warn("Error writing new dnode: %ld\n", PTR_ERR(new_fn)); ret = PTR_ERR(new_fn); break; } ret = jffs2_add_full_dnode_to_inode(c, f, new_fn); 104e5b: 89 44 24 08 mov %eax,0x8(%esp) 104e5f: 89 74 24 04 mov %esi,0x4(%esp) 104e63: 89 1c 24 mov %ebx,(%esp) 104e66: e8 45 08 00 00 call 1056b0 offset += datalen; if (f->metadata) { 104e6b: 8b 56 08 mov 0x8(%esi),%edx offset += datalen; 104e6e: 03 7d 9c add -0x64(%ebp),%edi if (f->metadata) { 104e71: 85 d2 test %edx,%edx 104e73: 0f 84 63 fe ff ff je 104cdc <== ALWAYS TAKEN 104e79: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) <== NOT EXECUTED jffs2_mark_node_obsolete(c, f->metadata->raw); 104e7f: 8b 12 mov (%edx),%edx <== NOT EXECUTED 104e81: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 104e84: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED 104e88: e8 33 15 00 00 call 1063c0 <== NOT EXECUTED jffs2_free_full_dnode(f->metadata); 104e8d: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED 104e90: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 104e93: e8 c8 02 00 00 call 105160 <== NOT EXECUTED f->metadata = NULL; 104e98: 8b 85 70 ff ff ff mov -0x90(%ebp),%eax <== NOT EXECUTED 104e9e: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) <== NOT EXECUTED 104ea5: e9 32 fe ff ff jmp 104cdc <== NOT EXECUTED pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_dnode failed: %d\n", 104eaa: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED 104eae: 89 f3 mov %esi,%ebx <== NOT EXECUTED 104eb0: 89 c6 mov %eax,%esi <== NOT EXECUTED 104eb2: c7 44 24 04 c4 00 00 movl $0xc4,0x4(%esp) <== NOT EXECUTED 104eb9: 00 104eba: c7 04 24 ac e8 12 00 movl $0x12e8ac,(%esp) <== NOT EXECUTED 104ec1: e8 6a e8 ff ff call 103730 <== NOT EXECUTED } } jffs2_gc_release_page(c, pg_ptr, &pg); 104ec6: 8d 45 98 lea -0x68(%ebp),%eax 104ec9: 89 44 24 08 mov %eax,0x8(%esp) 104ecd: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 104ed3: 89 44 24 04 mov %eax,0x4(%esp) 104ed7: 8b 45 08 mov 0x8(%ebp),%eax 104eda: 89 04 24 mov %eax,(%esp) 104edd: e8 0e dd ff ff call 102bf0 return ret; 104ee2: e9 d5 f1 ff ff jmp 1040bc 104ee7: 89 f3 mov %esi,%ebx 104ee9: 89 c6 mov %eax,%esi 104eeb: eb d9 jmp 104ec6 pr_warn("Error writing new dnode: %ld\n", 104eed: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 104ef1: 89 f3 mov %esi,%ebx <== NOT EXECUTED 104ef3: 89 c6 mov %eax,%esi <== NOT EXECUTED 104ef5: c7 04 24 80 e5 12 00 movl $0x12e580,(%esp) <== NOT EXECUTED 104efc: e8 2f e8 ff ff call 103730 <== NOT EXECUTED break; 104f01: eb c3 jmp 104ec6 <== NOT EXECUTED pr_warn("read_cache_page() returned error: %ld\n", 104f03: c7 04 24 78 e8 12 00 movl $0x12e878,(%esp) <== NOT EXECUTED 104f0a: 8b b5 74 ff ff ff mov -0x8c(%ebp),%esi <== NOT EXECUTED 104f10: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED 104f14: e8 17 e8 ff ff call 103730 <== NOT EXECUTED return PTR_ERR(pg_ptr); 104f19: e9 9e f1 ff ff jmp 1040bc <== NOT EXECUTED BUG_ON(start > orig_start); 104f1e: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED 104f25: 00 104f26: c7 44 24 08 88 ea 12 movl $0x12ea88,0x8(%esp) <== NOT EXECUTED 104f2d: 00 104f2e: c7 44 24 04 2c 05 00 movl $0x52c,0x4(%esp) <== NOT EXECUTED 104f35: 00 104f36: c7 04 24 f8 e2 12 00 movl $0x12e2f8,(%esp) <== NOT EXECUTED 104f3d: e8 2e 8d 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED BUG_ON(end < orig_end); 104f42: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED 104f49: 00 104f4a: c7 44 24 08 88 ea 12 movl $0x12ea88,0x8(%esp) <== NOT EXECUTED 104f51: 00 104f52: c7 44 24 04 2b 05 00 movl $0x52b,0x4(%esp) <== NOT EXECUTED 104f59: 00 104f5a: c7 04 24 f8 e2 12 00 movl $0x12e2f8,(%esp) <== NOT EXECUTED 104f61: e8 0a 8d 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED 104f66: 89 4d 84 mov %ecx,-0x7c(%ebp) 104f69: e9 cb fc ff ff jmp 104c39 104f6e: 89 cf mov %ecx,%edi <== NOT EXECUTED 104f70: e9 58 fc ff ff jmp 104bcd <== NOT EXECUTED BUG_ON(frag->ofs != start); 104f75: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED 104f7c: 00 104f7d: c7 44 24 08 88 ea 12 movl $0x12ea88,0x8(%esp) <== NOT EXECUTED 104f84: 00 104f85: c7 44 24 04 ba 04 00 movl $0x4ba,0x4(%esp) <== NOT EXECUTED 104f8c: 00 104f8d: c7 04 24 f8 e2 12 00 movl $0x12e2f8,(%esp) <== NOT EXECUTED 104f94: e8 d7 8c 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED 104f99: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax 104f9f: 8b bd 74 ff ff ff mov -0x8c(%ebp),%edi 104fa5: 89 45 84 mov %eax,-0x7c(%ebp) 104fa8: e9 fb fc ff ff jmp 104ca8 ret = jffs2_garbage_collect_pristine(c, f->inocache, raw); 104fad: 8b 53 14 mov 0x14(%ebx),%edx <== NOT EXECUTED 104fb0: 89 f9 mov %edi,%ecx <== NOT EXECUTED 104fb2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 104fb5: e8 96 e7 ff ff call 103750 <== NOT EXECUTED if (!ret) { 104fba: 85 c0 test %eax,%eax <== NOT EXECUTED ret = jffs2_garbage_collect_pristine(c, f->inocache, raw); 104fbc: 89 c6 mov %eax,%esi <== NOT EXECUTED if (!ret) { 104fbe: 0f 85 45 01 00 00 jne 105109 <== NOT EXECUTED frag->node->raw = f->inocache->nodes; 104fc4: 8b 53 14 mov 0x14(%ebx),%edx <== NOT EXECUTED 104fc7: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 104fca: 8b 52 04 mov 0x4(%edx),%edx <== NOT EXECUTED 104fcd: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 104fd0: 89 10 mov %edx,(%eax) <== NOT EXECUTED if (ret != -EBADFD) 104fd2: e9 e5 f0 ff ff jmp 1040bc <== NOT EXECUTED ret = PTR_ERR(f); 104fd7: 89 c6 mov %eax,%esi <== NOT EXECUTED goto release_sem; 104fd9: e9 fe f0 ff ff jmp 1040dc <== NOT EXECUTED 104fde: 89 f0 mov %esi,%eax <== NOT EXECUTED 104fe0: e9 7d ef ff ff jmp 103f62 <== NOT EXECUTED pr_warn("Eep. ret->gc_node for block at 0x%08x is NULL\n", 104fe5: 8b 41 0c mov 0xc(%ecx),%eax <== NOT EXECUTED 104fe8: c7 04 24 6c e3 12 00 movl $0x12e36c,(%esp) <== NOT EXECUTED 104fef: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 104ff3: e8 38 e7 ff ff call 103730 <== NOT EXECUTED BUG(); 104ff8: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED 104fff: 00 105000: c7 44 24 08 dc ea 12 movl $0x12eadc,0x8(%esp) <== NOT EXECUTED 105007: 00 105008: c7 44 24 04 6a 00 00 movl $0x6a,0x4(%esp) <== NOT EXECUTED 10500f: 00 105010: c7 04 24 f8 e2 12 00 movl $0x12e2f8,(%esp) <== NOT EXECUTED 105017: e8 54 8c 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED switch(ic->state) { 10501c: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED pr_warn("Inode #%u is in state %d during CRC check phase!\n", 105020: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED 105024: c7 04 24 bc e2 12 00 movl $0x12e2bc,(%esp) <== NOT EXECUTED 10502b: e8 00 e7 ff ff call 103730 <== NOT EXECUTED BUG(); 105030: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED 105037: 00 105038: c7 44 24 08 f0 ea 12 movl $0x12eaf0,0x8(%esp) <== NOT EXECUTED 10503f: 00 105040: c7 44 24 04 d3 00 00 movl $0xd3,0x4(%esp) <== NOT EXECUTED 105047: 00 105048: c7 04 24 f8 e2 12 00 movl $0x12e2f8,(%esp) <== NOT EXECUTED 10504f: e8 1c 8c 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED BUG(); 105054: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED 10505b: 00 10505c: c7 44 24 08 f0 ea 12 movl $0x12eaf0,0x8(%esp) <== NOT EXECUTED 105063: 00 105064: c7 44 24 04 e4 00 00 movl $0xe4,0x4(%esp) <== NOT EXECUTED 10506b: 00 10506c: c7 04 24 f8 e2 12 00 movl $0x12e2f8,(%esp) <== NOT EXECUTED 105073: e8 f8 8b 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED if (ref_flags(raw) == REF_PRISTINE) { 105078: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10507b: 74 40 je 1050bd <== NOT EXECUTED jffs2_mark_node_obsolete(c, raw); 10507d: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED 105081: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED int ret = 0, inum, nlink; 105084: 31 f6 xor %esi,%esi <== NOT EXECUTED jffs2_mark_node_obsolete(c, raw); 105086: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 105089: e8 32 13 00 00 call 1063c0 <== NOT EXECUTED 10508e: e9 49 f0 ff ff jmp 1040dc <== NOT EXECUTED ret = jffs2_garbage_collect_pristine(c, ic, raw); 105093: 8b 45 08 mov 0x8(%ebp),%eax 105096: 89 f9 mov %edi,%ecx 105098: 89 da mov %ebx,%edx ic->state = INO_STATE_GC; 10509a: 66 c7 43 0a 04 00 movw $0x4,0xa(%ebx) ret = jffs2_garbage_collect_pristine(c, ic, raw); 1050a0: e8 ab e6 ff ff call 103750 ic->state = INO_STATE_CHECKEDABSENT; 1050a5: 66 c7 43 0a 03 00 movw $0x3,0xa(%ebx) if (ret != -EBADFD) { 1050ab: 3d 01 80 ff ff cmp $0xffff8001,%eax ret = jffs2_garbage_collect_pristine(c, ic, raw); 1050b0: 89 c6 mov %eax,%esi if (ret != -EBADFD) { 1050b2: 0f 85 13 f0 ff ff jne 1040cb 1050b8: e9 be ef ff ff jmp 10407b <== NOT EXECUTED jffs2_garbage_collect_pristine(c, NULL, raw); 1050bd: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1050c0: 89 f9 mov %edi,%ecx <== NOT EXECUTED int ret = 0, inum, nlink; 1050c2: 31 f6 xor %esi,%esi <== NOT EXECUTED jffs2_garbage_collect_pristine(c, NULL, raw); 1050c4: e8 87 e6 ff ff call 103750 <== NOT EXECUTED 1050c9: e9 0e f0 ff ff jmp 1040dc <== NOT EXECUTED switch(ic->state) { 1050ce: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED pr_crit("Inode #%u already in state %d in jffs2_garbage_collect_pass()!\n", 1050d2: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 1050d5: c7 04 24 44 e4 12 00 movl $0x12e444,(%esp) <== NOT EXECUTED 1050dc: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 1050e0: e8 4b e6 ff ff call 103730 <== NOT EXECUTED BUG(); 1050e5: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED 1050ec: 00 1050ed: c7 44 24 08 f0 ea 12 movl $0x12eaf0,0x8(%esp) <== NOT EXECUTED 1050f4: 00 1050f5: c7 44 24 04 8d 01 00 movl $0x18d,0x4(%esp) <== NOT EXECUTED 1050fc: 00 1050fd: c7 04 24 f8 e2 12 00 movl $0x12e2f8,(%esp) <== NOT EXECUTED 105104: e8 67 8b 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED if (ret != -EBADFD) 105109: 3d 01 80 ff ff cmp $0xffff8001,%eax <== NOT EXECUTED 10510e: 0f 84 23 f1 ff ff je 104237 <== NOT EXECUTED 105114: e9 a3 ef ff ff jmp 1040bc <== NOT EXECUTED 105119: 90 nop 10511a: 90 nop 10511b: 90 nop 10511c: 90 nop 10511d: 90 nop 10511e: 90 nop 10511f: 90 nop =============================================================================== 001036b0 : struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c, int inum, int unlinked) { 1036b0: 55 push %ebp 1036b1: 89 e5 mov %esp,%ebp 1036b3: 83 ec 18 sub $0x18,%esp struct _inode *inode; struct jffs2_inode_cache *ic; if (unlinked) { 1036b6: 8b 45 10 mov 0x10(%ebp),%eax { 1036b9: 8b 4d 08 mov 0x8(%ebp),%ecx 1036bc: 8b 55 0c mov 0xc(%ebp),%edx if (unlinked) { 1036bf: 85 c0 test %eax,%eax 1036c1: 74 2d je 1036f0 <== ALWAYS TAKEN for (inode = sb->s_root; inode != NULL; inode = inode->i_cache_next) { 1036c3: 8b 81 e0 00 00 00 mov 0xe0(%ecx),%eax <== NOT EXECUTED 1036c9: 85 c0 test %eax,%eax <== NOT EXECUTED 1036cb: 75 0a jne 1036d7 <== NOT EXECUTED 1036cd: eb 41 jmp 103710 <== NOT EXECUTED 1036cf: 90 nop <== NOT EXECUTED 1036d0: 8b 40 64 mov 0x64(%eax),%eax <== NOT EXECUTED 1036d3: 85 c0 test %eax,%eax <== NOT EXECUTED 1036d5: 74 39 je 103710 <== NOT EXECUTED if (inode->i_ino == ino) { 1036d7: 3b 10 cmp (%eax),%edx <== NOT EXECUTED 1036d9: 75 f5 jne 1036d0 <== NOT EXECUTED inode->i_count++; 1036db: ff 40 04 incl 0x4(%eax) <== NOT EXECUTED if (IS_ERR(inode)) return ERR_CAST(inode); } return JFFS2_INODE_INFO(inode); } 1036de: 89 ec mov %ebp,%esp return JFFS2_INODE_INFO(inode); 1036e0: 83 c0 44 add $0x44,%eax } 1036e3: 5d pop %ebp 1036e4: c3 ret 1036e5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 1036ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum); 1036f0: 89 54 24 04 mov %edx,0x4(%esp) 1036f4: 89 0c 24 mov %ecx,(%esp) 1036f7: e8 c4 f8 ff ff call 102fc0 if (IS_ERR(inode)) 1036fc: 3d 18 fc ff ff cmp $0xfffffc18,%eax 103701: 76 db jbe 1036de <== ALWAYS TAKEN } 103703: 89 ec mov %ebp,%esp <== NOT EXECUTED 103705: 5d pop %ebp <== NOT EXECUTED 103706: c3 ret <== NOT EXECUTED 103707: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10370e: 66 90 xchg %ax,%ax <== NOT EXECUTED ic = jffs2_get_ino_cache(c, inum); 103710: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED 103714: 89 0c 24 mov %ecx,(%esp) <== NOT EXECUTED 103717: e8 34 24 00 00 call 105b50 <== NOT EXECUTED } 10371c: 89 ec mov %ebp,%esp <== NOT EXECUTED return NULL; 10371e: 31 c0 xor %eax,%eax <== NOT EXECUTED } 103720: 5d pop %ebp <== NOT EXECUTED 103721: c3 ret <== NOT EXECUTED 103722: 90 nop 103723: 90 nop 103724: 90 nop 103725: 90 nop 103726: 90 nop 103727: 90 nop 103728: 90 nop 103729: 90 nop 10372a: 90 nop 10372b: 90 nop 10372c: 90 nop 10372d: 90 nop 10372e: 90 nop 10372f: 90 nop =============================================================================== 00102ba0 : { 102ba0: 55 push %ebp ret = jffs2_read_inode_range(c, f, gc_buffer, 102ba1: b8 00 10 00 00 mov $0x1000,%eax { 102ba6: 89 e5 mov %esp,%ebp 102ba8: 83 ec 28 sub $0x28,%esp ret = jffs2_read_inode_range(c, f, gc_buffer, 102bab: 89 44 24 10 mov %eax,0x10(%esp) 102baf: 8b 45 10 mov 0x10(%ebp),%eax { 102bb2: 89 5d fc mov %ebx,-0x4(%ebp) 102bb5: 8b 55 08 mov 0x8(%ebp),%edx ret = jffs2_read_inode_range(c, f, gc_buffer, 102bb8: 25 00 f0 ff ff and $0xfffff000,%eax 102bbd: 89 44 24 0c mov %eax,0xc(%esp) 102bc1: 8b 45 0c mov 0xc(%ebp),%eax unsigned char *gc_buffer = &sb->s_gc_buffer[0]; 102bc4: 8d 9a ed 00 00 00 lea 0xed(%edx),%ebx ret = jffs2_read_inode_range(c, f, gc_buffer, 102bca: 89 5c 24 08 mov %ebx,0x8(%esp) 102bce: 89 14 24 mov %edx,(%esp) 102bd1: 89 44 24 04 mov %eax,0x4(%esp) 102bd5: e8 56 47 00 00 call 107330 if (ret) 102bda: 85 c0 test %eax,%eax 102bdc: 74 02 je 102be0 <== ALWAYS TAKEN return ERR_PTR(ret); 102bde: 89 c3 mov %eax,%ebx <== NOT EXECUTED } 102be0: 89 d8 mov %ebx,%eax 102be2: 8b 5d fc mov -0x4(%ebp),%ebx 102be5: 89 ec mov %ebp,%esp 102be7: 5d pop %ebp 102be8: c3 ret 102be9: 90 nop 102bea: 90 nop 102beb: 90 nop 102bec: 90 nop 102bed: 90 nop 102bee: 90 nop 102bef: 90 nop =============================================================================== 00105b50 : { 105b50: 55 push %ebp ret = c->inocache_list[ino % c->inocache_hashsize]; 105b51: 31 d2 xor %edx,%edx { 105b53: 89 e5 mov %esp,%ebp 105b55: 53 push %ebx 105b56: 8b 4d 0c mov 0xc(%ebp),%ecx 105b59: 8b 5d 08 mov 0x8(%ebp),%ebx ret = c->inocache_list[ino % c->inocache_hashsize]; 105b5c: 89 c8 mov %ecx,%eax 105b5e: f7 b3 c0 00 00 00 divl 0xc0(%ebx) 105b64: 8b 83 c4 00 00 00 mov 0xc4(%ebx),%eax 105b6a: 8b 04 90 mov (%eax,%edx,4),%eax while (ret && ret->ino < ino) { 105b6d: 85 c0 test %eax,%eax 105b6f: 75 16 jne 105b87 105b71: eb 1b jmp 105b8e 105b73: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105b7a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi ret = ret->next; 105b80: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED while (ret && ret->ino < ino) { 105b83: 85 c0 test %eax,%eax <== NOT EXECUTED 105b85: 74 07 je 105b8e <== NOT EXECUTED 105b87: 39 48 0c cmp %ecx,0xc(%eax) 105b8a: 72 f4 jb 105b80 <== NEVER TAKEN if (ret && ret->ino != ino) 105b8c: 75 12 jne 105ba0 <== NEVER TAKEN } 105b8e: 5b pop %ebx 105b8f: 5d pop %ebp 105b90: c3 ret 105b91: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105b98: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105b9f: 90 nop 105ba0: 5b pop %ebx <== NOT EXECUTED ret = NULL; 105ba1: 31 c0 xor %eax,%eax <== NOT EXECUTED } 105ba3: 5d pop %ebp <== NOT EXECUTED 105ba4: c3 ret <== NOT EXECUTED 105ba5: 90 nop 105ba6: 90 nop 105ba7: 90 nop 105ba8: 90 nop 105ba9: 90 nop 105baa: 90 nop 105bab: 90 nop 105bac: 90 nop 105bad: 90 nop 105bae: 90 nop 105baf: 90 nop =============================================================================== 00102fc0 : { 102fc0: 55 push %ebp 102fc1: 89 e5 mov %esp,%ebp 102fc3: 57 push %edi 102fc4: 56 push %esi 102fc5: 53 push %ebx 102fc6: 83 ec 7c sub $0x7c,%esp 102fc9: 8b 45 08 mov 0x8(%ebp),%eax 102fcc: 8b 75 0c mov 0xc(%ebp),%esi for (inode = sb->s_root; inode != NULL; inode = inode->i_cache_next) { 102fcf: 8b 98 e0 00 00 00 mov 0xe0(%eax),%ebx 102fd5: 85 db test %ebx,%ebx 102fd7: 75 0e jne 102fe7 102fd9: eb 25 jmp 103000 102fdb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi 102fdf: 90 nop 102fe0: 8b 5b 64 mov 0x64(%ebx),%ebx 102fe3: 85 db test %ebx,%ebx 102fe5: 74 19 je 103000 if (inode->i_ino == ino) { 102fe7: 3b 33 cmp (%ebx),%esi 102fe9: 75 f5 jne 102fe0 inode->i_count++; 102feb: ff 43 04 incl 0x4(%ebx) } 102fee: 83 c4 7c add $0x7c,%esp 102ff1: 89 d8 mov %ebx,%eax 102ff3: 5b pop %ebx 102ff4: 5e pop %esi 102ff5: 5f pop %edi 102ff6: 5d pop %ebp 102ff7: c3 ret 102ff8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 102fff: 90 nop inode = new_inode(sb); 103000: e8 ab e4 ff ff call 1014b0 if (inode == NULL) 103005: 85 c0 test %eax,%eax inode = new_inode(sb); 103007: 89 c3 mov %eax,%ebx if (inode == NULL) 103009: 0f 84 59 01 00 00 je 103168 <== NEVER TAKEN int ret; D1(printk(KERN_DEBUG "jffs2_read_inode(): inode->i_ino == %lu\n", inode->i_ino)); f = JFFS2_INODE_INFO(inode); c = JFFS2_SB_INFO(inode->i_sb); 10300f: 8b 4b 3c mov 0x3c(%ebx),%ecx f = JFFS2_INODE_INFO(inode); 103012: 8d 43 44 lea 0x44(%ebx),%eax memset(f, 0, sizeof(*f)); 103015: bf 1c 00 00 00 mov $0x1c,%edi inode->i_ino = ino; 10301a: 89 33 mov %esi,(%ebx) memset(f, 0, sizeof(*f)); 10301c: 89 c2 mov %eax,%edx f = JFFS2_INODE_INFO(inode); 10301e: 89 45 90 mov %eax,-0x70(%ebp) c = JFFS2_SB_INFO(inode->i_sb); 103021: 89 4d 8c mov %ecx,-0x74(%ebp) memset(f, 0, sizeof(*f)); 103024: 31 c9 xor %ecx,%ecx 103026: a8 01 test $0x1,%al 103028: 0f 85 54 01 00 00 jne 103182 <== NEVER TAKEN 10302e: f6 c2 02 test $0x2,%dl 103031: 0f 85 3b 01 00 00 jne 103172 <== NEVER TAKEN 103037: 89 f8 mov %edi,%eax 103039: 83 e0 f8 and $0xfffffff8,%eax 10303c: 89 45 94 mov %eax,-0x6c(%ebp) 10303f: 31 c0 xor %eax,%eax 103041: 89 0c 02 mov %ecx,(%edx,%eax,1) 103044: 89 4c 02 04 mov %ecx,0x4(%edx,%eax,1) 103048: 83 c0 08 add $0x8,%eax 10304b: 3b 45 94 cmp -0x6c(%ebp),%eax 10304e: 72 f1 jb 103041 103050: 01 c2 add %eax,%edx 103052: f7 c7 04 00 00 00 test $0x4,%edi 103058: 0f 85 d2 00 00 00 jne 103130 <== ALWAYS TAKEN 10305e: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED 103064: 0f 85 a6 00 00 00 jne 103110 <== NOT EXECUTED 10306a: 83 e7 01 and $0x1,%edi 10306d: 0f 85 8d 00 00 00 jne 103100 <== NEVER TAKEN jffs2_init_inode_info(f); ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node); 103073: 89 74 24 08 mov %esi,0x8(%esp) 103077: 8d 45 a4 lea -0x5c(%ebp),%eax 10307a: 89 44 24 0c mov %eax,0xc(%esp) 10307e: 8b 45 90 mov -0x70(%ebp),%eax 103081: 89 44 24 04 mov %eax,0x4(%esp) 103085: 8b 45 8c mov -0x74(%ebp),%eax 103088: 89 04 24 mov %eax,(%esp) 10308b: e8 80 61 00 00 call 109210 if (ret) { 103090: 85 c0 test %eax,%eax ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node); 103092: 89 c6 mov %eax,%esi if (ret) { 103094: 0f 85 ad 00 00 00 jne 103147 <== NEVER TAKEN return ret; } inode->i_mode = jemode_to_cpu(latest_node.mode); inode->i_uid = je16_to_cpu(latest_node.uid); inode->i_gid = je16_to_cpu(latest_node.gid); inode->i_size = je32_to_cpu(latest_node.isize); 10309a: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) return jmode & (S_IFMT | S_IRWXU | S_IRWXG | S_IRWXO); 1030a1: 8b 45 b8 mov -0x48(%ebp),%eax 1030a4: 25 ff f1 00 00 and $0xf1ff,%eax inode->i_mode = jemode_to_cpu(latest_node.mode); 1030a9: 89 43 08 mov %eax,0x8(%ebx) inode->i_uid = je16_to_cpu(latest_node.uid); 1030ac: 8b 45 bc mov -0x44(%ebp),%eax 1030af: 66 89 43 0e mov %ax,0xe(%ebx) inode->i_gid = je16_to_cpu(latest_node.gid); 1030b3: 0f b7 45 be movzwl -0x42(%ebp),%eax 1030b7: 66 89 43 10 mov %ax,0x10(%ebx) inode->i_size = je32_to_cpu(latest_node.isize); 1030bb: 8b 45 c0 mov -0x40(%ebp),%eax 1030be: 89 43 34 mov %eax,0x34(%ebx) inode->i_atime = je32_to_cpu(latest_node.atime); 1030c1: 8b 45 c4 mov -0x3c(%ebp),%eax 1030c4: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) 1030cb: 89 43 14 mov %eax,0x14(%ebx) inode->i_mtime = je32_to_cpu(latest_node.mtime); 1030ce: 8b 45 c8 mov -0x38(%ebp),%eax 1030d1: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) 1030d8: 89 43 1c mov %eax,0x1c(%ebx) inode->i_ctime = je32_to_cpu(latest_node.ctime); 1030db: 8b 45 cc mov -0x34(%ebp),%eax 1030de: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) 1030e5: 89 43 24 mov %eax,0x24(%ebx) inode->i_nlink = f->inocache->pino_nlink; 1030e8: 8b 43 58 mov 0x58(%ebx),%eax 1030eb: 8b 40 14 mov 0x14(%eax),%eax 1030ee: 66 89 43 0c mov %ax,0xc(%ebx) } 1030f2: 83 c4 7c add $0x7c,%esp 1030f5: 89 d8 mov %ebx,%eax 1030f7: 5b pop %ebx 1030f8: 5e pop %esi 1030f9: 5f pop %edi 1030fa: 5d pop %ebp 1030fb: c3 ret 1030fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi memset(f, 0, sizeof(*f)); 103100: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED 103103: e9 6b ff ff ff jmp 103073 <== NOT EXECUTED 103108: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10310f: 90 nop <== NOT EXECUTED 103110: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED 103115: 83 c2 02 add $0x2,%edx <== NOT EXECUTED 103118: 83 e7 01 and $0x1,%edi <== NOT EXECUTED 10311b: 0f 84 52 ff ff ff je 103073 <== NOT EXECUTED 103121: eb dd jmp 103100 <== NOT EXECUTED 103123: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED 10312a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED 103130: c7 02 00 00 00 00 movl $0x0,(%edx) 103136: 83 c2 04 add $0x4,%edx 103139: f7 c7 02 00 00 00 test $0x2,%edi 10313f: 0f 84 25 ff ff ff je 10306a <== ALWAYS TAKEN 103145: eb c9 jmp 103110 <== NOT EXECUTED printk("jffs2_read_inode() failed\n"); 103147: c7 04 24 a5 dd 12 00 movl $0x12dda5,(%esp) <== NOT EXECUTED 10314e: e8 fd f1 ff ff call 102350 <== NOT EXECUTED inode->i_nlink = 0; // free _this_ bad inode right now 103153: 66 c7 43 0c 00 00 movw $0x0,0xc(%ebx) <== NOT EXECUTED jffs2_iput(inode); 103159: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED return ERR_PTR(err); 10315c: 89 f3 mov %esi,%ebx <== NOT EXECUTED jffs2_iput(inode); 10315e: e8 9d fa ff ff call 102c00 <== NOT EXECUTED return ERR_PTR(err); 103163: e9 86 fe ff ff jmp 102fee <== NOT EXECUTED return ERR_PTR(-ENOMEM); 103168: bb f4 ff ff ff mov $0xfffffff4,%ebx <== NOT EXECUTED 10316d: e9 7c fe ff ff jmp 102fee <== NOT EXECUTED memset(f, 0, sizeof(*f)); 103172: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED 103177: 83 ef 02 sub $0x2,%edi <== NOT EXECUTED 10317a: 83 c2 02 add $0x2,%edx <== NOT EXECUTED 10317d: e9 b5 fe ff ff jmp 103037 <== NOT EXECUTED 103182: c6 43 44 00 movb $0x0,0x44(%ebx) <== NOT EXECUTED 103186: 8d 53 45 lea 0x45(%ebx),%edx <== NOT EXECUTED 103189: bf 1b 00 00 00 mov $0x1b,%edi <== NOT EXECUTED 10318e: e9 9b fe ff ff jmp 10302e <== NOT EXECUTED 103193: 90 nop 103194: 90 nop 103195: 90 nop 103196: 90 nop 103197: 90 nop 103198: 90 nop 103199: 90 nop 10319a: 90 nop 10319b: 90 nop 10319c: 90 nop 10319d: 90 nop 10319e: 90 nop 10319f: 90 nop =============================================================================== 00102c00 : { 102c00: 55 push %ebp 102c01: 89 e5 mov %esp,%ebp 102c03: 56 push %esi 102c04: 53 push %ebx 102c05: 83 ec 10 sub $0x10,%esp 102c08: 8b 5d 08 mov 0x8(%ebp),%ebx 102c0b: eb 48 jmp 102c55 102c0d: 8d 76 00 lea 0x0(%esi),%esi if (!i->i_nlink) { 102c10: 66 83 7b 0c 00 cmpw $0x0,0xc(%ebx) 102c15: 75 59 jne 102c70 if (i->i_cache_prev) 102c17: 8b 53 60 mov 0x60(%ebx),%edx i->i_cache_prev->i_cache_next = i->i_cache_next; 102c1a: 8b 43 64 mov 0x64(%ebx),%eax if (i->i_cache_prev) 102c1d: 85 d2 test %edx,%edx 102c1f: 74 06 je 102c27 <== NEVER TAKEN i->i_cache_prev->i_cache_next = i->i_cache_next; 102c21: 89 42 64 mov %eax,0x64(%edx) if (i->i_cache_next) 102c24: 8b 43 64 mov 0x64(%ebx),%eax 102c27: 85 c0 test %eax,%eax 102c29: 74 03 je 102c2e i->i_cache_next->i_cache_prev = i->i_cache_prev; 102c2b: 89 50 60 mov %edx,0x60(%eax) <== NOT EXECUTED struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); 102c2e: 8d 43 44 lea 0x44(%ebx),%eax parent = i->i_parent; 102c31: 8b 73 30 mov 0x30(%ebx),%esi struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); 102c34: 89 44 24 04 mov %eax,0x4(%esp) jffs2_do_clear_inode(c, f); 102c38: 8b 43 3c mov 0x3c(%ebx),%eax 102c3b: 89 04 24 mov %eax,(%esp) 102c3e: e8 cd 67 00 00 call 109410 free(i); 102c43: 89 1c 24 mov %ebx,(%esp) 102c46: e8 e5 b4 00 00 call 10e130 if (parent && parent != i) { 102c4b: 85 f6 test %esi,%esi 102c4d: 74 13 je 102c62 102c4f: 39 f3 cmp %esi,%ebx 102c51: 74 0f je 102c62 <== NEVER TAKEN 102c53: 89 f3 mov %esi,%ebx assert(i != NULL); 102c55: 85 db test %ebx,%ebx 102c57: 74 54 je 102cad <== NEVER TAKEN i->i_count--; 102c59: ff 4b 04 decl 0x4(%ebx) if (i->i_count < 0) 102c5c: 78 28 js 102c86 <== NEVER TAKEN if (i->i_count) 102c5e: 66 90 xchg %ax,%ax 102c60: 74 ae je 102c10 } 102c62: 83 c4 10 add $0x10,%esp 102c65: 5b pop %ebx 102c66: 5e pop %esi 102c67: 5d pop %ebp 102c68: c3 ret 102c69: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi icache_evict(i->i_sb->s_root, i); 102c70: 8b 43 3c mov 0x3c(%ebx),%eax 102c73: 89 da mov %ebx,%edx 102c75: 8b 80 e0 00 00 00 mov 0xe0(%eax),%eax } 102c7b: 83 c4 10 add $0x10,%esp 102c7e: 5b pop %ebx 102c7f: 5e pop %esi 102c80: 5d pop %ebp icache_evict(i->i_sb->s_root, i); 102c81: e9 8a f0 ff ff jmp 101d10 BUG(); 102c86: b8 3b d6 12 00 mov $0x12d63b,%eax <== NOT EXECUTED 102c8b: ba 1c de 12 00 mov $0x12de1c,%edx <== NOT EXECUTED 102c90: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED 102c94: b9 a8 05 00 00 mov $0x5a8,%ecx <== NOT EXECUTED 102c99: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED 102c9d: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED 102ca1: c7 04 24 44 dd 12 00 movl $0x12dd44,(%esp) <== NOT EXECUTED 102ca8: e8 c3 af 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED assert(i != NULL); 102cad: bb 39 dd 12 00 mov $0x12dd39,%ebx <== NOT EXECUTED 102cb2: be 1c de 12 00 mov $0x12de1c,%esi <== NOT EXECUTED 102cb7: 89 5c 24 0c mov %ebx,0xc(%esp) <== NOT EXECUTED 102cbb: b8 a3 05 00 00 mov $0x5a3,%eax <== NOT EXECUTED 102cc0: 89 74 24 08 mov %esi,0x8(%esp) <== NOT EXECUTED 102cc4: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 102cc8: c7 04 24 44 dd 12 00 movl $0x12dd44,(%esp) <== NOT EXECUTED 102ccf: e8 9c af 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED 102cd4: 90 nop 102cd5: 90 nop 102cd6: 90 nop 102cd7: 90 nop 102cd8: 90 nop 102cd9: 90 nop 102cda: 90 nop 102cdb: 90 nop 102cdc: 90 nop 102cdd: 90 nop 102cde: 90 nop 102cdf: 90 nop =============================================================================== 00105de0 : /* Pass 'c' argument to indicate that nodes should be marked obsolete as they're killed. */ void jffs2_kill_fragtree(struct rb_root *root, struct jffs2_sb_info *c) { 105de0: 55 push %ebp struct jffs2_node_frag *frag, *next; dbg_fragtree("killing\n"); rbtree_postorder_for_each_entry_safe(frag, next, root, rb) { 105de1: 31 d2 xor %edx,%edx { 105de3: 89 e5 mov %esp,%ebp 105de5: 57 push %edi 105de6: 56 push %esi 105de7: 53 push %ebx 105de8: 83 ec 1c sub $0x1c,%esp rbtree_postorder_for_each_entry_safe(frag, next, root, rb) { 105deb: 89 54 24 04 mov %edx,0x4(%esp) 105def: 8b 45 08 mov 0x8(%ebp),%eax { 105df2: 8b 75 0c mov 0xc(%ebp),%esi rbtree_postorder_for_each_entry_safe(frag, next, root, rb) { 105df5: 89 04 24 mov %eax,(%esp) 105df8: e8 a3 fd 00 00 call 115ba0 <_RBTree_Postorder_first> 105dfd: 85 c0 test %eax,%eax 105dff: 89 c3 mov %eax,%ebx 105e01: 74 54 je 105e57 105e03: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi 105e0a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi 105e10: 89 1c 24 mov %ebx,(%esp) 105e13: 31 c0 xor %eax,%eax 105e15: 89 df mov %ebx,%edi 105e17: 89 44 24 04 mov %eax,0x4(%esp) 105e1b: e8 40 fd 00 00 call 115b60 <_RBTree_Postorder_next> 105e20: 89 c3 mov %eax,%ebx if (frag->node && !(--frag->node->frags)) { 105e22: 8b 47 10 mov 0x10(%edi),%eax 105e25: 85 c0 test %eax,%eax 105e27: 74 22 je 105e4b <== NEVER TAKEN 105e29: ff 48 0c decl 0xc(%eax) 105e2c: 75 1d jne 105e4b <== NEVER TAKEN /* Not a hole, and it's the final remaining frag of this node. Free the node */ if (c) 105e2e: 85 f6 test %esi,%esi 105e30: 74 11 je 105e43 jffs2_mark_node_obsolete(c, frag->node->raw); 105e32: 8b 00 mov (%eax),%eax <== NOT EXECUTED 105e34: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 105e37: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED 105e3b: e8 80 05 00 00 call 1063c0 <== NOT EXECUTED jffs2_free_full_dnode(frag->node); 105e40: 8b 47 10 mov 0x10(%edi),%eax 105e43: 89 04 24 mov %eax,(%esp) 105e46: e8 15 f3 ff ff call 105160 } jffs2_free_node_frag(frag); 105e4b: 89 3c 24 mov %edi,(%esp) 105e4e: e8 8d f4 ff ff call 1052e0 rbtree_postorder_for_each_entry_safe(frag, next, root, rb) { 105e53: 85 db test %ebx,%ebx 105e55: 75 b9 jne 105e10 cond_resched(); } } 105e57: 83 c4 1c add $0x1c,%esp 105e5a: 5b pop %ebx 105e5b: 5e pop %esi 105e5c: 5f pop %edi 105e5d: 5d pop %ebp 105e5e: c3 ret 105e5f: 90 nop =============================================================================== 0010b5a0 : /***********************************************************************/ int jffs2_link (struct _inode *old_d_inode, struct _inode *dir_i, const unsigned char *d_name, size_t d_namelen) { 10b5a0: 55 push %ebp 10b5a1: 89 e5 mov %esp,%ebp 10b5a3: 83 ec 48 sub $0x48,%esp 10b5a6: 89 75 f8 mov %esi,-0x8(%ebp) 10b5a9: 8b 75 08 mov 0x8(%ebp),%esi 10b5ac: 89 5d f4 mov %ebx,-0xc(%ebp) struct jffs2_sb_info *c = JFFS2_SB_INFO(old_d_inode->i_sb); struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_d_inode); struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 10b5af: 8b 45 0c mov 0xc(%ebp),%eax { 10b5b2: 89 7d fc mov %edi,-0x4(%ebp) int ret; /* XXX: This is ugly */ uint8_t type = (old_d_inode->i_mode & S_IFMT) >> 12; 10b5b5: 8b 5e 08 mov 0x8(%esi),%ebx struct jffs2_sb_info *c = JFFS2_SB_INFO(old_d_inode->i_sb); 10b5b8: 8b 4e 3c mov 0x3c(%esi),%ecx struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 10b5bb: 8d 78 44 lea 0x44(%eax),%edi uint8_t type = (old_d_inode->i_mode & S_IFMT) >> 12; 10b5be: c1 eb 0c shr $0xc,%ebx if (!type) type = DT_REG; 10b5c1: 80 e3 0f and $0xf,%bl 10b5c4: 75 02 jne 10b5c8 <== ALWAYS TAKEN 10b5c6: b3 08 mov $0x8,%bl <== NOT EXECUTED ret = jffs2_do_link(c, dir_f, f->inocache->ino, type, (const char * )d_name, d_namelen, get_seconds()); 10b5c8: c7 04 24 00 00 00 00 movl $0x0,(%esp) ret = jffs2_do_link(c, dir_f, f->inocache->ino, type, 10b5cf: 0f b6 db movzbl %bl,%ebx 10b5d2: 89 4d e4 mov %ecx,-0x1c(%ebp) d_namelen, get_seconds()); 10b5d5: e8 56 f4 01 00 call 12aa30