RTEMS-6
Annotated Report
libjffs2
Sun Feb 28 22:27:57 2021
4000be38 <__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);
4000be38: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
4000be3c: 7f ff ff a7 call 4000bcd8 <__jffs2_dbg_acct_sanity_check_nolock> <== NOT EXECUTED
4000be40: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
4000bcd8 <__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)
{
4000bcd8: 9d e3 bf 90 save %sp, -112, %sp
if (unlikely(jeb && jeb->used_size + jeb->dirty_size +
4000bcdc: 80 a6 60 00 cmp %i1, 0
4000bce0: 22 80 00 10 be,a 4000bd20 <__jffs2_dbg_acct_sanity_check_nolock+0x48> <== NEVER TAKEN
4000bce4: c4 06 20 1c ld [ %i0 + 0x1c ], %g2 <== NOT EXECUTED
4000bce8: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
4000bcec: f8 06 60 18 ld [ %i1 + 0x18 ], %i4
4000bcf0: fa 06 60 20 ld [ %i1 + 0x20 ], %i5
4000bcf4: c8 06 60 1c ld [ %i1 + 0x1c ], %g4
4000bcf8: c6 06 60 10 ld [ %i1 + 0x10 ], %g3
4000bcfc: c4 06 20 34 ld [ %i0 + 0x34 ], %g2
4000bd00: 82 00 40 1c add %g1, %i4, %g1
4000bd04: 82 00 40 1d add %g1, %i5, %g1
4000bd08: 82 00 40 04 add %g1, %g4, %g1
4000bd0c: 82 00 40 03 add %g1, %g3, %g1
4000bd10: 80 a0 40 02 cmp %g1, %g2
4000bd14: 32 80 00 30 bne,a 4000bdd4 <__jffs2_dbg_acct_sanity_check_nolock+0xfc> <== NEVER TAKEN
4000bd18: d4 06 60 0c ld [ %i1 + 0xc ], %o2 <== NOT EXECUTED
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
4000bd1c: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
4000bd20: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
4000bd24: f4 06 20 28 ld [ %i0 + 0x28 ], %i2
4000bd28: f6 06 20 2c ld [ %i0 + 0x2c ], %i3
4000bd2c: f8 06 20 30 ld [ %i0 + 0x30 ], %i4
4000bd30: fa 06 20 24 ld [ %i0 + 0x24 ], %i5
4000bd34: c8 06 20 38 ld [ %i0 + 0x38 ], %g4
4000bd38: c6 06 20 18 ld [ %i0 + 0x18 ], %g3
4000bd3c: 82 00 80 01 add %g2, %g1, %g1
4000bd40: 82 00 40 1a add %g1, %i2, %g1
4000bd44: 82 00 40 1b add %g1, %i3, %g1
4000bd48: 82 00 40 1c add %g1, %i4, %g1
4000bd4c: 82 00 40 1d add %g1, %i5, %g1
4000bd50: 82 00 40 04 add %g1, %g4, %g1
4000bd54: 80 a0 40 03 cmp %g1, %g3
4000bd58: 12 80 00 04 bne 4000bd68 <__jffs2_dbg_acct_sanity_check_nolock+0x90> <== NEVER TAKEN
4000bd5c: 3b 10 00 82 sethi %hi(0x40020800), %i5
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();
}
}
4000bd60: 81 c7 e0 08 ret
4000bd64: 81 e8 00 00 restore
JFFS2_ERROR("eeep, space accounting superblock info is screwed.\n");
4000bd68: 11 10 00 82 sethi %hi(0x40020800), %o0 <== NOT EXECUTED
4000bd6c: 92 17 61 48 or %i5, 0x148, %o1 <== NOT EXECUTED
4000bd70: 7f ff ff ce call 4000bca8 <jffs2_printk> <== NOT EXECUTED
4000bd74: 90 12 20 68 or %o0, 0x68, %o0 <== NOT EXECUTED
JFFS2_ERROR("free %#08x + dirty %#08x + used %#08x + erasing %#08x + bad %#08x + wasted %#08x + unchecked %#08x != total %#08x.\n",
4000bd78: c8 06 20 18 ld [ %i0 + 0x18 ], %g4 <== NOT EXECUTED
4000bd7c: c6 06 20 38 ld [ %i0 + 0x38 ], %g3 <== NOT EXECUTED
4000bd80: c4 06 20 24 ld [ %i0 + 0x24 ], %g2 <== NOT EXECUTED
4000bd84: c2 06 20 30 ld [ %i0 + 0x30 ], %g1 <== NOT EXECUTED
4000bd88: c8 23 a0 68 st %g4, [ %sp + 0x68 ] <== NOT EXECUTED
4000bd8c: 92 17 61 48 or %i5, 0x148, %o1 <== NOT EXECUTED
4000bd90: c6 23 a0 64 st %g3, [ %sp + 0x64 ] <== NOT EXECUTED
4000bd94: 11 10 00 82 sethi %hi(0x40020800), %o0 <== NOT EXECUTED
4000bd98: c4 23 a0 60 st %g2, [ %sp + 0x60 ] <== NOT EXECUTED
4000bd9c: 90 12 20 b8 or %o0, 0xb8, %o0 <== NOT EXECUTED
4000bda0: c2 23 a0 5c st %g1, [ %sp + 0x5c ] <== NOT EXECUTED
4000bda4: d6 06 20 20 ld [ %i0 + 0x20 ], %o3 <== NOT EXECUTED
4000bda8: d4 06 20 28 ld [ %i0 + 0x28 ], %o2 <== NOT EXECUTED
4000bdac: da 06 20 2c ld [ %i0 + 0x2c ], %o5 <== NOT EXECUTED
4000bdb0: 7f ff ff be call 4000bca8 <jffs2_printk> <== NOT EXECUTED
4000bdb4: d8 06 20 1c ld [ %i0 + 0x1c ], %o4 <== NOT EXECUTED
BUG();
4000bdb8: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
4000bdbc: 11 10 00 82 sethi %hi(0x40020800), %o0 <== NOT EXECUTED
4000bdc0: 94 17 61 48 or %i5, 0x148, %o2 <== NOT EXECUTED
4000bdc4: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
4000bdc8: 92 10 20 31 mov 0x31, %o1 <== NOT EXECUTED
4000bdcc: 40 00 0a eb call 4000e978 <__assert_func> <== NOT EXECUTED
4000bdd0: 90 12 20 38 or %o0, 0x38, %o0 <== NOT EXECUTED
JFFS2_ERROR("eeep, space accounting for block at 0x%08x is screwed.\n", jeb->offset);
4000bdd4: 3b 10 00 82 sethi %hi(0x40020800), %i5 <== NOT EXECUTED
4000bdd8: 11 10 00 81 sethi %hi(0x40020400), %o0 <== NOT EXECUTED
4000bddc: 92 17 61 48 or %i5, 0x148, %o1 <== NOT EXECUTED
4000bde0: 7f ff ff b2 call 4000bca8 <jffs2_printk> <== NOT EXECUTED
4000bde4: 90 12 23 78 or %o0, 0x378, %o0 <== NOT EXECUTED
JFFS2_ERROR("free %#08x + dirty %#08x + used %#08x + wasted %#08x + unchecked %#08x != total %#08x.\n",
4000bde8: c4 06 20 34 ld [ %i0 + 0x34 ], %g2 <== NOT EXECUTED
4000bdec: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 <== NOT EXECUTED
4000bdf0: c4 23 a0 60 st %g2, [ %sp + 0x60 ] <== NOT EXECUTED
4000bdf4: 92 17 61 48 or %i5, 0x148, %o1 <== NOT EXECUTED
4000bdf8: c2 23 a0 5c st %g1, [ %sp + 0x5c ] <== NOT EXECUTED
4000bdfc: 11 10 00 81 sethi %hi(0x40020400), %o0 <== NOT EXECUTED
4000be00: d6 06 60 18 ld [ %i1 + 0x18 ], %o3 <== NOT EXECUTED
4000be04: d4 06 60 20 ld [ %i1 + 0x20 ], %o2 <== NOT EXECUTED
4000be08: da 06 60 1c ld [ %i1 + 0x1c ], %o5 <== NOT EXECUTED
4000be0c: d8 06 60 14 ld [ %i1 + 0x14 ], %o4 <== NOT EXECUTED
4000be10: 7f ff ff a6 call 4000bca8 <jffs2_printk> <== NOT EXECUTED
4000be14: 90 12 23 c8 or %o0, 0x3c8, %o0 <== NOT EXECUTED
BUG();
4000be18: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
4000be1c: 11 10 00 82 sethi %hi(0x40020800), %o0 <== NOT EXECUTED
4000be20: 94 17 61 48 or %i5, 0x148, %o2 <== NOT EXECUTED
4000be24: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
4000be28: 92 10 20 28 mov 0x28, %o1 <== NOT EXECUTED
4000be2c: 40 00 0a d3 call 4000e978 <__assert_func> <== NOT EXECUTED
4000be30: 90 12 20 38 or %o0, 0x38, %o0 <== NOT EXECUTED
4000be34: 01 00 00 00 nop <== NOT EXECUTED
40006c5c <__jffs2_ref_totlen>:
}
uint32_t __jffs2_ref_totlen(struct jffs2_sb_info *c, struct jffs2_eraseblock *jeb,
struct jffs2_raw_node_ref *ref)
{
40006c5c: 9d e3 bf a0 save %sp, -96, %sp
if (ref->flash_offset == REF_LINK_NODE) {
40006c60: c2 06 a0 0c ld [ %i2 + 0xc ], %g1
jeb = &c->blocks[ref->flash_offset / c->sector_size];
40006c64: c4 06 a0 04 ld [ %i2 + 4 ], %g2
40006c68: 80 a0 7f ff cmp %g1, -1
40006c6c: 02 80 00 09 be 40006c90 <__jffs2_ref_totlen+0x34>
40006c70: 94 08 bf fc and %g2, -4, %o2
if (ref->flash_offset == REF_EMPTY_NODE)
40006c74: 80 a0 7f fe cmp %g1, -2
40006c78: 22 80 00 0c be,a 40006ca8 <__jffs2_ref_totlen+0x4c>
40006c7c: 80 a6 60 00 cmp %i1, 0
ref_end = ref_offset(next_ref);
40006c80: b0 08 7f fc and %g1, -4, %i0
ret = ref->__totlen;
}
#endif /* TEST_TOTLEN */
return ret;
}
40006c84: b0 26 00 0a sub %i0, %o2, %i0
40006c88: 81 c7 e0 08 ret
40006c8c: 81 e8 00 00 restore
ref = ref->next_in_ino;
40006c90: c2 06 a0 08 ld [ %i2 + 8 ], %g1
if (!ref)
40006c94: 80 a0 60 00 cmp %g1, 0
40006c98: 02 80 00 04 be 40006ca8 <__jffs2_ref_totlen+0x4c> <== NEVER TAKEN
40006c9c: 80 a6 60 00 cmp %i1, 0
if (ref->flash_offset == REF_EMPTY_NODE)
40006ca0: 10 bf ff f5 b 40006c74 <__jffs2_ref_totlen+0x18>
40006ca4: c2 00 60 04 ld [ %g1 + 4 ], %g1
if (!jeb)
40006ca8: 22 80 00 0e be,a 40006ce0 <__jffs2_ref_totlen+0x84> <== NEVER TAKEN
40006cac: f2 06 20 54 ld [ %i0 + 0x54 ], %i1 <== NOT EXECUTED
if (unlikely(ref != jeb->last_node)) {
40006cb0: d6 06 60 2c ld [ %i1 + 0x2c ], %o3
40006cb4: 80 a6 80 0b cmp %i2, %o3
40006cb8: 32 80 00 12 bne,a 40006d00 <__jffs2_ref_totlen+0xa4> <== NEVER TAKEN
40006cbc: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED
ref_end = jeb->offset + c->sector_size - jeb->free_size;
40006cc0: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
40006cc4: c4 06 60 0c ld [ %i1 + 0xc ], %g2
40006cc8: f0 06 60 20 ld [ %i1 + 0x20 ], %i0
40006ccc: 82 00 80 01 add %g2, %g1, %g1
40006cd0: b0 20 40 18 sub %g1, %i0, %i0
}
40006cd4: b0 26 00 0a sub %i0, %o2, %i0
40006cd8: 81 c7 e0 08 ret
40006cdc: 81 e8 00 00 restore
jeb = &c->blocks[ref->flash_offset / c->sector_size];
40006ce0: 81 80 20 00 wr %g0, %y <== NOT EXECUTED
40006ce4: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 <== NOT EXECUTED
40006ce8: 01 00 00 00 nop <== NOT EXECUTED
40006cec: 01 00 00 00 nop <== NOT EXECUTED
40006cf0: 82 70 80 01 udiv %g2, %g1, %g1 <== NOT EXECUTED
40006cf4: 82 58 60 34 smul %g1, 0x34, %g1 <== NOT EXECUTED
40006cf8: 10 bf ff ee b 40006cb0 <__jffs2_ref_totlen+0x54> <== NOT EXECUTED
40006cfc: b2 06 40 01 add %i1, %g1, %i1 <== NOT EXECUTED
pr_crit("ref %p @0x%08x is not jeb->last_node (%p @0x%08x)\n",
40006d00: 22 80 00 04 be,a 40006d10 <__jffs2_ref_totlen+0xb4> <== NOT EXECUTED
40006d04: 98 10 20 00 clr %o4 <== NOT EXECUTED
40006d08: d8 02 e0 04 ld [ %o3 + 4 ], %o4 <== NOT EXECUTED
40006d0c: 98 0b 3f fc and %o4, -4, %o4 <== NOT EXECUTED
40006d10: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40006d14: 11 10 00 7b sethi %hi(0x4001ec00), %o0 <== NOT EXECUTED
40006d18: 7f ff fc 15 call 40005d6c <jffs2_printk> <== NOT EXECUTED
40006d1c: 90 12 23 30 or %o0, 0x330, %o0 ! 4001ef30 <__func__.4+0x180> <== NOT EXECUTED
BUG();
40006d20: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
40006d24: 15 10 00 7b sethi %hi(0x4001ec00), %o2 <== NOT EXECUTED
40006d28: 11 10 00 7b sethi %hi(0x4001ec00), %o0 <== NOT EXECUTED
40006d2c: 92 10 22 c9 mov 0x2c9, %o1 <== NOT EXECUTED
40006d30: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
40006d34: 94 12 a3 70 or %o2, 0x370, %o2 <== NOT EXECUTED
40006d38: 40 00 1f 10 call 4000e978 <__assert_func> <== NOT EXECUTED
40006d3c: 90 12 22 08 or %o0, 0x208, %o0 <== NOT EXECUTED
40006d40: 01 00 00 00 nop <== NOT EXECUTED
40005e34 <jffs2_add_fd_to_list>:
{
40005e34: 9d e3 bf a0 save %sp, -96, %sp
while ((*prev) && (*prev)->nhash <= new->nhash) {
40005e38: fa 06 80 00 ld [ %i2 ], %i5
40005e3c: 80 a7 60 00 cmp %i5, 0
40005e40: 02 80 00 28 be 40005ee0 <jffs2_add_fd_to_list+0xac>
40005e44: b6 06 60 15 add %i1, 0x15, %i3
40005e48: 10 80 00 06 b 40005e60 <jffs2_add_fd_to_list+0x2c>
40005e4c: f8 06 60 10 ld [ %i1 + 0x10 ], %i4
40005e50: fa 07 60 04 ld [ %i5 + 4 ], %i5
40005e54: 80 a7 60 00 cmp %i5, 0
40005e58: 22 80 00 23 be,a 40005ee4 <jffs2_add_fd_to_list+0xb0>
40005e5c: fa 26 60 04 st %i5, [ %i1 + 4 ]
40005e60: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40005e64: 80 a0 40 1c cmp %g1, %i4
40005e68: 38 80 00 1f bgu,a 40005ee4 <jffs2_add_fd_to_list+0xb0>
40005e6c: fa 26 60 04 st %i5, [ %i1 + 4 ]
if ((*prev)->nhash == new->nhash && !strcmp((*prev)->name, new->name)) {
40005e70: 32 bf ff f8 bne,a 40005e50 <jffs2_add_fd_to_list+0x1c>
40005e74: b4 07 60 04 add %i5, 4, %i2
40005e78: 90 07 60 15 add %i5, 0x15, %o0
40005e7c: 40 00 5d 0b call 4001d2a8 <strcmp>
40005e80: 92 10 00 1b mov %i3, %o1
40005e84: 80 a2 20 00 cmp %o0, 0
40005e88: 32 bf ff f2 bne,a 40005e50 <jffs2_add_fd_to_list+0x1c> <== NEVER TAKEN
40005e8c: b4 07 60 04 add %i5, 4, %i2 <== NOT EXECUTED
if (new->version < (*prev)->version) {
40005e90: c4 06 60 08 ld [ %i1 + 8 ], %g2
40005e94: c2 07 60 08 ld [ %i5 + 8 ], %g1
40005e98: 80 a0 80 01 cmp %g2, %g1
40005e9c: 2a 80 00 15 bcs,a 40005ef0 <jffs2_add_fd_to_list+0xbc> <== NEVER TAKEN
40005ea0: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
new->next = (*prev)->next;
40005ea4: c2 07 60 04 ld [ %i5 + 4 ], %g1
40005ea8: c2 26 60 04 st %g1, [ %i1 + 4 ]
if ((*prev)->raw)
40005eac: d0 06 80 00 ld [ %i2 ], %o0
40005eb0: d2 02 00 00 ld [ %o0 ], %o1
40005eb4: 80 a2 60 00 cmp %o1, 0
40005eb8: 02 80 00 05 be 40005ecc <jffs2_add_fd_to_list+0x98>
40005ebc: 01 00 00 00 nop
jffs2_mark_node_obsolete(c, ((*prev)->raw));
40005ec0: 40 00 04 14 call 40006f10 <jffs2_mark_node_obsolete>
40005ec4: 90 10 00 18 mov %i0, %o0
jffs2_free_full_dirent(*prev);
40005ec8: d0 06 80 00 ld [ %i2 ], %o0
40005ecc: 7f ff ff 30 call 40005b8c <jffs2_free_full_dirent>
40005ed0: 01 00 00 00 nop
*prev = new;
40005ed4: f2 26 80 00 st %i1, [ %i2 ]
40005ed8: 81 c7 e0 08 ret
40005edc: 81 e8 00 00 restore
new->next = *prev;
40005ee0: fa 26 60 04 st %i5, [ %i1 + 4 ]
*prev = new;
40005ee4: f2 26 80 00 st %i1, [ %i2 ]
}
40005ee8: 81 c7 e0 08 ret
40005eec: 81 e8 00 00 restore
jffs2_mark_node_obsolete(c, new->raw);
40005ef0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40005ef4: 40 00 04 07 call 40006f10 <jffs2_mark_node_obsolete> <== NOT EXECUTED
40005ef8: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED
jffs2_free_full_dirent(new);
40005efc: 7f ff ff 24 call 40005b8c <jffs2_free_full_dirent> <== NOT EXECUTED
40005f00: 81 e8 00 00 restore <== NOT EXECUTED
40006094 <jffs2_add_full_dnode_to_inode>:
{
40006094: 9d e3 bf a0 save %sp, -96, %sp
if (unlikely(!fn->size))
40006098: e4 06 a0 08 ld [ %i2 + 8 ], %l2
4000609c: 80 a4 a0 00 cmp %l2, 0
400060a0: 12 80 00 04 bne 400060b0 <jffs2_add_full_dnode_to_inode+0x1c> <== ALWAYS TAKEN
400060a4: 01 00 00 00 nop
return 0;
400060a8: 81 c7 e0 08 ret
400060ac: 91 e8 20 00 restore %g0, 0, %o0
newfrag = jffs2_alloc_node_frag();
400060b0: 7f ff ff 0b call 40005cdc <jffs2_alloc_node_frag>
400060b4: e6 06 a0 04 ld [ %i2 + 4 ], %l3
if (likely(newfrag)) {
400060b8: b6 92 20 00 orcc %o0, 0, %i3
400060bc: 02 80 00 f4 be 4000648c <jffs2_add_full_dnode_to_inode+0x3f8> <== NEVER TAKEN
400060c0: 82 10 20 01 mov 1, %g1
newfrag->ofs = ofs;
400060c4: e6 26 e0 18 st %l3, [ %i3 + 0x18 ]
newfrag->size = size;
400060c8: e4 26 e0 14 st %l2, [ %i3 + 0x14 ]
ret = jffs2_add_frag_to_fragtree(c, &f->fragtree, newfrag);
400060cc: a2 06 60 04 add %i1, 4, %l1
newfrag->node = fn;
400060d0: f4 26 e0 10 st %i2, [ %i3 + 0x10 ]
struct jffs2_node_frag *prev = NULL;
400060d4: 84 10 20 00 clr %g2
newfrag->node->frags = 1;
400060d8: c2 26 a0 0c st %g1, [ %i2 + 0xc ]
next = fragtree->rb_node;
400060dc: fa 06 60 04 ld [ %i1 + 4 ], %i5
while(next) {
400060e0: 80 a7 60 00 cmp %i5, 0
400060e4: 02 80 00 6b be 40006290 <jffs2_add_full_dnode_to_inode+0x1fc>
400060e8: e0 06 a0 04 ld [ %i2 + 4 ], %l0
if (frag->ofs + frag->size <= offset) {
400060ec: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
400060f0: f8 07 60 14 ld [ %i5 + 0x14 ], %i4
400060f4: b8 00 40 1c add %g1, %i4, %i4
400060f8: 80 a4 00 1c cmp %l0, %i4
400060fc: 0a 80 00 61 bcs 40006280 <jffs2_add_full_dnode_to_inode+0x1ec>
40006100: 80 a4 00 01 cmp %l0, %g1
if (!prev || frag->ofs > prev->ofs)
40006104: 80 a0 a0 00 cmp %g2, 0
40006108: 22 80 00 06 be,a 40006120 <jffs2_add_full_dnode_to_inode+0x8c>
4000610c: 84 10 00 1d mov %i5, %g2
40006110: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
40006114: 80 a0 40 03 cmp %g1, %g3
40006118: 38 80 00 02 bgu,a 40006120 <jffs2_add_full_dnode_to_inode+0x8c> <== ALWAYS TAKEN
4000611c: 84 10 00 1d mov %i5, %g2
next = frag->rb.rb_right;
40006120: fa 07 60 04 ld [ %i5 + 4 ], %i5
while(next) {
40006124: 80 a7 60 00 cmp %i5, 0
40006128: 32 bf ff f2 bne,a 400060f0 <jffs2_add_full_dnode_to_inode+0x5c>
4000612c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
if (this) {
40006130: 80 a0 a0 00 cmp %g2, 0
40006134: 02 80 00 57 be 40006290 <jffs2_add_full_dnode_to_inode+0x1fc> <== NEVER TAKEN
40006138: ba 10 00 02 mov %g2, %i5
lastend = this->ofs + this->size;
4000613c: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1
40006140: f8 00 a0 14 ld [ %g2 + 0x14 ], %i4
40006144: b8 00 40 1c add %g1, %i4, %i4
if (lastend <= newfrag->ofs) {
40006148: 80 a4 c0 1c cmp %l3, %i4
4000614c: 1a 80 00 a1 bcc 400063d0 <jffs2_add_full_dnode_to_inode+0x33c>
40006150: 80 a4 c0 01 cmp %l3, %g1
if (newfrag->ofs > this->ofs) {
40006154: 08 80 00 b6 bleu 4000642c <jffs2_add_full_dnode_to_inode+0x398>
40006158: 94 10 00 1b mov %i3, %o2
mark_ref_normal(newfrag->node->raw);
4000615c: c6 06 80 00 ld [ %i2 ], %g3
40006160: c4 00 e0 04 ld [ %g3 + 4 ], %g2
if (this->node)
40006164: e0 07 60 10 ld [ %i5 + 0x10 ], %l0
mark_ref_normal(newfrag->node->raw);
40006168: 84 10 a0 03 or %g2, 3, %g2
if (this->node)
4000616c: 80 a4 20 00 cmp %l0, 0
40006170: 02 80 00 06 be 40006188 <jffs2_add_full_dnode_to_inode+0xf4>
40006174: c4 20 e0 04 st %g2, [ %g3 + 4 ]
mark_ref_normal(this->node->raw);
40006178: c6 04 00 00 ld [ %l0 ], %g3
4000617c: c4 00 e0 04 ld [ %g3 + 4 ], %g2
40006180: 84 10 a0 03 or %g2, 3, %g2
40006184: c4 20 e0 04 st %g2, [ %g3 + 4 ]
if (this->ofs + this->size > newfrag->ofs + newfrag->size) {
40006188: a4 04 80 13 add %l2, %l3, %l2
4000618c: 80 a4 80 1c cmp %l2, %i4
40006190: 1a 80 00 5f bcc 4000630c <jffs2_add_full_dnode_to_inode+0x278> <== ALWAYS TAKEN
40006194: 82 24 c0 01 sub %l3, %g1, %g1
newfrag = jffs2_alloc_node_frag();
40006198: 7f ff fe d1 call 40005cdc <jffs2_alloc_node_frag> <== NOT EXECUTED
4000619c: b8 27 00 12 sub %i4, %l2, %i4 <== NOT EXECUTED
if (likely(newfrag)) {
400061a0: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
400061a4: 02 80 00 bb be 40006490 <jffs2_add_full_dnode_to_inode+0x3fc> <== NOT EXECUTED
400061a8: 13 10 00 7b sethi %hi(0x4001ec00), %o1 <== NOT EXECUTED
newfrag->node = fn;
400061ac: e0 26 60 10 st %l0, [ %i1 + 0x10 ] <== NOT EXECUTED
newfrag->ofs = ofs;
400061b0: e4 26 60 18 st %l2, [ %i1 + 0x18 ] <== NOT EXECUTED
newfrag->size = size;
400061b4: f8 26 60 14 st %i4, [ %i1 + 0x14 ] <== NOT EXECUTED
if (this->node)
400061b8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
400061bc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400061c0: 02 80 00 05 be 400061d4 <jffs2_add_full_dnode_to_inode+0x140> <== NOT EXECUTED
400061c4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
this->node->frags++;
400061c8: c4 00 60 0c ld [ %g1 + 0xc ], %g2 <== NOT EXECUTED
400061cc: 84 00 a0 01 inc %g2 <== NOT EXECUTED
400061d0: c4 20 60 0c st %g2, [ %g1 + 0xc ] <== NOT EXECUTED
this->size = newfrag->ofs - this->ofs;
400061d4: c4 07 60 18 ld [ %i5 + 0x18 ], %g2 <== NOT EXECUTED
400061d8: c2 06 e0 18 ld [ %i3 + 0x18 ], %g1 <== NOT EXECUTED
400061dc: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
400061e0: c2 27 60 14 st %g1, [ %i5 + 0x14 ] <== NOT EXECUTED
jffs2_fragtree_insert(newfrag, this);
400061e4: 7f ff fe ee call 40005d9c <jffs2_fragtree_insert> <== NOT EXECUTED
400061e8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
_RBTree_Insert_color( (RBTree_Control *) root, node );
400061ec: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
400061f0: 40 00 3d 52 call 40015738 <_RBTree_Insert_color> <== NOT EXECUTED
400061f4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
jffs2_fragtree_insert(newfrag2, newfrag);
400061f8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
400061fc: 7f ff fe e8 call 40005d9c <jffs2_fragtree_insert> <== NOT EXECUTED
40006200: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
40006204: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40006208: 40 00 3d 4c call 40015738 <_RBTree_Insert_color> <== NOT EXECUTED
4000620c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
if (newfrag->ofs & (PAGE_SIZE-1)) {
40006210: c6 06 e0 18 ld [ %i3 + 0x18 ], %g3 <== NOT EXECUTED
40006214: 80 88 ef ff btst 0xfff, %g3
40006218: 12 80 00 2d bne 400062cc <jffs2_add_full_dnode_to_inode+0x238>
4000621c: 01 00 00 00 nop
if ((newfrag->ofs+newfrag->size) & (PAGE_SIZE-1)) {
40006220: c2 06 e0 14 ld [ %i3 + 0x14 ], %g1
40006224: 86 00 c0 01 add %g3, %g1, %g3
40006228: 80 88 ef ff btst 0xfff, %g3
4000622c: 02 bf ff 9f be 400060a8 <jffs2_add_full_dnode_to_inode+0x14>
40006230: 01 00 00 00 nop
return _RBTree_Successor( node );
40006234: 40 00 3d f0 call 400159f4 <_RBTree_Successor>
40006238: 90 10 00 1b mov %i3, %o0
if (next) {
4000623c: 80 a2 20 00 cmp %o0, 0
40006240: 02 bf ff 9a be 400060a8 <jffs2_add_full_dnode_to_inode+0x14>
40006244: 01 00 00 00 nop
mark_ref_normal(fn->raw);
40006248: c4 06 80 00 ld [ %i2 ], %g2
4000624c: c2 00 a0 04 ld [ %g2 + 4 ], %g1
40006250: 82 10 60 03 or %g1, 3, %g1
40006254: c2 20 a0 04 st %g1, [ %g2 + 4 ]
if (next->node)
40006258: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
4000625c: 80 a0 60 00 cmp %g1, 0
40006260: 02 bf ff 92 be 400060a8 <jffs2_add_full_dnode_to_inode+0x14> <== NEVER TAKEN
40006264: 01 00 00 00 nop
mark_ref_normal(next->node->raw);
40006268: c4 00 40 00 ld [ %g1 ], %g2
4000626c: c2 00 a0 04 ld [ %g2 + 4 ], %g1
40006270: 82 10 60 03 or %g1, 3, %g1
40006274: c2 20 a0 04 st %g1, [ %g2 + 4 ]
}
40006278: 81 c7 e0 08 ret
4000627c: 91 e8 20 00 restore %g0, 0, %o0
} else if (frag->ofs > offset) {
40006280: 1a bf ff b3 bcc 4000614c <jffs2_add_full_dnode_to_inode+0xb8>
40006284: 80 a4 c0 1c cmp %l3, %i4
40006288: 10 bf ff a7 b 40006124 <jffs2_add_full_dnode_to_inode+0x90>
4000628c: fa 07 40 00 ld [ %i5 ], %i5
if (lastend < newfrag->node->ofs) {
40006290: 80 a4 20 00 cmp %l0, 0
40006294: 12 80 00 a6 bne 4000652c <jffs2_add_full_dnode_to_inode+0x498>
40006298: 82 10 20 01 mov 1, %g1
RB_SET( child, parent, Node );
4000629c: c0 26 e0 08 clr [ %i3 + 8 ]
400062a0: c0 26 e0 04 clr [ %i3 + 4 ]
_RBTree_Insert_color( (RBTree_Control *) root, node );
400062a4: 92 10 00 1b mov %i3, %o1
400062a8: c0 26 c0 00 clr [ %i3 ]
400062ac: 90 10 00 11 mov %l1, %o0
400062b0: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
400062b4: 40 00 3d 21 call 40015738 <_RBTree_Insert_color>
400062b8: f6 26 60 04 st %i3, [ %i1 + 4 ]
if (newfrag->ofs & (PAGE_SIZE-1)) {
400062bc: c6 06 e0 18 ld [ %i3 + 0x18 ], %g3
400062c0: 80 88 ef ff btst 0xfff, %g3
400062c4: 22 bf ff d8 be,a 40006224 <jffs2_add_full_dnode_to_inode+0x190>
400062c8: c2 06 e0 14 ld [ %i3 + 0x14 ], %g1
return _RBTree_Predecessor( node );
400062cc: 40 00 3d ed call 40015a80 <_RBTree_Predecessor>
400062d0: 90 10 00 1b mov %i3, %o0
mark_ref_normal(fn->raw);
400062d4: c4 06 80 00 ld [ %i2 ], %g2
400062d8: c2 00 a0 04 ld [ %g2 + 4 ], %g1
400062dc: 82 10 60 03 or %g1, 3, %g1
400062e0: c2 20 a0 04 st %g1, [ %g2 + 4 ]
if (prev->node)
400062e4: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
400062e8: 80 a0 60 00 cmp %g1, 0
400062ec: 22 bf ff cd be,a 40006220 <jffs2_add_full_dnode_to_inode+0x18c>
400062f0: c6 06 e0 18 ld [ %i3 + 0x18 ], %g3
mark_ref_normal(prev->node->raw);
400062f4: c4 00 40 00 ld [ %g1 ], %g2
400062f8: c2 00 a0 04 ld [ %g2 + 4 ], %g1
400062fc: 82 10 60 03 or %g1, 3, %g1
40006300: c2 20 a0 04 st %g1, [ %g2 + 4 ]
if ((newfrag->ofs+newfrag->size) & (PAGE_SIZE-1)) {
40006304: 10 bf ff c7 b 40006220 <jffs2_add_full_dnode_to_inode+0x18c>
40006308: c6 06 e0 18 ld [ %i3 + 0x18 ], %g3
this->size = newfrag->ofs - this->ofs;
4000630c: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
jffs2_fragtree_insert(newfrag, this);
40006310: 92 10 00 1d mov %i5, %o1
40006314: 7f ff fe a2 call 40005d9c <jffs2_fragtree_insert>
40006318: 90 10 00 1b mov %i3, %o0
_RBTree_Insert_color( (RBTree_Control *) root, node );
4000631c: 92 10 00 1b mov %i3, %o1
40006320: 40 00 3d 06 call 40015738 <_RBTree_Insert_color>
40006324: 90 10 00 11 mov %l1, %o0
}
40006328: 30 80 00 06 b,a 40006340 <jffs2_add_full_dnode_to_inode+0x2ac>
_RBTree_Extract( (RBTree_Control *) root, node );
4000632c: 40 00 3b 9b call 40015198 <_RBTree_Extract>
40006330: 90 10 00 11 mov %l1, %o0
jffs2_obsolete_node_frag(c, this);
40006334: 92 10 00 1d mov %i5, %o1
40006338: 7f ff fe 77 call 40005d14 <jffs2_obsolete_node_frag>
4000633c: 90 10 00 18 mov %i0, %o0
return _RBTree_Successor( node );
40006340: 40 00 3d ad call 400159f4 <_RBTree_Successor>
40006344: 90 10 00 1b mov %i3, %o0
while ((this = frag_next(newfrag)) && newfrag->ofs + newfrag->size >= this->ofs + this->size) {
40006348: c6 06 e0 18 ld [ %i3 + 0x18 ], %g3
4000634c: 80 a2 20 00 cmp %o0, 0
40006350: 02 bf ff b1 be 40006214 <jffs2_add_full_dnode_to_inode+0x180>
40006354: ba 10 00 08 mov %o0, %i5
40006358: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
4000635c: c8 02 20 18 ld [ %o0 + 0x18 ], %g4
40006360: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40006364: 84 00 c0 02 add %g3, %g2, %g2
40006368: 82 01 00 01 add %g4, %g1, %g1
4000636c: 80 a0 80 01 cmp %g2, %g1
40006370: 1a bf ff ef bcc 4000632c <jffs2_add_full_dnode_to_inode+0x298>
40006374: 92 10 00 1d mov %i5, %o1
if (!this || newfrag->ofs + newfrag->size == this->ofs)
40006378: 80 a0 80 04 cmp %g2, %g4
4000637c: 02 bf ff a6 be 40006214 <jffs2_add_full_dnode_to_inode+0x180>
40006380: 82 20 40 02 sub %g1, %g2, %g1
this->size = (this->ofs + this->size) - (newfrag->ofs + newfrag->size);
40006384: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
this->ofs = newfrag->ofs + newfrag->size;
40006388: c2 06 e0 14 ld [ %i3 + 0x14 ], %g1
4000638c: 86 00 40 03 add %g1, %g3, %g3
40006390: c6 27 60 18 st %g3, [ %i5 + 0x18 ]
if (this->node)
40006394: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40006398: 80 a0 60 00 cmp %g1, 0
4000639c: 22 80 00 07 be,a 400063b8 <jffs2_add_full_dnode_to_inode+0x324> <== NEVER TAKEN
400063a0: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1 <== NOT EXECUTED
mark_ref_normal(this->node->raw);
400063a4: c4 00 40 00 ld [ %g1 ], %g2
400063a8: c2 00 a0 04 ld [ %g2 + 4 ], %g1
400063ac: 82 10 60 03 or %g1, 3, %g1
400063b0: c2 20 a0 04 st %g1, [ %g2 + 4 ]
mark_ref_normal(newfrag->node->raw);
400063b4: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
400063b8: c4 00 40 00 ld [ %g1 ], %g2
400063bc: c2 00 a0 04 ld [ %g2 + 4 ], %g1
400063c0: 82 10 60 03 or %g1, 3, %g1
if (newfrag->ofs & (PAGE_SIZE-1)) {
400063c4: c6 06 e0 18 ld [ %i3 + 0x18 ], %g3
mark_ref_normal(newfrag->node->raw);
400063c8: 10 bf ff 93 b 40006214 <jffs2_add_full_dnode_to_inode+0x180>
400063cc: c2 20 a0 04 st %g1, [ %g2 + 4 ]
if (lastend && (lastend-1) >> PAGE_SHIFT == newfrag->ofs >> PAGE_SHIFT) {
400063d0: 80 a7 20 00 cmp %i4, 0
400063d4: 02 80 00 07 be 400063f0 <jffs2_add_full_dnode_to_inode+0x35c> <== NEVER TAKEN
400063d8: 82 07 3f ff add %i4, -1, %g1
400063dc: a7 34 e0 0c srl %l3, 0xc, %l3
400063e0: 83 30 60 0c srl %g1, 0xc, %g1
400063e4: 80 a0 40 13 cmp %g1, %l3
400063e8: 22 80 00 45 be,a 400064fc <jffs2_add_full_dnode_to_inode+0x468>
400063ec: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
if (lastend < newfrag->node->ofs) {
400063f0: 80 a4 00 1c cmp %l0, %i4
400063f4: 18 80 00 2e bgu 400064ac <jffs2_add_full_dnode_to_inode+0x418> <== NEVER TAKEN
400063f8: 01 00 00 00 nop
rb_link_node(&newfrag->rb, &this->rb, &this->rb.rb_right);
400063fc: b8 10 00 1d mov %i5, %i4
40006400: fa 26 e0 08 st %i5, [ %i3 + 8 ]
40006404: 82 10 20 01 mov 1, %g1
40006408: c0 26 e0 04 clr [ %i3 + 4 ]
_RBTree_Insert_color( (RBTree_Control *) root, node );
4000640c: 92 10 00 1b mov %i3, %o1
40006410: c0 26 c0 00 clr [ %i3 ]
40006414: 90 10 00 11 mov %l1, %o0
40006418: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
4000641c: 40 00 3c c7 call 40015738 <_RBTree_Insert_color>
40006420: f6 27 60 04 st %i3, [ %i5 + 4 ]
if (newfrag->ofs & (PAGE_SIZE-1)) {
40006424: 10 bf ff a7 b 400062c0 <jffs2_add_full_dnode_to_inode+0x22c>
40006428: c6 06 e0 18 ld [ %i3 + 0x18 ], %g3
struct rb_node *victim,
struct rb_node *replacement,
struct rb_root *root
)
{
_RBTree_Replace_node(
4000642c: 92 10 00 1d mov %i5, %o1
40006430: 40 00 3d db call 40015b9c <_RBTree_Replace_node>
40006434: 90 10 00 11 mov %l1, %o0
if (newfrag->ofs + newfrag->size >= this->ofs+this->size) {
40006438: c8 06 e0 14 ld [ %i3 + 0x14 ], %g4
4000643c: c6 07 60 18 ld [ %i5 + 0x18 ], %g3
40006440: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
40006444: c2 06 e0 18 ld [ %i3 + 0x18 ], %g1
40006448: 82 01 00 01 add %g4, %g1, %g1
4000644c: b8 00 c0 02 add %g3, %g2, %i4
40006450: 80 a0 40 1c cmp %g1, %i4
40006454: 1a bf ff b9 bcc 40006338 <jffs2_add_full_dnode_to_inode+0x2a4> <== ALWAYS TAKEN
40006458: 92 10 00 1d mov %i5, %o1
this->ofs += newfrag->size;
4000645c: 86 01 00 03 add %g4, %g3, %g3 <== NOT EXECUTED
this->size -= newfrag->size;
40006460: 84 20 80 04 sub %g2, %g4, %g2 <== NOT EXECUTED
this->ofs += newfrag->size;
40006464: c6 27 60 18 st %g3, [ %i5 + 0x18 ] <== NOT EXECUTED
jffs2_fragtree_insert(this, newfrag);
40006468: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
this->size -= newfrag->size;
4000646c: c4 27 60 14 st %g2, [ %i5 + 0x14 ] <== NOT EXECUTED
jffs2_fragtree_insert(this, newfrag);
40006470: 7f ff fe 4b call 40005d9c <jffs2_fragtree_insert> <== NOT EXECUTED
40006474: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
_RBTree_Insert_color( (RBTree_Control *) root, node );
40006478: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000647c: 40 00 3c af call 40015738 <_RBTree_Insert_color> <== NOT EXECUTED
40006480: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
if (newfrag->ofs & (PAGE_SIZE-1)) {
40006484: 10 bf ff 64 b 40006214 <jffs2_add_full_dnode_to_inode+0x180> <== NOT EXECUTED
40006488: c6 06 e0 18 ld [ %i3 + 0x18 ], %g3 <== NOT EXECUTED
JFFS2_ERROR("cannot allocate a jffs2_node_frag object\n");
4000648c: 13 10 00 7b sethi %hi(0x4001ec00), %o1 <== NOT EXECUTED
40006490: 11 10 00 7b sethi %hi(0x4001ec00), %o0 <== NOT EXECUTED
40006494: 92 12 63 c8 or %o1, 0x3c8, %o1 <== NOT EXECUTED
40006498: 90 12 22 38 or %o0, 0x238, %o0 <== NOT EXECUTED
4000649c: 7f ff fe 34 call 40005d6c <jffs2_printk> <== NOT EXECUTED
400064a0: b0 10 3f f4 mov -12, %i0 <== NOT EXECUTED
if (unlikely(!newfrag))
400064a4: 81 c7 e0 08 ret <== NOT EXECUTED
400064a8: 81 e8 00 00 restore <== NOT EXECUTED
newfrag = jffs2_alloc_node_frag();
400064ac: 7f ff fe 0c call 40005cdc <jffs2_alloc_node_frag> <== NOT EXECUTED
400064b0: a0 24 00 1c sub %l0, %i4, %l0 <== NOT EXECUTED
if (likely(newfrag)) {
400064b4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400064b8: 02 80 00 2c be 40006568 <jffs2_add_full_dnode_to_inode+0x4d4> <== NOT EXECUTED
400064bc: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
newfrag->ofs = ofs;
400064c0: f8 22 20 18 st %i4, [ %o0 + 0x18 ] <== NOT EXECUTED
400064c4: fa 22 20 08 st %i5, [ %o0 + 8 ] <== NOT EXECUTED
rb_link_node(&holefrag->rb, &this->rb, &this->rb.rb_right);
400064c8: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
newfrag->size = size;
400064cc: e0 22 20 14 st %l0, [ %o0 + 0x14 ] <== NOT EXECUTED
newfrag->node = fn;
400064d0: c0 22 20 10 clr [ %o0 + 0x10 ] <== NOT EXECUTED
400064d4: c0 22 20 04 clr [ %o0 + 4 ] <== NOT EXECUTED
400064d8: c0 22 00 00 clr [ %o0 ] <== NOT EXECUTED
400064dc: c2 22 20 0c st %g1, [ %o0 + 0xc ] <== NOT EXECUTED
*link = child;
400064e0: d0 27 60 04 st %o0, [ %i5 + 4 ] <== NOT EXECUTED
struct rb_node **link
)
{
_RBTree_Initialize_node( node );
_RBTree_Add_child( node, parent, link );
}
400064e4: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
_RBTree_Insert_color( (RBTree_Control *) root, node );
400064e8: 92 10 00 1c mov %i4, %o1
400064ec: 40 00 3c 93 call 40015738 <_RBTree_Insert_color>
400064f0: 90 10 00 11 mov %l1, %o0
RB_SET( child, parent, Node );
400064f4: 10 bf ff c4 b 40006404 <jffs2_add_full_dnode_to_inode+0x370>
400064f8: f8 26 e0 08 st %i4, [ %i3 + 8 ]
if (this->node)
400064fc: 80 a0 60 00 cmp %g1, 0
40006500: 22 80 00 07 be,a 4000651c <jffs2_add_full_dnode_to_inode+0x488> <== NEVER TAKEN
40006504: c4 06 80 00 ld [ %i2 ], %g2 <== NOT EXECUTED
mark_ref_normal(this->node->raw);
40006508: c4 00 40 00 ld [ %g1 ], %g2
4000650c: c2 00 a0 04 ld [ %g2 + 4 ], %g1
40006510: 82 10 60 03 or %g1, 3, %g1
40006514: c2 20 a0 04 st %g1, [ %g2 + 4 ]
mark_ref_normal(newfrag->node->raw);
40006518: c4 06 80 00 ld [ %i2 ], %g2
4000651c: c2 00 a0 04 ld [ %g2 + 4 ], %g1
40006520: 82 10 60 03 or %g1, 3, %g1
40006524: 10 bf ff b3 b 400063f0 <jffs2_add_full_dnode_to_inode+0x35c>
40006528: c2 20 a0 04 st %g1, [ %g2 + 4 ]
newfrag = jffs2_alloc_node_frag();
4000652c: 7f ff fd ec call 40005cdc <jffs2_alloc_node_frag>
40006530: 01 00 00 00 nop
if (likely(newfrag)) {
40006534: ba 92 20 00 orcc %o0, 0, %i5
40006538: 02 80 00 0c be 40006568 <jffs2_add_full_dnode_to_inode+0x4d4> <== NEVER TAKEN
4000653c: 82 10 20 01 mov 1, %g1
newfrag->ofs = ofs;
40006540: c0 27 60 18 clr [ %i5 + 0x18 ]
newfrag->size = size;
40006544: e0 27 60 14 st %l0, [ %i5 + 0x14 ]
rb_link_node(&holefrag->rb, NULL, &root->rb_node);
40006548: b8 10 00 1d mov %i5, %i4
newfrag->node = fn;
4000654c: c0 27 60 10 clr [ %i5 + 0x10 ]
40006550: c0 27 60 08 clr [ %i5 + 8 ]
40006554: c0 27 60 04 clr [ %i5 + 4 ]
40006558: c0 27 40 00 clr [ %i5 ]
4000655c: c2 27 60 0c st %g1, [ %i5 + 0xc ]
}
40006560: 10 bf ff e2 b 400064e8 <jffs2_add_full_dnode_to_inode+0x454>
40006564: fa 26 60 04 st %i5, [ %i1 + 4 ]
JFFS2_ERROR("cannot allocate a jffs2_node_frag object\n");
40006568: 13 10 00 7b sethi %hi(0x4001ec00), %o1 <== NOT EXECUTED
4000656c: 11 10 00 7b sethi %hi(0x4001ec00), %o0 <== NOT EXECUTED
40006570: 92 12 63 c8 or %o1, 0x3c8, %o1 <== NOT EXECUTED
40006574: 7f ff fd fe call 40005d6c <jffs2_printk> <== NOT EXECUTED
40006578: 90 12 22 38 or %o0, 0x238, %o0 <== NOT EXECUTED
jffs2_free_node_frag(newfrag);
4000657c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
40006580: 7f ff fd db call 40005cec <jffs2_free_node_frag> <== NOT EXECUTED
40006584: b0 10 3f f4 mov -12, %i0 <== NOT EXECUTED
if (unlikely(ret))
40006588: 81 c7 e0 08 ret <== NOT EXECUTED
4000658c: 81 e8 00 00 restore <== NOT EXECUTED
40006610 <jffs2_add_ino_cache>:
if (!new->ino)
40006610: c6 02 60 0c ld [ %o1 + 0xc ], %g3
40006614: 80 a0 e0 00 cmp %g3, 0
40006618: 12 80 00 06 bne 40006630 <jffs2_add_ino_cache+0x20>
4000661c: 01 00 00 00 nop
new->ino = ++c->highest_ino;
40006620: c6 02 20 04 ld [ %o0 + 4 ], %g3
40006624: 86 00 e0 01 inc %g3
40006628: c6 22 20 04 st %g3, [ %o0 + 4 ]
4000662c: c6 22 60 0c st %g3, [ %o1 + 0xc ]
prev = &c->inocache_list[new->ino % c->inocache_hashsize];
40006630: 81 80 20 00 wr %g0, %y
40006634: c4 02 20 c0 ld [ %o0 + 0xc0 ], %g2
40006638: 01 00 00 00 nop
4000663c: 01 00 00 00 nop
40006640: 84 70 c0 02 udiv %g3, %g2, %g2
40006644: c8 02 20 c4 ld [ %o0 + 0xc4 ], %g4
40006648: c2 02 20 c0 ld [ %o0 + 0xc0 ], %g1
4000664c: 84 58 80 01 smul %g2, %g1, %g2
40006650: 84 20 c0 02 sub %g3, %g2, %g2
40006654: 85 28 a0 02 sll %g2, 2, %g2
while ((*prev) && (*prev)->ino < new->ino) {
40006658: c2 01 00 02 ld [ %g4 + %g2 ], %g1
4000665c: 80 a0 60 00 cmp %g1, 0
40006660: 12 80 00 08 bne 40006680 <jffs2_add_ino_cache+0x70> <== NEVER TAKEN
40006664: 88 01 00 02 add %g4, %g2, %g4
new->next = *prev;
40006668: 10 80 00 0b b 40006694 <jffs2_add_ino_cache+0x84>
4000666c: c2 22 60 10 st %g1, [ %o1 + 0x10 ]
while ((*prev) && (*prev)->ino < new->ino) {
40006670: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED
40006674: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40006678: 22 80 00 07 be,a 40006694 <jffs2_add_ino_cache+0x84> <== NOT EXECUTED
4000667c: c2 22 60 10 st %g1, [ %o1 + 0x10 ] <== NOT EXECUTED
40006680: c4 00 60 0c ld [ %g1 + 0xc ], %g2 <== NOT EXECUTED
40006684: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
40006688: 2a bf ff fa bcs,a 40006670 <jffs2_add_ino_cache+0x60> <== NOT EXECUTED
4000668c: 88 00 60 10 add %g1, 0x10, %g4 <== NOT EXECUTED
new->next = *prev;
40006690: c2 22 60 10 st %g1, [ %o1 + 0x10 ] <== NOT EXECUTED
}
40006694: 81 c3 e0 08 retl
40006698: d2 21 00 00 st %o1, [ %g4 ]
40006d74 <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)
{
40006d74: 9d e3 bf a0 save %sp, -96, %sp
struct jffs2_eraseblock *jeb;
struct jffs2_raw_node_ref *new;
jeb = &c->blocks[ofs / c->sector_size];
40006d78: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
40006d7c: e2 06 20 54 ld [ %i0 + 0x54 ], %l1
__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))
40006d80: c4 06 20 58 ld [ %i0 + 0x58 ], %g2
jeb = &c->blocks[ofs / c->sector_size];
40006d84: 81 80 20 00 wr %g0, %y
40006d88: 01 00 00 00 nop
40006d8c: 01 00 00 00 nop
40006d90: 01 00 00 00 nop
40006d94: a0 76 40 01 udiv %i1, %g1, %l0
{
40006d98: ba 10 00 18 mov %i0, %i5
jeb = &c->blocks[ofs / c->sector_size];
40006d9c: a0 5c 20 34 smul %l0, 0x34, %l0
if ((c->nextblock || ((ofs & 3) != REF_OBSOLETE))
40006da0: 80 a0 a0 00 cmp %g2, 0
40006da4: 02 80 00 23 be 40006e30 <jffs2_add_physical_node_ref+0xbc> <== NEVER TAKEN
40006da8: b8 04 40 10 add %l1, %l0, %i4
&& (jeb != c->nextblock || (ofs & ~3) != jeb->offset + (c->sector_size - jeb->free_size))) {
40006dac: 80 a0 80 1c cmp %g2, %i4
40006db0: 12 80 00 09 bne 40006dd4 <jffs2_add_physical_node_ref+0x60> <== NEVER TAKEN
40006db4: 92 0e 7f fc and %i1, -4, %o1
40006db8: c6 07 20 0c ld [ %i4 + 0xc ], %g3
40006dbc: c4 07 20 20 ld [ %i4 + 0x20 ], %g2
40006dc0: 82 00 40 03 add %g1, %g3, %g1
40006dc4: 82 20 40 02 sub %g1, %g2, %g1
40006dc8: 80 a0 40 09 cmp %g1, %o1
40006dcc: 02 80 00 1e be 40006e44 <jffs2_add_physical_node_ref+0xd0> <== ALWAYS TAKEN
40006dd0: 98 10 00 1b mov %i3, %o4
pr_warn("argh. node added in wrong place at 0x%08x(%d)\n",
40006dd4: 94 0e 60 03 and %i1, 3, %o2 <== NOT EXECUTED
40006dd8: 11 10 00 7b sethi %hi(0x4001ec00), %o0 <== NOT EXECUTED
40006ddc: 7f ff ff da call 40006d44 <jffs2_printk> <== NOT EXECUTED
40006de0: 90 12 23 d8 or %o0, 0x3d8, %o0 ! 4001efd8 <__func__.4+0x10> <== NOT EXECUTED
ofs & ~3, ofs & 3);
if (c->nextblock)
40006de4: c2 07 60 58 ld [ %i5 + 0x58 ], %g1 <== NOT EXECUTED
40006de8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40006dec: 22 80 00 32 be,a 40006eb4 <jffs2_add_physical_node_ref+0x140> <== NOT EXECUTED
40006df0: 11 10 00 7c sethi %hi(0x4001f000), %o0 <== NOT EXECUTED
pr_warn("nextblock 0x%08x", c->nextblock->offset);
40006df4: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
40006df8: 11 10 00 7c sethi %hi(0x4001f000), %o0 <== NOT EXECUTED
40006dfc: 7f ff ff d2 call 40006d44 <jffs2_printk> <== NOT EXECUTED
40006e00: 90 12 20 18 or %o0, 0x18, %o0 ! 4001f018 <__func__.4+0x50> <== NOT EXECUTED
else
pr_warn("No nextblock");
pr_cont(", expected at %08x\n",
40006e04: c2 07 20 0c ld [ %i4 + 0xc ], %g1 <== NOT EXECUTED
40006e08: c4 07 60 34 ld [ %i5 + 0x34 ], %g2 <== NOT EXECUTED
40006e0c: d2 07 20 20 ld [ %i4 + 0x20 ], %o1 <== NOT EXECUTED
40006e10: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED
jeb->offset + (c->sector_size - jeb->free_size));
return ERR_PTR(-EINVAL);
40006e14: b0 10 3f ea mov -22, %i0 <== NOT EXECUTED
pr_cont(", expected at %08x\n",
40006e18: 92 20 40 09 sub %g1, %o1, %o1 <== NOT EXECUTED
40006e1c: 11 10 00 7c sethi %hi(0x4001f000), %o0 <== NOT EXECUTED
40006e20: 7f ff ff c9 call 40006d44 <jffs2_printk> <== NOT EXECUTED
40006e24: 90 12 20 50 or %o0, 0x50, %o0 ! 4001f050 <__func__.4+0x88> <== NOT EXECUTED
return ERR_PTR(-EINVAL);
40006e28: 81 c7 e0 08 ret <== NOT EXECUTED
40006e2c: 81 e8 00 00 restore <== NOT EXECUTED
if ((c->nextblock || ((ofs & 3) != REF_OBSOLETE))
40006e30: 86 0e 60 03 and %i1, 3, %g3 <== NOT EXECUTED
40006e34: 80 a0 e0 01 cmp %g3, 1 <== NOT EXECUTED
40006e38: 12 bf ff de bne 40006db0 <jffs2_add_physical_node_ref+0x3c> <== NOT EXECUTED
40006e3c: 80 a0 80 1c cmp %g2, %i4 <== NOT EXECUTED
}
#endif
spin_lock(&c->erase_completion_lock);
new = jffs2_link_node_ref(c, jeb, ofs, len, ic);
40006e40: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED
40006e44: 96 10 00 1a mov %i2, %o3
40006e48: 94 10 00 19 mov %i1, %o2
40006e4c: 92 10 00 1c mov %i4, %o1
40006e50: 7f ff fe bf call 4000694c <jffs2_link_node_ref>
40006e54: 90 10 00 1d mov %i5, %o0
if (!jeb->free_size && !jeb->dirty_size && !ISDIRTY(jeb->wasted_size)) {
40006e58: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
40006e5c: 80 a0 60 00 cmp %g1, 0
40006e60: 12 80 00 10 bne 40006ea0 <jffs2_add_physical_node_ref+0x12c>
40006e64: b0 10 00 08 mov %o0, %i0
40006e68: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
40006e6c: 80 a0 60 00 cmp %g1, 0
40006e70: 12 80 00 0d bne 40006ea4 <jffs2_add_physical_node_ref+0x130> <== NEVER TAKEN
40006e74: 92 10 00 1c mov %i4, %o1
40006e78: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
40006e7c: 80 a0 60 c4 cmp %g1, 0xc4
40006e80: 18 80 00 09 bgu 40006ea4 <jffs2_add_physical_node_ref+0x130>
40006e84: 84 07 60 60 add %i5, 0x60, %g2
struct list_head *prev = beforethisent->prev;
40006e88: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
newent->prev = prev;
40006e8c: c2 27 20 04 st %g1, [ %i4 + 4 ]
newent->next = beforethisent;
40006e90: c4 24 40 10 st %g2, [ %l1 + %l0 ]
beforethisent->prev = newent;
40006e94: f8 27 60 64 st %i4, [ %i5 + 0x64 ]
prev->next = newent;
40006e98: f8 20 40 00 st %i4, [ %g1 ]
jffs2_flush_wbuf_pad(c);
spin_lock(&c->erase_completion_lock);
}
list_add_tail(&jeb->list, &c->clean_list);
c->nextblock = NULL;
40006e9c: c0 27 60 58 clr [ %i5 + 0x58 ]
}
jffs2_dbg_acct_sanity_check_nolock(c,jeb);
40006ea0: 92 10 00 1c mov %i4, %o1
40006ea4: 40 00 13 8d call 4000bcd8 <__jffs2_dbg_acct_sanity_check_nolock>
40006ea8: 90 10 00 1d mov %i5, %o0
jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
spin_unlock(&c->erase_completion_lock);
return new;
}
40006eac: 81 c7 e0 08 ret
40006eb0: 81 e8 00 00 restore
pr_warn("No nextblock");
40006eb4: 7f ff ff a4 call 40006d44 <jffs2_printk> <== NOT EXECUTED
40006eb8: 90 12 20 38 or %o0, 0x38, %o0 <== NOT EXECUTED
pr_cont(", expected at %08x\n",
40006ebc: c2 07 20 0c ld [ %i4 + 0xc ], %g1 <== NOT EXECUTED
40006ec0: c4 07 60 34 ld [ %i5 + 0x34 ], %g2 <== NOT EXECUTED
40006ec4: d2 07 20 20 ld [ %i4 + 0x20 ], %o1 <== NOT EXECUTED
40006ec8: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED
return ERR_PTR(-EINVAL);
40006ecc: b0 10 3f ea mov -22, %i0 <== NOT EXECUTED
pr_cont(", expected at %08x\n",
40006ed0: 92 20 40 09 sub %g1, %o1, %o1 <== NOT EXECUTED
40006ed4: 11 10 00 7c sethi %hi(0x4001f000), %o0 <== NOT EXECUTED
40006ed8: 7f ff ff 9b call 40006d44 <jffs2_printk> <== NOT EXECUTED
40006edc: 90 12 20 50 or %o0, 0x50, %o0 ! 4001f050 <__func__.4+0x88> <== NOT EXECUTED
return ERR_PTR(-EINVAL);
40006ee0: 81 c7 e0 08 ret <== NOT EXECUTED
40006ee4: 81 e8 00 00 restore <== NOT EXECUTED
40006ee8 <jffs2_complete_reservation>:
void jffs2_complete_reservation(struct jffs2_sb_info *c)
{
40006ee8: 9d e3 bf a0 save %sp, -96, %sp
rtems_jffs2_flash_control *fc = sb->s_flash_control;
40006eec: d0 06 20 e4 ld [ %i0 + 0xe4 ], %o0
if (fc->trigger_garbage_collection != NULL) {
40006ef0: c2 02 20 20 ld [ %o0 + 0x20 ], %g1
40006ef4: 80 a0 60 00 cmp %g1, 0
40006ef8: 02 80 00 04 be 40006f08 <jffs2_complete_reservation+0x20> <== ALWAYS TAKEN
40006efc: 01 00 00 00 nop
(*fc->trigger_garbage_collection)(fc);
40006f00: 9f c0 40 00 call %g1 <== NOT EXECUTED
40006f04: 01 00 00 00 nop <== 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);
}
40006f08: 81 c7 e0 08 ret
40006f0c: 81 e8 00 00 restore
4000bbbc <jffs2_compress>:
* *datalen accordingly to show the amount of data which were compressed.
*/
uint16_t jffs2_compress(struct jffs2_sb_info *c, struct jffs2_inode_info *f,
unsigned char *data_in, unsigned char **cpage_out,
uint32_t *datalen, uint32_t *cdatalen)
{
4000bbbc: 9d e3 bf a0 save %sp, -96, %sp
struct super_block *sb = OFNI_BS_2SFFJ(c);
rtems_jffs2_compressor_control *cc = sb->s_compressor_control;
4000bbc0: d0 06 20 e8 ld [ %i0 + 0xe8 ], %o0
int ret;
if (cc != NULL) {
4000bbc4: 80 a2 20 00 cmp %o0, 0
4000bbc8: 02 80 00 0b be 4000bbf4 <jffs2_compress+0x38> <== NEVER TAKEN
4000bbcc: 94 02 20 0c add %o0, 0xc, %o2
*cpage_out = &cc->buffer[0];
4000bbd0: d4 26 c0 00 st %o2, [ %i3 ]
ret = (*cc->compress)(cc, data_in, *cpage_out, datalen, cdatalen);
4000bbd4: 98 10 00 1d mov %i5, %o4
4000bbd8: c2 02 00 00 ld [ %o0 ], %g1
4000bbdc: 96 10 00 1c mov %i4, %o3
4000bbe0: 9f c0 40 00 call %g1
4000bbe4: 92 10 00 1a mov %i2, %o1
} else {
ret = JFFS2_COMPR_NONE;
}
if (ret == JFFS2_COMPR_NONE) {
4000bbe8: 80 a2 20 00 cmp %o0, 0
4000bbec: 12 80 00 06 bne 4000bc04 <jffs2_compress+0x48>
4000bbf0: b0 10 00 08 mov %o0, %i0
*cpage_out = data_in;
4000bbf4: f4 26 c0 00 st %i2, [ %i3 ]
*datalen = *cdatalen;
4000bbf8: b0 10 20 00 clr %i0
4000bbfc: c2 07 40 00 ld [ %i5 ], %g1
4000bc00: c2 27 00 00 st %g1, [ %i4 ]
}
return ret;
4000bc04: b1 2e 20 10 sll %i0, 0x10, %i0
}
4000bc08: b1 36 20 10 srl %i0, 0x10, %i0
4000bc0c: 81 c7 e0 08 ret
4000bc10: 81 e8 00 00 restore
4000bfac <jffs2_create>:
/***********************************************************************/
int jffs2_create(struct _inode *dir_i, const char *d_name, size_t d_namelen, int mode)
{
4000bfac: 9d e3 bf 98 save %sp, -104, %sp
struct jffs2_sb_info *c;
struct _inode *inode;
int ret;
struct qstr qstr;
qstr.name = d_name;
4000bfb0: f2 27 bf f8 st %i1, [ %fp + -8 ]
{
4000bfb4: b2 10 00 18 mov %i0, %i1
qstr.len = d_namelen;
ri = jffs2_alloc_raw_inode();
4000bfb8: 7f ff e7 06 call 40005bd0 <jffs2_alloc_raw_inode>
4000bfbc: f4 27 bf fc st %i2, [ %fp + -4 ]
if (!ri)
4000bfc0: ba 92 20 00 orcc %o0, 0, %i5
4000bfc4: 02 80 00 31 be 4000c088 <jffs2_create+0xdc> <== NEVER TAKEN
4000bfc8: 94 10 00 1d mov %i5, %o2
return -ENOMEM;
c = JFFS2_SB_INFO(dir_i->i_sb);
4000bfcc: f4 06 20 40 ld [ %i0 + 0x40 ], %i2
D1(printk(KERN_DEBUG "jffs2_create()\n"));
inode = jffs2_new_inode(dir_i, mode, ri);
4000bfd0: 92 10 00 1b mov %i3, %o1
4000bfd4: 7f ff df e7 call 40003f70 <jffs2_new_inode>
4000bfd8: 90 10 00 18 mov %i0, %o0
if (IS_ERR(inode)) {
4000bfdc: 80 a2 3c 18 cmp %o0, -1000
4000bfe0: 18 80 00 25 bgu 4000c074 <jffs2_create+0xc8> <== NEVER TAKEN
4000bfe4: b8 10 00 08 mov %o0, %i4
}
f = JFFS2_INODE_INFO(inode);
dir_f = JFFS2_INODE_INFO(dir_i);
ret = jffs2_do_create(c, dir_f, f, ri, &qstr);
4000bfe8: 94 02 20 48 add %o0, 0x48, %o2
4000bfec: 92 06 20 48 add %i0, 0x48, %o1
4000bff0: 98 07 bf f8 add %fp, -8, %o4
4000bff4: 96 10 00 1d mov %i5, %o3
4000bff8: 7f ff fb 56 call 4000ad50 <jffs2_do_create>
4000bffc: 90 10 00 1a mov %i2, %o0
if (ret) {
4000c000: b0 92 20 00 orcc %o0, 0, %i0
4000c004: 12 80 00 15 bne 4000c058 <jffs2_create+0xac> <== NEVER TAKEN
4000c008: 90 10 00 1d mov %i5, %o0
jffs2_iput(inode);
jffs2_free_raw_inode(ri);
return ret;
}
dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(ri->ctime));
4000c00c: c8 0f 60 28 ldub [ %i5 + 0x28 ], %g4
4000c010: c4 0f 60 29 ldub [ %i5 + 0x29 ], %g2
4000c014: c2 0f 60 2a ldub [ %i5 + 0x2a ], %g1
4000c018: c6 0f 60 2b ldub [ %i5 + 0x2b ], %g3
4000c01c: 89 29 20 18 sll %g4, 0x18, %g4
4000c020: c0 26 60 28 clr [ %i1 + 0x28 ]
4000c024: 85 28 a0 10 sll %g2, 0x10, %g2
4000c028: c0 26 60 20 clr [ %i1 + 0x20 ]
4000c02c: 84 10 80 04 or %g2, %g4, %g2
4000c030: 83 28 60 08 sll %g1, 8, %g1
4000c034: 82 10 40 02 or %g1, %g2, %g1
4000c038: 82 10 c0 01 or %g3, %g1, %g1
4000c03c: c2 26 60 2c st %g1, [ %i1 + 0x2c ]
jffs2_free_raw_inode(ri);
4000c040: 7f ff e6 e8 call 40005be0 <jffs2_free_raw_inode>
4000c044: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
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);
4000c048: 7f ff dd de call 400037c0 <jffs2_iput>
4000c04c: 90 10 00 1c mov %i4, %o0
return 0;
4000c050: 81 c7 e0 08 ret
4000c054: 81 e8 00 00 restore
inode->i_nlink = 0;
4000c058: c0 37 20 0c clrh [ %i4 + 0xc ] <== NOT EXECUTED
jffs2_iput(inode);
4000c05c: 7f ff dd d9 call 400037c0 <jffs2_iput> <== NOT EXECUTED
4000c060: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
jffs2_free_raw_inode(ri);
4000c064: 7f ff e6 df call 40005be0 <jffs2_free_raw_inode> <== NOT EXECUTED
4000c068: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return ret;
4000c06c: 81 c7 e0 08 ret <== NOT EXECUTED
4000c070: 81 e8 00 00 restore <== NOT EXECUTED
return PTR_ERR(inode);
4000c074: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
jffs2_free_raw_inode(ri);
4000c078: 7f ff e6 da call 40005be0 <jffs2_free_raw_inode> <== NOT EXECUTED
4000c07c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return PTR_ERR(inode);
4000c080: 81 c7 e0 08 ret <== NOT EXECUTED
4000c084: 81 e8 00 00 restore <== NOT EXECUTED
}
4000c088: 81 c7 e0 08 ret <== NOT EXECUTED
4000c08c: 91 e8 3f f4 restore %g0, -12, %o0 <== NOT EXECUTED
4000bc14 <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)
{
4000bc14: 9d e3 bf a0 save %sp, -96, %sp
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)
4000bc18: 82 0e a0 ff and %i2, 0xff, %g1
4000bc1c: 80 a0 60 06 cmp %g1, 6
4000bc20: 08 80 00 0e bleu 4000bc58 <jffs2_decompress+0x44> <== ALWAYS TAKEN
4000bc24: 80 a0 60 00 cmp %g1, 0
rtems_jffs2_compressor_control *cc = sb->s_compressor_control;
4000bc28: d0 06 20 e8 ld [ %i0 + 0xe8 ], %o0
break;
case JFFS2_COMPR_ZERO:
memset(data_out, 0, datalen);
break;
default:
if (cc != NULL) {
4000bc2c: 80 a2 20 00 cmp %o0, 0
4000bc30: 02 80 00 1c be 4000bca0 <jffs2_decompress+0x8c> <== NEVER TAKEN
4000bc34: da 07 a0 5c ld [ %fp + 0x5c ], %o5
return (*cc->decompress)(cc, comprtype, cdata_in, data_out, cdatalen, datalen);
4000bc38: c2 02 20 04 ld [ %o0 + 4 ], %g1
4000bc3c: 98 10 00 1d mov %i5, %o4
4000bc40: 96 10 00 1c mov %i4, %o3
4000bc44: 94 10 00 1b mov %i3, %o2
4000bc48: 9f c0 40 00 call %g1
4000bc4c: 92 10 00 1a mov %i2, %o1
4000bc50: 81 c7 e0 08 ret
4000bc54: 91 e8 00 08 restore %g0, %o0, %o0
switch (comprtype & 0xff) {
4000bc58: 12 80 00 09 bne 4000bc7c <jffs2_decompress+0x68> <== ALWAYS TAKEN
4000bc5c: 80 a0 60 01 cmp %g1, 1
memcpy(data_out, cdata_in, datalen);
4000bc60: d4 07 a0 5c ld [ %fp + 0x5c ], %o2 <== NOT EXECUTED
4000bc64: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000bc68: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000bc6c: 40 00 44 af call 4001cf28 <memcpy> <== NOT EXECUTED
4000bc70: b0 10 20 00 clr %i0 <== NOT EXECUTED
break;
4000bc74: 81 c7 e0 08 ret <== NOT EXECUTED
4000bc78: 81 e8 00 00 restore <== NOT EXECUTED
switch (comprtype & 0xff) {
4000bc7c: 12 bf ff eb bne 4000bc28 <jffs2_decompress+0x14> <== ALWAYS TAKEN
4000bc80: b4 10 00 01 mov %g1, %i2
memset(data_out, 0, datalen);
4000bc84: d4 07 a0 5c ld [ %fp + 0x5c ], %o2 <== NOT EXECUTED
4000bc88: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000bc8c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000bc90: 40 00 44 e5 call 4001d024 <memset> <== NOT EXECUTED
4000bc94: b0 10 20 00 clr %i0 <== NOT EXECUTED
break;
4000bc98: 81 c7 e0 08 ret <== NOT EXECUTED
4000bc9c: 81 e8 00 00 restore <== NOT EXECUTED
} else {
return -EIO;
}
}
return 0;
}
4000bca0: 81 c7 e0 08 ret <== NOT EXECUTED
4000bca4: 91 e8 3f fb restore %g0, -5, %o0 <== NOT EXECUTED
4000669c <jffs2_del_ino_cache>:
prev = &c->inocache_list[old->ino % c->inocache_hashsize];
4000669c: c2 02 20 c0 ld [ %o0 + 0xc0 ], %g1
400066a0: c6 02 20 c4 ld [ %o0 + 0xc4 ], %g3
400066a4: c8 02 60 0c ld [ %o1 + 0xc ], %g4
400066a8: 81 80 20 00 wr %g0, %y
400066ac: 01 00 00 00 nop
400066b0: 01 00 00 00 nop
400066b4: 01 00 00 00 nop
400066b8: 84 71 00 01 udiv %g4, %g1, %g2
400066bc: 84 58 80 01 smul %g2, %g1, %g2
400066c0: 84 21 00 02 sub %g4, %g2, %g2
400066c4: 85 28 a0 02 sll %g2, 2, %g2
while ((*prev) && (*prev)->ino < old->ino) {
400066c8: c2 00 c0 02 ld [ %g3 + %g2 ], %g1
400066cc: 80 a0 60 00 cmp %g1, 0
400066d0: 12 80 00 08 bne 400066f0 <jffs2_del_ino_cache+0x54>
400066d4: 86 00 c0 02 add %g3, %g2, %g3
if (old->state != INO_STATE_READING && old->state != INO_STATE_CLEARING)
400066d8: 10 80 00 10 b 40006718 <jffs2_del_ino_cache+0x7c>
400066dc: c2 12 60 0a lduh [ %o1 + 0xa ], %g1
while ((*prev) && (*prev)->ino < old->ino) {
400066e0: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED
400066e4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400066e8: 22 80 00 0c be,a 40006718 <jffs2_del_ino_cache+0x7c> <== NOT EXECUTED
400066ec: c2 12 60 0a lduh [ %o1 + 0xa ], %g1 <== NOT EXECUTED
400066f0: c4 00 60 0c ld [ %g1 + 0xc ], %g2
400066f4: 80 a1 00 02 cmp %g4, %g2
400066f8: 38 bf ff fa bgu,a 400066e0 <jffs2_del_ino_cache+0x44> <== NEVER TAKEN
400066fc: 86 00 60 10 add %g1, 0x10, %g3 <== NOT EXECUTED
if ((*prev) == old) {
40006700: 80 a2 40 01 cmp %o1, %g1
40006704: 32 80 00 05 bne,a 40006718 <jffs2_del_ino_cache+0x7c> <== NEVER TAKEN
40006708: c2 12 60 0a lduh [ %o1 + 0xa ], %g1 <== NOT EXECUTED
*prev = old->next;
4000670c: c2 02 60 10 ld [ %o1 + 0x10 ], %g1
40006710: c2 20 c0 00 st %g1, [ %g3 ]
if (old->state != INO_STATE_READING && old->state != INO_STATE_CLEARING)
40006714: c2 12 60 0a lduh [ %o1 + 0xa ], %g1
40006718: 82 00 7f fb add %g1, -5, %g1
4000671c: 83 28 60 10 sll %g1, 0x10, %g1
40006720: 83 30 60 10 srl %g1, 0x10, %g1
40006724: 80 a0 60 01 cmp %g1, 1
40006728: 18 80 00 04 bgu 40006738 <jffs2_del_ino_cache+0x9c>
4000672c: 90 10 00 09 mov %o1, %o0
}
40006730: 81 c3 e0 08 retl
40006734: 01 00 00 00 nop
jffs2_free_inode_cache(old);
40006738: 82 13 c0 00 mov %o7, %g1
4000673c: 7f ff fd 73 call 40005d08 <jffs2_free_inode_cache>
40006740: 9e 10 40 00 mov %g1, %o7
40009e04 <jffs2_do_clear_inode>:
kfree (f);
return ret;
}
void jffs2_do_clear_inode(struct jffs2_sb_info *c, struct jffs2_inode_info *f)
{
40009e04: 9d e3 bf a0 save %sp, -96, %sp
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;
40009e08: d2 06 60 14 ld [ %i1 + 0x14 ], %o1
40009e0c: 80 a2 60 00 cmp %o1, 0
40009e10: 02 80 00 1b be 40009e7c <jffs2_do_clear_inode+0x78> <== NEVER TAKEN
40009e14: ba 06 60 04 add %i1, 4, %i5
40009e18: c4 02 60 14 ld [ %o1 + 0x14 ], %g2
40009e1c: 80 a0 a0 00 cmp %g2, 0
40009e20: 12 80 00 12 bne 40009e68 <jffs2_do_clear_inode+0x64>
40009e24: c2 12 60 0a lduh [ %o1 + 0xa ], %g1
if (f->inocache && f->inocache->state != INO_STATE_CHECKING)
40009e28: 83 28 60 10 sll %g1, 0x10, %g1
40009e2c: 83 30 60 10 srl %g1, 0x10, %g1
40009e30: 80 a0 60 01 cmp %g1, 1
40009e34: 12 80 00 3f bne 40009f30 <jffs2_do_clear_inode+0x12c> <== ALWAYS TAKEN
40009e38: 94 10 20 06 mov 6, %o2
jffs2_set_inocache_state(c, f->inocache, INO_STATE_CLEARING);
if (f->metadata) {
40009e3c: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
40009e40: 80 a0 60 00 cmp %g1, 0
40009e44: 22 80 00 15 be,a 40009e98 <jffs2_do_clear_inode+0x94>
40009e48: 92 10 00 18 mov %i0, %o1
if (deleted)
jffs2_mark_node_obsolete(c, f->metadata->raw);
40009e4c: d2 00 40 00 ld [ %g1 ], %o1
40009e50: 7f ff f4 30 call 40006f10 <jffs2_mark_node_obsolete>
40009e54: 90 10 00 18 mov %i0, %o0
jffs2_free_full_dnode(f->metadata);
40009e58: 7f ff ef 54 call 40005ba8 <jffs2_free_full_dnode>
40009e5c: d0 06 60 08 ld [ %i1 + 8 ], %o0
}
jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL);
40009e60: 10 80 00 0e b 40009e98 <jffs2_do_clear_inode+0x94>
40009e64: 92 10 00 18 mov %i0, %o1
if (f->inocache && f->inocache->state != INO_STATE_CHECKING)
40009e68: 83 28 60 10 sll %g1, 0x10, %g1
40009e6c: 83 30 60 10 srl %g1, 0x10, %g1
40009e70: 80 a0 60 01 cmp %g1, 1
40009e74: 12 80 00 33 bne 40009f40 <jffs2_do_clear_inode+0x13c> <== ALWAYS TAKEN
40009e78: 90 10 00 18 mov %i0, %o0
if (f->metadata) {
40009e7c: d0 06 60 08 ld [ %i1 + 8 ], %o0 <== NOT EXECUTED
40009e80: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40009e84: 02 80 00 05 be 40009e98 <jffs2_do_clear_inode+0x94> <== NOT EXECUTED
40009e88: 92 10 20 00 clr %o1 <== NOT EXECUTED
jffs2_free_full_dnode(f->metadata);
40009e8c: 7f ff ef 47 call 40005ba8 <jffs2_free_full_dnode> <== NOT EXECUTED
40009e90: 01 00 00 00 nop <== NOT EXECUTED
jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL);
40009e94: 92 10 20 00 clr %o1 ! 0 <PROM_START> <== NOT EXECUTED
40009e98: 7f ff f2 8b call 400068c4 <jffs2_kill_fragtree>
40009e9c: 90 10 00 1d mov %i5, %o0
if (f->target) {
40009ea0: d0 06 60 10 ld [ %i1 + 0x10 ], %o0
40009ea4: 80 a2 20 00 cmp %o0, 0
40009ea8: 22 80 00 06 be,a 40009ec0 <jffs2_do_clear_inode+0xbc>
40009eac: fa 06 60 0c ld [ %i1 + 0xc ], %i5
kfree(f->target);
40009eb0: 40 00 13 a1 call 4000ed34 <free>
40009eb4: 01 00 00 00 nop
f->target = NULL;
40009eb8: c0 26 60 10 clr [ %i1 + 0x10 ]
}
fds = f->dents;
40009ebc: fa 06 60 0c ld [ %i1 + 0xc ], %i5
while(fds) {
40009ec0: 80 a7 60 00 cmp %i5, 0
40009ec4: 22 80 00 09 be,a 40009ee8 <jffs2_do_clear_inode+0xe4>
40009ec8: d2 06 60 14 ld [ %i1 + 0x14 ], %o1
fd = fds;
fds = fd->next;
40009ecc: 90 10 00 1d mov %i5, %o0
jffs2_free_full_dirent(fd);
40009ed0: 7f ff ef 2f call 40005b8c <jffs2_free_full_dirent>
40009ed4: fa 07 60 04 ld [ %i5 + 4 ], %i5
while(fds) {
40009ed8: 80 a7 60 00 cmp %i5, 0
40009edc: 12 bf ff fd bne 40009ed0 <jffs2_do_clear_inode+0xcc>
40009ee0: 90 10 00 1d mov %i5, %o0
}
if (f->inocache && f->inocache->state != INO_STATE_CHECKING) {
40009ee4: d2 06 60 14 ld [ %i1 + 0x14 ], %o1
40009ee8: 80 a2 60 00 cmp %o1, 0
40009eec: 02 80 00 0f be 40009f28 <jffs2_do_clear_inode+0x124> <== NEVER TAKEN
40009ef0: 01 00 00 00 nop
40009ef4: c2 12 60 0a lduh [ %o1 + 0xa ], %g1
40009ef8: 80 a0 60 01 cmp %g1, 1
40009efc: 02 80 00 09 be 40009f20 <jffs2_do_clear_inode+0x11c> <== NEVER TAKEN
40009f00: 94 10 20 03 mov 3, %o2
jffs2_set_inocache_state(c, f->inocache, INO_STATE_CHECKEDABSENT);
40009f04: 7f ff f1 a3 call 40006590 <jffs2_set_inocache_state>
40009f08: 90 10 00 18 mov %i0, %o0
if (f->inocache->nodes == (void *)f->inocache)
40009f0c: f2 06 60 14 ld [ %i1 + 0x14 ], %i1
40009f10: c2 06 60 04 ld [ %i1 + 4 ], %g1
40009f14: 80 a6 40 01 cmp %i1, %g1
40009f18: 02 80 00 14 be 40009f68 <jffs2_do_clear_inode+0x164>
40009f1c: 01 00 00 00 nop
jffs2_del_ino_cache(c, f->inocache);
}
mutex_unlock(&f->sem);
}
40009f20: 81 c7 e0 08 ret
40009f24: 81 e8 00 00 restore
40009f28: 81 c7 e0 08 ret <== NOT EXECUTED
40009f2c: 81 e8 00 00 restore <== NOT EXECUTED
jffs2_set_inocache_state(c, f->inocache, INO_STATE_CLEARING);
40009f30: 7f ff f1 98 call 40006590 <jffs2_set_inocache_state>
40009f34: 90 10 00 18 mov %i0, %o0
if (f->metadata) {
40009f38: 10 bf ff c2 b 40009e40 <jffs2_do_clear_inode+0x3c>
40009f3c: c2 06 60 08 ld [ %i1 + 8 ], %g1
jffs2_set_inocache_state(c, f->inocache, INO_STATE_CLEARING);
40009f40: 7f ff f1 94 call 40006590 <jffs2_set_inocache_state>
40009f44: 94 10 20 06 mov 6, %o2
if (f->metadata) {
40009f48: d0 06 60 08 ld [ %i1 + 8 ], %o0
40009f4c: 80 a2 20 00 cmp %o0, 0
40009f50: 22 bf ff d2 be,a 40009e98 <jffs2_do_clear_inode+0x94>
40009f54: 92 10 20 00 clr %o1
jffs2_free_full_dnode(f->metadata);
40009f58: 7f ff ef 14 call 40005ba8 <jffs2_free_full_dnode>
40009f5c: 01 00 00 00 nop
jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL);
40009f60: 10 bf ff ce b 40009e98 <jffs2_do_clear_inode+0x94>
40009f64: 92 10 20 00 clr %o1 ! 0 <PROM_START>
jffs2_del_ino_cache(c, f->inocache);
40009f68: 7f ff f1 cd call 4000669c <jffs2_del_ino_cache>
40009f6c: 81 e8 00 00 restore
40009f70 <jffs2_do_crccheck_inode>:
{
40009f70: 9d e3 bf 58 save %sp, -168, %sp <== NOT EXECUTED
struct jffs2_inode_info *f = kzalloc(sizeof(*f), GFP_KERNEL);
40009f74: 92 10 20 1c mov 0x1c, %o1 <== NOT EXECUTED
40009f78: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
40009f7c: 40 00 12 af call 4000ea38 <calloc> <== NOT EXECUTED
40009f80: b8 10 00 18 mov %i0, %i4 <== NOT EXECUTED
if (!f)
40009f84: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40009f88: 02 80 00 0e be 40009fc0 <jffs2_do_crccheck_inode+0x50> <== NOT EXECUTED
40009f8c: 94 07 bf bc add %fp, -68, %o2 <== NOT EXECUTED
f->inocache = ic;
40009f90: f2 27 60 14 st %i1, [ %i5 + 0x14 ] <== NOT EXECUTED
ret = jffs2_do_read_inode_internal(c, f, &n);
40009f94: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40009f98: 7f ff f8 e6 call 40008330 <jffs2_do_read_inode_internal> <== NOT EXECUTED
40009f9c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
jffs2_do_clear_inode(c, f);
40009fa0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
ret = jffs2_do_read_inode_internal(c, f, &n);
40009fa4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
jffs2_do_clear_inode(c, f);
40009fa8: 7f ff ff 97 call 40009e04 <jffs2_do_clear_inode> <== NOT EXECUTED
40009fac: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
kfree (f);
40009fb0: 40 00 13 61 call 4000ed34 <free> <== NOT EXECUTED
40009fb4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return ret;
40009fb8: 81 c7 e0 08 ret <== NOT EXECUTED
40009fbc: 81 e8 00 00 restore <== NOT EXECUTED
}
40009fc0: 81 c7 e0 08 ret <== NOT EXECUTED
40009fc4: 91 e8 3f f4 restore %g0, -12, %o0 <== NOT EXECUTED
4000ad50 <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)
{
4000ad50: 9d e3 bf 98 save %sp, -104, %sp
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,
4000ad54: 98 10 20 12 mov 0x12, %o4
4000ad58: 96 10 20 00 clr %o3
4000ad5c: 94 07 bf fc add %fp, -4, %o2
4000ad60: 92 10 20 44 mov 0x44, %o1
4000ad64: 7f ff f2 8a call 4000778c <jffs2_reserve_space>
4000ad68: 90 10 00 18 mov %i0, %o0
JFFS2_SUMMARY_INODE_SIZE);
jffs2_dbg(1, "%s(): reserved 0x%x bytes\n", __func__, alloclen);
if (ret)
4000ad6c: ba 92 20 00 orcc %o0, 0, %i5
4000ad70: 22 80 00 04 be,a 4000ad80 <jffs2_do_create+0x30> <== ALWAYS TAKEN
4000ad74: c0 2e e0 3c clrb [ %i3 + 0x3c ]
jffs2_complete_reservation(c);
mutex_unlock(&dir_f->sem);
return 0;
}
4000ad78: 81 c7 e0 08 ret <== NOT EXECUTED
4000ad7c: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000ad80: 94 10 20 3c mov 0x3c, %o2
ri->data_crc = cpu_to_je32(0);
4000ad84: c0 2e e0 3d clrb [ %i3 + 0x3d ]
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000ad88: 92 10 00 1b mov %i3, %o1
ri->data_crc = cpu_to_je32(0);
4000ad8c: c0 2e e0 3e clrb [ %i3 + 0x3e ]
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000ad90: 40 00 03 7a call 4000bb78 <cyg_crc32_accumulate>
4000ad94: c0 2e e0 3f clrb [ %i3 + 0x3f ]
4000ad98: 87 32 20 18 srl %o0, 0x18, %g3
4000ad9c: 85 32 20 10 srl %o0, 0x10, %g2
4000ada0: 83 32 20 08 srl %o0, 8, %g1
4000ada4: d0 2e e0 43 stb %o0, [ %i3 + 0x43 ]
fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
4000ada8: 9a 10 20 00 clr %o5
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000adac: c6 2e e0 40 stb %g3, [ %i3 + 0x40 ]
fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
4000adb0: 98 10 20 00 clr %o4
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000adb4: c4 2e e0 41 stb %g2, [ %i3 + 0x41 ]
fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
4000adb8: 96 10 20 00 clr %o3
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000adbc: c2 2e e0 42 stb %g1, [ %i3 + 0x42 ]
fn = jffs2_write_dnode(c, f, ri, NULL, 0, ALLOC_NORMAL);
4000adc0: 94 10 00 1b mov %i3, %o2
4000adc4: 92 10 00 1a mov %i2, %o1
4000adc8: 7f ff fc ce call 4000a100 <jffs2_write_dnode>
4000adcc: 90 10 00 18 mov %i0, %o0
if (IS_ERR(fn)) {
4000add0: 80 a2 3c 18 cmp %o0, -1000
4000add4: 18 80 00 7d bgu 4000afc8 <jffs2_do_create+0x278> <== NEVER TAKEN
4000add8: ba 10 00 08 mov %o0, %i5
f->metadata = fn;
4000addc: d0 26 a0 08 st %o0, [ %i2 + 8 ]
jffs2_complete_reservation(c);
4000ade0: 7f ff f0 42 call 40006ee8 <jffs2_complete_reservation>
4000ade4: 90 10 00 18 mov %i0, %o0
ret = jffs2_reserve_space(c, sizeof(*rd)+qstr->len, &alloclen,
4000ade8: d2 07 20 04 ld [ %i4 + 4 ], %o1
4000adec: 98 02 60 18 add %o1, 0x18, %o4
4000adf0: 96 10 20 00 clr %o3
4000adf4: 94 07 bf fc add %fp, -4, %o2
4000adf8: 92 02 60 28 add %o1, 0x28, %o1
4000adfc: 7f ff f2 64 call 4000778c <jffs2_reserve_space>
4000ae00: 90 10 00 18 mov %i0, %o0
if (ret) {
4000ae04: ba 92 20 00 orcc %o0, 0, %i5
4000ae08: 12 bf ff dc bne 4000ad78 <jffs2_do_create+0x28> <== NEVER TAKEN
4000ae0c: 01 00 00 00 nop
rd = jffs2_alloc_raw_dirent();
4000ae10: 7f ff eb 69 call 40005bb4 <jffs2_alloc_raw_dirent>
4000ae14: 01 00 00 00 nop
if (!rd) {
4000ae18: b4 92 20 00 orcc %o0, 0, %i2
4000ae1c: 02 80 00 74 be 4000afec <jffs2_do_create+0x29c> <== NEVER TAKEN
4000ae20: 9e 10 20 19 mov 0x19, %o7
rd->totlen = cpu_to_je32(sizeof(*rd) + qstr->len);
4000ae24: c2 07 20 04 ld [ %i4 + 4 ], %g1
4000ae28: 82 00 60 28 add %g1, 0x28, %g1
4000ae2c: 89 30 60 18 srl %g1, 0x18, %g4
4000ae30: c8 2e a0 04 stb %g4, [ %i2 + 4 ]
rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
4000ae34: 88 10 3f 85 mov -123, %g4
4000ae38: c8 2e a0 01 stb %g4, [ %i2 + 1 ]
rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
4000ae3c: 88 10 3f e0 mov -32, %g4
rd->totlen = cpu_to_je32(sizeof(*rd) + qstr->len);
4000ae40: 87 30 60 10 srl %g1, 0x10, %g3
4000ae44: 85 30 60 08 srl %g1, 8, %g2
rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
4000ae48: c8 2e a0 02 stb %g4, [ %i2 + 2 ]
4000ae4c: 88 10 20 01 mov 1, %g4
rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
4000ae50: de 2e 80 00 stb %o7, [ %i2 ]
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000ae54: 94 10 20 08 mov 8, %o2
rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
4000ae58: c8 2e a0 03 stb %g4, [ %i2 + 3 ]
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000ae5c: 92 10 00 1a mov %i2, %o1
rd->totlen = cpu_to_je32(sizeof(*rd) + qstr->len);
4000ae60: c6 2e a0 05 stb %g3, [ %i2 + 5 ]
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000ae64: 90 10 20 00 clr %o0
rd->totlen = cpu_to_je32(sizeof(*rd) + qstr->len);
4000ae68: c4 2e a0 06 stb %g2, [ %i2 + 6 ]
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000ae6c: 40 00 03 43 call 4000bb78 <cyg_crc32_accumulate>
4000ae70: c2 2e a0 07 stb %g1, [ %i2 + 7 ]
rd->pino = cpu_to_je32(dir_f->inocache->ino);
4000ae74: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
4000ae78: de 08 60 0c ldub [ %g1 + 0xc ], %o7
4000ae7c: c8 08 60 0d ldub [ %g1 + 0xd ], %g4
4000ae80: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
4000ae84: c4 08 60 0f ldub [ %g1 + 0xf ], %g2
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000ae88: 9b 32 20 18 srl %o0, 0x18, %o5
rd->version = cpu_to_je32(++dir_f->highest_version);
4000ae8c: c2 06 40 00 ld [ %i1 ], %g1
rd->pino = cpu_to_je32(dir_f->inocache->ino);
4000ae90: de 2e a0 0c stb %o7, [ %i2 + 0xc ]
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000ae94: 9f 32 20 10 srl %o0, 0x10, %o7
4000ae98: d0 2e a0 0b stb %o0, [ %i2 + 0xb ]
4000ae9c: 91 32 20 08 srl %o0, 8, %o0
4000aea0: da 2e a0 08 stb %o5, [ %i2 + 8 ]
rd->version = cpu_to_je32(++dir_f->highest_version);
4000aea4: 82 00 60 01 inc %g1
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000aea8: de 2e a0 09 stb %o7, [ %i2 + 9 ]
rd->version = cpu_to_je32(++dir_f->highest_version);
4000aeac: 97 30 60 08 srl %g1, 8, %o3
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000aeb0: d0 2e a0 0a stb %o0, [ %i2 + 0xa ]
rd->version = cpu_to_je32(++dir_f->highest_version);
4000aeb4: 93 30 60 18 srl %g1, 0x18, %o1
rd->pino = cpu_to_je32(dir_f->inocache->ino);
4000aeb8: c8 2e a0 0d stb %g4, [ %i2 + 0xd ]
rd->version = cpu_to_je32(++dir_f->highest_version);
4000aebc: 91 30 60 10 srl %g1, 0x10, %o0
rd->pino = cpu_to_je32(dir_f->inocache->ino);
4000aec0: c6 2e a0 0e stb %g3, [ %i2 + 0xe ]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000aec4: 94 10 20 20 mov 0x20, %o2
rd->pino = cpu_to_je32(dir_f->inocache->ino);
4000aec8: c4 2e a0 0f stb %g2, [ %i2 + 0xf ]
rd->ino = ri->ino;
4000aecc: de 0e e0 0e ldub [ %i3 + 0xe ], %o7
4000aed0: d8 0e e0 0c ldub [ %i3 + 0xc ], %o4
4000aed4: da 0e e0 0d ldub [ %i3 + 0xd ], %o5
4000aed8: c8 0e e0 0f ldub [ %i3 + 0xf ], %g4
rd->mctime = ri->ctime;
4000aedc: c6 0e e0 28 ldub [ %i3 + 0x28 ], %g3
rd->version = cpu_to_je32(++dir_f->highest_version);
4000aee0: c2 26 40 00 st %g1, [ %i1 ]
rd->mctime = ri->ctime;
4000aee4: c4 0e e0 29 ldub [ %i3 + 0x29 ], %g2
4000aee8: c4 2e a0 19 stb %g2, [ %i2 + 0x19 ]
rd->ino = ri->ino;
4000aeec: de 2e a0 16 stb %o7, [ %i2 + 0x16 ]
rd->version = cpu_to_je32(++dir_f->highest_version);
4000aef0: d6 2e a0 12 stb %o3, [ %i2 + 0x12 ]
rd->ino = ri->ino;
4000aef4: d8 2e a0 14 stb %o4, [ %i2 + 0x14 ]
4000aef8: da 2e a0 15 stb %o5, [ %i2 + 0x15 ]
4000aefc: c8 2e a0 17 stb %g4, [ %i2 + 0x17 ]
rd->mctime = ri->ctime;
4000af00: c6 2e a0 18 stb %g3, [ %i2 + 0x18 ]
rd->version = cpu_to_je32(++dir_f->highest_version);
4000af04: d2 2e a0 10 stb %o1, [ %i2 + 0x10 ]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000af08: 92 10 00 1a mov %i2, %o1
rd->version = cpu_to_je32(++dir_f->highest_version);
4000af0c: d0 2e a0 11 stb %o0, [ %i2 + 0x11 ]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000af10: 90 10 20 00 clr %o0
rd->version = cpu_to_je32(++dir_f->highest_version);
4000af14: c2 2e a0 13 stb %g1, [ %i2 + 0x13 ]
rd->mctime = ri->ctime;
4000af18: c2 0e e0 2a ldub [ %i3 + 0x2a ], %g1
4000af1c: c2 2e a0 1a stb %g1, [ %i2 + 0x1a ]
rd->nsize = qstr->len;
4000af20: c2 07 20 04 ld [ %i4 + 4 ], %g1
rd->mctime = ri->ctime;
4000af24: c4 0e e0 2b ldub [ %i3 + 0x2b ], %g2
4000af28: c4 2e a0 1b stb %g2, [ %i2 + 0x1b ]
rd->nsize = qstr->len;
4000af2c: c2 2e a0 1c stb %g1, [ %i2 + 0x1c ]
rd->type = DT_REG;
4000af30: 82 10 20 08 mov 8, %g1
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000af34: 40 00 03 11 call 4000bb78 <cyg_crc32_accumulate>
4000af38: c2 2e a0 1d stb %g1, [ %i2 + 0x1d ]
4000af3c: 89 32 20 18 srl %o0, 0x18, %g4
4000af40: 82 10 00 08 mov %o0, %g1
4000af44: 87 32 20 10 srl %o0, 0x10, %g3
4000af48: 85 32 20 08 srl %o0, 8, %g2
4000af4c: c8 2e a0 20 stb %g4, [ %i2 + 0x20 ]
rd->name_crc = cpu_to_je32(crc32(0, qstr->name, qstr->len));
4000af50: 90 10 20 00 clr %o0
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000af54: c6 2e a0 21 stb %g3, [ %i2 + 0x21 ]
4000af58: c4 2e a0 22 stb %g2, [ %i2 + 0x22 ]
4000af5c: c2 2e a0 23 stb %g1, [ %i2 + 0x23 ]
rd->name_crc = cpu_to_je32(crc32(0, qstr->name, qstr->len));
4000af60: d4 07 20 04 ld [ %i4 + 4 ], %o2
4000af64: 40 00 03 05 call 4000bb78 <cyg_crc32_accumulate>
4000af68: d2 07 00 00 ld [ %i4 ], %o1
4000af6c: 87 32 20 18 srl %o0, 0x18, %g3
4000af70: 85 32 20 10 srl %o0, 0x10, %g2
4000af74: 83 32 20 08 srl %o0, 8, %g1
4000af78: c6 2e a0 24 stb %g3, [ %i2 + 0x24 ]
fd = jffs2_write_dirent(c, dir_f, rd, qstr->name, qstr->len, ALLOC_NORMAL);
4000af7c: 9a 10 20 00 clr %o5
rd->name_crc = cpu_to_je32(crc32(0, qstr->name, qstr->len));
4000af80: c4 2e a0 25 stb %g2, [ %i2 + 0x25 ]
fd = jffs2_write_dirent(c, dir_f, rd, qstr->name, qstr->len, ALLOC_NORMAL);
4000af84: 94 10 00 1a mov %i2, %o2
rd->name_crc = cpu_to_je32(crc32(0, qstr->name, qstr->len));
4000af88: c2 2e a0 26 stb %g1, [ %i2 + 0x26 ]
fd = jffs2_write_dirent(c, dir_f, rd, qstr->name, qstr->len, ALLOC_NORMAL);
4000af8c: 92 10 00 19 mov %i1, %o1
rd->name_crc = cpu_to_je32(crc32(0, qstr->name, qstr->len));
4000af90: d0 2e a0 27 stb %o0, [ %i2 + 0x27 ]
fd = jffs2_write_dirent(c, dir_f, rd, qstr->name, qstr->len, ALLOC_NORMAL);
4000af94: 90 10 00 18 mov %i0, %o0
4000af98: d8 07 20 04 ld [ %i4 + 4 ], %o4
4000af9c: 7f ff fd 67 call 4000a538 <jffs2_write_dirent>
4000afa0: d6 07 00 00 ld [ %i4 ], %o3
4000afa4: b8 10 00 08 mov %o0, %i4
jffs2_free_raw_dirent(rd);
4000afa8: 7f ff eb 07 call 40005bc4 <jffs2_free_raw_dirent>
4000afac: 90 10 00 1a mov %i2, %o0
if (IS_ERR(fd)) {
4000afb0: 80 a7 3c 18 cmp %i4, -1000
4000afb4: 18 80 00 0a bgu 4000afdc <jffs2_do_create+0x28c> <== NEVER TAKEN
4000afb8: 94 06 60 0c add %i1, 0xc, %o2
jffs2_add_fd_to_list(c, fd, &dir_f->dents);
4000afbc: 92 10 00 1c mov %i4, %o1
4000afc0: 7f ff eb 9d call 40005e34 <jffs2_add_fd_to_list>
4000afc4: 90 10 00 18 mov %i0, %o0
jffs2_complete_reservation(c);
4000afc8: 90 10 00 18 mov %i0, %o0
4000afcc: 7f ff ef c7 call 40006ee8 <jffs2_complete_reservation>
4000afd0: b0 10 00 1d mov %i5, %i0
}
4000afd4: 81 c7 e0 08 ret
4000afd8: 81 e8 00 00 restore
jffs2_complete_reservation(c);
4000afdc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000afe0: 7f ff ef c2 call 40006ee8 <jffs2_complete_reservation> <== NOT EXECUTED
4000afe4: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
return PTR_ERR(fd);
4000afe8: 30 bf ff 64 b,a 4000ad78 <jffs2_do_create+0x28> <== NOT EXECUTED
jffs2_complete_reservation(c);
4000afec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000aff0: 7f ff ef be call 40006ee8 <jffs2_complete_reservation> <== NOT EXECUTED
4000aff4: ba 10 3f f4 mov -12, %i5 <== NOT EXECUTED
return -ENOMEM;
4000aff8: 30 bf ff 60 b,a 4000ad78 <jffs2_do_create+0x28> <== NOT EXECUTED
4000b18c <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)
{
4000b18c: 9d e3 bf 98 save %sp, -104, %sp
struct jffs2_raw_dirent *rd;
struct jffs2_full_dirent *fd;
uint32_t alloclen;
int ret;
rd = jffs2_alloc_raw_dirent();
4000b190: 7f ff ea 89 call 40005bb4 <jffs2_alloc_raw_dirent>
4000b194: e4 07 a0 5c ld [ %fp + 0x5c ], %l2
if (!rd)
4000b198: a0 92 20 00 orcc %o0, 0, %l0
4000b19c: 02 80 00 7a be 4000b384 <jffs2_do_link+0x1f8> <== NEVER TAKEN
4000b1a0: a2 07 60 28 add %i5, 0x28, %l1
return -ENOMEM;
ret = jffs2_reserve_space(c, sizeof(*rd)+namelen, &alloclen,
4000b1a4: 98 07 60 18 add %i5, 0x18, %o4
4000b1a8: 96 10 20 00 clr %o3
4000b1ac: 94 07 bf fc add %fp, -4, %o2
4000b1b0: 92 10 00 11 mov %l1, %o1
4000b1b4: 7f ff f1 76 call 4000778c <jffs2_reserve_space>
4000b1b8: 90 10 00 18 mov %i0, %o0
ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(namelen));
if (ret) {
4000b1bc: a6 92 20 00 orcc %o0, 0, %l3
4000b1c0: 12 80 00 6c bne 4000b370 <jffs2_do_link+0x1e4> <== NEVER TAKEN
4000b1c4: 82 10 20 19 mov 0x19, %g1
}
mutex_lock(&dir_f->sem);
/* Build a deletion node */
rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
4000b1c8: c2 2c 00 00 stb %g1, [ %l0 ]
4000b1cc: 82 10 3f 85 mov -123, %g1
4000b1d0: c2 2c 20 01 stb %g1, [ %l0 + 1 ]
rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
4000b1d4: 82 10 3f e0 mov -32, %g1
4000b1d8: c2 2c 20 02 stb %g1, [ %l0 + 2 ]
4000b1dc: 82 10 20 01 mov 1, %g1
rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
4000b1e0: 85 34 60 18 srl %l1, 0x18, %g2
4000b1e4: e2 2c 20 07 stb %l1, [ %l0 + 7 ]
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000b1e8: 94 10 20 08 mov 8, %o2
rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
4000b1ec: c2 2c 20 03 stb %g1, [ %l0 + 3 ]
rd->totlen = cpu_to_je32(sizeof(*rd) + namelen);
4000b1f0: 83 34 60 10 srl %l1, 0x10, %g1
4000b1f4: c4 2c 20 04 stb %g2, [ %l0 + 4 ]
4000b1f8: a3 34 60 08 srl %l1, 8, %l1
4000b1fc: c2 2c 20 05 stb %g1, [ %l0 + 5 ]
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000b200: 92 10 00 10 mov %l0, %o1
4000b204: 40 00 02 5d call 4000bb78 <cyg_crc32_accumulate>
4000b208: e2 2c 20 06 stb %l1, [ %l0 + 6 ]
rd->pino = cpu_to_je32(dir_f->inocache->ino);
4000b20c: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
4000b210: c8 08 60 0c ldub [ %g1 + 0xc ], %g4
4000b214: c6 08 60 0d ldub [ %g1 + 0xd ], %g3
4000b218: da 08 60 0e ldub [ %g1 + 0xe ], %o5
4000b21c: de 08 60 0f ldub [ %g1 + 0xf ], %o7
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000b220: 83 32 20 18 srl %o0, 0x18, %g1
rd->version = cpu_to_je32(++dir_f->highest_version);
4000b224: c4 06 40 00 ld [ %i1 ], %g2
rd->pino = cpu_to_je32(dir_f->inocache->ino);
4000b228: c8 2c 20 0c stb %g4, [ %l0 + 0xc ]
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000b22c: 89 32 20 10 srl %o0, 0x10, %g4
4000b230: d0 2c 20 0b stb %o0, [ %l0 + 0xb ]
rd->version = cpu_to_je32(++dir_f->highest_version);
4000b234: 84 00 a0 01 inc %g2
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000b238: c2 2c 20 08 stb %g1, [ %l0 + 8 ]
4000b23c: 83 32 20 08 srl %o0, 8, %g1
4000b240: c8 2c 20 09 stb %g4, [ %l0 + 9 ]
rd->version = cpu_to_je32(++dir_f->highest_version);
4000b244: 89 30 a0 18 srl %g2, 0x18, %g4
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000b248: c2 2c 20 0a stb %g1, [ %l0 + 0xa ]
rd->version = cpu_to_je32(++dir_f->highest_version);
4000b24c: 83 30 a0 08 srl %g2, 8, %g1
rd->pino = cpu_to_je32(dir_f->inocache->ino);
4000b250: c6 2c 20 0d stb %g3, [ %l0 + 0xd ]
rd->version = cpu_to_je32(++dir_f->highest_version);
4000b254: 87 30 a0 10 srl %g2, 0x10, %g3
rd->pino = cpu_to_je32(dir_f->inocache->ino);
4000b258: da 2c 20 0e stb %o5, [ %l0 + 0xe ]
rd->ino = cpu_to_je32(ino);
4000b25c: 99 36 a0 18 srl %i2, 0x18, %o4
rd->pino = cpu_to_je32(dir_f->inocache->ino);
4000b260: de 2c 20 0f stb %o7, [ %l0 + 0xf ]
rd->ino = cpu_to_je32(ino);
4000b264: 9b 36 a0 10 srl %i2, 0x10, %o5
rd->version = cpu_to_je32(++dir_f->highest_version);
4000b268: c4 26 40 00 st %g2, [ %i1 ]
rd->ino = cpu_to_je32(ino);
4000b26c: 9f 36 a0 08 srl %i2, 8, %o7
4000b270: d8 2c 20 14 stb %o4, [ %l0 + 0x14 ]
rd->mctime = cpu_to_je32(time);
rd->nsize = namelen;
rd->type = type;
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000b274: 94 10 20 20 mov 0x20, %o2
rd->ino = cpu_to_je32(ino);
4000b278: de 2c 20 16 stb %o7, [ %l0 + 0x16 ]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000b27c: 92 10 00 10 mov %l0, %o1
rd->ino = cpu_to_je32(ino);
4000b280: da 2c 20 15 stb %o5, [ %l0 + 0x15 ]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000b284: 90 10 20 00 clr %o0
rd->version = cpu_to_je32(++dir_f->highest_version);
4000b288: c8 2c 20 10 stb %g4, [ %l0 + 0x10 ]
rd->mctime = cpu_to_je32(time);
4000b28c: 89 34 a0 18 srl %l2, 0x18, %g4
rd->version = cpu_to_je32(++dir_f->highest_version);
4000b290: c6 2c 20 11 stb %g3, [ %l0 + 0x11 ]
rd->mctime = cpu_to_je32(time);
4000b294: 87 34 a0 10 srl %l2, 0x10, %g3
rd->version = cpu_to_je32(++dir_f->highest_version);
4000b298: c2 2c 20 12 stb %g1, [ %l0 + 0x12 ]
rd->mctime = cpu_to_je32(time);
4000b29c: 83 34 a0 08 srl %l2, 8, %g1
rd->version = cpu_to_je32(++dir_f->highest_version);
4000b2a0: c4 2c 20 13 stb %g2, [ %l0 + 0x13 ]
rd->mctime = cpu_to_je32(time);
4000b2a4: c8 2c 20 18 stb %g4, [ %l0 + 0x18 ]
4000b2a8: c6 2c 20 19 stb %g3, [ %l0 + 0x19 ]
4000b2ac: c2 2c 20 1a stb %g1, [ %l0 + 0x1a ]
rd->nsize = namelen;
4000b2b0: fa 2c 20 1c stb %i5, [ %l0 + 0x1c ]
rd->ino = cpu_to_je32(ino);
4000b2b4: f4 2c 20 17 stb %i2, [ %l0 + 0x17 ]
rd->mctime = cpu_to_je32(time);
4000b2b8: e4 2c 20 1b stb %l2, [ %l0 + 0x1b ]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000b2bc: 40 00 02 2f call 4000bb78 <cyg_crc32_accumulate>
4000b2c0: f6 2c 20 1d stb %i3, [ %l0 + 0x1d ]
4000b2c4: 89 32 20 18 srl %o0, 0x18, %g4
4000b2c8: 82 10 00 08 mov %o0, %g1
4000b2cc: 87 32 20 10 srl %o0, 0x10, %g3
4000b2d0: 85 32 20 08 srl %o0, 8, %g2
4000b2d4: c8 2c 20 20 stb %g4, [ %l0 + 0x20 ]
rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
4000b2d8: 94 10 00 1d mov %i5, %o2
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000b2dc: c6 2c 20 21 stb %g3, [ %l0 + 0x21 ]
rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
4000b2e0: 92 10 00 1c mov %i4, %o1
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000b2e4: c4 2c 20 22 stb %g2, [ %l0 + 0x22 ]
rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
4000b2e8: 90 10 20 00 clr %o0
4000b2ec: 40 00 02 23 call 4000bb78 <cyg_crc32_accumulate>
4000b2f0: c2 2c 20 23 stb %g1, [ %l0 + 0x23 ]
4000b2f4: 87 32 20 18 srl %o0, 0x18, %g3
4000b2f8: 85 32 20 10 srl %o0, 0x10, %g2
4000b2fc: 83 32 20 08 srl %o0, 8, %g1
4000b300: c6 2c 20 24 stb %g3, [ %l0 + 0x24 ]
fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
4000b304: 98 10 00 1d mov %i5, %o4
rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
4000b308: c4 2c 20 25 stb %g2, [ %l0 + 0x25 ]
fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
4000b30c: 9a 10 20 00 clr %o5
rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
4000b310: c2 2c 20 26 stb %g1, [ %l0 + 0x26 ]
fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
4000b314: 96 10 00 1c mov %i4, %o3
rd->name_crc = cpu_to_je32(crc32(0, name, namelen));
4000b318: d0 2c 20 27 stb %o0, [ %l0 + 0x27 ]
fd = jffs2_write_dirent(c, dir_f, rd, name, namelen, ALLOC_NORMAL);
4000b31c: 94 10 00 10 mov %l0, %o2
4000b320: 92 10 00 19 mov %i1, %o1
4000b324: 7f ff fc 85 call 4000a538 <jffs2_write_dirent>
4000b328: 90 10 00 18 mov %i0, %o0
4000b32c: ba 10 00 08 mov %o0, %i5
jffs2_free_raw_dirent(rd);
4000b330: 7f ff ea 25 call 40005bc4 <jffs2_free_raw_dirent>
4000b334: 90 10 00 10 mov %l0, %o0
if (IS_ERR(fd)) {
4000b338: 80 a7 7c 18 cmp %i5, -1000
4000b33c: 18 80 00 09 bgu 4000b360 <jffs2_do_link+0x1d4> <== NEVER TAKEN
4000b340: 90 10 00 18 mov %i0, %o0
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);
4000b344: 94 06 60 0c add %i1, 0xc, %o2
4000b348: 7f ff ea bb call 40005e34 <jffs2_add_fd_to_list>
4000b34c: 92 10 00 1d mov %i5, %o1
jffs2_complete_reservation(c);
4000b350: 7f ff ee e6 call 40006ee8 <jffs2_complete_reservation>
4000b354: 90 10 00 18 mov %i0, %o0
mutex_unlock(&dir_f->sem);
return 0;
}
4000b358: 81 c7 e0 08 ret
4000b35c: 91 e8 00 13 restore %g0, %l3, %o0
jffs2_complete_reservation(c);
4000b360: 7f ff ee e2 call 40006ee8 <jffs2_complete_reservation> <== NOT EXECUTED
4000b364: a6 10 00 1d mov %i5, %l3 <== NOT EXECUTED
}
4000b368: 81 c7 e0 08 ret <== NOT EXECUTED
4000b36c: 91 e8 00 13 restore %g0, %l3, %o0 <== NOT EXECUTED
jffs2_free_raw_dirent(rd);
4000b370: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4000b374: 7f ff ea 14 call 40005bc4 <jffs2_free_raw_dirent> <== NOT EXECUTED
4000b378: b0 10 00 13 mov %l3, %i0 <== NOT EXECUTED
}
4000b37c: 81 c7 e0 08 ret <== NOT EXECUTED
4000b380: 81 e8 00 00 restore <== NOT EXECUTED
return -ENOMEM;
4000b384: 10 bf ff f5 b 4000b358 <jffs2_do_link+0x1cc> <== NOT EXECUTED
4000b388: a6 10 3f f4 mov -12, %l3 <== NOT EXECUTED
4000b474 <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)
{
4000b474: 9d e3 bf 98 save %sp, -104, %sp
int ret;
int i;
int size;
c->free_size = c->flash_size;
4000b478: f6 06 20 18 ld [ %i0 + 0x18 ], %i3
c->nr_blocks = c->flash_size / c->sector_size;
4000b47c: fa 06 20 34 ld [ %i0 + 0x34 ], %i5
4000b480: 81 80 20 00 wr %g0, %y
4000b484: 01 00 00 00 nop
4000b488: 01 00 00 00 nop
4000b48c: 01 00 00 00 nop
4000b490: b8 76 c0 1d udiv %i3, %i5, %i4
c->free_size = c->flash_size;
4000b494: f6 26 20 28 st %i3, [ %i0 + 0x28 ]
#ifndef __ECOS
if (jffs2_blocks_use_vmalloc(c))
c->blocks = vzalloc(size);
else
#endif
c->blocks = kzalloc(size, GFP_KERNEL);
4000b498: 92 5f 20 34 smul %i4, 0x34, %o1
c->nr_blocks = c->flash_size / c->sector_size;
4000b49c: f8 26 20 50 st %i4, [ %i0 + 0x50 ]
c->blocks = kzalloc(size, GFP_KERNEL);
4000b4a0: 40 00 0d 66 call 4000ea38 <calloc>
4000b4a4: 90 10 20 01 mov 1, %o0
4000b4a8: d0 26 20 54 st %o0, [ %i0 + 0x54 ]
{
4000b4ac: b4 10 00 18 mov %i0, %i2
if (!c->blocks)
4000b4b0: 80 a2 20 00 cmp %o0, 0
4000b4b4: 02 80 01 af be 4000bb70 <jffs2_do_mount_fs+0x6fc> <== NEVER TAKEN
4000b4b8: 82 10 00 08 mov %o0, %g1
return -ENOMEM;
for (i=0; i<c->nr_blocks; i++) {
4000b4bc: 86 10 20 00 clr %g3
4000b4c0: 80 a6 c0 1d cmp %i3, %i5
4000b4c4: 0a 80 00 0b bcs 4000b4f0 <jffs2_do_mount_fs+0x7c> <== NEVER TAKEN
4000b4c8: 84 10 20 00 clr %g2
INIT_LIST_HEAD(&c->blocks[i].list);
c->blocks[i].offset = i * c->sector_size;
4000b4cc: c6 20 60 0c st %g3, [ %g1 + 0xc ]
for (i=0; i<c->nr_blocks; i++) {
4000b4d0: 84 00 a0 01 inc %g2
INIT_LIST_HEAD(&c->blocks[i].list);
4000b4d4: c2 20 60 04 st %g1, [ %g1 + 4 ]
for (i=0; i<c->nr_blocks; i++) {
4000b4d8: 86 00 c0 1d add %g3, %i5, %g3
INIT_LIST_HEAD(&c->blocks[i].list);
4000b4dc: c2 20 40 00 st %g1, [ %g1 ]
for (i=0; i<c->nr_blocks; i++) {
4000b4e0: 80 a7 00 02 cmp %i4, %g2
c->blocks[i].free_size = c->sector_size;
4000b4e4: fa 20 60 20 st %i5, [ %g1 + 0x20 ]
for (i=0; i<c->nr_blocks; i++) {
4000b4e8: 18 bf ff f9 bgu 4000b4cc <jffs2_do_mount_fs+0x58>
4000b4ec: 82 00 60 34 add %g1, 0x34, %g1
c->flags |= JFFS2_SB_FLAG_SCANNING;
4000b4f0: d8 06 a0 0c ld [ %i2 + 0xc ], %o4
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);
INIT_LIST_HEAD(&c->bad_list);
INIT_LIST_HEAD(&c->bad_used_list);
4000b4f4: 82 06 a0 b8 add %i2, 0xb8, %g1
INIT_LIST_HEAD(&c->clean_list);
4000b4f8: 96 06 a0 60 add %i2, 0x60, %o3
INIT_LIST_HEAD(&c->very_dirty_list);
4000b4fc: 9a 06 a0 68 add %i2, 0x68, %o5
INIT_LIST_HEAD(&c->dirty_list);
4000b500: 9e 06 a0 70 add %i2, 0x70, %o7
INIT_LIST_HEAD(&c->erasable_list);
4000b504: b0 06 a0 78 add %i2, 0x78, %i0
INIT_LIST_HEAD(&c->erase_complete_list);
4000b508: 88 06 a0 a0 add %i2, 0xa0, %g4
INIT_LIST_HEAD(&c->free_list);
4000b50c: 86 06 a0 a8 add %i2, 0xa8, %g3
INIT_LIST_HEAD(&c->bad_list);
4000b510: 84 06 a0 b0 add %i2, 0xb0, %g2
INIT_LIST_HEAD(&c->erasable_list);
4000b514: f0 26 a0 7c st %i0, [ %i2 + 0x7c ]
INIT_LIST_HEAD(&c->erasing_list);
4000b518: b2 06 a0 88 add %i2, 0x88, %i1
INIT_LIST_HEAD(&c->erasable_list);
4000b51c: f0 26 a0 78 st %i0, [ %i2 + 0x78 ]
INIT_LIST_HEAD(&c->erase_checking_list);
4000b520: b6 06 a0 90 add %i2, 0x90, %i3
INIT_LIST_HEAD(&c->bad_used_list);
4000b524: c2 26 a0 bc st %g1, [ %i2 + 0xbc ]
INIT_LIST_HEAD(&c->erase_pending_list);
4000b528: b8 06 a0 98 add %i2, 0x98, %i4
INIT_LIST_HEAD(&c->bad_used_list);
4000b52c: c2 26 a0 b8 st %g1, [ %i2 + 0xb8 ]
INIT_LIST_HEAD(&c->erasable_pending_wbuf_list);
4000b530: ba 06 a0 80 add %i2, 0x80, %i5
c->highest_ino = 1;
4000b534: 82 10 20 01 mov 1, %g1
c->flags |= JFFS2_SB_FLAG_SCANNING;
4000b538: 98 13 20 02 or %o4, 2, %o4
c->highest_ino = 1;
4000b53c: c2 26 a0 04 st %g1, [ %i2 + 4 ]
ret = jffs2_scan_medium(c);
4000b540: 90 10 00 1a mov %i2, %o0
INIT_LIST_HEAD(&c->clean_list);
4000b544: d6 26 a0 64 st %o3, [ %i2 + 0x64 ]
4000b548: d6 26 a0 60 st %o3, [ %i2 + 0x60 ]
INIT_LIST_HEAD(&c->very_dirty_list);
4000b54c: da 26 a0 6c st %o5, [ %i2 + 0x6c ]
4000b550: da 26 a0 68 st %o5, [ %i2 + 0x68 ]
INIT_LIST_HEAD(&c->dirty_list);
4000b554: de 26 a0 74 st %o7, [ %i2 + 0x74 ]
4000b558: de 26 a0 70 st %o7, [ %i2 + 0x70 ]
INIT_LIST_HEAD(&c->erasing_list);
4000b55c: f2 26 a0 8c st %i1, [ %i2 + 0x8c ]
4000b560: f2 26 a0 88 st %i1, [ %i2 + 0x88 ]
INIT_LIST_HEAD(&c->erase_checking_list);
4000b564: f6 26 a0 94 st %i3, [ %i2 + 0x94 ]
4000b568: f6 26 a0 90 st %i3, [ %i2 + 0x90 ]
INIT_LIST_HEAD(&c->erase_pending_list);
4000b56c: f8 26 a0 9c st %i4, [ %i2 + 0x9c ]
4000b570: f8 26 a0 98 st %i4, [ %i2 + 0x98 ]
INIT_LIST_HEAD(&c->erasable_pending_wbuf_list);
4000b574: fa 26 a0 84 st %i5, [ %i2 + 0x84 ]
4000b578: fa 26 a0 80 st %i5, [ %i2 + 0x80 ]
INIT_LIST_HEAD(&c->erase_complete_list);
4000b57c: c8 26 a0 a4 st %g4, [ %i2 + 0xa4 ]
4000b580: c8 26 a0 a0 st %g4, [ %i2 + 0xa0 ]
INIT_LIST_HEAD(&c->free_list);
4000b584: c6 26 a0 ac st %g3, [ %i2 + 0xac ]
4000b588: c6 26 a0 a8 st %g3, [ %i2 + 0xa8 ]
INIT_LIST_HEAD(&c->bad_list);
4000b58c: c4 26 a0 b4 st %g2, [ %i2 + 0xb4 ]
4000b590: c4 26 a0 b0 st %g2, [ %i2 + 0xb0 ]
c->summary = NULL;
4000b594: c0 26 a0 cc clr [ %i2 + 0xcc ]
c->flags |= JFFS2_SB_FLAG_SCANNING;
4000b598: d8 26 a0 0c st %o4, [ %i2 + 0xc ]
ret = jffs2_scan_medium(c);
4000b59c: 40 00 07 64 call 4000d32c <jffs2_scan_medium>
4000b5a0: c0 27 bf fc clr [ %fp + -4 ]
c->flags &= ~JFFS2_SB_FLAG_SCANNING;
4000b5a4: c2 06 a0 0c ld [ %i2 + 0xc ], %g1
4000b5a8: 82 08 7f fd and %g1, -3, %g1
if (ret)
4000b5ac: b0 92 20 00 orcc %o0, 0, %i0
4000b5b0: 12 80 01 2a bne 4000ba58 <jffs2_do_mount_fs+0x5e4> <== NEVER TAKEN
4000b5b4: c2 26 a0 0c st %g1, [ %i2 + 0xc ]
c->flags |= JFFS2_SB_FLAG_BUILDING;
4000b5b8: 82 10 60 04 or %g1, 4, %g1
4000b5bc: c2 26 a0 0c st %g1, [ %i2 + 0xc ]
for (; *i < c->inocache_hashsize; (*i)++) {
4000b5c0: c2 06 a0 c0 ld [ %i2 + 0xc0 ], %g1
4000b5c4: 80 a0 60 00 cmp %g1, 0
4000b5c8: 04 80 01 68 ble 4000bb68 <jffs2_do_mount_fs+0x6f4> <== NEVER TAKEN
4000b5cc: b6 10 20 00 clr %i3
if (c->inocache_list[*i])
4000b5d0: 10 80 00 05 b 4000b5e4 <jffs2_do_mount_fs+0x170>
4000b5d4: c6 06 a0 c4 ld [ %i2 + 0xc4 ], %g3
for (; *i < c->inocache_hashsize; (*i)++) {
4000b5d8: 80 a6 c0 01 cmp %i3, %g1
4000b5dc: 02 80 00 08 be 4000b5fc <jffs2_do_mount_fs+0x188>
4000b5e0: 80 a7 20 00 cmp %i4, 0
if (c->inocache_list[*i])
4000b5e4: 85 2e e0 02 sll %i3, 2, %g2
4000b5e8: f8 00 c0 02 ld [ %g3 + %g2 ], %i4
4000b5ec: 80 a7 20 00 cmp %i4, 0
4000b5f0: 22 bf ff fa be,a 4000b5d8 <jffs2_do_mount_fs+0x164> <== ALWAYS TAKEN
4000b5f4: b6 06 e0 01 inc %i3
for_each_inode(i, c, ic) {
4000b5f8: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4000b5fc: 12 80 00 61 bne 4000b780 <jffs2_do_mount_fs+0x30c> <== NEVER TAKEN
4000b600: b2 10 20 00 clr %i1
for (; *i < c->inocache_hashsize; (*i)++) {
4000b604: 80 a0 60 00 cmp %g1, 0
4000b608: 04 80 00 0c ble 4000b638 <jffs2_do_mount_fs+0x1c4> <== NEVER TAKEN
4000b60c: ba 10 20 00 clr %i5
if (c->inocache_list[*i])
4000b610: 10 80 00 05 b 4000b624 <jffs2_do_mount_fs+0x1b0>
4000b614: c6 06 a0 c4 ld [ %i2 + 0xc4 ], %g3
for (; *i < c->inocache_hashsize; (*i)++) {
4000b618: 80 a7 40 01 cmp %i5, %g1
4000b61c: 02 80 00 08 be 4000b63c <jffs2_do_mount_fs+0x1c8>
4000b620: 80 a7 20 00 cmp %i4, 0
if (c->inocache_list[*i])
4000b624: 85 2f 60 02 sll %i5, 2, %g2
4000b628: f8 00 c0 02 ld [ %g3 + %g2 ], %i4
4000b62c: 80 a7 20 00 cmp %i4, 0
4000b630: 22 bf ff fa be,a 4000b618 <jffs2_do_mount_fs+0x1a4> <== ALWAYS TAKEN
4000b634: ba 07 60 01 inc %i5
for_each_inode(i, c, ic) {
4000b638: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4000b63c: 32 80 00 82 bne,a 4000b844 <jffs2_do_mount_fs+0x3d0> <== NEVER TAKEN
4000b640: c2 07 20 14 ld [ %i4 + 0x14 ], %g1 <== NOT EXECUTED
while (dead_fds) {
4000b644: fa 07 bf fc ld [ %fp + -4 ], %i5
4000b648: 80 a7 60 00 cmp %i5, 0
4000b64c: 02 80 00 14 be 4000b69c <jffs2_do_mount_fs+0x228> <== ALWAYS TAKEN
4000b650: 80 a6 60 00 cmp %i1, 0
dead_fds = fd->next;
4000b654: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
ic = jffs2_get_ino_cache(c, fd->ino);
4000b658: d2 07 60 0c ld [ %i5 + 0xc ], %o1 <== NOT EXECUTED
dead_fds = fd->next;
4000b65c: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
ic = jffs2_get_ino_cache(c, fd->ino);
4000b660: 7f ff eb ce call 40006598 <jffs2_get_ino_cache> <== NOT EXECUTED
4000b664: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
if (ic)
4000b668: 92 92 20 00 orcc %o0, 0, %o1 <== NOT EXECUTED
4000b66c: 02 80 00 04 be 4000b67c <jffs2_do_mount_fs+0x208> <== NOT EXECUTED
4000b670: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
jffs2_build_remove_unlinked_inode(c, ic, &dead_fds);
4000b674: 7f ff ff 46 call 4000b38c <jffs2_build_remove_unlinked_inode> <== NOT EXECUTED
4000b678: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
jffs2_free_full_dirent(fd);
4000b67c: 7f ff e9 44 call 40005b8c <jffs2_free_full_dirent> <== NOT EXECUTED
4000b680: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
while (dead_fds) {
4000b684: fa 07 bf fc ld [ %fp + -4 ], %i5 <== NOT EXECUTED
4000b688: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4000b68c: 32 bf ff f3 bne,a 4000b658 <jffs2_do_mount_fs+0x1e4> <== NOT EXECUTED
4000b690: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
4000b694: c2 06 a0 c0 ld [ %i2 + 0xc0 ], %g1 <== NOT EXECUTED
if (dir_hardlinks) {
4000b698: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
4000b69c: 02 80 00 7a be 4000b884 <jffs2_do_mount_fs+0x410> <== ALWAYS TAKEN
4000b6a0: 80 a0 60 00 cmp %g1, 0
for_each_inode(i, c, ic) {
4000b6a4: 84 10 20 00 clr %g2 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000b6a8: 04 80 00 74 ble 4000b878 <jffs2_do_mount_fs+0x404> <== NOT EXECUTED
4000b6ac: 86 10 20 00 clr %g3 <== NOT EXECUTED
if (c->inocache_list[*i])
4000b6b0: 10 80 00 05 b 4000b6c4 <jffs2_do_mount_fs+0x250> <== NOT EXECUTED
4000b6b4: c8 06 a0 c4 ld [ %i2 + 0xc4 ], %g4 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000b6b8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4000b6bc: 02 80 00 70 be 4000b87c <jffs2_do_mount_fs+0x408> <== NOT EXECUTED
4000b6c0: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
if (c->inocache_list[*i])
4000b6c4: 87 28 a0 02 sll %g2, 2, %g3 <== NOT EXECUTED
4000b6c8: c6 01 00 03 ld [ %g4 + %g3 ], %g3 <== NOT EXECUTED
4000b6cc: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
4000b6d0: 22 bf ff fa be,a 4000b6b8 <jffs2_do_mount_fs+0x244> <== NOT EXECUTED
4000b6d4: 84 00 a0 01 inc %g2 <== NOT EXECUTED
if (ic->flags & INO_FLAGS_IS_DIR)
4000b6d8: c8 08 e0 09 ldub [ %g3 + 9 ], %g4 <== NOT EXECUTED
4000b6dc: 80 89 20 02 btst 2, %g4 <== NOT EXECUTED
4000b6e0: 32 80 00 02 bne,a 4000b6e8 <jffs2_do_mount_fs+0x274> <== NOT EXECUTED
4000b6e4: c0 20 e0 14 clr [ %g3 + 0x14 ] <== NOT EXECUTED
if (ic->next)
4000b6e8: c6 00 e0 10 ld [ %g3 + 0x10 ], %g3 <== NOT EXECUTED
4000b6ec: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
4000b6f0: 32 bf ff fb bne,a 4000b6dc <jffs2_do_mount_fs+0x268> <== NOT EXECUTED
4000b6f4: c8 08 e0 09 ldub [ %g3 + 9 ], %g4 <== NOT EXECUTED
(*i)++;
4000b6f8: 84 00 a0 01 inc %g2 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000b6fc: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4000b700: 16 80 00 61 bge 4000b884 <jffs2_do_mount_fs+0x410> <== NOT EXECUTED
4000b704: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
if (c->inocache_list[*i])
4000b708: 10 80 00 05 b 4000b71c <jffs2_do_mount_fs+0x2a8> <== NOT EXECUTED
4000b70c: c8 06 a0 c4 ld [ %i2 + 0xc4 ], %g4 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000b710: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4000b714: 02 80 00 5c be 4000b884 <jffs2_do_mount_fs+0x410> <== NOT EXECUTED
4000b718: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
if (c->inocache_list[*i])
4000b71c: 87 28 a0 02 sll %g2, 2, %g3 <== NOT EXECUTED
4000b720: c6 01 00 03 ld [ %g4 + %g3 ], %g3 <== NOT EXECUTED
4000b724: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
4000b728: 22 bf ff fa be,a 4000b710 <jffs2_do_mount_fs+0x29c> <== NOT EXECUTED
4000b72c: 84 00 a0 01 inc %g2 <== NOT EXECUTED
4000b730: 10 bf ff eb b 4000b6dc <jffs2_do_mount_fs+0x268> <== NOT EXECUTED
4000b734: c8 08 e0 09 ldub [ %g3 + 9 ], %g4 <== NOT EXECUTED
if (ic->next)
4000b738: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4000b73c: 32 80 00 12 bne,a 4000b784 <jffs2_do_mount_fs+0x310> <== NOT EXECUTED
4000b740: fa 07 00 00 ld [ %i4 ], %i5 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000b744: c2 06 a0 c0 ld [ %i2 + 0xc0 ], %g1 <== NOT EXECUTED
(*i)++;
4000b748: b6 06 e0 01 inc %i3 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000b74c: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
4000b750: 16 bf ff ae bge 4000b608 <jffs2_do_mount_fs+0x194> <== NOT EXECUTED
4000b754: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
if (c->inocache_list[*i])
4000b758: 10 80 00 05 b 4000b76c <jffs2_do_mount_fs+0x2f8> <== NOT EXECUTED
4000b75c: c6 06 a0 c4 ld [ %i2 + 0xc4 ], %g3 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000b760: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
4000b764: 02 bf ff a9 be 4000b608 <jffs2_do_mount_fs+0x194> <== NOT EXECUTED
4000b768: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
if (c->inocache_list[*i])
4000b76c: 85 2e e0 02 sll %i3, 2, %g2 <== NOT EXECUTED
4000b770: f8 00 c0 02 ld [ %g3 + %g2 ], %i4 <== NOT EXECUTED
4000b774: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4000b778: 22 bf ff fa be,a 4000b760 <jffs2_do_mount_fs+0x2ec> <== NOT EXECUTED
4000b77c: b6 06 e0 01 inc %i3 <== NOT EXECUTED
if (ic->scan_dents) {
4000b780: fa 07 00 00 ld [ %i4 ], %i5 <== NOT EXECUTED
4000b784: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4000b788: 32 80 00 09 bne,a 4000b7ac <jffs2_do_mount_fs+0x338> <== NOT EXECUTED
4000b78c: d2 07 60 0c ld [ %i5 + 0xc ], %o1 <== NOT EXECUTED
4000b790: 10 bf ff ea b 4000b738 <jffs2_do_mount_fs+0x2c4> <== NOT EXECUTED
4000b794: f8 07 20 10 ld [ %i4 + 0x10 ], %i4 <== NOT EXECUTED
for(fd = ic->scan_dents; fd; fd = fd->next) {
4000b798: fa 07 60 04 ld [ %i5 + 4 ], %i5 <== NOT EXECUTED
4000b79c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4000b7a0: 22 bf ff e6 be,a 4000b738 <jffs2_do_mount_fs+0x2c4> <== NOT EXECUTED
4000b7a4: f8 07 20 10 ld [ %i4 + 0x10 ], %i4 <== NOT EXECUTED
if (!fd->ino)
4000b7a8: d2 07 60 0c ld [ %i5 + 0xc ], %o1 <== NOT EXECUTED
4000b7ac: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
4000b7b0: 22 bf ff fb be,a 4000b79c <jffs2_do_mount_fs+0x328> <== NOT EXECUTED
4000b7b4: fa 07 60 04 ld [ %i5 + 4 ], %i5 <== NOT EXECUTED
child_ic = jffs2_get_ino_cache(c, fd->ino);
4000b7b8: 7f ff eb 78 call 40006598 <jffs2_get_ino_cache> <== NOT EXECUTED
4000b7bc: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
if (!child_ic) {
4000b7c0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000b7c4: 22 80 00 a1 be,a 4000ba48 <jffs2_do_mount_fs+0x5d4> <== NOT EXECUTED
4000b7c8: d2 07 40 00 ld [ %i5 ], %o1 <== NOT EXECUTED
child_ic->pino_nlink++;
4000b7cc: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 <== NOT EXECUTED
fd->ic = child_ic;
4000b7d0: d0 27 40 00 st %o0, [ %i5 ] <== NOT EXECUTED
child_ic->pino_nlink++;
4000b7d4: 82 00 60 01 inc %g1 <== NOT EXECUTED
4000b7d8: c2 22 20 14 st %g1, [ %o0 + 0x14 ] <== NOT EXECUTED
if (fd->type == DT_DIR) {
4000b7dc: c4 0f 60 14 ldub [ %i5 + 0x14 ], %g2 <== NOT EXECUTED
4000b7e0: 80 a0 a0 04 cmp %g2, 4 <== NOT EXECUTED
4000b7e4: 32 bf ff ee bne,a 4000b79c <jffs2_do_mount_fs+0x328> <== NOT EXECUTED
4000b7e8: fa 07 60 04 ld [ %i5 + 4 ], %i5 <== NOT EXECUTED
child_ic->flags |= INO_FLAGS_IS_DIR;
4000b7ec: c4 0a 20 09 ldub [ %o0 + 9 ], %g2 <== NOT EXECUTED
4000b7f0: 84 10 a0 02 or %g2, 2, %g2 <== NOT EXECUTED
if (child_ic->pino_nlink > 1)
4000b7f4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
4000b7f8: 08 bf ff e8 bleu 4000b798 <jffs2_do_mount_fs+0x324> <== NOT EXECUTED
4000b7fc: c4 2a 20 09 stb %g2, [ %o0 + 9 ] <== NOT EXECUTED
*dir_hardlinks = 1;
4000b800: 10 bf ff e6 b 4000b798 <jffs2_do_mount_fs+0x324> <== NOT EXECUTED
4000b804: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED
(*i)++;
4000b808: ba 07 60 01 inc %i5 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000b80c: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
4000b810: 36 bf ff 8e bge,a 4000b648 <jffs2_do_mount_fs+0x1d4> <== NOT EXECUTED
4000b814: fa 07 bf fc ld [ %fp + -4 ], %i5 <== NOT EXECUTED
if (c->inocache_list[*i])
4000b818: 10 80 00 05 b 4000b82c <jffs2_do_mount_fs+0x3b8> <== NOT EXECUTED
4000b81c: c6 06 a0 c4 ld [ %i2 + 0xc4 ], %g3 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000b820: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
4000b824: 22 bf ff 89 be,a 4000b648 <jffs2_do_mount_fs+0x1d4> <== NOT EXECUTED
4000b828: fa 07 bf fc ld [ %fp + -4 ], %i5 <== NOT EXECUTED
if (c->inocache_list[*i])
4000b82c: 85 2f 60 02 sll %i5, 2, %g2 <== NOT EXECUTED
4000b830: f8 00 c0 02 ld [ %g3 + %g2 ], %i4 <== NOT EXECUTED
4000b834: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4000b838: 22 bf ff fa be,a 4000b820 <jffs2_do_mount_fs+0x3ac> <== NOT EXECUTED
4000b83c: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (ic->pino_nlink)
4000b840: c2 07 20 14 ld [ %i4 + 0x14 ], %g1 <== NOT EXECUTED
4000b844: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000b848: 32 80 00 07 bne,a 4000b864 <jffs2_do_mount_fs+0x3f0> <== NOT EXECUTED
4000b84c: f8 07 20 10 ld [ %i4 + 0x10 ], %i4 <== NOT EXECUTED
jffs2_build_remove_unlinked_inode(c, ic, &dead_fds);
4000b850: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
4000b854: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
4000b858: 7f ff fe cd call 4000b38c <jffs2_build_remove_unlinked_inode> <== NOT EXECUTED
4000b85c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
if (ic->next)
4000b860: f8 07 20 10 ld [ %i4 + 0x10 ], %i4 <== NOT EXECUTED
4000b864: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4000b868: 32 bf ff f7 bne,a 4000b844 <jffs2_do_mount_fs+0x3d0> <== NOT EXECUTED
4000b86c: c2 07 20 14 ld [ %i4 + 0x14 ], %g1 <== NOT EXECUTED
4000b870: 10 bf ff e6 b 4000b808 <jffs2_do_mount_fs+0x394> <== NOT EXECUTED
4000b874: c2 06 a0 c0 ld [ %i2 + 0xc0 ], %g1 <== NOT EXECUTED
for_each_inode(i, c, ic) {
4000b878: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
4000b87c: 12 bf ff 97 bne 4000b6d8 <jffs2_do_mount_fs+0x264> <== NOT EXECUTED
4000b880: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000b884: 04 80 00 0c ble 4000b8b4 <jffs2_do_mount_fs+0x440> <== NEVER TAKEN
4000b888: b6 10 20 00 clr %i3
if (c->inocache_list[*i])
4000b88c: 10 80 00 05 b 4000b8a0 <jffs2_do_mount_fs+0x42c>
4000b890: c6 06 a0 c4 ld [ %i2 + 0xc4 ], %g3
for (; *i < c->inocache_hashsize; (*i)++) {
4000b894: 80 a6 c0 01 cmp %i3, %g1
4000b898: 02 80 00 08 be 4000b8b8 <jffs2_do_mount_fs+0x444>
4000b89c: 21 10 00 80 sethi %hi(0x40020000), %l0
if (c->inocache_list[*i])
4000b8a0: 85 2e e0 02 sll %i3, 2, %g2
4000b8a4: f8 00 c0 02 ld [ %g3 + %g2 ], %i4
4000b8a8: 80 a7 20 00 cmp %i4, 0
4000b8ac: 22 bf ff fa be,a 4000b894 <jffs2_do_mount_fs+0x420> <== ALWAYS TAKEN
4000b8b0: b6 06 e0 01 inc %i3
JFFS2_ERROR("child dir \"%s\" (ino #%u) of dir ino #%u is also hard linked from dir ino #%u\n",
4000b8b4: 21 10 00 80 sethi %hi(0x40020000), %l0 <== NOT EXECUTED
4000b8b8: 23 10 00 80 sethi %hi(0x40020000), %l1
4000b8bc: a0 14 23 60 or %l0, 0x360, %l0
for_each_inode(i, c, ic) {
4000b8c0: 80 a7 20 00 cmp %i4, 0
4000b8c4: 12 80 00 3d bne 4000b9b8 <jffs2_do_mount_fs+0x544> <== NEVER TAKEN
4000b8c8: a2 14 62 c8 or %l1, 0x2c8, %l1
c->flags &= ~JFFS2_SB_FLAG_BUILDING;
4000b8cc: c2 06 a0 0c ld [ %i2 + 0xc ], %g1
4000b8d0: 82 08 7f fb and %g1, -5, %g1
4000b8d4: c2 26 a0 0c st %g1, [ %i2 + 0xc ]
jffs2_rotate_lists(c);
4000b8d8: 40 00 0b 17 call 4000e534 <jffs2_rotate_lists>
4000b8dc: 90 10 00 1a mov %i2, %o0
size = c->flash_size / 50; /* 2% of flash size */
4000b8e0: c4 06 a0 18 ld [ %i2 + 0x18 ], %g2
4000b8e4: 3b 14 7a e1 sethi %hi(0x51eb8400), %i5
4000b8e8: ba 17 61 1f or %i5, 0x11f, %i5 ! 51eb851f <RAM_END+0x11ab851f>
size += c->sector_size - 1; /* ... and round up */
4000b8ec: c6 06 a0 34 ld [ %i2 + 0x34 ], %g3
size = c->flash_size / 50; /* 2% of flash size */
4000b8f0: 80 50 80 1d umul %g2, %i5, %g0
4000b8f4: 85 40 00 00 rd %y, %g2
c->resv_blocks_deletion = 2;
4000b8f8: ba 10 20 02 mov 2, %i5
size += c->nr_blocks * 100; /* And 100 bytes per eraseblock */
4000b8fc: c2 06 a0 50 ld [ %i2 + 0x50 ], %g1
c->resv_blocks_deletion = 2;
4000b900: fa 2e a0 45 stb %i5, [ %i2 + 0x45 ]
4000b904: 88 00 ff ff add %g3, -1, %g4
size = c->flash_size / 50; /* 2% of flash size */
4000b908: bb 30 a0 04 srl %g2, 4, %i5
4000b90c: 88 01 00 1d add %g4, %i5, %g4
size += c->nr_blocks * 100; /* And 100 bytes per eraseblock */
4000b910: 82 58 60 64 smul %g1, 0x64, %g1
size += c->sector_size - 1; /* ... and round up */
4000b914: 82 00 40 04 add %g1, %g4, %g1
c->resv_blocks_gcmerge = c->resv_blocks_deletion + 1;
4000b918: 88 10 20 03 mov 3, %g4
c->resv_blocks_write = c->resv_blocks_deletion + (size / c->sector_size);
4000b91c: 81 80 20 00 wr %g0, %y
4000b920: 01 00 00 00 nop
4000b924: 01 00 00 00 nop
4000b928: 01 00 00 00 nop
4000b92c: 82 70 40 03 udiv %g1, %g3, %g1
c->resv_blocks_gcmerge = c->resv_blocks_deletion + 1;
4000b930: c8 2e a0 48 stb %g4, [ %i2 + 0x48 ]
c->resv_blocks_gctrigger = c->resv_blocks_write + 1;
4000b934: 88 00 60 03 add %g1, 3, %g4
c->resv_blocks_write = c->resv_blocks_deletion + (size / c->sector_size);
4000b938: 82 00 60 02 add %g1, 2, %g1
c->resv_blocks_gcbad = 0;//c->resv_blocks_deletion + 2;
4000b93c: c0 2e a0 47 clrb [ %i2 + 0x47 ]
c->nospc_dirty_size = c->sector_size + (c->flash_size / 100);
4000b940: 85 30 a0 05 srl %g2, 5, %g2
c->resv_blocks_write = c->resv_blocks_deletion + (size / c->sector_size);
4000b944: c2 2e a0 44 stb %g1, [ %i2 + 0x44 ]
c->nospc_dirty_size = c->sector_size + (c->flash_size / 100);
4000b948: 84 00 80 03 add %g2, %g3, %g2
c->resv_blocks_gctrigger = c->resv_blocks_write + 1;
4000b94c: c8 2e a0 46 stb %g4, [ %i2 + 0x46 ]
c->vdirty_blocks_gctrigger *= 10;
4000b950: 87 29 20 02 sll %g4, 2, %g3
c->nospc_dirty_size = c->sector_size + (c->flash_size / 100);
4000b954: c4 26 a0 4c st %g2, [ %i2 + 0x4c ]
c->vdirty_blocks_gctrigger *= 10;
4000b958: 82 01 00 03 add %g4, %g3, %g1
4000b95c: 83 28 60 01 sll %g1, 1, %g1
4000b960: c2 2e a0 49 stb %g1, [ %i2 + 0x49 ]
}
4000b964: 81 c7 e0 08 ret
4000b968: 81 e8 00 00 restore
if (ic->next)
4000b96c: f8 07 20 10 ld [ %i4 + 0x10 ], %i4 <== NOT EXECUTED
4000b970: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4000b974: 32 80 00 12 bne,a 4000b9bc <jffs2_do_mount_fs+0x548> <== NOT EXECUTED
4000b978: fa 07 00 00 ld [ %i4 ], %i5 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000b97c: c4 06 a0 c0 ld [ %i2 + 0xc0 ], %g2 <== NOT EXECUTED
(*i)++;
4000b980: b6 06 e0 01 inc %i3 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000b984: 80 a6 c0 02 cmp %i3, %g2 <== NOT EXECUTED
4000b988: 36 bf ff d2 bge,a 4000b8d0 <jffs2_do_mount_fs+0x45c> <== NOT EXECUTED
4000b98c: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 <== NOT EXECUTED
if (c->inocache_list[*i])
4000b990: 10 80 00 05 b 4000b9a4 <jffs2_do_mount_fs+0x530> <== NOT EXECUTED
4000b994: c6 06 a0 c4 ld [ %i2 + 0xc4 ], %g3 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000b998: 80 a6 c0 02 cmp %i3, %g2 <== NOT EXECUTED
4000b99c: 22 bf ff cd be,a 4000b8d0 <jffs2_do_mount_fs+0x45c> <== NOT EXECUTED
4000b9a0: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 <== NOT EXECUTED
if (c->inocache_list[*i])
4000b9a4: 83 2e e0 02 sll %i3, 2, %g1 <== NOT EXECUTED
4000b9a8: f8 00 c0 01 ld [ %g3 + %g1 ], %i4 <== NOT EXECUTED
4000b9ac: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
4000b9b0: 22 bf ff fa be,a 4000b998 <jffs2_do_mount_fs+0x524> <== NOT EXECUTED
4000b9b4: b6 06 e0 01 inc %i3 <== NOT EXECUTED
while(ic->scan_dents) {
4000b9b8: fa 07 00 00 ld [ %i4 ], %i5 <== NOT EXECUTED
4000b9bc: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4000b9c0: 22 bf ff eb be,a 4000b96c <jffs2_do_mount_fs+0x4f8> <== NOT EXECUTED
4000b9c4: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
ic->scan_dents = fd->next;
4000b9c8: c4 07 60 04 ld [ %i5 + 4 ], %g2 <== NOT EXECUTED
4000b9cc: c4 27 00 00 st %g2, [ %i4 ] <== NOT EXECUTED
if (fd->type == DT_DIR) {
4000b9d0: c2 0f 60 14 ldub [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
4000b9d4: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
4000b9d8: 12 80 00 11 bne 4000ba1c <jffs2_do_mount_fs+0x5a8> <== NOT EXECUTED
4000b9dc: 01 00 00 00 nop <== NOT EXECUTED
if (!fd->ic) {
4000b9e0: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
4000b9e4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000b9e8: 22 bf ff f5 be,a 4000b9bc <jffs2_do_mount_fs+0x548> <== NOT EXECUTED
4000b9ec: ba 10 00 02 mov %g2, %i5 <== NOT EXECUTED
BUG_ON(!(fd->ic->flags & INO_FLAGS_IS_DIR));
4000b9f0: c4 08 60 09 ldub [ %g1 + 9 ], %g2 <== NOT EXECUTED
4000b9f4: 80 88 a0 02 btst 2, %g2 <== NOT EXECUTED
4000b9f8: 02 80 00 54 be 4000bb48 <jffs2_do_mount_fs+0x6d4> <== NOT EXECUTED
4000b9fc: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
if (dir_hardlinks && fd->ic->pino_nlink) {
4000ba00: 02 80 00 06 be 4000ba18 <jffs2_do_mount_fs+0x5a4> <== NOT EXECUTED
4000ba04: d8 07 20 0c ld [ %i4 + 0xc ], %o4 <== NOT EXECUTED
4000ba08: da 00 60 14 ld [ %g1 + 0x14 ], %o5 <== NOT EXECUTED
4000ba0c: 80 a3 60 00 cmp %o5, 0 <== NOT EXECUTED
4000ba10: 32 80 00 07 bne,a 4000ba2c <jffs2_do_mount_fs+0x5b8> <== NOT EXECUTED
4000ba14: d6 07 60 0c ld [ %i5 + 0xc ], %o3 <== NOT EXECUTED
fd->ic->pino_nlink = ic->ino;
4000ba18: d8 20 60 14 st %o4, [ %g1 + 0x14 ] <== NOT EXECUTED
jffs2_free_full_dirent(fd);
4000ba1c: 7f ff e8 5c call 40005b8c <jffs2_free_full_dirent> <== NOT EXECUTED
4000ba20: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
while(ic->scan_dents) {
4000ba24: 10 bf ff e6 b 4000b9bc <jffs2_do_mount_fs+0x548> <== NOT EXECUTED
4000ba28: fa 07 00 00 ld [ %i4 ], %i5 <== NOT EXECUTED
JFFS2_ERROR("child dir \"%s\" (ino #%u) of dir ino #%u is also hard linked from dir ino #%u\n",
4000ba2c: 94 07 60 15 add %i5, 0x15, %o2 <== NOT EXECUTED
4000ba30: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4000ba34: 7f ff fe 83 call 4000b440 <jffs2_printk.constprop.0> <== NOT EXECUTED
4000ba38: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
fd->ic->pino_nlink = ic->ino;
4000ba3c: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
4000ba40: 10 bf ff f6 b 4000ba18 <jffs2_do_mount_fs+0x5a4> <== NOT EXECUTED
4000ba44: d8 07 20 0c ld [ %i4 + 0xc ], %o4 <== NOT EXECUTED
jffs2_mark_node_obsolete(c, fd->raw);
4000ba48: 7f ff ed 32 call 40006f10 <jffs2_mark_node_obsolete> <== NOT EXECUTED
4000ba4c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
continue;
4000ba50: 10 bf ff 52 b 4000b798 <jffs2_do_mount_fs+0x324> <== NOT EXECUTED
4000ba54: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000ba58: c6 06 a0 c0 ld [ %i2 + 0xc0 ], %g3 <== NOT EXECUTED
for_each_inode(i, c, ic) {
4000ba5c: b8 10 20 00 clr %i4 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000ba60: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
4000ba64: 04 80 00 2e ble 4000bb1c <jffs2_do_mount_fs+0x6a8> <== NOT EXECUTED
4000ba68: ba 10 20 00 clr %i5 <== NOT EXECUTED
if (c->inocache_list[*i])
4000ba6c: 10 80 00 05 b 4000ba80 <jffs2_do_mount_fs+0x60c> <== NOT EXECUTED
4000ba70: c4 06 a0 c4 ld [ %i2 + 0xc4 ], %g2 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000ba74: 80 a7 00 03 cmp %i4, %g3 <== NOT EXECUTED
4000ba78: 02 80 00 2a be 4000bb20 <jffs2_do_mount_fs+0x6ac> <== NOT EXECUTED
4000ba7c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
if (c->inocache_list[*i])
4000ba80: 83 2f 20 02 sll %i4, 2, %g1 <== NOT EXECUTED
4000ba84: fa 00 80 01 ld [ %g2 + %g1 ], %i5 <== NOT EXECUTED
4000ba88: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4000ba8c: 22 bf ff fa be,a 4000ba74 <jffs2_do_mount_fs+0x600> <== NOT EXECUTED
4000ba90: b8 07 20 01 inc %i4 <== NOT EXECUTED
4000ba94: 10 80 00 05 b 4000baa8 <jffs2_do_mount_fs+0x634> <== NOT EXECUTED
4000ba98: d0 07 40 00 ld [ %i5 ], %o0 <== NOT EXECUTED
jffs2_free_full_dirent(fd);
4000ba9c: 7f ff e8 3c call 40005b8c <jffs2_free_full_dirent> <== NOT EXECUTED
4000baa0: c2 27 40 00 st %g1, [ %i5 ] <== NOT EXECUTED
while(ic->scan_dents) {
4000baa4: d0 07 40 00 ld [ %i5 ], %o0 <== NOT EXECUTED
4000baa8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000baac: 32 bf ff fc bne,a 4000ba9c <jffs2_do_mount_fs+0x628> <== NOT EXECUTED
4000bab0: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED
if (ic->next)
4000bab4: fa 07 60 10 ld [ %i5 + 0x10 ], %i5 <== NOT EXECUTED
4000bab8: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4000babc: 32 bf ff fb bne,a 4000baa8 <jffs2_do_mount_fs+0x634> <== NOT EXECUTED
4000bac0: d0 07 40 00 ld [ %i5 ], %o0 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000bac4: c4 06 a0 c0 ld [ %i2 + 0xc0 ], %g2 <== NOT EXECUTED
(*i)++;
4000bac8: b8 07 20 01 inc %i4 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000bacc: 80 a0 80 1c cmp %g2, %i4 <== NOT EXECUTED
4000bad0: 04 80 00 0b ble 4000bafc <jffs2_do_mount_fs+0x688> <== NOT EXECUTED
4000bad4: 83 2f 20 02 sll %i4, 2, %g1 <== NOT EXECUTED
if (c->inocache_list[*i])
4000bad8: c6 06 a0 c4 ld [ %i2 + 0xc4 ], %g3 <== NOT EXECUTED
4000badc: fa 00 c0 01 ld [ %g3 + %g1 ], %i5 <== NOT EXECUTED
4000bae0: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4000bae4: 32 bf ff f1 bne,a 4000baa8 <jffs2_do_mount_fs+0x634> <== NOT EXECUTED
4000bae8: d0 07 40 00 ld [ %i5 ], %o0 <== NOT EXECUTED
for (; *i < c->inocache_hashsize; (*i)++) {
4000baec: b8 07 20 01 inc %i4 <== NOT EXECUTED
4000baf0: 80 a0 80 1c cmp %g2, %i4 <== NOT EXECUTED
4000baf4: 12 bf ff fa bne 4000badc <jffs2_do_mount_fs+0x668> <== NOT EXECUTED
4000baf8: 83 2f 20 02 sll %i4, 2, %g1 <== NOT EXECUTED
if (ret)
goto out_free;
if (jffs2_build_filesystem(c)) {
dbg_fsbuild("build_fs failed\n");
jffs2_free_ino_caches(c);
4000bafc: 7f ff eb 12 call 40006744 <jffs2_free_ino_caches> <== NOT EXECUTED
4000bb00: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
jffs2_free_raw_node_refs(c);
4000bb04: 7f ff eb 2a call 400067ac <jffs2_free_raw_node_refs> <== NOT EXECUTED
4000bb08: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
jffs2_calc_trigger_levels(c);
return 0;
out_free:
kvfree(c->blocks);
4000bb0c: 40 00 0c 8a call 4000ed34 <free> <== NOT EXECUTED
4000bb10: d0 06 a0 54 ld [ %i2 + 0x54 ], %o0 <== NOT EXECUTED
return ret;
4000bb14: 81 c7 e0 08 ret <== NOT EXECUTED
4000bb18: 91 e8 3f fb restore %g0, -5, %o0 <== NOT EXECUTED
for_each_inode(i, c, ic) {
4000bb1c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4000bb20: 32 bf ff e2 bne,a 4000baa8 <jffs2_do_mount_fs+0x634> <== NOT EXECUTED
4000bb24: d0 07 40 00 ld [ %i5 ], %o0 <== NOT EXECUTED
jffs2_free_ino_caches(c);
4000bb28: 7f ff eb 07 call 40006744 <jffs2_free_ino_caches> <== NOT EXECUTED
4000bb2c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
jffs2_free_raw_node_refs(c);
4000bb30: 7f ff eb 1f call 400067ac <jffs2_free_raw_node_refs> <== NOT EXECUTED
4000bb34: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
kvfree(c->blocks);
4000bb38: 40 00 0c 7f call 4000ed34 <free> <== NOT EXECUTED
4000bb3c: d0 06 a0 54 ld [ %i2 + 0x54 ], %o0 <== NOT EXECUTED
return ret;
4000bb40: 81 c7 e0 08 ret <== NOT EXECUTED
4000bb44: 91 e8 3f fb restore %g0, -5, %o0 <== NOT EXECUTED
BUG_ON(!(fd->ic->flags & INO_FLAGS_IS_DIR));
4000bb48: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
4000bb4c: 15 10 00 80 sethi %hi(0x40020000), %o2 <== NOT EXECUTED
4000bb50: 11 10 00 80 sethi %hi(0x40020000), %o0 <== NOT EXECUTED
4000bb54: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
4000bb58: 94 12 a3 60 or %o2, 0x360, %o2 <== NOT EXECUTED
4000bb5c: 92 10 20 c4 mov 0xc4, %o1 <== NOT EXECUTED
4000bb60: 40 00 0b 86 call 4000e978 <__assert_func> <== NOT EXECUTED
4000bb64: 90 12 23 30 or %o0, 0x330, %o0 <== NOT EXECUTED
return NULL;
4000bb68: 10 bf fe a4 b 4000b5f8 <jffs2_do_mount_fs+0x184> <== NOT EXECUTED
4000bb6c: b8 10 20 00 clr %i4 <== NOT EXECUTED
}
4000bb70: 81 c7 e0 08 ret <== NOT EXECUTED
4000bb74: 91 e8 3f f4 restore %g0, -12, %o0 <== NOT EXECUTED
40009ff8 <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)
{
40009ff8: 9d e3 bf a0 save %sp, -96, %sp
struct jffs2_inode_cache *ic;
ic = jffs2_alloc_inode_cache();
40009ffc: 7f ff ef 3f call 40005cf8 <jffs2_alloc_inode_cache>
4000a000: 01 00 00 00 nop
if (!ic) {
4000a004: ba 92 20 00 orcc %o0, 0, %i5
4000a008: 02 80 00 3c be 4000a0f8 <jffs2_do_new_inode+0x100> <== NEVER TAKEN
4000a00c: 94 10 20 18 mov 0x18, %o2
return -ENOMEM;
}
memset(ic, 0, sizeof(*ic));
4000a010: 40 00 4c 05 call 4001d024 <memset>
4000a014: 92 10 20 00 clr %o1
f->inocache = ic;
4000a018: fa 26 60 14 st %i5, [ %i1 + 0x14 ]
f->inocache->pino_nlink = 1; /* Will be overwritten shortly for directories */
4000a01c: b8 10 20 01 mov 1, %i4
f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
f->inocache->state = INO_STATE_PRESENT;
4000a020: 82 10 20 02 mov 2, %g1
f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
4000a024: fa 27 60 04 st %i5, [ %i5 + 4 ]
jffs2_add_ino_cache(c, f->inocache);
4000a028: 92 10 00 1d mov %i5, %o1
f->inocache->state = INO_STATE_PRESENT;
4000a02c: c2 37 60 0a sth %g1, [ %i5 + 0xa ]
jffs2_add_ino_cache(c, f->inocache);
4000a030: 90 10 00 18 mov %i0, %o0
f->inocache->pino_nlink = 1; /* Will be overwritten shortly for directories */
4000a034: f8 27 60 14 st %i4, [ %i5 + 0x14 ]
jffs2_add_ino_cache(c, f->inocache);
4000a038: 7f ff f1 76 call 40006610 <jffs2_add_ino_cache>
4000a03c: b0 10 20 00 clr %i0
jffs2_dbg(1, "%s(): Assigned ino# %d\n", __func__, f->inocache->ino);
ri->ino = cpu_to_je32(f->inocache->ino);
4000a040: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
4000a044: c8 08 60 0c ldub [ %g1 + 0xc ], %g4
4000a048: c6 08 60 0d ldub [ %g1 + 0xd ], %g3
4000a04c: c4 08 60 0e ldub [ %g1 + 0xe ], %g2
4000a050: c2 08 60 0f ldub [ %g1 + 0xf ], %g1
4000a054: c2 2e e0 0f stb %g1, [ %i3 + 0xf ]
ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
4000a058: 82 10 20 19 mov 0x19, %g1
4000a05c: c2 2e c0 00 stb %g1, [ %i3 ]
4000a060: 82 10 3f 85 mov -123, %g1
4000a064: c2 2e e0 01 stb %g1, [ %i3 + 1 ]
ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
4000a068: 82 10 3f e0 mov -32, %g1
4000a06c: c2 2e e0 02 stb %g1, [ %i3 + 2 ]
4000a070: 82 10 20 02 mov 2, %g1
ri->ino = cpu_to_je32(f->inocache->ino);
4000a074: c4 2e e0 0e stb %g2, [ %i3 + 0xe ]
ri->totlen = cpu_to_je32(PAD(sizeof(*ri)));
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000a078: 94 10 20 08 mov 8, %o2
ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
4000a07c: c2 2e e0 03 stb %g1, [ %i3 + 3 ]
ri->totlen = cpu_to_je32(PAD(sizeof(*ri)));
4000a080: 82 10 20 44 mov 0x44, %g1
ri->ino = cpu_to_je32(f->inocache->ino);
4000a084: c8 2e e0 0c stb %g4, [ %i3 + 0xc ]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000a088: 92 10 00 1b mov %i3, %o1
ri->totlen = cpu_to_je32(PAD(sizeof(*ri)));
4000a08c: c2 2e e0 07 stb %g1, [ %i3 + 7 ]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000a090: 90 10 20 00 clr %o0
ri->ino = cpu_to_je32(f->inocache->ino);
4000a094: c6 2e e0 0d stb %g3, [ %i3 + 0xd ]
ri->totlen = cpu_to_je32(PAD(sizeof(*ri)));
4000a098: c0 2e e0 04 clrb [ %i3 + 4 ]
4000a09c: c0 2e e0 05 clrb [ %i3 + 5 ]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000a0a0: 40 00 06 b6 call 4000bb78 <cyg_crc32_accumulate>
4000a0a4: c0 2e e0 06 clrb [ %i3 + 6 ]
4000a0a8: 83 32 20 10 srl %o0, 0x10, %g1
4000a0ac: d0 2e e0 0b stb %o0, [ %i3 + 0xb ]
4000a0b0: 85 32 20 18 srl %o0, 0x18, %g2
4000a0b4: c2 2e e0 09 stb %g1, [ %i3 + 9 ]
4000a0b8: 91 32 20 08 srl %o0, 8, %o0
ri->mode = cpu_to_jemode(mode);
4000a0bc: c0 2e e0 14 clrb [ %i3 + 0x14 ]
return osmode & (S_IFMT | S_IRWXU | S_IRWXG | S_IRWXO);
4000a0c0: 83 36 a0 08 srl %i2, 8, %g1
4000a0c4: c0 2e e0 15 clrb [ %i3 + 0x15 ]
4000a0c8: 82 08 60 f1 and %g1, 0xf1, %g1
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000a0cc: c4 2e e0 08 stb %g2, [ %i3 + 8 ]
4000a0d0: d0 2e e0 0a stb %o0, [ %i3 + 0xa ]
ri->mode = cpu_to_jemode(mode);
4000a0d4: f4 2e e0 17 stb %i2, [ %i3 + 0x17 ]
4000a0d8: c2 2e e0 16 stb %g1, [ %i3 + 0x16 ]
f->highest_version = 1;
4000a0dc: f8 26 40 00 st %i4, [ %i1 ]
ri->version = cpu_to_je32(f->highest_version);
4000a0e0: c0 2e e0 10 clrb [ %i3 + 0x10 ]
4000a0e4: c0 2e e0 11 clrb [ %i3 + 0x11 ]
4000a0e8: c0 2e e0 12 clrb [ %i3 + 0x12 ]
4000a0ec: f8 2e e0 13 stb %i4, [ %i3 + 0x13 ]
return 0;
4000a0f0: 81 c7 e0 08 ret
4000a0f4: 81 e8 00 00 restore
}
4000a0f8: 81 c7 e0 08 ret <== NOT EXECUTED
4000a0fc: 91 e8 3f f4 restore %g0, -12, %o0 <== NOT EXECUTED
40009cc4 <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)
{
40009cc4: 9d e3 bf a0 save %sp, -96, %sp
40009cc8: 3b 10 00 27 sethi %hi(0x40009c00), %i5
40009ccc: ba 17 60 ac or %i5, 0xac, %i5 ! 40009cac <jffs2_do_read_inode_internal+0x197c>
dbg_readinode("read inode #%u\n", ino);
retry_inocache:
spin_lock(&c->inocache_lock);
f->inocache = jffs2_get_ino_cache(c, ino);
40009cd0: 92 10 00 1a mov %i2, %o1
40009cd4: 7f ff f2 31 call 40006598 <jffs2_get_ino_cache>
40009cd8: 90 10 00 18 mov %i0, %o0
if (f->inocache) {
40009cdc: 80 a2 20 00 cmp %o0, 0
40009ce0: 02 80 00 13 be 40009d2c <jffs2_do_read_inode+0x68>
40009ce4: d0 26 60 14 st %o0, [ %i1 + 0x14 ]
/* Check its state. We may need to wait before we can use it */
switch(f->inocache->state) {
40009ce8: d6 12 20 0a lduh [ %o0 + 0xa ], %o3
40009cec: 97 2a e0 10 sll %o3, 0x10, %o3
40009cf0: 83 32 e0 10 srl %o3, 0x10, %g1
40009cf4: 80 a0 60 05 cmp %g1, 5
40009cf8: 18 80 00 3a bgu 40009de0 <jffs2_do_read_inode+0x11c> <== NEVER TAKEN
40009cfc: 83 28 60 02 sll %g1, 2, %g1
40009d00: c2 07 40 01 ld [ %i5 + %g1 ], %g1
40009d04: 81 c0 40 00 jmp %g1
40009d08: 01 00 00 00 nop
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);
40009d0c: 97 32 e0 10 srl %o3, 0x10, %o3 <== NOT EXECUTED
40009d10: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
40009d14: 13 10 00 80 sethi %hi(0x40020000), %o1 <== NOT EXECUTED
40009d18: 11 10 00 7f sethi %hi(0x4001fc00), %o0 <== NOT EXECUTED
40009d1c: 92 12 60 88 or %o1, 0x88, %o1 <== NOT EXECUTED
40009d20: 7f ff f8 ed call 400080d4 <jffs2_printk> <== NOT EXECUTED
40009d24: 90 12 22 e8 or %o0, 0x2e8, %o0 <== NOT EXECUTED
/* Fail. That's probably better than allowing it to succeed */
f->inocache = NULL;
40009d28: c0 26 60 14 clr [ %i1 + 0x14 ] <== NOT EXECUTED
BUG();
}
}
spin_unlock(&c->inocache_lock);
if (!f->inocache && ino == 1) {
40009d2c: 80 a6 a0 01 cmp %i2, 1
40009d30: 12 80 00 24 bne 40009dc0 <jffs2_do_read_inode+0xfc> <== NEVER TAKEN
40009d34: 94 10 00 1a mov %i2, %o2
/* Special case - no root inode on medium */
f->inocache = jffs2_alloc_inode_cache();
40009d38: 7f ff ef f0 call 40005cf8 <jffs2_alloc_inode_cache>
40009d3c: 01 00 00 00 nop
if (!f->inocache) {
40009d40: 80 a2 20 00 cmp %o0, 0
40009d44: 02 80 00 17 be 40009da0 <jffs2_do_read_inode+0xdc> <== NEVER TAKEN
40009d48: d0 26 60 14 st %o0, [ %i1 + 0x14 ]
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));
40009d4c: 94 10 20 18 mov 0x18, %o2
40009d50: 40 00 4c b5 call 4001d024 <memset>
40009d54: 92 10 20 00 clr %o1
f->inocache->ino = f->inocache->pino_nlink = 1;
40009d58: d2 06 60 14 ld [ %i1 + 0x14 ], %o1
f->inocache->nodes = (struct jffs2_raw_node_ref *)f->inocache;
f->inocache->state = INO_STATE_READING;
40009d5c: 82 10 20 05 mov 5, %g1
f->inocache->ino = f->inocache->pino_nlink = 1;
40009d60: f4 22 60 14 st %i2, [ %o1 + 0x14 ]
jffs2_add_ino_cache(c, f->inocache);
40009d64: 90 10 00 18 mov %i0, %o0
f->inocache->state = INO_STATE_READING;
40009d68: c2 32 60 0a sth %g1, [ %o1 + 0xa ]
f->inocache->ino = f->inocache->pino_nlink = 1;
40009d6c: f4 22 60 0c st %i2, [ %o1 + 0xc ]
jffs2_add_ino_cache(c, f->inocache);
40009d70: 7f ff f2 28 call 40006610 <jffs2_add_ino_cache>
40009d74: d2 22 60 04 st %o1, [ %o1 + 4 ]
}
if (!f->inocache) {
40009d78: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
40009d7c: 80 a0 60 00 cmp %g1, 0
40009d80: 02 80 00 10 be 40009dc0 <jffs2_do_read_inode+0xfc> <== NEVER TAKEN
40009d84: 94 10 00 1a mov %i2, %o2
JFFS2_ERROR("requested to read a nonexistent ino %u\n", ino);
return -ENOENT;
}
return jffs2_do_read_inode_internal(c, f, latest_node);
40009d88: 7f ff f9 6a call 40008330 <jffs2_do_read_inode_internal>
40009d8c: 95 e8 00 1b restore %g0, %i3, %o2
f->inocache->state = INO_STATE_READING;
40009d90: 82 10 20 05 mov 5, %g1
40009d94: c2 32 20 0a sth %g1, [ %o0 + 0xa ]
return jffs2_do_read_inode_internal(c, f, latest_node);
40009d98: 7f ff f9 66 call 40008330 <jffs2_do_read_inode_internal>
40009d9c: 95 e8 00 1b restore %g0, %i3, %o2
JFFS2_ERROR("cannot allocate inocache for root inode\n");
40009da0: 13 10 00 80 sethi %hi(0x40020000), %o1 <== NOT EXECUTED
40009da4: 11 10 00 7f sethi %hi(0x4001fc00), %o0 <== NOT EXECUTED
40009da8: 92 12 60 88 or %o1, 0x88, %o1 <== NOT EXECUTED
40009dac: 90 12 23 40 or %o0, 0x340, %o0 <== NOT EXECUTED
40009db0: 7f ff f8 c9 call 400080d4 <jffs2_printk> <== NOT EXECUTED
40009db4: b0 10 3f f4 mov -12, %i0 <== NOT EXECUTED
return -ENOMEM;
40009db8: 81 c7 e0 08 ret <== NOT EXECUTED
40009dbc: 81 e8 00 00 restore <== NOT EXECUTED
JFFS2_ERROR("requested to read a nonexistent ino %u\n", ino);
40009dc0: 13 10 00 80 sethi %hi(0x40020000), %o1 <== NOT EXECUTED
40009dc4: 11 10 00 7f sethi %hi(0x4001fc00), %o0 <== NOT EXECUTED
40009dc8: 92 12 60 88 or %o1, 0x88, %o1 <== NOT EXECUTED
40009dcc: 90 12 23 80 or %o0, 0x380, %o0 <== NOT EXECUTED
40009dd0: 7f ff f8 c1 call 400080d4 <jffs2_printk> <== NOT EXECUTED
40009dd4: b0 10 3f fe mov -2, %i0 <== NOT EXECUTED
}
40009dd8: 81 c7 e0 08 ret <== NOT EXECUTED
40009ddc: 81 e8 00 00 restore <== NOT EXECUTED
BUG();
40009de0: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
40009de4: 15 10 00 80 sethi %hi(0x40020000), %o2 <== NOT EXECUTED
40009de8: 11 10 00 7d sethi %hi(0x4001f400), %o0 <== NOT EXECUTED
40009dec: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
40009df0: 94 12 a0 88 or %o2, 0x88, %o2 <== NOT EXECUTED
40009df4: 92 10 25 5a mov 0x55a, %o1 <== NOT EXECUTED
40009df8: 40 00 12 e0 call 4000e978 <__assert_func> <== NOT EXECUTED
40009dfc: 90 12 20 c8 or %o0, 0xc8, %o0 <== NOT EXECUTED
40009e00: 01 00 00 00 nop <== NOT EXECUTED
4000affc <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)
{
4000affc: 9d e3 bf a0 save %sp, -96, %sp
while (len--) {
4000b000: 80 a6 e0 00 cmp %i3, 0
4000b004: 02 80 00 0c be 4000b034 <jffs2_do_unlink+0x38> <== NEVER TAKEN
4000b008: ba 10 20 00 clr %i5
4000b00c: 88 06 80 1b add %i2, %i3, %g4
4000b010: 82 10 00 1a mov %i2, %g1
hash ^= *(name++);
4000b014: c4 08 40 00 ldub [ %g1 ], %g2
hash = (hash << 4) | (hash >> 28);
4000b018: 87 2f 60 04 sll %i5, 4, %g3
hash ^= *(name++);
4000b01c: 82 00 60 01 inc %g1
hash = (hash << 4) | (hash >> 28);
4000b020: bb 37 60 1c srl %i5, 0x1c, %i5
while (len--) {
4000b024: 80 a0 40 04 cmp %g1, %g4
hash = (hash << 4) | (hash >> 28);
4000b028: ba 17 40 03 or %i5, %g3, %i5
while (len--) {
4000b02c: 12 bf ff fa bne 4000b014 <jffs2_do_unlink+0x18>
4000b030: ba 18 80 1d xor %g2, %i5, %i5
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;
4000b034: f2 06 60 0c ld [ %i1 + 0xc ], %i1
/* 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) {
4000b038: 80 a6 60 00 cmp %i1, 0
4000b03c: 32 80 00 09 bne,a 4000b060 <jffs2_do_unlink+0x64> <== ALWAYS TAKEN
4000b040: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
}
/* 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) {
4000b044: 10 80 00 1b b 4000b0b0 <jffs2_do_unlink+0xb4> <== NOT EXECUTED
4000b048: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
for (fd = dir_f->dents; fd; fd = fd->next) {
4000b04c: f2 06 60 04 ld [ %i1 + 4 ], %i1 <== NOT EXECUTED
4000b050: 80 a6 60 00 cmp %i1, 0
4000b054: 02 80 00 17 be 4000b0b0 <jffs2_do_unlink+0xb4> <== NEVER TAKEN
4000b058: 80 a7 20 00 cmp %i4, 0
if (fd->nhash == nhash &&
4000b05c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000b060: 80 a0 40 1d cmp %g1, %i5
4000b064: 32 bf ff fb bne,a 4000b050 <jffs2_do_unlink+0x54>
4000b068: f2 06 60 04 ld [ %i1 + 4 ], %i1
!memcmp(fd->name, name, namelen) &&
4000b06c: 90 06 60 15 add %i1, 0x15, %o0
4000b070: 94 10 00 1b mov %i3, %o2
4000b074: 40 00 47 8b call 4001cea0 <memcmp>
4000b078: 92 10 00 1a mov %i2, %o1
if (fd->nhash == nhash &&
4000b07c: 80 a2 20 00 cmp %o0, 0
4000b080: 12 bf ff f3 bne 4000b04c <jffs2_do_unlink+0x50> <== NEVER TAKEN
4000b084: 82 06 40 1b add %i1, %i3, %g1
!memcmp(fd->name, name, namelen) &&
4000b088: c2 08 60 15 ldub [ %g1 + 0x15 ], %g1
4000b08c: 80 a0 60 00 cmp %g1, 0
4000b090: 32 bf ff f0 bne,a 4000b050 <jffs2_do_unlink+0x54> <== NEVER TAKEN
4000b094: f2 06 60 04 ld [ %i1 + 4 ], %i1 <== NOT EXECUTED
jffs2_mark_node_obsolete(c, fd->raw);
4000b098: d2 06 40 00 ld [ %i1 ], %o1
4000b09c: 7f ff ef 9d call 40006f10 <jffs2_mark_node_obsolete>
4000b0a0: 90 10 00 18 mov %i0, %o0
fd->raw = NULL;
4000b0a4: c0 26 40 00 clr [ %i1 ]
fd->ino = 0;
4000b0a8: c0 26 60 0c clr [ %i1 + 0xc ]
if (dead_f && dead_f->inocache) {
4000b0ac: 80 a7 20 00 cmp %i4, 0
4000b0b0: 22 80 00 10 be,a 4000b0f0 <jffs2_do_unlink+0xf4> <== NEVER TAKEN
4000b0b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000b0b8: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
4000b0bc: 80 a0 60 00 cmp %g1, 0
4000b0c0: 02 80 00 0b be 4000b0ec <jffs2_do_unlink+0xf0> <== NEVER TAKEN
4000b0c4: 07 00 00 3c sethi %hi(0xf000), %g3
mutex_lock(&dead_f->sem);
if (S_ISDIR(OFNI_EDONI_2SFFJ(dead_f)->i_mode)) {
4000b0c8: c4 07 3f c0 ld [ %i4 + -64 ], %g2
4000b0cc: 84 08 80 03 and %g2, %g3, %g2
4000b0d0: 07 00 00 10 sethi %hi(0x4000), %g3
4000b0d4: 80 a0 80 03 cmp %g2, %g3
4000b0d8: 22 80 00 0a be,a 4000b100 <jffs2_do_unlink+0x104>
4000b0dc: fa 07 20 0c ld [ %i4 + 0xc ], %i5
jffs2_mark_node_obsolete(c, fd->raw);
jffs2_free_full_dirent(fd);
}
dead_f->inocache->pino_nlink = 0;
} else
dead_f->inocache->pino_nlink--;
4000b0e0: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
4000b0e4: 84 00 bf ff add %g2, -1, %g2
4000b0e8: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
/* NB: Caller must set inode nlink if appropriate */
mutex_unlock(&dead_f->sem);
}
jffs2_complete_reservation(c);
4000b0ec: 90 10 00 18 mov %i0, %o0
4000b0f0: 7f ff ef 7e call 40006ee8 <jffs2_complete_reservation>
4000b0f4: b0 10 20 00 clr %i0
return 0;
}
4000b0f8: 81 c7 e0 08 ret
4000b0fc: 81 e8 00 00 restore
while (dead_f->dents) {
4000b100: 80 a7 60 00 cmp %i5, 0
4000b104: 02 80 00 1c be 4000b174 <jffs2_do_unlink+0x178> <== ALWAYS TAKEN
4000b108: 37 10 00 80 sethi %hi(0x40020000), %i3
pr_warn("Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
4000b10c: 10 80 00 0d b 4000b140 <jffs2_do_unlink+0x144> <== NOT EXECUTED
4000b110: b6 16 e2 58 or %i3, 0x258, %i3 ! 40020258 <__func__.10+0x1d0> <== NOT EXECUTED
if (fd->raw)
4000b114: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
4000b118: 02 80 00 04 be 4000b128 <jffs2_do_unlink+0x12c> <== NOT EXECUTED
4000b11c: 01 00 00 00 nop <== NOT EXECUTED
jffs2_mark_node_obsolete(c, fd->raw);
4000b120: 7f ff ef 7c call 40006f10 <jffs2_mark_node_obsolete> <== NOT EXECUTED
4000b124: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
jffs2_free_full_dirent(fd);
4000b128: 7f ff ea 99 call 40005b8c <jffs2_free_full_dirent> <== NOT EXECUTED
4000b12c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
while (dead_f->dents) {
4000b130: fa 07 20 0c ld [ %i4 + 0xc ], %i5 <== NOT EXECUTED
4000b134: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4000b138: 22 80 00 0f be,a 4000b174 <jffs2_do_unlink+0x178> <== NOT EXECUTED
4000b13c: c2 07 20 14 ld [ %i4 + 0x14 ], %g1 <== NOT EXECUTED
dead_f->dents = fd->next;
4000b140: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
4000b144: c2 27 20 0c st %g1, [ %i4 + 0xc ] <== NOT EXECUTED
if (fd->ino) {
4000b148: d6 07 60 0c ld [ %i5 + 0xc ], %o3 <== NOT EXECUTED
4000b14c: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED
4000b150: 22 bf ff f1 be,a 4000b114 <jffs2_do_unlink+0x118> <== NOT EXECUTED
4000b154: d2 07 40 00 ld [ %i5 ], %o1 <== NOT EXECUTED
pr_warn("Deleting inode #%u with active dentry \"%s\"->ino #%u\n",
4000b158: c2 07 20 14 ld [ %i4 + 0x14 ], %g1 <== NOT EXECUTED
4000b15c: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
4000b160: 94 07 60 15 add %i5, 0x15, %o2 <== NOT EXECUTED
4000b164: 7f ff fb 99 call 40009fc8 <jffs2_printk> <== NOT EXECUTED
4000b168: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
4000b16c: 10 bf ff ea b 4000b114 <jffs2_do_unlink+0x118> <== NOT EXECUTED
4000b170: d2 07 40 00 ld [ %i5 ], %o1 <== NOT EXECUTED
dead_f->inocache->pino_nlink = 0;
4000b174: c0 20 60 14 clr [ %g1 + 0x14 ]
jffs2_complete_reservation(c);
4000b178: 90 10 00 18 mov %i0, %o0
4000b17c: 7f ff ef 5b call 40006ee8 <jffs2_complete_reservation>
4000b180: b0 10 20 00 clr %i0
}
4000b184: 81 c7 e0 08 ret
4000b188: 81 e8 00 00 restore
4000c8b8 <jffs2_erase_pending_blocks>:
{
4000c8b8: 9d e3 bf 80 save %sp, -128, %sp
*bad_offset = ofs;
ret = jffs2_flash_read(c, ofs, readlen, &retlen, ebuf);
if (ret) {
pr_warn("Read of newly-erased block at 0x%08x failed: %d. Putting on bad_list\n",
4000c8bc: 27 10 00 82 sethi %hi(0x40020800), %l3
4000c8c0: 82 14 e2 d0 or %l3, 0x2d0, %g1 ! 40020ad0 <__func__.0+0x188>
4000c8c4: c2 27 bf e4 st %g1, [ %fp + -28 ]
{
4000c8c8: ba 10 00 18 mov %i0, %i5
while (!list_empty(&c->erase_complete_list) ||
4000c8cc: b4 06 20 a0 add %i0, 0xa0, %i2
pr_warn("Erase at 0x%08x failed immediately: errno %d\n",
4000c8d0: 23 10 00 83 sethi %hi(0x40020c00), %l1
pr_warn("Erase at 0x%08x failed immediately: -EROFS. Is the sector locked?\n",
4000c8d4: 25 10 00 83 sethi %hi(0x40020c00), %l2
for (i=0; i<readlen; i += sizeof(unsigned long)) {
/* It's OK. We know it's properly aligned */
unsigned long *datum = ebuf + i;
if (*datum + 1) {
*bad_offset += i;
pr_warn("Newly-erased block contained word 0x%lx at offset 0x%08x\n",
4000c8d8: 21 10 00 82 sethi %hi(0x40020800), %l0
pr_warn("Short read from newly-erased block at 0x%08x. Wanted %d, got %zd\n",
4000c8dc: 29 10 00 82 sethi %hi(0x40020800), %l4
int work_done = 0;
4000c8e0: b0 10 20 00 clr %i0
pr_warn("Erase at 0x%08x failed immediately: errno %d\n",
4000c8e4: a2 14 60 98 or %l1, 0x98, %l1
pr_warn("Erase at 0x%08x failed immediately: -EROFS. Is the sector locked?\n",
4000c8e8: a4 14 a0 48 or %l2, 0x48, %l2
pr_warn("Newly-erased block contained word 0x%lx at offset 0x%08x\n",
4000c8ec: a0 14 23 70 or %l0, 0x370, %l0
pr_warn("Short read from newly-erased block at 0x%08x. Wanted %d, got %zd\n",
4000c8f0: a8 15 23 20 or %l4, 0x320, %l4
return ( list->next == list );
4000c8f4: ea 07 60 a0 ld [ %i5 + 0xa0 ], %l5
while (!list_empty(&c->erase_complete_list) ||
4000c8f8: 80 a5 40 1a cmp %l5, %i2
4000c8fc: 02 80 00 77 be 4000cad8 <jffs2_erase_pending_blocks+0x220>
4000c900: 82 07 60 90 add %i5, 0x90, %g1
ent->prev->next = ent->next;
4000c904: c4 05 40 00 ld [ %l5 ], %g2
4000c908: c6 05 60 04 ld [ %l5 + 4 ], %g3
4000c90c: c4 20 c0 00 st %g2, [ %g3 ]
ent->next->prev = ent->prev;
4000c910: c6 20 a0 04 st %g3, [ %g2 + 4 ]
ebuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
4000c914: 11 00 00 04 sethi %hi(0x1000), %o0
struct list_head *next = afterthisent->next;
4000c918: c4 07 60 90 ld [ %i5 + 0x90 ], %g2
newent->next = next;
4000c91c: c4 25 40 00 st %g2, [ %l5 ]
newent->prev = afterthisent;
4000c920: c2 25 60 04 st %g1, [ %l5 + 4 ]
afterthisent->next = newent;
4000c924: ea 27 60 90 st %l5, [ %i5 + 0x90 ]
next->prev = newent;
4000c928: ea 20 a0 04 st %l5, [ %g2 + 4 ]
4000c92c: 40 00 09 e6 call 4000f0c4 <malloc>
4000c930: c0 27 bf f4 clr [ %fp + -12 ]
if (!ebuf) {
4000c934: b6 92 20 00 orcc %o0, 0, %i3
4000c938: 02 80 00 b4 be 4000cc08 <jffs2_erase_pending_blocks+0x350> <== NEVER TAKEN
4000c93c: ec 05 60 0c ld [ %l5 + 0xc ], %l6
for (ofs = jeb->offset; ofs < jeb->offset + c->sector_size; ) {
4000c940: f8 07 60 34 ld [ %i5 + 0x34 ], %i4
4000c944: b8 05 80 1c add %l6, %i4, %i4
4000c948: a6 07 bf f4 add %fp, -12, %l3
4000c94c: 80 a7 00 16 cmp %i4, %l6
4000c950: 08 80 00 3f bleu 4000ca4c <jffs2_erase_pending_blocks+0x194> <== NEVER TAKEN
4000c954: 2f 00 00 04 sethi %hi(0x1000), %l7
uint32_t readlen = min((uint32_t)PAGE_SIZE, jeb->offset + c->sector_size - ofs);
4000c958: b8 27 00 16 sub %i4, %l6, %i4
4000c95c: 80 a7 00 17 cmp %i4, %l7
4000c960: 38 80 00 02 bgu,a 4000c968 <jffs2_erase_pending_blocks+0xb0>
4000c964: b8 10 00 17 mov %l7, %i4
ret = jffs2_flash_read(c, ofs, readlen, &retlen, ebuf);
4000c968: 98 10 00 1b mov %i3, %o4
4000c96c: 96 10 00 13 mov %l3, %o3
4000c970: 94 10 00 1c mov %i4, %o2
4000c974: 92 10 00 16 mov %l6, %o1
4000c978: 40 00 01 32 call 4000ce40 <jffs2_flash_read>
4000c97c: 90 10 00 1d mov %i5, %o0
if (ret) {
4000c980: 80 a2 20 00 cmp %o0, 0
4000c984: 12 80 01 18 bne 4000cde4 <jffs2_erase_pending_blocks+0x52c> <== NEVER TAKEN
4000c988: d6 07 bf f4 ld [ %fp + -12 ], %o3
if (retlen != readlen) {
4000c98c: 80 a7 00 0b cmp %i4, %o3
4000c990: 12 80 01 1d bne 4000ce04 <jffs2_erase_pending_blocks+0x54c> <== NEVER TAKEN
4000c994: 94 10 20 00 clr %o2
if (*datum + 1) {
4000c998: 10 80 00 06 b 4000c9b0 <jffs2_erase_pending_blocks+0xf8>
4000c99c: d2 06 c0 0a ld [ %i3 + %o2 ], %o1
for (i=0; i<readlen; i += sizeof(unsigned long)) {
4000c9a0: 80 a7 00 0a cmp %i4, %o2
4000c9a4: 28 80 00 24 bleu,a 4000ca34 <jffs2_erase_pending_blocks+0x17c>
4000c9a8: d4 05 60 0c ld [ %l5 + 0xc ], %o2
if (*datum + 1) {
4000c9ac: d2 06 c0 0a ld [ %i3 + %o2 ], %o1
4000c9b0: 80 a2 7f ff cmp %o1, -1
4000c9b4: 22 bf ff fb be,a 4000c9a0 <jffs2_erase_pending_blocks+0xe8> <== ALWAYS TAKEN
4000c9b8: 94 02 a0 04 add %o2, 4, %o2
pr_warn("Newly-erased block contained word 0x%lx at offset 0x%08x\n",
4000c9bc: 94 05 80 0a add %l6, %o2, %o2
4000c9c0: 7f ff ff 5f call 4000c73c <jffs2_printk>
4000c9c4: 90 10 00 10 mov %l0, %o0
ofs += readlen;
cond_resched();
}
ret = 0;
fail:
kfree(ebuf);
4000c9c8: 40 00 08 db call 4000ed34 <free>
4000c9cc: 90 10 00 1b mov %i3, %o0
c->erasing_size -= c->sector_size;
4000c9d0: f8 07 60 34 ld [ %i5 + 0x34 ], %i4
4000c9d4: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
c->bad_size += c->sector_size;
4000c9d8: c4 07 60 30 ld [ %i5 + 0x30 ], %g2
ent->prev->next = ent->next;
4000c9dc: c8 05 60 04 ld [ %l5 + 4 ], %g4
4000c9e0: c6 05 40 00 ld [ %l5 ], %g3
c->erasing_size -= c->sector_size;
4000c9e4: 82 20 40 1c sub %g1, %i4, %g1
c->bad_size += c->sector_size;
4000c9e8: 84 00 80 1c add %g2, %i4, %g2
c->erasing_size -= c->sector_size;
4000c9ec: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
list_move(&jeb->list, &c->bad_list);
4000c9f0: 82 07 60 b0 add %i5, 0xb0, %g1
c->bad_size += c->sector_size;
4000c9f4: c4 27 60 30 st %g2, [ %i5 + 0x30 ]
4000c9f8: c6 21 00 00 st %g3, [ %g4 ]
ent->next->prev = ent->prev;
4000c9fc: c8 20 e0 04 st %g4, [ %g3 + 4 ]
struct list_head *next = afterthisent->next;
4000ca00: c4 07 60 b0 ld [ %i5 + 0xb0 ], %g2
newent->next = next;
4000ca04: c4 25 40 00 st %g2, [ %l5 ]
newent->prev = afterthisent;
4000ca08: c2 25 60 04 st %g1, [ %l5 + 4 ]
afterthisent->next = newent;
4000ca0c: ea 27 60 b0 st %l5, [ %i5 + 0xb0 ]
c->nr_erasing_blocks--;
4000ca10: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
next->prev = newent;
4000ca14: ea 20 a0 04 st %l5, [ %g2 + 4 ]
4000ca18: 82 00 7f ff add %g1, -1, %g1
4000ca1c: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
if (!--count) {
4000ca20: b2 86 7f ff addcc %i1, -1, %i1
4000ca24: 12 bf ff b4 bne 4000c8f4 <jffs2_erase_pending_blocks+0x3c>
4000ca28: b0 06 20 01 inc %i0
4000ca2c: 81 c7 e0 08 ret
4000ca30: 81 e8 00 00 restore
for (ofs = jeb->offset; ofs < jeb->offset + c->sector_size; ) {
4000ca34: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
ofs += readlen;
4000ca38: ac 05 80 1c add %l6, %i4, %l6
for (ofs = jeb->offset; ofs < jeb->offset + c->sector_size; ) {
4000ca3c: b8 02 80 01 add %o2, %g1, %i4
4000ca40: 80 a7 00 16 cmp %i4, %l6
4000ca44: 38 bf ff c6 bgu,a 4000c95c <jffs2_erase_pending_blocks+0xa4>
4000ca48: b8 27 00 16 sub %i4, %l6, %i4
kfree(ebuf);
4000ca4c: 40 00 08 ba call 4000ed34 <free>
4000ca50: 90 10 00 1b mov %i3, %o0
/* Write the erase complete marker */
jffs2_dbg(1, "Writing erased marker to block at 0x%08x\n", jeb->offset);
bad_offset = jeb->offset;
/* Cleanmarker in oob area or no cleanmarker at all ? */
if (jffs2_cleanmarker_oob(c) || c->cleanmarker_size == 0) {
4000ca54: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000ca58: 80 a0 60 00 cmp %g1, 0
4000ca5c: 32 80 00 a8 bne,a 4000ccfc <jffs2_erase_pending_blocks+0x444> <== ALWAYS TAKEN
4000ca60: c2 27 bf f8 st %g1, [ %fp + -8 ]
goto filebad;
}
}
/* Everything else got zeroed before the erase */
jeb->free_size = c->sector_size;
4000ca64: c6 07 60 34 ld [ %i5 + 0x34 ], %g3 <== NOT EXECUTED
4000ca68: c6 25 60 20 st %g3, [ %l5 + 0x20 ] <== NOT EXECUTED
mutex_lock(&c->erase_free_sem);
spin_lock(&c->erase_completion_lock);
c->erasing_size -= c->sector_size;
4000ca6c: c4 07 60 2c ld [ %i5 + 0x2c ], %g2 <== NOT EXECUTED
c->free_size += c->sector_size;
4000ca70: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
c->erasing_size -= c->sector_size;
4000ca74: 84 20 80 03 sub %g2, %g3, %g2 <== NOT EXECUTED
c->free_size += c->sector_size;
4000ca78: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
c->erasing_size -= c->sector_size;
4000ca7c: c4 27 60 2c st %g2, [ %i5 + 0x2c ] <== NOT EXECUTED
c->free_size += c->sector_size;
4000ca80: c2 27 60 28 st %g1, [ %i5 + 0x28 ] <== NOT EXECUTED
/* 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);
4000ca84: 82 07 60 a8 add %i5, 0xa8, %g1 <== NOT EXECUTED
ent->prev->next = ent->next;
4000ca88: c4 05 40 00 ld [ %l5 ], %g2
4000ca8c: c6 05 60 04 ld [ %l5 + 4 ], %g3
4000ca90: c4 20 c0 00 st %g2, [ %g3 ]
c->nr_erasing_blocks--;
c->nr_free_blocks++;
jffs2_dbg_acct_sanity_check_nolock(c, jeb);
4000ca94: 92 10 00 15 mov %l5, %o1
ent->next->prev = ent->prev;
4000ca98: c6 20 a0 04 st %g3, [ %g2 + 4 ]
4000ca9c: 90 10 00 1d mov %i5, %o0
struct list_head *prev = beforethisent->prev;
4000caa0: c4 07 60 ac ld [ %i5 + 0xac ], %g2
newent->prev = prev;
4000caa4: c4 25 60 04 st %g2, [ %l5 + 4 ]
newent->next = beforethisent;
4000caa8: c2 25 40 00 st %g1, [ %l5 ]
beforethisent->prev = newent;
4000caac: ea 27 60 ac st %l5, [ %i5 + 0xac ]
prev->next = newent;
4000cab0: ea 20 80 00 st %l5, [ %g2 ]
c->nr_free_blocks++;
4000cab4: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
c->nr_erasing_blocks--;
4000cab8: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
4000cabc: 84 00 bf ff add %g2, -1, %g2
c->nr_free_blocks++;
4000cac0: 82 00 60 01 inc %g1
c->nr_erasing_blocks--;
4000cac4: c4 27 60 40 st %g2, [ %i5 + 0x40 ]
jffs2_dbg_acct_sanity_check_nolock(c, jeb);
4000cac8: 7f ff fc 84 call 4000bcd8 <__jffs2_dbg_acct_sanity_check_nolock>
4000cacc: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
if (!--count) {
4000cad0: 10 bf ff d5 b 4000ca24 <jffs2_erase_pending_blocks+0x16c>
4000cad4: b2 86 7f ff addcc %i1, -1, %i1
return ( list->next == list );
4000cad8: f8 07 60 98 ld [ %i5 + 0x98 ], %i4
!list_empty(&c->erase_pending_list)) {
4000cadc: b6 07 60 98 add %i5, 0x98, %i3
while (!list_empty(&c->erase_complete_list) ||
4000cae0: 80 a6 c0 1c cmp %i3, %i4
4000cae4: 02 bf ff d2 be 4000ca2c <jffs2_erase_pending_blocks+0x174>
4000cae8: 92 10 00 1c mov %i4, %o1
ent->prev->next = ent->next;
4000caec: c4 07 20 04 ld [ %i4 + 4 ], %g2
4000caf0: c2 07 00 00 ld [ %i4 ], %g1
4000caf4: c2 20 80 00 st %g1, [ %g2 ]
ent->next->prev = ent->prev;
4000caf8: c4 20 60 04 st %g2, [ %g1 + 4 ]
jffs2_free_jeb_node_refs(c, jeb);
4000cafc: 90 10 00 1d mov %i5, %o0
c->wasted_size -= jeb->wasted_size;
4000cb00: d4 07 20 1c ld [ %i4 + 0x1c ], %o2
c->free_size -= jeb->free_size;
4000cb04: d6 07 20 20 ld [ %i4 + 0x20 ], %o3
c->used_size -= jeb->used_size;
4000cb08: d8 07 20 14 ld [ %i4 + 0x14 ], %o4
c->dirty_size -= jeb->dirty_size;
4000cb0c: da 07 20 18 ld [ %i4 + 0x18 ], %o5
c->erasing_size += c->sector_size;
4000cb10: de 07 60 2c ld [ %i5 + 0x2c ], %o7
c->wasted_size -= jeb->wasted_size;
4000cb14: c8 07 60 24 ld [ %i5 + 0x24 ], %g4
c->free_size -= jeb->free_size;
4000cb18: c6 07 60 28 ld [ %i5 + 0x28 ], %g3
c->used_size -= jeb->used_size;
4000cb1c: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
c->dirty_size -= jeb->dirty_size;
4000cb20: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
c->erasing_size += c->sector_size;
4000cb24: ea 07 60 34 ld [ %i5 + 0x34 ], %l5
c->used_size -= jeb->used_size;
4000cb28: 84 20 80 0c sub %g2, %o4, %g2
c->dirty_size -= jeb->dirty_size;
4000cb2c: 82 20 40 0d sub %g1, %o5, %g1
c->used_size -= jeb->used_size;
4000cb30: c4 27 60 1c st %g2, [ %i5 + 0x1c ]
c->erasing_size += c->sector_size;
4000cb34: 9e 03 c0 15 add %o7, %l5, %o7
c->dirty_size -= jeb->dirty_size;
4000cb38: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
c->wasted_size -= jeb->wasted_size;
4000cb3c: 88 21 00 0a sub %g4, %o2, %g4
c->erasing_size += c->sector_size;
4000cb40: de 27 60 2c st %o7, [ %i5 + 0x2c ]
c->free_size -= jeb->free_size;
4000cb44: 86 20 c0 0b sub %g3, %o3, %g3
c->wasted_size -= jeb->wasted_size;
4000cb48: c8 27 60 24 st %g4, [ %i5 + 0x24 ]
c->free_size -= jeb->free_size;
4000cb4c: c6 27 60 28 st %g3, [ %i5 + 0x28 ]
jeb->wasted_size = jeb->used_size = jeb->dirty_size = jeb->free_size = 0;
4000cb50: c0 27 20 20 clr [ %i4 + 0x20 ]
4000cb54: c0 27 20 18 clr [ %i4 + 0x18 ]
4000cb58: c0 27 20 14 clr [ %i4 + 0x14 ]
jffs2_free_jeb_node_refs(c, jeb);
4000cb5c: 7f ff ff 04 call 4000c76c <jffs2_free_jeb_node_refs>
4000cb60: c0 27 20 1c clr [ %i4 + 0x1c ]
struct list_head *next = afterthisent->next;
4000cb64: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
newent->next = next;
4000cb68: c2 27 00 00 st %g1, [ %i4 ]
list_add(&jeb->list, &c->erasing_list);
4000cb6c: 84 07 60 88 add %i5, 0x88, %g2
newent->prev = afterthisent;
4000cb70: c4 27 20 04 st %g2, [ %i4 + 4 ]
ret = jffs2_flash_erase(c, jeb);
4000cb74: 92 10 00 1c mov %i4, %o1
afterthisent->next = newent;
4000cb78: f8 27 60 88 st %i4, [ %i5 + 0x88 ]
4000cb7c: 90 10 00 1d mov %i5, %o0
4000cb80: 40 00 01 4a call 4000d0a8 <jffs2_flash_erase>
4000cb84: f8 20 60 04 st %i4, [ %g1 + 4 ]
if (!ret) {
4000cb88: 80 a2 20 00 cmp %o0, 0
4000cb8c: 02 80 00 46 be 4000cca4 <jffs2_erase_pending_blocks+0x3ec> <== ALWAYS TAKEN
4000cb90: 82 02 20 0c add %o0, 0xc, %g1
if (ret == -ENOMEM || ret == -EAGAIN) {
4000cb94: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
4000cb98: 08 80 00 31 bleu 4000cc5c <jffs2_erase_pending_blocks+0x3a4> <== NOT EXECUTED
4000cb9c: 80 a2 3f e2 cmp %o0, -30 <== NOT EXECUTED
if (ret == -EROFS)
4000cba0: 02 80 00 53 be 4000ccec <jffs2_erase_pending_blocks+0x434> <== NOT EXECUTED
4000cba4: d2 07 20 0c ld [ %i4 + 0xc ], %o1 <== NOT EXECUTED
pr_warn("Erase at 0x%08x failed immediately: errno %d\n",
4000cba8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4000cbac: 7f ff fe e4 call 4000c73c <jffs2_printk> <== NOT EXECUTED
4000cbb0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
c->erasing_size -= c->sector_size;
4000cbb4: f6 07 60 34 ld [ %i5 + 0x34 ], %i3 <== NOT EXECUTED
4000cbb8: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
c->bad_size += c->sector_size;
4000cbbc: c4 07 60 30 ld [ %i5 + 0x30 ], %g2 <== NOT EXECUTED
ent->prev->next = ent->next;
4000cbc0: c8 07 20 04 ld [ %i4 + 4 ], %g4 <== NOT EXECUTED
4000cbc4: c6 07 00 00 ld [ %i4 ], %g3 <== NOT EXECUTED
c->erasing_size -= c->sector_size;
4000cbc8: 82 20 40 1b sub %g1, %i3, %g1 <== NOT EXECUTED
c->bad_size += c->sector_size;
4000cbcc: 84 00 80 1b add %g2, %i3, %g2 <== NOT EXECUTED
c->erasing_size -= c->sector_size;
4000cbd0: c2 27 60 2c st %g1, [ %i5 + 0x2c ] <== NOT EXECUTED
list_move(&jeb->list, &c->bad_list);
4000cbd4: 82 07 60 b0 add %i5, 0xb0, %g1 <== NOT EXECUTED
c->bad_size += c->sector_size;
4000cbd8: c4 27 60 30 st %g2, [ %i5 + 0x30 ] <== NOT EXECUTED
4000cbdc: c6 21 00 00 st %g3, [ %g4 ] <== NOT EXECUTED
ent->next->prev = ent->prev;
4000cbe0: c8 20 e0 04 st %g4, [ %g3 + 4 ] <== NOT EXECUTED
struct list_head *next = afterthisent->next;
4000cbe4: c4 07 60 b0 ld [ %i5 + 0xb0 ], %g2 <== NOT EXECUTED
newent->next = next;
4000cbe8: c4 27 00 00 st %g2, [ %i4 ] <== NOT EXECUTED
newent->prev = afterthisent;
4000cbec: c2 27 20 04 st %g1, [ %i4 + 4 ] <== NOT EXECUTED
afterthisent->next = newent;
4000cbf0: f8 27 60 b0 st %i4, [ %i5 + 0xb0 ] <== NOT EXECUTED
c->nr_erasing_blocks--;
4000cbf4: c2 07 60 40 ld [ %i5 + 0x40 ], %g1 <== NOT EXECUTED
next->prev = newent;
4000cbf8: f8 20 a0 04 st %i4, [ %g2 + 4 ] <== NOT EXECUTED
4000cbfc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
4000cc00: 10 bf ff 3d b 4000c8f4 <jffs2_erase_pending_blocks+0x3c> <== NOT EXECUTED
4000cc04: c2 27 60 40 st %g1, [ %i5 + 0x40 ] <== NOT EXECUTED
pr_warn("Failed to allocate page buffer for verifying erase at 0x%08x. Refiling\n",
4000cc08: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
4000cc0c: 11 10 00 82 sethi %hi(0x40020800), %o0 <== NOT EXECUTED
4000cc10: 7f ff fe cb call 4000c73c <jffs2_printk> <== NOT EXECUTED
4000cc14: 90 12 22 78 or %o0, 0x278, %o0 ! 40020a78 <__func__.0+0x130> <== NOT EXECUTED
rtems_jffs2_flash_control *fc = sb->s_flash_control;
4000cc18: d0 07 60 e4 ld [ %i5 + 0xe4 ], %o0 <== NOT EXECUTED
if (fc->trigger_garbage_collection != NULL) {
4000cc1c: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 <== NOT EXECUTED
4000cc20: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000cc24: 22 80 00 05 be,a 4000cc38 <jffs2_erase_pending_blocks+0x380> <== NOT EXECUTED
4000cc28: c2 05 40 00 ld [ %l5 ], %g1 <== NOT EXECUTED
(*fc->trigger_garbage_collection)(fc);
4000cc2c: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000cc30: 01 00 00 00 nop <== NOT EXECUTED
ent->prev->next = ent->next;
4000cc34: c2 05 40 00 ld [ %l5 ], %g1 <== NOT EXECUTED
4000cc38: c4 05 60 04 ld [ %l5 + 4 ], %g2 <== NOT EXECUTED
4000cc3c: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
ent->next->prev = ent->prev;
4000cc40: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
struct list_head *next = afterthisent->next;
4000cc44: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 <== NOT EXECUTED
newent->next = next;
4000cc48: c2 25 40 00 st %g1, [ %l5 ] <== NOT EXECUTED
newent->prev = afterthisent;
4000cc4c: f4 25 60 04 st %i2, [ %l5 + 4 ] <== NOT EXECUTED
afterthisent->next = newent;
4000cc50: ea 27 60 a0 st %l5, [ %i5 + 0xa0 ] <== NOT EXECUTED
next->prev = newent;
4000cc54: 10 bf ff 73 b 4000ca20 <jffs2_erase_pending_blocks+0x168> <== NOT EXECUTED
4000cc58: ea 20 60 04 st %l5, [ %g1 + 4 ] <== NOT EXECUTED
ent->prev->next = ent->next;
4000cc5c: c4 07 20 04 ld [ %i4 + 4 ], %g2 <== NOT EXECUTED
4000cc60: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED
4000cc64: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
ent->next->prev = ent->prev;
4000cc68: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
struct list_head *next = afterthisent->next;
4000cc6c: c2 07 60 98 ld [ %i5 + 0x98 ], %g1 <== NOT EXECUTED
newent->next = next;
4000cc70: c2 27 00 00 st %g1, [ %i4 ] <== NOT EXECUTED
newent->prev = afterthisent;
4000cc74: f6 27 20 04 st %i3, [ %i4 + 4 ] <== NOT EXECUTED
afterthisent->next = newent;
4000cc78: f8 27 60 98 st %i4, [ %i5 + 0x98 ] <== NOT EXECUTED
next->prev = newent;
4000cc7c: f8 20 60 04 st %i4, [ %g1 + 4 ] <== NOT EXECUTED
c->erasing_size -= c->sector_size;
4000cc80: c6 07 60 2c ld [ %i5 + 0x2c ], %g3 <== NOT EXECUTED
4000cc84: c2 07 60 34 ld [ %i5 + 0x34 ], %g1 <== NOT EXECUTED
c->dirty_size += c->sector_size;
4000cc88: c4 07 60 20 ld [ %i5 + 0x20 ], %g2 <== NOT EXECUTED
c->erasing_size -= c->sector_size;
4000cc8c: 86 20 c0 01 sub %g3, %g1, %g3 <== NOT EXECUTED
c->dirty_size += c->sector_size;
4000cc90: 84 00 80 01 add %g2, %g1, %g2 <== NOT EXECUTED
c->erasing_size -= c->sector_size;
4000cc94: c6 27 60 2c st %g3, [ %i5 + 0x2c ] <== NOT EXECUTED
c->dirty_size += c->sector_size;
4000cc98: c4 27 60 20 st %g2, [ %i5 + 0x20 ] <== NOT EXECUTED
return;
4000cc9c: 10 bf ff 16 b 4000c8f4 <jffs2_erase_pending_blocks+0x3c> <== NOT EXECUTED
4000cca0: c2 27 20 18 st %g1, [ %i4 + 0x18 ] <== NOT EXECUTED
ent->prev->next = ent->next;
4000cca4: c2 07 00 00 ld [ %i4 ], %g1
4000cca8: c4 07 20 04 ld [ %i4 + 4 ], %g2
4000ccac: c2 20 80 00 st %g1, [ %g2 ]
ent->next->prev = ent->prev;
4000ccb0: c4 20 60 04 st %g2, [ %g1 + 4 ]
struct list_head *prev = beforethisent->prev;
4000ccb4: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1
newent->prev = prev;
4000ccb8: c2 27 20 04 st %g1, [ %i4 + 4 ]
newent->next = beforethisent;
4000ccbc: f4 27 00 00 st %i2, [ %i4 ]
beforethisent->prev = newent;
4000ccc0: f8 27 60 a4 st %i4, [ %i5 + 0xa4 ]
rtems_jffs2_flash_control *fc = sb->s_flash_control;
4000ccc4: d0 07 60 e4 ld [ %i5 + 0xe4 ], %o0
prev->next = newent;
4000ccc8: f8 20 40 00 st %i4, [ %g1 ]
if (fc->trigger_garbage_collection != NULL) {
4000cccc: c2 02 20 20 ld [ %o0 + 0x20 ], %g1
4000ccd0: 80 a0 60 00 cmp %g1, 0
4000ccd4: 22 bf ff 09 be,a 4000c8f8 <jffs2_erase_pending_blocks+0x40> <== ALWAYS TAKEN
4000ccd8: ea 07 60 a0 ld [ %i5 + 0xa0 ], %l5
(*fc->trigger_garbage_collection)(fc);
4000ccdc: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000cce0: 01 00 00 00 nop <== NOT EXECUTED
return ( list->next == list );
4000cce4: 10 bf ff 05 b 4000c8f8 <jffs2_erase_pending_blocks+0x40> <== NOT EXECUTED
4000cce8: ea 07 60 a0 ld [ %i5 + 0xa0 ], %l5 <== NOT EXECUTED
pr_warn("Erase at 0x%08x failed immediately: -EROFS. Is the sector locked?\n",
4000ccec: 7f ff fe 94 call 4000c73c <jffs2_printk> <== NOT EXECUTED
4000ccf0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
4000ccf4: 10 bf ff b1 b 4000cbb8 <jffs2_erase_pending_blocks+0x300> <== NOT EXECUTED
4000ccf8: f6 07 60 34 ld [ %i5 + 0x34 ], %i3 <== NOT EXECUTED
struct jffs2_unknown_node marker = {
4000ccfc: 03 00 00 06 sethi %hi(0x1800), %g1
4000cd00: 82 10 61 85 or %g1, 0x185, %g1 ! 1985 <_ISR_Stack_size+0x985>
4000cd04: c2 37 bf f4 sth %g1, [ %fp + -12 ]
4000cd08: 03 00 00 08 sethi %hi(0x2000), %g1
4000cd0c: 82 10 60 03 or %g1, 3, %g1 ! 2003 <_ISR_Stack_size+0x1003>
jffs2_prealloc_raw_node_refs(c, jeb, 1);
4000cd10: 94 10 20 01 mov 1, %o2
struct jffs2_unknown_node marker = {
4000cd14: c2 37 bf f6 sth %g1, [ %fp + -10 ]
jffs2_prealloc_raw_node_refs(c, jeb, 1);
4000cd18: 92 10 00 15 mov %l5, %o1
struct jffs2_unknown_node marker = {
4000cd1c: c0 27 bf fc clr [ %fp + -4 ]
jffs2_prealloc_raw_node_refs(c, jeb, 1);
4000cd20: 7f ff e3 ba call 40005c08 <jffs2_prealloc_raw_node_refs>
4000cd24: 90 10 00 1d mov %i5, %o0
marker.hdr_crc = cpu_to_je32(crc32(0, &marker, sizeof(struct jffs2_unknown_node)-4));
4000cd28: a6 07 bf f4 add %fp, -12, %l3
4000cd2c: 94 10 20 08 mov 8, %o2
4000cd30: 92 10 00 13 mov %l3, %o1
4000cd34: 7f ff fb 91 call 4000bb78 <cyg_crc32_accumulate>
4000cd38: 90 10 20 00 clr %o0
ret = jffs2_flash_direct_writev(c, vecs, 1, jeb->offset, &retlen);
4000cd3c: d8 05 60 0c ld [ %l5 + 0xc ], %o4
vecs[0].iov_len = sizeof(marker);
4000cd40: 82 10 20 0c mov 0xc, %g1
marker.hdr_crc = cpu_to_je32(crc32(0, &marker, sizeof(struct jffs2_unknown_node)-4));
4000cd44: d0 27 bf fc st %o0, [ %fp + -4 ]
ret = jffs2_flash_direct_writev(c, vecs, 1, jeb->offset, &retlen);
4000cd48: 9a 07 bf e8 add %fp, -24, %o5
vecs[0].iov_base = (unsigned char *) ▮
4000cd4c: e6 27 bf ec st %l3, [ %fp + -20 ]
ret = jffs2_flash_direct_writev(c, vecs, 1, jeb->offset, &retlen);
4000cd50: 96 10 20 00 clr %o3
vecs[0].iov_len = sizeof(marker);
4000cd54: c2 27 bf f0 st %g1, [ %fp + -16 ]
ret = jffs2_flash_direct_writev(c, vecs, 1, jeb->offset, &retlen);
4000cd58: 94 10 20 01 mov 1, %o2
4000cd5c: 92 07 bf ec add %fp, -20, %o1
4000cd60: 40 00 00 4c call 4000ce90 <jffs2_flash_direct_writev>
4000cd64: 90 10 00 1d mov %i5, %o0
if (ret || retlen != sizeof(marker)) {
4000cd68: 80 a2 20 00 cmp %o0, 0
4000cd6c: 12 80 00 2e bne 4000ce24 <jffs2_erase_pending_blocks+0x56c> <== NEVER TAKEN
4000cd70: d6 07 bf e8 ld [ %fp + -24 ], %o3
4000cd74: 80 a2 e0 0c cmp %o3, 0xc
4000cd78: 22 80 00 09 be,a 4000cd9c <jffs2_erase_pending_blocks+0x4e4> <== ALWAYS TAKEN
4000cd7c: c6 07 60 34 ld [ %i5 + 0x34 ], %g3
pr_warn("Short write to newly-erased block at 0x%08x: Wanted %zd, got %zd\n",
4000cd80: d2 05 60 0c ld [ %l5 + 0xc ], %o1 <== NOT EXECUTED
4000cd84: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
4000cd88: 11 10 00 82 sethi %hi(0x40020800), %o0 <== NOT EXECUTED
4000cd8c: 7f ff fe 6c call 4000c73c <jffs2_printk> <== NOT EXECUTED
4000cd90: 90 12 23 f8 or %o0, 0x3f8, %o0 ! 40020bf8 <__func__.0+0x2b0> <== NOT EXECUTED
c->erasing_size -= c->sector_size;
4000cd94: 10 bf ff 10 b 4000c9d4 <jffs2_erase_pending_blocks+0x11c> <== NOT EXECUTED
4000cd98: f8 07 60 34 ld [ %i5 + 0x34 ], %i4 <== NOT EXECUTED
c->erasing_size -= c->sector_size;
4000cd9c: c4 07 60 2c ld [ %i5 + 0x2c ], %g2
if (c->cleanmarker_size && !jffs2_cleanmarker_oob(c))
4000cda0: d6 07 60 14 ld [ %i5 + 0x14 ], %o3
c->free_size += c->sector_size;
4000cda4: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
jeb->free_size = c->sector_size;
4000cda8: c6 25 60 20 st %g3, [ %l5 + 0x20 ]
c->erasing_size -= c->sector_size;
4000cdac: 84 20 80 03 sub %g2, %g3, %g2
c->free_size += c->sector_size;
4000cdb0: 82 00 40 03 add %g1, %g3, %g1
c->erasing_size -= c->sector_size;
4000cdb4: c4 27 60 2c st %g2, [ %i5 + 0x2c ]
if (c->cleanmarker_size && !jffs2_cleanmarker_oob(c))
4000cdb8: 80 a2 e0 00 cmp %o3, 0
4000cdbc: 02 bf ff 32 be 4000ca84 <jffs2_erase_pending_blocks+0x1cc> <== NEVER TAKEN
4000cdc0: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
jffs2_link_node_ref(c, jeb, jeb->offset | REF_NORMAL, c->cleanmarker_size, NULL);
4000cdc4: d4 05 60 0c ld [ %l5 + 0xc ], %o2
4000cdc8: 98 10 20 00 clr %o4
4000cdcc: 94 12 a0 03 or %o2, 3, %o2
4000cdd0: 92 10 00 15 mov %l5, %o1
4000cdd4: 7f ff e6 de call 4000694c <jffs2_link_node_ref>
4000cdd8: 90 10 00 1d mov %i5, %o0
list_move_tail(&jeb->list, &c->free_list);
4000cddc: 10 bf ff 2b b 4000ca88 <jffs2_erase_pending_blocks+0x1d0>
4000cde0: 82 07 60 a8 add %i5, 0xa8, %g1
pr_warn("Read of newly-erased block at 0x%08x failed: %d. Putting on bad_list\n",
4000cde4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4000cde8: d0 07 bf e4 ld [ %fp + -28 ], %o0 <== NOT EXECUTED
4000cdec: 7f ff fe 54 call 4000c73c <jffs2_printk> <== NOT EXECUTED
4000cdf0: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
kfree(ebuf);
4000cdf4: 40 00 07 d0 call 4000ed34 <free> <== NOT EXECUTED
4000cdf8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
c->erasing_size -= c->sector_size;
4000cdfc: 10 bf fe f6 b 4000c9d4 <jffs2_erase_pending_blocks+0x11c> <== NOT EXECUTED
4000ce00: f8 07 60 34 ld [ %i5 + 0x34 ], %i4 <== NOT EXECUTED
pr_warn("Short read from newly-erased block at 0x%08x. Wanted %d, got %zd\n",
4000ce04: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4000ce08: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
4000ce0c: 7f ff fe 4c call 4000c73c <jffs2_printk> <== NOT EXECUTED
4000ce10: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
kfree(ebuf);
4000ce14: 40 00 07 c8 call 4000ed34 <free> <== NOT EXECUTED
4000ce18: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
c->erasing_size -= c->sector_size;
4000ce1c: 10 bf fe ee b 4000c9d4 <jffs2_erase_pending_blocks+0x11c> <== NOT EXECUTED
4000ce20: f8 07 60 34 ld [ %i5 + 0x34 ], %i4 <== NOT EXECUTED
pr_warn("Write clean marker to block at 0x%08x failed: %d\n",
4000ce24: d2 05 60 0c ld [ %l5 + 0xc ], %o1 <== NOT EXECUTED
4000ce28: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4000ce2c: 11 10 00 82 sethi %hi(0x40020800), %o0 <== NOT EXECUTED
4000ce30: 7f ff fe 43 call 4000c73c <jffs2_printk> <== NOT EXECUTED
4000ce34: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 40020bb8 <__func__.0+0x270> <== NOT EXECUTED
4000ce38: 10 bf fe e7 b 4000c9d4 <jffs2_erase_pending_blocks+0x11c> <== NOT EXECUTED
4000ce3c: f8 07 60 34 ld [ %i5 + 0x34 ], %i4 <== NOT EXECUTED
4000ce90 <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)
{
4000ce90: 9d e3 be a0 save %sp, -352, %sp
4000ce94: aa 10 00 18 mov %i0, %l5
4000ce98: a4 10 00 1b mov %i3, %l2
unsigned long i;
size_t totlen = 0, thislen;
int ret = 0;
for (i = 0; i < count; i++) {
4000ce9c: 80 a6 a0 00 cmp %i2, 0
4000cea0: 02 80 00 7d be 4000d094 <jffs2_flash_direct_writev+0x204> <== NEVER TAKEN
4000cea4: a6 10 00 1c mov %i4, %l3
4000cea8: ac 06 60 04 add %i1, 4, %l6
size_t totlen = 0, thislen;
4000ceac: a8 10 20 00 clr %l4
4000ceb0: b6 10 00 16 mov %l6, %i3
for (i = 0; i < count; i++) {
4000ceb4: 10 80 00 18 b 4000cf14 <jffs2_flash_direct_writev+0x84>
4000ceb8: a0 10 20 00 clr %l0
// 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))) ||
4000cebc: 80 8a a0 03 btst 3, %o2
4000cec0: 12 80 00 1a bne 4000cf28 <jffs2_flash_direct_writev+0x98>
4000cec4: 82 04 20 01 add %l0, 1, %g1
rtems_jffs2_flash_control *fc = sb->s_flash_control;
4000cec8: d0 05 60 e4 ld [ %l5 + 0xe4 ], %o0
return (*fc->write)(fc, write_buffer_offset, read_buffer, size);
4000cecc: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4000ced0: 96 10 00 1c mov %i4, %o3
4000ced4: 9f c0 40 00 call %g1
4000ced8: 92 10 00 13 mov %l3, %o1
4000cedc: b0 10 00 08 mov %o0, %i0
} else
ret =
jffs2_flash_write(c, to, vecs[i].iov_len, &thislen,
vecs[i].iov_base);
totlen += thislen;
if (ret || thislen != vecs[i].iov_len)
4000cee0: 80 a6 20 00 cmp %i0, 0
4000cee4: 12 80 00 2d bne 4000cf98 <jffs2_flash_direct_writev+0x108> <== NEVER TAKEN
4000cee8: a8 05 00 1c add %l4, %i4, %l4
4000ceec: c2 06 c0 00 ld [ %i3 ], %g1
4000cef0: 80 a0 40 1c cmp %g1, %i4
4000cef4: 12 80 00 2a bne 4000cf9c <jffs2_flash_direct_writev+0x10c> <== NEVER TAKEN
4000cef8: 80 a7 60 00 cmp %i5, 0
break;
to += vecs[i].iov_len;
4000cefc: a6 84 c0 1c addcc %l3, %i4, %l3
for (i = 0; i < count; i++) {
4000cf00: a0 04 20 01 inc %l0
to += vecs[i].iov_len;
4000cf04: a4 44 a0 00 addx %l2, 0, %l2
for (i = 0; i < count; i++) {
4000cf08: 80 a6 80 10 cmp %i2, %l0
4000cf0c: 02 80 00 23 be 4000cf98 <jffs2_flash_direct_writev+0x108>
4000cf10: b6 06 e0 08 add %i3, 8, %i3
if (((vecs[i].iov_len & (sizeof (int) - 1))) ||
4000cf14: f8 06 c0 00 ld [ %i3 ], %i4
4000cf18: 80 8f 20 03 btst 3, %i4
4000cf1c: 22 bf ff e8 be,a 4000cebc <jffs2_flash_direct_writev+0x2c>
4000cf20: d4 06 ff fc ld [ %i3 + -4 ], %o2
if ((i + 1) < count || vecs[i].iov_len > 256) {
4000cf24: 82 04 20 01 add %l0, 1, %g1
4000cf28: 80 a0 40 1a cmp %g1, %i2
4000cf2c: 0a 80 00 23 bcs 4000cfb8 <jffs2_flash_direct_writev+0x128> <== NEVER TAKEN
4000cf30: 80 a7 21 00 cmp %i4, 0x100
4000cf34: 18 80 00 03 bgu 4000cf40 <jffs2_flash_direct_writev+0xb0>
4000cf38: 82 10 20 01 mov 1, %g1
4000cf3c: 82 10 20 00 clr %g1
4000cf40: 80 88 60 ff btst 0xff, %g1
4000cf44: 12 80 00 1d bne 4000cfb8 <jffs2_flash_direct_writev+0x128>
4000cf48: 90 07 bf 00 add %fp, -256, %o0
memcpy(buf, vecs[i].iov_base, lentowrite);
4000cf4c: d2 06 ff fc ld [ %i3 + -4 ], %o1
lentowrite += sizeof (int) - 1;
4000cf50: b8 07 20 03 add %i4, 3, %i4
lentowrite &= ~(sizeof (int) - 1);
4000cf54: a2 0f 3f fc and %i4, -4, %l1
memcpy(buf, vecs[i].iov_base, lentowrite);
4000cf58: 40 00 3f f4 call 4001cf28 <memcpy>
4000cf5c: 94 10 00 11 mov %l1, %o2
rtems_jffs2_flash_control *fc = sb->s_flash_control;
4000cf60: d0 05 60 e4 ld [ %l5 + 0xe4 ], %o0
return (*fc->write)(fc, write_buffer_offset, read_buffer, size);
4000cf64: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4000cf68: 96 10 00 11 mov %l1, %o3
4000cf6c: 94 07 bf 00 add %fp, -256, %o2
4000cf70: 9f c0 40 00 call %g1
4000cf74: 92 10 00 13 mov %l3, %o1
4000cf78: f8 06 c0 00 ld [ %i3 ], %i4
if (thislen > vecs[i].iov_len)
4000cf7c: 80 a7 00 11 cmp %i4, %l1
return (*fc->write)(fc, write_buffer_offset, read_buffer, size);
4000cf80: 08 bf ff d8 bleu 4000cee0 <jffs2_flash_direct_writev+0x50> <== ALWAYS TAKEN
4000cf84: b0 10 00 08 mov %o0, %i0
4000cf88: b8 10 00 11 mov %l1, %i4 <== NOT EXECUTED
if (ret || thislen != vecs[i].iov_len)
4000cf8c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
4000cf90: 02 bf ff d7 be 4000ceec <jffs2_flash_direct_writev+0x5c> <== NOT EXECUTED
4000cf94: a8 05 00 1c add %l4, %i4, %l4 <== NOT EXECUTED
}
writev_out:
if (retlen)
4000cf98: 80 a7 60 00 cmp %i5, 0
4000cf9c: 02 80 00 05 be 4000cfb0 <jffs2_flash_direct_writev+0x120> <== NEVER TAKEN
4000cfa0: 01 00 00 00 nop
*retlen = totlen;
4000cfa4: e8 27 40 00 st %l4, [ %i5 ]
return ret;
4000cfa8: 81 c7 e0 08 ret
4000cfac: 81 e8 00 00 restore
}
4000cfb0: 81 c7 e0 08 ret <== NOT EXECUTED
4000cfb4: 81 e8 00 00 restore <== NOT EXECUTED
for (j = i; j < count; j++)
4000cfb8: 80 a6 80 10 cmp %i2, %l0
4000cfbc: 08 80 00 2f bleu 4000d078 <jffs2_flash_direct_writev+0x1e8> <== NEVER TAKEN
4000cfc0: 84 10 00 1c mov %i4, %g2
4000cfc4: 82 10 00 10 mov %l0, %g1
4000cfc8: 10 80 00 04 b 4000cfd8 <jffs2_flash_direct_writev+0x148>
4000cfcc: a2 10 20 00 clr %l1
totvecsize += vecs[j].iov_len;
4000cfd0: 85 28 60 03 sll %g1, 3, %g2 <== NOT EXECUTED
4000cfd4: c4 05 80 02 ld [ %l6 + %g2 ], %g2 <== NOT EXECUTED
for (j = i; j < count; j++)
4000cfd8: 82 00 60 01 inc %g1
4000cfdc: 80 a6 80 01 cmp %i2, %g1
4000cfe0: 12 bf ff fc bne 4000cfd0 <jffs2_flash_direct_writev+0x140> <== NEVER TAKEN
4000cfe4: a2 04 40 02 add %l1, %g2, %l1
sizetomalloc = totvecsize + sizeof (int) - 1;
4000cfe8: b0 04 60 03 add %l1, 3, %i0
sizetomalloc &= ~(sizeof (int) - 1);
4000cfec: b0 0e 3f fc and %i0, -4, %i0
cbuf = (char *) malloc(sizetomalloc);
4000cff0: 40 00 08 35 call 4000f0c4 <malloc>
4000cff4: 90 10 00 18 mov %i0, %o0
if (!cbuf) {
4000cff8: b6 92 20 00 orcc %o0, 0, %i3
4000cffc: 02 80 00 29 be 4000d0a0 <jffs2_flash_direct_writev+0x210> <== NEVER TAKEN
4000d000: 82 10 00 1b mov %i3, %g1
4000d004: a1 2c 20 03 sll %l0, 3, %l0
4000d008: b5 2e a0 03 sll %i2, 3, %i2
4000d00c: a0 06 40 10 add %i1, %l0, %l0
4000d010: 10 80 00 03 b 4000d01c <jffs2_flash_direct_writev+0x18c>
4000d014: b4 06 40 1a add %i1, %i2, %i2
memcpy(cbufptr, vecs[j].iov_base,
4000d018: f8 04 20 04 ld [ %l0 + 4 ], %i4 <== NOT EXECUTED
4000d01c: d2 04 00 00 ld [ %l0 ], %o1
4000d020: 90 10 00 01 mov %g1, %o0
4000d024: 40 00 3f c1 call 4001cf28 <memcpy>
4000d028: 94 10 00 1c mov %i4, %o2
for (j = i; j < count; j++) {
4000d02c: a0 04 20 08 add %l0, 8, %l0
4000d030: 80 a6 80 10 cmp %i2, %l0
4000d034: 12 bf ff f9 bne 4000d018 <jffs2_flash_direct_writev+0x188> <== NEVER TAKEN
4000d038: 82 02 00 1c add %o0, %i4, %g1
totlen += thislen;
4000d03c: 80 a4 40 18 cmp %l1, %i0
4000d040: 38 80 00 02 bgu,a 4000d048 <jffs2_flash_direct_writev+0x1b8> <== NEVER TAKEN
4000d044: a2 10 00 18 mov %i0, %l1 <== NOT EXECUTED
4000d048: a8 05 00 11 add %l4, %l1, %l4
rtems_jffs2_flash_control *fc = sb->s_flash_control;
4000d04c: d0 05 60 e4 ld [ %l5 + 0xe4 ], %o0
return (*fc->write)(fc, write_buffer_offset, read_buffer, size);
4000d050: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4000d054: 96 10 00 18 mov %i0, %o3
4000d058: 94 10 00 1b mov %i3, %o2
4000d05c: 9f c0 40 00 call %g1
4000d060: 92 10 00 13 mov %l3, %o1
4000d064: b0 10 00 08 mov %o0, %i0
free(cbuf);
4000d068: 40 00 07 33 call 4000ed34 <free>
4000d06c: 90 10 00 1b mov %i3, %o0
goto writev_out;
4000d070: 10 bf ff cb b 4000cf9c <jffs2_flash_direct_writev+0x10c>
4000d074: 80 a7 60 00 cmp %i5, 0
cbuf = (char *) malloc(sizetomalloc);
4000d078: 40 00 08 13 call 4000f0c4 <malloc> <== NOT EXECUTED
4000d07c: 90 10 20 00 clr %o0 <== NOT EXECUTED
if (!cbuf) {
4000d080: b6 92 20 00 orcc %o0, 0, %i3 <== NOT EXECUTED
4000d084: 22 bf ff c5 be,a 4000cf98 <jffs2_flash_direct_writev+0x108> <== NOT EXECUTED
4000d088: b0 10 3f f4 mov -12, %i0 <== NOT EXECUTED
cbuf = (char *) malloc(sizetomalloc);
4000d08c: 10 bf ff f0 b 4000d04c <jffs2_flash_direct_writev+0x1bc> <== NOT EXECUTED
4000d090: b0 10 20 00 clr %i0 <== NOT EXECUTED
size_t totlen = 0, thislen;
4000d094: a8 10 20 00 clr %l4 <== NOT EXECUTED
for (i = 0; i < count; i++) {
4000d098: 10 bf ff c0 b 4000cf98 <jffs2_flash_direct_writev+0x108> <== NOT EXECUTED
4000d09c: b0 10 20 00 clr %i0 <== NOT EXECUTED
ret = -ENOMEM;
4000d0a0: 10 bf ff be b 4000cf98 <jffs2_flash_direct_writev+0x108> <== NOT EXECUTED
4000d0a4: b0 10 3f f4 mov -12, %i0 <== NOT EXECUTED
40006744 <jffs2_free_ino_caches>:
{
40006744: 9d e3 bf a0 save %sp, -96, %sp
for (i=0; i < c->inocache_hashsize; i++) {
40006748: c6 06 20 c0 ld [ %i0 + 0xc0 ], %g3
4000674c: 80 a0 e0 00 cmp %g3, 0
40006750: 04 80 00 15 ble 400067a4 <jffs2_free_ino_caches+0x60> <== NEVER TAKEN
40006754: b8 10 20 00 clr %i4
this = c->inocache_list[i];
40006758: c2 06 20 c4 ld [ %i0 + 0xc4 ], %g1
4000675c: b7 2f 20 02 sll %i4, 2, %i3
40006760: fa 00 40 1b ld [ %g1 + %i3 ], %i5
while (this) {
40006764: 80 a7 60 00 cmp %i5, 0
40006768: 02 80 00 0b be 40006794 <jffs2_free_ino_caches+0x50>
4000676c: 84 00 40 1b add %g1, %i3, %g2
next = this->next;
40006770: 90 10 00 1d mov %i5, %o0
jffs2_free_inode_cache(this);
40006774: 7f ff fd 65 call 40005d08 <jffs2_free_inode_cache>
40006778: fa 07 60 10 ld [ %i5 + 0x10 ], %i5
while (this) {
4000677c: 80 a7 60 00 cmp %i5, 0
40006780: 12 bf ff fd bne 40006774 <jffs2_free_ino_caches+0x30> <== NEVER TAKEN
40006784: 90 10 00 1d mov %i5, %o0
c->inocache_list[i] = NULL;
40006788: c2 06 20 c4 ld [ %i0 + 0xc4 ], %g1
4000678c: c6 06 20 c0 ld [ %i0 + 0xc0 ], %g3
40006790: 84 00 40 1b add %g1, %i3, %g2
for (i=0; i < c->inocache_hashsize; i++) {
40006794: b8 07 20 01 inc %i4
40006798: 80 a0 c0 1c cmp %g3, %i4
4000679c: 14 bf ff f0 bg 4000675c <jffs2_free_ino_caches+0x18>
400067a0: c0 20 80 00 clr [ %g2 ]
}
400067a4: 81 c7 e0 08 ret
400067a8: 81 e8 00 00 restore
4000c76c <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)
{
4000c76c: 9d e3 bf a0 save %sp, -96, %sp
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;
4000c770: fa 06 60 28 ld [ %i1 + 0x28 ], %i5
while (ref) {
4000c774: 80 a7 60 00 cmp %i5, 0
4000c778: 22 80 00 3c be,a 4000c868 <jffs2_free_jeb_node_refs+0xfc>
4000c77c: c0 26 60 2c clr [ %i1 + 0x2c ]
JFFS2_WARNING("inode_cache/xattr_datum/xattr_ref"
4000c780: 21 10 00 83 sethi %hi(0x40020c00), %l0
4000c784: 35 10 00 82 sethi %hi(0x40020800), %i2
while (ref) {
4000c788: a2 10 00 1d mov %i5, %l1
JFFS2_WARNING("inode_cache/xattr_datum/xattr_ref"
4000c78c: a0 14 20 d0 or %l0, 0xd0, %l0
4000c790: b4 16 a2 18 or %i2, 0x218, %i2
if (ref->flash_offset == REF_LINK_NODE) {
4000c794: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000c798: 80 a0 7f ff cmp %g1, -1
4000c79c: 22 80 00 2d be,a 4000c850 <jffs2_free_jeb_node_refs+0xe4> <== NEVER TAKEN
4000c7a0: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
ref = ref->next_in_ino;
jffs2_free_refblock(block);
block = ref;
continue;
}
if (ref->flash_offset != REF_EMPTY_NODE && ref->next_in_ino)
4000c7a4: 80 a0 7f fe cmp %g1, -2
4000c7a8: 22 80 00 25 be,a 4000c83c <jffs2_free_jeb_node_refs+0xd0>
4000c7ac: ba 07 60 08 add %i5, 8, %i5
4000c7b0: c2 07 40 00 ld [ %i5 ], %g1
4000c7b4: 80 a0 60 00 cmp %g1, 0
4000c7b8: 02 80 00 20 be 4000c838 <jffs2_free_jeb_node_refs+0xcc> <== ALWAYS TAKEN
4000c7bc: 88 10 00 1d mov %i5, %g4
if (SECTOR_ADDR((*prev)->flash_offset) == jeb->offset) {
4000c7c0: f8 06 20 34 ld [ %i0 + 0x34 ], %i4 <== NOT EXECUTED
4000c7c4: f6 06 60 0c ld [ %i1 + 0xc ], %i3 <== NOT EXECUTED
4000c7c8: b8 20 00 1c neg %i4 <== NOT EXECUTED
struct jffs2_inode_cache *ic = NULL;
4000c7cc: 92 10 20 00 clr %o1 <== NOT EXECUTED
if (!(*prev)->next_in_ino) {
4000c7d0: c6 00 40 00 ld [ %g1 ], %g3 <== NOT EXECUTED
4000c7d4: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
4000c7d8: 22 80 00 0e be,a 4000c810 <jffs2_free_jeb_node_refs+0xa4> <== NOT EXECUTED
4000c7dc: 88 00 60 04 add %g1, 4, %g4 <== NOT EXECUTED
if (SECTOR_ADDR((*prev)->flash_offset) == jeb->offset) {
4000c7e0: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED
4000c7e4: 84 0f 00 02 and %i4, %g2, %g2 <== NOT EXECUTED
4000c7e8: 80 a0 80 1b cmp %g2, %i3 <== NOT EXECUTED
4000c7ec: 22 80 00 22 be,a 4000c874 <jffs2_free_jeb_node_refs+0x108> <== NOT EXECUTED
4000c7f0: c6 21 00 00 st %g3, [ %g4 ] <== NOT EXECUTED
prev = &((*prev)->next_in_ino);
4000c7f4: 88 10 00 01 mov %g1, %g4 <== NOT EXECUTED
4000c7f8: 82 10 00 03 mov %g3, %g1 <== NOT EXECUTED
if (!(*prev)->next_in_ino) {
4000c7fc: c6 00 40 00 ld [ %g1 ], %g3 <== NOT EXECUTED
4000c800: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
4000c804: 32 bf ff f8 bne,a 4000c7e4 <jffs2_free_jeb_node_refs+0x78> <== NOT EXECUTED
4000c808: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED
prev = &ic->nodes;
4000c80c: 88 00 60 04 add %g1, 4, %g4 <== NOT EXECUTED
continue;
4000c810: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED
4000c814: 10 bf ff ef b 4000c7d0 <jffs2_free_jeb_node_refs+0x64> <== NOT EXECUTED
4000c818: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
if (!ic) {
4000c81c: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
4000c820: 22 80 00 21 be,a 4000c8a4 <jffs2_free_jeb_node_refs+0x138> <== NOT EXECUTED
4000c824: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
if (ic->nodes == (void *)ic && ic->pino_nlink == 0)
4000c828: c2 02 60 04 ld [ %o1 + 4 ], %g1 <== NOT EXECUTED
4000c82c: 80 a0 40 09 cmp %g1, %o1 <== NOT EXECUTED
4000c830: 22 80 00 16 be,a 4000c888 <jffs2_free_jeb_node_refs+0x11c> <== NOT EXECUTED
4000c834: c2 02 60 14 ld [ %o1 + 0x14 ], %g1 <== 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++;
4000c838: ba 07 60 08 add %i5, 8, %i5
if (ref->flash_offset == REF_LINK_NODE) {
4000c83c: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000c840: 80 a0 7f ff cmp %g1, -1
4000c844: 12 bf ff d9 bne 4000c7a8 <jffs2_free_jeb_node_refs+0x3c>
4000c848: 80 a0 7f fe cmp %g1, -2
ref = ref->next_in_ino;
4000c84c: fa 07 40 00 ld [ %i5 ], %i5
jffs2_free_refblock(block);
4000c850: 7f ff e5 20 call 40005cd0 <jffs2_free_refblock>
4000c854: 90 10 00 11 mov %l1, %o0
while (ref) {
4000c858: 80 a7 60 00 cmp %i5, 0
4000c85c: 32 bf ff ce bne,a 4000c794 <jffs2_free_jeb_node_refs+0x28>
4000c860: a2 10 00 1d mov %i5, %l1
}
jeb->first_node = jeb->last_node = NULL;
4000c864: c0 26 60 2c clr [ %i1 + 0x2c ]
4000c868: c0 26 60 28 clr [ %i1 + 0x28 ]
}
4000c86c: 81 c7 e0 08 ret
4000c870: 81 e8 00 00 restore
if (this == ref)
4000c874: 80 a0 40 1d cmp %g1, %i5 <== NOT EXECUTED
4000c878: 02 bf ff e9 be 4000c81c <jffs2_free_jeb_node_refs+0xb0> <== NOT EXECUTED
4000c87c: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED
if (!(*prev)->next_in_ino) {
4000c880: 10 bf ff d4 b 4000c7d0 <jffs2_free_jeb_node_refs+0x64> <== NOT EXECUTED
4000c884: c2 01 00 00 ld [ %g4 ], %g1 <== NOT EXECUTED
if (ic->nodes == (void *)ic && ic->pino_nlink == 0)
4000c888: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000c88c: 12 bf ff ec bne 4000c83c <jffs2_free_jeb_node_refs+0xd0> <== NOT EXECUTED
4000c890: ba 07 60 08 add %i5, 8, %i5 <== NOT EXECUTED
jffs2_del_ino_cache(c, ic);
4000c894: 7f ff e7 82 call 4000669c <jffs2_del_ino_cache> <== NOT EXECUTED
4000c898: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (ref->flash_offset == REF_LINK_NODE) {
4000c89c: 10 bf ff e9 b 4000c840 <jffs2_free_jeb_node_refs+0xd4> <== NOT EXECUTED
4000c8a0: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
JFFS2_WARNING("inode_cache/xattr_datum/xattr_ref"
4000c8a4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4000c8a8: 7f ff ff a5 call 4000c73c <jffs2_printk> <== NOT EXECUTED
4000c8ac: ba 07 60 08 add %i5, 8, %i5 <== NOT EXECUTED
if (ref->flash_offset == REF_LINK_NODE) {
4000c8b0: 10 bf ff e4 b 4000c840 <jffs2_free_jeb_node_refs+0xd4> <== NOT EXECUTED
4000c8b4: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
400067ac <jffs2_free_raw_node_refs>:
{
400067ac: 9d e3 bf a0 save %sp, -96, %sp
for (i=0; i<c->nr_blocks; i++) {
400067b0: c6 06 20 50 ld [ %i0 + 0x50 ], %g3
400067b4: 80 a0 e0 00 cmp %g3, 0
400067b8: 02 80 00 20 be 40006838 <jffs2_free_raw_node_refs+0x8c> <== NEVER TAKEN
400067bc: ba 10 20 00 clr %i5
this = c->blocks[i].first_node;
400067c0: c2 06 20 54 ld [ %i0 + 0x54 ], %g1
for (i=0; i<c->nr_blocks; i++) {
400067c4: 10 80 00 0d b 400067f8 <jffs2_free_raw_node_refs+0x4c>
400067c8: b6 10 20 00 clr %i3
jffs2_free_refblock(this);
400067cc: 7f ff fd 41 call 40005cd0 <jffs2_free_refblock> <== NOT EXECUTED
400067d0: 01 00 00 00 nop <== NOT EXECUTED
c->blocks[i].first_node = c->blocks[i].last_node = NULL;
400067d4: c2 06 20 54 ld [ %i0 + 0x54 ], %g1 <== NOT EXECUTED
400067d8: c6 06 20 50 ld [ %i0 + 0x50 ], %g3 <== NOT EXECUTED
400067dc: 84 00 40 1d add %g1, %i5, %g2 <== NOT EXECUTED
400067e0: c0 20 a0 2c clr [ %g2 + 0x2c ]
for (i=0; i<c->nr_blocks; i++) {
400067e4: b6 06 e0 01 inc %i3
c->blocks[i].first_node = c->blocks[i].last_node = NULL;
400067e8: c0 20 a0 28 clr [ %g2 + 0x28 ]
for (i=0; i<c->nr_blocks; i++) {
400067ec: 80 a0 c0 1b cmp %g3, %i3
400067f0: 08 80 00 12 bleu 40006838 <jffs2_free_raw_node_refs+0x8c>
400067f4: ba 07 60 34 add %i5, 0x34, %i5
this = c->blocks[i].first_node;
400067f8: 84 00 40 1d add %g1, %i5, %g2
400067fc: d0 00 a0 28 ld [ %g2 + 0x28 ], %o0
while (this) {
40006800: 80 a2 20 00 cmp %o0, 0
40006804: 22 bf ff f8 be,a 400067e4 <jffs2_free_raw_node_refs+0x38> <== NEVER TAKEN
40006808: c0 20 a0 2c clr [ %g2 + 0x2c ] <== NOT EXECUTED
if (this[REFS_PER_BLOCK].flash_offset == REF_LINK_NODE)
4000680c: c2 02 20 f4 ld [ %o0 + 0xf4 ], %g1
40006810: 80 a0 7f ff cmp %g1, -1
40006814: 12 bf ff ee bne 400067cc <jffs2_free_raw_node_refs+0x20> <== NEVER TAKEN
40006818: 01 00 00 00 nop
jffs2_free_refblock(this);
4000681c: 7f ff fd 2d call 40005cd0 <jffs2_free_refblock>
40006820: f8 02 20 f0 ld [ %o0 + 0xf0 ], %i4
while (this) {
40006824: 80 a7 20 00 cmp %i4, 0
40006828: 02 80 00 06 be 40006840 <jffs2_free_raw_node_refs+0x94>
4000682c: 90 10 00 1c mov %i4, %o0
if (this[REFS_PER_BLOCK].flash_offset == REF_LINK_NODE)
40006830: 10 bf ff f8 b 40006810 <jffs2_free_raw_node_refs+0x64>
40006834: c2 02 20 f4 ld [ %o0 + 0xf4 ], %g1
}
40006838: 81 c7 e0 08 ret
4000683c: 81 e8 00 00 restore
c->blocks[i].first_node = c->blocks[i].last_node = NULL;
40006840: c2 06 20 54 ld [ %i0 + 0x54 ], %g1
40006844: c6 06 20 50 ld [ %i0 + 0x50 ], %g3
40006848: 10 bf ff e6 b 400067e0 <jffs2_free_raw_node_refs+0x34>
4000684c: 84 00 40 1d add %g1, %i5, %g2
40004688 <jffs2_garbage_collect_pass>:
{
40004688: 9d e3 bf 48 save %sp, -184, %sp
if (!c->unchecked_size)
4000468c: f6 06 20 38 ld [ %i0 + 0x38 ], %i3
40004690: 80 a6 e0 00 cmp %i3, 0
40004694: 22 80 00 5d be,a 40004808 <jffs2_garbage_collect_pass+0x180> <== ALWAYS TAKEN
40004698: c4 06 20 a0 ld [ %i0 + 0xa0 ], %g2
for (bucket = c->check_ino % c->inocache_hashsize ; bucket < c->inocache_hashsize; bucket++) {
4000469c: c8 06 20 c0 ld [ %i0 + 0xc0 ], %g4 <== NOT EXECUTED
want_ino = c->check_ino;
400046a0: c4 06 20 08 ld [ %i0 + 8 ], %g2 <== NOT EXECUTED
for (bucket = c->check_ino % c->inocache_hashsize ; bucket < c->inocache_hashsize; bucket++) {
400046a4: 81 80 20 00 wr %g0, %y <== NOT EXECUTED
400046a8: 01 00 00 00 nop <== NOT EXECUTED
400046ac: 01 00 00 00 nop <== NOT EXECUTED
400046b0: 01 00 00 00 nop <== NOT EXECUTED
400046b4: 86 70 80 04 udiv %g2, %g4, %g3 <== NOT EXECUTED
400046b8: 86 58 c0 04 smul %g3, %g4, %g3 <== NOT EXECUTED
400046bc: 86 20 80 03 sub %g2, %g3, %g3 <== NOT EXECUTED
400046c0: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED
400046c4: 24 80 00 1c ble,a 40004734 <jffs2_garbage_collect_pass+0xac> <== NOT EXECUTED
400046c8: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED
for (ic = c->inocache_list[bucket]; ic; ic = ic->next) {
400046cc: f8 06 20 c4 ld [ %i0 + 0xc4 ], %i4 <== NOT EXECUTED
400046d0: 83 28 e0 02 sll %g3, 2, %g1 <== NOT EXECUTED
400046d4: fa 07 00 01 ld [ %i4 + %g1 ], %i5 <== NOT EXECUTED
400046d8: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
400046dc: 22 80 00 12 be,a 40004724 <jffs2_garbage_collect_pass+0x9c> <== NOT EXECUTED
400046e0: 86 00 e0 01 inc %g3 <== NOT EXECUTED
if (ic->ino < want_ino)
400046e4: d2 07 60 0c ld [ %i5 + 0xc ], %o1 <== NOT EXECUTED
400046e8: 80 a2 40 02 cmp %o1, %g2 <== NOT EXECUTED
400046ec: 2a 80 00 0a bcs,a 40004714 <jffs2_garbage_collect_pass+0x8c> <== NOT EXECUTED
400046f0: fa 07 60 10 ld [ %i5 + 0x10 ], %i5 <== NOT EXECUTED
if (ic->state != INO_STATE_CHECKEDABSENT &&
400046f4: d4 17 60 0a lduh [ %i5 + 0xa ], %o2 <== NOT EXECUTED
400046f8: 82 02 bf fe add %o2, -2, %g1 <== NOT EXECUTED
400046fc: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
40004700: 83 30 60 10 srl %g1, 0x10, %g1 <== NOT EXECUTED
40004704: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
40004708: 38 80 00 18 bgu,a 40004768 <jffs2_garbage_collect_pass+0xe0> <== NOT EXECUTED
4000470c: 88 01 00 09 add %g4, %o1, %g4 <== NOT EXECUTED
for (ic = c->inocache_list[bucket]; ic; ic = ic->next) {
40004710: fa 07 60 10 ld [ %i5 + 0x10 ], %i5 <== NOT EXECUTED
40004714: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
40004718: 32 bf ff f4 bne,a 400046e8 <jffs2_garbage_collect_pass+0x60> <== NOT EXECUTED
4000471c: d2 07 60 0c ld [ %i5 + 0xc ], %o1 <== NOT EXECUTED
for (bucket = c->check_ino % c->inocache_hashsize ; bucket < c->inocache_hashsize; bucket++) {
40004720: 86 00 e0 01 inc %g3 <== NOT EXECUTED
40004724: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED
40004728: 12 bf ff ea bne 400046d0 <jffs2_garbage_collect_pass+0x48> <== NOT EXECUTED
4000472c: 84 10 20 00 clr %g2 <== NOT EXECUTED
c->check_ino = ((c->highest_ino + c->inocache_hashsize + 1) &
40004730: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED
40004734: 82 00 60 01 inc %g1 <== NOT EXECUTED
40004738: 82 00 40 04 add %g1, %g4, %g1 <== NOT EXECUTED
4000473c: 82 28 40 04 andn %g1, %g4, %g1 <== NOT EXECUTED
~c->inocache_hashsize) - 1;
40004740: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
c->check_ino = ((c->highest_ino + c->inocache_hashsize + 1) &
40004744: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED
pr_crit("Checked all inodes but still 0x%x bytes of unchecked space?\n",
40004748: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
4000474c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
return -ENOSPC;
40004750: b8 10 3f e4 mov -28, %i4 <== NOT EXECUTED
pr_crit("Checked all inodes but still 0x%x bytes of unchecked space?\n",
40004754: 7f ff fe ba call 4000423c <jffs2_printk> <== NOT EXECUTED
40004758: 90 12 20 e8 or %o0, 0xe8, %o0 <== NOT EXECUTED
}
4000475c: b0 10 00 1c mov %i4, %i0
40004760: 81 c7 e0 08 ret
40004764: 81 e8 00 00 restore
c->check_ino = ic->ino + c->inocache_hashsize;
40004768: c8 26 20 08 st %g4, [ %i0 + 8 ] <== NOT EXECUTED
if (!ic->pino_nlink) {
4000476c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
40004770: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004774: 02 bf ff c7 be 40004690 <jffs2_garbage_collect_pass+0x8> <== NOT EXECUTED
40004778: 95 2a a0 10 sll %o2, 0x10, %o2 <== NOT EXECUTED
switch(ic->state) {
4000477c: 83 32 a0 10 srl %o2, 0x10, %g1 <== NOT EXECUTED
40004780: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
40004784: 22 80 01 41 be,a 40004c88 <jffs2_garbage_collect_pass+0x600> <== NOT EXECUTED
40004788: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
4000478c: 18 80 00 10 bgu 400047cc <jffs2_garbage_collect_pass+0x144> <== NOT EXECUTED
40004790: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004794: 12 80 01 3c bne 40004c84 <jffs2_garbage_collect_pass+0x5fc> <== NOT EXECUTED
40004798: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
ic->state = INO_STATE_CHECKING;
4000479c: c2 37 60 0a sth %g1, [ %i5 + 0xa ] <== NOT EXECUTED
ret = jffs2_do_crccheck_inode(c, ic);
400047a0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400047a4: 40 00 15 f3 call 40009f70 <jffs2_do_crccheck_inode> <== NOT EXECUTED
400047a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (ret)
400047ac: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
400047b0: 12 80 00 0d bne 400047e4 <jffs2_garbage_collect_pass+0x15c> <== NOT EXECUTED
400047b4: 94 10 20 03 mov 3, %o2 <== NOT EXECUTED
jffs2_set_inocache_state(c, ic, INO_STATE_CHECKEDABSENT);
400047b8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400047bc: 40 00 07 75 call 40006590 <jffs2_set_inocache_state> <== NOT EXECUTED
400047c0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
400047c4: 81 c7 e0 08 ret <== NOT EXECUTED
400047c8: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
switch(ic->state) {
400047cc: 80 a0 60 05 cmp %g1, 5 <== NOT EXECUTED
400047d0: 12 80 01 33 bne 40004c9c <jffs2_garbage_collect_pass+0x614> <== NOT EXECUTED
400047d4: b8 10 20 00 clr %i4 <== NOT EXECUTED
c->check_ino = ic->ino;
400047d8: d2 26 20 08 st %o1, [ %i0 + 8 ] <== NOT EXECUTED
}
400047dc: 81 c7 e0 08 ret <== NOT EXECUTED
400047e0: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
pr_warn("Returned error for crccheck of ino #%u. Expect badness...\n",
400047e4: d2 07 60 0c ld [ %i5 + 0xc ], %o1 <== NOT EXECUTED
400047e8: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
400047ec: 7f ff fe 94 call 4000423c <jffs2_printk> <== NOT EXECUTED
400047f0: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 4001e5a0 <rtems_jffs2_directory_handlers+0x424><== NOT EXECUTED
jffs2_set_inocache_state(c, ic, INO_STATE_CHECKEDABSENT);
400047f4: 94 10 20 03 mov 3, %o2 <== NOT EXECUTED
400047f8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
400047fc: 40 00 07 65 call 40006590 <jffs2_set_inocache_state> <== NOT EXECUTED
40004800: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return ret;
40004804: 30 bf ff f0 b,a 400047c4 <jffs2_garbage_collect_pass+0x13c> <== NOT EXECUTED
if (!list_empty(&c->erase_complete_list) ||
40004808: 82 06 20 a0 add %i0, 0xa0, %g1
4000480c: 80 a0 80 01 cmp %g2, %g1
40004810: 22 80 00 24 be,a 400048a0 <jffs2_garbage_collect_pass+0x218> <== ALWAYS TAKEN
40004814: c4 06 20 98 ld [ %i0 + 0x98 ], %g2
if (jffs2_erase_pending_blocks(c, 1))
40004818: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
4000481c: 40 00 20 27 call 4000c8b8 <jffs2_erase_pending_blocks>
40004820: 90 10 00 18 mov %i0, %o0
40004824: 80 a2 20 00 cmp %o0, 0
40004828: 12 bf ff cd bne 4000475c <jffs2_garbage_collect_pass+0xd4> <== ALWAYS TAKEN
4000482c: b8 10 20 00 clr %i4
jeb = c->gcblock;
40004830: e0 06 20 5c ld [ %i0 + 0x5c ], %l0 <== NOT EXECUTED
if (!jeb)
40004834: 80 a4 20 00 cmp %l0, 0
40004838: 02 80 00 32 be 40004900 <jffs2_garbage_collect_pass+0x278>
4000483c: 03 10 01 1d sethi %hi(0x40047400), %g1
if (!jeb->used_size) {
40004840: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
40004844: 80 a0 60 00 cmp %g1, 0
40004848: 22 80 00 88 be,a 40004a68 <jffs2_garbage_collect_pass+0x3e0> <== NEVER TAKEN
4000484c: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED
raw = jeb->gc_node;
40004850: fa 04 20 30 ld [ %l0 + 0x30 ], %i5
while(ref_obsolete(raw)) {
40004854: 10 80 00 05 b 40004868 <jffs2_garbage_collect_pass+0x1e0>
40004858: c2 07 60 04 ld [ %i5 + 4 ], %g1
if (!ref)
return ref;
}
/* End of chain */
if (ref->flash_offset == REF_EMPTY_NODE)
4000485c: 80 a0 7f fe cmp %g1, -2
40004860: 02 80 00 16 be 400048b8 <jffs2_garbage_collect_pass+0x230> <== NEVER TAKEN
40004864: 11 10 00 79 sethi %hi(0x4001e400), %o0
40004868: 82 08 60 03 and %g1, 3, %g1
4000486c: 80 a0 60 01 cmp %g1, 1
40004870: 32 80 00 95 bne,a 40004ac4 <jffs2_garbage_collect_pass+0x43c>
40004874: fa 24 20 30 st %i5, [ %l0 + 0x30 ]
if (ref->flash_offset == REF_LINK_NODE) {
40004878: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000487c: 80 a0 7f ff cmp %g1, -1
40004880: 32 bf ff f7 bne,a 4000485c <jffs2_garbage_collect_pass+0x1d4>
40004884: ba 07 60 08 add %i5, 8, %i5
ref = ref->next_in_ino;
40004888: fa 07 60 08 ld [ %i5 + 8 ], %i5
if (!ref)
4000488c: 80 a7 60 00 cmp %i5, 0
40004890: 02 80 00 0a be 400048b8 <jffs2_garbage_collect_pass+0x230> <== NEVER TAKEN
40004894: 11 10 00 79 sethi %hi(0x4001e400), %o0
if (ref->flash_offset == REF_EMPTY_NODE)
40004898: 10 bf ff f1 b 4000485c <jffs2_garbage_collect_pass+0x1d4>
4000489c: c2 07 60 04 ld [ %i5 + 4 ], %g1
!list_empty(&c->erase_pending_list)) {
400048a0: 82 06 20 98 add %i0, 0x98, %g1
if (!list_empty(&c->erase_complete_list) ||
400048a4: 80 a0 80 01 cmp %g2, %g1
400048a8: 12 bf ff dd bne 4000481c <jffs2_garbage_collect_pass+0x194>
400048ac: 92 10 20 01 mov 1, %o1
400048b0: 10 bf ff e1 b 40004834 <jffs2_garbage_collect_pass+0x1ac>
400048b4: e0 06 20 5c ld [ %i0 + 0x5c ], %l0
pr_warn("eep. End of raw list while still supposedly nodes to GC\n");
400048b8: 7f ff fe 61 call 4000423c <jffs2_printk> <== NOT EXECUTED
400048bc: 90 12 22 28 or %o0, 0x228, %o0 <== NOT EXECUTED
pr_warn("erase block at 0x%08x. free_size 0x%08x, dirty_size 0x%08x, used_size 0x%08x\n",
400048c0: d6 04 20 18 ld [ %l0 + 0x18 ], %o3 <== NOT EXECUTED
400048c4: d4 04 20 20 ld [ %l0 + 0x20 ], %o2 <== NOT EXECUTED
400048c8: d2 04 20 0c ld [ %l0 + 0xc ], %o1 <== NOT EXECUTED
400048cc: d8 04 20 14 ld [ %l0 + 0x14 ], %o4 <== NOT EXECUTED
400048d0: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
400048d4: 7f ff fe 5a call 4000423c <jffs2_printk> <== NOT EXECUTED
400048d8: 90 12 22 70 or %o0, 0x270, %o0 ! 4001e670 <rtems_jffs2_directory_handlers+0x4f4><== NOT EXECUTED
jeb->gc_node = raw;
400048dc: c0 24 20 30 clr [ %l0 + 0x30 ] <== NOT EXECUTED
BUG();
400048e0: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
400048e4: 15 10 00 7b sethi %hi(0x4001ec00), %o2 <== NOT EXECUTED
400048e8: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
400048ec: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
400048f0: 94 12 a1 b0 or %o2, 0x1b0, %o2 <== NOT EXECUTED
400048f4: 92 10 21 33 mov 0x133, %o1 <== NOT EXECUTED
400048f8: 40 00 28 20 call 4000e978 <__assert_func> <== NOT EXECUTED
400048fc: 90 12 21 70 or %o0, 0x170, %o0 <== NOT EXECUTED
40004900: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
/* Is this list empty? */
static __inline__ int
list_empty( struct list_head *list )
{
return ( list->next == list );
40004904: de 06 20 b8 ld [ %i0 + 0xb8 ], %o7
int n = jiffies % 128;
40004908: 84 08 a0 7f and %g2, 0x7f, %g2
if (!list_empty(&c->bad_used_list) && c->nr_free_blocks > c->resv_blocks_gcbad) {
4000490c: b4 06 20 b8 add %i0, 0xb8, %i2
} else if (n < 126 && !list_empty(&c->dirty_list)) {
40004910: b8 06 20 70 add %i0, 0x70, %i4
} else if (!list_empty(&c->clean_list)) {
40004914: ba 06 20 60 add %i0, 0x60, %i5
} else if (n < 110 && !list_empty(&c->very_dirty_list)) {
40004918: 88 06 20 68 add %i0, 0x68, %g4
} else if (n < 50 && !list_empty(&c->erasable_list)) {
4000491c: 86 06 20 78 add %i0, 0x78, %g3
} else if (!list_empty(&c->erasable_pending_wbuf_list)) {
40004920: 10 80 00 1d b 40004994 <jffs2_garbage_collect_pass+0x30c>
40004924: b2 06 20 80 add %i0, 0x80, %i1
} else if (n < 50 && !list_empty(&c->erasable_list)) {
40004928: 80 a0 c0 0d cmp %g3, %o5
4000492c: 12 80 00 31 bne 400049f0 <jffs2_garbage_collect_pass+0x368> <== NEVER TAKEN
40004930: 82 10 00 03 mov %g3, %g1
} else if (n < 110 && !list_empty(&c->very_dirty_list)) {
40004934: da 06 20 68 ld [ %i0 + 0x68 ], %o5
40004938: 80 a1 00 0d cmp %g4, %o5
4000493c: 12 80 00 2d bne 400049f0 <jffs2_garbage_collect_pass+0x368>
40004940: 82 10 00 04 mov %g4, %g1
} else if (n < 126 && !list_empty(&c->dirty_list)) {
40004944: da 06 20 70 ld [ %i0 + 0x70 ], %o5
40004948: 80 a7 00 0d cmp %i4, %o5
4000494c: 12 80 00 29 bne 400049f0 <jffs2_garbage_collect_pass+0x368> <== NEVER TAKEN
40004950: 82 10 00 1c mov %i4, %g1
} else if (!list_empty(&c->clean_list)) {
40004954: da 06 20 60 ld [ %i0 + 0x60 ], %o5
40004958: 80 a3 40 1d cmp %o5, %i5
4000495c: 12 80 00 25 bne 400049f0 <jffs2_garbage_collect_pass+0x368> <== NEVER TAKEN
40004960: 82 10 00 1d mov %i5, %g1
} else if (!list_empty(&c->very_dirty_list)) {
40004964: da 06 20 68 ld [ %i0 + 0x68 ], %o5
40004968: 80 a1 00 0d cmp %g4, %o5
4000496c: 12 80 00 21 bne 400049f0 <jffs2_garbage_collect_pass+0x368> <== NEVER TAKEN
40004970: 82 10 00 04 mov %g4, %g1
} else if (!list_empty(&c->erasable_list)) {
40004974: da 06 20 78 ld [ %i0 + 0x78 ], %o5
40004978: 80 a0 c0 0d cmp %g3, %o5
4000497c: 12 80 00 1d bne 400049f0 <jffs2_garbage_collect_pass+0x368> <== NEVER TAKEN
40004980: 82 10 00 03 mov %g3, %g1
} else if (!list_empty(&c->erasable_pending_wbuf_list)) {
40004984: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
40004988: 80 a0 40 19 cmp %g1, %i1
4000498c: 22 80 00 32 be,a 40004a54 <jffs2_garbage_collect_pass+0x3cc> <== ALWAYS TAKEN
40004990: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
if (!list_empty(&c->bad_used_list) && c->nr_free_blocks > c->resv_blocks_gcbad) {
40004994: 80 a3 c0 1a cmp %o7, %i2
40004998: 02 80 00 07 be 400049b4 <jffs2_garbage_collect_pass+0x32c> <== ALWAYS TAKEN
4000499c: 80 a0 a0 31 cmp %g2, 0x31
400049a0: c2 0e 20 47 ldub [ %i0 + 0x47 ], %g1 <== NOT EXECUTED
400049a4: da 06 20 3c ld [ %i0 + 0x3c ], %o5 <== NOT EXECUTED
400049a8: 80 a3 40 01 cmp %o5, %g1 <== NOT EXECUTED
400049ac: 18 80 00 a8 bgu 40004c4c <jffs2_garbage_collect_pass+0x5c4> <== NOT EXECUTED
400049b0: 80 a0 a0 31 cmp %g2, 0x31 <== NOT EXECUTED
} else if (n < 50 && !list_empty(&c->erasable_list)) {
400049b4: 24 bf ff dd ble,a 40004928 <jffs2_garbage_collect_pass+0x2a0>
400049b8: da 06 20 78 ld [ %i0 + 0x78 ], %o5
} else if (n < 110 && !list_empty(&c->very_dirty_list)) {
400049bc: 80 a0 a0 6d cmp %g2, 0x6d
400049c0: 04 bf ff dd ble 40004934 <jffs2_garbage_collect_pass+0x2ac> <== ALWAYS TAKEN
400049c4: 80 a0 a0 7d cmp %g2, 0x7d
} else if (n < 126 && !list_empty(&c->dirty_list)) {
400049c8: 24 bf ff e0 ble,a 40004948 <jffs2_garbage_collect_pass+0x2c0> <== NOT EXECUTED
400049cc: da 06 20 70 ld [ %i0 + 0x70 ], %o5 <== NOT EXECUTED
} else if (!list_empty(&c->clean_list)) {
400049d0: da 06 20 60 ld [ %i0 + 0x60 ], %o5 <== NOT EXECUTED
400049d4: 80 a7 40 0d cmp %i5, %o5 <== NOT EXECUTED
400049d8: 12 80 00 06 bne 400049f0 <jffs2_garbage_collect_pass+0x368> <== NOT EXECUTED
400049dc: 82 10 00 1d mov %i5, %g1 <== NOT EXECUTED
} else if (!list_empty(&c->dirty_list)) {
400049e0: da 06 20 70 ld [ %i0 + 0x70 ], %o5 <== NOT EXECUTED
400049e4: 80 a7 00 0d cmp %i4, %o5 <== NOT EXECUTED
400049e8: 02 bf ff df be 40004964 <jffs2_garbage_collect_pass+0x2dc> <== NOT EXECUTED
400049ec: 82 10 00 1c mov %i4, %g1 <== NOT EXECUTED
ret = list_entry(nextlist->next, struct jffs2_eraseblock, list);
400049f0: e0 00 40 00 ld [ %g1 ], %l0
ent->prev->next = ent->next;
400049f4: c2 04 00 00 ld [ %l0 ], %g1
400049f8: c4 04 20 04 ld [ %l0 + 4 ], %g2
400049fc: c2 20 80 00 st %g1, [ %g2 ]
ent->next->prev = ent->prev;
40004a00: c4 20 60 04 st %g2, [ %g1 + 4 ]
ret->gc_node = ret->first_node;
40004a04: c2 04 20 28 ld [ %l0 + 0x28 ], %g1
c->gcblock = ret;
40004a08: e0 26 20 5c st %l0, [ %i0 + 0x5c ]
if (!ret->gc_node) {
40004a0c: 80 a0 60 00 cmp %g1, 0
40004a10: 02 80 00 91 be 40004c54 <jffs2_garbage_collect_pass+0x5cc> <== NEVER TAKEN
40004a14: c2 24 20 30 st %g1, [ %l0 + 0x30 ]
if (ret->wasted_size) {
40004a18: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
40004a1c: 80 a0 60 00 cmp %g1, 0
40004a20: 22 bf ff 89 be,a 40004844 <jffs2_garbage_collect_pass+0x1bc> <== ALWAYS TAKEN
40004a24: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
ret->dirty_size += ret->wasted_size;
40004a28: c8 04 20 18 ld [ %l0 + 0x18 ], %g4 <== NOT EXECUTED
c->wasted_size -= ret->wasted_size;
40004a2c: c6 06 20 24 ld [ %i0 + 0x24 ], %g3 <== NOT EXECUTED
c->dirty_size += ret->wasted_size;
40004a30: c4 06 20 20 ld [ %i0 + 0x20 ], %g2 <== NOT EXECUTED
ret->dirty_size += ret->wasted_size;
40004a34: 88 01 00 01 add %g4, %g1, %g4 <== NOT EXECUTED
40004a38: c8 24 20 18 st %g4, [ %l0 + 0x18 ] <== NOT EXECUTED
c->wasted_size -= ret->wasted_size;
40004a3c: 86 20 c0 01 sub %g3, %g1, %g3 <== NOT EXECUTED
c->dirty_size += ret->wasted_size;
40004a40: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
c->wasted_size -= ret->wasted_size;
40004a44: c6 26 20 24 st %g3, [ %i0 + 0x24 ] <== NOT EXECUTED
c->dirty_size += ret->wasted_size;
40004a48: c2 26 20 20 st %g1, [ %i0 + 0x20 ] <== NOT EXECUTED
ret->wasted_size = 0;
40004a4c: 10 bf ff 7d b 40004840 <jffs2_garbage_collect_pass+0x1b8> <== NOT EXECUTED
40004a50: c0 24 20 1c clr [ %l0 + 0x1c ] <== NOT EXECUTED
return -EIO;
40004a54: 80 a0 00 01 cmp %g0, %g1
40004a58: b8 60 20 00 subx %g0, 0, %i4
40004a5c: b8 0f 3f fa and %i4, -6, %i4
40004a60: 10 bf ff 3f b 4000475c <jffs2_garbage_collect_pass+0xd4>
40004a64: b8 07 3f fb add %i4, -5, %i4
int ret = 0, inum, nlink;
40004a68: b8 10 20 00 clr %i4 <== NOT EXECUTED
if (c->gcblock && !c->gcblock->used_size) {
40004a6c: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 <== NOT EXECUTED
40004a70: 80 a0 a0 00 cmp %g2, 0
40004a74: 32 bf ff 3b bne,a 40004760 <jffs2_garbage_collect_pass+0xd8> <== ALWAYS TAKEN
40004a78: b0 10 00 1c mov %i4, %i0
struct list_head *prev = beforethisent->prev;
40004a7c: c4 06 20 9c ld [ %i0 + 0x9c ], %g2 <== NOT EXECUTED
newent->prev = prev;
40004a80: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
list_add_tail(&c->gcblock->list, &c->erase_pending_list);
40004a84: 86 06 20 98 add %i0, 0x98, %g3 <== NOT EXECUTED
newent->next = beforethisent;
40004a88: c6 20 40 00 st %g3, [ %g1 ] <== NOT EXECUTED
beforethisent->prev = newent;
40004a8c: c2 26 20 9c st %g1, [ %i0 + 0x9c ] <== NOT EXECUTED
prev->next = newent;
40004a90: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
c->nr_erasing_blocks++;
40004a94: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED
40004a98: 82 00 60 01 inc %g1 <== NOT EXECUTED
rtems_jffs2_flash_control *fc = sb->s_flash_control;
40004a9c: d0 06 20 e4 ld [ %i0 + 0xe4 ], %o0 <== NOT EXECUTED
40004aa0: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED
c->gcblock = NULL;
40004aa4: c0 26 20 5c clr [ %i0 + 0x5c ] <== NOT EXECUTED
if (fc->trigger_garbage_collection != NULL) {
40004aa8: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 <== NOT EXECUTED
40004aac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004ab0: 02 bf ff 2c be 40004760 <jffs2_garbage_collect_pass+0xd8> <== NOT EXECUTED
40004ab4: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
(*fc->trigger_garbage_collection)(fc);
40004ab8: 9f c0 40 00 call %g1 <== NOT EXECUTED
40004abc: 01 00 00 00 nop <== NOT EXECUTED
40004ac0: 30 bf ff 28 b,a 40004760 <jffs2_garbage_collect_pass+0xd8> <== NOT EXECUTED
if (!raw->next_in_ino) {
40004ac4: f2 07 40 00 ld [ %i5 ], %i1
40004ac8: 80 a6 60 00 cmp %i1, 0
40004acc: 02 80 00 44 be 40004bdc <jffs2_garbage_collect_pass+0x554> <== NEVER TAKEN
40004ad0: e6 04 20 18 ld [ %l0 + 0x18 ], %l3
40004ad4: b4 10 00 19 mov %i1, %i2
return ref;
}
static inline struct jffs2_inode_cache *jffs2_raw_ref_to_ic(struct jffs2_raw_node_ref *raw)
{
while(raw->next_in_ino)
40004ad8: f2 06 40 00 ld [ %i1 ], %i1
40004adc: 80 a6 60 00 cmp %i1, 0
40004ae0: 32 bf ff fe bne,a 40004ad8 <jffs2_garbage_collect_pass+0x450> <== NEVER TAKEN
40004ae4: b4 10 00 19 mov %i1, %i2 <== NOT EXECUTED
switch(ic->state) {
40004ae8: d4 16 a0 0a lduh [ %i2 + 0xa ], %o2
40004aec: 95 2a a0 10 sll %o2, 0x10, %o2
40004af0: a3 32 a0 10 srl %o2, 0x10, %l1
40004af4: 80 a4 60 04 cmp %l1, 4
40004af8: 22 80 00 2d be,a 40004bac <jffs2_garbage_collect_pass+0x524> <== NEVER TAKEN
40004afc: d2 06 a0 0c ld [ %i2 + 0xc ], %o1 <== NOT EXECUTED
40004b00: 18 80 00 25 bgu 40004b94 <jffs2_garbage_collect_pass+0x50c> <== NEVER TAKEN
40004b04: 80 a4 60 01 cmp %l1, 1
40004b08: 08 80 00 28 bleu 40004ba8 <jffs2_garbage_collect_pass+0x520> <== NEVER TAKEN
40004b0c: 80 a4 60 03 cmp %l1, 3
40004b10: 12 80 00 04 bne 40004b20 <jffs2_garbage_collect_pass+0x498>
40004b14: 80 a0 60 02 cmp %g1, 2
if (ref_flags(raw) == REF_PRISTINE)
40004b18: 02 80 00 39 be 40004bfc <jffs2_garbage_collect_pass+0x574>
40004b1c: 82 10 20 04 mov 4, %g1
f = jffs2_gc_fetch_inode(c, inum, !nlink);
40004b20: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1
40004b24: 80 a0 00 01 cmp %g0, %g1
40004b28: d2 06 a0 0c ld [ %i2 + 0xc ], %o1
40004b2c: 94 60 3f ff subx %g0, -1, %o2
40004b30: 7f ff fd 90 call 40004170 <jffs2_gc_fetch_inode>
40004b34: 90 10 00 18 mov %i0, %o0
if (IS_ERR(f)) {
40004b38: 80 a2 3c 18 cmp %o0, -1000
40004b3c: 18 80 03 2c bgu 400057ec <jffs2_garbage_collect_pass+0x1164> <== NEVER TAKEN
40004b40: b4 10 00 08 mov %o0, %i2
if (!f) {
40004b44: 80 a2 20 00 cmp %o0, 0
40004b48: 02 80 00 0d be 40004b7c <jffs2_garbage_collect_pass+0x4f4> <== NEVER TAKEN
40004b4c: b8 10 20 00 clr %i4
if (c->gcblock != jeb) {
40004b50: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
40004b54: 80 a4 00 01 cmp %l0, %g1
40004b58: 22 80 00 65 be,a 40004cec <jffs2_garbage_collect_pass+0x664> <== ALWAYS TAKEN
40004b5c: c2 07 60 04 ld [ %i5 + 4 ], %g1
jffs2_gc_release_inode(c, f);
40004b60: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40004b64: 7f ff fd 7f call 40004160 <jffs2_gc_release_inode>
40004b68: 90 10 00 18 mov %i0, %o0
if (jeb->dirty_size == gcblock_dirty && !ref_obsolete(jeb->gc_node)) {
40004b6c: c2 04 20 18 ld [ %l0 + 0x18 ], %g1
40004b70: 80 a0 40 13 cmp %g1, %l3
40004b74: 22 80 00 52 be,a 40004cbc <jffs2_garbage_collect_pass+0x634> <== NEVER TAKEN
40004b78: c2 04 20 30 ld [ %l0 + 0x30 ], %g1 <== NOT EXECUTED
if (c->gcblock && !c->gcblock->used_size) {
40004b7c: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
40004b80: 80 a0 60 00 cmp %g1, 0
40004b84: 22 bf fe f7 be,a 40004760 <jffs2_garbage_collect_pass+0xd8>
40004b88: b0 10 00 1c mov %i4, %i0
40004b8c: 10 bf ff b9 b 40004a70 <jffs2_garbage_collect_pass+0x3e8>
40004b90: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
switch(ic->state) {
40004b94: 80 a4 60 05 cmp %l1, 5 <== NOT EXECUTED
40004b98: 02 bf fe f1 be 4000475c <jffs2_garbage_collect_pass+0xd4> <== NOT EXECUTED
40004b9c: b8 10 20 00 clr %i4 <== NOT EXECUTED
f = jffs2_gc_fetch_inode(c, inum, !nlink);
40004ba0: 10 bf ff e1 b 40004b24 <jffs2_garbage_collect_pass+0x49c> <== NOT EXECUTED
40004ba4: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1 <== NOT EXECUTED
pr_crit("Inode #%u already in state %d in jffs2_garbage_collect_pass()!\n",
40004ba8: d2 06 a0 0c ld [ %i2 + 0xc ], %o1 <== NOT EXECUTED
40004bac: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
40004bb0: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
40004bb4: 7f ff fd a2 call 4000423c <jffs2_printk> <== NOT EXECUTED
40004bb8: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 4001e6c8 <rtems_jffs2_directory_handlers+0x54c><== NOT EXECUTED
BUG();
40004bbc: 92 10 21 8d mov 0x18d, %o1 <== NOT EXECUTED
40004bc0: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
40004bc4: 15 10 00 7b sethi %hi(0x4001ec00), %o2 <== NOT EXECUTED
40004bc8: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
40004bcc: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
40004bd0: 94 12 a1 b0 or %o2, 0x1b0, %o2 <== NOT EXECUTED
40004bd4: 40 00 27 69 call 4000e978 <__assert_func> <== NOT EXECUTED
40004bd8: 90 12 21 70 or %o0, 0x170, %o0 <== NOT EXECUTED
if (ref_flags(raw) == REF_PRISTINE) {
40004bdc: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
40004be0: 02 80 00 14 be 40004c30 <jffs2_garbage_collect_pass+0x5a8> <== NOT EXECUTED
40004be4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
jffs2_mark_node_obsolete(c, raw);
40004be8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40004bec: 40 00 08 c9 call 40006f10 <jffs2_mark_node_obsolete> <== NOT EXECUTED
40004bf0: b8 10 20 00 clr %i4 <== NOT EXECUTED
if (c->gcblock && !c->gcblock->used_size) {
40004bf4: 10 bf ff e3 b 40004b80 <jffs2_garbage_collect_pass+0x4f8> <== NOT EXECUTED
40004bf8: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED
ic->state = INO_STATE_GC;
40004bfc: c2 36 a0 0a sth %g1, [ %i2 + 0xa ]
ret = jffs2_garbage_collect_pristine(c, ic, raw);
40004c00: 94 10 00 1d mov %i5, %o2
40004c04: 92 10 00 1a mov %i2, %o1
40004c08: 7f ff fd 99 call 4000426c <jffs2_garbage_collect_pristine>
40004c0c: 90 10 00 18 mov %i0, %o0
ic->state = INO_STATE_CHECKEDABSENT;
40004c10: e2 36 a0 0a sth %l1, [ %i2 + 0xa ]
if (ret != -EBADFD) {
40004c14: 03 3f ff e0 sethi %hi(0xffff8000), %g1
40004c18: 82 10 60 01 or %g1, 1, %g1 ! ffff8001 <RAM_END+0xbfbf8001>
40004c1c: 80 a2 00 01 cmp %o0, %g1
40004c20: 12 bf ff d3 bne 40004b6c <jffs2_garbage_collect_pass+0x4e4> <== ALWAYS TAKEN
40004c24: b8 10 00 08 mov %o0, %i4
f = jffs2_gc_fetch_inode(c, inum, !nlink);
40004c28: 10 bf ff bf b 40004b24 <jffs2_garbage_collect_pass+0x49c> <== NOT EXECUTED
40004c2c: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1 <== NOT EXECUTED
jffs2_garbage_collect_pristine(c, NULL, raw);
40004c30: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
40004c34: 92 10 20 00 clr %o1 <== NOT EXECUTED
40004c38: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40004c3c: 7f ff fd 8c call 4000426c <jffs2_garbage_collect_pristine> <== NOT EXECUTED
40004c40: b8 10 20 00 clr %i4 <== NOT EXECUTED
40004c44: 10 bf ff cf b 40004b80 <jffs2_garbage_collect_pass+0x4f8> <== NOT EXECUTED
40004c48: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED
40004c4c: 10 bf ff 69 b 400049f0 <jffs2_garbage_collect_pass+0x368> <== NOT EXECUTED
40004c50: 82 10 00 1a mov %i2, %g1 <== NOT EXECUTED
pr_warn("Eep. ret->gc_node for block at 0x%08x is NULL\n",
40004c54: d2 04 20 0c ld [ %l0 + 0xc ], %o1 <== NOT EXECUTED
40004c58: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
40004c5c: 7f ff fd 78 call 4000423c <jffs2_printk> <== NOT EXECUTED
40004c60: 90 12 21 e8 or %o0, 0x1e8, %o0 ! 4001e5e8 <rtems_jffs2_directory_handlers+0x46c><== NOT EXECUTED
BUG();
40004c64: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
40004c68: 15 10 00 7b sethi %hi(0x4001ec00), %o2 <== NOT EXECUTED
40004c6c: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
40004c70: 92 10 20 6a mov 0x6a, %o1 <== NOT EXECUTED
40004c74: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
40004c78: 94 12 a1 98 or %o2, 0x198, %o2 <== NOT EXECUTED
40004c7c: 40 00 27 3f call 4000e978 <__assert_func> <== NOT EXECUTED
40004c80: 90 12 21 70 or %o0, 0x170, %o0 <== NOT EXECUTED
pr_warn("Inode #%u is in state %d during CRC check phase!\n",
40004c84: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
40004c88: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
40004c8c: 7f ff fd 6c call 4000423c <jffs2_printk> <== NOT EXECUTED
40004c90: 90 12 21 30 or %o0, 0x130, %o0 ! 4001e530 <rtems_jffs2_directory_handlers+0x3b4><== NOT EXECUTED
BUG();
40004c94: 10 bf ff cb b 40004bc0 <jffs2_garbage_collect_pass+0x538> <== NOT EXECUTED
40004c98: 92 10 20 d3 mov 0xd3, %o1 <== NOT EXECUTED
BUG();
40004c9c: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
40004ca0: 15 10 00 7b sethi %hi(0x4001ec00), %o2 <== NOT EXECUTED
40004ca4: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
40004ca8: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
40004cac: 94 12 a1 b0 or %o2, 0x1b0, %o2 <== NOT EXECUTED
40004cb0: 92 10 20 e4 mov 0xe4, %o1 <== NOT EXECUTED
40004cb4: 40 00 27 31 call 4000e978 <__assert_func> <== NOT EXECUTED
40004cb8: 90 12 21 70 or %o0, 0x170, %o0 <== NOT EXECUTED
if (jeb->dirty_size == gcblock_dirty && !ref_obsolete(jeb->gc_node)) {
40004cbc: d2 00 60 04 ld [ %g1 + 4 ], %o1 <== NOT EXECUTED
40004cc0: 82 0a 60 03 and %o1, 3, %g1 <== NOT EXECUTED
40004cc4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
40004cc8: 22 bf ff ae be,a 40004b80 <jffs2_garbage_collect_pass+0x4f8> <== NOT EXECUTED
40004ccc: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED
pr_err("Error garbage collecting node at %08x!\n",
40004cd0: 92 0a 7f fc and %o1, -4, %o1 <== NOT EXECUTED
ret = -ENOSPC;
40004cd4: b8 10 3f e4 mov -28, %i4 <== NOT EXECUTED
pr_err("Error garbage collecting node at %08x!\n",
40004cd8: 11 10 00 7b sethi %hi(0x4001ec00), %o0 <== NOT EXECUTED
40004cdc: 7f ff fd 58 call 4000423c <jffs2_printk> <== NOT EXECUTED
40004ce0: 90 12 20 c0 or %o0, 0xc0, %o0 ! 4001ecc0 <rtems_jffs2_directory_handlers+0xb44><== NOT EXECUTED
if (c->gcblock && !c->gcblock->used_size) {
40004ce4: 10 bf ff a7 b 40004b80 <jffs2_garbage_collect_pass+0x4f8> <== NOT EXECUTED
40004ce8: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED
if (ref_obsolete(raw)) {
40004cec: 82 08 60 03 and %g1, 3, %g1
40004cf0: 80 a0 60 01 cmp %g1, 1
40004cf4: 02 bf ff 9c be 40004b64 <jffs2_garbage_collect_pass+0x4dc> <== NEVER TAKEN
40004cf8: 92 10 00 1a mov %i2, %o1
if (f->metadata && f->metadata->raw == raw) {
40004cfc: e2 02 20 08 ld [ %o0 + 8 ], %l1
40004d00: 80 a4 60 00 cmp %l1, 0
40004d04: 02 80 00 06 be 40004d1c <jffs2_garbage_collect_pass+0x694>
40004d08: a8 06 a0 04 add %i2, 4, %l4
40004d0c: c2 04 40 00 ld [ %l1 ], %g1
40004d10: 80 a7 40 01 cmp %i5, %g1
40004d14: 22 80 02 b8 be,a 400057f4 <jffs2_garbage_collect_pass+0x116c> <== ALWAYS TAKEN
40004d18: c2 02 3f c0 ld [ %o0 + -64 ], %g1
return _RBTree_Predecessor( node );
}
static inline struct rb_node *rb_first( struct rb_root *root )
{
return _RBTree_Minimum( (RBTree_Control *) root );
40004d1c: 40 00 43 1c call 4001598c <_RBTree_Minimum>
40004d20: 90 10 00 14 mov %l4, %o0
static inline struct jffs2_node_frag *frag_first(struct rb_root *root)
{
struct rb_node *node = rb_first(root);
if (!node)
40004d24: a4 92 20 00 orcc %o0, 0, %l2
40004d28: 02 80 00 1d be 40004d9c <jffs2_garbage_collect_pass+0x714>
40004d2c: a2 10 20 00 clr %l1
40004d30: 10 80 00 07 b 40004d4c <jffs2_garbage_collect_pass+0x6c4>
40004d34: b8 10 20 00 clr %i4
return _RBTree_Successor( node );
40004d38: 40 00 43 2f call 400159f4 <_RBTree_Successor>
40004d3c: 90 10 00 12 mov %l2, %o0
for (frag = frag_first(&f->fragtree); frag; frag = frag_next(frag)) {
40004d40: a4 92 20 00 orcc %o0, 0, %l2
40004d44: 02 80 00 32 be 40004e0c <jffs2_garbage_collect_pass+0x784> <== NEVER TAKEN
40004d48: 80 a6 60 00 cmp %i1, 0
if (frag->node && frag->node->raw == raw) {
40004d4c: c2 04 a0 10 ld [ %l2 + 0x10 ], %g1
40004d50: 80 a0 60 00 cmp %g1, 0
40004d54: 02 bf ff f9 be 40004d38 <jffs2_garbage_collect_pass+0x6b0> <== NEVER TAKEN
40004d58: 01 00 00 00 nop
40004d5c: c4 00 40 00 ld [ %g1 ], %g2
40004d60: 80 a7 40 02 cmp %i5, %g2
40004d64: 12 bf ff f5 bne 40004d38 <jffs2_garbage_collect_pass+0x6b0>
40004d68: 80 a7 20 00 cmp %i4, 0
end = frag->ofs + frag->size;
40004d6c: c6 04 a0 18 ld [ %l2 + 0x18 ], %g3
40004d70: f6 04 a0 14 ld [ %l2 + 0x14 ], %i3
40004d74: b6 00 c0 1b add %g3, %i3, %i3
if (!nrfrags++)
40004d78: 12 80 00 03 bne 40004d84 <jffs2_garbage_collect_pass+0x6fc> <== NEVER TAKEN
40004d7c: 84 07 20 01 add %i4, 1, %g2
start = frag->ofs;
40004d80: a2 10 00 03 mov %g3, %l1
if (nrfrags == frag->node->frags)
40004d84: c6 00 60 0c ld [ %g1 + 0xc ], %g3
40004d88: 80 a0 80 03 cmp %g2, %g3
40004d8c: 02 80 03 0d be 400059c0 <jffs2_garbage_collect_pass+0x1338> <== ALWAYS TAKEN
40004d90: b8 10 00 02 mov %g2, %i4
40004d94: 10 bf ff e9 b 40004d38 <jffs2_garbage_collect_pass+0x6b0> <== NOT EXECUTED
40004d98: b2 10 00 01 mov %g1, %i1 <== NOT EXECUTED
for (fd = f->dents; fd; fd=fd->next) {
40004d9c: c2 06 a0 0c ld [ %i2 + 0xc ], %g1
40004da0: 10 80 00 06 b 40004db8 <jffs2_garbage_collect_pass+0x730>
40004da4: b6 10 00 01 mov %g1, %i3
if (fd->raw == raw)
40004da8: 80 a7 40 02 cmp %i5, %g2
40004dac: 22 80 00 9f be,a 40005028 <jffs2_garbage_collect_pass+0x9a0>
40004db0: c4 06 e0 0c ld [ %i3 + 0xc ], %g2
for (fd = f->dents; fd; fd=fd->next) {
40004db4: f6 06 e0 04 ld [ %i3 + 4 ], %i3
40004db8: 80 a6 e0 00 cmp %i3, 0
40004dbc: 32 bf ff fb bne,a 40004da8 <jffs2_garbage_collect_pass+0x720> <== ALWAYS TAKEN
40004dc0: c4 06 c0 00 ld [ %i3 ], %g2
pr_warn("Raw node at 0x%08x wasn't in node lists for ino #%u\n",
40004dc4: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1 <== NOT EXECUTED
40004dc8: d2 07 60 04 ld [ %i5 + 4 ], %o1 <== NOT EXECUTED
40004dcc: d4 00 60 0c ld [ %g1 + 0xc ], %o2 <== NOT EXECUTED
40004dd0: 92 0a 7f fc and %o1, -4, %o1 <== NOT EXECUTED
40004dd4: 11 10 00 7b sethi %hi(0x4001ec00), %o0 <== NOT EXECUTED
40004dd8: 7f ff fd 19 call 4000423c <jffs2_printk> <== NOT EXECUTED
40004ddc: 90 12 20 f8 or %o0, 0xf8, %o0 ! 4001ecf8 <rtems_jffs2_directory_handlers+0xb7c><== NOT EXECUTED
if (ref_obsolete(raw)) {
40004de0: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
40004de4: 82 08 60 03 and %g1, 3, %g1 <== NOT EXECUTED
40004de8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
40004dec: 12 80 00 ba bne 400050d4 <jffs2_garbage_collect_pass+0xa4c> <== NOT EXECUTED
40004df0: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
int ret = 0;
40004df4: b8 10 20 00 clr %i4 <== NOT EXECUTED
pr_warn("But it's obsolete so we don't mind too much\n");
40004df8: 11 10 00 7b sethi %hi(0x4001ec00), %o0 <== NOT EXECUTED
40004dfc: 7f ff fd 10 call 4000423c <jffs2_printk> <== NOT EXECUTED
40004e00: 90 12 20 88 or %o0, 0x88, %o0 ! 4001ec88 <rtems_jffs2_directory_handlers+0xb0c><== NOT EXECUTED
40004e04: 10 bf ff 58 b 40004b64 <jffs2_garbage_collect_pass+0x4dc> <== NOT EXECUTED
40004e08: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
if (fn) {
40004e0c: 22 bf ff e5 be,a 40004da0 <jffs2_garbage_collect_pass+0x718> <== NOT EXECUTED
40004e10: c2 06 a0 0c ld [ %i2 + 0xc ], %g1 <== NOT EXECUTED
if (ref_flags(raw) == REF_PRISTINE) {
40004e14: c2 07 60 04 ld [ %i5 + 4 ], %g1
40004e18: 82 08 60 03 and %g1, 3, %g1
40004e1c: 80 a0 60 02 cmp %g1, 2
40004e20: 22 80 02 30 be,a 400056e0 <jffs2_garbage_collect_pass+0x1058> <== NEVER TAKEN
40004e24: d2 06 a0 14 ld [ %i2 + 0x14 ], %o1 <== NOT EXECUTED
if((start >> PAGE_SHIFT) < ((end-1) >> PAGE_SHIFT)) {
40004e28: a4 06 ff ff add %i3, -1, %l2
40004e2c: 83 34 60 0c srl %l1, 0xc, %g1
40004e30: 85 34 a0 0c srl %l2, 0xc, %g2
40004e34: 80 a0 40 02 cmp %g1, %g2
40004e38: 3a 80 01 46 bcc,a 40005350 <jffs2_garbage_collect_pass+0xcc8> <== ALWAYS TAKEN
40004e3c: c0 27 bf ac clr [ %fp + -84 ]
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));
40004e40: ba 07 bf bc add %fp, -68, %i5 <== NOT EXECUTED
40004e44: 94 10 20 44 mov 0x44, %o2 <== NOT EXECUTED
40004e48: 92 10 20 00 clr %o1 <== NOT EXECUTED
40004e4c: 40 00 60 76 call 4001d024 <memset> <== NOT EXECUTED
40004e50: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if(fn->frags > 1) {
40004e54: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
40004e58: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
40004e5c: 08 80 01 22 bleu 400052e4 <jffs2_garbage_collect_pass+0xc5c> <== NOT EXECUTED
40004e60: b8 07 bf b8 add %fp, -72, %i4 <== 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);
40004e64: c2 06 40 00 ld [ %i1 ], %g1 <== NOT EXECUTED
40004e68: d2 00 60 04 ld [ %g1 + 4 ], %o1 <== NOT EXECUTED
40004e6c: 94 10 20 44 mov 0x44, %o2 <== NOT EXECUTED
40004e70: 92 0a 7f fc and %o1, -4, %o1 <== NOT EXECUTED
40004e74: b8 07 bf b8 add %fp, -72, %i4 <== NOT EXECUTED
40004e78: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
40004e7c: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
40004e80: 40 00 1f f0 call 4000ce40 <jffs2_flash_read> <== NOT EXECUTED
40004e84: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (readlen != sizeof(ri) || ret) {
40004e88: d4 07 bf b8 ld [ %fp + -72 ], %o2 <== NOT EXECUTED
40004e8c: 80 a2 a0 44 cmp %o2, 0x44 <== NOT EXECUTED
40004e90: 12 80 01 12 bne 400052d8 <jffs2_garbage_collect_pass+0xc50> <== NOT EXECUTED
40004e94: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40004e98: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40004e9c: 12 80 01 0f bne 400052d8 <jffs2_garbage_collect_pass+0xc50> <== NOT EXECUTED
40004ea0: d6 17 bf be lduh [ %fp + -66 ], %o3 <== 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) {
40004ea4: 19 00 00 38 sethi %hi(0xe000), %o4 <== NOT EXECUTED
40004ea8: 98 13 20 02 or %o4, 2, %o4 ! e002 <_ISR_Stack_size+0xd002> <== NOT EXECUTED
40004eac: 80 a2 c0 0c cmp %o3, %o4 <== NOT EXECUTED
40004eb0: 32 80 03 0e bne,a 40005ae8 <jffs2_garbage_collect_pass+0x1460> <== NOT EXECUTED
40004eb4: c2 06 40 00 ld [ %i1 ], %g1 <== 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)) {
40004eb8: d6 07 bf c0 ld [ %fp + -64 ], %o3 <== NOT EXECUTED
40004ebc: 80 a2 e0 44 cmp %o3, 0x44 <== NOT EXECUTED
40004ec0: 12 80 02 df bne 40005a3c <jffs2_garbage_collect_pass+0x13b4> <== NOT EXECUTED
40004ec4: 94 10 20 3c mov 0x3c, %o2 <== 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);
40004ec8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
40004ecc: 40 00 1b 2b call 4000bb78 <cyg_crc32_accumulate> <== NOT EXECUTED
40004ed0: 90 10 20 00 clr %o0 <== NOT EXECUTED
if (crc != je32_to_cpu(ri.node_crc)) {
40004ed4: d6 07 bf fc ld [ %fp + -4 ], %o3 <== NOT EXECUTED
40004ed8: 80 a2 00 0b cmp %o0, %o3 <== NOT EXECUTED
40004edc: 12 80 02 f9 bne 40005ac0 <jffs2_garbage_collect_pass+0x1438> <== NOT EXECUTED
40004ee0: 98 10 00 08 mov %o0, %o4 <== 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) {
40004ee4: c2 0f bf f4 ldub [ %fp + -12 ], %g1 <== NOT EXECUTED
40004ee8: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
40004eec: 32 80 02 e5 bne,a 40005a80 <jffs2_garbage_collect_pass+0x13f8> <== NOT EXECUTED
40004ef0: c2 06 40 00 ld [ %i1 ], %g1 <== NOT EXECUTED
}
static inline struct rb_node *rb_last( struct rb_root *root )
{
return _RBTree_Maximum( (RBTree_Control *) root );
40004ef4: 40 00 42 b3 call 400159c0 <_RBTree_Maximum> <== NOT EXECUTED
40004ef8: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
static inline struct jffs2_node_frag *frag_last(struct rb_root *root)
{
struct rb_node *node = rb_last(root);
if (!node)
40004efc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40004f00: 22 80 00 05 be,a 40004f14 <jffs2_garbage_collect_pass+0x88c> <== NOT EXECUTED
40004f04: c2 06 bf f4 ld [ %i2 + -12 ], %g1 <== 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;
40004f08: c2 02 20 18 ld [ %o0 + 0x18 ], %g1 <== NOT EXECUTED
40004f0c: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 <== NOT EXECUTED
40004f10: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED
return osmode & (S_IFMT | S_IRWXU | S_IRWXG | S_IRWXO);
40004f14: c4 06 bf c0 ld [ %i2 + -64 ], %g2 <== 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));
40004f18: da 16 bf c6 lduh [ %i2 + -58 ], %o5 <== NOT EXECUTED
ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
40004f1c: de 16 bf c8 lduh [ %i2 + -56 ], %o7 <== NOT EXECUTED
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));
40004f20: c8 06 bf e4 ld [ %i2 + -28 ], %g4 <== NOT EXECUTED
ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
40004f24: c6 06 bf dc ld [ %i2 + -36 ], %g3 <== NOT EXECUTED
ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
40004f28: f6 06 bf d4 ld [ %i2 + -44 ], %i3 <== NOT EXECUTED
ri.isize = cpu_to_je32(ilen);
40004f2c: c2 27 bf d8 st %g1, [ %fp + -40 ] <== NOT EXECUTED
40004f30: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
40004f34: 82 10 61 ff or %g1, 0x1ff, %g1 ! f1ff <_ISR_Stack_size+0xe1ff> <== NOT EXECUTED
40004f38: 82 08 80 01 and %g2, %g1, %g1 <== NOT EXECUTED
ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
40004f3c: da 37 bf d4 sth %o5, [ %fp + -44 ] <== NOT EXECUTED
ri.data_crc = cpu_to_je32(0);
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
40004f40: 94 10 20 3c mov 0x3c, %o2 <== NOT EXECUTED
ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
40004f44: de 37 bf d6 sth %o7, [ %fp + -42 ] <== NOT EXECUTED
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
40004f48: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
40004f4c: c2 27 bf d0 st %g1, [ %fp + -48 ] <== NOT EXECUTED
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
40004f50: 90 10 20 00 clr %o0 <== NOT EXECUTED
ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
40004f54: c8 27 bf e4 st %g4, [ %fp + -28 ] <== NOT EXECUTED
ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
40004f58: c6 27 bf e0 st %g3, [ %fp + -32 ] <== NOT EXECUTED
ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
40004f5c: f6 27 bf dc st %i3, [ %fp + -36 ] <== NOT EXECUTED
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
40004f60: 40 00 1b 06 call 4000bb78 <cyg_crc32_accumulate> <== NOT EXECUTED
40004f64: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
ret = jffs2_reserve_space_gc(c, sizeof(ri), &alloclen,
40004f68: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
40004f6c: d0 27 bf fc st %o0, [ %fp + -4 ] <== NOT EXECUTED
ret = jffs2_reserve_space_gc(c, sizeof(ri), &alloclen,
40004f70: 96 10 20 12 mov 0x12, %o3 <== NOT EXECUTED
40004f74: 92 10 20 44 mov 0x44, %o1 <== NOT EXECUTED
40004f78: 40 00 09 f4 call 40007748 <jffs2_reserve_space_gc> <== NOT EXECUTED
40004f7c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
JFFS2_SUMMARY_INODE_SIZE);
if (ret) {
40004f80: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40004f84: 12 80 02 e3 bne 40005b10 <jffs2_garbage_collect_pass+0x1488> <== NOT EXECUTED
40004f88: 94 10 00 1d mov %i5, %o2 <== 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);
40004f8c: 9a 10 20 02 mov 2, %o5 <== NOT EXECUTED
40004f90: 98 10 20 00 clr %o4 <== NOT EXECUTED
40004f94: 96 10 20 00 clr %o3 <== NOT EXECUTED
40004f98: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40004f9c: 40 00 14 59 call 4000a100 <jffs2_write_dnode> <== NOT EXECUTED
40004fa0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (IS_ERR(new_fn)) {
40004fa4: 80 a2 3c 18 cmp %o0, -1000 <== NOT EXECUTED
40004fa8: 18 80 00 c5 bgu 400052bc <jffs2_garbage_collect_pass+0xc34> <== NOT EXECUTED
40004fac: ba 10 00 08 mov %o0, %i5 <== 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) {
40004fb0: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
40004fb4: c4 07 bf cc ld [ %fp + -52 ], %g2 <== NOT EXECUTED
40004fb8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40004fbc: 02 80 00 b2 be 40005284 <jffs2_garbage_collect_pass+0xbfc> <== NOT EXECUTED
40004fc0: 94 10 00 08 mov %o0, %o2 <== 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);
40004fc4: c4 02 00 00 ld [ %o0 ], %g2 <== NOT EXECUTED
40004fc8: c2 00 a0 04 ld [ %g2 + 4 ], %g1 <== NOT EXECUTED
40004fcc: 82 10 60 03 or %g1, 3, %g1 <== NOT EXECUTED
40004fd0: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
for (frag = jffs2_lookup_node_frag(&f->fragtree, fn->ofs);
40004fd4: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
40004fd8: 40 00 06 1e call 40006850 <jffs2_lookup_node_frag> <== NOT EXECUTED
40004fdc: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
40004fe0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40004fe4: 22 80 00 2e be,a 4000509c <jffs2_garbage_collect_pass+0xa14> <== NOT EXECUTED
40004fe8: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
frag; frag = frag_next(frag)) {
if (frag->ofs > fn->size + fn->ofs)
40004fec: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
40004ff0: c6 06 60 04 ld [ %i1 + 4 ], %g3 <== NOT EXECUTED
40004ff4: c4 02 20 18 ld [ %o0 + 0x18 ], %g2 <== NOT EXECUTED
40004ff8: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
40004ffc: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
40005000: 38 80 00 27 bgu,a 4000509c <jffs2_garbage_collect_pass+0xa14> <== NOT EXECUTED
40005004: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
break;
if (frag->node == fn) {
40005008: c2 02 20 10 ld [ %o0 + 0x10 ], %g1 <== NOT EXECUTED
4000500c: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED
40005010: 22 80 00 1a be,a 40005078 <jffs2_garbage_collect_pass+0x9f0> <== NOT EXECUTED
40005014: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
return _RBTree_Successor( node );
40005018: 40 00 42 77 call 400159f4 <_RBTree_Successor> <== NOT EXECUTED
4000501c: 01 00 00 00 nop <== NOT EXECUTED
for (frag = jffs2_lookup_node_frag(&f->fragtree, fn->ofs);
40005020: 10 bf ff f1 b 40004fe4 <jffs2_garbage_collect_pass+0x95c> <== NOT EXECUTED
40005024: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
if (fd && fd->ino) {
40005028: 80 a0 a0 00 cmp %g2, 0
4000502c: 12 80 00 50 bne 4000516c <jffs2_garbage_collect_pass+0xae4> <== ALWAYS TAKEN
40005030: 84 06 a0 0c add %i2, 0xc, %g2
while (*fdp) {
40005034: 10 80 00 07 b 40005050 <jffs2_garbage_collect_pass+0x9c8> <== NOT EXECUTED
40005038: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
if ((*fdp) == fd) {
4000503c: 22 80 00 43 be,a 40005148 <jffs2_garbage_collect_pass+0xac0> <== NOT EXECUTED
40005040: c2 06 e0 04 ld [ %i3 + 4 ], %g1 <== NOT EXECUTED
fdp = &(*fdp)->next;
40005044: 84 00 60 04 add %g1, 4, %g2 <== NOT EXECUTED
40005048: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
while (*fdp) {
4000504c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005050: 12 bf ff fb bne 4000503c <jffs2_garbage_collect_pass+0x9b4> <== NOT EXECUTED
40005054: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
pr_warn("Deletion dirent \"%s\" not found in list for ino #%u\n",
40005058: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1 <== NOT EXECUTED
4000505c: d4 00 60 0c ld [ %g1 + 0xc ], %o2 <== NOT EXECUTED
40005060: 92 06 e0 15 add %i3, 0x15, %o1 <== NOT EXECUTED
40005064: 11 10 00 7b sethi %hi(0x4001ec00), %o0 <== NOT EXECUTED
40005068: 7f ff fc 75 call 4000423c <jffs2_printk> <== NOT EXECUTED
4000506c: 90 12 20 48 or %o0, 0x48, %o0 ! 4001ec48 <rtems_jffs2_directory_handlers+0xacc><== NOT EXECUTED
jffs2_mark_node_obsolete(c, fd->raw);
40005070: 10 80 00 38 b 40005150 <jffs2_garbage_collect_pass+0xac8> <== NOT EXECUTED
40005074: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
frag->node = new_fn;
40005078: fa 22 20 10 st %i5, [ %o0 + 0x10 ] <== NOT EXECUTED
new_fn->frags++;
4000507c: 82 00 60 01 inc %g1 <== NOT EXECUTED
40005080: c2 27 60 0c st %g1, [ %i5 + 0xc ] <== NOT EXECUTED
fn->frags--;
40005084: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
40005088: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
4000508c: 40 00 42 5a call 400159f4 <_RBTree_Successor> <== NOT EXECUTED
40005090: c2 26 60 0c st %g1, [ %i1 + 0xc ] <== NOT EXECUTED
for (frag = jffs2_lookup_node_frag(&f->fragtree, fn->ofs);
40005094: 10 bf ff d4 b 40004fe4 <jffs2_garbage_collect_pass+0x95c> <== NOT EXECUTED
40005098: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
}
}
if (fn->frags) {
4000509c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400050a0: 32 80 00 1f bne,a 4000511c <jffs2_garbage_collect_pass+0xa94> <== NOT EXECUTED
400050a4: 3b 10 00 7b sethi %hi(0x4001ec00), %i5 <== NOT EXECUTED
pr_warn("%s(): Old node still has frags!\n", __func__);
BUG();
}
if (!new_fn->frags) {
400050a8: c2 07 60 0c ld [ %i5 + 0xc ], %g1 ! 4001ec0c <rtems_jffs2_directory_handlers+0xa90><== NOT EXECUTED
400050ac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
400050b0: 22 80 00 10 be,a 400050f0 <jffs2_garbage_collect_pass+0xa68> <== NOT EXECUTED
400050b4: 3b 10 00 7b sethi %hi(0x4001ec00), %i5 <== NOT EXECUTED
pr_warn("%s(): New node has no frags!\n", __func__);
BUG();
}
jffs2_mark_node_obsolete(c, fn->raw);
400050b8: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
400050bc: 40 00 07 95 call 40006f10 <jffs2_mark_node_obsolete> <== NOT EXECUTED
400050c0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
jffs2_free_full_dnode(fn);
400050c4: 40 00 02 b9 call 40005ba8 <jffs2_free_full_dnode> <== NOT EXECUTED
400050c8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
return 0;
400050cc: 10 bf fe a6 b 40004b64 <jffs2_garbage_collect_pass+0x4dc> <== NOT EXECUTED
400050d0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
BUG();
400050d4: 15 10 00 7b sethi %hi(0x4001ec00), %o2 <== NOT EXECUTED
400050d8: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
400050dc: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
400050e0: 94 12 a1 78 or %o2, 0x178, %o2 <== NOT EXECUTED
400050e4: 92 10 22 48 mov 0x248, %o1 <== NOT EXECUTED
400050e8: 40 00 26 24 call 4000e978 <__assert_func> <== NOT EXECUTED
400050ec: 90 12 21 70 or %o0, 0x170, %o0 <== NOT EXECUTED
pr_warn("%s(): New node has no frags!\n", __func__);
400050f0: 11 10 00 7a sethi %hi(0x4001e800), %o0 <== NOT EXECUTED
400050f4: 92 17 61 58 or %i5, 0x158, %o1 <== NOT EXECUTED
400050f8: 7f ff fc 51 call 4000423c <jffs2_printk> <== NOT EXECUTED
400050fc: 90 12 22 f0 or %o0, 0x2f0, %o0 <== NOT EXECUTED
BUG();
40005100: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
40005104: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
40005108: 94 17 61 58 or %i5, 0x158, %o2 <== NOT EXECUTED
4000510c: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
40005110: 92 10 24 8b mov 0x48b, %o1 <== NOT EXECUTED
40005114: 40 00 26 19 call 4000e978 <__assert_func> <== NOT EXECUTED
40005118: 90 12 21 70 or %o0, 0x170, %o0 <== NOT EXECUTED
pr_warn("%s(): Old node still has frags!\n", __func__);
4000511c: 11 10 00 7a sethi %hi(0x4001e800), %o0 <== NOT EXECUTED
40005120: 92 17 61 58 or %i5, 0x158, %o1 <== NOT EXECUTED
40005124: 7f ff fc 46 call 4000423c <jffs2_printk> <== NOT EXECUTED
40005128: 90 12 22 c0 or %o0, 0x2c0, %o0 <== NOT EXECUTED
BUG();
4000512c: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
40005130: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
40005134: 94 17 61 58 or %i5, 0x158, %o2 <== NOT EXECUTED
40005138: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
4000513c: 92 10 24 87 mov 0x487, %o1 <== NOT EXECUTED
40005140: 40 00 26 0e call 4000e978 <__assert_func> <== NOT EXECUTED
40005144: 90 12 21 70 or %o0, 0x170, %o0 <== NOT EXECUTED
*fdp = fd->next;
40005148: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
jffs2_mark_node_obsolete(c, fd->raw);
4000514c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40005150: 40 00 07 70 call 40006f10 <jffs2_mark_node_obsolete> <== NOT EXECUTED
40005154: d2 06 c0 00 ld [ %i3 ], %o1 <== NOT EXECUTED
ret = jffs2_garbage_collect_deletion_dirent(c, jeb, f, fd);
40005158: b8 10 20 00 clr %i4 <== NOT EXECUTED
jffs2_free_full_dirent(fd);
4000515c: 40 00 02 8c call 40005b8c <jffs2_free_full_dirent> <== NOT EXECUTED
40005160: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
return 0;
40005164: 10 bf fe 80 b 40004b64 <jffs2_garbage_collect_pass+0x4dc> <== NOT EXECUTED
40005168: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
rd.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
4000516c: 03 00 00 06 sethi %hi(0x1800), %g1
40005170: 82 10 61 85 or %g1, 0x185, %g1 ! 1985 <_ISR_Stack_size+0x985>
40005174: c2 37 bf bc sth %g1, [ %fp + -68 ]
rd.nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
40005178: 03 3f ff f8 sethi %hi(0xffffe000), %g1
4000517c: 82 10 60 01 or %g1, 1, %g1 ! ffffe001 <RAM_END+0xbfbfe001>
rd.nsize = strlen(fd->name);
40005180: b2 06 e0 15 add %i3, 0x15, %i1
rd.nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
40005184: c2 37 bf be sth %g1, [ %fp + -66 ]
rd.nsize = strlen(fd->name);
40005188: 40 00 60 99 call 4001d3ec <strlen>
4000518c: 90 10 00 19 mov %i1, %o0
rd.totlen = cpu_to_je32(sizeof(rd) + rd.nsize);
40005190: 82 0a 20 ff and %o0, 0xff, %g1
40005194: 82 00 60 28 add %g1, 0x28, %g1
rd.nsize = strlen(fd->name);
40005198: d0 2f bf d8 stb %o0, [ %fp + -40 ]
rd.hdr_crc = cpu_to_je32(crc32(0, &rd, sizeof(struct jffs2_unknown_node)-4));
4000519c: ba 07 bf bc add %fp, -68, %i5
rd.totlen = cpu_to_je32(sizeof(rd) + rd.nsize);
400051a0: c2 27 bf c0 st %g1, [ %fp + -64 ]
rd.hdr_crc = cpu_to_je32(crc32(0, &rd, sizeof(struct jffs2_unknown_node)-4));
400051a4: 94 10 20 08 mov 8, %o2
400051a8: 92 10 00 1d mov %i5, %o1
400051ac: 40 00 1a 73 call 4000bb78 <cyg_crc32_accumulate>
400051b0: 90 10 20 00 clr %o0
rd.pino = cpu_to_je32(f->inocache->ino);
400051b4: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1
400051b8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
rd.version = cpu_to_je32(++f->highest_version);
400051bc: c2 06 80 00 ld [ %i2 ], %g1
rd.pino = cpu_to_je32(f->inocache->ino);
400051c0: c4 27 bf c8 st %g2, [ %fp + -56 ]
rd.version = cpu_to_je32(++f->highest_version);
400051c4: 82 00 60 01 inc %g1
rd.hdr_crc = cpu_to_je32(crc32(0, &rd, sizeof(struct jffs2_unknown_node)-4));
400051c8: d0 27 bf c4 st %o0, [ %fp + -60 ]
rd.version = cpu_to_je32(++f->highest_version);
400051cc: c2 26 80 00 st %g1, [ %i2 ]
rd.ino = cpu_to_je32(fd->ino);
400051d0: c4 06 e0 0c ld [ %i3 + 0xc ], %g2
400051d4: c4 27 bf d0 st %g2, [ %fp + -48 ]
rd.version = cpu_to_je32(++f->highest_version);
400051d8: c2 27 bf cc st %g1, [ %fp + -52 ]
if (JFFS2_F_I_MTIME(f) == JFFS2_F_I_CTIME(f))
400051dc: c4 06 bf e0 ld [ %i2 + -32 ], %g2
400051e0: c6 06 bf d8 ld [ %i2 + -40 ], %g3
400051e4: 80 a0 c0 02 cmp %g3, %g2
400051e8: 02 80 02 51 be 40005b2c <jffs2_garbage_collect_pass+0x14a4> <== ALWAYS TAKEN
400051ec: c2 06 bf e4 ld [ %i2 + -28 ], %g1
400051f0: 82 10 20 00 clr %g1 <== NOT EXECUTED
400051f4: c2 27 bf d4 st %g1, [ %fp + -44 ] <== NOT EXECUTED
rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8));
400051f8: 94 10 20 20 mov 0x20, %o2
rd.type = fd->type;
400051fc: c2 0e e0 14 ldub [ %i3 + 0x14 ], %g1
40005200: c2 2f bf d9 stb %g1, [ %fp + -39 ]
rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8));
40005204: 92 10 00 1d mov %i5, %o1
40005208: 40 00 1a 5c call 4000bb78 <cyg_crc32_accumulate>
4000520c: 90 10 20 00 clr %o0
rd.name_crc = cpu_to_je32(crc32(0, fd->name, rd.nsize));
40005210: d4 0f bf d8 ldub [ %fp + -40 ], %o2
rd.node_crc = cpu_to_je32(crc32(0, &rd, sizeof(rd)-8));
40005214: d0 27 bf dc st %o0, [ %fp + -36 ]
rd.name_crc = cpu_to_je32(crc32(0, fd->name, rd.nsize));
40005218: 92 10 00 19 mov %i1, %o1
4000521c: 40 00 1a 57 call 4000bb78 <cyg_crc32_accumulate>
40005220: 90 10 20 00 clr %o0
ret = jffs2_reserve_space_gc(c, sizeof(rd)+rd.nsize, &alloclen,
40005224: d2 0f bf d8 ldub [ %fp + -40 ], %o1
rd.name_crc = cpu_to_je32(crc32(0, fd->name, rd.nsize));
40005228: d0 27 bf e0 st %o0, [ %fp + -32 ]
ret = jffs2_reserve_space_gc(c, sizeof(rd)+rd.nsize, &alloclen,
4000522c: 96 02 60 18 add %o1, 0x18, %o3
40005230: 94 07 bf b8 add %fp, -72, %o2
40005234: 92 02 60 28 add %o1, 0x28, %o1
40005238: 40 00 09 44 call 40007748 <jffs2_reserve_space_gc>
4000523c: 90 10 00 18 mov %i0, %o0
if (ret) {
40005240: b8 92 20 00 orcc %o0, 0, %i4
40005244: 12 80 02 40 bne 40005b44 <jffs2_garbage_collect_pass+0x14bc> <== NEVER TAKEN
40005248: d8 0f bf d8 ldub [ %fp + -40 ], %o4
new_fd = jffs2_write_dirent(c, f, &rd, fd->name, rd.nsize, ALLOC_GC);
4000524c: 92 10 00 1a mov %i2, %o1
40005250: 9a 10 20 02 mov 2, %o5
40005254: 96 10 00 19 mov %i1, %o3
40005258: 94 10 00 1d mov %i5, %o2
4000525c: 40 00 14 b7 call 4000a538 <jffs2_write_dirent>
40005260: 90 10 00 18 mov %i0, %o0
if (IS_ERR(new_fd)) {
40005264: 80 a2 3c 18 cmp %o0, -1000
40005268: 18 80 02 3f bgu 40005b64 <jffs2_garbage_collect_pass+0x14dc> <== NEVER TAKEN
4000526c: 92 10 00 08 mov %o0, %o1
jffs2_add_fd_to_list(c, new_fd, &f->dents);
40005270: 94 06 a0 0c add %i2, 0xc, %o2
40005274: 40 00 02 f0 call 40005e34 <jffs2_add_fd_to_list>
40005278: 90 10 00 18 mov %i0, %o0
ret = jffs2_garbage_collect_dirent(c, jeb, f, fd);
4000527c: 10 bf fe 3a b 40004b64 <jffs2_garbage_collect_pass+0x4dc>
40005280: 92 10 00 1a mov %i2, %o1
jffs2_add_full_dnode_to_inode(c, f, new_fn);
40005284: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40005288: 40 00 03 83 call 40006094 <jffs2_add_full_dnode_to_inode> <== NOT EXECUTED
4000528c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (f->metadata) {
40005290: c2 06 a0 08 ld [ %i2 + 8 ], %g1 <== NOT EXECUTED
40005294: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40005298: 02 bf fe 33 be 40004b64 <jffs2_garbage_collect_pass+0x4dc> <== NOT EXECUTED
4000529c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
jffs2_mark_node_obsolete(c, f->metadata->raw);
400052a0: d2 00 40 00 ld [ %g1 ], %o1 <== NOT EXECUTED
400052a4: 40 00 07 1b call 40006f10 <jffs2_mark_node_obsolete> <== NOT EXECUTED
400052a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
jffs2_free_full_dnode(f->metadata);
400052ac: 40 00 02 3f call 40005ba8 <jffs2_free_full_dnode> <== NOT EXECUTED
400052b0: d0 06 a0 08 ld [ %i2 + 8 ], %o0 <== NOT EXECUTED
f->metadata = NULL;
400052b4: 10 bf fe 2b b 40004b60 <jffs2_garbage_collect_pass+0x4d8> <== NOT EXECUTED
400052b8: c0 26 a0 08 clr [ %i2 + 8 ] <== NOT EXECUTED
pr_warn("Error writing new hole node: %ld\n", PTR_ERR(new_fn));
400052bc: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
return PTR_ERR(new_fn);
400052c0: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
pr_warn("Error writing new hole node: %ld\n", PTR_ERR(new_fn));
400052c4: 11 10 00 7a sethi %hi(0x4001e800), %o0 <== NOT EXECUTED
400052c8: 7f ff fb dd call 4000423c <jffs2_printk> <== NOT EXECUTED
400052cc: 90 12 22 90 or %o0, 0x290, %o0 ! 4001ea90 <rtems_jffs2_directory_handlers+0x914><== NOT EXECUTED
return PTR_ERR(new_fn);
400052d0: 10 bf fe 25 b 40004b64 <jffs2_garbage_collect_pass+0x4dc> <== NOT EXECUTED
400052d4: 92 10 00 1a mov %i2, %o1 <== 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",
400052d8: 11 10 00 7a sethi %hi(0x4001e800), %o0 <== NOT EXECUTED
400052dc: 7f ff fb d8 call 4000423c <jffs2_printk> <== NOT EXECUTED
400052e0: 90 12 20 30 or %o0, 0x30, %o0 ! 4001e830 <rtems_jffs2_directory_handlers+0x6b4><== NOT EXECUTED
ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
400052e4: 03 00 00 06 sethi %hi(0x1800), %g1 <== NOT EXECUTED
400052e8: 82 10 61 85 or %g1, 0x185, %g1 ! 1985 <_ISR_Stack_size+0x985> <== NOT EXECUTED
400052ec: c2 37 bf bc sth %g1, [ %fp + -68 ] <== NOT EXECUTED
ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
400052f0: 03 3f ff f8 sethi %hi(0xffffe000), %g1 <== NOT EXECUTED
400052f4: 82 10 60 02 or %g1, 2, %g1 ! ffffe002 <RAM_END+0xbfbfe002> <== NOT EXECUTED
400052f8: c2 37 bf be sth %g1, [ %fp + -66 ] <== NOT EXECUTED
ri.totlen = cpu_to_je32(sizeof(ri));
400052fc: 82 10 20 44 mov 0x44, %g1 <== NOT EXECUTED
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
40005300: 94 10 20 08 mov 8, %o2 <== NOT EXECUTED
ri.totlen = cpu_to_je32(sizeof(ri));
40005304: c2 27 bf c0 st %g1, [ %fp + -64 ] <== NOT EXECUTED
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
40005308: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000530c: 40 00 1a 1b call 4000bb78 <cyg_crc32_accumulate> <== NOT EXECUTED
40005310: 90 10 20 00 clr %o0 <== NOT EXECUTED
ri.ino = cpu_to_je32(f->inocache->ino);
40005314: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1 <== NOT EXECUTED
40005318: c4 00 60 0c ld [ %g1 + 0xc ], %g2 <== NOT EXECUTED
ri.version = cpu_to_je32(++f->highest_version);
4000531c: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
40005320: d0 27 bf c4 st %o0, [ %fp + -60 ] <== NOT EXECUTED
ri.version = cpu_to_je32(++f->highest_version);
40005324: 82 00 60 01 inc %g1 <== NOT EXECUTED
ri.ino = cpu_to_je32(f->inocache->ino);
40005328: c4 27 bf c8 st %g2, [ %fp + -56 ] <== NOT EXECUTED
ri.dsize = cpu_to_je32(end - start);
4000532c: b6 26 c0 11 sub %i3, %l1, %i3 <== NOT EXECUTED
ri.version = cpu_to_je32(++f->highest_version);
40005330: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
40005334: c2 27 bf cc st %g1, [ %fp + -52 ] <== NOT EXECUTED
ri.compr = JFFS2_COMPR_ZERO;
40005338: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
ri.offset = cpu_to_je32(start);
4000533c: e2 27 bf e8 st %l1, [ %fp + -24 ] <== NOT EXECUTED
ri.dsize = cpu_to_je32(end - start);
40005340: f6 27 bf f0 st %i3, [ %fp + -16 ] <== NOT EXECUTED
ri.csize = cpu_to_je32(0);
40005344: c0 27 bf ec clr [ %fp + -20 ] <== NOT EXECUTED
ri.compr = JFFS2_COMPR_ZERO;
40005348: 10 bf fe eb b 40004ef4 <jffs2_garbage_collect_pass+0x86c> <== NOT EXECUTED
4000534c: c2 2f bf f4 stb %g1, [ %fp + -12 ] <== NOT EXECUTED
int ret = 0;
unsigned char *comprbuf = NULL, *writebuf;
unsigned long pg;
unsigned char *pg_ptr;
memset(&ri, 0, sizeof(ri));
40005350: ba 07 bf bc add %fp, -68, %i5
40005354: 94 10 20 44 mov 0x44, %o2
40005358: 92 10 20 00 clr %o1
4000535c: 40 00 5f 32 call 4001d024 <memset>
40005360: 90 10 00 1d mov %i5, %o0
f->inocache->ino, start, end);
orig_end = end;
orig_start = start;
if (c->nr_free_blocks + c->nr_erasing_blocks > c->resv_blocks_gcmerge) {
40005364: c2 06 20 3c ld [ %i0 + 0x3c ], %g1
40005368: c6 06 20 40 ld [ %i0 + 0x40 ], %g3
4000536c: c4 0e 20 48 ldub [ %i0 + 0x48 ], %g2
40005370: 82 00 40 03 add %g1, %g3, %g1
40005374: 80 a0 40 02 cmp %g1, %g2
40005378: 28 80 01 1b bleu,a 400057e4 <jffs2_garbage_collect_pass+0x115c>
4000537c: a4 10 00 1b mov %i3, %l2
uint32_t min, max;
min = start & ~(PAGE_SIZE-1);
max = min + PAGE_SIZE;
frag = jffs2_lookup_node_frag(&f->fragtree, start);
40005380: 92 10 00 11 mov %l1, %o1
40005384: 40 00 05 33 call 40006850 <jffs2_lookup_node_frag>
40005388: 90 10 00 14 mov %l4, %o0
/* BUG_ON(!frag) but that'll happen anyway... */
BUG_ON(frag->ofs != start);
4000538c: c2 02 20 18 ld [ %o0 + 0x18 ], %g1
min = start & ~(PAGE_SIZE-1);
40005390: aa 0c 70 00 and %l1, -4096, %l5
max = min + PAGE_SIZE;
40005394: b2 10 00 11 mov %l1, %i1
BUG_ON(frag->ofs != start);
40005398: 80 a0 40 11 cmp %g1, %l1
4000539c: 12 80 01 0a bne 400057c4 <jffs2_garbage_collect_pass+0x113c> <== NEVER TAKEN
400053a0: b8 25 70 00 sub %l5, -4096, %i4
return _RBTree_Predecessor( node );
400053a4: 40 00 41 b7 call 40015a80 <_RBTree_Predecessor>
400053a8: 01 00 00 00 nop
/* First grow down... */
while((frag = frag_prev(frag)) && frag->ofs >= min) {
400053ac: 80 a2 20 00 cmp %o0, 0
400053b0: 02 80 00 25 be 40005444 <jffs2_garbage_collect_pass+0xdbc>
400053b4: 92 10 00 12 mov %l2, %o1
400053b8: c4 02 20 18 ld [ %o0 + 0x18 ], %g2
400053bc: 80 a5 40 02 cmp %l5, %g2
400053c0: 38 80 00 22 bgu,a 40005448 <jffs2_garbage_collect_pass+0xdc0>
400053c4: 90 10 00 14 mov %l4, %o0
/* If the previous frag doesn't even reach the beginning, there's
excessive fragmentation. Just merge. */
if (frag->ofs > min) {
400053c8: 2a bf ff f7 bcs,a 400053a4 <jffs2_garbage_collect_pass+0xd1c> <== NEVER TAKEN
400053cc: b2 10 00 02 mov %g2, %i1 <== NOT EXECUTED
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) {
400053d0: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
400053d4: 80 a0 60 00 cmp %g1, 0
400053d8: 22 80 00 1c be,a 40005448 <jffs2_garbage_collect_pass+0xdc0> <== NEVER TAKEN
400053dc: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
400053e0: c6 00 40 00 ld [ %g1 ], %g3
400053e4: 80 a0 e0 00 cmp %g3, 0
400053e8: 22 80 00 18 be,a 40005448 <jffs2_garbage_collect_pass+0xdc0> <== NEVER TAKEN
400053ec: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
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];
400053f0: c2 06 20 54 ld [ %i0 + 0x54 ], %g1
if (jeb == c->gcblock) {
400053f4: c8 06 20 5c ld [ %i0 + 0x5c ], %g4
jeb = &c->blocks[raw->flash_offset / c->sector_size];
400053f8: de 00 e0 04 ld [ %g3 + 4 ], %o7
400053fc: 81 80 20 00 wr %g0, %y
40005400: c6 06 20 34 ld [ %i0 + 0x34 ], %g3
40005404: 01 00 00 00 nop
40005408: 01 00 00 00 nop
4000540c: 86 73 c0 03 udiv %o7, %g3, %g3
40005410: 86 58 e0 34 smul %g3, 0x34, %g3
40005414: 82 00 40 03 add %g1, %g3, %g1
if (jeb == c->gcblock) {
40005418: 80 a0 40 04 cmp %g1, %g4
4000541c: 22 80 00 0a be,a 40005444 <jffs2_garbage_collect_pass+0xdbc> <== NEVER TAKEN
40005420: b2 10 00 02 mov %g2, %i1 <== NOT EXECUTED
frag->ofs + frag->size,
ref_offset(raw));
start = frag->ofs;
break;
}
if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) {
40005424: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
40005428: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4000542c: 82 00 c0 01 add %g3, %g1, %g1
40005430: 80 a0 60 c4 cmp %g1, 0xc4
40005434: 08 80 00 05 bleu 40005448 <jffs2_garbage_collect_pass+0xdc0> <== NEVER TAKEN
40005438: 90 10 00 14 mov %l4, %o0
while((frag = frag_prev(frag)) && frag->ofs >= min) {
4000543c: b2 10 00 02 mov %g2, %i1
}
/* ... 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);
40005440: 92 10 00 12 mov %l2, %o1
40005444: 90 10 00 14 mov %l4, %o0
40005448: 40 00 05 02 call 40006850 <jffs2_lookup_node_frag>
4000544c: a4 10 00 1b mov %i3, %l2
return _RBTree_Successor( node );
40005450: 40 00 41 69 call 400159f4 <_RBTree_Successor>
40005454: 01 00 00 00 nop
while((frag = frag_next(frag)) && frag->ofs+frag->size <= max) {
40005458: 80 a2 20 00 cmp %o0, 0
4000545c: 02 80 00 27 be 400054f8 <jffs2_garbage_collect_pass+0xe70>
40005460: 80 a4 80 1b cmp %l2, %i3
40005464: c2 02 20 18 ld [ %o0 + 0x18 ], %g1
40005468: c4 02 20 14 ld [ %o0 + 0x14 ], %g2
4000546c: 82 00 40 02 add %g1, %g2, %g1
40005470: 80 a7 00 01 cmp %i4, %g1
40005474: 2a 80 00 21 bcs,a 400054f8 <jffs2_garbage_collect_pass+0xe70>
40005478: 80 a4 80 1b cmp %l2, %i3
/* If the previous frag doesn't even reach the beginning, there's lots
of fragmentation. Just merge. */
if (frag->ofs+frag->size < max) {
4000547c: 38 bf ff f5 bgu,a 40005450 <jffs2_garbage_collect_pass+0xdc8>
40005480: a4 10 00 01 mov %g1, %l2
frag->ofs, frag->ofs+frag->size);
end = frag->ofs + frag->size;
continue;
}
if (!frag->node || !frag->node->raw) {
40005484: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
40005488: 80 a0 a0 00 cmp %g2, 0
4000548c: 02 80 00 1b be 400054f8 <jffs2_garbage_collect_pass+0xe70> <== NEVER TAKEN
40005490: 80 a4 80 1b cmp %l2, %i3
40005494: c6 00 80 00 ld [ %g2 ], %g3
40005498: 80 a0 e0 00 cmp %g3, 0
4000549c: 02 80 00 17 be 400054f8 <jffs2_garbage_collect_pass+0xe70> <== NEVER TAKEN
400054a0: 80 a4 80 1b cmp %l2, %i3
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];
400054a4: c4 06 20 54 ld [ %i0 + 0x54 ], %g2
if (jeb == c->gcblock) {
400054a8: c8 06 20 5c ld [ %i0 + 0x5c ], %g4
jeb = &c->blocks[raw->flash_offset / c->sector_size];
400054ac: f8 00 e0 04 ld [ %g3 + 4 ], %i4
400054b0: 81 80 20 00 wr %g0, %y
400054b4: c6 06 20 34 ld [ %i0 + 0x34 ], %g3
400054b8: 01 00 00 00 nop
400054bc: 01 00 00 00 nop
400054c0: 86 77 00 03 udiv %i4, %g3, %g3
400054c4: 86 58 e0 34 smul %g3, 0x34, %g3
400054c8: 84 00 80 03 add %g2, %g3, %g2
if (jeb == c->gcblock) {
400054cc: 80 a0 80 04 cmp %g2, %g4
400054d0: 22 80 00 09 be,a 400054f4 <jffs2_garbage_collect_pass+0xe6c> <== NEVER TAKEN
400054d4: a4 10 00 01 mov %g1, %l2 <== NOT EXECUTED
frag->ofs + frag->size,
ref_offset(raw));
end = frag->ofs + frag->size;
break;
}
if (!ISDIRTY(jeb->dirty_size + jeb->wasted_size)) {
400054d8: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
400054dc: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
400054e0: 84 00 c0 02 add %g3, %g2, %g2
400054e4: 80 a0 a0 c4 cmp %g2, 0xc4
400054e8: 08 80 00 04 bleu 400054f8 <jffs2_garbage_collect_pass+0xe70> <== NEVER TAKEN
400054ec: 80 a4 80 1b cmp %l2, %i3
while((frag = frag_next(frag)) && frag->ofs+frag->size <= max) {
400054f0: a4 10 00 01 mov %g1, %l2
}
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);
400054f4: 80 a4 80 1b cmp %l2, %i3
400054f8: 0a 80 00 ab bcs 400057a4 <jffs2_garbage_collect_pass+0x111c> <== NEVER TAKEN
400054fc: 80 a6 40 11 cmp %i1, %l1
BUG_ON(start > orig_start);
40005500: 18 80 00 a2 bgu 40005788 <jffs2_garbage_collect_pass+0x1100> <== NEVER TAKEN
40005504: 17 10 00 76 sethi %hi(0x4001d800), %o3
* 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);
40005508: 94 10 00 19 mov %i1, %o2
4000550c: 96 07 bf b0 add %fp, -80, %o3
40005510: 92 10 00 1a mov %i2, %o1
40005514: 90 10 00 18 mov %i0, %o0
40005518: 7f ff f8 9b call 40003784 <jffs2_gc_fetch_page>
4000551c: b8 10 20 00 clr %i4
mutex_lock(&f->sem);
if (IS_ERR(pg_ptr)) {
40005520: 80 a2 3c 18 cmp %o0, -1000
40005524: 18 80 00 92 bgu 4000576c <jffs2_garbage_collect_pass+0x10e4> <== NEVER TAKEN
40005528: a2 10 00 08 mov %o0, %l1
writebuf = pg_ptr + (offset & (PAGE_SIZE -1));
comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen);
ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
4000552c: 2d 00 00 06 sethi %hi(0x1800), %l6
ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
40005530: 2b 3f ff f8 sethi %hi(0xffffe000), %l5
40005534: 29 00 00 3c sethi %hi(0xf000), %l4
ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
40005538: ac 15 a1 85 or %l6, 0x185, %l6
ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
4000553c: aa 15 60 02 or %l5, 2, %l5
40005540: a8 15 21 ff or %l4, 0x1ff, %l4
while(offset < orig_end) {
40005544: 80 a6 40 1b cmp %i1, %i3
40005548: 1a 80 00 7c bcc 40005738 <jffs2_garbage_collect_pass+0x10b0>
4000554c: 96 10 20 12 mov 0x12, %o3
ret = jffs2_reserve_space_gc(c, sizeof(ri) + JFFS2_MIN_DATA_LEN,
40005550: 94 07 bf a8 add %fp, -88, %o2
40005554: 92 10 20 c4 mov 0xc4, %o1
40005558: 40 00 08 7c call 40007748 <jffs2_reserve_space_gc>
4000555c: 90 10 00 18 mov %i0, %o0
if (ret) {
40005560: b8 92 20 00 orcc %o0, 0, %i4
40005564: 12 80 00 70 bne 40005724 <jffs2_garbage_collect_pass+0x109c> <== NEVER TAKEN
40005568: c2 07 bf a8 ld [ %fp + -88 ], %g1
cdatalen = min_t(uint32_t, alloclen - sizeof(ri), end - offset);
4000556c: 84 24 80 19 sub %l2, %i1, %g2
40005570: 82 00 7f bc add %g1, -68, %g1
40005574: 80 a0 40 02 cmp %g1, %g2
40005578: 38 80 00 02 bgu,a 40005580 <jffs2_garbage_collect_pass+0xef8>
4000557c: 82 10 00 02 mov %g2, %g1
datalen = end - offset;
40005580: c4 27 bf b4 st %g2, [ %fp + -76 ]
comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen);
40005584: 9a 07 bf b8 add %fp, -72, %o5
40005588: 98 07 bf b4 add %fp, -76, %o4
4000558c: 96 07 bf ac add %fp, -84, %o3
cdatalen = min_t(uint32_t, alloclen - sizeof(ri), end - offset);
40005590: c2 27 bf b8 st %g1, [ %fp + -72 ]
comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen);
40005594: 92 10 00 1a mov %i2, %o1
writebuf = pg_ptr + (offset & (PAGE_SIZE -1));
40005598: 94 0e 6f ff and %i1, 0xfff, %o2
comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen);
4000559c: 90 10 00 18 mov %i0, %o0
400055a0: 40 00 19 87 call 4000bbbc <jffs2_compress>
400055a4: 94 04 40 0a add %l1, %o2, %o2
ri.totlen = cpu_to_je32(sizeof(ri) + cdatalen);
400055a8: c2 07 bf b8 ld [ %fp + -72 ], %g1
400055ac: 82 00 60 44 add %g1, 0x44, %g1
comprtype = jffs2_compress(c, f, writebuf, &comprbuf, &datalen, &cdatalen);
400055b0: b8 10 00 08 mov %o0, %i4
ri.totlen = cpu_to_je32(sizeof(ri) + cdatalen);
400055b4: c2 27 bf c0 st %g1, [ %fp + -64 ]
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
400055b8: 94 10 20 08 mov 8, %o2
400055bc: 92 10 00 1d mov %i5, %o1
ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
400055c0: ec 37 bf bc sth %l6, [ %fp + -68 ]
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
400055c4: 90 10 20 00 clr %o0
400055c8: 40 00 19 6c call 4000bb78 <cyg_crc32_accumulate>
400055cc: ea 37 bf be sth %l5, [ %fp + -66 ]
ri.ino = cpu_to_je32(f->inocache->ino);
400055d0: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1
400055d4: c4 00 60 0c ld [ %g1 + 0xc ], %g2
ri.version = cpu_to_je32(++f->highest_version);
400055d8: c2 06 80 00 ld [ %i2 ], %g1
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
400055dc: d0 27 bf c4 st %o0, [ %fp + -60 ]
ri.version = cpu_to_je32(++f->highest_version);
400055e0: 82 00 60 01 inc %g1
ri.ino = cpu_to_je32(f->inocache->ino);
400055e4: c4 27 bf c8 st %g2, [ %fp + -56 ]
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));
400055e8: 94 10 20 3c mov 0x3c, %o2
ri.version = cpu_to_je32(++f->highest_version);
400055ec: c2 26 80 00 st %g1, [ %i2 ]
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
400055f0: 92 10 00 1d mov %i5, %o1
400055f4: c4 06 bf c0 ld [ %i2 + -64 ], %g2
400055f8: 84 08 80 14 and %g2, %l4, %g2
ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
400055fc: d6 16 bf c6 lduh [ %i2 + -58 ], %o3
ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
40005600: d8 16 bf c8 lduh [ %i2 + -56 ], %o4
ri.isize = cpu_to_je32(JFFS2_F_I_SIZE(f));
40005604: da 06 bf f4 ld [ %i2 + -12 ], %o5
ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
40005608: de 06 bf d4 ld [ %i2 + -44 ], %o7
ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
4000560c: c8 06 bf e4 ld [ %i2 + -28 ], %g4
ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
40005610: c6 06 bf dc ld [ %i2 + -36 ], %g3
ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
40005614: c4 27 bf d0 st %g2, [ %fp + -48 ]
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
40005618: 90 10 20 00 clr %o0
ri.csize = cpu_to_je32(cdatalen);
4000561c: c4 07 bf b8 ld [ %fp + -72 ], %g2
ri.version = cpu_to_je32(++f->highest_version);
40005620: c2 27 bf cc st %g1, [ %fp + -52 ]
ri.usercompr = (comprtype >> 8) & 0xff;
40005624: 83 2f 20 10 sll %i4, 0x10, %g1
ri.csize = cpu_to_je32(cdatalen);
40005628: c4 27 bf ec st %g2, [ %fp + -20 ]
ri.usercompr = (comprtype >> 8) & 0xff;
4000562c: 83 30 60 18 srl %g1, 0x18, %g1
ri.dsize = cpu_to_je32(datalen);
40005630: c4 07 bf b4 ld [ %fp + -76 ], %g2
ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
40005634: d6 37 bf d4 sth %o3, [ %fp + -44 ]
ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
40005638: d8 37 bf d6 sth %o4, [ %fp + -42 ]
ri.isize = cpu_to_je32(JFFS2_F_I_SIZE(f));
4000563c: da 27 bf d8 st %o5, [ %fp + -40 ]
ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
40005640: de 27 bf dc st %o7, [ %fp + -36 ]
ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
40005644: c8 27 bf e4 st %g4, [ %fp + -28 ]
ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
40005648: c6 27 bf e0 st %g3, [ %fp + -32 ]
ri.dsize = cpu_to_je32(datalen);
4000564c: c4 27 bf f0 st %g2, [ %fp + -16 ]
ri.usercompr = (comprtype >> 8) & 0xff;
40005650: c2 2f bf f5 stb %g1, [ %fp + -11 ]
ri.offset = cpu_to_je32(offset);
40005654: f2 27 bf e8 st %i1, [ %fp + -24 ]
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
40005658: 40 00 19 48 call 4000bb78 <cyg_crc32_accumulate>
4000565c: f8 2f bf f4 stb %i4, [ %fp + -12 ]
ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
40005660: d4 07 bf b8 ld [ %fp + -72 ], %o2
40005664: d2 07 bf ac ld [ %fp + -84 ], %o1
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
40005668: d0 27 bf fc st %o0, [ %fp + -4 ]
ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
4000566c: 40 00 19 43 call 4000bb78 <cyg_crc32_accumulate>
40005670: 90 10 20 00 clr %o0
new_fn = jffs2_write_dnode(c, f, &ri, comprbuf, cdatalen, ALLOC_GC);
40005674: 94 10 00 1d mov %i5, %o2
40005678: d8 07 bf b8 ld [ %fp + -72 ], %o4
4000567c: d6 07 bf ac ld [ %fp + -84 ], %o3
ri.data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
40005680: d0 27 bf f8 st %o0, [ %fp + -8 ]
new_fn = jffs2_write_dnode(c, f, &ri, comprbuf, cdatalen, ALLOC_GC);
40005684: 9a 10 20 02 mov 2, %o5
40005688: 92 10 00 1a mov %i2, %o1
4000568c: 40 00 12 9d call 4000a100 <jffs2_write_dnode>
40005690: 90 10 00 18 mov %i0, %o0
jffs2_free_comprbuf(comprbuf, writebuf);
if (IS_ERR(new_fn)) {
40005694: 80 a2 3c 18 cmp %o0, -1000
40005698: 18 80 00 2e bgu 40005750 <jffs2_garbage_collect_pass+0x10c8> <== NEVER TAKEN
4000569c: 94 10 00 08 mov %o0, %o2
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);
400056a0: 92 10 00 1a mov %i2, %o1
400056a4: 40 00 02 7c call 40006094 <jffs2_add_full_dnode_to_inode>
400056a8: 90 10 00 18 mov %i0, %o0
offset += datalen;
if (f->metadata) {
400056ac: c2 06 a0 08 ld [ %i2 + 8 ], %g1
offset += datalen;
400056b0: c4 07 bf b4 ld [ %fp + -76 ], %g2
ret = jffs2_add_full_dnode_to_inode(c, f, new_fn);
400056b4: b8 10 00 08 mov %o0, %i4
if (f->metadata) {
400056b8: 80 a0 60 00 cmp %g1, 0
400056bc: 02 bf ff a2 be 40005544 <jffs2_garbage_collect_pass+0xebc> <== ALWAYS TAKEN
400056c0: b2 06 40 02 add %i1, %g2, %i1
jffs2_mark_node_obsolete(c, f->metadata->raw);
400056c4: d2 00 40 00 ld [ %g1 ], %o1 <== NOT EXECUTED
400056c8: 40 00 06 12 call 40006f10 <jffs2_mark_node_obsolete> <== NOT EXECUTED
400056cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
jffs2_free_full_dnode(f->metadata);
400056d0: 40 00 01 36 call 40005ba8 <jffs2_free_full_dnode> <== NOT EXECUTED
400056d4: d0 06 a0 08 ld [ %i2 + 8 ], %o0 <== NOT EXECUTED
f->metadata = NULL;
400056d8: 10 bf ff 9b b 40005544 <jffs2_garbage_collect_pass+0xebc> <== NOT EXECUTED
400056dc: c0 26 a0 08 clr [ %i2 + 8 ] <== NOT EXECUTED
ret = jffs2_garbage_collect_pristine(c, f->inocache, raw);
400056e0: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
400056e4: 7f ff fa e2 call 4000426c <jffs2_garbage_collect_pristine> <== NOT EXECUTED
400056e8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (!ret) {
400056ec: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
400056f0: 12 80 00 07 bne 4000570c <jffs2_garbage_collect_pass+0x1084> <== NOT EXECUTED
400056f4: 03 3f ff e0 sethi %hi(0xffff8000), %g1 <== NOT EXECUTED
frag->node->raw = f->inocache->nodes;
400056f8: c4 06 a0 14 ld [ %i2 + 0x14 ], %g2 <== NOT EXECUTED
400056fc: c2 04 a0 10 ld [ %l2 + 0x10 ], %g1 <== NOT EXECUTED
40005700: c4 00 a0 04 ld [ %g2 + 4 ], %g2 <== NOT EXECUTED
40005704: 10 bf fd 17 b 40004b60 <jffs2_garbage_collect_pass+0x4d8> <== NOT EXECUTED
40005708: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED
if (ret != -EBADFD)
4000570c: 82 10 60 01 or %g1, 1, %g1 <== NOT EXECUTED
40005710: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
40005714: 02 bf fd c6 be 40004e2c <jffs2_garbage_collect_pass+0x7a4> <== NOT EXECUTED
40005718: a4 06 ff ff add %i3, -1, %l2 <== NOT EXECUTED
jffs2_gc_release_inode(c, f);
4000571c: 10 bf fd 12 b 40004b64 <jffs2_garbage_collect_pass+0x4dc> <== NOT EXECUTED
40005720: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_dnode failed: %d\n",
40005724: 11 10 00 7a sethi %hi(0x4001e800), %o0 <== NOT EXECUTED
40005728: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4000572c: 92 10 20 c4 mov 0xc4, %o1 <== NOT EXECUTED
40005730: 7f ff fa c3 call 4000423c <jffs2_printk> <== NOT EXECUTED
40005734: 90 12 23 50 or %o0, 0x350, %o0 <== NOT EXECUTED
}
}
jffs2_gc_release_page(c, pg_ptr, &pg);
40005738: 94 07 bf b0 add %fp, -80, %o2
4000573c: 92 10 00 11 mov %l1, %o1
40005740: 7f ff f8 1e call 400037b8 <jffs2_gc_release_page>
40005744: 90 10 00 18 mov %i0, %o0
return ret;
40005748: 10 bf fd 07 b 40004b64 <jffs2_garbage_collect_pass+0x4dc>
4000574c: 92 10 00 1a mov %i2, %o1
pr_warn("Error writing new dnode: %ld\n",
40005750: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
ret = PTR_ERR(new_fn);
40005754: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
pr_warn("Error writing new dnode: %ld\n",
40005758: 11 10 00 7a sethi %hi(0x4001e800), %o0 <== NOT EXECUTED
4000575c: 7f ff fa b8 call 4000423c <jffs2_printk> <== NOT EXECUTED
40005760: 90 12 20 08 or %o0, 8, %o0 ! 4001e808 <rtems_jffs2_directory_handlers+0x68c><== NOT EXECUTED
break;
40005764: 10 bf ff f6 b 4000573c <jffs2_garbage_collect_pass+0x10b4> <== NOT EXECUTED
40005768: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
pr_warn("read_cache_page() returned error: %ld\n",
4000576c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
return PTR_ERR(pg_ptr);
40005770: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
pr_warn("read_cache_page() returned error: %ld\n",
40005774: 11 10 00 7a sethi %hi(0x4001e800), %o0 <== NOT EXECUTED
40005778: 7f ff fa b1 call 4000423c <jffs2_printk> <== NOT EXECUTED
4000577c: 90 12 23 18 or %o0, 0x318, %o0 ! 4001eb18 <rtems_jffs2_directory_handlers+0x99c><== NOT EXECUTED
return PTR_ERR(pg_ptr);
40005780: 10 bf fc f9 b 40004b64 <jffs2_garbage_collect_pass+0x4dc> <== NOT EXECUTED
40005784: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
BUG_ON(start > orig_start);
40005788: 15 10 00 7b sethi %hi(0x4001ec00), %o2 <== NOT EXECUTED
4000578c: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
40005790: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
40005794: 94 12 a1 38 or %o2, 0x138, %o2 <== NOT EXECUTED
40005798: 92 10 25 2c mov 0x52c, %o1 <== NOT EXECUTED
4000579c: 40 00 24 77 call 4000e978 <__assert_func> <== NOT EXECUTED
400057a0: 90 12 21 70 or %o0, 0x170, %o0 <== NOT EXECUTED
BUG_ON(end < orig_end);
400057a4: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
400057a8: 15 10 00 7b sethi %hi(0x4001ec00), %o2 <== NOT EXECUTED
400057ac: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
400057b0: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
400057b4: 94 12 a1 38 or %o2, 0x138, %o2 <== NOT EXECUTED
400057b8: 92 10 25 2b mov 0x52b, %o1 <== NOT EXECUTED
400057bc: 40 00 24 6f call 4000e978 <__assert_func> <== NOT EXECUTED
400057c0: 90 12 21 70 or %o0, 0x170, %o0 <== NOT EXECUTED
BUG_ON(frag->ofs != start);
400057c4: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
400057c8: 15 10 00 7b sethi %hi(0x4001ec00), %o2 <== NOT EXECUTED
400057cc: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
400057d0: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
400057d4: 94 12 a1 38 or %o2, 0x138, %o2 <== NOT EXECUTED
400057d8: 92 10 24 ba mov 0x4ba, %o1 <== NOT EXECUTED
400057dc: 40 00 24 67 call 4000e978 <__assert_func> <== NOT EXECUTED
400057e0: 90 12 21 70 or %o0, 0x170, %o0 <== NOT EXECUTED
400057e4: 10 bf ff 49 b 40005508 <jffs2_garbage_collect_pass+0xe80>
400057e8: b2 10 00 11 mov %l1, %i1
goto release_sem;
400057ec: 10 bf fc e4 b 40004b7c <jffs2_garbage_collect_pass+0x4f4> <== NOT EXECUTED
400057f0: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
if (S_ISBLK(JFFS2_F_I_MODE(f)) ||
400057f4: 07 00 00 3c sethi %hi(0xf000), %g3
400057f8: 05 00 00 2c sethi %hi(0xb000), %g2
400057fc: 84 08 40 02 and %g1, %g2, %g2
40005800: 82 08 40 03 and %g1, %g3, %g1
40005804: 07 00 00 08 sethi %hi(0x2000), %g3
40005808: 80 a0 80 03 cmp %g2, %g3
4000580c: 02 80 00 95 be 40005a60 <jffs2_garbage_collect_pass+0x13d8> <== NEVER TAKEN
40005810: 05 00 00 28 sethi %hi(0xa000), %g2
} else if (S_ISLNK(JFFS2_F_I_MODE(f))) {
40005814: 80 a0 40 02 cmp %g1, %g2
40005818: 02 80 00 72 be 400059e0 <jffs2_garbage_collect_pass+0x1358> <== NEVER TAKEN
4000581c: ba 10 20 00 clr %i5
ret = jffs2_reserve_space_gc(c, sizeof(ri) + mdatalen, &alloclen,
40005820: a4 07 60 44 add %i5, 0x44, %l2
40005824: 96 10 20 12 mov 0x12, %o3
40005828: 94 07 bf b8 add %fp, -72, %o2
4000582c: 92 10 00 12 mov %l2, %o1
40005830: 40 00 07 c6 call 40007748 <jffs2_reserve_space_gc>
40005834: 90 10 00 18 mov %i0, %o0
if (ret) {
40005838: b8 92 20 00 orcc %o0, 0, %i4
4000583c: 12 80 00 63 bne 400059c8 <jffs2_garbage_collect_pass+0x1340> <== NEVER TAKEN
40005840: 94 10 00 1c mov %i4, %o2
return _RBTree_Maximum( (RBTree_Control *) root );
40005844: 40 00 40 5f call 400159c0 <_RBTree_Maximum>
40005848: 90 06 a0 04 add %i2, 4, %o0
4000584c: 80 a2 20 00 cmp %o0, 0
40005850: 22 80 00 05 be,a 40005864 <jffs2_garbage_collect_pass+0x11dc> <== NEVER TAKEN
40005854: f6 06 bf f4 ld [ %i2 + -12 ], %i3 <== NOT EXECUTED
ilen = last_frag->ofs + last_frag->size;
40005858: f6 02 20 18 ld [ %o0 + 0x18 ], %i3
4000585c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40005860: b6 06 c0 01 add %i3, %g1, %i3
memset(&ri, 0, sizeof(ri));
40005864: 94 10 20 3c mov 0x3c, %o2
40005868: 92 10 20 00 clr %o1
4000586c: 40 00 5d ee call 4001d024 <memset>
40005870: 90 07 bf c4 add %fp, -60, %o0
ri.magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
40005874: 03 00 00 06 sethi %hi(0x1800), %g1
40005878: 82 10 61 85 or %g1, 0x185, %g1 ! 1985 <_ISR_Stack_size+0x985>
4000587c: c2 37 bf bc sth %g1, [ %fp + -68 ]
ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
40005880: 03 3f ff f8 sethi %hi(0xffffe000), %g1
40005884: 82 10 60 02 or %g1, 2, %g1 ! ffffe002 <RAM_END+0xbfbfe002>
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
40005888: 94 10 20 08 mov 8, %o2
ri.nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
4000588c: c2 37 bf be sth %g1, [ %fp + -66 ]
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
40005890: 92 07 bf bc add %fp, -68, %o1
ri.totlen = cpu_to_je32(sizeof(ri) + mdatalen);
40005894: e4 27 bf c0 st %l2, [ %fp + -64 ]
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
40005898: 40 00 18 b8 call 4000bb78 <cyg_crc32_accumulate>
4000589c: 90 10 20 00 clr %o0
ri.ino = cpu_to_je32(f->inocache->ino);
400058a0: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1
400058a4: c4 00 60 0c ld [ %g1 + 0xc ], %g2
ri.version = cpu_to_je32(++f->highest_version);
400058a8: c2 06 80 00 ld [ %i2 ], %g1
ri.hdr_crc = cpu_to_je32(crc32(0, &ri, sizeof(struct jffs2_unknown_node)-4));
400058ac: d0 27 bf c4 st %o0, [ %fp + -60 ]
ri.version = cpu_to_je32(++f->highest_version);
400058b0: 82 00 60 01 inc %g1
ri.ino = cpu_to_je32(f->inocache->ino);
400058b4: c4 27 bf c8 st %g2, [ %fp + -56 ]
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
400058b8: 94 10 20 3c mov 0x3c, %o2
400058bc: c4 06 bf c0 ld [ %i2 + -64 ], %g2
ri.version = cpu_to_je32(++f->highest_version);
400058c0: c2 26 80 00 st %g1, [ %i2 ]
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
400058c4: 92 07 bf bc add %fp, -68, %o1
ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
400058c8: d8 16 bf c6 lduh [ %i2 + -58 ], %o4
ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
400058cc: da 16 bf c8 lduh [ %i2 + -56 ], %o5
ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
400058d0: de 06 bf d4 ld [ %i2 + -44 ], %o7
ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
400058d4: c8 06 bf e4 ld [ %i2 + -28 ], %g4
ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
400058d8: c6 06 bf dc ld [ %i2 + -36 ], %g3
ri.version = cpu_to_je32(++f->highest_version);
400058dc: c2 27 bf cc st %g1, [ %fp + -52 ]
400058e0: 03 00 00 3c sethi %hi(0xf000), %g1
400058e4: 82 10 61 ff or %g1, 0x1ff, %g1 ! f1ff <_ISR_Stack_size+0xe1ff>
400058e8: 82 08 80 01 and %g2, %g1, %g1
ri.uid = cpu_to_je16(JFFS2_F_I_UID(f));
400058ec: d8 37 bf d4 sth %o4, [ %fp + -44 ]
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
400058f0: 90 10 20 00 clr %o0
ri.gid = cpu_to_je16(JFFS2_F_I_GID(f));
400058f4: da 37 bf d6 sth %o5, [ %fp + -42 ]
ri.mode = cpu_to_jemode(JFFS2_F_I_MODE(f));
400058f8: c2 27 bf d0 st %g1, [ %fp + -48 ]
ri.atime = cpu_to_je32(JFFS2_F_I_ATIME(f));
400058fc: de 27 bf dc st %o7, [ %fp + -36 ]
ri.ctime = cpu_to_je32(JFFS2_F_I_CTIME(f));
40005900: c8 27 bf e4 st %g4, [ %fp + -28 ]
ri.mtime = cpu_to_je32(JFFS2_F_I_MTIME(f));
40005904: c6 27 bf e0 st %g3, [ %fp + -32 ]
ri.csize = cpu_to_je32(mdatalen);
40005908: fa 27 bf ec st %i5, [ %fp + -20 ]
ri.dsize = cpu_to_je32(mdatalen);
4000590c: fa 27 bf f0 st %i5, [ %fp + -16 ]
ri.isize = cpu_to_je32(ilen);
40005910: f6 27 bf d8 st %i3, [ %fp + -40 ]
ri.offset = cpu_to_je32(0);
40005914: c0 27 bf e8 clr [ %fp + -24 ]
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
40005918: 40 00 18 98 call 4000bb78 <cyg_crc32_accumulate>
4000591c: c0 2f bf f4 clrb [ %fp + -12 ]
ri.data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
40005920: 94 10 00 1d mov %i5, %o2
ri.node_crc = cpu_to_je32(crc32(0, &ri, sizeof(ri)-8));
40005924: d0 27 bf fc st %o0, [ %fp + -4 ]
ri.data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
40005928: 92 10 00 19 mov %i1, %o1
4000592c: 40 00 18 93 call 4000bb78 <cyg_crc32_accumulate>
40005930: 90 10 20 00 clr %o0
new_fn = jffs2_write_dnode(c, f, &ri, mdata, mdatalen, ALLOC_GC);
40005934: 98 10 00 1d mov %i5, %o4
ri.data_crc = cpu_to_je32(crc32(0, mdata, mdatalen));
40005938: d0 27 bf f8 st %o0, [ %fp + -8 ]
new_fn = jffs2_write_dnode(c, f, &ri, mdata, mdatalen, ALLOC_GC);
4000593c: 9a 10 20 02 mov 2, %o5
40005940: 96 10 00 19 mov %i1, %o3
40005944: 94 07 bf bc add %fp, -68, %o2
40005948: 92 10 00 1a mov %i2, %o1
4000594c: 40 00 11 ed call 4000a100 <jffs2_write_dnode>
40005950: 90 10 00 18 mov %i0, %o0
if (IS_ERR(new_fn)) {
40005954: 80 a2 3c 18 cmp %o0, -1000
40005958: 18 80 00 13 bgu 400059a4 <jffs2_garbage_collect_pass+0x131c> <== NEVER TAKEN
4000595c: ba 10 00 08 mov %o0, %i5
jffs2_mark_node_obsolete(c, fn->raw);
40005960: d2 04 40 00 ld [ %l1 ], %o1
40005964: 40 00 05 6b call 40006f10 <jffs2_mark_node_obsolete>
40005968: 90 10 00 18 mov %i0, %o0
jffs2_free_full_dnode(fn);
4000596c: 40 00 00 8f call 40005ba8 <jffs2_free_full_dnode>
40005970: 90 10 00 11 mov %l1, %o0
f->metadata = new_fn;
40005974: fa 26 a0 08 st %i5, [ %i2 + 8 ]
if (S_ISLNK(JFFS2_F_I_MODE(f)))
40005978: 05 00 00 3c sethi %hi(0xf000), %g2
4000597c: c2 06 bf c0 ld [ %i2 + -64 ], %g1
40005980: 82 08 40 02 and %g1, %g2, %g1
40005984: 05 00 00 28 sethi %hi(0xa000), %g2
40005988: 80 a0 40 02 cmp %g1, %g2
4000598c: 32 bf fc 76 bne,a 40004b64 <jffs2_garbage_collect_pass+0x4dc> <== ALWAYS TAKEN
40005990: 92 10 00 1a mov %i2, %o1
kfree(mdata);
40005994: 40 00 24 e8 call 4000ed34 <free> <== NOT EXECUTED
40005998: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
jffs2_gc_release_inode(c, f);
4000599c: 10 bf fc 72 b 40004b64 <jffs2_garbage_collect_pass+0x4dc> <== NOT EXECUTED
400059a0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
pr_warn("Error writing new dnode: %ld\n", PTR_ERR(new_fn));
400059a4: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
ret = PTR_ERR(new_fn);
400059a8: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
pr_warn("Error writing new dnode: %ld\n", PTR_ERR(new_fn));
400059ac: 11 10 00 7a sethi %hi(0x4001e800), %o0 <== NOT EXECUTED
400059b0: 7f ff fa 23 call 4000423c <jffs2_printk> <== NOT EXECUTED
400059b4: 90 12 20 08 or %o0, 8, %o0 ! 4001e808 <rtems_jffs2_directory_handlers+0x68c><== NOT EXECUTED
goto out;
400059b8: 10 bf ff f1 b 4000597c <jffs2_garbage_collect_pass+0x12f4> <== NOT EXECUTED
400059bc: 05 00 00 3c sethi %hi(0xf000), %g2 <== NOT EXECUTED
400059c0: 10 bf fd 15 b 40004e14 <jffs2_garbage_collect_pass+0x78c>
400059c4: b2 10 00 01 mov %g1, %i1
pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_metadata failed: %d\n",
400059c8: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
400059cc: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
400059d0: 7f ff fa 1b call 4000423c <jffs2_printk> <== NOT EXECUTED
400059d4: 90 12 23 b0 or %o0, 0x3b0, %o0 ! 4001e7b0 <rtems_jffs2_directory_handlers+0x634><== NOT EXECUTED
goto out;
400059d8: 10 bf ff e9 b 4000597c <jffs2_garbage_collect_pass+0x12f4> <== NOT EXECUTED
400059dc: 05 00 00 3c sethi %hi(0xf000), %g2 <== NOT EXECUTED
mdatalen = fn->size;
400059e0: fa 04 60 08 ld [ %l1 + 8 ], %i5 <== NOT EXECUTED
mdata = kmalloc(fn->size, GFP_KERNEL);
400059e4: 40 00 25 b8 call 4000f0c4 <malloc> <== NOT EXECUTED
400059e8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (!mdata) {
400059ec: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
400059f0: 02 80 00 1e be 40005a68 <jffs2_garbage_collect_pass+0x13e0> <== NOT EXECUTED
400059f4: 9a 10 00 1d mov %i5, %o5 <== NOT EXECUTED
ret = jffs2_read_dnode(c, f, fn, mdata, 0, mdatalen);
400059f8: 98 10 20 00 clr %o4 <== NOT EXECUTED
400059fc: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
40005a00: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
40005a04: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40005a08: 40 00 07 fc call 400079f8 <jffs2_read_dnode> <== NOT EXECUTED
40005a0c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (ret) {
40005a10: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
40005a14: 02 bf ff 84 be 40005824 <jffs2_garbage_collect_pass+0x119c> <== NOT EXECUTED
40005a18: a4 07 60 44 add %i5, 0x44, %l2 <== NOT EXECUTED
pr_warn("read of old metadata failed in jffs2_garbage_collect_metadata(): %d\n",
40005a1c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
40005a20: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
40005a24: 7f ff fa 06 call 4000423c <jffs2_printk> <== NOT EXECUTED
40005a28: 90 12 23 60 or %o0, 0x360, %o0 ! 4001e760 <rtems_jffs2_directory_handlers+0x5e4><== NOT EXECUTED
kfree(mdata);
40005a2c: 40 00 24 c2 call 4000ed34 <free> <== NOT EXECUTED
40005a30: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
return ret;
40005a34: 10 bf fc 4c b 40004b64 <jffs2_garbage_collect_pass+0x4dc> <== NOT EXECUTED
40005a38: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
pr_warn("%s(): Node at 0x%08x had totlen 0x%x instead of expected 0x%zx\n",
40005a3c: c2 06 40 00 ld [ %i1 ], %g1 <== NOT EXECUTED
40005a40: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
40005a44: 13 10 00 7b sethi %hi(0x4001ec00), %o1 <== NOT EXECUTED
40005a48: 11 10 00 7a sethi %hi(0x4001e800), %o0 <== NOT EXECUTED
40005a4c: 98 10 20 44 mov 0x44, %o4 <== NOT EXECUTED
40005a50: 94 0a bf fc and %o2, -4, %o2 <== NOT EXECUTED
40005a54: 92 12 61 58 or %o1, 0x158, %o1 <== NOT EXECUTED
40005a58: 7f ff f9 f9 call 4000423c <jffs2_printk> <== NOT EXECUTED
40005a5c: 90 12 21 10 or %o0, 0x110, %o0 <== NOT EXECUTED
return -EIO;
40005a60: 10 bf fc 40 b 40004b60 <jffs2_garbage_collect_pass+0x4d8> <== NOT EXECUTED
40005a64: b8 10 3f fb mov -5, %i4 <== NOT EXECUTED
return -ENOMEM;
40005a68: b8 10 3f f4 mov -12, %i4 <== NOT EXECUTED
pr_warn("kmalloc of mdata failed in jffs2_garbage_collect_metadata()\n");
40005a6c: 11 10 00 79 sethi %hi(0x4001e400), %o0 <== NOT EXECUTED
40005a70: 7f ff f9 f3 call 4000423c <jffs2_printk> <== NOT EXECUTED
40005a74: 90 12 23 18 or %o0, 0x318, %o0 ! 4001e718 <rtems_jffs2_directory_handlers+0x59c><== NOT EXECUTED
return -ENOMEM;
40005a78: 10 bf fc 3b b 40004b64 <jffs2_garbage_collect_pass+0x4dc> <== NOT EXECUTED
40005a7c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
pr_warn("%s(): Node 0x%08x wasn't a hole node!\n",
40005a80: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
40005a84: 13 10 00 7b sethi %hi(0x4001ec00), %o1 <== NOT EXECUTED
40005a88: 11 10 00 7a sethi %hi(0x4001e800), %o0 <== NOT EXECUTED
40005a8c: 94 0a bf fc and %o2, -4, %o2 <== NOT EXECUTED
40005a90: 92 12 61 58 or %o1, 0x158, %o1 <== NOT EXECUTED
40005a94: 7f ff f9 ea call 4000423c <jffs2_printk> <== NOT EXECUTED
40005a98: 90 12 22 00 or %o0, 0x200, %o0 <== NOT EXECUTED
pr_warn("Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n",
40005a9c: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1 <== NOT EXECUTED
40005aa0: d6 00 60 0c ld [ %g1 + 0xc ], %o3 <== NOT EXECUTED
40005aa4: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
40005aa8: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
40005aac: 11 10 00 7a sethi %hi(0x4001e800), %o0 <== NOT EXECUTED
40005ab0: 7f ff f9 e3 call 4000423c <jffs2_printk> <== NOT EXECUTED
40005ab4: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 4001e9b8 <rtems_jffs2_directory_handlers+0x83c><== NOT EXECUTED
goto fill;
40005ab8: 10 bf fe 0c b 400052e8 <jffs2_garbage_collect_pass+0xc60> <== NOT EXECUTED
40005abc: 03 00 00 06 sethi %hi(0x1800), %g1 <== NOT EXECUTED
pr_warn("%s: Node at 0x%08x had CRC 0x%08x which doesn't match calculated CRC 0x%08x\n",
40005ac0: c2 06 40 00 ld [ %i1 ], %g1 <== NOT EXECUTED
40005ac4: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
40005ac8: 94 0a bf fc and %o2, -4, %o2 <== NOT EXECUTED
40005acc: 13 10 00 7b sethi %hi(0x4001ec00), %o1 <== NOT EXECUTED
40005ad0: 11 10 00 7a sethi %hi(0x4001e800), %o0 <== NOT EXECUTED
40005ad4: 92 12 61 58 or %o1, 0x158, %o1 <== NOT EXECUTED
40005ad8: 7f ff f9 d9 call 4000423c <jffs2_printk> <== NOT EXECUTED
40005adc: 90 12 21 60 or %o0, 0x160, %o0 <== NOT EXECUTED
pr_warn("Data in the range 0x%08x to 0x%08x of inode #%u will be lost\n",
40005ae0: 10 bf ff f0 b 40005aa0 <jffs2_garbage_collect_pass+0x1418> <== NOT EXECUTED
40005ae4: c2 06 a0 14 ld [ %i2 + 0x14 ], %g1 <== NOT EXECUTED
pr_warn("%s(): Node at 0x%08x had node type 0x%04x instead of JFFS2_NODETYPE_INODE(0x%04x)\n",
40005ae8: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
40005aec: 94 0a bf fc and %o2, -4, %o2 <== NOT EXECUTED
40005af0: 13 10 00 7b sethi %hi(0x4001ec00), %o1 <== NOT EXECUTED
40005af4: 11 10 00 7a sethi %hi(0x4001e800), %o0 <== NOT EXECUTED
40005af8: 92 12 61 58 or %o1, 0x158, %o1 <== NOT EXECUTED
40005afc: 90 12 20 b0 or %o0, 0xb0, %o0 <== NOT EXECUTED
40005b00: 7f ff f9 cf call 4000423c <jffs2_printk> <== NOT EXECUTED
40005b04: b8 10 3f fb mov -5, %i4 <== NOT EXECUTED
jffs2_gc_release_inode(c, f);
40005b08: 10 bf fc 17 b 40004b64 <jffs2_garbage_collect_pass+0x4dc> <== NOT EXECUTED
40005b0c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_hole failed: %d\n",
40005b10: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40005b14: 92 10 20 44 mov 0x44, %o1 <== NOT EXECUTED
40005b18: 11 10 00 7a sethi %hi(0x4001e800), %o0 <== NOT EXECUTED
40005b1c: 7f ff f9 c8 call 4000423c <jffs2_printk> <== NOT EXECUTED
40005b20: 90 12 22 38 or %o0, 0x238, %o0 ! 4001ea38 <rtems_jffs2_directory_handlers+0x8bc><== NOT EXECUTED
return ret;
40005b24: 10 bf fc 10 b 40004b64 <jffs2_garbage_collect_pass+0x4dc> <== NOT EXECUTED
40005b28: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
if (JFFS2_F_I_MTIME(f) == JFFS2_F_I_CTIME(f))
40005b2c: c4 06 bf dc ld [ %i2 + -36 ], %g2
40005b30: 80 a0 80 01 cmp %g2, %g1
40005b34: 32 bf fd b0 bne,a 400051f4 <jffs2_garbage_collect_pass+0xb6c> <== NEVER TAKEN
40005b38: 82 10 20 00 clr %g1 <== NOT EXECUTED
40005b3c: 10 bf fd af b 400051f8 <jffs2_garbage_collect_pass+0xb70>
40005b40: c2 27 bf d4 st %g1, [ %fp + -44 ]
pr_warn("jffs2_reserve_space_gc of %zd bytes for garbage_collect_dirent failed: %d\n",
40005b44: d2 0f bf d8 ldub [ %fp + -40 ], %o1 <== NOT EXECUTED
40005b48: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
40005b4c: 92 02 60 28 add %o1, 0x28, %o1 <== NOT EXECUTED
40005b50: 11 10 00 7a sethi %hi(0x4001e800), %o0 <== NOT EXECUTED
40005b54: 7f ff f9 ba call 4000423c <jffs2_printk> <== NOT EXECUTED
40005b58: 90 12 23 a8 or %o0, 0x3a8, %o0 ! 4001eba8 <rtems_jffs2_directory_handlers+0xa2c><== NOT EXECUTED
return ret;
40005b5c: 10 bf fc 02 b 40004b64 <jffs2_garbage_collect_pass+0x4dc> <== NOT EXECUTED
40005b60: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
return PTR_ERR(new_fd);
40005b64: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
pr_warn("jffs2_write_dirent in garbage_collect_dirent failed: %ld\n",
40005b68: 11 10 00 7b sethi %hi(0x4001ec00), %o0 <== NOT EXECUTED
40005b6c: 7f ff f9 b4 call 4000423c <jffs2_printk> <== NOT EXECUTED
40005b70: 90 12 20 00 mov %o0, %o0 ! 4001ec00 <rtems_jffs2_directory_handlers+0xa84><== NOT EXECUTED
return PTR_ERR(new_fd);
40005b74: 10 bf fb fc b 40004b64 <jffs2_garbage_collect_pass+0x4dc> <== NOT EXECUTED
40005b78: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40004170 <jffs2_gc_fetch_inode>:
}
struct jffs2_inode_info *jffs2_gc_fetch_inode(struct jffs2_sb_info *c,
int inum, int unlinked)
{
40004170: 9d e3 bf a0 save %sp, -96, %sp
struct _inode *inode;
struct jffs2_inode_cache *ic;
if (unlinked) {
40004174: 80 a6 a0 00 cmp %i2, 0
40004178: 02 80 00 14 be 400041c8 <jffs2_gc_fetch_inode+0x58> <== ALWAYS TAKEN
4000417c: d0 06 20 e0 ld [ %i0 + 0xe0 ], %o0
for (inode = sb->s_root; inode != NULL; inode = inode->i_cache_next) {
40004180: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40004184: 32 80 00 08 bne,a 400041a4 <jffs2_gc_fetch_inode+0x34> <== NOT EXECUTED
40004188: c4 02 00 00 ld [ %o0 ], %g2 <== NOT EXECUTED
if (!inode) {
jffs2_dbg(1, "ilookup() failed for ino #%u; inode is probably deleted.\n",
inum);
spin_lock(&c->inocache_lock);
ic = jffs2_get_ino_cache(c, inum);
4000418c: 10 80 00 23 b 40004218 <jffs2_gc_fetch_inode+0xa8> <== NOT EXECUTED
40004190: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
for (inode = sb->s_root; inode != NULL; inode = inode->i_cache_next) {
40004194: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40004198: 02 80 00 20 be 40004218 <jffs2_gc_fetch_inode+0xa8> <== NOT EXECUTED
4000419c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (inode->i_ino == ino) {
400041a0: c4 02 00 00 ld [ %o0 ], %g2 <== NOT EXECUTED
400041a4: 80 a0 80 19 cmp %g2, %i1 <== NOT EXECUTED
400041a8: 32 bf ff fb bne,a 40004194 <jffs2_gc_fetch_inode+0x24> <== NOT EXECUTED
400041ac: d0 02 20 68 ld [ %o0 + 0x68 ], %o0 <== NOT EXECUTED
inode->i_count++;
400041b0: c4 02 20 04 ld [ %o0 + 4 ], %g2 <== NOT EXECUTED
400041b4: 84 00 a0 01 inc %g2 <== NOT EXECUTED
400041b8: c4 22 20 04 st %g2, [ %o0 + 4 ] <== NOT EXECUTED
inode = jffs2_iget(OFNI_BS_2SFFJ(c), inum);
if (IS_ERR(inode))
return ERR_CAST(inode);
}
return JFFS2_INODE_INFO(inode);
400041bc: 90 02 20 48 add %o0, 0x48, %o0 <== NOT EXECUTED
}
400041c0: 81 c7 e0 08 ret
400041c4: 91 e8 00 08 restore %g0, %o0, %o0
for (inode = sb->s_root; inode != NULL; inode = inode->i_cache_next) {
400041c8: 80 a2 20 00 cmp %o0, 0
400041cc: 32 80 00 08 bne,a 400041ec <jffs2_gc_fetch_inode+0x7c> <== ALWAYS TAKEN
400041d0: c4 02 00 00 ld [ %o0 ], %g2
400041d4: 10 80 00 16 b 4000422c <jffs2_gc_fetch_inode+0xbc> <== NOT EXECUTED
400041d8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
400041dc: 80 a2 20 00 cmp %o0, 0
400041e0: 02 80 00 13 be 4000422c <jffs2_gc_fetch_inode+0xbc>
400041e4: 92 10 00 19 mov %i1, %o1
if (inode->i_ino == ino) {
400041e8: c4 02 00 00 ld [ %o0 ], %g2
400041ec: 80 a6 40 02 cmp %i1, %g2
400041f0: 32 bf ff fb bne,a 400041dc <jffs2_gc_fetch_inode+0x6c>
400041f4: d0 02 20 68 ld [ %o0 + 0x68 ], %o0
inode->i_count++;
400041f8: c4 02 20 04 ld [ %o0 + 4 ], %g2
400041fc: 84 00 a0 01 inc %g2
40004200: c4 22 20 04 st %g2, [ %o0 + 4 ]
if (IS_ERR(inode))
40004204: 80 a2 3c 18 cmp %o0, -1000
40004208: 28 bf ff ee bleu,a 400041c0 <jffs2_gc_fetch_inode+0x50> <== ALWAYS TAKEN
4000420c: 90 02 20 48 add %o0, 0x48, %o0
}
40004210: 81 c7 e0 08 ret <== NOT EXECUTED
40004214: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
ic = jffs2_get_ino_cache(c, inum);
40004218: 40 00 08 e0 call 40006598 <jffs2_get_ino_cache> <== NOT EXECUTED
4000421c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return NULL;
40004220: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
40004224: 81 c7 e0 08 ret <== NOT EXECUTED
40004228: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
if (inode)
4000422c: 7f ff fe 54 call 40003b7c <jffs2_iget.part.0>
40004230: 90 10 00 18 mov %i0, %o0
if (IS_ERR(inode))
40004234: 10 bf ff f5 b 40004208 <jffs2_gc_fetch_inode+0x98>
40004238: 80 a2 3c 18 cmp %o0, -1000
40003784 <jffs2_gc_fetch_page>:
{
40003784: 9d e3 bf a0 save %sp, -96, %sp
ret = jffs2_read_inode_range(c, f, gc_buffer,
40003788: 19 00 00 04 sethi %hi(0x1000), %o4
unsigned char *gc_buffer = &sb->s_gc_buffer[0];
4000378c: ba 06 20 ed add %i0, 0xed, %i5
ret = jffs2_read_inode_range(c, f, gc_buffer,
40003790: 96 0e b0 00 and %i2, -4096, %o3
40003794: 94 10 00 1d mov %i5, %o2
40003798: 92 10 00 19 mov %i1, %o1
4000379c: 40 00 11 f0 call 40007f5c <jffs2_read_inode_range>
400037a0: 90 10 00 18 mov %i0, %o0
if (ret)
400037a4: 80 a2 20 00 cmp %o0, 0
400037a8: 32 80 00 02 bne,a 400037b0 <jffs2_gc_fetch_page+0x2c> <== NEVER TAKEN
400037ac: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
}
400037b0: 81 c7 e0 08 ret
400037b4: 91 e8 00 1d restore %g0, %i5, %o0
40006598 <jffs2_get_ino_cache>:
ret = c->inocache_list[ino % c->inocache_hashsize];
40006598: c6 02 20 c0 ld [ %o0 + 0xc0 ], %g3
4000659c: c4 02 20 c4 ld [ %o0 + 0xc4 ], %g2
400065a0: 81 80 20 00 wr %g0, %y
400065a4: 01 00 00 00 nop
400065a8: 01 00 00 00 nop
400065ac: 01 00 00 00 nop
400065b0: 82 72 40 03 udiv %o1, %g3, %g1
400065b4: 82 58 40 03 smul %g1, %g3, %g1
400065b8: 82 22 40 01 sub %o1, %g1, %g1
400065bc: 83 28 60 02 sll %g1, 2, %g1
400065c0: d0 00 80 01 ld [ %g2 + %g1 ], %o0
while (ret && ret->ino < ino) {
400065c4: 80 a2 20 00 cmp %o0, 0
400065c8: 32 80 00 07 bne,a 400065e4 <jffs2_get_ino_cache+0x4c>
400065cc: c2 02 20 0c ld [ %o0 + 0xc ], %g1
400065d0: 30 80 00 0e b,a 40006608 <jffs2_get_ino_cache+0x70>
400065d4: 80 a2 20 00 cmp %o0, 0
400065d8: 02 80 00 0c be 40006608 <jffs2_get_ino_cache+0x70> <== NOT EXECUTED
400065dc: 01 00 00 00 nop <== NOT EXECUTED
400065e0: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
400065e4: 80 a0 40 09 cmp %g1, %o1
400065e8: 2a bf ff fb bcs,a 400065d4 <jffs2_get_ino_cache+0x3c> <== NEVER TAKEN
400065ec: d0 02 20 10 ld [ %o0 + 0x10 ], %o0 <== NOT EXECUTED
if (ret && ret->ino != ino)
400065f0: 12 80 00 04 bne 40006600 <jffs2_get_ino_cache+0x68> <== NEVER TAKEN
400065f4: 01 00 00 00 nop
}
400065f8: 81 c3 e0 08 retl
400065fc: 01 00 00 00 nop
return ret;
40006600: 81 c3 e0 08 retl <== NOT EXECUTED
40006604: 90 10 20 00 clr %o0 ! 0 <PROM_START> <== NOT EXECUTED
40006608: 81 c3 e0 08 retl
4000660c: 01 00 00 00 nop
40003b7c <jffs2_iget.part.0>:
struct _inode *jffs2_iget(struct super_block *sb, cyg_uint32 ino)
40003b7c: 9d e3 bf 58 save %sp, -168, %sp <== NOT EXECUTED
inode = new_inode(sb);
40003b80: 7f ff f9 91 call 400021c4 <new_inode> <== NOT EXECUTED
40003b84: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (inode == NULL)
40003b88: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
40003b8c: 02 80 00 32 be 40003c54 <jffs2_iget.part.0+0xd8> <== NOT EXECUTED
40003b90: 82 06 20 48 add %i0, 0x48, %g1 <== NOT EXECUTED
inode->i_ino = ino;
40003b94: f2 26 00 00 st %i1, [ %i0 ] <== NOT EXECUTED
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);
40003b98: fa 06 20 40 ld [ %i0 + 0x40 ], %i5 <== NOT EXECUTED
memset(f, 0, sizeof(*f));
40003b9c: 94 10 20 1c mov 0x1c, %o2 <== NOT EXECUTED
40003ba0: 92 10 20 00 clr %o1 <== NOT EXECUTED
40003ba4: 40 00 65 20 call 4001d024 <memset> <== NOT EXECUTED
40003ba8: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED
jffs2_init_inode_info(f);
ret = jffs2_do_read_inode(c, f, inode->i_ino, &latest_node);
40003bac: 96 07 bf bc add %fp, -68, %o3 <== NOT EXECUTED
40003bb0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
40003bb4: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40003bb8: 40 00 18 43 call 40009cc4 <jffs2_do_read_inode> <== NOT EXECUTED
40003bbc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (ret) {
40003bc0: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
40003bc4: 12 80 00 1b bne 40003c30 <jffs2_iget.part.0+0xb4> <== NOT EXECUTED
40003bc8: c8 07 bf e4 ld [ %fp + -28 ], %g4 <== NOT EXECUTED
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;
40003bcc: c6 06 20 5c ld [ %i0 + 0x5c ], %g3 <== NOT EXECUTED
40003bd0: c6 00 e0 14 ld [ %g3 + 0x14 ], %g3 <== NOT EXECUTED
inode->i_mtime = je32_to_cpu(latest_node.mtime);
40003bd4: fa 07 bf e0 ld [ %fp + -32 ], %i5 <== NOT EXECUTED
inode->i_size = je32_to_cpu(latest_node.isize);
40003bd8: f6 07 bf d8 ld [ %fp + -40 ], %i3 <== NOT EXECUTED
inode->i_atime = je32_to_cpu(latest_node.atime);
40003bdc: f8 07 bf dc ld [ %fp + -36 ], %i4 <== NOT EXECUTED
inode->i_gid = je16_to_cpu(latest_node.gid);
40003be0: c4 17 bf d6 lduh [ %fp + -42 ], %g2 <== NOT EXECUTED
return jmode & (S_IFMT | S_IRWXU | S_IRWXG | S_IRWXO);
40003be4: c2 07 bf d0 ld [ %fp + -48 ], %g1 <== NOT EXECUTED
inode->i_uid = je16_to_cpu(latest_node.uid);
40003be8: f4 17 bf d4 lduh [ %fp + -44 ], %i2 <== NOT EXECUTED
40003bec: f4 36 20 0e sth %i2, [ %i0 + 0xe ] <== NOT EXECUTED
inode->i_gid = je16_to_cpu(latest_node.gid);
40003bf0: c4 36 20 10 sth %g2, [ %i0 + 0x10 ] <== NOT EXECUTED
40003bf4: 05 00 00 3c sethi %hi(0xf000), %g2 <== NOT EXECUTED
inode->i_size = je32_to_cpu(latest_node.isize);
40003bf8: c0 26 20 38 clr [ %i0 + 0x38 ] <== NOT EXECUTED
40003bfc: 84 10 a1 ff or %g2, 0x1ff, %g2 <== NOT EXECUTED
40003c00: f6 26 20 3c st %i3, [ %i0 + 0x3c ] <== NOT EXECUTED
40003c04: 82 08 40 02 and %g1, %g2, %g1 <== NOT EXECUTED
inode->i_atime = je32_to_cpu(latest_node.atime);
40003c08: c0 26 20 18 clr [ %i0 + 0x18 ] <== NOT EXECUTED
inode->i_mode = jemode_to_cpu(latest_node.mode);
40003c0c: c2 26 20 08 st %g1, [ %i0 + 8 ] <== NOT EXECUTED
inode->i_atime = je32_to_cpu(latest_node.atime);
40003c10: f8 26 20 1c st %i4, [ %i0 + 0x1c ] <== NOT EXECUTED
inode->i_mtime = je32_to_cpu(latest_node.mtime);
40003c14: c0 26 20 20 clr [ %i0 + 0x20 ] <== NOT EXECUTED
40003c18: fa 26 20 24 st %i5, [ %i0 + 0x24 ] <== NOT EXECUTED
inode->i_ctime = je32_to_cpu(latest_node.ctime);
40003c1c: c0 26 20 28 clr [ %i0 + 0x28 ] <== NOT EXECUTED
40003c20: c8 26 20 2c st %g4, [ %i0 + 0x2c ] <== NOT EXECUTED
inode->i_nlink = f->inocache->pino_nlink;
40003c24: c6 36 20 0c sth %g3, [ %i0 + 0xc ] <== NOT EXECUTED
if (err) {
40003c28: 81 c7 e0 08 ret <== NOT EXECUTED
40003c2c: 81 e8 00 00 restore <== NOT EXECUTED
printk("jffs2_read_inode() failed\n");
40003c30: 11 10 00 78 sethi %hi(0x4001e000), %o0 <== NOT EXECUTED
40003c34: 7f ff fd 78 call 40003214 <jffs2_printk> <== NOT EXECUTED
40003c38: 90 12 20 00 mov %o0, %o0 ! 4001e000 <mount_data+0x114> <== NOT EXECUTED
inode->i_nlink = 0; // free _this_ bad inode right now
40003c3c: c0 36 20 0c clrh [ %i0 + 0xc ] <== NOT EXECUTED
jffs2_iput(inode);
40003c40: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40003c44: 7f ff fe df call 400037c0 <jffs2_iput> <== NOT EXECUTED
40003c48: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return ERR_PTR(err);
40003c4c: 81 c7 e0 08 ret <== NOT EXECUTED
40003c50: 81 e8 00 00 restore <== NOT EXECUTED
}
40003c54: 81 c7 e0 08 ret <== NOT EXECUTED
40003c58: 91 e8 3f f4 restore %g0, -12, %o0 <== NOT EXECUTED
400037c0 <jffs2_iput>:
{
400037c0: 9d e3 bf a0 save %sp, -96, %sp
400037c4: 10 80 00 19 b 40003828 <jffs2_iput+0x68>
400037c8: b2 10 00 18 mov %i0, %i1
if (!i->i_nlink) {
400037cc: 80 a0 60 00 cmp %g1, 0
400037d0: 32 80 00 22 bne,a 40003858 <jffs2_iput+0x98>
400037d4: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
if (i->i_cache_prev)
400037d8: c4 06 60 64 ld [ %i1 + 0x64 ], %g2
400037dc: 80 a0 a0 00 cmp %g2, 0
400037e0: 02 80 00 04 be 400037f0 <jffs2_iput+0x30> <== NEVER TAKEN
400037e4: c2 06 60 68 ld [ %i1 + 0x68 ], %g1
i->i_cache_prev->i_cache_next = i->i_cache_next;
400037e8: c2 20 a0 68 st %g1, [ %g2 + 0x68 ]
if (i->i_cache_next)
400037ec: c2 06 60 68 ld [ %i1 + 0x68 ], %g1
400037f0: 80 a0 60 00 cmp %g1, 0
400037f4: 32 80 00 02 bne,a 400037fc <jffs2_iput+0x3c>
400037f8: c4 20 60 64 st %g2, [ %g1 + 0x64 ]
jffs2_do_clear_inode(c, f);
400037fc: 92 06 60 48 add %i1, 0x48, %o1
40003800: d0 06 60 40 ld [ %i1 + 0x40 ], %o0
40003804: 40 00 19 80 call 40009e04 <jffs2_do_clear_inode>
40003808: fa 06 60 34 ld [ %i1 + 0x34 ], %i5
free(i);
4000380c: 40 00 2d 4a call 4000ed34 <free>
40003810: 90 10 00 19 mov %i1, %o0
if (parent && parent != i) {
40003814: 80 a7 60 00 cmp %i5, 0
40003818: 02 80 00 0e be 40003850 <jffs2_iput+0x90>
4000381c: 80 a6 40 1d cmp %i1, %i5
40003820: 02 80 00 0c be 40003850 <jffs2_iput+0x90> <== NEVER TAKEN
40003824: b2 10 00 1d mov %i5, %i1
assert(i != NULL);
40003828: 80 a6 60 00 cmp %i1, 0
4000382c: 02 80 00 0e be 40003864 <jffs2_iput+0xa4> <== NEVER TAKEN
40003830: 17 10 00 77 sethi %hi(0x4001dc00), %o3
i->i_count--;
40003834: c2 06 60 04 ld [ %i1 + 4 ], %g1
40003838: 82 00 7f ff add %g1, -1, %g1
if (i->i_count < 0)
4000383c: 80 a0 60 00 cmp %g1, 0
40003840: 06 80 00 10 bl 40003880 <jffs2_iput+0xc0> <== NEVER TAKEN
40003844: c2 26 60 04 st %g1, [ %i1 + 4 ]
if (i->i_count)
40003848: 22 bf ff e1 be,a 400037cc <jffs2_iput+0xc>
4000384c: c2 16 60 0c lduh [ %i1 + 0xc ], %g1
}
40003850: 81 c7 e0 08 ret
40003854: 81 e8 00 00 restore
icache_evict(i->i_sb->s_root, i);
40003858: f0 00 60 e0 ld [ %g1 + 0xe0 ], %i0
4000385c: 7f ff fc f7 call 40002c38 <icache_evict>
40003860: 81 e8 00 00 restore
assert(i != NULL);
40003864: 15 10 00 78 sethi %hi(0x4001e000), %o2 <== NOT EXECUTED
40003868: 11 10 00 77 sethi %hi(0x4001dc00), %o0 <== NOT EXECUTED
4000386c: 96 12 e3 88 or %o3, 0x388, %o3 <== NOT EXECUTED
40003870: 94 12 a0 80 or %o2, 0x80, %o2 <== NOT EXECUTED
40003874: 92 10 25 a3 mov 0x5a3, %o1 <== NOT EXECUTED
40003878: 40 00 2c 40 call 4000e978 <__assert_func> <== NOT EXECUTED
4000387c: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
BUG();
40003880: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
40003884: 15 10 00 78 sethi %hi(0x4001e000), %o2 <== NOT EXECUTED
40003888: 11 10 00 77 sethi %hi(0x4001dc00), %o0 <== NOT EXECUTED
4000388c: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
40003890: 94 12 a0 80 or %o2, 0x80, %o2 <== NOT EXECUTED
40003894: 92 10 25 a8 mov 0x5a8, %o1 <== NOT EXECUTED
40003898: 40 00 2c 38 call 4000e978 <__assert_func> <== NOT EXECUTED
4000389c: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
400038a0: 01 00 00 00 nop <== NOT EXECUTED
400068c4 <jffs2_kill_fragtree>:
/* Pass 'c' argument to indicate that nodes should be marked obsolete as
they're killed. */
void jffs2_kill_fragtree(struct rb_root *root, struct jffs2_sb_info *c)
{
400068c4: 9d e3 bf a0 save %sp, -96, %sp
struct jffs2_node_frag *frag, *next;
dbg_fragtree("killing\n");
rbtree_postorder_for_each_entry_safe(frag, next, root, rb) {
400068c8: 92 10 20 00 clr %o1
400068cc: 40 00 3c a5 call 40015b60 <_RBTree_Postorder_first>
400068d0: 90 10 00 18 mov %i0, %o0
400068d4: ba 92 20 00 orcc %o0, 0, %i5
400068d8: 02 80 00 1b be 40006944 <jffs2_kill_fragtree+0x80>
400068dc: 90 10 00 1d mov %i5, %o0
400068e0: 40 00 3c 8b call 40015b0c <_RBTree_Postorder_next>
400068e4: 92 10 20 00 clr %o1
if (frag->node && !(--frag->node->frags)) {
400068e8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
400068ec: b8 10 00 1d mov %i5, %i4
400068f0: 80 a0 60 00 cmp %g1, 0
400068f4: 02 80 00 0f be 40006930 <jffs2_kill_fragtree+0x6c> <== NEVER TAKEN
400068f8: ba 10 00 08 mov %o0, %i5
400068fc: c4 00 60 0c ld [ %g1 + 0xc ], %g2
40006900: 84 00 bf ff add %g2, -1, %g2
40006904: 80 a0 a0 00 cmp %g2, 0
40006908: 12 80 00 0a bne 40006930 <jffs2_kill_fragtree+0x6c> <== NEVER TAKEN
4000690c: c4 20 60 0c st %g2, [ %g1 + 0xc ]
/* Not a hole, and it's the final remaining frag
of this node. Free the node */
if (c)
40006910: 90 96 60 00 orcc %i1, 0, %o0
40006914: 02 80 00 05 be 40006928 <jffs2_kill_fragtree+0x64>
40006918: 01 00 00 00 nop
jffs2_mark_node_obsolete(c, frag->node->raw);
4000691c: 40 00 01 7d call 40006f10 <jffs2_mark_node_obsolete>
40006920: d2 00 40 00 ld [ %g1 ], %o1
jffs2_free_full_dnode(frag->node);
40006924: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
40006928: 7f ff fc a0 call 40005ba8 <jffs2_free_full_dnode>
4000692c: 90 10 00 01 mov %g1, %o0
}
jffs2_free_node_frag(frag);
40006930: 7f ff fc ef call 40005cec <jffs2_free_node_frag>
40006934: 90 10 00 1c mov %i4, %o0
rbtree_postorder_for_each_entry_safe(frag, next, root, rb) {
40006938: 80 a7 60 00 cmp %i5, 0
4000693c: 12 bf ff e9 bne 400068e0 <jffs2_kill_fragtree+0x1c>
40006940: 90 10 00 1d mov %i5, %o0
cond_resched();
}
}
40006944: 81 c7 e0 08 ret
40006948: 81 e8 00 00 restore
4000c0dc <jffs2_link>:
/***********************************************************************/
int jffs2_link (struct _inode *old_d_inode, struct _inode *dir_i, const unsigned char *d_name, size_t d_namelen)
{
4000c0dc: 9d e3 bf 90 save %sp, -112, %sp
struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_d_inode);
struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
int ret;
/* XXX: This is ugly */
uint8_t type = (old_d_inode->i_mode & S_IFMT) >> 12;
4000c0e0: c2 06 20 08 ld [ %i0 + 8 ], %g1
4000c0e4: 83 30 60 0c srl %g1, 0xc, %g1
struct jffs2_sb_info *c = JFFS2_SB_INFO(old_d_inode->i_sb);
4000c0e8: f8 06 20 40 ld [ %i0 + 0x40 ], %i4
uint8_t type = (old_d_inode->i_mode & S_IFMT) >> 12;
4000c0ec: 82 08 60 0f and %g1, 0xf, %g1
struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i);
4000c0f0: b2 06 60 48 add %i1, 0x48, %i1
if (!type) type = DT_REG;
4000c0f4: 80 a0 60 00 cmp %g1, 0
4000c0f8: 12 80 00 03 bne 4000c104 <jffs2_link+0x28> <== ALWAYS TAKEN
4000c0fc: ba 10 00 01 mov %g1, %i5
4000c100: ba 10 20 08 mov 8, %i5 <== NOT EXECUTED
ret = jffs2_do_link(c, dir_f, f->inocache->ino, type,
4000c104: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
4000c108: d4 00 60 0c ld [ %g1 + 0xc ], %o2
4000c10c: d4 27 bf fc st %o2, [ %fp + -4 ]
(const char * )d_name,
d_namelen, get_seconds());
4000c110: 40 00 45 35 call 4001d5e4 <time>
4000c114: 90 10 20 00 clr %o0
ret = jffs2_do_link(c, dir_f, f->inocache->ino, type,
4000c118: d2 23 a0 5c st %o1, [ %sp + 0x5c ]
4000c11c: 9a 10 00 1b mov %i3, %o5
4000c120: d4 07 bf fc ld [ %fp + -4 ], %o2
4000c124: 98 10 00 1a mov %i2, %o4
4000c128: 96 0f 60 0f and %i5, 0xf, %o3
4000c12c: 92 10 00 19 mov %i1, %o1
4000c130: 7f ff fc 17 call 4000b18c <jffs2_do_link>
4000c134: 90 10 00 1c mov %i4, %o0
if (!ret) {
4000c138: 80 a2 20 00 cmp %o0, 0
4000c13c: 12 80 00 07 bne 4000c158 <jffs2_link+0x7c> <== NEVER TAKEN
4000c140: 01 00 00 00 nop
mutex_lock(&f->sem);
old_d_inode->i_nlink = ++f->inocache->pino_nlink;
4000c144: c4 06 20 5c ld [ %i0 + 0x5c ], %g2
4000c148: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
4000c14c: 82 00 60 01 inc %g1
4000c150: c2 20 a0 14 st %g1, [ %g2 + 0x14 ]
4000c154: c2 36 20 0c sth %g1, [ %i0 + 0xc ]
mutex_unlock(&f->sem);
}
return ret;
}
4000c158: 81 c7 e0 08 ret
4000c15c: 91 e8 00 08 restore %g0, %o0, %o0
4000694c <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)
{
4000694c: 9d e3 bf 98 save %sp, -104, %sp
struct jffs2_raw_node_ref *ref;
BUG_ON(!jeb->allocated_refs);
40006950: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
40006954: 80 a0 60 00 cmp %g1, 0
40006958: 02 80 00 64 be 40006ae8 <jffs2_link_node_ref+0x19c> <== NEVER TAKEN
4000695c: 82 00 7f ff add %g1, -1, %g1
jeb->allocated_refs--;
ref = jeb->last_node;
40006960: c6 06 60 2c ld [ %i1 + 0x2c ], %g3
jeb->allocated_refs--;
40006964: c2 26 60 24 st %g1, [ %i1 + 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) {
40006968: c2 00 e0 04 ld [ %g3 + 4 ], %g1
4000696c: 80 a0 7f fe cmp %g1, -2
40006970: 12 80 00 07 bne 4000698c <jffs2_link_node_ref+0x40>
40006974: 94 10 00 03 mov %g3, %o2
}
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;
40006978: 10 80 00 0e b 400069b0 <jffs2_link_node_ref+0x64>
4000697c: f4 22 a0 04 st %i2, [ %o2 + 4 ]
while (ref->flash_offset != REF_EMPTY_NODE) {
40006980: 80 a0 7f fe cmp %g1, -2
40006984: 02 80 00 0a be 400069ac <jffs2_link_node_ref+0x60>
40006988: 94 02 a0 08 add %o2, 8, %o2
if (ref->flash_offset == REF_LINK_NODE)
4000698c: 80 a0 7f ff cmp %g1, -1
40006990: 32 bf ff fc bne,a 40006980 <jffs2_link_node_ref+0x34>
40006994: c2 02 a0 0c ld [ %o2 + 0xc ], %g1
ref = ref->next_in_ino;
40006998: d4 02 80 00 ld [ %o2 ], %o2
while (ref->flash_offset != REF_EMPTY_NODE) {
4000699c: c2 02 a0 04 ld [ %o2 + 4 ], %g1
400069a0: 80 a0 7f fe cmp %g1, -2
400069a4: 12 bf ff fb bne 40006990 <jffs2_link_node_ref+0x44> <== NEVER TAKEN
400069a8: 80 a0 7f ff cmp %g1, -1
ref->flash_offset = ofs;
400069ac: f4 22 a0 04 st %i2, [ %o2 + 4 ]
if (!jeb->first_node) {
jeb->first_node = ref;
BUG_ON(ref_offset(ref) != jeb->offset);
400069b0: 98 0e bf fc and %i2, -4, %o4
if (!jeb->first_node) {
400069b4: c4 06 60 28 ld [ %i1 + 0x28 ], %g2
400069b8: 80 a0 a0 00 cmp %g2, 0
400069bc: 02 80 00 3e be 40006ab4 <jffs2_link_node_ref+0x168>
400069c0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
} else if (unlikely(ref_offset(ref) != jeb->offset + c->sector_size - jeb->free_size)) {
400069c4: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
400069c8: c8 06 20 34 ld [ %i0 + 0x34 ], %g4
400069cc: 82 00 40 04 add %g1, %g4, %g1
400069d0: 82 20 40 02 sub %g1, %g2, %g1
400069d4: 80 a0 40 0c cmp %g1, %o4
400069d8: 32 80 00 4c bne,a 40006b08 <jffs2_link_node_ref+0x1bc> <== NEVER TAKEN
400069dc: c4 00 e0 0c ld [ %g3 + 0xc ], %g2 <== NOT EXECUTED
ref_offset(jeb->last_node)+last_len);
BUG();
}
jeb->last_node = ref;
if (ic) {
400069e0: 80 a7 20 00 cmp %i4, 0
400069e4: 02 80 00 32 be 40006aac <jffs2_link_node_ref+0x160>
400069e8: d4 26 60 2c st %o2, [ %i1 + 0x2c ]
ref->next_in_ino = ic->nodes;
400069ec: c2 07 20 04 ld [ %i4 + 4 ], %g1
400069f0: c2 22 80 00 st %g1, [ %o2 ]
ic->nodes = ref;
400069f4: d4 27 20 04 st %o2, [ %i4 + 4 ]
} else {
ref->next_in_ino = NULL;
}
switch(ref_flags(ref)) {
400069f8: b4 0e a0 03 and %i2, 3, %i2
400069fc: 80 a6 a0 01 cmp %i2, 1
40006a00: 02 80 00 12 be 40006a48 <jffs2_link_node_ref+0xfc>
40006a04: b4 06 bf fe add %i2, -2, %i2
40006a08: 80 a6 a0 01 cmp %i2, 1
40006a0c: 38 80 00 1c bgu,a 40006a7c <jffs2_link_node_ref+0x130> <== NEVER TAKEN
40006a10: c6 06 20 38 ld [ %i0 + 0x38 ], %g3 <== NOT EXECUTED
jeb->unchecked_size += len;
break;
case REF_NORMAL:
case REF_PRISTINE:
c->used_size += len;
40006a14: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
jeb->used_size += len;
40006a18: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
c->used_size += len;
40006a1c: 86 00 c0 1b add %g3, %i3, %g3
jeb->used_size += len;
40006a20: 82 00 40 1b add %g1, %i3, %g1
c->used_size += len;
40006a24: c6 26 20 1c st %g3, [ %i0 + 0x1c ]
c->dirty_size += len;
jeb->dirty_size += len;
break;
}
c->free_size -= len;
jeb->free_size -= len;
40006a28: 84 20 80 1b sub %g2, %i3, %g2
jeb->used_size += len;
40006a2c: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
c->free_size -= len;
40006a30: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
40006a34: b6 20 40 1b sub %g1, %i3, %i3
40006a38: f6 26 20 28 st %i3, [ %i0 + 0x28 ]
jeb->free_size -= len;
40006a3c: c4 26 60 20 st %g2, [ %i1 + 0x20 ]
/* Set (and test) __totlen field... for now */
ref->__totlen = len;
ref_totlen(c, jeb, ref);
#endif
return ref;
}
40006a40: 81 c7 e0 08 ret
40006a44: 91 e8 00 0a restore %g0, %o2, %o0
c->dirty_size += len;
40006a48: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
jeb->dirty_size += len;
40006a4c: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
c->dirty_size += len;
40006a50: 86 00 c0 1b add %g3, %i3, %g3
jeb->dirty_size += len;
40006a54: 82 00 40 1b add %g1, %i3, %g1
c->dirty_size += len;
40006a58: c6 26 20 20 st %g3, [ %i0 + 0x20 ]
jeb->free_size -= len;
40006a5c: 84 20 80 1b sub %g2, %i3, %g2
jeb->dirty_size += len;
40006a60: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
c->free_size -= len;
40006a64: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
40006a68: b6 20 40 1b sub %g1, %i3, %i3
40006a6c: f6 26 20 28 st %i3, [ %i0 + 0x28 ]
jeb->free_size -= len;
40006a70: c4 26 60 20 st %g2, [ %i1 + 0x20 ]
}
40006a74: 81 c7 e0 08 ret
40006a78: 91 e8 00 0a restore %g0, %o2, %o0
jeb->unchecked_size += len;
40006a7c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 <== NOT EXECUTED
c->unchecked_size += len;
40006a80: 86 00 c0 1b add %g3, %i3, %g3 <== NOT EXECUTED
jeb->unchecked_size += len;
40006a84: 82 00 40 1b add %g1, %i3, %g1 <== NOT EXECUTED
c->unchecked_size += len;
40006a88: c6 26 20 38 st %g3, [ %i0 + 0x38 ] <== NOT EXECUTED
jeb->free_size -= len;
40006a8c: 84 20 80 1b sub %g2, %i3, %g2 <== NOT EXECUTED
jeb->unchecked_size += len;
40006a90: c2 26 60 10 st %g1, [ %i1 + 0x10 ] <== NOT EXECUTED
c->free_size -= len;
40006a94: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
40006a98: b6 20 40 1b sub %g1, %i3, %i3 <== NOT EXECUTED
40006a9c: f6 26 20 28 st %i3, [ %i0 + 0x28 ] <== NOT EXECUTED
jeb->free_size -= len;
40006aa0: c4 26 60 20 st %g2, [ %i1 + 0x20 ] <== NOT EXECUTED
}
40006aa4: 81 c7 e0 08 ret <== NOT EXECUTED
40006aa8: 91 e8 00 0a restore %g0, %o2, %o0 <== NOT EXECUTED
ref->next_in_ino = NULL;
40006aac: 10 bf ff d3 b 400069f8 <jffs2_link_node_ref+0xac>
40006ab0: c0 22 80 00 clr [ %o2 ]
BUG_ON(ref_offset(ref) != jeb->offset);
40006ab4: 80 a3 00 01 cmp %o4, %g1
40006ab8: 12 80 00 04 bne 40006ac8 <jffs2_link_node_ref+0x17c> <== NEVER TAKEN
40006abc: d4 26 60 28 st %o2, [ %i1 + 0x28 ]
} else if (unlikely(ref_offset(ref) != jeb->offset + c->sector_size - jeb->free_size)) {
40006ac0: 10 bf ff c8 b 400069e0 <jffs2_link_node_ref+0x94>
40006ac4: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
BUG_ON(ref_offset(ref) != jeb->offset);
40006ac8: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
40006acc: 15 10 00 7b sethi %hi(0x4001ec00), %o2 <== NOT EXECUTED
40006ad0: 11 10 00 7b sethi %hi(0x4001ec00), %o0 <== NOT EXECUTED
40006ad4: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
40006ad8: 94 12 a3 98 or %o2, 0x398, %o2 <== NOT EXECUTED
40006adc: 92 10 22 68 mov 0x268, %o1 <== NOT EXECUTED
40006ae0: 40 00 1f a6 call 4000e978 <__assert_func> <== NOT EXECUTED
40006ae4: 90 12 22 08 or %o0, 0x208, %o0 <== NOT EXECUTED
BUG_ON(!jeb->allocated_refs);
40006ae8: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
40006aec: 15 10 00 7b sethi %hi(0x4001ec00), %o2 <== NOT EXECUTED
40006af0: 11 10 00 7b sethi %hi(0x4001ec00), %o0 <== NOT EXECUTED
40006af4: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
40006af8: 94 12 a3 98 or %o2, 0x398, %o2 <== NOT EXECUTED
40006afc: 92 10 22 52 mov 0x252, %o1 <== NOT EXECUTED
40006b00: 40 00 1f 9e call 4000e978 <__assert_func> <== NOT EXECUTED
40006b04: 90 12 22 08 or %o0, 0x208, %o0 <== NOT EXECUTED
if (ref->flash_offset == REF_LINK_NODE) {
40006b08: 80 a0 bf ff cmp %g2, -1 <== NOT EXECUTED
40006b0c: 02 80 00 17 be 40006b68 <jffs2_link_node_ref+0x21c> <== NOT EXECUTED
40006b10: 84 00 e0 08 add %g3, 8, %g2 <== NOT EXECUTED
if (ref->flash_offset == REF_EMPTY_NODE)
40006b14: c4 00 a0 04 ld [ %g2 + 4 ], %g2 <== NOT EXECUTED
40006b18: 80 a0 bf fe cmp %g2, -2 <== NOT EXECUTED
40006b1c: 32 80 00 02 bne,a 40006b24 <jffs2_link_node_ref+0x1d8> <== NOT EXECUTED
40006b20: 82 08 bf fc and %g2, -4, %g1 <== 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);
40006b24: da 00 e0 04 ld [ %g3 + 4 ], %o5 <== NOT EXECUTED
JFFS2_ERROR("Adding new ref %p at (0x%08x-0x%08x) not immediately after previous (0x%08x-0x%08x)\n",
40006b28: c2 23 a0 5c st %g1, [ %sp + 0x5c ] <== NOT EXECUTED
40006b2c: 96 10 00 0c mov %o4, %o3 <== NOT EXECUTED
40006b30: 3b 10 00 7b sethi %hi(0x4001ec00), %i5 <== NOT EXECUTED
40006b34: 9a 0b 7f fc and %o5, -4, %o5 <== NOT EXECUTED
40006b38: 92 17 63 98 or %i5, 0x398, %o1 <== NOT EXECUTED
40006b3c: 98 06 c0 0c add %i3, %o4, %o4 <== NOT EXECUTED
40006b40: 11 10 00 7b sethi %hi(0x4001ec00), %o0 <== NOT EXECUTED
40006b44: 7f ff fc 8a call 40005d6c <jffs2_printk> <== NOT EXECUTED
40006b48: 90 12 22 78 or %o0, 0x278, %o0 ! 4001ee78 <__func__.4+0xc8> <== NOT EXECUTED
BUG();
40006b4c: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
40006b50: 11 10 00 7b sethi %hi(0x4001ec00), %o0 <== NOT EXECUTED
40006b54: 94 17 63 98 or %i5, 0x398, %o2 <== NOT EXECUTED
40006b58: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
40006b5c: 92 10 22 70 mov 0x270, %o1 <== NOT EXECUTED
40006b60: 40 00 1f 86 call 4000e978 <__assert_func> <== NOT EXECUTED
40006b64: 90 12 22 08 or %o0, 0x208, %o0 <== NOT EXECUTED
ref = ref->next_in_ino;
40006b68: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED
if (!ref)
40006b6c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40006b70: 32 bf ff ea bne,a 40006b18 <jffs2_link_node_ref+0x1cc> <== NOT EXECUTED
40006b74: c4 00 a0 04 ld [ %g2 + 4 ], %g2 <== NOT EXECUTED
40006b78: 10 bf ff ec b 40006b28 <jffs2_link_node_ref+0x1dc> <== NOT EXECUTED
40006b7c: da 00 e0 04 ld [ %g3 + 4 ], %o5 <== NOT EXECUTED
4000be74 <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)
{
4000be74: 9d e3 bf a0 save %sp, -96, %sp
4000be78: 80 a6 a0 00 cmp %i2, 0
4000be7c: 02 80 00 0c be 4000beac <jffs2_lookup+0x38> <== NEVER TAKEN
4000be80: ba 10 20 00 clr %i5
4000be84: 88 06 40 1a add %i1, %i2, %g4
4000be88: 82 10 00 19 mov %i1, %g1
hash ^= *(name++);
4000be8c: c4 08 40 00 ldub [ %g1 ], %g2
hash = (hash << 4) | (hash >> 28);
4000be90: 87 2f 60 04 sll %i5, 4, %g3
hash ^= *(name++);
4000be94: 82 00 60 01 inc %g1
hash = (hash << 4) | (hash >> 28);
4000be98: bb 37 60 1c srl %i5, 0x1c, %i5
while (len--) {
4000be9c: 80 a1 00 01 cmp %g4, %g1
hash = (hash << 4) | (hash >> 28);
4000bea0: ba 17 40 03 or %i5, %g3, %i5
while (len--) {
4000bea4: 12 bf ff fa bne 4000be8c <jffs2_lookup+0x18>
4000bea8: ba 18 80 1d xor %g2, %i5, %i5
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) {
4000beac: f8 06 20 54 ld [ %i0 + 0x54 ], %i4
4000beb0: 80 a7 20 00 cmp %i4, 0
4000beb4: 12 80 00 07 bne 4000bed0 <jffs2_lookup+0x5c>
4000beb8: b6 10 20 00 clr %i3
inode->i_fd = fd;
}
}
return inode;
}
4000bebc: 81 c7 e0 08 ret
4000bec0: 91 e8 00 1c restore %g0, %i4, %o0
for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= hash; fd_list = fd_list->next) {
4000bec4: 80 a7 20 00 cmp %i4, 0
4000bec8: 02 80 00 23 be 4000bf54 <jffs2_lookup+0xe0>
4000becc: 80 a6 e0 00 cmp %i3, 0
4000bed0: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
4000bed4: 80 a0 40 1d cmp %g1, %i5
4000bed8: 38 80 00 1f bgu,a 4000bf54 <jffs2_lookup+0xe0>
4000bedc: 80 a6 e0 00 cmp %i3, 0
if (fd_list->nhash == hash &&
4000bee0: 32 bf ff f9 bne,a 4000bec4 <jffs2_lookup+0x50>
4000bee4: f8 07 20 04 ld [ %i4 + 4 ], %i4
strlen((char *)fd_list->name) == namelen &&
4000bee8: a0 07 20 15 add %i4, 0x15, %l0
if (fd_list->nhash == hash &&
4000beec: 80 a6 e0 00 cmp %i3, 0
4000bef0: 02 80 00 07 be 4000bf0c <jffs2_lookup+0x98> <== ALWAYS TAKEN
4000bef4: 90 10 00 10 mov %l0, %o0
(!fd || fd_list->version > fd->version) &&
4000bef8: c4 07 20 08 ld [ %i4 + 8 ], %g2 <== NOT EXECUTED
4000befc: c2 06 e0 08 ld [ %i3 + 8 ], %g1 <== NOT EXECUTED
4000bf00: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4000bf04: 28 bf ff f0 bleu,a 4000bec4 <jffs2_lookup+0x50> <== NOT EXECUTED
4000bf08: f8 07 20 04 ld [ %i4 + 4 ], %i4 <== NOT EXECUTED
strlen((char *)fd_list->name) == namelen &&
4000bf0c: 40 00 45 38 call 4001d3ec <strlen>
4000bf10: 01 00 00 00 nop
(!fd || fd_list->version > fd->version) &&
4000bf14: 80 a2 00 1a cmp %o0, %i2
4000bf18: 32 bf ff eb bne,a 4000bec4 <jffs2_lookup+0x50> <== NEVER TAKEN
4000bf1c: f8 07 20 04 ld [ %i4 + 4 ], %i4 <== NOT EXECUTED
!strncmp((char *)fd_list->name, (char *)name, namelen)) {
4000bf20: 94 10 00 1a mov %i2, %o2
4000bf24: 92 10 00 19 mov %i1, %o1
4000bf28: 40 00 45 5b call 4001d494 <strncmp>
4000bf2c: 90 10 00 10 mov %l0, %o0
strlen((char *)fd_list->name) == namelen &&
4000bf30: 80 a2 20 00 cmp %o0, 0
4000bf34: 32 bf ff e4 bne,a 4000bec4 <jffs2_lookup+0x50> <== NEVER TAKEN
4000bf38: f8 07 20 04 ld [ %i4 + 4 ], %i4 <== NOT EXECUTED
4000bf3c: b6 10 00 1c mov %i4, %i3
for (fd_list = dir_f->dents; fd_list && fd_list->nhash <= hash; fd_list = fd_list->next) {
4000bf40: f8 07 20 04 ld [ %i4 + 4 ], %i4
4000bf44: 80 a7 20 00 cmp %i4, 0
4000bf48: 32 bf ff e3 bne,a 4000bed4 <jffs2_lookup+0x60>
4000bf4c: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
if (fd)
4000bf50: 80 a6 e0 00 cmp %i3, 0
4000bf54: 02 80 00 0d be 4000bf88 <jffs2_lookup+0x114>
4000bf58: b8 10 20 00 clr %i4
ino = fd->ino;
4000bf5c: fa 06 e0 0c ld [ %i3 + 0xc ], %i5
if (ino) {
4000bf60: 80 a7 60 00 cmp %i5, 0
4000bf64: 22 80 00 0a be,a 4000bf8c <jffs2_lookup+0x118>
4000bf68: b0 10 00 1c mov %i4, %i0
inode = jffs2_iget(dir_i->i_sb, ino);
4000bf6c: d0 06 20 40 ld [ %i0 + 0x40 ], %o0
4000bf70: 7f ff df 3b call 40003c5c <jffs2_iget>
4000bf74: 92 10 00 1d mov %i5, %o1
if (IS_ERR(inode)) {
4000bf78: 80 a2 3c 18 cmp %o0, -1000
4000bf7c: 18 80 00 06 bgu 4000bf94 <jffs2_lookup+0x120> <== NEVER TAKEN
4000bf80: b8 10 00 08 mov %o0, %i4
inode->i_fd = fd;
4000bf84: f6 22 20 44 st %i3, [ %o0 + 0x44 ]
}
4000bf88: b0 10 00 1c mov %i4, %i0
4000bf8c: 81 c7 e0 08 ret
4000bf90: 81 e8 00 00 restore
printk("jffs2_iget() failed for ino #%lu\n", ino);
4000bf94: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000bf98: 11 10 00 82 sethi %hi(0x40020800), %o0 <== NOT EXECUTED
4000bf9c: 7f ff ff aa call 4000be44 <jffs2_printk> <== NOT EXECUTED
4000bfa0: 90 12 21 70 or %o0, 0x170, %o0 ! 40020970 <__func__.0+0x28> <== NOT EXECUTED
return inode;
4000bfa4: 81 c7 e0 08 ret <== NOT EXECUTED
4000bfa8: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
40006850 <jffs2_lookup_node_frag>:
next = fragtree->rb_node;
40006850: c2 02 00 00 ld [ %o0 ], %g1
while(next) {
40006854: 80 a0 60 00 cmp %g1, 0
40006858: 02 80 00 13 be 400068a4 <jffs2_lookup_node_frag+0x54> <== NEVER TAKEN
4000685c: 90 10 20 00 clr %o0
if (frag->ofs + frag->size <= offset) {
40006860: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
40006864: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
40006868: 84 00 c0 02 add %g3, %g2, %g2
4000686c: 80 a0 80 09 cmp %g2, %o1
40006870: 18 80 00 0f bgu 400068ac <jffs2_lookup_node_frag+0x5c>
40006874: 80 a0 c0 09 cmp %g3, %o1
if (!prev || frag->ofs > prev->ofs)
40006878: 80 a2 20 00 cmp %o0, 0
4000687c: 22 80 00 06 be,a 40006894 <jffs2_lookup_node_frag+0x44>
40006880: 90 10 00 01 mov %g1, %o0
40006884: c4 02 20 18 ld [ %o0 + 0x18 ], %g2
40006888: 80 a0 c0 02 cmp %g3, %g2
4000688c: 38 80 00 02 bgu,a 40006894 <jffs2_lookup_node_frag+0x44> <== ALWAYS TAKEN
40006890: 90 10 00 01 mov %g1, %o0
next = frag->rb.rb_right;
40006894: c2 00 60 04 ld [ %g1 + 4 ], %g1
while(next) {
40006898: 80 a0 60 00 cmp %g1, 0
4000689c: 32 bf ff f2 bne,a 40006864 <jffs2_lookup_node_frag+0x14> <== ALWAYS TAKEN
400068a0: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
400068a4: 81 c3 e0 08 retl <== NOT EXECUTED
400068a8: 01 00 00 00 nop <== NOT EXECUTED
} else if (frag->ofs > offset) {
400068ac: 08 80 00 04 bleu 400068bc <jffs2_lookup_node_frag+0x6c>
400068b0: 01 00 00 00 nop
400068b4: 10 bf ff f9 b 40006898 <jffs2_lookup_node_frag+0x48>
400068b8: c2 00 40 00 ld [ %g1 ], %g1
prev->ofs, prev->ofs+prev->size);
else
dbg_fragtree2("returning NULL, empty fragtree\n");
return prev;
}
400068bc: 81 c3 e0 08 retl
400068c0: 90 10 00 01 mov %g1, %o0
40006f10 <jffs2_mark_node_obsolete>:
}
return 0;
}
void jffs2_mark_node_obsolete(struct jffs2_sb_info *c, struct jffs2_raw_node_ref *ref)
{
40006f10: 9d e3 bf 90 save %sp, -112, %sp
struct jffs2_unknown_node n;
int ret, addedsize;
size_t retlen;
uint32_t freed_len;
if(unlikely(!ref)) {
40006f14: 80 a6 60 00 cmp %i1, 0
40006f18: 22 80 00 ed be,a 400072cc <jffs2_mark_node_obsolete+0x3bc> <== NEVER TAKEN
40006f1c: 31 10 00 7c sethi %hi(0x4001f000), %i0 <== NOT EXECUTED
pr_notice("EEEEEK. jffs2_mark_node_obsolete called with NULL node\n");
return;
}
if (ref_obsolete(ref)) {
40006f20: d2 06 60 04 ld [ %i1 + 4 ], %o1
40006f24: 82 0a 60 03 and %o1, 3, %g1
40006f28: 80 a0 60 01 cmp %g1, 1
40006f2c: 02 80 01 25 be 400073c0 <jffs2_mark_node_obsolete+0x4b0> <== NEVER TAKEN
40006f30: 01 00 00 00 nop
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;
if (blocknr >= c->nr_blocks) {
40006f34: c4 06 20 50 ld [ %i0 + 0x50 ], %g2
blocknr = ref->flash_offset / c->sector_size;
40006f38: 81 80 20 00 wr %g0, %y
40006f3c: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
40006f40: 01 00 00 00 nop
40006f44: 01 00 00 00 nop
40006f48: 82 72 40 01 udiv %o1, %g1, %g1
if (blocknr >= c->nr_blocks) {
40006f4c: 80 a0 40 02 cmp %g1, %g2
40006f50: 1a 80 01 1e bcc 400073c8 <jffs2_mark_node_obsolete+0x4b8> <== NEVER TAKEN
40006f54: b6 58 60 34 smul %g1, 0x34, %i3
pr_notice("raw node at 0x%08x is off the end of device!\n",
ref->flash_offset);
BUG();
}
jeb = &c->blocks[blocknr];
40006f58: f4 06 20 54 ld [ %i0 + 0x54 ], %i2
mutex_lock(&c->erase_free_sem);
}
spin_lock(&c->erase_completion_lock);
freed_len = ref_totlen(c, jeb, ref);
40006f5c: 94 10 00 19 mov %i1, %o2
jeb = &c->blocks[blocknr];
40006f60: ba 06 80 1b add %i2, %i3, %i5
freed_len = ref_totlen(c, jeb, ref);
40006f64: 90 10 00 18 mov %i0, %o0
40006f68: 7f ff ff 3d call 40006c5c <__jffs2_ref_totlen>
40006f6c: 92 10 00 1d mov %i5, %o1
if (ref_flags(ref) == REF_UNCHECKED) {
40006f70: c4 06 60 04 ld [ %i1 + 4 ], %g2
40006f74: 80 88 a0 03 btst 3, %g2
40006f78: 02 80 00 56 be 400070d0 <jffs2_mark_node_obsolete+0x1c0> <== NEVER TAKEN
40006f7c: b8 10 00 08 mov %o0, %i4
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;
40006f80: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
c->used_size -= freed_len;
40006f84: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
jeb->used_size -= freed_len;
40006f88: 86 20 c0 08 sub %g3, %o0, %g3
40006f8c: c6 27 60 14 st %g3, [ %i5 + 0x14 ]
c->used_size -= freed_len;
40006f90: 82 20 40 08 sub %g1, %o0, %g1
40006f94: c2 26 20 1c st %g1, [ %i0 + 0x1c ]
}
// Take care, that wasted size is taken into concern
if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) {
40006f98: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
40006f9c: 80 a0 60 00 cmp %g1, 0
40006fa0: 12 80 00 06 bne 40006fb8 <jffs2_mark_node_obsolete+0xa8>
40006fa4: c8 07 60 1c ld [ %i5 + 0x1c ], %g4
40006fa8: 86 07 00 04 add %i4, %g4, %g3
40006fac: 80 a0 e0 c4 cmp %g3, 0xc4
40006fb0: 28 80 00 51 bleu,a 400070f4 <jffs2_mark_node_obsolete+0x1e4>
40006fb4: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40006fb8: c6 06 20 58 ld [ %i0 + 0x58 ], %g3
40006fbc: 80 a0 c0 1d cmp %g3, %i5
40006fc0: 02 80 00 4b be 400070ec <jffs2_mark_node_obsolete+0x1dc>
40006fc4: 86 07 00 01 add %i4, %g1, %g3
jffs2_dbg(1, "Dirtying\n");
addedsize = freed_len;
jeb->dirty_size += freed_len;
c->dirty_size += freed_len;
40006fc8: da 06 20 20 ld [ %i0 + 0x20 ], %o5
jeb->dirty_size += freed_len;
40006fcc: c6 27 60 18 st %g3, [ %i5 + 0x18 ]
c->dirty_size += freed_len;
40006fd0: 9a 07 00 0d add %i4, %o5, %o5
40006fd4: da 26 20 20 st %o5, [ %i0 + 0x20 ]
/* Convert wasted space to dirty, if not a bad block */
if (jeb->wasted_size) {
40006fd8: 80 a1 20 00 cmp %g4, 0
40006fdc: 12 80 00 6a bne 40007184 <jffs2_mark_node_obsolete+0x274>
40006fe0: a0 10 00 1c mov %i4, %l0
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;
40006fe4: 84 08 bf fc and %g2, -4, %g2
40006fe8: 84 10 a0 01 or %g2, 1, %g2
40006fec: c4 26 60 04 st %g2, [ %i1 + 4 ]
jffs2_dbg_acct_sanity_check_nolock(c, jeb);
40006ff0: 92 10 00 1d mov %i5, %o1
40006ff4: 40 00 13 39 call 4000bcd8 <__jffs2_dbg_acct_sanity_check_nolock>
40006ff8: 90 10 00 18 mov %i0, %o0
jffs2_dbg_acct_paranoia_check_nolock(c, jeb);
if (c->flags & JFFS2_SB_FLAG_SCANNING) {
40006ffc: c2 06 20 0c ld [ %i0 + 0xc ], %g1
40007000: 80 88 60 02 btst 2, %g1
40007004: 12 80 00 ef bne 400073c0 <jffs2_mark_node_obsolete+0x4b0> <== NEVER TAKEN
40007008: 01 00 00 00 nop
spin_unlock(&c->erase_completion_lock);
/* We didn't lock the erase_free_sem */
return;
}
if (jeb == c->nextblock) {
4000700c: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
40007010: 80 a0 40 1d cmp %g1, %i5
40007014: 22 80 00 26 be,a 400070ac <jffs2_mark_node_obsolete+0x19c>
40007018: c2 0e 20 ec ldub [ %i0 + 0xec ], %g1
jffs2_dbg(2, "Not moving nextblock 0x%08x to dirty/erase_pending list\n",
jeb->offset);
} else if (!jeb->used_size && !jeb->unchecked_size) {
4000701c: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
40007020: 80 a0 a0 00 cmp %g2, 0
40007024: 12 80 00 39 bne 40007108 <jffs2_mark_node_obsolete+0x1f8>
40007028: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
4000702c: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
40007030: 80 a0 a0 00 cmp %g2, 0
40007034: 12 80 00 36 bne 4000710c <jffs2_mark_node_obsolete+0x1fc> <== NEVER TAKEN
40007038: 80 a7 40 01 cmp %i5, %g1
if (jeb == c->gcblock) {
4000703c: 22 80 00 06 be,a 40007054 <jffs2_mark_node_obsolete+0x144>
40007040: c0 26 20 5c clr [ %i0 + 0x5c ]
ent->prev->next = ent->next;
40007044: c4 07 60 04 ld [ %i5 + 4 ], %g2
40007048: c2 06 80 1b ld [ %i2 + %i3 ], %g1
4000704c: c2 20 80 00 st %g1, [ %g2 ]
ent->next->prev = ent->prev;
40007050: c4 20 60 04 st %g2, [ %g1 + 4 ]
40007054: 03 10 01 1d sethi %hi(0x40047400), %g1
40007058: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 ! 4004741c <_Watchdog_Ticks_since_boot>
}
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) {
4000705c: 80 88 60 7f btst 0x7f, %g1
40007060: 22 80 00 b1 be,a 40007324 <jffs2_mark_node_obsolete+0x414> <== NEVER TAKEN
40007064: c2 06 20 7c ld [ %i0 + 0x7c ], %g1 <== NOT EXECUTED
struct list_head *prev = beforethisent->prev;
40007068: c4 06 20 9c ld [ %i0 + 0x9c ], %g2
newent->prev = prev;
4000706c: c4 27 60 04 st %g2, [ %i5 + 4 ]
/* 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);
40007070: 82 06 20 98 add %i0, 0x98, %g1
newent->next = beforethisent;
40007074: c2 26 80 1b st %g1, [ %i2 + %i3 ]
beforethisent->prev = newent;
40007078: fa 26 20 9c st %i5, [ %i0 + 0x9c ]
c->nr_erasing_blocks++;
4000707c: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
prev->next = newent;
40007080: fa 20 80 00 st %i5, [ %g2 ]
40007084: 82 00 60 01 inc %g1
rtems_jffs2_flash_control *fc = sb->s_flash_control;
40007088: d0 06 20 e4 ld [ %i0 + 0xe4 ], %o0
4000708c: c2 26 20 40 st %g1, [ %i0 + 0x40 ]
if (fc->trigger_garbage_collection != NULL) {
40007090: c2 02 20 20 ld [ %o0 + 0x20 ], %g1
40007094: 80 a0 60 00 cmp %g1, 0
40007098: 22 80 00 05 be,a 400070ac <jffs2_mark_node_obsolete+0x19c> <== ALWAYS TAKEN
4000709c: c2 0e 20 ec ldub [ %i0 + 0xec ], %g1
(*fc->trigger_garbage_collection)(fc);
400070a0: 9f c0 40 00 call %g1 <== NOT EXECUTED
400070a4: 01 00 00 00 nop <== NOT EXECUTED
jeb->used_size);
}
spin_unlock(&c->erase_completion_lock);
if (!jffs2_can_mark_obsolete(c) || jffs2_is_readonly(c) ||
400070a8: c2 0e 20 ec ldub [ %i0 + 0xec ], %g1
400070ac: 80 a0 60 00 cmp %g1, 0
400070b0: 12 80 00 c4 bne 400073c0 <jffs2_mark_node_obsolete+0x4b0> <== NEVER TAKEN
400070b4: 01 00 00 00 nop
(c->flags & JFFS2_SB_FLAG_BUILDING)) {
400070b8: c2 06 20 0c ld [ %i0 + 0xc ], %g1
if (!jffs2_can_mark_obsolete(c) || jffs2_is_readonly(c) ||
400070bc: 80 88 60 04 btst 4, %g1
400070c0: 22 80 00 3f be,a 400071bc <jffs2_mark_node_obsolete+0x2ac> <== ALWAYS TAKEN
400070c4: d2 06 60 04 ld [ %i1 + 4 ], %o1
spin_unlock(&c->erase_completion_lock);
}
out_erase_sem:
mutex_unlock(&c->erase_free_sem);
}
400070c8: 81 c7 e0 08 ret
400070cc: 81 e8 00 00 restore
jeb->unchecked_size -= freed_len;
400070d0: c6 07 60 10 ld [ %i5 + 0x10 ], %g3 <== NOT EXECUTED
c->unchecked_size -= freed_len;
400070d4: c2 06 20 38 ld [ %i0 + 0x38 ], %g1 <== NOT EXECUTED
jeb->unchecked_size -= freed_len;
400070d8: 86 20 c0 08 sub %g3, %o0, %g3 <== NOT EXECUTED
400070dc: c6 27 60 10 st %g3, [ %i5 + 0x10 ] <== NOT EXECUTED
c->unchecked_size -= freed_len;
400070e0: 82 20 40 08 sub %g1, %o0, %g1 <== NOT EXECUTED
400070e4: 10 bf ff ad b 40006f98 <jffs2_mark_node_obsolete+0x88> <== NOT EXECUTED
400070e8: c2 26 20 38 st %g1, [ %i0 + 0x38 ] <== NOT EXECUTED
if ((jeb->dirty_size || ISDIRTY(jeb->wasted_size + freed_len)) && jeb != c->nextblock) {
400070ec: 86 07 00 04 add %i4, %g4, %g3
c->wasted_size += freed_len;
400070f0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
jeb->wasted_size += freed_len;
400070f4: c6 27 60 1c st %g3, [ %i5 + 0x1c ]
c->wasted_size += freed_len;
400070f8: 82 00 40 1c add %g1, %i4, %g1
addedsize = 0;
400070fc: a0 10 20 00 clr %l0
c->wasted_size += freed_len;
40007100: 10 bf ff b9 b 40006fe4 <jffs2_mark_node_obsolete+0xd4>
40007104: c2 26 20 24 st %g1, [ %i0 + 0x24 ]
} else if (jeb == c->gcblock) {
40007108: 80 a7 40 01 cmp %i5, %g1
4000710c: 22 bf ff e8 be,a 400070ac <jffs2_mark_node_obsolete+0x19c>
40007110: c2 0e 20 ec ldub [ %i0 + 0xec ], %g1
} else if (ISDIRTY(jeb->dirty_size) && !ISDIRTY(jeb->dirty_size - addedsize)) {
40007114: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
40007118: 80 a0 60 c4 cmp %g1, 0xc4
4000711c: 28 80 00 07 bleu,a 40007138 <jffs2_mark_node_obsolete+0x228>
40007120: c4 06 20 34 ld [ %i0 + 0x34 ], %g2
40007124: 84 20 40 10 sub %g1, %l0, %g2
40007128: 80 a0 a0 c4 cmp %g2, 0xc4
4000712c: 28 80 00 74 bleu,a 400072fc <jffs2_mark_node_obsolete+0x3ec>
40007130: c4 06 80 1b ld [ %i2 + %i3 ], %g2
} else if (VERYDIRTY(c, jeb->dirty_size) &&
40007134: c4 06 20 34 ld [ %i0 + 0x34 ], %g2
40007138: 85 30 a0 01 srl %g2, 1, %g2
4000713c: 80 a0 40 02 cmp %g1, %g2
40007140: 2a bf ff db bcs,a 400070ac <jffs2_mark_node_obsolete+0x19c>
40007144: c2 0e 20 ec ldub [ %i0 + 0xec ], %g1
!VERYDIRTY(c, jeb->dirty_size - addedsize)) {
40007148: 88 20 40 10 sub %g1, %l0, %g4
} else if (VERYDIRTY(c, jeb->dirty_size) &&
4000714c: 80 a0 80 04 cmp %g2, %g4
40007150: 28 bf ff d7 bleu,a 400070ac <jffs2_mark_node_obsolete+0x19c>
40007154: c2 0e 20 ec ldub [ %i0 + 0xec ], %g1
ent->prev->next = ent->next;
40007158: c4 06 80 1b ld [ %i2 + %i3 ], %g2
4000715c: c6 07 60 04 ld [ %i5 + 4 ], %g3
40007160: c4 20 c0 00 st %g2, [ %g3 ]
list_add_tail(&jeb->list, &c->very_dirty_list);
40007164: 82 06 20 68 add %i0, 0x68, %g1
ent->next->prev = ent->prev;
40007168: c6 20 a0 04 st %g3, [ %g2 + 4 ]
struct list_head *prev = beforethisent->prev;
4000716c: c4 06 20 6c ld [ %i0 + 0x6c ], %g2
newent->prev = prev;
40007170: c4 27 60 04 st %g2, [ %i5 + 4 ]
newent->next = beforethisent;
40007174: c2 26 80 1b st %g1, [ %i2 + %i3 ]
beforethisent->prev = newent;
40007178: fa 26 20 6c st %i5, [ %i0 + 0x6c ]
} /* list_add_tail() */
4000717c: 10 bf ff cb b 400070a8 <jffs2_mark_node_obsolete+0x198>
40007180: fa 20 80 00 st %i5, [ %g2 ]
list_for_each(this, head) {
40007184: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
if (on_list(&jeb->list, &c->bad_used_list)) {
40007188: 9e 06 20 b8 add %i0, 0xb8, %o7
list_for_each(this, head) {
4000718c: 80 a3 c0 01 cmp %o7, %g1
40007190: 12 80 00 07 bne 400071ac <jffs2_mark_node_obsolete+0x29c> <== NEVER TAKEN
40007194: 80 a7 40 01 cmp %i5, %g1
c->wasted_size -= jeb->wasted_size;
40007198: 10 80 00 50 b 400072d8 <jffs2_mark_node_obsolete+0x3c8>
4000719c: de 06 20 24 ld [ %i0 + 0x24 ], %o7
list_for_each(this, head) {
400071a0: 80 a3 c0 01 cmp %o7, %g1 <== NOT EXECUTED
400071a4: 02 80 00 4c be 400072d4 <jffs2_mark_node_obsolete+0x3c4> <== NOT EXECUTED
400071a8: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
if (this == obj) {
400071ac: 32 bf ff fd bne,a 400071a0 <jffs2_mark_node_obsolete+0x290> <== NOT EXECUTED
400071b0: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
addedsize = 0; /* To fool the refiling code later */
400071b4: 10 bf ff 8c b 40006fe4 <jffs2_mark_node_obsolete+0xd4> <== NOT EXECUTED
400071b8: a0 10 20 00 clr %l0 <== NOT EXECUTED
ret = jffs2_flash_read(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
400071bc: 98 07 bf f4 add %fp, -12, %o4
400071c0: 96 07 bf f0 add %fp, -16, %o3
400071c4: 94 10 20 0c mov 0xc, %o2
400071c8: 92 0a 7f fc and %o1, -4, %o1
400071cc: 40 00 17 1d call 4000ce40 <jffs2_flash_read>
400071d0: 90 10 00 18 mov %i0, %o0
if (ret) {
400071d4: 80 a2 20 00 cmp %o0, 0
400071d8: 12 80 00 60 bne 40007358 <jffs2_mark_node_obsolete+0x448> <== NEVER TAKEN
400071dc: d4 07 bf f0 ld [ %fp + -16 ], %o2
if (retlen != sizeof(n)) {
400071e0: 80 a2 a0 0c cmp %o2, 0xc
400071e4: 12 80 00 56 bne 4000733c <jffs2_mark_node_obsolete+0x42c> <== NEVER TAKEN
400071e8: d2 07 bf f8 ld [ %fp + -8 ], %o1
if (PAD(je32_to_cpu(n.totlen)) != PAD(freed_len)) {
400071ec: 82 02 60 03 add %o1, 3, %g1
400071f0: 84 07 20 03 add %i4, 3, %g2
400071f4: 82 18 40 02 xor %g1, %g2, %g1
400071f8: 80 88 7f fc btst -4, %g1
400071fc: 12 80 00 5f bne 40007378 <jffs2_mark_node_obsolete+0x468> <== NEVER TAKEN
40007200: c2 17 bf f6 lduh [ %fp + -10 ], %g1
if (!(je16_to_cpu(n.nodetype) & JFFS2_NODE_ACCURATE)) {
40007204: 05 00 00 08 sethi %hi(0x2000), %g2
40007208: 80 88 80 01 btst %g2, %g1
4000720c: 02 bf ff af be 400070c8 <jffs2_mark_node_obsolete+0x1b8> <== NEVER TAKEN
40007210: 82 28 40 02 andn %g1, %g2, %g1
ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
40007214: d2 06 60 04 ld [ %i1 + 4 ], %o1
40007218: 98 07 bf f4 add %fp, -12, %o4
n.nodetype = cpu_to_je16(je16_to_cpu(n.nodetype) & ~JFFS2_NODE_ACCURATE);
4000721c: c2 37 bf f6 sth %g1, [ %fp + -10 ]
ret = jffs2_flash_write(c, ref_offset(ref), sizeof(n), &retlen, (char *)&n);
40007220: 96 07 bf f0 add %fp, -16, %o3
40007224: 94 10 20 0c mov 0xc, %o2
40007228: 92 0a 7f fc and %o1, -4, %o1
4000722c: 40 00 17 0f call 4000ce68 <jffs2_flash_write>
40007230: 90 10 00 18 mov %i0, %o0
if (ret) {
40007234: 80 a2 20 00 cmp %o0, 0
40007238: 12 80 00 5c bne 400073a8 <jffs2_mark_node_obsolete+0x498> <== NEVER TAKEN
4000723c: d4 07 bf f0 ld [ %fp + -16 ], %o2
if (retlen != sizeof(n)) {
40007240: 80 a2 a0 0c cmp %o2, 0xc
40007244: 32 80 00 53 bne,a 40007390 <jffs2_mark_node_obsolete+0x480> <== NEVER TAKEN
40007248: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
if (ref->next_in_ino) {
4000724c: c6 06 40 00 ld [ %i1 ], %g3
40007250: 80 a0 e0 00 cmp %g3, 0
40007254: 02 bf ff 9d be 400070c8 <jffs2_mark_node_obsolete+0x1b8>
40007258: 82 10 00 03 mov %g3, %g1
4000725c: 92 10 00 01 mov %g1, %o1
while(raw->next_in_ino)
40007260: c2 00 40 00 ld [ %g1 ], %g1
40007264: 80 a0 60 00 cmp %g1, 0
40007268: 32 bf ff fe bne,a 40007260 <jffs2_mark_node_obsolete+0x350>
4000726c: 92 10 00 01 mov %g1, %o1
for (p = &ic->nodes; (*p) != ref; p = &((*p)->next_in_ino))
40007270: c2 02 60 04 ld [ %o1 + 4 ], %g1
40007274: 80 a0 40 19 cmp %g1, %i1
40007278: 02 80 00 07 be 40007294 <jffs2_mark_node_obsolete+0x384>
4000727c: 84 02 60 04 add %o1, 4, %g2
40007280: 84 10 00 01 mov %g1, %g2
40007284: c2 00 40 00 ld [ %g1 ], %g1
40007288: 80 a6 40 01 cmp %i1, %g1
4000728c: 32 bf ff fe bne,a 40007284 <jffs2_mark_node_obsolete+0x374>
40007290: 84 10 00 01 mov %g1, %g2
*p = ref->next_in_ino;
40007294: c6 20 80 00 st %g3, [ %g2 ]
ref->next_in_ino = NULL;
40007298: c0 26 40 00 clr [ %i1 ]
if (ic->nodes == (void *)ic && ic->pino_nlink == 0)
4000729c: c2 02 60 04 ld [ %o1 + 4 ], %g1
400072a0: 80 a2 40 01 cmp %o1, %g1
400072a4: 12 80 00 47 bne 400073c0 <jffs2_mark_node_obsolete+0x4b0>
400072a8: 01 00 00 00 nop
400072ac: c2 02 60 14 ld [ %o1 + 0x14 ], %g1
400072b0: 80 a0 60 00 cmp %g1, 0
400072b4: 12 80 00 43 bne 400073c0 <jffs2_mark_node_obsolete+0x4b0>
400072b8: 01 00 00 00 nop
jffs2_del_ino_cache(c, ic);
400072bc: 7f ff fc f8 call 4000669c <jffs2_del_ino_cache>
400072c0: 90 10 00 18 mov %i0, %o0
return 0;
}
static inline void mutex_unlock(struct mutex *m)
{
(void) m;
400072c4: 81 c7 e0 08 ret
400072c8: 81 e8 00 00 restore
pr_notice("EEEEEK. jffs2_mark_node_obsolete called with NULL node\n");
400072cc: 7f ff fe 9e call 40006d44 <jffs2_printk> <== NOT EXECUTED
400072d0: 91 ee 20 68 restore %i0, 0x68, %o0 <== NOT EXECUTED
c->wasted_size -= jeb->wasted_size;
400072d4: de 06 20 24 ld [ %i0 + 0x24 ], %o7 <== NOT EXECUTED
jeb->dirty_size += jeb->wasted_size;
400072d8: 82 00 c0 04 add %g3, %g4, %g1
400072dc: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
c->dirty_size += jeb->wasted_size;
400072e0: 9a 03 40 04 add %o5, %g4, %o5
c->wasted_size -= jeb->wasted_size;
400072e4: 82 23 c0 04 sub %o7, %g4, %g1
c->dirty_size += jeb->wasted_size;
400072e8: da 26 20 20 st %o5, [ %i0 + 0x20 ]
addedsize += jeb->wasted_size;
400072ec: a0 07 00 04 add %i4, %g4, %l0
c->wasted_size -= jeb->wasted_size;
400072f0: c2 26 20 24 st %g1, [ %i0 + 0x24 ]
jeb->wasted_size = 0;
400072f4: 10 bf ff 3c b 40006fe4 <jffs2_mark_node_obsolete+0xd4>
400072f8: c0 27 60 1c clr [ %i5 + 0x1c ]
ent->prev->next = ent->next;
400072fc: c6 07 60 04 ld [ %i5 + 4 ], %g3
40007300: c4 20 c0 00 st %g2, [ %g3 ]
list_add_tail(&jeb->list, &c->dirty_list);
40007304: 82 06 20 70 add %i0, 0x70, %g1
ent->next->prev = ent->prev;
40007308: c6 20 a0 04 st %g3, [ %g2 + 4 ]
struct list_head *prev = beforethisent->prev;
4000730c: c4 06 20 74 ld [ %i0 + 0x74 ], %g2
newent->prev = prev;
40007310: c4 27 60 04 st %g2, [ %i5 + 4 ]
newent->next = beforethisent;
40007314: c2 26 80 1b st %g1, [ %i2 + %i3 ]
beforethisent->prev = newent;
40007318: fa 26 20 74 st %i5, [ %i0 + 0x74 ]
} /* list_add_tail() */
4000731c: 10 bf ff 63 b 400070a8 <jffs2_mark_node_obsolete+0x198>
40007320: fa 20 80 00 st %i5, [ %g2 ]
newent->prev = prev;
40007324: c2 27 60 04 st %g1, [ %i5 + 4 ] <== NOT EXECUTED
list_add_tail(&jeb->list, &c->erasable_list);
40007328: 84 06 20 78 add %i0, 0x78, %g2 <== NOT EXECUTED
newent->next = beforethisent;
4000732c: c4 26 80 1b st %g2, [ %i2 + %i3 ] <== NOT EXECUTED
beforethisent->prev = newent;
40007330: fa 26 20 7c st %i5, [ %i0 + 0x7c ] <== NOT EXECUTED
} /* list_add_tail() */
40007334: 10 bf ff 5d b 400070a8 <jffs2_mark_node_obsolete+0x198> <== NOT EXECUTED
40007338: fa 20 40 00 st %i5, [ %g1 ] <== NOT EXECUTED
pr_warn("Short read from obsoleted node at 0x%08x: %zd\n",
4000733c: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
40007340: 92 0a 7f fc and %o1, -4, %o1 <== NOT EXECUTED
40007344: 11 10 00 7c sethi %hi(0x4001f000), %o0 <== NOT EXECUTED
40007348: 7f ff fe 7f call 40006d44 <jffs2_printk> <== NOT EXECUTED
4000734c: 90 12 21 58 or %o0, 0x158, %o0 ! 4001f158 <__func__.4+0x190> <== NOT EXECUTED
goto out_erase_sem;
40007350: 81 c7 e0 08 ret <== NOT EXECUTED
40007354: 81 e8 00 00 restore <== NOT EXECUTED
pr_warn("Read error reading from obsoleted node at 0x%08x: %d\n",
40007358: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
4000735c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40007360: 92 0a 7f fc and %o1, -4, %o1 <== NOT EXECUTED
40007364: 11 10 00 7c sethi %hi(0x4001f000), %o0 <== NOT EXECUTED
40007368: 7f ff fe 77 call 40006d44 <jffs2_printk> <== NOT EXECUTED
4000736c: 90 12 21 18 or %o0, 0x118, %o0 ! 4001f118 <__func__.4+0x150> <== NOT EXECUTED
goto out_erase_sem;
40007370: 81 c7 e0 08 ret <== NOT EXECUTED
40007374: 81 e8 00 00 restore <== NOT EXECUTED
pr_warn("Node totlen on flash (0x%08x) != totlen from node ref (0x%08x)\n",
40007378: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
4000737c: 11 10 00 7c sethi %hi(0x4001f000), %o0 <== NOT EXECUTED
40007380: 7f ff fe 71 call 40006d44 <jffs2_printk> <== NOT EXECUTED
40007384: 90 12 21 98 or %o0, 0x198, %o0 ! 4001f198 <__func__.4+0x1d0> <== NOT EXECUTED
goto out_erase_sem;
40007388: 81 c7 e0 08 ret <== NOT EXECUTED
4000738c: 81 e8 00 00 restore <== NOT EXECUTED
pr_warn("Short write in obliterating obsoleted node at 0x%08x: %zd\n",
40007390: 92 0a 7f fc and %o1, -4, %o1 <== NOT EXECUTED
40007394: 11 10 00 7c sethi %hi(0x4001f000), %o0 <== NOT EXECUTED
40007398: 7f ff fe 6b call 40006d44 <jffs2_printk> <== NOT EXECUTED
4000739c: 90 12 22 30 or %o0, 0x230, %o0 ! 4001f230 <__func__.4+0x268> <== NOT EXECUTED
goto out_erase_sem;
400073a0: 81 c7 e0 08 ret <== NOT EXECUTED
400073a4: 81 e8 00 00 restore <== NOT EXECUTED
pr_warn("Write error in obliterating obsoleted node at 0x%08x: %d\n",
400073a8: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
400073ac: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
400073b0: 92 0a 7f fc and %o1, -4, %o1 <== NOT EXECUTED
400073b4: 11 10 00 7c sethi %hi(0x4001f000), %o0 <== NOT EXECUTED
400073b8: 7f ff fe 63 call 40006d44 <jffs2_printk> <== NOT EXECUTED
400073bc: 90 12 21 e8 or %o0, 0x1e8, %o0 ! 4001f1e8 <__func__.4+0x220> <== NOT EXECUTED
goto out_erase_sem;
400073c0: 81 c7 e0 08 ret
400073c4: 81 e8 00 00 restore
pr_notice("raw node at 0x%08x is off the end of device!\n",
400073c8: 11 10 00 7c sethi %hi(0x4001f000), %o0 <== NOT EXECUTED
400073cc: 7f ff fe 5e call 40006d44 <jffs2_printk> <== NOT EXECUTED
400073d0: 90 12 20 b0 or %o0, 0xb0, %o0 ! 4001f0b0 <__func__.4+0xe8> <== NOT EXECUTED
BUG();
400073d4: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
400073d8: 15 10 00 7c sethi %hi(0x4001f000), %o2 <== NOT EXECUTED
400073dc: 11 10 00 7c sethi %hi(0x4001f000), %o0 <== NOT EXECUTED
400073e0: 92 10 22 5b mov 0x25b, %o1 <== NOT EXECUTED
400073e4: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
400073e8: 94 12 a3 70 or %o2, 0x370, %o2 <== NOT EXECUTED
400073ec: 40 00 1d 63 call 4000e978 <__assert_func> <== NOT EXECUTED
400073f0: 90 12 20 e8 or %o0, 0xe8, %o0 <== NOT EXECUTED
400073f4: 01 00 00 00 nop <== NOT EXECUTED
4000c160 <jffs2_mknod>:
size_t d_namelen,
int mode,
const unsigned char *data,
size_t datalen
)
{
4000c160: 9d e3 bf 98 save %sp, -104, %sp
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)
4000c164: 80 a7 60 fe cmp %i5, 0xfe
4000c168: 18 80 01 19 bgu 4000c5cc <jffs2_mknod+0x46c> <== NEVER TAKEN
4000c16c: a4 10 00 18 mov %i0, %l2
return -ENAMETOOLONG;
ri = jffs2_alloc_raw_inode();
4000c170: 7f ff e6 98 call 40005bd0 <jffs2_alloc_raw_inode>
4000c174: 01 00 00 00 nop
if (!ri)
4000c178: a0 92 20 00 orcc %o0, 0, %l0
4000c17c: 02 80 01 1f be 4000c5f8 <jffs2_mknod+0x498> <== NEVER TAKEN
4000c180: a8 07 60 44 add %i5, 0x44, %l4
return -ENOMEM;
c = JFFS2_SB_INFO(dir_i->i_sb);
4000c184: e6 06 20 40 ld [ %i0 + 0x40 ], %l3
/* 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,
4000c188: 98 10 20 12 mov 0x12, %o4
4000c18c: 96 10 20 00 clr %o3
4000c190: 94 07 bf fc add %fp, -4, %o2
4000c194: 92 10 00 14 mov %l4, %o1
4000c198: 7f ff ed 7d call 4000778c <jffs2_reserve_space>
4000c19c: 90 10 00 13 mov %l3, %o0
ALLOC_NORMAL, JFFS2_SUMMARY_INODE_SIZE);
if (ret) {
4000c1a0: b0 92 20 00 orcc %o0, 0, %i0
4000c1a4: 12 80 00 71 bne 4000c368 <jffs2_mknod+0x208> <== NEVER TAKEN
4000c1a8: 94 10 00 10 mov %l0, %o2
jffs2_free_raw_inode(ri);
return ret;
}
inode = jffs2_new_inode(dir_i, mode, ri);
4000c1ac: 92 10 00 1b mov %i3, %o1
4000c1b0: 7f ff df 70 call 40003f70 <jffs2_new_inode>
4000c1b4: 90 10 00 12 mov %l2, %o0
if (IS_ERR(inode)) {
4000c1b8: 80 a2 3c 18 cmp %o0, -1000
4000c1bc: 18 80 00 64 bgu 4000c34c <jffs2_mknod+0x1ec> <== NEVER TAKEN
4000c1c0: a2 10 00 08 mov %o0, %l1
return PTR_ERR(inode);
}
f = JFFS2_INODE_INFO(inode);
inode->i_size = datalen;
4000c1c4: c0 22 20 38 clr [ %o0 + 0x38 ]
ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size);
4000c1c8: 9f 35 20 10 srl %l4, 0x10, %o7
inode->i_size = datalen;
4000c1cc: fa 22 20 3c st %i5, [ %o0 + 0x3c ]
ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
4000c1d0: 89 37 60 18 srl %i5, 0x18, %g4
ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size);
4000c1d4: de 2c 20 05 stb %o7, [ %l0 + 5 ]
ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
4000c1d8: 86 0f 60 ff and %i5, 0xff, %g3
ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size);
4000c1dc: 9b 35 20 18 srl %l4, 0x18, %o5
ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
4000c1e0: c8 2c 20 30 stb %g4, [ %l0 + 0x30 ]
ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size);
4000c1e4: b1 35 20 08 srl %l4, 8, %i0
4000c1e8: da 2c 20 04 stb %o5, [ %l0 + 4 ]
ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
4000c1ec: 85 37 60 10 srl %i5, 0x10, %g2
4000c1f0: c6 2c 20 33 stb %g3, [ %l0 + 0x33 ]
4000c1f4: 84 08 a0 ff and %g2, 0xff, %g2
4000c1f8: c8 2c 20 34 stb %g4, [ %l0 + 0x34 ]
4000c1fc: 83 37 60 08 srl %i5, 8, %g1
4000c200: c4 2c 20 31 stb %g2, [ %l0 + 0x31 ]
4000c204: 82 08 60 ff and %g1, 0xff, %g1
4000c208: c4 2c 20 35 stb %g2, [ %l0 + 0x35 ]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000c20c: 94 10 20 08 mov 8, %o2
ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
4000c210: c2 2c 20 32 stb %g1, [ %l0 + 0x32 ]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000c214: 92 10 00 10 mov %l0, %o1
ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
4000c218: c2 2c 20 36 stb %g1, [ %l0 + 0x36 ]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000c21c: 90 10 20 00 clr %o0
ri->isize = ri->dsize = ri->csize = cpu_to_je32(inode->i_size);
4000c220: c6 2c 20 37 stb %g3, [ %l0 + 0x37 ]
4000c224: c8 2c 20 1c stb %g4, [ %l0 + 0x1c ]
4000c228: c4 2c 20 1d stb %g2, [ %l0 + 0x1d ]
4000c22c: c2 2c 20 1e stb %g1, [ %l0 + 0x1e ]
4000c230: c6 2c 20 1f stb %g3, [ %l0 + 0x1f ]
ri->totlen = cpu_to_je32(sizeof(*ri) + inode->i_size);
4000c234: f0 2c 20 06 stb %i0, [ %l0 + 6 ]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000c238: 7f ff fe 50 call 4000bb78 <cyg_crc32_accumulate>
4000c23c: e8 2c 20 07 stb %l4, [ %l0 + 7 ]
ri->compr = JFFS2_COMPR_NONE;
4000c240: c0 2c 20 38 clrb [ %l0 + 0x38 ]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000c244: 82 10 00 08 mov %o0, %g1
4000c248: 89 32 20 18 srl %o0, 0x18, %g4
4000c24c: 87 32 20 10 srl %o0, 0x10, %g3
4000c250: 85 32 20 08 srl %o0, 8, %g2
4000c254: c8 2c 20 08 stb %g4, [ %l0 + 8 ]
ri->data_crc = cpu_to_je32(crc32(0, data, datalen));
4000c258: 94 10 00 1d mov %i5, %o2
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000c25c: c6 2c 20 09 stb %g3, [ %l0 + 9 ]
ri->data_crc = cpu_to_je32(crc32(0, data, datalen));
4000c260: 92 10 00 1c mov %i4, %o1
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000c264: c4 2c 20 0a stb %g2, [ %l0 + 0xa ]
ri->data_crc = cpu_to_je32(crc32(0, data, datalen));
4000c268: 90 10 20 00 clr %o0
4000c26c: 7f ff fe 43 call 4000bb78 <cyg_crc32_accumulate>
4000c270: c2 2c 20 0b stb %g1, [ %l0 + 0xb ]
4000c274: 89 32 20 18 srl %o0, 0x18, %g4
4000c278: 82 10 00 08 mov %o0, %g1
4000c27c: 87 32 20 10 srl %o0, 0x10, %g3
4000c280: 85 32 20 08 srl %o0, 8, %g2
4000c284: c8 2c 20 3c stb %g4, [ %l0 + 0x3c ]
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000c288: 94 10 20 3c mov 0x3c, %o2
ri->data_crc = cpu_to_je32(crc32(0, data, datalen));
4000c28c: c6 2c 20 3d stb %g3, [ %l0 + 0x3d ]
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000c290: 92 10 00 10 mov %l0, %o1
ri->data_crc = cpu_to_je32(crc32(0, data, datalen));
4000c294: c4 2c 20 3e stb %g2, [ %l0 + 0x3e ]
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000c298: 90 10 20 00 clr %o0
4000c29c: 7f ff fe 37 call 4000bb78 <cyg_crc32_accumulate>
4000c2a0: c2 2c 20 3f stb %g1, [ %l0 + 0x3f ]
4000c2a4: 87 32 20 18 srl %o0, 0x18, %g3
4000c2a8: 85 32 20 10 srl %o0, 0x10, %g2
4000c2ac: 83 32 20 08 srl %o0, 8, %g1
4000c2b0: c6 2c 20 40 stb %g3, [ %l0 + 0x40 ]
fn = jffs2_write_dnode(c, f, ri, data, datalen, ALLOC_NORMAL);
4000c2b4: 9a 10 20 00 clr %o5
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000c2b8: c4 2c 20 41 stb %g2, [ %l0 + 0x41 ]
fn = jffs2_write_dnode(c, f, ri, data, datalen, ALLOC_NORMAL);
4000c2bc: 98 10 00 1d mov %i5, %o4
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000c2c0: c2 2c 20 42 stb %g1, [ %l0 + 0x42 ]
fn = jffs2_write_dnode(c, f, ri, data, datalen, ALLOC_NORMAL);
4000c2c4: 96 10 00 1c mov %i4, %o3
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000c2c8: d0 2c 20 43 stb %o0, [ %l0 + 0x43 ]
fn = jffs2_write_dnode(c, f, ri, data, datalen, ALLOC_NORMAL);
4000c2cc: 94 10 00 10 mov %l0, %o2
4000c2d0: 92 04 60 48 add %l1, 0x48, %o1
4000c2d4: 7f ff f7 8b call 4000a100 <jffs2_write_dnode>
4000c2d8: 90 10 00 13 mov %l3, %o0
4000c2dc: b0 10 00 08 mov %o0, %i0
jffs2_free_raw_inode(ri);
4000c2e0: 7f ff e6 40 call 40005be0 <jffs2_free_raw_inode>
4000c2e4: 90 10 00 10 mov %l0, %o0
if (IS_ERR(fn)) {
4000c2e8: 80 a6 3c 18 cmp %i0, -1000
4000c2ec: 18 80 00 9e bgu 4000c564 <jffs2_mknod+0x404> <== NEVER TAKEN
4000c2f0: 03 00 00 3c sethi %hi(0xf000), %g1
jffs2_complete_reservation(c);
ret = PTR_ERR(fn);
goto fail;
}
if (S_ISLNK(mode)) {
4000c2f4: 05 00 00 28 sethi %hi(0xa000), %g2
4000c2f8: 82 0e c0 01 and %i3, %g1, %g1
4000c2fc: 80 a0 40 02 cmp %g1, %g2
4000c300: 02 80 00 9f be 4000c57c <jffs2_mknod+0x41c>
4000c304: 01 00 00 00 nop
}
/* No data here. Only a metadata node, which will be
obsoleted by the first data write
*/
f->metadata = fn;
4000c308: f0 24 60 50 st %i0, [ %l1 + 0x50 ]
mutex_unlock(&f->sem);
jffs2_complete_reservation(c);
4000c30c: 7f ff ea f7 call 40006ee8 <jffs2_complete_reservation>
4000c310: 90 10 00 13 mov %l3, %o0
ret = jffs2_reserve_space(c, sizeof(*rd)+d_namelen, &alloclen,
4000c314: b8 06 a0 28 add %i2, 0x28, %i4
4000c318: 98 06 a0 18 add %i2, 0x18, %o4
4000c31c: 96 10 20 00 clr %o3
4000c320: 94 07 bf fc add %fp, -4, %o2
4000c324: 92 10 00 1c mov %i4, %o1
4000c328: 7f ff ed 19 call 4000778c <jffs2_reserve_space>
4000c32c: 90 10 00 13 mov %l3, %o0
ALLOC_NORMAL, JFFS2_SUMMARY_DIRENT_SIZE(d_namelen));
if (ret)
4000c330: b0 92 20 00 orcc %o0, 0, %i0
4000c334: 02 80 00 11 be 4000c378 <jffs2_mknod+0x218> <== ALWAYS TAKEN
4000c338: 01 00 00 00 nop
mutex_unlock(&dir_f->sem);
jffs2_complete_reservation(c);
fail:
jffs2_iput(inode);
4000c33c: 7f ff dd 21 call 400037c0 <jffs2_iput> <== NOT EXECUTED
4000c340: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
return ret;
4000c344: 81 c7 e0 08 ret <== NOT EXECUTED
4000c348: 81 e8 00 00 restore <== NOT EXECUTED
jffs2_free_raw_inode(ri);
4000c34c: 7f ff e6 25 call 40005be0 <jffs2_free_raw_inode> <== NOT EXECUTED
4000c350: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
return PTR_ERR(inode);
4000c354: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
jffs2_complete_reservation(c);
4000c358: 7f ff ea e4 call 40006ee8 <jffs2_complete_reservation> <== NOT EXECUTED
4000c35c: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
return PTR_ERR(inode);
4000c360: 81 c7 e0 08 ret <== NOT EXECUTED
4000c364: 81 e8 00 00 restore <== NOT EXECUTED
jffs2_free_raw_inode(ri);
4000c368: 7f ff e6 1e call 40005be0 <jffs2_free_raw_inode> <== NOT EXECUTED
4000c36c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
return ret;
4000c370: 81 c7 e0 08 ret <== NOT EXECUTED
4000c374: 81 e8 00 00 restore <== NOT EXECUTED
rd = jffs2_alloc_raw_dirent();
4000c378: 7f ff e6 0f call 40005bb4 <jffs2_alloc_raw_dirent>
4000c37c: 01 00 00 00 nop
if (!rd) {
4000c380: ba 92 20 00 orcc %o0, 0, %i5
4000c384: 02 80 00 8e be 4000c5bc <jffs2_mknod+0x45c> <== NEVER TAKEN
4000c388: 82 10 20 19 mov 0x19, %g1
rd->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
4000c38c: c2 2f 40 00 stb %g1, [ %i5 ]
4000c390: 82 10 3f 85 mov -123, %g1
4000c394: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
4000c398: 82 10 3f e0 mov -32, %g1
4000c39c: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
4000c3a0: 82 10 20 01 mov 1, %g1
rd->totlen = cpu_to_je32(sizeof(*rd) + d_namelen);
4000c3a4: 85 37 20 18 srl %i4, 0x18, %g2
4000c3a8: f8 2f 60 07 stb %i4, [ %i5 + 7 ]
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000c3ac: 94 10 20 08 mov 8, %o2
rd->nodetype = cpu_to_je16(JFFS2_NODETYPE_DIRENT);
4000c3b0: c2 2f 60 03 stb %g1, [ %i5 + 3 ]
rd->totlen = cpu_to_je32(sizeof(*rd) + d_namelen);
4000c3b4: 83 37 20 10 srl %i4, 0x10, %g1
4000c3b8: c4 2f 60 04 stb %g2, [ %i5 + 4 ]
4000c3bc: b9 37 20 08 srl %i4, 8, %i4
4000c3c0: c2 2f 60 05 stb %g1, [ %i5 + 5 ]
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000c3c4: 92 10 00 1d mov %i5, %o1
rd->totlen = cpu_to_je32(sizeof(*rd) + d_namelen);
4000c3c8: f8 2f 60 06 stb %i4, [ %i5 + 6 ]
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000c3cc: 7f ff fd eb call 4000bb78 <cyg_crc32_accumulate>
4000c3d0: 90 10 20 00 clr %o0
rd->pino = cpu_to_je32(dir_i->i_ino);
4000c3d4: c8 0c a0 01 ldub [ %l2 + 1 ], %g4
4000c3d8: f8 0c 80 00 ldub [ %l2 ], %i4
4000c3dc: c6 0c a0 02 ldub [ %l2 + 2 ], %g3
4000c3e0: c4 0c a0 03 ldub [ %l2 + 3 ], %g2
rd->version = cpu_to_je32(++dir_f->highest_version);
4000c3e4: c2 04 a0 48 ld [ %l2 + 0x48 ], %g1
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000c3e8: 9f 32 20 18 srl %o0, 0x18, %o7
rd->pino = cpu_to_je32(dir_i->i_ino);
4000c3ec: f8 2f 60 0c stb %i4, [ %i5 + 0xc ]
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000c3f0: b9 32 20 10 srl %o0, 0x10, %i4
4000c3f4: d0 2f 60 0b stb %o0, [ %i5 + 0xb ]
4000c3f8: 91 32 20 08 srl %o0, 8, %o0
4000c3fc: de 2f 60 08 stb %o7, [ %i5 + 8 ]
rd->version = cpu_to_je32(++dir_f->highest_version);
4000c400: 82 00 60 01 inc %g1
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000c404: f8 2f 60 09 stb %i4, [ %i5 + 9 ]
rd->version = cpu_to_je32(++dir_f->highest_version);
4000c408: 99 30 60 18 srl %g1, 0x18, %o4
rd->hdr_crc = cpu_to_je32(crc32(0, rd, sizeof(struct jffs2_unknown_node)-4));
4000c40c: d0 2f 60 0a stb %o0, [ %i5 + 0xa ]
rd->version = cpu_to_je32(++dir_f->highest_version);
4000c410: 9b 30 60 10 srl %g1, 0x10, %o5
rd->pino = cpu_to_je32(dir_i->i_ino);
4000c414: c8 2f 60 0d stb %g4, [ %i5 + 0xd ]
rd->version = cpu_to_je32(++dir_f->highest_version);
4000c418: 9f 30 60 08 srl %g1, 8, %o7
rd->pino = cpu_to_je32(dir_i->i_ino);
4000c41c: c6 2f 60 0e stb %g3, [ %i5 + 0xe ]
rd->mctime = cpu_to_je32(get_seconds());
4000c420: 90 10 20 00 clr %o0
rd->pino = cpu_to_je32(dir_i->i_ino);
4000c424: c4 2f 60 0f stb %g2, [ %i5 + 0xf ]
rd->type = (mode & S_IFMT) >> 12;
4000c428: b7 3e e0 0c sra %i3, 0xc, %i3
rd->version = cpu_to_je32(++dir_f->highest_version);
4000c42c: c2 24 a0 48 st %g1, [ %l2 + 0x48 ]
rd->type = (mode & S_IFMT) >> 12;
4000c430: b6 0e e0 0f and %i3, 0xf, %i3
rd->ino = cpu_to_je32(inode->i_ino);
4000c434: f8 0c 40 00 ldub [ %l1 ], %i4
4000c438: c8 0c 60 01 ldub [ %l1 + 1 ], %g4
4000c43c: c6 0c 60 02 ldub [ %l1 + 2 ], %g3
4000c440: c4 0c 60 03 ldub [ %l1 + 3 ], %g2
4000c444: c4 2f 60 17 stb %g2, [ %i5 + 0x17 ]
rd->version = cpu_to_je32(++dir_f->highest_version);
4000c448: d8 2f 60 10 stb %o4, [ %i5 + 0x10 ]
4000c44c: da 2f 60 11 stb %o5, [ %i5 + 0x11 ]
4000c450: de 2f 60 12 stb %o7, [ %i5 + 0x12 ]
4000c454: c2 2f 60 13 stb %g1, [ %i5 + 0x13 ]
rd->ino = cpu_to_je32(inode->i_ino);
4000c458: f8 2f 60 14 stb %i4, [ %i5 + 0x14 ]
4000c45c: c8 2f 60 15 stb %g4, [ %i5 + 0x15 ]
rd->mctime = cpu_to_je32(get_seconds());
4000c460: 40 00 44 61 call 4001d5e4 <time>
4000c464: c6 2f 60 16 stb %g3, [ %i5 + 0x16 ]
rd->nsize = d_namelen;
4000c468: f4 2f 60 1c stb %i2, [ %i5 + 0x1c ]
rd->mctime = cpu_to_je32(get_seconds());
4000c46c: 82 10 00 09 mov %o1, %g1
4000c470: 89 32 60 18 srl %o1, 0x18, %g4
4000c474: 87 32 60 10 srl %o1, 0x10, %g3
4000c478: 85 32 60 08 srl %o1, 8, %g2
4000c47c: c8 2f 60 18 stb %g4, [ %i5 + 0x18 ]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000c480: 94 10 20 20 mov 0x20, %o2
rd->mctime = cpu_to_je32(get_seconds());
4000c484: c6 2f 60 19 stb %g3, [ %i5 + 0x19 ]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000c488: 92 10 00 1d mov %i5, %o1
rd->mctime = cpu_to_je32(get_seconds());
4000c48c: c4 2f 60 1a stb %g2, [ %i5 + 0x1a ]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000c490: 90 10 20 00 clr %o0
rd->mctime = cpu_to_je32(get_seconds());
4000c494: c2 2f 60 1b stb %g1, [ %i5 + 0x1b ]
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000c498: 7f ff fd b8 call 4000bb78 <cyg_crc32_accumulate>
4000c49c: f6 2f 60 1d stb %i3, [ %i5 + 0x1d ]
4000c4a0: 82 10 00 08 mov %o0, %g1
4000c4a4: 89 32 20 18 srl %o0, 0x18, %g4
4000c4a8: 87 32 20 10 srl %o0, 0x10, %g3
4000c4ac: 85 32 20 08 srl %o0, 8, %g2
4000c4b0: c8 2f 60 20 stb %g4, [ %i5 + 0x20 ]
rd->name_crc = cpu_to_je32(crc32(0, d_name, d_namelen));
4000c4b4: 94 10 00 1a mov %i2, %o2
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000c4b8: c6 2f 60 21 stb %g3, [ %i5 + 0x21 ]
rd->name_crc = cpu_to_je32(crc32(0, d_name, d_namelen));
4000c4bc: 92 10 00 19 mov %i1, %o1
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000c4c0: c4 2f 60 22 stb %g2, [ %i5 + 0x22 ]
rd->name_crc = cpu_to_je32(crc32(0, d_name, d_namelen));
4000c4c4: 90 10 20 00 clr %o0
4000c4c8: 7f ff fd ac call 4000bb78 <cyg_crc32_accumulate>
4000c4cc: c2 2f 60 23 stb %g1, [ %i5 + 0x23 ]
4000c4d0: 87 32 20 18 srl %o0, 0x18, %g3
4000c4d4: 85 32 20 10 srl %o0, 0x10, %g2
4000c4d8: 83 32 20 08 srl %o0, 8, %g1
4000c4dc: d0 2f 60 27 stb %o0, [ %i5 + 0x27 ]
fd = jffs2_write_dirent(c, dir_f, rd, d_name, d_namelen, ALLOC_NORMAL);
4000c4e0: 9a 10 20 00 clr %o5
rd->name_crc = cpu_to_je32(crc32(0, d_name, d_namelen));
4000c4e4: c6 2f 60 24 stb %g3, [ %i5 + 0x24 ]
fd = jffs2_write_dirent(c, dir_f, rd, d_name, d_namelen, ALLOC_NORMAL);
4000c4e8: 98 10 00 1a mov %i2, %o4
rd->name_crc = cpu_to_je32(crc32(0, d_name, d_namelen));
4000c4ec: c4 2f 60 25 stb %g2, [ %i5 + 0x25 ]
fd = jffs2_write_dirent(c, dir_f, rd, d_name, d_namelen, ALLOC_NORMAL);
4000c4f0: 96 10 00 19 mov %i1, %o3
rd->name_crc = cpu_to_je32(crc32(0, d_name, d_namelen));
4000c4f4: c2 2f 60 26 stb %g1, [ %i5 + 0x26 ]
fd = jffs2_write_dirent(c, dir_f, rd, d_name, d_namelen, ALLOC_NORMAL);
4000c4f8: 94 10 00 1d mov %i5, %o2
4000c4fc: 92 04 a0 48 add %l2, 0x48, %o1
4000c500: 7f ff f8 0e call 4000a538 <jffs2_write_dirent>
4000c504: 90 10 00 13 mov %l3, %o0
if (IS_ERR(fd)) {
4000c508: 80 a2 3c 18 cmp %o0, -1000
4000c50c: 18 80 00 26 bgu 4000c5a4 <jffs2_mknod+0x444> <== NEVER TAKEN
4000c510: b8 10 00 08 mov %o0, %i4
dir_i->i_mtime = dir_i->i_ctime = ITIME(je32_to_cpu(rd->mctime));
4000c514: c8 0f 60 18 ldub [ %i5 + 0x18 ], %g4
4000c518: c4 0f 60 19 ldub [ %i5 + 0x19 ], %g2
4000c51c: c2 0f 60 1a ldub [ %i5 + 0x1a ], %g1
4000c520: c6 0f 60 1b ldub [ %i5 + 0x1b ], %g3
4000c524: 89 29 20 18 sll %g4, 0x18, %g4
4000c528: c0 24 a0 28 clr [ %l2 + 0x28 ]
4000c52c: 85 28 a0 10 sll %g2, 0x10, %g2
4000c530: c0 24 a0 20 clr [ %l2 + 0x20 ]
4000c534: 84 10 80 04 or %g2, %g4, %g2
4000c538: 83 28 60 08 sll %g1, 8, %g1
4000c53c: 82 10 40 02 or %g1, %g2, %g1
4000c540: 82 10 c0 01 or %g3, %g1, %g1
4000c544: c2 24 a0 2c st %g1, [ %l2 + 0x2c ]
jffs2_free_raw_dirent(rd);
4000c548: 90 10 00 1d mov %i5, %o0
4000c54c: 7f ff e5 9e call 40005bc4 <jffs2_free_raw_dirent>
4000c550: c2 24 a0 24 st %g1, [ %l2 + 0x24 ]
jffs2_add_fd_to_list(c, fd, &dir_f->dents);
4000c554: 94 04 a0 54 add %l2, 0x54, %o2
4000c558: 92 10 00 1c mov %i4, %o1
4000c55c: 7f ff e6 36 call 40005e34 <jffs2_add_fd_to_list>
4000c560: 90 10 00 13 mov %l3, %o0
jffs2_complete_reservation(c);
4000c564: 7f ff ea 61 call 40006ee8 <jffs2_complete_reservation>
4000c568: 90 10 00 13 mov %l3, %o0
jffs2_iput(inode);
4000c56c: 7f ff dc 95 call 400037c0 <jffs2_iput>
4000c570: 90 10 00 11 mov %l1, %o0
return ret;
4000c574: 81 c7 e0 08 ret
4000c578: 81 e8 00 00 restore
char *dup = malloc(n + 1);
4000c57c: 40 00 0a d2 call 4000f0c4 <malloc>
4000c580: 90 07 60 02 add %i5, 2, %o0
if (dup != 0) {
4000c584: 82 92 20 00 orcc %o0, 0, %g1
4000c588: 02 80 00 13 be 4000c5d4 <jffs2_mknod+0x474> <== NEVER TAKEN
4000c58c: 94 07 60 01 add %i5, 1, %o2
dup[n] = '\0';
4000c590: c0 28 40 0a clrb [ %g1 + %o2 ]
dup = memcpy(dup, s, n);
4000c594: 40 00 42 65 call 4001cf28 <memcpy>
4000c598: 92 10 00 1c mov %i4, %o1
f->target = kmemdup(data, datalen + 1, GFP_KERNEL);
4000c59c: 10 bf ff 5b b 4000c308 <jffs2_mknod+0x1a8>
4000c5a0: d0 24 60 58 st %o0, [ %l1 + 0x58 ]
jffs2_complete_reservation(c);
4000c5a4: 7f ff ea 51 call 40006ee8 <jffs2_complete_reservation> <== NOT EXECUTED
4000c5a8: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
ret = PTR_ERR(fd);
4000c5ac: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
jffs2_free_raw_dirent(rd);
4000c5b0: 7f ff e5 85 call 40005bc4 <jffs2_free_raw_dirent> <== NOT EXECUTED
4000c5b4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
goto fail;
4000c5b8: 30 bf ff 61 b,a 4000c33c <jffs2_mknod+0x1dc> <== NOT EXECUTED
jffs2_complete_reservation(c);
4000c5bc: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
4000c5c0: 7f ff ea 4a call 40006ee8 <jffs2_complete_reservation> <== NOT EXECUTED
4000c5c4: b0 10 3f f4 mov -12, %i0 <== NOT EXECUTED
goto fail;
4000c5c8: 30 bf ff 5d b,a 4000c33c <jffs2_mknod+0x1dc> <== NOT EXECUTED
return -ENAMETOOLONG;
4000c5cc: 81 c7 e0 08 ret <== NOT EXECUTED
4000c5d0: 91 e8 3f a5 restore %g0, -91, %o0 <== NOT EXECUTED
f->target = kmemdup(data, datalen + 1, GFP_KERNEL);
4000c5d4: c0 24 60 58 clr [ %l1 + 0x58 ] <== NOT EXECUTED
pr_warn("Can't allocate %d bytes of memory\n", datalen + 1);
4000c5d8: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
4000c5dc: 11 10 00 82 sethi %hi(0x40020800), %o0 <== NOT EXECUTED
4000c5e0: 7f ff fe 19 call 4000be44 <jffs2_printk> <== NOT EXECUTED
4000c5e4: 90 12 21 98 or %o0, 0x198, %o0 ! 40020998 <__func__.0+0x50> <== NOT EXECUTED
ret = -ENOMEM;
4000c5e8: b0 10 3f f4 mov -12, %i0 <== NOT EXECUTED
jffs2_complete_reservation(c);
4000c5ec: 7f ff ea 3f call 40006ee8 <jffs2_complete_reservation> <== NOT EXECUTED
4000c5f0: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
goto fail;
4000c5f4: 30 bf ff 52 b,a 4000c33c <jffs2_mknod+0x1dc> <== NOT EXECUTED
}
4000c5f8: 81 c7 e0 08 ret <== NOT EXECUTED
4000c5fc: 91 e8 3f f4 restore %g0, -12, %o0 <== NOT EXECUTED
40003f70 <jffs2_new_inode>:
{
40003f70: 9d e3 bf a0 save %sp, -96, %sp
struct super_block *sb = dir_i->i_sb;
40003f74: fa 06 20 40 ld [ %i0 + 0x40 ], %i5
inode = new_inode(sb);
40003f78: 7f ff f8 93 call 400021c4 <new_inode>
40003f7c: 90 10 00 1d mov %i5, %o0
if (!inode)
40003f80: b0 92 20 00 orcc %o0, 0, %i0
40003f84: 02 80 00 75 be 40004158 <jffs2_new_inode+0x1e8> <== NEVER TAKEN
40003f88: b6 06 20 48 add %i0, 0x48, %i3
memset(f, 0, sizeof(*f));
40003f8c: 94 10 20 1c mov 0x1c, %o2
40003f90: 92 10 20 00 clr %o1
40003f94: 40 00 64 24 call 4001d024 <memset>
40003f98: 90 10 00 1b mov %i3, %o0
memset(ri, 0, sizeof(*ri));
40003f9c: 94 10 20 44 mov 0x44, %o2
40003fa0: 92 10 20 00 clr %o1
40003fa4: 40 00 64 20 call 4001d024 <memset>
40003fa8: 90 10 00 1a mov %i2, %o0
ri->uid = cpu_to_je16(geteuid());
40003fac: 40 00 2b ae call 4000ee64 <geteuid>
40003fb0: 39 00 00 3c sethi %hi(0xf000), %i4
40003fb4: 91 2a 20 10 sll %o0, 0x10, %o0
40003fb8: 83 32 20 10 srl %o0, 0x10, %g1
40003fbc: 91 32 20 18 srl %o0, 0x18, %o0
40003fc0: c2 2e a0 19 stb %g1, [ %i2 + 0x19 ]
40003fc4: d0 2e a0 18 stb %o0, [ %i2 + 0x18 ]
ri->gid = cpu_to_je16(getegid());
40003fc8: 40 00 2b a1 call 4000ee4c <getegid>
40003fcc: b8 17 21 ff or %i4, 0x1ff, %i4
40003fd0: 91 2a 20 10 sll %o0, 0x10, %o0
40003fd4: 83 32 20 10 srl %o0, 0x10, %g1
ri->mode = cpu_to_jemode(mode);
40003fd8: c0 2e a0 14 clrb [ %i2 + 0x14 ]
ri->gid = cpu_to_je16(getegid());
40003fdc: 91 32 20 18 srl %o0, 0x18, %o0
40003fe0: c2 2e a0 1b stb %g1, [ %i2 + 0x1b ]
return osmode & (S_IFMT | S_IRWXU | S_IRWXG | S_IRWXO);
40003fe4: 82 0e 40 1c and %i1, %i4, %g1
40003fe8: d0 2e a0 1a stb %o0, [ %i2 + 0x1a ]
ri->mode = cpu_to_jemode(mode);
40003fec: 83 30 60 08 srl %g1, 8, %g1
40003ff0: c0 2e a0 15 clrb [ %i2 + 0x15 ]
ret = jffs2_do_new_inode (c, f, mode, ri);
40003ff4: 90 10 00 1d mov %i5, %o0
ri->mode = cpu_to_jemode(mode);
40003ff8: f2 2e a0 17 stb %i1, [ %i2 + 0x17 ]
ret = jffs2_do_new_inode (c, f, mode, ri);
40003ffc: 96 10 00 1a mov %i2, %o3
ri->mode = cpu_to_jemode(mode);
40004000: c2 2e a0 16 stb %g1, [ %i2 + 0x16 ]
ret = jffs2_do_new_inode (c, f, mode, ri);
40004004: 94 10 00 19 mov %i1, %o2
40004008: 40 00 17 fc call 40009ff8 <jffs2_do_new_inode>
4000400c: 92 10 00 1b mov %i3, %o1
if (ret) {
40004010: ba 92 20 00 orcc %o0, 0, %i5
40004014: 22 80 00 12 be,a 4000405c <jffs2_new_inode+0xec> <== ALWAYS TAKEN
40004018: 82 10 20 01 mov 1, %g1
if (inode->i_cache_prev)
4000401c: c4 06 20 64 ld [ %i0 + 0x64 ], %g2 <== NOT EXECUTED
40004020: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40004024: 02 80 00 03 be 40004030 <jffs2_new_inode+0xc0> <== NOT EXECUTED
40004028: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 <== NOT EXECUTED
inode->i_cache_prev->i_cache_next = inode->i_cache_next;
4000402c: c2 20 a0 68 st %g1, [ %g2 + 0x68 ] <== NOT EXECUTED
if (inode->i_cache_next)
40004030: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40004034: 32 80 00 02 bne,a 4000403c <jffs2_new_inode+0xcc> <== NOT EXECUTED
40004038: c4 20 60 64 st %g2, [ %g1 + 0x64 ] <== NOT EXECUTED
jffs2_do_clear_inode(c, f);
4000403c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
40004040: 40 00 17 71 call 40009e04 <jffs2_do_clear_inode> <== NOT EXECUTED
40004044: d0 06 20 40 ld [ %i0 + 0x40 ], %o0 <== NOT EXECUTED
free(inode);
40004048: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000404c: 40 00 2b 3a call 4000ed34 <free> <== NOT EXECUTED
40004050: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return ERR_PTR(ret);
40004054: 81 c7 e0 08 ret <== NOT EXECUTED
40004058: 81 e8 00 00 restore <== NOT EXECUTED
inode->i_nlink = 1;
4000405c: c2 36 20 0c sth %g1, [ %i0 + 0xc ]
inode->i_ino = je32_to_cpu(ri->ino);
40004060: c6 0e a0 0f ldub [ %i2 + 0xf ], %g3
40004064: c8 0e a0 0c ldub [ %i2 + 0xc ], %g4
40004068: c4 0e a0 0d ldub [ %i2 + 0xd ], %g2
4000406c: c2 0e a0 0e ldub [ %i2 + 0xe ], %g1
40004070: 89 29 20 18 sll %g4, 0x18, %g4
40004074: 85 28 a0 10 sll %g2, 0x10, %g2
40004078: 83 28 60 08 sll %g1, 8, %g1
4000407c: 84 10 80 04 or %g2, %g4, %g2
40004080: 82 10 40 02 or %g1, %g2, %g1
40004084: 82 10 c0 01 or %g3, %g1, %g1
40004088: c2 26 00 00 st %g1, [ %i0 ]
inode->i_mode = jemode_to_cpu(ri->mode);
4000408c: c8 0e a0 14 ldub [ %i2 + 0x14 ], %g4
40004090: c6 0e a0 15 ldub [ %i2 + 0x15 ], %g3
40004094: c4 0e a0 16 ldub [ %i2 + 0x16 ], %g2
40004098: c2 0e a0 17 ldub [ %i2 + 0x17 ], %g1
4000409c: 89 29 20 18 sll %g4, 0x18, %g4
400040a0: 87 28 e0 10 sll %g3, 0x10, %g3
400040a4: 85 28 a0 08 sll %g2, 8, %g2
400040a8: 86 10 c0 04 or %g3, %g4, %g3
400040ac: 84 10 80 03 or %g2, %g3, %g2
400040b0: 82 10 40 02 or %g1, %g2, %g1
return jmode & (S_IFMT | S_IRWXU | S_IRWXG | S_IRWXO);
400040b4: b8 08 40 1c and %g1, %i4, %i4
400040b8: f8 26 20 08 st %i4, [ %i0 + 8 ]
inode->i_gid = je16_to_cpu(ri->gid);
400040bc: c4 0e a0 1a ldub [ %i2 + 0x1a ], %g2
400040c0: c2 0e a0 1b ldub [ %i2 + 0x1b ], %g1
400040c4: 85 28 a0 08 sll %g2, 8, %g2
400040c8: 82 10 40 02 or %g1, %g2, %g1
400040cc: c2 36 20 10 sth %g1, [ %i0 + 0x10 ]
inode->i_uid = je16_to_cpu(ri->uid);
400040d0: c4 0e a0 18 ldub [ %i2 + 0x18 ], %g2
400040d4: c2 0e a0 19 ldub [ %i2 + 0x19 ], %g1
400040d8: 85 28 a0 08 sll %g2, 8, %g2
400040dc: 82 10 40 02 or %g1, %g2, %g1
inode->i_atime = inode->i_ctime = inode->i_mtime = get_seconds();
400040e0: 40 00 65 41 call 4001d5e4 <time>
400040e4: c2 36 20 0e sth %g1, [ %i0 + 0xe ]
400040e8: d0 26 20 20 st %o0, [ %i0 + 0x20 ]
ri->atime = ri->mtime = ri->ctime = cpu_to_je32(inode->i_mtime);
400040ec: 89 32 60 18 srl %o1, 0x18, %g4
inode->i_atime = inode->i_ctime = inode->i_mtime = get_seconds();
400040f0: d2 26 20 24 st %o1, [ %i0 + 0x24 ]
ri->atime = ri->mtime = ri->ctime = cpu_to_je32(inode->i_mtime);
400040f4: 86 0a 60 ff and %o1, 0xff, %g3
inode->i_atime = inode->i_ctime = inode->i_mtime = get_seconds();
400040f8: d0 26 20 28 st %o0, [ %i0 + 0x28 ]
ri->atime = ri->mtime = ri->ctime = cpu_to_je32(inode->i_mtime);
400040fc: 85 32 60 10 srl %o1, 0x10, %g2
inode->i_atime = inode->i_ctime = inode->i_mtime = get_seconds();
40004100: d2 26 20 2c st %o1, [ %i0 + 0x2c ]
ri->atime = ri->mtime = ri->ctime = cpu_to_je32(inode->i_mtime);
40004104: 84 08 a0 ff and %g2, 0xff, %g2
inode->i_atime = inode->i_ctime = inode->i_mtime = get_seconds();
40004108: d0 26 20 18 st %o0, [ %i0 + 0x18 ]
ri->atime = ri->mtime = ri->ctime = cpu_to_je32(inode->i_mtime);
4000410c: 83 32 60 08 srl %o1, 8, %g1
inode->i_atime = inode->i_ctime = inode->i_mtime = get_seconds();
40004110: d2 26 20 1c st %o1, [ %i0 + 0x1c ]
ri->atime = ri->mtime = ri->ctime = cpu_to_je32(inode->i_mtime);
40004114: 82 08 60 ff and %g1, 0xff, %g1
40004118: c8 2e a0 28 stb %g4, [ %i2 + 0x28 ]
4000411c: c4 2e a0 29 stb %g2, [ %i2 + 0x29 ]
40004120: c2 2e a0 2a stb %g1, [ %i2 + 0x2a ]
40004124: c6 2e a0 2b stb %g3, [ %i2 + 0x2b ]
40004128: c8 2e a0 24 stb %g4, [ %i2 + 0x24 ]
4000412c: c4 2e a0 25 stb %g2, [ %i2 + 0x25 ]
40004130: c2 2e a0 26 stb %g1, [ %i2 + 0x26 ]
40004134: c6 2e a0 27 stb %g3, [ %i2 + 0x27 ]
40004138: c8 2e a0 20 stb %g4, [ %i2 + 0x20 ]
4000413c: c4 2e a0 21 stb %g2, [ %i2 + 0x21 ]
40004140: c2 2e a0 22 stb %g1, [ %i2 + 0x22 ]
40004144: c6 2e a0 23 stb %g3, [ %i2 + 0x23 ]
inode->i_size = 0;
40004148: c0 26 20 38 clr [ %i0 + 0x38 ]
4000414c: c0 26 20 3c clr [ %i0 + 0x3c ]
return inode;
40004150: 81 c7 e0 08 ret
40004154: 81 e8 00 00 restore
}
40004158: 81 c7 e0 08 ret <== NOT EXECUTED
4000415c: 91 e8 3f f4 restore %g0, -12, %o0 <== NOT EXECUTED
40005c08 <jffs2_prealloc_raw_node_refs>:
return ret;
}
int jffs2_prealloc_raw_node_refs(struct jffs2_sb_info *c,
struct jffs2_eraseblock *jeb, int nr)
{
40005c08: 9d e3 bf a0 save %sp, -96, %sp
struct jffs2_raw_node_ref **p, *ref;
int i = nr;
p = &jeb->last_node;
ref = *p;
40005c0c: d0 06 60 2c ld [ %i1 + 0x2c ], %o0
/* If jeb->last_node is really a valid node then skip over it */
if (ref && ref->flash_offset != REF_EMPTY_NODE)
40005c10: 80 a2 20 00 cmp %o0, 0
40005c14: 02 80 00 06 be 40005c2c <jffs2_prealloc_raw_node_refs+0x24>
40005c18: b6 06 60 2c add %i1, 0x2c, %i3
40005c1c: c2 02 20 04 ld [ %o0 + 4 ], %g1
40005c20: 80 a0 7f fe cmp %g1, -2
40005c24: 32 80 00 02 bne,a 40005c2c <jffs2_prealloc_raw_node_refs+0x24> <== ALWAYS TAKEN
40005c28: 90 02 20 08 add %o0, 8, %o0
ref++;
while (i) {
40005c2c: 80 a6 a0 00 cmp %i2, 0
40005c30: 22 80 00 10 be,a 40005c70 <jffs2_prealloc_raw_node_refs+0x68> <== NEVER TAKEN
40005c34: f4 26 60 24 st %i2, [ %i1 + 0x24 ] <== NOT EXECUTED
40005c38: b8 10 00 1a mov %i2, %i4
ret[i].flash_offset = REF_EMPTY_NODE;
40005c3c: ba 10 3f fe mov -2, %i5
ret[i].flash_offset = REF_LINK_NODE;
40005c40: b0 10 3f ff mov -1, %i0
if (!ref) {
40005c44: 80 a2 20 00 cmp %o0, 0
40005c48: 02 80 00 10 be 40005c88 <jffs2_prealloc_raw_node_refs+0x80>
40005c4c: 01 00 00 00 nop
ref = *p = jffs2_alloc_refblock();
if (!ref)
return -ENOMEM;
}
if (ref->flash_offset == REF_LINK_NODE) {
40005c50: c2 02 20 04 ld [ %o0 + 4 ], %g1
40005c54: 80 a0 7f ff cmp %g1, -1
40005c58: 22 80 00 08 be,a 40005c78 <jffs2_prealloc_raw_node_refs+0x70>
40005c5c: b6 10 00 08 mov %o0, %i3
while (i) {
40005c60: b8 87 3f ff addcc %i4, -1, %i4
40005c64: 12 bf ff f8 bne 40005c44 <jffs2_prealloc_raw_node_refs+0x3c> <== NEVER TAKEN
40005c68: 90 02 20 08 add %o0, 8, %o0
continue;
}
i--;
ref++;
}
jeb->allocated_refs = nr;
40005c6c: f4 26 60 24 st %i2, [ %i1 + 0x24 ]
return 0;
40005c70: 81 c7 e0 08 ret
40005c74: 91 e8 20 00 restore %g0, 0, %o0
ref = *p;
40005c78: d0 02 00 00 ld [ %o0 ], %o0
if (!ref) {
40005c7c: 80 a2 20 00 cmp %o0, 0
40005c80: 32 bf ff f5 bne,a 40005c54 <jffs2_prealloc_raw_node_refs+0x4c> <== NEVER TAKEN
40005c84: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED
ret = malloc((REFS_PER_BLOCK + 1) * sizeof(*ret));
40005c88: 40 00 25 0f call 4000f0c4 <malloc>
40005c8c: 90 10 20 f8 mov 0xf8, %o0
if (ret) {
40005c90: 80 a2 20 00 cmp %o0, 0
40005c94: 02 80 00 0c be 40005cc4 <jffs2_prealloc_raw_node_refs+0xbc> <== NEVER TAKEN
40005c98: 82 10 00 08 mov %o0, %g1
40005c9c: 84 02 20 f0 add %o0, 0xf0, %g2
ret[i].flash_offset = REF_EMPTY_NODE;
40005ca0: fa 20 60 04 st %i5, [ %g1 + 4 ]
for (i=0; i < REFS_PER_BLOCK; i++) {
40005ca4: 82 00 60 08 add %g1, 8, %g1
40005ca8: 80 a0 80 01 cmp %g2, %g1
40005cac: 12 bf ff fd bne 40005ca0 <jffs2_prealloc_raw_node_refs+0x98>
40005cb0: c0 20 7f f8 clr [ %g1 + -8 ]
ret[i].flash_offset = REF_LINK_NODE;
40005cb4: f0 22 20 f4 st %i0, [ %o0 + 0xf4 ]
ret[i].next_in_ino = NULL;
40005cb8: c0 22 20 f0 clr [ %o0 + 0xf0 ]
ref = *p = jffs2_alloc_refblock();
40005cbc: 10 bf ff e5 b 40005c50 <jffs2_prealloc_raw_node_refs+0x48>
40005cc0: d0 26 c0 00 st %o0, [ %i3 ]
40005cc4: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
}
40005cc8: 81 c7 e0 08 ret <== NOT EXECUTED
40005ccc: 91 e8 3f f4 restore %g0, -12, %o0 <== NOT EXECUTED
400079f8 <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)
{
400079f8: 9d e3 bf 88 save %sp, -120, %sp
uint32_t crc;
unsigned char *decomprbuf = NULL;
unsigned char *readbuf = NULL;
int ret = 0;
ri = jffs2_alloc_raw_inode();
400079fc: 7f ff f8 75 call 40005bd0 <jffs2_alloc_raw_inode>
40007a00: 01 00 00 00 nop
if (!ri)
40007a04: a0 92 20 00 orcc %o0, 0, %l0
40007a08: 02 80 01 4a be 40007f30 <jffs2_read_dnode+0x538> <== NEVER TAKEN
40007a0c: 98 10 00 10 mov %l0, %o4
return -ENOMEM;
ret = jffs2_flash_read(c, ref_offset(fd->raw), sizeof(*ri), &readlen, (char *)ri);
40007a10: c2 06 80 00 ld [ %i2 ], %g1
40007a14: d2 00 60 04 ld [ %g1 + 4 ], %o1
40007a18: 96 07 bf fc add %fp, -4, %o3
40007a1c: 94 10 20 44 mov 0x44, %o2
40007a20: 92 0a 7f fc and %o1, -4, %o1
40007a24: 40 00 15 07 call 4000ce40 <jffs2_flash_read>
40007a28: 90 10 00 18 mov %i0, %o0
if (ret) {
40007a2c: a2 92 20 00 orcc %o0, 0, %l1
40007a30: 12 80 00 88 bne 40007c50 <jffs2_read_dnode+0x258> <== NEVER TAKEN
40007a34: c2 07 bf fc ld [ %fp + -4 ], %g1
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)) {
40007a38: 80 a0 60 44 cmp %g1, 0x44
40007a3c: 12 80 01 31 bne 40007f00 <jffs2_read_dnode+0x508> <== NEVER TAKEN
40007a40: 92 10 00 10 mov %l0, %o1
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);
40007a44: 40 00 10 4d call 4000bb78 <cyg_crc32_accumulate>
40007a48: 94 10 20 3c mov 0x3c, %o2
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)) {
40007a4c: c6 0c 20 40 ldub [ %l0 + 0x40 ], %g3
40007a50: c4 0c 20 41 ldub [ %l0 + 0x41 ], %g2
40007a54: c2 0c 20 42 ldub [ %l0 + 0x42 ], %g1
40007a58: d2 0c 20 43 ldub [ %l0 + 0x43 ], %o1
40007a5c: 87 28 e0 18 sll %g3, 0x18, %g3
40007a60: 85 28 a0 10 sll %g2, 0x10, %g2
40007a64: 83 28 60 08 sll %g1, 8, %g1
40007a68: 84 10 80 03 or %g2, %g3, %g2
40007a6c: 82 10 40 02 or %g1, %g2, %g1
40007a70: 92 12 40 01 or %o1, %g1, %o1
40007a74: 80 a2 40 08 cmp %o1, %o0
40007a78: 32 80 00 6e bne,a 40007c30 <jffs2_read_dnode+0x238> <== NEVER TAKEN
40007a7c: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
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) &&
40007a80: c6 0c 20 38 ldub [ %l0 + 0x38 ], %g3
40007a84: 80 a0 e0 01 cmp %g3, 1
40007a88: 02 80 00 7e be 40007c80 <jffs2_read_dnode+0x288>
40007a8c: 80 a0 e0 00 cmp %g3, 0
je32_to_cpu(ri->csize)) {
40007a90: c4 0c 20 30 ldub [ %l0 + 0x30 ], %g2
40007a94: c2 0c 20 31 ldub [ %l0 + 0x31 ], %g1
40007a98: d4 0c 20 32 ldub [ %l0 + 0x32 ], %o2
40007a9c: c8 0c 20 33 ldub [ %l0 + 0x33 ], %g4
40007aa0: 85 28 a0 18 sll %g2, 0x18, %g2
40007aa4: 83 28 60 10 sll %g1, 0x10, %g1
40007aa8: 95 2a a0 08 sll %o2, 8, %o2
40007aac: 82 10 40 02 or %g1, %g2, %g1
40007ab0: 94 12 80 01 or %o2, %g1, %o2
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)) {
40007ab4: 12 80 00 85 bne 40007cc8 <jffs2_read_dnode+0x2d0>
40007ab8: 94 11 00 0a or %g4, %o2, %o2
40007abc: c8 0c 20 34 ldub [ %l0 + 0x34 ], %g4
40007ac0: c4 0c 20 35 ldub [ %l0 + 0x35 ], %g2
40007ac4: c2 0c 20 36 ldub [ %l0 + 0x36 ], %g1
40007ac8: c6 0c 20 37 ldub [ %l0 + 0x37 ], %g3
40007acc: 89 29 20 18 sll %g4, 0x18, %g4
40007ad0: 85 28 a0 10 sll %g2, 0x10, %g2
40007ad4: 83 28 60 08 sll %g1, 8, %g1
40007ad8: 84 10 80 04 or %g2, %g4, %g2
40007adc: 82 10 40 02 or %g1, %g2, %g1
40007ae0: 82 10 c0 01 or %g3, %g1, %g1
40007ae4: 80 a0 40 1d cmp %g1, %i5
40007ae8: 22 80 00 9d be,a 40007d5c <jffs2_read_dnode+0x364>
40007aec: c2 06 80 00 ld [ %i2 ], %g1
readbuf = buf;
} else {
readbuf = kmalloc(je32_to_cpu(ri->csize), GFP_KERNEL);
40007af0: d4 27 bf f4 st %o2, [ %fp + -12 ]
40007af4: 40 00 1d 74 call 4000f0c4 <malloc>
40007af8: 90 10 00 0a mov %o2, %o0
if (!readbuf) {
40007afc: d4 07 bf f4 ld [ %fp + -12 ], %o2
40007b00: a6 92 20 00 orcc %o0, 0, %l3
40007b04: 02 80 01 12 be 40007f4c <jffs2_read_dnode+0x554> <== NEVER TAKEN
40007b08: a4 10 00 08 mov %o0, %l2
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),
40007b0c: c2 06 80 00 ld [ %i2 ], %g1
40007b10: d2 00 60 04 ld [ %g1 + 4 ], %o1
40007b14: 92 0a 7f fc and %o1, -4, %o1
40007b18: 98 10 00 13 mov %l3, %o4
40007b1c: 96 07 bf fc add %fp, -4, %o3
40007b20: 92 02 60 44 add %o1, 0x44, %o1
40007b24: 40 00 14 c7 call 4000ce40 <jffs2_flash_read>
40007b28: 90 10 00 18 mov %i0, %o0
je32_to_cpu(ri->csize), &readlen, readbuf);
if (!ret && readlen != je32_to_cpu(ri->csize))
40007b2c: a2 92 20 00 orcc %o0, 0, %l1
40007b30: 12 80 00 38 bne 40007c10 <jffs2_read_dnode+0x218> <== NEVER TAKEN
40007b34: 80 a6 c0 13 cmp %i3, %l3
40007b38: c6 0c 20 30 ldub [ %l0 + 0x30 ], %g3
40007b3c: c4 0c 20 31 ldub [ %l0 + 0x31 ], %g2
40007b40: c2 0c 20 32 ldub [ %l0 + 0x32 ], %g1
40007b44: d4 0c 20 33 ldub [ %l0 + 0x33 ], %o2
40007b48: 87 28 e0 18 sll %g3, 0x18, %g3
40007b4c: 85 28 a0 10 sll %g2, 0x10, %g2
40007b50: 83 28 60 08 sll %g1, 8, %g1
40007b54: 84 10 80 03 or %g2, %g3, %g2
40007b58: 82 10 40 02 or %g1, %g2, %g1
40007b5c: 94 12 80 01 or %o2, %g1, %o2
40007b60: c2 07 bf fc ld [ %fp + -4 ], %g1
40007b64: 80 a2 80 01 cmp %o2, %g1
40007b68: 12 80 00 22 bne 40007bf0 <jffs2_read_dnode+0x1f8> <== NEVER TAKEN
40007b6c: a2 10 3f fb mov -5, %l1
ret = -EIO;
if (ret)
goto out_decomprbuf;
crc = crc32(0, readbuf, je32_to_cpu(ri->csize));
40007b70: 92 10 00 13 mov %l3, %o1
40007b74: 40 00 10 01 call 4000bb78 <cyg_crc32_accumulate>
40007b78: 90 10 20 00 clr %o0
if (crc != je32_to_cpu(ri->data_crc)) {
40007b7c: c6 0c 20 3c ldub [ %l0 + 0x3c ], %g3
40007b80: c4 0c 20 3d ldub [ %l0 + 0x3d ], %g2
40007b84: c2 0c 20 3e ldub [ %l0 + 0x3e ], %g1
40007b88: d2 0c 20 3f ldub [ %l0 + 0x3f ], %o1
40007b8c: 87 28 e0 18 sll %g3, 0x18, %g3
40007b90: 85 28 a0 10 sll %g2, 0x10, %g2
40007b94: 83 28 60 08 sll %g1, 8, %g1
40007b98: 84 10 80 03 or %g2, %g3, %g2
40007b9c: 82 10 40 02 or %g1, %g2, %g1
40007ba0: 92 12 40 01 or %o1, %g1, %o1
40007ba4: 80 a2 40 08 cmp %o1, %o0
40007ba8: 32 80 00 9f bne,a 40007e24 <jffs2_read_dnode+0x42c> <== NEVER TAKEN
40007bac: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
jffs2_dbg(2, "Data CRC matches calculated CRC %08x\n", crc);
if (ri->compr != JFFS2_COMPR_NONE) {
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));
40007bb0: c8 0c 20 34 ldub [ %l0 + 0x34 ], %g4
40007bb4: c4 0c 20 35 ldub [ %l0 + 0x35 ], %g2
40007bb8: c2 0c 20 36 ldub [ %l0 + 0x36 ], %g1
40007bbc: c6 0c 20 37 ldub [ %l0 + 0x37 ], %g3
if (ri->compr != JFFS2_COMPR_NONE) {
40007bc0: f4 0c 20 38 ldub [ %l0 + 0x38 ], %i2
ret = jffs2_decompress(c, f, ri->compr | (ri->usercompr << 8), readbuf, decomprbuf, je32_to_cpu(ri->csize), je32_to_cpu(ri->dsize));
40007bc4: 89 29 20 18 sll %g4, 0x18, %g4
40007bc8: 85 28 a0 10 sll %g2, 0x10, %g2
40007bcc: 83 28 60 08 sll %g1, 8, %g1
40007bd0: 84 10 80 04 or %g2, %g4, %g2
if (ri->compr != JFFS2_COMPR_NONE) {
40007bd4: 80 a6 a0 00 cmp %i2, 0
ret = jffs2_decompress(c, f, ri->compr | (ri->usercompr << 8), readbuf, decomprbuf, je32_to_cpu(ri->csize), je32_to_cpu(ri->dsize));
40007bd8: 82 10 40 02 or %g1, %g2, %g1
if (ri->compr != JFFS2_COMPR_NONE) {
40007bdc: 12 80 00 9d bne 40007e50 <jffs2_read_dnode+0x458>
40007be0: 82 10 c0 01 or %g3, %g1, %g1
pr_warn("Error: jffs2_decompress returned %d\n", ret);
goto out_decomprbuf;
}
}
if (len < je32_to_cpu(ri->dsize)) {
40007be4: 80 a7 40 01 cmp %i5, %g1
40007be8: 0a 80 00 c0 bcs 40007ee8 <jffs2_read_dnode+0x4f0>
40007bec: a2 10 20 00 clr %l1
memcpy(buf, decomprbuf+ofs, len);
}
out_decomprbuf:
if(decomprbuf != buf && decomprbuf != readbuf)
40007bf0: 80 a6 c0 12 cmp %i3, %l2
40007bf4: 02 80 00 06 be 40007c0c <jffs2_read_dnode+0x214>
40007bf8: 80 a4 c0 12 cmp %l3, %l2
40007bfc: 02 80 00 05 be 40007c10 <jffs2_read_dnode+0x218>
40007c00: 80 a6 c0 13 cmp %i3, %l3
kfree(decomprbuf);
40007c04: 40 00 1c 4c call 4000ed34 <free>
40007c08: 90 10 00 12 mov %l2, %o0
out_readbuf:
if(readbuf != buf)
40007c0c: 80 a6 c0 13 cmp %i3, %l3
40007c10: 02 80 00 04 be 40007c20 <jffs2_read_dnode+0x228>
40007c14: 01 00 00 00 nop
kfree(readbuf);
40007c18: 40 00 1c 47 call 4000ed34 <free>
40007c1c: 90 10 00 13 mov %l3, %o0
out_ri:
jffs2_free_raw_inode(ri);
40007c20: 7f ff f7 f0 call 40005be0 <jffs2_free_raw_inode>
40007c24: 90 10 00 10 mov %l0, %o0
return ret;
}
40007c28: 81 c7 e0 08 ret
40007c2c: 91 e8 00 11 restore %g0, %l1, %o0
pr_warn("Node CRC %08x != calculated CRC %08x for node at %08x\n",
40007c30: d6 00 60 04 ld [ %g1 + 4 ], %o3 <== NOT EXECUTED
40007c34: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40007c38: 96 0a ff fc and %o3, -4, %o3 <== NOT EXECUTED
ret = -EIO;
40007c3c: a2 10 3f fb mov -5, %l1 <== NOT EXECUTED
pr_warn("Node CRC %08x != calculated CRC %08x for node at %08x\n",
40007c40: 11 10 00 7d sethi %hi(0x4001f400), %o0 <== NOT EXECUTED
40007c44: 7f ff ff 61 call 400079c8 <jffs2_printk> <== NOT EXECUTED
40007c48: 90 12 20 08 or %o0, 8, %o0 ! 4001f408 <__func__.0+0x98> <== NOT EXECUTED
goto out_ri;
40007c4c: 30 bf ff f5 b,a 40007c20 <jffs2_read_dnode+0x228> <== NOT EXECUTED
jffs2_free_raw_inode(ri);
40007c50: 7f ff f7 e4 call 40005be0 <jffs2_free_raw_inode> <== NOT EXECUTED
40007c54: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
pr_warn("Error reading node from 0x%08x: %d\n",
40007c58: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
40007c5c: d2 00 60 04 ld [ %g1 + 4 ], %o1 <== NOT EXECUTED
40007c60: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
40007c64: 92 0a 7f fc and %o1, -4, %o1 <== NOT EXECUTED
40007c68: 11 10 00 7c sethi %hi(0x4001f000), %o0 <== NOT EXECUTED
}
40007c6c: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
pr_warn("Error reading node from 0x%08x: %d\n",
40007c70: 7f ff ff 56 call 400079c8 <jffs2_printk> <== NOT EXECUTED
40007c74: 90 12 23 90 or %o0, 0x390, %o0 <== NOT EXECUTED
}
40007c78: 81 c7 e0 08 ret <== NOT EXECUTED
40007c7c: 81 e8 00 00 restore <== NOT EXECUTED
if (ri->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(ri->dsize) &&
40007c80: c6 0c 20 34 ldub [ %l0 + 0x34 ], %g3
40007c84: c4 0c 20 35 ldub [ %l0 + 0x35 ], %g2
40007c88: c2 0c 20 36 ldub [ %l0 + 0x36 ], %g1
40007c8c: c8 0c 20 37 ldub [ %l0 + 0x37 ], %g4
40007c90: 87 28 e0 18 sll %g3, 0x18, %g3
40007c94: 85 28 a0 10 sll %g2, 0x10, %g2
40007c98: 83 28 60 08 sll %g1, 8, %g1
40007c9c: 84 10 80 03 or %g2, %g3, %g2
40007ca0: 82 10 40 02 or %g1, %g2, %g1
40007ca4: 80 91 00 01 orcc %g4, %g1, %g0
40007ca8: 22 80 00 48 be,a 40007dc8 <jffs2_read_dnode+0x3d0> <== NEVER TAKEN
40007cac: f4 0c 20 30 ldub [ %l0 + 0x30 ], %i2 <== NOT EXECUTED
memset(buf, 0, len);
40007cb0: 94 10 00 1d mov %i5, %o2
40007cb4: 92 10 20 00 clr %o1
40007cb8: 90 10 00 1b mov %i3, %o0
40007cbc: 40 00 54 da call 4001d024 <memset>
40007cc0: a2 10 20 00 clr %l1
goto out_ri;
40007cc4: 30 bf ff d7 b,a 40007c20 <jffs2_read_dnode+0x228>
readbuf = kmalloc(je32_to_cpu(ri->csize), GFP_KERNEL);
40007cc8: d4 27 bf f4 st %o2, [ %fp + -12 ]
40007ccc: 40 00 1c fe call 4000f0c4 <malloc>
40007cd0: 90 10 00 0a mov %o2, %o0
if (!readbuf) {
40007cd4: a6 92 20 00 orcc %o0, 0, %l3
40007cd8: 02 80 00 9d be 40007f4c <jffs2_read_dnode+0x554> <== NEVER TAKEN
40007cdc: d4 07 bf f4 ld [ %fp + -12 ], %o2
if (ri->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(ri->dsize) &&
40007ce0: c6 0c 20 34 ldub [ %l0 + 0x34 ], %g3
40007ce4: c2 0c 20 35 ldub [ %l0 + 0x35 ], %g1
40007ce8: d0 0c 20 36 ldub [ %l0 + 0x36 ], %o0
40007cec: c4 0c 20 37 ldub [ %l0 + 0x37 ], %g2
40007cf0: 87 28 e0 18 sll %g3, 0x18, %g3
40007cf4: 83 28 60 10 sll %g1, 0x10, %g1
40007cf8: 91 2a 20 08 sll %o0, 8, %o0
40007cfc: 82 10 40 03 or %g1, %g3, %g1
40007d00: 90 12 00 01 or %o0, %g1, %o0
40007d04: 90 10 80 08 or %g2, %o0, %o0
if (len < je32_to_cpu(ri->dsize)) {
40007d08: 80 a7 40 08 cmp %i5, %o0
40007d0c: 1a bf ff 80 bcc 40007b0c <jffs2_read_dnode+0x114>
40007d10: a4 10 00 1b mov %i3, %l2
decomprbuf = kmalloc(je32_to_cpu(ri->dsize), GFP_KERNEL);
40007d14: 40 00 1c ec call 4000f0c4 <malloc>
40007d18: d4 27 bf f4 st %o2, [ %fp + -12 ]
if (!decomprbuf) {
40007d1c: a4 92 20 00 orcc %o0, 0, %l2
40007d20: 02 80 00 8d be 40007f54 <jffs2_read_dnode+0x55c> <== NEVER TAKEN
40007d24: d4 07 bf f4 ld [ %fp + -12 ], %o2
ret = jffs2_flash_read(c, (ref_offset(fd->raw)) + sizeof(*ri),
40007d28: c2 06 80 00 ld [ %i2 ], %g1
40007d2c: d2 00 60 04 ld [ %g1 + 4 ], %o1
40007d30: 92 0a 7f fc and %o1, -4, %o1
40007d34: 98 10 00 13 mov %l3, %o4
40007d38: 96 07 bf fc add %fp, -4, %o3
40007d3c: 92 02 60 44 add %o1, 0x44, %o1
40007d40: 40 00 14 40 call 4000ce40 <jffs2_flash_read>
40007d44: 90 10 00 18 mov %i0, %o0
if (!ret && readlen != je32_to_cpu(ri->csize))
40007d48: a2 92 20 00 orcc %o0, 0, %l1
40007d4c: 12 bf ff aa bne 40007bf4 <jffs2_read_dnode+0x1fc> <== NEVER TAKEN
40007d50: 80 a6 c0 12 cmp %i3, %l2
40007d54: 10 bf ff 7a b 40007b3c <jffs2_read_dnode+0x144>
40007d58: c6 0c 20 30 ldub [ %l0 + 0x30 ], %g3
ret = jffs2_flash_read(c, (ref_offset(fd->raw)) + sizeof(*ri),
40007d5c: d2 00 60 04 ld [ %g1 + 4 ], %o1
40007d60: 92 0a 7f fc and %o1, -4, %o1
40007d64: 98 10 00 1b mov %i3, %o4
40007d68: 96 07 bf fc add %fp, -4, %o3
40007d6c: 92 02 60 44 add %o1, 0x44, %o1
40007d70: 40 00 14 34 call 4000ce40 <jffs2_flash_read>
40007d74: 90 10 00 18 mov %i0, %o0
if (!ret && readlen != je32_to_cpu(ri->csize))
40007d78: a2 92 20 00 orcc %o0, 0, %l1
40007d7c: 12 bf ff a9 bne 40007c20 <jffs2_read_dnode+0x228> <== NEVER TAKEN
40007d80: 01 00 00 00 nop
40007d84: c6 0c 20 30 ldub [ %l0 + 0x30 ], %g3
40007d88: c4 0c 20 31 ldub [ %l0 + 0x31 ], %g2
40007d8c: c2 0c 20 32 ldub [ %l0 + 0x32 ], %g1
40007d90: d4 0c 20 33 ldub [ %l0 + 0x33 ], %o2
40007d94: 87 28 e0 18 sll %g3, 0x18, %g3
40007d98: 85 28 a0 10 sll %g2, 0x10, %g2
40007d9c: 83 28 60 08 sll %g1, 8, %g1
40007da0: 84 10 80 03 or %g2, %g3, %g2
40007da4: 82 10 40 02 or %g1, %g2, %g1
40007da8: 94 12 80 01 or %o2, %g1, %o2
40007dac: c2 07 bf fc ld [ %fp + -4 ], %g1
40007db0: 80 a2 80 01 cmp %o2, %g1
40007db4: 22 80 00 25 be,a 40007e48 <jffs2_read_dnode+0x450> <== ALWAYS TAKEN
40007db8: a4 10 00 1b mov %i3, %l2
40007dbc: a6 10 00 1b mov %i3, %l3 <== NOT EXECUTED
ret = -EIO;
40007dc0: 10 bf ff 93 b 40007c0c <jffs2_read_dnode+0x214> <== NOT EXECUTED
40007dc4: a2 10 3f fb mov -5, %l1 <== NOT EXECUTED
je32_to_cpu(ri->csize)) {
40007dc8: b3 2e a0 18 sll %i2, 0x18, %i1 <== NOT EXECUTED
40007dcc: f8 0c 20 31 ldub [ %l0 + 0x31 ], %i4 <== NOT EXECUTED
40007dd0: c8 0c 20 32 ldub [ %l0 + 0x32 ], %g4 <== NOT EXECUTED
40007dd4: c6 0c 20 33 ldub [ %l0 + 0x33 ], %g3 <== NOT EXECUTED
40007dd8: 84 0f 20 ff and %i4, 0xff, %g2 <== NOT EXECUTED
40007ddc: 82 09 20 ff and %g4, 0xff, %g1 <== NOT EXECUTED
40007de0: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
40007de4: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
40007de8: 84 10 80 19 or %g2, %i1, %g2 <== NOT EXECUTED
40007dec: b2 08 e0 ff and %g3, 0xff, %i1 <== NOT EXECUTED
40007df0: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
if (ri->compr == JFFS2_COMPR_ZERO && !je32_to_cpu(ri->dsize) &&
40007df4: 80 96 40 01 orcc %i1, %g1, %g0 <== NOT EXECUTED
40007df8: 02 bf ff af be 40007cb4 <jffs2_read_dnode+0x2bc> <== NOT EXECUTED
40007dfc: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
ri->dsize = ri->csize;
40007e00: f4 2c 20 34 stb %i2, [ %l0 + 0x34 ] <== NOT EXECUTED
40007e04: f8 2c 20 35 stb %i4, [ %l0 + 0x35 ] <== NOT EXECUTED
40007e08: c8 2c 20 36 stb %g4, [ %l0 + 0x36 ] <== NOT EXECUTED
40007e0c: c6 2c 20 37 stb %g3, [ %l0 + 0x37 ] <== NOT EXECUTED
ri->csize = cpu_to_je32(0);
40007e10: c0 2c 20 30 clrb [ %l0 + 0x30 ] <== NOT EXECUTED
40007e14: c0 2c 20 31 clrb [ %l0 + 0x31 ] <== NOT EXECUTED
40007e18: c0 2c 20 32 clrb [ %l0 + 0x32 ] <== NOT EXECUTED
40007e1c: 10 bf ff a6 b 40007cb4 <jffs2_read_dnode+0x2bc> <== NOT EXECUTED
40007e20: c0 2c 20 33 clrb [ %l0 + 0x33 ] <== NOT EXECUTED
pr_warn("Data CRC %08x != calculated CRC %08x for node at %08x\n",
40007e24: d6 00 60 04 ld [ %g1 + 4 ], %o3 <== NOT EXECUTED
40007e28: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
40007e2c: 96 0a ff fc and %o3, -4, %o3 <== NOT EXECUTED
ret = -EIO;
40007e30: a2 10 3f fb mov -5, %l1 <== NOT EXECUTED
pr_warn("Data CRC %08x != calculated CRC %08x for node at %08x\n",
40007e34: 11 10 00 7d sethi %hi(0x4001f400), %o0 <== NOT EXECUTED
40007e38: 7f ff fe e4 call 400079c8 <jffs2_printk> <== NOT EXECUTED
40007e3c: 90 12 20 50 or %o0, 0x50, %o0 ! 4001f450 <__func__.0+0xe0> <== NOT EXECUTED
goto out_decomprbuf;
40007e40: 10 bf ff 6d b 40007bf4 <jffs2_read_dnode+0x1fc> <== NOT EXECUTED
40007e44: 80 a6 c0 12 cmp %i3, %l2 <== NOT EXECUTED
if (!ret && readlen != je32_to_cpu(ri->csize))
40007e48: 10 bf ff 4a b 40007b70 <jffs2_read_dnode+0x178>
40007e4c: a6 10 00 1b mov %i3, %l3
ret = jffs2_decompress(c, f, ri->compr | (ri->usercompr << 8), readbuf, decomprbuf, je32_to_cpu(ri->csize), je32_to_cpu(ri->dsize));
40007e50: c6 0c 20 32 ldub [ %l0 + 0x32 ], %g3
40007e54: de 0c 20 30 ldub [ %l0 + 0x30 ], %o7
40007e58: c8 0c 20 31 ldub [ %l0 + 0x31 ], %g4
40007e5c: da 0c 20 33 ldub [ %l0 + 0x33 ], %o5
40007e60: c4 0c 20 39 ldub [ %l0 + 0x39 ], %g2
40007e64: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40007e68: 9f 2b e0 18 sll %o7, 0x18, %o7
40007e6c: 89 29 20 10 sll %g4, 0x10, %g4
40007e70: 83 28 e0 08 sll %g3, 8, %g1
40007e74: b5 2e a0 08 sll %i2, 8, %i2
40007e78: 86 11 00 0f or %g4, %o7, %g3
40007e7c: b4 10 80 1a or %g2, %i2, %i2
40007e80: 82 10 40 03 or %g1, %g3, %g1
40007e84: 95 2e a0 08 sll %i2, 8, %o2
40007e88: 9a 13 40 01 or %o5, %g1, %o5
40007e8c: b5 36 a0 08 srl %i2, 8, %i2
40007e90: 98 10 00 12 mov %l2, %o4
40007e94: b4 12 80 1a or %o2, %i2, %i2
40007e98: 96 10 00 13 mov %l3, %o3
40007e9c: 95 2e a0 10 sll %i2, 0x10, %o2
40007ea0: 92 10 00 19 mov %i1, %o1
40007ea4: 95 32 a0 10 srl %o2, 0x10, %o2
40007ea8: 40 00 0f 5b call 4000bc14 <jffs2_decompress>
40007eac: 90 10 00 18 mov %i0, %o0
if (ret) {
40007eb0: a2 92 20 00 orcc %o0, 0, %l1
40007eb4: 32 80 00 21 bne,a 40007f38 <jffs2_read_dnode+0x540> <== NEVER TAKEN
40007eb8: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
if (len < je32_to_cpu(ri->dsize)) {
40007ebc: c8 0c 20 34 ldub [ %l0 + 0x34 ], %g4
40007ec0: c6 0c 20 35 ldub [ %l0 + 0x35 ], %g3
40007ec4: c4 0c 20 36 ldub [ %l0 + 0x36 ], %g2
40007ec8: c2 0c 20 37 ldub [ %l0 + 0x37 ], %g1
40007ecc: 89 29 20 18 sll %g4, 0x18, %g4
40007ed0: 87 28 e0 10 sll %g3, 0x10, %g3
40007ed4: 85 28 a0 08 sll %g2, 8, %g2
40007ed8: 86 10 c0 04 or %g3, %g4, %g3
40007edc: 84 10 80 03 or %g2, %g3, %g2
40007ee0: 10 bf ff 41 b 40007be4 <jffs2_read_dnode+0x1ec>
40007ee4: 82 10 40 02 or %g1, %g2, %g1
memcpy(buf, decomprbuf+ofs, len);
40007ee8: 94 10 00 1d mov %i5, %o2
40007eec: 92 04 80 1c add %l2, %i4, %o1
40007ef0: 40 00 54 0e call 4001cf28 <memcpy>
40007ef4: 90 10 00 1b mov %i3, %o0
if(decomprbuf != buf && decomprbuf != readbuf)
40007ef8: 10 bf ff 3f b 40007bf4 <jffs2_read_dnode+0x1fc>
40007efc: 80 a6 c0 12 cmp %i3, %l2
jffs2_free_raw_inode(ri);
40007f00: 7f ff f7 38 call 40005be0 <jffs2_free_raw_inode> <== NOT EXECUTED
40007f04: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
pr_warn("Short read from 0x%08x: wanted 0x%zx bytes, got 0x%zx\n",
40007f08: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
40007f0c: d2 00 60 04 ld [ %g1 + 4 ], %o1 <== NOT EXECUTED
40007f10: d6 07 bf fc ld [ %fp + -4 ], %o3 <== NOT EXECUTED
40007f14: 94 10 20 44 mov 0x44, %o2 <== NOT EXECUTED
40007f18: 92 0a 7f fc and %o1, -4, %o1 <== NOT EXECUTED
return -EIO;
40007f1c: a2 10 3f fb mov -5, %l1 <== NOT EXECUTED
pr_warn("Short read from 0x%08x: wanted 0x%zx bytes, got 0x%zx\n",
40007f20: 11 10 00 7c sethi %hi(0x4001f000), %o0 <== NOT EXECUTED
40007f24: 7f ff fe a9 call 400079c8 <jffs2_printk> <== NOT EXECUTED
40007f28: 90 12 23 c0 or %o0, 0x3c0, %o0 ! 4001f3c0 <__func__.0+0x50> <== NOT EXECUTED
return -EIO;
40007f2c: 30 bf ff 3f b,a 40007c28 <jffs2_read_dnode+0x230> <== NOT EXECUTED
return -ENOMEM;
40007f30: 10 bf ff 3e b 40007c28 <jffs2_read_dnode+0x230> <== NOT EXECUTED
40007f34: a2 10 3f f4 mov -12, %l1 <== NOT EXECUTED
pr_warn("Error: jffs2_decompress returned %d\n", ret);
40007f38: 11 10 00 7d sethi %hi(0x4001f400), %o0 <== NOT EXECUTED
40007f3c: 7f ff fe a3 call 400079c8 <jffs2_printk> <== NOT EXECUTED
40007f40: 90 12 20 98 or %o0, 0x98, %o0 ! 4001f498 <__func__.0+0x128> <== NOT EXECUTED
goto out_decomprbuf;
40007f44: 10 bf ff 2c b 40007bf4 <jffs2_read_dnode+0x1fc> <== NOT EXECUTED
40007f48: 80 a6 c0 12 cmp %i3, %l2 <== NOT EXECUTED
ret = -ENOMEM;
40007f4c: 10 bf ff 35 b 40007c20 <jffs2_read_dnode+0x228> <== NOT EXECUTED
40007f50: a2 10 3f f4 mov -12, %l1 <== NOT EXECUTED
ret = -ENOMEM;
40007f54: 10 bf ff 2e b 40007c0c <jffs2_read_dnode+0x214> <== NOT EXECUTED
40007f58: a2 10 3f f4 mov -12, %l1 <== NOT EXECUTED
40007f5c <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)
{
40007f5c: 9d e3 bf a0 save %sp, -96, %sp
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);
40007f60: 92 10 00 1b mov %i3, %o1
40007f64: 90 06 60 04 add %i1, 4, %o0
40007f68: 7f ff fa 3a call 40006850 <jffs2_lookup_node_frag>
40007f6c: b8 06 c0 1c add %i3, %i4, %i4
40007f70: a0 10 00 08 mov %o0, %l0
/* 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) {
40007f74: 80 a6 c0 1c cmp %i3, %i4
40007f78: 1a 80 00 29 bcc 4000801c <jffs2_read_inode_range+0xc0>
40007f7c: a2 10 20 00 clr %l1
jffs2_dbg(2, "%s(): offset %d, end %d\n",
__func__, offset, end);
if (unlikely(!frag || frag->ofs > offset ||
40007f80: 80 a4 20 00 cmp %l0, 0
40007f84: 02 80 00 28 be 40008024 <jffs2_read_inode_range+0xc8>
40007f88: 94 27 00 1b sub %i4, %i3, %o2
40007f8c: d4 04 20 18 ld [ %l0 + 0x18 ], %o2
40007f90: 80 a2 80 1b cmp %o2, %i3
40007f94: 18 80 00 2b bgu 40008040 <jffs2_read_inode_range+0xe4> <== NEVER TAKEN
40007f98: 82 27 00 1b sub %i4, %i3, %g1
40007f9c: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
40007fa0: 82 02 80 01 add %o2, %g1, %g1
40007fa4: 80 a0 40 1b cmp %g1, %i3
40007fa8: 08 80 00 1f bleu 40008024 <jffs2_read_inode_range+0xc8> <== NEVER TAKEN
40007fac: 94 27 00 1b sub %i4, %i3, %o2
offset, offset + holesize);
memset(buf, 0, holesize);
buf += holesize;
offset += holesize;
continue;
} else if (unlikely(!frag->node)) {
40007fb0: d4 04 20 10 ld [ %l0 + 0x10 ], %o2
40007fb4: 80 a2 a0 00 cmp %o2, 0
40007fb8: 02 80 00 28 be 40008058 <jffs2_read_inode_range+0xfc> <== NEVER TAKEN
40007fbc: 80 a0 40 1c cmp %g1, %i4
} 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);
40007fc0: 82 20 40 1b sub %g1, %i3, %g1
40007fc4: ba 27 00 1b sub %i4, %i3, %i5
40007fc8: 80 a7 40 01 cmp %i5, %g1
40007fcc: 38 80 00 02 bgu,a 40007fd4 <jffs2_read_inode_range+0x78>
40007fd0: ba 10 00 01 mov %g1, %i5
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);
40007fd4: d8 02 a0 04 ld [ %o2 + 4 ], %o4
40007fd8: 9a 10 00 1d mov %i5, %o5
40007fdc: 98 26 c0 0c sub %i3, %o4, %o4
40007fe0: 96 10 00 1a mov %i2, %o3
40007fe4: 92 10 00 19 mov %i1, %o1
40007fe8: 7f ff fe 84 call 400079f8 <jffs2_read_dnode>
40007fec: 90 10 00 18 mov %i0, %o0
jffs2_dbg(2, "node read done\n");
if (ret) {
40007ff0: a2 92 20 00 orcc %o0, 0, %l1
40007ff4: 12 80 00 32 bne 400080bc <jffs2_read_inode_range+0x160> <== NEVER TAKEN
40007ff8: 94 10 00 1d mov %i5, %o2
return _RBTree_Successor( node );
40007ffc: 40 00 36 7e call 400159f4 <_RBTree_Successor>
40008000: 90 10 00 10 mov %l0, %o0
__func__, ret);
memset(buf, 0, readlen);
return ret;
}
buf += readlen;
offset += readlen;
40008004: b6 06 c0 1d add %i3, %i5, %i3
buf += readlen;
40008008: b4 06 80 1d add %i2, %i5, %i2
while(offset < end) {
4000800c: 80 a6 c0 1c cmp %i3, %i4
40008010: 0a bf ff dc bcs 40007f80 <jffs2_read_inode_range+0x24>
40008014: a0 10 00 08 mov %o0, %l0
frag = frag_next(frag);
jffs2_dbg(2, "node read was OK. Looping\n");
}
}
return 0;
40008018: a2 10 20 00 clr %l1
}
4000801c: 81 c7 e0 08 ret
40008020: 91 e8 00 11 restore %g0, %l1, %o0
uint32_t holesize = end - offset;
40008024: b6 10 00 1c mov %i4, %i3
memset(buf, 0, holesize);
40008028: 90 10 00 1a mov %i2, %o0
4000802c: 92 10 20 00 clr %o1
40008030: 40 00 53 fd call 4001d024 <memset>
40008034: b4 06 80 0a add %i2, %o2, %i2
continue;
40008038: 10 bf ff d0 b 40007f78 <jffs2_read_inode_range+0x1c>
4000803c: 80 a6 c0 1c cmp %i3, %i4
holesize = min(holesize, frag->ofs - offset);
40008040: 94 22 80 1b sub %o2, %i3, %o2 <== NOT EXECUTED
40008044: 80 a2 80 01 cmp %o2, %g1 <== NOT EXECUTED
40008048: 38 80 00 02 bgu,a 40008050 <jffs2_read_inode_range+0xf4> <== NOT EXECUTED
4000804c: 94 10 00 01 mov %g1, %o2 <== NOT EXECUTED
offset += holesize;
40008050: 10 bf ff f6 b 40008028 <jffs2_read_inode_range+0xcc> <== NOT EXECUTED
40008054: b6 06 c0 0a add %i3, %o2, %i3 <== NOT EXECUTED
uint32_t holeend = min(end, frag->ofs + frag->size);
40008058: 18 80 00 0d bgu 4000808c <jffs2_read_inode_range+0x130> <== NOT EXECUTED
4000805c: ba 10 00 01 mov %g1, %i5 <== NOT EXECUTED
memset(buf, 0, holeend - offset);
40008060: b6 27 40 1b sub %i5, %i3, %i3 <== NOT EXECUTED
40008064: 92 10 20 00 clr %o1 <== NOT EXECUTED
40008068: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
4000806c: 40 00 53 ee call 4001d024 <memset> <== NOT EXECUTED
40008070: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
40008074: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
40008078: 40 00 36 5f call 400159f4 <_RBTree_Successor> <== NOT EXECUTED
4000807c: b4 06 80 1b add %i2, %i3, %i2 <== NOT EXECUTED
offset = holeend;
40008080: b6 10 00 1d mov %i5, %i3 <== NOT EXECUTED
continue;
40008084: 10 bf ff bc b 40007f74 <jffs2_read_inode_range+0x18> <== NOT EXECUTED
40008088: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
uint32_t holeend = min(end, frag->ofs + frag->size);
4000808c: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
memset(buf, 0, holeend - offset);
40008090: 92 10 20 00 clr %o1 <== NOT EXECUTED
40008094: b6 27 40 1b sub %i5, %i3, %i3 <== NOT EXECUTED
40008098: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
4000809c: 40 00 53 e2 call 4001d024 <memset> <== NOT EXECUTED
400080a0: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
400080a4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
400080a8: 40 00 36 53 call 400159f4 <_RBTree_Successor> <== NOT EXECUTED
400080ac: b4 06 80 1b add %i2, %i3, %i2 <== NOT EXECUTED
offset = holeend;
400080b0: b6 10 00 1d mov %i5, %i3 <== NOT EXECUTED
400080b4: 10 bf ff b0 b 40007f74 <jffs2_read_inode_range+0x18> <== NOT EXECUTED
400080b8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
memset(buf, 0, readlen);
400080bc: 92 10 20 00 clr %o1 <== NOT EXECUTED
400080c0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
400080c4: 40 00 53 d8 call 4001d024 <memset> <== NOT EXECUTED
400080c8: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
}
400080cc: 81 c7 e0 08 ret <== NOT EXECUTED
400080d0: 81 e8 00 00 restore <== NOT EXECUTED
4000c684 <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)
{
4000c684: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
*/
/* Make a hard link */
/* XXX: This is ugly */
type = (d_inode->i_mode & S_IFMT) >> 12;
4000c688: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
4000c68c: 83 30 60 0c srl %g1, 0xc, %g1 <== NOT EXECUTED
struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb);
4000c690: e4 06 20 40 ld [ %i0 + 0x40 ], %l2 <== NOT EXECUTED
type = (d_inode->i_mode & S_IFMT) >> 12;
4000c694: 82 08 60 0f and %g1, 0xf, %g1 <== NOT EXECUTED
{
4000c698: a6 10 00 18 mov %i0, %l3 <== NOT EXECUTED
if (!type) type = DT_REG;
4000c69c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000c6a0: 12 80 00 03 bne 4000c6ac <jffs2_rename+0x28> <== NOT EXECUTED
4000c6a4: a2 10 00 01 mov %g1, %l1 <== NOT EXECUTED
4000c6a8: a2 10 20 08 mov 8, %l1 <== NOT EXECUTED
now = get_seconds();
4000c6ac: 40 00 43 ce call 4001d5e4 <time> <== NOT EXECUTED
4000c6b0: 90 10 20 00 clr %o0 <== NOT EXECUTED
ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i),
4000c6b4: d2 23 a0 5c st %o1, [ %sp + 0x5c ] <== NOT EXECUTED
now = get_seconds();
4000c6b8: a0 10 00 09 mov %o1, %l0 <== NOT EXECUTED
ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i),
4000c6bc: da 07 a0 5c ld [ %fp + 0x5c ], %o5 <== NOT EXECUTED
4000c6c0: d4 06 40 00 ld [ %i1 ], %o2 <== NOT EXECUTED
4000c6c4: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
4000c6c8: 96 0c 60 0f and %l1, 0xf, %o3 <== NOT EXECUTED
4000c6cc: 92 07 20 48 add %i4, 0x48, %o1 <== NOT EXECUTED
4000c6d0: 7f ff fa af call 4000b18c <jffs2_do_link> <== NOT EXECUTED
4000c6d4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
d_inode->i_ino, type,
(const char *)new_d_name,
new_d_namelen, now);
if (ret)
4000c6d8: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4000c6dc: 12 80 00 16 bne 4000c734 <jffs2_rename+0xb0> <== NOT EXECUTED
4000c6e0: 9a 10 00 10 mov %l0, %o5 <== NOT EXECUTED
mutex_unlock(&victim_f->sem);
}
}
/* Unlink the original */
ret = jffs2_do_unlink(c, JFFS2_INODE_INFO(old_dir_i),
4000c6e4: 98 10 20 00 clr %o4 <== NOT EXECUTED
4000c6e8: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
4000c6ec: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4000c6f0: 92 04 e0 48 add %l3, 0x48, %o1 <== NOT EXECUTED
4000c6f4: 7f ff fa 42 call 4000affc <jffs2_do_unlink> <== NOT EXECUTED
4000c6f8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
(const char *)old_d_name,
old_d_namelen, NULL, now);
if (ret) {
4000c6fc: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
4000c700: 02 80 00 0d be 4000c734 <jffs2_rename+0xb0> <== NOT EXECUTED
4000c704: 01 00 00 00 nop <== NOT EXECUTED
/* Oh shit. We really ought to make a single node which can do both atomically */
struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode);
mutex_lock(&f->sem);
if (f->inocache)
4000c708: c2 06 60 5c ld [ %i1 + 0x5c ], %g1 <== NOT EXECUTED
4000c70c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000c710: 02 80 00 06 be 4000c728 <jffs2_rename+0xa4> <== NOT EXECUTED
4000c714: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
d_inode->i_nlink = f->inocache->pino_nlink++;
4000c718: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 <== NOT EXECUTED
4000c71c: 86 00 a0 01 add %g2, 1, %g3 <== NOT EXECUTED
4000c720: c6 20 60 14 st %g3, [ %g1 + 0x14 ] <== NOT EXECUTED
4000c724: c4 36 60 0c sth %g2, [ %i1 + 0xc ] <== 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);
4000c728: 11 10 00 82 sethi %hi(0x40020800), %o0 <== NOT EXECUTED
4000c72c: 7f ff fd c6 call 4000be44 <jffs2_printk> <== NOT EXECUTED
4000c730: 90 12 21 c0 or %o0, 0x1c0, %o0 ! 400209c0 <__func__.0+0x78> <== NOT EXECUTED
}
return ret;
}
4000c734: 81 c7 e0 08 ret <== NOT EXECUTED
4000c738: 81 e8 00 00 restore <== NOT EXECUTED
4000778c <jffs2_reserve_space>:
{
4000778c: 9d e3 bf a0 save %sp, -96, %sp
if (prio != ALLOC_DELETION && !jffs2_rp_can_write(c)) {
40007790: 80 a6 e0 01 cmp %i3, 1
40007794: 02 80 00 15 be 400077e8 <jffs2_reserve_space+0x5c> <== NEVER TAKEN
40007798: f8 0e 20 44 ldub [ %i0 + 0x44 ], %i4
avail = c->dirty_size + c->free_size + c->unchecked_size +
4000779c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
400077a0: da 06 20 28 ld [ %i0 + 0x28 ], %o5
400077a4: de 06 20 38 ld [ %i0 + 0x38 ], %o7
400077a8: fa 06 20 2c ld [ %i0 + 0x2c ], %i5
400077ac: c8 06 20 4c ld [ %i0 + 0x4c ], %g4
c->erasing_size - c->resv_blocks_write * c->sector_size
400077b0: c4 06 20 34 ld [ %i0 + 0x34 ], %g2
if (avail > opts->rp_size)
400077b4: c6 06 20 d8 ld [ %i0 + 0xd8 ], %g3
avail = c->dirty_size + c->free_size + c->unchecked_size +
400077b8: 82 00 40 0d add %g1, %o5, %g1
c->erasing_size - c->resv_blocks_write * c->sector_size
400077bc: 84 5f 00 02 smul %i4, %g2, %g2
avail = c->dirty_size + c->free_size + c->unchecked_size +
400077c0: 82 00 40 0f add %g1, %o7, %g1
400077c4: 82 00 40 1d add %g1, %i5, %g1
400077c8: 82 20 40 04 sub %g1, %g4, %g1
400077cc: 82 20 40 02 sub %g1, %g2, %g1
if (avail > opts->rp_size)
400077d0: 80 a0 40 03 cmp %g1, %g3
400077d4: 38 80 00 06 bgu,a 400077ec <jffs2_reserve_space+0x60> <== ALWAYS TAKEN
400077d8: b2 06 60 03 add %i1, 3, %i1
ret = -ENOSPC;
400077dc: 90 10 3f e4 mov -28, %o0 <== NOT EXECUTED
}
400077e0: 81 c7 e0 08 ret
400077e4: 91 e8 00 08 restore %g0, %o0, %o0
minsize = PAD(minsize);
400077e8: b2 06 60 03 add %i1, 3, %i1 <== NOT EXECUTED
400077ec: b2 0e 7f fc and %i1, -4, %i1
while(c->nr_free_blocks + c->nr_erasing_blocks < blocksneeded) {
400077f0: c4 06 20 40 ld [ %i0 + 0x40 ], %g2
400077f4: c6 06 20 3c ld [ %i0 + 0x3c ], %g3
400077f8: 86 00 80 03 add %g2, %g3, %g3
400077fc: 80 a0 c0 1c cmp %g3, %i4
40007800: 1a 80 00 25 bcc 40007894 <jffs2_reserve_space+0x108>
40007804: 90 10 00 18 mov %i0, %o0
dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size + c->unchecked_size;
40007808: c8 06 20 34 ld [ %i0 + 0x34 ], %g4
4000780c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40007810: da 06 20 2c ld [ %i0 + 0x2c ], %o5
40007814: de 06 20 38 ld [ %i0 + 0x38 ], %o7
if (dirty < c->nospc_dirty_size) {
40007818: fa 06 20 4c ld [ %i0 + 0x4c ], %i5
4000781c: 82 00 40 0d add %g1, %o5, %g1
dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size + c->unchecked_size;
40007820: 84 59 00 02 smul %g4, %g2, %g2
40007824: 82 00 40 0f add %g1, %o7, %g1
40007828: 84 20 40 02 sub %g1, %g2, %g2
if (dirty < c->nospc_dirty_size) {
4000782c: 80 a7 40 02 cmp %i5, %g2
40007830: 18 80 00 26 bgu 400078c8 <jffs2_reserve_space+0x13c>
40007834: 80 a6 e0 01 cmp %i3, 1
avail = c->free_size + c->dirty_size + c->erasing_size + c->unchecked_size;
40007838: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
4000783c: 82 00 40 02 add %g1, %g2, %g1
if ( (avail / c->sector_size) <= blocksneeded) {
40007840: 81 80 20 00 wr %g0, %y
40007844: 01 00 00 00 nop
40007848: 01 00 00 00 nop
4000784c: 01 00 00 00 nop
40007850: 82 70 40 04 udiv %g1, %g4, %g1
40007854: 80 a0 40 1c cmp %g1, %i4
40007858: 08 80 00 1c bleu 400078c8 <jffs2_reserve_space+0x13c> <== NEVER TAKEN
4000785c: 80 a6 e0 01 cmp %i3, 1
ret = jffs2_garbage_collect_pass(c);
40007860: 7f ff f3 8a call 40004688 <jffs2_garbage_collect_pass>
40007864: 01 00 00 00 nop
} else if (ret)
40007868: 80 a2 3f f5 cmp %o0, -11
4000786c: 02 bf ff e1 be 400077f0 <jffs2_reserve_space+0x64> <== NEVER TAKEN
40007870: 80 a2 20 00 cmp %o0, 0
40007874: 12 bf ff db bne 400077e0 <jffs2_reserve_space+0x54> <== NEVER TAKEN
40007878: 01 00 00 00 nop
while(c->nr_free_blocks + c->nr_erasing_blocks < blocksneeded) {
4000787c: c4 06 20 40 ld [ %i0 + 0x40 ], %g2
40007880: c6 06 20 3c ld [ %i0 + 0x3c ], %g3
40007884: 86 00 80 03 add %g2, %g3, %g3
40007888: 80 a0 c0 1c cmp %g3, %i4
4000788c: 0a bf ff df bcs 40007808 <jffs2_reserve_space+0x7c>
40007890: 90 10 00 18 mov %i0, %o0
ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
40007894: 94 10 00 1a mov %i2, %o2
40007898: 92 10 00 19 mov %i1, %o1
4000789c: 7f ff fe d7 call 400073f8 <jffs2_do_reserve_space.constprop.0>
400078a0: 90 10 00 18 mov %i0, %o0
while(ret == -EAGAIN) {
400078a4: 80 a2 3f f5 cmp %o0, -11
400078a8: 22 bf ff d3 be,a 400077f4 <jffs2_reserve_space+0x68> <== NEVER TAKEN
400078ac: c4 06 20 40 ld [ %i0 + 0x40 ], %g2 <== NOT EXECUTED
if (!ret)
400078b0: 80 a2 20 00 cmp %o0, 0
400078b4: 12 bf ff cb bne 400077e0 <jffs2_reserve_space+0x54> <== NEVER TAKEN
400078b8: 01 00 00 00 nop
ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
400078bc: f2 06 20 58 ld [ %i0 + 0x58 ], %i1
400078c0: 7f ff f8 d2 call 40005c08 <jffs2_prealloc_raw_node_refs>
400078c4: 95 e8 20 01 restore %g0, 1, %o2
if (prio == ALLOC_DELETION && c->nr_free_blocks + c->nr_erasing_blocks >= c->resv_blocks_deletion) {
400078c8: 12 bf ff c6 bne 400077e0 <jffs2_reserve_space+0x54> <== ALWAYS TAKEN
400078cc: 90 10 3f e4 mov -28, %o0
400078d0: c2 0e 20 45 ldub [ %i0 + 0x45 ], %g1 <== NOT EXECUTED
400078d4: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
400078d8: 18 bf ff c2 bgu 400077e0 <jffs2_reserve_space+0x54> <== NOT EXECUTED
400078dc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
400078e0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
400078e4: 7f ff fe c5 call 400073f8 <jffs2_do_reserve_space.constprop.0> <== NOT EXECUTED
400078e8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
while(ret == -EAGAIN) {
400078ec: 80 a2 3f f5 cmp %o0, -11 <== NOT EXECUTED
400078f0: 22 bf ff c1 be,a 400077f4 <jffs2_reserve_space+0x68> <== NOT EXECUTED
400078f4: c4 06 20 40 ld [ %i0 + 0x40 ], %g2 <== NOT EXECUTED
if (!ret)
400078f8: 10 bf ff ef b 400078b4 <jffs2_reserve_space+0x128> <== NOT EXECUTED
400078fc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40007748 <jffs2_reserve_space_gc>:
{
40007748: 9d e3 bf a0 save %sp, -96, %sp
minsize = PAD(minsize);
4000774c: b2 06 60 03 add %i1, 3, %i1
40007750: b2 0e 7f fc and %i1, -4, %i1
ret = jffs2_do_reserve_space(c, minsize, len, sumsize);
40007754: 94 10 00 1a mov %i2, %o2
40007758: 92 10 00 19 mov %i1, %o1
4000775c: 7f ff ff 27 call 400073f8 <jffs2_do_reserve_space.constprop.0>
40007760: 90 10 00 18 mov %i0, %o0
if (ret == -EAGAIN)
40007764: 80 a2 3f f5 cmp %o0, -11
40007768: 02 bf ff fc be 40007758 <jffs2_reserve_space_gc+0x10> <== NEVER TAKEN
4000776c: 94 10 00 1a mov %i2, %o2
if (!ret)
40007770: 80 a2 20 00 cmp %o0, 0
40007774: 22 80 00 04 be,a 40007784 <jffs2_reserve_space_gc+0x3c> <== ALWAYS TAKEN
40007778: f2 06 20 58 ld [ %i0 + 0x58 ], %i1
}
4000777c: 81 c7 e0 08 ret <== NOT EXECUTED
40007780: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
ret = jffs2_prealloc_raw_node_refs(c, c->nextblock, 1);
40007784: 7f ff f9 21 call 40005c08 <jffs2_prealloc_raw_node_refs>
40007788: 95 e8 20 01 restore %g0, 1, %o2
4000c600 <jffs2_rmdir>:
int jffs2_rmdir (struct _inode *dir_i, struct _inode *d_inode, const unsigned char *d_name, size_t d_namelen)
{
4000c600: 9d e3 bf a0 save %sp, -96, %sp
struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode);
struct jffs2_full_dirent *fd;
for (fd = f->dents ; fd; fd = fd->next) {
4000c604: c2 06 60 54 ld [ %i1 + 0x54 ], %g1
4000c608: 80 a0 60 00 cmp %g1, 0
4000c60c: 32 80 00 08 bne,a 4000c62c <jffs2_rmdir+0x2c>
4000c610: c4 00 60 0c ld [ %g1 + 0xc ], %g2
struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb);
4000c614: 10 80 00 0b b 4000c640 <jffs2_rmdir+0x40>
4000c618: fa 06 20 40 ld [ %i0 + 0x40 ], %i5
for (fd = f->dents ; fd; fd = fd->next) {
4000c61c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000c620: 22 80 00 08 be,a 4000c640 <jffs2_rmdir+0x40> <== NOT EXECUTED
4000c624: fa 06 20 40 ld [ %i0 + 0x40 ], %i5 <== NOT EXECUTED
if (fd->ino)
4000c628: c4 00 60 0c ld [ %g1 + 0xc ], %g2 <== NOT EXECUTED
4000c62c: 80 a0 a0 00 cmp %g2, 0
4000c630: 22 bf ff fb be,a 4000c61c <jffs2_rmdir+0x1c> <== NEVER TAKEN
4000c634: c2 00 60 04 ld [ %g1 + 4 ], %g1 <== NOT EXECUTED
return -ENOTEMPTY;
}
return jffs2_unlink(dir_i, d_inode, d_name, d_namelen);
}
4000c638: 81 c7 e0 08 ret
4000c63c: 91 e8 3f a6 restore %g0, -90, %o0
d_namelen, dead_f, get_seconds());
4000c640: 40 00 43 e9 call 4001d5e4 <time>
4000c644: 90 10 20 00 clr %o0
ret = jffs2_do_unlink(c, dir_f, (const char *)d_name,
4000c648: 98 06 60 48 add %i1, 0x48, %o4
d_namelen, dead_f, get_seconds());
4000c64c: 9a 10 00 09 mov %o1, %o5
ret = jffs2_do_unlink(c, dir_f, (const char *)d_name,
4000c650: 96 10 00 1b mov %i3, %o3
4000c654: 92 06 20 48 add %i0, 0x48, %o1
4000c658: 94 10 00 1a mov %i2, %o2
4000c65c: 7f ff fa 68 call 4000affc <jffs2_do_unlink>
4000c660: 90 10 00 1d mov %i5, %o0
if (dead_f->inocache)
4000c664: c2 06 60 5c ld [ %i1 + 0x5c ], %g1
4000c668: 80 a0 60 00 cmp %g1, 0
4000c66c: 02 80 00 04 be 4000c67c <jffs2_rmdir+0x7c> <== NEVER TAKEN
4000c670: b0 10 00 08 mov %o0, %i0
d_inode->i_nlink = dead_f->inocache->pino_nlink;
4000c674: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
4000c678: c2 36 60 0c sth %g1, [ %i1 + 0xc ]
4000c67c: 81 c7 e0 08 ret
4000c680: 81 e8 00 00 restore
4000e534 <jffs2_rotate_lists>:
static int count_list(struct list_head *l)
{
uint32_t count = 0;
struct list_head *tmp;
list_for_each(tmp, l) {
4000e534: c8 02 20 60 ld [ %o0 + 0x60 ], %g4
void jffs2_rotate_lists(struct jffs2_sb_info *c)
{
uint32_t x;
uint32_t rotateby;
x = count_list(&c->clean_list);
4000e538: 86 02 20 60 add %o0, 0x60, %g3
list_for_each(tmp, l) {
4000e53c: 80 a0 c0 04 cmp %g3, %g4
4000e540: 22 80 00 0c be,a 4000e570 <jffs2_rotate_lists+0x3c> <== ALWAYS TAKEN
4000e544: c8 02 20 68 ld [ %o0 + 0x68 ], %g4
4000e548: 82 10 00 04 mov %g4, %g1 <== NOT EXECUTED
uint32_t count = 0;
4000e54c: 84 10 20 00 clr %g2 <== NOT EXECUTED
list_for_each(tmp, l) {
4000e550: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
4000e554: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED
4000e558: 12 bf ff fe bne 4000e550 <jffs2_rotate_lists+0x1c> <== NOT EXECUTED
4000e55c: 84 00 a0 01 inc %g2 <== NOT EXECUTED
if (x) {
4000e560: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4000e564: 32 80 00 b0 bne,a 4000e824 <jffs2_rotate_lists+0x2f0> <== NOT EXECUTED
4000e568: c6 02 20 64 ld [ %o0 + 0x64 ], %g3 <== NOT EXECUTED
list_for_each(tmp, l) {
4000e56c: c8 02 20 68 ld [ %o0 + 0x68 ], %g4 <== NOT EXECUTED
rotateby = pseudo_random % x;
rotate_list((&c->clean_list), rotateby);
}
x = count_list(&c->very_dirty_list);
4000e570: 86 02 20 68 add %o0, 0x68, %g3
list_for_each(tmp, l) {
4000e574: 80 a0 c0 04 cmp %g3, %g4
4000e578: 22 80 00 0c be,a 4000e5a8 <jffs2_rotate_lists+0x74> <== ALWAYS TAKEN
4000e57c: c8 02 20 70 ld [ %o0 + 0x70 ], %g4
4000e580: 82 10 00 04 mov %g4, %g1 <== NOT EXECUTED
uint32_t count = 0;
4000e584: 84 10 20 00 clr %g2 <== NOT EXECUTED
list_for_each(tmp, l) {
4000e588: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
4000e58c: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED
4000e590: 12 bf ff fe bne 4000e588 <jffs2_rotate_lists+0x54> <== NOT EXECUTED
4000e594: 84 00 a0 01 inc %g2 <== NOT EXECUTED
if (x) {
4000e598: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4000e59c: 32 80 00 8a bne,a 4000e7c4 <jffs2_rotate_lists+0x290> <== NOT EXECUTED
4000e5a0: c6 02 20 6c ld [ %o0 + 0x6c ], %g3 <== NOT EXECUTED
list_for_each(tmp, l) {
4000e5a4: c8 02 20 70 ld [ %o0 + 0x70 ], %g4 <== NOT EXECUTED
rotateby = pseudo_random % x;
rotate_list((&c->very_dirty_list), rotateby);
}
x = count_list(&c->dirty_list);
4000e5a8: 86 02 20 70 add %o0, 0x70, %g3
list_for_each(tmp, l) {
4000e5ac: 80 a0 c0 04 cmp %g3, %g4
4000e5b0: 02 80 00 0a be 4000e5d8 <jffs2_rotate_lists+0xa4> <== ALWAYS TAKEN
4000e5b4: 82 10 00 04 mov %g4, %g1
uint32_t count = 0;
4000e5b8: 84 10 20 00 clr %g2 <== NOT EXECUTED
list_for_each(tmp, l) {
4000e5bc: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
4000e5c0: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED
4000e5c4: 12 bf ff fe bne 4000e5bc <jffs2_rotate_lists+0x88> <== NOT EXECUTED
4000e5c8: 84 00 a0 01 inc %g2 <== NOT EXECUTED
if (x) {
4000e5cc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4000e5d0: 32 80 00 65 bne,a 4000e764 <jffs2_rotate_lists+0x230> <== NOT EXECUTED
4000e5d4: c6 02 20 74 ld [ %o0 + 0x74 ], %g3 <== NOT EXECUTED
list_for_each(tmp, l) {
4000e5d8: c8 02 20 78 ld [ %o0 + 0x78 ], %g4
rotateby = pseudo_random % x;
rotate_list((&c->dirty_list), rotateby);
}
x = count_list(&c->erasable_list);
4000e5dc: 86 02 20 78 add %o0, 0x78, %g3
list_for_each(tmp, l) {
4000e5e0: 80 a0 c0 04 cmp %g3, %g4
4000e5e4: 02 80 00 0a be 4000e60c <jffs2_rotate_lists+0xd8> <== ALWAYS TAKEN
4000e5e8: 82 10 00 04 mov %g4, %g1
uint32_t count = 0;
4000e5ec: 84 10 20 00 clr %g2 <== NOT EXECUTED
list_for_each(tmp, l) {
4000e5f0: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
4000e5f4: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED
4000e5f8: 12 bf ff fe bne 4000e5f0 <jffs2_rotate_lists+0xbc> <== NOT EXECUTED
4000e5fc: 84 00 a0 01 inc %g2 <== NOT EXECUTED
if (x) {
4000e600: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4000e604: 32 80 00 40 bne,a 4000e704 <jffs2_rotate_lists+0x1d0> <== NOT EXECUTED
4000e608: c6 02 20 7c ld [ %o0 + 0x7c ], %g3 <== NOT EXECUTED
rotateby = pseudo_random % x;
rotate_list((&c->erasable_list), rotateby);
}
if (c->nr_erasing_blocks) {
4000e60c: c2 02 20 40 ld [ %o0 + 0x40 ], %g1
4000e610: 80 a0 60 00 cmp %g1, 0
4000e614: 32 80 00 22 bne,a 4000e69c <jffs2_rotate_lists+0x168> <== ALWAYS TAKEN
4000e618: c6 02 20 9c ld [ %o0 + 0x9c ], %g3
rotateby = pseudo_random % c->nr_erasing_blocks;
rotate_list((&c->erase_pending_list), rotateby);
}
if (c->nr_free_blocks) {
4000e61c: c2 02 20 3c ld [ %o0 + 0x3c ], %g1
4000e620: 80 a0 60 00 cmp %g1, 0
4000e624: 32 80 00 04 bne,a 4000e634 <jffs2_rotate_lists+0x100> <== NEVER TAKEN
4000e628: c6 02 20 ac ld [ %o0 + 0xac ], %g3 <== NOT EXECUTED
rotateby = pseudo_random % c->nr_free_blocks;
rotate_list((&c->free_list), rotateby);
}
}
4000e62c: 81 c3 e0 08 retl
4000e630: 01 00 00 00 nop
struct list_head *n = head->next;
4000e634: c4 02 20 a8 ld [ %o0 + 0xa8 ], %g2 <== NOT EXECUTED
ent->prev->next = ent->next;
4000e638: c4 20 c0 00 st %g2, [ %g3 ] <== NOT EXECUTED
rotate_list((&c->free_list), rotateby);
4000e63c: 9a 02 20 a8 add %o0, 0xa8, %o5 <== NOT EXECUTED
ent->next->prev = ent->prev;
4000e640: c6 20 a0 04 st %g3, [ %g2 + 4 ] <== NOT EXECUTED
rotateby = pseudo_random % c->nr_free_blocks;
4000e644: 07 10 01 1c sethi %hi(0x40047000), %g3 <== NOT EXECUTED
4000e648: c6 00 e3 9c ld [ %g3 + 0x39c ], %g3 ! 4004739c <pseudo_random> <== NOT EXECUTED
4000e64c: 81 80 20 00 wr %g0, %y <== NOT EXECUTED
4000e650: 01 00 00 00 nop <== NOT EXECUTED
4000e654: 01 00 00 00 nop <== NOT EXECUTED
4000e658: 01 00 00 00 nop <== NOT EXECUTED
4000e65c: 88 70 c0 01 udiv %g3, %g1, %g4 <== NOT EXECUTED
4000e660: 82 59 00 01 smul %g4, %g1, %g1 <== NOT EXECUTED
4000e664: 86 20 c0 01 sub %g3, %g1, %g3 <== NOT EXECUTED
while(count--) {
4000e668: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
4000e66c: 02 80 00 06 be 4000e684 <jffs2_rotate_lists+0x150> <== NOT EXECUTED
4000e670: 82 00 ff ff add %g3, -1, %g1 <== NOT EXECUTED
4000e674: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
4000e678: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
4000e67c: 12 bf ff fe bne 4000e674 <jffs2_rotate_lists+0x140> <== NOT EXECUTED
4000e680: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED
struct list_head *next = afterthisent->next;
4000e684: c2 00 80 00 ld [ %g2 ], %g1 <== NOT EXECUTED
newent->next = next;
4000e688: c2 22 20 a8 st %g1, [ %o0 + 0xa8 ] <== NOT EXECUTED
newent->prev = afterthisent;
4000e68c: c4 22 20 ac st %g2, [ %o0 + 0xac ] <== NOT EXECUTED
afterthisent->next = newent;
4000e690: da 20 80 00 st %o5, [ %g2 ] <== NOT EXECUTED
}
4000e694: 81 c3 e0 08 retl <== NOT EXECUTED
4000e698: da 20 60 04 st %o5, [ %g1 + 4 ] <== NOT EXECUTED
struct list_head *n = head->next;
4000e69c: c4 02 20 98 ld [ %o0 + 0x98 ], %g2
ent->prev->next = ent->next;
4000e6a0: c4 20 c0 00 st %g2, [ %g3 ]
rotate_list((&c->erase_pending_list), rotateby);
4000e6a4: 9a 02 20 98 add %o0, 0x98, %o5
ent->next->prev = ent->prev;
4000e6a8: c6 20 a0 04 st %g3, [ %g2 + 4 ]
rotateby = pseudo_random % c->nr_erasing_blocks;
4000e6ac: 07 10 01 1c sethi %hi(0x40047000), %g3
4000e6b0: c6 00 e3 9c ld [ %g3 + 0x39c ], %g3 ! 4004739c <pseudo_random>
4000e6b4: 81 80 20 00 wr %g0, %y
4000e6b8: 01 00 00 00 nop
4000e6bc: 01 00 00 00 nop
4000e6c0: 01 00 00 00 nop
4000e6c4: 88 70 c0 01 udiv %g3, %g1, %g4
4000e6c8: 82 59 00 01 smul %g4, %g1, %g1
4000e6cc: 86 20 c0 01 sub %g3, %g1, %g3
while(count--) {
4000e6d0: 80 a0 e0 00 cmp %g3, 0
4000e6d4: 02 80 00 06 be 4000e6ec <jffs2_rotate_lists+0x1b8> <== ALWAYS TAKEN
4000e6d8: 82 00 ff ff add %g3, -1, %g1
4000e6dc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
4000e6e0: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
4000e6e4: 12 bf ff fe bne 4000e6dc <jffs2_rotate_lists+0x1a8> <== NOT EXECUTED
4000e6e8: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED
struct list_head *next = afterthisent->next;
4000e6ec: c2 00 80 00 ld [ %g2 ], %g1
newent->next = next;
4000e6f0: c2 22 20 98 st %g1, [ %o0 + 0x98 ]
newent->prev = afterthisent;
4000e6f4: c4 22 20 9c st %g2, [ %o0 + 0x9c ]
afterthisent->next = newent;
4000e6f8: da 20 80 00 st %o5, [ %g2 ]
}
4000e6fc: 10 bf ff c8 b 4000e61c <jffs2_rotate_lists+0xe8>
4000e700: da 20 60 04 st %o5, [ %g1 + 4 ]
ent->prev->next = ent->next;
4000e704: c8 20 c0 00 st %g4, [ %g3 ] <== NOT EXECUTED
ent->next->prev = ent->prev;
4000e708: c6 21 20 04 st %g3, [ %g4 + 4 ] <== NOT EXECUTED
rotateby = pseudo_random % x;
4000e70c: 07 10 01 1c sethi %hi(0x40047000), %g3 <== NOT EXECUTED
4000e710: c6 00 e3 9c ld [ %g3 + 0x39c ], %g3 ! 4004739c <pseudo_random> <== NOT EXECUTED
4000e714: 81 80 20 00 wr %g0, %y <== NOT EXECUTED
4000e718: 01 00 00 00 nop <== NOT EXECUTED
4000e71c: 01 00 00 00 nop <== NOT EXECUTED
4000e720: 01 00 00 00 nop <== NOT EXECUTED
4000e724: 9a 70 c0 02 udiv %g3, %g2, %o5 <== NOT EXECUTED
4000e728: 84 5b 40 02 smul %o5, %g2, %g2 <== NOT EXECUTED
4000e72c: 86 20 c0 02 sub %g3, %g2, %g3 <== NOT EXECUTED
while(count--) {
4000e730: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
4000e734: 02 80 00 06 be 4000e74c <jffs2_rotate_lists+0x218> <== NOT EXECUTED
4000e738: 84 00 ff ff add %g3, -1, %g2 <== NOT EXECUTED
4000e73c: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
4000e740: 80 a0 bf ff cmp %g2, -1 <== NOT EXECUTED
4000e744: 12 bf ff fe bne 4000e73c <jffs2_rotate_lists+0x208> <== NOT EXECUTED
4000e748: c8 01 00 00 ld [ %g4 ], %g4 <== NOT EXECUTED
struct list_head *next = afterthisent->next;
4000e74c: c4 01 00 00 ld [ %g4 ], %g2 <== NOT EXECUTED
newent->next = next;
4000e750: c4 22 20 78 st %g2, [ %o0 + 0x78 ] <== NOT EXECUTED
newent->prev = afterthisent;
4000e754: c8 22 20 7c st %g4, [ %o0 + 0x7c ] <== NOT EXECUTED
afterthisent->next = newent;
4000e758: c2 21 00 00 st %g1, [ %g4 ] <== NOT EXECUTED
}
4000e75c: 10 bf ff ac b 4000e60c <jffs2_rotate_lists+0xd8> <== NOT EXECUTED
4000e760: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
ent->prev->next = ent->next;
4000e764: c8 20 c0 00 st %g4, [ %g3 ] <== NOT EXECUTED
ent->next->prev = ent->prev;
4000e768: c6 21 20 04 st %g3, [ %g4 + 4 ] <== NOT EXECUTED
rotateby = pseudo_random % x;
4000e76c: 07 10 01 1c sethi %hi(0x40047000), %g3 <== NOT EXECUTED
4000e770: c6 00 e3 9c ld [ %g3 + 0x39c ], %g3 ! 4004739c <pseudo_random> <== NOT EXECUTED
4000e774: 81 80 20 00 wr %g0, %y <== NOT EXECUTED
4000e778: 01 00 00 00 nop <== NOT EXECUTED
4000e77c: 01 00 00 00 nop <== NOT EXECUTED
4000e780: 01 00 00 00 nop <== NOT EXECUTED
4000e784: 9a 70 c0 02 udiv %g3, %g2, %o5 <== NOT EXECUTED
4000e788: 84 5b 40 02 smul %o5, %g2, %g2 <== NOT EXECUTED
4000e78c: 86 20 c0 02 sub %g3, %g2, %g3 <== NOT EXECUTED
while(count--) {
4000e790: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
4000e794: 02 80 00 06 be 4000e7ac <jffs2_rotate_lists+0x278> <== NOT EXECUTED
4000e798: 84 00 ff ff add %g3, -1, %g2 <== NOT EXECUTED
4000e79c: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
4000e7a0: 80 a0 bf ff cmp %g2, -1 <== NOT EXECUTED
4000e7a4: 12 bf ff fe bne 4000e79c <jffs2_rotate_lists+0x268> <== NOT EXECUTED
4000e7a8: c8 01 00 00 ld [ %g4 ], %g4 <== NOT EXECUTED
struct list_head *next = afterthisent->next;
4000e7ac: c4 01 00 00 ld [ %g4 ], %g2 <== NOT EXECUTED
newent->next = next;
4000e7b0: c4 22 20 70 st %g2, [ %o0 + 0x70 ] <== NOT EXECUTED
newent->prev = afterthisent;
4000e7b4: c8 22 20 74 st %g4, [ %o0 + 0x74 ] <== NOT EXECUTED
afterthisent->next = newent;
4000e7b8: c2 21 00 00 st %g1, [ %g4 ] <== NOT EXECUTED
}
4000e7bc: 10 bf ff 87 b 4000e5d8 <jffs2_rotate_lists+0xa4> <== NOT EXECUTED
4000e7c0: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
ent->prev->next = ent->next;
4000e7c4: c8 20 c0 00 st %g4, [ %g3 ] <== NOT EXECUTED
ent->next->prev = ent->prev;
4000e7c8: c6 21 20 04 st %g3, [ %g4 + 4 ] <== NOT EXECUTED
rotateby = pseudo_random % x;
4000e7cc: 07 10 01 1c sethi %hi(0x40047000), %g3 <== NOT EXECUTED
4000e7d0: c6 00 e3 9c ld [ %g3 + 0x39c ], %g3 ! 4004739c <pseudo_random> <== NOT EXECUTED
4000e7d4: 81 80 20 00 wr %g0, %y <== NOT EXECUTED
4000e7d8: 01 00 00 00 nop <== NOT EXECUTED
4000e7dc: 01 00 00 00 nop <== NOT EXECUTED
4000e7e0: 01 00 00 00 nop <== NOT EXECUTED
4000e7e4: 9a 70 c0 02 udiv %g3, %g2, %o5 <== NOT EXECUTED
4000e7e8: 84 5b 40 02 smul %o5, %g2, %g2 <== NOT EXECUTED
4000e7ec: 86 20 c0 02 sub %g3, %g2, %g3 <== NOT EXECUTED
while(count--) {
4000e7f0: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
4000e7f4: 02 80 00 06 be 4000e80c <jffs2_rotate_lists+0x2d8> <== NOT EXECUTED
4000e7f8: 84 00 ff ff add %g3, -1, %g2 <== NOT EXECUTED
4000e7fc: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
4000e800: 80 a0 bf ff cmp %g2, -1 <== NOT EXECUTED
4000e804: 12 bf ff fe bne 4000e7fc <jffs2_rotate_lists+0x2c8> <== NOT EXECUTED
4000e808: c8 01 00 00 ld [ %g4 ], %g4 <== NOT EXECUTED
struct list_head *next = afterthisent->next;
4000e80c: c4 01 00 00 ld [ %g4 ], %g2 <== NOT EXECUTED
newent->next = next;
4000e810: c4 22 20 68 st %g2, [ %o0 + 0x68 ] <== NOT EXECUTED
newent->prev = afterthisent;
4000e814: c8 22 20 6c st %g4, [ %o0 + 0x6c ] <== NOT EXECUTED
afterthisent->next = newent;
4000e818: c2 21 00 00 st %g1, [ %g4 ] <== NOT EXECUTED
}
4000e81c: 10 bf ff 62 b 4000e5a4 <jffs2_rotate_lists+0x70> <== NOT EXECUTED
4000e820: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
ent->prev->next = ent->next;
4000e824: c8 20 c0 00 st %g4, [ %g3 ] <== NOT EXECUTED
ent->next->prev = ent->prev;
4000e828: c6 21 20 04 st %g3, [ %g4 + 4 ] <== NOT EXECUTED
rotateby = pseudo_random % x;
4000e82c: 07 10 01 1c sethi %hi(0x40047000), %g3 <== NOT EXECUTED
4000e830: c6 00 e3 9c ld [ %g3 + 0x39c ], %g3 ! 4004739c <pseudo_random> <== NOT EXECUTED
4000e834: 81 80 20 00 wr %g0, %y <== NOT EXECUTED
4000e838: 01 00 00 00 nop <== NOT EXECUTED
4000e83c: 01 00 00 00 nop <== NOT EXECUTED
4000e840: 01 00 00 00 nop <== NOT EXECUTED
4000e844: 9a 70 c0 02 udiv %g3, %g2, %o5 <== NOT EXECUTED
4000e848: 84 5b 40 02 smul %o5, %g2, %g2 <== NOT EXECUTED
4000e84c: 86 20 c0 02 sub %g3, %g2, %g3 <== NOT EXECUTED
while(count--) {
4000e850: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
4000e854: 02 80 00 06 be 4000e86c <jffs2_rotate_lists+0x338> <== NOT EXECUTED
4000e858: 84 00 ff ff add %g3, -1, %g2 <== NOT EXECUTED
4000e85c: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
4000e860: 80 a0 bf ff cmp %g2, -1 <== NOT EXECUTED
4000e864: 12 bf ff fe bne 4000e85c <jffs2_rotate_lists+0x328> <== NOT EXECUTED
4000e868: c8 01 00 00 ld [ %g4 ], %g4 <== NOT EXECUTED
struct list_head *next = afterthisent->next;
4000e86c: c4 01 00 00 ld [ %g4 ], %g2 <== NOT EXECUTED
newent->next = next;
4000e870: c4 22 20 60 st %g2, [ %o0 + 0x60 ] <== NOT EXECUTED
newent->prev = afterthisent;
4000e874: c8 22 20 64 st %g4, [ %o0 + 0x64 ] <== NOT EXECUTED
afterthisent->next = newent;
4000e878: c2 21 00 00 st %g1, [ %g4 ] <== NOT EXECUTED
}
4000e87c: 10 bf ff 3c b 4000e56c <jffs2_rotate_lists+0x38> <== NOT EXECUTED
4000e880: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
4000d1b0 <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
4000d1b0: c4 02 60 14 ld [ %o1 + 0x14 ], %g2 <== NOT EXECUTED
4000d1b4: c8 02 60 10 ld [ %o1 + 0x10 ], %g4 <== NOT EXECUTED
4000d1b8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 <== NOT EXECUTED
4000d1bc: 86 00 80 04 add %g2, %g4, %g3 <== NOT EXECUTED
4000d1c0: 82 00 60 03 add %g1, 3, %g1 <== NOT EXECUTED
4000d1c4: 82 08 7f fc and %g1, -4, %g1 <== NOT EXECUTED
4000d1c8: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED
4000d1cc: 22 80 00 0c be,a 4000d1fc <jffs2_scan_classify_jeb+0x4c> <== NOT EXECUTED
4000d1d0: c2 02 60 18 ld [ %o1 + 0x18 ], %g1 <== 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))) {
4000d1d4: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 <== NOT EXECUTED
4000d1d8: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED
4000d1dc: 80 a0 60 c4 cmp %g1, 0xc4 <== NOT EXECUTED
4000d1e0: 08 80 00 17 bleu 4000d23c <jffs2_scan_classify_jeb+0x8c> <== NOT EXECUTED
4000d1e4: 84 10 80 04 or %g2, %g4, %g2 <== 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;
4000d1e8: 80 a0 00 02 cmp %g0, %g2 <== NOT EXECUTED
4000d1ec: 90 60 20 00 subx %g0, 0, %o0 <== NOT EXECUTED
4000d1f0: 90 0a 3f fe and %o0, -2, %o0 <== NOT EXECUTED
4000d1f4: 81 c3 e0 08 retl <== NOT EXECUTED
4000d1f8: 90 02 20 04 add %o0, 4, %o0 <== NOT EXECUTED
if ((jeb->used_size + jeb->unchecked_size) == PAD(c->cleanmarker_size) && !jeb->dirty_size
4000d1fc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000d200: 32 bf ff f6 bne,a 4000d1d8 <jffs2_scan_classify_jeb+0x28> <== NOT EXECUTED
4000d204: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 <== NOT EXECUTED
&& (!jeb->first_node || !ref_next(jeb->first_node)) )
4000d208: c2 02 60 28 ld [ %o1 + 0x28 ], %g1 <== NOT EXECUTED
4000d20c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000d210: 02 80 00 09 be 4000d234 <jffs2_scan_classify_jeb+0x84> <== NOT EXECUTED
4000d214: 01 00 00 00 nop <== NOT EXECUTED
if (ref->flash_offset == REF_LINK_NODE) {
4000d218: da 00 60 0c ld [ %g1 + 0xc ], %o5 <== NOT EXECUTED
4000d21c: 80 a3 7f ff cmp %o5, -1 <== NOT EXECUTED
4000d220: 22 80 00 14 be,a 4000d270 <jffs2_scan_classify_jeb+0xc0> <== NOT EXECUTED
4000d224: c2 00 60 08 ld [ %g1 + 8 ], %g1 <== NOT EXECUTED
if (ref->flash_offset == REF_EMPTY_NODE)
4000d228: 80 a3 7f fe cmp %o5, -2 <== NOT EXECUTED
4000d22c: 32 bf ff eb bne,a 4000d1d8 <jffs2_scan_classify_jeb+0x28> <== NOT EXECUTED
4000d230: c2 02 20 34 ld [ %o0 + 0x34 ], %g1 <== NOT EXECUTED
}
4000d234: 81 c3 e0 08 retl <== NOT EXECUTED
4000d238: 90 10 20 03 mov 3, %o0 <== NOT EXECUTED
c->dirty_size -= jeb->dirty_size;
4000d23c: c6 02 60 18 ld [ %o1 + 0x18 ], %g3 <== NOT EXECUTED
4000d240: c8 02 20 20 ld [ %o0 + 0x20 ], %g4 <== NOT EXECUTED
c->wasted_size += jeb->dirty_size;
4000d244: c4 02 20 24 ld [ %o0 + 0x24 ], %g2 <== NOT EXECUTED
jeb->wasted_size += jeb->dirty_size;
4000d248: c2 02 60 1c ld [ %o1 + 0x1c ], %g1 <== NOT EXECUTED
c->dirty_size -= jeb->dirty_size;
4000d24c: 88 21 00 03 sub %g4, %g3, %g4 <== NOT EXECUTED
c->wasted_size += jeb->dirty_size;
4000d250: 84 00 80 03 add %g2, %g3, %g2 <== NOT EXECUTED
c->dirty_size -= jeb->dirty_size;
4000d254: c8 22 20 20 st %g4, [ %o0 + 0x20 ] <== NOT EXECUTED
jeb->wasted_size += jeb->dirty_size;
4000d258: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
c->wasted_size += jeb->dirty_size;
4000d25c: c4 22 20 24 st %g2, [ %o0 + 0x24 ] <== NOT EXECUTED
return BLK_STATE_CLEAN;
4000d260: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
jeb->wasted_size += jeb->dirty_size;
4000d264: c2 22 60 1c st %g1, [ %o1 + 0x1c ] <== NOT EXECUTED
return BLK_STATE_CLEAN;
4000d268: 81 c3 e0 08 retl <== NOT EXECUTED
4000d26c: c0 22 60 18 clr [ %o1 + 0x18 ] <== NOT EXECUTED
if (!ref)
4000d270: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000d274: 02 bf ff f0 be 4000d234 <jffs2_scan_classify_jeb+0x84> <== NOT EXECUTED
4000d278: 01 00 00 00 nop <== NOT EXECUTED
if (ref->flash_offset == REF_EMPTY_NODE)
4000d27c: 10 bf ff eb b 4000d228 <jffs2_scan_classify_jeb+0x78> <== NOT EXECUTED
4000d280: da 00 60 04 ld [ %g1 + 4 ], %o5 <== NOT EXECUTED
40006b80 <jffs2_scan_dirty_space>:
{
40006b80: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if (!size)
40006b84: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
40006b88: 02 80 00 19 be 40006bec <jffs2_scan_dirty_space+0x6c> <== NOT EXECUTED
40006b8c: 01 00 00 00 nop <== NOT EXECUTED
if (unlikely(size > jeb->free_size)) {
40006b90: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
40006b94: 80 a0 40 1a cmp %g1, %i2 <== NOT EXECUTED
40006b98: 2a 80 00 23 bcs,a 40006c24 <jffs2_scan_dirty_space+0xa4> <== NOT EXECUTED
40006b9c: d6 06 60 1c ld [ %i1 + 0x1c ], %o3 <== NOT EXECUTED
if (jeb->last_node && ref_obsolete(jeb->last_node)) {
40006ba0: c4 06 60 2c ld [ %i1 + 0x2c ], %g2 <== NOT EXECUTED
40006ba4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
40006ba8: 22 80 00 08 be,a 40006bc8 <jffs2_scan_dirty_space+0x48> <== NOT EXECUTED
40006bac: d4 06 60 0c ld [ %i1 + 0xc ], %o2 <== NOT EXECUTED
40006bb0: c4 00 a0 04 ld [ %g2 + 4 ], %g2 <== NOT EXECUTED
40006bb4: 84 08 a0 03 and %g2, 3, %g2 <== NOT EXECUTED
40006bb8: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED
40006bbc: 22 80 00 0e be,a 40006bf4 <jffs2_scan_dirty_space+0x74> <== NOT EXECUTED
40006bc0: c8 06 20 20 ld [ %i0 + 0x20 ], %g4 <== NOT EXECUTED
uint32_t ofs = jeb->offset + c->sector_size - jeb->free_size;
40006bc4: d4 06 60 0c ld [ %i1 + 0xc ], %o2 <== NOT EXECUTED
40006bc8: c4 06 20 34 ld [ %i0 + 0x34 ], %g2 <== NOT EXECUTED
40006bcc: 94 02 80 02 add %o2, %g2, %o2 <== NOT EXECUTED
jffs2_link_node_ref(c, jeb, ofs, size, NULL);
40006bd0: 98 10 20 00 clr %o4 <== NOT EXECUTED
uint32_t ofs = jeb->offset + c->sector_size - jeb->free_size;
40006bd4: 94 22 80 01 sub %o2, %g1, %o2 <== NOT EXECUTED
jffs2_link_node_ref(c, jeb, ofs, size, NULL);
40006bd8: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
40006bdc: 94 12 a0 01 or %o2, 1, %o2 <== NOT EXECUTED
40006be0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
40006be4: 7f ff ff 5a call 4000694c <jffs2_link_node_ref> <== NOT EXECUTED
40006be8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
40006bec: 81 c7 e0 08 ret <== NOT EXECUTED
40006bf0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
c->free_size -= size;
40006bf4: c6 06 20 28 ld [ %i0 + 0x28 ], %g3 <== NOT EXECUTED
jeb->dirty_size += size;
40006bf8: c4 06 60 18 ld [ %i1 + 0x18 ], %g2 <== NOT EXECUTED
c->dirty_size += size;
40006bfc: 88 01 00 1a add %g4, %i2, %g4 <== NOT EXECUTED
c->free_size -= size;
40006c00: 86 20 c0 1a sub %g3, %i2, %g3 <== NOT EXECUTED
c->dirty_size += size;
40006c04: c8 26 20 20 st %g4, [ %i0 + 0x20 ] <== NOT EXECUTED
jeb->dirty_size += size;
40006c08: 84 00 80 1a add %g2, %i2, %g2 <== NOT EXECUTED
c->free_size -= size;
40006c0c: c6 26 20 28 st %g3, [ %i0 + 0x28 ] <== NOT EXECUTED
jeb->free_size -= size;
40006c10: 94 20 40 1a sub %g1, %i2, %o2 <== NOT EXECUTED
jeb->dirty_size += size;
40006c14: c4 26 60 18 st %g2, [ %i1 + 0x18 ] <== NOT EXECUTED
jeb->free_size -= size;
40006c18: d4 26 60 20 st %o2, [ %i1 + 0x20 ] <== NOT EXECUTED
}
40006c1c: 81 c7 e0 08 ret <== NOT EXECUTED
40006c20: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
pr_crit("Dirty space 0x%x larger then free_size 0x%x (wasted 0x%x)\n",
40006c24: 94 10 00 01 mov %g1, %o2 <== NOT EXECUTED
40006c28: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
40006c2c: 11 10 00 7b sethi %hi(0x4001ec00), %o0 <== NOT EXECUTED
40006c30: 7f ff fc 4f call 40005d6c <jffs2_printk> <== NOT EXECUTED
40006c34: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 4001eee8 <__func__.4+0x138> <== NOT EXECUTED
BUG();
40006c38: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
40006c3c: 15 10 00 7b sethi %hi(0x4001ec00), %o2 <== NOT EXECUTED
40006c40: 11 10 00 7b sethi %hi(0x4001ec00), %o0 <== NOT EXECUTED
40006c44: 92 10 22 a0 mov 0x2a0, %o1 <== NOT EXECUTED
40006c48: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
40006c4c: 94 12 a3 80 or %o2, 0x380, %o2 <== NOT EXECUTED
40006c50: 40 00 1f 4a call 4000e978 <__assert_func> <== NOT EXECUTED
40006c54: 90 12 22 08 or %o0, 0x208, %o0 <== NOT EXECUTED
40006c58: 01 00 00 00 nop <== NOT EXECUTED
4000d284 <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)
{
4000d284: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
struct jffs2_inode_cache *ic;
ic = jffs2_get_ino_cache(c, ino);
4000d288: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000d28c: 7f ff e4 c3 call 40006598 <jffs2_get_ino_cache> <== NOT EXECUTED
4000d290: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (ic)
4000d294: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4000d298: 22 80 00 04 be,a 4000d2a8 <jffs2_scan_make_ino_cache+0x24> <== NOT EXECUTED
4000d29c: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED
ic->nodes = (void *)ic;
jffs2_add_ino_cache(c, ic);
if (ino == 1)
ic->pino_nlink = 1;
return ic;
}
4000d2a0: 81 c7 e0 08 ret <== NOT EXECUTED
4000d2a4: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
if (ino > c->highest_ino)
4000d2a8: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
4000d2ac: 38 80 00 02 bgu,a 4000d2b4 <jffs2_scan_make_ino_cache+0x30> <== NOT EXECUTED
4000d2b0: f2 26 20 04 st %i1, [ %i0 + 4 ] <== NOT EXECUTED
ic = jffs2_alloc_inode_cache();
4000d2b4: 7f ff e2 91 call 40005cf8 <jffs2_alloc_inode_cache> <== NOT EXECUTED
4000d2b8: 01 00 00 00 nop <== NOT EXECUTED
if (!ic) {
4000d2bc: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
4000d2c0: 02 80 00 0f be 4000d2fc <jffs2_scan_make_ino_cache+0x78> <== NOT EXECUTED
4000d2c4: 94 10 20 18 mov 0x18, %o2 <== NOT EXECUTED
memset(ic, 0, sizeof(*ic));
4000d2c8: 40 00 3f 57 call 4001d024 <memset> <== NOT EXECUTED
4000d2cc: 92 10 20 00 clr %o1 <== NOT EXECUTED
ic->ino = ino;
4000d2d0: f2 27 60 0c st %i1, [ %i5 + 0xc ] <== NOT EXECUTED
jffs2_add_ino_cache(c, ic);
4000d2d4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
ic->nodes = (void *)ic;
4000d2d8: fa 27 60 04 st %i5, [ %i5 + 4 ] <== NOT EXECUTED
jffs2_add_ino_cache(c, ic);
4000d2dc: 7f ff e4 cd call 40006610 <jffs2_add_ino_cache> <== NOT EXECUTED
4000d2e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (ino == 1)
4000d2e4: 80 a6 60 01 cmp %i1, 1 <== NOT EXECUTED
4000d2e8: 12 bf ff ee bne 4000d2a0 <jffs2_scan_make_ino_cache+0x1c> <== NOT EXECUTED
4000d2ec: 01 00 00 00 nop <== NOT EXECUTED
ic->pino_nlink = 1;
4000d2f0: f2 27 60 14 st %i1, [ %i5 + 0x14 ] <== NOT EXECUTED
}
4000d2f4: 81 c7 e0 08 ret <== NOT EXECUTED
4000d2f8: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
pr_notice("%s(): allocation of inode cache failed\n", __func__);
4000d2fc: 13 10 00 84 sethi %hi(0x40021000), %o1 <== NOT EXECUTED
4000d300: 11 10 00 83 sethi %hi(0x40020c00), %o0 <== NOT EXECUTED
4000d304: 92 12 63 b0 or %o1, 0x3b0, %o1 <== NOT EXECUTED
4000d308: 7f ff ff 6f call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000d30c: 90 12 20 f8 or %o0, 0xf8, %o0 <== NOT EXECUTED
return NULL;
4000d310: 30 bf ff e4 b,a 4000d2a0 <jffs2_scan_make_ino_cache+0x1c> <== NOT EXECUTED
4000d32c <jffs2_scan_medium>:
{
4000d32c: 9d e3 bf 68 save %sp, -152, %sp
flashbuf = mtd_kmalloc_up_to(c->mtd, &try_size);
4000d330: 11 00 00 04 sethi %hi(0x1000), %o0
4000d334: 40 00 07 64 call 4000f0c4 <malloc>
4000d338: b8 10 00 18 mov %i0, %i4
if (!flashbuf)
4000d33c: b4 92 20 00 orcc %o0, 0, %i2
4000d340: 02 80 01 94 be 4000d990 <jffs2_scan_medium+0x664> <== NEVER TAKEN
4000d344: 84 10 3f f4 mov -12, %g2
for (i=0; i<c->nr_blocks; i++) {
4000d348: ee 06 20 50 ld [ %i0 + 0x50 ], %l7
4000d34c: 80 a5 e0 00 cmp %l7, 0
4000d350: 22 80 03 50 be,a 4000e090 <jffs2_scan_medium+0xd64> <== NEVER TAKEN
4000d354: c0 27 bf ec clr [ %fp + -20 ] <== NOT EXECUTED
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",
4000d358: 03 10 00 84 sethi %hi(0x40021000), %g1
4000d35c: 82 10 63 d0 or %g1, 0x3d0, %g1 ! 400213d0 <__func__.1>
4000d360: c2 27 bf e0 st %g1, [ %fp + -32 ]
4000d364: 03 10 00 84 sethi %hi(0x40021000), %g1
4000d368: 82 10 61 30 or %g1, 0x130, %g1 ! 40021130 <__func__.0+0x460>
uint32_t empty_blocks = 0, bad_blocks = 0;
4000d36c: ae 10 20 00 clr %l7
pr_notice("%s(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
4000d370: c2 27 bf dc st %g1, [ %fp + -36 ]
pr_err("Dirent at %08x has zeroes in name. Truncating to %d chars\n",
4000d374: 03 10 00 84 sethi %hi(0x40021000), %g1
uint32_t empty_blocks = 0, bad_blocks = 0;
4000d378: c0 27 bf ec clr [ %fp + -20 ]
pr_err("Dirent at %08x has zeroes in name. Truncating to %d chars\n",
4000d37c: 82 10 60 e8 or %g1, 0xe8, %g1
4000d380: ee 27 bf e8 st %l7, [ %fp + -24 ]
4000d384: 29 10 00 34 sethi %hi(0x4000d000), %l4
4000d388: c2 27 bf d8 st %g1, [ %fp + -40 ]
for (i=0; i<c->nr_blocks; i++) {
4000d38c: a2 10 20 00 clr %l1
4000d390: a4 10 20 00 clr %l2
4000d394: a8 15 23 14 or %l4, 0x314, %l4
struct jffs2_eraseblock *jeb = &c->blocks[i];
4000d398: f6 07 20 54 ld [ %i4 + 0x54 ], %i3
buf_len = EMPTY_SCAN_SIZE(c->sector_size);
4000d39c: f2 07 20 34 ld [ %i4 + 0x34 ], %i1
struct jffs2_eraseblock *jeb = &c->blocks[i];
4000d3a0: b6 06 c0 11 add %i3, %l1, %i3
if (sector_size < DEFAULT_EMPTY_SCAN_SIZE)
4000d3a4: 80 a6 60 ff cmp %i1, 0xff
4000d3a8: 08 80 00 03 bleu 4000d3b4 <jffs2_scan_medium+0x88> <== NEVER TAKEN
4000d3ac: f0 06 e0 0c ld [ %i3 + 0xc ], %i0
return DEFAULT_EMPTY_SCAN_SIZE;
4000d3b0: b2 10 21 00 mov 0x100, %i1
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
4000d3b4: 98 10 00 1a mov %i2, %o4
4000d3b8: 96 07 bf f4 add %fp, -12, %o3
4000d3bc: 94 10 00 19 mov %i1, %o2
4000d3c0: 92 10 00 18 mov %i0, %o1
4000d3c4: 7f ff fe 9f call 4000ce40 <jffs2_flash_read>
4000d3c8: 90 10 00 1c mov %i4, %o0
if (ret) {
4000d3cc: 80 a2 20 00 cmp %o0, 0
4000d3d0: 12 80 00 69 bne 4000d574 <jffs2_scan_medium+0x248> <== NEVER TAKEN
4000d3d4: c2 07 bf f4 ld [ %fp + -12 ], %g1
if (retlen < len) {
4000d3d8: 80 a6 40 01 cmp %i1, %g1
4000d3dc: 38 80 01 69 bgu,a 4000d980 <jffs2_scan_medium+0x654> <== NEVER TAKEN
4000d3e0: 84 10 3f fb mov -5, %g2 <== NOT EXECUTED
max_ofs = EMPTY_SCAN_SIZE(c->sector_size);
4000d3e4: c6 07 20 34 ld [ %i4 + 0x34 ], %g3
if (sector_size < DEFAULT_EMPTY_SCAN_SIZE)
4000d3e8: 80 a0 e0 ff cmp %g3, 0xff
4000d3ec: 18 80 00 05 bgu 4000d400 <jffs2_scan_medium+0xd4> <== ALWAYS TAKEN
4000d3f0: 84 10 21 00 mov 0x100, %g2
while(ofs < max_ofs && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF)
4000d3f4: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
4000d3f8: 02 80 00 9a be 4000d660 <jffs2_scan_medium+0x334> <== NOT EXECUTED
4000d3fc: 84 10 00 03 mov %g3, %g2 <== NOT EXECUTED
ofs = 0;
4000d400: 10 80 00 05 b 4000d414 <jffs2_scan_medium+0xe8>
4000d404: ba 10 20 00 clr %i5
while(ofs < max_ofs && *(uint32_t *)(&buf[ofs]) == 0xFFFFFFFF)
4000d408: 80 a7 40 02 cmp %i5, %g2
4000d40c: 1a 80 00 93 bcc 4000d658 <jffs2_scan_medium+0x32c>
4000d410: 01 00 00 00 nop
4000d414: c2 06 80 1d ld [ %i2 + %i5 ], %g1
4000d418: 80 a0 7f ff cmp %g1, -1
4000d41c: 22 bf ff fb be,a 4000d408 <jffs2_scan_medium+0xdc> <== ALWAYS TAKEN
4000d420: ba 07 60 04 add %i5, 4, %i5
if (ofs) {
4000d424: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
4000d428: 12 80 01 32 bne 4000d8f0 <jffs2_scan_medium+0x5c4> <== NOT EXECUTED
4000d42c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
switch(je16_to_cpu(node->nodetype)) {
4000d430: 2b 00 00 38 sethi %hi(0xe000), %l5 <== NOT EXECUTED
4000d434: 84 15 60 01 or %l5, 1, %g2 ! e001 <_ISR_Stack_size+0xd001> <== NOT EXECUTED
4000d438: c4 27 bf e4 st %g2, [ %fp + -28 ] <== NOT EXECUTED
prevofs = jeb->offset - 1;
4000d43c: a0 06 3f ff add %i0, -1, %l0 <== NOT EXECUTED
ofs += jeb->offset;
4000d440: c2 06 e0 0c ld [ %i3 + 0xc ], %g1 <== NOT EXECUTED
4000d444: ba 00 40 1d add %g1, %i5, %i5 <== NOT EXECUTED
noise = 10;
4000d448: a6 10 20 0a mov 0xa, %l3 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000d44c: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
4000d450: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
4000d454: 3a 80 00 41 bcc,a 4000d558 <jffs2_scan_medium+0x22c> <== NOT EXECUTED
4000d458: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
err = jffs2_prealloc_raw_node_refs(c, jeb, 2);
4000d45c: 94 10 20 02 mov 2, %o2 <== NOT EXECUTED
4000d460: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000d464: 7f ff e1 e9 call 40005c08 <jffs2_prealloc_raw_node_refs> <== NOT EXECUTED
4000d468: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (err)
4000d46c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000d470: 12 80 00 40 bne 4000d570 <jffs2_scan_medium+0x244> <== NOT EXECUTED
4000d474: 80 8f 60 03 btst 3, %i5 <== NOT EXECUTED
if (ofs & 3) {
4000d478: 12 80 01 14 bne 4000d8c8 <jffs2_scan_medium+0x59c> <== NOT EXECUTED
4000d47c: 80 a7 40 10 cmp %i5, %l0 <== NOT EXECUTED
if (ofs == prevofs) {
4000d480: 02 80 01 2a be 4000d928 <jffs2_scan_medium+0x5fc> <== NOT EXECUTED
4000d484: ae 07 60 0c add %i5, 0xc, %l7 <== NOT EXECUTED
if (jeb->offset + c->sector_size < ofs + sizeof(*node)) {
4000d488: d4 06 e0 0c ld [ %i3 + 0xc ], %o2 <== NOT EXECUTED
4000d48c: c2 07 20 34 ld [ %i4 + 0x34 ], %g1 <== NOT EXECUTED
4000d490: 94 02 80 01 add %o2, %g1, %o2 <== NOT EXECUTED
4000d494: 80 a2 80 17 cmp %o2, %l7 <== NOT EXECUTED
4000d498: 0a 80 02 18 bcs 4000dcf8 <jffs2_scan_medium+0x9cc> <== NOT EXECUTED
4000d49c: 82 06 00 19 add %i0, %i1, %g1 <== NOT EXECUTED
node = (struct jffs2_unknown_node *)&buf[ofs-buf_ofs];
4000d4a0: ac 27 40 18 sub %i5, %i0, %l6 <== NOT EXECUTED
if (buf_ofs + buf_len < ofs + sizeof(*node)) {
4000d4a4: 80 a5 c0 01 cmp %l7, %g1 <== NOT EXECUTED
4000d4a8: 18 80 00 c8 bgu 4000d7c8 <jffs2_scan_medium+0x49c> <== NOT EXECUTED
4000d4ac: ac 06 80 16 add %i2, %l6, %l6 <== NOT EXECUTED
if (*(uint32_t *)(&buf[ofs-buf_ofs]) == 0xffffffff) {
4000d4b0: c2 05 80 00 ld [ %l6 ], %g1 <== NOT EXECUTED
4000d4b4: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
4000d4b8: 22 80 00 da be,a 4000d820 <jffs2_scan_medium+0x4f4> <== NOT EXECUTED
4000d4bc: c4 07 20 34 ld [ %i4 + 0x34 ], %g2 <== NOT EXECUTED
if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) {
4000d4c0: c2 0d 80 00 ldub [ %l6 ], %g1 <== NOT EXECUTED
4000d4c4: d8 0d a0 01 ldub [ %l6 + 1 ], %o4 <== NOT EXECUTED
4000d4c8: c4 06 e0 0c ld [ %i3 + 0xc ], %g2 <== NOT EXECUTED
4000d4cc: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4000d4d0: 80 a0 80 1d cmp %g2, %i5 <== NOT EXECUTED
4000d4d4: 98 13 00 01 or %o4, %g1, %o4 <== NOT EXECUTED
4000d4d8: 02 80 00 a7 be 4000d774 <jffs2_scan_medium+0x448> <== NOT EXECUTED
4000d4dc: 99 2b 20 10 sll %o4, 0x10, %o4 <== NOT EXECUTED
if (je16_to_cpu(node->magic) == JFFS2_DIRTY_BITMASK) {
4000d4e0: 99 33 20 10 srl %o4, 0x10, %o4 <== NOT EXECUTED
4000d4e4: 80 a3 20 00 cmp %o4, 0 <== NOT EXECUTED
4000d4e8: 02 80 00 ab be 4000d794 <jffs2_scan_medium+0x468> <== NOT EXECUTED
4000d4ec: 03 00 00 06 sethi %hi(0x1800), %g1 <== NOT EXECUTED
if (je16_to_cpu(node->magic) == JFFS2_OLD_MAGIC_BITMASK) {
4000d4f0: 82 10 61 84 or %g1, 0x184, %g1 ! 1984 <_ISR_Stack_size+0x984> <== NOT EXECUTED
4000d4f4: 80 a3 00 01 cmp %o4, %g1 <== NOT EXECUTED
4000d4f8: 02 80 01 51 be 4000da3c <jffs2_scan_medium+0x710> <== NOT EXECUTED
4000d4fc: 03 00 00 06 sethi %hi(0x1800), %g1 <== NOT EXECUTED
if (je16_to_cpu(node->magic) != JFFS2_MAGIC_BITMASK) {
4000d500: 94 10 61 85 or %g1, 0x185, %o2 ! 1985 <_ISR_Stack_size+0x985> <== NOT EXECUTED
4000d504: 80 a3 00 0a cmp %o4, %o2 <== NOT EXECUTED
4000d508: 02 80 01 56 be 4000da60 <jffs2_scan_medium+0x734> <== NOT EXECUTED
4000d50c: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
noisy_printk(&noise, "%s(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n",
4000d510: 12 80 01 3e bne 4000da08 <jffs2_scan_medium+0x6dc> <== NOT EXECUTED
4000d514: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
4000d518: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED
4000d51c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000d520: 7f ff e5 98 call 40006b80 <jffs2_scan_dirty_space> <== NOT EXECUTED
4000d524: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000d528: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000d52c: 12 80 00 12 bne 4000d574 <jffs2_scan_medium+0x248> <== NOT EXECUTED
4000d530: 01 00 00 00 nop <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000d534: c4 06 e0 0c ld [ %i3 + 0xc ], %g2 <== NOT EXECUTED
4000d538: c2 07 20 34 ld [ %i4 + 0x34 ], %g1 <== NOT EXECUTED
continue;
4000d53c: a0 10 00 1d mov %i5, %l0 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000d540: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
ofs += 4;
4000d544: ba 07 60 04 add %i5, 4, %i5 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000d548: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
4000d54c: 0a bf ff c5 bcs 4000d460 <jffs2_scan_medium+0x134> <== NOT EXECUTED
4000d550: 94 10 20 02 mov 2, %o2 <== NOT EXECUTED
if (jeb->wasted_size) {
4000d554: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
4000d558: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000d55c: 32 80 01 9f bne,a 4000dbd8 <jffs2_scan_medium+0x8ac> <== NOT EXECUTED
4000d560: c8 06 e0 18 ld [ %i3 + 0x18 ], %g4 <== NOT EXECUTED
return jffs2_scan_classify_jeb(c, jeb);
4000d564: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000d568: 7f ff ff 12 call 4000d1b0 <jffs2_scan_classify_jeb> <== NOT EXECUTED
4000d56c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (ret < 0)
4000d570: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000d574: 06 80 01 02 bl 4000d97c <jffs2_scan_medium+0x650> <== NOT EXECUTED
4000d578: 80 a2 20 05 cmp %o0, 5 <== NOT EXECUTED
pr_warn("%s(): unknown block state\n", __func__);
4000d57c: 38 80 03 18 bgu,a 4000e1dc <jffs2_scan_medium+0xeb0> <== NOT EXECUTED
4000d580: 3b 10 00 85 sethi %hi(0x40021400), %i5 <== NOT EXECUTED
4000d584: 91 2a 20 02 sll %o0, 2, %o0 <== NOT EXECUTED
4000d588: c2 05 00 08 ld [ %l4 + %o0 ], %g1 <== NOT EXECUTED
4000d58c: 81 c0 40 00 jmp %g1 <== NOT EXECUTED
4000d590: 01 00 00 00 nop <== NOT EXECUTED
struct list_head *next = afterthisent->next;
4000d594: c4 07 20 98 ld [ %i4 + 0x98 ], %g2 <== NOT EXECUTED
list_add(&jeb->list, &c->erase_pending_list);
4000d598: 82 07 20 98 add %i4, 0x98, %g1 <== NOT EXECUTED
newent->next = next;
4000d59c: c4 26 c0 00 st %g2, [ %i3 ] <== NOT EXECUTED
newent->prev = afterthisent;
4000d5a0: c2 26 e0 04 st %g1, [ %i3 + 4 ] <== NOT EXECUTED
afterthisent->next = newent;
4000d5a4: f6 27 20 98 st %i3, [ %i4 + 0x98 ]
c->nr_erasing_blocks++;
4000d5a8: c2 07 20 40 ld [ %i4 + 0x40 ], %g1
next->prev = newent;
4000d5ac: f6 20 a0 04 st %i3, [ %g2 + 4 ]
4000d5b0: 82 00 60 01 inc %g1
4000d5b4: c2 27 20 40 st %g1, [ %i4 + 0x40 ]
for (i=0; i<c->nr_blocks; i++) {
4000d5b8: a4 04 a0 01 inc %l2
4000d5bc: c2 07 20 50 ld [ %i4 + 0x50 ], %g1
4000d5c0: 80 a0 40 12 cmp %g1, %l2
4000d5c4: 18 bf ff 75 bgu 4000d398 <jffs2_scan_medium+0x6c>
4000d5c8: a2 04 60 34 add %l1, 0x34, %l1
4000d5cc: ee 07 bf e8 ld [ %fp + -24 ], %l7
if (c->nextblock && (c->nextblock->dirty_size)) {
4000d5d0: c4 07 20 58 ld [ %i4 + 0x58 ], %g2
4000d5d4: 80 a0 a0 00 cmp %g2, 0
4000d5d8: 22 80 00 07 be,a 4000d5f4 <jffs2_scan_medium+0x2c8> <== ALWAYS TAKEN
4000d5dc: c6 07 20 40 ld [ %i4 + 0x40 ], %g3
4000d5e0: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 <== NOT EXECUTED
4000d5e4: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
4000d5e8: 32 80 01 d1 bne,a 4000dd2c <jffs2_scan_medium+0xa00> <== NOT EXECUTED
4000d5ec: f6 00 a0 1c ld [ %g2 + 0x1c ], %i3 <== NOT EXECUTED
if (c->nr_erasing_blocks) {
4000d5f0: c6 07 20 40 ld [ %i4 + 0x40 ], %g3 <== NOT EXECUTED
4000d5f4: 80 a0 e0 00 cmp %g3, 0
4000d5f8: 02 80 00 e2 be 4000d980 <jffs2_scan_medium+0x654> <== NEVER TAKEN
4000d5fc: 84 10 20 00 clr %g2
if ( !c->used_size && ((c->nr_free_blocks+empty_blocks+bad_blocks)!= c->nr_blocks || bad_blocks == c->nr_blocks) ) {
4000d600: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
4000d604: 80 a0 a0 00 cmp %g2, 0
4000d608: 32 80 00 0c bne,a 4000d638 <jffs2_scan_medium+0x30c> <== NEVER TAKEN
4000d60c: d0 07 20 e4 ld [ %i4 + 0xe4 ], %o0 <== NOT EXECUTED
4000d610: c6 07 20 3c ld [ %i4 + 0x3c ], %g3
4000d614: c4 07 bf ec ld [ %fp + -20 ], %g2
4000d618: 84 00 80 17 add %g2, %l7, %g2
4000d61c: 84 00 80 03 add %g2, %g3, %g2
4000d620: 80 a0 80 01 cmp %g2, %g1
4000d624: 12 80 01 cc bne 4000dd54 <jffs2_scan_medium+0xa28> <== NEVER TAKEN
4000d628: 80 a0 40 17 cmp %g1, %l7
4000d62c: 02 80 01 cb be 4000dd58 <jffs2_scan_medium+0xa2c> <== NEVER TAKEN
4000d630: 11 10 00 84 sethi %hi(0x40021000), %o0
rtems_jffs2_flash_control *fc = sb->s_flash_control;
4000d634: d0 07 20 e4 ld [ %i4 + 0xe4 ], %o0
if (fc->trigger_garbage_collection != NULL) {
4000d638: c2 02 20 20 ld [ %o0 + 0x20 ], %g1
4000d63c: 80 a0 60 00 cmp %g1, 0
4000d640: 02 80 00 d0 be 4000d980 <jffs2_scan_medium+0x654> <== ALWAYS TAKEN
4000d644: 84 10 20 00 clr %g2
(*fc->trigger_garbage_collection)(fc);
4000d648: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000d64c: c4 27 bf ec st %g2, [ %fp + -20 ] <== NOT EXECUTED
4000d650: 10 80 00 cc b 4000d980 <jffs2_scan_medium+0x654> <== NOT EXECUTED
4000d654: c4 07 bf ec ld [ %fp + -20 ], %g2 <== NOT EXECUTED
if (ofs == max_ofs) {
4000d658: 12 80 00 a6 bne 4000d8f0 <jffs2_scan_medium+0x5c4> <== NEVER TAKEN
4000d65c: 94 10 20 01 mov 1, %o2
if (c->cleanmarker_size == 0)
4000d660: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
4000d664: 80 a0 60 00 cmp %g1, 0
4000d668: 12 80 00 2b bne 4000d714 <jffs2_scan_medium+0x3e8> <== ALWAYS TAKEN
4000d66c: 82 07 20 98 add %i4, 0x98, %g1
if (!jeb->dirty_size) {
4000d670: c2 06 e0 18 ld [ %i3 + 0x18 ], %g1 <== NOT EXECUTED
4000d674: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000d678: 32 bf ff c8 bne,a 4000d598 <jffs2_scan_medium+0x26c> <== NOT EXECUTED
4000d67c: c4 07 20 98 ld [ %i4 + 0x98 ], %g2 <== NOT EXECUTED
struct list_head *next = afterthisent->next;
4000d680: c4 07 20 a8 ld [ %i4 + 0xa8 ], %g2 <== NOT EXECUTED
newent->next = next;
4000d684: c4 26 c0 00 st %g2, [ %i3 ] <== NOT EXECUTED
list_add(&jeb->list, &c->free_list);
4000d688: 82 07 20 a8 add %i4, 0xa8, %g1 <== NOT EXECUTED
newent->prev = afterthisent;
4000d68c: c2 26 e0 04 st %g1, [ %i3 + 4 ] <== NOT EXECUTED
afterthisent->next = newent;
4000d690: f6 27 20 a8 st %i3, [ %i4 + 0xa8 ] <== NOT EXECUTED
c->nr_free_blocks++;
4000d694: c2 07 20 3c ld [ %i4 + 0x3c ], %g1 <== NOT EXECUTED
next->prev = newent;
4000d698: f6 20 a0 04 st %i3, [ %g2 + 4 ] <== NOT EXECUTED
4000d69c: 82 00 60 01 inc %g1 <== NOT EXECUTED
4000d6a0: 10 bf ff c6 b 4000d5b8 <jffs2_scan_medium+0x28c> <== NOT EXECUTED
4000d6a4: c2 27 20 3c st %g1, [ %i4 + 0x3c ] <== NOT EXECUTED
if (jeb->free_size > min_free(c) &&
4000d6a8: c2 06 e0 20 ld [ %i3 + 0x20 ], %g1 <== NOT EXECUTED
4000d6ac: 80 a0 60 88 cmp %g1, 0x88 <== NOT EXECUTED
4000d6b0: 08 80 00 ae bleu 4000d968 <jffs2_scan_medium+0x63c> <== NOT EXECUTED
4000d6b4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
(!c->nextblock || c->nextblock->free_size < jeb->free_size)) {
4000d6b8: d2 07 20 58 ld [ %i4 + 0x58 ], %o1 <== NOT EXECUTED
if (jeb->free_size > min_free(c) &&
4000d6bc: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
4000d6c0: 22 bf ff be be,a 4000d5b8 <jffs2_scan_medium+0x28c> <== NOT EXECUTED
4000d6c4: f6 27 20 58 st %i3, [ %i4 + 0x58 ] <== NOT EXECUTED
(!c->nextblock || c->nextblock->free_size < jeb->free_size)) {
4000d6c8: c4 02 60 20 ld [ %o1 + 0x20 ], %g2 <== NOT EXECUTED
4000d6cc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4000d6d0: 28 80 00 a6 bleu,a 4000d968 <jffs2_scan_medium+0x63c> <== NOT EXECUTED
4000d6d4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
ret = file_dirty(c, c->nextblock);
4000d6d8: 7f ff fe 87 call 4000d0f4 <file_dirty> <== NOT EXECUTED
4000d6dc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (ret)
4000d6e0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000d6e4: 12 80 00 a7 bne 4000d980 <jffs2_scan_medium+0x654> <== NOT EXECUTED
4000d6e8: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
c->nextblock = jeb;
4000d6ec: 10 bf ff b3 b 4000d5b8 <jffs2_scan_medium+0x28c> <== NOT EXECUTED
4000d6f0: f6 27 20 58 st %i3, [ %i4 + 0x58 ] <== NOT EXECUTED
struct list_head *next = afterthisent->next;
4000d6f4: c2 07 20 60 ld [ %i4 + 0x60 ], %g1 <== NOT EXECUTED
newent->next = next;
4000d6f8: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED
list_add(&jeb->list, &c->clean_list);
4000d6fc: 84 07 20 60 add %i4, 0x60, %g2 <== NOT EXECUTED
newent->prev = afterthisent;
4000d700: c4 26 e0 04 st %g2, [ %i3 + 4 ] <== NOT EXECUTED
afterthisent->next = newent;
4000d704: f6 27 20 60 st %i3, [ %i4 + 0x60 ] <== NOT EXECUTED
} /* list_add() */
4000d708: 10 bf ff ac b 4000d5b8 <jffs2_scan_medium+0x28c> <== NOT EXECUTED
4000d70c: f6 20 60 04 st %i3, [ %g1 + 4 ] <== NOT EXECUTED
list_add(&jeb->list, &c->erase_pending_list);
4000d710: 82 07 20 98 add %i4, 0x98, %g1 <== NOT EXECUTED
struct list_head *next = afterthisent->next;
4000d714: c4 07 20 98 ld [ %i4 + 0x98 ], %g2
newent->prev = afterthisent;
4000d718: c2 26 e0 04 st %g1, [ %i3 + 4 ]
empty_blocks++;
4000d71c: c2 07 bf ec ld [ %fp + -20 ], %g1
4000d720: 82 00 60 01 inc %g1
newent->next = next;
4000d724: c4 26 c0 00 st %g2, [ %i3 ]
4000d728: 10 bf ff 9f b 4000d5a4 <jffs2_scan_medium+0x278>
4000d72c: c2 27 bf ec st %g1, [ %fp + -20 ]
struct list_head *next = afterthisent->next;
4000d730: c2 07 20 b0 ld [ %i4 + 0xb0 ], %g1 <== NOT EXECUTED
list_add(&jeb->list, &c->bad_list);
4000d734: 84 07 20 b0 add %i4, 0xb0, %g2 <== NOT EXECUTED
newent->next = next;
4000d738: c2 26 c0 00 st %g1, [ %i3 ] <== NOT EXECUTED
newent->prev = afterthisent;
4000d73c: c4 26 e0 04 st %g2, [ %i3 + 4 ] <== NOT EXECUTED
bad_blocks++;
4000d740: c4 07 bf e8 ld [ %fp + -24 ], %g2 <== NOT EXECUTED
4000d744: 84 00 a0 01 inc %g2 <== NOT EXECUTED
afterthisent->next = newent;
4000d748: f6 27 20 b0 st %i3, [ %i4 + 0xb0 ] <== NOT EXECUTED
next->prev = newent;
4000d74c: f6 20 60 04 st %i3, [ %g1 + 4 ] <== NOT EXECUTED
c->bad_size += c->sector_size;
4000d750: c6 07 20 34 ld [ %i4 + 0x34 ], %g3 <== NOT EXECUTED
c->free_size -= c->sector_size;
4000d754: c2 07 20 28 ld [ %i4 + 0x28 ], %g1 <== NOT EXECUTED
bad_blocks++;
4000d758: c4 27 bf e8 st %g2, [ %fp + -24 ] <== NOT EXECUTED
c->free_size -= c->sector_size;
4000d75c: 82 20 40 03 sub %g1, %g3, %g1 <== NOT EXECUTED
c->bad_size += c->sector_size;
4000d760: c4 07 20 30 ld [ %i4 + 0x30 ], %g2 <== NOT EXECUTED
4000d764: 84 00 80 03 add %g2, %g3, %g2 <== NOT EXECUTED
c->free_size -= c->sector_size;
4000d768: c2 27 20 28 st %g1, [ %i4 + 0x28 ] <== NOT EXECUTED
break;
4000d76c: 10 bf ff 93 b 4000d5b8 <jffs2_scan_medium+0x28c> <== NOT EXECUTED
4000d770: c4 27 20 30 st %g2, [ %i4 + 0x30 ] <== NOT EXECUTED
if (ofs == jeb->offset && je16_to_cpu(node->magic) == KSAMTIB_CIGAM_2SFFJ) {
4000d774: 03 21 46 40 sethi %hi(0x85190000), %g1 <== NOT EXECUTED
4000d778: 80 a3 00 01 cmp %o4, %g1 <== NOT EXECUTED
4000d77c: 12 bf ff 5a bne 4000d4e4 <jffs2_scan_medium+0x1b8> <== NOT EXECUTED
4000d780: 99 33 20 10 srl %o4, 0x10, %o4 <== NOT EXECUTED
pr_warn("Magic bitmask is backwards at offset 0x%08x. Wrong endian filesystem?\n",
4000d784: 11 10 00 83 sethi %hi(0x40020c00), %o0 <== NOT EXECUTED
4000d788: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000d78c: 7f ff fe 4e call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000d790: 90 12 21 c8 or %o0, 0x1c8, %o0 <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
4000d794: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED
4000d798: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000d79c: 7f ff e4 f9 call 40006b80 <jffs2_scan_dirty_space> <== NOT EXECUTED
4000d7a0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000d7a4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000d7a8: 12 bf ff 73 bne 4000d574 <jffs2_scan_medium+0x248> <== NOT EXECUTED
4000d7ac: 01 00 00 00 nop <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000d7b0: c4 07 20 34 ld [ %i4 + 0x34 ], %g2 <== NOT EXECUTED
4000d7b4: c2 06 e0 0c ld [ %i3 + 0xc ], %g1 <== NOT EXECUTED
continue;
4000d7b8: a0 10 00 1d mov %i5, %l0 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000d7bc: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
continue;
4000d7c0: 10 bf ff 24 b 4000d450 <jffs2_scan_medium+0x124> <== NOT EXECUTED
4000d7c4: ba 07 60 04 add %i5, 4, %i5 <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
4000d7c8: b2 22 80 1d sub %o2, %i5, %i1 <== NOT EXECUTED
4000d7cc: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED
4000d7d0: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
4000d7d4: 38 80 00 02 bgu,a 4000d7dc <jffs2_scan_medium+0x4b0> <== NOT EXECUTED
4000d7d8: b2 10 00 01 mov %g1, %i1 <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
4000d7dc: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
4000d7e0: 96 07 bf f0 add %fp, -16, %o3 <== NOT EXECUTED
4000d7e4: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4000d7e8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000d7ec: 7f ff fd 95 call 4000ce40 <jffs2_flash_read> <== NOT EXECUTED
4000d7f0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (ret) {
4000d7f4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000d7f8: 12 bf ff 5f bne 4000d574 <jffs2_scan_medium+0x248> <== NOT EXECUTED
4000d7fc: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
if (retlen < len) {
4000d800: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
4000d804: 18 80 01 61 bgu 4000dd88 <jffs2_scan_medium+0xa5c> <== NOT EXECUTED
4000d808: ac 10 00 1a mov %i2, %l6 <== NOT EXECUTED
if (*(uint32_t *)(&buf[ofs-buf_ofs]) == 0xffffffff) {
4000d80c: c2 05 80 00 ld [ %l6 ], %g1 <== NOT EXECUTED
4000d810: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
4000d814: 12 bf ff 2b bne 4000d4c0 <jffs2_scan_medium+0x194> <== NOT EXECUTED
4000d818: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
scan_end = min_t(uint32_t, EMPTY_SCAN_SIZE(c->sector_size)/8, buf_len);
4000d81c: c4 07 20 34 ld [ %i4 + 0x34 ], %g2 <== NOT EXECUTED
ofs += 4;
4000d820: ac 07 60 04 add %i5, 4, %l6 <== NOT EXECUTED
if (sector_size < DEFAULT_EMPTY_SCAN_SIZE)
4000d824: 80 a0 a0 ff cmp %g2, 0xff <== NOT EXECUTED
4000d828: 18 80 00 03 bgu 4000d834 <jffs2_scan_medium+0x508> <== NOT EXECUTED
4000d82c: 82 10 20 20 mov 0x20, %g1 <== NOT EXECUTED
scan_end = min_t(uint32_t, EMPTY_SCAN_SIZE(c->sector_size)/8, buf_len);
4000d830: 83 30 a0 03 srl %g2, 3, %g1 <== NOT EXECUTED
4000d834: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
4000d838: 08 80 00 03 bleu 4000d844 <jffs2_scan_medium+0x518> <== NOT EXECUTED
4000d83c: 84 10 00 19 mov %i1, %g2 <== NOT EXECUTED
4000d840: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
4000d844: 21 00 00 04 sethi %hi(0x1000), %l0 <== NOT EXECUTED
inbuf_ofs = ofs - buf_ofs;
4000d848: 82 25 80 18 sub %l6, %i0, %g1 <== NOT EXECUTED
while (inbuf_ofs < scan_end) {
4000d84c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4000d850: 1a 80 00 52 bcc 4000d998 <jffs2_scan_medium+0x66c> <== NOT EXECUTED
4000d854: 86 26 80 18 sub %i2, %i0, %g3 <== NOT EXECUTED
if (unlikely(*(uint32_t *)(&buf[inbuf_ofs]) != 0xffffffff)) {
4000d858: 10 80 00 07 b 4000d874 <jffs2_scan_medium+0x548> <== NOT EXECUTED
4000d85c: c2 00 c0 16 ld [ %g3 + %l6 ], %g1 <== NOT EXECUTED
while (inbuf_ofs < scan_end) {
4000d860: 82 25 80 18 sub %l6, %i0, %g1 <== NOT EXECUTED
4000d864: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
4000d868: 28 80 00 4d bleu,a 4000d99c <jffs2_scan_medium+0x670> <== NOT EXECUTED
4000d86c: c2 06 e0 0c ld [ %i3 + 0xc ], %g1 <== NOT EXECUTED
if (unlikely(*(uint32_t *)(&buf[inbuf_ofs]) != 0xffffffff)) {
4000d870: c2 00 c0 16 ld [ %g3 + %l6 ], %g1 <== NOT EXECUTED
4000d874: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
4000d878: 22 bf ff fa be,a 4000d860 <jffs2_scan_medium+0x534> <== NOT EXECUTED
4000d87c: ac 05 a0 04 add %l6, 4, %l6 <== NOT EXECUTED
pr_warn("Empty flash at 0x%08x ends at 0x%08x\n",
4000d880: 94 10 00 16 mov %l6, %o2 <== NOT EXECUTED
4000d884: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000d888: 11 10 00 83 sethi %hi(0x40020c00), %o0 <== NOT EXECUTED
4000d88c: 7f ff fe 0e call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000d890: 90 12 21 98 or %o0, 0x198, %o0 ! 40020d98 <__func__.0+0xc8> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, ofs-empty_start)))
4000d894: 94 25 80 1d sub %l6, %i5, %o2 <== NOT EXECUTED
4000d898: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000d89c: 7f ff e4 b9 call 40006b80 <jffs2_scan_dirty_space> <== NOT EXECUTED
4000d8a0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000d8a4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000d8a8: 12 bf ff 33 bne 4000d574 <jffs2_scan_medium+0x248> <== NOT EXECUTED
4000d8ac: 01 00 00 00 nop <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000d8b0: c4 07 20 34 ld [ %i4 + 0x34 ], %g2 <== NOT EXECUTED
4000d8b4: c2 06 e0 0c ld [ %i3 + 0xc ], %g1 <== NOT EXECUTED
4000d8b8: a0 10 00 1d mov %i5, %l0 <== NOT EXECUTED
4000d8bc: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
4000d8c0: 10 bf fe e4 b 4000d450 <jffs2_scan_medium+0x124> <== NOT EXECUTED
4000d8c4: ba 10 00 16 mov %l6, %i5 <== NOT EXECUTED
pr_warn("Eep. ofs 0x%08x not word-aligned!\n", ofs);
4000d8c8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000d8cc: 11 10 00 83 sethi %hi(0x40020c00), %o0 <== NOT EXECUTED
4000d8d0: 7f ff fd fd call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000d8d4: 90 12 21 30 or %o0, 0x130, %o0 ! 40020d30 <__func__.0+0x60> <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000d8d8: c4 07 20 34 ld [ %i4 + 0x34 ], %g2 <== NOT EXECUTED
4000d8dc: c2 06 e0 0c ld [ %i3 + 0xc ], %g1 <== NOT EXECUTED
ofs = PAD(ofs);
4000d8e0: ba 07 60 03 add %i5, 3, %i5 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000d8e4: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
continue;
4000d8e8: 10 bf fe da b 4000d450 <jffs2_scan_medium+0x124> <== NOT EXECUTED
4000d8ec: ba 0f 7f fc and %i5, -4, %i5 <== NOT EXECUTED
if ((err = jffs2_prealloc_raw_node_refs(c, jeb, 1)))
4000d8f0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000d8f4: 7f ff e0 c5 call 40005c08 <jffs2_prealloc_raw_node_refs> <== NOT EXECUTED
4000d8f8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000d8fc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000d900: 12 bf ff 1d bne 4000d574 <jffs2_scan_medium+0x248> <== NOT EXECUTED
4000d904: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, ofs)))
4000d908: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000d90c: 7f ff e4 9d call 40006b80 <jffs2_scan_dirty_space> <== NOT EXECUTED
4000d910: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000d914: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000d918: 12 bf ff 17 bne 4000d574 <jffs2_scan_medium+0x248> <== NOT EXECUTED
4000d91c: 01 00 00 00 nop <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000d920: 10 bf fe c4 b 4000d430 <jffs2_scan_medium+0x104> <== NOT EXECUTED
4000d924: c6 07 20 34 ld [ %i4 + 0x34 ], %g3 <== NOT EXECUTED
pr_warn("ofs 0x%08x has already been seen. Skipping\n",
4000d928: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000d92c: 11 10 00 83 sethi %hi(0x40020c00), %o0 <== NOT EXECUTED
4000d930: 7f ff fd e5 call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000d934: 90 12 21 60 or %o0, 0x160, %o0 ! 40020d60 <__func__.0+0x90> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
4000d938: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED
4000d93c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000d940: 7f ff e4 90 call 40006b80 <jffs2_scan_dirty_space> <== NOT EXECUTED
4000d944: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000d948: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000d94c: 12 bf ff 0a bne 4000d574 <jffs2_scan_medium+0x248> <== NOT EXECUTED
4000d950: 01 00 00 00 nop <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000d954: c4 07 20 34 ld [ %i4 + 0x34 ], %g2 <== NOT EXECUTED
4000d958: c2 06 e0 0c ld [ %i3 + 0xc ], %g1 <== NOT EXECUTED
ofs += 4;
4000d95c: ba 07 60 04 add %i5, 4, %i5 <== NOT EXECUTED
continue;
4000d960: 10 bf fe bc b 4000d450 <jffs2_scan_medium+0x124> <== NOT EXECUTED
4000d964: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
ret = file_dirty(c, jeb);
4000d968: 7f ff fd e3 call 4000d0f4 <file_dirty> <== NOT EXECUTED
4000d96c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (ret)
4000d970: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000d974: 22 bf ff 12 be,a 4000d5bc <jffs2_scan_medium+0x290> <== NOT EXECUTED
4000d978: a4 04 a0 01 inc %l2 <== NOT EXECUTED
4000d97c: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
4000d980: c4 27 bf ec st %g2, [ %fp + -20 ]
kfree(flashbuf);
4000d984: 40 00 04 ec call 4000ed34 <free>
4000d988: 90 10 00 1a mov %i2, %o0
return ret;
4000d98c: c4 07 bf ec ld [ %fp + -20 ], %g2
}
4000d990: 81 c7 e0 08 ret
4000d994: 91 e8 00 02 restore %g0, %g2, %o0
if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) &&
4000d998: c2 06 e0 0c ld [ %i3 + 0xc ], %g1 <== NOT EXECUTED
4000d99c: 80 a6 00 01 cmp %i0, %g1 <== NOT EXECUTED
4000d9a0: 22 80 00 78 be,a 4000db80 <jffs2_scan_medium+0x854> <== NOT EXECUTED
4000d9a4: c6 07 20 14 ld [ %i4 + 0x14 ], %g3 <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
4000d9a8: f2 07 20 34 ld [ %i4 + 0x34 ], %i1 <== NOT EXECUTED
4000d9ac: 82 00 40 19 add %g1, %i1, %g1 <== NOT EXECUTED
if (!buf_len) {
4000d9b0: 80 a0 40 16 cmp %g1, %l6 <== NOT EXECUTED
4000d9b4: 22 bf fe e9 be,a 4000d558 <jffs2_scan_medium+0x22c> <== NOT EXECUTED
4000d9b8: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
4000d9bc: b2 20 40 16 sub %g1, %l6, %i1 <== NOT EXECUTED
4000d9c0: 80 a6 40 10 cmp %i1, %l0 <== NOT EXECUTED
4000d9c4: 38 80 00 02 bgu,a 4000d9cc <jffs2_scan_medium+0x6a0> <== NOT EXECUTED
4000d9c8: b2 10 00 10 mov %l0, %i1 <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
4000d9cc: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
4000d9d0: 96 07 bf f0 add %fp, -16, %o3 <== NOT EXECUTED
4000d9d4: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4000d9d8: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
4000d9dc: 7f ff fd 19 call 4000ce40 <jffs2_flash_read> <== NOT EXECUTED
4000d9e0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (ret) {
4000d9e4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000d9e8: 12 bf fe e3 bne 4000d574 <jffs2_scan_medium+0x248> <== NOT EXECUTED
4000d9ec: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
if (retlen < len) {
4000d9f0: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
4000d9f4: 38 bf ff e3 bgu,a 4000d980 <jffs2_scan_medium+0x654> <== NOT EXECUTED
4000d9f8: 84 10 3f fb mov -5, %g2 <== NOT EXECUTED
if (err)
4000d9fc: 84 10 00 19 mov %i1, %g2 <== NOT EXECUTED
4000da00: 10 bf ff 92 b 4000d848 <jffs2_scan_medium+0x51c> <== NOT EXECUTED
4000da04: b0 10 00 16 mov %l6, %i0 <== NOT EXECUTED
noisy_printk(&noise, "%s(): Magic bitmask 0x%04x not found at 0x%08x: 0x%04x instead\n",
4000da08: 13 10 00 85 sethi %hi(0x40021400), %o1 <== NOT EXECUTED
4000da0c: 11 10 00 83 sethi %hi(0x40020c00), %o0 <== NOT EXECUTED
4000da10: 92 12 60 00 mov %o1, %o1 <== NOT EXECUTED
4000da14: 7f ff fd ac call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000da18: 90 12 22 98 or %o0, 0x298, %o0 <== NOT EXECUTED
4000da1c: a6 84 ff ff addcc %l3, -1, %l3 <== NOT EXECUTED
4000da20: 32 bf fe bf bne,a 4000d51c <jffs2_scan_medium+0x1f0> <== NOT EXECUTED
4000da24: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED
4000da28: 11 10 00 83 sethi %hi(0x40020c00), %o0 <== NOT EXECUTED
4000da2c: 7f ff fd a6 call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000da30: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 40020ee8 <__func__.0+0x218> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
4000da34: 10 bf fe ba b 4000d51c <jffs2_scan_medium+0x1f0> <== NOT EXECUTED
4000da38: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED
pr_warn("Old JFFS2 bitmask found at 0x%08x\n", ofs);
4000da3c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000da40: 11 10 00 83 sethi %hi(0x40020c00), %o0 <== NOT EXECUTED
4000da44: 7f ff fd a0 call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000da48: 90 12 22 20 or %o0, 0x220, %o0 ! 40020e20 <__func__.0+0x150> <== NOT EXECUTED
pr_warn("You cannot use older JFFS2 filesystems with newer kernels\n");
4000da4c: 11 10 00 83 sethi %hi(0x40020c00), %o0 <== NOT EXECUTED
pr_warn("Perhaps the file system was created with the wrong erase size?\n");
4000da50: 7f ff fd 9d call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000da54: 90 12 22 50 or %o0, 0x250, %o0 ! 40020e50 <__func__.0+0x180> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
4000da58: 10 bf fe b1 b 4000d51c <jffs2_scan_medium+0x1f0> <== NOT EXECUTED
4000da5c: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED
crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE);
4000da60: c4 0d a0 02 ldub [ %l6 + 2 ], %g2 <== NOT EXECUTED
4000da64: c2 0d a0 03 ldub [ %l6 + 3 ], %g1 <== NOT EXECUTED
crcnode.totlen = node->totlen;
4000da68: c8 0d a0 06 ldub [ %l6 + 6 ], %g4 <== NOT EXECUTED
4000da6c: c6 0d a0 07 ldub [ %l6 + 7 ], %g3 <== NOT EXECUTED
crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE);
4000da70: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
crcnode.magic = node->magic;
4000da74: d6 0d 80 00 ldub [ %l6 ], %o3 <== NOT EXECUTED
crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE);
4000da78: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
crcnode.magic = node->magic;
4000da7c: d8 0d a0 01 ldub [ %l6 + 1 ], %o4 <== NOT EXECUTED
crcnode.totlen = node->totlen;
4000da80: da 0d a0 04 ldub [ %l6 + 4 ], %o5 <== NOT EXECUTED
4000da84: de 0d a0 05 ldub [ %l6 + 5 ], %o7 <== NOT EXECUTED
crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE);
4000da88: 21 00 00 08 sethi %hi(0x2000), %l0 <== NOT EXECUTED
4000da8c: 82 10 40 10 or %g1, %l0, %g1 <== NOT EXECUTED
crcnode.totlen = node->totlen;
4000da90: c8 2f bf fa stb %g4, [ %fp + -6 ] <== NOT EXECUTED
hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4);
4000da94: 94 10 20 08 mov 8, %o2 <== NOT EXECUTED
crcnode.nodetype = cpu_to_je16( je16_to_cpu(node->nodetype) | JFFS2_NODE_ACCURATE);
4000da98: c2 37 bf f6 sth %g1, [ %fp + -10 ] <== NOT EXECUTED
hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4);
4000da9c: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
crcnode.totlen = node->totlen;
4000daa0: c6 2f bf fb stb %g3, [ %fp + -5 ] <== NOT EXECUTED
crcnode.magic = node->magic;
4000daa4: d6 2f bf f4 stb %o3, [ %fp + -12 ] <== NOT EXECUTED
4000daa8: d8 2f bf f5 stb %o4, [ %fp + -11 ] <== NOT EXECUTED
crcnode.totlen = node->totlen;
4000daac: da 2f bf f8 stb %o5, [ %fp + -8 ] <== NOT EXECUTED
4000dab0: de 2f bf f9 stb %o7, [ %fp + -7 ] <== NOT EXECUTED
hdr_crc = crc32(0, &crcnode, sizeof(crcnode)-4);
4000dab4: 7f ff f8 31 call 4000bb78 <cyg_crc32_accumulate> <== NOT EXECUTED
4000dab8: 90 10 20 00 clr %o0 <== NOT EXECUTED
if (hdr_crc != je32_to_cpu(node->hdr_crc)) {
4000dabc: c8 0d a0 08 ldub [ %l6 + 8 ], %g4 <== NOT EXECUTED
4000dac0: c4 0d a0 09 ldub [ %l6 + 9 ], %g2 <== NOT EXECUTED
4000dac4: c2 0d a0 0a ldub [ %l6 + 0xa ], %g1 <== NOT EXECUTED
4000dac8: c6 0d a0 0b ldub [ %l6 + 0xb ], %g3 <== NOT EXECUTED
4000dacc: 89 29 20 18 sll %g4, 0x18, %g4 <== NOT EXECUTED
4000dad0: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4000dad4: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4000dad8: 84 10 80 04 or %g2, %g4, %g2 <== NOT EXECUTED
4000dadc: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
4000dae0: 82 10 c0 01 or %g3, %g1, %g1 <== NOT EXECUTED
4000dae4: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED
4000dae8: 02 80 00 46 be 4000dc00 <jffs2_scan_medium+0x8d4> <== NOT EXECUTED
4000daec: 80 a4 e0 00 cmp %l3, 0 <== 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",
4000daf0: 02 bf ff 2a be 4000d798 <jffs2_scan_medium+0x46c> <== NOT EXECUTED
4000daf4: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED
4000daf8: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
4000dafc: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4000db00: c2 23 a0 5c st %g1, [ %sp + 0x5c ] <== NOT EXECUTED
4000db04: 13 10 00 85 sethi %hi(0x40021400), %o1 <== NOT EXECUTED
4000db08: de 0d a0 04 ldub [ %l6 + 4 ], %o7 <== NOT EXECUTED
4000db0c: c4 0d a0 05 ldub [ %l6 + 5 ], %g2 <== NOT EXECUTED
4000db10: c2 0d a0 06 ldub [ %l6 + 6 ], %g1 <== NOT EXECUTED
4000db14: c8 0d a0 02 ldub [ %l6 + 2 ], %g4 <== NOT EXECUTED
4000db18: c6 0d 80 00 ldub [ %l6 ], %g3 <== NOT EXECUTED
4000db1c: da 0d a0 07 ldub [ %l6 + 7 ], %o5 <== NOT EXECUTED
4000db20: d8 0d a0 03 ldub [ %l6 + 3 ], %o4 <== NOT EXECUTED
4000db24: d6 0d a0 01 ldub [ %l6 + 1 ], %o3 <== NOT EXECUTED
4000db28: 9f 2b e0 18 sll %o7, 0x18, %o7 <== NOT EXECUTED
4000db2c: 89 29 20 08 sll %g4, 8, %g4 <== NOT EXECUTED
4000db30: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
4000db34: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4000db38: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4000db3c: 84 10 80 0f or %g2, %o7, %g2 <== NOT EXECUTED
4000db40: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
4000db44: 98 13 00 04 or %o4, %g4, %o4 <== NOT EXECUTED
4000db48: 9a 13 40 01 or %o5, %g1, %o5 <== NOT EXECUTED
4000db4c: 96 12 c0 03 or %o3, %g3, %o3 <== NOT EXECUTED
4000db50: 92 12 60 00 mov %o1, %o1 <== NOT EXECUTED
4000db54: 11 10 00 83 sethi %hi(0x40020c00), %o0 <== NOT EXECUTED
4000db58: 7f ff fd 5b call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000db5c: 90 12 23 30 or %o0, 0x330, %o0 ! 40020f30 <__func__.0+0x260> <== NOT EXECUTED
4000db60: a6 84 ff ff addcc %l3, -1, %l3 <== NOT EXECUTED
4000db64: 32 bf ff 0d bne,a 4000d798 <jffs2_scan_medium+0x46c> <== NOT EXECUTED
4000db68: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED
4000db6c: 11 10 00 83 sethi %hi(0x40020c00), %o0 <== NOT EXECUTED
4000db70: 7f ff fd 55 call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000db74: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 40020ee8 <__func__.0+0x218> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
4000db78: 10 bf ff 08 b 4000d798 <jffs2_scan_medium+0x46c> <== NOT EXECUTED
4000db7c: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED
if (buf_ofs == jeb->offset && jeb->used_size == PAD(c->cleanmarker_size) &&
4000db80: c8 06 e0 14 ld [ %i3 + 0x14 ], %g4 <== NOT EXECUTED
4000db84: 84 00 e0 03 add %g3, 3, %g2 <== NOT EXECUTED
4000db88: 84 08 bf fc and %g2, -4, %g2 <== NOT EXECUTED
4000db8c: 80 a0 80 04 cmp %g2, %g4 <== NOT EXECUTED
4000db90: 12 bf ff 86 bne 4000d9a8 <jffs2_scan_medium+0x67c> <== NOT EXECUTED
4000db94: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
4000db98: 22 bf ff 85 be,a 4000d9ac <jffs2_scan_medium+0x680> <== NOT EXECUTED
4000db9c: f2 07 20 34 ld [ %i4 + 0x34 ], %i1 <== NOT EXECUTED
c->cleanmarker_size && !jeb->dirty_size && !ref_next(jeb->first_node)) {
4000dba0: c4 06 e0 18 ld [ %i3 + 0x18 ], %g2 <== NOT EXECUTED
4000dba4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4000dba8: 32 bf ff 81 bne,a 4000d9ac <jffs2_scan_medium+0x680> <== NOT EXECUTED
4000dbac: f2 07 20 34 ld [ %i4 + 0x34 ], %i1 <== NOT EXECUTED
4000dbb0: c6 06 e0 28 ld [ %i3 + 0x28 ], %g3 <== NOT EXECUTED
if (ref->flash_offset == REF_LINK_NODE) {
4000dbb4: c4 00 e0 0c ld [ %g3 + 0xc ], %g2 <== NOT EXECUTED
4000dbb8: 80 a0 bf ff cmp %g2, -1 <== NOT EXECUTED
4000dbbc: 22 80 00 dc be,a 4000df2c <jffs2_scan_medium+0xc00> <== NOT EXECUTED
4000dbc0: c4 00 e0 08 ld [ %g3 + 8 ], %g2 <== NOT EXECUTED
if (ref->flash_offset == REF_EMPTY_NODE)
4000dbc4: 80 a0 bf fe cmp %g2, -2 <== NOT EXECUTED
4000dbc8: 32 bf ff 79 bne,a 4000d9ac <jffs2_scan_medium+0x680> <== NOT EXECUTED
4000dbcc: f2 07 20 34 ld [ %i4 + 0x34 ], %i1 <== NOT EXECUTED
4000dbd0: 10 bf fe ad b 4000d684 <jffs2_scan_medium+0x358> <== NOT EXECUTED
4000dbd4: c4 07 20 a8 ld [ %i4 + 0xa8 ], %g2 <== NOT EXECUTED
c->dirty_size += jeb->wasted_size;
4000dbd8: c6 07 20 20 ld [ %i4 + 0x20 ], %g3 <== NOT EXECUTED
c->wasted_size -= jeb->wasted_size;
4000dbdc: c4 07 20 24 ld [ %i4 + 0x24 ], %g2 <== NOT EXECUTED
jeb->dirty_size += jeb->wasted_size;
4000dbe0: 88 01 00 01 add %g4, %g1, %g4 <== NOT EXECUTED
4000dbe4: c8 26 e0 18 st %g4, [ %i3 + 0x18 ] <== NOT EXECUTED
c->dirty_size += jeb->wasted_size;
4000dbe8: 86 00 c0 01 add %g3, %g1, %g3 <== NOT EXECUTED
c->wasted_size -= jeb->wasted_size;
4000dbec: 82 20 80 01 sub %g2, %g1, %g1 <== NOT EXECUTED
c->dirty_size += jeb->wasted_size;
4000dbf0: c6 27 20 20 st %g3, [ %i4 + 0x20 ] <== NOT EXECUTED
c->wasted_size -= jeb->wasted_size;
4000dbf4: c2 27 20 24 st %g1, [ %i4 + 0x24 ] <== NOT EXECUTED
jeb->wasted_size = 0;
4000dbf8: 10 bf fe 5b b 4000d564 <jffs2_scan_medium+0x238> <== NOT EXECUTED
4000dbfc: c0 26 e0 1c clr [ %i3 + 0x1c ] <== NOT EXECUTED
if (ofs + je32_to_cpu(node->totlen) > jeb->offset + c->sector_size) {
4000dc00: c8 0d a0 04 ldub [ %l6 + 4 ], %g4 <== NOT EXECUTED
4000dc04: c6 0d a0 05 ldub [ %l6 + 5 ], %g3 <== NOT EXECUTED
4000dc08: c4 0d a0 06 ldub [ %l6 + 6 ], %g2 <== NOT EXECUTED
4000dc0c: d4 0d a0 07 ldub [ %l6 + 7 ], %o2 <== NOT EXECUTED
4000dc10: de 06 e0 0c ld [ %i3 + 0xc ], %o7 <== NOT EXECUTED
4000dc14: c2 07 20 34 ld [ %i4 + 0x34 ], %g1 <== NOT EXECUTED
4000dc18: 89 29 20 18 sll %g4, 0x18, %g4 <== NOT EXECUTED
4000dc1c: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED
4000dc20: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED
4000dc24: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
4000dc28: 82 03 c0 01 add %o7, %g1, %g1 <== NOT EXECUTED
4000dc2c: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
4000dc30: 94 12 80 02 or %o2, %g2, %o2 <== NOT EXECUTED
4000dc34: 86 02 80 1d add %o2, %i5, %g3 <== NOT EXECUTED
4000dc38: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED
4000dc3c: 18 80 00 b4 bgu 4000df0c <jffs2_scan_medium+0xbe0> <== NOT EXECUTED
4000dc40: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
if (!(je16_to_cpu(node->nodetype) & JFFS2_NODE_ACCURATE)) {
4000dc44: c8 0d a0 02 ldub [ %l6 + 2 ], %g4 <== NOT EXECUTED
4000dc48: c4 0d a0 03 ldub [ %l6 + 3 ], %g2 <== NOT EXECUTED
4000dc4c: 89 29 20 08 sll %g4, 8, %g4 <== NOT EXECUTED
4000dc50: 84 10 80 04 or %g2, %g4, %g2 <== NOT EXECUTED
4000dc54: 80 88 80 10 btst %g2, %l0 <== NOT EXECUTED
4000dc58: 02 80 00 0e be 4000dc90 <jffs2_scan_medium+0x964> <== NOT EXECUTED
4000dc5c: da 07 bf e4 ld [ %fp + -28 ], %o5 <== NOT EXECUTED
switch(je16_to_cpu(node->nodetype)) {
4000dc60: 88 10 00 02 mov %g2, %g4 <== NOT EXECUTED
4000dc64: 80 a0 80 0d cmp %g2, %o5 <== NOT EXECUTED
4000dc68: 02 80 00 cb be 4000df94 <jffs2_scan_medium+0xc68> <== NOT EXECUTED
4000dc6c: 93 28 a0 10 sll %g2, 0x10, %o1 <== NOT EXECUTED
4000dc70: 18 80 00 48 bgu 4000dd90 <jffs2_scan_medium+0xa64> <== NOT EXECUTED
4000dc74: 86 14 20 03 or %l0, 3, %g3 <== NOT EXECUTED
4000dc78: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
4000dc7c: 02 80 00 b1 be 4000df40 <jffs2_scan_medium+0xc14> <== NOT EXECUTED
4000dc80: a0 14 20 04 or %l0, 4, %l0 <== NOT EXECUTED
4000dc84: 80 a0 80 10 cmp %g2, %l0 <== NOT EXECUTED
4000dc88: 12 80 01 0d bne 4000e0bc <jffs2_scan_medium+0xd90> <== NOT EXECUTED
4000dc8c: 07 3f ff f0 sethi %hi(0xffffc000), %g3 <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
4000dc90: 94 02 a0 03 add %o2, 3, %o2 <== NOT EXECUTED
4000dc94: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000dc98: 94 0a bf fc and %o2, -4, %o2 <== NOT EXECUTED
4000dc9c: 7f ff e3 b9 call 40006b80 <jffs2_scan_dirty_space> <== NOT EXECUTED
4000dca0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000dca4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000dca8: 12 bf fe 33 bne 4000d574 <jffs2_scan_medium+0x248> <== NOT EXECUTED
4000dcac: 01 00 00 00 nop <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
4000dcb0: de 0d a0 04 ldub [ %l6 + 4 ], %o7 <== NOT EXECUTED
4000dcb4: c8 0d a0 05 ldub [ %l6 + 5 ], %g4 <== NOT EXECUTED
4000dcb8: c6 0d a0 06 ldub [ %l6 + 6 ], %g3 <== NOT EXECUTED
4000dcbc: c4 0d a0 07 ldub [ %l6 + 7 ], %g2 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000dcc0: da 07 20 34 ld [ %i4 + 0x34 ], %o5 <== NOT EXECUTED
4000dcc4: c2 06 e0 0c ld [ %i3 + 0xc ], %g1 <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
4000dcc8: 9f 2b e0 18 sll %o7, 0x18, %o7 <== NOT EXECUTED
4000dccc: 89 29 20 10 sll %g4, 0x10, %g4 <== NOT EXECUTED
4000dcd0: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
4000dcd4: 88 11 00 0f or %g4, %o7, %g4 <== NOT EXECUTED
break;
4000dcd8: a0 10 00 1d mov %i5, %l0 <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
4000dcdc: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000dce0: 82 03 40 01 add %o5, %g1, %g1 <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
4000dce4: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
4000dce8: 84 00 a0 03 add %g2, 3, %g2 <== NOT EXECUTED
4000dcec: 84 08 bf fc and %g2, -4, %g2 <== NOT EXECUTED
break;
4000dcf0: 10 bf fd d8 b 4000d450 <jffs2_scan_medium+0x124> <== NOT EXECUTED
4000dcf4: ba 00 80 1d add %g2, %i5, %i5 <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, (jeb->offset + c->sector_size)-ofs)))
4000dcf8: 94 22 80 1d sub %o2, %i5, %o2 <== NOT EXECUTED
4000dcfc: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000dd00: 7f ff e3 a0 call 40006b80 <jffs2_scan_dirty_space> <== NOT EXECUTED
4000dd04: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000dd08: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000dd0c: 12 bf fe 1a bne 4000d574 <jffs2_scan_medium+0x248> <== NOT EXECUTED
4000dd10: 01 00 00 00 nop <== NOT EXECUTED
if (jeb->wasted_size) {
4000dd14: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
4000dd18: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000dd1c: 32 bf ff af bne,a 4000dbd8 <jffs2_scan_medium+0x8ac> <== NOT EXECUTED
4000dd20: c8 06 e0 18 ld [ %i3 + 0x18 ], %g4 <== NOT EXECUTED
return jffs2_scan_classify_jeb(c, jeb);
4000dd24: 10 bf fe 11 b 4000d568 <jffs2_scan_medium+0x23c> <== NOT EXECUTED
4000dd28: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
c->wasted_size += c->nextblock->dirty_size;
4000dd2c: fa 07 20 24 ld [ %i4 + 0x24 ], %i5 <== NOT EXECUTED
c->dirty_size -= c->nextblock->dirty_size;
4000dd30: c8 07 20 20 ld [ %i4 + 0x20 ], %g4 <== NOT EXECUTED
c->nextblock->wasted_size += c->nextblock->dirty_size;
4000dd34: b6 06 c0 03 add %i3, %g3, %i3 <== NOT EXECUTED
4000dd38: f6 20 a0 1c st %i3, [ %g2 + 0x1c ] <== NOT EXECUTED
c->wasted_size += c->nextblock->dirty_size;
4000dd3c: ba 07 40 03 add %i5, %g3, %i5 <== NOT EXECUTED
c->dirty_size -= c->nextblock->dirty_size;
4000dd40: 86 21 00 03 sub %g4, %g3, %g3 <== NOT EXECUTED
c->wasted_size += c->nextblock->dirty_size;
4000dd44: fa 27 20 24 st %i5, [ %i4 + 0x24 ] <== NOT EXECUTED
c->dirty_size -= c->nextblock->dirty_size;
4000dd48: c6 27 20 20 st %g3, [ %i4 + 0x20 ] <== NOT EXECUTED
c->nextblock->dirty_size = 0;
4000dd4c: 10 bf fe 29 b 4000d5f0 <jffs2_scan_medium+0x2c4> <== NOT EXECUTED
4000dd50: c0 20 a0 18 clr [ %g2 + 0x18 ] <== NOT EXECUTED
pr_notice("Cowardly refusing to erase blocks on filesystem with no valid JFFS2 nodes\n");
4000dd54: 11 10 00 84 sethi %hi(0x40021000), %o0 <== NOT EXECUTED
4000dd58: 7f ff fc db call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000dd5c: 90 12 23 18 or %o0, 0x318, %o0 ! 40021318 <__func__.0+0x648> <== NOT EXECUTED
ret = -EIO;
4000dd60: 84 10 3f fb mov -5, %g2 <== NOT EXECUTED
pr_notice("empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n",
4000dd64: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
4000dd68: d6 07 20 50 ld [ %i4 + 0x50 ], %o3 <== NOT EXECUTED
ret = -EIO;
4000dd6c: c4 27 bf ec st %g2, [ %fp + -20 ] <== NOT EXECUTED
pr_notice("empty_blocks %d, bad_blocks %d, c->nr_blocks %d\n",
4000dd70: 94 10 00 17 mov %l7, %o2 <== NOT EXECUTED
4000dd74: 11 10 00 84 sethi %hi(0x40021000), %o0 <== NOT EXECUTED
4000dd78: 7f ff fc d3 call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000dd7c: 90 12 23 70 or %o0, 0x370, %o0 ! 40021370 <__func__.0+0x6a0> <== NOT EXECUTED
goto out;
4000dd80: 10 bf ff 00 b 4000d980 <jffs2_scan_medium+0x654> <== NOT EXECUTED
4000dd84: c4 07 bf ec ld [ %fp + -20 ], %g2 <== NOT EXECUTED
return -EIO;
4000dd88: 10 bf fe fe b 4000d980 <jffs2_scan_medium+0x654> <== NOT EXECUTED
4000dd8c: 84 10 3f fb mov -5, %g2 <== NOT EXECUTED
switch(je16_to_cpu(node->nodetype)) {
4000dd90: 84 15 60 02 or %l5, 2, %g2 <== NOT EXECUTED
4000dd94: 80 a1 00 02 cmp %g4, %g2 <== NOT EXECUTED
4000dd98: 12 80 00 c0 bne 4000e098 <jffs2_scan_medium+0xd6c> <== NOT EXECUTED
4000dd9c: 86 07 60 44 add %i5, 0x44, %g3 <== NOT EXECUTED
if (buf_ofs + buf_len < ofs + sizeof(struct jffs2_raw_inode)) {
4000dda0: 84 06 00 19 add %i0, %i1, %g2 <== NOT EXECUTED
4000dda4: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
4000dda8: 3a 80 00 15 bcc,a 4000ddfc <jffs2_scan_medium+0xad0> <== NOT EXECUTED
4000ddac: c6 0d a0 0c ldub [ %l6 + 0xc ], %g3 <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
4000ddb0: b2 20 40 1d sub %g1, %i5, %i1 <== NOT EXECUTED
4000ddb4: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED
4000ddb8: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
4000ddbc: 38 80 00 02 bgu,a 4000ddc4 <jffs2_scan_medium+0xa98> <== NOT EXECUTED
4000ddc0: b2 10 00 01 mov %g1, %i1 <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
4000ddc4: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
4000ddc8: 96 07 bf f0 add %fp, -16, %o3 <== NOT EXECUTED
4000ddcc: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4000ddd0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000ddd4: 7f ff fc 1b call 4000ce40 <jffs2_flash_read> <== NOT EXECUTED
4000ddd8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (ret) {
4000dddc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000dde0: 12 bf fd e5 bne 4000d574 <jffs2_scan_medium+0x248> <== NOT EXECUTED
4000dde4: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
if (retlen < len) {
4000dde8: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
4000ddec: 18 bf ff e7 bgu 4000dd88 <jffs2_scan_medium+0xa5c> <== NOT EXECUTED
4000ddf0: ac 10 00 1a mov %i2, %l6 <== NOT EXECUTED
if (err)
4000ddf4: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
uint32_t crc, ino = je32_to_cpu(ri->ino);
4000ddf8: c6 0d a0 0c ldub [ %l6 + 0xc ], %g3 <== NOT EXECUTED
4000ddfc: c4 0d a0 0d ldub [ %l6 + 0xd ], %g2 <== NOT EXECUTED
4000de00: c2 0d a0 0e ldub [ %l6 + 0xe ], %g1 <== NOT EXECUTED
4000de04: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
4000de08: e0 0d a0 0f ldub [ %l6 + 0xf ], %l0 <== NOT EXECUTED
4000de0c: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4000de10: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4000de14: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
4000de18: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
crc = crc32(0, ri, sizeof(*ri)-8);
4000de1c: 94 10 20 3c mov 0x3c, %o2 <== NOT EXECUTED
uint32_t crc, ino = je32_to_cpu(ri->ino);
4000de20: a0 14 00 01 or %l0, %g1, %l0 <== NOT EXECUTED
crc = crc32(0, ri, sizeof(*ri)-8);
4000de24: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
4000de28: 7f ff f7 54 call 4000bb78 <cyg_crc32_accumulate> <== NOT EXECUTED
4000de2c: 90 10 20 00 clr %o0 <== NOT EXECUTED
if (crc != je32_to_cpu(ri->node_crc)) {
4000de30: c6 0d a0 40 ldub [ %l6 + 0x40 ], %g3 <== NOT EXECUTED
4000de34: c4 0d a0 41 ldub [ %l6 + 0x41 ], %g2 <== NOT EXECUTED
4000de38: c2 0d a0 42 ldub [ %l6 + 0x42 ], %g1 <== NOT EXECUTED
4000de3c: d6 0d a0 43 ldub [ %l6 + 0x43 ], %o3 <== NOT EXECUTED
4000de40: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
4000de44: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4000de48: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4000de4c: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
4000de50: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
4000de54: 96 12 c0 01 or %o3, %g1, %o3 <== NOT EXECUTED
4000de58: 80 a2 00 0b cmp %o0, %o3 <== NOT EXECUTED
4000de5c: 02 80 00 ac be 4000e10c <jffs2_scan_medium+0xde0> <== NOT EXECUTED
4000de60: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
pr_notice("%s(): CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
4000de64: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4000de68: 13 10 00 84 sethi %hi(0x40021000), %o1 <== NOT EXECUTED
4000de6c: 11 10 00 84 sethi %hi(0x40021000), %o0 <== NOT EXECUTED
4000de70: 92 12 63 e8 or %o1, 0x3e8, %o1 <== NOT EXECUTED
4000de74: 7f ff fc 94 call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000de78: 90 12 20 40 or %o0, 0x40, %o0 <== NOT EXECUTED
PAD(je32_to_cpu(ri->totlen)));
4000de7c: c6 0d a0 04 ldub [ %l6 + 4 ], %g3 <== NOT EXECUTED
4000de80: c4 0d a0 05 ldub [ %l6 + 5 ], %g2 <== NOT EXECUTED
4000de84: c2 0d a0 06 ldub [ %l6 + 6 ], %g1 <== NOT EXECUTED
4000de88: d4 0d a0 07 ldub [ %l6 + 7 ], %o2 <== NOT EXECUTED
4000de8c: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
4000de90: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4000de94: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4000de98: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
4000de9c: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
return jffs2_scan_dirty_space(c, jeb,
4000dea0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
PAD(je32_to_cpu(ri->totlen)));
4000dea4: 94 12 80 01 or %o2, %g1, %o2 <== NOT EXECUTED
return jffs2_scan_dirty_space(c, jeb,
4000dea8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
PAD(je32_to_cpu(ri->totlen)));
4000deac: 94 02 a0 03 add %o2, 3, %o2 <== NOT EXECUTED
return jffs2_scan_dirty_space(c, jeb,
4000deb0: 7f ff e3 34 call 40006b80 <jffs2_scan_dirty_space> <== NOT EXECUTED
4000deb4: 94 0a bf fc and %o2, -4, %o2 <== NOT EXECUTED
if (err) return err;
4000deb8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000debc: 12 bf fd ae bne 4000d574 <jffs2_scan_medium+0x248> <== NOT EXECUTED
4000dec0: 01 00 00 00 nop <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
4000dec4: de 0d a0 04 ldub [ %l6 + 4 ], %o7 <== NOT EXECUTED
4000dec8: c8 0d a0 05 ldub [ %l6 + 5 ], %g4 <== NOT EXECUTED
4000decc: c6 0d a0 06 ldub [ %l6 + 6 ], %g3 <== NOT EXECUTED
4000ded0: c4 0d a0 07 ldub [ %l6 + 7 ], %g2 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000ded4: da 07 20 34 ld [ %i4 + 0x34 ], %o5 <== NOT EXECUTED
4000ded8: c2 06 e0 0c ld [ %i3 + 0xc ], %g1 <== NOT EXECUTED
break;
4000dedc: a0 10 00 1d mov %i5, %l0 <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
4000dee0: 9f 2b e0 18 sll %o7, 0x18, %o7 <== NOT EXECUTED
4000dee4: 89 29 20 10 sll %g4, 0x10, %g4 <== NOT EXECUTED
4000dee8: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
4000deec: 88 11 00 0f or %g4, %o7, %g4 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000def0: 82 03 40 01 add %o5, %g1, %g1 <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
4000def4: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED
4000def8: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
4000defc: 84 00 a0 03 add %g2, 3, %g2 <== NOT EXECUTED
4000df00: 84 08 bf fc and %g2, -4, %g2 <== NOT EXECUTED
break;
4000df04: 10 bf fd 53 b 4000d450 <jffs2_scan_medium+0x124> <== NOT EXECUTED
4000df08: ba 00 80 1d add %g2, %i5, %i5 <== NOT EXECUTED
pr_warn("Node at 0x%08x with length 0x%08x would run over the end of the erase block\n",
4000df0c: 11 10 00 83 sethi %hi(0x40020c00), %o0 <== NOT EXECUTED
4000df10: 7f ff fc 6d call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000df14: 90 12 23 98 or %o0, 0x398, %o0 ! 40020f98 <__func__.0+0x2c8> <== NOT EXECUTED
pr_warn("Perhaps the file system was created with the wrong erase size?\n");
4000df18: 11 10 00 83 sethi %hi(0x40020c00), %o0 <== NOT EXECUTED
4000df1c: 7f ff fc 6a call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000df20: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 40020ff0 <__func__.0+0x320> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, 4)))
4000df24: 10 bf fd 7e b 4000d51c <jffs2_scan_medium+0x1f0> <== NOT EXECUTED
4000df28: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED
if (!ref)
4000df2c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4000df30: 22 bf fd d5 be,a 4000d684 <jffs2_scan_medium+0x358> <== NOT EXECUTED
4000df34: c4 07 20 a8 ld [ %i4 + 0xa8 ], %g2 <== NOT EXECUTED
if (ref->flash_offset == REF_EMPTY_NODE)
4000df38: 10 bf ff 23 b 4000dbc4 <jffs2_scan_medium+0x898> <== NOT EXECUTED
4000df3c: c4 00 a0 04 ld [ %g2 + 4 ], %g2 <== NOT EXECUTED
if (je32_to_cpu(node->totlen) != c->cleanmarker_size) {
4000df40: d6 07 20 14 ld [ %i4 + 0x14 ], %o3 <== NOT EXECUTED
4000df44: 80 a2 80 0b cmp %o2, %o3 <== NOT EXECUTED
4000df48: 22 80 00 9c be,a 4000e1b8 <jffs2_scan_medium+0xe8c> <== NOT EXECUTED
4000df4c: c2 06 e0 28 ld [ %i3 + 0x28 ], %g1 <== NOT EXECUTED
pr_notice("CLEANMARKER node found at 0x%08x has totlen 0x%x != normal 0x%x\n",
4000df50: 11 10 00 84 sethi %hi(0x40021000), %o0 <== NOT EXECUTED
4000df54: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000df58: 7f ff fc 5b call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000df5c: 90 12 21 88 or %o0, 0x188, %o0 <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node)))))
4000df60: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
4000df64: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000df68: 7f ff e3 06 call 40006b80 <jffs2_scan_dirty_space> <== NOT EXECUTED
4000df6c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000df70: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000df74: 12 bf fd 80 bne 4000d574 <jffs2_scan_medium+0x248> <== NOT EXECUTED
4000df78: 01 00 00 00 nop <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000df7c: c4 07 20 34 ld [ %i4 + 0x34 ], %g2 <== NOT EXECUTED
4000df80: c2 06 e0 0c ld [ %i3 + 0xc ], %g1 <== NOT EXECUTED
4000df84: a0 10 00 1d mov %i5, %l0 <== NOT EXECUTED
4000df88: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
4000df8c: 10 bf fd 31 b 4000d450 <jffs2_scan_medium+0x124> <== NOT EXECUTED
4000df90: ba 10 00 17 mov %l7, %i5 <== NOT EXECUTED
if (buf_ofs + buf_len < ofs + je32_to_cpu(node->totlen)) {
4000df94: 84 06 00 19 add %i0, %i1, %g2 <== NOT EXECUTED
4000df98: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
4000df9c: 08 80 00 15 bleu 4000dff0 <jffs2_scan_medium+0xcc4> <== NOT EXECUTED
4000dfa0: 94 10 20 20 mov 0x20, %o2 <== NOT EXECUTED
buf_len = min_t(uint32_t, buf_size, jeb->offset + c->sector_size - ofs);
4000dfa4: b2 20 40 1d sub %g1, %i5, %i1 <== NOT EXECUTED
4000dfa8: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED
4000dfac: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
4000dfb0: 38 80 00 02 bgu,a 4000dfb8 <jffs2_scan_medium+0xc8c> <== NOT EXECUTED
4000dfb4: b2 10 00 01 mov %g1, %i1 <== NOT EXECUTED
ret = jffs2_flash_read(c, ofs, len, &retlen, buf);
4000dfb8: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
4000dfbc: 96 07 bf f0 add %fp, -16, %o3 <== NOT EXECUTED
4000dfc0: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
4000dfc4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000dfc8: 7f ff fb 9e call 4000ce40 <jffs2_flash_read> <== NOT EXECUTED
4000dfcc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (ret) {
4000dfd0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000dfd4: 12 bf fd 68 bne 4000d574 <jffs2_scan_medium+0x248> <== NOT EXECUTED
4000dfd8: c2 07 bf f0 ld [ %fp + -16 ], %g1 <== NOT EXECUTED
if (retlen < len) {
4000dfdc: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
4000dfe0: 18 bf ff 6a bgu 4000dd88 <jffs2_scan_medium+0xa5c> <== NOT EXECUTED
4000dfe4: ac 10 00 1a mov %i2, %l6 <== NOT EXECUTED
if (err)
4000dfe8: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
crc = crc32(0, rd, sizeof(*rd)-8);
4000dfec: 94 10 20 20 mov 0x20, %o2 <== NOT EXECUTED
4000dff0: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
4000dff4: 7f ff f6 e1 call 4000bb78 <cyg_crc32_accumulate> <== NOT EXECUTED
4000dff8: 90 10 20 00 clr %o0 <== NOT EXECUTED
if (crc != je32_to_cpu(rd->node_crc)) {
4000dffc: c6 0d a0 20 ldub [ %l6 + 0x20 ], %g3 <== NOT EXECUTED
4000e000: c4 0d a0 21 ldub [ %l6 + 0x21 ], %g2 <== NOT EXECUTED
4000e004: c2 0d a0 22 ldub [ %l6 + 0x22 ], %g1 <== NOT EXECUTED
4000e008: d6 0d a0 23 ldub [ %l6 + 0x23 ], %o3 <== NOT EXECUTED
4000e00c: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
4000e010: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4000e014: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4000e018: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
4000e01c: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
4000e020: 96 12 c0 01 or %o3, %g1, %o3 <== NOT EXECUTED
4000e024: 80 a2 00 0b cmp %o0, %o3 <== NOT EXECUTED
4000e028: 02 80 00 78 be 4000e208 <jffs2_scan_medium+0xedc> <== NOT EXECUTED
4000e02c: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
pr_notice("%s(): Node CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
4000e030: d2 07 bf e0 ld [ %fp + -32 ], %o1 <== NOT EXECUTED
4000e034: 11 10 00 84 sethi %hi(0x40021000), %o0 <== NOT EXECUTED
4000e038: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4000e03c: 7f ff fc 22 call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000e040: 90 12 20 90 or %o0, 0x90, %o0 <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
4000e044: c6 0d a0 04 ldub [ %l6 + 4 ], %g3 <== NOT EXECUTED
4000e048: c4 0d a0 05 ldub [ %l6 + 5 ], %g2 <== NOT EXECUTED
4000e04c: c2 0d a0 06 ldub [ %l6 + 6 ], %g1 <== NOT EXECUTED
4000e050: d4 0d a0 07 ldub [ %l6 + 7 ], %o2 <== NOT EXECUTED
4000e054: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
4000e058: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4000e05c: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4000e060: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
4000e064: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
4000e068: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000e06c: 94 12 80 01 or %o2, %g1, %o2 <== NOT EXECUTED
4000e070: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000e074: 94 02 a0 03 add %o2, 3, %o2 <== NOT EXECUTED
4000e078: 7f ff e2 c2 call 40006b80 <jffs2_scan_dirty_space> <== NOT EXECUTED
4000e07c: 94 0a bf fc and %o2, -4, %o2 <== NOT EXECUTED
4000e080: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
4000e084: 22 bf ff 0c be,a 4000dcb4 <jffs2_scan_medium+0x988> <== NOT EXECUTED
4000e088: de 0d a0 04 ldub [ %l6 + 4 ], %o7 <== NOT EXECUTED
4000e08c: 30 bf fd 3a b,a 4000d574 <jffs2_scan_medium+0x248> <== NOT EXECUTED
for (i=0; i<c->nr_blocks; i++) {
4000e090: 10 bf fd 50 b 4000d5d0 <jffs2_scan_medium+0x2a4> <== NOT EXECUTED
4000e094: 82 10 20 00 clr %g1 <== NOT EXECUTED
if (!(je16_to_cpu(node->nodetype) & JFFS2_NODE_ACCURATE)) {
4000e098: 92 10 00 04 mov %g4, %o1 <== NOT EXECUTED
return -EINVAL;
4000e09c: 84 10 3f ea mov -22, %g2 <== NOT EXECUTED
pr_notice("Incompatible feature node (0x%04x) found at offset 0x%08x\n",
4000e0a0: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
return -EINVAL;
4000e0a4: c4 27 bf ec st %g2, [ %fp + -20 ] <== NOT EXECUTED
pr_notice("Incompatible feature node (0x%04x) found at offset 0x%08x\n",
4000e0a8: 11 10 00 84 sethi %hi(0x40021000), %o0 <== NOT EXECUTED
4000e0ac: 7f ff fc 06 call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000e0b0: 90 12 22 78 or %o0, 0x278, %o0 ! 40021278 <__func__.0+0x5a8> <== NOT EXECUTED
if (ret < 0)
4000e0b4: 10 bf fe 33 b 4000d980 <jffs2_scan_medium+0x654> <== NOT EXECUTED
4000e0b8: c4 07 bf ec ld [ %fp + -20 ], %g2 <== NOT EXECUTED
switch (je16_to_cpu(node->nodetype) & JFFS2_COMPAT_MASK) {
4000e0bc: 84 08 80 03 and %g2, %g3, %g2 <== NOT EXECUTED
4000e0c0: 07 00 00 20 sethi %hi(0x8000), %g3 <== NOT EXECUTED
4000e0c4: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
4000e0c8: 02 80 00 93 be 4000e314 <jffs2_scan_medium+0xfe8> <== NOT EXECUTED
4000e0cc: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED
4000e0d0: 18 80 00 34 bgu 4000e1a0 <jffs2_scan_medium+0xe74> <== NOT EXECUTED
4000e0d4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4000e0d8: 02 bf fe ee be 4000dc90 <jffs2_scan_medium+0x964> <== NOT EXECUTED
4000e0dc: 07 00 00 10 sethi %hi(0x4000), %g3 <== NOT EXECUTED
4000e0e0: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
4000e0e4: 12 80 00 33 bne 4000e1b0 <jffs2_scan_medium+0xe84> <== NOT EXECUTED
4000e0e8: 96 02 a0 03 add %o2, 3, %o3 <== NOT EXECUTED
jffs2_link_node_ref(c, jeb, ofs | REF_PRISTINE, PAD(je32_to_cpu(node->totlen)), NULL);
4000e0ec: 98 10 20 00 clr %o4 <== NOT EXECUTED
4000e0f0: 94 17 60 02 or %i5, 2, %o2 <== NOT EXECUTED
4000e0f4: 96 0a ff fc and %o3, -4, %o3 <== NOT EXECUTED
4000e0f8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000e0fc: 7f ff e2 14 call 4000694c <jffs2_link_node_ref> <== NOT EXECUTED
4000e100: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
4000e104: 10 bf fe ec b 4000dcb4 <jffs2_scan_medium+0x988> <== NOT EXECUTED
4000e108: de 0d a0 04 ldub [ %l6 + 4 ], %o7 <== NOT EXECUTED
ic = jffs2_get_ino_cache(c, ino);
4000e10c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4000e110: 7f ff e1 22 call 40006598 <jffs2_get_ino_cache> <== NOT EXECUTED
4000e114: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (!ic) {
4000e118: 98 92 20 00 orcc %o0, 0, %o4 <== NOT EXECUTED
4000e11c: 02 80 00 77 be 4000e2f8 <jffs2_scan_medium+0xfcc> <== NOT EXECUTED
4000e120: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
jffs2_link_node_ref(c, jeb, ofs | REF_UNCHECKED, PAD(je32_to_cpu(ri->totlen)), ic);
4000e124: c6 0d a0 04 ldub [ %l6 + 4 ], %g3 <== NOT EXECUTED
4000e128: c4 0d a0 05 ldub [ %l6 + 5 ], %g2 <== NOT EXECUTED
4000e12c: c2 0d a0 06 ldub [ %l6 + 6 ], %g1 <== NOT EXECUTED
4000e130: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
4000e134: d6 0d a0 07 ldub [ %l6 + 7 ], %o3 <== NOT EXECUTED
4000e138: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
4000e13c: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4000e140: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
4000e144: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
4000e148: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4000e14c: 96 12 c0 01 or %o3, %g1, %o3 <== NOT EXECUTED
4000e150: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000e154: 96 02 e0 03 add %o3, 3, %o3 <== NOT EXECUTED
4000e158: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000e15c: 7f ff e1 fc call 4000694c <jffs2_link_node_ref> <== NOT EXECUTED
4000e160: 96 0a ff fc and %o3, -4, %o3 <== NOT EXECUTED
pseudo_random += je32_to_cpu(ri->version);
4000e164: c8 0d a0 10 ldub [ %l6 + 0x10 ], %g4 <== NOT EXECUTED
4000e168: c6 0d a0 11 ldub [ %l6 + 0x11 ], %g3 <== NOT EXECUTED
4000e16c: c4 0d a0 12 ldub [ %l6 + 0x12 ], %g2 <== NOT EXECUTED
4000e170: c2 0d a0 13 ldub [ %l6 + 0x13 ], %g1 <== NOT EXECUTED
4000e174: 1f 10 01 1c sethi %hi(0x40047000), %o7 <== NOT EXECUTED
4000e178: da 03 e3 9c ld [ %o7 + 0x39c ], %o5 ! 4004739c <pseudo_random> <== NOT EXECUTED
4000e17c: 89 29 20 18 sll %g4, 0x18, %g4 <== NOT EXECUTED
4000e180: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED
4000e184: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
4000e188: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED
4000e18c: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
4000e190: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
4000e194: 82 00 40 0d add %g1, %o5, %g1 <== NOT EXECUTED
4000e198: 10 bf ff 4b b 4000dec4 <jffs2_scan_medium+0xb98> <== NOT EXECUTED
4000e19c: c2 23 e3 9c st %g1, [ %o7 + 0x39c ] <== NOT EXECUTED
4000e1a0: 07 00 00 30 sethi %hi(0xc000), %g3 <== NOT EXECUTED
4000e1a4: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
4000e1a8: 02 bf ff be be 4000e0a0 <jffs2_scan_medium+0xd74> <== NOT EXECUTED
4000e1ac: 84 10 3f ea mov -22, %g2 <== NOT EXECUTED
4000e1b0: 10 bf fc a8 b 4000d450 <jffs2_scan_medium+0x124> <== NOT EXECUTED
4000e1b4: a0 10 00 1d mov %i5, %l0 <== NOT EXECUTED
} else if (jeb->first_node) {
4000e1b8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000e1bc: 02 80 00 63 be 4000e348 <jffs2_scan_medium+0x101c> <== NOT EXECUTED
4000e1c0: 94 10 00 0f mov %o7, %o2 <== NOT EXECUTED
pr_notice("CLEANMARKER node found at 0x%08x, not first node in block (0x%08x)\n",
4000e1c4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000e1c8: 11 10 00 84 sethi %hi(0x40021000), %o0 <== NOT EXECUTED
4000e1cc: 7f ff fb be call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000e1d0: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 400211d8 <__func__.0+0x508> <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, PAD(sizeof(struct jffs2_unknown_node)))))
4000e1d4: 10 bf ff 64 b 4000df64 <jffs2_scan_medium+0xc38> <== NOT EXECUTED
4000e1d8: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
pr_warn("%s(): unknown block state\n", __func__);
4000e1dc: 11 10 00 84 sethi %hi(0x40021000), %o0 <== NOT EXECUTED
4000e1e0: 92 17 60 18 or %i5, 0x18, %o1 <== NOT EXECUTED
4000e1e4: 7f ff fb b8 call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000e1e8: 90 12 22 c0 or %o0, 0x2c0, %o0 <== NOT EXECUTED
BUG();
4000e1ec: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
4000e1f0: 11 10 00 84 sethi %hi(0x40021000), %o0 <== NOT EXECUTED
4000e1f4: 94 17 60 18 or %i5, 0x18, %o2 <== NOT EXECUTED
4000e1f8: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
4000e1fc: 92 10 20 f1 mov 0xf1, %o1 <== NOT EXECUTED
4000e200: 40 00 01 de call 4000e978 <__assert_func> <== NOT EXECUTED
4000e204: 90 12 22 e8 or %o0, 0x2e8, %o0 <== NOT EXECUTED
pseudo_random += je32_to_cpu(rd->version);
4000e208: da 0d a0 10 ldub [ %l6 + 0x10 ], %o5 <== NOT EXECUTED
4000e20c: c6 0d a0 11 ldub [ %l6 + 0x11 ], %g3 <== NOT EXECUTED
4000e210: c4 0d a0 12 ldub [ %l6 + 0x12 ], %g2 <== NOT EXECUTED
4000e214: c2 0d a0 13 ldub [ %l6 + 0x13 ], %g1 <== NOT EXECUTED
4000e218: 09 10 01 1c sethi %hi(0x40047000), %g4 <== NOT EXECUTED
4000e21c: de 01 23 9c ld [ %g4 + 0x39c ], %o7 ! 4004739c <pseudo_random> <== NOT EXECUTED
checkedlen = strnlen(rd->name, rd->nsize);
4000e220: e0 0d a0 1c ldub [ %l6 + 0x1c ], %l0 <== NOT EXECUTED
pseudo_random += je32_to_cpu(rd->version);
4000e224: 9b 2b 60 18 sll %o5, 0x18, %o5 <== NOT EXECUTED
4000e228: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED
4000e22c: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
4000e230: 86 10 c0 0d or %g3, %o5, %g3 <== NOT EXECUTED
4000e234: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
4000e238: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED
4000e23c: 82 00 40 0f add %g1, %o7, %g1 <== NOT EXECUTED
checkedlen = strnlen(rd->name, rd->nsize);
4000e240: 90 05 a0 28 add %l6, 0x28, %o0 <== NOT EXECUTED
pseudo_random += je32_to_cpu(rd->version);
4000e244: c2 21 23 9c st %g1, [ %g4 + 0x39c ] <== NOT EXECUTED
checkedlen = strnlen(rd->name, rd->nsize);
4000e248: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4000e24c: 40 00 3c d3 call 4001d598 <strnlen> <== NOT EXECUTED
4000e250: d0 27 bf d4 st %o0, [ %fp + -44 ] <== NOT EXECUTED
if (checkedlen < rd->nsize) {
4000e254: 80 a4 00 08 cmp %l0, %o0 <== NOT EXECUTED
4000e258: 18 80 00 ac bgu 4000e508 <jffs2_scan_medium+0x11dc> <== NOT EXECUTED
4000e25c: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
fd = jffs2_alloc_full_dirent(checkedlen+1);
4000e260: 7f ff de 47 call 40005b7c <jffs2_alloc_full_dirent> <== NOT EXECUTED
4000e264: 90 05 e0 01 add %l7, 1, %o0 <== NOT EXECUTED
if (!fd) {
4000e268: a0 92 20 00 orcc %o0, 0, %l0 <== NOT EXECUTED
4000e26c: 02 80 00 28 be 4000e30c <jffs2_scan_medium+0xfe0> <== NOT EXECUTED
4000e270: d2 07 bf d4 ld [ %fp + -44 ], %o1 <== NOT EXECUTED
memcpy(&fd->name, rd->name, checkedlen);
4000e274: 84 04 20 15 add %l0, 0x15, %g2 <== NOT EXECUTED
4000e278: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
4000e27c: 40 00 3b 2b call 4001cf28 <memcpy> <== NOT EXECUTED
4000e280: 94 10 00 17 mov %l7, %o2 <== NOT EXECUTED
fd->name[checkedlen] = 0;
4000e284: 86 04 00 17 add %l0, %l7, %g3 <== NOT EXECUTED
4000e288: c0 28 e0 15 clrb [ %g3 + 0x15 ] <== NOT EXECUTED
crc = crc32(0, fd->name, rd->nsize);
4000e28c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
4000e290: d4 0d a0 1c ldub [ %l6 + 0x1c ], %o2 <== NOT EXECUTED
4000e294: d0 27 bf d4 st %o0, [ %fp + -44 ] <== NOT EXECUTED
4000e298: 7f ff f6 38 call 4000bb78 <cyg_crc32_accumulate> <== NOT EXECUTED
4000e29c: 90 10 20 00 clr %o0 <== NOT EXECUTED
if (crc != je32_to_cpu(rd->name_crc)) {
4000e2a0: de 0d a0 24 ldub [ %l6 + 0x24 ], %o7 <== NOT EXECUTED
4000e2a4: c8 0d a0 25 ldub [ %l6 + 0x25 ], %g4 <== NOT EXECUTED
4000e2a8: c6 0d a0 26 ldub [ %l6 + 0x26 ], %g3 <== NOT EXECUTED
4000e2ac: d6 0d a0 27 ldub [ %l6 + 0x27 ], %o3 <== NOT EXECUTED
4000e2b0: 9f 2b e0 18 sll %o7, 0x18, %o7 <== NOT EXECUTED
4000e2b4: 89 29 20 10 sll %g4, 0x10, %g4 <== NOT EXECUTED
4000e2b8: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
4000e2bc: 88 11 00 0f or %g4, %o7, %g4 <== NOT EXECUTED
4000e2c0: c4 07 bf d4 ld [ %fp + -44 ], %g2 <== NOT EXECUTED
4000e2c4: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED
4000e2c8: 96 12 c0 03 or %o3, %g3, %o3 <== NOT EXECUTED
4000e2cc: 80 a2 00 0b cmp %o0, %o3 <== NOT EXECUTED
4000e2d0: 02 80 00 2c be 4000e380 <jffs2_scan_medium+0x1054> <== NOT EXECUTED
4000e2d4: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
pr_notice("%s(): Name CRC failed on node at 0x%08x: Read 0x%08x, calculated 0x%08x\n",
4000e2d8: d2 07 bf e0 ld [ %fp + -32 ], %o1 <== NOT EXECUTED
4000e2dc: d0 07 bf dc ld [ %fp + -36 ], %o0 <== NOT EXECUTED
4000e2e0: 7f ff fb 79 call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000e2e4: 94 10 00 1d mov %i5, %o2 <== 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);
4000e2e8: 7f ff de 29 call 40005b8c <jffs2_free_full_dirent> <== NOT EXECUTED
4000e2ec: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
if ((err = jffs2_scan_dirty_space(c, jeb, PAD(je32_to_cpu(node->totlen)))))
4000e2f0: 10 bf ff 56 b 4000e048 <jffs2_scan_medium+0xd1c> <== NOT EXECUTED
4000e2f4: c6 0d a0 04 ldub [ %l6 + 4 ], %g3 <== NOT EXECUTED
ic = jffs2_scan_make_ino_cache(c, ino);
4000e2f8: 7f ff fb e3 call 4000d284 <jffs2_scan_make_ino_cache> <== NOT EXECUTED
4000e2fc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (!ic)
4000e300: 98 92 20 00 orcc %o0, 0, %o4 <== NOT EXECUTED
4000e304: 32 bf ff 89 bne,a 4000e128 <jffs2_scan_medium+0xdfc> <== NOT EXECUTED
4000e308: c6 0d a0 04 ldub [ %l6 + 4 ], %g3 <== NOT EXECUTED
return -ENOMEM;
4000e30c: 10 bf fd 9d b 4000d980 <jffs2_scan_medium+0x654> <== NOT EXECUTED
4000e310: 84 10 3f f4 mov -12, %g2 <== NOT EXECUTED
pr_notice("Read-only compatible feature node (0x%04x) found at offset 0x%08x\n",
4000e314: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
4000e318: 11 10 00 84 sethi %hi(0x40021000), %o0 <== NOT EXECUTED
4000e31c: 7f ff fb 6a call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000e320: 90 12 22 28 or %o0, 0x228, %o0 ! 40021228 <__func__.0+0x558> <== NOT EXECUTED
c->flags |= JFFS2_SB_FLAG_RO;
4000e324: c2 07 20 0c ld [ %i4 + 0xc ], %g1 <== NOT EXECUTED
4000e328: 82 10 60 01 or %g1, 1, %g1 <== NOT EXECUTED
4000e32c: c2 27 20 0c st %g1, [ %i4 + 0xc ] <== NOT EXECUTED
if (!(jffs2_is_readonly(c)))
4000e330: c2 0f 20 ec ldub [ %i4 + 0xec ], %g1 <== NOT EXECUTED
4000e334: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000e338: 32 bf ff 44 bne,a 4000e048 <jffs2_scan_medium+0xd1c> <== NOT EXECUTED
4000e33c: c6 0d a0 04 ldub [ %l6 + 4 ], %g3 <== NOT EXECUTED
return -EROFS;
4000e340: 10 bf fd 90 b 4000d980 <jffs2_scan_medium+0x654> <== NOT EXECUTED
4000e344: 84 10 3f e2 mov -30, %g2 <== NOT EXECUTED
jffs2_link_node_ref(c, jeb, ofs | REF_NORMAL, c->cleanmarker_size, NULL);
4000e348: 94 17 60 03 or %i5, 3, %o2 <== NOT EXECUTED
4000e34c: 98 10 20 00 clr %o4 <== NOT EXECUTED
4000e350: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000e354: 7f ff e1 7e call 4000694c <jffs2_link_node_ref> <== NOT EXECUTED
4000e358: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
ofs += PAD(c->cleanmarker_size);
4000e35c: c4 07 20 14 ld [ %i4 + 0x14 ], %g2 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000e360: c6 07 20 34 ld [ %i4 + 0x34 ], %g3 <== NOT EXECUTED
4000e364: c2 06 e0 0c ld [ %i3 + 0xc ], %g1 <== NOT EXECUTED
ofs += PAD(c->cleanmarker_size);
4000e368: 84 00 a0 03 add %g2, 3, %g2 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000e36c: a0 10 00 1d mov %i5, %l0 <== NOT EXECUTED
ofs += PAD(c->cleanmarker_size);
4000e370: 84 08 bf fc and %g2, -4, %g2 <== NOT EXECUTED
while(ofs < jeb->offset + c->sector_size) {
4000e374: 82 00 c0 01 add %g3, %g1, %g1 <== NOT EXECUTED
ofs += PAD(c->cleanmarker_size);
4000e378: 10 bf fc 36 b 4000d450 <jffs2_scan_medium+0x124> <== NOT EXECUTED
4000e37c: ba 00 80 1d add %g2, %i5, %i5 <== 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));
4000e380: c4 27 bf d4 st %g2, [ %fp + -44 ] <== NOT EXECUTED
4000e384: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000e388: de 0d a0 0c ldub [ %l6 + 0xc ], %o7 <== NOT EXECUTED
4000e38c: c8 0d a0 0d ldub [ %l6 + 0xd ], %g4 <== NOT EXECUTED
4000e390: c6 0d a0 0e ldub [ %l6 + 0xe ], %g3 <== NOT EXECUTED
4000e394: d2 0d a0 0f ldub [ %l6 + 0xf ], %o1 <== NOT EXECUTED
4000e398: 9f 2b e0 18 sll %o7, 0x18, %o7 <== NOT EXECUTED
4000e39c: 89 29 20 10 sll %g4, 0x10, %g4 <== NOT EXECUTED
4000e3a0: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
4000e3a4: 88 11 00 0f or %g4, %o7, %g4 <== NOT EXECUTED
4000e3a8: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED
4000e3ac: 7f ff fb b6 call 4000d284 <jffs2_scan_make_ino_cache> <== NOT EXECUTED
4000e3b0: 92 12 40 03 or %o1, %g3, %o1 <== NOT EXECUTED
if (!ic) {
4000e3b4: 82 92 20 00 orcc %o0, 0, %g1 <== NOT EXECUTED
4000e3b8: 02 80 00 59 be 4000e51c <jffs2_scan_medium+0x11f0> <== NOT EXECUTED
4000e3bc: c4 07 bf d4 ld [ %fp + -44 ], %g2 <== NOT EXECUTED
jffs2_free_full_dirent(fd);
return -ENOMEM;
}
fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
4000e3c0: c4 27 bf d0 st %g2, [ %fp + -48 ] <== NOT EXECUTED
4000e3c4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
4000e3c8: d4 0d a0 17 ldub [ %l6 + 0x17 ], %o2 <== NOT EXECUTED
4000e3cc: d2 0d a0 14 ldub [ %l6 + 0x14 ], %o1 <== NOT EXECUTED
4000e3d0: da 0d a0 15 ldub [ %l6 + 0x15 ], %o5 <== NOT EXECUTED
4000e3d4: de 0d a0 16 ldub [ %l6 + 0x16 ], %o7 <== NOT EXECUTED
PAD(je32_to_cpu(rd->totlen)), ic);
4000e3d8: d8 0d a0 04 ldub [ %l6 + 4 ], %o4 <== NOT EXECUTED
4000e3dc: c8 0d a0 05 ldub [ %l6 + 5 ], %g4 <== NOT EXECUTED
4000e3e0: c6 0d a0 06 ldub [ %l6 + 6 ], %g3 <== NOT EXECUTED
4000e3e4: d6 0d a0 07 ldub [ %l6 + 7 ], %o3 <== NOT EXECUTED
fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
4000e3e8: 93 2a 60 18 sll %o1, 0x18, %o1 <== NOT EXECUTED
PAD(je32_to_cpu(rd->totlen)), ic);
4000e3ec: 99 2b 20 18 sll %o4, 0x18, %o4 <== NOT EXECUTED
fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
4000e3f0: 9b 2b 60 10 sll %o5, 0x10, %o5 <== NOT EXECUTED
4000e3f4: 9f 2b e0 08 sll %o7, 8, %o7 <== NOT EXECUTED
4000e3f8: 9a 13 40 09 or %o5, %o1, %o5 <== NOT EXECUTED
PAD(je32_to_cpu(rd->totlen)), ic);
4000e3fc: 89 29 20 10 sll %g4, 0x10, %g4 <== NOT EXECUTED
fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
4000e400: 9e 13 c0 0d or %o7, %o5, %o7 <== NOT EXECUTED
PAD(je32_to_cpu(rd->totlen)), ic);
4000e404: 88 11 00 0c or %g4, %o4, %g4 <== NOT EXECUTED
fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
4000e408: 9e 12 80 0f or %o2, %o7, %o7 <== NOT EXECUTED
PAD(je32_to_cpu(rd->totlen)), ic);
4000e40c: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
4000e410: 80 a0 00 0f cmp %g0, %o7 <== NOT EXECUTED
PAD(je32_to_cpu(rd->totlen)), ic);
4000e414: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED
fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
4000e418: 94 60 3f ff subx %g0, -1, %o2 <== NOT EXECUTED
PAD(je32_to_cpu(rd->totlen)), ic);
4000e41c: 96 12 c0 03 or %o3, %g3, %o3 <== NOT EXECUTED
fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
4000e420: c2 27 bf d4 st %g1, [ %fp + -44 ] <== NOT EXECUTED
4000e424: 98 10 00 01 mov %g1, %o4 <== NOT EXECUTED
4000e428: 94 02 a0 02 add %o2, 2, %o2 <== NOT EXECUTED
4000e42c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000e430: 94 12 80 1d or %o2, %i5, %o2 <== NOT EXECUTED
PAD(je32_to_cpu(rd->totlen)), ic);
4000e434: 96 02 e0 03 add %o3, 3, %o3 <== NOT EXECUTED
fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
4000e438: 7f ff e1 45 call 4000694c <jffs2_link_node_ref> <== NOT EXECUTED
4000e43c: 96 0a ff fc and %o3, -4, %o3 <== NOT EXECUTED
fd->next = NULL;
4000e440: c0 24 20 04 clr [ %l0 + 4 ] <== NOT EXECUTED
while (len--) {
4000e444: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED
fd->raw = jffs2_link_node_ref(c, jeb, ofs | dirent_node_state(rd),
4000e448: d0 24 00 00 st %o0, [ %l0 ] <== NOT EXECUTED
fd->version = je32_to_cpu(rd->version);
4000e44c: de 0d a0 13 ldub [ %l6 + 0x13 ], %o7 <== NOT EXECUTED
4000e450: da 0d a0 10 ldub [ %l6 + 0x10 ], %o5 <== NOT EXECUTED
4000e454: c8 0d a0 11 ldub [ %l6 + 0x11 ], %g4 <== NOT EXECUTED
4000e458: c6 0d a0 12 ldub [ %l6 + 0x12 ], %g3 <== NOT EXECUTED
4000e45c: 9b 2b 60 18 sll %o5, 0x18, %o5 <== NOT EXECUTED
4000e460: 89 29 20 10 sll %g4, 0x10, %g4 <== NOT EXECUTED
4000e464: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
4000e468: 88 11 00 0d or %g4, %o5, %g4 <== NOT EXECUTED
4000e46c: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED
4000e470: 86 13 c0 03 or %o7, %g3, %g3 <== NOT EXECUTED
4000e474: c6 24 20 08 st %g3, [ %l0 + 8 ] <== NOT EXECUTED
fd->ino = je32_to_cpu(rd->ino);
4000e478: da 0d a0 14 ldub [ %l6 + 0x14 ], %o5 <== NOT EXECUTED
4000e47c: c8 0d a0 15 ldub [ %l6 + 0x15 ], %g4 <== NOT EXECUTED
4000e480: c6 0d a0 16 ldub [ %l6 + 0x16 ], %g3 <== NOT EXECUTED
4000e484: de 0d a0 17 ldub [ %l6 + 0x17 ], %o7 <== NOT EXECUTED
4000e488: 9b 2b 60 18 sll %o5, 0x18, %o5 <== NOT EXECUTED
4000e48c: 89 29 20 10 sll %g4, 0x10, %g4 <== NOT EXECUTED
4000e490: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
4000e494: 88 11 00 0d or %g4, %o5, %g4 <== NOT EXECUTED
4000e498: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED
4000e49c: 86 13 c0 03 or %o7, %g3, %g3 <== NOT EXECUTED
4000e4a0: c6 24 20 0c st %g3, [ %l0 + 0xc ] <== NOT EXECUTED
4000e4a4: 02 80 00 10 be 4000e4e4 <jffs2_scan_medium+0x11b8> <== NOT EXECUTED
4000e4a8: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED
4000e4ac: c4 07 bf d0 ld [ %fp + -48 ], %g2 <== NOT EXECUTED
4000e4b0: 86 05 e0 15 add %l7, 0x15, %g3 <== NOT EXECUTED
uint32_t hash = 0;
4000e4b4: ae 10 20 00 clr %l7 <== NOT EXECUTED
4000e4b8: 86 04 00 03 add %l0, %g3, %g3 <== NOT EXECUTED
4000e4bc: 88 10 00 17 mov %l7, %g4 <== NOT EXECUTED
hash ^= *(name++);
4000e4c0: de 08 80 00 ldub [ %g2 ], %o7 <== NOT EXECUTED
hash = (hash << 4) | (hash >> 28);
4000e4c4: 9b 29 20 04 sll %g4, 4, %o5 <== NOT EXECUTED
hash ^= *(name++);
4000e4c8: 84 00 a0 01 inc %g2 <== NOT EXECUTED
hash = (hash << 4) | (hash >> 28);
4000e4cc: 89 31 20 1c srl %g4, 0x1c, %g4 <== NOT EXECUTED
while (len--) {
4000e4d0: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
hash = (hash << 4) | (hash >> 28);
4000e4d4: 88 11 00 0d or %g4, %o5, %g4 <== NOT EXECUTED
while (len--) {
4000e4d8: 12 bf ff fa bne 4000e4c0 <jffs2_scan_medium+0x1194> <== NOT EXECUTED
4000e4dc: 88 1b c0 04 xor %o7, %g4, %g4 <== NOT EXECUTED
4000e4e0: ae 10 00 04 mov %g4, %l7 <== NOT EXECUTED
fd->nhash = full_name_hash(NULL, fd->name, checkedlen);
4000e4e4: ee 24 20 10 st %l7, [ %l0 + 0x10 ] <== NOT EXECUTED
fd->type = rd->type;
jffs2_add_fd_to_list(c, fd, &ic->scan_dents);
4000e4e8: 94 10 00 01 mov %g1, %o2 <== NOT EXECUTED
fd->type = rd->type;
4000e4ec: c4 0d a0 1d ldub [ %l6 + 0x1d ], %g2 <== NOT EXECUTED
4000e4f0: c4 2c 20 14 stb %g2, [ %l0 + 0x14 ] <== NOT EXECUTED
jffs2_add_fd_to_list(c, fd, &ic->scan_dents);
4000e4f4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4000e4f8: 7f ff de 4f call 40005e34 <jffs2_add_fd_to_list> <== NOT EXECUTED
4000e4fc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
ofs += PAD(je32_to_cpu(node->totlen));
4000e500: 10 bf fd ed b 4000dcb4 <jffs2_scan_medium+0x988> <== NOT EXECUTED
4000e504: de 0d a0 04 ldub [ %l6 + 4 ], %o7 <== NOT EXECUTED
pr_err("Dirent at %08x has zeroes in name. Truncating to %d chars\n",
4000e508: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
4000e50c: d0 07 bf d8 ld [ %fp + -40 ], %o0 <== NOT EXECUTED
4000e510: 7f ff fa ed call 4000d0c4 <jffs2_printk> <== NOT EXECUTED
4000e514: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
4000e518: 30 bf ff 52 b,a 4000e260 <jffs2_scan_medium+0xf34> <== NOT EXECUTED
return -ENOMEM;
4000e51c: 84 10 3f f4 mov -12, %g2 <== NOT EXECUTED
jffs2_free_full_dirent(fd);
4000e520: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4000e524: 7f ff dd 9a call 40005b8c <jffs2_free_full_dirent> <== NOT EXECUTED
4000e528: c4 27 bf ec st %g2, [ %fp + -20 ] <== NOT EXECUTED
if (err) return err;
4000e52c: 10 bf fd 15 b 4000d980 <jffs2_scan_medium+0x654> <== NOT EXECUTED
4000e530: c4 07 bf ec ld [ %fp + -20 ], %g2 <== NOT EXECUTED
40007900 <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) ||
40007900: c6 02 20 a0 ld [ %o0 + 0xa0 ], %g3
40007904: 84 02 20 a0 add %o0, 0xa0, %g2
{
40007908: 82 10 00 08 mov %o0, %g1
if (!list_empty(&c->erase_complete_list) ||
4000790c: 80 a0 c0 02 cmp %g3, %g2
40007910: 12 80 00 2c bne 400079c0 <jffs2_thread_should_wake+0xc0> <== NEVER TAKEN
40007914: 90 10 20 01 mov 1, %o0
40007918: c6 00 60 98 ld [ %g1 + 0x98 ], %g3
!list_empty(&c->erase_pending_list))
4000791c: 84 00 60 98 add %g1, 0x98, %g2
if (!list_empty(&c->erase_complete_list) ||
40007920: 80 a0 c0 02 cmp %g3, %g2
40007924: 12 80 00 27 bne 400079c0 <jffs2_thread_should_wake+0xc0>
40007928: 01 00 00 00 nop
return 1;
if (c->unchecked_size) {
4000792c: c4 00 60 38 ld [ %g1 + 0x38 ], %g2
40007930: 80 a0 a0 00 cmp %g2, 0
40007934: 12 80 00 23 bne 400079c0 <jffs2_thread_should_wake+0xc0> <== NEVER TAKEN
40007938: 01 00 00 00 nop
* but it is counted in c->nr_erasing_blocks, so we add it and subtract it
* with c->nr_erasing_blocks * c->sector_size again.
* 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;
4000793c: c6 00 60 40 ld [ %g1 + 0x40 ], %g3
if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger &&
40007940: c4 00 60 3c ld [ %g1 + 0x3c ], %g2
40007944: c8 08 60 46 ldub [ %g1 + 0x46 ], %g4
40007948: 84 00 c0 02 add %g3, %g2, %g2
4000794c: 80 a0 80 04 cmp %g2, %g4
40007950: 1a 80 00 0b bcc 4000797c <jffs2_thread_should_wake+0x7c> <== ALWAYS TAKEN
40007954: 90 10 20 00 clr %o0
dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size;
40007958: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 <== NOT EXECUTED
4000795c: d8 00 60 2c ld [ %g1 + 0x2c ], %o4 <== NOT EXECUTED
40007960: da 00 60 34 ld [ %g1 + 0x34 ], %o5 <== NOT EXECUTED
if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger &&
40007964: c8 00 60 4c ld [ %g1 + 0x4c ], %g4 <== NOT EXECUTED
dirty = c->dirty_size + c->erasing_size - c->nr_erasing_blocks * c->sector_size;
40007968: 84 00 80 0c add %g2, %o4, %g2 <== NOT EXECUTED
4000796c: 86 58 c0 0d smul %g3, %o5, %g3 <== NOT EXECUTED
40007970: 86 20 80 03 sub %g2, %g3, %g3 <== NOT EXECUTED
if (c->nr_free_blocks + c->nr_erasing_blocks < c->resv_blocks_gctrigger &&
40007974: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED
40007978: 90 40 20 00 addx %g0, 0, %o0 <== NOT EXECUTED
(dirty > c->nospc_dirty_size))
ret = 1;
list_for_each_entry(jeb, &c->very_dirty_list, list) {
4000797c: c4 00 60 68 ld [ %g1 + 0x68 ], %g2
40007980: 86 00 60 68 add %g1, 0x68, %g3
40007984: 80 a0 80 03 cmp %g2, %g3
40007988: 02 80 00 0e be 400079c0 <jffs2_thread_should_wake+0xc0> <== NEVER TAKEN
4000798c: 01 00 00 00 nop
nr_very_dirty++;
if (nr_very_dirty == c->vdirty_blocks_gctrigger) {
40007990: c8 08 60 49 ldub [ %g1 + 0x49 ], %g4
int nr_very_dirty = 0;
40007994: 10 80 00 05 b 400079a8 <jffs2_thread_should_wake+0xa8>
40007998: 82 10 20 00 clr %g1
list_for_each_entry(jeb, &c->very_dirty_list, list) {
4000799c: 80 a0 80 03 cmp %g2, %g3
400079a0: 02 80 00 08 be 400079c0 <jffs2_thread_should_wake+0xc0>
400079a4: 01 00 00 00 nop
nr_very_dirty++;
400079a8: 82 00 60 01 inc %g1
if (nr_very_dirty == c->vdirty_blocks_gctrigger) {
400079ac: 80 a1 00 01 cmp %g4, %g1
400079b0: 32 bf ff fb bne,a 4000799c <jffs2_thread_should_wake+0x9c> <== ALWAYS TAKEN
400079b4: c4 00 80 00 ld [ %g2 ], %g2
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;
}
400079b8: 81 c3 e0 08 retl <== NOT EXECUTED
400079bc: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
400079c0: 81 c3 e0 08 retl
400079c4: 01 00 00 00 nop
40005f04 <jffs2_truncate_fragtree>:
{
40005f04: 9d e3 bf a0 save %sp, -96, %sp
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;
40005f08: c2 06 40 00 ld [ %i1 ], %g1
while(next) {
40005f0c: 80 a0 60 00 cmp %g1, 0
40005f10: 02 80 00 37 be 40005fec <jffs2_truncate_fragtree+0xe8>
40005f14: ba 10 20 00 clr %i5
frag = rb_entry(next, struct jffs2_node_frag, rb);
if (frag->ofs + frag->size <= offset) {
40005f18: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
40005f1c: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
40005f20: 86 00 80 03 add %g2, %g3, %g3
40005f24: 80 a6 80 03 cmp %i2, %g3
40005f28: 0a 80 00 36 bcs 40006000 <jffs2_truncate_fragtree+0xfc>
40005f2c: 80 a6 80 02 cmp %i2, %g2
/* Remember the closest smaller match on the way down */
if (!prev || frag->ofs > prev->ofs)
40005f30: 80 a7 60 00 cmp %i5, 0
40005f34: 22 80 00 06 be,a 40005f4c <jffs2_truncate_fragtree+0x48>
40005f38: ba 10 00 01 mov %g1, %i5
40005f3c: c6 07 60 18 ld [ %i5 + 0x18 ], %g3
40005f40: 80 a0 80 03 cmp %g2, %g3
40005f44: 38 80 00 02 bgu,a 40005f4c <jffs2_truncate_fragtree+0x48> <== ALWAYS TAKEN
40005f48: ba 10 00 01 mov %g1, %i5
prev = frag;
next = frag->rb.rb_right;
40005f4c: c2 00 60 04 ld [ %g1 + 4 ], %g1
while(next) {
40005f50: 80 a0 60 00 cmp %g1, 0
40005f54: 32 bf ff f2 bne,a 40005f1c <jffs2_truncate_fragtree+0x18>
40005f58: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
if (frag && frag->ofs != size) {
40005f5c: 80 a7 60 00 cmp %i5, 0
40005f60: 02 80 00 24 be 40005ff0 <jffs2_truncate_fragtree+0xec> <== NEVER TAKEN
40005f64: 80 a6 a0 00 cmp %i2, 0
40005f68: c4 07 60 18 ld [ %i5 + 0x18 ], %g2
40005f6c: 80 a0 80 1a cmp %g2, %i2
40005f70: 02 80 00 1d be 40005fe4 <jffs2_truncate_fragtree+0xe0> <== NEVER TAKEN
40005f74: 80 a6 80 02 cmp %i2, %g2
if (frag->ofs+frag->size > size) {
40005f78: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40005f7c: 82 00 80 01 add %g2, %g1, %g1
40005f80: 80 a0 40 1a cmp %g1, %i2
40005f84: 18 80 00 40 bgu 40006084 <jffs2_truncate_fragtree+0x180> <== NEVER TAKEN
40005f88: 82 10 00 1d mov %i5, %g1
return _RBTree_Successor( node );
40005f8c: 40 00 3e 9a call 400159f4 <_RBTree_Successor>
40005f90: 90 10 00 1d mov %i5, %o0
while (frag && frag->ofs >= size) {
40005f94: ba 92 20 00 orcc %o0, 0, %i5
40005f98: 02 80 00 16 be 40005ff0 <jffs2_truncate_fragtree+0xec> <== ALWAYS TAKEN
40005f9c: 80 a6 a0 00 cmp %i2, 0
40005fa0: 10 80 00 10 b 40005fe0 <jffs2_truncate_fragtree+0xdc> <== NOT EXECUTED
40005fa4: c4 07 60 18 ld [ %i5 + 0x18 ], %g2 <== NOT EXECUTED
40005fa8: 40 00 3e 93 call 400159f4 <_RBTree_Successor>
40005fac: 01 00 00 00 nop
_RBTree_Extract( (RBTree_Control *) root, node );
40005fb0: 92 10 00 1d mov %i5, %o1
return _RBTree_Successor( node );
40005fb4: b8 10 00 08 mov %o0, %i4
_RBTree_Extract( (RBTree_Control *) root, node );
40005fb8: 40 00 3c 78 call 40015198 <_RBTree_Extract>
40005fbc: 90 10 00 19 mov %i1, %o0
jffs2_obsolete_node_frag(c, frag);
40005fc0: 92 10 00 1d mov %i5, %o1
40005fc4: 7f ff ff 54 call 40005d14 <jffs2_obsolete_node_frag>
40005fc8: 90 10 00 18 mov %i0, %o0
while (frag && frag->ofs >= size) {
40005fcc: 80 a7 20 00 cmp %i4, 0
40005fd0: 02 80 00 08 be 40005ff0 <jffs2_truncate_fragtree+0xec>
40005fd4: 80 a6 a0 00 cmp %i2, 0
40005fd8: c4 07 20 18 ld [ %i4 + 0x18 ], %g2
40005fdc: ba 10 00 1c mov %i4, %i5
40005fe0: 80 a6 80 02 cmp %i2, %g2
40005fe4: 08 bf ff f1 bleu 40005fa8 <jffs2_truncate_fragtree+0xa4> <== ALWAYS TAKEN
40005fe8: 90 10 00 1d mov %i5, %o0
if (size == 0)
40005fec: 80 a6 a0 00 cmp %i2, 0
40005ff0: 12 80 00 08 bne 40006010 <jffs2_truncate_fragtree+0x10c>
40005ff4: 01 00 00 00 nop
return 0;
40005ff8: 81 c7 e0 08 ret
40005ffc: 91 e8 20 00 restore %g0, 0, %o0
} else if (frag->ofs > offset) {
40006000: 1a 80 00 1f bcc 4000607c <jffs2_truncate_fragtree+0x178>
40006004: 01 00 00 00 nop
40006008: 10 bf ff d2 b 40005f50 <jffs2_truncate_fragtree+0x4c>
4000600c: c2 00 40 00 ld [ %g1 ], %g1
return _RBTree_Maximum( (RBTree_Control *) root );
40006010: 40 00 3e 6c call 400159c0 <_RBTree_Maximum>
40006014: 90 10 00 19 mov %i1, %o0
40006018: 80 a2 20 00 cmp %o0, 0
4000601c: 02 bf ff f7 be 40005ff8 <jffs2_truncate_fragtree+0xf4> <== NEVER TAKEN
40006020: 01 00 00 00 nop
if (frag->ofs + frag->size < size)
40006024: c2 02 20 18 ld [ %o0 + 0x18 ], %g1
40006028: f0 02 20 14 ld [ %o0 + 0x14 ], %i0
4000602c: b0 00 40 18 add %g1, %i0, %i0
40006030: 80 a6 00 1a cmp %i0, %i2
40006034: 0a 80 00 10 bcs 40006074 <jffs2_truncate_fragtree+0x170> <== NEVER TAKEN
40006038: 01 00 00 00 nop
if (frag->node && (frag->ofs & (PAGE_SIZE - 1)) == 0) {
4000603c: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
40006040: 80 a0 a0 00 cmp %g2, 0
40006044: 02 80 00 0a be 4000606c <jffs2_truncate_fragtree+0x168> <== NEVER TAKEN
40006048: b0 10 00 1a mov %i2, %i0
4000604c: 80 88 6f ff btst 0xfff, %g1
40006050: 12 80 00 09 bne 40006074 <jffs2_truncate_fragtree+0x170>
40006054: 01 00 00 00 nop
frag->node->raw->flash_offset = ref_offset(frag->node->raw) | REF_PRISTINE;
40006058: c4 00 80 00 ld [ %g2 ], %g2
4000605c: c2 00 a0 04 ld [ %g2 + 4 ], %g1
40006060: 82 08 7f fc and %g1, -4, %g1
40006064: 82 10 60 02 or %g1, 2, %g1
40006068: c2 20 a0 04 st %g1, [ %g2 + 4 ]
4000606c: 81 c7 e0 08 ret
40006070: 81 e8 00 00 restore
}
40006074: 81 c7 e0 08 ret
40006078: 81 e8 00 00 restore
if (frag && frag->ofs != size) {
4000607c: 02 bf ff d9 be 40005fe0 <jffs2_truncate_fragtree+0xdc>
40006080: ba 10 00 01 mov %g1, %i5
frag->size = size - frag->ofs;
40006084: 84 26 80 02 sub %i2, %g2, %g2
40006088: ba 10 00 01 mov %g1, %i5
4000608c: 10 bf ff c0 b 40005f8c <jffs2_truncate_fragtree+0x88>
40006090: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
4000c090 <jffs2_unlink>:
/***********************************************************************/
int jffs2_unlink(struct _inode *dir_i, struct _inode *d_inode, const unsigned char *d_name, size_t d_namelen)
{
4000c090: 9d e3 bf a0 save %sp, -96, %sp <== 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());
4000c094: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000c098: 40 00 45 53 call 4001d5e4 <time> <== NOT EXECUTED
4000c09c: fa 06 20 40 ld [ %i0 + 0x40 ], %i5 <== NOT EXECUTED
ret = jffs2_do_unlink(c, dir_f, (const char *)d_name,
4000c0a0: 98 06 60 48 add %i1, 0x48, %o4 <== NOT EXECUTED
d_namelen, dead_f, get_seconds());
4000c0a4: 9a 10 00 09 mov %o1, %o5 <== NOT EXECUTED
ret = jffs2_do_unlink(c, dir_f, (const char *)d_name,
4000c0a8: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
4000c0ac: 92 06 20 48 add %i0, 0x48, %o1 <== NOT EXECUTED
4000c0b0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
4000c0b4: 7f ff fb d2 call 4000affc <jffs2_do_unlink> <== NOT EXECUTED
4000c0b8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (dead_f->inocache)
4000c0bc: c2 06 60 5c ld [ %i1 + 0x5c ], %g1 <== NOT EXECUTED
4000c0c0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000c0c4: 02 80 00 04 be 4000c0d4 <jffs2_unlink+0x44> <== NOT EXECUTED
4000c0c8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
d_inode->i_nlink = dead_f->inocache->pino_nlink;
4000c0cc: c2 00 60 14 ld [ %g1 + 0x14 ], %g1 <== NOT EXECUTED
4000c0d0: c2 36 60 0c sth %g1, [ %i1 + 0xc ] <== NOT EXECUTED
return ret;
}
4000c0d4: 81 c7 e0 08 ret <== NOT EXECUTED
4000c0d8: 81 e8 00 00 restore <== NOT EXECUTED
4000a538 <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)
{
4000a538: 9d e3 bf 80 save %sp, -128, %sp
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) {
4000a53c: 92 10 00 1c mov %i4, %o1
4000a540: 40 00 4c 16 call 4001d598 <strnlen>
4000a544: 90 10 00 1b mov %i3, %o0
4000a548: 80 a2 00 1c cmp %o0, %i4
4000a54c: 02 80 00 2b be 4000a5f8 <jffs2_write_dirent+0xc0> <== ALWAYS TAKEN
4000a550: 82 10 20 28 mov 0x28, %g1
/* 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");
4000a554: 11 10 00 80 sethi %hi(0x40020000), %o0 <== NOT EXECUTED
4000a558: 7f ff fe 9c call 40009fc8 <jffs2_printk> <== NOT EXECUTED
4000a55c: 90 12 21 70 or %o0, 0x170, %o0 ! 40020170 <__func__.10+0xe8> <== NOT EXECUTED
pr_crit("Directory inode #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x\n",
4000a560: c6 0e a0 16 ldub [ %i2 + 0x16 ], %g3 <== NOT EXECUTED
4000a564: de 0e a0 24 ldub [ %i2 + 0x24 ], %o7 <== NOT EXECUTED
4000a568: c4 0e a0 14 ldub [ %i2 + 0x14 ], %g2 <== NOT EXECUTED
4000a56c: f8 0e a0 15 ldub [ %i2 + 0x15 ], %i4 <== NOT EXECUTED
4000a570: f0 0e a0 0c ldub [ %i2 + 0xc ], %i0 <== NOT EXECUTED
4000a574: c8 0e a0 0d ldub [ %i2 + 0xd ], %g4 <== NOT EXECUTED
4000a578: c2 0e a0 0e ldub [ %i2 + 0xe ], %g1 <== NOT EXECUTED
4000a57c: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
4000a580: f2 0e a0 25 ldub [ %i2 + 0x25 ], %i1 <== NOT EXECUTED
4000a584: fa 0e a0 26 ldub [ %i2 + 0x26 ], %i5 <== NOT EXECUTED
4000a588: da 0e a0 27 ldub [ %i2 + 0x27 ], %o5 <== NOT EXECUTED
4000a58c: d8 0e a0 17 ldub [ %i2 + 0x17 ], %o4 <== NOT EXECUTED
4000a590: d2 0e a0 0f ldub [ %i2 + 0xf ], %o1 <== NOT EXECUTED
4000a594: 9f 2b e0 18 sll %o7, 0x18, %o7 <== NOT EXECUTED
4000a598: b5 28 a0 18 sll %g2, 0x18, %i2 <== NOT EXECUTED
4000a59c: b1 2e 20 18 sll %i0, 0x18, %i0 <== NOT EXECUTED
4000a5a0: 85 2f 20 10 sll %i4, 0x10, %g2 <== NOT EXECUTED
4000a5a4: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
4000a5a8: 84 10 80 1a or %g2, %i2, %g2 <== NOT EXECUTED
4000a5ac: 84 10 c0 02 or %g3, %g2, %g2 <== NOT EXECUTED
4000a5b0: 87 29 20 10 sll %g4, 0x10, %g3 <== NOT EXECUTED
4000a5b4: 86 10 c0 18 or %g3, %i0, %g3 <== NOT EXECUTED
4000a5b8: 82 10 40 03 or %g1, %g3, %g1 <== NOT EXECUTED
4000a5bc: b3 2e 60 10 sll %i1, 0x10, %i1 <== NOT EXECUTED
4000a5c0: bb 2f 60 08 sll %i5, 8, %i5 <== NOT EXECUTED
4000a5c4: b2 16 40 0f or %i1, %o7, %i1 <== NOT EXECUTED
4000a5c8: 11 10 00 80 sethi %hi(0x40020000), %o0 <== NOT EXECUTED
4000a5cc: ba 17 40 19 or %i5, %i1, %i5 <== NOT EXECUTED
4000a5d0: 98 13 00 02 or %o4, %g2, %o4 <== NOT EXECUTED
4000a5d4: 9a 13 40 1d or %o5, %i5, %o5 <== NOT EXECUTED
4000a5d8: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
4000a5dc: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
4000a5e0: 92 12 40 01 or %o1, %g1, %o1 <== 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);
4000a5e4: a0 10 3f fb mov -5, %l0 <== NOT EXECUTED
pr_crit("Directory inode #%u, name at *0x%p \"%s\"->ino #%u, name_crc 0x%08x\n",
4000a5e8: 7f ff fe 78 call 40009fc8 <jffs2_printk> <== NOT EXECUTED
4000a5ec: 90 12 21 b8 or %o0, 0x1b8, %o0 <== NOT EXECUTED
if (retried) {
jffs2_dbg_acct_sanity_check(c,NULL);
}
return fd;
}
4000a5f0: 81 c7 e0 08 ret
4000a5f4: 91 e8 00 10 restore %g0, %l0, %o0
vecs[0].iov_base = rd;
4000a5f8: f4 27 bf f0 st %i2, [ %fp + -16 ]
fd = jffs2_alloc_full_dirent(namelen+1);
4000a5fc: 90 07 20 01 add %i4, 1, %o0
vecs[1].iov_base = (unsigned char *)name;
4000a600: f6 27 bf f8 st %i3, [ %fp + -8 ]
vecs[0].iov_len = sizeof(*rd);
4000a604: c2 27 bf f4 st %g1, [ %fp + -12 ]
fd = jffs2_alloc_full_dirent(namelen+1);
4000a608: 7f ff ed 5d call 40005b7c <jffs2_alloc_full_dirent>
4000a60c: f8 27 bf fc st %i4, [ %fp + -4 ]
if (!fd)
4000a610: a0 92 20 00 orcc %o0, 0, %l0
4000a614: 02 80 00 bc be 4000a904 <jffs2_write_dirent+0x3cc> <== NEVER TAKEN
4000a618: 80 a7 20 00 cmp %i4, 0
fd->version = je32_to_cpu(rd->version);
4000a61c: c6 0e a0 13 ldub [ %i2 + 0x13 ], %g3
4000a620: c8 0e a0 10 ldub [ %i2 + 0x10 ], %g4
4000a624: c4 0e a0 11 ldub [ %i2 + 0x11 ], %g2
4000a628: c2 0e a0 12 ldub [ %i2 + 0x12 ], %g1
4000a62c: 89 29 20 18 sll %g4, 0x18, %g4
4000a630: 85 28 a0 10 sll %g2, 0x10, %g2
4000a634: 83 28 60 08 sll %g1, 8, %g1
4000a638: 84 10 80 04 or %g2, %g4, %g2
4000a63c: 82 10 40 02 or %g1, %g2, %g1
4000a640: 82 10 c0 01 or %g3, %g1, %g1
4000a644: c2 24 20 08 st %g1, [ %l0 + 8 ]
fd->ino = je32_to_cpu(rd->ino);
4000a648: c8 0e a0 14 ldub [ %i2 + 0x14 ], %g4
4000a64c: c4 0e a0 15 ldub [ %i2 + 0x15 ], %g2
4000a650: c2 0e a0 16 ldub [ %i2 + 0x16 ], %g1
4000a654: c6 0e a0 17 ldub [ %i2 + 0x17 ], %g3
4000a658: 89 29 20 18 sll %g4, 0x18, %g4
4000a65c: 85 28 a0 10 sll %g2, 0x10, %g2
4000a660: 83 28 60 08 sll %g1, 8, %g1
4000a664: 84 10 80 04 or %g2, %g4, %g2
4000a668: 82 10 40 02 or %g1, %g2, %g1
4000a66c: 82 10 c0 01 or %g3, %g1, %g1
while (len--) {
4000a670: 02 80 00 cb be 4000a99c <jffs2_write_dirent+0x464> <== NEVER TAKEN
4000a674: c2 24 20 0c st %g1, [ %l0 + 0xc ]
4000a678: 9e 06 c0 1c add %i3, %i4, %o7
4000a67c: 84 10 00 1b mov %i3, %g2
uint32_t hash = 0;
4000a680: 82 10 20 00 clr %g1
hash ^= *(name++);
4000a684: c6 08 80 00 ldub [ %g2 ], %g3
hash = (hash << 4) | (hash >> 28);
4000a688: 89 28 60 04 sll %g1, 4, %g4
hash ^= *(name++);
4000a68c: 84 00 a0 01 inc %g2
hash = (hash << 4) | (hash >> 28);
4000a690: 83 30 60 1c srl %g1, 0x1c, %g1
while (len--) {
4000a694: 80 a0 80 0f cmp %g2, %o7
hash = (hash << 4) | (hash >> 28);
4000a698: 82 10 40 04 or %g1, %g4, %g1
while (len--) {
4000a69c: 12 bf ff fa bne 4000a684 <jffs2_write_dirent+0x14c>
4000a6a0: 82 18 c0 01 xor %g3, %g1, %g1
fd->nhash = full_name_hash(NULL, name, namelen);
4000a6a4: c2 24 20 10 st %g1, [ %l0 + 0x10 ]
memcpy(fd->name, name, namelen);
4000a6a8: 94 10 00 1c mov %i4, %o2
fd->type = rd->type;
4000a6ac: c2 0e a0 1d ldub [ %i2 + 0x1d ], %g1
4000a6b0: c2 2c 20 14 stb %g1, [ %l0 + 0x14 ]
memcpy(fd->name, name, namelen);
4000a6b4: 92 10 00 1b mov %i3, %o1
4000a6b8: 40 00 4a 1c call 4001cf28 <memcpy>
4000a6bc: 90 04 20 15 add %l0, 0x15, %o0
fd->name[namelen]=0;
4000a6c0: 82 04 00 1c add %l0, %i4, %g1
4000a6c4: c0 28 60 15 clrb [ %g1 + 0x15 ]
jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL);
4000a6c8: a2 07 20 2b add %i4, 0x2b, %l1
pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
4000a6cc: 25 10 00 80 sethi %hi(0x40020000), %l2
pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n",
4000a6d0: 27 10 00 79 sethi %hi(0x4001e400), %l3
fd->name[namelen]=0;
4000a6d4: aa 10 20 02 mov 2, %l5
int retried = 0;
4000a6d8: 84 10 20 00 clr %g2
if (ret || (retlen != sizeof(*rd) + namelen)) {
4000a6dc: a8 07 20 28 add %i4, 0x28, %l4
pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
4000a6e0: a4 14 a1 28 or %l2, 0x128, %l2
pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n",
4000a6e4: a6 14 e0 80 or %l3, 0x80, %l3
jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL);
4000a6e8: a2 0c 7f fc and %l1, -4, %l1
ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &dummy,
4000a6ec: ac 07 20 18 add %i4, 0x18, %l6
flash_ofs = write_ofs(c);
4000a6f0: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
4000a6f4: ee 00 60 0c ld [ %g1 + 0xc ], %l7
4000a6f8: c8 06 20 34 ld [ %i0 + 0x34 ], %g4
if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(rd->version) < f->highest_version)) {
4000a6fc: 80 a7 60 02 cmp %i5, 2
4000a700: 02 80 00 33 be 4000a7cc <jffs2_write_dirent+0x294>
4000a704: f6 00 60 20 ld [ %g1 + 0x20 ], %i3
4000a708: da 06 40 00 ld [ %i1 ], %o5
4000a70c: d8 0e a0 10 ldub [ %i2 + 0x10 ], %o4
4000a710: c6 0e a0 11 ldub [ %i2 + 0x11 ], %g3
4000a714: c2 0e a0 12 ldub [ %i2 + 0x12 ], %g1
4000a718: de 0e a0 13 ldub [ %i2 + 0x13 ], %o7
4000a71c: 99 2b 20 18 sll %o4, 0x18, %o4
4000a720: 87 28 e0 10 sll %g3, 0x10, %g3
4000a724: 83 28 60 08 sll %g1, 8, %g1
4000a728: 86 10 c0 0c or %g3, %o4, %g3
4000a72c: 82 10 40 03 or %g1, %g3, %g1
4000a730: 82 13 c0 01 or %o7, %g1, %g1
4000a734: 80 a0 40 0d cmp %g1, %o5
4000a738: 3a 80 00 26 bcc,a 4000a7d0 <jffs2_write_dirent+0x298> <== ALWAYS TAKEN
4000a73c: 88 05 c0 04 add %l7, %g4, %g4
BUG_ON(!retried);
4000a740: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4000a744: 12 80 00 09 bne 4000a768 <jffs2_write_dirent+0x230> <== NOT EXECUTED
4000a748: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
4000a74c: 15 10 00 80 sethi %hi(0x40020000), %o2 <== NOT EXECUTED
4000a750: 11 10 00 80 sethi %hi(0x40020000), %o0 <== NOT EXECUTED
4000a754: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
4000a758: 94 12 a2 98 or %o2, 0x298, %o2 <== NOT EXECUTED
4000a75c: 92 10 21 05 mov 0x105, %o1 <== NOT EXECUTED
4000a760: 40 00 10 86 call 4000e978 <__assert_func> <== NOT EXECUTED
4000a764: 90 12 20 f8 or %o0, 0xf8, %o0 <== NOT EXECUTED
rd->version = cpu_to_je32(++f->highest_version);
4000a768: 9a 03 60 01 inc %o5 <== NOT EXECUTED
4000a76c: da 26 40 00 st %o5, [ %i1 ] <== NOT EXECUTED
4000a770: 83 33 60 18 srl %o5, 0x18, %g1 <== NOT EXECUTED
4000a774: 87 33 60 10 srl %o5, 0x10, %g3 <== NOT EXECUTED
4000a778: c2 2e a0 10 stb %g1, [ %i2 + 0x10 ] <== NOT EXECUTED
4000a77c: 83 33 60 08 srl %o5, 8, %g1 <== NOT EXECUTED
4000a780: c6 2e a0 11 stb %g3, [ %i2 + 0x11 ] <== NOT EXECUTED
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000a784: 94 10 20 20 mov 0x20, %o2 <== NOT EXECUTED
rd->version = cpu_to_je32(++f->highest_version);
4000a788: c2 2e a0 12 stb %g1, [ %i2 + 0x12 ] <== NOT EXECUTED
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000a78c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
rd->version = cpu_to_je32(++f->highest_version);
4000a790: da 2e a0 13 stb %o5, [ %i2 + 0x13 ] <== NOT EXECUTED
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000a794: 90 10 20 00 clr %o0 <== NOT EXECUTED
fd->version = je32_to_cpu(rd->version);
4000a798: da 24 20 08 st %o5, [ %l0 + 8 ] <== NOT EXECUTED
rd->node_crc = cpu_to_je32(crc32(0, rd, sizeof(*rd)-8));
4000a79c: c4 27 bf e0 st %g2, [ %fp + -32 ] <== NOT EXECUTED
4000a7a0: 40 00 04 f6 call 4000bb78 <cyg_crc32_accumulate> <== NOT EXECUTED
4000a7a4: c8 27 bf e4 st %g4, [ %fp + -28 ] <== NOT EXECUTED
4000a7a8: 9f 32 20 18 srl %o0, 0x18, %o7 <== NOT EXECUTED
4000a7ac: 87 32 20 10 srl %o0, 0x10, %g3 <== NOT EXECUTED
4000a7b0: 83 32 20 08 srl %o0, 8, %g1 <== NOT EXECUTED
4000a7b4: de 2e a0 20 stb %o7, [ %i2 + 0x20 ] <== NOT EXECUTED
4000a7b8: c6 2e a0 21 stb %g3, [ %i2 + 0x21 ] <== NOT EXECUTED
4000a7bc: c2 2e a0 22 stb %g1, [ %i2 + 0x22 ] <== NOT EXECUTED
4000a7c0: d0 2e a0 23 stb %o0, [ %i2 + 0x23 ] <== NOT EXECUTED
4000a7c4: c4 07 bf e0 ld [ %fp + -32 ], %g2 <== NOT EXECUTED
4000a7c8: c8 07 bf e4 ld [ %fp + -28 ], %g4 <== NOT EXECUTED
flash_ofs = write_ofs(c);
4000a7cc: 88 05 c0 04 add %l7, %g4, %g4
4000a7d0: c4 27 bf e4 st %g2, [ %fp + -28 ]
4000a7d4: b6 21 00 1b sub %g4, %i3, %i3
ret = jffs2_flash_writev(c, vecs, 2, flash_ofs, &retlen,
4000a7d8: 9a 07 bf e8 add %fp, -24, %o5
4000a7dc: 98 10 00 1b mov %i3, %o4
4000a7e0: 96 10 20 00 clr %o3
4000a7e4: 94 10 20 02 mov 2, %o2
4000a7e8: 92 07 bf f0 add %fp, -16, %o1
4000a7ec: 40 00 09 a9 call 4000ce90 <jffs2_flash_direct_writev>
4000a7f0: 90 10 00 18 mov %i0, %o0
if (ret || (retlen != sizeof(*rd) + namelen)) {
4000a7f4: d8 07 bf e8 ld [ %fp + -24 ], %o4
4000a7f8: c4 07 bf e4 ld [ %fp + -28 ], %g2
4000a7fc: 80 a2 20 00 cmp %o0, 0
4000a800: 12 80 00 05 bne 4000a814 <jffs2_write_dirent+0x2dc> <== NEVER TAKEN
4000a804: ae 10 00 08 mov %o0, %l7
4000a808: 80 a3 00 14 cmp %o4, %l4
4000a80c: 22 80 00 40 be,a 4000a90c <jffs2_write_dirent+0x3d4> <== ALWAYS TAKEN
4000a810: c4 27 bf e4 st %g2, [ %fp + -28 ]
pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
4000a814: 96 10 00 17 mov %l7, %o3 <== NOT EXECUTED
4000a818: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
4000a81c: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
4000a820: 7f ff fd ea call 40009fc8 <jffs2_printk> <== NOT EXECUTED
4000a824: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
if (retlen) {
4000a828: c2 07 bf e8 ld [ %fp + -24 ], %g1 <== NOT EXECUTED
4000a82c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
4000a830: 12 80 00 27 bne 4000a8cc <jffs2_write_dirent+0x394> <== NOT EXECUTED
4000a834: 96 10 20 00 clr %o3 <== NOT EXECUTED
pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n",
4000a838: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
4000a83c: 7f ff fd e3 call 40009fc8 <jffs2_printk> <== NOT EXECUTED
4000a840: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
if (!retried) {
4000a844: 80 a5 60 01 cmp %l5, 1 <== NOT EXECUTED
4000a848: 02 80 00 28 be 4000a8e8 <jffs2_write_dirent+0x3b0> <== NOT EXECUTED
4000a84c: 01 00 00 00 nop <== NOT EXECUTED
struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
4000a850: 81 80 20 00 wr %g0, %y <== NOT EXECUTED
4000a854: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 <== NOT EXECUTED
4000a858: 01 00 00 00 nop <== NOT EXECUTED
4000a85c: 01 00 00 00 nop <== NOT EXECUTED
4000a860: 82 76 c0 01 udiv %i3, %g1, %g1 <== NOT EXECUTED
4000a864: c4 06 20 54 ld [ %i0 + 0x54 ], %g2 <== NOT EXECUTED
4000a868: 82 58 60 34 smul %g1, 0x34, %g1 <== NOT EXECUTED
jffs2_dbg_acct_sanity_check(c,jeb);
4000a86c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
4000a870: b6 00 80 01 add %g2, %g1, %i3 <== NOT EXECUTED
jffs2_dbg_acct_sanity_check(c,jeb);
4000a874: 40 00 05 71 call 4000be38 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
4000a878: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
if (alloc_mode == ALLOC_GC) {
4000a87c: 80 a7 60 02 cmp %i5, 2 <== NOT EXECUTED
4000a880: 02 80 00 41 be 4000a984 <jffs2_write_dirent+0x44c> <== NOT EXECUTED
4000a884: 96 10 00 16 mov %l6, %o3 <== NOT EXECUTED
jffs2_complete_reservation(c);
4000a888: 7f ff f1 98 call 40006ee8 <jffs2_complete_reservation> <== NOT EXECUTED
4000a88c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
ret = jffs2_reserve_space(c, sizeof(*rd) + namelen, &dummy,
4000a890: 98 10 00 16 mov %l6, %o4 <== NOT EXECUTED
4000a894: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
4000a898: 94 07 bf ec add %fp, -20, %o2 <== NOT EXECUTED
4000a89c: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
4000a8a0: 7f ff f3 bb call 4000778c <jffs2_reserve_space> <== NOT EXECUTED
4000a8a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000a8a8: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
if (!ret) {
4000a8ac: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED
4000a8b0: 02 80 00 3d be 4000a9a4 <jffs2_write_dirent+0x46c> <== NOT EXECUTED
4000a8b4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
jffs2_free_full_dirent(fd);
4000a8b8: 7f ff ec b5 call 40005b8c <jffs2_free_full_dirent> <== NOT EXECUTED
4000a8bc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
return ERR_PTR(ret?ret:-EIO);
4000a8c0: a0 10 00 17 mov %l7, %l0 <== NOT EXECUTED
}
4000a8c4: 81 c7 e0 08 ret <== NOT EXECUTED
4000a8c8: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*rd)+namelen), NULL);
4000a8cc: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
4000a8d0: 92 16 e0 01 or %i3, 1, %o1 <== NOT EXECUTED
4000a8d4: 7f ff f1 28 call 40006d74 <jffs2_add_physical_node_ref> <== NOT EXECUTED
4000a8d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (!retried) {
4000a8dc: 80 a5 60 01 cmp %l5, 1 <== NOT EXECUTED
4000a8e0: 12 bf ff dc bne 4000a850 <jffs2_write_dirent+0x318> <== NOT EXECUTED
4000a8e4: 01 00 00 00 nop <== NOT EXECUTED
jffs2_free_full_dirent(fd);
4000a8e8: 7f ff ec a9 call 40005b8c <jffs2_free_full_dirent> <== NOT EXECUTED
4000a8ec: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
return ERR_PTR(ret?ret:-EIO);
4000a8f0: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED
4000a8f4: 12 bf ff f3 bne 4000a8c0 <jffs2_write_dirent+0x388> <== NOT EXECUTED
4000a8f8: a0 10 3f fb mov -5, %l0 <== NOT EXECUTED
}
4000a8fc: 81 c7 e0 08 ret <== NOT EXECUTED
4000a900: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
return ERR_PTR(-ENOMEM);
4000a904: 10 bf ff 3b b 4000a5f0 <jffs2_write_dirent+0xb8> <== NOT EXECUTED
4000a908: a0 10 3f f4 mov -12, %l0 <== NOT EXECUTED
PAD(sizeof(*rd)+namelen), f->inocache);
4000a90c: b8 07 20 2b add %i4, 0x2b, %i4
fd->raw = jffs2_add_physical_node_ref(c, flash_ofs | dirent_node_state(rd),
4000a910: fa 0e a0 14 ldub [ %i2 + 0x14 ], %i5
4000a914: c6 0e a0 15 ldub [ %i2 + 0x15 ], %g3
4000a918: c2 0e a0 16 ldub [ %i2 + 0x16 ], %g1
4000a91c: c8 0e a0 17 ldub [ %i2 + 0x17 ], %g4
4000a920: d6 06 60 14 ld [ %i1 + 0x14 ], %o3
4000a924: bb 2f 60 18 sll %i5, 0x18, %i5
4000a928: 87 28 e0 10 sll %g3, 0x10, %g3
4000a92c: 83 28 60 08 sll %g1, 8, %g1
4000a930: 86 10 c0 1d or %g3, %i5, %g3
4000a934: 82 10 40 03 or %g1, %g3, %g1
4000a938: 82 11 00 01 or %g4, %g1, %g1
4000a93c: 80 a0 00 01 cmp %g0, %g1
4000a940: 94 0f 3f fc and %i4, -4, %o2
4000a944: 92 60 3f ff subx %g0, -1, %o1
4000a948: 90 10 00 18 mov %i0, %o0
4000a94c: 92 02 60 02 add %o1, 2, %o1
4000a950: 7f ff f1 09 call 40006d74 <jffs2_add_physical_node_ref>
4000a954: 92 12 40 1b or %o1, %i3, %o1
4000a958: d0 24 00 00 st %o0, [ %l0 ]
4000a95c: 82 10 00 08 mov %o0, %g1
if (IS_ERR(fd->raw)) {
4000a960: 80 a2 3c 18 cmp %o0, -1000
4000a964: 18 80 00 15 bgu 4000a9b8 <jffs2_write_dirent+0x480> <== NEVER TAKEN
4000a968: c4 07 bf e4 ld [ %fp + -28 ], %g2
if (retried) {
4000a96c: 80 a0 a0 00 cmp %g2, 0
4000a970: 02 bf ff 20 be 4000a5f0 <jffs2_write_dirent+0xb8> <== ALWAYS TAKEN
4000a974: 92 10 20 00 clr %o1
jffs2_dbg_acct_sanity_check(c,NULL);
4000a978: 40 00 05 30 call 4000be38 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
4000a97c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000a980: 30 bf ff 1c b,a 4000a5f0 <jffs2_write_dirent+0xb8> <== NOT EXECUTED
ret = jffs2_reserve_space_gc(c, sizeof(*rd) + namelen, &dummy,
4000a984: 94 07 bf ec add %fp, -20, %o2 <== NOT EXECUTED
4000a988: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
4000a98c: 7f ff f3 6f call 40007748 <jffs2_reserve_space_gc> <== NOT EXECUTED
4000a990: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000a994: 10 bf ff c6 b 4000a8ac <jffs2_write_dirent+0x374> <== NOT EXECUTED
4000a998: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
uint32_t hash = 0;
4000a99c: 10 bf ff 42 b 4000a6a4 <jffs2_write_dirent+0x16c> <== NOT EXECUTED
4000a9a0: 82 10 20 00 clr %g1 <== NOT EXECUTED
jffs2_dbg_acct_sanity_check(c,jeb);
4000a9a4: 40 00 05 25 call 4000be38 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
4000a9a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
goto retry;
4000a9ac: aa 10 20 01 mov 1, %l5 <== NOT EXECUTED
retried = 1;
4000a9b0: 10 bf ff 50 b 4000a6f0 <jffs2_write_dirent+0x1b8> <== NOT EXECUTED
4000a9b4: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
jffs2_free_full_dirent(fd);
4000a9b8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
4000a9bc: 7f ff ec 74 call 40005b8c <jffs2_free_full_dirent> <== NOT EXECUTED
4000a9c0: a0 10 00 01 mov %g1, %l0 <== NOT EXECUTED
return ERR_CAST(hold_err);
4000a9c4: 30 bf ff 0b b,a 4000a5f0 <jffs2_write_dirent+0xb8> <== NOT EXECUTED
4000a100 <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)
{
4000a100: 9d e3 bf 80 save %sp, -128, %sp
pr_crit("Eep. CRC not correct in jffs2_write_dnode()\n");
BUG();
}
);
vecs[0].iov_base = ri;
vecs[0].iov_len = sizeof(*ri);
4000a104: 82 10 20 44 mov 0x44, %g1
vecs[0].iov_base = ri;
4000a108: f4 27 bf f0 st %i2, [ %fp + -16 ]
vecs[1].iov_base = (unsigned char *)data;
vecs[1].iov_len = datalen;
if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) {
4000a10c: a0 07 20 44 add %i4, 0x44, %l0
vecs[0].iov_len = sizeof(*ri);
4000a110: c2 27 bf f4 st %g1, [ %fp + -12 ]
vecs[1].iov_base = (unsigned char *)data;
4000a114: f6 27 bf f8 st %i3, [ %fp + -8 ]
vecs[1].iov_len = datalen;
4000a118: f8 27 bf fc st %i4, [ %fp + -4 ]
if (je32_to_cpu(ri->totlen) != sizeof(*ri) + datalen) {
4000a11c: c6 0e a0 04 ldub [ %i2 + 4 ], %g3
4000a120: c2 0e a0 05 ldub [ %i2 + 5 ], %g1
4000a124: d4 0e a0 06 ldub [ %i2 + 6 ], %o2
4000a128: c4 0e a0 07 ldub [ %i2 + 7 ], %g2
4000a12c: 87 28 e0 18 sll %g3, 0x18, %g3
4000a130: 83 28 60 10 sll %g1, 0x10, %g1
4000a134: 95 2a a0 08 sll %o2, 8, %o2
4000a138: 82 10 40 03 or %g1, %g3, %g1
4000a13c: 94 12 80 01 or %o2, %g1, %o2
4000a140: 94 10 80 0a or %g2, %o2, %o2
4000a144: 80 a2 80 10 cmp %o2, %l0
4000a148: 02 80 00 08 be 4000a168 <jffs2_write_dnode+0x68> <== ALWAYS TAKEN
4000a14c: 13 10 00 80 sethi %hi(0x40020000), %o1
pr_warn("%s(): ri->totlen (0x%08x) != sizeof(*ri) (0x%08zx) + datalen (0x%08x)\n",
4000a150: 11 10 00 80 sethi %hi(0x40020000), %o0 <== NOT EXECUTED
4000a154: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED
4000a158: 96 10 20 44 mov 0x44, %o3 <== NOT EXECUTED
4000a15c: 92 12 62 b0 or %o1, 0x2b0, %o1 <== NOT EXECUTED
4000a160: 7f ff ff 9a call 40009fc8 <jffs2_printk> <== NOT EXECUTED
4000a164: 90 12 20 a0 or %o0, 0xa0, %o0 <== NOT EXECUTED
__func__, je32_to_cpu(ri->totlen),
sizeof(*ri), datalen);
}
fn = jffs2_alloc_full_dnode();
4000a168: 7f ff ee 8c call 40005b98 <jffs2_alloc_full_dnode>
4000a16c: 01 00 00 00 nop
if (!fn)
4000a170: a4 92 20 00 orcc %o0, 0, %l2
4000a174: 02 80 00 92 be 4000a3bc <jffs2_write_dnode+0x2bc> <== NEVER TAKEN
4000a178: 80 a7 20 00 cmp %i4, 0
return ERR_PTR(-ENOMEM);
/* check number of valid vecs */
if (!datalen || !data)
4000a17c: 02 80 00 88 be 4000a39c <jffs2_write_dnode+0x29c>
4000a180: 80 a6 e0 00 cmp %i3, 0
4000a184: 02 80 00 86 be 4000a39c <jffs2_write_dnode+0x29c> <== NEVER TAKEN
4000a188: ac 10 20 02 mov 2, %l6
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",
flash_ofs);
}
if (!retried && alloc_mode != ALLOC_NORETRY) {
4000a18c: 82 1f 60 03 xor %i5, 3, %g1
jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*ri)+datalen), NULL);
4000a190: a2 07 20 47 add %i4, 0x47, %l1
if (!retried && alloc_mode != ALLOC_NORETRY) {
4000a194: 80 a0 00 01 cmp %g0, %g1
jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*ri)+datalen), NULL);
4000a198: 82 0c 7f fc and %l1, -4, %g1
4000a19c: c2 27 bf e4 st %g1, [ %fp + -28 ]
pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
4000a1a0: 29 10 00 80 sethi %hi(0x40020000), %l4
pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n",
4000a1a4: 2b 10 00 79 sethi %hi(0x4001e400), %l5
retry:
4000a1a8: a6 10 20 00 clr %l3
pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
4000a1ac: a8 15 21 28 or %l4, 0x128, %l4
pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n",
4000a1b0: aa 15 60 80 or %l5, 0x80, %l5
if (!retried && alloc_mode != ALLOC_NORETRY) {
4000a1b4: ae 40 20 00 addx %g0, 0, %l7
flash_ofs = write_ofs(c);
4000a1b8: c4 06 20 58 ld [ %i0 + 0x58 ], %g2
4000a1bc: c2 00 a0 0c ld [ %g2 + 0xc ], %g1
4000a1c0: f6 06 20 34 ld [ %i0 + 0x34 ], %i3
if ((alloc_mode!=ALLOC_GC) && (je32_to_cpu(ri->version) < f->highest_version)) {
4000a1c4: 80 a7 60 02 cmp %i5, 2
4000a1c8: 02 80 00 30 be 4000a288 <jffs2_write_dnode+0x188>
4000a1cc: e2 00 a0 20 ld [ %g2 + 0x20 ], %l1
4000a1d0: da 06 40 00 ld [ %i1 ], %o5
4000a1d4: d8 0e a0 10 ldub [ %i2 + 0x10 ], %o4
4000a1d8: c6 0e a0 11 ldub [ %i2 + 0x11 ], %g3
4000a1dc: c4 0e a0 12 ldub [ %i2 + 0x12 ], %g2
4000a1e0: de 0e a0 13 ldub [ %i2 + 0x13 ], %o7
4000a1e4: 99 2b 20 18 sll %o4, 0x18, %o4
4000a1e8: 87 28 e0 10 sll %g3, 0x10, %g3
4000a1ec: 85 28 a0 08 sll %g2, 8, %g2
4000a1f0: 86 10 c0 0c or %g3, %o4, %g3
4000a1f4: 84 10 80 03 or %g2, %g3, %g2
4000a1f8: 84 13 c0 02 or %o7, %g2, %g2
4000a1fc: 80 a0 80 0d cmp %g2, %o5
4000a200: 3a 80 00 23 bcc,a 4000a28c <jffs2_write_dnode+0x18c> <== ALWAYS TAKEN
4000a204: b6 00 40 1b add %g1, %i3, %i3
BUG_ON(!retried);
4000a208: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
4000a20c: 12 80 00 09 bne 4000a230 <jffs2_write_dnode+0x130> <== NOT EXECUTED
4000a210: 17 10 00 76 sethi %hi(0x4001d800), %o3 <== NOT EXECUTED
4000a214: 15 10 00 80 sethi %hi(0x40020000), %o2 <== NOT EXECUTED
4000a218: 11 10 00 80 sethi %hi(0x40020000), %o0 <== NOT EXECUTED
4000a21c: 96 12 e1 20 or %o3, 0x120, %o3 <== NOT EXECUTED
4000a220: 94 12 a2 b0 or %o2, 0x2b0, %o2 <== NOT EXECUTED
4000a224: 92 10 20 67 mov 0x67, %o1 <== NOT EXECUTED
4000a228: 40 00 11 d4 call 4000e978 <__assert_func> <== NOT EXECUTED
4000a22c: 90 12 20 f8 or %o0, 0xf8, %o0 <== NOT EXECUTED
ri->version = cpu_to_je32(++f->highest_version);
4000a230: 9a 03 60 01 inc %o5 <== NOT EXECUTED
4000a234: da 26 40 00 st %o5, [ %i1 ] <== NOT EXECUTED
4000a238: 9f 33 60 18 srl %o5, 0x18, %o7 <== NOT EXECUTED
4000a23c: 87 33 60 10 srl %o5, 0x10, %g3 <== NOT EXECUTED
4000a240: 85 33 60 08 srl %o5, 8, %g2 <== NOT EXECUTED
4000a244: de 2e a0 10 stb %o7, [ %i2 + 0x10 ] <== NOT EXECUTED
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000a248: 94 10 20 3c mov 0x3c, %o2 <== NOT EXECUTED
ri->version = cpu_to_je32(++f->highest_version);
4000a24c: c6 2e a0 11 stb %g3, [ %i2 + 0x11 ] <== NOT EXECUTED
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000a250: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
ri->version = cpu_to_je32(++f->highest_version);
4000a254: c4 2e a0 12 stb %g2, [ %i2 + 0x12 ] <== NOT EXECUTED
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000a258: 90 10 20 00 clr %o0 <== NOT EXECUTED
ri->version = cpu_to_je32(++f->highest_version);
4000a25c: da 2e a0 13 stb %o5, [ %i2 + 0x13 ] <== NOT EXECUTED
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000a260: 40 00 06 46 call 4000bb78 <cyg_crc32_accumulate> <== NOT EXECUTED
4000a264: c2 27 bf e0 st %g1, [ %fp + -32 ] <== NOT EXECUTED
4000a268: 9f 32 20 18 srl %o0, 0x18, %o7 <== NOT EXECUTED
4000a26c: 87 32 20 10 srl %o0, 0x10, %g3 <== NOT EXECUTED
4000a270: 85 32 20 08 srl %o0, 8, %g2 <== NOT EXECUTED
4000a274: de 2e a0 40 stb %o7, [ %i2 + 0x40 ] <== NOT EXECUTED
4000a278: c6 2e a0 41 stb %g3, [ %i2 + 0x41 ] <== NOT EXECUTED
4000a27c: c4 2e a0 42 stb %g2, [ %i2 + 0x42 ] <== NOT EXECUTED
4000a280: d0 2e a0 43 stb %o0, [ %i2 + 0x43 ] <== NOT EXECUTED
4000a284: c2 07 bf e0 ld [ %fp + -32 ], %g1 <== NOT EXECUTED
flash_ofs = write_ofs(c);
4000a288: b6 00 40 1b add %g1, %i3, %i3
ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen,
4000a28c: 9a 07 bf e8 add %fp, -24, %o5
flash_ofs = write_ofs(c);
4000a290: b6 26 c0 11 sub %i3, %l1, %i3
ret = jffs2_flash_writev(c, vecs, cnt, flash_ofs, &retlen,
4000a294: 96 10 20 00 clr %o3
4000a298: 98 10 00 1b mov %i3, %o4
4000a29c: 94 10 00 16 mov %l6, %o2
4000a2a0: 92 07 bf f0 add %fp, -16, %o1
4000a2a4: 40 00 0a fb call 4000ce90 <jffs2_flash_direct_writev>
4000a2a8: 90 10 00 18 mov %i0, %o0
if (ret || (retlen != sizeof(*ri) + datalen)) {
4000a2ac: d8 07 bf e8 ld [ %fp + -24 ], %o4
4000a2b0: 80 a2 20 00 cmp %o0, 0
4000a2b4: 12 80 00 05 bne 4000a2c8 <jffs2_write_dnode+0x1c8> <== NEVER TAKEN
4000a2b8: a2 10 00 08 mov %o0, %l1
4000a2bc: 80 a4 00 0c cmp %l0, %o4
4000a2c0: 22 80 00 4d be,a 4000a3f4 <jffs2_write_dnode+0x2f4> <== ALWAYS TAKEN
4000a2c4: c8 0e a0 34 ldub [ %i2 + 0x34 ], %g4
pr_notice("Write of %zd bytes at 0x%08x failed. returned %d, retlen %zd\n",
4000a2c8: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
4000a2cc: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
4000a2d0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4000a2d4: 7f ff ff 3d call 40009fc8 <jffs2_printk> <== NOT EXECUTED
4000a2d8: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
if (retlen) {
4000a2dc: c4 07 bf e8 ld [ %fp + -24 ], %g2 <== NOT EXECUTED
4000a2e0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
4000a2e4: 02 80 00 2a be 4000a38c <jffs2_write_dnode+0x28c> <== NOT EXECUTED
4000a2e8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
jffs2_add_physical_node_ref(c, flash_ofs | REF_OBSOLETE, PAD(sizeof(*ri)+datalen), NULL);
4000a2ec: d4 07 bf e4 ld [ %fp + -28 ], %o2 <== NOT EXECUTED
4000a2f0: 96 10 20 00 clr %o3 <== NOT EXECUTED
4000a2f4: 92 16 e0 01 or %i3, 1, %o1 <== NOT EXECUTED
4000a2f8: 7f ff f2 9f call 40006d74 <jffs2_add_physical_node_ref> <== NOT EXECUTED
4000a2fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (!retried && alloc_mode != ALLOC_NORETRY) {
4000a300: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
4000a304: 12 80 00 31 bne 4000a3c8 <jffs2_write_dnode+0x2c8> <== NOT EXECUTED
4000a308: 80 a5 e0 00 cmp %l7, 0 <== NOT EXECUTED
4000a30c: 02 80 00 2f be 4000a3c8 <jffs2_write_dnode+0x2c8> <== NOT EXECUTED
4000a310: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
/* Try to reallocate space and retry */
uint32_t dummy;
struct jffs2_eraseblock *jeb = &c->blocks[flash_ofs / c->sector_size];
4000a314: 81 80 20 00 wr %g0, %y <== NOT EXECUTED
4000a318: c2 06 20 34 ld [ %i0 + 0x34 ], %g1 <== NOT EXECUTED
4000a31c: 01 00 00 00 nop <== NOT EXECUTED
4000a320: 01 00 00 00 nop <== NOT EXECUTED
4000a324: 82 76 c0 01 udiv %i3, %g1, %g1 <== NOT EXECUTED
4000a328: c4 06 20 54 ld [ %i0 + 0x54 ], %g2 <== NOT EXECUTED
4000a32c: 82 58 60 34 smul %g1, 0x34, %g1 <== NOT EXECUTED
4000a330: b6 00 80 01 add %g2, %g1, %i3 <== NOT EXECUTED
retried = 1;
jffs2_dbg(1, "Retrying failed write.\n");
jffs2_dbg_acct_sanity_check(c,jeb);
4000a334: 40 00 06 c1 call 4000be38 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
4000a338: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
jffs2_dbg_acct_paranoia_check(c, jeb);
if (alloc_mode == ALLOC_GC) {
4000a33c: 80 a7 60 02 cmp %i5, 2 <== NOT EXECUTED
4000a340: 02 80 00 19 be 4000a3a4 <jffs2_write_dnode+0x2a4> <== NOT EXECUTED
4000a344: 96 10 20 12 mov 0x12, %o3 <== 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);
4000a348: 7f ff f2 e8 call 40006ee8 <jffs2_complete_reservation> <== NOT EXECUTED
4000a34c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
ret = jffs2_reserve_space(c, sizeof(*ri) + datalen, &dummy,
4000a350: 98 10 20 12 mov 0x12, %o4 <== NOT EXECUTED
4000a354: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
4000a358: 94 07 bf ec add %fp, -20, %o2 <== NOT EXECUTED
4000a35c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4000a360: 7f ff f5 0b call 4000778c <jffs2_reserve_space> <== NOT EXECUTED
4000a364: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000a368: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
alloc_mode, JFFS2_SUMMARY_INODE_SIZE);
mutex_lock(&f->sem);
}
if (!ret) {
4000a36c: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
4000a370: 12 80 00 1d bne 4000a3e4 <jffs2_write_dnode+0x2e4> <== NOT EXECUTED
4000a374: 92 10 00 1b mov %i3, %o1 <== 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);
4000a378: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000a37c: 40 00 06 af call 4000be38 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
4000a380: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED
flash_ofs = write_ofs(c);
4000a384: 10 bf ff 8e b 4000a1bc <jffs2_write_dnode+0xbc> <== NOT EXECUTED
4000a388: c4 06 20 58 ld [ %i0 + 0x58 ], %g2 <== NOT EXECUTED
pr_notice("Not marking the space at 0x%08x as dirty because the flash driver returned retlen zero\n",
4000a38c: 7f ff ff 0f call 40009fc8 <jffs2_printk> <== NOT EXECUTED
4000a390: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
if (!retried && alloc_mode != ALLOC_NORETRY) {
4000a394: 10 bf ff dc b 4000a304 <jffs2_write_dnode+0x204> <== NOT EXECUTED
4000a398: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
cnt = 1;
4000a39c: 10 bf ff 7c b 4000a18c <jffs2_write_dnode+0x8c>
4000a3a0: ac 10 20 01 mov 1, %l6
ret = jffs2_reserve_space_gc(c, sizeof(*ri) + datalen, &dummy,
4000a3a4: 94 07 bf ec add %fp, -20, %o2 <== NOT EXECUTED
4000a3a8: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
4000a3ac: 7f ff f4 e7 call 40007748 <jffs2_reserve_space_gc> <== NOT EXECUTED
4000a3b0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000a3b4: 10 bf ff ee b 4000a36c <jffs2_write_dnode+0x26c> <== NOT EXECUTED
4000a3b8: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
return ERR_PTR(-ENOMEM);
4000a3bc: a4 10 3f f4 mov -12, %l2 <== NOT EXECUTED
if (retried) {
jffs2_dbg_acct_sanity_check(c,NULL);
}
return fn;
}
4000a3c0: 81 c7 e0 08 ret
4000a3c4: 91 e8 00 12 restore %g0, %l2, %o0
jffs2_free_full_dnode(fn);
4000a3c8: 7f ff ed f8 call 40005ba8 <jffs2_free_full_dnode> <== NOT EXECUTED
4000a3cc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
return ERR_PTR(ret?ret:-EIO);
4000a3d0: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
4000a3d4: 02 bf ff fb be 4000a3c0 <jffs2_write_dnode+0x2c0> <== NOT EXECUTED
4000a3d8: a4 10 3f fb mov -5, %l2 <== NOT EXECUTED
4000a3dc: 10 bf ff f9 b 4000a3c0 <jffs2_write_dnode+0x2c0> <== NOT EXECUTED
4000a3e0: a4 10 00 11 mov %l1, %l2 <== NOT EXECUTED
jffs2_free_full_dnode(fn);
4000a3e4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
4000a3e8: 7f ff ed f0 call 40005ba8 <jffs2_free_full_dnode> <== NOT EXECUTED
4000a3ec: a4 10 00 11 mov %l1, %l2 <== NOT EXECUTED
return ERR_PTR(ret?ret:-EIO);
4000a3f0: 30 bf ff f4 b,a 4000a3c0 <jffs2_write_dnode+0x2c0> <== NOT EXECUTED
if ((je32_to_cpu(ri->dsize) >= PAGE_SIZE) ||
4000a3f4: c4 0e a0 35 ldub [ %i2 + 0x35 ], %g2
4000a3f8: c2 0e a0 36 ldub [ %i2 + 0x36 ], %g1
4000a3fc: c6 0e a0 37 ldub [ %i2 + 0x37 ], %g3
4000a400: 89 29 20 18 sll %g4, 0x18, %g4
4000a404: 85 28 a0 10 sll %g2, 0x10, %g2
4000a408: 83 28 60 08 sll %g1, 8, %g1
4000a40c: 84 10 80 04 or %g2, %g4, %g2
4000a410: 82 10 40 02 or %g1, %g2, %g1
4000a414: 82 10 c0 01 or %g3, %g1, %g1
4000a418: 80 a0 6f ff cmp %g1, 0xfff
4000a41c: 18 80 00 1d bgu 4000a490 <jffs2_write_dnode+0x390>
4000a420: 92 16 e0 02 or %i3, 2, %o1
( ((je32_to_cpu(ri->offset)&(PAGE_SIZE-1))==0) &&
4000a424: fa 0e a0 2c ldub [ %i2 + 0x2c ], %i5
4000a428: c6 0e a0 2d ldub [ %i2 + 0x2d ], %g3
4000a42c: c4 0e a0 2e ldub [ %i2 + 0x2e ], %g2
4000a430: c8 0e a0 2f ldub [ %i2 + 0x2f ], %g4
4000a434: bb 2f 60 18 sll %i5, 0x18, %i5
4000a438: 87 28 e0 10 sll %g3, 0x10, %g3
4000a43c: 85 28 a0 08 sll %g2, 8, %g2
4000a440: 86 10 c0 1d or %g3, %i5, %g3
4000a444: 84 10 80 03 or %g2, %g3, %g2
4000a448: 84 11 00 02 or %g4, %g2, %g2
if ((je32_to_cpu(ri->dsize) >= PAGE_SIZE) ||
4000a44c: 80 88 af ff btst 0xfff, %g2
4000a450: 12 80 00 10 bne 4000a490 <jffs2_write_dnode+0x390>
4000a454: 92 16 e0 03 or %i3, 3, %o1
(je32_to_cpu(ri->dsize)+je32_to_cpu(ri->offset) == je32_to_cpu(ri->isize)))) {
4000a458: c6 0e a0 1e ldub [ %i2 + 0x1e ], %g3
4000a45c: de 0e a0 1c ldub [ %i2 + 0x1c ], %o7
4000a460: c8 0e a0 1d ldub [ %i2 + 0x1d ], %g4
4000a464: fa 0e a0 1f ldub [ %i2 + 0x1f ], %i5
4000a468: 82 00 40 02 add %g1, %g2, %g1
4000a46c: 9f 2b e0 18 sll %o7, 0x18, %o7
4000a470: 85 28 e0 08 sll %g3, 8, %g2
4000a474: 89 29 20 10 sll %g4, 0x10, %g4
4000a478: 86 11 00 0f or %g4, %o7, %g3
4000a47c: 84 10 80 03 or %g2, %g3, %g2
4000a480: 84 17 40 02 or %i5, %g2, %g2
( ((je32_to_cpu(ri->offset)&(PAGE_SIZE-1))==0) &&
4000a484: 80 a0 40 02 cmp %g1, %g2
4000a488: 22 80 00 02 be,a 4000a490 <jffs2_write_dnode+0x390>
4000a48c: 92 16 e0 02 or %i3, 2, %o1
fn->raw = jffs2_add_physical_node_ref(c, flash_ofs, PAD(sizeof(*ri)+datalen), f->inocache);
4000a490: d6 06 60 14 ld [ %i1 + 0x14 ], %o3
4000a494: b8 07 20 47 add %i4, 0x47, %i4
4000a498: 90 10 00 18 mov %i0, %o0
4000a49c: 7f ff f2 36 call 40006d74 <jffs2_add_physical_node_ref>
4000a4a0: 94 0f 3f fc and %i4, -4, %o2
4000a4a4: d0 24 80 00 st %o0, [ %l2 ]
if (IS_ERR(fn->raw)) {
4000a4a8: 80 a2 3c 18 cmp %o0, -1000
4000a4ac: 18 80 00 1f bgu 4000a528 <jffs2_write_dnode+0x428> <== NEVER TAKEN
4000a4b0: 82 10 00 08 mov %o0, %g1
fn->ofs = je32_to_cpu(ri->offset);
4000a4b4: c6 0e a0 2f ldub [ %i2 + 0x2f ], %g3
4000a4b8: c8 0e a0 2c ldub [ %i2 + 0x2c ], %g4
4000a4bc: c4 0e a0 2d ldub [ %i2 + 0x2d ], %g2
4000a4c0: c2 0e a0 2e ldub [ %i2 + 0x2e ], %g1
4000a4c4: 89 29 20 18 sll %g4, 0x18, %g4
4000a4c8: 85 28 a0 10 sll %g2, 0x10, %g2
4000a4cc: 83 28 60 08 sll %g1, 8, %g1
4000a4d0: 84 10 80 04 or %g2, %g4, %g2
4000a4d4: 82 10 40 02 or %g1, %g2, %g1
4000a4d8: 82 10 c0 01 or %g3, %g1, %g1
4000a4dc: c2 24 a0 04 st %g1, [ %l2 + 4 ]
if (retried) {
4000a4e0: 80 a4 e0 00 cmp %l3, 0
fn->size = je32_to_cpu(ri->dsize);
4000a4e4: c8 0e a0 34 ldub [ %i2 + 0x34 ], %g4
4000a4e8: c4 0e a0 35 ldub [ %i2 + 0x35 ], %g2
4000a4ec: c2 0e a0 36 ldub [ %i2 + 0x36 ], %g1
4000a4f0: c6 0e a0 37 ldub [ %i2 + 0x37 ], %g3
4000a4f4: 89 29 20 18 sll %g4, 0x18, %g4
4000a4f8: 85 28 a0 10 sll %g2, 0x10, %g2
4000a4fc: 83 28 60 08 sll %g1, 8, %g1
4000a500: 84 10 80 04 or %g2, %g4, %g2
fn->frags = 0;
4000a504: c0 24 a0 0c clr [ %l2 + 0xc ]
fn->size = je32_to_cpu(ri->dsize);
4000a508: 82 10 40 02 or %g1, %g2, %g1
4000a50c: 82 10 c0 01 or %g3, %g1, %g1
if (retried) {
4000a510: 02 bf ff ac be 4000a3c0 <jffs2_write_dnode+0x2c0> <== ALWAYS TAKEN
4000a514: c2 24 a0 08 st %g1, [ %l2 + 8 ]
jffs2_dbg_acct_sanity_check(c,NULL);
4000a518: 92 10 20 00 clr %o1 <== NOT EXECUTED
4000a51c: 40 00 06 47 call 4000be38 <__jffs2_dbg_acct_sanity_check> <== NOT EXECUTED
4000a520: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
4000a524: 30 bf ff a7 b,a 4000a3c0 <jffs2_write_dnode+0x2c0> <== NOT EXECUTED
jffs2_free_full_dnode(fn);
4000a528: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
4000a52c: 7f ff ed 9f call 40005ba8 <jffs2_free_full_dnode> <== NOT EXECUTED
4000a530: a4 10 00 01 mov %g1, %l2 <== NOT EXECUTED
return ERR_CAST(hold_err);
4000a534: 30 bf ff a3 b,a 4000a3c0 <jffs2_write_dnode+0x2c0> <== NOT EXECUTED
4000a9c8 <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)
{
4000a9c8: 9d e3 bf 88 save %sp, -120, %sp
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) {
4000a9cc: 80 a7 60 00 cmp %i5, 0
4000a9d0: 02 80 00 d0 be 4000ad10 <jffs2_write_inode_range+0x348> <== NEVER TAKEN
4000a9d4: c0 27 bf ec clr [ %fp + -20 ]
struct jffs2_full_dnode *fn;
unsigned char *comprbuf = NULL;
4000a9d8: ac 10 20 02 mov 2, %l6
PAGE_SIZE - (offset & (PAGE_SIZE-1)));
cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen);
comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
4000a9dc: aa 10 20 19 mov 0x19, %l5
unsigned char *comprbuf = NULL;
4000a9e0: c0 27 bf f0 clr [ %fp + -16 ]
datalen = min_t(uint32_t, writelen,
4000a9e4: a2 0f 2f ff and %i4, 0xfff, %l1
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
ri->ino = cpu_to_je32(f->inocache->ino);
ri->version = cpu_to_je32(++f->highest_version);
ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
ri->offset = cpu_to_je32(offset);
4000a9e8: a7 37 20 10 srl %i4, 0x10, %l3
4000a9ec: a5 37 20 08 srl %i4, 8, %l2
datalen = min_t(uint32_t, writelen,
4000a9f0: 03 00 00 04 sethi %hi(0x1000), %g1
unsigned char *comprbuf = NULL;
4000a9f4: a8 10 20 02 mov 2, %l4
datalen = min_t(uint32_t, writelen,
4000a9f8: a2 20 40 11 sub %g1, %l1, %l1
ri->offset = cpu_to_je32(offset);
4000a9fc: a6 0c e0 ff and %l3, 0xff, %l3
4000aa00: a4 0c a0 ff and %l2, 0xff, %l2
ret = jffs2_reserve_space(c, sizeof(*ri) + JFFS2_MIN_DATA_LEN,
4000aa04: 98 10 20 12 mov 0x12, %o4
4000aa08: 96 10 20 00 clr %o3
4000aa0c: 94 07 bf f4 add %fp, -12, %o2
4000aa10: 92 10 20 c4 mov 0xc4, %o1
4000aa14: 7f ff f3 5e call 4000778c <jffs2_reserve_space>
4000aa18: 90 10 00 18 mov %i0, %o0
if (ret) {
4000aa1c: 80 a2 20 00 cmp %o0, 0
4000aa20: 12 80 00 9b bne 4000ac8c <jffs2_write_inode_range+0x2c4>
4000aa24: 80 a4 40 1d cmp %l1, %i5
datalen = min_t(uint32_t, writelen,
4000aa28: 08 80 00 03 bleu 4000aa34 <jffs2_write_inode_range+0x6c>
4000aa2c: 84 10 00 11 mov %l1, %g2
4000aa30: 84 10 00 1d mov %i5, %g2
4000aa34: c4 27 bf f8 st %g2, [ %fp + -8 ]
cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen);
4000aa38: c2 07 bf f4 ld [ %fp + -12 ], %g1
4000aa3c: 82 00 7f bc add %g1, -68, %g1
4000aa40: 80 a0 40 02 cmp %g1, %g2
4000aa44: 38 80 00 02 bgu,a 4000aa4c <jffs2_write_inode_range+0x84>
4000aa48: 82 10 00 02 mov %g2, %g1
comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
4000aa4c: 9a 07 bf fc add %fp, -4, %o5
cdatalen = min_t(uint32_t, alloclen - sizeof(*ri), datalen);
4000aa50: c2 27 bf fc st %g1, [ %fp + -4 ]
comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
4000aa54: 98 07 bf f8 add %fp, -8, %o4
4000aa58: 96 07 bf f0 add %fp, -16, %o3
4000aa5c: 94 10 00 1b mov %i3, %o2
4000aa60: 92 10 00 19 mov %i1, %o1
4000aa64: 40 00 04 56 call 4000bbbc <jffs2_compress>
4000aa68: 90 10 00 18 mov %i0, %o0
ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen);
4000aa6c: c2 07 bf fc ld [ %fp + -4 ], %g1
4000aa70: 82 00 60 44 add %g1, 0x44, %g1
4000aa74: 89 30 60 18 srl %g1, 0x18, %g4
4000aa78: c8 2e a0 04 stb %g4, [ %i2 + 4 ]
ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
4000aa7c: 88 10 3f 85 mov -123, %g4
ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen);
4000aa80: 87 30 60 10 srl %g1, 0x10, %g3
4000aa84: 85 30 60 08 srl %g1, 8, %g2
ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
4000aa88: c8 2e a0 01 stb %g4, [ %i2 + 1 ]
ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
4000aa8c: 88 10 3f e0 mov -32, %g4
ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen);
4000aa90: c6 2e a0 05 stb %g3, [ %i2 + 5 ]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000aa94: 94 10 20 08 mov 8, %o2
ri->nodetype = cpu_to_je16(JFFS2_NODETYPE_INODE);
4000aa98: c8 2e a0 02 stb %g4, [ %i2 + 2 ]
comprtype = jffs2_compress(c, f, buf, &comprbuf, &datalen, &cdatalen);
4000aa9c: a0 10 00 08 mov %o0, %l0
ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen);
4000aaa0: c4 2e a0 06 stb %g2, [ %i2 + 6 ]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000aaa4: 92 10 00 1a mov %i2, %o1
ri->totlen = cpu_to_je32(sizeof(*ri) + cdatalen);
4000aaa8: c2 2e a0 07 stb %g1, [ %i2 + 7 ]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000aaac: 90 10 20 00 clr %o0
ri->magic = cpu_to_je16(JFFS2_MAGIC_BITMASK);
4000aab0: ea 2e 80 00 stb %l5, [ %i2 ]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000aab4: 40 00 04 31 call 4000bb78 <cyg_crc32_accumulate>
4000aab8: ec 2e a0 03 stb %l6, [ %i2 + 3 ]
ri->ino = cpu_to_je32(f->inocache->ino);
4000aabc: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
4000aac0: c8 08 60 0c ldub [ %g1 + 0xc ], %g4
4000aac4: c6 08 60 0d ldub [ %g1 + 0xd ], %g3
4000aac8: da 08 60 0e ldub [ %g1 + 0xe ], %o5
4000aacc: de 08 60 0f ldub [ %g1 + 0xf ], %o7
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000aad0: 83 32 20 18 srl %o0, 0x18, %g1
ri->version = cpu_to_je32(++f->highest_version);
4000aad4: c4 06 40 00 ld [ %i1 ], %g2
ri->ino = cpu_to_je32(f->inocache->ino);
4000aad8: c8 2e a0 0c stb %g4, [ %i2 + 0xc ]
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000aadc: 89 32 20 10 srl %o0, 0x10, %g4
4000aae0: c2 2e a0 08 stb %g1, [ %i2 + 8 ]
4000aae4: 83 32 20 08 srl %o0, 8, %g1
4000aae8: c8 2e a0 09 stb %g4, [ %i2 + 9 ]
ri->version = cpu_to_je32(++f->highest_version);
4000aaec: 84 00 a0 01 inc %g2
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000aaf0: c2 2e a0 0a stb %g1, [ %i2 + 0xa ]
ri->version = cpu_to_je32(++f->highest_version);
4000aaf4: 89 30 a0 18 srl %g2, 0x18, %g4
ri->ino = cpu_to_je32(f->inocache->ino);
4000aaf8: c6 2e a0 0d stb %g3, [ %i2 + 0xd ]
ri->version = cpu_to_je32(++f->highest_version);
4000aafc: 87 30 a0 10 srl %g2, 0x10, %g3
ri->hdr_crc = cpu_to_je32(crc32(0, ri, sizeof(struct jffs2_unknown_node)-4));
4000ab00: d0 2e a0 0b stb %o0, [ %i2 + 0xb ]
ri->version = cpu_to_je32(++f->highest_version);
4000ab04: 83 30 a0 08 srl %g2, 8, %g1
ri->ino = cpu_to_je32(f->inocache->ino);
4000ab08: da 2e a0 0e stb %o5, [ %i2 + 0xe ]
4000ab0c: de 2e a0 0f stb %o7, [ %i2 + 0xf ]
ri->version = cpu_to_je32(++f->highest_version);
4000ab10: c4 26 40 00 st %g2, [ %i1 ]
4000ab14: c8 2e a0 10 stb %g4, [ %i2 + 0x10 ]
4000ab18: c6 2e a0 11 stb %g3, [ %i2 + 0x11 ]
4000ab1c: c2 2e a0 12 stb %g1, [ %i2 + 0x12 ]
4000ab20: c4 2e a0 13 stb %g2, [ %i2 + 0x13 ]
ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
4000ab24: c6 0e a0 1c ldub [ %i2 + 0x1c ], %g3
4000ab28: d4 0e a0 1d ldub [ %i2 + 0x1d ], %o2
4000ab2c: 87 28 e0 18 sll %g3, 0x18, %g3
4000ab30: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000ab34: c4 0e a0 1e ldub [ %i2 + 0x1e ], %g2
4000ab38: c8 0e a0 1f ldub [ %i2 + 0x1f ], %g4
4000ab3c: 95 2a a0 10 sll %o2, 0x10, %o2
4000ab40: 94 12 80 03 or %o2, %g3, %o2
4000ab44: 85 28 a0 08 sll %g2, 8, %g2
4000ab48: 86 00 40 1c add %g1, %i4, %g3
4000ab4c: 84 10 80 0a or %g2, %o2, %g2
4000ab50: 94 11 00 02 or %g4, %g2, %o2
4000ab54: 80 a2 80 03 cmp %o2, %g3
4000ab58: 2a 80 00 02 bcs,a 4000ab60 <jffs2_write_inode_range+0x198>
4000ab5c: 94 10 00 03 mov %g3, %o2
ri->csize = cpu_to_je32(cdatalen);
4000ab60: c4 07 bf fc ld [ %fp + -4 ], %g2
ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
4000ab64: 93 32 a0 18 srl %o2, 0x18, %o1
4000ab68: 87 32 a0 10 srl %o2, 0x10, %g3
ri->csize = cpu_to_je32(cdatalen);
4000ab6c: 97 30 a0 10 srl %g2, 0x10, %o3
4000ab70: 99 30 a0 08 srl %g2, 8, %o4
ri->dsize = cpu_to_je32(datalen);
4000ab74: 9b 30 60 18 srl %g1, 0x18, %o5
4000ab78: 9f 30 60 10 srl %g1, 0x10, %o7
ri->csize = cpu_to_je32(cdatalen);
4000ab7c: af 30 a0 18 srl %g2, 0x18, %l7
ri->dsize = cpu_to_je32(datalen);
4000ab80: 89 30 60 08 srl %g1, 8, %g4
ri->csize = cpu_to_je32(cdatalen);
4000ab84: d6 2e a0 31 stb %o3, [ %i2 + 0x31 ]
ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
4000ab88: 91 32 a0 08 srl %o2, 8, %o0
ri->csize = cpu_to_je32(cdatalen);
4000ab8c: d8 2e a0 32 stb %o4, [ %i2 + 0x32 ]
ri->dsize = cpu_to_je32(datalen);
4000ab90: da 2e a0 34 stb %o5, [ %i2 + 0x34 ]
4000ab94: de 2e a0 35 stb %o7, [ %i2 + 0x35 ]
ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
4000ab98: d2 2e a0 1c stb %o1, [ %i2 + 0x1c ]
ri->offset = cpu_to_je32(offset);
4000ab9c: 93 37 20 18 srl %i4, 0x18, %o1
ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
4000aba0: c6 2e a0 1d stb %g3, [ %i2 + 0x1d ]
ri->compr = comprtype & 0xff;
ri->usercompr = (comprtype >> 8 ) & 0xff;
4000aba4: 87 2c 20 10 sll %l0, 0x10, %g3
ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
4000aba8: d0 2e a0 1e stb %o0, [ %i2 + 0x1e ]
ri->usercompr = (comprtype >> 8 ) & 0xff;
4000abac: 87 30 e0 18 srl %g3, 0x18, %g3
ri->isize = cpu_to_je32(max(je32_to_cpu(ri->isize), offset + datalen));
4000abb0: d4 2e a0 1f stb %o2, [ %i2 + 0x1f ]
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000abb4: 90 10 20 00 clr %o0
ri->offset = cpu_to_je32(offset);
4000abb8: d2 2e a0 2c stb %o1, [ %i2 + 0x2c ]
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000abbc: 94 10 20 3c mov 0x3c, %o2
ri->csize = cpu_to_je32(cdatalen);
4000abc0: ee 2e a0 30 stb %l7, [ %i2 + 0x30 ]
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000abc4: 92 10 00 1a mov %i2, %o1
ri->csize = cpu_to_je32(cdatalen);
4000abc8: c4 2e a0 33 stb %g2, [ %i2 + 0x33 ]
ri->dsize = cpu_to_je32(datalen);
4000abcc: c8 2e a0 36 stb %g4, [ %i2 + 0x36 ]
4000abd0: c2 2e a0 37 stb %g1, [ %i2 + 0x37 ]
ri->usercompr = (comprtype >> 8 ) & 0xff;
4000abd4: c6 2e a0 39 stb %g3, [ %i2 + 0x39 ]
ri->offset = cpu_to_je32(offset);
4000abd8: e6 2e a0 2d stb %l3, [ %i2 + 0x2d ]
4000abdc: e4 2e a0 2e stb %l2, [ %i2 + 0x2e ]
4000abe0: f8 2e a0 2f stb %i4, [ %i2 + 0x2f ]
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000abe4: 40 00 03 e5 call 4000bb78 <cyg_crc32_accumulate>
4000abe8: e0 2e a0 38 stb %l0, [ %i2 + 0x38 ]
4000abec: 82 10 00 08 mov %o0, %g1
4000abf0: 89 32 20 18 srl %o0, 0x18, %g4
4000abf4: 87 32 20 10 srl %o0, 0x10, %g3
4000abf8: 85 32 20 08 srl %o0, 8, %g2
4000abfc: c8 2e a0 40 stb %g4, [ %i2 + 0x40 ]
ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
4000ac00: 90 10 20 00 clr %o0
ri->node_crc = cpu_to_je32(crc32(0, ri, sizeof(*ri)-8));
4000ac04: c6 2e a0 41 stb %g3, [ %i2 + 0x41 ]
4000ac08: c4 2e a0 42 stb %g2, [ %i2 + 0x42 ]
4000ac0c: c2 2e a0 43 stb %g1, [ %i2 + 0x43 ]
ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
4000ac10: d4 07 bf fc ld [ %fp + -4 ], %o2
4000ac14: 40 00 03 d9 call 4000bb78 <cyg_crc32_accumulate>
4000ac18: d2 07 bf f0 ld [ %fp + -16 ], %o1
4000ac1c: 87 32 20 18 srl %o0, 0x18, %g3
4000ac20: 85 32 20 10 srl %o0, 0x10, %g2
4000ac24: 83 32 20 08 srl %o0, 8, %g1
4000ac28: d0 2e a0 3f stb %o0, [ %i2 + 0x3f ]
fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY);
4000ac2c: 9a 10 20 03 mov 3, %o5
ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
4000ac30: c6 2e a0 3c stb %g3, [ %i2 + 0x3c ]
fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY);
4000ac34: 94 10 00 1a mov %i2, %o2
ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
4000ac38: c4 2e a0 3d stb %g2, [ %i2 + 0x3d ]
fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY);
4000ac3c: 92 10 00 19 mov %i1, %o1
ri->data_crc = cpu_to_je32(crc32(0, comprbuf, cdatalen));
4000ac40: c2 2e a0 3e stb %g1, [ %i2 + 0x3e ]
fn = jffs2_write_dnode(c, f, ri, comprbuf, cdatalen, ALLOC_NORETRY);
4000ac44: 90 10 00 18 mov %i0, %o0
4000ac48: d8 07 bf fc ld [ %fp + -4 ], %o4
4000ac4c: 7f ff fd 2d call 4000a100 <jffs2_write_dnode>
4000ac50: d6 07 bf f0 ld [ %fp + -16 ], %o3
jffs2_free_comprbuf(comprbuf, buf);
if (IS_ERR(fn)) {
4000ac54: 80 a2 3c 18 cmp %o0, -1000
4000ac58: 08 80 00 0f bleu 4000ac94 <jffs2_write_inode_range+0x2cc> <== ALWAYS TAKEN
4000ac5c: ae 10 00 08 mov %o0, %l7
ret = PTR_ERR(fn);
mutex_unlock(&f->sem);
jffs2_complete_reservation(c);
4000ac60: 7f ff f0 a2 call 40006ee8 <jffs2_complete_reservation> <== NOT EXECUTED
4000ac64: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (!retried) {
4000ac68: 80 a5 20 01 cmp %l4, 1 <== NOT EXECUTED
4000ac6c: 12 bf ff 66 bne 4000aa04 <jffs2_write_inode_range+0x3c> <== NOT EXECUTED
4000ac70: a8 10 20 01 mov 1, %l4 <== NOT EXECUTED
ret = PTR_ERR(fn);
4000ac74: a0 10 00 17 mov %l7, %l0 <== NOT EXECUTED
writtenlen += datalen;
offset += datalen;
writelen -= datalen;
buf += datalen;
}
*retlen = writtenlen;
4000ac78: c2 07 a0 5c ld [ %fp + 0x5c ], %g1
4000ac7c: c4 07 bf ec ld [ %fp + -20 ], %g2
4000ac80: c4 20 40 00 st %g2, [ %g1 ]
return ret;
}
4000ac84: 81 c7 e0 08 ret
4000ac88: 91 e8 00 10 restore %g0, %l0, %o0
4000ac8c: 10 bf ff fb b 4000ac78 <jffs2_write_inode_range+0x2b0>
4000ac90: a0 10 00 08 mov %o0, %l0
ret = jffs2_add_full_dnode_to_inode(c, f, fn);
4000ac94: 94 10 00 08 mov %o0, %o2
4000ac98: 92 10 00 19 mov %i1, %o1
4000ac9c: 7f ff ec fe call 40006094 <jffs2_add_full_dnode_to_inode>
4000aca0: 90 10 00 18 mov %i0, %o0
if (f->metadata) {
4000aca4: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000aca8: 80 a0 60 00 cmp %g1, 0
4000acac: 02 80 00 08 be 4000accc <jffs2_write_inode_range+0x304>
4000acb0: a0 10 00 08 mov %o0, %l0
jffs2_mark_node_obsolete(c, f->metadata->raw);
4000acb4: d2 00 40 00 ld [ %g1 ], %o1
4000acb8: 7f ff f0 96 call 40006f10 <jffs2_mark_node_obsolete>
4000acbc: 90 10 00 18 mov %i0, %o0
jffs2_free_full_dnode(f->metadata);
4000acc0: 7f ff eb ba call 40005ba8 <jffs2_free_full_dnode>
4000acc4: d0 06 60 08 ld [ %i1 + 8 ], %o0
f->metadata = NULL;
4000acc8: c0 26 60 08 clr [ %i1 + 8 ]
if (ret) {
4000accc: 80 a4 20 00 cmp %l0, 0
4000acd0: 32 80 00 18 bne,a 4000ad30 <jffs2_write_inode_range+0x368> <== NEVER TAKEN
4000acd4: d2 05 c0 00 ld [ %l7 ], %o1 <== NOT EXECUTED
jffs2_complete_reservation(c);
4000acd8: 7f ff f0 84 call 40006ee8 <jffs2_complete_reservation>
4000acdc: 90 10 00 18 mov %i0, %o0
if (!datalen) {
4000ace0: c2 07 bf f8 ld [ %fp + -8 ], %g1
4000ace4: 80 a0 60 00 cmp %g1, 0
4000ace8: 02 80 00 0c be 4000ad18 <jffs2_write_inode_range+0x350> <== NEVER TAKEN
4000acec: c4 07 bf ec ld [ %fp + -20 ], %g2
writtenlen += datalen;
4000acf0: 84 00 80 01 add %g2, %g1, %g2
4000acf4: c4 27 bf ec st %g2, [ %fp + -20 ]
offset += datalen;
4000acf8: b8 07 00 01 add %i4, %g1, %i4
while(writelen) {
4000acfc: ba a7 40 01 subcc %i5, %g1, %i5
4000ad00: 12 bf ff 38 bne 4000a9e0 <jffs2_write_inode_range+0x18>
4000ad04: b6 06 c0 01 add %i3, %g1, %i3
*retlen = writtenlen;
4000ad08: 10 bf ff dd b 4000ac7c <jffs2_write_inode_range+0x2b4>
4000ad0c: c2 07 a0 5c ld [ %fp + 0x5c ], %g1
while(writelen) {
4000ad10: 10 bf ff da b 4000ac78 <jffs2_write_inode_range+0x2b0> <== NOT EXECUTED
4000ad14: a0 10 20 00 clr %l0 <== NOT EXECUTED
ret = -EIO;
4000ad18: a0 10 3f fb mov -5, %l0 <== NOT EXECUTED
pr_warn("Eep. We didn't actually write any data in jffs2_write_inode_range()\n");
4000ad1c: 11 10 00 80 sethi %hi(0x40020000), %o0 <== NOT EXECUTED
4000ad20: 7f ff fc aa call 40009fc8 <jffs2_printk> <== NOT EXECUTED
4000ad24: 90 12 22 08 or %o0, 0x208, %o0 ! 40020208 <__func__.10+0x180> <== NOT EXECUTED
break;
4000ad28: 10 bf ff d5 b 4000ac7c <jffs2_write_inode_range+0x2b4> <== NOT EXECUTED
4000ad2c: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 <== NOT EXECUTED
jffs2_mark_node_obsolete(c, fn->raw);
4000ad30: 7f ff f0 78 call 40006f10 <jffs2_mark_node_obsolete> <== NOT EXECUTED
4000ad34: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
jffs2_free_full_dnode(fn);
4000ad38: 7f ff eb 9c call 40005ba8 <jffs2_free_full_dnode> <== NOT EXECUTED
4000ad3c: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
jffs2_complete_reservation(c);
4000ad40: 7f ff f0 6a call 40006ee8 <jffs2_complete_reservation> <== NOT EXECUTED
4000ad44: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
break;
4000ad48: 10 bf ff cd b 4000ac7c <jffs2_write_inode_range+0x2b4> <== NOT EXECUTED
4000ad4c: c2 07 a0 5c ld [ %fp + 0x5c ], %g1 <== NOT EXECUTED
40001a5c <rtems_jffs2_compressor_rtime_compress>:
unsigned char *data_in,
unsigned char *cpage_out,
uint32_t *sourcelen,
uint32_t *dstlen
)
{
40001a5c: 9d e3 bd a0 save %sp, -608, %sp
int outpos = 0;
int pos=0;
(void) self;
memset(positions,0,sizeof(positions));
40001a60: 94 10 22 00 mov 0x200, %o2
40001a64: 92 10 20 00 clr %o1
40001a68: 40 00 6d 6f call 4001d024 <memset>
40001a6c: 90 07 be 00 add %fp, -512, %o0
while (pos < (*sourcelen) && outpos <= (*dstlen)-2) {
40001a70: c2 06 c0 00 ld [ %i3 ], %g1
40001a74: 80 a0 60 00 cmp %g1, 0
40001a78: 02 80 00 40 be 40001b78 <rtems_jffs2_compressor_rtime_compress+0x11c> <== NEVER TAKEN
40001a7c: 88 10 20 00 clr %g4
int pos=0;
40001a80: 82 10 20 00 clr %g1
int outpos = 0;
40001a84: 98 10 20 00 clr %o4
40001a88: 96 06 bf ff add %i2, -1, %o3
int backpos, runlen=0;
unsigned char value;
value = data_in[pos];
40001a8c: c6 0e 40 04 ldub [ %i1 + %g4 ], %g3
cpage_out[outpos++] = data_in[pos++];
40001a90: 82 00 60 01 inc %g1
backpos = positions[value];
40001a94: 84 08 e0 ff and %g3, 0xff, %g2
cpage_out[outpos++] = data_in[pos++];
40001a98: c6 2e 80 0c stb %g3, [ %i2 + %o4 ]
backpos = positions[value];
40001a9c: 85 28 a0 01 sll %g2, 1, %g2
40001aa0: 84 07 80 02 add %fp, %g2, %g2
40001aa4: f0 10 be 00 lduh [ %g2 + -512 ], %i0
positions[value]=pos;
40001aa8: c2 30 be 00 sth %g1, [ %g2 + -512 ]
backpos = positions[value];
40001aac: b1 2e 20 10 sll %i0, 0x10, %i0
while ((backpos < pos) && (pos < (*sourcelen)) &&
40001ab0: 88 10 00 01 mov %g1, %g4
backpos = positions[value];
40001ab4: b1 36 20 10 srl %i0, 0x10, %i0
while ((backpos < pos) && (pos < (*sourcelen)) &&
40001ab8: 80 a0 40 18 cmp %g1, %i0
40001abc: 04 80 00 17 ble 40001b18 <rtems_jffs2_compressor_rtime_compress+0xbc> <== NEVER TAKEN
40001ac0: 84 10 20 00 clr %g2
(data_in[pos]==data_in[backpos++]) && (runlen<255)) {
40001ac4: 9a 06 40 18 add %i1, %i0, %o5
while ((backpos < pos) && (pos < (*sourcelen)) &&
40001ac8: de 06 c0 00 ld [ %i3 ], %o7
int backpos, runlen=0;
40001acc: 84 10 20 00 clr %g2
while ((backpos < pos) && (pos < (*sourcelen)) &&
40001ad0: 10 80 00 0f b 40001b0c <rtems_jffs2_compressor_rtime_compress+0xb0>
40001ad4: b0 06 3f ff add %i0, -1, %i0
40001ad8: fa 0e 40 01 ldub [ %i1 + %g1 ], %i5
40001adc: c6 0b 40 02 ldub [ %o5 + %g2 ], %g3
40001ae0: 80 a7 40 03 cmp %i5, %g3
40001ae4: 12 80 00 0d bne 40001b18 <rtems_jffs2_compressor_rtime_compress+0xbc>
40001ae8: 80 a0 a0 ff cmp %g2, 0xff
(data_in[pos]==data_in[backpos++]) && (runlen<255)) {
40001aec: 02 80 00 21 be 40001b70 <rtems_jffs2_compressor_rtime_compress+0x114>
40001af0: 86 00 60 01 add %g1, 1, %g3
pos++;
runlen++;
40001af4: 84 00 a0 01 inc %g2
while ((backpos < pos) && (pos < (*sourcelen)) &&
40001af8: ba 06 00 02 add %i0, %g2, %i5
40001afc: 80 a7 40 01 cmp %i5, %g1
40001b00: 16 80 00 1a bge 40001b68 <rtems_jffs2_compressor_rtime_compress+0x10c> <== NEVER TAKEN
40001b04: 88 10 00 03 mov %g3, %g4
pos++;
40001b08: 82 10 00 03 mov %g3, %g1
while ((backpos < pos) && (pos < (*sourcelen)) &&
40001b0c: 80 a3 c0 01 cmp %o7, %g1
40001b10: 18 bf ff f2 bgu 40001ad8 <rtems_jffs2_compressor_rtime_compress+0x7c>
40001b14: 88 10 00 01 mov %g1, %g4
}
cpage_out[outpos++] = runlen;
40001b18: 98 03 20 02 add %o4, 2, %o4
40001b1c: c4 2a c0 0c stb %g2, [ %o3 + %o4 ]
while (pos < (*sourcelen) && outpos <= (*dstlen)-2) {
40001b20: c4 06 c0 00 ld [ %i3 ], %g2
40001b24: 80 a0 80 04 cmp %g2, %g4
40001b28: 08 80 00 08 bleu 40001b48 <rtems_jffs2_compressor_rtime_compress+0xec>
40001b2c: 80 a3 00 01 cmp %o4, %g1
40001b30: c4 07 00 00 ld [ %i4 ], %g2
40001b34: 84 00 bf fe add %g2, -2, %g2
40001b38: 80 a0 80 0c cmp %g2, %o4
40001b3c: 3a bf ff d5 bcc,a 40001a90 <rtems_jffs2_compressor_rtime_compress+0x34>
40001b40: c6 0e 40 04 ldub [ %i1 + %g4 ], %g3
}
if (outpos >= pos) {
40001b44: 80 a3 00 01 cmp %o4, %g1
40001b48: 16 80 00 0c bge 40001b78 <rtems_jffs2_compressor_rtime_compress+0x11c>
40001b4c: 82 10 20 02 mov 2, %g1
/* We failed */
return JFFS2_COMPR_NONE;
}
/* Tell the caller how much we managed to compress, and how much space it took */
*sourcelen = pos;
40001b50: c8 26 c0 00 st %g4, [ %i3 ]
*dstlen = outpos;
40001b54: d8 27 00 00 st %o4, [ %i4 ]
return JFFS2_COMPR_RTIME;
}
40001b58: 83 28 60 10 sll %g1, 0x10, %g1
40001b5c: b1 30 60 10 srl %g1, 0x10, %i0
40001b60: 81 c7 e0 08 ret
40001b64: 81 e8 00 00 restore
pos++;
40001b68: 10 bf ff ec b 40001b18 <rtems_jffs2_compressor_rtime_compress+0xbc> <== NOT EXECUTED
40001b6c: 82 10 00 03 mov %g3, %g1 <== NOT EXECUTED
40001b70: 10 bf ff ea b 40001b18 <rtems_jffs2_compressor_rtime_compress+0xbc>
40001b74: 84 10 3f ff mov -1, %g2
return JFFS2_COMPR_NONE;
40001b78: 82 10 20 00 clr %g1
}
40001b7c: 83 28 60 10 sll %g1, 0x10, %g1
40001b80: b1 30 60 10 srl %g1, 0x10, %i0
40001b84: 81 c7 e0 08 ret
40001b88: 81 e8 00 00 restore
40001b8c <rtems_jffs2_compressor_rtime_decompress>:
unsigned char *data_in,
unsigned char *cpage_out,
uint32_t srclen,
uint32_t destlen
)
{
40001b8c: 9d e3 bd a0 save %sp, -608, %sp
int outpos = 0;
int pos=0;
(void) self;
if (comprtype != JFFS2_COMPR_RTIME) {
40001b90: 80 a6 60 02 cmp %i1, 2
40001b94: 12 80 00 37 bne 40001c70 <rtems_jffs2_compressor_rtime_decompress+0xe4> <== NEVER TAKEN
40001b98: 94 10 22 00 mov 0x200, %o2
return -EIO;
}
memset(positions,0,sizeof(positions));
40001b9c: 92 10 20 00 clr %o1
40001ba0: 40 00 6d 21 call 4001d024 <memset>
40001ba4: 90 07 be 00 add %fp, -512, %o0
int outpos = 0;
40001ba8: 84 10 20 00 clr %g2
while (outpos<destlen) {
40001bac: 80 a7 60 00 cmp %i5, 0
40001bb0: 12 80 00 11 bne 40001bf4 <rtems_jffs2_compressor_rtime_decompress+0x68> <== ALWAYS TAKEN
40001bb4: b8 10 20 00 clr %i4
memcpy(&cpage_out[outpos],&cpage_out[backoffs],repeat);
outpos+=repeat;
}
}
}
return 0;
40001bb8: 81 c7 e0 08 ret <== NOT EXECUTED
40001bbc: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
backoffs = positions[value];
40001bc0: 93 32 60 10 srl %o1, 0x10, %o1
if (backoffs + repeat >= outpos) {
40001bc4: 82 02 40 19 add %o1, %i1, %g1
40001bc8: 80 a0 40 1c cmp %g1, %i4
40001bcc: 16 80 00 1c bge 40001c3c <rtems_jffs2_compressor_rtime_decompress+0xb0>
40001bd0: 90 06 c0 1c add %i3, %i4, %o0
memcpy(&cpage_out[outpos],&cpage_out[backoffs],repeat);
40001bd4: 94 10 00 19 mov %i1, %o2
40001bd8: 40 00 6c d4 call 4001cf28 <memcpy>
40001bdc: 92 06 c0 09 add %i3, %o1, %o1
outpos+=repeat;
40001be0: 84 07 00 19 add %i4, %i1, %g2
while (outpos<destlen) {
40001be4: b8 10 00 02 mov %g2, %i4
40001be8: 80 a7 40 1c cmp %i5, %i4
40001bec: 08 80 00 12 bleu 40001c34 <rtems_jffs2_compressor_rtime_decompress+0xa8>
40001bf0: b4 06 a0 02 add %i2, 2, %i2
value = data_in[pos++];
40001bf4: c2 0e 80 00 ldub [ %i2 ], %g1
cpage_out[outpos++] = value; /* first the verbatim copied byte */
40001bf8: c2 2e c0 1c stb %g1, [ %i3 + %i4 ]
40001bfc: b8 00 a0 01 add %g2, 1, %i4
backoffs = positions[value];
40001c00: 82 08 60 ff and %g1, 0xff, %g1
40001c04: 83 28 60 01 sll %g1, 1, %g1
40001c08: 82 07 80 01 add %fp, %g1, %g1
40001c0c: d2 10 7e 00 lduh [ %g1 + -512 ], %o1
positions[value]=outpos;
40001c10: f8 30 7e 00 sth %i4, [ %g1 + -512 ]
repeat = data_in[pos++];
40001c14: f2 0e a0 01 ldub [ %i2 + 1 ], %i1
if (repeat) {
40001c18: 80 a6 60 00 cmp %i1, 0
40001c1c: 32 bf ff e9 bne,a 40001bc0 <rtems_jffs2_compressor_rtime_decompress+0x34>
40001c20: 93 2a 60 10 sll %o1, 0x10, %o1
cpage_out[outpos++] = value; /* first the verbatim copied byte */
40001c24: 84 10 00 1c mov %i4, %g2
while (outpos<destlen) {
40001c28: 80 a7 40 1c cmp %i5, %i4
40001c2c: 18 bf ff f2 bgu 40001bf4 <rtems_jffs2_compressor_rtime_decompress+0x68>
40001c30: b4 06 a0 02 add %i2, 2, %i2
return 0;
40001c34: 81 c7 e0 08 ret
40001c38: 91 e8 20 00 restore %g0, 0, %o0
40001c3c: 82 06 c0 02 add %i3, %g2, %g1
40001c40: 88 00 40 19 add %g1, %i1, %g4
cpage_out[outpos++] = cpage_out[backoffs++];
40001c44: 86 20 40 02 sub %g1, %g2, %g3
40001c48: c6 08 c0 09 ldub [ %g3 + %o1 ], %g3
40001c4c: c6 28 60 01 stb %g3, [ %g1 + 1 ]
while(repeat) {
40001c50: 82 00 60 01 inc %g1
40001c54: 80 a1 00 01 cmp %g4, %g1
40001c58: 12 bf ff fc bne 40001c48 <rtems_jffs2_compressor_rtime_decompress+0xbc>
40001c5c: 86 20 40 02 sub %g1, %g2, %g3
cpage_out[outpos++] = cpage_out[backoffs++];
40001c60: 84 00 80 19 add %g2, %i1, %g2
40001c64: 84 00 a0 01 inc %g2
while (outpos<destlen) {
40001c68: 10 bf ff e0 b 40001be8 <rtems_jffs2_compressor_rtime_decompress+0x5c>
40001c6c: b8 10 00 02 mov %g2, %i4
return -EIO;
40001c70: b0 10 3f fb mov -5, %i0 <== NOT EXECUTED
}
40001c74: 81 c7 e0 08 ret <== NOT EXECUTED
40001c78: 81 e8 00 00 restore <== NOT EXECUTED
40003cac <rtems_jffs2_initialize>:
{
40003cac: 9d e3 bf a0 save %sp, -96, %sp
rtems_jffs2_flash_control *fc = jffs2_mount_data->flash_control;
40003cb0: f6 06 40 00 ld [ %i1 ], %i3
int inocache_hashsize = calculate_inocache_hashsize(fc->flash_size);
40003cb4: f4 06 e0 04 ld [ %i3 + 4 ], %i2
int size_mb = flash_size / 1024 / 1024;
40003cb8: b9 36 a0 14 srl %i2, 0x14, %i4
int hashsize = (size_mb * 2) & ~0x3f;
40003cbc: b9 2f 20 01 sll %i4, 1, %i4
40003cc0: b8 0f 3f c0 and %i4, -64, %i4
40003cc4: 80 a7 24 00 cmp %i4, 0x400
{
40003cc8: 04 80 00 58 ble 40003e28 <rtems_jffs2_initialize+0x17c> <== ALWAYS TAKEN
40003ccc: a0 10 00 18 mov %i0, %l0
40003cd0: b8 10 24 00 mov 0x400, %i4 <== NOT EXECUTED
sizeof(*fs_info) + (size_t) inocache_hashsize * sizeof(fs_info->inode_cache[0])
40003cd4: 92 07 24 82 add %i4, 0x482, %o1
rtems_jffs2_fs_info *fs_info = calloc(
40003cd8: 90 10 20 01 mov 1, %o0
40003cdc: 40 00 2b 57 call 4000ea38 <calloc>
40003ce0: 93 2a 60 02 sll %o1, 2, %o1
if (fs_info != NULL) {
40003ce4: ba 92 20 00 orcc %o0, 0, %i5
40003ce8: 02 80 00 8f be 40003f24 <rtems_jffs2_initialize+0x278> <== NEVER TAKEN
40003cec: 03 00 00 04 sethi %hi(0x1000), %g1
const char *_name)
{
struct _Mutex_recursive_Control _init =
_MUTEX_RECURSIVE_NAMED_INITIALIZER(_name);
*_mutex = _init;
40003cf0: 82 10 60 f0 or %g1, 0xf0, %g1 ! 10f0 <_ISR_Stack_size+0xf0>
40003cf4: c0 27 40 01 clr [ %i5 + %g1 ]
40003cf8: 05 10 00 77 sethi %hi(0x4001dc00), %g2
40003cfc: 82 07 40 01 add %i5, %g1, %g1
40003d00: 84 10 a0 f0 or %g2, 0xf0, %g2
40003d04: c0 20 60 04 clr [ %g1 + 4 ]
40003d08: c0 20 60 08 clr [ %g1 + 8 ]
40003d0c: c0 20 60 0c clr [ %g1 + 0xc ]
40003d10: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
40003d14: c0 20 60 14 clr [ %g1 + 0x14 ]
uint32_t blocks = fc->flash_size / fc->block_size;
40003d18: c2 06 c0 00 ld [ %i3 ], %g1
40003d1c: 81 80 20 00 wr %g0, %y
40003d20: 01 00 00 00 nop
40003d24: 01 00 00 00 nop
40003d28: 01 00 00 00 nop
40003d2c: 92 76 80 01 udiv %i2, %g1, %o1
if ((fc->block_size * blocks) != fc->flash_size) {
40003d30: 92 5a 40 01 smul %o1, %g1, %o1
40003d34: 80 a6 80 09 cmp %i2, %o1
40003d38: 12 80 00 41 bne 40003e3c <rtems_jffs2_initialize+0x190> <== NEVER TAKEN
40003d3c: 85 28 60 02 sll %g1, 2, %g2
if (fc->flash_size < 5*fc->block_size) {
40003d40: 84 00 80 01 add %g2, %g1, %g2
40003d44: 80 a0 80 09 cmp %g2, %o1
40003d48: 18 80 00 49 bgu 40003e6c <rtems_jffs2_initialize+0x1c0> <== NEVER TAKEN
40003d4c: 01 00 00 00 nop
sb->s_is_readonly = !mt_entry->writeable;
40003d50: c4 0c 20 29 ldub [ %l0 + 0x29 ], %g2
sb->s_compressor_control = jffs2_mount_data->compressor_control;
40003d54: c6 06 60 04 ld [ %i1 + 4 ], %g3
sb->s_is_readonly = !mt_entry->writeable;
40003d58: 84 18 a0 01 xor %g2, 1, %g2
c->sector_size = fc->block_size;
40003d5c: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
c->cleanmarker_size = sizeof(struct jffs2_unknown_node);
40003d60: 82 10 20 0c mov 0xc, %g1
sb->s_is_readonly = !mt_entry->writeable;
40003d64: c4 2f 60 ec stb %g2, [ %i5 + 0xec ]
c->inocache_list = &fs_info->inode_cache[0];
40003d68: 05 00 00 04 sethi %hi(0x1000), %g2
sb->s_flash_control = fc;
40003d6c: f6 27 60 e4 st %i3, [ %i5 + 0xe4 ]
c->inocache_list = &fs_info->inode_cache[0];
40003d70: 84 10 a2 08 or %g2, 0x208, %g2
sb->s_compressor_control = jffs2_mount_data->compressor_control;
40003d74: c6 27 60 e8 st %g3, [ %i5 + 0xe8 ]
c->inocache_list = &fs_info->inode_cache[0];
40003d78: 84 07 40 02 add %i5, %g2, %g2
c->inocache_hashsize = inocache_hashsize;
40003d7c: f8 27 60 c0 st %i4, [ %i5 + 0xc0 ]
err = jffs2_do_mount_fs(c);
40003d80: 90 10 00 1d mov %i5, %o0
c->inocache_list = &fs_info->inode_cache[0];
40003d84: c4 27 60 c4 st %g2, [ %i5 + 0xc4 ]
c->flash_size = fc->flash_size;
40003d88: d2 27 60 18 st %o1, [ %i5 + 0x18 ]
err = jffs2_do_mount_fs(c);
40003d8c: 40 00 1d ba call 4000b474 <jffs2_do_mount_fs>
40003d90: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
if (err == 0) {
40003d94: b0 92 20 00 orcc %o0, 0, %i0
40003d98: 12 80 00 74 bne 40003f68 <rtems_jffs2_initialize+0x2bc> <== NEVER TAKEN
40003d9c: 92 10 20 00 clr %o1
for (inode = sb->s_root; inode != NULL; inode = inode->i_cache_next) {
40003da0: c2 07 60 e0 ld [ %i5 + 0xe0 ], %g1
40003da4: 80 a0 60 00 cmp %g1, 0
40003da8: 32 80 00 08 bne,a 40003dc8 <rtems_jffs2_initialize+0x11c> <== NEVER TAKEN
40003dac: c4 00 40 00 ld [ %g1 ], %g2 <== NOT EXECUTED
40003db0: 10 80 00 50 b 40003ef0 <rtems_jffs2_initialize+0x244>
40003db4: 92 10 20 01 mov 1, %o1
40003db8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003dbc: 02 80 00 4d be 40003ef0 <rtems_jffs2_initialize+0x244> <== NOT EXECUTED
40003dc0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
if (inode->i_ino == ino) {
40003dc4: c4 00 40 00 ld [ %g1 ], %g2 <== NOT EXECUTED
40003dc8: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED
40003dcc: 32 bf ff fb bne,a 40003db8 <rtems_jffs2_initialize+0x10c> <== NOT EXECUTED
40003dd0: c2 00 60 68 ld [ %g1 + 0x68 ], %g1 <== NOT EXECUTED
inode->i_count++;
40003dd4: c4 00 60 04 ld [ %g1 + 4 ], %g2 <== NOT EXECUTED
40003dd8: 84 00 a0 01 inc %g2 <== NOT EXECUTED
40003ddc: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
if (IS_ERR(sb->s_root)) {
40003de0: 80 a0 7c 18 cmp %g1, -1000 <== NOT EXECUTED
40003de4: 18 80 00 4c bgu 40003f14 <rtems_jffs2_initialize+0x268> <== NOT EXECUTED
40003de8: c2 27 60 e0 st %g1, [ %i5 + 0xe0 ] <== NOT EXECUTED
sb->s_root->i_parent = sb->s_root;
40003dec: c2 20 60 34 st %g1, [ %g1 + 0x34 ]
if (!jffs2_is_readonly(c)) {
40003df0: c4 0f 60 ec ldub [ %i5 + 0xec ], %g2
40003df4: 80 a0 a0 00 cmp %g2, 0
40003df8: 02 80 00 2f be 40003eb4 <rtems_jffs2_initialize+0x208> <== ALWAYS TAKEN
40003dfc: 05 10 00 78 sethi %hi(0x4001e000), %g2
mt_entry->fs_info = fs_info;
40003e00: fa 24 20 08 st %i5, [ %l0 + 8 ] <== NOT EXECUTED
mt_entry->mt_fs_root->location.node_access = sb->s_root;
40003e04: c6 04 20 24 ld [ %l0 + 0x24 ], %g3 <== NOT EXECUTED
mt_entry->ops = &rtems_jffs2_ops;
40003e08: 84 10 a0 a8 or %g2, 0xa8, %g2 <== NOT EXECUTED
40003e0c: c4 24 20 0c st %g2, [ %l0 + 0xc ] <== NOT EXECUTED
mt_entry->mt_fs_root->location.node_access = sb->s_root;
40003e10: c2 20 e0 08 st %g1, [ %g3 + 8 ] <== NOT EXECUTED
mt_entry->mt_fs_root->location.handlers = &rtems_jffs2_directory_handlers;
40003e14: 03 10 00 78 sethi %hi(0x4001e000), %g1 <== NOT EXECUTED
40003e18: 82 10 61 7c or %g1, 0x17c, %g1 ! 4001e17c <rtems_jffs2_directory_handlers><== NOT EXECUTED
40003e1c: c2 20 e0 10 st %g1, [ %g3 + 0x10 ] <== NOT EXECUTED
return 0;
40003e20: 81 c7 e0 08 ret <== NOT EXECUTED
40003e24: 81 e8 00 00 restore <== NOT EXECUTED
40003e28: 80 a7 20 80 cmp %i4, 0x80
40003e2c: 26 bf ff aa bl,a 40003cd4 <rtems_jffs2_initialize+0x28> <== ALWAYS TAKEN
40003e30: b8 10 20 80 mov 0x80, %i4
sizeof(*fs_info) + (size_t) inocache_hashsize * sizeof(fs_info->inode_cache[0])
40003e34: 10 bf ff a9 b 40003cd8 <rtems_jffs2_initialize+0x2c> <== NOT EXECUTED
40003e38: 92 07 24 82 add %i4, 0x482, %o1 <== NOT EXECUTED
fc->flash_size = fc->block_size * blocks;
40003e3c: d2 26 e0 04 st %o1, [ %i3 + 4 ] <== NOT EXECUTED
pr_info("Flash size not aligned to erasesize, reducing to %dKiB\n",
40003e40: 11 10 00 78 sethi %hi(0x4001e000), %o0 <== NOT EXECUTED
40003e44: 93 32 60 0a srl %o1, 0xa, %o1 <== NOT EXECUTED
40003e48: 7f ff fc f3 call 40003214 <jffs2_printk> <== NOT EXECUTED
40003e4c: 90 12 20 20 or %o0, 0x20, %o0 <== NOT EXECUTED
if (fc->flash_size < 5*fc->block_size) {
40003e50: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED
40003e54: d2 06 e0 04 ld [ %i3 + 4 ], %o1 <== NOT EXECUTED
40003e58: 85 28 60 02 sll %g1, 2, %g2 <== NOT EXECUTED
40003e5c: 84 00 80 01 add %g2, %g1, %g2 <== NOT EXECUTED
40003e60: 80 a0 80 09 cmp %g2, %o1 <== NOT EXECUTED
40003e64: 28 bf ff bc bleu,a 40003d54 <rtems_jffs2_initialize+0xa8> <== NOT EXECUTED
40003e68: c4 0c 20 29 ldub [ %l0 + 0x29 ], %g2 <== NOT EXECUTED
pr_err("Too few erase blocks (%d)\n",
40003e6c: 81 80 20 00 wr %g0, %y <== NOT EXECUTED
40003e70: 01 00 00 00 nop <== NOT EXECUTED
40003e74: 01 00 00 00 nop <== NOT EXECUTED
40003e78: 01 00 00 00 nop <== NOT EXECUTED
40003e7c: 92 72 40 01 udiv %o1, %g1, %o1 <== NOT EXECUTED
40003e80: 11 10 00 78 sethi %hi(0x4001e000), %o0 <== NOT EXECUTED
40003e84: 7f ff fc e4 call 40003214 <jffs2_printk> <== NOT EXECUTED
40003e88: 90 12 20 60 or %o0, 0x60, %o0 ! 4001e060 <mount_data+0x174> <== NOT EXECUTED
40003e8c: b8 10 20 16 mov 0x16, %i4 <== NOT EXECUTED
bool do_mount_fs_was_successful = false;
40003e90: 92 10 20 00 clr %o1 <== NOT EXECUTED
rtems_jffs2_free_fs_info(fs_info, do_mount_fs_was_successful);
40003e94: 92 0a 60 01 and %o1, 1, %o1 <== NOT EXECUTED
40003e98: 7f ff fd 48 call 400033b8 <rtems_jffs2_free_fs_info> <== NOT EXECUTED
40003e9c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
errno = -err;
40003ea0: 40 00 63 fb call 4001ce8c <__errno> <== NOT EXECUTED
40003ea4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40003ea8: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
}
40003eac: 81 c7 e0 08 ret <== NOT EXECUTED
40003eb0: 81 e8 00 00 restore <== NOT EXECUTED
jffs2_erase_pending_blocks(c, 0);
40003eb4: 92 10 20 00 clr %o1
40003eb8: 40 00 22 80 call 4000c8b8 <jffs2_erase_pending_blocks>
40003ebc: 90 10 00 1d mov %i5, %o0
mt_entry->mt_fs_root->location.node_access = sb->s_root;
40003ec0: c2 07 60 e0 ld [ %i5 + 0xe0 ], %g1
mt_entry->fs_info = fs_info;
40003ec4: fa 24 20 08 st %i5, [ %l0 + 8 ]
mt_entry->ops = &rtems_jffs2_ops;
40003ec8: 05 10 00 78 sethi %hi(0x4001e000), %g2
mt_entry->mt_fs_root->location.node_access = sb->s_root;
40003ecc: c6 04 20 24 ld [ %l0 + 0x24 ], %g3
mt_entry->ops = &rtems_jffs2_ops;
40003ed0: 84 10 a0 a8 or %g2, 0xa8, %g2
40003ed4: c4 24 20 0c st %g2, [ %l0 + 0xc ]
mt_entry->mt_fs_root->location.node_access = sb->s_root;
40003ed8: c2 20 e0 08 st %g1, [ %g3 + 8 ]
mt_entry->mt_fs_root->location.handlers = &rtems_jffs2_directory_handlers;
40003edc: 03 10 00 78 sethi %hi(0x4001e000), %g1
40003ee0: 82 10 61 7c or %g1, 0x17c, %g1 ! 4001e17c <rtems_jffs2_directory_handlers>
40003ee4: c2 20 e0 10 st %g1, [ %g3 + 0x10 ]
return 0;
40003ee8: 81 c7 e0 08 ret
40003eec: 81 e8 00 00 restore
if (inode)
40003ef0: 7f ff ff 23 call 40003b7c <jffs2_iget.part.0>
40003ef4: 90 10 00 1d mov %i5, %o0
sb->s_root = jffs2_iget(sb, 1);
40003ef8: d0 27 60 e0 st %o0, [ %i5 + 0xe0 ]
if (IS_ERR(sb->s_root)) {
40003efc: 80 a2 3c 18 cmp %o0, -1000
40003f00: 08 bf ff bb bleu 40003dec <rtems_jffs2_initialize+0x140> <== ALWAYS TAKEN
40003f04: 82 10 00 08 mov %o0, %g1
if (err == 0) {
40003f08: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003f0c: 22 bf ff b9 be,a 40003df0 <rtems_jffs2_initialize+0x144> <== NOT EXECUTED
40003f10: c2 20 60 34 st %g1, [ %g1 + 0x34 ] <== NOT EXECUTED
err = PTR_ERR(sb->s_root);
40003f14: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED
do_mount_fs_was_successful = true;
40003f18: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
errno = -err;
40003f1c: 10 bf ff de b 40003e94 <rtems_jffs2_initialize+0x1e8> <== NOT EXECUTED
40003f20: b8 20 00 18 neg %i0, %i4 <== NOT EXECUTED
if (fc->destroy != NULL) {
40003f24: c2 06 e0 14 ld [ %i3 + 0x14 ], %g1 <== NOT EXECUTED
40003f28: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003f2c: 22 80 00 05 be,a 40003f40 <rtems_jffs2_initialize+0x294> <== NOT EXECUTED
40003f30: d0 06 60 04 ld [ %i1 + 4 ], %o0 <== NOT EXECUTED
(*fc->destroy)(fc);
40003f34: 9f c0 40 00 call %g1 <== NOT EXECUTED
40003f38: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
rtems_jffs2_compressor_control_destroy(jffs2_mount_data->compressor_control);
40003f3c: d0 06 60 04 ld [ %i1 + 4 ], %o0 <== NOT EXECUTED
if (cc != NULL && cc->destroy != NULL) {
40003f40: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40003f44: 02 bf ff d7 be 40003ea0 <rtems_jffs2_initialize+0x1f4> <== NOT EXECUTED
40003f48: b8 10 20 0c mov 0xc, %i4 <== NOT EXECUTED
40003f4c: c2 02 20 08 ld [ %o0 + 8 ], %g1 <== NOT EXECUTED
40003f50: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
40003f54: 02 bf ff d3 be 40003ea0 <rtems_jffs2_initialize+0x1f4> <== NOT EXECUTED
40003f58: 01 00 00 00 nop <== NOT EXECUTED
(*cc->destroy)(cc);
40003f5c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40003f60: 01 00 00 00 nop <== NOT EXECUTED
40003f64: 30 bf ff cf b,a 40003ea0 <rtems_jffs2_initialize+0x1f4> <== NOT EXECUTED
errno = -err;
40003f68: 10 bf ff cb b 40003e94 <rtems_jffs2_initialize+0x1e8> <== NOT EXECUTED
40003f6c: b8 20 00 18 neg %i0, %i4 <== NOT EXECUTED