RTEMS-6
Annotated Report
libjffs2
Sun Feb 28 23:11:48 2021
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 <jffs2_printk> <== 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 <jffs2_printk> <== 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 <jffs2_printk> <== 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 <jffs2_printk> <== 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 <jffs2_printk> <== 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 <jffs2_add_fd_to_list>:
{
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 <jffs2_add_fd_to_list+0xa0>
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 <jffs2_add_fd_to_list+0x3a>
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 <jffs2_add_fd_to_list+0xa0>
10548a: 39 73 10 cmp %esi,0x10(%ebx)
10548d: 77 61 ja 1054f0 <jffs2_add_fd_to_list+0xa0>
if ((*prev)->nhash == new->nhash && !strcmp((*prev)->name, new->name)) {
10548f: 75 ef jne 105480 <jffs2_add_fd_to_list+0x30>
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 <strcmp>
1054a3: 85 c0 test %eax,%eax
1054a5: 75 d9 jne 105480 <jffs2_add_fd_to_list+0x30> <== 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 <jffs2_add_fd_to_list+0xb0> <== 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_add_fd_to_list+0x84>
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 <jffs2_mark_node_obsolete> <== 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 <jffs2_free_full_dirent>
*prev = new;
1054dc: 8b 45 e0 mov -0x20(%ebp),%eax
1054df: 89 07 mov %eax,(%edi)
1054e1: eb 15 jmp 1054f8 <jffs2_add_fd_to_list+0xa8>
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 <jffs2_mark_node_obsolete> <== 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 <jffs2_free_full_dirent> <== 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 <jffs2_add_full_dnode_to_inode>:
{
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 <jffs2_add_full_dnode_to_inode+0x20> <== 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 <jffs2_alloc_node_frag>
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 <jffs2_add_full_dnode_to_inode+0x390> <== 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 <jffs2_add_full_dnode_to_inode+0x1c0>
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 <jffs2_add_full_dnode_to_inode+0x1b0>
if (!prev || frag->ofs > prev->ofs)
105730: 85 c9 test %ecx,%ecx
105732: 0f 84 18 01 00 00 je 105850 <jffs2_add_full_dnode_to_inode+0x1a0>
105738: 3b 41 18 cmp 0x18(%ecx),%eax
10573b: 0f 87 0f 01 00 00 ja 105850 <jffs2_add_full_dnode_to_inode+0x1a0> <== 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 <jffs2_add_full_dnode_to_inode+0x70>
if (this) {
105748: 85 c9 test %ecx,%ecx
10574a: 0f 84 20 01 00 00 je 105870 <jffs2_add_full_dnode_to_inode+0x1c0> <== 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 <jffs2_add_full_dnode_to_inode+0x2e0>
if (newfrag->ofs > this->ofs) {
105763: 39 45 dc cmp %eax,-0x24(%ebp)
105766: 0f 86 74 02 00 00 jbe 1059e0 <jffs2_add_full_dnode_to_inode+0x330>
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 <jffs2_add_full_dnode_to_inode+0xd2>
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 <jffs2_add_full_dnode_to_inode+0x230> <== 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 <jffs2_alloc_node_frag> <== 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 <jffs2_add_full_dnode_to_inode+0x390> <== 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 <jffs2_add_full_dnode_to_inode+0x118> <== 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 <jffs2_fragtree_insert> <== 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 <jffs2_fragtree_insert> <== 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 <jffs2_add_full_dnode_to_inode+0x206>
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 <jffs2_add_full_dnode_to_inode+0x16>
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 <jffs2_add_full_dnode_to_inode+0x16>
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 <jffs2_add_full_dnode_to_inode+0x16> <== 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 <jffs2_add_full_dnode_to_inode+0x16>
10584d: 8d 76 00 lea 0x0(%esi),%esi
105850: 89 d9 mov %ebx,%ecx
105852: e9 ea fe ff ff jmp 105741 <jffs2_add_full_dnode_to_inode+0x91>
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 <jffs2_add_full_dnode_to_inode+0xaa>
next = frag->rb.rb_left;
105868: 8b 1b mov (%ebx),%ebx
10586a: e9 d5 fe ff ff jmp 105744 <jffs2_add_full_dnode_to_inode+0x94>
10586f: 90 nop
if (lastend < newfrag->node->ofs) {
105870: 85 d2 test %edx,%edx
105872: 0f 85 59 02 00 00 jne 105ad1 <jffs2_add_full_dnode_to_inode+0x421>
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 <jffs2_add_full_dnode_to_inode+0x15e>
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 <jffs2_add_full_dnode_to_inode+0x224>
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 <jffs2_add_full_dnode_to_inode+0x15e>
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 <jffs2_fragtree_insert>
_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 <jffs2_add_full_dnode_to_inode+0x279>
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 <jffs2_obsolete_node_frag>
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 <jffs2_add_full_dnode_to_inode+0x153>
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 <jffs2_add_full_dnode_to_inode+0x260>
if (!this || newfrag->ofs + newfrag->size == this->ofs)
10594f: 39 f1 cmp %esi,%ecx
105951: 0f 84 ac fe ff ff je 105803 <jffs2_add_full_dnode_to_inode+0x153>
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 <jffs2_add_full_dnode_to_inode+0x2c1> <== 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 <jffs2_add_full_dnode_to_inode+0x153>
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 <jffs2_add_full_dnode_to_inode+0x2f8> <== 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 <jffs2_add_full_dnode_to_inode+0x406>
if (lastend < newfrag->node->ofs) {
1059a8: 39 f2 cmp %esi,%edx
1059aa: 0f 87 b2 00 00 00 ja 105a62 <jffs2_add_full_dnode_to_inode+0x3b2> <== 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 <jffs2_add_full_dnode_to_inode+0x1e9>
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 <jffs2_add_full_dnode_to_inode+0x26f> <== 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 <jffs2_fragtree_insert> <== 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 <jffs2_add_full_dnode_to_inode+0x153> <== 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 <jffs2_printk> <== 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 <jffs2_alloc_node_frag> <== NOT EXECUTED
if (likely(newfrag)) {
105a6c: 85 c0 test %eax,%eax <== NOT EXECUTED
105a6e: 0f 84 a4 00 00 00 je 105b18 <jffs2_add_full_dnode_to_inode+0x468> <== 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 <jffs2_add_full_dnode_to_inode+0x302>
if (this->node)
105ab6: 8b 43 10 mov 0x10(%ebx),%eax
105ab9: 85 c0 test %eax,%eax
105abb: 74 06 je 105ac3 <jffs2_add_full_dnode_to_inode+0x413> <== 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 <jffs2_add_full_dnode_to_inode+0x2f8>
105ad1: 89 55 e0 mov %edx,-0x20(%ebp)
newfrag = jffs2_alloc_node_frag();
105ad4: e8 e7 f7 ff ff call 1052c0 <jffs2_alloc_node_frag>
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 <jffs2_add_full_dnode_to_inode+0x468> <== 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_add_full_dnode_to_inode+0x3f2>
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 <jffs2_printk> <== NOT EXECUTED
jffs2_free_node_frag(newfrag);
105b2d: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
105b30: e8 ab f7 ff ff call 1052e0 <jffs2_free_node_frag> <== NOT EXECUTED
return -ENOMEM;
105b35: b8 f4 ff ff ff mov $0xfffffff4,%eax <== NOT EXECUTED
105b3a: e9 89 fb ff ff jmp 1056c8 <jffs2_add_full_dnode_to_inode+0x18> <== NOT EXECUTED
105b3f: 90 nop
00105bb0 <jffs2_add_ino_cache>:
{
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 <jffs2_add_ino_cache+0x1e>
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 <jffs2_add_ino_cache+0x4a> <== NEVER TAKEN
105be7: eb 16 jmp 105bff <jffs2_add_ino_cache+0x4f>
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 <jffs2_add_ino_cache+0x4f> <== NOT EXECUTED
105bfa: 39 48 0c cmp %ecx,0xc(%eax) <== NOT EXECUTED
105bfd: 72 f1 jb 105bf0 <jffs2_add_ino_cache+0x40> <== 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 <jffs2_add_physical_node_ref>:
*/
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 <jffs2_add_physical_node_ref+0xb0> <== 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 <jffs2_add_physical_node_ref+0x48> <== 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 <jffs2_add_physical_node_ref+0xbc> <== 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 <jffs2_printk> <== 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 <jffs2_add_physical_node_ref+0x130> <== 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 <jffs2_printk> <== 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 <jffs2_printk> <== 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 <jffs2_add_physical_node_ref+0x31> <== 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 <jffs2_link_node_ref>
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 <jffs2_add_physical_node_ref+0x108>
106321: 8b 56 18 mov 0x18(%esi),%edx
106324: 85 d2 test %edx,%edx
106326: 75 20 jne 106348 <jffs2_add_physical_node_ref+0x108> <== NEVER TAKEN
106328: 81 7e 1c c4 00 00 00 cmpl $0xc4,0x1c(%esi)
10632f: 77 17 ja 106348 <jffs2_add_physical_node_ref+0x108>
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 <jffs2_printk> <== NOT EXECUTED
10637c: e9 3c ff ff ff jmp 1062bd <jffs2_add_physical_node_ref+0x7d> <== 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 <jffs2_complete_reservation>:
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 <jffs2_complete_reservation+0x20> <== 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 <jffs2_compress>:
* *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 <jffs2_compress+0x49> <== 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 <jffs2_compress+0x54>
*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 <jffs2_create>:
/***********************************************************************/
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 <jffs2_alloc_raw_inode>
if (!ri)
10b443: 85 c0 test %eax,%eax
10b445: 0f 84 de 00 00 00 je 10b529 <jffs2_create+0x109> <== 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 <jffs2_new_inode>
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 <jffs2_create+0xf0> <== 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 <jffs2_do_create>
if (ret) {
10b497: 89 45 d4 mov %eax,-0x2c(%ebp)
10b49a: 85 c0 test %eax,%eax
10b49c: 75 42 jne 10b4e0 <jffs2_create+0xc0> <== 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 <jffs2_free_raw_inode>
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 <jffs2_iput>
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 <jffs2_iput> <== NOT EXECUTED
jffs2_free_raw_inode(ri);
10b4ee: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10b4f1: e8 ca 9c ff ff call 1051c0 <jffs2_free_raw_inode> <== 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 <jffs2_free_raw_inode> <== 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 <jffs2_create+0xa2> <== NOT EXECUTED
0010af50 <jffs2_decompress>:
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 <jffs2_decompress+0x70> <== 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 <jffs2_decompress+0x15f> <== 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 <jffs2_decompress+0x90> <== 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 <jffs2_decompress+0x130> <== 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 <jffs2_decompress+0x1da> <== 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 <jffs2_decompress+0xf0> <== NOT EXECUTED
10aff0: f6 c2 04 test $0x4,%dl <== NOT EXECUTED
10aff3: 75 3b jne 10b030 <jffs2_decompress+0xe0> <== NOT EXECUTED
10aff5: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
10aff8: 75 26 jne 10b020 <jffs2_decompress+0xd0> <== NOT EXECUTED
10affa: f6 c2 01 test $0x1,%dl <== NOT EXECUTED
10affd: 75 11 jne 10b010 <jffs2_decompress+0xc0> <== 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 <jffs2_decompress+0xb1> <== 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 <jffs2_decompress+0xaf> <== NOT EXECUTED
10b02d: eb e1 jmp 10b010 <jffs2_decompress+0xc0> <== 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 <jffs2_decompress+0xaa> <== NOT EXECUTED
10b03e: eb e0 jmp 10b020 <jffs2_decompress+0xd0> <== NOT EXECUTED
10b040: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED
10b046: 0f 85 d4 00 00 00 jne 10b120 <jffs2_decompress+0x1d0> <== NOT EXECUTED
10b04c: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
10b052: 0f 85 b8 00 00 00 jne 10b110 <jffs2_decompress+0x1c0> <== NOT EXECUTED
10b058: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
10b05e: 0f 85 8c 00 00 00 jne 10b0f0 <jffs2_decompress+0x1a0> <== 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 <jffs2_decompress+0xa5> <== NOT EXECUTED
10b075: eb b9 jmp 10b030 <jffs2_decompress+0xe0> <== 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 <jffs2_decompress+0x190> <== NOT EXECUTED
10b088: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
10b08e: 75 30 jne 10b0c0 <jffs2_decompress+0x170> <== NOT EXECUTED
10b090: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
10b096: 0f 84 31 ff ff ff je 10afcd <jffs2_decompress+0x7d> <== 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 <jffs2_decompress+0x7d> <== NOT EXECUTED
return -EIO;
10b0af: b8 fb ff ff ff mov $0xfffffffb,%eax <== NOT EXECUTED
10b0b4: e9 18 ff ff ff jmp 10afd1 <jffs2_decompress+0x81> <== 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 <jffs2_decompress+0x140> <== 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 <jffs2_decompress+0x138> <== 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 <jffs2_decompress+0x114> <== 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 <jffs2_decompress+0x108> <== 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 <jffs2_decompress+0xfc> <== NOT EXECUTED
switch (comprtype & 0xff) {
10b12a: 89 c2 mov %eax,%edx
10b12c: e9 4d fe ff ff jmp 10af7e <jffs2_decompress+0x2e>
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 <jffs2_del_ino_cache>:
{
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 <jffs2_del_ino_cache+0x3a>
105c37: eb 1f jmp 105c58 <jffs2_del_ino_cache+0x48>
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 <jffs2_del_ino_cache+0x48> <== NOT EXECUTED
105c4a: 3b 48 0c cmp 0xc(%eax),%ecx
105c4d: 77 f1 ja 105c40 <jffs2_del_ino_cache+0x30> <== NEVER TAKEN
if ((*prev) == old) {
105c4f: 39 c3 cmp %eax,%ebx
105c51: 75 05 jne 105c58 <jffs2_del_ino_cache+0x48> <== 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 <jffs2_del_ino_cache+0x60>
}
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 <jffs2_free_inode_cache>
105c7b: 90 nop
105c7c: 90 nop
105c7d: 90 nop
105c7e: 90 nop
105c7f: 90 nop
00109410 <jffs2_do_clear_inode>:
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 <jffs2_do_clear_inode+0x57> <== 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 <jffs2_do_clear_inode+0x50>
if (f->inocache && f->inocache->state != INO_STATE_CHECKING)
109431: 4a dec %edx
109432: 0f 85 c8 00 00 00 jne 109500 <jffs2_do_clear_inode+0xf0> <== 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 <jffs2_do_clear_inode+0x48>
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 <jffs2_mark_node_obsolete> <== 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_free_full_dnode>
}
jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL);
109458: 89 f8 mov %edi,%eax
10945a: eb 1c jmp 109478 <jffs2_do_clear_inode+0x68>
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 <jffs2_do_clear_inode+0x110> <== 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 <jffs2_do_clear_inode+0x66> <== NOT EXECUTED
jffs2_free_full_dnode(f->metadata);
10946e: 89 04 24 mov %eax,(%esp)
109471: e8 ea bc ff ff call 105160 <jffs2_free_full_dnode>
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 <jffs2_kill_fragtree>
if (f->target) {
109487: 8b 46 10 mov 0x10(%esi),%eax
10948a: 85 c0 test %eax,%eax
10948c: 74 0f je 10949d <jffs2_do_clear_inode+0x8d>
kfree(f->target);
10948e: 89 04 24 mov %eax,(%esp)
109491: e8 9a 4c 00 00 call 10e130 <free>
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 <jffs2_do_clear_inode+0xb1>
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 <jffs2_free_full_dirent>
while(fds) {
1094bd: 85 db test %ebx,%ebx
1094bf: 75 ef jne 1094b0 <jffs2_do_clear_inode+0xa0>
}
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 <jffs2_do_clear_inode+0xdc> <== NEVER TAKEN
1094c8: 66 83 78 0a 01 cmpw $0x1,0xa(%eax)
1094cd: 74 1d je 1094ec <jffs2_do_clear_inode+0xdc> <== 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 <jffs2_set_inocache_state>
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_do_clear_inode+0x135>
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 <jffs2_set_inocache_state>
109515: e9 1e ff ff ff jmp 109438 <jffs2_do_clear_inode+0x28>
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 <jffs2_set_inocache_state>
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 <jffs2_do_clear_inode+0x66>
109540: e9 29 ff ff ff jmp 10946e <jffs2_do_clear_inode+0x5e>
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 <jffs2_del_ino_cache> <== 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 <jffs2_do_crccheck_inode>:
{
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 <calloc> <== NOT EXECUTED
if (!f)
109580: 85 c0 test %eax,%eax <== NOT EXECUTED
109582: 74 35 je 1095b9 <jffs2_do_crccheck_inode+0x59> <== 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 <jffs2_do_read_inode_internal> <== 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 <jffs2_do_clear_inode> <== NOT EXECUTED
kfree (f);
1095a7: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
1095aa: e8 81 4b 00 00 call 10e130 <free> <== 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 <jffs2_do_crccheck_inode+0x52> <== NOT EXECUTED
0010a1e0 <jffs2_do_create>:
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_reserve_space>
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 <jffs2_do_create+0x50> <== 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 <cyg_crc32_accumulate>
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 <jffs2_write_dnode>
if (IS_ERR(fn)) {
10a278: 3d 18 fc ff ff cmp $0xfffffc18,%eax
10a27d: 0f 87 7d 01 00 00 ja 10a400 <jffs2_do_create+0x220> <== 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 <jffs2_complete_reservation>
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 <jffs2_reserve_space>
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 <jffs2_do_create+0x3c> <== NEVER TAKEN
10a2c1: 89 45 d4 mov %eax,-0x2c(%ebp)
rd = jffs2_alloc_raw_dirent();
10a2c4: e8 a7 ae ff ff call 105170 <jffs2_alloc_raw_dirent>
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 <jffs2_do_create+0x24f> <== 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 <cyg_crc32_accumulate>
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 <cyg_crc32_accumulate>
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 <cyg_crc32_accumulate>
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_write_dirent>
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 <jffs2_free_raw_dirent>
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 <jffs2_do_create+0x240> <== 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_add_fd_to_list>
jffs2_complete_reservation(c);
10a3dc: 89 1c 24 mov %ebx,(%esp)
10a3df: e8 ac bf ff ff call 106390 <jffs2_complete_reservation>
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 <jffs2_complete_reservation> <== 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 <jffs2_complete_reservation> <== NOT EXECUTED
return PTR_ERR(fd);
10a428: 89 f2 mov %esi,%edx <== NOT EXECUTED
10a42a: e9 ed fd ff ff jmp 10a21c <jffs2_do_create+0x3c> <== NOT EXECUTED
jffs2_complete_reservation(c);
10a42f: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10a432: e8 59 bf ff ff call 106390 <jffs2_complete_reservation> <== NOT EXECUTED
return -ENOMEM;
10a437: ba f4 ff ff ff mov $0xfffffff4,%edx <== NOT EXECUTED
10a43c: e9 db fd ff ff jmp 10a21c <jffs2_do_create+0x3c> <== 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 <jffs2_do_link>:
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 <jffs2_alloc_raw_dirent>
if (!rd)
10a5da: 85 c0 test %eax,%eax
10a5dc: 0f 84 63 01 00 00 je 10a745 <jffs2_do_link+0x185> <== 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 <jffs2_reserve_space>
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 <jffs2_do_link+0x170> <== 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 <cyg_crc32_accumulate>
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 <cyg_crc32_accumulate>
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 <cyg_crc32_accumulate>
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_write_dirent>
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 <jffs2_free_raw_dirent>
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 <jffs2_do_link+0x150> <== 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 <jffs2_add_fd_to_list> <== 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 <jffs2_complete_reservation>
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 <jffs2_complete_reservation> <== 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 <jffs2_free_raw_dirent> <== 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 <jffs2_do_link+0x13d> <== NOT EXECUTED
10a74c: 90 nop
10a74d: 90 nop
10a74e: 90 nop
10a74f: 90 nop
0010a800 <jffs2_do_mount_fs>:
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 <calloc>
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 <jffs2_do_mount_fs+0x679> <== NEVER TAKEN
return -ENOMEM;
for (i=0; i<c->nr_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 <jffs2_do_mount_fs+0x75> <== 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; i<c->nr_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; i<c->nr_blocks; i++) {
10a86e: 83 c0 34 add $0x34,%eax
10a871: 39 d6 cmp %edx,%esi
10a873: 77 eb ja 10a860 <jffs2_do_mount_fs+0x60>
}
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 <jffs2_scan_medium>
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 <jffs2_do_mount_fs+0x526> <== 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 <jffs2_do_mount_fs+0x670> <== 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 <jffs2_do_mount_fs+0x1a5>
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 <jffs2_do_mount_fs+0x1ac>
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 <jffs2_do_mount_fs+0x1a0> <== 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 <jffs2_do_mount_fs+0x320> <== 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 <jffs2_do_mount_fs+0x669> <== 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 <jffs2_do_mount_fs+0x1e5>
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 <jffs2_do_mount_fs+0x1ec>
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 <jffs2_do_mount_fs+0x1e0> <== ALWAYS TAKEN
for_each_inode(i, c, ic) {
10a9ec: 85 f6 test %esi,%esi
10a9ee: 0f 85 f4 03 00 00 jne 10ade8 <jffs2_do_mount_fs+0x5e8> <== 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 <jffs2_do_mount_fs+0x24d> <== 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 <jffs2_get_ino_cache> <== 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 <jffs2_do_mount_fs+0x235> <== 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 <jffs2_build_remove_unlinked_inode> <== NOT EXECUTED
jffs2_free_full_dirent(fd);
10aa35: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10aa38: e8 f3 a6 ff ff call 105130 <jffs2_free_full_dirent> <== 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 <jffs2_do_mount_fs+0x210> <== 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 <jffs2_do_mount_fs+0x37b> <== 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 <jffs2_do_mount_fs+0x373> <== 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 <jffs2_do_mount_fs+0x27a> <== 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 <jffs2_do_mount_fs+0x373> <== 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 <jffs2_do_mount_fs+0x271> <== 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 <jffs2_do_mount_fs+0x29d> <== 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 <jffs2_do_mount_fs+0x290> <== 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 <jffs2_do_mount_fs+0x37b> <== 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 <jffs2_do_mount_fs+0x2c9> <== 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 <jffs2_do_mount_fs+0x37b> <== 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 <jffs2_do_mount_fs+0x2c0> <== NOT EXECUTED
10aad0: eb be jmp 10aa90 <jffs2_do_mount_fs+0x290> <== 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 <jffs2_do_mount_fs+0x320> <== 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 <jffs2_do_mount_fs+0x1c0> <== 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 <jffs2_do_mount_fs+0x319> <== 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 <jffs2_do_mount_fs+0x1c0> <== 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 <jffs2_do_mount_fs+0x310> <== 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 <jffs2_do_mount_fs+0x2e3> <== 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 <jffs2_do_mount_fs+0x337> <== 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 <jffs2_do_mount_fs+0x2e0> <== 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 <jffs2_do_mount_fs+0x330> <== 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 <jffs2_get_ino_cache> <== NOT EXECUTED
if (!child_ic) {
10ab4a: 85 c0 test %eax,%eax <== NOT EXECUTED
10ab4c: 0f 84 bb 01 00 00 je 10ad0d <jffs2_do_mount_fs+0x50d> <== 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 <jffs2_do_mount_fs+0x330> <== 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 <jffs2_do_mount_fs+0x330> <== NOT EXECUTED
*dir_hardlinks = 1;
10ab6a: c7 45 d0 01 00 00 00 movl $0x1,-0x30(%ebp) <== NOT EXECUTED
10ab71: eb bd jmp 10ab30 <jffs2_do_mount_fs+0x330> <== 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 <jffs2_do_mount_fs+0x290> <== 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 <jffs2_do_mount_fs+0x485> <== 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 <jffs2_do_mount_fs+0x3a9>
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 <jffs2_do_mount_fs+0x485>
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 <jffs2_do_mount_fs+0x3a0> <== 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 <jffs2_do_mount_fs+0x403> <== 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 <jffs2_do_mount_fs+0x3e9> <== 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 <jffs2_do_mount_fs+0x642> <== 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 <jffs2_do_mount_fs+0x3d8> <== 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 <jffs2_do_mount_fs+0x450> <== 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 <jffs2_free_full_dirent> <== 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 <jffs2_do_mount_fs+0x400> <== 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 <jffs2_do_mount_fs+0x3db> <== 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 <jffs2_do_mount_fs+0x3c0> <== 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 <jffs2_do_mount_fs+0x3e9> <== 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 <jffs2_do_mount_fs+0x3b0> <== 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 <jffs2_do_mount_fs+0x48d> <== 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 <jffs2_do_mount_fs+0x435> <== 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 <jffs2_do_mount_fs+0x48d> <== 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 <jffs2_do_mount_fs+0x430> <== NOT EXECUTED
10ac3c: e9 6f ff ff ff jmp 10abb0 <jffs2_do_mount_fs+0x3b0> <== 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 <jffs2_printk.constprop.0> <== 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 <jffs2_do_mount_fs+0x3d8> <== NOT EXECUTED
for_each_inode(i, c, ic) {
10ac85: 85 f6 test %esi,%esi
10ac87: 0f 85 23 ff ff ff jne 10abb0 <jffs2_do_mount_fs+0x3b0> <== 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 <jffs2_rotate_lists>
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 <jffs2_mark_node_obsolete> <== 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 <jffs2_do_mount_fs+0x330> <== 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 <jffs2_do_mount_fs+0x5e2> <== 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 <jffs2_do_mount_fs+0x551> <== 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 <jffs2_do_mount_fs+0x5e2> <== 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 <jffs2_do_mount_fs+0x548> <== NOT EXECUTED
10ad58: eb 13 jmp 10ad6d <jffs2_do_mount_fs+0x56d> <== 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 <jffs2_free_full_dirent> <== 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 <jffs2_do_mount_fs+0x560> <== 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 <jffs2_do_mount_fs+0x56d> <== 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 <jffs2_do_mount_fs+0x5ac> <== 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 <jffs2_do_mount_fs+0x56d> <== 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 <jffs2_do_mount_fs+0x5a0> <== 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 <jffs2_free_ino_caches> <== 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 <jffs2_free_raw_node_refs> <== 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 <free> <== 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 <jffs2_do_mount_fs+0x5ac> <== NOT EXECUTED
10ade6: eb 85 jmp 10ad6d <jffs2_do_mount_fs+0x56d> <== 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 <jffs2_do_mount_fs+0x603> <== 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 <jffs2_build_remove_unlinked_inode> <== 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 <jffs2_do_mount_fs+0x5f0> <== 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 <jffs2_do_mount_fs+0x200> <== 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 <jffs2_do_mount_fs+0x639> <== 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 <jffs2_do_mount_fs+0x200> <== 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 <jffs2_do_mount_fs+0x630> <== NOT EXECUTED
10ae40: eb ae jmp 10adf0 <jffs2_do_mount_fs+0x5f0> <== 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 <jffs2_do_mount_fs+0x1ec> <== 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 <jffs2_do_mount_fs+0x1ac> <== 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 <jffs2_do_mount_fs+0x502> <== 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 <jffs2_do_new_inode>:
#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 <jffs2_alloc_inode_cache>
if (!ic) {
1095f4: 85 c0 test %eax,%eax
1095f6: 0f 84 44 01 00 00 je 109740 <jffs2_do_new_inode+0x160> <== 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 <jffs2_do_new_inode+0x150> <== NEVER TAKEN
10960b: f6 c2 02 test $0x2,%dl
10960e: 0f 85 0c 01 00 00 jne 109720 <jffs2_do_new_inode+0x140> <== 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 <jffs2_do_new_inode+0x3e>
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 <jffs2_do_new_inode+0x120> <== NEVER TAKEN
109643: f7 c7 02 00 00 00 test $0x2,%edi
109649: 0f 85 91 00 00 00 jne 1096e0 <jffs2_do_new_inode+0x100> <== NEVER TAKEN
10964f: 83 e7 01 and $0x1,%edi
109652: 75 7c jne 1096d0 <jffs2_do_new_inode+0xf0> <== 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 <jffs2_add_ino_cache> <== 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 <cyg_crc32_accumulate>
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 <jffs2_do_new_inode+0x74> <== 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 <jffs2_do_new_inode+0x74> <== NOT EXECUTED
1096f1: eb dd jmp 1096d0 <jffs2_do_new_inode+0xf0> <== 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 <jffs2_do_new_inode+0x6f> <== NOT EXECUTED
109715: eb c9 jmp 1096e0 <jffs2_do_new_inode+0x100> <== 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 <jffs2_do_new_inode+0x34> <== 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 <jffs2_do_new_inode+0x2b> <== NOT EXECUTED
return -ENOMEM;
109740: b8 f4 ff ff ff mov $0xfffffff4,%eax <== NOT EXECUTED
109745: e9 78 ff ff ff jmp 1096c2 <jffs2_do_new_inode+0xe2> <== NOT EXECUTED
10974a: 90 nop
10974b: 90 nop
10974c: 90 nop
10974d: 90 nop
10974e: 90 nop
10974f: 90 nop
00109210 <jffs2_do_read_inode>:
/* 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 <jffs2_get_ino_cache>
109234: 89 46 14 mov %eax,0x14(%esi)
if (f->inocache) {
109237: 85 c0 test %eax,%eax
109239: 74 39 je 109274 <jffs2_do_read_inode+0x64>
/* 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 <jffs2_do_read_inode+0x1d1> <== 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 <jffs2_printk> <== 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 <jffs2_do_read_inode+0x1b1> <== NEVER TAKEN
/* Special case - no root inode on medium */
f->inocache = jffs2_alloc_inode_cache();
10927d: e8 6e c0 ff ff call 1052f0 <jffs2_alloc_inode_cache>
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 <jffs2_do_read_inode+0x190> <== 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 <jffs2_do_read_inode+0x180> <== NEVER TAKEN
10929e: a8 02 test $0x2,%al
1092a0: 0f 85 ca 00 00 00 jne 109370 <jffs2_do_read_inode+0x160> <== 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 <jffs2_do_read_inode+0xa1>
1092c0: 01 d0 add %edx,%eax
1092c2: f6 45 e4 04 testb $0x4,-0x1c(%ebp)
1092c6: 0f 85 84 00 00 00 jne 109350 <jffs2_do_read_inode+0x140> <== NEVER TAKEN
1092cc: f6 45 e4 02 testb $0x2,-0x1c(%ebp)
1092d0: 75 6e jne 109340 <jffs2_do_read_inode+0x130> <== NEVER TAKEN
1092d2: f6 45 e4 01 testb $0x1,-0x1c(%ebp)
1092d6: 75 58 jne 109330 <jffs2_do_read_inode+0x120> <== 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 <jffs2_add_ino_cache>
}
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 <jffs2_do_read_inode+0x1b1> <== 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 <jffs2_do_read_inode_internal>
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 <jffs2_do_read_inode+0xf9>
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 <jffs2_do_read_inode+0xc8> <== 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 <jffs2_do_read_inode+0xc8> <== NOT EXECUTED
10934e: eb e0 jmp 109330 <jffs2_do_read_inode+0x120> <== 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 <jffs2_do_read_inode+0xc2> <== NOT EXECUTED
109363: eb db jmp 109340 <jffs2_do_read_inode+0x130> <== 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 <jffs2_do_read_inode+0x96> <== 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 <jffs2_do_read_inode+0x8e> <== 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 <jffs2_printk> <== 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 <jffs2_printk> <== NOT EXECUTED
return -ENOENT;
1093da: b8 fe ff ff ff mov $0xfffffffe,%eax <== NOT EXECUTED
1093df: eb d8 jmp 1093b9 <jffs2_do_read_inode+0x1a9> <== 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 <jffs2_do_unlink>:
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 <jffs2_do_unlink+0x163> <== 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_do_unlink+0x20>
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 <jffs2_do_unlink+0x47> <== ALWAYS TAKEN
10a487: eb 57 jmp 10a4e0 <jffs2_do_unlink+0x90> <== 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 <jffs2_do_unlink+0x90> <== NEVER TAKEN
if (fd->nhash == nhash &&
10a497: 39 5e 10 cmp %ebx,0x10(%esi)
10a49a: 75 f4 jne 10a490 <jffs2_do_unlink+0x40>
!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 <memcmp>
if (fd->nhash == nhash &&
10a4b2: 85 c0 test %eax,%eax
10a4b4: 75 da jne 10a490 <jffs2_do_unlink+0x40> <== NEVER TAKEN
!memcmp(fd->name, name, namelen) &&
10a4b6: 80 7c 3e 15 00 cmpb $0x0,0x15(%esi,%edi,1)
10a4bb: 75 d3 jne 10a490 <jffs2_do_unlink+0x40> <== 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 <jffs2_mark_node_obsolete>
/* 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 <jffs2_do_unlink+0xbd> <== 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 <jffs2_do_unlink+0xbd> <== 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_do_unlink+0xe0>
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 <jffs2_complete_reservation>
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 <jffs2_do_unlink+0x157> <== 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 <jffs2_do_unlink+0x121> <== 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 <jffs2_do_unlink+0x112> <== 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 <jffs2_mark_node_obsolete> <== NOT EXECUTED
jffs2_free_full_dirent(fd);
10a562: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
10a565: e8 c6 ab ff ff call 105130 <jffs2_free_full_dirent> <== 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 <jffs2_do_unlink+0x151> <== 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 <jffs2_do_unlink+0x100> <== 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 <jffs2_printk> <== NOT EXECUTED
10a59f: eb af jmp 10a550 <jffs2_do_unlink+0x100> <== 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 <jffs2_do_unlink+0xbd>
uint32_t hash = 0;
10a5b3: 31 db xor %ebx,%ebx
10a5b5: e9 c3 fe ff ff jmp 10a47d <jffs2_do_unlink+0x2d> <== NOT EXECUTED
10a5ba: 90 nop
10a5bb: 90 nop
10a5bc: 90 nop
10a5bd: 90 nop
10a5be: 90 nop
10a5bf: 90 nop
0010bd30 <jffs2_erase_pending_blocks>:
{
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 <jffs2_erase_pending_blocks+0x1f0>
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 <malloc>
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 <jffs2_erase_pending_blocks+0x2db> <== 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 <jffs2_erase_pending_blocks+0x187> <== 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 <jffs2_erase_pending_blocks+0xb3>
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 <jffs2_flash_read>
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 <jffs2_erase_pending_blocks+0x4bd> <== 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 <jffs2_erase_pending_blocks+0x4e3> <== NEVER TAKEN
10be17: 31 c0 xor %eax,%eax
10be19: eb 0c jmp 10be27 <jffs2_erase_pending_blocks+0xf7>
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<readlen; i += sizeof(unsigned long)) {
10be20: 83 c0 04 add $0x4,%eax
10be23: 39 c3 cmp %eax,%ebx
10be25: 76 79 jbe 10bea0 <jffs2_erase_pending_blocks+0x170>
/* 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 <jffs2_erase_pending_blocks+0xf0> <== 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 <jffs2_printk> <== 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 <free> <== 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 <jffs2_erase_pending_blocks+0x30>
}
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 <jffs2_erase_pending_blocks+0xa4>
10beb5: 89 d7 mov %edx,%edi
kfree(ebuf);
10beb7: 89 34 24 mov %esi,(%esp)
10beba: e8 71 22 00 00 call 10e130 <free>
/* 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 <jffs2_erase_pending_blocks+0x3c5> <== 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 <jffs2_erase_pending_blocks+0x158>
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 <jffs2_erase_pending_blocks+0x164>
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 <jffs2_free_jeb_node_refs>
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 <jffs2_flash_erase>
if (!ret) {
10bfa2: 85 c0 test %eax,%eax
10bfa4: 0f 84 f6 00 00 00 je 10c0a0 <jffs2_erase_pending_blocks+0x370> <== 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 <jffs2_erase_pending_blocks+0x330> <== 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 <jffs2_erase_pending_blocks+0x3b0> <== 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 <jffs2_printk> <== 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 <jffs2_erase_pending_blocks+0x30> <== 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 <jffs2_printk> <== 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 <jffs2_erase_pending_blocks+0x2fd> <== 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 <jffs2_erase_pending_blocks+0x158> <== 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 <jffs2_erase_pending_blocks+0x30> <== 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 <jffs2_erase_pending_blocks+0x30> <== 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 <jffs2_erase_pending_blocks+0x30> <== 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 <jffs2_printk> <== NOT EXECUTED
10c0f0: e9 e1 fe ff ff jmp 10bfd6 <jffs2_erase_pending_blocks+0x2a6> <== 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 <jffs2_prealloc_raw_node_refs>
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 <cyg_crc32_accumulate>
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 <jffs2_flash_direct_writev>
if (ret || retlen != sizeof(marker)) {
10c173: 85 c0 test %eax,%eax
10c175: 0f 85 c5 00 00 00 jne 10c240 <jffs2_erase_pending_blocks+0x510> <== NEVER TAKEN
10c17b: 8b 45 d0 mov -0x30(%ebp),%eax
10c17e: 83 f8 0c cmp $0xc,%eax
10c181: 74 28 je 10c1ab <jffs2_erase_pending_blocks+0x47b> <== 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 <jffs2_printk> <== NOT EXECUTED
goto filebad;
10c1a6: e9 aa fc ff ff jmp 10be55 <jffs2_erase_pending_blocks+0x125> <== 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 <jffs2_erase_pending_blocks+0x1a9> <== 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 <jffs2_link_node_ref>
10c1e8: e9 ec fc ff ff jmp 10bed9 <jffs2_erase_pending_blocks+0x1a9>
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 <jffs2_printk> <== NOT EXECUTED
kfree(ebuf);
10c206: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10c209: e8 22 1f 00 00 call 10e130 <free> <== NOT EXECUTED
return ret;
10c20e: e9 42 fc ff ff jmp 10be55 <jffs2_erase_pending_blocks+0x125> <== 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 <jffs2_printk> <== NOT EXECUTED
kfree(ebuf);
10c233: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10c236: e8 f5 1e 00 00 call 10e130 <free> <== NOT EXECUTED
return ret;
10c23b: e9 15 fc ff ff jmp 10be55 <jffs2_erase_pending_blocks+0x125> <== 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 <jffs2_printk> <== NOT EXECUTED
10c25a: e9 f6 fb ff ff jmp 10be55 <jffs2_erase_pending_blocks+0x125> <== NOT EXECUTED
10c25f: 90 nop
0010c2c0 <jffs2_flash_direct_writev>:
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 <jffs2_flash_direct_writev+0x2fa> <== NEVER TAKEN
10c2f7: 31 f6 xor %esi,%esi
10c2f9: eb 5f jmp 10c35a <jffs2_flash_direct_writev+0x9a>
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 <jffs2_flash_direct_writev+0xa3>
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 <jffs2_flash_direct_writev+0x120> <== NEVER TAKEN
10c338: 39 5c f7 04 cmp %ebx,0x4(%edi,%esi,8)
10c33c: 0f 85 9e 00 00 00 jne 10c3e0 <jffs2_flash_direct_writev+0x120> <== 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 <jffs2_flash_direct_writev+0x120>
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 <jffs2_flash_direct_writev+0x40>
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 <jffs2_flash_direct_writev+0x160> <== NEVER TAKEN
10c36f: 81 fb 00 01 00 00 cmp $0x100,%ebx
10c375: 0f 87 a5 00 00 00 ja 10c420 <jffs2_flash_direct_writev+0x160>
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 <jffs2_flash_direct_writev+0x140> <== 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 <jffs2_flash_direct_writev+0x6a> <== 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 <jffs2_flash_direct_writev+0x78> <== 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 <jffs2_flash_direct_writev+0x132> <== 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 <jffs2_flash_direct_writev+0x142>
10c413: e9 71 ff ff ff jmp 10c389 <jffs2_flash_direct_writev+0xc9>
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 <jffs2_flash_direct_writev+0x2d7> <== 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 <jffs2_flash_direct_writev+0x184>
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 <jffs2_flash_direct_writev+0x180> <== 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 <malloc>
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 <jffs2_flash_direct_writev+0x301> <== 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 <jffs2_flash_direct_writev+0x1e8>
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 <jffs2_flash_direct_writev+0x230> <== 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 <jffs2_flash_direct_writev+0x1d0> <== NEVER TAKEN
10c4b9: f6 c2 01 test $0x1,%dl
10c4bc: 0f 85 be 00 00 00 jne 10c580 <jffs2_flash_direct_writev+0x2c0> <== NEVER TAKEN
10c4c2: f7 c7 02 00 00 00 test $0x2,%edi
10c4c8: 0f 85 92 00 00 00 jne 10c560 <jffs2_flash_direct_writev+0x2a0> <== NEVER TAKEN
10c4ce: f7 c7 04 00 00 00 test $0x4,%edi
10c4d4: 74 ba je 10c490 <jffs2_flash_direct_writev+0x1d0>
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 <jffs2_flash_direct_writev+0x1d0>
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 <jffs2_flash_direct_writev+0x290> <== 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 <free>
goto writev_out;
10c541: 8b 8d e0 fe ff ff mov -0x120(%ebp),%ecx
10c547: e9 94 fe ff ff jmp 10c3e0 <jffs2_flash_direct_writev+0x120>
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 <jffs2_flash_direct_writev+0x240> <== 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 <jffs2_flash_direct_writev+0x20e> <== 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 <jffs2_flash_direct_writev+0x202> <== 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 <malloc> <== 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 <jffs2_flash_direct_writev+0x301> <== 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 <jffs2_flash_direct_writev+0x246> <== NOT EXECUTED
for (i = 0; i < count; i++) {
10c5ba: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
10c5bc: e9 1f fe ff ff jmp 10c3e0 <jffs2_flash_direct_writev+0x120> <== NOT EXECUTED
ret = -ENOMEM;
10c5c1: b9 f4 ff ff ff mov $0xfffffff4,%ecx <== NOT EXECUTED
10c5c6: e9 15 fe ff ff jmp 10c3e0 <jffs2_flash_direct_writev+0x120> <== NOT EXECUTED
10c5cb: 90 nop
10c5cc: 90 nop
10c5cd: 90 nop
10c5ce: 90 nop
10c5cf: 90 nop
00105c80 <jffs2_free_ino_caches>:
{
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 <jffs2_free_ino_caches+0x5f> <== 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 <jffs2_free_ino_caches+0x4d>
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 <jffs2_free_inode_cache>
while (this) {
105cbd: 85 ff test %edi,%edi
105cbf: 75 ef jne 105cb0 <jffs2_free_ino_caches+0x30> <== 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 <jffs2_free_ino_caches+0x20>
}
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_free_jeb_node_refs>:
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 <jffs2_free_jeb_node_refs+0xb3>
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 <jffs2_free_jeb_node_refs+0x9e> <== 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 <jffs2_free_jeb_node_refs+0x93>
10bc35: 8b 07 mov (%edi),%eax
10bc37: 85 c0 test %eax,%eax
10bc39: 74 58 je 10bc93 <jffs2_free_jeb_node_refs+0x93> <== 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 <jffs2_free_jeb_node_refs+0x6f> <== 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 <jffs2_free_jeb_node_refs+0xd0> <== 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 <jffs2_free_jeb_node_refs+0x5b> <== 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 <jffs2_free_jeb_node_refs+0x55> <== 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 <jffs2_free_jeb_node_refs+0x110> <== 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 <jffs2_free_jeb_node_refs+0xf0> <== 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_jeb_node_refs+0x30>
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 <jffs2_free_refblock>
while (ref) {
10bcab: 85 ff test %edi,%edi
10bcad: 0f 85 64 ff ff ff jne 10bc17 <jffs2_free_jeb_node_refs+0x17>
}
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 <jffs2_free_jeb_node_refs+0x80> <== NOT EXECUTED
if (!(*prev)->next_in_ino) {
10bcdc: 8b 03 mov (%ebx),%eax <== NOT EXECUTED
10bcde: e9 72 ff ff ff jmp 10bc55 <jffs2_free_jeb_node_refs+0x55> <== 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 <jffs2_free_jeb_node_refs+0x93> <== 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 <jffs2_del_ino_cache> <== NOT EXECUTED
while (ref) {
10bd09: eb 8b jmp 10bc96 <jffs2_free_jeb_node_refs+0x96> <== 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 <jffs2_printk> <== NOT EXECUTED
while (ref) {
10bd28: e9 69 ff ff ff jmp 10bc96 <jffs2_free_jeb_node_refs+0x96> <== NOT EXECUTED
10bd2d: 90 nop
10bd2e: 90 nop
10bd2f: 90 nop
00105cf0 <jffs2_free_raw_node_refs>:
{
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; i<c->nr_blocks; i++) {
105cfc: 8b 46 50 mov 0x50(%esi),%eax
105cff: 85 c0 test %eax,%eax
105d01: 74 6d je 105d70 <jffs2_free_raw_node_refs+0x80> <== NEVER TAKEN
this = c->blocks[i].first_node;
105d03: 8b 56 54 mov 0x54(%esi),%edx
for (i=0; i<c->nr_blocks; i++) {
105d06: 31 ff xor %edi,%edi
105d08: eb 28 jmp 105d32 <jffs2_free_raw_node_refs+0x42>
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 <jffs2_free_refblock> <== 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; i<c->nr_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; i<c->nr_blocks; i++) {
105d30: 76 3e jbe 105d70 <jffs2_free_raw_node_refs+0x80>
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 <jffs2_free_raw_node_refs+0x2e> <== 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 <jffs2_free_raw_node_refs+0x20> <== 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 <jffs2_free_refblock>
while (this) {
105d5f: 8b 55 e4 mov -0x1c(%ebp),%edx
105d62: 85 d2 test %edx,%edx
105d64: 74 12 je 105d78 <jffs2_free_raw_node_refs+0x88>
105d66: 89 d0 mov %edx,%eax
105d68: eb db jmp 105d45 <jffs2_free_raw_node_refs+0x55>
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 <jffs2_free_raw_node_refs+0x2e>
00103c50 <jffs2_garbage_collect_pass>:
{
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 <jffs2_garbage_collect_pass+0x173> <== 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 <jffs2_garbage_collect_pass+0x83> <== 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 <jffs2_garbage_collect_pass+0x7b> <== 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 <jffs2_garbage_collect_pass+0x74> <== 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 <jffs2_garbage_collect_pass+0xd0> <== 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 <jffs2_garbage_collect_pass+0x60> <== 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 <jffs2_garbage_collect_pass+0x4b> <== 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 <jffs2_printk> <== 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 <jffs2_garbage_collect_pass+0x18> <== NOT EXECUTED
switch(ic->state) {
103d36: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED
103d39: 0f 84 dd 12 00 00 je 10501c <jffs2_garbage_collect_pass+0x13cc> <== NOT EXECUTED
103d3f: 77 4f ja 103d90 <jffs2_garbage_collect_pass+0x140> <== NOT EXECUTED
103d41: 85 c0 test %eax,%eax <== NOT EXECUTED
103d43: 0f 85 d3 12 00 00 jne 10501c <jffs2_garbage_collect_pass+0x13cc> <== 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 <jffs2_do_crccheck_inode> <== 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 <jffs2_garbage_collect_pass+0x15e> <== 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 <jffs2_set_inocache_state> <== 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 <jffs2_garbage_collect_pass+0x1404> <== 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 <jffs2_printk> <== NOT EXECUTED
103dc1: eb a1 jmp 103d64 <jffs2_garbage_collect_pass+0x114> <== 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 <jffs2_garbage_collect_pass+0x1fa> <== 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 <jffs2_erase_pending_blocks> <== NOT EXECUTED
103de7: 85 c0 test %eax,%eax
103de9: 0f 85 d8 00 00 00 jne 103ec7 <jffs2_garbage_collect_pass+0x277> <== 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 <jffs2_garbage_collect_pass+0x27e>
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 <jffs2_garbage_collect_pass+0x375> <== 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 <jffs2_garbage_collect_pass+0x1da>
/* 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 <jffs2_garbage_collect_pass+0x20f> <== 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 <jffs2_garbage_collect_pass+0x3cf>
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 <jffs2_garbage_collect_pass+0x1d2>
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 <jffs2_garbage_collect_pass+0x20f> <== NEVER TAKEN
if (ref->flash_offset == REF_EMPTY_NODE)
103e45: 8b 47 04 mov 0x4(%edi),%eax
103e48: eb db jmp 103e25 <jffs2_garbage_collect_pass+0x1d5>
!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 <jffs2_garbage_collect_pass+0x183>
103e5d: eb 90 jmp 103def <jffs2_garbage_collect_pass+0x19f>
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 <jffs2_printk> <== 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 <jffs2_printk> <== 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 <jffs2_garbage_collect_pass+0xb8>
/* 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 <jffs2_garbage_collect_pass+0x2e3>
} 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 <jffs2_garbage_collect_pass+0x312> <== 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 <jffs2_garbage_collect_pass+0x312>
} 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 <jffs2_garbage_collect_pass+0x312> <== 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 <jffs2_garbage_collect_pass+0x312> <== 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 <jffs2_garbage_collect_pass+0x312> <== 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 <jffs2_garbage_collect_pass+0x312> <== 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 <jffs2_garbage_collect_pass+0x361> <== 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 <jffs2_garbage_collect_pass+0x2f5> <== 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 <jffs2_garbage_collect_pass+0x138e> <== NOT EXECUTED
} else if (n < 50 && !list_empty(&c->erasable_list)) {
103f45: 83 fa 31 cmp $0x31,%edx
103f48: 7e a9 jle 103ef3 <jffs2_garbage_collect_pass+0x2a3> <== 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 <jffs2_garbage_collect_pass+0x2ab> <== 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 <jffs2_garbage_collect_pass+0x2b3> <== 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 <jffs2_garbage_collect_pass+0x312> <== 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 <jffs2_garbage_collect_pass+0x2c1> <== 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 <jffs2_garbage_collect_pass+0x1395> <== 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 <jffs2_garbage_collect_pass+0x1b3> <== 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 <jffs2_garbage_collect_pass+0x1b3> <== 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 <jffs2_garbage_collect_pass+0xb8>
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 <jffs2_garbage_collect_pass+0xb8> <== 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 <jffs2_garbage_collect_pass+0xb8> <== 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 <jffs2_garbage_collect_pass+0xb8> <== 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 <jffs2_garbage_collect_pass+0x1428> <== 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 <jffs2_garbage_collect_pass+0x3f1> <== 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 <jffs2_garbage_collect_pass+0x147e> <== NEVER TAKEN
104059: 0f 87 91 00 00 00 ja 1040f0 <jffs2_garbage_collect_pass+0x4a0> <== NEVER TAKEN
10405f: 83 fa 01 cmp $0x1,%edx
104062: 0f 86 66 10 00 00 jbe 1050ce <jffs2_garbage_collect_pass+0x147e> <== 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 <jffs2_garbage_collect_pass+0x42b>
if (ref_flags(raw) == REF_PRISTINE)
104072: 83 f8 02 cmp $0x2,%eax
104075: 0f 84 18 10 00 00 je 105093 <jffs2_garbage_collect_pass+0x1443> <== 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 <jffs2_gc_fetch_inode>
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 <jffs2_garbage_collect_pass+0x1387> <== NEVER TAKEN
ret = 0;
1040a8: 31 f6 xor %esi,%esi
if (!f) {
1040aa: 85 c0 test %eax,%eax
1040ac: 74 2e je 1040dc <jffs2_garbage_collect_pass+0x48c> <== 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 <jffs2_garbage_collect_pass+0x4dd> <== 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 <jffs2_gc_release_inode>
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 <jffs2_garbage_collect_pass+0x4b5> <== 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 <jffs2_garbage_collect_pass+0xb8>
1040ea: e9 de fe ff ff jmp 103fcd <jffs2_garbage_collect_pass+0x37d>
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 <jffs2_garbage_collect_pass+0xb8> <== 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 <jffs2_garbage_collect_pass+0x42b> <== 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 <jffs2_garbage_collect_pass+0x48c> <== 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 <jffs2_printk> <== NOT EXECUTED
ret = -ENOSPC;
10412b: eb af jmp 1040dc <jffs2_garbage_collect_pass+0x48c> <== 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 <jffs2_garbage_collect_pass+0x46c> <== 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 <jffs2_garbage_collect_pass+0x4fc>
104144: 3b 38 cmp (%eax),%edi
104146: 0f 84 9c 04 00 00 je 1045e8 <jffs2_garbage_collect_pass+0x998> <== 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 <jffs2_garbage_collect_pass+0x576>
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 <jffs2_garbage_collect_pass+0x540>
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 <jffs2_garbage_collect_pass+0x5cc> <== 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 <jffs2_garbage_collect_pass+0x530> <== NEVER TAKEN
104197: 3b 39 cmp (%ecx),%edi
104199: 75 e5 jne 104180 <jffs2_garbage_collect_pass+0x530>
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 <jffs2_garbage_collect_pass+0x566> <== 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 <jffs2_garbage_collect_pass+0xb7d> <== 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 <jffs2_garbage_collect_pass+0x530> <== 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 <jffs2_garbage_collect_pass+0x588>
if (fd->raw == raw)
1041cd: 3b 3e cmp (%esi),%edi
1041cf: 0f 84 68 02 00 00 je 10443d <jffs2_garbage_collect_pass+0x7ed>
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 <jffs2_garbage_collect_pass+0x57d> <== 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 <jffs2_printk> <== 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 <jffs2_garbage_collect_pass+0x84a> <== 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 <jffs2_printk> <== NOT EXECUTED
104217: e9 a0 fe ff ff jmp 1040bc <jffs2_garbage_collect_pass+0x46c> <== 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 <jffs2_garbage_collect_pass+0x576> <== 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 <jffs2_garbage_collect_pass+0x135d> <== 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 <jffs2_garbage_collect_pass+0xf17> <== 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 <jffs2_garbage_collect_pass+0xe39> <== 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 <jffs2_flash_read> <== 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 <jffs2_garbage_collect_pass+0xeca> <== NOT EXECUTED
1042b1: 85 c0 test %eax,%eax <== NOT EXECUTED
1042b3: 0f 85 61 08 00 00 jne 104b1a <jffs2_garbage_collect_pass+0xeca> <== 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 <jffs2_garbage_collect_pass+0xee3> <== 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 <jffs2_garbage_collect_pass+0xc2d> <== 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 <cyg_crc32_accumulate> <== 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 <jffs2_garbage_collect_pass+0xe9a> <== 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 <jffs2_garbage_collect_pass+0xdec> <== 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 <jffs2_garbage_collect_pass+0xcf6> <== 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 <cyg_crc32_accumulate> <== 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 <jffs2_reserve_space_gc> <== 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 <jffs2_garbage_collect_pass+0xcd9> <== 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 <jffs2_write_dnode> <== 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 <jffs2_garbage_collect_pass+0xcc2> <== 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 <jffs2_garbage_collect_pass+0xc7c> <== 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 <jffs2_lookup_node_frag> <== 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 <jffs2_garbage_collect_pass+0x7c6> <== 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 <jffs2_garbage_collect_pass+0xcfe> <== 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 <jffs2_garbage_collect_pass+0xcfe> <== NOT EXECUTED
break;
if (frag->node == fn) {
10442d: 39 58 10 cmp %ebx,0x10(%eax) <== NOT EXECUTED
104430: 75 dc jne 10440e <jffs2_garbage_collect_pass+0x7be> <== 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 <jffs2_garbage_collect_pass+0x7be> <== 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 <jffs2_garbage_collect_pass+0x802> <== NEVER TAKEN
104446: eb 76 jmp 1044be <jffs2_garbage_collect_pass+0x86e>
if ((*fdp) == fd) {
104448: 39 c6 cmp %eax,%esi <== NOT EXECUTED
10444a: 74 29 je 104475 <jffs2_garbage_collect_pass+0x825> <== 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 <jffs2_garbage_collect_pass+0x7f8> <== 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 <jffs2_printk> <== NOT EXECUTED
104473: eb 05 jmp 10447a <jffs2_garbage_collect_pass+0x82a> <== 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 <jffs2_mark_node_obsolete> <== 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 <jffs2_free_full_dirent> <== NOT EXECUTED
return 0;
104495: e9 22 fc ff ff jmp 1040bc <jffs2_garbage_collect_pass+0x46c> <== 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 <strlen>
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 <cyg_crc32_accumulate>
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 <jffs2_garbage_collect_pass+0xd33> <== 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 <cyg_crc32_accumulate>
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 <cyg_crc32_accumulate>
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 <jffs2_reserve_space_gc>
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 <jffs2_garbage_collect_pass+0xdcc> <== 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 <jffs2_write_dirent>
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 <jffs2_garbage_collect_pass+0xdb5> <== 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 <jffs2_add_fd_to_list> <== NOT EXECUTED
ret = jffs2_garbage_collect_dirent(c, jeb, f, fd);
1045e3: e9 d4 fa ff ff jmp 1040bc <jffs2_garbage_collect_pass+0x46c>
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 <jffs2_garbage_collect_pass+0xc5c> <== 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 <jffs2_garbage_collect_pass+0xbb5> <== 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 <jffs2_reserve_space_gc>
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 <jffs2_garbage_collect_pass+0xb99> <== 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 <jffs2_garbage_collect_pass+0xb8b> <== 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 <cyg_crc32_accumulate>
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 <cyg_crc32_accumulate>
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 <cyg_crc32_accumulate>
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 <jffs2_write_dnode>
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 <jffs2_garbage_collect_pass+0xb69> <== 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 <jffs2_mark_node_obsolete> <== 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 <jffs2_free_full_dnode>
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 <jffs2_garbage_collect_pass+0x46c> <== 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 <free> <== NOT EXECUTED
1047b4: e9 03 f9 ff ff jmp 1040bc <jffs2_garbage_collect_pass+0x46c> <== 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 <jffs2_printk> <== NOT EXECUTED
goto out;
1047cb: eb c9 jmp 104796 <jffs2_garbage_collect_pass+0xb46> <== 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 <jffs2_garbage_collect_pass+0x5d8>
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 <jffs2_garbage_collect_pass+0xa21> <== 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 <jffs2_printk> <== NOT EXECUTED
goto out;
104803: eb 91 jmp 104796 <jffs2_garbage_collect_pass+0xb46> <== 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 <malloc> <== 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 <jffs2_garbage_collect_pass+0xc66> <== 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 <jffs2_read_dnode> <== 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 <jffs2_garbage_collect_pass+0x9c9> <== 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 <jffs2_printk> <== 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 <free> <== NOT EXECUTED
return ret;
104878: e9 3f f8 ff ff jmp 1040bc <jffs2_garbage_collect_pass+0x46c> <== 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 <jffs2_printk> <== NOT EXECUTED
return -EIO;
1048ac: be fb ff ff ff mov $0xfffffffb,%esi <== NOT EXECUTED
1048b1: e9 06 f8 ff ff jmp 1040bc <jffs2_garbage_collect_pass+0x46c> <== 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 <jffs2_printk> <== NOT EXECUTED
return -ENOMEM;
1048c7: e9 f0 f7 ff ff jmp 1040bc <jffs2_garbage_collect_pass+0x46c> <== 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 <jffs2_add_full_dnode_to_inode> <== 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 <jffs2_garbage_collect_pass+0x46c> <== 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 <jffs2_mark_node_obsolete> <== 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 <jffs2_free_full_dnode> <== 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 <jffs2_garbage_collect_pass+0x46c> <== 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 <jffs2_printk> <== NOT EXECUTED
return PTR_ERR(new_fn);
104924: e9 93 f7 ff ff jmp 1040bc <jffs2_garbage_collect_pass+0x46c> <== 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 <jffs2_printk> <== NOT EXECUTED
return ret;
104941: e9 76 f7 ff ff jmp 1040bc <jffs2_garbage_collect_pass+0x46c> <== 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 <jffs2_garbage_collect_pass+0x6d2> <== 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 <jffs2_garbage_collect_pass+0xd7d> <== 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 <jffs2_garbage_collect_pass+0xd45> <== 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 <jffs2_mark_node_obsolete> <== NOT EXECUTED
jffs2_free_full_dnode(fn);
104976: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
104979: e8 e2 07 00 00 call 105160 <jffs2_free_full_dnode> <== NOT EXECUTED
return 0;
10497e: e9 39 f7 ff ff jmp 1040bc <jffs2_garbage_collect_pass+0x46c> <== 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 <jffs2_garbage_collect_pass+0x8d3> <== NEVER TAKEN
10498c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
104990: e9 90 fb ff ff jmp 104525 <jffs2_garbage_collect_pass+0x8d5>
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 <jffs2_printk> <== 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 <jffs2_printk> <== 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 <jffs2_printk> <== NOT EXECUTED
return PTR_ERR(new_fd);
104a17: e9 a0 f6 ff ff jmp 1040bc <jffs2_garbage_collect_pass+0x46c> <== 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 <jffs2_printk> <== NOT EXECUTED
return ret;
104a37: e9 80 f6 ff ff jmp 1040bc <jffs2_garbage_collect_pass+0x46c> <== 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 <jffs2_printk> <== 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 <jffs2_printk> <== 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 <cyg_crc32_accumulate> <== 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 <jffs2_garbage_collect_pass+0x6b4> <== 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 <jffs2_printk> <== 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 <jffs2_garbage_collect_pass+0xe0f> <== 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 <jffs2_printk> <== NOT EXECUTED
goto fill;
104b2e: e9 56 ff ff ff jmp 104a89 <jffs2_garbage_collect_pass+0xe39> <== 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 <jffs2_printk> <== NOT EXECUTED
return -EIO;
104b62: e9 45 fd ff ff jmp 1048ac <jffs2_garbage_collect_pass+0xc5c> <== 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 <jffs2_garbage_collect_pass+0x1349>
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 <jffs2_lookup_node_frag>
/* 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 <jffs2_garbage_collect_pass+0x1325> <== 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 <jffs2_garbage_collect_pass+0xfce>
104bd9: 8b 48 18 mov 0x18(%eax),%ecx
104bdc: 39 4d 84 cmp %ecx,-0x7c(%ebp)
104bdf: 77 3d ja 104c1e <jffs2_garbage_collect_pass+0xfce>
/* 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 <jffs2_garbage_collect_pass+0x131e> <== 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 <jffs2_garbage_collect_pass+0xfce> <== NEVER TAKEN
104bf1: 8b 00 mov (%eax),%eax
104bf3: 85 c0 test %eax,%eax
104bf5: 74 27 je 104c1e <jffs2_garbage_collect_pass+0xfce> <== 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 <jffs2_garbage_collect_pass+0xfcb> <== 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 <jffs2_garbage_collect_pass+0xfce> <== 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 <jffs2_lookup_node_frag>
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 <jffs2_garbage_collect_pass+0x103d>
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 <jffs2_garbage_collect_pass+0x103d>
/* 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 <jffs2_garbage_collect_pass+0x1316>
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 <jffs2_garbage_collect_pass+0x103d> <== NEVER TAKEN
104c60: 8b 00 mov (%eax),%eax
104c62: 85 c0 test %eax,%eax
104c64: 74 27 je 104c8d <jffs2_garbage_collect_pass+0x103d> <== 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 <jffs2_garbage_collect_pass+0x103a> <== 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 <jffs2_garbage_collect_pass+0x103d> <== 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 <jffs2_garbage_collect_pass+0x12f2> <== 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 <jffs2_garbage_collect_pass+0x12ce> <== 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 <jffs2_gc_fetch_page>
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 <jffs2_garbage_collect_pass+0x12b3> <== 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 <jffs2_garbage_collect_pass+0x1297>
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 <jffs2_reserve_space_gc>
&alloclen, JFFS2_SUMMARY_INODE_SIZE);
if (ret) {
104d07: 85 c0 test %eax,%eax
104d09: 0f 85 9b 01 00 00 jne 104eaa <jffs2_garbage_collect_pass+0x125a> <== 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 <jffs2_garbage_collect_pass+0x10d0>
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 <jffs2_compress>
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 <cyg_crc32_accumulate>
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 <cyg_crc32_accumulate>
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 <cyg_crc32_accumulate>
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_write_dnode>
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 <jffs2_garbage_collect_pass+0x129d> <== 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 <jffs2_add_full_dnode_to_inode>
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 <jffs2_garbage_collect_pass+0x108c> <== 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 <jffs2_mark_node_obsolete> <== 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 <jffs2_free_full_dnode> <== 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 <jffs2_garbage_collect_pass+0x108c> <== 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 <jffs2_printk> <== 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 <jffs2_gc_release_page>
return ret;
104ee2: e9 d5 f1 ff ff jmp 1040bc <jffs2_garbage_collect_pass+0x46c>
104ee7: 89 f3 mov %esi,%ebx
104ee9: 89 c6 mov %eax,%esi
104eeb: eb d9 jmp 104ec6 <jffs2_garbage_collect_pass+0x1276>
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 <jffs2_printk> <== NOT EXECUTED
break;
104f01: eb c3 jmp 104ec6 <jffs2_garbage_collect_pass+0x1276> <== 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 <jffs2_printk> <== NOT EXECUTED
return PTR_ERR(pg_ptr);
104f19: e9 9e f1 ff ff jmp 1040bc <jffs2_garbage_collect_pass+0x46c> <== 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 <jffs2_garbage_collect_pass+0xfe9>
104f6e: 89 cf mov %ecx,%edi <== NOT EXECUTED
104f70: e9 58 fc ff ff jmp 104bcd <jffs2_garbage_collect_pass+0xf7d> <== 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 <jffs2_garbage_collect_pass+0x1058>
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 <jffs2_garbage_collect_pristine> <== 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 <jffs2_garbage_collect_pass+0x14b9> <== 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 <jffs2_garbage_collect_pass+0x46c> <== 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 <jffs2_garbage_collect_pass+0x48c> <== NOT EXECUTED
104fde: 89 f0 mov %esi,%eax <== NOT EXECUTED
104fe0: e9 7d ef ff ff jmp 103f62 <jffs2_garbage_collect_pass+0x312> <== 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 <jffs2_printk> <== 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 <jffs2_printk> <== 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 <jffs2_garbage_collect_pass+0x146d> <== 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 <jffs2_mark_node_obsolete> <== NOT EXECUTED
10508e: e9 49 f0 ff ff jmp 1040dc <jffs2_garbage_collect_pass+0x48c> <== 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 <jffs2_garbage_collect_pristine>
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 <jffs2_garbage_collect_pass+0x47b>
1050b8: e9 be ef ff ff jmp 10407b <jffs2_garbage_collect_pass+0x42b> <== 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 <jffs2_garbage_collect_pristine> <== NOT EXECUTED
1050c9: e9 0e f0 ff ff jmp 1040dc <jffs2_garbage_collect_pass+0x48c> <== 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 <jffs2_printk> <== 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 <jffs2_garbage_collect_pass+0x5e7> <== NOT EXECUTED
105114: e9 a3 ef ff ff jmp 1040bc <jffs2_garbage_collect_pass+0x46c> <== NOT EXECUTED
105119: 90 nop
10511a: 90 nop
10511b: 90 nop
10511c: 90 nop
10511d: 90 nop
10511e: 90 nop
10511f: 90 nop
001036b0 <jffs2_gc_fetch_inode>:
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 <jffs2_gc_fetch_inode+0x40> <== 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 <jffs2_gc_fetch_inode+0x27> <== NOT EXECUTED
1036cd: eb 41 jmp 103710 <jffs2_gc_fetch_inode+0x60> <== 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 <jffs2_gc_fetch_inode+0x60> <== NOT EXECUTED
if (inode->i_ino == ino) {
1036d7: 3b 10 cmp (%eax),%edx <== NOT EXECUTED
1036d9: 75 f5 jne 1036d0 <jffs2_gc_fetch_inode+0x20> <== 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 <jffs2_iget>
if (IS_ERR(inode))
1036fc: 3d 18 fc ff ff cmp $0xfffffc18,%eax
103701: 76 db jbe 1036de <jffs2_gc_fetch_inode+0x2e> <== 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 <jffs2_get_ino_cache> <== 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 <jffs2_gc_fetch_page>:
{
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 <jffs2_read_inode_range>
if (ret)
102bda: 85 c0 test %eax,%eax
102bdc: 74 02 je 102be0 <jffs2_gc_fetch_page+0x40> <== 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 <jffs2_get_ino_cache>:
{
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 <jffs2_get_ino_cache+0x37>
105b71: eb 1b jmp 105b8e <jffs2_get_ino_cache+0x3e>
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 <jffs2_get_ino_cache+0x3e> <== NOT EXECUTED
105b87: 39 48 0c cmp %ecx,0xc(%eax)
105b8a: 72 f4 jb 105b80 <jffs2_get_ino_cache+0x30> <== NEVER TAKEN
if (ret && ret->ino != ino)
105b8c: 75 12 jne 105ba0 <jffs2_get_ino_cache+0x50> <== 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 <jffs2_iget>:
{
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 <jffs2_iget+0x27>
102fd9: eb 25 jmp 103000 <jffs2_iget+0x40>
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 <jffs2_iget+0x40>
if (inode->i_ino == ino) {
102fe7: 3b 33 cmp (%ebx),%esi
102fe9: 75 f5 jne 102fe0 <jffs2_iget+0x20>
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 <new_inode>
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 <jffs2_iget+0x1a8> <== 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 <jffs2_iget+0x1c2> <== NEVER TAKEN
10302e: f6 c2 02 test $0x2,%dl
103031: 0f 85 3b 01 00 00 jne 103172 <jffs2_iget+0x1b2> <== 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 <jffs2_iget+0x81>
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 <jffs2_iget+0x170> <== ALWAYS TAKEN
10305e: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
103064: 0f 85 a6 00 00 00 jne 103110 <jffs2_iget+0x150> <== NOT EXECUTED
10306a: 83 e7 01 and $0x1,%edi
10306d: 0f 85 8d 00 00 00 jne 103100 <jffs2_iget+0x140> <== 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 <jffs2_do_read_inode>
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 <jffs2_iget+0x187> <== 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 <jffs2_iget+0xb3> <== 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 <jffs2_iget+0xb3> <== NOT EXECUTED
103121: eb dd jmp 103100 <jffs2_iget+0x140> <== 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 <jffs2_iget+0xaa> <== ALWAYS TAKEN
103145: eb c9 jmp 103110 <jffs2_iget+0x150> <== 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 <jffs2_printk> <== 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 <jffs2_iput> <== NOT EXECUTED
return ERR_PTR(err);
103163: e9 86 fe ff ff jmp 102fee <jffs2_iget+0x2e> <== 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 <jffs2_iget+0x2e> <== 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 <jffs2_iget+0x77> <== 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 <jffs2_iget+0x6e> <== 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 <jffs2_iput>:
{
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 <jffs2_iput+0x55>
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 <jffs2_iput+0x70>
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 <jffs2_iput+0x27> <== 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 <jffs2_iput+0x2e>
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 <jffs2_do_clear_inode>
free(i);
102c43: 89 1c 24 mov %ebx,(%esp)
102c46: e8 e5 b4 00 00 call 10e130 <free>
if (parent && parent != i) {
102c4b: 85 f6 test %esi,%esi
102c4d: 74 13 je 102c62 <jffs2_iput+0x62>
102c4f: 39 f3 cmp %esi,%ebx
102c51: 74 0f je 102c62 <jffs2_iput+0x62> <== NEVER TAKEN
102c53: 89 f3 mov %esi,%ebx
assert(i != NULL);
102c55: 85 db test %ebx,%ebx
102c57: 74 54 je 102cad <jffs2_iput+0xad> <== NEVER TAKEN
i->i_count--;
102c59: ff 4b 04 decl 0x4(%ebx)
if (i->i_count < 0)
102c5c: 78 28 js 102c86 <jffs2_iput+0x86> <== NEVER TAKEN
if (i->i_count)
102c5e: 66 90 xchg %ax,%ax
102c60: 74 ae je 102c10 <jffs2_iput+0x10>
}
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 <icache_evict>
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 <jffs2_kill_fragtree>:
/* 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 <jffs2_kill_fragtree+0x77>
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 <jffs2_kill_fragtree+0x6b> <== NEVER TAKEN
105e29: ff 48 0c decl 0xc(%eax)
105e2c: 75 1d jne 105e4b <jffs2_kill_fragtree+0x6b> <== 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_kill_fragtree+0x63>
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 <jffs2_mark_node_obsolete> <== 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_full_dnode>
}
jffs2_free_node_frag(frag);
105e4b: 89 3c 24 mov %edi,(%esp)
105e4e: e8 8d f4 ff ff call 1052e0 <jffs2_free_node_frag>
rbtree_postorder_for_each_entry_safe(frag, next, root, rb) {
105e53: 85 db test %ebx,%ebx
105e55: 75 b9 jne 105e10 <jffs2_kill_fragtree+0x30>
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 <jffs2_link>:
/***********************************************************************/
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 <jffs2_link+0x28> <== 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 <time>
ret = jffs2_do_link(c, dir_f, f->inocache->ino, type,
10b5da: 8b 4d e4 mov -0x1c(%ebp),%ecx
10b5dd: 89 5c 24 0c mov %ebx,0xc(%esp)
10b5e1: 89 44 24 18 mov %eax,0x18(%esp)
10b5e5: 8b 45 14 mov 0x14(%ebp),%eax
10b5e8: 89 44 24 14 mov %eax,0x14(%esp)
10b5ec: 8b 45 10 mov 0x10(%ebp),%eax
10b5ef: 89 44 24 10 mov %eax,0x10(%esp)
10b5f3: 8b 46 58 mov 0x58(%esi),%eax
10b5f6: 8b 40 0c mov 0xc(%eax),%eax
10b5f9: 89 7c 24 04 mov %edi,0x4(%esp)
10b5fd: 89 0c 24 mov %ecx,(%esp)
10b600: 89 44 24 08 mov %eax,0x8(%esp)
10b604: e8 b7 ef ff ff call 10a5c0 <jffs2_do_link>
if (!ret) {
10b609: 85 c0 test %eax,%eax
10b60b: 75 0e jne 10b61b <jffs2_link+0x7b> <== NEVER TAKEN
mutex_lock(&f->sem);
old_d_inode->i_nlink = ++f->inocache->pino_nlink;
10b60d: 8b 4e 58 mov 0x58(%esi),%ecx
10b610: 8b 51 14 mov 0x14(%ecx),%edx
10b613: 42 inc %edx
10b614: 89 51 14 mov %edx,0x14(%ecx)
10b617: 66 89 56 0c mov %dx,0xc(%esi)
mutex_unlock(&f->sem);
}
return ret;
}
10b61b: 8b 5d f4 mov -0xc(%ebp),%ebx
10b61e: 8b 75 f8 mov -0x8(%ebp),%esi
10b621: 8b 7d fc mov -0x4(%ebp),%edi
10b624: 89 ec mov %ebp,%esp
10b626: 5d pop %ebp
10b627: c3 ret
10b628: 90 nop
10b629: 90 nop
10b62a: 90 nop
10b62b: 90 nop
10b62c: 90 nop
10b62d: 90 nop
10b62e: 90 nop
10b62f: 90 nop
00105e60 <jffs2_link_node_ref>:
struct jffs2_raw_node_ref *jffs2_link_node_ref(struct jffs2_sb_info *c,
struct jffs2_eraseblock *jeb,
uint32_t ofs, uint32_t len,
struct jffs2_inode_cache *ic)
{
105e60: 55 push %ebp
105e61: 89 e5 mov %esp,%ebp
105e63: 57 push %edi
105e64: 56 push %esi
105e65: 53 push %ebx
105e66: 83 ec 3c sub $0x3c,%esp
105e69: 8b 55 0c mov 0xc(%ebp),%edx
105e6c: 8b 4d 08 mov 0x8(%ebp),%ecx
105e6f: 8b 5d 14 mov 0x14(%ebp),%ebx
struct jffs2_raw_node_ref *ref;
BUG_ON(!jeb->allocated_refs);
105e72: 8b 42 24 mov 0x24(%edx),%eax
105e75: 85 c0 test %eax,%eax
105e77: 0f 84 2f 01 00 00 je 105fac <jffs2_link_node_ref+0x14c> <== NEVER TAKEN
jeb->allocated_refs--;
105e7d: 48 dec %eax
105e7e: 89 42 24 mov %eax,0x24(%edx)
ref = jeb->last_node;
105e81: 8b 42 2c mov 0x2c(%edx),%eax
105e84: 89 45 e4 mov %eax,-0x1c(%ebp)
dbg_noderef("Last node at %p is (%08x,%p)\n", ref, ref->flash_offset,
ref->next_in_ino);
while (ref->flash_offset != REF_EMPTY_NODE) {
105e87: 8b 70 04 mov 0x4(%eax),%esi
105e8a: 89 c7 mov %eax,%edi
105e8c: 83 fe fe cmp $0xfffffffe,%esi
105e8f: 75 1a jne 105eab <jffs2_link_node_ref+0x4b>
105e91: e9 ea 00 00 00 jmp 105f80 <jffs2_link_node_ref+0x120>
105e96: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105e9d: 8d 76 00 lea 0x0(%esi),%esi
105ea0: 8b 70 0c mov 0xc(%eax),%esi
if (ref->flash_offset == REF_LINK_NODE)
ref = ref->next_in_ino;
else
ref++;
105ea3: 83 c0 08 add $0x8,%eax
while (ref->flash_offset != REF_EMPTY_NODE) {
105ea6: 83 fe fe cmp $0xfffffffe,%esi
105ea9: 74 0d je 105eb8 <jffs2_link_node_ref+0x58>
if (ref->flash_offset == REF_LINK_NODE)
105eab: 46 inc %esi
105eac: 75 f2 jne 105ea0 <jffs2_link_node_ref+0x40>
ref = ref->next_in_ino;
105eae: 8b 00 mov (%eax),%eax
while (ref->flash_offset != REF_EMPTY_NODE) {
105eb0: 8b 70 04 mov 0x4(%eax),%esi
105eb3: 83 fe fe cmp $0xfffffffe,%esi
105eb6: 75 f3 jne 105eab <jffs2_link_node_ref+0x4b> <== NEVER TAKEN
105eb8: 89 7d e4 mov %edi,-0x1c(%ebp)
}
dbg_noderef("New ref is %p (%08x becomes %08x,%p) len 0x%x\n", ref,
ref->flash_offset, ofs, ref->next_in_ino, len);
ref->flash_offset = ofs;
105ebb: 8b 7d 10 mov 0x10(%ebp),%edi
105ebe: 89 78 04 mov %edi,0x4(%eax)
if (!jeb->first_node) {
jeb->first_node = ref;
BUG_ON(ref_offset(ref) != jeb->offset);
105ec1: 89 fe mov %edi,%esi
if (!jeb->first_node) {
105ec3: 8b 7a 28 mov 0x28(%edx),%edi
BUG_ON(ref_offset(ref) != jeb->offset);
105ec6: 83 e6 fc and $0xfffffffc,%esi
105ec9: 89 75 e0 mov %esi,-0x20(%ebp)
105ecc: 8b 72 0c mov 0xc(%edx),%esi
if (!jeb->first_node) {
105ecf: 85 ff test %edi,%edi
105ed1: 0f 84 89 00 00 00 je 105f60 <jffs2_link_node_ref+0x100>
} else if (unlikely(ref_offset(ref) != jeb->offset + c->sector_size - jeb->free_size)) {
105ed7: 8b 7a 20 mov 0x20(%edx),%edi
105eda: 03 71 34 add 0x34(%ecx),%esi
105edd: 89 7d dc mov %edi,-0x24(%ebp)
105ee0: 29 fe sub %edi,%esi
105ee2: 3b 75 e0 cmp -0x20(%ebp),%esi
105ee5: 0f 85 e5 00 00 00 jne 105fd0 <jffs2_link_node_ref+0x170> <== NEVER TAKEN
ref, ref_offset(ref), ref_offset(ref)+len,
ref_offset(jeb->last_node),
ref_offset(jeb->last_node)+last_len);
BUG();
}
jeb->last_node = ref;
105eeb: 89 42 2c mov %eax,0x2c(%edx)
if (ic) {
105eee: 8b 75 18 mov 0x18(%ebp),%esi
105ef1: 85 f6 test %esi,%esi
105ef3: 74 5b je 105f50 <jffs2_link_node_ref+0xf0>
ref->next_in_ino = ic->nodes;
105ef5: 8b 7d 18 mov 0x18(%ebp),%edi
105ef8: 8b 77 04 mov 0x4(%edi),%esi
105efb: 89 30 mov %esi,(%eax)
ic->nodes = ref;
105efd: 89 47 04 mov %eax,0x4(%edi)
} else {
ref->next_in_ino = NULL;
}
switch(ref_flags(ref)) {
105f00: 8b 75 10 mov 0x10(%ebp),%esi
105f03: 83 e6 03 and $0x3,%esi
105f06: 83 fe 01 cmp $0x1,%esi
105f09: 74 25 je 105f30 <jffs2_link_node_ref+0xd0>
105f0b: 83 ee 02 sub $0x2,%esi
105f0e: 83 fe 01 cmp $0x1,%esi
105f11: 77 2d ja 105f40 <jffs2_link_node_ref+0xe0> <== NEVER TAKEN
jeb->unchecked_size += len;
break;
case REF_NORMAL:
case REF_PRISTINE:
c->used_size += len;
105f13: 01 59 1c add %ebx,0x1c(%ecx)
jeb->used_size += len;
105f16: 01 5a 14 add %ebx,0x14(%edx)
c->dirty_size += len;
jeb->dirty_size += len;
break;
}
c->free_size -= len;
jeb->free_size -= len;
105f19: 8b 7d dc mov -0x24(%ebp),%edi
c->free_size -= len;
105f1c: 29 59 28 sub %ebx,0x28(%ecx)
jeb->free_size -= len;
105f1f: 29 df sub %ebx,%edi
105f21: 89 7a 20 mov %edi,0x20(%edx)
/* Set (and test) __totlen field... for now */
ref->__totlen = len;
ref_totlen(c, jeb, ref);
#endif
return ref;
}
105f24: 83 c4 3c add $0x3c,%esp
105f27: 5b pop %ebx
105f28: 5e pop %esi
105f29: 5f pop %edi
105f2a: 5d pop %ebp
105f2b: c3 ret
105f2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
c->dirty_size += len;
105f30: 01 59 20 add %ebx,0x20(%ecx)
jeb->dirty_size += len;
105f33: 01 5a 18 add %ebx,0x18(%edx)
break;
105f36: eb e1 jmp 105f19 <jffs2_link_node_ref+0xb9>
105f38: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105f3f: 90 nop
c->unchecked_size += len;
105f40: 01 59 38 add %ebx,0x38(%ecx) <== NOT EXECUTED
jeb->unchecked_size += len;
105f43: 01 5a 10 add %ebx,0x10(%edx) <== NOT EXECUTED
break;
105f46: eb d1 jmp 105f19 <jffs2_link_node_ref+0xb9> <== NOT EXECUTED
105f48: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
105f4f: 90 nop <== NOT EXECUTED
ref->next_in_ino = NULL;
105f50: c7 00 00 00 00 00 movl $0x0,(%eax)
105f56: eb a8 jmp 105f00 <jffs2_link_node_ref+0xa0>
105f58: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105f5f: 90 nop
BUG_ON(ref_offset(ref) != jeb->offset);
105f60: 39 75 e0 cmp %esi,-0x20(%ebp)
jeb->first_node = ref;
105f63: 89 42 28 mov %eax,0x28(%edx)
BUG_ON(ref_offset(ref) != jeb->offset);
105f66: 75 20 jne 105f88 <jffs2_link_node_ref+0x128> <== NEVER TAKEN
} else if (unlikely(ref_offset(ref) != jeb->offset + c->sector_size - jeb->free_size)) {
105f68: 8b 7a 20 mov 0x20(%edx),%edi
105f6b: 89 7d dc mov %edi,-0x24(%ebp)
105f6e: e9 78 ff ff ff jmp 105eeb <jffs2_link_node_ref+0x8b>
105f73: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105f7a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
while (ref->flash_offset != REF_EMPTY_NODE) {
105f80: 8b 45 e4 mov -0x1c(%ebp),%eax
105f83: e9 33 ff ff ff jmp 105ebb <jffs2_link_node_ref+0x5b>
BUG_ON(ref_offset(ref) != jeb->offset);
105f88: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED
105f8f: 00
105f90: c7 44 24 08 d0 ec 12 movl $0x12ecd0,0x8(%esp) <== NOT EXECUTED
105f97: 00
105f98: c7 44 24 04 68 02 00 movl $0x268,0x4(%esp) <== NOT EXECUTED
105f9f: 00
105fa0: c7 04 24 44 eb 12 00 movl $0x12eb44,(%esp) <== NOT EXECUTED
105fa7: e8 c4 7c 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED
BUG_ON(!jeb->allocated_refs);
105fac: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED
105fb3: 00
105fb4: c7 44 24 08 d0 ec 12 movl $0x12ecd0,0x8(%esp) <== NOT EXECUTED
105fbb: 00
105fbc: c7 44 24 04 52 02 00 movl $0x252,0x4(%esp) <== NOT EXECUTED
105fc3: 00
105fc4: c7 04 24 44 eb 12 00 movl $0x12eb44,(%esp) <== NOT EXECUTED
105fcb: e8 a0 7c 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED
if (ref->flash_offset == REF_LINK_NODE) {
105fd0: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
105fd3: 83 79 0c ff cmpl $0xffffffff,0xc(%ecx) <== NOT EXECUTED
105fd7: 74 6a je 106043 <jffs2_link_node_ref+0x1e3> <== NOT EXECUTED
ref++;
105fd9: 8d 51 08 lea 0x8(%ecx),%edx <== NOT EXECUTED
if (ref->flash_offset == REF_EMPTY_NODE)
105fdc: 8b 52 04 mov 0x4(%edx),%edx <== NOT EXECUTED
105fdf: 83 fa fe cmp $0xfffffffe,%edx <== NOT EXECUTED
105fe2: 74 05 je 105fe9 <jffs2_link_node_ref+0x189> <== NOT EXECUTED
{
uint32_t ref_end;
struct jffs2_raw_node_ref *next_ref = ref_next(ref);
if (next_ref)
ref_end = ref_offset(next_ref);
105fe4: 83 e2 fc and $0xfffffffc,%edx <== NOT EXECUTED
105fe7: 89 d6 mov %edx,%esi <== NOT EXECUTED
JFFS2_ERROR("Adding new ref %p at (0x%08x-0x%08x) not immediately after previous (0x%08x-0x%08x)\n",
105fe9: 89 74 24 18 mov %esi,0x18(%esp) <== NOT EXECUTED
ref_offset(jeb->last_node) : 0);
BUG();
}
ref_end = jeb->offset + c->sector_size - jeb->free_size;
}
return ref_end - ref_offset(ref);
105fed: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
105ff0: 8b 51 04 mov 0x4(%ecx),%edx <== NOT EXECUTED
JFFS2_ERROR("Adding new ref %p at (0x%08x-0x%08x) not immediately after previous (0x%08x-0x%08x)\n",
105ff3: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
105ff7: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED
105ffa: c7 44 24 04 d0 ec 12 movl $0x12ecd0,0x4(%esp) <== NOT EXECUTED
106001: 00
106002: c7 04 24 b4 eb 12 00 movl $0x12ebb4,(%esp) <== NOT EXECUTED
return ref_end - ref_offset(ref);
106009: 83 e2 fc and $0xfffffffc,%edx <== NOT EXECUTED
JFFS2_ERROR("Adding new ref %p at (0x%08x-0x%08x) not immediately after previous (0x%08x-0x%08x)\n",
10600c: 89 54 24 14 mov %edx,0x14(%esp) <== NOT EXECUTED
106010: 01 cb add %ecx,%ebx <== NOT EXECUTED
106012: 89 5c 24 10 mov %ebx,0x10(%esp) <== NOT EXECUTED
106016: 89 4c 24 0c mov %ecx,0xc(%esp) <== NOT EXECUTED
10601a: e8 61 f3 ff ff call 105380 <jffs2_printk> <== NOT EXECUTED
BUG();
10601f: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED
106026: 00
106027: c7 44 24 08 d0 ec 12 movl $0x12ecd0,0x8(%esp) <== NOT EXECUTED
10602e: 00
10602f: c7 44 24 04 70 02 00 movl $0x270,0x4(%esp) <== NOT EXECUTED
106036: 00
106037: c7 04 24 44 eb 12 00 movl $0x12eb44,(%esp) <== NOT EXECUTED
10603e: e8 2d 7c 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED
ref = ref->next_in_ino;
106043: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED
106046: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED
if (!ref)
106049: 85 d2 test %edx,%edx <== NOT EXECUTED
10604b: 75 8f jne 105fdc <jffs2_link_node_ref+0x17c> <== NOT EXECUTED
10604d: eb 9a jmp 105fe9 <jffs2_link_node_ref+0x189> <== NOT EXECUTED
10604f: 90 nop
0010b300 <jffs2_lookup>:
/***********************************************************************/
/* Takes length argument because it can be either NUL-terminated or '/'-terminated */
struct _inode *jffs2_lookup(struct _inode *dir_i, const unsigned char *name, size_t namelen)
{
10b300: 55 push %ebp
10b301: 89 e5 mov %esp,%ebp
10b303: 57 push %edi
10b304: 56 push %esi
10b305: 53 push %ebx
10b306: 83 ec 2c sub $0x2c,%esp
while (len--) {
10b309: 8b 55 10 mov 0x10(%ebp),%edx
10b30c: 85 d2 test %edx,%edx
10b30e: 0f 84 dc 00 00 00 je 10b3f0 <jffs2_lookup+0xf0> <== NEVER TAKEN
10b314: 8b 45 10 mov 0x10(%ebp),%eax
uint32_t hash = 0;
10b317: 31 f6 xor %esi,%esi
10b319: 8b 55 0c mov 0xc(%ebp),%edx
10b31c: 01 c2 add %eax,%edx
while (len--) {
10b31e: 8b 45 0c mov 0xc(%ebp),%eax
10b321: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b328: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b32f: 90 nop
hash ^= *(name++);
10b330: 0f b6 08 movzbl (%eax),%ecx
hash = (hash << 4) | (hash >> 28);
10b333: c1 c6 04 rol $0x4,%esi
hash ^= *(name++);
10b336: 40 inc %eax
10b337: 31 ce xor %ecx,%esi
while (len--) {
10b339: 39 c2 cmp %eax,%edx
10b33b: 75 f3 jne 10b330 <jffs2_lookup+0x30>
dir_f = JFFS2_INODE_INFO(dir_i);
mutex_lock(&dir_f->sem);
/* NB: The 2.2 backport will need to explicitly check for '.' and '..' here */
for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= hash; fd_list = fd_list->next) {
10b33d: 8b 45 08 mov 0x8(%ebp),%eax
struct jffs2_full_dirent *fd = NULL, *fd_list;
10b340: 31 ff xor %edi,%edi
for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= hash; fd_list = fd_list->next) {
10b342: 8b 58 50 mov 0x50(%eax),%ebx
10b345: 85 db test %ebx,%ebx
10b347: 75 0e jne 10b357 <jffs2_lookup+0x57>
10b349: e9 8d 00 00 00 jmp 10b3db <jffs2_lookup+0xdb>
10b34e: 66 90 xchg %ax,%ax
10b350: 8b 5b 04 mov 0x4(%ebx),%ebx
10b353: 85 db test %ebx,%ebx
10b355: 74 59 je 10b3b0 <jffs2_lookup+0xb0>
10b357: 39 73 10 cmp %esi,0x10(%ebx)
10b35a: 77 54 ja 10b3b0 <jffs2_lookup+0xb0>
if (fd_list->nhash == hash &&
10b35c: 75 f2 jne 10b350 <jffs2_lookup+0x50>
10b35e: 85 ff test %edi,%edi
10b360: 74 08 je 10b36a <jffs2_lookup+0x6a> <== ALWAYS TAKEN
(!fd || fd_list->version > fd->version) &&
10b362: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED
10b365: 39 43 08 cmp %eax,0x8(%ebx) <== NOT EXECUTED
10b368: 76 e6 jbe 10b350 <jffs2_lookup+0x50> <== NOT EXECUTED
strlen((char *)fd_list->name) == namelen &&
10b36a: 8d 4b 15 lea 0x15(%ebx),%ecx
10b36d: 89 0c 24 mov %ecx,(%esp)
10b370: 89 4d e4 mov %ecx,-0x1c(%ebp)
10b373: e8 c8 bc 01 00 call 127040 <strlen>
(!fd || fd_list->version > fd->version) &&
10b378: 8b 4d e4 mov -0x1c(%ebp),%ecx
10b37b: 3b 45 10 cmp 0x10(%ebp),%eax
10b37e: 75 d0 jne 10b350 <jffs2_lookup+0x50> <== NEVER TAKEN
!strncmp((char *)fd_list->name, (char *)name, namelen)) {
10b380: 89 0c 24 mov %ecx,(%esp)
10b383: 8b 45 10 mov 0x10(%ebp),%eax
10b386: 89 44 24 08 mov %eax,0x8(%esp)
10b38a: 8b 45 0c mov 0xc(%ebp),%eax
10b38d: 89 44 24 04 mov %eax,0x4(%esp)
10b391: e8 2a bd 01 00 call 1270c0 <strncmp>
strlen((char *)fd_list->name) == namelen &&
10b396: 85 c0 test %eax,%eax
10b398: 75 b6 jne 10b350 <jffs2_lookup+0x50> <== NEVER TAKEN
10b39a: 89 df mov %ebx,%edi
for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= hash; fd_list = fd_list->next) {
10b39c: 8b 5b 04 mov 0x4(%ebx),%ebx
10b39f: 85 db test %ebx,%ebx
10b3a1: 75 b4 jne 10b357 <jffs2_lookup+0x57>
10b3a3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b3aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
fd = fd_list;
}
}
if (fd)
10b3b0: 85 ff test %edi,%edi
10b3b2: 74 5e je 10b412 <jffs2_lookup+0x112>
ino = fd->ino;
10b3b4: 8b 77 0c mov 0xc(%edi),%esi
struct _inode *inode = NULL;
10b3b7: 31 db xor %ebx,%ebx
mutex_unlock(&dir_f->sem);
if (ino) {
10b3b9: 85 f6 test %esi,%esi
10b3bb: 74 1e je 10b3db <jffs2_lookup+0xdb>
inode = jffs2_iget(dir_i->i_sb, ino);
10b3bd: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
10b3c1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10b3c4: 8b 40 3c mov 0x3c(%eax),%eax <== NOT EXECUTED
10b3c7: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10b3ca: e8 f1 7b ff ff call 102fc0 <jffs2_iget> <== NOT EXECUTED
if (IS_ERR(inode)) {
10b3cf: 3d 18 fc ff ff cmp $0xfffffc18,%eax
inode = jffs2_iget(dir_i->i_sb, ino);
10b3d4: 89 c3 mov %eax,%ebx
if (IS_ERR(inode)) {
10b3d6: 77 28 ja 10b400 <jffs2_lookup+0x100> <== NEVER TAKEN
printk("jffs2_iget() failed for ino #%lu\n", ino);
return inode;
} else {
inode->i_fd = fd;
10b3d8: 89 78 40 mov %edi,0x40(%eax) <== NOT EXECUTED
}
}
return inode;
}
10b3db: 83 c4 2c add $0x2c,%esp
10b3de: 89 d8 mov %ebx,%eax
10b3e0: 5b pop %ebx
10b3e1: 5e pop %esi
10b3e2: 5f pop %edi
10b3e3: 5d pop %ebp
10b3e4: c3 ret
10b3e5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b3ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
uint32_t hash = 0;
10b3f0: 31 f6 xor %esi,%esi
10b3f2: e9 46 ff ff ff jmp 10b33d <jffs2_lookup+0x3d> <== NOT EXECUTED
10b3f7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10b3fe: 66 90 xchg %ax,%ax <== NOT EXECUTED
printk("jffs2_iget() failed for ino #%lu\n", ino);
10b400: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
10b404: c7 04 24 28 06 13 00 movl $0x130628,(%esp) <== NOT EXECUTED
10b40b: e8 d0 fe ff ff call 10b2e0 <jffs2_printk> <== NOT EXECUTED
return inode;
10b410: eb c9 jmp 10b3db <jffs2_lookup+0xdb> <== NOT EXECUTED
struct _inode *inode = NULL;
10b412: 31 db xor %ebx,%ebx
10b414: eb c5 jmp 10b3db <jffs2_lookup+0xdb>
10b416: 90 nop
10b417: 90 nop
10b418: 90 nop
10b419: 90 nop
10b41a: 90 nop
10b41b: 90 nop
10b41c: 90 nop
10b41d: 90 nop
10b41e: 90 nop
10b41f: 90 nop
00105d80 <jffs2_lookup_node_frag>:
{
105d80: 55 push %ebp
105d81: 89 e5 mov %esp,%ebp
105d83: 56 push %esi
next = fragtree->rb_node;
105d84: 8b 45 08 mov 0x8(%ebp),%eax
struct jffs2_node_frag *prev = NULL;
105d87: 31 f6 xor %esi,%esi
{
105d89: 53 push %ebx
105d8a: 8b 5d 0c mov 0xc(%ebp),%ebx
next = fragtree->rb_node;
105d8d: 8b 00 mov (%eax),%eax
while(next) {
105d8f: 90 nop
105d90: 85 c0 test %eax,%eax
105d92: 74 1e je 105db2 <jffs2_lookup_node_frag+0x32> <== NEVER TAKEN
if (frag->ofs + frag->size <= offset) {
105d94: 8b 50 18 mov 0x18(%eax),%edx
105d97: 8b 48 14 mov 0x14(%eax),%ecx
105d9a: 01 d1 add %edx,%ecx
105d9c: 39 d9 cmp %ebx,%ecx
105d9e: 77 20 ja 105dc0 <jffs2_lookup_node_frag+0x40>
if (!prev || frag->ofs > prev->ofs)
105da0: 85 f6 test %esi,%esi
105da2: 74 05 je 105da9 <jffs2_lookup_node_frag+0x29>
105da4: 3b 56 18 cmp 0x18(%esi),%edx
105da7: 76 02 jbe 105dab <jffs2_lookup_node_frag+0x2b> <== NEVER TAKEN
105da9: 89 c6 mov %eax,%esi
next = frag->rb.rb_right;
105dab: 8b 40 04 mov 0x4(%eax),%eax
while(next) {
105dae: 85 c0 test %eax,%eax
105db0: 75 e2 jne 105d94 <jffs2_lookup_node_frag+0x14> <== ALWAYS TAKEN
prev->ofs, prev->ofs+prev->size);
else
dbg_fragtree2("returning NULL, empty fragtree\n");
return prev;
}
105db2: 5b pop %ebx <== NOT EXECUTED
105db3: 89 f0 mov %esi,%eax <== NOT EXECUTED
105db5: 5e pop %esi <== NOT EXECUTED
105db6: 5d pop %ebp <== NOT EXECUTED
105db7: c3 ret <== NOT EXECUTED
105db8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
105dbf: 90 nop <== NOT EXECUTED
} else if (frag->ofs > offset) {
105dc0: 39 da cmp %ebx,%edx
105dc2: 76 0c jbe 105dd0 <jffs2_lookup_node_frag+0x50>
next = frag->rb.rb_left;
105dc4: 8b 00 mov (%eax),%eax
while(next) {
105dc6: eb c8 jmp 105d90 <jffs2_lookup_node_frag+0x10>
105dc8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
105dcf: 90 nop
}
105dd0: 5b pop %ebx
105dd1: 89 c6 mov %eax,%esi
105dd3: 89 f0 mov %esi,%eax
105dd5: 5e pop %esi
105dd6: 5d pop %ebp
105dd7: c3 ret
105dd8: 90 nop
105dd9: 90 nop
105dda: 90 nop
105ddb: 90 nop
105ddc: 90 nop
105ddd: 90 nop
105dde: 90 nop
105ddf: 90 nop
001063c0 <jffs2_mark_node_obsolete>:
}
return 0;
}
void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref)
{
1063c0: 55 push %ebp
1063c1: 89 e5 mov %esp,%ebp
1063c3: 57 push %edi
1063c4: 56 push %esi
1063c5: 53 push %ebx
1063c6: 83 ec 5c sub $0x5c,%esp
1063c9: 8b 7d 0c mov 0xc(%ebp),%edi
1063cc: 8b 5d 08 mov 0x8(%ebp),%ebx
struct jffs2_unknown_node n;
int ret, addedsize;
size_t retlen;
uint32_t freed_len;
if(unlikely(!ref)) {
1063cf: 85 ff test %edi,%edi
1063d1: 0f 84 59 03 00 00 je 106730 <jffs2_mark_node_obsolete+0x370> <== NEVER TAKEN
pr_notice("EEEEEK. jffs2_mark_node_obsolete called with NULL node\n");
return;
}
if (ref_obsolete(ref)) {
1063d7: 8b 4f 04 mov 0x4(%edi),%ecx
1063da: 89 c8 mov %ecx,%eax
1063dc: 83 e0 03 and $0x3,%eax
1063df: 48 dec %eax
1063e0: 0f 84 20 01 00 00 je 106506 <jffs2_mark_node_obsolete+0x146> <== NEVER TAKEN
jffs2_dbg(1, "%s(): called with already obsolete node at 0x%08x\n",
__func__, ref_offset(ref));
return;
}
blocknr = ref->flash_offset / c->sector_size;
1063e6: 31 d2 xor %edx,%edx
1063e8: 89 c8 mov %ecx,%eax
1063ea: f7 73 34 divl 0x34(%ebx)
if (blocknr >= c->nr_blocks) {
1063ed: 3b 43 50 cmp 0x50(%ebx),%eax
1063f0: 0f 83 75 04 00 00 jae 10686b <jffs2_mark_node_obsolete+0x4ab> <== NEVER TAKEN
pr_notice("raw node at 0x%08x is off the end of device!\n",
ref->flash_offset);
BUG();
}
jeb = &c->blocks[blocknr];
1063f6: 8d 14 40 lea (%eax,%eax,2),%edx
1063f9: 8d 14 90 lea (%eax,%edx,4),%edx
1063fc: 8b 43 54 mov 0x54(%ebx),%eax
mutex_lock(&c->erase_free_sem);
}
spin_lock(&c->erase_completion_lock);
freed_len = ref_totlen(c, jeb, ref);
1063ff: 89 7c 24 08 mov %edi,0x8(%esp)
106403: 89 1c 24 mov %ebx,(%esp)
jeb = &c->blocks[blocknr];
106406: 8d 34 90 lea (%eax,%edx,4),%esi
freed_len = ref_totlen(c, jeb, ref);
106409: 89 74 24 04 mov %esi,0x4(%esp)
10640d: e8 0e fd ff ff call 106120 <__jffs2_ref_totlen>
106412: 89 c2 mov %eax,%edx
if (ref_flags(ref) == REF_UNCHECKED) {
106414: 8b 47 04 mov 0x4(%edi),%eax
106417: 89 45 d4 mov %eax,-0x2c(%ebp)
10641a: a8 03 test $0x3,%al
10641c: 0f 84 ee 00 00 00 je 106510 <jffs2_mark_node_obsolete+0x150> <== NEVER TAKEN
jeb->used_size -= freed_len;
c->used_size -= freed_len;
}
// Take care, that wasted size is taken into concern
if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) {
106422: 8b 46 18 mov 0x18(%esi),%eax
106425: 8b 4e 1c mov 0x1c(%esi),%ecx
jeb->used_size -= freed_len;
106428: 29 56 14 sub %edx,0x14(%esi)
c->used_size -= freed_len;
10642b: 29 53 1c sub %edx,0x1c(%ebx)
if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) {
10642e: 85 c0 test %eax,%eax
106430: 89 4d d0 mov %ecx,-0x30(%ebp)
106433: 0f 85 ee 00 00 00 jne 106527 <jffs2_mark_node_obsolete+0x167>
106439: 01 d1 add %edx,%ecx
10643b: 81 f9 c4 00 00 00 cmp $0xc4,%ecx
106441: 0f 87 e0 00 00 00 ja 106527 <jffs2_mark_node_obsolete+0x167>
}
}
} else {
jffs2_dbg(1, "Wasting\n");
addedsize = 0;
jeb->wasted_size += freed_len;
106447: 89 4e 1c mov %ecx,0x1c(%esi)
c->wasted_size += freed_len;
10644a: 01 53 24 add %edx,0x24(%ebx)
addedsize = 0;
10644d: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp)
106454: 89 55 d0 mov %edx,-0x30(%ebp)
}
ref->flash_offset = ref_offset(ref) | REF_OBSOLETE;
106457: 8b 45 d4 mov -0x2c(%ebp),%eax
10645a: 83 e0 fc and $0xfffffffc,%eax
10645d: 83 c8 01 or $0x1,%eax
106460: 89 47 04 mov %eax,0x4(%edi)
jffs2_dbg_acct_sanity_check_nolock(c, jeb);
106463: 89 74 24 04 mov %esi,0x4(%esp)
106467: 89 1c 24 mov %ebx,(%esp)
10646a: e8 f1 4c 00 00 call 10b160 <__jffs2_dbg_acct_sanity_check_nolock>
jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
if (c->flags & JFFS2_SB_FLAG_SCANNING) {
10646f: f6 43 0c 02 testb $0x2,0xc(%ebx)
106473: 0f 85 8d 00 00 00 jne 106506 <jffs2_mark_node_obsolete+0x146> <== NEVER TAKEN
spin_unlock(&c->erase_completion_lock);
/* We didn't lock the erase_free_sem */
return;
}
if (jeb == c->nextblock) {
106479: 39 73 58 cmp %esi,0x58(%ebx)
10647c: 8b 55 d0 mov -0x30(%ebp),%edx
10647f: 74 6f je 1064f0 <jffs2_mark_node_obsolete+0x130>
jffs2_dbg(2, "Not moving nextblock 0x%08x to dirty/erase_pending list\n",
jeb->offset);
} else if (!jeb->used_size && !jeb->unchecked_size) {
106481: 8b 4e 14 mov 0x14(%esi),%ecx
if (jeb == c->gcblock) {
106484: 8b 43 5c mov 0x5c(%ebx),%eax
} else if (!jeb->used_size && !jeb->unchecked_size) {
106487: 85 c9 test %ecx,%ecx
106489: 0f 85 01 01 00 00 jne 106590 <jffs2_mark_node_obsolete+0x1d0>
10648f: 8b 4e 10 mov 0x10(%esi),%ecx
106492: 85 c9 test %ecx,%ecx
106494: 0f 85 f6 00 00 00 jne 106590 <jffs2_mark_node_obsolete+0x1d0> <== NEVER TAKEN
if (jeb == c->gcblock) {
10649a: 39 c6 cmp %eax,%esi
10649c: 0f 84 5e 03 00 00 je 106800 <jffs2_mark_node_obsolete+0x440>
ent->prev->next = ent->next;
1064a2: 8b 4e 04 mov 0x4(%esi),%ecx
1064a5: 8b 06 mov (%esi),%eax
1064a7: 89 01 mov %eax,(%ecx)
ent->next->prev = ent->prev;
1064a9: 89 48 04 mov %ecx,0x4(%eax)
1064ac: a1 34 b8 15 00 mov 0x15b834,%eax
}
if (jffs2_wbuf_dirty(c)) {
jffs2_dbg(1, "...and adding to erasable_pending_wbuf_list\n");
list_add_tail(&jeb->list, &c->erasable_pending_wbuf_list);
} else {
if (jiffies & 127) {
1064b1: a8 7f test $0x7f,%al
1064b3: 0f 84 e7 02 00 00 je 1067a0 <jffs2_mark_node_obsolete+0x3e0> <== NEVER TAKEN
/* Most of the time, we just erase it immediately. Otherwise we
spend ages scanning it on mount, etc. */
jffs2_dbg(1, "...and adding to erase_pending_list\n");
list_add_tail(&jeb->list, &c->erase_pending_list);
1064b9: 8d 8b 98 00 00 00 lea 0x98(%ebx),%ecx
struct list_head *prev = beforethisent->prev;
1064bf: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax
1064c5: 89 0e mov %ecx,(%esi)
rtems_jffs2_flash_control *fc = sb->s_flash_control;
1064c7: 8b 8b e4 00 00 00 mov 0xe4(%ebx),%ecx
newent->prev = prev;
1064cd: 89 46 04 mov %eax,0x4(%esi)
beforethisent->prev = newent;
1064d0: 89 b3 9c 00 00 00 mov %esi,0x9c(%ebx)
prev->next = newent;
1064d6: 89 30 mov %esi,(%eax)
if (fc->trigger_garbage_collection != NULL) {
1064d8: 8b 41 20 mov 0x20(%ecx),%eax
c->nr_erasing_blocks++;
1064db: ff 43 40 incl 0x40(%ebx)
1064de: 85 c0 test %eax,%eax
1064e0: 74 0e je 1064f0 <jffs2_mark_node_obsolete+0x130> <== ALWAYS TAKEN
(*fc->trigger_garbage_collection)(fc);
1064e2: 89 0c 24 mov %ecx,(%esp) <== NOT EXECUTED
1064e5: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED
1064e8: ff d0 call *%eax <== NOT EXECUTED
1064ea: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED
1064ed: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
jeb->used_size);
}
spin_unlock(&c->erase_completion_lock);
if (!jffs2_can_mark_obsolete(c) || jffs2_is_readonly(c) ||
1064f0: 80 bb ec 00 00 00 00 cmpb $0x0,0xec(%ebx)
1064f7: 89 55 d4 mov %edx,-0x2c(%ebp)
1064fa: 75 0a jne 106506 <jffs2_mark_node_obsolete+0x146> <== NEVER TAKEN
1064fc: f6 43 0c 04 testb $0x4,0xc(%ebx)
106500: 0f 84 fa 00 00 00 je 106600 <jffs2_mark_node_obsolete+0x240> <== ALWAYS TAKEN
spin_unlock(&c->erase_completion_lock);
}
out_erase_sem:
mutex_unlock(&c->erase_free_sem);
}
106506: 83 c4 5c add $0x5c,%esp
106509: 5b pop %ebx
10650a: 5e pop %esi
10650b: 5f pop %edi
10650c: 5d pop %ebp
10650d: c3 ret
10650e: 66 90 xchg %ax,%ax
if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) {
106510: 8b 46 18 mov 0x18(%esi),%eax <== NOT EXECUTED
106513: 8b 4e 1c mov 0x1c(%esi),%ecx <== NOT EXECUTED
jeb->unchecked_size -= freed_len;
106516: 29 56 10 sub %edx,0x10(%esi) <== NOT EXECUTED
c->unchecked_size -= freed_len;
106519: 29 53 38 sub %edx,0x38(%ebx) <== NOT EXECUTED
if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) {
10651c: 85 c0 test %eax,%eax <== NOT EXECUTED
10651e: 89 4d d0 mov %ecx,-0x30(%ebp) <== NOT EXECUTED
106521: 0f 84 12 ff ff ff je 106439 <jffs2_mark_node_obsolete+0x79> <== NOT EXECUTED
106527: 39 73 58 cmp %esi,0x58(%ebx)
10652a: 0f 84 f0 01 00 00 je 106720 <jffs2_mark_node_obsolete+0x360>
jeb->dirty_size += freed_len;
106530: 01 d0 add %edx,%eax
106532: 89 46 18 mov %eax,0x18(%esi)
106535: 89 45 c8 mov %eax,-0x38(%ebp)
c->dirty_size += freed_len;
106538: 8b 43 20 mov 0x20(%ebx),%eax
10653b: 01 d0 add %edx,%eax
10653d: 89 45 c4 mov %eax,-0x3c(%ebp)
106540: 89 43 20 mov %eax,0x20(%ebx)
if (jeb->wasted_size) {
106543: 8b 45 d0 mov -0x30(%ebp),%eax
106546: 85 c0 test %eax,%eax
106548: 0f 84 a2 00 00 00 je 1065f0 <jffs2_mark_node_obsolete+0x230>
list_for_each(this, head) {
10654e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax
if (on_list(&jeb->list, &c->bad_used_list)) {
106554: 8d 8b b8 00 00 00 lea 0xb8(%ebx),%ecx
list_for_each(this, head) {
10655a: 39 c1 cmp %eax,%ecx
10655c: 75 1c jne 10657a <jffs2_mark_node_obsolete+0x1ba> <== NEVER TAKEN
10655e: e9 ed 01 00 00 jmp 106750 <jffs2_mark_node_obsolete+0x390>
106563: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10656a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
106570: 8b 00 mov (%eax),%eax <== NOT EXECUTED
106572: 39 c1 cmp %eax,%ecx <== NOT EXECUTED
106574: 0f 84 d6 01 00 00 je 106750 <jffs2_mark_node_obsolete+0x390> <== NOT EXECUTED
if (this == obj) {
10657a: 39 c6 cmp %eax,%esi <== NOT EXECUTED
10657c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106580: 75 ee jne 106570 <jffs2_mark_node_obsolete+0x1b0> <== NOT EXECUTED
addedsize = 0; /* To fool the refiling code later */
106582: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp) <== NOT EXECUTED
106589: e9 c6 fe ff ff jmp 106454 <jffs2_mark_node_obsolete+0x94> <== NOT EXECUTED
10658e: 66 90 xchg %ax,%ax <== NOT EXECUTED
} else if (jeb == c->gcblock) {
106590: 39 c6 cmp %eax,%esi
106592: 0f 84 58 ff ff ff je 1064f0 <jffs2_mark_node_obsolete+0x130>
} else if (ISDIRTY(jeb->dirty_size) && !ISDIRTY(jeb->dirty_size - addedsize)) {
106598: 8b 46 18 mov 0x18(%esi),%eax
10659b: 3d c4 00 00 00 cmp $0xc4,%eax
1065a0: 76 11 jbe 1065b3 <jffs2_mark_node_obsolete+0x1f3>
1065a2: 89 c1 mov %eax,%ecx
1065a4: 2b 4d cc sub -0x34(%ebp),%ecx
1065a7: 81 f9 c4 00 00 00 cmp $0xc4,%ecx
1065ad: 0f 86 cd 01 00 00 jbe 106780 <jffs2_mark_node_obsolete+0x3c0>
} else if (VERYDIRTY(c, jeb->dirty_size) &&
1065b3: 8b 4b 34 mov 0x34(%ebx),%ecx
1065b6: d1 e9 shr %ecx
1065b8: 39 c8 cmp %ecx,%eax
1065ba: 0f 82 30 ff ff ff jb 1064f0 <jffs2_mark_node_obsolete+0x130>
!VERYDIRTY(c, jeb->dirty_size - addedsize)) {
1065c0: 2b 45 cc sub -0x34(%ebp),%eax
} else if (VERYDIRTY(c, jeb->dirty_size) &&
1065c3: 39 c1 cmp %eax,%ecx
1065c5: 0f 86 25 ff ff ff jbe 1064f0 <jffs2_mark_node_obsolete+0x130>
ent->prev->next = ent->next;
1065cb: 8b 4e 04 mov 0x4(%esi),%ecx
1065ce: 8b 06 mov (%esi),%eax
1065d0: 89 01 mov %eax,(%ecx)
ent->next->prev = ent->prev;
1065d2: 89 48 04 mov %ecx,0x4(%eax)
list_add_tail(&jeb->list, &c->very_dirty_list);
1065d5: 8d 4b 68 lea 0x68(%ebx),%ecx
struct list_head *prev = beforethisent->prev;
1065d8: 8b 43 6c mov 0x6c(%ebx),%eax
1065db: 89 0e mov %ecx,(%esi)
newent->prev = prev;
1065dd: 89 46 04 mov %eax,0x4(%esi)
beforethisent->prev = newent;
1065e0: 89 73 6c mov %esi,0x6c(%ebx)
prev->next = newent;
1065e3: 89 30 mov %esi,(%eax)
} /* list_add_tail() */
1065e5: e9 06 ff ff ff jmp 1064f0 <jffs2_mark_node_obsolete+0x130>
1065ea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
addedsize = freed_len;
1065f0: 89 55 cc mov %edx,-0x34(%ebp)
1065f3: e9 5c fe ff ff jmp 106454 <jffs2_mark_node_obsolete+0x94>
1065f8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1065ff: 90 nop
ret = jffs2_flash_read(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
106600: 8d 45 dc lea -0x24(%ebp),%eax
106603: 89 44 24 10 mov %eax,0x10(%esp)
106607: 8d 75 d8 lea -0x28(%ebp),%esi
10660a: b8 0c 00 00 00 mov $0xc,%eax
10660f: 89 74 24 0c mov %esi,0xc(%esp)
106613: 89 44 24 08 mov %eax,0x8(%esp)
106617: 8b 47 04 mov 0x4(%edi),%eax
10661a: 89 1c 24 mov %ebx,(%esp)
10661d: 83 e0 fc and $0xfffffffc,%eax
106620: 89 44 24 04 mov %eax,0x4(%esp)
106624: e8 37 5c 00 00 call 10c260 <jffs2_flash_read>
if (ret) {
106629: 8b 55 d4 mov -0x2c(%ebp),%edx
10662c: 85 c0 test %eax,%eax
10662e: 0f 85 ac 01 00 00 jne 1067e0 <jffs2_mark_node_obsolete+0x420> <== NEVER TAKEN
if (retlen != sizeof(n)) {
106634: 8b 45 d8 mov -0x28(%ebp),%eax
106637: 83 f8 0c cmp $0xc,%eax
10663a: 0f 85 80 01 00 00 jne 1067c0 <jffs2_mark_node_obsolete+0x400> <== NEVER TAKEN
if (PAD(je32_to_cpu(n.totlen)) != PAD(freed_len)) {
106640: 8b 4d e0 mov -0x20(%ebp),%ecx
106643: 8d 41 03 lea 0x3(%ecx),%eax
106646: 89 45 d4 mov %eax,-0x2c(%ebp)
106649: 8d 42 03 lea 0x3(%edx),%eax
10664c: 33 45 d4 xor -0x2c(%ebp),%eax
10664f: 83 e0 fc and $0xfffffffc,%eax
106652: 0f 85 b4 01 00 00 jne 10680c <jffs2_mark_node_obsolete+0x44c> <== NEVER TAKEN
if (!(je16_to_cpu(n.nodetype) & JFFS2_NODE_ACCURATE)) {
106658: 0f b7 45 de movzwl -0x22(%ebp),%eax
10665c: f6 c4 20 test $0x20,%ah
10665f: 0f 84 a1 fe ff ff je 106506 <jffs2_mark_node_obsolete+0x146> <== NEVER TAKEN
ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
106665: 89 74 24 0c mov %esi,0xc(%esp)
n.nodetype = cpu_to_je16(je16_to_cpu(n.nodetype) & ~JFFS2_NODE_ACCURATE);
106669: 25 ff df ff ff and $0xffffdfff,%eax
ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
10666e: ba 0c 00 00 00 mov $0xc,%edx
n.nodetype = cpu_to_je16(je16_to_cpu(n.nodetype) & ~JFFS2_NODE_ACCURATE);
106673: 66 89 45 de mov %ax,-0x22(%ebp)
ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
106677: 8d 45 dc lea -0x24(%ebp),%eax
10667a: 89 44 24 10 mov %eax,0x10(%esp)
10667e: 89 54 24 08 mov %edx,0x8(%esp)
106682: 8b 47 04 mov 0x4(%edi),%eax
106685: 89 1c 24 mov %ebx,(%esp)
106688: 83 e0 fc and $0xfffffffc,%eax
10668b: 89 44 24 04 mov %eax,0x4(%esp)
10668f: e8 fc 5b 00 00 call 10c290 <jffs2_flash_write>
if (ret) {
106694: 85 c0 test %eax,%eax
106696: 0f 85 a8 01 00 00 jne 106844 <jffs2_mark_node_obsolete+0x484> <== NEVER TAKEN
if (retlen != sizeof(n)) {
10669c: 8b 45 d8 mov -0x28(%ebp),%eax
10669f: 83 f8 0c cmp $0xc,%eax
1066a2: 0f 85 7d 01 00 00 jne 106825 <jffs2_mark_node_obsolete+0x465> <== NEVER TAKEN
if (ref->next_in_ino) {
1066a8: 8b 0f mov (%edi),%ecx
1066aa: 85 c9 test %ecx,%ecx
1066ac: 0f 84 54 fe ff ff je 106506 <jffs2_mark_node_obsolete+0x146>
1066b2: 89 c8 mov %ecx,%eax
1066b4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1066bb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1066bf: 90 nop
1066c0: 89 c2 mov %eax,%edx
while(raw->next_in_ino)
1066c2: 8b 00 mov (%eax),%eax
1066c4: 85 c0 test %eax,%eax
1066c6: 75 f8 jne 1066c0 <jffs2_mark_node_obsolete+0x300>
for (p = &ic->nodes; (*p) != ref; p = &((*p)->next_in_ino))
1066c8: 8b 42 04 mov 0x4(%edx),%eax
1066cb: 39 f8 cmp %edi,%eax
1066cd: 0f 84 90 01 00 00 je 106863 <jffs2_mark_node_obsolete+0x4a3>
1066d3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1066da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
1066e0: 89 c6 mov %eax,%esi
1066e2: 8b 00 mov (%eax),%eax
1066e4: 39 c7 cmp %eax,%edi
1066e6: 75 f8 jne 1066e0 <jffs2_mark_node_obsolete+0x320>
*p = ref->next_in_ino;
1066e8: 89 0e mov %ecx,(%esi)
if (ic->nodes == (void *)ic && ic->pino_nlink == 0)
1066ea: 3b 52 04 cmp 0x4(%edx),%edx
ref->next_in_ino = NULL;
1066ed: c7 07 00 00 00 00 movl $0x0,(%edi)
if (ic->nodes == (void *)ic && ic->pino_nlink == 0)
1066f3: 0f 85 0d fe ff ff jne 106506 <jffs2_mark_node_obsolete+0x146>
1066f9: 8b 42 14 mov 0x14(%edx),%eax
1066fc: 85 c0 test %eax,%eax
1066fe: 0f 85 02 fe ff ff jne 106506 <jffs2_mark_node_obsolete+0x146>
jffs2_del_ino_cache(c, ic);
106704: 89 54 24 04 mov %edx,0x4(%esp)
106708: 89 1c 24 mov %ebx,(%esp)
10670b: e8 00 f5 ff ff call 105c10 <jffs2_del_ino_cache>
return 0;
}
static inline void mutex_unlock(struct mutex *m)
{
(void) m;
106710: e9 f1 fd ff ff jmp 106506 <jffs2_mark_node_obsolete+0x146>
106715: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10671c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) {
106720: 8b 4d d0 mov -0x30(%ebp),%ecx
106723: 01 d1 add %edx,%ecx
106725: e9 1d fd ff ff jmp 106447 <jffs2_mark_node_obsolete+0x87>
10672a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
pr_notice("EEEEEK. jffs2_mark_node_obsolete called with NULL node\n");
106730: c7 45 08 8c ed 12 00 movl $0x12ed8c,0x8(%ebp) <== NOT EXECUTED
}
106737: 83 c4 5c add $0x5c,%esp <== NOT EXECUTED
10673a: 5b pop %ebx <== NOT EXECUTED
10673b: 5e pop %esi <== NOT EXECUTED
10673c: 5f pop %edi <== NOT EXECUTED
10673d: 5d pop %ebp <== NOT EXECUTED
pr_notice("EEEEEK. jffs2_mark_node_obsolete called with NULL node\n");
10673e: e9 dd fa ff ff jmp 106220 <jffs2_printk> <== NOT EXECUTED
106743: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10674a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
addedsize += jeb->wasted_size;
106750: 8b 4d d0 mov -0x30(%ebp),%ecx
106753: 8d 04 0a lea (%edx,%ecx,1),%eax
106756: 89 45 cc mov %eax,-0x34(%ebp)
jeb->dirty_size += jeb->wasted_size;
106759: 8b 45 c8 mov -0x38(%ebp),%eax
10675c: 01 c8 add %ecx,%eax
10675e: 89 46 18 mov %eax,0x18(%esi)
c->dirty_size += jeb->wasted_size;
106761: 8b 45 c4 mov -0x3c(%ebp),%eax
c->wasted_size -= jeb->wasted_size;
106764: 29 4b 24 sub %ecx,0x24(%ebx)
c->dirty_size += jeb->wasted_size;
106767: 01 c8 add %ecx,%eax
106769: 89 43 20 mov %eax,0x20(%ebx)
jeb->wasted_size = 0;
10676c: c7 46 1c 00 00 00 00 movl $0x0,0x1c(%esi)
106773: e9 dc fc ff ff jmp 106454 <jffs2_mark_node_obsolete+0x94>
106778: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10677f: 90 nop
ent->prev->next = ent->next;
106780: 8b 4e 04 mov 0x4(%esi),%ecx
106783: 8b 06 mov (%esi),%eax
106785: 89 01 mov %eax,(%ecx)
ent->next->prev = ent->prev;
106787: 89 48 04 mov %ecx,0x4(%eax)
list_add_tail(&jeb->list, &c->dirty_list);
10678a: 8d 4b 70 lea 0x70(%ebx),%ecx
struct list_head *prev = beforethisent->prev;
10678d: 8b 43 74 mov 0x74(%ebx),%eax
106790: 89 0e mov %ecx,(%esi)
newent->prev = prev;
106792: 89 46 04 mov %eax,0x4(%esi)
beforethisent->prev = newent;
106795: 89 73 74 mov %esi,0x74(%ebx)
prev->next = newent;
106798: 89 30 mov %esi,(%eax)
} /* list_add_tail() */
10679a: e9 51 fd ff ff jmp 1064f0 <jffs2_mark_node_obsolete+0x130>
10679f: 90 nop
struct list_head *prev = beforethisent->prev;
1067a0: 8b 43 7c mov 0x7c(%ebx),%eax <== NOT EXECUTED
list_add_tail(&jeb->list, &c->erasable_list);
1067a3: 8d 4b 78 lea 0x78(%ebx),%ecx <== NOT EXECUTED
1067a6: 89 0e mov %ecx,(%esi) <== NOT EXECUTED
newent->prev = prev;
1067a8: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED
beforethisent->prev = newent;
1067ab: 89 73 7c mov %esi,0x7c(%ebx) <== NOT EXECUTED
prev->next = newent;
1067ae: 89 30 mov %esi,(%eax) <== NOT EXECUTED
} /* list_add_tail() */
1067b0: e9 3b fd ff ff jmp 1064f0 <jffs2_mark_node_obsolete+0x130> <== NOT EXECUTED
1067b5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1067bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
pr_warn("Short read from obsoleted node at 0x%08x: %zd\n",
1067c0: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1067c4: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
1067c7: c7 04 24 78 ee 12 00 movl $0x12ee78,(%esp) <== NOT EXECUTED
1067ce: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
1067d1: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1067d5: e8 46 fa ff ff call 106220 <jffs2_printk> <== NOT EXECUTED
goto out_erase_sem;
1067da: e9 27 fd ff ff jmp 106506 <jffs2_mark_node_obsolete+0x146> <== NOT EXECUTED
1067df: 90 nop <== NOT EXECUTED
pr_warn("Read error reading from obsoleted node at 0x%08x: %d\n",
1067e0: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1067e4: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
1067e7: c7 04 24 38 ee 12 00 movl $0x12ee38,(%esp) <== NOT EXECUTED
1067ee: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
1067f1: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1067f5: e8 26 fa ff ff call 106220 <jffs2_printk> <== NOT EXECUTED
goto out_erase_sem;
1067fa: e9 07 fd ff ff jmp 106506 <jffs2_mark_node_obsolete+0x146> <== NOT EXECUTED
1067ff: 90 nop <== NOT EXECUTED
c->gcblock = NULL;
106800: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
106807: e9 a0 fc ff ff jmp 1064ac <jffs2_mark_node_obsolete+0xec>
pr_warn("Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n",
10680c: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
106810: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
106814: c7 04 24 b4 ee 12 00 movl $0x12eeb4,(%esp) <== NOT EXECUTED
10681b: e8 00 fa ff ff call 106220 <jffs2_printk> <== NOT EXECUTED
goto out_erase_sem;
106820: e9 e1 fc ff ff jmp 106506 <jffs2_mark_node_obsolete+0x146> <== NOT EXECUTED
pr_warn("Short write in obliterating obsoleted node at 0x%08x: %zd\n",
106825: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
106829: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
10682c: c7 04 24 44 ef 12 00 movl $0x12ef44,(%esp) <== NOT EXECUTED
106833: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
106836: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10683a: e8 e1 f9 ff ff call 106220 <jffs2_printk> <== NOT EXECUTED
goto out_erase_sem;
10683f: e9 c2 fc ff ff jmp 106506 <jffs2_mark_node_obsolete+0x146> <== NOT EXECUTED
pr_warn("Write error in obliterating obsoleted node at 0x%08x: %d\n",
106844: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
106848: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
10684b: c7 04 24 00 ef 12 00 movl $0x12ef00,(%esp) <== NOT EXECUTED
106852: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
106855: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
106859: e8 c2 f9 ff ff call 106220 <jffs2_printk> <== NOT EXECUTED
goto out_erase_sem;
10685e: e9 a3 fc ff ff jmp 106506 <jffs2_mark_node_obsolete+0x146> <== NOT EXECUTED
for (p = &ic->nodes; (*p) != ref; p = &((*p)->next_in_ino))
106863: 8d 72 04 lea 0x4(%edx),%esi
106866: e9 7d fe ff ff jmp 1066e8 <jffs2_mark_node_obsolete+0x328>
pr_notice("raw node at 0x%08x is off the end of device!\n",
10686b: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
10686f: c7 04 24 d0 ed 12 00 movl $0x12edd0,(%esp) <== NOT EXECUTED
106876: e8 a5 f9 ff ff call 106220 <jffs2_printk> <== NOT EXECUTED
BUG();
10687b: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED
106882: 00
106883: c7 44 24 08 74 f0 12 movl $0x12f074,0x8(%esp) <== NOT EXECUTED
10688a: 00
10688b: c7 44 24 04 5b 02 00 movl $0x25b,0x4(%esp) <== NOT EXECUTED
106892: 00
106893: c7 04 24 08 ee 12 00 movl $0x12ee08,(%esp) <== NOT EXECUTED
10689a: e8 d1 73 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED
10689f: 90 nop
0010b630 <jffs2_mknod>:
size_t d_namelen,
int mode,
const unsigned char *data,
size_t datalen
)
{
10b630: 55 push %ebp
10b631: 89 e5 mov %esp,%ebp
10b633: 57 push %edi
10b634: 56 push %esi
10b635: 53 push %ebx
10b636: 83 ec 4c sub $0x4c,%esp
10b639: 8b 5d 1c mov 0x1c(%ebp),%ebx
uint32_t alloclen;
int ret;
/* FIXME: If you care. We'd need to use frags for the data
if it grows much more than this */
if (datalen > 254)
10b63c: 81 fb fe 00 00 00 cmp $0xfe,%ebx
10b642: 0f 87 f8 03 00 00 ja 10ba40 <jffs2_mknod+0x410> <== NEVER TAKEN
return -ENAMETOOLONG;
ri = jffs2_alloc_raw_inode();
10b648: e8 53 9b ff ff call 1051a0 <jffs2_alloc_raw_inode>
if (!ri)
10b64d: 85 c0 test %eax,%eax
ri = jffs2_alloc_raw_inode();
10b64f: 89 c7 mov %eax,%edi
if (!ri)
10b651: 0f 84 f3 03 00 00 je 10ba4a <jffs2_mknod+0x41a> <== NEVER TAKEN
return -ENOMEM;
c = JFFS2_SB_INFO(dir_i->i_sb);
10b657: 8b 45 08 mov 0x8(%ebp),%eax
/* 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) + datalen, &alloclen,
10b65a: ba 12 00 00 00 mov $0x12,%edx
10b65f: 31 c9 xor %ecx,%ecx
c = JFFS2_SB_INFO(dir_i->i_sb);
10b661: 8b 70 3c mov 0x3c(%eax),%esi
ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &alloclen,
10b664: 8d 43 44 lea 0x44(%ebx),%eax
10b667: 89 54 24 10 mov %edx,0x10(%esp)
10b66b: 8d 55 e4 lea -0x1c(%ebp),%edx
10b66e: 89 4c 24 0c mov %ecx,0xc(%esp)
10b672: 89 54 24 08 mov %edx,0x8(%esp)
10b676: 89 44 24 04 mov %eax,0x4(%esp)
10b67a: 89 34 24 mov %esi,(%esp)
10b67d: 89 45 d0 mov %eax,-0x30(%ebp)
10b680: e8 6b b5 ff ff call 106bf0 <jffs2_reserve_space>
ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
if (ret) {
10b685: 85 c0 test %eax,%eax
10b687: 0f 85 63 01 00 00 jne 10b7f0 <jffs2_mknod+0x1c0> <== NEVER TAKEN
jffs2_free_raw_inode(ri);
return ret;
}
inode = jffs2_new_inode(dir_i, mode, ri);
10b68d: 89 7c 24 08 mov %edi,0x8(%esp)
10b691: 8b 45 14 mov 0x14(%ebp),%eax
10b694: 89 44 24 04 mov %eax,0x4(%esp)
10b698: 8b 45 08 mov 0x8(%ebp),%eax
10b69b: 89 04 24 mov %eax,(%esp)
10b69e: e8 2d 7d ff ff call 1033d0 <jffs2_new_inode>
10b6a3: 89 45 d4 mov %eax,-0x2c(%ebp)
if (IS_ERR(inode)) {
10b6a6: 3d 18 fc ff ff cmp $0xfffffc18,%eax
10b6ab: 0f 87 1f 01 00 00 ja 10b7d0 <jffs2_mknod+0x1a0> <== NEVER TAKEN
return PTR_ERR(inode);
}
f = JFFS2_INODE_INFO(inode);
inode->i_size = datalen;
10b6b1: 8b 45 d4 mov -0x2c(%ebp),%eax
ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size);
10b6b4: 8b 55 d0 mov -0x30(%ebp),%edx
inode->i_size = datalen;
10b6b7: 89 58 34 mov %ebx,0x34(%eax)
10b6ba: c7 40 38 00 00 00 00 movl $0x0,0x38(%eax)
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
10b6c1: b8 08 00 00 00 mov $0x8,%eax
ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size);
10b6c6: 89 57 04 mov %edx,0x4(%edi)
ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
10b6c9: 89 5f 30 mov %ebx,0x30(%edi)
10b6cc: 89 5f 34 mov %ebx,0x34(%edi)
10b6cf: 89 5f 1c mov %ebx,0x1c(%edi)
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
10b6d2: 89 44 24 08 mov %eax,0x8(%esp)
10b6d6: 89 7c 24 04 mov %edi,0x4(%esp)
10b6da: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10b6e1: e8 aa f7 ff ff call 10ae90 <cyg_crc32_accumulate>
ri->compr = JFFS2_COMPR_NONE;
ri->data_crc = cpu_to_je32(crc32(0, data, datalen));
10b6e6: 8b 55 18 mov 0x18(%ebp),%edx
ri->compr = JFFS2_COMPR_NONE;
10b6e9: c6 47 38 00 movb $0x0,0x38(%edi)
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
10b6ed: 89 47 08 mov %eax,0x8(%edi)
ri->data_crc = cpu_to_je32(crc32(0, data, datalen));
10b6f0: 89 54 24 04 mov %edx,0x4(%esp)
10b6f4: 89 5c 24 08 mov %ebx,0x8(%esp)
10b6f8: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10b6ff: e8 8c f7 ff ff call 10ae90 <cyg_crc32_accumulate>
10b704: 89 47 3c mov %eax,0x3c(%edi)
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
10b707: b8 3c 00 00 00 mov $0x3c,%eax
10b70c: 89 44 24 08 mov %eax,0x8(%esp)
10b710: 89 7c 24 04 mov %edi,0x4(%esp)
10b714: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10b71b: e8 70 f7 ff ff call 10ae90 <cyg_crc32_accumulate>
fn = jffs2_write_dnode(c, f, ri, data, datalen, ALLOC_NORMAL);
10b720: 8b 55 18 mov 0x18(%ebp),%edx
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
10b723: 89 47 40 mov %eax,0x40(%edi)
fn = jffs2_write_dnode(c, f, ri, data, datalen, ALLOC_NORMAL);
10b726: 31 c0 xor %eax,%eax
10b728: 89 44 24 14 mov %eax,0x14(%esp)
f = JFFS2_INODE_INFO(inode);
10b72c: 8b 45 d4 mov -0x2c(%ebp),%eax
fn = jffs2_write_dnode(c, f, ri, data, datalen, ALLOC_NORMAL);
10b72f: 89 54 24 0c mov %edx,0xc(%esp)
10b733: 89 5c 24 10 mov %ebx,0x10(%esp)
10b737: 89 7c 24 08 mov %edi,0x8(%esp)
10b73b: 89 34 24 mov %esi,(%esp)
f = JFFS2_INODE_INFO(inode);
10b73e: 83 c0 44 add $0x44,%eax
10b741: 89 44 24 04 mov %eax,0x4(%esp)
fn = jffs2_write_dnode(c, f, ri, data, datalen, ALLOC_NORMAL);
10b745: e8 06 e0 ff ff call 109750 <jffs2_write_dnode>
jffs2_free_raw_inode(ri);
10b74a: 89 3c 24 mov %edi,(%esp)
fn = jffs2_write_dnode(c, f, ri, data, datalen, ALLOC_NORMAL);
10b74d: 89 45 d0 mov %eax,-0x30(%ebp)
jffs2_free_raw_inode(ri);
10b750: e8 6b 9a ff ff call 1051c0 <jffs2_free_raw_inode>
if (IS_ERR(fn)) {
10b755: 81 7d d0 18 fc ff ff cmpl $0xfffffc18,-0x30(%ebp)
10b75c: 0f 87 d7 01 00 00 ja 10b939 <jffs2_mknod+0x309> <== NEVER TAKEN
jffs2_complete_reservation(c);
ret = PTR_ERR(fn);
goto fail;
}
if (S_ISLNK(mode)) {
10b762: 8b 45 14 mov 0x14(%ebp),%eax
10b765: 25 00 f0 00 00 and $0xf000,%eax
10b76a: 3d 00 a0 00 00 cmp $0xa000,%eax
10b76f: 0f 84 db 01 00 00 je 10b950 <jffs2_mknod+0x320>
}
/* No data here. Only a metadata node, which will be
obsoleted by the first data write
*/
f->metadata = fn;
10b775: 8b 45 d4 mov -0x2c(%ebp),%eax
mutex_unlock(&f->sem);
jffs2_complete_reservation(c);
ret = jffs2_reserve_space(c, sizeof(*rd)+d_namelen, &alloclen,
10b778: 31 ff xor %edi,%edi
f->metadata = fn;
10b77a: 8b 55 d0 mov -0x30(%ebp),%edx
10b77d: 89 50 4c mov %edx,0x4c(%eax)
jffs2_complete_reservation(c);
10b780: 89 34 24 mov %esi,(%esp)
10b783: e8 08 ac ff ff call 106390 <jffs2_complete_reservation>
ret = jffs2_reserve_space(c, sizeof(*rd)+d_namelen, &alloclen,
10b788: 8b 45 10 mov 0x10(%ebp),%eax
10b78b: 89 7c 24 0c mov %edi,0xc(%esp)
10b78f: 89 34 24 mov %esi,(%esp)
10b792: 8d 58 28 lea 0x28(%eax),%ebx
ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(d_namelen));
10b795: 83 c0 18 add $0x18,%eax
ret = jffs2_reserve_space(c, sizeof(*rd)+d_namelen, &alloclen,
10b798: 89 44 24 10 mov %eax,0x10(%esp)
10b79c: 8d 45 e4 lea -0x1c(%ebp),%eax
10b79f: 89 44 24 08 mov %eax,0x8(%esp)
10b7a3: 89 5c 24 04 mov %ebx,0x4(%esp)
10b7a7: e8 44 b4 ff ff call 106bf0 <jffs2_reserve_space>
if (ret)
10b7ac: 85 c0 test %eax,%eax
ret = jffs2_reserve_space(c, sizeof(*rd)+d_namelen, &alloclen,
10b7ae: 89 c1 mov %eax,%ecx
if (ret)
10b7b0: 74 5e je 10b810 <jffs2_mknod+0x1e0> <== ALWAYS TAKEN
10b7b2: 89 4d d0 mov %ecx,-0x30(%ebp)
mutex_unlock(&dir_f->sem);
jffs2_complete_reservation(c);
fail:
jffs2_iput(inode);
10b7b5: 8b 45 d4 mov -0x2c(%ebp),%eax
10b7b8: 89 04 24 mov %eax,(%esp)
10b7bb: e8 40 74 ff ff call 102c00 <jffs2_iput>
return ret;
10b7c0: 8b 4d d0 mov -0x30(%ebp),%ecx
}
10b7c3: 83 c4 4c add $0x4c,%esp
10b7c6: 5b pop %ebx
10b7c7: 5e pop %esi
10b7c8: 89 c8 mov %ecx,%eax
10b7ca: 5f pop %edi
10b7cb: 5d pop %ebp
10b7cc: c3 ret
10b7cd: 8d 76 00 lea 0x0(%esi),%esi
jffs2_free_raw_inode(ri);
10b7d0: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10b7d3: e8 e8 99 ff ff call 1051c0 <jffs2_free_raw_inode> <== NOT EXECUTED
jffs2_complete_reservation(c);
10b7d8: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10b7db: e8 b0 ab ff ff call 106390 <jffs2_complete_reservation> <== NOT EXECUTED
return PTR_ERR(inode);
10b7e0: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED
}
10b7e3: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED
10b7e6: 89 c8 mov %ecx,%eax <== NOT EXECUTED
10b7e8: 5b pop %ebx <== NOT EXECUTED
10b7e9: 5e pop %esi <== NOT EXECUTED
10b7ea: 5f pop %edi <== NOT EXECUTED
10b7eb: 5d pop %ebp <== NOT EXECUTED
10b7ec: c3 ret <== NOT EXECUTED
10b7ed: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
jffs2_free_raw_inode(ri);
10b7f0: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10b7f3: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
10b7f6: e8 c5 99 ff ff call 1051c0 <jffs2_free_raw_inode> <== NOT EXECUTED
return ret;
10b7fb: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED
}
10b7fe: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED
10b801: 5b pop %ebx <== NOT EXECUTED
10b802: 5e pop %esi <== NOT EXECUTED
10b803: 89 c8 mov %ecx,%eax <== NOT EXECUTED
10b805: 5f pop %edi <== NOT EXECUTED
10b806: 5d pop %ebp <== NOT EXECUTED
10b807: c3 ret <== NOT EXECUTED
10b808: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10b80f: 90 nop <== NOT EXECUTED
10b810: 89 45 d0 mov %eax,-0x30(%ebp)
rd = jffs2_alloc_raw_dirent();
10b813: e8 58 99 ff ff call 105170 <jffs2_alloc_raw_dirent>
if (!rd) {
10b818: 8b 4d d0 mov -0x30(%ebp),%ecx
10b81b: 85 c0 test %eax,%eax
rd = jffs2_alloc_raw_dirent();
10b81d: 89 c7 mov %eax,%edi
if (!rd) {
10b81f: 0f 84 ff 01 00 00 je 10ba24 <jffs2_mknod+0x3f4> <== NEVER TAKEN
rd->totlen = cpu_to_je32(sizeof(*rd) + d_namelen);
10b825: 89 58 04 mov %ebx,0x4(%eax)
rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
10b828: c7 00 85 19 01 e0 movl $0xe0011985,(%eax)
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
10b82e: b8 08 00 00 00 mov $0x8,%eax
10b833: 89 44 24 08 mov %eax,0x8(%esp)
10b837: 89 7c 24 04 mov %edi,0x4(%esp)
10b83b: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10b842: 89 4d cc mov %ecx,-0x34(%ebp)
10b845: e8 46 f6 ff ff call 10ae90 <cyg_crc32_accumulate>
rd->version = cpu_to_je32(++dir_f->highest_version);
10b84a: 8b 55 08 mov 0x8(%ebp),%edx
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
10b84d: 89 47 08 mov %eax,0x8(%edi)
rd->pino = cpu_to_je32(dir_i->i_ino);
10b850: 8b 45 08 mov 0x8(%ebp),%eax
10b853: 8b 00 mov (%eax),%eax
10b855: 89 47 0c mov %eax,0xc(%edi)
rd->version = cpu_to_je32(++dir_f->highest_version);
10b858: 8b 45 08 mov 0x8(%ebp),%eax
10b85b: 8b 40 44 mov 0x44(%eax),%eax
10b85e: 89 45 d0 mov %eax,-0x30(%ebp)
10b861: 40 inc %eax
10b862: 89 42 44 mov %eax,0x44(%edx)
10b865: 89 47 10 mov %eax,0x10(%edi)
rd->ino = cpu_to_je32(inode->i_ino);
10b868: 8b 45 d4 mov -0x2c(%ebp),%eax
10b86b: 8b 00 mov (%eax),%eax
10b86d: 89 47 14 mov %eax,0x14(%edi)
rd->mctime = cpu_to_je32(get_seconds());
10b870: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10b877: e8 b4 f1 01 00 call 12aa30 <time>
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
10b87c: ba 20 00 00 00 mov $0x20,%edx
rd->mctime = cpu_to_je32(get_seconds());
10b881: 89 47 18 mov %eax,0x18(%edi)
rd->nsize = d_namelen;
10b884: 0f b6 45 10 movzbl 0x10(%ebp),%eax
10b888: 88 47 1c mov %al,0x1c(%edi)
rd->type = (mode & S_IFMT) >> 12;
10b88b: 8b 45 14 mov 0x14(%ebp),%eax
10b88e: c1 f8 0c sar $0xc,%eax
10b891: 24 0f and $0xf,%al
10b893: 88 47 1d mov %al,0x1d(%edi)
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
10b896: 89 54 24 08 mov %edx,0x8(%esp)
10b89a: 89 7c 24 04 mov %edi,0x4(%esp)
10b89e: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10b8a5: e8 e6 f5 ff ff call 10ae90 <cyg_crc32_accumulate>
10b8aa: 89 47 20 mov %eax,0x20(%edi)
rd->name_crc = cpu_to_je32(crc32(0, d_name, d_namelen));
10b8ad: 8b 45 10 mov 0x10(%ebp),%eax
10b8b0: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10b8b7: 89 44 24 08 mov %eax,0x8(%esp)
10b8bb: 8b 45 0c mov 0xc(%ebp),%eax
10b8be: 89 44 24 04 mov %eax,0x4(%esp)
10b8c2: e8 c9 f5 ff ff call 10ae90 <cyg_crc32_accumulate>
fd = jffs2_write_dirent(c, dir_f, rd, d_name, d_namelen, ALLOC_NORMAL);
10b8c7: 31 c9 xor %ecx,%ecx
rd->name_crc = cpu_to_je32(crc32(0, d_name, d_namelen));
10b8c9: 89 47 24 mov %eax,0x24(%edi)
fd = jffs2_write_dirent(c, dir_f, rd, d_name, d_namelen, ALLOC_NORMAL);
10b8cc: 8b 45 10 mov 0x10(%ebp),%eax
10b8cf: 89 4c 24 14 mov %ecx,0x14(%esp)
10b8d3: 89 7c 24 08 mov %edi,0x8(%esp)
10b8d7: 89 34 24 mov %esi,(%esp)
10b8da: 89 44 24 10 mov %eax,0x10(%esp)
10b8de: 8b 45 0c mov 0xc(%ebp),%eax
10b8e1: 89 44 24 0c mov %eax,0xc(%esp)
dir_f = JFFS2_INODE_INFO(dir_i);
10b8e5: 8b 45 08 mov 0x8(%ebp),%eax
10b8e8: 83 c0 44 add $0x44,%eax
10b8eb: 89 44 24 04 mov %eax,0x4(%esp)
fd = jffs2_write_dirent(c, dir_f, rd, d_name, d_namelen, ALLOC_NORMAL);
10b8ef: e8 fc e1 ff ff call 109af0 <jffs2_write_dirent>
if (IS_ERR(fd)) {
10b8f4: 8b 4d cc mov -0x34(%ebp),%ecx
10b8f7: 3d 18 fc ff ff cmp $0xfffffc18,%eax
fd = jffs2_write_dirent(c, dir_f, rd, d_name, d_namelen, ALLOC_NORMAL);
10b8fc: 89 c3 mov %eax,%ebx
if (IS_ERR(fd)) {
10b8fe: 0f 87 ec 00 00 00 ja 10b9f0 <jffs2_mknod+0x3c0> <== NEVER TAKEN
10b904: 89 4d d0 mov %ecx,-0x30(%ebp)
dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime));
10b907: 8b 47 18 mov 0x18(%edi),%eax
10b90a: 31 d2 xor %edx,%edx
10b90c: 8b 4d 08 mov 0x8(%ebp),%ecx
10b90f: 89 41 24 mov %eax,0x24(%ecx)
10b912: 89 41 1c mov %eax,0x1c(%ecx)
10b915: 89 51 28 mov %edx,0x28(%ecx)
10b918: 89 51 20 mov %edx,0x20(%ecx)
jffs2_free_raw_dirent(rd);
10b91b: 89 3c 24 mov %edi,(%esp)
10b91e: e8 6d 98 ff ff call 105190 <jffs2_free_raw_dirent>
jffs2_add_fd_to_list(c, fd, &dir_f->dents);
10b923: 8b 45 08 mov 0x8(%ebp),%eax
10b926: 89 5c 24 04 mov %ebx,0x4(%esp)
10b92a: 89 34 24 mov %esi,(%esp)
10b92d: 83 c0 50 add $0x50,%eax
10b930: 89 44 24 08 mov %eax,0x8(%esp)
10b934: e8 17 9b ff ff call 105450 <jffs2_add_fd_to_list>
jffs2_complete_reservation(c);
10b939: 89 34 24 mov %esi,(%esp)
10b93c: e8 4f aa ff ff call 106390 <jffs2_complete_reservation>
10b941: 8b 4d d0 mov -0x30(%ebp),%ecx
10b944: e9 69 fe ff ff jmp 10b7b2 <jffs2_mknod+0x182>
10b949: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
f->target = kmemdup(data, datalen + 1, GFP_KERNEL);
10b950: 8d 7b 01 lea 0x1(%ebx),%edi
char *dup = malloc(n + 1);
10b953: 83 c3 02 add $0x2,%ebx
10b956: 89 1c 24 mov %ebx,(%esp)
10b959: 89 7d cc mov %edi,-0x34(%ebp)
10b95c: e8 bf 2b 00 00 call 10e520 <malloc>
if (dup != 0) {
10b961: 85 c0 test %eax,%eax
char *dup = malloc(n + 1);
10b963: 89 c2 mov %eax,%edx
if (dup != 0) {
10b965: 0f 84 9c 00 00 00 je 10ba07 <jffs2_mknod+0x3d7> <== NEVER TAKEN
dup[n] = '\0';
10b96b: c6 04 38 00 movb $0x0,(%eax,%edi,1)
dup = memcpy(dup, s, n);
10b96f: 83 ff 04 cmp $0x4,%edi
10b972: 89 c3 mov %eax,%ebx
10b974: 8b 45 18 mov 0x18(%ebp),%eax
10b977: 73 47 jae 10b9c0 <jffs2_mknod+0x390> <== ALWAYS TAKEN
10b979: 31 c9 xor %ecx,%ecx
10b97b: f6 45 cc 02 testb $0x2,-0x34(%ebp)
10b97f: 75 2f jne 10b9b0 <jffs2_mknod+0x380>
10b981: f6 45 cc 01 testb $0x1,-0x34(%ebp)
10b985: 75 19 jne 10b9a0 <jffs2_mknod+0x370> <== ALWAYS TAKEN
10b987: 8b 45 d4 mov -0x2c(%ebp),%eax
10b98a: 89 50 54 mov %edx,0x54(%eax)
if (!f->target) {
10b98d: e9 e3 fd ff ff jmp 10b775 <jffs2_mknod+0x145>
10b992: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b999: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b9a0: 0f b6 04 08 movzbl (%eax,%ecx,1),%eax
10b9a4: 88 04 0b mov %al,(%ebx,%ecx,1)
10b9a7: eb de jmp 10b987 <jffs2_mknod+0x357>
10b9a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b9b0: 0f b7 08 movzwl (%eax),%ecx
10b9b3: 66 89 0b mov %cx,(%ebx)
10b9b6: b9 02 00 00 00 mov $0x2,%ecx
10b9bb: eb c4 jmp 10b981 <jffs2_mknod+0x351>
10b9bd: 8d 76 00 lea 0x0(%esi),%esi
10b9c0: 83 e7 fc and $0xfffffffc,%edi
10b9c3: 31 c0 xor %eax,%eax
10b9c5: 89 f9 mov %edi,%ecx
10b9c7: 8b 7d 18 mov 0x18(%ebp),%edi
10b9ca: 8b 1c 07 mov (%edi,%eax,1),%ebx
10b9cd: 89 1c 02 mov %ebx,(%edx,%eax,1)
10b9d0: 83 c0 04 add $0x4,%eax
10b9d3: 39 c8 cmp %ecx,%eax
10b9d5: 72 f3 jb 10b9ca <jffs2_mknod+0x39a> <== NEVER TAKEN
10b9d7: 8b 4d 18 mov 0x18(%ebp),%ecx
10b9da: 8d 1c 02 lea (%edx,%eax,1),%ebx
10b9dd: 01 c8 add %ecx,%eax
10b9df: eb 98 jmp 10b979 <jffs2_mknod+0x349>
10b9e1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b9e8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10b9ef: 90 nop
jffs2_complete_reservation(c);
10b9f0: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10b9f3: e8 98 a9 ff ff call 106390 <jffs2_complete_reservation> <== NOT EXECUTED
jffs2_free_raw_dirent(rd);
10b9f8: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10b9fb: e8 90 97 ff ff call 105190 <jffs2_free_raw_dirent> <== NOT EXECUTED
ret = PTR_ERR(fd);
10ba00: 89 d9 mov %ebx,%ecx <== NOT EXECUTED
goto fail;
10ba02: e9 ab fd ff ff jmp 10b7b2 <jffs2_mknod+0x182> <== NOT EXECUTED
f->target = kmemdup(data, datalen + 1, GFP_KERNEL);
10ba07: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED
10ba0a: c7 40 54 00 00 00 00 movl $0x0,0x54(%eax) <== NOT EXECUTED
pr_warn("Can't allocate %d bytes of memory\n", datalen + 1);
10ba11: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED
10ba14: c7 04 24 4c 06 13 00 movl $0x13064c,(%esp) <== NOT EXECUTED
10ba1b: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10ba1f: e8 bc f8 ff ff call 10b2e0 <jffs2_printk> <== NOT EXECUTED
jffs2_complete_reservation(c);
10ba24: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10ba27: e8 64 a9 ff ff call 106390 <jffs2_complete_reservation> <== NOT EXECUTED
ret = -ENOMEM;
10ba2c: b9 f4 ff ff ff mov $0xfffffff4,%ecx <== NOT EXECUTED
goto fail;
10ba31: e9 7c fd ff ff jmp 10b7b2 <jffs2_mknod+0x182> <== NOT EXECUTED
10ba36: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10ba3d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
return -ENAMETOOLONG;
10ba40: b9 a5 ff ff ff mov $0xffffffa5,%ecx <== NOT EXECUTED
10ba45: e9 99 fd ff ff jmp 10b7e3 <jffs2_mknod+0x1b3> <== NOT EXECUTED
return -ENOMEM;
10ba4a: b9 f4 ff ff ff mov $0xfffffff4,%ecx <== NOT EXECUTED
10ba4f: e9 8f fd ff ff jmp 10b7e3 <jffs2_mknod+0x1b3> <== NOT EXECUTED
10ba54: 90 nop
10ba55: 90 nop
10ba56: 90 nop
10ba57: 90 nop
10ba58: 90 nop
10ba59: 90 nop
10ba5a: 90 nop
10ba5b: 90 nop
10ba5c: 90 nop
10ba5d: 90 nop
10ba5e: 90 nop
10ba5f: 90 nop
001033d0 <jffs2_new_inode>:
{
1033d0: 55 push %ebp
1033d1: 89 e5 mov %esp,%ebp
1033d3: 57 push %edi
1033d4: 56 push %esi
1033d5: 53 push %ebx
1033d6: 83 ec 2c sub $0x2c,%esp
struct super_block *sb = dir_i->i_sb;
1033d9: 8b 45 08 mov 0x8(%ebp),%eax
{
1033dc: 8b 75 10 mov 0x10(%ebp),%esi
struct super_block *sb = dir_i->i_sb;
1033df: 8b 40 3c mov 0x3c(%eax),%eax
1033e2: 89 45 dc mov %eax,-0x24(%ebp)
inode = new_inode(sb);
1033e5: e8 c6 e0 ff ff call 1014b0 <new_inode>
if (!inode)
1033ea: 85 c0 test %eax,%eax
1033ec: 0f 84 ee 01 00 00 je 1035e0 <jffs2_new_inode+0x210> <== NEVER TAKEN
1033f2: 89 c3 mov %eax,%ebx
memset(f, 0, sizeof(*f));
1033f4: 31 ff xor %edi,%edi
f = JFFS2_INODE_INFO(inode);
1033f6: 8d 40 44 lea 0x44(%eax),%eax
memset(f, 0, sizeof(*f));
1033f9: b9 1c 00 00 00 mov $0x1c,%ecx
f = JFFS2_INODE_INFO(inode);
1033fe: 89 45 e0 mov %eax,-0x20(%ebp)
memset(f, 0, sizeof(*f));
103401: a8 01 test $0x1,%al
103403: 0f 85 57 02 00 00 jne 103660 <jffs2_new_inode+0x290> <== NEVER TAKEN
103409: a8 02 test $0x2,%al
10340b: 0f 85 6f 02 00 00 jne 103680 <jffs2_new_inode+0x2b0> <== NEVER TAKEN
103411: 89 ca mov %ecx,%edx
103413: 83 e2 f8 and $0xfffffff8,%edx
103416: 89 55 e4 mov %edx,-0x1c(%ebp)
103419: 31 d2 xor %edx,%edx
10341b: 89 3c 10 mov %edi,(%eax,%edx,1)
10341e: 89 7c 10 04 mov %edi,0x4(%eax,%edx,1)
103422: 83 c2 08 add $0x8,%edx
103425: 3b 55 e4 cmp -0x1c(%ebp),%edx
103428: 72 f1 jb 10341b <jffs2_new_inode+0x4b>
10342a: 01 d0 add %edx,%eax
10342c: f6 c1 04 test $0x4,%cl
10342f: 0f 85 1b 01 00 00 jne 103550 <jffs2_new_inode+0x180> <== ALWAYS TAKEN
103435: f6 c1 02 test $0x2,%cl <== NOT EXECUTED
103438: 0f 85 f2 00 00 00 jne 103530 <jffs2_new_inode+0x160> <== NOT EXECUTED
10343e: f6 c1 01 test $0x1,%cl
103441: 0f 85 d9 00 00 00 jne 103520 <jffs2_new_inode+0x150> <== NEVER TAKEN
memset(ri, 0, sizeof(*ri));
103447: 31 c9 xor %ecx,%ecx
103449: f7 c6 01 00 00 00 test $0x1,%esi
10344f: 89 f2 mov %esi,%edx
103451: bf 44 00 00 00 mov $0x44,%edi
103456: 0f 85 e4 01 00 00 jne 103640 <jffs2_new_inode+0x270> <== NEVER TAKEN
10345c: f6 c2 02 test $0x2,%dl
10345f: 0f 85 eb 01 00 00 jne 103650 <jffs2_new_inode+0x280> <== NEVER TAKEN
103465: 89 f8 mov %edi,%eax
103467: 83 e0 f8 and $0xfffffff8,%eax
10346a: 89 45 e4 mov %eax,-0x1c(%ebp)
10346d: 31 c0 xor %eax,%eax
10346f: 89 0c 02 mov %ecx,(%edx,%eax,1)
103472: 89 4c 02 04 mov %ecx,0x4(%edx,%eax,1)
103476: 83 c0 08 add $0x8,%eax
103479: 3b 45 e4 cmp -0x1c(%ebp),%eax
10347c: 72 f1 jb 10346f <jffs2_new_inode+0x9f>
10347e: 01 c2 add %eax,%edx
103480: f7 c7 04 00 00 00 test $0x4,%edi
103486: 0f 85 94 01 00 00 jne 103620 <jffs2_new_inode+0x250> <== ALWAYS TAKEN
10348c: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
103492: 0f 85 68 01 00 00 jne 103600 <jffs2_new_inode+0x230> <== NOT EXECUTED
103498: 83 e7 01 and $0x1,%edi
10349b: 0f 85 4f 01 00 00 jne 1035f0 <jffs2_new_inode+0x220> <== NEVER TAKEN
ri->uid = cpu_to_je16(geteuid());
1034a1: e8 8a ad 00 00 call 10e230 <geteuid>
1034a6: 66 89 46 18 mov %ax,0x18(%esi)
ri->gid = cpu_to_je16(getegid());
1034aa: e8 61 ad 00 00 call 10e210 <getegid>
1034af: 66 89 46 1a mov %ax,0x1a(%esi)
return osmode & (S_IFMT | S_IRWXU | S_IRWXG | S_IRWXO);
1034b3: 8b 45 0c mov 0xc(%ebp),%eax
1034b6: 25 ff f1 00 00 and $0xf1ff,%eax
1034bb: 89 46 14 mov %eax,0x14(%esi)
ret = jffs2_do_new_inode (c, f, mode, ri);
1034be: 8b 45 0c mov 0xc(%ebp),%eax
1034c1: 89 74 24 0c mov %esi,0xc(%esp)
1034c5: 89 44 24 08 mov %eax,0x8(%esp)
1034c9: 8b 45 e0 mov -0x20(%ebp),%eax
1034cc: 89 44 24 04 mov %eax,0x4(%esp)
1034d0: 8b 45 dc mov -0x24(%ebp),%eax
1034d3: 89 04 24 mov %eax,(%esp)
1034d6: e8 05 61 00 00 call 1095e0 <jffs2_do_new_inode>
if (ret) {
1034db: 85 c0 test %eax,%eax
ret = jffs2_do_new_inode (c, f, mode, ri);
1034dd: 89 c7 mov %eax,%edi
if (ret) {
1034df: 0f 84 8b 00 00 00 je 103570 <jffs2_new_inode+0x1a0> <== ALWAYS TAKEN
if (inode->i_cache_prev)
1034e5: 8b 53 60 mov 0x60(%ebx),%edx <== NOT EXECUTED
inode->i_cache_prev->i_cache_next = inode->i_cache_next;
1034e8: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED
if (inode->i_cache_prev)
1034eb: 85 d2 test %edx,%edx <== NOT EXECUTED
1034ed: 74 03 je 1034f2 <jffs2_new_inode+0x122> <== NOT EXECUTED
inode->i_cache_prev->i_cache_next = inode->i_cache_next;
1034ef: 89 42 64 mov %eax,0x64(%edx) <== NOT EXECUTED
if (inode->i_cache_next)
1034f2: 85 c0 test %eax,%eax <== NOT EXECUTED
1034f4: 74 03 je 1034f9 <jffs2_new_inode+0x129> <== NOT EXECUTED
inode->i_cache_next->i_cache_prev = inode->i_cache_prev;
1034f6: 89 50 60 mov %edx,0x60(%eax) <== NOT EXECUTED
jffs2_do_clear_inode(c, f);
1034f9: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
1034fc: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
103500: 8b 43 3c mov 0x3c(%ebx),%eax <== NOT EXECUTED
103503: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
103506: e8 05 5f 00 00 call 109410 <jffs2_do_clear_inode> <== NOT EXECUTED
free(inode);
10350b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
return ERR_PTR(ret);
10350e: 89 fb mov %edi,%ebx <== NOT EXECUTED
free(inode);
103510: e8 1b ac 00 00 call 10e130 <free> <== NOT EXECUTED
}
103515: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
103518: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10351a: 5b pop %ebx <== NOT EXECUTED
10351b: 5e pop %esi <== NOT EXECUTED
10351c: 5f pop %edi <== NOT EXECUTED
10351d: 5d pop %ebp <== NOT EXECUTED
10351e: c3 ret <== NOT EXECUTED
10351f: 90 nop <== NOT EXECUTED
memset(f, 0, sizeof(*f));
103520: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED
103523: e9 1f ff ff ff jmp 103447 <jffs2_new_inode+0x77> <== NOT EXECUTED
103528: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10352f: 90 nop <== NOT EXECUTED
103530: 66 c7 00 00 00 movw $0x0,(%eax) <== NOT EXECUTED
103535: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
103538: f6 c1 01 test $0x1,%cl <== NOT EXECUTED
10353b: 0f 84 06 ff ff ff je 103447 <jffs2_new_inode+0x77> <== NOT EXECUTED
103541: eb dd jmp 103520 <jffs2_new_inode+0x150> <== NOT EXECUTED
103543: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10354a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
103550: c7 00 00 00 00 00 movl $0x0,(%eax)
103556: 83 c0 04 add $0x4,%eax
103559: f6 c1 02 test $0x2,%cl
10355c: 0f 84 dc fe ff ff je 10343e <jffs2_new_inode+0x6e> <== ALWAYS TAKEN
103562: eb cc jmp 103530 <jffs2_new_inode+0x160> <== NOT EXECUTED
103564: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10356b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10356f: 90 nop <== NOT EXECUTED
inode->i_nlink = 1;
103570: 66 c7 43 0c 01 00 movw $0x1,0xc(%ebx)
inode->i_ino = je32_to_cpu(ri->ino);
103576: 8b 46 0c mov 0xc(%esi),%eax
103579: 89 03 mov %eax,(%ebx)
return jmode & (S_IFMT | S_IRWXU | S_IRWXG | S_IRWXO);
10357b: 8b 46 14 mov 0x14(%esi),%eax
10357e: 25 ff f1 00 00 and $0xf1ff,%eax
inode->i_mode = jemode_to_cpu(ri->mode);
103583: 89 43 08 mov %eax,0x8(%ebx)
inode->i_gid = je16_to_cpu(ri->gid);
103586: 0f b7 46 1a movzwl 0x1a(%esi),%eax
10358a: 66 89 43 10 mov %ax,0x10(%ebx)
inode->i_uid = je16_to_cpu(ri->uid);
10358e: 0f b7 46 18 movzwl 0x18(%esi),%eax
103592: 66 89 43 0e mov %ax,0xe(%ebx)
inode->i_atime = inode->i_ctime = inode->i_mtime = get_seconds();
103596: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10359d: e8 8e 74 02 00 call 12aa30 <time>
1035a2: 89 43 1c mov %eax,0x1c(%ebx)
1035a5: 89 43 24 mov %eax,0x24(%ebx)
1035a8: 89 43 14 mov %eax,0x14(%ebx)
1035ab: 89 53 20 mov %edx,0x20(%ebx)
1035ae: 89 53 28 mov %edx,0x28(%ebx)
1035b1: 89 53 18 mov %edx,0x18(%ebx)
ri->atime = ri->mtime = ri->ctime = cpu_to_je32(inode->i_mtime);
1035b4: 89 46 28 mov %eax,0x28(%esi)
1035b7: 89 46 24 mov %eax,0x24(%esi)
1035ba: 89 46 20 mov %eax,0x20(%esi)
}
1035bd: 89 d8 mov %ebx,%eax
inode->i_size = 0;
1035bf: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx)
1035c6: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx)
}
1035cd: 83 c4 2c add $0x2c,%esp
1035d0: 5b pop %ebx
1035d1: 5e pop %esi
1035d2: 5f pop %edi
1035d3: 5d pop %ebp
1035d4: c3 ret
1035d5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1035dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1035e0: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
return ERR_PTR(-ENOMEM);
1035e3: bb f4 ff ff ff mov $0xfffffff4,%ebx <== NOT EXECUTED
}
1035e8: 89 d8 mov %ebx,%eax <== NOT EXECUTED
1035ea: 5b pop %ebx <== NOT EXECUTED
1035eb: 5e pop %esi <== NOT EXECUTED
1035ec: 5f pop %edi <== NOT EXECUTED
1035ed: 5d pop %ebp <== NOT EXECUTED
1035ee: c3 ret <== NOT EXECUTED
1035ef: 90 nop <== NOT EXECUTED
memset(ri, 0, sizeof(*ri));
1035f0: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
1035f3: e9 a9 fe ff ff jmp 1034a1 <jffs2_new_inode+0xd1> <== NOT EXECUTED
1035f8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1035ff: 90 nop <== NOT EXECUTED
103600: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
103605: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
103608: 83 e7 01 and $0x1,%edi <== NOT EXECUTED
10360b: 0f 84 90 fe ff ff je 1034a1 <jffs2_new_inode+0xd1> <== NOT EXECUTED
103611: eb dd jmp 1035f0 <jffs2_new_inode+0x220> <== NOT EXECUTED
103613: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10361a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
103620: c7 02 00 00 00 00 movl $0x0,(%edx)
103626: 83 c2 04 add $0x4,%edx
103629: f7 c7 02 00 00 00 test $0x2,%edi
10362f: 0f 84 63 fe ff ff je 103498 <jffs2_new_inode+0xc8> <== ALWAYS TAKEN
103635: eb c9 jmp 103600 <jffs2_new_inode+0x230> <== NOT EXECUTED
103637: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10363e: 66 90 xchg %ax,%ax <== NOT EXECUTED
103640: c6 06 00 movb $0x0,(%esi) <== NOT EXECUTED
103643: 8d 56 01 lea 0x1(%esi),%edx <== NOT EXECUTED
103646: bf 43 00 00 00 mov $0x43,%edi <== NOT EXECUTED
10364b: e9 0c fe ff ff jmp 10345c <jffs2_new_inode+0x8c> <== NOT EXECUTED
103650: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
103655: 83 ef 02 sub $0x2,%edi <== NOT EXECUTED
103658: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
10365b: e9 05 fe ff ff jmp 103465 <jffs2_new_inode+0x95> <== NOT EXECUTED
memset(f, 0, sizeof(*f));
103660: c6 43 44 00 movb $0x0,0x44(%ebx) <== NOT EXECUTED
103664: 8d 43 45 lea 0x45(%ebx),%eax <== NOT EXECUTED
103667: b9 1b 00 00 00 mov $0x1b,%ecx <== NOT EXECUTED
10366c: e9 98 fd ff ff jmp 103409 <jffs2_new_inode+0x39> <== NOT EXECUTED
103671: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
103678: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10367f: 90 nop <== NOT EXECUTED
103680: 66 c7 00 00 00 movw $0x0,(%eax) <== NOT EXECUTED
103685: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
103688: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
10368b: e9 81 fd ff ff jmp 103411 <jffs2_new_inode+0x41> <== NOT EXECUTED
00105200 <jffs2_prealloc_raw_node_refs>:
return ret;
}
int jffs2_prealloc_raw_node_refs(struct jffs2_sb_info *c,
struct jffs2_eraseblock *jeb, int nr)
{
105200: 55 push %ebp
105201: 89 e5 mov %esp,%ebp
105203: 57 push %edi
105204: 56 push %esi
105205: 53 push %ebx
105206: 83 ec 1c sub $0x1c,%esp
105209: 8b 5d 0c mov 0xc(%ebp),%ebx
struct jffs2_raw_node_ref **p, *ref;
int i = nr;
p = &jeb->last_node;
ref = *p;
10520c: 8b 53 2c mov 0x2c(%ebx),%edx
p = &jeb->last_node;
10520f: 8d 7b 2c lea 0x2c(%ebx),%edi
/* If jeb->last_node is really a valid node then skip over it */
if (ref && ref->flash_offset != REF_EMPTY_NODE)
105212: 85 d2 test %edx,%edx
105214: 74 09 je 10521f <jffs2_prealloc_raw_node_refs+0x1f>
105216: 83 7a 04 fe cmpl $0xfffffffe,0x4(%edx)
10521a: 74 03 je 10521f <jffs2_prealloc_raw_node_refs+0x1f> <== NEVER TAKEN
ref++;
10521c: 83 c2 08 add $0x8,%edx
while (i) {
10521f: 8b 75 10 mov 0x10(%ebp),%esi
105222: 85 f6 test %esi,%esi
105224: 74 1a je 105240 <jffs2_prealloc_raw_node_refs+0x40> <== NEVER TAKEN
105226: 8b 75 10 mov 0x10(%ebp),%esi
105229: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if (!ref) {
105230: 85 d2 test %edx,%edx
105232: 74 24 je 105258 <jffs2_prealloc_raw_node_refs+0x58>
ref = *p = jffs2_alloc_refblock();
if (!ref)
return -ENOMEM;
}
if (ref->flash_offset == REF_LINK_NODE) {
105234: 83 7a 04 ff cmpl $0xffffffff,0x4(%edx)
105238: 74 16 je 105250 <jffs2_prealloc_raw_node_refs+0x50>
p = &ref->next_in_ino;
ref = *p;
continue;
}
i--;
ref++;
10523a: 83 c2 08 add $0x8,%edx
while (i) {
10523d: 4e dec %esi
10523e: 75 f0 jne 105230 <jffs2_prealloc_raw_node_refs+0x30> <== NEVER TAKEN
}
jeb->allocated_refs = nr;
105240: 8b 45 10 mov 0x10(%ebp),%eax
105243: 89 43 24 mov %eax,0x24(%ebx)
return 0;
105246: 31 c0 xor %eax,%eax
}
105248: 83 c4 1c add $0x1c,%esp
10524b: 5b pop %ebx
10524c: 5e pop %esi
10524d: 5f pop %edi
10524e: 5d pop %ebp
10524f: c3 ret
p = &ref->next_in_ino;
105250: 89 d7 mov %edx,%edi
ref = *p;
105252: 8b 12 mov (%edx),%edx
if (!ref) {
105254: 85 d2 test %edx,%edx
105256: 75 dc jne 105234 <jffs2_prealloc_raw_node_refs+0x34> <== NEVER TAKEN
ret = malloc((REFS_PER_BLOCK + 1) * sizeof(*ret));
105258: c7 04 24 f8 00 00 00 movl $0xf8,(%esp)
10525f: e8 bc 92 00 00 call 10e520 <malloc>
if (ret) {
105264: 85 c0 test %eax,%eax
ret = malloc((REFS_PER_BLOCK + 1) * sizeof(*ret));
105266: 89 c2 mov %eax,%edx
if (ret) {
105268: 74 32 je 10529c <jffs2_prealloc_raw_node_refs+0x9c> <== NEVER TAKEN
10526a: 8d 88 f0 00 00 00 lea 0xf0(%eax),%ecx
ret[i].flash_offset = REF_EMPTY_NODE;
105270: c7 40 04 fe ff ff ff movl $0xfffffffe,0x4(%eax)
for (i=0; i < REFS_PER_BLOCK; i++) {
105277: 83 c0 08 add $0x8,%eax
ret[i].next_in_ino = NULL;
10527a: c7 40 f8 00 00 00 00 movl $0x0,-0x8(%eax)
for (i=0; i < REFS_PER_BLOCK; i++) {
105281: 39 c1 cmp %eax,%ecx
105283: 75 eb jne 105270 <jffs2_prealloc_raw_node_refs+0x70>
ret[i].flash_offset = REF_LINK_NODE;
105285: b8 ff ff ff ff mov $0xffffffff,%eax
ret[i].next_in_ino = NULL;
10528a: 31 c9 xor %ecx,%ecx
ret[i].flash_offset = REF_LINK_NODE;
10528c: 89 82 f4 00 00 00 mov %eax,0xf4(%edx)
ret[i].next_in_ino = NULL;
105292: 89 8a f0 00 00 00 mov %ecx,0xf0(%edx)
ref = *p = jffs2_alloc_refblock();
105298: 89 17 mov %edx,(%edi)
if (!ref)
10529a: eb 98 jmp 105234 <jffs2_prealloc_raw_node_refs+0x34>
ref = *p = jffs2_alloc_refblock();
10529c: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
return -ENOMEM;
1052a2: b8 f4 ff ff ff mov $0xfffffff4,%eax <== NOT EXECUTED
1052a7: eb 9f jmp 105248 <jffs2_prealloc_raw_node_refs+0x48> <== NOT EXECUTED
1052a9: 90 nop
1052aa: 90 nop
1052ab: 90 nop
1052ac: 90 nop
1052ad: 90 nop
1052ae: 90 nop
1052af: 90 nop
00106df0 <jffs2_read_dnode>:
#include "compr.h"
int jffs2_read_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
struct jffs2_full_dnode *fd, unsigned char *buf,
int ofs, int len)
{
106df0: 55 push %ebp
106df1: 89 e5 mov %esp,%ebp
106df3: 57 push %edi
106df4: 56 push %esi
106df5: 53 push %ebx
106df6: 83 ec 4c sub $0x4c,%esp
106df9: 8b 75 10 mov 0x10(%ebp),%esi
uint32_t crc;
unsigned char *decomprbuf = NULL;
unsigned char *readbuf = NULL;
int ret = 0;
ri = jffs2_alloc_raw_inode();
106dfc: e8 9f e3 ff ff call 1051a0 <jffs2_alloc_raw_inode>
if (!ri)
106e01: 85 c0 test %eax,%eax
106e03: 0f 84 93 04 00 00 je 10729c <jffs2_read_dnode+0x4ac> <== NEVER TAKEN
return -ENOMEM;
ret = jffs2_flash_read(c, ref_offset(fd->raw), sizeof(*ri), &readlen, (char *)ri);
106e09: 89 44 24 10 mov %eax,0x10(%esp)
106e0d: 8d 7d e4 lea -0x1c(%ebp),%edi
106e10: 89 c3 mov %eax,%ebx
106e12: 89 7c 24 0c mov %edi,0xc(%esp)
106e16: b8 44 00 00 00 mov $0x44,%eax
106e1b: 89 44 24 08 mov %eax,0x8(%esp)
106e1f: 8b 06 mov (%esi),%eax
106e21: 8b 40 04 mov 0x4(%eax),%eax
106e24: 83 e0 fc and $0xfffffffc,%eax
106e27: 89 44 24 04 mov %eax,0x4(%esp)
106e2b: 8b 45 08 mov 0x8(%ebp),%eax
106e2e: 89 04 24 mov %eax,(%esp)
106e31: e8 2a 54 00 00 call 10c260 <jffs2_flash_read>
if (ret) {
106e36: 85 c0 test %eax,%eax
106e38: 0f 85 52 01 00 00 jne 106f90 <jffs2_read_dnode+0x1a0> <== NEVER TAKEN
jffs2_free_raw_inode(ri);
pr_warn("Error reading node from 0x%08x: %d\n",
ref_offset(fd->raw), ret);
return ret;
}
if (readlen != sizeof(*ri)) {
106e3e: 83 7d e4 44 cmpl $0x44,-0x1c(%ebp)
106e42: 0f 85 e8 03 00 00 jne 107230 <jffs2_read_dnode+0x440> <== NEVER TAKEN
jffs2_free_raw_inode(ri);
pr_warn("Short read from 0x%08x: wanted 0x%zx bytes, got 0x%zx\n",
ref_offset(fd->raw), sizeof(*ri), readlen);
return -EIO;
}
crc = crc32(0, ri, sizeof(*ri)-8);
106e48: 89 5c 24 04 mov %ebx,0x4(%esp)
106e4c: b9 3c 00 00 00 mov $0x3c,%ecx
106e51: 89 4c 24 08 mov %ecx,0x8(%esp)
106e55: c7 04 24 00 00 00 00 movl $0x0,(%esp)
106e5c: e8 2f 40 00 00 call 10ae90 <cyg_crc32_accumulate>
jffs2_dbg(1, "Node read from %08x: node_crc %08x, calculated CRC %08x. dsize %x, csize %x, offset %x, buf %p\n",
ref_offset(fd->raw), je32_to_cpu(ri->node_crc),
crc, je32_to_cpu(ri->dsize), je32_to_cpu(ri->csize),
je32_to_cpu(ri->offset), buf);
if (crc != je32_to_cpu(ri->node_crc)) {
106e61: 8b 53 40 mov 0x40(%ebx),%edx
106e64: 39 c2 cmp %eax,%edx
106e66: 0f 85 f4 00 00 00 jne 106f60 <jffs2_read_dnode+0x170> <== NEVER TAKEN
ret = -EIO;
goto out_ri;
}
/* There was a bug where we wrote hole nodes out with csize/dsize
swapped. Deal with it */
if (ri->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(ri->dsize) &&
106e6c: 0f b6 43 38 movzbl 0x38(%ebx),%eax
106e70: 3c 01 cmp $0x1,%al
106e72: 0f 84 58 01 00 00 je 106fd0 <jffs2_read_dnode+0x1e0>
Reading whole node and it's uncompressed - read directly to buffer provided, check CRC.
Reading whole node and it's compressed - read into comprbuf, check CRC and decompress to buffer provided
Reading partial node and it's uncompressed - read into readbuf, check CRC, and copy
Reading partial node and it's compressed - read into readbuf, check checksum, decompress to decomprbuf and copy
*/
if (ri->compr == JFFS2_COMPR_NONE && len == je32_to_cpu(ri->dsize)) {
106e78: 84 c0 test %al,%al
je32_to_cpu(ri->csize)) {
106e7a: 8b 4b 30 mov 0x30(%ebx),%ecx
if (ri->compr == JFFS2_COMPR_NONE && len == je32_to_cpu(ri->dsize)) {
106e7d: 0f 85 8d 01 00 00 jne 107010 <jffs2_read_dnode+0x220>
106e83: 8b 45 1c mov 0x1c(%ebp),%eax
106e86: 39 43 34 cmp %eax,0x34(%ebx)
106e89: 0f 84 b1 01 00 00 je 107040 <jffs2_read_dnode+0x250>
readbuf = buf;
} else {
readbuf = kmalloc(je32_to_cpu(ri->csize), GFP_KERNEL);
106e8f: 89 0c 24 mov %ecx,(%esp)
106e92: 89 4d d4 mov %ecx,-0x2c(%ebp)
106e95: e8 86 76 00 00 call 10e520 <malloc>
if (!readbuf) {
106e9a: 8b 4d d4 mov -0x2c(%ebp),%ecx
106e9d: 85 c0 test %eax,%eax
readbuf = kmalloc(je32_to_cpu(ri->csize), GFP_KERNEL);
106e9f: 89 c2 mov %eax,%edx
if (!readbuf) {
106ea1: 0f 84 69 04 00 00 je 107310 <jffs2_read_dnode+0x520> <== NEVER TAKEN
106ea7: 89 45 d4 mov %eax,-0x2c(%ebp)
decomprbuf = readbuf;
}
jffs2_dbg(2, "Read %d bytes to %p\n", je32_to_cpu(ri->csize),
readbuf);
ret = jffs2_flash_read(c, (ref_offset(fd->raw)) + sizeof(*ri),
106eaa: 89 7c 24 0c mov %edi,0xc(%esp)
106eae: 8b 45 d4 mov -0x2c(%ebp),%eax
106eb1: 89 4c 24 08 mov %ecx,0x8(%esp)
106eb5: 89 55 d0 mov %edx,-0x30(%ebp)
106eb8: 89 44 24 10 mov %eax,0x10(%esp)
106ebc: 8b 06 mov (%esi),%eax
106ebe: 8b 40 04 mov 0x4(%eax),%eax
106ec1: 83 e0 fc and $0xfffffffc,%eax
106ec4: 83 c0 44 add $0x44,%eax
106ec7: 89 44 24 04 mov %eax,0x4(%esp)
106ecb: 8b 45 08 mov 0x8(%ebp),%eax
106ece: 89 04 24 mov %eax,(%esp)
106ed1: e8 8a 53 00 00 call 10c260 <jffs2_flash_read>
je32_to_cpu(ri->csize), &readlen, readbuf);
if (!ret && readlen != je32_to_cpu(ri->csize))
106ed6: 8b 55 d0 mov -0x30(%ebp),%edx
106ed9: 85 c0 test %eax,%eax
ret = jffs2_flash_read(c, (ref_offset(fd->raw)) + sizeof(*ri),
106edb: 89 c7 mov %eax,%edi
if (!ret && readlen != je32_to_cpu(ri->csize))
106edd: 75 5f jne 106f3e <jffs2_read_dnode+0x14e> <== NEVER TAKEN
106edf: 8b 43 30 mov 0x30(%ebx),%eax
ret = -EIO;
106ee2: bf fb ff ff ff mov $0xfffffffb,%edi
if (!ret && readlen != je32_to_cpu(ri->csize))
106ee7: 3b 45 e4 cmp -0x1c(%ebp),%eax
106eea: 75 40 jne 106f2c <jffs2_read_dnode+0x13c> <== NEVER TAKEN
if (ret)
goto out_decomprbuf;
crc = crc32(0, readbuf, je32_to_cpu(ri->csize));
106eec: 89 44 24 08 mov %eax,0x8(%esp)
106ef0: 8b 45 d4 mov -0x2c(%ebp),%eax
106ef3: c7 04 24 00 00 00 00 movl $0x0,(%esp)
106efa: 89 55 d0 mov %edx,-0x30(%ebp)
106efd: 89 44 24 04 mov %eax,0x4(%esp)
106f01: e8 8a 3f 00 00 call 10ae90 <cyg_crc32_accumulate>
if (crc != je32_to_cpu(ri->data_crc)) {
106f06: 8b 4b 3c mov 0x3c(%ebx),%ecx
106f09: 8b 55 d0 mov -0x30(%ebp),%edx
106f0c: 39 c1 cmp %eax,%ecx
106f0e: 0f 85 fc 01 00 00 jne 107110 <jffs2_read_dnode+0x320> <== NEVER TAKEN
je32_to_cpu(ri->data_crc), crc, ref_offset(fd->raw));
ret = -EIO;
goto out_decomprbuf;
}
jffs2_dbg(2, "Data CRC matches calculated CRC %08x\n", crc);
if (ri->compr != JFFS2_COMPR_NONE) {
106f14: 80 7b 38 00 cmpb $0x0,0x38(%ebx)
jffs2_dbg(2, "Decompress %d bytes from %p to %d bytes at %p\n",
je32_to_cpu(ri->csize), readbuf,
je32_to_cpu(ri->dsize), decomprbuf);
ret = jffs2_decompress(c, f, ri->compr | (ri->usercompr << 8), readbuf, decomprbuf, je32_to_cpu(ri->csize), je32_to_cpu(ri->dsize));
106f18: 8b 43 34 mov 0x34(%ebx),%eax
if (ri->compr != JFFS2_COMPR_NONE) {
106f1b: 0f 85 9f 02 00 00 jne 1071c0 <jffs2_read_dnode+0x3d0> <== NEVER TAKEN
}
if (len < je32_to_cpu(ri->dsize)) {
memcpy(buf, decomprbuf+ofs, len);
}
out_decomprbuf:
106f21: 31 ff xor %edi,%edi
if (len < je32_to_cpu(ri->dsize)) {
106f23: 39 45 1c cmp %eax,0x1c(%ebp)
106f26: 0f 82 e4 02 00 00 jb 107210 <jffs2_read_dnode+0x420> <== NEVER TAKEN
if(decomprbuf != buf && decomprbuf != readbuf)
106f2c: 39 55 14 cmp %edx,0x14(%ebp)
106f2f: 74 0d je 106f3e <jffs2_read_dnode+0x14e>
106f31: 39 55 d4 cmp %edx,-0x2c(%ebp)
106f34: 74 08 je 106f3e <jffs2_read_dnode+0x14e>
kfree(decomprbuf);
106f36: 89 14 24 mov %edx,(%esp)
106f39: e8 f2 71 00 00 call 10e130 <free>
out_readbuf:
if(readbuf != buf)
106f3e: 8b 45 d4 mov -0x2c(%ebp),%eax
106f41: 39 45 14 cmp %eax,0x14(%ebp)
106f44: 74 08 je 106f4e <jffs2_read_dnode+0x15e>
kfree(readbuf);
106f46: 89 04 24 mov %eax,(%esp)
106f49: e8 e2 71 00 00 call 10e130 <free>
out_ri:
jffs2_free_raw_inode(ri);
106f4e: 89 1c 24 mov %ebx,(%esp)
106f51: e8 6a e2 ff ff call 1051c0 <jffs2_free_raw_inode>
return ret;
}
106f56: 83 c4 4c add $0x4c,%esp
106f59: 89 f8 mov %edi,%eax
106f5b: 5b pop %ebx
106f5c: 5e pop %esi
106f5d: 5f pop %edi
106f5e: 5d pop %ebp
106f5f: c3 ret
pr_warn("Node CRC %08x != calculated CRC %08x for node at %08x\n",
106f60: 8b 0e mov (%esi),%ecx <== NOT EXECUTED
ret = -EIO;
106f62: bf fb ff ff ff mov $0xfffffffb,%edi <== NOT EXECUTED
pr_warn("Node CRC %08x != calculated CRC %08x for node at %08x\n",
106f67: 8b 49 04 mov 0x4(%ecx),%ecx <== NOT EXECUTED
106f6a: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
106f6e: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
106f72: c7 04 24 04 f1 12 00 movl $0x12f104,(%esp) <== NOT EXECUTED
106f79: 83 e1 fc and $0xfffffffc,%ecx <== NOT EXECUTED
106f7c: 89 4c 24 0c mov %ecx,0xc(%esp) <== NOT EXECUTED
106f80: e8 4b fe ff ff call 106dd0 <jffs2_printk> <== NOT EXECUTED
goto out_ri;
106f85: eb c7 jmp 106f4e <jffs2_read_dnode+0x15e> <== NOT EXECUTED
106f87: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106f8e: 66 90 xchg %ax,%ax <== NOT EXECUTED
jffs2_free_raw_inode(ri);
106f90: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
106f93: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
106f96: e8 25 e2 ff ff call 1051c0 <jffs2_free_raw_inode> <== NOT EXECUTED
pr_warn("Error reading node from 0x%08x: %d\n",
106f9b: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED
106f9e: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
106fa2: 8b 06 mov (%esi),%eax <== NOT EXECUTED
106fa4: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED
106fa7: c7 04 24 90 f0 12 00 movl $0x12f090,(%esp) <== NOT EXECUTED
106fae: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
106fb1: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
106fb5: e8 16 fe ff ff call 106dd0 <jffs2_printk> <== NOT EXECUTED
return ret;
106fba: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED
}
106fbd: 83 c4 4c add $0x4c,%esp <== NOT EXECUTED
106fc0: 5b pop %ebx <== NOT EXECUTED
106fc1: 5e pop %esi <== NOT EXECUTED
return ret;
106fc2: 89 d7 mov %edx,%edi <== NOT EXECUTED
}
106fc4: 89 f8 mov %edi,%eax <== NOT EXECUTED
106fc6: 5f pop %edi <== NOT EXECUTED
106fc7: 5d pop %ebp <== NOT EXECUTED
106fc8: c3 ret <== NOT EXECUTED
106fc9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (ri->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(ri->dsize) &&
106fd0: 8b 53 34 mov 0x34(%ebx),%edx
106fd3: 85 d2 test %edx,%edx
106fd5: 0f 84 15 01 00 00 je 1070f0 <jffs2_read_dnode+0x300> <== NEVER TAKEN
memset(buf, 0, len);
106fdb: 8b 55 1c mov 0x1c(%ebp),%edx
106fde: 8b 7d 14 mov 0x14(%ebp),%edi
106fe1: 83 fa 08 cmp $0x8,%edx
106fe4: 0f 83 96 01 00 00 jae 107180 <jffs2_read_dnode+0x390> <== NEVER TAKEN
106fea: f6 c2 04 test $0x4,%dl
106fed: 0f 85 6d 01 00 00 jne 107160 <jffs2_read_dnode+0x370> <== NEVER TAKEN
106ff3: f6 c2 02 test $0x2,%dl
106ff6: 0f 85 54 01 00 00 jne 107150 <jffs2_read_dnode+0x360> <== NEVER TAKEN
106ffc: f6 c2 01 test $0x1,%dl
106fff: 90 nop
107000: 0f 85 3a 01 00 00 jne 107140 <jffs2_read_dnode+0x350> <== NEVER TAKEN
ret = jffs2_flash_read(c, ref_offset(fd->raw), sizeof(*ri), &readlen, (char *)ri);
107006: 31 ff xor %edi,%edi
goto out_ri;
107008: e9 41 ff ff ff jmp 106f4e <jffs2_read_dnode+0x15e>
10700d: 8d 76 00 lea 0x0(%esi),%esi
readbuf = kmalloc(je32_to_cpu(ri->csize), GFP_KERNEL);
107010: 89 0c 24 mov %ecx,(%esp)
107013: 89 4d d0 mov %ecx,-0x30(%ebp)
107016: e8 05 75 00 00 call 10e520 <malloc>
10701b: 89 45 d4 mov %eax,-0x2c(%ebp)
if (!readbuf) {
10701e: 85 c0 test %eax,%eax
107020: 0f 84 ea 02 00 00 je 107310 <jffs2_read_dnode+0x520> <== NEVER TAKEN
if (ri->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(ri->dsize) &&
107026: 8b 43 34 mov 0x34(%ebx),%eax
if (len < je32_to_cpu(ri->dsize)) {
107029: 39 45 1c cmp %eax,0x1c(%ebp)
10702c: 8b 4d d0 mov -0x30(%ebp),%ecx
10702f: 72 5f jb 107090 <jffs2_read_dnode+0x2a0>
107031: 8b 55 14 mov 0x14(%ebp),%edx
107034: e9 71 fe ff ff jmp 106eaa <jffs2_read_dnode+0xba>
107039: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
ret = jffs2_flash_read(c, (ref_offset(fd->raw)) + sizeof(*ri),
107040: 89 7c 24 0c mov %edi,0xc(%esp)
107044: 8b 45 14 mov 0x14(%ebp),%eax
107047: 89 4c 24 08 mov %ecx,0x8(%esp)
10704b: 89 44 24 10 mov %eax,0x10(%esp)
10704f: 8b 06 mov (%esi),%eax
107051: 8b 40 04 mov 0x4(%eax),%eax
107054: 83 e0 fc and $0xfffffffc,%eax
107057: 83 c0 44 add $0x44,%eax
10705a: 89 44 24 04 mov %eax,0x4(%esp)
10705e: 8b 45 08 mov 0x8(%ebp),%eax
107061: 89 04 24 mov %eax,(%esp)
107064: e8 f7 51 00 00 call 10c260 <jffs2_flash_read>
if (!ret && readlen != je32_to_cpu(ri->csize))
107069: 85 c0 test %eax,%eax
ret = jffs2_flash_read(c, (ref_offset(fd->raw)) + sizeof(*ri),
10706b: 89 c7 mov %eax,%edi
if (!ret && readlen != je32_to_cpu(ri->csize))
10706d: 0f 85 db fe ff ff jne 106f4e <jffs2_read_dnode+0x15e> <== NEVER TAKEN
107073: 8b 43 30 mov 0x30(%ebx),%eax
107076: 3b 45 e4 cmp -0x1c(%ebp),%eax
107079: 0f 84 f1 00 00 00 je 107170 <jffs2_read_dnode+0x380> <== ALWAYS TAKEN
10707f: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
ret = -EIO;
107082: bf fb ff ff ff mov $0xfffffffb,%edi <== NOT EXECUTED
if (!ret && readlen != je32_to_cpu(ri->csize))
107087: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED
10708a: e9 af fe ff ff jmp 106f3e <jffs2_read_dnode+0x14e> <== NOT EXECUTED
10708f: 90 nop <== NOT EXECUTED
decomprbuf = kmalloc(je32_to_cpu(ri->dsize), GFP_KERNEL);
107090: 89 04 24 mov %eax,(%esp)
107093: 89 4d cc mov %ecx,-0x34(%ebp)
107096: e8 85 74 00 00 call 10e520 <malloc>
if (!decomprbuf) {
10709b: 89 45 d0 mov %eax,-0x30(%ebp)
10709e: 85 c0 test %eax,%eax
1070a0: 0f 84 74 02 00 00 je 10731a <jffs2_read_dnode+0x52a> <== NEVER TAKEN
ret = jffs2_flash_read(c, (ref_offset(fd->raw)) + sizeof(*ri),
1070a6: 89 7c 24 0c mov %edi,0xc(%esp)
1070aa: 8b 45 d4 mov -0x2c(%ebp),%eax
1070ad: 8b 4d cc mov -0x34(%ebp),%ecx
1070b0: 89 44 24 10 mov %eax,0x10(%esp)
1070b4: 89 4c 24 08 mov %ecx,0x8(%esp)
1070b8: 8b 06 mov (%esi),%eax
1070ba: 8b 40 04 mov 0x4(%eax),%eax
1070bd: 83 e0 fc and $0xfffffffc,%eax
1070c0: 83 c0 44 add $0x44,%eax
1070c3: 89 44 24 04 mov %eax,0x4(%esp)
1070c7: 8b 45 08 mov 0x8(%ebp),%eax
1070ca: 89 04 24 mov %eax,(%esp)
1070cd: e8 8e 51 00 00 call 10c260 <jffs2_flash_read>
if (!ret && readlen != je32_to_cpu(ri->csize))
1070d2: 8b 55 d0 mov -0x30(%ebp),%edx
1070d5: 85 c0 test %eax,%eax
ret = jffs2_flash_read(c, (ref_offset(fd->raw)) + sizeof(*ri),
1070d7: 89 c7 mov %eax,%edi
if (!ret && readlen != je32_to_cpu(ri->csize))
1070d9: 0f 85 4d fe ff ff jne 106f2c <jffs2_read_dnode+0x13c> <== NEVER TAKEN
1070df: e9 fb fd ff ff jmp 106edf <jffs2_read_dnode+0xef>
1070e4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1070eb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1070ef: 90 nop
if (ri->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(ri->dsize) &&
1070f0: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED
1070f3: 85 c0 test %eax,%eax <== NOT EXECUTED
1070f5: 0f 84 e0 fe ff ff je 106fdb <jffs2_read_dnode+0x1eb> <== NOT EXECUTED
ri->dsize = ri->csize;
1070fb: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED
ri->csize = cpu_to_je32(0);
1070fe: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx) <== NOT EXECUTED
ri->dsize = ri->csize;
107105: 89 43 34 mov %eax,0x34(%ebx) <== NOT EXECUTED
ri->csize = cpu_to_je32(0);
107108: e9 ce fe ff ff jmp 106fdb <jffs2_read_dnode+0x1eb> <== NOT EXECUTED
10710d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
pr_warn("Data CRC %08x != calculated CRC %08x for node at %08x\n",
107110: 8b 36 mov (%esi),%esi <== NOT EXECUTED
ret = -EIO;
107112: bf fb ff ff ff mov $0xfffffffb,%edi <== NOT EXECUTED
pr_warn("Data CRC %08x != calculated CRC %08x for node at %08x\n",
107117: 8b 76 04 mov 0x4(%esi),%esi <== NOT EXECUTED
10711a: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10711e: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
107122: c7 04 24 48 f1 12 00 movl $0x12f148,(%esp) <== NOT EXECUTED
107129: 83 e6 fc and $0xfffffffc,%esi <== NOT EXECUTED
10712c: 89 74 24 0c mov %esi,0xc(%esp) <== NOT EXECUTED
107130: e8 9b fc ff ff call 106dd0 <jffs2_printk> <== NOT EXECUTED
goto out_decomprbuf;
107135: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED
107138: e9 ef fd ff ff jmp 106f2c <jffs2_read_dnode+0x13c> <== NOT EXECUTED
10713d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
memset(buf, 0, len);
107140: c6 07 00 movb $0x0,(%edi)
ret = jffs2_flash_read(c, ref_offset(fd->raw), sizeof(*ri), &readlen, (char *)ri);
107143: 31 ff xor %edi,%edi
107145: e9 04 fe ff ff jmp 106f4e <jffs2_read_dnode+0x15e>
10714a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
memset(buf, 0, len);
107150: 66 c7 07 00 00 movw $0x0,(%edi)
107155: 83 c7 02 add $0x2,%edi
107158: e9 9f fe ff ff jmp 106ffc <jffs2_read_dnode+0x20c>
10715d: 8d 76 00 lea 0x0(%esi),%esi
107160: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
107166: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
107169: e9 85 fe ff ff jmp 106ff3 <jffs2_read_dnode+0x203> <== NOT EXECUTED
10716e: 66 90 xchg %ax,%ax <== NOT EXECUTED
if (!ret && readlen != je32_to_cpu(ri->csize))
107170: 8b 55 14 mov 0x14(%ebp),%edx
107173: 89 55 d4 mov %edx,-0x2c(%ebp)
107176: e9 71 fd ff ff jmp 106eec <jffs2_read_dnode+0xfc>
10717b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10717f: 90 nop
memset(buf, 0, len);
107180: f7 c7 01 00 00 00 test $0x1,%edi
107186: 0f 85 56 01 00 00 jne 1072e2 <jffs2_read_dnode+0x4f2>
10718c: f7 c7 02 00 00 00 test $0x2,%edi
107192: 0f 85 3a 01 00 00 jne 1072d2 <jffs2_read_dnode+0x4e2>
107198: f7 c7 04 00 00 00 test $0x4,%edi
10719e: 0f 85 1d 01 00 00 jne 1072c1 <jffs2_read_dnode+0x4d1>
1071a4: 89 d1 mov %edx,%ecx
1071a6: 31 c0 xor %eax,%eax
1071a8: c1 e9 02 shr $0x2,%ecx
1071ab: 83 e2 03 and $0x3,%edx
1071ae: f3 ab rep stos %eax,%es:(%edi)
1071b0: e9 35 fe ff ff jmp 106fea <jffs2_read_dnode+0x1fa>
1071b5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1071bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
ret = jffs2_decompress(c, f, ri->compr | (ri->usercompr << 8), readbuf, decomprbuf, je32_to_cpu(ri->csize), je32_to_cpu(ri->dsize));
1071c0: 89 44 24 18 mov %eax,0x18(%esp)
1071c4: 89 55 d0 mov %edx,-0x30(%ebp)
1071c7: 8b 43 30 mov 0x30(%ebx),%eax
1071ca: 89 54 24 10 mov %edx,0x10(%esp)
1071ce: 89 44 24 14 mov %eax,0x14(%esp)
1071d2: 8b 45 d4 mov -0x2c(%ebp),%eax
1071d5: 89 44 24 0c mov %eax,0xc(%esp)
1071d9: 0f b7 43 38 movzwl 0x38(%ebx),%eax
1071dd: 89 44 24 08 mov %eax,0x8(%esp)
1071e1: 8b 45 0c mov 0xc(%ebp),%eax
1071e4: 89 44 24 04 mov %eax,0x4(%esp)
1071e8: 8b 45 08 mov 0x8(%ebp),%eax
1071eb: 89 04 24 mov %eax,(%esp)
1071ee: e8 5d 3d 00 00 call 10af50 <jffs2_decompress>
if (ret) {
1071f3: 8b 55 d0 mov -0x30(%ebp),%edx
1071f6: 85 c0 test %eax,%eax
ret = jffs2_decompress(c, f, ri->compr | (ri->usercompr << 8), readbuf, decomprbuf, je32_to_cpu(ri->csize), je32_to_cpu(ri->dsize));
1071f8: 89 c7 mov %eax,%edi
if (ret) {
1071fa: 0f 85 a6 00 00 00 jne 1072a6 <jffs2_read_dnode+0x4b6> <== NEVER TAKEN
if (len < je32_to_cpu(ri->dsize)) {
107200: 8b 43 34 mov 0x34(%ebx),%eax
107203: e9 19 fd ff ff jmp 106f21 <jffs2_read_dnode+0x131>
107208: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10720f: 90 nop
memcpy(buf, decomprbuf+ofs, len);
107210: 8b 4d 1c mov 0x1c(%ebp),%ecx
107213: 8b 45 18 mov 0x18(%ebp),%eax
107216: 8b 7d 14 mov 0x14(%ebp),%edi
107219: 83 f9 08 cmp $0x8,%ecx
10721c: 8d 34 02 lea (%edx,%eax,1),%esi
10721f: 73 4f jae 107270 <jffs2_read_dnode+0x480> <== ALWAYS TAKEN
107221: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
107223: 31 ff xor %edi,%edi <== NOT EXECUTED
107225: e9 02 fd ff ff jmp 106f2c <jffs2_read_dnode+0x13c> <== NOT EXECUTED
10722a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
jffs2_free_raw_inode(ri);
107230: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
pr_warn("Short read from 0x%08x: wanted 0x%zx bytes, got 0x%zx\n",
107233: bb 44 00 00 00 mov $0x44,%ebx <== NOT EXECUTED
return -EIO;
107238: bf fb ff ff ff mov $0xfffffffb,%edi <== NOT EXECUTED
jffs2_free_raw_inode(ri);
10723d: e8 7e df ff ff call 1051c0 <jffs2_free_raw_inode> <== NOT EXECUTED
pr_warn("Short read from 0x%08x: wanted 0x%zx bytes, got 0x%zx\n",
107242: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
107245: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
107249: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
10724d: 8b 06 mov (%esi),%eax <== NOT EXECUTED
10724f: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED
107252: c7 04 24 c0 f0 12 00 movl $0x12f0c0,(%esp) <== NOT EXECUTED
107259: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
10725c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
107260: e8 6b fb ff ff call 106dd0 <jffs2_printk> <== NOT EXECUTED
return -EIO;
107265: e9 ec fc ff ff jmp 106f56 <jffs2_read_dnode+0x166> <== NOT EXECUTED
10726a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
memcpy(buf, decomprbuf+ofs, len);
107270: f7 c7 01 00 00 00 test $0x1,%edi
107276: 0f 85 82 00 00 00 jne 1072fe <jffs2_read_dnode+0x50e>
10727c: f7 c7 02 00 00 00 test $0x2,%edi
107282: 75 68 jne 1072ec <jffs2_read_dnode+0x4fc>
107284: f7 c7 04 00 00 00 test $0x4,%edi
10728a: 74 95 je 107221 <jffs2_read_dnode+0x431>
10728c: 8b 06 mov (%esi),%eax
10728e: 83 c7 04 add $0x4,%edi
107291: 83 c6 04 add $0x4,%esi
107294: 83 e9 04 sub $0x4,%ecx
107297: 89 47 fc mov %eax,-0x4(%edi)
10729a: eb 85 jmp 107221 <jffs2_read_dnode+0x431>
return -ENOMEM;
10729c: bf f4 ff ff ff mov $0xfffffff4,%edi <== NOT EXECUTED
1072a1: e9 b0 fc ff ff jmp 106f56 <jffs2_read_dnode+0x166> <== NOT EXECUTED
pr_warn("Error: jffs2_decompress returned %d\n", ret);
1072a6: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1072aa: c7 04 24 8c f1 12 00 movl $0x12f18c,(%esp) <== NOT EXECUTED
1072b1: 89 55 d0 mov %edx,-0x30(%ebp) <== NOT EXECUTED
1072b4: e8 17 fb ff ff call 106dd0 <jffs2_printk> <== NOT EXECUTED
goto out_decomprbuf;
1072b9: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED
1072bc: e9 6b fc ff ff jmp 106f2c <jffs2_read_dnode+0x13c> <== NOT EXECUTED
memset(buf, 0, len);
1072c1: c7 07 00 00 00 00 movl $0x0,(%edi)
1072c7: 83 ea 04 sub $0x4,%edx
1072ca: 83 c7 04 add $0x4,%edi
1072cd: e9 d2 fe ff ff jmp 1071a4 <jffs2_read_dnode+0x3b4>
1072d2: 66 c7 07 00 00 movw $0x0,(%edi)
1072d7: 83 ea 02 sub $0x2,%edx
1072da: 83 c7 02 add $0x2,%edi
1072dd: e9 b6 fe ff ff jmp 107198 <jffs2_read_dnode+0x3a8>
1072e2: c6 07 00 movb $0x0,(%edi)
1072e5: 4a dec %edx
1072e6: 47 inc %edi
1072e7: e9 a0 fe ff ff jmp 10718c <jffs2_read_dnode+0x39c>
memcpy(buf, decomprbuf+ofs, len);
1072ec: 0f b7 06 movzwl (%esi),%eax
1072ef: 83 c7 02 add $0x2,%edi
1072f2: 83 c6 02 add $0x2,%esi
1072f5: 83 e9 02 sub $0x2,%ecx
1072f8: 66 89 47 fe mov %ax,-0x2(%edi)
1072fc: eb 86 jmp 107284 <jffs2_read_dnode+0x494>
1072fe: 0f b6 06 movzbl (%esi),%eax
107301: 49 dec %ecx
107302: 46 inc %esi
107303: 88 07 mov %al,(%edi)
107305: 8b 45 14 mov 0x14(%ebp),%eax
107308: 8d 78 01 lea 0x1(%eax),%edi
10730b: e9 6c ff ff ff jmp 10727c <jffs2_read_dnode+0x48c>
ret = -ENOMEM;
107310: bf f4 ff ff ff mov $0xfffffff4,%edi <== NOT EXECUTED
107315: e9 34 fc ff ff jmp 106f4e <jffs2_read_dnode+0x15e> <== NOT EXECUTED
ret = -ENOMEM;
10731a: bf f4 ff ff ff mov $0xfffffff4,%edi <== NOT EXECUTED
10731f: e9 1a fc ff ff jmp 106f3e <jffs2_read_dnode+0x14e> <== NOT EXECUTED
107324: 90 nop
107325: 90 nop
107326: 90 nop
107327: 90 nop
107328: 90 nop
107329: 90 nop
10732a: 90 nop
10732b: 90 nop
10732c: 90 nop
10732d: 90 nop
10732e: 90 nop
10732f: 90 nop
00107330 <jffs2_read_inode_range>:
int jffs2_read_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
unsigned char *buf, uint32_t offset, uint32_t len)
{
107330: 55 push %ebp
107331: 89 e5 mov %esp,%ebp
107333: 57 push %edi
107334: 56 push %esi
107335: 53 push %ebx
107336: 83 ec 3c sub $0x3c,%esp
int ret;
jffs2_dbg(1, "%s(): ino #%u, range 0x%08x-0x%08x\n",
__func__, f->inocache->ino, offset, offset + len);
frag = jffs2_lookup_node_frag(&f->fragtree, offset);
107339: 8b 45 0c mov 0xc(%ebp),%eax
{
10733c: 8b 75 14 mov 0x14(%ebp),%esi
uint32_t end = offset + len;
10733f: 8b 5d 18 mov 0x18(%ebp),%ebx
frag = jffs2_lookup_node_frag(&f->fragtree, offset);
107342: 83 c0 04 add $0x4,%eax
107345: 89 74 24 04 mov %esi,0x4(%esp)
107349: 89 04 24 mov %eax,(%esp)
uint32_t end = offset + len;
10734c: 01 f3 add %esi,%ebx
10734e: 89 5d e0 mov %ebx,-0x20(%ebp)
frag = jffs2_lookup_node_frag(&f->fragtree, offset);
107351: e8 2a ea ff ff call 105d80 <jffs2_lookup_node_frag>
/* XXX FIXME: Where a single physical node actually shows up in two
frags, we read it twice. Don't do that. */
/* Now we're pointing at the first frag which overlaps our page
* (or perhaps is before it, if we've been asked to read off the
* end of the file). */
while(offset < end) {
107356: 39 de cmp %ebx,%esi
107358: 0f 83 db 00 00 00 jae 107439 <jffs2_read_inode_range+0x109> <== NEVER TAKEN
10735e: 89 c3 mov %eax,%ebx
107360: eb 7b jmp 1073dd <jffs2_read_inode_range+0xad>
107362: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
107369: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
jffs2_dbg(2, "%s(): offset %d, end %d\n",
__func__, offset, end);
if (unlikely(!frag || frag->ofs > offset ||
107370: 8b 7b 14 mov 0x14(%ebx),%edi
107373: 01 fa add %edi,%edx
107375: 39 f2 cmp %esi,%edx
107377: 0f 86 d3 00 00 00 jbe 107450 <jffs2_read_inode_range+0x120> <== NEVER TAKEN
offset, offset + holesize);
memset(buf, 0, holesize);
buf += holesize;
offset += holesize;
continue;
} else if (unlikely(!frag->node)) {
10737d: 8b 43 10 mov 0x10(%ebx),%eax
107380: 85 c0 test %eax,%eax
107382: 0f 84 18 01 00 00 je 1074a0 <jffs2_read_inode_range+0x170> <== NEVER TAKEN
} else {
uint32_t readlen;
uint32_t fragofs; /* offset within the frag to start reading */
fragofs = offset - frag->ofs;
readlen = min(frag->size - fragofs, end - offset);
107388: 8b 7d e0 mov -0x20(%ebp),%edi
10738b: 29 f2 sub %esi,%edx
10738d: 29 f7 sub %esi,%edi
10738f: 39 d7 cmp %edx,%edi
107391: 76 02 jbe 107395 <jffs2_read_inode_range+0x65>
107393: 89 d7 mov %edx,%edi
jffs2_dbg(1, "Reading %d-%d from node at 0x%08x (%d)\n",
frag->ofs+fragofs,
frag->ofs + fragofs+readlen,
ref_offset(frag->node->raw),
ref_flags(frag->node->raw));
ret = jffs2_read_dnode(c, f, frag->node, buf, fragofs + frag->ofs - frag->node->ofs, readlen);
107395: 89 7c 24 14 mov %edi,0x14(%esp)
107399: 89 f2 mov %esi,%edx
10739b: 8b 48 04 mov 0x4(%eax),%ecx
10739e: 89 44 24 08 mov %eax,0x8(%esp)
1073a2: 8b 45 0c mov 0xc(%ebp),%eax
1073a5: 29 ca sub %ecx,%edx
1073a7: 8b 4d 10 mov 0x10(%ebp),%ecx
1073aa: 89 44 24 04 mov %eax,0x4(%esp)
1073ae: 8b 45 08 mov 0x8(%ebp),%eax
1073b1: 89 54 24 10 mov %edx,0x10(%esp)
1073b5: 89 4c 24 0c mov %ecx,0xc(%esp)
1073b9: 89 04 24 mov %eax,(%esp)
1073bc: e8 2f fa ff ff call 106df0 <jffs2_read_dnode>
jffs2_dbg(2, "node read done\n");
if (ret) {
1073c1: 85 c0 test %eax,%eax
1073c3: 0f 85 f7 01 00 00 jne 1075c0 <jffs2_read_inode_range+0x290> <== NEVER TAKEN
return _RBTree_Successor( node );
1073c9: 89 1c 24 mov %ebx,(%esp)
__func__, ret);
memset(buf, 0, readlen);
return ret;
}
buf += readlen;
offset += readlen;
1073cc: 01 fe add %edi,%esi
buf += readlen;
1073ce: 01 7d 10 add %edi,0x10(%ebp)
1073d1: e8 ea e6 00 00 call 115ac0 <_RBTree_Successor>
1073d6: 89 c3 mov %eax,%ebx
while(offset < end) {
1073d8: 3b 75 e0 cmp -0x20(%ebp),%esi
1073db: 73 5c jae 107439 <jffs2_read_inode_range+0x109>
if (unlikely(!frag || frag->ofs > offset ||
1073dd: 85 db test %ebx,%ebx
1073df: 74 6f je 107450 <jffs2_read_inode_range+0x120>
1073e1: 8b 53 18 mov 0x18(%ebx),%edx
1073e4: 39 f2 cmp %esi,%edx
1073e6: 76 88 jbe 107370 <jffs2_read_inode_range+0x40> <== ALWAYS TAKEN
uint32_t holesize = end - offset;
1073e8: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED
holesize = min(holesize, frag->ofs - offset);
1073eb: 29 f2 sub %esi,%edx <== NOT EXECUTED
1073ed: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED
uint32_t holesize = end - offset;
1073f0: 29 f0 sub %esi,%eax <== NOT EXECUTED
holesize = min(holesize, frag->ofs - offset);
1073f2: 39 c2 cmp %eax,%edx <== NOT EXECUTED
1073f4: 76 03 jbe 1073f9 <jffs2_read_inode_range+0xc9> <== NOT EXECUTED
1073f6: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED
offset += holesize;
1073f9: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
memset(buf, 0, holesize);
1073fc: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED
offset += holesize;
1073ff: 01 c6 add %eax,%esi <== NOT EXECUTED
memset(buf, 0, holesize);
107401: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
107404: 83 f8 08 cmp $0x8,%eax <== NOT EXECUTED
107407: 89 c2 mov %eax,%edx <== NOT EXECUTED
107409: 73 5e jae 107469 <jffs2_read_inode_range+0x139> <== NOT EXECUTED
10740b: f6 c2 04 test $0x4,%dl
10740e: 74 09 je 107419 <jffs2_read_inode_range+0xe9> <== ALWAYS TAKEN
107410: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
107416: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
107419: f6 c2 02 test $0x2,%dl
10741c: 74 08 je 107426 <jffs2_read_inode_range+0xf6> <== ALWAYS TAKEN
10741e: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
107423: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
107426: f6 c2 01 test $0x1,%dl
107429: 74 03 je 10742e <jffs2_read_inode_range+0xfe> <== NEVER TAKEN
10742b: c6 07 00 movb $0x0,(%edi)
buf += holesize;
10742e: 8b 45 e4 mov -0x1c(%ebp),%eax
107431: 01 45 10 add %eax,0x10(%ebp)
while(offset < end) {
107434: 3b 75 e0 cmp -0x20(%ebp),%esi
107437: 72 a4 jb 1073dd <jffs2_read_inode_range+0xad> <== NEVER TAKEN
frag = frag_next(frag);
jffs2_dbg(2, "node read was OK. Looping\n");
}
}
return 0;
107439: 31 d2 xor %edx,%edx
}
10743b: 83 c4 3c add $0x3c,%esp
10743e: 89 d0 mov %edx,%eax
107440: 5b pop %ebx
107441: 5e pop %esi
107442: 5f pop %edi
107443: 5d pop %ebp
107444: c3 ret
107445: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10744c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
uint32_t holesize = end - offset;
107450: 8b 45 e0 mov -0x20(%ebp),%eax
memset(buf, 0, holesize);
107453: 8b 7d 10 mov 0x10(%ebp),%edi
uint32_t holesize = end - offset;
107456: 89 c1 mov %eax,%ecx
107458: 29 f1 sub %esi,%ecx
10745a: 89 c6 mov %eax,%esi
10745c: 89 4d e4 mov %ecx,-0x1c(%ebp)
memset(buf, 0, holesize);
10745f: 8b 45 e4 mov -0x1c(%ebp),%eax
107462: 83 f8 08 cmp $0x8,%eax
107465: 89 c2 mov %eax,%edx
107467: 72 a2 jb 10740b <jffs2_read_inode_range+0xdb> <== NEVER TAKEN
107469: f7 c7 01 00 00 00 test $0x1,%edi
10746f: 0f 85 2b 01 00 00 jne 1075a0 <jffs2_read_inode_range+0x270> <== NEVER TAKEN
107475: f7 c7 02 00 00 00 test $0x2,%edi
10747b: 0f 85 0f 01 00 00 jne 107590 <jffs2_read_inode_range+0x260> <== NEVER TAKEN
107481: f7 c7 04 00 00 00 test $0x4,%edi
107487: 0f 85 e3 00 00 00 jne 107570 <jffs2_read_inode_range+0x240>
10748d: 89 d1 mov %edx,%ecx
10748f: 31 c0 xor %eax,%eax
107491: c1 e9 02 shr $0x2,%ecx
107494: 83 e2 03 and $0x3,%edx
107497: f3 ab rep stos %eax,%es:(%edi)
107499: e9 6d ff ff ff jmp 10740b <jffs2_read_inode_range+0xdb>
10749e: 66 90 xchg %ax,%ax
uint32_t holeend = min(end, frag->ofs + frag->size);
1074a0: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED
1074a3: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED
1074a6: 39 ca cmp %ecx,%edx <== NOT EXECUTED
1074a8: 77 76 ja 107520 <jffs2_read_inode_range+0x1f0> <== NOT EXECUTED
memset(buf, 0, holeend - offset);
1074aa: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
1074ad: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED
1074b0: 29 f0 sub %esi,%eax <== NOT EXECUTED
1074b2: 83 f8 08 cmp $0x8,%eax <== NOT EXECUTED
1074b5: 89 c6 mov %eax,%esi <== NOT EXECUTED
1074b7: 89 c2 mov %eax,%edx <== NOT EXECUTED
1074b9: 73 75 jae 107530 <jffs2_read_inode_range+0x200> <== NOT EXECUTED
1074bb: f6 c2 04 test $0x4,%dl <== NOT EXECUTED
1074be: 75 50 jne 107510 <jffs2_read_inode_range+0x1e0> <== NOT EXECUTED
1074c0: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
1074c3: 75 3b jne 107500 <jffs2_read_inode_range+0x1d0> <== NOT EXECUTED
1074c5: f6 c2 01 test $0x1,%dl <== NOT EXECUTED
1074c8: 75 16 jne 1074e0 <jffs2_read_inode_range+0x1b0> <== NOT EXECUTED
1074ca: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
buf += holeend - offset;
1074cd: 01 75 10 add %esi,0x10(%ebp) <== NOT EXECUTED
1074d0: e8 eb e5 00 00 call 115ac0 <_RBTree_Successor> <== NOT EXECUTED
offset = holeend;
1074d5: 8b 75 e4 mov -0x1c(%ebp),%esi <== NOT EXECUTED
1074d8: 89 c3 mov %eax,%ebx <== NOT EXECUTED
continue;
1074da: e9 f9 fe ff ff jmp 1073d8 <jffs2_read_inode_range+0xa8> <== NOT EXECUTED
1074df: 90 nop <== NOT EXECUTED
memset(buf, 0, holeend - offset);
1074e0: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
1074e3: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
buf += holeend - offset;
1074e6: 01 75 10 add %esi,0x10(%ebp) <== NOT EXECUTED
1074e9: e8 d2 e5 00 00 call 115ac0 <_RBTree_Successor> <== NOT EXECUTED
offset = holeend;
1074ee: 8b 75 e4 mov -0x1c(%ebp),%esi <== NOT EXECUTED
1074f1: 89 c3 mov %eax,%ebx <== NOT EXECUTED
continue;
1074f3: e9 e0 fe ff ff jmp 1073d8 <jffs2_read_inode_range+0xa8> <== NOT EXECUTED
1074f8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1074ff: 90 nop <== NOT EXECUTED
memset(buf, 0, holeend - offset);
107500: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
107505: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
107508: f6 c2 01 test $0x1,%dl <== NOT EXECUTED
10750b: 74 bd je 1074ca <jffs2_read_inode_range+0x19a> <== NOT EXECUTED
10750d: eb d1 jmp 1074e0 <jffs2_read_inode_range+0x1b0> <== NOT EXECUTED
10750f: 90 nop <== NOT EXECUTED
107510: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
107516: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
107519: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
10751c: 74 a7 je 1074c5 <jffs2_read_inode_range+0x195> <== NOT EXECUTED
10751e: eb e0 jmp 107500 <jffs2_read_inode_range+0x1d0> <== NOT EXECUTED
uint32_t holeend = min(end, frag->ofs + frag->size);
107520: 89 4d e4 mov %ecx,-0x1c(%ebp) <== NOT EXECUTED
107523: eb 85 jmp 1074aa <jffs2_read_inode_range+0x17a> <== NOT EXECUTED
107525: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10752c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
memset(buf, 0, holeend - offset);
107530: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED
107536: 0f 85 0a 01 00 00 jne 107646 <jffs2_read_inode_range+0x316> <== NOT EXECUTED
10753c: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
107542: 0f 85 0f 01 00 00 jne 107657 <jffs2_read_inode_range+0x327> <== NOT EXECUTED
107548: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
10754e: 0f 85 e1 00 00 00 jne 107635 <jffs2_read_inode_range+0x305> <== NOT EXECUTED
107554: 89 d1 mov %edx,%ecx <== NOT EXECUTED
107556: 31 c0 xor %eax,%eax <== NOT EXECUTED
107558: c1 e9 02 shr $0x2,%ecx <== NOT EXECUTED
10755b: 83 e2 03 and $0x3,%edx <== NOT EXECUTED
10755e: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED
107560: e9 56 ff ff ff jmp 1074bb <jffs2_read_inode_range+0x18b> <== NOT EXECUTED
107565: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10756c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
memset(buf, 0, holesize);
107570: c7 07 00 00 00 00 movl $0x0,(%edi)
107576: 83 ea 04 sub $0x4,%edx
107579: 83 c7 04 add $0x4,%edi
10757c: e9 0c ff ff ff jmp 10748d <jffs2_read_inode_range+0x15d>
107581: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
107588: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10758f: 90 nop
107590: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
107595: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
107598: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
10759b: e9 e1 fe ff ff jmp 107481 <jffs2_read_inode_range+0x151> <== NOT EXECUTED
1075a0: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
1075a3: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
1075a6: 8d 78 01 lea 0x1(%eax),%edi <== NOT EXECUTED
1075a9: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED
1075ac: 8d 50 ff lea -0x1(%eax),%edx <== NOT EXECUTED
1075af: e9 c1 fe ff ff jmp 107475 <jffs2_read_inode_range+0x145> <== NOT EXECUTED
1075b4: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1075bb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1075bf: 90 nop <== NOT EXECUTED
memset(buf, 0, readlen);
1075c0: 89 fb mov %edi,%ebx <== NOT EXECUTED
1075c2: 89 c2 mov %eax,%edx <== NOT EXECUTED
1075c4: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED
1075c7: 83 fb 08 cmp $0x8,%ebx <== NOT EXECUTED
1075ca: 73 43 jae 10760f <jffs2_read_inode_range+0x2df> <== NOT EXECUTED
1075cc: f6 c3 04 test $0x4,%bl <== NOT EXECUTED
1075cf: 75 2e jne 1075ff <jffs2_read_inode_range+0x2cf> <== NOT EXECUTED
1075d1: f6 c3 02 test $0x2,%bl <== NOT EXECUTED
1075d4: 75 16 jne 1075ec <jffs2_read_inode_range+0x2bc> <== NOT EXECUTED
1075d6: f6 c3 01 test $0x1,%bl <== NOT EXECUTED
1075d9: 0f 84 5c fe ff ff je 10743b <jffs2_read_inode_range+0x10b> <== NOT EXECUTED
1075df: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
}
1075e2: 83 c4 3c add $0x3c,%esp <== NOT EXECUTED
1075e5: 89 d0 mov %edx,%eax <== NOT EXECUTED
1075e7: 5b pop %ebx <== NOT EXECUTED
1075e8: 5e pop %esi <== NOT EXECUTED
1075e9: 5f pop %edi <== NOT EXECUTED
1075ea: 5d pop %ebp <== NOT EXECUTED
1075eb: c3 ret <== NOT EXECUTED
memset(buf, 0, readlen);
1075ec: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
1075f1: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
1075f4: f6 c3 01 test $0x1,%bl <== NOT EXECUTED
1075f7: 0f 84 3e fe ff ff je 10743b <jffs2_read_inode_range+0x10b> <== NOT EXECUTED
1075fd: eb e0 jmp 1075df <jffs2_read_inode_range+0x2af> <== NOT EXECUTED
1075ff: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
107605: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
107608: f6 c3 02 test $0x2,%bl <== NOT EXECUTED
10760b: 74 c9 je 1075d6 <jffs2_read_inode_range+0x2a6> <== NOT EXECUTED
10760d: eb dd jmp 1075ec <jffs2_read_inode_range+0x2bc> <== NOT EXECUTED
10760f: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED
107615: 75 6b jne 107682 <jffs2_read_inode_range+0x352> <== NOT EXECUTED
107617: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
10761d: 75 56 jne 107675 <jffs2_read_inode_range+0x345> <== NOT EXECUTED
10761f: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
107625: 75 40 jne 107667 <jffs2_read_inode_range+0x337> <== NOT EXECUTED
107627: 89 d9 mov %ebx,%ecx <== NOT EXECUTED
107629: 31 c0 xor %eax,%eax <== NOT EXECUTED
10762b: c1 e9 02 shr $0x2,%ecx <== NOT EXECUTED
10762e: 83 e3 03 and $0x3,%ebx <== NOT EXECUTED
107631: f3 ab rep stos %eax,%es:(%edi) <== NOT EXECUTED
107633: eb 97 jmp 1075cc <jffs2_read_inode_range+0x29c> <== NOT EXECUTED
memset(buf, 0, holeend - offset);
107635: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
10763b: 83 ea 04 sub $0x4,%edx <== NOT EXECUTED
10763e: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
107641: e9 0e ff ff ff jmp 107554 <jffs2_read_inode_range+0x224> <== NOT EXECUTED
107646: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
107649: 8d 56 ff lea -0x1(%esi),%edx <== NOT EXECUTED
10764c: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10764f: 8d 78 01 lea 0x1(%eax),%edi <== NOT EXECUTED
107652: e9 e5 fe ff ff jmp 10753c <jffs2_read_inode_range+0x20c> <== NOT EXECUTED
107657: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
10765c: 83 ea 02 sub $0x2,%edx <== NOT EXECUTED
10765f: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
107662: e9 e1 fe ff ff jmp 107548 <jffs2_read_inode_range+0x218> <== NOT EXECUTED
memset(buf, 0, readlen);
107667: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED
10766d: 83 eb 04 sub $0x4,%ebx <== NOT EXECUTED
107670: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
107673: eb b2 jmp 107627 <jffs2_read_inode_range+0x2f7> <== NOT EXECUTED
107675: 66 c7 07 00 00 movw $0x0,(%edi) <== NOT EXECUTED
10767a: 83 eb 02 sub $0x2,%ebx <== NOT EXECUTED
10767d: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
107680: eb 9d jmp 10761f <jffs2_read_inode_range+0x2ef> <== NOT EXECUTED
107682: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED
107685: 4b dec %ebx <== NOT EXECUTED
107686: 47 inc %edi <== NOT EXECUTED
107687: eb 8e jmp 107617 <jffs2_read_inode_range+0x2e7> <== NOT EXECUTED
107689: 90 nop
10768a: 90 nop
10768b: 90 nop
10768c: 90 nop
10768d: 90 nop
10768e: 90 nop
10768f: 90 nop
0010bb00 <jffs2_rename>:
int jffs2_rename (struct _inode *old_dir_i, struct _inode *d_inode, const unsigned char *old_d_name, size_t old_d_namelen,
struct _inode *new_dir_i, const unsigned char *new_d_name, size_t new_d_namelen)
{
10bb00: 55 push %ebp <== NOT EXECUTED
10bb01: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10bb03: 57 push %edi <== NOT EXECUTED
10bb04: 56 push %esi <== NOT EXECUTED
10bb05: 53 push %ebx <== NOT EXECUTED
10bb06: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED
10bb09: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
int ret;
struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb);
10bb0c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
*/
/* Make a hard link */
/* XXX: This is ugly */
type = (d_inode->i_mode & S_IFMT) >> 12;
10bb0f: 8b 5e 08 mov 0x8(%esi),%ebx <== NOT EXECUTED
struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb);
10bb12: 8b 78 3c mov 0x3c(%eax),%edi <== NOT EXECUTED
type = (d_inode->i_mode & S_IFMT) >> 12;
10bb15: c1 eb 0c shr $0xc,%ebx <== NOT EXECUTED
if (!type) type = DT_REG;
10bb18: 80 e3 0f and $0xf,%bl <== NOT EXECUTED
10bb1b: 75 02 jne 10bb1f <jffs2_rename+0x1f> <== NOT EXECUTED
10bb1d: b3 08 mov $0x8,%bl <== NOT EXECUTED
now = get_seconds();
10bb1f: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i),
10bb26: 0f b6 db movzbl %bl,%ebx <== NOT EXECUTED
now = get_seconds();
10bb29: e8 02 ef 01 00 call 12aa30 <time> <== NOT EXECUTED
ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i),
10bb2e: 89 5c 24 0c mov %ebx,0xc(%esp) <== NOT EXECUTED
10bb32: 89 44 24 18 mov %eax,0x18(%esp) <== NOT EXECUTED
10bb36: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED
10bb39: 8b 45 20 mov 0x20(%ebp),%eax <== NOT EXECUTED
10bb3c: 89 44 24 14 mov %eax,0x14(%esp) <== NOT EXECUTED
10bb40: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED
10bb43: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
10bb47: 8b 06 mov (%esi),%eax <== NOT EXECUTED
10bb49: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10bb4c: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10bb50: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
10bb53: 83 c0 44 add $0x44,%eax <== NOT EXECUTED
10bb56: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10bb5a: e8 61 ea ff ff call 10a5c0 <jffs2_do_link> <== NOT EXECUTED
d_inode->i_ino, type,
(const char *)new_d_name,
new_d_namelen, now);
if (ret)
10bb5f: 85 c0 test %eax,%eax <== NOT EXECUTED
ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i),
10bb61: 89 c3 mov %eax,%ebx <== NOT EXECUTED
if (ret)
10bb63: 74 0b je 10bb70 <jffs2_rename+0x70> <== NOT EXECUTED
mutex_unlock(&f->sem);
printk(KERN_NOTICE "jffs2_rename(): Link succeeded, unlink failed (err %d). You now have a hard link\n", ret);
}
return ret;
}
10bb65: 83 c4 3c add $0x3c,%esp <== NOT EXECUTED
10bb68: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10bb6a: 5b pop %ebx <== NOT EXECUTED
10bb6b: 5e pop %esi <== NOT EXECUTED
10bb6c: 5f pop %edi <== NOT EXECUTED
10bb6d: 5d pop %ebp <== NOT EXECUTED
10bb6e: c3 ret <== NOT EXECUTED
10bb6f: 90 nop <== NOT EXECUTED
ret = jffs2_do_unlink(c, JFFS2_INODE_INFO(old_dir_i),
10bb70: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10bb73: 31 c0 xor %eax,%eax <== NOT EXECUTED
10bb75: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED
10bb78: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
10bb7c: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
10bb7f: 89 54 24 14 mov %edx,0x14(%esp) <== NOT EXECUTED
10bb83: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
10bb87: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10bb8a: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10bb8e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10bb91: 83 c0 44 add $0x44,%eax <== NOT EXECUTED
10bb94: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10bb98: e8 b3 e8 ff ff call 10a450 <jffs2_do_unlink> <== NOT EXECUTED
if (ret) {
10bb9d: 85 c0 test %eax,%eax <== NOT EXECUTED
ret = jffs2_do_unlink(c, JFFS2_INODE_INFO(old_dir_i),
10bb9f: 89 c3 mov %eax,%ebx <== NOT EXECUTED
if (ret) {
10bba1: 74 c2 je 10bb65 <jffs2_rename+0x65> <== NOT EXECUTED
if (f->inocache)
10bba3: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED
10bba6: 85 c0 test %eax,%eax <== NOT EXECUTED
10bba8: 74 0d je 10bbb7 <jffs2_rename+0xb7> <== NOT EXECUTED
d_inode->i_nlink = f->inocache->pino_nlink++;
10bbaa: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED
10bbad: 8d 4a 01 lea 0x1(%edx),%ecx <== NOT EXECUTED
10bbb0: 89 48 14 mov %ecx,0x14(%eax) <== NOT EXECUTED
10bbb3: 66 89 56 0c mov %dx,0xc(%esi) <== NOT EXECUTED
printk(KERN_NOTICE "jffs2_rename(): Link succeeded, unlink failed (err %d). You now have a hard link\n", ret);
10bbb7: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10bbbb: c7 04 24 74 06 13 00 movl $0x130674,(%esp) <== NOT EXECUTED
10bbc2: e8 19 f7 ff ff call 10b2e0 <jffs2_printk> <== NOT EXECUTED
}
10bbc7: 83 c4 3c add $0x3c,%esp <== NOT EXECUTED
10bbca: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10bbcc: 5b pop %ebx <== NOT EXECUTED
10bbcd: 5e pop %esi <== NOT EXECUTED
10bbce: 5f pop %edi <== NOT EXECUTED
10bbcf: 5d pop %ebp <== NOT EXECUTED
10bbd0: c3 ret <== NOT EXECUTED
10bbd1: 90 nop
10bbd2: 90 nop
10bbd3: 90 nop
10bbd4: 90 nop
10bbd5: 90 nop
10bbd6: 90 nop
10bbd7: 90 nop
10bbd8: 90 nop
10bbd9: 90 nop
10bbda: 90 nop
10bbdb: 90 nop
10bbdc: 90 nop
10bbdd: 90 nop
10bbde: 90 nop
10bbdf: 90 nop
00106bf0 <jffs2_reserve_space>:
{
106bf0: 55 push %ebp
106bf1: 89 e5 mov %esp,%ebp
106bf3: 57 push %edi
106bf4: 56 push %esi
106bf5: 53 push %ebx
106bf6: 83 ec 2c sub $0x2c,%esp
106bf9: 8b 45 10 mov 0x10(%ebp),%eax
106bfc: 8b 5d 08 mov 0x8(%ebp),%ebx
106bff: 8b 55 0c mov 0xc(%ebp),%edx
106c02: 89 45 e0 mov %eax,-0x20(%ebp)
106c05: 8b 45 14 mov 0x14(%ebp),%eax
c->erasing_size - c->resv_blocks_write * c->sector_size
106c08: 0f b6 7b 44 movzbl 0x44(%ebx),%edi
{
106c0c: 89 45 d8 mov %eax,-0x28(%ebp)
if (prio != ALLOC_DELETION && !jffs2_rp_can_write(c)) {
106c0f: 48 dec %eax
106c10: 74 3e je 106c50 <jffs2_reserve_space+0x60> <== NEVER TAKEN
avail = c->dirty_size + c->free_size + c->unchecked_size +
106c12: 8b 4b 20 mov 0x20(%ebx),%ecx
106c15: 8b 43 28 mov 0x28(%ebx),%eax
106c18: 8b 73 38 mov 0x38(%ebx),%esi
106c1b: 01 c8 add %ecx,%eax
106c1d: 8b 4b 2c mov 0x2c(%ebx),%ecx
106c20: 01 f0 add %esi,%eax
106c22: 8b 73 4c mov 0x4c(%ebx),%esi
106c25: 01 c8 add %ecx,%eax
c->erasing_size - c->resv_blocks_write * c->sector_size
106c27: 8b 4b 34 mov 0x34(%ebx),%ecx
avail = c->dirty_size + c->free_size + c->unchecked_size +
106c2a: 29 f0 sub %esi,%eax
c->erasing_size - c->resv_blocks_write * c->sector_size
106c2c: 0f af cf imul %edi,%ecx
avail = c->dirty_size + c->free_size + c->unchecked_size +
106c2f: 29 c8 sub %ecx,%eax
if (avail > opts->rp_size)
106c31: 3b 83 d8 00 00 00 cmp 0xd8(%ebx),%eax
106c37: 77 17 ja 106c50 <jffs2_reserve_space+0x60> <== ALWAYS TAKEN
ret = -ENOSPC;
106c39: b8 e4 ff ff ff mov $0xffffffe4,%eax <== NOT EXECUTED
}
106c3e: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
106c41: 5b pop %ebx <== NOT EXECUTED
106c42: 5e pop %esi <== NOT EXECUTED
106c43: 5f pop %edi <== NOT EXECUTED
106c44: 5d pop %ebp <== NOT EXECUTED
106c45: c3 ret <== NOT EXECUTED
106c46: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106c4d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
minsize = PAD(minsize);
106c50: 89 7d e4 mov %edi,-0x1c(%ebp)
106c53: 83 c2 03 add $0x3,%edx
106c56: 83 e2 fc and $0xfffffffc,%edx
106c59: 89 55 dc mov %edx,-0x24(%ebp)
106c5c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
while(c->nr_free_blocks + c->nr_erasing_blocks < blocksneeded) {
106c60: 8b 53 40 mov 0x40(%ebx),%edx
106c63: 8b 73 3c mov 0x3c(%ebx),%esi
106c66: 01 d6 add %edx,%esi
106c68: 3b 75 e4 cmp -0x1c(%ebp),%esi
106c6b: 73 53 jae 106cc0 <jffs2_reserve_space+0xd0>
dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size + c->unchecked_size;
106c6d: 8b 7b 20 mov 0x20(%ebx),%edi
106c70: 8b 43 2c mov 0x2c(%ebx),%eax
106c73: 8b 4b 34 mov 0x34(%ebx),%ecx
106c76: 01 f8 add %edi,%eax
106c78: 8b 7b 38 mov 0x38(%ebx),%edi
106c7b: 0f af d1 imul %ecx,%edx
106c7e: 01 f8 add %edi,%eax
106c80: 89 c7 mov %eax,%edi
106c82: 29 d7 sub %edx,%edi
if (dirty < c->nospc_dirty_size) {
106c84: 39 7b 4c cmp %edi,0x4c(%ebx)
106c87: 77 77 ja 106d00 <jffs2_reserve_space+0x110>
avail = c->free_size + c->dirty_size + c->erasing_size + c->unchecked_size;
106c89: 8b 53 28 mov 0x28(%ebx),%edx
106c8c: 01 d0 add %edx,%eax
if ( (avail / c->sector_size) <= blocksneeded) {
106c8e: 31 d2 xor %edx,%edx
106c90: f7 f1 div %ecx
106c92: 3b 45 e4 cmp -0x1c(%ebp),%eax
106c95: 76 69 jbe 106d00 <jffs2_reserve_space+0x110> <== NEVER TAKEN
ret = jffs2_garbage_collect_pass(c);
106c97: 89 1c 24 mov %ebx,(%esp)
106c9a: e8 b1 cf ff ff call 103c50 <jffs2_garbage_collect_pass>
} else if (ret)
106c9f: 83 f8 f5 cmp $0xfffffff5,%eax
106ca2: 74 bc je 106c60 <jffs2_reserve_space+0x70> <== NEVER TAKEN
106ca4: 85 c0 test %eax,%eax
106ca6: 75 96 jne 106c3e <jffs2_reserve_space+0x4e> <== NEVER TAKEN
while(c->nr_free_blocks + c->nr_erasing_blocks < blocksneeded) {
106ca8: 8b 53 40 mov 0x40(%ebx),%edx
106cab: 8b 73 3c mov 0x3c(%ebx),%esi
106cae: 01 d6 add %edx,%esi
106cb0: 3b 75 e4 cmp -0x1c(%ebp),%esi
106cb3: 72 b8 jb 106c6d <jffs2_reserve_space+0x7d>
106cb5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106cbc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
106cc0: 8b 4d e0 mov -0x20(%ebp),%ecx
106cc3: 89 d8 mov %ebx,%eax
106cc5: 8b 55 dc mov -0x24(%ebp),%edx
106cc8: e8 d3 fb ff ff call 1068a0 <jffs2_do_reserve_space.constprop.0>
while(ret == -EAGAIN) {
106ccd: 83 f8 f5 cmp $0xfffffff5,%eax
106cd0: 74 8e je 106c60 <jffs2_reserve_space+0x70> <== NEVER TAKEN
if (!ret)
106cd2: 85 c0 test %eax,%eax
106cd4: 0f 85 64 ff ff ff jne 106c3e <jffs2_reserve_space+0x4e> <== NEVER TAKEN
ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
106cda: c7 45 10 01 00 00 00 movl $0x1,0x10(%ebp) <== NOT EXECUTED
106ce1: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED
106ce4: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED
106ce7: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED
}
106cea: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED
106ced: 5b pop %ebx <== NOT EXECUTED
106cee: 5e pop %esi <== NOT EXECUTED
106cef: 5f pop %edi <== NOT EXECUTED
106cf0: 5d pop %ebp <== NOT EXECUTED
ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
106cf1: e9 0a e5 ff ff jmp 105200 <jffs2_prealloc_raw_node_refs> <== NOT EXECUTED
106cf6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
106cfd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) {
106d00: 83 7d d8 01 cmpl $0x1,-0x28(%ebp)
106d04: 0f 85 2f ff ff ff jne 106c39 <jffs2_reserve_space+0x49> <== ALWAYS TAKEN
106d0a: 0f b6 43 45 movzbl 0x45(%ebx),%eax <== NOT EXECUTED
106d0e: 39 f0 cmp %esi,%eax <== NOT EXECUTED
106d10: 76 ae jbe 106cc0 <jffs2_reserve_space+0xd0> <== NOT EXECUTED
106d12: e9 22 ff ff ff jmp 106c39 <jffs2_reserve_space+0x49> <== NOT EXECUTED
106d17: 90 nop
106d18: 90 nop
106d19: 90 nop
106d1a: 90 nop
106d1b: 90 nop
106d1c: 90 nop
106d1d: 90 nop
106d1e: 90 nop
106d1f: 90 nop
00106b90 <jffs2_reserve_space_gc>:
{
106b90: 55 push %ebp
106b91: 89 e5 mov %esp,%ebp
106b93: 57 push %edi
106b94: 56 push %esi
106b95: 53 push %ebx
106b96: 83 ec 0c sub $0xc,%esp
minsize = PAD(minsize);
106b99: 8b 45 0c mov 0xc(%ebp),%eax
{
106b9c: 8b 75 08 mov 0x8(%ebp),%esi
106b9f: 8b 7d 10 mov 0x10(%ebp),%edi
minsize = PAD(minsize);
106ba2: 8d 58 03 lea 0x3(%eax),%ebx
106ba5: 83 e3 fc and $0xfffffffc,%ebx
jffs2_dbg(1, "%s(): Requested 0x%x bytes\n", __func__, minsize);
106ba8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106baf: 90 nop
ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
106bb0: 89 f9 mov %edi,%ecx
106bb2: 89 da mov %ebx,%edx
106bb4: 89 f0 mov %esi,%eax
106bb6: e8 e5 fc ff ff call 1068a0 <jffs2_do_reserve_space.constprop.0>
if (ret == -EAGAIN)
106bbb: 83 f8 f5 cmp $0xfffffff5,%eax
106bbe: 74 f0 je 106bb0 <jffs2_reserve_space_gc+0x20> <== NEVER TAKEN
if (!ret)
106bc0: 85 c0 test %eax,%eax
106bc2: 74 0c je 106bd0 <jffs2_reserve_space_gc+0x40> <== ALWAYS TAKEN
}
106bc4: 83 c4 0c add $0xc,%esp <== NOT EXECUTED
106bc7: 5b pop %ebx <== NOT EXECUTED
106bc8: 5e pop %esi <== NOT EXECUTED
106bc9: 5f pop %edi <== NOT EXECUTED
106bca: 5d pop %ebp <== NOT EXECUTED
106bcb: c3 ret <== NOT EXECUTED
106bcc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
106bd0: c7 45 10 01 00 00 00 movl $0x1,0x10(%ebp)
106bd7: 8b 46 58 mov 0x58(%esi),%eax
106bda: 89 75 08 mov %esi,0x8(%ebp)
106bdd: 89 45 0c mov %eax,0xc(%ebp)
}
106be0: 83 c4 0c add $0xc,%esp
106be3: 5b pop %ebx
106be4: 5e pop %esi
106be5: 5f pop %edi
106be6: 5d pop %ebp
ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
106be7: e9 14 e6 ff ff jmp 105200 <jffs2_prealloc_raw_node_refs>
106bec: 90 nop
106bed: 90 nop
106bee: 90 nop
106bef: 90 nop
0010ba60 <jffs2_rmdir>:
int jffs2_rmdir (struct _inode *dir_i, struct _inode *d_inode, const unsigned char *d_name, size_t d_namelen)
{
10ba60: 55 push %ebp
10ba61: 89 e5 mov %esp,%ebp
10ba63: 56 push %esi
10ba64: 53 push %ebx
10ba65: 83 ec 20 sub $0x20,%esp
10ba68: 8b 5d 0c mov 0xc(%ebp),%ebx
struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode);
struct jffs2_full_dirent *fd;
for (fd = f->dents ; fd; fd = fd->next) {
10ba6b: 8b 43 50 mov 0x50(%ebx),%eax
10ba6e: 85 c0 test %eax,%eax
10ba70: 75 15 jne 10ba87 <jffs2_rmdir+0x27>
10ba72: eb 2c jmp 10baa0 <jffs2_rmdir+0x40>
10ba74: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10ba7b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10ba7f: 90 nop
10ba80: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED
10ba83: 85 c0 test %eax,%eax <== NOT EXECUTED
10ba85: 74 19 je 10baa0 <jffs2_rmdir+0x40> <== NOT EXECUTED
if (fd->ino)
10ba87: 8b 50 0c mov 0xc(%eax),%edx
10ba8a: 85 d2 test %edx,%edx
10ba8c: 74 f2 je 10ba80 <jffs2_rmdir+0x20> <== NEVER TAKEN
return -ENOTEMPTY;
10ba8e: b8 a6 ff ff ff mov $0xffffffa6,%eax
}
return jffs2_unlink(dir_i, d_inode, d_name, d_namelen);
}
10ba93: 83 c4 20 add $0x20,%esp
10ba96: 5b pop %ebx
10ba97: 5e pop %esi
10ba98: 5d pop %ebp
10ba99: c3 ret
10ba9a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
10baa0: 8b 45 08 mov 0x8(%ebp),%eax
10baa3: 8b 70 3c mov 0x3c(%eax),%esi
d_namelen, dead_f, get_seconds());
10baa6: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10baad: e8 7e ef 01 00 call 12aa30 <time>
ret = jffs2_do_unlink(c, dir_f, (const char *)d_name,
10bab2: 89 34 24 mov %esi,(%esp)
10bab5: 89 44 24 14 mov %eax,0x14(%esp)
struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(d_inode);
10bab9: 8d 43 44 lea 0x44(%ebx),%eax
10babc: 89 44 24 10 mov %eax,0x10(%esp)
ret = jffs2_do_unlink(c, dir_f, (const char *)d_name,
10bac0: 8b 45 14 mov 0x14(%ebp),%eax
10bac3: 89 44 24 0c mov %eax,0xc(%esp)
10bac7: 8b 45 10 mov 0x10(%ebp),%eax
10baca: 89 44 24 08 mov %eax,0x8(%esp)
struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
10bace: 8b 45 08 mov 0x8(%ebp),%eax
10bad1: 83 c0 44 add $0x44,%eax
10bad4: 89 44 24 04 mov %eax,0x4(%esp)
ret = jffs2_do_unlink(c, dir_f, (const char *)d_name,
10bad8: e8 73 e9 ff ff call 10a450 <jffs2_do_unlink>
if (dead_f->inocache)
10badd: 8b 53 58 mov 0x58(%ebx),%edx
10bae0: 85 d2 test %edx,%edx
10bae2: 74 af je 10ba93 <jffs2_rmdir+0x33> <== NEVER TAKEN
d_inode->i_nlink = dead_f->inocache->pino_nlink;
10bae4: 8b 52 14 mov 0x14(%edx),%edx
10bae7: 66 89 53 0c mov %dx,0xc(%ebx)
}
10baeb: 83 c4 20 add $0x20,%esp
10baee: 5b pop %ebx
10baef: 5e pop %esi
10baf0: 5d pop %ebp
10baf1: c3 ret
10baf2: 90 nop
10baf3: 90 nop
10baf4: 90 nop
10baf5: 90 nop
10baf6: 90 nop
10baf7: 90 nop
10baf8: 90 nop
10baf9: 90 nop
10bafa: 90 nop
10bafb: 90 nop
10bafc: 90 nop
10bafd: 90 nop
10bafe: 90 nop
10baff: 90 nop
0010d8f0 <jffs2_rotate_lists>:
}
list_add(head, n);
}
void jffs2_rotate_lists(struct jffs2_sb_info *c)
{
10d8f0: 55 push %ebp
10d8f1: 89 e5 mov %esp,%ebp
10d8f3: 57 push %edi
10d8f4: 56 push %esi
10d8f5: 53 push %ebx
10d8f6: 8b 5d 08 mov 0x8(%ebp),%ebx
list_for_each(tmp, l) {
10d8f9: 8b 7b 60 mov 0x60(%ebx),%edi
uint32_t x;
uint32_t rotateby;
x = count_list(&c->clean_list);
10d8fc: 8d 43 60 lea 0x60(%ebx),%eax
list_for_each(tmp, l) {
10d8ff: 39 f8 cmp %edi,%eax
10d901: 74 1c je 10d91f <jffs2_rotate_lists+0x2f> <== ALWAYS TAKEN
10d903: 89 f9 mov %edi,%ecx <== NOT EXECUTED
uint32_t count = 0;
10d905: 31 f6 xor %esi,%esi <== NOT EXECUTED
10d907: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10d90e: 66 90 xchg %ax,%ax <== NOT EXECUTED
list_for_each(tmp, l) {
10d910: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED
count++;
10d912: 46 inc %esi <== NOT EXECUTED
list_for_each(tmp, l) {
10d913: 39 c8 cmp %ecx,%eax <== NOT EXECUTED
10d915: 75 f9 jne 10d910 <jffs2_rotate_lists+0x20> <== NOT EXECUTED
if (x) {
10d917: 85 f6 test %esi,%esi <== NOT EXECUTED
10d919: 0f 85 81 00 00 00 jne 10d9a0 <jffs2_rotate_lists+0xb0> <== NOT EXECUTED
list_for_each(tmp, l) {
10d91f: 8b 7b 68 mov 0x68(%ebx),%edi
rotateby = pseudo_random % x;
rotate_list((&c->clean_list), rotateby);
}
x = count_list(&c->very_dirty_list);
10d922: 8d 43 68 lea 0x68(%ebx),%eax
list_for_each(tmp, l) {
10d925: 39 f8 cmp %edi,%eax
10d927: 74 16 je 10d93f <jffs2_rotate_lists+0x4f> <== ALWAYS TAKEN
10d929: 89 f9 mov %edi,%ecx <== NOT EXECUTED
uint32_t count = 0;
10d92b: 31 f6 xor %esi,%esi <== NOT EXECUTED
10d92d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
list_for_each(tmp, l) {
10d930: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED
count++;
10d932: 46 inc %esi <== NOT EXECUTED
list_for_each(tmp, l) {
10d933: 39 c8 cmp %ecx,%eax <== NOT EXECUTED
10d935: 75 f9 jne 10d930 <jffs2_rotate_lists+0x40> <== NOT EXECUTED
if (x) {
10d937: 85 f6 test %esi,%esi <== NOT EXECUTED
10d939: 0f 85 c1 01 00 00 jne 10db00 <jffs2_rotate_lists+0x210> <== NOT EXECUTED
list_for_each(tmp, l) {
10d93f: 8b 7b 70 mov 0x70(%ebx),%edi
rotateby = pseudo_random % x;
rotate_list((&c->very_dirty_list), rotateby);
}
x = count_list(&c->dirty_list);
10d942: 8d 43 70 lea 0x70(%ebx),%eax
list_for_each(tmp, l) {
10d945: 39 f8 cmp %edi,%eax
10d947: 74 16 je 10d95f <jffs2_rotate_lists+0x6f> <== ALWAYS TAKEN
10d949: 89 f9 mov %edi,%ecx <== NOT EXECUTED
uint32_t count = 0;
10d94b: 31 f6 xor %esi,%esi <== NOT EXECUTED
10d94d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
list_for_each(tmp, l) {
10d950: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED
count++;
10d952: 46 inc %esi <== NOT EXECUTED
list_for_each(tmp, l) {
10d953: 39 c8 cmp %ecx,%eax <== NOT EXECUTED
10d955: 75 f9 jne 10d950 <jffs2_rotate_lists+0x60> <== NOT EXECUTED
if (x) {
10d957: 85 f6 test %esi,%esi <== NOT EXECUTED
10d959: 0f 85 61 01 00 00 jne 10dac0 <jffs2_rotate_lists+0x1d0> <== NOT EXECUTED
list_for_each(tmp, l) {
10d95f: 8b 7b 78 mov 0x78(%ebx),%edi
rotateby = pseudo_random % x;
rotate_list((&c->dirty_list), rotateby);
}
x = count_list(&c->erasable_list);
10d962: 8d 43 78 lea 0x78(%ebx),%eax
list_for_each(tmp, l) {
10d965: 39 f8 cmp %edi,%eax
10d967: 74 16 je 10d97f <jffs2_rotate_lists+0x8f> <== ALWAYS TAKEN
10d969: 89 f9 mov %edi,%ecx <== NOT EXECUTED
uint32_t count = 0;
10d96b: 31 f6 xor %esi,%esi <== NOT EXECUTED
10d96d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
list_for_each(tmp, l) {
10d970: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED
count++;
10d972: 46 inc %esi <== NOT EXECUTED
list_for_each(tmp, l) {
10d973: 39 c8 cmp %ecx,%eax <== NOT EXECUTED
10d975: 75 f9 jne 10d970 <jffs2_rotate_lists+0x80> <== NOT EXECUTED
if (x) {
10d977: 85 f6 test %esi,%esi <== NOT EXECUTED
10d979: 0f 85 01 01 00 00 jne 10da80 <jffs2_rotate_lists+0x190> <== NOT EXECUTED
rotateby = pseudo_random % x;
rotate_list((&c->erasable_list), rotateby);
}
if (c->nr_erasing_blocks) {
10d97f: 8b 4b 40 mov 0x40(%ebx),%ecx
10d982: 85 c9 test %ecx,%ecx
10d984: 0f 85 a6 00 00 00 jne 10da30 <jffs2_rotate_lists+0x140> <== ALWAYS TAKEN
rotateby = pseudo_random % c->nr_erasing_blocks;
rotate_list((&c->erase_pending_list), rotateby);
}
if (c->nr_free_blocks) {
10d98a: 8b 4b 3c mov 0x3c(%ebx),%ecx
10d98d: 85 c9 test %ecx,%ecx
10d98f: 75 4f jne 10d9e0 <jffs2_rotate_lists+0xf0> <== NEVER TAKEN
rotateby = pseudo_random % c->nr_free_blocks;
rotate_list((&c->free_list), rotateby);
}
}
10d991: 5b pop %ebx
10d992: 5e pop %esi
10d993: 5f pop %edi
10d994: 5d pop %ebp
10d995: c3 ret
10d996: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10d99d: 8d 76 00 lea 0x0(%esi),%esi
rotateby = pseudo_random % x;
10d9a0: a1 b8 b7 15 00 mov 0x15b7b8,%eax <== NOT EXECUTED
10d9a5: 31 d2 xor %edx,%edx <== NOT EXECUTED
10d9a7: f7 f6 div %esi <== NOT EXECUTED
ent->prev->next = ent->next;
10d9a9: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED
10d9ac: 89 38 mov %edi,(%eax) <== NOT EXECUTED
ent->next->prev = ent->prev;
10d9ae: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED
while(count--) {
10d9b1: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED
10d9b4: 85 d2 test %edx,%edx <== NOT EXECUTED
10d9b6: 74 0f je 10d9c7 <jffs2_rotate_lists+0xd7> <== NOT EXECUTED
10d9b8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10d9bf: 90 nop <== NOT EXECUTED
10d9c0: 83 e8 01 sub $0x1,%eax <== NOT EXECUTED
n = n->next;
10d9c3: 8b 3f mov (%edi),%edi <== NOT EXECUTED
while(count--) {
10d9c5: 73 f9 jae 10d9c0 <jffs2_rotate_lists+0xd0> <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10d9c7: 8b 07 mov (%edi),%eax <== NOT EXECUTED
newent->prev = afterthisent;
10d9c9: 89 7b 64 mov %edi,0x64(%ebx) <== NOT EXECUTED
newent->next = next;
10d9cc: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED
afterthisent->next = newent;
10d9cf: 89 0f mov %ecx,(%edi) <== NOT EXECUTED
next->prev = newent;
10d9d1: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED
}
10d9d4: e9 46 ff ff ff jmp 10d91f <jffs2_rotate_lists+0x2f> <== NOT EXECUTED
10d9d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
rotateby = pseudo_random % c->nr_free_blocks;
10d9e0: a1 b8 b7 15 00 mov 0x15b7b8,%eax <== NOT EXECUTED
rotate_list((&c->free_list), rotateby);
10d9e5: 8d b3 a8 00 00 00 lea 0xa8(%ebx),%esi <== NOT EXECUTED
rotateby = pseudo_random % c->nr_free_blocks;
10d9eb: 31 d2 xor %edx,%edx <== NOT EXECUTED
10d9ed: f7 f1 div %ecx <== NOT EXECUTED
ent->prev->next = ent->next;
10d9ef: 8b 83 ac 00 00 00 mov 0xac(%ebx),%eax <== NOT EXECUTED
struct list_head *n = head->next;
10d9f5: 8b 8b a8 00 00 00 mov 0xa8(%ebx),%ecx <== NOT EXECUTED
10d9fb: 89 08 mov %ecx,(%eax) <== NOT EXECUTED
ent->next->prev = ent->prev;
10d9fd: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED
while(count--) {
10da00: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED
10da03: 85 d2 test %edx,%edx <== NOT EXECUTED
10da05: 74 10 je 10da17 <jffs2_rotate_lists+0x127> <== NOT EXECUTED
10da07: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10da0e: 66 90 xchg %ax,%ax <== NOT EXECUTED
10da10: 83 e8 01 sub $0x1,%eax <== NOT EXECUTED
n = n->next;
10da13: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED
while(count--) {
10da15: 73 f9 jae 10da10 <jffs2_rotate_lists+0x120> <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10da17: 8b 01 mov (%ecx),%eax <== NOT EXECUTED
newent->prev = afterthisent;
10da19: 89 8b ac 00 00 00 mov %ecx,0xac(%ebx) <== NOT EXECUTED
newent->next = next;
10da1f: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) <== NOT EXECUTED
afterthisent->next = newent;
10da25: 89 31 mov %esi,(%ecx) <== NOT EXECUTED
next->prev = newent;
10da27: 89 70 04 mov %esi,0x4(%eax) <== NOT EXECUTED
}
10da2a: 5b pop %ebx <== NOT EXECUTED
10da2b: 5e pop %esi <== NOT EXECUTED
10da2c: 5f pop %edi <== NOT EXECUTED
10da2d: 5d pop %ebp <== NOT EXECUTED
10da2e: c3 ret <== NOT EXECUTED
10da2f: 90 nop <== NOT EXECUTED
rotateby = pseudo_random % c->nr_erasing_blocks;
10da30: a1 b8 b7 15 00 mov 0x15b7b8,%eax
rotate_list((&c->erase_pending_list), rotateby);
10da35: 8d b3 98 00 00 00 lea 0x98(%ebx),%esi
rotateby = pseudo_random % c->nr_erasing_blocks;
10da3b: 31 d2 xor %edx,%edx
10da3d: f7 f1 div %ecx
ent->prev->next = ent->next;
10da3f: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax
struct list_head *n = head->next;
10da45: 8b 8b 98 00 00 00 mov 0x98(%ebx),%ecx
10da4b: 89 08 mov %ecx,(%eax)
ent->next->prev = ent->prev;
10da4d: 89 41 04 mov %eax,0x4(%ecx)
while(count--) {
10da50: 8d 42 ff lea -0x1(%edx),%eax
10da53: 85 d2 test %edx,%edx
10da55: 74 10 je 10da67 <jffs2_rotate_lists+0x177> <== ALWAYS TAKEN
10da57: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10da5e: 66 90 xchg %ax,%ax
10da60: 83 e8 01 sub $0x1,%eax <== NOT EXECUTED
n = n->next;
10da63: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED
while(count--) {
10da65: 73 f9 jae 10da60 <jffs2_rotate_lists+0x170> <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10da67: 8b 01 mov (%ecx),%eax
newent->prev = afterthisent;
10da69: 89 8b 9c 00 00 00 mov %ecx,0x9c(%ebx)
newent->next = next;
10da6f: 89 83 98 00 00 00 mov %eax,0x98(%ebx)
afterthisent->next = newent;
10da75: 89 31 mov %esi,(%ecx)
next->prev = newent;
10da77: 89 70 04 mov %esi,0x4(%eax)
}
10da7a: e9 0b ff ff ff jmp 10d98a <jffs2_rotate_lists+0x9a>
10da7f: 90 nop
rotateby = pseudo_random % x;
10da80: a1 b8 b7 15 00 mov 0x15b7b8,%eax <== NOT EXECUTED
10da85: 31 d2 xor %edx,%edx <== NOT EXECUTED
10da87: f7 f6 div %esi <== NOT EXECUTED
ent->prev->next = ent->next;
10da89: 8b 43 7c mov 0x7c(%ebx),%eax <== NOT EXECUTED
10da8c: 89 38 mov %edi,(%eax) <== NOT EXECUTED
ent->next->prev = ent->prev;
10da8e: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED
while(count--) {
10da91: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED
10da94: 85 d2 test %edx,%edx <== NOT EXECUTED
10da96: 74 0f je 10daa7 <jffs2_rotate_lists+0x1b7> <== NOT EXECUTED
10da98: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10da9f: 90 nop <== NOT EXECUTED
10daa0: 83 e8 01 sub $0x1,%eax <== NOT EXECUTED
n = n->next;
10daa3: 8b 3f mov (%edi),%edi <== NOT EXECUTED
while(count--) {
10daa5: 73 f9 jae 10daa0 <jffs2_rotate_lists+0x1b0> <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10daa7: 8b 07 mov (%edi),%eax <== NOT EXECUTED
newent->prev = afterthisent;
10daa9: 89 7b 7c mov %edi,0x7c(%ebx) <== NOT EXECUTED
newent->next = next;
10daac: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED
afterthisent->next = newent;
10daaf: 89 0f mov %ecx,(%edi) <== NOT EXECUTED
next->prev = newent;
10dab1: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED
}
10dab4: e9 c6 fe ff ff jmp 10d97f <jffs2_rotate_lists+0x8f> <== NOT EXECUTED
10dab9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
rotateby = pseudo_random % x;
10dac0: a1 b8 b7 15 00 mov 0x15b7b8,%eax <== NOT EXECUTED
10dac5: 31 d2 xor %edx,%edx <== NOT EXECUTED
10dac7: f7 f6 div %esi <== NOT EXECUTED
ent->prev->next = ent->next;
10dac9: 8b 43 74 mov 0x74(%ebx),%eax <== NOT EXECUTED
10dacc: 89 38 mov %edi,(%eax) <== NOT EXECUTED
ent->next->prev = ent->prev;
10dace: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED
while(count--) {
10dad1: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED
10dad4: 85 d2 test %edx,%edx <== NOT EXECUTED
10dad6: 74 0f je 10dae7 <jffs2_rotate_lists+0x1f7> <== NOT EXECUTED
10dad8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10dadf: 90 nop <== NOT EXECUTED
10dae0: 83 e8 01 sub $0x1,%eax <== NOT EXECUTED
n = n->next;
10dae3: 8b 3f mov (%edi),%edi <== NOT EXECUTED
while(count--) {
10dae5: 73 f9 jae 10dae0 <jffs2_rotate_lists+0x1f0> <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10dae7: 8b 07 mov (%edi),%eax <== NOT EXECUTED
newent->prev = afterthisent;
10dae9: 89 7b 74 mov %edi,0x74(%ebx) <== NOT EXECUTED
newent->next = next;
10daec: 89 43 70 mov %eax,0x70(%ebx) <== NOT EXECUTED
afterthisent->next = newent;
10daef: 89 0f mov %ecx,(%edi) <== NOT EXECUTED
next->prev = newent;
10daf1: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED
}
10daf4: e9 66 fe ff ff jmp 10d95f <jffs2_rotate_lists+0x6f> <== NOT EXECUTED
10daf9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
rotateby = pseudo_random % x;
10db00: a1 b8 b7 15 00 mov 0x15b7b8,%eax <== NOT EXECUTED
10db05: 31 d2 xor %edx,%edx <== NOT EXECUTED
10db07: f7 f6 div %esi <== NOT EXECUTED
ent->prev->next = ent->next;
10db09: 8b 43 6c mov 0x6c(%ebx),%eax <== NOT EXECUTED
10db0c: 89 38 mov %edi,(%eax) <== NOT EXECUTED
ent->next->prev = ent->prev;
10db0e: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED
while(count--) {
10db11: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED
10db14: 85 d2 test %edx,%edx <== NOT EXECUTED
10db16: 74 0f je 10db27 <jffs2_rotate_lists+0x237> <== NOT EXECUTED
10db18: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10db1f: 90 nop <== NOT EXECUTED
10db20: 83 e8 01 sub $0x1,%eax <== NOT EXECUTED
n = n->next;
10db23: 8b 3f mov (%edi),%edi <== NOT EXECUTED
while(count--) {
10db25: 73 f9 jae 10db20 <jffs2_rotate_lists+0x230> <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10db27: 8b 07 mov (%edi),%eax <== NOT EXECUTED
newent->prev = afterthisent;
10db29: 89 7b 6c mov %edi,0x6c(%ebx) <== NOT EXECUTED
newent->next = next;
10db2c: 89 43 68 mov %eax,0x68(%ebx) <== NOT EXECUTED
afterthisent->next = newent;
10db2f: 89 0f mov %ecx,(%edi) <== NOT EXECUTED
next->prev = newent;
10db31: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED
}
10db34: e9 06 fe ff ff jmp 10d93f <jffs2_rotate_lists+0x4f> <== NOT EXECUTED
10db39: 90 nop
10db3a: 90 nop
10db3b: 90 nop
10db3c: 90 nop
10db3d: 90 nop
10db3e: 90 nop
10db3f: 90 nop
0010c6b0 <jffs2_scan_classify_jeb>:
}
return 0;
}
int jffs2_scan_classify_jeb(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
{
10c6b0: 55 push %ebp <== NOT EXECUTED
10c6b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10c6b3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED
10c6b6: 89 7d fc mov %edi,-0x4(%ebp) <== NOT EXECUTED
if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size
10c6b9: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
{
10c6bc: 89 75 f8 mov %esi,-0x8(%ebp) <== NOT EXECUTED
10c6bf: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
10c6c2: 89 5d f4 mov %ebx,-0xc(%ebp) <== NOT EXECUTED
if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size
10c6c5: 8b 7a 14 mov 0x14(%edx),%edi <== NOT EXECUTED
10c6c8: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED
10c6cb: 8b 70 10 mov 0x10(%eax),%esi <== NOT EXECUTED
10c6ce: 83 c7 03 add $0x3,%edi <== NOT EXECUTED
10c6d1: 83 e7 fc and $0xfffffffc,%edi <== NOT EXECUTED
10c6d4: 8d 1c 31 lea (%ecx,%esi,1),%ebx <== NOT EXECUTED
10c6d7: 39 fb cmp %edi,%ebx <== NOT EXECUTED
10c6d9: 74 35 je 10c710 <jffs2_scan_classify_jeb+0x60> <== NOT EXECUTED
&& (!jeb->first_node || !ref_next(jeb->first_node)) )
return BLK_STATE_CLEANMARKER;
/* move blocks with max 4 byte dirty space to cleanlist */
else if (!ISDIRTY(c->sector_size - (jeb->used_size + jeb->unchecked_size))) {
10c6db: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED
10c6de: 8b 7a 34 mov 0x34(%edx),%edi <== NOT EXECUTED
10c6e1: 29 df sub %ebx,%edi <== NOT EXECUTED
10c6e3: 81 ff c4 00 00 00 cmp $0xc4,%edi <== NOT EXECUTED
10c6e9: 76 55 jbe 10c740 <jffs2_scan_classify_jeb+0x90> <== NOT EXECUTED
c->dirty_size -= jeb->dirty_size;
c->wasted_size += jeb->dirty_size;
jeb->wasted_size += jeb->dirty_size;
jeb->dirty_size = 0;
return BLK_STATE_CLEAN;
} else if (jeb->used_size || jeb->unchecked_size)
10c6eb: 09 f1 or %esi,%ecx <== NOT EXECUTED
return BLK_STATE_PARTDIRTY;
else
return BLK_STATE_ALLDIRTY;
10c6ed: 83 f9 01 cmp $0x1,%ecx <== NOT EXECUTED
10c6f0: 19 c0 sbb %eax,%eax <== NOT EXECUTED
10c6f2: 83 e0 02 and $0x2,%eax <== NOT EXECUTED
10c6f5: 83 c0 02 add $0x2,%eax <== NOT EXECUTED
}
10c6f8: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED
10c6fb: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED
10c6fe: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED
10c701: 89 ec mov %ebp,%esp <== NOT EXECUTED
10c703: 5d pop %ebp <== NOT EXECUTED
10c704: c3 ret <== NOT EXECUTED
10c705: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10c70c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size
10c710: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED
10c713: 85 d2 test %edx,%edx <== NOT EXECUTED
10c715: 75 c4 jne 10c6db <jffs2_scan_classify_jeb+0x2b> <== NOT EXECUTED
&& (!jeb->first_node || !ref_next(jeb->first_node)) )
10c717: 8b 78 28 mov 0x28(%eax),%edi <== NOT EXECUTED
10c71a: 85 ff test %edi,%edi <== NOT EXECUTED
10c71c: 74 0d je 10c72b <jffs2_scan_classify_jeb+0x7b> <== NOT EXECUTED
if (ref->flash_offset == REF_LINK_NODE) {
10c71e: 8b 57 0c mov 0xc(%edi),%edx <== NOT EXECUTED
10c721: 83 fa ff cmp $0xffffffff,%edx <== NOT EXECUTED
10c724: 74 4a je 10c770 <jffs2_scan_classify_jeb+0xc0> <== NOT EXECUTED
if (ref->flash_offset == REF_EMPTY_NODE)
10c726: 83 fa fe cmp $0xfffffffe,%edx <== NOT EXECUTED
10c729: 75 b0 jne 10c6db <jffs2_scan_classify_jeb+0x2b> <== NOT EXECUTED
return BLK_STATE_CLEANMARKER;
10c72b: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED
10c730: eb c6 jmp 10c6f8 <jffs2_scan_classify_jeb+0x48> <== NOT EXECUTED
10c732: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10c739: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
c->dirty_size -= jeb->dirty_size;
10c740: 8b 48 18 mov 0x18(%eax),%ecx <== NOT EXECUTED
10c743: 29 4a 20 sub %ecx,0x20(%edx) <== NOT EXECUTED
c->wasted_size += jeb->dirty_size;
10c746: 01 4a 24 add %ecx,0x24(%edx) <== NOT EXECUTED
jeb->wasted_size += jeb->dirty_size;
10c749: 01 48 1c add %ecx,0x1c(%eax) <== NOT EXECUTED
}
10c74c: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED
jeb->dirty_size = 0;
10c74f: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED
}
10c756: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED
return BLK_STATE_CLEAN;
10c759: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
}
10c75e: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED
10c761: 89 ec mov %ebp,%esp <== NOT EXECUTED
10c763: 5d pop %ebp <== NOT EXECUTED
10c764: c3 ret <== NOT EXECUTED
10c765: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10c76c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
ref = ref->next_in_ino;
10c770: 8b 7f 08 mov 0x8(%edi),%edi <== NOT EXECUTED
if (!ref)
10c773: 85 ff test %edi,%edi <== NOT EXECUTED
10c775: 74 b4 je 10c72b <jffs2_scan_classify_jeb+0x7b> <== NOT EXECUTED
if (ref->flash_offset == REF_EMPTY_NODE)
10c777: 8b 57 04 mov 0x4(%edi),%edx <== NOT EXECUTED
10c77a: eb aa jmp 10c726 <jffs2_scan_classify_jeb+0x76> <== NOT EXECUTED
10c77c: 90 nop
10c77d: 90 nop
10c77e: 90 nop
10c77f: 90 nop
00106050 <jffs2_scan_dirty_space>:
{
106050: 55 push %ebp <== NOT EXECUTED
106051: 89 e5 mov %esp,%ebp <== NOT EXECUTED
106053: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED
106056: 89 5d f8 mov %ebx,-0x8(%ebp) <== NOT EXECUTED
106059: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10605c: 89 75 fc mov %esi,-0x4(%ebp) <== NOT EXECUTED
10605f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
106062: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
if (!size)
106065: 85 c0 test %eax,%eax <== NOT EXECUTED
106067: 74 3e je 1060a7 <jffs2_scan_dirty_space+0x57> <== NOT EXECUTED
if (unlikely(size > jeb->free_size)) {
106069: 8b 72 20 mov 0x20(%edx),%esi <== NOT EXECUTED
10606c: 39 c6 cmp %eax,%esi <== NOT EXECUTED
10606e: 72 6a jb 1060da <jffs2_scan_dirty_space+0x8a> <== NOT EXECUTED
if (jeb->last_node && ref_obsolete(jeb->last_node)) {
106070: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED
106073: 85 c9 test %ecx,%ecx <== NOT EXECUTED
106075: 74 09 je 106080 <jffs2_scan_dirty_space+0x30> <== NOT EXECUTED
106077: 8b 49 04 mov 0x4(%ecx),%ecx <== NOT EXECUTED
10607a: 83 e1 03 and $0x3,%ecx <== NOT EXECUTED
10607d: 49 dec %ecx <== NOT EXECUTED
10607e: 74 40 je 1060c0 <jffs2_scan_dirty_space+0x70> <== NOT EXECUTED
uint32_t ofs = jeb->offset + c->sector_size - jeb->free_size;
106080: 8b 4b 34 mov 0x34(%ebx),%ecx <== NOT EXECUTED
106083: 03 4a 0c add 0xc(%edx),%ecx <== NOT EXECUTED
jffs2_link_node_ref(c, jeb, ofs, size, NULL);
106086: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
10608a: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
10608e: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
uint32_t ofs = jeb->offset + c->sector_size - jeb->free_size;
106091: 29 f1 sub %esi,%ecx <== NOT EXECUTED
jffs2_link_node_ref(c, jeb, ofs, size, NULL);
106093: 31 f6 xor %esi,%esi <== NOT EXECUTED
106095: 89 74 24 10 mov %esi,0x10(%esp) <== NOT EXECUTED
ofs |= REF_OBSOLETE;
106099: 89 c8 mov %ecx,%eax <== NOT EXECUTED
10609b: 83 c8 01 or $0x1,%eax <== NOT EXECUTED
jffs2_link_node_ref(c, jeb, ofs, size, NULL);
10609e: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1060a2: e8 b9 fd ff ff call 105e60 <jffs2_link_node_ref> <== NOT EXECUTED
}
1060a7: 8b 5d f8 mov -0x8(%ebp),%ebx <== NOT EXECUTED
1060aa: 31 c0 xor %eax,%eax <== NOT EXECUTED
1060ac: 8b 75 fc mov -0x4(%ebp),%esi <== NOT EXECUTED
1060af: 89 ec mov %ebp,%esp <== NOT EXECUTED
1060b1: 5d pop %ebp <== NOT EXECUTED
1060b2: c3 ret <== NOT EXECUTED
1060b3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1060ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
c->dirty_size += size;
1060c0: 01 43 20 add %eax,0x20(%ebx) <== NOT EXECUTED
jeb->free_size -= size;
1060c3: 29 c6 sub %eax,%esi <== NOT EXECUTED
c->free_size -= size;
1060c5: 29 43 28 sub %eax,0x28(%ebx) <== NOT EXECUTED
jeb->dirty_size += size;
1060c8: 01 42 18 add %eax,0x18(%edx) <== NOT EXECUTED
}
1060cb: 31 c0 xor %eax,%eax <== NOT EXECUTED
1060cd: 8b 5d f8 mov -0x8(%ebp),%ebx <== NOT EXECUTED
jeb->free_size -= size;
1060d0: 89 72 20 mov %esi,0x20(%edx) <== NOT EXECUTED
}
1060d3: 8b 75 fc mov -0x4(%ebp),%esi <== NOT EXECUTED
1060d6: 89 ec mov %ebp,%esp <== NOT EXECUTED
1060d8: 5d pop %ebp <== NOT EXECUTED
1060d9: c3 ret <== NOT EXECUTED
pr_crit("Dirty space 0x%x larger then free_size 0x%x (wasted 0x%x)\n",
1060da: 8b 52 1c mov 0x1c(%edx),%edx <== NOT EXECUTED
1060dd: 89 74 24 08 mov %esi,0x8(%esp) <== NOT EXECUTED
1060e1: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1060e5: c7 04 24 20 ec 12 00 movl $0x12ec20,(%esp) <== NOT EXECUTED
1060ec: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED
1060f0: e8 8b f2 ff ff call 105380 <jffs2_printk> <== NOT EXECUTED
BUG();
1060f5: c7 44 24 0c 3b d6 12 movl $0x12d63b,0xc(%esp) <== NOT EXECUTED
1060fc: 00
1060fd: c7 44 24 08 b8 ec 12 movl $0x12ecb8,0x8(%esp) <== NOT EXECUTED
106104: 00
106105: c7 44 24 04 a0 02 00 movl $0x2a0,0x4(%esp) <== NOT EXECUTED
10610c: 00
10610d: c7 04 24 44 eb 12 00 movl $0x12eb44,(%esp) <== NOT EXECUTED
106114: e8 57 7b 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED
106119: 90 nop
10611a: 90 nop
10611b: 90 nop
10611c: 90 nop
10611d: 90 nop
10611e: 90 nop
10611f: 90 nop
0010c780 <jffs2_scan_make_ino_cache>:
return jffs2_scan_classify_jeb(c, jeb);
}
struct jffs2_inode_cache *jffs2_scan_make_ino_cache(struct jffs2_sb_info *c, uint32_t ino)
{
10c780: 55 push %ebp <== NOT EXECUTED
10c781: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10c783: 83 ec 38 sub $0x38,%esp <== NOT EXECUTED
10c786: 89 75 f8 mov %esi,-0x8(%ebp) <== NOT EXECUTED
struct jffs2_inode_cache *ic;
ic = jffs2_get_ino_cache(c, ino);
10c789: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
{
10c78c: 89 5d f4 mov %ebx,-0xc(%ebp) <== NOT EXECUTED
10c78f: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
10c792: 89 7d fc mov %edi,-0x4(%ebp) <== NOT EXECUTED
ic = jffs2_get_ino_cache(c, ino);
10c795: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10c798: 89 74 24 04 mov %esi,0x4(%esp) <== NOT EXECUTED
10c79c: e8 af 93 ff ff call 105b50 <jffs2_get_ino_cache> <== NOT EXECUTED
if (ic)
10c7a1: 85 c0 test %eax,%eax <== NOT EXECUTED
ic = jffs2_get_ino_cache(c, ino);
10c7a3: 89 c3 mov %eax,%ebx <== NOT EXECUTED
if (ic)
10c7a5: 74 19 je 10c7c0 <jffs2_scan_make_ino_cache+0x40> <== NOT EXECUTED
ic->nodes = (void *)ic;
jffs2_add_ino_cache(c, ic);
if (ino == 1)
ic->pino_nlink = 1;
return ic;
}
10c7a7: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED
10c7aa: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10c7ac: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED
10c7af: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED
10c7b2: 89 ec mov %ebp,%esp <== NOT EXECUTED
10c7b4: 5d pop %ebp <== NOT EXECUTED
10c7b5: c3 ret <== NOT EXECUTED
10c7b6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10c7bd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (ino > c->highest_ino)
10c7c0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
10c7c3: 3b 70 04 cmp 0x4(%eax),%esi <== NOT EXECUTED
10c7c6: 76 03 jbe 10c7cb <jffs2_scan_make_ino_cache+0x4b> <== NOT EXECUTED
c->highest_ino = ino;
10c7c8: 89 70 04 mov %esi,0x4(%eax) <== NOT EXECUTED
ic = jffs2_alloc_inode_cache();
10c7cb: e8 20 8b ff ff call 1052f0 <jffs2_alloc_inode_cache> <== NOT EXECUTED
if (!ic) {
10c7d0: 85 c0 test %eax,%eax <== NOT EXECUTED
ic = jffs2_alloc_inode_cache();
10c7d2: 89 c3 mov %eax,%ebx <== NOT EXECUTED
if (!ic) {
10c7d4: 0f 84 b6 00 00 00 je 10c890 <jffs2_scan_make_ino_cache+0x110> <== NOT EXECUTED
memset(ic, 0, sizeof(*ic));
10c7da: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
10c7dc: a8 01 test $0x1,%al <== NOT EXECUTED
10c7de: 89 c2 mov %eax,%edx <== NOT EXECUTED
10c7e0: bf 18 00 00 00 mov $0x18,%edi <== NOT EXECUTED
10c7e5: 0f 85 95 00 00 00 jne 10c880 <jffs2_scan_make_ino_cache+0x100> <== NOT EXECUTED
10c7eb: f6 c2 02 test $0x2,%dl <== NOT EXECUTED
10c7ee: 0f 85 7c 00 00 00 jne 10c870 <jffs2_scan_make_ino_cache+0xf0> <== NOT EXECUTED
10c7f4: 89 f8 mov %edi,%eax <== NOT EXECUTED
10c7f6: 83 e0 f8 and $0xfffffff8,%eax <== NOT EXECUTED
10c7f9: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED
10c7fc: 31 c0 xor %eax,%eax <== NOT EXECUTED
10c7fe: 89 0c 02 mov %ecx,(%edx,%eax,1) <== NOT EXECUTED
10c801: 89 4c 02 04 mov %ecx,0x4(%edx,%eax,1) <== NOT EXECUTED
10c805: 83 c0 08 add $0x8,%eax <== NOT EXECUTED
10c808: 3b 45 e4 cmp -0x1c(%ebp),%eax <== NOT EXECUTED
10c80b: 72 f1 jb 10c7fe <jffs2_scan_make_ino_cache+0x7e> <== NOT EXECUTED
10c80d: 01 c2 add %eax,%edx <== NOT EXECUTED
10c80f: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
10c815: 74 09 je 10c820 <jffs2_scan_make_ino_cache+0xa0> <== NOT EXECUTED
10c817: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED
10c81d: 83 c2 04 add $0x4,%edx <== NOT EXECUTED
10c820: f7 c7 02 00 00 00 test $0x2,%edi <== NOT EXECUTED
10c826: 74 08 je 10c830 <jffs2_scan_make_ino_cache+0xb0> <== NOT EXECUTED
10c828: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
10c82d: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
10c830: 83 e7 01 and $0x1,%edi <== NOT EXECUTED
10c833: 74 03 je 10c838 <jffs2_scan_make_ino_cache+0xb8> <== NOT EXECUTED
10c835: c6 02 00 movb $0x0,(%edx) <== NOT EXECUTED
ic->ino = ino;
10c838: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED
jffs2_add_ino_cache(c, ic);
10c83b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
ic->nodes = (void *)ic;
10c83e: 89 5b 04 mov %ebx,0x4(%ebx) <== NOT EXECUTED
jffs2_add_ino_cache(c, ic);
10c841: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10c845: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10c848: e8 63 93 ff ff call 105bb0 <jffs2_add_ino_cache> <== NOT EXECUTED
if (ino == 1)
10c84d: 4e dec %esi <== NOT EXECUTED
10c84e: 0f 85 53 ff ff ff jne 10c7a7 <jffs2_scan_make_ino_cache+0x27> <== NOT EXECUTED
ic->pino_nlink = 1;
10c854: c7 43 14 01 00 00 00 movl $0x1,0x14(%ebx) <== NOT EXECUTED
}
10c85b: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED
10c85e: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10c860: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED
10c863: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED
10c866: 89 ec mov %ebp,%esp <== NOT EXECUTED
10c868: 5d pop %ebp <== NOT EXECUTED
10c869: c3 ret <== NOT EXECUTED
10c86a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
memset(ic, 0, sizeof(*ic));
10c870: 66 c7 02 00 00 movw $0x0,(%edx) <== NOT EXECUTED
10c875: 83 ef 02 sub $0x2,%edi <== NOT EXECUTED
10c878: 83 c2 02 add $0x2,%edx <== NOT EXECUTED
10c87b: e9 74 ff ff ff jmp 10c7f4 <jffs2_scan_make_ino_cache+0x74> <== NOT EXECUTED
10c880: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED
10c883: 8d 50 01 lea 0x1(%eax),%edx <== NOT EXECUTED
10c886: bf 17 00 00 00 mov $0x17,%edi <== NOT EXECUTED
10c88b: e9 5b ff ff ff jmp 10c7eb <jffs2_scan_make_ino_cache+0x6b> <== NOT EXECUTED
pr_notice("%s(): allocation of inode cache failed\n", __func__);
10c890: c7 04 24 a8 09 13 00 movl $0x1309a8,(%esp) <== NOT EXECUTED
10c897: b8 50 10 13 00 mov $0x131050,%eax <== NOT EXECUTED
10c89c: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10c8a0: e8 4b fd ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
return NULL;
10c8a5: e9 fd fe ff ff jmp 10c7a7 <jffs2_scan_make_ino_cache+0x27> <== NOT EXECUTED
10c8aa: 90 nop
10c8ab: 90 nop
10c8ac: 90 nop
10c8ad: 90 nop
10c8ae: 90 nop
10c8af: 90 nop
0010c8b0 <jffs2_scan_medium>:
{
10c8b0: 55 push %ebp
10c8b1: 89 e5 mov %esp,%ebp
10c8b3: 57 push %edi
10c8b4: 56 push %esi
10c8b5: 53 push %ebx
10c8b6: 81 ec 8c 00 00 00 sub $0x8c,%esp
flashbuf = mtd_kmalloc_up_to(c->mtd, &try_size);
10c8bc: c7 04 24 00 10 00 00 movl $0x1000,(%esp)
{
10c8c3: 8b 75 08 mov 0x8(%ebp),%esi
flashbuf = mtd_kmalloc_up_to(c->mtd, &try_size);
10c8c6: e8 55 1c 00 00 call 10e520 <malloc>
if (!flashbuf)
10c8cb: 85 c0 test %eax,%eax
10c8cd: 0f 84 88 0e 00 00 je 10d75b <jffs2_scan_medium+0xeab> <== NEVER TAKEN
10c8d3: 89 c7 mov %eax,%edi
for (i=0; i<c->nr_blocks; i++) {
10c8d5: 8b 46 50 mov 0x50(%esi),%eax
10c8d8: 89 45 b8 mov %eax,-0x48(%ebp)
10c8db: 85 c0 test %eax,%eax
10c8dd: 0f 84 ce 0a 00 00 je 10d3b1 <jffs2_scan_medium+0xb01> <== NEVER TAKEN
10c8e3: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp)
uint32_t empty_blocks = 0, bad_blocks = 0;
10c8ea: c7 45 b4 00 00 00 00 movl $0x0,-0x4c(%ebp)
10c8f1: c7 45 b8 00 00 00 00 movl $0x0,-0x48(%ebp)
10c8f8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10c8ff: 90 nop
struct jffs2_eraseblock *jeb = &c->blocks[i];
10c900: 8b 55 d4 mov -0x2c(%ebp),%edx
10c903: 8d 04 52 lea (%edx,%edx,2),%eax
10c906: 8d 14 82 lea (%edx,%eax,4),%edx
10c909: 8b 46 54 mov 0x54(%esi),%eax
10c90c: 8d 0c 90 lea (%eax,%edx,4),%ecx
ofs = jeb->offset;
10c90f: 8b 41 0c mov 0xc(%ecx),%eax
10c912: 89 45 c8 mov %eax,-0x38(%ebp)
buf_len = EMPTY_SCAN_SIZE(c->sector_size);
10c915: 8b 46 34 mov 0x34(%esi),%eax
10c918: 89 45 d0 mov %eax,-0x30(%ebp)
if (sector_size < DEFAULT_EMPTY_SCAN_SIZE)
10c91b: 3d ff 00 00 00 cmp $0xff,%eax
10c920: 76 07 jbe 10c929 <jffs2_scan_medium+0x79> <== NEVER TAKEN
return DEFAULT_EMPTY_SCAN_SIZE;
10c922: c7 45 d0 00 01 00 00 movl $0x100,-0x30(%ebp)
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10c929: 89 7c 24 10 mov %edi,0x10(%esp)
10c92d: 8d 45 dc lea -0x24(%ebp),%eax
10c930: 8b 5d d0 mov -0x30(%ebp),%ebx
10c933: 89 44 24 0c mov %eax,0xc(%esp)
10c937: 8b 45 c8 mov -0x38(%ebp),%eax
10c93a: 89 34 24 mov %esi,(%esp)
10c93d: 89 4d cc mov %ecx,-0x34(%ebp)
10c940: 89 5c 24 08 mov %ebx,0x8(%esp)
10c944: 89 44 24 04 mov %eax,0x4(%esp)
10c948: e8 13 f9 ff ff call 10c260 <jffs2_flash_read>
if (ret) {
10c94d: 8b 4d cc mov -0x34(%ebp),%ecx
10c950: 85 c0 test %eax,%eax
10c952: 0f 85 78 01 00 00 jne 10cad0 <jffs2_scan_medium+0x220> <== NEVER TAKEN
if (retlen < len) {
10c958: 3b 5d dc cmp -0x24(%ebp),%ebx
10c95b: 0f 87 32 08 00 00 ja 10d193 <jffs2_scan_medium+0x8e3> <== NEVER TAKEN
max_ofs = EMPTY_SCAN_SIZE(c->sector_size);
10c961: 8b 46 34 mov 0x34(%esi),%eax
return DEFAULT_EMPTY_SCAN_SIZE;
10c964: ba 00 01 00 00 mov $0x100,%edx
if (sector_size < DEFAULT_EMPTY_SCAN_SIZE)
10c969: 3d ff 00 00 00 cmp $0xff,%eax
10c96e: 77 0a ja 10c97a <jffs2_scan_medium+0xca> <== ALWAYS TAKEN
while(ofs < max_ofs && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF)
10c970: 85 c0 test %eax,%eax <== NOT EXECUTED
10c972: 0f 84 7e 01 00 00 je 10caf6 <jffs2_scan_medium+0x246> <== NOT EXECUTED
10c978: 89 c2 mov %eax,%edx <== NOT EXECUTED
ofs = 0;
10c97a: 31 db xor %ebx,%ebx
10c97c: eb 0d jmp 10c98b <jffs2_scan_medium+0xdb>
10c97e: 66 90 xchg %ax,%ax
ofs += 4;
10c980: 83 c3 04 add $0x4,%ebx
while(ofs < max_ofs && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF)
10c983: 39 d3 cmp %edx,%ebx
10c985: 0f 83 65 01 00 00 jae 10caf0 <jffs2_scan_medium+0x240>
10c98b: 83 3c 1f ff cmpl $0xffffffff,(%edi,%ebx,1)
10c98f: 74 ef je 10c980 <jffs2_scan_medium+0xd0> <== ALWAYS TAKEN
if (ofs) {
10c991: 85 db test %ebx,%ebx <== NOT EXECUTED
10c993: 0f 85 67 04 00 00 jne 10ce00 <jffs2_scan_medium+0x550> <== NOT EXECUTED
ofs += jeb->offset;
10c999: 8b 51 0c mov 0xc(%ecx),%edx <== NOT EXECUTED
10c99c: 01 d3 add %edx,%ebx <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10c99e: 8b 51 0c mov 0xc(%ecx),%edx <== NOT EXECUTED
10c9a1: 01 d0 add %edx,%eax <== NOT EXECUTED
10c9a3: 39 c3 cmp %eax,%ebx <== NOT EXECUTED
10c9a5: 0f 83 f5 00 00 00 jae 10caa0 <jffs2_scan_medium+0x1f0> <== NOT EXECUTED
noise = 10;
10c9ab: c7 45 bc 0a 00 00 00 movl $0xa,-0x44(%ebp) <== NOT EXECUTED
prevofs = jeb->offset - 1;
10c9b2: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED
noise = 10;
10c9b5: 89 7d c4 mov %edi,-0x3c(%ebp) <== NOT EXECUTED
10c9b8: 89 4d cc mov %ecx,-0x34(%ebp) <== NOT EXECUTED
prevofs = jeb->offset - 1;
10c9bb: 48 dec %eax <== NOT EXECUTED
10c9bc: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED
err = jffs2_prealloc_raw_node_refs(c, jeb, 2);
10c9bf: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10c9c2: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED
10c9c5: b9 02 00 00 00 mov $0x2,%ecx <== NOT EXECUTED
10c9ca: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED
10c9ce: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10c9d2: e8 29 88 ff ff call 105200 <jffs2_prealloc_raw_node_refs> <== NOT EXECUTED
if (err)
10c9d7: 85 c0 test %eax,%eax <== NOT EXECUTED
10c9d9: 0f 85 91 02 00 00 jne 10cc70 <jffs2_scan_medium+0x3c0> <== NOT EXECUTED
if (ofs & 3) {
10c9df: f6 c3 03 test $0x3,%bl <== NOT EXECUTED
10c9e2: 0f 85 e8 03 00 00 jne 10cdd0 <jffs2_scan_medium+0x520> <== NOT EXECUTED
if (ofs == prevofs) {
10c9e8: 3b 5d c0 cmp -0x40(%ebp),%ebx <== NOT EXECUTED
10c9eb: 0f 84 5f 04 00 00 je 10ce50 <jffs2_scan_medium+0x5a0> <== NOT EXECUTED
if (jeb->offset + c->sector_size < ofs + sizeof(*node)) {
10c9f1: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED
10c9f4: 8b 46 34 mov 0x34(%esi),%eax <== NOT EXECUTED
10c9f7: 8b 57 0c mov 0xc(%edi),%edx <== NOT EXECUTED
10c9fa: 8d 7b 0c lea 0xc(%ebx),%edi <== NOT EXECUTED
10c9fd: 01 d0 add %edx,%eax <== NOT EXECUTED
10c9ff: 39 f8 cmp %edi,%eax <== NOT EXECUTED
10ca01: 0f 82 14 07 00 00 jb 10d11b <jffs2_scan_medium+0x86b> <== NOT EXECUTED
if (buf_ofs + buf_len < ofs + sizeof(*node)) {
10ca07: 8b 55 c8 mov -0x38(%ebp),%edx <== NOT EXECUTED
10ca0a: 8b 4d d0 mov -0x30(%ebp),%ecx <== NOT EXECUTED
10ca0d: 01 ca add %ecx,%edx <== NOT EXECUTED
10ca0f: 39 d7 cmp %edx,%edi <== NOT EXECUTED
10ca11: 0f 87 b9 02 00 00 ja 10ccd0 <jffs2_scan_medium+0x420> <== NOT EXECUTED
node = (struct jffs2_unknown_node *)&buf[ofs-buf_ofs];
10ca17: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED
10ca1a: 89 d9 mov %ebx,%ecx <== NOT EXECUTED
10ca1c: 29 c1 sub %eax,%ecx <== NOT EXECUTED
10ca1e: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED
10ca21: 01 c1 add %eax,%ecx <== NOT EXECUTED
if (*(uint32_t *)(&buf[ofs-buf_ofs]) == 0xffffffff) {
10ca23: 83 39 ff cmpl $0xffffffff,(%ecx) <== NOT EXECUTED
10ca26: 0f 84 fb 02 00 00 je 10cd27 <jffs2_scan_medium+0x477> <== NOT EXECUTED
if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) {
10ca2c: 8b 55 cc mov -0x34(%ebp),%edx <== NOT EXECUTED
10ca2f: 0f b7 01 movzwl (%ecx),%eax <== NOT EXECUTED
10ca32: 39 5a 0c cmp %ebx,0xc(%edx) <== NOT EXECUTED
10ca35: 0f 84 45 02 00 00 je 10cc80 <jffs2_scan_medium+0x3d0> <== NOT EXECUTED
if (je16_to_cpu(node->magic) == JFFS2_DIRTY_BITMASK) {
10ca3b: 85 c0 test %eax,%eax <== NOT EXECUTED
10ca3d: 0f 84 5d 02 00 00 je 10cca0 <jffs2_scan_medium+0x3f0> <== NOT EXECUTED
if (je16_to_cpu(node->magic) == JFFS2_OLD_MAGIC_BITMASK) {
10ca43: 3d 84 19 00 00 cmp $0x1984,%eax <== NOT EXECUTED
10ca48: 0f 84 0c 05 00 00 je 10cf5a <jffs2_scan_medium+0x6aa> <== NOT EXECUTED
if (je16_to_cpu(node->magic) != JFFS2_MAGIC_BITMASK) {
10ca4e: 3d 85 19 00 00 cmp $0x1985,%eax <== NOT EXECUTED
10ca53: 0f 84 22 05 00 00 je 10cf7b <jffs2_scan_medium+0x6cb> <== NOT EXECUTED
noisy_printk(&noise, "%s(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n",
10ca59: 8b 55 bc mov -0x44(%ebp),%edx <== NOT EXECUTED
10ca5c: 85 d2 test %edx,%edx <== NOT EXECUTED
10ca5e: 0f 85 b6 04 00 00 jne 10cf1a <jffs2_scan_medium+0x66a> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
10ca64: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10ca67: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED
10ca6a: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
10ca6f: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED
10ca73: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
10ca77: e8 d4 95 ff ff call 106050 <jffs2_scan_dirty_space> <== NOT EXECUTED
10ca7c: 85 c0 test %eax,%eax <== NOT EXECUTED
10ca7e: 0f 85 ec 01 00 00 jne 10cc70 <jffs2_scan_medium+0x3c0> <== NOT EXECUTED
continue;
10ca84: 89 5d c0 mov %ebx,-0x40(%ebp) <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10ca87: 8b 46 34 mov 0x34(%esi),%eax <== NOT EXECUTED
ofs += 4;
10ca8a: 83 c3 04 add $0x4,%ebx <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10ca8d: 8b 57 0c mov 0xc(%edi),%edx <== NOT EXECUTED
10ca90: 01 d0 add %edx,%eax <== NOT EXECUTED
10ca92: 39 c3 cmp %eax,%ebx <== NOT EXECUTED
10ca94: 0f 82 25 ff ff ff jb 10c9bf <jffs2_scan_medium+0x10f> <== NOT EXECUTED
10ca9a: 8b 7d c4 mov -0x3c(%ebp),%edi <== NOT EXECUTED
10ca9d: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED
if (jeb->wasted_size) {
10caa0: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED
10caa3: 85 c0 test %eax,%eax <== NOT EXECUTED
10caa5: 74 10 je 10cab7 <jffs2_scan_medium+0x207> <== NOT EXECUTED
jeb->dirty_size += jeb->wasted_size;
10caa7: 01 41 18 add %eax,0x18(%ecx) <== NOT EXECUTED
c->dirty_size += jeb->wasted_size;
10caaa: 01 46 20 add %eax,0x20(%esi) <== NOT EXECUTED
c->wasted_size -= jeb->wasted_size;
10caad: 29 46 24 sub %eax,0x24(%esi) <== NOT EXECUTED
jeb->wasted_size = 0;
10cab0: c7 41 1c 00 00 00 00 movl $0x0,0x1c(%ecx) <== NOT EXECUTED
return jffs2_scan_classify_jeb(c, jeb);
10cab7: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
10cabb: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10cabe: 89 4d d0 mov %ecx,-0x30(%ebp) <== NOT EXECUTED
10cac1: e8 ea fb ff ff call 10c6b0 <jffs2_scan_classify_jeb> <== NOT EXECUTED
10cac6: 8b 4d d0 mov -0x30(%ebp),%ecx <== NOT EXECUTED
10cac9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (ret < 0)
10cad0: 85 c0 test %eax,%eax <== NOT EXECUTED
10cad2: 0f 88 b6 00 00 00 js 10cb8e <jffs2_scan_medium+0x2de> <== NOT EXECUTED
switch(ret) {
10cad8: 83 f8 05 cmp $0x5,%eax <== NOT EXECUTED
10cadb: 0f 87 19 0a 00 00 ja 10d4fa <jffs2_scan_medium+0xc4a> <== NOT EXECUTED
10cae1: ff 24 85 38 10 13 00 jmp *0x131038(,%eax,4) <== NOT EXECUTED
10cae8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10caef: 90 nop <== NOT EXECUTED
if (ofs == max_ofs) {
10caf0: 0f 85 0a 03 00 00 jne 10ce00 <jffs2_scan_medium+0x550> <== NEVER TAKEN
if (c->cleanmarker_size == 0)
10caf6: 8b 46 14 mov 0x14(%esi),%eax
10caf9: 85 c0 test %eax,%eax
10cafb: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10caff: 90 nop
10cb00: 0f 84 aa 00 00 00 je 10cbb0 <jffs2_scan_medium+0x300> <== NEVER TAKEN
empty_blocks++;
10cb06: ff 45 b4 incl -0x4c(%ebp)
struct list_head *next = afterthisent->next;
10cb09: 8b 86 98 00 00 00 mov 0x98(%esi),%eax
list_add(&jeb->list, &c->erase_pending_list);
10cb0f: 8d 96 98 00 00 00 lea 0x98(%esi),%edx
10cb15: 89 51 04 mov %edx,0x4(%ecx)
newent->next = next;
10cb18: 89 01 mov %eax,(%ecx)
afterthisent->next = newent;
10cb1a: 89 8e 98 00 00 00 mov %ecx,0x98(%esi)
next->prev = newent;
10cb20: 89 48 04 mov %ecx,0x4(%eax)
c->nr_erasing_blocks++;
10cb23: ff 46 40 incl 0x40(%esi)
for (i=0; i<c->nr_blocks; i++) {
10cb26: ff 45 d4 incl -0x2c(%ebp)
10cb29: 8b 56 50 mov 0x50(%esi),%edx
10cb2c: 8b 45 d4 mov -0x2c(%ebp),%eax
10cb2f: 39 c2 cmp %eax,%edx
10cb31: 0f 87 c9 fd ff ff ja 10c900 <jffs2_scan_medium+0x50>
if (c->nextblock && (c->nextblock->dirty_size)) {
10cb37: 8b 46 58 mov 0x58(%esi),%eax
10cb3a: 85 c0 test %eax,%eax
10cb3c: 74 0b je 10cb49 <jffs2_scan_medium+0x299> <== ALWAYS TAKEN
10cb3e: 8b 48 18 mov 0x18(%eax),%ecx <== NOT EXECUTED
10cb41: 85 c9 test %ecx,%ecx <== NOT EXECUTED
10cb43: 0f 85 08 06 00 00 jne 10d151 <jffs2_scan_medium+0x8a1> <== NOT EXECUTED
if (c->nr_erasing_blocks) {
10cb49: 8b 4e 40 mov 0x40(%esi),%ecx
ret = 0;
10cb4c: 31 c0 xor %eax,%eax
if (c->nr_erasing_blocks) {
10cb4e: 85 c9 test %ecx,%ecx
10cb50: 74 3c je 10cb8e <jffs2_scan_medium+0x2de> <== NEVER TAKEN
if ( !c->used_size && ((c->nr_free_blocks+empty_blocks+bad_blocks)!= c->nr_blocks || bad_blocks == c->nr_blocks) ) {
10cb52: 8b 46 1c mov 0x1c(%esi),%eax
10cb55: 85 c0 test %eax,%eax
10cb57: 75 1d jne 10cb76 <jffs2_scan_medium+0x2c6> <== NEVER TAKEN
10cb59: 8b 45 b4 mov -0x4c(%ebp),%eax
10cb5c: 8b 4d b8 mov -0x48(%ebp),%ecx
10cb5f: 8b 5e 3c mov 0x3c(%esi),%ebx
10cb62: 01 c8 add %ecx,%eax
10cb64: 01 d8 add %ebx,%eax
10cb66: 39 d0 cmp %edx,%eax
10cb68: 0f 85 f8 05 00 00 jne 10d166 <jffs2_scan_medium+0x8b6> <== NEVER TAKEN
10cb6e: 39 ca cmp %ecx,%edx
10cb70: 0f 84 f0 05 00 00 je 10d166 <jffs2_scan_medium+0x8b6> <== NEVER TAKEN
rtems_jffs2_flash_control *fc = sb->s_flash_control;
10cb76: 8b 96 e4 00 00 00 mov 0xe4(%esi),%edx
if (fc->trigger_garbage_collection != NULL) {
10cb7c: 8b 42 20 mov 0x20(%edx),%eax
10cb7f: 85 c0 test %eax,%eax
10cb81: 0f 84 35 07 00 00 je 10d2bc <jffs2_scan_medium+0xa0c> <== ALWAYS TAKEN
(*fc->trigger_garbage_collection)(fc);
10cb87: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED
10cb8a: ff d0 call *%eax <== NOT EXECUTED
ret = 0;
10cb8c: 31 c0 xor %eax,%eax <== NOT EXECUTED
kfree(flashbuf);
10cb8e: 89 3c 24 mov %edi,(%esp)
10cb91: 89 45 d4 mov %eax,-0x2c(%ebp)
10cb94: e8 97 15 00 00 call 10e130 <free>
return ret;
10cb99: 8b 45 d4 mov -0x2c(%ebp),%eax
}
10cb9c: 81 c4 8c 00 00 00 add $0x8c,%esp
10cba2: 5b pop %ebx
10cba3: 5e pop %esi
10cba4: 5f pop %edi
10cba5: 5d pop %ebp
10cba6: c3 ret
10cba7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10cbae: 66 90 xchg %ax,%ax
if (!jeb->dirty_size) {
10cbb0: 8b 41 18 mov 0x18(%ecx),%eax <== NOT EXECUTED
10cbb3: 85 c0 test %eax,%eax <== NOT EXECUTED
10cbb5: 0f 85 4e ff ff ff jne 10cb09 <jffs2_scan_medium+0x259> <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10cbbb: 8b 86 a8 00 00 00 mov 0xa8(%esi),%eax <== NOT EXECUTED
list_add(&jeb->list, &c->free_list);
10cbc1: 8d 96 a8 00 00 00 lea 0xa8(%esi),%edx <== NOT EXECUTED
10cbc7: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED
newent->next = next;
10cbca: 89 01 mov %eax,(%ecx) <== NOT EXECUTED
afterthisent->next = newent;
10cbcc: 89 8e a8 00 00 00 mov %ecx,0xa8(%esi) <== NOT EXECUTED
next->prev = newent;
10cbd2: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED
c->nr_free_blocks++;
10cbd5: ff 46 3c incl 0x3c(%esi) <== NOT EXECUTED
10cbd8: e9 49 ff ff ff jmp 10cb26 <jffs2_scan_medium+0x276> <== NOT EXECUTED
10cbdd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (jeb->free_size > min_free(c) &&
10cbe0: 8b 41 20 mov 0x20(%ecx),%eax <== NOT EXECUTED
10cbe3: 3d 88 00 00 00 cmp $0x88,%eax <== NOT EXECUTED
10cbe8: 0f 86 a2 02 00 00 jbe 10ce90 <jffs2_scan_medium+0x5e0> <== NOT EXECUTED
(!c->nextblock || c->nextblock->free_size < jeb->free_size)) {
10cbee: 8b 56 58 mov 0x58(%esi),%edx <== NOT EXECUTED
if (jeb->free_size > min_free(c) &&
10cbf1: 85 d2 test %edx,%edx <== NOT EXECUTED
10cbf3: 74 1e je 10cc13 <jffs2_scan_medium+0x363> <== NOT EXECUTED
(!c->nextblock || c->nextblock->free_size < jeb->free_size)) {
10cbf5: 3b 42 20 cmp 0x20(%edx),%eax <== NOT EXECUTED
10cbf8: 0f 86 92 02 00 00 jbe 10ce90 <jffs2_scan_medium+0x5e0> <== NOT EXECUTED
10cbfe: 89 4d d0 mov %ecx,-0x30(%ebp) <== NOT EXECUTED
ret = file_dirty(c, c->nextblock);
10cc01: 89 f0 mov %esi,%eax <== NOT EXECUTED
10cc03: e8 08 fa ff ff call 10c610 <file_dirty> <== NOT EXECUTED
if (ret)
10cc08: 8b 4d d0 mov -0x30(%ebp),%ecx <== NOT EXECUTED
10cc0b: 85 c0 test %eax,%eax <== NOT EXECUTED
10cc0d: 0f 85 7b ff ff ff jne 10cb8e <jffs2_scan_medium+0x2de> <== NOT EXECUTED
c->nextblock = jeb;
10cc13: 89 4e 58 mov %ecx,0x58(%esi) <== NOT EXECUTED
10cc16: e9 0b ff ff ff jmp 10cb26 <jffs2_scan_medium+0x276> <== NOT EXECUTED
10cc1b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10cc1f: 90 nop <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10cc20: 8b 46 60 mov 0x60(%esi),%eax <== NOT EXECUTED
list_add(&jeb->list, &c->clean_list);
10cc23: 8d 56 60 lea 0x60(%esi),%edx <== NOT EXECUTED
10cc26: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED
newent->next = next;
10cc29: 89 01 mov %eax,(%ecx) <== NOT EXECUTED
afterthisent->next = newent;
10cc2b: 89 4e 60 mov %ecx,0x60(%esi) <== NOT EXECUTED
next->prev = newent;
10cc2e: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED
} /* list_add() */
10cc31: e9 f0 fe ff ff jmp 10cb26 <jffs2_scan_medium+0x276> <== NOT EXECUTED
10cc36: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10cc3d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10cc40: 8b 86 b0 00 00 00 mov 0xb0(%esi),%eax <== NOT EXECUTED
list_add(&jeb->list, &c->bad_list);
10cc46: 8d 96 b0 00 00 00 lea 0xb0(%esi),%edx <== NOT EXECUTED
10cc4c: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED
bad_blocks++;
10cc4f: ff 45 b8 incl -0x48(%ebp) <== NOT EXECUTED
newent->next = next;
10cc52: 89 01 mov %eax,(%ecx) <== NOT EXECUTED
afterthisent->next = newent;
10cc54: 89 8e b0 00 00 00 mov %ecx,0xb0(%esi) <== NOT EXECUTED
next->prev = newent;
10cc5a: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED
c->bad_size += c->sector_size;
10cc5d: 8b 46 34 mov 0x34(%esi),%eax <== NOT EXECUTED
10cc60: 01 46 30 add %eax,0x30(%esi) <== NOT EXECUTED
c->free_size -= c->sector_size;
10cc63: 29 46 28 sub %eax,0x28(%esi) <== NOT EXECUTED
break;
10cc66: e9 bb fe ff ff jmp 10cb26 <jffs2_scan_medium+0x276> <== NOT EXECUTED
10cc6b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10cc6f: 90 nop <== NOT EXECUTED
10cc70: 8b 7d c4 mov -0x3c(%ebp),%edi <== NOT EXECUTED
10cc73: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED
10cc76: e9 55 fe ff ff jmp 10cad0 <jffs2_scan_medium+0x220> <== NOT EXECUTED
10cc7b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10cc7f: 90 nop <== NOT EXECUTED
if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) {
10cc80: 3d 19 85 00 00 cmp $0x8519,%eax <== NOT EXECUTED
10cc85: 0f 85 b0 fd ff ff jne 10ca3b <jffs2_scan_medium+0x18b> <== NOT EXECUTED
pr_warn("Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n",
10cc8b: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10cc8f: c7 04 24 74 0a 13 00 movl $0x130a74,(%esp) <== NOT EXECUTED
10cc96: e8 55 f9 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
10cc9b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10cc9f: 90 nop <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
10cca0: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10cca3: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED
10cca6: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED
10ccab: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED
10ccaf: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
10ccb3: e8 98 93 ff ff call 106050 <jffs2_scan_dirty_space> <== NOT EXECUTED
10ccb8: 85 c0 test %eax,%eax <== NOT EXECUTED
10ccba: 75 b4 jne 10cc70 <jffs2_scan_medium+0x3c0> <== NOT EXECUTED
continue;
10ccbc: 89 5d c0 mov %ebx,-0x40(%ebp) <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10ccbf: 8b 47 0c mov 0xc(%edi),%eax <== NOT EXECUTED
ofs += 4;
10ccc2: 83 c3 04 add $0x4,%ebx <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10ccc5: 8b 56 34 mov 0x34(%esi),%edx <== NOT EXECUTED
10ccc8: 01 d0 add %edx,%eax <== NOT EXECUTED
continue;
10ccca: e9 c3 fd ff ff jmp 10ca92 <jffs2_scan_medium+0x1e2> <== NOT EXECUTED
10cccf: 90 nop <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10ccd0: 29 d8 sub %ebx,%eax <== NOT EXECUTED
10ccd2: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED
10ccd5: 3d 00 10 00 00 cmp $0x1000,%eax <== NOT EXECUTED
10ccda: 76 07 jbe 10cce3 <jffs2_scan_medium+0x433> <== NOT EXECUTED
10ccdc: c7 45 d0 00 10 00 00 movl $0x1000,-0x30(%ebp) <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10cce3: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10cce7: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED
10ccea: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10cced: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
10ccf1: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED
10ccf4: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
10ccf8: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED
10ccfb: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10ccff: e8 5c f5 ff ff call 10c260 <jffs2_flash_read> <== NOT EXECUTED
if (ret) {
10cd04: 85 c0 test %eax,%eax <== NOT EXECUTED
10cd06: 0f 85 64 ff ff ff jne 10cc70 <jffs2_scan_medium+0x3c0> <== NOT EXECUTED
if (retlen < len) {
10cd0c: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED
10cd0f: 3b 45 d8 cmp -0x28(%ebp),%eax <== NOT EXECUTED
10cd12: 0f 87 be 05 00 00 ja 10d2d6 <jffs2_scan_medium+0xa26> <== NOT EXECUTED
if (err)
10cd18: 89 5d c8 mov %ebx,-0x38(%ebp) <== NOT EXECUTED
if (*(uint32_t *)(&buf[ofs-buf_ofs]) == 0xffffffff) {
10cd1b: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED
10cd1e: 83 39 ff cmpl $0xffffffff,(%ecx) <== NOT EXECUTED
10cd21: 0f 85 05 fd ff ff jne 10ca2c <jffs2_scan_medium+0x17c> <== NOT EXECUTED
scan_end = min_t(uint32_t, EMPTY_SCAN_SIZE(c->sector_size)/8, buf_len);
10cd27: 8b 46 34 mov 0x34(%esi),%eax <== NOT EXECUTED
ofs += 4;
10cd2a: 8d 7b 04 lea 0x4(%ebx),%edi <== NOT EXECUTED
if (sector_size < DEFAULT_EMPTY_SCAN_SIZE)
10cd2d: 3d ff 00 00 00 cmp $0xff,%eax <== NOT EXECUTED
10cd32: 0f 87 e6 02 00 00 ja 10d01e <jffs2_scan_medium+0x76e> <== NOT EXECUTED
scan_end = min_t(uint32_t, EMPTY_SCAN_SIZE(c->sector_size)/8, buf_len);
10cd38: c1 e8 03 shr $0x3,%eax <== NOT EXECUTED
10cd3b: 8b 4d d0 mov -0x30(%ebp),%ecx <== NOT EXECUTED
10cd3e: 39 c1 cmp %eax,%ecx <== NOT EXECUTED
10cd40: 89 ca mov %ecx,%edx <== NOT EXECUTED
10cd42: 76 02 jbe 10cd46 <jffs2_scan_medium+0x496> <== NOT EXECUTED
10cd44: 89 c2 mov %eax,%edx <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10cd46: 89 5d c0 mov %ebx,-0x40(%ebp) <== NOT EXECUTED
10cd49: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED
inbuf_ofs = ofs - buf_ofs;
10cd4c: 89 f8 mov %edi,%eax <== NOT EXECUTED
10cd4e: 29 c8 sub %ecx,%eax <== NOT EXECUTED
while (inbuf_ofs < scan_end) {
10cd50: 39 d0 cmp %edx,%eax <== NOT EXECUTED
10cd52: 0f 83 58 01 00 00 jae 10ceb0 <jffs2_scan_medium+0x600> <== NOT EXECUTED
if (unlikely(*(uint32_t *)(&buf[inbuf_ofs]) != 0xffffffff)) {
10cd58: 8b 5d c4 mov -0x3c(%ebp),%ebx <== NOT EXECUTED
10cd5b: 29 cb sub %ecx,%ebx <== NOT EXECUTED
10cd5d: eb 10 jmp 10cd6f <jffs2_scan_medium+0x4bf> <== NOT EXECUTED
10cd5f: 90 nop <== NOT EXECUTED
ofs += 4;
10cd60: 83 c7 04 add $0x4,%edi <== NOT EXECUTED
while (inbuf_ofs < scan_end) {
10cd63: 89 f8 mov %edi,%eax <== NOT EXECUTED
10cd65: 29 c8 sub %ecx,%eax <== NOT EXECUTED
10cd67: 39 c2 cmp %eax,%edx <== NOT EXECUTED
10cd69: 0f 86 41 01 00 00 jbe 10ceb0 <jffs2_scan_medium+0x600> <== NOT EXECUTED
if (unlikely(*(uint32_t *)(&buf[inbuf_ofs]) != 0xffffffff)) {
10cd6f: 83 3c 3b ff cmpl $0xffffffff,(%ebx,%edi,1) <== NOT EXECUTED
10cd73: 74 eb je 10cd60 <jffs2_scan_medium+0x4b0> <== NOT EXECUTED
pr_warn("Empty flash at 0x%08x ends at 0x%08x\n",
10cd75: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
10cd79: 8b 5d c0 mov -0x40(%ebp),%ebx <== NOT EXECUTED
10cd7c: c7 04 24 44 0a 13 00 movl $0x130a44,(%esp) <== NOT EXECUTED
10cd83: 89 4d c8 mov %ecx,-0x38(%ebp) <== NOT EXECUTED
10cd86: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10cd8a: e8 61 f8 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, ofs-empty_start)))
10cd8f: 89 f8 mov %edi,%eax <== NOT EXECUTED
10cd91: 29 d8 sub %ebx,%eax <== NOT EXECUTED
10cd93: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node)))))
10cd97: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10cd9a: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED
10cd9d: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10cda1: e8 aa 92 ff ff call 106050 <jffs2_scan_dirty_space> <== NOT EXECUTED
10cda6: 85 c0 test %eax,%eax <== NOT EXECUTED
10cda8: 0f 85 c2 fe ff ff jne 10cc70 <jffs2_scan_medium+0x3c0> <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10cdae: 89 5d c0 mov %ebx,-0x40(%ebp) <== NOT EXECUTED
10cdb1: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED
10cdb4: 89 fb mov %edi,%ebx <== NOT EXECUTED
10cdb6: 8b 4e 34 mov 0x34(%esi),%ecx <== NOT EXECUTED
10cdb9: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED
10cdbc: 01 c8 add %ecx,%eax <== NOT EXECUTED
10cdbe: e9 cf fc ff ff jmp 10ca92 <jffs2_scan_medium+0x1e2> <== NOT EXECUTED
10cdc3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10cdca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
pr_warn("Eep. ofs 0x%08x not word-aligned!\n", ofs);
10cdd0: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
ofs = PAD(ofs);
10cdd4: 83 c3 03 add $0x3,%ebx <== NOT EXECUTED
pr_warn("Eep. ofs 0x%08x not word-aligned!\n", ofs);
10cdd7: c7 04 24 dc 09 13 00 movl $0x1309dc,(%esp) <== NOT EXECUTED
ofs = PAD(ofs);
10cdde: 83 e3 fc and $0xfffffffc,%ebx <== NOT EXECUTED
pr_warn("Eep. ofs 0x%08x not word-aligned!\n", ofs);
10cde1: e8 0a f8 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10cde6: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED
10cde9: 8b 56 34 mov 0x34(%esi),%edx <== NOT EXECUTED
10cdec: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED
10cdef: 01 d0 add %edx,%eax <== NOT EXECUTED
continue;
10cdf1: e9 9c fc ff ff jmp 10ca92 <jffs2_scan_medium+0x1e2> <== NOT EXECUTED
10cdf6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10cdfd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if ((err = jffs2_prealloc_raw_node_refs(c, jeb, 1)))
10ce00: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
10ce04: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED
10ce09: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10ce0d: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10ce10: 89 4d cc mov %ecx,-0x34(%ebp) <== NOT EXECUTED
10ce13: e8 e8 83 ff ff call 105200 <jffs2_prealloc_raw_node_refs> <== NOT EXECUTED
10ce18: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED
10ce1b: 85 c0 test %eax,%eax <== NOT EXECUTED
10ce1d: 0f 85 ad fc ff ff jne 10cad0 <jffs2_scan_medium+0x220> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, ofs)))
10ce23: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
10ce27: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
10ce2b: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10ce2e: e8 1d 92 ff ff call 106050 <jffs2_scan_dirty_space> <== NOT EXECUTED
10ce33: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED
10ce36: 85 c0 test %eax,%eax <== NOT EXECUTED
10ce38: 0f 85 92 fc ff ff jne 10cad0 <jffs2_scan_medium+0x220> <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10ce3e: 8b 46 34 mov 0x34(%esi),%eax <== NOT EXECUTED
10ce41: e9 53 fb ff ff jmp 10c999 <jffs2_scan_medium+0xe9> <== NOT EXECUTED
10ce46: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10ce4d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
pr_warn("ofs 0x%08x has already been seen. Skipping\n",
10ce50: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
10ce54: bf 04 00 00 00 mov $0x4,%edi <== NOT EXECUTED
pr_warn("ofs 0x%08x has already been seen. Skipping\n",
10ce59: c7 04 24 0c 0a 13 00 movl $0x130a0c,(%esp) <== NOT EXECUTED
10ce60: e8 8b f7 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
10ce65: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
10ce69: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED
10ce6c: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10ce6f: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
10ce73: e8 d8 91 ff ff call 106050 <jffs2_scan_dirty_space> <== NOT EXECUTED
10ce78: 85 c0 test %eax,%eax <== NOT EXECUTED
10ce7a: 0f 85 f0 fd ff ff jne 10cc70 <jffs2_scan_medium+0x3c0> <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10ce80: 8b 47 0c mov 0xc(%edi),%eax <== NOT EXECUTED
ofs += 4;
10ce83: 83 c3 04 add $0x4,%ebx <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10ce86: 8b 4e 34 mov 0x34(%esi),%ecx <== NOT EXECUTED
10ce89: 01 c8 add %ecx,%eax <== NOT EXECUTED
continue;
10ce8b: e9 02 fc ff ff jmp 10ca92 <jffs2_scan_medium+0x1e2> <== NOT EXECUTED
ret = file_dirty(c, jeb);
10ce90: 89 ca mov %ecx,%edx <== NOT EXECUTED
10ce92: 89 f0 mov %esi,%eax <== NOT EXECUTED
10ce94: e8 77 f7 ff ff call 10c610 <file_dirty> <== NOT EXECUTED
if (ret)
10ce99: 85 c0 test %eax,%eax <== NOT EXECUTED
10ce9b: 0f 84 85 fc ff ff je 10cb26 <jffs2_scan_medium+0x276> <== NOT EXECUTED
10cea1: e9 e8 fc ff ff jmp 10cb8e <jffs2_scan_medium+0x2de> <== NOT EXECUTED
10cea6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10cead: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) &&
10ceb0: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED
10ceb3: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED
10ceb6: 39 c1 cmp %eax,%ecx <== NOT EXECUTED
10ceb8: 0f 84 6a 01 00 00 je 10d028 <jffs2_scan_medium+0x778> <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10cebe: 8b 4e 34 mov 0x34(%esi),%ecx <== NOT EXECUTED
10cec1: 01 c8 add %ecx,%eax <== NOT EXECUTED
if (!buf_len) {
10cec3: 39 f8 cmp %edi,%eax <== NOT EXECUTED
10cec5: 0f 84 cf fb ff ff je 10ca9a <jffs2_scan_medium+0x1ea> <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10cecb: 29 f8 sub %edi,%eax <== NOT EXECUTED
10cecd: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED
10ced0: 3d 00 10 00 00 cmp $0x1000,%eax <== NOT EXECUTED
10ced5: 76 07 jbe 10cede <jffs2_scan_medium+0x62e> <== NOT EXECUTED
10ced7: c7 45 d0 00 10 00 00 movl $0x1000,-0x30(%ebp) <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10cede: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
10cee2: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED
10cee5: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10cee8: 8b 5d d0 mov -0x30(%ebp),%ebx <== NOT EXECUTED
10ceeb: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
10ceef: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED
10cef2: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
10cef6: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
10cefa: e8 61 f3 ff ff call 10c260 <jffs2_flash_read> <== NOT EXECUTED
if (ret) {
10ceff: 85 c0 test %eax,%eax <== NOT EXECUTED
10cf01: 0f 85 69 fd ff ff jne 10cc70 <jffs2_scan_medium+0x3c0> <== NOT EXECUTED
if (retlen < len) {
10cf07: 3b 5d d8 cmp -0x28(%ebp),%ebx <== NOT EXECUTED
10cf0a: 0f 87 c6 03 00 00 ja 10d2d6 <jffs2_scan_medium+0xa26> <== NOT EXECUTED
if (err)
10cf10: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED
10cf13: 89 f9 mov %edi,%ecx <== NOT EXECUTED
10cf15: e9 32 fe ff ff jmp 10cd4c <jffs2_scan_medium+0x49c> <== NOT EXECUTED
noisy_printk(&noise, "%s(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n",
10cf1a: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
10cf1e: b8 85 19 00 00 mov $0x1985,%eax <== NOT EXECUTED
10cf23: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10cf27: b8 9c 10 13 00 mov $0x13109c,%eax <== NOT EXECUTED
10cf2c: 89 5c 24 0c mov %ebx,0xc(%esp) <== NOT EXECUTED
10cf30: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10cf34: c7 04 24 40 0b 13 00 movl $0x130b40,(%esp) <== NOT EXECUTED
10cf3b: e8 b0 f6 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
10cf40: ff 4d bc decl -0x44(%ebp) <== NOT EXECUTED
10cf43: 0f 85 1b fb ff ff jne 10ca64 <jffs2_scan_medium+0x1b4> <== NOT EXECUTED
10cf49: c7 04 24 8c 0b 13 00 movl $0x130b8c,(%esp) <== NOT EXECUTED
10cf50: e8 9b f6 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
10cf55: e9 0a fb ff ff jmp 10ca64 <jffs2_scan_medium+0x1b4> <== NOT EXECUTED
pr_warn("Old JFFS2 bitmask found at 0x%08x\n", ofs);
10cf5a: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10cf5e: c7 04 24 c8 0a 13 00 movl $0x130ac8,(%esp) <== NOT EXECUTED
10cf65: e8 86 f6 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
pr_warn("You cannot use older JFFS2 filesystems with newer kernels\n");
10cf6a: c7 04 24 f8 0a 13 00 movl $0x130af8,(%esp) <== NOT EXECUTED
pr_warn("Perhaps the file system was created with the wrong erase size?\n");
10cf71: e8 7a f6 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
10cf76: e9 e9 fa ff ff jmp 10ca64 <jffs2_scan_medium+0x1b4> <== NOT EXECUTED
crcnode.totlen = node->totlen;
10cf7b: 89 4d c0 mov %ecx,-0x40(%ebp) <== NOT EXECUTED
crcnode.magic = node->magic;
10cf7e: 0f b7 01 movzwl (%ecx),%eax <== NOT EXECUTED
10cf81: 66 89 45 dc mov %ax,-0x24(%ebp) <== NOT EXECUTED
crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE);
10cf85: 0f b7 41 02 movzwl 0x2(%ecx),%eax <== NOT EXECUTED
10cf89: 0d 00 20 00 00 or $0x2000,%eax <== NOT EXECUTED
10cf8e: 66 89 45 de mov %ax,-0x22(%ebp) <== NOT EXECUTED
crcnode.totlen = node->totlen;
10cf92: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED
hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4);
10cf95: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
crcnode.totlen = node->totlen;
10cf9c: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED
hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4);
10cf9f: b8 08 00 00 00 mov $0x8,%eax <== NOT EXECUTED
10cfa4: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10cfa8: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED
10cfab: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10cfaf: e8 dc de ff ff call 10ae90 <cyg_crc32_accumulate> <== NOT EXECUTED
if (hdr_crc != je32_to_cpu(node->hdr_crc)) {
10cfb4: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10cfb7: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED
10cfba: 39 d0 cmp %edx,%eax <== NOT EXECUTED
10cfbc: 0f 84 be 00 00 00 je 10d080 <jffs2_scan_medium+0x7d0> <== NOT EXECUTED
noisy_printk(&noise, "%s(): Node at 0x%08x {0x%04x, 0x%04x, 0x%08x) has invalid CRC 0x%08x (calculated 0x%08x)\n",
10cfc2: 8b 7d bc mov -0x44(%ebp),%edi <== NOT EXECUTED
10cfc5: 85 ff test %edi,%edi <== NOT EXECUTED
10cfc7: 0f 84 d3 fc ff ff je 10cca0 <jffs2_scan_medium+0x3f0> <== NOT EXECUTED
10cfcd: 89 44 24 1c mov %eax,0x1c(%esp) <== NOT EXECUTED
10cfd1: bf 9c 10 13 00 mov $0x13109c,%edi <== NOT EXECUTED
10cfd6: 89 54 24 18 mov %edx,0x18(%esp) <== NOT EXECUTED
10cfda: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED
10cfdd: 89 44 24 14 mov %eax,0x14(%esp) <== NOT EXECUTED
10cfe1: 0f b7 41 02 movzwl 0x2(%ecx),%eax <== NOT EXECUTED
10cfe5: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
10cfe9: 0f b7 01 movzwl (%ecx),%eax <== NOT EXECUTED
10cfec: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
10cff0: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
10cff4: c7 04 24 d4 0b 13 00 movl $0x130bd4,(%esp) <== NOT EXECUTED
10cffb: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
10cfff: e8 ec f5 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
10d004: ff 4d bc decl -0x44(%ebp) <== NOT EXECUTED
10d007: 0f 85 93 fc ff ff jne 10cca0 <jffs2_scan_medium+0x3f0> <== NOT EXECUTED
10d00d: c7 04 24 8c 0b 13 00 movl $0x130b8c,(%esp) <== NOT EXECUTED
10d014: e8 d7 f5 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
10d019: e9 82 fc ff ff jmp 10cca0 <jffs2_scan_medium+0x3f0> <== NOT EXECUTED
10d01e: b8 20 00 00 00 mov $0x20,%eax <== NOT EXECUTED
10d023: e9 13 fd ff ff jmp 10cd3b <jffs2_scan_medium+0x48b> <== NOT EXECUTED
if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) &&
10d028: 8b 4e 14 mov 0x14(%esi),%ecx <== NOT EXECUTED
10d02b: 8b 5d cc mov -0x34(%ebp),%ebx <== NOT EXECUTED
10d02e: 8d 51 03 lea 0x3(%ecx),%edx <== NOT EXECUTED
10d031: 83 e2 fc and $0xfffffffc,%edx <== NOT EXECUTED
10d034: 3b 53 14 cmp 0x14(%ebx),%edx <== NOT EXECUTED
10d037: 0f 85 81 fe ff ff jne 10cebe <jffs2_scan_medium+0x60e> <== NOT EXECUTED
10d03d: 85 c9 test %ecx,%ecx <== NOT EXECUTED
10d03f: 0f 84 79 fe ff ff je 10cebe <jffs2_scan_medium+0x60e> <== NOT EXECUTED
c->cleanmarker_size && !jeb->dirty_size && !ref_next(jeb->first_node)) {
10d045: 89 d9 mov %ebx,%ecx <== NOT EXECUTED
10d047: 8b 5b 18 mov 0x18(%ebx),%ebx <== NOT EXECUTED
10d04a: 85 db test %ebx,%ebx <== NOT EXECUTED
10d04c: 0f 85 6c fe ff ff jne 10cebe <jffs2_scan_medium+0x60e> <== NOT EXECUTED
10d052: 8b 49 28 mov 0x28(%ecx),%ecx <== NOT EXECUTED
if (ref->flash_offset == REF_LINK_NODE) {
10d055: 8b 51 0c mov 0xc(%ecx),%edx <== NOT EXECUTED
10d058: 83 fa ff cmp $0xffffffff,%edx <== NOT EXECUTED
10d05b: 0f 84 62 02 00 00 je 10d2c3 <jffs2_scan_medium+0xa13> <== NOT EXECUTED
if (ref->flash_offset == REF_EMPTY_NODE)
10d061: 83 fa fe cmp $0xfffffffe,%edx <== NOT EXECUTED
10d064: 0f 85 54 fe ff ff jne 10cebe <jffs2_scan_medium+0x60e> <== NOT EXECUTED
10d06a: 8b 7d c4 mov -0x3c(%ebp),%edi <== NOT EXECUTED
10d06d: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED
10d070: e9 46 fb ff ff jmp 10cbbb <jffs2_scan_medium+0x30b> <== NOT EXECUTED
10d075: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10d07c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
if (ofs + je32_to_cpu(node->totlen) > jeb->offset + c->sector_size) {
10d080: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED
10d083: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED
10d086: 01 d8 add %ebx,%eax <== NOT EXECUTED
10d088: 89 45 b0 mov %eax,-0x50(%ebp) <== NOT EXECUTED
10d08b: 89 c2 mov %eax,%edx <== NOT EXECUTED
10d08d: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED
10d090: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED
10d093: 89 45 ac mov %eax,-0x54(%ebp) <== NOT EXECUTED
10d096: 03 46 34 add 0x34(%esi),%eax <== NOT EXECUTED
10d099: 39 c2 cmp %eax,%edx <== NOT EXECUTED
10d09b: 0f 87 f8 01 00 00 ja 10d299 <jffs2_scan_medium+0x9e9> <== NOT EXECUTED
if (!(je16_to_cpu(node->nodetype) & JFFS2_NODE_ACCURATE)) {
10d0a1: 0f b7 51 02 movzwl 0x2(%ecx),%edx <== NOT EXECUTED
10d0a5: f6 c6 20 test $0x20,%dh <== NOT EXECUTED
10d0a8: 74 2c je 10d0d6 <jffs2_scan_medium+0x826> <== NOT EXECUTED
switch(je16_to_cpu(node->nodetype)) {
10d0aa: 81 fa 01 e0 00 00 cmp $0xe001,%edx <== NOT EXECUTED
10d0b0: 0f 84 2d 02 00 00 je 10d2e3 <jffs2_scan_medium+0xa33> <== NOT EXECUTED
10d0b6: 0f 87 e1 00 00 00 ja 10d19d <jffs2_scan_medium+0x8ed> <== NOT EXECUTED
10d0bc: 81 fa 03 20 00 00 cmp $0x2003,%edx <== NOT EXECUTED
10d0c2: 0f 84 f7 02 00 00 je 10d3bf <jffs2_scan_medium+0xb0f> <== NOT EXECUTED
10d0c8: 81 fa 04 20 00 00 cmp $0x2004,%edx <== NOT EXECUTED
10d0ce: 89 d7 mov %edx,%edi <== NOT EXECUTED
10d0d0: 0f 85 c5 03 00 00 jne 10d49b <jffs2_scan_medium+0xbeb> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
10d0d6: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10d0d9: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED
10d0dc: 89 4d b0 mov %ecx,-0x50(%ebp) <== NOT EXECUTED
10d0df: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED
10d0e2: 83 c0 03 add $0x3,%eax <== NOT EXECUTED
10d0e5: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
10d0e9: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
10d0ec: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10d0f0: e8 5b 8f ff ff call 106050 <jffs2_scan_dirty_space> <== NOT EXECUTED
10d0f5: 85 c0 test %eax,%eax <== NOT EXECUTED
10d0f7: 0f 85 73 fb ff ff jne 10cc70 <jffs2_scan_medium+0x3c0> <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
10d0fd: 8b 4d b0 mov -0x50(%ebp),%ecx <== NOT EXECUTED
10d100: 8b 51 04 mov 0x4(%ecx),%edx <== NOT EXECUTED
10d103: 83 c2 03 add $0x3,%edx <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10d106: 8b 47 0c mov 0xc(%edi),%eax <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
10d109: 83 e2 fc and $0xfffffffc,%edx <== NOT EXECUTED
break;
10d10c: 89 5d c0 mov %ebx,-0x40(%ebp) <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10d10f: 8b 4e 34 mov 0x34(%esi),%ecx <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
10d112: 01 d3 add %edx,%ebx <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10d114: 01 c8 add %ecx,%eax <== NOT EXECUTED
break;
10d116: e9 77 f9 ff ff jmp 10ca92 <jffs2_scan_medium+0x1e2> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, (jeb->offset + c->sector_size)-ofs)))
10d11b: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10d11e: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED
10d121: 29 d8 sub %ebx,%eax <== NOT EXECUTED
10d123: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10d127: 8b 7d c4 mov -0x3c(%ebp),%edi <== NOT EXECUTED
10d12a: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
10d12e: 89 4d d0 mov %ecx,-0x30(%ebp) <== NOT EXECUTED
10d131: e8 1a 8f ff ff call 106050 <jffs2_scan_dirty_space> <== NOT EXECUTED
10d136: 8b 4d d0 mov -0x30(%ebp),%ecx <== NOT EXECUTED
10d139: 85 c0 test %eax,%eax <== NOT EXECUTED
10d13b: 0f 85 8f f9 ff ff jne 10cad0 <jffs2_scan_medium+0x220> <== NOT EXECUTED
if (jeb->wasted_size) {
10d141: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED
10d144: 85 c0 test %eax,%eax <== NOT EXECUTED
10d146: 0f 85 5b f9 ff ff jne 10caa7 <jffs2_scan_medium+0x1f7> <== NOT EXECUTED
10d14c: e9 66 f9 ff ff jmp 10cab7 <jffs2_scan_medium+0x207> <== NOT EXECUTED
c->nextblock->wasted_size += c->nextblock->dirty_size;
10d151: 01 48 1c add %ecx,0x1c(%eax) <== NOT EXECUTED
c->wasted_size += c->nextblock->dirty_size;
10d154: 01 4e 24 add %ecx,0x24(%esi) <== NOT EXECUTED
c->dirty_size -= c->nextblock->dirty_size;
10d157: 29 4e 20 sub %ecx,0x20(%esi) <== NOT EXECUTED
c->nextblock->dirty_size = 0;
10d15a: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED
10d161: e9 e3 f9 ff ff jmp 10cb49 <jffs2_scan_medium+0x299> <== NOT EXECUTED
pr_notice("Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n");
10d166: c7 04 24 a4 0f 13 00 movl $0x130fa4,(%esp) <== NOT EXECUTED
10d16d: e8 7e f4 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
pr_notice("empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n",
10d172: 8b 46 50 mov 0x50(%esi),%eax <== NOT EXECUTED
10d175: c7 04 24 fc 0f 13 00 movl $0x130ffc,(%esp) <== NOT EXECUTED
10d17c: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
10d180: 8b 45 b8 mov -0x48(%ebp),%eax <== NOT EXECUTED
10d183: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10d187: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED
10d18a: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10d18e: e8 5d f4 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
ret = -EIO;
10d193: b8 fb ff ff ff mov $0xfffffffb,%eax <== NOT EXECUTED
goto out;
10d198: e9 f1 f9 ff ff jmp 10cb8e <jffs2_scan_medium+0x2de> <== NOT EXECUTED
switch(je16_to_cpu(node->nodetype)) {
10d19d: 81 fa 02 e0 00 00 cmp $0xe002,%edx <== NOT EXECUTED
10d1a3: 0f 85 a4 04 00 00 jne 10d64d <jffs2_scan_medium+0xd9d> <== NOT EXECUTED
if (buf_ofs + buf_len < ofs + sizeof(struct jffs2_raw_inode)) {
10d1a9: 8b 7d d0 mov -0x30(%ebp),%edi <== NOT EXECUTED
10d1ac: 8b 55 c8 mov -0x38(%ebp),%edx <== NOT EXECUTED
10d1af: 01 fa add %edi,%edx <== NOT EXECUTED
10d1b1: 8d 7b 44 lea 0x44(%ebx),%edi <== NOT EXECUTED
10d1b4: 39 fa cmp %edi,%edx <== NOT EXECUTED
10d1b6: 73 4b jae 10d203 <jffs2_scan_medium+0x953> <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10d1b8: 29 d8 sub %ebx,%eax <== NOT EXECUTED
10d1ba: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED
10d1bd: 3d 00 10 00 00 cmp $0x1000,%eax <== NOT EXECUTED
10d1c2: 76 07 jbe 10d1cb <jffs2_scan_medium+0x91b> <== NOT EXECUTED
10d1c4: c7 45 d0 00 10 00 00 movl $0x1000,-0x30(%ebp) <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10d1cb: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10d1cf: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED
10d1d2: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10d1d5: 8b 7d d0 mov -0x30(%ebp),%edi <== NOT EXECUTED
10d1d8: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
10d1dc: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED
10d1df: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
10d1e3: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
10d1e7: e8 74 f0 ff ff call 10c260 <jffs2_flash_read> <== NOT EXECUTED
if (ret) {
10d1ec: 85 c0 test %eax,%eax <== NOT EXECUTED
10d1ee: 0f 85 7c fa ff ff jne 10cc70 <jffs2_scan_medium+0x3c0> <== NOT EXECUTED
if (retlen < len) {
10d1f4: 3b 7d d8 cmp -0x28(%ebp),%edi <== NOT EXECUTED
10d1f7: 0f 87 d9 00 00 00 ja 10d2d6 <jffs2_scan_medium+0xa26> <== NOT EXECUTED
if (err)
10d1fd: 89 5d c8 mov %ebx,-0x38(%ebp) <== NOT EXECUTED
10d200: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED
but we have to go _back_ to the flash in order to finish the CRC checking, etc.
Which means that the _full_ amount of time to get to proper write mode with GC
operational may actually be _longer_ than before. Sucks to be me. */
/* Check the node CRC in any case. */
crc = crc32(0, ri, sizeof(*ri)-8);
10d203: 89 4d c0 mov %ecx,-0x40(%ebp) <== NOT EXECUTED
10d206: b8 3c 00 00 00 mov $0x3c,%eax <== NOT EXECUTED
uint32_t crc, ino = je32_to_cpu(ri->ino);
10d20b: 8b 79 0c mov 0xc(%ecx),%edi <== NOT EXECUTED
crc = crc32(0, ri, sizeof(*ri)-8);
10d20e: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
10d212: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10d216: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
10d21d: e8 6e dc ff ff call 10ae90 <cyg_crc32_accumulate> <== NOT EXECUTED
if (crc != je32_to_cpu(ri->node_crc)) {
10d222: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10d225: 8b 51 40 mov 0x40(%ecx),%edx <== NOT EXECUTED
10d228: 39 d0 cmp %edx,%eax <== NOT EXECUTED
10d22a: 0f 84 bf 01 00 00 je 10d3ef <jffs2_scan_medium+0xb3f> <== NOT EXECUTED
pr_notice("%s(): CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
10d230: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
10d234: b8 84 10 13 00 mov $0x131084,%eax <== NOT EXECUTED
10d239: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED
10d23d: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
10d241: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10d245: c7 04 24 dc 0c 13 00 movl $0x130cdc,(%esp) <== NOT EXECUTED
10d24c: e8 9f f3 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
/*
* We believe totlen because the CRC on the node
* _header_ was OK, just the node itself failed.
*/
return jffs2_scan_dirty_space(c, jeb,
PAD(je32_to_cpu(ri->totlen)));
10d251: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10d254: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED
return jffs2_scan_dirty_space(c, jeb,
10d257: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
PAD(je32_to_cpu(ri->totlen)));
10d25a: 83 c0 03 add $0x3,%eax <== NOT EXECUTED
return jffs2_scan_dirty_space(c, jeb,
10d25d: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
10d260: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10d264: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED
10d267: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10d26b: e8 e0 8d ff ff call 106050 <jffs2_scan_dirty_space> <== NOT EXECUTED
if (err) return err;
10d270: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10d273: 85 c0 test %eax,%eax <== NOT EXECUTED
10d275: 0f 85 f5 f9 ff ff jne 10cc70 <jffs2_scan_medium+0x3c0> <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10d27b: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
10d27e: 8b 51 04 mov 0x4(%ecx),%edx <== NOT EXECUTED
break;
10d281: 89 5d c0 mov %ebx,-0x40(%ebp) <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10d284: 8b 4e 34 mov 0x34(%esi),%ecx <== NOT EXECUTED
10d287: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
10d28a: 83 c2 03 add $0x3,%edx <== NOT EXECUTED
10d28d: 83 e2 fc and $0xfffffffc,%edx <== NOT EXECUTED
10d290: 01 d3 add %edx,%ebx <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10d292: 01 c8 add %ecx,%eax <== NOT EXECUTED
break;
10d294: e9 f9 f7 ff ff jmp 10ca92 <jffs2_scan_medium+0x1e2> <== NOT EXECUTED
pr_warn("Node at 0x%08x with length 0x%08x would run over the end of the erase block\n",
10d299: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10d29d: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED
10d2a0: c7 04 24 38 0c 13 00 movl $0x130c38,(%esp) <== NOT EXECUTED
10d2a7: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10d2ab: e8 40 f3 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
pr_warn("Perhaps the file system was created with the wrong erase size?\n");
10d2b0: c7 04 24 90 0c 13 00 movl $0x130c90,(%esp) <== NOT EXECUTED
10d2b7: e9 b5 fc ff ff jmp 10cf71 <jffs2_scan_medium+0x6c1> <== NOT EXECUTED
ret = 0;
10d2bc: 31 c0 xor %eax,%eax
10d2be: e9 cb f8 ff ff jmp 10cb8e <jffs2_scan_medium+0x2de>
ref = ref->next_in_ino;
10d2c3: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED
if (!ref)
10d2c6: 85 d2 test %edx,%edx <== NOT EXECUTED
10d2c8: 0f 84 9c fd ff ff je 10d06a <jffs2_scan_medium+0x7ba> <== NOT EXECUTED
if (ref->flash_offset == REF_EMPTY_NODE)
10d2ce: 8b 52 04 mov 0x4(%edx),%edx <== NOT EXECUTED
10d2d1: e9 8b fd ff ff jmp 10d061 <jffs2_scan_medium+0x7b1> <== NOT EXECUTED
return -EIO;
10d2d6: 8b 7d c4 mov -0x3c(%ebp),%edi <== NOT EXECUTED
10d2d9: b8 fb ff ff ff mov $0xfffffffb,%eax <== NOT EXECUTED
10d2de: e9 ab f8 ff ff jmp 10cb8e <jffs2_scan_medium+0x2de> <== NOT EXECUTED
if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) {
10d2e3: 8b 55 c8 mov -0x38(%ebp),%edx <== NOT EXECUTED
10d2e6: 8b 7d d0 mov -0x30(%ebp),%edi <== NOT EXECUTED
10d2e9: 01 fa add %edi,%edx <== NOT EXECUTED
10d2eb: 39 55 b0 cmp %edx,-0x50(%ebp) <== NOT EXECUTED
10d2ee: 76 47 jbe 10d337 <jffs2_scan_medium+0xa87> <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10d2f0: 29 d8 sub %ebx,%eax <== NOT EXECUTED
10d2f2: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED
10d2f5: 3d 00 10 00 00 cmp $0x1000,%eax <== NOT EXECUTED
10d2fa: 76 07 jbe 10d303 <jffs2_scan_medium+0xa53> <== NOT EXECUTED
10d2fc: c7 45 d0 00 10 00 00 movl $0x1000,-0x30(%ebp) <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10d303: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10d307: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED
10d30a: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10d30d: 8b 7d d0 mov -0x30(%ebp),%edi <== NOT EXECUTED
10d310: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
10d314: 8d 45 d8 lea -0x28(%ebp),%eax <== NOT EXECUTED
10d317: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
10d31b: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
10d31f: e8 3c ef ff ff call 10c260 <jffs2_flash_read> <== NOT EXECUTED
if (ret) {
10d324: 85 c0 test %eax,%eax <== NOT EXECUTED
10d326: 0f 85 44 f9 ff ff jne 10cc70 <jffs2_scan_medium+0x3c0> <== NOT EXECUTED
if (retlen < len) {
10d32c: 3b 7d d8 cmp -0x28(%ebp),%edi <== NOT EXECUTED
10d32f: 77 a5 ja 10d2d6 <jffs2_scan_medium+0xa26> <== NOT EXECUTED
if (err)
10d331: 89 5d c8 mov %ebx,-0x38(%ebp) <== NOT EXECUTED
10d334: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED
jffs2_dbg(1, "%s(): Node at 0x%08x\n", __func__, ofs);
/* We don't get here unless the node is still valid, so we don't have to
mask in the ACCURATE bit any more. */
crc = crc32(0, rd, sizeof(*rd)-8);
10d337: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
10d33b: bf 20 00 00 00 mov $0x20,%edi <== NOT EXECUTED
10d340: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
10d344: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
10d34b: 89 4d c0 mov %ecx,-0x40(%ebp) <== NOT EXECUTED
10d34e: e8 3d db ff ff call 10ae90 <cyg_crc32_accumulate> <== NOT EXECUTED
if (crc != je32_to_cpu(rd->node_crc)) {
10d353: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10d356: 8b 51 20 mov 0x20(%ecx),%edx <== NOT EXECUTED
10d359: 39 d0 cmp %edx,%eax <== NOT EXECUTED
10d35b: 0f 84 d5 01 00 00 je 10d536 <jffs2_scan_medium+0xc86> <== NOT EXECUTED
pr_notice("%s(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
10d361: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED
10d365: ba 6c 10 13 00 mov $0x13106c,%edx <== NOT EXECUTED
10d36a: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
10d36e: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
10d372: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
10d376: c7 04 24 2c 0d 13 00 movl $0x130d2c,(%esp) <== NOT EXECUTED
10d37d: e8 6e f2 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
jffs2_dbg(1, "Name for which CRC failed is (now) '%s', ino #%d\n",
fd->name, je32_to_cpu(rd->ino));
jffs2_free_full_dirent(fd);
/* FIXME: Why do we believe totlen? */
/* We believe totlen because the CRC on the node _header_ was OK, just the name failed. */
if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen)))))
10d382: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10d385: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED
10d388: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10d38b: 83 c0 03 add $0x3,%eax <== NOT EXECUTED
10d38e: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
10d391: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10d395: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED
10d398: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10d39c: e8 af 8c ff ff call 106050 <jffs2_scan_dirty_space> <== NOT EXECUTED
10d3a1: 85 c0 test %eax,%eax <== NOT EXECUTED
10d3a3: 0f 85 c7 f8 ff ff jne 10cc70 <jffs2_scan_medium+0x3c0> <== NOT EXECUTED
10d3a9: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10d3ac: e9 ca fe ff ff jmp 10d27b <jffs2_scan_medium+0x9cb> <== NOT EXECUTED
uint32_t empty_blocks = 0, bad_blocks = 0;
10d3b1: c7 45 b4 00 00 00 00 movl $0x0,-0x4c(%ebp) <== NOT EXECUTED
for (i=0; i<c->nr_blocks; i++) {
10d3b8: 31 d2 xor %edx,%edx <== NOT EXECUTED
10d3ba: e9 78 f7 ff ff jmp 10cb37 <jffs2_scan_medium+0x287> <== NOT EXECUTED
if (je32_to_cpu(node->totlen) != c->cleanmarker_size) {
10d3bf: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED
10d3c2: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10d3c5: 39 c1 cmp %eax,%ecx <== NOT EXECUTED
10d3c7: 74 78 je 10d441 <jffs2_scan_medium+0xb91> <== NOT EXECUTED
pr_notice("CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n",
10d3c9: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
10d3cd: 89 4c 24 08 mov %ecx,0x8(%esp) <== NOT EXECUTED
10d3d1: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10d3d5: c7 04 24 1c 0e 13 00 movl $0x130e1c,(%esp) <== NOT EXECUTED
10d3dc: e8 0f f2 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node)))))
10d3e1: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED
10d3e6: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10d3ea: e9 a8 f9 ff ff jmp 10cd97 <jffs2_scan_medium+0x4e7> <== NOT EXECUTED
ic = jffs2_get_ino_cache(c, ino);
10d3ef: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
10d3f3: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10d3f6: 89 4d c0 mov %ecx,-0x40(%ebp) <== NOT EXECUTED
10d3f9: e8 52 87 ff ff call 105b50 <jffs2_get_ino_cache> <== NOT EXECUTED
if (!ic) {
10d3fe: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10d401: 85 c0 test %eax,%eax <== NOT EXECUTED
10d403: 0f 84 b8 02 00 00 je 10d6c1 <jffs2_scan_medium+0xe11> <== NOT EXECUTED
jffs2_link_node_ref(c, jeb, ofs | REF_UNCHECKED, PAD(je32_to_cpu(ri->totlen)), ic);
10d409: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
10d40d: 89 4d c0 mov %ecx,-0x40(%ebp) <== NOT EXECUTED
10d410: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED
10d413: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
10d417: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10d41a: 83 c0 03 add $0x3,%eax <== NOT EXECUTED
10d41d: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
10d420: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
10d424: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED
10d427: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10d42b: e8 30 8a ff ff call 105e60 <jffs2_link_node_ref> <== NOT EXECUTED
pseudo_random += je32_to_cpu(ri->version);
10d430: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10d433: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED
10d436: 01 05 b8 b7 15 00 add %eax,0x15b7b8 <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
10d43c: e9 3a fe ff ff jmp 10d27b <jffs2_scan_medium+0x9cb> <== NOT EXECUTED
} else if (jeb->first_node) {
10d441: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED
10d444: 8b 51 28 mov 0x28(%ecx),%edx <== NOT EXECUTED
10d447: 85 d2 test %edx,%edx <== NOT EXECUTED
10d449: 0f 84 3d 03 00 00 je 10d78c <jffs2_scan_medium+0xedc> <== NOT EXECUTED
pr_notice("CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n",
10d44f: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10d453: 8b 45 ac mov -0x54(%ebp),%eax <== NOT EXECUTED
10d456: c7 04 24 68 0e 13 00 movl $0x130e68,(%esp) <== NOT EXECUTED
10d45d: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10d461: e8 8a f1 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node)))))
10d466: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED
10d469: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED
10d46e: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10d472: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10d475: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
10d479: e8 d2 8b ff ff call 106050 <jffs2_scan_dirty_space> <== NOT EXECUTED
10d47e: 85 c0 test %eax,%eax <== NOT EXECUTED
10d480: 0f 85 ea f7 ff ff jne 10cc70 <jffs2_scan_medium+0x3c0> <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10d486: 89 5d c0 mov %ebx,-0x40(%ebp) <== NOT EXECUTED
10d489: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED
10d48c: 89 fb mov %edi,%ebx <== NOT EXECUTED
10d48e: 8b 41 0c mov 0xc(%ecx),%eax <== NOT EXECUTED
10d491: 8b 4e 34 mov 0x34(%esi),%ecx <== NOT EXECUTED
10d494: 01 c8 add %ecx,%eax <== NOT EXECUTED
10d496: e9 f7 f5 ff ff jmp 10ca92 <jffs2_scan_medium+0x1e2> <== NOT EXECUTED
switch (je16_to_cpu(node->nodetype) & JFFS2_COMPAT_MASK) {
10d49b: 81 e7 00 c0 00 00 and $0xc000,%edi <== NOT EXECUTED
10d4a1: 81 ff 00 80 00 00 cmp $0x8000,%edi <== NOT EXECUTED
10d4a7: 0f 84 c1 01 00 00 je 10d66e <jffs2_scan_medium+0xdbe> <== NOT EXECUTED
10d4ad: 0f 87 92 01 00 00 ja 10d645 <jffs2_scan_medium+0xd95> <== NOT EXECUTED
10d4b3: 85 ff test %edi,%edi <== NOT EXECUTED
10d4b5: 0f 84 1b fc ff ff je 10d0d6 <jffs2_scan_medium+0x826> <== NOT EXECUTED
10d4bb: 81 ff 00 40 00 00 cmp $0x4000,%edi <== NOT EXECUTED
10d4c1: 0f 85 74 01 00 00 jne 10d63b <jffs2_scan_medium+0xd8b> <== NOT EXECUTED
jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(node->totlen)), NULL);
10d4c7: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10d4ca: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED
10d4cd: 31 ff xor %edi,%edi <== NOT EXECUTED
10d4cf: 89 7c 24 10 mov %edi,0x10(%esp) <== NOT EXECUTED
10d4d3: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED
10d4d6: 89 4d b0 mov %ecx,-0x50(%ebp) <== NOT EXECUTED
10d4d9: 83 c0 03 add $0x3,%eax <== NOT EXECUTED
10d4dc: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
10d4e0: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
10d4e3: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
10d4e7: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10d4e9: 83 c8 02 or $0x2,%eax <== NOT EXECUTED
10d4ec: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10d4f0: e8 6b 89 ff ff call 105e60 <jffs2_link_node_ref> <== NOT EXECUTED
10d4f5: e9 03 fc ff ff jmp 10d0fd <jffs2_scan_medium+0x84d> <== NOT EXECUTED
pr_warn("%s(): unknown block state\n", __func__);
10d4fa: c7 04 24 50 0f 13 00 movl $0x130f50,(%esp) <== NOT EXECUTED
10d501: bb b4 10 13 00 mov $0x1310b4,%ebx <== NOT EXECUTED
BUG();
10d506: be 3b d6 12 00 mov $0x12d63b,%esi <== NOT EXECUTED
pr_warn("%s(): unknown block state\n", __func__);
10d50b: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
BUG();
10d50f: bf b4 10 13 00 mov $0x1310b4,%edi <== NOT EXECUTED
pr_warn("%s(): unknown block state\n", __func__);
10d514: e8 d7 f0 ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
BUG();
10d519: b8 f1 00 00 00 mov $0xf1,%eax <== NOT EXECUTED
10d51e: 89 74 24 0c mov %esi,0xc(%esp) <== NOT EXECUTED
10d522: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
10d526: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10d52a: c7 04 24 78 0f 13 00 movl $0x130f78,(%esp) <== NOT EXECUTED
10d531: e8 3a 07 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED
checkedlen = strnlen(rd->name, rd->nsize);
10d536: 89 4d c0 mov %ecx,-0x40(%ebp) <== NOT EXECUTED
10d539: 0f b6 79 1c movzbl 0x1c(%ecx),%edi <== NOT EXECUTED
pseudo_random += je32_to_cpu(rd->version);
10d53d: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED
10d540: 01 05 b8 b7 15 00 add %eax,0x15b7b8 <== NOT EXECUTED
checkedlen = strnlen(rd->name, rd->nsize);
10d546: 8d 41 28 lea 0x28(%ecx),%eax <== NOT EXECUTED
10d549: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
10d54d: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10d550: 89 45 98 mov %eax,-0x68(%ebp) <== NOT EXECUTED
10d553: e8 08 9c 01 00 call 127160 <strnlen> <== NOT EXECUTED
if (checkedlen < rd->nsize) {
10d558: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
checkedlen = strnlen(rd->name, rd->nsize);
10d55b: 89 45 a4 mov %eax,-0x5c(%ebp) <== NOT EXECUTED
if (checkedlen < rd->nsize) {
10d55e: 39 c7 cmp %eax,%edi <== NOT EXECUTED
checkedlen = strnlen(rd->name, rd->nsize);
10d560: 89 45 9c mov %eax,-0x64(%ebp) <== NOT EXECUTED
if (checkedlen < rd->nsize) {
10d563: 0f 87 07 02 00 00 ja 10d770 <jffs2_scan_medium+0xec0> <== NOT EXECUTED
10d569: 89 4d 94 mov %ecx,-0x6c(%ebp) <== NOT EXECUTED
fd = jffs2_alloc_full_dirent(checkedlen+1);
10d56c: 8b 7d a4 mov -0x5c(%ebp),%edi <== NOT EXECUTED
10d56f: 89 f8 mov %edi,%eax <== NOT EXECUTED
10d571: 40 inc %eax <== NOT EXECUTED
10d572: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10d575: e8 a6 7b ff ff call 105120 <jffs2_alloc_full_dirent> <== NOT EXECUTED
10d57a: 89 45 ac mov %eax,-0x54(%ebp) <== NOT EXECUTED
if (!fd) {
10d57d: 85 c0 test %eax,%eax <== NOT EXECUTED
10d57f: 0f 84 53 01 00 00 je 10d6d8 <jffs2_scan_medium+0xe28> <== NOT EXECUTED
memcpy(&fd->name, rd->name, checkedlen);
10d585: 89 7d a0 mov %edi,-0x60(%ebp) <== NOT EXECUTED
10d588: 8d 48 15 lea 0x15(%eax),%ecx <== NOT EXECUTED
10d58b: 89 f8 mov %edi,%eax <== NOT EXECUTED
10d58d: 89 4d a8 mov %ecx,-0x58(%ebp) <== NOT EXECUTED
10d590: 89 cf mov %ecx,%edi <== NOT EXECUTED
10d592: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED
10d595: 89 4d c0 mov %ecx,-0x40(%ebp) <== NOT EXECUTED
10d598: 8b 4d 98 mov -0x68(%ebp),%ecx <== NOT EXECUTED
10d59b: 89 4d b0 mov %ecx,-0x50(%ebp) <== NOT EXECUTED
10d59e: 8b 4d 94 mov -0x6c(%ebp),%ecx <== NOT EXECUTED
10d5a1: 0f 83 59 01 00 00 jae 10d700 <jffs2_scan_medium+0xe50> <== NOT EXECUTED
10d5a7: 31 c0 xor %eax,%eax <== NOT EXECUTED
10d5a9: f6 45 a0 02 testb $0x2,-0x60(%ebp) <== NOT EXECUTED
10d5ad: 74 11 je 10d5c0 <jffs2_scan_medium+0xd10> <== NOT EXECUTED
10d5af: 8b 45 b0 mov -0x50(%ebp),%eax <== NOT EXECUTED
10d5b2: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED
10d5b5: 0f b7 00 movzwl (%eax),%eax <== NOT EXECUTED
10d5b8: 66 89 02 mov %ax,(%edx) <== NOT EXECUTED
10d5bb: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED
10d5c0: f6 45 a0 01 testb $0x1,-0x60(%ebp) <== NOT EXECUTED
10d5c4: 74 10 je 10d5d6 <jffs2_scan_medium+0xd26> <== NOT EXECUTED
10d5c6: 8b 7d b0 mov -0x50(%ebp),%edi <== NOT EXECUTED
10d5c9: 0f b6 14 07 movzbl (%edi,%eax,1),%edx <== NOT EXECUTED
10d5cd: 8b 7d c0 mov -0x40(%ebp),%edi <== NOT EXECUTED
10d5d0: 88 55 b0 mov %dl,-0x50(%ebp) <== NOT EXECUTED
10d5d3: 88 14 07 mov %dl,(%edi,%eax,1) <== NOT EXECUTED
crc = crc32(0, fd->name, rd->nsize);
10d5d6: 89 4d c0 mov %ecx,-0x40(%ebp) <== NOT EXECUTED
fd->name[checkedlen] = 0;
10d5d9: 8b 45 a4 mov -0x5c(%ebp),%eax <== NOT EXECUTED
10d5dc: 8b 7d ac mov -0x54(%ebp),%edi <== NOT EXECUTED
10d5df: c6 44 07 15 00 movb $0x0,0x15(%edi,%eax,1) <== NOT EXECUTED
crc = crc32(0, fd->name, rd->nsize);
10d5e4: 0f b6 41 1c movzbl 0x1c(%ecx),%eax <== NOT EXECUTED
10d5e8: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
10d5ef: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10d5f3: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED
10d5f6: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10d5fa: e8 91 d8 ff ff call 10ae90 <cyg_crc32_accumulate> <== NOT EXECUTED
if (crc != je32_to_cpu(rd->name_crc)) {
10d5ff: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10d602: 8b 51 24 mov 0x24(%ecx),%edx <== NOT EXECUTED
10d605: 39 d0 cmp %edx,%eax <== NOT EXECUTED
10d607: 0f 84 ac 01 00 00 je 10d7b9 <jffs2_scan_medium+0xf09> <== NOT EXECUTED
pr_notice("%s(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
10d60d: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
10d611: b8 6c 10 13 00 mov $0x13106c,%eax <== NOT EXECUTED
10d616: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED
10d61a: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
10d61e: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10d622: c7 04 24 c8 0d 13 00 movl $0x130dc8,(%esp) <== NOT EXECUTED
10d629: e8 c2 ef ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
jffs2_free_full_dirent(fd);
10d62e: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10d631: e8 fa 7a ff ff call 105130 <jffs2_free_full_dirent> <== NOT EXECUTED
10d636: e9 47 fd ff ff jmp 10d382 <jffs2_scan_medium+0xad2> <== NOT EXECUTED
10d63b: 89 5d c0 mov %ebx,-0x40(%ebp) <== NOT EXECUTED
10d63e: 66 90 xchg %ax,%ax <== NOT EXECUTED
10d640: e9 4d f4 ff ff jmp 10ca92 <jffs2_scan_medium+0x1e2> <== NOT EXECUTED
10d645: 81 ff 00 c0 00 00 cmp $0xc000,%edi <== NOT EXECUTED
10d64b: 75 ee jne 10d63b <jffs2_scan_medium+0xd8b> <== NOT EXECUTED
pr_notice("Incompatible feature node (0x%04x) found at offset 0x%08x\n",
10d64d: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
10d651: 8b 7d c4 mov -0x3c(%ebp),%edi <== NOT EXECUTED
10d654: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
10d658: c7 04 24 08 0f 13 00 movl $0x130f08,(%esp) <== NOT EXECUTED
10d65f: e8 8c ef ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
return -EINVAL;
10d664: b8 ea ff ff ff mov $0xffffffea,%eax <== NOT EXECUTED
10d669: e9 20 f5 ff ff jmp 10cb8e <jffs2_scan_medium+0x2de> <== NOT EXECUTED
pr_notice("Read-only compatible feature node (0x%04x) found at offset 0x%08x\n",
10d66e: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
10d672: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
10d676: c7 04 24 b8 0e 13 00 movl $0x130eb8,(%esp) <== NOT EXECUTED
10d67d: 89 4d c0 mov %ecx,-0x40(%ebp) <== NOT EXECUTED
10d680: e8 6b ef ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
c->flags |= JFFS2_SB_FLAG_RO;
10d685: 83 4e 0c 01 orl $0x1,0xc(%esi) <== NOT EXECUTED
if (!(jffs2_is_readonly(c)))
10d689: 80 be ec 00 00 00 00 cmpb $0x0,0xec(%esi) <== NOT EXECUTED
10d690: 74 53 je 10d6e5 <jffs2_scan_medium+0xe35> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
10d692: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10d695: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED
10d698: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED
10d69b: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
10d69f: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10d6a2: 83 c0 03 add $0x3,%eax <== NOT EXECUTED
10d6a5: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
10d6a8: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10d6ac: e8 9f 89 ff ff call 106050 <jffs2_scan_dirty_space> <== NOT EXECUTED
10d6b1: 85 c0 test %eax,%eax <== NOT EXECUTED
10d6b3: 0f 85 b7 f5 ff ff jne 10cc70 <jffs2_scan_medium+0x3c0> <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
10d6b9: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10d6bc: e9 3f fa ff ff jmp 10d100 <jffs2_scan_medium+0x850> <== NOT EXECUTED
ic = jffs2_scan_make_ino_cache(c, ino);
10d6c1: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
10d6c5: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10d6c8: e8 b3 f0 ff ff call 10c780 <jffs2_scan_make_ino_cache> <== NOT EXECUTED
if (!ic)
10d6cd: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10d6d0: 85 c0 test %eax,%eax <== NOT EXECUTED
10d6d2: 0f 85 31 fd ff ff jne 10d409 <jffs2_scan_medium+0xb59> <== NOT EXECUTED
return -ENOMEM;
10d6d8: 8b 7d c4 mov -0x3c(%ebp),%edi <== NOT EXECUTED
10d6db: b8 f4 ff ff ff mov $0xfffffff4,%eax <== NOT EXECUTED
10d6e0: e9 a9 f4 ff ff jmp 10cb8e <jffs2_scan_medium+0x2de> <== NOT EXECUTED
return -EROFS;
10d6e5: 8b 7d c4 mov -0x3c(%ebp),%edi <== NOT EXECUTED
10d6e8: b8 e2 ff ff ff mov $0xffffffe2,%eax <== NOT EXECUTED
if (ret < 0)
10d6ed: e9 9c f4 ff ff jmp 10cb8e <jffs2_scan_medium+0x2de> <== NOT EXECUTED
10d6f2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10d6f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
memcpy(&fd->name, rd->name, checkedlen);
10d700: 89 f8 mov %edi,%eax <== NOT EXECUTED
10d702: a8 01 test $0x1,%al <== NOT EXECUTED
10d704: 0f 85 bc 01 00 00 jne 10d8c6 <jffs2_scan_medium+0x1016> <== NOT EXECUTED
10d70a: f6 45 c0 02 testb $0x2,-0x40(%ebp) <== NOT EXECUTED
10d70e: 0f 85 91 01 00 00 jne 10d8a5 <jffs2_scan_medium+0xff5> <== NOT EXECUTED
10d714: 8b 45 a0 mov -0x60(%ebp),%eax <== NOT EXECUTED
10d717: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED
10d71a: 0f 82 87 fe ff ff jb 10d5a7 <jffs2_scan_medium+0xcf7> <== NOT EXECUTED
10d720: 8b 7d ac mov -0x54(%ebp),%edi <== NOT EXECUTED
10d723: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED
10d726: 89 45 98 mov %eax,-0x68(%ebp) <== NOT EXECUTED
10d729: 8b 55 b0 mov -0x50(%ebp),%edx <== NOT EXECUTED
10d72c: 31 c0 xor %eax,%eax <== NOT EXECUTED
10d72e: 89 5d 94 mov %ebx,-0x6c(%ebp) <== NOT EXECUTED
10d731: 89 4d 90 mov %ecx,-0x70(%ebp) <== NOT EXECUTED
10d734: 8b 1c 02 mov (%edx,%eax,1),%ebx <== NOT EXECUTED
10d737: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10d73a: 89 1c 01 mov %ebx,(%ecx,%eax,1) <== NOT EXECUTED
10d73d: 83 c0 04 add $0x4,%eax <== NOT EXECUTED
10d740: 3b 45 98 cmp -0x68(%ebp),%eax <== NOT EXECUTED
10d743: 72 ef jb 10d734 <jffs2_scan_medium+0xe84> <== NOT EXECUTED
10d745: 01 c2 add %eax,%edx <== NOT EXECUTED
10d747: 8b 5d 94 mov -0x6c(%ebp),%ebx <== NOT EXECUTED
10d74a: 89 7d ac mov %edi,-0x54(%ebp) <== NOT EXECUTED
10d74d: 8b 4d 90 mov -0x70(%ebp),%ecx <== NOT EXECUTED
10d750: 01 45 c0 add %eax,-0x40(%ebp) <== NOT EXECUTED
10d753: 89 55 b0 mov %edx,-0x50(%ebp) <== NOT EXECUTED
10d756: e9 4c fe ff ff jmp 10d5a7 <jffs2_scan_medium+0xcf7> <== NOT EXECUTED
return -ENOMEM;
10d75b: b8 f4 ff ff ff mov $0xfffffff4,%eax <== NOT EXECUTED
10d760: e9 37 f4 ff ff jmp 10cb9c <jffs2_scan_medium+0x2ec> <== NOT EXECUTED
10d765: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10d76c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
pr_err("Dirent at %08x has zeroes in name. Truncating to %d chars\n",
10d770: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10d774: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10d778: c7 04 24 80 0d 13 00 movl $0x130d80,(%esp) <== NOT EXECUTED
10d77f: e8 6c ee ff ff call 10c5f0 <jffs2_printk> <== NOT EXECUTED
10d784: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10d787: e9 dd fd ff ff jmp 10d569 <jffs2_scan_medium+0xcb9> <== NOT EXECUTED
jffs2_link_node_ref(c, jeb, ofs | REF_NORMAL, c->cleanmarker_size, NULL);
10d78c: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
10d790: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED
10d793: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10d795: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10d798: 31 d2 xor %edx,%edx <== NOT EXECUTED
10d79a: 83 c8 03 or $0x3,%eax <== NOT EXECUTED
10d79d: 89 54 24 10 mov %edx,0x10(%esp) <== NOT EXECUTED
10d7a1: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10d7a5: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
10d7a9: e8 b2 86 ff ff call 105e60 <jffs2_link_node_ref> <== NOT EXECUTED
ofs += PAD(c->cleanmarker_size);
10d7ae: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED
10d7b1: 8d 50 03 lea 0x3(%eax),%edx <== NOT EXECUTED
10d7b4: e9 4d f9 ff ff jmp 10d106 <jffs2_scan_medium+0x856> <== NOT EXECUTED
return err;
return 0;
}
ic = jffs2_scan_make_ino_cache(c, je32_to_cpu(rd->pino));
10d7b9: 89 4d b0 mov %ecx,-0x50(%ebp) <== NOT EXECUTED
10d7bc: 8b 41 0c mov 0xc(%ecx),%eax <== NOT EXECUTED
10d7bf: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10d7c2: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10d7c6: e8 b5 ef ff ff call 10c780 <jffs2_scan_make_ino_cache> <== NOT EXECUTED
if (!ic) {
10d7cb: 8b 4d b0 mov -0x50(%ebp),%ecx <== NOT EXECUTED
ic = jffs2_scan_make_ino_cache(c, je32_to_cpu(rd->pino));
10d7ce: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED
if (!ic) {
10d7d1: 85 c0 test %eax,%eax <== NOT EXECUTED
10d7d3: 0f 84 b4 00 00 00 je 10d88d <jffs2_scan_medium+0xfdd> <== NOT EXECUTED
jffs2_free_full_dirent(fd);
return -ENOMEM;
}
fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
10d7d9: 89 4d b0 mov %ecx,-0x50(%ebp) <== NOT EXECUTED
PAD(je32_to_cpu(rd->totlen)), ic);
10d7dc: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED
10d7df: 8d 50 03 lea 0x3(%eax),%edx <== NOT EXECUTED
fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
10d7e2: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED
10d7e7: 83 e2 fc and $0xfffffffc,%edx <== NOT EXECUTED
10d7ea: 83 79 14 01 cmpl $0x1,0x14(%ecx) <== NOT EXECUTED
10d7ee: 89 54 24 0c mov %edx,0xc(%esp) <== NOT EXECUTED
10d7f2: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED
10d7f5: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10d7f8: 83 d0 ff adc $0xffffffff,%eax <== NOT EXECUTED
10d7fb: 09 d8 or %ebx,%eax <== NOT EXECUTED
10d7fd: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10d801: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED
10d804: 89 4c 24 10 mov %ecx,0x10(%esp) <== NOT EXECUTED
10d808: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10d80c: e8 4f 86 ff ff call 105e60 <jffs2_link_node_ref> <== NOT EXECUTED
10d811: 8b 7d ac mov -0x54(%ebp),%edi <== NOT EXECUTED
fd->next = NULL;
fd->version = je32_to_cpu(rd->version);
10d814: 8b 4d b0 mov -0x50(%ebp),%ecx <== NOT EXECUTED
fd->next = NULL;
10d817: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) <== NOT EXECUTED
fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
10d81e: 89 07 mov %eax,(%edi) <== NOT EXECUTED
fd->version = je32_to_cpu(rd->version);
10d820: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED
10d823: 89 47 08 mov %eax,0x8(%edi) <== NOT EXECUTED
fd->ino = je32_to_cpu(rd->ino);
10d826: 8b 41 14 mov 0x14(%ecx),%eax <== NOT EXECUTED
10d829: 89 47 0c mov %eax,0xc(%edi) <== NOT EXECUTED
while (len--) {
10d82c: 8b 45 a4 mov -0x5c(%ebp),%eax <== NOT EXECUTED
10d82f: 85 c0 test %eax,%eax <== NOT EXECUTED
10d831: 74 2c je 10d85f <jffs2_scan_medium+0xfaf> <== NOT EXECUTED
uint32_t hash = 0;
10d833: c7 45 9c 00 00 00 00 movl $0x0,-0x64(%ebp) <== NOT EXECUTED
10d83a: 8d 44 07 15 lea 0x15(%edi,%eax,1),%eax <== NOT EXECUTED
hash = (hash << 4) | (hash >> 28);
10d83e: 8b 55 9c mov -0x64(%ebp),%edx <== NOT EXECUTED
hash ^= *(name++);
10d841: ff 45 a8 incl -0x58(%ebp) <== NOT EXECUTED
hash = (hash << 4) | (hash >> 28);
10d844: c1 c2 04 rol $0x4,%edx <== NOT EXECUTED
10d847: 89 55 b0 mov %edx,-0x50(%ebp) <== NOT EXECUTED
hash ^= *(name++);
10d84a: 8b 55 a8 mov -0x58(%ebp),%edx <== NOT EXECUTED
10d84d: 0f b6 52 ff movzbl -0x1(%edx),%edx <== NOT EXECUTED
10d851: 33 55 b0 xor -0x50(%ebp),%edx <== NOT EXECUTED
while (len--) {
10d854: 39 45 a8 cmp %eax,-0x58(%ebp) <== NOT EXECUTED
hash ^= *(name++);
10d857: 89 55 9c mov %edx,-0x64(%ebp) <== NOT EXECUTED
while (len--) {
10d85a: 75 e2 jne 10d83e <jffs2_scan_medium+0xf8e> <== NOT EXECUTED
10d85c: 89 7d ac mov %edi,-0x54(%ebp) <== NOT EXECUTED
fd->nhash = full_name_hash(NULL, fd->name, checkedlen);
fd->type = rd->type;
10d85f: 89 4d b0 mov %ecx,-0x50(%ebp) <== NOT EXECUTED
fd->nhash = full_name_hash(NULL, fd->name, checkedlen);
10d862: 8b 7d ac mov -0x54(%ebp),%edi <== NOT EXECUTED
10d865: 8b 45 9c mov -0x64(%ebp),%eax <== NOT EXECUTED
10d868: 89 47 10 mov %eax,0x10(%edi) <== NOT EXECUTED
fd->type = rd->type;
10d86b: 0f b6 41 1d movzbl 0x1d(%ecx),%eax <== NOT EXECUTED
10d86f: 88 47 14 mov %al,0x14(%edi) <== NOT EXECUTED
jffs2_add_fd_to_list(c, fd, &ic->scan_dents);
10d872: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED
10d875: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
10d879: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10d87c: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10d880: e8 cb 7b ff ff call 105450 <jffs2_add_fd_to_list> <== NOT EXECUTED
10d885: 8b 4d b0 mov -0x50(%ebp),%ecx <== NOT EXECUTED
if (err) return err;
10d888: e9 ee f9 ff ff jmp 10d27b <jffs2_scan_medium+0x9cb> <== NOT EXECUTED
jffs2_free_full_dirent(fd);
10d88d: 8b 45 ac mov -0x54(%ebp),%eax <== NOT EXECUTED
10d890: 8b 7d c4 mov -0x3c(%ebp),%edi <== NOT EXECUTED
10d893: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
10d896: e8 95 78 ff ff call 105130 <jffs2_free_full_dirent> <== NOT EXECUTED
return -ENOMEM;
10d89b: b8 f4 ff ff ff mov $0xfffffff4,%eax <== NOT EXECUTED
10d8a0: e9 e9 f2 ff ff jmp 10cb8e <jffs2_scan_medium+0x2de> <== NOT EXECUTED
memcpy(&fd->name, rd->name, checkedlen);
10d8a5: 8b 7d b0 mov -0x50(%ebp),%edi <== NOT EXECUTED
10d8a8: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED
10d8ab: 0f b7 07 movzwl (%edi),%eax <== NOT EXECUTED
10d8ae: 66 89 02 mov %ax,(%edx) <== NOT EXECUTED
10d8b1: 8d 42 02 lea 0x2(%edx),%eax <== NOT EXECUTED
10d8b4: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED
10d8b7: 8d 47 02 lea 0x2(%edi),%eax <== NOT EXECUTED
10d8ba: 83 6d a0 02 subl $0x2,-0x60(%ebp) <== NOT EXECUTED
10d8be: 89 45 b0 mov %eax,-0x50(%ebp) <== NOT EXECUTED
10d8c1: e9 4e fe ff ff jmp 10d714 <jffs2_scan_medium+0xe64> <== NOT EXECUTED
10d8c6: 8b 45 98 mov -0x68(%ebp),%eax <== NOT EXECUTED
10d8c9: 8b 7d ac mov -0x54(%ebp),%edi <== NOT EXECUTED
10d8cc: 0f b6 00 movzbl (%eax),%eax <== NOT EXECUTED
10d8cf: 88 47 15 mov %al,0x15(%edi) <== NOT EXECUTED
10d8d2: 8d 47 16 lea 0x16(%edi),%eax <== NOT EXECUTED
10d8d5: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED
10d8d8: 8b 45 b0 mov -0x50(%ebp),%eax <== NOT EXECUTED
10d8db: 40 inc %eax <== NOT EXECUTED
10d8dc: 89 45 b0 mov %eax,-0x50(%ebp) <== NOT EXECUTED
10d8df: 8b 45 a4 mov -0x5c(%ebp),%eax <== NOT EXECUTED
10d8e2: 48 dec %eax <== NOT EXECUTED
10d8e3: 89 45 a0 mov %eax,-0x60(%ebp) <== NOT EXECUTED
10d8e6: e9 1f fe ff ff jmp 10d70a <jffs2_scan_medium+0xe5a> <== NOT EXECUTED
10d8eb: 90 nop
10d8ec: 90 nop
10d8ed: 90 nop
10d8ee: 90 nop
10d8ef: 90 nop
00106d20 <jffs2_thread_should_wake>:
int jffs2_thread_should_wake(struct jffs2_sb_info *c)
{
106d20: 55 push %ebp
int nr_very_dirty = 0;
struct jffs2_eraseblock *jeb;
if (!list_empty(&c->erase_complete_list) ||
!list_empty(&c->erase_pending_list))
return 1;
106d21: b9 01 00 00 00 mov $0x1,%ecx
{
106d26: 89 e5 mov %esp,%ebp
106d28: 83 ec 08 sub $0x8,%esp
106d2b: 89 5d f8 mov %ebx,-0x8(%ebp)
106d2e: 8b 45 08 mov 0x8(%ebp),%eax
106d31: 89 75 fc mov %esi,-0x4(%ebp)
if (!list_empty(&c->erase_complete_list) ||
106d34: 8d 90 a0 00 00 00 lea 0xa0(%eax),%edx
106d3a: 39 90 a0 00 00 00 cmp %edx,0xa0(%eax)
106d40: 74 0e je 106d50 <jffs2_thread_should_wake+0x30> <== ALWAYS TAKEN
jffs2_dbg(1, "%s(): nr_free_blocks %d, nr_erasing_blocks %d, dirty_size 0x%x, vdirty_blocks %d: %s\n",
__func__, c->nr_free_blocks, c->nr_erasing_blocks,
c->dirty_size, nr_very_dirty, ret ? "yes" : "no");
return ret;
}
106d42: 8b 5d f8 mov -0x8(%ebp),%ebx
106d45: 89 c8 mov %ecx,%eax
106d47: 8b 75 fc mov -0x4(%ebp),%esi
106d4a: 89 ec mov %ebp,%esp
106d4c: 5d pop %ebp
106d4d: c3 ret
106d4e: 66 90 xchg %ax,%ax
!list_empty(&c->erase_pending_list))
106d50: 8d 90 98 00 00 00 lea 0x98(%eax),%edx
if (!list_empty(&c->erase_complete_list) ||
106d56: 39 90 98 00 00 00 cmp %edx,0x98(%eax)
106d5c: 75 e4 jne 106d42 <jffs2_thread_should_wake+0x22>
if (c->unchecked_size) {
106d5e: 8b 50 38 mov 0x38(%eax),%edx
106d61: 85 d2 test %edx,%edx
106d63: 75 dd jne 106d42 <jffs2_thread_should_wake+0x22> <== NEVER TAKEN
dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size;
106d65: 8b 50 40 mov 0x40(%eax),%edx
int ret = 0;
106d68: 31 c9 xor %ecx,%ecx
if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger &&
106d6a: 8b 70 3c mov 0x3c(%eax),%esi
106d6d: 0f b6 58 46 movzbl 0x46(%eax),%ebx
106d71: 01 d6 add %edx,%esi
106d73: 39 de cmp %ebx,%esi
106d75: 73 19 jae 106d90 <jffs2_thread_should_wake+0x70> <== ALWAYS TAKEN
dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size;
106d77: 8b 70 34 mov 0x34(%eax),%esi <== NOT EXECUTED
106d7a: 8b 48 2c mov 0x2c(%eax),%ecx <== NOT EXECUTED
106d7d: 8b 58 20 mov 0x20(%eax),%ebx <== NOT EXECUTED
106d80: 0f af d6 imul %esi,%edx <== NOT EXECUTED
106d83: 01 d9 add %ebx,%ecx <== NOT EXECUTED
106d85: 29 d1 sub %edx,%ecx <== NOT EXECUTED
if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger &&
106d87: 39 48 4c cmp %ecx,0x4c(%eax) <== NOT EXECUTED
106d8a: 0f 92 c1 setb %cl <== NOT EXECUTED
106d8d: 0f b6 c9 movzbl %cl,%ecx <== NOT EXECUTED
list_for_each_entry(jeb, &c->very_dirty_list, list) {
106d90: 8b 50 68 mov 0x68(%eax),%edx
106d93: 8d 58 68 lea 0x68(%eax),%ebx
106d96: 39 da cmp %ebx,%edx
106d98: 74 a8 je 106d42 <jffs2_thread_should_wake+0x22> <== NEVER TAKEN
if (nr_very_dirty == c->vdirty_blocks_gctrigger) {
106d9a: 0f b6 70 49 movzbl 0x49(%eax),%esi
int nr_very_dirty = 0;
106d9e: 31 c0 xor %eax,%eax
106da0: eb 14 jmp 106db6 <jffs2_thread_should_wake+0x96>
106da2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
106da9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
list_for_each_entry(jeb, &c->very_dirty_list, list) {
106db0: 8b 12 mov (%edx),%edx
106db2: 39 da cmp %ebx,%edx
106db4: 74 8c je 106d42 <jffs2_thread_should_wake+0x22>
nr_very_dirty++;
106db6: 40 inc %eax
if (nr_very_dirty == c->vdirty_blocks_gctrigger) {
106db7: 39 c6 cmp %eax,%esi
106db9: 75 f5 jne 106db0 <jffs2_thread_should_wake+0x90> <== ALWAYS TAKEN
return 1;
106dbb: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED
106dc0: eb 80 jmp 106d42 <jffs2_thread_should_wake+0x22> <== NOT EXECUTED
106dc2: 90 nop
106dc3: 90 nop
106dc4: 90 nop
106dc5: 90 nop
106dc6: 90 nop
106dc7: 90 nop
106dc8: 90 nop
106dc9: 90 nop
106dca: 90 nop
106dcb: 90 nop
106dcc: 90 nop
106dcd: 90 nop
106dce: 90 nop
106dcf: 90 nop
00105530 <jffs2_truncate_fragtree>:
{
105530: 55 push %ebp
105531: 89 e5 mov %esp,%ebp
105533: 57 push %edi
105534: 56 push %esi
105535: 53 push %ebx
105536: 31 db xor %ebx,%ebx
105538: 83 ec 1c sub $0x1c,%esp
struct jffs2_node_frag *prev = NULL;
struct jffs2_node_frag *frag = NULL;
dbg_fragtree2("root %p, offset %d\n", fragtree, offset);
next = fragtree->rb_node;
10553b: 8b 45 0c mov 0xc(%ebp),%eax
{
10553e: 8b 7d 10 mov 0x10(%ebp),%edi
next = fragtree->rb_node;
105541: 8b 00 mov (%eax),%eax
while(next) {
105543: 85 c0 test %eax,%eax
105545: 0f 84 a8 00 00 00 je 1055f3 <jffs2_truncate_fragtree+0xc3>
10554b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10554f: 90 nop
frag = rb_entry(next, struct jffs2_node_frag, rb);
if (frag->ofs + frag->size <= offset) {
105550: 8b 50 18 mov 0x18(%eax),%edx
105553: 8b 48 14 mov 0x14(%eax),%ecx
105556: 01 d1 add %edx,%ecx
105558: 39 cf cmp %ecx,%edi
10555a: 0f 82 c0 00 00 00 jb 105620 <jffs2_truncate_fragtree+0xf0>
/* Remember the closest smaller match on the way down */
if (!prev || frag->ofs > prev->ofs)
105560: 85 db test %ebx,%ebx
105562: 0f 84 a8 00 00 00 je 105610 <jffs2_truncate_fragtree+0xe0>
105568: 3b 53 18 cmp 0x18(%ebx),%edx
10556b: 0f 87 9f 00 00 00 ja 105610 <jffs2_truncate_fragtree+0xe0> <== ALWAYS TAKEN
prev = frag;
next = frag->rb.rb_right;
105571: 8b 40 04 mov 0x4(%eax),%eax
while(next) {
105574: 85 c0 test %eax,%eax
105576: 75 d8 jne 105550 <jffs2_truncate_fragtree+0x20>
if (frag && frag->ofs != size) {
105578: 85 db test %ebx,%ebx
10557a: 74 77 je 1055f3 <jffs2_truncate_fragtree+0xc3> <== NEVER TAKEN
10557c: 8b 53 18 mov 0x18(%ebx),%edx
10557f: 39 fa cmp %edi,%edx
if (frag->ofs+frag->size > size) {
105581: 89 d0 mov %edx,%eax
if (frag && frag->ofs != size) {
105583: 0f 84 07 01 00 00 je 105690 <jffs2_truncate_fragtree+0x160> <== NEVER TAKEN
if (frag->ofs+frag->size > size) {
105589: 8b 4b 14 mov 0x14(%ebx),%ecx
10558c: 01 c8 add %ecx,%eax
10558e: 39 f8 cmp %edi,%eax
105590: 0f 87 14 01 00 00 ja 1056aa <jffs2_truncate_fragtree+0x17a> <== NEVER TAKEN
105596: 89 1c 24 mov %ebx,(%esp)
105599: e8 22 05 01 00 call 115ac0 <_RBTree_Successor>
while (frag && frag->ofs >= size) {
10559e: 85 c0 test %eax,%eax
1055a0: 89 c3 mov %eax,%ebx
1055a2: 74 4f je 1055f3 <jffs2_truncate_fragtree+0xc3> <== ALWAYS TAKEN
1055a4: 89 7d 10 mov %edi,0x10(%ebp) <== NOT EXECUTED
1055a7: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED
1055aa: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
1055ad: 89 d0 mov %edx,%eax <== NOT EXECUTED
1055af: eb 3a jmp 1055eb <jffs2_truncate_fragtree+0xbb> <== NOT EXECUTED
1055b1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1055b8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1055bf: 90 nop <== NOT EXECUTED
1055c0: 89 1c 24 mov %ebx,(%esp)
1055c3: e8 f8 04 01 00 call 115ac0 <_RBTree_Successor>
_RBTree_Extract( (RBTree_Control *) root, node );
1055c8: 89 5c 24 04 mov %ebx,0x4(%esp)
return _RBTree_Successor( node );
1055cc: 89 c7 mov %eax,%edi
_RBTree_Extract( (RBTree_Control *) root, node );
1055ce: 8b 45 0c mov 0xc(%ebp),%eax
1055d1: 89 04 24 mov %eax,(%esp)
1055d4: e8 e7 fd 00 00 call 1153c0 <_RBTree_Extract>
jffs2_obsolete_node_frag(c, frag);
1055d9: 89 da mov %ebx,%edx
1055db: 89 f0 mov %esi,%eax
1055dd: e8 3e fd ff ff call 105320 <jffs2_obsolete_node_frag>
while (frag && frag->ofs >= size) {
1055e2: 85 ff test %edi,%edi
1055e4: 74 0a je 1055f0 <jffs2_truncate_fragtree+0xc0>
1055e6: 8b 47 18 mov 0x18(%edi),%eax
1055e9: 89 fb mov %edi,%ebx
1055eb: 39 45 10 cmp %eax,0x10(%ebp)
1055ee: 76 d0 jbe 1055c0 <jffs2_truncate_fragtree+0x90> <== ALWAYS TAKEN
1055f0: 8b 7d 10 mov 0x10(%ebp),%edi
if (size == 0)
1055f3: 85 ff test %edi,%edi
1055f5: 75 39 jne 105630 <jffs2_truncate_fragtree+0x100>
return 0;
1055f7: 31 d2 xor %edx,%edx
}
1055f9: 83 c4 1c add $0x1c,%esp
1055fc: 89 d0 mov %edx,%eax
1055fe: 5b pop %ebx
1055ff: 5e pop %esi
105600: 5f pop %edi
105601: 5d pop %ebp
105602: c3 ret
105603: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10560a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
105610: 89 c3 mov %eax,%ebx
105612: e9 5a ff ff ff jmp 105571 <jffs2_truncate_fragtree+0x41>
105617: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10561e: 66 90 xchg %ax,%ax
} else if (frag->ofs > offset) {
105620: 39 d7 cmp %edx,%edi
105622: 73 5c jae 105680 <jffs2_truncate_fragtree+0x150>
next = frag->rb.rb_left;
105624: 8b 00 mov (%eax),%eax
105626: e9 49 ff ff ff jmp 105574 <jffs2_truncate_fragtree+0x44>
10562b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10562f: 90 nop
return _RBTree_Maximum( (RBTree_Control *) root );
105630: 8b 45 0c mov 0xc(%ebp),%eax
105633: 89 04 24 mov %eax,(%esp)
105636: e8 55 04 01 00 call 115a90 <_RBTree_Maximum>
10563b: 85 c0 test %eax,%eax
10563d: 74 b8 je 1055f7 <jffs2_truncate_fragtree+0xc7> <== NEVER TAKEN
if (frag->ofs + frag->size < size)
10563f: 8b 48 18 mov 0x18(%eax),%ecx
105642: 8b 50 14 mov 0x14(%eax),%edx
105645: 01 ca add %ecx,%edx
105647: 39 fa cmp %edi,%edx
105649: 72 ae jb 1055f9 <jffs2_truncate_fragtree+0xc9> <== NEVER TAKEN
if (frag->node && (frag->ofs & (PAGE_SIZE - 1)) == 0) {
10564b: 8b 40 10 mov 0x10(%eax),%eax
10564e: 89 fa mov %edi,%edx
105650: 85 c0 test %eax,%eax
105652: 74 a5 je 1055f9 <jffs2_truncate_fragtree+0xc9> <== NEVER TAKEN
105654: 81 e1 ff 0f 00 00 and $0xfff,%ecx
10565a: 75 9d jne 1055f9 <jffs2_truncate_fragtree+0xc9>
frag->node->raw->flash_offset = ref_offset(frag->node->raw) | REF_PRISTINE;
10565c: 8b 08 mov (%eax),%ecx
10565e: 8b 41 04 mov 0x4(%ecx),%eax
105661: 83 e0 fc and $0xfffffffc,%eax
105664: 83 c8 02 or $0x2,%eax
105667: 89 41 04 mov %eax,0x4(%ecx)
}
10566a: 83 c4 1c add $0x1c,%esp
10566d: 89 d0 mov %edx,%eax
10566f: 5b pop %ebx
105670: 5e pop %esi
105671: 5f pop %edi
105672: 5d pop %ebp
105673: c3 ret
105674: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10567b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10567f: 90 nop
if (frag && frag->ofs != size) {
105680: 74 19 je 10569b <jffs2_truncate_fragtree+0x16b>
frag->size = size - frag->ofs;
105682: 89 f9 mov %edi,%ecx
105684: 89 c3 mov %eax,%ebx
105686: 29 d1 sub %edx,%ecx
105688: 89 48 14 mov %ecx,0x14(%eax)
10568b: e9 06 ff ff ff jmp 105596 <jffs2_truncate_fragtree+0x66>
105690: 89 7d 10 mov %edi,0x10(%ebp) <== NOT EXECUTED
105693: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
105696: e9 50 ff ff ff jmp 1055eb <jffs2_truncate_fragtree+0xbb> <== NOT EXECUTED
10569b: 89 7d 10 mov %edi,0x10(%ebp)
if (frag && frag->ofs != size) {
10569e: 89 c3 mov %eax,%ebx
1056a0: 8b 75 08 mov 0x8(%ebp),%esi
1056a3: 89 d0 mov %edx,%eax
1056a5: e9 41 ff ff ff jmp 1055eb <jffs2_truncate_fragtree+0xbb>
1056aa: 89 d8 mov %ebx,%eax <== NOT EXECUTED
1056ac: eb d4 jmp 105682 <jffs2_truncate_fragtree+0x152> <== NOT EXECUTED
1056ae: 90 nop
1056af: 90 nop
0010b530 <jffs2_unlink>:
/***********************************************************************/
int jffs2_unlink(struct _inode *dir_i, struct _inode *d_inode, const unsigned char *d_name, size_t d_namelen)
{
10b530: 55 push %ebp <== NOT EXECUTED
10b531: 89 e5 mov %esp,%ebp <== NOT EXECUTED
10b533: 83 ec 38 sub $0x38,%esp <== NOT EXECUTED
10b536: 89 5d f4 mov %ebx,-0xc(%ebp) <== NOT EXECUTED
10b539: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED
10b53c: 89 7d fc mov %edi,-0x4(%ebp) <== NOT EXECUTED
10b53f: 89 75 f8 mov %esi,-0x8(%ebp) <== NOT EXECUTED
10b542: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED
struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
10b545: 8b 7b 3c mov 0x3c(%ebx),%edi <== NOT EXECUTED
struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
10b548: 83 c3 44 add $0x44,%ebx <== NOT EXECUTED
struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(d_inode);
int ret;
ret = jffs2_do_unlink(c, dir_f, (const char *)d_name,
d_namelen, dead_f, get_seconds());
10b54b: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
10b552: e8 d9 f4 01 00 call 12aa30 <time> <== NOT EXECUTED
struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
10b557: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
ret = jffs2_do_unlink(c, dir_f, (const char *)d_name,
10b55b: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10b55e: 89 44 24 14 mov %eax,0x14(%esp) <== NOT EXECUTED
struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(d_inode);
10b562: 8d 46 44 lea 0x44(%esi),%eax <== NOT EXECUTED
10b565: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
ret = jffs2_do_unlink(c, dir_f, (const char *)d_name,
10b569: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
10b56c: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
10b570: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
10b573: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10b577: e8 d4 ee ff ff call 10a450 <jffs2_do_unlink> <== NOT EXECUTED
if (dead_f->inocache)
10b57c: 8b 56 58 mov 0x58(%esi),%edx <== NOT EXECUTED
10b57f: 85 d2 test %edx,%edx <== NOT EXECUTED
10b581: 74 07 je 10b58a <jffs2_unlink+0x5a> <== NOT EXECUTED
d_inode->i_nlink = dead_f->inocache->pino_nlink;
10b583: 8b 52 14 mov 0x14(%edx),%edx <== NOT EXECUTED
10b586: 66 89 56 0c mov %dx,0xc(%esi) <== NOT EXECUTED
return ret;
}
10b58a: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED
10b58d: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED
10b590: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED
10b593: 89 ec mov %ebp,%esp <== NOT EXECUTED
10b595: 5d pop %ebp <== NOT EXECUTED
10b596: c3 ret <== NOT EXECUTED
10b597: 90 nop
10b598: 90 nop
10b599: 90 nop
10b59a: 90 nop
10b59b: 90 nop
10b59c: 90 nop
10b59d: 90 nop
10b59e: 90 nop
10b59f: 90 nop
00109af0 <jffs2_write_dirent>:
struct jffs2_full_dirent *jffs2_write_dirent(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
struct jffs2_raw_dirent *rd, const unsigned char *name,
uint32_t namelen, int alloc_mode)
{
109af0: 55 push %ebp
109af1: 89 e5 mov %esp,%ebp
109af3: 57 push %edi
109af4: 56 push %esi
109af5: 53 push %ebx
109af6: 83 ec 6c sub $0x6c,%esp
D1(if(je32_to_cpu(rd->hdr_crc) != crc32(0, rd, sizeof(struct jffs2_unknown_node)-4)) {
pr_crit("Eep. CRC not correct in jffs2_write_dirent()\n");
BUG();
});
if (strnlen(name, namelen) != namelen) {
109af9: 8b 45 18 mov 0x18(%ebp),%eax
{
109afc: 8b 75 14 mov 0x14(%ebp),%esi
109aff: 8b 5d 10 mov 0x10(%ebp),%ebx
if (strnlen(name, namelen) != namelen) {
109b02: 89 44 24 04 mov %eax,0x4(%esp)
109b06: 89 34 24 mov %esi,(%esp)
109b09: e8 52 d6 01 00 call 127160 <strnlen>
109b0e: 3b 45 18 cmp 0x18(%ebp),%eax
109b11: 74 4d je 109b60 <jffs2_write_dirent+0x70> <== ALWAYS TAKEN
/* This should never happen, but seems to have done on at least one
occasion: https://dev.laptop.org/ticket/4184 */
pr_crit("Error in jffs2_write_dirent() -- name contains zero bytes!\n");
109b13: c7 04 24 24 fe 12 00 movl $0x12fe24,(%esp) <== NOT EXECUTED
109b1a: e8 a1 fa ff ff call 1095c0 <jffs2_printk> <== NOT EXECUTED
pr_crit("Directory inode #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x\n",
109b1f: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED
109b22: 89 44 24 14 mov %eax,0x14(%esp) <== NOT EXECUTED
109b26: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED
109b29: 89 74 24 0c mov %esi,0xc(%esp) <== NOT EXECUTED
109b2d: 89 74 24 08 mov %esi,0x8(%esp) <== NOT EXECUTED
109b31: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
109b35: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED
109b38: c7 04 24 6c fe 12 00 movl $0x12fe6c,(%esp) <== NOT EXECUTED
109b3f: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
109b43: e8 78 fa ff ff call 1095c0 <jffs2_printk> <== NOT EXECUTED
je32_to_cpu(rd->pino), name, name, je32_to_cpu(rd->ino),
je32_to_cpu(rd->name_crc));
WARN_ON(1);
return ERR_PTR(-EIO);
109b48: c7 45 c4 fb ff ff ff movl $0xfffffffb,-0x3c(%ebp) <== NOT EXECUTED
if (retried) {
jffs2_dbg_acct_sanity_check(c,NULL);
}
return fd;
}
109b4f: 8b 45 c4 mov -0x3c(%ebp),%eax
109b52: 83 c4 6c add $0x6c,%esp
109b55: 5b pop %ebx
109b56: 5e pop %esi
109b57: 5f pop %edi
109b58: 5d pop %ebp
109b59: c3 ret
109b5a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
vecs[0].iov_base = rd;
109b60: 89 5d d8 mov %ebx,-0x28(%ebp)
vecs[1].iov_len = namelen;
109b63: 8b 45 18 mov 0x18(%ebp),%eax
vecs[0].iov_len = sizeof(*rd);
109b66: c7 45 dc 28 00 00 00 movl $0x28,-0x24(%ebp)
vecs[1].iov_base = (unsigned char *)name;
109b6d: 89 75 e0 mov %esi,-0x20(%ebp)
vecs[1].iov_len = namelen;
109b70: 89 45 e4 mov %eax,-0x1c(%ebp)
fd = jffs2_alloc_full_dirent(namelen+1);
109b73: 40 inc %eax
109b74: 89 04 24 mov %eax,(%esp)
109b77: e8 a4 b5 ff ff call 105120 <jffs2_alloc_full_dirent>
109b7c: 89 45 c4 mov %eax,-0x3c(%ebp)
if (!fd)
109b7f: 85 c0 test %eax,%eax
fd = jffs2_alloc_full_dirent(namelen+1);
109b81: 89 c1 mov %eax,%ecx
if (!fd)
109b83: 0f 84 a7 02 00 00 je 109e30 <jffs2_write_dirent+0x340> <== NEVER TAKEN
fd->version = je32_to_cpu(rd->version);
109b89: 8b 43 10 mov 0x10(%ebx),%eax
while (len--) {
109b8c: 8b 7d 18 mov 0x18(%ebp),%edi
109b8f: 89 41 08 mov %eax,0x8(%ecx)
fd->ino = je32_to_cpu(rd->ino);
109b92: 8b 43 14 mov 0x14(%ebx),%eax
109b95: 85 ff test %edi,%edi
109b97: 89 41 0c mov %eax,0xc(%ecx)
109b9a: 0f 84 40 03 00 00 je 109ee0 <jffs2_write_dirent+0x3f0> <== NEVER TAKEN
109ba0: 8b 4d 18 mov 0x18(%ebp),%ecx
109ba3: 89 f2 mov %esi,%edx
uint32_t hash = 0;
109ba5: 31 c0 xor %eax,%eax
109ba7: 01 f1 add %esi,%ecx
109ba9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
hash ^= *(name++);
109bb0: 0f b6 3a movzbl (%edx),%edi
hash = (hash << 4) | (hash >> 28);
109bb3: c1 c0 04 rol $0x4,%eax
hash ^= *(name++);
109bb6: 42 inc %edx
109bb7: 31 f8 xor %edi,%eax
while (len--) {
109bb9: 39 ca cmp %ecx,%edx
109bbb: 75 f3 jne 109bb0 <jffs2_write_dirent+0xc0>
fd->nhash = full_name_hash(NULL, name, namelen);
109bbd: 8b 7d c4 mov -0x3c(%ebp),%edi
memcpy(fd->name, name, namelen);
109bc0: 8b 4d 18 mov 0x18(%ebp),%ecx
fd->nhash = full_name_hash(NULL, name, namelen);
109bc3: 89 47 10 mov %eax,0x10(%edi)
memcpy(fd->name, name, namelen);
109bc6: 83 c7 15 add $0x15,%edi
fd->type = rd->type;
109bc9: 0f b6 43 1d movzbl 0x1d(%ebx),%eax
109bcd: 88 47 ff mov %al,-0x1(%edi)
memcpy(fd->name, name, namelen);
109bd0: 83 f9 08 cmp $0x8,%ecx
109bd3: 0f 83 17 02 00 00 jae 109df0 <jffs2_write_dirent+0x300>
109bd9: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL);
109bdb: 89 5d 10 mov %ebx,0x10(%ebp)
fd->name[namelen]=0;
109bde: c7 45 bc 02 00 00 00 movl $0x2,-0x44(%ebp)
int retried = 0;
109be5: c7 45 b8 00 00 00 00 movl $0x0,-0x48(%ebp)
fd->name[namelen]=0;
109bec: 8b 45 c4 mov -0x3c(%ebp),%eax
109bef: 8b 75 18 mov 0x18(%ebp),%esi
jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL);
109bf2: 8b 5d 08 mov 0x8(%ebp),%ebx
fd->name[namelen]=0;
109bf5: c6 44 30 15 00 movb $0x0,0x15(%eax,%esi,1)
jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL);
109bfa: 89 f0 mov %esi,%eax
109bfc: 83 c0 2b add $0x2b,%eax
109bff: 83 e0 fc and $0xfffffffc,%eax
109c02: 89 45 b4 mov %eax,-0x4c(%ebp)
flash_ofs = write_ofs(c);
109c05: 8b 43 58 mov 0x58(%ebx),%eax
if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) {
109c08: 83 7d 1c 02 cmpl $0x2,0x1c(%ebp)
flash_ofs = write_ofs(c);
109c0c: 8b 53 34 mov 0x34(%ebx),%edx
109c0f: 8b 78 0c mov 0xc(%eax),%edi
109c12: 8b 70 20 mov 0x20(%eax),%esi
if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) {
109c15: 74 79 je 109c90 <jffs2_write_dirent+0x1a0>
109c17: 8b 45 0c mov 0xc(%ebp),%eax
109c1a: 8b 4d 10 mov 0x10(%ebp),%ecx
109c1d: 8b 00 mov (%eax),%eax
109c1f: 39 41 10 cmp %eax,0x10(%ecx)
109c22: 73 6c jae 109c90 <jffs2_write_dirent+0x1a0> <== ALWAYS TAKEN
BUG_ON(!retried);
109c24: 8b 4d b8 mov -0x48(%ebp),%ecx <== NOT EXECUTED
109c27: 85 c9 test %ecx,%ecx <== NOT EXECUTED
109c29: 75 27 jne 109c52 <jffs2_write_dirent+0x162> <== NOT EXECUTED
109c2b: c7 04 24 b0 fd 12 00 movl $0x12fdb0,(%esp) <== NOT EXECUTED
109c32: b8 3b d6 12 00 mov $0x12d63b,%eax <== NOT EXECUTED
109c37: ba 05 01 00 00 mov $0x105,%edx <== NOT EXECUTED
109c3c: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
109c40: b8 4c ff 12 00 mov $0x12ff4c,%eax <== NOT EXECUTED
109c45: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
109c49: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
109c4d: e8 1e 40 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED
109c52: 89 55 c0 mov %edx,-0x40(%ebp) <== NOT EXECUTED
rd->version = cpu_to_je32(++f->highest_version);
109c55: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED
109c58: 40 inc %eax <== NOT EXECUTED
109c59: 89 02 mov %eax,(%edx) <== NOT EXECUTED
109c5b: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
109c5e: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED
fd->version = je32_to_cpu(rd->version);
109c61: 8b 55 c4 mov -0x3c(%ebp),%edx <== NOT EXECUTED
109c64: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
109c67: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED
109c6a: c7 44 24 08 20 00 00 movl $0x20,0x8(%esp) <== NOT EXECUTED
109c71: 00
109c72: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
109c79: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
109c7d: e8 0e 12 00 00 call 10ae90 <cyg_crc32_accumulate> <== NOT EXECUTED
109c82: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED
109c85: 89 42 20 mov %eax,0x20(%edx) <== NOT EXECUTED
109c88: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED
109c8b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109c8f: 90 nop <== NOT EXECUTED
ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen,
109c90: 89 1c 24 mov %ebx,(%esp)
109c93: 8d 45 d0 lea -0x30(%ebp),%eax
flash_ofs = write_ofs(c);
109c96: 01 d7 add %edx,%edi
ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen,
109c98: 89 44 24 14 mov %eax,0x14(%esp)
109c9c: 31 c0 xor %eax,%eax
flash_ofs = write_ofs(c);
109c9e: 29 f7 sub %esi,%edi
ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen,
109ca0: 89 44 24 10 mov %eax,0x10(%esp)
109ca4: b8 02 00 00 00 mov $0x2,%eax
109ca9: 89 44 24 08 mov %eax,0x8(%esp)
109cad: 8d 45 d8 lea -0x28(%ebp),%eax
109cb0: 89 7c 24 0c mov %edi,0xc(%esp)
109cb4: 89 44 24 04 mov %eax,0x4(%esp)
109cb8: e8 03 26 00 00 call 10c2c0 <jffs2_flash_direct_writev>
109cbd: 89 c6 mov %eax,%esi
if (ret || (retlen != sizeof(*rd) + namelen)) {
109cbf: 8b 45 18 mov 0x18(%ebp),%eax
109cc2: 83 c0 28 add $0x28,%eax
109cc5: 85 f6 test %esi,%esi
109cc7: 89 45 c0 mov %eax,-0x40(%ebp)
109cca: 8b 45 d0 mov -0x30(%ebp),%eax
109ccd: 75 09 jne 109cd8 <jffs2_write_dirent+0x1e8> <== NEVER TAKEN
109ccf: 3b 45 c0 cmp -0x40(%ebp),%eax
109cd2: 0f 84 64 01 00 00 je 109e3c <jffs2_write_dirent+0x34c> <== ALWAYS TAKEN
pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
109cd8: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
109cdc: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED
109cdf: 89 74 24 0c mov %esi,0xc(%esp) <== NOT EXECUTED
109ce3: 89 7c 24 08 mov %edi,0x8(%esp) <== NOT EXECUTED
109ce7: c7 04 24 dc fd 12 00 movl $0x12fddc,(%esp) <== NOT EXECUTED
109cee: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
109cf2: e8 c9 f8 ff ff call 1095c0 <jffs2_printk> <== NOT EXECUTED
if (retlen) {
109cf7: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED
109cfa: 85 c0 test %eax,%eax <== NOT EXECUTED
109cfc: 0f 85 9e 00 00 00 jne 109da0 <jffs2_write_dirent+0x2b0> <== NOT EXECUTED
pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n",
109d02: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
109d06: c7 04 24 10 e2 12 00 movl $0x12e210,(%esp) <== NOT EXECUTED
109d0d: e8 ae f8 ff ff call 1095c0 <jffs2_printk> <== NOT EXECUTED
if (!retried) {
109d12: 83 7d bc 01 cmpl $0x1,-0x44(%ebp) <== NOT EXECUTED
109d16: 0f 84 ac 00 00 00 je 109dc8 <jffs2_write_dirent+0x2d8> <== NOT EXECUTED
struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
109d1c: 89 f8 mov %edi,%eax <== NOT EXECUTED
109d1e: 31 d2 xor %edx,%edx <== NOT EXECUTED
109d20: f7 73 34 divl 0x34(%ebx) <== NOT EXECUTED
109d23: 8d 14 40 lea (%eax,%eax,2),%edx <== NOT EXECUTED
109d26: 8d 14 90 lea (%eax,%edx,4),%edx <== NOT EXECUTED
109d29: 8b 43 54 mov 0x54(%ebx),%eax <== NOT EXECUTED
jffs2_dbg_acct_sanity_check(c,jeb);
109d2c: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
109d2f: 8d 3c 90 lea (%eax,%edx,4),%edi <== NOT EXECUTED
jffs2_dbg_acct_sanity_check(c,jeb);
109d32: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
109d36: e8 95 15 00 00 call 10b2d0 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
JFFS2_SUMMARY_DIRENT_SIZE(namelen));
109d3b: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
if (alloc_mode == ALLOC_GC) {
109d3e: 83 7d 1c 02 cmpl $0x2,0x1c(%ebp) <== NOT EXECUTED
JFFS2_SUMMARY_DIRENT_SIZE(namelen));
109d42: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED
if (alloc_mode == ALLOC_GC) {
109d45: 0f 84 65 01 00 00 je 109eb0 <jffs2_write_dirent+0x3c0> <== NOT EXECUTED
jffs2_complete_reservation(c);
109d4b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
109d4e: e8 3d c6 ff ff call 106390 <jffs2_complete_reservation> <== NOT EXECUTED
ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &dummy,
109d53: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED
109d56: 89 74 24 10 mov %esi,0x10(%esp) <== NOT EXECUTED
109d5a: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
109d5d: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
109d61: 8d 45 d4 lea -0x2c(%ebp),%eax <== NOT EXECUTED
109d64: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
109d68: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED
109d6b: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
109d6f: e8 7c ce ff ff call 106bf0 <jffs2_reserve_space> <== NOT EXECUTED
109d74: 89 c6 mov %eax,%esi <== NOT EXECUTED
if (!ret) {
109d76: 85 f6 test %esi,%esi <== NOT EXECUTED
109d78: 0f 84 72 01 00 00 je 109ef0 <jffs2_write_dirent+0x400> <== NOT EXECUTED
jffs2_free_full_dirent(fd);
109d7e: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED
109d81: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
109d84: e8 a7 b3 ff ff call 105130 <jffs2_free_full_dirent> <== NOT EXECUTED
return ERR_PTR(ret?ret:-EIO);
109d89: 89 75 c4 mov %esi,-0x3c(%ebp) <== NOT EXECUTED
}
109d8c: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED
109d8f: 83 c4 6c add $0x6c,%esp <== NOT EXECUTED
109d92: 5b pop %ebx <== NOT EXECUTED
109d93: 5e pop %esi <== NOT EXECUTED
109d94: 5f pop %edi <== NOT EXECUTED
109d95: 5d pop %ebp <== NOT EXECUTED
109d96: c3 ret <== NOT EXECUTED
109d97: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109d9e: 66 90 xchg %ax,%ax <== NOT EXECUTED
jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL);
109da0: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
109da3: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED
109da6: 31 c9 xor %ecx,%ecx <== NOT EXECUTED
109da8: 89 4c 24 0c mov %ecx,0xc(%esp) <== NOT EXECUTED
109dac: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
109db0: 89 f8 mov %edi,%eax <== NOT EXECUTED
109db2: 83 c8 01 or $0x1,%eax <== NOT EXECUTED
109db5: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
109db9: e8 82 c4 ff ff call 106240 <jffs2_add_physical_node_ref> <== NOT EXECUTED
if (!retried) {
109dbe: 83 7d bc 01 cmpl $0x1,-0x44(%ebp) <== NOT EXECUTED
109dc2: 0f 85 54 ff ff ff jne 109d1c <jffs2_write_dirent+0x22c> <== NOT EXECUTED
jffs2_free_full_dirent(fd);
109dc8: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED
109dcb: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
109dce: e8 5d b3 ff ff call 105130 <jffs2_free_full_dirent> <== NOT EXECUTED
return ERR_PTR(ret?ret:-EIO);
109dd3: 85 f6 test %esi,%esi <== NOT EXECUTED
109dd5: c7 45 c4 fb ff ff ff movl $0xfffffffb,-0x3c(%ebp) <== NOT EXECUTED
109ddc: 75 ab jne 109d89 <jffs2_write_dirent+0x299> <== NOT EXECUTED
}
109dde: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED
109de1: 83 c4 6c add $0x6c,%esp <== NOT EXECUTED
109de4: 5b pop %ebx <== NOT EXECUTED
109de5: 5e pop %esi <== NOT EXECUTED
109de6: 5f pop %edi <== NOT EXECUTED
109de7: 5d pop %ebp <== NOT EXECUTED
109de8: c3 ret <== NOT EXECUTED
109de9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
memcpy(fd->name, name, namelen);
109df0: f7 c7 01 00 00 00 test $0x1,%edi
109df6: 0f 85 28 01 00 00 jne 109f24 <jffs2_write_dirent+0x434> <== ALWAYS TAKEN
109dfc: f7 c7 02 00 00 00 test $0x2,%edi
109e02: 0f 85 07 01 00 00 jne 109f0f <jffs2_write_dirent+0x41f> <== ALWAYS TAKEN
109e08: f7 c7 04 00 00 00 test $0x4,%edi
109e0e: 0f 84 c5 fd ff ff je 109bd9 <jffs2_write_dirent+0xe9>
109e14: 8b 06 mov (%esi),%eax
109e16: 83 c7 04 add $0x4,%edi
109e19: 83 c6 04 add $0x4,%esi
109e1c: 83 e9 04 sub $0x4,%ecx
109e1f: 89 47 fc mov %eax,-0x4(%edi)
109e22: e9 b2 fd ff ff jmp 109bd9 <jffs2_write_dirent+0xe9>
109e27: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
109e2e: 66 90 xchg %ax,%ax
return ERR_PTR(-ENOMEM);
109e30: c7 45 c4 f4 ff ff ff movl $0xfffffff4,-0x3c(%ebp) <== NOT EXECUTED
109e37: e9 13 fd ff ff jmp 109b4f <jffs2_write_dirent+0x5f> <== NOT EXECUTED
fd->raw = jffs2_add_physical_node_ref(c, flash_ofs | dirent_node_state(rd),
109e3c: 8b 45 0c mov 0xc(%ebp),%eax
109e3f: b9 03 00 00 00 mov $0x3,%ecx
109e44: 8b 5d 10 mov 0x10(%ebp),%ebx
109e47: 8b 50 14 mov 0x14(%eax),%edx
PAD(sizeof(*rd)+namelen), f->inocache);
109e4a: 8b 45 18 mov 0x18(%ebp),%eax
109e4d: 83 c0 2b add $0x2b,%eax
fd->raw = jffs2_add_physical_node_ref(c, flash_ofs | dirent_node_state(rd),
109e50: 83 e0 fc and $0xfffffffc,%eax
109e53: 83 7b 14 01 cmpl $0x1,0x14(%ebx)
109e57: 89 44 24 08 mov %eax,0x8(%esp)
109e5b: 8b 45 08 mov 0x8(%ebp),%eax
109e5e: 89 54 24 0c mov %edx,0xc(%esp)
109e62: 83 d1 ff adc $0xffffffff,%ecx
109e65: 09 cf or %ecx,%edi
109e67: 89 7c 24 04 mov %edi,0x4(%esp)
109e6b: 89 04 24 mov %eax,(%esp)
109e6e: e8 cd c3 ff ff call 106240 <jffs2_add_physical_node_ref>
109e73: 89 c3 mov %eax,%ebx
109e75: 8b 45 c4 mov -0x3c(%ebp),%eax
if (IS_ERR(fd->raw)) {
109e78: 81 fb 18 fc ff ff cmp $0xfffffc18,%ebx
fd->raw = jffs2_add_physical_node_ref(c, flash_ofs | dirent_node_state(rd),
109e7e: 89 18 mov %ebx,(%eax)
if (IS_ERR(fd->raw)) {
109e80: 0f 87 b5 00 00 00 ja 109f3b <jffs2_write_dirent+0x44b> <== NEVER TAKEN
if (retried) {
109e86: 8b 55 b8 mov -0x48(%ebp),%edx
109e89: 85 d2 test %edx,%edx
109e8b: 0f 84 be fc ff ff je 109b4f <jffs2_write_dirent+0x5f> <== ALWAYS TAKEN
jffs2_dbg_acct_sanity_check(c,NULL);
109e91: 31 c0 xor %eax,%eax
109e93: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
109e97: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED
109e9a: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
109e9d: e8 2e 14 00 00 call 10b2d0 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
109ea2: e9 a8 fc ff ff jmp 109b4f <jffs2_write_dirent+0x5f> <== NOT EXECUTED
109ea7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109eae: 66 90 xchg %ax,%ax <== NOT EXECUTED
ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &dummy,
109eb0: 89 74 24 0c mov %esi,0xc(%esp) <== NOT EXECUTED
109eb4: 8d 45 d4 lea -0x2c(%ebp),%eax <== NOT EXECUTED
109eb7: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
109ebb: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED
109ebe: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
109ec1: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
109ec5: e8 c6 cc ff ff call 106b90 <jffs2_reserve_space_gc> <== NOT EXECUTED
109eca: 89 c6 mov %eax,%esi <== NOT EXECUTED
109ecc: e9 a5 fe ff ff jmp 109d76 <jffs2_write_dirent+0x286> <== NOT EXECUTED
109ed1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109ed8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109edf: 90 nop <== NOT EXECUTED
uint32_t hash = 0;
109ee0: 31 c0 xor %eax,%eax <== NOT EXECUTED
109ee2: e9 d6 fc ff ff jmp 109bbd <jffs2_write_dirent+0xcd> <== NOT EXECUTED
109ee7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109eee: 66 90 xchg %ax,%ax <== NOT EXECUTED
jffs2_dbg_acct_sanity_check(c,jeb);
109ef0: 89 7c 24 04 mov %edi,0x4(%esp) <== NOT EXECUTED
109ef4: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED
109ef7: e8 d4 13 00 00 call 10b2d0 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
goto retry;
109efc: c7 45 bc 01 00 00 00 movl $0x1,-0x44(%ebp) <== NOT EXECUTED
retried = 1;
109f03: c7 45 b8 01 00 00 00 movl $0x1,-0x48(%ebp) <== NOT EXECUTED
109f0a: e9 f6 fc ff ff jmp 109c05 <jffs2_write_dirent+0x115> <== NOT EXECUTED
memcpy(fd->name, name, namelen);
109f0f: 0f b7 06 movzwl (%esi),%eax
109f12: 83 c7 02 add $0x2,%edi
109f15: 83 c6 02 add $0x2,%esi
109f18: 83 e9 02 sub $0x2,%ecx
109f1b: 66 89 47 fe mov %ax,-0x2(%edi)
109f1f: e9 e4 fe ff ff jmp 109e08 <jffs2_write_dirent+0x318>
109f24: 0f b6 06 movzbl (%esi),%eax
109f27: 46 inc %esi
109f28: 88 07 mov %al,(%edi)
109f2a: 8b 45 c4 mov -0x3c(%ebp),%eax
109f2d: 8d 78 16 lea 0x16(%eax),%edi
109f30: 8b 45 18 mov 0x18(%ebp),%eax
109f33: 8d 48 ff lea -0x1(%eax),%ecx
109f36: e9 c1 fe ff ff jmp 109dfc <jffs2_write_dirent+0x30c>
jffs2_free_full_dirent(fd);
109f3b: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
109f3e: e8 ed b1 ff ff call 105130 <jffs2_free_full_dirent> <== NOT EXECUTED
return ERR_CAST(hold_err);
109f43: 89 5d c4 mov %ebx,-0x3c(%ebp) <== NOT EXECUTED
109f46: e9 04 fc ff ff jmp 109b4f <jffs2_write_dirent+0x5f> <== NOT EXECUTED
109f4b: 90 nop
109f4c: 90 nop
109f4d: 90 nop
109f4e: 90 nop
109f4f: 90 nop
00109750 <jffs2_write_dnode>:
struct jffs2_full_dnode *jffs2_write_dnode(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
struct jffs2_raw_inode *ri, const unsigned char *data,
uint32_t datalen, int alloc_mode)
{
109750: 55 push %ebp
109751: 89 e5 mov %esp,%ebp
109753: 57 push %edi
109754: 56 push %esi
109755: 53 push %ebx
109756: 83 ec 6c sub $0x6c,%esp
D1(if(je32_to_cpu(ri->hdr_crc) != crc32(0, ri, sizeof(struct jffs2_unknown_node)-4)) {
pr_crit("Eep. CRC not correct in jffs2_write_dnode()\n");
BUG();
}
);
vecs[0].iov_base = ri;
109759: 8b 45 10 mov 0x10(%ebp),%eax
vecs[0].iov_len = sizeof(*ri);
vecs[1].iov_base = (unsigned char *)data;
vecs[1].iov_len = datalen;
if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) {
10975c: 8b 55 18 mov 0x18(%ebp),%edx
vecs[0].iov_len = sizeof(*ri);
10975f: c7 45 dc 44 00 00 00 movl $0x44,-0x24(%ebp)
{
109766: 8b 5d 14 mov 0x14(%ebp),%ebx
109769: 8b 75 08 mov 0x8(%ebp),%esi
vecs[0].iov_base = ri;
10976c: 89 45 d8 mov %eax,-0x28(%ebp)
vecs[1].iov_len = datalen;
10976f: 8b 45 18 mov 0x18(%ebp),%eax
if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) {
109772: 8d 4a 44 lea 0x44(%edx),%ecx
vecs[1].iov_base = (unsigned char *)data;
109775: 89 5d e0 mov %ebx,-0x20(%ebp)
if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) {
109778: 89 4d c4 mov %ecx,-0x3c(%ebp)
vecs[1].iov_len = datalen;
10977b: 89 45 e4 mov %eax,-0x1c(%ebp)
if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) {
10977e: 8b 45 10 mov 0x10(%ebp),%eax
109781: 8b 40 04 mov 0x4(%eax),%eax
109784: 39 c8 cmp %ecx,%eax
109786: 74 26 je 1097ae <jffs2_write_dnode+0x5e> <== ALWAYS TAKEN
pr_warn("%s(): ri->totlen (0x%08x) != sizeof(*ri) (0x%08zx) + datalen (0x%08x)\n",
109788: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
10978c: bf 44 00 00 00 mov $0x44,%edi <== NOT EXECUTED
109791: b8 60 ff 12 00 mov $0x12ff60,%eax <== NOT EXECUTED
109796: 89 54 24 10 mov %edx,0x10(%esp) <== NOT EXECUTED
10979a: 89 7c 24 0c mov %edi,0xc(%esp) <== NOT EXECUTED
10979e: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1097a2: c7 04 24 5c fd 12 00 movl $0x12fd5c,(%esp) <== NOT EXECUTED
1097a9: e8 12 fe ff ff call 1095c0 <jffs2_printk> <== NOT EXECUTED
__func__, je32_to_cpu(ri->totlen),
sizeof(*ri), datalen);
}
fn = jffs2_alloc_full_dnode();
1097ae: e8 8d b9 ff ff call 105140 <jffs2_alloc_full_dnode>
1097b3: 89 45 b8 mov %eax,-0x48(%ebp)
if (!fn)
1097b6: 85 c0 test %eax,%eax
1097b8: 0f 84 32 02 00 00 je 1099f0 <jffs2_write_dnode+0x2a0> <== NEVER TAKEN
return ERR_PTR(-ENOMEM);
/* check number of valid vecs */
if (!datalen || !data)
1097be: 8b 4d 18 mov 0x18(%ebp),%ecx
1097c1: 85 c9 test %ecx,%ecx
1097c3: 0f 84 e7 01 00 00 je 1099b0 <jffs2_write_dnode+0x260>
unsigned long cnt = 2;
1097c9: c7 45 bc 02 00 00 00 movl $0x2,-0x44(%ebp)
if (!datalen || !data)
1097d0: 85 db test %ebx,%ebx
1097d2: 0f 84 d8 01 00 00 je 1099b0 <jffs2_write_dnode+0x260> <== NEVER TAKEN
cnt = 1;
retry:
1097d8: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp)
/* Don't change raw->size to match retlen. We may have
written the node header already, and only the data will
seem corrupted, in which case the scan would skip over
any node we write before the original intended end of
this node */
jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*ri)+datalen), NULL);
1097df: 8b 45 18 mov 0x18(%ebp),%eax
1097e2: 83 c0 47 add $0x47,%eax
1097e5: 83 e0 fc and $0xfffffffc,%eax
1097e8: 89 45 b4 mov %eax,-0x4c(%ebp)
flash_ofs = write_ofs(c);
1097eb: 8b 46 58 mov 0x58(%esi),%eax
if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) {
1097ee: 83 7d 1c 02 cmpl $0x2,0x1c(%ebp)
flash_ofs = write_ofs(c);
1097f2: 8b 4e 34 mov 0x34(%esi),%ecx
1097f5: 8b 58 0c mov 0xc(%eax),%ebx
1097f8: 8b 78 20 mov 0x20(%eax),%edi
if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) {
1097fb: 74 73 je 109870 <jffs2_write_dnode+0x120>
1097fd: 8b 45 0c mov 0xc(%ebp),%eax
109800: 8b 55 10 mov 0x10(%ebp),%edx
109803: 8b 00 mov (%eax),%eax
109805: 39 42 10 cmp %eax,0x10(%edx)
109808: 73 66 jae 109870 <jffs2_write_dnode+0x120> <== ALWAYS TAKEN
BUG_ON(!retried);
10980a: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED
10980d: 85 d2 test %edx,%edx <== NOT EXECUTED
10980f: 75 27 jne 109838 <jffs2_write_dnode+0xe8> <== NOT EXECUTED
109811: b8 3b d6 12 00 mov $0x12d63b,%eax <== NOT EXECUTED
109816: ba 60 ff 12 00 mov $0x12ff60,%edx <== NOT EXECUTED
10981b: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
10981f: b9 67 00 00 00 mov $0x67,%ecx <== NOT EXECUTED
109824: 89 54 24 08 mov %edx,0x8(%esp) <== NOT EXECUTED
109828: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
10982c: c7 04 24 b0 fd 12 00 movl $0x12fdb0,(%esp) <== NOT EXECUTED
109833: e8 38 44 00 00 call 10dc70 <__assert_func> <== NOT EXECUTED
109838: 89 4d b0 mov %ecx,-0x50(%ebp) <== NOT EXECUTED
ri->version = cpu_to_je32(++f->highest_version);
10983b: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED
10983e: 40 inc %eax <== NOT EXECUTED
10983f: 89 01 mov %eax,(%ecx) <== NOT EXECUTED
109841: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED
109844: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
109847: 89 4c 24 04 mov %ecx,0x4(%esp) <== NOT EXECUTED
10984b: c7 44 24 08 3c 00 00 movl $0x3c,0x8(%esp) <== NOT EXECUTED
109852: 00
109853: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED
10985a: e8 31 16 00 00 call 10ae90 <cyg_crc32_accumulate> <== NOT EXECUTED
10985f: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED
109862: 89 41 40 mov %eax,0x40(%ecx) <== NOT EXECUTED
109865: 8b 4d b0 mov -0x50(%ebp),%ecx <== NOT EXECUTED
109868: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10986f: 90 nop <== NOT EXECUTED
ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen,
109870: 89 34 24 mov %esi,(%esp)
109873: 8d 45 d0 lea -0x30(%ebp),%eax
flash_ofs = write_ofs(c);
109876: 01 cb add %ecx,%ebx
ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen,
109878: 89 44 24 14 mov %eax,0x14(%esp)
10987c: 31 c0 xor %eax,%eax
flash_ofs = write_ofs(c);
10987e: 29 fb sub %edi,%ebx
ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen,
109880: 89 44 24 10 mov %eax,0x10(%esp)
109884: 8b 45 bc mov -0x44(%ebp),%eax
109887: 89 5c 24 0c mov %ebx,0xc(%esp)
10988b: 89 44 24 08 mov %eax,0x8(%esp)
10988f: 8d 45 d8 lea -0x28(%ebp),%eax
109892: 89 44 24 04 mov %eax,0x4(%esp)
109896: e8 25 2a 00 00 call 10c2c0 <jffs2_flash_direct_writev>
10989b: 89 c7 mov %eax,%edi
if (ret || (retlen != sizeof(*ri) + datalen)) {
10989d: 8b 45 d0 mov -0x30(%ebp),%eax
1098a0: 85 ff test %edi,%edi
1098a2: 75 09 jne 1098ad <jffs2_write_dnode+0x15d> <== NEVER TAKEN
1098a4: 39 45 c4 cmp %eax,-0x3c(%ebp)
1098a7: 0f 84 93 01 00 00 je 109a40 <jffs2_write_dnode+0x2f0> <== ALWAYS TAKEN
pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
1098ad: 89 44 24 10 mov %eax,0x10(%esp) <== NOT EXECUTED
1098b1: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED
1098b4: 89 7c 24 0c mov %edi,0xc(%esp) <== NOT EXECUTED
1098b8: 89 5c 24 08 mov %ebx,0x8(%esp) <== NOT EXECUTED
1098bc: c7 04 24 dc fd 12 00 movl $0x12fddc,(%esp) <== NOT EXECUTED
1098c3: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1098c7: e8 f4 fc ff ff call 1095c0 <jffs2_printk> <== NOT EXECUTED
if (retlen) {
1098cc: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED
1098cf: 85 c0 test %eax,%eax <== NOT EXECUTED
1098d1: 0f 84 b9 00 00 00 je 109990 <jffs2_write_dnode+0x240> <== NOT EXECUTED
jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*ri)+datalen), NULL);
1098d7: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
1098da: 31 c0 xor %eax,%eax <== NOT EXECUTED
1098dc: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
1098e0: 8b 45 b4 mov -0x4c(%ebp),%eax <== NOT EXECUTED
1098e3: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1098e7: 89 d8 mov %ebx,%eax <== NOT EXECUTED
1098e9: 83 c8 01 or $0x1,%eax <== NOT EXECUTED
1098ec: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1098f0: e8 4b c9 ff ff call 106240 <jffs2_add_physical_node_ref> <== NOT EXECUTED
} else {
pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n",
flash_ofs);
}
if (!retried && alloc_mode != ALLOC_NORETRY) {
1098f5: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED
1098f8: 85 c0 test %eax,%eax <== NOT EXECUTED
1098fa: 0f 85 10 01 00 00 jne 109a10 <jffs2_write_dnode+0x2c0> <== NOT EXECUTED
109900: 83 7d 1c 03 cmpl $0x3,0x1c(%ebp) <== NOT EXECUTED
109904: 0f 84 06 01 00 00 je 109a10 <jffs2_write_dnode+0x2c0> <== NOT EXECUTED
/* Try to reallocate space and retry */
uint32_t dummy;
struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
10990a: 89 d8 mov %ebx,%eax <== NOT EXECUTED
10990c: 31 d2 xor %edx,%edx <== NOT EXECUTED
10990e: f7 76 34 divl 0x34(%esi) <== NOT EXECUTED
109911: 8d 14 40 lea (%eax,%eax,2),%edx <== NOT EXECUTED
109914: 8d 14 90 lea (%eax,%edx,4),%edx <== NOT EXECUTED
109917: 8b 46 54 mov 0x54(%esi),%eax <== NOT EXECUTED
retried = 1;
jffs2_dbg(1, "Retrying failed write.\n");
jffs2_dbg_acct_sanity_check(c,jeb);
10991a: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
10991d: 8d 1c 90 lea (%eax,%edx,4),%ebx <== NOT EXECUTED
jffs2_dbg_acct_sanity_check(c,jeb);
109920: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
109924: e8 a7 19 00 00 call 10b2d0 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
jffs2_dbg_acct_paranoia_check(c, jeb);
if (alloc_mode == ALLOC_GC) {
109929: 83 7d 1c 02 cmpl $0x2,0x1c(%ebp) <== NOT EXECUTED
10992d: 0f 84 8d 00 00 00 je 1099c0 <jffs2_write_dnode+0x270> <== NOT EXECUTED
ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &dummy,
JFFS2_SUMMARY_INODE_SIZE);
} else {
/* Locking pain */
mutex_unlock(&f->sem);
jffs2_complete_reservation(c);
109933: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
109936: e8 55 ca ff ff call 106390 <jffs2_complete_reservation> <== NOT EXECUTED
ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &dummy,
10993b: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED
10993e: b9 12 00 00 00 mov $0x12,%ecx <== NOT EXECUTED
109943: 89 4c 24 10 mov %ecx,0x10(%esp) <== NOT EXECUTED
109947: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
10994a: 89 44 24 0c mov %eax,0xc(%esp) <== NOT EXECUTED
10994e: 8d 45 d4 lea -0x2c(%ebp),%eax <== NOT EXECUTED
109951: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
109955: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED
109958: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10995c: e8 8f d2 ff ff call 106bf0 <jffs2_reserve_space> <== NOT EXECUTED
109961: 89 c7 mov %eax,%edi <== NOT EXECUTED
alloc_mode, JFFS2_SUMMARY_INODE_SIZE);
mutex_lock(&f->sem);
}
if (!ret) {
109963: 85 ff test %edi,%edi <== NOT EXECUTED
109965: 0f 85 c5 00 00 00 jne 109a30 <jffs2_write_dnode+0x2e0> <== NOT EXECUTED
flash_ofs = write_ofs(c);
jffs2_dbg(1, "Allocated space at 0x%08x to retry failed write.\n",
flash_ofs);
jffs2_dbg_acct_sanity_check(c,jeb);
10996b: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
10996f: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
109972: e8 59 19 00 00 call 10b2d0 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
retried = 1;
109977: c7 45 c0 01 00 00 00 movl $0x1,-0x40(%ebp) <== NOT EXECUTED
10997e: e9 68 fe ff ff jmp 1097eb <jffs2_write_dnode+0x9b> <== NOT EXECUTED
109983: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10998a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n",
109990: 89 5c 24 04 mov %ebx,0x4(%esp) <== NOT EXECUTED
109994: c7 04 24 10 e2 12 00 movl $0x12e210,(%esp) <== NOT EXECUTED
10999b: e8 20 fc ff ff call 1095c0 <jffs2_printk> <== NOT EXECUTED
1099a0: e9 50 ff ff ff jmp 1098f5 <jffs2_write_dnode+0x1a5> <== NOT EXECUTED
1099a5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1099ac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
cnt = 1;
1099b0: c7 45 bc 01 00 00 00 movl $0x1,-0x44(%ebp)
1099b7: e9 1c fe ff ff jmp 1097d8 <jffs2_write_dnode+0x88>
1099bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &dummy,
1099c0: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
1099c3: 8d 45 d4 lea -0x2c(%ebp),%eax <== NOT EXECUTED
1099c6: bf 12 00 00 00 mov $0x12,%edi <== NOT EXECUTED
1099cb: 89 44 24 08 mov %eax,0x8(%esp) <== NOT EXECUTED
1099cf: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED
1099d2: 89 7c 24 0c mov %edi,0xc(%esp) <== NOT EXECUTED
1099d6: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
1099da: e8 b1 d1 ff ff call 106b90 <jffs2_reserve_space_gc> <== NOT EXECUTED
1099df: 89 c7 mov %eax,%edi <== NOT EXECUTED
1099e1: eb 80 jmp 109963 <jffs2_write_dnode+0x213> <== NOT EXECUTED
1099e3: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1099ea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi <== NOT EXECUTED
return ERR_PTR(-ENOMEM);
1099f0: c7 45 b8 f4 ff ff ff movl $0xfffffff4,-0x48(%ebp) <== NOT EXECUTED
if (retried) {
jffs2_dbg_acct_sanity_check(c,NULL);
}
return fn;
}
1099f7: 8b 45 b8 mov -0x48(%ebp),%eax
1099fa: 83 c4 6c add $0x6c,%esp
1099fd: 5b pop %ebx
1099fe: 5e pop %esi
1099ff: 5f pop %edi
109a00: 5d pop %ebp
109a01: c3 ret
109a02: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
109a09: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
jffs2_free_full_dnode(fn);
109a10: 8b 45 b8 mov -0x48(%ebp),%eax <== NOT EXECUTED
109a13: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
109a16: e8 45 b7 ff ff call 105160 <jffs2_free_full_dnode> <== NOT EXECUTED
return ERR_PTR(ret?ret:-EIO);
109a1b: 85 ff test %edi,%edi <== NOT EXECUTED
109a1d: 75 1c jne 109a3b <jffs2_write_dnode+0x2eb> <== NOT EXECUTED
109a1f: c7 45 b8 fb ff ff ff movl $0xfffffffb,-0x48(%ebp) <== NOT EXECUTED
109a26: eb cf jmp 1099f7 <jffs2_write_dnode+0x2a7> <== NOT EXECUTED
109a28: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
109a2f: 90 nop <== NOT EXECUTED
jffs2_free_full_dnode(fn);
109a30: 8b 45 b8 mov -0x48(%ebp),%eax <== NOT EXECUTED
109a33: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
109a36: e8 25 b7 ff ff call 105160 <jffs2_free_full_dnode> <== NOT EXECUTED
return ERR_PTR(ret?ret:-EIO);
109a3b: 89 7d b8 mov %edi,-0x48(%ebp) <== NOT EXECUTED
109a3e: eb b7 jmp 1099f7 <jffs2_write_dnode+0x2a7> <== NOT EXECUTED
if ((je32_to_cpu(ri->dsize) >= PAGE_SIZE) ||
109a40: 8b 45 10 mov 0x10(%ebp),%eax
109a43: 8b 40 34 mov 0x34(%eax),%eax
109a46: 3d ff 0f 00 00 cmp $0xfff,%eax
109a4b: 0f 87 81 00 00 00 ja 109ad2 <jffs2_write_dnode+0x382>
( ((je32_to_cpu(ri->offset)&(PAGE_SIZE-1))==0) &&
109a51: 8b 7d 10 mov 0x10(%ebp),%edi
109a54: 8b 57 2c mov 0x2c(%edi),%edx
if ((je32_to_cpu(ri->dsize) >= PAGE_SIZE) ||
109a57: f7 c2 ff 0f 00 00 test $0xfff,%edx
109a5d: 75 07 jne 109a66 <jffs2_write_dnode+0x316>
(je32_to_cpu(ri->dsize)+je32_to_cpu(ri->offset) == je32_to_cpu(ri->isize)))) {
109a5f: 01 d0 add %edx,%eax
( ((je32_to_cpu(ri->offset)&(PAGE_SIZE-1))==0) &&
109a61: 3b 47 1c cmp 0x1c(%edi),%eax
109a64: 74 6c je 109ad2 <jffs2_write_dnode+0x382>
flash_ofs |= REF_NORMAL;
109a66: 83 cb 03 or $0x3,%ebx
fn->raw = jffs2_add_physical_node_ref(c, flash_ofs, PAD(sizeof(*ri)+datalen), f->inocache);
109a69: 8b 45 0c mov 0xc(%ebp),%eax
109a6c: 8b 40 14 mov 0x14(%eax),%eax
109a6f: 89 5c 24 04 mov %ebx,0x4(%esp)
109a73: 89 34 24 mov %esi,(%esp)
109a76: 89 44 24 0c mov %eax,0xc(%esp)
109a7a: 8b 45 18 mov 0x18(%ebp),%eax
109a7d: 83 c0 47 add $0x47,%eax
109a80: 83 e0 fc and $0xfffffffc,%eax
109a83: 89 44 24 08 mov %eax,0x8(%esp)
109a87: e8 b4 c7 ff ff call 106240 <jffs2_add_physical_node_ref>
109a8c: 8b 7d b8 mov -0x48(%ebp),%edi
109a8f: 89 07 mov %eax,(%edi)
if (IS_ERR(fn->raw)) {
109a91: 3d 18 fc ff ff cmp $0xfffffc18,%eax
109a96: 77 3f ja 109ad7 <jffs2_write_dnode+0x387> <== NEVER TAKEN
fn->ofs = je32_to_cpu(ri->offset);
109a98: 8b 45 10 mov 0x10(%ebp),%eax
109a9b: 8b 7d b8 mov -0x48(%ebp),%edi
if (retried) {
109a9e: 8b 55 c0 mov -0x40(%ebp),%edx
fn->ofs = je32_to_cpu(ri->offset);
109aa1: 8b 40 2c mov 0x2c(%eax),%eax
if (retried) {
109aa4: 85 d2 test %edx,%edx
fn->ofs = je32_to_cpu(ri->offset);
109aa6: 89 47 04 mov %eax,0x4(%edi)
fn->size = je32_to_cpu(ri->dsize);
109aa9: 8b 45 10 mov 0x10(%ebp),%eax
109aac: 8b 40 34 mov 0x34(%eax),%eax
fn->frags = 0;
109aaf: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi)
fn->size = je32_to_cpu(ri->dsize);
109ab6: 89 47 08 mov %eax,0x8(%edi)
if (retried) {
109ab9: 0f 84 38 ff ff ff je 1099f7 <jffs2_write_dnode+0x2a7> <== ALWAYS TAKEN
jffs2_dbg_acct_sanity_check(c,NULL);
109abf: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
109ac2: 31 c0 xor %eax,%eax <== NOT EXECUTED
109ac4: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
109ac8: e8 03 18 00 00 call 10b2d0 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
109acd: e9 25 ff ff ff jmp 1099f7 <jffs2_write_dnode+0x2a7> <== NOT EXECUTED
flash_ofs |= REF_PRISTINE;
109ad2: 83 cb 02 or $0x2,%ebx
109ad5: eb 92 jmp 109a69 <jffs2_write_dnode+0x319>
jffs2_free_full_dnode(fn);
109ad7: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
109ada: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED
109add: e8 7e b6 ff ff call 105160 <jffs2_free_full_dnode> <== NOT EXECUTED
return ERR_CAST(hold_err);
109ae2: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED
109ae5: 89 45 b8 mov %eax,-0x48(%ebp) <== NOT EXECUTED
109ae8: e9 0a ff ff ff jmp 1099f7 <jffs2_write_dnode+0x2a7> <== NOT EXECUTED
109aed: 90 nop
109aee: 90 nop
109aef: 90 nop
00109f50 <jffs2_write_inode_range>:
we don't have to go digging in struct inode or its equivalent. It should set:
mode, uid, gid, (starting)isize, atime, ctime, mtime */
int jffs2_write_inode_range(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
struct jffs2_raw_inode *ri, unsigned char *buf,
uint32_t offset, uint32_t writelen, uint32_t *retlen)
{
109f50: 55 push %ebp
109f51: 89 e5 mov %esp,%ebp
109f53: 57 push %edi
109f54: 56 push %esi
109f55: 53 push %ebx
109f56: 83 ec 4c sub $0x4c,%esp
uint32_t writtenlen = 0;
jffs2_dbg(1, "%s(): Ino #%u, ofs 0x%x, len 0x%x\n",
__func__, f->inocache->ino, offset, writelen);
while(writelen) {
109f59: 8b 45 1c mov 0x1c(%ebp),%eax
{
109f5c: 8b 7d 08 mov 0x8(%ebp),%edi
uint32_t writtenlen = 0;
109f5f: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
{
109f66: 8b 75 0c mov 0xc(%ebp),%esi
109f69: 8b 5d 10 mov 0x10(%ebp),%ebx
while(writelen) {
109f6c: 85 c0 test %eax,%eax
109f6e: 0f 84 4c 02 00 00 je 10a1c0 <jffs2_write_inode_range+0x270> <== NEVER TAKEN
struct jffs2_full_dnode *fn;
unsigned char *comprbuf = NULL;
109f74: c7 45 d8 00 00 00 00 movl $0x0,-0x28(%ebp)
if (ret) {
jffs2_dbg(1, "jffs2_reserve_space returned %d\n", ret);
break;
}
mutex_lock(&f->sem);
datalen = min_t(uint32_t, writelen,
109f7b: 8b 45 18 mov 0x18(%ebp),%eax
unsigned char *comprbuf = NULL;
109f7e: c7 45 d4 02 00 00 00 movl $0x2,-0x2c(%ebp)
datalen = min_t(uint32_t, writelen,
109f85: 25 ff 0f 00 00 and $0xfff,%eax
109f8a: 89 45 cc mov %eax,-0x34(%ebp)
ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN,
109f8d: 89 3c 24 mov %edi,(%esp)
109f90: b8 12 00 00 00 mov $0x12,%eax
109f95: 89 44 24 10 mov %eax,0x10(%esp)
109f99: 31 c0 xor %eax,%eax
109f9b: 89 44 24 0c mov %eax,0xc(%esp)
109f9f: 8d 45 dc lea -0x24(%ebp),%eax
109fa2: 89 44 24 08 mov %eax,0x8(%esp)
109fa6: b8 c4 00 00 00 mov $0xc4,%eax
109fab: 89 44 24 04 mov %eax,0x4(%esp)
109faf: e8 3c cc ff ff call 106bf0 <jffs2_reserve_space>
if (ret) {
109fb4: 85 c0 test %eax,%eax
109fb6: 0f 85 67 01 00 00 jne 10a123 <jffs2_write_inode_range+0x1d3>
datalen = min_t(uint32_t, writelen,
109fbc: 8b 45 cc mov -0x34(%ebp),%eax
109fbf: ba 00 10 00 00 mov $0x1000,%edx
109fc4: 29 c2 sub %eax,%edx
109fc6: 3b 55 1c cmp 0x1c(%ebp),%edx
109fc9: 76 03 jbe 109fce <jffs2_write_inode_range+0x7e>
109fcb: 8b 55 1c mov 0x1c(%ebp),%edx
109fce: 89 55 e0 mov %edx,-0x20(%ebp)
PAGE_SIZE - (offset & (PAGE_SIZE-1)));
cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen);
109fd1: 8b 45 dc mov -0x24(%ebp),%eax
109fd4: 83 e8 44 sub $0x44,%eax
109fd7: 39 d0 cmp %edx,%eax
109fd9: 76 02 jbe 109fdd <jffs2_write_inode_range+0x8d>
109fdb: 89 d0 mov %edx,%eax
109fdd: 89 45 e4 mov %eax,-0x1c(%ebp)
comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
109fe0: 8d 45 e4 lea -0x1c(%ebp),%eax
109fe3: 89 44 24 14 mov %eax,0x14(%esp)
109fe7: 8d 45 e0 lea -0x20(%ebp),%eax
109fea: 89 44 24 10 mov %eax,0x10(%esp)
109fee: 8d 45 d8 lea -0x28(%ebp),%eax
109ff1: 89 44 24 0c mov %eax,0xc(%esp)
109ff5: 8b 45 14 mov 0x14(%ebp),%eax
109ff8: 89 74 24 04 mov %esi,0x4(%esp)
109ffc: 89 3c 24 mov %edi,(%esp)
109fff: 89 44 24 08 mov %eax,0x8(%esp)
10a003: e8 d8 0e 00 00 call 10aee0 <jffs2_compress>
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));
10a008: b9 08 00 00 00 mov $0x8,%ecx
ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
10a00d: c7 03 85 19 02 e0 movl $0xe0021985,(%ebx)
comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
10a013: 66 89 45 d0 mov %ax,-0x30(%ebp)
ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen);
10a017: 8b 45 e4 mov -0x1c(%ebp),%eax
10a01a: 83 c0 44 add $0x44,%eax
10a01d: 89 43 04 mov %eax,0x4(%ebx)
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
10a020: 89 4c 24 08 mov %ecx,0x8(%esp)
10a024: 89 5c 24 04 mov %ebx,0x4(%esp)
10a028: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10a02f: e8 5c 0e 00 00 call 10ae90 <cyg_crc32_accumulate>
ri->ino = cpu_to_je32(f->inocache->ino);
ri->version = cpu_to_je32(++f->highest_version);
ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
10a034: 8b 55 e0 mov -0x20(%ebp),%edx
10a037: 8b 4d 18 mov 0x18(%ebp),%ecx
10a03a: 01 d1 add %edx,%ecx
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
10a03c: 89 43 08 mov %eax,0x8(%ebx)
ri->ino = cpu_to_je32(f->inocache->ino);
10a03f: 8b 46 14 mov 0x14(%esi),%eax
10a042: 8b 40 0c mov 0xc(%eax),%eax
10a045: 89 43 0c mov %eax,0xc(%ebx)
ri->version = cpu_to_je32(++f->highest_version);
10a048: 8b 06 mov (%esi),%eax
10a04a: 40 inc %eax
10a04b: 89 06 mov %eax,(%esi)
10a04d: 89 43 10 mov %eax,0x10(%ebx)
ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
10a050: 8b 43 1c mov 0x1c(%ebx),%eax
10a053: 39 c8 cmp %ecx,%eax
10a055: 73 02 jae 10a059 <jffs2_write_inode_range+0x109>
10a057: 89 c8 mov %ecx,%eax
10a059: 89 43 1c mov %eax,0x1c(%ebx)
ri->offset = cpu_to_je32(offset);
10a05c: 8b 45 18 mov 0x18(%ebp),%eax
ri->csize = cpu_to_je32(cdatalen);
ri->dsize = cpu_to_je32(datalen);
10a05f: 89 53 34 mov %edx,0x34(%ebx)
ri->offset = cpu_to_je32(offset);
10a062: 89 43 2c mov %eax,0x2c(%ebx)
ri->csize = cpu_to_je32(cdatalen);
10a065: 8b 45 e4 mov -0x1c(%ebp),%eax
10a068: 89 43 30 mov %eax,0x30(%ebx)
ri->compr = comprtype & 0xff;
10a06b: 8b 45 d0 mov -0x30(%ebp),%eax
10a06e: 66 89 43 38 mov %ax,0x38(%ebx)
ri->usercompr = (comprtype >> 8 ) & 0xff;
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
10a072: b8 3c 00 00 00 mov $0x3c,%eax
10a077: 89 44 24 08 mov %eax,0x8(%esp)
10a07b: 89 5c 24 04 mov %ebx,0x4(%esp)
10a07f: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10a086: e8 05 0e 00 00 call 10ae90 <cyg_crc32_accumulate>
10a08b: 89 43 40 mov %eax,0x40(%ebx)
ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
10a08e: 8b 45 e4 mov -0x1c(%ebp),%eax
10a091: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10a098: 89 44 24 08 mov %eax,0x8(%esp)
10a09c: 8b 45 d8 mov -0x28(%ebp),%eax
10a09f: 89 44 24 04 mov %eax,0x4(%esp)
10a0a3: e8 e8 0d 00 00 call 10ae90 <cyg_crc32_accumulate>
fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY);
10a0a8: ba 03 00 00 00 mov $0x3,%edx
ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
10a0ad: 89 43 3c mov %eax,0x3c(%ebx)
fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY);
10a0b0: 8b 45 e4 mov -0x1c(%ebp),%eax
10a0b3: 89 54 24 14 mov %edx,0x14(%esp)
10a0b7: 89 5c 24 08 mov %ebx,0x8(%esp)
10a0bb: 89 74 24 04 mov %esi,0x4(%esp)
10a0bf: 89 44 24 10 mov %eax,0x10(%esp)
10a0c3: 8b 45 d8 mov -0x28(%ebp),%eax
10a0c6: 89 3c 24 mov %edi,(%esp)
10a0c9: 89 44 24 0c mov %eax,0xc(%esp)
10a0cd: e8 7e f6 ff ff call 109750 <jffs2_write_dnode>
jffs2_free_comprbuf(comprbuf, buf);
if (IS_ERR(fn)) {
10a0d2: 3d 18 fc ff ff cmp $0xfffffc18,%eax
10a0d7: 76 67 jbe 10a140 <jffs2_write_inode_range+0x1f0> <== ALWAYS TAKEN
ret = PTR_ERR(fn);
mutex_unlock(&f->sem);
jffs2_complete_reservation(c);
10a0d9: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10a0dc: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED
10a0df: e8 ac c2 ff ff call 106390 <jffs2_complete_reservation> <== NOT EXECUTED
if (!retried) {
10a0e4: 83 7d d4 01 cmpl $0x1,-0x2c(%ebp) <== NOT EXECUTED
10a0e8: 74 36 je 10a120 <jffs2_write_inode_range+0x1d0> <== NOT EXECUTED
10a0ea: c7 45 d4 01 00 00 00 movl $0x1,-0x2c(%ebp) <== NOT EXECUTED
10a0f1: e9 97 fe ff ff jmp 109f8d <jffs2_write_inode_range+0x3d> <== NOT EXECUTED
}
if (ret) {
/* Eep */
jffs2_dbg(1, "Eep. add_full_dnode_to_inode() failed in commit_write, returned %d\n",
ret);
jffs2_mark_node_obsolete(c, fn->raw);
10a0f6: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED
10a0f9: 8b 11 mov (%ecx),%edx <== NOT EXECUTED
10a0fb: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10a0fe: 89 4d d4 mov %ecx,-0x2c(%ebp) <== NOT EXECUTED
10a101: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
10a105: e8 b6 c2 ff ff call 1063c0 <jffs2_mark_node_obsolete> <== NOT EXECUTED
jffs2_free_full_dnode(fn);
10a10a: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED
10a10d: 89 0c 24 mov %ecx,(%esp) <== NOT EXECUTED
10a110: e8 4b b0 ff ff call 105160 <jffs2_free_full_dnode> <== NOT EXECUTED
mutex_unlock(&f->sem);
jffs2_complete_reservation(c);
10a115: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
10a118: e8 73 c2 ff ff call 106390 <jffs2_complete_reservation> <== NOT EXECUTED
10a11d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
break;
10a120: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED
writtenlen += datalen;
offset += datalen;
writelen -= datalen;
buf += datalen;
}
*retlen = writtenlen;
10a123: 8b 55 20 mov 0x20(%ebp),%edx
10a126: 8b 4d c8 mov -0x38(%ebp),%ecx
10a129: 89 0a mov %ecx,(%edx)
return ret;
}
10a12b: 83 c4 4c add $0x4c,%esp
10a12e: 5b pop %ebx
10a12f: 5e pop %esi
10a130: 5f pop %edi
10a131: 5d pop %ebp
10a132: c3 ret
10a133: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10a13a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
ret = jffs2_add_full_dnode_to_inode(c, f, fn);
10a140: 89 44 24 08 mov %eax,0x8(%esp)
10a144: 89 74 24 04 mov %esi,0x4(%esp)
10a148: 89 3c 24 mov %edi,(%esp)
10a14b: 89 45 d4 mov %eax,-0x2c(%ebp)
10a14e: e8 5d b5 ff ff call 1056b0 <jffs2_add_full_dnode_to_inode>
if (f->metadata) {
10a153: 8b 56 08 mov 0x8(%esi),%edx
10a156: 8b 4d d4 mov -0x2c(%ebp),%ecx
10a159: 85 d2 test %edx,%edx
10a15b: 74 2c je 10a189 <jffs2_write_inode_range+0x239>
10a15d: 89 4d d0 mov %ecx,-0x30(%ebp)
jffs2_mark_node_obsolete(c, f->metadata->raw);
10a160: 8b 12 mov (%edx),%edx
10a162: 89 3c 24 mov %edi,(%esp)
10a165: 89 45 d4 mov %eax,-0x2c(%ebp)
10a168: 89 54 24 04 mov %edx,0x4(%esp)
10a16c: e8 4f c2 ff ff call 1063c0 <jffs2_mark_node_obsolete>
jffs2_free_full_dnode(f->metadata);
10a171: 8b 56 08 mov 0x8(%esi),%edx
10a174: 89 14 24 mov %edx,(%esp)
10a177: e8 e4 af ff ff call 105160 <jffs2_free_full_dnode>
f->metadata = NULL;
10a17c: 8b 4d d0 mov -0x30(%ebp),%ecx
10a17f: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi)
10a186: 8b 45 d4 mov -0x2c(%ebp),%eax
if (ret) {
10a189: 85 c0 test %eax,%eax
10a18b: 0f 85 65 ff ff ff jne 10a0f6 <jffs2_write_inode_range+0x1a6> <== NEVER TAKEN
jffs2_complete_reservation(c);
10a191: 89 3c 24 mov %edi,(%esp)
10a194: 89 45 d4 mov %eax,-0x2c(%ebp)
10a197: e8 f4 c1 ff ff call 106390 <jffs2_complete_reservation>
if (!datalen) {
10a19c: 8b 55 e0 mov -0x20(%ebp),%edx
10a19f: 8b 45 d4 mov -0x2c(%ebp),%eax
10a1a2: 85 d2 test %edx,%edx
10a1a4: 74 21 je 10a1c7 <jffs2_write_inode_range+0x277> <== NEVER TAKEN
writtenlen += datalen;
10a1a6: 01 55 c8 add %edx,-0x38(%ebp)
offset += datalen;
10a1a9: 01 55 18 add %edx,0x18(%ebp)
buf += datalen;
10a1ac: 01 55 14 add %edx,0x14(%ebp)
while(writelen) {
10a1af: 29 55 1c sub %edx,0x1c(%ebp)
10a1b2: 0f 85 bc fd ff ff jne 109f74 <jffs2_write_inode_range+0x24> <== NEVER TAKEN
10a1b8: e9 66 ff ff ff jmp 10a123 <jffs2_write_inode_range+0x1d3>
10a1bd: 8d 76 00 lea 0x0(%esi),%esi
10a1c0: 31 c0 xor %eax,%eax
10a1c2: e9 5c ff ff ff jmp 10a123 <jffs2_write_inode_range+0x1d3> <== NOT EXECUTED
pr_warn("Eep. We didn't actually write any data in jffs2_write_inode_range()\n");
10a1c7: c7 04 24 bc fe 12 00 movl $0x12febc,(%esp) <== NOT EXECUTED
10a1ce: e8 ed f3 ff ff call 1095c0 <jffs2_printk> <== NOT EXECUTED
ret = -EIO;
10a1d3: b8 fb ff ff ff mov $0xfffffffb,%eax <== NOT EXECUTED
break;
10a1d8: e9 46 ff ff ff jmp 10a123 <jffs2_write_inode_range+0x1d3> <== NOT EXECUTED
10a1dd: 90 nop
10a1de: 90 nop
10a1df: 90 nop
00100c60 <rtems_jffs2_compressor_rtime_compress>:
unsigned char *data_in,
unsigned char *cpage_out,
uint32_t *sourcelen,
uint32_t *dstlen
)
{
100c60: 55 push %ebp
int outpos = 0;
int pos=0;
(void) self;
memset(positions,0,sizeof(positions));
100c61: 31 d2 xor %edx,%edx
{
100c63: 89 e5 mov %esp,%ebp
memset(positions,0,sizeof(positions));
100c65: 31 c0 xor %eax,%eax
{
100c67: 57 push %edi
100c68: 56 push %esi
100c69: 53 push %ebx
100c6a: 81 ec 10 02 00 00 sub $0x210,%esp
memset(positions,0,sizeof(positions));
100c70: 89 94 05 f4 fd ff ff mov %edx,-0x20c(%ebp,%eax,1)
100c77: 89 94 05 f8 fd ff ff mov %edx,-0x208(%ebp,%eax,1)
100c7e: 83 c0 08 add $0x8,%eax
100c81: 3d 00 02 00 00 cmp $0x200,%eax
100c86: 72 e8 jb 100c70 <rtems_jffs2_compressor_rtime_compress+0x10>
while (pos < (*sourcelen) && outpos <= (*dstlen)-2) {
100c88: 8b 45 14 mov 0x14(%ebp),%eax
100c8b: 8b 10 mov (%eax),%edx
100c8d: 85 d2 test %edx,%edx
100c8f: 0f 84 03 01 00 00 je 100d98 <rtems_jffs2_compressor_rtime_compress+0x138><== NEVER TAKEN
100c95: 31 f6 xor %esi,%esi
int outpos = 0;
100c97: 31 c0 xor %eax,%eax
100c99: 89 85 e4 fd ff ff mov %eax,-0x21c(%ebp)
100c9f: 89 f3 mov %esi,%ebx
100ca1: 8b 75 0c mov 0xc(%ebp),%esi
int pos=0;
100ca4: 31 ff xor %edi,%edi
100ca6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
100cad: 8d 76 00 lea 0x0(%esi),%esi
int backpos, runlen=0;
unsigned char value;
value = data_in[pos];
100cb0: 0f b6 04 1e movzbl (%esi,%ebx,1),%eax
cpage_out[outpos++] = data_in[pos++];
100cb4: 47 inc %edi
100cb5: 8b 5d 10 mov 0x10(%ebp),%ebx
100cb8: 8b 95 e4 fd ff ff mov -0x21c(%ebp),%edx
100cbe: 88 04 13 mov %al,(%ebx,%edx,1)
backpos = positions[value];
100cc1: 0f b7 9c 45 f4 fd ff movzwl -0x20c(%ebp,%eax,2),%ebx
100cc8: ff
positions[value]=pos;
100cc9: 66 89 bc 45 f4 fd ff mov %di,-0x20c(%ebp,%eax,2)
100cd0: ff
while ((backpos < pos) && (pos < (*sourcelen)) &&
100cd1: 39 df cmp %ebx,%edi
100cd3: 0f 8e cc 00 00 00 jle 100da5 <rtems_jffs2_compressor_rtime_compress+0x145><== NEVER TAKEN
100cd9: 8b 45 14 mov 0x14(%ebp),%eax
(data_in[pos]==data_in[backpos++]) && (runlen<255)) {
100cdc: 8d 14 1e lea (%esi,%ebx,1),%edx
while ((backpos < pos) && (pos < (*sourcelen)) &&
100cdf: 4b dec %ebx
(data_in[pos]==data_in[backpos++]) && (runlen<255)) {
100ce0: 89 95 ec fd ff ff mov %edx,-0x214(%ebp)
while ((backpos < pos) && (pos < (*sourcelen)) &&
100ce6: 89 9d e8 fd ff ff mov %ebx,-0x218(%ebp)
100cec: 8b 00 mov (%eax),%eax
100cee: 89 85 f0 fd ff ff mov %eax,-0x210(%ebp)
int backpos, runlen=0;
100cf4: 31 c0 xor %eax,%eax
100cf6: eb 32 jmp 100d2a <rtems_jffs2_compressor_rtime_compress+0xca>
100cf8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
100cff: 90 nop
while ((backpos < pos) && (pos < (*sourcelen)) &&
100d00: 8b 8d ec fd ff ff mov -0x214(%ebp),%ecx
100d06: 0f b6 0c 01 movzbl (%ecx,%eax,1),%ecx
100d0a: 38 0c 3e cmp %cl,(%esi,%edi,1)
100d0d: 75 25 jne 100d34 <rtems_jffs2_compressor_rtime_compress+0xd4>
(data_in[pos]==data_in[backpos++]) && (runlen<255)) {
100d0f: 3d ff 00 00 00 cmp $0xff,%eax
100d14: 74 7e je 100d94 <rtems_jffs2_compressor_rtime_compress+0x134>
while ((backpos < pos) && (pos < (*sourcelen)) &&
100d16: 8b 8d e8 fd ff ff mov -0x218(%ebp),%ecx
pos++;
100d1c: 8d 57 01 lea 0x1(%edi),%edx
runlen++;
100d1f: 40 inc %eax
while ((backpos < pos) && (pos < (*sourcelen)) &&
100d20: 89 d3 mov %edx,%ebx
100d22: 01 c1 add %eax,%ecx
100d24: 39 f9 cmp %edi,%ecx
100d26: 7d 68 jge 100d90 <rtems_jffs2_compressor_rtime_compress+0x130><== NEVER TAKEN
pos++;
100d28: 89 d7 mov %edx,%edi
while ((backpos < pos) && (pos < (*sourcelen)) &&
100d2a: 39 bd f0 fd ff ff cmp %edi,-0x210(%ebp)
100d30: 89 fb mov %edi,%ebx
100d32: 77 cc ja 100d00 <rtems_jffs2_compressor_rtime_compress+0xa0>
}
cpage_out[outpos++] = runlen;
100d34: 83 85 e4 fd ff ff 02 addl $0x2,-0x21c(%ebp)
100d3b: 8b 4d 10 mov 0x10(%ebp),%ecx
100d3e: 8b 95 e4 fd ff ff mov -0x21c(%ebp),%edx
100d44: 88 44 11 ff mov %al,-0x1(%ecx,%edx,1)
while (pos < (*sourcelen) && outpos <= (*dstlen)-2) {
100d48: 8b 45 14 mov 0x14(%ebp),%eax
100d4b: 39 18 cmp %ebx,(%eax)
100d4d: 76 16 jbe 100d65 <rtems_jffs2_compressor_rtime_compress+0x105>
100d4f: 8b 45 18 mov 0x18(%ebp),%eax
100d52: 8b 00 mov (%eax),%eax
100d54: 89 85 f0 fd ff ff mov %eax,-0x210(%ebp)
100d5a: 83 e8 02 sub $0x2,%eax
100d5d: 39 d0 cmp %edx,%eax
100d5f: 0f 83 4b ff ff ff jae 100cb0 <rtems_jffs2_compressor_rtime_compress+0x50>
}
if (outpos >= pos) {
100d65: 8b 85 e4 fd ff ff mov -0x21c(%ebp),%eax
100d6b: 89 de mov %ebx,%esi
100d6d: 39 f8 cmp %edi,%eax
100d6f: 7d 27 jge 100d98 <rtems_jffs2_compressor_rtime_compress+0x138>
/* We failed */
return JFFS2_COMPR_NONE;
}
/* Tell the caller how much we managed to compress, and how much space it took */
*sourcelen = pos;
100d71: 8b 5d 14 mov 0x14(%ebp),%ebx
100d74: 89 33 mov %esi,(%ebx)
*dstlen = outpos;
100d76: 8b 75 18 mov 0x18(%ebp),%esi
100d79: 89 06 mov %eax,(%esi)
return JFFS2_COMPR_RTIME;
}
100d7b: 81 c4 10 02 00 00 add $0x210,%esp
return JFFS2_COMPR_RTIME;
100d81: b8 02 00 00 00 mov $0x2,%eax
}
100d86: 5b pop %ebx
100d87: 5e pop %esi
100d88: 5f pop %edi
100d89: 5d pop %ebp
100d8a: c3 ret
100d8b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
100d8f: 90 nop
pos++;
100d90: 89 d7 mov %edx,%edi <== NOT EXECUTED
100d92: eb a0 jmp 100d34 <rtems_jffs2_compressor_rtime_compress+0xd4><== NOT EXECUTED
100d94: b0 ff mov $0xff,%al
100d96: eb 9c jmp 100d34 <rtems_jffs2_compressor_rtime_compress+0xd4>
}
100d98: 81 c4 10 02 00 00 add $0x210,%esp
return JFFS2_COMPR_NONE;
100d9e: 31 c0 xor %eax,%eax
}
100da0: 5b pop %ebx
100da1: 5e pop %esi
100da2: 5f pop %edi
100da3: 5d pop %ebp
100da4: c3 ret
while ((backpos < pos) && (pos < (*sourcelen)) &&
100da5: 89 fb mov %edi,%ebx <== NOT EXECUTED
100da7: 31 c0 xor %eax,%eax <== NOT EXECUTED
100da9: eb 89 jmp 100d34 <rtems_jffs2_compressor_rtime_compress+0xd4><== NOT EXECUTED
100dab: 90 nop
100dac: 90 nop
100dad: 90 nop
100dae: 90 nop
100daf: 90 nop
00100db0 <rtems_jffs2_compressor_rtime_decompress>:
unsigned char *data_in,
unsigned char *cpage_out,
uint32_t srclen,
uint32_t destlen
)
{
100db0: 55 push %ebp
100db1: 89 e5 mov %esp,%ebp
100db3: 57 push %edi
100db4: 56 push %esi
100db5: 53 push %ebx
100db6: 81 ec 0c 02 00 00 sub $0x20c,%esp
int outpos = 0;
int pos=0;
(void) self;
if (comprtype != JFFS2_COMPR_RTIME) {
100dbc: 66 83 7d 0c 02 cmpw $0x2,0xc(%ebp)
100dc1: 0f 85 a8 01 00 00 jne 100f6f <rtems_jffs2_compressor_rtime_decompress+0x1bf><== NEVER TAKEN
return -EIO;
}
memset(positions,0,sizeof(positions));
100dc7: 31 d2 xor %edx,%edx
100dc9: 31 c0 xor %eax,%eax
100dcb: 89 94 05 f4 fd ff ff mov %edx,-0x20c(%ebp,%eax,1)
100dd2: 89 94 05 f8 fd ff ff mov %edx,-0x208(%ebp,%eax,1)
100dd9: 83 c0 08 add $0x8,%eax
100ddc: 3d 00 02 00 00 cmp $0x200,%eax
100de1: 72 e8 jb 100dcb <rtems_jffs2_compressor_rtime_decompress+0x1b>
while (outpos<destlen) {
100de3: 8b 7d 1c mov 0x1c(%ebp),%edi
100de6: 85 ff test %edi,%edi
100de8: 0f 84 b0 00 00 00 je 100e9e <rtems_jffs2_compressor_rtime_decompress+0xee><== NEVER TAKEN
100dee: 8b 55 10 mov 0x10(%ebp),%edx
int outpos = 0;
100df1: 31 db xor %ebx,%ebx
while (outpos<destlen) {
100df3: 31 ff xor %edi,%edi
100df5: eb 67 jmp 100e5e <rtems_jffs2_compressor_rtime_decompress+0xae>
100df7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
100dfe: 66 90 xchg %ax,%ax
repeat = data_in[pos++];
backoffs = positions[value];
positions[value]=outpos;
if (repeat) {
if (backoffs + repeat >= outpos) {
100e00: 01 c8 add %ecx,%eax
100e02: 39 f0 cmp %esi,%eax
100e04: 0f 8d a6 00 00 00 jge 100eb0 <rtems_jffs2_compressor_rtime_decompress+0x100>
while(repeat) {
cpage_out[outpos++] = cpage_out[backoffs++];
repeat--;
}
} else {
memcpy(&cpage_out[outpos],&cpage_out[backoffs],repeat);
100e0a: 8b 45 14 mov 0x14(%ebp),%eax
100e0d: 8b 5d 14 mov 0x14(%ebp),%ebx
100e10: 8b bd f0 fd ff ff mov -0x210(%ebp),%edi
100e16: 01 c1 add %eax,%ecx
100e18: 01 f3 add %esi,%ebx
100e1a: 89 c8 mov %ecx,%eax
100e1c: 89 9d ec fd ff ff mov %ebx,-0x214(%ebp)
100e22: 83 ff 04 cmp $0x4,%edi
100e25: 0f 83 d5 00 00 00 jae 100f00 <rtems_jffs2_compressor_rtime_decompress+0x150>
100e2b: 31 c9 xor %ecx,%ecx
100e2d: f7 c7 02 00 00 00 test $0x2,%edi
100e33: 74 0b je 100e40 <rtems_jffs2_compressor_rtime_decompress+0x90>
100e35: 0f b7 08 movzwl (%eax),%ecx
100e38: 66 89 0b mov %cx,(%ebx)
100e3b: b9 02 00 00 00 mov $0x2,%ecx
100e40: 83 e7 01 and $0x1,%edi
100e43: 74 07 je 100e4c <rtems_jffs2_compressor_rtime_decompress+0x9c>
100e45: 0f b6 04 08 movzbl (%eax,%ecx,1),%eax
100e49: 88 04 0b mov %al,(%ebx,%ecx,1)
outpos+=repeat;
100e4c: 8b 9d f0 fd ff ff mov -0x210(%ebp),%ebx
100e52: 01 f3 add %esi,%ebx
while (outpos<destlen) {
100e54: 89 df mov %ebx,%edi
100e56: 83 c2 02 add $0x2,%edx
100e59: 39 7d 1c cmp %edi,0x1c(%ebp)
100e5c: 76 40 jbe 100e9e <rtems_jffs2_compressor_rtime_decompress+0xee>
value = data_in[pos++];
100e5e: 0f b6 02 movzbl (%edx),%eax
cpage_out[outpos++] = value; /* first the verbatim copied byte */
100e61: 8d 73 01 lea 0x1(%ebx),%esi
100e64: 8b 4d 14 mov 0x14(%ebp),%ecx
100e67: 88 04 39 mov %al,(%ecx,%edi,1)
memcpy(&cpage_out[outpos],&cpage_out[backoffs],repeat);
100e6a: 89 f7 mov %esi,%edi
repeat = data_in[pos++];
100e6c: 0f b6 4a 01 movzbl 0x1(%edx),%ecx
100e70: 89 8d f0 fd ff ff mov %ecx,-0x210(%ebp)
backoffs = positions[value];
100e76: 0f b7 8c 45 f4 fd ff movzwl -0x20c(%ebp,%eax,2),%ecx
100e7d: ff
positions[value]=outpos;
100e7e: 66 89 b4 45 f4 fd ff mov %si,-0x20c(%ebp,%eax,2)
100e85: ff
if (repeat) {
100e86: 8b 85 f0 fd ff ff mov -0x210(%ebp),%eax
100e8c: 85 c0 test %eax,%eax
100e8e: 0f 85 6c ff ff ff jne 100e00 <rtems_jffs2_compressor_rtime_decompress+0x50>
while (outpos<destlen) {
100e94: 83 c2 02 add $0x2,%edx
cpage_out[outpos++] = value; /* first the verbatim copied byte */
100e97: 89 f3 mov %esi,%ebx
while (outpos<destlen) {
100e99: 39 7d 1c cmp %edi,0x1c(%ebp)
100e9c: 77 c0 ja 100e5e <rtems_jffs2_compressor_rtime_decompress+0xae>
}
}
}
return 0;
100e9e: 31 c0 xor %eax,%eax
}
100ea0: 81 c4 0c 02 00 00 add $0x20c,%esp
100ea6: 5b pop %ebx
100ea7: 5e pop %esi
100ea8: 5f pop %edi
100ea9: 5d pop %ebp
100eaa: c3 ret
100eab: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
100eaf: 90 nop
100eb0: 89 95 ec fd ff ff mov %edx,-0x214(%ebp)
100eb6: 8b 75 14 mov 0x14(%ebp),%esi
100eb9: 8b bd f0 fd ff ff mov -0x210(%ebp),%edi
100ebf: 01 ce add %ecx,%esi
100ec1: 89 f0 mov %esi,%eax
100ec3: 8b 75 14 mov 0x14(%ebp),%esi
100ec6: 01 f7 add %esi,%edi
100ec8: 01 cf add %ecx,%edi
100eca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
cpage_out[outpos++] = cpage_out[backoffs++];
100ed0: 0f b6 10 movzbl (%eax),%edx
100ed3: 89 c6 mov %eax,%esi
while(repeat) {
100ed5: 40 inc %eax
cpage_out[outpos++] = cpage_out[backoffs++];
100ed6: 29 ce sub %ecx,%esi
while(repeat) {
100ed8: 39 c7 cmp %eax,%edi
cpage_out[outpos++] = cpage_out[backoffs++];
100eda: 88 54 1e 01 mov %dl,0x1(%esi,%ebx,1)
while(repeat) {
100ede: 75 f0 jne 100ed0 <rtems_jffs2_compressor_rtime_decompress+0x120>
cpage_out[outpos++] = cpage_out[backoffs++];
100ee0: 8b 85 f0 fd ff ff mov -0x210(%ebp),%eax
100ee6: 8b 95 ec fd ff ff mov -0x214(%ebp),%edx
100eec: 8d 5c 03 01 lea 0x1(%ebx,%eax,1),%ebx
while (outpos<destlen) {
100ef0: 89 df mov %ebx,%edi
100ef2: e9 5f ff ff ff jmp 100e56 <rtems_jffs2_compressor_rtime_decompress+0xa6>
100ef7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
100efe: 66 90 xchg %ax,%ax
memcpy(&cpage_out[outpos],&cpage_out[backoffs],repeat);
100f00: f6 c3 01 test $0x1,%bl
100f03: 75 53 jne 100f58 <rtems_jffs2_compressor_rtime_decompress+0x1a8>
100f05: f6 c3 02 test $0x2,%bl
100f08: 75 3c jne 100f46 <rtems_jffs2_compressor_rtime_decompress+0x196>
100f0a: 83 ff 04 cmp $0x4,%edi
100f0d: 0f 82 18 ff ff ff jb 100e2b <rtems_jffs2_compressor_rtime_decompress+0x7b><== NEVER TAKEN
100f13: 89 95 e8 fd ff ff mov %edx,-0x218(%ebp)
100f19: 89 f9 mov %edi,%ecx
100f1b: 83 e1 fc and $0xfffffffc,%ecx
100f1e: 89 8d ec fd ff ff mov %ecx,-0x214(%ebp)
100f24: 31 c9 xor %ecx,%ecx
100f26: 8b 14 08 mov (%eax,%ecx,1),%edx
100f29: 89 14 0b mov %edx,(%ebx,%ecx,1)
100f2c: 83 c1 04 add $0x4,%ecx
100f2f: 3b 8d ec fd ff ff cmp -0x214(%ebp),%ecx
100f35: 72 ef jb 100f26 <rtems_jffs2_compressor_rtime_decompress+0x176>
100f37: 8b 95 e8 fd ff ff mov -0x218(%ebp),%edx
100f3d: 01 cb add %ecx,%ebx
100f3f: 01 c8 add %ecx,%eax
100f41: e9 e5 fe ff ff jmp 100e2b <rtems_jffs2_compressor_rtime_decompress+0x7b>
100f46: 0f b7 08 movzwl (%eax),%ecx
100f49: 83 c3 02 add $0x2,%ebx
100f4c: 83 c0 02 add $0x2,%eax
100f4f: 83 ef 02 sub $0x2,%edi
100f52: 66 89 4b fe mov %cx,-0x2(%ebx)
100f56: eb b2 jmp 100f0a <rtems_jffs2_compressor_rtime_decompress+0x15a>
100f58: 0f b6 09 movzbl (%ecx),%ecx
100f5b: 43 inc %ebx
100f5c: 40 inc %eax
100f5d: 88 8d e8 fd ff ff mov %cl,-0x218(%ebp)
100f63: 88 4b ff mov %cl,-0x1(%ebx)
100f66: 8b bd f0 fd ff ff mov -0x210(%ebp),%edi
100f6c: 4f dec %edi
100f6d: eb 96 jmp 100f05 <rtems_jffs2_compressor_rtime_decompress+0x155>
return -EIO;
100f6f: b8 fb ff ff ff mov $0xfffffffb,%eax <== NOT EXECUTED
100f74: e9 27 ff ff ff jmp 100ea0 <rtems_jffs2_compressor_rtime_decompress+0xf0><== NOT EXECUTED
100f79: 90 nop
100f7a: 90 nop
100f7b: 90 nop
100f7c: 90 nop
100f7d: 90 nop
100f7e: 90 nop
100f7f: 90 nop
001031a0 <rtems_jffs2_initialize>:
{
1031a0: 55 push %ebp
1031a1: 89 e5 mov %esp,%ebp
1031a3: 57 push %edi
1031a4: 56 push %esi
1031a5: 53 push %ebx
1031a6: 83 ec 2c sub $0x2c,%esp
rtems_jffs2_flash_control *fc = jffs2_mount_data->flash_control;
1031a9: 8b 45 0c mov 0xc(%ebp),%eax
1031ac: 8b 38 mov (%eax),%edi
int inocache_hashsize = calculate_inocache_hashsize(fc->flash_size);
1031ae: 8b 47 04 mov 0x4(%edi),%eax
1031b1: 89 45 e4 mov %eax,-0x1c(%ebp)
int hashsize = (size_mb * 2) & ~0x3f;
1031b4: 89 c6 mov %eax,%esi
1031b6: c1 ee 13 shr $0x13,%esi
1031b9: 81 e6 c0 1f 00 00 and $0x1fc0,%esi
1031bf: 81 fe 00 04 00 00 cmp $0x400,%esi
1031c5: 0f 8e 25 01 00 00 jle 1032f0 <rtems_jffs2_initialize+0x150> <== ALWAYS TAKEN
1031cb: be 00 04 00 00 mov $0x400,%esi <== NOT EXECUTED
rtems_jffs2_fs_info *fs_info = calloc(
1031d0: c7 04 24 01 00 00 00 movl $0x1,(%esp)
1031d7: 8d 04 b5 08 12 00 00 lea 0x1208(,%esi,4),%eax
1031de: 89 44 24 04 mov %eax,0x4(%esp)
1031e2: e8 69 ab 00 00 call 10dd50 <calloc>
if (fs_info != NULL) {
1031e7: 85 c0 test %eax,%eax
rtems_jffs2_fs_info *fs_info = calloc(
1031e9: 89 c3 mov %eax,%ebx
if (fs_info != NULL) {
1031eb: 0f 84 a8 01 00 00 je 103399 <rtems_jffs2_initialize+0x1f9> <== NEVER TAKEN
const char *_name)
{
struct _Mutex_recursive_Control _init =
_MUTEX_RECURSIVE_NAMED_INITIALIZER(_name);
*_mutex = _init;
1031f1: 31 c9 xor %ecx,%ecx
uint32_t blocks = fc->flash_size / fc->block_size;
1031f3: 31 d2 xor %edx,%edx
1031f5: 89 88 f0 10 00 00 mov %ecx,0x10f0(%eax)
1031fb: 31 c0 xor %eax,%eax
1031fd: 8b 0f mov (%edi),%ecx
1031ff: 89 83 f4 10 00 00 mov %eax,0x10f4(%ebx)
103205: 31 c0 xor %eax,%eax
103207: 89 83 f8 10 00 00 mov %eax,0x10f8(%ebx)
10320d: 31 c0 xor %eax,%eax
10320f: 89 83 fc 10 00 00 mov %eax,0x10fc(%ebx)
103215: b8 45 da 12 00 mov $0x12da45,%eax
10321a: 89 83 00 11 00 00 mov %eax,0x1100(%ebx)
103220: 31 c0 xor %eax,%eax
103222: 89 83 04 11 00 00 mov %eax,0x1104(%ebx)
103228: 8b 45 e4 mov -0x1c(%ebp),%eax
10322b: f7 f1 div %ecx
if ((fc->block_size * blocks) != fc->flash_size) {
10322d: 0f af c1 imul %ecx,%eax
103230: 39 45 e4 cmp %eax,-0x1c(%ebp)
103233: 0f 85 07 01 00 00 jne 103340 <rtems_jffs2_initialize+0x1a0> <== NEVER TAKEN
if (fc->flash_size < 5*fc->block_size) {
103239: 8d 14 89 lea (%ecx,%ecx,4),%edx
10323c: 39 c2 cmp %eax,%edx
10323e: 0f 87 22 01 00 00 ja 103366 <rtems_jffs2_initialize+0x1c6> <== NEVER TAKEN
sb->s_flash_control = fc;
103244: 89 bb e4 00 00 00 mov %edi,0xe4(%ebx)
sb->s_is_readonly = !mt_entry->writeable;
10324a: 8b 55 08 mov 0x8(%ebp),%edx
c->inocache_hashsize = inocache_hashsize;
10324d: 89 b3 c0 00 00 00 mov %esi,0xc0(%ebx)
sb->s_compressor_control = jffs2_mount_data->compressor_control;
103253: 8b 7d 0c mov 0xc(%ebp),%edi
c->sector_size = fc->block_size;
103256: 89 4b 34 mov %ecx,0x34(%ebx)
c->flash_size = fc->flash_size;
103259: 89 43 18 mov %eax,0x18(%ebx)
c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
10325c: c7 43 14 0c 00 00 00 movl $0xc,0x14(%ebx)
sb->s_is_readonly = !mt_entry->writeable;
103263: 0f b6 52 29 movzbl 0x29(%edx),%edx
103267: 88 55 e4 mov %dl,-0x1c(%ebp)
10326a: 80 f2 01 xor $0x1,%dl
10326d: 88 93 ec 00 00 00 mov %dl,0xec(%ebx)
sb->s_compressor_control = jffs2_mount_data->compressor_control;
103273: 8b 57 04 mov 0x4(%edi),%edx
err = jffs2_do_mount_fs(c);
103276: 89 1c 24 mov %ebx,(%esp)
sb->s_compressor_control = jffs2_mount_data->compressor_control;
103279: 89 93 e8 00 00 00 mov %edx,0xe8(%ebx)
c->inocache_list = &fs_info->inode_cache[0];
10327f: 8d 93 08 12 00 00 lea 0x1208(%ebx),%edx
103285: 89 93 c4 00 00 00 mov %edx,0xc4(%ebx)
err = jffs2_do_mount_fs(c);
10328b: e8 70 75 00 00 call 10a800 <jffs2_do_mount_fs>
if (err == 0) {
103290: 85 c0 test %eax,%eax
err = jffs2_do_mount_fs(c);
103292: 89 c6 mov %eax,%esi
if (err == 0) {
103294: 0f 85 28 01 00 00 jne 1033c2 <rtems_jffs2_initialize+0x222> <== NEVER TAKEN
sb->s_root = jffs2_iget(sb, 1);
10329a: 89 1c 24 mov %ebx,(%esp)
10329d: ba 01 00 00 00 mov $0x1,%edx
1032a2: 89 54 24 04 mov %edx,0x4(%esp)
1032a6: e8 15 fd ff ff call 102fc0 <jffs2_iget>
1032ab: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx)
if (IS_ERR(sb->s_root)) {
1032b1: 3d 18 fc ff ff cmp $0xfffffc18,%eax
1032b6: 77 58 ja 103310 <rtems_jffs2_initialize+0x170> <== NEVER TAKEN
1032b8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1032bf: 90 nop
if (!jffs2_is_readonly(c)) {
1032c0: 80 bb ec 00 00 00 00 cmpb $0x0,0xec(%ebx)
sb->s_root->i_parent = sb->s_root;
1032c7: 89 40 30 mov %eax,0x30(%eax)
if (!jffs2_is_readonly(c)) {
1032ca: 74 54 je 103320 <rtems_jffs2_initialize+0x180> <== ALWAYS TAKEN
mt_entry->fs_info = fs_info;
1032cc: 8b 7d 08 mov 0x8(%ebp),%edi
1032cf: 89 5f 08 mov %ebx,0x8(%edi)
mt_entry->mt_fs_root->location.node_access = sb->s_root;
1032d2: 8b 57 24 mov 0x24(%edi),%edx
mt_entry->ops = &rtems_jffs2_ops;
1032d5: c7 47 0c 40 de 12 00 movl $0x12de40,0xc(%edi)
mt_entry->mt_fs_root->location.node_access = sb->s_root;
1032dc: 89 42 08 mov %eax,0x8(%edx)
mt_entry->mt_fs_root->location.handlers = &rtems_jffs2_directory_handlers;
1032df: c7 42 10 20 df 12 00 movl $0x12df20,0x10(%edx)
}
1032e6: 83 c4 2c add $0x2c,%esp
1032e9: 89 f0 mov %esi,%eax
1032eb: 5b pop %ebx
1032ec: 5e pop %esi
1032ed: 5f pop %edi
1032ee: 5d pop %ebp
1032ef: c3 ret
1032f0: 81 fe 80 00 00 00 cmp $0x80,%esi
1032f6: 0f 8d d4 fe ff ff jge 1031d0 <rtems_jffs2_initialize+0x30> <== NEVER TAKEN
1032fc: be 80 00 00 00 mov $0x80,%esi
103301: e9 ca fe ff ff jmp 1031d0 <rtems_jffs2_initialize+0x30>
103306: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10330d: 8d 76 00 lea 0x0(%esi),%esi
if (err == 0) {
103310: 85 c0 test %eax,%eax <== NOT EXECUTED
103312: 74 ac je 1032c0 <rtems_jffs2_initialize+0x120> <== NOT EXECUTED
err = PTR_ERR(sb->s_root);
103314: 89 c6 mov %eax,%esi <== NOT EXECUTED
do_mount_fs_was_successful = true;
103316: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED
errno = -err;
10331b: f7 de neg %esi <== NOT EXECUTED
10331d: eb 62 jmp 103381 <rtems_jffs2_initialize+0x1e1> <== NOT EXECUTED
10331f: 90 nop <== NOT EXECUTED
jffs2_erase_pending_blocks(c, 0);
103320: 89 1c 24 mov %ebx,(%esp)
103323: 31 c0 xor %eax,%eax
103325: 89 44 24 04 mov %eax,0x4(%esp)
103329: e8 02 8a 00 00 call 10bd30 <jffs2_erase_pending_blocks>
mt_entry->mt_fs_root->location.node_access = sb->s_root;
10332e: 8b 83 e0 00 00 00 mov 0xe0(%ebx),%eax
103334: eb 96 jmp 1032cc <rtems_jffs2_initialize+0x12c>
103336: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10333d: 8d 76 00 lea 0x0(%esi),%esi
fc->flash_size = fc->block_size * blocks;
103340: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED
pr_info("Flash size not aligned to erasesize, reducing to %dKiB\n",
103343: c1 e8 0a shr $0xa,%eax <== NOT EXECUTED
103346: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10334a: c7 04 24 e0 dd 12 00 movl $0x12dde0,(%esp) <== NOT EXECUTED
103351: e8 fa ef ff ff call 102350 <jffs2_printk> <== NOT EXECUTED
if (fc->flash_size < 5*fc->block_size) {
103356: 8b 0f mov (%edi),%ecx <== NOT EXECUTED
103358: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED
10335b: 8d 14 89 lea (%ecx,%ecx,4),%edx <== NOT EXECUTED
10335e: 39 c2 cmp %eax,%edx <== NOT EXECUTED
103360: 0f 86 de fe ff ff jbe 103244 <rtems_jffs2_initialize+0xa4> <== NOT EXECUTED
pr_err("Too few erase blocks (%d)\n",
103366: c7 04 24 c0 dd 12 00 movl $0x12ddc0,(%esp) <== NOT EXECUTED
10336d: 31 d2 xor %edx,%edx <== NOT EXECUTED
10336f: be 16 00 00 00 mov $0x16,%esi <== NOT EXECUTED
103374: f7 f1 div %ecx <== NOT EXECUTED
103376: 89 44 24 04 mov %eax,0x4(%esp) <== NOT EXECUTED
10337a: e8 d1 ef ff ff call 102350 <jffs2_printk> <== NOT EXECUTED
10337f: 31 d2 xor %edx,%edx <== NOT EXECUTED
rtems_jffs2_free_fs_info(fs_info, do_mount_fs_was_successful);
103381: 89 d8 mov %ebx,%eax <== NOT EXECUTED
103383: e8 a8 f2 ff ff call 102630 <rtems_jffs2_free_fs_info> <== NOT EXECUTED
errno = -err;
103388: e8 83 37 02 00 call 126b10 <__errno> <== NOT EXECUTED
10338d: 89 30 mov %esi,(%eax) <== NOT EXECUTED
return -1;
10338f: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED
103394: e9 4d ff ff ff jmp 1032e6 <rtems_jffs2_initialize+0x146> <== NOT EXECUTED
if (fc->destroy != NULL) {
103399: 8b 47 14 mov 0x14(%edi),%eax <== NOT EXECUTED
10339c: 85 c0 test %eax,%eax <== NOT EXECUTED
10339e: 74 05 je 1033a5 <rtems_jffs2_initialize+0x205> <== NOT EXECUTED
(*fc->destroy)(fc);
1033a0: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED
1033a3: ff d0 call *%eax <== NOT EXECUTED
rtems_jffs2_compressor_control_destroy(jffs2_mount_data->compressor_control);
1033a5: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED
1033a8: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED
if (cc != NULL && cc->destroy != NULL) {
1033ab: 85 c0 test %eax,%eax <== NOT EXECUTED
1033ad: 74 19 je 1033c8 <rtems_jffs2_initialize+0x228> <== NOT EXECUTED
1033af: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED
1033b2: 85 d2 test %edx,%edx <== NOT EXECUTED
1033b4: 74 12 je 1033c8 <rtems_jffs2_initialize+0x228> <== NOT EXECUTED
(*cc->destroy)(cc);
1033b6: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED
1033b9: be 0c 00 00 00 mov $0xc,%esi <== NOT EXECUTED
1033be: ff d2 call *%edx <== NOT EXECUTED
1033c0: eb c6 jmp 103388 <rtems_jffs2_initialize+0x1e8> <== NOT EXECUTED
bool do_mount_fs_was_successful = false;
1033c2: 31 d2 xor %edx,%edx <== NOT EXECUTED
errno = -err;
1033c4: f7 de neg %esi <== NOT EXECUTED
1033c6: eb b9 jmp 103381 <rtems_jffs2_initialize+0x1e1> <== NOT EXECUTED
1033c8: be 0c 00 00 00 mov $0xc,%esi <== NOT EXECUTED
1033cd: eb b9 jmp 103388 <rtems_jffs2_initialize+0x1e8> <== NOT EXECUTED
1033cf: 90 nop