RTEMS-6
Annotated Report
libjffs2
Sun Feb 28 23:47:00 2021
0010ae90 <__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);
10ae90: f7ff bf7c b.w 10ad8c <__jffs2_dbg_acct_sanity_check_nolock> <== NOT EXECUTED
0010ad8c <__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)
{
10ad8c: b570 push {r4, r5, r6, lr}
10ad8e: 4604 mov r4, r0
10ad90: b086 sub sp, #24
if (unlikely(jeb && jeb->used_size + jeb->dirty_size +
10ad92: b161 cbz r1, 10adae <__jffs2_dbg_acct_sanity_check_nolock+0x22>
10ad94: 460d mov r5, r1
10ad96: e9d1 3105 ldrd r3, r1, [r1, #20]
10ad9a: 6a2a ldr r2, [r5, #32]
10ad9c: 440b add r3, r1
10ad9e: 69e9 ldr r1, [r5, #28]
10ada0: 4413 add r3, r2
10ada2: 692a ldr r2, [r5, #16]
10ada4: 440b add r3, r1
10ada6: 4413 add r3, r2
10ada8: 6b42 ldr r2, [r0, #52] ; 0x34
10adaa: 4293 cmp r3, r2
10adac: d142 bne.n 10ae34 <__jffs2_dbg_acct_sanity_check_nolock+0xa8> <== ALWAYS 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
10adae: e9d4 3007 ldrd r3, r0, [r4, #28]
10adb2: e9d4 210a ldrd r2, r1, [r4, #40] ; 0x28
10adb6: 4403 add r3, r0
10adb8: 6a60 ldr r0, [r4, #36] ; 0x24
10adba: 4413 add r3, r2
10adbc: 6b22 ldr r2, [r4, #48] ; 0x30
10adbe: 440b add r3, r1
10adc0: 6ba1 ldr r1, [r4, #56] ; 0x38
10adc2: 4413 add r3, r2
10adc4: 69a2 ldr r2, [r4, #24]
10adc6: 4403 add r3, r0
10adc8: 440b add r3, r1
10adca: 4293 cmp r3, r2
10adcc: d101 bne.n 10add2 <__jffs2_dbg_acct_sanity_check_nolock+0x46> <== ALWAYS 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();
}
}
10adce: b006 add sp, #24
10add0: bd70 pop {r4, r5, r6, pc}
JFFS2_ERROR("eeep, space accounting superblock info is screwed.\n");
10add2: f648 01e0 movw r1, #35040 ; 0x88e0 <== NOT EXECUTED
10add6: f648 0008 movw r0, #34824 ; 0x8808 <== NOT EXECUTED
10adda: f2c0 0111 movt r1, #17 <== NOT EXECUTED
10adde: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10ade2: f7ff ffc5 bl 10ad70 <jffs2_printk> <== NOT EXECUTED
JFFS2_ERROR("free %#08x + dirty %#08x + used %#08x + erasing %#08x + bad %#08x + wasted %#08x + unchecked %#08x != total %#08x.\n",
10ade6: 69a0 ldr r0, [r4, #24] <== NOT EXECUTED
10ade8: 6ba1 ldr r1, [r4, #56] ; 0x38 <== NOT EXECUTED
10adea: 6a62 ldr r2, [r4, #36] ; 0x24 <== NOT EXECUTED
10adec: 6b23 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED
10adee: e9cd 1004 strd r1, r0, [sp, #16] <== NOT EXECUTED
10adf2: f648 01e0 movw r1, #35040 ; 0x88e0 <== NOT EXECUTED
10adf6: 6ae6 ldr r6, [r4, #44] ; 0x2c <== NOT EXECUTED
10adf8: f648 0054 movw r0, #34900 ; 0x8854 <== NOT EXECUTED
10adfc: 69e5 ldr r5, [r4, #28] <== NOT EXECUTED
10adfe: f2c0 0111 movt r1, #17 <== NOT EXECUTED
10ae02: e9cd 3202 strd r3, r2, [sp, #8] <== NOT EXECUTED
10ae06: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10ae0a: 6a23 ldr r3, [r4, #32] <== NOT EXECUTED
10ae0c: 6aa2 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED
10ae0e: e9cd 5600 strd r5, r6, [sp] <== NOT EXECUTED
10ae12: f7ff ffad bl 10ad70 <jffs2_printk> <== NOT EXECUTED
BUG();
10ae16: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
10ae1a: f648 02e0 movw r2, #35040 ; 0x88e0 <== NOT EXECUTED
10ae1e: f248 70dc movw r0, #34780 ; 0x87dc <== NOT EXECUTED
10ae22: f2c0 0311 movt r3, #17 <== NOT EXECUTED
10ae26: f2c0 0211 movt r2, #17 <== NOT EXECUTED
10ae2a: 2131 movs r1, #49 ; 0x31 <== NOT EXECUTED
10ae2c: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10ae30: f001 fc1e bl 10c670 <__assert_func> <== NOT EXECUTED
JFFS2_ERROR("eeep, space accounting for block at 0x%08x is screwed.\n", jeb->offset);
10ae34: f648 01e0 movw r1, #35040 ; 0x88e0 <== NOT EXECUTED
10ae38: f248 701c movw r0, #34588 ; 0x871c <== NOT EXECUTED
10ae3c: 68ea ldr r2, [r5, #12] <== NOT EXECUTED
10ae3e: f2c0 0111 movt r1, #17 <== NOT EXECUTED
10ae42: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10ae46: f7ff ff93 bl 10ad70 <jffs2_printk> <== NOT EXECUTED
JFFS2_ERROR("free %#08x + dirty %#08x + used %#08x + wasted %#08x + unchecked %#08x != total %#08x.\n",
10ae4a: 6b62 ldr r2, [r4, #52] ; 0x34 <== NOT EXECUTED
10ae4c: f648 01e0 movw r1, #35040 ; 0x88e0 <== NOT EXECUTED
10ae50: 692b ldr r3, [r5, #16] <== NOT EXECUTED
10ae52: f248 706c movw r0, #34668 ; 0x876c <== NOT EXECUTED
10ae56: 69ee ldr r6, [r5, #28] <== NOT EXECUTED
10ae58: f2c0 0111 movt r1, #17 <== NOT EXECUTED
10ae5c: 696c ldr r4, [r5, #20] <== NOT EXECUTED
10ae5e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10ae62: e9cd 3202 strd r3, r2, [sp, #8] <== NOT EXECUTED
10ae66: 69ab ldr r3, [r5, #24] <== NOT EXECUTED
10ae68: 6a2a ldr r2, [r5, #32] <== NOT EXECUTED
10ae6a: e9cd 4600 strd r4, r6, [sp] <== NOT EXECUTED
10ae6e: f7ff ff7f bl 10ad70 <jffs2_printk> <== NOT EXECUTED
BUG();
10ae72: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
10ae76: f648 02e0 movw r2, #35040 ; 0x88e0 <== NOT EXECUTED
10ae7a: f248 70dc movw r0, #34780 ; 0x87dc <== NOT EXECUTED
10ae7e: f2c0 0311 movt r3, #17 <== NOT EXECUTED
10ae82: f2c0 0211 movt r2, #17 <== NOT EXECUTED
10ae86: 2128 movs r1, #40 ; 0x28 <== NOT EXECUTED
10ae88: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10ae8c: f001 fbf0 bl 10c670 <__assert_func> <== NOT EXECUTED
00107ef4 <__jffs2_ref_totlen>:
}
uint32_t __jffs2_ref_totlen(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
struct jffs2_raw_node_ref *ref)
{
107ef4: b570 push {r4, r5, r6, lr}
107ef6: 4614 mov r4, r2
if (ref->flash_offset == REF_LINK_NODE) {
107ef8: 68e3 ldr r3, [r4, #12]
107efa: 4606 mov r6, r0
107efc: b082 sub sp, #8
jeb = &c->blocks[ref->flash_offset / c->sector_size];
107efe: 6852 ldr r2, [r2, #4]
107f00: 1c58 adds r0, r3, #1
pr_crit("ref %p @0x%08x is not jeb->last_node (%p @0x%08x)\n",
107f02: f022 0503 bic.w r5, r2, #3
107f06: d006 beq.n 107f16 <__jffs2_ref_totlen+0x22>
if (ref->flash_offset == REF_EMPTY_NODE)
107f08: 1c98 adds r0, r3, #2
107f0a: d008 beq.n 107f1e <__jffs2_ref_totlen+0x2a>
ref_end = ref_offset(next_ref);
107f0c: f023 0003 bic.w r0, r3, #3
ret = ref->__totlen;
}
#endif /* TEST_TOTLEN */
return ret;
}
107f10: 1b40 subs r0, r0, r5
107f12: b002 add sp, #8
107f14: bd70 pop {r4, r5, r6, pc}
ref = ref->next_in_ino;
107f16: 68a3 ldr r3, [r4, #8]
if (!ref)
107f18: b10b cbz r3, 107f1e <__jffs2_ref_totlen+0x2a>
if (ref->flash_offset == REF_EMPTY_NODE)
107f1a: 685b ldr r3, [r3, #4]
107f1c: e7f4 b.n 107f08 <__jffs2_ref_totlen+0x14>
if (!jeb)
107f1e: b151 cbz r1, 107f36 <__jffs2_ref_totlen+0x42>
if (unlikely(ref != jeb->last_node)) {
107f20: 6acb ldr r3, [r1, #44] ; 0x2c
107f22: 429c cmp r4, r3
107f24: d110 bne.n 107f48 <__jffs2_ref_totlen+0x54> <== ALWAYS TAKEN
ref_end = jeb->offset + c->sector_size - jeb->free_size;
107f26: 68cb ldr r3, [r1, #12]
107f28: 6b70 ldr r0, [r6, #52] ; 0x34
107f2a: 6a0a ldr r2, [r1, #32]
107f2c: 4418 add r0, r3
107f2e: 1a80 subs r0, r0, r2
}
107f30: 1b40 subs r0, r0, r5
107f32: b002 add sp, #8
107f34: bd70 pop {r4, r5, r6, pc}
jeb = &c->blocks[ref->flash_offset / c->sector_size];
107f36: 6b71 ldr r1, [r6, #52] ; 0x34 <== NOT EXECUTED
107f38: 4610 mov r0, r2 <== NOT EXECUTED
107f3a: f00c fb11 bl 114560 <__udivsi3> <== NOT EXECUTED
107f3e: 6d71 ldr r1, [r6, #84] ; 0x54 <== NOT EXECUTED
107f40: 2334 movs r3, #52 ; 0x34 <== NOT EXECUTED
107f42: fb03 1100 mla r1, r3, r0, r1 <== NOT EXECUTED
107f46: e7eb b.n 107f20 <__jffs2_ref_totlen+0x2c> <== NOT EXECUTED
pr_crit("ref %p @0x%08x is not jeb->last_node (%p @0x%08x)\n",
107f48: b1db cbz r3, 107f82 <__jffs2_ref_totlen+0x8e> <== NOT EXECUTED
107f4a: 685e ldr r6, [r3, #4] <== NOT EXECUTED
107f4c: f026 0603 bic.w r6, r6, #3 <== NOT EXECUTED
107f50: f646 7078 movw r0, #28536 ; 0x6f78 <== NOT EXECUTED
107f54: 462a mov r2, r5 <== NOT EXECUTED
107f56: 4621 mov r1, r4 <== NOT EXECUTED
107f58: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107f5c: 9600 str r6, [sp, #0] <== NOT EXECUTED
107f5e: f7ff fb5f bl 107620 <jffs2_printk> <== NOT EXECUTED
BUG();
107f62: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
107f66: f646 72b8 movw r2, #28600 ; 0x6fb8 <== NOT EXECUTED
107f6a: f646 6054 movw r0, #28244 ; 0x6e54 <== NOT EXECUTED
107f6e: f2c0 0311 movt r3, #17 <== NOT EXECUTED
107f72: f2c0 0211 movt r2, #17 <== NOT EXECUTED
107f76: f240 21c9 movw r1, #713 ; 0x2c9 <== NOT EXECUTED
107f7a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107f7e: f004 fb77 bl 10c670 <__assert_func> <== NOT EXECUTED
pr_crit("ref %p @0x%08x is not jeb->last_node (%p @0x%08x)\n",
107f82: 461e mov r6, r3 <== NOT EXECUTED
107f84: e7e4 b.n 107f50 <__jffs2_ref_totlen+0x5c> <== NOT EXECUTED
107f86: bf00 nop
001076b4 <jffs2_add_fd_to_list>:
{
1076b4: e92d 43f8 stmdb sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
1076b8: 4615 mov r5, r2
while ((*prev) && (*prev)->nhash <= new->nhash) {
1076ba: 6814 ldr r4, [r2, #0]
{
1076bc: 4689 mov r9, r1
while ((*prev) && (*prev)->nhash <= new->nhash) {
1076be: b334 cbz r4, 10770e <jffs2_add_fd_to_list+0x5a>
1076c0: 690e ldr r6, [r1, #16]
1076c2: 4680 mov r8, r0
if ((*prev)->nhash == new->nhash && !strcmp((*prev)->name, new->name)) {
1076c4: f101 0715 add.w r7, r1, #21
1076c8: e002 b.n 1076d0 <jffs2_add_fd_to_list+0x1c>
prev = &((*prev)->next);
1076ca: 1d25 adds r5, r4, #4
while ((*prev) && (*prev)->nhash <= new->nhash) {
1076cc: 6864 ldr r4, [r4, #4]
1076ce: b1f4 cbz r4, 10770e <jffs2_add_fd_to_list+0x5a>
1076d0: 6923 ldr r3, [r4, #16]
1076d2: 42b3 cmp r3, r6
1076d4: d81b bhi.n 10770e <jffs2_add_fd_to_list+0x5a>
if ((*prev)->nhash == new->nhash && !strcmp((*prev)->name, new->name)) {
1076d6: d1f8 bne.n 1076ca <jffs2_add_fd_to_list+0x16>
1076d8: f104 0015 add.w r0, r4, #21
1076dc: 4639 mov r1, r7
1076de: f00d fe03 bl 1152e8 <strcmp>
1076e2: 2800 cmp r0, #0
1076e4: d1f1 bne.n 1076ca <jffs2_add_fd_to_list+0x16> <== ALWAYS TAKEN
if (new->version < (*prev)->version) {
1076e6: f8d9 2008 ldr.w r2, [r9, #8]
1076ea: 68a3 ldr r3, [r4, #8]
1076ec: 429a cmp r2, r3
1076ee: d314 bcc.n 10771a <jffs2_add_fd_to_list+0x66> <== ALWAYS TAKEN
new->next = (*prev)->next;
1076f0: 6863 ldr r3, [r4, #4]
1076f2: f8c9 3004 str.w r3, [r9, #4]
if ((*prev)->raw)
1076f6: 6828 ldr r0, [r5, #0]
1076f8: 6801 ldr r1, [r0, #0]
1076fa: b119 cbz r1, 107704 <jffs2_add_fd_to_list+0x50>
jffs2_mark_node_obsolete(c, ((*prev)->raw));
1076fc: 4640 mov r0, r8
1076fe: f000 fcc5 bl 10808c <jffs2_mark_node_obsolete>
jffs2_free_full_dirent(*prev);
107702: 6828 ldr r0, [r5, #0]
107704: f7ff ff0c bl 107520 <jffs2_free_full_dirent>
*prev = new;
107708: f8c5 9000 str.w r9, [r5]
10770c: e003 b.n 107716 <jffs2_add_fd_to_list+0x62>
new->next = *prev;
10770e: f8c9 4004 str.w r4, [r9, #4]
*prev = new;
107712: f8c5 9000 str.w r9, [r5]
}
107716: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc}
jffs2_mark_node_obsolete(c, new->raw);
10771a: 4640 mov r0, r8 <== NOT EXECUTED
10771c: f8d9 1000 ldr.w r1, [r9] <== NOT EXECUTED
107720: f000 fcb4 bl 10808c <jffs2_mark_node_obsolete> <== NOT EXECUTED
jffs2_free_full_dirent(new);
107724: 4648 mov r0, r9 <== NOT EXECUTED
}
107726: e8bd 43f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, lr} <== NOT EXECUTED
jffs2_free_full_dirent(new);
10772a: f7ff bef9 b.w 107520 <jffs2_free_full_dirent> <== NOT EXECUTED
10772e: bf00 nop
00107808 <jffs2_add_full_dnode_to_inode>:
{
107808: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
10780c: 4690 mov r8, r2
if (unlikely(!fn->size))
10780e: 6892 ldr r2, [r2, #8]
{
107810: b083 sub sp, #12
if (unlikely(!fn->size))
107812: b91a cbnz r2, 10781c <jffs2_add_full_dnode_to_inode+0x14>
return 0;
107814: 2000 movs r0, #0
}
107816: b003 add sp, #12
107818: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
newfrag = new_fragment(fn, fn->ofs, fn->size);
10781c: f8d8 4004 ldr.w r4, [r8, #4]
107820: 4681 mov r9, r0
107822: 468b mov fp, r1
107824: 9201 str r2, [sp, #4]
107826: 9400 str r4, [sp, #0]
newfrag = jffs2_alloc_node_frag();
107828: f7ff fed2 bl 1075d0 <jffs2_alloc_node_frag>
if (likely(newfrag)) {
10782c: 4606 mov r6, r0
10782e: 2800 cmp r0, #0
107830: f000 811d beq.w 107a6e <jffs2_add_full_dnode_to_inode+0x266> <== ALWAYS TAKEN
newfrag->ofs = ofs;
107834: 6184 str r4, [r0, #24]
newfrag->node->frags = 1;
107836: 2301 movs r3, #1
next = fragtree->rb_node;
107838: f8db 4004 ldr.w r4, [fp, #4]
ret = jffs2_add_frag_to_fragtree(c, &f->fragtree, newfrag);
10783c: f10b 0a04 add.w sl, fp, #4
newfrag->size = size;
107840: 9a01 ldr r2, [sp, #4]
this = jffs2_lookup_node_frag(root, newfrag->node->ofs);
107842: f8d8 7004 ldr.w r7, [r8, #4]
newfrag->node = fn;
107846: e9c0 8204 strd r8, r2, [r0, #16]
struct jffs2_node_frag *prev = NULL;
10784a: 2000 movs r0, #0
newfrag->node->frags = 1;
10784c: f8c8 300c str.w r3, [r8, #12]
while(next) {
107850: 2c00 cmp r4, #0
107852: d07b beq.n 10794c <jffs2_add_full_dnode_to_inode+0x144>
if (frag->ofs + frag->size <= offset) {
107854: e9d4 5105 ldrd r5, r1, [r4, #20]
107858: 440d add r5, r1
10785a: 42af cmp r7, r5
10785c: d36e bcc.n 10793c <jffs2_add_full_dnode_to_inode+0x134>
if (!prev || frag->ofs > prev->ofs)
10785e: 2800 cmp r0, #0
107860: d072 beq.n 107948 <jffs2_add_full_dnode_to_inode+0x140>
107862: 6983 ldr r3, [r0, #24]
107864: 4299 cmp r1, r3
107866: bf88 it hi
107868: 4620 movhi r0, r4
next = frag->rb.rb_right;
10786a: 6864 ldr r4, [r4, #4]
while(next) {
10786c: 2c00 cmp r4, #0
10786e: d1f1 bne.n 107854 <jffs2_add_full_dnode_to_inode+0x4c>
if (this) {
107870: 2800 cmp r0, #0
107872: d06b beq.n 10794c <jffs2_add_full_dnode_to_inode+0x144> <== ALWAYS TAKEN
lastend = this->ofs + this->size;
107874: e9d0 5105 ldrd r5, r1, [r0, #20]
107878: 4604 mov r4, r0
10787a: 440d add r5, r1
if (lastend <= newfrag->ofs) {
10787c: 9b00 ldr r3, [sp, #0]
10787e: 42ab cmp r3, r5
107880: f080 80c3 bcs.w 107a0a <jffs2_add_full_dnode_to_inode+0x202>
if (newfrag->ofs > this->ofs) {
107884: 9b00 ldr r3, [sp, #0]
107886: 428b cmp r3, r1
107888: f240 80d6 bls.w 107a38 <jffs2_add_full_dnode_to_inode+0x230>
mark_ref_normal(newfrag->node->raw);
10788c: f8d8 0000 ldr.w r0, [r8]
if (this->node)
107890: 6927 ldr r7, [r4, #16]
mark_ref_normal(newfrag->node->raw);
107892: 6843 ldr r3, [r0, #4]
107894: f043 0303 orr.w r3, r3, #3
107898: 6043 str r3, [r0, #4]
if (this->node)
10789a: b127 cbz r7, 1078a6 <jffs2_add_full_dnode_to_inode+0x9e>
mark_ref_normal(this->node->raw);
10789c: 6838 ldr r0, [r7, #0]
10789e: 6843 ldr r3, [r0, #4]
1078a0: f043 0303 orr.w r3, r3, #3
1078a4: 6043 str r3, [r0, #4]
if (this->ofs + this->size > newfrag->ofs + newfrag->size) {
1078a6: 9b00 ldr r3, [sp, #0]
1078a8: eb02 0b03 add.w fp, r2, r3
1078ac: 45ab cmp fp, r5
1078ae: d274 bcs.n 10799a <jffs2_add_full_dnode_to_inode+0x192> <== NEVER TAKEN
newfrag = jffs2_alloc_node_frag();
1078b0: f7ff fe8e bl 1075d0 <jffs2_alloc_node_frag> <== NOT EXECUTED
newfrag2 = new_fragment(this->node, newfrag->ofs + newfrag->size,
1078b4: eba5 050b sub.w r5, r5, fp <== NOT EXECUTED
if (likely(newfrag)) {
1078b8: 4681 mov r9, r0 <== NOT EXECUTED
1078ba: 2800 cmp r0, #0 <== NOT EXECUTED
1078bc: f000 80d7 beq.w 107a6e <jffs2_add_full_dnode_to_inode+0x266> <== NOT EXECUTED
newfrag->node = fn;
1078c0: 6107 str r7, [r0, #16] <== NOT EXECUTED
if (this->node)
1078c2: 6923 ldr r3, [r4, #16] <== NOT EXECUTED
newfrag->size = size;
1078c4: e9c0 5b05 strd r5, fp, [r0, #20] <== NOT EXECUTED
if (this->node)
1078c8: b113 cbz r3, 1078d0 <jffs2_add_full_dnode_to_inode+0xc8> <== NOT EXECUTED
this->node->frags++;
1078ca: 68da ldr r2, [r3, #12] <== NOT EXECUTED
1078cc: 3201 adds r2, #1 <== NOT EXECUTED
1078ce: 60da str r2, [r3, #12] <== NOT EXECUTED
this->size = newfrag->ofs - this->ofs;
1078d0: 69a2 ldr r2, [r4, #24] <== NOT EXECUTED
jffs2_fragtree_insert(newfrag, this);
1078d2: 4621 mov r1, r4 <== NOT EXECUTED
this->size = newfrag->ofs - this->ofs;
1078d4: 69b3 ldr r3, [r6, #24] <== NOT EXECUTED
jffs2_fragtree_insert(newfrag, this);
1078d6: 4630 mov r0, r6 <== NOT EXECUTED
this->size = newfrag->ofs - this->ofs;
1078d8: 1a9b subs r3, r3, r2 <== NOT EXECUTED
1078da: 6163 str r3, [r4, #20] <== NOT EXECUTED
jffs2_fragtree_insert(newfrag, this);
1078dc: f7ff feae bl 10763c <jffs2_fragtree_insert> <== NOT EXECUTED
_RBTree_Insert_color( (RBTree_Control *) root, node );
1078e0: 4631 mov r1, r6 <== NOT EXECUTED
1078e2: 4650 mov r0, sl <== NOT EXECUTED
1078e4: f009 f99e bl 110c24 <_RBTree_Insert_color> <== NOT EXECUTED
jffs2_fragtree_insert(newfrag2, newfrag);
1078e8: 4631 mov r1, r6 <== NOT EXECUTED
1078ea: 4648 mov r0, r9 <== NOT EXECUTED
1078ec: f7ff fea6 bl 10763c <jffs2_fragtree_insert> <== NOT EXECUTED
1078f0: 4649 mov r1, r9 <== NOT EXECUTED
1078f2: 4650 mov r0, sl <== NOT EXECUTED
1078f4: f009 f996 bl 110c24 <_RBTree_Insert_color> <== NOT EXECUTED
if (newfrag->ofs & (PAGE_SIZE-1)) {
1078f8: 69b5 ldr r5, [r6, #24] <== NOT EXECUTED
1078fa: f3c5 030b ubfx r3, r5, #0, #12
1078fe: 2b00 cmp r3, #0
107900: d137 bne.n 107972 <jffs2_add_full_dnode_to_inode+0x16a>
if ((newfrag->ofs+newfrag->size) & (PAGE_SIZE-1)) {
107902: 6973 ldr r3, [r6, #20]
107904: 442b add r3, r5
107906: f3c3 030b ubfx r3, r3, #0, #12
10790a: 2b00 cmp r3, #0
10790c: d082 beq.n 107814 <jffs2_add_full_dnode_to_inode+0xc>
return _RBTree_Successor( node );
10790e: 4630 mov r0, r6
107910: f009 fa28 bl 110d64 <_RBTree_Successor>
if (next) {
107914: 2800 cmp r0, #0
107916: f43f af7d beq.w 107814 <jffs2_add_full_dnode_to_inode+0xc>
mark_ref_normal(fn->raw);
10791a: f8d8 2000 ldr.w r2, [r8]
if (next->node)
10791e: 6901 ldr r1, [r0, #16]
mark_ref_normal(fn->raw);
107920: 6853 ldr r3, [r2, #4]
107922: f043 0303 orr.w r3, r3, #3
107926: 6053 str r3, [r2, #4]
if (next->node)
107928: 2900 cmp r1, #0
10792a: f43f af73 beq.w 107814 <jffs2_add_full_dnode_to_inode+0xc> <== ALWAYS TAKEN
mark_ref_normal(next->node->raw);
10792e: 680a ldr r2, [r1, #0]
return 0;
107930: 2000 movs r0, #0
mark_ref_normal(next->node->raw);
107932: 6853 ldr r3, [r2, #4]
107934: f043 0303 orr.w r3, r3, #3
107938: 6053 str r3, [r2, #4]
10793a: e76c b.n 107816 <jffs2_add_full_dnode_to_inode+0xe>
} else if (frag->ofs > offset) {
10793c: 428f cmp r7, r1
10793e: d29d bcs.n 10787c <jffs2_add_full_dnode_to_inode+0x74>
next = frag->rb.rb_left;
107940: 6824 ldr r4, [r4, #0]
while(next) {
107942: 2c00 cmp r4, #0
107944: d186 bne.n 107854 <jffs2_add_full_dnode_to_inode+0x4c> <== NEVER TAKEN
107946: e793 b.n 107870 <jffs2_add_full_dnode_to_inode+0x68> <== NOT EXECUTED
107948: 4620 mov r0, r4
10794a: e78e b.n 10786a <jffs2_add_full_dnode_to_inode+0x62>
if (lastend < newfrag->node->ofs) {
10794c: 2f00 cmp r7, #0
10794e: f040 80c3 bne.w 107ad8 <jffs2_add_full_dnode_to_inode+0x2d0>
RB_SET( child, parent, Node );
107952: 2301 movs r3, #1
107954: e9c6 7701 strd r7, r7, [r6, #4]
107958: 6037 str r7, [r6, #0]
_RBTree_Insert_color( (RBTree_Control *) root, node );
10795a: 4631 mov r1, r6
10795c: 60f3 str r3, [r6, #12]
10795e: 4650 mov r0, sl
*link = child;
107960: f8cb 6004 str.w r6, [fp, #4]
107964: f009 f95e bl 110c24 <_RBTree_Insert_color>
if (newfrag->ofs & (PAGE_SIZE-1)) {
107968: 69b5 ldr r5, [r6, #24]
10796a: f3c5 030b ubfx r3, r5, #0, #12
10796e: 2b00 cmp r3, #0
107970: d0c7 beq.n 107902 <jffs2_add_full_dnode_to_inode+0xfa>
return _RBTree_Predecessor( node );
107972: 4630 mov r0, r6
107974: f009 fa0e bl 110d94 <_RBTree_Predecessor>
mark_ref_normal(fn->raw);
107978: f8d8 2000 ldr.w r2, [r8]
if (prev->node)
10797c: 6901 ldr r1, [r0, #16]
mark_ref_normal(fn->raw);
10797e: 6853 ldr r3, [r2, #4]
107980: f043 0303 orr.w r3, r3, #3
107984: 6053 str r3, [r2, #4]
if (prev->node)
107986: 2900 cmp r1, #0
107988: f000 8096 beq.w 107ab8 <jffs2_add_full_dnode_to_inode+0x2b0>
mark_ref_normal(prev->node->raw);
10798c: 680a ldr r2, [r1, #0]
if ((newfrag->ofs+newfrag->size) & (PAGE_SIZE-1)) {
10798e: 69b5 ldr r5, [r6, #24]
mark_ref_normal(prev->node->raw);
107990: 6853 ldr r3, [r2, #4]
107992: f043 0303 orr.w r3, r3, #3
107996: 6053 str r3, [r2, #4]
107998: e7b3 b.n 107902 <jffs2_add_full_dnode_to_inode+0xfa>
this->size = newfrag->ofs - this->ofs;
10799a: 9b00 ldr r3, [sp, #0]
jffs2_fragtree_insert(newfrag, this);
10799c: 4630 mov r0, r6
this->size = newfrag->ofs - this->ofs;
10799e: 1a59 subs r1, r3, r1
1079a0: 6161 str r1, [r4, #20]
jffs2_fragtree_insert(newfrag, this);
1079a2: 4621 mov r1, r4
1079a4: f7ff fe4a bl 10763c <jffs2_fragtree_insert>
_RBTree_Insert_color( (RBTree_Control *) root, node );
1079a8: 4631 mov r1, r6
1079aa: 4650 mov r0, sl
1079ac: f009 f93a bl 110c24 <_RBTree_Insert_color>
}
1079b0: e005 b.n 1079be <jffs2_add_full_dnode_to_inode+0x1b6>
_RBTree_Extract( (RBTree_Control *) root, node );
1079b2: f008 fff5 bl 1109a0 <_RBTree_Extract>
jffs2_obsolete_node_frag(c, this);
1079b6: 4621 mov r1, r4
1079b8: 4648 mov r0, r9
1079ba: f7ff fe15 bl 1075e8 <jffs2_obsolete_node_frag>
return _RBTree_Successor( node );
1079be: 4630 mov r0, r6
1079c0: f009 f9d0 bl 110d64 <_RBTree_Successor>
1079c4: 4604 mov r4, r0
while ((this = frag_next(newfrag)) && newfrag->ofs + newfrag->size >= this->ofs + this->size) {
1079c6: 69b5 ldr r5, [r6, #24]
_RBTree_Extract( (RBTree_Control *) root, node );
1079c8: 4650 mov r0, sl
1079ca: 4621 mov r1, r4
1079cc: 2c00 cmp r4, #0
1079ce: d094 beq.n 1078fa <jffs2_add_full_dnode_to_inode+0xf2>
1079d0: 6973 ldr r3, [r6, #20]
1079d2: 69a7 ldr r7, [r4, #24]
1079d4: 18ea adds r2, r5, r3
1079d6: 6963 ldr r3, [r4, #20]
1079d8: 443b add r3, r7
1079da: 429a cmp r2, r3
1079dc: d2e9 bcs.n 1079b2 <jffs2_add_full_dnode_to_inode+0x1aa>
if (!this || newfrag->ofs + newfrag->size == this->ofs)
1079de: 42ba cmp r2, r7
1079e0: d08b beq.n 1078fa <jffs2_add_full_dnode_to_inode+0xf2>
this->size = (this->ofs + this->size) - (newfrag->ofs + newfrag->size);
1079e2: 1a9b subs r3, r3, r2
if (this->node)
1079e4: 6922 ldr r2, [r4, #16]
this->size = (this->ofs + this->size) - (newfrag->ofs + newfrag->size);
1079e6: 6163 str r3, [r4, #20]
this->ofs = newfrag->ofs + newfrag->size;
1079e8: 6973 ldr r3, [r6, #20]
1079ea: 442b add r3, r5
1079ec: 61a3 str r3, [r4, #24]
if (this->node)
1079ee: b122 cbz r2, 1079fa <jffs2_add_full_dnode_to_inode+0x1f2>
mark_ref_normal(this->node->raw);
1079f0: 6812 ldr r2, [r2, #0]
1079f2: 6853 ldr r3, [r2, #4]
1079f4: f043 0303 orr.w r3, r3, #3
1079f8: 6053 str r3, [r2, #4]
mark_ref_normal(newfrag->node->raw);
1079fa: 6933 ldr r3, [r6, #16]
if (newfrag->ofs & (PAGE_SIZE-1)) {
1079fc: 69b5 ldr r5, [r6, #24]
mark_ref_normal(newfrag->node->raw);
1079fe: 681a ldr r2, [r3, #0]
107a00: 6853 ldr r3, [r2, #4]
107a02: f043 0303 orr.w r3, r3, #3
107a06: 6053 str r3, [r2, #4]
if (unlikely(ret))
107a08: e777 b.n 1078fa <jffs2_add_full_dnode_to_inode+0xf2>
if (lastend && (lastend-1) >> PAGE_SHIFT == newfrag->ofs >> PAGE_SHIFT) {
107a0a: b125 cbz r5, 107a16 <jffs2_add_full_dnode_to_inode+0x20e>
107a0c: 0b1b lsrs r3, r3, #12
107a0e: 1e6a subs r2, r5, #1
107a10: ebb3 3f12 cmp.w r3, r2, lsr #12
107a14: d052 beq.n 107abc <jffs2_add_full_dnode_to_inode+0x2b4>
if (lastend < newfrag->node->ofs) {
107a16: 42af cmp r7, r5
rb_link_node(&newfrag->rb, &this->rb, &this->rb.rb_right);
107a18: bf98 it ls
107a1a: 4625 movls r5, r4
if (lastend < newfrag->node->ofs) {
107a1c: d836 bhi.n 107a8c <jffs2_add_full_dnode_to_inode+0x284> <== ALWAYS TAKEN
RB_SET( child, parent, Node );
107a1e: 2300 movs r3, #0
107a20: 60b5 str r5, [r6, #8]
107a22: e9c6 3300 strd r3, r3, [r6]
107a26: 2301 movs r3, #1
107a28: 60f3 str r3, [r6, #12]
_RBTree_Insert_color( (RBTree_Control *) root, node );
107a2a: 4631 mov r1, r6
107a2c: 4650 mov r0, sl
*link = child;
107a2e: 6066 str r6, [r4, #4]
107a30: f009 f8f8 bl 110c24 <_RBTree_Insert_color>
if (newfrag->ofs & (PAGE_SIZE-1)) {
107a34: 69b5 ldr r5, [r6, #24]
107a36: e798 b.n 10796a <jffs2_add_full_dnode_to_inode+0x162>
struct rb_node *victim,
struct rb_node *replacement,
struct rb_root *root
)
{
_RBTree_Replace_node(
107a38: 4632 mov r2, r6
107a3a: 4621 mov r1, r4
107a3c: 4650 mov r0, sl
107a3e: f009 f9e1 bl 110e04 <_RBTree_Replace_node>
if (newfrag->ofs + newfrag->size >= this->ofs+this->size) {
107a42: 6970 ldr r0, [r6, #20]
107a44: e9d4 2105 ldrd r2, r1, [r4, #20]
107a48: 69b3 ldr r3, [r6, #24]
107a4a: 188d adds r5, r1, r2
107a4c: 4403 add r3, r0
107a4e: 42ab cmp r3, r5
107a50: d2b1 bcs.n 1079b6 <jffs2_add_full_dnode_to_inode+0x1ae> <== NEVER TAKEN
this->size -= newfrag->size;
107a52: 1a12 subs r2, r2, r0 <== NOT EXECUTED
this->ofs += newfrag->size;
107a54: 4401 add r1, r0 <== NOT EXECUTED
this->size -= newfrag->size;
107a56: e9c4 2105 strd r2, r1, [r4, #20] <== NOT EXECUTED
jffs2_fragtree_insert(this, newfrag);
107a5a: 4620 mov r0, r4 <== NOT EXECUTED
107a5c: 4631 mov r1, r6 <== NOT EXECUTED
107a5e: f7ff fded bl 10763c <jffs2_fragtree_insert> <== NOT EXECUTED
_RBTree_Insert_color( (RBTree_Control *) root, node );
107a62: 4621 mov r1, r4 <== NOT EXECUTED
107a64: 4650 mov r0, sl <== NOT EXECUTED
107a66: f009 f8dd bl 110c24 <_RBTree_Insert_color> <== NOT EXECUTED
if (newfrag->ofs & (PAGE_SIZE-1)) {
107a6a: 69b5 ldr r5, [r6, #24] <== NOT EXECUTED
107a6c: e745 b.n 1078fa <jffs2_add_full_dnode_to_inode+0xf2> <== NOT EXECUTED
JFFS2_ERROR("cannot allocate a jffs2_node_frag object\n");
107a6e: f247 010c movw r1, #28684 ; 0x700c <== NOT EXECUTED
107a72: f646 6084 movw r0, #28292 ; 0x6e84 <== NOT EXECUTED
107a76: f2c0 0111 movt r1, #17 <== NOT EXECUTED
107a7a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107a7e: f7ff fdcf bl 107620 <jffs2_printk> <== NOT EXECUTED
return -ENOMEM;
107a82: f06f 000b mvn.w r0, #11 <== NOT EXECUTED
}
107a86: b003 add sp, #12 <== NOT EXECUTED
107a88: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
holefrag= new_fragment(NULL, lastend, newfrag->node->ofs - lastend);
107a8c: 1b7f subs r7, r7, r5 <== NOT EXECUTED
newfrag = jffs2_alloc_node_frag();
107a8e: f7ff fd9f bl 1075d0 <jffs2_alloc_node_frag> <== NOT EXECUTED
if (likely(newfrag)) {
107a92: 2800 cmp r0, #0 <== NOT EXECUTED
107a94: d031 beq.n 107afa <jffs2_add_full_dnode_to_inode+0x2f2> <== NOT EXECUTED
newfrag->node = fn;
107a96: 2300 movs r3, #0 <== NOT EXECUTED
newfrag->size = size;
107a98: e9c0 7505 strd r7, r5, [r0, #20] <== NOT EXECUTED
RB_SET( child, parent, Node );
107a9c: e9c0 3401 strd r3, r4, [r0, #4] <== NOT EXECUTED
rb_link_node(&holefrag->rb, &this->rb, &this->rb.rb_right);
107aa0: 4605 mov r5, r0 <== NOT EXECUTED
newfrag->node = fn;
107aa2: 6103 str r3, [r0, #16] <== NOT EXECUTED
107aa4: 6003 str r3, [r0, #0] <== NOT EXECUTED
107aa6: 2301 movs r3, #1 <== NOT EXECUTED
107aa8: 60c3 str r3, [r0, #12] <== NOT EXECUTED
*link = child;
107aaa: 6060 str r0, [r4, #4] <== NOT EXECUTED
struct rb_node **link
)
{
_RBTree_Initialize_node( node );
_RBTree_Add_child( node, parent, link );
}
107aac: 4604 mov r4, r0 <== NOT EXECUTED
_RBTree_Insert_color( (RBTree_Control *) root, node );
107aae: 4629 mov r1, r5
107ab0: 4650 mov r0, sl
107ab2: f009 f8b7 bl 110c24 <_RBTree_Insert_color>
if (this) {
107ab6: e7b2 b.n 107a1e <jffs2_add_full_dnode_to_inode+0x216>
if ((newfrag->ofs+newfrag->size) & (PAGE_SIZE-1)) {
107ab8: 69b5 ldr r5, [r6, #24]
107aba: e722 b.n 107902 <jffs2_add_full_dnode_to_inode+0xfa>
if (this->node)
107abc: 6923 ldr r3, [r4, #16]
107abe: b123 cbz r3, 107aca <jffs2_add_full_dnode_to_inode+0x2c2>
mark_ref_normal(this->node->raw);
107ac0: 681a ldr r2, [r3, #0]
107ac2: 6853 ldr r3, [r2, #4]
107ac4: f043 0303 orr.w r3, r3, #3
107ac8: 6053 str r3, [r2, #4]
mark_ref_normal(newfrag->node->raw);
107aca: f8d8 2000 ldr.w r2, [r8]
107ace: 6853 ldr r3, [r2, #4]
107ad0: f043 0303 orr.w r3, r3, #3
107ad4: 6053 str r3, [r2, #4]
107ad6: e79e b.n 107a16 <jffs2_add_full_dnode_to_inode+0x20e>
newfrag = jffs2_alloc_node_frag();
107ad8: f7ff fd7a bl 1075d0 <jffs2_alloc_node_frag>
if (likely(newfrag)) {
107adc: 4604 mov r4, r0
107ade: b160 cbz r0, 107afa <jffs2_add_full_dnode_to_inode+0x2f2>
newfrag->ofs = ofs;
107ae0: 2300 movs r3, #0
newfrag->size = size;
107ae2: 6147 str r7, [r0, #20]
newfrag->ofs = ofs;
107ae4: 6183 str r3, [r0, #24]
rb_link_node(&holefrag->rb, NULL, &root->rb_node);
107ae6: 4605 mov r5, r0
newfrag->node = fn;
107ae8: 6103 str r3, [r0, #16]
RB_SET( child, parent, Node );
107aea: e9c0 3301 strd r3, r3, [r0, #4]
107aee: 6003 str r3, [r0, #0]
107af0: 2301 movs r3, #1
107af2: 60c3 str r3, [r0, #12]
*link = child;
107af4: f8cb 0004 str.w r0, [fp, #4]
}
107af8: e7d9 b.n 107aae <jffs2_add_full_dnode_to_inode+0x2a6>
JFFS2_ERROR("cannot allocate a jffs2_node_frag object\n");
107afa: f247 010c movw r1, #28684 ; 0x700c <== NOT EXECUTED
107afe: f646 6084 movw r0, #28292 ; 0x6e84 <== NOT EXECUTED
107b02: f2c0 0111 movt r1, #17 <== NOT EXECUTED
107b06: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107b0a: f7ff fd89 bl 107620 <jffs2_printk> <== NOT EXECUTED
jffs2_free_node_frag(newfrag);
107b0e: 4630 mov r0, r6 <== NOT EXECUTED
107b10: f7ff fd62 bl 1075d8 <jffs2_free_node_frag> <== NOT EXECUTED
return -ENOMEM;
107b14: f06f 000b mvn.w r0, #11 <== NOT EXECUTED
107b18: e67d b.n 107816 <jffs2_add_full_dnode_to_inode+0xe> <== NOT EXECUTED
107b1a: bf00 nop
00107b4c <jffs2_add_ino_cache>:
{
107b4c: b570 push {r4, r5, r6, lr}
107b4e: 460d mov r5, r1
if (!new->ino)
107b50: 68cc ldr r4, [r1, #12]
{
107b52: 4606 mov r6, r0
if (!new->ino)
107b54: b91c cbnz r4, 107b5e <jffs2_add_ino_cache+0x12>
new->ino = ++c->highest_ino;
107b56: 6844 ldr r4, [r0, #4]
107b58: 3401 adds r4, #1
107b5a: 6044 str r4, [r0, #4]
107b5c: 60cc str r4, [r1, #12]
prev = &c->inocache_list[new->ino % c->inocache_hashsize];
107b5e: f8d6 10c0 ldr.w r1, [r6, #192] ; 0xc0
107b62: 4620 mov r0, r4
107b64: f00c fe2a bl 1147bc <__aeabi_uidivmod>
107b68: f8d6 00c4 ldr.w r0, [r6, #196] ; 0xc4
while ((*prev) && (*prev)->ino < new->ino) {
107b6c: f850 3021 ldr.w r3, [r0, r1, lsl #2]
prev = &c->inocache_list[new->ino % c->inocache_hashsize];
107b70: eb00 0081 add.w r0, r0, r1, lsl #2
while ((*prev) && (*prev)->ino < new->ino) {
107b74: b923 cbnz r3, 107b80 <jffs2_add_ino_cache+0x34>
107b76: e006 b.n 107b86 <jffs2_add_ino_cache+0x3a>
prev = &(*prev)->next;
107b78: f103 0010 add.w r0, r3, #16 <== NOT EXECUTED
while ((*prev) && (*prev)->ino < new->ino) {
107b7c: 691b ldr r3, [r3, #16] <== NOT EXECUTED
107b7e: b113 cbz r3, 107b86 <jffs2_add_ino_cache+0x3a> <== NOT EXECUTED
107b80: 68da ldr r2, [r3, #12] <== NOT EXECUTED
107b82: 42a2 cmp r2, r4 <== NOT EXECUTED
107b84: d3f8 bcc.n 107b78 <jffs2_add_ino_cache+0x2c> <== NOT EXECUTED
new->next = *prev;
107b86: 612b str r3, [r5, #16]
*prev = new;
107b88: 6005 str r5, [r0, #0]
}
107b8a: bd70 pop {r4, r5, r6, pc}
00107fa4 <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)
{
107fa4: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
107fa8: 4604 mov r4, r0
struct jffs2_eraseblock *jeb;
struct jffs2_raw_node_ref *new;
jeb = &c->blocks[ofs / c->sector_size];
107faa: 6b47 ldr r7, [r0, #52] ; 0x34
{
107fac: b083 sub sp, #12
jeb = &c->blocks[ofs / c->sector_size];
107fae: 4608 mov r0, r1
{
107fb0: 460d mov r5, r1
jeb = &c->blocks[ofs / c->sector_size];
107fb2: f04f 0834 mov.w r8, #52 ; 0x34
{
107fb6: 469a mov sl, r3
jeb = &c->blocks[ofs / c->sector_size];
107fb8: 4639 mov r1, r7
{
107fba: 4691 mov r9, r2
jeb = &c->blocks[ofs / c->sector_size];
107fbc: f00c fad0 bl 114560 <__udivsi3>
107fc0: e9d4 b315 ldrd fp, r3, [r4, #84] ; 0x54
107fc4: fb08 f800 mul.w r8, r8, r0
107fc8: eb0b 0608 add.w r6, fp, r8
__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))
107fcc: b363 cbz r3, 108028 <jffs2_add_physical_node_ref+0x84>
&& (jeb != c->nextblock || (ofs & ~3) != jeb->offset + (c->sector_size - jeb->free_size))) {
107fce: 42b3 cmp r3, r6
107fd0: f025 0103 bic.w r1, r5, #3
107fd4: d105 bne.n 107fe2 <jffs2_add_physical_node_ref+0x3e> <== ALWAYS TAKEN
107fd6: 68f3 ldr r3, [r6, #12]
107fd8: 441f add r7, r3
107fda: 6a33 ldr r3, [r6, #32]
107fdc: 1aff subs r7, r7, r3
107fde: 428f cmp r7, r1
107fe0: d026 beq.n 108030 <jffs2_add_physical_node_ref+0x8c> <== NEVER TAKEN
pr_warn("argh. node added in wrong place at 0x%08x(%d)\n",
107fe2: f247 001c movw r0, #28700 ; 0x701c <== NOT EXECUTED
107fe6: f005 0203 and.w r2, r5, #3 <== NOT EXECUTED
107fea: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107fee: f7ff ffcb bl 107f88 <jffs2_printk> <== NOT EXECUTED
ofs & ~3, ofs & 3);
if (c->nextblock)
107ff2: 6da3 ldr r3, [r4, #88] ; 0x58 <== NOT EXECUTED
107ff4: 2b00 cmp r3, #0 <== NOT EXECUTED
107ff6: d03c beq.n 108072 <jffs2_add_physical_node_ref+0xce> <== NOT EXECUTED
pr_warn("nextblock 0x%08x", c->nextblock->offset);
107ff8: f247 0058 movw r0, #28760 ; 0x7058 <== NOT EXECUTED
107ffc: 68d9 ldr r1, [r3, #12] <== NOT EXECUTED
107ffe: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108002: f7ff ffc1 bl 107f88 <jffs2_printk> <== NOT EXECUTED
else
pr_warn("No nextblock");
pr_cont(", expected at %08x\n",
108006: 68f3 ldr r3, [r6, #12] <== NOT EXECUTED
108008: f247 008c movw r0, #28812 ; 0x708c <== NOT EXECUTED
10800c: 6b62 ldr r2, [r4, #52] ; 0x34 <== NOT EXECUTED
jeb->offset + (c->sector_size - jeb->free_size));
return ERR_PTR(-EINVAL);
10800e: f06f 0515 mvn.w r5, #21 <== NOT EXECUTED
pr_cont(", expected at %08x\n",
108012: 6a31 ldr r1, [r6, #32] <== NOT EXECUTED
108014: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108018: 4413 add r3, r2 <== NOT EXECUTED
10801a: 1a59 subs r1, r3, r1 <== NOT EXECUTED
10801c: f7ff ffb4 bl 107f88 <jffs2_printk> <== NOT EXECUTED
jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
spin_unlock(&c->erase_completion_lock);
return new;
}
108020: 4628 mov r0, r5 <== NOT EXECUTED
108022: b003 add sp, #12 <== NOT EXECUTED
108024: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if ((c->nextblock || ((ofs & 3) != REF_OBSOLETE))
108028: f005 0203 and.w r2, r5, #3 <== NOT EXECUTED
10802c: 2a01 cmp r2, #1 <== NOT EXECUTED
10802e: d1ce bne.n 107fce <jffs2_add_physical_node_ref+0x2a> <== NOT EXECUTED
new = jffs2_link_node_ref(c, jeb, ofs, len, ic);
108030: 464b mov r3, r9
108032: 462a mov r2, r5
108034: 4631 mov r1, r6
108036: 4620 mov r0, r4
108038: f8cd a000 str.w sl, [sp]
10803c: f7ff fe68 bl 107d10 <jffs2_link_node_ref>
if (!jeb->free_size && !jeb->dirty_size && !ISDIRTY(jeb->wasted_size)) {
108040: 6a33 ldr r3, [r6, #32]
new = jffs2_link_node_ref(c, jeb, ofs, len, ic);
108042: 4605 mov r5, r0
if (!jeb->free_size && !jeb->dirty_size && !ISDIRTY(jeb->wasted_size)) {
108044: b96b cbnz r3, 108062 <jffs2_add_physical_node_ref+0xbe>
108046: 69b3 ldr r3, [r6, #24]
108048: b95b cbnz r3, 108062 <jffs2_add_physical_node_ref+0xbe>
10804a: 69f2 ldr r2, [r6, #28]
10804c: 2ac4 cmp r2, #196 ; 0xc4
10804e: d808 bhi.n 108062 <jffs2_add_physical_node_ref+0xbe>
struct list_head *prev = beforethisent->prev;
108050: 6e62 ldr r2, [r4, #100] ; 0x64
list_add_tail(&jeb->list, &c->clean_list);
108052: f104 0160 add.w r1, r4, #96 ; 0x60
newent->prev = prev;
108056: 6072 str r2, [r6, #4]
newent->next = beforethisent;
108058: f84b 1008 str.w r1, [fp, r8]
beforethisent->prev = newent;
10805c: 6666 str r6, [r4, #100] ; 0x64
prev->next = newent;
10805e: 6016 str r6, [r2, #0]
c->nextblock = NULL;
108060: 65a3 str r3, [r4, #88] ; 0x58
jffs2_dbg_acct_sanity_check_nolock(c,jeb);
108062: 4620 mov r0, r4
108064: 4631 mov r1, r6
108066: f002 fe91 bl 10ad8c <__jffs2_dbg_acct_sanity_check_nolock>
}
10806a: 4628 mov r0, r5
10806c: b003 add sp, #12
10806e: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
pr_warn("No nextblock");
108072: f247 0074 movw r0, #28788 ; 0x7074 <== NOT EXECUTED
108076: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10807a: f7ff ff85 bl 107f88 <jffs2_printk> <== NOT EXECUTED
10807e: e7c2 b.n 108006 <jffs2_add_physical_node_ref+0x62> <== NOT EXECUTED
00108080 <jffs2_complete_reservation>:
rtems_jffs2_flash_control *fc = sb->s_flash_control;
108080: f8d0 00e4 ldr.w r0, [r0, #228] ; 0xe4
if (fc->trigger_garbage_collection != NULL) {
108084: 6a03 ldr r3, [r0, #32]
108086: b103 cbz r3, 10808a <jffs2_complete_reservation+0xa>
(*fc->trigger_garbage_collection)(fc);
108088: 4718 bx r3 <== 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);
}
10808a: 4770 bx lr
0010af50 <jffs2_create>:
/***********************************************************************/
int jffs2_create(struct _inode *dir_i, const char *d_name, size_t d_namelen, int mode)
{
10af50: b5f0 push {r4, r5, r6, r7, lr}
10af52: b085 sub sp, #20
10af54: 4604 mov r4, r0
10af56: 461e mov r6, r3
struct _inode *inode;
int ret;
struct qstr qstr;
qstr.name = d_name;
qstr.len = d_namelen;
10af58: e9cd 1202 strd r1, r2, [sp, #8]
ri = jffs2_alloc_raw_inode();
10af5c: f7fc faee bl 10753c <jffs2_alloc_raw_inode>
if (!ri)
10af60: b3b0 cbz r0, 10afd0 <jffs2_create+0x80>
c = JFFS2_SB_INFO(dir_i->i_sb);
D1(printk(KERN_DEBUG "jffs2_create()\n"));
inode = jffs2_new_inode(dir_i, mode, ri);
10af62: 4602 mov r2, r0
10af64: 4631 mov r1, r6
10af66: 4605 mov r5, r0
10af68: 4620 mov r0, r4
c = JFFS2_SB_INFO(dir_i->i_sb);
10af6a: 6c27 ldr r7, [r4, #64] ; 0x40
inode = jffs2_new_inode(dir_i, mode, ri);
10af6c: f7fb f9bc bl 1062e8 <jffs2_new_inode>
if (IS_ERR(inode)) {
10af70: f510 7f7a cmn.w r0, #1000 ; 0x3e8
inode = jffs2_new_inode(dir_i, mode, ri);
10af74: 4606 mov r6, r0
if (IS_ERR(inode)) {
10af76: d824 bhi.n 10afc2 <jffs2_create+0x72> <== ALWAYS TAKEN
}
f = JFFS2_INODE_INFO(inode);
dir_f = JFFS2_INODE_INFO(dir_i);
ret = jffs2_do_create(c, dir_f, f, ri, &qstr);
10af78: ab02 add r3, sp, #8
10af7a: 4638 mov r0, r7
10af7c: 9300 str r3, [sp, #0]
10af7e: f106 0248 add.w r2, r6, #72 ; 0x48
10af82: 462b mov r3, r5
10af84: f104 0148 add.w r1, r4, #72 ; 0x48
10af88: f7ff faac bl 10a4e4 <jffs2_do_create>
if (ret) {
10af8c: 4607 mov r7, r0
10af8e: b968 cbnz r0, 10afac <jffs2_create+0x5c>
jffs2_iput(inode);
jffs2_free_raw_inode(ri);
return ret;
}
dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(ri->ctime));
10af90: 6aab ldr r3, [r5, #40] ; 0x28
jffs2_free_raw_inode(ri);
10af92: 4628 mov r0, r5
dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(ri->ctime));
10af94: 62e7 str r7, [r4, #44] ; 0x2c
10af96: e9c4 7309 strd r7, r3, [r4, #36] ; 0x24
10af9a: 6223 str r3, [r4, #32]
jffs2_free_raw_inode(ri);
10af9c: f7fc fad2 bl 107544 <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);
10afa0: 4630 mov r0, r6
10afa2: f7fa ff6b bl 105e7c <jffs2_iput>
return 0;
}
10afa6: 4638 mov r0, r7
10afa8: b005 add sp, #20
10afaa: bdf0 pop {r4, r5, r6, r7, pc}
inode->i_nlink = 0;
10afac: 2300 movs r3, #0 <== NOT EXECUTED
jffs2_iput(inode);
10afae: 4630 mov r0, r6 <== NOT EXECUTED
inode->i_nlink = 0;
10afb0: 81b3 strh r3, [r6, #12] <== NOT EXECUTED
jffs2_iput(inode);
10afb2: f7fa ff63 bl 105e7c <jffs2_iput> <== NOT EXECUTED
jffs2_free_raw_inode(ri);
10afb6: 4628 mov r0, r5 <== NOT EXECUTED
10afb8: f7fc fac4 bl 107544 <jffs2_free_raw_inode> <== NOT EXECUTED
}
10afbc: 4638 mov r0, r7 <== NOT EXECUTED
10afbe: b005 add sp, #20 <== NOT EXECUTED
10afc0: bdf0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
jffs2_free_raw_inode(ri);
10afc2: 4628 mov r0, r5 <== NOT EXECUTED
return PTR_ERR(inode);
10afc4: 4637 mov r7, r6 <== NOT EXECUTED
jffs2_free_raw_inode(ri);
10afc6: f7fc fabd bl 107544 <jffs2_free_raw_inode> <== NOT EXECUTED
}
10afca: 4638 mov r0, r7 <== NOT EXECUTED
10afcc: b005 add sp, #20 <== NOT EXECUTED
10afce: bdf0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
return -ENOMEM;
10afd0: f06f 070b mvn.w r7, #11 <== NOT EXECUTED
10afd4: e7e7 b.n 10afa6 <jffs2_create+0x56> <== NOT EXECUTED
10afd6: bf00 nop
0010ad1c <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)
{
10ad1c: b570 push {r4, r5, r6, lr}
10ad1e: b2d4 uxtb r4, r2
10ad20: 4694 mov ip, r2
10ad22: e9dd 5604 ldrd r5, r6, [sp, #16]
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)
10ad26: 2c06 cmp r4, #6
{
10ad28: 4686 mov lr, r0
10ad2a: 9a06 ldr r2, [sp, #24]
10ad2c: 4619 mov r1, r3
if ((comprtype & 0xff) <= JFFS2_COMPR_ZLIB)
10ad2e: d90c bls.n 10ad4a <jffs2_decompress+0x2e> <== NEVER TAKEN
rtems_jffs2_compressor_control *cc = sb->s_compressor_control;
10ad30: f8de 00e8 ldr.w r0, [lr, #232] ; 0xe8
break;
case JFFS2_COMPR_ZERO:
memset(data_out, 0, datalen);
break;
default:
if (cc != NULL) {
10ad34: b1c8 cbz r0, 10ad6a <jffs2_decompress+0x4e>
return (*cc->decompress)(cc, comprtype, cdata_in, data_out, cdatalen, datalen);
10ad36: e9cd 6204 strd r6, r2, [sp, #16]
10ad3a: 462b mov r3, r5
10ad3c: 6844 ldr r4, [r0, #4]
10ad3e: 460a mov r2, r1
10ad40: 4661 mov r1, ip
10ad42: 46a4 mov ip, r4
} else {
return -EIO;
}
}
return 0;
}
10ad44: e8bd 4070 ldmia.w sp!, {r4, r5, r6, lr}
return (*cc->decompress)(cc, comprtype, cdata_in, data_out, cdatalen, datalen);
10ad48: 4760 bx ip
switch (comprtype & 0xff) {
10ad4a: b924 cbnz r4, 10ad56 <jffs2_decompress+0x3a>
memcpy(data_out, cdata_in, datalen);
10ad4c: 4628 mov r0, r5 <== NOT EXECUTED
10ad4e: f009 ef98 blx 114c80 <memcpy> <== NOT EXECUTED
return 0;
10ad52: 4620 mov r0, r4 <== NOT EXECUTED
}
10ad54: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
switch (comprtype & 0xff) {
10ad56: 2c01 cmp r4, #1
10ad58: bf18 it ne
10ad5a: 46a4 movne ip, r4
10ad5c: d1e8 bne.n 10ad30 <jffs2_decompress+0x14> <== NEVER TAKEN
memset(data_out, 0, datalen);
10ad5e: 2100 movs r1, #0 <== NOT EXECUTED
10ad60: 4628 mov r0, r5 <== NOT EXECUTED
10ad62: f00a f9fd bl 115160 <memset> <== NOT EXECUTED
return 0;
10ad66: 2000 movs r0, #0 <== NOT EXECUTED
}
10ad68: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
return -EIO;
10ad6a: f06f 0004 mvn.w r0, #4 <== NOT EXECUTED
}
10ad6e: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
00107b8c <jffs2_del_ino_cache>:
{
107b8c: b570 push {r4, r5, r6, lr}
107b8e: 4606 mov r6, r0
prev = &c->inocache_list[old->ino % c->inocache_hashsize];
107b90: 68cc ldr r4, [r1, #12]
{
107b92: 460d mov r5, r1
prev = &c->inocache_list[old->ino % c->inocache_hashsize];
107b94: f8d0 10c0 ldr.w r1, [r0, #192] ; 0xc0
107b98: 4620 mov r0, r4
107b9a: f00c fe0f bl 1147bc <__aeabi_uidivmod>
107b9e: f8d6 20c4 ldr.w r2, [r6, #196] ; 0xc4
while ((*prev) && (*prev)->ino < old->ino) {
107ba2: f852 3021 ldr.w r3, [r2, r1, lsl #2]
prev = &c->inocache_list[old->ino % c->inocache_hashsize];
107ba6: eb02 0c81 add.w ip, r2, r1, lsl #2
while ((*prev) && (*prev)->ino < old->ino) {
107baa: b923 cbnz r3, 107bb6 <jffs2_del_ino_cache+0x2a>
107bac: e00b b.n 107bc6 <jffs2_del_ino_cache+0x3a>
prev = &(*prev)->next;
107bae: f103 0c10 add.w ip, r3, #16 <== NOT EXECUTED
while ((*prev) && (*prev)->ino < old->ino) {
107bb2: 691b ldr r3, [r3, #16] <== NOT EXECUTED
107bb4: b13b cbz r3, 107bc6 <jffs2_del_ino_cache+0x3a> <== NOT EXECUTED
107bb6: 68da ldr r2, [r3, #12]
107bb8: 4294 cmp r4, r2
107bba: d8f8 bhi.n 107bae <jffs2_del_ino_cache+0x22> <== ALWAYS TAKEN
if ((*prev) == old) {
107bbc: 429d cmp r5, r3
*prev = old->next;
107bbe: bf04 itt eq
107bc0: 692b ldreq r3, [r5, #16]
107bc2: f8cc 3000 streq.w r3, [ip]
if (old->state != INO_STATE_READING && old->state != INO_STATE_CLEARING)
107bc6: 896b ldrh r3, [r5, #10]
107bc8: 3b05 subs r3, #5
107bca: b29b uxth r3, r3
107bcc: 2b01 cmp r3, #1
107bce: d800 bhi.n 107bd2 <jffs2_del_ino_cache+0x46>
}
107bd0: bd70 pop {r4, r5, r6, pc}
jffs2_free_inode_cache(old);
107bd2: 4628 mov r0, r5
}
107bd4: e8bd 4070 ldmia.w sp!, {r4, r5, r6, lr}
jffs2_free_inode_cache(old);
107bd8: f7ff bd04 b.w 1075e4 <jffs2_free_inode_cache>
00109d48 <jffs2_do_clear_inode>:
kfree (f);
return ret;
}
void jffs2_do_clear_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f)
{
109d48: b570 push {r4, r5, r6, lr}
109d4a: 460d mov r5, r1
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;
109d4c: 6949 ldr r1, [r1, #20]
{
109d4e: 4606 mov r6, r0
if (deleted)
jffs2_mark_node_obsolete(c, f->metadata->raw);
jffs2_free_full_dnode(f->metadata);
}
jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL);
109d50: 1d2c adds r4, r5, #4
deleted = f->inocache && !f->inocache->pino_nlink;
109d52: b189 cbz r1, 109d78 <jffs2_do_clear_inode+0x30>
109d54: 694b ldr r3, [r1, #20]
if (f->inocache && f->inocache->state != INO_STATE_CHECKING)
109d56: 894a ldrh r2, [r1, #10]
deleted = f->inocache && !f->inocache->pino_nlink;
109d58: b963 cbnz r3, 109d74 <jffs2_do_clear_inode+0x2c>
if (f->inocache && f->inocache->state != INO_STATE_CHECKING)
109d5a: 2a01 cmp r2, #1
109d5c: d130 bne.n 109dc0 <jffs2_do_clear_inode+0x78> <== NEVER TAKEN
if (f->metadata) {
109d5e: 68ab ldr r3, [r5, #8]
109d60: b133 cbz r3, 109d70 <jffs2_do_clear_inode+0x28>
jffs2_mark_node_obsolete(c, f->metadata->raw);
109d62: 4630 mov r0, r6
109d64: 6819 ldr r1, [r3, #0]
109d66: f7fe f991 bl 10808c <jffs2_mark_node_obsolete>
jffs2_free_full_dnode(f->metadata);
109d6a: 68a8 ldr r0, [r5, #8]
109d6c: f7fd fbde bl 10752c <jffs2_free_full_dnode>
jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL);
109d70: 4631 mov r1, r6
109d72: e006 b.n 109d82 <jffs2_do_clear_inode+0x3a>
if (f->inocache && f->inocache->state != INO_STATE_CHECKING)
109d74: 2a01 cmp r2, #1
109d76: d127 bne.n 109dc8 <jffs2_do_clear_inode+0x80> <== NEVER TAKEN
if (f->metadata) {
109d78: 68a8 ldr r0, [r5, #8] <== NOT EXECUTED
109d7a: b108 cbz r0, 109d80 <jffs2_do_clear_inode+0x38> <== NOT EXECUTED
jffs2_free_full_dnode(f->metadata);
109d7c: f7fd fbd6 bl 10752c <jffs2_free_full_dnode>
jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL);
109d80: 2100 movs r1, #0
109d82: 4620 mov r0, r4
109d84: f7fd ffa2 bl 107ccc <jffs2_kill_fragtree>
if (f->target) {
109d88: 6928 ldr r0, [r5, #16]
109d8a: b118 cbz r0, 109d94 <jffs2_do_clear_inode+0x4c>
kfree(f->target);
109d8c: f002 fdac bl 10c8e8 <free>
f->target = NULL;
109d90: 2300 movs r3, #0
109d92: 612b str r3, [r5, #16]
}
fds = f->dents;
109d94: 68ec ldr r4, [r5, #12]
while(fds) {
109d96: b12c cbz r4, 109da4 <jffs2_do_clear_inode+0x5c>
fd = fds;
fds = fd->next;
109d98: 4620 mov r0, r4
109d9a: 6864 ldr r4, [r4, #4]
jffs2_free_full_dirent(fd);
109d9c: f7fd fbc0 bl 107520 <jffs2_free_full_dirent>
while(fds) {
109da0: 2c00 cmp r4, #0
109da2: d1f9 bne.n 109d98 <jffs2_do_clear_inode+0x50>
}
if (f->inocache && f->inocache->state != INO_STATE_CHECKING) {
109da4: 6969 ldr r1, [r5, #20]
109da6: b151 cbz r1, 109dbe <jffs2_do_clear_inode+0x76>
109da8: 894b ldrh r3, [r1, #10]
109daa: 2b01 cmp r3, #1
109dac: d007 beq.n 109dbe <jffs2_do_clear_inode+0x76> <== ALWAYS TAKEN
jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
109dae: 2203 movs r2, #3
109db0: 4630 mov r0, r6
109db2: f7fd feb3 bl 107b1c <jffs2_set_inocache_state>
if (f->inocache->nodes == (void *)f->inocache)
109db6: 6969 ldr r1, [r5, #20]
109db8: 684b ldr r3, [r1, #4]
109dba: 4299 cmp r1, r3
109dbc: d00b beq.n 109dd6 <jffs2_do_clear_inode+0x8e>
jffs2_del_ino_cache(c, f->inocache);
}
mutex_unlock(&f->sem);
}
109dbe: bd70 pop {r4, r5, r6, pc}
jffs2_set_inocache_state(c, f->inocache, INO_STATE_CLEARING);
109dc0: 2206 movs r2, #6
109dc2: f7fd feab bl 107b1c <jffs2_set_inocache_state>
109dc6: e7ca b.n 109d5e <jffs2_do_clear_inode+0x16>
109dc8: 2206 movs r2, #6
109dca: f7fd fea7 bl 107b1c <jffs2_set_inocache_state>
if (f->metadata) {
109dce: 68a8 ldr r0, [r5, #8]
109dd0: 2800 cmp r0, #0
109dd2: d0d5 beq.n 109d80 <jffs2_do_clear_inode+0x38>
109dd4: e7d2 b.n 109d7c <jffs2_do_clear_inode+0x34>
jffs2_del_ino_cache(c, f->inocache);
109dd6: 4630 mov r0, r6
}
109dd8: e8bd 4070 ldmia.w sp!, {r4, r5, r6, lr}
jffs2_del_ino_cache(c, f->inocache);
109ddc: f7fd bed6 b.w 107b8c <jffs2_del_ino_cache>
00109de0 <jffs2_do_crccheck_inode>:
{
109de0: b570 push {r4, r5, r6, lr} <== NOT EXECUTED
109de2: 4605 mov r5, r0 <== NOT EXECUTED
109de4: b092 sub sp, #72 ; 0x48 <== NOT EXECUTED
109de6: 460e mov r6, r1 <== NOT EXECUTED
struct jffs2_inode_info *f = kzalloc(sizeof(*f), GFP_KERNEL);
109de8: 2001 movs r0, #1 <== NOT EXECUTED
109dea: 211c movs r1, #28 <== NOT EXECUTED
109dec: f002 fc88 bl 10c700 <calloc> <== NOT EXECUTED
if (!f)
109df0: b190 cbz r0, 109e18 <jffs2_do_crccheck_inode+0x38> <== NOT EXECUTED
f->inocache = ic;
109df2: 4604 mov r4, r0 <== NOT EXECUTED
ret = jffs2_do_read_inode_internal(c, f, &n);
109df4: 4601 mov r1, r0 <== NOT EXECUTED
109df6: aa01 add r2, sp, #4 <== NOT EXECUTED
f->inocache = ic;
109df8: 6146 str r6, [r0, #20] <== NOT EXECUTED
ret = jffs2_do_read_inode_internal(c, f, &n);
109dfa: 4628 mov r0, r5 <== NOT EXECUTED
109dfc: f7fe ff20 bl 108c40 <jffs2_do_read_inode_internal> <== NOT EXECUTED
jffs2_do_clear_inode(c, f);
109e00: 4621 mov r1, r4 <== NOT EXECUTED
ret = jffs2_do_read_inode_internal(c, f, &n);
109e02: 4603 mov r3, r0 <== NOT EXECUTED
jffs2_do_clear_inode(c, f);
109e04: 4628 mov r0, r5 <== NOT EXECUTED
ret = jffs2_do_read_inode_internal(c, f, &n);
109e06: 461d mov r5, r3 <== NOT EXECUTED
jffs2_do_clear_inode(c, f);
109e08: f7ff ff9e bl 109d48 <jffs2_do_clear_inode> <== NOT EXECUTED
kfree (f);
109e0c: 4620 mov r0, r4 <== NOT EXECUTED
109e0e: f002 fd6b bl 10c8e8 <free> <== NOT EXECUTED
}
109e12: 4628 mov r0, r5 <== NOT EXECUTED
109e14: b012 add sp, #72 ; 0x48 <== NOT EXECUTED
109e16: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
return -ENOMEM;
109e18: f06f 050b mvn.w r5, #11 <== NOT EXECUTED
109e1c: e7f9 b.n 109e12 <jffs2_do_crccheck_inode+0x32> <== NOT EXECUTED
109e1e: bf00 nop
0010a4e4 <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)
{
10a4e4: e92d 43f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, lr}
10a4e8: 461d mov r5, r3
10a4ea: b085 sub sp, #20
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,
10a4ec: 2312 movs r3, #18
{
10a4ee: 4688 mov r8, r1
10a4f0: 4617 mov r7, r2
ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL,
10a4f2: 9300 str r3, [sp, #0]
10a4f4: aa03 add r2, sp, #12
10a4f6: 2300 movs r3, #0
10a4f8: 2144 movs r1, #68 ; 0x44
{
10a4fa: f8dd 9030 ldr.w r9, [sp, #48] ; 0x30
10a4fe: 4606 mov r6, r0
ret = jffs2_reserve_space(c, sizeof(*ri), &alloclen, ALLOC_NORMAL,
10a500: f7fe f868 bl 1085d4 <jffs2_reserve_space>
JFFS2_SUMMARY_INODE_SIZE);
jffs2_dbg(1, "%s(): reserved 0x%x bytes\n", __func__, alloclen);
if (ret)
10a504: 4604 mov r4, r0
10a506: b118 cbz r0, 10a510 <jffs2_do_create+0x2c>
jffs2_complete_reservation(c);
mutex_unlock(&dir_f->sem);
return 0;
}
10a508: 4620 mov r0, r4 <== NOT EXECUTED
10a50a: b005 add sp, #20 <== NOT EXECUTED
10a50c: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
10a510: 223c movs r2, #60 ; 0x3c
10a512: 4629 mov r1, r5
ri->data_crc = cpu_to_je32(0);
10a514: f885 003c strb.w r0, [r5, #60] ; 0x3c
10a518: f885 003d strb.w r0, [r5, #61] ; 0x3d
10a51c: f885 003e strb.w r0, [r5, #62] ; 0x3e
10a520: f885 003f strb.w r0, [r5, #63] ; 0x3f
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
10a524: f000 fbca bl 10acbc <cyg_crc32_accumulate>
fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
10a528: 4623 mov r3, r4
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
10a52a: 6428 str r0, [r5, #64] ; 0x40
fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
10a52c: 462a mov r2, r5
10a52e: 4639 mov r1, r7
10a530: 4630 mov r0, r6
10a532: e9cd 4400 strd r4, r4, [sp]
10a536: f7ff fcc7 bl 109ec8 <jffs2_write_dnode>
if (IS_ERR(fn)) {
10a53a: f510 7f7a cmn.w r0, #1000 ; 0x3e8
fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
10a53e: 4603 mov r3, r0
if (IS_ERR(fn)) {
10a540: d868 bhi.n 10a614 <jffs2_do_create+0x130> <== ALWAYS TAKEN
f->metadata = fn;
10a542: 60b8 str r0, [r7, #8]
jffs2_complete_reservation(c);
10a544: 4630 mov r0, r6
10a546: f7fd fd9b bl 108080 <jffs2_complete_reservation>
ret = jffs2_reserve_space(c, sizeof(*rd)+qstr->len, &alloclen,
10a54a: f8d9 1004 ldr.w r1, [r9, #4]
10a54e: 4623 mov r3, r4
10a550: aa03 add r2, sp, #12
10a552: 4630 mov r0, r6
10a554: f101 0418 add.w r4, r1, #24
10a558: 3128 adds r1, #40 ; 0x28
10a55a: 9400 str r4, [sp, #0]
10a55c: f7fe f83a bl 1085d4 <jffs2_reserve_space>
if (ret) {
10a560: 4604 mov r4, r0
10a562: 2800 cmp r0, #0
10a564: d1d0 bne.n 10a508 <jffs2_do_create+0x24> <== ALWAYS TAKEN
rd = jffs2_alloc_raw_dirent();
10a566: f7fc ffe3 bl 107530 <jffs2_alloc_raw_dirent>
if (!rd) {
10a56a: 4607 mov r7, r0
10a56c: 2800 cmp r0, #0
10a56e: d05e beq.n 10a62e <jffs2_do_create+0x14a> <== ALWAYS TAKEN
rd->totlen = cpu_to_je32(sizeof(*rd) + qstr->len);
10a570: f8d9 3004 ldr.w r3, [r9, #4]
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
10a574: 4601 mov r1, r0
10a576: 2208 movs r2, #8
rd->totlen = cpu_to_je32(sizeof(*rd) + qstr->len);
10a578: 3328 adds r3, #40 ; 0x28
10a57a: 6043 str r3, [r0, #4]
rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
10a57c: f06f 037a mvn.w r3, #122 ; 0x7a
10a580: 7003 strb r3, [r0, #0]
10a582: 2319 movs r3, #25
10a584: 7043 strb r3, [r0, #1]
rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
10a586: 2301 movs r3, #1
10a588: 7083 strb r3, [r0, #2]
10a58a: f06f 031f mvn.w r3, #31
10a58e: 70c3 strb r3, [r0, #3]
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
10a590: 4620 mov r0, r4
10a592: f000 fb93 bl 10acbc <cyg_crc32_accumulate>
rd->pino = cpu_to_je32(dir_f->inocache->ino);
10a596: f8d8 3014 ldr.w r3, [r8, #20]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
10a59a: 2220 movs r2, #32
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
10a59c: 60b8 str r0, [r7, #8]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
10a59e: 4639 mov r1, r7
10a5a0: 4620 mov r0, r4
rd->pino = cpu_to_je32(dir_f->inocache->ino);
10a5a2: 68db ldr r3, [r3, #12]
10a5a4: 60fb str r3, [r7, #12]
rd->version = cpu_to_je32(++dir_f->highest_version);
10a5a6: f8d8 3000 ldr.w r3, [r8]
10a5aa: 3301 adds r3, #1
10a5ac: f8c8 3000 str.w r3, [r8]
10a5b0: 613b str r3, [r7, #16]
rd->ino = ri->ino;
10a5b2: 68eb ldr r3, [r5, #12]
10a5b4: 617b str r3, [r7, #20]
rd->mctime = ri->ctime;
10a5b6: 6aab ldr r3, [r5, #40] ; 0x28
10a5b8: 61bb str r3, [r7, #24]
rd->nsize = qstr->len;
10a5ba: f8d9 3004 ldr.w r3, [r9, #4]
10a5be: 773b strb r3, [r7, #28]
rd->type = DT_REG;
10a5c0: 2308 movs r3, #8
10a5c2: 777b strb r3, [r7, #29]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
10a5c4: f000 fb7a bl 10acbc <cyg_crc32_accumulate>
rd->name_crc = cpu_to_je32(crc32(0, qstr->name, qstr->len));
10a5c8: e9d9 1200 ldrd r1, r2, [r9]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
10a5cc: 6238 str r0, [r7, #32]
rd->name_crc = cpu_to_je32(crc32(0, qstr->name, qstr->len));
10a5ce: 4620 mov r0, r4
10a5d0: f000 fb74 bl 10acbc <cyg_crc32_accumulate>
10a5d4: 6278 str r0, [r7, #36] ; 0x24
fd = jffs2_write_dirent(c, dir_f, rd, qstr->name, qstr->len, ALLOC_NORMAL);
10a5d6: 463a mov r2, r7
10a5d8: 9401 str r4, [sp, #4]
10a5da: 4641 mov r1, r8
10a5dc: f8d9 3004 ldr.w r3, [r9, #4]
10a5e0: 4630 mov r0, r6
10a5e2: 9300 str r3, [sp, #0]
10a5e4: f8d9 3000 ldr.w r3, [r9]
10a5e8: f7ff fd7a bl 10a0e0 <jffs2_write_dirent>
10a5ec: 4605 mov r5, r0
jffs2_free_raw_dirent(rd);
10a5ee: 4638 mov r0, r7
10a5f0: f7fc ffa2 bl 107538 <jffs2_free_raw_dirent>
if (IS_ERR(fd)) {
10a5f4: f515 7f7a cmn.w r5, #1000 ; 0x3e8
10a5f8: d814 bhi.n 10a624 <jffs2_do_create+0x140> <== ALWAYS TAKEN
jffs2_add_fd_to_list(c, fd, &dir_f->dents);
10a5fa: f108 020c add.w r2, r8, #12
10a5fe: 4629 mov r1, r5
10a600: 4630 mov r0, r6
10a602: f7fd f857 bl 1076b4 <jffs2_add_fd_to_list>
jffs2_complete_reservation(c);
10a606: 4630 mov r0, r6
10a608: f7fd fd3a bl 108080 <jffs2_complete_reservation>
}
10a60c: 4620 mov r0, r4
10a60e: b005 add sp, #20
10a610: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
jffs2_complete_reservation(c);
10a614: 4630 mov r0, r6 <== NOT EXECUTED
return PTR_ERR(fn);
10a616: 461c mov r4, r3 <== NOT EXECUTED
jffs2_complete_reservation(c);
10a618: f7fd fd32 bl 108080 <jffs2_complete_reservation> <== NOT EXECUTED
}
10a61c: 4620 mov r0, r4 <== NOT EXECUTED
10a61e: b005 add sp, #20 <== NOT EXECUTED
10a620: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
jffs2_complete_reservation(c);
10a624: 4630 mov r0, r6 <== NOT EXECUTED
return PTR_ERR(fd);
10a626: 462c mov r4, r5 <== NOT EXECUTED
jffs2_complete_reservation(c);
10a628: f7fd fd2a bl 108080 <jffs2_complete_reservation> <== NOT EXECUTED
return PTR_ERR(fd);
10a62c: e76c b.n 10a508 <jffs2_do_create+0x24> <== NOT EXECUTED
jffs2_complete_reservation(c);
10a62e: 4630 mov r0, r6 <== NOT EXECUTED
return -ENOMEM;
10a630: f06f 040b mvn.w r4, #11 <== NOT EXECUTED
jffs2_complete_reservation(c);
10a634: f7fd fd24 bl 108080 <jffs2_complete_reservation> <== NOT EXECUTED
return -ENOMEM;
10a638: e766 b.n 10a508 <jffs2_do_create+0x24> <== NOT EXECUTED
10a63a: bf00 nop
0010a708 <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)
{
10a708: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
10a70c: b085 sub sp, #20
10a70e: f8dd 803c ldr.w r8, [sp, #60] ; 0x3c
10a712: 4607 mov r7, r0
10a714: 460e mov r6, r1
10a716: 4692 mov sl, r2
10a718: 4699 mov r9, r3
struct jffs2_raw_dirent *rd;
struct jffs2_full_dirent *fd;
uint32_t alloclen;
int ret;
rd = jffs2_alloc_raw_dirent();
10a71a: f7fc ff09 bl 107530 <jffs2_alloc_raw_dirent>
if (!rd)
10a71e: 2800 cmp r0, #0
10a720: d066 beq.n 10a7f0 <jffs2_do_link+0xe8> <== ALWAYS TAKEN
return -ENOMEM;
ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
10a722: f108 0318 add.w r3, r8, #24
10a726: f108 0b28 add.w fp, r8, #40 ; 0x28
10a72a: 9300 str r3, [sp, #0]
10a72c: 4604 mov r4, r0
10a72e: 2300 movs r3, #0
10a730: aa03 add r2, sp, #12
10a732: 4659 mov r1, fp
10a734: 4638 mov r0, r7
10a736: f7fd ff4d bl 1085d4 <jffs2_reserve_space>
ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
if (ret) {
10a73a: 4605 mov r5, r0
10a73c: 2800 cmp r0, #0
10a73e: d150 bne.n 10a7e2 <jffs2_do_link+0xda> <== ALWAYS TAKEN
}
mutex_lock(&dir_f->sem);
/* Build a deletion node */
rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
10a740: f06f 037a mvn.w r3, #122 ; 0x7a
rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
10a744: 2208 movs r2, #8
rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
10a746: 7023 strb r3, [r4, #0]
10a748: 2319 movs r3, #25
10a74a: 7063 strb r3, [r4, #1]
rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
10a74c: 2301 movs r3, #1
10a74e: 70a3 strb r3, [r4, #2]
10a750: f06f 031f mvn.w r3, #31
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
10a754: 4621 mov r1, r4
rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
10a756: 70e3 strb r3, [r4, #3]
rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
10a758: f8c4 b004 str.w fp, [r4, #4]
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
10a75c: f000 faae bl 10acbc <cyg_crc32_accumulate>
rd->pino = cpu_to_je32(dir_f->inocache->ino);
10a760: 6973 ldr r3, [r6, #20]
rd->mctime = cpu_to_je32(time);
rd->nsize = namelen;
rd->type = type;
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
10a762: 2220 movs r2, #32
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
10a764: 60a0 str r0, [r4, #8]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
10a766: 4621 mov r1, r4
10a768: 4628 mov r0, r5
rd->pino = cpu_to_je32(dir_f->inocache->ino);
10a76a: 68db ldr r3, [r3, #12]
10a76c: 60e3 str r3, [r4, #12]
rd->version = cpu_to_je32(++dir_f->highest_version);
10a76e: 6833 ldr r3, [r6, #0]
10a770: 3301 adds r3, #1
10a772: 6033 str r3, [r6, #0]
10a774: 6123 str r3, [r4, #16]
rd->mctime = cpu_to_je32(time);
10a776: 9b10 ldr r3, [sp, #64] ; 0x40
rd->nsize = namelen;
10a778: f884 801c strb.w r8, [r4, #28]
rd->ino = cpu_to_je32(ino);
10a77c: f8c4 a014 str.w sl, [r4, #20]
rd->mctime = cpu_to_je32(time);
10a780: 61a3 str r3, [r4, #24]
rd->type = type;
10a782: f884 901d strb.w r9, [r4, #29]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
10a786: f000 fa99 bl 10acbc <cyg_crc32_accumulate>
rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
10a78a: 4642 mov r2, r8
10a78c: 990e ldr r1, [sp, #56] ; 0x38
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
10a78e: 6220 str r0, [r4, #32]
rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
10a790: 4628 mov r0, r5
10a792: f000 fa93 bl 10acbc <cyg_crc32_accumulate>
fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
10a796: 9b0e ldr r3, [sp, #56] ; 0x38
10a798: 4622 mov r2, r4
rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
10a79a: 6260 str r0, [r4, #36] ; 0x24
fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
10a79c: 4631 mov r1, r6
10a79e: f8cd 8000 str.w r8, [sp]
10a7a2: 4638 mov r0, r7
10a7a4: 9501 str r5, [sp, #4]
10a7a6: f7ff fc9b bl 10a0e0 <jffs2_write_dirent>
10a7aa: 4680 mov r8, r0
jffs2_free_raw_dirent(rd);
10a7ac: 4620 mov r0, r4
10a7ae: f7fc fec3 bl 107538 <jffs2_free_raw_dirent>
if (IS_ERR(fd)) {
10a7b2: f518 7f7a cmn.w r8, #1000 ; 0x3e8
10a7b6: d80c bhi.n 10a7d2 <jffs2_do_link+0xca> <== ALWAYS 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);
10a7b8: 4638 mov r0, r7
10a7ba: f106 020c add.w r2, r6, #12
10a7be: 4641 mov r1, r8
10a7c0: f7fc ff78 bl 1076b4 <jffs2_add_fd_to_list>
jffs2_complete_reservation(c);
10a7c4: 4638 mov r0, r7
10a7c6: f7fd fc5b bl 108080 <jffs2_complete_reservation>
mutex_unlock(&dir_f->sem);
return 0;
}
10a7ca: 4628 mov r0, r5
10a7cc: b005 add sp, #20
10a7ce: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
jffs2_complete_reservation(c);
10a7d2: 4638 mov r0, r7 <== NOT EXECUTED
return PTR_ERR(fd);
10a7d4: 4645 mov r5, r8 <== NOT EXECUTED
jffs2_complete_reservation(c);
10a7d6: f7fd fc53 bl 108080 <jffs2_complete_reservation> <== NOT EXECUTED
}
10a7da: 4628 mov r0, r5 <== NOT EXECUTED
10a7dc: b005 add sp, #20 <== NOT EXECUTED
10a7de: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
jffs2_free_raw_dirent(rd);
10a7e2: 4620 mov r0, r4 <== NOT EXECUTED
10a7e4: f7fc fea8 bl 107538 <jffs2_free_raw_dirent> <== NOT EXECUTED
}
10a7e8: 4628 mov r0, r5 <== NOT EXECUTED
10a7ea: b005 add sp, #20 <== NOT EXECUTED
10a7ec: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
return -ENOMEM;
10a7f0: f06f 050b mvn.w r5, #11 <== NOT EXECUTED
10a7f4: e7e9 b.n 10a7ca <jffs2_do_link+0xc2> <== NOT EXECUTED
10a7f6: bf00 nop
0010a868 <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)
{
10a868: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
10a86c: 4607 mov r7, r0
int ret;
int i;
int size;
c->free_size = c->flash_size;
c->nr_blocks = c->flash_size / c->sector_size;
10a86e: 6b44 ldr r4, [r0, #52] ; 0x34
{
10a870: b087 sub sp, #28
c->free_size = c->flash_size;
10a872: 6986 ldr r6, [r0, #24]
c->nr_blocks = c->flash_size / c->sector_size;
10a874: 4621 mov r1, r4
10a876: 4630 mov r0, r6
c->free_size = c->flash_size;
10a878: 62be str r6, [r7, #40] ; 0x28
c->nr_blocks = c->flash_size / c->sector_size;
10a87a: f009 fe71 bl 114560 <__udivsi3>
size = sizeof(struct jffs2_eraseblock) * c->nr_blocks;
10a87e: 2134 movs r1, #52 ; 0x34
c->nr_blocks = c->flash_size / c->sector_size;
10a880: 6538 str r0, [r7, #80] ; 0x50
#ifndef __ECOS
if (jffs2_blocks_use_vmalloc(c))
c->blocks = vzalloc(size);
else
#endif
c->blocks = kzalloc(size, GFP_KERNEL);
10a882: fb00 f101 mul.w r1, r0, r1
c->nr_blocks = c->flash_size / c->sector_size;
10a886: 4605 mov r5, r0
c->blocks = kzalloc(size, GFP_KERNEL);
10a888: 2001 movs r0, #1
10a88a: f001 ff39 bl 10c700 <calloc>
10a88e: 6578 str r0, [r7, #84] ; 0x54
if (!c->blocks)
10a890: 2800 cmp r0, #0
10a892: f000 820f beq.w 10acb4 <jffs2_do_mount_fs+0x44c> <== ALWAYS TAKEN
return -ENOMEM;
for (i=0; i<c->nr_blocks; i++) {
10a896: 42a6 cmp r6, r4
10a898: bf22 ittt cs
10a89a: 2200 movcs r2, #0
10a89c: 4603 movcs r3, r0
10a89e: 4611 movcs r1, r2
10a8a0: d309 bcc.n 10a8b6 <jffs2_do_mount_fs+0x4e> <== ALWAYS TAKEN
10a8a2: 3101 adds r1, #1
INIT_LIST_HEAD(&c->blocks[i].list);
c->blocks[i].offset = i * c->sector_size;
10a8a4: 60da str r2, [r3, #12]
for (i=0; i<c->nr_blocks; i++) {
10a8a6: 428d cmp r5, r1
INIT_LIST_HEAD(&c->blocks[i].list);
10a8a8: e9c3 3300 strd r3, r3, [r3]
c->blocks[i].free_size = c->sector_size;
10a8ac: 621c str r4, [r3, #32]
for (i=0; i<c->nr_blocks; i++) {
10a8ae: 4422 add r2, r4
10a8b0: f103 0334 add.w r3, r3, #52 ; 0x34
10a8b4: d8f5 bhi.n 10a8a2 <jffs2_do_mount_fs+0x3a>
}
INIT_LIST_HEAD(&c->clean_list);
INIT_LIST_HEAD(&c->very_dirty_list);
10a8b6: f107 0168 add.w r1, r7, #104 ; 0x68
INIT_LIST_HEAD(&c->clean_list);
10a8ba: f107 0060 add.w r0, r7, #96 ; 0x60
INIT_LIST_HEAD(&c->very_dirty_list);
10a8be: e9c7 111a strd r1, r1, [r7, #104] ; 0x68
INIT_LIST_HEAD(&c->dirty_list);
INIT_LIST_HEAD(&c->erasable_list);
INIT_LIST_HEAD(&c->erasing_list);
INIT_LIST_HEAD(&c->erase_checking_list);
10a8c2: f107 0190 add.w r1, r7, #144 ; 0x90
10a8c6: e9c7 1124 strd r1, r1, [r7, #144] ; 0x90
INIT_LIST_HEAD(&c->erase_pending_list);
INIT_LIST_HEAD(&c->erasable_pending_wbuf_list);
INIT_LIST_HEAD(&c->erase_complete_list);
INIT_LIST_HEAD(&c->free_list);
10a8ca: f107 01a8 add.w r1, r7, #168 ; 0xa8
10a8ce: e9c7 112a strd r1, r1, [r7, #168] ; 0xa8
INIT_LIST_HEAD(&c->dirty_list);
10a8d2: f107 0270 add.w r2, r7, #112 ; 0x70
c->flags |= JFFS2_SB_FLAG_SCANNING;
10a8d6: 68f9 ldr r1, [r7, #12]
INIT_LIST_HEAD(&c->erasable_list);
10a8d8: f107 0378 add.w r3, r7, #120 ; 0x78
INIT_LIST_HEAD(&c->clean_list);
10a8dc: e9c7 0018 strd r0, r0, [r7, #96] ; 0x60
INIT_LIST_HEAD(&c->erasing_list);
10a8e0: f107 0088 add.w r0, r7, #136 ; 0x88
INIT_LIST_HEAD(&c->dirty_list);
10a8e4: e9c7 221c strd r2, r2, [r7, #112] ; 0x70
INIT_LIST_HEAD(&c->erase_pending_list);
10a8e8: f107 0298 add.w r2, r7, #152 ; 0x98
INIT_LIST_HEAD(&c->erasable_list);
10a8ec: e9c7 331e strd r3, r3, [r7, #120] ; 0x78
INIT_LIST_HEAD(&c->erasable_pending_wbuf_list);
10a8f0: f107 0380 add.w r3, r7, #128 ; 0x80
INIT_LIST_HEAD(&c->erasing_list);
10a8f4: e9c7 0022 strd r0, r0, [r7, #136] ; 0x88
INIT_LIST_HEAD(&c->erase_complete_list);
10a8f8: f107 00a0 add.w r0, r7, #160 ; 0xa0
INIT_LIST_HEAD(&c->bad_list);
INIT_LIST_HEAD(&c->bad_used_list);
c->highest_ino = 1;
c->summary = NULL;
10a8fc: 2500 movs r5, #0
c->flags |= JFFS2_SB_FLAG_SCANNING;
10a8fe: f041 0102 orr.w r1, r1, #2
INIT_LIST_HEAD(&c->erase_pending_list);
10a902: e9c7 2226 strd r2, r2, [r7, #152] ; 0x98
INIT_LIST_HEAD(&c->bad_list);
10a906: f107 02b0 add.w r2, r7, #176 ; 0xb0
INIT_LIST_HEAD(&c->erasable_pending_wbuf_list);
10a90a: e9c7 3320 strd r3, r3, [r7, #128] ; 0x80
INIT_LIST_HEAD(&c->bad_used_list);
10a90e: f107 03b8 add.w r3, r7, #184 ; 0xb8
INIT_LIST_HEAD(&c->erase_complete_list);
10a912: e9c7 0028 strd r0, r0, [r7, #160] ; 0xa0
c->highest_ino = 1;
10a916: 2001 movs r0, #1
10a918: 6078 str r0, [r7, #4]
ret = jffs2_scan_medium(c);
10a91a: 4638 mov r0, r7
INIT_LIST_HEAD(&c->bad_list);
10a91c: f8c7 20b4 str.w r2, [r7, #180] ; 0xb4
10a920: f8c7 20b0 str.w r2, [r7, #176] ; 0xb0
INIT_LIST_HEAD(&c->bad_used_list);
10a924: e9c7 332e strd r3, r3, [r7, #184] ; 0xb8
c->summary = NULL;
10a928: f8c7 50cc str.w r5, [r7, #204] ; 0xcc
c->flags |= JFFS2_SB_FLAG_SCANNING;
10a92c: 60f9 str r1, [r7, #12]
struct jffs2_full_dirent *dead_fds = NULL;
10a92e: 9505 str r5, [sp, #20]
ret = jffs2_scan_medium(c);
10a930: f001 f8ca bl 10bac8 <jffs2_scan_medium>
c->flags &= ~JFFS2_SB_FLAG_SCANNING;
10a934: 68fa ldr r2, [r7, #12]
if (ret)
10a936: 9003 str r0, [sp, #12]
c->flags &= ~JFFS2_SB_FLAG_SCANNING;
10a938: f022 0202 bic.w r2, r2, #2
10a93c: 60fa str r2, [r7, #12]
if (ret)
10a93e: 2800 cmp r0, #0
10a940: f040 8164 bne.w 10ac0c <jffs2_do_mount_fs+0x3a4> <== ALWAYS TAKEN
for (; *i < c->inocache_hashsize; (*i)++) {
10a944: f8d7 30c0 ldr.w r3, [r7, #192] ; 0xc0
c->flags |= JFFS2_SB_FLAG_BUILDING;
10a948: f042 0204 orr.w r2, r2, #4
10a94c: 60fa str r2, [r7, #12]
for (; *i < c->inocache_hashsize; (*i)++) {
10a94e: 2b00 cmp r3, #0
10a950: f340 81ab ble.w 10acaa <jffs2_do_mount_fs+0x442> <== ALWAYS TAKEN
10a954: f8d7 20c4 ldr.w r2, [r7, #196] ; 0xc4
for_each_inode(i, c, ic) {
10a958: f8dd 900c ldr.w r9, [sp, #12]
10a95c: 3a04 subs r2, #4
10a95e: e003 b.n 10a968 <jffs2_do_mount_fs+0x100>
for (; *i < c->inocache_hashsize; (*i)++) {
10a960: f109 0901 add.w r9, r9, #1
10a964: 4599 cmp r9, r3
10a966: d003 beq.n 10a970 <jffs2_do_mount_fs+0x108>
if (c->inocache_list[*i])
10a968: f852 5f04 ldr.w r5, [r2, #4]!
10a96c: 2d00 cmp r5, #0
10a96e: d0f7 beq.n 10a960 <jffs2_do_mount_fs+0xf8> <== NEVER TAKEN
10a970: f04f 0800 mov.w r8, #0
for_each_inode(i, c, ic) {
10a974: 2d00 cmp r5, #0
10a976: f040 80a8 bne.w 10aaca <jffs2_do_mount_fs+0x262> <== ALWAYS TAKEN
for (; *i < c->inocache_hashsize; (*i)++) {
10a97a: 2b00 cmp r3, #0
10a97c: f340 8198 ble.w 10acb0 <jffs2_do_mount_fs+0x448> <== ALWAYS TAKEN
10a980: f8d7 20c4 ldr.w r2, [r7, #196] ; 0xc4
for_each_inode(i, c, ic) {
10a984: 2400 movs r4, #0
10a986: 3a04 subs r2, #4
10a988: e002 b.n 10a990 <jffs2_do_mount_fs+0x128>
for (; *i < c->inocache_hashsize; (*i)++) {
10a98a: 3401 adds r4, #1
10a98c: 429c cmp r4, r3
10a98e: d003 beq.n 10a998 <jffs2_do_mount_fs+0x130>
if (c->inocache_list[*i])
10a990: f852 5f04 ldr.w r5, [r2, #4]!
10a994: 2d00 cmp r5, #0
10a996: d0f8 beq.n 10a98a <jffs2_do_mount_fs+0x122> <== NEVER TAKEN
for_each_inode(i, c, ic) {
10a998: 2d00 cmp r5, #0
10a99a: f040 80c8 bne.w 10ab2e <jffs2_do_mount_fs+0x2c6> <== ALWAYS TAKEN
while (dead_fds) {
10a99e: 9c05 ldr r4, [sp, #20]
10a9a0: b19c cbz r4, 10a9ca <jffs2_do_mount_fs+0x162>
dead_fds = fd->next;
10a9a2: 6863 ldr r3, [r4, #4] <== NOT EXECUTED
ic = jffs2_get_ino_cache(c, fd->ino);
10a9a4: 4638 mov r0, r7 <== NOT EXECUTED
10a9a6: 68e1 ldr r1, [r4, #12] <== NOT EXECUTED
dead_fds = fd->next;
10a9a8: 9305 str r3, [sp, #20] <== NOT EXECUTED
ic = jffs2_get_ino_cache(c, fd->ino);
10a9aa: f7fd f8b9 bl 107b20 <jffs2_get_ino_cache> <== NOT EXECUTED
if (ic)
10a9ae: 4601 mov r1, r0 <== NOT EXECUTED
10a9b0: b118 cbz r0, 10a9ba <jffs2_do_mount_fs+0x152> <== NOT EXECUTED
jffs2_build_remove_unlinked_inode(c, ic, &dead_fds);
10a9b2: aa05 add r2, sp, #20 <== NOT EXECUTED
10a9b4: 4638 mov r0, r7 <== NOT EXECUTED
10a9b6: f7ff ff1f bl 10a7f8 <jffs2_build_remove_unlinked_inode> <== NOT EXECUTED
jffs2_free_full_dirent(fd);
10a9ba: 4620 mov r0, r4 <== NOT EXECUTED
10a9bc: f7fc fdb0 bl 107520 <jffs2_free_full_dirent> <== NOT EXECUTED
while (dead_fds) {
10a9c0: 9c05 ldr r4, [sp, #20] <== NOT EXECUTED
10a9c2: 2c00 cmp r4, #0 <== NOT EXECUTED
10a9c4: d1ed bne.n 10a9a2 <jffs2_do_mount_fs+0x13a> <== NOT EXECUTED
10a9c6: f8d7 30c0 ldr.w r3, [r7, #192] ; 0xc0 <== NOT EXECUTED
if (dir_hardlinks) {
10a9ca: f1b8 0f00 cmp.w r8, #0
10a9ce: d014 beq.n 10a9fa <jffs2_do_mount_fs+0x192> <== NEVER TAKEN
for (; *i < c->inocache_hashsize; (*i)++) {
10a9d0: 2b00 cmp r3, #0 <== NOT EXECUTED
for_each_inode(i, c, ic) {
10a9d2: bfdc itt le <== NOT EXECUTED
10a9d4: 2200 movle r2, #0 <== NOT EXECUTED
return NULL;
10a9d6: 4611 movle r1, r2 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10a9d8: dd0b ble.n 10a9f2 <jffs2_do_mount_fs+0x18a> <== NOT EXECUTED
10a9da: f8d7 00c4 ldr.w r0, [r7, #196] ; 0xc4 <== NOT EXECUTED
for_each_inode(i, c, ic) {
10a9de: 2200 movs r2, #0 <== NOT EXECUTED
10a9e0: 3804 subs r0, #4 <== NOT EXECUTED
10a9e2: e002 b.n 10a9ea <jffs2_do_mount_fs+0x182> <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10a9e4: 3201 adds r2, #1 <== NOT EXECUTED
10a9e6: 429a cmp r2, r3 <== NOT EXECUTED
10a9e8: d003 beq.n 10a9f2 <jffs2_do_mount_fs+0x18a> <== NOT EXECUTED
if (c->inocache_list[*i])
10a9ea: f850 1f04 ldr.w r1, [r0, #4]! <== NOT EXECUTED
10a9ee: 2900 cmp r1, #0 <== NOT EXECUTED
10a9f0: d0f8 beq.n 10a9e4 <jffs2_do_mount_fs+0x17c> <== NOT EXECUTED
ic->pino_nlink = 0;
10a9f2: 2400 movs r4, #0 <== NOT EXECUTED
for_each_inode(i, c, ic) {
10a9f4: 2900 cmp r1, #0 <== NOT EXECUTED
10a9f6: f040 80f3 bne.w 10abe0 <jffs2_do_mount_fs+0x378> <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10a9fa: 2b00 cmp r3, #0
10a9fc: bfd8 it le
10a9fe: 2600 movle r6, #0
10aa00: dd0b ble.n 10aa1a <jffs2_do_mount_fs+0x1b2> <== ALWAYS TAKEN
10aa02: f8d7 20c4 ldr.w r2, [r7, #196] ; 0xc4
if (c->inocache_list[*i])
10aa06: 2600 movs r6, #0
10aa08: 3a04 subs r2, #4
10aa0a: e002 b.n 10aa12 <jffs2_do_mount_fs+0x1aa>
for (; *i < c->inocache_hashsize; (*i)++) {
10aa0c: 3601 adds r6, #1
10aa0e: 429e cmp r6, r3
10aa10: d003 beq.n 10aa1a <jffs2_do_mount_fs+0x1b2>
if (c->inocache_list[*i])
10aa12: f852 5f04 ldr.w r5, [r2, #4]!
10aa16: 2d00 cmp r5, #0
10aa18: d0f8 beq.n 10aa0c <jffs2_do_mount_fs+0x1a4> <== NEVER TAKEN
JFFS2_ERROR("child dir \"%s\" (ino #%u) of dir ino #%u is also hard linked from dir ino #%u\n",
10aa1a: f248 3a04 movw sl, #33540 ; 0x8304
10aa1e: f248 2b74 movw fp, #33396 ; 0x8274
10aa22: f2c0 0a11 movt sl, #17
10aa26: f2c0 0b11 movt fp, #17
for_each_inode(i, c, ic) {
10aa2a: 2d00 cmp r5, #0
10aa2c: f040 8090 bne.w 10ab50 <jffs2_do_mount_fs+0x2e8> <== ALWAYS TAKEN
c->flags &= ~JFFS2_SB_FLAG_BUILDING;
10aa30: 68fb ldr r3, [r7, #12]
jffs2_rotate_lists(c);
10aa32: 4638 mov r0, r7
c->flags &= ~JFFS2_SB_FLAG_BUILDING;
10aa34: f023 0304 bic.w r3, r3, #4
10aa38: 60fb str r3, [r7, #12]
jffs2_rotate_lists(c);
10aa3a: f001 fcf9 bl 10c430 <jffs2_rotate_lists>
size = c->flash_size / 50; /* 2% of flash size */
10aa3e: 69be ldr r6, [r7, #24]
c->resv_blocks_deletion = 2;
10aa40: 2302 movs r3, #2
10aa42: f887 3045 strb.w r3, [r7, #69] ; 0x45
size = c->flash_size / 50; /* 2% of flash size */
10aa46: f248 531f movw r3, #34079 ; 0x851f
10aa4a: f2c5 13eb movt r3, #20971 ; 0x51eb
size += c->sector_size - 1; /* ... and round up */
10aa4e: 6b7c ldr r4, [r7, #52] ; 0x34
size += c->nr_blocks * 100; /* And 100 bytes per eraseblock */
10aa50: 6d3a ldr r2, [r7, #80] ; 0x50
10aa52: 2064 movs r0, #100 ; 0x64
size = c->flash_size / 50; /* 2% of flash size */
10aa54: fba3 3606 umull r3, r6, r3, r6
10aa58: 1e63 subs r3, r4, #1
c->resv_blocks_write = c->resv_blocks_deletion + (size / c->sector_size);
10aa5a: 4621 mov r1, r4
10aa5c: eb03 1316 add.w r3, r3, r6, lsr #4
c->nospc_dirty_size = c->sector_size + (c->flash_size / 100);
10aa60: eb04 1456 add.w r4, r4, r6, lsr #5
c->resv_blocks_write = c->resv_blocks_deletion + (size / c->sector_size);
10aa64: fb00 3002 mla r0, r0, r2, r3
10aa68: f009 fd7a bl 114560 <__udivsi3>
10aa6c: b2c2 uxtb r2, r0
c->resv_blocks_gcmerge = c->resv_blocks_deletion + 1;
10aa6e: 2303 movs r3, #3
10aa70: f887 3048 strb.w r3, [r7, #72] ; 0x48
c->resv_blocks_gctrigger = c->resv_blocks_write + 1;
10aa74: 18d3 adds r3, r2, r3
c->resv_blocks_write = c->resv_blocks_deletion + (size / c->sector_size);
10aa76: 3202 adds r2, #2
c->resv_blocks_gctrigger = c->resv_blocks_write + 1;
10aa78: b2db uxtb r3, r3
c->resv_blocks_gcbad = 0;//c->resv_blocks_deletion + 2;
10aa7a: f887 5047 strb.w r5, [r7, #71] ; 0x47
c->nospc_dirty_size = c->sector_size + (c->flash_size / 100);
10aa7e: 64fc str r4, [r7, #76] ; 0x4c
c->resv_blocks_gctrigger = c->resv_blocks_write + 1;
10aa80: f887 3046 strb.w r3, [r7, #70] ; 0x46
c->vdirty_blocks_gctrigger *= 10;
10aa84: eb03 0383 add.w r3, r3, r3, lsl #2
c->resv_blocks_write = c->resv_blocks_deletion + (size / c->sector_size);
10aa88: f887 2044 strb.w r2, [r7, #68] ; 0x44
c->vdirty_blocks_gctrigger *= 10;
10aa8c: 005b lsls r3, r3, #1
10aa8e: f887 3049 strb.w r3, [r7, #73] ; 0x49
out_free:
kvfree(c->blocks);
return ret;
}
10aa92: 9803 ldr r0, [sp, #12]
10aa94: b007 add sp, #28
10aa96: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if (ic->next)
10aa9a: 692d ldr r5, [r5, #16] <== NOT EXECUTED
10aa9c: b9ad cbnz r5, 10aaca <jffs2_do_mount_fs+0x262> <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10aa9e: f8d7 30c0 ldr.w r3, [r7, #192] ; 0xc0 <== NOT EXECUTED
(*i)++;
10aaa2: f109 0101 add.w r1, r9, #1 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10aaa6: 4299 cmp r1, r3 <== NOT EXECUTED
10aaa8: f6bf af67 bge.w 10a97a <jffs2_do_mount_fs+0x112> <== NOT EXECUTED
10aaac: f8d7 20c4 ldr.w r2, [r7, #196] ; 0xc4 <== NOT EXECUTED
10aab0: eb02 0289 add.w r2, r2, r9, lsl #2 <== NOT EXECUTED
if (c->inocache_list[*i])
10aab4: 4689 mov r9, r1 <== NOT EXECUTED
10aab6: e004 b.n 10aac2 <jffs2_do_mount_fs+0x25a> <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10aab8: f109 0901 add.w r9, r9, #1 <== NOT EXECUTED
10aabc: 4599 cmp r9, r3 <== NOT EXECUTED
10aabe: f43f af5c beq.w 10a97a <jffs2_do_mount_fs+0x112> <== NOT EXECUTED
if (c->inocache_list[*i])
10aac2: f852 5f04 ldr.w r5, [r2, #4]! <== NOT EXECUTED
10aac6: 2d00 cmp r5, #0 <== NOT EXECUTED
10aac8: d0f6 beq.n 10aab8 <jffs2_do_mount_fs+0x250> <== NOT EXECUTED
if (ic->scan_dents) {
10aaca: 682c ldr r4, [r5, #0] <== NOT EXECUTED
10aacc: 2c00 cmp r4, #0 <== NOT EXECUTED
10aace: d0e4 beq.n 10aa9a <jffs2_do_mount_fs+0x232> <== NOT EXECUTED
if (!fd->ino)
10aad0: 68e1 ldr r1, [r4, #12] <== NOT EXECUTED
10aad2: b1a1 cbz r1, 10aafe <jffs2_do_mount_fs+0x296> <== NOT EXECUTED
child_ic = jffs2_get_ino_cache(c, fd->ino);
10aad4: 4638 mov r0, r7 <== NOT EXECUTED
10aad6: f7fd f823 bl 107b20 <jffs2_get_ino_cache> <== NOT EXECUTED
if (!child_ic) {
10aada: 4606 mov r6, r0 <== NOT EXECUTED
10aadc: 2800 cmp r0, #0 <== NOT EXECUTED
10aade: d031 beq.n 10ab44 <jffs2_do_mount_fs+0x2dc> <== NOT EXECUTED
child_ic->pino_nlink++;
10aae0: 6943 ldr r3, [r0, #20] <== NOT EXECUTED
fd->ic = child_ic;
10aae2: 6020 str r0, [r4, #0] <== NOT EXECUTED
child_ic->pino_nlink++;
10aae4: 3301 adds r3, #1 <== NOT EXECUTED
10aae6: 6143 str r3, [r0, #20] <== NOT EXECUTED
if (fd->type == DT_DIR) {
10aae8: 7d22 ldrb r2, [r4, #20] <== NOT EXECUTED
10aaea: 2a04 cmp r2, #4 <== NOT EXECUTED
10aaec: d107 bne.n 10aafe <jffs2_do_mount_fs+0x296> <== NOT EXECUTED
child_ic->flags |= INO_FLAGS_IS_DIR;
10aaee: 7a42 ldrb r2, [r0, #9] <== NOT EXECUTED
*dir_hardlinks = 1;
10aaf0: 2b02 cmp r3, #2 <== NOT EXECUTED
10aaf2: bf28 it cs <== NOT EXECUTED
10aaf4: f04f 0801 movcs.w r8, #1 <== NOT EXECUTED
child_ic->flags |= INO_FLAGS_IS_DIR;
10aaf8: f042 0302 orr.w r3, r2, #2 <== NOT EXECUTED
10aafc: 7243 strb r3, [r0, #9] <== NOT EXECUTED
for(fd = ic->scan_dents; fd; fd = fd->next) {
10aafe: 6864 ldr r4, [r4, #4] <== NOT EXECUTED
10ab00: 2c00 cmp r4, #0 <== NOT EXECUTED
10ab02: d1e5 bne.n 10aad0 <jffs2_do_mount_fs+0x268> <== NOT EXECUTED
10ab04: e7c9 b.n 10aa9a <jffs2_do_mount_fs+0x232> <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10ab06: f8d7 30c0 ldr.w r3, [r7, #192] ; 0xc0 <== NOT EXECUTED
(*i)++;
10ab0a: 1c61 adds r1, r4, #1 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10ab0c: 4299 cmp r1, r3 <== NOT EXECUTED
10ab0e: f6bf af46 bge.w 10a99e <jffs2_do_mount_fs+0x136> <== NOT EXECUTED
10ab12: f8d7 20c4 ldr.w r2, [r7, #196] ; 0xc4 <== NOT EXECUTED
10ab16: eb02 0284 add.w r2, r2, r4, lsl #2 <== NOT EXECUTED
if (c->inocache_list[*i])
10ab1a: 460c mov r4, r1 <== NOT EXECUTED
10ab1c: e003 b.n 10ab26 <jffs2_do_mount_fs+0x2be> <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10ab1e: 3401 adds r4, #1 <== NOT EXECUTED
10ab20: 429c cmp r4, r3 <== NOT EXECUTED
10ab22: f43f af3c beq.w 10a99e <jffs2_do_mount_fs+0x136> <== NOT EXECUTED
if (c->inocache_list[*i])
10ab26: f852 5f04 ldr.w r5, [r2, #4]! <== NOT EXECUTED
10ab2a: 2d00 cmp r5, #0 <== NOT EXECUTED
10ab2c: d0f7 beq.n 10ab1e <jffs2_do_mount_fs+0x2b6> <== NOT EXECUTED
if (ic->pino_nlink)
10ab2e: 696b ldr r3, [r5, #20] <== NOT EXECUTED
10ab30: b923 cbnz r3, 10ab3c <jffs2_do_mount_fs+0x2d4> <== NOT EXECUTED
jffs2_build_remove_unlinked_inode(c, ic, &dead_fds);
10ab32: aa05 add r2, sp, #20 <== NOT EXECUTED
10ab34: 4629 mov r1, r5 <== NOT EXECUTED
10ab36: 4638 mov r0, r7 <== NOT EXECUTED
10ab38: f7ff fe5e bl 10a7f8 <jffs2_build_remove_unlinked_inode> <== NOT EXECUTED
if (ic->next)
10ab3c: 692d ldr r5, [r5, #16] <== NOT EXECUTED
10ab3e: 2d00 cmp r5, #0 <== NOT EXECUTED
10ab40: d1f5 bne.n 10ab2e <jffs2_do_mount_fs+0x2c6> <== NOT EXECUTED
10ab42: e7e0 b.n 10ab06 <jffs2_do_mount_fs+0x29e> <== NOT EXECUTED
jffs2_mark_node_obsolete(c, fd->raw);
10ab44: 6821 ldr r1, [r4, #0] <== NOT EXECUTED
10ab46: 4638 mov r0, r7 <== NOT EXECUTED
10ab48: f7fd faa0 bl 10808c <jffs2_mark_node_obsolete> <== NOT EXECUTED
fd->ic = NULL;
10ab4c: 6026 str r6, [r4, #0] <== NOT EXECUTED
continue;
10ab4e: e7d6 b.n 10aafe <jffs2_do_mount_fs+0x296> <== NOT EXECUTED
10ab50: 46b9 mov r9, r7 <== NOT EXECUTED
10ab52: 4647 mov r7, r8 <== NOT EXECUTED
ic->scan_dents = NULL;
10ab54: f04f 0800 mov.w r8, #0 <== NOT EXECUTED
while(ic->scan_dents) {
10ab58: 682c ldr r4, [r5, #0] <== NOT EXECUTED
10ab5a: b1bc cbz r4, 10ab8c <jffs2_do_mount_fs+0x324> <== NOT EXECUTED
ic->scan_dents = fd->next;
10ab5c: 6862 ldr r2, [r4, #4] <== NOT EXECUTED
10ab5e: 602a str r2, [r5, #0] <== NOT EXECUTED
if (fd->type == DT_DIR) {
10ab60: 7d23 ldrb r3, [r4, #20] <== NOT EXECUTED
10ab62: 2b04 cmp r3, #4 <== NOT EXECUTED
10ab64: d10c bne.n 10ab80 <jffs2_do_mount_fs+0x318> <== NOT EXECUTED
if (!fd->ic) {
10ab66: 6823 ldr r3, [r4, #0] <== NOT EXECUTED
10ab68: 2b00 cmp r3, #0 <== NOT EXECUTED
10ab6a: d041 beq.n 10abf0 <jffs2_do_mount_fs+0x388> <== NOT EXECUTED
BUG_ON(!(fd->ic->flags & INO_FLAGS_IS_DIR));
10ab6c: 7a5a ldrb r2, [r3, #9] <== NOT EXECUTED
10ab6e: 0792 lsls r2, r2, #30 <== NOT EXECUTED
10ab70: f140 808c bpl.w 10ac8c <jffs2_do_mount_fs+0x424> <== NOT EXECUTED
JFFS2_ERROR("child dir \"%s\" (ino #%u) of dir ino #%u is also hard linked from dir ino #%u\n",
10ab74: 68e9 ldr r1, [r5, #12] <== NOT EXECUTED
if (dir_hardlinks && fd->ic->pino_nlink) {
10ab76: b117 cbz r7, 10ab7e <jffs2_do_mount_fs+0x316> <== NOT EXECUTED
10ab78: 6958 ldr r0, [r3, #20] <== NOT EXECUTED
10ab7a: 2800 cmp r0, #0 <== NOT EXECUTED
10ab7c: d13a bne.n 10abf4 <jffs2_do_mount_fs+0x38c> <== NOT EXECUTED
fd->ic->pino_nlink = ic->ino;
10ab7e: 6159 str r1, [r3, #20] <== NOT EXECUTED
jffs2_free_full_dirent(fd);
10ab80: 4620 mov r0, r4 <== NOT EXECUTED
10ab82: f7fc fccd bl 107520 <jffs2_free_full_dirent> <== NOT EXECUTED
while(ic->scan_dents) {
10ab86: 682c ldr r4, [r5, #0] <== NOT EXECUTED
10ab88: 2c00 cmp r4, #0 <== NOT EXECUTED
10ab8a: d1e7 bne.n 10ab5c <jffs2_do_mount_fs+0x2f4> <== NOT EXECUTED
ic->scan_dents = NULL;
10ab8c: f8c5 8000 str.w r8, [r5] <== NOT EXECUTED
if (ic->next)
10ab90: 692d ldr r5, [r5, #16] <== NOT EXECUTED
10ab92: 2d00 cmp r5, #0 <== NOT EXECUTED
10ab94: d1e0 bne.n 10ab58 <jffs2_do_mount_fs+0x2f0> <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10ab96: f8d9 20c0 ldr.w r2, [r9, #192] ; 0xc0 <== NOT EXECUTED
(*i)++;
10ab9a: 1c71 adds r1, r6, #1 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10ab9c: 4291 cmp r1, r2 <== NOT EXECUTED
10ab9e: da0b bge.n 10abb8 <jffs2_do_mount_fs+0x350> <== NOT EXECUTED
10aba0: f8d9 30c4 ldr.w r3, [r9, #196] ; 0xc4 <== NOT EXECUTED
10aba4: eb03 0386 add.w r3, r3, r6, lsl #2 <== NOT EXECUTED
if (c->inocache_list[*i])
10aba8: 460e mov r6, r1 <== NOT EXECUTED
10abaa: f853 5f04 ldr.w r5, [r3, #4]! <== NOT EXECUTED
10abae: 2d00 cmp r5, #0 <== NOT EXECUTED
10abb0: d1d0 bne.n 10ab54 <jffs2_do_mount_fs+0x2ec> <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10abb2: 3601 adds r6, #1 <== NOT EXECUTED
10abb4: 4296 cmp r6, r2 <== NOT EXECUTED
10abb6: d1f8 bne.n 10abaa <jffs2_do_mount_fs+0x342> <== NOT EXECUTED
10abb8: 464f mov r7, r9 <== NOT EXECUTED
10abba: e739 b.n 10aa30 <jffs2_do_mount_fs+0x1c8> <== NOT EXECUTED
(*i)++;
10abbc: 1c51 adds r1, r2, #1 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10abbe: 4299 cmp r1, r3 <== NOT EXECUTED
10abc0: f6bf af1b bge.w 10a9fa <jffs2_do_mount_fs+0x192> <== NOT EXECUTED
10abc4: f8d7 00c4 ldr.w r0, [r7, #196] ; 0xc4 <== NOT EXECUTED
10abc8: eb00 0082 add.w r0, r0, r2, lsl #2 <== NOT EXECUTED
if (c->inocache_list[*i])
10abcc: 460a mov r2, r1 <== NOT EXECUTED
10abce: e003 b.n 10abd8 <jffs2_do_mount_fs+0x370> <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10abd0: 3201 adds r2, #1 <== NOT EXECUTED
10abd2: 429a cmp r2, r3 <== NOT EXECUTED
10abd4: f43f af11 beq.w 10a9fa <jffs2_do_mount_fs+0x192> <== NOT EXECUTED
if (c->inocache_list[*i])
10abd8: f850 1f04 ldr.w r1, [r0, #4]! <== NOT EXECUTED
10abdc: 2900 cmp r1, #0 <== NOT EXECUTED
10abde: d0f7 beq.n 10abd0 <jffs2_do_mount_fs+0x368> <== NOT EXECUTED
if (ic->flags & INO_FLAGS_IS_DIR)
10abe0: 7a48 ldrb r0, [r1, #9] <== NOT EXECUTED
10abe2: 0780 lsls r0, r0, #30 <== NOT EXECUTED
ic->pino_nlink = 0;
10abe4: bf48 it mi <== NOT EXECUTED
10abe6: 614c strmi r4, [r1, #20] <== NOT EXECUTED
if (ic->next)
10abe8: 6909 ldr r1, [r1, #16] <== NOT EXECUTED
10abea: 2900 cmp r1, #0 <== NOT EXECUTED
10abec: d1f8 bne.n 10abe0 <jffs2_do_mount_fs+0x378> <== NOT EXECUTED
10abee: e7e5 b.n 10abbc <jffs2_do_mount_fs+0x354> <== NOT EXECUTED
10abf0: 4614 mov r4, r2 <== NOT EXECUTED
10abf2: e7b2 b.n 10ab5a <jffs2_do_mount_fs+0x2f2> <== NOT EXECUTED
JFFS2_ERROR("child dir \"%s\" (ino #%u) of dir ino #%u is also hard linked from dir ino #%u\n",
10abf4: 68e3 ldr r3, [r4, #12] <== NOT EXECUTED
10abf6: f104 0215 add.w r2, r4, #21 <== NOT EXECUTED
10abfa: e9cd 1000 strd r1, r0, [sp] <== NOT EXECUTED
10abfe: 4651 mov r1, sl <== NOT EXECUTED
10ac00: 4658 mov r0, fp <== NOT EXECUTED
10ac02: f7ff fe21 bl 10a848 <jffs2_printk.constprop.0> <== NOT EXECUTED
fd->ic->pino_nlink = ic->ino;
10ac06: 6823 ldr r3, [r4, #0] <== NOT EXECUTED
10ac08: 68e9 ldr r1, [r5, #12] <== NOT EXECUTED
10ac0a: e7b8 b.n 10ab7e <jffs2_do_mount_fs+0x316> <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10ac0c: f8d7 20c0 ldr.w r2, [r7, #192] ; 0xc0 <== NOT EXECUTED
10ac10: 2a00 cmp r2, #0 <== NOT EXECUTED
return NULL;
10ac12: bfd8 it le <== NOT EXECUTED
10ac14: 462c movle r4, r5 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10ac16: dd36 ble.n 10ac86 <jffs2_do_mount_fs+0x41e> <== NOT EXECUTED
10ac18: f8d7 30c4 ldr.w r3, [r7, #196] ; 0xc4 <== NOT EXECUTED
10ac1c: 3b04 subs r3, #4 <== NOT EXECUTED
10ac1e: e002 b.n 10ac26 <jffs2_do_mount_fs+0x3be> <== NOT EXECUTED
10ac20: 3501 adds r5, #1 <== NOT EXECUTED
10ac22: 4295 cmp r5, r2 <== NOT EXECUTED
10ac24: d02f beq.n 10ac86 <jffs2_do_mount_fs+0x41e> <== NOT EXECUTED
if (c->inocache_list[*i])
10ac26: f853 4f04 ldr.w r4, [r3, #4]! <== NOT EXECUTED
10ac2a: 2c00 cmp r4, #0 <== NOT EXECUTED
10ac2c: d0f8 beq.n 10ac20 <jffs2_do_mount_fs+0x3b8> <== NOT EXECUTED
10ac2e: e003 b.n 10ac38 <jffs2_do_mount_fs+0x3d0> <== NOT EXECUTED
ic->scan_dents = fd->next;
10ac30: 6843 ldr r3, [r0, #4] <== NOT EXECUTED
10ac32: 6023 str r3, [r4, #0] <== NOT EXECUTED
jffs2_free_full_dirent(fd);
10ac34: f7fc fc74 bl 107520 <jffs2_free_full_dirent> <== NOT EXECUTED
while(ic->scan_dents) {
10ac38: 6820 ldr r0, [r4, #0] <== NOT EXECUTED
10ac3a: 2800 cmp r0, #0 <== NOT EXECUTED
10ac3c: d1f8 bne.n 10ac30 <jffs2_do_mount_fs+0x3c8> <== NOT EXECUTED
if (ic->next)
10ac3e: 6924 ldr r4, [r4, #16] <== NOT EXECUTED
10ac40: 2c00 cmp r4, #0 <== NOT EXECUTED
10ac42: d1f9 bne.n 10ac38 <jffs2_do_mount_fs+0x3d0> <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10ac44: f8d7 20c0 ldr.w r2, [r7, #192] ; 0xc0 <== NOT EXECUTED
(*i)++;
10ac48: 1c69 adds r1, r5, #1 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10ac4a: 428a cmp r2, r1 <== NOT EXECUTED
10ac4c: dd0b ble.n 10ac66 <jffs2_do_mount_fs+0x3fe> <== NOT EXECUTED
10ac4e: f8d7 30c4 ldr.w r3, [r7, #196] ; 0xc4 <== NOT EXECUTED
10ac52: eb03 0385 add.w r3, r3, r5, lsl #2 <== NOT EXECUTED
if (c->inocache_list[*i])
10ac56: 460d mov r5, r1 <== NOT EXECUTED
10ac58: f853 4f04 ldr.w r4, [r3, #4]! <== NOT EXECUTED
10ac5c: 2c00 cmp r4, #0 <== NOT EXECUTED
10ac5e: d1eb bne.n 10ac38 <jffs2_do_mount_fs+0x3d0> <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
10ac60: 3501 adds r5, #1 <== NOT EXECUTED
10ac62: 42aa cmp r2, r5 <== NOT EXECUTED
10ac64: d1f8 bne.n 10ac58 <jffs2_do_mount_fs+0x3f0> <== NOT EXECUTED
return ret;
10ac66: f06f 0304 mvn.w r3, #4 <== NOT EXECUTED
jffs2_free_ino_caches(c);
10ac6a: 4638 mov r0, r7 <== NOT EXECUTED
return ret;
10ac6c: 9303 str r3, [sp, #12] <== NOT EXECUTED
jffs2_free_ino_caches(c);
10ac6e: f7fc ffb5 bl 107bdc <jffs2_free_ino_caches> <== NOT EXECUTED
jffs2_free_raw_node_refs(c);
10ac72: 4638 mov r0, r7 <== NOT EXECUTED
10ac74: f7fc ffd4 bl 107c20 <jffs2_free_raw_node_refs> <== NOT EXECUTED
kvfree(c->blocks);
10ac78: 6d78 ldr r0, [r7, #84] ; 0x54 <== NOT EXECUTED
10ac7a: f001 fe35 bl 10c8e8 <free> <== NOT EXECUTED
}
10ac7e: 9803 ldr r0, [sp, #12] <== NOT EXECUTED
10ac80: b007 add sp, #28 <== NOT EXECUTED
10ac82: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
for_each_inode(i, c, ic) {
10ac86: 2c00 cmp r4, #0 <== NOT EXECUTED
10ac88: d0ed beq.n 10ac66 <jffs2_do_mount_fs+0x3fe> <== NOT EXECUTED
10ac8a: e7d5 b.n 10ac38 <jffs2_do_mount_fs+0x3d0> <== NOT EXECUTED
BUG_ON(!(fd->ic->flags & INO_FLAGS_IS_DIR));
10ac8c: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
10ac90: f248 3204 movw r2, #33540 ; 0x8304 <== NOT EXECUTED
10ac94: f248 20d8 movw r0, #33496 ; 0x82d8 <== NOT EXECUTED
10ac98: f2c0 0311 movt r3, #17 <== NOT EXECUTED
10ac9c: f2c0 0211 movt r2, #17 <== NOT EXECUTED
10aca0: 21c4 movs r1, #196 ; 0xc4 <== NOT EXECUTED
10aca2: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10aca6: f001 fce3 bl 10c670 <__assert_func> <== NOT EXECUTED
for_each_inode(i, c, ic) {
10acaa: 9d03 ldr r5, [sp, #12] <== NOT EXECUTED
10acac: 46a9 mov r9, r5 <== NOT EXECUTED
10acae: e65f b.n 10a970 <jffs2_do_mount_fs+0x108> <== NOT EXECUTED
for_each_inode(i, c, ic) {
10acb0: 2400 movs r4, #0 <== NOT EXECUTED
10acb2: e671 b.n 10a998 <jffs2_do_mount_fs+0x130> <== NOT EXECUTED
return -ENOMEM;
10acb4: f06f 030b mvn.w r3, #11 <== NOT EXECUTED
10acb8: 9303 str r3, [sp, #12] <== NOT EXECUTED
10acba: e6ea b.n 10aa92 <jffs2_do_mount_fs+0x22a> <== NOT EXECUTED
00109e3c <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)
{
109e3c: e92d 43f8 stmdb sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
109e40: 4605 mov r5, r0
109e42: 460e mov r6, r1
109e44: 4617 mov r7, r2
109e46: 461c mov r4, r3
struct jffs2_inode_cache *ic;
ic = jffs2_alloc_inode_cache();
109e48: f7fd fbc8 bl 1075dc <jffs2_alloc_inode_cache>
if (!ic) {
109e4c: b3c0 cbz r0, 109ec0 <jffs2_do_new_inode+0x84>
return -ENOMEM;
}
memset(ic, 0, sizeof(*ic));
109e4e: 4601 mov r1, r0
f->inocache = ic;
f->inocache->pino_nlink = 1; /* Will be overwritten shortly for directories */
109e50: f04f 0801 mov.w r8, #1
f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
f->inocache->state = INO_STATE_PRESENT;
jffs2_add_ino_cache(c, f->inocache);
109e54: 4628 mov r0, r5
f->inocache->state = INO_STATE_PRESENT;
109e56: f04f 0902 mov.w r9, #2
memset(ic, 0, sizeof(*ic));
109e5a: 2500 movs r5, #0
109e5c: 608d str r5, [r1, #8]
109e5e: 600d str r5, [r1, #0]
109e60: 60cd str r5, [r1, #12]
109e62: 610d str r5, [r1, #16]
f->inocache = ic;
109e64: 6171 str r1, [r6, #20]
f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
109e66: 6049 str r1, [r1, #4]
f->inocache->pino_nlink = 1; /* Will be overwritten shortly for directories */
109e68: f8c1 8014 str.w r8, [r1, #20]
f->inocache->state = INO_STATE_PRESENT;
109e6c: f8a1 900a strh.w r9, [r1, #10]
jffs2_add_ino_cache(c, f->inocache);
109e70: f7fd fe6c bl 107b4c <jffs2_add_ino_cache>
jffs2_dbg(1, "%s(): Assigned ino# %d\n", __func__, f->inocache->ino);
ri->ino = cpu_to_je32(f->inocache->ino);
109e74: 6973 ldr r3, [r6, #20]
ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
ri->totlen = cpu_to_je32(PAD(sizeof(*ri)));
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
109e76: 2208 movs r2, #8
109e78: 4621 mov r1, r4
109e7a: 4628 mov r0, r5
ri->ino = cpu_to_je32(f->inocache->ino);
109e7c: 68db ldr r3, [r3, #12]
ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
109e7e: f884 9002 strb.w r9, [r4, #2]
ri->totlen = cpu_to_je32(PAD(sizeof(*ri)));
109e82: 7165 strb r5, [r4, #5]
ri->ino = cpu_to_je32(f->inocache->ino);
109e84: 60e3 str r3, [r4, #12]
ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
109e86: f06f 037a mvn.w r3, #122 ; 0x7a
109e8a: 7023 strb r3, [r4, #0]
109e8c: 2319 movs r3, #25
109e8e: 7063 strb r3, [r4, #1]
ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
109e90: f06f 031f mvn.w r3, #31
109e94: 70e3 strb r3, [r4, #3]
ri->totlen = cpu_to_je32(PAD(sizeof(*ri)));
109e96: 2344 movs r3, #68 ; 0x44
109e98: 71a5 strb r5, [r4, #6]
109e9a: 71e5 strb r5, [r4, #7]
109e9c: 7123 strb r3, [r4, #4]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
109e9e: f000 ff0d bl 10acbc <cyg_crc32_accumulate>
return osmode & (S_IFMT | S_IRWXU | S_IRWXG | S_IRWXO);
109ea2: f24f 12ff movw r2, #61951 ; 0xf1ff
109ea6: 60a0 str r0, [r4, #8]
ri->mode = cpu_to_jemode(mode);
f->highest_version = 1;
ri->version = cpu_to_je32(f->highest_version);
return 0;
109ea8: 4628 mov r0, r5
109eaa: 4017 ands r7, r2
ri->mode = cpu_to_jemode(mode);
109eac: 6167 str r7, [r4, #20]
f->highest_version = 1;
109eae: f8c6 8000 str.w r8, [r6]
ri->version = cpu_to_je32(f->highest_version);
109eb2: f884 8010 strb.w r8, [r4, #16]
109eb6: 7465 strb r5, [r4, #17]
109eb8: 74a5 strb r5, [r4, #18]
109eba: 74e5 strb r5, [r4, #19]
}
109ebc: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc}
return -ENOMEM;
109ec0: f06f 000b mvn.w r0, #11 <== NOT EXECUTED
109ec4: e7fa b.n 109ebc <jffs2_do_new_inode+0x80> <== NOT EXECUTED
109ec6: bf00 nop
00109c4c <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)
{
109c4c: b5f8 push {r3, r4, r5, r6, r7, lr}
109c4e: 4606 mov r6, r0
109c50: 460c mov r4, r1
109c52: 4615 mov r5, r2
109c54: 461f mov r7, r3
dbg_readinode("read inode #%u\n", ino);
retry_inocache:
spin_lock(&c->inocache_lock);
f->inocache = jffs2_get_ino_cache(c, ino);
109c56: 4629 mov r1, r5
109c58: 4630 mov r0, r6
109c5a: f7fd ff61 bl 107b20 <jffs2_get_ino_cache>
109c5e: 6160 str r0, [r4, #20]
if (f->inocache) {
109c60: b1f8 cbz r0, 109ca2 <jffs2_do_read_inode+0x56>
/* Check its state. We may need to wait before we can use it */
switch(f->inocache->state) {
109c62: 8943 ldrh r3, [r0, #10]
109c64: 2b05 cmp r3, #5
109c66: d85f bhi.n 109d28 <jffs2_do_read_inode+0xdc> <== ALWAYS TAKEN
109c68: a201 add r2, pc, #4 ; (adr r2, 109c70 <jffs2_do_read_inode+0x24>)
109c6a: f852 f023 ldr.w pc, [r2, r3, lsl #2]
109c6e: bf00 nop
109c70: 00109ce1 .word 0x00109ce1
109c74: 00109c57 .word 0x00109c57
109c78: 00109c89 .word 0x00109c89
109c7c: 00109ce1 .word 0x00109ce1
109c80: 00109c57 .word 0x00109c57
109c84: 00109c89 .word 0x00109c89
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);
109c88: f647 71b8 movw r1, #32696 ; 0x7fb8 <== NOT EXECUTED
109c8c: f647 60bc movw r0, #32444 ; 0x7ebc <== NOT EXECUTED
109c90: f2c0 0111 movt r1, #17 <== NOT EXECUTED
109c94: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109c98: 462a mov r2, r5 <== NOT EXECUTED
109c9a: f7fe fef7 bl 108a8c <jffs2_printk> <== NOT EXECUTED
/* Fail. That's probably better than allowing it to succeed */
f->inocache = NULL;
109c9e: 2300 movs r3, #0 <== NOT EXECUTED
109ca0: 6163 str r3, [r4, #20] <== NOT EXECUTED
BUG();
}
}
spin_unlock(&c->inocache_lock);
if (!f->inocache && ino == 1) {
109ca2: 2d01 cmp r5, #1
109ca4: d132 bne.n 109d0c <jffs2_do_read_inode+0xc0> <== ALWAYS TAKEN
/* Special case - no root inode on medium */
f->inocache = jffs2_alloc_inode_cache();
109ca6: f7fd fc99 bl 1075dc <jffs2_alloc_inode_cache>
109caa: 6160 str r0, [r4, #20]
if (!f->inocache) {
109cac: b308 cbz r0, 109cf2 <jffs2_do_read_inode+0xa6>
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));
109cae: 2300 movs r3, #0
109cb0: 6003 str r3, [r0, #0]
109cb2: 6043 str r3, [r0, #4]
109cb4: 6083 str r3, [r0, #8]
109cb6: 60c3 str r3, [r0, #12]
109cb8: 6103 str r3, [r0, #16]
109cba: 6143 str r3, [r0, #20]
f->inocache->ino = f->inocache->pino_nlink = 1;
f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
f->inocache->state = INO_STATE_READING;
109cbc: 2305 movs r3, #5
f->inocache->ino = f->inocache->pino_nlink = 1;
109cbe: 6961 ldr r1, [r4, #20]
jffs2_add_ino_cache(c, f->inocache);
109cc0: 4630 mov r0, r6
f->inocache->state = INO_STATE_READING;
109cc2: 814b strh r3, [r1, #10]
f->inocache->ino = f->inocache->pino_nlink = 1;
109cc4: 614d str r5, [r1, #20]
109cc6: 60cd str r5, [r1, #12]
f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
109cc8: 6049 str r1, [r1, #4]
jffs2_add_ino_cache(c, f->inocache);
109cca: f7fd ff3f bl 107b4c <jffs2_add_ino_cache>
}
if (!f->inocache) {
109cce: 6963 ldr r3, [r4, #20]
109cd0: b1e3 cbz r3, 109d0c <jffs2_do_read_inode+0xc0>
JFFS2_ERROR("requested to read a nonexistent ino %u\n", ino);
return -ENOENT;
}
return jffs2_do_read_inode_internal(c, f, latest_node);
109cd2: 463a mov r2, r7
109cd4: 4621 mov r1, r4
109cd6: 4630 mov r0, r6
}
109cd8: e8bd 40f8 ldmia.w sp!, {r3, r4, r5, r6, r7, lr}
return jffs2_do_read_inode_internal(c, f, latest_node);
109cdc: f7fe bfb0 b.w 108c40 <jffs2_do_read_inode_internal>
f->inocache->state = INO_STATE_READING;
109ce0: 2305 movs r3, #5
return jffs2_do_read_inode_internal(c, f, latest_node);
109ce2: 463a mov r2, r7
f->inocache->state = INO_STATE_READING;
109ce4: 8143 strh r3, [r0, #10]
return jffs2_do_read_inode_internal(c, f, latest_node);
109ce6: 4621 mov r1, r4
109ce8: 4630 mov r0, r6
}
109cea: e8bd 40f8 ldmia.w sp!, {r3, r4, r5, r6, r7, lr}
return jffs2_do_read_inode_internal(c, f, latest_node);
109cee: f7fe bfa7 b.w 108c40 <jffs2_do_read_inode_internal>
JFFS2_ERROR("cannot allocate inocache for root inode\n");
109cf2: f647 71b8 movw r1, #32696 ; 0x7fb8 <== NOT EXECUTED
109cf6: f647 7010 movw r0, #32528 ; 0x7f10 <== NOT EXECUTED
109cfa: f2c0 0111 movt r1, #17 <== NOT EXECUTED
109cfe: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109d02: f7fe fec3 bl 108a8c <jffs2_printk> <== NOT EXECUTED
return -ENOMEM;
109d06: f06f 000b mvn.w r0, #11 <== NOT EXECUTED
}
109d0a: bdf8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
JFFS2_ERROR("requested to read a nonexistent ino %u\n", ino);
109d0c: f647 71b8 movw r1, #32696 ; 0x7fb8 <== NOT EXECUTED
109d10: f647 7050 movw r0, #32592 ; 0x7f50 <== NOT EXECUTED
109d14: 462a mov r2, r5 <== NOT EXECUTED
109d16: f2c0 0111 movt r1, #17 <== NOT EXECUTED
109d1a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109d1e: f7fe feb5 bl 108a8c <jffs2_printk> <== NOT EXECUTED
return -ENOENT;
109d22: f06f 0001 mvn.w r0, #1 <== NOT EXECUTED
}
109d26: bdf8 pop {r3, r4, r5, r6, r7, pc} <== NOT EXECUTED
BUG();
109d28: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
109d2c: f647 72b8 movw r2, #32696 ; 0x7fb8 <== NOT EXECUTED
109d30: f247 40d4 movw r0, #29908 ; 0x74d4 <== NOT EXECUTED
109d34: f2c0 0311 movt r3, #17 <== NOT EXECUTED
109d38: f2c0 0211 movt r2, #17 <== NOT EXECUTED
109d3c: f240 515a movw r1, #1370 ; 0x55a <== NOT EXECUTED
109d40: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109d44: f002 fc94 bl 10c670 <__assert_func> <== NOT EXECUTED
0010a63c <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)
{
10a63c: e92d 43f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, lr}
10a640: b083 sub sp, #12
10a642: 9f0a ldr r7, [sp, #40] ; 0x28
10a644: 4680 mov r8, r0
10a646: 4691 mov r9, r2
while (len--) {
10a648: 461e mov r6, r3
10a64a: 2b00 cmp r3, #0
10a64c: d05a beq.n 10a704 <jffs2_do_unlink+0xc8> <== ALWAYS TAKEN
10a64e: 18d3 adds r3, r2, r3
10a650: 4614 mov r4, r2
uint32_t hash = 0;
10a652: 2500 movs r5, #0
hash ^= *(name++);
10a654: f814 cb01 ldrb.w ip, [r4], #1
while (len--) {
10a658: 429c cmp r4, r3
hash ^= *(name++);
10a65a: ea8c 7535 eor.w r5, ip, r5, ror #28
while (len--) {
10a65e: d1f9 bne.n 10a654 <jffs2_do_unlink+0x18>
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;
10a660: 68cc ldr r4, [r1, #12]
/* 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) {
10a662: b914 cbnz r4, 10a66a <jffs2_do_unlink+0x2e>
10a664: e018 b.n 10a698 <jffs2_do_unlink+0x5c> <== NOT EXECUTED
10a666: 6864 ldr r4, [r4, #4]
10a668: b1b4 cbz r4, 10a698 <jffs2_do_unlink+0x5c>
if (fd->nhash == nhash &&
10a66a: 6923 ldr r3, [r4, #16]
10a66c: 42ab cmp r3, r5
10a66e: d1fa bne.n 10a666 <jffs2_do_unlink+0x2a>
!memcmp(fd->name, name, namelen) &&
10a670: f104 0015 add.w r0, r4, #21
10a674: 4632 mov r2, r6
10a676: 4649 mov r1, r9
10a678: f00a fad2 bl 114c20 <memcmp>
!fd->name[namelen]) {
10a67c: 19a3 adds r3, r4, r6
if (fd->nhash == nhash &&
10a67e: 2800 cmp r0, #0
10a680: d1f1 bne.n 10a666 <jffs2_do_unlink+0x2a> <== ALWAYS TAKEN
!memcmp(fd->name, name, namelen) &&
10a682: 7d5b ldrb r3, [r3, #21]
10a684: 2b00 cmp r3, #0
10a686: d1ee bne.n 10a666 <jffs2_do_unlink+0x2a> <== ALWAYS TAKEN
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);
10a688: 6821 ldr r1, [r4, #0]
10a68a: 4640 mov r0, r8
10a68c: 9301 str r3, [sp, #4]
10a68e: f7fd fcfd bl 10808c <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;
10a692: 9b01 ldr r3, [sp, #4]
10a694: 6023 str r3, [r4, #0]
fd->ino = 0;
10a696: 60e3 str r3, [r4, #12]
}
/* 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) {
10a698: b15f cbz r7, 10a6b2 <jffs2_do_unlink+0x76>
10a69a: 697b ldr r3, [r7, #20]
10a69c: b14b cbz r3, 10a6b2 <jffs2_do_unlink+0x76>
mutex_lock(&dead_f->sem);
if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) {
10a69e: f857 2c40 ldr.w r2, [r7, #-64]
10a6a2: f402 4270 and.w r2, r2, #61440 ; 0xf000
10a6a6: f5b2 4f80 cmp.w r2, #16384 ; 0x4000
10a6aa: d009 beq.n 10a6c0 <jffs2_do_unlink+0x84>
jffs2_mark_node_obsolete(c, fd->raw);
jffs2_free_full_dirent(fd);
}
dead_f->inocache->pino_nlink = 0;
} else
dead_f->inocache->pino_nlink--;
10a6ac: 695a ldr r2, [r3, #20]
10a6ae: 3a01 subs r2, #1
10a6b0: 615a str r2, [r3, #20]
/* NB: Caller must set inode nlink if appropriate */
mutex_unlock(&dead_f->sem);
}
jffs2_complete_reservation(c);
10a6b2: 4640 mov r0, r8
10a6b4: f7fd fce4 bl 108080 <jffs2_complete_reservation>
return 0;
}
10a6b8: 2000 movs r0, #0
10a6ba: b003 add sp, #12
10a6bc: e8bd 83f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, pc}
while (dead_f->dents) {
10a6c0: 68fc ldr r4, [r7, #12]
10a6c2: b1e4 cbz r4, 10a6fe <jffs2_do_unlink+0xc2>
pr_warn("Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
10a6c4: f248 250c movw r5, #33292 ; 0x820c <== NOT EXECUTED
10a6c8: f2c0 0511 movt r5, #17 <== NOT EXECUTED
10a6cc: e009 b.n 10a6e2 <jffs2_do_unlink+0xa6> <== NOT EXECUTED
if (fd->raw)
10a6ce: 6821 ldr r1, [r4, #0] <== NOT EXECUTED
jffs2_mark_node_obsolete(c, fd->raw);
10a6d0: 4640 mov r0, r8 <== NOT EXECUTED
if (fd->raw)
10a6d2: b109 cbz r1, 10a6d8 <jffs2_do_unlink+0x9c> <== NOT EXECUTED
jffs2_mark_node_obsolete(c, fd->raw);
10a6d4: f7fd fcda bl 10808c <jffs2_mark_node_obsolete> <== NOT EXECUTED
jffs2_free_full_dirent(fd);
10a6d8: 4620 mov r0, r4 <== NOT EXECUTED
10a6da: f7fc ff21 bl 107520 <jffs2_free_full_dirent> <== NOT EXECUTED
while (dead_f->dents) {
10a6de: 68fc ldr r4, [r7, #12] <== NOT EXECUTED
10a6e0: b164 cbz r4, 10a6fc <jffs2_do_unlink+0xc0> <== NOT EXECUTED
if (fd->ino) {
10a6e2: 68e3 ldr r3, [r4, #12] <== NOT EXECUTED
dead_f->dents = fd->next;
10a6e4: 6862 ldr r2, [r4, #4] <== NOT EXECUTED
10a6e6: 60fa str r2, [r7, #12] <== NOT EXECUTED
if (fd->ino) {
10a6e8: 2b00 cmp r3, #0 <== NOT EXECUTED
10a6ea: d0f0 beq.n 10a6ce <jffs2_do_unlink+0x92> <== NOT EXECUTED
pr_warn("Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
10a6ec: 697a ldr r2, [r7, #20] <== NOT EXECUTED
10a6ee: 4628 mov r0, r5 <== NOT EXECUTED
10a6f0: 68d1 ldr r1, [r2, #12] <== NOT EXECUTED
10a6f2: f104 0215 add.w r2, r4, #21 <== NOT EXECUTED
10a6f6: f7ff fb93 bl 109e20 <jffs2_printk> <== NOT EXECUTED
10a6fa: e7e8 b.n 10a6ce <jffs2_do_unlink+0x92> <== NOT EXECUTED
dead_f->inocache->pino_nlink = 0;
10a6fc: 697b ldr r3, [r7, #20] <== NOT EXECUTED
10a6fe: 2200 movs r2, #0
10a700: 615a str r2, [r3, #20]
10a702: e7d6 b.n 10a6b2 <jffs2_do_unlink+0x76>
uint32_t hash = 0;
10a704: 461d mov r5, r3 <== NOT EXECUTED
10a706: e7ab b.n 10a660 <jffs2_do_unlink+0x24> <== NOT EXECUTED
0010b448 <jffs2_erase_pending_blocks>:
{
10b448: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
10b44c: 4604 mov r4, r0
pr_warn("Erase at 0x%08x failed immediately: errno %d\n",
10b44e: f648 4314 movw r3, #35860 ; 0x8c14
pr_warn("Erase at 0x%08x failed immediately: -EROFS. Is the sector locked?\n",
10b452: f648 32c4 movw r2, #35780 ; 0x8bc4
vecs[0].iov_len = sizeof(marker);
ret = jffs2_flash_direct_writev(c, vecs, 1, jeb->offset, &retlen);
if (ret || retlen != sizeof(marker)) {
if (ret)
pr_warn("Write clean marker to block at 0x%08x failed: %d\n",
10b456: f648 303c movw r0, #35644 ; 0x8b3c
while (!list_empty(&c->erase_complete_list) ||
10b45a: f104 05a0 add.w r5, r4, #160 ; 0xa0
int work_done = 0;
10b45e: 2600 movs r6, #0
{
10b460: b08f sub sp, #60 ; 0x3c
pr_warn("Erase at 0x%08x failed immediately: errno %d\n",
10b462: f2c0 0311 movt r3, #17
pr_warn("Erase at 0x%08x failed immediately: -EROFS. Is the sector locked?\n",
10b466: f2c0 0211 movt r2, #17
pr_warn("Write clean marker to block at 0x%08x failed: %d\n",
10b46a: f2c0 0011 movt r0, #17
{
10b46e: 9104 str r1, [sp, #16]
pr_warn("Erase at 0x%08x failed immediately: errno %d\n",
10b470: 9305 str r3, [sp, #20]
pr_warn("Erase at 0x%08x failed immediately: -EROFS. Is the sector locked?\n",
10b472: 9206 str r2, [sp, #24]
pr_warn("Write clean marker to block at 0x%08x failed: %d\n",
10b474: 9007 str r0, [sp, #28]
return ( list->next == list );
10b476: f8d4 80a0 ldr.w r8, [r4, #160] ; 0xa0
while (!list_empty(&c->erase_complete_list) ||
10b47a: 45a8 cmp r8, r5
10b47c: f000 80a0 beq.w 10b5c0 <jffs2_erase_pending_blocks+0x178>
ent->prev->next = ent->next;
10b480: e9d8 1700 ldrd r1, r7, [r8]
struct list_head *next = afterthisent->next;
10b484: 4623 mov r3, r4
#define MTD_FAIL_ADDR_UNKNOWN -1LL
static inline int do_mtd_point(size_t *retlen, void **ebuf)
{
*retlen = 0;
10b486: f04f 0c00 mov.w ip, #0
ebuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
10b48a: f44f 5080 mov.w r0, #4096 ; 0x1000
ent->prev->next = ent->next;
10b48e: 6039 str r1, [r7, #0]
struct list_head *next = afterthisent->next;
10b490: f853 2f90 ldr.w r2, [r3, #144]!
ent->next->prev = ent->prev;
10b494: 604f str r7, [r1, #4]
newent->prev = afterthisent;
10b496: e9c8 2300 strd r2, r3, [r8]
afterthisent->next = newent;
10b49a: f8c4 8090 str.w r8, [r4, #144] ; 0x90
next->prev = newent;
10b49e: f8c2 8004 str.w r8, [r2, #4]
10b4a2: f8cd c02c str.w ip, [sp, #44] ; 0x2c
10b4a6: f001 fb5b bl 10cb60 <malloc>
pr_warn("Failed to allocate page buffer for verifying erase at 0x%08x. Refiling\n",
10b4aa: f8d8 a00c ldr.w sl, [r8, #12]
if (!ebuf) {
10b4ae: 4683 mov fp, r0
10b4b0: 2800 cmp r0, #0
10b4b2: f000 80ef beq.w 10b694 <jffs2_erase_pending_blocks+0x24c> <== ALWAYS TAKEN
for (ofs = jeb->offset; ofs < jeb->offset + c->sector_size; ) {
10b4b6: 6b67 ldr r7, [r4, #52] ; 0x34
10b4b8: 4457 add r7, sl
10b4ba: 4557 cmp r7, sl
10b4bc: d955 bls.n 10b56a <jffs2_erase_pending_blocks+0x122> <== ALWAYS TAKEN
10b4be: f10d 092c add.w r9, sp, #44 ; 0x2c
uint32_t readlen = min((uint32_t)PAGE_SIZE, jeb->offset + c->sector_size - ofs);
10b4c2: eba7 070a sub.w r7, r7, sl
ret = jffs2_flash_read(c, ofs, readlen, &retlen, ebuf);
10b4c6: 464b mov r3, r9
uint32_t readlen = min((uint32_t)PAGE_SIZE, jeb->offset + c->sector_size - ofs);
10b4c8: f5b7 5f80 cmp.w r7, #4096 ; 0x1000
ret = jffs2_flash_read(c, ofs, readlen, &retlen, ebuf);
10b4cc: 4651 mov r1, sl
uint32_t readlen = min((uint32_t)PAGE_SIZE, jeb->offset + c->sector_size - ofs);
10b4ce: bf28 it cs
10b4d0: f44f 5780 movcs.w r7, #4096 ; 0x1000
ret = jffs2_flash_read(c, ofs, readlen, &retlen, ebuf);
10b4d4: 4620 mov r0, r4
10b4d6: 463a mov r2, r7
10b4d8: f8cd b000 str.w fp, [sp]
10b4dc: f000 f992 bl 10b804 <jffs2_flash_read>
if (ret) {
10b4e0: 2800 cmp r0, #0
10b4e2: f040 8170 bne.w 10b7c6 <jffs2_erase_pending_blocks+0x37e> <== ALWAYS TAKEN
if (retlen != readlen) {
10b4e6: 9b0b ldr r3, [sp, #44] ; 0x2c
10b4e8: 429f cmp r7, r3
10b4ea: f040 8178 bne.w 10b7de <jffs2_erase_pending_blocks+0x396> <== ALWAYS TAKEN
10b4ee: f1ab 0304 sub.w r3, fp, #4
10b4f2: e002 b.n 10b4fa <jffs2_erase_pending_blocks+0xb2>
for (i=0; i<readlen; i += sizeof(unsigned long)) {
10b4f4: 3004 adds r0, #4
10b4f6: 4287 cmp r7, r0
10b4f8: d930 bls.n 10b55c <jffs2_erase_pending_blocks+0x114>
if (*datum + 1) {
10b4fa: f853 1f04 ldr.w r1, [r3, #4]!
10b4fe: 1c4a adds r2, r1, #1
10b500: d0f8 beq.n 10b4f4 <jffs2_erase_pending_blocks+0xac> <== NEVER TAKEN
pr_warn("Newly-erased block contained word 0x%lx at offset 0x%08x\n",
10b502: 4602 mov r2, r0 <== NOT EXECUTED
10b504: f648 20f8 movw r0, #35576 ; 0x8af8 <== NOT EXECUTED
10b508: 4452 add r2, sl <== NOT EXECUTED
10b50a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10b50e: f7ff ff31 bl 10b374 <jffs2_printk> <== NOT EXECUTED
kfree(ebuf);
10b512: 4658 mov r0, fp <== NOT EXECUTED
10b514: f001 f9e8 bl 10c8e8 <free> <== NOT EXECUTED
c->erasing_size -= c->sector_size;
10b518: 6b61 ldr r1, [r4, #52] ; 0x34 <== NOT EXECUTED
c->bad_size += c->sector_size;
10b51a: e9d4 230b ldrd r2, r3, [r4, #44] ; 0x2c <== NOT EXECUTED
ent->prev->next = ent->next;
10b51e: f8d8 0004 ldr.w r0, [r8, #4] <== NOT EXECUTED
c->erasing_size -= c->sector_size;
10b522: 1a52 subs r2, r2, r1 <== NOT EXECUTED
c->bad_size += c->sector_size;
10b524: 440b add r3, r1 <== NOT EXECUTED
10b526: f8d8 1000 ldr.w r1, [r8] <== NOT EXECUTED
10b52a: e9c4 230b strd r2, r3, [r4, #44] ; 0x2c <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10b52e: 4623 mov r3, r4 <== NOT EXECUTED
ent->prev->next = ent->next;
10b530: 6001 str r1, [r0, #0] <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10b532: f853 2fb0 ldr.w r2, [r3, #176]! <== NOT EXECUTED
ent->next->prev = ent->prev;
10b536: 6048 str r0, [r1, #4] <== NOT EXECUTED
newent->prev = afterthisent;
10b538: e9c8 2300 strd r2, r3, [r8] <== NOT EXECUTED
c->nr_erasing_blocks--;
10b53c: 6c23 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED
afterthisent->next = newent;
10b53e: f8c4 80b0 str.w r8, [r4, #176] ; 0xb0 <== NOT EXECUTED
next->prev = newent;
10b542: f8c2 8004 str.w r8, [r2, #4] <== NOT EXECUTED
10b546: 3b01 subs r3, #1 <== NOT EXECUTED
10b548: 6423 str r3, [r4, #64] ; 0x40 <== NOT EXECUTED
if (!--count) {
10b54a: 9b04 ldr r3, [sp, #16]
work_done++;
10b54c: 3601 adds r6, #1
if (!--count) {
10b54e: 3b01 subs r3, #1
10b550: 9304 str r3, [sp, #16]
10b552: d190 bne.n 10b476 <jffs2_erase_pending_blocks+0x2e>
}
10b554: 4630 mov r0, r6
10b556: b00f add sp, #60 ; 0x3c
10b558: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
ofs += readlen;
10b55c: 44ba add sl, r7
for (ofs = jeb->offset; ofs < jeb->offset + c->sector_size; ) {
10b55e: f8d8 300c ldr.w r3, [r8, #12]
10b562: 6b67 ldr r7, [r4, #52] ; 0x34
10b564: 441f add r7, r3
10b566: 4557 cmp r7, sl
10b568: d8ab bhi.n 10b4c2 <jffs2_erase_pending_blocks+0x7a>
kfree(ebuf);
10b56a: 4658 mov r0, fp
10b56c: f001 f9bc bl 10c8e8 <free>
if (jffs2_cleanmarker_oob(c) || c->cleanmarker_size == 0) {
10b570: 6963 ldr r3, [r4, #20]
10b572: 2b00 cmp r3, #0
10b574: f040 80d9 bne.w 10b72a <jffs2_erase_pending_blocks+0x2e2> <== NEVER TAKEN
mutex_lock(&c->erase_free_sem);
spin_lock(&c->erase_completion_lock);
c->erasing_size -= c->sector_size;
c->free_size += c->sector_size;
10b578: e9d4 320a ldrd r3, r2, [r4, #40] ; 0x28 <== NOT EXECUTED
jeb->free_size = c->sector_size;
10b57c: 6b61 ldr r1, [r4, #52] ; 0x34 <== NOT EXECUTED
c->erasing_size -= c->sector_size;
10b57e: 1a52 subs r2, r2, r1 <== NOT EXECUTED
c->free_size += c->sector_size;
10b580: 440b add r3, r1 <== NOT EXECUTED
jeb->free_size = c->sector_size;
10b582: f8c8 1020 str.w r1, [r8, #32] <== NOT EXECUTED
c->free_size += c->sector_size;
10b586: e9c4 320a strd r3, r2, [r4, #40] ; 0x28 <== NOT EXECUTED
ent->prev->next = ent->next;
10b58a: e9d8 1000 ldrd r1, r0, [r8]
/* 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);
10b58e: f104 03a8 add.w r3, r4, #168 ; 0xa8
c->nr_erasing_blocks--;
10b592: 6c22 ldr r2, [r4, #64] ; 0x40
10b594: 6001 str r1, [r0, #0]
ent->next->prev = ent->prev;
10b596: 6048 str r0, [r1, #4]
10b598: 3a01 subs r2, #1
struct list_head *prev = beforethisent->prev;
10b59a: f8d4 00ac ldr.w r0, [r4, #172] ; 0xac
c->nr_free_blocks++;
jffs2_dbg_acct_sanity_check_nolock(c, jeb);
10b59e: 4641 mov r1, r8
newent->next = beforethisent;
10b5a0: f8c8 3000 str.w r3, [r8]
c->nr_free_blocks++;
10b5a4: 6be3 ldr r3, [r4, #60] ; 0x3c
newent->prev = prev;
10b5a6: f8c8 0004 str.w r0, [r8, #4]
beforethisent->prev = newent;
10b5aa: f8c4 80ac str.w r8, [r4, #172] ; 0xac
10b5ae: 3301 adds r3, #1
prev->next = newent;
10b5b0: f8c0 8000 str.w r8, [r0]
jffs2_dbg_acct_sanity_check_nolock(c, jeb);
10b5b4: 4620 mov r0, r4
c->nr_erasing_blocks--;
10b5b6: 6422 str r2, [r4, #64] ; 0x40
c->nr_free_blocks++;
10b5b8: 63e3 str r3, [r4, #60] ; 0x3c
jffs2_dbg_acct_sanity_check_nolock(c, jeb);
10b5ba: f7ff fbe7 bl 10ad8c <__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);
10b5be: e7c4 b.n 10b54a <jffs2_erase_pending_blocks+0x102>
return ( list->next == list );
10b5c0: f8d4 8098 ldr.w r8, [r4, #152] ; 0x98
!list_empty(&c->erase_pending_list)) {
10b5c4: f104 0998 add.w r9, r4, #152 ; 0x98
while (!list_empty(&c->erase_complete_list) ||
10b5c8: 45c1 cmp r9, r8
10b5ca: d0c3 beq.n 10b554 <jffs2_erase_pending_blocks+0x10c>
c->wasted_size -= jeb->wasted_size;
10b5cc: 6a60 ldr r0, [r4, #36] ; 0x24
10b5ce: f8d8 301c ldr.w r3, [r8, #28]
c->erasing_size += c->sector_size;
10b5d2: 6ae2 ldr r2, [r4, #44] ; 0x2c
10b5d4: 6b61 ldr r1, [r4, #52] ; 0x34
c->wasted_size -= jeb->wasted_size;
10b5d6: 1ac3 subs r3, r0, r3
c->free_size -= jeb->free_size;
10b5d8: 6aa0 ldr r0, [r4, #40] ; 0x28
ent->prev->next = ent->next;
10b5da: f8d8 a000 ldr.w sl, [r8]
c->erasing_size += c->sector_size;
10b5de: 440a add r2, r1
10b5e0: f8d8 1004 ldr.w r1, [r8, #4]
c->free_size -= jeb->free_size;
10b5e4: 4607 mov r7, r0
10b5e6: f8d8 0020 ldr.w r0, [r8, #32]
10b5ea: eba7 0c00 sub.w ip, r7, r0
c->used_size -= jeb->used_size;
10b5ee: 69e0 ldr r0, [r4, #28]
10b5f0: 4607 mov r7, r0
10b5f2: f8d8 0014 ldr.w r0, [r8, #20]
10b5f6: eba7 0e00 sub.w lr, r7, r0
c->dirty_size -= jeb->dirty_size;
10b5fa: f8d8 0018 ldr.w r0, [r8, #24]
10b5fe: 6a27 ldr r7, [r4, #32]
10b600: f8c1 a000 str.w sl, [r1]
ent->next->prev = ent->prev;
10b604: f8ca 1004 str.w r1, [sl, #4]
jffs2_free_jeb_node_refs(c, jeb);
10b608: 4641 mov r1, r8
c->free_size -= jeb->free_size;
10b60a: e9c4 3c09 strd r3, ip, [r4, #36] ; 0x24
c->dirty_size -= jeb->dirty_size;
10b60e: 1a38 subs r0, r7, r0
jeb->wasted_size = jeb->used_size = jeb->dirty_size = jeb->free_size = 0;
10b610: 2300 movs r3, #0
c->erasing_size += c->sector_size;
10b612: 62e2 str r2, [r4, #44] ; 0x2c
c->dirty_size -= jeb->dirty_size;
10b614: 6220 str r0, [r4, #32]
jffs2_free_jeb_node_refs(c, jeb);
10b616: 4620 mov r0, r4
c->used_size -= jeb->used_size;
10b618: f8c4 e01c str.w lr, [r4, #28]
jeb->wasted_size = jeb->used_size = jeb->dirty_size = jeb->free_size = 0;
10b61c: f8c8 3020 str.w r3, [r8, #32]
10b620: e9c8 3305 strd r3, r3, [r8, #20]
10b624: f8c8 301c str.w r3, [r8, #28]
jffs2_free_jeb_node_refs(c, jeb);
10b628: f7ff feb2 bl 10b390 <jffs2_free_jeb_node_refs>
struct list_head *next = afterthisent->next;
10b62c: 4623 mov r3, r4
ret = jffs2_flash_erase(c, jeb);
10b62e: 4641 mov r1, r8
10b630: f853 2f88 ldr.w r2, [r3, #136]!
10b634: 4620 mov r0, r4
newent->prev = afterthisent;
10b636: e9c8 2300 strd r2, r3, [r8]
afterthisent->next = newent;
10b63a: f8c4 8088 str.w r8, [r4, #136] ; 0x88
next->prev = newent;
10b63e: f8c2 8004 str.w r8, [r2, #4]
10b642: f000 f99f bl 10b984 <jffs2_flash_erase>
if (!ret) {
10b646: 2800 cmp r0, #0
10b648: d055 beq.n 10b6f6 <jffs2_erase_pending_blocks+0x2ae> <== NEVER TAKEN
if (ret == -ENOMEM || ret == -EAGAIN) {
10b64a: f100 030c add.w r3, r0, #12 <== NOT EXECUTED
10b64e: 2b01 cmp r3, #1 <== NOT EXECUTED
10b650: d939 bls.n 10b6c6 <jffs2_erase_pending_blocks+0x27e> <== NOT EXECUTED
if (ret == -EROFS)
10b652: f110 0f1e cmn.w r0, #30 <== NOT EXECUTED
bad_offset = jeb->offset;
10b656: f8d8 100c ldr.w r1, [r8, #12] <== NOT EXECUTED
if (ret == -EROFS)
10b65a: d062 beq.n 10b722 <jffs2_erase_pending_blocks+0x2da> <== NOT EXECUTED
pr_warn("Erase at 0x%08x failed immediately: errno %d\n",
10b65c: 4602 mov r2, r0 <== NOT EXECUTED
10b65e: 9805 ldr r0, [sp, #20] <== NOT EXECUTED
10b660: f7ff fe88 bl 10b374 <jffs2_printk> <== NOT EXECUTED
c->erasing_size -= c->sector_size;
10b664: 6b61 ldr r1, [r4, #52] ; 0x34 <== NOT EXECUTED
c->bad_size += c->sector_size;
10b666: e9d4 230b ldrd r2, r3, [r4, #44] ; 0x2c <== NOT EXECUTED
ent->prev->next = ent->next;
10b66a: e9d8 0700 ldrd r0, r7, [r8] <== NOT EXECUTED
c->erasing_size -= c->sector_size;
10b66e: 1a52 subs r2, r2, r1 <== NOT EXECUTED
c->bad_size += c->sector_size;
10b670: 440b add r3, r1 <== NOT EXECUTED
10b672: e9c4 230b strd r2, r3, [r4, #44] ; 0x2c <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10b676: 4622 mov r2, r4 <== NOT EXECUTED
c->nr_erasing_blocks--;
10b678: 6c23 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED
ent->prev->next = ent->next;
10b67a: 6038 str r0, [r7, #0] <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10b67c: f852 1fb0 ldr.w r1, [r2, #176]! <== NOT EXECUTED
10b680: 3b01 subs r3, #1 <== NOT EXECUTED
ent->next->prev = ent->prev;
10b682: 6047 str r7, [r0, #4] <== NOT EXECUTED
newent->prev = afterthisent;
10b684: e9c8 1200 strd r1, r2, [r8] <== NOT EXECUTED
afterthisent->next = newent;
10b688: f8c4 80b0 str.w r8, [r4, #176] ; 0xb0 <== NOT EXECUTED
next->prev = newent;
10b68c: f8c1 8004 str.w r8, [r1, #4] <== NOT EXECUTED
10b690: 6423 str r3, [r4, #64] ; 0x40 <== 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) { }
10b692: e6f0 b.n 10b476 <jffs2_erase_pending_blocks+0x2e> <== NOT EXECUTED
pr_warn("Failed to allocate page buffer for verifying erase at 0x%08x. Refiling\n",
10b694: f648 2008 movw r0, #35336 ; 0x8a08 <== NOT EXECUTED
10b698: 4651 mov r1, sl <== NOT EXECUTED
10b69a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10b69e: f7ff fe69 bl 10b374 <jffs2_printk> <== NOT EXECUTED
rtems_jffs2_flash_control *fc = sb->s_flash_control;
10b6a2: f8d4 00e4 ldr.w r0, [r4, #228] ; 0xe4 <== NOT EXECUTED
if (fc->trigger_garbage_collection != NULL) {
10b6a6: 6a03 ldr r3, [r0, #32] <== NOT EXECUTED
10b6a8: b103 cbz r3, 10b6ac <jffs2_erase_pending_blocks+0x264> <== NOT EXECUTED
(*fc->trigger_garbage_collection)(fc);
10b6aa: 4798 blx r3 <== NOT EXECUTED
ent->prev->next = ent->next;
10b6ac: e9d8 2100 ldrd r2, r1, [r8] <== NOT EXECUTED
10b6b0: 600a str r2, [r1, #0] <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10b6b2: f8d4 30a0 ldr.w r3, [r4, #160] ; 0xa0 <== NOT EXECUTED
ent->next->prev = ent->prev;
10b6b6: 6051 str r1, [r2, #4] <== NOT EXECUTED
newent->next = next;
10b6b8: e9c8 3500 strd r3, r5, [r8] <== NOT EXECUTED
afterthisent->next = newent;
10b6bc: f8c4 80a0 str.w r8, [r4, #160] ; 0xa0 <== NOT EXECUTED
next->prev = newent;
10b6c0: f8c3 8004 str.w r8, [r3, #4] <== 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);
10b6c4: e741 b.n 10b54a <jffs2_erase_pending_blocks+0x102> <== NOT EXECUTED
ent->prev->next = ent->next;
10b6c6: e9d8 3200 ldrd r3, r2, [r8] <== NOT EXECUTED
10b6ca: 6013 str r3, [r2, #0] <== NOT EXECUTED
ent->next->prev = ent->prev;
10b6cc: 605a str r2, [r3, #4] <== NOT EXECUTED
c->erasing_size -= c->sector_size;
10b6ce: 6b63 ldr r3, [r4, #52] ; 0x34 <== NOT EXECUTED
10b6d0: 6ae2 ldr r2, [r4, #44] ; 0x2c <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10b6d2: f8d4 1098 ldr.w r1, [r4, #152] ; 0x98 <== NOT EXECUTED
newent->prev = afterthisent;
10b6d6: f8c8 9004 str.w r9, [r8, #4] <== NOT EXECUTED
10b6da: 1ad2 subs r2, r2, r3 <== NOT EXECUTED
newent->next = next;
10b6dc: f8c8 1000 str.w r1, [r8] <== NOT EXECUTED
afterthisent->next = newent;
10b6e0: f8c4 8098 str.w r8, [r4, #152] ; 0x98 <== NOT EXECUTED
next->prev = newent;
10b6e4: f8c1 8004 str.w r8, [r1, #4] <== NOT EXECUTED
10b6e8: 62e2 str r2, [r4, #44] ; 0x2c <== NOT EXECUTED
c->dirty_size += c->sector_size;
10b6ea: 6a22 ldr r2, [r4, #32] <== NOT EXECUTED
10b6ec: 441a add r2, r3 <== NOT EXECUTED
10b6ee: 6222 str r2, [r4, #32] <== NOT EXECUTED
jeb->dirty_size = c->sector_size;
10b6f0: f8c8 3018 str.w r3, [r8, #24] <== NOT EXECUTED
return;
10b6f4: e6bf b.n 10b476 <jffs2_erase_pending_blocks+0x2e> <== NOT EXECUTED
ent->prev->next = ent->next;
10b6f6: e9d8 3200 ldrd r3, r2, [r8]
rtems_jffs2_flash_control *fc = sb->s_flash_control;
10b6fa: f8d4 00e4 ldr.w r0, [r4, #228] ; 0xe4
10b6fe: 6013 str r3, [r2, #0]
ent->next->prev = ent->prev;
10b700: 605a str r2, [r3, #4]
if (fc->trigger_garbage_collection != NULL) {
10b702: 6a02 ldr r2, [r0, #32]
struct list_head *prev = beforethisent->prev;
10b704: f8d4 30a4 ldr.w r3, [r4, #164] ; 0xa4
newent->next = beforethisent;
10b708: f8c8 5000 str.w r5, [r8]
newent->prev = prev;
10b70c: f8c8 3004 str.w r3, [r8, #4]
beforethisent->prev = newent;
10b710: f8c4 80a4 str.w r8, [r4, #164] ; 0xa4
prev->next = newent;
10b714: f8c3 8000 str.w r8, [r3]
10b718: 2a00 cmp r2, #0
10b71a: f43f aeac beq.w 10b476 <jffs2_erase_pending_blocks+0x2e> <== NEVER TAKEN
(*fc->trigger_garbage_collection)(fc);
10b71e: 4790 blx r2 <== NOT EXECUTED
10b720: e6a9 b.n 10b476 <jffs2_erase_pending_blocks+0x2e> <== NOT EXECUTED
pr_warn("Erase at 0x%08x failed immediately: -EROFS. Is the sector locked?\n",
10b722: 9806 ldr r0, [sp, #24] <== NOT EXECUTED
10b724: f7ff fe26 bl 10b374 <jffs2_printk> <== NOT EXECUTED
10b728: e79c b.n 10b664 <jffs2_erase_pending_blocks+0x21c> <== NOT EXECUTED
struct jffs2_unknown_node marker = {
10b72a: f641 1085 movw r0, #6533 ; 0x1985
10b72e: 2700 movs r7, #0
10b730: f8ad 002c strh.w r0, [sp, #44] ; 0x2c
10b734: f242 0003 movw r0, #8195 ; 0x2003
jffs2_prealloc_raw_node_refs(c, jeb, 1);
10b738: 2201 movs r2, #1
10b73a: 4641 mov r1, r8
marker.hdr_crc = cpu_to_je32(crc32(0, &marker, sizeof(struct jffs2_unknown_node)-4));
10b73c: f10d 092c add.w r9, sp, #44 ; 0x2c
struct jffs2_unknown_node marker = {
10b740: f8ad 002e strh.w r0, [sp, #46] ; 0x2e
jffs2_prealloc_raw_node_refs(c, jeb, 1);
10b744: 4620 mov r0, r4
struct jffs2_unknown_node marker = {
10b746: 930c str r3, [sp, #48] ; 0x30
10b748: 970d str r7, [sp, #52] ; 0x34
jffs2_prealloc_raw_node_refs(c, jeb, 1);
10b74a: f7fb ff03 bl 107554 <jffs2_prealloc_raw_node_refs>
marker.hdr_crc = cpu_to_je32(crc32(0, &marker, sizeof(struct jffs2_unknown_node)-4));
10b74e: 2208 movs r2, #8
10b750: 4649 mov r1, r9
10b752: 4638 mov r0, r7
10b754: f7ff fab2 bl 10acbc <cyg_crc32_accumulate>
ret = jffs2_flash_direct_writev(c, vecs, 1, jeb->offset, &retlen);
10b758: ab08 add r3, sp, #32
10b75a: 2201 movs r2, #1
10b75c: 9302 str r3, [sp, #8]
10b75e: a909 add r1, sp, #36 ; 0x24
10b760: f8d8 300c ldr.w r3, [r8, #12]
marker.hdr_crc = cpu_to_je32(crc32(0, &marker, sizeof(struct jffs2_unknown_node)-4));
10b764: 900d str r0, [sp, #52] ; 0x34
ret = jffs2_flash_direct_writev(c, vecs, 1, jeb->offset, &retlen);
10b766: 4620 mov r0, r4
vecs[0].iov_base = (unsigned char *) ▮
10b768: f8cd 9024 str.w r9, [sp, #36] ; 0x24
ret = jffs2_flash_direct_writev(c, vecs, 1, jeb->offset, &retlen);
10b76c: e9cd 3700 strd r3, r7, [sp]
vecs[0].iov_len = sizeof(marker);
10b770: 270c movs r7, #12
10b772: 970a str r7, [sp, #40] ; 0x28
ret = jffs2_flash_direct_writev(c, vecs, 1, jeb->offset, &retlen);
10b774: f000 f85e bl 10b834 <jffs2_flash_direct_writev>
if (ret || retlen != sizeof(marker)) {
10b778: 4602 mov r2, r0
10b77a: 2800 cmp r0, #0
10b77c: d13b bne.n 10b7f6 <jffs2_erase_pending_blocks+0x3ae> <== ALWAYS TAKEN
10b77e: 9b08 ldr r3, [sp, #32]
10b780: 42bb cmp r3, r7
10b782: d009 beq.n 10b798 <jffs2_erase_pending_blocks+0x350> <== NEVER TAKEN
pr_warn("Short write to newly-erased block at 0x%08x: Wanted %zd, got %zd\n",
10b784: f648 3078 movw r0, #35704 ; 0x8b78 <== NOT EXECUTED
10b788: f8d8 100c ldr.w r1, [r8, #12] <== NOT EXECUTED
10b78c: 463a mov r2, r7 <== NOT EXECUTED
10b78e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10b792: f7ff fdef bl 10b374 <jffs2_printk> <== NOT EXECUTED
goto filebad;
10b796: e6bf b.n 10b518 <jffs2_erase_pending_blocks+0xd0> <== NOT EXECUTED
c->erasing_size -= c->sector_size;
10b798: 6ae3 ldr r3, [r4, #44] ; 0x2c
jeb->free_size = c->sector_size;
10b79a: 6b67 ldr r7, [r4, #52] ; 0x34
c->erasing_size -= c->sector_size;
10b79c: 1bd8 subs r0, r3, r7
c->free_size += c->sector_size;
10b79e: 6aa3 ldr r3, [r4, #40] ; 0x28
10b7a0: 19d9 adds r1, r3, r7
if (c->cleanmarker_size && !jffs2_cleanmarker_oob(c))
10b7a2: 6963 ldr r3, [r4, #20]
jeb->free_size = c->sector_size;
10b7a4: f8c8 7020 str.w r7, [r8, #32]
c->free_size += c->sector_size;
10b7a8: e9c4 100a strd r1, r0, [r4, #40] ; 0x28
if (c->cleanmarker_size && !jffs2_cleanmarker_oob(c))
10b7ac: 2b00 cmp r3, #0
10b7ae: f43f aeec beq.w 10b58a <jffs2_erase_pending_blocks+0x142> <== ALWAYS TAKEN
jffs2_link_node_ref(c, jeb, jeb->offset | REF_NORMAL, c->cleanmarker_size, NULL);
10b7b2: f8d8 100c ldr.w r1, [r8, #12]
10b7b6: 4620 mov r0, r4
10b7b8: 9200 str r2, [sp, #0]
10b7ba: f041 0203 orr.w r2, r1, #3
10b7be: 4641 mov r1, r8
10b7c0: f7fc faa6 bl 107d10 <jffs2_link_node_ref>
10b7c4: e6e1 b.n 10b58a <jffs2_erase_pending_blocks+0x142>
pr_warn("Read of newly-erased block at 0x%08x failed: %d. Putting on bad_list\n",
10b7c6: 4602 mov r2, r0 <== NOT EXECUTED
10b7c8: f648 205c movw r0, #35420 ; 0x8a5c <== NOT EXECUTED
10b7cc: 4651 mov r1, sl <== NOT EXECUTED
10b7ce: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10b7d2: f7ff fdcf bl 10b374 <jffs2_printk> <== NOT EXECUTED
kfree(ebuf);
10b7d6: 4658 mov r0, fp <== NOT EXECUTED
10b7d8: f001 f886 bl 10c8e8 <free> <== NOT EXECUTED
return ret;
10b7dc: e69c b.n 10b518 <jffs2_erase_pending_blocks+0xd0> <== NOT EXECUTED
pr_warn("Short read from newly-erased block at 0x%08x. Wanted %d, got %zd\n",
10b7de: f648 20ac movw r0, #35500 ; 0x8aac <== NOT EXECUTED
10b7e2: 463a mov r2, r7 <== NOT EXECUTED
10b7e4: 4651 mov r1, sl <== NOT EXECUTED
10b7e6: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10b7ea: f7ff fdc3 bl 10b374 <jffs2_printk> <== NOT EXECUTED
kfree(ebuf);
10b7ee: 4658 mov r0, fp <== NOT EXECUTED
10b7f0: f001 f87a bl 10c8e8 <free> <== NOT EXECUTED
return ret;
10b7f4: e690 b.n 10b518 <jffs2_erase_pending_blocks+0xd0> <== NOT EXECUTED
pr_warn("Write clean marker to block at 0x%08x failed: %d\n",
10b7f6: f8d8 100c ldr.w r1, [r8, #12] <== NOT EXECUTED
10b7fa: 9807 ldr r0, [sp, #28] <== NOT EXECUTED
10b7fc: f7ff fdba bl 10b374 <jffs2_printk> <== NOT EXECUTED
10b800: e68a b.n 10b518 <jffs2_erase_pending_blocks+0xd0> <== NOT EXECUTED
10b802: bf00 nop
0010b834 <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)
{
10b834: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
10b838: b0c3 sub sp, #268 ; 0x10c
10b83a: f8dd 8130 ldr.w r8, [sp, #304] ; 0x130
unsigned long i;
size_t totlen = 0, thislen;
int ret = 0;
for (i = 0; i < count; i++) {
10b83e: 4691 mov r9, r2
{
10b840: 9100 str r1, [sp, #0]
for (i = 0; i < count; i++) {
10b842: 2a00 cmp r2, #0
10b844: f000 8098 beq.w 10b978 <jffs2_flash_direct_writev+0x144> <== ALWAYS TAKEN
size_t totlen = 0, thislen;
10b848: f04f 0a00 mov.w sl, #0
10b84c: 4683 mov fp, r0
for (i = 0; i < count; i++) {
10b84e: 460f mov r7, r1
10b850: 4655 mov r5, sl
10b852: e017 b.n 10b884 <jffs2_flash_direct_writev+0x50>
// 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].
10b854: 9b00 ldr r3, [sp, #0]
10b856: f853 c035 ldr.w ip, [r3, r5, lsl #3]
return (*fc->write)(fc, write_buffer_offset, read_buffer, size);
10b85a: 4623 mov r3, r4
if (((vecs[i].iov_len & (sizeof (int) - 1))) ||
10b85c: f01c 0f03 tst.w ip, #3
10b860: d11a bne.n 10b898 <jffs2_flash_direct_writev+0x64>
rtems_jffs2_flash_control *fc = sb->s_flash_control;
10b862: f8db 00e4 ldr.w r0, [fp, #228] ; 0xe4
return (*fc->write)(fc, write_buffer_offset, read_buffer, size);
10b866: 4662 mov r2, ip
10b868: 4641 mov r1, r8
for (i = 0; i < count; i++) {
10b86a: 3501 adds r5, #1
} // else
} else
ret =
jffs2_flash_write(c, to, vecs[i].iov_len, &thislen,
vecs[i].iov_base);
totlen += thislen;
10b86c: 44a2 add sl, r4
return (*fc->write)(fc, write_buffer_offset, read_buffer, size);
10b86e: 68c6 ldr r6, [r0, #12]
10b870: 47b0 blx r6
if (ret || thislen != vecs[i].iov_len)
10b872: bb78 cbnz r0, 10b8d4 <jffs2_flash_direct_writev+0xa0>
10b874: 687b ldr r3, [r7, #4]
for (i = 0; i < count; i++) {
10b876: 3708 adds r7, #8
if (ret || thislen != vecs[i].iov_len)
10b878: 42a3 cmp r3, r4
10b87a: d12b bne.n 10b8d4 <jffs2_flash_direct_writev+0xa0> <== ALWAYS TAKEN
break;
to += vecs[i].iov_len;
10b87c: eb14 0808 adds.w r8, r4, r8
for (i = 0; i < count; i++) {
10b880: 45a9 cmp r9, r5
10b882: d027 beq.n 10b8d4 <jffs2_flash_direct_writev+0xa0>
if (((vecs[i].iov_len & (sizeof (int) - 1))) ||
10b884: 687c ldr r4, [r7, #4]
memcpy(buf, vecs[i].iov_base, lentowrite);
10b886: a802 add r0, sp, #8
if ((i + 1) < count || vecs[i].iov_len > 256) {
10b888: 1c69 adds r1, r5, #1
lentowrite += sizeof (int) - 1;
10b88a: 1ce6 adds r6, r4, #3
if (((vecs[i].iov_len & (sizeof (int) - 1))) ||
10b88c: f014 0f03 tst.w r4, #3
lentowrite &= ~(sizeof (int) - 1);
10b890: f026 0603 bic.w r6, r6, #3
memcpy(buf, vecs[i].iov_base, lentowrite);
10b894: 4632 mov r2, r6
if (((vecs[i].iov_len & (sizeof (int) - 1))) ||
10b896: d0dd beq.n 10b854 <jffs2_flash_direct_writev+0x20>
if ((i + 1) < count || vecs[i].iov_len > 256) {
10b898: f5b4 7f80 cmp.w r4, #256 ; 0x100
10b89c: bf94 ite ls
10b89e: 2300 movls r3, #0
10b8a0: 2301 movhi r3, #1
10b8a2: 4549 cmp r1, r9
10b8a4: bf38 it cc
10b8a6: f043 0301 orrcc.w r3, r3, #1
10b8aa: b9e3 cbnz r3, 10b8e6 <jffs2_flash_direct_writev+0xb2>
memcpy(buf, vecs[i].iov_base, lentowrite);
10b8ac: 9b00 ldr r3, [sp, #0]
10b8ae: f853 1035 ldr.w r1, [r3, r5, lsl #3]
for (i = 0; i < count; i++) {
10b8b2: 3501 adds r5, #1
memcpy(buf, vecs[i].iov_base, lentowrite);
10b8b4: f009 e9e4 blx 114c80 <memcpy>
rtems_jffs2_flash_control *fc = sb->s_flash_control;
10b8b8: f8db 00e4 ldr.w r0, [fp, #228] ; 0xe4
return (*fc->write)(fc, write_buffer_offset, read_buffer, size);
10b8bc: 4633 mov r3, r6
10b8be: aa02 add r2, sp, #8
10b8c0: 4641 mov r1, r8
10b8c2: 68c4 ldr r4, [r0, #12]
10b8c4: 47a0 blx r4
10b8c6: 687c ldr r4, [r7, #4]
if (thislen > vecs[i].iov_len)
10b8c8: 42b4 cmp r4, r6
10b8ca: bf28 it cs
10b8cc: 4634 movcs r4, r6
totlen += thislen;
10b8ce: 44a2 add sl, r4
if (ret || thislen != vecs[i].iov_len)
10b8d0: 2800 cmp r0, #0
10b8d2: d0cf beq.n 10b874 <jffs2_flash_direct_writev+0x40> <== NEVER TAKEN
10b8d4: 4603 mov r3, r0
}
writev_out:
if (retlen)
10b8d6: 9a4e ldr r2, [sp, #312] ; 0x138
10b8d8: b10a cbz r2, 10b8de <jffs2_flash_direct_writev+0xaa>
*retlen = totlen;
10b8da: f8c2 a000 str.w sl, [r2]
return ret;
}
10b8de: 4618 mov r0, r3
10b8e0: b043 add sp, #268 ; 0x10c
10b8e2: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
for (j = i; j < count; j++)
10b8e6: 45a9 cmp r9, r5
10b8e8: d93e bls.n 10b968 <jffs2_flash_direct_writev+0x134> <== ALWAYS TAKEN
totvecsize += vecs[j].iov_len;
10b8ea: 9900 ldr r1, [sp, #0]
if (((vecs[i].iov_len & (sizeof (int) - 1))) ||
10b8ec: 4622 mov r2, r4
for (j = i; j < count; j++)
10b8ee: 462b mov r3, r5
10b8f0: 2700 movs r7, #0
totvecsize += vecs[j].iov_len;
10b8f2: 3104 adds r1, #4
10b8f4: e001 b.n 10b8fa <jffs2_flash_direct_writev+0xc6>
10b8f6: f851 2033 ldr.w r2, [r1, r3, lsl #3] <== NOT EXECUTED
for (j = i; j < count; j++)
10b8fa: 3301 adds r3, #1
totvecsize += vecs[j].iov_len;
10b8fc: 4417 add r7, r2
for (j = i; j < count; j++)
10b8fe: 4599 cmp r9, r3
10b900: d1f9 bne.n 10b8f6 <jffs2_flash_direct_writev+0xc2> <== ALWAYS TAKEN
sizetomalloc = totvecsize + sizeof (int) - 1;
10b902: 1cfb adds r3, r7, #3
sizetomalloc &= ~(sizeof (int) - 1);
10b904: f023 0303 bic.w r3, r3, #3
cbuf = (char *) malloc(sizetomalloc);
10b908: 4618 mov r0, r3
sizetomalloc &= ~(sizeof (int) - 1);
10b90a: 9301 str r3, [sp, #4]
cbuf = (char *) malloc(sizetomalloc);
10b90c: f001 f928 bl 10cb60 <malloc>
if (!cbuf) {
10b910: 4606 mov r6, r0
10b912: b3a0 cbz r0, 10b97e <jffs2_flash_direct_writev+0x14a>
10b914: 9b00 ldr r3, [sp, #0]
10b916: f103 010c add.w r1, r3, #12
10b91a: eb03 05c5 add.w r5, r3, r5, lsl #3
10b91e: eb01 09c9 add.w r9, r1, r9, lsl #3
10b922: 350c adds r5, #12
10b924: 4603 mov r3, r0
10b926: e001 b.n 10b92c <jffs2_flash_direct_writev+0xf8>
memcpy(cbufptr, vecs[j].iov_base,
10b928: f855 4c08 ldr.w r4, [r5, #-8] <== NOT EXECUTED
10b92c: f855 1c0c ldr.w r1, [r5, #-12]
10b930: 4618 mov r0, r3
10b932: 4622 mov r2, r4
for (j = i; j < count; j++) {
10b934: 3508 adds r5, #8
memcpy(cbufptr, vecs[j].iov_base,
10b936: f009 e9a4 blx 114c80 <memcpy>
for (j = i; j < count; j++) {
10b93a: 45a9 cmp r9, r5
memcpy(cbufptr, vecs[j].iov_base,
10b93c: 4603 mov r3, r0
cbufptr += vecs[j].iov_len;
10b93e: 4423 add r3, r4
for (j = i; j < count; j++) {
10b940: d1f2 bne.n 10b928 <jffs2_flash_direct_writev+0xf4> <== ALWAYS TAKEN
totlen += thislen;
10b942: 9b01 ldr r3, [sp, #4]
10b944: 429f cmp r7, r3
10b946: bf94 ite ls
10b948: 44ba addls sl, r7
10b94a: 449a addhi sl, r3
rtems_jffs2_flash_control *fc = sb->s_flash_control;
10b94c: f8db 00e4 ldr.w r0, [fp, #228] ; 0xe4
return (*fc->write)(fc, write_buffer_offset, read_buffer, size);
10b950: 4641 mov r1, r8
10b952: 9b01 ldr r3, [sp, #4]
10b954: 4632 mov r2, r6
10b956: 68c4 ldr r4, [r0, #12]
10b958: 47a0 blx r4
10b95a: 4603 mov r3, r0
free(cbuf);
10b95c: 4630 mov r0, r6
return (*fc->write)(fc, write_buffer_offset, read_buffer, size);
10b95e: 9300 str r3, [sp, #0]
free(cbuf);
10b960: f000 ffc2 bl 10c8e8 <free>
goto writev_out;
10b964: 9b00 ldr r3, [sp, #0]
10b966: e7b6 b.n 10b8d6 <jffs2_flash_direct_writev+0xa2>
cbuf = (char *) malloc(sizetomalloc);
10b968: 2000 movs r0, #0 <== NOT EXECUTED
10b96a: f001 f8f9 bl 10cb60 <malloc> <== NOT EXECUTED
if (!cbuf) {
10b96e: 4606 mov r6, r0 <== NOT EXECUTED
10b970: b128 cbz r0, 10b97e <jffs2_flash_direct_writev+0x14a> <== NOT EXECUTED
cbuf = (char *) malloc(sizetomalloc);
10b972: 2300 movs r3, #0 <== NOT EXECUTED
10b974: 9301 str r3, [sp, #4] <== NOT EXECUTED
10b976: e7e9 b.n 10b94c <jffs2_flash_direct_writev+0x118> <== NOT EXECUTED
size_t totlen = 0, thislen;
10b978: 4692 mov sl, r2 <== NOT EXECUTED
for (i = 0; i < count; i++) {
10b97a: 464b mov r3, r9 <== NOT EXECUTED
10b97c: e7ab b.n 10b8d6 <jffs2_flash_direct_writev+0xa2> <== NOT EXECUTED
ret = -ENOMEM;
10b97e: f06f 030b mvn.w r3, #11 <== NOT EXECUTED
10b982: e7a8 b.n 10b8d6 <jffs2_flash_direct_writev+0xa2> <== NOT EXECUTED
00107bdc <jffs2_free_ino_caches>:
for (i=0; i < c->inocache_hashsize; i++) {
107bdc: f8d0 10c0 ldr.w r1, [r0, #192] ; 0xc0
107be0: 2900 cmp r1, #0
107be2: dd1b ble.n 107c1c <jffs2_free_ino_caches+0x40> <== ALWAYS TAKEN
this = c->inocache_list[i];
107be4: f8d0 30c4 ldr.w r3, [r0, #196] ; 0xc4
{
107be8: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
for (i=0; i < c->inocache_hashsize; i++) {
107bec: 2500 movs r5, #0
107bee: 4607 mov r7, r0
c->inocache_list[i] = NULL;
107bf0: 46a8 mov r8, r5
this = c->inocache_list[i];
107bf2: 00ae lsls r6, r5, #2
107bf4: f853 4025 ldr.w r4, [r3, r5, lsl #2]
107bf8: 199a adds r2, r3, r6
while (this) {
107bfa: b144 cbz r4, 107c0e <jffs2_free_ino_caches+0x32>
next = this->next;
107bfc: 4620 mov r0, r4
107bfe: 6924 ldr r4, [r4, #16]
jffs2_free_inode_cache(this);
107c00: f7ff fcf0 bl 1075e4 <jffs2_free_inode_cache>
while (this) {
107c04: 2c00 cmp r4, #0
107c06: d1f9 bne.n 107bfc <jffs2_free_ino_caches+0x20> <== ALWAYS TAKEN
107c08: e9d7 1330 ldrd r1, r3, [r7, #192] ; 0xc0
c->inocache_list[i] = NULL;
107c0c: 199a adds r2, r3, r6
for (i=0; i < c->inocache_hashsize; i++) {
107c0e: 3501 adds r5, #1
c->inocache_list[i] = NULL;
107c10: f8c2 8000 str.w r8, [r2]
for (i=0; i < c->inocache_hashsize; i++) {
107c14: 42a9 cmp r1, r5
107c16: dcec bgt.n 107bf2 <jffs2_free_ino_caches+0x16>
}
107c18: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
107c1c: 4770 bx lr <== NOT EXECUTED
107c1e: bf00 nop
0010b390 <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)
{
10b390: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
10b394: 460e mov r6, r1
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;
10b396: 6a8d ldr r5, [r1, #40] ; 0x28
while (ref) {
10b398: 2d00 cmp r5, #0
10b39a: d03b beq.n 10b414 <jffs2_free_jeb_node_refs+0x84>
JFFS2_WARNING("inode_cache/xattr_datum/xattr_ref"
10b39c: f648 494c movw r9, #35916 ; 0x8c4c
10b3a0: 4680 mov r8, r0
while (ref) {
10b3a2: 46aa mov sl, r5
struct jffs2_inode_cache *ic = NULL;
10b3a4: 2700 movs r7, #0
JFFS2_WARNING("inode_cache/xattr_datum/xattr_ref"
10b3a6: f2c0 0911 movt r9, #17
if (ref->flash_offset == REF_LINK_NODE) {
10b3aa: 686b ldr r3, [r5, #4]
10b3ac: 1c5a adds r2, r3, #1
10b3ae: d02c beq.n 10b40a <jffs2_free_jeb_node_refs+0x7a> <== ALWAYS TAKEN
ref = ref->next_in_ino;
jffs2_free_refblock(block);
block = ref;
continue;
}
if (ref->flash_offset != REF_EMPTY_NODE && ref->next_in_ino)
10b3b0: 3302 adds r3, #2
10b3b2: d026 beq.n 10b402 <jffs2_free_jeb_node_refs+0x72>
10b3b4: 682b ldr r3, [r5, #0]
10b3b6: b323 cbz r3, 10b402 <jffs2_free_jeb_node_refs+0x72>
if (SECTOR_ADDR((*prev)->flash_offset) == jeb->offset) {
10b3b8: f8d8 2034 ldr.w r2, [r8, #52] ; 0x34 <== NOT EXECUTED
prev = &ref->next_in_ino;
10b3bc: 4628 mov r0, r5 <== NOT EXECUTED
if (SECTOR_ADDR((*prev)->flash_offset) == jeb->offset) {
10b3be: 68f1 ldr r1, [r6, #12] <== NOT EXECUTED
struct jffs2_inode_cache *ic = NULL;
10b3c0: f04f 0e00 mov.w lr, #0 <== NOT EXECUTED
if (SECTOR_ADDR((*prev)->flash_offset) == jeb->offset) {
10b3c4: f1c2 0c00 rsb ip, r2, #0 <== NOT EXECUTED
if (!(*prev)->next_in_ino) {
10b3c8: 681c ldr r4, [r3, #0] <== NOT EXECUTED
10b3ca: b17c cbz r4, 10b3ec <jffs2_free_jeb_node_refs+0x5c> <== NOT EXECUTED
if (SECTOR_ADDR((*prev)->flash_offset) == jeb->offset) {
10b3cc: 685a ldr r2, [r3, #4] <== NOT EXECUTED
10b3ce: ea0c 0202 and.w r2, ip, r2 <== NOT EXECUTED
10b3d2: 428a cmp r2, r1 <== NOT EXECUTED
prev = &((*prev)->next_in_ino);
10b3d4: bf1c itt ne <== NOT EXECUTED
10b3d6: 4618 movne r0, r3 <== NOT EXECUTED
10b3d8: 4623 movne r3, r4 <== NOT EXECUTED
if (SECTOR_ADDR((*prev)->flash_offset) == jeb->offset) {
10b3da: d1f5 bne.n 10b3c8 <jffs2_free_jeb_node_refs+0x38> <== NOT EXECUTED
if (this == ref)
10b3dc: 42ab cmp r3, r5 <== NOT EXECUTED
*prev = this->next_in_ino;
10b3de: 6004 str r4, [r0, #0] <== NOT EXECUTED
this->next_in_ino = NULL;
10b3e0: 601f str r7, [r3, #0] <== NOT EXECUTED
if (this == ref)
10b3e2: d007 beq.n 10b3f4 <jffs2_free_jeb_node_refs+0x64> <== NOT EXECUTED
if (!(*prev)->next_in_ino) {
10b3e4: 6803 ldr r3, [r0, #0] <== NOT EXECUTED
10b3e6: 681c ldr r4, [r3, #0] <== NOT EXECUTED
10b3e8: 2c00 cmp r4, #0 <== NOT EXECUTED
10b3ea: d1ef bne.n 10b3cc <jffs2_free_jeb_node_refs+0x3c> <== NOT EXECUTED
prev = &ic->nodes;
10b3ec: 1d18 adds r0, r3, #4 <== NOT EXECUTED
continue;
10b3ee: 469e mov lr, r3 <== NOT EXECUTED
10b3f0: 685b ldr r3, [r3, #4] <== NOT EXECUTED
10b3f2: e7e9 b.n 10b3c8 <jffs2_free_jeb_node_refs+0x38> <== NOT EXECUTED
if (!ic) {
10b3f4: f1be 0f00 cmp.w lr, #0 <== NOT EXECUTED
10b3f8: d01b beq.n 10b432 <jffs2_free_jeb_node_refs+0xa2> <== NOT EXECUTED
if (ic->nodes == (void *)ic && ic->pino_nlink == 0)
10b3fa: f8de 3004 ldr.w r3, [lr, #4] <== NOT EXECUTED
10b3fe: 4573 cmp r3, lr <== NOT EXECUTED
10b400: d00d beq.n 10b41e <jffs2_free_jeb_node_refs+0x8e> <== 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++;
10b402: 3508 adds r5, #8
if (ref->flash_offset == REF_LINK_NODE) {
10b404: 686b ldr r3, [r5, #4]
10b406: 1c5a adds r2, r3, #1
10b408: d1d2 bne.n 10b3b0 <jffs2_free_jeb_node_refs+0x20>
ref = ref->next_in_ino;
10b40a: 682d ldr r5, [r5, #0]
jffs2_free_refblock(block);
10b40c: 4650 mov r0, sl
10b40e: f7fc f8dd bl 1075cc <jffs2_free_refblock>
while (ref) {
10b412: b9bd cbnz r5, 10b444 <jffs2_free_jeb_node_refs+0xb4>
}
jeb->first_node = jeb->last_node = NULL;
10b414: 2300 movs r3, #0
10b416: e9c6 330a strd r3, r3, [r6, #40] ; 0x28
}
10b41a: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
if (ic->nodes == (void *)ic && ic->pino_nlink == 0)
10b41e: f8de 3014 ldr.w r3, [lr, #20] <== NOT EXECUTED
10b422: 2b00 cmp r3, #0 <== NOT EXECUTED
10b424: d1ed bne.n 10b402 <jffs2_free_jeb_node_refs+0x72> <== NOT EXECUTED
jffs2_del_ino_cache(c, ic);
10b426: 4671 mov r1, lr <== NOT EXECUTED
10b428: 4640 mov r0, r8 <== NOT EXECUTED
ref++;
10b42a: 3508 adds r5, #8 <== NOT EXECUTED
jffs2_del_ino_cache(c, ic);
10b42c: f7fc fbae bl 107b8c <jffs2_del_ino_cache> <== NOT EXECUTED
while (ref) {
10b430: e7e8 b.n 10b404 <jffs2_free_jeb_node_refs+0x74> <== NOT EXECUTED
JFFS2_WARNING("inode_cache/xattr_datum/xattr_ref"
10b432: f648 10ac movw r0, #35244 ; 0x89ac <== NOT EXECUTED
10b436: 4649 mov r1, r9 <== NOT EXECUTED
10b438: f2c0 0011 movt r0, #17 <== NOT EXECUTED
ref++;
10b43c: 3508 adds r5, #8 <== NOT EXECUTED
JFFS2_WARNING("inode_cache/xattr_datum/xattr_ref"
10b43e: f7ff ff99 bl 10b374 <jffs2_printk> <== NOT EXECUTED
while (ref) {
10b442: e7df b.n 10b404 <jffs2_free_jeb_node_refs+0x74> <== NOT EXECUTED
10b444: 46aa mov sl, r5
10b446: e7b0 b.n 10b3aa <jffs2_free_jeb_node_refs+0x1a>
00107c20 <jffs2_free_raw_node_refs>:
for (i=0; i<c->nr_blocks; i++) {
107c20: 6d01 ldr r1, [r0, #80] ; 0x50
107c22: b379 cbz r1, 107c84 <jffs2_free_raw_node_refs+0x64>
{
107c24: e92d 43f8 stmdb sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
for (i=0; i<c->nr_blocks; i++) {
107c28: 2600 movs r6, #0
this = c->blocks[i].first_node;
107c2a: 6d43 ldr r3, [r0, #84] ; 0x54
107c2c: 4604 mov r4, r0
107c2e: f04f 0834 mov.w r8, #52 ; 0x34
c->blocks[i].first_node = c->blocks[i].last_node = NULL;
107c32: 4637 mov r7, r6
107c34: e009 b.n 107c4a <jffs2_free_raw_node_refs+0x2a>
jffs2_free_refblock(this);
107c36: f7ff fcc9 bl 1075cc <jffs2_free_refblock> <== NOT EXECUTED
while (this) {
107c3a: e9d4 1314 ldrd r1, r3, [r4, #80] ; 0x50 <== NOT EXECUTED
c->blocks[i].first_node = c->blocks[i].last_node = NULL;
107c3e: 195a adds r2, r3, r5 <== NOT EXECUTED
for (i=0; i<c->nr_blocks; i++) {
107c40: 3601 adds r6, #1 <== NOT EXECUTED
c->blocks[i].first_node = c->blocks[i].last_node = NULL;
107c42: e9c2 770a strd r7, r7, [r2, #40] ; 0x28 <== NOT EXECUTED
for (i=0; i<c->nr_blocks; i++) {
107c46: 42b1 cmp r1, r6 <== NOT EXECUTED
107c48: d91a bls.n 107c80 <jffs2_free_raw_node_refs+0x60> <== NOT EXECUTED
this = c->blocks[i].first_node;
107c4a: fb08 f506 mul.w r5, r8, r6
107c4e: 195a adds r2, r3, r5
107c50: 6a90 ldr r0, [r2, #40] ; 0x28
while (this) {
107c52: 2800 cmp r0, #0
107c54: d0f4 beq.n 107c40 <jffs2_free_raw_node_refs+0x20> <== ALWAYS TAKEN
if (this[REFS_PER_BLOCK].flash_offset == REF_LINK_NODE)
107c56: f8d0 30f4 ldr.w r3, [r0, #244] ; 0xf4
107c5a: 3301 adds r3, #1
107c5c: d1eb bne.n 107c36 <jffs2_free_raw_node_refs+0x16> <== ALWAYS TAKEN
next = this[REFS_PER_BLOCK].next_in_ino;
107c5e: f8d0 90f0 ldr.w r9, [r0, #240] ; 0xf0
jffs2_free_refblock(this);
107c62: f7ff fcb3 bl 1075cc <jffs2_free_refblock>
while (this) {
107c66: 4648 mov r0, r9
107c68: f1b9 0f00 cmp.w r9, #0
107c6c: d1f3 bne.n 107c56 <jffs2_free_raw_node_refs+0x36>
107c6e: 6d21 ldr r1, [r4, #80] ; 0x50
for (i=0; i<c->nr_blocks; i++) {
107c70: 3601 adds r6, #1
c->blocks[i].first_node = c->blocks[i].last_node = NULL;
107c72: 6d63 ldr r3, [r4, #84] ; 0x54
for (i=0; i<c->nr_blocks; i++) {
107c74: 42b1 cmp r1, r6
c->blocks[i].first_node = c->blocks[i].last_node = NULL;
107c76: eb03 0205 add.w r2, r3, r5
107c7a: e9c2 770a strd r7, r7, [r2, #40] ; 0x28
for (i=0; i<c->nr_blocks; i++) {
107c7e: d8e4 bhi.n 107c4a <jffs2_free_raw_node_refs+0x2a>
}
107c80: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc}
107c84: 4770 bx lr <== NOT EXECUTED
107c86: bf00 nop
001066d8 <jffs2_garbage_collect_pass>:
{
1066d8: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
if (!c->unchecked_size)
1066dc: 4680 mov r8, r0
1066de: 6b85 ldr r5, [r0, #56] ; 0x38
{
1066e0: b09f sub sp, #124 ; 0x7c
if (!c->unchecked_size)
1066e2: 2d00 cmp r5, #0
1066e4: d063 beq.n 1067ae <jffs2_garbage_collect_pass+0xd6> <== NEVER TAKEN
for (bucket = c->check_ino % c->inocache_hashsize ; bucket < c->inocache_hashsize; bucket++) {
1066e6: f8d8 40c0 ldr.w r4, [r8, #192] ; 0xc0 <== NOT EXECUTED
want_ino = c->check_ino;
1066ea: f8d8 6008 ldr.w r6, [r8, #8] <== NOT EXECUTED
for (bucket = c->check_ino % c->inocache_hashsize ; bucket < c->inocache_hashsize; bucket++) {
1066ee: 4621 mov r1, r4 <== NOT EXECUTED
1066f0: 4630 mov r0, r6 <== NOT EXECUTED
1066f2: f00e f863 bl 1147bc <__aeabi_uidivmod> <== NOT EXECUTED
1066f6: 428c cmp r4, r1 <== NOT EXECUTED
1066f8: dd14 ble.n 106724 <jffs2_garbage_collect_pass+0x4c> <== NOT EXECUTED
1066fa: f8d8 30c4 ldr.w r3, [r8, #196] ; 0xc4 <== NOT EXECUTED
1066fe: eb03 0c81 add.w ip, r3, r1, lsl #2 <== NOT EXECUTED
for (ic = c->inocache_list[bucket]; ic; ic = ic->next) {
106702: f85c 7b04 ldr.w r7, [ip], #4 <== NOT EXECUTED
106706: b14f cbz r7, 10671c <jffs2_garbage_collect_pass+0x44> <== NOT EXECUTED
if (ic->ino < want_ino)
106708: 68fb ldr r3, [r7, #12] <== NOT EXECUTED
10670a: 42b3 cmp r3, r6 <== NOT EXECUTED
10670c: d303 bcc.n 106716 <jffs2_garbage_collect_pass+0x3e> <== NOT EXECUTED
if (ic->state != INO_STATE_CHECKEDABSENT &&
10670e: 897a ldrh r2, [r7, #10] <== NOT EXECUTED
106710: 1e90 subs r0, r2, #2 <== NOT EXECUTED
106712: 2801 cmp r0, #1 <== NOT EXECUTED
106714: d81d bhi.n 106752 <jffs2_garbage_collect_pass+0x7a> <== NOT EXECUTED
for (ic = c->inocache_list[bucket]; ic; ic = ic->next) {
106716: 693f ldr r7, [r7, #16] <== NOT EXECUTED
106718: 2f00 cmp r7, #0 <== NOT EXECUTED
10671a: d1f5 bne.n 106708 <jffs2_garbage_collect_pass+0x30> <== NOT EXECUTED
for (bucket = c->check_ino % c->inocache_hashsize ; bucket < c->inocache_hashsize; bucket++) {
10671c: 3101 adds r1, #1 <== NOT EXECUTED
want_ino = 0;
10671e: 2600 movs r6, #0 <== NOT EXECUTED
for (bucket = c->check_ino % c->inocache_hashsize ; bucket < c->inocache_hashsize; bucket++) {
106720: 428c cmp r4, r1 <== NOT EXECUTED
106722: d1ee bne.n 106702 <jffs2_garbage_collect_pass+0x2a> <== NOT EXECUTED
c->check_ino = ((c->highest_ino + c->inocache_hashsize + 1) &
106724: 4643 mov r3, r8 <== NOT EXECUTED
106726: 46a0 mov r8, r4 <== NOT EXECUTED
106728: 461c mov r4, r3 <== NOT EXECUTED
10672a: 685b ldr r3, [r3, #4] <== NOT EXECUTED
pr_crit("Checked all inodes but still 0x%x bytes of unchecked space?\n",
10672c: f246 5084 movw r0, #25988 ; 0x6584 <== NOT EXECUTED
106730: 4629 mov r1, r5 <== NOT EXECUTED
return -ENOSPC;
106732: f06f 061b mvn.w r6, #27 <== NOT EXECUTED
pr_crit("Checked all inodes but still 0x%x bytes of unchecked space?\n",
106736: f2c0 0011 movt r0, #17 <== NOT EXECUTED
c->check_ino = ((c->highest_ino + c->inocache_hashsize + 1) &
10673a: 3301 adds r3, #1 <== NOT EXECUTED
10673c: 4443 add r3, r8 <== NOT EXECUTED
10673e: ea23 0308 bic.w r3, r3, r8 <== NOT EXECUTED
~c->inocache_hashsize) - 1;
106742: 3b01 subs r3, #1 <== NOT EXECUTED
c->check_ino = ((c->highest_ino + c->inocache_hashsize + 1) &
106744: 60a3 str r3, [r4, #8] <== NOT EXECUTED
pr_crit("Checked all inodes but still 0x%x bytes of unchecked space?\n",
106746: f7ff fe55 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
}
10674a: 4630 mov r0, r6 <== NOT EXECUTED
10674c: b01f add sp, #124 ; 0x7c <== NOT EXECUTED
10674e: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (!ic->pino_nlink) {
106752: 6979 ldr r1, [r7, #20] <== NOT EXECUTED
c->check_ino = ic->ino + c->inocache_hashsize;
106754: 441c add r4, r3 <== NOT EXECUTED
106756: f8c8 4008 str.w r4, [r8, #8] <== NOT EXECUTED
if (!ic->pino_nlink) {
10675a: 2900 cmp r1, #0 <== NOT EXECUTED
10675c: d0c1 beq.n 1066e2 <jffs2_garbage_collect_pass+0xa> <== NOT EXECUTED
10675e: 4644 mov r4, r8 <== NOT EXECUTED
switch(ic->state) {
106760: 2a05 cmp r2, #5 <== NOT EXECUTED
106762: d867 bhi.n 106834 <jffs2_garbage_collect_pass+0x15c> <== NOT EXECUTED
106764: e8df f002 tbb [pc, r2] <== NOT EXECUTED
106768: 66665003 .word 0x66665003 <== NOT EXECUTED
10676c: 1450 .short 0x1450 <== NOT EXECUTED
ic->state = INO_STATE_CHECKING;
10676e: 2301 movs r3, #1 <== NOT EXECUTED
ret = jffs2_do_crccheck_inode(c, ic);
106770: 4639 mov r1, r7 <== NOT EXECUTED
106772: 4640 mov r0, r8 <== NOT EXECUTED
ic->state = INO_STATE_CHECKING;
106774: 817b strh r3, [r7, #10] <== NOT EXECUTED
ret = jffs2_do_crccheck_inode(c, ic);
106776: f003 fb33 bl 109de0 <jffs2_do_crccheck_inode> <== NOT EXECUTED
if (ret)
10677a: 4606 mov r6, r0 <== NOT EXECUTED
10677c: b978 cbnz r0, 10679e <jffs2_garbage_collect_pass+0xc6> <== NOT EXECUTED
jffs2_set_inocache_state(c, ic, INO_STATE_CHECKEDABSENT);
10677e: 2203 movs r2, #3 <== NOT EXECUTED
106780: 4639 mov r1, r7 <== NOT EXECUTED
106782: 4620 mov r0, r4 <== NOT EXECUTED
106784: f001 f9ca bl 107b1c <jffs2_set_inocache_state> <== NOT EXECUTED
}
106788: 4630 mov r0, r6
10678a: b01f add sp, #124 ; 0x7c
10678c: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return 0;
106790: 2600 movs r6, #0 <== NOT EXECUTED
c->check_ino = ic->ino;
106792: f8c8 3008 str.w r3, [r8, #8] <== NOT EXECUTED
}
106796: 4630 mov r0, r6 <== NOT EXECUTED
106798: b01f add sp, #124 ; 0x7c <== NOT EXECUTED
10679a: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
pr_warn("Returned error for crccheck of ino #%u. Expect badness...\n",
10679e: f246 6034 movw r0, #26164 ; 0x6634 <== NOT EXECUTED
1067a2: 68f9 ldr r1, [r7, #12] <== NOT EXECUTED
1067a4: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1067a8: f7ff fe24 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
1067ac: e7e7 b.n 10677e <jffs2_garbage_collect_pass+0xa6> <== NOT EXECUTED
if (!list_empty(&c->erase_complete_list) ||
1067ae: f8d8 20a0 ldr.w r2, [r8, #160] ; 0xa0
1067b2: f108 03a0 add.w r3, r8, #160 ; 0xa0
1067b6: 4644 mov r4, r8
1067b8: 429a cmp r2, r3
1067ba: d04a beq.n 106852 <jffs2_garbage_collect_pass+0x17a> <== NEVER TAKEN
if (jffs2_erase_pending_blocks(c, 1))
1067bc: 2101 movs r1, #1
1067be: 4620 mov r0, r4
1067c0: f004 fe42 bl 10b448 <jffs2_erase_pending_blocks>
1067c4: 2800 cmp r0, #0
1067c6: d14b bne.n 106860 <jffs2_garbage_collect_pass+0x188> <== NEVER TAKEN
jeb = c->gcblock;
1067c8: f8d4 805c ldr.w r8, [r4, #92] ; 0x5c
if (!jeb)
1067cc: f1b8 0f00 cmp.w r8, #0
1067d0: d070 beq.n 1068b4 <jffs2_garbage_collect_pass+0x1dc>
if (!jeb->used_size) {
1067d2: f8d8 6014 ldr.w r6, [r8, #20]
1067d6: 2e00 cmp r6, #0
1067d8: f000 80e1 beq.w 10699e <jffs2_garbage_collect_pass+0x2c6> <== ALWAYS TAKEN
raw = jeb->gc_node;
1067dc: f8d8 9030 ldr.w r9, [r8, #48] ; 0x30
while(ref_obsolete(raw)) {
1067e0: f8d9 3004 ldr.w r3, [r9, #4]
1067e4: 464a mov r2, r9
1067e6: e001 b.n 1067ec <jffs2_garbage_collect_pass+0x114>
if (!ref)
return ref;
}
/* End of chain */
if (ref->flash_offset == REF_EMPTY_NODE)
1067e8: 1c99 adds r1, r3, #2
1067ea: d03b beq.n 106864 <jffs2_garbage_collect_pass+0x18c> <== ALWAYS TAKEN
1067ec: f003 0303 and.w r3, r3, #3
1067f0: 2b01 cmp r3, #1
1067f2: f040 80ef bne.w 1069d4 <jffs2_garbage_collect_pass+0x2fc>
if (ref->flash_offset == REF_LINK_NODE) {
1067f6: 68d3 ldr r3, [r2, #12]
1067f8: 1c58 adds r0, r3, #1
ref++;
1067fa: bf18 it ne
1067fc: 3208 addne r2, #8
if (ref->flash_offset == REF_LINK_NODE) {
1067fe: d1f3 bne.n 1067e8 <jffs2_garbage_collect_pass+0x110>
ref = ref->next_in_ino;
106800: 6892 ldr r2, [r2, #8]
if (!ref)
106802: b37a cbz r2, 106864 <jffs2_garbage_collect_pass+0x18c>
if (ref->flash_offset == REF_EMPTY_NODE)
106804: 6853 ldr r3, [r2, #4]
106806: e7ef b.n 1067e8 <jffs2_garbage_collect_pass+0x110>
pr_warn("Inode #%u is in state %d during CRC check phase!\n",
106808: f246 50cc movw r0, #26060 ; 0x65cc <== NOT EXECUTED
10680c: 4619 mov r1, r3 <== NOT EXECUTED
10680e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106812: f7ff fdef bl 1063f4 <jffs2_printk> <== NOT EXECUTED
BUG();
106816: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
10681a: f646 6200 movw r2, #28160 ; 0x6e00 <== NOT EXECUTED
10681e: f246 6008 movw r0, #26120 ; 0x6608 <== NOT EXECUTED
106822: f2c0 0311 movt r3, #17 <== NOT EXECUTED
106826: f2c0 0211 movt r2, #17 <== NOT EXECUTED
10682a: 21d3 movs r1, #211 ; 0xd3 <== NOT EXECUTED
10682c: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106830: f005 ff1e bl 10c670 <__assert_func> <== NOT EXECUTED
BUG();
106834: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
106838: f646 6200 movw r2, #28160 ; 0x6e00 <== NOT EXECUTED
10683c: f246 6008 movw r0, #26120 ; 0x6608 <== NOT EXECUTED
106840: f2c0 0311 movt r3, #17 <== NOT EXECUTED
106844: f2c0 0211 movt r2, #17 <== NOT EXECUTED
106848: 21e4 movs r1, #228 ; 0xe4 <== NOT EXECUTED
10684a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10684e: f005 ff0f bl 10c670 <__assert_func> <== NOT EXECUTED
if (!list_empty(&c->erase_complete_list) ||
106852: f8d8 2098 ldr.w r2, [r8, #152] ; 0x98
!list_empty(&c->erase_pending_list)) {
106856: f108 0398 add.w r3, r8, #152 ; 0x98
if (!list_empty(&c->erase_complete_list) ||
10685a: 429a cmp r2, r3
10685c: d1ae bne.n 1067bc <jffs2_garbage_collect_pass+0xe4>
10685e: e7b3 b.n 1067c8 <jffs2_garbage_collect_pass+0xf0>
switch(ic->state) {
106860: 2600 movs r6, #0
106862: e791 b.n 106788 <jffs2_garbage_collect_pass+0xb0>
pr_warn("eep. End of raw list while still supposedly nodes to GC\n");
106864: f246 60b8 movw r0, #26296 ; 0x66b8 <== NOT EXECUTED
106868: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10686c: f7ff fdc2 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
pr_warn("erase block at 0x%08x. free_size 0x%08x, dirty_size 0x%08x, used_size 0x%08x\n",
106870: f8d8 0014 ldr.w r0, [r8, #20] <== NOT EXECUTED
106874: f8d8 3018 ldr.w r3, [r8, #24] <== NOT EXECUTED
106878: f8d8 2020 ldr.w r2, [r8, #32] <== NOT EXECUTED
10687c: f8d8 100c ldr.w r1, [r8, #12] <== NOT EXECUTED
106880: 9000 str r0, [sp, #0] <== NOT EXECUTED
106882: f246 60fc movw r0, #26364 ; 0x66fc <== NOT EXECUTED
106886: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10688a: f7ff fdb3 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
jeb->gc_node = raw;
10688e: 2000 movs r0, #0 <== NOT EXECUTED
BUG();
106890: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
106894: f646 6200 movw r2, #28160 ; 0x6e00 <== NOT EXECUTED
jeb->gc_node = raw;
106898: f8c8 0030 str.w r0, [r8, #48] ; 0x30 <== NOT EXECUTED
BUG();
10689c: f246 6008 movw r0, #26120 ; 0x6608 <== NOT EXECUTED
1068a0: f2c0 0311 movt r3, #17 <== NOT EXECUTED
1068a4: f2c0 0211 movt r2, #17 <== NOT EXECUTED
1068a8: f240 1133 movw r1, #307 ; 0x133 <== NOT EXECUTED
1068ac: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1068b0: f005 fede bl 10c670 <__assert_func> <== NOT EXECUTED
1068b4: f243 6314 movw r3, #13844 ; 0x3614
/* Is this list empty? */
static __inline__ int
list_empty( struct list_head *list )
{
return ( list->next == list );
1068b8: 4622 mov r2, r4
1068ba: f2c0 0322 movt r3, #34 ; 0x22
1068be: f852 7fb8 ldr.w r7, [r2, #184]!
1068c2: 681e ldr r6, [r3, #0]
} else if (!list_empty(&c->erasable_pending_wbuf_list)) {
1068c4: 46a9 mov r9, r5
} else if (n < 126 && !list_empty(&c->dirty_list)) {
1068c6: f104 0e70 add.w lr, r4, #112 ; 0x70
} else if (!list_empty(&c->clean_list)) {
1068ca: f104 0c60 add.w ip, r4, #96 ; 0x60
} else if (n < 110 && !list_empty(&c->very_dirty_list)) {
1068ce: f104 0068 add.w r0, r4, #104 ; 0x68
} else if (n < 50 && !list_empty(&c->erasable_list)) {
1068d2: f104 0178 add.w r1, r4, #120 ; 0x78
int n = jiffies % 128;
1068d6: f006 067f and.w r6, r6, #127 ; 0x7f
} else if (!list_empty(&c->erasable_pending_wbuf_list)) {
1068da: f104 0880 add.w r8, r4, #128 ; 0x80
1068de: 4615 mov r5, r2
1068e0: e01b b.n 10691a <jffs2_garbage_collect_pass+0x242>
} else if (n < 50 && !list_empty(&c->erasable_list)) {
1068e2: 6fa2 ldr r2, [r4, #120] ; 0x78
1068e4: 460b mov r3, r1
1068e6: 4291 cmp r1, r2
1068e8: d12d bne.n 106946 <jffs2_garbage_collect_pass+0x26e> <== ALWAYS TAKEN
} else if (n < 110 && !list_empty(&c->very_dirty_list)) {
1068ea: 6ea2 ldr r2, [r4, #104] ; 0x68
1068ec: 4603 mov r3, r0
1068ee: 4290 cmp r0, r2
1068f0: d129 bne.n 106946 <jffs2_garbage_collect_pass+0x26e>
} else if (n < 126 && !list_empty(&c->dirty_list)) {
1068f2: 6f22 ldr r2, [r4, #112] ; 0x70
1068f4: 4673 mov r3, lr
1068f6: 4596 cmp lr, r2
1068f8: d125 bne.n 106946 <jffs2_garbage_collect_pass+0x26e> <== ALWAYS TAKEN
} else if (!list_empty(&c->clean_list)) {
1068fa: 6e22 ldr r2, [r4, #96] ; 0x60
1068fc: 4663 mov r3, ip
1068fe: 4562 cmp r2, ip
106900: d121 bne.n 106946 <jffs2_garbage_collect_pass+0x26e> <== ALWAYS TAKEN
} else if (!list_empty(&c->very_dirty_list)) {
106902: 6ea2 ldr r2, [r4, #104] ; 0x68
106904: 4603 mov r3, r0
106906: 4290 cmp r0, r2
106908: d11d bne.n 106946 <jffs2_garbage_collect_pass+0x26e> <== ALWAYS TAKEN
} else if (!list_empty(&c->erasable_list)) {
10690a: 6fa2 ldr r2, [r4, #120] ; 0x78
10690c: 460b mov r3, r1
10690e: 4291 cmp r1, r2
106910: d119 bne.n 106946 <jffs2_garbage_collect_pass+0x26e> <== ALWAYS TAKEN
} else if (!list_empty(&c->erasable_pending_wbuf_list)) {
106912: f8d4 3080 ldr.w r3, [r4, #128] ; 0x80
106916: 4543 cmp r3, r8
106918: d039 beq.n 10698e <jffs2_garbage_collect_pass+0x2b6> <== NEVER TAKEN
if (!list_empty(&c->bad_used_list) && c->nr_free_blocks > c->resv_blocks_gcbad) {
10691a: 42af cmp r7, r5
10691c: d005 beq.n 10692a <jffs2_garbage_collect_pass+0x252> <== NEVER TAKEN
10691e: f894 2047 ldrb.w r2, [r4, #71] ; 0x47 <== NOT EXECUTED
106922: 6be3 ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
106924: 4293 cmp r3, r2 <== NOT EXECUTED
106926: f200 80ea bhi.w 106afe <jffs2_garbage_collect_pass+0x426> <== NOT EXECUTED
} else if (n < 50 && !list_empty(&c->erasable_list)) {
10692a: 2e31 cmp r6, #49 ; 0x31
10692c: ddd9 ble.n 1068e2 <jffs2_garbage_collect_pass+0x20a> <== NEVER TAKEN
} else if (n < 110 && !list_empty(&c->very_dirty_list)) {
10692e: 2e6d cmp r6, #109 ; 0x6d <== NOT EXECUTED
106930: dddb ble.n 1068ea <jffs2_garbage_collect_pass+0x212> <== NOT EXECUTED
} else if (n < 126 && !list_empty(&c->dirty_list)) {
106932: 2e7d cmp r6, #125 ; 0x7d <== NOT EXECUTED
106934: dddd ble.n 1068f2 <jffs2_garbage_collect_pass+0x21a> <== NOT EXECUTED
} else if (!list_empty(&c->clean_list)) {
106936: 6e22 ldr r2, [r4, #96] ; 0x60 <== NOT EXECUTED
106938: 4663 mov r3, ip <== NOT EXECUTED
10693a: 4594 cmp ip, r2 <== NOT EXECUTED
10693c: d103 bne.n 106946 <jffs2_garbage_collect_pass+0x26e> <== NOT EXECUTED
} else if (!list_empty(&c->dirty_list)) {
10693e: 6f22 ldr r2, [r4, #112] ; 0x70 <== NOT EXECUTED
106940: 4673 mov r3, lr <== NOT EXECUTED
106942: 4596 cmp lr, r2 <== NOT EXECUTED
106944: d0dd beq.n 106902 <jffs2_garbage_collect_pass+0x22a> <== NOT EXECUTED
106946: 464d mov r5, r9
ret = list_entry(nextlist->next, struct jffs2_eraseblock, list);
106948: f8d3 8000 ldr.w r8, [r3]
ent->prev->next = ent->next;
10694c: e9d8 3200 ldrd r3, r2, [r8]
106950: 6013 str r3, [r2, #0]
ent->next->prev = ent->prev;
106952: 605a str r2, [r3, #4]
ret->gc_node = ret->first_node;
106954: f8d8 3028 ldr.w r3, [r8, #40] ; 0x28
c->gcblock = ret;
106958: f8c4 805c str.w r8, [r4, #92] ; 0x5c
ret->gc_node = ret->first_node;
10695c: f8c8 3030 str.w r3, [r8, #48] ; 0x30
if (!ret->gc_node) {
106960: 2b00 cmp r3, #0
106962: f000 80ae beq.w 106ac2 <jffs2_garbage_collect_pass+0x3ea> <== ALWAYS TAKEN
if (ret->wasted_size) {
106966: f8d8 301c ldr.w r3, [r8, #28]
10696a: 2b00 cmp r3, #0
10696c: f43f af31 beq.w 1067d2 <jffs2_garbage_collect_pass+0xfa> <== NEVER TAKEN
ret->dirty_size += ret->wasted_size;
106970: f8d8 2018 ldr.w r2, [r8, #24] <== NOT EXECUTED
106974: 441a add r2, r3 <== NOT EXECUTED
106976: f8c8 2018 str.w r2, [r8, #24] <== NOT EXECUTED
c->wasted_size -= ret->wasted_size;
10697a: 6a62 ldr r2, [r4, #36] ; 0x24 <== NOT EXECUTED
10697c: 1ad2 subs r2, r2, r3 <== NOT EXECUTED
10697e: 6262 str r2, [r4, #36] ; 0x24 <== NOT EXECUTED
c->dirty_size += ret->wasted_size;
106980: 6a22 ldr r2, [r4, #32] <== NOT EXECUTED
106982: 4413 add r3, r2 <== NOT EXECUTED
ret->wasted_size = 0;
106984: 2200 movs r2, #0 <== NOT EXECUTED
c->dirty_size += ret->wasted_size;
106986: 6223 str r3, [r4, #32] <== NOT EXECUTED
ret->wasted_size = 0;
106988: f8c8 201c str.w r2, [r8, #28] <== NOT EXECUTED
10698c: e721 b.n 1067d2 <jffs2_garbage_collect_pass+0xfa> <== NOT EXECUTED
if (c->nr_erasing_blocks) {
10698e: 6c23 ldr r3, [r4, #64] ; 0x40
return -EIO;
106990: 2b00 cmp r3, #0
106992: bf14 ite ne
106994: f06f 060a mvnne.w r6, #10
106998: f06f 0604 mvneq.w r6, #4
10699c: e6f4 b.n 106788 <jffs2_garbage_collect_pass+0xb0>
if (c->gcblock && !c->gcblock->used_size) {
10699e: 6de3 ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED
1069a0: 695d ldr r5, [r3, #20]
1069a2: 2d00 cmp r5, #0
1069a4: f47f aef0 bne.w 106788 <jffs2_garbage_collect_pass+0xb0> <== NEVER TAKEN
rtems_jffs2_flash_control *fc = sb->s_flash_control;
1069a8: f8d4 00e4 ldr.w r0, [r4, #228] ; 0xe4 <== NOT EXECUTED
list_add_tail(&c->gcblock->list, &c->erase_pending_list);
1069ac: f104 0c98 add.w ip, r4, #152 ; 0x98 <== NOT EXECUTED
c->nr_erasing_blocks++;
1069b0: 6c22 ldr r2, [r4, #64] ; 0x40 <== NOT EXECUTED
struct list_head *prev = beforethisent->prev;
1069b2: f8d4 709c ldr.w r7, [r4, #156] ; 0x9c <== NOT EXECUTED
if (fc->trigger_garbage_collection != NULL) {
1069b6: 6a01 ldr r1, [r0, #32] <== NOT EXECUTED
1069b8: 3201 adds r2, #1 <== NOT EXECUTED
newent->next = beforethisent;
1069ba: f8c3 c000 str.w ip, [r3] <== NOT EXECUTED
newent->prev = prev;
1069be: 605f str r7, [r3, #4] <== NOT EXECUTED
beforethisent->prev = newent;
1069c0: f8c4 309c str.w r3, [r4, #156] ; 0x9c <== NOT EXECUTED
prev->next = newent;
1069c4: 603b str r3, [r7, #0] <== NOT EXECUTED
c->gcblock = NULL;
1069c6: 65e5 str r5, [r4, #92] ; 0x5c <== NOT EXECUTED
c->nr_erasing_blocks++;
1069c8: 6422 str r2, [r4, #64] ; 0x40 <== NOT EXECUTED
1069ca: 2900 cmp r1, #0 <== NOT EXECUTED
1069cc: f43f aedc beq.w 106788 <jffs2_garbage_collect_pass+0xb0> <== NOT EXECUTED
(*fc->trigger_garbage_collection)(fc);
1069d0: 4788 blx r1 <== NOT EXECUTED
1069d2: e6d9 b.n 106788 <jffs2_garbage_collect_pass+0xb0> <== NOT EXECUTED
if (!raw->next_in_ino) {
1069d4: f8d2 b000 ldr.w fp, [r2]
jeb->gc_node = raw;
1069d8: 4691 mov r9, r2
1069da: f8c8 2030 str.w r2, [r8, #48] ; 0x30
gcblock_dirty = jeb->dirty_size;
1069de: f8d8 2018 ldr.w r2, [r8, #24]
1069e2: 9205 str r2, [sp, #20]
if (!raw->next_in_ino) {
1069e4: 465a mov r2, fp
1069e6: f1bb 0f00 cmp.w fp, #0
1069ea: d062 beq.n 106ab2 <jffs2_garbage_collect_pass+0x3da> <== ALWAYS TAKEN
1069ec: 4617 mov r7, r2
return ref;
}
static inline struct jffs2_inode_cache *jffs2_raw_ref_to_ic(struct jffs2_raw_node_ref *raw)
{
while(raw->next_in_ino)
1069ee: 6812 ldr r2, [r2, #0]
1069f0: 2a00 cmp r2, #0
1069f2: d1fb bne.n 1069ec <jffs2_garbage_collect_pass+0x314> <== ALWAYS TAKEN
switch(ic->state) {
1069f4: 4693 mov fp, r2
1069f6: 897a ldrh r2, [r7, #10]
1069f8: 2a05 cmp r2, #5
1069fa: d838 bhi.n 106a6e <jffs2_garbage_collect_pass+0x396> <== ALWAYS TAKEN
1069fc: a101 add r1, pc, #4 ; (adr r1, 106a04 <jffs2_garbage_collect_pass+0x32c>)
1069fe: f851 f022 ldr.w pc, [r1, r2, lsl #2]
106a02: bf00 nop
106a04: 00106a1d .word 0x00106a1d
106a08: 00106a1d .word 0x00106a1d
106a0c: 00106a6f .word 0x00106a6f
106a10: 00106a4b .word 0x00106a4b
106a14: 00106a1d .word 0x00106a1d
106a18: 00106861 .word 0x00106861
pr_crit("Inode #%u already in state %d in jffs2_garbage_collect_pass()!\n",
106a1c: f246 7054 movw r0, #26452 ; 0x6754 <== NOT EXECUTED
106a20: 68f9 ldr r1, [r7, #12] <== NOT EXECUTED
106a22: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106a26: f7ff fce5 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
BUG();
106a2a: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
106a2e: f646 6200 movw r2, #28160 ; 0x6e00 <== NOT EXECUTED
106a32: f246 6008 movw r0, #26120 ; 0x6608 <== NOT EXECUTED
106a36: f2c0 0311 movt r3, #17 <== NOT EXECUTED
106a3a: f2c0 0211 movt r2, #17 <== NOT EXECUTED
106a3e: f240 118d movw r1, #397 ; 0x18d <== NOT EXECUTED
106a42: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106a46: f005 fe13 bl 10c670 <__assert_func> <== NOT EXECUTED
if (ref_flags(raw) == REF_PRISTINE)
106a4a: 2b02 cmp r3, #2
106a4c: d10f bne.n 106a6e <jffs2_garbage_collect_pass+0x396>
ic->state = INO_STATE_GC;
106a4e: 2304 movs r3, #4
ret = jffs2_garbage_collect_pristine(c, ic, raw);
106a50: 464a mov r2, r9
ic->state = INO_STATE_GC;
106a52: 817b strh r3, [r7, #10]
ret = jffs2_garbage_collect_pristine(c, ic, raw);
106a54: 4639 mov r1, r7
106a56: 4620 mov r0, r4
106a58: f7ff fcda bl 106410 <jffs2_garbage_collect_pristine>
if (ret != -EBADFD) {
106a5c: f248 0301 movw r3, #32769 ; 0x8001
ic->state = INO_STATE_CHECKEDABSENT;
106a60: 2203 movs r2, #3
if (ret != -EBADFD) {
106a62: f6cf 73ff movt r3, #65535 ; 0xffff
ret = jffs2_garbage_collect_pristine(c, ic, raw);
106a66: 4606 mov r6, r0
if (ret != -EBADFD) {
106a68: 4298 cmp r0, r3
ic->state = INO_STATE_CHECKEDABSENT;
106a6a: 817a strh r2, [r7, #10]
if (ret != -EBADFD) {
106a6c: d117 bne.n 106a9e <jffs2_garbage_collect_pass+0x3c6> <== NEVER TAKEN
f = jffs2_gc_fetch_inode(c, inum, !nlink);
106a6e: 697a ldr r2, [r7, #20]
106a70: 4620 mov r0, r4
106a72: 68f9 ldr r1, [r7, #12]
106a74: fab2 f282 clz r2, r2
106a78: 0952 lsrs r2, r2, #5
106a7a: f7ff fc9d bl 1063b8 <jffs2_gc_fetch_inode>
if (IS_ERR(f)) {
106a7e: f510 7f7a cmn.w r0, #1000 ; 0x3e8
f = jffs2_gc_fetch_inode(c, inum, !nlink);
106a82: 4607 mov r7, r0
if (IS_ERR(f)) {
106a84: f200 808c bhi.w 106ba0 <jffs2_garbage_collect_pass+0x4c8> <== ALWAYS TAKEN
if (!f) {
106a88: 2800 cmp r0, #0
106a8a: f000 8089 beq.w 106ba0 <jffs2_garbage_collect_pass+0x4c8> <== ALWAYS TAKEN
if (c->gcblock != jeb) {
106a8e: 6de3 ldr r3, [r4, #92] ; 0x5c
106a90: 4598 cmp r8, r3
106a92: d04a beq.n 106b2a <jffs2_garbage_collect_pass+0x452> <== NEVER TAKEN
int ret = 0;
106a94: 2600 movs r6, #0 <== NOT EXECUTED
jffs2_gc_release_inode(c, f);
106a96: 4639 mov r1, r7
106a98: 4620 mov r0, r4
106a9a: f7ff fc89 bl 1063b0 <jffs2_gc_release_inode>
if (jeb->dirty_size == gcblock_dirty && !ref_obsolete(jeb->gc_node)) {
106a9e: f8d8 3018 ldr.w r3, [r8, #24]
106aa2: 9a05 ldr r2, [sp, #20]
106aa4: 4293 cmp r3, r2
106aa6: d02e beq.n 106b06 <jffs2_garbage_collect_pass+0x42e> <== ALWAYS TAKEN
if (c->gcblock && !c->gcblock->used_size) {
106aa8: 6de3 ldr r3, [r4, #92] ; 0x5c
106aaa: 2b00 cmp r3, #0
106aac: f43f ae6c beq.w 106788 <jffs2_garbage_collect_pass+0xb0>
106ab0: e776 b.n 1069a0 <jffs2_garbage_collect_pass+0x2c8>
if (ref_flags(raw) == REF_PRISTINE) {
106ab2: 2b02 cmp r3, #2 <== NOT EXECUTED
106ab4: d01c beq.n 106af0 <jffs2_garbage_collect_pass+0x418> <== NOT EXECUTED
jffs2_mark_node_obsolete(c, raw);
106ab6: 4649 mov r1, r9 <== NOT EXECUTED
106ab8: 4620 mov r0, r4 <== NOT EXECUTED
int ret = 0, inum, nlink;
106aba: 465e mov r6, fp <== NOT EXECUTED
jffs2_mark_node_obsolete(c, raw);
106abc: f001 fae6 bl 10808c <jffs2_mark_node_obsolete> <== NOT EXECUTED
106ac0: e7f2 b.n 106aa8 <jffs2_garbage_collect_pass+0x3d0> <== NOT EXECUTED
pr_warn("Eep. ret->gc_node for block at 0x%08x is NULL\n",
106ac2: f246 607c movw r0, #26236 ; 0x667c <== NOT EXECUTED
106ac6: f8d8 100c ldr.w r1, [r8, #12] <== NOT EXECUTED
106aca: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106ace: f7ff fc91 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
BUG();
106ad2: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
106ad6: f646 52ec movw r2, #28140 ; 0x6dec <== NOT EXECUTED
106ada: f246 6008 movw r0, #26120 ; 0x6608 <== NOT EXECUTED
106ade: f2c0 0311 movt r3, #17 <== NOT EXECUTED
106ae2: f2c0 0211 movt r2, #17 <== NOT EXECUTED
106ae6: 216a movs r1, #106 ; 0x6a <== NOT EXECUTED
106ae8: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106aec: f005 fdc0 bl 10c670 <__assert_func> <== NOT EXECUTED
jffs2_garbage_collect_pristine(c, NULL, raw);
106af0: 464a mov r2, r9 <== NOT EXECUTED
106af2: 4659 mov r1, fp <== NOT EXECUTED
106af4: 4620 mov r0, r4 <== NOT EXECUTED
int ret = 0, inum, nlink;
106af6: 465e mov r6, fp <== NOT EXECUTED
jffs2_garbage_collect_pristine(c, NULL, raw);
106af8: f7ff fc8a bl 106410 <jffs2_garbage_collect_pristine> <== NOT EXECUTED
106afc: e7d4 b.n 106aa8 <jffs2_garbage_collect_pass+0x3d0> <== NOT EXECUTED
106afe: 462a mov r2, r5 <== NOT EXECUTED
106b00: 464d mov r5, r9 <== NOT EXECUTED
106b02: 4613 mov r3, r2 <== NOT EXECUTED
106b04: e720 b.n 106948 <jffs2_garbage_collect_pass+0x270> <== NOT EXECUTED
if (jeb->dirty_size == gcblock_dirty && !ref_obsolete(jeb->gc_node)) {
106b06: f8d8 3030 ldr.w r3, [r8, #48] ; 0x30 <== NOT EXECUTED
106b0a: 6859 ldr r1, [r3, #4] <== NOT EXECUTED
106b0c: f001 0303 and.w r3, r1, #3 <== NOT EXECUTED
106b10: 2b01 cmp r3, #1 <== NOT EXECUTED
106b12: d0c9 beq.n 106aa8 <jffs2_garbage_collect_pass+0x3d0> <== NOT EXECUTED
pr_err("Error garbage collecting node at %08x!\n",
106b14: f646 5024 movw r0, #27940 ; 0x6d24 <== NOT EXECUTED
106b18: f021 0103 bic.w r1, r1, #3 <== NOT EXECUTED
106b1c: f2c0 0011 movt r0, #17 <== NOT EXECUTED
ret = -ENOSPC;
106b20: f06f 061b mvn.w r6, #27 <== NOT EXECUTED
pr_err("Error garbage collecting node at %08x!\n",
106b24: f7ff fc66 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
ret = -ENOSPC;
106b28: e7be b.n 106aa8 <jffs2_garbage_collect_pass+0x3d0> <== NOT EXECUTED
if (ref_obsolete(raw)) {
106b2a: f8d9 3004 ldr.w r3, [r9, #4]
106b2e: f003 0303 and.w r3, r3, #3
106b32: 2b01 cmp r3, #1
106b34: d0ae beq.n 106a94 <jffs2_garbage_collect_pass+0x3bc> <== ALWAYS TAKEN
if (f->metadata && f->metadata->raw == raw) {
106b36: f8d0 a008 ldr.w sl, [r0, #8]
106b3a: f1ba 0f00 cmp.w sl, #0
106b3e: d004 beq.n 106b4a <jffs2_garbage_collect_pass+0x472>
106b40: f8da 3000 ldr.w r3, [sl]
106b44: 4599 cmp r9, r3
106b46: f000 8339 beq.w 1071bc <jffs2_garbage_collect_pass+0xae4> <== NEVER TAKEN
for (frag = frag_first(&f->fragtree); frag; frag = frag_next(frag)) {
106b4a: 1d3b adds r3, r7, #4
return _RBTree_Predecessor( node );
}
static inline struct rb_node *rb_first( struct rb_root *root )
{
return _RBTree_Minimum( (RBTree_Control *) root );
106b4c: 4618 mov r0, r3
106b4e: 9303 str r3, [sp, #12]
106b50: f00a f8f4 bl 110d3c <_RBTree_Minimum>
static inline struct jffs2_node_frag *frag_first(struct rb_root *root)
{
struct rb_node *node = rb_first(root);
if (!node)
106b54: b1c8 cbz r0, 106b8a <jffs2_garbage_collect_pass+0x4b2>
106b56: f04f 0a00 mov.w sl, #0
106b5a: 4656 mov r6, sl
106b5c: e002 b.n 106b64 <jffs2_garbage_collect_pass+0x48c>
return _RBTree_Successor( node );
106b5e: f00a f901 bl 110d64 <_RBTree_Successor>
106b62: b1f8 cbz r0, 106ba4 <jffs2_garbage_collect_pass+0x4cc>
if (frag->node && frag->node->raw == raw) {
106b64: 6902 ldr r2, [r0, #16]
106b66: 2a00 cmp r2, #0
106b68: d0f9 beq.n 106b5e <jffs2_garbage_collect_pass+0x486> <== ALWAYS TAKEN
106b6a: 6811 ldr r1, [r2, #0]
106b6c: 4589 cmp r9, r1
106b6e: d1f6 bne.n 106b5e <jffs2_garbage_collect_pass+0x486>
end = frag->ofs + frag->size;
106b70: 6985 ldr r5, [r0, #24]
106b72: 6941 ldr r1, [r0, #20]
start = frag->ofs;
106b74: 2e00 cmp r6, #0
106b76: bf08 it eq
106b78: 46aa moveq sl, r5
if (!nrfrags++)
106b7a: 3601 adds r6, #1
end = frag->ofs + frag->size;
106b7c: 440d add r5, r1
if (nrfrags == frag->node->frags)
106b7e: 68d1 ldr r1, [r2, #12]
106b80: 428e cmp r6, r1
106b82: f000 80b8 beq.w 106cf6 <jffs2_garbage_collect_pass+0x61e> <== NEVER TAKEN
106b86: 4693 mov fp, r2 <== NOT EXECUTED
106b88: e7e9 b.n 106b5e <jffs2_garbage_collect_pass+0x486> <== NOT EXECUTED
for (fd = f->dents; fd; fd=fd->next) {
106b8a: 68fb ldr r3, [r7, #12]
106b8c: 461e mov r6, r3
106b8e: 2e00 cmp r6, #0
106b90: f000 83be beq.w 107310 <jffs2_garbage_collect_pass+0xc38> <== ALWAYS TAKEN
if (fd->raw == raw)
106b94: 6832 ldr r2, [r6, #0]
106b96: 4591 cmp r9, r2
106b98: f000 83ad beq.w 1072f6 <jffs2_garbage_collect_pass+0xc1e>
for (fd = f->dents; fd; fd=fd->next) {
106b9c: 6876 ldr r6, [r6, #4]
106b9e: e7f6 b.n 106b8e <jffs2_garbage_collect_pass+0x4b6>
ret = 0;
106ba0: 463e mov r6, r7 <== NOT EXECUTED
106ba2: e781 b.n 106aa8 <jffs2_garbage_collect_pass+0x3d0> <== NOT EXECUTED
if (fn) {
106ba4: 4603 mov r3, r0 <== NOT EXECUTED
106ba6: f1bb 0f00 cmp.w fp, #0 <== NOT EXECUTED
106baa: d0ee beq.n 106b8a <jffs2_garbage_collect_pass+0x4b2> <== NOT EXECUTED
if (ref_flags(raw) == REF_PRISTINE) {
106bac: f8d9 2004 ldr.w r2, [r9, #4]
106bb0: f002 0203 and.w r2, r2, #3
106bb4: 2a02 cmp r2, #2
106bb6: f000 848b beq.w 1074d0 <jffs2_garbage_collect_pass+0xdf8> <== ALWAYS TAKEN
if((start >> PAGE_SHIFT) < ((end-1) >> PAGE_SHIFT)) {
106bba: 1e6b subs r3, r5, #1
106bbc: 9306 str r3, [sp, #24]
106bbe: 0b1b lsrs r3, r3, #12
106bc0: ebb3 3f1a cmp.w r3, sl, lsr #12
106bc4: f240 8189 bls.w 106eda <jffs2_garbage_collect_pass+0x802> <== NEVER 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));
106bc8: f10d 0934 add.w r9, sp, #52 ; 0x34 <== NOT EXECUTED
106bcc: 2244 movs r2, #68 ; 0x44 <== NOT EXECUTED
106bce: 2100 movs r1, #0 <== NOT EXECUTED
106bd0: 4648 mov r0, r9 <== NOT EXECUTED
106bd2: f00e fac5 bl 115160 <memset> <== NOT EXECUTED
if(fn->frags > 1) {
106bd6: f8db 300c ldr.w r3, [fp, #12] <== NOT EXECUTED
106bda: 2244 movs r2, #68 ; 0x44 <== NOT EXECUTED
106bdc: 2b01 cmp r3, #1 <== NOT EXECUTED
106bde: f240 817a bls.w 106ed6 <jffs2_garbage_collect_pass+0x7fe> <== 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);
106be2: f8db 3000 ldr.w r3, [fp] <== NOT EXECUTED
106be6: ae0c add r6, sp, #48 ; 0x30 <== NOT EXECUTED
106be8: 4620 mov r0, r4 <== NOT EXECUTED
106bea: 6859 ldr r1, [r3, #4] <== NOT EXECUTED
106bec: 4633 mov r3, r6 <== NOT EXECUTED
106bee: f8cd 9000 str.w r9, [sp] <== NOT EXECUTED
106bf2: f021 0103 bic.w r1, r1, #3 <== NOT EXECUTED
106bf6: f004 fe05 bl 10b804 <jffs2_flash_read> <== NOT EXECUTED
if (readlen != sizeof(ri) || ret) {
106bfa: 9b0c ldr r3, [sp, #48] ; 0x30 <== NOT EXECUTED
ret = jffs2_flash_read(c, ref_offset(fn->raw), sizeof(ri), &readlen, (char *)&ri);
106bfc: 4601 mov r1, r0 <== NOT EXECUTED
if (readlen != sizeof(ri) || ret) {
106bfe: 2b44 cmp r3, #68 ; 0x44 <== NOT EXECUTED
106c00: f040 8161 bne.w 106ec6 <jffs2_garbage_collect_pass+0x7ee> <== NOT EXECUTED
106c04: 3800 subs r0, #0 <== NOT EXECUTED
106c06: f04f 0244 mov.w r2, #68 ; 0x44 <== NOT EXECUTED
106c0a: bf18 it ne <== NOT EXECUTED
106c0c: 2001 movne r0, #1 <== NOT EXECUTED
106c0e: 2900 cmp r1, #0 <== NOT EXECUTED
106c10: f040 8159 bne.w 106ec6 <jffs2_garbage_collect_pass+0x7ee> <== 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) {
106c14: f8bd 3036 ldrh.w r3, [sp, #54] ; 0x36 <== NOT EXECUTED
106c18: f24e 0102 movw r1, #57346 ; 0xe002 <== NOT EXECUTED
106c1c: 428b cmp r3, r1 <== NOT EXECUTED
106c1e: f040 8141 bne.w 106ea4 <jffs2_garbage_collect_pass+0x7cc> <== 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)) {
106c22: 9b0e ldr r3, [sp, #56] ; 0x38 <== NOT EXECUTED
106c24: 2b44 cmp r3, #68 ; 0x44 <== NOT EXECUTED
106c26: f040 812a bne.w 106e7e <jffs2_garbage_collect_pass+0x7a6> <== 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);
106c2a: 223c movs r2, #60 ; 0x3c <== NOT EXECUTED
106c2c: 4649 mov r1, r9 <== NOT EXECUTED
106c2e: f004 f845 bl 10acbc <cyg_crc32_accumulate> <== NOT EXECUTED
if (crc != je32_to_cpu(ri.node_crc)) {
106c32: 9b1d ldr r3, [sp, #116] ; 0x74 <== NOT EXECUTED
106c34: 4298 cmp r0, r3 <== NOT EXECUTED
106c36: f040 80dd bne.w 106df4 <jffs2_garbage_collect_pass+0x71c> <== 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) {
106c3a: f89d 306c ldrb.w r3, [sp, #108] ; 0x6c <== NOT EXECUTED
106c3e: 2b01 cmp r3, #1 <== NOT EXECUTED
106c40: f040 809d bne.w 106d7e <jffs2_garbage_collect_pass+0x6a6> <== NOT EXECUTED
}
static inline struct rb_node *rb_last( struct rb_root *root )
{
return _RBTree_Maximum( (RBTree_Control *) root );
106c44: 9803 ldr r0, [sp, #12] <== NOT EXECUTED
106c46: f00a f883 bl 110d50 <_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)
106c4a: 2800 cmp r0, #0 <== NOT EXECUTED
106c4c: f000 8094 beq.w 106d78 <jffs2_garbage_collect_pass+0x6a0> <== 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;
106c50: e9d0 3205 ldrd r3, r2, [r0, #20] <== NOT EXECUTED
106c54: 4413 add r3, r2 <== NOT EXECUTED
else
ilen = JFFS2_F_I_SIZE(f);
ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
106c56: f837 1c3a ldrh.w r1, [r7, #-58] <== NOT EXECUTED
ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
ri.isize = cpu_to_je32(ilen);
ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
ri.data_crc = cpu_to_je32(0);
106c5a: 2000 movs r0, #0 <== NOT EXECUTED
return osmode & (S_IFMT | S_IRWXU | S_IRWXG | S_IRWXO);
106c5c: f857 2c40 ldr.w r2, [r7, #-64] <== NOT EXECUTED
ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
106c60: f8ad 104c strh.w r1, [sp, #76] ; 0x4c <== NOT EXECUTED
ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
106c64: f837 1c38 ldrh.w r1, [r7, #-56] <== NOT EXECUTED
ri.isize = cpu_to_je32(ilen);
106c68: 9314 str r3, [sp, #80] ; 0x50 <== NOT EXECUTED
ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
106c6a: f857 3c30 ldr.w r3, [r7, #-48] <== NOT EXECUTED
ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
106c6e: f8ad 104e strh.w r1, [sp, #78] ; 0x4e <== NOT EXECUTED
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
106c72: 4649 mov r1, r9 <== NOT EXECUTED
ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
106c74: 9315 str r3, [sp, #84] ; 0x54 <== NOT EXECUTED
ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
106c76: f857 3c20 ldr.w r3, [r7, #-32] <== NOT EXECUTED
106c7a: 9317 str r3, [sp, #92] ; 0x5c <== NOT EXECUTED
ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
106c7c: f857 3c28 ldr.w r3, [r7, #-40] <== NOT EXECUTED
ri.data_crc = cpu_to_je32(0);
106c80: 901c str r0, [sp, #112] ; 0x70 <== NOT EXECUTED
ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
106c82: 9316 str r3, [sp, #88] ; 0x58 <== NOT EXECUTED
106c84: f24f 13ff movw r3, #61951 ; 0xf1ff <== NOT EXECUTED
106c88: 4013 ands r3, r2 <== NOT EXECUTED
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
106c8a: 223c movs r2, #60 ; 0x3c <== NOT EXECUTED
ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
106c8c: 9312 str r3, [sp, #72] ; 0x48 <== NOT EXECUTED
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
106c8e: f004 f815 bl 10acbc <cyg_crc32_accumulate> <== NOT EXECUTED
ret = jffs2_reserve_space_gc(c, sizeof(ri), &alloclen,
106c92: 4632 mov r2, r6 <== NOT EXECUTED
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
106c94: 901d str r0, [sp, #116] ; 0x74 <== NOT EXECUTED
ret = jffs2_reserve_space_gc(c, sizeof(ri), &alloclen,
106c96: 2312 movs r3, #18 <== NOT EXECUTED
106c98: 2144 movs r1, #68 ; 0x44 <== NOT EXECUTED
106c9a: 4620 mov r0, r4 <== NOT EXECUTED
106c9c: f001 fc82 bl 1085a4 <jffs2_reserve_space_gc> <== NOT EXECUTED
JFFS2_SUMMARY_INODE_SIZE);
if (ret) {
106ca0: 4606 mov r6, r0 <== NOT EXECUTED
106ca2: 2800 cmp r0, #0 <== NOT EXECUTED
106ca4: d15f bne.n 106d66 <jffs2_garbage_collect_pass+0x68e> <== 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);
106ca6: 2302 movs r3, #2 <== NOT EXECUTED
106ca8: 9000 str r0, [sp, #0] <== NOT EXECUTED
106caa: 9301 str r3, [sp, #4] <== NOT EXECUTED
106cac: 464a mov r2, r9 <== NOT EXECUTED
106cae: 4603 mov r3, r0 <== NOT EXECUTED
106cb0: 4639 mov r1, r7 <== NOT EXECUTED
106cb2: 4620 mov r0, r4 <== NOT EXECUTED
106cb4: f003 f908 bl 109ec8 <jffs2_write_dnode> <== NOT EXECUTED
if (IS_ERR(new_fn)) {
106cb8: f510 7f7a cmn.w r0, #1000 ; 0x3e8 <== NOT EXECUTED
new_fn = jffs2_write_dnode(c, f, &ri, NULL, 0, ALLOC_GC);
106cbc: 4605 mov r5, r0 <== NOT EXECUTED
if (IS_ERR(new_fn)) {
106cbe: d82f bhi.n 106d20 <jffs2_garbage_collect_pass+0x648> <== 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) {
106cc0: 9a11 ldr r2, [sp, #68] ; 0x44 <== NOT EXECUTED
106cc2: 683b ldr r3, [r7, #0] <== NOT EXECUTED
106cc4: 429a cmp r2, r3 <== NOT EXECUTED
106cc6: d019 beq.n 106cfc <jffs2_garbage_collect_pass+0x624> <== 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);
106cc8: 682a ldr r2, [r5, #0] <== NOT EXECUTED
for (frag = jffs2_lookup_node_frag(&f->fragtree, fn->ofs);
106cca: f8db 1004 ldr.w r1, [fp, #4] <== NOT EXECUTED
106cce: 9803 ldr r0, [sp, #12] <== NOT EXECUTED
mark_ref_normal(new_fn->raw);
106cd0: 6853 ldr r3, [r2, #4] <== NOT EXECUTED
106cd2: f043 0303 orr.w r3, r3, #3 <== NOT EXECUTED
106cd6: 6053 str r3, [r2, #4] <== NOT EXECUTED
for (frag = jffs2_lookup_node_frag(&f->fragtree, fn->ofs);
106cd8: f000 ffd6 bl 107c88 <jffs2_lookup_node_frag> <== NOT EXECUTED
106cdc: b398 cbz r0, 106d46 <jffs2_garbage_collect_pass+0x66e> <== NOT EXECUTED
frag; frag = frag_next(frag)) {
if (frag->ofs > fn->size + fn->ofs)
106cde: e9db 2301 ldrd r2, r3, [fp, #4] <== NOT EXECUTED
106ce2: 4413 add r3, r2 <== NOT EXECUTED
106ce4: 6982 ldr r2, [r0, #24] <== NOT EXECUTED
106ce6: 429a cmp r2, r3 <== NOT EXECUTED
106ce8: d82d bhi.n 106d46 <jffs2_garbage_collect_pass+0x66e> <== NOT EXECUTED
break;
if (frag->node == fn) {
106cea: 6903 ldr r3, [r0, #16] <== NOT EXECUTED
106cec: 455b cmp r3, fp <== NOT EXECUTED
106cee: d020 beq.n 106d32 <jffs2_garbage_collect_pass+0x65a> <== NOT EXECUTED
return _RBTree_Successor( node );
106cf0: f00a f838 bl 110d64 <_RBTree_Successor> <== NOT EXECUTED
106cf4: e7f2 b.n 106cdc <jffs2_garbage_collect_pass+0x604> <== NOT EXECUTED
106cf6: 4603 mov r3, r0
106cf8: 4693 mov fp, r2
106cfa: e757 b.n 106bac <jffs2_garbage_collect_pass+0x4d4>
jffs2_add_full_dnode_to_inode(c, f, new_fn);
106cfc: 4602 mov r2, r0 <== NOT EXECUTED
106cfe: 4639 mov r1, r7 <== NOT EXECUTED
106d00: 4620 mov r0, r4 <== NOT EXECUTED
106d02: f000 fd81 bl 107808 <jffs2_add_full_dnode_to_inode> <== NOT EXECUTED
if (f->metadata) {
106d06: 68bb ldr r3, [r7, #8] <== NOT EXECUTED
106d08: 2b00 cmp r3, #0 <== NOT EXECUTED
106d0a: f43f aec4 beq.w 106a96 <jffs2_garbage_collect_pass+0x3be> <== NOT EXECUTED
jffs2_mark_node_obsolete(c, f->metadata->raw);
106d0e: 6819 ldr r1, [r3, #0] <== NOT EXECUTED
106d10: 4620 mov r0, r4 <== NOT EXECUTED
106d12: f001 f9bb bl 10808c <jffs2_mark_node_obsolete> <== NOT EXECUTED
jffs2_free_full_dnode(f->metadata);
106d16: 68b8 ldr r0, [r7, #8] <== NOT EXECUTED
106d18: f000 fc08 bl 10752c <jffs2_free_full_dnode> <== NOT EXECUTED
f->metadata = NULL;
106d1c: 60be str r6, [r7, #8] <== NOT EXECUTED
106d1e: e6ba b.n 106a96 <jffs2_garbage_collect_pass+0x3be> <== NOT EXECUTED
pr_warn("Error writing new hole node: %ld\n", PTR_ERR(new_fn));
106d20: f646 3008 movw r0, #27400 ; 0x6b08 <== NOT EXECUTED
106d24: 4629 mov r1, r5 <== NOT EXECUTED
106d26: f2c0 0011 movt r0, #17 <== NOT EXECUTED
return PTR_ERR(new_fn);
106d2a: 462e mov r6, r5 <== NOT EXECUTED
pr_warn("Error writing new hole node: %ld\n", PTR_ERR(new_fn));
106d2c: f7ff fb62 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
return PTR_ERR(new_fn);
106d30: e6b1 b.n 106a96 <jffs2_garbage_collect_pass+0x3be> <== NOT EXECUTED
frag->node = new_fn;
new_fn->frags++;
106d32: 68eb ldr r3, [r5, #12] <== NOT EXECUTED
frag->node = new_fn;
106d34: 6105 str r5, [r0, #16] <== NOT EXECUTED
new_fn->frags++;
106d36: 3301 adds r3, #1 <== NOT EXECUTED
106d38: 60eb str r3, [r5, #12] <== NOT EXECUTED
fn->frags--;
106d3a: f8db 300c ldr.w r3, [fp, #12] <== NOT EXECUTED
106d3e: 3b01 subs r3, #1 <== NOT EXECUTED
106d40: f8cb 300c str.w r3, [fp, #12] <== NOT EXECUTED
106d44: e7d4 b.n 106cf0 <jffs2_garbage_collect_pass+0x618> <== NOT EXECUTED
}
}
if (fn->frags) {
106d46: f8db 300c ldr.w r3, [fp, #12] <== NOT EXECUTED
106d4a: 2b00 cmp r3, #0 <== NOT EXECUTED
106d4c: d17d bne.n 106e4a <jffs2_garbage_collect_pass+0x772> <== NOT EXECUTED
pr_warn("%s(): Old node still has frags!\n", __func__);
BUG();
}
if (!new_fn->frags) {
106d4e: 68eb ldr r3, [r5, #12] <== NOT EXECUTED
106d50: 2b00 cmp r3, #0 <== NOT EXECUTED
106d52: d060 beq.n 106e16 <jffs2_garbage_collect_pass+0x73e> <== NOT EXECUTED
pr_warn("%s(): New node has no frags!\n", __func__);
BUG();
}
jffs2_mark_node_obsolete(c, fn->raw);
106d54: 4620 mov r0, r4 <== NOT EXECUTED
106d56: f8db 1000 ldr.w r1, [fp] <== NOT EXECUTED
106d5a: f001 f997 bl 10808c <jffs2_mark_node_obsolete> <== NOT EXECUTED
jffs2_free_full_dnode(fn);
106d5e: 4658 mov r0, fp <== NOT EXECUTED
106d60: f000 fbe4 bl 10752c <jffs2_free_full_dnode> <== NOT EXECUTED
return 0;
106d64: e697 b.n 106a96 <jffs2_garbage_collect_pass+0x3be> <== NOT EXECUTED
pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_hole failed: %d\n",
106d66: f646 20b4 movw r0, #27316 ; 0x6ab4 <== NOT EXECUTED
106d6a: 4632 mov r2, r6 <== NOT EXECUTED
106d6c: 2144 movs r1, #68 ; 0x44 <== NOT EXECUTED
106d6e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106d72: f7ff fb3f bl 1063f4 <jffs2_printk> <== NOT EXECUTED
return ret;
106d76: e68e b.n 106a96 <jffs2_garbage_collect_pass+0x3be> <== NOT EXECUTED
ilen = JFFS2_F_I_SIZE(f);
106d78: f857 3c10 ldr.w r3, [r7, #-16] <== NOT EXECUTED
106d7c: e76b b.n 106c56 <jffs2_garbage_collect_pass+0x57e> <== NOT EXECUTED
pr_warn("%s(): Node 0x%08x wasn't a hole node!\n",
106d7e: f8db 3000 ldr.w r3, [fp] <== NOT EXECUTED
106d82: f646 51b4 movw r1, #28084 ; 0x6db4 <== NOT EXECUTED
106d86: f646 2080 movw r0, #27264 ; 0x6a80 <== NOT EXECUTED
106d8a: f2c0 0111 movt r1, #17 <== NOT EXECUTED
106d8e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106d92: 685a ldr r2, [r3, #4] <== NOT EXECUTED
106d94: f022 0203 bic.w r2, r2, #3 <== NOT EXECUTED
106d98: f7ff fb2c bl 1063f4 <jffs2_printk> <== NOT EXECUTED
pr_warn("Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n",
106d9c: 697b ldr r3, [r7, #20] <== NOT EXECUTED
106d9e: f646 2038 movw r0, #27192 ; 0x6a38 <== NOT EXECUTED
106da2: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106da6: 462a mov r2, r5 <== NOT EXECUTED
106da8: 4651 mov r1, sl <== NOT EXECUTED
106daa: 68db ldr r3, [r3, #12] <== NOT EXECUTED
106dac: f7ff fb22 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
106db0: f641 1385 movw r3, #6533 ; 0x1985 <== NOT EXECUTED
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
106db4: 2208 movs r2, #8 <== NOT EXECUTED
ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
106db6: f8ad 3034 strh.w r3, [sp, #52] ; 0x34 <== NOT EXECUTED
ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
106dba: f24e 0302 movw r3, #57346 ; 0xe002 <== NOT EXECUTED
106dbe: f8ad 3036 strh.w r3, [sp, #54] ; 0x36 <== NOT EXECUTED
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
106dc2: 4649 mov r1, r9 <== NOT EXECUTED
ri.totlen = cpu_to_je32(sizeof(ri));
106dc4: 2344 movs r3, #68 ; 0x44 <== NOT EXECUTED
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
106dc6: 2000 movs r0, #0 <== NOT EXECUTED
ri.totlen = cpu_to_je32(sizeof(ri));
106dc8: 930e str r3, [sp, #56] ; 0x38 <== NOT EXECUTED
ri.dsize = cpu_to_je32(end - start);
106dca: eba5 050a sub.w r5, r5, sl <== NOT EXECUTED
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
106dce: f003 ff75 bl 10acbc <cyg_crc32_accumulate> <== NOT EXECUTED
ri.ino = cpu_to_je32(f->inocache->ino);
106dd2: 697b ldr r3, [r7, #20] <== NOT EXECUTED
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
106dd4: 900f str r0, [sp, #60] ; 0x3c <== NOT EXECUTED
ri.ino = cpu_to_je32(f->inocache->ino);
106dd6: 68db ldr r3, [r3, #12] <== NOT EXECUTED
106dd8: 9310 str r3, [sp, #64] ; 0x40 <== NOT EXECUTED
ri.version = cpu_to_je32(++f->highest_version);
106dda: 683b ldr r3, [r7, #0] <== NOT EXECUTED
106ddc: 3301 adds r3, #1 <== NOT EXECUTED
106dde: 603b str r3, [r7, #0] <== NOT EXECUTED
106de0: 9311 str r3, [sp, #68] ; 0x44 <== NOT EXECUTED
ri.csize = cpu_to_je32(0);
106de2: 2300 movs r3, #0 <== NOT EXECUTED
106de4: 9319 str r3, [sp, #100] ; 0x64 <== NOT EXECUTED
ri.compr = JFFS2_COMPR_ZERO;
106de6: 2301 movs r3, #1 <== NOT EXECUTED
ri.offset = cpu_to_je32(start);
106de8: f8cd a060 str.w sl, [sp, #96] ; 0x60 <== NOT EXECUTED
ri.dsize = cpu_to_je32(end - start);
106dec: 951a str r5, [sp, #104] ; 0x68 <== NOT EXECUTED
ri.compr = JFFS2_COMPR_ZERO;
106dee: f88d 306c strb.w r3, [sp, #108] ; 0x6c <== NOT EXECUTED
106df2: e727 b.n 106c44 <jffs2_garbage_collect_pass+0x56c> <== NOT EXECUTED
pr_warn("%s: Node at 0x%08x had CRC 0x%08x which doesn't match calculated CRC 0x%08x\n",
106df4: f8db 2000 ldr.w r2, [fp] <== NOT EXECUTED
106df8: f646 51b4 movw r1, #28084 ; 0x6db4 <== NOT EXECUTED
106dfc: f2c0 0111 movt r1, #17 <== NOT EXECUTED
106e00: 6852 ldr r2, [r2, #4] <== NOT EXECUTED
106e02: 9000 str r0, [sp, #0] <== NOT EXECUTED
106e04: f646 10e0 movw r0, #27104 ; 0x69e0 <== NOT EXECUTED
106e08: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106e0c: f022 0203 bic.w r2, r2, #3 <== NOT EXECUTED
106e10: f7ff faf0 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
pr_warn("Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n",
106e14: e7c2 b.n 106d9c <jffs2_garbage_collect_pass+0x6c4> <== NOT EXECUTED
pr_warn("%s(): New node has no frags!\n", __func__);
106e16: f646 51b4 movw r1, #28084 ; 0x6db4 <== NOT EXECUTED
106e1a: f646 3060 movw r0, #27488 ; 0x6b60 <== NOT EXECUTED
106e1e: f2c0 0111 movt r1, #17 <== NOT EXECUTED
106e22: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106e26: f7ff fae5 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
BUG();
106e2a: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
106e2e: f646 52b4 movw r2, #28084 ; 0x6db4 <== NOT EXECUTED
106e32: f246 6008 movw r0, #26120 ; 0x6608 <== NOT EXECUTED
106e36: f2c0 0311 movt r3, #17 <== NOT EXECUTED
106e3a: f2c0 0211 movt r2, #17 <== NOT EXECUTED
106e3e: f240 418b movw r1, #1163 ; 0x48b <== NOT EXECUTED
106e42: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106e46: f005 fc13 bl 10c670 <__assert_func> <== NOT EXECUTED
pr_warn("%s(): Old node still has frags!\n", __func__);
106e4a: f646 51b4 movw r1, #28084 ; 0x6db4 <== NOT EXECUTED
106e4e: f646 3034 movw r0, #27444 ; 0x6b34 <== NOT EXECUTED
106e52: f2c0 0111 movt r1, #17 <== NOT EXECUTED
106e56: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106e5a: f7ff facb bl 1063f4 <jffs2_printk> <== NOT EXECUTED
BUG();
106e5e: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
106e62: f646 52b4 movw r2, #28084 ; 0x6db4 <== NOT EXECUTED
106e66: f246 6008 movw r0, #26120 ; 0x6608 <== NOT EXECUTED
106e6a: f2c0 0311 movt r3, #17 <== NOT EXECUTED
106e6e: f2c0 0211 movt r2, #17 <== NOT EXECUTED
106e72: f240 4187 movw r1, #1159 ; 0x487 <== NOT EXECUTED
106e76: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106e7a: f005 fbf9 bl 10c670 <__assert_func> <== NOT EXECUTED
pr_warn("%s(): Node at 0x%08x had totlen 0x%x instead of expected 0x%zx\n",
106e7e: f8db 1000 ldr.w r1, [fp] <== NOT EXECUTED
106e82: f646 1094 movw r0, #27028 ; 0x6994 <== NOT EXECUTED
106e86: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106e8a: 6849 ldr r1, [r1, #4] <== NOT EXECUTED
106e8c: 9200 str r2, [sp, #0] <== NOT EXECUTED
106e8e: f021 0203 bic.w r2, r1, #3 <== NOT EXECUTED
106e92: f646 51b4 movw r1, #28084 ; 0x6db4 <== NOT EXECUTED
106e96: f2c0 0111 movt r1, #17 <== NOT EXECUTED
106e9a: f7ff faab bl 1063f4 <jffs2_printk> <== NOT EXECUTED
return -EIO;
106e9e: f06f 0604 mvn.w r6, #4 <== NOT EXECUTED
106ea2: e5f8 b.n 106a96 <jffs2_garbage_collect_pass+0x3be> <== NOT EXECUTED
pr_warn("%s(): Node at 0x%08x had node type 0x%04x instead of JFFS2_NODETYPE_INODE(0x%04x)\n",
106ea4: f8db 2000 ldr.w r2, [fp] <== NOT EXECUTED
106ea8: f646 1034 movw r0, #26932 ; 0x6934 <== NOT EXECUTED
106eac: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106eb0: 6852 ldr r2, [r2, #4] <== NOT EXECUTED
106eb2: 9100 str r1, [sp, #0] <== NOT EXECUTED
106eb4: f646 51b4 movw r1, #28084 ; 0x6db4 <== NOT EXECUTED
106eb8: f2c0 0111 movt r1, #17 <== NOT EXECUTED
106ebc: f022 0203 bic.w r2, r2, #3 <== NOT EXECUTED
106ec0: f7ff fa98 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
return -EIO;
106ec4: e7eb b.n 106e9e <jffs2_garbage_collect_pass+0x7c6> <== 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",
106ec6: f646 00b8 movw r0, #26808 ; 0x68b8 <== NOT EXECUTED
106eca: 461a mov r2, r3 <== NOT EXECUTED
106ecc: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106ed0: f7ff fa90 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
goto fill;
106ed4: e76c b.n 106db0 <jffs2_garbage_collect_pass+0x6d8> <== NOT EXECUTED
106ed6: ae0c add r6, sp, #48 ; 0x30 <== NOT EXECUTED
106ed8: e76a b.n 106db0 <jffs2_garbage_collect_pass+0x6d8> <== NOT EXECUTED
int ret = 0;
unsigned char *comprbuf = NULL, *writebuf;
unsigned long pg;
unsigned char *pg_ptr;
memset(&ri, 0, sizeof(ri));
106eda: f10d 0934 add.w r9, sp, #52 ; 0x34
unsigned char *comprbuf = NULL, *writebuf;
106ede: 2100 movs r1, #0
memset(&ri, 0, sizeof(ri));
106ee0: 2244 movs r2, #68 ; 0x44
106ee2: 4648 mov r0, r9
unsigned char *comprbuf = NULL, *writebuf;
106ee4: 9109 str r1, [sp, #36] ; 0x24
memset(&ri, 0, sizeof(ri));
106ee6: f00e f93b bl 115160 <memset>
f->inocache->ino, start, end);
orig_end = end;
orig_start = start;
if (c->nr_free_blocks + c->nr_erasing_blocks > c->resv_blocks_gcmerge) {
106eea: e9d4 320f ldrd r3, r2, [r4, #60] ; 0x3c
106eee: 4413 add r3, r2
106ef0: f894 2048 ldrb.w r2, [r4, #72] ; 0x48
106ef4: 4293 cmp r3, r2
106ef6: f240 815e bls.w 1071b6 <jffs2_garbage_collect_pass+0xade>
uint32_t min, max;
min = start & ~(PAGE_SIZE-1);
max = min + PAGE_SIZE;
frag = jffs2_lookup_node_frag(&f->fragtree, start);
106efa: 4651 mov r1, sl
106efc: 9803 ldr r0, [sp, #12]
106efe: f000 fec3 bl 107c88 <jffs2_lookup_node_frag>
/* BUG_ON(!frag) but that'll happen anyway... */
BUG_ON(frag->ofs != start);
106f02: 6982 ldr r2, [r0, #24]
min = start & ~(PAGE_SIZE-1);
106f04: f42a 637f bic.w r3, sl, #4080 ; 0xff0
106f08: f023 030f bic.w r3, r3, #15
max = min + PAGE_SIZE;
106f0c: f503 5180 add.w r1, r3, #4096 ; 0x1000
BUG_ON(frag->ofs != start);
106f10: 4552 cmp r2, sl
max = min + PAGE_SIZE;
106f12: 9107 str r1, [sp, #28]
BUG_ON(frag->ofs != start);
106f14: f040 813f bne.w 107196 <jffs2_garbage_collect_pass+0xabe> <== ALWAYS TAKEN
106f18: f8cd 9010 str.w r9, [sp, #16]
106f1c: 46d3 mov fp, sl
106f1e: 46a1 mov r9, r4
106f20: 461c mov r4, r3
return _RBTree_Predecessor( node );
106f22: f009 ff37 bl 110d94 <_RBTree_Predecessor>
/* First grow down... */
while((frag = frag_prev(frag)) && frag->ofs >= min) {
106f26: 2800 cmp r0, #0
106f28: f000 8131 beq.w 10718e <jffs2_garbage_collect_pass+0xab6>
106f2c: 6986 ldr r6, [r0, #24]
106f2e: 42b4 cmp r4, r6
106f30: f200 812d bhi.w 10718e <jffs2_garbage_collect_pass+0xab6>
/* If the previous frag doesn't even reach the beginning, there's
excessive fragmentation. Just merge. */
if (frag->ofs > min) {
106f34: f0c0 8129 bcc.w 10718a <jffs2_garbage_collect_pass+0xab2> <== ALWAYS 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) {
106f38: 6903 ldr r3, [r0, #16]
106f3a: 464c mov r4, r9
106f3c: f8dd 9010 ldr.w r9, [sp, #16]
106f40: b19b cbz r3, 106f6a <jffs2_garbage_collect_pass+0x892>
106f42: 681b ldr r3, [r3, #0]
106f44: b18b cbz r3, 106f6a <jffs2_garbage_collect_pass+0x892>
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];
106f46: 6858 ldr r0, [r3, #4]
106f48: 6b61 ldr r1, [r4, #52] ; 0x34
106f4a: f00d fb09 bl 114560 <__udivsi3>
106f4e: 6d63 ldr r3, [r4, #84] ; 0x54
106f50: 2234 movs r2, #52 ; 0x34
106f52: fb02 3300 mla r3, r2, r0, r3
if (jeb == c->gcblock) {
106f56: 6de2 ldr r2, [r4, #92] ; 0x5c
106f58: 4293 cmp r3, r2
106f5a: f000 82c8 beq.w 1074ee <jffs2_garbage_collect_pass+0xe16> <== ALWAYS TAKEN
frag->ofs + frag->size,
ref_offset(raw));
start = frag->ofs;
break;
}
if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) {
106f5e: e9d3 2306 ldrd r2, r3, [r3, #24]
106f62: 4413 add r3, r2
while((frag = frag_prev(frag)) && frag->ofs >= min) {
106f64: 2bc4 cmp r3, #196 ; 0xc4
106f66: bf88 it hi
106f68: 46b3 movhi fp, r6
}
/* ... 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);
106f6a: 9906 ldr r1, [sp, #24]
106f6c: 9803 ldr r0, [sp, #12]
106f6e: f000 fe8b bl 107c88 <jffs2_lookup_node_frag>
while((frag = frag_next(frag)) && frag->ofs+frag->size <= max) {
106f72: 9503 str r5, [sp, #12]
return _RBTree_Successor( node );
106f74: f009 fef6 bl 110d64 <_RBTree_Successor>
106f78: b1f8 cbz r0, 106fba <jffs2_garbage_collect_pass+0x8e2>
106f7a: e9d0 2305 ldrd r2, r3, [r0, #20]
106f7e: 189e adds r6, r3, r2
106f80: 9b07 ldr r3, [sp, #28]
106f82: 42b3 cmp r3, r6
106f84: d319 bcc.n 106fba <jffs2_garbage_collect_pass+0x8e2>
/* If the previous frag doesn't even reach the beginning, there's lots
of fragmentation. Just merge. */
if (frag->ofs+frag->size < max) {
106f86: f200 80be bhi.w 107106 <jffs2_garbage_collect_pass+0xa2e>
frag->ofs, frag->ofs+frag->size);
end = frag->ofs + frag->size;
continue;
}
if (!frag->node || !frag->node->raw) {
106f8a: 6903 ldr r3, [r0, #16]
106f8c: b1ab cbz r3, 106fba <jffs2_garbage_collect_pass+0x8e2>
106f8e: 681b ldr r3, [r3, #0]
106f90: b19b cbz r3, 106fba <jffs2_garbage_collect_pass+0x8e2>
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];
106f92: 6858 ldr r0, [r3, #4]
106f94: 6b61 ldr r1, [r4, #52] ; 0x34
106f96: f00d fae3 bl 114560 <__udivsi3>
106f9a: 6d63 ldr r3, [r4, #84] ; 0x54
106f9c: 2234 movs r2, #52 ; 0x34
106f9e: fb02 3300 mla r3, r2, r0, r3
if (jeb == c->gcblock) {
106fa2: 6de2 ldr r2, [r4, #92] ; 0x5c
106fa4: 4293 cmp r3, r2
106fa6: f000 80ac beq.w 107102 <jffs2_garbage_collect_pass+0xa2a> <== ALWAYS TAKEN
frag->ofs + frag->size,
ref_offset(raw));
end = frag->ofs + frag->size;
break;
}
if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) {
106faa: e9d3 2306 ldrd r2, r3, [r3, #24]
106fae: 4413 add r3, r2
while((frag = frag_next(frag)) && frag->ofs+frag->size <= max) {
106fb0: 9a03 ldr r2, [sp, #12]
106fb2: 2bc4 cmp r3, #196 ; 0xc4
106fb4: bf88 it hi
106fb6: 4632 movhi r2, r6
106fb8: 9203 str r2, [sp, #12]
}
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);
106fba: 9b03 ldr r3, [sp, #12]
106fbc: 42ab cmp r3, r5
106fbe: f0c0 80d4 bcc.w 10716a <jffs2_garbage_collect_pass+0xa92> <== ALWAYS TAKEN
BUG_ON(start > orig_start);
106fc2: 45d3 cmp fp, sl
106fc4: f200 80c1 bhi.w 10714a <jffs2_garbage_collect_pass+0xa72> <== ALWAYS 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);
106fc8: 465a mov r2, fp
106fca: ab0a add r3, sp, #40 ; 0x28
106fcc: 4639 mov r1, r7
106fce: 4620 mov r0, r4
106fd0: f7fe ff3e bl 105e50 <jffs2_gc_fetch_page>
mutex_lock(&f->sem);
if (IS_ERR(pg_ptr)) {
106fd4: f510 7f7a cmn.w r0, #1000 ; 0x3e8
pg_ptr = jffs2_gc_fetch_page(c, f, start, &pg);
106fd8: 4682 mov sl, r0
if (IS_ERR(pg_ptr)) {
106fda: f200 80ad bhi.w 107138 <jffs2_garbage_collect_pass+0xa60> <== ALWAYS TAKEN
int ret = 0;
106fde: 2600 movs r6, #0
PTR_ERR(pg_ptr));
return PTR_ERR(pg_ptr);
}
offset = start;
while(offset < orig_end) {
106fe0: 45ab cmp fp, r5
106fe2: f080 809a bcs.w 10711a <jffs2_garbage_collect_pass+0xa42>
uint32_t datalen;
uint32_t cdatalen;
uint16_t comprtype = JFFS2_COMPR_NONE;
ret = jffs2_reserve_space_gc(c, sizeof(ri) + JFFS2_MIN_DATA_LEN,
106fe6: 2312 movs r3, #18
106fe8: aa08 add r2, sp, #32
106fea: 21c4 movs r1, #196 ; 0xc4
106fec: 4620 mov r0, r4
106fee: f001 fad9 bl 1085a4 <jffs2_reserve_space_gc>
&alloclen, JFFS2_SUMMARY_INODE_SIZE);
if (ret) {
106ff2: 4606 mov r6, r0
106ff4: 2800 cmp r0, #0
106ff6: f040 8096 bne.w 107126 <jffs2_garbage_collect_pass+0xa4e> <== ALWAYS 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);
106ffa: 9b08 ldr r3, [sp, #32]
datalen = end - offset;
writebuf = pg_ptr + (offset & (PAGE_SIZE -1));
comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen);
106ffc: 4639 mov r1, r7
cdatalen = min_t(uint32_t, alloclen - sizeof(ri), end - offset);
106ffe: 9a03 ldr r2, [sp, #12]
comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen);
107000: 4620 mov r0, r4
cdatalen = min_t(uint32_t, alloclen - sizeof(ri), end - offset);
107002: 3b44 subs r3, #68 ; 0x44
107004: eba2 020b sub.w r2, r2, fp
107008: 4293 cmp r3, r2
10700a: bf28 it cs
10700c: 4613 movcs r3, r2
10700e: e9cd 230b strd r2, r3, [sp, #44] ; 0x2c
comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen);
107012: ab0c add r3, sp, #48 ; 0x30
107014: 9301 str r3, [sp, #4]
writebuf = pg_ptr + (offset & (PAGE_SIZE -1));
107016: f3cb 020b ubfx r2, fp, #0, #12
comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen);
10701a: ab0b add r3, sp, #44 ; 0x2c
10701c: 4452 add r2, sl
10701e: 9300 str r3, [sp, #0]
107020: ab09 add r3, sp, #36 ; 0x24
107022: f003 fe5f bl 10ace4 <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);
107026: 9a0c ldr r2, [sp, #48] ; 0x30
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
107028: 4649 mov r1, r9
comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen);
10702a: 9004 str r0, [sp, #16]
ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
10702c: f641 1085 movw r0, #6533 ; 0x1985
107030: f8ad 0034 strh.w r0, [sp, #52] ; 0x34
ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
107034: f24e 0002 movw r0, #57346 ; 0xe002
ri.totlen = cpu_to_je32(sizeof(ri) + cdatalen);
107038: 3244 adds r2, #68 ; 0x44
ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
10703a: f8ad 0036 strh.w r0, [sp, #54] ; 0x36
ri.totlen = cpu_to_je32(sizeof(ri) + cdatalen);
10703e: 920e str r2, [sp, #56] ; 0x38
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
107040: 4630 mov r0, r6
107042: 2208 movs r2, #8
107044: f003 fe3a bl 10acbc <cyg_crc32_accumulate>
ri.ino = cpu_to_je32(f->inocache->ino);
107048: 697a ldr r2, [r7, #20]
ri.version = cpu_to_je32(++f->highest_version);
ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
10704a: f837 1c3a ldrh.w r1, [r7, #-58]
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
10704e: 900f str r0, [sp, #60] ; 0x3c
ri.offset = cpu_to_je32(offset);
ri.csize = cpu_to_je32(cdatalen);
ri.dsize = cpu_to_je32(datalen);
ri.compr = comprtype & 0xff;
ri.usercompr = (comprtype >> 8) & 0xff;
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
107050: 4630 mov r0, r6
ri.ino = cpu_to_je32(f->inocache->ino);
107052: 68d2 ldr r2, [r2, #12]
ri.compr = comprtype & 0xff;
107054: 9b04 ldr r3, [sp, #16]
ri.ino = cpu_to_je32(f->inocache->ino);
107056: 9210 str r2, [sp, #64] ; 0x40
ri.version = cpu_to_je32(++f->highest_version);
107058: 683a ldr r2, [r7, #0]
10705a: 3201 adds r2, #1
10705c: 603a str r2, [r7, #0]
10705e: 9211 str r2, [sp, #68] ; 0x44
107060: f857 2c40 ldr.w r2, [r7, #-64]
ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
107064: f8ad 104c strh.w r1, [sp, #76] ; 0x4c
ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
107068: f837 1c38 ldrh.w r1, [r7, #-56]
10706c: f8ad 104e strh.w r1, [sp, #78] ; 0x4e
ri.isize = cpu_to_je32(JFFS2_F_I_SIZE(f));
107070: f857 1c10 ldr.w r1, [r7, #-16]
107074: 9114 str r1, [sp, #80] ; 0x50
ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
107076: f857 1c30 ldr.w r1, [r7, #-48]
10707a: 9115 str r1, [sp, #84] ; 0x54
ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
10707c: f857 1c20 ldr.w r1, [r7, #-32]
107080: 9117 str r1, [sp, #92] ; 0x5c
ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
107082: f857 1c28 ldr.w r1, [r7, #-40]
ri.compr = comprtype & 0xff;
107086: f88d 306c strb.w r3, [sp, #108] ; 0x6c
ri.usercompr = (comprtype >> 8) & 0xff;
10708a: 0a1b lsrs r3, r3, #8
ri.offset = cpu_to_je32(offset);
10708c: f8cd b060 str.w fp, [sp, #96] ; 0x60
ri.usercompr = (comprtype >> 8) & 0xff;
107090: f88d 306d strb.w r3, [sp, #109] ; 0x6d
ri.csize = cpu_to_je32(cdatalen);
107094: 9b0c ldr r3, [sp, #48] ; 0x30
ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
107096: 9116 str r1, [sp, #88] ; 0x58
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
107098: 4649 mov r1, r9
ri.csize = cpu_to_je32(cdatalen);
10709a: 9319 str r3, [sp, #100] ; 0x64
ri.dsize = cpu_to_je32(datalen);
10709c: 9b0b ldr r3, [sp, #44] ; 0x2c
10709e: 931a str r3, [sp, #104] ; 0x68
1070a0: f24f 13ff movw r3, #61951 ; 0xf1ff
1070a4: 4013 ands r3, r2
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
1070a6: 223c movs r2, #60 ; 0x3c
ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
1070a8: 9312 str r3, [sp, #72] ; 0x48
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
1070aa: f003 fe07 bl 10acbc <cyg_crc32_accumulate>
ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
1070ae: 9a0c ldr r2, [sp, #48] ; 0x30
1070b0: 9909 ldr r1, [sp, #36] ; 0x24
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
1070b2: 901d str r0, [sp, #116] ; 0x74
ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
1070b4: 4630 mov r0, r6
1070b6: f003 fe01 bl 10acbc <cyg_crc32_accumulate>
new_fn = jffs2_write_dnode(c, f, &ri, comprbuf, cdatalen, ALLOC_GC);
1070ba: 9b0c ldr r3, [sp, #48] ; 0x30
1070bc: 464a mov r2, r9
ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
1070be: 901c str r0, [sp, #112] ; 0x70
new_fn = jffs2_write_dnode(c, f, &ri, comprbuf, cdatalen, ALLOC_GC);
1070c0: 4639 mov r1, r7
1070c2: 4620 mov r0, r4
1070c4: 9300 str r3, [sp, #0]
1070c6: 2302 movs r3, #2
1070c8: 9301 str r3, [sp, #4]
1070ca: 9b09 ldr r3, [sp, #36] ; 0x24
1070cc: f002 fefc bl 109ec8 <jffs2_write_dnode>
jffs2_free_comprbuf(comprbuf, writebuf);
if (IS_ERR(new_fn)) {
1070d0: f510 7f7a cmn.w r0, #1000 ; 0x3e8
new_fn = jffs2_write_dnode(c, f, &ri, comprbuf, cdatalen, ALLOC_GC);
1070d4: 4602 mov r2, r0
if (IS_ERR(new_fn)) {
1070d6: d818 bhi.n 10710a <jffs2_garbage_collect_pass+0xa32> <== ALWAYS 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);
1070d8: 4639 mov r1, r7
1070da: 4620 mov r0, r4
1070dc: f000 fb94 bl 107808 <jffs2_add_full_dnode_to_inode>
offset += datalen;
if (f->metadata) {
1070e0: 68bb ldr r3, [r7, #8]
ret = jffs2_add_full_dnode_to_inode(c, f, new_fn);
1070e2: 4606 mov r6, r0
offset += datalen;
1070e4: 9a0b ldr r2, [sp, #44] ; 0x2c
1070e6: 4493 add fp, r2
if (f->metadata) {
1070e8: 2b00 cmp r3, #0
1070ea: f43f af79 beq.w 106fe0 <jffs2_garbage_collect_pass+0x908> <== NEVER TAKEN
jffs2_mark_node_obsolete(c, f->metadata->raw);
1070ee: 6819 ldr r1, [r3, #0] <== NOT EXECUTED
1070f0: 4620 mov r0, r4 <== NOT EXECUTED
1070f2: f000 ffcb bl 10808c <jffs2_mark_node_obsolete> <== NOT EXECUTED
jffs2_free_full_dnode(f->metadata);
1070f6: 68b8 ldr r0, [r7, #8] <== NOT EXECUTED
1070f8: f000 fa18 bl 10752c <jffs2_free_full_dnode> <== NOT EXECUTED
f->metadata = NULL;
1070fc: 2300 movs r3, #0 <== NOT EXECUTED
1070fe: 60bb str r3, [r7, #8] <== NOT EXECUTED
107100: e76e b.n 106fe0 <jffs2_garbage_collect_pass+0x908> <== NOT EXECUTED
while((frag = frag_next(frag)) && frag->ofs+frag->size <= max) {
107102: 9603 str r6, [sp, #12] <== NOT EXECUTED
107104: e759 b.n 106fba <jffs2_garbage_collect_pass+0x8e2> <== NOT EXECUTED
107106: 9603 str r6, [sp, #12]
107108: e734 b.n 106f74 <jffs2_garbage_collect_pass+0x89c>
pr_warn("Error writing new dnode: %ld\n",
10710a: 4606 mov r6, r0 <== NOT EXECUTED
10710c: f646 0090 movw r0, #26768 ; 0x6890 <== NOT EXECUTED
107110: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107114: 4611 mov r1, r2 <== NOT EXECUTED
107116: f7ff f96d bl 1063f4 <jffs2_printk> <== NOT EXECUTED
}
}
jffs2_gc_release_page(c, pg_ptr, &pg);
10711a: aa0a add r2, sp, #40 ; 0x28
10711c: 4651 mov r1, sl
10711e: 4620 mov r0, r4
107120: f7fe feaa bl 105e78 <jffs2_gc_release_page>
return ret;
107124: e4b7 b.n 106a96 <jffs2_garbage_collect_pass+0x3be>
pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_dnode failed: %d\n",
107126: f646 30bc movw r0, #27580 ; 0x6bbc <== NOT EXECUTED
10712a: 4632 mov r2, r6 <== NOT EXECUTED
10712c: 21c4 movs r1, #196 ; 0xc4 <== NOT EXECUTED
10712e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107132: f7ff f95f bl 1063f4 <jffs2_printk> <== NOT EXECUTED
break;
107136: e7f0 b.n 10711a <jffs2_garbage_collect_pass+0xa42> <== NOT EXECUTED
pr_warn("read_cache_page() returned error: %ld\n",
107138: f646 3088 movw r0, #27528 ; 0x6b88 <== NOT EXECUTED
10713c: 4651 mov r1, sl <== NOT EXECUTED
10713e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
return PTR_ERR(pg_ptr);
107142: 4656 mov r6, sl <== NOT EXECUTED
pr_warn("read_cache_page() returned error: %ld\n",
107144: f7ff f956 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
return PTR_ERR(pg_ptr);
107148: e4a5 b.n 106a96 <jffs2_garbage_collect_pass+0x3be> <== NOT EXECUTED
BUG_ON(start > orig_start);
10714a: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
10714e: f646 5298 movw r2, #28056 ; 0x6d98 <== NOT EXECUTED
107152: f246 6008 movw r0, #26120 ; 0x6608 <== NOT EXECUTED
107156: f2c0 0311 movt r3, #17 <== NOT EXECUTED
10715a: f2c0 0211 movt r2, #17 <== NOT EXECUTED
10715e: f240 512c movw r1, #1324 ; 0x52c <== NOT EXECUTED
107162: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107166: f005 fa83 bl 10c670 <__assert_func> <== NOT EXECUTED
BUG_ON(end < orig_end);
10716a: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
10716e: f646 5298 movw r2, #28056 ; 0x6d98 <== NOT EXECUTED
107172: f246 6008 movw r0, #26120 ; 0x6608 <== NOT EXECUTED
107176: f2c0 0311 movt r3, #17 <== NOT EXECUTED
10717a: f2c0 0211 movt r2, #17 <== NOT EXECUTED
10717e: f240 512b movw r1, #1323 ; 0x52b <== NOT EXECUTED
107182: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107186: f005 fa73 bl 10c670 <__assert_func> <== NOT EXECUTED
10718a: 46b3 mov fp, r6 <== NOT EXECUTED
10718c: e6c9 b.n 106f22 <jffs2_garbage_collect_pass+0x84a> <== NOT EXECUTED
10718e: 464c mov r4, r9
107190: f8dd 9010 ldr.w r9, [sp, #16]
107194: e6e9 b.n 106f6a <jffs2_garbage_collect_pass+0x892>
BUG_ON(frag->ofs != start);
107196: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
10719a: f646 5298 movw r2, #28056 ; 0x6d98 <== NOT EXECUTED
10719e: f246 6008 movw r0, #26120 ; 0x6608 <== NOT EXECUTED
1071a2: f2c0 0311 movt r3, #17 <== NOT EXECUTED
1071a6: f2c0 0211 movt r2, #17 <== NOT EXECUTED
1071aa: f240 41ba movw r1, #1210 ; 0x4ba <== NOT EXECUTED
1071ae: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1071b2: f005 fa5d bl 10c670 <__assert_func> <== NOT EXECUTED
1071b6: 46d3 mov fp, sl
1071b8: 9503 str r5, [sp, #12]
1071ba: e705 b.n 106fc8 <jffs2_garbage_collect_pass+0x8f0>
if (S_ISBLK(JFFS2_F_I_MODE(f)) ||
1071bc: f850 3c40 ldr.w r3, [r0, #-64]
1071c0: f403 4230 and.w r2, r3, #45056 ; 0xb000
1071c4: f403 4370 and.w r3, r3, #61440 ; 0xf000
1071c8: f5b2 5f00 cmp.w r2, #8192 ; 0x2000
1071cc: f43f ae67 beq.w 106e9e <jffs2_garbage_collect_pass+0x7c6> <== ALWAYS TAKEN
} else if (S_ISLNK(JFFS2_F_I_MODE(f))) {
1071d0: f5b3 4f20 cmp.w r3, #40960 ; 0xa000
1071d4: f000 815c beq.w 107490 <jffs2_garbage_collect_pass+0xdb8> <== ALWAYS TAKEN
int mdatalen = 0;
1071d8: 2500 movs r5, #0
ret = jffs2_reserve_space_gc(c, sizeof(ri) + mdatalen, &alloclen,
1071da: f105 0944 add.w r9, r5, #68 ; 0x44
1071de: 2312 movs r3, #18
1071e0: aa0c add r2, sp, #48 ; 0x30
1071e2: 4649 mov r1, r9
1071e4: 4620 mov r0, r4
1071e6: f001 f9dd bl 1085a4 <jffs2_reserve_space_gc>
if (ret) {
1071ea: 4606 mov r6, r0
1071ec: 2800 cmp r0, #0
1071ee: f040 8146 bne.w 10747e <jffs2_garbage_collect_pass+0xda6> <== ALWAYS TAKEN
return _RBTree_Maximum( (RBTree_Control *) root );
1071f2: 1d38 adds r0, r7, #4
1071f4: f009 fdac bl 110d50 <_RBTree_Maximum>
1071f8: 2800 cmp r0, #0
1071fa: d079 beq.n 1072f0 <jffs2_garbage_collect_pass+0xc18> <== ALWAYS TAKEN
ilen = last_frag->ofs + last_frag->size;
1071fc: e9d0 3205 ldrd r3, r2, [r0, #20]
107200: 4413 add r3, r2
memset(&ri, 0, sizeof(ri));
107202: 223c movs r2, #60 ; 0x3c
107204: 2100 movs r1, #0
107206: eb0d 0002 add.w r0, sp, r2
10720a: 9303 str r3, [sp, #12]
10720c: f00d ffa8 bl 115160 <memset>
ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
107210: f641 1085 movw r0, #6533 ; 0x1985
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
107214: 2208 movs r2, #8
ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
107216: f8ad 0034 strh.w r0, [sp, #52] ; 0x34
ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
10721a: f24e 0002 movw r0, #57346 ; 0xe002
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
10721e: a90d add r1, sp, #52 ; 0x34
ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
107220: f8ad 0036 strh.w r0, [sp, #54] ; 0x36
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
107224: 2000 movs r0, #0
ri.totlen = cpu_to_je32(sizeof(ri) + mdatalen);
107226: f8cd 9038 str.w r9, [sp, #56] ; 0x38
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
10722a: f003 fd47 bl 10acbc <cyg_crc32_accumulate>
ri.ino = cpu_to_je32(f->inocache->ino);
10722e: 697a ldr r2, [r7, #20]
ri.offset = cpu_to_je32(0);
107230: f04f 0900 mov.w r9, #0
ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
107234: f837 1c3a ldrh.w r1, [r7, #-58]
ri.isize = cpu_to_je32(ilen);
107238: 9b03 ldr r3, [sp, #12]
ri.ino = cpu_to_je32(f->inocache->ino);
10723a: 68d2 ldr r2, [r2, #12]
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
10723c: 900f str r0, [sp, #60] ; 0x3c
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
10723e: 4648 mov r0, r9
ri.ino = cpu_to_je32(f->inocache->ino);
107240: 9210 str r2, [sp, #64] ; 0x40
ri.version = cpu_to_je32(++f->highest_version);
107242: 683a ldr r2, [r7, #0]
107244: 3201 adds r2, #1
107246: 603a str r2, [r7, #0]
107248: 9211 str r2, [sp, #68] ; 0x44
10724a: f857 2c40 ldr.w r2, [r7, #-64]
ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
10724e: f8ad 104c strh.w r1, [sp, #76] ; 0x4c
ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
107252: f837 1c38 ldrh.w r1, [r7, #-56]
ri.isize = cpu_to_je32(ilen);
107256: 9314 str r3, [sp, #80] ; 0x50
ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
107258: f857 3c30 ldr.w r3, [r7, #-48]
ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
10725c: f8ad 104e strh.w r1, [sp, #78] ; 0x4e
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
107260: a90d add r1, sp, #52 ; 0x34
ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
107262: 9315 str r3, [sp, #84] ; 0x54
ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
107264: f857 3c20 ldr.w r3, [r7, #-32]
107268: 9317 str r3, [sp, #92] ; 0x5c
ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
10726a: f857 3c28 ldr.w r3, [r7, #-40]
ri.dsize = cpu_to_je32(mdatalen);
10726e: e9cd 5519 strd r5, r5, [sp, #100] ; 0x64
ri.offset = cpu_to_je32(0);
107272: f8cd 9060 str.w r9, [sp, #96] ; 0x60
ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
107276: 9316 str r3, [sp, #88] ; 0x58
107278: f24f 13ff movw r3, #61951 ; 0xf1ff
10727c: 4013 ands r3, r2
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
10727e: 223c movs r2, #60 ; 0x3c
ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
107280: 9312 str r3, [sp, #72] ; 0x48
ri.compr = JFFS2_COMPR_NONE;
107282: f88d 906c strb.w r9, [sp, #108] ; 0x6c
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
107286: f003 fd19 bl 10acbc <cyg_crc32_accumulate>
ri.data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
10728a: 462a mov r2, r5
10728c: 4659 mov r1, fp
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
10728e: 901d str r0, [sp, #116] ; 0x74
ri.data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
107290: 4648 mov r0, r9
107292: f003 fd13 bl 10acbc <cyg_crc32_accumulate>
new_fn = jffs2_write_dnode(c, f, &ri, mdata, mdatalen, ALLOC_GC);
107296: 2302 movs r3, #2
107298: 9500 str r5, [sp, #0]
ri.data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
10729a: 901c str r0, [sp, #112] ; 0x70
new_fn = jffs2_write_dnode(c, f, &ri, mdata, mdatalen, ALLOC_GC);
10729c: aa0d add r2, sp, #52 ; 0x34
10729e: 9301 str r3, [sp, #4]
1072a0: 4639 mov r1, r7
1072a2: 465b mov r3, fp
1072a4: 4620 mov r0, r4
1072a6: f002 fe0f bl 109ec8 <jffs2_write_dnode>
if (IS_ERR(new_fn)) {
1072aa: f510 7f7a cmn.w r0, #1000 ; 0x3e8
new_fn = jffs2_write_dnode(c, f, &ri, mdata, mdatalen, ALLOC_GC);
1072ae: 4605 mov r5, r0
if (IS_ERR(new_fn)) {
1072b0: d815 bhi.n 1072de <jffs2_garbage_collect_pass+0xc06> <== ALWAYS TAKEN
jffs2_mark_node_obsolete(c, fn->raw);
1072b2: f8da 1000 ldr.w r1, [sl]
1072b6: 4620 mov r0, r4
1072b8: f000 fee8 bl 10808c <jffs2_mark_node_obsolete>
jffs2_free_full_dnode(fn);
1072bc: 4650 mov r0, sl
1072be: f000 f935 bl 10752c <jffs2_free_full_dnode>
f->metadata = new_fn;
1072c2: 60bd str r5, [r7, #8]
if (S_ISLNK(JFFS2_F_I_MODE(f)))
1072c4: f857 3c40 ldr.w r3, [r7, #-64]
1072c8: f403 4370 and.w r3, r3, #61440 ; 0xf000
1072cc: f5b3 4f20 cmp.w r3, #40960 ; 0xa000
1072d0: f47f abe1 bne.w 106a96 <jffs2_garbage_collect_pass+0x3be> <== NEVER TAKEN
kfree(mdata);
1072d4: 4658 mov r0, fp <== NOT EXECUTED
1072d6: f005 fb07 bl 10c8e8 <free> <== NOT EXECUTED
1072da: f7ff bbdc b.w 106a96 <jffs2_garbage_collect_pass+0x3be> <== NOT EXECUTED
pr_warn("Error writing new dnode: %ld\n", PTR_ERR(new_fn));
1072de: f646 0090 movw r0, #26768 ; 0x6890 <== NOT EXECUTED
1072e2: 4629 mov r1, r5 <== NOT EXECUTED
1072e4: f2c0 0011 movt r0, #17 <== NOT EXECUTED
ret = PTR_ERR(new_fn);
1072e8: 462e mov r6, r5 <== NOT EXECUTED
pr_warn("Error writing new dnode: %ld\n", PTR_ERR(new_fn));
1072ea: f7ff f883 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
goto out;
1072ee: e7e9 b.n 1072c4 <jffs2_garbage_collect_pass+0xbec> <== NOT EXECUTED
ilen = JFFS2_F_I_SIZE(f);
1072f0: f857 3c10 ldr.w r3, [r7, #-16] <== NOT EXECUTED
1072f4: e785 b.n 107202 <jffs2_garbage_collect_pass+0xb2a> <== NOT EXECUTED
if (fd && fd->ino) {
1072f6: 68f2 ldr r2, [r6, #12]
1072f8: bb22 cbnz r2, 107344 <jffs2_garbage_collect_pass+0xc6c>
struct jffs2_full_dirent **fdp = &f->dents;
1072fa: f107 020c add.w r2, r7, #12 <== NOT EXECUTED
while (*fdp) {
1072fe: 2b00 cmp r3, #0 <== NOT EXECUTED
107300: f000 80b2 beq.w 107468 <jffs2_garbage_collect_pass+0xd90> <== NOT EXECUTED
if ((*fdp) == fd) {
107304: 429e cmp r6, r3 <== NOT EXECUTED
107306: f000 80a3 beq.w 107450 <jffs2_garbage_collect_pass+0xd78> <== NOT EXECUTED
fdp = &(*fdp)->next;
10730a: 1d1a adds r2, r3, #4 <== NOT EXECUTED
10730c: 685b ldr r3, [r3, #4] <== NOT EXECUTED
10730e: e7f6 b.n 1072fe <jffs2_garbage_collect_pass+0xc26> <== NOT EXECUTED
pr_warn("Raw node at 0x%08x wasn't in node lists for ino #%u\n",
107310: 697b ldr r3, [r7, #20] <== NOT EXECUTED
107312: f646 5058 movw r0, #27992 ; 0x6d58 <== NOT EXECUTED
107316: f8d9 1004 ldr.w r1, [r9, #4] <== NOT EXECUTED
10731a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10731e: 68da ldr r2, [r3, #12] <== NOT EXECUTED
107320: f021 0103 bic.w r1, r1, #3 <== NOT EXECUTED
107324: f7ff f866 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
if (ref_obsolete(raw)) {
107328: f8d9 3004 ldr.w r3, [r9, #4] <== NOT EXECUTED
10732c: f003 0303 and.w r3, r3, #3 <== NOT EXECUTED
107330: 2b01 cmp r3, #1 <== NOT EXECUTED
107332: d167 bne.n 107404 <jffs2_garbage_collect_pass+0xd2c> <== NOT EXECUTED
pr_warn("But it's obsolete so we don't mind too much\n");
107334: f646 40ec movw r0, #27884 ; 0x6cec <== NOT EXECUTED
107338: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10733c: f7ff f85a bl 1063f4 <jffs2_printk> <== NOT EXECUTED
107340: f7ff bba9 b.w 106a96 <jffs2_garbage_collect_pass+0x3be> <== NOT EXECUTED
rd.nsize = strlen(fd->name);
107344: f106 0515 add.w r5, r6, #21
rd.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
107348: f641 1385 movw r3, #6533 ; 0x1985
10734c: f8ad 3034 strh.w r3, [sp, #52] ; 0x34
rd.nsize = strlen(fd->name);
107350: 4628 mov r0, r5
rd.nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
107352: f24e 0301 movw r3, #57345 ; 0xe001
rd.hdr_crc = cpu_to_je32(crc32(0, &rd, sizeof(struct jffs2_unknown_node)-4));
107356: f10d 0934 add.w r9, sp, #52 ; 0x34
rd.nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
10735a: f8ad 3036 strh.w r3, [sp, #54] ; 0x36
rd.nsize = strlen(fd->name);
10735e: f00e f9cf bl 115700 <strlen>
rd.totlen = cpu_to_je32(sizeof(rd) + rd.nsize);
107362: b2c3 uxtb r3, r0
rd.hdr_crc = cpu_to_je32(crc32(0, &rd, sizeof(struct jffs2_unknown_node)-4));
107364: 2208 movs r2, #8
107366: 4649 mov r1, r9
rd.nsize = strlen(fd->name);
107368: f88d 0050 strb.w r0, [sp, #80] ; 0x50
rd.totlen = cpu_to_je32(sizeof(rd) + rd.nsize);
10736c: 3328 adds r3, #40 ; 0x28
rd.hdr_crc = cpu_to_je32(crc32(0, &rd, sizeof(struct jffs2_unknown_node)-4));
10736e: 2000 movs r0, #0
rd.totlen = cpu_to_je32(sizeof(rd) + rd.nsize);
107370: 930e str r3, [sp, #56] ; 0x38
rd.hdr_crc = cpu_to_je32(crc32(0, &rd, sizeof(struct jffs2_unknown_node)-4));
107372: f003 fca3 bl 10acbc <cyg_crc32_accumulate>
rd.pino = cpu_to_je32(f->inocache->ino);
107376: 697b ldr r3, [r7, #20]
rd.hdr_crc = cpu_to_je32(crc32(0, &rd, sizeof(struct jffs2_unknown_node)-4));
107378: 900f str r0, [sp, #60] ; 0x3c
if (JFFS2_F_I_MTIME(f) == JFFS2_F_I_CTIME(f))
10737a: e957 120a ldrd r1, r2, [r7, #-40] ; 0x28
rd.pino = cpu_to_je32(f->inocache->ino);
10737e: 68db ldr r3, [r3, #12]
107380: 9310 str r3, [sp, #64] ; 0x40
rd.version = cpu_to_je32(++f->highest_version);
107382: 683b ldr r3, [r7, #0]
107384: 3301 adds r3, #1
107386: 603b str r3, [r7, #0]
107388: 9311 str r3, [sp, #68] ; 0x44
rd.ino = cpu_to_je32(fd->ino);
10738a: 68f3 ldr r3, [r6, #12]
10738c: 9312 str r3, [sp, #72] ; 0x48
if (JFFS2_F_I_MTIME(f) == JFFS2_F_I_CTIME(f))
10738e: e957 0308 ldrd r0, r3, [r7, #-32]
107392: 429a cmp r2, r3
107394: bf08 it eq
107396: 4281 cmpeq r1, r0
rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8));
107398: f04f 0220 mov.w r2, #32
if (JFFS2_F_I_MTIME(f) == JFFS2_F_I_CTIME(f))
10739c: bf18 it ne
10739e: 2000 movne r0, #0
rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8));
1073a0: 4649 mov r1, r9
1073a2: 9013 str r0, [sp, #76] ; 0x4c
1073a4: 2000 movs r0, #0
rd.type = fd->type;
1073a6: 7d33 ldrb r3, [r6, #20]
1073a8: f88d 3051 strb.w r3, [sp, #81] ; 0x51
rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8));
1073ac: f003 fc86 bl 10acbc <cyg_crc32_accumulate>
rd.name_crc = cpu_to_je32(crc32(0, fd->name, rd.nsize));
1073b0: f89d 2050 ldrb.w r2, [sp, #80] ; 0x50
1073b4: 4629 mov r1, r5
rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8));
1073b6: 9015 str r0, [sp, #84] ; 0x54
rd.name_crc = cpu_to_je32(crc32(0, fd->name, rd.nsize));
1073b8: 2000 movs r0, #0
1073ba: f003 fc7f bl 10acbc <cyg_crc32_accumulate>
ret = jffs2_reserve_space_gc(c, sizeof(rd)+rd.nsize, &alloclen,
1073be: f89d 1050 ldrb.w r1, [sp, #80] ; 0x50
1073c2: aa0c add r2, sp, #48 ; 0x30
rd.name_crc = cpu_to_je32(crc32(0, fd->name, rd.nsize));
1073c4: 9016 str r0, [sp, #88] ; 0x58
ret = jffs2_reserve_space_gc(c, sizeof(rd)+rd.nsize, &alloclen,
1073c6: 4620 mov r0, r4
1073c8: f101 0318 add.w r3, r1, #24
1073cc: 3128 adds r1, #40 ; 0x28
1073ce: f001 f8e9 bl 1085a4 <jffs2_reserve_space_gc>
if (ret) {
1073d2: 4606 mov r6, r0
1073d4: bb80 cbnz r0, 107438 <jffs2_garbage_collect_pass+0xd60>
new_fd = jffs2_write_dirent(c, f, &rd, fd->name, rd.nsize, ALLOC_GC);
1073d6: f89d 1050 ldrb.w r1, [sp, #80] ; 0x50
1073da: 462b mov r3, r5
1073dc: 464a mov r2, r9
1073de: 4620 mov r0, r4
1073e0: 9100 str r1, [sp, #0]
1073e2: 2102 movs r1, #2
1073e4: 9101 str r1, [sp, #4]
1073e6: 4639 mov r1, r7
1073e8: f002 fe7a bl 10a0e0 <jffs2_write_dirent>
if (IS_ERR(new_fd)) {
1073ec: f510 7f7a cmn.w r0, #1000 ; 0x3e8
new_fd = jffs2_write_dirent(c, f, &rd, fd->name, rd.nsize, ALLOC_GC);
1073f0: 4605 mov r5, r0
if (IS_ERR(new_fd)) {
1073f2: d817 bhi.n 107424 <jffs2_garbage_collect_pass+0xd4c> <== ALWAYS TAKEN
jffs2_add_fd_to_list(c, new_fd, &f->dents);
1073f4: 4601 mov r1, r0
1073f6: f107 020c add.w r2, r7, #12
1073fa: 4620 mov r0, r4
1073fc: f000 f95a bl 1076b4 <jffs2_add_fd_to_list>
ret = jffs2_garbage_collect_dirent(c, jeb, f, fd);
107400: f7ff bb49 b.w 106a96 <jffs2_garbage_collect_pass+0x3be>
BUG();
107404: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
107408: f646 52d0 movw r2, #28112 ; 0x6dd0 <== NOT EXECUTED
10740c: f246 6008 movw r0, #26120 ; 0x6608 <== NOT EXECUTED
107410: f2c0 0311 movt r3, #17 <== NOT EXECUTED
107414: f2c0 0211 movt r2, #17 <== NOT EXECUTED
107418: f44f 7112 mov.w r1, #584 ; 0x248 <== NOT EXECUTED
10741c: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107420: f005 f926 bl 10c670 <__assert_func> <== NOT EXECUTED
pr_warn("jffs2_write_dirent in garbage_collect_dirent failed: %ld\n",
107424: f646 4068 movw r0, #27752 ; 0x6c68 <== NOT EXECUTED
107428: 4629 mov r1, r5 <== NOT EXECUTED
10742a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
return PTR_ERR(new_fd);
10742e: 462e mov r6, r5 <== NOT EXECUTED
pr_warn("jffs2_write_dirent in garbage_collect_dirent failed: %ld\n",
107430: f7fe ffe0 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
return PTR_ERR(new_fd);
107434: f7ff bb2f b.w 106a96 <jffs2_garbage_collect_pass+0x3be> <== NOT EXECUTED
pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_dirent failed: %d\n",
107438: f89d 1050 ldrb.w r1, [sp, #80] ; 0x50 <== NOT EXECUTED
10743c: f646 4010 movw r0, #27664 ; 0x6c10 <== NOT EXECUTED
107440: 4632 mov r2, r6 <== NOT EXECUTED
107442: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107446: 3128 adds r1, #40 ; 0x28 <== NOT EXECUTED
107448: f7fe ffd4 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
return ret;
10744c: f7ff bb23 b.w 106a96 <jffs2_garbage_collect_pass+0x3be> <== NOT EXECUTED
*fdp = fd->next;
107450: 6873 ldr r3, [r6, #4] <== NOT EXECUTED
107452: 6013 str r3, [r2, #0] <== NOT EXECUTED
jffs2_mark_node_obsolete(c, fd->raw);
107454: 6831 ldr r1, [r6, #0] <== NOT EXECUTED
107456: 4620 mov r0, r4 <== NOT EXECUTED
107458: f000 fe18 bl 10808c <jffs2_mark_node_obsolete> <== NOT EXECUTED
jffs2_free_full_dirent(fd);
10745c: 4630 mov r0, r6 <== NOT EXECUTED
ret = jffs2_garbage_collect_deletion_dirent(c, jeb, f, fd);
10745e: 2600 movs r6, #0 <== NOT EXECUTED
jffs2_free_full_dirent(fd);
107460: f000 f85e bl 107520 <jffs2_free_full_dirent> <== NOT EXECUTED
return 0;
107464: f7ff bb17 b.w 106a96 <jffs2_garbage_collect_pass+0x3be> <== NOT EXECUTED
pr_warn("Deletion dirent \"%s\" not found in list for ino #%u\n",
107468: 697b ldr r3, [r7, #20] <== NOT EXECUTED
10746a: f646 40ac movw r0, #27820 ; 0x6cac <== NOT EXECUTED
10746e: f106 0115 add.w r1, r6, #21 <== NOT EXECUTED
107472: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107476: 68da ldr r2, [r3, #12] <== NOT EXECUTED
107478: f7fe ffbc bl 1063f4 <jffs2_printk> <== NOT EXECUTED
10747c: e7ea b.n 107454 <jffs2_garbage_collect_pass+0xd7c> <== NOT EXECUTED
pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_metadata failed: %d\n",
10747e: f646 0038 movw r0, #26680 ; 0x6838 <== NOT EXECUTED
107482: 4649 mov r1, r9 <== NOT EXECUTED
107484: 4632 mov r2, r6 <== NOT EXECUTED
107486: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10748a: f7fe ffb3 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
goto out;
10748e: e719 b.n 1072c4 <jffs2_garbage_collect_pass+0xbec> <== NOT EXECUTED
mdatalen = fn->size;
107490: f8da 5008 ldr.w r5, [sl, #8] <== NOT EXECUTED
mdata = kmalloc(fn->size, GFP_KERNEL);
107494: 4628 mov r0, r5 <== NOT EXECUTED
107496: f005 fb63 bl 10cb60 <malloc> <== NOT EXECUTED
if (!mdata) {
10749a: 4683 mov fp, r0 <== NOT EXECUTED
10749c: b348 cbz r0, 1074f2 <jffs2_garbage_collect_pass+0xe1a> <== NOT EXECUTED
ret = jffs2_read_dnode(c, f, fn, mdata, 0, mdatalen);
10749e: 2300 movs r3, #0 <== NOT EXECUTED
1074a0: 4652 mov r2, sl <== NOT EXECUTED
1074a2: 9300 str r3, [sp, #0] <== NOT EXECUTED
1074a4: 4639 mov r1, r7 <== NOT EXECUTED
1074a6: 4603 mov r3, r0 <== NOT EXECUTED
1074a8: 9501 str r5, [sp, #4] <== NOT EXECUTED
1074aa: 4620 mov r0, r4 <== NOT EXECUTED
1074ac: f001 f950 bl 108750 <jffs2_read_dnode> <== NOT EXECUTED
if (ret) {
1074b0: 4606 mov r6, r0 <== NOT EXECUTED
1074b2: 2800 cmp r0, #0 <== NOT EXECUTED
1074b4: f43f ae91 beq.w 1071da <jffs2_garbage_collect_pass+0xb02> <== NOT EXECUTED
pr_warn("read of old metadata failed in jffs2_garbage_collect_metadata(): %d\n",
1074b8: f246 70e8 movw r0, #26600 ; 0x67e8 <== NOT EXECUTED
1074bc: 4631 mov r1, r6 <== NOT EXECUTED
1074be: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1074c2: f7fe ff97 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
kfree(mdata);
1074c6: 4658 mov r0, fp <== NOT EXECUTED
1074c8: f005 fa0e bl 10c8e8 <free> <== NOT EXECUTED
return ret;
1074cc: f7ff bae3 b.w 106a96 <jffs2_garbage_collect_pass+0x3be> <== NOT EXECUTED
ret = jffs2_garbage_collect_pristine(c, f->inocache, raw);
1074d0: 6979 ldr r1, [r7, #20] <== NOT EXECUTED
1074d2: 464a mov r2, r9 <== NOT EXECUTED
1074d4: 4620 mov r0, r4 <== NOT EXECUTED
1074d6: 9304 str r3, [sp, #16] <== NOT EXECUTED
1074d8: f7fe ff9a bl 106410 <jffs2_garbage_collect_pristine> <== NOT EXECUTED
if (!ret) {
1074dc: 4606 mov r6, r0 <== NOT EXECUTED
1074de: b990 cbnz r0, 107506 <jffs2_garbage_collect_pass+0xe2e> <== NOT EXECUTED
frag->node->raw = f->inocache->nodes;
1074e0: 697a ldr r2, [r7, #20] <== NOT EXECUTED
1074e2: 9b04 ldr r3, [sp, #16] <== NOT EXECUTED
1074e4: 6852 ldr r2, [r2, #4] <== NOT EXECUTED
1074e6: 691b ldr r3, [r3, #16] <== NOT EXECUTED
1074e8: 601a str r2, [r3, #0] <== NOT EXECUTED
if (ret != -EBADFD)
1074ea: f7ff bad4 b.w 106a96 <jffs2_garbage_collect_pass+0x3be> <== NOT EXECUTED
while((frag = frag_prev(frag)) && frag->ofs >= min) {
1074ee: 46b3 mov fp, r6 <== NOT EXECUTED
1074f0: e53b b.n 106f6a <jffs2_garbage_collect_pass+0x892> <== NOT EXECUTED
pr_warn("kmalloc of mdata failed in jffs2_garbage_collect_metadata()\n");
1074f2: f246 70a0 movw r0, #26528 ; 0x67a0 <== NOT EXECUTED
return -ENOMEM;
1074f6: f06f 060b mvn.w r6, #11 <== NOT EXECUTED
pr_warn("kmalloc of mdata failed in jffs2_garbage_collect_metadata()\n");
1074fa: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1074fe: f7fe ff79 bl 1063f4 <jffs2_printk> <== NOT EXECUTED
return -ENOMEM;
107502: f7ff bac8 b.w 106a96 <jffs2_garbage_collect_pass+0x3be> <== NOT EXECUTED
if (ret != -EBADFD)
107506: f248 0301 movw r3, #32769 ; 0x8001 <== NOT EXECUTED
10750a: f6cf 73ff movt r3, #65535 ; 0xffff <== NOT EXECUTED
10750e: 4298 cmp r0, r3 <== NOT EXECUTED
107510: f43f ab53 beq.w 106bba <jffs2_garbage_collect_pass+0x4e2> <== NOT EXECUTED
107514: f7ff babf b.w 106a96 <jffs2_garbage_collect_pass+0x3be> <== NOT EXECUTED
001063b8 <jffs2_gc_fetch_inode>:
}
struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
int inum, int unlinked)
{
1063b8: b508 push {r3, lr}
struct _inode *inode;
struct jffs2_inode_cache *ic;
if (unlinked) {
1063ba: b17a cbz r2, 1063dc <jffs2_gc_fetch_inode+0x24>
for (inode = sb->s_root; inode != NULL; inode = inode->i_cache_next) {
1063bc: 4686 mov lr, r0 <== NOT EXECUTED
1063be: f8d0 00e0 ldr.w r0, [r0, #224] ; 0xe0 <== NOT EXECUTED
1063c2: 468c mov ip, r1 <== NOT EXECUTED
1063c4: b910 cbnz r0, 1063cc <jffs2_gc_fetch_inode+0x14> <== NOT EXECUTED
1063c6: e00f b.n 1063e8 <jffs2_gc_fetch_inode+0x30> <== NOT EXECUTED
1063c8: 6e80 ldr r0, [r0, #104] ; 0x68 <== NOT EXECUTED
1063ca: b168 cbz r0, 1063e8 <jffs2_gc_fetch_inode+0x30> <== NOT EXECUTED
if (inode->i_ino == ino) {
1063cc: 6803 ldr r3, [r0, #0] <== NOT EXECUTED
1063ce: 459c cmp ip, r3 <== NOT EXECUTED
1063d0: d1fa bne.n 1063c8 <jffs2_gc_fetch_inode+0x10> <== NOT EXECUTED
inode->i_count++;
1063d2: 6843 ldr r3, [r0, #4] <== NOT EXECUTED
1063d4: 3301 adds r3, #1 <== NOT EXECUTED
1063d6: 6043 str r3, [r0, #4] <== NOT EXECUTED
inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
if (IS_ERR(inode))
return ERR_CAST(inode);
}
return JFFS2_INODE_INFO(inode);
1063d8: 3048 adds r0, #72 ; 0x48
}
1063da: bd08 pop {r3, pc}
inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
1063dc: f7ff fe78 bl 1060d0 <jffs2_iget>
if (IS_ERR(inode))
1063e0: f510 7f7a cmn.w r0, #1000 ; 0x3e8
1063e4: d9f8 bls.n 1063d8 <jffs2_gc_fetch_inode+0x20> <== NEVER TAKEN
}
1063e6: bd08 pop {r3, pc} <== NOT EXECUTED
ic = jffs2_get_ino_cache(c, inum);
1063e8: 4661 mov r1, ip <== NOT EXECUTED
1063ea: 4670 mov r0, lr <== NOT EXECUTED
1063ec: f001 fb98 bl 107b20 <jffs2_get_ino_cache> <== NOT EXECUTED
return NULL;
1063f0: 2000 movs r0, #0 <== NOT EXECUTED
}
1063f2: bd08 pop {r3, pc} <== NOT EXECUTED
00107b20 <jffs2_get_ino_cache>:
{
107b20: b538 push {r3, r4, r5, lr}
107b22: 460c mov r4, r1
107b24: 4605 mov r5, r0
ret = c->inocache_list[ino % c->inocache_hashsize];
107b26: f8d0 10c0 ldr.w r1, [r0, #192] ; 0xc0
107b2a: 4620 mov r0, r4
107b2c: f00c fe46 bl 1147bc <__aeabi_uidivmod>
107b30: f8d5 30c4 ldr.w r3, [r5, #196] ; 0xc4
107b34: f853 0021 ldr.w r0, [r3, r1, lsl #2]
while (ret && ret->ino < ino) {
107b38: b910 cbnz r0, 107b40 <jffs2_get_ino_cache+0x20>
107b3a: e006 b.n 107b4a <jffs2_get_ino_cache+0x2a>
ret = ret->next;
107b3c: 6900 ldr r0, [r0, #16] <== NOT EXECUTED
while (ret && ret->ino < ino) {
107b3e: b120 cbz r0, 107b4a <jffs2_get_ino_cache+0x2a> <== NOT EXECUTED
107b40: 68c3 ldr r3, [r0, #12]
107b42: 42a3 cmp r3, r4
107b44: d3fa bcc.n 107b3c <jffs2_get_ino_cache+0x1c> <== ALWAYS TAKEN
ret = NULL;
107b46: bf18 it ne
107b48: 2000 movne r0, #0
}
107b4a: bd38 pop {r3, r4, r5, pc}
001060d0 <jffs2_iget>:
{
1060d0: b570 push {r4, r5, r6, lr}
1060d2: 460d mov r5, r1
for (inode = sb->s_root; inode != NULL; inode = inode->i_cache_next) {
1060d4: f8d0 40e0 ldr.w r4, [r0, #224] ; 0xe0
{
1060d8: b092 sub sp, #72 ; 0x48
for (inode = sb->s_root; inode != NULL; inode = inode->i_cache_next) {
1060da: b914 cbnz r4, 1060e2 <jffs2_iget+0x12>
1060dc: e00a b.n 1060f4 <jffs2_iget+0x24>
1060de: 6ea4 ldr r4, [r4, #104] ; 0x68
1060e0: b144 cbz r4, 1060f4 <jffs2_iget+0x24>
if (inode->i_ino == ino) {
1060e2: 6823 ldr r3, [r4, #0]
1060e4: 429d cmp r5, r3
1060e6: d1fa bne.n 1060de <jffs2_iget+0xe>
inode->i_count++;
1060e8: 6863 ldr r3, [r4, #4]
1060ea: 3301 adds r3, #1
1060ec: 6063 str r3, [r4, #4]
}
1060ee: 4620 mov r0, r4
1060f0: b012 add sp, #72 ; 0x48
1060f2: bd70 pop {r4, r5, r6, pc}
inode = new_inode(sb);
1060f4: f7ff f912 bl 10531c <new_inode>
if (inode == NULL)
1060f8: 4604 mov r4, r0
1060fa: 2800 cmp r0, #0
1060fc: d03a beq.n 106174 <jffs2_iget+0xa4> <== ALWAYS TAKEN
inode->i_ino = ino;
1060fe: 4621 mov r1, r4
memset(f, 0, sizeof(*f));
106100: 2600 movs r6, #0
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);
106102: 6c20 ldr r0, [r4, #64] ; 0x40
jffs2_init_inode_info(f);
ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
106104: 462a mov r2, r5
inode->i_ino = ino;
106106: f841 5b48 str.w r5, [r1], #72
ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
10610a: ab01 add r3, sp, #4
memset(f, 0, sizeof(*f));
10610c: 64a6 str r6, [r4, #72] ; 0x48
10610e: 604e str r6, [r1, #4]
106110: 608e str r6, [r1, #8]
106112: 60ce str r6, [r1, #12]
106114: 610e str r6, [r1, #16]
106116: 614e str r6, [r1, #20]
106118: 618e str r6, [r1, #24]
ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
10611a: f003 fd97 bl 109c4c <jffs2_do_read_inode>
if (ret) {
10611e: 4605 mov r5, r0
106120: b9e0 cbnz r0, 10615c <jffs2_iget+0x8c>
return jmode & (S_IFMT | S_IRWXU | S_IRWXG | S_IRWXO);
106122: 9b06 ldr r3, [sp, #24]
106124: f24f 10ff movw r0, #61951 ; 0xf1ff
inode->i_size = je32_to_cpu(latest_node.isize);
inode->i_atime = je32_to_cpu(latest_node.atime);
inode->i_mtime = je32_to_cpu(latest_node.mtime);
inode->i_ctime = je32_to_cpu(latest_node.ctime);
inode->i_nlink = f->inocache->pino_nlink;
106128: 6de1 ldr r1, [r4, #92] ; 0x5c
inode->i_uid = je16_to_cpu(latest_node.uid);
10612a: f8bd 201c ldrh.w r2, [sp, #28]
10612e: 4003 ands r3, r0
inode->i_nlink = f->inocache->pino_nlink;
106130: 6948 ldr r0, [r1, #20]
inode->i_size = je32_to_cpu(latest_node.isize);
106132: 9908 ldr r1, [sp, #32]
inode->i_mode = jemode_to_cpu(latest_node.mode);
106134: 60a3 str r3, [r4, #8]
inode->i_gid = je16_to_cpu(latest_node.gid);
106136: f8bd 301e ldrh.w r3, [sp, #30]
inode->i_size = je32_to_cpu(latest_node.isize);
10613a: 63a1 str r1, [r4, #56] ; 0x38
inode->i_uid = je16_to_cpu(latest_node.uid);
10613c: 81e2 strh r2, [r4, #14]
inode->i_gid = je16_to_cpu(latest_node.gid);
10613e: 8223 strh r3, [r4, #16]
inode->i_mtime = je32_to_cpu(latest_node.mtime);
106140: e9dd 1209 ldrd r1, r2, [sp, #36] ; 0x24
inode->i_ctime = je32_to_cpu(latest_node.ctime);
106144: 9b0b ldr r3, [sp, #44] ; 0x2c
inode->i_size = je32_to_cpu(latest_node.isize);
106146: 63e5 str r5, [r4, #60] ; 0x3c
inode->i_nlink = f->inocache->pino_nlink;
106148: 81a0 strh r0, [r4, #12]
}
10614a: 4620 mov r0, r4
inode->i_ctime = je32_to_cpu(latest_node.ctime);
10614c: 62e5 str r5, [r4, #44] ; 0x2c
inode->i_atime = je32_to_cpu(latest_node.atime);
10614e: 61e5 str r5, [r4, #28]
inode->i_mtime = je32_to_cpu(latest_node.mtime);
106150: 6265 str r5, [r4, #36] ; 0x24
inode->i_atime = je32_to_cpu(latest_node.atime);
106152: 61a1 str r1, [r4, #24]
inode->i_mtime = je32_to_cpu(latest_node.mtime);
106154: 6222 str r2, [r4, #32]
inode->i_ctime = je32_to_cpu(latest_node.ctime);
106156: 62a3 str r3, [r4, #40] ; 0x28
}
106158: b012 add sp, #72 ; 0x48
10615a: bd70 pop {r4, r5, r6, pc}
printk("jffs2_read_inode() failed\n");
10615c: f246 00c0 movw r0, #24768 ; 0x60c0 <== NOT EXECUTED
106160: f2c0 0011 movt r0, #17 <== NOT EXECUTED
106164: f7ff fcbc bl 105ae0 <jffs2_printk> <== NOT EXECUTED
jffs2_iput(inode);
106168: 4620 mov r0, r4 <== NOT EXECUTED
inode->i_nlink = 0; // free _this_ bad inode right now
10616a: 81a6 strh r6, [r4, #12] <== NOT EXECUTED
return ERR_PTR(err);
10616c: 462c mov r4, r5 <== NOT EXECUTED
jffs2_iput(inode);
10616e: f7ff fe85 bl 105e7c <jffs2_iput> <== NOT EXECUTED
return ERR_PTR(err);
106172: e7bc b.n 1060ee <jffs2_iget+0x1e> <== NOT EXECUTED
return ERR_PTR(-ENOMEM);
106174: f06f 040b mvn.w r4, #11 <== NOT EXECUTED
106178: e7b9 b.n 1060ee <jffs2_iget+0x1e> <== NOT EXECUTED
10617a: bf00 nop
00105e7c <jffs2_iput>:
{
105e7c: b538 push {r3, r4, r5, lr}
105e7e: 4604 mov r4, r0
assert(i != NULL);
105e80: b3b4 cbz r4, 105ef0 <jffs2_iput+0x74>
i->i_count--;
105e82: 6863 ldr r3, [r4, #4]
105e84: 3b01 subs r3, #1
if (i->i_count < 0)
105e86: 2b00 cmp r3, #0
i->i_count--;
105e88: 6063 str r3, [r4, #4]
if (i->i_count < 0)
105e8a: db21 blt.n 105ed0 <jffs2_iput+0x54> <== ALWAYS TAKEN
if (i->i_count)
105e8c: d117 bne.n 105ebe <jffs2_iput+0x42>
if (!i->i_nlink) {
105e8e: 89a3 ldrh r3, [r4, #12]
105e90: b9b3 cbnz r3, 105ec0 <jffs2_iput+0x44>
i->i_cache_prev->i_cache_next = i->i_cache_next;
105e92: e9d4 2319 ldrd r2, r3, [r4, #100] ; 0x64
if (i->i_cache_prev)
105e96: b10a cbz r2, 105e9c <jffs2_iput+0x20>
i->i_cache_prev->i_cache_next = i->i_cache_next;
105e98: 6693 str r3, [r2, #104] ; 0x68
if (i->i_cache_next)
105e9a: 6ea3 ldr r3, [r4, #104] ; 0x68
105e9c: b103 cbz r3, 105ea0 <jffs2_iput+0x24>
i->i_cache_next->i_cache_prev = i->i_cache_prev;
105e9e: 665a str r2, [r3, #100] ; 0x64
parent = i->i_parent;
105ea0: 6b65 ldr r5, [r4, #52] ; 0x34
jffs2_do_clear_inode(c, f);
105ea2: f104 0148 add.w r1, r4, #72 ; 0x48
105ea6: 6c20 ldr r0, [r4, #64] ; 0x40
105ea8: f003 ff4e bl 109d48 <jffs2_do_clear_inode>
free(i);
105eac: 4620 mov r0, r4
105eae: f006 fd1b bl 10c8e8 <free>
if (parent && parent != i) {
105eb2: 2d00 cmp r5, #0
105eb4: bf18 it ne
105eb6: 42ac cmpne r4, r5
105eb8: d001 beq.n 105ebe <jffs2_iput+0x42>
105eba: 462c mov r4, r5
105ebc: e7e0 b.n 105e80 <jffs2_iput+0x4>
}
105ebe: bd38 pop {r3, r4, r5, pc}
icache_evict(i->i_sb->s_root, i);
105ec0: 6c23 ldr r3, [r4, #64] ; 0x40
105ec2: 4621 mov r1, r4
105ec4: f8d3 00e0 ldr.w r0, [r3, #224] ; 0xe0
}
105ec8: e8bd 4038 ldmia.w sp!, {r3, r4, r5, lr}
icache_evict(i->i_sb->s_root, i);
105ecc: f7ff bc66 b.w 10579c <icache_evict>
BUG();
105ed0: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
105ed4: f246 1238 movw r2, #24888 ; 0x6138 <== NOT EXECUTED
105ed8: f246 0058 movw r0, #24664 ; 0x6058 <== NOT EXECUTED
105edc: f2c0 0311 movt r3, #17 <== NOT EXECUTED
105ee0: f2c0 0211 movt r2, #17 <== NOT EXECUTED
105ee4: f44f 61b5 mov.w r1, #1448 ; 0x5a8 <== NOT EXECUTED
105ee8: f2c0 0011 movt r0, #17 <== NOT EXECUTED
105eec: f006 fbc0 bl 10c670 <__assert_func> <== NOT EXECUTED
assert(i != NULL);
105ef0: f246 034c movw r3, #24652 ; 0x604c <== NOT EXECUTED
105ef4: f246 1238 movw r2, #24888 ; 0x6138 <== NOT EXECUTED
105ef8: f246 0058 movw r0, #24664 ; 0x6058 <== NOT EXECUTED
105efc: f2c0 0311 movt r3, #17 <== NOT EXECUTED
105f00: f2c0 0211 movt r2, #17 <== NOT EXECUTED
105f04: f240 51a3 movw r1, #1443 ; 0x5a3 <== NOT EXECUTED
105f08: f2c0 0011 movt r0, #17 <== NOT EXECUTED
105f0c: f006 fbb0 bl 10c670 <__assert_func> <== NOT EXECUTED
00107d10 <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)
{
107d10: 4684 mov ip, r0
struct jffs2_raw_node_ref *ref;
BUG_ON(!jeb->allocated_refs);
107d12: 6a48 ldr r0, [r1, #36] ; 0x24
{
107d14: b5f0 push {r4, r5, r6, r7, lr}
107d16: b085 sub sp, #20
107d18: 9d0a ldr r5, [sp, #40] ; 0x28
BUG_ON(!jeb->allocated_refs);
107d1a: 2800 cmp r0, #0
107d1c: d061 beq.n 107de2 <jffs2_link_node_ref+0xd2> <== ALWAYS TAKEN
jeb->allocated_refs--;
ref = jeb->last_node;
107d1e: 6ace ldr r6, [r1, #44] ; 0x2c
jeb->allocated_refs--;
107d20: 3801 subs r0, #1
107d22: 6248 str r0, [r1, #36] ; 0x24
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) {
107d24: 6874 ldr r4, [r6, #4]
107d26: 4630 mov r0, r6
107d28: 1ca7 adds r7, r4, #2
107d2a: d006 beq.n 107d3a <jffs2_link_node_ref+0x2a>
if (ref->flash_offset == REF_LINK_NODE)
107d2c: 3401 adds r4, #1
ref = ref->next_in_ino;
107d2e: bf0c ite eq
107d30: 6800 ldreq r0, [r0, #0]
else
ref++;
107d32: 3008 addne r0, #8
while (ref->flash_offset != REF_EMPTY_NODE) {
107d34: 6844 ldr r4, [r0, #4]
107d36: 1ca7 adds r7, r4, #2
107d38: d1f8 bne.n 107d2c <jffs2_link_node_ref+0x1c>
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;
if (!jeb->first_node) {
107d3a: 6a8f ldr r7, [r1, #40] ; 0x28
jeb->first_node = ref;
BUG_ON(ref_offset(ref) != jeb->offset);
107d3c: f022 0e03 bic.w lr, r2, #3
107d40: 68cc ldr r4, [r1, #12]
ref->flash_offset = ofs;
107d42: 6042 str r2, [r0, #4]
if (!jeb->first_node) {
107d44: 2f00 cmp r7, #0
107d46: d037 beq.n 107db8 <jffs2_link_node_ref+0xa8>
} else if (unlikely(ref_offset(ref) != jeb->offset + c->sector_size - jeb->free_size)) {
107d48: f8dc 7034 ldr.w r7, [ip, #52] ; 0x34
107d4c: 443c add r4, r7
107d4e: 6a0f ldr r7, [r1, #32]
107d50: 1be4 subs r4, r4, r7
107d52: 4574 cmp r4, lr
107d54: d155 bne.n 107e02 <jffs2_link_node_ref+0xf2> <== ALWAYS 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;
107d56: 62c8 str r0, [r1, #44] ; 0x2c
if (ic) {
107d58: b365 cbz r5, 107db4 <jffs2_link_node_ref+0xa4>
ref->next_in_ino = ic->nodes;
107d5a: 686c ldr r4, [r5, #4]
107d5c: 6004 str r4, [r0, #0]
ic->nodes = ref;
107d5e: 6068 str r0, [r5, #4]
} else {
ref->next_in_ino = NULL;
}
switch(ref_flags(ref)) {
107d60: f002 0203 and.w r2, r2, #3
107d64: 2a01 cmp r2, #1
107d66: d013 beq.n 107d90 <jffs2_link_node_ref+0x80>
107d68: 3a02 subs r2, #2
107d6a: 2a01 cmp r2, #1
107d6c: d819 bhi.n 107da2 <jffs2_link_node_ref+0x92> <== ALWAYS TAKEN
jeb->unchecked_size += len;
break;
case REF_NORMAL:
case REF_PRISTINE:
c->used_size += len;
107d6e: f8dc 201c ldr.w r2, [ip, #28]
107d72: 441a add r2, r3
107d74: f8cc 201c str.w r2, [ip, #28]
jeb->used_size += len;
107d78: 694a ldr r2, [r1, #20]
107d7a: 441a add r2, r3
107d7c: 614a str r2, [r1, #20]
case REF_OBSOLETE:
c->dirty_size += len;
jeb->dirty_size += len;
break;
}
c->free_size -= len;
107d7e: f8dc 2028 ldr.w r2, [ip, #40] ; 0x28
jeb->free_size -= len;
107d82: 1aff subs r7, r7, r3
c->free_size -= len;
107d84: 1ad3 subs r3, r2, r3
107d86: f8cc 3028 str.w r3, [ip, #40] ; 0x28
jeb->free_size -= len;
107d8a: 620f str r7, [r1, #32]
/* Set (and test) __totlen field... for now */
ref->__totlen = len;
ref_totlen(c, jeb, ref);
#endif
return ref;
}
107d8c: b005 add sp, #20
107d8e: bdf0 pop {r4, r5, r6, r7, pc}
c->dirty_size += len;
107d90: f8dc 2020 ldr.w r2, [ip, #32]
107d94: 441a add r2, r3
107d96: f8cc 2020 str.w r2, [ip, #32]
jeb->dirty_size += len;
107d9a: 698a ldr r2, [r1, #24]
107d9c: 441a add r2, r3
107d9e: 618a str r2, [r1, #24]
break;
107da0: e7ed b.n 107d7e <jffs2_link_node_ref+0x6e>
c->unchecked_size += len;
107da2: f8dc 2038 ldr.w r2, [ip, #56] ; 0x38 <== NOT EXECUTED
107da6: 441a add r2, r3 <== NOT EXECUTED
107da8: f8cc 2038 str.w r2, [ip, #56] ; 0x38 <== NOT EXECUTED
jeb->unchecked_size += len;
107dac: 690a ldr r2, [r1, #16] <== NOT EXECUTED
107dae: 441a add r2, r3 <== NOT EXECUTED
107db0: 610a str r2, [r1, #16] <== NOT EXECUTED
break;
107db2: e7e4 b.n 107d7e <jffs2_link_node_ref+0x6e> <== NOT EXECUTED
ref->next_in_ino = NULL;
107db4: 6005 str r5, [r0, #0]
107db6: e7d3 b.n 107d60 <jffs2_link_node_ref+0x50>
BUG_ON(ref_offset(ref) != jeb->offset);
107db8: 45a6 cmp lr, r4
jeb->first_node = ref;
107dba: 6288 str r0, [r1, #40] ; 0x28
} else if (unlikely(ref_offset(ref) != jeb->offset + c->sector_size - jeb->free_size)) {
107dbc: bf08 it eq
107dbe: 6a0f ldreq r7, [r1, #32]
BUG_ON(ref_offset(ref) != jeb->offset);
107dc0: d0c9 beq.n 107d56 <jffs2_link_node_ref+0x46> <== NEVER TAKEN
107dc2: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
107dc6: f646 72e0 movw r2, #28640 ; 0x6fe0 <== NOT EXECUTED
107dca: f646 6054 movw r0, #28244 ; 0x6e54 <== NOT EXECUTED
107dce: f2c0 0311 movt r3, #17 <== NOT EXECUTED
107dd2: f2c0 0211 movt r2, #17 <== NOT EXECUTED
107dd6: f44f 711a mov.w r1, #616 ; 0x268 <== NOT EXECUTED
107dda: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107dde: f004 fc47 bl 10c670 <__assert_func> <== NOT EXECUTED
BUG_ON(!jeb->allocated_refs);
107de2: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
107de6: f646 72e0 movw r2, #28640 ; 0x6fe0 <== NOT EXECUTED
107dea: f646 6054 movw r0, #28244 ; 0x6e54 <== NOT EXECUTED
107dee: f2c0 0311 movt r3, #17 <== NOT EXECUTED
107df2: f2c0 0211 movt r2, #17 <== NOT EXECUTED
107df6: f240 2152 movw r1, #594 ; 0x252 <== NOT EXECUTED
107dfa: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107dfe: f004 fc37 bl 10c670 <__assert_func> <== NOT EXECUTED
if (ref->flash_offset == REF_LINK_NODE) {
107e02: 68f2 ldr r2, [r6, #12] <== NOT EXECUTED
107e04: 3201 adds r2, #1 <== NOT EXECUTED
107e06: d02a beq.n 107e5e <jffs2_link_node_ref+0x14e> <== NOT EXECUTED
ref++;
107e08: f106 0208 add.w r2, r6, #8 <== NOT EXECUTED
if (ref->flash_offset == REF_EMPTY_NODE)
107e0c: 6852 ldr r2, [r2, #4] <== NOT EXECUTED
107e0e: 1c91 adds r1, r2, #2 <== 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);
107e10: bf18 it ne <== NOT EXECUTED
107e12: f022 0403 bicne.w r4, r2, #3 <== NOT EXECUTED
JFFS2_ERROR("Adding new ref %p at (0x%08x-0x%08x) not immediately after previous (0x%08x-0x%08x)\n",
107e16: 9402 str r4, [sp, #8] <== NOT EXECUTED
107e18: eb03 050e add.w r5, r3, lr <== 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);
107e1c: 6874 ldr r4, [r6, #4] <== NOT EXECUTED
JFFS2_ERROR("Adding new ref %p at (0x%08x-0x%08x) not immediately after previous (0x%08x-0x%08x)\n",
107e1e: 4602 mov r2, r0 <== NOT EXECUTED
107e20: f646 71e0 movw r1, #28640 ; 0x6fe0 <== NOT EXECUTED
107e24: f646 60c4 movw r0, #28356 ; 0x6ec4 <== NOT EXECUTED
107e28: 4673 mov r3, lr <== NOT EXECUTED
107e2a: f2c0 0111 movt r1, #17 <== NOT EXECUTED
return ref_end - ref_offset(ref);
107e2e: f024 0403 bic.w r4, r4, #3 <== NOT EXECUTED
JFFS2_ERROR("Adding new ref %p at (0x%08x-0x%08x) not immediately after previous (0x%08x-0x%08x)\n",
107e32: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107e36: e9cd 5400 strd r5, r4, [sp] <== NOT EXECUTED
107e3a: f7ff fbf1 bl 107620 <jffs2_printk> <== NOT EXECUTED
BUG();
107e3e: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
107e42: f646 72e0 movw r2, #28640 ; 0x6fe0 <== NOT EXECUTED
107e46: f646 6054 movw r0, #28244 ; 0x6e54 <== NOT EXECUTED
107e4a: f2c0 0311 movt r3, #17 <== NOT EXECUTED
107e4e: f2c0 0211 movt r2, #17 <== NOT EXECUTED
107e52: f44f 711c mov.w r1, #624 ; 0x270 <== NOT EXECUTED
107e56: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107e5a: f004 fc09 bl 10c670 <__assert_func> <== NOT EXECUTED
ref = ref->next_in_ino;
107e5e: 68b2 ldr r2, [r6, #8] <== NOT EXECUTED
if (!ref)
107e60: 2a00 cmp r2, #0 <== NOT EXECUTED
107e62: d1d3 bne.n 107e0c <jffs2_link_node_ref+0xfc> <== NOT EXECUTED
107e64: e7d7 b.n 107e16 <jffs2_link_node_ref+0x106> <== NOT EXECUTED
107e66: bf00 nop
0010aeb0 <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)
{
10aeb0: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
10aeb4: 4680 mov r8, r0
10aeb6: 460f mov r7, r1
while (len--) {
10aeb8: 4691 mov r9, r2
10aeba: 2a00 cmp r2, #0
10aebc: d044 beq.n 10af48 <jffs2_lookup+0x98> <== ALWAYS TAKEN
10aebe: 4411 add r1, r2
10aec0: 463b mov r3, r7
uint32_t hash = 0;
10aec2: 2500 movs r5, #0
hash ^= *(name++);
10aec4: f813 4b01 ldrb.w r4, [r3], #1
while (len--) {
10aec8: 4299 cmp r1, r3
hash ^= *(name++);
10aeca: ea84 7535 eor.w r5, r4, r5, ror #28
while (len--) {
10aece: d1f9 bne.n 10aec4 <jffs2_lookup+0x14>
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) {
10aed0: f8d8 4054 ldr.w r4, [r8, #84] ; 0x54
struct jffs2_full_dirent *fd = NULL, *fd_list;
10aed4: 2600 movs r6, #0
for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= hash; fd_list = fd_list->next) {
10aed6: b914 cbnz r4, 10aede <jffs2_lookup+0x2e>
10aed8: e02b b.n 10af32 <jffs2_lookup+0x82>
10aeda: 6864 ldr r4, [r4, #4]
10aedc: b1d4 cbz r4, 10af14 <jffs2_lookup+0x64>
10aede: 6923 ldr r3, [r4, #16]
10aee0: 42ab cmp r3, r5
10aee2: d817 bhi.n 10af14 <jffs2_lookup+0x64>
if (fd_list->nhash == hash &&
10aee4: d1f9 bne.n 10aeda <jffs2_lookup+0x2a>
(!fd || fd_list->version > fd->version) &&
strlen((char *)fd_list->name) == namelen &&
10aee6: f104 0a15 add.w sl, r4, #21
if (fd_list->nhash == hash &&
10aeea: b11e cbz r6, 10aef4 <jffs2_lookup+0x44>
(!fd || fd_list->version > fd->version) &&
10aeec: 68a2 ldr r2, [r4, #8] <== NOT EXECUTED
10aeee: 68b3 ldr r3, [r6, #8] <== NOT EXECUTED
10aef0: 429a cmp r2, r3 <== NOT EXECUTED
10aef2: d9f2 bls.n 10aeda <jffs2_lookup+0x2a> <== NOT EXECUTED
strlen((char *)fd_list->name) == namelen &&
10aef4: 4650 mov r0, sl
10aef6: f00a fc03 bl 115700 <strlen>
(!fd || fd_list->version > fd->version) &&
10aefa: 4548 cmp r0, r9
10aefc: d1ed bne.n 10aeda <jffs2_lookup+0x2a> <== ALWAYS TAKEN
!strncmp((char *)fd_list->name, (char *)name, namelen)) {
10aefe: 4650 mov r0, sl
10af00: 464a mov r2, r9
10af02: 4639 mov r1, r7
10af04: f00a fc6a bl 1157dc <strncmp>
strlen((char *)fd_list->name) == namelen &&
10af08: 2800 cmp r0, #0
10af0a: bf08 it eq
10af0c: 4626 moveq r6, r4
for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= hash; fd_list = fd_list->next) {
10af0e: 6864 ldr r4, [r4, #4]
10af10: 2c00 cmp r4, #0
10af12: d1e4 bne.n 10aede <jffs2_lookup+0x2e>
fd = fd_list;
}
}
if (fd)
10af14: b1d6 cbz r6, 10af4c <jffs2_lookup+0x9c>
ino = fd->ino;
10af16: 68f5 ldr r5, [r6, #12]
struct _inode *inode = NULL;
10af18: 462c mov r4, r5
mutex_unlock(&dir_f->sem);
if (ino) {
10af1a: b155 cbz r5, 10af32 <jffs2_lookup+0x82>
inode = jffs2_iget(dir_i->i_sb, ino);
10af1c: f8d8 0040 ldr.w r0, [r8, #64] ; 0x40
10af20: 4629 mov r1, r5
10af22: f7fb f8d5 bl 1060d0 <jffs2_iget>
if (IS_ERR(inode)) {
10af26: f510 7f7a cmn.w r0, #1000 ; 0x3e8
inode = jffs2_iget(dir_i->i_sb, ino);
10af2a: 4604 mov r4, r0
printk("jffs2_iget() failed for ino #%lu\n", ino);
return inode;
} else {
inode->i_fd = fd;
10af2c: bf98 it ls
10af2e: 6446 strls r6, [r0, #68] ; 0x44
if (IS_ERR(inode)) {
10af30: d802 bhi.n 10af38 <jffs2_lookup+0x88> <== ALWAYS TAKEN
}
}
return inode;
}
10af32: 4620 mov r0, r4
10af34: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
printk("jffs2_iget() failed for ino #%lu\n", ino);
10af38: f648 1008 movw r0, #35080 ; 0x8908 <== NOT EXECUTED
10af3c: 4629 mov r1, r5 <== NOT EXECUTED
10af3e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10af42: f7ff ffa7 bl 10ae94 <jffs2_printk> <== NOT EXECUTED
return inode;
10af46: e7f4 b.n 10af32 <jffs2_lookup+0x82> <== NOT EXECUTED
uint32_t hash = 0;
10af48: 4615 mov r5, r2 <== NOT EXECUTED
10af4a: e7c1 b.n 10aed0 <jffs2_lookup+0x20> <== NOT EXECUTED
struct _inode *inode = NULL;
10af4c: 4634 mov r4, r6
10af4e: e7f0 b.n 10af32 <jffs2_lookup+0x82>
00107c88 <jffs2_lookup_node_frag>:
next = fragtree->rb_node;
107c88: 6803 ldr r3, [r0, #0]
while(next) {
107c8a: b1eb cbz r3, 107cc8 <jffs2_lookup_node_frag+0x40>
struct jffs2_node_frag *prev = NULL;
107c8c: 2000 movs r0, #0
{
107c8e: b410 push {r4}
if (frag->ofs + frag->size <= offset) {
107c90: e9d3 2405 ldrd r2, r4, [r3, #20]
107c94: 4422 add r2, r4
107c96: 428a cmp r2, r1
107c98: d80a bhi.n 107cb0 <jffs2_lookup_node_frag+0x28>
if (!prev || frag->ofs > prev->ofs)
107c9a: b178 cbz r0, 107cbc <jffs2_lookup_node_frag+0x34>
107c9c: 6982 ldr r2, [r0, #24]
107c9e: 4294 cmp r4, r2
107ca0: bf88 it hi
107ca2: 4618 movhi r0, r3
next = frag->rb.rb_right;
107ca4: 685b ldr r3, [r3, #4]
while(next) {
107ca6: 2b00 cmp r3, #0
107ca8: d1f2 bne.n 107c90 <jffs2_lookup_node_frag+0x8> <== NEVER TAKEN
prev->ofs, prev->ofs+prev->size);
else
dbg_fragtree2("returning NULL, empty fragtree\n");
return prev;
}
107caa: f85d 4b04 ldr.w r4, [sp], #4 <== NOT EXECUTED
107cae: 4770 bx lr <== NOT EXECUTED
} else if (frag->ofs > offset) {
107cb0: 428c cmp r4, r1
107cb2: d905 bls.n 107cc0 <jffs2_lookup_node_frag+0x38>
next = frag->rb.rb_left;
107cb4: 681b ldr r3, [r3, #0]
while(next) {
107cb6: 2b00 cmp r3, #0
107cb8: d1ea bne.n 107c90 <jffs2_lookup_node_frag+0x8> <== NEVER TAKEN
107cba: e7f6 b.n 107caa <jffs2_lookup_node_frag+0x22> <== NOT EXECUTED
107cbc: 4618 mov r0, r3
107cbe: e7f1 b.n 107ca4 <jffs2_lookup_node_frag+0x1c>
107cc0: 4618 mov r0, r3
}
107cc2: f85d 4b04 ldr.w r4, [sp], #4
107cc6: 4770 bx lr
struct jffs2_node_frag *prev = NULL;
107cc8: 4618 mov r0, r3 <== NOT EXECUTED
}
107cca: 4770 bx lr <== NOT EXECUTED
0010808c <jffs2_mark_node_obsolete>:
struct jffs2_unknown_node n;
int ret, addedsize;
size_t retlen;
uint32_t freed_len;
if(unlikely(!ref)) {
10808c: 2900 cmp r1, #0
10808e: f000 8109 beq.w 1082a4 <jffs2_mark_node_obsolete+0x218> <== ALWAYS TAKEN
{
108092: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
108096: 460e mov r6, r1
pr_notice("EEEEEK. jffs2_mark_node_obsolete called with NULL node\n");
return;
}
if (ref_obsolete(ref)) {
108098: 684d ldr r5, [r1, #4]
{
10809a: b086 sub sp, #24
if (ref_obsolete(ref)) {
10809c: f005 0303 and.w r3, r5, #3
1080a0: 2b01 cmp r3, #1
1080a2: d073 beq.n 10818c <jffs2_mark_node_obsolete+0x100> <== ALWAYS 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;
1080a4: 6b41 ldr r1, [r0, #52] ; 0x34
1080a6: 4604 mov r4, r0
1080a8: 4628 mov r0, r5
1080aa: f00c fa59 bl 114560 <__udivsi3>
if (blocknr >= c->nr_blocks) {
1080ae: 6d23 ldr r3, [r4, #80] ; 0x50
1080b0: 4298 cmp r0, r3
1080b2: f080 8153 bcs.w 10835c <jffs2_mark_node_obsolete+0x2d0> <== ALWAYS TAKEN
pr_notice("raw node at 0x%08x is off the end of device!\n",
ref->flash_offset);
BUG();
}
jeb = &c->blocks[blocknr];
1080b6: f04f 0934 mov.w r9, #52 ; 0x34
1080ba: f8d4 8054 ldr.w r8, [r4, #84] ; 0x54
1080be: fb09 f900 mul.w r9, r9, r0
mutex_lock(&c->erase_free_sem);
}
spin_lock(&c->erase_completion_lock);
freed_len = ref_totlen(c, jeb, ref);
1080c2: 4632 mov r2, r6
1080c4: 4620 mov r0, r4
jeb = &c->blocks[blocknr];
1080c6: eb08 0509 add.w r5, r8, r9
freed_len = ref_totlen(c, jeb, ref);
1080ca: 4629 mov r1, r5
1080cc: f7ff ff12 bl 107ef4 <__jffs2_ref_totlen>
if (ref_flags(ref) == REF_UNCHECKED) {
1080d0: 6872 ldr r2, [r6, #4]
freed_len = ref_totlen(c, jeb, ref);
1080d2: 4607 mov r7, r0
if (ref_flags(ref) == REF_UNCHECKED) {
1080d4: 0791 lsls r1, r2, #30
1080d6: d05c beq.n 108192 <jffs2_mark_node_obsolete+0x106> <== ALWAYS TAKEN
ref->flash_offset, jeb->used_size);
BUG();
})
jffs2_dbg(1, "Obsoleting node at 0x%08x of len %#x: ",
ref_offset(ref), freed_len);
jeb->used_size -= freed_len;
1080d8: 696b ldr r3, [r5, #20]
1080da: 1a1b subs r3, r3, r0
1080dc: 616b str r3, [r5, #20]
c->used_size -= freed_len;
1080de: 69e3 ldr r3, [r4, #28]
1080e0: 1a1b subs r3, r3, r0
1080e2: 61e3 str r3, [r4, #28]
}
// Take care, that wasted size is taken into concern
if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) {
1080e4: e9d5 3006 ldrd r3, r0, [r5, #24]
1080e8: b913 cbnz r3, 1080f0 <jffs2_mark_node_obsolete+0x64>
1080ea: 1839 adds r1, r7, r0
1080ec: 29c4 cmp r1, #196 ; 0xc4
1080ee: d957 bls.n 1081a0 <jffs2_mark_node_obsolete+0x114>
1080f0: 6da1 ldr r1, [r4, #88] ; 0x58
1080f2: 42a9 cmp r1, r5
1080f4: bf08 it eq
1080f6: 1839 addeq r1, r7, r0
1080f8: d052 beq.n 1081a0 <jffs2_mark_node_obsolete+0x114>
jffs2_dbg(1, "Dirtying\n");
addedsize = freed_len;
jeb->dirty_size += freed_len;
1080fa: 18f9 adds r1, r7, r3
c->dirty_size += freed_len;
1080fc: 6a23 ldr r3, [r4, #32]
jeb->dirty_size += freed_len;
1080fe: 61a9 str r1, [r5, #24]
addedsize = freed_len;
108100: 46ba mov sl, r7
c->dirty_size += freed_len;
108102: eb07 0e03 add.w lr, r7, r3
108106: f8c4 e020 str.w lr, [r4, #32]
/* Convert wasted space to dirty, if not a bad block */
if (jeb->wasted_size) {
10810a: 2800 cmp r0, #0
10810c: d16f bne.n 1081ee <jffs2_mark_node_obsolete+0x162>
jffs2_dbg(1, "Wasting\n");
addedsize = 0;
jeb->wasted_size += freed_len;
c->wasted_size += freed_len;
}
ref->flash_offset = ref_offset(ref) | REF_OBSOLETE;
10810e: f022 0203 bic.w r2, r2, #3
jffs2_dbg_acct_sanity_check_nolock(c, jeb);
108112: 4629 mov r1, r5
ref->flash_offset = ref_offset(ref) | REF_OBSOLETE;
108114: f042 0201 orr.w r2, r2, #1
jffs2_dbg_acct_sanity_check_nolock(c, jeb);
108118: 4620 mov r0, r4
ref->flash_offset = ref_offset(ref) | REF_OBSOLETE;
10811a: 6072 str r2, [r6, #4]
jffs2_dbg_acct_sanity_check_nolock(c, jeb);
10811c: f002 fe36 bl 10ad8c <__jffs2_dbg_acct_sanity_check_nolock>
jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
if (c->flags & JFFS2_SB_FLAG_SCANNING) {
108120: 68e3 ldr r3, [r4, #12]
108122: 079a lsls r2, r3, #30
108124: d432 bmi.n 10818c <jffs2_mark_node_obsolete+0x100> <== ALWAYS TAKEN
spin_unlock(&c->erase_completion_lock);
/* We didn't lock the erase_free_sem */
return;
}
if (jeb == c->nextblock) {
108126: 6da3 ldr r3, [r4, #88] ; 0x58
108128: 42ab cmp r3, r5
10812a: d029 beq.n 108180 <jffs2_mark_node_obsolete+0xf4>
jffs2_dbg(2, "Not moving nextblock 0x%08x to dirty/erase_pending list\n",
jeb->offset);
} else if (!jeb->used_size && !jeb->unchecked_size) {
10812c: 696a ldr r2, [r5, #20]
if (jeb == c->gcblock) {
10812e: 6de3 ldr r3, [r4, #92] ; 0x5c
} else if (!jeb->used_size && !jeb->unchecked_size) {
108130: 2a00 cmp r2, #0
108132: d13c bne.n 1081ae <jffs2_mark_node_obsolete+0x122>
108134: 692a ldr r2, [r5, #16]
108136: 2a00 cmp r2, #0
108138: d139 bne.n 1081ae <jffs2_mark_node_obsolete+0x122> <== ALWAYS TAKEN
if (jeb == c->gcblock) {
10813a: 429d cmp r5, r3
ent->prev->next = ent->next;
10813c: bf1b ittet ne
10813e: f858 3009 ldrne.w r3, [r8, r9]
108142: 686a ldrne r2, [r5, #4]
jffs2_dbg(1, "gcblock at 0x%08x completely dirtied. Clearing gcblock...\n",
jeb->offset);
c->gcblock = NULL;
108144: 65e2 streq r2, [r4, #92] ; 0x5c
108146: 6013 strne r3, [r2, #0]
ent->next->prev = ent->prev;
108148: bf18 it ne
10814a: 605a strne r2, [r3, #4]
10814c: f243 6314 movw r3, #13844 ; 0x3614
108150: f2c0 0322 movt r3, #34 ; 0x22
108154: 681b ldr r3, [r3, #0]
}
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) {
108156: 065b lsls r3, r3, #25
108158: f000 80c5 beq.w 1082e6 <jffs2_mark_node_obsolete+0x25a> <== ALWAYS TAKEN
rtems_jffs2_flash_control *fc = sb->s_flash_control;
10815c: f8d4 00e4 ldr.w r0, [r4, #228] ; 0xe4
/* 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);
108160: f104 0c98 add.w ip, r4, #152 ; 0x98
c->nr_erasing_blocks++;
108164: 6c23 ldr r3, [r4, #64] ; 0x40
struct list_head *prev = beforethisent->prev;
108166: f8d4 209c ldr.w r2, [r4, #156] ; 0x9c
if (fc->trigger_garbage_collection != NULL) {
10816a: 6a01 ldr r1, [r0, #32]
10816c: 3301 adds r3, #1
newent->prev = prev;
10816e: 606a str r2, [r5, #4]
newent->next = beforethisent;
108170: f848 c009 str.w ip, [r8, r9]
beforethisent->prev = newent;
108174: f8c4 509c str.w r5, [r4, #156] ; 0x9c
prev->next = newent;
108178: 6015 str r5, [r2, #0]
10817a: 6423 str r3, [r4, #64] ; 0x40
10817c: b101 cbz r1, 108180 <jffs2_mark_node_obsolete+0xf4>
(*fc->trigger_garbage_collection)(fc);
10817e: 4788 blx r1 <== NOT EXECUTED
jeb->used_size);
}
spin_unlock(&c->erase_completion_lock);
if (!jffs2_can_mark_obsolete(c) || jffs2_is_readonly(c) ||
108180: f894 30ec ldrb.w r3, [r4, #236] ; 0xec
108184: b913 cbnz r3, 10818c <jffs2_mark_node_obsolete+0x100>
(c->flags & JFFS2_SB_FLAG_BUILDING)) {
108186: 68e3 ldr r3, [r4, #12]
if (!jffs2_can_mark_obsolete(c) || jffs2_is_readonly(c) ||
108188: 0758 lsls r0, r3, #29
10818a: d53f bpl.n 10820c <jffs2_mark_node_obsolete+0x180> <== NEVER TAKEN
spin_unlock(&c->erase_completion_lock);
}
out_erase_sem:
mutex_unlock(&c->erase_free_sem);
}
10818c: b006 add sp, #24
10818e: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
jeb->unchecked_size -= freed_len;
108192: 692b ldr r3, [r5, #16] <== NOT EXECUTED
108194: 1a1b subs r3, r3, r0 <== NOT EXECUTED
108196: 612b str r3, [r5, #16] <== NOT EXECUTED
c->unchecked_size -= freed_len;
108198: 6ba3 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED
10819a: 1a1b subs r3, r3, r0 <== NOT EXECUTED
10819c: 63a3 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
10819e: e7a1 b.n 1080e4 <jffs2_mark_node_obsolete+0x58> <== NOT EXECUTED
c->wasted_size += freed_len;
1081a0: 6a63 ldr r3, [r4, #36] ; 0x24
addedsize = 0;
1081a2: f04f 0a00 mov.w sl, #0
jeb->wasted_size += freed_len;
1081a6: 61e9 str r1, [r5, #28]
c->wasted_size += freed_len;
1081a8: 443b add r3, r7
1081aa: 6263 str r3, [r4, #36] ; 0x24
1081ac: e7af b.n 10810e <jffs2_mark_node_obsolete+0x82>
} else if (jeb == c->gcblock) {
1081ae: 429d cmp r5, r3
1081b0: d0e6 beq.n 108180 <jffs2_mark_node_obsolete+0xf4>
} else if (ISDIRTY(jeb->dirty_size) && !ISDIRTY(jeb->dirty_size - addedsize)) {
1081b2: 69ab ldr r3, [r5, #24]
1081b4: 2bc4 cmp r3, #196 ; 0xc4
1081b6: d904 bls.n 1081c2 <jffs2_mark_node_obsolete+0x136>
1081b8: eba3 020a sub.w r2, r3, sl
1081bc: 2ac4 cmp r2, #196 ; 0xc4
1081be: f240 8084 bls.w 1082ca <jffs2_mark_node_obsolete+0x23e>
} else if (VERYDIRTY(c, jeb->dirty_size) &&
1081c2: 6b62 ldr r2, [r4, #52] ; 0x34
1081c4: 0852 lsrs r2, r2, #1
1081c6: 4293 cmp r3, r2
1081c8: d3da bcc.n 108180 <jffs2_mark_node_obsolete+0xf4>
!VERYDIRTY(c, jeb->dirty_size - addedsize)) {
1081ca: eba3 030a sub.w r3, r3, sl
} else if (VERYDIRTY(c, jeb->dirty_size) &&
1081ce: 429a cmp r2, r3
1081d0: d9d6 bls.n 108180 <jffs2_mark_node_obsolete+0xf4>
ent->prev->next = ent->next;
1081d2: 686a ldr r2, [r5, #4]
1081d4: f858 3009 ldr.w r3, [r8, r9]
1081d8: 6013 str r3, [r2, #0]
ent->next->prev = ent->prev;
1081da: 605a str r2, [r3, #4]
list_add_tail(&jeb->list, &c->very_dirty_list);
1081dc: f104 0268 add.w r2, r4, #104 ; 0x68
struct list_head *prev = beforethisent->prev;
1081e0: 6ee3 ldr r3, [r4, #108] ; 0x6c
newent->prev = prev;
1081e2: 606b str r3, [r5, #4]
newent->next = beforethisent;
1081e4: f848 2009 str.w r2, [r8, r9]
beforethisent->prev = newent;
1081e8: 66e5 str r5, [r4, #108] ; 0x6c
prev->next = newent;
1081ea: 601d str r5, [r3, #0]
} /* list_add_tail() */
1081ec: e7c8 b.n 108180 <jffs2_mark_node_obsolete+0xf4>
list_for_each(this, head) {
1081ee: f8d4 30b8 ldr.w r3, [r4, #184] ; 0xb8
if (on_list(&jeb->list, &c->bad_used_list)) {
1081f2: f104 0cb8 add.w ip, r4, #184 ; 0xb8
list_for_each(this, head) {
1081f6: 459c cmp ip, r3
1081f8: d103 bne.n 108202 <jffs2_mark_node_obsolete+0x176> <== ALWAYS TAKEN
1081fa: e059 b.n 1082b0 <jffs2_mark_node_obsolete+0x224>
1081fc: 681b ldr r3, [r3, #0] <== NOT EXECUTED
1081fe: 459c cmp ip, r3 <== NOT EXECUTED
108200: d056 beq.n 1082b0 <jffs2_mark_node_obsolete+0x224> <== NOT EXECUTED
if (this == obj) {
108202: 429d cmp r5, r3 <== NOT EXECUTED
108204: d1fa bne.n 1081fc <jffs2_mark_node_obsolete+0x170> <== NOT EXECUTED
addedsize = 0; /* To fool the refiling code later */
108206: f04f 0a00 mov.w sl, #0 <== NOT EXECUTED
10820a: e780 b.n 10810e <jffs2_mark_node_obsolete+0x82> <== NOT EXECUTED
ret = jffs2_flash_read(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
10820c: 6871 ldr r1, [r6, #4]
10820e: ab03 add r3, sp, #12
108210: 220c movs r2, #12
108212: 9300 str r3, [sp, #0]
108214: 4620 mov r0, r4
108216: ab02 add r3, sp, #8
108218: f021 0103 bic.w r1, r1, #3
10821c: f003 faf2 bl 10b804 <jffs2_flash_read>
if (ret) {
108220: 4602 mov r2, r0
108222: 2800 cmp r0, #0
108224: d172 bne.n 10830c <jffs2_mark_node_obsolete+0x280> <== ALWAYS TAKEN
if (retlen != sizeof(n)) {
108226: 9a02 ldr r2, [sp, #8]
108228: 2a0c cmp r2, #12
10822a: d165 bne.n 1082f8 <jffs2_mark_node_obsolete+0x26c> <== ALWAYS TAKEN
if (PAD(je32_to_cpu(n.totlen)) != PAD(freed_len)) {
10822c: 9904 ldr r1, [sp, #16]
10822e: 1cfb adds r3, r7, #3
108230: 1cc8 adds r0, r1, #3
108232: 4043 eors r3, r0
108234: f033 0303 bics.w r3, r3, #3
108238: d172 bne.n 108320 <jffs2_mark_node_obsolete+0x294> <== ALWAYS TAKEN
if (!(je16_to_cpu(n.nodetype) & JFFS2_NODE_ACCURATE)) {
10823a: f8bd 300e ldrh.w r3, [sp, #14]
10823e: 0499 lsls r1, r3, #18
108240: d5a4 bpl.n 10818c <jffs2_mark_node_obsolete+0x100> <== ALWAYS TAKEN
ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
108242: a903 add r1, sp, #12
n.nodetype = cpu_to_je16(je16_to_cpu(n.nodetype) & ~JFFS2_NODE_ACCURATE);
108244: f423 5300 bic.w r3, r3, #8192 ; 0x2000
ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
108248: 9100 str r1, [sp, #0]
10824a: 4620 mov r0, r4
10824c: 6871 ldr r1, [r6, #4]
n.nodetype = cpu_to_je16(je16_to_cpu(n.nodetype) & ~JFFS2_NODE_ACCURATE);
10824e: f8ad 300e strh.w r3, [sp, #14]
ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
108252: ab02 add r3, sp, #8
108254: f021 0103 bic.w r1, r1, #3
108258: f003 fae0 bl 10b81c <jffs2_flash_write>
if (ret) {
10825c: 4602 mov r2, r0
10825e: 2800 cmp r0, #0
108260: d170 bne.n 108344 <jffs2_mark_node_obsolete+0x2b8> <== ALWAYS TAKEN
if (retlen != sizeof(n)) {
108262: 9a02 ldr r2, [sp, #8]
108264: 2a0c cmp r2, #12
108266: d163 bne.n 108330 <jffs2_mark_node_obsolete+0x2a4> <== ALWAYS TAKEN
if (ref->next_in_ino) {
108268: 6830 ldr r0, [r6, #0]
10826a: 2800 cmp r0, #0
10826c: d08e beq.n 10818c <jffs2_mark_node_obsolete+0x100>
10826e: 4603 mov r3, r0
108270: 4619 mov r1, r3
while(raw->next_in_ino)
108272: 681b ldr r3, [r3, #0]
108274: 2b00 cmp r3, #0
108276: d1fb bne.n 108270 <jffs2_mark_node_obsolete+0x1e4>
for (p = &ic->nodes; (*p) != ref; p = &((*p)->next_in_ino))
108278: 684b ldr r3, [r1, #4]
10827a: 42b3 cmp r3, r6
10827c: d06c beq.n 108358 <jffs2_mark_node_obsolete+0x2cc>
10827e: 461a mov r2, r3
108280: 681b ldr r3, [r3, #0]
108282: 429e cmp r6, r3
108284: d1fb bne.n 10827e <jffs2_mark_node_obsolete+0x1f2>
*p = ref->next_in_ino;
108286: 6010 str r0, [r2, #0]
ref->next_in_ino = NULL;
108288: 2200 movs r2, #0
if (ic->nodes == (void *)ic && ic->pino_nlink == 0)
10828a: 684b ldr r3, [r1, #4]
ref->next_in_ino = NULL;
10828c: 6032 str r2, [r6, #0]
if (ic->nodes == (void *)ic && ic->pino_nlink == 0)
10828e: 4299 cmp r1, r3
108290: f47f af7c bne.w 10818c <jffs2_mark_node_obsolete+0x100>
108294: 694b ldr r3, [r1, #20]
108296: 2b00 cmp r3, #0
108298: f47f af78 bne.w 10818c <jffs2_mark_node_obsolete+0x100>
jffs2_del_ino_cache(c, ic);
10829c: 4620 mov r0, r4
10829e: f7ff fc75 bl 107b8c <jffs2_del_ino_cache>
return 0;
}
static inline void mutex_unlock(struct mutex *m)
{
(void) m;
1082a2: e773 b.n 10818c <jffs2_mark_node_obsolete+0x100>
pr_notice("EEEEEK. jffs2_mark_node_obsolete called with NULL node\n");
1082a4: f247 00a0 movw r0, #28832 ; 0x70a0 <== NOT EXECUTED
1082a8: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1082ac: f7ff be6c b.w 107f88 <jffs2_printk> <== NOT EXECUTED
c->dirty_size += jeb->wasted_size;
1082b0: eb0e 0300 add.w r3, lr, r0
jeb->dirty_size += jeb->wasted_size;
1082b4: 4401 add r1, r0
1082b6: 61a9 str r1, [r5, #24]
addedsize += jeb->wasted_size;
1082b8: eb07 0a00 add.w sl, r7, r0
c->dirty_size += jeb->wasted_size;
1082bc: 6223 str r3, [r4, #32]
c->wasted_size -= jeb->wasted_size;
1082be: 6a63 ldr r3, [r4, #36] ; 0x24
1082c0: 1a1b subs r3, r3, r0
1082c2: 6263 str r3, [r4, #36] ; 0x24
jeb->wasted_size = 0;
1082c4: 2300 movs r3, #0
1082c6: 61eb str r3, [r5, #28]
1082c8: e721 b.n 10810e <jffs2_mark_node_obsolete+0x82>
ent->prev->next = ent->next;
1082ca: 686a ldr r2, [r5, #4]
1082cc: f858 3009 ldr.w r3, [r8, r9]
1082d0: 6013 str r3, [r2, #0]
ent->next->prev = ent->prev;
1082d2: 605a str r2, [r3, #4]
list_add_tail(&jeb->list, &c->dirty_list);
1082d4: f104 0270 add.w r2, r4, #112 ; 0x70
struct list_head *prev = beforethisent->prev;
1082d8: 6f63 ldr r3, [r4, #116] ; 0x74
newent->prev = prev;
1082da: 606b str r3, [r5, #4]
newent->next = beforethisent;
1082dc: f848 2009 str.w r2, [r8, r9]
beforethisent->prev = newent;
1082e0: 6765 str r5, [r4, #116] ; 0x74
prev->next = newent;
1082e2: 601d str r5, [r3, #0]
} /* list_add_tail() */
1082e4: e74c b.n 108180 <jffs2_mark_node_obsolete+0xf4>
struct list_head *prev = beforethisent->prev;
1082e6: 6fe3 ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
list_add_tail(&jeb->list, &c->erasable_list);
1082e8: f104 0278 add.w r2, r4, #120 ; 0x78 <== NOT EXECUTED
newent->prev = prev;
1082ec: 606b str r3, [r5, #4] <== NOT EXECUTED
newent->next = beforethisent;
1082ee: f848 2009 str.w r2, [r8, r9] <== NOT EXECUTED
beforethisent->prev = newent;
1082f2: 67e5 str r5, [r4, #124] ; 0x7c <== NOT EXECUTED
prev->next = newent;
1082f4: 601d str r5, [r3, #0] <== NOT EXECUTED
} /* list_add_tail() */
1082f6: e743 b.n 108180 <jffs2_mark_node_obsolete+0xf4> <== NOT EXECUTED
pr_warn("Short read from obsoleted node at 0x%08x: %zd\n",
1082f8: 6871 ldr r1, [r6, #4] <== NOT EXECUTED
1082fa: f247 108c movw r0, #29068 ; 0x718c <== NOT EXECUTED
1082fe: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108302: f021 0103 bic.w r1, r1, #3 <== NOT EXECUTED
108306: f7ff fe3f bl 107f88 <jffs2_printk> <== NOT EXECUTED
goto out_erase_sem;
10830a: e73f b.n 10818c <jffs2_mark_node_obsolete+0x100> <== NOT EXECUTED
pr_warn("Read error reading from obsoleted node at 0x%08x: %d\n",
10830c: 6871 ldr r1, [r6, #4] <== NOT EXECUTED
10830e: f247 104c movw r0, #29004 ; 0x714c <== NOT EXECUTED
108312: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108316: f021 0103 bic.w r1, r1, #3 <== NOT EXECUTED
10831a: f7ff fe35 bl 107f88 <jffs2_printk> <== NOT EXECUTED
goto out_erase_sem;
10831e: e735 b.n 10818c <jffs2_mark_node_obsolete+0x100> <== NOT EXECUTED
pr_warn("Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n",
108320: f247 10c8 movw r0, #29128 ; 0x71c8 <== NOT EXECUTED
108324: 463a mov r2, r7 <== NOT EXECUTED
108326: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10832a: f7ff fe2d bl 107f88 <jffs2_printk> <== NOT EXECUTED
goto out_erase_sem;
10832e: e72d b.n 10818c <jffs2_mark_node_obsolete+0x100> <== NOT EXECUTED
pr_warn("Short write in obliterating obsoleted node at 0x%08x: %zd\n",
108330: 6871 ldr r1, [r6, #4] <== NOT EXECUTED
108332: f247 2058 movw r0, #29272 ; 0x7258 <== NOT EXECUTED
108336: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10833a: f021 0103 bic.w r1, r1, #3 <== NOT EXECUTED
10833e: f7ff fe23 bl 107f88 <jffs2_printk> <== NOT EXECUTED
goto out_erase_sem;
108342: e723 b.n 10818c <jffs2_mark_node_obsolete+0x100> <== NOT EXECUTED
pr_warn("Write error in obliterating obsoleted node at 0x%08x: %d\n",
108344: 6871 ldr r1, [r6, #4] <== NOT EXECUTED
108346: f247 2014 movw r0, #29204 ; 0x7214 <== NOT EXECUTED
10834a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10834e: f021 0103 bic.w r1, r1, #3 <== NOT EXECUTED
108352: f7ff fe19 bl 107f88 <jffs2_printk> <== NOT EXECUTED
goto out_erase_sem;
108356: e719 b.n 10818c <jffs2_mark_node_obsolete+0x100> <== NOT EXECUTED
for (p = &ic->nodes; (*p) != ref; p = &((*p)->next_in_ino))
108358: 1d0a adds r2, r1, #4
10835a: e794 b.n 108286 <jffs2_mark_node_obsolete+0x1fa>
pr_notice("raw node at 0x%08x is off the end of device!\n",
10835c: f247 00e4 movw r0, #28900 ; 0x70e4 <== NOT EXECUTED
108360: 4629 mov r1, r5 <== NOT EXECUTED
108362: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108366: f7ff fe0f bl 107f88 <jffs2_printk> <== NOT EXECUTED
BUG();
10836a: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
10836e: f247 328c movw r2, #29580 ; 0x738c <== NOT EXECUTED
108372: f247 101c movw r0, #28956 ; 0x711c <== NOT EXECUTED
108376: f2c0 0311 movt r3, #17 <== NOT EXECUTED
10837a: f2c0 0211 movt r2, #17 <== NOT EXECUTED
10837e: f240 215b movw r1, #603 ; 0x25b <== NOT EXECUTED
108382: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108386: f004 f973 bl 10c670 <__assert_func> <== NOT EXECUTED
10838a: bf00 nop
0010b068 <jffs2_mknod>:
size_t d_namelen,
int mode,
const unsigned char *data,
size_t datalen
)
{
10b068: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
10b06c: b087 sub sp, #28
10b06e: 9f11 ldr r7, [sp, #68] ; 0x44
10b070: e9cd 2102 strd r2, r1, [sp, #8]
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)
10b074: 2ffe cmp r7, #254 ; 0xfe
10b076: f200 8102 bhi.w 10b27e <jffs2_mknod+0x216> <== ALWAYS TAKEN
return -ENAMETOOLONG;
ri = jffs2_alloc_raw_inode();
10b07a: 4606 mov r6, r0
10b07c: 4699 mov r9, r3
10b07e: f7fc fa5d bl 10753c <jffs2_alloc_raw_inode>
if (!ri)
10b082: 4604 mov r4, r0
10b084: 2800 cmp r0, #0
10b086: f000 80fd beq.w 10b284 <jffs2_mknod+0x21c> <== ALWAYS TAKEN
return -ENOMEM;
c = JFFS2_SB_INFO(dir_i->i_sb);
10b08a: f8d6 a040 ldr.w sl, [r6, #64] ; 0x40
/* 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,
10b08e: 2312 movs r3, #18
10b090: f107 0b44 add.w fp, r7, #68 ; 0x44
10b094: 9300 str r3, [sp, #0]
10b096: aa05 add r2, sp, #20
10b098: 2300 movs r3, #0
10b09a: 4659 mov r1, fp
10b09c: 4650 mov r0, sl
10b09e: f7fd fa99 bl 1085d4 <jffs2_reserve_space>
ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
if (ret) {
10b0a2: 4605 mov r5, r0
10b0a4: 2800 cmp r0, #0
10b0a6: d160 bne.n 10b16a <jffs2_mknod+0x102> <== ALWAYS TAKEN
jffs2_free_raw_inode(ri);
return ret;
}
inode = jffs2_new_inode(dir_i, mode, ri);
10b0a8: 4622 mov r2, r4
10b0aa: 4649 mov r1, r9
10b0ac: 4630 mov r0, r6
10b0ae: f7fb f91b bl 1062e8 <jffs2_new_inode>
if (IS_ERR(inode)) {
10b0b2: f510 7f7a cmn.w r0, #1000 ; 0x3e8
inode = jffs2_new_inode(dir_i, mode, ri);
10b0b6: 4680 mov r8, r0
if (IS_ERR(inode)) {
10b0b8: d84c bhi.n 10b154 <jffs2_mknod+0xec> <== ALWAYS TAKEN
return PTR_ERR(inode);
}
f = JFFS2_INODE_INFO(inode);
inode->i_size = datalen;
10b0ba: e9c0 750e strd r7, r5, [r0, #56] ; 0x38
ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size);
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
10b0be: 2208 movs r2, #8
ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
10b0c0: 6327 str r7, [r4, #48] ; 0x30
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
10b0c2: 4621 mov r1, r4
ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
10b0c4: 6b23 ldr r3, [r4, #48] ; 0x30
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
10b0c6: 4628 mov r0, r5
ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size);
10b0c8: f8c4 b004 str.w fp, [r4, #4]
ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
10b0cc: 6363 str r3, [r4, #52] ; 0x34
10b0ce: 6b63 ldr r3, [r4, #52] ; 0x34
10b0d0: 61e3 str r3, [r4, #28]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
10b0d2: f7ff fdf3 bl 10acbc <cyg_crc32_accumulate>
ri->compr = JFFS2_COMPR_NONE;
ri->data_crc = cpu_to_je32(crc32(0, data, datalen));
10b0d6: 9910 ldr r1, [sp, #64] ; 0x40
10b0d8: 463a mov r2, r7
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
10b0da: 60a0 str r0, [r4, #8]
ri->data_crc = cpu_to_je32(crc32(0, data, datalen));
10b0dc: 4628 mov r0, r5
ri->compr = JFFS2_COMPR_NONE;
10b0de: f884 5038 strb.w r5, [r4, #56] ; 0x38
ri->data_crc = cpu_to_je32(crc32(0, data, datalen));
10b0e2: f7ff fdeb bl 10acbc <cyg_crc32_accumulate>
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
10b0e6: 223c movs r2, #60 ; 0x3c
10b0e8: 4621 mov r1, r4
ri->data_crc = cpu_to_je32(crc32(0, data, datalen));
10b0ea: 63e0 str r0, [r4, #60] ; 0x3c
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
10b0ec: 4628 mov r0, r5
10b0ee: f7ff fde5 bl 10acbc <cyg_crc32_accumulate>
fn = jffs2_write_dnode(c, f, ri, data, datalen, ALLOC_NORMAL);
10b0f2: 9b10 ldr r3, [sp, #64] ; 0x40
10b0f4: 4622 mov r2, r4
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
10b0f6: 6420 str r0, [r4, #64] ; 0x40
fn = jffs2_write_dnode(c, f, ri, data, datalen, ALLOC_NORMAL);
10b0f8: f108 0148 add.w r1, r8, #72 ; 0x48
10b0fc: 4650 mov r0, sl
10b0fe: e9cd 7500 strd r7, r5, [sp]
10b102: f7fe fee1 bl 109ec8 <jffs2_write_dnode>
10b106: 4683 mov fp, r0
jffs2_free_raw_inode(ri);
10b108: 4620 mov r0, r4
10b10a: f7fc fa1b bl 107544 <jffs2_free_raw_inode>
if (IS_ERR(fn)) {
10b10e: f51b 7f7a cmn.w fp, #1000 ; 0x3e8
10b112: f200 8098 bhi.w 10b246 <jffs2_mknod+0x1de> <== ALWAYS TAKEN
jffs2_complete_reservation(c);
ret = PTR_ERR(fn);
goto fail;
}
if (S_ISLNK(mode)) {
10b116: f409 4370 and.w r3, r9, #61440 ; 0xf000
10b11a: f5b3 4f20 cmp.w r3, #40960 ; 0xa000
10b11e: f000 8085 beq.w 10b22c <jffs2_mknod+0x1c4>
obsoleted by the first data write
*/
f->metadata = fn;
mutex_unlock(&f->sem);
jffs2_complete_reservation(c);
10b122: 4650 mov r0, sl
f->metadata = fn;
10b124: f8c8 b050 str.w fp, [r8, #80] ; 0x50
jffs2_complete_reservation(c);
10b128: f7fc ffaa bl 108080 <jffs2_complete_reservation>
ret = jffs2_reserve_space(c, sizeof(*rd)+d_namelen, &alloclen,
10b12c: 9b02 ldr r3, [sp, #8]
10b12e: aa05 add r2, sp, #20
10b130: 4650 mov r0, sl
10b132: f103 0728 add.w r7, r3, #40 ; 0x28
10b136: 3318 adds r3, #24
10b138: 9300 str r3, [sp, #0]
10b13a: 4639 mov r1, r7
10b13c: 2300 movs r3, #0
10b13e: f7fd fa49 bl 1085d4 <jffs2_reserve_space>
ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(d_namelen));
if (ret)
10b142: 4605 mov r5, r0
10b144: b1c0 cbz r0, 10b178 <jffs2_mknod+0x110>
mutex_unlock(&dir_f->sem);
jffs2_complete_reservation(c);
fail:
jffs2_iput(inode);
10b146: 4640 mov r0, r8
10b148: f7fa fe98 bl 105e7c <jffs2_iput>
return ret;
}
10b14c: 4628 mov r0, r5
10b14e: b007 add sp, #28
10b150: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
jffs2_free_raw_inode(ri);
10b154: 4620 mov r0, r4 <== NOT EXECUTED
return PTR_ERR(inode);
10b156: 4645 mov r5, r8 <== NOT EXECUTED
jffs2_free_raw_inode(ri);
10b158: f7fc f9f4 bl 107544 <jffs2_free_raw_inode> <== NOT EXECUTED
jffs2_complete_reservation(c);
10b15c: 4650 mov r0, sl <== NOT EXECUTED
10b15e: f7fc ff8f bl 108080 <jffs2_complete_reservation> <== NOT EXECUTED
}
10b162: 4628 mov r0, r5 <== NOT EXECUTED
10b164: b007 add sp, #28 <== NOT EXECUTED
10b166: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
jffs2_free_raw_inode(ri);
10b16a: 4620 mov r0, r4 <== NOT EXECUTED
10b16c: f7fc f9ea bl 107544 <jffs2_free_raw_inode> <== NOT EXECUTED
}
10b170: 4628 mov r0, r5 <== NOT EXECUTED
10b172: b007 add sp, #28 <== NOT EXECUTED
10b174: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
rd = jffs2_alloc_raw_dirent();
10b178: f7fc f9da bl 107530 <jffs2_alloc_raw_dirent>
if (!rd) {
10b17c: 4604 mov r4, r0
10b17e: 2800 cmp r0, #0
10b180: d077 beq.n 10b272 <jffs2_mknod+0x20a> <== ALWAYS TAKEN
rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
10b182: f06f 037a mvn.w r3, #122 ; 0x7a
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
10b186: 4601 mov r1, r0
rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
10b188: 7003 strb r3, [r0, #0]
10b18a: 2319 movs r3, #25
10b18c: 7043 strb r3, [r0, #1]
rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
10b18e: 2301 movs r3, #1
10b190: 7083 strb r3, [r0, #2]
10b192: f06f 031f mvn.w r3, #31
rd->totlen = cpu_to_je32(sizeof(*rd) + d_namelen);
10b196: 6047 str r7, [r0, #4]
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
10b198: 2208 movs r2, #8
rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
10b19a: 70c3 strb r3, [r0, #3]
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
10b19c: 4628 mov r0, r5
10b19e: f7ff fd8d bl 10acbc <cyg_crc32_accumulate>
rd->pino = cpu_to_je32(dir_i->i_ino);
10b1a2: 6832 ldr r2, [r6, #0]
rd->version = cpu_to_je32(++dir_f->highest_version);
10b1a4: 4637 mov r7, r6
10b1a6: 6cb3 ldr r3, [r6, #72] ; 0x48
rd->type = (mode & S_IFMT) >> 12;
10b1a8: f3c9 3903 ubfx r9, r9, #12, #4
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
10b1ac: 60a0 str r0, [r4, #8]
rd->mctime = cpu_to_je32(get_seconds());
10b1ae: 4628 mov r0, r5
rd->pino = cpu_to_je32(dir_i->i_ino);
10b1b0: 60e2 str r2, [r4, #12]
rd->ino = cpu_to_je32(inode->i_ino);
10b1b2: f8d8 2000 ldr.w r2, [r8]
rd->version = cpu_to_je32(++dir_f->highest_version);
10b1b6: 3301 adds r3, #1
10b1b8: f847 3f48 str.w r3, [r7, #72]!
10b1bc: 6123 str r3, [r4, #16]
rd->ino = cpu_to_je32(inode->i_ino);
10b1be: 6162 str r2, [r4, #20]
rd->mctime = cpu_to_je32(get_seconds());
10b1c0: f00a fb5a bl 115878 <time>
rd->nsize = d_namelen;
10b1c4: 9b02 ldr r3, [sp, #8]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
10b1c6: 2220 movs r2, #32
10b1c8: 4621 mov r1, r4
rd->mctime = cpu_to_je32(get_seconds());
10b1ca: 61a0 str r0, [r4, #24]
rd->type = (mode & S_IFMT) >> 12;
10b1cc: f884 901d strb.w r9, [r4, #29]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
10b1d0: 4628 mov r0, r5
rd->nsize = d_namelen;
10b1d2: 7723 strb r3, [r4, #28]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
10b1d4: f7ff fd72 bl 10acbc <cyg_crc32_accumulate>
rd->name_crc = cpu_to_je32(crc32(0, d_name, d_namelen));
10b1d8: f8dd b008 ldr.w fp, [sp, #8]
10b1dc: f8dd 900c ldr.w r9, [sp, #12]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
10b1e0: 6220 str r0, [r4, #32]
rd->name_crc = cpu_to_je32(crc32(0, d_name, d_namelen));
10b1e2: 4628 mov r0, r5
10b1e4: 465a mov r2, fp
10b1e6: 4649 mov r1, r9
10b1e8: f7ff fd68 bl 10acbc <cyg_crc32_accumulate>
fd = jffs2_write_dirent(c, dir_f, rd, d_name, d_namelen, ALLOC_NORMAL);
10b1ec: 4639 mov r1, r7
rd->name_crc = cpu_to_je32(crc32(0, d_name, d_namelen));
10b1ee: 6260 str r0, [r4, #36] ; 0x24
fd = jffs2_write_dirent(c, dir_f, rd, d_name, d_namelen, ALLOC_NORMAL);
10b1f0: 464b mov r3, r9
10b1f2: 4622 mov r2, r4
10b1f4: 4650 mov r0, sl
10b1f6: f8cd b000 str.w fp, [sp]
10b1fa: 9501 str r5, [sp, #4]
10b1fc: f7fe ff70 bl 10a0e0 <jffs2_write_dirent>
if (IS_ERR(fd)) {
10b200: f510 7f7a cmn.w r0, #1000 ; 0x3e8
fd = jffs2_write_dirent(c, dir_f, rd, d_name, d_namelen, ALLOC_NORMAL);
10b204: 4607 mov r7, r0
if (IS_ERR(fd)) {
10b206: d823 bhi.n 10b250 <jffs2_mknod+0x1e8> <== ALWAYS TAKEN
dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime));
10b208: 69a3 ldr r3, [r4, #24]
jffs2_free_raw_dirent(rd);
10b20a: 4620 mov r0, r4
dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime));
10b20c: 62f5 str r5, [r6, #44] ; 0x2c
10b20e: e9c6 5309 strd r5, r3, [r6, #36] ; 0x24
10b212: 6233 str r3, [r6, #32]
jffs2_free_raw_dirent(rd);
10b214: f7fc f990 bl 107538 <jffs2_free_raw_dirent>
jffs2_add_fd_to_list(c, fd, &dir_f->dents);
10b218: 4650 mov r0, sl
10b21a: f106 0254 add.w r2, r6, #84 ; 0x54
10b21e: 4639 mov r1, r7
10b220: f7fc fa48 bl 1076b4 <jffs2_add_fd_to_list>
jffs2_complete_reservation(c);
10b224: 4650 mov r0, sl
10b226: f7fc ff2b bl 108080 <jffs2_complete_reservation>
10b22a: e78c b.n 10b146 <jffs2_mknod+0xde>
char *dup = malloc(n + 1);
10b22c: 1cb8 adds r0, r7, #2
f->target = kmemdup(data, datalen + 1, GFP_KERNEL);
10b22e: 3701 adds r7, #1
10b230: f001 fc96 bl 10cb60 <malloc>
if (dup != 0) {
10b234: b1a0 cbz r0, 10b260 <jffs2_mknod+0x1f8>
dup = memcpy(dup, s, n);
10b236: 9910 ldr r1, [sp, #64] ; 0x40
10b238: 463a mov r2, r7
dup[n] = '\0';
10b23a: 55c5 strb r5, [r0, r7]
dup = memcpy(dup, s, n);
10b23c: f009 ed20 blx 114c80 <memcpy>
10b240: f8c8 0058 str.w r0, [r8, #88] ; 0x58
if (!f->target) {
10b244: e76d b.n 10b122 <jffs2_mknod+0xba>
jffs2_complete_reservation(c);
10b246: 4650 mov r0, sl <== NOT EXECUTED
ret = PTR_ERR(fn);
10b248: 465d mov r5, fp <== NOT EXECUTED
jffs2_complete_reservation(c);
10b24a: f7fc ff19 bl 108080 <jffs2_complete_reservation> <== NOT EXECUTED
goto fail;
10b24e: e77a b.n 10b146 <jffs2_mknod+0xde> <== NOT EXECUTED
jffs2_complete_reservation(c);
10b250: 4650 mov r0, sl <== NOT EXECUTED
ret = PTR_ERR(fd);
10b252: 463d mov r5, r7 <== NOT EXECUTED
jffs2_complete_reservation(c);
10b254: f7fc ff14 bl 108080 <jffs2_complete_reservation> <== NOT EXECUTED
jffs2_free_raw_dirent(rd);
10b258: 4620 mov r0, r4 <== NOT EXECUTED
10b25a: f7fc f96d bl 107538 <jffs2_free_raw_dirent> <== NOT EXECUTED
goto fail;
10b25e: e772 b.n 10b146 <jffs2_mknod+0xde> <== NOT EXECUTED
pr_warn("Can't allocate %d bytes of memory\n", datalen + 1);
10b260: f648 102c movw r0, #35116 ; 0x892c <== NOT EXECUTED
10b264: 4639 mov r1, r7 <== NOT EXECUTED
10b266: f2c0 0011 movt r0, #17 <== NOT EXECUTED
f->target = kmemdup(data, datalen + 1, GFP_KERNEL);
10b26a: f8c8 5058 str.w r5, [r8, #88] ; 0x58 <== NOT EXECUTED
pr_warn("Can't allocate %d bytes of memory\n", datalen + 1);
10b26e: f7ff fe11 bl 10ae94 <jffs2_printk> <== NOT EXECUTED
jffs2_complete_reservation(c);
10b272: 4650 mov r0, sl <== NOT EXECUTED
ret = -ENOMEM;
10b274: f06f 050b mvn.w r5, #11 <== NOT EXECUTED
jffs2_complete_reservation(c);
10b278: f7fc ff02 bl 108080 <jffs2_complete_reservation> <== NOT EXECUTED
goto fail;
10b27c: e763 b.n 10b146 <jffs2_mknod+0xde> <== NOT EXECUTED
return -ENAMETOOLONG;
10b27e: f06f 055a mvn.w r5, #90 ; 0x5a <== NOT EXECUTED
10b282: e76e b.n 10b162 <jffs2_mknod+0xfa> <== NOT EXECUTED
return -ENOMEM;
10b284: f06f 050b mvn.w r5, #11 <== NOT EXECUTED
10b288: e76b b.n 10b162 <jffs2_mknod+0xfa> <== NOT EXECUTED
10b28a: bf00 nop
001062e8 <jffs2_new_inode>:
{
1062e8: e92d 43f8 stmdb sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
1062ec: 460e mov r6, r1
struct super_block *sb = dir_i->i_sb;
1062ee: 6c07 ldr r7, [r0, #64] ; 0x40
{
1062f0: 4615 mov r5, r2
return ERR_PTR(-ENOMEM);
1062f2: f06f 040b mvn.w r4, #11
inode = new_inode(sb);
1062f6: 4638 mov r0, r7
1062f8: f7ff f810 bl 10531c <new_inode>
if (!inode)
1062fc: b378 cbz r0, 10635e <jffs2_new_inode+0x76>
memset(f, 0, sizeof(*f));
1062fe: 2100 movs r1, #0
memset(ri, 0, sizeof(*ri));
106300: 2244 movs r2, #68 ; 0x44
memset(f, 0, sizeof(*f));
106302: 6481 str r1, [r0, #72] ; 0x48
f = JFFS2_INODE_INFO(inode);
106304: f100 0848 add.w r8, r0, #72 ; 0x48
memset(f, 0, sizeof(*f));
106308: 64c1 str r1, [r0, #76] ; 0x4c
10630a: 4604 mov r4, r0
10630c: 6501 str r1, [r0, #80] ; 0x50
return osmode & (S_IFMT | S_IRWXU | S_IRWXG | S_IRWXO);
10630e: f24f 19ff movw r9, #61951 ; 0xf1ff
106312: 6541 str r1, [r0, #84] ; 0x54
106314: 6581 str r1, [r0, #88] ; 0x58
106316: 65c1 str r1, [r0, #92] ; 0x5c
106318: 6601 str r1, [r0, #96] ; 0x60
memset(ri, 0, sizeof(*ri));
10631a: 4628 mov r0, r5
10631c: f00e ff20 bl 115160 <memset>
ri->uid = cpu_to_je16(geteuid());
106320: f006 fb3e bl 10c9a0 <geteuid>
106324: 8328 strh r0, [r5, #24]
ri->gid = cpu_to_je16(getegid());
106326: f006 fb35 bl 10c994 <getegid>
10632a: ea06 0309 and.w r3, r6, r9
ret = jffs2_do_new_inode (c, f, mode, ri);
10632e: 4632 mov r2, r6
ri->gid = cpu_to_je16(getegid());
106330: 8368 strh r0, [r5, #26]
ret = jffs2_do_new_inode (c, f, mode, ri);
106332: 4641 mov r1, r8
ri->mode = cpu_to_jemode(mode);
106334: 616b str r3, [r5, #20]
ret = jffs2_do_new_inode (c, f, mode, ri);
106336: 4638 mov r0, r7
106338: 462b mov r3, r5
10633a: f003 fd7f bl 109e3c <jffs2_do_new_inode>
if (ret) {
10633e: 4606 mov r6, r0
106340: b180 cbz r0, 106364 <jffs2_new_inode+0x7c>
inode->i_cache_prev->i_cache_next = inode->i_cache_next;
106342: e9d4 2319 ldrd r2, r3, [r4, #100] ; 0x64 <== NOT EXECUTED
if (inode->i_cache_prev)
106346: b102 cbz r2, 10634a <jffs2_new_inode+0x62> <== NOT EXECUTED
inode->i_cache_prev->i_cache_next = inode->i_cache_next;
106348: 6693 str r3, [r2, #104] ; 0x68 <== NOT EXECUTED
if (inode->i_cache_next)
10634a: b103 cbz r3, 10634e <jffs2_new_inode+0x66> <== NOT EXECUTED
inode->i_cache_next->i_cache_prev = inode->i_cache_prev;
10634c: 665a str r2, [r3, #100] ; 0x64 <== NOT EXECUTED
jffs2_do_clear_inode(c, f);
10634e: 6c20 ldr r0, [r4, #64] ; 0x40 <== NOT EXECUTED
106350: 4641 mov r1, r8 <== NOT EXECUTED
106352: f003 fcf9 bl 109d48 <jffs2_do_clear_inode> <== NOT EXECUTED
free(inode);
106356: 4620 mov r0, r4 <== NOT EXECUTED
return ERR_PTR(ret);
106358: 4634 mov r4, r6 <== NOT EXECUTED
free(inode);
10635a: f006 fac5 bl 10c8e8 <free> <== NOT EXECUTED
}
10635e: 4620 mov r0, r4 <== NOT EXECUTED
106360: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
inode->i_nlink = 1;
106364: 2301 movs r3, #1
106366: 81a3 strh r3, [r4, #12]
inode->i_ino = je32_to_cpu(ri->ino);
106368: 68eb ldr r3, [r5, #12]
10636a: 6023 str r3, [r4, #0]
inode->i_mode = jemode_to_cpu(ri->mode);
10636c: 696b ldr r3, [r5, #20]
return jmode & (S_IFMT | S_IRWXU | S_IRWXG | S_IRWXO);
10636e: ea03 0309 and.w r3, r3, r9
106372: 60a3 str r3, [r4, #8]
inode->i_gid = je16_to_cpu(ri->gid);
106374: 7eea ldrb r2, [r5, #27]
106376: 7eab ldrb r3, [r5, #26]
106378: ea43 2302 orr.w r3, r3, r2, lsl #8
10637c: 8223 strh r3, [r4, #16]
inode->i_uid = je16_to_cpu(ri->uid);
10637e: 7e2b ldrb r3, [r5, #24]
106380: 7e6a ldrb r2, [r5, #25]
106382: ea43 2302 orr.w r3, r3, r2, lsl #8
106386: 81e3 strh r3, [r4, #14]
inode->i_atime = inode->i_ctime = inode->i_mtime = get_seconds();
106388: f00f fa76 bl 115878 <time>
10638c: e9c4 0108 strd r0, r1, [r4, #32]
106390: e9c4 010a strd r0, r1, [r4, #40] ; 0x28
106394: e9c4 0106 strd r0, r1, [r4, #24]
ri->atime = ri->mtime = ri->ctime = cpu_to_je32(inode->i_mtime);
106398: 62a8 str r0, [r5, #40] ; 0x28
}
10639a: 4620 mov r0, r4
ri->atime = ri->mtime = ri->ctime = cpu_to_je32(inode->i_mtime);
10639c: 6aab ldr r3, [r5, #40] ; 0x28
inode->i_size = 0;
10639e: efc0 0010 vmov.i32 d16, #0 ; 0x00000000
ri->atime = ri->mtime = ri->ctime = cpu_to_je32(inode->i_mtime);
1063a2: 626b str r3, [r5, #36] ; 0x24
1063a4: 6a6b ldr r3, [r5, #36] ; 0x24
1063a6: 622b str r3, [r5, #32]
inode->i_size = 0;
1063a8: edc4 0b0e vstr d16, [r4, #56] ; 0x38
}
1063ac: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc}
00107554 <jffs2_prealloc_raw_node_refs>:
return ret;
}
int jffs2_prealloc_raw_node_refs(struct jffs2_sb_info *c,
struct jffs2_eraseblock *jeb, int nr)
{
107554: e92d 43f8 stmdb sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
107558: 4617 mov r7, r2
struct jffs2_raw_node_ref **p, *ref;
int i = nr;
p = &jeb->last_node;
ref = *p;
10755a: 6aca ldr r2, [r1, #44] ; 0x2c
{
10755c: 460e mov r6, r1
p = &jeb->last_node;
10755e: f101 092c add.w r9, r1, #44 ; 0x2c
/* If jeb->last_node is really a valid node then skip over it */
if (ref && ref->flash_offset != REF_EMPTY_NODE)
107562: b11a cbz r2, 10756c <jffs2_prealloc_raw_node_refs+0x18>
107564: 6853 ldr r3, [r2, #4]
107566: 3302 adds r3, #2
ref++;
107568: bf18 it ne
10756a: 3208 addne r2, #8
while (i) {
10756c: b167 cbz r7, 107588 <jffs2_prealloc_raw_node_refs+0x34>
10756e: 46b8 mov r8, r7
ret[i].flash_offset = REF_EMPTY_NODE;
107570: f06f 0501 mvn.w r5, #1
ret[i].next_in_ino = NULL;
107574: 2400 movs r4, #0
if (!ref) {
107576: b17a cbz r2, 107598 <jffs2_prealloc_raw_node_refs+0x44>
ref = *p = jffs2_alloc_refblock();
if (!ref)
return -ENOMEM;
}
if (ref->flash_offset == REF_LINK_NODE) {
107578: 6853 ldr r3, [r2, #4]
10757a: 3301 adds r3, #1
10757c: d008 beq.n 107590 <jffs2_prealloc_raw_node_refs+0x3c>
while (i) {
10757e: f1b8 0801 subs.w r8, r8, #1
p = &ref->next_in_ino;
ref = *p;
continue;
}
i--;
ref++;
107582: f102 0208 add.w r2, r2, #8
while (i) {
107586: d1f6 bne.n 107576 <jffs2_prealloc_raw_node_refs+0x22> <== ALWAYS TAKEN
}
jeb->allocated_refs = nr;
return 0;
107588: 2000 movs r0, #0
jeb->allocated_refs = nr;
10758a: 6277 str r7, [r6, #36] ; 0x24
}
10758c: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc}
p = &ref->next_in_ino;
107590: 4691 mov r9, r2
ref = *p;
107592: 6812 ldr r2, [r2, #0]
if (!ref) {
107594: 2a00 cmp r2, #0
107596: d1ef bne.n 107578 <jffs2_prealloc_raw_node_refs+0x24> <== ALWAYS TAKEN
ret = malloc((REFS_PER_BLOCK + 1) * sizeof(*ret));
107598: 20f8 movs r0, #248 ; 0xf8
10759a: f005 fae1 bl 10cb60 <malloc>
if (ret) {
10759e: 4602 mov r2, r0
1075a0: b178 cbz r0, 1075c2 <jffs2_prealloc_raw_node_refs+0x6e>
for (i=0; i < REFS_PER_BLOCK; i++) {
1075a2: 2300 movs r3, #0
1075a4: 3004 adds r0, #4
ret[i].flash_offset = REF_EMPTY_NODE;
1075a6: f840 5033 str.w r5, [r0, r3, lsl #3]
ret[i].next_in_ino = NULL;
1075aa: f842 4033 str.w r4, [r2, r3, lsl #3]
for (i=0; i < REFS_PER_BLOCK; i++) {
1075ae: 3301 adds r3, #1
1075b0: 2b1e cmp r3, #30
1075b2: d1f8 bne.n 1075a6 <jffs2_prealloc_raw_node_refs+0x52>
ret[i].flash_offset = REF_LINK_NODE;
1075b4: f04f 33ff mov.w r3, #4294967295 ; 0xffffffff
1075b8: e9c2 433c strd r4, r3, [r2, #240] ; 0xf0
ref = *p = jffs2_alloc_refblock();
1075bc: f8c9 2000 str.w r2, [r9]
if (!ref)
1075c0: e7da b.n 107578 <jffs2_prealloc_raw_node_refs+0x24>
return -ENOMEM;
1075c2: f06f 000b mvn.w r0, #11 <== NOT EXECUTED
ref = *p = jffs2_alloc_refblock();
1075c6: f8c9 2000 str.w r2, [r9] <== NOT EXECUTED
if (!ref)
1075ca: e7df b.n 10758c <jffs2_prealloc_raw_node_refs+0x38> <== NOT EXECUTED
00108750 <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)
{
108750: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
108754: b087 sub sp, #28
108756: 4606 mov r6, r0
108758: 468a mov sl, r1
10875a: 4615 mov r5, r2
10875c: 4698 mov r8, r3
uint32_t crc;
unsigned char *decomprbuf = NULL;
unsigned char *readbuf = NULL;
int ret = 0;
ri = jffs2_alloc_raw_inode();
10875e: f7fe feed bl 10753c <jffs2_alloc_raw_inode>
if (!ri)
108762: 2800 cmp r0, #0
108764: f000 8116 beq.w 108994 <jffs2_read_dnode+0x244> <== ALWAYS TAKEN
return -ENOMEM;
ret = jffs2_flash_read(c, ref_offset(fd->raw), sizeof(*ri), &readlen, (char *)ri);
108768: 682b ldr r3, [r5, #0]
10876a: 4604 mov r4, r0
10876c: 2244 movs r2, #68 ; 0x44
10876e: 6859 ldr r1, [r3, #4]
108770: ab05 add r3, sp, #20
108772: 9000 str r0, [sp, #0]
108774: 4630 mov r0, r6
108776: f021 0103 bic.w r1, r1, #3
10877a: f003 f843 bl 10b804 <jffs2_flash_read>
if (ret) {
10877e: 4607 mov r7, r0
108780: 2800 cmp r0, #0
108782: d16a bne.n 10885a <jffs2_read_dnode+0x10a> <== ALWAYS 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)) {
108784: 9b05 ldr r3, [sp, #20]
108786: 2b44 cmp r3, #68 ; 0x44
108788: f040 80f2 bne.w 108970 <jffs2_read_dnode+0x220> <== ALWAYS 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);
10878c: 223c movs r2, #60 ; 0x3c
10878e: 4621 mov r1, r4
108790: f002 fa94 bl 10acbc <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)) {
108794: 6c21 ldr r1, [r4, #64] ; 0x40
crc = crc32(0, ri, sizeof(*ri)-8);
108796: 4602 mov r2, r0
if (crc != je32_to_cpu(ri->node_crc)) {
108798: 4281 cmp r1, r0
10879a: d151 bne.n 108840 <jffs2_read_dnode+0xf0> <== ALWAYS 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) &&
10879c: f894 3038 ldrb.w r3, [r4, #56] ; 0x38
1087a0: 2b01 cmp r3, #1
1087a2: d06d beq.n 108880 <jffs2_read_dnode+0x130>
je32_to_cpu(ri->csize)) {
1087a4: f8d4 9030 ldr.w r9, [r4, #48] ; 0x30
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)) {
1087a8: 2b00 cmp r3, #0
1087aa: d173 bne.n 108894 <jffs2_read_dnode+0x144>
1087ac: 6b63 ldr r3, [r4, #52] ; 0x34
1087ae: 9a11 ldr r2, [sp, #68] ; 0x44
1087b0: 4293 cmp r3, r2
1087b2: f000 8091 beq.w 1088d8 <jffs2_read_dnode+0x188>
readbuf = buf;
} else {
readbuf = kmalloc(je32_to_cpu(ri->csize), GFP_KERNEL);
1087b6: 4648 mov r0, r9
1087b8: f004 f9d2 bl 10cb60 <malloc>
if (!readbuf) {
1087bc: 4607 mov r7, r0
1087be: 4683 mov fp, r0
1087c0: 2800 cmp r0, #0
1087c2: f000 80f2 beq.w 1089aa <jffs2_read_dnode+0x25a> <== ALWAYS TAKEN
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),
1087c6: 6829 ldr r1, [r5, #0]
1087c8: 464a mov r2, r9
1087ca: ab05 add r3, sp, #20
1087cc: 4630 mov r0, r6
1087ce: 6849 ldr r1, [r1, #4]
1087d0: f8cd b000 str.w fp, [sp]
1087d4: f021 0103 bic.w r1, r1, #3
1087d8: 3144 adds r1, #68 ; 0x44
1087da: f003 f813 bl 10b804 <jffs2_flash_read>
je32_to_cpu(ri->csize), &readlen, readbuf);
if (!ret && readlen != je32_to_cpu(ri->csize))
1087de: 4681 mov r9, r0
1087e0: bb10 cbnz r0, 108828 <jffs2_read_dnode+0xd8>
1087e2: 6b22 ldr r2, [r4, #48] ; 0x30
1087e4: 9b05 ldr r3, [sp, #20]
1087e6: 429a cmp r2, r3
ret = -EIO;
1087e8: bf18 it ne
1087ea: f06f 0904 mvnne.w r9, #4
if (!ret && readlen != je32_to_cpu(ri->csize))
1087ee: d114 bne.n 10881a <jffs2_read_dnode+0xca> <== ALWAYS TAKEN
if (ret)
goto out_decomprbuf;
crc = crc32(0, readbuf, je32_to_cpu(ri->csize));
1087f0: 4659 mov r1, fp
1087f2: 2000 movs r0, #0
1087f4: f002 fa62 bl 10acbc <cyg_crc32_accumulate>
if (crc != je32_to_cpu(ri->data_crc)) {
1087f8: 6be1 ldr r1, [r4, #60] ; 0x3c
1087fa: 4281 cmp r1, r0
1087fc: f040 8094 bne.w 108928 <jffs2_read_dnode+0x1d8> <== ALWAYS 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) {
108800: f894 2038 ldrb.w r2, [r4, #56] ; 0x38
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));
108804: 6b63 ldr r3, [r4, #52] ; 0x34
if (ri->compr != JFFS2_COMPR_NONE) {
108806: 2a00 cmp r2, #0
108808: f040 809c bne.w 108944 <jffs2_read_dnode+0x1f4>
pr_warn("Error: jffs2_decompress returned %d\n", ret);
goto out_decomprbuf;
}
}
if (len < je32_to_cpu(ri->dsize)) {
10880c: 9a11 ldr r2, [sp, #68] ; 0x44
10880e: 429a cmp r2, r3
memcpy(buf, decomprbuf+ofs, len);
}
out_decomprbuf:
108810: bf28 it cs
108812: f04f 0900 movcs.w r9, #0
if (len < je32_to_cpu(ri->dsize)) {
108816: f0c0 80a3 bcc.w 108960 <jffs2_read_dnode+0x210>
if(decomprbuf != buf && decomprbuf != readbuf)
10881a: 45b8 cmp r8, r7
10881c: bf18 it ne
10881e: 45bb cmpne fp, r7
108820: d002 beq.n 108828 <jffs2_read_dnode+0xd8>
kfree(decomprbuf);
108822: 4638 mov r0, r7
108824: f004 f860 bl 10c8e8 <free>
out_readbuf:
if(readbuf != buf)
108828: 45d8 cmp r8, fp
10882a: d002 beq.n 108832 <jffs2_read_dnode+0xe2>
kfree(readbuf);
10882c: 4658 mov r0, fp
10882e: f004 f85b bl 10c8e8 <free>
out_ri:
jffs2_free_raw_inode(ri);
108832: 4620 mov r0, r4
108834: f7fe fe86 bl 107544 <jffs2_free_raw_inode>
return ret;
}
108838: 4648 mov r0, r9
10883a: b007 add sp, #28
10883c: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
pr_warn("Node CRC %08x != calculated CRC %08x for node at %08x\n",
108840: 682b ldr r3, [r5, #0] <== NOT EXECUTED
108842: f247 401c movw r0, #29724 ; 0x741c <== NOT EXECUTED
108846: f2c0 0011 movt r0, #17 <== NOT EXECUTED
ret = -EIO;
10884a: f06f 0904 mvn.w r9, #4 <== NOT EXECUTED
pr_warn("Node CRC %08x != calculated CRC %08x for node at %08x\n",
10884e: 685b ldr r3, [r3, #4] <== NOT EXECUTED
108850: f023 0303 bic.w r3, r3, #3 <== NOT EXECUTED
108854: f7ff ff6e bl 108734 <jffs2_printk> <== NOT EXECUTED
goto out_ri;
108858: e7eb b.n 108832 <jffs2_read_dnode+0xe2> <== NOT EXECUTED
jffs2_free_raw_inode(ri);
10885a: 4620 mov r0, r4 <== NOT EXECUTED
return ret;
10885c: 46b9 mov r9, r7 <== NOT EXECUTED
jffs2_free_raw_inode(ri);
10885e: f7fe fe71 bl 107544 <jffs2_free_raw_inode> <== NOT EXECUTED
pr_warn("Error reading node from 0x%08x: %d\n",
108862: 682b ldr r3, [r5, #0] <== NOT EXECUTED
108864: f247 30a8 movw r0, #29608 ; 0x73a8 <== NOT EXECUTED
108868: 463a mov r2, r7 <== NOT EXECUTED
10886a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10886e: 6859 ldr r1, [r3, #4] <== NOT EXECUTED
108870: f021 0103 bic.w r1, r1, #3 <== NOT EXECUTED
108874: f7ff ff5e bl 108734 <jffs2_printk> <== NOT EXECUTED
}
108878: 4648 mov r0, r9 <== NOT EXECUTED
10887a: b007 add sp, #28 <== NOT EXECUTED
10887c: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (ri->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(ri->dsize) &&
108880: 6b63 ldr r3, [r4, #52] ; 0x34
108882: 2b00 cmp r3, #0
108884: d043 beq.n 10890e <jffs2_read_dnode+0x1be> <== ALWAYS TAKEN
memset(buf, 0, len);
108886: 2100 movs r1, #0
108888: 9a11 ldr r2, [sp, #68] ; 0x44
10888a: 4640 mov r0, r8
ret = jffs2_flash_read(c, ref_offset(fd->raw), sizeof(*ri), &readlen, (char *)ri);
10888c: 4689 mov r9, r1
memset(buf, 0, len);
10888e: f00c fc67 bl 115160 <memset>
goto out_ri;
108892: e7ce b.n 108832 <jffs2_read_dnode+0xe2>
readbuf = kmalloc(je32_to_cpu(ri->csize), GFP_KERNEL);
108894: 4648 mov r0, r9
108896: f004 f963 bl 10cb60 <malloc>
if (!readbuf) {
10889a: 4683 mov fp, r0
10889c: 2800 cmp r0, #0
10889e: f000 8084 beq.w 1089aa <jffs2_read_dnode+0x25a> <== ALWAYS TAKEN
if (ri->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(ri->dsize) &&
1088a2: 6b60 ldr r0, [r4, #52] ; 0x34
if (len < je32_to_cpu(ri->dsize)) {
1088a4: 9b11 ldr r3, [sp, #68] ; 0x44
1088a6: 4283 cmp r3, r0
1088a8: bf28 it cs
1088aa: 4647 movcs r7, r8
1088ac: d28b bcs.n 1087c6 <jffs2_read_dnode+0x76>
decomprbuf = kmalloc(je32_to_cpu(ri->dsize), GFP_KERNEL);
1088ae: f004 f957 bl 10cb60 <malloc>
if (!decomprbuf) {
1088b2: 4607 mov r7, r0
1088b4: 2800 cmp r0, #0
1088b6: d07b beq.n 1089b0 <jffs2_read_dnode+0x260> <== ALWAYS TAKEN
ret = jffs2_flash_read(c, (ref_offset(fd->raw)) + sizeof(*ri),
1088b8: 6829 ldr r1, [r5, #0]
1088ba: 464a mov r2, r9
1088bc: ab05 add r3, sp, #20
1088be: 4630 mov r0, r6
1088c0: 6849 ldr r1, [r1, #4]
1088c2: f8cd b000 str.w fp, [sp]
1088c6: f021 0103 bic.w r1, r1, #3
1088ca: 3144 adds r1, #68 ; 0x44
1088cc: f002 ff9a bl 10b804 <jffs2_flash_read>
if (!ret && readlen != je32_to_cpu(ri->csize))
1088d0: 4681 mov r9, r0
1088d2: 2800 cmp r0, #0
1088d4: d1a1 bne.n 10881a <jffs2_read_dnode+0xca> <== ALWAYS TAKEN
1088d6: e784 b.n 1087e2 <jffs2_read_dnode+0x92>
ret = jffs2_flash_read(c, (ref_offset(fd->raw)) + sizeof(*ri),
1088d8: 6829 ldr r1, [r5, #0]
1088da: 464a mov r2, r9
1088dc: ab05 add r3, sp, #20
1088de: 4630 mov r0, r6
1088e0: 6849 ldr r1, [r1, #4]
1088e2: f8cd 8000 str.w r8, [sp]
1088e6: f021 0103 bic.w r1, r1, #3
1088ea: 3144 adds r1, #68 ; 0x44
1088ec: f002 ff8a bl 10b804 <jffs2_flash_read>
if (!ret && readlen != je32_to_cpu(ri->csize))
1088f0: 4681 mov r9, r0
1088f2: 2800 cmp r0, #0
1088f4: d19d bne.n 108832 <jffs2_read_dnode+0xe2> <== ALWAYS TAKEN
1088f6: 6b22 ldr r2, [r4, #48] ; 0x30
1088f8: 9b05 ldr r3, [sp, #20]
1088fa: 429a cmp r2, r3
1088fc: bf04 itt eq
1088fe: 4647 moveq r7, r8
108900: 46c3 moveq fp, r8
108902: f43f af75 beq.w 1087f0 <jffs2_read_dnode+0xa0> <== NEVER TAKEN
108906: 46c3 mov fp, r8 <== NOT EXECUTED
ret = -EIO;
108908: f06f 0904 mvn.w r9, #4 <== NOT EXECUTED
10890c: e78c b.n 108828 <jffs2_read_dnode+0xd8> <== NOT EXECUTED
je32_to_cpu(ri->csize)) {
10890e: 6b22 ldr r2, [r4, #48] ; 0x30 <== NOT EXECUTED
if (ri->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(ri->dsize) &&
108910: 2a00 cmp r2, #0 <== NOT EXECUTED
108912: d0b8 beq.n 108886 <jffs2_read_dnode+0x136> <== NOT EXECUTED
ri->dsize = ri->csize;
108914: 6362 str r2, [r4, #52] ; 0x34 <== NOT EXECUTED
ri->csize = cpu_to_je32(0);
108916: f884 3030 strb.w r3, [r4, #48] ; 0x30 <== NOT EXECUTED
10891a: f884 3031 strb.w r3, [r4, #49] ; 0x31 <== NOT EXECUTED
10891e: f884 3032 strb.w r3, [r4, #50] ; 0x32 <== NOT EXECUTED
108922: f884 3033 strb.w r3, [r4, #51] ; 0x33 <== NOT EXECUTED
108926: e7ae b.n 108886 <jffs2_read_dnode+0x136> <== NOT EXECUTED
pr_warn("Data CRC %08x != calculated CRC %08x for node at %08x\n",
108928: 682b ldr r3, [r5, #0] <== NOT EXECUTED
10892a: 4602 mov r2, r0 <== NOT EXECUTED
10892c: f247 4060 movw r0, #29792 ; 0x7460 <== NOT EXECUTED
ret = -EIO;
108930: f06f 0904 mvn.w r9, #4 <== NOT EXECUTED
pr_warn("Data CRC %08x != calculated CRC %08x for node at %08x\n",
108934: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108938: 685b ldr r3, [r3, #4] <== NOT EXECUTED
10893a: f023 0303 bic.w r3, r3, #3 <== NOT EXECUTED
10893e: f7ff fef9 bl 108734 <jffs2_printk> <== NOT EXECUTED
goto out_decomprbuf;
108942: e76a b.n 10881a <jffs2_read_dnode+0xca> <== NOT EXECUTED
ret = jffs2_decompress(c, f, ri->compr | (ri->usercompr << 8), readbuf, decomprbuf, je32_to_cpu(ri->csize), je32_to_cpu(ri->dsize));
108944: 8f22 ldrh r2, [r4, #56] ; 0x38
108946: 4651 mov r1, sl
108948: 9302 str r3, [sp, #8]
10894a: 4630 mov r0, r6
10894c: 6b23 ldr r3, [r4, #48] ; 0x30
10894e: e9cd 7300 strd r7, r3, [sp]
108952: 465b mov r3, fp
108954: f002 f9e2 bl 10ad1c <jffs2_decompress>
if (ret) {
108958: 4681 mov r9, r0
10895a: b9f0 cbnz r0, 10899a <jffs2_read_dnode+0x24a>
if (len < je32_to_cpu(ri->dsize)) {
10895c: 6b63 ldr r3, [r4, #52] ; 0x34
10895e: e755 b.n 10880c <jffs2_read_dnode+0xbc>
memcpy(buf, decomprbuf+ofs, len);
108960: 9b10 ldr r3, [sp, #64] ; 0x40
108962: 4640 mov r0, r8
108964: f04f 0900 mov.w r9, #0
108968: 18f9 adds r1, r7, r3
10896a: f00c e98a blx 114c80 <memcpy>
10896e: e754 b.n 10881a <jffs2_read_dnode+0xca>
jffs2_free_raw_inode(ri);
108970: 4620 mov r0, r4 <== NOT EXECUTED
return -EIO;
108972: f06f 0904 mvn.w r9, #4 <== NOT EXECUTED
jffs2_free_raw_inode(ri);
108976: f7fe fde5 bl 107544 <jffs2_free_raw_inode> <== NOT EXECUTED
pr_warn("Short read from 0x%08x: wanted 0x%zx bytes, got 0x%zx\n",
10897a: 6829 ldr r1, [r5, #0] <== NOT EXECUTED
10897c: f247 30d8 movw r0, #29656 ; 0x73d8 <== NOT EXECUTED
108980: 9b05 ldr r3, [sp, #20] <== NOT EXECUTED
108982: 2244 movs r2, #68 ; 0x44 <== NOT EXECUTED
108984: f2c0 0011 movt r0, #17 <== NOT EXECUTED
108988: 6849 ldr r1, [r1, #4] <== NOT EXECUTED
10898a: f021 0103 bic.w r1, r1, #3 <== NOT EXECUTED
10898e: f7ff fed1 bl 108734 <jffs2_printk> <== NOT EXECUTED
return -EIO;
108992: e751 b.n 108838 <jffs2_read_dnode+0xe8> <== NOT EXECUTED
return -ENOMEM;
108994: f06f 090b mvn.w r9, #11 <== NOT EXECUTED
108998: e74e b.n 108838 <jffs2_read_dnode+0xe8> <== NOT EXECUTED
pr_warn("Error: jffs2_decompress returned %d\n", ret);
10899a: f247 40a4 movw r0, #29860 ; 0x74a4 <== NOT EXECUTED
10899e: 4649 mov r1, r9 <== NOT EXECUTED
1089a0: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1089a4: f7ff fec6 bl 108734 <jffs2_printk> <== NOT EXECUTED
goto out_decomprbuf;
1089a8: e737 b.n 10881a <jffs2_read_dnode+0xca> <== NOT EXECUTED
ret = -ENOMEM;
1089aa: f06f 090b mvn.w r9, #11 <== NOT EXECUTED
1089ae: e740 b.n 108832 <jffs2_read_dnode+0xe2> <== NOT EXECUTED
ret = -ENOMEM;
1089b0: f06f 090b mvn.w r9, #11 <== NOT EXECUTED
1089b4: e738 b.n 108828 <jffs2_read_dnode+0xd8> <== NOT EXECUTED
1089b6: bf00 nop
001089b8 <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)
{
1089b8: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
1089bc: b083 sub sp, #12
1089be: 9c0c ldr r4, [sp, #48] ; 0x30
1089c0: 4688 mov r8, r1
1089c2: 461d mov r5, r3
1089c4: 4681 mov r9, r0
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);
1089c6: 4619 mov r1, r3
1089c8: f108 0004 add.w r0, r8, #4
uint32_t end = offset + len;
1089cc: eb03 0a04 add.w sl, r3, r4
{
1089d0: 4617 mov r7, r2
frag = jffs2_lookup_node_frag(&f->fragtree, offset);
1089d2: f7ff f959 bl 107c88 <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) {
1089d6: 4555 cmp r5, sl
1089d8: bf38 it cc
1089da: 4606 movcc r6, r0
1089dc: d225 bcs.n 108a2a <jffs2_read_inode_range+0x72> <== ALWAYS TAKEN
jffs2_dbg(2, "%s(): offset %d, end %d\n",
__func__, offset, end);
if (unlikely(!frag || frag->ofs > offset ||
1089de: b356 cbz r6, 108a36 <jffs2_read_inode_range+0x7e>
1089e0: 69b4 ldr r4, [r6, #24]
1089e2: 42ac cmp r4, r5
1089e4: d830 bhi.n 108a48 <jffs2_read_inode_range+0x90> <== ALWAYS TAKEN
1089e6: 6972 ldr r2, [r6, #20]
1089e8: 4414 add r4, r2
1089ea: 42ac cmp r4, r5
1089ec: d923 bls.n 108a36 <jffs2_read_inode_range+0x7e> <== ALWAYS TAKEN
offset, offset + holesize);
memset(buf, 0, holesize);
buf += holesize;
offset += holesize;
continue;
} else if (unlikely(!frag->node)) {
1089ee: 6932 ldr r2, [r6, #16]
1089f0: b392 cbz r2, 108a58 <jffs2_read_inode_range+0xa0>
} 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);
1089f2: 1b64 subs r4, r4, r5
1089f4: ebaa 0305 sub.w r3, sl, r5
1089f8: 429c cmp r4, r3
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);
1089fa: 4641 mov r1, r8
readlen = min(frag->size - fragofs, end - offset);
1089fc: bf28 it cs
1089fe: 461c movcs r4, r3
ret = jffs2_read_dnode(c, f, frag->node, buf, fragofs + frag->ofs - frag->node->ofs, readlen);
108a00: 4648 mov r0, r9
108a02: 9401 str r4, [sp, #4]
108a04: 463b mov r3, r7
108a06: f8d2 c004 ldr.w ip, [r2, #4]
108a0a: eba5 0c0c sub.w ip, r5, ip
108a0e: f8cd c000 str.w ip, [sp]
108a12: f7ff fe9d bl 108750 <jffs2_read_dnode>
jffs2_dbg(2, "node read done\n");
if (ret) {
108a16: 4683 mov fp, r0
108a18: bb78 cbnz r0, 108a7a <jffs2_read_inode_range+0xc2>
return _RBTree_Successor( node );
108a1a: 4630 mov r0, r6
jffs2_dbg(1, "%s(): error %d\n",
__func__, ret);
memset(buf, 0, readlen);
return ret;
}
buf += readlen;
108a1c: 4427 add r7, r4
108a1e: f008 f9a1 bl 110d64 <_RBTree_Successor>
offset += readlen;
108a22: 4425 add r5, r4
108a24: 4606 mov r6, r0
while(offset < end) {
108a26: 4555 cmp r5, sl
108a28: d3d9 bcc.n 1089de <jffs2_read_inode_range+0x26>
frag = frag_next(frag);
jffs2_dbg(2, "node read was OK. Looping\n");
}
}
return 0;
108a2a: f04f 0b00 mov.w fp, #0
}
108a2e: 4658 mov r0, fp
108a30: b003 add sp, #12
108a32: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
uint32_t holesize = end - offset;
108a36: ebaa 0205 sub.w r2, sl, r5
108a3a: 4655 mov r5, sl
memset(buf, 0, holesize);
108a3c: 4638 mov r0, r7
108a3e: 2100 movs r1, #0
buf += holesize;
108a40: 4417 add r7, r2
memset(buf, 0, holesize);
108a42: f00c fb8d bl 115160 <memset>
continue;
108a46: e7ee b.n 108a26 <jffs2_read_inode_range+0x6e>
uint32_t holesize = end - offset;
108a48: ebaa 0305 sub.w r3, sl, r5 <== NOT EXECUTED
holesize = min(holesize, frag->ofs - offset);
108a4c: 1b62 subs r2, r4, r5 <== NOT EXECUTED
108a4e: 429a cmp r2, r3 <== NOT EXECUTED
108a50: bf28 it cs <== NOT EXECUTED
108a52: 461a movcs r2, r3 <== NOT EXECUTED
offset += holesize;
108a54: 4415 add r5, r2 <== NOT EXECUTED
108a56: e7f1 b.n 108a3c <jffs2_read_inode_range+0x84> <== NOT EXECUTED
uint32_t holeend = min(end, frag->ofs + frag->size);
108a58: 4554 cmp r4, sl <== NOT EXECUTED
memset(buf, 0, holeend - offset);
108a5a: 4611 mov r1, r2 <== NOT EXECUTED
uint32_t holeend = min(end, frag->ofs + frag->size);
108a5c: bf28 it cs <== NOT EXECUTED
108a5e: 4654 movcs r4, sl <== NOT EXECUTED
memset(buf, 0, holeend - offset);
108a60: 4638 mov r0, r7 <== NOT EXECUTED
108a62: eba4 0b05 sub.w fp, r4, r5 <== NOT EXECUTED
offset = holeend;
108a66: 4625 mov r5, r4 <== NOT EXECUTED
memset(buf, 0, holeend - offset);
108a68: 465a mov r2, fp <== NOT EXECUTED
buf += holeend - offset;
108a6a: 445f add r7, fp <== NOT EXECUTED
memset(buf, 0, holeend - offset);
108a6c: f00c fb78 bl 115160 <memset> <== NOT EXECUTED
108a70: 4630 mov r0, r6 <== NOT EXECUTED
108a72: f008 f977 bl 110d64 <_RBTree_Successor> <== NOT EXECUTED
108a76: 4606 mov r6, r0 <== NOT EXECUTED
continue;
108a78: e7d5 b.n 108a26 <jffs2_read_inode_range+0x6e> <== NOT EXECUTED
memset(buf, 0, readlen);
108a7a: 4622 mov r2, r4 <== NOT EXECUTED
108a7c: 2100 movs r1, #0 <== NOT EXECUTED
108a7e: 4638 mov r0, r7 <== NOT EXECUTED
108a80: f00c fb6e bl 115160 <memset> <== NOT EXECUTED
}
108a84: 4658 mov r0, fp <== NOT EXECUTED
108a86: b003 add sp, #12 <== NOT EXECUTED
108a88: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0010b2e4 <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)
{
10b2e4: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
10b2e8: 461f mov r7, r3 <== NOT EXECUTED
*/
/* Make a hard link */
/* XXX: This is ugly */
type = (d_inode->i_mode & S_IFMT) >> 12;
10b2ea: 688b ldr r3, [r1, #8] <== NOT EXECUTED
{
10b2ec: b086 sub sp, #24 <== NOT EXECUTED
10b2ee: 4605 mov r5, r0 <== NOT EXECUTED
10b2f0: 460c mov r4, r1 <== NOT EXECUTED
struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb);
10b2f2: f8d0 8040 ldr.w r8, [r0, #64] ; 0x40 <== NOT EXECUTED
if (!type) type = DT_REG;
now = get_seconds();
10b2f6: 2000 movs r0, #0 <== NOT EXECUTED
type = (d_inode->i_mode & S_IFMT) >> 12;
10b2f8: f3c3 3a03 ubfx sl, r3, #12, #4 <== NOT EXECUTED
{
10b2fc: 4616 mov r6, r2 <== NOT EXECUTED
if (!type) type = DT_REG;
10b2fe: f1ba 0f00 cmp.w sl, #0 <== NOT EXECUTED
10b302: bf08 it eq <== NOT EXECUTED
10b304: f04f 0a08 moveq.w sl, #8 <== NOT EXECUTED
now = get_seconds();
10b308: f00a fab6 bl 115878 <time> <== NOT EXECUTED
ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i),
10b30c: 9b10 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED
now = get_seconds();
10b30e: 4681 mov r9, r0 <== NOT EXECUTED
ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i),
10b310: 9a0e ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED
10b312: 4640 mov r0, r8 <== NOT EXECUTED
10b314: f8cd 9008 str.w r9, [sp, #8] <== NOT EXECUTED
10b318: 9301 str r3, [sp, #4] <== NOT EXECUTED
10b31a: 9b0f ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED
10b31c: f102 0148 add.w r1, r2, #72 ; 0x48 <== NOT EXECUTED
10b320: 9300 str r3, [sp, #0] <== NOT EXECUTED
10b322: 4653 mov r3, sl <== NOT EXECUTED
10b324: 6822 ldr r2, [r4, #0] <== NOT EXECUTED
10b326: f7ff f9ef bl 10a708 <jffs2_do_link> <== NOT EXECUTED
d_inode->i_ino, type,
(const char *)new_d_name,
new_d_namelen, now);
if (ret)
10b32a: 4601 mov r1, r0 <== NOT EXECUTED
10b32c: b118 cbz r0, 10b336 <jffs2_rename+0x52> <== 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;
}
10b32e: 4608 mov r0, r1 <== NOT EXECUTED
10b330: b006 add sp, #24 <== NOT EXECUTED
10b332: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
ret = jffs2_do_unlink(c, JFFS2_INODE_INFO(old_dir_i),
10b336: f105 0148 add.w r1, r5, #72 ; 0x48 <== NOT EXECUTED
10b33a: e9cd 0900 strd r0, r9, [sp] <== NOT EXECUTED
10b33e: 463b mov r3, r7 <== NOT EXECUTED
10b340: 4632 mov r2, r6 <== NOT EXECUTED
10b342: 4640 mov r0, r8 <== NOT EXECUTED
10b344: f7ff f97a bl 10a63c <jffs2_do_unlink> <== NOT EXECUTED
if (ret) {
10b348: 4601 mov r1, r0 <== NOT EXECUTED
10b34a: 2800 cmp r0, #0 <== NOT EXECUTED
10b34c: d0ef beq.n 10b32e <jffs2_rename+0x4a> <== NOT EXECUTED
if (f->inocache)
10b34e: 6de3 ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED
10b350: b11b cbz r3, 10b35a <jffs2_rename+0x76> <== NOT EXECUTED
d_inode->i_nlink = f->inocache->pino_nlink++;
10b352: 695a ldr r2, [r3, #20] <== NOT EXECUTED
10b354: 1c50 adds r0, r2, #1 <== NOT EXECUTED
10b356: 6158 str r0, [r3, #20] <== NOT EXECUTED
10b358: 81a2 strh r2, [r4, #12] <== NOT EXECUTED
printk(KERN_NOTICE "jffs2_rename(): Link succeeded, unlink failed (err %d). You now have a hard link\n", ret);
10b35a: f648 1054 movw r0, #35156 ; 0x8954 <== NOT EXECUTED
10b35e: 9105 str r1, [sp, #20] <== NOT EXECUTED
10b360: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10b364: f7ff fd96 bl 10ae94 <jffs2_printk> <== NOT EXECUTED
10b368: 9905 ldr r1, [sp, #20] <== NOT EXECUTED
}
10b36a: 4608 mov r0, r1 <== NOT EXECUTED
10b36c: b006 add sp, #24 <== NOT EXECUTED
10b36e: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
10b372: bf00 nop
001085d4 <jffs2_reserve_space>:
if (prio != ALLOC_DELETION && !jffs2_rp_can_write(c)) {
1085d4: 2b01 cmp r3, #1
{
1085d6: e92d 43f8 stmdb sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
1085da: 4680 mov r8, r0
c->erasing_size - c->resv_blocks_write * c->sector_size
1085dc: f890 4044 ldrb.w r4, [r0, #68] ; 0x44
{
1085e0: 461f mov r7, r3
1085e2: 4616 mov r6, r2
if (prio != ALLOC_DELETION && !jffs2_rp_can_write(c)) {
1085e4: d013 beq.n 10860e <jffs2_reserve_space+0x3a> <== ALWAYS TAKEN
avail = c->dirty_size + c->free_size + c->unchecked_size +
1085e6: 6a82 ldr r2, [r0, #40] ; 0x28
1085e8: 6a03 ldr r3, [r0, #32]
1085ea: 4413 add r3, r2
1085ec: 6b82 ldr r2, [r0, #56] ; 0x38
1085ee: 4413 add r3, r2
1085f0: 6ac2 ldr r2, [r0, #44] ; 0x2c
1085f2: 4413 add r3, r2
1085f4: 6cc2 ldr r2, [r0, #76] ; 0x4c
1085f6: 1a9b subs r3, r3, r2
c->erasing_size - c->resv_blocks_write * c->sector_size
1085f8: 6b42 ldr r2, [r0, #52] ; 0x34
avail = c->dirty_size + c->free_size + c->unchecked_size +
1085fa: fb02 3314 mls r3, r2, r4, r3
if (avail > opts->rp_size)
1085fe: f8d0 20d8 ldr.w r2, [r0, #216] ; 0xd8
108602: 4293 cmp r3, r2
108604: d803 bhi.n 10860e <jffs2_reserve_space+0x3a> <== NEVER TAKEN
ret = -ENOSPC;
108606: f06f 001b mvn.w r0, #27
}
10860a: e8bd 83f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, pc}
minsize = PAD(minsize);
10860e: 1ccd adds r5, r1, #3
108610: f025 0503 bic.w r5, r5, #3
108614: e01f b.n 108656 <jffs2_reserve_space+0x82>
108616: f8d8 202c ldr.w r2, [r8, #44] ; 0x2c
10861a: f8d8 0020 ldr.w r0, [r8, #32]
dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size + c->unchecked_size;
10861e: f8d8 1034 ldr.w r1, [r8, #52] ; 0x34
108622: 4410 add r0, r2
108624: f8d8 2038 ldr.w r2, [r8, #56] ; 0x38
108628: 4410 add r0, r2
if (dirty < c->nospc_dirty_size) {
10862a: f8d8 204c ldr.w r2, [r8, #76] ; 0x4c
dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size + c->unchecked_size;
10862e: fb03 0311 mls r3, r3, r1, r0
if (dirty < c->nospc_dirty_size) {
108632: 429a cmp r2, r3
108634: d827 bhi.n 108686 <jffs2_reserve_space+0xb2>
avail = c->free_size + c->dirty_size + c->erasing_size + c->unchecked_size;
108636: f8d8 3028 ldr.w r3, [r8, #40] ; 0x28
if ( (avail / c->sector_size) <= blocksneeded) {
10863a: 4418 add r0, r3
10863c: f00b ff90 bl 114560 <__udivsi3>
108640: 4603 mov r3, r0
ret = jffs2_garbage_collect_pass(c);
108642: 4640 mov r0, r8
if ( (avail / c->sector_size) <= blocksneeded) {
108644: 42a3 cmp r3, r4
108646: d91e bls.n 108686 <jffs2_reserve_space+0xb2> <== ALWAYS TAKEN
ret = jffs2_garbage_collect_pass(c);
108648: f7fe f846 bl 1066d8 <jffs2_garbage_collect_pass>
} else if (ret)
10864c: 2800 cmp r0, #0
10864e: bf18 it ne
108650: f110 0f0b cmnne.w r0, #11
108654: d1d9 bne.n 10860a <jffs2_reserve_space+0x36> <== ALWAYS TAKEN
while(c->nr_free_blocks + c->nr_erasing_blocks < blocksneeded) {
108656: e9d8 230f ldrd r2, r3, [r8, #60] ; 0x3c
10865a: eb03 0902 add.w r9, r3, r2
10865e: 45a1 cmp r9, r4
108660: d3d9 bcc.n 108616 <jffs2_reserve_space+0x42>
ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
108662: 4632 mov r2, r6
108664: 4629 mov r1, r5
108666: 4640 mov r0, r8
108668: f7ff fe90 bl 10838c <jffs2_do_reserve_space.constprop.0>
while(ret == -EAGAIN) {
10866c: f110 0f0b cmn.w r0, #11
108670: d0f1 beq.n 108656 <jffs2_reserve_space+0x82> <== ALWAYS TAKEN
if (!ret)
108672: 2800 cmp r0, #0
108674: d1c9 bne.n 10860a <jffs2_reserve_space+0x36> <== ALWAYS TAKEN
ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
108676: f8d8 1058 ldr.w r1, [r8, #88] ; 0x58
10867a: 4640 mov r0, r8
10867c: 2201 movs r2, #1
}
10867e: e8bd 43f8 ldmia.w sp!, {r3, r4, r5, r6, r7, r8, r9, lr}
ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
108682: f7fe bf67 b.w 107554 <jffs2_prealloc_raw_node_refs>
if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) {
108686: 2f01 cmp r7, #1
108688: d1bd bne.n 108606 <jffs2_reserve_space+0x32> <== NEVER TAKEN
10868a: f898 3045 ldrb.w r3, [r8, #69] ; 0x45 <== NOT EXECUTED
10868e: 454b cmp r3, r9 <== NOT EXECUTED
108690: d8b9 bhi.n 108606 <jffs2_reserve_space+0x32> <== NOT EXECUTED
ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
108692: 4632 mov r2, r6 <== NOT EXECUTED
108694: 4629 mov r1, r5 <== NOT EXECUTED
108696: 4640 mov r0, r8 <== NOT EXECUTED
108698: f7ff fe78 bl 10838c <jffs2_do_reserve_space.constprop.0> <== NOT EXECUTED
while(ret == -EAGAIN) {
10869c: f110 0f0b cmn.w r0, #11 <== NOT EXECUTED
1086a0: d0d9 beq.n 108656 <jffs2_reserve_space+0x82> <== NOT EXECUTED
1086a2: e7e6 b.n 108672 <jffs2_reserve_space+0x9e> <== NOT EXECUTED
001085a4 <jffs2_reserve_space_gc>:
minsize = PAD(minsize);
1085a4: 3103 adds r1, #3
{
1085a6: b570 push {r4, r5, r6, lr}
1085a8: 4605 mov r5, r0
1085aa: 4616 mov r6, r2
minsize = PAD(minsize);
1085ac: f021 0403 bic.w r4, r1, #3
ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
1085b0: 4632 mov r2, r6
1085b2: 4621 mov r1, r4
1085b4: 4628 mov r0, r5
1085b6: f7ff fee9 bl 10838c <jffs2_do_reserve_space.constprop.0>
if (ret == -EAGAIN)
1085ba: f110 0f0b cmn.w r0, #11
1085be: d0f7 beq.n 1085b0 <jffs2_reserve_space_gc+0xc> <== ALWAYS TAKEN
if (!ret)
1085c0: b100 cbz r0, 1085c4 <jffs2_reserve_space_gc+0x20>
}
1085c2: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
1085c4: 6da9 ldr r1, [r5, #88] ; 0x58
1085c6: 4628 mov r0, r5
1085c8: 2201 movs r2, #1
}
1085ca: e8bd 4070 ldmia.w sp!, {r4, r5, r6, lr}
ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
1085ce: f7fe bfc1 b.w 107554 <jffs2_prealloc_raw_node_refs>
1085d2: bf00 nop
0010b28c <jffs2_rmdir>:
int jffs2_rmdir (struct _inode *dir_i, struct _inode *d_inode, const unsigned char *d_name, size_t d_namelen)
{
10b28c: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
10b290: 460d mov r5, r1
struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode);
struct jffs2_full_dirent *fd;
for (fd = f->dents ; fd; fd = fd->next) {
10b292: 6d4c ldr r4, [r1, #84] ; 0x54
{
10b294: b082 sub sp, #8
10b296: 4606 mov r6, r0
10b298: 4617 mov r7, r2
10b29a: 4698 mov r8, r3
for (fd = f->dents ; fd; fd = fd->next) {
10b29c: b914 cbnz r4, 10b2a4 <jffs2_rmdir+0x18>
10b29e: e009 b.n 10b2b4 <jffs2_rmdir+0x28>
10b2a0: 6864 ldr r4, [r4, #4] <== NOT EXECUTED
10b2a2: b13c cbz r4, 10b2b4 <jffs2_rmdir+0x28> <== NOT EXECUTED
if (fd->ino)
10b2a4: 68e3 ldr r3, [r4, #12]
10b2a6: 2b00 cmp r3, #0
10b2a8: d0fa beq.n 10b2a0 <jffs2_rmdir+0x14> <== ALWAYS TAKEN
return -ENOTEMPTY;
10b2aa: f06f 0059 mvn.w r0, #89 ; 0x59
}
return jffs2_unlink(dir_i, d_inode, d_name, d_namelen);
}
10b2ae: b002 add sp, #8
10b2b0: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
10b2b4: 6c34 ldr r4, [r6, #64] ; 0x40
d_namelen, dead_f, get_seconds());
10b2b6: 2000 movs r0, #0
10b2b8: f00a fade bl 115878 <time>
ret = jffs2_do_unlink(c, dir_f, (const char *)d_name,
10b2bc: 9001 str r0, [sp, #4]
10b2be: 4643 mov r3, r8
10b2c0: 4620 mov r0, r4
struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(d_inode);
10b2c2: f105 0448 add.w r4, r5, #72 ; 0x48
ret = jffs2_do_unlink(c, dir_f, (const char *)d_name,
10b2c6: 463a mov r2, r7
10b2c8: f106 0148 add.w r1, r6, #72 ; 0x48
10b2cc: 9400 str r4, [sp, #0]
10b2ce: f7ff f9b5 bl 10a63c <jffs2_do_unlink>
if (dead_f->inocache)
10b2d2: 6deb ldr r3, [r5, #92] ; 0x5c
10b2d4: 2b00 cmp r3, #0
10b2d6: d0ea beq.n 10b2ae <jffs2_rmdir+0x22> <== ALWAYS TAKEN
d_inode->i_nlink = dead_f->inocache->pino_nlink;
10b2d8: 695b ldr r3, [r3, #20]
10b2da: 81ab strh r3, [r5, #12]
}
10b2dc: b002 add sp, #8
10b2de: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
10b2e2: bf00 nop
0010c430 <jffs2_rotate_lists>:
}
list_add(head, n);
}
void jffs2_rotate_lists(struct jffs2_sb_info *c)
{
10c430: b570 push {r4, r5, r6, lr}
uint32_t x;
uint32_t rotateby;
x = count_list(&c->clean_list);
10c432: f100 0360 add.w r3, r0, #96 ; 0x60
list_for_each(tmp, l) {
10c436: 6e06 ldr r6, [r0, #96] ; 0x60
{
10c438: 4605 mov r5, r0
list_for_each(tmp, l) {
10c43a: 42b3 cmp r3, r6
10c43c: d008 beq.n 10c450 <jffs2_rotate_lists+0x20> <== NEVER TAKEN
10c43e: 4634 mov r4, r6 <== NOT EXECUTED
uint32_t count = 0;
10c440: 2100 movs r1, #0 <== NOT EXECUTED
list_for_each(tmp, l) {
10c442: 6824 ldr r4, [r4, #0] <== NOT EXECUTED
count++;
10c444: 3101 adds r1, #1 <== NOT EXECUTED
list_for_each(tmp, l) {
10c446: 42a3 cmp r3, r4 <== NOT EXECUTED
10c448: d1fb bne.n 10c442 <jffs2_rotate_lists+0x12> <== NOT EXECUTED
if (x) {
10c44a: 2900 cmp r1, #0 <== NOT EXECUTED
10c44c: f040 80a0 bne.w 10c590 <jffs2_rotate_lists+0x160> <== NOT EXECUTED
list_for_each(tmp, l) {
10c450: 6eae ldr r6, [r5, #104] ; 0x68
rotateby = pseudo_random % x;
rotate_list((&c->clean_list), rotateby);
}
x = count_list(&c->very_dirty_list);
10c452: f105 0368 add.w r3, r5, #104 ; 0x68
list_for_each(tmp, l) {
10c456: 42b3 cmp r3, r6
10c458: d007 beq.n 10c46a <jffs2_rotate_lists+0x3a> <== NEVER TAKEN
10c45a: 4634 mov r4, r6 <== NOT EXECUTED
uint32_t count = 0;
10c45c: 2100 movs r1, #0 <== NOT EXECUTED
list_for_each(tmp, l) {
10c45e: 6824 ldr r4, [r4, #0] <== NOT EXECUTED
count++;
10c460: 3101 adds r1, #1 <== NOT EXECUTED
list_for_each(tmp, l) {
10c462: 42a3 cmp r3, r4 <== NOT EXECUTED
10c464: d1fb bne.n 10c45e <jffs2_rotate_lists+0x2e> <== NOT EXECUTED
if (x) {
10c466: 2900 cmp r1, #0 <== NOT EXECUTED
10c468: d17c bne.n 10c564 <jffs2_rotate_lists+0x134> <== NOT EXECUTED
list_for_each(tmp, l) {
10c46a: 6f2e ldr r6, [r5, #112] ; 0x70
rotateby = pseudo_random % x;
rotate_list((&c->very_dirty_list), rotateby);
}
x = count_list(&c->dirty_list);
10c46c: f105 0370 add.w r3, r5, #112 ; 0x70
list_for_each(tmp, l) {
10c470: 42b3 cmp r3, r6
10c472: d007 beq.n 10c484 <jffs2_rotate_lists+0x54> <== NEVER TAKEN
10c474: 4634 mov r4, r6 <== NOT EXECUTED
uint32_t count = 0;
10c476: 2100 movs r1, #0 <== NOT EXECUTED
list_for_each(tmp, l) {
10c478: 6824 ldr r4, [r4, #0] <== NOT EXECUTED
count++;
10c47a: 3101 adds r1, #1 <== NOT EXECUTED
list_for_each(tmp, l) {
10c47c: 42a3 cmp r3, r4 <== NOT EXECUTED
10c47e: d1fb bne.n 10c478 <jffs2_rotate_lists+0x48> <== NOT EXECUTED
if (x) {
10c480: 2900 cmp r1, #0 <== NOT EXECUTED
10c482: d159 bne.n 10c538 <jffs2_rotate_lists+0x108> <== NOT EXECUTED
list_for_each(tmp, l) {
10c484: 6fae ldr r6, [r5, #120] ; 0x78
rotateby = pseudo_random % x;
rotate_list((&c->dirty_list), rotateby);
}
x = count_list(&c->erasable_list);
10c486: f105 0378 add.w r3, r5, #120 ; 0x78
list_for_each(tmp, l) {
10c48a: 42b3 cmp r3, r6
10c48c: d007 beq.n 10c49e <jffs2_rotate_lists+0x6e> <== NEVER TAKEN
10c48e: 4634 mov r4, r6 <== NOT EXECUTED
uint32_t count = 0;
10c490: 2100 movs r1, #0 <== NOT EXECUTED
list_for_each(tmp, l) {
10c492: 6824 ldr r4, [r4, #0] <== NOT EXECUTED
count++;
10c494: 3101 adds r1, #1 <== NOT EXECUTED
list_for_each(tmp, l) {
10c496: 42a3 cmp r3, r4 <== NOT EXECUTED
10c498: d1fb bne.n 10c492 <jffs2_rotate_lists+0x62> <== NOT EXECUTED
if (x) {
10c49a: 2900 cmp r1, #0 <== NOT EXECUTED
10c49c: d136 bne.n 10c50c <jffs2_rotate_lists+0xdc> <== NOT EXECUTED
rotateby = pseudo_random % x;
rotate_list((&c->erasable_list), rotateby);
}
if (c->nr_erasing_blocks) {
10c49e: 6c29 ldr r1, [r5, #64] ; 0x40
10c4a0: b9d9 cbnz r1, 10c4da <jffs2_rotate_lists+0xaa>
rotateby = pseudo_random % c->nr_erasing_blocks;
rotate_list((&c->erase_pending_list), rotateby);
}
if (c->nr_free_blocks) {
10c4a2: 6be9 ldr r1, [r5, #60] ; 0x3c
10c4a4: b901 cbnz r1, 10c4a8 <jffs2_rotate_lists+0x78>
rotateby = pseudo_random % c->nr_free_blocks;
rotate_list((&c->free_list), rotateby);
}
}
10c4a6: bd70 pop {r4, r5, r6, pc}
rotateby = pseudo_random % c->nr_free_blocks;
10c4a8: f243 536c movw r3, #13676 ; 0x356c <== NOT EXECUTED
10c4ac: f2c0 0322 movt r3, #34 ; 0x22 <== NOT EXECUTED
10c4b0: 6818 ldr r0, [r3, #0] <== NOT EXECUTED
10c4b2: f008 f983 bl 1147bc <__aeabi_uidivmod> <== NOT EXECUTED
ent->prev->next = ent->next;
10c4b6: e9d5 232a ldrd r2, r3, [r5, #168] ; 0xa8 <== NOT EXECUTED
rotate_list((&c->free_list), rotateby);
10c4ba: f105 00a8 add.w r0, r5, #168 ; 0xa8 <== NOT EXECUTED
10c4be: 601a str r2, [r3, #0] <== NOT EXECUTED
ent->next->prev = ent->prev;
10c4c0: 6053 str r3, [r2, #4] <== NOT EXECUTED
while(count--) {
10c4c2: 1e4b subs r3, r1, #1 <== NOT EXECUTED
10c4c4: b119 cbz r1, 10c4ce <jffs2_rotate_lists+0x9e> <== NOT EXECUTED
10c4c6: 3b01 subs r3, #1 <== NOT EXECUTED
n = n->next;
10c4c8: 6812 ldr r2, [r2, #0] <== NOT EXECUTED
while(count--) {
10c4ca: 1c59 adds r1, r3, #1 <== NOT EXECUTED
10c4cc: d1fb bne.n 10c4c6 <jffs2_rotate_lists+0x96> <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10c4ce: 6813 ldr r3, [r2, #0] <== NOT EXECUTED
newent->next = next;
10c4d0: e9c5 322a strd r3, r2, [r5, #168] ; 0xa8 <== NOT EXECUTED
afterthisent->next = newent;
10c4d4: 6010 str r0, [r2, #0] <== NOT EXECUTED
next->prev = newent;
10c4d6: 6058 str r0, [r3, #4] <== NOT EXECUTED
}
10c4d8: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
rotateby = pseudo_random % c->nr_erasing_blocks;
10c4da: f243 536c movw r3, #13676 ; 0x356c
10c4de: f2c0 0322 movt r3, #34 ; 0x22
10c4e2: 6818 ldr r0, [r3, #0]
10c4e4: f008 f96a bl 1147bc <__aeabi_uidivmod>
ent->prev->next = ent->next;
10c4e8: e9d5 2326 ldrd r2, r3, [r5, #152] ; 0x98
rotate_list((&c->erase_pending_list), rotateby);
10c4ec: f105 0098 add.w r0, r5, #152 ; 0x98
10c4f0: 601a str r2, [r3, #0]
ent->next->prev = ent->prev;
10c4f2: 6053 str r3, [r2, #4]
while(count--) {
10c4f4: 1e4b subs r3, r1, #1
10c4f6: b119 cbz r1, 10c500 <jffs2_rotate_lists+0xd0>
10c4f8: 3b01 subs r3, #1 <== NOT EXECUTED
n = n->next;
10c4fa: 6812 ldr r2, [r2, #0] <== NOT EXECUTED
while(count--) {
10c4fc: 1c5c adds r4, r3, #1 <== NOT EXECUTED
10c4fe: d1fb bne.n 10c4f8 <jffs2_rotate_lists+0xc8> <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10c500: 6813 ldr r3, [r2, #0]
newent->next = next;
10c502: e9c5 3226 strd r3, r2, [r5, #152] ; 0x98
afterthisent->next = newent;
10c506: 6010 str r0, [r2, #0]
next->prev = newent;
10c508: 6058 str r0, [r3, #4]
}
10c50a: e7ca b.n 10c4a2 <jffs2_rotate_lists+0x72>
rotateby = pseudo_random % x;
10c50c: f243 536c movw r3, #13676 ; 0x356c <== NOT EXECUTED
10c510: f2c0 0322 movt r3, #34 ; 0x22 <== NOT EXECUTED
10c514: 6818 ldr r0, [r3, #0] <== NOT EXECUTED
10c516: f008 f951 bl 1147bc <__aeabi_uidivmod> <== NOT EXECUTED
ent->prev->next = ent->next;
10c51a: 6feb ldr r3, [r5, #124] ; 0x7c <== NOT EXECUTED
10c51c: 601e str r6, [r3, #0] <== NOT EXECUTED
ent->next->prev = ent->prev;
10c51e: 6073 str r3, [r6, #4] <== NOT EXECUTED
while(count--) {
10c520: 1e4b subs r3, r1, #1 <== NOT EXECUTED
10c522: b119 cbz r1, 10c52c <jffs2_rotate_lists+0xfc> <== NOT EXECUTED
10c524: 3b01 subs r3, #1 <== NOT EXECUTED
n = n->next;
10c526: 6836 ldr r6, [r6, #0] <== NOT EXECUTED
while(count--) {
10c528: 1c5a adds r2, r3, #1 <== NOT EXECUTED
10c52a: d1fb bne.n 10c524 <jffs2_rotate_lists+0xf4> <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10c52c: 6833 ldr r3, [r6, #0] <== NOT EXECUTED
newent->next = next;
10c52e: e9c5 361e strd r3, r6, [r5, #120] ; 0x78 <== NOT EXECUTED
afterthisent->next = newent;
10c532: 6034 str r4, [r6, #0] <== NOT EXECUTED
next->prev = newent;
10c534: 605c str r4, [r3, #4] <== NOT EXECUTED
}
10c536: e7b2 b.n 10c49e <jffs2_rotate_lists+0x6e> <== NOT EXECUTED
rotateby = pseudo_random % x;
10c538: f243 536c movw r3, #13676 ; 0x356c <== NOT EXECUTED
10c53c: f2c0 0322 movt r3, #34 ; 0x22 <== NOT EXECUTED
10c540: 6818 ldr r0, [r3, #0] <== NOT EXECUTED
10c542: f008 f93b bl 1147bc <__aeabi_uidivmod> <== NOT EXECUTED
ent->prev->next = ent->next;
10c546: 6f6b ldr r3, [r5, #116] ; 0x74 <== NOT EXECUTED
10c548: 601e str r6, [r3, #0] <== NOT EXECUTED
ent->next->prev = ent->prev;
10c54a: 6073 str r3, [r6, #4] <== NOT EXECUTED
while(count--) {
10c54c: 1e4b subs r3, r1, #1 <== NOT EXECUTED
10c54e: b119 cbz r1, 10c558 <jffs2_rotate_lists+0x128> <== NOT EXECUTED
10c550: 3b01 subs r3, #1 <== NOT EXECUTED
n = n->next;
10c552: 6836 ldr r6, [r6, #0] <== NOT EXECUTED
while(count--) {
10c554: 1c59 adds r1, r3, #1 <== NOT EXECUTED
10c556: d1fb bne.n 10c550 <jffs2_rotate_lists+0x120> <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10c558: 6833 ldr r3, [r6, #0] <== NOT EXECUTED
newent->next = next;
10c55a: e9c5 361c strd r3, r6, [r5, #112] ; 0x70 <== NOT EXECUTED
afterthisent->next = newent;
10c55e: 6034 str r4, [r6, #0] <== NOT EXECUTED
next->prev = newent;
10c560: 605c str r4, [r3, #4] <== NOT EXECUTED
}
10c562: e78f b.n 10c484 <jffs2_rotate_lists+0x54> <== NOT EXECUTED
rotateby = pseudo_random % x;
10c564: f243 536c movw r3, #13676 ; 0x356c <== NOT EXECUTED
10c568: f2c0 0322 movt r3, #34 ; 0x22 <== NOT EXECUTED
10c56c: 6818 ldr r0, [r3, #0] <== NOT EXECUTED
10c56e: f008 f925 bl 1147bc <__aeabi_uidivmod> <== NOT EXECUTED
ent->prev->next = ent->next;
10c572: 6eeb ldr r3, [r5, #108] ; 0x6c <== NOT EXECUTED
10c574: 601e str r6, [r3, #0] <== NOT EXECUTED
ent->next->prev = ent->prev;
10c576: 6073 str r3, [r6, #4] <== NOT EXECUTED
while(count--) {
10c578: 1e4b subs r3, r1, #1 <== NOT EXECUTED
10c57a: b119 cbz r1, 10c584 <jffs2_rotate_lists+0x154> <== NOT EXECUTED
10c57c: 3b01 subs r3, #1 <== NOT EXECUTED
n = n->next;
10c57e: 6836 ldr r6, [r6, #0] <== NOT EXECUTED
while(count--) {
10c580: 1c58 adds r0, r3, #1 <== NOT EXECUTED
10c582: d1fb bne.n 10c57c <jffs2_rotate_lists+0x14c> <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10c584: 6833 ldr r3, [r6, #0] <== NOT EXECUTED
newent->next = next;
10c586: e9c5 361a strd r3, r6, [r5, #104] ; 0x68 <== NOT EXECUTED
afterthisent->next = newent;
10c58a: 6034 str r4, [r6, #0] <== NOT EXECUTED
next->prev = newent;
10c58c: 605c str r4, [r3, #4] <== NOT EXECUTED
}
10c58e: e76c b.n 10c46a <jffs2_rotate_lists+0x3a> <== NOT EXECUTED
rotateby = pseudo_random % x;
10c590: f243 536c movw r3, #13676 ; 0x356c <== NOT EXECUTED
10c594: f2c0 0322 movt r3, #34 ; 0x22 <== NOT EXECUTED
10c598: 6818 ldr r0, [r3, #0] <== NOT EXECUTED
10c59a: f008 f90f bl 1147bc <__aeabi_uidivmod> <== NOT EXECUTED
ent->prev->next = ent->next;
10c59e: 6e6b ldr r3, [r5, #100] ; 0x64 <== NOT EXECUTED
10c5a0: 601e str r6, [r3, #0] <== NOT EXECUTED
ent->next->prev = ent->prev;
10c5a2: 6073 str r3, [r6, #4] <== NOT EXECUTED
while(count--) {
10c5a4: 1e4b subs r3, r1, #1 <== NOT EXECUTED
10c5a6: b119 cbz r1, 10c5b0 <jffs2_rotate_lists+0x180> <== NOT EXECUTED
10c5a8: 3b01 subs r3, #1 <== NOT EXECUTED
n = n->next;
10c5aa: 6836 ldr r6, [r6, #0] <== NOT EXECUTED
while(count--) {
10c5ac: 1c5a adds r2, r3, #1 <== NOT EXECUTED
10c5ae: d1fb bne.n 10c5a8 <jffs2_rotate_lists+0x178> <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10c5b0: 6833 ldr r3, [r6, #0] <== NOT EXECUTED
newent->next = next;
10c5b2: e9c5 3618 strd r3, r6, [r5, #96] ; 0x60 <== NOT EXECUTED
afterthisent->next = newent;
10c5b6: 6034 str r4, [r6, #0] <== NOT EXECUTED
next->prev = newent;
10c5b8: 605c str r4, [r3, #4] <== NOT EXECUTED
}
10c5ba: e749 b.n 10c450 <jffs2_rotate_lists+0x20> <== NOT EXECUTED
0010ba04 <jffs2_scan_classify_jeb>:
return 0;
}
int jffs2_scan_classify_jeb(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb)
{
if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size
10ba04: 6943 ldr r3, [r0, #20] <== NOT EXECUTED
{
10ba06: b470 push {r4, r5, r6} <== NOT EXECUTED
if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size
10ba08: e9d1 4504 ldrd r4, r5, [r1, #16] <== NOT EXECUTED
10ba0c: 3303 adds r3, #3 <== NOT EXECUTED
10ba0e: f023 0303 bic.w r3, r3, #3 <== NOT EXECUTED
10ba12: 192a adds r2, r5, r4 <== NOT EXECUTED
10ba14: 429a cmp r2, r3 <== NOT EXECUTED
10ba16: d00a beq.n 10ba2e <jffs2_scan_classify_jeb+0x2a> <== 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))) {
10ba18: 6b43 ldr r3, [r0, #52] ; 0x34 <== NOT EXECUTED
10ba1a: 1a9b subs r3, r3, r2 <== NOT EXECUTED
10ba1c: 2bc4 cmp r3, #196 ; 0xc4 <== NOT EXECUTED
10ba1e: d913 bls.n 10ba48 <jffs2_scan_classify_jeb+0x44> <== NOT EXECUTED
jeb->dirty_size = 0;
return BLK_STATE_CLEAN;
} else if (jeb->used_size || jeb->unchecked_size)
return BLK_STATE_PARTDIRTY;
else
return BLK_STATE_ALLDIRTY;
10ba20: ea55 0304 orrs.w r3, r5, r4 <== NOT EXECUTED
10ba24: bf14 ite ne <== NOT EXECUTED
10ba26: 2002 movne r0, #2 <== NOT EXECUTED
10ba28: 2004 moveq r0, #4 <== NOT EXECUTED
}
10ba2a: bc70 pop {r4, r5, r6} <== NOT EXECUTED
10ba2c: 4770 bx lr <== NOT EXECUTED
if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size
10ba2e: 698b ldr r3, [r1, #24] <== NOT EXECUTED
10ba30: 2b00 cmp r3, #0 <== NOT EXECUTED
10ba32: d1f1 bne.n 10ba18 <jffs2_scan_classify_jeb+0x14> <== NOT EXECUTED
&& (!jeb->first_node || !ref_next(jeb->first_node)) )
10ba34: 6a8b ldr r3, [r1, #40] ; 0x28 <== NOT EXECUTED
10ba36: b12b cbz r3, 10ba44 <jffs2_scan_classify_jeb+0x40> <== NOT EXECUTED
if (ref->flash_offset == REF_LINK_NODE) {
10ba38: 68de ldr r6, [r3, #12] <== NOT EXECUTED
10ba3a: f1b6 3fff cmp.w r6, #4294967295 ; 0xffffffff <== NOT EXECUTED
10ba3e: d012 beq.n 10ba66 <jffs2_scan_classify_jeb+0x62> <== NOT EXECUTED
if (ref->flash_offset == REF_EMPTY_NODE)
10ba40: 3602 adds r6, #2 <== NOT EXECUTED
10ba42: d1e9 bne.n 10ba18 <jffs2_scan_classify_jeb+0x14> <== NOT EXECUTED
return BLK_STATE_CLEANMARKER;
10ba44: 2003 movs r0, #3 <== NOT EXECUTED
10ba46: e7f0 b.n 10ba2a <jffs2_scan_classify_jeb+0x26> <== NOT EXECUTED
c->wasted_size += jeb->dirty_size;
10ba48: e9d0 4308 ldrd r4, r3, [r0, #32] <== NOT EXECUTED
c->dirty_size -= jeb->dirty_size;
10ba4c: 698a ldr r2, [r1, #24] <== NOT EXECUTED
10ba4e: 1aa4 subs r4, r4, r2 <== NOT EXECUTED
c->wasted_size += jeb->dirty_size;
10ba50: 4413 add r3, r2 <== NOT EXECUTED
10ba52: e9c0 4308 strd r4, r3, [r0, #32] <== NOT EXECUTED
jeb->dirty_size = 0;
10ba56: 2400 movs r4, #0 <== NOT EXECUTED
jeb->wasted_size += jeb->dirty_size;
10ba58: 69cb ldr r3, [r1, #28] <== NOT EXECUTED
return BLK_STATE_CLEAN;
10ba5a: 2001 movs r0, #1 <== NOT EXECUTED
jeb->dirty_size = 0;
10ba5c: 618c str r4, [r1, #24] <== NOT EXECUTED
}
10ba5e: bc70 pop {r4, r5, r6} <== NOT EXECUTED
jeb->wasted_size += jeb->dirty_size;
10ba60: 4413 add r3, r2 <== NOT EXECUTED
10ba62: 61cb str r3, [r1, #28] <== NOT EXECUTED
}
10ba64: 4770 bx lr <== NOT EXECUTED
ref = ref->next_in_ino;
10ba66: 689b ldr r3, [r3, #8] <== NOT EXECUTED
if (!ref)
10ba68: 2b00 cmp r3, #0 <== NOT EXECUTED
10ba6a: d0eb beq.n 10ba44 <jffs2_scan_classify_jeb+0x40> <== NOT EXECUTED
if (ref->flash_offset == REF_EMPTY_NODE)
10ba6c: 685e ldr r6, [r3, #4] <== NOT EXECUTED
10ba6e: e7e7 b.n 10ba40 <jffs2_scan_classify_jeb+0x3c> <== NOT EXECUTED
00107e68 <jffs2_scan_dirty_space>:
if (!size)
107e68: b1d2 cbz r2, 107ea0 <jffs2_scan_dirty_space+0x38> <== NOT EXECUTED
{
107e6a: b530 push {r4, r5, lr} <== NOT EXECUTED
107e6c: 4694 mov ip, r2 <== NOT EXECUTED
if (unlikely(size > jeb->free_size)) {
107e6e: 6a0c ldr r4, [r1, #32] <== NOT EXECUTED
{
107e70: b083 sub sp, #12 <== NOT EXECUTED
if (unlikely(size > jeb->free_size)) {
107e72: 4294 cmp r4, r2 <== NOT EXECUTED
107e74: d324 bcc.n 107ec0 <jffs2_scan_dirty_space+0x58> <== NOT EXECUTED
if (jeb->last_node && ref_obsolete(jeb->last_node)) {
107e76: 6acb ldr r3, [r1, #44] ; 0x2c <== NOT EXECUTED
107e78: b123 cbz r3, 107e84 <jffs2_scan_dirty_space+0x1c> <== NOT EXECUTED
107e7a: 685b ldr r3, [r3, #4] <== NOT EXECUTED
107e7c: f003 0303 and.w r3, r3, #3 <== NOT EXECUTED
107e80: 2b01 cmp r3, #1 <== NOT EXECUTED
107e82: d00f beq.n 107ea4 <jffs2_scan_dirty_space+0x3c> <== NOT EXECUTED
uint32_t ofs = jeb->offset + c->sector_size - jeb->free_size;
107e84: 68ca ldr r2, [r1, #12] <== NOT EXECUTED
jffs2_link_node_ref(c, jeb, ofs, size, NULL);
107e86: 4663 mov r3, ip <== NOT EXECUTED
uint32_t ofs = jeb->offset + c->sector_size - jeb->free_size;
107e88: 6b45 ldr r5, [r0, #52] ; 0x34 <== NOT EXECUTED
107e8a: 442a add r2, r5 <== NOT EXECUTED
107e8c: 1b12 subs r2, r2, r4 <== NOT EXECUTED
jffs2_link_node_ref(c, jeb, ofs, size, NULL);
107e8e: 2400 movs r4, #0 <== NOT EXECUTED
107e90: f042 0201 orr.w r2, r2, #1 <== NOT EXECUTED
107e94: 9400 str r4, [sp, #0] <== NOT EXECUTED
107e96: f7ff ff3b bl 107d10 <jffs2_link_node_ref> <== NOT EXECUTED
}
107e9a: 2000 movs r0, #0 <== NOT EXECUTED
107e9c: b003 add sp, #12 <== NOT EXECUTED
107e9e: bd30 pop {r4, r5, pc} <== NOT EXECUTED
107ea0: 2000 movs r0, #0 <== NOT EXECUTED
107ea2: 4770 bx lr <== NOT EXECUTED
c->dirty_size += size;
107ea4: 6a03 ldr r3, [r0, #32] <== NOT EXECUTED
jeb->free_size -= size;
107ea6: 1aa4 subs r4, r4, r2 <== NOT EXECUTED
c->dirty_size += size;
107ea8: 4413 add r3, r2 <== NOT EXECUTED
107eaa: 6203 str r3, [r0, #32] <== NOT EXECUTED
c->free_size -= size;
107eac: 6a83 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
107eae: 1a9b subs r3, r3, r2 <== NOT EXECUTED
107eb0: 6283 str r3, [r0, #40] ; 0x28 <== NOT EXECUTED
}
107eb2: 2000 movs r0, #0 <== NOT EXECUTED
jeb->dirty_size += size;
107eb4: 698b ldr r3, [r1, #24] <== NOT EXECUTED
jeb->free_size -= size;
107eb6: 620c str r4, [r1, #32] <== NOT EXECUTED
jeb->dirty_size += size;
107eb8: 4413 add r3, r2 <== NOT EXECUTED
107eba: 618b str r3, [r1, #24] <== NOT EXECUTED
}
107ebc: b003 add sp, #12 <== NOT EXECUTED
107ebe: bd30 pop {r4, r5, pc} <== NOT EXECUTED
pr_crit("Dirty space 0x%x larger then free_size 0x%x (wasted 0x%x)\n",
107ec0: f646 7030 movw r0, #28464 ; 0x6f30 <== NOT EXECUTED
107ec4: 69cb ldr r3, [r1, #28] <== NOT EXECUTED
107ec6: 4622 mov r2, r4 <== NOT EXECUTED
107ec8: 4661 mov r1, ip <== NOT EXECUTED
107eca: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107ece: f7ff fba7 bl 107620 <jffs2_printk> <== NOT EXECUTED
BUG();
107ed2: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
107ed6: f646 72c8 movw r2, #28616 ; 0x6fc8 <== NOT EXECUTED
107eda: f646 6054 movw r0, #28244 ; 0x6e54 <== NOT EXECUTED
107ede: f2c0 0311 movt r3, #17 <== NOT EXECUTED
107ee2: f2c0 0211 movt r2, #17 <== NOT EXECUTED
107ee6: f44f 7128 mov.w r1, #672 ; 0x2a0 <== NOT EXECUTED
107eea: f2c0 0011 movt r0, #17 <== NOT EXECUTED
107eee: f004 fbbf bl 10c670 <__assert_func> <== NOT EXECUTED
107ef2: bf00 nop
0010ba70 <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)
{
10ba70: b570 push {r4, r5, r6, lr} <== NOT EXECUTED
10ba72: 4606 mov r6, r0 <== NOT EXECUTED
10ba74: 460d mov r5, r1 <== NOT EXECUTED
struct jffs2_inode_cache *ic;
ic = jffs2_get_ino_cache(c, ino);
10ba76: f7fc f853 bl 107b20 <jffs2_get_ino_cache> <== NOT EXECUTED
if (ic)
10ba7a: 4604 mov r4, r0 <== NOT EXECUTED
10ba7c: b108 cbz r0, 10ba82 <jffs2_scan_make_ino_cache+0x12> <== NOT EXECUTED
ic->nodes = (void *)ic;
jffs2_add_ino_cache(c, ic);
if (ino == 1)
ic->pino_nlink = 1;
return ic;
}
10ba7e: 4620 mov r0, r4 <== NOT EXECUTED
10ba80: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
if (ino > c->highest_ino)
10ba82: 6873 ldr r3, [r6, #4] <== NOT EXECUTED
10ba84: 429d cmp r5, r3 <== NOT EXECUTED
c->highest_ino = ino;
10ba86: bf88 it hi <== NOT EXECUTED
10ba88: 6075 strhi r5, [r6, #4] <== NOT EXECUTED
ic = jffs2_alloc_inode_cache();
10ba8a: f7fb fda7 bl 1075dc <jffs2_alloc_inode_cache> <== NOT EXECUTED
if (!ic) {
10ba8e: 4604 mov r4, r0 <== NOT EXECUTED
10ba90: b178 cbz r0, 10bab2 <jffs2_scan_make_ino_cache+0x42> <== NOT EXECUTED
memset(ic, 0, sizeof(*ic));
10ba92: 2300 movs r3, #0 <== NOT EXECUTED
jffs2_add_ino_cache(c, ic);
10ba94: 4601 mov r1, r0 <== NOT EXECUTED
memset(ic, 0, sizeof(*ic));
10ba96: 6023 str r3, [r4, #0] <== NOT EXECUTED
jffs2_add_ino_cache(c, ic);
10ba98: 4630 mov r0, r6 <== NOT EXECUTED
memset(ic, 0, sizeof(*ic));
10ba9a: 60a3 str r3, [r4, #8] <== NOT EXECUTED
10ba9c: 6123 str r3, [r4, #16] <== NOT EXECUTED
10ba9e: 6163 str r3, [r4, #20] <== NOT EXECUTED
ic->ino = ino;
10baa0: 60e5 str r5, [r4, #12] <== NOT EXECUTED
ic->nodes = (void *)ic;
10baa2: 6064 str r4, [r4, #4] <== NOT EXECUTED
jffs2_add_ino_cache(c, ic);
10baa4: f7fc f852 bl 107b4c <jffs2_add_ino_cache> <== NOT EXECUTED
if (ino == 1)
10baa8: 2d01 cmp r5, #1 <== NOT EXECUTED
}
10baaa: 4620 mov r0, r4 <== NOT EXECUTED
ic->pino_nlink = 1;
10baac: bf08 it eq <== NOT EXECUTED
10baae: 6165 streq r5, [r4, #20] <== NOT EXECUTED
}
10bab0: bd70 pop {r4, r5, r6, pc} <== NOT EXECUTED
pr_notice("%s(): allocation of inode cache failed\n", __func__);
10bab2: f249 3104 movw r1, #37636 ; 0x9304 <== NOT EXECUTED
10bab6: f648 4074 movw r0, #35956 ; 0x8c74 <== NOT EXECUTED
10baba: f2c0 0111 movt r1, #17 <== NOT EXECUTED
10babe: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10bac2: f7ff ff65 bl 10b990 <jffs2_printk> <== NOT EXECUTED
return NULL;
10bac6: e7da b.n 10ba7e <jffs2_scan_make_ino_cache+0xe> <== NOT EXECUTED
0010bac8 <jffs2_scan_medium>:
{
10bac8: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
10bacc: 4680 mov r8, r0
10bace: b095 sub sp, #84 ; 0x54
flashbuf = mtd_kmalloc_up_to(c->mtd, &try_size);
10bad0: f44f 5080 mov.w r0, #4096 ; 0x1000
10bad4: f001 f844 bl 10cb60 <malloc>
if (!flashbuf)
10bad8: 9005 str r0, [sp, #20]
10bada: 2800 cmp r0, #0
10badc: f000 8478 beq.w 10c3d0 <jffs2_scan_medium+0x908> <== ALWAYS TAKEN
for (i=0; i<c->nr_blocks; i++) {
10bae0: f8d8 3050 ldr.w r3, [r8, #80] ; 0x50
10bae4: 9308 str r3, [sp, #32]
10bae6: 2b00 cmp r3, #0
10bae8: f000 838f beq.w 10c20a <jffs2_scan_medium+0x742> <== ALWAYS TAKEN
if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(rd->totlen)))))
return err;
return 0;
}
pseudo_random += je32_to_cpu(rd->version);
10baec: f243 526c movw r2, #13676 ; 0x356c
for (i=0; i<c->nr_blocks; i++) {
10baf0: 2300 movs r3, #0
pseudo_random += je32_to_cpu(rd->version);
10baf2: f2c0 0222 movt r2, #34 ; 0x22
10baf6: 469b mov fp, r3
10baf8: 920b str r2, [sp, #44] ; 0x2c
memcpy(&fd->name, rd->name, checkedlen);
fd->name[checkedlen] = 0;
crc = crc32(0, fd->name, rd->nsize);
if (crc != je32_to_cpu(rd->name_crc)) {
pr_notice("%s(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
10bafa: f249 3220 movw r2, #37664 ; 0x9320
10bafe: f2c0 0211 movt r2, #17
for (i=0; i<c->nr_blocks; i++) {
10bb02: 9306 str r3, [sp, #24]
uint32_t empty_blocks = 0, bad_blocks = 0;
10bb04: 9309 str r3, [sp, #36] ; 0x24
pr_notice("%s(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
10bb06: 920c str r2, [sp, #48] ; 0x30
uint32_t empty_blocks = 0, bad_blocks = 0;
10bb08: 9308 str r3, [sp, #32]
struct jffs2_eraseblock *jeb = &c->blocks[i];
10bb0a: f8d8 4054 ldr.w r4, [r8, #84] ; 0x54
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10bb0e: ab11 add r3, sp, #68 ; 0x44
buf_len = EMPTY_SCAN_SIZE(c->sector_size);
10bb10: f8d8 5034 ldr.w r5, [r8, #52] ; 0x34
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10bb14: 4640 mov r0, r8
10bb16: 9a05 ldr r2, [sp, #20]
struct jffs2_eraseblock *jeb = &c->blocks[i];
10bb18: 445c add r4, fp
ofs = jeb->offset;
10bb1a: f8d4 900c ldr.w r9, [r4, #12]
return DEFAULT_EMPTY_SCAN_SIZE;
10bb1e: f5b5 7f80 cmp.w r5, #256 ; 0x100
10bb22: bf28 it cs
10bb24: f44f 7580 movcs.w r5, #256 ; 0x100
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10bb28: 9200 str r2, [sp, #0]
10bb2a: 462a mov r2, r5
10bb2c: 4649 mov r1, r9
10bb2e: f7ff fe69 bl 10b804 <jffs2_flash_read>
if (ret) {
10bb32: 2800 cmp r0, #0
10bb34: d17b bne.n 10bc2e <jffs2_scan_medium+0x166> <== ALWAYS TAKEN
if (retlen < len) {
10bb36: 9b11 ldr r3, [sp, #68] ; 0x44
10bb38: 429d cmp r5, r3
10bb3a: f200 80ef bhi.w 10bd1c <jffs2_scan_medium+0x254> <== ALWAYS TAKEN
max_ofs = EMPTY_SCAN_SIZE(c->sector_size);
10bb3e: f8d8 0034 ldr.w r0, [r8, #52] ; 0x34
if (sector_size < DEFAULT_EMPTY_SCAN_SIZE)
10bb42: 28ff cmp r0, #255 ; 0xff
return DEFAULT_EMPTY_SCAN_SIZE;
10bb44: bf88 it hi
10bb46: f44f 7180 movhi.w r1, #256 ; 0x100
if (sector_size < DEFAULT_EMPTY_SCAN_SIZE)
10bb4a: d803 bhi.n 10bb54 <jffs2_scan_medium+0x8c> <== NEVER TAKEN
while(ofs < max_ofs && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF)
10bb4c: 2800 cmp r0, #0 <== NOT EXECUTED
10bb4e: f000 80f8 beq.w 10bd42 <jffs2_scan_medium+0x27a> <== NOT EXECUTED
10bb52: 4601 mov r1, r0 <== NOT EXECUTED
10bb54: 9b05 ldr r3, [sp, #20]
ofs = 0;
10bb56: 2600 movs r6, #0
10bb58: 3b04 subs r3, #4
10bb5a: e003 b.n 10bb64 <jffs2_scan_medium+0x9c>
ofs += 4;
10bb5c: 3604 adds r6, #4
while(ofs < max_ofs && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF)
10bb5e: 428e cmp r6, r1
10bb60: f080 80ed bcs.w 10bd3e <jffs2_scan_medium+0x276>
10bb64: f853 2f04 ldr.w r2, [r3, #4]!
10bb68: 3201 adds r2, #1
10bb6a: d0f7 beq.n 10bb5c <jffs2_scan_medium+0x94> <== NEVER TAKEN
if (ofs) {
10bb6c: 2e00 cmp r6, #0 <== NOT EXECUTED
10bb6e: f040 817e bne.w 10be6e <jffs2_scan_medium+0x3a6> <== NOT EXECUTED
ofs += jeb->offset;
10bb72: 68e3 ldr r3, [r4, #12] <== NOT EXECUTED
10bb74: eb03 0a06 add.w sl, r3, r6 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10bb78: 4403 add r3, r0 <== NOT EXECUTED
10bb7a: 459a cmp sl, r3 <== NOT EXECUTED
10bb7c: d24f bcs.n 10bc1e <jffs2_scan_medium+0x156> <== NOT EXECUTED
pr_notice("%s(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
10bb7e: f249 0394 movw r3, #37012 ; 0x9094 <== NOT EXECUTED
prevofs = jeb->offset - 1;
10bb82: f109 36ff add.w r6, r9, #4294967295 ; 0xffffffff <== NOT EXECUTED
pr_notice("%s(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
10bb86: f2c0 0311 movt r3, #17 <== NOT EXECUTED
10bb8a: 930a str r3, [sp, #40] ; 0x28 <== NOT EXECUTED
noise = 10;
10bb8c: 230a movs r3, #10 <== NOT EXECUTED
10bb8e: 9307 str r3, [sp, #28] <== NOT EXECUTED
err = jffs2_prealloc_raw_node_refs(c, jeb, 2);
10bb90: 2202 movs r2, #2 <== NOT EXECUTED
10bb92: 4621 mov r1, r4 <== NOT EXECUTED
10bb94: 4640 mov r0, r8 <== NOT EXECUTED
10bb96: f7fb fcdd bl 107554 <jffs2_prealloc_raw_node_refs> <== NOT EXECUTED
if (err)
10bb9a: 2800 cmp r0, #0 <== NOT EXECUTED
10bb9c: d147 bne.n 10bc2e <jffs2_scan_medium+0x166> <== NOT EXECUTED
if (ofs & 3) {
10bb9e: f01a 0f03 tst.w sl, #3 <== NOT EXECUTED
10bba2: f040 8154 bne.w 10be4e <jffs2_scan_medium+0x386> <== NOT EXECUTED
if (ofs == prevofs) {
10bba6: 45b2 cmp sl, r6 <== NOT EXECUTED
10bba8: f000 8174 beq.w 10be94 <jffs2_scan_medium+0x3cc> <== NOT EXECUTED
if (jeb->offset + c->sector_size < ofs + sizeof(*node)) {
10bbac: 68e2 ldr r2, [r4, #12] <== NOT EXECUTED
10bbae: f10a 070c add.w r7, sl, #12 <== NOT EXECUTED
10bbb2: f8d8 3034 ldr.w r3, [r8, #52] ; 0x34 <== NOT EXECUTED
10bbb6: 441a add r2, r3 <== NOT EXECUTED
10bbb8: 42ba cmp r2, r7 <== NOT EXECUTED
10bbba: f0c0 826f bcc.w 10c09c <jffs2_scan_medium+0x5d4> <== NOT EXECUTED
if (buf_ofs + buf_len < ofs + sizeof(*node)) {
10bbbe: eb09 0305 add.w r3, r9, r5 <== NOT EXECUTED
10bbc2: 429f cmp r7, r3 <== NOT EXECUTED
10bbc4: f200 80f4 bhi.w 10bdb0 <jffs2_scan_medium+0x2e8> <== NOT EXECUTED
node = (struct jffs2_unknown_node *)&buf[ofs-buf_ofs];
10bbc8: 9b05 ldr r3, [sp, #20] <== NOT EXECUTED
10bbca: ebaa 0609 sub.w r6, sl, r9 <== NOT EXECUTED
10bbce: 441e add r6, r3 <== NOT EXECUTED
if (*(uint32_t *)(&buf[ofs-buf_ofs]) == 0xffffffff) {
10bbd0: 6833 ldr r3, [r6, #0] <== NOT EXECUTED
10bbd2: 3301 adds r3, #1 <== NOT EXECUTED
10bbd4: f000 8107 beq.w 10bde6 <jffs2_scan_medium+0x31e> <== NOT EXECUTED
if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) {
10bbd8: 68e2 ldr r2, [r4, #12] <== NOT EXECUTED
10bbda: 8833 ldrh r3, [r6, #0] <== NOT EXECUTED
10bbdc: 4552 cmp r2, sl <== NOT EXECUTED
10bbde: d031 beq.n 10bc44 <jffs2_scan_medium+0x17c> <== NOT EXECUTED
if (je16_to_cpu(node->magic) == JFFS2_DIRTY_BITMASK) {
10bbe0: 2b00 cmp r3, #0 <== NOT EXECUTED
10bbe2: d03a beq.n 10bc5a <jffs2_scan_medium+0x192> <== NOT EXECUTED
if (je16_to_cpu(node->magic) == JFFS2_OLD_MAGIC_BITMASK) {
10bbe4: f641 1284 movw r2, #6532 ; 0x1984 <== NOT EXECUTED
10bbe8: 4293 cmp r3, r2 <== NOT EXECUTED
10bbea: f000 81b3 beq.w 10bf54 <jffs2_scan_medium+0x48c> <== NOT EXECUTED
if (je16_to_cpu(node->magic) != JFFS2_MAGIC_BITMASK) {
10bbee: f641 1285 movw r2, #6533 ; 0x1985 <== NOT EXECUTED
10bbf2: 4293 cmp r3, r2 <== NOT EXECUTED
10bbf4: f000 81bc beq.w 10bf70 <jffs2_scan_medium+0x4a8> <== NOT EXECUTED
noisy_printk(&noise, "%s(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n",
10bbf8: 9907 ldr r1, [sp, #28] <== NOT EXECUTED
10bbfa: 2900 cmp r1, #0 <== NOT EXECUTED
10bbfc: f040 8194 bne.w 10bf28 <jffs2_scan_medium+0x460> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
10bc00: 2204 movs r2, #4 <== NOT EXECUTED
10bc02: 4621 mov r1, r4 <== NOT EXECUTED
10bc04: 4640 mov r0, r8 <== NOT EXECUTED
10bc06: f7fc f92f bl 107e68 <jffs2_scan_dirty_space> <== NOT EXECUTED
10bc0a: b980 cbnz r0, 10bc2e <jffs2_scan_medium+0x166> <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10bc0c: 68e2 ldr r2, [r4, #12] <== NOT EXECUTED
continue;
10bc0e: 4656 mov r6, sl <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10bc10: f8d8 3034 ldr.w r3, [r8, #52] ; 0x34 <== NOT EXECUTED
ofs += 4;
10bc14: f10a 0a04 add.w sl, sl, #4 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10bc18: 4413 add r3, r2 <== NOT EXECUTED
10bc1a: 459a cmp sl, r3 <== NOT EXECUTED
10bc1c: d3b8 bcc.n 10bb90 <jffs2_scan_medium+0xc8> <== NOT EXECUTED
if (jeb->wasted_size) {
10bc1e: 69e3 ldr r3, [r4, #28] <== NOT EXECUTED
10bc20: 2b00 cmp r3, #0 <== NOT EXECUTED
10bc22: f040 81f8 bne.w 10c016 <jffs2_scan_medium+0x54e> <== NOT EXECUTED
return jffs2_scan_classify_jeb(c, jeb);
10bc26: 4621 mov r1, r4 <== NOT EXECUTED
10bc28: 4640 mov r0, r8 <== NOT EXECUTED
10bc2a: f7ff feeb bl 10ba04 <jffs2_scan_classify_jeb> <== NOT EXECUTED
if (ret < 0)
10bc2e: 2800 cmp r0, #0 <== NOT EXECUTED
10bc30: f2c0 814d blt.w 10bece <jffs2_scan_medium+0x406> <== NOT EXECUTED
switch(ret) {
10bc34: 2805 cmp r0, #5 <== NOT EXECUTED
10bc36: f200 83e1 bhi.w 10c3fc <jffs2_scan_medium+0x934> <== NOT EXECUTED
10bc3a: e8df f000 tbb [pc, r0] <== NOT EXECUTED
10bc3e: abb4 .short 0xabb4 <== NOT EXECUTED
10bc40: 1d728597 .word 0x1d728597 <== NOT EXECUTED
if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) {
10bc44: f248 5219 movw r2, #34073 ; 0x8519 <== NOT EXECUTED
10bc48: 4293 cmp r3, r2 <== NOT EXECUTED
10bc4a: d1c9 bne.n 10bbe0 <jffs2_scan_medium+0x118> <== NOT EXECUTED
pr_warn("Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n",
10bc4c: f648 5040 movw r0, #36160 ; 0x8d40 <== NOT EXECUTED
10bc50: 4651 mov r1, sl <== NOT EXECUTED
10bc52: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10bc56: f7ff fe9b bl 10b990 <jffs2_printk> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
10bc5a: 2204 movs r2, #4 <== NOT EXECUTED
10bc5c: 4621 mov r1, r4 <== NOT EXECUTED
10bc5e: 4640 mov r0, r8 <== NOT EXECUTED
10bc60: f7fc f902 bl 107e68 <jffs2_scan_dirty_space> <== NOT EXECUTED
10bc64: 2800 cmp r0, #0 <== NOT EXECUTED
10bc66: d1e2 bne.n 10bc2e <jffs2_scan_medium+0x166> <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10bc68: f8d8 2034 ldr.w r2, [r8, #52] ; 0x34 <== NOT EXECUTED
continue;
10bc6c: 4656 mov r6, sl <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10bc6e: 68e3 ldr r3, [r4, #12] <== NOT EXECUTED
ofs += 4;
10bc70: f10a 0a04 add.w sl, sl, #4 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10bc74: 4413 add r3, r2 <== NOT EXECUTED
continue;
10bc76: e7d0 b.n 10bc1a <jffs2_scan_medium+0x152> <== NOT EXECUTED
bad_blocks++;
10bc78: 9b08 ldr r3, [sp, #32] <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10bc7a: 4641 mov r1, r8 <== NOT EXECUTED
c->bad_size += c->sector_size;
10bc7c: e9d8 200c ldrd r2, r0, [r8, #48] ; 0x30 <== NOT EXECUTED
bad_blocks++;
10bc80: 3301 adds r3, #1 <== NOT EXECUTED
10bc82: 9308 str r3, [sp, #32] <== NOT EXECUTED
c->bad_size += c->sector_size;
10bc84: 4402 add r2, r0 <== NOT EXECUTED
c->free_size -= c->sector_size;
10bc86: f8d8 3028 ldr.w r3, [r8, #40] ; 0x28 <== NOT EXECUTED
10bc8a: 1a1b subs r3, r3, r0 <== NOT EXECUTED
10bc8c: f851 0fb0 ldr.w r0, [r1, #176]! <== NOT EXECUTED
newent->next = next;
10bc90: e9c4 0100 strd r0, r1, [r4] <== NOT EXECUTED
afterthisent->next = newent;
10bc94: f8c8 40b0 str.w r4, [r8, #176] ; 0xb0 <== NOT EXECUTED
next->prev = newent;
10bc98: 6044 str r4, [r0, #4] <== NOT EXECUTED
c->bad_size += c->sector_size;
10bc9a: f8c8 2030 str.w r2, [r8, #48] ; 0x30 <== NOT EXECUTED
c->free_size -= c->sector_size;
10bc9e: f8c8 3028 str.w r3, [r8, #40] ; 0x28 <== NOT EXECUTED
for (i=0; i<c->nr_blocks; i++) {
10bca2: 9a06 ldr r2, [sp, #24]
10bca4: f10b 0b34 add.w fp, fp, #52 ; 0x34
10bca8: f8d8 3050 ldr.w r3, [r8, #80] ; 0x50
10bcac: 3201 adds r2, #1
10bcae: 4293 cmp r3, r2
10bcb0: 9206 str r2, [sp, #24]
10bcb2: f63f af2a bhi.w 10bb0a <jffs2_scan_medium+0x42>
if (c->nextblock && (c->nextblock->dirty_size)) {
10bcb6: f8d8 2058 ldr.w r2, [r8, #88] ; 0x58
10bcba: b11a cbz r2, 10bcc4 <jffs2_scan_medium+0x1fc>
10bcbc: 6991 ldr r1, [r2, #24] <== NOT EXECUTED
10bcbe: 2900 cmp r1, #0 <== NOT EXECUTED
10bcc0: f040 81f9 bne.w 10c0b6 <jffs2_scan_medium+0x5ee> <== NOT EXECUTED
if (c->nr_erasing_blocks) {
10bcc4: f8d8 2040 ldr.w r2, [r8, #64] ; 0x40
ret = 0;
10bcc8: 4693 mov fp, r2
if (c->nr_erasing_blocks) {
10bcca: 2a00 cmp r2, #0
10bccc: f000 8100 beq.w 10bed0 <jffs2_scan_medium+0x408> <== ALWAYS TAKEN
if ( !c->used_size && ((c->nr_free_blocks+empty_blocks+bad_blocks)!= c->nr_blocks || bad_blocks == c->nr_blocks) ) {
10bcd0: f8d8 201c ldr.w r2, [r8, #28]
10bcd4: 2a00 cmp r2, #0
10bcd6: f040 81fe bne.w 10c0d6 <jffs2_scan_medium+0x60e> <== ALWAYS TAKEN
10bcda: e9dd 4508 ldrd r4, r5, [sp, #32]
10bcde: f8d8 203c ldr.w r2, [r8, #60] ; 0x3c
10bce2: 1929 adds r1, r5, r4
10bce4: 4411 add r1, r2
10bce6: 1b1a subs r2, r3, r4
10bce8: fab2 f282 clz r2, r2
10bcec: 0952 lsrs r2, r2, #5
10bcee: 4299 cmp r1, r3
10bcf0: bf18 it ne
10bcf2: f042 0201 orrne.w r2, r2, #1
10bcf6: 2a00 cmp r2, #0
10bcf8: f000 81ed beq.w 10c0d6 <jffs2_scan_medium+0x60e> <== NEVER TAKEN
pr_notice("Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n");
10bcfc: f249 2070 movw r0, #37488 ; 0x9270 <== NOT EXECUTED
10bd00: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10bd04: f7ff fe44 bl 10b990 <jffs2_printk> <== NOT EXECUTED
pr_notice("empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n",
10bd08: f249 20c8 movw r0, #37576 ; 0x92c8 <== NOT EXECUTED
10bd0c: f8d8 3050 ldr.w r3, [r8, #80] ; 0x50 <== NOT EXECUTED
10bd10: 4622 mov r2, r4 <== NOT EXECUTED
10bd12: 4629 mov r1, r5 <== NOT EXECUTED
10bd14: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10bd18: f7ff fe3a bl 10b990 <jffs2_printk> <== NOT EXECUTED
ret = -EIO;
10bd1c: f06f 0b04 mvn.w fp, #4 <== NOT EXECUTED
goto out;
10bd20: e0d6 b.n 10bed0 <jffs2_scan_medium+0x408> <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10bd22: 4642 mov r2, r8 <== NOT EXECUTED
c->nr_erasing_blocks++;
10bd24: f8d8 3040 ldr.w r3, [r8, #64] ; 0x40
10bd28: 3301 adds r3, #1
10bd2a: f852 1f98 ldr.w r1, [r2, #152]!
newent->next = next;
10bd2e: e9c4 1200 strd r1, r2, [r4]
afterthisent->next = newent;
10bd32: f8c8 4098 str.w r4, [r8, #152] ; 0x98
next->prev = newent;
10bd36: 604c str r4, [r1, #4]
10bd38: f8c8 3040 str.w r3, [r8, #64] ; 0x40
break;
10bd3c: e7b1 b.n 10bca2 <jffs2_scan_medium+0x1da>
if (ofs == max_ofs) {
10bd3e: f040 8096 bne.w 10be6e <jffs2_scan_medium+0x3a6> <== ALWAYS TAKEN
if (c->cleanmarker_size == 0)
10bd42: f8d8 3014 ldr.w r3, [r8, #20]
10bd46: bb73 cbnz r3, 10bda6 <jffs2_scan_medium+0x2de>
if (!jeb->dirty_size) {
10bd48: 69a3 ldr r3, [r4, #24] <== NOT EXECUTED
10bd4a: 2b00 cmp r3, #0 <== NOT EXECUTED
10bd4c: f040 80e7 bne.w 10bf1e <jffs2_scan_medium+0x456> <== NOT EXECUTED
c->nr_free_blocks++;
10bd50: f8d8 303c ldr.w r3, [r8, #60] ; 0x3c <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10bd54: 4642 mov r2, r8 <== NOT EXECUTED
10bd56: f852 1fa8 ldr.w r1, [r2, #168]! <== NOT EXECUTED
10bd5a: 3301 adds r3, #1 <== NOT EXECUTED
newent->next = next;
10bd5c: e9c4 1200 strd r1, r2, [r4] <== NOT EXECUTED
afterthisent->next = newent;
10bd60: f8c8 40a8 str.w r4, [r8, #168] ; 0xa8 <== NOT EXECUTED
next->prev = newent;
10bd64: 604c str r4, [r1, #4] <== NOT EXECUTED
10bd66: f8c8 303c str.w r3, [r8, #60] ; 0x3c <== NOT EXECUTED
10bd6a: e79a b.n 10bca2 <jffs2_scan_medium+0x1da> <== NOT EXECUTED
if (jeb->free_size > min_free(c) &&
10bd6c: 6a23 ldr r3, [r4, #32] <== NOT EXECUTED
10bd6e: 2b88 cmp r3, #136 ; 0x88 <== NOT EXECUTED
10bd70: f240 80a6 bls.w 10bec0 <jffs2_scan_medium+0x3f8> <== NOT EXECUTED
(!c->nextblock || c->nextblock->free_size < jeb->free_size)) {
10bd74: f8d8 1058 ldr.w r1, [r8, #88] ; 0x58 <== NOT EXECUTED
if (jeb->free_size > min_free(c) &&
10bd78: b149 cbz r1, 10bd8e <jffs2_scan_medium+0x2c6> <== NOT EXECUTED
(!c->nextblock || c->nextblock->free_size < jeb->free_size)) {
10bd7a: 6a0a ldr r2, [r1, #32] <== NOT EXECUTED
10bd7c: 4293 cmp r3, r2 <== NOT EXECUTED
10bd7e: f240 809f bls.w 10bec0 <jffs2_scan_medium+0x3f8> <== NOT EXECUTED
ret = file_dirty(c, c->nextblock);
10bd82: 4640 mov r0, r8 <== NOT EXECUTED
10bd84: f7ff fe12 bl 10b9ac <file_dirty> <== NOT EXECUTED
if (ret)
10bd88: 2800 cmp r0, #0 <== NOT EXECUTED
10bd8a: f040 80a0 bne.w 10bece <jffs2_scan_medium+0x406> <== NOT EXECUTED
c->nextblock = jeb;
10bd8e: f8c8 4058 str.w r4, [r8, #88] ; 0x58 <== NOT EXECUTED
10bd92: e786 b.n 10bca2 <jffs2_scan_medium+0x1da> <== NOT EXECUTED
struct list_head *next = afterthisent->next;
10bd94: 4643 mov r3, r8 <== NOT EXECUTED
10bd96: f853 2f60 ldr.w r2, [r3, #96]! <== NOT EXECUTED
newent->next = next;
10bd9a: e9c4 2300 strd r2, r3, [r4] <== NOT EXECUTED
afterthisent->next = newent;
10bd9e: f8c8 4060 str.w r4, [r8, #96] ; 0x60 <== NOT EXECUTED
next->prev = newent;
10bda2: 6054 str r4, [r2, #4] <== NOT EXECUTED
} /* list_add() */
10bda4: e77d b.n 10bca2 <jffs2_scan_medium+0x1da> <== NOT EXECUTED
empty_blocks++;
10bda6: 9b09 ldr r3, [sp, #36] ; 0x24
struct list_head *next = afterthisent->next;
10bda8: 4642 mov r2, r8
10bdaa: 3301 adds r3, #1
10bdac: 9309 str r3, [sp, #36] ; 0x24
10bdae: e7b9 b.n 10bd24 <jffs2_scan_medium+0x25c>
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10bdb0: eba2 050a sub.w r5, r2, sl <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10bdb4: 9b05 ldr r3, [sp, #20] <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10bdb6: f5b5 5f80 cmp.w r5, #4096 ; 0x1000 <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10bdba: 4651 mov r1, sl <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10bdbc: bf28 it cs <== NOT EXECUTED
10bdbe: f44f 5580 movcs.w r5, #4096 ; 0x1000 <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10bdc2: 4640 mov r0, r8 <== NOT EXECUTED
10bdc4: 9300 str r3, [sp, #0] <== NOT EXECUTED
10bdc6: 462a mov r2, r5 <== NOT EXECUTED
10bdc8: ab10 add r3, sp, #64 ; 0x40 <== NOT EXECUTED
10bdca: f7ff fd1b bl 10b804 <jffs2_flash_read> <== NOT EXECUTED
if (ret) {
10bdce: 2800 cmp r0, #0 <== NOT EXECUTED
10bdd0: f47f af2d bne.w 10bc2e <jffs2_scan_medium+0x166> <== NOT EXECUTED
if (retlen < len) {
10bdd4: 9b10 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED
10bdd6: 429d cmp r5, r3 <== NOT EXECUTED
10bdd8: d8a0 bhi.n 10bd1c <jffs2_scan_medium+0x254> <== NOT EXECUTED
if (err)
10bdda: 9e05 ldr r6, [sp, #20] <== NOT EXECUTED
10bddc: 46d1 mov r9, sl <== NOT EXECUTED
if (*(uint32_t *)(&buf[ofs-buf_ofs]) == 0xffffffff) {
10bdde: 6833 ldr r3, [r6, #0] <== NOT EXECUTED
10bde0: 3301 adds r3, #1 <== NOT EXECUTED
10bde2: f47f aef9 bne.w 10bbd8 <jffs2_scan_medium+0x110> <== NOT EXECUTED
scan_end = min_t(uint32_t, EMPTY_SCAN_SIZE(c->sector_size)/8, buf_len);
10bde6: f8d8 1034 ldr.w r1, [r8, #52] ; 0x34 <== NOT EXECUTED
ofs += 4;
10bdea: f10a 0704 add.w r7, sl, #4 <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10bdee: 9e05 ldr r6, [sp, #20] <== NOT EXECUTED
if (sector_size < DEFAULT_EMPTY_SCAN_SIZE)
10bdf0: 29ff cmp r1, #255 ; 0xff <== NOT EXECUTED
scan_end = min_t(uint32_t, EMPTY_SCAN_SIZE(c->sector_size)/8, buf_len);
10bdf2: bf94 ite ls <== NOT EXECUTED
10bdf4: 08c9 lsrls r1, r1, #3 <== NOT EXECUTED
10bdf6: 2120 movhi r1, #32 <== NOT EXECUTED
10bdf8: 42a9 cmp r1, r5 <== NOT EXECUTED
10bdfa: bf28 it cs <== NOT EXECUTED
10bdfc: 4629 movcs r1, r5 <== NOT EXECUTED
inbuf_ofs = ofs - buf_ofs;
10bdfe: eba7 0309 sub.w r3, r7, r9 <== NOT EXECUTED
while (inbuf_ofs < scan_end) {
10be02: 428b cmp r3, r1 <== NOT EXECUTED
10be04: d26b bcs.n 10bede <jffs2_scan_medium+0x416> <== NOT EXECUTED
10be06: 3b04 subs r3, #4 <== NOT EXECUTED
10be08: 4433 add r3, r6 <== NOT EXECUTED
10be0a: e004 b.n 10be16 <jffs2_scan_medium+0x34e> <== NOT EXECUTED
ofs += 4;
10be0c: 3704 adds r7, #4 <== NOT EXECUTED
while (inbuf_ofs < scan_end) {
10be0e: eba7 0209 sub.w r2, r7, r9 <== NOT EXECUTED
10be12: 4291 cmp r1, r2 <== NOT EXECUTED
10be14: d963 bls.n 10bede <jffs2_scan_medium+0x416> <== NOT EXECUTED
if (unlikely(*(uint32_t *)(&buf[inbuf_ofs]) != 0xffffffff)) {
10be16: f853 2f04 ldr.w r2, [r3, #4]! <== NOT EXECUTED
10be1a: 3201 adds r2, #1 <== NOT EXECUTED
10be1c: d0f6 beq.n 10be0c <jffs2_scan_medium+0x344> <== NOT EXECUTED
pr_warn("Empty flash at 0x%08x ends at 0x%08x\n",
10be1e: f648 5010 movw r0, #36112 ; 0x8d10 <== NOT EXECUTED
10be22: 463a mov r2, r7 <== NOT EXECUTED
10be24: 4651 mov r1, sl <== NOT EXECUTED
10be26: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10be2a: f7ff fdb1 bl 10b990 <jffs2_printk> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, ofs-empty_start)))
10be2e: eba7 020a sub.w r2, r7, sl <== NOT EXECUTED
10be32: 4621 mov r1, r4 <== NOT EXECUTED
10be34: 4640 mov r0, r8 <== NOT EXECUTED
10be36: f7fc f817 bl 107e68 <jffs2_scan_dirty_space> <== NOT EXECUTED
10be3a: 2800 cmp r0, #0 <== NOT EXECUTED
10be3c: f47f aef7 bne.w 10bc2e <jffs2_scan_medium+0x166> <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10be40: f8d8 2034 ldr.w r2, [r8, #52] ; 0x34 <== NOT EXECUTED
10be44: 4656 mov r6, sl <== NOT EXECUTED
10be46: 68e3 ldr r3, [r4, #12] <== NOT EXECUTED
10be48: 46ba mov sl, r7 <== NOT EXECUTED
10be4a: 4413 add r3, r2 <== NOT EXECUTED
10be4c: e6e5 b.n 10bc1a <jffs2_scan_medium+0x152> <== NOT EXECUTED
pr_warn("Eep. ofs 0x%08x not word-aligned!\n", ofs);
10be4e: f648 40a8 movw r0, #36008 ; 0x8ca8 <== NOT EXECUTED
10be52: 4651 mov r1, sl <== NOT EXECUTED
10be54: f2c0 0011 movt r0, #17 <== NOT EXECUTED
ofs = PAD(ofs);
10be58: f10a 0a03 add.w sl, sl, #3 <== NOT EXECUTED
pr_warn("Eep. ofs 0x%08x not word-aligned!\n", ofs);
10be5c: f7ff fd98 bl 10b990 <jffs2_printk> <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10be60: f8d8 2034 ldr.w r2, [r8, #52] ; 0x34 <== NOT EXECUTED
ofs = PAD(ofs);
10be64: f02a 0a03 bic.w sl, sl, #3 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10be68: 68e3 ldr r3, [r4, #12] <== NOT EXECUTED
10be6a: 4413 add r3, r2 <== NOT EXECUTED
continue;
10be6c: e6d5 b.n 10bc1a <jffs2_scan_medium+0x152> <== NOT EXECUTED
if ((err = jffs2_prealloc_raw_node_refs(c, jeb, 1)))
10be6e: 2201 movs r2, #1 <== NOT EXECUTED
10be70: 4621 mov r1, r4 <== NOT EXECUTED
10be72: 4640 mov r0, r8 <== NOT EXECUTED
10be74: f7fb fb6e bl 107554 <jffs2_prealloc_raw_node_refs> <== NOT EXECUTED
10be78: 2800 cmp r0, #0 <== NOT EXECUTED
10be7a: f47f aed8 bne.w 10bc2e <jffs2_scan_medium+0x166> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, ofs)))
10be7e: 4632 mov r2, r6 <== NOT EXECUTED
10be80: 4621 mov r1, r4 <== NOT EXECUTED
10be82: 4640 mov r0, r8 <== NOT EXECUTED
10be84: f7fb fff0 bl 107e68 <jffs2_scan_dirty_space> <== NOT EXECUTED
10be88: 2800 cmp r0, #0 <== NOT EXECUTED
10be8a: f47f aed0 bne.w 10bc2e <jffs2_scan_medium+0x166> <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10be8e: f8d8 0034 ldr.w r0, [r8, #52] ; 0x34 <== NOT EXECUTED
10be92: e66e b.n 10bb72 <jffs2_scan_medium+0xaa> <== NOT EXECUTED
pr_warn("ofs 0x%08x has already been seen. Skipping\n",
10be94: f648 40d8 movw r0, #36056 ; 0x8cd8 <== NOT EXECUTED
10be98: 4651 mov r1, sl <== NOT EXECUTED
10be9a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10be9e: f7ff fd77 bl 10b990 <jffs2_printk> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
10bea2: 2204 movs r2, #4 <== NOT EXECUTED
10bea4: 4621 mov r1, r4 <== NOT EXECUTED
10bea6: 4640 mov r0, r8 <== NOT EXECUTED
10bea8: f7fb ffde bl 107e68 <jffs2_scan_dirty_space> <== NOT EXECUTED
10beac: 2800 cmp r0, #0 <== NOT EXECUTED
10beae: f47f aebe bne.w 10bc2e <jffs2_scan_medium+0x166> <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10beb2: f8d8 2034 ldr.w r2, [r8, #52] ; 0x34 <== NOT EXECUTED
ofs += 4;
10beb6: f10a 0a04 add.w sl, sl, #4 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10beba: 68e3 ldr r3, [r4, #12] <== NOT EXECUTED
10bebc: 4413 add r3, r2 <== NOT EXECUTED
continue;
10bebe: e6ac b.n 10bc1a <jffs2_scan_medium+0x152> <== NOT EXECUTED
ret = file_dirty(c, jeb);
10bec0: 4621 mov r1, r4 <== NOT EXECUTED
10bec2: 4640 mov r0, r8 <== NOT EXECUTED
10bec4: f7ff fd72 bl 10b9ac <file_dirty> <== NOT EXECUTED
if (ret)
10bec8: 2800 cmp r0, #0 <== NOT EXECUTED
10beca: f43f aeea beq.w 10bca2 <jffs2_scan_medium+0x1da> <== NOT EXECUTED
10bece: 4683 mov fp, r0 <== NOT EXECUTED
kfree(flashbuf);
10bed0: 9805 ldr r0, [sp, #20]
10bed2: f000 fd09 bl 10c8e8 <free>
}
10bed6: 4658 mov r0, fp
10bed8: b015 add sp, #84 ; 0x54
10beda: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) &&
10bede: 68e3 ldr r3, [r4, #12] <== NOT EXECUTED
10bee0: 4599 cmp r9, r3 <== NOT EXECUTED
10bee2: d079 beq.n 10bfd8 <jffs2_scan_medium+0x510> <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10bee4: f8d8 5034 ldr.w r5, [r8, #52] ; 0x34 <== NOT EXECUTED
10bee8: 442b add r3, r5 <== NOT EXECUTED
if (!buf_len) {
10beea: 42bb cmp r3, r7 <== NOT EXECUTED
10beec: f43f ae97 beq.w 10bc1e <jffs2_scan_medium+0x156> <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10bef0: 1bdd subs r5, r3, r7 <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10bef2: 4639 mov r1, r7 <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10bef4: f5b5 5f80 cmp.w r5, #4096 ; 0x1000 <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10bef8: ab10 add r3, sp, #64 ; 0x40 <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10befa: bf28 it cs <== NOT EXECUTED
10befc: f44f 5580 movcs.w r5, #4096 ; 0x1000 <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10bf00: 4640 mov r0, r8 <== NOT EXECUTED
10bf02: 462a mov r2, r5 <== NOT EXECUTED
10bf04: 9600 str r6, [sp, #0] <== NOT EXECUTED
10bf06: f7ff fc7d bl 10b804 <jffs2_flash_read> <== NOT EXECUTED
if (ret) {
10bf0a: 2800 cmp r0, #0 <== NOT EXECUTED
10bf0c: f47f ae8f bne.w 10bc2e <jffs2_scan_medium+0x166> <== NOT EXECUTED
if (retlen < len) {
10bf10: 9b10 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED
10bf12: 429d cmp r5, r3 <== NOT EXECUTED
10bf14: f63f af02 bhi.w 10bd1c <jffs2_scan_medium+0x254> <== NOT EXECUTED
if (err)
10bf18: 4629 mov r1, r5 <== NOT EXECUTED
10bf1a: 46b9 mov r9, r7 <== NOT EXECUTED
10bf1c: e76f b.n 10bdfe <jffs2_scan_medium+0x336> <== NOT EXECUTED
c->nr_erasing_blocks++;
10bf1e: f8d8 3040 ldr.w r3, [r8, #64] ; 0x40 <== NOT EXECUTED
10bf22: 4642 mov r2, r8 <== NOT EXECUTED
10bf24: 3301 adds r3, #1 <== NOT EXECUTED
10bf26: e700 b.n 10bd2a <jffs2_scan_medium+0x262> <== NOT EXECUTED
noisy_printk(&noise, "%s(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n",
10bf28: f249 3150 movw r1, #37712 ; 0x9350 <== NOT EXECUTED
10bf2c: f648 600c movw r0, #36364 ; 0x8e0c <== NOT EXECUTED
10bf30: 9300 str r3, [sp, #0] <== NOT EXECUTED
10bf32: f2c0 0111 movt r1, #17 <== NOT EXECUTED
10bf36: 4653 mov r3, sl <== NOT EXECUTED
10bf38: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10bf3c: f7ff fd28 bl 10b990 <jffs2_printk> <== NOT EXECUTED
10bf40: 9b07 ldr r3, [sp, #28] <== NOT EXECUTED
10bf42: 3b01 subs r3, #1 <== NOT EXECUTED
10bf44: 9307 str r3, [sp, #28] <== NOT EXECUTED
10bf46: f47f ae5b bne.w 10bc00 <jffs2_scan_medium+0x138> <== NOT EXECUTED
10bf4a: f648 6058 movw r0, #36440 ; 0x8e58 <== NOT EXECUTED
10bf4e: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10bf52: e00a b.n 10bf6a <jffs2_scan_medium+0x4a2> <== NOT EXECUTED
pr_warn("Old JFFS2 bitmask found at 0x%08x\n", ofs);
10bf54: f648 5094 movw r0, #36244 ; 0x8d94 <== NOT EXECUTED
10bf58: 4651 mov r1, sl <== NOT EXECUTED
10bf5a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10bf5e: f7ff fd17 bl 10b990 <jffs2_printk> <== NOT EXECUTED
pr_warn("You cannot use older JFFS2 filesystems with newer kernels\n");
10bf62: f648 50c4 movw r0, #36292 ; 0x8dc4 <== NOT EXECUTED
10bf66: f2c0 0011 movt r0, #17 <== NOT EXECUTED
noisy_printk(&noise, "%s(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n",
10bf6a: f7ff fd11 bl 10b990 <jffs2_printk> <== NOT EXECUTED
10bf6e: e647 b.n 10bc00 <jffs2_scan_medium+0x138> <== NOT EXECUTED
crcnode.magic = node->magic;
10bf70: 8833 ldrh r3, [r6, #0] <== NOT EXECUTED
hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4);
10bf72: 2208 movs r2, #8 <== NOT EXECUTED
crcnode.totlen = node->totlen;
10bf74: 6870 ldr r0, [r6, #4] <== NOT EXECUTED
hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4);
10bf76: a911 add r1, sp, #68 ; 0x44 <== NOT EXECUTED
crcnode.magic = node->magic;
10bf78: f8ad 3044 strh.w r3, [sp, #68] ; 0x44 <== NOT EXECUTED
crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE);
10bf7c: 8873 ldrh r3, [r6, #2] <== NOT EXECUTED
crcnode.totlen = node->totlen;
10bf7e: 9012 str r0, [sp, #72] ; 0x48 <== NOT EXECUTED
hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4);
10bf80: 2000 movs r0, #0 <== NOT EXECUTED
crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE);
10bf82: f443 5300 orr.w r3, r3, #8192 ; 0x2000 <== NOT EXECUTED
10bf86: f8ad 3046 strh.w r3, [sp, #70] ; 0x46 <== NOT EXECUTED
hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4);
10bf8a: f7fe fe97 bl 10acbc <cyg_crc32_accumulate> <== NOT EXECUTED
if (hdr_crc != je32_to_cpu(node->hdr_crc)) {
10bf8e: 68b3 ldr r3, [r6, #8] <== NOT EXECUTED
10bf90: 4298 cmp r0, r3 <== NOT EXECUTED
10bf92: d050 beq.n 10c036 <jffs2_scan_medium+0x56e> <== 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",
10bf94: 9a07 ldr r2, [sp, #28] <== NOT EXECUTED
10bf96: 2a00 cmp r2, #0 <== NOT EXECUTED
10bf98: f43f ae5f beq.w 10bc5a <jffs2_scan_medium+0x192> <== NOT EXECUTED
10bf9c: e9cd 3002 strd r3, r0, [sp, #8] <== NOT EXECUTED
10bfa0: f249 3150 movw r1, #37712 ; 0x9350 <== NOT EXECUTED
10bfa4: 6873 ldr r3, [r6, #4] <== NOT EXECUTED
10bfa6: f648 60a0 movw r0, #36512 ; 0x8ea0 <== NOT EXECUTED
10bfaa: f2c0 0111 movt r1, #17 <== NOT EXECUTED
10bfae: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10bfb2: 4652 mov r2, sl <== NOT EXECUTED
10bfb4: 9301 str r3, [sp, #4] <== NOT EXECUTED
10bfb6: 8873 ldrh r3, [r6, #2] <== NOT EXECUTED
10bfb8: 9300 str r3, [sp, #0] <== NOT EXECUTED
10bfba: 8833 ldrh r3, [r6, #0] <== NOT EXECUTED
10bfbc: f7ff fce8 bl 10b990 <jffs2_printk> <== NOT EXECUTED
10bfc0: 9b07 ldr r3, [sp, #28] <== NOT EXECUTED
10bfc2: 3b01 subs r3, #1 <== NOT EXECUTED
10bfc4: 9307 str r3, [sp, #28] <== NOT EXECUTED
10bfc6: f47f ae48 bne.w 10bc5a <jffs2_scan_medium+0x192> <== NOT EXECUTED
10bfca: f648 6058 movw r0, #36440 ; 0x8e58 <== NOT EXECUTED
10bfce: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10bfd2: f7ff fcdd bl 10b990 <jffs2_printk> <== NOT EXECUTED
10bfd6: e640 b.n 10bc5a <jffs2_scan_medium+0x192> <== NOT EXECUTED
if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) &&
10bfd8: f8d8 0014 ldr.w r0, [r8, #20] <== NOT EXECUTED
10bfdc: 6961 ldr r1, [r4, #20] <== NOT EXECUTED
10bfde: 1cc2 adds r2, r0, #3 <== NOT EXECUTED
10bfe0: 2800 cmp r0, #0 <== NOT EXECUTED
10bfe2: f022 0203 bic.w r2, r2, #3 <== NOT EXECUTED
10bfe6: eba2 0201 sub.w r2, r2, r1 <== NOT EXECUTED
10bfea: fab2 f282 clz r2, r2 <== NOT EXECUTED
10bfee: ea4f 1252 mov.w r2, r2, lsr #5 <== NOT EXECUTED
10bff2: bf08 it eq <== NOT EXECUTED
10bff4: 2200 moveq r2, #0 <== NOT EXECUTED
10bff6: 2a00 cmp r2, #0 <== NOT EXECUTED
10bff8: f43f af74 beq.w 10bee4 <jffs2_scan_medium+0x41c> <== NOT EXECUTED
c->cleanmarker_size && !jeb->dirty_size && !ref_next(jeb->first_node)) {
10bffc: 69a2 ldr r2, [r4, #24] <== NOT EXECUTED
10bffe: 2a00 cmp r2, #0 <== NOT EXECUTED
10c000: f47f af70 bne.w 10bee4 <jffs2_scan_medium+0x41c> <== NOT EXECUTED
10c004: 6aa1 ldr r1, [r4, #40] ; 0x28 <== NOT EXECUTED
if (ref->flash_offset == REF_LINK_NODE) {
10c006: 68ca ldr r2, [r1, #12] <== NOT EXECUTED
10c008: 1c50 adds r0, r2, #1 <== NOT EXECUTED
10c00a: f000 80b5 beq.w 10c178 <jffs2_scan_medium+0x6b0> <== NOT EXECUTED
if (ref->flash_offset == REF_EMPTY_NODE)
10c00e: 3202 adds r2, #2 <== NOT EXECUTED
10c010: f47f af68 bne.w 10bee4 <jffs2_scan_medium+0x41c> <== NOT EXECUTED
10c014: e69c b.n 10bd50 <jffs2_scan_medium+0x288> <== NOT EXECUTED
jeb->dirty_size += jeb->wasted_size;
10c016: 69a2 ldr r2, [r4, #24] <== NOT EXECUTED
10c018: 441a add r2, r3 <== NOT EXECUTED
10c01a: 61a2 str r2, [r4, #24] <== NOT EXECUTED
c->dirty_size += jeb->wasted_size;
10c01c: f8d8 2020 ldr.w r2, [r8, #32] <== NOT EXECUTED
10c020: 441a add r2, r3 <== NOT EXECUTED
10c022: f8c8 2020 str.w r2, [r8, #32] <== NOT EXECUTED
c->wasted_size -= jeb->wasted_size;
10c026: f8d8 2024 ldr.w r2, [r8, #36] ; 0x24 <== NOT EXECUTED
10c02a: 1ad3 subs r3, r2, r3 <== NOT EXECUTED
10c02c: f8c8 3024 str.w r3, [r8, #36] ; 0x24 <== NOT EXECUTED
jeb->wasted_size = 0;
10c030: 2300 movs r3, #0 <== NOT EXECUTED
10c032: 61e3 str r3, [r4, #28] <== NOT EXECUTED
10c034: e5f7 b.n 10bc26 <jffs2_scan_medium+0x15e> <== NOT EXECUTED
if (ofs + je32_to_cpu(node->totlen) > jeb->offset + c->sector_size) {
10c036: 6872 ldr r2, [r6, #4] <== NOT EXECUTED
10c038: 68e0 ldr r0, [r4, #12] <== NOT EXECUTED
10c03a: f8d8 3034 ldr.w r3, [r8, #52] ; 0x34 <== NOT EXECUTED
10c03e: eb02 0c0a add.w ip, r2, sl <== NOT EXECUTED
10c042: 4403 add r3, r0 <== NOT EXECUTED
10c044: 459c cmp ip, r3 <== NOT EXECUTED
10c046: f200 808b bhi.w 10c160 <jffs2_scan_medium+0x698> <== NOT EXECUTED
if (!(je16_to_cpu(node->nodetype) & JFFS2_NODE_ACCURATE)) {
10c04a: 8871 ldrh r1, [r6, #2] <== NOT EXECUTED
10c04c: f411 5f00 tst.w r1, #8192 ; 0x2000 <== NOT EXECUTED
10c050: d00f beq.n 10c072 <jffs2_scan_medium+0x5aa> <== NOT EXECUTED
switch(je16_to_cpu(node->nodetype)) {
10c052: f24e 0e01 movw lr, #57345 ; 0xe001 <== NOT EXECUTED
10c056: 4571 cmp r1, lr <== NOT EXECUTED
10c058: f000 80a8 beq.w 10c1ac <jffs2_scan_medium+0x6e4> <== NOT EXECUTED
10c05c: d846 bhi.n 10c0ec <jffs2_scan_medium+0x624> <== NOT EXECUTED
10c05e: f242 0c03 movw ip, #8195 ; 0x2003 <== NOT EXECUTED
10c062: 4561 cmp r1, ip <== NOT EXECUTED
10c064: f000 808e beq.w 10c184 <jffs2_scan_medium+0x6bc> <== NOT EXECUTED
10c068: f242 0004 movw r0, #8196 ; 0x2004 <== NOT EXECUTED
10c06c: 4281 cmp r1, r0 <== NOT EXECUTED
10c06e: f040 80e7 bne.w 10c240 <jffs2_scan_medium+0x778> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
10c072: 3203 adds r2, #3 <== NOT EXECUTED
10c074: 4621 mov r1, r4 <== NOT EXECUTED
10c076: f022 0203 bic.w r2, r2, #3 <== NOT EXECUTED
10c07a: 4640 mov r0, r8 <== NOT EXECUTED
10c07c: f7fb fef4 bl 107e68 <jffs2_scan_dirty_space> <== NOT EXECUTED
10c080: 2800 cmp r0, #0 <== NOT EXECUTED
10c082: f47f add4 bne.w 10bc2e <jffs2_scan_medium+0x166> <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
10c086: 6872 ldr r2, [r6, #4] <== NOT EXECUTED
10c088: 3203 adds r2, #3 <== NOT EXECUTED
10c08a: f022 0203 bic.w r2, r2, #3 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10c08e: f8d8 1034 ldr.w r1, [r8, #52] ; 0x34 <== NOT EXECUTED
break;
10c092: 4656 mov r6, sl <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10c094: 68e3 ldr r3, [r4, #12] <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
10c096: 4492 add sl, r2 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
10c098: 440b add r3, r1 <== NOT EXECUTED
break;
10c09a: e5be b.n 10bc1a <jffs2_scan_medium+0x152> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, (jeb->offset + c->sector_size)-ofs)))
10c09c: eba2 020a sub.w r2, r2, sl <== NOT EXECUTED
10c0a0: 4621 mov r1, r4 <== NOT EXECUTED
10c0a2: 4640 mov r0, r8 <== NOT EXECUTED
10c0a4: f7fb fee0 bl 107e68 <jffs2_scan_dirty_space> <== NOT EXECUTED
10c0a8: 2800 cmp r0, #0 <== NOT EXECUTED
10c0aa: f47f adc0 bne.w 10bc2e <jffs2_scan_medium+0x166> <== NOT EXECUTED
if (jeb->wasted_size) {
10c0ae: 69e3 ldr r3, [r4, #28] <== NOT EXECUTED
10c0b0: 2b00 cmp r3, #0 <== NOT EXECUTED
10c0b2: d1b0 bne.n 10c016 <jffs2_scan_medium+0x54e> <== NOT EXECUTED
10c0b4: e5b7 b.n 10bc26 <jffs2_scan_medium+0x15e> <== NOT EXECUTED
c->nextblock->wasted_size += c->nextblock->dirty_size;
10c0b6: 69d0 ldr r0, [r2, #28] <== NOT EXECUTED
10c0b8: 4408 add r0, r1 <== NOT EXECUTED
10c0ba: 61d0 str r0, [r2, #28] <== NOT EXECUTED
c->wasted_size += c->nextblock->dirty_size;
10c0bc: f8d8 0024 ldr.w r0, [r8, #36] ; 0x24 <== NOT EXECUTED
10c0c0: 4408 add r0, r1 <== NOT EXECUTED
10c0c2: f8c8 0024 str.w r0, [r8, #36] ; 0x24 <== NOT EXECUTED
c->dirty_size -= c->nextblock->dirty_size;
10c0c6: f8d8 0020 ldr.w r0, [r8, #32] <== NOT EXECUTED
10c0ca: 1a41 subs r1, r0, r1 <== NOT EXECUTED
10c0cc: f8c8 1020 str.w r1, [r8, #32] <== NOT EXECUTED
c->nextblock->dirty_size = 0;
10c0d0: 2100 movs r1, #0 <== NOT EXECUTED
10c0d2: 6191 str r1, [r2, #24] <== NOT EXECUTED
10c0d4: e5f6 b.n 10bcc4 <jffs2_scan_medium+0x1fc> <== NOT EXECUTED
rtems_jffs2_flash_control *fc = sb->s_flash_control;
10c0d6: f8d8 00e4 ldr.w r0, [r8, #228] ; 0xe4
if (fc->trigger_garbage_collection != NULL) {
10c0da: 6a03 ldr r3, [r0, #32]
ret = 0;
10c0dc: 469b mov fp, r3
10c0de: 2b00 cmp r3, #0
10c0e0: f43f aef6 beq.w 10bed0 <jffs2_scan_medium+0x408> <== NEVER TAKEN
10c0e4: f04f 0b00 mov.w fp, #0 <== NOT EXECUTED
(*fc->trigger_garbage_collection)(fc);
10c0e8: 4798 blx r3 <== NOT EXECUTED
10c0ea: e6f1 b.n 10bed0 <jffs2_scan_medium+0x408> <== NOT EXECUTED
switch(je16_to_cpu(node->nodetype)) {
10c0ec: f24e 0202 movw r2, #57346 ; 0xe002 <== NOT EXECUTED
10c0f0: 4291 cmp r1, r2 <== NOT EXECUTED
10c0f2: f040 8105 bne.w 10c300 <jffs2_scan_medium+0x838> <== NOT EXECUTED
if (buf_ofs + buf_len < ofs + sizeof(struct jffs2_raw_inode)) {
10c0f6: eb09 0205 add.w r2, r9, r5 <== NOT EXECUTED
10c0fa: f10a 0144 add.w r1, sl, #68 ; 0x44 <== NOT EXECUTED
10c0fe: 428a cmp r2, r1 <== NOT EXECUTED
10c100: d217 bcs.n 10c132 <jffs2_scan_medium+0x66a> <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10c102: eba3 050a sub.w r5, r3, sl <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10c106: 9b05 ldr r3, [sp, #20] <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10c108: f5b5 5f80 cmp.w r5, #4096 ; 0x1000 <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10c10c: 4651 mov r1, sl <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10c10e: bf28 it cs <== NOT EXECUTED
10c110: f44f 5580 movcs.w r5, #4096 ; 0x1000 <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10c114: 4640 mov r0, r8 <== NOT EXECUTED
10c116: 9300 str r3, [sp, #0] <== NOT EXECUTED
10c118: 462a mov r2, r5 <== NOT EXECUTED
10c11a: ab10 add r3, sp, #64 ; 0x40 <== NOT EXECUTED
10c11c: f7ff fb72 bl 10b804 <jffs2_flash_read> <== NOT EXECUTED
if (ret) {
10c120: 2800 cmp r0, #0 <== NOT EXECUTED
10c122: f47f ad84 bne.w 10bc2e <jffs2_scan_medium+0x166> <== NOT EXECUTED
if (retlen < len) {
10c126: 9b10 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED
10c128: 429d cmp r5, r3 <== NOT EXECUTED
10c12a: f63f adf7 bhi.w 10bd1c <jffs2_scan_medium+0x254> <== NOT EXECUTED
if (err)
10c12e: 9e05 ldr r6, [sp, #20] <== NOT EXECUTED
10c130: 46d1 mov r9, sl <== NOT EXECUTED
crc = crc32(0, ri, sizeof(*ri)-8);
10c132: 223c movs r2, #60 ; 0x3c <== NOT EXECUTED
10c134: 4631 mov r1, r6 <== NOT EXECUTED
10c136: 2000 movs r0, #0 <== NOT EXECUTED
uint32_t crc, ino = je32_to_cpu(ri->ino);
10c138: 68f7 ldr r7, [r6, #12] <== NOT EXECUTED
crc = crc32(0, ri, sizeof(*ri)-8);
10c13a: f7fe fdbf bl 10acbc <cyg_crc32_accumulate> <== NOT EXECUTED
if (crc != je32_to_cpu(ri->node_crc)) {
10c13e: 6c33 ldr r3, [r6, #64] ; 0x40 <== NOT EXECUTED
10c140: 4298 cmp r0, r3 <== NOT EXECUTED
10c142: d066 beq.n 10c212 <jffs2_scan_medium+0x74a> <== NOT EXECUTED
pr_notice("%s(): CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
10c144: f249 3138 movw r1, #37688 ; 0x9338 <== NOT EXECUTED
10c148: 9000 str r0, [sp, #0] <== NOT EXECUTED
10c14a: f648 70a8 movw r0, #36776 ; 0x8fa8 <== NOT EXECUTED
10c14e: f2c0 0111 movt r1, #17 <== NOT EXECUTED
10c152: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10c156: 4652 mov r2, sl <== NOT EXECUTED
10c158: f7ff fc1a bl 10b990 <jffs2_printk> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
10c15c: 6872 ldr r2, [r6, #4] <== NOT EXECUTED
10c15e: e788 b.n 10c072 <jffs2_scan_medium+0x5aa> <== NOT EXECUTED
pr_warn("Node at 0x%08x with length 0x%08x would run over the end of the erase block\n",
10c160: f648 7004 movw r0, #36612 ; 0x8f04 <== NOT EXECUTED
10c164: 4651 mov r1, sl <== NOT EXECUTED
10c166: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10c16a: f7ff fc11 bl 10b990 <jffs2_printk> <== NOT EXECUTED
pr_warn("Perhaps the file system was created with the wrong erase size?\n");
10c16e: f648 705c movw r0, #36700 ; 0x8f5c <== NOT EXECUTED
10c172: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10c176: e6f8 b.n 10bf6a <jffs2_scan_medium+0x4a2> <== NOT EXECUTED
ref = ref->next_in_ino;
10c178: 688a ldr r2, [r1, #8] <== NOT EXECUTED
if (!ref)
10c17a: 2a00 cmp r2, #0 <== NOT EXECUTED
10c17c: f43f ade8 beq.w 10bd50 <jffs2_scan_medium+0x288> <== NOT EXECUTED
if (ref->flash_offset == REF_EMPTY_NODE)
10c180: 6852 ldr r2, [r2, #4] <== NOT EXECUTED
10c182: e744 b.n 10c00e <jffs2_scan_medium+0x546> <== NOT EXECUTED
if (je32_to_cpu(node->totlen) != c->cleanmarker_size) {
10c184: f8d8 3014 ldr.w r3, [r8, #20] <== NOT EXECUTED
10c188: 429a cmp r2, r3 <== NOT EXECUTED
10c18a: d071 beq.n 10c270 <jffs2_scan_medium+0x7a8> <== NOT EXECUTED
pr_notice("CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n",
10c18c: f249 00e8 movw r0, #37096 ; 0x90e8 <== NOT EXECUTED
10c190: 4651 mov r1, sl <== NOT EXECUTED
10c192: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10c196: f7ff fbfb bl 10b990 <jffs2_printk> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node)))))
10c19a: 220c movs r2, #12 <== NOT EXECUTED
10c19c: 4621 mov r1, r4 <== NOT EXECUTED
10c19e: 4640 mov r0, r8 <== NOT EXECUTED
10c1a0: f7fb fe62 bl 107e68 <jffs2_scan_dirty_space> <== NOT EXECUTED
10c1a4: 2800 cmp r0, #0 <== NOT EXECUTED
10c1a6: f43f ae4b beq.w 10be40 <jffs2_scan_medium+0x378> <== NOT EXECUTED
10c1aa: e540 b.n 10bc2e <jffs2_scan_medium+0x166> <== NOT EXECUTED
if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) {
10c1ac: eb09 0205 add.w r2, r9, r5 <== NOT EXECUTED
10c1b0: 4594 cmp ip, r2 <== NOT EXECUTED
10c1b2: d917 bls.n 10c1e4 <jffs2_scan_medium+0x71c> <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10c1b4: eba3 050a sub.w r5, r3, sl <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10c1b8: 9b05 ldr r3, [sp, #20] <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10c1ba: f5b5 5f80 cmp.w r5, #4096 ; 0x1000 <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10c1be: 4651 mov r1, sl <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
10c1c0: bf28 it cs <== NOT EXECUTED
10c1c2: f44f 5580 movcs.w r5, #4096 ; 0x1000 <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
10c1c6: 4640 mov r0, r8 <== NOT EXECUTED
10c1c8: 9300 str r3, [sp, #0] <== NOT EXECUTED
10c1ca: 462a mov r2, r5 <== NOT EXECUTED
10c1cc: ab10 add r3, sp, #64 ; 0x40 <== NOT EXECUTED
10c1ce: f7ff fb19 bl 10b804 <jffs2_flash_read> <== NOT EXECUTED
if (ret) {
10c1d2: 2800 cmp r0, #0 <== NOT EXECUTED
10c1d4: f47f ad2b bne.w 10bc2e <jffs2_scan_medium+0x166> <== NOT EXECUTED
if (retlen < len) {
10c1d8: 9b10 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED
10c1da: 429d cmp r5, r3 <== NOT EXECUTED
10c1dc: f63f ad9e bhi.w 10bd1c <jffs2_scan_medium+0x254> <== NOT EXECUTED
if (err)
10c1e0: 9e05 ldr r6, [sp, #20] <== NOT EXECUTED
10c1e2: 46d1 mov r9, sl <== NOT EXECUTED
crc = crc32(0, rd, sizeof(*rd)-8);
10c1e4: 2220 movs r2, #32 <== NOT EXECUTED
10c1e6: 4631 mov r1, r6 <== NOT EXECUTED
10c1e8: 2000 movs r0, #0 <== NOT EXECUTED
10c1ea: f7fe fd67 bl 10acbc <cyg_crc32_accumulate> <== NOT EXECUTED
if (crc != je32_to_cpu(rd->node_crc)) {
10c1ee: 6a33 ldr r3, [r6, #32] <== NOT EXECUTED
10c1f0: 4298 cmp r0, r3 <== NOT EXECUTED
10c1f2: d04a beq.n 10c28a <jffs2_scan_medium+0x7c2> <== NOT EXECUTED
pr_notice("%s(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
10c1f4: 9000 str r0, [sp, #0] <== NOT EXECUTED
10c1f6: f648 70f8 movw r0, #36856 ; 0x8ff8 <== NOT EXECUTED
10c1fa: 4652 mov r2, sl <== NOT EXECUTED
10c1fc: 990c ldr r1, [sp, #48] ; 0x30 <== NOT EXECUTED
10c1fe: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10c202: f7ff fbc5 bl 10b990 <jffs2_printk> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
10c206: 6872 ldr r2, [r6, #4] <== NOT EXECUTED
10c208: e733 b.n 10c072 <jffs2_scan_medium+0x5aa> <== NOT EXECUTED
for (i=0; i<c->nr_blocks; i++) {
10c20a: 9a08 ldr r2, [sp, #32] <== NOT EXECUTED
10c20c: 4613 mov r3, r2 <== NOT EXECUTED
uint32_t empty_blocks = 0, bad_blocks = 0;
10c20e: 9209 str r2, [sp, #36] ; 0x24 <== NOT EXECUTED
10c210: e551 b.n 10bcb6 <jffs2_scan_medium+0x1ee> <== NOT EXECUTED
ic = jffs2_get_ino_cache(c, ino);
10c212: 4639 mov r1, r7 <== NOT EXECUTED
10c214: 4640 mov r0, r8 <== NOT EXECUTED
10c216: f7fb fc83 bl 107b20 <jffs2_get_ino_cache> <== NOT EXECUTED
if (!ic) {
10c21a: 2800 cmp r0, #0 <== NOT EXECUTED
10c21c: f000 808f beq.w 10c33e <jffs2_scan_medium+0x876> <== NOT EXECUTED
jffs2_link_node_ref(c, jeb, ofs | REF_UNCHECKED, PAD(je32_to_cpu(ri->totlen)), ic);
10c220: 6872 ldr r2, [r6, #4] <== NOT EXECUTED
10c222: 4621 mov r1, r4 <== NOT EXECUTED
10c224: 9000 str r0, [sp, #0] <== NOT EXECUTED
10c226: 4640 mov r0, r8 <== NOT EXECUTED
10c228: 1cd3 adds r3, r2, #3 <== NOT EXECUTED
10c22a: 4652 mov r2, sl <== NOT EXECUTED
10c22c: f023 0303 bic.w r3, r3, #3 <== NOT EXECUTED
10c230: f7fb fd6e bl 107d10 <jffs2_link_node_ref> <== NOT EXECUTED
pseudo_random += je32_to_cpu(ri->version);
10c234: 990b ldr r1, [sp, #44] ; 0x2c <== NOT EXECUTED
10c236: 6933 ldr r3, [r6, #16] <== NOT EXECUTED
10c238: 680a ldr r2, [r1, #0] <== NOT EXECUTED
10c23a: 4413 add r3, r2 <== NOT EXECUTED
10c23c: 600b str r3, [r1, #0] <== NOT EXECUTED
if (err) return err;
10c23e: e722 b.n 10c086 <jffs2_scan_medium+0x5be> <== NOT EXECUTED
switch (je16_to_cpu(node->nodetype) & JFFS2_COMPAT_MASK) {
10c240: f401 4040 and.w r0, r1, #49152 ; 0xc000 <== NOT EXECUTED
10c244: f5b0 4f00 cmp.w r0, #32768 ; 0x8000 <== NOT EXECUTED
10c248: d064 beq.n 10c314 <jffs2_scan_medium+0x84c> <== NOT EXECUTED
10c24a: d856 bhi.n 10c2fa <jffs2_scan_medium+0x832> <== NOT EXECUTED
10c24c: 2800 cmp r0, #0 <== NOT EXECUTED
10c24e: f43f af10 beq.w 10c072 <jffs2_scan_medium+0x5aa> <== NOT EXECUTED
10c252: f5b0 4f80 cmp.w r0, #16384 ; 0x4000 <== NOT EXECUTED
10c256: d14e bne.n 10c2f6 <jffs2_scan_medium+0x82e> <== NOT EXECUTED
jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(node->totlen)), NULL);
10c258: 1cd3 adds r3, r2, #3 <== NOT EXECUTED
10c25a: 2200 movs r2, #0 <== NOT EXECUTED
10c25c: 9200 str r2, [sp, #0] <== NOT EXECUTED
10c25e: f023 0303 bic.w r3, r3, #3 <== NOT EXECUTED
10c262: f04a 0202 orr.w r2, sl, #2 <== NOT EXECUTED
10c266: 4621 mov r1, r4 <== NOT EXECUTED
10c268: 4640 mov r0, r8 <== NOT EXECUTED
10c26a: f7fb fd51 bl 107d10 <jffs2_link_node_ref> <== NOT EXECUTED
10c26e: e70a b.n 10c086 <jffs2_scan_medium+0x5be> <== NOT EXECUTED
} else if (jeb->first_node) {
10c270: 6aa2 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED
10c272: 2a00 cmp r2, #0 <== NOT EXECUTED
10c274: f000 80af beq.w 10c3d6 <jffs2_scan_medium+0x90e> <== NOT EXECUTED
pr_notice("CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n",
10c278: 4602 mov r2, r0 <== NOT EXECUTED
10c27a: f249 1034 movw r0, #37172 ; 0x9134 <== NOT EXECUTED
10c27e: 4651 mov r1, sl <== NOT EXECUTED
10c280: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10c284: f7ff fb84 bl 10b990 <jffs2_printk> <== NOT EXECUTED
10c288: e787 b.n 10c19a <jffs2_scan_medium+0x6d2> <== NOT EXECUTED
pseudo_random += je32_to_cpu(rd->version);
10c28a: 990b ldr r1, [sp, #44] ; 0x2c <== NOT EXECUTED
10c28c: 6933 ldr r3, [r6, #16] <== NOT EXECUTED
checkedlen = strnlen(rd->name, rd->nsize);
10c28e: 7f37 ldrb r7, [r6, #28] <== NOT EXECUTED
pseudo_random += je32_to_cpu(rd->version);
10c290: 680a ldr r2, [r1, #0] <== NOT EXECUTED
10c292: 4413 add r3, r2 <== NOT EXECUTED
10c294: 600b str r3, [r1, #0] <== NOT EXECUTED
checkedlen = strnlen(rd->name, rd->nsize);
10c296: f106 0328 add.w r3, r6, #40 ; 0x28 <== NOT EXECUTED
10c29a: 4618 mov r0, r3 <== NOT EXECUTED
10c29c: 4639 mov r1, r7 <== NOT EXECUTED
10c29e: 930e str r3, [sp, #56] ; 0x38 <== NOT EXECUTED
10c2a0: f009 fad8 bl 115854 <strnlen> <== NOT EXECUTED
if (checkedlen < rd->nsize) {
10c2a4: 4287 cmp r7, r0 <== NOT EXECUTED
checkedlen = strnlen(rd->name, rd->nsize);
10c2a6: 4603 mov r3, r0 <== NOT EXECUTED
10c2a8: 900d str r0, [sp, #52] ; 0x34 <== NOT EXECUTED
if (checkedlen < rd->nsize) {
10c2aa: d852 bhi.n 10c352 <jffs2_scan_medium+0x88a> <== NOT EXECUTED
fd = jffs2_alloc_full_dirent(checkedlen+1);
10c2ac: 9b0d ldr r3, [sp, #52] ; 0x34 <== NOT EXECUTED
10c2ae: 1c58 adds r0, r3, #1 <== NOT EXECUTED
10c2b0: f7fb f932 bl 107518 <jffs2_alloc_full_dirent> <== NOT EXECUTED
if (!fd) {
10c2b4: 4607 mov r7, r0 <== NOT EXECUTED
10c2b6: 2800 cmp r0, #0 <== NOT EXECUTED
10c2b8: d048 beq.n 10c34c <jffs2_scan_medium+0x884> <== NOT EXECUTED
memcpy(&fd->name, rd->name, checkedlen);
10c2ba: 990e ldr r1, [sp, #56] ; 0x38 <== NOT EXECUTED
10c2bc: 3015 adds r0, #21 <== NOT EXECUTED
10c2be: 9a0d ldr r2, [sp, #52] ; 0x34 <== NOT EXECUTED
10c2c0: 900f str r0, [sp, #60] ; 0x3c <== NOT EXECUTED
10c2c2: f008 ecde blx 114c80 <memcpy> <== NOT EXECUTED
fd->name[checkedlen] = 0;
10c2c6: 9b0d ldr r3, [sp, #52] ; 0x34 <== NOT EXECUTED
10c2c8: f04f 0200 mov.w r2, #0 <== NOT EXECUTED
crc = crc32(0, fd->name, rd->nsize);
10c2cc: 990f ldr r1, [sp, #60] ; 0x3c <== NOT EXECUTED
10c2ce: 2000 movs r0, #0 <== NOT EXECUTED
fd->name[checkedlen] = 0;
10c2d0: 18fb adds r3, r7, r3 <== NOT EXECUTED
10c2d2: 755a strb r2, [r3, #21] <== NOT EXECUTED
crc = crc32(0, fd->name, rd->nsize);
10c2d4: 7f32 ldrb r2, [r6, #28] <== NOT EXECUTED
10c2d6: f7fe fcf1 bl 10acbc <cyg_crc32_accumulate> <== NOT EXECUTED
if (crc != je32_to_cpu(rd->name_crc)) {
10c2da: 6a73 ldr r3, [r6, #36] ; 0x24 <== NOT EXECUTED
10c2dc: 4298 cmp r0, r3 <== NOT EXECUTED
10c2de: d041 beq.n 10c364 <jffs2_scan_medium+0x89c> <== NOT EXECUTED
pr_notice("%s(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
10c2e0: 4652 mov r2, sl <== NOT EXECUTED
10c2e2: 990c ldr r1, [sp, #48] ; 0x30 <== NOT EXECUTED
10c2e4: 9000 str r0, [sp, #0] <== NOT EXECUTED
10c2e6: 980a ldr r0, [sp, #40] ; 0x28 <== NOT EXECUTED
10c2e8: f7ff fb52 bl 10b990 <jffs2_printk> <== NOT EXECUTED
__func__, ofs, je32_to_cpu(rd->name_crc), crc);
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);
10c2ec: 4638 mov r0, r7 <== NOT EXECUTED
10c2ee: f7fb f917 bl 107520 <jffs2_free_full_dirent> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
10c2f2: 6872 ldr r2, [r6, #4] <== NOT EXECUTED
10c2f4: e6bd b.n 10c072 <jffs2_scan_medium+0x5aa> <== NOT EXECUTED
10c2f6: 4656 mov r6, sl <== NOT EXECUTED
10c2f8: e48f b.n 10bc1a <jffs2_scan_medium+0x152> <== NOT EXECUTED
10c2fa: f5b0 4f40 cmp.w r0, #49152 ; 0xc000 <== NOT EXECUTED
10c2fe: d1fa bne.n 10c2f6 <jffs2_scan_medium+0x82e> <== NOT EXECUTED
pr_notice("Incompatible feature node (0x%04x) found at offset 0x%08x\n",
10c300: f249 10d4 movw r0, #37332 ; 0x91d4 <== NOT EXECUTED
10c304: 4652 mov r2, sl <== NOT EXECUTED
10c306: f2c0 0011 movt r0, #17 <== NOT EXECUTED
return -EINVAL;
10c30a: f06f 0b15 mvn.w fp, #21 <== NOT EXECUTED
pr_notice("Incompatible feature node (0x%04x) found at offset 0x%08x\n",
10c30e: f7ff fb3f bl 10b990 <jffs2_printk> <== NOT EXECUTED
if (ret < 0)
10c312: e5dd b.n 10bed0 <jffs2_scan_medium+0x408> <== NOT EXECUTED
pr_notice("Read-only compatible feature node (0x%04x) found at offset 0x%08x\n",
10c314: f249 1084 movw r0, #37252 ; 0x9184 <== NOT EXECUTED
10c318: 4652 mov r2, sl <== NOT EXECUTED
10c31a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10c31e: f7ff fb37 bl 10b990 <jffs2_printk> <== NOT EXECUTED
c->flags |= JFFS2_SB_FLAG_RO;
10c322: f8d8 300c ldr.w r3, [r8, #12] <== NOT EXECUTED
10c326: f043 0301 orr.w r3, r3, #1 <== NOT EXECUTED
10c32a: f8c8 300c str.w r3, [r8, #12] <== NOT EXECUTED
if (!(jffs2_is_readonly(c)))
10c32e: f898 30ec ldrb.w r3, [r8, #236] ; 0xec <== NOT EXECUTED
10c332: 2b00 cmp r3, #0 <== NOT EXECUTED
10c334: f47f af12 bne.w 10c15c <jffs2_scan_medium+0x694> <== NOT EXECUTED
return -EROFS;
10c338: f06f 0b1d mvn.w fp, #29 <== NOT EXECUTED
if (ret < 0)
10c33c: e5c8 b.n 10bed0 <jffs2_scan_medium+0x408> <== NOT EXECUTED
ic = jffs2_scan_make_ino_cache(c, ino);
10c33e: 4639 mov r1, r7 <== NOT EXECUTED
10c340: 4640 mov r0, r8 <== NOT EXECUTED
10c342: f7ff fb95 bl 10ba70 <jffs2_scan_make_ino_cache> <== NOT EXECUTED
if (!ic)
10c346: 2800 cmp r0, #0 <== NOT EXECUTED
10c348: f47f af6a bne.w 10c220 <jffs2_scan_medium+0x758> <== NOT EXECUTED
return -ENOMEM;
10c34c: f06f 0b0b mvn.w fp, #11 <== NOT EXECUTED
10c350: e5be b.n 10bed0 <jffs2_scan_medium+0x408> <== NOT EXECUTED
pr_err("Dirent at %08x has zeroes in name. Truncating to %d chars\n",
10c352: f249 004c movw r0, #36940 ; 0x904c <== NOT EXECUTED
10c356: 461a mov r2, r3 <== NOT EXECUTED
10c358: 4651 mov r1, sl <== NOT EXECUTED
10c35a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10c35e: f7ff fb17 bl 10b990 <jffs2_printk> <== NOT EXECUTED
10c362: e7a3 b.n 10c2ac <jffs2_scan_medium+0x7e4> <== NOT EXECUTED
/* 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)))))
return err;
return 0;
}
ic = jffs2_scan_make_ino_cache(c, je32_to_cpu(rd->pino));
10c364: 68f1 ldr r1, [r6, #12] <== NOT EXECUTED
10c366: 4640 mov r0, r8 <== NOT EXECUTED
10c368: f7ff fb82 bl 10ba70 <jffs2_scan_make_ino_cache> <== NOT EXECUTED
if (!ic) {
10c36c: 900e str r0, [sp, #56] ; 0x38 <== NOT EXECUTED
10c36e: 2800 cmp r0, #0 <== NOT EXECUTED
10c370: d03e beq.n 10c3f0 <jffs2_scan_medium+0x928> <== NOT EXECUTED
jffs2_free_full_dirent(fd);
return -ENOMEM;
}
fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
10c372: 6973 ldr r3, [r6, #20] <== NOT EXECUTED
10c374: 4621 mov r1, r4 <== NOT EXECUTED
10c376: 9a0e ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED
10c378: 4640 mov r0, r8 <== NOT EXECUTED
10c37a: 2b00 cmp r3, #0 <== NOT EXECUTED
PAD(je32_to_cpu(rd->totlen)), ic);
10c37c: 6873 ldr r3, [r6, #4] <== NOT EXECUTED
fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
10c37e: 9200 str r2, [sp, #0] <== NOT EXECUTED
10c380: bf14 ite ne <== NOT EXECUTED
10c382: 2202 movne r2, #2 <== NOT EXECUTED
10c384: 2203 moveq r2, #3 <== NOT EXECUTED
PAD(je32_to_cpu(rd->totlen)), ic);
10c386: 3303 adds r3, #3 <== NOT EXECUTED
fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
10c388: ea42 020a orr.w r2, r2, sl <== NOT EXECUTED
10c38c: f023 0303 bic.w r3, r3, #3 <== NOT EXECUTED
10c390: f7fb fcbe bl 107d10 <jffs2_link_node_ref> <== NOT EXECUTED
fd->next = NULL;
10c394: 2300 movs r3, #0 <== NOT EXECUTED
fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
10c396: 6038 str r0, [r7, #0] <== NOT EXECUTED
fd->next = NULL;
10c398: 607b str r3, [r7, #4] <== NOT EXECUTED
fd->version = je32_to_cpu(rd->version);
10c39a: 6933 ldr r3, [r6, #16] <== NOT EXECUTED
10c39c: 60bb str r3, [r7, #8] <== NOT EXECUTED
fd->ino = je32_to_cpu(rd->ino);
10c39e: 6973 ldr r3, [r6, #20] <== NOT EXECUTED
10c3a0: 60fb str r3, [r7, #12] <== NOT EXECUTED
while (len--) {
10c3a2: 9b0d ldr r3, [sp, #52] ; 0x34 <== NOT EXECUTED
10c3a4: b153 cbz r3, 10c3bc <jffs2_scan_medium+0x8f4> <== NOT EXECUTED
10c3a6: 9a0f ldr r2, [sp, #60] ; 0x3c <== NOT EXECUTED
10c3a8: 3315 adds r3, #21 <== NOT EXECUTED
uint32_t hash = 0;
10c3aa: 2100 movs r1, #0 <== NOT EXECUTED
10c3ac: 443b add r3, r7 <== NOT EXECUTED
hash ^= *(name++);
10c3ae: f812 0b01 ldrb.w r0, [r2], #1 <== NOT EXECUTED
while (len--) {
10c3b2: 429a cmp r2, r3 <== NOT EXECUTED
hash ^= *(name++);
10c3b4: ea80 7131 eor.w r1, r0, r1, ror #28 <== NOT EXECUTED
while (len--) {
10c3b8: d1f9 bne.n 10c3ae <jffs2_scan_medium+0x8e6> <== NOT EXECUTED
10c3ba: 910d str r1, [sp, #52] ; 0x34 <== NOT EXECUTED
fd->nhash = full_name_hash(NULL, fd->name, checkedlen);
10c3bc: 9b0d ldr r3, [sp, #52] ; 0x34 <== NOT EXECUTED
fd->type = rd->type;
jffs2_add_fd_to_list(c, fd, &ic->scan_dents);
10c3be: 4639 mov r1, r7 <== NOT EXECUTED
10c3c0: 9a0e ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED
10c3c2: 4640 mov r0, r8 <== NOT EXECUTED
fd->nhash = full_name_hash(NULL, fd->name, checkedlen);
10c3c4: 613b str r3, [r7, #16] <== NOT EXECUTED
fd->type = rd->type;
10c3c6: 7f73 ldrb r3, [r6, #29] <== NOT EXECUTED
10c3c8: 753b strb r3, [r7, #20] <== NOT EXECUTED
jffs2_add_fd_to_list(c, fd, &ic->scan_dents);
10c3ca: f7fb f973 bl 1076b4 <jffs2_add_fd_to_list> <== NOT EXECUTED
if (err) return err;
10c3ce: e65a b.n 10c086 <jffs2_scan_medium+0x5be> <== NOT EXECUTED
return -ENOMEM;
10c3d0: f06f 0b0b mvn.w fp, #11 <== NOT EXECUTED
10c3d4: e57f b.n 10bed6 <jffs2_scan_medium+0x40e> <== NOT EXECUTED
jffs2_link_node_ref(c, jeb, ofs | REF_NORMAL, c->cleanmarker_size, NULL);
10c3d6: 9200 str r2, [sp, #0] <== NOT EXECUTED
10c3d8: 4621 mov r1, r4 <== NOT EXECUTED
10c3da: f04a 0203 orr.w r2, sl, #3 <== NOT EXECUTED
10c3de: 4640 mov r0, r8 <== NOT EXECUTED
10c3e0: f7fb fc96 bl 107d10 <jffs2_link_node_ref> <== NOT EXECUTED
ofs += PAD(c->cleanmarker_size);
10c3e4: f8d8 3014 ldr.w r3, [r8, #20] <== NOT EXECUTED
10c3e8: 3303 adds r3, #3 <== NOT EXECUTED
10c3ea: f023 0203 bic.w r2, r3, #3 <== NOT EXECUTED
10c3ee: e64e b.n 10c08e <jffs2_scan_medium+0x5c6> <== NOT EXECUTED
jffs2_free_full_dirent(fd);
10c3f0: 4638 mov r0, r7 <== NOT EXECUTED
return -ENOMEM;
10c3f2: f06f 0b0b mvn.w fp, #11 <== NOT EXECUTED
jffs2_free_full_dirent(fd);
10c3f6: f7fb f893 bl 107520 <jffs2_free_full_dirent> <== NOT EXECUTED
if (err) return err;
10c3fa: e569 b.n 10bed0 <jffs2_scan_medium+0x408> <== NOT EXECUTED
pr_warn("%s(): unknown block state\n", __func__);
10c3fc: f249 3168 movw r1, #37736 ; 0x9368 <== NOT EXECUTED
10c400: f249 201c movw r0, #37404 ; 0x921c <== NOT EXECUTED
10c404: f2c0 0111 movt r1, #17 <== NOT EXECUTED
10c408: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10c40c: f7ff fac0 bl 10b990 <jffs2_printk> <== NOT EXECUTED
BUG();
10c410: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
10c414: f249 3268 movw r2, #37736 ; 0x9368 <== NOT EXECUTED
10c418: f249 2044 movw r0, #37444 ; 0x9244 <== NOT EXECUTED
10c41c: f2c0 0311 movt r3, #17 <== NOT EXECUTED
10c420: f2c0 0211 movt r2, #17 <== NOT EXECUTED
10c424: 21f1 movs r1, #241 ; 0xf1 <== NOT EXECUTED
10c426: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10c42a: f000 f921 bl 10c670 <__assert_func> <== NOT EXECUTED
10c42e: bf00 nop
001086a4 <jffs2_thread_should_wake>:
int ret = 0;
uint32_t dirty;
int nr_very_dirty = 0;
struct jffs2_eraseblock *jeb;
if (!list_empty(&c->erase_complete_list) ||
1086a4: f8d0 10a0 ldr.w r1, [r0, #160] ; 0xa0
1086a8: f100 02a0 add.w r2, r0, #160 ; 0xa0
1086ac: 4291 cmp r1, r2
1086ae: d001 beq.n 1086b4 <jffs2_thread_should_wake+0x10> <== NEVER TAKEN
!list_empty(&c->erase_pending_list))
return 1;
1086b0: 2001 movs r0, #1
1086b2: 4770 bx lr
if (!list_empty(&c->erase_complete_list) ||
1086b4: f8d0 1098 ldr.w r1, [r0, #152] ; 0x98
!list_empty(&c->erase_pending_list))
1086b8: f100 0298 add.w r2, r0, #152 ; 0x98
1086bc: 4603 mov r3, r0
if (!list_empty(&c->erase_complete_list) ||
1086be: 4291 cmp r1, r2
1086c0: d1f6 bne.n 1086b0 <jffs2_thread_should_wake+0xc>
if (c->unchecked_size) {
1086c2: 6b80 ldr r0, [r0, #56] ; 0x38
1086c4: 2800 cmp r0, #0
1086c6: d1f3 bne.n 1086b0 <jffs2_thread_should_wake+0xc> <== ALWAYS TAKEN
* Blocks on erasable_list are counted as dirty_size, but not in c->nr_erasing_blocks
* This helps us to force gc and pick eventually a clean block to spread the load.
*/
dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size;
if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger &&
1086c8: e9d3 210f ldrd r2, r1, [r3, #60] ; 0x3c
1086cc: f893 c046 ldrb.w ip, [r3, #70] ; 0x46
1086d0: 440a add r2, r1
1086d2: 4562 cmp r2, ip
1086d4: d21e bcs.n 108714 <jffs2_thread_should_wake+0x70> <== NEVER TAKEN
dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size;
1086d6: 6b58 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED
1086d8: 6a1a ldr r2, [r3, #32] <== NOT EXECUTED
{
1086da: b410 push {r4} <== NOT EXECUTED
dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size;
1086dc: 6adc ldr r4, [r3, #44] ; 0x2c <== NOT EXECUTED
1086de: 4422 add r2, r4 <== NOT EXECUTED
1086e0: fb00 2211 mls r2, r0, r1, r2 <== NOT EXECUTED
if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger &&
1086e4: 6cd8 ldr r0, [r3, #76] ; 0x4c <== NOT EXECUTED
(dirty > c->nospc_dirty_size))
ret = 1;
list_for_each_entry(jeb, &c->very_dirty_list, list) {
1086e6: 4619 mov r1, r3 <== NOT EXECUTED
if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger &&
1086e8: 4290 cmp r0, r2 <== NOT EXECUTED
list_for_each_entry(jeb, &c->very_dirty_list, list) {
1086ea: f851 2f68 ldr.w r2, [r1, #104]! <== NOT EXECUTED
if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger &&
1086ee: bf2c ite cs <== NOT EXECUTED
1086f0: 2000 movcs r0, #0 <== NOT EXECUTED
1086f2: 2001 movcc r0, #1 <== NOT EXECUTED
list_for_each_entry(jeb, &c->very_dirty_list, list) {
1086f4: 428a cmp r2, r1 <== NOT EXECUTED
1086f6: d00a beq.n 10870e <jffs2_thread_should_wake+0x6a> <== NOT EXECUTED
nr_very_dirty++;
if (nr_very_dirty == c->vdirty_blocks_gctrigger) {
1086f8: f893 c049 ldrb.w ip, [r3, #73] ; 0x49 <== NOT EXECUTED
int nr_very_dirty = 0;
1086fc: 2300 movs r3, #0 <== NOT EXECUTED
1086fe: e002 b.n 108706 <jffs2_thread_should_wake+0x62> <== NOT EXECUTED
list_for_each_entry(jeb, &c->very_dirty_list, list) {
108700: 6812 ldr r2, [r2, #0] <== NOT EXECUTED
108702: 428a cmp r2, r1 <== NOT EXECUTED
108704: d003 beq.n 10870e <jffs2_thread_should_wake+0x6a> <== NOT EXECUTED
nr_very_dirty++;
108706: 3301 adds r3, #1 <== NOT EXECUTED
if (nr_very_dirty == c->vdirty_blocks_gctrigger) {
108708: 459c cmp ip, r3 <== NOT EXECUTED
10870a: d1f9 bne.n 108700 <jffs2_thread_should_wake+0x5c> <== NOT EXECUTED
return 1;
10870c: 2001 movs r0, #1 <== NOT EXECUTED
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;
}
10870e: f85d 4b04 ldr.w r4, [sp], #4 <== NOT EXECUTED
108712: 4770 bx lr <== NOT EXECUTED
list_for_each_entry(jeb, &c->very_dirty_list, list) {
108714: 4619 mov r1, r3
108716: f851 2f68 ldr.w r2, [r1, #104]!
10871a: 428a cmp r2, r1
10871c: d009 beq.n 108732 <jffs2_thread_should_wake+0x8e> <== ALWAYS TAKEN
if (nr_very_dirty == c->vdirty_blocks_gctrigger) {
10871e: f893 c049 ldrb.w ip, [r3, #73] ; 0x49
int nr_very_dirty = 0;
108722: 2300 movs r3, #0
nr_very_dirty++;
108724: 3301 adds r3, #1
if (nr_very_dirty == c->vdirty_blocks_gctrigger) {
108726: 459c cmp ip, r3
108728: d0c2 beq.n 1086b0 <jffs2_thread_should_wake+0xc> <== ALWAYS TAKEN
list_for_each_entry(jeb, &c->very_dirty_list, list) {
10872a: 6812 ldr r2, [r2, #0]
10872c: 428a cmp r2, r1
10872e: d1f9 bne.n 108724 <jffs2_thread_should_wake+0x80>
108730: 4770 bx lr
}
108732: 4770 bx lr <== NOT EXECUTED
00107730 <jffs2_truncate_fragtree>:
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;
107730: 680b ldr r3, [r1, #0]
{
107732: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
107736: 460e mov r6, r1
107738: 4690 mov r8, r2
while(next) {
10773a: 4607 mov r7, r0
struct jffs2_node_frag *prev = NULL;
10773c: 2400 movs r4, #0
while(next) {
10773e: b36b cbz r3, 10779c <jffs2_truncate_fragtree+0x6c>
frag = rb_entry(next, struct jffs2_node_frag, rb);
if (frag->ofs + frag->size <= offset) {
107740: e9d3 1505 ldrd r1, r5, [r3, #20]
107744: 4429 add r1, r5
107746: 4588 cmp r8, r1
107748: d32e bcc.n 1077a8 <jffs2_truncate_fragtree+0x78>
/* Remember the closest smaller match on the way down */
if (!prev || frag->ofs > prev->ofs)
10774a: 2c00 cmp r4, #0
10774c: d032 beq.n 1077b4 <jffs2_truncate_fragtree+0x84>
10774e: 69a2 ldr r2, [r4, #24]
107750: 4295 cmp r5, r2
107752: bf88 it hi
107754: 461c movhi r4, r3
prev = frag;
next = frag->rb.rb_right;
107756: 685b ldr r3, [r3, #4]
while(next) {
107758: 2b00 cmp r3, #0
10775a: d1f1 bne.n 107740 <jffs2_truncate_fragtree+0x10>
if (frag && frag->ofs != size) {
10775c: b1f4 cbz r4, 10779c <jffs2_truncate_fragtree+0x6c>
10775e: 69a5 ldr r5, [r4, #24]
107760: 4545 cmp r5, r8
107762: d018 beq.n 107796 <jffs2_truncate_fragtree+0x66> <== ALWAYS TAKEN
if (frag->ofs+frag->size > size) {
107764: 6963 ldr r3, [r4, #20]
107766: 442b add r3, r5
107768: 4543 cmp r3, r8
10776a: d84a bhi.n 107802 <jffs2_truncate_fragtree+0xd2> <== ALWAYS TAKEN
return _RBTree_Successor( node );
10776c: 4620 mov r0, r4
10776e: f009 faf9 bl 110d64 <_RBTree_Successor>
while (frag && frag->ofs >= size) {
107772: 4604 mov r4, r0
107774: b190 cbz r0, 10779c <jffs2_truncate_fragtree+0x6c>
107776: 6985 ldr r5, [r0, #24] <== NOT EXECUTED
107778: e00d b.n 107796 <jffs2_truncate_fragtree+0x66> <== NOT EXECUTED
10777a: f009 faf3 bl 110d64 <_RBTree_Successor>
_RBTree_Extract( (RBTree_Control *) root, node );
10777e: 4621 mov r1, r4
return _RBTree_Successor( node );
107780: 4605 mov r5, r0
_RBTree_Extract( (RBTree_Control *) root, node );
107782: 4630 mov r0, r6
107784: f009 f90c bl 1109a0 <_RBTree_Extract>
jffs2_obsolete_node_frag(c, frag);
107788: 4621 mov r1, r4
10778a: 4638 mov r0, r7
while (frag && frag->ofs >= size) {
10778c: 462c mov r4, r5
jffs2_obsolete_node_frag(c, frag);
10778e: f7ff ff2b bl 1075e8 <jffs2_obsolete_node_frag>
while (frag && frag->ofs >= size) {
107792: b11d cbz r5, 10779c <jffs2_truncate_fragtree+0x6c>
107794: 69ad ldr r5, [r5, #24]
107796: 45a8 cmp r8, r5
return _RBTree_Successor( node );
107798: 4620 mov r0, r4
10779a: d9ee bls.n 10777a <jffs2_truncate_fragtree+0x4a> <== NEVER TAKEN
if (size == 0)
10779c: f1b8 0f00 cmp.w r8, #0
1077a0: d10a bne.n 1077b8 <jffs2_truncate_fragtree+0x88>
return 0;
1077a2: 2000 movs r0, #0
}
1077a4: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
} else if (frag->ofs > offset) {
1077a8: 45a8 cmp r8, r5
1077aa: d21f bcs.n 1077ec <jffs2_truncate_fragtree+0xbc>
next = frag->rb.rb_left;
1077ac: 681b ldr r3, [r3, #0]
while(next) {
1077ae: 2b00 cmp r3, #0
1077b0: d1c6 bne.n 107740 <jffs2_truncate_fragtree+0x10> <== NEVER TAKEN
1077b2: e7d3 b.n 10775c <jffs2_truncate_fragtree+0x2c> <== NOT EXECUTED
1077b4: 461c mov r4, r3
1077b6: e7ce b.n 107756 <jffs2_truncate_fragtree+0x26>
return _RBTree_Maximum( (RBTree_Control *) root );
1077b8: 4630 mov r0, r6
1077ba: f009 fac9 bl 110d50 <_RBTree_Maximum>
1077be: 4602 mov r2, r0
1077c0: 2800 cmp r0, #0
1077c2: d0ee beq.n 1077a2 <jffs2_truncate_fragtree+0x72> <== ALWAYS TAKEN
if (frag->ofs + frag->size < size)
1077c4: e9d0 3105 ldrd r3, r1, [r0, #20]
1077c8: 18c8 adds r0, r1, r3
1077ca: 4540 cmp r0, r8
1077cc: d3ea bcc.n 1077a4 <jffs2_truncate_fragtree+0x74> <== ALWAYS TAKEN
if (frag->node && (frag->ofs & (PAGE_SIZE - 1)) == 0) {
1077ce: 6913 ldr r3, [r2, #16]
1077d0: b1a3 cbz r3, 1077fc <jffs2_truncate_fragtree+0xcc>
1077d2: f3c1 010b ubfx r1, r1, #0, #12
1077d6: b989 cbnz r1, 1077fc <jffs2_truncate_fragtree+0xcc>
frag->node->raw->flash_offset = ref_offset(frag->node->raw) | REF_PRISTINE;
1077d8: 681a ldr r2, [r3, #0]
1077da: 4640 mov r0, r8
1077dc: 6853 ldr r3, [r2, #4]
1077de: f023 0303 bic.w r3, r3, #3
1077e2: f043 0302 orr.w r3, r3, #2
1077e6: 6053 str r3, [r2, #4]
}
1077e8: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
if (frag && frag->ofs != size) {
1077ec: bf08 it eq
1077ee: 461c moveq r4, r3
1077f0: d0d1 beq.n 107796 <jffs2_truncate_fragtree+0x66>
frag->size = size - frag->ofs;
1077f2: eba8 0505 sub.w r5, r8, r5
1077f6: 461c mov r4, r3
1077f8: 615d str r5, [r3, #20]
1077fa: e7b7 b.n 10776c <jffs2_truncate_fragtree+0x3c>
1077fc: 4640 mov r0, r8
}
1077fe: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
107802: 4623 mov r3, r4 <== NOT EXECUTED
107804: e7f5 b.n 1077f2 <jffs2_truncate_fragtree+0xc2> <== NOT EXECUTED
107806: bf00 nop
0010afd8 <jffs2_unlink>:
/***********************************************************************/
int jffs2_unlink(struct _inode *dir_i, struct _inode *d_inode, const unsigned char *d_name, size_t d_namelen)
{
10afd8: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
10afdc: 4605 mov r5, r0 <== NOT EXECUTED
struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
10afde: f8d0 8040 ldr.w r8, [r0, #64] ; 0x40 <== NOT EXECUTED
{
10afe2: b082 sub sp, #8 <== NOT EXECUTED
10afe4: 460c mov r4, r1 <== NOT EXECUTED
struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
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());
10afe6: 2000 movs r0, #0 <== NOT EXECUTED
{
10afe8: 4616 mov r6, r2 <== NOT EXECUTED
10afea: 461f mov r7, r3 <== NOT EXECUTED
d_namelen, dead_f, get_seconds());
10afec: f00a fc44 bl 115878 <time> <== NOT EXECUTED
ret = jffs2_do_unlink(c, dir_f, (const char *)d_name,
10aff0: f105 0148 add.w r1, r5, #72 ; 0x48 <== NOT EXECUTED
struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(d_inode);
10aff4: f104 0548 add.w r5, r4, #72 ; 0x48 <== NOT EXECUTED
ret = jffs2_do_unlink(c, dir_f, (const char *)d_name,
10aff8: 463b mov r3, r7 <== NOT EXECUTED
10affa: 9001 str r0, [sp, #4] <== NOT EXECUTED
10affc: 4632 mov r2, r6 <== NOT EXECUTED
10affe: 4640 mov r0, r8 <== NOT EXECUTED
10b000: 9500 str r5, [sp, #0] <== NOT EXECUTED
10b002: f7ff fb1b bl 10a63c <jffs2_do_unlink> <== NOT EXECUTED
if (dead_f->inocache)
10b006: 6de3 ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED
10b008: b10b cbz r3, 10b00e <jffs2_unlink+0x36> <== NOT EXECUTED
d_inode->i_nlink = dead_f->inocache->pino_nlink;
10b00a: 695b ldr r3, [r3, #20] <== NOT EXECUTED
10b00c: 81a3 strh r3, [r4, #12] <== NOT EXECUTED
return ret;
}
10b00e: b002 add sp, #8 <== NOT EXECUTED
10b010: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
0010a0e0 <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)
{
10a0e0: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
10a0e4: b091 sub sp, #68 ; 0x44
10a0e6: 9e1a ldr r6, [sp, #104] ; 0x68
10a0e8: 4607 mov r7, r0
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) {
10a0ea: 4618 mov r0, r3
{
10a0ec: 4698 mov r8, r3
10a0ee: 9105 str r1, [sp, #20]
10a0f0: 4614 mov r4, r2
if (strnlen(name, namelen) != namelen) {
10a0f2: 4631 mov r1, r6
10a0f4: f00b fbae bl 115854 <strnlen>
10a0f8: 42b0 cmp r0, r6
10a0fa: d018 beq.n 10a12e <jffs2_write_dirent+0x4e> <== NEVER 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");
10a0fc: f248 1024 movw r0, #33060 ; 0x8124 <== NOT EXECUTED
10a100: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10a104: f7ff fe8c bl 109e20 <jffs2_printk> <== NOT EXECUTED
pr_crit("Directory inode #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x\n",
10a108: 6a65 ldr r5, [r4, #36] ; 0x24 <== NOT EXECUTED
10a10a: 4643 mov r3, r8 <== NOT EXECUTED
10a10c: 6960 ldr r0, [r4, #20] <== NOT EXECUTED
10a10e: 4642 mov r2, r8 <== NOT EXECUTED
10a110: 68e1 ldr r1, [r4, #12] <== NOT EXECUTED
10a112: e9cd 0500 strd r0, r5, [sp] <== NOT EXECUTED
10a116: f248 106c movw r0, #33132 ; 0x816c <== NOT EXECUTED
10a11a: f2c0 0011 movt r0, #17 <== 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);
10a11e: f06f 0504 mvn.w r5, #4 <== NOT EXECUTED
pr_crit("Directory inode #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x\n",
10a122: f7ff fe7d bl 109e20 <jffs2_printk> <== NOT EXECUTED
if (retried) {
jffs2_dbg_acct_sanity_check(c,NULL);
}
return fd;
}
10a126: 4628 mov r0, r5
10a128: b011 add sp, #68 ; 0x44
10a12a: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
vecs[0].iov_len = sizeof(*rd);
10a12e: 2328 movs r3, #40 ; 0x28
fd = jffs2_alloc_full_dirent(namelen+1);
10a130: 1c70 adds r0, r6, #1
vecs[0].iov_base = rd;
10a132: 940c str r4, [sp, #48] ; 0x30
vecs[1].iov_len = namelen;
10a134: e9cd 860e strd r8, r6, [sp, #56] ; 0x38
vecs[0].iov_len = sizeof(*rd);
10a138: 930d str r3, [sp, #52] ; 0x34
fd = jffs2_alloc_full_dirent(namelen+1);
10a13a: f7fd f9ed bl 107518 <jffs2_alloc_full_dirent>
if (!fd)
10a13e: 4605 mov r5, r0
10a140: 2800 cmp r0, #0
10a142: f000 80c0 beq.w 10a2c6 <jffs2_write_dirent+0x1e6> <== ALWAYS TAKEN
fd->version = je32_to_cpu(rd->version);
10a146: 6923 ldr r3, [r4, #16]
10a148: 6083 str r3, [r0, #8]
fd->ino = je32_to_cpu(rd->ino);
10a14a: 6963 ldr r3, [r4, #20]
10a14c: 60c3 str r3, [r0, #12]
while (len--) {
10a14e: 2e00 cmp r6, #0
10a150: f000 80e7 beq.w 10a322 <jffs2_write_dirent+0x242> <== ALWAYS TAKEN
10a154: eb08 0306 add.w r3, r8, r6
10a158: 4642 mov r2, r8
uint32_t hash = 0;
10a15a: 2100 movs r1, #0
hash ^= *(name++);
10a15c: f812 0b01 ldrb.w r0, [r2], #1
while (len--) {
10a160: 429a cmp r2, r3
hash ^= *(name++);
10a162: ea80 7131 eor.w r1, r0, r1, ror #28
while (len--) {
10a166: d1f9 bne.n 10a15c <jffs2_write_dirent+0x7c>
fd->nhash = full_name_hash(NULL, name, namelen);
10a168: 6129 str r1, [r5, #16]
memcpy(fd->name, name, namelen);
10a16a: 4632 mov r2, r6
fd->type = rd->type;
10a16c: 7f63 ldrb r3, [r4, #29]
memcpy(fd->name, name, namelen);
10a16e: f105 0015 add.w r0, r5, #21
10a172: 4641 mov r1, r8
pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n",
10a174: f246 5b20 movw fp, #25888 ; 0x6520
10a178: f2c0 0b11 movt fp, #17
pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
10a17c: f248 0adc movw sl, #32988 ; 0x80dc
fd->type = rd->type;
10a180: 752b strb r3, [r5, #20]
pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
10a182: f2c0 0a11 movt sl, #17
memcpy(fd->name, name, namelen);
10a186: f00a ed7c blx 114c80 <memcpy>
fd->name[namelen]=0;
10a18a: 2202 movs r2, #2
10a18c: 9507 str r5, [sp, #28]
10a18e: 9206 str r2, [sp, #24]
10a190: 46b1 mov r9, r6
10a192: 19aa adds r2, r5, r6
10a194: 465d mov r5, fp
10a196: 46a3 mov fp, r4
10a198: 2300 movs r3, #0
int retried = 0;
10a19a: 9308 str r3, [sp, #32]
fd->name[namelen]=0;
10a19c: 7553 strb r3, [r2, #21]
if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) {
10a19e: 9a1b ldr r2, [sp, #108] ; 0x6c
flash_ofs = write_ofs(c);
10a1a0: 6dbb ldr r3, [r7, #88] ; 0x58
10a1a2: 6b7c ldr r4, [r7, #52] ; 0x34
if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) {
10a1a4: 2a02 cmp r2, #2
flash_ofs = write_ofs(c);
10a1a6: 68de ldr r6, [r3, #12]
10a1a8: 6a1b ldr r3, [r3, #32]
if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) {
10a1aa: d027 beq.n 10a1fc <jffs2_write_dirent+0x11c>
10a1ac: 9a05 ldr r2, [sp, #20]
10a1ae: f8db 1010 ldr.w r1, [fp, #16]
10a1b2: 6812 ldr r2, [r2, #0]
10a1b4: 4291 cmp r1, r2
10a1b6: d221 bcs.n 10a1fc <jffs2_write_dirent+0x11c> <== NEVER TAKEN
BUG_ON(!retried);
10a1b8: 9908 ldr r1, [sp, #32] <== NOT EXECUTED
10a1ba: b979 cbnz r1, 10a1dc <jffs2_write_dirent+0xfc> <== NOT EXECUTED
10a1bc: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
10a1c0: f248 224c movw r2, #33356 ; 0x824c <== NOT EXECUTED
10a1c4: f248 00b0 movw r0, #32944 ; 0x80b0 <== NOT EXECUTED
10a1c8: f2c0 0311 movt r3, #17 <== NOT EXECUTED
10a1cc: f2c0 0211 movt r2, #17 <== NOT EXECUTED
10a1d0: f240 1105 movw r1, #261 ; 0x105 <== NOT EXECUTED
10a1d4: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10a1d8: f002 fa4a bl 10c670 <__assert_func> <== NOT EXECUTED
rd->version = cpu_to_je32(++f->highest_version);
10a1dc: 9309 str r3, [sp, #36] ; 0x24 <== NOT EXECUTED
10a1de: 3201 adds r2, #1 <== NOT EXECUTED
10a1e0: 9b05 ldr r3, [sp, #20] <== NOT EXECUTED
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
10a1e2: 4659 mov r1, fp <== NOT EXECUTED
10a1e4: 2000 movs r0, #0 <== NOT EXECUTED
rd->version = cpu_to_je32(++f->highest_version);
10a1e6: 601a str r2, [r3, #0] <== NOT EXECUTED
fd->version = je32_to_cpu(rd->version);
10a1e8: 9b07 ldr r3, [sp, #28] <== NOT EXECUTED
rd->version = cpu_to_je32(++f->highest_version);
10a1ea: f8cb 2010 str.w r2, [fp, #16] <== NOT EXECUTED
fd->version = je32_to_cpu(rd->version);
10a1ee: 609a str r2, [r3, #8] <== NOT EXECUTED
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
10a1f0: 2220 movs r2, #32 <== NOT EXECUTED
10a1f2: f000 fd63 bl 10acbc <cyg_crc32_accumulate> <== NOT EXECUTED
10a1f6: 9b09 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
10a1f8: f8cb 0020 str.w r0, [fp, #32] <== NOT EXECUTED
flash_ofs = write_ofs(c);
10a1fc: 4434 add r4, r6
ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen,
10a1fe: 2202 movs r2, #2
flash_ofs = write_ofs(c);
10a200: 1ae4 subs r4, r4, r3
ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen,
10a202: ab0a add r3, sp, #40 ; 0x28
10a204: 9302 str r3, [sp, #8]
10a206: 2300 movs r3, #0
10a208: 9301 str r3, [sp, #4]
10a20a: a90c add r1, sp, #48 ; 0x30
10a20c: 4638 mov r0, r7
10a20e: 9400 str r4, [sp, #0]
10a210: f001 fb10 bl 10b834 <jffs2_flash_direct_writev>
if (ret || (retlen != sizeof(*rd) + namelen)) {
10a214: f109 0828 add.w r8, r9, #40 ; 0x28
10a218: 9b0a ldr r3, [sp, #40] ; 0x28
10a21a: 4606 mov r6, r0
10a21c: b908 cbnz r0, 10a222 <jffs2_write_dirent+0x142>
10a21e: 4543 cmp r3, r8
10a220: d054 beq.n 10a2cc <jffs2_write_dirent+0x1ec> <== NEVER TAKEN
pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
10a222: 9300 str r3, [sp, #0] <== NOT EXECUTED
10a224: 4622 mov r2, r4 <== NOT EXECUTED
10a226: 4633 mov r3, r6 <== NOT EXECUTED
10a228: 4641 mov r1, r8 <== NOT EXECUTED
10a22a: 4650 mov r0, sl <== NOT EXECUTED
10a22c: f7ff fdf8 bl 109e20 <jffs2_printk> <== NOT EXECUTED
if (retlen) {
10a230: 9b0a ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED
10a232: bb73 cbnz r3, 10a292 <jffs2_write_dirent+0x1b2> <== NOT EXECUTED
pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n",
10a234: 4621 mov r1, r4 <== NOT EXECUTED
10a236: 4628 mov r0, r5 <== NOT EXECUTED
10a238: f7ff fdf2 bl 109e20 <jffs2_printk> <== NOT EXECUTED
if (!retried) {
10a23c: 9b06 ldr r3, [sp, #24] <== NOT EXECUTED
10a23e: 2b01 cmp r3, #1 <== NOT EXECUTED
10a240: d034 beq.n 10a2ac <jffs2_write_dirent+0x1cc> <== NOT EXECUTED
struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
10a242: 6b79 ldr r1, [r7, #52] ; 0x34 <== NOT EXECUTED
10a244: 4620 mov r0, r4 <== NOT EXECUTED
10a246: f00a f98b bl 114560 <__udivsi3> <== NOT EXECUTED
10a24a: 6d7c ldr r4, [r7, #84] ; 0x54 <== NOT EXECUTED
10a24c: 2334 movs r3, #52 ; 0x34 <== NOT EXECUTED
ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &dummy,
10a24e: f109 0618 add.w r6, r9, #24 <== NOT EXECUTED
struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
10a252: fb03 4400 mla r4, r3, r0, r4 <== NOT EXECUTED
jffs2_dbg_acct_sanity_check(c,jeb);
10a256: 4638 mov r0, r7 <== NOT EXECUTED
10a258: 4621 mov r1, r4 <== NOT EXECUTED
10a25a: f000 fe19 bl 10ae90 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
if (alloc_mode == ALLOC_GC) {
10a25e: 9b1b ldr r3, [sp, #108] ; 0x6c <== NOT EXECUTED
10a260: 2b02 cmp r3, #2 <== NOT EXECUTED
10a262: d056 beq.n 10a312 <jffs2_write_dirent+0x232> <== NOT EXECUTED
jffs2_complete_reservation(c);
10a264: 4638 mov r0, r7 <== NOT EXECUTED
10a266: f7fd ff0b bl 108080 <jffs2_complete_reservation> <== NOT EXECUTED
ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &dummy,
10a26a: 9600 str r6, [sp, #0] <== NOT EXECUTED
10a26c: 4641 mov r1, r8 <== NOT EXECUTED
10a26e: 9b1b ldr r3, [sp, #108] ; 0x6c <== NOT EXECUTED
10a270: aa0b add r2, sp, #44 ; 0x2c <== NOT EXECUTED
10a272: 4638 mov r0, r7 <== NOT EXECUTED
10a274: f7fe f9ae bl 1085d4 <jffs2_reserve_space> <== NOT EXECUTED
10a278: 4606 mov r6, r0 <== NOT EXECUTED
if (!ret) {
10a27a: 2e00 cmp r6, #0 <== NOT EXECUTED
10a27c: d053 beq.n 10a326 <jffs2_write_dirent+0x246> <== NOT EXECUTED
jffs2_free_full_dirent(fd);
10a27e: 9d07 ldr r5, [sp, #28] <== NOT EXECUTED
10a280: 46b1 mov r9, r6 <== NOT EXECUTED
10a282: 4628 mov r0, r5 <== NOT EXECUTED
10a284: f7fd f94c bl 107520 <jffs2_free_full_dirent> <== NOT EXECUTED
return ERR_PTR(ret?ret:-EIO);
10a288: 464d mov r5, r9 <== NOT EXECUTED
}
10a28a: 4628 mov r0, r5 <== NOT EXECUTED
10a28c: b011 add sp, #68 ; 0x44 <== NOT EXECUTED
10a28e: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL);
10a292: f109 022b add.w r2, r9, #43 ; 0x2b <== NOT EXECUTED
10a296: 2300 movs r3, #0 <== NOT EXECUTED
10a298: f022 0203 bic.w r2, r2, #3 <== NOT EXECUTED
10a29c: f044 0101 orr.w r1, r4, #1 <== NOT EXECUTED
10a2a0: 4638 mov r0, r7 <== NOT EXECUTED
10a2a2: f7fd fe7f bl 107fa4 <jffs2_add_physical_node_ref> <== NOT EXECUTED
if (!retried) {
10a2a6: 9b06 ldr r3, [sp, #24] <== NOT EXECUTED
10a2a8: 2b01 cmp r3, #1 <== NOT EXECUTED
10a2aa: d1ca bne.n 10a242 <jffs2_write_dirent+0x162> <== NOT EXECUTED
jffs2_free_full_dirent(fd);
10a2ac: 9d07 ldr r5, [sp, #28] <== NOT EXECUTED
10a2ae: 46b1 mov r9, r6 <== NOT EXECUTED
10a2b0: 4628 mov r0, r5 <== NOT EXECUTED
return ERR_PTR(ret?ret:-EIO);
10a2b2: f06f 0504 mvn.w r5, #4 <== NOT EXECUTED
jffs2_free_full_dirent(fd);
10a2b6: f7fd f933 bl 107520 <jffs2_free_full_dirent> <== NOT EXECUTED
return ERR_PTR(ret?ret:-EIO);
10a2ba: 2e00 cmp r6, #0 <== NOT EXECUTED
10a2bc: d1e4 bne.n 10a288 <jffs2_write_dirent+0x1a8> <== NOT EXECUTED
}
10a2be: 4628 mov r0, r5 <== NOT EXECUTED
10a2c0: b011 add sp, #68 ; 0x44 <== NOT EXECUTED
10a2c2: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
return ERR_PTR(-ENOMEM);
10a2c6: f06f 050b mvn.w r5, #11 <== NOT EXECUTED
10a2ca: e72c b.n 10a126 <jffs2_write_dirent+0x46> <== NOT EXECUTED
fd->raw = jffs2_add_physical_node_ref(c, flash_ofs | dirent_node_state(rd),
10a2cc: f8cd 9068 str.w r9, [sp, #104] ; 0x68
10a2d0: 4681 mov r9, r0
10a2d2: f8db 3014 ldr.w r3, [fp, #20]
10a2d6: 4638 mov r0, r7
10a2d8: 9e1a ldr r6, [sp, #104] ; 0x68
10a2da: 9d07 ldr r5, [sp, #28]
10a2dc: 2b00 cmp r3, #0
10a2de: 9b05 ldr r3, [sp, #20]
10a2e0: bf14 ite ne
10a2e2: 2102 movne r1, #2
10a2e4: 2103 moveq r1, #3
PAD(sizeof(*rd)+namelen), f->inocache);
10a2e6: f106 022b add.w r2, r6, #43 ; 0x2b
fd->raw = jffs2_add_physical_node_ref(c, flash_ofs | dirent_node_state(rd),
10a2ea: 4321 orrs r1, r4
10a2ec: 695b ldr r3, [r3, #20]
10a2ee: f022 0203 bic.w r2, r2, #3
10a2f2: f7fd fe57 bl 107fa4 <jffs2_add_physical_node_ref>
if (IS_ERR(fd->raw)) {
10a2f6: f510 7f7a cmn.w r0, #1000 ; 0x3e8
fd->raw = jffs2_add_physical_node_ref(c, flash_ofs | dirent_node_state(rd),
10a2fa: 4603 mov r3, r0
10a2fc: 6028 str r0, [r5, #0]
if (IS_ERR(fd->raw)) {
10a2fe: d81a bhi.n 10a336 <jffs2_write_dirent+0x256> <== ALWAYS TAKEN
if (retried) {
10a300: 9b08 ldr r3, [sp, #32]
10a302: 2b00 cmp r3, #0
10a304: f43f af0f beq.w 10a126 <jffs2_write_dirent+0x46> <== NEVER TAKEN
jffs2_dbg_acct_sanity_check(c,NULL);
10a308: 4649 mov r1, r9 <== NOT EXECUTED
10a30a: 4638 mov r0, r7 <== NOT EXECUTED
10a30c: f000 fdc0 bl 10ae90 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
10a310: e709 b.n 10a126 <jffs2_write_dirent+0x46> <== NOT EXECUTED
ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &dummy,
10a312: 4633 mov r3, r6 <== NOT EXECUTED
10a314: 4641 mov r1, r8 <== NOT EXECUTED
10a316: aa0b add r2, sp, #44 ; 0x2c <== NOT EXECUTED
10a318: 4638 mov r0, r7 <== NOT EXECUTED
10a31a: f7fe f943 bl 1085a4 <jffs2_reserve_space_gc> <== NOT EXECUTED
10a31e: 4606 mov r6, r0 <== NOT EXECUTED
10a320: e7ab b.n 10a27a <jffs2_write_dirent+0x19a> <== NOT EXECUTED
uint32_t hash = 0;
10a322: 4631 mov r1, r6 <== NOT EXECUTED
10a324: e720 b.n 10a168 <jffs2_write_dirent+0x88> <== NOT EXECUTED
jffs2_dbg_acct_sanity_check(c,jeb);
10a326: 4621 mov r1, r4 <== NOT EXECUTED
10a328: 4638 mov r0, r7 <== NOT EXECUTED
10a32a: f000 fdb1 bl 10ae90 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
goto retry;
10a32e: 2301 movs r3, #1 <== NOT EXECUTED
10a330: 9306 str r3, [sp, #24] <== NOT EXECUTED
retried = 1;
10a332: 9308 str r3, [sp, #32] <== NOT EXECUTED
10a334: e733 b.n 10a19e <jffs2_write_dirent+0xbe> <== NOT EXECUTED
jffs2_free_full_dirent(fd);
10a336: 4628 mov r0, r5 <== NOT EXECUTED
return ERR_CAST(hold_err);
10a338: 461d mov r5, r3 <== NOT EXECUTED
jffs2_free_full_dirent(fd);
10a33a: f7fd f8f1 bl 107520 <jffs2_free_full_dirent> <== NOT EXECUTED
return ERR_CAST(hold_err);
10a33e: e6f2 b.n 10a126 <jffs2_write_dirent+0x46> <== NOT EXECUTED
00109ec8 <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)
{
109ec8: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
109ecc: b091 sub sp, #68 ; 0x44
BUG();
}
);
vecs[0].iov_base = ri;
vecs[0].iov_len = sizeof(*ri);
vecs[1].iov_base = (unsigned char *)data;
109ece: 930e str r3, [sp, #56] ; 0x38
{
109ed0: 461d mov r5, r3
109ed2: 4617 mov r7, r2
109ed4: 4604 mov r4, r0
vecs[1].iov_len = datalen;
109ed6: 9b1a ldr r3, [sp, #104] ; 0x68
{
109ed8: 9105 str r1, [sp, #20]
if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) {
109eda: 991a ldr r1, [sp, #104] ; 0x68
vecs[1].iov_len = datalen;
109edc: 930f str r3, [sp, #60] ; 0x3c
vecs[0].iov_len = sizeof(*ri);
109ede: 2344 movs r3, #68 ; 0x44
vecs[0].iov_base = ri;
109ee0: 920c str r2, [sp, #48] ; 0x30
if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) {
109ee2: 6852 ldr r2, [r2, #4]
109ee4: eb01 0903 add.w r9, r1, r3
{
109ee8: f8dd 806c ldr.w r8, [sp, #108] ; 0x6c
vecs[0].iov_len = sizeof(*ri);
109eec: 930d str r3, [sp, #52] ; 0x34
if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) {
109eee: 454a cmp r2, r9
109ef0: d00a beq.n 109f08 <jffs2_write_dnode+0x40> <== NEVER TAKEN
pr_warn("%s(): ri->totlen (0x%08x) != sizeof(*ri) (0x%08zx) + datalen (0x%08x)\n",
109ef2: f248 005c movw r0, #32860 ; 0x805c <== NOT EXECUTED
109ef6: 9100 str r1, [sp, #0] <== NOT EXECUTED
109ef8: f248 2160 movw r1, #33376 ; 0x8260 <== NOT EXECUTED
109efc: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109f00: f2c0 0111 movt r1, #17 <== NOT EXECUTED
109f04: f7ff ff8c bl 109e20 <jffs2_printk> <== NOT EXECUTED
__func__, je32_to_cpu(ri->totlen),
sizeof(*ri), datalen);
}
fn = jffs2_alloc_full_dnode();
109f08: f7fd fb0c bl 107524 <jffs2_alloc_full_dnode>
if (!fn)
109f0c: 9007 str r0, [sp, #28]
109f0e: 2800 cmp r0, #0
109f10: f000 809c beq.w 10a04c <jffs2_write_dnode+0x184> <== ALWAYS TAKEN
return ERR_PTR(-ENOMEM);
/* check number of valid vecs */
if (!datalen || !data)
cnt = 1;
109f14: 9b1a ldr r3, [sp, #104] ; 0x68
ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen,
(alloc_mode==ALLOC_GC)?0:f->inocache->ino);
if (ret || (retlen != sizeof(*ri) + datalen)) {
pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
109f16: f248 0adc movw sl, #32988 ; 0x80dc
109f1a: f2c0 0a11 movt sl, #17
retry:
109f1e: 2600 movs r6, #0
cnt = 1;
109f20: 2d00 cmp r5, #0
109f22: bf18 it ne
109f24: 2b00 cmpne r3, #0
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);
} else {
pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n",
109f26: f246 5320 movw r3, #25888 ; 0x6520
109f2a: f2c0 0311 movt r3, #17
109f2e: 9308 str r3, [sp, #32]
cnt = 1;
109f30: bf14 ite ne
109f32: 2302 movne r3, #2
109f34: 2301 moveq r3, #1
109f36: 9306 str r3, [sp, #24]
flash_ofs = write_ofs(c);
109f38: 6da3 ldr r3, [r4, #88] ; 0x58
if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) {
109f3a: f1b8 0f02 cmp.w r8, #2
flash_ofs = write_ofs(c);
109f3e: f8d4 b034 ldr.w fp, [r4, #52] ; 0x34
109f42: 68dd ldr r5, [r3, #12]
109f44: 6a1b ldr r3, [r3, #32]
if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) {
109f46: d020 beq.n 109f8a <jffs2_write_dnode+0xc2>
109f48: 9a05 ldr r2, [sp, #20]
109f4a: 6939 ldr r1, [r7, #16]
109f4c: 6812 ldr r2, [r2, #0]
109f4e: 4291 cmp r1, r2
109f50: d21b bcs.n 109f8a <jffs2_write_dnode+0xc2> <== NEVER TAKEN
BUG_ON(!retried);
109f52: b976 cbnz r6, 109f72 <jffs2_write_dnode+0xaa> <== NOT EXECUTED
109f54: f645 2378 movw r3, #23160 ; 0x5a78 <== NOT EXECUTED
109f58: f248 2260 movw r2, #33376 ; 0x8260 <== NOT EXECUTED
109f5c: f248 00b0 movw r0, #32944 ; 0x80b0 <== NOT EXECUTED
109f60: f2c0 0311 movt r3, #17 <== NOT EXECUTED
109f64: f2c0 0211 movt r2, #17 <== NOT EXECUTED
109f68: 2167 movs r1, #103 ; 0x67 <== NOT EXECUTED
109f6a: f2c0 0011 movt r0, #17 <== NOT EXECUTED
109f6e: f002 fb7f bl 10c670 <__assert_func> <== NOT EXECUTED
ri->version = cpu_to_je32(++f->highest_version);
109f72: 9309 str r3, [sp, #36] ; 0x24 <== NOT EXECUTED
109f74: 3201 adds r2, #1 <== NOT EXECUTED
109f76: 9b05 ldr r3, [sp, #20] <== NOT EXECUTED
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
109f78: 4639 mov r1, r7 <== NOT EXECUTED
109f7a: 2000 movs r0, #0 <== NOT EXECUTED
ri->version = cpu_to_je32(++f->highest_version);
109f7c: 601a str r2, [r3, #0] <== NOT EXECUTED
109f7e: 613a str r2, [r7, #16] <== NOT EXECUTED
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
109f80: 223c movs r2, #60 ; 0x3c <== NOT EXECUTED
109f82: f000 fe9b bl 10acbc <cyg_crc32_accumulate> <== NOT EXECUTED
109f86: 9b09 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
109f88: 6438 str r0, [r7, #64] ; 0x40 <== NOT EXECUTED
flash_ofs = write_ofs(c);
109f8a: 445d add r5, fp
ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen,
109f8c: 9a06 ldr r2, [sp, #24]
flash_ofs = write_ofs(c);
109f8e: 1aed subs r5, r5, r3
ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen,
109f90: ab0a add r3, sp, #40 ; 0x28
109f92: 9302 str r3, [sp, #8]
109f94: 2300 movs r3, #0
109f96: 9301 str r3, [sp, #4]
109f98: a90c add r1, sp, #48 ; 0x30
109f9a: 4620 mov r0, r4
109f9c: 9500 str r5, [sp, #0]
109f9e: f001 fc49 bl 10b834 <jffs2_flash_direct_writev>
if (ret || (retlen != sizeof(*ri) + datalen)) {
109fa2: 9b0a ldr r3, [sp, #40] ; 0x28
109fa4: 4683 mov fp, r0
109fa6: b908 cbnz r0, 109fac <jffs2_write_dnode+0xe4>
109fa8: 4599 cmp r9, r3
109faa: d066 beq.n 10a07a <jffs2_write_dnode+0x1b2> <== NEVER TAKEN
pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
109fac: 9300 str r3, [sp, #0] <== NOT EXECUTED
109fae: 462a mov r2, r5 <== NOT EXECUTED
109fb0: 465b mov r3, fp <== NOT EXECUTED
109fb2: 4649 mov r1, r9 <== NOT EXECUTED
109fb4: 4650 mov r0, sl <== NOT EXECUTED
109fb6: f7ff ff33 bl 109e20 <jffs2_printk> <== NOT EXECUTED
if (retlen) {
109fba: 9b0a ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED
109fbc: 2b00 cmp r3, #0 <== NOT EXECUTED
109fbe: d038 beq.n 10a032 <jffs2_write_dnode+0x16a> <== NOT EXECUTED
jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*ri)+datalen), NULL);
109fc0: 9b1a ldr r3, [sp, #104] ; 0x68 <== NOT EXECUTED
109fc2: f045 0101 orr.w r1, r5, #1 <== NOT EXECUTED
109fc6: 4620 mov r0, r4 <== NOT EXECUTED
109fc8: f103 0247 add.w r2, r3, #71 ; 0x47 <== NOT EXECUTED
109fcc: 2300 movs r3, #0 <== NOT EXECUTED
109fce: f022 0203 bic.w r2, r2, #3 <== NOT EXECUTED
109fd2: f7fd ffe7 bl 107fa4 <jffs2_add_physical_node_ref> <== NOT EXECUTED
flash_ofs);
}
if (!retried && alloc_mode != ALLOC_NORETRY) {
109fd6: f086 0601 eor.w r6, r6, #1 <== NOT EXECUTED
109fda: f1b8 0f03 cmp.w r8, #3 <== NOT EXECUTED
109fde: bf0c ite eq <== NOT EXECUTED
109fe0: 2600 moveq r6, #0 <== NOT EXECUTED
109fe2: f006 0601 andne.w r6, r6, #1 <== NOT EXECUTED
109fe6: 2e00 cmp r6, #0 <== NOT EXECUTED
109fe8: d037 beq.n 10a05a <jffs2_write_dnode+0x192> <== NOT EXECUTED
/* Try to reallocate space and retry */
uint32_t dummy;
struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
109fea: 6b61 ldr r1, [r4, #52] ; 0x34 <== NOT EXECUTED
109fec: 4628 mov r0, r5 <== NOT EXECUTED
109fee: f00a fab7 bl 114560 <__udivsi3> <== NOT EXECUTED
109ff2: 6d65 ldr r5, [r4, #84] ; 0x54 <== NOT EXECUTED
109ff4: 2334 movs r3, #52 ; 0x34 <== NOT EXECUTED
109ff6: fb03 5500 mla r5, r3, r0, r5 <== NOT EXECUTED
retried = 1;
jffs2_dbg(1, "Retrying failed write.\n");
jffs2_dbg_acct_sanity_check(c,jeb);
109ffa: 4620 mov r0, r4 <== NOT EXECUTED
109ffc: 4629 mov r1, r5 <== NOT EXECUTED
109ffe: f000 ff47 bl 10ae90 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
jffs2_dbg_acct_paranoia_check(c, jeb);
if (alloc_mode == ALLOC_GC) {
10a002: f1b8 0f02 cmp.w r8, #2 <== NOT EXECUTED
10a006: d019 beq.n 10a03c <jffs2_write_dnode+0x174> <== 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);
10a008: 4620 mov r0, r4 <== NOT EXECUTED
10a00a: f7fe f839 bl 108080 <jffs2_complete_reservation> <== NOT EXECUTED
ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &dummy,
10a00e: 2312 movs r3, #18 <== NOT EXECUTED
10a010: aa0b add r2, sp, #44 ; 0x2c <== NOT EXECUTED
10a012: 9300 str r3, [sp, #0] <== NOT EXECUTED
10a014: 4649 mov r1, r9 <== NOT EXECUTED
10a016: 4643 mov r3, r8 <== NOT EXECUTED
10a018: 4620 mov r0, r4 <== NOT EXECUTED
10a01a: f7fe fadb bl 1085d4 <jffs2_reserve_space> <== NOT EXECUTED
10a01e: 4683 mov fp, r0 <== NOT EXECUTED
alloc_mode, JFFS2_SUMMARY_INODE_SIZE);
mutex_lock(&f->sem);
}
if (!ret) {
10a020: f1bb 0f00 cmp.w fp, #0 <== NOT EXECUTED
10a024: d123 bne.n 10a06e <jffs2_write_dnode+0x1a6> <== 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);
10a026: 4629 mov r1, r5 <== NOT EXECUTED
10a028: 4620 mov r0, r4 <== NOT EXECUTED
retried = 1;
10a02a: 2601 movs r6, #1 <== NOT EXECUTED
jffs2_dbg_acct_sanity_check(c,jeb);
10a02c: f000 ff30 bl 10ae90 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
jffs2_dbg_acct_paranoia_check(c, jeb);
goto retry;
10a030: e782 b.n 109f38 <jffs2_write_dnode+0x70> <== NOT EXECUTED
pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n",
10a032: 9808 ldr r0, [sp, #32] <== NOT EXECUTED
10a034: 4629 mov r1, r5 <== NOT EXECUTED
10a036: f7ff fef3 bl 109e20 <jffs2_printk> <== NOT EXECUTED
10a03a: e7cc b.n 109fd6 <jffs2_write_dnode+0x10e> <== NOT EXECUTED
ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &dummy,
10a03c: 2312 movs r3, #18 <== NOT EXECUTED
10a03e: aa0b add r2, sp, #44 ; 0x2c <== NOT EXECUTED
10a040: 4649 mov r1, r9 <== NOT EXECUTED
10a042: 4620 mov r0, r4 <== NOT EXECUTED
10a044: f7fe faae bl 1085a4 <jffs2_reserve_space_gc> <== NOT EXECUTED
10a048: 4683 mov fp, r0 <== NOT EXECUTED
10a04a: e7e9 b.n 10a020 <jffs2_write_dnode+0x158> <== NOT EXECUTED
return ERR_PTR(-ENOMEM);
10a04c: f06f 030b mvn.w r3, #11 <== NOT EXECUTED
10a050: 9307 str r3, [sp, #28] <== NOT EXECUTED
if (retried) {
jffs2_dbg_acct_sanity_check(c,NULL);
}
return fn;
}
10a052: 9807 ldr r0, [sp, #28]
10a054: b011 add sp, #68 ; 0x44
10a056: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
jffs2_free_full_dnode(fn);
10a05a: 9807 ldr r0, [sp, #28] <== NOT EXECUTED
10a05c: f7fd fa66 bl 10752c <jffs2_free_full_dnode> <== NOT EXECUTED
return ERR_PTR(ret?ret:-EIO);
10a060: f1bb 0f00 cmp.w fp, #0 <== NOT EXECUTED
10a064: d106 bne.n 10a074 <jffs2_write_dnode+0x1ac> <== NOT EXECUTED
10a066: f06f 0304 mvn.w r3, #4 <== NOT EXECUTED
10a06a: 9307 str r3, [sp, #28] <== NOT EXECUTED
10a06c: e7f1 b.n 10a052 <jffs2_write_dnode+0x18a> <== NOT EXECUTED
jffs2_free_full_dnode(fn);
10a06e: 9807 ldr r0, [sp, #28] <== NOT EXECUTED
10a070: f7fd fa5c bl 10752c <jffs2_free_full_dnode> <== NOT EXECUTED
return ERR_PTR(ret?ret:-EIO);
10a074: f8cd b01c str.w fp, [sp, #28] <== NOT EXECUTED
10a078: e7eb b.n 10a052 <jffs2_write_dnode+0x18a> <== NOT EXECUTED
if ((je32_to_cpu(ri->dsize) >= PAGE_SIZE) ||
10a07a: 6b7b ldr r3, [r7, #52] ; 0x34
10a07c: f5b3 5f80 cmp.w r3, #4096 ; 0x1000
10a080: d226 bcs.n 10a0d0 <jffs2_write_dnode+0x208>
( ((je32_to_cpu(ri->offset)&(PAGE_SIZE-1))==0) &&
10a082: 6afa ldr r2, [r7, #44] ; 0x2c
10a084: f3c2 010b ubfx r1, r2, #0, #12
if ((je32_to_cpu(ri->dsize) >= PAGE_SIZE) ||
10a088: b919 cbnz r1, 10a092 <jffs2_write_dnode+0x1ca>
(je32_to_cpu(ri->dsize)+je32_to_cpu(ri->offset) == je32_to_cpu(ri->isize)))) {
10a08a: 4413 add r3, r2
10a08c: 69fa ldr r2, [r7, #28]
( ((je32_to_cpu(ri->offset)&(PAGE_SIZE-1))==0) &&
10a08e: 4293 cmp r3, r2
10a090: d01e beq.n 10a0d0 <jffs2_write_dnode+0x208>
flash_ofs |= REF_NORMAL;
10a092: f045 0103 orr.w r1, r5, #3
fn->raw = jffs2_add_physical_node_ref(c, flash_ofs, PAD(sizeof(*ri)+datalen), f->inocache);
10a096: 9b1a ldr r3, [sp, #104] ; 0x68
10a098: 4620 mov r0, r4
10a09a: f103 0247 add.w r2, r3, #71 ; 0x47
10a09e: 9b05 ldr r3, [sp, #20]
10a0a0: f022 0203 bic.w r2, r2, #3
10a0a4: 695b ldr r3, [r3, #20]
10a0a6: f7fd ff7d bl 107fa4 <jffs2_add_physical_node_ref>
10a0aa: 9a07 ldr r2, [sp, #28]
if (IS_ERR(fn->raw)) {
10a0ac: f510 7f7a cmn.w r0, #1000 ; 0x3e8
fn->raw = jffs2_add_physical_node_ref(c, flash_ofs, PAD(sizeof(*ri)+datalen), f->inocache);
10a0b0: 4603 mov r3, r0
10a0b2: 6010 str r0, [r2, #0]
if (IS_ERR(fn->raw)) {
10a0b4: d80f bhi.n 10a0d6 <jffs2_write_dnode+0x20e> <== ALWAYS TAKEN
fn->ofs = je32_to_cpu(ri->offset);
10a0b6: 6afb ldr r3, [r7, #44] ; 0x2c
fn->frags = 0;
10a0b8: 2100 movs r1, #0
fn->ofs = je32_to_cpu(ri->offset);
10a0ba: 9a07 ldr r2, [sp, #28]
10a0bc: 6053 str r3, [r2, #4]
fn->size = je32_to_cpu(ri->dsize);
10a0be: 6b7b ldr r3, [r7, #52] ; 0x34
fn->frags = 0;
10a0c0: 60d1 str r1, [r2, #12]
fn->size = je32_to_cpu(ri->dsize);
10a0c2: 6093 str r3, [r2, #8]
if (retried) {
10a0c4: 2e00 cmp r6, #0
10a0c6: d0c4 beq.n 10a052 <jffs2_write_dnode+0x18a> <== NEVER TAKEN
jffs2_dbg_acct_sanity_check(c,NULL);
10a0c8: 4620 mov r0, r4 <== NOT EXECUTED
10a0ca: f000 fee1 bl 10ae90 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
10a0ce: e7c0 b.n 10a052 <jffs2_write_dnode+0x18a> <== NOT EXECUTED
flash_ofs |= REF_PRISTINE;
10a0d0: f045 0102 orr.w r1, r5, #2
10a0d4: e7df b.n 10a096 <jffs2_write_dnode+0x1ce>
jffs2_free_full_dnode(fn);
10a0d6: 4610 mov r0, r2 <== NOT EXECUTED
return ERR_CAST(hold_err);
10a0d8: 9307 str r3, [sp, #28] <== NOT EXECUTED
jffs2_free_full_dnode(fn);
10a0da: f7fd fa27 bl 10752c <jffs2_free_full_dnode> <== NOT EXECUTED
return ERR_CAST(hold_err);
10a0de: e7b8 b.n 10a052 <jffs2_write_dnode+0x18a> <== NOT EXECUTED
0010a340 <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)
{
10a340: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
10a344: b08b sub sp, #44 ; 0x2c
10a346: 4699 mov r9, r3
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) {
10a348: 9b15 ldr r3, [sp, #84] ; 0x54
10a34a: 2b00 cmp r3, #0
10a34c: f000 80b1 beq.w 10a4b2 <jffs2_write_inode_range+0x172> <== ALWAYS TAKEN
retry:
jffs2_dbg(2, "jffs2_commit_write() loop: 0x%x to write to 0x%x\n",
writelen, offset);
ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN,
10a350: f8dd b050 ldr.w fp, [sp, #80] ; 0x50
10a354: 460e mov r6, r1
10a356: 4614 mov r4, r2
10a358: 4680 mov r8, r0
uint32_t writtenlen = 0;
10a35a: 2300 movs r3, #0
10a35c: 9305 str r3, [sp, #20]
unsigned char *comprbuf = NULL;
10a35e: 2300 movs r3, #0
if (ret) {
jffs2_dbg(1, "jffs2_reserve_space returned %d\n", ret);
break;
}
mutex_lock(&f->sem);
datalen = min_t(uint32_t, writelen,
10a360: f3cb 070b ubfx r7, fp, #0, #12
unsigned char *comprbuf = NULL;
10a364: 9306 str r3, [sp, #24]
datalen = min_t(uint32_t, writelen,
10a366: f5c7 5780 rsb r7, r7, #4096 ; 0x1000
10a36a: 9b15 ldr r3, [sp, #84] ; 0x54
unsigned char *comprbuf = NULL;
10a36c: f04f 0a02 mov.w sl, #2
datalen = min_t(uint32_t, writelen,
10a370: 429f cmp r7, r3
10a372: bf28 it cs
10a374: 461f movcs r7, r3
10a376: 9703 str r7, [sp, #12]
ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN,
10a378: 2212 movs r2, #18
10a37a: 2300 movs r3, #0
10a37c: 21c4 movs r1, #196 ; 0xc4
10a37e: 9200 str r2, [sp, #0]
10a380: 4640 mov r0, r8
10a382: aa07 add r2, sp, #28
10a384: f7fe f926 bl 1085d4 <jffs2_reserve_space>
10a388: 4605 mov r5, r0
PAGE_SIZE - (offset & (PAGE_SIZE-1)));
cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen);
comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
10a38a: ab06 add r3, sp, #24
10a38c: 464a mov r2, r9
10a38e: 4631 mov r1, r6
10a390: 4640 mov r0, r8
if (ret) {
10a392: 2d00 cmp r5, #0
10a394: d160 bne.n 10a458 <jffs2_write_inode_range+0x118>
comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
10a396: af09 add r7, sp, #36 ; 0x24
10a398: 9701 str r7, [sp, #4]
10a39a: af08 add r7, sp, #32
10a39c: 9700 str r7, [sp, #0]
datalen = min_t(uint32_t, writelen,
10a39e: 9f03 ldr r7, [sp, #12]
10a3a0: 9708 str r7, [sp, #32]
cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen);
10a3a2: 9f07 ldr r7, [sp, #28]
10a3a4: f1a7 0c44 sub.w ip, r7, #68 ; 0x44
10a3a8: 9f03 ldr r7, [sp, #12]
10a3aa: 45bc cmp ip, r7
10a3ac: bf28 it cs
10a3ae: 46bc movcs ip, r7
10a3b0: f8cd c024 str.w ip, [sp, #36] ; 0x24
comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
10a3b4: f000 fc96 bl 10ace4 <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);
10a3b8: 9a09 ldr r2, [sp, #36] ; 0x24
ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
10a3ba: f04f 0302 mov.w r3, #2
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
10a3be: 4621 mov r1, r4
ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
10a3c0: 70a3 strb r3, [r4, #2]
comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
10a3c2: 9004 str r0, [sp, #16]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
10a3c4: 4628 mov r0, r5
ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen);
10a3c6: 3244 adds r2, #68 ; 0x44
10a3c8: 6062 str r2, [r4, #4]
ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
10a3ca: f06f 027a mvn.w r2, #122 ; 0x7a
10a3ce: 7022 strb r2, [r4, #0]
10a3d0: 2219 movs r2, #25
10a3d2: 7062 strb r2, [r4, #1]
ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
10a3d4: f06f 021f mvn.w r2, #31
10a3d8: 70e2 strb r2, [r4, #3]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
10a3da: 2208 movs r2, #8
10a3dc: f000 fc6e bl 10acbc <cyg_crc32_accumulate>
ri->ino = cpu_to_je32(f->inocache->ino);
10a3e0: 6972 ldr r2, [r6, #20]
ri->offset = cpu_to_je32(offset);
ri->csize = cpu_to_je32(cdatalen);
ri->dsize = cpu_to_je32(datalen);
ri->compr = comprtype & 0xff;
ri->usercompr = (comprtype >> 8 ) & 0xff;
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
10a3e2: 4621 mov r1, r4
ri->compr = comprtype & 0xff;
10a3e4: 9b04 ldr r3, [sp, #16]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
10a3e6: 60a0 str r0, [r4, #8]
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
10a3e8: 4628 mov r0, r5
ri->ino = cpu_to_je32(f->inocache->ino);
10a3ea: 68d2 ldr r2, [r2, #12]
10a3ec: 60e2 str r2, [r4, #12]
ri->version = cpu_to_je32(++f->highest_version);
10a3ee: 6832 ldr r2, [r6, #0]
10a3f0: 3201 adds r2, #1
10a3f2: 6032 str r2, [r6, #0]
ri->compr = comprtype & 0xff;
10a3f4: f884 3038 strb.w r3, [r4, #56] ; 0x38
ri->usercompr = (comprtype >> 8 ) & 0xff;
10a3f8: 0a1b lsrs r3, r3, #8
ri->version = cpu_to_je32(++f->highest_version);
10a3fa: 6122 str r2, [r4, #16]
ri->usercompr = (comprtype >> 8 ) & 0xff;
10a3fc: f884 3039 strb.w r3, [r4, #57] ; 0x39
ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
10a400: 9b08 ldr r3, [sp, #32]
10a402: 69e2 ldr r2, [r4, #28]
ri->offset = cpu_to_je32(offset);
10a404: f8c4 b02c str.w fp, [r4, #44] ; 0x2c
ri->dsize = cpu_to_je32(datalen);
10a408: 6363 str r3, [r4, #52] ; 0x34
ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
10a40a: 445b add r3, fp
10a40c: 4293 cmp r3, r2
10a40e: bf38 it cc
10a410: 4613 movcc r3, r2
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
10a412: 223c movs r2, #60 ; 0x3c
ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
10a414: 61e3 str r3, [r4, #28]
ri->csize = cpu_to_je32(cdatalen);
10a416: 9b09 ldr r3, [sp, #36] ; 0x24
10a418: 6323 str r3, [r4, #48] ; 0x30
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
10a41a: f000 fc4f bl 10acbc <cyg_crc32_accumulate>
ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
10a41e: 9a09 ldr r2, [sp, #36] ; 0x24
10a420: 9906 ldr r1, [sp, #24]
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
10a422: 6420 str r0, [r4, #64] ; 0x40
ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
10a424: 4628 mov r0, r5
10a426: f000 fc49 bl 10acbc <cyg_crc32_accumulate>
fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY);
10a42a: 2303 movs r3, #3
ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
10a42c: 63e0 str r0, [r4, #60] ; 0x3c
fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY);
10a42e: 9301 str r3, [sp, #4]
10a430: 4622 mov r2, r4
10a432: 9b09 ldr r3, [sp, #36] ; 0x24
10a434: 4631 mov r1, r6
10a436: 4640 mov r0, r8
10a438: 9300 str r3, [sp, #0]
10a43a: 9b06 ldr r3, [sp, #24]
10a43c: f7ff fd44 bl 109ec8 <jffs2_write_dnode>
jffs2_free_comprbuf(comprbuf, buf);
if (IS_ERR(fn)) {
10a440: f510 7f7a cmn.w r0, #1000 ; 0x3e8
fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY);
10a444: 4605 mov r5, r0
if (IS_ERR(fn)) {
10a446: d90f bls.n 10a468 <jffs2_write_inode_range+0x128> <== NEVER TAKEN
ret = PTR_ERR(fn);
mutex_unlock(&f->sem);
jffs2_complete_reservation(c);
10a448: 4640 mov r0, r8 <== NOT EXECUTED
10a44a: f7fd fe19 bl 108080 <jffs2_complete_reservation> <== NOT EXECUTED
if (!retried) {
10a44e: f1ba 0f01 cmp.w sl, #1 <== NOT EXECUTED
10a452: f04f 0a01 mov.w sl, #1 <== NOT EXECUTED
10a456: d18f bne.n 10a378 <jffs2_write_inode_range+0x38> <== NOT EXECUTED
writtenlen += datalen;
offset += datalen;
writelen -= datalen;
buf += datalen;
}
*retlen = writtenlen;
10a458: 9b16 ldr r3, [sp, #88] ; 0x58
return ret;
}
10a45a: 4628 mov r0, r5
*retlen = writtenlen;
10a45c: 461a mov r2, r3
10a45e: 9b05 ldr r3, [sp, #20]
10a460: 6013 str r3, [r2, #0]
}
10a462: b00b add sp, #44 ; 0x2c
10a464: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
ret = jffs2_add_full_dnode_to_inode(c, f, fn);
10a468: 4602 mov r2, r0
10a46a: 9003 str r0, [sp, #12]
10a46c: 4631 mov r1, r6
10a46e: 4640 mov r0, r8
10a470: f7fd f9ca bl 107808 <jffs2_add_full_dnode_to_inode>
if (f->metadata) {
10a474: 68b3 ldr r3, [r6, #8]
ret = jffs2_add_full_dnode_to_inode(c, f, fn);
10a476: 4605 mov r5, r0
if (f->metadata) {
10a478: 9a03 ldr r2, [sp, #12]
10a47a: b14b cbz r3, 10a490 <jffs2_write_inode_range+0x150>
jffs2_mark_node_obsolete(c, f->metadata->raw);
10a47c: 6819 ldr r1, [r3, #0]
10a47e: 4640 mov r0, r8
10a480: f7fd fe04 bl 10808c <jffs2_mark_node_obsolete>
jffs2_free_full_dnode(f->metadata);
10a484: 68b0 ldr r0, [r6, #8]
10a486: f7fd f851 bl 10752c <jffs2_free_full_dnode>
f->metadata = NULL;
10a48a: 9a03 ldr r2, [sp, #12]
10a48c: 2300 movs r3, #0
10a48e: 60b3 str r3, [r6, #8]
if (ret) {
10a490: b9e5 cbnz r5, 10a4cc <jffs2_write_inode_range+0x18c>
jffs2_complete_reservation(c);
10a492: 4640 mov r0, r8
10a494: f7fd fdf4 bl 108080 <jffs2_complete_reservation>
if (!datalen) {
10a498: 9b08 ldr r3, [sp, #32]
10a49a: b173 cbz r3, 10a4ba <jffs2_write_inode_range+0x17a>
writtenlen += datalen;
10a49c: 9a05 ldr r2, [sp, #20]
offset += datalen;
10a49e: 449b add fp, r3
buf += datalen;
10a4a0: 4499 add r9, r3
writtenlen += datalen;
10a4a2: 441a add r2, r3
10a4a4: 9205 str r2, [sp, #20]
while(writelen) {
10a4a6: 9a15 ldr r2, [sp, #84] ; 0x54
10a4a8: 1ad3 subs r3, r2, r3
10a4aa: 9315 str r3, [sp, #84] ; 0x54
10a4ac: f47f af57 bne.w 10a35e <jffs2_write_inode_range+0x1e>
10a4b0: e7d2 b.n 10a458 <jffs2_write_inode_range+0x118>
uint32_t writtenlen = 0;
10a4b2: 9b15 ldr r3, [sp, #84] ; 0x54 <== NOT EXECUTED
while(writelen) {
10a4b4: 461d mov r5, r3 <== NOT EXECUTED
uint32_t writtenlen = 0;
10a4b6: 9305 str r3, [sp, #20] <== NOT EXECUTED
10a4b8: e7ce b.n 10a458 <jffs2_write_inode_range+0x118> <== NOT EXECUTED
pr_warn("Eep. We didn't actually write any data in jffs2_write_inode_range()\n");
10a4ba: f248 10bc movw r0, #33212 ; 0x81bc <== NOT EXECUTED
ret = -EIO;
10a4be: f06f 0504 mvn.w r5, #4 <== NOT EXECUTED
pr_warn("Eep. We didn't actually write any data in jffs2_write_inode_range()\n");
10a4c2: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10a4c6: f7ff fcab bl 109e20 <jffs2_printk> <== NOT EXECUTED
break;
10a4ca: e7c5 b.n 10a458 <jffs2_write_inode_range+0x118> <== NOT EXECUTED
jffs2_mark_node_obsolete(c, fn->raw);
10a4cc: 4693 mov fp, r2 <== NOT EXECUTED
10a4ce: 6811 ldr r1, [r2, #0] <== NOT EXECUTED
10a4d0: 4640 mov r0, r8 <== NOT EXECUTED
10a4d2: f7fd fddb bl 10808c <jffs2_mark_node_obsolete> <== NOT EXECUTED
jffs2_free_full_dnode(fn);
10a4d6: 4658 mov r0, fp <== NOT EXECUTED
10a4d8: f7fd f828 bl 10752c <jffs2_free_full_dnode> <== NOT EXECUTED
jffs2_complete_reservation(c);
10a4dc: 4640 mov r0, r8 <== NOT EXECUTED
10a4de: f7fd fdcf bl 108080 <jffs2_complete_reservation> <== NOT EXECUTED
break;
10a4e2: e7b9 b.n 10a458 <jffs2_write_inode_range+0x118> <== NOT EXECUTED
00104e54 <rtems_jffs2_compressor_rtime_compress>:
unsigned char *data_in,
unsigned char *cpage_out,
uint32_t *sourcelen,
uint32_t *dstlen
)
{
104e54: e92d 4ff0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, fp, lr}
104e58: 4610 mov r0, r2
104e5a: f5ad 7d03 sub.w sp, sp, #524 ; 0x20c
104e5e: 461d mov r5, r3
int outpos = 0;
int pos=0;
(void) self;
memset(positions,0,sizeof(positions));
104e60: f44f 7200 mov.w r2, #512 ; 0x200
{
104e64: 460c mov r4, r1
104e66: 9000 str r0, [sp, #0]
memset(positions,0,sizeof(positions));
104e68: 2100 movs r1, #0
104e6a: a802 add r0, sp, #8
{
104e6c: 9e8c ldr r6, [sp, #560] ; 0x230
memset(positions,0,sizeof(positions));
104e6e: f010 f977 bl 115160 <memset>
while (pos < (*sourcelen) && outpos <= (*dstlen)-2) {
104e72: 682b ldr r3, [r5, #0]
104e74: 2b00 cmp r3, #0
104e76: d052 beq.n 104f1e <rtems_jffs2_compressor_rtime_compress+0xca> <== ALWAYS TAKEN
104e78: 9b00 ldr r3, [sp, #0]
104e7a: 2200 movs r2, #0
int outpos = 0;
104e7c: 4693 mov fp, r2
104e7e: 46aa mov sl, r5
104e80: 3b01 subs r3, #1
104e82: 9301 str r3, [sp, #4]
int pos=0;
104e84: 4613 mov r3, r2
int backpos, runlen=0;
unsigned char value;
value = data_in[pos];
104e86: 5ca2 ldrb r2, [r4, r2]
cpage_out[outpos++] = data_in[pos++];
backpos = positions[value];
104e88: a902 add r1, sp, #8
cpage_out[outpos++] = data_in[pos++];
104e8a: 9800 ldr r0, [sp, #0]
104e8c: 1c5f adds r7, r3, #1
backpos = positions[value];
104e8e: f831 1012 ldrh.w r1, [r1, r2, lsl #1]
cpage_out[outpos++] = data_in[pos++];
104e92: f800 200b strb.w r2, [r0, fp]
positions[value]=pos;
104e96: a802 add r0, sp, #8
104e98: f820 7012 strh.w r7, [r0, r2, lsl #1]
while ((backpos < pos) && (pos < (*sourcelen)) &&
104e9c: 428f cmp r7, r1
104e9e: bfde ittt le
104ea0: 463a movle r2, r7
104ea2: 2000 movle r0, #0
104ea4: 4613 movle r3, r2
104ea6: dd1e ble.n 104ee6 <rtems_jffs2_compressor_rtime_compress+0x92> <== ALWAYS TAKEN
104ea8: 3901 subs r1, #1
104eaa: f8da 5000 ldr.w r5, [sl]
104eae: eb04 0c03 add.w ip, r4, r3
104eb2: 4421 add r1, r4
int backpos, runlen=0;
104eb4: 2000 movs r0, #0
104eb6: e00f b.n 104ed8 <rtems_jffs2_compressor_rtime_compress+0x84>
while ((backpos < pos) && (pos < (*sourcelen)) &&
104eb8: f811 ef01 ldrb.w lr, [r1, #1]!
104ebc: f81c 8f01 ldrb.w r8, [ip, #1]!
104ec0: eba1 0904 sub.w r9, r1, r4
104ec4: 45f0 cmp r8, lr
104ec6: d10c bne.n 104ee2 <rtems_jffs2_compressor_rtime_compress+0x8e>
(data_in[pos]==data_in[backpos++]) && (runlen<255)) {
104ec8: 28ff cmp r0, #255 ; 0xff
104eca: d026 beq.n 104f1a <rtems_jffs2_compressor_rtime_compress+0xc6>
while ((backpos < pos) && (pos < (*sourcelen)) &&
104ecc: 454f cmp r7, r9
pos++;
runlen++;
104ece: f100 0001 add.w r0, r0, #1
while ((backpos < pos) && (pos < (*sourcelen)) &&
104ed2: 461a mov r2, r3
pos++;
104ed4: 461f mov r7, r3
while ((backpos < pos) && (pos < (*sourcelen)) &&
104ed6: dd1e ble.n 104f16 <rtems_jffs2_compressor_rtime_compress+0xc2> <== ALWAYS TAKEN
104ed8: 42bd cmp r5, r7
104eda: 463a mov r2, r7
pos++;
104edc: f107 0301 add.w r3, r7, #1
while ((backpos < pos) && (pos < (*sourcelen)) &&
104ee0: d8ea bhi.n 104eb8 <rtems_jffs2_compressor_rtime_compress+0x64>
}
cpage_out[outpos++] = runlen;
104ee2: b2c0 uxtb r0, r0
104ee4: 4613 mov r3, r2
104ee6: 9901 ldr r1, [sp, #4]
104ee8: f10b 0b02 add.w fp, fp, #2
104eec: f801 000b strb.w r0, [r1, fp]
while (pos < (*sourcelen) && outpos <= (*dstlen)-2) {
104ef0: f8da 1000 ldr.w r1, [sl]
104ef4: 4291 cmp r1, r2
104ef6: d903 bls.n 104f00 <rtems_jffs2_compressor_rtime_compress+0xac>
104ef8: 6831 ldr r1, [r6, #0]
104efa: 3902 subs r1, #2
104efc: 4559 cmp r1, fp
104efe: d2c2 bcs.n 104e86 <rtems_jffs2_compressor_rtime_compress+0x32>
}
if (outpos >= pos) {
104f00: 459b cmp fp, r3
104f02: da0c bge.n 104f1e <rtems_jffs2_compressor_rtime_compress+0xca>
}
/* Tell the caller how much we managed to compress, and how much space it took */
*sourcelen = pos;
*dstlen = outpos;
return JFFS2_COMPR_RTIME;
104f04: 2002 movs r0, #2
*sourcelen = pos;
104f06: f8ca 2000 str.w r2, [sl]
*dstlen = outpos;
104f0a: f8c6 b000 str.w fp, [r6]
}
104f0e: f50d 7d03 add.w sp, sp, #524 ; 0x20c
104f12: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
cpage_out[outpos++] = runlen;
104f16: b2c0 uxtb r0, r0 <== NOT EXECUTED
104f18: e7e5 b.n 104ee6 <rtems_jffs2_compressor_rtime_compress+0x92> <== NOT EXECUTED
104f1a: 463b mov r3, r7
104f1c: e7e3 b.n 104ee6 <rtems_jffs2_compressor_rtime_compress+0x92>
return JFFS2_COMPR_NONE;
104f1e: 2000 movs r0, #0
}
104f20: f50d 7d03 add.w sp, sp, #524 ; 0x20c
104f24: e8bd 8ff0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, fp, pc}
00104f28 <rtems_jffs2_compressor_rtime_decompress>:
int outpos = 0;
int pos=0;
(void) self;
if (comprtype != JFFS2_COMPR_RTIME) {
104f28: 2902 cmp r1, #2
{
104f2a: e92d 41f0 stmdb sp!, {r4, r5, r6, r7, r8, lr}
104f2e: f5ad 7d00 sub.w sp, sp, #512 ; 0x200
104f32: 9f87 ldr r7, [sp, #540] ; 0x21c
if (comprtype != JFFS2_COMPR_RTIME) {
104f34: d145 bne.n 104fc2 <rtems_jffs2_compressor_rtime_decompress+0x9a> <== ALWAYS TAKEN
return -EIO;
}
memset(positions,0,sizeof(positions));
104f36: 4615 mov r5, r2
104f38: 2100 movs r1, #0
104f3a: f44f 7200 mov.w r2, #512 ; 0x200
104f3e: 4668 mov r0, sp
104f40: 461e mov r6, r3
104f42: f010 f90d bl 115160 <memset>
int outpos = 0;
104f46: f04f 0c00 mov.w ip, #0
while (outpos<destlen) {
104f4a: 4664 mov r4, ip
104f4c: b987 cbnz r7, 104f70 <rtems_jffs2_compressor_rtime_decompress+0x48>
104f4e: e022 b.n 104f96 <rtems_jffs2_compressor_rtime_decompress+0x6e> <== NOT EXECUTED
repeat = data_in[pos++];
backoffs = positions[value];
positions[value]=outpos;
if (repeat) {
if (backoffs + repeat >= outpos) {
104f50: eb01 0308 add.w r3, r1, r8
104f54: 4283 cmp r3, r0
104f56: da23 bge.n 104fa0 <rtems_jffs2_compressor_rtime_decompress+0x78>
while(repeat) {
cpage_out[outpos++] = cpage_out[backoffs++];
repeat--;
}
} else {
memcpy(&cpage_out[outpos],&cpage_out[backoffs],repeat);
104f58: 1830 adds r0, r6, r0
104f5a: 4642 mov r2, r8
104f5c: 4431 add r1, r6
104f5e: f00f ee90 blx 114c80 <memcpy>
outpos+=repeat;
104f62: eb04 0c08 add.w ip, r4, r8
while (outpos<destlen) {
104f66: 4664 mov r4, ip
104f68: 42a7 cmp r7, r4
104f6a: f105 0502 add.w r5, r5, #2
104f6e: d912 bls.n 104f96 <rtems_jffs2_compressor_rtime_decompress+0x6e>
value = data_in[pos++];
104f70: 782b ldrb r3, [r5, #0]
cpage_out[outpos++] = value; /* first the verbatim copied byte */
104f72: f10c 0001 add.w r0, ip, #1
104f76: 5533 strb r3, [r6, r4]
memcpy(&cpage_out[outpos],&cpage_out[backoffs],repeat);
104f78: 4604 mov r4, r0
repeat = data_in[pos++];
104f7a: f895 8001 ldrb.w r8, [r5, #1]
backoffs = positions[value];
104f7e: f83d 1013 ldrh.w r1, [sp, r3, lsl #1]
positions[value]=outpos;
104f82: f82d 0013 strh.w r0, [sp, r3, lsl #1]
if (repeat) {
104f86: f1b8 0f00 cmp.w r8, #0
104f8a: d1e1 bne.n 104f50 <rtems_jffs2_compressor_rtime_decompress+0x28>
while (outpos<destlen) {
104f8c: 42a7 cmp r7, r4
cpage_out[outpos++] = value; /* first the verbatim copied byte */
104f8e: 4684 mov ip, r0
while (outpos<destlen) {
104f90: f105 0502 add.w r5, r5, #2
104f94: d8ec bhi.n 104f70 <rtems_jffs2_compressor_rtime_decompress+0x48>
}
}
}
return 0;
104f96: 2000 movs r0, #0
}
104f98: f50d 7d00 add.w sp, sp, #512 ; 0x200
104f9c: e8bd 81f0 ldmia.w sp!, {r4, r5, r6, r7, r8, pc}
104fa0: 3901 subs r1, #1
104fa2: eb06 000c add.w r0, r6, ip
104fa6: 4431 add r1, r6
104fa8: eb00 0208 add.w r2, r0, r8
cpage_out[outpos++] = cpage_out[backoffs++];
104fac: f811 3f01 ldrb.w r3, [r1, #1]!
104fb0: f800 3f01 strb.w r3, [r0, #1]!
while(repeat) {
104fb4: 4290 cmp r0, r2
104fb6: d1f9 bne.n 104fac <rtems_jffs2_compressor_rtime_decompress+0x84>
cpage_out[outpos++] = cpage_out[backoffs++];
104fb8: 44c4 add ip, r8
104fba: f10c 0c01 add.w ip, ip, #1
while (outpos<destlen) {
104fbe: 4664 mov r4, ip
104fc0: e7d2 b.n 104f68 <rtems_jffs2_compressor_rtime_decompress+0x40>
return -EIO;
104fc2: f06f 0004 mvn.w r0, #4 <== NOT EXECUTED
104fc6: e7e7 b.n 104f98 <rtems_jffs2_compressor_rtime_decompress+0x70> <== NOT EXECUTED
0010617c <rtems_jffs2_initialize>:
{
10617c: e92d 47f0 stmdb sp!, {r4, r5, r6, r7, r8, r9, sl, lr}
106180: 460f mov r7, r1
rtems_jffs2_flash_control *fc = jffs2_mount_data->flash_control;
106182: f8d1 8000 ldr.w r8, [r1]
{
106186: 4606 mov r6, r0
rtems_jffs2_fs_info *fs_info = calloc(
106188: 2001 movs r0, #1
int inocache_hashsize = calculate_inocache_hashsize(fc->flash_size);
10618a: f8d8 9004 ldr.w r9, [r8, #4]
int hashsize = (size_mb * 2) & ~0x3f;
10618e: ea4f 45d9 mov.w r5, r9, lsr #19
106192: f405 55fe and.w r5, r5, #8128 ; 0x1fc0
106196: f5b5 6f80 cmp.w r5, #1024 ; 0x400
10619a: bfa8 it ge
10619c: f44f 6580 movge.w r5, #1024 ; 0x400
1061a0: 2d80 cmp r5, #128 ; 0x80
1061a2: bfb8 it lt
1061a4: 2580 movlt r5, #128 ; 0x80
sizeof(*fs_info) + (size_t) inocache_hashsize * sizeof(fs_info->inode_cache[0])
1061a6: f205 4182 addw r1, r5, #1154 ; 0x482
rtems_jffs2_fs_info *fs_info = calloc(
1061aa: 0089 lsls r1, r1, #2
1061ac: f006 faa8 bl 10c700 <calloc>
if (fs_info != NULL) {
1061b0: 2800 cmp r0, #0
1061b2: f000 8087 beq.w 1062c4 <rtems_jffs2_initialize+0x148> <== ALWAYS TAKEN
uint32_t blocks = fc->flash_size / fc->block_size;
1061b6: f8d8 a000 ldr.w sl, [r8]
const char *_name)
{
struct _Mutex_recursive_Control _init =
_MUTEX_RECURSIVE_NAMED_INITIALIZER(_name);
*_mutex = _init;
1061ba: f645 52c4 movw r2, #24004 ; 0x5dc4
1061be: f500 5380 add.w r3, r0, #4096 ; 0x1000
1061c2: f2c0 0211 movt r2, #17
1061c6: f8c3 2100 str.w r2, [r3, #256] ; 0x100
1061ca: 2200 movs r2, #0
1061cc: 4604 mov r4, r0
1061ce: 4651 mov r1, sl
1061d0: 4648 mov r0, r9
1061d2: e9c3 223c strd r2, r2, [r3, #240] ; 0xf0
1061d6: e9c3 223e strd r2, r2, [r3, #248] ; 0xf8
1061da: f8c3 2104 str.w r2, [r3, #260] ; 0x104
1061de: f00e f9bf bl 114560 <__udivsi3>
if ((fc->block_size * blocks) != fc->flash_size) {
1061e2: fb0a f000 mul.w r0, sl, r0
1061e6: 4581 cmp r9, r0
1061e8: d148 bne.n 10627c <rtems_jffs2_initialize+0x100> <== ALWAYS TAKEN
if (fc->flash_size < 5*fc->block_size) {
1061ea: eb0a 038a add.w r3, sl, sl, lsl #2
1061ee: 4283 cmp r3, r0
1061f0: d853 bhi.n 10629a <rtems_jffs2_initialize+0x11e> <== ALWAYS TAKEN
sb->s_compressor_control = jffs2_mount_data->compressor_control;
1061f2: 687b ldr r3, [r7, #4]
c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
1061f4: 220c movs r2, #12
c->inocache_hashsize = inocache_hashsize;
1061f6: f8c4 50c0 str.w r5, [r4, #192] ; 0xc0
c->flash_size = fc->flash_size;
1061fa: 61a0 str r0, [r4, #24]
err = jffs2_do_mount_fs(c);
1061fc: 4620 mov r0, r4
sb->s_compressor_control = jffs2_mount_data->compressor_control;
1061fe: f8c4 30e8 str.w r3, [r4, #232] ; 0xe8
c->inocache_list = &fs_info->inode_cache[0];
106202: f504 5390 add.w r3, r4, #4608 ; 0x1200
106206: 3308 adds r3, #8
sb->s_flash_control = fc;
106208: f8c4 80e4 str.w r8, [r4, #228] ; 0xe4
c->inocache_list = &fs_info->inode_cache[0];
10620c: f8c4 30c4 str.w r3, [r4, #196] ; 0xc4
sb->s_is_readonly = !mt_entry->writeable;
106210: f896 3029 ldrb.w r3, [r6, #41] ; 0x29
c->sector_size = fc->block_size;
106214: f8c4 a034 str.w sl, [r4, #52] ; 0x34
c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
106218: 6162 str r2, [r4, #20]
sb->s_is_readonly = !mt_entry->writeable;
10621a: f083 0301 eor.w r3, r3, #1
10621e: f884 30ec strb.w r3, [r4, #236] ; 0xec
err = jffs2_do_mount_fs(c);
106222: f004 fb21 bl 10a868 <jffs2_do_mount_fs>
if (err == 0) {
106226: 4605 mov r5, r0
106228: 2800 cmp r0, #0
10622a: d158 bne.n 1062de <rtems_jffs2_initialize+0x162> <== ALWAYS TAKEN
sb->s_root = jffs2_iget(sb, 1);
10622c: 2101 movs r1, #1
10622e: 4620 mov r0, r4
106230: f7ff ff4e bl 1060d0 <jffs2_iget>
if (IS_ERR(sb->s_root)) {
106234: f510 7f7a cmn.w r0, #1000 ; 0x3e8
sb->s_root = jffs2_iget(sb, 1);
106238: f8c4 00e0 str.w r0, [r4, #224] ; 0xe0
if (IS_ERR(sb->s_root)) {
10623c: d813 bhi.n 106266 <rtems_jffs2_initialize+0xea> <== ALWAYS TAKEN
if (!jffs2_is_readonly(c)) {
10623e: f894 10ec ldrb.w r1, [r4, #236] ; 0xec
sb->s_root->i_parent = sb->s_root;
106242: 6340 str r0, [r0, #52] ; 0x34
if (!jffs2_is_readonly(c)) {
106244: b1a1 cbz r1, 106270 <rtems_jffs2_initialize+0xf4>
mt_entry->ops = &rtems_jffs2_ops;
106246: f246 2324 movw r3, #25124 ; 0x6224
mt_entry->mt_fs_root->location.node_access = sb->s_root;
10624a: 6a72 ldr r2, [r6, #36] ; 0x24
mt_entry->ops = &rtems_jffs2_ops;
10624c: f2c0 0311 movt r3, #17
mt_entry->fs_info = fs_info;
106250: e9c6 4302 strd r4, r3, [r6, #8]
mt_entry->mt_fs_root->location.handlers = &rtems_jffs2_directory_handlers;
106254: f246 135c movw r3, #24924 ; 0x615c
106258: f2c0 0311 movt r3, #17
mt_entry->mt_fs_root->location.node_access = sb->s_root;
10625c: 6090 str r0, [r2, #8]
mt_entry->mt_fs_root->location.handlers = &rtems_jffs2_directory_handlers;
10625e: 6113 str r3, [r2, #16]
}
106260: 4628 mov r0, r5
106262: e8bd 87f0 ldmia.w sp!, {r4, r5, r6, r7, r8, r9, sl, pc}
if (err == 0) {
106266: 2800 cmp r0, #0 <== NOT EXECUTED
106268: d0e9 beq.n 10623e <rtems_jffs2_initialize+0xc2> <== NOT EXECUTED
err = PTR_ERR(sb->s_root);
10626a: 4605 mov r5, r0 <== NOT EXECUTED
do_mount_fs_was_successful = true;
10626c: 2101 movs r1, #1 <== NOT EXECUTED
10626e: e037 b.n 1062e0 <rtems_jffs2_initialize+0x164> <== NOT EXECUTED
jffs2_erase_pending_blocks(c, 0);
106270: 4620 mov r0, r4
106272: f005 f8e9 bl 10b448 <jffs2_erase_pending_blocks>
mt_entry->mt_fs_root->location.node_access = sb->s_root;
106276: f8d4 00e0 ldr.w r0, [r4, #224] ; 0xe0
10627a: e7e4 b.n 106246 <rtems_jffs2_initialize+0xca>
pr_info("Flash size not aligned to erasesize, reducing to %dKiB\n",
10627c: 0a81 lsrs r1, r0, #10 <== NOT EXECUTED
fc->flash_size = fc->block_size * blocks;
10627e: f8c8 0004 str.w r0, [r8, #4] <== NOT EXECUTED
pr_info("Flash size not aligned to erasesize, reducing to %dKiB\n",
106282: f246 00dc movw r0, #24796 ; 0x60dc <== NOT EXECUTED
106286: f2c0 0011 movt r0, #17 <== NOT EXECUTED
10628a: f7ff fc29 bl 105ae0 <jffs2_printk> <== NOT EXECUTED
if (fc->flash_size < 5*fc->block_size) {
10628e: e9d8 a000 ldrd sl, r0, [r8] <== NOT EXECUTED
106292: eb0a 038a add.w r3, sl, sl, lsl #2 <== NOT EXECUTED
106296: 4283 cmp r3, r0 <== NOT EXECUTED
106298: d9ab bls.n 1061f2 <rtems_jffs2_initialize+0x76> <== NOT EXECUTED
pr_err("Too few erase blocks (%d)\n",
10629a: 4651 mov r1, sl <== NOT EXECUTED
10629c: 2616 movs r6, #22 <== NOT EXECUTED
10629e: f00e f95f bl 114560 <__udivsi3> <== NOT EXECUTED
1062a2: 4601 mov r1, r0 <== NOT EXECUTED
1062a4: f246 1018 movw r0, #24856 ; 0x6118 <== NOT EXECUTED
1062a8: f2c0 0011 movt r0, #17 <== NOT EXECUTED
1062ac: f7ff fc18 bl 105ae0 <jffs2_printk> <== NOT EXECUTED
bool do_mount_fs_was_successful = false;
1062b0: 2100 movs r1, #0 <== NOT EXECUTED
rtems_jffs2_free_fs_info(fs_info, do_mount_fs_was_successful);
1062b2: 4620 mov r0, r4 <== NOT EXECUTED
1062b4: f7ff fc94 bl 105be0 <rtems_jffs2_free_fs_info> <== NOT EXECUTED
errno = -err;
1062b8: f00e fc86 bl 114bc8 <__errno> <== NOT EXECUTED
return -1;
1062bc: f04f 35ff mov.w r5, #4294967295 ; 0xffffffff <== NOT EXECUTED
errno = -err;
1062c0: 6006 str r6, [r0, #0] <== NOT EXECUTED
return -1;
1062c2: e7cd b.n 106260 <rtems_jffs2_initialize+0xe4> <== NOT EXECUTED
if (fc->destroy != NULL) {
1062c4: f8d8 3014 ldr.w r3, [r8, #20] <== NOT EXECUTED
1062c8: b10b cbz r3, 1062ce <rtems_jffs2_initialize+0x152> <== NOT EXECUTED
(*fc->destroy)(fc);
1062ca: 4640 mov r0, r8 <== NOT EXECUTED
1062cc: 4798 blx r3 <== NOT EXECUTED
rtems_jffs2_compressor_control_destroy(jffs2_mount_data->compressor_control);
1062ce: 6878 ldr r0, [r7, #4] <== NOT EXECUTED
if (cc != NULL && cc->destroy != NULL) {
1062d0: b140 cbz r0, 1062e4 <rtems_jffs2_initialize+0x168> <== NOT EXECUTED
1062d2: 6883 ldr r3, [r0, #8] <== NOT EXECUTED
(*cc->destroy)(cc);
1062d4: 260c movs r6, #12 <== NOT EXECUTED
if (cc != NULL && cc->destroy != NULL) {
1062d6: 2b00 cmp r3, #0 <== NOT EXECUTED
1062d8: d0ee beq.n 1062b8 <rtems_jffs2_initialize+0x13c> <== NOT EXECUTED
(*cc->destroy)(cc);
1062da: 4798 blx r3 <== NOT EXECUTED
1062dc: e7ec b.n 1062b8 <rtems_jffs2_initialize+0x13c> <== NOT EXECUTED
bool do_mount_fs_was_successful = false;
1062de: 2100 movs r1, #0 <== NOT EXECUTED
errno = -err;
1062e0: 426e negs r6, r5 <== NOT EXECUTED
1062e2: e7e6 b.n 1062b2 <rtems_jffs2_initialize+0x136> <== NOT EXECUTED
1062e4: 260c movs r6, #12 <== NOT EXECUTED
1062e6: e7e7 b.n 1062b8 <rtems_jffs2_initialize+0x13c> <== NOT EXECUTED