=============================================================================== 4001a964 : int rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control) { 4001a964: 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); 4001a968: 90 10 00 18 mov %i0, %o0 { 4001a96c: ba 10 00 18 mov %i0, %i5 rc = rtems_rfs_bitmap_load_map (control, &map); 4001a970: 7f ff fe 93 call 4001a3bc 4001a974: 92 07 bf fc add %fp, -4, %o1 if (rc > 0) 4001a978: b0 92 20 00 orcc %o0, 0, %i0 4001a97c: 24 80 00 04 ble,a 4001a98c <== ALWAYS TAKEN 4001a980: c0 27 60 10 clr [ %i5 + 0x10 ] bit++; map++; } return 0; } 4001a984: 81 c7 e0 08 ret <== NOT EXECUTED 4001a988: 81 e8 00 00 restore <== NOT EXECUTED *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR; 4001a98c: 82 10 3f ff mov -1, %g1 search_map = control->search_bits; 4001a990: f0 07 60 14 ld [ %i5 + 0x14 ], %i0 size = control->size; 4001a994: c6 07 60 0c ld [ %i5 + 0xc ], %g3 while (size) 4001a998: 80 a0 e0 00 cmp %g3, 0 4001a99c: 02 80 00 31 be 4001aa60 <== NEVER TAKEN 4001a9a0: c2 26 00 00 st %g1, [ %i0 ] 4001a9a4: f8 07 bf fc ld [ %fp + -4 ], %i4 bit = 0; 4001a9a8: b4 10 20 00 clr %i2 available = rtems_rfs_bitmap_element_bits (); 4001a9ac: 9a 10 20 20 mov 0x20, %o5 mask >>= (rtems_rfs_bitmap_element_bits () - size); 4001a9b0: 9e 10 3f ff mov -1, %o7 return RTEMS_RFS_BITMAP_TEST_BIT (target, bit); 4001a9b4: 10 80 00 10 b 4001a9f4 4001a9b8: b2 10 20 01 mov 1, %i1 mask >>= (rtems_rfs_bitmap_element_bits () - size); 4001a9bc: 82 23 40 03 sub %o5, %g3, %g1 available = size; 4001a9c0: b6 10 00 03 mov %g3, %i3 mask >>= (rtems_rfs_bitmap_element_bits () - size); 4001a9c4: 83 33 c0 01 srl %o7, %g1, %g1 4001a9c8: 84 08 80 01 and %g2, %g1, %g2 if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET)) 4001a9cc: 80 a0 a0 00 cmp %g2, 0 4001a9d0: 12 80 00 10 bne 4001aa10 <== ALWAYS TAKEN 4001a9d4: 86 10 20 00 clr %g3 if (bit == (rtems_rfs_bitmap_element_bits () - 1)) 4001a9d8: 80 a6 a0 1f cmp %i2, 0x1f <== NOT EXECUTED 4001a9dc: 22 80 00 1c be,a 4001aa4c <== NOT EXECUTED 4001a9e0: de 26 20 04 st %o7, [ %i0 + 4 ] <== NOT EXECUTED bit++; 4001a9e4: b4 06 a0 01 inc %i2 <== NOT EXECUTED while (size) 4001a9e8: 80 a0 e0 00 cmp %g3, 0 4001a9ec: 02 80 00 1d be 4001aa60 4001a9f0: b8 07 20 04 add %i4, 4, %i4 if (size < rtems_rfs_bitmap_element_bits ()) 4001a9f4: 80 a0 e0 1f cmp %g3, 0x1f 4001a9f8: 08 bf ff f1 bleu 4001a9bc 4001a9fc: c4 07 00 00 ld [ %i4 ], %g2 4001aa00: 86 00 ff e0 add %g3, -32, %g3 if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET)) 4001aa04: 80 a0 a0 00 cmp %g2, 0 4001aa08: 02 bf ff f4 be 4001a9d8 <== NEVER TAKEN 4001aa0c: b6 10 20 20 mov 0x20, %i3 for (b = 0; b < available; b++) 4001aa10: 82 10 20 00 clr %g1 return RTEMS_RFS_BITMAP_TEST_BIT (target, bit); 4001aa14: 89 2e 40 01 sll %i1, %g1, %g4 if (!rtems_rfs_bitmap_test (bits, b)) 4001aa18: 80 89 00 02 btst %g4, %g2 4001aa1c: 02 80 00 05 be 4001aa30 4001aa20: 82 00 60 01 inc %g1 control->free++; 4001aa24: c8 07 60 10 ld [ %i5 + 0x10 ], %g4 4001aa28: 88 01 20 01 inc %g4 4001aa2c: c8 27 60 10 st %g4, [ %i5 + 0x10 ] for (b = 0; b < available; b++) 4001aa30: 80 a6 c0 01 cmp %i3, %g1 4001aa34: 12 bf ff f9 bne 4001aa18 4001aa38: 89 2e 40 01 sll %i1, %g1, %g4 if (bit == (rtems_rfs_bitmap_element_bits () - 1)) 4001aa3c: 80 a6 a0 1f cmp %i2, 0x1f 4001aa40: 12 bf ff ea bne 4001a9e8 <== ALWAYS TAKEN 4001aa44: b4 06 a0 01 inc %i2 *search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR; 4001aa48: de 26 20 04 st %o7, [ %i0 + 4 ] <== NOT EXECUTED bit = 0; 4001aa4c: b4 10 20 00 clr %i2 <== NOT EXECUTED search_map++; 4001aa50: b0 06 20 04 add %i0, 4, %i0 <== NOT EXECUTED while (size) 4001aa54: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED 4001aa58: 12 bf ff e7 bne 4001a9f4 <== NOT EXECUTED 4001aa5c: b8 07 20 04 add %i4, 4, %i4 <== NOT EXECUTED } 4001aa60: 81 c7 e0 08 ret 4001aa64: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 4001a860 : int rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control, rtems_rfs_bitmap_bit seed, bool* allocated, rtems_rfs_bitmap_bit* bit) { 4001a860: 9d e3 bf a0 save %sp, -96, %sp int rc = 0; /* * By default we assume the allocation failed. */ *allocated = false; 4001a864: 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; 4001a868: 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)) 4001a86c: 80 a6 60 00 cmp %i1, 0 4001a870: 06 80 00 1e bl 4001a8e8 <== NEVER TAKEN 4001a874: 80 a7 60 00 cmp %i5, 0 4001a878: c2 06 20 0c ld [ %i0 + 0xc ], %g1 4001a87c: 80 a0 40 19 cmp %g1, %i1 4001a880: 08 80 00 1a bleu 4001a8e8 4001a884: 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; 4001a888: f2 26 c0 00 st %i1, [ %i3 ] rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated, 4001a88c: 96 10 20 01 mov 1, %o3 4001a890: 94 10 00 1a mov %i2, %o2 4001a894: 92 10 00 1b mov %i3, %o1 4001a898: 7f ff fe dd call 4001a40c 4001a89c: 90 10 00 18 mov %i0, %o0 window, 1); if ((rc > 0) || *allocated) 4001a8a0: 80 a2 20 00 cmp %o0, 0 4001a8a4: 14 80 00 2c bg 4001a954 <== NEVER TAKEN 4001a8a8: 01 00 00 00 nop 4001a8ac: c2 0e 80 00 ldub [ %i2 ], %g1 4001a8b0: 80 a0 60 00 cmp %g1, 0 4001a8b4: 12 80 00 28 bne 4001a954 4001a8b8: 80 a7 60 00 cmp %i5, 0 break; } if (lower_seed >= 0) 4001a8bc: 36 80 00 14 bge,a 4001a90c <== ALWAYS TAKEN 4001a8c0: 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) 4001a8c4: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED 4001a8c8: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED 4001a8cc: 1a bf ff e9 bcc 4001a870 <== NOT EXECUTED 4001a8d0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED upper_seed += window; 4001a8d4: b2 06 68 00 add %i1, 0x800, %i1 <== NOT EXECUTED while (((upper_seed >= 0) && (upper_seed < control->size)) 4001a8d8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 4001a8dc: 16 bf ff e9 bge 4001a880 <== NOT EXECUTED 4001a8e0: 80 a0 40 19 cmp %g1, %i1 <== NOT EXECUTED || ((lower_seed >= 0) && (lower_seed < control->size))) 4001a8e4: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED 4001a8e8: 06 80 00 1b bl 4001a954 <== ALWAYS TAKEN 4001a8ec: 01 00 00 00 nop 4001a8f0: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED 4001a8f4: 80 a0 40 1d cmp %g1, %i5 <== NOT EXECUTED 4001a8f8: 08 80 00 17 bleu 4001a954 <== NOT EXECUTED 4001a8fc: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED if (upper_seed < control->size) 4001a900: 2a bf ff e3 bcs,a 4001a88c <== NOT EXECUTED 4001a904: f2 26 c0 00 st %i1, [ %i3 ] <== NOT EXECUTED *bit = lower_seed; 4001a908: fa 26 c0 00 st %i5, [ %i3 ] <== NOT EXECUTED rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated, 4001a90c: 96 10 3f ff mov -1, %o3 4001a910: 94 10 00 1a mov %i2, %o2 4001a914: 92 10 00 1b mov %i3, %o1 4001a918: 7f ff fe bd call 4001a40c 4001a91c: 90 10 00 18 mov %i0, %o0 if ((rc > 0) || *allocated) 4001a920: 80 a2 20 00 cmp %o0, 0 4001a924: 14 80 00 0c bg 4001a954 <== NEVER TAKEN 4001a928: 01 00 00 00 nop 4001a92c: c2 0e 80 00 ldub [ %i2 ], %g1 4001a930: 80 a0 60 00 cmp %g1, 0 4001a934: 12 80 00 08 bne 4001a954 4001a938: 01 00 00 00 nop if (upper_seed < control->size) 4001a93c: c2 06 20 0c ld [ %i0 + 0xc ], %g1 4001a940: 80 a6 40 01 cmp %i1, %g1 4001a944: 2a 80 00 06 bcs,a 4001a95c <== ALWAYS TAKEN 4001a948: b2 06 68 00 add %i1, 0x800, %i1 if (lower_seed >= 0) lower_seed -= window; 4001a94c: 10 bf ff c8 b 4001a86c <== NOT EXECUTED 4001a950: ba 07 78 00 add %i5, -2048, %i5 <== NOT EXECUTED } return 0; } 4001a954: 81 c7 e0 08 ret 4001a958: 91 e8 20 00 restore %g0, 0, %o0 lower_seed -= window; 4001a95c: 10 bf ff c4 b 4001a86c 4001a960: ba 07 78 00 add %i5, -2048, %i5 =============================================================================== 4001a704 : { 4001a704: 9d e3 bf 98 save %sp, -104, %sp rc = rtems_rfs_bitmap_load_map (control, &map); 4001a708: 92 07 bf fc add %fp, -4, %o1 4001a70c: 7f ff ff 2c call 4001a3bc 4001a710: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001a714: 80 a2 20 00 cmp %o0, 0 4001a718: 24 80 00 04 ble,a 4001a728 <== ALWAYS TAKEN 4001a71c: c2 06 20 0c ld [ %i0 + 0xc ], %g1 } 4001a720: 81 c7 e0 08 ret <== NOT EXECUTED 4001a724: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED if (bit >= control->size) 4001a728: 80 a0 40 19 cmp %g1, %i1 4001a72c: 08 bf ff fd bleu 4001a720 <== NEVER TAKEN 4001a730: 90 10 20 16 mov 0x16, %o0 element = map[index]; 4001a734: f8 07 bf fc ld [ %fp + -4 ], %i4 index = rtems_rfs_bitmap_map_index (bit); 4001a738: 85 3e 60 05 sra %i1, 5, %g2 element = map[index]; 4001a73c: bb 28 a0 02 sll %g2, 2, %i5 4001a740: c8 07 00 1d ld [ %i4 + %i5 ], %g4 search_map = control->search_bits; 4001a744: f6 06 20 14 ld [ %i0 + 0x14 ], %i3 map[index] = rtems_rfs_bitmap_clear (element, 1 << offset); 4001a748: 86 10 20 01 mov 1, %g3 4001a74c: 83 28 c0 19 sll %g3, %i1, %g1 return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits); 4001a750: 82 10 40 04 or %g1, %g4, %g1 map[index] = rtems_rfs_bitmap_clear (element, 1 << offset); 4001a754: c2 27 00 1d st %g1, [ %i4 + %i5 ] if (rtems_rfs_bitmap_match(element, map[index])) 4001a758: 80 a1 00 01 cmp %g4, %g1 4001a75c: 02 bf ff f1 be 4001a720 <== NEVER TAKEN 4001a760: 90 10 20 00 clr %o0 index = rtems_rfs_bitmap_map_index (bit); 4001a764: b3 3e 60 0a sra %i1, 0xa, %i1 search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset); 4001a768: b3 2e 60 02 sll %i1, 2, %i1 return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits); 4001a76c: c2 06 c0 19 ld [ %i3 + %i1 ], %g1 rtems_rfs_buffer_mark_dirty (control->buffer); 4001a770: c8 06 00 00 ld [ %i0 ], %g4 search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset); 4001a774: 85 28 c0 02 sll %g3, %g2, %g2 return RTEMS_RFS_BITMAP_CLEAR_BITS (target, bits); 4001a778: 84 10 40 02 or %g1, %g2, %g2 search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset); 4001a77c: c4 26 c0 19 st %g2, [ %i3 + %i1 ] control->free++; 4001a780: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 rtems_rfs_buffer_mark_dirty (control->buffer); 4001a784: c6 29 00 00 stb %g3, [ %g4 ] control->free++; 4001a788: 82 00 60 01 inc %g1 4001a78c: c2 26 20 10 st %g1, [ %i0 + 0x10 ] } 4001a790: 81 c7 e0 08 ret 4001a794: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 4001a798 : { 4001a798: 9d e3 bf 98 save %sp, -104, %sp rc = rtems_rfs_bitmap_load_map (control, &map); 4001a79c: 90 10 00 18 mov %i0, %o0 { 4001a7a0: ba 10 00 18 mov %i0, %i5 rc = rtems_rfs_bitmap_load_map (control, &map); 4001a7a4: 7f ff ff 06 call 4001a3bc 4001a7a8: 92 07 bf fc add %fp, -4, %o1 if (rc > 0) 4001a7ac: b0 92 20 00 orcc %o0, 0, %i0 4001a7b0: 24 80 00 04 ble,a 4001a7c0 <== ALWAYS TAKEN 4001a7b4: c4 07 60 0c ld [ %i5 + 0xc ], %g2 } 4001a7b8: 81 c7 e0 08 ret <== NOT EXECUTED 4001a7bc: 81 e8 00 00 restore <== NOT EXECUTED elements = rtems_rfs_bitmap_elements (control->size); 4001a7c0: 86 00 bf ff add %g2, -1, %g3 control->free = control->size; 4001a7c4: c4 27 60 10 st %g2, [ %i5 + 0x10 ] elements = rtems_rfs_bitmap_elements (control->size); 4001a7c8: b9 30 e0 05 srl %g3, 5, %i4 4001a7cc: c4 07 bf fc ld [ %fp + -4 ], %g2 4001a7d0: 89 2f 20 02 sll %i4, 2, %g4 4001a7d4: 82 00 a0 04 add %g2, 4, %g1 4001a7d8: b8 07 20 01 inc %i4 4001a7dc: 88 00 40 04 add %g1, %g4, %g4 map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR; 4001a7e0: 10 80 00 03 b 4001a7ec 4001a7e4: b6 10 3f ff mov -1, %i3 4001a7e8: 82 00 60 04 add %g1, 4, %g1 4001a7ec: f6 20 80 00 st %i3, [ %g2 ] for (e = 0; e < elements; e++) 4001a7f0: 80 a1 00 01 cmp %g4, %g1 4001a7f4: 12 bf ff fd bne 4001a7e8 4001a7f8: 84 10 00 01 mov %g1, %g2 if (last_search_bit == 0) 4001a7fc: b8 8f 20 1f andcc %i4, 0x1f, %i4 4001a800: 02 80 00 04 be 4001a810 <== NEVER TAKEN 4001a804: b4 10 3f ff mov -1, %i2 4001a808: b8 20 00 1c neg %i4 4001a80c: b5 36 c0 1c srl %i3, %i4, %i2 elements = rtems_rfs_bitmap_elements (elements); 4001a810: 85 30 e0 0a srl %g3, 0xa, %g2 for (e = 0; e < (elements - 1); e++) 4001a814: 80 a0 a0 00 cmp %g2, 0 4001a818: 02 80 00 0b be 4001a844 <== ALWAYS TAKEN 4001a81c: f6 07 60 14 ld [ %i5 + 0x14 ], %i3 4001a820: 87 28 a0 02 sll %g2, 2, %g3 <== NOT EXECUTED 4001a824: 82 10 00 1b mov %i3, %g1 <== NOT EXECUTED 4001a828: 86 00 c0 1b add %g3, %i3, %g3 <== NOT EXECUTED control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR; 4001a82c: 88 10 3f ff mov -1, %g4 <== NOT EXECUTED 4001a830: c8 20 40 00 st %g4, [ %g1 ] <== NOT EXECUTED 4001a834: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED for (e = 0; e < (elements - 1); e++) 4001a838: 80 a0 c0 01 cmp %g3, %g1 <== NOT EXECUTED 4001a83c: 32 bf ff fe bne,a 4001a834 <== NOT EXECUTED 4001a840: c8 20 40 00 st %g4, [ %g1 ] <== NOT EXECUTED rtems_rfs_buffer_mark_dirty (control->buffer); 4001a844: c2 07 40 00 ld [ %i5 ], %g1 control->search_bits[elements - 1] = 4001a848: 85 28 a0 02 sll %g2, 2, %g2 4001a84c: f4 26 c0 02 st %i2, [ %i3 + %g2 ] rtems_rfs_buffer_mark_dirty (control->buffer); 4001a850: 84 10 20 01 mov 1, %g2 4001a854: c4 28 40 00 stb %g2, [ %g1 ] } 4001a858: 81 c7 e0 08 ret 4001a85c: 91 e8 20 00 restore %g0, 0, %o0 =============================================================================== 4001a668 : { 4001a668: 9d e3 bf 98 save %sp, -104, %sp rc = rtems_rfs_bitmap_load_map (control, &map); 4001a66c: 92 07 bf fc add %fp, -4, %o1 4001a670: 7f ff ff 53 call 4001a3bc 4001a674: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001a678: 80 a2 20 00 cmp %o0, 0 4001a67c: 24 80 00 04 ble,a 4001a68c <== ALWAYS TAKEN 4001a680: c2 06 20 0c ld [ %i0 + 0xc ], %g1 } 4001a684: 81 c7 e0 08 ret <== NOT EXECUTED 4001a688: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED if (bit >= control->size) 4001a68c: 80 a0 40 19 cmp %g1, %i1 4001a690: 08 bf ff fd bleu 4001a684 <== NEVER TAKEN 4001a694: 90 10 20 16 mov 0x16, %o0 element = map[index]; 4001a698: fa 07 bf fc ld [ %fp + -4 ], %i5 index = rtems_rfs_bitmap_map_index (bit); 4001a69c: b9 3e 60 05 sra %i1, 5, %i4 element = map[index]; 4001a6a0: 89 2f 20 02 sll %i4, 2, %g4 4001a6a4: c6 07 40 04 ld [ %i5 + %g4 ], %g3 search_map = control->search_bits; 4001a6a8: f6 06 20 14 ld [ %i0 + 0x14 ], %i3 map[index] = rtems_rfs_bitmap_set (element, 1 << offset); 4001a6ac: 84 10 20 01 mov 1, %g2 4001a6b0: 83 28 80 19 sll %g2, %i1, %g1 return RTEMS_RFS_BITMAP_SET_BITS (target, bits); 4001a6b4: 82 28 c0 01 andn %g3, %g1, %g1 if (rtems_rfs_bitmap_match(element, map[index])) 4001a6b8: 80 a0 c0 01 cmp %g3, %g1 4001a6bc: 02 80 00 0f be 4001a6f8 <== NEVER TAKEN 4001a6c0: c2 27 40 04 st %g1, [ %i5 + %g4 ] control->free--; 4001a6c4: c6 06 20 10 ld [ %i0 + 0x10 ], %g3 4001a6c8: 86 00 ff ff add %g3, -1, %g3 rtems_rfs_buffer_mark_dirty (control->buffer); 4001a6cc: c8 06 00 00 ld [ %i0 ], %g4 control->free--; 4001a6d0: c6 26 20 10 st %g3, [ %i0 + 0x10 ] if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET)) 4001a6d4: 80 a0 60 00 cmp %g1, 0 4001a6d8: 12 80 00 08 bne 4001a6f8 <== ALWAYS TAKEN 4001a6dc: c4 29 00 00 stb %g2, [ %g4 ] index = rtems_rfs_bitmap_map_index (bit); 4001a6e0: b3 3e 60 0a sra %i1, 0xa, %i1 <== NOT EXECUTED search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset); 4001a6e4: b3 2e 60 02 sll %i1, 2, %i1 <== NOT EXECUTED return RTEMS_RFS_BITMAP_SET_BITS (target, bits); 4001a6e8: c2 06 c0 19 ld [ %i3 + %i1 ], %g1 <== NOT EXECUTED search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset); 4001a6ec: 85 28 80 1c sll %g2, %i4, %g2 <== NOT EXECUTED return RTEMS_RFS_BITMAP_SET_BITS (target, bits); 4001a6f0: 84 28 40 02 andn %g1, %g2, %g2 <== NOT EXECUTED search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset); 4001a6f4: c4 26 c0 19 st %g2, [ %i3 + %i1 ] <== NOT EXECUTED return 0; 4001a6f8: 90 10 20 00 clr %o0 } 4001a6fc: 81 c7 e0 08 ret 4001a700: 91 e8 00 08 restore %g0, %o0, %o0 =============================================================================== 4001aa68 : rtems_rfs_bitmap_open (rtems_rfs_bitmap_control* control, rtems_rfs_file_system* fs, rtems_rfs_buffer_handle* buffer, size_t size, rtems_rfs_buffer_block block) { 4001aa68: 9d e3 bf a0 save %sp, -96, %sp size_t elements = rtems_rfs_bitmap_elements (size); control->buffer = buffer; 4001aa6c: f4 26 00 00 st %i2, [ %i0 ] size_t elements = rtems_rfs_bitmap_elements (size); 4001aa70: 90 06 ff ff add %i3, -1, %o0 control->fs = fs; 4001aa74: f2 26 20 04 st %i1, [ %i0 + 4 ] control->block = block; control->size = size; elements = rtems_rfs_bitmap_elements (elements); 4001aa78: 91 32 20 0a srl %o0, 0xa, %o0 control->block = block; 4001aa7c: f8 26 20 08 st %i4, [ %i0 + 8 ] elements = rtems_rfs_bitmap_elements (elements); 4001aa80: 90 02 20 01 inc %o0 control->size = size; 4001aa84: f6 26 20 0c st %i3, [ %i0 + 0xc ] control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element)); 4001aa88: 7f ff bc 62 call 40009c10 4001aa8c: 91 2a 20 02 sll %o0, 2, %o0 if (!control->search_bits) 4001aa90: 80 a2 20 00 cmp %o0, 0 4001aa94: 02 80 00 04 be 4001aaa4 <== NEVER TAKEN 4001aa98: d0 26 20 14 st %o0, [ %i0 + 0x14 ] return ENOMEM; return rtems_rfs_bitmap_create_search (control); 4001aa9c: 7f ff ff b2 call 4001a964 4001aaa0: 81 e8 00 00 restore } 4001aaa4: 81 c7 e0 08 ret <== NOT EXECUTED 4001aaa8: 91 e8 20 0c restore %g0, 0xc, %o0 <== NOT EXECUTED =============================================================================== 4001afc8 : { 4001afc8: 9d e3 bf a0 save %sp, -96, %sp if (map->dirty && map->inode) 4001afcc: c2 0e 40 00 ldub [ %i1 ], %g1 4001afd0: 80 a0 60 00 cmp %g1, 0 4001afd4: 02 80 00 5f be 4001b150 4001afd8: ba 10 00 18 mov %i0, %i5 4001afdc: d2 06 60 04 ld [ %i1 + 4 ], %o1 4001afe0: 80 a2 60 00 cmp %o1, 0 4001afe4: 02 80 00 5b be 4001b150 <== NEVER TAKEN 4001afe8: 90 10 00 18 mov %i0, %o0 brc = rtems_rfs_inode_load (fs, map->inode); 4001afec: 7f ff e1 b0 call 400136ac 4001aff0: b8 06 60 38 add %i1, 0x38, %i4 if (brc > 0) 4001aff4: 80 a2 20 00 cmp %o0, 0 4001aff8: 14 80 00 58 bg 4001b158 <== NEVER TAKEN 4001affc: b0 10 00 08 mov %o0, %i0 4001b000: 9e 10 3f f8 mov -8, %o7 4001b004: 84 06 60 24 add %i1, 0x24, %g2 4001b008: 9e 23 c0 19 sub %o7, %i1, %o7 rtems_rfs_buffer_mark_dirty (&handle->buffer); 4001b00c: b0 10 20 01 mov 1, %i0 rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]); 4001b010: c2 06 60 04 ld [ %i1 + 4 ], %g1 4001b014: c6 00 80 00 ld [ %g2 ], %g3 rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno); 4001b018: f6 00 60 0c ld [ %g1 + 0xc ], %i3 4001b01c: 88 03 c0 02 add %o7, %g2, %g4 4001b020: b5 30 e0 18 srl %g3, 0x18, %i2 4001b024: f4 2e c0 04 stb %i2, [ %i3 + %g4 ] 4001b028: b5 30 e0 10 srl %g3, 0x10, %i2 4001b02c: f6 00 60 0c ld [ %g1 + 0xc ], %i3 4001b030: b6 06 c0 04 add %i3, %g4, %i3 4001b034: f4 2e e0 01 stb %i2, [ %i3 + 1 ] 4001b038: b5 30 e0 08 srl %g3, 8, %i2 4001b03c: f6 00 60 0c ld [ %g1 + 0xc ], %i3 4001b040: b6 06 c0 04 add %i3, %g4, %i3 4001b044: f4 2e e0 02 stb %i2, [ %i3 + 2 ] 4001b048: 84 00 a0 04 add %g2, 4, %g2 4001b04c: f6 00 60 0c ld [ %g1 + 0xc ], %i3 4001b050: 88 06 c0 04 add %i3, %g4, %g4 4001b054: c6 29 20 03 stb %g3, [ %g4 + 3 ] for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++) 4001b058: 80 a7 00 02 cmp %i4, %g2 4001b05c: 12 bf ff ed bne 4001b010 4001b060: f0 28 60 10 stb %i0, [ %g1 + 0x10 ] rtems_rfs_inode_set_block_count (map->inode, map->size.count); 4001b064: c2 06 60 04 ld [ %i1 + 4 ], %g1 4001b068: c4 06 60 08 ld [ %i1 + 8 ], %g2 rtems_rfs_write_u32 (&handle->node->block_count, block_count); 4001b06c: c6 00 60 0c ld [ %g1 + 0xc ], %g3 4001b070: 89 30 a0 18 srl %g2, 0x18, %g4 4001b074: c8 28 e0 0c stb %g4, [ %g3 + 0xc ] 4001b078: 89 30 a0 10 srl %g2, 0x10, %g4 4001b07c: c6 00 60 0c ld [ %g1 + 0xc ], %g3 4001b080: c8 28 e0 0d stb %g4, [ %g3 + 0xd ] 4001b084: 89 30 a0 08 srl %g2, 8, %g4 4001b088: c6 00 60 0c ld [ %g1 + 0xc ], %g3 4001b08c: c8 28 e0 0e stb %g4, [ %g3 + 0xe ] brc = rtems_rfs_inode_unload (fs, map->inode, true); 4001b090: 94 10 20 01 mov 1, %o2 4001b094: c6 00 60 0c ld [ %g1 + 0xc ], %g3 4001b098: c4 28 e0 0f stb %g2, [ %g3 + 0xf ] 4001b09c: 90 10 00 1d mov %i5, %o0 rtems_rfs_inode_set_block_offset (map->inode, map->size.offset); 4001b0a0: c6 06 60 04 ld [ %i1 + 4 ], %g3 rtems_rfs_write_u16 (&handle->node->block_offset, block_offset); 4001b0a4: c8 0e 60 0e ldub [ %i1 + 0xe ], %g4 rtems_rfs_buffer_mark_dirty (&handle->buffer); 4001b0a8: f0 28 60 10 stb %i0, [ %g1 + 0x10 ] rtems_rfs_write_u16 (&handle->node->block_offset, block_offset); 4001b0ac: c2 00 e0 0c ld [ %g3 + 0xc ], %g1 4001b0b0: c4 06 60 0c ld [ %i1 + 0xc ], %g2 4001b0b4: c8 28 60 0a stb %g4, [ %g1 + 0xa ] 4001b0b8: c2 00 e0 0c ld [ %g3 + 0xc ], %g1 4001b0bc: c4 28 60 0b stb %g2, [ %g1 + 0xb ] rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block); 4001b0c0: c4 06 60 04 ld [ %i1 + 4 ], %g2 4001b0c4: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 rtems_rfs_buffer_mark_dirty (&handle->buffer); 4001b0c8: f0 28 e0 10 stb %i0, [ %g3 + 0x10 ] rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block); 4001b0cc: 89 30 60 18 srl %g1, 0x18, %g4 4001b0d0: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 4001b0d4: c8 28 e0 30 stb %g4, [ %g3 + 0x30 ] 4001b0d8: 89 30 60 10 srl %g1, 0x10, %g4 4001b0dc: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 4001b0e0: c8 28 e0 31 stb %g4, [ %g3 + 0x31 ] 4001b0e4: 89 30 60 08 srl %g1, 8, %g4 4001b0e8: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 4001b0ec: c8 28 e0 32 stb %g4, [ %g3 + 0x32 ] 4001b0f0: c6 00 a0 0c ld [ %g2 + 0xc ], %g3 4001b0f4: c2 28 e0 33 stb %g1, [ %g3 + 0x33 ] rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block); 4001b0f8: c2 06 60 04 ld [ %i1 + 4 ], %g1 4001b0fc: c6 06 60 20 ld [ %i1 + 0x20 ], %g3 rtems_rfs_buffer_mark_dirty (&handle->buffer); 4001b100: f0 28 a0 10 stb %i0, [ %g2 + 0x10 ] rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block); 4001b104: 89 30 e0 18 srl %g3, 0x18, %g4 4001b108: c4 00 60 0c ld [ %g1 + 0xc ], %g2 4001b10c: c8 28 a0 34 stb %g4, [ %g2 + 0x34 ] 4001b110: 89 30 e0 10 srl %g3, 0x10, %g4 4001b114: c4 00 60 0c ld [ %g1 + 0xc ], %g2 4001b118: c8 28 a0 35 stb %g4, [ %g2 + 0x35 ] 4001b11c: 89 30 e0 08 srl %g3, 8, %g4 4001b120: c4 00 60 0c ld [ %g1 + 0xc ], %g2 4001b124: c8 28 a0 36 stb %g4, [ %g2 + 0x36 ] 4001b128: c4 00 60 0c ld [ %g1 + 0xc ], %g2 4001b12c: c6 28 a0 37 stb %g3, [ %g2 + 0x37 ] rtems_rfs_buffer_mark_dirty (&handle->buffer); 4001b130: f0 28 60 10 stb %i0, [ %g1 + 0x10 ] brc = rtems_rfs_inode_unload (fs, map->inode, true); 4001b134: 7f ff e1 c4 call 40013844 4001b138: d2 06 60 04 ld [ %i1 + 4 ], %o1 map->dirty = false; 4001b13c: c0 2e 40 00 clrb [ %i1 ] 4001b140: 82 38 00 08 xnor %g0, %o0, %g1 4001b144: 83 38 60 1f sra %g1, 0x1f, %g1 4001b148: 10 80 00 04 b 4001b158 4001b14c: b0 0a 00 01 and %o0, %g1, %i0 int rc = 0; 4001b150: b0 10 20 00 clr %i0 4001b154: b8 06 60 38 add %i1, 0x38, %i4 map->inode = NULL; 4001b158: c0 26 60 04 clr [ %i1 + 4 ] rtems_rfs_buffer_handle_release (fs, handle); 4001b15c: 92 10 00 1c mov %i4, %o1 4001b160: 40 00 04 1c call 4001c1d0 4001b164: 90 10 00 1d mov %i5, %o0 handle->dirty = false; 4001b168: c0 2e 60 38 clrb [ %i1 + 0x38 ] rtems_rfs_buffer_handle_release (fs, handle); 4001b16c: 92 06 60 44 add %i1, 0x44, %o1 handle->bnum = 0; 4001b170: c0 26 60 3c clr [ %i1 + 0x3c ] rtems_rfs_buffer_handle_release (fs, handle); 4001b174: 90 10 00 1d mov %i5, %o0 4001b178: 40 00 04 16 call 4001c1d0 4001b17c: c0 26 60 40 clr [ %i1 + 0x40 ] handle->dirty = false; 4001b180: c0 2e 60 44 clrb [ %i1 + 0x44 ] handle->bnum = 0; 4001b184: c0 26 60 48 clr [ %i1 + 0x48 ] handle->buffer = NULL; 4001b188: c0 26 60 4c clr [ %i1 + 0x4c ] } 4001b18c: 81 c7 e0 08 ret 4001b190: 81 e8 00 00 restore =============================================================================== 4001b194 : { 4001b194: 9d e3 bf 98 save %sp, -104, %sp *block = 0; 4001b198: c0 26 c0 00 clr [ %i3 ] if (rtems_rfs_block_pos_block_past_end (bpos, &map->size)) 4001b19c: c2 06 80 00 ld [ %i2 ], %g1 4001b1a0: 80 a0 60 00 cmp %g1, 0 4001b1a4: 02 80 00 05 be 4001b1b8 4001b1a8: c4 06 60 08 ld [ %i1 + 8 ], %g2 4001b1ac: 80 a0 a0 00 cmp %g2, 0 4001b1b0: 02 80 00 1a be 4001b218 <== NEVER TAKEN 4001b1b4: 90 10 20 06 mov 6, %o0 4001b1b8: 80 a0 40 02 cmp %g1, %g2 4001b1bc: 1a 80 00 17 bcc 4001b218 4001b1c0: 90 10 20 06 mov 6, %o0 if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0)) 4001b1c4: c6 06 60 10 ld [ %i1 + 0x10 ], %g3 4001b1c8: 80 a0 40 03 cmp %g1, %g3 4001b1cc: 22 80 00 39 be,a 4001b2b0 4001b1d0: c6 06 60 18 ld [ %i1 + 0x18 ], %g3 if (map->size.count <= RTEMS_RFS_INODE_BLOCKS) 4001b1d4: 80 a0 a0 05 cmp %g2, 5 4001b1d8: 38 80 00 12 bgu,a 4001b220 4001b1dc: c6 06 20 34 ld [ %i0 + 0x34 ], %g3 *block = map->blocks[bpos->bno]; 4001b1e0: 82 00 60 08 add %g1, 8, %g1 4001b1e4: 83 28 60 02 sll %g1, 2, %g1 4001b1e8: 82 06 40 01 add %i1, %g1, %g1 4001b1ec: c2 00 60 04 ld [ %g1 + 4 ], %g1 4001b1f0: c2 26 c0 00 st %g1, [ %i3 ] map->bpos.block = *block; 4001b1f4: 90 10 20 00 clr %o0 rtems_rfs_block_copy_bpos (&map->bpos, bpos); 4001b1f8: c2 06 a0 04 ld [ %i2 + 4 ], %g1 4001b1fc: c4 06 80 00 ld [ %i2 ], %g2 4001b200: c6 06 a0 08 ld [ %i2 + 8 ], %g3 4001b204: c6 26 60 18 st %g3, [ %i1 + 0x18 ] 4001b208: c4 26 60 10 st %g2, [ %i1 + 0x10 ] 4001b20c: c2 26 60 14 st %g1, [ %i1 + 0x14 ] map->bpos.block = *block; 4001b210: c2 06 c0 00 ld [ %i3 ], %g1 4001b214: c2 26 60 18 st %g1, [ %i1 + 0x18 ] } 4001b218: 81 c7 e0 08 ret 4001b21c: 91 e8 00 08 restore %g0, %o0, %o0 direct = bpos->bno % fs->blocks_per_block; 4001b220: 81 80 20 00 wr %g0, %y 4001b224: 01 00 00 00 nop 4001b228: 01 00 00 00 nop 4001b22c: 01 00 00 00 nop 4001b230: 96 70 40 03 udiv %g1, %g3, %o3 singly = bpos->bno / fs->blocks_per_block; 4001b234: d6 27 bf fc st %o3, [ %fp + -4 ] direct = bpos->bno % fs->blocks_per_block; 4001b238: ba 5a c0 03 smul %o3, %g3, %i5 if (map->size.count <= fs->block_map_singly_blocks) 4001b23c: c8 06 20 38 ld [ %i0 + 0x38 ], %g4 4001b240: 80 a1 00 02 cmp %g4, %g2 4001b244: 1a 80 00 20 bcc 4001b2c4 <== ALWAYS TAKEN 4001b248: ba 20 40 1d sub %g1, %i5, %i5 singly %= fs->blocks_per_block; 4001b24c: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 4001b250: 01 00 00 00 nop <== NOT EXECUTED 4001b254: 01 00 00 00 nop <== NOT EXECUTED 4001b258: 01 00 00 00 nop <== NOT EXECUTED 4001b25c: 82 72 c0 03 udiv %o3, %g3, %g1 <== NOT EXECUTED 4001b260: 86 58 40 03 smul %g1, %g3, %g3 <== NOT EXECUTED 4001b264: 96 22 c0 03 sub %o3, %g3, %o3 <== NOT EXECUTED 4001b268: d6 27 bf fc st %o3, [ %fp + -4 ] <== NOT EXECUTED if (map->size.count < fs->block_map_doubly_blocks) 4001b26c: c6 06 20 3c ld [ %i0 + 0x3c ], %g3 <== NOT EXECUTED 4001b270: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED 4001b274: 08 bf ff e9 bleu 4001b218 <== NOT EXECUTED 4001b278: 90 10 20 06 mov 6, %o0 <== NOT EXECUTED rc = rtems_rfs_block_find_indirect (fs, 4001b27c: 82 00 60 08 add %g1, 8, %g1 <== NOT EXECUTED 4001b280: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 4001b284: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED 4001b288: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED 4001b28c: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED 4001b290: 92 06 60 44 add %i1, 0x44, %o1 <== NOT EXECUTED 4001b294: 7f ff fe 5e call 4001ac0c <== NOT EXECUTED 4001b298: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc == 0) 4001b29c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001b2a0: 12 bf ff de bne 4001b218 <== NOT EXECUTED 4001b2a4: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED rc = rtems_rfs_block_find_indirect (fs, 4001b2a8: 10 80 00 0c b 4001b2d8 <== NOT EXECUTED 4001b2ac: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0)) 4001b2b0: 80 a0 e0 00 cmp %g3, 0 4001b2b4: 02 bf ff c9 be 4001b1d8 <== ALWAYS TAKEN 4001b2b8: 80 a0 a0 05 cmp %g2, 5 *block = map->bpos.block; 4001b2bc: 10 bf ff ce b 4001b1f4 <== NOT EXECUTED 4001b2c0: c6 26 c0 00 st %g3, [ %i3 ] <== NOT EXECUTED rc = rtems_rfs_block_find_indirect (fs, 4001b2c4: 96 02 e0 08 add %o3, 8, %o3 4001b2c8: 97 2a e0 02 sll %o3, 2, %o3 4001b2cc: 96 06 40 0b add %i1, %o3, %o3 4001b2d0: d4 02 e0 04 ld [ %o3 + 4 ], %o2 rc = rtems_rfs_block_find_indirect (fs, 4001b2d4: 98 10 00 1b mov %i3, %o4 4001b2d8: 96 10 00 1d mov %i5, %o3 4001b2dc: 92 06 60 38 add %i1, 0x38, %o1 4001b2e0: 7f ff fe 4b call 4001ac0c 4001b2e4: 90 10 00 18 mov %i0, %o0 if (rc == 0) 4001b2e8: 80 a2 20 00 cmp %o0, 0 4001b2ec: 22 bf ff c3 be,a 4001b1f8 <== ALWAYS TAKEN 4001b2f0: 90 10 20 00 clr %o0 4001b2f4: 30 bf ff c9 b,a 4001b218 <== NOT EXECUTED =============================================================================== 4001b3a4 : { 4001b3a4: 9d e3 bf 98 save %sp, -104, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW)) 4001b3a8: 90 10 20 00 clr %o0 4001b3ac: 7f ff e7 22 call 40015034 4001b3b0: 13 00 00 08 sethi %hi(0x2000), %o1 4001b3b4: 80 a2 20 00 cmp %o0, 0 4001b3b8: 32 80 00 eb bne,a 4001b764 <== NEVER TAKEN 4001b3bc: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs)) 4001b3c0: c2 06 60 08 ld [ %i1 + 8 ], %g1 4001b3c4: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 4001b3c8: 82 06 80 01 add %i2, %g1, %g1 4001b3cc: 80 a0 40 02 cmp %g1, %g2 4001b3d0: 1a 80 00 68 bcc 4001b570 <== NEVER TAKEN 4001b3d4: b8 10 20 1b mov 0x1b, %i4 for (b = 0; b < blocks; b++) 4001b3d8: 80 a6 a0 00 cmp %i2, 0 4001b3dc: 02 80 00 65 be 4001b570 <== NEVER TAKEN 4001b3e0: b8 10 20 00 clr %i4 4001b3e4: d2 06 60 20 ld [ %i1 + 0x20 ], %o1 4001b3e8: a8 10 20 00 clr %l4 rtems_rfs_block_set_number (&map->singly_buffer, direct, block); 4001b3ec: a0 10 20 01 mov 1, %l0 rc = rtems_rfs_buffer_handle_request (fs, 4001b3f0: a4 06 60 44 add %i1, 0x44, %l2 rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 4001b3f4: 10 80 00 10 b 4001b434 4001b3f8: a2 06 60 38 add %i1, 0x38, %l1 map->blocks[map->size.count] = block; 4001b3fc: 84 00 60 08 add %g1, 8, %g2 4001b400: 85 28 a0 02 sll %g2, 2, %g2 4001b404: 84 06 40 02 add %i1, %g2, %g2 4001b408: d2 20 a0 04 st %o1, [ %g2 + 4 ] map->size.count++; 4001b40c: 82 00 60 01 inc %g1 map->size.offset = 0; 4001b410: c0 26 60 0c clr [ %i1 + 0xc ] if (b == 0) 4001b414: 80 a5 20 00 cmp %l4, 0 4001b418: 02 80 00 4f be 4001b554 <== ALWAYS TAKEN 4001b41c: c2 26 60 08 st %g1, [ %i1 + 8 ] map->last_data_block = block; 4001b420: d2 26 60 20 st %o1, [ %i1 + 0x20 ] <== NOT EXECUTED for (b = 0; b < blocks; b++) 4001b424: a8 05 20 01 inc %l4 <== NOT EXECUTED 4001b428: 80 a5 00 1a cmp %l4, %i2 <== NOT EXECUTED 4001b42c: 02 80 00 50 be 4001b56c <== NOT EXECUTED 4001b430: e0 2e 40 00 stb %l0, [ %i1 ] <== NOT EXECUTED rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block, 4001b434: 96 07 bf f8 add %fp, -8, %o3 4001b438: 94 10 20 00 clr %o2 4001b43c: 7f ff df 77 call 40013218 4001b440: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001b444: b8 92 20 00 orcc %o0, 0, %i4 4001b448: 14 80 00 4a bg 4001b570 4001b44c: 01 00 00 00 nop if (map->size.count < RTEMS_RFS_INODE_BLOCKS) 4001b450: c2 06 60 08 ld [ %i1 + 8 ], %g1 4001b454: 80 a0 60 04 cmp %g1, 4 4001b458: 08 bf ff e9 bleu 4001b3fc 4001b45c: d2 07 bf f8 ld [ %fp + -8 ], %o1 direct = map->size.count % fs->blocks_per_block; 4001b460: e6 06 20 34 ld [ %i0 + 0x34 ], %l3 if (map->size.count < fs->block_map_singly_blocks) 4001b464: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 direct = map->size.count % fs->blocks_per_block; 4001b468: 81 80 20 00 wr %g0, %y 4001b46c: 01 00 00 00 nop 4001b470: 01 00 00 00 nop 4001b474: 01 00 00 00 nop 4001b478: 96 70 40 13 udiv %g1, %l3, %o3 if (map->size.count < fs->block_map_singly_blocks) 4001b47c: 80 a0 40 02 cmp %g1, %g2 direct = map->size.count % fs->blocks_per_block; 4001b480: ba 5a c0 13 smul %o3, %l3, %i5 if (map->size.count < fs->block_map_singly_blocks) 4001b484: 1a 80 00 3d bcc 4001b578 <== NEVER TAKEN 4001b488: ba 20 40 1d sub %g1, %i5, %i5 if ((direct == 0) || 4001b48c: 80 a7 60 00 cmp %i5, 0 4001b490: 02 80 00 06 be 4001b4a8 <== NEVER TAKEN 4001b494: 80 a2 e0 00 cmp %o3, 0 4001b498: 12 80 00 95 bne 4001b6ec <== NEVER TAKEN 4001b49c: 80 a7 60 05 cmp %i5, 5 4001b4a0: 32 80 00 94 bne,a 4001b6f0 4001b4a4: 82 02 e0 08 add %o3, 8, %g1 upping = map->size.count == RTEMS_RFS_INODE_BLOCKS; 4001b4a8: 82 18 60 05 xor %g1, 5, %g1 rc = rtems_rfs_block_map_indirect_alloc (fs, map, 4001b4ac: 80 a0 00 01 cmp %g0, %g1 &map->blocks[singly], 4001b4b0: 96 02 e0 09 add %o3, 9, %o3 rc = rtems_rfs_block_map_indirect_alloc (fs, map, 4001b4b4: 98 60 3f ff subx %g0, -1, %o4 &map->blocks[singly], 4001b4b8: 97 2a e0 02 sll %o3, 2, %o3 rc = rtems_rfs_block_map_indirect_alloc (fs, map, 4001b4bc: 94 10 00 11 mov %l1, %o2 4001b4c0: 96 06 40 0b add %i1, %o3, %o3 4001b4c4: 92 10 00 19 mov %i1, %o1 4001b4c8: 7f ff fd 7e call 4001aac0 4001b4cc: 90 10 00 18 mov %i0, %o0 4001b4d0: b8 10 00 08 mov %o0, %i4 if (rc > 0) 4001b4d4: 80 a7 20 00 cmp %i4, 0 4001b4d8: 14 80 00 aa bg 4001b780 <== NEVER TAKEN 4001b4dc: d4 07 bf f8 ld [ %fp + -8 ], %o2 rtems_rfs_block_set_number (&map->singly_buffer, direct, block); 4001b4e0: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 4001b4e4: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 4001b4e8: c6 0f bf f8 ldub [ %fp + -8 ], %g3 4001b4ec: 83 2f 60 02 sll %i5, 2, %g1 4001b4f0: c6 28 80 01 stb %g3, [ %g2 + %g1 ] if (b == 0) 4001b4f4: 80 a5 20 00 cmp %l4, 0 rtems_rfs_block_set_number (&map->singly_buffer, direct, block); 4001b4f8: c4 06 60 40 ld [ %i1 + 0x40 ], %g2 4001b4fc: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 4001b500: c6 17 bf f8 lduh [ %fp + -8 ], %g3 4001b504: 84 00 80 01 add %g2, %g1, %g2 4001b508: c6 28 a0 01 stb %g3, [ %g2 + 1 ] 4001b50c: c4 06 60 40 ld [ %i1 + 0x40 ], %g2 4001b510: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 4001b514: c6 07 bf f8 ld [ %fp + -8 ], %g3 4001b518: 84 00 80 01 add %g2, %g1, %g2 4001b51c: 87 30 e0 08 srl %g3, 8, %g3 4001b520: c6 28 a0 02 stb %g3, [ %g2 + 2 ] 4001b524: c4 06 60 40 ld [ %i1 + 0x40 ], %g2 4001b528: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 4001b52c: 82 00 80 01 add %g2, %g1, %g1 4001b530: c4 07 bf f8 ld [ %fp + -8 ], %g2 4001b534: c4 28 60 03 stb %g2, [ %g1 + 3 ] 4001b538: c2 06 60 08 ld [ %i1 + 8 ], %g1 map->size.count++; 4001b53c: 82 00 60 01 inc %g1 rtems_rfs_block_set_number (&map->singly_buffer, direct, block); 4001b540: e0 2e 60 38 stb %l0, [ %i1 + 0x38 ] map->size.offset = 0; 4001b544: c0 26 60 0c clr [ %i1 + 0xc ] map->size.count++; 4001b548: c2 26 60 08 st %g1, [ %i1 + 8 ] if (b == 0) 4001b54c: 12 bf ff b5 bne 4001b420 <== NEVER TAKEN 4001b550: d2 07 bf f8 ld [ %fp + -8 ], %o1 *new_block = block; 4001b554: d2 26 c0 00 st %o1, [ %i3 ] for (b = 0; b < blocks; b++) 4001b558: a8 05 20 01 inc %l4 map->last_data_block = block; 4001b55c: d2 26 60 20 st %o1, [ %i1 + 0x20 ] for (b = 0; b < blocks; b++) 4001b560: 80 a5 00 1a cmp %l4, %i2 4001b564: 12 bf ff b4 bne 4001b434 <== NEVER TAKEN 4001b568: e0 2e 40 00 stb %l0, [ %i1 ] return 0; 4001b56c: b8 10 20 00 clr %i4 } 4001b570: 81 c7 e0 08 ret 4001b574: 91 e8 00 1c restore %g0, %i4, %o0 doubly = singly / fs->blocks_per_block; 4001b578: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 4001b57c: 01 00 00 00 nop <== NOT EXECUTED 4001b580: 01 00 00 00 nop <== NOT EXECUTED 4001b584: 01 00 00 00 nop <== NOT EXECUTED 4001b588: aa 72 c0 13 udiv %o3, %l3, %l5 <== NOT EXECUTED if (direct == 0) 4001b58c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED singly %= fs->blocks_per_block; 4001b590: a6 5d 40 13 smul %l5, %l3, %l3 <== NOT EXECUTED if (direct == 0) 4001b594: 12 80 00 37 bne 4001b670 <== NOT EXECUTED 4001b598: a6 22 c0 13 sub %o3, %l3, %l3 <== NOT EXECUTED rc = rtems_rfs_block_map_indirect_alloc (fs, map, 4001b59c: 98 10 20 00 clr %o4 <== NOT EXECUTED 4001b5a0: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED 4001b5a4: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED 4001b5a8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4001b5ac: 7f ff fd 45 call 4001aac0 <== NOT EXECUTED 4001b5b0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 4001b5b4: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED 4001b5b8: 14 80 00 71 bg 4001b77c <== NOT EXECUTED 4001b5bc: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED if ((singly == 0) || 4001b5c0: 02 80 00 06 be 4001b5d8 <== NOT EXECUTED 4001b5c4: 80 a5 60 00 cmp %l5, 0 <== NOT EXECUTED 4001b5c8: 12 80 00 53 bne 4001b714 <== NOT EXECUTED 4001b5cc: 80 a4 e0 05 cmp %l3, 5 <== NOT EXECUTED 4001b5d0: 12 80 00 52 bne 4001b718 <== NOT EXECUTED 4001b5d4: 82 05 60 08 add %l5, 8, %g1 <== NOT EXECUTED upping = map->size.count == fs->block_map_singly_blocks; 4001b5d8: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED 4001b5dc: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 <== NOT EXECUTED 4001b5e0: 82 18 40 02 xor %g1, %g2, %g1 <== NOT EXECUTED rc = rtems_rfs_block_map_indirect_alloc (fs, map, 4001b5e4: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED &map->blocks[doubly], 4001b5e8: 96 05 60 09 add %l5, 9, %o3 <== NOT EXECUTED rc = rtems_rfs_block_map_indirect_alloc (fs, map, 4001b5ec: 98 60 3f ff subx %g0, -1, %o4 <== NOT EXECUTED &map->blocks[doubly], 4001b5f0: 97 2a e0 02 sll %o3, 2, %o3 <== NOT EXECUTED rc = rtems_rfs_block_map_indirect_alloc (fs, map, 4001b5f4: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED 4001b5f8: 96 06 40 0b add %i1, %o3, %o3 <== NOT EXECUTED 4001b5fc: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4001b600: 7f ff fd 30 call 4001aac0 <== NOT EXECUTED 4001b604: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 4001b608: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED 4001b60c: 14 80 00 4e bg 4001b744 <== NOT EXECUTED 4001b610: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED rtems_rfs_block_set_number (&map->doubly_buffer, 4001b614: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED 4001b618: c4 0f bf fc ldub [ %fp + -4 ], %g2 <== NOT EXECUTED 4001b61c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 4001b620: 97 2c e0 02 sll %l3, 2, %o3 <== NOT EXECUTED 4001b624: c4 28 40 0b stb %g2, [ %g1 + %o3 ] <== NOT EXECUTED 4001b628: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED 4001b62c: c4 17 bf fc lduh [ %fp + -4 ], %g2 <== NOT EXECUTED 4001b630: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 4001b634: 82 00 40 0b add %g1, %o3, %g1 <== NOT EXECUTED 4001b638: c4 28 60 01 stb %g2, [ %g1 + 1 ] <== NOT EXECUTED 4001b63c: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED 4001b640: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED 4001b644: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED 4001b648: 82 00 40 0b add %g1, %o3, %g1 <== NOT EXECUTED 4001b64c: 85 30 a0 08 srl %g2, 8, %g2 <== NOT EXECUTED 4001b650: c4 28 60 02 stb %g2, [ %g1 + 2 ] <== NOT EXECUTED 4001b654: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED 4001b658: e6 00 60 1c ld [ %g1 + 0x1c ], %l3 <== NOT EXECUTED 4001b65c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED 4001b660: 96 04 c0 0b add %l3, %o3, %o3 <== NOT EXECUTED 4001b664: c2 2a e0 03 stb %g1, [ %o3 + 3 ] <== NOT EXECUTED 4001b668: 10 bf ff 9e b 4001b4e0 <== NOT EXECUTED 4001b66c: e0 2e 60 44 stb %l0, [ %i1 + 0x44 ] <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, 4001b670: aa 05 60 08 add %l5, 8, %l5 <== NOT EXECUTED 4001b674: ab 2d 60 02 sll %l5, 2, %l5 <== NOT EXECUTED 4001b678: aa 06 40 15 add %i1, %l5, %l5 <== NOT EXECUTED 4001b67c: d4 05 60 04 ld [ %l5 + 4 ], %o2 <== NOT EXECUTED 4001b680: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED 4001b684: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED 4001b688: 40 00 02 0b call 4001beb4 <== NOT EXECUTED 4001b68c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 4001b690: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED 4001b694: 14 80 00 3a bg 4001b77c <== NOT EXECUTED 4001b698: 97 2c e0 02 sll %l3, 2, %o3 <== NOT EXECUTED singly_block = rtems_rfs_block_get_number (&map->doubly_buffer, 4001b69c: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED 4001b6a0: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 <== NOT EXECUTED 4001b6a4: d4 08 80 0b ldub [ %g2 + %o3 ], %o2 <== NOT EXECUTED 4001b6a8: 82 00 80 0b add %g2, %o3, %g1 <== NOT EXECUTED 4001b6ac: c6 08 60 03 ldub [ %g1 + 3 ], %g3 <== NOT EXECUTED 4001b6b0: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED 4001b6b4: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED 4001b6b8: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED 4001b6bc: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED 4001b6c0: 95 2a a0 18 sll %o2, 0x18, %o2 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 4001b6c4: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED singly_block = rtems_rfs_block_get_number (&map->doubly_buffer, 4001b6c8: 94 12 80 03 or %o2, %g3, %o2 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 4001b6cc: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED singly_block = rtems_rfs_block_get_number (&map->doubly_buffer, 4001b6d0: 94 12 80 02 or %o2, %g2, %o2 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 4001b6d4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED singly_block = rtems_rfs_block_get_number (&map->doubly_buffer, 4001b6d8: 94 12 80 01 or %o2, %g1, %o2 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 4001b6dc: 40 00 01 f6 call 4001beb4 <== NOT EXECUTED 4001b6e0: d4 27 bf fc st %o2, [ %fp + -4 ] <== NOT EXECUTED 4001b6e4: 10 bf ff 7c b 4001b4d4 <== NOT EXECUTED 4001b6e8: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 4001b6ec: 82 02 e0 08 add %o3, 8, %g1 <== NOT EXECUTED 4001b6f0: 83 28 60 02 sll %g1, 2, %g1 4001b6f4: 82 06 40 01 add %i1, %g1, %g1 4001b6f8: d4 00 60 04 ld [ %g1 + 4 ], %o2 4001b6fc: 96 10 20 01 mov 1, %o3 4001b700: 92 10 00 11 mov %l1, %o1 4001b704: 40 00 01 ec call 4001beb4 4001b708: 90 10 00 18 mov %i0, %o0 4001b70c: 10 bf ff 72 b 4001b4d4 4001b710: b8 10 00 08 mov %o0, %i4 rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer, 4001b714: 82 05 60 08 add %l5, 8, %g1 <== NOT EXECUTED 4001b718: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 4001b71c: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED 4001b720: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED 4001b724: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED 4001b728: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED 4001b72c: 40 00 01 e2 call 4001beb4 <== NOT EXECUTED 4001b730: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 4001b734: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED 4001b738: 24 bf ff b8 ble,a 4001b618 <== NOT EXECUTED 4001b73c: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED rtems_rfs_group_bitmap_free (fs, false, singly_block); 4001b740: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED 4001b744: 92 10 20 00 clr %o1 <== NOT EXECUTED 4001b748: 7f ff df 62 call 400134d0 <== NOT EXECUTED 4001b74c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED rtems_rfs_group_bitmap_free (fs, false, block); 4001b750: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED 4001b754: 92 10 20 00 clr %o1 <== NOT EXECUTED 4001b758: 7f ff df 5e call 400134d0 <== NOT EXECUTED 4001b75c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED return rc; 4001b760: 30 bf ff 84 b,a 4001b570 <== NOT EXECUTED printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n", 4001b764: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4001b768: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED 4001b76c: 7f ff e6 bf call 40015268 <__wrap_printf> <== NOT EXECUTED 4001b770: 90 12 20 78 or %o0, 0x78, %o0 ! 40032878 <== NOT EXECUTED if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs)) 4001b774: 10 bf ff 14 b 4001b3c4 <== NOT EXECUTED 4001b778: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED rtems_rfs_group_bitmap_free (fs, false, block); 4001b77c: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED 4001b780: 92 10 20 00 clr %o1 <== NOT EXECUTED 4001b784: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001b788: 7f ff df 52 call 400134d0 <== NOT EXECUTED 4001b78c: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED } 4001b790: 81 c7 e0 08 ret <== NOT EXECUTED 4001b794: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4001ae4c : { 4001ae4c: 9d e3 bf a0 save %sp, -96, %sp map->dirty = false; 4001ae50: c0 2e 80 00 clrb [ %i2 ] rc = rtems_rfs_inode_load (fs, inode); 4001ae54: 92 10 00 19 mov %i1, %o1 map->inode = NULL; 4001ae58: c0 26 a0 04 clr [ %i2 + 4 ] rc = rtems_rfs_inode_load (fs, inode); 4001ae5c: 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; 4001ae60: c0 26 a0 08 clr [ %i2 + 8 ] { 4001ae64: ba 10 00 1a mov %i2, %i5 size->offset = 0; 4001ae68: c0 26 a0 0c clr [ %i2 + 0xc ] bpos->bno = 0; 4001ae6c: c0 26 a0 10 clr [ %i2 + 0x10 ] bpos->boff = 0; 4001ae70: c0 26 a0 14 clr [ %i2 + 0x14 ] bpos->block = 0; 4001ae74: c0 26 a0 18 clr [ %i2 + 0x18 ] handle->dirty = false; 4001ae78: c0 2e a0 38 clrb [ %i2 + 0x38 ] handle->bnum = 0; 4001ae7c: c0 26 a0 3c clr [ %i2 + 0x3c ] handle->buffer = NULL; 4001ae80: c0 26 a0 40 clr [ %i2 + 0x40 ] handle->dirty = false; 4001ae84: c0 2e a0 44 clrb [ %i2 + 0x44 ] handle->bnum = 0; 4001ae88: c0 26 a0 48 clr [ %i2 + 0x48 ] rc = rtems_rfs_inode_load (fs, inode); 4001ae8c: 7f ff e2 08 call 400136ac 4001ae90: c0 26 a0 4c clr [ %i2 + 0x4c ] if (rc > 0) 4001ae94: b8 92 20 00 orcc %o0, 0, %i4 4001ae98: 14 80 00 3d bg 4001af8c <== NEVER TAKEN 4001ae9c: 88 06 a0 24 add %i2, 0x24, %g4 4001aea0: de 06 60 0c ld [ %i1 + 0xc ], %o7 map->inode = inode; 4001aea4: f2 26 a0 04 st %i1, [ %i2 + 4 ] 4001aea8: 82 03 e0 1c add %o7, 0x1c, %g1 4001aeac: b4 06 a0 38 add %i2, 0x38, %i2 return rtems_rfs_read_u32 (&handle->node->data.blocks[block]); 4001aeb0: f6 08 40 00 ldub [ %g1 ], %i3 4001aeb4: c6 08 60 01 ldub [ %g1 + 1 ], %g3 4001aeb8: c4 08 60 02 ldub [ %g1 + 2 ], %g2 4001aebc: f8 08 60 03 ldub [ %g1 + 3 ], %i4 4001aec0: b7 2e e0 18 sll %i3, 0x18, %i3 4001aec4: 87 28 e0 10 sll %g3, 0x10, %g3 4001aec8: 85 28 a0 08 sll %g2, 8, %g2 4001aecc: 86 10 c0 1b or %g3, %i3, %g3 4001aed0: 84 10 80 03 or %g2, %g3, %g2 4001aed4: 84 17 00 02 or %i4, %g2, %g2 map->blocks[b] = rtems_rfs_inode_get_block (inode, b); 4001aed8: c4 21 00 00 st %g2, [ %g4 ] 4001aedc: 88 01 20 04 add %g4, 4, %g4 for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++) 4001aee0: 80 a6 80 04 cmp %i2, %g4 4001aee4: 12 bf ff f3 bne 4001aeb0 4001aee8: 82 00 60 04 add %g1, 4, %g1 return rtems_rfs_read_u32 (&handle->node->block_count); 4001aeec: c6 0b e0 0f ldub [ %o7 + 0xf ], %g3 4001aef0: c8 0b e0 0c ldub [ %o7 + 0xc ], %g4 4001aef4: c4 0b e0 0d ldub [ %o7 + 0xd ], %g2 4001aef8: c2 0b e0 0e ldub [ %o7 + 0xe ], %g1 4001aefc: 89 29 20 18 sll %g4, 0x18, %g4 4001af00: 85 28 a0 10 sll %g2, 0x10, %g2 4001af04: 83 28 60 08 sll %g1, 8, %g1 4001af08: 84 10 80 04 or %g2, %g4, %g2 4001af0c: 82 10 40 02 or %g1, %g2, %g1 4001af10: 82 10 c0 01 or %g3, %g1, %g1 map->size.count = rtems_rfs_inode_get_block_count (inode); 4001af14: c2 27 60 08 st %g1, [ %i5 + 8 ] return rtems_rfs_read_u16 (&handle->node->block_offset); 4001af18: c4 0b e0 0b ldub [ %o7 + 0xb ], %g2 4001af1c: c2 0b e0 0a ldub [ %o7 + 0xa ], %g1 4001af20: 83 28 60 08 sll %g1, 8, %g1 map->size.offset = rtems_rfs_inode_get_block_offset (inode); 4001af24: 82 10 40 02 or %g1, %g2, %g1 4001af28: c2 27 60 0c st %g1, [ %i5 + 0xc ] return rtems_rfs_read_u32 (&handle->node->last_map_block); 4001af2c: c6 0b e0 33 ldub [ %o7 + 0x33 ], %g3 4001af30: c8 0b e0 30 ldub [ %o7 + 0x30 ], %g4 4001af34: c4 0b e0 31 ldub [ %o7 + 0x31 ], %g2 4001af38: c2 0b e0 32 ldub [ %o7 + 0x32 ], %g1 4001af3c: 89 29 20 18 sll %g4, 0x18, %g4 4001af40: 85 28 a0 10 sll %g2, 0x10, %g2 4001af44: 83 28 60 08 sll %g1, 8, %g1 4001af48: 84 10 80 04 or %g2, %g4, %g2 4001af4c: 82 10 40 02 or %g1, %g2, %g1 4001af50: 82 10 c0 01 or %g3, %g1, %g1 map->last_map_block = rtems_rfs_inode_get_last_map_block (inode); 4001af54: c2 27 60 1c st %g1, [ %i5 + 0x1c ] return rtems_rfs_read_u32 (&handle->node->last_data_block); 4001af58: c8 0b e0 34 ldub [ %o7 + 0x34 ], %g4 4001af5c: c4 0b e0 35 ldub [ %o7 + 0x35 ], %g2 4001af60: c2 0b e0 36 ldub [ %o7 + 0x36 ], %g1 4001af64: c6 0b e0 37 ldub [ %o7 + 0x37 ], %g3 4001af68: 89 29 20 18 sll %g4, 0x18, %g4 4001af6c: 85 28 a0 10 sll %g2, 0x10, %g2 4001af70: 83 28 60 08 sll %g1, 8, %g1 4001af74: 84 10 80 04 or %g2, %g4, %g2 4001af78: 82 10 40 02 or %g1, %g2, %g1 4001af7c: 82 10 c0 01 or %g3, %g1, %g1 map->last_data_block = rtems_rfs_inode_get_last_data_block (inode); 4001af80: c2 27 60 20 st %g1, [ %i5 + 0x20 ] rc = rtems_rfs_inode_unload (fs, inode, false); 4001af84: 7f ff e2 30 call 40013844 4001af88: 95 e8 20 00 restore %g0, 0, %o2 rtems_rfs_buffer_handle_release (fs, handle); 4001af8c: 92 06 a0 38 add %i2, 0x38, %o1 <== NOT EXECUTED 4001af90: 40 00 04 90 call 4001c1d0 <== NOT EXECUTED 4001af94: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED handle->dirty = false; 4001af98: c0 2e a0 38 clrb [ %i2 + 0x38 ] <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001af9c: 92 06 a0 44 add %i2, 0x44, %o1 <== NOT EXECUTED handle->bnum = 0; 4001afa0: c0 26 a0 3c clr [ %i2 + 0x3c ] <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001afa4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED handle->buffer = NULL; 4001afa8: c0 26 a0 40 clr [ %i2 + 0x40 ] <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001afac: 40 00 04 89 call 4001c1d0 <== NOT EXECUTED 4001afb0: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED handle->dirty = false; 4001afb4: c0 2e a0 44 clrb [ %i2 + 0x44 ] <== NOT EXECUTED handle->bnum = 0; 4001afb8: c0 26 a0 48 clr [ %i2 + 0x48 ] <== NOT EXECUTED handle->buffer = NULL; 4001afbc: c0 26 a0 4c clr [ %i2 + 0x4c ] <== NOT EXECUTED } 4001afc0: 81 c7 e0 08 ret <== NOT EXECUTED 4001afc4: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4001b798 : int rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs, rtems_rfs_block_map* map, size_t blocks) { 4001b798: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK)) 4001b79c: 90 10 20 00 clr %o0 4001b7a0: 7f ff e6 25 call 40015034 4001b7a4: 13 00 00 10 sethi %hi(0x4000), %o1 4001b7a8: 80 a2 20 00 cmp %o0, 0 4001b7ac: 32 80 00 a3 bne,a 4001ba38 <== NEVER TAKEN 4001b7b0: 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) 4001b7b4: c2 06 60 08 ld [ %i1 + 8 ], %g1 4001b7b8: 80 a0 60 00 cmp %g1, 0 4001b7bc: 02 80 00 9a be 4001ba24 4001b7c0: 80 a0 40 1a cmp %g1, %i2 4001b7c4: 18 80 00 9b bgu 4001ba30 <== NEVER TAKEN 4001b7c8: b6 10 00 01 mov %g1, %i3 return 0; if (blocks > map->size.count) blocks = map->size.count; while (blocks) 4001b7cc: 80 a6 e0 00 cmp %i3, 0 4001b7d0: 02 80 00 8e be 4001ba08 <== NEVER TAKEN 4001b7d4: 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, 4001b7d8: 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, 4001b7dc: a6 06 60 4c add %i1, 0x4c, %l3 rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer, 4001b7e0: 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; 4001b7e4: 10 80 00 13 b 4001b830 4001b7e8: b4 10 20 01 mov 1, %i2 4001b7ec: 82 06 40 01 add %i1, %g1, %g1 block_to_free = map->blocks[block]; 4001b7f0: fa 00 60 20 ld [ %g1 + 0x20 ], %i5 map->blocks[block] = 0; 4001b7f4: c0 20 60 20 clr [ %g1 + 0x20 ] rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free); 4001b7f8: 94 10 00 1d mov %i5, %o2 4001b7fc: 92 10 20 00 clr %o1 4001b800: 7f ff df 34 call 400134d0 4001b804: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001b808: 80 a2 20 00 cmp %o0, 0 4001b80c: 14 80 00 61 bg 4001b990 <== NEVER TAKEN 4001b810: b6 86 ff ff addcc %i3, -1, %i3 map->size.count--; 4001b814: c2 06 60 08 ld [ %i1 + 8 ], %g1 4001b818: 82 00 7f ff add %g1, -1, %g1 map->size.offset = 0; 4001b81c: c0 26 60 0c clr [ %i1 + 0xc ] map->size.count--; 4001b820: c2 26 60 08 st %g1, [ %i1 + 8 ] map->last_data_block = block_to_free; 4001b824: fa 26 60 20 st %i5, [ %i1 + 0x20 ] while (blocks) 4001b828: 02 80 00 8a be 4001ba50 4001b82c: f4 2e 40 00 stb %i2, [ %i1 ] block = map->size.count - 1; 4001b830: 84 00 7f ff add %g1, -1, %g2 if (block < RTEMS_RFS_INODE_BLOCKS) 4001b834: 80 a0 a0 04 cmp %g2, 4 4001b838: 28 bf ff ed bleu,a 4001b7ec 4001b83c: 83 28 60 02 sll %g1, 2, %g1 direct = block % fs->blocks_per_block; 4001b840: c6 06 20 34 ld [ %i0 + 0x34 ], %g3 if (block < fs->block_map_singly_blocks) 4001b844: c8 06 20 38 ld [ %i0 + 0x38 ], %g4 direct = block % fs->blocks_per_block; 4001b848: 81 80 20 00 wr %g0, %y 4001b84c: 01 00 00 00 nop 4001b850: 01 00 00 00 nop 4001b854: 01 00 00 00 nop 4001b858: aa 70 80 03 udiv %g2, %g3, %l5 if (block < fs->block_map_singly_blocks) 4001b85c: 80 a1 00 02 cmp %g4, %g2 direct = block % fs->blocks_per_block; 4001b860: ac 5d 40 03 smul %l5, %g3, %l6 if (block < fs->block_map_singly_blocks) 4001b864: 18 80 00 4d bgu 4001b998 <== ALWAYS TAKEN 4001b868: ac 20 80 16 sub %g2, %l6, %l6 else if (block < fs->block_map_doubly_blocks) 4001b86c: c8 06 20 3c ld [ %i0 + 0x3c ], %g4 <== NOT EXECUTED 4001b870: 80 a1 00 02 cmp %g4, %g2 <== NOT EXECUTED 4001b874: 08 80 00 77 bleu 4001ba50 <== NOT EXECUTED 4001b878: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED doubly = singly / fs->blocks_per_block; 4001b87c: 81 80 20 00 wr %g0, %y <== NOT EXECUTED 4001b880: 01 00 00 00 nop <== NOT EXECUTED 4001b884: 01 00 00 00 nop <== NOT EXECUTED 4001b888: 01 00 00 00 nop <== NOT EXECUTED 4001b88c: ae 75 40 03 udiv %l5, %g3, %l7 <== NOT EXECUTED doubly_singly = singly % fs->blocks_per_block; 4001b890: 86 5d c0 03 smul %l7, %g3, %g3 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer, 4001b894: 82 05 e0 08 add %l7, 8, %g1 <== NOT EXECUTED 4001b898: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED 4001b89c: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED 4001b8a0: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED doubly_singly = singly % fs->blocks_per_block; 4001b8a4: aa 25 40 03 sub %l5, %g3, %l5 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer, 4001b8a8: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED 4001b8ac: 40 00 01 82 call 4001beb4 <== NOT EXECUTED 4001b8b0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 4001b8b4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001b8b8: 14 80 00 36 bg 4001b990 <== NOT EXECUTED 4001b8bc: 85 2d 60 02 sll %l5, 2, %g2 <== NOT EXECUTED singly = rtems_rfs_block_get_number (&map->doubly_buffer, 4001b8c0: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED 4001b8c4: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED 4001b8c8: e8 08 c0 02 ldub [ %g3 + %g2 ], %l4 <== NOT EXECUTED 4001b8cc: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED 4001b8d0: c6 08 60 03 ldub [ %g1 + 3 ], %g3 <== NOT EXECUTED 4001b8d4: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED 4001b8d8: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED 4001b8dc: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED 4001b8e0: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED 4001b8e4: a9 2d 20 18 sll %l4, 0x18, %l4 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 4001b8e8: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED singly = rtems_rfs_block_get_number (&map->doubly_buffer, 4001b8ec: a8 15 00 03 or %l4, %g3, %l4 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 4001b8f0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED singly = rtems_rfs_block_get_number (&map->doubly_buffer, 4001b8f4: a8 15 00 02 or %l4, %g2, %l4 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 4001b8f8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED singly = rtems_rfs_block_get_number (&map->doubly_buffer, 4001b8fc: a8 15 00 01 or %l4, %g1, %l4 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 4001b900: 40 00 01 6d call 4001beb4 <== NOT EXECUTED 4001b904: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED if (rc > 0) 4001b908: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001b90c: 14 80 00 21 bg 4001b990 <== NOT EXECUTED 4001b910: 85 2d a0 02 sll %l6, 2, %g2 <== NOT EXECUTED block_to_free = rtems_rfs_block_get_number (&map->singly_buffer, 4001b914: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED 4001b918: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED 4001b91c: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED 4001b920: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5 <== NOT EXECUTED 4001b924: c6 08 60 03 ldub [ %g1 + 3 ], %g3 <== NOT EXECUTED 4001b928: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED 4001b92c: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED 4001b930: bb 2f 60 18 sll %i5, 0x18, %i5 <== NOT EXECUTED 4001b934: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED 4001b938: ba 17 40 03 or %i5, %g3, %i5 <== NOT EXECUTED 4001b93c: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED 4001b940: ba 17 40 02 or %i5, %g2, %i5 <== NOT EXECUTED if (direct == 0) 4001b944: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED 4001b948: 12 bf ff ac bne 4001b7f8 <== NOT EXECUTED 4001b94c: ba 17 40 01 or %i5, %g1, %i5 <== NOT EXECUTED rc = rtems_rfs_group_bitmap_free (fs, false, singly); 4001b950: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED 4001b954: 92 10 20 00 clr %o1 <== NOT EXECUTED 4001b958: 7f ff de de call 400134d0 <== NOT EXECUTED 4001b95c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 4001b960: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001b964: 14 80 00 0b bg 4001b990 <== NOT EXECUTED 4001b968: 98 10 00 15 mov %l5, %o4 <== NOT EXECUTED map->last_map_block = singly; 4001b96c: e8 26 60 1c st %l4, [ %i1 + 0x1c ] <== NOT EXECUTED rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer, 4001b970: 96 10 00 17 mov %l7, %o3 <== NOT EXECUTED 4001b974: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED 4001b978: 92 10 00 19 mov %i1, %o1 4001b97c: 7f ff fc d7 call 4001acd8 4001b980: 90 10 00 18 mov %i0, %o0 if (rc) 4001b984: 80 a2 20 00 cmp %o0, 0 4001b988: 02 bf ff 9d be 4001b7fc <== ALWAYS TAKEN 4001b98c: 94 10 00 1d mov %i5, %o2 */ if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size)) rtems_rfs_block_size_get_bpos (&map->size, &map->bpos); return 0; } 4001b990: 81 c7 e0 08 ret <== NOT EXECUTED 4001b994: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer, 4001b998: 82 05 60 08 add %l5, 8, %g1 4001b99c: 83 28 60 02 sll %g1, 2, %g1 4001b9a0: 82 06 40 01 add %i1, %g1, %g1 4001b9a4: d4 00 60 04 ld [ %g1 + 4 ], %o2 4001b9a8: 96 10 20 01 mov 1, %o3 4001b9ac: 92 10 00 10 mov %l0, %o1 4001b9b0: 40 00 01 41 call 4001beb4 4001b9b4: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001b9b8: 80 a2 20 00 cmp %o0, 0 4001b9bc: 14 bf ff f5 bg 4001b990 <== NEVER TAKEN 4001b9c0: 85 2d a0 02 sll %l6, 2, %g2 block_to_free = rtems_rfs_block_get_number (&map->singly_buffer, 4001b9c4: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 4001b9c8: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 4001b9cc: 82 00 c0 02 add %g3, %g2, %g1 4001b9d0: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5 4001b9d4: c6 08 60 03 ldub [ %g1 + 3 ], %g3 4001b9d8: c4 08 60 01 ldub [ %g1 + 1 ], %g2 4001b9dc: c2 08 60 02 ldub [ %g1 + 2 ], %g1 4001b9e0: bb 2f 60 18 sll %i5, 0x18, %i5 4001b9e4: 85 28 a0 10 sll %g2, 0x10, %g2 4001b9e8: ba 17 40 03 or %i5, %g3, %i5 4001b9ec: 83 28 60 08 sll %g1, 8, %g1 4001b9f0: ba 17 40 02 or %i5, %g2, %i5 rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer, 4001b9f4: 98 10 00 16 mov %l6, %o4 block_to_free = rtems_rfs_block_get_number (&map->singly_buffer, 4001b9f8: ba 17 40 01 or %i5, %g1, %i5 rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer, 4001b9fc: 96 10 00 15 mov %l5, %o3 4001ba00: 10 bf ff de b 4001b978 4001ba04: 94 10 00 12 mov %l2, %o2 if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size)) 4001ba08: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 <== NOT EXECUTED 4001ba0c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED 4001ba10: 08 80 00 25 bleu 4001baa4 <== NOT EXECUTED 4001ba14: 86 00 7f ff add %g1, -1, %g3 <== NOT EXECUTED 4001ba18: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED 4001ba1c: 22 80 00 1c be,a 4001ba8c <== NOT EXECUTED 4001ba20: c4 06 60 0c ld [ %i1 + 0xc ], %g2 <== NOT EXECUTED return 0; 4001ba24: 90 10 20 00 clr %o0 } 4001ba28: 81 c7 e0 08 ret 4001ba2c: 91 e8 00 08 restore %g0, %o0, %o0 4001ba30: 10 bf ff 67 b 4001b7cc <== NOT EXECUTED 4001ba34: b6 10 00 1a mov %i2, %i3 <== NOT EXECUTED printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n", 4001ba38: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4001ba3c: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED 4001ba40: 7f ff e6 0a call 40015268 <__wrap_printf> <== NOT EXECUTED 4001ba44: 90 12 20 b0 or %o0, 0xb0, %o0 ! 400328b0 <== NOT EXECUTED if (map->size.count == 0) 4001ba48: 10 bf ff 5c b 4001b7b8 <== NOT EXECUTED 4001ba4c: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED if (map->size.count == 0) 4001ba50: 80 a0 60 00 cmp %g1, 0 4001ba54: 32 bf ff ee bne,a 4001ba0c <== NEVER TAKEN 4001ba58: c4 06 60 10 ld [ %i1 + 0x10 ], %g2 <== NOT EXECUTED map->last_map_block = 0; 4001ba5c: c0 26 60 1c clr [ %i1 + 0x1c ] map->last_data_block = 0; 4001ba60: c0 26 60 20 clr [ %i1 + 0x20 ] 4001ba64: c4 06 60 0c ld [ %i1 + 0xc ], %g2 rtems_rfs_block_size_get_bpos (&map->size, &map->bpos); 4001ba68: c2 26 60 10 st %g1, [ %i1 + 0x10 ] 4001ba6c: 80 a0 a0 00 cmp %g2, 0 4001ba70: c4 26 60 14 st %g2, [ %i1 + 0x14 ] 4001ba74: 02 bf ff ec be 4001ba24 <== ALWAYS TAKEN 4001ba78: c0 26 60 18 clr [ %i1 + 0x18 ] 4001ba7c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED return 0; 4001ba80: 90 10 20 00 clr %o0 <== NOT EXECUTED rtems_rfs_block_size_get_bpos (&map->size, &map->bpos); 4001ba84: 10 bf ff c3 b 4001b990 <== NOT EXECUTED 4001ba88: c2 26 60 10 st %g1, [ %i1 + 0x10 ] <== NOT EXECUTED if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size)) 4001ba8c: c6 06 60 14 ld [ %i1 + 0x14 ], %g3 <== NOT EXECUTED 4001ba90: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED 4001ba94: 38 bf ff f6 bgu,a 4001ba6c <== NOT EXECUTED 4001ba98: c2 26 60 10 st %g1, [ %i1 + 0x10 ] <== NOT EXECUTED return 0; 4001ba9c: 10 bf ff e3 b 4001ba28 <== NOT EXECUTED 4001baa0: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001baa4: 10 bf ff f1 b 4001ba68 <== NOT EXECUTED 4001baa8: c4 06 60 0c ld [ %i1 + 0xc ], %g2 <== NOT EXECUTED =============================================================================== 400208e0 : int rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer, bool modified) { 400208e0: 9d e3 bf a0 save %sp, -96, %sp rtems_status_code sc; int rc = 0; if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE)) 400208e4: 90 10 20 00 clr %o0 400208e8: 7f ff d1 d3 call 40015034 400208ec: 92 10 20 40 mov 0x40, %o1 400208f0: 80 a2 20 00 cmp %o0, 0 400208f4: 02 80 00 0b be 40020920 <== ALWAYS TAKEN 400208f8: 80 a6 60 00 cmp %i1, 0 printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n", 400208fc: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 <== NOT EXECUTED 40020900: 12 80 00 18 bne 40020960 <== NOT EXECUTED 40020904: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 <== NOT EXECUTED 40020908: 17 10 00 ce sethi %hi(0x40033800), %o3 <== NOT EXECUTED 4002090c: 96 12 e0 48 or %o3, 0x48, %o3 ! 40033848 <== NOT EXECUTED 40020910: 11 10 00 d0 sethi %hi(0x40034000), %o0 <== NOT EXECUTED 40020914: 7f ff d2 55 call 40015268 <__wrap_printf> <== NOT EXECUTED 40020918: 90 12 22 40 or %o0, 0x240, %o0 ! 40034240 <== NOT EXECUTED ((intptr_t) buffer->user), buffer->block, modified ? "(modified)" : ""); if (modified) 4002091c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED 40020920: 02 80 00 09 be 40020944 40020924: 90 10 00 18 mov %i0, %o0 sc = rtems_bdbuf_release_modified (buffer); 40020928: 7f ff dc 41 call 40017a2c 4002092c: 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; 40020930: 80 a0 00 08 cmp %g0, %o0 40020934: b0 40 3f ff addx %g0, -1, %i0 40020938: b0 0e 3f fb and %i0, -5, %i0 } return rc; } 4002093c: 81 c7 e0 08 ret 40020940: 91 ee 20 05 restore %i0, 5, %o0 sc = rtems_bdbuf_release (buffer); 40020944: 7f ff db f4 call 40017914 40020948: 01 00 00 00 nop rc = EIO; 4002094c: 80 a0 00 08 cmp %g0, %o0 40020950: b0 40 3f ff addx %g0, -1, %i0 40020954: b0 0e 3f fb and %i0, -5, %i0 } 40020958: 81 c7 e0 08 ret 4002095c: 91 ee 20 05 restore %i0, 5, %o0 printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n", 40020960: 17 10 00 d0 sethi %hi(0x40034000), %o3 <== NOT EXECUTED 40020964: 10 bf ff eb b 40020910 <== NOT EXECUTED 40020968: 96 12 e2 30 or %o3, 0x230, %o3 ! 40034230 <== NOT EXECUTED =============================================================================== 4001c5c0 : { 4001c5c0: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE)) 4001c5c4: 90 10 20 00 clr %o0 4001c5c8: 92 10 20 10 mov 0x10, %o1 4001c5cc: 7f ff e2 9a call 40015034 4001c5d0: ba 10 00 18 mov %i0, %i5 4001c5d4: 80 a2 20 00 cmp %o0, 0 4001c5d8: 12 80 00 2f bne 4001c694 <== NEVER TAKEN 4001c5dc: 11 10 00 cb sethi %hi(0x40032c00), %o0 rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs)); 4001c5e0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 4001c5e4: d2 00 60 20 ld [ %g1 + 0x20 ], %o1 4001c5e8: 7f ff ff b5 call 4001c4bc 4001c5ec: 90 10 00 1d mov %i5, %o0 if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE)) 4001c5f0: b0 92 20 00 orcc %o0, 0, %i0 4001c5f4: 14 80 00 1b bg 4001c660 <== NEVER TAKEN 4001c5f8: 90 10 20 00 clr %o0 if (close (fs->device) < 0) 4001c5fc: 7f ff b3 26 call 40009294 4001c600: d0 07 60 0c ld [ %i5 + 0xc ], %o0 4001c604: 80 a2 20 00 cmp %o0, 0 4001c608: 06 80 00 04 bl 4001c618 <== NEVER TAKEN 4001c60c: 01 00 00 00 nop } 4001c610: 81 c7 e0 08 ret 4001c614: 81 e8 00 00 restore rc = errno; 4001c618: 40 00 11 94 call 40020c68 <__errno> <== NOT EXECUTED 4001c61c: 01 00 00 00 nop <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE)) 4001c620: 92 10 20 10 mov 0x10, %o1 ! 10 <_TLS_Alignment+0xf> <== NOT EXECUTED rc = errno; 4001c624: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE)) 4001c628: 7f ff e2 83 call 40015034 <== NOT EXECUTED 4001c62c: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001c630: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001c634: 02 80 00 09 be 4001c658 <== NOT EXECUTED 4001c638: 01 00 00 00 nop <== NOT EXECUTED printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n", 4001c63c: 40 00 19 d4 call 40022d8c <== NOT EXECUTED 4001c640: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001c644: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4001c648: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 4001c64c: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED 4001c650: 7f ff e3 06 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c654: 90 12 21 f8 or %o0, 0x1f8, %o0 ! 40032df8 <== NOT EXECUTED } 4001c658: 81 c7 e0 08 ret <== NOT EXECUTED 4001c65c: 81 e8 00 00 restore <== NOT EXECUTED if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE)) 4001c660: 7f ff e2 75 call 40015034 <== NOT EXECUTED 4001c664: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED 4001c668: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001c66c: 02 bf ff e4 be 4001c5fc <== NOT EXECUTED 4001c670: 01 00 00 00 nop <== NOT EXECUTED printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n", 4001c674: 40 00 19 c6 call 40022d8c <== NOT EXECUTED 4001c678: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001c67c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4001c680: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 4001c684: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED 4001c688: 7f ff e2 f8 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c68c: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 40032db8 <== NOT EXECUTED 4001c690: 30 bf ff db b,a 4001c5fc <== NOT EXECUTED printf ("rtems-rfs: buffer-close: closing\n"); 4001c694: 7f ff e3 04 call 400152a4 <__wrap_puts> <== NOT EXECUTED 4001c698: 90 12 21 90 or %o0, 0x190, %o0 <== NOT EXECUTED rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs)); 4001c69c: 10 bf ff d2 b 4001c5e4 <== NOT EXECUTED 4001c6a0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED =============================================================================== 4001beb4 : { 4001beb4: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_buffer_handle_has_block (handle)) 4001beb8: c2 06 60 08 ld [ %i1 + 8 ], %g1 4001bebc: 80 a0 60 00 cmp %g1, 0 4001bec0: 02 80 00 1b be 4001bf2c 4001bec4: ba 10 00 18 mov %i0, %i5 if (block && (rtems_rfs_buffer_bnum (handle) == block)) 4001bec8: 80 a6 a0 00 cmp %i2, 0 4001becc: 02 80 00 06 be 4001bee4 <== NEVER TAKEN 4001bed0: 90 10 20 00 clr %o0 4001bed4: c2 06 60 04 ld [ %i1 + 4 ], %g1 4001bed8: 80 a0 40 1a cmp %g1, %i2 4001bedc: 02 80 00 7a be 4001c0c4 4001bee0: 01 00 00 00 nop if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 4001bee4: 7f ff e4 54 call 40015034 4001bee8: 92 10 21 00 mov 0x100, %o1 ! 100 <_TLS_Alignment+0xff> 4001beec: 80 a2 20 00 cmp %o0, 0 4001bef0: 32 80 00 4f bne,a 4001c02c <== NEVER TAKEN 4001bef4: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED if (rtems_rfs_buffer_handle_has_block (handle)) 4001bef8: c2 06 60 08 ld [ %i1 + 8 ], %g1 4001befc: 80 a0 60 00 cmp %g1, 0 4001bf00: 22 80 00 0a be,a 4001bf28 <== NEVER TAKEN 4001bf04: c0 2e 40 00 clrb [ %i1 ] <== NOT EXECUTED 4001bf08: 92 10 00 19 mov %i1, %o1 4001bf0c: 7f ff ff 5b call 4001bc78 4001bf10: 90 10 00 1d mov %i5, %o0 if (rc > 0) 4001bf14: b0 92 20 00 orcc %o0, 0, %i0 4001bf18: 24 80 00 04 ble,a 4001bf28 <== ALWAYS TAKEN 4001bf1c: c0 2e 40 00 clrb [ %i1 ] } 4001bf20: 81 c7 e0 08 ret <== NOT EXECUTED 4001bf24: 81 e8 00 00 restore <== NOT EXECUTED handle->bnum = 0; 4001bf28: c0 26 60 04 clr [ %i1 + 4 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 4001bf2c: 90 10 20 00 clr %o0 4001bf30: 7f ff e4 41 call 40015034 4001bf34: 92 10 21 00 mov 0x100, %o1 4001bf38: 80 a2 20 00 cmp %o0, 0 4001bf3c: 32 80 00 59 bne,a 4001c0a0 <== NEVER TAKEN 4001bf40: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED if (fs->buffers_count) 4001bf44: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 4001bf48: 80 a0 60 00 cmp %g1, 0 4001bf4c: 12 80 00 41 bne 4001c050 4001bf50: 94 10 00 1a mov %i2, %o2 if (!rtems_rfs_fs_no_local_cache (fs) && 4001bf54: c4 07 40 00 ld [ %i5 ], %g2 4001bf58: 80 88 a0 02 btst 2, %g2 4001bf5c: 12 80 00 26 bne 4001bff4 4001bf60: c2 06 60 08 ld [ %i1 + 8 ], %g1 4001bf64: 80 a0 60 00 cmp %g1, 0 4001bf68: 22 80 00 69 be,a 4001c10c 4001bf6c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 rtems_rfs_buffer_refs_up (handle); 4001bf70: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 old_last = tail->previous; 4001bf74: c6 07 60 4c ld [ %i5 + 0x4c ], %g3 return &the_chain->Tail.Node; 4001bf78: 88 07 60 48 add %i5, 0x48, %g4 4001bf7c: 84 00 a0 01 inc %g2 the_node->next = tail; 4001bf80: c8 20 40 00 st %g4, [ %g1 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 4001bf84: 90 10 20 00 clr %o0 rtems_rfs_buffer_refs_up (handle); 4001bf88: c4 20 60 30 st %g2, [ %g1 + 0x30 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 4001bf8c: 92 10 21 00 mov 0x100, %o1 tail->previous = the_node; 4001bf90: c2 27 60 4c st %g1, [ %i5 + 0x4c ] old_last->next = the_node; 4001bf94: c2 20 c0 00 st %g1, [ %g3 ] fs->buffers_count++; 4001bf98: c4 07 60 50 ld [ %i5 + 0x50 ], %g2 the_node->previous = old_last; 4001bf9c: c6 20 60 04 st %g3, [ %g1 + 4 ] 4001bfa0: 84 00 a0 01 inc %g2 4001bfa4: c4 27 60 50 st %g2, [ %i5 + 0x50 ] handle->buffer->user = (void*) ((intptr_t) block); 4001bfa8: f4 20 60 34 st %i2, [ %g1 + 0x34 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 4001bfac: 7f ff e4 22 call 40015034 4001bfb0: f4 26 60 04 st %i2, [ %i1 + 4 ] 4001bfb4: 80 a2 20 00 cmp %o0, 0 4001bfb8: 02 80 00 43 be 4001c0c4 <== ALWAYS TAKEN 4001bfbc: 80 a6 e0 00 cmp %i3, 0 printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n", 4001bfc0: 12 80 00 43 bne 4001c0cc <== NOT EXECUTED 4001bfc4: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED 4001bfc8: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED 4001bfcc: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED return 0; 4001bfd0: b0 10 20 00 clr %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n", 4001bfd4: 15 10 00 ca sethi %hi(0x40032800), %o2 <== NOT EXECUTED 4001bfd8: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4001bfdc: 94 12 a2 08 or %o2, 0x208, %o2 <== NOT EXECUTED 4001bfe0: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED 4001bfe4: 7f ff e4 a1 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001bfe8: 90 12 22 e0 or %o0, 0x2e0, %o0 ! 40032ae0 <== NOT EXECUTED 4001bfec: 81 c7 e0 08 ret <== NOT EXECUTED 4001bff0: 81 e8 00 00 restore <== NOT EXECUTED if (!rtems_rfs_buffer_handle_has_block (handle)) 4001bff4: 80 a0 60 00 cmp %g1, 0 4001bff8: 32 bf ff df bne,a 4001bf74 <== NEVER TAKEN 4001bffc: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 <== NOT EXECUTED rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer); 4001c000: 96 06 60 08 add %i1, 8, %o3 4001c004: 94 10 00 1b mov %i3, %o2 4001c008: 92 10 00 1a mov %i2, %o1 4001c00c: 40 00 12 21 call 40020890 4001c010: 90 10 00 1d mov %i5, %o0 if (rc > 0) 4001c014: b0 92 20 00 orcc %o0, 0, %i0 4001c018: 14 80 00 4f bg 4001c154 <== NEVER TAKEN 4001c01c: 90 10 20 00 clr %o0 rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle)); 4001c020: c2 06 60 08 ld [ %i1 + 8 ], %g1 node->next = NULL; 4001c024: 10 bf ff d3 b 4001bf70 4001c028: c0 20 40 00 clr [ %g1 ] printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n", 4001c02c: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED 4001c030: 7f ff e4 8e call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c034: 90 12 22 10 or %o0, 0x210, %o0 ! 40032a10 <== NOT EXECUTED if (rtems_rfs_buffer_handle_has_block (handle)) 4001c038: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED 4001c03c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001c040: 32 bf ff b3 bne,a 4001bf0c <== NOT EXECUTED 4001c044: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED handle->dirty = false; 4001c048: 10 bf ff b8 b 4001bf28 <== NOT EXECUTED 4001c04c: c0 2e 40 00 clrb [ %i1 ] <== NOT EXECUTED handle->buffer = rtems_rfs_scan_chain (&fs->buffers, 4001c050: 92 07 60 50 add %i5, 0x50, %o1 4001c054: 7f ff fe 9a call 4001babc 4001c058: 90 07 60 44 add %i5, 0x44, %o0 if (rtems_rfs_buffer_handle_has_block (handle) && 4001c05c: 80 a2 20 00 cmp %o0, 0 4001c060: 02 80 00 26 be 4001c0f8 4001c064: d0 26 60 08 st %o0, [ %i1 + 8 ] rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 4001c068: 90 10 20 00 clr %o0 4001c06c: 7f ff e3 f2 call 40015034 4001c070: 92 10 21 00 mov 0x100, %o1 if (rtems_rfs_buffer_handle_has_block (handle) && 4001c074: 80 a2 20 00 cmp %o0, 0 4001c078: 22 bf ff b8 be,a 4001bf58 <== ALWAYS TAKEN 4001c07c: c4 07 40 00 ld [ %i5 ], %g2 rtems_rfs_buffer_refs (handle) + 1); 4001c080: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED printf ("rtems-rfs: buffer-request: buffer shared: refs: %d\n", 4001c084: d2 00 60 30 ld [ %g1 + 0x30 ], %o1 <== NOT EXECUTED 4001c088: 92 02 60 01 inc %o1 <== NOT EXECUTED 4001c08c: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED 4001c090: 7f ff e4 76 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c094: 90 12 22 70 or %o0, 0x270, %o0 ! 40032a70 <== NOT EXECUTED if (!rtems_rfs_fs_no_local_cache (fs) && 4001c098: 10 bf ff b0 b 4001bf58 <== NOT EXECUTED 4001c09c: c4 07 40 00 ld [ %i5 ], %g2 <== NOT EXECUTED printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block); 4001c0a0: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED 4001c0a4: 7f ff e4 71 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c0a8: 90 12 22 48 or %o0, 0x248, %o0 ! 40032a48 <== NOT EXECUTED if (fs->buffers_count) 4001c0ac: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 <== NOT EXECUTED 4001c0b0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001c0b4: 22 bf ff a9 be,a 4001bf58 <== NOT EXECUTED 4001c0b8: c4 07 40 00 ld [ %i5 ], %g2 <== NOT EXECUTED handle->buffer = rtems_rfs_scan_chain (&fs->buffers, 4001c0bc: 10 bf ff e5 b 4001c050 <== NOT EXECUTED 4001c0c0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED return 0; 4001c0c4: 81 c7 e0 08 ret 4001c0c8: 91 e8 20 00 restore %g0, 0, %o0 printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n", 4001c0cc: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED 4001c0d0: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED return 0; 4001c0d4: b0 10 20 00 clr %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n", 4001c0d8: 15 10 00 ca sethi %hi(0x40032800), %o2 <== NOT EXECUTED 4001c0dc: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4001c0e0: 94 12 a2 00 or %o2, 0x200, %o2 <== NOT EXECUTED 4001c0e4: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED 4001c0e8: 7f ff e4 60 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c0ec: 90 12 22 e0 or %o0, 0x2e0, %o0 ! 40032ae0 <== NOT EXECUTED 4001c0f0: 81 c7 e0 08 ret <== NOT EXECUTED 4001c0f4: 81 e8 00 00 restore <== NOT EXECUTED if (!rtems_rfs_fs_no_local_cache (fs) && 4001c0f8: c2 07 40 00 ld [ %i5 ], %g1 4001c0fc: 80 88 60 02 btst 2, %g1 4001c100: 12 bf ff c1 bne 4001c004 4001c104: 96 06 60 08 add %i1, 8, %o3 if (fs->release_count) 4001c108: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 4001c10c: 80 a0 60 00 cmp %g1, 0 4001c110: 12 80 00 25 bne 4001c1a4 4001c114: 94 10 00 1a mov %i2, %o2 if (!rtems_rfs_buffer_handle_has_block (handle) && 4001c118: c2 07 60 70 ld [ %i5 + 0x70 ], %g1 4001c11c: 80 a0 60 00 cmp %g1, 0 4001c120: 02 bf ff b9 be 4001c004 4001c124: 96 06 60 08 add %i1, 8, %o3 handle->buffer = rtems_rfs_scan_chain (&fs->release_modified, 4001c128: 94 10 00 1a mov %i2, %o2 4001c12c: 92 07 60 70 add %i5, 0x70, %o1 4001c130: 7f ff fe 63 call 4001babc 4001c134: 90 07 60 64 add %i5, 0x64, %o0 4001c138: d0 26 60 08 st %o0, [ %i1 + 8 ] if (rtems_rfs_buffer_handle_has_block (handle)) 4001c13c: 80 a2 20 00 cmp %o0, 0 4001c140: 02 bf ff b0 be 4001c000 4001c144: 82 10 00 08 mov %o0, %g1 rtems_rfs_buffer_mark_dirty (handle); 4001c148: 84 10 20 01 mov 1, %g2 4001c14c: 10 bf ff 89 b 4001bf70 4001c150: c4 2e 40 00 stb %g2, [ %i1 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST)) 4001c154: 7f ff e3 b8 call 40015034 <== NOT EXECUTED 4001c158: 92 10 21 00 mov 0x100, %o1 <== NOT EXECUTED 4001c15c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001c160: 02 bf ff 70 be 4001bf20 <== NOT EXECUTED 4001c164: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n", 4001c168: 12 80 00 18 bne 4001c1c8 <== NOT EXECUTED 4001c16c: 3b 10 00 ca sethi %hi(0x40032800), %i5 <== NOT EXECUTED 4001c170: 3b 10 00 ca sethi %hi(0x40032800), %i5 <== NOT EXECUTED 4001c174: ba 17 62 08 or %i5, 0x208, %i5 ! 40032a08 <== NOT EXECUTED 4001c178: 40 00 1b 05 call 40022d8c <== NOT EXECUTED 4001c17c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001c180: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED 4001c184: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED 4001c188: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 4001c18c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4001c190: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED 4001c194: 7f ff e4 35 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c198: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 40032aa8 <== NOT EXECUTED 4001c19c: 81 c7 e0 08 ret <== NOT EXECUTED 4001c1a0: 81 e8 00 00 restore <== NOT EXECUTED handle->buffer = rtems_rfs_scan_chain (&fs->release, 4001c1a4: 92 07 60 60 add %i5, 0x60, %o1 4001c1a8: 7f ff fe 45 call 4001babc 4001c1ac: 90 07 60 54 add %i5, 0x54, %o0 4001c1b0: d0 26 60 08 st %o0, [ %i1 + 8 ] if (!rtems_rfs_buffer_handle_has_block (handle) && 4001c1b4: 80 a2 20 00 cmp %o0, 0 4001c1b8: 12 bf ff 6e bne 4001bf70 4001c1bc: 82 10 00 08 mov %o0, %g1 4001c1c0: 10 bf ff d7 b 4001c11c 4001c1c4: c2 07 60 70 ld [ %i5 + 0x70 ], %g1 printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n", 4001c1c8: 10 bf ff ec b 4001c178 <== NOT EXECUTED 4001c1cc: ba 17 62 00 or %i5, 0x200, %i5 <== NOT EXECUTED =============================================================================== 4001c1f4 : { 4001c1f4: 9d e3 bf 40 save %sp, -192, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC)) 4001c1f8: 90 10 20 00 clr %o0 4001c1fc: 7f ff e3 8e call 40015034 4001c200: 92 10 20 20 mov 0x20, %o1 4001c204: 80 a2 20 00 cmp %o0, 0 4001c208: 12 80 00 26 bne 4001c2a0 <== NEVER TAKEN 4001c20c: 92 10 00 18 mov %i0, %o1 fs->device = open (name, O_RDWR); 4001c210: 92 10 20 02 mov 2, %o1 4001c214: 7f ff b7 f6 call 4000a1ec 4001c218: 90 10 00 18 mov %i0, %o0 if (fs->device < 0) 4001c21c: 80 a2 20 00 cmp %o0, 0 4001c220: 06 80 00 15 bl 4001c274 <== NEVER TAKEN 4001c224: d0 26 60 0c st %o0, [ %i1 + 0xc ] if (fstat (fs->device, &st) < 0) 4001c228: 7f ff b4 91 call 4000946c 4001c22c: 92 07 bf a0 add %fp, -96, %o1 4001c230: 80 a2 20 00 cmp %o0, 0 4001c234: 06 80 00 32 bl 4001c2fc <== NEVER TAKEN 4001c238: 05 00 00 3c sethi %hi(0xf000), %g2 if (!S_ISBLK (st.st_mode)) 4001c23c: c2 07 bf ac ld [ %fp + -84 ], %g1 4001c240: 82 08 40 02 and %g1, %g2, %g1 4001c244: 05 00 00 18 sethi %hi(0x6000), %g2 4001c248: 80 a0 40 02 cmp %g1, %g2 4001c24c: 22 80 00 1a be,a 4001c2b4 <== ALWAYS TAKEN 4001c250: d0 06 60 0c ld [ %i1 + 0xc ], %o0 if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN)) 4001c254: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001c258: 7f ff e3 77 call 40015034 <== NOT EXECUTED 4001c25c: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED 4001c260: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001c264: 12 80 00 38 bne 4001c344 <== NOT EXECUTED 4001c268: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED return ENXIO; 4001c26c: 81 c7 e0 08 ret <== NOT EXECUTED 4001c270: 91 e8 20 06 restore %g0, 6, %o0 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN)) 4001c274: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001c278: 7f ff e3 6f call 40015034 <== NOT EXECUTED 4001c27c: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED 4001c280: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001c284: 02 bf ff fa be 4001c26c <== NOT EXECUTED 4001c288: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED return ENXIO; 4001c28c: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-open: cannot open file\n"); 4001c290: 7f ff e4 05 call 400152a4 <__wrap_puts> <== NOT EXECUTED 4001c294: 90 12 23 48 or %o0, 0x348, %o0 <== NOT EXECUTED 4001c298: 81 c7 e0 08 ret <== NOT EXECUTED 4001c29c: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: buffer-open: opening: %s\n", name); 4001c2a0: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED 4001c2a4: 7f ff e3 f1 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c2a8: 90 12 23 20 or %o0, 0x320, %o0 ! 40032b20 <== NOT EXECUTED fs->device = open (name, O_RDWR); 4001c2ac: 10 bf ff da b 4001c214 <== NOT EXECUTED 4001c2b0: 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); 4001c2b4: 94 06 60 10 add %i1, 0x10, %o2 4001c2b8: 13 10 01 10 sethi %hi(0x40044000), %o1 4001c2bc: 7f ff b4 df call 40009638 4001c2c0: 92 12 62 09 or %o1, 0x209, %o1 ! 40044209 4001c2c4: b0 10 00 08 mov %o0, %i0 if (rv != 0) 4001c2c8: 80 a6 20 00 cmp %i0, 0 4001c2cc: 02 80 00 24 be 4001c35c <== ALWAYS TAKEN 4001c2d0: 90 10 20 00 clr %o0 if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN)) 4001c2d4: 7f ff e3 58 call 40015034 <== NOT EXECUTED 4001c2d8: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED 4001c2dc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001c2e0: 02 bf ff e3 be 4001c26c <== NOT EXECUTED 4001c2e4: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED return ENXIO; 4001c2e8: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-open: cannot obtain the disk\n"); 4001c2ec: 7f ff e3 ee call 400152a4 <__wrap_puts> <== NOT EXECUTED 4001c2f0: 90 12 23 e0 or %o0, 0x3e0, %o0 <== NOT EXECUTED 4001c2f4: 81 c7 e0 08 ret <== NOT EXECUTED 4001c2f8: 81 e8 00 00 restore <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN)) 4001c2fc: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001c300: 7f ff e3 4d call 40015034 <== NOT EXECUTED 4001c304: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED 4001c308: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001c30c: 02 bf ff d8 be 4001c26c <== NOT EXECUTED 4001c310: 01 00 00 00 nop <== NOT EXECUTED name, strerror (errno)); 4001c314: 40 00 12 55 call 40020c68 <__errno> <== NOT EXECUTED 4001c318: 01 00 00 00 nop <== NOT EXECUTED printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n", 4001c31c: 40 00 1a 9c call 40022d8c <== NOT EXECUTED 4001c320: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED 4001c324: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED 4001c328: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED return ENXIO; 4001c32c: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n", 4001c330: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED 4001c334: 7f ff e3 cd call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c338: 90 12 23 78 or %o0, 0x378, %o0 ! 40032b78 <== NOT EXECUTED 4001c33c: 81 c7 e0 08 ret <== NOT EXECUTED 4001c340: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name); 4001c344: 11 10 00 ca sethi %hi(0x40032800), %o0 <== NOT EXECUTED return ENXIO; 4001c348: b0 10 20 06 mov 6, %i0 <== NOT EXECUTED printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name); 4001c34c: 7f ff e3 c7 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c350: 90 12 23 a8 or %o0, 0x3a8, %o0 <== NOT EXECUTED 4001c354: 81 c7 e0 08 ret <== NOT EXECUTED 4001c358: 81 e8 00 00 restore <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC)) 4001c35c: 7f ff e3 36 call 40015034 4001c360: 92 10 20 20 mov 0x20, %o1 4001c364: 80 a2 20 00 cmp %o0, 0 4001c368: 32 80 00 04 bne,a 4001c378 <== NEVER TAKEN 4001c36c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 <== NOT EXECUTED } 4001c370: 81 c7 e0 08 ret 4001c374: 81 e8 00 00 restore printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n", 4001c378: d4 00 60 20 ld [ %g1 + 0x20 ], %o2 <== NOT EXECUTED 4001c37c: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED 4001c380: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED 4001c384: 7f ff e3 b9 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c388: 90 12 20 10 or %o0, 0x10, %o0 ! 40032c10 <== NOT EXECUTED } 4001c38c: 81 c7 e0 08 ret <== NOT EXECUTED 4001c390: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 4001c4bc : { 4001c4bc: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 4001c4c0: 90 10 20 00 clr %o0 { 4001c4c4: f2 27 a0 48 st %i1, [ %fp + 0x48 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 4001c4c8: 7f ff e2 db call 40015034 4001c4cc: 92 10 24 00 mov 0x400, %o1 4001c4d0: 80 a2 20 00 cmp %o0, 0 4001c4d4: 12 80 00 37 bne 4001c5b0 <== NEVER TAKEN 4001c4d8: d2 07 a0 48 ld [ %fp + 0x48 ], %o1 rc = rtems_rfs_buffers_release (fs); 4001c4dc: 7f ff ff d4 call 4001c42c 4001c4e0: 90 10 00 18 mov %i0, %o0 if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 4001c4e4: ba 92 20 00 orcc %o0, 0, %i5 4001c4e8: 14 80 00 25 bg 4001c57c <== NEVER TAKEN 4001c4ec: 90 10 20 00 clr %o0 rc = rtems_rfs_buffer_sync (fs); 4001c4f0: 7f ff ff a9 call 4001c394 4001c4f4: 90 10 00 18 mov %i0, %o0 if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 4001c4f8: ba 92 20 00 orcc %o0, 0, %i5 4001c4fc: 14 80 00 12 bg 4001c544 <== NEVER TAKEN 4001c500: 90 10 20 00 clr %o0 rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size); 4001c504: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 4001c508: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 4001c50c: 94 07 a0 48 add %fp, 0x48, %o2 4001c510: 13 20 01 10 sethi %hi(0x80044000), %o1 4001c514: 9f c0 40 00 call %g1 4001c518: 92 12 62 04 or %o1, 0x204, %o1 ! 80044204 if (rc < 0) 4001c51c: b0 92 20 00 orcc %o0, 0, %i0 4001c520: 06 80 00 04 bl 4001c530 <== NEVER TAKEN 4001c524: 01 00 00 00 nop } 4001c528: 81 c7 e0 08 ret 4001c52c: 81 e8 00 00 restore rc = errno; 4001c530: 40 00 11 ce call 40020c68 <__errno> <== NOT EXECUTED 4001c534: 01 00 00 00 nop <== NOT EXECUTED 4001c538: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED } 4001c53c: 81 c7 e0 08 ret <== NOT EXECUTED 4001c540: 81 e8 00 00 restore <== NOT EXECUTED if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 4001c544: 7f ff e2 bc call 40015034 <== NOT EXECUTED 4001c548: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED 4001c54c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001c550: 22 bf ff ee be,a 4001c508 <== NOT EXECUTED 4001c554: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n", 4001c558: 40 00 1a 0d call 40022d8c <== NOT EXECUTED 4001c55c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 4001c560: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001c564: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 4001c568: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED 4001c56c: 7f ff e3 3f call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c570: 90 12 21 50 or %o0, 0x150, %o0 ! 40032d50 <== NOT EXECUTED rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size); 4001c574: 10 bf ff e5 b 4001c508 <== NOT EXECUTED 4001c578: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE)) 4001c57c: 7f ff e2 ae call 40015034 <== NOT EXECUTED 4001c580: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED 4001c584: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001c588: 02 bf ff da be 4001c4f0 <== NOT EXECUTED 4001c58c: 01 00 00 00 nop <== NOT EXECUTED printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n", 4001c590: 40 00 19 ff call 40022d8c <== NOT EXECUTED 4001c594: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 4001c598: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001c59c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 4001c5a0: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED 4001c5a4: 7f ff e3 31 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c5a8: 90 12 21 10 or %o0, 0x110, %o0 ! 40032d10 <== NOT EXECUTED 4001c5ac: 30 bf ff d1 b,a 4001c4f0 <== NOT EXECUTED printf ("rtems-rfs: buffer-setblksize: block size: %" PRIu32 "\n", size); 4001c5b0: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED 4001c5b4: 7f ff e3 2d call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c5b8: 90 12 20 e0 or %o0, 0xe0, %o0 ! 40032ce0 <== NOT EXECUTED 4001c5bc: 30 bf ff c8 b,a 4001c4dc <== NOT EXECUTED =============================================================================== 4001c394 : { 4001c394: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC)) 4001c398: 90 10 20 00 clr %o0 4001c39c: 92 10 20 20 mov 0x20, %o1 4001c3a0: 7f ff e3 25 call 40015034 4001c3a4: ba 10 00 18 mov %i0, %i5 4001c3a8: 80 a2 20 00 cmp %o0, 0 4001c3ac: 12 80 00 1d bne 4001c420 <== NEVER TAKEN 4001c3b0: 11 10 00 cb sethi %hi(0x40032c00), %o0 sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs)); 4001c3b4: 7f ff ed c0 call 40017ab4 4001c3b8: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 int result = 0; 4001c3bc: b0 10 20 00 clr %i0 if (sc != RTEMS_SUCCESSFUL) 4001c3c0: 80 a2 20 00 cmp %o0, 0 4001c3c4: 12 80 00 06 bne 4001c3dc <== NEVER TAKEN 4001c3c8: b8 10 00 08 mov %o0, %i4 rtems_disk_release (fs->disk); 4001c3cc: 7f ff a0 e8 call 4000476c 4001c3d0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 } 4001c3d4: 81 c7 e0 08 ret 4001c3d8: 81 e8 00 00 restore if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC)) 4001c3dc: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001c3e0: 92 10 20 20 mov 0x20, %o1 <== NOT EXECUTED 4001c3e4: 7f ff e3 14 call 40015034 <== NOT EXECUTED 4001c3e8: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED 4001c3ec: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001c3f0: 02 bf ff f7 be 4001c3cc <== NOT EXECUTED 4001c3f4: 01 00 00 00 nop <== NOT EXECUTED printf ("rtems-rfs: buffer-sync: device sync failed: %s\n", 4001c3f8: 40 00 11 12 call 40020840 <== NOT EXECUTED 4001c3fc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED 4001c400: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED 4001c404: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED 4001c408: 7f ff e3 98 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c40c: 90 12 20 60 or %o0, 0x60, %o0 ! 40032c60 <== NOT EXECUTED rtems_disk_release (fs->disk); 4001c410: 7f ff a0 d7 call 4000476c <== NOT EXECUTED 4001c414: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED } 4001c418: 81 c7 e0 08 ret <== NOT EXECUTED 4001c41c: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: buffer-sync: syncing\n"); 4001c420: 7f ff e3 a1 call 400152a4 <__wrap_puts> <== NOT EXECUTED 4001c424: 90 12 20 40 or %o0, 0x40, %o0 <== NOT EXECUTED 4001c428: 30 bf ff e3 b,a 4001c3b4 <== NOT EXECUTED =============================================================================== 4001c42c : int rtems_rfs_buffers_release (rtems_rfs_file_system* fs) { 4001c42c: 9d e3 bf a0 save %sp, -96, %sp int rrc = 0; int rc; if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE)) 4001c430: 90 10 20 00 clr %o0 4001c434: 92 10 20 40 mov 0x40, %o1 4001c438: 7f ff e2 ff call 40015034 4001c43c: ba 10 00 18 mov %i0, %i5 4001c440: 80 a2 20 00 cmp %o0, 0 4001c444: 32 80 00 17 bne,a 4001c4a0 <== NEVER TAKEN 4001c448: 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, 4001c44c: 94 10 20 00 clr %o2 4001c450: 92 07 60 60 add %i5, 0x60, %o1 4001c454: 7f ff fd e1 call 4001bbd8 4001c458: 90 07 60 54 add %i5, 0x54, %o0 4001c45c: 92 07 60 70 add %i5, 0x70, %o1 4001c460: 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, 4001c464: 94 10 20 01 mov 1, %o2 if ((rc > 0) && (rrc == 0)) 4001c468: 80 a6 20 00 cmp %i0, 0 4001c46c: 04 80 00 06 ble 4001c484 <== ALWAYS TAKEN 4001c470: 90 07 60 64 add %i5, 0x64, %o0 rc = rtems_rfs_release_chain (&fs->release_modified, 4001c474: 7f ff fd d9 call 4001bbd8 <== NOT EXECUTED 4001c478: 01 00 00 00 nop <== NOT EXECUTED true); if ((rc > 0) && (rrc == 0)) rrc = rc; return rrc; } 4001c47c: 81 c7 e0 08 ret <== NOT EXECUTED 4001c480: 81 e8 00 00 restore <== NOT EXECUTED rc = rtems_rfs_release_chain (&fs->release_modified, 4001c484: 7f ff fd d5 call 4001bbd8 4001c488: 01 00 00 00 nop 4001c48c: 82 38 00 08 xnor %g0, %o0, %g1 4001c490: 83 38 60 1f sra %g1, 0x1f, %g1 4001c494: b0 0a 00 01 and %o0, %g1, %i0 4001c498: 81 c7 e0 08 ret 4001c49c: 81 e8 00 00 restore printf ("rtems-rfs: buffers-release: active:%" PRIu32 " " 4001c4a0: d4 06 20 60 ld [ %i0 + 0x60 ], %o2 <== NOT EXECUTED 4001c4a4: d2 06 20 50 ld [ %i0 + 0x50 ], %o1 <== NOT EXECUTED 4001c4a8: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED 4001c4ac: 7f ff e3 6f call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c4b0: 90 12 20 90 or %o0, 0x90, %o0 ! 40032c90 <== NOT EXECUTED rc = rtems_rfs_release_chain (&fs->release, 4001c4b4: 10 bf ff e7 b 4001c450 <== NOT EXECUTED 4001c4b8: 94 10 20 00 clr %o2 <== NOT EXECUTED =============================================================================== 4001cbe4 : 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) { 4001cbe4: 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)) 4001cbe8: 90 10 20 00 clr %o0 4001cbec: 7f ff e1 12 call 40015034 4001cbf0: 13 08 00 00 sethi %hi(0x20000000), %o1 4001cbf4: 80 a2 20 00 cmp %o0, 0 4001cbf8: 12 80 00 3e bne 4001ccf0 <== NEVER TAKEN 4001cbfc: 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); 4001cc00: 94 07 bf b0 add %fp, -80, %o2 4001cc04: 7f ff f8 92 call 4001ae4c 4001cc08: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001cc0c: a0 92 20 00 orcc %o0, 0, %l0 4001cc10: 24 80 00 04 ble,a 4001cc20 <== ALWAYS TAKEN 4001cc14: c0 2f bf a4 clrb [ %fp + -92 ] } rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_block_map_close (fs, &map); return rc; } 4001cc18: 81 c7 e0 08 ret 4001cc1c: 91 e8 00 10 restore %g0, %l0, %o0 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001cc20: 27 00 00 3f sethi %hi(0xfc00), %l3 handle->bnum = 0; 4001cc24: c0 27 bf a8 clr [ %fp + -88 ] 4001cc28: a6 14 e3 ff or %l3, 0x3ff, %l3 handle->buffer = NULL; 4001cc2c: c0 27 bf ac clr [ %fp + -84 ] if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) < 4001cc30: a4 06 e0 0a add %i3, 0xa, %l2 bpos->bno = 0; 4001cc34: c0 27 bf 98 clr [ %fp + -104 ] bpos->boff = 0; 4001cc38: c0 27 bf 9c clr [ %fp + -100 ] bpos->block = 0; 4001cc3c: c0 27 bf a0 clr [ %fp + -96 ] rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block); 4001cc40: 96 07 bf 94 add %fp, -108, %o3 4001cc44: 94 07 bf 98 add %fp, -104, %o2 4001cc48: 92 07 bf b0 add %fp, -80, %o1 4001cc4c: 7f ff f9 52 call 4001b194 4001cc50: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001cc54: a0 92 20 00 orcc %o0, 0, %l0 4001cc58: 04 80 00 88 ble 4001ce78 4001cc5c: 80 a4 20 06 cmp %l0, 6 if (rc != ENXIO) 4001cc60: 12 80 00 d9 bne 4001cfc4 <== NEVER TAKEN 4001cc64: 96 07 bf 94 add %fp, -108, %o3 rc = rtems_rfs_block_map_grow (fs, &map, 1, &block); 4001cc68: 94 10 20 01 mov 1, %o2 4001cc6c: 92 07 bf b0 add %fp, -80, %o1 4001cc70: 7f ff f9 cd call 4001b3a4 4001cc74: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001cc78: a0 92 20 00 orcc %o0, 0, %l0 4001cc7c: 14 80 00 c1 bg 4001cf80 <== NEVER TAKEN 4001cc80: c2 07 bf 98 ld [ %fp + -104 ], %g1 bpos.bno++; 4001cc84: 82 00 60 01 inc %g1 rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read); 4001cc88: d4 07 bf 94 ld [ %fp + -108 ], %o2 4001cc8c: 96 10 20 00 clr %o3 bpos.bno++; 4001cc90: c2 27 bf 98 st %g1, [ %fp + -104 ] rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read); 4001cc94: 92 07 bf a4 add %fp, -92, %o1 4001cc98: 7f ff fc 87 call 4001beb4 4001cc9c: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001cca0: a0 92 20 00 orcc %o0, 0, %l0 4001cca4: 04 80 00 27 ble 4001cd40 <== ALWAYS TAKEN 4001cca8: c2 07 bf ac ld [ %fp + -84 ], %g1 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) 4001ccac: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001ccb0: 7f ff e0 e1 call 40015034 <== NOT EXECUTED 4001ccb4: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED 4001ccb8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001ccbc: 32 80 00 a7 bne,a 4001cf58 <== NOT EXECUTED 4001ccc0: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001ccc4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED 4001ccc8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001cccc: 7f ff fd 41 call 4001c1d0 4001ccd0: 01 00 00 00 nop rtems_rfs_block_map_close (fs, &map); 4001ccd4: 92 07 bf b0 add %fp, -80, %o1 handle->dirty = false; 4001ccd8: c0 2f bf a4 clrb [ %fp + -92 ] 4001ccdc: 90 10 00 18 mov %i0, %o0 handle->bnum = 0; 4001cce0: c0 27 bf a8 clr [ %fp + -88 ] 4001cce4: 7f ff f8 b9 call 4001afc8 4001cce8: c0 27 bf ac clr [ %fp + -84 ] return rc; 4001ccec: 30 bf ff cb b,a 4001cc18 printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=", 4001ccf0: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001ccf4: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED 4001ccf8: 7f ff e1 5c call 40015268 <__wrap_printf> <== NOT EXECUTED 4001ccfc: 90 12 21 00 or %o0, 0x100, %o0 ! 40033100 <== NOT EXECUTED for (c = 0; c < length; c++) 4001cd00: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 4001cd04: 02 80 00 09 be 4001cd28 <== NOT EXECUTED 4001cd08: a0 06 c0 1a add %i3, %i2, %l0 <== NOT EXECUTED 4001cd0c: ba 10 00 1a mov %i2, %i5 <== NOT EXECUTED printf ("%c", name[c]); 4001cd10: 7f ff e1 6b call 400152bc <__wrap_putchar> <== NOT EXECUTED 4001cd14: d0 4f 40 00 ldsb [ %i5 ], %o0 <== NOT EXECUTED 4001cd18: ba 07 60 01 inc %i5 <== NOT EXECUTED for (c = 0; c < length; c++) 4001cd1c: 80 a4 00 1d cmp %l0, %i5 <== NOT EXECUTED 4001cd20: 12 bf ff fc bne 4001cd10 <== NOT EXECUTED 4001cd24: 01 00 00 00 nop <== NOT EXECUTED printf (", len=%zd\n", length); 4001cd28: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 4001cd2c: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED 4001cd30: 7f ff e1 4e call 40015268 <__wrap_printf> <== NOT EXECUTED 4001cd34: 90 12 21 30 or %o0, 0x130, %o0 ! 40033130 <== NOT EXECUTED rc = rtems_rfs_block_map_open (fs, dir, &map); 4001cd38: 10 bf ff b2 b 4001cc00 <== NOT EXECUTED 4001cd3c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED entry = rtems_rfs_buffer_data (&buffer); 4001cd40: fa 00 60 1c ld [ %g1 + 0x1c ], %i5 memset (entry, 0xff, rtems_rfs_fs_block_size (fs)); 4001cd44: d4 06 20 08 ld [ %i0 + 8 ], %o2 4001cd48: 92 10 20 ff mov 0xff, %o1 4001cd4c: 40 00 13 6a call 40021af4 4001cd50: 90 10 00 1d mov %i5, %o0 while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 4001cd54: c8 06 20 08 ld [ %i0 + 8 ], %g4 4001cd58: 86 81 3f f6 addcc %g4, -10, %g3 4001cd5c: 02 bf ff ba be 4001cc44 <== NEVER TAKEN 4001cd60: 96 07 bf 94 add %fp, -108, %o3 elength = rtems_rfs_dir_entry_length (entry); 4001cd64: d4 0f 60 08 ldub [ %i5 + 8 ], %o2 4001cd68: e0 0f 60 09 ldub [ %i5 + 9 ], %l0 eino = rtems_rfs_dir_entry_ino (entry); 4001cd6c: c4 0f 40 00 ldub [ %i5 ], %g2 4001cd70: c2 0f 60 01 ldub [ %i5 + 1 ], %g1 4001cd74: e2 0f 60 02 ldub [ %i5 + 2 ], %l1 4001cd78: d6 0f 60 03 ldub [ %i5 + 3 ], %o3 elength = rtems_rfs_dir_entry_length (entry); 4001cd7c: 95 2a a0 08 sll %o2, 8, %o2 eino = rtems_rfs_dir_entry_ino (entry); 4001cd80: 85 28 a0 18 sll %g2, 0x18, %g2 elength = rtems_rfs_dir_entry_length (entry); 4001cd84: a0 14 00 0a or %l0, %o2, %l0 eino = rtems_rfs_dir_entry_ino (entry); 4001cd88: 83 28 60 10 sll %g1, 0x10, %g1 4001cd8c: a3 2c 60 08 sll %l1, 8, %l1 4001cd90: 82 10 40 02 or %g1, %g2, %g1 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001cd94: 80 a4 00 13 cmp %l0, %l3 eino = rtems_rfs_dir_entry_ino (entry); 4001cd98: a2 14 40 01 or %l1, %g1, %l1 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001cd9c: 02 80 00 4d be 4001ced0 4001cda0: a2 12 c0 11 or %o3, %l1, %l1 offset = 0; 4001cda4: 10 80 00 1f b 4001ce20 4001cda8: a8 10 20 00 clr %l4 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 4001cdac: 80 a0 40 10 cmp %g1, %l0 4001cdb0: 08 80 00 1f bleu 4001ce2c <== NEVER TAKEN 4001cdb4: 80 a4 60 00 cmp %l1, 0 4001cdb8: 02 80 00 1e be 4001ce30 <== NEVER TAKEN 4001cdbc: 90 10 20 00 clr %o0 4001cdc0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 4001cdc4: 80 a0 40 11 cmp %g1, %l1 4001cdc8: 0a 80 00 1a bcs 4001ce30 <== NEVER TAKEN 4001cdcc: 01 00 00 00 nop offset += elength; 4001cdd0: a8 05 00 10 add %l4, %l0, %l4 while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 4001cdd4: 80 a0 c0 14 cmp %g3, %l4 4001cdd8: 08 bf ff 9a bleu 4001cc40 <== NEVER TAKEN 4001cddc: ba 07 40 10 add %i5, %l0, %i5 elength = rtems_rfs_dir_entry_length (entry); 4001cde0: d4 0f 60 08 ldub [ %i5 + 8 ], %o2 4001cde4: e0 0f 60 09 ldub [ %i5 + 9 ], %l0 eino = rtems_rfs_dir_entry_ino (entry); 4001cde8: c4 0f 40 00 ldub [ %i5 ], %g2 4001cdec: c2 0f 60 01 ldub [ %i5 + 1 ], %g1 4001cdf0: d6 0f 60 02 ldub [ %i5 + 2 ], %o3 4001cdf4: e2 0f 60 03 ldub [ %i5 + 3 ], %l1 elength = rtems_rfs_dir_entry_length (entry); 4001cdf8: 95 2a a0 08 sll %o2, 8, %o2 eino = rtems_rfs_dir_entry_ino (entry); 4001cdfc: 85 28 a0 18 sll %g2, 0x18, %g2 elength = rtems_rfs_dir_entry_length (entry); 4001ce00: a0 14 00 0a or %l0, %o2, %l0 eino = rtems_rfs_dir_entry_ino (entry); 4001ce04: 83 28 60 10 sll %g1, 0x10, %g1 4001ce08: 97 2a e0 08 sll %o3, 8, %o3 4001ce0c: 82 10 40 02 or %g1, %g2, %g1 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001ce10: 80 a4 00 13 cmp %l0, %l3 eino = rtems_rfs_dir_entry_ino (entry); 4001ce14: 96 12 c0 01 or %o3, %g1, %o3 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001ce18: 02 80 00 2d be 4001cecc 4001ce1c: a2 14 40 0b or %l1, %o3, %l1 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 4001ce20: 80 a4 20 0a cmp %l0, 0xa 4001ce24: 34 bf ff e2 bg,a 4001cdac <== ALWAYS TAKEN 4001ce28: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) 4001ce2c: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001ce30: 7f ff e0 81 call 40015034 <== NOT EXECUTED 4001ce34: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED 4001ce38: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001ce3c: 32 80 00 1c bne,a 4001ceac <== NOT EXECUTED 4001ce40: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001ce44: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED 4001ce48: 7f ff fc e2 call 4001c1d0 <== NOT EXECUTED 4001ce4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED rtems_rfs_block_map_close (fs, &map); 4001ce50: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED handle->dirty = false; 4001ce54: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED 4001ce58: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED handle->bnum = 0; 4001ce5c: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED return EIO; 4001ce60: a0 10 20 05 mov 5, %l0 <== NOT EXECUTED handle->buffer = NULL; 4001ce64: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED rtems_rfs_block_map_close (fs, &map); 4001ce68: 7f ff f8 58 call 4001afc8 <== NOT EXECUTED 4001ce6c: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED } 4001ce70: 81 c7 e0 08 ret <== NOT EXECUTED 4001ce74: 81 e8 00 00 restore <== NOT EXECUTED bpos.bno++; 4001ce78: c2 07 bf 98 ld [ %fp + -104 ], %g1 4001ce7c: 82 00 60 01 inc %g1 rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read); 4001ce80: d4 07 bf 94 ld [ %fp + -108 ], %o2 4001ce84: 96 10 20 01 mov 1, %o3 bpos.bno++; 4001ce88: c2 27 bf 98 st %g1, [ %fp + -104 ] rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read); 4001ce8c: 92 07 bf a4 add %fp, -92, %o1 4001ce90: 7f ff fc 09 call 4001beb4 4001ce94: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001ce98: a0 92 20 00 orcc %o0, 0, %l0 4001ce9c: 14 bf ff 84 bg 4001ccac <== NEVER TAKEN 4001cea0: c2 07 bf ac ld [ %fp + -84 ], %g1 entry = rtems_rfs_buffer_data (&buffer); 4001cea4: 10 bf ff ac b 4001cd54 4001cea8: fa 00 60 1c ld [ %g1 + 0x1c ], %i5 printf ("rtems-rfs: dir-add-entry: " 4001ceac: 98 10 00 14 mov %l4, %o4 <== NOT EXECUTED 4001ceb0: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED 4001ceb4: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED 4001ceb8: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED 4001cebc: 7f ff e0 eb call 40015268 <__wrap_printf> <== NOT EXECUTED 4001cec0: 90 12 22 18 or %o0, 0x218, %o0 ! 40033218 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001cec4: 10 bf ff e1 b 4001ce48 <== NOT EXECUTED 4001cec8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED 4001cecc: 88 21 00 14 sub %g4, %l4, %g4 if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) < 4001ced0: 80 a4 80 04 cmp %l2, %g4 4001ced4: 1a bf ff 5c bcc 4001cc44 <== NEVER TAKEN 4001ced8: 96 07 bf 94 add %fp, -108, %o3 hash = rtems_rfs_dir_hash (name, length); 4001cedc: 92 10 00 1b mov %i3, %o1 4001cee0: 40 00 0e b0 call 400209a0 4001cee4: 90 10 00 1a mov %i2, %o0 rtems_rfs_dir_set_entry_hash (entry, hash); 4001cee8: 87 32 20 18 srl %o0, 0x18, %g3 4001ceec: 85 32 20 10 srl %o0, 0x10, %g2 4001cef0: 83 32 20 08 srl %o0, 8, %g1 rtems_rfs_dir_set_entry_ino (entry, ino); 4001cef4: 89 37 20 18 srl %i4, 0x18, %g4 rtems_rfs_dir_set_entry_hash (entry, hash); 4001cef8: c6 2f 60 04 stb %g3, [ %i5 + 4 ] rtems_rfs_dir_set_entry_ino (entry, ino); 4001cefc: 87 37 20 10 srl %i4, 0x10, %g3 rtems_rfs_dir_set_entry_hash (entry, hash); 4001cf00: c4 2f 60 05 stb %g2, [ %i5 + 5 ] rtems_rfs_dir_set_entry_ino (entry, ino); 4001cf04: 85 37 20 08 srl %i4, 8, %g2 rtems_rfs_dir_set_entry_hash (entry, hash); 4001cf08: c2 2f 60 06 stb %g1, [ %i5 + 6 ] rtems_rfs_dir_set_entry_length (entry, 4001cf0c: 83 2c a0 10 sll %l2, 0x10, %g1 rtems_rfs_dir_set_entry_hash (entry, hash); 4001cf10: d0 2f 60 07 stb %o0, [ %i5 + 7 ] rtems_rfs_dir_set_entry_length (entry, 4001cf14: 83 30 60 18 srl %g1, 0x18, %g1 rtems_rfs_dir_set_entry_ino (entry, ino); 4001cf18: c8 2f 40 00 stb %g4, [ %i5 ] memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length); 4001cf1c: 92 10 00 1a mov %i2, %o1 rtems_rfs_dir_set_entry_length (entry, 4001cf20: c2 2f 60 08 stb %g1, [ %i5 + 8 ] memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length); 4001cf24: 94 10 00 1b mov %i3, %o2 rtems_rfs_dir_set_entry_ino (entry, ino); 4001cf28: c6 2f 60 01 stb %g3, [ %i5 + 1 ] memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length); 4001cf2c: 90 07 60 0a add %i5, 0xa, %o0 rtems_rfs_dir_set_entry_ino (entry, ino); 4001cf30: c4 2f 60 02 stb %g2, [ %i5 + 2 ] return 0; 4001cf34: a0 10 20 00 clr %l0 rtems_rfs_dir_set_entry_ino (entry, ino); 4001cf38: f8 2f 60 03 stb %i4, [ %i5 + 3 ] memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length); 4001cf3c: 40 00 12 64 call 400218cc 4001cf40: e4 2f 60 09 stb %l2, [ %i5 + 9 ] rtems_rfs_buffer_mark_dirty (&buffer); 4001cf44: 82 10 20 01 mov 1, %g1 4001cf48: 92 07 bf a4 add %fp, -92, %o1 4001cf4c: 90 10 00 18 mov %i0, %o0 4001cf50: 10 bf ff 5f b 4001cccc 4001cf54: c2 2f bf a4 stb %g1, [ %fp + -92 ] printf ("rtems-rfs: dir-add-entry: " 4001cf58: 40 00 17 8d call 40022d8c <== NOT EXECUTED 4001cf5c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 4001cf60: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED 4001cf64: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001cf68: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001cf6c: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED 4001cf70: 7f ff e0 be call 40015268 <__wrap_printf> <== NOT EXECUTED 4001cf74: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 400331d0 <== NOT EXECUTED 4001cf78: 10 bf ff 54 b 4001ccc8 <== NOT EXECUTED 4001cf7c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) 4001cf80: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001cf84: 7f ff e0 2c call 40015034 <== NOT EXECUTED 4001cf88: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED 4001cf8c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001cf90: 22 bf ff 4e be,a 4001ccc8 <== NOT EXECUTED 4001cf94: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-add-entry: " 4001cf98: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED 4001cf9c: 40 00 17 7c call 40022d8c <== NOT EXECUTED 4001cfa0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 4001cfa4: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED 4001cfa8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001cfac: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001cfb0: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED 4001cfb4: 7f ff e0 ad call 40015268 <__wrap_printf> <== NOT EXECUTED 4001cfb8: 90 12 21 88 or %o0, 0x188, %o0 ! 40033188 <== NOT EXECUTED 4001cfbc: 10 bf ff 43 b 4001ccc8 <== NOT EXECUTED 4001cfc0: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY)) 4001cfc4: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001cfc8: 7f ff e0 1b call 40015034 <== NOT EXECUTED 4001cfcc: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED 4001cfd0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001cfd4: 22 bf ff 3d be,a 4001ccc8 <== NOT EXECUTED 4001cfd8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-add-entry: " 4001cfdc: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED 4001cfe0: 40 00 17 6b call 40022d8c <== NOT EXECUTED 4001cfe4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED 4001cfe8: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED 4001cfec: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001cff0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001cff4: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED 4001cff8: 7f ff e0 9c call 40015268 <__wrap_printf> <== NOT EXECUTED 4001cffc: 90 12 21 40 or %o0, 0x140, %o0 ! 40033140 <== NOT EXECUTED 4001d000: 10 bf ff 32 b 4001ccc8 <== NOT EXECUTED 4001d004: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED =============================================================================== 4001d008 : int rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir, rtems_rfs_ino ino, uint32_t offset) { 4001d008: 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)) 4001d00c: 90 10 20 00 clr %o0 4001d010: 7f ff e0 09 call 40015034 4001d014: 13 10 00 00 sethi %hi(0x40000000), %o1 4001d018: 80 a2 20 00 cmp %o0, 0 4001d01c: 12 80 00 0a bne 4001d044 <== NEVER TAKEN 4001d020: 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); 4001d024: 94 07 bf b0 add %fp, -80, %o2 4001d028: 7f ff f7 89 call 4001ae4c 4001d02c: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001d030: a4 92 20 00 orcc %o0, 0, %l2 4001d034: 04 80 00 11 ble 4001d078 <== ALWAYS TAKEN 4001d038: 94 10 20 00 clr %o2 } rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_block_map_close (fs, &map); return rc; } 4001d03c: 81 c7 e0 08 ret 4001d040: 91 e8 00 12 restore %g0, %l2, %o0 printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n", 4001d044: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001d048: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED 4001d04c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 4001d050: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED 4001d054: 7f ff e0 85 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001d058: 90 12 22 60 or %o0, 0x260, %o0 ! 40033260 <== NOT EXECUTED rc = rtems_rfs_block_map_open (fs, dir, &map); 4001d05c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4001d060: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED 4001d064: 7f ff f7 7a call 4001ae4c <== NOT EXECUTED 4001d068: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 4001d06c: a4 92 20 00 orcc %o0, 0, %l2 <== NOT EXECUTED 4001d070: 14 bf ff f3 bg 4001d03c <== NOT EXECUTED 4001d074: 94 10 20 00 clr %o2 <== NOT EXECUTED rc = rtems_rfs_block_map_seek (fs, &map, offset, &block); 4001d078: 98 07 bf a0 add %fp, -96, %o4 4001d07c: 96 10 00 1b mov %i3, %o3 4001d080: 92 07 bf b0 add %fp, -80, %o1 4001d084: 7f ff f8 9d call 4001b2f8 4001d088: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001d08c: a4 92 20 00 orcc %o0, 0, %l2 4001d090: 04 80 00 0a ble 4001d0b8 <== ALWAYS TAKEN 4001d094: 80 a4 a0 06 cmp %l2, 6 if (rc == ENXIO) 4001d098: 22 80 00 02 be,a 4001d0a0 <== NOT EXECUTED 4001d09c: a4 10 20 02 mov 2, %l2 <== NOT EXECUTED rtems_rfs_block_map_close (fs, &map); 4001d0a0: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 4001d0a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001d0a8: 7f ff f7 c8 call 4001afc8 <== NOT EXECUTED 4001d0ac: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED } 4001d0b0: 81 c7 e0 08 ret <== NOT EXECUTED 4001d0b4: 81 e8 00 00 restore <== NOT EXECUTED handle->dirty = false; 4001d0b8: c0 2f bf a4 clrb [ %fp + -92 ] if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001d0bc: 27 00 00 3f sethi %hi(0xfc00), %l3 handle->bnum = 0; 4001d0c0: c0 27 bf a8 clr [ %fp + -88 ] 4001d0c4: a6 14 e3 ff or %l3, 0x3ff, %l3 handle->buffer = NULL; 4001d0c8: c0 27 bf ac clr [ %fp + -84 ] rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true); 4001d0cc: 96 10 20 01 mov 1, %o3 4001d0d0: d4 07 bf a0 ld [ %fp + -96 ], %o2 4001d0d4: 92 07 bf a4 add %fp, -92, %o1 4001d0d8: 7f ff fb 77 call 4001beb4 4001d0dc: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001d0e0: a4 92 20 00 orcc %o0, 0, %l2 4001d0e4: 14 80 00 c5 bg 4001d3f8 <== NEVER TAKEN 4001d0e8: 80 a6 e0 00 cmp %i3, 0 if (search) 4001d0ec: 02 80 00 46 be 4001d204 <== NEVER TAKEN 4001d0f0: c8 06 20 08 ld [ %i0 + 8 ], %g4 eoffset = offset % rtems_rfs_fs_block_size (fs); 4001d0f4: 81 80 20 00 wr %g0, %y 4001d0f8: 01 00 00 00 nop 4001d0fc: 01 00 00 00 nop 4001d100: 01 00 00 00 nop 4001d104: 82 76 c0 04 udiv %i3, %g4, %g1 4001d108: 82 58 40 04 smul %g1, %g4, %g1 4001d10c: 82 26 c0 01 sub %i3, %g1, %g1 4001d110: a2 10 00 01 mov %g1, %l1 entry = rtems_rfs_buffer_data (&buffer) + eoffset; 4001d114: c4 07 bf ac ld [ %fp + -84 ], %g2 4001d118: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 4001d11c: 9e 01 3f f6 add %g4, -10, %o7 4001d120: 80 a3 c0 01 cmp %o7, %g1 4001d124: 08 80 00 2b bleu 4001d1d0 <== NEVER TAKEN 4001d128: ba 00 80 01 add %g2, %g1, %i5 elength = rtems_rfs_dir_entry_length (entry); 4001d12c: c6 0f 60 08 ldub [ %i5 + 8 ], %g3 4001d130: f8 0f 60 09 ldub [ %i5 + 9 ], %i4 eino = rtems_rfs_dir_entry_ino (entry); 4001d134: 10 80 00 1a b 4001d19c 4001d138: c4 08 80 01 ldub [ %g2 + %g1 ], %g2 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 4001d13c: 80 a7 20 0a cmp %i4, 0xa 4001d140: 04 80 00 34 ble 4001d210 <== NEVER TAKEN 4001d144: 90 10 20 00 clr %o0 4001d148: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 4001d14c: 80 a0 40 1c cmp %g1, %i4 4001d150: 08 80 00 30 bleu 4001d210 <== NEVER TAKEN 4001d154: 80 a4 20 00 cmp %l0, 0 4001d158: 02 80 00 2f be 4001d214 <== NEVER TAKEN 4001d15c: 13 10 00 00 sethi %hi(0x40000000), %o1 4001d160: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 4001d164: 80 a0 40 10 cmp %g1, %l0 4001d168: 0a 80 00 2a bcs 4001d210 <== NEVER TAKEN 4001d16c: 80 a6 80 10 cmp %i2, %l0 if (ino == rtems_rfs_dir_entry_ino (entry)) 4001d170: 02 80 00 43 be 4001d27c <== ALWAYS TAKEN 4001d174: 80 a6 e0 00 cmp %i3, 0 if (!search) 4001d178: 32 80 00 19 bne,a 4001d1dc <== NOT EXECUTED 4001d17c: a4 10 20 05 mov 5, %l2 <== NOT EXECUTED eoffset += elength; 4001d180: a2 04 40 1c add %l1, %i4, %l1 <== NOT EXECUTED while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 4001d184: 80 a4 40 0f cmp %l1, %o7 <== NOT EXECUTED 4001d188: 1a 80 00 12 bcc 4001d1d0 <== NOT EXECUTED 4001d18c: ba 07 40 1c add %i5, %i4, %i5 <== NOT EXECUTED elength = rtems_rfs_dir_entry_length (entry); 4001d190: c6 0f 60 08 ldub [ %i5 + 8 ], %g3 <== NOT EXECUTED 4001d194: f8 0f 60 09 ldub [ %i5 + 9 ], %i4 <== NOT EXECUTED eino = rtems_rfs_dir_entry_ino (entry); 4001d198: c4 0f 40 00 ldub [ %i5 ], %g2 <== NOT EXECUTED 4001d19c: c2 0f 60 01 ldub [ %i5 + 1 ], %g1 4001d1a0: d6 0f 60 02 ldub [ %i5 + 2 ], %o3 4001d1a4: e0 0f 60 03 ldub [ %i5 + 3 ], %l0 elength = rtems_rfs_dir_entry_length (entry); 4001d1a8: 87 28 e0 08 sll %g3, 8, %g3 eino = rtems_rfs_dir_entry_ino (entry); 4001d1ac: 85 28 a0 18 sll %g2, 0x18, %g2 elength = rtems_rfs_dir_entry_length (entry); 4001d1b0: b8 17 00 03 or %i4, %g3, %i4 eino = rtems_rfs_dir_entry_ino (entry); 4001d1b4: 83 28 60 10 sll %g1, 0x10, %g1 4001d1b8: 97 2a e0 08 sll %o3, 8, %o3 4001d1bc: 82 10 40 02 or %g1, %g2, %g1 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001d1c0: 80 a7 00 13 cmp %i4, %l3 eino = rtems_rfs_dir_entry_ino (entry); 4001d1c4: 96 12 c0 01 or %o3, %g1, %o3 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001d1c8: 12 bf ff dd bne 4001d13c <== ALWAYS TAKEN 4001d1cc: a0 14 00 0b or %l0, %o3, %l0 if (rc == 0) 4001d1d0: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED 4001d1d4: 02 80 00 1f be 4001d250 <== NOT EXECUTED 4001d1d8: 94 07 bf a0 add %fp, -96, %o2 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001d1dc: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED 4001d1e0: 7f ff fb fc call 4001c1d0 <== NOT EXECUTED 4001d1e4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED rtems_rfs_block_map_close (fs, &map); 4001d1e8: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED handle->dirty = false; 4001d1ec: c0 2f bf a4 clrb [ %fp + -92 ] <== NOT EXECUTED 4001d1f0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED handle->bnum = 0; 4001d1f4: c0 27 bf a8 clr [ %fp + -88 ] <== NOT EXECUTED 4001d1f8: 7f ff f7 74 call 4001afc8 <== NOT EXECUTED 4001d1fc: c0 27 bf ac clr [ %fp + -84 ] <== NOT EXECUTED return rc; 4001d200: 30 bf ff 8f b,a 4001d03c <== NOT EXECUTED 4001d204: 82 10 20 00 clr %g1 <== NOT EXECUTED eoffset = 0; 4001d208: 10 bf ff c3 b 4001d114 <== NOT EXECUTED 4001d20c: a2 10 20 00 clr %l1 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) 4001d210: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED 4001d214: 7f ff df 88 call 40015034 <== NOT EXECUTED 4001d218: a4 10 20 05 mov 5, %l2 <== NOT EXECUTED 4001d21c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001d220: 22 bf ff f0 be,a 4001d1e0 <== NOT EXECUTED 4001d224: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-del-entry: " 4001d228: d8 07 bf a0 ld [ %fp + -96 ], %o4 <== NOT EXECUTED 4001d22c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001d230: 9a 10 00 11 mov %l1, %o5 <== NOT EXECUTED 4001d234: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED 4001d238: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED 4001d23c: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED 4001d240: 7f ff e0 0a call 40015268 <__wrap_printf> <== NOT EXECUTED 4001d244: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 400332e8 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001d248: 10 bf ff e6 b 4001d1e0 <== NOT EXECUTED 4001d24c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED rc = rtems_rfs_block_map_next_block (fs, &map, &block); 4001d250: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 4001d254: 7f ff f8 47 call 4001b370 <== NOT EXECUTED 4001d258: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc == ENXIO) 4001d25c: 80 a2 20 06 cmp %o0, 6 <== NOT EXECUTED 4001d260: 02 80 00 77 be 4001d43c <== NOT EXECUTED 4001d264: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED while (rc == 0) 4001d268: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001d26c: 02 bf ff 99 be 4001d0d0 <== NOT EXECUTED 4001d270: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED 4001d274: 10 bf ff db b 4001d1e0 <== NOT EXECUTED 4001d278: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED memmove (entry, entry + elength, remaining); 4001d27c: 92 07 40 1c add %i5, %i4, %o1 4001d280: 90 10 00 1d mov %i5, %o0 remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength); 4001d284: b6 04 40 1c add %l1, %i4, %i3 4001d288: b6 21 00 1b sub %g4, %i3, %i3 memmove (entry, entry + elength, remaining); 4001d28c: 40 00 11 cc call 400219bc 4001d290: 94 10 00 1b mov %i3, %o2 memset (entry + remaining, 0xff, elength); 4001d294: 94 10 00 1c mov %i4, %o2 4001d298: 92 10 20 ff mov 0xff, %o1 4001d29c: 40 00 12 16 call 40021af4 4001d2a0: 90 07 40 1b add %i5, %i3, %o0 elength = rtems_rfs_dir_entry_length (entry); 4001d2a4: c2 0f 60 08 ldub [ %i5 + 8 ], %g1 4001d2a8: 83 28 60 08 sll %g1, 8, %g1 4001d2ac: fa 0f 60 09 ldub [ %i5 + 9 ], %i5 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) 4001d2b0: 90 10 20 00 clr %o0 4001d2b4: 13 10 00 00 sethi %hi(0x40000000), %o1 4001d2b8: 7f ff df 5f call 40015034 4001d2bc: ba 17 40 01 or %i5, %g1, %i5 4001d2c0: 80 a2 20 00 cmp %o0, 0 4001d2c4: 22 80 00 17 be,a 4001d320 <== ALWAYS TAKEN 4001d2c8: 03 3f ff c0 sethi %hi(0xffff0000), %g1 rtems_rfs_block_map_last (&map) ? "yes" : "no"); 4001d2cc: c4 07 bf c0 ld [ %fp + -64 ], %g2 <== NOT EXECUTED printf ("rtems-rfs: dir-del-entry: " 4001d2d0: d6 07 bf a0 ld [ %fp + -96 ], %o3 <== NOT EXECUTED 4001d2d4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001d2d8: 12 80 00 05 bne 4001d2ec <== NOT EXECUTED 4001d2dc: c2 07 bf b8 ld [ %fp + -72 ], %g1 <== NOT EXECUTED rtems_rfs_block_map_last (&map) ? "yes" : "no"); 4001d2e0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001d2e4: 02 80 00 3d be 4001d3d8 <== NOT EXECUTED 4001d2e8: 1b 10 00 c8 sethi %hi(0x40032000), %o5 <== NOT EXECUTED 4001d2ec: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001d2f0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 4001d2f4: 02 80 00 39 be 4001d3d8 <== NOT EXECUTED 4001d2f8: 1b 10 00 c8 sethi %hi(0x40032000), %o5 <== NOT EXECUTED printf ("rtems-rfs: dir-del-entry: " 4001d2fc: 1b 10 00 c2 sethi %hi(0x40030800), %o5 <== NOT EXECUTED 4001d300: 9a 13 60 d8 or %o5, 0xd8, %o5 ! 400308d8 <__func__.8600+0x1c0> <== NOT EXECUTED 4001d304: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED 4001d308: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED 4001d30c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 4001d310: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4001d314: 7f ff df d5 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001d318: 90 12 23 38 or %o0, 0x338, %o0 <== NOT EXECUTED if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) && 4001d31c: 03 3f ff c0 sethi %hi(0xffff0000), %g1 <== NOT EXECUTED 4001d320: ba 38 40 1d xnor %g1, %i5, %i5 4001d324: 80 a7 60 00 cmp %i5, 0 4001d328: 12 80 00 1f bne 4001d3a4 4001d32c: 80 a4 60 00 cmp %l1, 0 4001d330: 12 80 00 1d bne 4001d3a4 <== ALWAYS TAKEN 4001d334: c4 07 bf c0 ld [ %fp + -64 ], %g2 (eoffset == 0) && rtems_rfs_block_map_last (&map)) 4001d338: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 4001d33c: 12 80 00 29 bne 4001d3e0 <== NOT EXECUTED 4001d340: c2 07 bf b8 ld [ %fp + -72 ], %g1 <== NOT EXECUTED 4001d344: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4001d348: 12 80 00 27 bne 4001d3e4 <== NOT EXECUTED 4001d34c: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED rc = rtems_rfs_block_map_shrink (fs, &map, 1); 4001d350: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED 4001d354: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 4001d358: 7f ff f9 10 call 4001b798 <== NOT EXECUTED 4001d35c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 4001d360: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED 4001d364: 04 80 00 10 ble 4001d3a4 <== NOT EXECUTED 4001d368: 90 10 20 00 clr %o0 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) 4001d36c: 7f ff df 32 call 40015034 <== NOT EXECUTED 4001d370: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED 4001d374: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001d378: 02 80 00 0c be 4001d3a8 <== NOT EXECUTED 4001d37c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED printf ("rtems-rfs: dir-del-entry: " 4001d380: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED 4001d384: 40 00 16 82 call 40022d8c <== NOT EXECUTED 4001d388: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 4001d38c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 4001d390: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001d394: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED 4001d398: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED 4001d39c: 7f ff df b3 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001d3a0: 90 12 23 98 or %o0, 0x398, %o0 ! 40033398 <== NOT EXECUTED rtems_rfs_buffer_mark_dirty (&buffer); 4001d3a4: 82 10 20 01 mov 1, %g1 4001d3a8: 92 07 bf a4 add %fp, -92, %o1 4001d3ac: 90 10 00 18 mov %i0, %o0 4001d3b0: 7f ff fb 88 call 4001c1d0 4001d3b4: c2 2f bf a4 stb %g1, [ %fp + -92 ] rtems_rfs_block_map_close (fs, &map); 4001d3b8: 92 07 bf b0 add %fp, -80, %o1 handle->dirty = false; 4001d3bc: c0 2f bf a4 clrb [ %fp + -92 ] 4001d3c0: 90 10 00 18 mov %i0, %o0 handle->bnum = 0; 4001d3c4: c0 27 bf a8 clr [ %fp + -88 ] return 0; 4001d3c8: a4 10 20 00 clr %l2 rtems_rfs_block_map_close (fs, &map); 4001d3cc: 7f ff f6 ff call 4001afc8 4001d3d0: c0 27 bf ac clr [ %fp + -84 ] return 0; 4001d3d4: 30 bf ff 1a b,a 4001d03c printf ("rtems-rfs: dir-del-entry: " 4001d3d8: 10 bf ff cb b 4001d304 <== NOT EXECUTED 4001d3dc: 9a 13 62 70 or %o5, 0x270, %o5 <== NOT EXECUTED (eoffset == 0) && rtems_rfs_block_map_last (&map)) 4001d3e0: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED 4001d3e4: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED 4001d3e8: 12 bf ff f0 bne 4001d3a8 <== NOT EXECUTED 4001d3ec: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED 4001d3f0: 10 bf ff d9 b 4001d354 <== NOT EXECUTED 4001d3f4: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY)) 4001d3f8: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001d3fc: 7f ff df 0e call 40015034 <== NOT EXECUTED 4001d400: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED 4001d404: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001d408: 22 bf ff 76 be,a 4001d1e0 <== NOT EXECUTED 4001d40c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-del-entry: " 4001d410: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED 4001d414: 40 00 16 5e call 40022d8c <== NOT EXECUTED 4001d418: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4001d41c: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED 4001d420: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001d424: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001d428: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED 4001d42c: 7f ff df 8f call 40015268 <__wrap_printf> <== NOT EXECUTED 4001d430: 90 12 22 a0 or %o0, 0x2a0, %o0 ! 400332a0 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001d434: 10 bf ff 6b b 4001d1e0 <== NOT EXECUTED 4001d438: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED rc = ENOENT; 4001d43c: 10 bf ff 68 b 4001d1dc <== NOT EXECUTED 4001d440: a4 10 20 02 mov 2, %l2 <== NOT EXECUTED =============================================================================== 4001d804 : int rtems_rfs_dir_empty (rtems_rfs_file_system* fs, rtems_rfs_inode_handle* dir) { 4001d804: 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)) 4001d808: 90 10 20 00 clr %o0 4001d80c: 7f ff de 0a call 40015034 4001d810: 13 20 00 00 sethi %hi(0x80000000), %o1 4001d814: 80 a2 20 00 cmp %o0, 0 4001d818: 12 80 00 0a bne 4001d840 <== NEVER TAKEN 4001d81c: 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); 4001d820: 94 07 bf b0 add %fp, -80, %o2 4001d824: 7f ff f5 8a call 4001ae4c 4001d828: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001d82c: a4 92 20 00 orcc %o0, 0, %l2 4001d830: 04 80 00 0f ble 4001d86c <== ALWAYS TAKEN 4001d834: 94 10 20 00 clr %o2 rc = ENOTEMPTY; rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_block_map_close (fs, &map); return rc; } 4001d838: 81 c7 e0 08 ret <== NOT EXECUTED 4001d83c: 91 e8 00 12 restore %g0, %l2, %o0 <== NOT EXECUTED printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir)); 4001d840: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001d844: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED 4001d848: 7f ff de 88 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001d84c: 90 12 20 c8 or %o0, 0xc8, %o0 ! 400334c8 <== NOT EXECUTED rc = rtems_rfs_block_map_open (fs, dir, &map); 4001d850: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4001d854: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED 4001d858: 7f ff f5 7d call 4001ae4c <== NOT EXECUTED 4001d85c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 4001d860: a4 92 20 00 orcc %o0, 0, %l2 <== NOT EXECUTED 4001d864: 14 bf ff f5 bg 4001d838 <== NOT EXECUTED 4001d868: 94 10 20 00 clr %o2 <== NOT EXECUTED rc = rtems_rfs_block_map_seek (fs, &map, 0, &block); 4001d86c: 96 10 20 00 clr %o3 4001d870: 98 07 bf a0 add %fp, -96, %o4 4001d874: 92 07 bf b0 add %fp, -80, %o1 4001d878: 7f ff f6 a0 call 4001b2f8 4001d87c: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001d880: a4 92 20 00 orcc %o0, 0, %l2 4001d884: 14 80 00 67 bg 4001da20 <== NEVER TAKEN 4001d888: 23 00 00 3f sethi %hi(0xfc00), %l1 handle->dirty = false; 4001d88c: c0 2f bf a4 clrb [ %fp + -92 ] handle->bnum = 0; 4001d890: c0 27 bf a8 clr [ %fp + -88 ] printf ("rtems-rfs: dir-empty: " 4001d894: 21 10 00 cd sethi %hi(0x40033400), %l0 handle->buffer = NULL; 4001d898: c0 27 bf ac clr [ %fp + -84 ] if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001d89c: a2 14 63 ff or %l1, 0x3ff, %l1 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY)) 4001d8a0: b4 10 20 01 mov 1, %i2 4001d8a4: b6 10 20 00 clr %i3 printf ("rtems-rfs: dir-empty: " 4001d8a8: a0 14 20 e8 or %l0, 0xe8, %l0 rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true); 4001d8ac: d4 07 bf a0 ld [ %fp + -96 ], %o2 4001d8b0: 96 10 20 01 mov 1, %o3 4001d8b4: 92 07 bf a4 add %fp, -92, %o1 4001d8b8: 7f ff f9 7f call 4001beb4 4001d8bc: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001d8c0: a4 92 20 00 orcc %o0, 0, %l2 4001d8c4: 14 80 00 4b bg 4001d9f0 <== NEVER TAKEN 4001d8c8: c2 07 bf ac ld [ %fp + -84 ], %g1 while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 4001d8cc: c8 06 20 08 ld [ %i0 + 8 ], %g4 4001d8d0: 88 81 3f f6 addcc %g4, -10, %g4 4001d8d4: 02 80 00 63 be 4001da60 <== NEVER TAKEN 4001d8d8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 elength = rtems_rfs_dir_entry_length (entry); 4001d8dc: d4 08 60 08 ldub [ %g1 + 8 ], %o2 4001d8e0: fa 08 60 09 ldub [ %g1 + 9 ], %i5 eino = rtems_rfs_dir_entry_ino (entry); 4001d8e4: c6 08 40 00 ldub [ %g1 ], %g3 4001d8e8: c4 08 60 01 ldub [ %g1 + 1 ], %g2 4001d8ec: f8 08 60 02 ldub [ %g1 + 2 ], %i4 4001d8f0: d6 08 60 03 ldub [ %g1 + 3 ], %o3 elength = rtems_rfs_dir_entry_length (entry); 4001d8f4: 95 2a a0 08 sll %o2, 8, %o2 eino = rtems_rfs_dir_entry_ino (entry); 4001d8f8: 87 28 e0 18 sll %g3, 0x18, %g3 elength = rtems_rfs_dir_entry_length (entry); 4001d8fc: ba 17 40 0a or %i5, %o2, %i5 eino = rtems_rfs_dir_entry_ino (entry); 4001d900: 85 28 a0 10 sll %g2, 0x10, %g2 4001d904: b9 2f 20 08 sll %i4, 8, %i4 4001d908: 84 10 80 03 or %g2, %g3, %g2 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001d90c: 80 a7 40 11 cmp %i5, %l1 eino = rtems_rfs_dir_entry_ino (entry); 4001d910: b8 17 00 02 or %i4, %g2, %i4 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001d914: 02 80 00 53 be 4001da60 <== NEVER TAKEN 4001d918: b8 12 c0 1c or %o3, %i4, %i4 offset = 0; 4001d91c: 10 80 00 20 b 4001d99c 4001d920: a6 10 20 00 clr %l3 (entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) && 4001d924: 12 80 00 31 bne 4001d9e8 4001d928: 80 a4 a0 00 cmp %l2, 0 ((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) || 4001d92c: c4 08 60 0a ldub [ %g1 + 0xa ], %g2 4001d930: 80 a0 a0 2e cmp %g2, 0x2e 4001d934: 12 80 00 2d bne 4001d9e8 <== NEVER TAKEN 4001d938: 80 a4 a0 00 cmp %l2, 0 (entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') || 4001d93c: c4 08 60 0b ldub [ %g1 + 0xb ], %g2 4001d940: 80 a0 a0 2e cmp %g2, 0x2e 4001d944: 12 80 00 29 bne 4001d9e8 <== NEVER TAKEN 4001d948: 80 a4 a0 00 cmp %l2, 0 offset += elength; 4001d94c: a6 04 c0 1d add %l3, %i5, %l3 while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 4001d950: 80 a4 c0 04 cmp %l3, %g4 4001d954: 1a 80 00 43 bcc 4001da60 <== NEVER TAKEN 4001d958: 82 00 40 1d add %g1, %i5, %g1 elength = rtems_rfs_dir_entry_length (entry); 4001d95c: d4 08 60 08 ldub [ %g1 + 8 ], %o2 4001d960: fa 08 60 09 ldub [ %g1 + 9 ], %i5 eino = rtems_rfs_dir_entry_ino (entry); 4001d964: c6 08 40 00 ldub [ %g1 ], %g3 4001d968: c4 08 60 01 ldub [ %g1 + 1 ], %g2 4001d96c: d6 08 60 02 ldub [ %g1 + 2 ], %o3 4001d970: f8 08 60 03 ldub [ %g1 + 3 ], %i4 elength = rtems_rfs_dir_entry_length (entry); 4001d974: 95 2a a0 08 sll %o2, 8, %o2 eino = rtems_rfs_dir_entry_ino (entry); 4001d978: 87 28 e0 18 sll %g3, 0x18, %g3 elength = rtems_rfs_dir_entry_length (entry); 4001d97c: ba 17 40 0a or %i5, %o2, %i5 eino = rtems_rfs_dir_entry_ino (entry); 4001d980: 85 28 a0 10 sll %g2, 0x10, %g2 4001d984: 97 2a e0 08 sll %o3, 8, %o3 4001d988: 84 10 80 03 or %g2, %g3, %g2 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001d98c: 80 a7 40 11 cmp %i5, %l1 eino = rtems_rfs_dir_entry_ino (entry); 4001d990: 96 12 c0 02 or %o3, %g2, %o3 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001d994: 02 80 00 33 be 4001da60 4001d998: b8 17 00 0b or %i4, %o3, %i4 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 4001d99c: 80 a7 60 0a cmp %i5, 0xa 4001d9a0: 04 80 00 26 ble 4001da38 <== NEVER TAKEN 4001d9a4: 90 10 00 1a mov %i2, %o0 4001d9a8: c4 06 20 1c ld [ %i0 + 0x1c ], %g2 4001d9ac: 80 a0 80 1d cmp %g2, %i5 4001d9b0: 08 80 00 22 bleu 4001da38 <== NEVER TAKEN 4001d9b4: 80 a7 20 00 cmp %i4, 0 4001d9b8: 02 80 00 20 be 4001da38 <== NEVER TAKEN 4001d9bc: 01 00 00 00 nop 4001d9c0: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 4001d9c4: 80 a0 80 1c cmp %g2, %i4 4001d9c8: 0a 80 00 1c bcs 4001da38 <== NEVER TAKEN 4001d9cc: 80 a7 60 0b cmp %i5, 0xb if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) || 4001d9d0: 12 bf ff d5 bne 4001d924 4001d9d4: 80 a7 60 0c cmp %i5, 0xc 4001d9d8: c4 08 60 0a ldub [ %g1 + 0xa ], %g2 4001d9dc: 80 a0 a0 2e cmp %g2, 0x2e 4001d9e0: 02 bf ff db be 4001d94c <== ALWAYS TAKEN 4001d9e4: 80 a4 a0 00 cmp %l2, 0 if ((rc == 0) && !empty) 4001d9e8: 22 80 00 02 be,a 4001d9f0 <== ALWAYS TAKEN 4001d9ec: a4 10 20 5a mov 0x5a, %l2 rtems_rfs_buffer_handle_release (fs, handle); 4001d9f0: 92 07 bf a4 add %fp, -92, %o1 4001d9f4: 7f ff f9 f7 call 4001c1d0 4001d9f8: 90 10 00 18 mov %i0, %o0 rtems_rfs_block_map_close (fs, &map); 4001d9fc: 92 07 bf b0 add %fp, -80, %o1 handle->dirty = false; 4001da00: c0 2f bf a4 clrb [ %fp + -92 ] 4001da04: 90 10 00 18 mov %i0, %o0 handle->bnum = 0; 4001da08: c0 27 bf a8 clr [ %fp + -88 ] } 4001da0c: b0 10 00 12 mov %l2, %i0 rtems_rfs_block_map_close (fs, &map); 4001da10: 7f ff f5 6e call 4001afc8 4001da14: c0 27 bf ac clr [ %fp + -84 ] } 4001da18: 81 c7 e0 08 ret 4001da1c: 81 e8 00 00 restore rtems_rfs_block_map_close (fs, &map); 4001da20: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 4001da24: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001da28: 7f ff f5 68 call 4001afc8 <== NOT EXECUTED 4001da2c: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED } 4001da30: 81 c7 e0 08 ret <== NOT EXECUTED 4001da34: 81 e8 00 00 restore <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY)) 4001da38: 7f ff dd 7f call 40015034 <== NOT EXECUTED 4001da3c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 4001da40: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001da44: 02 80 00 07 be 4001da60 <== NOT EXECUTED 4001da48: 98 10 00 13 mov %l3, %o4 <== NOT EXECUTED printf ("rtems-rfs: dir-empty: " 4001da4c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001da50: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED 4001da54: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED 4001da58: 7f ff de 04 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001da5c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED rc = rtems_rfs_block_map_next_block (fs, &map, &block); 4001da60: 94 07 bf a0 add %fp, -96, %o2 4001da64: 92 07 bf b0 add %fp, -80, %o1 4001da68: 7f ff f6 42 call 4001b370 4001da6c: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001da70: a4 92 20 00 orcc %o0, 0, %l2 4001da74: 04 bf ff 8f ble 4001d8b0 <== NEVER TAKEN 4001da78: d4 07 bf a0 ld [ %fp + -96 ], %o2 rc = 0; 4001da7c: 82 1c a0 06 xor %l2, 6, %g1 4001da80: 80 a0 00 01 cmp %g0, %g1 4001da84: 82 60 20 00 subx %g0, 0, %g1 4001da88: 10 bf ff da b 4001d9f0 4001da8c: a4 0c 80 01 and %l2, %g1, %l2 =============================================================================== 400209a0 : */ #define initval (20010928) uint32_t rtems_rfs_dir_hash (const void *key, size_t length) { 400209a0: 9d e3 bf a0 save %sp, -96, %sp 400209a4: 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; 400209a8: 31 37 f7 c5 sethi %hi(0xdfdf1400), %i0 400209ac: 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) 400209b0: 80 a6 60 0c cmp %i1, 0xc a = b = c = 0xdeadbeef + ((uint32_t)length) + initval; 400209b4: b6 06 40 18 add %i1, %i0, %i3 400209b8: b0 10 00 1b mov %i3, %i0 while (length > 12) 400209bc: 08 80 00 4b bleu 40020ae8 <== ALWAYS TAKEN 400209c0: 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; 400209c4: fa 08 60 05 ldub [ %g1 + 5 ], %i5 <== NOT EXECUTED b += ((uint32_t)k[6])<<16; 400209c8: c4 08 60 06 ldub [ %g1 + 6 ], %g2 <== NOT EXECUTED b += ((uint32_t)k[7])<<24; c += k[8]; c += ((uint32_t)k[9])<<8; c += ((uint32_t)k[10])<<16; 400209cc: d6 08 60 0a ldub [ %g1 + 0xa ], %o3 <== NOT EXECUTED b += ((uint32_t)k[5])<<8; 400209d0: bb 2f 60 08 sll %i5, 8, %i5 <== NOT EXECUTED c += ((uint32_t)k[9])<<8; 400209d4: c6 08 60 09 ldub [ %g1 + 9 ], %g3 <== NOT EXECUTED c += ((uint32_t)k[11])<<24; 400209d8: d8 08 60 0b ldub [ %g1 + 0xb ], %o4 <== NOT EXECUTED b += ((uint32_t)k[6])<<16; 400209dc: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED b += ((uint32_t)k[7])<<24; 400209e0: 84 07 40 02 add %i5, %g2, %g2 <== NOT EXECUTED c += ((uint32_t)k[10])<<16; 400209e4: bb 2a e0 10 sll %o3, 0x10, %i5 <== NOT EXECUTED c += k[8]; 400209e8: d2 08 60 08 ldub [ %g1 + 8 ], %o1 <== NOT EXECUTED a += ((uint32_t)k[2])<<16; 400209ec: de 08 60 02 ldub [ %g1 + 2 ], %o7 <== NOT EXECUTED c += ((uint32_t)k[9])<<8; 400209f0: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED c += ((uint32_t)k[11])<<24; 400209f4: 86 00 c0 1d add %g3, %i5, %g3 <== NOT EXECUTED 400209f8: bb 2b 20 18 sll %o4, 0x18, %i5 <== NOT EXECUTED a += ((uint32_t)k[1])<<8; 400209fc: c8 08 60 01 ldub [ %g1 + 1 ], %g4 <== NOT EXECUTED a += ((uint32_t)k[3])<<24; 40020a00: f4 08 60 03 ldub [ %g1 + 3 ], %i2 <== NOT EXECUTED c += ((uint32_t)k[11])<<24; 40020a04: 86 00 c0 09 add %g3, %o1, %g3 <== NOT EXECUTED 40020a08: 86 00 c0 1d add %g3, %i5, %g3 <== NOT EXECUTED a += ((uint32_t)k[2])<<16; 40020a0c: bb 2b e0 10 sll %o7, 0x10, %i5 <== NOT EXECUTED c += ((uint32_t)k[11])<<24; 40020a10: b0 00 c0 18 add %g3, %i0, %i0 <== NOT EXECUTED a += k[0]; 40020a14: da 08 40 00 ldub [ %g1 ], %o5 <== NOT EXECUTED a += ((uint32_t)k[1])<<8; 40020a18: 89 29 20 08 sll %g4, 8, %g4 <== NOT EXECUTED mix(a,b,c); 40020a1c: 86 01 00 1d add %g4, %i5, %g3 <== NOT EXECUTED a += ((uint32_t)k[3])<<24; 40020a20: bb 2e a0 18 sll %i2, 0x18, %i5 <== NOT EXECUTED b += k[4]; 40020a24: d0 08 60 04 ldub [ %g1 + 4 ], %o0 <== NOT EXECUTED b += ((uint32_t)k[7])<<24; 40020a28: d4 08 60 07 ldub [ %g1 + 7 ], %o2 <== NOT EXECUTED mix(a,b,c); 40020a2c: 89 2e 20 04 sll %i0, 4, %g4 <== NOT EXECUTED 40020a30: 86 00 c0 0d add %g3, %o5, %g3 <== NOT EXECUTED 40020a34: 86 00 c0 1d add %g3, %i5, %g3 <== NOT EXECUTED 40020a38: bb 36 20 1c srl %i0, 0x1c, %i5 <== NOT EXECUTED 40020a3c: 88 11 00 1d or %g4, %i5, %g4 <== NOT EXECUTED b += ((uint32_t)k[7])<<24; 40020a40: 95 2a a0 18 sll %o2, 0x18, %o2 <== NOT EXECUTED 40020a44: 84 00 80 08 add %g2, %o0, %g2 <== NOT EXECUTED 40020a48: 84 00 80 0a add %g2, %o2, %g2 <== NOT EXECUTED 40020a4c: 84 00 80 1c add %g2, %i4, %g2 <== NOT EXECUTED mix(a,b,c); 40020a50: b8 06 00 02 add %i0, %g2, %i4 <== NOT EXECUTED 40020a54: b0 20 c0 18 sub %g3, %i0, %i0 <== NOT EXECUTED 40020a58: b0 06 00 1b add %i0, %i3, %i0 <== NOT EXECUTED 40020a5c: b0 19 00 18 xor %g4, %i0, %i0 <== NOT EXECUTED 40020a60: b6 06 00 1c add %i0, %i4, %i3 <== NOT EXECUTED 40020a64: 89 2e 20 06 sll %i0, 6, %g4 <== NOT EXECUTED 40020a68: 84 20 80 18 sub %g2, %i0, %g2 <== NOT EXECUTED 40020a6c: b1 36 20 1a srl %i0, 0x1a, %i0 <== NOT EXECUTED 40020a70: b0 11 00 18 or %g4, %i0, %i0 <== NOT EXECUTED 40020a74: 84 1e 00 02 xor %i0, %g2, %g2 <== NOT EXECUTED 40020a78: ba 00 80 1b add %g2, %i3, %i5 <== NOT EXECUTED 40020a7c: b8 27 00 02 sub %i4, %g2, %i4 <== NOT EXECUTED 40020a80: 87 28 a0 08 sll %g2, 8, %g3 <== NOT EXECUTED 40020a84: 85 30 a0 18 srl %g2, 0x18, %g2 <== NOT EXECUTED 40020a88: 86 10 c0 02 or %g3, %g2, %g3 <== NOT EXECUTED 40020a8c: 86 18 c0 1c xor %g3, %i4, %g3 <== NOT EXECUTED 40020a90: 88 00 c0 1d add %g3, %i5, %g4 <== NOT EXECUTED 40020a94: b6 26 c0 03 sub %i3, %g3, %i3 <== NOT EXECUTED 40020a98: b1 28 e0 10 sll %g3, 0x10, %i0 <== NOT EXECUTED 40020a9c: 87 30 e0 10 srl %g3, 0x10, %g3 <== NOT EXECUTED 40020aa0: 86 16 00 03 or %i0, %g3, %g3 <== NOT EXECUTED 40020aa4: b0 18 c0 1b xor %g3, %i3, %i0 <== NOT EXECUTED 40020aa8: 87 2e 20 13 sll %i0, 0x13, %g3 <== NOT EXECUTED 40020aac: b6 06 00 04 add %i0, %g4, %i3 <== NOT EXECUTED 40020ab0: ba 27 40 18 sub %i5, %i0, %i5 <== NOT EXECUTED 40020ab4: 85 36 20 0d srl %i0, 0xd, %g2 <== NOT EXECUTED length -= 12; 40020ab8: b2 06 7f f4 add %i1, -12, %i1 <== NOT EXECUTED mix(a,b,c); 40020abc: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED k += 12; 40020ac0: 82 00 60 0c add %g1, 0xc, %g1 <== NOT EXECUTED mix(a,b,c); 40020ac4: 84 18 80 1d xor %g2, %i5, %g2 <== NOT EXECUTED while (length > 12) 40020ac8: 80 a6 60 0c cmp %i1, 0xc <== NOT EXECUTED mix(a,b,c); 40020acc: 88 21 00 02 sub %g4, %g2, %g4 <== NOT EXECUTED 40020ad0: b1 28 a0 04 sll %g2, 4, %i0 <== NOT EXECUTED 40020ad4: 87 30 a0 1c srl %g2, 0x1c, %g3 <== NOT EXECUTED 40020ad8: b8 00 80 1b add %g2, %i3, %i4 <== NOT EXECUTED 40020adc: b0 16 00 03 or %i0, %g3, %i0 <== NOT EXECUTED while (length > 12) 40020ae0: 18 bf ff b9 bgu 400209c4 <== NOT EXECUTED 40020ae4: b0 1e 00 04 xor %i0, %g4, %i0 <== NOT EXECUTED } /*-------------------------------- last block: affect all 32 bits of (c) */ switch(length) /* all the case statements fall through */ 40020ae8: b3 2e 60 02 sll %i1, 2, %i1 40020aec: 05 10 00 82 sethi %hi(0x40020800), %g2 40020af0: 84 10 a1 6c or %g2, 0x16c, %g2 ! 4002096c 40020af4: c4 00 80 19 ld [ %g2 + %i1 ], %g2 40020af8: 81 c0 80 00 jmp %g2 40020afc: 01 00 00 00 nop { case 12: c+=((uint32_t)k[11])<<24; 40020b00: c4 08 60 0b ldub [ %g1 + 0xb ], %g2 <== NOT EXECUTED 40020b04: 85 28 a0 18 sll %g2, 0x18, %g2 <== NOT EXECUTED 40020b08: b0 06 00 02 add %i0, %g2, %i0 <== NOT EXECUTED case 11: c+=((uint32_t)k[10])<<16; 40020b0c: c4 08 60 0a ldub [ %g1 + 0xa ], %g2 <== NOT EXECUTED 40020b10: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED 40020b14: b0 06 00 02 add %i0, %g2, %i0 <== NOT EXECUTED case 10: c+=((uint32_t)k[9])<<8; 40020b18: c4 08 60 09 ldub [ %g1 + 9 ], %g2 40020b1c: 85 28 a0 08 sll %g2, 8, %g2 40020b20: b0 06 00 02 add %i0, %g2, %i0 case 9 : c+=k[8]; 40020b24: c4 08 60 08 ldub [ %g1 + 8 ], %g2 40020b28: b0 06 00 02 add %i0, %g2, %i0 case 8 : b+=((uint32_t)k[7])<<24; 40020b2c: c4 08 60 07 ldub [ %g1 + 7 ], %g2 40020b30: 85 28 a0 18 sll %g2, 0x18, %g2 40020b34: b8 07 00 02 add %i4, %g2, %i4 case 7 : b+=((uint32_t)k[6])<<16; 40020b38: c4 08 60 06 ldub [ %g1 + 6 ], %g2 40020b3c: 85 28 a0 10 sll %g2, 0x10, %g2 40020b40: b8 07 00 02 add %i4, %g2, %i4 case 6 : b+=((uint32_t)k[5])<<8; 40020b44: c4 08 60 05 ldub [ %g1 + 5 ], %g2 40020b48: 85 28 a0 08 sll %g2, 8, %g2 40020b4c: b8 07 00 02 add %i4, %g2, %i4 case 5 : b+=k[4]; 40020b50: c4 08 60 04 ldub [ %g1 + 4 ], %g2 40020b54: b8 07 00 02 add %i4, %g2, %i4 case 4 : a+=((uint32_t)k[3])<<24; 40020b58: c4 08 60 03 ldub [ %g1 + 3 ], %g2 40020b5c: 85 28 a0 18 sll %g2, 0x18, %g2 40020b60: b6 06 c0 02 add %i3, %g2, %i3 case 3 : a+=((uint32_t)k[2])<<16; 40020b64: c4 08 60 02 ldub [ %g1 + 2 ], %g2 40020b68: 85 28 a0 10 sll %g2, 0x10, %g2 40020b6c: b6 06 c0 02 add %i3, %g2, %i3 case 2 : a+=((uint32_t)k[1])<<8; 40020b70: c4 08 60 01 ldub [ %g1 + 1 ], %g2 40020b74: 85 28 a0 08 sll %g2, 8, %g2 40020b78: b6 06 c0 02 add %i3, %g2, %i3 case 1 : a+=k[0]; 40020b7c: c2 08 40 00 ldub [ %g1 ], %g1 break; case 0 : return c; } } final(a,b,c); 40020b80: 85 37 20 12 srl %i4, 0x12, %g2 case 1 : a+=k[0]; 40020b84: b6 00 40 1b add %g1, %i3, %i3 final(a,b,c); 40020b88: 83 2f 20 0e sll %i4, 0xe, %g1 40020b8c: 82 10 40 02 or %g1, %g2, %g1 40020b90: b0 1f 00 18 xor %i4, %i0, %i0 40020b94: b0 26 00 01 sub %i0, %g1, %i0 40020b98: 85 36 20 15 srl %i0, 0x15, %g2 40020b9c: 83 2e 20 0b sll %i0, 0xb, %g1 40020ba0: 82 10 40 02 or %g1, %g2, %g1 40020ba4: b6 1e c0 18 xor %i3, %i0, %i3 40020ba8: b6 26 c0 01 sub %i3, %g1, %i3 40020bac: 83 2e e0 19 sll %i3, 0x19, %g1 40020bb0: 84 1f 00 1b xor %i4, %i3, %g2 40020bb4: b9 36 e0 07 srl %i3, 7, %i4 40020bb8: b8 17 00 01 or %i4, %g1, %i4 40020bbc: 84 20 80 1c sub %g2, %i4, %g2 40020bc0: 87 30 a0 10 srl %g2, 0x10, %g3 40020bc4: 83 28 a0 10 sll %g2, 0x10, %g1 40020bc8: 82 10 40 03 or %g1, %g3, %g1 40020bcc: b0 1e 00 02 xor %i0, %g2, %i0 40020bd0: b0 26 00 01 sub %i0, %g1, %i0 40020bd4: 83 2e 20 04 sll %i0, 4, %g1 40020bd8: 87 36 20 1c srl %i0, 0x1c, %g3 40020bdc: 82 10 40 03 or %g1, %g3, %g1 40020be0: b6 1e 00 1b xor %i0, %i3, %i3 40020be4: b6 26 c0 01 sub %i3, %g1, %i3 40020be8: 83 2e e0 0e sll %i3, 0xe, %g1 40020bec: 84 1e c0 02 xor %i3, %g2, %g2 40020bf0: b7 36 e0 12 srl %i3, 0x12, %i3 40020bf4: b6 10 40 1b or %g1, %i3, %i3 40020bf8: 84 20 80 1b sub %g2, %i3, %g2 40020bfc: b0 18 80 18 xor %g2, %i0, %i0 40020c00: 83 30 a0 08 srl %g2, 8, %g1 40020c04: 85 28 a0 18 sll %g2, 0x18, %g2 40020c08: 84 10 40 02 or %g1, %g2, %g2 40020c0c: b0 26 00 02 sub %i0, %g2, %i0 return c; } 40020c10: 81 c7 e0 08 ret 40020c14: 81 e8 00 00 restore =============================================================================== 4001c6a4 : rtems_rfs_inode_handle* inode, const char* name, int length, rtems_rfs_ino* ino, uint32_t* offset) { 4001c6a4: 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)) 4001c6a8: 90 10 20 00 clr %o0 4001c6ac: 7f ff e2 62 call 40015034 4001c6b0: 13 01 00 00 sethi %hi(0x4000000), %o1 4001c6b4: 80 a2 20 00 cmp %o0, 0 4001c6b8: 32 80 00 ad bne,a 4001c96c <== NEVER TAKEN 4001c6bc: 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; 4001c6c0: c0 27 00 00 clr [ %i4 ] *offset = 0; rc = rtems_rfs_block_map_open (fs, inode, &map); 4001c6c4: 94 07 bf b0 add %fp, -80, %o2 *offset = 0; 4001c6c8: c0 27 40 00 clr [ %i5 ] rc = rtems_rfs_block_map_open (fs, inode, &map); 4001c6cc: 92 10 00 19 mov %i1, %o1 4001c6d0: 7f ff f9 df call 4001ae4c 4001c6d4: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001c6d8: a6 92 20 00 orcc %o0, 0, %l3 4001c6dc: 24 80 00 15 ble,a 4001c730 <== ALWAYS TAKEN 4001c6e0: 92 10 00 1b mov %i3, %o1 { if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 4001c6e4: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001c6e8: 7f ff e2 53 call 40015034 <== NOT EXECUTED 4001c6ec: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 4001c6f0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001c6f4: 32 80 00 04 bne,a 4001c704 <== NOT EXECUTED 4001c6f8: 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; } 4001c6fc: 81 c7 e0 08 ret 4001c700: 91 e8 00 13 restore %g0, %l3, %o0 printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s", 4001c704: 40 00 19 a2 call 40022d8c <== NOT EXECUTED 4001c708: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED 4001c70c: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED 4001c710: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001c714: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001c718: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED } 4001c71c: b0 10 00 13 mov %l3, %i0 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s", 4001c720: 7f ff e2 d2 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c724: 90 12 22 78 or %o0, 0x278, %o0 <== NOT EXECUTED } 4001c728: 81 c7 e0 08 ret <== NOT EXECUTED 4001c72c: 81 e8 00 00 restore <== NOT EXECUTED handle->dirty = false; 4001c730: c0 2f bf a4 clrb [ %fp + -92 ] hash = rtems_rfs_dir_hash (name, length); 4001c734: 90 10 00 1a mov %i2, %o0 handle->bnum = 0; 4001c738: c0 27 bf a8 clr [ %fp + -88 ] 4001c73c: 40 00 10 99 call 400209a0 4001c740: c0 27 bf ac clr [ %fp + -84 ] rc = rtems_rfs_block_map_seek (fs, &map, 0, &block); 4001c744: 98 07 bf a0 add %fp, -96, %o4 hash = rtems_rfs_dir_hash (name, length); 4001c748: a4 10 00 08 mov %o0, %l2 rc = rtems_rfs_block_map_seek (fs, &map, 0, &block); 4001c74c: 94 10 20 00 clr %o2 4001c750: 96 10 20 00 clr %o3 4001c754: 92 07 bf b0 add %fp, -80, %o1 4001c758: 7f ff fa e8 call 4001b2f8 4001c75c: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001c760: a6 92 20 00 orcc %o0, 0, %l3 4001c764: 14 80 00 95 bg 4001c9b8 <== NEVER TAKEN 4001c768: 2f 10 00 cb sethi %hi(0x40032c00), %l7 printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n", 4001c76c: 82 15 e2 f8 or %l7, 0x2f8, %g1 ! 40032ef8 4001c770: c2 27 bf 9c st %g1, [ %fp + -100 ] printf ("rtems-rfs: dir-lookup-ino: " 4001c774: 03 10 00 cc sethi %hi(0x40033000), %g1 4001c778: 82 10 60 70 or %g1, 0x70, %g1 ! 40033070 4001c77c: c2 27 bf 98 st %g1, [ %fp + -104 ] if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001c780: 23 00 00 3f sethi %hi(0xfc00), %l1 printf ("rtems-rfs: dir-lookup-ino: " 4001c784: 2d 10 00 cb sethi %hi(0x40032c00), %l6 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001c788: a2 14 63 ff or %l1, 0x3ff, %l1 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 4001c78c: a8 10 20 00 clr %l4 4001c790: 2b 02 00 00 sethi %hi(0x8000000), %l5 printf ("rtems-rfs: dir-lookup-ino: " 4001c794: ac 15 a3 c8 or %l6, 0x3c8, %l6 while ((rc == 0) && block) 4001c798: 80 a4 e0 00 cmp %l3, 0 4001c79c: 12 80 00 90 bne 4001c9dc <== NEVER TAKEN 4001c7a0: c2 07 bf a0 ld [ %fp + -96 ], %g1 4001c7a4: 80 a0 60 00 cmp %g1, 0 4001c7a8: 02 80 00 fe be 4001cba0 <== NEVER TAKEN 4001c7ac: 90 10 20 00 clr %o0 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 4001c7b0: 7f ff e2 21 call 40015034 4001c7b4: 13 01 00 00 sethi %hi(0x4000000), %o1 4001c7b8: 80 a2 20 00 cmp %o0, 0 4001c7bc: 12 80 00 b5 bne 4001ca90 <== NEVER TAKEN 4001c7c0: d4 07 bf c0 ld [ %fp + -64 ], %o2 rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true); 4001c7c4: d4 07 bf a0 ld [ %fp + -96 ], %o2 4001c7c8: 96 10 20 01 mov 1, %o3 4001c7cc: 92 07 bf a4 add %fp, -92, %o1 4001c7d0: 7f ff fd b9 call 4001beb4 4001c7d4: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001c7d8: a6 92 20 00 orcc %o0, 0, %l3 4001c7dc: 14 80 00 c4 bg 4001caec <== NEVER TAKEN 4001c7e0: 90 10 20 00 clr %o0 map.bpos.boff = 0; 4001c7e4: c0 27 bf c4 clr [ %fp + -60 ] while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 4001c7e8: d0 06 20 08 ld [ %i0 + 8 ], %o0 entry = rtems_rfs_buffer_data (&entries); 4001c7ec: c2 07 bf ac ld [ %fp + -84 ], %g1 while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 4001c7f0: 80 a2 20 0a cmp %o0, 0xa 4001c7f4: 12 80 00 0a bne 4001c81c <== ALWAYS TAKEN 4001c7f8: e0 00 60 1c ld [ %g1 + 0x1c ], %l0 if (rc == 0) 4001c7fc: 10 80 00 47 b 4001c918 <== NOT EXECUTED 4001c800: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED map.bpos.boff += elength; 4001c804: 82 05 c0 01 add %l7, %g1, %g1 4001c808: c2 27 bf c4 st %g1, [ %fp + -60 ] while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE)) 4001c80c: 86 02 3f f6 add %o0, -10, %g3 4001c810: 80 a0 40 03 cmp %g1, %g3 4001c814: 1a 80 00 40 bcc 4001c914 <== NEVER TAKEN 4001c818: a0 04 00 17 add %l0, %l7, %l0 *ino = rtems_rfs_dir_entry_ino (entry); 4001c81c: d8 0c 00 00 ldub [ %l0 ], %o4 4001c820: de 0c 20 01 ldub [ %l0 + 1 ], %o7 4001c824: c2 0c 20 02 ldub [ %l0 + 2 ], %g1 4001c828: d2 0c 20 03 ldub [ %l0 + 3 ], %o1 ehash = rtems_rfs_dir_entry_hash (entry); 4001c82c: da 0c 20 04 ldub [ %l0 + 4 ], %o5 4001c830: c8 0c 20 05 ldub [ %l0 + 5 ], %g4 4001c834: c6 0c 20 06 ldub [ %l0 + 6 ], %g3 4001c838: d6 0c 20 07 ldub [ %l0 + 7 ], %o3 4001c83c: c4 0c 20 08 ldub [ %l0 + 8 ], %g2 4001c840: d4 0c 20 09 ldub [ %l0 + 9 ], %o2 *ino = rtems_rfs_dir_entry_ino (entry); 4001c844: 99 2b 20 18 sll %o4, 0x18, %o4 4001c848: 9f 2b e0 10 sll %o7, 0x10, %o7 4001c84c: 83 28 60 08 sll %g1, 8, %g1 4001c850: 9e 13 c0 0c or %o7, %o4, %o7 4001c854: 82 10 40 0f or %g1, %o7, %g1 4001c858: 92 12 40 01 or %o1, %g1, %o1 4001c85c: d2 27 00 00 st %o1, [ %i4 ] ehash = rtems_rfs_dir_entry_hash (entry); 4001c860: 9b 2b 60 18 sll %o5, 0x18, %o5 4001c864: 89 29 20 10 sll %g4, 0x10, %g4 4001c868: 87 28 e0 08 sll %g3, 8, %g3 4001c86c: 88 11 00 0d or %g4, %o5, %g4 4001c870: 85 28 a0 08 sll %g2, 8, %g2 4001c874: 86 10 c0 04 or %g3, %g4, %g3 elength = rtems_rfs_dir_entry_length (entry); 4001c878: ae 12 80 02 or %o2, %g2, %l7 if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY) 4001c87c: 80 a5 c0 11 cmp %l7, %l1 4001c880: 02 80 00 25 be 4001c914 4001c884: 86 12 c0 03 or %o3, %g3, %g3 if (rtems_rfs_dir_entry_valid (fs, elength, *ino)) 4001c888: 80 a5 e0 0a cmp %l7, 0xa 4001c88c: 24 80 00 61 ble,a 4001ca10 <== NEVER TAKEN 4001c890: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001c894: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 4001c898: 80 a5 c0 01 cmp %l7, %g1 4001c89c: 1a 80 00 5c bcc 4001ca0c <== NEVER TAKEN 4001c8a0: 80 a2 60 00 cmp %o1, 0 4001c8a4: 22 80 00 5b be,a 4001ca10 <== NEVER TAKEN 4001c8a8: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001c8ac: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 4001c8b0: 80 a2 40 01 cmp %o1, %g1 4001c8b4: 18 80 00 56 bgu 4001ca0c <== NEVER TAKEN 4001c8b8: 80 a4 80 03 cmp %l2, %g3 if (ehash == hash) 4001c8bc: 12 bf ff d2 bne 4001c804 4001c8c0: c2 07 bf c4 ld [ %fp + -60 ], %g1 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK)) 4001c8c4: 90 10 00 14 mov %l4, %o0 4001c8c8: 7f ff e1 db call 40015034 4001c8cc: 92 10 00 15 mov %l5, %o1 4001c8d0: 80 a2 20 00 cmp %o0, 0 4001c8d4: 32 80 00 5f bne,a 4001ca50 <== NEVER TAKEN 4001c8d8: c8 0c 00 00 ldub [ %l0 ], %g4 <== NOT EXECUTED if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0) 4001c8dc: 94 10 00 1b mov %i3, %o2 4001c8e0: 92 10 00 1a mov %i2, %o1 4001c8e4: 40 00 13 d1 call 40021828 4001c8e8: 90 04 20 0a add %l0, 0xa, %o0 4001c8ec: 80 a2 20 00 cmp %o0, 0 4001c8f0: 02 80 00 91 be 4001cb34 <== ALWAYS TAKEN 4001c8f4: c2 07 bf c4 ld [ %fp + -60 ], %g1 map.bpos.boff += elength; 4001c8f8: 82 05 c0 01 add %l7, %g1, %g1 <== NOT EXECUTED 4001c8fc: c2 27 bf c4 st %g1, [ %fp + -60 ] <== NOT EXECUTED 4001c900: 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)) 4001c904: 86 02 3f f6 add %o0, -10, %g3 <== NOT EXECUTED 4001c908: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED 4001c90c: 0a bf ff c4 bcs 4001c81c <== NOT EXECUTED 4001c910: a0 04 00 17 add %l0, %l7, %l0 <== NOT EXECUTED if (rc == 0) 4001c914: 80 a4 e0 00 cmp %l3, 0 4001c918: 12 80 00 32 bne 4001c9e0 <== NEVER TAKEN 4001c91c: 92 07 bf a4 add %fp, -92, %o1 rc = rtems_rfs_block_map_next_block (fs, &map, &block); 4001c920: 94 07 bf a0 add %fp, -96, %o2 4001c924: 92 07 bf b0 add %fp, -80, %o1 4001c928: 7f ff fa 92 call 4001b370 4001c92c: 90 10 00 18 mov %i0, %o0 if ((rc > 0) && (rc != ENXIO)) 4001c930: a6 92 20 00 orcc %o0, 0, %l3 4001c934: 04 80 00 09 ble 4001c958 <== NEVER TAKEN 4001c938: 80 a4 e0 06 cmp %l3, 6 4001c93c: 02 80 00 08 be 4001c95c <== ALWAYS TAKEN 4001c940: 90 10 20 00 clr %o0 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 4001c944: 7f ff e1 bc call 40015034 <== NOT EXECUTED 4001c948: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 4001c94c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001c950: 32 80 00 5e bne,a 4001cac8 <== NOT EXECUTED 4001c954: e0 06 60 08 ld [ %i1 + 8 ], %l0 <== NOT EXECUTED if (rc == ENXIO) 4001c958: 80 a4 e0 06 cmp %l3, 6 <== NOT EXECUTED 4001c95c: 12 bf ff 90 bne 4001c79c <== NEVER TAKEN 4001c960: 80 a4 e0 00 cmp %l3, 0 rc = ENOENT; 4001c964: 10 80 00 1e b 4001c9dc 4001c968: a6 10 20 02 mov 2, %l3 printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=", 4001c96c: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED 4001c970: 7f ff e2 3e call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c974: 90 12 22 30 or %o0, 0x230, %o0 ! 40032e30 <== NOT EXECUTED for (c = 0; c < length; c++) 4001c978: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED 4001c97c: 04 80 00 0a ble 4001c9a4 <== NOT EXECUTED 4001c980: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED 4001c984: a0 10 00 1a mov %i2, %l0 <== NOT EXECUTED 4001c988: a2 06 c0 1a add %i3, %i2, %l1 <== NOT EXECUTED printf ("%c", name[c]); 4001c98c: 7f ff e2 4c call 400152bc <__wrap_putchar> <== NOT EXECUTED 4001c990: d0 4c 00 00 ldsb [ %l0 ], %o0 <== NOT EXECUTED 4001c994: a0 04 20 01 inc %l0 <== NOT EXECUTED for (c = 0; c < length; c++) 4001c998: 80 a4 40 10 cmp %l1, %l0 <== NOT EXECUTED 4001c99c: 12 bf ff fc bne 4001c98c <== NOT EXECUTED 4001c9a0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED printf (", len=%d\n", length); 4001c9a4: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED 4001c9a8: 7f ff e2 30 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001c9ac: 90 12 22 68 or %o0, 0x268, %o0 ! 40032e68 <== NOT EXECUTED *ino = RTEMS_RFS_EMPTY_INO; 4001c9b0: 10 bf ff 45 b 4001c6c4 <== NOT EXECUTED 4001c9b4: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 4001c9b8: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001c9bc: 7f ff e1 9e call 40015034 <== NOT EXECUTED 4001c9c0: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 4001c9c4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001c9c8: 12 80 00 37 bne 4001caa4 <== NOT EXECUTED 4001c9cc: 01 00 00 00 nop <== NOT EXECUTED if (rc == ENXIO) 4001c9d0: 80 a4 e0 06 cmp %l3, 6 <== NOT EXECUTED 4001c9d4: 22 80 00 02 be,a 4001c9dc <== NOT EXECUTED 4001c9d8: a6 10 20 02 mov 2, %l3 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001c9dc: 92 07 bf a4 add %fp, -92, %o1 4001c9e0: 7f ff fd fc call 4001c1d0 4001c9e4: 90 10 00 18 mov %i0, %o0 rtems_rfs_block_map_close (fs, &map); 4001c9e8: 92 07 bf b0 add %fp, -80, %o1 handle->dirty = false; 4001c9ec: c0 2f bf a4 clrb [ %fp + -92 ] 4001c9f0: 90 10 00 18 mov %i0, %o0 handle->bnum = 0; 4001c9f4: c0 27 bf a8 clr [ %fp + -88 ] } 4001c9f8: b0 10 00 13 mov %l3, %i0 rtems_rfs_block_map_close (fs, &map); 4001c9fc: 7f ff f9 73 call 4001afc8 4001ca00: c0 27 bf ac clr [ %fp + -84 ] } 4001ca04: 81 c7 e0 08 ret 4001ca08: 81 e8 00 00 restore if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 4001ca0c: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001ca10: 7f ff e1 89 call 40015034 <== NOT EXECUTED 4001ca14: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 4001ca18: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001ca1c: 12 80 00 04 bne 4001ca2c <== NOT EXECUTED 4001ca20: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED rc = EIO; 4001ca24: 10 bf ff ee b 4001c9dc <== NOT EXECUTED 4001ca28: a6 10 20 05 mov 5, %l3 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: " 4001ca2c: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED 4001ca30: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001ca34: 94 10 00 17 mov %l7, %o2 <== NOT EXECUTED rc = EIO; 4001ca38: a6 10 20 05 mov 5, %l3 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: " 4001ca3c: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED 4001ca40: 7f ff e2 0a call 40015268 <__wrap_printf> <== NOT EXECUTED 4001ca44: 90 12 23 78 or %o0, 0x378, %o0 ! 40032f78 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001ca48: 10 bf ff e6 b 4001c9e0 <== NOT EXECUTED 4001ca4c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: " 4001ca50: c6 0c 20 01 ldub [ %l0 + 1 ], %g3 <== NOT EXECUTED 4001ca54: c2 0c 20 02 ldub [ %l0 + 2 ], %g1 <== NOT EXECUTED 4001ca58: da 0c 20 03 ldub [ %l0 + 3 ], %o5 <== NOT EXECUTED 4001ca5c: 89 29 20 18 sll %g4, 0x18, %g4 <== NOT EXECUTED 4001ca60: d4 1f bf c0 ldd [ %fp + -64 ], %o2 <== NOT EXECUTED 4001ca64: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001ca68: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED 4001ca6c: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED 4001ca70: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED 4001ca74: 82 10 40 03 or %g1, %g3, %g1 <== NOT EXECUTED 4001ca78: 98 10 00 17 mov %l7, %o4 <== NOT EXECUTED 4001ca7c: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED 4001ca80: 7f ff e1 fa call 40015268 <__wrap_printf> <== NOT EXECUTED 4001ca84: 9a 13 40 01 or %o5, %g1, %o5 <== NOT EXECUTED if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0) 4001ca88: 10 bf ff 96 b 4001c8e0 <== NOT EXECUTED 4001ca8c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n", 4001ca90: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001ca94: 7f ff e1 f5 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001ca98: d0 07 bf 9c ld [ %fp + -100 ], %o0 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true); 4001ca9c: 10 bf ff 4b b 4001c7c8 <== NOT EXECUTED 4001caa0: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n", 4001caa4: 40 00 18 ba call 40022d8c <== NOT EXECUTED 4001caa8: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED 4001caac: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 4001cab0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 4001cab4: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED 4001cab8: 7f ff e1 ec call 40015268 <__wrap_printf> <== NOT EXECUTED 4001cabc: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 40032eb8 <== NOT EXECUTED if (rc == ENXIO) 4001cac0: 10 bf ff c5 b 4001c9d4 <== NOT EXECUTED 4001cac4: 80 a4 e0 06 cmp %l3, 6 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: " 4001cac8: 40 00 18 b1 call 40022d8c <== NOT EXECUTED 4001cacc: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED 4001cad0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001cad4: d0 07 bf 98 ld [ %fp + -104 ], %o0 <== NOT EXECUTED 4001cad8: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED 4001cadc: 7f ff e1 e3 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001cae0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED if (rc == ENXIO) 4001cae4: 10 bf ff 9e b 4001c95c <== NOT EXECUTED 4001cae8: 80 a4 e0 06 cmp %l3, 6 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 4001caec: 7f ff e1 52 call 40015034 <== NOT EXECUTED 4001caf0: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 4001caf4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001caf8: 22 bf ff ba be,a 4001c9e0 <== NOT EXECUTED 4001cafc: 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", 4001cb00: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED 4001cb04: f8 07 bf a0 ld [ %fp + -96 ], %i4 <== NOT EXECUTED 4001cb08: 40 00 18 a1 call 40022d8c <== NOT EXECUTED 4001cb0c: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED 4001cb10: 96 10 00 13 mov %l3, %o3 <== NOT EXECUTED 4001cb14: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED 4001cb18: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED 4001cb1c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001cb20: 11 10 00 cb sethi %hi(0x40032c00), %o0 <== NOT EXECUTED 4001cb24: 7f ff e1 d1 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001cb28: 90 12 23 30 or %o0, 0x330, %o0 ! 40032f30 <== NOT EXECUTED 4001cb2c: 10 bf ff ad b 4001c9e0 <== NOT EXECUTED 4001cb30: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED *offset = rtems_rfs_block_map_pos (fs, &map); 4001cb34: 92 07 bf c0 add %fp, -64, %o1 4001cb38: 7f ff f8 ab call 4001ade4 4001cb3c: 90 10 00 18 mov %i0, %o0 4001cb40: d2 27 40 00 st %o1, [ %i5 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND)) 4001cb44: 90 10 20 00 clr %o0 4001cb48: 7f ff e1 3b call 40015034 4001cb4c: 13 04 00 00 sethi %hi(0x10000000), %o1 4001cb50: 80 a2 20 00 cmp %o0, 0 4001cb54: 02 80 00 09 be 4001cb78 <== ALWAYS TAKEN 4001cb58: 92 07 bf a4 add %fp, -92, %o1 printf ("rtems-rfs: dir-lookup-ino: " 4001cb5c: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED 4001cb60: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED 4001cb64: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001cb68: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED 4001cb6c: 7f ff e1 bf call 40015268 <__wrap_printf> <== NOT EXECUTED 4001cb70: 90 12 20 28 or %o0, 0x28, %o0 ! 40033028 <== NOT EXECUTED 4001cb74: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED 4001cb78: 7f ff fd 96 call 4001c1d0 4001cb7c: 90 10 00 18 mov %i0, %o0 rtems_rfs_block_map_close (fs, &map); 4001cb80: 92 07 bf b0 add %fp, -80, %o1 handle->dirty = false; 4001cb84: c0 2f bf a4 clrb [ %fp + -92 ] 4001cb88: 90 10 00 18 mov %i0, %o0 handle->bnum = 0; 4001cb8c: c0 27 bf a8 clr [ %fp + -88 ] return 0; 4001cb90: a6 10 20 00 clr %l3 rtems_rfs_block_map_close (fs, &map); 4001cb94: 7f ff f9 0d call 4001afc8 4001cb98: c0 27 bf ac clr [ %fp + -84 ] return 0; 4001cb9c: 30 bf fe d8 b,a 4001c6fc if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO)) 4001cba0: 7f ff e1 25 call 40015034 <== NOT EXECUTED 4001cba4: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED 4001cba8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001cbac: 22 bf ff 8c be,a 4001c9dc <== NOT EXECUTED 4001cbb0: a6 10 20 05 mov 5, %l3 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n", 4001cbb4: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED 4001cbb8: 40 00 18 75 call 40022d8c <== NOT EXECUTED 4001cbbc: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED 4001cbc0: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED 4001cbc4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001cbc8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED rc = EIO; 4001cbcc: a6 10 20 05 mov 5, %l3 <== NOT EXECUTED printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n", 4001cbd0: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED 4001cbd4: 7f ff e1 a5 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001cbd8: 90 12 20 c0 or %o0, 0xc0, %o0 ! 400330c0 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001cbdc: 10 bf ff 81 b 4001c9e0 <== NOT EXECUTED 4001cbe0: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED =============================================================================== 4001d444 : 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) { 4001d444: 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)) 4001d448: 90 10 20 00 clr %o0 4001d44c: 13 20 00 00 sethi %hi(0x80000000), %o1 4001d450: 7f ff de f9 call 40015034 4001d454: a4 10 00 1a mov %i2, %l2 4001d458: 80 a2 20 00 cmp %o0, 0 4001d45c: 12 80 00 29 bne 4001d500 <== NEVER TAKEN 4001d460: 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; 4001d464: c0 27 40 00 clr [ %i5 ] rc = rtems_rfs_block_map_open (fs, dir, &map); 4001d468: 92 10 00 19 mov %i1, %o1 4001d46c: 94 07 bf b0 add %fp, -80, %o2 4001d470: 7f ff f6 77 call 4001ae4c 4001d474: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001d478: b6 92 20 00 orcc %o0, 0, %i3 4001d47c: 24 80 00 04 ble,a 4001d48c <== ALWAYS TAKEN 4001d480: e0 06 20 08 ld [ %i0 + 8 ], %l0 } rtems_rfs_buffer_handle_close (fs, &buffer); rtems_rfs_block_map_close (fs, &map); return rc; } 4001d484: 81 c7 e0 08 ret <== NOT EXECUTED 4001d488: 91 e8 00 1b restore %g0, %i3, %o0 <== NOT EXECUTED if (((rtems_rfs_fs_block_size (fs) - 4001d48c: b4 10 20 00 clr %i2 (offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE)) 4001d490: 90 10 00 12 mov %l2, %o0 4001d494: 92 10 00 13 mov %l3, %o1 4001d498: 94 10 00 1a mov %i2, %o2 4001d49c: 40 00 47 2c call 4002f14c <__moddi3> 4001d4a0: 96 10 00 10 mov %l0, %o3 if (((rtems_rfs_fs_block_size (fs) - 4001d4a4: 86 a4 00 09 subcc %l0, %o1, %g3 4001d4a8: 84 66 80 08 subx %i2, %o0, %g2 4001d4ac: 80 a0 a0 00 cmp %g2, 0 4001d4b0: 04 80 00 1c ble 4001d520 <== ALWAYS TAKEN 4001d4b4: b6 10 00 10 mov %l0, %i3 rc = rtems_rfs_block_map_seek (fs, &map, offset, &block); 4001d4b8: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED 4001d4bc: 96 10 00 13 mov %l3, %o3 4001d4c0: 98 07 bf a0 add %fp, -96, %o4 4001d4c4: 92 07 bf b0 add %fp, -80, %o1 4001d4c8: 7f ff f7 8c call 4001b2f8 4001d4cc: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001d4d0: b6 92 20 00 orcc %o0, 0, %i3 4001d4d4: 24 80 00 2d ble,a 4001d588 <== ALWAYS TAKEN 4001d4d8: 35 00 00 3f sethi %hi(0xfc00), %i2 if (rc == ENXIO) 4001d4dc: 80 a6 e0 06 cmp %i3, 6 <== NOT EXECUTED 4001d4e0: 22 80 00 02 be,a 4001d4e8 <== NOT EXECUTED 4001d4e4: b6 10 20 02 mov 2, %i3 <== NOT EXECUTED rtems_rfs_block_map_close (fs, &map); 4001d4e8: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 4001d4ec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001d4f0: 7f ff f6 b6 call 4001afc8 <== NOT EXECUTED 4001d4f4: b0 10 00 1b mov %i3, %i0 <== NOT EXECUTED } 4001d4f8: 81 c7 e0 08 ret <== NOT EXECUTED 4001d4fc: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n", 4001d500: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001d504: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 4001d508: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED 4001d50c: 11 10 00 cc sethi %hi(0x40033000), %o0 <== NOT EXECUTED 4001d510: 7f ff df 56 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001d514: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 400333e0 <== NOT EXECUTED *length = 0; 4001d518: 10 bf ff d4 b 4001d468 <== NOT EXECUTED 4001d51c: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED if (((rtems_rfs_fs_block_size (fs) - 4001d520: 12 80 00 06 bne 4001d538 <== NEVER TAKEN 4001d524: 96 10 00 1b mov %i3, %o3 4001d528: 80 a0 e0 0a cmp %g3, 0xa 4001d52c: 38 bf ff e4 bgu,a 4001d4bc <== ALWAYS TAKEN 4001d530: 94 10 00 12 mov %l2, %o2 offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) * 4001d534: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED 4001d538: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED 4001d53c: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED 4001d540: 40 00 46 78 call 4002ef20 <__divdi3> <== NOT EXECUTED 4001d544: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 4001d548: 86 82 60 01 addcc %o1, 1, %g3 <== NOT EXECUTED 4001d54c: 84 42 20 00 addx %o0, 0, %g2 <== NOT EXECUTED 4001d550: 82 58 80 10 smul %g2, %l0, %g1 <== NOT EXECUTED 4001d554: a6 54 00 03 umul %l0, %g3, %l3 <== NOT EXECUTED 4001d558: a5 40 00 00 rd %y, %l2 <== NOT EXECUTED rc = rtems_rfs_block_map_seek (fs, &map, offset, &block); 4001d55c: 98 07 bf a0 add %fp, -96, %o4 <== NOT EXECUTED offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) * 4001d560: a4 00 40 12 add %g1, %l2, %l2 <== NOT EXECUTED rc = rtems_rfs_block_map_seek (fs, &map, offset, &block); 4001d564: 96 10 00 13 mov %l3, %o3 <== NOT EXECUTED 4001d568: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED 4001d56c: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED 4001d570: 7f ff f7 62 call 4001b2f8 <== NOT EXECUTED 4001d574: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED if (rc > 0) 4001d578: b6 92 20 00 orcc %o0, 0, %i3 <== NOT EXECUTED 4001d57c: 14 bf ff d9 bg 4001d4e0 <== NOT EXECUTED 4001d580: 80 a6 e0 06 cmp %i3, 6 <== NOT EXECUTED if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY) 4001d584: 35 00 00 3f sethi %hi(0xfc00), %i2 <== NOT EXECUTED printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n", 4001d588: 2d 10 00 cd sethi %hi(0x40033400), %l6 handle->dirty = false; 4001d58c: c0 2f bf a4 clrb [ %fp + -92 ] if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY) 4001d590: b4 16 a3 ff or %i2, 0x3ff, %i2 handle->bnum = 0; 4001d594: c0 27 bf a8 clr [ %fp + -88 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) 4001d598: a8 10 20 00 clr %l4 handle->buffer = NULL; 4001d59c: c0 27 bf ac clr [ %fp + -84 ] 4001d5a0: 2b 20 00 00 sethi %hi(0x80000000), %l5 printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n", 4001d5a4: 10 80 00 0b b 4001d5d0 4001d5a8: ac 15 a0 90 or %l6, 0x90, %l6 rc = rtems_rfs_block_map_next_block (fs, &map, &block); 4001d5ac: 92 07 bf b0 add %fp, -80, %o1 4001d5b0: 7f ff f7 70 call 4001b370 4001d5b4: 90 10 00 18 mov %i0, %o0 if (rc == ENXIO) 4001d5b8: 80 a2 20 06 cmp %o0, 6 4001d5bc: 02 80 00 90 be 4001d7fc <== ALWAYS TAKEN 4001d5c0: b6 10 00 08 mov %o0, %i3 while (rc == 0) 4001d5c4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001d5c8: 12 80 00 60 bne 4001d748 <== NOT EXECUTED 4001d5cc: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true); 4001d5d0: d4 07 bf a0 ld [ %fp + -96 ], %o2 4001d5d4: 96 10 20 01 mov 1, %o3 4001d5d8: 92 07 bf a4 add %fp, -92, %o1 4001d5dc: 7f ff fa 36 call 4001beb4 4001d5e0: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001d5e4: b6 92 20 00 orcc %o0, 0, %i3 4001d5e8: 14 80 00 57 bg 4001d744 <== NEVER TAKEN 4001d5ec: c2 07 bf ac ld [ %fp + -84 ], %g1 entry = rtems_rfs_buffer_data (&buffer); 4001d5f0: e0 00 60 1c ld [ %g1 + 0x1c ], %l0 entry += map.bpos.boff; 4001d5f4: c6 07 bf c4 ld [ %fp + -60 ], %g3 4001d5f8: a0 04 00 03 add %l0, %g3, %l0 4001d5fc: c2 0c 20 08 ldub [ %l0 + 8 ], %g1 4001d600: e2 0c 20 09 ldub [ %l0 + 9 ], %l1 4001d604: 83 28 60 08 sll %g1, 8, %g1 elength = rtems_rfs_dir_entry_length (entry); 4001d608: a2 14 40 01 or %l1, %g1, %l1 if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY) 4001d60c: 80 a4 40 1a cmp %l1, %i2 4001d610: 12 80 00 59 bne 4001d774 4001d614: 90 10 00 14 mov %l4, %o0 *length += rtems_rfs_fs_block_size (fs) - map.bpos.boff; 4001d618: c4 06 20 08 ld [ %i0 + 8 ], %g2 4001d61c: c2 07 40 00 ld [ %i5 ], %g1 4001d620: 84 20 80 03 sub %g2, %g3, %g2 4001d624: 82 00 40 02 add %g1, %g2, %g1 4001d628: c2 27 40 00 st %g1, [ %i5 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) 4001d62c: 7f ff de 82 call 40015034 4001d630: 92 10 00 15 mov %l5, %o1 4001d634: 80 a2 20 00 cmp %o0, 0 4001d638: 22 bf ff dd be,a 4001d5ac <== ALWAYS TAKEN 4001d63c: 94 07 bf a0 add %fp, -96, %o2 printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n", 4001d640: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED 4001d644: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED 4001d648: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED 4001d64c: 7f ff df 07 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001d650: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED rc = rtems_rfs_block_map_next_block (fs, &map, &block); 4001d654: 10 bf ff d6 b 4001d5ac <== NOT EXECUTED 4001d658: 94 07 bf a0 add %fp, -96, %o2 <== NOT EXECUTED if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 4001d65c: 80 a0 40 1a cmp %g1, %i2 4001d660: 0a 80 00 58 bcs 4001d7c0 <== NEVER TAKEN 4001d664: 90 10 20 00 clr %o0 memset (dirent, 0, sizeof (struct dirent)); 4001d668: 94 10 21 18 mov 0x118, %o2 4001d66c: 92 10 20 00 clr %o1 4001d670: 40 00 11 21 call 40021af4 4001d674: 90 10 00 1c mov %i4, %o0 dirent->d_off = rtems_rfs_block_get_pos (fs, &map.bpos); 4001d678: 92 07 bf c0 add %fp, -64, %o1 4001d67c: 7f ff f5 da call 4001ade4 4001d680: 90 10 00 18 mov %i0, %o0 *length += elength; 4001d684: c2 07 40 00 ld [ %i5 ], %g1 dirent->d_reclen = sizeof (struct dirent); 4001d688: 84 10 21 18 mov 0x118, %g2 dirent->d_off = rtems_rfs_block_get_pos (fs, &map.bpos); 4001d68c: d0 3f 20 08 std %o0, [ %i4 + 8 ] *length += elength; 4001d690: 82 04 40 01 add %l1, %g1, %g1 dirent->d_reclen = sizeof (struct dirent); 4001d694: c4 37 20 10 sth %g2, [ %i4 + 0x10 ] *length += elength; 4001d698: c2 27 40 00 st %g1, [ %i5 ] remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength); 4001d69c: c6 07 bf c4 ld [ %fp + -60 ], %g3 4001d6a0: c4 06 20 08 ld [ %i0 + 8 ], %g2 4001d6a4: 84 20 80 03 sub %g2, %g3, %g2 4001d6a8: 84 20 80 11 sub %g2, %l1, %g2 if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE) 4001d6ac: 80 a0 a0 0a cmp %g2, 0xa 4001d6b0: 14 80 00 04 bg 4001d6c0 <== ALWAYS TAKEN 4001d6b4: a2 04 7f f6 add %l1, -10, %l1 *length += remaining; 4001d6b8: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED 4001d6bc: c2 27 40 00 st %g1, [ %i5 ] <== NOT EXECUTED 4001d6c0: 80 a4 60 ff cmp %l1, 0xff 4001d6c4: 34 80 00 02 bg,a 4001d6cc <== NEVER TAKEN 4001d6c8: a2 10 20 ff mov 0xff, %l1 <== NOT EXECUTED memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength); 4001d6cc: 94 10 00 11 mov %l1, %o2 4001d6d0: 92 04 20 0a add %l0, 0xa, %o1 4001d6d4: ba 07 20 14 add %i4, 0x14, %i5 4001d6d8: 40 00 10 7d call 400218cc 4001d6dc: 90 10 00 1d mov %i5, %o0 dirent->d_ino = rtems_rfs_dir_entry_ino (entry); 4001d6e0: c8 0c 00 00 ldub [ %l0 ], %g4 4001d6e4: c4 0c 20 01 ldub [ %l0 + 1 ], %g2 4001d6e8: c2 0c 20 02 ldub [ %l0 + 2 ], %g1 4001d6ec: c6 0c 20 03 ldub [ %l0 + 3 ], %g3 4001d6f0: 89 29 20 18 sll %g4, 0x18, %g4 4001d6f4: 85 28 a0 10 sll %g2, 0x10, %g2 4001d6f8: 83 28 60 08 sll %g1, 8, %g1 4001d6fc: 84 10 80 04 or %g2, %g4, %g2 dirent->d_namlen = elength; 4001d700: e2 37 20 12 sth %l1, [ %i4 + 0x12 ] dirent->d_ino = rtems_rfs_dir_entry_ino (entry); 4001d704: 82 10 40 02 or %g1, %g2, %g1 4001d708: 82 10 c0 01 or %g3, %g1, %g1 4001d70c: c2 27 00 00 st %g1, [ %i4 ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) 4001d710: 90 10 20 00 clr %o0 4001d714: 7f ff de 48 call 40015034 4001d718: 13 20 00 00 sethi %hi(0x80000000), %o1 4001d71c: 80 a2 20 00 cmp %o0, 0 4001d720: 02 80 00 0a be 4001d748 <== ALWAYS TAKEN 4001d724: 92 07 bf a4 add %fp, -92, %o1 printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n", 4001d728: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED 4001d72c: d2 07 20 08 ld [ %i4 + 8 ], %o1 <== NOT EXECUTED 4001d730: d4 07 20 0c ld [ %i4 + 0xc ], %o2 <== NOT EXECUTED 4001d734: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED 4001d738: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED 4001d73c: 7f ff de cb call 40015268 <__wrap_printf> <== NOT EXECUTED 4001d740: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001d744: 92 07 bf a4 add %fp, -92, %o1 4001d748: 7f ff fa a2 call 4001c1d0 4001d74c: 90 10 00 18 mov %i0, %o0 rtems_rfs_block_map_close (fs, &map); 4001d750: 92 07 bf b0 add %fp, -80, %o1 handle->dirty = false; 4001d754: c0 2f bf a4 clrb [ %fp + -92 ] 4001d758: 90 10 00 18 mov %i0, %o0 handle->bnum = 0; 4001d75c: c0 27 bf a8 clr [ %fp + -88 ] } 4001d760: b0 10 00 1b mov %i3, %i0 rtems_rfs_block_map_close (fs, &map); 4001d764: 7f ff f6 19 call 4001afc8 4001d768: c0 27 bf ac clr [ %fp + -84 ] } 4001d76c: 81 c7 e0 08 ret 4001d770: 81 e8 00 00 restore eino = rtems_rfs_dir_entry_ino (entry); 4001d774: c4 0c 00 00 ldub [ %l0 ], %g2 4001d778: c2 0c 20 01 ldub [ %l0 + 1 ], %g1 4001d77c: d6 0c 20 02 ldub [ %l0 + 2 ], %o3 4001d780: c6 0c 20 03 ldub [ %l0 + 3 ], %g3 4001d784: 85 28 a0 18 sll %g2, 0x18, %g2 4001d788: 83 28 60 10 sll %g1, 0x10, %g1 4001d78c: 97 2a e0 08 sll %o3, 8, %o3 4001d790: 82 10 40 02 or %g1, %g2, %g1 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 4001d794: 80 a4 60 0a cmp %l1, 0xa eino = rtems_rfs_dir_entry_ino (entry); 4001d798: 96 12 c0 01 or %o3, %g1, %o3 if (rtems_rfs_dir_entry_valid (fs, elength, eino)) 4001d79c: 04 80 00 08 ble 4001d7bc <== NEVER TAKEN 4001d7a0: b4 10 c0 0b or %g3, %o3, %i2 4001d7a4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 4001d7a8: 80 a4 40 01 cmp %l1, %g1 4001d7ac: 1a 80 00 04 bcc 4001d7bc <== NEVER TAKEN 4001d7b0: 80 a6 a0 00 cmp %i2, 0 4001d7b4: 32 bf ff aa bne,a 4001d65c <== ALWAYS TAKEN 4001d7b8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ)) 4001d7bc: 90 10 20 00 clr %o0 <== NOT EXECUTED 4001d7c0: 13 20 00 00 sethi %hi(0x80000000), %o1 <== NOT EXECUTED 4001d7c4: 7f ff de 1c call 40015034 <== NOT EXECUTED 4001d7c8: b6 10 20 05 mov 5, %i3 <== NOT EXECUTED 4001d7cc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001d7d0: 22 bf ff de be,a 4001d748 <== NOT EXECUTED 4001d7d4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED printf ("rtems-rfs: dir-read: " 4001d7d8: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED 4001d7dc: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED 4001d7e0: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED 4001d7e4: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED 4001d7e8: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED 4001d7ec: 7f ff de 9f call 40015268 <__wrap_printf> <== NOT EXECUTED 4001d7f0: 90 12 20 10 or %o0, 0x10, %o0 ! 40033410 <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001d7f4: 10 bf ff d5 b 4001d748 <== NOT EXECUTED 4001d7f8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED rc = ENOENT; 4001d7fc: 10 bf ff d2 b 4001d744 4001d800: b6 10 20 02 mov 2, %i3 =============================================================================== 4001ddb8 : { 4001ddb8: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE)) 4001ddbc: 90 10 20 10 mov 0x10, %o0 4001ddc0: 7f ff dc 9d call 40015034 4001ddc4: 92 10 20 00 clr %o1 4001ddc8: 80 a2 20 00 cmp %o0, 0 4001ddcc: 32 80 00 79 bne,a 4001dfb0 <== NEVER TAKEN 4001ddd0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED if (handle->shared->references > 0) 4001ddd4: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 4001ddd8: fa 02 60 08 ld [ %o1 + 8 ], %i5 4001dddc: 80 a7 60 00 cmp %i5, 0 4001dde0: 04 80 00 05 ble 4001ddf4 <== NEVER TAKEN 4001dde4: 01 00 00 00 nop handle->shared->references--; 4001dde8: ba 07 7f ff add %i5, -1, %i5 4001ddec: fa 22 60 08 st %i5, [ %o1 + 8 ] if (handle->shared->references == 0) 4001ddf0: 80 a7 60 00 cmp %i5, 0 4001ddf4: 02 80 00 0b be 4001de20 <== ALWAYS TAKEN 4001ddf8: b8 06 60 04 add %i1, 4, %i4 4001ddfc: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED 4001de00: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001de04: 7f ff f8 f3 call 4001c1d0 <== NOT EXECUTED 4001de08: ba 10 20 00 clr %i5 <== NOT EXECUTED free (handle); 4001de0c: 90 10 00 19 mov %i1, %o0 4001de10: 7f ff ad 81 call 40009414 4001de14: b0 10 00 1d mov %i5, %i0 } 4001de18: 81 c7 e0 08 ret 4001de1c: 81 e8 00 00 restore if (!rtems_rfs_inode_is_loaded (&handle->shared->inode)) 4001de20: c4 02 60 18 ld [ %o1 + 0x18 ], %g2 4001de24: 80 a0 a0 00 cmp %g2, 0 4001de28: 22 80 00 87 be,a 4001e044 <== ALWAYS TAKEN 4001de2c: 92 02 60 0c add %o1, 0xc, %o1 rtems_rfs_inode_set_atime (&handle->shared->inode, 4001de30: c2 02 60 8c ld [ %o1 + 0x8c ], %g1 rtems_rfs_write_u32 (&handle->node->atime, atime); 4001de34: 87 30 60 18 srl %g1, 0x18, %g3 4001de38: c6 28 a0 10 stb %g3, [ %g2 + 0x10 ] 4001de3c: 87 30 60 10 srl %g1, 0x10, %g3 4001de40: c4 02 60 18 ld [ %o1 + 0x18 ], %g2 4001de44: c6 28 a0 11 stb %g3, [ %g2 + 0x11 ] 4001de48: 87 30 60 08 srl %g1, 8, %g3 4001de4c: c4 02 60 18 ld [ %o1 + 0x18 ], %g2 4001de50: c6 28 a0 12 stb %g3, [ %g2 + 0x12 ] rtems_rfs_buffer_mark_dirty (&handle->buffer); 4001de54: 88 10 20 01 mov 1, %g4 rtems_rfs_write_u32 (&handle->node->atime, atime); 4001de58: c4 02 60 18 ld [ %o1 + 0x18 ], %g2 4001de5c: c2 28 a0 13 stb %g1, [ %g2 + 0x13 ] rtems_rfs_inode_set_mtime (&handle->shared->inode, 4001de60: c4 06 60 1c ld [ %i1 + 0x1c ], %g2 4001de64: c2 00 a0 90 ld [ %g2 + 0x90 ], %g1 rtems_rfs_write_u32 (&handle->node->mtime, mtime); 4001de68: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 rtems_rfs_buffer_mark_dirty (&handle->buffer); 4001de6c: c8 2a 60 1c stb %g4, [ %o1 + 0x1c ] rtems_rfs_write_u32 (&handle->node->mtime, mtime); 4001de70: b7 30 60 18 srl %g1, 0x18, %i3 4001de74: f6 28 e0 14 stb %i3, [ %g3 + 0x14 ] 4001de78: b7 30 60 10 srl %g1, 0x10, %i3 4001de7c: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 4001de80: f6 28 e0 15 stb %i3, [ %g3 + 0x15 ] 4001de84: b7 30 60 08 srl %g1, 8, %i3 4001de88: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 4001de8c: f6 28 e0 16 stb %i3, [ %g3 + 0x16 ] 4001de90: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 4001de94: c2 28 e0 17 stb %g1, [ %g3 + 0x17 ] rtems_rfs_inode_set_ctime (&handle->shared->inode, 4001de98: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 4001de9c: c6 00 60 94 ld [ %g1 + 0x94 ], %g3 rtems_rfs_buffer_mark_dirty (&handle->buffer); 4001dea0: c8 28 a0 1c stb %g4, [ %g2 + 0x1c ] rtems_rfs_write_u32 (&handle->node->ctime, ctime); 4001dea4: b7 30 e0 18 srl %g3, 0x18, %i3 4001dea8: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 4001deac: f6 28 a0 18 stb %i3, [ %g2 + 0x18 ] 4001deb0: b7 30 e0 10 srl %g3, 0x10, %i3 4001deb4: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 4001deb8: f6 28 a0 19 stb %i3, [ %g2 + 0x19 ] 4001debc: b7 30 e0 08 srl %g3, 8, %i3 4001dec0: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 4001dec4: f6 28 a0 1a stb %i3, [ %g2 + 0x1a ] 4001dec8: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 4001decc: c6 28 a0 1b stb %g3, [ %g2 + 0x1b ] if (!rtems_rfs_block_size_equal (&handle->shared->size, 4001ded0: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 rtems_rfs_buffer_mark_dirty (&handle->buffer); 4001ded4: c8 28 60 1c stb %g4, [ %g1 + 0x1c ] 4001ded8: c2 02 60 84 ld [ %o1 + 0x84 ], %g1 4001dedc: c4 02 60 3c ld [ %o1 + 0x3c ], %g2 4001dee0: 80 a0 40 02 cmp %g1, %g2 4001dee4: 02 80 00 75 be 4001e0b8 <== ALWAYS TAKEN 4001dee8: 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); 4001deec: c2 22 60 3c st %g1, [ %o1 + 0x3c ] <== NOT EXECUTED map->dirty = true; 4001def0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED rtems_rfs_block_copy_size (&map->size, size); 4001def4: c4 22 60 40 st %g2, [ %o1 + 0x40 ] <== NOT EXECUTED map->dirty = true; 4001def8: c2 2a 60 34 stb %g1, [ %o1 + 0x34 ] <== NOT EXECUTED rc = rtems_rfs_block_map_close (fs, &handle->shared->map); 4001defc: 92 02 60 34 add %o1, 0x34, %o1 <== NOT EXECUTED 4001df00: 7f ff f4 32 call 4001afc8 4001df04: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001df08: b6 92 20 00 orcc %o0, 0, %i3 4001df0c: 14 80 00 44 bg 4001e01c <== NEVER TAKEN 4001df10: 90 10 20 10 mov 0x10, %o0 rc = rtems_rfs_inode_close (fs, &handle->shared->inode); 4001df14: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 4001df18: 92 02 60 0c add %o1, 0xc, %o1 4001df1c: 7f ff d6 88 call 4001393c 4001df20: 90 10 00 18 mov %i0, %o0 if (rc > 0) 4001df24: b6 92 20 00 orcc %o0, 0, %i3 4001df28: 34 80 00 28 bg,a 4001dfc8 <== NEVER TAKEN 4001df2c: 90 10 20 10 mov 0x10, %o0 <== NOT EXECUTED 4001df30: d0 06 60 1c ld [ %i1 + 0x1c ], %o0 4001df34: c4 02 00 00 ld [ %o0 ], %g2 4001df38: c2 02 20 04 ld [ %o0 + 4 ], %g1 next->previous = previous; 4001df3c: c2 20 a0 04 st %g1, [ %g2 + 4 ] free (handle->shared); 4001df40: 7f ff ad 35 call 40009414 4001df44: c4 20 40 00 st %g2, [ %g1 ] 4001df48: 92 10 00 1c mov %i4, %o1 4001df4c: 7f ff f8 a1 call 4001c1d0 4001df50: 90 10 00 18 mov %i0, %o0 handle->dirty = false; 4001df54: c0 2e 60 04 clrb [ %i1 + 4 ] if (rrc > 0) 4001df58: 80 a7 60 00 cmp %i5, 0 handle->bnum = 0; 4001df5c: c0 26 60 08 clr [ %i1 + 8 ] 4001df60: 04 bf ff ab ble 4001de0c <== ALWAYS TAKEN 4001df64: c0 26 60 0c clr [ %i1 + 0xc ] if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE)) 4001df68: 90 10 20 10 mov 0x10, %o0 <== NOT EXECUTED 4001df6c: 7f ff dc 32 call 40015034 <== NOT EXECUTED 4001df70: 92 10 20 00 clr %o1 <== NOT EXECUTED 4001df74: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001df78: 22 bf ff a6 be,a 4001de10 <== NOT EXECUTED 4001df7c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc)); 4001df80: 40 00 13 83 call 40022d8c <== NOT EXECUTED 4001df84: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 4001df88: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001df8c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED 4001df90: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED 4001df94: 7f ff dc b5 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001df98: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 400336c0 <== NOT EXECUTED free (handle); 4001df9c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED 4001dfa0: 7f ff ad 1d call 40009414 <== NOT EXECUTED 4001dfa4: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED } 4001dfa8: 81 c7 e0 08 ret <== NOT EXECUTED 4001dfac: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n", 4001dfb0: d2 00 60 14 ld [ %g1 + 0x14 ], %o1 <== NOT EXECUTED 4001dfb4: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED 4001dfb8: 7f ff dc ac call 40015268 <__wrap_printf> <== NOT EXECUTED 4001dfbc: 90 12 22 18 or %o0, 0x218, %o0 ! 40033618 <== NOT EXECUTED if (handle->shared->references > 0) 4001dfc0: 10 bf ff 86 b 4001ddd8 <== NOT EXECUTED 4001dfc4: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE)) 4001dfc8: 7f ff dc 1b call 40015034 <== NOT EXECUTED 4001dfcc: 92 10 20 00 clr %o1 <== NOT EXECUTED 4001dfd0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001dfd4: 32 80 00 23 bne,a 4001e060 <== NOT EXECUTED 4001dfd8: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED 4001dfdc: d0 06 60 1c ld [ %i1 + 0x1c ], %o0 <== NOT EXECUTED 4001dfe0: c4 02 00 00 ld [ %o0 ], %g2 <== NOT EXECUTED if (rrc == 0) 4001dfe4: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED 4001dfe8: 12 bf ff d5 bne 4001df3c <== NOT EXECUTED 4001dfec: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED 4001dff0: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED handle->buffer = NULL; 4001dff4: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED free (handle->shared); 4001dff8: 7f ff ad 07 call 40009414 <== NOT EXECUTED 4001dffc: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED rtems_rfs_buffer_handle_release (fs, handle); 4001e000: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED 4001e004: 7f ff f8 73 call 4001c1d0 <== NOT EXECUTED 4001e008: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED handle->dirty = false; 4001e00c: c0 2e 60 04 clrb [ %i1 + 4 ] <== NOT EXECUTED handle->bnum = 0; 4001e010: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED handle->buffer = NULL; 4001e014: 10 bf ff d5 b 4001df68 <== NOT EXECUTED 4001e018: c0 26 60 0c clr [ %i1 + 0xc ] <== NOT EXECUTED if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE)) 4001e01c: 7f ff dc 06 call 40015034 <== NOT EXECUTED 4001e020: 92 10 20 00 clr %o1 <== NOT EXECUTED 4001e024: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 4001e028: 32 80 00 19 bne,a 4001e08c <== NOT EXECUTED 4001e02c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED if (rrc == 0) 4001e030: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED 4001e034: 22 bf ff b8 be,a 4001df14 <== NOT EXECUTED 4001e038: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED rc = rtems_rfs_inode_close (fs, &handle->shared->inode); 4001e03c: 10 bf ff b7 b 4001df18 <== NOT EXECUTED 4001e040: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED rrc = rtems_rfs_inode_load (fs, &handle->shared->inode); 4001e044: 7f ff d5 9a call 400136ac 4001e048: 90 10 00 18 mov %i0, %o0 if (rrc == 0) 4001e04c: 80 a2 20 00 cmp %o0, 0 4001e050: 12 80 00 20 bne 4001e0d0 <== NEVER TAKEN 4001e054: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 4001e058: 10 bf ff 76 b 4001de30 4001e05c: c4 02 60 18 ld [ %o1 + 0x18 ], %g2 printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n", 4001e060: f4 00 60 14 ld [ %g1 + 0x14 ], %i2 <== NOT EXECUTED 4001e064: 40 00 13 4a call 40022d8c <== NOT EXECUTED 4001e068: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED 4001e06c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 4001e070: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001e074: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4001e078: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED 4001e07c: 7f ff dc 7b call 40015268 <__wrap_printf> <== NOT EXECUTED 4001e080: 90 12 22 80 or %o0, 0x280, %o0 ! 40033680 <== NOT EXECUTED 4001e084: 10 bf ff d7 b 4001dfe0 <== NOT EXECUTED 4001e088: d0 06 60 1c ld [ %i1 + 0x1c ], %o0 <== NOT EXECUTED printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n", 4001e08c: f4 00 60 14 ld [ %g1 + 0x14 ], %i2 <== NOT EXECUTED 4001e090: 40 00 13 3f call 40022d8c <== NOT EXECUTED 4001e094: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED 4001e098: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED 4001e09c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED 4001e0a0: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED 4001e0a4: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED 4001e0a8: 7f ff dc 70 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001e0ac: 90 12 22 40 or %o0, 0x240, %o0 ! 40033640 <== NOT EXECUTED if (rrc == 0) 4001e0b0: 10 bf ff e1 b 4001e034 <== NOT EXECUTED 4001e0b4: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED if (!rtems_rfs_block_size_equal (&handle->shared->size, 4001e0b8: c6 02 60 40 ld [ %o1 + 0x40 ], %g3 4001e0bc: 80 a0 80 03 cmp %g2, %g3 4001e0c0: 32 bf ff 8c bne,a 4001def0 <== NEVER TAKEN 4001e0c4: c2 22 60 3c st %g1, [ %o1 + 0x3c ] <== NOT EXECUTED 4001e0c8: 10 bf ff 8e b 4001df00 4001e0cc: 92 02 60 34 add %o1, 0x34, %o1 if (rrc == 0) 4001e0d0: 10 bf ff 8b b 4001defc <== NOT EXECUTED 4001e0d4: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED =============================================================================== 4001ea88 : return _Chain_Immutable_head( the_chain )->next; 4001ea88: c2 02 20 74 ld [ %o0 + 0x74 ], %g1 return &the_chain->Tail.Node; 4001ea8c: 90 02 20 78 add %o0, 0x78, %o0 while (!rtems_chain_is_tail (&fs->file_shares, node)) 4001ea90: 80 a0 40 08 cmp %g1, %o0 4001ea94: 22 80 00 10 be,a 4001ead4 4001ea98: 82 10 20 00 clr %g1 if (shared->inode.ino == ino) 4001ea9c: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 4001eaa0: 80 a2 40 02 cmp %o1, %g2 4001eaa4: 32 80 00 08 bne,a 4001eac4 <== NEVER TAKEN 4001eaa8: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED return shared; node = rtems_chain_next (node); } return NULL; } 4001eaac: 81 c3 e0 08 retl 4001eab0: 90 10 00 01 mov %g1, %o0 if (shared->inode.ino == ino) 4001eab4: 80 a0 80 09 cmp %g2, %o1 <== NOT EXECUTED 4001eab8: 22 80 00 08 be,a 4001ead8 <== NOT EXECUTED 4001eabc: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED 4001eac0: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED while (!rtems_chain_is_tail (&fs->file_shares, node)) 4001eac4: 80 a0 40 08 cmp %g1, %o0 <== NOT EXECUTED 4001eac8: 32 bf ff fb bne,a 4001eab4 <== NOT EXECUTED 4001eacc: c4 00 60 14 ld [ %g1 + 0x14 ], %g2 <== NOT EXECUTED return NULL; 4001ead0: 82 10 20 00 clr %g1 <== NOT EXECUTED } 4001ead4: 90 10 00 01 mov %g1, %o0 4001ead8: 81 c3 e0 08 retl 4001eadc: 01 00 00 00 nop =============================================================================== 4001e364 : { 4001e364: 9d e3 bf a0 save %sp, -96, %sp if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO)) 4001e368: 90 10 20 20 mov 0x20, %o0 4001e36c: 92 10 20 00 clr %o1 4001e370: 7f ff db 31 call 40015034 4001e374: ba 10 00 18 mov %i0, %i5 4001e378: 80 a2 20 00 cmp %o0, 0 4001e37c: 22 80 00 0c be,a 4001e3ac <== ALWAYS TAKEN 4001e380: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 printf ("rtems-rfs: file-io: end: %s size=%zu\n", 4001e384: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED 4001e388: 12 80 00 35 bne 4001e45c <== NOT EXECUTED 4001e38c: 13 10 00 ca sethi %hi(0x40032800), %o1 <== NOT EXECUTED 4001e390: 13 10 00 cd sethi %hi(0x40033400), %o1 <== NOT EXECUTED 4001e394: 92 12 62 e8 or %o1, 0x2e8, %o1 ! 400336e8 <== NOT EXECUTED 4001e398: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED 4001e39c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 4001e3a0: 7f ff db b2 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001e3a4: 90 12 23 a8 or %o0, 0x3a8, %o0 <== NOT EXECUTED 4001e3a8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED if (rtems_rfs_buffer_handle_has_block (&handle->buffer)) 4001e3ac: c4 07 60 0c ld [ %i5 + 0xc ], %g2 4001e3b0: 80 a0 a0 00 cmp %g2, 0 4001e3b4: 02 80 00 2c be 4001e464 <== NEVER TAKEN 4001e3b8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 if (!read) 4001e3bc: 80 a6 a0 00 cmp %i2, 0 4001e3c0: 02 80 00 14 be 4001e410 4001e3c4: 92 07 60 04 add %i5, 4, %o1 rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 4001e3c8: 7f ff f7 82 call 4001c1d0 4001e3cc: 01 00 00 00 nop if (rc > 0) 4001e3d0: b0 92 20 00 orcc %o0, 0, %i0 4001e3d4: 24 80 00 9b ble,a 4001e640 <== ALWAYS TAKEN 4001e3d8: c4 07 60 14 ld [ %i5 + 0x14 ], %g2 printf ( 4001e3dc: 40 00 12 6c call 40022d8c <== NOT EXECUTED 4001e3e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001e3e4: 3b 10 00 ca sethi %hi(0x40032800), %i5 <== NOT EXECUTED 4001e3e8: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED 4001e3ec: ba 17 62 00 or %i5, 0x200, %i5 <== NOT EXECUTED 4001e3f0: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED 4001e3f4: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 4001e3f8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001e3fc: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED 4001e400: 7f ff db 9a call 40015268 <__wrap_printf> <== NOT EXECUTED 4001e404: 90 12 23 d0 or %o0, 0x3d0, %o0 ! 400337d0 <== NOT EXECUTED return rc; 4001e408: 81 c7 e0 08 ret <== NOT EXECUTED 4001e40c: 81 e8 00 00 restore <== NOT EXECUTED rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle)); 4001e410: 82 10 20 01 mov 1, %g1 rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle), 4001e414: 7f ff f7 6f call 4001c1d0 4001e418: c2 2f 60 04 stb %g1, [ %i5 + 4 ] if (rc > 0) 4001e41c: b0 92 20 00 orcc %o0, 0, %i0 4001e420: 24 80 00 49 ble,a 4001e544 <== ALWAYS TAKEN 4001e424: c4 07 60 14 ld [ %i5 + 0x14 ], %g2 printf ( 4001e428: 40 00 12 59 call 40022d8c <== NOT EXECUTED 4001e42c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4001e430: 3b 10 00 cd sethi %hi(0x40033400), %i5 <== NOT EXECUTED 4001e434: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED 4001e438: ba 17 62 e8 or %i5, 0x2e8, %i5 <== NOT EXECUTED 4001e43c: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED 4001e440: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED 4001e444: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED 4001e448: 11 10 00 cd sethi %hi(0x40033400), %o0 <== NOT EXECUTED 4001e44c: 7f ff db 87 call 40015268 <__wrap_printf> <== NOT EXECUTED 4001e450: 90 12 23 d0 or %o0, 0x3d0, %o0 ! 400337d0 <== NOT EXECUTED return rc; 4001e454: 81 c7 e0 08 ret <== NOT EXECUTED 4001e458: 81 e8 00 00 restore <== NOT EXECUTED printf ("rtems-rfs: file-io: end: %s size=%zu\n", 4001e45c: 10 bf ff cf b 4001e398 <== NOT EXECUTED 4001e460: 92 12 62 00 or %o1, 0x200, %o1 <== NOT EXECUTED handle->bpos.boff += size; 4001e464: c4 07 60 14 ld [ %i5 + 0x14 ], %g2 <== NOT EXECUTED 4001e468: b2 06 40 02 add %i1, %g2, %i1 <== NOT EXECUTED 4001e46c: f2 27 60 14 st %i1, [ %i5 + 0x14 ] <== NOT EXECUTED 4001e470: 86 1e a0 01 xor %i2, 1, %g3 <== NOT EXECUTED rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) 4001e474: c4 02 20 08 ld [ %o0 + 8 ], %g2 <== NOT EXECUTED if (handle->bpos.boff >= 4001e478: 80 a6 40 02 cmp %i1, %g2 <== NOT EXECUTED 4001e47c: 1a 80 00 3a bcc 4001e564 <== NOT EXECUTED 4001e480: b0 10 20 00 clr %i0 <== NOT EXECUTED if (!read && 4001e484: 80 a6 a0 00 cmp %i2, 0 4001e488: 12 80 00 0e bne 4001e4c0 <== NEVER TAKEN 4001e48c: 84 10 20 00 clr %g2 rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle), 4001e490: f8 07 60 10 ld [ %i5 + 0x10 ], %i4 if (!read && 4001e494: 80 a7 20 00 cmp %i4, 0 4001e498: 02 80 00 39 be 4001e57c 4001e49c: c4 00 60 3c ld [ %g1 + 0x3c ], %g2 rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle), 4001e4a0: 80 a0 a0 00 cmp %g2, 0 4001e4a4: 12 80 00 37 bne 4001e580 <== ALWAYS TAKEN 4001e4a8: 80 a7 00 02 cmp %i4, %g2 4001e4ac: c8 07 60 14 ld [ %i5 + 0x14 ], %g4 <== NOT EXECUTED map->size.offset = offset; 4001e4b0: c8 20 60 40 st %g4, [ %g1 + 0x40 ] map->dirty = true; 4001e4b4: 88 10 20 01 mov 1, %g4 4001e4b8: c8 28 60 34 stb %g4, [ %g1 + 0x34 ] length = true; 4001e4bc: 84 10 20 01 mov 1, %g2 atime = rtems_rfs_file_update_atime (handle); 4001e4c0: e0 07 40 00 ld [ %i5 ], %l0 if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO)) 4001e4c4: 90 10 20 20 mov 0x20, %o0 4001e4c8: 92 10 20 00 clr %o1 atime = rtems_rfs_file_update_atime (handle); 4001e4cc: b2 38 00 10 xnor %g0, %l0, %i1 mtime = rtems_rfs_file_update_mtime (handle) && mtime; 4001e4d0: b9 34 20 01 srl %l0, 1, %i4 length = rtems_rfs_file_update_length (handle) && length; 4001e4d4: b7 34 20 02 srl %l0, 2, %i3 mtime = rtems_rfs_file_update_mtime (handle) && mtime; 4001e4d8: b8 1f 20 01 xor %i4, 1, %i4 length = rtems_rfs_file_update_length (handle) && length; 4001e4dc: b6 1e e0 01 xor %i3, 1, %i3 mtime = rtems_rfs_file_update_mtime (handle) && mtime; 4001e4e0: b8 0f 20 01 and %i4, 1, %i4 length = rtems_rfs_file_update_length (handle) && length; 4001e4e4: b6 0e e0 01 and %i3, 1, %i3 mtime = rtems_rfs_file_update_mtime (handle) && mtime; 4001e4e8: b8 0f 00 03 and %i4, %g3, %i4 length = rtems_rfs_file_update_length (handle) && length; 4001e4ec: b6 0e c0 02 and %i3, %g2, %i3 if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO)) 4001e4f0: 7f ff da d1 call 40015034 4001e4f4: b2 0e 60 01 and %i1, 1, %i1 4001e4f8: 80 a2 20 00 cmp %o0, 0 4001e4fc: 32 80 00 30 bne,a 4001e5bc <== NEVER TAKEN 4001e500: d4 07 60 14 ld [ %i5 + 0x14 ], %o2 <== NOT EXECUTED 4001e504: b8 0f 20 ff and %i4, 0xff, %i4 4001e508: b6 0e e0 ff and %i3, 0xff, %i3 if (atime || mtime) 4001e50c: b2 8e 60 ff andcc %i1, 0xff, %i1 4001e510: 12 80 00 3d bne 4001e604 <== ALWAYS TAKEN 4001e514: 80 a7 20 00 cmp %i4, 0 4001e518: 12 80 00 3b bne 4001e604 <== NOT EXECUTED 4001e51c: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED if (length) 4001e520: 02 80 00 25 be 4001e5b4 4001e524: 01 00 00 00 nop rtems_rfs_block_map_count (rtems_rfs_file_map (handle)); 4001e528: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 handle->shared->size.count = 4001e52c: c6 00 60 3c ld [ %g1 + 0x3c ], %g3 handle->shared->size.offset = 4001e530: c4 00 60 40 ld [ %g1 + 0x40 ], %g2 handle->shared->size.count = 4001e534: c6 20 60 84 st %g3, [ %g1 + 0x84 ] handle->shared->size.offset = 4001e538: c4 20 60 88 st %g2, [ %g1 + 0x88 ] 4001e53c: 81 c7 e0 08 ret 4001e540: 81 e8 00 00 restore rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) 4001e544: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 handle->bpos.boff += size; 4001e548: b2 06 40 02 add %i1, %g2, %i1 rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) 4001e54c: c4 00 60 98 ld [ %g1 + 0x98 ], %g2 handle->bpos.boff += size; 4001e550: f2 27 60 14 st %i1, [ %i5 + 0x14 ] rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) 4001e554: c4 00 a0 08 ld [ %g2 + 8 ], %g2 if (handle->bpos.boff >= 4001e558: 80 a0 80 19 cmp %g2, %i1 4001e55c: 18 bf ff cd bgu 4001e490 4001e560: 86 10 20 01 mov 1, %g3 handle->bpos.bno++; 4001e564: c8 07 60 10 ld [ %i5 + 0x10 ], %g4 4001e568: 88 01 20 01 inc %g4 handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)); 4001e56c: b2 26 40 02 sub %i1, %g2, %i1 handle->bpos.bno++; 4001e570: c8 27 60 10 st %g4, [ %i5 + 0x10 ] handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)); 4001e574: 10 bf ff c4 b 4001e484 4001e578: f2 27 60 14 st %i1, [ %i5 + 0x14 ] rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle), 4001e57c: 80 a7 00 02 cmp %i4, %g2 4001e580: 3a bf ff cc bcc,a 4001e4b0 4001e584: c8 07 60 14 ld [ %i5 + 0x14 ], %g4 4001e588: 88 00 bf ff add %g2, -1, %g4 4001e58c: 80 a7 00 04 cmp %i4, %g4 4001e590: 12 bf ff cc bne 4001e4c0 <== NEVER TAKEN 4001e594: 84 10 20 00 clr %g2 4001e598: c8 07 60 14 ld [ %i5 + 0x14 ], %g4 4001e59c: f8 00 60 40 ld [ %g1 + 0x40 ], %i4 4001e5a0: 80 a1 00 1c cmp %g4, %i4 4001e5a4: 28 bf ff c8 bleu,a 4001e4c4 <== NEVER TAKEN 4001e5a8: e0 07 40 00 ld [ %i5 ], %l0 <== NOT EXECUTED 4001e5ac: 10 bf ff c2 b 4001e4b4 4001e5b0: c8 20 60 40 st %g4, [ %g1 + 0x40 ] } 4001e5b4: 81 c7 e0 08 ret 4001e5b8: 81 e8 00 00 restore printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n", 4001e5bc: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED 4001e5c0: 96 0c 20 01 and %l0, 1, %o3 <== NOT EXECUTED 4001e5c4: b8 0f 20 ff and %i4, 0xff, %i4 <== NOT EXECUTED 4001e5c8: b6 0e e0 ff and %i3, 0xff, %i3 <== NOT EXECUTED 4001e5cc: 98 07 3f ff add %i4, -1, %o4 <== NOT EXECUTED 4001e5d0: 9a 06 ff ff add %i3, -1, %o5 <== NOT EXECUTED 4001e5d4: 96 20 00 0b neg %o3 <== NOT EXECUTED 4001e5d8: 98 0b 3f e0 and %o4, -32, %o4 <== NOT EXECUTED 4001e5dc: 96 0a ff ec and %o3, -20, %o3 <== NOT EXECUTED 4001e5e0: 98 03 20 4d add %o4, 0x4d, %o4 <== NOT EXECUTED 4001e5e4: 9a 0b 7f e1 and %o5, -31, %o5 <== NOT EXECUTED 4001e5e8: 96 02 e0 41 add %o3, 0x41, %o3 <== NOT EXECUTED 4001e5ec: 9a 03 60 4c add %o5, 0x4c, %o5 <== NOT EXECUTED 4001e5f0: 11 10 00 ce sethi %hi(0x40033800), %o0 <== NOT EXECUTED 4001e5f4: 7f ff db 1d call 40015268 <__wrap_printf> <== NOT EXECUTED 4001e5f8: 90 12 20 18 or %o0, 0x18, %o0 ! 40033818 <== NOT EXECUTED if (atime || mtime) 4001e5fc: 10 bf ff c5 b 4001e510 <== NOT EXECUTED 4001e600: b2 8e 60 ff andcc %i1, 0xff, %i1 <== NOT EXECUTED time_t now = time (NULL); 4001e604: 40 00 1e 01 call 40025e08