=============================================================================== 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 <== 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 <== 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 <== 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 <== 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 <== 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 : { 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 40005e44: b6 06 60 15 add %i1, 0x15, %i3 40005e48: 10 80 00 06 b 40005e60 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 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 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 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 40005e80: 92 10 00 1b mov %i3, %o1 40005e84: 80 a2 20 00 cmp %o0, 0 40005e88: 32 bf ff f2 bne,a 40005e50 <== 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 <== 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 40005ebc: 01 00 00 00 nop jffs2_mark_node_obsolete(c, ((*prev)->raw)); 40005ec0: 40 00 04 14 call 40006f10 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 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 <== NOT EXECUTED 40005ef8: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED jffs2_free_full_dirent(new); 40005efc: 7f ff ff 24 call 40005b8c <== NOT EXECUTED 40005f00: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40006094 : { 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 <== 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 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 <== 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 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 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 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 <== 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 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 <== 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 40006150: 80 a4 c0 01 cmp %l3, %g1 if (newfrag->ofs > this->ofs) { 40006154: 08 80 00 b6 bleu 4000642c 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 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 <== ALWAYS TAKEN 40006194: 82 24 c0 01 sub %l3, %g1, %g1 newfrag = jffs2_alloc_node_frag(); 40006198: 7f ff fe d1 call 40005cdc <== 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 <== 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 <== 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 <== 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 <== 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 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 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 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 <== 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 40006284: 80 a4 c0 1c cmp %l3, %i4 40006288: 10 bf ff a7 b 40006124 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 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 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 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 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 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 _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 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 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 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 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 <== 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 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 <== 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 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 <== 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 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 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 <== 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 40006528: c2 20 a0 04 st %g1, [ %g2 + 4 ] newfrag = jffs2_alloc_node_frag(); 4000652c: 7f ff fd ec call 40005cdc 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 <== 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 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 <== 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 <== 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 : 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 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 <== NEVER TAKEN 40006664: 88 01 00 02 add %g4, %g2, %g4 new->next = *prev; 40006668: 10 80 00 0b b 40006694 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 <== 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 <== 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 : */ 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 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 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 <== 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 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 <== 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 <== 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 : 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 <== 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 : * *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 <== 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 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 : /***********************************************************************/ 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 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 <== 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 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 <== 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 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 <== 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 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 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 <== NOT EXECUTED 4000c060: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED jffs2_free_raw_inode(ri); 4000c064: 7f ff e6 df call 40005be0 <== 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 <== 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 : 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 : 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 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 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 <== 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 <== 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 <== 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 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 40006740: 9e 10 40 00 mov %g1, %o7 =============================================================================== 40009e04 : 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 <== 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 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 <== 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 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 40009e54: 90 10 00 18 mov %i0, %o0 jffs2_free_full_dnode(f->metadata); 40009e58: 7f ff ef 54 call 40005ba8 40009e5c: d0 06 60 08 ld [ %i1 + 8 ], %o0 } jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL); 40009e60: 10 80 00 0e b 40009e98 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 <== 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 <== NOT EXECUTED 40009e88: 92 10 20 00 clr %o1 <== NOT EXECUTED jffs2_free_full_dnode(f->metadata); 40009e8c: 7f ff ef 47 call 40005ba8 <== 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 <== NOT EXECUTED 40009e98: 7f ff f2 8b call 400068c4 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 40009eac: fa 06 60 0c ld [ %i1 + 0xc ], %i5 kfree(f->target); 40009eb0: 40 00 13 a1 call 4000ed34 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 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 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 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 <== 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 <== 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 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 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 40009f34: 90 10 00 18 mov %i0, %o0 if (f->metadata) { 40009f38: 10 bf ff c2 b 40009e40 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 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 40009f54: 92 10 20 00 clr %o1 jffs2_free_full_dnode(f->metadata); 40009f58: 7f ff ef 14 call 40005ba8 40009f5c: 01 00 00 00 nop jffs2_kill_fragtree(&f->fragtree, deleted?c:NULL); 40009f60: 10 bf ff ce b 40009e98 40009f64: 92 10 20 00 clr %o1 ! 0 jffs2_del_ino_cache(c, f->inocache); 40009f68: 7f ff f1 cd call 4000669c 40009f6c: 81 e8 00 00 restore =============================================================================== 40009f70 : { 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 40009fac: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED kfree (f); 40009fb0: 40 00 13 61 call 4000ed34 <== 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 : 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 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 <== 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 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 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 <== 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 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 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 <== NEVER TAKEN 4000ae0c: 01 00 00 00 nop rd = jffs2_alloc_raw_dirent(); 4000ae10: 7f ff eb 69 call 40005bb4 4000ae14: 01 00 00 00 nop if (!rd) { 4000ae18: b4 92 20 00 orcc %o0, 0, %i2 4000ae1c: 02 80 00 74 be 4000afec <== 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 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 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 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 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 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 <== 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 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 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 <== NOT EXECUTED 4000afe4: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED return PTR_ERR(fd); 4000afe8: 30 bf ff 64 b,a 4000ad78 <== NOT EXECUTED jffs2_complete_reservation(c); 4000afec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000aff0: 7f ff ef be call 40006ee8 <== NOT EXECUTED 4000aff4: ba 10 3f f4 mov -12, %i5 <== NOT EXECUTED return -ENOMEM; 4000aff8: 30 bf ff 60 b,a 4000ad78 <== NOT EXECUTED =============================================================================== 4000b18c : 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 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 <== 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 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 <== 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 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 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 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 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 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 <== 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 4000b34c: 92 10 00 1d mov %i5, %o1 jffs2_complete_reservation(c); 4000b350: 7f ff ee e6 call 40006ee8 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 <== 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 <== 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 <== NOT EXECUTED 4000b388: a6 10 3f f4 mov -12, %l3 <== NOT EXECUTED =============================================================================== 4000b474 : 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 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 <== NEVER TAKEN 4000b4b8: 82 10 00 08 mov %o0, %g1 return -ENOMEM; for (i=0; inr_blocks; i++) { 4000b4bc: 86 10 20 00 clr %g3 4000b4c0: 80 a6 c0 1d cmp %i3, %i5 4000b4c4: 0a 80 00 0b bcs 4000b4f0 <== 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; inr_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; inr_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; inr_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; inr_blocks; i++) { 4000b4e8: 18 bf ff f9 bgu 4000b4cc 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 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 <== 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 <== NEVER TAKEN 4000b5cc: b6 10 20 00 clr %i3 if (c->inocache_list[*i]) 4000b5d0: 10 80 00 05 b 4000b5e4 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 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 <== 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 <== 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 <== NEVER TAKEN 4000b60c: ba 10 20 00 clr %i5 if (c->inocache_list[*i]) 4000b610: 10 80 00 05 b 4000b624 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 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 4000b678: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED jffs2_free_full_dirent(fd); 4000b67c: 7f ff e9 44 call 40005b8c <== 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 <== 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 <== 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 <== NOT EXECUTED 4000b6ac: 86 10 20 00 clr %g3 <== NOT EXECUTED if (c->inocache_list[*i]) 4000b6b0: 10 80 00 05 b 4000b6c4 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 4000b704: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED if (c->inocache_list[*i]) 4000b708: 10 80 00 05 b 4000b71c <== 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 <== 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 <== NOT EXECUTED 4000b72c: 84 00 a0 01 inc %g2 <== NOT EXECUTED 4000b730: 10 bf ff eb b 4000b6dc <== 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 <== 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 <== NOT EXECUTED 4000b754: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED if (c->inocache_list[*i]) 4000b758: 10 80 00 05 b 4000b76c <== 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 <== 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 <== 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 <== NOT EXECUTED 4000b78c: d2 07 60 0c ld [ %i5 + 0xc ], %o1 <== NOT EXECUTED 4000b790: 10 bf ff ea b 4000b738 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 4000b7fc: c4 2a 20 09 stb %g2, [ %o0 + 9 ] <== NOT EXECUTED *dir_hardlinks = 1; 4000b800: 10 bf ff e6 b 4000b798 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 4000b86c: c2 07 20 14 ld [ %i4 + 0x14 ], %g1 <== NOT EXECUTED 4000b870: 10 bf ff e6 b 4000b808 <== 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 <== 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 <== NEVER TAKEN 4000b888: b6 10 20 00 clr %i3 if (c->inocache_list[*i]) 4000b88c: 10 80 00 05 b 4000b8a0 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 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 <== 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 <== 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 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 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 4000ba20: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED while(ic->scan_dents) { 4000ba24: 10 bf ff e6 b 4000b9bc <== 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 <== 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 <== 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 <== NOT EXECUTED 4000ba4c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED continue; 4000ba50: 10 bf ff 52 b 4000b798 <== 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 <== NOT EXECUTED 4000ba68: ba 10 20 00 clr %i5 <== NOT EXECUTED if (c->inocache_list[*i]) 4000ba6c: 10 80 00 05 b 4000ba80 <== 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 <== 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 <== NOT EXECUTED 4000ba90: b8 07 20 01 inc %i4 <== NOT EXECUTED 4000ba94: 10 80 00 05 b 4000baa8 <== NOT EXECUTED 4000ba98: d0 07 40 00 ld [ %i5 ], %o0 <== NOT EXECUTED jffs2_free_full_dirent(fd); 4000ba9c: 7f ff e8 3c call 40005b8c <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 4000bb24: d0 07 40 00 ld [ %i5 ], %o0 <== NOT EXECUTED jffs2_free_ino_caches(c); 4000bb28: 7f ff eb 07 call 40006744 <== 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 <== NOT EXECUTED 4000bb34: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED kvfree(c->blocks); 4000bb38: 40 00 0c 7f call 4000ed34 <== 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 <== 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 : #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 4000a000: 01 00 00 00 nop if (!ic) { 4000a004: ba 92 20 00 orcc %o0, 0, %i5 4000a008: 02 80 00 3c be 4000a0f8 <== NEVER TAKEN 4000a00c: 94 10 20 18 mov 0x18, %o2 return -ENOMEM; } memset(ic, 0, sizeof(*ic)); 4000a010: 40 00 4c 05 call 4001d024 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 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 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 : /* 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 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 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 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 <== 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 <== 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 <== 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 40009d3c: 01 00 00 00 nop if (!f->inocache) { 40009d40: 80 a2 20 00 cmp %o0, 0 40009d44: 02 80 00 17 be 40009da0 <== 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 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 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 <== 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 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 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 <== 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 <== 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 : 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 <== 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 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 <== 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 <== 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 <== 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 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 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 <== 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 <== 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 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 <== 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 <== 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 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 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 <== 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 <== 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 <== NOT EXECUTED 4000b11c: 01 00 00 00 nop <== NOT EXECUTED jffs2_mark_node_obsolete(c, fd->raw); 4000b120: 7f ff ef 7c call 40006f10 <== NOT EXECUTED 4000b124: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED jffs2_free_full_dirent(fd); 4000b128: 7f ff ea 99 call 40005b8c <== 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 <== 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 <== 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 <== NOT EXECUTED 4000b168: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED 4000b16c: 10 bf ff ea b 4000b114 <== 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 4000b180: b0 10 20 00 clr %i0 } 4000b184: 81 c7 e0 08 ret 4000b188: 81 e8 00 00 restore =============================================================================== 4000c8b8 : { 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; inext == 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 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 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 <== 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 <== 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 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 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 <== 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 <== NEVER TAKEN 4000c994: 94 10 20 00 clr %o2 if (*datum + 1) { 4000c998: 10 80 00 06 b 4000c9b0 4000c99c: d2 06 c0 0a ld [ %i3 + %o2 ], %o1 for (i=0; i 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 <== 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 4000c9c4: 90 10 00 10 mov %l0, %o0 ofs += readlen; cond_resched(); } ret = 0; fail: kfree(ebuf); 4000c9c8: 40 00 08 db call 4000ed34 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 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 4000ca48: b8 27 00 16 sub %i4, %l6, %i4 kfree(ebuf); 4000ca4c: 40 00 08 ba call 4000ed34 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 <== 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 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 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 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 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 <== 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 <== NOT EXECUTED 4000cb9c: 80 a2 3f e2 cmp %o0, -30 <== NOT EXECUTED if (ret == -EROFS) 4000cba0: 02 80 00 53 be 4000ccec <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 4000ccf0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4000ccf4: 10 bf ff b1 b 4000cbb8 <== 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 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 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 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 <== 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 <== 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 <== 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 <== 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 <== 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 4000cdd8: 90 10 00 1d mov %i5, %o0 list_move_tail(&jeb->list, &c->free_list); 4000cddc: 10 bf ff 2b b 4000ca88 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 <== NOT EXECUTED 4000cdf0: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED kfree(ebuf); 4000cdf4: 40 00 07 d0 call 4000ed34 <== 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 <== 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 <== NOT EXECUTED 4000ce10: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED kfree(ebuf); 4000ce14: 40 00 07 c8 call 4000ed34 <== 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 <== 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 <== NOT EXECUTED 4000ce34: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 40020bb8 <__func__.0+0x270> <== NOT EXECUTED 4000ce38: 10 bf fe e7 b 4000c9d4 <== NOT EXECUTED 4000ce3c: f8 07 60 34 ld [ %i5 + 0x34 ], %i4 <== NOT EXECUTED =============================================================================== 4000ce90 : 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 <== 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 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 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 <== 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 <== 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 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 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 <== NEVER TAKEN 4000cf30: 80 a7 21 00 cmp %i4, 0x100 4000cf34: 18 80 00 03 bgu 4000cf40 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 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 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 <== 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 <== 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 <== 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 <== 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 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 <== 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 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 <== 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 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 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 <== 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 <== 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 4000d06c: 90 10 00 1b mov %i3, %o0 goto writev_out; 4000d070: 10 bf ff cb b 4000cf9c 4000d074: 80 a7 60 00 cmp %i5, 0 cbuf = (char *) malloc(sizetomalloc); 4000d078: 40 00 08 13 call 4000f0c4 <== 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 <== NOT EXECUTED 4000d088: b0 10 3f f4 mov -12, %i0 <== NOT EXECUTED cbuf = (char *) malloc(sizetomalloc); 4000d08c: 10 bf ff f0 b 4000d04c <== 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 <== NOT EXECUTED 4000d09c: b0 10 20 00 clr %i0 <== NOT EXECUTED ret = -ENOMEM; 4000d0a0: 10 bf ff be b 4000cf98 <== NOT EXECUTED 4000d0a4: b0 10 3f f4 mov -12, %i0 <== NOT EXECUTED =============================================================================== 40006744 : { 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 <== 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 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 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 <== 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 400067a0: c0 20 80 00 clr [ %g2 ] } 400067a4: 81 c7 e0 08 ret 400067a8: 81 e8 00 00 restore =============================================================================== 4000c76c : 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 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 <== 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 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 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 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 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 <== NOT EXECUTED 4000c87c: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED if (!(*prev)->next_in_ino) { 4000c880: 10 bf ff d4 b 4000c7d0 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 4000c8b4: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED =============================================================================== 400067ac : { 400067ac: 9d e3 bf a0 save %sp, -96, %sp for (i=0; inr_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 <== 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; inr_blocks; i++) { 400067c4: 10 80 00 0d b 400067f8 400067c8: b6 10 20 00 clr %i3 jffs2_free_refblock(this); 400067cc: 7f ff fd 41 call 40005cd0 <== 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; inr_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; inr_blocks; i++) { 400067ec: 80 a0 c0 1b cmp %g3, %i3 400067f0: 08 80 00 12 bleu 40006838 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 <== 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 <== NEVER TAKEN 40006818: 01 00 00 00 nop jffs2_free_refblock(this); 4000681c: 7f ff fd 2d call 40005cd0 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 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 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 4000684c: 84 00 40 1d add %g1, %i5, %g2 =============================================================================== 40004688 : { 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 40004788: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED 4000478c: 18 80 00 10 bgu 400047cc <== NOT EXECUTED 40004790: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 40004794: 12 80 01 3c bne 40004c84 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 400047f0: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 4001e5a0 <== 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 <== NOT EXECUTED 40004800: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return ret; 40004804: 30 bf ff f0 b,a 400047c4 <== 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 <== 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 40004820: 90 10 00 18 mov %i0, %o0 40004824: 80 a2 20 00 cmp %o0, 0 40004828: 12 bf ff cd bne 4000475c <== 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 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 <== 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 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 <== 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 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 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 <== 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 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 400048ac: 92 10 20 01 mov 1, %o1 400048b0: 10 bf ff e1 b 40004834 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 <== 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 <== NOT EXECUTED 400048d8: 90 12 22 70 or %o0, 0x270, %o0 ! 4001e670 <== 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 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 <== 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 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NEVER TAKEN 40004afc: d2 06 a0 0c ld [ %i2 + 0xc ], %o1 <== NOT EXECUTED 40004b00: 18 80 00 25 bgu 40004b94 <== NEVER TAKEN 40004b04: 80 a4 60 01 cmp %l1, 1 40004b08: 08 80 00 28 bleu 40004ba8 <== NEVER TAKEN 40004b0c: 80 a4 60 03 cmp %l1, 3 40004b10: 12 80 00 04 bne 40004b20 40004b14: 80 a0 60 02 cmp %g1, 2 if (ref_flags(raw) == REF_PRISTINE) 40004b18: 02 80 00 39 be 40004bfc 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 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 <== 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 <== 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 <== 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 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 <== 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 40004b88: b0 10 00 1c mov %i4, %i0 40004b8c: 10 bf ff b9 b 40004a70 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 <== 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 <== 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 <== NOT EXECUTED 40004bb8: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 4001e6c8 <== 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 <== 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 <== 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 <== 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 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 40004c1c: 80 a2 00 01 cmp %o0, %g1 40004c20: 12 bf ff d3 bne 40004b6c <== 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 <== 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 <== NOT EXECUTED 40004c40: b8 10 20 00 clr %i4 <== NOT EXECUTED 40004c44: 10 bf ff cf b 40004b80 <== NOT EXECUTED 40004c48: c2 06 20 5c ld [ %i0 + 0x5c ], %g1 <== NOT EXECUTED 40004c4c: 10 bf ff 69 b 400049f0 <== 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 <== NOT EXECUTED 40004c60: 90 12 21 e8 or %o0, 0x1e8, %o0 ! 4001e5e8 <== 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 <== NOT EXECUTED 40004c90: 90 12 21 30 or %o0, 0x130, %o0 ! 4001e530 <== NOT EXECUTED BUG(); 40004c94: 10 bf ff cb b 40004bc0 <== 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 <== 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 <== NOT EXECUTED 40004ce0: 90 12 20 c0 or %o0, 0xc0, %o0 ! 4001ecc0 <== NOT EXECUTED if (c->gcblock && !c->gcblock->used_size) { 40004ce4: 10 bf ff a7 b 40004b80 <== 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 <== 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 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 <== 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 40004d2c: a2 10 20 00 clr %l1 40004d30: 10 80 00 07 b 40004d4c 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 <== 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 <== 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 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 <== 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 <== ALWAYS TAKEN 40004d90: b8 10 00 02 mov %g2, %i4 40004d94: 10 bf ff e9 b 40004d38 <== 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 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 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 <== 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 <== NOT EXECUTED 40004ddc: 90 12 20 f8 or %o0, 0xf8, %o0 ! 4001ecf8 <== 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 <== 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 <== NOT EXECUTED 40004e00: 90 12 20 88 or %o0, 0x88, %o0 ! 4001ec88 <== NOT EXECUTED 40004e04: 10 bf ff 58 b 40004b64 <== NOT EXECUTED 40004e08: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED if (fn) { 40004e0c: 22 bf ff e5 be,a 40004da0 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== ALWAYS TAKEN 40005030: 84 06 a0 0c add %i2, 0xc, %g2 while (*fdp) { 40005034: 10 80 00 07 b 40005050 <== NOT EXECUTED 40005038: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED if ((*fdp) == fd) { 4000503c: 22 80 00 43 be,a 40005148 <== 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 <== 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 <== NOT EXECUTED 4000506c: 90 12 20 48 or %o0, 0x48, %o0 ! 4001ec48 <== NOT EXECUTED jffs2_mark_node_obsolete(c, fd->raw); 40005070: 10 80 00 38 b 40005150 <== 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 <== 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 <== 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 <== NOT EXECUTED 400050ac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400050b0: 22 80 00 10 be,a 400050f0 <== 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 <== NOT EXECUTED 400050c0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED jffs2_free_full_dnode(fn); 400050c4: 40 00 02 b9 call 40005ba8 <== NOT EXECUTED 400050c8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED return 0; 400050cc: 10 bf fe a6 b 40004b64 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 40005160: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED return 0; 40005164: 10 bf fe 80 b 40004b64 <== 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 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 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 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 <== 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 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 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 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 <== 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 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 <== 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 40005278: 90 10 00 18 mov %i0, %o0 ret = jffs2_garbage_collect_dirent(c, jeb, f, fd); 4000527c: 10 bf fe 3a b 40004b64 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 400052b0: d0 06 a0 08 ld [ %i2 + 8 ], %o0 <== NOT EXECUTED f->metadata = NULL; 400052b4: 10 bf fe 2b b 40004b60 <== 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 <== NOT EXECUTED 400052cc: 90 12 22 90 or %o0, 0x290, %o0 ! 4001ea90 <== NOT EXECUTED return PTR_ERR(new_fn); 400052d0: 10 bf fe 25 b 40004b64 <== 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 <== NOT EXECUTED 400052e0: 90 12 20 30 or %o0, 0x30, %o0 ! 4001e830 <== 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 <== 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 <== 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 <== 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 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 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 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 <== 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 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 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 <== 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 <== 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 <== 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 <== 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 <== 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 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 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 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 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 <== 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 <== 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 <== 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 <== 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 <== NEVER TAKEN 400054fc: 80 a6 40 11 cmp %i1, %l1 BUG_ON(start > orig_start); 40005500: 18 80 00 a2 bgu 40005788 <== 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 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 <== 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 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 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 <== 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 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 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 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 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 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 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 <== 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 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 <== 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 <== 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 <== NOT EXECUTED 400056d4: d0 06 a0 08 ld [ %i2 + 8 ], %o0 <== NOT EXECUTED f->metadata = NULL; 400056d8: 10 bf ff 9b b 40005544 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== 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 40005744: 90 10 00 18 mov %i0, %o0 return ret; 40005748: 10 bf fd 07 b 40004b64 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 <== NOT EXECUTED 40005760: 90 12 20 08 or %o0, 8, %o0 ! 4001e808 <== NOT EXECUTED break; 40005764: 10 bf ff f6 b 4000573c <== 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 <== NOT EXECUTED 4000577c: 90 12 23 18 or %o0, 0x318, %o0 ! 4001eb18 <== NOT EXECUTED return PTR_ERR(pg_ptr); 40005780: 10 bf fc f9 b 40004b64 <== 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 400057e8: b2 10 00 11 mov %l1, %i1 goto release_sem; 400057ec: 10 bf fc e4 b 40004b7c <== 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 <== 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 <== 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 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 <== 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 <== 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 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 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 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 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 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 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 <== 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 40005968: 90 10 00 18 mov %i0, %o0 jffs2_free_full_dnode(fn); 4000596c: 40 00 00 8f call 40005ba8 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 <== ALWAYS TAKEN 40005990: 92 10 00 1a mov %i2, %o1 kfree(mdata); 40005994: 40 00 24 e8 call 4000ed34 <== 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 <== 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 <== NOT EXECUTED 400059b4: 90 12 20 08 or %o0, 8, %o0 ! 4001e808 <== NOT EXECUTED goto out; 400059b8: 10 bf ff f1 b 4000597c <== NOT EXECUTED 400059bc: 05 00 00 3c sethi %hi(0xf000), %g2 <== NOT EXECUTED 400059c0: 10 bf fd 15 b 40004e14 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 <== NOT EXECUTED 400059d4: 90 12 23 b0 or %o0, 0x3b0, %o0 ! 4001e7b0 <== NOT EXECUTED goto out; 400059d8: 10 bf ff e9 b 4000597c <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 40005a28: 90 12 23 60 or %o0, 0x360, %o0 ! 4001e760 <== NOT EXECUTED kfree(mdata); 40005a2c: 40 00 24 c2 call 4000ed34 <== NOT EXECUTED 40005a30: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED return ret; 40005a34: 10 bf fc 4c b 40004b64 <== 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 <== NOT EXECUTED 40005a5c: 90 12 21 10 or %o0, 0x110, %o0 <== NOT EXECUTED return -EIO; 40005a60: 10 bf fc 40 b 40004b60 <== 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 <== NOT EXECUTED 40005a74: 90 12 23 18 or %o0, 0x318, %o0 ! 4001e718 <== NOT EXECUTED return -ENOMEM; 40005a78: 10 bf fc 3b b 40004b64 <== 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 <== 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 <== NOT EXECUTED 40005ab4: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 4001e9b8 <== NOT EXECUTED goto fill; 40005ab8: 10 bf fe 0c b 400052e8 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 40005b20: 90 12 22 38 or %o0, 0x238, %o0 ! 4001ea38 <== NOT EXECUTED return ret; 40005b24: 10 bf fc 10 b 40004b64 <== 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 <== NEVER TAKEN 40005b38: 82 10 20 00 clr %g1 <== NOT EXECUTED 40005b3c: 10 bf fd af b 400051f8 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 <== NOT EXECUTED 40005b58: 90 12 23 a8 or %o0, 0x3a8, %o0 ! 4001eba8 <== NOT EXECUTED return ret; 40005b5c: 10 bf fc 02 b 40004b64 <== 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 <== NOT EXECUTED 40005b70: 90 12 20 00 mov %o0, %o0 ! 4001ec00 <== NOT EXECUTED return PTR_ERR(new_fd); 40005b74: 10 bf fb fc b 40004b64 <== NOT EXECUTED 40005b78: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED =============================================================================== 40004170 : } 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== ALWAYS TAKEN 400041d0: c4 02 00 00 ld [ %o0 ], %g2 400041d4: 10 80 00 16 b 4000422c <== 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 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 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 <== 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 <== 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 40004230: 90 10 00 18 mov %i0, %o0 if (IS_ERR(inode)) 40004234: 10 bf ff f5 b 40004208 40004238: 80 a2 3c 18 cmp %o0, -1000 =============================================================================== 40003784 : { 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 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 <== 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 : 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 400065cc: c2 02 20 0c ld [ %o0 + 0xc ], %g1 400065d0: 30 80 00 0e b,a 40006608 400065d4: 80 a2 20 00 cmp %o0, 0 400065d8: 02 80 00 0c be 40006608 <== 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 <== 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 <== 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 <== NOT EXECUTED 40006608: 81 c3 e0 08 retl 4000660c: 01 00 00 00 nop =============================================================================== 40003b7c : 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 <== 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 <== 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 <== 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 <== 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 <== 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 <== NOT EXECUTED 40003c38: 90 12 20 00 mov %o0, %o0 ! 4001e000 <== 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 <== 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 : { 400037c0: 9d e3 bf a0 save %sp, -96, %sp 400037c4: 10 80 00 19 b 40003828 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 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 <== 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 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 40003808: fa 06 60 34 ld [ %i1 + 0x34 ], %i5 free(i); 4000380c: 40 00 2d 4a call 4000ed34 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 4000381c: 80 a6 40 1d cmp %i1, %i5 40003820: 02 80 00 0c be 40003850 <== 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 <== 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 <== NEVER TAKEN 40003844: c2 26 60 04 st %g1, [ %i1 + 4 ] if (i->i_count) 40003848: 22 bf ff e1 be,a 400037cc 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 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 : /* 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 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 <== 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 <== 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 40006918: 01 00 00 00 nop jffs2_mark_node_obsolete(c, frag->node->raw); 4000691c: 40 00 01 7d call 40006f10 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 4000692c: 90 10 00 01 mov %g1, %o0 } jffs2_free_node_frag(frag); 40006930: 7f ff fc ef call 40005cec 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 40006940: 90 10 00 1d mov %i5, %o0 cond_resched(); } } 40006944: 81 c7 e0 08 ret 40006948: 81 e8 00 00 restore =============================================================================== 4000c0dc : /***********************************************************************/ 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 <== 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