=============================================================================== 4000f374 : int rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control) { 4000f374: 9d e3 bf 98 save %sp, -104, %sp rtems_rfs_bitmap_map map; size_t size; rtems_rfs_bitmap_bit bit; int rc; rc = rtems_rfs_bitmap_load_map (control, &map); 4000f378: 90 10 00 18 mov %i0, %o0 { 4000f37c: ba 10 00 18 mov %i0, %i5 rc = rtems_rfs_bitmap_load_map (control, &map); 4000f380: 7f ff fe 53 call 4000eccc 4000f384: 92 07 bf fc add %fp, -4, %o1 if (rc > 0) 4000f388: b0 92 20 00 orcc %o0, 0, %i0 4000f38c: 24 80 00 04 ble,a 4000f39c 4000f390: c0 27 60 10 clr [ %i5 + 0x10 ] bit++; map++; } return 0; } 4000f394: 81 c7 e0 08 ret 4000f398: 81 e8 00 00 restore *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR; 4000f39c: 82 10 3f ff mov -1, %g1 search_map = control->search_bits; 4000f3a0: f0 07 60 14 ld [ %i5 + 0x14 ], %i0 size = control->size; 4000f3a4: c6 07 60 0c ld [ %i5 + 0xc ], %g3 while (size) 4000f3a8: 80 a0 e0 00 cmp %g3, 0 4000f3ac: 02 80 00 31 be 4000f470 <== NEVER TAKEN 4000f3b0: c2 26 00 00 st %g1, [ %i0 ] 4000f3b4: f8 07 bf fc ld [ %fp + -4 ], %i4 bit = 0; 4000f3b8: b4 10 20 00 clr %i2 available = rtems_rfs_bitmap_element_bits (); 4000f3bc: 9a 10 20 20 mov 0x20, %o5 mask >>= (rtems_rfs_bitmap_element_bits () - size); 4000f3c0: 9e 10 3f ff mov -1, %o7 return RTEMS_RFS_BITMAP_TEST_BIT (target, bit); 4000f3c4: 10 80 00 10 b 4000f404 4000f3c8: b2 10 20 01 mov 1, %i1 mask >>= (rtems_rfs_bitmap_element_bits () - size); 4000f3cc: 82 23 40 03 sub %o5, %g3, %g1 available = size; 4000f3d0: b6 10 00 03 mov %g3, %i3 mask >>= (rtems_rfs_bitmap_element_bits () - size); 4000f3d4: 83 33 c0 01 srl %o7, %g1, %g1 4000f3d8: 84 08 80 01 and %g2, %g1, %g2 if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET)) 4000f3dc: 80 a0 a0 00 cmp %g2, 0 4000f3e0: 12 80 00 10 bne 4000f420 4000f3e4: 86 10 20 00 clr %g3 if (bit == (rtems_rfs_bitmap_element_bits () - 1)) 4000f3e8: 80 a6 a0 1f cmp %i2, 0x1f 4000f3ec: 22 80 00 1c be,a 4000f45c 4000f3f0: de 26 20 04 st %o7, [ %i0 + 4 ] bit++; 4000f3f4: b4 06 a0 01 inc %i2 while (size) 4000f3f8: 80 a0 e0 00 cmp %g3, 0 4000f3fc: 02 80 00 1d be 4000f470 4000f400: b8 07 20 04 add %i4, 4, %i4 if (size < rtems_rfs_bitmap_element_bits ()) 4000f404: 80 a0 e0 1f cmp %g3, 0x1f 4000f408: 08 bf ff f1 bleu 4000f3cc 4000f40c: c4 07 00 00 ld [ %i4 ], %g2 4000f410: 86 00 ff e0 add %g3, -32, %g3 if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET)) 4000f414: 80 a0 a0 00 cmp %g2, 0 4000f418: 02 bf ff f4 be 4000f3e8 4000f41c: b6 10 20 20 mov 0x20, %i3 for (b = 0; b < available; b++) 4000f420: 82 10 20 00 clr %g1 return RTEMS_RFS_BITMAP_TEST_BIT (target, bit); 4000f424: 89 2e 40 01 sll %i1, %g1, %g4 if (!rtems_rfs_bitmap_test (bits, b)) 4000f428: 80 89 00 02 btst %g4, %g2 4000f42c: 02 80 00 05 be 4000f440 4000f430: 82 00 60 01 inc %g1 control->free++; 4000f434: c8 07 60 10 ld [ %i5 + 0x10 ], %g4 4000f438: 88 01 20 01 inc %g4 4000f43c: c8 27 60 10 st %g4, [ %i5 + 0x10 ] for (b = 0; b < available; b++) 4000f440: 80 a6 c0 01 cmp %i3, %g1 4000f444: 12 bf ff f9 bne 4000f428 4000f448: 89 2e 40 01 sll %i1, %g1, %g4 if (bit == (rtems_rfs_bitmap_element_bits () - 1)) 4000f44c: 80 a6 a0 1f cmp %i2, 0x1f 4000f450: 12 bf ff ea bne 4000f3f8 4000f454: b4 06 a0 01 inc %i2 *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR; 4000f458: de 26 20 04 st %o7, [ %i0 + 4 ] bit = 0; 4000f45c: b4 10 20 00 clr %i2 search_map++; 4000f460: b0 06 20 04 add %i0, 4, %i0 while (size) 4000f464: 80 a0 e0 00 cmp %g3, 0 4000f468: 12 bf ff e7 bne 4000f404 4000f46c: b8 07 20 04 add %i4, 4, %i4 } 4000f470: 81 c7 e0 08 ret 4000f474: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 4000f270 : int rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control, rtems_rfs_bitmap_bit seed, bool* allocated, rtems_rfs_bitmap_bit* bit) { 4000f270: 9d e3 bf a0 save %sp, -96, %sp int rc = 0; /* * By default we assume the allocation failed. */ *allocated = false; 4000f274: c0 2e 80 00 clrb [ %i2 ] * seed up then from the seed down a window number of bits, then repeat the * process from the window distance from the seed, again above then * below. Keep moving out until all bits have been searched. */ upper_seed = seed; lower_seed = seed; 4000f278: ba 10 00 19 mov %i1, %i5 * we have searched all of the map. The seed may not be aligned to a window * boundary so we may need to search a partial window and this may also not * be balanced for the upper or lower seeds. We move to the limits, search * then return false if no clear bits are found. */ while (((upper_seed >= 0) && (upper_seed < control->size)) 4000f27c: 80 a6 60 00 cmp %i1, 0 4000f280: 06 80 00 1e bl 4000f2f8 4000f284: 80 a7 60 00 cmp %i5, 0 4000f288: c2 06 20 0c ld [ %i0 + 0xc ], %g1 4000f28c: 80 a0 40 19 cmp %g1, %i1 4000f290: 08 80 00 1a bleu 4000f2f8 4000f294: 80 a7 60 00 cmp %i5, 0 /* * Search up first so bits allocated in succession are grouped together. */ if (upper_seed < control->size) { *bit = upper_seed; 4000f298: f2 26 c0 00 st %i1, [ %i3 ] rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated, 4000f29c: 96 10 20 01 mov 1, %o3 4000f2a0: 94 10 00 1a mov %i2, %o2 4000f2a4: 92 10 00 1b mov %i3, %o1 4000f2a8: 7f ff fe 9d call 4000ed1c 4000f2ac: 90 10 00 18 mov %i0, %o0 window, 1); if ((rc > 0) || *allocated) 4000f2b0: 80 a2 20 00 cmp %o0, 0 4000f2b4: 14 80 00 2c bg 4000f364 <== NEVER TAKEN 4000f2b8: 01 00 00 00 nop 4000f2bc: c2 0e 80 00 ldub [ %i2 ], %g1 4000f2c0: 80 a0 60 00 cmp %g1, 0 4000f2c4: 12 80 00 28 bne 4000f364 4000f2c8: 80 a7 60 00 cmp %i5, 0 break; } if (lower_seed >= 0) 4000f2cc: 36 80 00 14 bge,a 4000f31c 4000f2d0: fa 26 c0 00 st %i5, [ %i3 ] /* * Do not bound the limits at the edges of the map. Do not update if an * edge has been passed. */ if (upper_seed < control->size) 4000f2d4: c2 06 20 0c ld [ %i0 + 0xc ], %g1 4000f2d8: 80 a6 40 01 cmp %i1, %g1 4000f2dc: 1a bf ff e9 bcc 4000f280 <== NEVER TAKEN 4000f2e0: 80 a6 60 00 cmp %i1, 0 upper_seed += window; 4000f2e4: b2 06 68 00 add %i1, 0x800, %i1 while (((upper_seed >= 0) && (upper_seed < control->size)) 4000f2e8: 80 a6 60 00 cmp %i1, 0 4000f2ec: 16 bf ff e9 bge 4000f290 <== ALWAYS TAKEN 4000f2f0: 80 a0 40 19 cmp %g1, %i1 || ((lower_seed >= 0) && (lower_seed < control->size))) 4000f2f4: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED 4000f2f8: 06 80 00 1b bl 4000f364 4000f2fc: 01 00 00 00 nop 4000f300: c2 06 20 0c ld [ %i0 + 0xc ], %g1 4000f304: 80 a0 40 1d cmp %g1, %i5 4000f308: 08 80 00 17 bleu 4000f364 4000f30c: 80 a6 40 01 cmp %i1, %g1 if (upper_seed < control->size) 4000f310: 2a bf ff e3 bcs,a 4000f29c <== NEVER TAKEN 4000f314: f2 26 c0 00 st %i1, [ %i3 ] <== NOT EXECUTED *bit = lower_seed; 4000f318: fa 26 c0 00 st %i5, [ %i3 ] rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated, 4000f31c: 96 10 3f ff mov -1, %o3 4000f320: 94 10 00 1a mov %i2, %o2 4000f324: 92 10 00 1b mov %i3, %o1 4000f328: 7f ff fe 7d call 4000ed1c 4000f32c: 90 10 00 18 mov %i0, %o0 if ((rc > 0) || *allocated) 4000f330: 80 a2 20 00 cmp %o0, 0 4000f334: 14 80 00 0c bg 4000f364 <== NEVER TAKEN 4000f338: 01 00 00 00 nop 4000f33c: c2 0e 80 00 ldub [ %i2 ], %g1 4000f340: 80 a0 60 00 cmp %g1, 0 4000f344: 12 80 00 08 bne 4000f364 4000f348: 01 00 00 00 nop if (upper_seed < control->size) 4000f34c: c2 06 20 0c ld [ %i0 + 0xc ], %g1 4000f350: 80 a6 40 01 cmp %i1, %g1 4000f354: 2a 80 00 06 bcs,a 4000f36c 4000f358: b2 06 68 00 add %i1, 0x800, %i1 if (lower_seed >= 0) lower_seed -= window; 4000f35c: 10 bf ff c8 b 4000f27c 4000f360: ba 07 78 00 add %i5, -2048, %i5 } return 0; } 4000f364: 81 c7 e0 08 ret 4000f368: 91 e8 20 00 restore %g0, 0, %o0 lower_seed -= window; 4000f36c: 10 bf ff c4 b 4000f27c 4000f370: ba 07 78 00 add %i5, -2048, %i5 =============================================================================== 4000f014 : { 4000f014: 9d e3 bf 98 save %sp, -104, %sp rc = rtems_rfs_bitmap_load_map (control, &map); 4000f018: 92 07 bf fc add %fp, -4, %o1 4000f01c: 7f ff ff 2c call 4000eccc 4000f020: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4000f024: 80 a2 20 00 cmp %o0, 0 4000f028: 24 80 00 04 ble,a 4000f038 4000f02c: c2 06 20 0c ld [ %i0 + 0xc ], %g1 } 4000f030: 81 c7 e0 08 ret 4000f034: 91 e8 00 08 restore %g0, %o0, %o0 if (bit >= control->size) 4000f038: 80 a0 40 19 cmp %g1, %i1 4000f03c: 08 bf ff fd bleu 4000f030 4000f040: 90 10 20 16 mov 0x16, %o0 element = map[index]; 4000f044: f8 07 bf fc ld [ %fp + -4 ], %i4 index = rtems_rfs_bitmap_map_index (bit); 4000f048: 85 3e 60 05 sra %i1, 5, %g2 element = map[index]; 4000f04c: bb 28 a0 02 sll %g2, 2, %i5 4000f050: c8 07 00 1d ld [ %i4 + %i5 ], %g4 search_map = control->search_bits; 4000f054: f6 06 20 14 ld [ %i0 + 0x14 ], %i3 map[index] = rtems_rfs_bitmap_clear (element, 1 << offset); 4000f058: 86 10 20 01 mov 1, %g3 4000f05c: 83 28 c0 19 sll %g3, %i1, %g1 return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits); 4000f060: 82 10 40 04 or %g1, %g4, %g1 map[index] = rtems_rfs_bitmap_clear (element, 1 << offset); 4000f064: c2 27 00 1d st %g1, [ %i4 + %i5 ] if (rtems_rfs_bitmap_match(element, map[index])) 4000f068: 80 a1 00 01 cmp %g4, %g1 4000f06c: 02 bf ff f1 be 4000f030 <== NEVER TAKEN 4000f070: 90 10 20 00 clr %o0 index = rtems_rfs_bitmap_map_index (bit); 4000f074: b3 3e 60 0a sra %i1, 0xa, %i1 search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset); 4000f078: b3 2e 60 02 sll %i1, 2, %i1 return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits); 4000f07c: c2 06 c0 19 ld [ %i3 + %i1 ], %g1 rtems_rfs_buffer_mark_dirty (control->buffer); 4000f080: c8 06 00 00 ld [ %i0 ], %g4 search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset); 4000f084: 85 28 c0 02 sll %g3, %g2, %g2 return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits); 4000f088: 84 10 40 02 or %g1, %g2, %g2 search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset); 4000f08c: c4 26 c0 19 st %g2, [ %i3 + %i1 ] control->free++; 4000f090: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 rtems_rfs_buffer_mark_dirty (control->buffer); 4000f094: c6 29 00 00 stb %g3, [ %g4 ] control->free++; 4000f098: 82 00 60 01 inc %g1 4000f09c: c2 26 20 10 st %g1, [ %i0 + 0x10 ] } 4000f0a0: 81 c7 e0 08 ret 4000f0a4: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 4001927c : { 4001927c: 9d e3 bf a0 save %sp, -96, %sp if (map->dirty && map->inode) 40019280: c2 0e 40 00 ldub [ %i1 ], %g1 40019284: 80 a0 60 00 cmp %g1, 0 40019288: 02 80 00 5f be 40019404 4001928c: ba 10 00 18 mov %i0, %i5 40019290: d2 06 60 04 ld [ %i1 + 4 ], %o1 40019294: 80 a2 60 00 cmp %o1, 0 40019298: 02 80 00 5b be 40019404 <== NEVER TAKEN 4001929c: 90 10 00 18 mov %i0, %o0 brc = rtems_rfs_inode_load (fs, map->inode); 400192a0: 7f ff e1 4a call 400117c8 400192a4: b8 06 60 38 add %i1, 0x38, %i4 if (brc > 0) 400192a8: 80 a2 20 00 cmp %o0, 0 400192ac: 14 80 00 58 bg 4001940c <== NEVER TAKEN 400192b0: b0 10 00 08 mov %o0, %i0 400192b4: 9e 10 3f f8 mov -8, %o7 400192b8: 84 06 60 24 add %i1, 0x24, %g2 400192bc: 9e 23 c0 19 sub %o7, %i1, %o7 rtems_rfs_buffer_mark_dirty (&handle->buffer); 400192c0: b0 10 20 01 mov 1, %i0 rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]); 400192c4: c2 06 60 04 ld [ %i1 + 4 ], %g1 400192c8: c6 00 80 00 ld [ %g2 ], %g3 rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno); 400192cc: f6 00 60 0c ld [ %g1 + 0xc ], %i3 400192d0: 88 03 c0 02 add %o7, %g2, %g4 400192d4: b5 30 e0 18 srl %g3, 0x18, %i2 400192d8: f4 2e c0 04 stb %i2, [ %i3 + %g4 ] 400192dc: b5 30 e0 10 srl %g3, 0x10, %i2 400192e0: f6 00 60 0c ld [ %g1 + 0xc ], %i3 400192e4: b6 06 c0 04 add %i3, %g4, %i3 400192e8: f4 2e e0 01 stb %i2, [ %i3 + 1 ] 400192ec: b5 30 e0 08 srl %g3, 8, %i2 400192f0: f6 00 60 0c ld [ %g1 + 0xc ], %i3 400192f4: b6 06 c0 04 add %i3, %g4, %i3 400192f8: f4 2e e0 02 stb %i2, [ %i3 + 2 ] 400192fc: 84 00 a0 04 add %g2, 4, %g2 40019300: f6 00 60 0c ld [ %g1 + 0xc ], %i3 40019304: 88 06 c0 04 add %i3, %g4, %g4 40019308: c6 29 20 03 stb %g3, [ %g4 + 3 ] for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++) 4001930c: 80 a7 00 02 cmp %i4, %g2 40019310: 12 bf ff ed bne 400192c4 40019314: f0 28 60 10 stb %i0, [ %g1 + 0x10 ] rtems_rfs_inode_set_block_count (map->inode, map->size.count); 40019318: c2 06 60 04 ld [ %i1 + 4 ], %g1 4001931c: c4 06 60 08 ld [ %i1 + 8 ], %g2 rtems_rfs_write_u32 (&handle->node->block_count, block_count); 40019320: c6 00 60 0c ld [ %g1 + 0xc ], %g3 40019324: 89 30 a0 18 srl %g2, 0x18, %g4 40019328: c8 28 e0 0c stb %g4, [ %g3 + 0xc ] 4001932c: 89 30 a0 10 srl %g2, 0x10, %g4 40019330: c6 00 60 0c ld [ %g1 + 0xc ], %g3 40019334: c8 28 e0 0d stb %g4, [ %g3 + 0xd ] 40019338: 89 30 a0 08 srl %g2, 8, %g4 4001933c: c6 00 60 0c ld [ %g1 + 0xc ], %g3 40019340: c8 28 e0 0e stb %g4, [ %g3 + 0xe ] brc = rtems_rfs_inode_unload (fs, map->inode, true); 40019344: 94 10 20 01 mov 1, %o2 40019348: c6 00 60 0c ld [ %g1 + 0xc ], %g3 4001934c: c4 28 e0 0f stb %g2, [ %g3 + 0xf ] 40019350: 90 10 00 1d mov %i5, %o0 rtems_rfs_inode_set_block_offset (map->inode, map->size.offset); 40019354: c6 06 60 04 ld [ %i1 + 4 ], %g3 rtems_rfs_write_u16 (&handle->node->block_offset, block_offset); 40019358: c8 0e 60 0e ldub [ %i1 + 0xe ], %g4 rtems_rfs_buffer_mark_dirty (&handle->buffer); 4001935c: f0 28 60 10 stb %i0, [ %g1 + 0x10 ] rtems_rfs_write_u16 (&handle->node->block_offset, block_offset); 40019360: c2 00 e0 0c ld [ %g3 + 0xc ], %g1 40019364: c4 06 60 0c ld [ %i1 + 0xc ], %g2 40019368: c8 28 60 0a stb %g4, [ %g1 + 0xa ] 4001936c: c2 00 e0 0c ld [ %g3 + 0xc ], %g1 40019370: c4 28 60 0b stb %g2, [ %g1 + 0xb ] rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block); 40019374: c4 06 60 04 ld [ %i1 + 4 ], %g2 40019378: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 rtems_rfs_buffer_mark_dirty (&handle->buffer); 4001937c: f0 28 e0 10 stb %i0, [ %g3 + 0x10 ] rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block); 40019380: 89 30 60 18 srl %g1, 0x18, %g4 40019384: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 40019388: c8 28 e0 30 stb %g4, [ %g3 + 0x30 ] 4001938c: 89 30 60 10 srl %g1, 0x10, %g4 40019390: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 40019394: c8 28 e0 31 stb %g4, [ %g3 + 0x31 ] 40019398: 89 30 60 08 srl %g1, 8, %g4 4001939c: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 400193a0: c8 28 e0 32 stb %g4, [ %g3 + 0x32 ] 400193a4: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 400193a8: c2 28 e0 33 stb %g1, [ %g3 + 0x33 ] rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block); 400193ac: c2 06 60 04 ld [ %i1 + 4 ], %g1 400193b0: c6 06 60 20 ld [ %i1 + 0x20 ], %g3 rtems_rfs_buffer_mark_dirty (&handle->buffer); 400193b4: f0 28 a0 10 stb %i0, [ %g2 + 0x10 ] rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block); 400193b8: 89 30 e0 18 srl %g3, 0x18, %g4 400193bc: c4 00 60 0c ld [ %g1 + 0xc ], %g2 400193c0: c8 28 a0 34 stb %g4, [ %g2 + 0x34 ] 400193c4: 89 30 e0 10 srl %g3, 0x10, %g4 400193c8: c4 00 60 0c ld [ %g1 + 0xc ], %g2 400193cc: c8 28 a0 35 stb %g4, [ %g2 + 0x35 ] 400193d0: 89 30 e0 08 srl %g3, 8, %g4 400193d4: c4 00 60 0c ld [ %g1 + 0xc ], %g2 400193d8: c8 28 a0 36 stb %g4, [ %g2 + 0x36 ] 400193dc: c4 00 60 0c ld [ %g1 + 0xc ], %g2 400193e0: c6 28 a0 37 stb %g3, [ %g2 + 0x37 ] rtems_rfs_buffer_mark_dirty (&handle->buffer); 400193e4: f0 28 60 10 stb %i0, [ %g1 + 0x10 ] brc = rtems_rfs_inode_unload (fs, map->inode, true); 400193e8: 7f ff e1 5e call 40011960 400193ec: d2 06 60 04 ld [ %i1 + 4 ], %o1 map->dirty = false; 400193f0: c0 2e 40 00 clrb [ %i1 ] 400193f4: 82 38 00 08 xnor %g0, %o0, %g1 400193f8: 83 38 60 1f sra %g1, 0x1f, %g1 400193fc: 10 80 00 04 b 4001940c 40019400: b0 0a 00 01 and %o0, %g1, %i0 int rc = 0; 40019404: b0 10 20 00 clr %i0 40019408: b8 06 60 38 add %i1, 0x38, %i4 map->inode = NULL; 4001940c: c0 26 60 04 clr [ %i1 + 4 ] rtems_rfs_buffer_handle_release (fs, handle); 40019410: 92 10 00 1c mov %i4, %o1 40019414: 7f ff d9 f4 call 4000fbe4 40019418: 90 10 00 1d mov %i5, %o0 handle->dirty = false; 4001941c: c0 2e 60 38 clrb [ %i1 + 0x38 ] rtems_rfs_buffer_handle_release (fs, handle); 40019420: 92 06 60 44 add %i1, 0x44, %o1 handle->bnum = 0; 40019424: c0 26 60 3c clr [ %i1 + 0x3c ] rtems_rfs_buffer_handle_release (fs, handle); 40019428: 90 10 00 1d mov %i5, %o0 4001942c: 7f ff d9 ee call 4000fbe4 40019430: c0 26 60 40 clr [ %i1 + 0x40 ] handle->dirty = false; 40019434: c0 2e 60 44 clrb [ %i1 + 0x44 ] handle->bnum = 0; 40019438: c0 26 60 48 clr [ %i1 + 0x48 ] handle->buffer = NULL; 4001943c: c0 26 60 4c clr [ %i1 + 0x4c ] } 40019440: 81 c7 e0 08 ret 40019444: 81 e8 00 00 restore =============================================================================== 40019448 : { 40019448: 9d e3 bf 98 save %sp, -104, %sp *block = 0; 4001944c: c0 26 c0 00 clr [ %i3 ] if (rtems_rfs_block_pos_block_past_end (bpos, &map->size)) 40019450: c2 06 80 00 ld [ %i2 ], %g1 40019454: 80 a0 60 00 cmp %g1, 0 40019458: 02 80 00 05 be 4001946c 4001945c: c4 06 60 08 ld [ %i1 + 8 ], %g2 40019460: 80 a0 a0 00 cmp %g2, 0 40019464: 02 80 00 1a be 400194cc <== NEVER TAKEN 40019468: 90 10 20 06 mov 6, %o0 4001946c: 80 a0 40 02 cmp %g1, %g2 40019470: 1a 80 00 17 bcc 400194cc 40019474: 90 10 20 06 mov 6, %o0 if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0)) 40019478: c6 06 60 10 ld [ %i1 + 0x10 ], %g3 4001947c: 80 a0 40 03 cmp %g1, %g3 40019480: 22 80 00 39 be,a 40019564 40019484: c6 06 60 18 ld [ %i1 + 0x18 ], %g3 if (map->size.count <= RTEMS_RFS_INODE_BLOCKS) 40019488: 80 a0 a0 05 cmp %g2, 5 4001948c: 38 80 00 12 bgu,a 400194d4 40019490: c6 06 20 34 ld [ %i0 + 0x34 ], %g3 *block = map->blocks[bpos->bno]; 40019494: 82 00 60 08 add %g1, 8, %g1 40019498: 83 28 60 02 sll %g1, 2, %g1 4001949c: 82 06 40 01 add %i1, %g1, %g1 400194a0: c2 00 60 04 ld [ %g1 + 4 ], %g1 400194a4: c2 26 c0 00 st %g1, [ %i3 ] map->bpos.block = *block; 400194a8: 90 10 20 00 clr %o0 rtems_rfs_block_copy_bpos (&map->bpos, bpos); 400194ac: c2 06 a0 04 ld [ %i2 + 4 ], %g1 400194b0: c4 06 80 00 ld [ %i2 ], %g2 400194b4: c6 06 a0 08 ld [ %i2 + 8 ], %g3 400194b8: c6 26 60 18 st %g3, [ %i1 + 0x18 ] 400194bc: c4 26 60 10 st %g2, [ %i1 + 0x10 ] 400194c0: c2 26 60 14 st %g1, [ %i1 + 0x14 ] map->bpos.block = *block; 400194c4: c2 06 c0 00 ld [ %i3 ], %g1 400194c8: c2 26 60 18 st %g1, [ %i1 + 0x18 ] } 400194cc: 81 c7 e0 08 ret 400194d0: 91 e8 00 08 restore %g0, %o0, %o0 direct = bpos->bno % fs->blocks_per_block; 400194d4: 81 80 20 00 wr %g0, %y 400194d8: 01 00 00 00 nop 400194dc: 01 00 00 00 nop 400194e0: 01 00 00 00 nop 400194e4: 96 70 40 03 udiv %g1, %g3, %o3 singly = bpos->bno / fs->blocks_per_block; 400194e8: d6 27 bf fc st %o3, [ %fp + -4 ] direct = bpos->bno % fs->blocks_per_block; 400194ec: ba 5a c0 03 smul %o3, %g3, %i5 if (map->size.count <= fs->block_map_singly_blocks) 400194f0: c8 06 20 38 ld [ %i0 + 0x38 ], %g4 400194f4: 80 a1 00 02 cmp %g4, %g2 400194f8: 1a 80 00 20 bcc 40019578 400194fc: ba 20 40 1d sub %g1, %i5, %i5 singly %= fs->blocks_per_block; 40019500: 81 80 20 00 wr %g0, %y 40019504: 01 00 00 00 nop 40019508: 01 00 00 00 nop 4001950c: 01 00 00 00 nop 40019510: 82 72 c0 03 udiv %o3, %g3, %g1 40019514: 86 58 40 03 smul %g1, %g3, %g3 40019518: 96 22 c0 03 sub %o3, %g3, %o3 4001951c: d6 27 bf fc st %o3, [ %fp + -4 ] if (map->size.count < fs->block_map_doubly_blocks) 40019520: c6 06 20 3c ld [ %i0 + 0x3c ], %g3 40019524: 80 a0 c0 02 cmp %g3, %g2 40019528: 08 bf ff e9 bleu 400194cc <== NEVER TAKEN 4001952c: 90 10 20 06 mov 6, %o0 rc = rtems_rfs_block_find_indirect (fs, 40019530: 82 00 60 08 add %g1, 8, %g1 40019534: 83 28 60 02 sll %g1, 2, %g1 40019538: 82 06 40 01 add %i1, %g1, %g1 4001953c: d4 00 60 04 ld [ %g1 + 4 ], %o2 40019540: 98 07 bf fc add %fp, -4, %o4 40019544: 92 06 60 44 add %i1, 0x44, %o1 40019548: 7f ff fe 5e call 40018ec0 4001954c: 90 10 00 18 mov %i0, %o0 if (rc == 0) 40019550: 80 a2 20 00 cmp %o0, 0 40019554: 12 bf ff de bne 400194cc <== NEVER TAKEN 40019558: d4 07 bf fc ld [ %fp + -4 ], %o2 rc = rtems_rfs_block_find_indirect (fs, 4001955c: 10 80 00 0c b 4001958c 40019560: 98 10 00 1b mov %i3, %o4 if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0)) 40019564: 80 a0 e0 00 cmp %g3, 0 40019568: 02 bf ff c9 be 4001948c 4001956c: 80 a0 a0 05 cmp %g2, 5 *block = map->bpos.block; 40019570: 10 bf ff ce b 400194a8 40019574: c6 26 c0 00 st %g3, [ %i3 ] rc = rtems_rfs_block_find_indirect (fs, 40019578: 96 02 e0 08 add %o3, 8, %o3 4001957c: 97 2a e0 02 sll %o3, 2, %o3 40019580: 96 06 40 0b add %i1, %o3, %o3 40019584: d4 02 e0 04 ld [ %o3 + 4 ], %o2 rc = rtems_rfs_block_find_indirect (fs, 40019588: 98 10 00 1b mov %i3, %o4 4001958c: 96 10 00 1d mov %i5, %o3 40019590: 92 06 60 38 add %i1, 0x38, %o1 40019594: 7f ff fe 4b call 40018ec0 40019598: 90 10 00 18 mov %i0, %o0 if (rc == 0) 4001959c: 80 a2 20 00 cmp %o0, 0 400195a0: 22 bf ff c3 be,a 400194ac <== ALWAYS TAKEN 400195a4: 90 10 20 00 clr %o0 400195a8: 30 bf ff c9 b,a 400194cc <== NOT EXECUTED =============================================================================== 40019658 : { 40019658: 9d e3 bf 98 save %sp, -104, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW)) 4001965c: 90 10 20 00 clr %o0 40019660: 7f ff e6 bc call 40013150 40019664: 13 00 00 08 sethi %hi(0x2000), %o1 40019668: 80 a2 20 00 cmp %o0, 0 4001966c: 32 80 00 eb bne,a 40019a18 <== NEVER TAKEN 40019670: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs)) 40019674: c2 06 60 08 ld [ %i1 + 8 ], %g1 40019678: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 4001967c: 82 06 80 01 add %i2, %g1, %g1 40019680: 80 a0 40 02 cmp %g1, %g2 40019684: 1a 80 00 68 bcc 40019824 <== NEVER TAKEN 40019688: b8 10 20 1b mov 0x1b, %i4 for (b = 0; b < blocks; b++) 4001968c: 80 a6 a0 00 cmp %i2, 0 40019690: 02 80 00 65 be 40019824 <== NEVER TAKEN 40019694: b8 10 20 00 clr %i4 40019698: d2 06 60 20 ld [ %i1 + 0x20 ], %o1 4001969c: a8 10 20 00 clr %l4 rtems_rfs_block_set_number (&map->singly_buffer, direct, block); 400196a0: a0 10 20 01 mov 1, %l0 rc = rtems_rfs_buffer_handle_request (fs, 400196a4: a4 06 60 44 add %i1, 0x44, %l2 rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 400196a8: 10 80 00 10 b 400196e8 400196ac: a2 06 60 38 add %i1, 0x38, %l1 map->blocks[map->size.count] = block; 400196b0: 84 00 60 08 add %g1, 8, %g2 400196b4: 85 28 a0 02 sll %g2, 2, %g2 400196b8: 84 06 40 02 add %i1, %g2, %g2 400196bc: d2 20 a0 04 st %o1, [ %g2 + 4 ] map->size.count++; 400196c0: 82 00 60 01 inc %g1 map->size.offset = 0; 400196c4: c0 26 60 0c clr [ %i1 + 0xc ] if (b == 0) 400196c8: 80 a5 20 00 cmp %l4, 0 400196cc: 02 80 00 4f be 40019808 <== ALWAYS TAKEN 400196d0: c2 26 60 08 st %g1, [ %i1 + 8 ] map->last_data_block = block; 400196d4: d2 26 60 20 st %o1, [ %i1 + 0x20 ] <== NOT EXECUTED for (b = 0; b < blocks; b++) 400196d8: a8 05 20 01 inc %l4 <== NOT EXECUTED 400196dc: 80 a5 00 1a cmp %l4, %i2 <== NOT EXECUTED 400196e0: 02 80 00 50 be 40019820 <== NOT EXECUTED 400196e4: e0 2e 40 00 stb %l0, [ %i1 ] <== NOT EXECUTED rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block, 400196e8: 96 07 bf f8 add %fp, -8, %o3 400196ec: 94 10 20 00 clr %o2 400196f0: 7f ff df 11 call 40011334 400196f4: 90 10 00 18 mov %i0, %o0 if (rc > 0) 400196f8: b8 92 20 00 orcc %o0, 0, %i4 400196fc: 14 80 00 4a bg 40019824 40019700: 01 00 00 00 nop if (map->size.count < RTEMS_RFS_INODE_BLOCKS) 40019704: c2 06 60 08 ld [ %i1 + 8 ], %g1 40019708: 80 a0 60 04 cmp %g1, 4 4001970c: 08 bf ff e9 bleu 400196b0 40019710: d2 07 bf f8 ld [ %fp + -8 ], %o1 direct = map->size.count % fs->blocks_per_block; 40019714: e6 06 20 34 ld [ %i0 + 0x34 ], %l3 if (map->size.count < fs->block_map_singly_blocks) 40019718: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 direct = map->size.count % fs->blocks_per_block; 4001971c: 81 80 20 00 wr %g0, %y 40019720: 01 00 00 00 nop 40019724: 01 00 00 00 nop 40019728: 01 00 00 00 nop 4001972c: 96 70 40 13 udiv %g1, %l3, %o3 if (map->size.count < fs->block_map_singly_blocks) 40019730: 80 a0 40 02 cmp %g1, %g2 direct = map->size.count % fs->blocks_per_block; 40019734: ba 5a c0 13 smul %o3, %l3, %i5 if (map->size.count < fs->block_map_singly_blocks) 40019738: 1a 80 00 3d bcc 4001982c 4001973c: ba 20 40 1d sub %g1, %i5, %i5 if ((direct == 0) || 40019740: 80 a7 60 00 cmp %i5, 0 40019744: 02 80 00 06 be 4001975c 40019748: 80 a2 e0 00 cmp %o3, 0 4001974c: 12 80 00 95 bne 400199a0 40019750: 80 a7 60 05 cmp %i5, 5 40019754: 32 80 00 94 bne,a 400199a4 40019758: 82 02 e0 08 add %o3, 8, %g1 upping = map->size.count == RTEMS_RFS_INODE_BLOCKS; 4001975c: 82 18 60 05 xor %g1, 5, %g1 rc = rtems_rfs_block_map_indirect_alloc (fs, map, 40019760: 80 a0 00 01 cmp %g0, %g1 &map->blocks[singly], 40019764: 96 02 e0 09 add %o3, 9, %o3 rc = rtems_rfs_block_map_indirect_alloc (fs, map, 40019768: 98 60 3f ff subx %g0, -1, %o4 &map->blocks[singly], 4001976c: 97 2a e0 02 sll %o3, 2, %o3 rc = rtems_rfs_block_map_indirect_alloc (fs, map, 40019770: 94 10 00 11 mov %l1, %o2 40019774: 96 06 40 0b add %i1, %o3, %o3 40019778: 92 10 00 19 mov %i1, %o1 4001977c: 7f ff fd 7e call 40018d74 40019780: 90 10 00 18 mov %i0, %o0 40019784: b8 10 00 08 mov %o0, %i4 if (rc > 0) 40019788: 80 a7 20 00 cmp %i4, 0 4001978c: 14 80 00 aa bg 40019a34 <== NEVER TAKEN 40019790: d4 07 bf f8 ld [ %fp + -8 ], %o2 rtems_rfs_block_set_number (&map->singly_buffer, direct, block); 40019794: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 40019798: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 4001979c: c6 0f bf f8 ldub [ %fp + -8 ], %g3 400197a0: 83 2f 60 02 sll %i5, 2, %g1 400197a4: c6 28 80 01 stb %g3, [ %g2 + %g1 ] if (b == 0) 400197a8: 80 a5 20 00 cmp %l4, 0 rtems_rfs_block_set_number (&map->singly_buffer, direct, block); 400197ac: c4 06 60 40 ld [ %i1 + 0x40 ], %g2 400197b0: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 400197b4: c6 17 bf f8 lduh [ %fp + -8 ], %g3 400197b8: 84 00 80 01 add %g2, %g1, %g2 400197bc: c6 28 a0 01 stb %g3, [ %g2 + 1 ] 400197c0: c4 06 60 40 ld [ %i1 + 0x40 ], %g2 400197c4: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 400197c8: c6 07 bf f8 ld [ %fp + -8 ], %g3 400197cc: 84 00 80 01 add %g2, %g1, %g2 400197d0: 87 30 e0 08 srl %g3, 8, %g3 400197d4: c6 28 a0 02 stb %g3, [ %g2 + 2 ] 400197d8: c4 06 60 40 ld [ %i1 + 0x40 ], %g2 400197dc: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 400197e0: 82 00 80 01 add %g2, %g1, %g1 400197e4: c4 07 bf f8 ld [ %fp + -8 ], %g2 400197e8: c4 28 60 03 stb %g2, [ %g1 + 3 ] 400197ec: c2 06 60 08 ld [ %i1 + 8 ], %g1 map->size.count++; 400197f0: 82 00 60 01 inc %g1 rtems_rfs_block_set_number (&map->singly_buffer, direct, block); 400197f4: e0 2e 60 38 stb %l0, [ %i1 + 0x38 ] map->size.offset = 0; 400197f8: c0 26 60 0c clr [ %i1 + 0xc ] map->size.count++; 400197fc: c2 26 60 08 st %g1, [ %i1 + 8 ] if (b == 0) 40019800: 12 bf ff b5 bne 400196d4 <== NEVER TAKEN 40019804: d2 07 bf f8 ld [ %fp + -8 ], %o1 *new_block = block; 40019808: d2 26 c0 00 st %o1, [ %i3 ] for (b = 0; b < blocks; b++) 4001980c: a8 05 20 01 inc %l4 map->last_data_block = block; 40019810: d2 26 60 20 st %o1, [ %i1 + 0x20 ] for (b = 0; b < blocks; b++) 40019814: 80 a5 00 1a cmp %l4, %i2 40019818: 12 bf ff b4 bne 400196e8 <== NEVER TAKEN 4001981c: e0 2e 40 00 stb %l0, [ %i1 ] return 0; 40019820: b8 10 20 00 clr %i4 } 40019824: 81 c7 e0 08 ret 40019828: 91 e8 00 1c restore %g0, %i4, %o0 doubly = singly / fs->blocks_per_block; 4001982c: 81 80 20 00 wr %g0, %y 40019830: 01 00 00 00 nop 40019834: 01 00 00 00 nop 40019838: 01 00 00 00 nop 4001983c: aa 72 c0 13 udiv %o3, %l3, %l5 if (direct == 0) 40019840: 80 a7 60 00 cmp %i5, 0 singly %= fs->blocks_per_block; 40019844: a6 5d 40 13 smul %l5, %l3, %l3 if (direct == 0) 40019848: 12 80 00 37 bne 40019924 4001984c: a6 22 c0 13 sub %o3, %l3, %l3 rc = rtems_rfs_block_map_indirect_alloc (fs, map, 40019850: 98 10 20 00 clr %o4 40019854: 96 07 bf fc add %fp, -4, %o3 40019858: 94 10 00 11 mov %l1, %o2 4001985c: 92 10 00 19 mov %i1, %o1 40019860: 7f ff fd 45 call 40018d74 40019864: 90 10 00 18 mov %i0, %o0 if (rc > 0) 40019868: b8 92 20 00 orcc %o0, 0, %i4 4001986c: 14 80 00 71 bg 40019a30 <== NEVER TAKEN 40019870: 80 a4 e0 00 cmp %l3, 0 if ((singly == 0) || 40019874: 02 80 00 06 be 4001988c <== NEVER TAKEN 40019878: 80 a5 60 00 cmp %l5, 0 4001987c: 12 80 00 53 bne 400199c8 <== NEVER TAKEN 40019880: 80 a4 e0 05 cmp %l3, 5 40019884: 12 80 00 52 bne 400199cc 40019888: 82 05 60 08 add %l5, 8, %g1 upping = map->size.count == fs->block_map_singly_blocks; 4001988c: c2 06 60 08 ld [ %i1 + 8 ], %g1 40019890: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 40019894: 82 18 40 02 xor %g1, %g2, %g1 rc = rtems_rfs_block_map_indirect_alloc (fs, map, 40019898: 80 a0 00 01 cmp %g0, %g1 &map->blocks[doubly], 4001989c: 96 05 60 09 add %l5, 9, %o3 rc = rtems_rfs_block_map_indirect_alloc (fs, map, 400198a0: 98 60 3f ff subx %g0, -1, %o4 &map->blocks[doubly], 400198a4: 97 2a e0 02 sll %o3, 2, %o3 rc = rtems_rfs_block_map_indirect_alloc (fs, map, 400198a8: 94 10 00 12 mov %l2, %o2 400198ac: 96 06 40 0b add %i1, %o3, %o3 400198b0: 92 10 00 19 mov %i1, %o1 400198b4: 7f ff fd 30 call 40018d74 400198b8: 90 10 00 18 mov %i0, %o0 if (rc > 0) 400198bc: b8 92 20 00 orcc %o0, 0, %i4 400198c0: 14 80 00 4e bg 400199f8 <== NEVER TAKEN 400198c4: d4 07 bf fc ld [ %fp + -4 ], %o2 rtems_rfs_block_set_number (&map->doubly_buffer, 400198c8: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 400198cc: c4 0f bf fc ldub [ %fp + -4 ], %g2 400198d0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 400198d4: 97 2c e0 02 sll %l3, 2, %o3 400198d8: c4 28 40 0b stb %g2, [ %g1 + %o3 ] 400198dc: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 400198e0: c4 17 bf fc lduh [ %fp + -4 ], %g2 400198e4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 400198e8: 82 00 40 0b add %g1, %o3, %g1 400198ec: c4 28 60 01 stb %g2, [ %g1 + 1 ] 400198f0: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 400198f4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 400198f8: c4 07 bf fc ld [ %fp + -4 ], %g2 400198fc: 82 00 40 0b add %g1, %o3, %g1 40019900: 85 30 a0 08 srl %g2, 8, %g2 40019904: c4 28 60 02 stb %g2, [ %g1 + 2 ] 40019908: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 4001990c: e6 00 60 1c ld [ %g1 + 0x1c ], %l3 40019910: c2 07 bf fc ld [ %fp + -4 ], %g1 40019914: 96 04 c0 0b add %l3, %o3, %o3 40019918: c2 2a e0 03 stb %g1, [ %o3 + 3 ] 4001991c: 10 bf ff 9e b 40019794 40019920: e0 2e 60 44 stb %l0, [ %i1 + 0x44 ] rc = rtems_rfs_buffer_handle_request (fs, 40019924: aa 05 60 08 add %l5, 8, %l5 40019928: ab 2d 60 02 sll %l5, 2, %l5 4001992c: aa 06 40 15 add %i1, %l5, %l5 40019930: d4 05 60 04 ld [ %l5 + 4 ], %o2 40019934: 96 10 20 01 mov 1, %o3 40019938: 92 10 00 12 mov %l2, %o1 4001993c: 7f ff d7 e3 call 4000f8c8 40019940: 90 10 00 18 mov %i0, %o0 if (rc > 0) 40019944: b8 92 20 00 orcc %o0, 0, %i4 40019948: 14 80 00 3a bg 40019a30 <== NEVER TAKEN 4001994c: 97 2c e0 02 sll %l3, 2, %o3 singly_block = rtems_rfs_block_get_number (&map->doubly_buffer, 40019950: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 40019954: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 40019958: d4 08 80 0b ldub [ %g2 + %o3 ], %o2 4001995c: 82 00 80 0b add %g2, %o3, %g1 40019960: c6 08 60 03 ldub [ %g1 + 3 ], %g3 40019964: c4 08 60 01 ldub [ %g1 + 1 ], %g2 40019968: c2 08 60 02 ldub [ %g1 + 2 ], %g1 4001996c: 85 28 a0 10 sll %g2, 0x10, %g2 40019970: 83 28 60 08 sll %g1, 8, %g1 40019974: 95 2a a0 18 sll %o2, 0x18, %o2 rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40019978: 96 10 20 01 mov 1, %o3 singly_block = rtems_rfs_block_get_number (&map->doubly_buffer, 4001997c: 94 12 80 03 or %o2, %g3, %o2 rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40019980: 92 10 00 11 mov %l1, %o1 singly_block = rtems_rfs_block_get_number (&map->doubly_buffer, 40019984: 94 12 80 02 or %o2, %g2, %o2 rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40019988: 90 10 00 18 mov %i0, %o0 singly_block = rtems_rfs_block_get_number (&map->doubly_buffer, 4001998c: 94 12 80 01 or %o2, %g1, %o2 rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40019990: 7f ff d7 ce call 4000f8c8 40019994: d4 27 bf fc st %o2, [ %fp + -4 ] 40019998: 10 bf ff 7c b 40019788 4001999c: b8 10 00 08 mov %o0, %i4 rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 400199a0: 82 02 e0 08 add %o3, 8, %g1 400199a4: 83 28 60 02 sll %g1, 2, %g1 400199a8: 82 06 40 01 add %i1, %g1, %g1 400199ac: d4 00 60 04 ld [ %g1 + 4 ], %o2 400199b0: 96 10 20 01 mov 1, %o3 400199b4: 92 10 00 11 mov %l1, %o1 400199b8: 7f ff d7 c4 call 4000f8c8 400199bc: 90 10 00 18 mov %i0, %o0 400199c0: 10 bf ff 72 b 40019788 400199c4: b8 10 00 08 mov %o0, %i4 rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer, 400199c8: 82 05 60 08 add %l5, 8, %g1 <== NOT EXECUTED 400199cc: 83 28 60 02 sll %g1, 2, %g1 400199d0: 82 06 40 01 add %i1, %g1, %g1 400199d4: d4 00 60 04 ld [ %g1 + 4 ], %o2 400199d8: 96 10 20 01 mov 1, %o3 400199dc: 92 10 00 12 mov %l2, %o1 400199e0: 7f ff d7 ba call 4000f8c8 400199e4: 90 10 00 18 mov %i0, %o0 if (rc > 0) 400199e8: b8 92 20 00 orcc %o0, 0, %i4 400199ec: 24 bf ff b8 ble,a 400198cc <== ALWAYS TAKEN 400199f0: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 rtems_rfs_group_bitmap_free (fs, false, singly_block); 400199f4: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED 400199f8: 92 10 20 00 clr %o1 <== NOT EXECUTED 400199fc: 7f ff de fc call 400115ec <== NOT EXECUTED 40019a00: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED rtems_rfs_group_bitmap_free (fs, false, block); 40019a04: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED 40019a08: 92 10 20 00 clr %o1 <== NOT EXECUTED 40019a0c: 7f ff de f8 call 400115ec <== NOT EXECUTED 40019a10: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return rc; 40019a14: 30 bf ff 84 b,a 40019824 <== NOT EXECUTED printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n", 40019a18: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 40019a1c: 11 10 00 8d sethi %hi(0x40023400), %o0 <== NOT EXECUTED 40019a20: 7f ff e6 5a call 40013388 <__wrap_printf> <== NOT EXECUTED 40019a24: 90 12 22 50 or %o0, 0x250, %o0 ! 40023650 <== NOT EXECUTED if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs)) 40019a28: 10 bf ff 14 b 40019678 <== NOT EXECUTED 40019a2c: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED rtems_rfs_group_bitmap_free (fs, false, block); 40019a30: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED 40019a34: 92 10 20 00 clr %o1 <== NOT EXECUTED 40019a38: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40019a3c: 7f ff de ec call 400115ec <== NOT EXECUTED 40019a40: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED } 40019a44: 81 c7 e0 08 ret <== NOT EXECUTED 40019a48: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40019100 : { 40019100: 9d e3 bf a0 save %sp, -96, %sp map->dirty = false; 40019104: c0 2e 80 00 clrb [ %i2 ] rc = rtems_rfs_inode_load (fs, inode); 40019108: 92 10 00 19 mov %i1, %o1 map->inode = NULL; 4001910c: c0 26 a0 04 clr [ %i2 + 4 ] rc = rtems_rfs_inode_load (fs, inode); 40019110: 90 10 00 18 mov %i0, %o0 * @param[in] size is a pointer to the block size. */ static inline void rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size) { size->count = 0; 40019114: c0 26 a0 08 clr [ %i2 + 8 ] { 40019118: ba 10 00 1a mov %i2, %i5 size->offset = 0; 4001911c: c0 26 a0 0c clr [ %i2 + 0xc ] bpos->bno = 0; 40019120: c0 26 a0 10 clr [ %i2 + 0x10 ] bpos->boff = 0; 40019124: c0 26 a0 14 clr [ %i2 + 0x14 ] bpos->block = 0; 40019128: c0 26 a0 18 clr [ %i2 + 0x18 ] handle->dirty = false; 4001912c: c0 2e a0 38 clrb [ %i2 + 0x38 ] handle->bnum = 0; 40019130: c0 26 a0 3c clr [ %i2 + 0x3c ] handle->buffer = NULL; 40019134: c0 26 a0 40 clr [ %i2 + 0x40 ] handle->dirty = false; 40019138: c0 2e a0 44 clrb [ %i2 + 0x44 ] handle->bnum = 0; 4001913c: c0 26 a0 48 clr [ %i2 + 0x48 ] rc = rtems_rfs_inode_load (fs, inode); 40019140: 7f ff e1 a2 call 400117c8 40019144: c0 26 a0 4c clr [ %i2 + 0x4c ] if (rc > 0) 40019148: b8 92 20 00 orcc %o0, 0, %i4 4001914c: 14 80 00 3d bg 40019240 <== NEVER TAKEN 40019150: 88 06 a0 24 add %i2, 0x24, %g4 40019154: de 06 60 0c ld [ %i1 + 0xc ], %o7 map->inode = inode; 40019158: f2 26 a0 04 st %i1, [ %i2 + 4 ] 4001915c: 82 03 e0 1c add %o7, 0x1c, %g1 40019160: b4 06 a0 38 add %i2, 0x38, %i2 return rtems_rfs_read_u32 (&handle->node->data.blocks[block]); 40019164: f6 08 40 00 ldub [ %g1 ], %i3 40019168: c6 08 60 01 ldub [ %g1 + 1 ], %g3 4001916c: c4 08 60 02 ldub [ %g1 + 2 ], %g2 40019170: f8 08 60 03 ldub [ %g1 + 3 ], %i4 40019174: b7 2e e0 18 sll %i3, 0x18, %i3 40019178: 87 28 e0 10 sll %g3, 0x10, %g3 4001917c: 85 28 a0 08 sll %g2, 8, %g2 40019180: 86 10 c0 1b or %g3, %i3, %g3 40019184: 84 10 80 03 or %g2, %g3, %g2 40019188: 84 17 00 02 or %i4, %g2, %g2 map->blocks[b] = rtems_rfs_inode_get_block (inode, b); 4001918c: c4 21 00 00 st %g2, [ %g4 ] 40019190: 88 01 20 04 add %g4, 4, %g4 for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++) 40019194: 80 a6 80 04 cmp %i2, %g4 40019198: 12 bf ff f3 bne 40019164 4001919c: 82 00 60 04 add %g1, 4, %g1 return rtems_rfs_read_u32 (&handle->node->block_count); 400191a0: c6 0b e0 0f ldub [ %o7 + 0xf ], %g3 400191a4: c8 0b e0 0c ldub [ %o7 + 0xc ], %g4 400191a8: c4 0b e0 0d ldub [ %o7 + 0xd ], %g2 400191ac: c2 0b e0 0e ldub [ %o7 + 0xe ], %g1 400191b0: 89 29 20 18 sll %g4, 0x18, %g4 400191b4: 85 28 a0 10 sll %g2, 0x10, %g2 400191b8: 83 28 60 08 sll %g1, 8, %g1 400191bc: 84 10 80 04 or %g2, %g4, %g2 400191c0: 82 10 40 02 or %g1, %g2, %g1 400191c4: 82 10 c0 01 or %g3, %g1, %g1 map->size.count = rtems_rfs_inode_get_block_count (inode); 400191c8: c2 27 60 08 st %g1, [ %i5 + 8 ] return rtems_rfs_read_u16 (&handle->node->block_offset); 400191cc: c4 0b e0 0b ldub [ %o7 + 0xb ], %g2 400191d0: c2 0b e0 0a ldub [ %o7 + 0xa ], %g1 400191d4: 83 28 60 08 sll %g1, 8, %g1 map->size.offset = rtems_rfs_inode_get_block_offset (inode); 400191d8: 82 10 40 02 or %g1, %g2, %g1 400191dc: c2 27 60 0c st %g1, [ %i5 + 0xc ] return rtems_rfs_read_u32 (&handle->node->last_map_block); 400191e0: c6 0b e0 33 ldub [ %o7 + 0x33 ], %g3 400191e4: c8 0b e0 30 ldub [ %o7 + 0x30 ], %g4 400191e8: c4 0b e0 31 ldub [ %o7 + 0x31 ], %g2 400191ec: c2 0b e0 32 ldub [ %o7 + 0x32 ], %g1 400191f0: 89 29 20 18 sll %g4, 0x18, %g4 400191f4: 85 28 a0 10 sll %g2, 0x10, %g2 400191f8: 83 28 60 08 sll %g1, 8, %g1 400191fc: 84 10 80 04 or %g2, %g4, %g2 40019200: 82 10 40 02 or %g1, %g2, %g1 40019204: 82 10 c0 01 or %g3, %g1, %g1 map->last_map_block = rtems_rfs_inode_get_last_map_block (inode); 40019208: c2 27 60 1c st %g1, [ %i5 + 0x1c ] return rtems_rfs_read_u32 (&handle->node->last_data_block); 4001920c: c8 0b e0 34 ldub [ %o7 + 0x34 ], %g4 40019210: c4 0b e0 35 ldub [ %o7 + 0x35 ], %g2 40019214: c2 0b e0 36 ldub [ %o7 + 0x36 ], %g1 40019218: c6 0b e0 37 ldub [ %o7 + 0x37 ], %g3 4001921c: 89 29 20 18 sll %g4, 0x18, %g4 40019220: 85 28 a0 10 sll %g2, 0x10, %g2 40019224: 83 28 60 08 sll %g1, 8, %g1 40019228: 84 10 80 04 or %g2, %g4, %g2 4001922c: 82 10 40 02 or %g1, %g2, %g1 40019230: 82 10 c0 01 or %g3, %g1, %g1 map->last_data_block = rtems_rfs_inode_get_last_data_block (inode); 40019234: c2 27 60 20 st %g1, [ %i5 + 0x20 ] rc = rtems_rfs_inode_unload (fs, inode, false); 40019238: 7f ff e1 ca call 40011960 4001923c: 95 e8 20 00 restore %g0, 0, %o2 rtems_rfs_buffer_handle_release (fs, handle); 40019240: 92 06 a0 38 add %i2, 0x38, %o1 <== NOT EXECUTED 40019244: 7f ff da 68 call 4000fbe4 <== NOT EXECUTED 40019248: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED handle->dirty = false; 4001924c: c0 2e a0 38 clrb [ %i2 + 0x38 ] <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 40019250: 92 06 a0 44 add %i2, 0x44, %o1 <== NOT EXECUTED handle->bnum = 0; 40019254: c0 26 a0 3c clr [ %i2 + 0x3c ] <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 40019258: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED handle->buffer = NULL; 4001925c: c0 26 a0 40 clr [ %i2 + 0x40 ] <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 40019260: 7f ff da 61 call 4000fbe4 <== NOT EXECUTED 40019264: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED handle->dirty = false; 40019268: c0 2e a0 44 clrb [ %i2 + 0x44 ] <== NOT EXECUTED handle->bnum = 0; 4001926c: c0 26 a0 48 clr [ %i2 + 0x48 ] <== NOT EXECUTED handle->buffer = NULL; 40019270: c0 26 a0 4c clr [ %i2 + 0x4c ] <== NOT EXECUTED } 40019274: 81 c7 e0 08 ret <== NOT EXECUTED 40019278: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40019a4c : int rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs, rtems_rfs_block_map* map, size_t blocks) { 40019a4c: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK)) 40019a50: 90 10 20 00 clr %o0 40019a54: 7f ff e5 bf call 40013150 40019a58: 13 00 00 10 sethi %hi(0x4000), %o1 40019a5c: 80 a2 20 00 cmp %o0, 0 40019a60: 32 80 00 a3 bne,a 40019cec <== NEVER TAKEN 40019a64: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n", blocks, map->size.count); if (map->size.count == 0) 40019a68: c2 06 60 08 ld [ %i1 + 8 ], %g1 40019a6c: 80 a0 60 00 cmp %g1, 0 40019a70: 02 80 00 9a be 40019cd8 40019a74: 80 a0 40 1a cmp %g1, %i2 40019a78: 18 80 00 9b bgu 40019ce4 40019a7c: b6 10 00 01 mov %g1, %i3 return 0; if (blocks > map->size.count) blocks = map->size.count; while (blocks) 40019a80: 80 a6 e0 00 cmp %i3, 0 40019a84: 02 80 00 8e be 40019cbc <== NEVER TAKEN 40019a88: a2 06 60 44 add %i1, 0x44, %l1 doubly_singly); /* * Read the singly indirect table and get the block number. */ rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40019a8c: a0 06 60 38 add %i1, 0x38, %l0 if (rc > 0) return rc; map->last_map_block = singly; rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer, 40019a90: a6 06 60 4c add %i1, 0x4c, %l3 rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer, 40019a94: a4 06 60 40 add %i1, 0x40, %l2 if (rc > 0) return rc; map->size.count--; map->size.offset = 0; map->last_data_block = block_to_free; map->dirty = true; 40019a98: 10 80 00 13 b 40019ae4 40019a9c: b4 10 20 01 mov 1, %i2 40019aa0: 82 06 40 01 add %i1, %g1, %g1 block_to_free = map->blocks[block]; 40019aa4: fa 00 60 20 ld [ %g1 + 0x20 ], %i5 map->blocks[block] = 0; 40019aa8: c0 20 60 20 clr [ %g1 + 0x20 ] rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free); 40019aac: 94 10 00 1d mov %i5, %o2 40019ab0: 92 10 20 00 clr %o1 40019ab4: 7f ff de ce call 400115ec 40019ab8: 90 10 00 18 mov %i0, %o0 if (rc > 0) 40019abc: 80 a2 20 00 cmp %o0, 0 40019ac0: 14 80 00 61 bg 40019c44 <== NEVER TAKEN 40019ac4: b6 86 ff ff addcc %i3, -1, %i3 map->size.count--; 40019ac8: c2 06 60 08 ld [ %i1 + 8 ], %g1 40019acc: 82 00 7f ff add %g1, -1, %g1 map->size.offset = 0; 40019ad0: c0 26 60 0c clr [ %i1 + 0xc ] map->size.count--; 40019ad4: c2 26 60 08 st %g1, [ %i1 + 8 ] map->last_data_block = block_to_free; 40019ad8: fa 26 60 20 st %i5, [ %i1 + 0x20 ] while (blocks) 40019adc: 02 80 00 8a be 40019d04 40019ae0: f4 2e 40 00 stb %i2, [ %i1 ] block = map->size.count - 1; 40019ae4: 84 00 7f ff add %g1, -1, %g2 if (block < RTEMS_RFS_INODE_BLOCKS) 40019ae8: 80 a0 a0 04 cmp %g2, 4 40019aec: 28 bf ff ed bleu,a 40019aa0 <== ALWAYS TAKEN 40019af0: 83 28 60 02 sll %g1, 2, %g1 direct = block % fs->blocks_per_block; 40019af4: c6 06 20 34 ld [ %i0 + 0x34 ], %g3 <== NOT EXECUTED if (block < fs->block_map_singly_blocks) 40019af8: c8 06 20 38 ld [ %i0 + 0x38 ], %g4 <== NOT EXECUTED direct = block % fs->blocks_per_block; 40019afc: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 40019b00: 01 00 00 00 nop <== NOT EXECUTED 40019b04: 01 00 00 00 nop <== NOT EXECUTED 40019b08: 01 00 00 00 nop <== NOT EXECUTED 40019b0c: aa 70 80 03 udiv %g2, %g3, %l5 <== NOT EXECUTED if (block < fs->block_map_singly_blocks) 40019b10: 80 a1 00 02 cmp %g4, %g2 <== NOT EXECUTED direct = block % fs->blocks_per_block; 40019b14: ac 5d 40 03 smul %l5, %g3, %l6 <== NOT EXECUTED if (block < fs->block_map_singly_blocks) 40019b18: 18 80 00 4d bgu 40019c4c <== NOT EXECUTED 40019b1c: ac 20 80 16 sub %g2, %l6, %l6 <== NOT EXECUTED else if (block < fs->block_map_doubly_blocks) 40019b20: c8 06 20 3c ld [ %i0 + 0x3c ], %g4 <== NOT EXECUTED 40019b24: 80 a1 00 02 cmp %g4, %g2 <== NOT EXECUTED 40019b28: 08 80 00 77 bleu 40019d04 <== NOT EXECUTED 40019b2c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED doubly = singly / fs->blocks_per_block; 40019b30: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 40019b34: 01 00 00 00 nop <== NOT EXECUTED 40019b38: 01 00 00 00 nop <== NOT EXECUTED 40019b3c: 01 00 00 00 nop <== NOT EXECUTED 40019b40: ae 75 40 03 udiv %l5, %g3, %l7 <== NOT EXECUTED doubly_singly = singly % fs->blocks_per_block; 40019b44: 86 5d c0 03 smul %l7, %g3, %g3 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer, 40019b48: 82 05 e0 08 add %l7, 8, %g1 <== NOT EXECUTED 40019b4c: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 40019b50: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED 40019b54: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED doubly_singly = singly % fs->blocks_per_block; 40019b58: aa 25 40 03 sub %l5, %g3, %l5 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer, 40019b5c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 40019b60: 7f ff d7 5a call 4000f8c8 <== NOT EXECUTED 40019b64: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 40019b68: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40019b6c: 14 80 00 36 bg 40019c44 <== NOT EXECUTED 40019b70: 85 2d 60 02 sll %l5, 2, %g2 <== NOT EXECUTED singly = rtems_rfs_block_get_number (&map->doubly_buffer, 40019b74: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED 40019b78: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED 40019b7c: e8 08 c0 02 ldub [ %g3 + %g2 ], %l4 <== NOT EXECUTED 40019b80: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED 40019b84: c6 08 60 03 ldub [ %g1 + 3 ], %g3 <== NOT EXECUTED 40019b88: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED 40019b8c: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED 40019b90: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED 40019b94: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED 40019b98: a9 2d 20 18 sll %l4, 0x18, %l4 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40019b9c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED singly = rtems_rfs_block_get_number (&map->doubly_buffer, 40019ba0: a8 15 00 03 or %l4, %g3, %l4 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40019ba4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED singly = rtems_rfs_block_get_number (&map->doubly_buffer, 40019ba8: a8 15 00 02 or %l4, %g2, %l4 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40019bac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED singly = rtems_rfs_block_get_number (&map->doubly_buffer, 40019bb0: a8 15 00 01 or %l4, %g1, %l4 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40019bb4: 7f ff d7 45 call 4000f8c8 <== NOT EXECUTED 40019bb8: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED if (rc > 0) 40019bbc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40019bc0: 14 80 00 21 bg 40019c44 <== NOT EXECUTED 40019bc4: 85 2d a0 02 sll %l6, 2, %g2 <== NOT EXECUTED block_to_free = rtems_rfs_block_get_number (&map->singly_buffer, 40019bc8: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED 40019bcc: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED 40019bd0: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED 40019bd4: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5 <== NOT EXECUTED 40019bd8: c6 08 60 03 ldub [ %g1 + 3 ], %g3 <== NOT EXECUTED 40019bdc: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED 40019be0: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED 40019be4: bb 2f 60 18 sll %i5, 0x18, %i5 <== NOT EXECUTED 40019be8: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED 40019bec: ba 17 40 03 or %i5, %g3, %i5 <== NOT EXECUTED 40019bf0: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED 40019bf4: ba 17 40 02 or %i5, %g2, %i5 <== NOT EXECUTED if (direct == 0) 40019bf8: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 40019bfc: 12 bf ff ac bne 40019aac <== NOT EXECUTED 40019c00: ba 17 40 01 or %i5, %g1, %i5 <== NOT EXECUTED rc = rtems_rfs_group_bitmap_free (fs, false, singly); 40019c04: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED 40019c08: 92 10 20 00 clr %o1 <== NOT EXECUTED 40019c0c: 7f ff de 78 call 400115ec <== NOT EXECUTED 40019c10: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 40019c14: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40019c18: 14 80 00 0b bg 40019c44 <== NOT EXECUTED 40019c1c: 98 10 00 15 mov %l5, %o4 <== NOT EXECUTED map->last_map_block = singly; 40019c20: e8 26 60 1c st %l4, [ %i1 + 0x1c ] <== NOT EXECUTED rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer, 40019c24: 96 10 00 17 mov %l7, %o3 <== NOT EXECUTED 40019c28: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED 40019c2c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 40019c30: 7f ff fc d7 call 40018f8c <== NOT EXECUTED 40019c34: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc) 40019c38: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40019c3c: 02 bf ff 9d be 40019ab0 <== NOT EXECUTED 40019c40: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED */ if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size)) rtems_rfs_block_size_get_bpos (&map->size, &map->bpos); return 0; } 40019c44: 81 c7 e0 08 ret <== NOT EXECUTED 40019c48: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 40019c4c: 82 05 60 08 add %l5, 8, %g1 <== NOT EXECUTED 40019c50: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 40019c54: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED 40019c58: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED 40019c5c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED 40019c60: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED 40019c64: 7f ff d7 19 call 4000f8c8 <== NOT EXECUTED 40019c68: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 40019c6c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40019c70: 14 bf ff f5 bg 40019c44 <== NOT EXECUTED 40019c74: 85 2d a0 02 sll %l6, 2, %g2 <== NOT EXECUTED block_to_free = rtems_rfs_block_get_number (&map->singly_buffer, 40019c78: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED 40019c7c: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED 40019c80: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED 40019c84: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5 <== NOT EXECUTED 40019c88: c6 08 60 03 ldub [ %g1 + 3 ], %g3 <== NOT EXECUTED 40019c8c: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED 40019c90: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED 40019c94: bb 2f 60 18 sll %i5, 0x18, %i5 <== NOT EXECUTED 40019c98: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED 40019c9c: ba 17 40 03 or %i5, %g3, %i5 <== NOT EXECUTED 40019ca0: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED 40019ca4: ba 17 40 02 or %i5, %g2, %i5 <== NOT EXECUTED rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer, 40019ca8: 98 10 00 16 mov %l6, %o4 <== NOT EXECUTED block_to_free = rtems_rfs_block_get_number (&map->singly_buffer, 40019cac: ba 17 40 01 or %i5, %g1, %i5 <== NOT EXECUTED rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer, 40019cb0: 96 10 00 15 mov %l5, %o3 <== NOT EXECUTED 40019cb4: 10 bf ff de b 40019c2c <== NOT EXECUTED 40019cb8: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size)) 40019cbc: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 <== NOT EXECUTED 40019cc0: 80 a0 40 02 cmp %g1, %g2 40019cc4: 08 80 00 25 bleu 40019d58 <== NEVER TAKEN 40019cc8: 86 00 7f ff add %g1, -1, %g3 40019ccc: 80 a0 c0 02 cmp %g3, %g2 40019cd0: 22 80 00 1c be,a 40019d40 <== ALWAYS TAKEN 40019cd4: c4 06 60 0c ld [ %i1 + 0xc ], %g2 return 0; 40019cd8: 90 10 20 00 clr %o0 } 40019cdc: 81 c7 e0 08 ret 40019ce0: 91 e8 00 08 restore %g0, %o0, %o0 40019ce4: 10 bf ff 67 b 40019a80 40019ce8: b6 10 00 1a mov %i2, %i3 printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n", 40019cec: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 40019cf0: 11 10 00 8d sethi %hi(0x40023400), %o0 <== NOT EXECUTED 40019cf4: 7f ff e5 a5 call 40013388 <__wrap_printf> <== NOT EXECUTED 40019cf8: 90 12 22 88 or %o0, 0x288, %o0 ! 40023688 <== NOT EXECUTED if (map->size.count == 0) 40019cfc: 10 bf ff 5c b 40019a6c <== NOT EXECUTED 40019d00: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED if (map->size.count == 0) 40019d04: 80 a0 60 00 cmp %g1, 0 40019d08: 32 bf ff ee bne,a 40019cc0 40019d0c: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 map->last_map_block = 0; 40019d10: c0 26 60 1c clr [ %i1 + 0x1c ] map->last_data_block = 0; 40019d14: c0 26 60 20 clr [ %i1 + 0x20 ] 40019d18: c4 06 60 0c ld [ %i1 + 0xc ], %g2 rtems_rfs_block_size_get_bpos (&map->size, &map->bpos); 40019d1c: c2 26 60 10 st %g1, [ %i1 + 0x10 ] 40019d20: 80 a0 a0 00 cmp %g2, 0 40019d24: c4 26 60 14 st %g2, [ %i1 + 0x14 ] 40019d28: 02 bf ff ec be 40019cd8 <== ALWAYS TAKEN 40019d2c: c0 26 60 18 clr [ %i1 + 0x18 ] 40019d30: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED return 0; 40019d34: 90 10 20 00 clr %o0 <== NOT EXECUTED rtems_rfs_block_size_get_bpos (&map->size, &map->bpos); 40019d38: 10 bf ff c3 b 40019c44 <== NOT EXECUTED 40019d3c: c2 26 60 10 st %g1, [ %i1 + 0x10 ] <== NOT EXECUTED if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size)) 40019d40: c6 06 60 14 ld [ %i1 + 0x14 ], %g3 40019d44: 80 a0 c0 02 cmp %g3, %g2 40019d48: 38 bf ff f6 bgu,a 40019d20 <== ALWAYS TAKEN 40019d4c: c2 26 60 10 st %g1, [ %i1 + 0x10 ] return 0; 40019d50: 10 bf ff e3 b 40019cdc <== NOT EXECUTED 40019d54: 90 10 20 00 clr %o0 <== NOT EXECUTED 40019d58: 10 bf ff f1 b 40019d1c <== NOT EXECUTED 40019d5c: c4 06 60 0c ld [ %i1 + 0xc ], %g2 <== NOT EXECUTED =============================================================================== 40019dc0 : int rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer, bool modified) { 40019dc0: 9d e3 bf a0 save %sp, -96, %sp rtems_status_code sc; int rc = 0; if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE)) 40019dc4: 90 10 20 00 clr %o0 40019dc8: 7f ff e4 e2 call 40013150 40019dcc: 92 10 20 40 mov 0x40, %o1 40019dd0: 80 a2 20 00 cmp %o0, 0 40019dd4: 02 80 00 0b be 40019e00 <== ALWAYS TAKEN 40019dd8: 80 a6 60 00 cmp %i1, 0 printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n", 40019ddc: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 <== NOT EXECUTED 40019de0: 12 80 00 18 bne 40019e40 <== NOT EXECUTED 40019de4: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 <== NOT EXECUTED 40019de8: 17 10 00 84 sethi %hi(0x40021000), %o3 <== NOT EXECUTED 40019dec: 96 12 e1 c0 or %o3, 0x1c0, %o3 ! 400211c0 <_rodata_start+0x8e0> <== NOT EXECUTED 40019df0: 11 10 00 8d sethi %hi(0x40023400), %o0 <== NOT EXECUTED 40019df4: 7f ff e5 65 call 40013388 <__wrap_printf> <== NOT EXECUTED 40019df8: 90 12 22 d8 or %o0, 0x2d8, %o0 ! 400236d8 <== NOT EXECUTED ((intptr_t) buffer->user), buffer->block, modified ? "(modified)" : ""); if (modified) 40019dfc: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 40019e00: 02 80 00 09 be 40019e24 40019e04: 90 10 00 18 mov %i0, %o0 sc = rtems_bdbuf_release_modified (buffer); 40019e08: 7f ff ef 51 call 40015b4c 40019e0c: 01 00 00 00 nop #if RTEMS_RFS_BUFFER_ERRORS printf ("rtems-rfs: buffer-release: bdbuf-%s: %s(%d)\n", modified ? "modified" : "not-modified", rtems_status_text (sc), sc); #endif rc = EIO; 40019e10: 80 a0 00 08 cmp %g0, %o0 40019e14: b0 40 3f ff addx %g0, -1, %i0 40019e18: b0 0e 3f fb and %i0, -5, %i0 } return rc; } 40019e1c: 81 c7 e0 08 ret 40019e20: 91 ee 20 05 restore %i0, 5, %o0 sc = rtems_bdbuf_release (buffer); 40019e24: 7f ff ef 04 call 40015a34 40019e28: 01 00 00 00 nop rc = EIO; 40019e2c: 80 a0 00 08 cmp %g0, %o0 40019e30: b0 40 3f ff addx %g0, -1, %i0 40019e34: b0 0e 3f fb and %i0, -5, %i0 } 40019e38: 81 c7 e0 08 ret 40019e3c: 91 ee 20 05 restore %i0, 5, %o0 printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n", 40019e40: 17 10 00 8d sethi %hi(0x40023400), %o3 <== NOT EXECUTED 40019e44: 10 bf ff eb b 40019df0 <== NOT EXECUTED 40019e48: 96 12 e2 c8 or %o3, 0x2c8, %o3 ! 400236c8 <== NOT EXECUTED =============================================================================== 4000ffd4 : { 4000ffd4: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE)) 4000ffd8: 90 10 20 00 clr %o0 4000ffdc: 92 10 20 10 mov 0x10, %o1 4000ffe0: 40 00 0c 5c call 40013150 4000ffe4: ba 10 00 18 mov %i0, %i5 4000ffe8: 80 a2 20 00 cmp %o0, 0 4000ffec: 12 80 00 2f bne 400100a8 <== NEVER TAKEN 4000fff0: 11 10 00 88 sethi %hi(0x40022000), %o0 rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs)); 4000fff4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 4000fff8: d2 00 60 20 ld [ %g1 + 0x20 ], %o1 4000fffc: 7f ff ff b5 call 4000fed0 40010000: 90 10 00 1d mov %i5, %o0 if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE)) 40010004: b0 92 20 00 orcc %o0, 0, %i0 40010008: 14 80 00 1b bg 40010074 <== NEVER TAKEN 4001000c: 90 10 20 00 clr %o0 if (close (fs->device) < 0) 40010010: 40 00 1a c3 call 40016b1c 40010014: d0 07 60 0c ld [ %i5 + 0xc ], %o0 40010018: 80 a2 20 00 cmp %o0, 0 4001001c: 06 80 00 04 bl 4001002c <== NEVER TAKEN 40010020: 01 00 00 00 nop } 40010024: 81 c7 e0 08 ret 40010028: 81 e8 00 00 restore rc = errno; 4001002c: 40 00 39 48 call 4001e54c <__errno> <== NOT EXECUTED 40010030: 01 00 00 00 nop <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE)) 40010034: 92 10 20 10 mov 0x10, %o1 ! 10 <_TLS_Alignment+0xf> <== NOT EXECUTED rc = errno; 40010038: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE)) 4001003c: 40 00 0c 45 call 40013150 <== NOT EXECUTED 40010040: 90 10 20 00 clr %o0 <== NOT EXECUTED 40010044: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40010048: 02 80 00 09 be 4001006c <== NOT EXECUTED 4001004c: 01 00 00 00 nop <== NOT EXECUTED printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n", 40010050: 40 00 3d 14 call 4001f4a0 <== NOT EXECUTED 40010054: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40010058: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4001005c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 40010060: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED 40010064: 40 00 0c c9 call 40013388 <__wrap_printf> <== NOT EXECUTED 40010068: 90 12 22 38 or %o0, 0x238, %o0 ! 40022238 <== NOT EXECUTED } 4001006c: 81 c7 e0 08 ret <== NOT EXECUTED 40010070: 81 e8 00 00 restore <== NOT EXECUTED if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE)) 40010074: 40 00 0c 37 call 40013150 <== NOT EXECUTED 40010078: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED 4001007c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40010080: 02 bf ff e4 be 40010010 <== NOT EXECUTED 40010084: 01 00 00 00 nop <== NOT EXECUTED printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n", 40010088: 40 00 3d 06 call 4001f4a0 <== NOT EXECUTED 4001008c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40010090: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 40010094: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 40010098: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED 4001009c: 40 00 0c bb call 40013388 <__wrap_printf> <== NOT EXECUTED 400100a0: 90 12 21 f8 or %o0, 0x1f8, %o0 ! 400221f8 <== NOT EXECUTED 400100a4: 30 bf ff db b,a 40010010 <== NOT EXECUTED printf ("rtems-rfs: buffer-close: closing\n"); 400100a8: 40 00 0c c7 call 400133c4 <__wrap_puts> <== NOT EXECUTED 400100ac: 90 12 21 d0 or %o0, 0x1d0, %o0 <== NOT EXECUTED rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs)); 400100b0: 10 bf ff d2 b 4000fff8 <== NOT EXECUTED 400100b4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED =============================================================================== 4000f8c8 : { 4000f8c8: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_buffer_handle_has_block (handle)) 4000f8cc: c2 06 60 08 ld [ %i1 + 8 ], %g1 4000f8d0: 80 a0 60 00 cmp %g1, 0 4000f8d4: 02 80 00 1b be 4000f940 4000f8d8: ba 10 00 18 mov %i0, %i5 if (block && (rtems_rfs_buffer_bnum (handle) == block)) 4000f8dc: 80 a6 a0 00 cmp %i2, 0 4000f8e0: 02 80 00 06 be 4000f8f8 <== NEVER TAKEN 4000f8e4: 90 10 20 00 clr %o0 4000f8e8: c2 06 60 04 ld [ %i1 + 4 ], %g1 4000f8ec: 80 a0 40 1a cmp %g1, %i2 4000f8f0: 02 80 00 7a be 4000fad8 4000f8f4: 01 00 00 00 nop if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 4000f8f8: 40 00 0e 16 call 40013150 4000f8fc: 92 10 21 00 mov 0x100, %o1 ! 100 <_TLS_Alignment+0xff> 4000f900: 80 a2 20 00 cmp %o0, 0 4000f904: 32 80 00 4f bne,a 4000fa40 <== NEVER TAKEN 4000f908: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED if (rtems_rfs_buffer_handle_has_block (handle)) 4000f90c: c2 06 60 08 ld [ %i1 + 8 ], %g1 4000f910: 80 a0 60 00 cmp %g1, 0 4000f914: 22 80 00 0a be,a 4000f93c <== NEVER TAKEN 4000f918: c0 2e 40 00 clrb [ %i1 ] <== NOT EXECUTED 4000f91c: 92 10 00 19 mov %i1, %o1 4000f920: 7f ff ff 5b call 4000f68c 4000f924: 90 10 00 1d mov %i5, %o0 if (rc > 0) 4000f928: b0 92 20 00 orcc %o0, 0, %i0 4000f92c: 24 80 00 04 ble,a 4000f93c <== ALWAYS TAKEN 4000f930: c0 2e 40 00 clrb [ %i1 ] } 4000f934: 81 c7 e0 08 ret <== NOT EXECUTED 4000f938: 81 e8 00 00 restore <== NOT EXECUTED handle->bnum = 0; 4000f93c: c0 26 60 04 clr [ %i1 + 4 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 4000f940: 90 10 20 00 clr %o0 4000f944: 40 00 0e 03 call 40013150 4000f948: 92 10 21 00 mov 0x100, %o1 4000f94c: 80 a2 20 00 cmp %o0, 0 4000f950: 32 80 00 59 bne,a 4000fab4 <== NEVER TAKEN 4000f954: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED if (fs->buffers_count) 4000f958: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 4000f95c: 80 a0 60 00 cmp %g1, 0 4000f960: 12 80 00 41 bne 4000fa64 4000f964: 94 10 00 1a mov %i2, %o2 if (!rtems_rfs_fs_no_local_cache (fs) && 4000f968: c4 07 40 00 ld [ %i5 ], %g2 4000f96c: 80 88 a0 02 btst 2, %g2 4000f970: 12 80 00 26 bne 4000fa08 4000f974: c2 06 60 08 ld [ %i1 + 8 ], %g1 4000f978: 80 a0 60 00 cmp %g1, 0 4000f97c: 22 80 00 69 be,a 4000fb20 4000f980: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 rtems_rfs_buffer_refs_up (handle); 4000f984: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 old_last = tail->previous; 4000f988: c6 07 60 4c ld [ %i5 + 0x4c ], %g3 return &the_chain->Tail.Node; 4000f98c: 88 07 60 48 add %i5, 0x48, %g4 4000f990: 84 00 a0 01 inc %g2 the_node->next = tail; 4000f994: c8 20 40 00 st %g4, [ %g1 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 4000f998: 90 10 20 00 clr %o0 rtems_rfs_buffer_refs_up (handle); 4000f99c: c4 20 60 30 st %g2, [ %g1 + 0x30 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 4000f9a0: 92 10 21 00 mov 0x100, %o1 tail->previous = the_node; 4000f9a4: c2 27 60 4c st %g1, [ %i5 + 0x4c ] old_last->next = the_node; 4000f9a8: c2 20 c0 00 st %g1, [ %g3 ] fs->buffers_count++; 4000f9ac: c4 07 60 50 ld [ %i5 + 0x50 ], %g2 the_node->previous = old_last; 4000f9b0: c6 20 60 04 st %g3, [ %g1 + 4 ] 4000f9b4: 84 00 a0 01 inc %g2 4000f9b8: c4 27 60 50 st %g2, [ %i5 + 0x50 ] handle->buffer->user = (void*) ((intptr_t) block); 4000f9bc: f4 20 60 34 st %i2, [ %g1 + 0x34 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 4000f9c0: 40 00 0d e4 call 40013150 4000f9c4: f4 26 60 04 st %i2, [ %i1 + 4 ] 4000f9c8: 80 a2 20 00 cmp %o0, 0 4000f9cc: 02 80 00 43 be 4000fad8 <== ALWAYS TAKEN 4000f9d0: 80 a6 e0 00 cmp %i3, 0 printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n", 4000f9d4: 12 80 00 43 bne 4000fae0 <== NOT EXECUTED 4000f9d8: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED 4000f9dc: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED 4000f9e0: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED return 0; 4000f9e4: b0 10 20 00 clr %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n", 4000f9e8: 15 10 00 87 sethi %hi(0x40021c00), %o2 <== NOT EXECUTED 4000f9ec: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4000f9f0: 94 12 a2 48 or %o2, 0x248, %o2 <== NOT EXECUTED 4000f9f4: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED 4000f9f8: 40 00 0e 64 call 40013388 <__wrap_printf> <== NOT EXECUTED 4000f9fc: 90 12 23 20 or %o0, 0x320, %o0 ! 40021f20 <== NOT EXECUTED 4000fa00: 81 c7 e0 08 ret <== NOT EXECUTED 4000fa04: 81 e8 00 00 restore <== NOT EXECUTED if (!rtems_rfs_buffer_handle_has_block (handle)) 4000fa08: 80 a0 60 00 cmp %g1, 0 4000fa0c: 32 bf ff df bne,a 4000f988 <== NEVER TAKEN 4000fa10: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 <== NOT EXECUTED rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer); 4000fa14: 96 06 60 08 add %i1, 8, %o3 4000fa18: 94 10 00 1b mov %i3, %o2 4000fa1c: 92 10 00 1a mov %i2, %o1 4000fa20: 40 00 28 d4 call 40019d70 4000fa24: 90 10 00 1d mov %i5, %o0 if (rc > 0) 4000fa28: b0 92 20 00 orcc %o0, 0, %i0 4000fa2c: 14 80 00 4f bg 4000fb68 <== NEVER TAKEN 4000fa30: 90 10 20 00 clr %o0 rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle)); 4000fa34: c2 06 60 08 ld [ %i1 + 8 ], %g1 node->next = NULL; 4000fa38: 10 bf ff d3 b 4000f984 4000fa3c: c0 20 40 00 clr [ %g1 ] printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n", 4000fa40: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED 4000fa44: 40 00 0e 51 call 40013388 <__wrap_printf> <== NOT EXECUTED 4000fa48: 90 12 22 50 or %o0, 0x250, %o0 ! 40021e50 <== NOT EXECUTED if (rtems_rfs_buffer_handle_has_block (handle)) 4000fa4c: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED 4000fa50: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000fa54: 32 bf ff b3 bne,a 4000f920 <== NOT EXECUTED 4000fa58: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED handle->dirty = false; 4000fa5c: 10 bf ff b8 b 4000f93c <== NOT EXECUTED 4000fa60: c0 2e 40 00 clrb [ %i1 ] <== NOT EXECUTED handle->buffer = rtems_rfs_scan_chain (&fs->buffers, 4000fa64: 92 07 60 50 add %i5, 0x50, %o1 4000fa68: 7f ff fe 9a call 4000f4d0 4000fa6c: 90 07 60 44 add %i5, 0x44, %o0 if (rtems_rfs_buffer_handle_has_block (handle) && 4000fa70: 80 a2 20 00 cmp %o0, 0 4000fa74: 02 80 00 26 be 4000fb0c 4000fa78: d0 26 60 08 st %o0, [ %i1 + 8 ] rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 4000fa7c: 90 10 20 00 clr %o0 4000fa80: 40 00 0d b4 call 40013150 4000fa84: 92 10 21 00 mov 0x100, %o1 if (rtems_rfs_buffer_handle_has_block (handle) && 4000fa88: 80 a2 20 00 cmp %o0, 0 4000fa8c: 22 bf ff b8 be,a 4000f96c <== ALWAYS TAKEN 4000fa90: c4 07 40 00 ld [ %i5 ], %g2 rtems_rfs_buffer_refs (handle) + 1); 4000fa94: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n", 4000fa98: d2 00 60 30 ld [ %g1 + 0x30 ], %o1 <== NOT EXECUTED 4000fa9c: 92 02 60 01 inc %o1 <== NOT EXECUTED 4000faa0: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED 4000faa4: 40 00 0e 39 call 40013388 <__wrap_printf> <== NOT EXECUTED 4000faa8: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 40021eb0 <== NOT EXECUTED if (!rtems_rfs_fs_no_local_cache (fs) && 4000faac: 10 bf ff b0 b 4000f96c <== NOT EXECUTED 4000fab0: c4 07 40 00 ld [ %i5 ], %g2 <== NOT EXECUTED printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block); 4000fab4: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED 4000fab8: 40 00 0e 34 call 40013388 <__wrap_printf> <== NOT EXECUTED 4000fabc: 90 12 22 88 or %o0, 0x288, %o0 ! 40021e88 <== NOT EXECUTED if (fs->buffers_count) 4000fac0: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 <== NOT EXECUTED 4000fac4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000fac8: 22 bf ff a9 be,a 4000f96c <== NOT EXECUTED 4000facc: c4 07 40 00 ld [ %i5 ], %g2 <== NOT EXECUTED handle->buffer = rtems_rfs_scan_chain (&fs->buffers, 4000fad0: 10 bf ff e5 b 4000fa64 <== NOT EXECUTED 4000fad4: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED return 0; 4000fad8: 81 c7 e0 08 ret 4000fadc: 91 e8 20 00 restore %g0, 0, %o0 printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n", 4000fae0: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED 4000fae4: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED return 0; 4000fae8: b0 10 20 00 clr %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n", 4000faec: 15 10 00 87 sethi %hi(0x40021c00), %o2 <== NOT EXECUTED 4000faf0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4000faf4: 94 12 a2 40 or %o2, 0x240, %o2 <== NOT EXECUTED 4000faf8: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED 4000fafc: 40 00 0e 23 call 40013388 <__wrap_printf> <== NOT EXECUTED 4000fb00: 90 12 23 20 or %o0, 0x320, %o0 ! 40021f20 <== NOT EXECUTED 4000fb04: 81 c7 e0 08 ret <== NOT EXECUTED 4000fb08: 81 e8 00 00 restore <== NOT EXECUTED if (!rtems_rfs_fs_no_local_cache (fs) && 4000fb0c: c2 07 40 00 ld [ %i5 ], %g1 4000fb10: 80 88 60 02 btst 2, %g1 4000fb14: 12 bf ff c1 bne 4000fa18 4000fb18: 96 06 60 08 add %i1, 8, %o3 if (fs->release_count) 4000fb1c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 4000fb20: 80 a0 60 00 cmp %g1, 0 4000fb24: 12 80 00 25 bne 4000fbb8 4000fb28: 94 10 00 1a mov %i2, %o2 if (!rtems_rfs_buffer_handle_has_block (handle) && 4000fb2c: c2 07 60 70 ld [ %i5 + 0x70 ], %g1 4000fb30: 80 a0 60 00 cmp %g1, 0 4000fb34: 02 bf ff b9 be 4000fa18 4000fb38: 96 06 60 08 add %i1, 8, %o3 handle->buffer = rtems_rfs_scan_chain (&fs->release_modified, 4000fb3c: 94 10 00 1a mov %i2, %o2 4000fb40: 92 07 60 70 add %i5, 0x70, %o1 4000fb44: 7f ff fe 63 call 4000f4d0 4000fb48: 90 07 60 64 add %i5, 0x64, %o0 4000fb4c: d0 26 60 08 st %o0, [ %i1 + 8 ] if (rtems_rfs_buffer_handle_has_block (handle)) 4000fb50: 80 a2 20 00 cmp %o0, 0 4000fb54: 02 bf ff b0 be 4000fa14 4000fb58: 82 10 00 08 mov %o0, %g1 rtems_rfs_buffer_mark_dirty (handle); 4000fb5c: 84 10 20 01 mov 1, %g2 4000fb60: 10 bf ff 89 b 4000f984 4000fb64: c4 2e 40 00 stb %g2, [ %i1 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 4000fb68: 40 00 0d 7a call 40013150 <== NOT EXECUTED 4000fb6c: 92 10 21 00 mov 0x100, %o1 <== NOT EXECUTED 4000fb70: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000fb74: 02 bf ff 70 be 4000f934 <== NOT EXECUTED 4000fb78: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n", 4000fb7c: 12 80 00 18 bne 4000fbdc <== NOT EXECUTED 4000fb80: 3b 10 00 87 sethi %hi(0x40021c00), %i5 <== NOT EXECUTED 4000fb84: 3b 10 00 87 sethi %hi(0x40021c00), %i5 <== NOT EXECUTED 4000fb88: ba 17 62 48 or %i5, 0x248, %i5 ! 40021e48 <== NOT EXECUTED 4000fb8c: 40 00 3e 45 call 4001f4a0 <== NOT EXECUTED 4000fb90: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000fb94: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED 4000fb98: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED 4000fb9c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 4000fba0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4000fba4: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED 4000fba8: 40 00 0d f8 call 40013388 <__wrap_printf> <== NOT EXECUTED 4000fbac: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 40021ee8 <== NOT EXECUTED 4000fbb0: 81 c7 e0 08 ret <== NOT EXECUTED 4000fbb4: 81 e8 00 00 restore <== NOT EXECUTED handle->buffer = rtems_rfs_scan_chain (&fs->release, 4000fbb8: 92 07 60 60 add %i5, 0x60, %o1 4000fbbc: 7f ff fe 45 call 4000f4d0 4000fbc0: 90 07 60 54 add %i5, 0x54, %o0 4000fbc4: d0 26 60 08 st %o0, [ %i1 + 8 ] if (!rtems_rfs_buffer_handle_has_block (handle) && 4000fbc8: 80 a2 20 00 cmp %o0, 0 4000fbcc: 12 bf ff 6e bne 4000f984 4000fbd0: 82 10 00 08 mov %o0, %g1 4000fbd4: 10 bf ff d7 b 4000fb30 4000fbd8: c2 07 60 70 ld [ %i5 + 0x70 ], %g1 printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n", 4000fbdc: 10 bf ff ec b 4000fb8c <== NOT EXECUTED 4000fbe0: ba 17 62 40 or %i5, 0x240, %i5 <== NOT EXECUTED =============================================================================== 4000fc08 : { 4000fc08: 9d e3 bf 40 save %sp, -192, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC)) 4000fc0c: 90 10 20 00 clr %o0 4000fc10: 40 00 0d 50 call 40013150 4000fc14: 92 10 20 20 mov 0x20, %o1 4000fc18: 80 a2 20 00 cmp %o0, 0 4000fc1c: 12 80 00 26 bne 4000fcb4 <== NEVER TAKEN 4000fc20: 92 10 00 18 mov %i0, %o1 fs->device = open (name, O_RDWR); 4000fc24: 92 10 20 02 mov 2, %o1 4000fc28: 7f ff dc df call 40006fa4 4000fc2c: 90 10 00 18 mov %i0, %o0 if (fs->device < 0) 4000fc30: 80 a2 20 00 cmp %o0, 0 4000fc34: 06 80 00 15 bl 4000fc88 <== NEVER TAKEN 4000fc38: d0 26 60 0c st %o0, [ %i1 + 0xc ] if (fstat (fs->device, &st) < 0) 4000fc3c: 40 00 1c 00 call 40016c3c 4000fc40: 92 07 bf a0 add %fp, -96, %o1 4000fc44: 80 a2 20 00 cmp %o0, 0 4000fc48: 06 80 00 32 bl 4000fd10 <== NEVER TAKEN 4000fc4c: 05 00 00 3c sethi %hi(0xf000), %g2 if (!S_ISBLK (st.st_mode)) 4000fc50: c2 07 bf ac ld [ %fp + -84 ], %g1 4000fc54: 82 08 40 02 and %g1, %g2, %g1 4000fc58: 05 00 00 18 sethi %hi(0x6000), %g2 4000fc5c: 80 a0 40 02 cmp %g1, %g2 4000fc60: 22 80 00 1a be,a 4000fcc8 <== ALWAYS TAKEN 4000fc64: d0 06 60 0c ld [ %i1 + 0xc ], %o0 if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN)) 4000fc68: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000fc6c: 40 00 0d 39 call 40013150 <== NOT EXECUTED 4000fc70: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED 4000fc74: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000fc78: 12 80 00 38 bne 4000fd58 <== NOT EXECUTED 4000fc7c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return ENXIO; 4000fc80: 81 c7 e0 08 ret <== NOT EXECUTED 4000fc84: 91 e8 20 06 restore %g0, 6, %o0 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN)) 4000fc88: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000fc8c: 40 00 0d 31 call 40013150 <== NOT EXECUTED 4000fc90: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED 4000fc94: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000fc98: 02 bf ff fa be 4000fc80 <== NOT EXECUTED 4000fc9c: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED return ENXIO; 4000fca0: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-open: cannot open file\n"); 4000fca4: 40 00 0d c8 call 400133c4 <__wrap_puts> <== NOT EXECUTED 4000fca8: 90 12 23 88 or %o0, 0x388, %o0 <== NOT EXECUTED 4000fcac: 81 c7 e0 08 ret <== NOT EXECUTED 4000fcb0: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: buffer-open: opening: %s\n", name); 4000fcb4: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED 4000fcb8: 40 00 0d b4 call 40013388 <__wrap_printf> <== NOT EXECUTED 4000fcbc: 90 12 23 60 or %o0, 0x360, %o0 ! 40021f60 <== NOT EXECUTED fs->device = open (name, O_RDWR); 4000fcc0: 10 bf ff da b 4000fc28 <== NOT EXECUTED 4000fcc4: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED static inline int rtems_disk_fd_get_disk_device( int fd, rtems_disk_device **dd_ptr ) { return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr); 4000fcc8: 94 06 60 10 add %i1, 0x10, %o2 4000fccc: 13 10 01 10 sethi %hi(0x40044000), %o1 4000fcd0: 40 00 1c 56 call 40016e28 4000fcd4: 92 12 62 09 or %o1, 0x209, %o1 ! 40044209 <__end+0x1b4f9> 4000fcd8: b0 10 00 08 mov %o0, %i0 if (rv != 0) 4000fcdc: 80 a6 20 00 cmp %i0, 0 4000fce0: 02 80 00 24 be 4000fd70 <== ALWAYS TAKEN 4000fce4: 90 10 20 00 clr %o0 if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN)) 4000fce8: 40 00 0d 1a call 40013150 <== NOT EXECUTED 4000fcec: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED 4000fcf0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000fcf4: 02 bf ff e3 be 4000fc80 <== NOT EXECUTED 4000fcf8: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED return ENXIO; 4000fcfc: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-open: cannot obtain the disk\n"); 4000fd00: 40 00 0d b1 call 400133c4 <__wrap_puts> <== NOT EXECUTED 4000fd04: 90 12 20 20 or %o0, 0x20, %o0 <== NOT EXECUTED 4000fd08: 81 c7 e0 08 ret <== NOT EXECUTED 4000fd0c: 81 e8 00 00 restore <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN)) 4000fd10: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000fd14: 40 00 0d 0f call 40013150 <== NOT EXECUTED 4000fd18: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED 4000fd1c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000fd20: 02 bf ff d8 be 4000fc80 <== NOT EXECUTED 4000fd24: 01 00 00 00 nop <== NOT EXECUTED name, strerror (errno)); 4000fd28: 40 00 3a 09 call 4001e54c <__errno> <== NOT EXECUTED 4000fd2c: 01 00 00 00 nop <== NOT EXECUTED printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n", 4000fd30: 40 00 3d dc call 4001f4a0 <== NOT EXECUTED 4000fd34: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED 4000fd38: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4000fd3c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED return ENXIO; 4000fd40: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n", 4000fd44: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED 4000fd48: 40 00 0d 90 call 40013388 <__wrap_printf> <== NOT EXECUTED 4000fd4c: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 40021fb8 <== NOT EXECUTED 4000fd50: 81 c7 e0 08 ret <== NOT EXECUTED 4000fd54: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name); 4000fd58: 11 10 00 87 sethi %hi(0x40021c00), %o0 <== NOT EXECUTED return ENXIO; 4000fd5c: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name); 4000fd60: 40 00 0d 8a call 40013388 <__wrap_printf> <== NOT EXECUTED 4000fd64: 90 12 23 e8 or %o0, 0x3e8, %o0 <== NOT EXECUTED 4000fd68: 81 c7 e0 08 ret <== NOT EXECUTED 4000fd6c: 81 e8 00 00 restore <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC)) 4000fd70: 40 00 0c f8 call 40013150 4000fd74: 92 10 20 20 mov 0x20, %o1 4000fd78: 80 a2 20 00 cmp %o0, 0 4000fd7c: 32 80 00 04 bne,a 4000fd8c <== NEVER TAKEN 4000fd80: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 <== NOT EXECUTED } 4000fd84: 81 c7 e0 08 ret 4000fd88: 81 e8 00 00 restore printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n", 4000fd8c: d4 00 60 20 ld [ %g1 + 0x20 ], %o2 <== NOT EXECUTED 4000fd90: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED 4000fd94: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED 4000fd98: 40 00 0d 7c call 40013388 <__wrap_printf> <== NOT EXECUTED 4000fd9c: 90 12 20 50 or %o0, 0x50, %o0 ! 40022050 <== NOT EXECUTED } 4000fda0: 81 c7 e0 08 ret <== NOT EXECUTED 4000fda4: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4000fed0 : { 4000fed0: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 4000fed4: 90 10 20 00 clr %o0 { 4000fed8: f2 27 a0 48 st %i1, [ %fp + 0x48 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 4000fedc: 40 00 0c 9d call 40013150 4000fee0: 92 10 24 00 mov 0x400, %o1 4000fee4: 80 a2 20 00 cmp %o0, 0 4000fee8: 12 80 00 37 bne 4000ffc4 <== NEVER TAKEN 4000feec: d2 07 a0 48 ld [ %fp + 0x48 ], %o1 rc = rtems_rfs_buffers_release (fs); 4000fef0: 7f ff ff d4 call 4000fe40 4000fef4: 90 10 00 18 mov %i0, %o0 if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 4000fef8: ba 92 20 00 orcc %o0, 0, %i5 4000fefc: 14 80 00 25 bg 4000ff90 <== NEVER TAKEN 4000ff00: 90 10 20 00 clr %o0 rc = rtems_rfs_buffer_sync (fs); 4000ff04: 7f ff ff a9 call 4000fda8 4000ff08: 90 10 00 18 mov %i0, %o0 if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 4000ff0c: ba 92 20 00 orcc %o0, 0, %i5 4000ff10: 14 80 00 12 bg 4000ff58 <== NEVER TAKEN 4000ff14: 90 10 20 00 clr %o0 rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size); 4000ff18: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 4000ff1c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 4000ff20: 94 07 a0 48 add %fp, 0x48, %o2 4000ff24: 13 20 01 10 sethi %hi(0x80044000), %o1 4000ff28: 9f c0 40 00 call %g1 4000ff2c: 92 12 62 04 or %o1, 0x204, %o1 ! 80044204 if (rc < 0) 4000ff30: b0 92 20 00 orcc %o0, 0, %i0 4000ff34: 06 80 00 04 bl 4000ff44 <== NEVER TAKEN 4000ff38: 01 00 00 00 nop } 4000ff3c: 81 c7 e0 08 ret 4000ff40: 81 e8 00 00 restore rc = errno; 4000ff44: 40 00 39 82 call 4001e54c <__errno> <== NOT EXECUTED 4000ff48: 01 00 00 00 nop <== NOT EXECUTED 4000ff4c: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED } 4000ff50: 81 c7 e0 08 ret <== NOT EXECUTED 4000ff54: 81 e8 00 00 restore <== NOT EXECUTED if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 4000ff58: 40 00 0c 7e call 40013150 <== NOT EXECUTED 4000ff5c: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED 4000ff60: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000ff64: 22 bf ff ee be,a 4000ff1c <== NOT EXECUTED 4000ff68: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n", 4000ff6c: 40 00 3d 4d call 4001f4a0 <== NOT EXECUTED 4000ff70: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 4000ff74: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4000ff78: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 4000ff7c: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED 4000ff80: 40 00 0d 02 call 40013388 <__wrap_printf> <== NOT EXECUTED 4000ff84: 90 12 21 90 or %o0, 0x190, %o0 ! 40022190 <== NOT EXECUTED rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size); 4000ff88: 10 bf ff e5 b 4000ff1c <== NOT EXECUTED 4000ff8c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 4000ff90: 40 00 0c 70 call 40013150 <== NOT EXECUTED 4000ff94: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED 4000ff98: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000ff9c: 02 bf ff da be 4000ff04 <== NOT EXECUTED 4000ffa0: 01 00 00 00 nop <== NOT EXECUTED printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n", 4000ffa4: 40 00 3d 3f call 4001f4a0 <== NOT EXECUTED 4000ffa8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 4000ffac: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4000ffb0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 4000ffb4: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED 4000ffb8: 40 00 0c f4 call 40013388 <__wrap_printf> <== NOT EXECUTED 4000ffbc: 90 12 21 50 or %o0, 0x150, %o0 ! 40022150 <== NOT EXECUTED 4000ffc0: 30 bf ff d1 b,a 4000ff04 <== NOT EXECUTED printf ("rtems-rfs: buffer-setblksize: block size: %" PRIu32 "\n", size); 4000ffc4: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED 4000ffc8: 40 00 0c f0 call 40013388 <__wrap_printf> <== NOT EXECUTED 4000ffcc: 90 12 21 20 or %o0, 0x120, %o0 ! 40022120 <== NOT EXECUTED 4000ffd0: 30 bf ff c8 b,a 4000fef0 <== NOT EXECUTED =============================================================================== 4000fda8 : { 4000fda8: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC)) 4000fdac: 90 10 20 00 clr %o0 4000fdb0: 92 10 20 20 mov 0x20, %o1 4000fdb4: 40 00 0c e7 call 40013150 4000fdb8: ba 10 00 18 mov %i0, %i5 4000fdbc: 80 a2 20 00 cmp %o0, 0 4000fdc0: 12 80 00 1d bne 4000fe34 <== NEVER TAKEN 4000fdc4: 11 10 00 88 sethi %hi(0x40022000), %o0 sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs)); 4000fdc8: 40 00 17 83 call 40015bd4 4000fdcc: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 int result = 0; 4000fdd0: b0 10 20 00 clr %i0 if (sc != RTEMS_SUCCESSFUL) 4000fdd4: 80 a2 20 00 cmp %o0, 0 4000fdd8: 12 80 00 06 bne 4000fdf0 <== NEVER TAKEN 4000fddc: b8 10 00 08 mov %o0, %i4 rtems_disk_release (fs->disk); 4000fde0: 7f ff d3 18 call 40004a40 4000fde4: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 } 4000fde8: 81 c7 e0 08 ret 4000fdec: 81 e8 00 00 restore if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC)) 4000fdf0: 90 10 20 00 clr %o0 <== NOT EXECUTED 4000fdf4: 92 10 20 20 mov 0x20, %o1 <== NOT EXECUTED 4000fdf8: 40 00 0c d6 call 40013150 <== NOT EXECUTED 4000fdfc: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 4000fe00: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4000fe04: 02 bf ff f7 be 4000fde0 <== NOT EXECUTED 4000fe08: 01 00 00 00 nop <== NOT EXECUTED printf ("rtems-rfs: buffer-sync: device sync failed: %s\n", 4000fe0c: 40 00 1e 2a call 400176b4 <== NOT EXECUTED 4000fe10: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED 4000fe14: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED 4000fe18: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED 4000fe1c: 40 00 0d 5b call 40013388 <__wrap_printf> <== NOT EXECUTED 4000fe20: 90 12 20 a0 or %o0, 0xa0, %o0 ! 400220a0 <== NOT EXECUTED rtems_disk_release (fs->disk); 4000fe24: 7f ff d3 07 call 40004a40 <== NOT EXECUTED 4000fe28: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED } 4000fe2c: 81 c7 e0 08 ret <== NOT EXECUTED 4000fe30: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: buffer-sync: syncing\n"); 4000fe34: 40 00 0d 64 call 400133c4 <__wrap_puts> <== NOT EXECUTED 4000fe38: 90 12 20 80 or %o0, 0x80, %o0 <== NOT EXECUTED 4000fe3c: 30 bf ff e3 b,a 4000fdc8 <== NOT EXECUTED =============================================================================== 4000fe40 : int rtems_rfs_buffers_release (rtems_rfs_file_system* fs) { 4000fe40: 9d e3 bf a0 save %sp, -96, %sp int rrc = 0; int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE)) 4000fe44: 90 10 20 00 clr %o0 4000fe48: 92 10 20 40 mov 0x40, %o1 4000fe4c: 40 00 0c c1 call 40013150 4000fe50: ba 10 00 18 mov %i0, %i5 4000fe54: 80 a2 20 00 cmp %o0, 0 4000fe58: 32 80 00 17 bne,a 4000feb4 <== NEVER TAKEN 4000fe5c: d6 06 20 70 ld [ %i0 + 0x70 ], %o3 <== NOT EXECUTED printf ("rtems-rfs: buffers-release: active:%" PRIu32 " " "release:%" PRIu32 " release-modified:%" PRIu32 "\n", fs->buffers_count, fs->release_count, fs->release_modified_count); rc = rtems_rfs_release_chain (&fs->release, 4000fe60: 94 10 20 00 clr %o2 4000fe64: 92 07 60 60 add %i5, 0x60, %o1 4000fe68: 7f ff fd e1 call 4000f5ec 4000fe6c: 90 07 60 54 add %i5, 0x54, %o0 4000fe70: 92 07 60 70 add %i5, 0x70, %o1 4000fe74: b0 10 00 08 mov %o0, %i0 &fs->release_count, false); if ((rc > 0) && (rrc == 0)) rrc = rc; rc = rtems_rfs_release_chain (&fs->release_modified, 4000fe78: 94 10 20 01 mov 1, %o2 if ((rc > 0) && (rrc == 0)) 4000fe7c: 80 a6 20 00 cmp %i0, 0 4000fe80: 04 80 00 06 ble 4000fe98 <== ALWAYS TAKEN 4000fe84: 90 07 60 64 add %i5, 0x64, %o0 rc = rtems_rfs_release_chain (&fs->release_modified, 4000fe88: 7f ff fd d9 call 4000f5ec <== NOT EXECUTED 4000fe8c: 01 00 00 00 nop <== NOT EXECUTED true); if ((rc > 0) && (rrc == 0)) rrc = rc; return rrc; } 4000fe90: 81 c7 e0 08 ret <== NOT EXECUTED 4000fe94: 81 e8 00 00 restore <== NOT EXECUTED rc = rtems_rfs_release_chain (&fs->release_modified, 4000fe98: 7f ff fd d5 call 4000f5ec 4000fe9c: 01 00 00 00 nop 4000fea0: 82 38 00 08 xnor %g0, %o0, %g1 4000fea4: 83 38 60 1f sra %g1, 0x1f, %g1 4000fea8: b0 0a 00 01 and %o0, %g1, %i0 4000feac: 81 c7 e0 08 ret 4000feb0: 81 e8 00 00 restore printf ("rtems-rfs: buffers-release: active:%" PRIu32 " " 4000feb4: d4 06 20 60 ld [ %i0 + 0x60 ], %o2 <== NOT EXECUTED 4000feb8: d2 06 20 50 ld [ %i0 + 0x50 ], %o1 <== NOT EXECUTED 4000febc: 11 10 00 88 sethi %hi(0x40022000), %o0 <== NOT EXECUTED 4000fec0: 40 00 0d 32 call 40013388 <__wrap_printf> <== NOT EXECUTED 4000fec4: 90 12 20 d0 or %o0, 0xd0, %o0 ! 400220d0 <== NOT EXECUTED rc = rtems_rfs_release_chain (&fs->release, 4000fec8: 10 bf ff e7 b 4000fe64 <== NOT EXECUTED 4000fecc: 94 10 20 00 clr %o2 <== NOT EXECUTED =============================================================================== 4001a38c : rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir, const char* name, size_t length, rtems_rfs_ino ino) { 4001a38c: 9d e3 bf 30 save %sp, -208, %sp rtems_rfs_block_map map; rtems_rfs_block_pos bpos; rtems_rfs_buffer_handle buffer; int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) 4001a390: 90 10 20 00 clr %o0 4001a394: 7f ff e3 6f call 40013150 4001a398: 13 08 00 00 sethi %hi(0x20000000), %o1 4001a39c: 80 a2 20 00 cmp %o0, 0 4001a3a0: 12 80 00 3e bne 4001a498 <== NEVER TAKEN 4001a3a4: 92 10 00 19 mov %i1, %o1 for (c = 0; c < length; c++) printf ("%c", name[c]); printf (", len=%zd\n", length); } rc = rtems_rfs_block_map_open (fs, dir, &map); 4001a3a8: 94 07 bf b0 add %fp, -80, %o2 4001a3ac: 7f ff fb 55 call 40019100 4001a3b0: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001a3b4: a0 92 20 00 orcc %o0, 0, %l0 4001a3b8: 24 80 00 04 ble,a 4001a3c8 <== ALWAYS TAKEN 4001a3bc: c0 2f bf a4 clrb [ %fp + -92 ] } rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_block_map_close (fs, &map); return rc; } 4001a3c0: 81 c7 e0 08 ret 4001a3c4: 91 e8 00 10 restore %g0, %l0, %o0 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001a3c8: 27 00 00 3f sethi %hi(0xfc00), %l3 handle->bnum = 0; 4001a3cc: c0 27 bf a8 clr [ %fp + -88 ] 4001a3d0: a6 14 e3 ff or %l3, 0x3ff, %l3 handle->buffer = NULL; 4001a3d4: c0 27 bf ac clr [ %fp + -84 ] if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) < 4001a3d8: a4 06 e0 0a add %i3, 0xa, %l2 bpos->bno = 0; 4001a3dc: c0 27 bf 98 clr [ %fp + -104 ] bpos->boff = 0; 4001a3e0: c0 27 bf 9c clr [ %fp + -100 ] bpos->block = 0; 4001a3e4: c0 27 bf a0 clr [ %fp + -96 ] rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block); 4001a3e8: 96 07 bf 94 add %fp, -108, %o3 4001a3ec: 94 07 bf 98 add %fp, -104, %o2 4001a3f0: 92 07 bf b0 add %fp, -80, %o1 4001a3f4: 7f ff fc 15 call 40019448 4001a3f8: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001a3fc: a0 92 20 00 orcc %o0, 0, %l0 4001a400: 04 80 00 88 ble 4001a620 4001a404: 80 a4 20 06 cmp %l0, 6 if (rc != ENXIO) 4001a408: 12 80 00 d9 bne 4001a76c <== NEVER TAKEN 4001a40c: 96 07 bf 94 add %fp, -108, %o3 rc = rtems_rfs_block_map_grow (fs, &map, 1, &block); 4001a410: 94 10 20 01 mov 1, %o2 4001a414: 92 07 bf b0 add %fp, -80, %o1 4001a418: 7f ff fc 90 call 40019658 4001a41c: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001a420: a0 92 20 00 orcc %o0, 0, %l0 4001a424: 14 80 00 c1 bg 4001a728 <== NEVER TAKEN 4001a428: c2 07 bf 98 ld [ %fp + -104 ], %g1 bpos.bno++; 4001a42c: 82 00 60 01 inc %g1 rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read); 4001a430: d4 07 bf 94 ld [ %fp + -108 ], %o2 4001a434: 96 10 20 00 clr %o3 bpos.bno++; 4001a438: c2 27 bf 98 st %g1, [ %fp + -104 ] rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read); 4001a43c: 92 07 bf a4 add %fp, -92, %o1 4001a440: 7f ff d5 22 call 4000f8c8 4001a444: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001a448: a0 92 20 00 orcc %o0, 0, %l0 4001a44c: 04 80 00 27 ble 4001a4e8 <== ALWAYS TAKEN 4001a450: c2 07 bf ac ld [ %fp + -84 ], %g1 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) 4001a454: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001a458: 7f ff e3 3e call 40013150 <== NOT EXECUTED 4001a45c: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED 4001a460: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001a464: 32 80 00 a7 bne,a 4001a700 <== NOT EXECUTED 4001a468: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001a46c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED 4001a470: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001a474: 7f ff d5 dc call 4000fbe4 4001a478: 01 00 00 00 nop rtems_rfs_block_map_close (fs, &map); 4001a47c: 92 07 bf b0 add %fp, -80, %o1 handle->dirty = false; 4001a480: c0 2f bf a4 clrb [ %fp + -92 ] 4001a484: 90 10 00 18 mov %i0, %o0 handle->bnum = 0; 4001a488: c0 27 bf a8 clr [ %fp + -88 ] 4001a48c: 7f ff fb 7c call 4001927c 4001a490: c0 27 bf ac clr [ %fp + -84 ] return rc; 4001a494: 30 bf ff cb b,a 4001a3c0 printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=", 4001a498: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001a49c: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 4001a4a0: 7f ff e3 ba call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a4a4: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 400239e0 <== NOT EXECUTED for (c = 0; c < length; c++) 4001a4a8: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 4001a4ac: 02 80 00 09 be 4001a4d0 <== NOT EXECUTED 4001a4b0: a0 06 c0 1a add %i3, %i2, %l0 <== NOT EXECUTED 4001a4b4: ba 10 00 1a mov %i2, %i5 <== NOT EXECUTED printf ("%c", name[c]); 4001a4b8: 7f ff e3 c9 call 400133dc <__wrap_putchar> <== NOT EXECUTED 4001a4bc: d0 4f 40 00 ldsb [ %i5 ], %o0 <== NOT EXECUTED 4001a4c0: ba 07 60 01 inc %i5 <== NOT EXECUTED for (c = 0; c < length; c++) 4001a4c4: 80 a4 00 1d cmp %l0, %i5 <== NOT EXECUTED 4001a4c8: 12 bf ff fc bne 4001a4b8 <== NOT EXECUTED 4001a4cc: 01 00 00 00 nop <== NOT EXECUTED printf (", len=%zd\n", length); 4001a4d0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 4001a4d4: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 4001a4d8: 7f ff e3 ac call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a4dc: 90 12 22 10 or %o0, 0x210, %o0 ! 40023a10 <== NOT EXECUTED rc = rtems_rfs_block_map_open (fs, dir, &map); 4001a4e0: 10 bf ff b2 b 4001a3a8 <== NOT EXECUTED 4001a4e4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED entry = rtems_rfs_buffer_data (&buffer); 4001a4e8: fa 00 60 1c ld [ %g1 + 0x1c ], %i5 memset (entry, 0xff, rtems_rfs_fs_block_size (fs)); 4001a4ec: d4 06 20 08 ld [ %i0 + 8 ], %o2 4001a4f0: 92 10 20 ff mov 0xff, %o1 4001a4f4: 40 00 10 ce call 4001e82c 4001a4f8: 90 10 00 1d mov %i5, %o0 while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 4001a4fc: c8 06 20 08 ld [ %i0 + 8 ], %g4 4001a500: 86 81 3f f6 addcc %g4, -10, %g3 4001a504: 02 bf ff ba be 4001a3ec <== NEVER TAKEN 4001a508: 96 07 bf 94 add %fp, -108, %o3 elength = rtems_rfs_dir_entry_length (entry); 4001a50c: d4 0f 60 08 ldub [ %i5 + 8 ], %o2 4001a510: e0 0f 60 09 ldub [ %i5 + 9 ], %l0 eino = rtems_rfs_dir_entry_ino (entry); 4001a514: c4 0f 40 00 ldub [ %i5 ], %g2 4001a518: c2 0f 60 01 ldub [ %i5 + 1 ], %g1 4001a51c: e2 0f 60 02 ldub [ %i5 + 2 ], %l1 4001a520: d6 0f 60 03 ldub [ %i5 + 3 ], %o3 elength = rtems_rfs_dir_entry_length (entry); 4001a524: 95 2a a0 08 sll %o2, 8, %o2 eino = rtems_rfs_dir_entry_ino (entry); 4001a528: 85 28 a0 18 sll %g2, 0x18, %g2 elength = rtems_rfs_dir_entry_length (entry); 4001a52c: a0 14 00 0a or %l0, %o2, %l0 eino = rtems_rfs_dir_entry_ino (entry); 4001a530: 83 28 60 10 sll %g1, 0x10, %g1 4001a534: a3 2c 60 08 sll %l1, 8, %l1 4001a538: 82 10 40 02 or %g1, %g2, %g1 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001a53c: 80 a4 00 13 cmp %l0, %l3 eino = rtems_rfs_dir_entry_ino (entry); 4001a540: a2 14 40 01 or %l1, %g1, %l1 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001a544: 02 80 00 4d be 4001a678 4001a548: a2 12 c0 11 or %o3, %l1, %l1 offset = 0; 4001a54c: 10 80 00 1f b 4001a5c8 4001a550: a8 10 20 00 clr %l4 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 4001a554: 80 a0 40 10 cmp %g1, %l0 4001a558: 08 80 00 1f bleu 4001a5d4 <== NEVER TAKEN 4001a55c: 80 a4 60 00 cmp %l1, 0 4001a560: 02 80 00 1e be 4001a5d8 <== NEVER TAKEN 4001a564: 90 10 20 00 clr %o0 4001a568: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 4001a56c: 80 a0 40 11 cmp %g1, %l1 4001a570: 0a 80 00 1a bcs 4001a5d8 <== NEVER TAKEN 4001a574: 01 00 00 00 nop offset += elength; 4001a578: a8 05 00 10 add %l4, %l0, %l4 while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 4001a57c: 80 a0 c0 14 cmp %g3, %l4 4001a580: 08 bf ff 9a bleu 4001a3e8 <== NEVER TAKEN 4001a584: ba 07 40 10 add %i5, %l0, %i5 elength = rtems_rfs_dir_entry_length (entry); 4001a588: d4 0f 60 08 ldub [ %i5 + 8 ], %o2 4001a58c: e0 0f 60 09 ldub [ %i5 + 9 ], %l0 eino = rtems_rfs_dir_entry_ino (entry); 4001a590: c4 0f 40 00 ldub [ %i5 ], %g2 4001a594: c2 0f 60 01 ldub [ %i5 + 1 ], %g1 4001a598: d6 0f 60 02 ldub [ %i5 + 2 ], %o3 4001a59c: e2 0f 60 03 ldub [ %i5 + 3 ], %l1 elength = rtems_rfs_dir_entry_length (entry); 4001a5a0: 95 2a a0 08 sll %o2, 8, %o2 eino = rtems_rfs_dir_entry_ino (entry); 4001a5a4: 85 28 a0 18 sll %g2, 0x18, %g2 elength = rtems_rfs_dir_entry_length (entry); 4001a5a8: a0 14 00 0a or %l0, %o2, %l0 eino = rtems_rfs_dir_entry_ino (entry); 4001a5ac: 83 28 60 10 sll %g1, 0x10, %g1 4001a5b0: 97 2a e0 08 sll %o3, 8, %o3 4001a5b4: 82 10 40 02 or %g1, %g2, %g1 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001a5b8: 80 a4 00 13 cmp %l0, %l3 eino = rtems_rfs_dir_entry_ino (entry); 4001a5bc: 96 12 c0 01 or %o3, %g1, %o3 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001a5c0: 02 80 00 2d be 4001a674 4001a5c4: a2 14 40 0b or %l1, %o3, %l1 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 4001a5c8: 80 a4 20 0a cmp %l0, 0xa 4001a5cc: 34 bf ff e2 bg,a 4001a554 <== ALWAYS TAKEN 4001a5d0: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) 4001a5d4: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001a5d8: 7f ff e2 de call 40013150 <== NOT EXECUTED 4001a5dc: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED 4001a5e0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001a5e4: 32 80 00 1c bne,a 4001a654 <== NOT EXECUTED 4001a5e8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001a5ec: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED 4001a5f0: 7f ff d5 7d call 4000fbe4 <== NOT EXECUTED 4001a5f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED rtems_rfs_block_map_close (fs, &map); 4001a5f8: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED handle->dirty = false; 4001a5fc: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED 4001a600: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED handle->bnum = 0; 4001a604: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED return EIO; 4001a608: a0 10 20 05 mov 5, %l0 <== NOT EXECUTED handle->buffer = NULL; 4001a60c: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED rtems_rfs_block_map_close (fs, &map); 4001a610: 7f ff fb 1b call 4001927c <== NOT EXECUTED 4001a614: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED } 4001a618: 81 c7 e0 08 ret <== NOT EXECUTED 4001a61c: 81 e8 00 00 restore <== NOT EXECUTED bpos.bno++; 4001a620: c2 07 bf 98 ld [ %fp + -104 ], %g1 4001a624: 82 00 60 01 inc %g1 rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read); 4001a628: d4 07 bf 94 ld [ %fp + -108 ], %o2 4001a62c: 96 10 20 01 mov 1, %o3 bpos.bno++; 4001a630: c2 27 bf 98 st %g1, [ %fp + -104 ] rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read); 4001a634: 92 07 bf a4 add %fp, -92, %o1 4001a638: 7f ff d4 a4 call 4000f8c8 4001a63c: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001a640: a0 92 20 00 orcc %o0, 0, %l0 4001a644: 14 bf ff 84 bg 4001a454 <== NEVER TAKEN 4001a648: c2 07 bf ac ld [ %fp + -84 ], %g1 entry = rtems_rfs_buffer_data (&buffer); 4001a64c: 10 bf ff ac b 4001a4fc 4001a650: fa 00 60 1c ld [ %g1 + 0x1c ], %i5 printf ("rtems-rfs: dir-add-entry: " 4001a654: 98 10 00 14 mov %l4, %o4 <== NOT EXECUTED 4001a658: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED 4001a65c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED 4001a660: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 4001a664: 7f ff e3 49 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a668: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 40023af8 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001a66c: 10 bf ff e1 b 4001a5f0 <== NOT EXECUTED 4001a670: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED 4001a674: 88 21 00 14 sub %g4, %l4, %g4 if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) < 4001a678: 80 a4 80 04 cmp %l2, %g4 4001a67c: 1a bf ff 5c bcc 4001a3ec <== NEVER TAKEN 4001a680: 96 07 bf 94 add %fp, -108, %o3 hash = rtems_rfs_dir_hash (name, length); 4001a684: 92 10 00 1b mov %i3, %o1 4001a688: 40 00 0f 0c call 4001e2b8 4001a68c: 90 10 00 1a mov %i2, %o0 rtems_rfs_dir_set_entry_hash (entry, hash); 4001a690: 87 32 20 18 srl %o0, 0x18, %g3 4001a694: 85 32 20 10 srl %o0, 0x10, %g2 4001a698: 83 32 20 08 srl %o0, 8, %g1 rtems_rfs_dir_set_entry_ino (entry, ino); 4001a69c: 89 37 20 18 srl %i4, 0x18, %g4 rtems_rfs_dir_set_entry_hash (entry, hash); 4001a6a0: c6 2f 60 04 stb %g3, [ %i5 + 4 ] rtems_rfs_dir_set_entry_ino (entry, ino); 4001a6a4: 87 37 20 10 srl %i4, 0x10, %g3 rtems_rfs_dir_set_entry_hash (entry, hash); 4001a6a8: c4 2f 60 05 stb %g2, [ %i5 + 5 ] rtems_rfs_dir_set_entry_ino (entry, ino); 4001a6ac: 85 37 20 08 srl %i4, 8, %g2 rtems_rfs_dir_set_entry_hash (entry, hash); 4001a6b0: c2 2f 60 06 stb %g1, [ %i5 + 6 ] rtems_rfs_dir_set_entry_length (entry, 4001a6b4: 83 2c a0 10 sll %l2, 0x10, %g1 rtems_rfs_dir_set_entry_hash (entry, hash); 4001a6b8: d0 2f 60 07 stb %o0, [ %i5 + 7 ] rtems_rfs_dir_set_entry_length (entry, 4001a6bc: 83 30 60 18 srl %g1, 0x18, %g1 rtems_rfs_dir_set_entry_ino (entry, ino); 4001a6c0: c8 2f 40 00 stb %g4, [ %i5 ] memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length); 4001a6c4: 92 10 00 1a mov %i2, %o1 rtems_rfs_dir_set_entry_length (entry, 4001a6c8: c2 2f 60 08 stb %g1, [ %i5 + 8 ] memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length); 4001a6cc: 94 10 00 1b mov %i3, %o2 rtems_rfs_dir_set_entry_ino (entry, ino); 4001a6d0: c6 2f 60 01 stb %g3, [ %i5 + 1 ] memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length); 4001a6d4: 90 07 60 0a add %i5, 0xa, %o0 rtems_rfs_dir_set_entry_ino (entry, ino); 4001a6d8: c4 2f 60 02 stb %g2, [ %i5 + 2 ] return 0; 4001a6dc: a0 10 20 00 clr %l0 rtems_rfs_dir_set_entry_ino (entry, ino); 4001a6e0: f8 2f 60 03 stb %i4, [ %i5 + 3 ] memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length); 4001a6e4: 40 00 0f c8 call 4001e604 4001a6e8: e4 2f 60 09 stb %l2, [ %i5 + 9 ] rtems_rfs_buffer_mark_dirty (&buffer); 4001a6ec: 82 10 20 01 mov 1, %g1 4001a6f0: 92 07 bf a4 add %fp, -92, %o1 4001a6f4: 90 10 00 18 mov %i0, %o0 4001a6f8: 10 bf ff 5f b 4001a474 4001a6fc: c2 2f bf a4 stb %g1, [ %fp + -92 ] printf ("rtems-rfs: dir-add-entry: " 4001a700: 40 00 13 68 call 4001f4a0 <== NOT EXECUTED 4001a704: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 4001a708: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED 4001a70c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001a710: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001a714: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 4001a718: 7f ff e3 1c call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a71c: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 40023ab0 <== NOT EXECUTED 4001a720: 10 bf ff 54 b 4001a470 <== NOT EXECUTED 4001a724: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) 4001a728: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001a72c: 7f ff e2 89 call 40013150 <== NOT EXECUTED 4001a730: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED 4001a734: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001a738: 22 bf ff 4e be,a 4001a470 <== NOT EXECUTED 4001a73c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-add-entry: " 4001a740: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED 4001a744: 40 00 13 57 call 4001f4a0 <== NOT EXECUTED 4001a748: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 4001a74c: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED 4001a750: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001a754: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001a758: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 4001a75c: 7f ff e3 0b call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a760: 90 12 22 68 or %o0, 0x268, %o0 ! 40023a68 <== NOT EXECUTED 4001a764: 10 bf ff 43 b 4001a470 <== NOT EXECUTED 4001a768: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) 4001a76c: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001a770: 7f ff e2 78 call 40013150 <== NOT EXECUTED 4001a774: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED 4001a778: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001a77c: 22 bf ff 3d be,a 4001a470 <== NOT EXECUTED 4001a780: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-add-entry: " 4001a784: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED 4001a788: 40 00 13 46 call 4001f4a0 <== NOT EXECUTED 4001a78c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 4001a790: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED 4001a794: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001a798: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001a79c: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 4001a7a0: 7f ff e2 fa call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a7a4: 90 12 22 20 or %o0, 0x220, %o0 ! 40023a20 <== NOT EXECUTED 4001a7a8: 10 bf ff 32 b 4001a470 <== NOT EXECUTED 4001a7ac: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED =============================================================================== 4001a7b0 : int rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir, rtems_rfs_ino ino, uint32_t offset) { 4001a7b0: 9d e3 bf 40 save %sp, -192, %sp rtems_rfs_block_no block; rtems_rfs_buffer_handle buffer; bool search; int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) 4001a7b4: 90 10 20 00 clr %o0 4001a7b8: 7f ff e2 66 call 40013150 4001a7bc: 13 10 00 00 sethi %hi(0x40000000), %o1 4001a7c0: 80 a2 20 00 cmp %o0, 0 4001a7c4: 12 80 00 0a bne 4001a7ec <== NEVER TAKEN 4001a7c8: 92 10 00 19 mov %i1, %o1 printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n", rtems_rfs_inode_ino (dir), ino, offset); rc = rtems_rfs_block_map_open (fs, dir, &map); 4001a7cc: 94 07 bf b0 add %fp, -80, %o2 4001a7d0: 7f ff fa 4c call 40019100 4001a7d4: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001a7d8: a4 92 20 00 orcc %o0, 0, %l2 4001a7dc: 04 80 00 11 ble 4001a820 <== ALWAYS TAKEN 4001a7e0: 94 10 20 00 clr %o2 } rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_block_map_close (fs, &map); return rc; } 4001a7e4: 81 c7 e0 08 ret 4001a7e8: 91 e8 00 12 restore %g0, %l2, %o0 printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n", 4001a7ec: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001a7f0: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED 4001a7f4: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 4001a7f8: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 4001a7fc: 7f ff e2 e3 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a800: 90 12 23 40 or %o0, 0x340, %o0 ! 40023b40 <== NOT EXECUTED rc = rtems_rfs_block_map_open (fs, dir, &map); 4001a804: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4001a808: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED 4001a80c: 7f ff fa 3d call 40019100 <== NOT EXECUTED 4001a810: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 4001a814: a4 92 20 00 orcc %o0, 0, %l2 <== NOT EXECUTED 4001a818: 14 bf ff f3 bg 4001a7e4 <== NOT EXECUTED 4001a81c: 94 10 20 00 clr %o2 <== NOT EXECUTED rc = rtems_rfs_block_map_seek (fs, &map, offset, &block); 4001a820: 98 07 bf a0 add %fp, -96, %o4 4001a824: 96 10 00 1b mov %i3, %o3 4001a828: 92 07 bf b0 add %fp, -80, %o1 4001a82c: 7f ff fb 60 call 400195ac 4001a830: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001a834: a4 92 20 00 orcc %o0, 0, %l2 4001a838: 04 80 00 0a ble 4001a860 <== ALWAYS TAKEN 4001a83c: 80 a4 a0 06 cmp %l2, 6 if (rc == ENXIO) 4001a840: 22 80 00 02 be,a 4001a848 <== NOT EXECUTED 4001a844: a4 10 20 02 mov 2, %l2 <== NOT EXECUTED rtems_rfs_block_map_close (fs, &map); 4001a848: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 4001a84c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001a850: 7f ff fa 8b call 4001927c <== NOT EXECUTED 4001a854: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED } 4001a858: 81 c7 e0 08 ret <== NOT EXECUTED 4001a85c: 81 e8 00 00 restore <== NOT EXECUTED handle->dirty = false; 4001a860: c0 2f bf a4 clrb [ %fp + -92 ] if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001a864: 27 00 00 3f sethi %hi(0xfc00), %l3 handle->bnum = 0; 4001a868: c0 27 bf a8 clr [ %fp + -88 ] 4001a86c: a6 14 e3 ff or %l3, 0x3ff, %l3 handle->buffer = NULL; 4001a870: c0 27 bf ac clr [ %fp + -84 ] rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true); 4001a874: 96 10 20 01 mov 1, %o3 4001a878: d4 07 bf a0 ld [ %fp + -96 ], %o2 4001a87c: 92 07 bf a4 add %fp, -92, %o1 4001a880: 7f ff d4 12 call 4000f8c8 4001a884: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001a888: a4 92 20 00 orcc %o0, 0, %l2 4001a88c: 14 80 00 c5 bg 4001aba0 <== NEVER TAKEN 4001a890: 80 a6 e0 00 cmp %i3, 0 if (search) 4001a894: 02 80 00 46 be 4001a9ac <== NEVER TAKEN 4001a898: c8 06 20 08 ld [ %i0 + 8 ], %g4 eoffset = offset % rtems_rfs_fs_block_size (fs); 4001a89c: 81 80 20 00 wr %g0, %y 4001a8a0: 01 00 00 00 nop 4001a8a4: 01 00 00 00 nop 4001a8a8: 01 00 00 00 nop 4001a8ac: 82 76 c0 04 udiv %i3, %g4, %g1 4001a8b0: 82 58 40 04 smul %g1, %g4, %g1 4001a8b4: 82 26 c0 01 sub %i3, %g1, %g1 4001a8b8: a2 10 00 01 mov %g1, %l1 entry = rtems_rfs_buffer_data (&buffer) + eoffset; 4001a8bc: c4 07 bf ac ld [ %fp + -84 ], %g2 4001a8c0: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 4001a8c4: 9e 01 3f f6 add %g4, -10, %o7 4001a8c8: 80 a3 c0 01 cmp %o7, %g1 4001a8cc: 08 80 00 2b bleu 4001a978 <== NEVER TAKEN 4001a8d0: ba 00 80 01 add %g2, %g1, %i5 elength = rtems_rfs_dir_entry_length (entry); 4001a8d4: c6 0f 60 08 ldub [ %i5 + 8 ], %g3 4001a8d8: f8 0f 60 09 ldub [ %i5 + 9 ], %i4 eino = rtems_rfs_dir_entry_ino (entry); 4001a8dc: 10 80 00 1a b 4001a944 4001a8e0: c4 08 80 01 ldub [ %g2 + %g1 ], %g2 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 4001a8e4: 80 a7 20 0a cmp %i4, 0xa 4001a8e8: 04 80 00 34 ble 4001a9b8 <== NEVER TAKEN 4001a8ec: 90 10 20 00 clr %o0 4001a8f0: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 4001a8f4: 80 a0 40 1c cmp %g1, %i4 4001a8f8: 08 80 00 30 bleu 4001a9b8 <== NEVER TAKEN 4001a8fc: 80 a4 20 00 cmp %l0, 0 4001a900: 02 80 00 2f be 4001a9bc <== NEVER TAKEN 4001a904: 13 10 00 00 sethi %hi(0x40000000), %o1 4001a908: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 4001a90c: 80 a0 40 10 cmp %g1, %l0 4001a910: 0a 80 00 2a bcs 4001a9b8 <== NEVER TAKEN 4001a914: 80 a6 80 10 cmp %i2, %l0 if (ino == rtems_rfs_dir_entry_ino (entry)) 4001a918: 02 80 00 43 be 4001aa24 <== ALWAYS TAKEN 4001a91c: 80 a6 e0 00 cmp %i3, 0 if (!search) 4001a920: 32 80 00 19 bne,a 4001a984 <== NOT EXECUTED 4001a924: a4 10 20 05 mov 5, %l2 <== NOT EXECUTED eoffset += elength; 4001a928: a2 04 40 1c add %l1, %i4, %l1 <== NOT EXECUTED while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 4001a92c: 80 a4 40 0f cmp %l1, %o7 <== NOT EXECUTED 4001a930: 1a 80 00 12 bcc 4001a978 <== NOT EXECUTED 4001a934: ba 07 40 1c add %i5, %i4, %i5 <== NOT EXECUTED elength = rtems_rfs_dir_entry_length (entry); 4001a938: c6 0f 60 08 ldub [ %i5 + 8 ], %g3 <== NOT EXECUTED 4001a93c: f8 0f 60 09 ldub [ %i5 + 9 ], %i4 <== NOT EXECUTED eino = rtems_rfs_dir_entry_ino (entry); 4001a940: c4 0f 40 00 ldub [ %i5 ], %g2 <== NOT EXECUTED 4001a944: c2 0f 60 01 ldub [ %i5 + 1 ], %g1 4001a948: d6 0f 60 02 ldub [ %i5 + 2 ], %o3 4001a94c: e0 0f 60 03 ldub [ %i5 + 3 ], %l0 elength = rtems_rfs_dir_entry_length (entry); 4001a950: 87 28 e0 08 sll %g3, 8, %g3 eino = rtems_rfs_dir_entry_ino (entry); 4001a954: 85 28 a0 18 sll %g2, 0x18, %g2 elength = rtems_rfs_dir_entry_length (entry); 4001a958: b8 17 00 03 or %i4, %g3, %i4 eino = rtems_rfs_dir_entry_ino (entry); 4001a95c: 83 28 60 10 sll %g1, 0x10, %g1 4001a960: 97 2a e0 08 sll %o3, 8, %o3 4001a964: 82 10 40 02 or %g1, %g2, %g1 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001a968: 80 a7 00 13 cmp %i4, %l3 eino = rtems_rfs_dir_entry_ino (entry); 4001a96c: 96 12 c0 01 or %o3, %g1, %o3 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001a970: 12 bf ff dd bne 4001a8e4 <== ALWAYS TAKEN 4001a974: a0 14 00 0b or %l0, %o3, %l0 if (rc == 0) 4001a978: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED 4001a97c: 02 80 00 1f be 4001a9f8 <== NOT EXECUTED 4001a980: 94 07 bf a0 add %fp, -96, %o2 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001a984: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED 4001a988: 7f ff d4 97 call 4000fbe4 <== NOT EXECUTED 4001a98c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED rtems_rfs_block_map_close (fs, &map); 4001a990: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED handle->dirty = false; 4001a994: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED 4001a998: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED handle->bnum = 0; 4001a99c: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED 4001a9a0: 7f ff fa 37 call 4001927c <== NOT EXECUTED 4001a9a4: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED return rc; 4001a9a8: 30 bf ff 8f b,a 4001a7e4 <== NOT EXECUTED 4001a9ac: 82 10 20 00 clr %g1 <== NOT EXECUTED eoffset = 0; 4001a9b0: 10 bf ff c3 b 4001a8bc <== NOT EXECUTED 4001a9b4: a2 10 20 00 clr %l1 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) 4001a9b8: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED 4001a9bc: 7f ff e1 e5 call 40013150 <== NOT EXECUTED 4001a9c0: a4 10 20 05 mov 5, %l2 <== NOT EXECUTED 4001a9c4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001a9c8: 22 bf ff f0 be,a 4001a988 <== NOT EXECUTED 4001a9cc: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-del-entry: " 4001a9d0: d8 07 bf a0 ld [ %fp + -96 ], %o4 <== NOT EXECUTED 4001a9d4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001a9d8: 9a 10 00 11 mov %l1, %o5 <== NOT EXECUTED 4001a9dc: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED 4001a9e0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED 4001a9e4: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 4001a9e8: 7f ff e2 68 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a9ec: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 40023bc8 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001a9f0: 10 bf ff e6 b 4001a988 <== NOT EXECUTED 4001a9f4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED rc = rtems_rfs_block_map_next_block (fs, &map, &block); 4001a9f8: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 4001a9fc: 7f ff fb 0a call 40019624 <== NOT EXECUTED 4001aa00: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc == ENXIO) 4001aa04: 80 a2 20 06 cmp %o0, 6 <== NOT EXECUTED 4001aa08: 02 80 00 77 be 4001abe4 <== NOT EXECUTED 4001aa0c: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED while (rc == 0) 4001aa10: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001aa14: 02 bf ff 99 be 4001a878 <== NOT EXECUTED 4001aa18: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED 4001aa1c: 10 bf ff db b 4001a988 <== NOT EXECUTED 4001aa20: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED memmove (entry, entry + elength, remaining); 4001aa24: 92 07 40 1c add %i5, %i4, %o1 4001aa28: 90 10 00 1d mov %i5, %o0 remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength); 4001aa2c: b6 04 40 1c add %l1, %i4, %i3 4001aa30: b6 21 00 1b sub %g4, %i3, %i3 memmove (entry, entry + elength, remaining); 4001aa34: 40 00 0f 30 call 4001e6f4 4001aa38: 94 10 00 1b mov %i3, %o2 memset (entry + remaining, 0xff, elength); 4001aa3c: 94 10 00 1c mov %i4, %o2 4001aa40: 92 10 20 ff mov 0xff, %o1 4001aa44: 40 00 0f 7a call 4001e82c 4001aa48: 90 07 40 1b add %i5, %i3, %o0 elength = rtems_rfs_dir_entry_length (entry); 4001aa4c: c2 0f 60 08 ldub [ %i5 + 8 ], %g1 4001aa50: 83 28 60 08 sll %g1, 8, %g1 4001aa54: fa 0f 60 09 ldub [ %i5 + 9 ], %i5 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) 4001aa58: 90 10 20 00 clr %o0 4001aa5c: 13 10 00 00 sethi %hi(0x40000000), %o1 4001aa60: 7f ff e1 bc call 40013150 4001aa64: ba 17 40 01 or %i5, %g1, %i5 4001aa68: 80 a2 20 00 cmp %o0, 0 4001aa6c: 22 80 00 17 be,a 4001aac8 <== ALWAYS TAKEN 4001aa70: 03 3f ff c0 sethi %hi(0xffff0000), %g1 rtems_rfs_block_map_last (&map) ? "yes" : "no"); 4001aa74: c4 07 bf c0 ld [ %fp + -64 ], %g2 <== NOT EXECUTED printf ("rtems-rfs: dir-del-entry: " 4001aa78: d6 07 bf a0 ld [ %fp + -96 ], %o3 <== NOT EXECUTED 4001aa7c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001aa80: 12 80 00 05 bne 4001aa94 <== NOT EXECUTED 4001aa84: c2 07 bf b8 ld [ %fp + -72 ], %g1 <== NOT EXECUTED rtems_rfs_block_map_last (&map) ? "yes" : "no"); 4001aa88: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001aa8c: 02 80 00 3d be 4001ab80 <== NOT EXECUTED 4001aa90: 1b 10 00 8b sethi %hi(0x40022c00), %o5 <== NOT EXECUTED 4001aa94: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001aa98: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 4001aa9c: 02 80 00 39 be 4001ab80 <== NOT EXECUTED 4001aaa0: 1b 10 00 8b sethi %hi(0x40022c00), %o5 <== NOT EXECUTED printf ("rtems-rfs: dir-del-entry: " 4001aaa4: 1b 10 00 8b sethi %hi(0x40022c00), %o5 <== NOT EXECUTED 4001aaa8: 9a 13 60 a0 or %o5, 0xa0, %o5 ! 40022ca0 <== NOT EXECUTED 4001aaac: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 4001aab0: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED 4001aab4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 4001aab8: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4001aabc: 7f ff e2 33 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001aac0: 90 12 20 18 or %o0, 0x18, %o0 <== NOT EXECUTED if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) && 4001aac4: 03 3f ff c0 sethi %hi(0xffff0000), %g1 <== NOT EXECUTED 4001aac8: ba 38 40 1d xnor %g1, %i5, %i5 4001aacc: 80 a7 60 00 cmp %i5, 0 4001aad0: 12 80 00 1f bne 4001ab4c 4001aad4: 80 a4 60 00 cmp %l1, 0 4001aad8: 12 80 00 1d bne 4001ab4c <== ALWAYS TAKEN 4001aadc: c4 07 bf c0 ld [ %fp + -64 ], %g2 (eoffset == 0) && rtems_rfs_block_map_last (&map)) 4001aae0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001aae4: 12 80 00 29 bne 4001ab88 <== NOT EXECUTED 4001aae8: c2 07 bf b8 ld [ %fp + -72 ], %g1 <== NOT EXECUTED 4001aaec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001aaf0: 12 80 00 27 bne 4001ab8c <== NOT EXECUTED 4001aaf4: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED rc = rtems_rfs_block_map_shrink (fs, &map, 1); 4001aaf8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED 4001aafc: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 4001ab00: 7f ff fb d3 call 40019a4c <== NOT EXECUTED 4001ab04: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 4001ab08: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED 4001ab0c: 04 80 00 10 ble 4001ab4c <== NOT EXECUTED 4001ab10: 90 10 20 00 clr %o0 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) 4001ab14: 7f ff e1 8f call 40013150 <== NOT EXECUTED 4001ab18: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED 4001ab1c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001ab20: 02 80 00 0c be 4001ab50 <== NOT EXECUTED 4001ab24: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED printf ("rtems-rfs: dir-del-entry: " 4001ab28: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED 4001ab2c: 40 00 12 5d call 4001f4a0 <== NOT EXECUTED 4001ab30: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 4001ab34: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 4001ab38: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001ab3c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED 4001ab40: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 4001ab44: 7f ff e2 11 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001ab48: 90 12 20 78 or %o0, 0x78, %o0 ! 40023c78 <== NOT EXECUTED rtems_rfs_buffer_mark_dirty (&buffer); 4001ab4c: 82 10 20 01 mov 1, %g1 4001ab50: 92 07 bf a4 add %fp, -92, %o1 4001ab54: 90 10 00 18 mov %i0, %o0 4001ab58: 7f ff d4 23 call 4000fbe4 4001ab5c: c2 2f bf a4 stb %g1, [ %fp + -92 ] rtems_rfs_block_map_close (fs, &map); 4001ab60: 92 07 bf b0 add %fp, -80, %o1 handle->dirty = false; 4001ab64: c0 2f bf a4 clrb [ %fp + -92 ] 4001ab68: 90 10 00 18 mov %i0, %o0 handle->bnum = 0; 4001ab6c: c0 27 bf a8 clr [ %fp + -88 ] return 0; 4001ab70: a4 10 20 00 clr %l2 rtems_rfs_block_map_close (fs, &map); 4001ab74: 7f ff f9 c2 call 4001927c 4001ab78: c0 27 bf ac clr [ %fp + -84 ] return 0; 4001ab7c: 30 bf ff 1a b,a 4001a7e4 printf ("rtems-rfs: dir-del-entry: " 4001ab80: 10 bf ff cb b 4001aaac <== NOT EXECUTED 4001ab84: 9a 13 60 98 or %o5, 0x98, %o5 <== NOT EXECUTED (eoffset == 0) && rtems_rfs_block_map_last (&map)) 4001ab88: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001ab8c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 4001ab90: 12 bf ff f0 bne 4001ab50 <== NOT EXECUTED 4001ab94: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 4001ab98: 10 bf ff d9 b 4001aafc <== NOT EXECUTED 4001ab9c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) 4001aba0: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001aba4: 7f ff e1 6b call 40013150 <== NOT EXECUTED 4001aba8: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED 4001abac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001abb0: 22 bf ff 76 be,a 4001a988 <== NOT EXECUTED 4001abb4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-del-entry: " 4001abb8: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED 4001abbc: 40 00 12 39 call 4001f4a0 <== NOT EXECUTED 4001abc0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4001abc4: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED 4001abc8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001abcc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001abd0: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 4001abd4: 7f ff e1 ed call 40013388 <__wrap_printf> <== NOT EXECUTED 4001abd8: 90 12 23 80 or %o0, 0x380, %o0 ! 40023b80 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001abdc: 10 bf ff 6b b 4001a988 <== NOT EXECUTED 4001abe0: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED rc = ENOENT; 4001abe4: 10 bf ff 68 b 4001a984 <== NOT EXECUTED 4001abe8: a4 10 20 02 mov 2, %l2 <== NOT EXECUTED =============================================================================== 4001afac : int rtems_rfs_dir_empty (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir) { 4001afac: 9d e3 bf 40 save %sp, -192, %sp rtems_rfs_buffer_handle buffer; rtems_rfs_block_no block; bool empty; int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) 4001afb0: 90 10 20 00 clr %o0 4001afb4: 7f ff e0 67 call 40013150 4001afb8: 13 20 00 00 sethi %hi(0x80000000), %o1 4001afbc: 80 a2 20 00 cmp %o0, 0 4001afc0: 12 80 00 0a bne 4001afe8 <== NEVER TAKEN 4001afc4: 92 10 00 19 mov %i1, %o1 printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir)); empty = true; rc = rtems_rfs_block_map_open (fs, dir, &map); 4001afc8: 94 07 bf b0 add %fp, -80, %o2 4001afcc: 7f ff f8 4d call 40019100 4001afd0: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001afd4: a4 92 20 00 orcc %o0, 0, %l2 4001afd8: 04 80 00 0f ble 4001b014 <== ALWAYS TAKEN 4001afdc: 94 10 20 00 clr %o2 rc = ENOTEMPTY; rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_block_map_close (fs, &map); return rc; } 4001afe0: 81 c7 e0 08 ret <== NOT EXECUTED 4001afe4: 91 e8 00 12 restore %g0, %l2, %o0 <== NOT EXECUTED printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir)); 4001afe8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001afec: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 4001aff0: 7f ff e0 e6 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001aff4: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 40023da8 <== NOT EXECUTED rc = rtems_rfs_block_map_open (fs, dir, &map); 4001aff8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4001affc: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED 4001b000: 7f ff f8 40 call 40019100 <== NOT EXECUTED 4001b004: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 4001b008: a4 92 20 00 orcc %o0, 0, %l2 <== NOT EXECUTED 4001b00c: 14 bf ff f5 bg 4001afe0 <== NOT EXECUTED 4001b010: 94 10 20 00 clr %o2 <== NOT EXECUTED rc = rtems_rfs_block_map_seek (fs, &map, 0, &block); 4001b014: 96 10 20 00 clr %o3 4001b018: 98 07 bf a0 add %fp, -96, %o4 4001b01c: 92 07 bf b0 add %fp, -80, %o1 4001b020: 7f ff f9 63 call 400195ac 4001b024: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001b028: a4 92 20 00 orcc %o0, 0, %l2 4001b02c: 14 80 00 67 bg 4001b1c8 <== NEVER TAKEN 4001b030: 23 00 00 3f sethi %hi(0xfc00), %l1 handle->dirty = false; 4001b034: c0 2f bf a4 clrb [ %fp + -92 ] handle->bnum = 0; 4001b038: c0 27 bf a8 clr [ %fp + -88 ] printf ("rtems-rfs: dir-empty: " 4001b03c: 21 10 00 8f sethi %hi(0x40023c00), %l0 handle->buffer = NULL; 4001b040: c0 27 bf ac clr [ %fp + -84 ] if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001b044: a2 14 63 ff or %l1, 0x3ff, %l1 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY)) 4001b048: b4 10 20 01 mov 1, %i2 4001b04c: b6 10 20 00 clr %i3 printf ("rtems-rfs: dir-empty: " 4001b050: a0 14 21 c8 or %l0, 0x1c8, %l0 rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true); 4001b054: d4 07 bf a0 ld [ %fp + -96 ], %o2 4001b058: 96 10 20 01 mov 1, %o3 4001b05c: 92 07 bf a4 add %fp, -92, %o1 4001b060: 7f ff d2 1a call 4000f8c8 4001b064: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001b068: a4 92 20 00 orcc %o0, 0, %l2 4001b06c: 14 80 00 4b bg 4001b198 <== NEVER TAKEN 4001b070: c2 07 bf ac ld [ %fp + -84 ], %g1 while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 4001b074: c8 06 20 08 ld [ %i0 + 8 ], %g4 4001b078: 88 81 3f f6 addcc %g4, -10, %g4 4001b07c: 02 80 00 63 be 4001b208 <== NEVER TAKEN 4001b080: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 elength = rtems_rfs_dir_entry_length (entry); 4001b084: d4 08 60 08 ldub [ %g1 + 8 ], %o2 4001b088: fa 08 60 09 ldub [ %g1 + 9 ], %i5 eino = rtems_rfs_dir_entry_ino (entry); 4001b08c: c6 08 40 00 ldub [ %g1 ], %g3 4001b090: c4 08 60 01 ldub [ %g1 + 1 ], %g2 4001b094: f8 08 60 02 ldub [ %g1 + 2 ], %i4 4001b098: d6 08 60 03 ldub [ %g1 + 3 ], %o3 elength = rtems_rfs_dir_entry_length (entry); 4001b09c: 95 2a a0 08 sll %o2, 8, %o2 eino = rtems_rfs_dir_entry_ino (entry); 4001b0a0: 87 28 e0 18 sll %g3, 0x18, %g3 elength = rtems_rfs_dir_entry_length (entry); 4001b0a4: ba 17 40 0a or %i5, %o2, %i5 eino = rtems_rfs_dir_entry_ino (entry); 4001b0a8: 85 28 a0 10 sll %g2, 0x10, %g2 4001b0ac: b9 2f 20 08 sll %i4, 8, %i4 4001b0b0: 84 10 80 03 or %g2, %g3, %g2 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001b0b4: 80 a7 40 11 cmp %i5, %l1 eino = rtems_rfs_dir_entry_ino (entry); 4001b0b8: b8 17 00 02 or %i4, %g2, %i4 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001b0bc: 02 80 00 53 be 4001b208 <== NEVER TAKEN 4001b0c0: b8 12 c0 1c or %o3, %i4, %i4 offset = 0; 4001b0c4: 10 80 00 20 b 4001b144 4001b0c8: a6 10 20 00 clr %l3 (entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) && 4001b0cc: 12 80 00 31 bne 4001b190 4001b0d0: 80 a4 a0 00 cmp %l2, 0 ((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) || 4001b0d4: c4 08 60 0a ldub [ %g1 + 0xa ], %g2 4001b0d8: 80 a0 a0 2e cmp %g2, 0x2e 4001b0dc: 12 80 00 2d bne 4001b190 <== NEVER TAKEN 4001b0e0: 80 a4 a0 00 cmp %l2, 0 (entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') || 4001b0e4: c4 08 60 0b ldub [ %g1 + 0xb ], %g2 4001b0e8: 80 a0 a0 2e cmp %g2, 0x2e 4001b0ec: 12 80 00 29 bne 4001b190 <== NEVER TAKEN 4001b0f0: 80 a4 a0 00 cmp %l2, 0 offset += elength; 4001b0f4: a6 04 c0 1d add %l3, %i5, %l3 while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 4001b0f8: 80 a4 c0 04 cmp %l3, %g4 4001b0fc: 1a 80 00 43 bcc 4001b208 <== NEVER TAKEN 4001b100: 82 00 40 1d add %g1, %i5, %g1 elength = rtems_rfs_dir_entry_length (entry); 4001b104: d4 08 60 08 ldub [ %g1 + 8 ], %o2 4001b108: fa 08 60 09 ldub [ %g1 + 9 ], %i5 eino = rtems_rfs_dir_entry_ino (entry); 4001b10c: c6 08 40 00 ldub [ %g1 ], %g3 4001b110: c4 08 60 01 ldub [ %g1 + 1 ], %g2 4001b114: d6 08 60 02 ldub [ %g1 + 2 ], %o3 4001b118: f8 08 60 03 ldub [ %g1 + 3 ], %i4 elength = rtems_rfs_dir_entry_length (entry); 4001b11c: 95 2a a0 08 sll %o2, 8, %o2 eino = rtems_rfs_dir_entry_ino (entry); 4001b120: 87 28 e0 18 sll %g3, 0x18, %g3 elength = rtems_rfs_dir_entry_length (entry); 4001b124: ba 17 40 0a or %i5, %o2, %i5 eino = rtems_rfs_dir_entry_ino (entry); 4001b128: 85 28 a0 10 sll %g2, 0x10, %g2 4001b12c: 97 2a e0 08 sll %o3, 8, %o3 4001b130: 84 10 80 03 or %g2, %g3, %g2 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001b134: 80 a7 40 11 cmp %i5, %l1 eino = rtems_rfs_dir_entry_ino (entry); 4001b138: 96 12 c0 02 or %o3, %g2, %o3 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001b13c: 02 80 00 33 be 4001b208 4001b140: b8 17 00 0b or %i4, %o3, %i4 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 4001b144: 80 a7 60 0a cmp %i5, 0xa 4001b148: 04 80 00 26 ble 4001b1e0 <== NEVER TAKEN 4001b14c: 90 10 00 1a mov %i2, %o0 4001b150: c4 06 20 1c ld [ %i0 + 0x1c ], %g2 4001b154: 80 a0 80 1d cmp %g2, %i5 4001b158: 08 80 00 22 bleu 4001b1e0 <== NEVER TAKEN 4001b15c: 80 a7 20 00 cmp %i4, 0 4001b160: 02 80 00 20 be 4001b1e0 <== NEVER TAKEN 4001b164: 01 00 00 00 nop 4001b168: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 4001b16c: 80 a0 80 1c cmp %g2, %i4 4001b170: 0a 80 00 1c bcs 4001b1e0 <== NEVER TAKEN 4001b174: 80 a7 60 0b cmp %i5, 0xb if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) || 4001b178: 12 bf ff d5 bne 4001b0cc 4001b17c: 80 a7 60 0c cmp %i5, 0xc 4001b180: c4 08 60 0a ldub [ %g1 + 0xa ], %g2 4001b184: 80 a0 a0 2e cmp %g2, 0x2e 4001b188: 02 bf ff db be 4001b0f4 <== ALWAYS TAKEN 4001b18c: 80 a4 a0 00 cmp %l2, 0 if ((rc == 0) && !empty) 4001b190: 22 80 00 02 be,a 4001b198 <== ALWAYS TAKEN 4001b194: a4 10 20 5a mov 0x5a, %l2 rtems_rfs_buffer_handle_release (fs, handle); 4001b198: 92 07 bf a4 add %fp, -92, %o1 4001b19c: 7f ff d2 92 call 4000fbe4 4001b1a0: 90 10 00 18 mov %i0, %o0 rtems_rfs_block_map_close (fs, &map); 4001b1a4: 92 07 bf b0 add %fp, -80, %o1 handle->dirty = false; 4001b1a8: c0 2f bf a4 clrb [ %fp + -92 ] 4001b1ac: 90 10 00 18 mov %i0, %o0 handle->bnum = 0; 4001b1b0: c0 27 bf a8 clr [ %fp + -88 ] } 4001b1b4: b0 10 00 12 mov %l2, %i0 rtems_rfs_block_map_close (fs, &map); 4001b1b8: 7f ff f8 31 call 4001927c 4001b1bc: c0 27 bf ac clr [ %fp + -84 ] } 4001b1c0: 81 c7 e0 08 ret 4001b1c4: 81 e8 00 00 restore rtems_rfs_block_map_close (fs, &map); 4001b1c8: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 4001b1cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001b1d0: 7f ff f8 2b call 4001927c <== NOT EXECUTED 4001b1d4: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED } 4001b1d8: 81 c7 e0 08 ret <== NOT EXECUTED 4001b1dc: 81 e8 00 00 restore <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY)) 4001b1e0: 7f ff df dc call 40013150 <== NOT EXECUTED 4001b1e4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 4001b1e8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001b1ec: 02 80 00 07 be 4001b208 <== NOT EXECUTED 4001b1f0: 98 10 00 13 mov %l3, %o4 <== NOT EXECUTED printf ("rtems-rfs: dir-empty: " 4001b1f4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001b1f8: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED 4001b1fc: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 4001b200: 7f ff e0 62 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001b204: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rc = rtems_rfs_block_map_next_block (fs, &map, &block); 4001b208: 94 07 bf a0 add %fp, -96, %o2 4001b20c: 92 07 bf b0 add %fp, -80, %o1 4001b210: 7f ff f9 05 call 40019624 4001b214: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001b218: a4 92 20 00 orcc %o0, 0, %l2 4001b21c: 04 bf ff 8f ble 4001b058 <== NEVER TAKEN 4001b220: d4 07 bf a0 ld [ %fp + -96 ], %o2 rc = 0; 4001b224: 82 1c a0 06 xor %l2, 6, %g1 4001b228: 80 a0 00 01 cmp %g0, %g1 4001b22c: 82 60 20 00 subx %g0, 0, %g1 4001b230: 10 bf ff da b 4001b198 4001b234: a4 0c 80 01 and %l2, %g1, %l2 =============================================================================== 4001e2b8 : */ #define initval (20010928) uint32_t rtems_rfs_dir_hash (const void *key, size_t length) { 4001e2b8: 9d e3 bf a0 save %sp, -96, %sp 4001e2bc: 82 10 00 18 mov %i0, %g1 uint32_t a,b,c; /* internal state */ union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */ /* Set up the internal state */ a = b = c = 0xdeadbeef + ((uint32_t)length) + initval; 4001e2c0: 31 37 f7 c5 sethi %hi(0xdfdf1400), %i0 4001e2c4: b0 16 22 9f or %i0, 0x29f, %i0 ! dfdf169f } else { /* need to read the key one byte at a time */ const uint8_t *k = (const uint8_t *)key; /*--------------- all but the last block: affect some 32 bits of (a,b,c) */ while (length > 12) 4001e2c8: 80 a6 60 0c cmp %i1, 0xc a = b = c = 0xdeadbeef + ((uint32_t)length) + initval; 4001e2cc: b6 06 40 18 add %i1, %i0, %i3 4001e2d0: b0 10 00 1b mov %i3, %i0 while (length > 12) 4001e2d4: 08 80 00 4b bleu 4001e400 4001e2d8: b8 10 00 1b mov %i3, %i4 a += k[0]; a += ((uint32_t)k[1])<<8; a += ((uint32_t)k[2])<<16; a += ((uint32_t)k[3])<<24; b += k[4]; b += ((uint32_t)k[5])<<8; 4001e2dc: fa 08 60 05 ldub [ %g1 + 5 ], %i5 b += ((uint32_t)k[6])<<16; 4001e2e0: c4 08 60 06 ldub [ %g1 + 6 ], %g2 b += ((uint32_t)k[7])<<24; c += k[8]; c += ((uint32_t)k[9])<<8; c += ((uint32_t)k[10])<<16; 4001e2e4: d6 08 60 0a ldub [ %g1 + 0xa ], %o3 b += ((uint32_t)k[5])<<8; 4001e2e8: bb 2f 60 08 sll %i5, 8, %i5 c += ((uint32_t)k[9])<<8; 4001e2ec: c6 08 60 09 ldub [ %g1 + 9 ], %g3 c += ((uint32_t)k[11])<<24; 4001e2f0: d8 08 60 0b ldub [ %g1 + 0xb ], %o4 b += ((uint32_t)k[6])<<16; 4001e2f4: 85 28 a0 10 sll %g2, 0x10, %g2 b += ((uint32_t)k[7])<<24; 4001e2f8: 84 07 40 02 add %i5, %g2, %g2 c += ((uint32_t)k[10])<<16; 4001e2fc: bb 2a e0 10 sll %o3, 0x10, %i5 c += k[8]; 4001e300: d2 08 60 08 ldub [ %g1 + 8 ], %o1 a += ((uint32_t)k[2])<<16; 4001e304: de 08 60 02 ldub [ %g1 + 2 ], %o7 c += ((uint32_t)k[9])<<8; 4001e308: 87 28 e0 08 sll %g3, 8, %g3 c += ((uint32_t)k[11])<<24; 4001e30c: 86 00 c0 1d add %g3, %i5, %g3 4001e310: bb 2b 20 18 sll %o4, 0x18, %i5 a += ((uint32_t)k[1])<<8; 4001e314: c8 08 60 01 ldub [ %g1 + 1 ], %g4 a += ((uint32_t)k[3])<<24; 4001e318: f4 08 60 03 ldub [ %g1 + 3 ], %i2 c += ((uint32_t)k[11])<<24; 4001e31c: 86 00 c0 09 add %g3, %o1, %g3 4001e320: 86 00 c0 1d add %g3, %i5, %g3 a += ((uint32_t)k[2])<<16; 4001e324: bb 2b e0 10 sll %o7, 0x10, %i5 c += ((uint32_t)k[11])<<24; 4001e328: b0 00 c0 18 add %g3, %i0, %i0 a += k[0]; 4001e32c: da 08 40 00 ldub [ %g1 ], %o5 a += ((uint32_t)k[1])<<8; 4001e330: 89 29 20 08 sll %g4, 8, %g4 mix(a,b,c); 4001e334: 86 01 00 1d add %g4, %i5, %g3 a += ((uint32_t)k[3])<<24; 4001e338: bb 2e a0 18 sll %i2, 0x18, %i5 b += k[4]; 4001e33c: d0 08 60 04 ldub [ %g1 + 4 ], %o0 b += ((uint32_t)k[7])<<24; 4001e340: d4 08 60 07 ldub [ %g1 + 7 ], %o2 mix(a,b,c); 4001e344: 89 2e 20 04 sll %i0, 4, %g4 4001e348: 86 00 c0 0d add %g3, %o5, %g3 4001e34c: 86 00 c0 1d add %g3, %i5, %g3 4001e350: bb 36 20 1c srl %i0, 0x1c, %i5 4001e354: 88 11 00 1d or %g4, %i5, %g4 b += ((uint32_t)k[7])<<24; 4001e358: 95 2a a0 18 sll %o2, 0x18, %o2 4001e35c: 84 00 80 08 add %g2, %o0, %g2 4001e360: 84 00 80 0a add %g2, %o2, %g2 4001e364: 84 00 80 1c add %g2, %i4, %g2 mix(a,b,c); 4001e368: b8 06 00 02 add %i0, %g2, %i4 4001e36c: b0 20 c0 18 sub %g3, %i0, %i0 4001e370: b0 06 00 1b add %i0, %i3, %i0 4001e374: b0 19 00 18 xor %g4, %i0, %i0 4001e378: b6 06 00 1c add %i0, %i4, %i3 4001e37c: 89 2e 20 06 sll %i0, 6, %g4 4001e380: 84 20 80 18 sub %g2, %i0, %g2 4001e384: b1 36 20 1a srl %i0, 0x1a, %i0 4001e388: b0 11 00 18 or %g4, %i0, %i0 4001e38c: 84 1e 00 02 xor %i0, %g2, %g2 4001e390: ba 00 80 1b add %g2, %i3, %i5 4001e394: b8 27 00 02 sub %i4, %g2, %i4 4001e398: 87 28 a0 08 sll %g2, 8, %g3 4001e39c: 85 30 a0 18 srl %g2, 0x18, %g2 4001e3a0: 86 10 c0 02 or %g3, %g2, %g3 4001e3a4: 86 18 c0 1c xor %g3, %i4, %g3 4001e3a8: 88 00 c0 1d add %g3, %i5, %g4 4001e3ac: b6 26 c0 03 sub %i3, %g3, %i3 4001e3b0: b1 28 e0 10 sll %g3, 0x10, %i0 4001e3b4: 87 30 e0 10 srl %g3, 0x10, %g3 4001e3b8: 86 16 00 03 or %i0, %g3, %g3 4001e3bc: b0 18 c0 1b xor %g3, %i3, %i0 4001e3c0: 87 2e 20 13 sll %i0, 0x13, %g3 4001e3c4: b6 06 00 04 add %i0, %g4, %i3 4001e3c8: ba 27 40 18 sub %i5, %i0, %i5 4001e3cc: 85 36 20 0d srl %i0, 0xd, %g2 length -= 12; 4001e3d0: b2 06 7f f4 add %i1, -12, %i1 mix(a,b,c); 4001e3d4: 84 10 80 03 or %g2, %g3, %g2 k += 12; 4001e3d8: 82 00 60 0c add %g1, 0xc, %g1 mix(a,b,c); 4001e3dc: 84 18 80 1d xor %g2, %i5, %g2 while (length > 12) 4001e3e0: 80 a6 60 0c cmp %i1, 0xc mix(a,b,c); 4001e3e4: 88 21 00 02 sub %g4, %g2, %g4 4001e3e8: b1 28 a0 04 sll %g2, 4, %i0 4001e3ec: 87 30 a0 1c srl %g2, 0x1c, %g3 4001e3f0: b8 00 80 1b add %g2, %i3, %i4 4001e3f4: b0 16 00 03 or %i0, %g3, %i0 while (length > 12) 4001e3f8: 18 bf ff b9 bgu 4001e2dc <== NEVER TAKEN 4001e3fc: b0 1e 00 04 xor %i0, %g4, %i0 } /*-------------------------------- last block: affect all 32 bits of (c) */ switch(length) /* all the case statements fall through */ 4001e400: b3 2e 60 02 sll %i1, 2, %i1 4001e404: 05 10 00 78 sethi %hi(0x4001e000), %g2 4001e408: 84 10 a2 84 or %g2, 0x284, %g2 ! 4001e284 <_Objects_API_maximum_class+0x28> 4001e40c: c4 00 80 19 ld [ %g2 + %i1 ], %g2 4001e410: 81 c0 80 00 jmp %g2 4001e414: 01 00 00 00 nop { case 12: c+=((uint32_t)k[11])<<24; 4001e418: c4 08 60 0b ldub [ %g1 + 0xb ], %g2 4001e41c: 85 28 a0 18 sll %g2, 0x18, %g2 4001e420: b0 06 00 02 add %i0, %g2, %i0 case 11: c+=((uint32_t)k[10])<<16; 4001e424: c4 08 60 0a ldub [ %g1 + 0xa ], %g2 4001e428: 85 28 a0 10 sll %g2, 0x10, %g2 4001e42c: b0 06 00 02 add %i0, %g2, %i0 case 10: c+=((uint32_t)k[9])<<8; 4001e430: c4 08 60 09 ldub [ %g1 + 9 ], %g2 4001e434: 85 28 a0 08 sll %g2, 8, %g2 4001e438: b0 06 00 02 add %i0, %g2, %i0 case 9 : c+=k[8]; 4001e43c: c4 08 60 08 ldub [ %g1 + 8 ], %g2 4001e440: b0 06 00 02 add %i0, %g2, %i0 case 8 : b+=((uint32_t)k[7])<<24; 4001e444: c4 08 60 07 ldub [ %g1 + 7 ], %g2 4001e448: 85 28 a0 18 sll %g2, 0x18, %g2 4001e44c: b8 07 00 02 add %i4, %g2, %i4 case 7 : b+=((uint32_t)k[6])<<16; 4001e450: c4 08 60 06 ldub [ %g1 + 6 ], %g2 4001e454: 85 28 a0 10 sll %g2, 0x10, %g2 4001e458: b8 07 00 02 add %i4, %g2, %i4 case 6 : b+=((uint32_t)k[5])<<8; 4001e45c: c4 08 60 05 ldub [ %g1 + 5 ], %g2 4001e460: 85 28 a0 08 sll %g2, 8, %g2 4001e464: b8 07 00 02 add %i4, %g2, %i4 case 5 : b+=k[4]; 4001e468: c4 08 60 04 ldub [ %g1 + 4 ], %g2 4001e46c: b8 07 00 02 add %i4, %g2, %i4 case 4 : a+=((uint32_t)k[3])<<24; 4001e470: c4 08 60 03 ldub [ %g1 + 3 ], %g2 4001e474: 85 28 a0 18 sll %g2, 0x18, %g2 4001e478: b6 06 c0 02 add %i3, %g2, %i3 case 3 : a+=((uint32_t)k[2])<<16; 4001e47c: c4 08 60 02 ldub [ %g1 + 2 ], %g2 4001e480: 85 28 a0 10 sll %g2, 0x10, %g2 4001e484: b6 06 c0 02 add %i3, %g2, %i3 case 2 : a+=((uint32_t)k[1])<<8; 4001e488: c4 08 60 01 ldub [ %g1 + 1 ], %g2 4001e48c: 85 28 a0 08 sll %g2, 8, %g2 4001e490: b6 06 c0 02 add %i3, %g2, %i3 case 1 : a+=k[0]; 4001e494: c2 08 40 00 ldub [ %g1 ], %g1 break; case 0 : return c; } } final(a,b,c); 4001e498: 85 37 20 12 srl %i4, 0x12, %g2 case 1 : a+=k[0]; 4001e49c: b6 00 40 1b add %g1, %i3, %i3 final(a,b,c); 4001e4a0: 83 2f 20 0e sll %i4, 0xe, %g1 4001e4a4: 82 10 40 02 or %g1, %g2, %g1 4001e4a8: b0 1f 00 18 xor %i4, %i0, %i0 4001e4ac: b0 26 00 01 sub %i0, %g1, %i0 4001e4b0: 85 36 20 15 srl %i0, 0x15, %g2 4001e4b4: 83 2e 20 0b sll %i0, 0xb, %g1 4001e4b8: 82 10 40 02 or %g1, %g2, %g1 4001e4bc: b6 1e c0 18 xor %i3, %i0, %i3 4001e4c0: b6 26 c0 01 sub %i3, %g1, %i3 4001e4c4: 83 2e e0 19 sll %i3, 0x19, %g1 4001e4c8: 84 1f 00 1b xor %i4, %i3, %g2 4001e4cc: b9 36 e0 07 srl %i3, 7, %i4 4001e4d0: b8 17 00 01 or %i4, %g1, %i4 4001e4d4: 84 20 80 1c sub %g2, %i4, %g2 4001e4d8: 87 30 a0 10 srl %g2, 0x10, %g3 4001e4dc: 83 28 a0 10 sll %g2, 0x10, %g1 4001e4e0: 82 10 40 03 or %g1, %g3, %g1 4001e4e4: b0 1e 00 02 xor %i0, %g2, %i0 4001e4e8: b0 26 00 01 sub %i0, %g1, %i0 4001e4ec: 83 2e 20 04 sll %i0, 4, %g1 4001e4f0: 87 36 20 1c srl %i0, 0x1c, %g3 4001e4f4: 82 10 40 03 or %g1, %g3, %g1 4001e4f8: b6 1e 00 1b xor %i0, %i3, %i3 4001e4fc: b6 26 c0 01 sub %i3, %g1, %i3 4001e500: 83 2e e0 0e sll %i3, 0xe, %g1 4001e504: 84 1e c0 02 xor %i3, %g2, %g2 4001e508: b7 36 e0 12 srl %i3, 0x12, %i3 4001e50c: b6 10 40 1b or %g1, %i3, %i3 4001e510: 84 20 80 1b sub %g2, %i3, %g2 4001e514: b0 18 80 18 xor %g2, %i0, %i0 4001e518: 83 30 a0 08 srl %g2, 8, %g1 4001e51c: 85 28 a0 18 sll %g2, 0x18, %g2 4001e520: 84 10 40 02 or %g1, %g2, %g2 4001e524: b0 26 00 02 sub %i0, %g2, %i0 return c; } 4001e528: 81 c7 e0 08 ret 4001e52c: 81 e8 00 00 restore =============================================================================== 40019e4c : rtems_rfs_inode_handle* inode, const char* name, int length, rtems_rfs_ino* ino, uint32_t* offset) { 40019e4c: 9d e3 bf 38 save %sp, -200, %sp rtems_rfs_block_map map; rtems_rfs_buffer_handle entries; int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 40019e50: 90 10 20 00 clr %o0 40019e54: 7f ff e4 bf call 40013150 40019e58: 13 01 00 00 sethi %hi(0x4000000), %o1 40019e5c: 80 a2 20 00 cmp %o0, 0 40019e60: 32 80 00 ad bne,a 4001a114 <== NEVER TAKEN 40019e64: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED for (c = 0; c < length; c++) printf ("%c", name[c]); printf (", len=%d\n", length); } *ino = RTEMS_RFS_EMPTY_INO; 40019e68: c0 27 00 00 clr [ %i4 ] *offset = 0; rc = rtems_rfs_block_map_open (fs, inode, &map); 40019e6c: 94 07 bf b0 add %fp, -80, %o2 *offset = 0; 40019e70: c0 27 40 00 clr [ %i5 ] rc = rtems_rfs_block_map_open (fs, inode, &map); 40019e74: 92 10 00 19 mov %i1, %o1 40019e78: 7f ff fc a2 call 40019100 40019e7c: 90 10 00 18 mov %i0, %o0 if (rc > 0) 40019e80: a6 92 20 00 orcc %o0, 0, %l3 40019e84: 24 80 00 15 ble,a 40019ed8 <== ALWAYS TAKEN 40019e88: 92 10 00 1b mov %i3, %o1 { if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 40019e8c: 90 10 20 00 clr %o0 <== NOT EXECUTED 40019e90: 7f ff e4 b0 call 40013150 <== NOT EXECUTED 40019e94: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 40019e98: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40019e9c: 32 80 00 04 bne,a 40019eac <== NOT EXECUTED 40019ea0: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED } rtems_rfs_buffer_handle_close (fs, &entries); rtems_rfs_block_map_close (fs, &map); return rc; } 40019ea4: 81 c7 e0 08 ret 40019ea8: 91 e8 00 13 restore %g0, %l3, %o0 printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s", 40019eac: 40 00 15 7d call 4001f4a0 <== NOT EXECUTED 40019eb0: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED 40019eb4: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED 40019eb8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 40019ebc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 40019ec0: 11 10 00 8d sethi %hi(0x40023400), %o0 <== NOT EXECUTED } 40019ec4: b0 10 00 13 mov %l3, %i0 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s", 40019ec8: 7f ff e5 30 call 40013388 <__wrap_printf> <== NOT EXECUTED 40019ecc: 90 12 23 58 or %o0, 0x358, %o0 <== NOT EXECUTED } 40019ed0: 81 c7 e0 08 ret <== NOT EXECUTED 40019ed4: 81 e8 00 00 restore <== NOT EXECUTED handle->dirty = false; 40019ed8: c0 2f bf a4 clrb [ %fp + -92 ] hash = rtems_rfs_dir_hash (name, length); 40019edc: 90 10 00 1a mov %i2, %o0 handle->bnum = 0; 40019ee0: c0 27 bf a8 clr [ %fp + -88 ] 40019ee4: 40 00 10 f5 call 4001e2b8 40019ee8: c0 27 bf ac clr [ %fp + -84 ] rc = rtems_rfs_block_map_seek (fs, &map, 0, &block); 40019eec: 98 07 bf a0 add %fp, -96, %o4 hash = rtems_rfs_dir_hash (name, length); 40019ef0: a4 10 00 08 mov %o0, %l2 rc = rtems_rfs_block_map_seek (fs, &map, 0, &block); 40019ef4: 94 10 20 00 clr %o2 40019ef8: 96 10 20 00 clr %o3 40019efc: 92 07 bf b0 add %fp, -80, %o1 40019f00: 7f ff fd ab call 400195ac 40019f04: 90 10 00 18 mov %i0, %o0 if (rc > 0) 40019f08: a6 92 20 00 orcc %o0, 0, %l3 40019f0c: 14 80 00 95 bg 4001a160 <== NEVER TAKEN 40019f10: 2f 10 00 8d sethi %hi(0x40023400), %l7 printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n", 40019f14: 82 15 e3 d8 or %l7, 0x3d8, %g1 ! 400237d8 40019f18: c2 27 bf 9c st %g1, [ %fp + -100 ] printf ("rtems-rfs: dir-lookup-ino: " 40019f1c: 03 10 00 8e sethi %hi(0x40023800), %g1 40019f20: 82 10 61 50 or %g1, 0x150, %g1 ! 40023950 40019f24: c2 27 bf 98 st %g1, [ %fp + -104 ] if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 40019f28: 23 00 00 3f sethi %hi(0xfc00), %l1 printf ("rtems-rfs: dir-lookup-ino: " 40019f2c: 2d 10 00 8e sethi %hi(0x40023800), %l6 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 40019f30: a2 14 63 ff or %l1, 0x3ff, %l1 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 40019f34: a8 10 20 00 clr %l4 40019f38: 2b 02 00 00 sethi %hi(0x8000000), %l5 printf ("rtems-rfs: dir-lookup-ino: " 40019f3c: ac 15 a0 a8 or %l6, 0xa8, %l6 while ((rc == 0) && block) 40019f40: 80 a4 e0 00 cmp %l3, 0 40019f44: 12 80 00 90 bne 4001a184 <== NEVER TAKEN 40019f48: c2 07 bf a0 ld [ %fp + -96 ], %g1 40019f4c: 80 a0 60 00 cmp %g1, 0 40019f50: 02 80 00 fe be 4001a348 <== NEVER TAKEN 40019f54: 90 10 20 00 clr %o0 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 40019f58: 7f ff e4 7e call 40013150 40019f5c: 13 01 00 00 sethi %hi(0x4000000), %o1 40019f60: 80 a2 20 00 cmp %o0, 0 40019f64: 12 80 00 b5 bne 4001a238 <== NEVER TAKEN 40019f68: d4 07 bf c0 ld [ %fp + -64 ], %o2 rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true); 40019f6c: d4 07 bf a0 ld [ %fp + -96 ], %o2 40019f70: 96 10 20 01 mov 1, %o3 40019f74: 92 07 bf a4 add %fp, -92, %o1 40019f78: 7f ff d6 54 call 4000f8c8 40019f7c: 90 10 00 18 mov %i0, %o0 if (rc > 0) 40019f80: a6 92 20 00 orcc %o0, 0, %l3 40019f84: 14 80 00 c4 bg 4001a294 <== NEVER TAKEN 40019f88: 90 10 20 00 clr %o0 map.bpos.boff = 0; 40019f8c: c0 27 bf c4 clr [ %fp + -60 ] while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 40019f90: d0 06 20 08 ld [ %i0 + 8 ], %o0 entry = rtems_rfs_buffer_data (&entries); 40019f94: c2 07 bf ac ld [ %fp + -84 ], %g1 while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 40019f98: 80 a2 20 0a cmp %o0, 0xa 40019f9c: 12 80 00 0a bne 40019fc4 <== ALWAYS TAKEN 40019fa0: e0 00 60 1c ld [ %g1 + 0x1c ], %l0 if (rc == 0) 40019fa4: 10 80 00 47 b 4001a0c0 <== NOT EXECUTED 40019fa8: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED map.bpos.boff += elength; 40019fac: 82 05 c0 01 add %l7, %g1, %g1 40019fb0: c2 27 bf c4 st %g1, [ %fp + -60 ] while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 40019fb4: 86 02 3f f6 add %o0, -10, %g3 40019fb8: 80 a0 40 03 cmp %g1, %g3 40019fbc: 1a 80 00 40 bcc 4001a0bc <== NEVER TAKEN 40019fc0: a0 04 00 17 add %l0, %l7, %l0 *ino = rtems_rfs_dir_entry_ino (entry); 40019fc4: d8 0c 00 00 ldub [ %l0 ], %o4 40019fc8: de 0c 20 01 ldub [ %l0 + 1 ], %o7 40019fcc: c2 0c 20 02 ldub [ %l0 + 2 ], %g1 40019fd0: d2 0c 20 03 ldub [ %l0 + 3 ], %o1 ehash = rtems_rfs_dir_entry_hash (entry); 40019fd4: da 0c 20 04 ldub [ %l0 + 4 ], %o5 40019fd8: c8 0c 20 05 ldub [ %l0 + 5 ], %g4 40019fdc: c6 0c 20 06 ldub [ %l0 + 6 ], %g3 40019fe0: d6 0c 20 07 ldub [ %l0 + 7 ], %o3 40019fe4: c4 0c 20 08 ldub [ %l0 + 8 ], %g2 40019fe8: d4 0c 20 09 ldub [ %l0 + 9 ], %o2 *ino = rtems_rfs_dir_entry_ino (entry); 40019fec: 99 2b 20 18 sll %o4, 0x18, %o4 40019ff0: 9f 2b e0 10 sll %o7, 0x10, %o7 40019ff4: 83 28 60 08 sll %g1, 8, %g1 40019ff8: 9e 13 c0 0c or %o7, %o4, %o7 40019ffc: 82 10 40 0f or %g1, %o7, %g1 4001a000: 92 12 40 01 or %o1, %g1, %o1 4001a004: d2 27 00 00 st %o1, [ %i4 ] ehash = rtems_rfs_dir_entry_hash (entry); 4001a008: 9b 2b 60 18 sll %o5, 0x18, %o5 4001a00c: 89 29 20 10 sll %g4, 0x10, %g4 4001a010: 87 28 e0 08 sll %g3, 8, %g3 4001a014: 88 11 00 0d or %g4, %o5, %g4 4001a018: 85 28 a0 08 sll %g2, 8, %g2 4001a01c: 86 10 c0 04 or %g3, %g4, %g3 elength = rtems_rfs_dir_entry_length (entry); 4001a020: ae 12 80 02 or %o2, %g2, %l7 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001a024: 80 a5 c0 11 cmp %l7, %l1 4001a028: 02 80 00 25 be 4001a0bc 4001a02c: 86 12 c0 03 or %o3, %g3, %g3 if (rtems_rfs_dir_entry_valid (fs, elength, *ino)) 4001a030: 80 a5 e0 0a cmp %l7, 0xa 4001a034: 24 80 00 61 ble,a 4001a1b8 <== NEVER TAKEN 4001a038: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001a03c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 4001a040: 80 a5 c0 01 cmp %l7, %g1 4001a044: 1a 80 00 5c bcc 4001a1b4 <== NEVER TAKEN 4001a048: 80 a2 60 00 cmp %o1, 0 4001a04c: 22 80 00 5b be,a 4001a1b8 <== NEVER TAKEN 4001a050: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001a054: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 4001a058: 80 a2 40 01 cmp %o1, %g1 4001a05c: 18 80 00 56 bgu 4001a1b4 <== NEVER TAKEN 4001a060: 80 a4 80 03 cmp %l2, %g3 if (ehash == hash) 4001a064: 12 bf ff d2 bne 40019fac 4001a068: c2 07 bf c4 ld [ %fp + -60 ], %g1 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 4001a06c: 90 10 00 14 mov %l4, %o0 4001a070: 7f ff e4 38 call 40013150 4001a074: 92 10 00 15 mov %l5, %o1 4001a078: 80 a2 20 00 cmp %o0, 0 4001a07c: 32 80 00 5f bne,a 4001a1f8 <== NEVER TAKEN 4001a080: c8 0c 00 00 ldub [ %l0 ], %g4 <== NOT EXECUTED if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0) 4001a084: 94 10 00 1b mov %i3, %o2 4001a088: 92 10 00 1a mov %i2, %o1 4001a08c: 40 00 11 35 call 4001e560 4001a090: 90 04 20 0a add %l0, 0xa, %o0 4001a094: 80 a2 20 00 cmp %o0, 0 4001a098: 02 80 00 91 be 4001a2dc <== ALWAYS TAKEN 4001a09c: c2 07 bf c4 ld [ %fp + -60 ], %g1 map.bpos.boff += elength; 4001a0a0: 82 05 c0 01 add %l7, %g1, %g1 <== NOT EXECUTED 4001a0a4: c2 27 bf c4 st %g1, [ %fp + -60 ] <== NOT EXECUTED 4001a0a8: d0 06 20 08 ld [ %i0 + 8 ], %o0 <== NOT EXECUTED while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 4001a0ac: 86 02 3f f6 add %o0, -10, %g3 <== NOT EXECUTED 4001a0b0: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 4001a0b4: 0a bf ff c4 bcs 40019fc4 <== NOT EXECUTED 4001a0b8: a0 04 00 17 add %l0, %l7, %l0 <== NOT EXECUTED if (rc == 0) 4001a0bc: 80 a4 e0 00 cmp %l3, 0 4001a0c0: 12 80 00 32 bne 4001a188 <== NEVER TAKEN 4001a0c4: 92 07 bf a4 add %fp, -92, %o1 rc = rtems_rfs_block_map_next_block (fs, &map, &block); 4001a0c8: 94 07 bf a0 add %fp, -96, %o2 4001a0cc: 92 07 bf b0 add %fp, -80, %o1 4001a0d0: 7f ff fd 55 call 40019624 4001a0d4: 90 10 00 18 mov %i0, %o0 if ((rc > 0) && (rc != ENXIO)) 4001a0d8: a6 92 20 00 orcc %o0, 0, %l3 4001a0dc: 04 80 00 09 ble 4001a100 <== NEVER TAKEN 4001a0e0: 80 a4 e0 06 cmp %l3, 6 4001a0e4: 02 80 00 08 be 4001a104 <== ALWAYS TAKEN 4001a0e8: 90 10 20 00 clr %o0 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 4001a0ec: 7f ff e4 19 call 40013150 <== NOT EXECUTED 4001a0f0: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 4001a0f4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001a0f8: 32 80 00 5e bne,a 4001a270 <== NOT EXECUTED 4001a0fc: e0 06 60 08 ld [ %i1 + 8 ], %l0 <== NOT EXECUTED if (rc == ENXIO) 4001a100: 80 a4 e0 06 cmp %l3, 6 <== NOT EXECUTED 4001a104: 12 bf ff 90 bne 40019f44 <== NEVER TAKEN 4001a108: 80 a4 e0 00 cmp %l3, 0 rc = ENOENT; 4001a10c: 10 80 00 1e b 4001a184 4001a110: a6 10 20 02 mov 2, %l3 printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=", 4001a114: 11 10 00 8d sethi %hi(0x40023400), %o0 <== NOT EXECUTED 4001a118: 7f ff e4 9c call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a11c: 90 12 23 10 or %o0, 0x310, %o0 ! 40023710 <== NOT EXECUTED for (c = 0; c < length; c++) 4001a120: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 4001a124: 04 80 00 0a ble 4001a14c <== NOT EXECUTED 4001a128: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 4001a12c: a0 10 00 1a mov %i2, %l0 <== NOT EXECUTED 4001a130: a2 06 c0 1a add %i3, %i2, %l1 <== NOT EXECUTED printf ("%c", name[c]); 4001a134: 7f ff e4 aa call 400133dc <__wrap_putchar> <== NOT EXECUTED 4001a138: d0 4c 00 00 ldsb [ %l0 ], %o0 <== NOT EXECUTED 4001a13c: a0 04 20 01 inc %l0 <== NOT EXECUTED for (c = 0; c < length; c++) 4001a140: 80 a4 40 10 cmp %l1, %l0 <== NOT EXECUTED 4001a144: 12 bf ff fc bne 4001a134 <== NOT EXECUTED 4001a148: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED printf (", len=%d\n", length); 4001a14c: 11 10 00 8d sethi %hi(0x40023400), %o0 <== NOT EXECUTED 4001a150: 7f ff e4 8e call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a154: 90 12 23 48 or %o0, 0x348, %o0 ! 40023748 <== NOT EXECUTED *ino = RTEMS_RFS_EMPTY_INO; 4001a158: 10 bf ff 45 b 40019e6c <== NOT EXECUTED 4001a15c: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 4001a160: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001a164: 7f ff e3 fb call 40013150 <== NOT EXECUTED 4001a168: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 4001a16c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001a170: 12 80 00 37 bne 4001a24c <== NOT EXECUTED 4001a174: 01 00 00 00 nop <== NOT EXECUTED if (rc == ENXIO) 4001a178: 80 a4 e0 06 cmp %l3, 6 <== NOT EXECUTED 4001a17c: 22 80 00 02 be,a 4001a184 <== NOT EXECUTED 4001a180: a6 10 20 02 mov 2, %l3 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001a184: 92 07 bf a4 add %fp, -92, %o1 4001a188: 7f ff d6 97 call 4000fbe4 4001a18c: 90 10 00 18 mov %i0, %o0 rtems_rfs_block_map_close (fs, &map); 4001a190: 92 07 bf b0 add %fp, -80, %o1 handle->dirty = false; 4001a194: c0 2f bf a4 clrb [ %fp + -92 ] 4001a198: 90 10 00 18 mov %i0, %o0 handle->bnum = 0; 4001a19c: c0 27 bf a8 clr [ %fp + -88 ] } 4001a1a0: b0 10 00 13 mov %l3, %i0 rtems_rfs_block_map_close (fs, &map); 4001a1a4: 7f ff fc 36 call 4001927c 4001a1a8: c0 27 bf ac clr [ %fp + -84 ] } 4001a1ac: 81 c7 e0 08 ret 4001a1b0: 81 e8 00 00 restore if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 4001a1b4: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001a1b8: 7f ff e3 e6 call 40013150 <== NOT EXECUTED 4001a1bc: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 4001a1c0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001a1c4: 12 80 00 04 bne 4001a1d4 <== NOT EXECUTED 4001a1c8: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED rc = EIO; 4001a1cc: 10 bf ff ee b 4001a184 <== NOT EXECUTED 4001a1d0: a6 10 20 05 mov 5, %l3 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: " 4001a1d4: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED 4001a1d8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001a1dc: 94 10 00 17 mov %l7, %o2 <== NOT EXECUTED rc = EIO; 4001a1e0: a6 10 20 05 mov 5, %l3 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: " 4001a1e4: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 4001a1e8: 7f ff e4 68 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a1ec: 90 12 20 58 or %o0, 0x58, %o0 ! 40023858 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001a1f0: 10 bf ff e6 b 4001a188 <== NOT EXECUTED 4001a1f4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: " 4001a1f8: c6 0c 20 01 ldub [ %l0 + 1 ], %g3 <== NOT EXECUTED 4001a1fc: c2 0c 20 02 ldub [ %l0 + 2 ], %g1 <== NOT EXECUTED 4001a200: da 0c 20 03 ldub [ %l0 + 3 ], %o5 <== NOT EXECUTED 4001a204: 89 29 20 18 sll %g4, 0x18, %g4 <== NOT EXECUTED 4001a208: d4 1f bf c0 ldd [ %fp + -64 ], %o2 <== NOT EXECUTED 4001a20c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001a210: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED 4001a214: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED 4001a218: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED 4001a21c: 82 10 40 03 or %g1, %g3, %g1 <== NOT EXECUTED 4001a220: 98 10 00 17 mov %l7, %o4 <== NOT EXECUTED 4001a224: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED 4001a228: 7f ff e4 58 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a22c: 9a 13 40 01 or %o5, %g1, %o5 <== NOT EXECUTED if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0) 4001a230: 10 bf ff 96 b 4001a088 <== NOT EXECUTED 4001a234: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n", 4001a238: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001a23c: 7f ff e4 53 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a240: d0 07 bf 9c ld [ %fp + -100 ], %o0 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true); 4001a244: 10 bf ff 4b b 40019f70 <== NOT EXECUTED 4001a248: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n", 4001a24c: 40 00 14 95 call 4001f4a0 <== NOT EXECUTED 4001a250: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED 4001a254: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 4001a258: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 4001a25c: 11 10 00 8d sethi %hi(0x40023400), %o0 <== NOT EXECUTED 4001a260: 7f ff e4 4a call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a264: 90 12 23 98 or %o0, 0x398, %o0 ! 40023798 <== NOT EXECUTED if (rc == ENXIO) 4001a268: 10 bf ff c5 b 4001a17c <== NOT EXECUTED 4001a26c: 80 a4 e0 06 cmp %l3, 6 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: " 4001a270: 40 00 14 8c call 4001f4a0 <== NOT EXECUTED 4001a274: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED 4001a278: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001a27c: d0 07 bf 98 ld [ %fp + -104 ], %o0 <== NOT EXECUTED 4001a280: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED 4001a284: 7f ff e4 41 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a288: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED if (rc == ENXIO) 4001a28c: 10 bf ff 9e b 4001a104 <== NOT EXECUTED 4001a290: 80 a4 e0 06 cmp %l3, 6 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 4001a294: 7f ff e3 af call 40013150 <== NOT EXECUTED 4001a298: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 4001a29c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001a2a0: 22 bf ff ba be,a 4001a188 <== NOT EXECUTED 4001a2a4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n", 4001a2a8: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED 4001a2ac: f8 07 bf a0 ld [ %fp + -96 ], %i4 <== NOT EXECUTED 4001a2b0: 40 00 14 7c call 4001f4a0 <== NOT EXECUTED 4001a2b4: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED 4001a2b8: 96 10 00 13 mov %l3, %o3 <== NOT EXECUTED 4001a2bc: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED 4001a2c0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED 4001a2c4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001a2c8: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 4001a2cc: 7f ff e4 2f call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a2d0: 90 12 20 10 or %o0, 0x10, %o0 ! 40023810 <== NOT EXECUTED 4001a2d4: 10 bf ff ad b 4001a188 <== NOT EXECUTED 4001a2d8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED *offset = rtems_rfs_block_map_pos (fs, &map); 4001a2dc: 92 07 bf c0 add %fp, -64, %o1 4001a2e0: 7f ff fb 6e call 40019098 4001a2e4: 90 10 00 18 mov %i0, %o0 4001a2e8: d2 27 40 00 st %o1, [ %i5 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND)) 4001a2ec: 90 10 20 00 clr %o0 4001a2f0: 7f ff e3 98 call 40013150 4001a2f4: 13 04 00 00 sethi %hi(0x10000000), %o1 4001a2f8: 80 a2 20 00 cmp %o0, 0 4001a2fc: 02 80 00 09 be 4001a320 <== ALWAYS TAKEN 4001a300: 92 07 bf a4 add %fp, -92, %o1 printf ("rtems-rfs: dir-lookup-ino: " 4001a304: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED 4001a308: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED 4001a30c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001a310: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 4001a314: 7f ff e4 1d call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a318: 90 12 21 08 or %o0, 0x108, %o0 ! 40023908 <== NOT EXECUTED 4001a31c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED 4001a320: 7f ff d6 31 call 4000fbe4 4001a324: 90 10 00 18 mov %i0, %o0 rtems_rfs_block_map_close (fs, &map); 4001a328: 92 07 bf b0 add %fp, -80, %o1 handle->dirty = false; 4001a32c: c0 2f bf a4 clrb [ %fp + -92 ] 4001a330: 90 10 00 18 mov %i0, %o0 handle->bnum = 0; 4001a334: c0 27 bf a8 clr [ %fp + -88 ] return 0; 4001a338: a6 10 20 00 clr %l3 rtems_rfs_block_map_close (fs, &map); 4001a33c: 7f ff fb d0 call 4001927c 4001a340: c0 27 bf ac clr [ %fp + -84 ] return 0; 4001a344: 30 bf fe d8 b,a 40019ea4 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 4001a348: 7f ff e3 82 call 40013150 <== NOT EXECUTED 4001a34c: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 4001a350: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001a354: 22 bf ff 8c be,a 4001a184 <== NOT EXECUTED 4001a358: a6 10 20 05 mov 5, %l3 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n", 4001a35c: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED 4001a360: 40 00 14 50 call 4001f4a0 <== NOT EXECUTED 4001a364: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED 4001a368: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED 4001a36c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001a370: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED rc = EIO; 4001a374: a6 10 20 05 mov 5, %l3 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n", 4001a378: 11 10 00 8e sethi %hi(0x40023800), %o0 <== NOT EXECUTED 4001a37c: 7f ff e4 03 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001a380: 90 12 21 a0 or %o0, 0x1a0, %o0 ! 400239a0 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001a384: 10 bf ff 81 b 4001a188 <== NOT EXECUTED 4001a388: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED =============================================================================== 4001abec : rtems_rfs_dir_read (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir, rtems_rfs_pos_rel offset, struct dirent* dirent, size_t* length) { 4001abec: 9d e3 bf 40 save %sp, -192, %sp rtems_rfs_block_map map; rtems_rfs_buffer_handle buffer; rtems_rfs_block_no block; int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) 4001abf0: 90 10 20 00 clr %o0 4001abf4: 13 20 00 00 sethi %hi(0x80000000), %o1 4001abf8: 7f ff e1 56 call 40013150 4001abfc: a4 10 00 1a mov %i2, %l2 4001ac00: 80 a2 20 00 cmp %o0, 0 4001ac04: 12 80 00 29 bne 4001aca8 <== NEVER TAKEN 4001ac08: a6 10 00 1b mov %i3, %l3 printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n", rtems_rfs_inode_ino (dir), offset); *length = 0; 4001ac0c: c0 27 40 00 clr [ %i5 ] rc = rtems_rfs_block_map_open (fs, dir, &map); 4001ac10: 92 10 00 19 mov %i1, %o1 4001ac14: 94 07 bf b0 add %fp, -80, %o2 4001ac18: 7f ff f9 3a call 40019100 4001ac1c: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001ac20: b6 92 20 00 orcc %o0, 0, %i3 4001ac24: 24 80 00 04 ble,a 4001ac34 <== ALWAYS TAKEN 4001ac28: e0 06 20 08 ld [ %i0 + 8 ], %l0 } rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_block_map_close (fs, &map); return rc; } 4001ac2c: 81 c7 e0 08 ret <== NOT EXECUTED 4001ac30: 91 e8 00 1b restore %g0, %i3, %o0 <== NOT EXECUTED if (((rtems_rfs_fs_block_size (fs) - 4001ac34: b4 10 20 00 clr %i2 (offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE)) 4001ac38: 90 10 00 12 mov %l2, %o0 4001ac3c: 92 10 00 13 mov %l3, %o1 4001ac40: 94 10 00 1a mov %i2, %o2 4001ac44: 40 00 14 cf call 4001ff80 <__moddi3> 4001ac48: 96 10 00 10 mov %l0, %o3 if (((rtems_rfs_fs_block_size (fs) - 4001ac4c: 86 a4 00 09 subcc %l0, %o1, %g3 4001ac50: 84 66 80 08 subx %i2, %o0, %g2 4001ac54: 80 a0 a0 00 cmp %g2, 0 4001ac58: 04 80 00 1c ble 4001acc8 <== ALWAYS TAKEN 4001ac5c: b6 10 00 10 mov %l0, %i3 rc = rtems_rfs_block_map_seek (fs, &map, offset, &block); 4001ac60: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED 4001ac64: 96 10 00 13 mov %l3, %o3 4001ac68: 98 07 bf a0 add %fp, -96, %o4 4001ac6c: 92 07 bf b0 add %fp, -80, %o1 4001ac70: 7f ff fa 4f call 400195ac 4001ac74: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001ac78: b6 92 20 00 orcc %o0, 0, %i3 4001ac7c: 24 80 00 2d ble,a 4001ad30 <== ALWAYS TAKEN 4001ac80: 35 00 00 3f sethi %hi(0xfc00), %i2 if (rc == ENXIO) 4001ac84: 80 a6 e0 06 cmp %i3, 6 <== NOT EXECUTED 4001ac88: 22 80 00 02 be,a 4001ac90 <== NOT EXECUTED 4001ac8c: b6 10 20 02 mov 2, %i3 <== NOT EXECUTED rtems_rfs_block_map_close (fs, &map); 4001ac90: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 4001ac94: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001ac98: 7f ff f9 79 call 4001927c <== NOT EXECUTED 4001ac9c: b0 10 00 1b mov %i3, %i0 <== NOT EXECUTED } 4001aca0: 81 c7 e0 08 ret <== NOT EXECUTED 4001aca4: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n", 4001aca8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001acac: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 4001acb0: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED 4001acb4: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 4001acb8: 7f ff e1 b4 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001acbc: 90 12 20 c0 or %o0, 0xc0, %o0 ! 40023cc0 <== NOT EXECUTED *length = 0; 4001acc0: 10 bf ff d4 b 4001ac10 <== NOT EXECUTED 4001acc4: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED if (((rtems_rfs_fs_block_size (fs) - 4001acc8: 12 80 00 06 bne 4001ace0 <== NEVER TAKEN 4001accc: 96 10 00 1b mov %i3, %o3 4001acd0: 80 a0 e0 0a cmp %g3, 0xa 4001acd4: 38 bf ff e4 bgu,a 4001ac64 <== ALWAYS TAKEN 4001acd8: 94 10 00 12 mov %l2, %o2 offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) * 4001acdc: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED 4001ace0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4001ace4: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 4001ace8: 40 00 14 1b call 4001fd54 <__divdi3> <== NOT EXECUTED 4001acec: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 4001acf0: 86 82 60 01 addcc %o1, 1, %g3 <== NOT EXECUTED 4001acf4: 84 42 20 00 addx %o0, 0, %g2 <== NOT EXECUTED 4001acf8: 82 58 80 10 smul %g2, %l0, %g1 <== NOT EXECUTED 4001acfc: a6 54 00 03 umul %l0, %g3, %l3 <== NOT EXECUTED 4001ad00: a5 40 00 00 rd %y, %l2 <== NOT EXECUTED rc = rtems_rfs_block_map_seek (fs, &map, offset, &block); 4001ad04: 98 07 bf a0 add %fp, -96, %o4 <== NOT EXECUTED offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) * 4001ad08: a4 00 40 12 add %g1, %l2, %l2 <== NOT EXECUTED rc = rtems_rfs_block_map_seek (fs, &map, offset, &block); 4001ad0c: 96 10 00 13 mov %l3, %o3 <== NOT EXECUTED 4001ad10: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED 4001ad14: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 4001ad18: 7f ff fa 25 call 400195ac <== NOT EXECUTED 4001ad1c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 4001ad20: b6 92 20 00 orcc %o0, 0, %i3 <== NOT EXECUTED 4001ad24: 14 bf ff d9 bg 4001ac88 <== NOT EXECUTED 4001ad28: 80 a6 e0 06 cmp %i3, 6 <== NOT EXECUTED if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY) 4001ad2c: 35 00 00 3f sethi %hi(0xfc00), %i2 <== NOT EXECUTED printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n", 4001ad30: 2d 10 00 8f sethi %hi(0x40023c00), %l6 handle->dirty = false; 4001ad34: c0 2f bf a4 clrb [ %fp + -92 ] if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY) 4001ad38: b4 16 a3 ff or %i2, 0x3ff, %i2 handle->bnum = 0; 4001ad3c: c0 27 bf a8 clr [ %fp + -88 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) 4001ad40: a8 10 20 00 clr %l4 handle->buffer = NULL; 4001ad44: c0 27 bf ac clr [ %fp + -84 ] 4001ad48: 2b 20 00 00 sethi %hi(0x80000000), %l5 printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n", 4001ad4c: 10 80 00 0b b 4001ad78 4001ad50: ac 15 a1 70 or %l6, 0x170, %l6 rc = rtems_rfs_block_map_next_block (fs, &map, &block); 4001ad54: 92 07 bf b0 add %fp, -80, %o1 4001ad58: 7f ff fa 33 call 40019624 4001ad5c: 90 10 00 18 mov %i0, %o0 if (rc == ENXIO) 4001ad60: 80 a2 20 06 cmp %o0, 6 4001ad64: 02 80 00 90 be 4001afa4 <== ALWAYS TAKEN 4001ad68: b6 10 00 08 mov %o0, %i3 while (rc == 0) 4001ad6c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001ad70: 12 80 00 60 bne 4001aef0 <== NOT EXECUTED 4001ad74: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true); 4001ad78: d4 07 bf a0 ld [ %fp + -96 ], %o2 4001ad7c: 96 10 20 01 mov 1, %o3 4001ad80: 92 07 bf a4 add %fp, -92, %o1 4001ad84: 7f ff d2 d1 call 4000f8c8 4001ad88: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001ad8c: b6 92 20 00 orcc %o0, 0, %i3 4001ad90: 14 80 00 57 bg 4001aeec <== NEVER TAKEN 4001ad94: c2 07 bf ac ld [ %fp + -84 ], %g1 entry = rtems_rfs_buffer_data (&buffer); 4001ad98: e0 00 60 1c ld [ %g1 + 0x1c ], %l0 entry += map.bpos.boff; 4001ad9c: c6 07 bf c4 ld [ %fp + -60 ], %g3 4001ada0: a0 04 00 03 add %l0, %g3, %l0 4001ada4: c2 0c 20 08 ldub [ %l0 + 8 ], %g1 4001ada8: e2 0c 20 09 ldub [ %l0 + 9 ], %l1 4001adac: 83 28 60 08 sll %g1, 8, %g1 elength = rtems_rfs_dir_entry_length (entry); 4001adb0: a2 14 40 01 or %l1, %g1, %l1 if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY) 4001adb4: 80 a4 40 1a cmp %l1, %i2 4001adb8: 12 80 00 59 bne 4001af1c 4001adbc: 90 10 00 14 mov %l4, %o0 *length += rtems_rfs_fs_block_size (fs) - map.bpos.boff; 4001adc0: c4 06 20 08 ld [ %i0 + 8 ], %g2 4001adc4: c2 07 40 00 ld [ %i5 ], %g1 4001adc8: 84 20 80 03 sub %g2, %g3, %g2 4001adcc: 82 00 40 02 add %g1, %g2, %g1 4001add0: c2 27 40 00 st %g1, [ %i5 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) 4001add4: 7f ff e0 df call 40013150 4001add8: 92 10 00 15 mov %l5, %o1 4001addc: 80 a2 20 00 cmp %o0, 0 4001ade0: 22 bf ff dd be,a 4001ad54 <== ALWAYS TAKEN 4001ade4: 94 07 bf a0 add %fp, -96, %o2 printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n", 4001ade8: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED 4001adec: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED 4001adf0: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED 4001adf4: 7f ff e1 65 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001adf8: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED rc = rtems_rfs_block_map_next_block (fs, &map, &block); 4001adfc: 10 bf ff d6 b 4001ad54 <== NOT EXECUTED 4001ae00: 94 07 bf a0 add %fp, -96, %o2 <== NOT EXECUTED if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 4001ae04: 80 a0 40 1a cmp %g1, %i2 4001ae08: 0a 80 00 58 bcs 4001af68 <== NEVER TAKEN 4001ae0c: 90 10 20 00 clr %o0 memset (dirent, 0, sizeof (struct dirent)); 4001ae10: 94 10 21 18 mov 0x118, %o2 4001ae14: 92 10 20 00 clr %o1 4001ae18: 40 00 0e 85 call 4001e82c 4001ae1c: 90 10 00 1c mov %i4, %o0 dirent->d_off = rtems_rfs_block_get_pos (fs, &map.bpos); 4001ae20: 92 07 bf c0 add %fp, -64, %o1 4001ae24: 7f ff f8 9d call 40019098 4001ae28: 90 10 00 18 mov %i0, %o0 *length += elength; 4001ae2c: c2 07 40 00 ld [ %i5 ], %g1 dirent->d_reclen = sizeof (struct dirent); 4001ae30: 84 10 21 18 mov 0x118, %g2 dirent->d_off = rtems_rfs_block_get_pos (fs, &map.bpos); 4001ae34: d0 3f 20 08 std %o0, [ %i4 + 8 ] *length += elength; 4001ae38: 82 04 40 01 add %l1, %g1, %g1 dirent->d_reclen = sizeof (struct dirent); 4001ae3c: c4 37 20 10 sth %g2, [ %i4 + 0x10 ] *length += elength; 4001ae40: c2 27 40 00 st %g1, [ %i5 ] remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength); 4001ae44: c6 07 bf c4 ld [ %fp + -60 ], %g3 4001ae48: c4 06 20 08 ld [ %i0 + 8 ], %g2 4001ae4c: 84 20 80 03 sub %g2, %g3, %g2 4001ae50: 84 20 80 11 sub %g2, %l1, %g2 if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE) 4001ae54: 80 a0 a0 0a cmp %g2, 0xa 4001ae58: 14 80 00 04 bg 4001ae68 <== ALWAYS TAKEN 4001ae5c: a2 04 7f f6 add %l1, -10, %l1 *length += remaining; 4001ae60: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED 4001ae64: c2 27 40 00 st %g1, [ %i5 ] <== NOT EXECUTED 4001ae68: 80 a4 60 ff cmp %l1, 0xff 4001ae6c: 34 80 00 02 bg,a 4001ae74 <== NEVER TAKEN 4001ae70: a2 10 20 ff mov 0xff, %l1 <== NOT EXECUTED memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength); 4001ae74: 94 10 00 11 mov %l1, %o2 4001ae78: 92 04 20 0a add %l0, 0xa, %o1 4001ae7c: ba 07 20 14 add %i4, 0x14, %i5 4001ae80: 40 00 0d e1 call 4001e604 4001ae84: 90 10 00 1d mov %i5, %o0 dirent->d_ino = rtems_rfs_dir_entry_ino (entry); 4001ae88: c8 0c 00 00 ldub [ %l0 ], %g4 4001ae8c: c4 0c 20 01 ldub [ %l0 + 1 ], %g2 4001ae90: c2 0c 20 02 ldub [ %l0 + 2 ], %g1 4001ae94: c6 0c 20 03 ldub [ %l0 + 3 ], %g3 4001ae98: 89 29 20 18 sll %g4, 0x18, %g4 4001ae9c: 85 28 a0 10 sll %g2, 0x10, %g2 4001aea0: 83 28 60 08 sll %g1, 8, %g1 4001aea4: 84 10 80 04 or %g2, %g4, %g2 dirent->d_namlen = elength; 4001aea8: e2 37 20 12 sth %l1, [ %i4 + 0x12 ] dirent->d_ino = rtems_rfs_dir_entry_ino (entry); 4001aeac: 82 10 40 02 or %g1, %g2, %g1 4001aeb0: 82 10 c0 01 or %g3, %g1, %g1 4001aeb4: c2 27 00 00 st %g1, [ %i4 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) 4001aeb8: 90 10 20 00 clr %o0 4001aebc: 7f ff e0 a5 call 40013150 4001aec0: 13 20 00 00 sethi %hi(0x80000000), %o1 4001aec4: 80 a2 20 00 cmp %o0, 0 4001aec8: 02 80 00 0a be 4001aef0 <== ALWAYS TAKEN 4001aecc: 92 07 bf a4 add %fp, -92, %o1 printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n", 4001aed0: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED 4001aed4: d2 07 20 08 ld [ %i4 + 8 ], %o1 <== NOT EXECUTED 4001aed8: d4 07 20 0c ld [ %i4 + 0xc ], %o2 <== NOT EXECUTED 4001aedc: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 4001aee0: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED 4001aee4: 7f ff e1 29 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001aee8: 90 12 21 38 or %o0, 0x138, %o0 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001aeec: 92 07 bf a4 add %fp, -92, %o1 4001aef0: 7f ff d3 3d call 4000fbe4 4001aef4: 90 10 00 18 mov %i0, %o0 rtems_rfs_block_map_close (fs, &map); 4001aef8: 92 07 bf b0 add %fp, -80, %o1 handle->dirty = false; 4001aefc: c0 2f bf a4 clrb [ %fp + -92 ] 4001af00: 90 10 00 18 mov %i0, %o0 handle->bnum = 0; 4001af04: c0 27 bf a8 clr [ %fp + -88 ] } 4001af08: b0 10 00 1b mov %i3, %i0 rtems_rfs_block_map_close (fs, &map); 4001af0c: 7f ff f8 dc call 4001927c 4001af10: c0 27 bf ac clr [ %fp + -84 ] } 4001af14: 81 c7 e0 08 ret 4001af18: 81 e8 00 00 restore eino = rtems_rfs_dir_entry_ino (entry); 4001af1c: c4 0c 00 00 ldub [ %l0 ], %g2 4001af20: c2 0c 20 01 ldub [ %l0 + 1 ], %g1 4001af24: d6 0c 20 02 ldub [ %l0 + 2 ], %o3 4001af28: c6 0c 20 03 ldub [ %l0 + 3 ], %g3 4001af2c: 85 28 a0 18 sll %g2, 0x18, %g2 4001af30: 83 28 60 10 sll %g1, 0x10, %g1 4001af34: 97 2a e0 08 sll %o3, 8, %o3 4001af38: 82 10 40 02 or %g1, %g2, %g1 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 4001af3c: 80 a4 60 0a cmp %l1, 0xa eino = rtems_rfs_dir_entry_ino (entry); 4001af40: 96 12 c0 01 or %o3, %g1, %o3 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 4001af44: 04 80 00 08 ble 4001af64 <== NEVER TAKEN 4001af48: b4 10 c0 0b or %g3, %o3, %i2 4001af4c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 4001af50: 80 a4 40 01 cmp %l1, %g1 4001af54: 1a 80 00 04 bcc 4001af64 <== NEVER TAKEN 4001af58: 80 a6 a0 00 cmp %i2, 0 4001af5c: 32 bf ff aa bne,a 4001ae04 <== ALWAYS TAKEN 4001af60: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) 4001af64: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001af68: 13 20 00 00 sethi %hi(0x80000000), %o1 <== NOT EXECUTED 4001af6c: 7f ff e0 79 call 40013150 <== NOT EXECUTED 4001af70: b6 10 20 05 mov 5, %i3 <== NOT EXECUTED 4001af74: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001af78: 22 bf ff de be,a 4001aef0 <== NOT EXECUTED 4001af7c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-read: " 4001af80: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED 4001af84: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001af88: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 4001af8c: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED 4001af90: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 4001af94: 7f ff e0 fd call 40013388 <__wrap_printf> <== NOT EXECUTED 4001af98: 90 12 20 f0 or %o0, 0xf0, %o0 ! 40023cf0 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001af9c: 10 bf ff d5 b 4001aef0 <== NOT EXECUTED 4001afa0: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED rc = ENOENT; 4001afa4: 10 bf ff d2 b 4001aeec 4001afa8: b6 10 20 02 mov 2, %i3 =============================================================================== 4001b560 : { 4001b560: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE)) 4001b564: 90 10 20 10 mov 0x10, %o0 4001b568: 7f ff de fa call 40013150 4001b56c: 92 10 20 00 clr %o1 4001b570: 80 a2 20 00 cmp %o0, 0 4001b574: 32 80 00 79 bne,a 4001b758 <== NEVER TAKEN 4001b578: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED if (handle->shared->references > 0) 4001b57c: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 4001b580: fa 02 60 08 ld [ %o1 + 8 ], %i5 4001b584: 80 a7 60 00 cmp %i5, 0 4001b588: 04 80 00 05 ble 4001b59c <== NEVER TAKEN 4001b58c: 01 00 00 00 nop handle->shared->references--; 4001b590: ba 07 7f ff add %i5, -1, %i5 4001b594: fa 22 60 08 st %i5, [ %o1 + 8 ] if (handle->shared->references == 0) 4001b598: 80 a7 60 00 cmp %i5, 0 4001b59c: 02 80 00 0b be 4001b5c8 <== ALWAYS TAKEN 4001b5a0: b8 06 60 04 add %i1, 4, %i4 4001b5a4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED 4001b5a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001b5ac: 7f ff d1 8e call 4000fbe4 <== NOT EXECUTED 4001b5b0: ba 10 20 00 clr %i5 <== NOT EXECUTED free (handle); 4001b5b4: 90 10 00 19 mov %i1, %o0 4001b5b8: 7f ff ac 08 call 400065d8 4001b5bc: b0 10 00 1d mov %i5, %i0 } 4001b5c0: 81 c7 e0 08 ret 4001b5c4: 81 e8 00 00 restore if (!rtems_rfs_inode_is_loaded (&handle->shared->inode)) 4001b5c8: c4 02 60 18 ld [ %o1 + 0x18 ], %g2 4001b5cc: 80 a0 a0 00 cmp %g2, 0 4001b5d0: 22 80 00 87 be,a 4001b7ec <== ALWAYS TAKEN 4001b5d4: 92 02 60 0c add %o1, 0xc, %o1 rtems_rfs_inode_set_atime (&handle->shared->inode, 4001b5d8: c2 02 60 8c ld [ %o1 + 0x8c ], %g1 rtems_rfs_write_u32 (&handle->node->atime, atime); 4001b5dc: 87 30 60 18 srl %g1, 0x18, %g3 4001b5e0: c6 28 a0 10 stb %g3, [ %g2 + 0x10 ] 4001b5e4: 87 30 60 10 srl %g1, 0x10, %g3 4001b5e8: c4 02 60 18 ld [ %o1 + 0x18 ], %g2 4001b5ec: c6 28 a0 11 stb %g3, [ %g2 + 0x11 ] 4001b5f0: 87 30 60 08 srl %g1, 8, %g3 4001b5f4: c4 02 60 18 ld [ %o1 + 0x18 ], %g2 4001b5f8: c6 28 a0 12 stb %g3, [ %g2 + 0x12 ] rtems_rfs_buffer_mark_dirty (&handle->buffer); 4001b5fc: 88 10 20 01 mov 1, %g4 rtems_rfs_write_u32 (&handle->node->atime, atime); 4001b600: c4 02 60 18 ld [ %o1 + 0x18 ], %g2 4001b604: c2 28 a0 13 stb %g1, [ %g2 + 0x13 ] rtems_rfs_inode_set_mtime (&handle->shared->inode, 4001b608: c4 06 60 1c ld [ %i1 + 0x1c ], %g2 4001b60c: c2 00 a0 90 ld [ %g2 + 0x90 ], %g1 rtems_rfs_write_u32 (&handle->node->mtime, mtime); 4001b610: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 rtems_rfs_buffer_mark_dirty (&handle->buffer); 4001b614: c8 2a 60 1c stb %g4, [ %o1 + 0x1c ] rtems_rfs_write_u32 (&handle->node->mtime, mtime); 4001b618: b7 30 60 18 srl %g1, 0x18, %i3 4001b61c: f6 28 e0 14 stb %i3, [ %g3 + 0x14 ] 4001b620: b7 30 60 10 srl %g1, 0x10, %i3 4001b624: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 4001b628: f6 28 e0 15 stb %i3, [ %g3 + 0x15 ] 4001b62c: b7 30 60 08 srl %g1, 8, %i3 4001b630: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 4001b634: f6 28 e0 16 stb %i3, [ %g3 + 0x16 ] 4001b638: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 4001b63c: c2 28 e0 17 stb %g1, [ %g3 + 0x17 ] rtems_rfs_inode_set_ctime (&handle->shared->inode, 4001b640: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 4001b644: c6 00 60 94 ld [ %g1 + 0x94 ], %g3 rtems_rfs_buffer_mark_dirty (&handle->buffer); 4001b648: c8 28 a0 1c stb %g4, [ %g2 + 0x1c ] rtems_rfs_write_u32 (&handle->node->ctime, ctime); 4001b64c: b7 30 e0 18 srl %g3, 0x18, %i3 4001b650: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 4001b654: f6 28 a0 18 stb %i3, [ %g2 + 0x18 ] 4001b658: b7 30 e0 10 srl %g3, 0x10, %i3 4001b65c: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 4001b660: f6 28 a0 19 stb %i3, [ %g2 + 0x19 ] 4001b664: b7 30 e0 08 srl %g3, 8, %i3 4001b668: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 4001b66c: f6 28 a0 1a stb %i3, [ %g2 + 0x1a ] 4001b670: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 4001b674: c6 28 a0 1b stb %g3, [ %g2 + 0x1b ] if (!rtems_rfs_block_size_equal (&handle->shared->size, 4001b678: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 rtems_rfs_buffer_mark_dirty (&handle->buffer); 4001b67c: c8 28 60 1c stb %g4, [ %g1 + 0x1c ] 4001b680: c2 02 60 84 ld [ %o1 + 0x84 ], %g1 4001b684: c4 02 60 3c ld [ %o1 + 0x3c ], %g2 4001b688: 80 a0 40 02 cmp %g1, %g2 4001b68c: 02 80 00 75 be 4001b860 <== ALWAYS TAKEN 4001b690: c4 02 60 88 ld [ %o1 + 0x88 ], %g2 */ static inline void rtems_rfs_block_map_set_size (rtems_rfs_block_map* map, rtems_rfs_block_size* size) { rtems_rfs_block_copy_size (&map->size, size); 4001b694: c2 22 60 3c st %g1, [ %o1 + 0x3c ] <== NOT EXECUTED map->dirty = true; 4001b698: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED rtems_rfs_block_copy_size (&map->size, size); 4001b69c: c4 22 60 40 st %g2, [ %o1 + 0x40 ] <== NOT EXECUTED map->dirty = true; 4001b6a0: c2 2a 60 34 stb %g1, [ %o1 + 0x34 ] <== NOT EXECUTED rc = rtems_rfs_block_map_close (fs, &handle->shared->map); 4001b6a4: 92 02 60 34 add %o1, 0x34, %o1 <== NOT EXECUTED 4001b6a8: 7f ff f6 f5 call 4001927c 4001b6ac: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001b6b0: b6 92 20 00 orcc %o0, 0, %i3 4001b6b4: 14 80 00 44 bg 4001b7c4 <== NEVER TAKEN 4001b6b8: 90 10 20 10 mov 0x10, %o0 rc = rtems_rfs_inode_close (fs, &handle->shared->inode); 4001b6bc: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 4001b6c0: 92 02 60 0c add %o1, 0xc, %o1 4001b6c4: 7f ff d8 e5 call 40011a58 4001b6c8: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001b6cc: b6 92 20 00 orcc %o0, 0, %i3 4001b6d0: 34 80 00 28 bg,a 4001b770 <== NEVER TAKEN 4001b6d4: 90 10 20 10 mov 0x10, %o0 <== NOT EXECUTED 4001b6d8: d0 06 60 1c ld [ %i1 + 0x1c ], %o0 4001b6dc: c4 02 00 00 ld [ %o0 ], %g2 4001b6e0: c2 02 20 04 ld [ %o0 + 4 ], %g1 next->previous = previous; 4001b6e4: c2 20 a0 04 st %g1, [ %g2 + 4 ] free (handle->shared); 4001b6e8: 7f ff ab bc call 400065d8 4001b6ec: c4 20 40 00 st %g2, [ %g1 ] 4001b6f0: 92 10 00 1c mov %i4, %o1 4001b6f4: 7f ff d1 3c call 4000fbe4 4001b6f8: 90 10 00 18 mov %i0, %o0 handle->dirty = false; 4001b6fc: c0 2e 60 04 clrb [ %i1 + 4 ] if (rrc > 0) 4001b700: 80 a7 60 00 cmp %i5, 0 handle->bnum = 0; 4001b704: c0 26 60 08 clr [ %i1 + 8 ] 4001b708: 04 bf ff ab ble 4001b5b4 <== ALWAYS TAKEN 4001b70c: c0 26 60 0c clr [ %i1 + 0xc ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE)) 4001b710: 90 10 20 10 mov 0x10, %o0 <== NOT EXECUTED 4001b714: 7f ff de 8f call 40013150 <== NOT EXECUTED 4001b718: 92 10 20 00 clr %o1 <== NOT EXECUTED 4001b71c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001b720: 22 bf ff a6 be,a 4001b5b8 <== NOT EXECUTED 4001b724: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc)); 4001b728: 40 00 0f 5e call 4001f4a0 <== NOT EXECUTED 4001b72c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 4001b730: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001b734: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 4001b738: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 4001b73c: 7f ff df 13 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001b740: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 40023fa0 <== NOT EXECUTED free (handle); 4001b744: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 4001b748: 7f ff ab a4 call 400065d8 <== NOT EXECUTED 4001b74c: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED } 4001b750: 81 c7 e0 08 ret <== NOT EXECUTED 4001b754: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n", 4001b758: d2 00 60 14 ld [ %g1 + 0x14 ], %o1 <== NOT EXECUTED 4001b75c: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 4001b760: 7f ff df 0a call 40013388 <__wrap_printf> <== NOT EXECUTED 4001b764: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 40023ef8 <== NOT EXECUTED if (handle->shared->references > 0) 4001b768: 10 bf ff 86 b 4001b580 <== NOT EXECUTED 4001b76c: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE)) 4001b770: 7f ff de 78 call 40013150 <== NOT EXECUTED 4001b774: 92 10 20 00 clr %o1 <== NOT EXECUTED 4001b778: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001b77c: 32 80 00 23 bne,a 4001b808 <== NOT EXECUTED 4001b780: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED 4001b784: d0 06 60 1c ld [ %i1 + 0x1c ], %o0 <== NOT EXECUTED 4001b788: c4 02 00 00 ld [ %o0 ], %g2 <== NOT EXECUTED if (rrc == 0) 4001b78c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED 4001b790: 12 bf ff d5 bne 4001b6e4 <== NOT EXECUTED 4001b794: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 4001b798: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED handle->buffer = NULL; 4001b79c: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED free (handle->shared); 4001b7a0: 7f ff ab 8e call 400065d8 <== NOT EXECUTED 4001b7a4: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001b7a8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED 4001b7ac: 7f ff d1 0e call 4000fbe4 <== NOT EXECUTED 4001b7b0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED handle->dirty = false; 4001b7b4: c0 2e 60 04 clrb [ %i1 + 4 ] <== NOT EXECUTED handle->bnum = 0; 4001b7b8: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED handle->buffer = NULL; 4001b7bc: 10 bf ff d5 b 4001b710 <== NOT EXECUTED 4001b7c0: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE)) 4001b7c4: 7f ff de 63 call 40013150 <== NOT EXECUTED 4001b7c8: 92 10 20 00 clr %o1 <== NOT EXECUTED 4001b7cc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001b7d0: 32 80 00 19 bne,a 4001b834 <== NOT EXECUTED 4001b7d4: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED if (rrc == 0) 4001b7d8: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED 4001b7dc: 22 bf ff b8 be,a 4001b6bc <== NOT EXECUTED 4001b7e0: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED rc = rtems_rfs_inode_close (fs, &handle->shared->inode); 4001b7e4: 10 bf ff b7 b 4001b6c0 <== NOT EXECUTED 4001b7e8: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED rrc = rtems_rfs_inode_load (fs, &handle->shared->inode); 4001b7ec: 7f ff d7 f7 call 400117c8 4001b7f0: 90 10 00 18 mov %i0, %o0 if (rrc == 0) 4001b7f4: 80 a2 20 00 cmp %o0, 0 4001b7f8: 12 80 00 20 bne 4001b878 <== NEVER TAKEN 4001b7fc: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 4001b800: 10 bf ff 76 b 4001b5d8 4001b804: c4 02 60 18 ld [ %o1 + 0x18 ], %g2 printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n", 4001b808: f4 00 60 14 ld [ %g1 + 0x14 ], %i2 <== NOT EXECUTED 4001b80c: 40 00 0f 25 call 4001f4a0 <== NOT EXECUTED 4001b810: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED 4001b814: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 4001b818: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001b81c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4001b820: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 4001b824: 7f ff de d9 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001b828: 90 12 23 60 or %o0, 0x360, %o0 ! 40023f60 <== NOT EXECUTED 4001b82c: 10 bf ff d7 b 4001b788 <== NOT EXECUTED 4001b830: d0 06 60 1c ld [ %i1 + 0x1c ], %o0 <== NOT EXECUTED printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n", 4001b834: f4 00 60 14 ld [ %g1 + 0x14 ], %i2 <== NOT EXECUTED 4001b838: 40 00 0f 1a call 4001f4a0 <== NOT EXECUTED 4001b83c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED 4001b840: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 4001b844: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001b848: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4001b84c: 11 10 00 8f sethi %hi(0x40023c00), %o0 <== NOT EXECUTED 4001b850: 7f ff de ce call 40013388 <__wrap_printf> <== NOT EXECUTED 4001b854: 90 12 23 20 or %o0, 0x320, %o0 ! 40023f20 <== NOT EXECUTED if (rrc == 0) 4001b858: 10 bf ff e1 b 4001b7dc <== NOT EXECUTED 4001b85c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED if (!rtems_rfs_block_size_equal (&handle->shared->size, 4001b860: c6 02 60 40 ld [ %o1 + 0x40 ], %g3 4001b864: 80 a0 80 03 cmp %g2, %g3 4001b868: 32 bf ff 8c bne,a 4001b698 <== NEVER TAKEN 4001b86c: c2 22 60 3c st %g1, [ %o1 + 0x3c ] <== NOT EXECUTED 4001b870: 10 bf ff 8e b 4001b6a8 4001b874: 92 02 60 34 add %o1, 0x34, %o1 if (rrc == 0) 4001b878: 10 bf ff 8b b 4001b6a4 <== NOT EXECUTED 4001b87c: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED =============================================================================== 4001c230 : return _Chain_Immutable_head( the_chain )->next; 4001c230: c2 02 20 74 ld [ %o0 + 0x74 ], %g1 return &the_chain->Tail.Node; 4001c234: 90 02 20 78 add %o0, 0x78, %o0 while (!rtems_chain_is_tail (&fs->file_shares, node)) 4001c238: 80 a0 40 08 cmp %g1, %o0 4001c23c: 22 80 00 10 be,a 4001c27c 4001c240: 82 10 20 00 clr %g1 if (shared->inode.ino == ino) 4001c244: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 4001c248: 80 a2 40 02 cmp %o1, %g2 4001c24c: 32 80 00 08 bne,a 4001c26c <== NEVER TAKEN 4001c250: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED return shared; node = rtems_chain_next (node); } return NULL; } 4001c254: 81 c3 e0 08 retl 4001c258: 90 10 00 01 mov %g1, %o0 if (shared->inode.ino == ino) 4001c25c: 80 a0 80 09 cmp %g2, %o1 <== NOT EXECUTED 4001c260: 22 80 00 08 be,a 4001c280 <== NOT EXECUTED 4001c264: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED 4001c268: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED while (!rtems_chain_is_tail (&fs->file_shares, node)) 4001c26c: 80 a0 40 08 cmp %g1, %o0 <== NOT EXECUTED 4001c270: 32 bf ff fb bne,a 4001c25c <== NOT EXECUTED 4001c274: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 <== NOT EXECUTED return NULL; 4001c278: 82 10 20 00 clr %g1 <== NOT EXECUTED } 4001c27c: 90 10 00 01 mov %g1, %o0 4001c280: 81 c3 e0 08 retl 4001c284: 01 00 00 00 nop =============================================================================== 4001bb0c : { 4001bb0c: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO)) 4001bb10: 90 10 20 20 mov 0x20, %o0 4001bb14: 92 10 20 00 clr %o1 4001bb18: 7f ff dd 8e call 40013150 4001bb1c: ba 10 00 18 mov %i0, %i5 4001bb20: 80 a2 20 00 cmp %o0, 0 4001bb24: 22 80 00 0c be,a 4001bb54 <== ALWAYS TAKEN 4001bb28: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 printf ("rtems-rfs: file-io: end: %s size=%zu\n", 4001bb2c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 4001bb30: 12 80 00 35 bne 4001bc04 <== NOT EXECUTED 4001bb34: 13 10 00 87 sethi %hi(0x40021c00), %o1 <== NOT EXECUTED 4001bb38: 13 10 00 8f sethi %hi(0x40023c00), %o1 <== NOT EXECUTED 4001bb3c: 92 12 63 c8 or %o1, 0x3c8, %o1 ! 40023fc8 <== NOT EXECUTED 4001bb40: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED 4001bb44: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 4001bb48: 7f ff de 10 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001bb4c: 90 12 20 88 or %o0, 0x88, %o0 <== NOT EXECUTED 4001bb50: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED if (rtems_rfs_buffer_handle_has_block (&handle->buffer)) 4001bb54: c4 07 60 0c ld [ %i5 + 0xc ], %g2 4001bb58: 80 a0 a0 00 cmp %g2, 0 4001bb5c: 02 80 00 2c be 4001bc0c <== NEVER TAKEN 4001bb60: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 if (!read) 4001bb64: 80 a6 a0 00 cmp %i2, 0 4001bb68: 02 80 00 14 be 4001bbb8 4001bb6c: 92 07 60 04 add %i5, 4, %o1 rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 4001bb70: 7f ff d0 1d call 4000fbe4 4001bb74: 01 00 00 00 nop if (rc > 0) 4001bb78: b0 92 20 00 orcc %o0, 0, %i0 4001bb7c: 24 80 00 9b ble,a 4001bde8 <== ALWAYS TAKEN 4001bb80: c4 07 60 14 ld [ %i5 + 0x14 ], %g2 printf ( 4001bb84: 40 00 0e 47 call 4001f4a0 <== NOT EXECUTED 4001bb88: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001bb8c: 3b 10 00 87 sethi %hi(0x40021c00), %i5 <== NOT EXECUTED 4001bb90: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED 4001bb94: ba 17 62 40 or %i5, 0x240, %i5 <== NOT EXECUTED 4001bb98: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED 4001bb9c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 4001bba0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001bba4: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED 4001bba8: 7f ff dd f8 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001bbac: 90 12 20 b0 or %o0, 0xb0, %o0 ! 400240b0 <== NOT EXECUTED return rc; 4001bbb0: 81 c7 e0 08 ret <== NOT EXECUTED 4001bbb4: 81 e8 00 00 restore <== NOT EXECUTED rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle)); 4001bbb8: 82 10 20 01 mov 1, %g1 rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 4001bbbc: 7f ff d0 0a call 4000fbe4 4001bbc0: c2 2f 60 04 stb %g1, [ %i5 + 4 ] if (rc > 0) 4001bbc4: b0 92 20 00 orcc %o0, 0, %i0 4001bbc8: 24 80 00 49 ble,a 4001bcec <== ALWAYS TAKEN 4001bbcc: c4 07 60 14 ld [ %i5 + 0x14 ], %g2 printf ( 4001bbd0: 40 00 0e 34 call 4001f4a0 <== NOT EXECUTED 4001bbd4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001bbd8: 3b 10 00 8f sethi %hi(0x40023c00), %i5 <== NOT EXECUTED 4001bbdc: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED 4001bbe0: ba 17 63 c8 or %i5, 0x3c8, %i5 <== NOT EXECUTED 4001bbe4: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED 4001bbe8: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 4001bbec: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001bbf0: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED 4001bbf4: 7f ff dd e5 call 40013388 <__wrap_printf> <== NOT EXECUTED 4001bbf8: 90 12 20 b0 or %o0, 0xb0, %o0 ! 400240b0 <== NOT EXECUTED return rc; 4001bbfc: 81 c7 e0 08 ret <== NOT EXECUTED 4001bc00: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: file-io: end: %s size=%zu\n", 4001bc04: 10 bf ff cf b 4001bb40 <== NOT EXECUTED 4001bc08: 92 12 62 40 or %o1, 0x240, %o1 <== NOT EXECUTED handle->bpos.boff += size; 4001bc0c: c4 07 60 14 ld [ %i5 + 0x14 ], %g2 <== NOT EXECUTED 4001bc10: b2 06 40 02 add %i1, %g2, %i1 <== NOT EXECUTED 4001bc14: f2 27 60 14 st %i1, [ %i5 + 0x14 ] <== NOT EXECUTED 4001bc18: 86 1e a0 01 xor %i2, 1, %g3 <== NOT EXECUTED rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) 4001bc1c: c4 02 20 08 ld [ %o0 + 8 ], %g2 <== NOT EXECUTED if (handle->bpos.boff >= 4001bc20: 80 a6 40 02 cmp %i1, %g2 <== NOT EXECUTED 4001bc24: 1a 80 00 3a bcc 4001bd0c <== NOT EXECUTED 4001bc28: b0 10 20 00 clr %i0 <== NOT EXECUTED if (!read && 4001bc2c: 80 a6 a0 00 cmp %i2, 0 4001bc30: 12 80 00 0e bne 4001bc68 4001bc34: 84 10 20 00 clr %g2 rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle), 4001bc38: f8 07 60 10 ld [ %i5 + 0x10 ], %i4 if (!read && 4001bc3c: 80 a7 20 00 cmp %i4, 0 4001bc40: 02 80 00 39 be 4001bd24 4001bc44: c4 00 60 3c ld [ %g1 + 0x3c ], %g2 rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle), 4001bc48: 80 a0 a0 00 cmp %g2, 0 4001bc4c: 12 80 00 37 bne 4001bd28 <== ALWAYS TAKEN 4001bc50: 80 a7 00 02 cmp %i4, %g2 4001bc54: c8 07 60 14 ld [ %i5 + 0x14 ], %g4 <== NOT EXECUTED map->size.offset = offset; 4001bc58: c8 20 60 40 st %g4, [ %g1 + 0x40 ] map->dirty = true; 4001bc5c: 88 10 20 01 mov 1, %g4 4001bc60: c8 28 60 34 stb %g4, [ %g1 + 0x34 ] length = true; 4001bc64: 84 10 20 01 mov 1, %g2 atime = rtems_rfs_file_update_atime (handle); 4001bc68: e0 07 40 00 ld [ %i5 ], %l0 if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO)) 4001bc6c: 90 10 20 20 mov 0x20, %o0 4001bc70: 92 10 20 00 clr %o1 atime = rtems_rfs_file_update_atime (handle); 4001bc74: b2 38 00 10 xnor %g0, %l0, %i1 mtime = rtems_rfs_file_update_mtime (handle) && mtime; 4001bc78: b9 34 20 01 srl %l0, 1, %i4 length = rtems_rfs_file_update_length (handle) && length; 4001bc7c: b7 34 20 02 srl %l0, 2, %i3 mtime = rtems_rfs_file_update_mtime (handle) && mtime; 4001bc80: b8 1f 20 01 xor %i4, 1, %i4 length = rtems_rfs_file_update_length (handle) && length; 4001bc84: b6 1e e0 01 xor %i3, 1, %i3 mtime = rtems_rfs_file_update_mtime (handle) && mtime; 4001bc88: b8 0f 20 01 and %i4, 1, %i4 length = rtems_rfs_file_update_length (handle) && length; 4001bc8c: b6 0e e0 01 and %i3, 1, %i3 mtime = rtems_rfs_file_update_mtime (handle) && mtime; 4001bc90: b8 0f 00 03 and %i4, %g3, %i4 length = rtems_rfs_file_update_length (handle) && length; 4001bc94: b6 0e c0 02 and %i3, %g2, %i3 if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO)) 4001bc98: 7f ff dd 2e call 40013150 4001bc9c: b2 0e 60 01 and %i1, 1, %i1 4001bca0: 80 a2 20 00 cmp %o0, 0 4001bca4: 32 80 00 30 bne,a 4001bd64 <== NEVER TAKEN 4001bca8: d4 07 60 14 ld [ %i5 + 0x14 ], %o2 <== NOT EXECUTED 4001bcac: b8 0f 20 ff and %i4, 0xff, %i4 4001bcb0: b6 0e e0 ff and %i3, 0xff, %i3 if (atime || mtime) 4001bcb4: b2 8e 60 ff andcc %i1, 0xff, %i1 4001bcb8: 12 80 00 3d bne 4001bdac <== ALWAYS TAKEN 4001bcbc: 80 a7 20 00 cmp %i4, 0 4001bcc0: 12 80 00 3b bne 4001bdac <== NOT EXECUTED 4001bcc4: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED if (length) 4001bcc8: 02 80 00 25 be 4001bd5c 4001bccc: 01 00 00 00 nop rtems_rfs_block_map_count (rtems_rfs_file_map (handle)); 4001bcd0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 handle->shared->size.count = 4001bcd4: c6 00 60 3c ld [ %g1 + 0x3c ], %g3 handle->shared->size.offset = 4001bcd8: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 handle->shared->size.count = 4001bcdc: c6 20 60 84 st %g3, [ %g1 + 0x84 ] handle->shared->size.offset = 4001bce0: c4 20 60 88 st %g2, [ %g1 + 0x88 ] 4001bce4: 81 c7 e0 08 ret 4001bce8: 81 e8 00 00 restore rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) 4001bcec: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 handle->bpos.boff += size; 4001bcf0: b2 06 40 02 add %i1, %g2, %i1 rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) 4001bcf4: c4 00 60 98 ld [ %g1 + 0x98 ], %g2 handle->bpos.boff += size; 4001bcf8: f2 27 60 14 st %i1, [ %i5 + 0x14 ] rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) 4001bcfc: c4 00 a0 08 ld [ %g2 + 8 ], %g2 if (handle->bpos.boff >= 4001bd00: 80 a0 80 19 cmp %g2, %i1 4001bd04: 18 bf ff cd bgu 4001bc38 4001bd08: 86 10 20 01 mov 1, %g3 handle->bpos.bno++; 4001bd0c: c8 07 60 10 ld [ %i5 + 0x10 ], %g4 4001bd10: 88 01 20 01 inc %g4 handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)); 4001bd14: b2 26 40 02 sub %i1, %g2, %i1 handle->bpos.bno++; 4001bd18: c8 27 60 10 st %g4, [ %i5 + 0x10 ] handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)); 4001bd1c: 10 bf ff c4 b 4001bc2c 4001bd20: f2 27 60 14 st %i1, [ %i5 + 0x14 ] rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle), 4001bd24: 80 a7 00 02 cmp %i4, %g2 4001bd28: 3a bf ff cc bcc,a 4001bc58 4001bd2c: c8 07 60 14 ld [ %i5 + 0x14 ], %g4 4001bd30: 88 00 bf ff add %g2, -1, %g4 4001bd34: 80 a7 00 04 cmp %i4, %g4 4001bd38: 12 bf ff cc bne 4001bc68 4001bd3c: 84 10 20 00 clr %g2 4001bd40: c8 07 60 14 ld [ %i5 + 0x14 ], %g4 4001bd44: f8 00 60 40 ld [ %g1 + 0x40 ], %i4 4001bd48: 80 a1 00 1c cmp %g4, %i4 4001bd4c: 28 bf ff c8 bleu,a 4001bc6c 4001bd50: e0 07 40 00 ld [ %i5 ], %l0 4001bd54: 10 bf ff c2 b 4001bc5c 4001bd58: c8 20 60 40 st %g4, [ %g1 + 0x40 ] } 4001bd5c: 81 c7 e0 08 ret 4001bd60: 81 e8 00 00 restore printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n", 4001bd64: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED 4001bd68: 96 0c 20 01 and %l0, 1, %o3 <== NOT EXECUTED 4001bd6c: b8 0f 20 ff and %i4, 0xff, %i4 <== NOT EXECUTED 4001bd70: b6 0e e0 ff and %i3, 0xff, %i3 <== NOT EXECUTED 4001bd74: 98 07 3f ff add %i4, -1, %o4 <== NOT EXECUTED 4001bd78: 9a 06 ff ff add %i3, -1, %o5 <== NOT EXECUTED 4001bd7c: 96 20 00 0b neg %o3 <== NOT EXECUTED 4001bd80: 98 0b 3f e0 and %o4, -32, %o4 <== NOT EXECUTED 4001bd84: 96 0a ff ec and %o3, -20, %o3 <== NOT EXECUTED 4001bd88: 98 03 20 4d add %o4, 0x4d, %o4 <== NOT EXECUTED 4001bd8c: 9a 0b 7f e1 and %o5, -31, %o5 <== NOT EXECUTED 4001bd90: 96 02 e0 41 add %o3, 0x41, %o3 <== NOT EXECUTED 4001bd94: 9a 03 60 4c add %o5, 0x4c, %o5 <== NOT EXECUTED 4001bd98: 11 10 00 90 sethi %hi(0x40024000), %o0 <== NOT EXECUTED 4001bd9c: 7f ff dd 7b call 40013388 <__wrap_printf> <== NOT EXECUTED 4001bda0: 90 12 20 f8 or %o0, 0xf8, %o0 ! 400240f8 <== NOT EXECUTED if (atime || mtime) 4001bda4: 10 bf ff c5 b 4001bcb8 <== NOT EXECUTED 4001bda8: b2 8e 60 ff andcc %i1, 0xff, %i1 <== NOT EXECUTED time_t now = time (NULL); 4001bdac: 40 00 0e ed call 4001f960